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

tests/test_iter.py

@@ -1,4 +1,3 @@
-
 import asyncio
 import contextlib
 import pytest
@@ -10,30 +9,35 @@ from a_sync.exceptions import SyncModeInAsyncContextError
 from a_sync.iter import ASyncIterable, ASyncIterator
 
 
-
 test_both = pytest.mark.parametrize("cls_to_test", [ASyncIterable, ASyncIterator])
 
+
 @pytest.fixture
 def async_generator():
     async def async_gen(i: int = 3):
         for i in range(i):
             yield i
+
     yield async_gen
 
+
 @pytest.fixture
 def async_generator_empty():
     async def async_gen_empty():
         if True:
             return
         yield
+
     yield async_gen_empty
 
+
 @pytest.fixture
 def async_error_generator():
     async def async_err_gen():
         yield 0
         yield 1
         raise ValueError("Simulated error")
+
     return async_err_gen
 
 
@@ -42,6 +46,7 @@ def test_wrap_types(cls_to_test, async_generator):
     assert isinstance(cls_to_test(async_generator()), cls_to_test)
     assert isinstance(cls_to_test.wrap(async_generator()), cls_to_test)
 
+
 @test_both
 def test_sync(cls_to_test, async_generator):
     # sourcery skip: identity-comprehension, list-comprehension
@@ -64,13 +69,17 @@ def test_sync(cls_to_test, async_generator):
     assert cls_to_test(async_generator()).materialized == [0, 1, 2]
     assert cls_to_test.wrap(async_generator()).materialized == [0, 1, 2]
 
+
 @test_both
 @pytest.mark.asyncio_cooperative
 async def test_async(cls_to_test, async_generator):
     ait = cls_to_test(async_generator())
 
     # comprehension
-    with pytest.raises(SyncModeInAsyncContextError, match="The event loop is already running. Try iterating using `async for` instead of `for`."):
+    with pytest.raises(
+        SyncModeInAsyncContextError,
+        match="The event loop is already running. Try iterating using `async for` instead of `for`.",
+    ):
         list(ait)
     assert [i async for i in ait] == [0, 1, 2]
 
@@ -79,7 +88,10 @@ async def test_async(cls_to_test, async_generator):
     async for item in cls_to_test(async_generator()):
         result.append(item)
     assert result == [0, 1, 2]
-    with pytest.raises(SyncModeInAsyncContextError, match="The event loop is already running. Try iterating using `async for` instead of `for`."):
+    with pytest.raises(
+        SyncModeInAsyncContextError,
+        match="The event loop is already running. Try iterating using `async for` instead of `for`.",
+    ):
         for _ in cls_to_test(async_generator()):
             pass
 
@@ -95,11 +107,15 @@ async def test_async(cls_to_test, async_generator):
 def test_sync_empty(cls_to_test, async_generator_empty):
     assert not list(cls_to_test(async_generator_empty()))
 
+
 @test_both
 @pytest.mark.asyncio_cooperative
 async def test_async_empty(cls_to_test, async_generator_empty):
     ait = cls_to_test(async_generator_empty())
-    with pytest.raises(SyncModeInAsyncContextError, match="The event loop is already running. Try iterating using `async for` instead of `for`."):
+    with pytest.raises(
+        SyncModeInAsyncContextError,
+        match="The event loop is already running. Try iterating using `async for` instead of `for`.",
+    ):
         list(ait)
     assert not [i async for i in ait]
 
@@ -118,6 +134,7 @@ def test_sync_partial(cls_to_test, async_generator):
     remaining = list(iterator)
     assert remaining == [3, 4] if cls_to_test is ASyncIterator else [0, 1, 2, 3, 4]
 
+
 @test_both
 @pytest.mark.asyncio_cooperative
 async def test_async_partial(cls_to_test, async_generator):
@@ -146,6 +163,7 @@ def test_stop_iteration_sync(cls_to_test, async_generator):
             with pytest.raises(StopIteration):
                 next(it)
 
+
 @test_both
 @pytest.mark.asyncio_cooperative
 async def test_stop_iteration_async(cls_to_test, async_generator):
