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

a_sync/primitives/locks/semaphore.py

@@ -18,31 +18,34 @@ logger = logging.getLogger(__name__)
 
 class Semaphore(asyncio.Semaphore, _DebugDaemonMixin):
     """
-    A semaphore with additional debugging capabilities.
+    A semaphore with additional debugging capabilities inherited from :class:`_DebugDaemonMixin`.
 
-    This semaphore includes debug logging and can be used to decorate coroutine functions.
+    This semaphore includes debug logging capabilities that are activated when the semaphore has waiters.
     It allows rewriting the pattern of acquiring a semaphore within a coroutine using a decorator.
 
-    So you can write this pattern:
+    Example:
+        You can write this pattern:
 
-    ```
-    semaphore = Semaphore(5)
+        ```
+        semaphore = Semaphore(5)
 
-    async def limited():
-        async with semaphore:
-            return 1
+        async def limited():
+            async with semaphore:
+                return 1
+        ```
 
-    ```
+        like this:
 
-    like this:
+        ```
+        semaphore = Semaphore(5)
 
-    ```
-    semaphore = Semaphore(5)
+        @semaphore
+        async def limited():
+            return 1
+        ```
 
-    @semaphore
-    async def limited():
-        return 1
-    ```
+    See Also:
+        :class:`_DebugDaemonMixin` for more details on debugging capabilities.
     """
 
     if sys.version_info >= (3, 10):
@@ -109,6 +112,14 @@ class Semaphore(asyncio.Semaphore, _DebugDaemonMixin):
         return semaphore_wrapper
 
     async def acquire(self) -> Literal[True]:
+        """
+        Acquire the semaphore, ensuring that debug logging is enabled if there are waiters.
+
+        If the semaphore value is zero or less, the debug daemon is started to log the state of the semaphore.
+
+        Returns:
+            True when the semaphore is successfully acquired.
+        """
         if self._value <= 0:
             self._ensure_debug_daemon()
         return await super().acquire()
@@ -116,6 +127,15 @@ class Semaphore(asyncio.Semaphore, _DebugDaemonMixin):
     async def _debug_daemon(self) -> None:
         """
         Daemon coroutine (runs in a background task) which will emit a debug log every minute while the semaphore has waiters.
+
+        This method is part of the :class:`_DebugDaemonMixin` and is used to provide detailed logging information
+        about the semaphore's state when it is being waited on.
+
+        Example:
+            semaphore = Semaphore(5)
+
+            async def monitor():
+                await semaphore._debug_daemon()
         """
         while self._waiters:
             await asyncio.sleep(60)
@@ -129,6 +149,13 @@ class DummySemaphore(asyncio.Semaphore):
     A dummy semaphore that implements the standard :class:`asyncio.Semaphore` API but does nothing.
 
     This class is useful for scenarios where a semaphore interface is required but no actual synchronization is needed.
+
+    Example:
+        dummy_semaphore = DummySemaphore()
+
+        async def no_op():
+            async with dummy_semaphore:
+                return 1
     """
 
     __slots__ = "name", "_value"
@@ -149,11 +176,14 @@ class DummySemaphore(asyncio.Semaphore):
     async def acquire(self) -> Literal[True]:
         return True
 
-    def release(self) -> None: ...
+    def release(self) -> None:
+        """No-op release method."""
 
-    async def __aenter__(self): ...
+    async def __aenter__(self):
+        """No-op context manager entry."""
 
-    async def __aexit__(self, *args): ...
+    async def __aexit__(self, *args):
+        """No-op context manager exit."""
 
 
 class ThreadsafeSemaphore(Semaphore):
@@ -161,7 +191,18 @@ class ThreadsafeSemaphore(Semaphore):
     A semaphore that works in a multi-threaded environment.
 
     This semaphore ensures that the program functions correctly even when used with multiple event loops.
-    It provides a workaround for edge cases involving multiple threads and event loops.
+    It provides a workaround for edge cases involving multiple threads and event loops by using a separate semaphore
+    for each thread.
+
+    Example:
+        semaphore = ThreadsafeSemaphore(5)
+
+        async def limited():
+            async with semaphore:
+                return 1
+
+    See Also:
+        :class:`Semaphore` for the base class implementation.
     """
 
     __slots__ = "semaphores", "dummy"
@@ -198,6 +239,13 @@ class ThreadsafeSemaphore(Semaphore):
         Returns the appropriate semaphore for the current thread.
 
         NOTE: We can't cache this property because we need to check the current thread every time we access it.
