goroutine-py 1.0.8__tar.gz → 2.0__tar.gz

goroutine_py-2.0/PKG-INFO

@@ -0,0 +1,116 @@
+Metadata-Version: 2.4
+Name: goroutine-py
+Version: 2.0
+Summary: An Asyncio-based concurrency library for Python.
+Author-email: xudesoft <xudesoft@126.com>
+Project-URL: Homepage, https://github.com/purplegrapeZz/goroutine-py
+Project-URL: Issues, https://github.com/purplegrapeZz/goroutine-py/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+English | 中文
+
+goroutine-py
+
+🚀 An Asyncio-based concurrency library for Python.
+
+	Easy concurrency just like goroutine without worry about thread and coroutine in Python.
+
+
+
+Introduction
+
+Withing  goroutine.app.go you can run a coroutine or a func asynchronously.
+
+Main function go :
+
+go (obj: callable, *args, callback: callable = None, lock: bool = False)
+
+	obj: Takes both callable coroutinefunction and func as object.
+
+	*args: Arguments for your obj.
+
+	callback: Attaches a callable that will be called when the future finishes.
+
+
+
+Getting Started
+
+Support:
+
+    Python 3.7 / 3.8 / 3.9 / 3.10 / 3.11 / 3.12
+
+Installation
+
+First you have to install goroutine-py like this:
+
+    pip install goroutine-py
+
+Quick Tutorial
+
+The primary entity of goroutine-py is goroutine.app.go.
+
+You can simply start using goroutine-py like this:
+
+First, define your tasks:
+
+    import asyncio
+    import time
+    from goroutine.app import go
+    
+    # A normal func
+    def task_1(n=2):
+        time.sleep(n)
+        print('Task_1_done')
+        return 'Result_1'
+
+    # A coroutinefunction
+    async def task_2(n=1):
+        await asyncio.sleep(n)
+        print('Task_2_done')
+        return 'Result_2'
+
+    # Callback func
+    def callback(result):
+        '''
+        Parameter "result" is the return from task.
+        Use functools.partial() to give arguments if you need more args at the beginning.
+        '''
+        print('-* callback *-')
+        print(result)
+
+After you defined all your tasks and callback, you can go like this:
+
+    go(task_1)
+    go(task_2)
+    
+    # The "callback" parameter must be specified separately.
+    go(task_1, 5, callback = callback)
+    go(task_2, 3, callback = callback)
+    print('END')
+    
+    # Forever runing to show results.
+    while 1:
+        time.sleep(5)
+
+Output :
+
+    >>>
+    END
+    Task_2_done
+    Task_1_done
+    Task_2_done
+    -* callback *-
+    Result_2
+    Task_1_done
+    -* callback *-
+    Result_1
+
+License
+
+This project is licensed under the MIT License - see the LICENSE file for details.

goroutine_py-2.0/README.md

