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

a_sync/iter.py

@@ -1,4 +1,3 @@
-
 import asyncio
 import functools
 import inspect
@@ -22,6 +21,7 @@ else:
     SortKey = SyncFn[[T], bool]
     ViewFn = AnyFn[[T], bool]
 
+
 class _AwaitableAsyncIterableMixin(AsyncIterable[T]):
     """
     A mixin class defining logic for making an AsyncIterable awaitable.
@@ -30,24 +30,23 @@ class _AwaitableAsyncIterableMixin(AsyncIterable[T]):
 
     Example:
         You must subclass this mixin class and define your own `__aiter__` method as shown below.
-        ```
+
         >>> class MyAwaitableAIterable(_AwaitableAsyncIterableMixin):
-        ...    def __aiter__(self):
+        ...    async def __aiter__(self):
         ...        for i in range(4):
         ...            yield i
-        ... 
+
         >>> aiterable = MyAwaitableAIterable()
         >>> await aiterable
-        [0, 1, 2, 3, 4]
-
-        ```
+        [0, 1, 2, 3]
     """
+
     __wrapped__: AsyncIterable[T]
-    
+
     def __await__(self) -> Generator[Any, Any, List[T]]:
         """
         Asynchronously iterate through the {cls} and return all objects.
-        
+
         Returns:
             A list of the objects yielded by the {cls}.
         """
@@ -57,13 +56,15 @@ class _AwaitableAsyncIterableMixin(AsyncIterable[T]):
     def materialized(self) -> List[T]:
         """
         Synchronously iterate through the {cls} and return all objects.
-        
+
         Returns:
             A list of the objects yielded by the {cls}.
         """
         return _helpers._await(self._materialized)
 
-    def sort(self, *, key: SortKey[T] = None, reverse: bool = False) -> "ASyncSorter[T]":
+    def sort(
+        self, *, key: SortKey[T] = None, reverse: bool = False
+    ) -> "ASyncSorter[T]":
         """
         Sort the contents of the {cls}.
 
@@ -92,7 +93,7 @@ class _AwaitableAsyncIterableMixin(AsyncIterable[T]):
     async def _materialized(self) -> List[T]:
         """
         Asynchronously iterate through the {cls} and return all objects.
-        
+
         Returns:
             A list of the objects yielded by the {cls}.
         """
@@ -106,7 +107,7 @@ class _AwaitableAsyncIterableMixin(AsyncIterable[T]):
             cls.__doc__ = new
         else:
             cls.__doc__ += f"\n\n{new}"
-    
+
         # format the member docstrings
         for attr_name in dir(cls):
             attr = getattr(cls, attr_name, None)
@@ -115,27 +116,40 @@ class _AwaitableAsyncIterableMixin(AsyncIterable[T]):
 
         return super().__init_subclass__(**kwargs)
 
-    __slots__ = '__async_property__', 
-    
+    __slots__ = ("__async_property__",)
+
+
 class ASyncIterable(_AwaitableAsyncIterableMixin[T], Iterable[T]):
     """
     A hybrid Iterable/AsyncIterable implementation designed to offer dual compatibility with both synchronous and asynchronous iteration protocols.
