(aesthetic) I really don't want to write my own formatter...

Author: mikeshardmind

src/async_utils/__init__.py

@@ -20,30 +20,36 @@
 # - update `_misc._ensure_annotations.py` before extending this version.
 # - ensure `task_cache.__WrappedSignature` still works
 if (_vi.major, _vi.minor) > (3, 14):
-    msg: str = """This library is not tested for use on python versions above 3.14
-    This library relies on a few internal details that are not safe to rely upon
-    without checking this consistently.
-    """
+    msg: str = (
+        "This library is not tested for use on python versions above 3.14."
+        "\nThis library relies on a few internal details that are not "
+        "safe to rely upon without checking for changes to internals "
+        "consistently."
+    )
     if os.getenv("ASYNC_UTILS_UNCHECKED_PY_VER", ""):
         import logging
 
-        msg += """\n\nThis is not neccessarily broken, but if you encounter an
-        issue with it, please be aware that the library has not actively
-        chosen to support the python version you have opted into using this on
-        *yet*. If you encounter an issue with it, please do still report it.
-        """
+        msg += (
+            "\n\nThis is not neccessarily broken, but if you encounter an "
+            "issue with it, please be aware that the library has not actively "
+            "chosen to support the python version you have opted into using "
+            "yet. If you encounter an issue with it, please still report it. "
+        )
 
         logging.getLogger(__name__).warning(msg)
     elif sys.version_info.releaselevel in {"alpha", "beta", "candidate"}:
         import logging
 
-        msg += """\nThanks for testing this (and a development version of python)
-        prior to release!.\n"""
+        msg += (
+            "\nThanks for testing this (and a development version of python) "
+            " prior to release!."
+        )
         logging.getLogger(__name__).warning(msg)
     else:
-        msg += """\nYou can change this error to a warning if you are sure it is
-        safe and are willing to take the risk on yourself before I have verified
-        it by setting the environment variable `ASYNC_UTILS_UNCHECKED_PY_VER`
-        to a non-empty value.
-        """
+        msg += (
+            "\nYou can change this error to a warning if you are sure it "
+            "safe and are willing to take the risk on yourself before I "
+            "have verified it by setting the environment variable "
+            "`ASYNC_UTILS_UNCHECKED_PY_VER` to a non-empty value."
+        )
         raise RuntimeError(msg)

src/async_utils/_qs.py

@@ -44,7 +44,7 @@ def __gt__(self, other: _contraT) -> bool: ...
 else:
 
     class ExprWrapper:
-        """Future proof against runtime change preventing call expr in type statement."""
+        """Wrapper since call expressions aren't allowed in type statements."""
 
         def __class_getitem__(cls, key: None) -> t.Any:
             import typing

src/async_utils/corofunc_cache.py

@@ -50,7 +50,7 @@ def __call__[**P, R](self, c: CoroLike[P, R], /) -> CoroFunc[P, R]: ...
     def f__call__[**P, R](self, c: CoroLike[P, R], /) -> CoroFunc[P, R]: ...  # noqa: ANN001
 
     class ExprWrapper:
-        """Future proof against runtime change preventing call expr in type statement."""
+        """Wrapper since call expressions aren't allowed in type statements."""
 
         def __class_getitem__(cls, key: None) -> t.Any:
             return type(
@@ -83,7 +83,9 @@ def corocache(
     restrictive.
 
     Note: This by default uses the args and kwargs of the original coroutine
-    function as a cache key. This includes instances (self) when wrapping methods.
+    function as a cache key.
+    This includes instances (self) when wrapping methods.
+
     Consider not wrapping instance methods, but what those methods call when
     feasible in cases where this may matter, or using a cache transform.
 
@@ -92,7 +94,8 @@ def corocache(
     Parameters
     ----------
     ttl: float | None
-        The time to live in seconds for cached results. Defaults to None (forever)
+        The time to live in seconds for cached results.
+        Defaults to None (forever)
     cache_transform: CacheTransformer | None
         An optional callable that transforms args and kwargs used
         as a cache key.
@@ -158,7 +161,8 @@ def lrucorocache(
     restrictive.
 
     Note: This by default uses the args and kwargs of the original coroutine
-    function as a cache key. This includes instances (self) when wrapping methods.
+    function as a cache key.
+    This includes instances (self) when wrapping methods.
     Consider not wrapping instance methods, but what those methods call when
     feasible in cases where this may matter, or using a cache transform.
 
@@ -169,7 +173,8 @@ def lrucorocache(
     Parameters
     ----------
     ttl: float | None
-        The time to live in seconds for cached results. Defaults to None (forever)
+        The time to live in seconds for cached results.
+        Defaults to None (forever)
     maxsize: int
         The maximum number of items to retain no matter if they have reached
         expiration by ttl or not.

src/async_utils/gen_transform.py

@@ -135,7 +135,7 @@ async def gen() -> AsyncGenerator[Y]:
             lazy_ev.set()
             while q:
                 yield (await q.async_get())
-            # ensure errors in the generator propogate *after* the last values yielded
+            # ensure errors propogate *after* the last values yielded
             await bg_task
 
     return gen(), cancel_fut
@@ -156,11 +156,11 @@ def sync_to_async_gen[**P, Y](
     are not appropriate for this function. similarly, generator return values
     are completely swallowed.
 
-    If your generator is actually a synchronous coroutine, that's super cool,
-    but rewrite is as a native coroutine or use it directly then, you don't need
-    what this function does.
+    .. note:: If your generator is actually a synchronous coroutine,
+    that's super cool, but rewrite is as a native coroutine or use it directly;
+    you don't need what this function does.
+
 
-    .. note::
 
     Parameters
     ----------
@@ -195,14 +195,12 @@ def sync_to_async_gen_noctx[**P, Y](
     are not appropriate for this function. similarly, generator return values
     are completely swallowed.
 
-    If your generator is actually a synchronous coroutine, that's super cool,
-    but rewrite is as a native coroutine or use it directly then, you don't need
-    what this function does.
+    .. note:: If your generator is actually a synchronous coroutine,
+    that's super cool, but rewrite is as a native coroutine or use it directly;
+    you don't need what this function does.
 
     This version does not forward exception context and is not a context manager.
 
-    .. note::
-
     Parameters
     ----------
     f:

src/async_utils/lockout.py

@@ -130,7 +130,8 @@ class FIFOLockout:
             async with ratelimiter, lockout:
                 response = await some_request(route, **parameters)
                 if response.code == 429:
-                    if reset_after := response.headers.get('X-Ratelimit-Reset-After')
+                    headers = response.headers
+                    if reset_after := headers.get('X-Ratelimit-Reset-After')
                         lockout.lock_for(reset_after)
     """
 

src/async_utils/lru.py

@@ -32,15 +32,15 @@
 
 
 class ProbableTOCTOUError(Exception):
-    """Raised for operations that should not be done to avoid a Time of check-time of use bug."""
+    """Time of check-time of use bugs."""
 
 
 class ContainsMisuse(ProbableTOCTOUError):
-    """Checking containment rather than just getting, setting, or using setdefault."""
+    """Checking cache value exists rather than handling non-existence."""
 
 
 class IterationMisuse(ProbableTOCTOUError):
-    """Iterating over a mutable container that can change simply because of time or other access."""
+    """Iterating over a mutable cache."""
 
 
 class LRU[K, V]:

src/async_utils/scheduler.py

@@ -78,7 +78,8 @@ def __init__(self, granularity: float, /) -> None:
         self.__granularity: float = granularity
         self.__closed: bool = False
         self.__tasks: dict[CancellationToken, _Task[T]] = {}
-        # PYUPGRADE: check: 3.15; relies on asyncio.Lock & Queues not eagerly binding to an event loop.
+        # PYUPGRADE: check: 3.15;
+        #   relies on asyncio.Lock & Queues not eagerly binding to an event loop.
         self.__l = asyncio.Lock()
         self.__tqueue: asyncio.PriorityQueue[_Task[T]] = asyncio.PriorityQueue()
 

src/async_utils/task_cache.py

@@ -53,7 +53,7 @@ def __call__[**P, R](
     def f__call__[**P, R](self, c: TaskCoroFunc[P, R], /) -> TaskFunc[P, R]: ...  # noqa: ANN001
 
     class ExprWrapper:
-        """Future proof against runtime change preventing call expr in type statement."""
+        """Wrapper since call expressions aren't allowed in type statements."""
 
         def __class_getitem__(cls, key: None) -> t.Any:
             return type(

src/async_utils/waterfall.py

@@ -182,10 +182,8 @@ async def _dispatch_loop(self) -> None:
             # the result of that future is also not accurate in the typeshed.
             # as we dont rely on the type of the result, the below is annotated
             # to avoid spurious errors much as possible from inaccuracies.
-            # See: https://github.com/mikeshardmind/async-utils/actions/runs/14119338111
-            g: asyncio.Future[t.Any] = asyncio.gather(
-                f, *tasks, return_exceptions=True
-            )
+            g: asyncio.Future[t.Any]
+            g = asyncio.gather(f, *tasks, return_exceptions=True)
             try:
                 await asyncio.wait_for(g, timeout=self.max_wait_finalize)
             except TimeoutError:
@@ -198,7 +196,8 @@ async def _dispatch_loop(self) -> None:
     async def _finalize(self) -> None:
         loop = self._event_loop
         assert loop is not None
-        # WARNING: Do not allow an async context switch before the queue is drained
+        # WARNING:
+        # Do not allow an async context switch before the queue is drained
         # This can be changed to utilize queue.Shutdown in 3.13+
         # or when more of asyncio queues have been replaced here
         # as part of freethreading efforts.