@@ -0,0 +1,101 @@
+English | 中文
+
+goroutine-py
+
+🚀 An Asyncio-based concurrency library for Python.
+
+	Easy concurrency just like goroutine without worry about thread and coroutine in Python.
+
+
+
+Introduction
+
+Withing  goroutine.app.go you can run a coroutine or a func asynchronously.
+
+Main function go :
+
+go (obj: callable, *args, callback: callable = None, lock: bool = False)
+
+	obj: Takes both callable coroutinefunction and func as object.
+
+	*args: Arguments for your obj.
+
+	callback: Attaches a callable that will be called when the future finishes.
+
+
+
+Getting Started
+
+Support:
+
+    Python 3.7 / 3.8 / 3.9 / 3.10 / 3.11 / 3.12
+
+Installation
+
+First you have to install goroutine-py like this:
+
+    pip install goroutine-py
+
+Quick Tutorial
+
+The primary entity of goroutine-py is goroutine.app.go.
+
+You can simply start using goroutine-py like this:
+
+First, define your tasks:
+
+    import asyncio
+    import time
+    from goroutine.app import go
+    
+    # A normal func
+    def task_1(n=2):
+        time.sleep(n)
+        print('Task_1_done')
+        return 'Result_1'
+
+    # A coroutinefunction
+    async def task_2(n=1):
+        await asyncio.sleep(n)
+        print('Task_2_done')
+        return 'Result_2'
+
+    # Callback func
+    def callback(result):
+        '''
+        Parameter "result" is the return from task.
+        Use functools.partial() to give arguments if you need more args at the beginning.
+        '''
+        print('-* callback *-')
+        print(result)
+
+After you defined all your tasks and callback, you can go like this:
+
+    go(task_1)
+    go(task_2)
+    
+    # The "callback" parameter must be specified separately.
+    go(task_1, 5, callback = callback)
+    go(task_2, 3, callback = callback)
+    print('END')
+    
+    # Forever runing to show results.
+    while 1:
+        time.sleep(5)
+
+Output :
+
+    >>>
+    END
+    Task_2_done
+    Task_1_done
+    Task_2_done
+    -* callback *-
+    Result_2
+    Task_1_done
+    -* callback *-
+    Result_1
+
+License
+
+This project is licensed under the MIT License - see the LICENSE file for details.

goroutine_py-2.0/goroutine/app.py

@@ -0,0 +1,97 @@
+# Copyright 2022 ZIHAN MA. All Rights Reserved.
+
+'''
+🚀 An Asyncio-based concurrency library for Python.
+   Easy concurrency in Python. Just like goroutine.
+'''
+
+__author__ = 'ZIHAN MA (xudesoft@126.com)'
+
+
+from concurrent.futures import ThreadPoolExecutor
+import asyncio
+from threading import Thread
+from typing import Any
+
+
+Executor = ThreadPoolExecutor(max_workers=8)
+
+
+def _run() -> None:
+    '''
+    Start loop.
+    '''
+    _goroutine_loop.run_forever()
+
+
+def _iscor(obj: callable) -> bool:
+    '''
+    Check if obj a coroutinefunction.
+    Return:
+        True or Fale.
+    '''
+    return asyncio.iscoroutinefunction(obj)
+
+
+async def _wrap_cor(_cor, *args, callback = None) -> None:
+    '''
+    Handle the obj.
+    And will put this wrapper to the loop.
+    Return:
+        None.
+    '''
+    res = await _cor
+
+    # Handle the callback func from user.
+    if callable(callback):
+        if _iscor(callback):
+            await callback(res) if res else callback()
+        else:
+            await _wrap_func(callback, res) if res else _wrap_func(callback)
+
+
+async def _wrap_func(func: callable, *args) -> Any:
+    '''
+    For normal func, run as a thread.
+    Return:
+        Result of func.
+    '''
+    res = await asyncio.to_thread(func, *args)
+    return res
+
+
+def go(obj: callable, *args, callback: callable = None) -> None:
+    '''
+    Run a coroutine or a func asynchronously.
+    Easy concurrency in Python.
+    Args:
+        obj: Takes both callable coroutinefunction and func as object.
+             Coroutinefunction runs as coroutine.
+             Normal function runs as thread.
+        *args: Arguments for your obj.
+               You can also use functools.partial() for your func.
+        callback: Attaches a callable that will be called when the cor finishes.
+    Return:
+        None
+    '''
+    if callable(obj):
+        # Check if the given obeject callable.
+        if _iscor(obj):
+            # If a coroutinefunction run this.
+            future = asyncio.run_coroutine_threadsafe(_wrap_cor(obj(*args), callback=callback),  _goroutine_loop)
+        else:
+            # If normal func, runs as a thread.
+            # future = asyncio.run_coroutine_threadsafe(_wrap_cor(_wrap_func(obj, *args), callback=callback), _goroutine_loop)
+            Executor.submit(obj, *args)
+    else:
+        raise TypeError(
+            'A callable func or coroutinefunction object is required')
+
+
+# Getting loop.
+_goroutine_loop = asyncio.new_event_loop()
+
+# Run the loop in a thread.
+# T = Thread(target=_run, daemon=True)
+# T.start()
+Executor.submit(_run)