-    
+
     This class allows objects to be iterated over using either a standard `for` loop or an `async for` loop, making it versatile in scenarios where the mode of iteration (synchronous or asynchronous) needs to be flexible or is determined at runtime.
 
     The class achieves this by implementing both `__iter__` and `__aiter__` methods, enabling it to return appropriate iterator objects that can handle synchronous and asynchronous iteration, respectively. This dual functionality is particularly useful in codebases that are transitioning between synchronous and asynchronous code, or in libraries that aim to support both synchronous and asynchronous usage patterns without requiring the user to manage different types of iterable objects.
     """
+
     @classmethod
     def wrap(cls, wrapped: AsyncIterable[T]) -> "ASyncIterable[T]":
         "Class method to wrap an AsyncIterable for backward compatibility."
-        logger.warning("ASyncIterable.wrap will be removed soon. Please replace uses with simple instantiation ie `ASyncIterable(wrapped)`")
+        logger.warning(
+            "ASyncIterable.wrap will be removed soon. Please replace uses with simple instantiation ie `ASyncIterable(wrapped)`"
+        )
         return cls(wrapped)
+
     def __init__(self, async_iterable: AsyncIterable[T]):
-        "Initializes the ASyncIterable with an async iterable."
+        """
+        Initializes the ASyncIterable with an async iterable.
+
+        Args:
+            async_iterable: The async iterable to wrap.
+        """
         if not isinstance(async_iterable, AsyncIterable):
-            raise TypeError(f"`async_iterable` must be an AsyncIterable. You passed {async_iterable}")
+            raise TypeError(
+                f"`async_iterable` must be an AsyncIterable. You passed {async_iterable}"
+            )
         self.__wrapped__ = async_iterable
         "The wrapped async iterable object."
+
     def __repr__(self) -> str:
         start = f"<{type(self).__name__}"
         if wrapped := getattr(self, "__wrapped__", None):
@@ -151,10 +165,13 @@ class ASyncIterable(_AwaitableAsyncIterableMixin[T], Iterable[T]):
     def __iter__(self) -> Iterator[T]:
         "Return an iterator that yields :obj:`T` objects from the {cls}."
         yield from ASyncIterator(self.__aiter__())
-    __slots__ = "__wrapped__", 
+
+    __slots__ = ("__wrapped__",)
+
 
 AsyncGenFunc = Callable[P, Union[AsyncGenerator[T, None], AsyncIterator[T]]]
 
+
 class ASyncIterator(_AwaitableAsyncIterableMixin[T], Iterator[T]):
     """
     A hybrid Iterator/AsyncIterator implementation that bridges the gap between synchronous and asynchronous iteration. This class provides a unified interface for iteration that can seamlessly operate in both synchronous (`for` loop) and asynchronous (`async for` loop) contexts. It allows the wrapping of asynchronous iterable objects or async generator functions, making them usable in synchronous code without explicitly managing event loops or asynchronous context switches.
@@ -163,11 +180,11 @@ class ASyncIterator(_AwaitableAsyncIterableMixin[T], Iterator[T]):
 
     This class is particularly useful for library developers seeking to provide a consistent iteration interface across synchronous and asynchronous code, reducing the cognitive load on users and promoting code reusability and simplicity.
     """
-    
+
     def __next__(self) -> T:
         """
         Synchronously fetch the next item from the {cls}.
-        
+
         Raises:
             :class:`StopIteration`: Once all items have been fetched from the {cls}.
         """
@@ -177,34 +194,61 @@ class ASyncIterator(_AwaitableAsyncIterableMixin[T], Iterator[T]):
             raise StopIteration from e
         except RuntimeError as e:
             if str(e) == "This event loop is already running":
-                raise SyncModeInAsyncContextError("The event loop is already running. Try iterating using `async for` instead of `for`.") from e
+                raise SyncModeInAsyncContextError(
+                    "The event loop is already running. Try iterating using `async for` instead of `for`."
+                ) from e
             raise
 
     @overload
-    def wrap(cls, aiterator: AsyncIterator[T]) -> "ASyncIterator[T]":...
+    def wrap(cls, aiterator: AsyncIterator[T]) -> "ASyncIterator[T]":
+        """
+        Wraps an AsyncIterator in an ASyncIterator.
+
+        Args:
+            aiterator: The AsyncIterator to wrap.
+        """
+
     @overload
-    def wrap(cls, async_gen_func: AsyncGenFunc[P, T]) -> "ASyncGeneratorFunction[P, T]":...
+    def wrap(cls, async_gen_func: AsyncGenFunc[P, T]) -> "ASyncGeneratorFunction[P, T]":
+        """
+        Wraps an async generator function in an ASyncGeneratorFunction.
+
+        Args:
+            async_gen_func: The async generator function to wrap.
+        """
+
     @classmethod
     def wrap(cls, wrapped):
         "Class method to wrap either an AsyncIterator or an async generator function."
         if isinstance(wrapped, AsyncIterator):
-            logger.warning("This use case for ASyncIterator.wrap will be removed soon. Please replace uses with simple instantiation ie `ASyncIterator(wrapped)`")
+            logger.warning(
+                "This use case for ASyncIterator.wrap will be removed soon. Please replace uses with simple instantiation ie `ASyncIterator(wrapped)`"
+            )
             return cls(wrapped)
         elif inspect.isasyncgenfunction(wrapped):
             return ASyncGeneratorFunction(wrapped)
-        raise TypeError(f"`wrapped` must be an AsyncIterator or an async generator function. You passed {wrapped}")
+        raise TypeError(
+            f"`wrapped` must be an AsyncIterator or an async generator function. You passed {wrapped}"
+        )
 
     def __init__(self, async_iterator: AsyncIterator[T]):
-        "Initializes the ASyncIterator with an async iterator."
+        """
+        Initializes the ASyncIterator with an async iterator.
+
+        Args:
+            async_iterator: The async iterator to wrap.
+        """
         if not isinstance(async_iterator, AsyncIterator):
-            raise TypeError(f"`async_iterator` must be an AsyncIterator. You passed {async_iterator}")
+            raise TypeError(
+                f"`async_iterator` must be an AsyncIterator. You passed {async_iterator}"
+            )
         self.__wrapped__ = async_iterator
         "The wrapped :class:`AsyncIterator`."
 
     async def __anext__(self) -> T:
         """
         Asynchronously fetch the next item from the {cls}.
