Add asynctools.sync (#46)

* added asynctools.sync

* added unittest for argument TypeError case in asynctools.make_awaitable

Author: ArtyomKozyrev8

asyncstdlib/__init__.py

@@ -33,7 +33,7 @@
     zip_longest,
     groupby,
 )
-from .asynctools import borrow, scoped_iter, await_each, apply
+from .asynctools import borrow, scoped_iter, await_each, apply, sync
 
 __version__ = "3.9.2"
 
@@ -82,4 +82,5 @@
     "scoped_iter",
     "await_each",
     "apply",
+    "sync",
 ]

asyncstdlib/asynctools.py

@@ -1,3 +1,5 @@
+from asyncio import iscoroutinefunction
+from functools import wraps
 from typing import (
     Union,
     AsyncIterator,
@@ -324,3 +326,46 @@ async def compute_something_else() -> float:
     return __func(
         *[await arg for arg in args], **{k: await arg for k, arg in kwargs.items()}
     )
+
+
+def sync(function: Callable[..., T]) -> Callable[..., Awaitable[T]]:
+    """
+    Wraps any Callable, which allows to use it as Awaitable object
+
+    :param function - can be any Callable
+
+    :raise TypeError if function argument is not Callable
+
+    Example:
+
+    .. code-block:: python3
+
+        import asyncstdlib as a
+
+        def test1_sync(x, y):
+            ...
+
+        async def test1_async(x):
+            ...
+
+        async def main():
+            await a.sync(test1_sync)(x=1, y=2)
+            await a.sync(test1_async)(x=8)
+            await a.sync(lambda x: x ** 3)(x=5)
+
+        if __name__ == "__main__":
+            asyncio.run(main())
+    """
+    if not isinstance(function, Callable):
+        raise TypeError("function argument should be Callable")
+
+    if iscoroutinefunction(function):
+        return function
+
+    @wraps(function)
+    async def async_wrapped(*args, **kwargs):
+        result = function(*args, **kwargs)
+
+        return result
+
+    return async_wrapped

docs/source/api/asynctools.rst

@@ -23,6 +23,8 @@ Iterator lifetime
 Async transforming
 ==================
 
+.. autofunction:: sync(function: Callable[..., T]) -> Callable[..., Awaitable[T]]
+
 .. autofunction:: await_each(awaitables: iter await T)
     :async-for: :T
 

unittests/test_asynctools.py

@@ -201,3 +201,23 @@ async def compute_something_else() -> int:
     )
 
     assert result == 42 - 1984
+
+
+@sync
+async def test_sync():
+    def check_3(x: int) -> int:
+        return x + 10
+
+    async def check_4(x: int, y: int, z: int) -> int:
+        return x + y + z + 100
+
+    t1 = await a.sync(check_3)(x=100)
+    t2 = await a.sync(check_4)(x=5, y=5, z=10)
+    t3 = await a.sync(lambda x: x ** 3)(x=5)
+
+    with pytest.raises(TypeError):
+        a.sync("string")(10)
+
+    assert t1 == 110
+    assert t2 == 120
+    assert t3 == 125