ez-a-sync 0.22.14__py3-none-any.whl → 0.22.15__py3-none-any.whl

tests/test_cache.py

@@ -8,63 +8,79 @@ from tests.fixtures import _test_kwargs
 
 
 def test_decorator_async_with_cache_type():
-    @a_sync.a_sync(default='async', cache_type='memory')
+    @a_sync.a_sync(default="async", cache_type="memory")
     async def some_test_fn() -> int:
         return 2
+
     start = time()
     assert asyncio.get_event_loop().run_until_complete(some_test_fn()) == 2
     assert asyncio.get_event_loop().run_until_complete(some_test_fn()) == 2
     duration = time() - start
-    assert duration < 1.5, "There is a 1 second sleep in this function but it should only run once."
-    _test_kwargs(some_test_fn, 'async')
+    assert (
+        duration < 1.5
+    ), "There is a 1 second sleep in this function but it should only run once."
+    _test_kwargs(some_test_fn, "async")
+
 
 def test_decorator_async_with_cache_maxsize():
-    @a_sync.a_sync(default='async', ram_cache_maxsize=100)
+    @a_sync.a_sync(default="async", ram_cache_maxsize=100)
     def some_test_fn() -> int:
         sleep(1)
         return 2
+
     start = time()
     assert asyncio.get_event_loop().run_until_complete(some_test_fn()) == 2
     assert asyncio.get_event_loop().run_until_complete(some_test_fn()) == 2
     duration = time() - start
-    assert duration < 1.5, "There is a 1 second sleep in this function but it should only run once."
-    _test_kwargs(some_test_fn, 'async')
+    assert (
+        duration < 1.5
+    ), "There is a 1 second sleep in this function but it should only run once."
+    _test_kwargs(some_test_fn, "async")
+
 
 # This will never succeed due to some task the ttl kwargs creates
 def test_decorator_async_with_cache_ttl():
-    @a_sync.a_sync(default='async', cache_type='memory', ram_cache_ttl=5)
+    @a_sync.a_sync(default="async", cache_type="memory", ram_cache_ttl=5)
     async def some_test_fn() -> int:
         return 2
+
     assert asyncio.get_event_loop().run_until_complete(some_test_fn()) == 2
-    _test_kwargs(some_test_fn, 'async')
+    _test_kwargs(some_test_fn, "async")
 
 
 def test_decorator_sync_with_cache_type():
     # Fails
-    @a_sync.a_sync(default='sync', cache_type='memory')
+    @a_sync.a_sync(default="sync", cache_type="memory")
     async def some_test_fn() -> int:
         sleep(1)
         return 2
+
     start = time()
     assert some_test_fn() == 2
     assert some_test_fn() == 2
     assert some_test_fn() == 2
     duration = time() - start
-    assert duration < 1.5, "There is a 1 second sleep in this function but it should only run once."
-    _test_kwargs(some_test_fn, 'sync')
+    assert (
+        duration < 1.5
+    ), "There is a 1 second sleep in this function but it should only run once."
+    _test_kwargs(some_test_fn, "sync")
 
-@pytest.mark.skipif(True, reason='skipped manually')
+
+@pytest.mark.skipif(True, reason="skipped manually")
 def test_decorator_sync_with_cache_maxsize():
     # Fails
     # TODO diagnose and fix
-    @a_sync.a_sync(default="sync", cache_type='memory')
+    @a_sync.a_sync(default="sync", cache_type="memory")
     def some_test_fn() -> int:
         sleep(1)
         return 2
+
     start = time()
     assert some_test_fn() == 2
     assert some_test_fn() == 2
     assert some_test_fn() == 2
     duration = time() - start
-    assert duration < 1.5, "There is a 1 second sleep in this function but it should only run once."
-    _test_kwargs(some_test_fn, 'sync')
+    assert (
+        duration < 1.5
+    ), "There is a 1 second sleep in this function but it should only run once."
+    _test_kwargs(some_test_fn, "sync")

tests/test_decorator.py

@@ -1,4 +1,3 @@
-
 import asyncio
 import pytest
 
@@ -6,66 +5,79 @@ import a_sync
 from tests.fixtures import _test_kwargs
 
 
-
 # ASYNC DEF
 def test_decorator_no_args():
     @a_sync.a_sync
     async def some_test_fn() -> int:
         return 2
+
     assert asyncio.get_event_loop().run_until_complete(some_test_fn()) == 2
     _test_kwargs(some_test_fn, None)