-        
+
         Raises:
             :class:`StopAsyncIteration`: Once all items have been fetched from the {cls}.
         """
@@ -218,6 +262,7 @@ class ASyncIterator(_AwaitableAsyncIterableMixin[T], Iterator[T]):
         "Return the {cls} for aiteration."
         return self
 
+
 class ASyncGeneratorFunction(Generic[P, T]):
     """
     Encapsulates an asynchronous generator function, providing a mechanism to use it as an asynchronous iterator with enhanced capabilities. This class wraps an async generator function, allowing it to be called with parameters and return an :class:`~ASyncIterator` object. It is particularly useful for situations where an async generator function needs to be used in a manner that is consistent with both synchronous and asynchronous execution contexts.
@@ -233,7 +278,9 @@ class ASyncGeneratorFunction(Generic[P, T]):
     __weakself__: "weakref.ref[object]" = None
     "A weak reference to the instance the function is bound to, if any."
 
-    def __init__(self, async_gen_func: AsyncGenFunc[P, T], instance: Any = None) -> None:
+    def __init__(
+        self, async_gen_func: AsyncGenFunc[P, T], instance: Any = None
+    ) -> None:
         """
         Initializes the ASyncGeneratorFunction with the given async generator function and optionally an instance.
 
@@ -241,7 +288,7 @@ class ASyncGeneratorFunction(Generic[P, T]):
             async_gen_func: The async generator function to wrap.
             instance (optional): The object to bind to the function, if applicable.
         """
-        
+
         self.field_name = async_gen_func.__name__
         "The name of the async generator function."
 
@@ -263,7 +310,7 @@ class ASyncGeneratorFunction(Generic[P, T]):
         Args:
             *args: Positional arguments for the function.
             **kwargs: Keyword arguments for the function.
-    
+
         Returns:
             An :class:`ASyncIterator` wrapping the :class:`AsyncIterator` returned from the wrapped function call.
         """
@@ -296,11 +343,14 @@ class ASyncGeneratorFunction(Generic[P, T]):
 
     def __get_cache_handle(self, instance: object) -> asyncio.TimerHandle:
         # NOTE: we create a strong reference to instance here. I'm not sure if this is good or not but its necessary for now.
-        return asyncio.get_event_loop().call_later(300, delattr, instance, self.field_name)
+        return asyncio.get_event_loop().call_later(
+            300, delattr, instance, self.field_name
+        )
 
     def __cancel_cache_handle(self, instance: object) -> None:
         self._cache_handle.cancel()
 
+
 class _ASyncView(ASyncIterator[T]):
     """
     Internal mixin class containing logic for creating specialized views for :class:`~ASyncIterable` objects.
@@ -313,8 +363,8 @@ class _ASyncView(ASyncIterator[T]):
     """An optional iterator. If None, :attr:`~_ASyncView.__aiterator__` will have a value."""
 
     def __init__(
-        self, 
-        function: ViewFn[T], 
+        self,
+        function: ViewFn[T],
         iterable: AnyIterable[T],
     ) -> None:
         """
@@ -331,18 +381,21 @@ class _ASyncView(ASyncIterator[T]):
         elif isinstance(iterable, Iterable):
             self.__iterator__ = iterable.__iter__()
         else:
-            raise TypeError(f"`iterable` must be AsyncIterable or Iterable, you passed {iterable}")
+            raise TypeError(
+                f"`iterable` must be AsyncIterable or Iterable, you passed {iterable}"
+            )
+
 
-@final  
+@final
 class ASyncFilter(_ASyncView[T]):
     """
