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

tests/fixtures.py

@@ -1,4 +1,3 @@
-
 import asyncio
 import time
 from threading import current_thread, main_thread
@@ -11,97 +10,124 @@ from a_sync import ASyncBase
 from a_sync.a_sync._meta import ASyncMeta, ASyncSingletonMeta
 from a_sync.a_sync.singleton import ASyncGenericSingleton
 
-increment = pytest.mark.parametrize('i', range(10))
+increment = pytest.mark.parametrize("i", range(10))
+
+
+class WrongThreadError(Exception): ...
 
-class WrongThreadError(Exception):
-    ...
 
 class TestClass(ASyncBase):
     def __init__(self, v: int, sync: bool = False):
         self.v = v
         self.sync = sync
-    
+
     async def test_fn(self) -> int:
         if self.sync == False and main_thread() != current_thread():
-            raise WrongThreadError('This should be running on an event loop in the main thread.')
+            raise WrongThreadError(
+                "This should be running on an event loop in the main thread."
+            )
         elif self.sync == True and main_thread() != current_thread():
-            raise WrongThreadError('This should be awaited in the main thread')
+            raise WrongThreadError("This should be awaited in the main thread")
         return self.v
-    
+
     @a_sync.aka.property
     async def test_property(self) -> int:
         if self.sync == False and main_thread() != current_thread():
-            raise WrongThreadError('This should be running on an event loop in the main thread.')
+            raise WrongThreadError(
+                "This should be running on an event loop in the main thread."
+            )
         elif self.sync == True and main_thread() != current_thread():
-            raise WrongThreadError('This should be awaited in the main thread')
+            raise WrongThreadError("This should be awaited in the main thread")
         return self.v * 2
-    
+
     @a_sync.alias.cached_property
     async def test_cached_property(self) -> int:
         if self.sync == False and main_thread() != current_thread():
-            raise WrongThreadError('This should be running on an event loop in the main thread.')
+            raise WrongThreadError(
+                "This should be running on an event loop in the main thread."
+            )
         elif self.sync == True and main_thread() != current_thread():
-            raise WrongThreadError('This should be awaited in the main thread')
+            raise WrongThreadError("This should be awaited in the main thread")
         await asyncio.sleep(2)
         return self.v * 3
 
+
 class TestSync(ASyncBase):
     main = main_thread()
+
     def __init__(self, v: int, sync: bool):
         self.v = v
         self.sync = sync
-    
+
     def test_fn(self) -> int:
         # Sync bound methods are actually async functions that are run in an executor and awaited
         if self.sync == False and main_thread() == current_thread():
-            raise WrongThreadError('This should be running in an executor, not the main thread.')
+            raise WrongThreadError(
+                "This should be running in an executor, not the main thread."
+            )
         elif self.sync == True and main_thread() != current_thread():
-            raise WrongThreadError('This should be running synchronously in the main thread')
+            raise WrongThreadError(
+                "This should be running synchronously in the main thread"
+            )
         return self.v
-    
+
     @a_sync.aka.property
     def test_property(self) -> int:
         if self.sync == False and main_thread() == current_thread():
-            raise WrongThreadError('This should be running in an executor, not the main thread.')
+            raise WrongThreadError(
+                "This should be running in an executor, not the main thread."
+            )
         if self.sync == True and main_thread() == current_thread():
             # Sync properties are actually async functions that are run in an executor and awaited
-            raise WrongThreadError('This should be running in an executor, not the main thread.')
+            raise WrongThreadError(
+                "This should be running in an executor, not the main thread."
+            )
         return self.v * 2
-    
+
     @a_sync.alias.cached_property
     def test_cached_property(self) -> int:
         if self.sync == False and main_thread() == current_thread():
-            raise WrongThreadError('This should be running in an executor, not the main thread.')
+            raise WrongThreadError(
+                "This should be running in an executor, not the main thread."
+            )
         if self.sync == True and main_thread() == current_thread():
             # Sync properties are actually async functions that are run in an executor and awaited
-            raise WrongThreadError('This should be running in an executor, not the main thread.')
+            raise WrongThreadError(
+                "This should be running in an executor, not the main thread."
+            )
         time.sleep(2)
         return self.v * 3
 
+
 class TestLimiter(TestClass):
     limiter = 1
-    
+
+
 class TestInheritor(TestClass):
     pass
 
+
 class TestMeta(TestClass, metaclass=ASyncMeta):
     pass
 
+
 class TestSingleton(ASyncGenericSingleton, TestClass):
     runs_per_minute = 100
     pass
 