-    
+
     @a_sync.a_sync()
     async def some_test_fn() -> int:
         return 2
+
     assert asyncio.get_event_loop().run_until_complete(some_test_fn()) == 2
     _test_kwargs(some_test_fn, None)
-    
+
+
 def test_decorator_default_none_arg():
     @a_sync.a_sync(None)
     async def some_test_fn() -> int:
         return 2
+
     assert asyncio.get_event_loop().run_until_complete(some_test_fn()) == 2
     _test_kwargs(some_test_fn, None)
-    
+
+
 def test_decorator_default_none_kwarg():
     @a_sync.a_sync(default=None)
     async def some_test_fn() -> int:
         return 2
+
     assert asyncio.get_event_loop().run_until_complete(some_test_fn()) == 2
     _test_kwargs(some_test_fn, None)
 
+
 def test_decorator_default_sync_arg():
-    @a_sync.a_sync('sync')
+    @a_sync.a_sync("sync")
     async def some_test_fn() -> int:
         return 2
+
     with pytest.raises(TypeError):
         asyncio.get_event_loop().run_until_complete(some_test_fn())
     assert some_test_fn() == 2
-    _test_kwargs(some_test_fn, 'sync')
+    _test_kwargs(some_test_fn, "sync")
+
 
 def test_decorator_default_sync_kwarg():
-    @a_sync.a_sync(default='sync')
+    @a_sync.a_sync(default="sync")
     async def some_test_fn() -> int:
         return 2
+
     with pytest.raises(TypeError):
         asyncio.get_event_loop().run_until_complete(some_test_fn())
     assert some_test_fn() == 2
-    _test_kwargs(some_test_fn, 'sync')
-    
+    _test_kwargs(some_test_fn, "sync")
+
+
 def test_decorator_default_async_arg():
-    @a_sync.a_sync('async')
+    @a_sync.a_sync("async")
     async def some_test_fn() -> int:
         return 2
+
     assert asyncio.get_event_loop().run_until_complete(some_test_fn()) == 2
-    _test_kwargs(some_test_fn, 'async')
-    
+    _test_kwargs(some_test_fn, "async")
+
+
 def test_decorator_default_async_kwarg():
-    @a_sync.a_sync(default='async')
+    @a_sync.a_sync(default="async")
     async def some_test_fn() -> int:
         return 2
+
     assert asyncio.get_event_loop().run_until_complete(some_test_fn()) == 2
-    _test_kwargs(some_test_fn, 'async')
+    _test_kwargs(some_test_fn, "async")
 
 
 # SYNC DEF
@@ -73,53 +85,67 @@ def test_sync_decorator_no_args():
     @a_sync.a_sync
     def some_test_fn() -> int:
         return 2
+
     assert some_test_fn() == 2
     _test_kwargs(some_test_fn, None)
-    
+
     @a_sync.a_sync()
     def some_test_fn() -> int:
         return 2
+
     assert some_test_fn() == 2
     _test_kwargs(some_test_fn, None)
-    
+
+
 def test_sync_decorator_default_none_arg():
     @a_sync.a_sync(None)
     def some_test_fn() -> int:
         return 2
+
     assert some_test_fn() == 2
     _test_kwargs(some_test_fn, None)
-    
+
+
 def test_sync_decorator_default_none_kwarg():
     @a_sync.a_sync(default=None)
     def some_test_fn() -> int:
         return 2
+
     assert some_test_fn() == 2
     _test_kwargs(some_test_fn, None)
 
+
 def test_sync_decorator_default_sync_arg():
-    @a_sync.a_sync('sync')
+    @a_sync.a_sync("sync")
     def some_test_fn() -> int:
         return 2
+
     assert some_test_fn() == 2
-    _test_kwargs(some_test_fn, 'sync')
+    _test_kwargs(some_test_fn, "sync")
+
 
 def test_sync_decorator_default_sync_kwarg():
-    @a_sync.a_sync(default='sync')
+    @a_sync.a_sync(default="sync")
     def some_test_fn() -> int:
         return 2
+
     assert some_test_fn() == 2
-    _test_kwargs(some_test_fn, 'sync')
-    
+    _test_kwargs(some_test_fn, "sync")
+
+
 def test_sync_decorator_default_async_arg():
-    @a_sync.a_sync('async')
+    @a_sync.a_sync("async")
     def some_test_fn() -> int:
         return 2
+
     assert asyncio.get_event_loop().run_until_complete(some_test_fn()) == 2