-    An async filter class that filters items of an async iterable based on a provided function. 
-    
+    An async filter class that filters items of an async iterable based on a provided function.
+
     This class inherits from :class:`~_ASyncView` and provides the functionality to asynchronously
     iterate over items, applying the filter function to each item to determine if it should be
     included in the result.
     """
-    
+
     def __repr__(self) -> str:
         return f"<ASyncFilter for iterator={self.__wrapped__} function={self._function.__name__} at {hex(id(self))}>"
 
@@ -382,28 +435,27 @@ def _key_if_no_key(obj: T) -> T:
 
     Args:
         obj: The object to return.
-
-    Returns:
-        The object itself.
     """
     return obj
 
+
 @final
 class ASyncSorter(_ASyncView[T]):
     """
-    An async sorter class that sorts items of an async iterable based on a provided key function. 
-    
+    An async sorter class that sorts items of an async iterable based on a provided key function.
+
     This class inherits from :class:`~_ASyncView` and provides the functionality to asynchronously
     iterate over items, applying the key function to each item for sorting.
     """
+
     reversed: bool = False
     _consumed: bool = False
 
     def __init__(
-        self, 
+        self,
         iterable: AsyncIterable[T],
         *,
-        key: SortKey[T] = None, 
+        key: SortKey[T] = None,
         reverse: bool = False,
     ) -> None:
         """
@@ -467,7 +519,9 @@ class ASyncSorter(_ASyncView[T]):
                 for obj in self.__iterator__:
                     items.append(obj)
                     sort_tasks.append(asyncio.create_task(self._function(obj)))
-                for sort_value, obj in sorted(zip(await asyncio.gather(*sort_tasks), items), reverse=reverse):
+                for sort_value, obj in sorted(
+                    zip(await asyncio.gather(*sort_tasks), items), reverse=reverse
+                ):
                     yield obj
         else:
             if self.__aiterator__:
@@ -480,4 +534,10 @@ class ASyncSorter(_ASyncView[T]):
         self._consumed = True
 
 
-__all__ = ["ASyncIterable", "ASyncIterator", "ASyncFilter", "ASyncSorter", "ASyncGeneratorFunction"]
+__all__ = [
+    "ASyncIterable",
+    "ASyncIterator",
+    "ASyncFilter",
+    "ASyncSorter",
+    "ASyncGeneratorFunction",
+]

a_sync/primitives/__init__.py

@@ -1,6 +1,18 @@
-
 """
-While not the focus of this lib, this module includes some new primitives and some modified versions of standard asyncio primitives.
+This module includes both new primitives and modified versions of standard asyncio primitives.
+
+The primitives provided in this module are:
+
+- Semaphore
+- ThreadsafeSemaphore
+- PrioritySemaphore
+- CounterLock
+- Event
+- Queue
+- ProcessingQueue
+- SmartProcessingQueue
+
+These primitives extend or modify the functionality of standard asyncio primitives to provide additional features or improved performance for specific use cases.
 """
 
 from a_sync.primitives.locks import *

a_sync/primitives/_debug.py

@@ -14,17 +14,17 @@ from a_sync.primitives._loggable import _LoggerMixin
 class _DebugDaemonMixin(_LoggerMixin, metaclass=abc.ABCMeta):
     """
     A mixin class that provides debugging capabilities using a daemon task.
-    
+
     This mixin ensures that rich debug logs are automagically emitted from subclass instances whenever debug logging is enabled.
     """
-    
-    __slots__ = "_daemon",
+
+    __slots__ = ("_daemon",)
 
     @abc.abstractmethod
     async def _debug_daemon(self, fut: asyncio.Future, fn, *args, **kwargs) -> None:
         """
         Abstract method to define the debug daemon's behavior.
-        
+
         Args:
             fut: The future associated with the daemon.
             fn: The function to be debugged.