@@ -162,15 +180,23 @@ async def test_stop_iteration_async(cls_to_test, async_generator):
 
 # Test decorator
 
+
 def test_aiterable_decorated_func_sync():
-    with pytest.raises(TypeError, match="`async_iterable` must be an AsyncIterable. You passed "):
+    with pytest.raises(
+        TypeError, match="`async_iterable` must be an AsyncIterable. You passed "
+    ):
+
         @ASyncIterable.wrap
         async def decorated():
             yield 0
-        
+
+
 @pytest.mark.asyncio_cooperative
 async def test_aiterable_decorated_func_async(async_generator):
-    with pytest.raises(TypeError, match="`async_iterable` must be an AsyncIterable. You passed "):
+    with pytest.raises(
+        TypeError, match="`async_iterable` must be an AsyncIterable. You passed "
+    ):
+
         @ASyncIterable.wrap
         async def decorated():
             yield 0
@@ -181,16 +207,19 @@ def test_aiterator_decorated_func_sync(async_generator):
     async def decorated():
         async for i in async_generator():
             yield i
+
     retval = decorated()
     assert isinstance(retval, ASyncIterator)
     assert list(retval) == [0, 1, 2]
-        
+
+
 @pytest.mark.asyncio_cooperative
 async def test_aiterator_decorated_func_async(async_generator):
     @ASyncIterator.wrap
     async def decorated():
         async for i in async_generator():
             yield i
+
     retval = decorated()
     assert isinstance(retval, ASyncIterator)
     assert await retval == [0, 1, 2]
@@ -198,14 +227,17 @@ async def test_aiterator_decorated_func_async(async_generator):
 
 def test_aiterable_decorated_method_sync():
     with pytest.raises(TypeError, match=""):
+
         class Test:
             @ASyncIterable.wrap
             async def decorated(self):
                 yield 0
-        
+
+
 @pytest.mark.asyncio_cooperative
 async def test_aiterable_decorated_method_async():
     with pytest.raises(TypeError, match=""):
+
         class Test:
             @ASyncIterable.wrap
             async def decorated(self):
@@ -218,10 +250,12 @@ def test_aiterator_decorated_method_sync(async_generator):
         async def decorated(self):
             async for i in async_generator():
                 yield i
+
     retval = Test().decorated()
     assert isinstance(retval, ASyncIterator)
     assert list(retval) == [0, 1, 2]
-        
+
+
 @pytest.mark.asyncio_cooperative
 async def test_aiterator_decorated_method_async(async_generator):
     class Test:
@@ -229,10 +263,11 @@ async def test_aiterator_decorated_method_async(async_generator):
         async def decorated(self):
             async for i in async_generator():
                 yield i
+
     retval = Test().decorated()
     assert isinstance(retval, ASyncIterator)
     assert await retval == [0, 1, 2]
-        
+
 
 @test_both
 def test_sync_error_handling(cls_to_test, async_error_generator):
@@ -243,6 +278,7 @@ def test_sync_error_handling(cls_to_test, async_error_generator):
     # we still got some results though
     assert results == [0, 1]
 
+
 @test_both
 @pytest.mark.asyncio_cooperative
 async def test_async_error_handling(cls_to_test, async_error_generator):
@@ -257,11 +293,13 @@ async def test_async_error_handling(cls_to_test, async_error_generator):
 
 # Test failures
 
+
 @test_both
 def test_sync_with_iterable(cls_to_test):
     with pytest.raises(TypeError):
         cls_to_test([0, 1, 2])
 
+
 @test_both
 @pytest.mark.asyncio_cooperative
 async def test_async_with_iterable(cls_to_test):
@@ -271,24 +309,28 @@ async def test_async_with_iterable(cls_to_test):
 
 # Type check dunder methods
 
+
 def test_async_iterable_iter_method(async_generator):
     ait = ASyncIterable(async_generator())
     iterator = iter(ait)
     assert isinstance(iterator, Iterator)
 
+
 def test_async_iterator_iter_method(async_generator):
     ait = ASyncIterator(async_generator())
     iterator = iter(ait)
     assert iterator is ait  # Should return self
 
