h0rn3t · September 18, 2021 20:46 · Feb 3, 2017 · Feb 3, 2017 · Feb 3, 2017 · Feb 3, 2017
diff --git a/test.py b/test.py
@@ -30,15 +30,16 @@ def test():
         @force_sync
         async def main():
             import asyncio
+            # if it were to execute sequentially, it would take 10 seconds, in this case we expect to see only 1 second
             futures = list(map(lambda x: test(),
                                range(10)))
             return await asyncio.gather(*futures)
 
         import time
-
+        # take the elapsed time
         start = time.time()
         res = main()
         end = time.time()
         elapsed = end - start
         self.assertEqual(len(res), 10)
-        self.assertLess(elapsed, 1.2)
+        self.assertLess(elapsed, 1.2) # a little more than 1 second is normal
diff --git a/test.py b/test.py
@@ -1,11 +1,44 @@
-@force_async
-def long_blocking_function():
-    import time
-    time.sleep(10)
-    return True
-
-import asyncio
-async def run():
-    a = long_blocking_function()
-    b = long_blocking_function()
-    return await asyncio.gather(a, b) # [True, True] in 10 seconds
+import unittest
+from async import *
+
+class AsyncCanTurnAsyncIntoSyncFunction(unittest.TestCase):
+    def test_turn_async_to_sync(self):
+        @force_sync
+        async def test():
+            import asyncio
+            await asyncio.sleep(0.1)
+            return 1 + 2
+
+        self.assertEqual(test(), 3)
+
+    def test_turn_sync_to_sync(self):
+        @force_sync
+        def test():
+            return 1 + 2
+
+        self.assertEqual(test(), 3)
+
+
+class AsyncCanTurnSyncIntoAsyncFunction(unittest.TestCase):
+    def test_turn_sync_to_async(self):
+        @force_async
+        def test():
+            import time
+            time.sleep(1)
+            return True
+
+        @force_sync
+        async def main():
+            import asyncio
+            futures = list(map(lambda x: test(),
+                               range(10)))
+            return await asyncio.gather(*futures)
+
+        import time
+
+        start = time.time()
+        res = main()
+        end = time.time()
+        elapsed = end - start
+        self.assertEqual(len(res), 10)
+        self.assertLess(elapsed, 1.2)
diff --git a/async.py b/async.py
@@ -1,10 +1,33 @@
-def async(fn):
+import functools
+
+
+def force_async(fn):
+    '''
+    turns a sync function to async function using threads
+    '''
     from concurrent.futures import ThreadPoolExecutor
     import asyncio
     pool = ThreadPoolExecutor()
 
-    def wrapper(*args, **kwargs) -> asyncio.Future:
+    @functools.wraps(fn)
+    def wrapper(*args, **kwargs):
         future = pool.submit(fn, *args, **kwargs)
         return asyncio.wrap_future(future)  # make it awaitable
 
-    return wrapper
+    return wrapper
+
+
+def force_sync(fn):
+    '''
+    turn an async function to sync function
+    '''
+    import asyncio
+
+    @functools.wraps(fn)
+    def wrapper(*args, **kwargs):
+        res = fn(*args, **kwargs)
+        if asyncio.iscoroutine(res):
+            return asyncio.get_event_loop().run_until_complete(res)
+        return res
+
+    return wrapper
diff --git a/test.py b/test.py
@@ -0,0 +1,11 @@
+@force_async
+def long_blocking_function():
+    import time
+    time.sleep(10)
+    return True
+
+import asyncio
+async def run():
+    a = long_blocking_function()
+    b = long_blocking_function()
+    return await asyncio.gather(a, b) # [True, True] in 10 seconds
diff --git a/async.py b/async.py
@@ -0,0 +1,10 @@
+def async(fn):
+    from concurrent.futures import ThreadPoolExecutor
+    import asyncio
+    pool = ThreadPoolExecutor()
+
+    def wrapper(*args, **kwargs) -> asyncio.Future:
+        future = pool.submit(fn, *args, **kwargs)
+        return asyncio.wrap_future(future)  # make it awaitable
+
+    return wrapper