+
 class TestSingletonMeta(TestClass, metaclass=ASyncSingletonMeta):
     semaphore = 1
     pass
 
+
 class TestSemaphore(ASyncBase):
-    #semaphore=1  # NOTE: this is detected propely by undecorated test_fn but not the properties
-    
+    # semaphore=1  # NOTE: this is detected propely by undecorated test_fn but not the properties
+
     def __init__(self, v: int, sync: bool):
         self.v = v
         self.sync = sync
-    
+
     # spec on class and function both working
     @a_sync.a_sync(semaphore=1)
     async def test_fn(self) -> int:
@@ -109,11 +135,11 @@ class TestSemaphore(ASyncBase):
         return self.v
 
     # spec on class, function, property all working
-    @a_sync.aka.property('async', semaphore=1)
+    @a_sync.aka.property("async", semaphore=1)
     async def test_property(self) -> int:
         await asyncio.sleep(1)
         return self.v * 2
-    
+
     # spec on class, function, property all working
     @a_sync.alias.cached_property(semaphore=50)
     async def test_cached_property(self) -> int:
@@ -121,7 +147,7 @@ class TestSemaphore(ASyncBase):
         return self.v * 3
 
 
-def _test_kwargs(fn, default: Literal['sync','async',None]):
+def _test_kwargs(fn, default: Literal["sync", "async", None]):
     # force async
     assert asyncio.get_event_loop().run_until_complete(fn(sync=False)) == 2
     assert asyncio.get_event_loop().run_until_complete(fn(asynchronous=True)) == 2
@@ -132,18 +158,21 @@ def _test_kwargs(fn, default: Literal['sync','async',None]):
         assert asyncio.get_event_loop().run_until_complete(fn(asynchronous=False)) == 2
     assert fn(sync=True) == 2
     assert fn(asynchronous=False) == 2
-    if default == 'sync':
+    if default == "sync":
         assert fn() == 2
-    elif default == 'async':
+    elif default == "async":
         assert asyncio.get_event_loop().run_until_complete(fn()) == 2
 
+
 async def sample_task(n):
     await asyncio.sleep(0.01)
     return n
 
+
 async def timeout_task(n):
     await asyncio.sleep(0.1)
     return n
 
+
 async def sample_exc(n):
-    raise ValueError("Sample error")
+    raise ValueError("Sample error")

tests/test_abstract.py

@@ -1,17 +1,20 @@
-
 import sys
 
 import pytest
 
 from a_sync.a_sync.abstract import ASyncABC
 
-_methods = '__a_sync_default_mode__', '__a_sync_flag_name__', '__a_sync_flag_value__'
+_methods = "__a_sync_default_mode__", "__a_sync_flag_name__", "__a_sync_flag_value__"
 if sys.version_info >= (3, 12):
     _MIDDLE = "without an implementation for abstract methods"
     _methods = (f"'{method}'" for method in _methods)
 else:
     _MIDDLE = "with abstract methods"
 
+
 def test_abc_direct_init():
-    with pytest.raises(TypeError, match=f"Can't instantiate abstract class ASyncABC {_MIDDLE} {', '.join(_methods)}"):
-        ASyncABC()
+    with pytest.raises(
+        TypeError,
+        match=f"Can't instantiate abstract class ASyncABC {_MIDDLE} {', '.join(_methods)}",
+    ):
+        ASyncABC()

tests/test_as_completed.py

@@ -1,4 +1,3 @@
-
 import asyncio
 
 import a_sync
@@ -11,7 +10,10 @@ from tests.fixtures import sample_exc, sample_task, timeout_task
 async def test_as_completed_with_awaitables():
     tasks = [sample_task(i) for i in range(5)]
     results = [await result for result in a_sync.as_completed(tasks, aiter=False)]
-    assert sorted(results) == list(range(5)), "Results should be in ascending order from 0 to 4"
+    assert sorted(results) == list(
+        range(5)
+    ), "Results should be in ascending order from 0 to 4"
+
 
 @pytest.mark.asyncio_cooperative
 async def test_as_completed_with_awaitables_aiter():
@@ -19,42 +21,61 @@ async def test_as_completed_with_awaitables_aiter():
     results = []
     async for result in a_sync.as_completed(tasks, aiter=True):
         results.append(result)
-    assert sorted(results) == list(range(5)), "Results should be in ascending order from 0 to 4"
+    assert sorted(results) == list(
+        range(5)
+    ), "Results should be in ascending order from 0 to 4"
+
 
 @pytest.mark.asyncio_cooperative
 async def test_as_completed_with_mapping():