-    _test_kwargs(some_test_fn, 'async')
-    
+    _test_kwargs(some_test_fn, "async")
+
+
 def test_sync_decorator_default_async_kwarg():
-    @a_sync.a_sync(default='async')
+    @a_sync.a_sync(default="async")
     def some_test_fn() -> int:
         return 2
+
     assert asyncio.get_event_loop().run_until_complete(some_test_fn()) == 2
-    _test_kwargs(some_test_fn, 'async')
+    _test_kwargs(some_test_fn, "async")

tests/test_executor.py

@@ -3,15 +3,15 @@ import time
 
 import pytest
 
-from a_sync.executor import (AsyncProcessPoolExecutor,
-                                        ProcessPoolExecutor)
+from a_sync.executor import AsyncProcessPoolExecutor, ProcessPoolExecutor
 
 
 def do_work(i, kwarg=None):
     time.sleep(i)
     if kwarg:
         assert kwarg == i
-    
+
+
 def test_executor():
     executor = ProcessPoolExecutor(1)
     assert isinstance(executor, AsyncProcessPoolExecutor)
@@ -21,20 +21,15 @@ def test_executor():
     fut = executor.submit(do_work, 3)
     assert isinstance(fut, asyncio.Future), fut.__dict__
     asyncio.get_event_loop().run_until_complete(fut)
-    
+
     # asyncio implementation cant handle kwargs :(
     with pytest.raises(TypeError):
         asyncio.get_event_loop().run_until_complete(
             asyncio.get_event_loop().run_in_executor(executor, do_work, 3, kwarg=3)
         )
-        
+
     # but our clean implementation can :)
     fut = executor.submit(do_work, 3, kwarg=3)
-    
-    asyncio.get_event_loop().run_until_complete(
-        executor.run(do_work, 3, kwarg=3)
-    )
-    asyncio.get_event_loop().run_until_complete(
-        fut
-    )
-    
+
+    asyncio.get_event_loop().run_until_complete(executor.run(do_work, 3, kwarg=3))
+    asyncio.get_event_loop().run_until_complete(fut)

tests/test_future.py

@@ -1,4 +1,3 @@
-
 from a_sync.future import ASyncFuture
 
 
@@ -8,90 +7,129 @@ class StuffDoer:
             raise ValueError
         return 1
 
+
 async def dct():
-    return {1:2}
+    return {1: 2}
+
 
 async def one() -> int:
     return 1
 
+
 async def two() -> int:
     return 2
 
+
 async def zero():
     return 0
 
+
 def test_result():
     assert ASyncFuture(one()).result() == 1
+
+
 def test_add():
     assert ASyncFuture(one()) + ASyncFuture(two()) == 3
     assert ASyncFuture(one()) + 2 == 3
     assert 1 + ASyncFuture(two()) == 3
+
+
 def test_sum():
     assert sum([ASyncFuture(one()), ASyncFuture(two())]) == 3
     assert sum([ASyncFuture(one()), 2]) == 3
     assert sum([1, ASyncFuture(two())]) == 3
+
+
 def test_sub():
     assert ASyncFuture(one()) - ASyncFuture(two()) == -1
     assert ASyncFuture(one()) - 2 == -1
     assert 1 - ASyncFuture(two()) == -1
+
+
 def test_mul():
     assert ASyncFuture(one()) * ASyncFuture(two()) == 2
     assert ASyncFuture(one()) * 2 == 2
     assert 1 * ASyncFuture(two()) == 2
+
+
 def test_pow():
     assert ASyncFuture(two()) ** ASyncFuture(two()) == 4
     assert ASyncFuture(two()) ** 2 == 4
     assert 2 ** ASyncFuture(two()) == 4
+
+
 def test_realdiv():
     assert ASyncFuture(one()) / ASyncFuture(two()) == 0.5
     assert ASyncFuture(one()) / 2 == 0.5
     assert 1 / ASyncFuture(two()) == 0.5
+
+
 def test_floordiv():
     assert ASyncFuture(one()) // ASyncFuture(two()) == 0
     assert ASyncFuture(one()) // 2 == 0
     assert 1 // ASyncFuture(two()) == 0
+
+
 def test_gt():
     assert not ASyncFuture(one()) > ASyncFuture(two())
     assert ASyncFuture(two()) > ASyncFuture(one())
     assert not ASyncFuture(one()) > ASyncFuture(one())