goroutine_py-2.0/goroutine_py.egg-info/PKG-INFO

@@ -0,0 +1,116 @@
+Metadata-Version: 2.4
+Name: goroutine-py
+Version: 2.0
+Summary: An Asyncio-based concurrency library for Python.
+Author-email: xudesoft <xudesoft@126.com>
+Project-URL: Homepage, https://github.com/purplegrapeZz/goroutine-py
+Project-URL: Issues, https://github.com/purplegrapeZz/goroutine-py/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+English | 中文
+
+goroutine-py
+
+🚀 An Asyncio-based concurrency library for Python.
+
+	Easy concurrency just like goroutine without worry about thread and coroutine in Python.
+
+
+
+Introduction
+
+Withing  goroutine.app.go you can run a coroutine or a func asynchronously.
+
+Main function go :
+
+go (obj: callable, *args, callback: callable = None, lock: bool = False)
+
+	obj: Takes both callable coroutinefunction and func as object.
+
+	*args: Arguments for your obj.
+
+	callback: Attaches a callable that will be called when the future finishes.
+
+
+
+Getting Started
+
+Support:
+
+    Python 3.7 / 3.8 / 3.9 / 3.10 / 3.11 / 3.12
+
+Installation
+
+First you have to install goroutine-py like this:
+
+    pip install goroutine-py
+
+Quick Tutorial
+
+The primary entity of goroutine-py is goroutine.app.go.
+
+You can simply start using goroutine-py like this:
+
+First, define your tasks:
+
+    import asyncio
+    import time
+    from goroutine.app import go
+    
+    # A normal func
+    def task_1(n=2):
+        time.sleep(n)
+        print('Task_1_done')
+        return 'Result_1'
+
+    # A coroutinefunction
+    async def task_2(n=1):
+        await asyncio.sleep(n)
+        print('Task_2_done')
+        return 'Result_2'
+
+    # Callback func
+    def callback(result):
+        '''
+        Parameter "result" is the return from task.
+        Use functools.partial() to give arguments if you need more args at the beginning.
+        '''
+        print('-* callback *-')
+        print(result)
+
+After you defined all your tasks and callback, you can go like this:
+
+    go(task_1)
+    go(task_2)
+    
+    # The "callback" parameter must be specified separately.
+    go(task_1, 5, callback = callback)
+    go(task_2, 3, callback = callback)
+    print('END')
+    
+    # Forever runing to show results.
+    while 1:
+        time.sleep(5)
+
+Output :
+
+    >>>
+    END
+    Task_2_done
+    Task_1_done
+    Task_2_done
+    -* callback *-
+    Result_2
+    Task_1_done
+    -* callback *-
+    Result_1
+
+License
+
+This project is licensed under the MIT License - see the LICENSE file for details.