+
+        Example:
+            semaphore = ThreadsafeSemaphore(5)
+
+            async def limited():
+                async with semaphore.semaphore:
+                    return 1
         """
         return self.dummy if self.use_dummy else self.semaphores[current_thread()]
 

a_sync/primitives/queue.py

@@ -1,8 +1,16 @@
 """
-This module provides various queue implementations for managing asynchronous tasks, 
-including standard FIFO queues, priority queues, and processing queues.
-# TODO specify a list of specific objects with a brief description + use case example instead of being vague like this
-
+This module provides various queue implementations for managing asynchronous tasks. 
+It includes standard FIFO queues, priority queues, and processing queues with enhanced functionality.
+
+Classes:
+    Queue: A generic asynchronous queue that extends the functionality of `asyncio.Queue`.
+    ProcessingQueue: A queue designed for processing tasks asynchronously with multiple workers.
+    PriorityProcessingQueue: A priority-based processing queue where tasks are processed based on priority.
+    SmartProcessingQueue: A processing queue that executes jobs with the most waiters first, supporting dynamic priorities.
+
+See Also:
+    `asyncio.Queue`: The base class for asynchronous FIFO queues.
+    `asyncio.PriorityQueue`: The base class for priority queues.
 """
 
 import asyncio
@@ -38,7 +46,7 @@ else:
 
 class Queue(_Queue[T]):
     """
-    A generic asynchronous queue that extends the functionality of asyncio.Queue.
+    A generic asynchronous queue that extends the functionality of `asyncio.Queue`.
 
     This implementation supports retrieving multiple items at once and handling
     task processing in both FIFO and LIFO order. It provides enhanced type hinting
@@ -66,9 +74,6 @@ class Queue(_Queue[T]):
 
         If the queue is empty, this method will block until an item is available.
 
-        Returns:
-            T: The next item in the queue.
-
         Example:
             >>> result = await queue.get()
             >>> print(result)
@@ -85,9 +90,6 @@ class Queue(_Queue[T]):
         Raises:
             :exc:`~asyncio.QueueEmpty`: If the queue is empty.
 
-        Returns:
-            T: The next item in the queue.
-
         Example:
             >>> result = queue.get_nowait()
             >>> print(result)
@@ -133,9 +135,6 @@ class Queue(_Queue[T]):
         If the queue is empty, this method will wait until at least one item
         is available before returning.
 
-        Returns:
-            List[T]: A list of all items that were in the queue.
-
         Example:
             >>> tasks = await queue.get_all()
             >>> print(tasks)
@@ -155,9 +154,6 @@ class Queue(_Queue[T]):
         Raises:
             :exc:`~asyncio.QueueEmpty`: If the queue is empty.
 
-        Returns:
-            List[T]: A list of all items that were in the queue.
-
         Example:
             >>> tasks = queue.get_all_nowait()
             >>> print(tasks)
@@ -179,9 +175,6 @@ class Queue(_Queue[T]):
             i: The number of items to retrieve.
             can_return_less: If True, may return fewer than `i` items if queue is emptied.
 
-        Returns:
-            List[T]: A list containing the retrieved items.
-
         Raises:
             :exc:`~asyncio.QueueEmpty`: If no items are available and fewer items cannot be returned.
 
@@ -211,9 +204,6 @@ class Queue(_Queue[T]):
         Raises:
             :exc:`~asyncio.QueueEmpty`: If no items are available and fewer items cannot be returned.
 
-        Returns:
-            List[T]: A list containing the retrieved items.
-
         Example:
             >>> tasks = queue.get_multi_nowait(i=3, can_return_less=True)
             >>> print(tasks)
@@ -548,6 +538,9 @@ def _validate_args(i: int, can_return_less: bool) -> None:
 class _SmartFutureRef(weakref.ref, Generic[T]):
     """
     Weak reference for :class:`~_smart.SmartFuture` objects used in priority queues.
+
+    See Also:
+        :class:`~_smart.SmartFuture`
     """
 
     def __lt__(self, other: "_SmartFutureRef[T]") -> bool:
@@ -578,6 +571,9 @@ class _SmartFutureRef(weakref.ref, Generic[T]):
 class _PriorityQueueMixin(Generic[T]):
     """
     Mixin for creating priority queue functionality with support for custom comparison.
+
+    See Also:
+        :class:`~asyncio.PriorityQueue`
     """
 
     def _init(self, maxsize):