+
+
 def test_gte():
     assert not ASyncFuture(one()) >= ASyncFuture(two())
     assert ASyncFuture(two()) >= ASyncFuture(one())
     assert ASyncFuture(one()) >= ASyncFuture(one())
+
+
 def test_lt():
     assert ASyncFuture(one()) < ASyncFuture(two())
     assert not ASyncFuture(two()) < ASyncFuture(one())
     assert not ASyncFuture(one()) < ASyncFuture(one())
+
+
 def test_lte():
     assert ASyncFuture(one()) <= ASyncFuture(two())
     assert not ASyncFuture(two()) <= ASyncFuture(one())
     assert ASyncFuture(one()) <= ASyncFuture(one())
+
+
 def test_bool():
     assert bool(ASyncFuture(one())) == True
     assert bool(ASyncFuture(zero())) == False
+
+
 def test_float():
     assert float(ASyncFuture(one())) == float(1)
+
+
 def test_str():
     assert str(ASyncFuture(one())) == "1"
 
+
 def test_getitem():
     assert ASyncFuture(dct())[1] == 2
 
+
 # NOTE: does not work
 def test_setitem():
     meta = ASyncFuture(dct())
     print(meta)
     meta[3] = 4
-    assert meta == {1:2, 3:4}
+    assert meta == {1: 2, 3: 4}
     assert meta[3] == 4
-    
+
+
 async def stuff_doer():
     return StuffDoer()
 
+
 def test_getattr():
     assert ASyncFuture(stuff_doer()).do_stuff()
 
-import pytest 
+
+import pytest
+
 
 def test_multi_maths():
     some_cool_evm_value = ASyncFuture(two())
@@ -100,8 +138,8 @@ def test_multi_maths():
     other = ASyncFuture(two())
     stuff = ASyncFuture(two())
     idrk = ASyncFuture(one())
-    output0 = some_cool_evm_value / scale ** some # 2
-    output1 = other + stuff - idrk # 3
+    output0 = some_cool_evm_value / scale**some  # 2
+    output1 = other + stuff - idrk  # 3
     output = output0 * output1
     assert output0 < output1
     assert not output0 > output1
@@ -113,4 +151,3 @@ def test_multi_maths():
     assert output == 6
     with pytest.raises(ValueError):
         ASyncFuture(stuff_doer()).do_stuff(6)
-        

tests/test_gather.py

@@ -10,32 +10,38 @@ async def sample_task(number):
     await asyncio.sleep(0.1)
     return number * 2
 
+
 @pytest.mark.asyncio_cooperative
 async def test_gather_with_awaitables():
     results = await gather(sample_task(1), sample_task(2), sample_task(3))
     assert results == [2, 4, 6]
 
+
 @pytest.mark.asyncio_cooperative
 async def test_gather_with_awaitables_and_tqdm():
     results = await gather(sample_task(1), sample_task(2), sample_task(3), tqdm=True)
     assert results == [2, 4, 6]
 
+
 @pytest.mark.asyncio_cooperative
 async def test_gather_with_mapping_and_tqdm():
-    tasks = {'a': sample_task(1), 'b': sample_task(2), 'c': sample_task(3)}
+    tasks = {"a": sample_task(1), "b": sample_task(2), "c": sample_task(3)}
     results = await gather(tasks, tqdm=True)
-    assert results == {'a': 2, 'b': 4, 'c': 6}
+    assert results == {"a": 2, "b": 4, "c": 6}
+
 
 @pytest.mark.asyncio_cooperative
 async def test_gather_with_exceptions():
     with pytest.raises(ValueError):
         await gather(sample_exc(None))
 
+
 @pytest.mark.asyncio_cooperative
 async def test_gather_with_return_exceptions():
     results = await gather(sample_exc(None), return_exceptions=True)
     assert isinstance(results[0], ValueError)
 
+
 @pytest.mark.asyncio_cooperative
 async def test_gather_with_return_exceptions_and_tqdm():
     results = await gather(sample_exc(None), return_exceptions=True, tqdm=True)

tests/test_helpers.py

@@ -6,8 +6,10 @@ from a_sync.asyncio import get_event_loop
 def test_get_event_loop():
     assert get_event_loop() == asyncio.get_event_loop()
 
+
 def test_get_event_loop_in_thread():
     def task():
         assert get_event_loop() == asyncio.get_event_loop()
+
     loop = get_event_loop()
     loop.run_until_complete(loop.run_in_executor(None, task))