{goroutine_py-1.0.8 → goroutine_py-2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "goroutine-py"
-version = "1.0.8"
+version = "2.0"
 authors = [
   { name="xudesoft", email="xudesoft@126.com" },
 ]

goroutine_py-1.0.8/PKG-INFO

@@ -1,119 +0,0 @@
-Metadata-Version: 2.1
-Name: goroutine-py
-Version: 1.0.8
-Summary: An Asyncio-based concurrency library for Python.
-Author-email: xudesoft <xudesoft@126.com>
-Project-URL: Homepage, https://github.com/purplegrapeZz/goroutine-py
-Project-URL: Issues, https://github.com/purplegrapeZz/goroutine-py/issues
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-License-File: LICENSE
-
-English | [中文](https://github.com/purplegrapeZz/goroutine-py/blob/master/README-CN.md)
-
-### goroutine-py
-
-🚀 An Asyncio-based concurrency library for Python.
-
-​	Easy concurrency just like goroutine without worry about thread and coroutine in Python.
-
-
-
-# Introduction
-
-Withing  ``goroutine.app.go`` you can run a coroutine or a func asynchronously.
-
-Main function ___go___ :
-
-#####  go _(obj: callable, *args, callback: callable = None, lock: bool = False)_
-
-​	___obj:___ Takes both callable coroutinefunction and func as object.
-
-​	___*args:___ Arguments for your obj.
-
-​	___callback:___ Attaches a callable that will be called when the future finishes.
-
-​	___lock:___ Thread safe if True. It can slow your program.
-
-​		 This argument only work for "func" not "coroutinefunction".
-
-# Getting Started
-## Support:
-
-	Python 3.7 / 3.8 / 3.9 / 3.10 / 3.11 / 3.12
-
-## Installation
-
-First you have to install goroutine-py like this:
-
-```
-pip install goroutine-py
-```
-
-## Quick Tutorial
-
-The primary entity of goroutine-py is ``goroutine.app.go``.
-You can simply start using goroutine-py like this:
-
-First, define your tasks:
-
-```
-import asyncio
-import functools
-import time
-from goroutine.app import go
-
-# A normal func
-def task_1(n=2):
-    time.sleep(n)
-    print('Task_1_done')
-    return 'Result_1'
-```
-
-```
-# A coroutinefunction
-async def task_2(n=1):
-    await asyncio.sleep(n)
-    print('Task_2_done')
-    return 'Result_2'
-```
-
-```
-# Callback func
-def callback(future, arg=None):
-    '''
-    At least ONE Parameter "future" is required.
-    This future is a concurrent.futures.Future.
-    Use functools.partial() to give arguments for your callback func.
-    '''
-    print(future.result(),arg)
-```
-After you defined all your tasks and callback, you can go like this:
-
-```
-go(task_1)
-go(task_2)
-go(task_1, 4, callback=callback)
-go(task_2, 2, callback=functools.partial(callback,arg='a'))
-print('END')
-```
-
-Output :
-
-```
->>>
-END
-Task_2_done
-Task_1_done
-Task_2_done
-Result_2 a
-Task_1_done
-Result_1 None
-```
-
-# License
-
-This project is licensed under the MIT License - see the `LICENSE` file for details.

goroutine_py-1.0.8/README.md

@@ -1,105 +0,0 @@
-English | [中文](https://github.com/purplegrapeZz/goroutine-py/blob/master/README-CN.md)
-
-### goroutine-py
-
-🚀 An Asyncio-based concurrency library for Python.
-
-​	Easy concurrency just like goroutine without worry about thread and coroutine in Python.
-
-
-
-# Introduction
-
-Withing  ``goroutine.app.go`` you can run a coroutine or a func asynchronously.
-
-Main function ___go___ :
-
-#####  go _(obj: callable, *args, callback: callable = None, lock: bool = False)_
-
-​	___obj:___ Takes both callable coroutinefunction and func as object.
-
-​	___*args:___ Arguments for your obj.
-
-​	___callback:___ Attaches a callable that will be called when the future finishes.
-
-​	___lock:___ Thread safe if True. It can slow your program.
-
-​		 This argument only work for "func" not "coroutinefunction".
-
-# Getting Started
-## Support:
-
-	Python 3.7 / 3.8 / 3.9 / 3.10 / 3.11 / 3.12
-
-## Installation
-
-First you have to install goroutine-py like this:
-
-```
-pip install goroutine-py
-```
-
-## Quick Tutorial
-
-The primary entity of goroutine-py is ``goroutine.app.go``.
-You can simply start using goroutine-py like this:
-
-First, define your tasks:
-
-```
-import asyncio
-import functools
-import time
-from goroutine.app import go
-
-# A normal func
-def task_1(n=2):
-    time.sleep(n)
-    print('Task_1_done')
-    return 'Result_1'
-```
-
-```
-# A coroutinefunction
-async def task_2(n=1):
-    await asyncio.sleep(n)
-    print('Task_2_done')
-    return 'Result_2'
-```
-
-```
-# Callback func
-def callback(future, arg=None):
-    '''
-    At least ONE Parameter "future" is required.
-    This future is a concurrent.futures.Future.
-    Use functools.partial() to give arguments for your callback func.
-    '''
-    print(future.result(),arg)
-```
-After you defined all your tasks and callback, you can go like this:
-
-```
-go(task_1)
-go(task_2)
-go(task_1, 4, callback=callback)
-go(task_2, 2, callback=functools.partial(callback,arg='a'))
-print('END')
-```
-
-Output :
-
-```
->>>
-END
-Task_2_done
-Task_1_done
-Task_2_done
-Result_2 a
-Task_1_done
-Result_1 None
-```
-
-# License
-
-This project is licensed under the MIT License - see the `LICENSE` file for details.

goroutine_py-1.0.8/goroutine/app.py

@@ -1,128 +0,0 @@
-# Copyright 2022 ZIHAN MA. All Rights Reserved.
-
-'''
-🚀 An Asyncio-based concurrency library for Python.
-   Easy concurrency in Python. Just like goroutine.
-'''
-
-__author__ = 'ZIHAN MA (xudesoft@126.com)'
-
-import asyncio
-from threading import Thread
-import functools
-from asyncio.futures import Future
-
-
-def _run() -> None:
-    '''
-    Start loop.
-    '''
-    _goroutine_loop.run_forever()
-
-
-def _iscorfunc(obj: callable) -> bool:
-    '''
-    Check if obj a coroutinefunction.
-    Return:
-        True or Fale.
-    '''
-    return asyncio.iscoroutinefunction(obj)
-
-
-async def _wrap_as_cor(obj: callable, *args) -> Future:
-    '''
-    Wrap a func as a coroutine.
-    Return:
-        A coroutine.
-    '''
-    res = await asyncio.to_thread(obj, *args)
-    return res
-
-
-async def _wrap_as_cor_withlock(obj: callable, *args) -> Future:
-    '''
-    Wrap a func as a coroutine with lock. Means thread safe.
-    Return:
-        A coroutine.
-    '''
-    async with _goroutine_loop_lock:
-        res = await asyncio.to_thread(obj, *args)
-        return res
-
-
-def _wrap_as_func(obj: callable, future: Future) -> None:
-    '''
-    For callback func is given as a coroutine.
-    '''
-    asyncio.run_coroutine_threadsafe(obj(future), _goroutine_loop)
-
-
-def _finish(future: Future, callback: callable) -> None:
-    '''
-    Do the callback.
-    '''
-    if callable(callback):
-        if not _iscorfunc(callback):
-            # Check if callback a func.
-            future.add_done_callback(callback)
-        else:
-            future.add_done_callback(
-                functools.partial(
-                    _wrap_as_func, callback))
-    else:
-        raise TypeError(
-            'A callable func or coroutinefunction object is required for callback.')
-
-
-def go(obj: callable, *args, callback: callable = None, lock: bool = False) -> None:
-    '''
-    Run a coroutine or a func asynchronously.
-    Easy concurrency in Python.
-    Args:
-        obj: Takes both callable coroutinefunction and func as object.
-             Coroutinefunction runs as coroutine.
-             Normal function runs as thread.
-        *args: Arguments for your obj.
-               You can also use functools.partial() for your func.
-        callback: Attaches a callable that will be called when the future finishes.
-                  Use functools.partial() to your callback func.
-        lock: Thread safe if True. It can slow your program.
-              This argument only work for "func" not "coroutinefunction".
-    Return:
-        None
-    '''
-    if callable(obj):
-        '''
-        Check if the given obeject callable.
-        '''
-        if _iscorfunc(obj):
-            # If a coroutinefunction run this.
-            future = asyncio.run_coroutine_threadsafe(obj(*args), _goroutine_loop)
-            if callback:
-                # Add callback func.
-                _finish(future, callback)
-        else:
-            # Normal func runs as a thread.
-            if lock:
-                # Thread safe. Only for a normal func.
-                cor = _wrap_as_cor_withlock(obj, *args)
-            else:
-                # Thread without lock.
-                cor = _wrap_as_cor(obj, *args)
-            future = asyncio.run_coroutine_threadsafe(cor, _goroutine_loop)
-            if callback:
-                _finish(future, callback)
-    else:
-        raise TypeError(
-            'A callable func or coroutinefunction object is required')
-
-
-# An asyncio-lock.
-_goroutine_loop_lock = asyncio.Lock()
-
-# Getting loop.
-_goroutine_loop = asyncio.new_event_loop()
-
-# Run the loop in a thread.
-T = Thread(target=_run, daemon=True)
-T.start()

goroutine_py-1.0.8/goroutine_py.egg-info/PKG-INFO

@@ -1,119 +0,0 @@
-Metadata-Version: 2.1
-Name: goroutine-py
-Version: 1.0.8
-Summary: An Asyncio-based concurrency library for Python.
-Author-email: xudesoft <xudesoft@126.com>
-Project-URL: Homepage, https://github.com/purplegrapeZz/goroutine-py
-Project-URL: Issues, https://github.com/purplegrapeZz/goroutine-py/issues
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-License-File: LICENSE
-
-English | [中文](https://github.com/purplegrapeZz/goroutine-py/blob/master/README-CN.md)
-
-### goroutine-py
-
-🚀 An Asyncio-based concurrency library for Python.
-
-​	Easy concurrency just like goroutine without worry about thread and coroutine in Python.
-
-
-
-# Introduction
-
-Withing  ``goroutine.app.go`` you can run a coroutine or a func asynchronously.
-
-Main function ___go___ :
-
-#####  go _(obj: callable, *args, callback: callable = None, lock: bool = False)_
-
-​	___obj:___ Takes both callable coroutinefunction and func as object.
-
-​	___*args:___ Arguments for your obj.
-
-​	___callback:___ Attaches a callable that will be called when the future finishes.
-
-​	___lock:___ Thread safe if True. It can slow your program.
-
-​		 This argument only work for "func" not "coroutinefunction".
-
-# Getting Started
-## Support:
-
-	Python 3.7 / 3.8 / 3.9 / 3.10 / 3.11 / 3.12
-
-## Installation
-
-First you have to install goroutine-py like this:
-
-```
-pip install goroutine-py
-```
-
-## Quick Tutorial
-
-The primary entity of goroutine-py is ``goroutine.app.go``.
-You can simply start using goroutine-py like this:
-
-First, define your tasks:
-
-```
-import asyncio
-import functools
-import time
-from goroutine.app import go
-
-# A normal func
-def task_1(n=2):
-    time.sleep(n)
-    print('Task_1_done')
-    return 'Result_1'
-```
-
-```
-# A coroutinefunction
-async def task_2(n=1):
-    await asyncio.sleep(n)
-    print('Task_2_done')
-    return 'Result_2'
-```
-
-```
-# Callback func
-def callback(future, arg=None):
-    '''
-    At least ONE Parameter "future" is required.
-    This future is a concurrent.futures.Future.
-    Use functools.partial() to give arguments for your callback func.
-    '''
-    print(future.result(),arg)
-```
-After you defined all your tasks and callback, you can go like this:
-
-```
-go(task_1)
-go(task_2)
-go(task_1, 4, callback=callback)
-go(task_2, 2, callback=functools.partial(callback,arg='a'))
-print('END')
-```
-
-Output :
-
-```
->>>
-END
-Task_2_done
-Task_1_done
-Task_2_done
-Result_2 a
-Task_1_done
-Result_1 None
-```
-
-# License
-
-This project is licensed under the MIT License - see the `LICENSE` file for details.