-    tasks = {'task1': sample_task(1), 'task2': sample_task(2)}
+    tasks = {"task1": sample_task(1), "task2": sample_task(2)}
     results = {}
     for result in a_sync.as_completed(tasks, aiter=False):
         key, value = await result
         results[key] = value
-    assert results == {'task1': 1, 'task2': 2}, "Results should match the input mapping"
+    assert results == {"task1": 1, "task2": 2}, "Results should match the input mapping"
+
 
 @pytest.mark.asyncio_cooperative
 async def test_as_completed_with_mapping_aiter():
-    tasks = {'task1': sample_task(1), 'task2': sample_task(2)}
+    tasks = {"task1": sample_task(1), "task2": sample_task(2)}
     results = {}
     async for key, result in a_sync.as_completed(tasks, aiter=True):
         results[key] = result
-    assert results == {'task1': 1, 'task2': 2}, "Results should match the input mapping"
+    assert results == {"task1": 1, "task2": 2}, "Results should match the input mapping"
+
 
 @pytest.mark.asyncio_cooperative
 async def test_as_completed_with_timeout():
     tasks = [timeout_task(i) for i in range(2)]
     with pytest.raises(asyncio.TimeoutError):
-        [await result for result in a_sync.as_completed(tasks, aiter=False, timeout=0.05)]
+        [
+            await result
+            for result in a_sync.as_completed(tasks, aiter=False, timeout=0.05)
+        ]
+
 
 @pytest.mark.asyncio_cooperative
 async def test_as_completed_with_timeout_aiter():
     tasks = [timeout_task(i) for i in range(2)]
     with pytest.raises(asyncio.TimeoutError):
-        [result async for result in a_sync.as_completed(tasks, aiter=True, timeout=0.05)]
+        [
+            result
+            async for result in a_sync.as_completed(tasks, aiter=True, timeout=0.05)
+        ]
+
 
 @pytest.mark.asyncio_cooperative
 async def test_as_completed_return_exceptions():
     tasks = [sample_exc(i) for i in range(1)]
-    results = [await result for result in a_sync.as_completed(tasks, aiter=False, return_exceptions=True)]
-    assert isinstance(results[0], ValueError), f"The result should be an exception {results}"
+    results = [
+        await result
+        for result in a_sync.as_completed(tasks, aiter=False, return_exceptions=True)
+    ]
+    assert isinstance(
+        results[0], ValueError
+    ), f"The result should be an exception {results}"
+
 
 @pytest.mark.asyncio_cooperative
 async def test_as_completed_return_exceptions_aiter():
@@ -64,11 +85,17 @@ async def test_as_completed_return_exceptions_aiter():
         results.append(result)
     assert isinstance(results[0], ValueError), "The result should be an exception"
 
+
 @pytest.mark.asyncio_cooperative
 async def test_as_completed_with_tqdm_disabled():
     tasks = [sample_task(i) for i in range(5)]
-    results = [await result for result in a_sync.as_completed(tasks, aiter=False, tqdm=False)]
-    assert sorted(results) == list(range(5)), "Results should be in ascending order from 0 to 4"
+    results = [
+        await result for result in a_sync.as_completed(tasks, aiter=False, tqdm=False)
+    ]
+    assert sorted(results) == list(
+        range(5)
+    ), "Results should be in ascending order from 0 to 4"
+
 
 @pytest.mark.asyncio_cooperative
 async def test_as_completed_with_tqdm_disabled_aiter():
@@ -76,23 +103,29 @@ async def test_as_completed_with_tqdm_disabled_aiter():
     results = []
     async for result in a_sync.as_completed(tasks, aiter=True, tqdm=False):
         results.append(result)
-    assert sorted(results) == list(range(5)), "Results should be in ascending order from 0 to 4"
+    assert sorted(results) == list(
+        range(5)
+    ), "Results should be in ascending order from 0 to 4"
+
 
 @pytest.mark.asyncio_cooperative
 async def test_as_completed_with_mapping_and_return_exceptions():
-    tasks = {'task1': sample_exc(1), 'task2': sample_task(2)}
+    tasks = {"task1": sample_exc(1), "task2": sample_task(2)}
     results = {}
     for result in a_sync.as_completed(tasks, return_exceptions=True, aiter=False):
         key, value = await result
         results[key] = value
-    assert isinstance(results['task1'], ValueError), "Result should be ValueError"
-    assert results['task2'] == 2, "Results should match the input mapping"
+    assert isinstance(results["task1"], ValueError), "Result should be ValueError"
+    assert results["task2"] == 2, "Results should match the input mapping"
+
 
 @pytest.mark.asyncio_cooperative
 async def test_as_completed_with_mapping_and_return_exceptions_aiter():