@@ -35,13 +35,13 @@ class _DebugDaemonMixin(_LoggerMixin, metaclass=abc.ABCMeta):
     def _start_debug_daemon(self, *args, **kwargs) -> "asyncio.Future[None]":
         """
         Starts the debug daemon task if debug logging is enabled and the event loop is running.
-        
+
         Args:
             *args: Positional arguments for the debug daemon.
             **kwargs: Keyword arguments for the debug daemon.
-        
+
         Returns:
-            The debug daemon task, or a dummy future if debug logs are not enabled or if the daemon cannot be created.
+            The debug daemon task as an asyncio.Task, or a dummy future if debug logs are not enabled or if the daemon cannot be created.
         """
         if self.debug_logs_enabled and asyncio.get_event_loop().is_running():
             return asyncio.create_task(self._debug_daemon(*args, **kwargs))
@@ -51,17 +51,17 @@ class _DebugDaemonMixin(_LoggerMixin, metaclass=abc.ABCMeta):
     def _ensure_debug_daemon(self, *args, **kwargs) -> "asyncio.Future[None]":
         """
         Ensures that the debug daemon task is running.
-        
+
         Args:
             *args: Positional arguments for the debug daemon.
             **kwargs: Keyword arguments for the debug daemon.
-        
+
         Returns:
             Either the debug daemon task or a dummy future if debug logging is not enabled.
         """
         if not self.debug_logs_enabled:
             self._daemon = asyncio.get_event_loop().create_future()
-        if not hasattr(self, '_daemon') or self._daemon is None:
+        if not hasattr(self, "_daemon") or self._daemon is None:
             self._daemon = self._start_debug_daemon(*args, **kwargs)
             self._daemon.add_done_callback(self._stop_debug_daemon)
         return self._daemon
@@ -69,10 +69,10 @@ class _DebugDaemonMixin(_LoggerMixin, metaclass=abc.ABCMeta):
     def _stop_debug_daemon(self, t: Optional[asyncio.Task] = None) -> None:
         """
         Stops the debug daemon task.
-        
+
         Args:
-            t (optional): The task to be stopped, if any. 
-        
+            t (optional): The task to be stopped, if any.
+
         Raises:
             ValueError: If `t` is not the current daemon.
         """

a_sync/primitives/_loggable.py

@@ -9,22 +9,23 @@ from logging import Logger, getLogger, DEBUG
 class _LoggerMixin:
     """
     A mixin class that adds logging capabilities to other classes.
-    
+
     This mixin provides a cached property for accessing a logger instance and a property to check if debug logging is enabled.
     """
+
     @cached_property
     def logger(self) -> Logger:
         """
         Returns a logger instance specific to the class using this mixin.
-        
+
         The logger ID is constructed from the module and class name, and optionally includes an instance name if available.
 
         Returns:
             Logger: A logger instance for the class.
         """
         logger_id = type(self).__qualname__
-        if hasattr(self, '_name') and self._name:
-            logger_id += f'.{self._name}'
+        if hasattr(self, "_name") and self._name:
+            logger_id += f".{self._name}"
         return getLogger(logger_id)
 
     @property

a_sync/primitives/locks/__init__.py

@@ -1,5 +1,8 @@
-
 from a_sync.primitives.locks.counter import CounterLock
 from a_sync.primitives.locks.event import Event
-from a_sync.primitives.locks.semaphore import DummySemaphore, Semaphore, ThreadsafeSemaphore
+from a_sync.primitives.locks.semaphore import (
+    DummySemaphore,
+    Semaphore,
+    ThreadsafeSemaphore,
+)
 from a_sync.primitives.locks.prio_semaphore import PrioritySemaphore

a_sync/primitives/locks/counter.py

@@ -1,7 +1,7 @@
 """
 This module provides two specialized async flow management classes, CounterLock and CounterLockCluster.
 
-These primitives manages :class:`asyncio.Task` objects that must wait for an internal counter to reach a specific value.
+These primitives manage :class:`asyncio.Task` objects that must wait for an internal counter to reach a specific value.
 """
 
 import asyncio
@@ -15,23 +15,24 @@ from a_sync.primitives.locks.event import Event
 
 class CounterLock(_DebugDaemonMixin):
     """
-    An async primitive that blocks until the internal counter has reached a specific value.
-    
-    A coroutine can `await counter.wait_for(3)` and it will block until the internal counter >= 3.
-    If some other task executes `counter.value = 5` or `counter.set(5)`, the first coroutine will unblock as 5 >= 3.
-    
-    The internal counter can only increase.
+    An async primitive that uses an internal counter to manage task synchronization.
+
+    A coroutine can `await counter.wait_for(3)` and it will wait until the internal counter >= 3.
+    If some other task executes `counter.value = 5` or `counter.set(5)`, the first coroutine will proceed as 5 >= 3.
+
+    The internal counter can only be set to a value greater than the current value.
     """