@@ -612,7 +608,20 @@ class _PriorityQueueMixin(Generic[T]):
 class PriorityProcessingQueue(_PriorityQueueMixin[T], ProcessingQueue[T, V]):
     """
     A priority-based processing queue where tasks are processed based on priority.
-    # NOTE: WIP
+
+    This queue allows tasks to be added with a specified priority, ensuring that
+    higher priority tasks are processed before lower priority ones. It is ideal
+    for scenarios where task prioritization is crucial.
+
+    Example:
+        >>> async def process_task(data): return data.upper()
+        >>> queue = PriorityProcessingQueue(func=process_task, num_workers=5)
+        >>> fut = await queue.put(priority=1, item='task')
+        >>> print(await fut)
+        TASK
+
+    See Also:
+        :class:`~ProcessingQueue`
     """
 
     async def put(
@@ -679,6 +688,9 @@ class PriorityProcessingQueue(_PriorityQueueMixin[T], ProcessingQueue[T, V]):
 class _VariablePriorityQueueMixin(_PriorityQueueMixin[T]):
     """
     Mixin for priority queues where task priorities can be updated dynamically.
+
+    See Also:
+        :class:`~_PriorityQueueMixin`
     """
 
     def _get(self, heapify=heapq.heapify, heappop=heapq.heappop):
@@ -721,7 +733,20 @@ class _VariablePriorityQueueMixin(_PriorityQueueMixin[T]):
 class VariablePriorityQueue(_VariablePriorityQueueMixin[T], asyncio.PriorityQueue):
     """
     A :class:`~asyncio.PriorityQueue` subclass that allows priorities to be updated (or computed) on the fly.
-    # NOTE: WIP
+
+    This queue supports dynamic priority updates, making it suitable for tasks
+    where priorities may change over time. It ensures that tasks are processed
+    based on the most current priority.
+
+    Example:
+        >>> queue = VariablePriorityQueue()
+        >>> queue.put_nowait((1, 'task1'))
+        >>> queue.put_nowait((2, 'task2'))
+        >>> task = queue.get_nowait()
+        >>> print(task)
+
+    See Also:
+        :class:`~asyncio.PriorityQueue`
     """
 
 
@@ -729,7 +754,21 @@ class SmartProcessingQueue(
     _VariablePriorityQueueMixin[T], ProcessingQueue[Concatenate[T, P], V]
 ):
     """
-    A PriorityProcessingQueue subclass that will execute jobs with the most waiters first
+    A processing queue that will execute jobs with the most waiters first, supporting dynamic priorities.
+
+    This queue is designed to handle tasks with dynamic priorities, ensuring that
+    tasks with the most waiters are prioritized. It is ideal for scenarios where
+    task execution order is influenced by the number of waiters.
+
+    Example:
+        >>> async def process_task(data): return data.upper()
+        >>> queue = SmartProcessingQueue(func=process_task, num_workers=5)
+        >>> fut = await queue.put(item='task')
+        >>> print(await fut)
+        TASK
+
+    See Also:
+        :class:`~ProcessingQueue`
     """
 
     _no_futs = False

a_sync/task.py

@@ -45,21 +45,30 @@ class TaskMapping(DefaultDict[K, "asyncio.Task[V]"], AsyncIterable[Tuple[K, V]])
     """
     A mapping of keys to asynchronous tasks with additional functionality.
 
-    TaskMapping is a specialized dictionary that maps keys to asyncio Tasks. It provides
+    `TaskMapping` is a specialized dictionary that maps keys to `asyncio` Tasks. It provides
     convenient methods for creating, managing, and iterating over these tasks asynchronously.
 
-    Example:
-        async def fetch_data(url: str) -> str:
-            async with aiohttp.ClientSession() as session:
-                async with session.get(url) as response:
-                    return await response.text()
-
-        tasks = TaskMapping(fetch_data, name='url_fetcher', concurrency=5)
-        tasks['example.com'] = 'http://example.com'
-        tasks['python.org'] = 'https://www.python.org'
+    Tasks are created automatically for each key using a provided function. You cannot manually set items in a `TaskMapping` using dictionary-like syntax.
 
-        async for key, result in tasks:
-            print(f"Data for {key}: {result}")
+    Example:
+        >>> async def fetch_data(url: str) -> str:
+        ...     async with aiohttp.ClientSession() as session:
+        ...         async with session.get(url) as response:
+        ...             return await response.text()
+        ...
+        >>> tasks = TaskMapping(fetch_data, ['http://example.com', 'https://www.python.org'], name='url_fetcher', concurrency=5)
+        >>> async for key, result in tasks:
+        ...     print(f"Data for {key}: {result}")
+        ...
+        Data for python.org: http://python.org
+        Data for example.com: http://example.com
+
+    Note:
+        You cannot manually set items in a `TaskMapping` using dictionary-like syntax. Tasks are created and managed internally.
+
+    See Also:
+        - :class:`asyncio.Task`
+        - :func:`asyncio.create_task`
     """
 
     concurrency: Optional[int] = None
@@ -111,6 +120,13 @@ class TaskMapping(DefaultDict[K, "asyncio.Task[V]"], AsyncIterable[Tuple[K, V]])
             name: An optional name for the tasks created by this mapping.
             concurrency: Maximum number of tasks to run concurrently.
             **wrapped_func_kwargs: Additional keyword arguments to be passed to wrapped_func.
+
+        Example:
+            async def process_item(item: int) -> int:
+                await asyncio.sleep(1)
+                return item * 2
+
+            task_map = TaskMapping(process_item, [1, 2, 3], concurrency=2)
         """
 
         if concurrency:
@@ -126,9 +142,11 @@ class TaskMapping(DefaultDict[K, "asyncio.Task[V]"], AsyncIterable[Tuple[K, V]])
         self._wrapped_func = wrapped_func
         "The function used to create tasks for each key."
 
-        if isinstance(wrapped_func, ASyncMethodDescriptor):
-            if _kwargs.get_flag_name(wrapped_func_kwargs) is None:
-                wrapped_func_kwargs["sync"] = False
+        if (
+            isinstance(wrapped_func, ASyncMethodDescriptor)
+            and _kwargs.get_flag_name(wrapped_func_kwargs) is None
+        ):
+            wrapped_func_kwargs["sync"] = False
         if wrapped_func_kwargs:
             self._wrapped_func_kwargs = wrapped_func_kwargs
 
@@ -293,6 +311,15 @@ class TaskMapping(DefaultDict[K, "asyncio.Task[V]"], AsyncIterable[Tuple[K, V]])
         Yields:
             Depending on `yields`, either keys, values,
             or tuples of key-value pairs representing the results of completed tasks.
+
+        Example:
+            async def process_item(item: int) -> int:
+                await asyncio.sleep(1)
+                return item * 2
+
+            task_map = TaskMapping(process_item)
+            async for key, result in task_map.map([1, 2, 3]):
+                print(f"Processed {key}: {result}")
         """
         self._if_pop_check_destroyed(pop)
 
@@ -418,6 +445,15 @@ class TaskMapping(DefaultDict[K, "asyncio.Task[V]"], AsyncIterable[Tuple[K, V]])
 
         Yields:
             Tuples of key-value pairs representing the results of completed tasks.
+
+        Example:
+            async def process_item(item: int) -> int:
+                await asyncio.sleep(1)
+                return item * 2
+
+            task_map = TaskMapping(process_item, [1, 2, 3])
+            async for key, result in task_map.yield_completed():
+                print(f"Completed {key}: {result}")
         """
         if pop:
             for k, task in dict(self).items():

a_sync/utils/iterators.py

@@ -22,11 +22,22 @@ async def exhaust_iterator(
     """
     Asynchronously iterates over items from the given async iterator and optionally places them into a queue.
 
-    This function is a utility to exhaust an async iterator, with an option to forward the iterated items to a provided asyncio.Queue. It's particularly useful when dealing with asynchronous operations that produce items to be consumed by other parts of an application, enabling a producer-consumer pattern.
+    This function is a utility to exhaust an async iterator, with an option to forward the iterated items to a provided queue-like object.
+    The queue should have a `put_nowait` method. This is particularly useful when dealing with asynchronous operations that produce items
+    to be consumed by other parts of an application, enabling a producer-consumer pattern.
 
     Args:
         iterator (AsyncIterator[T]): The async iterator to exhaust.
-        queue (Optional[asyncio.Queue]): An optional queue where iterated items will be placed. If None, items are simply consumed.
+        queue (Optional[asyncio.Queue]): An optional queue-like object where iterated items will be placed.
+            The queue should support the `put_nowait` method. If None, items are simply consumed.
+
+    Example:
+        >>> async def example():
+        >>>     await exhaust_iterator(some_async_iterator, queue=my_queue)
+
+    See Also:
+        - :func:`exhaust_iterators`
+        - :func:`as_yielded`
     """
     async for thing in iterator:
         if queue:
@@ -40,12 +51,24 @@ async def exhaust_iterators(
     """
     Asynchronously iterates over multiple async iterators concurrently and optionally places their items into a queue.
 
-    This function leverages asyncio.gather to concurrently exhaust multiple async iterators. It's useful in scenarios where items from multiple async sources need to be processed or collected together, supporting concurrent operations and efficient multitasking.
+    This function leverages :func:`asyncio.gather` to concurrently exhaust multiple async iterators. It's useful in scenarios where items
+    from multiple async sources need to be processed or collected together, supporting concurrent operations and efficient multitasking.
 
     Args:
         iterators: A sequence of async iterators to be exhausted concurrently.
-        queue (Optional[asyncio.Queue]): An optional queue where items from all iterators will be placed. If None, items are simply consumed.
+        queue (Optional[Queue]): An optional queue-like object where items from all iterators will be placed. If None, items are simply consumed.
         join (Optional[bool]): If a queue was provided and join is True, this coroutine will continue to run until all queue items have been processed.
+
+    Raises:
+        ValueError: If `join` is True but no `queue` is provided.
+
+    Example:
+        >>> async def example():
+        >>>     await exhaust_iterators([iterator1, iterator2], queue=my_queue, join=True)
+
+    See Also:
+        - :func:`exhaust_iterator`
+        - :func:`as_yielded`
     """
     for x in await asyncio.gather(
         *[exhaust_iterator(iterator, queue=queue) for iterator in iterators],
@@ -167,17 +190,31 @@ async def as_yielded(*iterators: AsyncIterator[T]) -> AsyncIterator[T]:  # type:
     """
     Merges multiple async iterators into a single async iterator that yields items as they become available from any of the source iterators.
 
-    This function is designed to streamline the handling of multiple asynchronous data streams by consolidating them into a single asynchronous iteration context. It enables concurrent fetching and processing of items from multiple sources, improving efficiency and simplifying code structure when dealing with asynchronous operations.
+    This function is designed to streamline the handling of multiple asynchronous data streams by consolidating them into a single asynchronous iteration context.
+    It enables concurrent fetching and processing of items from multiple sources, improving efficiency and simplifying code structure when dealing with asynchronous operations.
 
-    The merging process is facilitated by internally managing a queue where items from the source iterators are placed as they are fetched. This mechanism ensures that the merged stream of items is delivered in an order determined by the availability of items from the source iterators, rather than their original sequence.
+    The merging process is facilitated by the :func:`exhaust_iterators` function, which concurrently processes the source iterators and places their items into a queue.
+    This mechanism ensures that the merged stream of items is delivered in an order determined by the availability of items from the source iterators, rather than their original sequence.
 
-    The function handles exceptions and ensures robustness and reliability by using asyncio tasks and queues. It manages edge cases such as early termination and exception management. The `_Done` sentinel class is used internally to signal the completion of processing.
+    The function handles exceptions and ensures robustness and reliability by using asyncio tasks and queues. It manages edge cases such as early termination and exception management.
+    The :class:`_Done` sentinel class is used internally to signal the completion of processing.
 
     Args:
-        *iterators: Variable length list of AsyncIterator objects to be merged.
+        *iterators: Variable length list of :class:`~collections.abc.AsyncIterator` objects to be merged.
 
     Note:
-        This implementation leverages asyncio tasks and queues to efficiently manage the asynchronous iteration and merging process. It handles edge cases such as early termination and exception management, ensuring robustness and reliability. The `_Done` sentinel class is used internally to signal the completion of processing.
+        This implementation leverages asyncio tasks and queues to efficiently manage the asynchronous iteration and merging process.
+        It handles edge cases such as early termination and exception management, ensuring robustness and reliability.
+        The :class:`_Done` sentinel class is used internally to signal the completion of processing.
+
+    Example:
+        >>> async def example():
+        >>>     async for item in as_yielded(iterator1, iterator2):
+        >>>         print(item)
+
+    See Also:
+        - :func:`exhaust_iterator`
+        - :func:`exhaust_iterators`
     """
     # hypothesis idea: _Done should never be exposed to user, works for all desired input types
     queue: Queue[Union[T, _Done]] = Queue()
@@ -224,17 +261,16 @@ async def as_yielded(*iterators: AsyncIterator[T]) -> AsyncIterator[T]:  # type:
 
 class _Done:
     """
-    A sentinel class used to signal the completion of processing in the as_yielded function.
+    A sentinel class used to signal the completion of processing in the :func:`as_yielded` function.
+
+    This class acts as a marker to indicate that all items have been processed and the asynchronous iteration can be concluded.
+    It is used internally within the implementation of :func:`as_yielded` to efficiently manage the termination of the iteration process once all source iterators have been exhausted.
 
-    This class acts as a marker to indicate that all items have been processed and the asynchronous iteration can be concluded. It is used internally within the implementation of as_yielded to efficiently manage the termination of the iteration process once all source iterators have been exhausted.
+    Args:
+        exc (Optional[Exception]): An optional exception to be associated with the completion.
     """
 
     def __init__(self, exc: Optional[Exception] = None) -> None:
-        """Initializes the _Done sentinel.
-
-        Args:
-            exc (Optional[Exception]): An optional exception to be associated with the completion.
-        """
         self._exc = exc
 
     @property

{ez_a_sync-0.22.15.dist-info → ez_a_sync-0.22.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ez-a-sync
-Version: 0.22.15
+Version: 0.22.16
 Summary: A library that makes it easy to define objects that can be used for both sync and async use cases.
 Home-page: https://github.com/BobTheBuidler/a-sync
 Author: BobTheBuidler

ez_a_sync-0.22.16.dist-info/RECORD

@@ -0,0 +1,74 @@
+a_sync/ENVIRONMENT_VARIABLES.py,sha256=JHTnvIA5rEXWLqMwNeJ2ewFwVqyg9T6CYcrdxWnnfyo,1309
+a_sync/__init__.py,sha256=wJdpi219HqUD4dN-zLK1VNE-3K_R2aa_R98ZnbVILL8,4787
+a_sync/_smart.py,sha256=qd6hkURaVHZZ1i9L88cJDv6SF7MnJM5bmrVGVQ12KuA,11526
+a_sync/_typing.py,sha256=M7ZzA6iUSl8Ur4zdySJLxWKk9CdA_kSHjbV0j72CRgQ,6628
+a_sync/aliases.py,sha256=TbLyuLeFfJEmcC5-NP6h4DQ9QXlQjGny2NUP_x1tflw,212
+a_sync/exceptions.py,sha256=Zm1YG55ApYF1NWciIkRpTgLMlgyCcAk6MadHTgwvhbs,12680
+a_sync/executor.py,sha256=4YzCSWPbas3sPeOJO-S-cwo1dLk-eq20F6bMVqZvxAA,14994
+a_sync/future.py,sha256=PxR1nm5DOYohDE5CWD7HXgzdP_3GDUg0_oFVBLvn7_A,48827
+a_sync/iter.py,sha256=KelwlPfUU5XIPgMpimIV4VwAjiRhOzRc2fK1TG5tTmY,23225
+a_sync/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+a_sync/task.py,sha256=dqi4TA8uIkONqHDMt1DUmotCbmhGwAR6iSbrA-h3SwI,32376
+a_sync/a_sync/__init__.py,sha256=qENRGhOVdj0uwYHqGZwDdTTYDepvpb0qjzVJn7Nco78,1814
+a_sync/a_sync/_descriptor.py,sha256=oO0AEfPVFGhG-YosH3G8-vUJM3ZU7PRwMDGNCP8XjSI,13537
+a_sync/a_sync/_flags.py,sha256=ZxlbF0OdGP-35dc5VjSh1YIGvbailrXaEOg1ZhYsjgs,3640
+a_sync/a_sync/_helpers.py,sha256=Emy4iiWHCw8e0HmqeihgQHKKCkGFax3tRlnUFjz8fCg,3144
+a_sync/a_sync/_kwargs.py,sha256=130eL6M54DUEDERA9Jn8V2kz8AZqraVsNC55ovyvS5s,2008
+a_sync/a_sync/_meta.py,sha256=psCfXKFY85OH8biUr-KT6Ew_YE0UOjficWtPdq4qMCE,9577
+a_sync/a_sync/abstract.py,sha256=OAkIqO6Zqm6QZfrmclpn85nsXJhI0v1aBFQwfwYsqoQ,7347
+a_sync/a_sync/base.py,sha256=rZolx0B4Dof84ahC3pfTDTQe4laZppNnAcliAmNkjDw,7431
+a_sync/a_sync/config.py,sha256=K7KunG2cvOfKic8BzShgvIgOY7GFa0p_S4S1lzPkqeY,5251
+a_sync/a_sync/decorator.py,sha256=O1m6kTBMCjV5coZRLHZoEsjbw0R4DQXD2huDehAi2qg,17039
+a_sync/a_sync/function.py,sha256=06kgIoYISmEc4AbvxL_G_d-3inc7V6atdE5HVZsXowA,40721
+a_sync/a_sync/method.py,sha256=s3nA1VrOo-wwiZd3gEosL1ERYLlps-IAhppgOJptzAw,32448
+a_sync/a_sync/property.py,sha256=llVqhVksV717ejaDBne7DHBuuMUmHdlsW83wcTElQJQ,25203
+a_sync/a_sync/singleton.py,sha256=fdzGGX8QeUTndE_7VQSzvZUe0NAWQ1vWLq_y2Ruo1Ws,2414
+a_sync/a_sync/modifiers/__init__.py,sha256=zi1qI3paHjXxFGx2J2fX5EuWAgvY_-5MYFLwv931he4,4120
+a_sync/a_sync/modifiers/limiter.py,sha256=YCEgmu_Cm06kq16F5YA2wMie9pgS-VZQ3U_WhgkO-Ps,4308
+a_sync/a_sync/modifiers/manager.py,sha256=5VWhsP1xF5zxZwq8q2IICqIRwnqD_lvqVsaVHB_eY3k,7152
+a_sync/a_sync/modifiers/semaphores.py,sha256=a6pUablxdXkSVpXpzUFk1lnfsu0U4yFXAoKZyt-u26Q,6796
+a_sync/a_sync/modifiers/cache/__init__.py,sha256=PMydVB29OhcBqhHGZnRDwdoObIvEYxkbqcbko4ZY8g8,5389
+a_sync/a_sync/modifiers/cache/memory.py,sha256=6w-C7q_K_ccPvYd6Jl0W2xYsg2JKLR_FmrWrfyIebfE,5394
+a_sync/asyncio/__init__.py,sha256=IBAciQTCGADpg3Omwnb9zw-MXUk40Gu6Yo_7ZMZk8sA,6135
+a_sync/asyncio/as_completed.py,sha256=xIvgyuN20JKMFakLlyJ_Vm1LpAZIU5KdQUkkKqMQT20,9402
+a_sync/asyncio/create_task.py,sha256=f3_PPdhK4lqDvJWSiI2SWaV0oa6iYliUlLnWi6JalZM,5078
+a_sync/asyncio/gather.py,sha256=AcqE0RGCCDA9SMtIgIMRZmfm0rjHEkREibA2L40Mx3Y,8072
+a_sync/asyncio/utils.py,sha256=C9XmHO_zU0-Cgob9_YYmqGfyjYyskKqySqyvUcWo7LU,391
+a_sync/primitives/__init__.py,sha256=zpmDwVSUOknQyIOTedyhwRWygiXSmYvjdl83oFAr1Rk,737
+a_sync/primitives/_debug.py,sha256=utZn33eYUzZAlf1VG5OPkBpHVCYV8gdj_YAJHQhvVsM,5073
+a_sync/primitives/_loggable.py,sha256=Ki7lLrTwdCXhnZ18Ns3mEOCJJcLFp8SVntzwzjVFjAM,2067
+a_sync/primitives/queue.py,sha256=BmgYNFm3k3czTkjFwwcH3rTNyUMXDRyEaRpqLohjAc4,30261
+a_sync/primitives/locks/__init__.py,sha256=zKSLeCUgMGSbuXN6ehb2dm0-4lbk-Ze8_ldatWEjy4Y,283
+a_sync/primitives/locks/counter.py,sha256=o7aAnEEG04Yybcbr1FbSpzjVM3JzXwXDvDTlZeNtZ6I,7276
+a_sync/primitives/locks/event.py,sha256=U1suI0OZEH8X3jxF_MChGUtuhemLzROqqd6a7bpHM8E,2974
+a_sync/primitives/locks/prio_semaphore.py,sha256=QNVOVk0m9509viBqEzruze_IKnIKBOarKj_xs42AERA,14755
+a_sync/primitives/locks/semaphore.py,sha256=8EZExO0L_bFCmSFzxaZO9oIqWNTIS4LMnYvukQncZwQ,8120
+a_sync/sphinx/__init__.py,sha256=UvdsakVmkn0Lw4vEd3jA3_Acymde95-78o87lel8ikk,49
+a_sync/sphinx/ext.py,sha256=3ktEWH1brCbHZi2m4BGwglfLyA5JjF05cB0e_c-MVTg,8997
+a_sync/utils/__init__.py,sha256=4JiGSyL5Jj2G7cAmeQN6fxwFnzyOtWYd9IeX8BhrR2k,3223
+a_sync/utils/iterators.py,sha256=jTeLdR5sAqUcB20ZnKZkwVNjJH3QBKgv4kw4yqlV5yI,10723
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/conftest.py,sha256=cZPQoOF3h1OtsFzEb7Jkx54COExVdf0XfD0LZBrmqcg,57
+tests/executor.py,sha256=7B1SWNM--gYcqgTgFXL_e0yHGGY2xuC5Fo6hozkOWqw,8594
+tests/fixtures.py,sha256=4j3GsopNo6tMFOyhWOb8Hnwcwiw2Xdjee4r1YLH1JBE,5774
+tests/test_abstract.py,sha256=bYV06gMvdnjU3KQJZEU5pvljgeaGcbnQnIQQn8yuVo8,1158
+tests/test_as_completed.py,sha256=_oy8L4xmK7NvpAaNPLdM6wwPtSD54nGxwQucK9pDvMg,4527
+tests/test_base.py,sha256=FkcDjam4wR3Bm5TDx5ZI6mlEENSXlzDruIP6YIt4_MI,16630
+tests/test_cache.py,sha256=lgcULExF1Nw4cjvujVvxub5CROqatf6TOkluUSVypIY,2562
+tests/test_decorator.py,sha256=OMV2H6JjmGftdIFd5hgHBt80SF29AX8HtvvdyL8covg,3670
+tests/test_executor.py,sha256=OG3cUeTq0MQkMg-hTsAh8qQqEqYMUaslX3xhXE_zkxA,1950
+tests/test_future.py,sha256=9UUFAh6eP1HFkLchprpcnBjKH7TETZr48k-WUt2PKGc,3433
+tests/test_gather.py,sha256=cjl20RIGbLNMn8hhEw9hFQ7qjWpLHIXVDVrAm6H5u4w,1382
+tests/test_helpers.py,sha256=68DBihIMqAIQLkAS89yutfDv3bPsrgIShad7JS6Bqv0,349
+tests/test_iter.py,sha256=jUaRiZMbfOu3HbGPXnijI2C11uXqde62gcPGG71v6m4,8995
+tests/test_limiter.py,sha256=3nyrikkThrTXrx_7J4gR9ZCNXTYIdrgkXF9Av_T1wqc,829
+tests/test_meta.py,sha256=NZyt6tjzypSJO2byY8NuthCXi545SdSeSDp8KBUkp1Q,3663
+tests/test_modified.py,sha256=_O0-HUJLCC4Ok12QtDjT1_OyLJYDgP0K3O0XhrZTGYs,250
+tests/test_semaphore.py,sha256=8WxfS-0eSlrWyRi-x_-KopsGEp_9oX4TgH2QB1DOnCM,1666
+tests/test_singleton.py,sha256=krzO5QOhLIEV4PPpiHnNw-dFisTCemFcggWxh6lXAZw,1033
+tests/test_task.py,sha256=xtTXdKHUEwQnNIZcMcAk_Xto5YJ0G-qt9Pkq9Dfdmwk,10271
+ez_a_sync-0.22.16.dist-info/LICENSE.txt,sha256=1on6-17OUMlja6vSPTcmlmeT_DwujCZJijYxaplBvZk,1075
+ez_a_sync-0.22.16.dist-info/METADATA,sha256=7IGGj1Gj5HHVv7Z5Fu1NZNeKZDgMZW_p2O_ZwRLBjw0,533
+ez_a_sync-0.22.16.dist-info/WHEEL,sha256=R06PA3UVYHThwHvxuRWMqaGcr-PuniXahwjmQRFMEkY,91
+ez_a_sync-0.22.16.dist-info/top_level.txt,sha256=GVK_7kp7dgBLeHp84iIQdsJmiXnrXd-5sIf2x0Q-VKc,13
+ez_a_sync-0.22.16.dist-info/RECORD,,

{ez_a_sync-0.22.15.dist-info → ez_a_sync-0.22.16.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.4.0)
+Generator: setuptools (75.5.0)
 Root-Is-Purelib: true
 Tag: py3-none-any