automatic import of python-aioprocessingopeneuler20.03

3 files changed, 228 insertions, 0 deletions

diff --git a/.gitignore b/.gitignore
index e69de29..824d291 100644
--- a/.gitignore
+++ b/.gitignore
@@ -0,0 +1 @@
+/aioprocessing-2.0.1.tar.gz
diff --git a/python-aioprocessing.spec b/python-aioprocessing.spec
new file mode 100644
index 0000000..56ff97e
--- /dev/null
+++ b/python-aioprocessing.spec
@@ -0,0 +1,226 @@
+%global _empty_manifest_terminate_build 0
+Name:		python-aioprocessing
+Version:	2.0.1
+Release:	1
+Summary:	A Python 3.5+ library that integrates the multiprocessing module with asyncio.
+License:	BSD License
+URL:		https://pypi.org/project/aioprocessing/
+Source0:	https://mirrors.nju.edu.cn/pypi/web/packages/4d/85/9a75151e7049bf144c01384279201d82d99484bd658f8e6fb013552d8724/aioprocessing-2.0.1.tar.gz
+BuildArch:	noarch
+
+Requires:	python3-multiprocess
+
+%description
+[![Build Status](https://github.com/dano/aioprocessing/workflows/aioprocessing%20tests/badge.svg?branch=master)](https://github.com/dano/aioprocessing/actions)
+`aioprocessing` provides asynchronous, [`asyncio`](https://docs.python.org/3/library/asyncio.html) compatible, coroutine 
+versions of many blocking instance methods on objects in the [`multiprocessing`](https://docs.python.org/3/library/multiprocessing.html) 
+library. To use [`dill`](https://pypi.org/project/dill) for universal pickling, install using `pip install aioprocessing[dill]`. Here's an example demonstrating the `aioprocessing` versions of 
+`Event`, `Queue`, and `Lock`:
+```python
+import time
+import asyncio
+import aioprocessing
+def func(queue, event, lock, items):
+    """ Demo worker function.
+    This worker function runs in its own process, and uses
+    normal blocking calls to aioprocessing objects, exactly 
+    the way you would use oridinary multiprocessing objects.
+    """
+    with lock:
+        event.set()
+        for item in items:
+            time.sleep(3)
+            queue.put(item+5)
+    queue.close()
+async def example(queue, event, lock):
+    l = [1,2,3,4,5]
+    p = aioprocessing.AioProcess(target=func, args=(queue, event, lock, l))
+    p.start()
+    while True:
+        result = await queue.coro_get()
+        if result is None:
+            break
+        print("Got result {}".format(result))
+    await p.coro_join()
+async def example2(queue, event, lock):
+    await event.coro_wait()
+    async with lock:
+        await queue.coro_put(78)
+        await queue.coro_put(None) # Shut down the worker
+if __name__ == "__main__":
+    loop = asyncio.get_event_loop()
+    queue = aioprocessing.AioQueue()
+    lock = aioprocessing.AioLock()
+    event = aioprocessing.AioEvent()
+    tasks = [
+        asyncio.ensure_future(example(queue, event, lock)), 
+        asyncio.ensure_future(example2(queue, event, lock)),
+    ]
+    loop.run_until_complete(asyncio.wait(tasks))
+    loop.close()
+```
+The aioprocessing objects can be used just like their multiprocessing
+equivalents - as they are in `func` above - but they can also be 
+seamlessly used inside of `asyncio` coroutines, without ever blocking
+the event loop.
+
+%package -n python3-aioprocessing
+Summary:	A Python 3.5+ library that integrates the multiprocessing module with asyncio.
+Provides:	python-aioprocessing
+BuildRequires:	python3-devel
+BuildRequires:	python3-setuptools
+BuildRequires:	python3-pip
+%description -n python3-aioprocessing
+[![Build Status](https://github.com/dano/aioprocessing/workflows/aioprocessing%20tests/badge.svg?branch=master)](https://github.com/dano/aioprocessing/actions)
+`aioprocessing` provides asynchronous, [`asyncio`](https://docs.python.org/3/library/asyncio.html) compatible, coroutine 
+versions of many blocking instance methods on objects in the [`multiprocessing`](https://docs.python.org/3/library/multiprocessing.html) 
+library. To use [`dill`](https://pypi.org/project/dill) for universal pickling, install using `pip install aioprocessing[dill]`. Here's an example demonstrating the `aioprocessing` versions of 
+`Event`, `Queue`, and `Lock`:
+```python
+import time
+import asyncio
+import aioprocessing
+def func(queue, event, lock, items):
+    """ Demo worker function.
+    This worker function runs in its own process, and uses
+    normal blocking calls to aioprocessing objects, exactly 
+    the way you would use oridinary multiprocessing objects.
+    """
+    with lock:
+        event.set()
+        for item in items:
+            time.sleep(3)
+            queue.put(item+5)
+    queue.close()
+async def example(queue, event, lock):
+    l = [1,2,3,4,5]
+    p = aioprocessing.AioProcess(target=func, args=(queue, event, lock, l))
+    p.start()
+    while True:
+        result = await queue.coro_get()
+        if result is None:
+            break
+        print("Got result {}".format(result))
+    await p.coro_join()
+async def example2(queue, event, lock):
+    await event.coro_wait()
+    async with lock:
+        await queue.coro_put(78)
+        await queue.coro_put(None) # Shut down the worker
+if __name__ == "__main__":
+    loop = asyncio.get_event_loop()
+    queue = aioprocessing.AioQueue()
+    lock = aioprocessing.AioLock()
+    event = aioprocessing.AioEvent()
+    tasks = [
+        asyncio.ensure_future(example(queue, event, lock)), 
+        asyncio.ensure_future(example2(queue, event, lock)),
+    ]
+    loop.run_until_complete(asyncio.wait(tasks))
+    loop.close()
+```
+The aioprocessing objects can be used just like their multiprocessing
+equivalents - as they are in `func` above - but they can also be 
+seamlessly used inside of `asyncio` coroutines, without ever blocking
+the event loop.
+
+%package help
+Summary:	Development documents and examples for aioprocessing
+Provides:	python3-aioprocessing-doc
+%description help
+[![Build Status](https://github.com/dano/aioprocessing/workflows/aioprocessing%20tests/badge.svg?branch=master)](https://github.com/dano/aioprocessing/actions)
+`aioprocessing` provides asynchronous, [`asyncio`](https://docs.python.org/3/library/asyncio.html) compatible, coroutine 
+versions of many blocking instance methods on objects in the [`multiprocessing`](https://docs.python.org/3/library/multiprocessing.html) 
+library. To use [`dill`](https://pypi.org/project/dill) for universal pickling, install using `pip install aioprocessing[dill]`. Here's an example demonstrating the `aioprocessing` versions of 
+`Event`, `Queue`, and `Lock`:
+```python
+import time
+import asyncio
+import aioprocessing
+def func(queue, event, lock, items):
+    """ Demo worker function.
+    This worker function runs in its own process, and uses
+    normal blocking calls to aioprocessing objects, exactly 
+    the way you would use oridinary multiprocessing objects.
+    """
+    with lock:
+        event.set()
+        for item in items:
+            time.sleep(3)
+            queue.put(item+5)
+    queue.close()
+async def example(queue, event, lock):
+    l = [1,2,3,4,5]
+    p = aioprocessing.AioProcess(target=func, args=(queue, event, lock, l))
+    p.start()
+    while True:
+        result = await queue.coro_get()
+        if result is None:
+            break
+        print("Got result {}".format(result))
+    await p.coro_join()
+async def example2(queue, event, lock):
+    await event.coro_wait()
+    async with lock:
+        await queue.coro_put(78)
+        await queue.coro_put(None) # Shut down the worker
+if __name__ == "__main__":
+    loop = asyncio.get_event_loop()
+    queue = aioprocessing.AioQueue()
+    lock = aioprocessing.AioLock()
+    event = aioprocessing.AioEvent()
+    tasks = [
+        asyncio.ensure_future(example(queue, event, lock)), 
+        asyncio.ensure_future(example2(queue, event, lock)),
+    ]
+    loop.run_until_complete(asyncio.wait(tasks))
+    loop.close()
+```
+The aioprocessing objects can be used just like their multiprocessing
+equivalents - as they are in `func` above - but they can also be 
+seamlessly used inside of `asyncio` coroutines, without ever blocking
+the event loop.
+
+%prep
+%autosetup -n aioprocessing-2.0.1
+
+%build
+%py3_build
+
+%install
+%py3_install
+install -d -m755 %{buildroot}/%{_pkgdocdir}
+if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi
+if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi
+if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi
+if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi
+pushd %{buildroot}
+if [ -d usr/lib ]; then
+	find usr/lib -type f -printf "/%h/%f\n" >> filelist.lst
+fi
+if [ -d usr/lib64 ]; then
+	find usr/lib64 -type f -printf "/%h/%f\n" >> filelist.lst
+fi
+if [ -d usr/bin ]; then
+	find usr/bin -type f -printf "/%h/%f\n" >> filelist.lst
+fi
+if [ -d usr/sbin ]; then
+	find usr/sbin -type f -printf "/%h/%f\n" >> filelist.lst
+fi
+touch doclist.lst
+if [ -d usr/share/man ]; then
+	find usr/share/man -type f -printf "/%h/%f.gz\n" >> doclist.lst
+fi
+popd
+mv %{buildroot}/filelist.lst .
+mv %{buildroot}/doclist.lst .
+
+%files -n python3-aioprocessing -f filelist.lst
+%dir %{python3_sitelib}/*
+
+%files help -f doclist.lst
+%{_docdir}/*
+
+%changelog
+* Fri May 05 2023 Python_Bot <Python_Bot@openeuler.org> - 2.0.1-1
+- Package Spec generated
diff --git a/sources b/sources
new file mode 100644
index 0000000..e0e9b90
--- /dev/null
+++ b/sources
@@ -0,0 +1 @@
+e533c65f5879374c27f266c2040405ea  aioprocessing-2.0.1.tar.gz