+
 @pytest.mark.asyncio_cooperative
 async def test_async_aiter_method(async_generator):
     ait = ASyncIterable(async_generator())
     async_iterator = ait.__aiter__()
     assert isinstance(async_iterator, AsyncIterator)
 
+
 @pytest.mark.asyncio_cooperative
 async def test_async_iterator_aiter_method(async_generator):
     ait = ASyncIterator(async_generator())
     async_iterator = ait.__aiter__()
-    assert async_iterator is ait  # Should return self
+    assert async_iterator is ait  # Should return self

tests/test_limiter.py

@@ -1,4 +1,3 @@
-
 import pytest
 from time import time
 from tests.fixtures import TestLimiter, increment
@@ -9,18 +8,21 @@ from tests.fixtures import TestLimiter, increment
 #   Maybe a problem with test suite interaction?
 # - semaphore modifier works fine with integer inputs
 
+
 @increment
 @pytest.mark.asyncio_cooperative
 async def test_semaphore(i: int):
     instance = TestLimiter(i, sync=False)
     assert await instance.test_fn() == i
-    
+
+
 @increment
 @pytest.mark.asyncio_cooperative
 async def test_semaphore_property(i: int):
     instance = TestLimiter(i, sync=False)
     assert await instance.test_property == i * 2
-    
+
+
 @increment
 @pytest.mark.asyncio_cooperative
 async def test_semaphore_cached_property(i: int):

tests/test_meta.py

@@ -9,7 +9,8 @@ from a_sync.a_sync.property import HiddenMethod
 from a_sync.a_sync.singleton import ASyncGenericSingleton
 from tests.fixtures import TestSingleton, TestSingletonMeta, increment
 
-classes = pytest.mark.parametrize('cls', [TestSingleton, TestSingletonMeta])
+classes = pytest.mark.parametrize("cls", [TestSingleton, TestSingletonMeta])
+
 
 @classes
 @increment
@@ -24,7 +25,9 @@ def test_singleton_meta_sync(cls: type, i: int):
     assert sync_instance.test_cached_property == 0
     assert isinstance(sync_instance.test_cached_property, int)
     duration = time.time() - start
-    assert duration < 3, "There is a 2 second sleep in 'test_cached_property' but it should only run once."
+    assert (
+        duration < 3
+    ), "There is a 2 second sleep in 'test_cached_property' but it should only run once."
 
     # Can we override with kwargs?
     val = asyncio.get_event_loop().run_until_complete(sync_instance.test_fn(sync=False))
@@ -41,9 +44,17 @@ def test_singleton_meta_sync(cls: type, i: int):
     getter_coro = getter()
     assert asyncio.get_event_loop().run_until_complete(getter_coro) == 0
     # Can we override them too?
-    assert asyncio.get_event_loop().run_until_complete(sync_instance.__test_cached_property__(sync=False)) == 0
+    assert (
+        asyncio.get_event_loop().run_until_complete(
+            sync_instance.__test_cached_property__(sync=False)
+        )
+        == 0
+    )
     duration = time.time() - start
-    assert duration < 3, "There is a 2 second sleep in 'test_cached_property' but it should only run once."
+    assert (
+        duration < 3
+    ), "There is a 2 second sleep in 'test_cached_property' but it should only run once."
+
 
 @classes
 @increment
@@ -59,12 +70,14 @@ async def test_singleton_meta_async(cls: type, i: int):
     assert await async_instance.test_cached_property == 0
     assert isinstance(await async_instance.test_cached_property, int)
     duration = time.time() - start
-    assert duration < 3, "There is a 2 second sleep in 'test_cached_property' but it should only run once."
+    assert (
+        duration < 3
+    ), "There is a 2 second sleep in 'test_cached_property' but it should only run once."
 
     # Can we override with kwargs?
     with pytest.raises(RuntimeError):
         async_instance.test_fn(sync=True)
-    
+
     # Can we access hidden methods for properties?
     assert await async_instance.__test_property__() == 0
     assert await async_instance.__test_cached_property__() == 0
@@ -73,24 +86,25 @@ async def test_singleton_meta_async(cls: type, i: int):
         async_instance.__test_cached_property__(sync=True)
 
 