-    tasks = {'task1': sample_exc(1), 'task2': sample_task(2)}
+    tasks = {"task1": sample_exc(1), "task2": sample_task(2)}
     results = {}
-    async for key, result in a_sync.as_completed(tasks, return_exceptions=True, aiter=True):
+    async for key, result in a_sync.as_completed(
+        tasks, return_exceptions=True, aiter=True
+    ):
         results[key] = result
-    assert isinstance(results['task1'], ValueError), "Result should be ValueError"
-    assert results['task2'] == 2, "Results should match the input mapping"
+    assert isinstance(results["task1"], ValueError), "Result should be ValueError"
+    assert results["task2"] == 2, "Results should match the input mapping"

tests/test_base.py

@@ -1,4 +1,3 @@
-
 import asyncio
 import time
 
@@ -9,7 +8,14 @@ from a_sync.a_sync.base import ASyncGenericBase
 from a_sync.a_sync._meta import ASyncMeta
 from a_sync.a_sync.method import ASyncBoundMethodAsyncDefault
 from a_sync.exceptions import SyncModeInAsyncContextError
-from tests.fixtures import TestClass, TestInheritor, TestMeta, increment, TestSync, WrongThreadError
+from tests.fixtures import (
+    TestClass,
+    TestInheritor,
+    TestMeta,
+    increment,
+    TestSync,
+    WrongThreadError,
+)
 
 
 def test_base_direct_init():
@@ -17,9 +23,10 @@ def test_base_direct_init():
         ASyncGenericBase()
 
 
-classes = pytest.mark.parametrize('cls', [TestClass, TestSync, TestInheritor, TestMeta])
+classes = pytest.mark.parametrize("cls", [TestClass, TestSync, TestInheritor, TestMeta])
+
+both_modes = pytest.mark.parametrize("sync", [True, False])
 
-both_modes = pytest.mark.parametrize('sync', [True, False])
 
 @classes
 @both_modes
@@ -28,12 +35,13 @@ def test_inheritance(cls, sync: bool):
     assert isinstance(instance, ASyncGenericBase)
     assert isinstance(instance.__class__, ASyncMeta)
 
+
 @classes
 @increment
 def test_method_sync(cls: type, i: int):
     sync_instance = cls(i, sync=True)
     assert sync_instance.test_fn() == i
-    
+
     # Can we override with kwargs?
     assert sync_instance.test_fn(sync=True) == i
     assert sync_instance.test_fn(asynchronous=False) == i
@@ -42,12 +50,27 @@ def test_method_sync(cls: type, i: int):
     if isinstance(sync_instance, TestSync):
         # this raises an assertion error inside of the test_fn execution. this is okay.
         with pytest.raises(WrongThreadError):
-            asyncio.get_event_loop().run_until_complete(sync_instance.test_fn(sync=False))
+            asyncio.get_event_loop().run_until_complete(
+                sync_instance.test_fn(sync=False)
+            )
         with pytest.raises(WrongThreadError):
-            asyncio.get_event_loop().run_until_complete(sync_instance.test_fn(asynchronous=True))
+            asyncio.get_event_loop().run_until_complete(
+                sync_instance.test_fn(asynchronous=True)
+            )
     else:
-        assert isinstance(asyncio.get_event_loop().run_until_complete(sync_instance.test_fn(sync=False)), int)
-        assert isinstance(asyncio.get_event_loop().run_until_complete(sync_instance.test_fn(asynchronous=True)), int)
+        assert isinstance(
+            asyncio.get_event_loop().run_until_complete(
+                sync_instance.test_fn(sync=False)
+            ),
+            int,
+        )
+        assert isinstance(
+            asyncio.get_event_loop().run_until_complete(
+                sync_instance.test_fn(asynchronous=True)
+            ),
+            int,
+        )
+
 
 @classes
 @increment
@@ -58,7 +81,7 @@ async def test_method_async(cls: type, i: int):
         # this raises an assertion error inside of the test_fn execution. this is okay.
         with pytest.raises(WrongThreadError):
             assert await async_instance.test_fn() == i
-            
+
         # Can we override with kwargs?
         with pytest.raises(WrongThreadError):
             async_instance.test_fn(sync=True)
@@ -84,7 +107,7 @@ async def test_method_async(cls: type, i: int):
 def test_property_sync(cls: type, i: int):
     sync_instance = cls(i, sync=True)
     assert sync_instance.test_property == i * 2