+
     __slots__ = "is_ready", "_name", "_value", "_events"
+
     def __init__(self, start_value: int = 0, name: Optional[str] = None):
         """
         Initializes the CounterLock with a starting value and an optional name.
 
         Args:
             start_value: The initial value of the counter.
-            name (optional): An optional name for the counter, used in debug logs.
+            name: An optional name for the counter, used in debug logs.
         """
-
         self._name = name
         """An optional name for the counter, used in debug logs."""
 
@@ -43,48 +44,42 @@ class CounterLock(_DebugDaemonMixin):
 
         self.is_ready = lambda v: self._value >= v
         """A lambda function that indicates whether a given value has already been surpassed."""
-        
+
     async def wait_for(self, value: int) -> bool:
         """
         Waits until the counter reaches or exceeds the specified value.
 
         Args:
             value: The value to wait for.
-
-        Returns:
-            True when the counter reaches or exceeds the specified value.
         """
         if not self.is_ready(value):
             self._ensure_debug_daemon()
             await self._events[value].wait()
         return True
-    
+
     def set(self, value: int) -> None:
         """
         Sets the counter to the specified value.
 
         Args:
-            value: The value to set the counter to. Must be >= the current value.
-        
+            value: The value to set the counter to. Must be strictly greater than the current value.
+
         Raises:
-            ValueError: If the new value is less than the current value.
+            ValueError: If the new value is less than or equal to the current value.
         """
         self.value = value
-    
+
     def __repr__(self) -> str:
         waiters = {v: len(self._events[v]._waiters) for v in sorted(self._events)}
         return f"<CounterLock name={self._name} value={self._value} waiters={waiters}>"
-        
+
     @property
     def value(self) -> int:
         """
         Gets the current value of the counter.
-
-        Returns:
-            The current value of the counter.
         """
         return self._value
-    
+
     @value.setter
     def value(self, value: int) -> None:
         """
@@ -98,28 +93,37 @@ class CounterLock(_DebugDaemonMixin):
         """
         if value > self._value:
             self._value = value
-            ready = [self._events.pop(key) for key in list(self._events.keys()) if key <= self._value]
+            ready = [
+                self._events.pop(key)
+                for key in list(self._events.keys())
+                if key <= self._value
+            ]
             for event in ready:
                 event.set()
         elif value < self._value:
             raise ValueError("You cannot decrease the value.")
-    
+
     async def _debug_daemon(self) -> None:
         """
         Periodically logs debug information about the counter state and waiters.
         """
         start = time()
         while self._events:
-            self.logger.debug("%s is still locked after %sm", self, round(time() - start / 60, 2))
+            self.logger.debug(
+                "%s is still locked after %sm", self, round(time() - start / 60, 2)
+            )
             await asyncio.sleep(300)
 
+
 class CounterLockCluster:
     """
-    An asyncio primitive that represents 2 or more CounterLock objects.
-    
-    `wait_for(i)` will block until the value of all CounterLock objects is >= i.
+    An asyncio primitive that represents a collection of CounterLock objects.
+
+    `wait_for(i)` will wait until the value of all CounterLock objects is >= i.
     """
-    __slots__ = "locks", 
+
+    __slots__ = ("locks",)
+
     def __init__(self, counter_locks: Iterable[CounterLock]) -> None:
         """
         Initializes the CounterLockCluster with a collection of CounterLock objects.
@@ -128,17 +132,15 @@ class CounterLockCluster:
             counter_locks: The CounterLock objects to manage.
         """
         self.locks = list(counter_locks)
-    
+
     async def wait_for(self, value: int) -> bool:
         """
         Waits until the value of all CounterLock objects in the cluster reaches or exceeds the specified value.
 
         Args:
             value: The value to wait for.
-
-        Returns:
-            True when the value of all CounterLock objects reach or exceed the specified value.
         """
-        await asyncio.gather(*[counter_lock.wait_for(value) for counter_lock in self.locks])
+        await asyncio.gather(
+            *[counter_lock.wait_for(value) for counter_lock in self.locks]
+        )
         return True
-