mypy passes for private stuff now too, may make it a full-fledged CI step soon

Author: mikeshardmind

src/async_utils/__init__.py

@@ -9,7 +9,7 @@
 __author__ = "Michael Hall"
 __license__ = "Apache-2.0"
 __copyright__ = "Copyright 2020-Present Michael Hall"
-__version__ = "2025.03.30b"
+__version__ = "2025.04.6b"
 
 import os
 import sys

src/async_utils/_paramkey.py

@@ -44,9 +44,10 @@ def __eq__(self, other: object) -> bool:
 _marker: tuple[object] = (object(),)
 
 
-def make_key(
+def _make_key(
     args: tuple[t.Any, ...],
     kwds: dict[t.Any, t.Any],
+    /, *,
     _typ: Callable[[object], type] = type,
     _fast_types: set[type] = {int, str},  # noqa: B006
 ) -> Hashable:
@@ -58,3 +59,6 @@ def make_key(
     elif len(key) == 1 and _typ(key[0]) in _fast_types:
         return key[0]
     return _HK(key)
+
+
+make_key: Callable[[tuple[t.Any, ...], dict[t.Any, t.Any]], Hashable] = _make_key

src/async_utils/corofunc_cache.py

@@ -82,7 +82,7 @@ def corocache[**P, R](
         key_func = make_key
     else:
 
-        def key_func(args: tuple[t.Any, ...], kwds: dict[t.Any, t.Any]) -> Hashable:
+        def key_func(args: tuple[t.Any, ...], kwds: dict[t.Any, t.Any], /) -> Hashable:
             return make_key(*cache_transform(args, kwds))
 
     def wrapper(coro: CoroLike[P, R]) -> CoroFunc[P, R]:
@@ -161,7 +161,7 @@ def lrucorocache[**P, R](
         key_func = make_key
     else:
 
-        def key_func(args: tuple[t.Any, ...], kwds: dict[t.Any, t.Any]) -> Hashable:
+        def key_func(args: tuple[t.Any, ...], kwds: dict[t.Any, t.Any], /) -> Hashable:
             return make_key(*cache_transform(args, kwds))
 
     def wrapper(coro: CoroLike[P, R]) -> CoroFunc[P, R]:

src/async_utils/task_cache.py

@@ -142,7 +142,7 @@ def taskcache[**P, R](
         key_func = make_key
     else:
 
-        def key_func(args: tuple[t.Any, ...], kwds: dict[t.Any, t.Any]) -> Hashable:
+        def key_func(args: tuple[t.Any, ...], kwds: dict[t.Any, t.Any], /) -> Hashable:
             return make_key(*cache_transform(args, kwds))
 
     def wrapper(coro: TaskCoroFunc[P, R]) -> TaskFunc[P, R]:
@@ -228,7 +228,7 @@ def lrutaskcache[**P, R](
         key_func = make_key
     else:
 
-        def key_func(args: tuple[t.Any, ...], kwds: dict[t.Any, t.Any]) -> Hashable:
+        def key_func(args: tuple[t.Any, ...], kwds: dict[t.Any, t.Any], /) -> Hashable:
             return make_key(*cache_transform(args, kwds))
 
     def wrapper(coro: TaskCoroFunc[P, R]) -> TaskFunc[P, R]:

src/async_utils/waterfall.py

@@ -115,7 +115,7 @@ def put(self, item: T) -> None:
             raise RuntimeError(msg)
         self.queue.put_nowait(item)
 
-    def _user_done_callback(self, num: int, future: asyncio.Future[t.Any]):
+    def _user_done_callback(self, num: int, future: asyncio.Future[t.Any]) -> None:
         if future.cancelled():
             log.warning("Callback cancelled due to timeout")
         elif exc := future.exception():
@@ -151,13 +151,13 @@ async def _dispatch_loop(self) -> None:
 
                 # get len before callback may mutate list
                 num_items = len(queue_items)
-                t = loop.create_task(self.callback(queue_items))
+                task = loop.create_task(self.callback(queue_items))
                 del queue_items
 
-                tasks.add(t)
-                t.add_done_callback(tasks.discard)
+                tasks.add(task)
+                task.add_done_callback(tasks.discard)
                 cb = partial(self._user_done_callback, num_items)
-                t.add_done_callback(cb)
+                task.add_done_callback(cb)
 
         finally:
             f = loop.create_task(self._finalize())
@@ -181,9 +181,9 @@ async def _dispatch_loop(self) -> None:
             except TimeoutError:
                 # GatheringFuture.cancel doesnt work here
                 # due to return_exceptions=True
-                for t in (f, *tasks):
-                    if not t.done():
-                        t.cancel()
+                for task in (f, *tasks):
+                    if not task.done():
+                        task.cancel()
 
     async def _finalize(self) -> None:
         loop = self._event_loop