-
 class TestUnspecified(ASyncGenericSingleton):
     def __init__(self, sync=True):
         self.sync = sync
 
+
 def test_singleton_unspecified():
     obj = TestUnspecified()
     assert obj.sync == True
     obj.test_attr = True
     newobj = TestUnspecified()
-    assert hasattr(newobj, 'test_attr')
+    assert hasattr(newobj, "test_attr")
 
     assert TestUnspecified(sync=True).sync == True
     assert TestUnspecified(sync=False).sync == False
 
+
 def test_singleton_switching():
     obj = TestUnspecified()
     assert obj.sync == True
     obj.test_attr = True
     newobj = TestUnspecified(sync=False)
-    assert not hasattr(newobj, 'test_attr')
+    assert not hasattr(newobj, "test_attr")

tests/test_modified.py

@@ -1,16 +1,19 @@
-
 import a_sync
 
+
 @a_sync.a_sync
 def sync_def():
     pass
 
+
 @a_sync.a_sync
 async def async_def():
     pass
 
+
 def test_sync_def_repr():
     assert sync_def.__name__ == "sync_def"
 
+
 def test_async_def_repr():
     assert async_def.__name__ == "async_def"

tests/test_semaphore.py

@@ -1,4 +1,3 @@
-
 import pytest
 from time import time
 from tests.fixtures import TestSemaphore, increment
@@ -12,30 +11,38 @@ from tests.fixtures import TestSemaphore, increment
 
 instance = TestSemaphore(1, sync=False)
 
+
 @increment
 @pytest.mark.asyncio_cooperative
 async def test_semaphore(i: int):
     start = time()
     assert await instance.test_fn() == 1
     duration = time() - start
-    assert i < 3 or duration > i # There is a 1 second sleep in this fn. If the semaphore is not working, all tests will complete in 1 second.
-    
-    
+    assert (
+        i < 3 or duration > i
+    )  # There is a 1 second sleep in this fn. If the semaphore is not working, all tests will complete in 1 second.
+
+
 @increment
 @pytest.mark.asyncio_cooperative
 async def test_semaphore_property(i: int):
     start = time()
     assert await instance.test_property == 2
     duration = time() - start
-    assert i < 3 or duration > i # There is a 1 second sleep in this fn. If the semaphore is not working, all tests will complete in 1 second.
-    
+    assert (
+        i < 3 or duration > i
+    )  # There is a 1 second sleep in this fn. If the semaphore is not working, all tests will complete in 1 second.
+
+
 @increment
 @pytest.mark.asyncio_cooperative
 async def test_semaphore_cached_property(i: int):
     start = time()
     assert await instance.test_cached_property == 3
     duration = time() - start
-    # There is a 1 second sleep in this fn but a semaphore override with a value of 50. 
+    # There is a 1 second sleep in this fn but a semaphore override with a value of 50.
     # You can tell it worked correctly because the class-defined semaphore value is just one, whch would cause this test to fail if it were used.
     # If the override is not working, all tests will complete in just over 1 second.
-    assert i == 1 or duration < 1.4  # We increased the threshold from 1.05 to 1.4 to help tests pass on slow github runners
+    assert (
+        i == 1 or duration < 1.4
+    )  # We increased the threshold from 1.05 to 1.4 to help tests pass on slow github runners

tests/test_singleton.py

@@ -1,20 +1,25 @@
-
 from a_sync.a_sync.singleton import ASyncGenericSingleton
 
+
 def test_flag_predefined():
     """We had a failure case where the subclass implementation assigned the flag value to the class and did not allow user to determine at init time"""
+
     class Test(ASyncGenericSingleton):
-        sync=True
-        def __init__(self):
-            ...
+        sync = True
+
+        def __init__(self): ...
+
     Test()
-    class TestInherit(Test):
-        ...
+
+    class TestInherit(Test): ...
+
     TestInherit()
 
     class Test(ASyncGenericSingleton):
-        sync=False
+        sync = False
+
     Test()
-    class TestInherit(Test):
-        ...
-    TestInherit()
+
+    class TestInherit(Test): ...
+
+    TestInherit()