-    
+
     # Can we access hidden methods for properties?
     getter = sync_instance.__test_property__
     assert isinstance(getter, HiddenMethod), getter
@@ -92,6 +115,7 @@ def test_property_sync(cls: type, i: int):
     assert asyncio.iscoroutine(getter_coro), getter_coro
     assert asyncio.get_event_loop().run_until_complete(getter_coro) == i * 2
 
+
 @classes
 @increment
 @pytest.mark.asyncio_cooperative
@@ -117,7 +141,9 @@ def test_cached_property_sync(cls: type, i: int):
     assert sync_instance.test_cached_property == i * 3
     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 access hidden methods for properties?
     start = time.time()
@@ -128,9 +154,17 @@ def test_cached_property_sync(cls: type, i: int):
     assert asyncio.get_event_loop().run_until_complete(getter_coro) == i * 3
 
     # Can we override them too?
-    assert asyncio.get_event_loop().run_until_complete(sync_instance.__test_cached_property__(sync=False)) == i * 3
+    assert (
+        asyncio.get_event_loop().run_until_complete(
+            sync_instance.__test_cached_property__(sync=False)
+        )
+        == i * 3
+    )
     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
@@ -146,7 +180,7 @@ async def test_cached_property_async(cls: type, i: int):
     getter_coro = getter()
     assert asyncio.iscoroutine(getter_coro), getter_coro
     assert await getter_coro == i * 3
-    
+
     # Can we override them too?
     with pytest.raises(SyncModeInAsyncContextError):
         getter(sync=True)
@@ -156,7 +190,9 @@ async def test_cached_property_async(cls: type, i: int):
     duration = time.time() - start
     # For TestSync, the duration can be higher because the calls execute inside of a threadpool which limits the amount of concurrency.
     target_duration = 5 if isinstance(async_instance, TestSync) else 2.1
-    assert duration < target_duration, "There is a 2 second sleep in 'test_cached_property' but it should only run once."
+    assert (
+        duration < target_duration
+    ), "There is a 2 second sleep in 'test_cached_property' but it should only run once."
 
 
 @pytest.mark.asyncio_cooperative
@@ -166,6 +202,7 @@ async def test_asynchronous_context_manager():
         async def __aenter__(self):
             self.entered = True
             return self
+
         async def __aexit__(self, exc_type, exc_val, exc_tb):
             self.exited = True
 
@@ -173,6 +210,7 @@ async def test_asynchronous_context_manager():
         assert cm.entered
     assert cm.exited
 
+
 def test_synchronous_context_manager():
     # Can the implementation work with a context manager?
 
@@ -180,6 +218,7 @@ def test_synchronous_context_manager():
         def __enter__(self):
             self.entered = True
             return self
+
         def __exit__(self, exc_type, exc_val, exc_tb):
             self.exited = True
 
@@ -187,33 +226,41 @@ def test_synchronous_context_manager():
         assert cm.entered
     assert cm.exited
 
+
 @pytest.mark.asyncio_cooperative
 async def test_asynchronous_iteration():
     # Does the implementation screw anything up with aiteration?
     class ASyncObjectWithAiter(ASyncGenericBase):
         def __init__(self):
             self.count = 0
+
         def __aiter__(self):
             return self
+
         async def __anext__(self):
             if self.count < 3:
                 self.count += 1
                 return self.count
             raise StopAsyncIteration
+
     assert [item async for item in ASyncObjectWithAiter()] == [1, 2, 3]
 
+
 def test_synchronous_iteration():
     # Does the implementation screw anything up with iteration?
     class ASyncObjectWithIter(ASyncGenericBase):
         def __init__(self):
             self.count = 0
+
         def __iter__(self):
             return self
+
         def __next__(self):
             if self.count < 3:
                 self.count += 1
                 return self.count
             raise StopIteration
+
     assert list(ASyncObjectWithIter()) == [1, 2, 3]
 
 
@@ -223,13 +270,15 @@ class ClassWithGenFunc(ASyncGenericBase):
         yield 1
         yield 2
 
+
 def test_bound_generator_meta_sync():
     """Does the metaclass handle generator functions correctly?"""
     for _ in ClassWithGenFunc().generate():
         assert isinstance(_, int)
 
+
 @pytest.mark.asyncio_cooperative
 async def test_bound_generator_meta_async():
     """Does the metaclass handle generator functions correctly?"""
     async for _ in ClassWithGenFunc().generate():
-        assert isinstance(_, int)
+        assert isinstance(_, int)