haiway 0.12.1__py3-none-any.whl → 0.13.1__py3-none-any.whl

haiway/context/access.py

@@ -238,8 +238,8 @@ class ScopeContext:
     @overload
     def __call__[Result, **Arguments](
         self,
-        function: Callable[Arguments, Coroutine[None, None, Result]],
-    ) -> Callable[Arguments, Coroutine[None, None, Result]]: ...
+        function: Callable[Arguments, Coroutine[Any, Any, Result]],
+    ) -> Callable[Arguments, Coroutine[Any, Any, Result]]: ...
 
     @overload
     def __call__[Result, **Arguments](
@@ -249,8 +249,8 @@ class ScopeContext:
 
     def __call__[Result, **Arguments](
         self,
-        function: Callable[Arguments, Coroutine[None, None, Result]] | Callable[Arguments, Result],
-    ) -> Callable[Arguments, Coroutine[None, None, Result]] | Callable[Arguments, Result]:
+        function: Callable[Arguments, Coroutine[Any, Any, Result]] | Callable[Arguments, Result],
+    ) -> Callable[Arguments, Coroutine[Any, Any, Result]] | Callable[Arguments, Result]:
         if iscoroutinefunction(function):
 
             async def async_context(
@@ -372,7 +372,7 @@ class ctx:
 
     @staticmethod
     def spawn[Result, **Arguments](
-        function: Callable[Arguments, Coroutine[None, None, Result]],
+        function: Callable[Arguments, Coroutine[Any, Any, Result]],
         /,
         *args: Arguments.args,
         **kwargs: Arguments.kwargs,
@@ -383,7 +383,7 @@ class ctx:
 
         Parameters
         ----------
-        function: Callable[Arguments, Coroutine[None, None, Result]]
+        function: Callable[Arguments, Coroutine[Any, Any, Result]]
             function to be called within the task group
 
         *args: Arguments.args

haiway/context/state.py

@@ -91,11 +91,6 @@ class ScopeState:
 class StateContext:
     _context = ContextVar[ScopeState]("StateContext")
 
-    __slots__ = (
-        "_state",
-        "_token",
-    )
-
     @classmethod
     def current[StateType: State](
         cls,
@@ -122,6 +117,11 @@ class StateContext:
         except LookupError:  # create root scope when missing
             return cls(state=ScopeState(state))
 
+    __slots__ = (
+        "_state",
+        "_token",
+    )
+
     def __init__(
         self,
         state: ScopeState,

haiway/context/tasks.py

@@ -16,7 +16,7 @@ class TaskGroupContext:
     @classmethod
     def run[Result, **Arguments](
         cls,
-        function: Callable[Arguments, Coroutine[None, None, Result]],
+        function: Callable[Arguments, Coroutine[Any, Any, Result]],
         /,
         *args: Arguments.args,
         **kwargs: Arguments.kwargs,

haiway/helpers/__init__.py

@@ -1,5 +1,5 @@
 from haiway.helpers.asynchrony import asynchronous, wrap_async
-from haiway.helpers.caching import cache
+from haiway.helpers.caching import CacheMakeKey, CacheRead, CacheWrite, cache
 from haiway.helpers.metrics import MetricsHolder, MetricsLogger
 from haiway.helpers.retries import retry
 from haiway.helpers.throttling import throttle
@@ -8,6 +8,9 @@ from haiway.helpers.tracing import ArgumentsTrace, ResultTrace, traced
 
 __all__ = [
     "ArgumentsTrace",
+    "CacheMakeKey",
+    "CacheRead",
+    "CacheWrite",
     "MetricsHolder",
     "MetricsLogger",
     "ResultTrace",

haiway/helpers/asynchrony.py

@@ -14,9 +14,9 @@ __all__ = [
 
 
 def wrap_async[**Args, Result](
-    function: Callable[Args, Coroutine[None, None, Result]] | Callable[Args, Result],
+    function: Callable[Args, Coroutine[Any, Any, Result]] | Callable[Args, Result],
     /,
-) -> Callable[Args, Coroutine[None, None, Result]]:
+) -> Callable[Args, Coroutine[Any, Any, Result]]:
     if iscoroutinefunction(function):
         return function
 
@@ -30,10 +30,12 @@ def wrap_async[**Args, Result](
 
 
 @overload
-def asynchronous[**Args, Result]() -> Callable[
-    [Callable[Args, Result]],
-    Callable[Args, Coroutine[None, None, Result]],
-]: ...
+def asynchronous[**Args, Result]() -> (
+    Callable[
+        [Callable[Args, Result]],
+        Callable[Args, Coroutine[Any, Any, Result]],
+    ]
+): ...
 
 
 @overload
@@ -43,7 +45,7 @@ def asynchronous[**Args, Result](
     executor: Executor,
 ) -> Callable[
     [Callable[Args, Result]],
-    Callable[Args, Coroutine[None, None, Result]],
+    Callable[Args, Coroutine[Any, Any, Result]],
 ]: ...
 
 
@@ -51,7 +53,7 @@ def asynchronous[**Args, Result](
 def asynchronous[**Args, Result](
     function: Callable[Args, Result],
     /,
-) -> Callable[Args, Coroutine[None, None, Result]]: ...
+) -> Callable[Args, Coroutine[Any, Any, Result]]: ...
 
 
 def asynchronous[**Args, Result](
@@ -62,9 +64,9 @@ def asynchronous[**Args, Result](
 ) -> (
     Callable[
         [Callable[Args, Result]],
-        Callable[Args, Coroutine[None, None, Result]],
+        Callable[Args, Coroutine[Any, Any, Result]],
     ]
-    | Callable[Args, Coroutine[None, None, Result]]
+    | Callable[Args, Coroutine[Any, Any, Result]]
 ):
     """\
     Wrapper for a sync function to convert it to an async function. \
@@ -90,7 +92,7 @@ def asynchronous[**Args, Result](
 
     def wrap(
         wrapped: Callable[Args, Result],
-    ) -> Callable[Args, Coroutine[None, None, Result]]:
+    ) -> Callable[Args, Coroutine[Any, Any, Result]]:
         assert not iscoroutinefunction(wrapped), "Cannot wrap async function in executor"  # nosec: B101
 
         return _ExecutorWrapper(
@@ -152,7 +154,7 @@ class _ExecutorWrapper[**Args, Result]:
         instance: object,
         owner: type | None = None,
         /,
-    ) -> Callable[Args, Coroutine[None, None, Result]]:
+    ) -> Callable[Args, Coroutine[Any, Any, Result]]:
         if owner is None:
             return self
 
@@ -180,8 +182,8 @@ class _ExecutorWrapper[**Args, Result]:
 def _mimic_async[**Args, Result](
     function: Callable[Args, Result],
     /,
-    within: Callable[..., Coroutine[None, None, Result]],
-) -> Callable[Args, Coroutine[None, None, Result]]:
+    within: Callable[..., Coroutine[Any, Any, Result]],
+) -> Callable[Args, Coroutine[Any, Any, Result]]:
     try:
         annotations: Any = getattr(  # noqa: B009
             function,
@@ -192,7 +194,7 @@ def _mimic_async[**Args, Result](
             "__annotations__",
             {
                 **annotations,
-                "return": Coroutine[None, None, annotations.get("return", Any)],
+                "return": Coroutine[Any, Any, annotations.get("return", Any)],
             },
         )
 
@@ -234,6 +236,6 @@ def _mimic_async[**Args, Result](
     )
 
     return cast(
-        Callable[Args, Coroutine[None, None, Result]],
+        Callable[Args, Coroutine[Any, Any, Result]],
         within,
     )

haiway/helpers/caching.py

@@ -1,18 +1,44 @@
-from asyncio import AbstractEventLoop, Task, get_running_loop, iscoroutinefunction, shield
+from asyncio import iscoroutinefunction
 from collections import OrderedDict
 from collections.abc import Callable, Coroutine, Hashable
-from functools import _make_key, partial  # pyright: ignore[reportPrivateUsage]
+from functools import _make_key  # pyright: ignore[reportPrivateUsage]
 from time import monotonic
-from typing import NamedTuple, cast, overload
-from weakref import ref
+from typing import Any, NamedTuple, Protocol, cast, overload
 
+from haiway.context.access import ctx
 from haiway.utils.mimic import mimic_function
 
 __all__ = [
+    "CacheMakeKey",
+    "CacheRead",
+    "CacheWrite",
     "cache",
 ]
 
 
+class CacheMakeKey[**Args, Key](Protocol):
+    def __call__(
+        self,
+        *args: Args.args,
+        **kwargs: Args.kwargs,
+    ) -> Key: ...
+
+
+class CacheRead[Key, Value](Protocol):
+    async def __call__(
+        self,
+        key: Key,
+    ) -> Value | None: ...
+
+
+class CacheWrite[Key, Value](Protocol):
+    async def __call__(
+        self,
+        key: Key,
+        value: Value,
+    ) -> None: ...
+
+
 @overload
 def cache[**Args, Result](
     function: Callable[Args, Result],
@@ -21,58 +47,156 @@ def cache[**Args, Result](
 
 
 @overload
-def cache[**Args, Result](
+def cache[**Args, Result, Key: Hashable](
     *,
-    limit: int = 1,
+    limit: int | None = None,
     expiration: float | None = None,
+    make_key: CacheMakeKey[Args, Key] | None = None,
 ) -> Callable[[Callable[Args, Result]], Callable[Args, Result]]: ...
 
 
-def cache[**Args, Result](
+@overload
+def cache[**Args, Result, Key](
+    *,
+    make_key: CacheMakeKey[Args, Key],
+    read: CacheRead[Key, Result],
+    write: CacheWrite[Key, Result],
+) -> Callable[
+    [Callable[Args, Coroutine[Any, Any, Result]]], Callable[Args, Coroutine[Any, Any, Result]]
+]: ...
+
+
+def cache[**Args, Result, Key](  # noqa: PLR0913
     function: Callable[Args, Result] | None = None,
     *,
-    limit: int = 1,
+    limit: int | None = None,
     expiration: float | None = None,
-) -> Callable[[Callable[Args, Result]], Callable[Args, Result]] | Callable[Args, Result]:
-    """\
-    Simple lru function result cache with optional expire time. \
-    Works for both sync and async functions. \
-    It is not allowed to be used on class methods. \
-    This wrapper is not thread safe.
+    make_key: CacheMakeKey[Args, Key] | None = None,
+    read: CacheRead[Key, Result] | None = None,
+    write: CacheWrite[Key, Result] | None = None,
+) -> (
+    Callable[
+        [Callable[Args, Coroutine[Any, Any, Result]]],
+        Callable[Args, Coroutine[Any, Any, Result]],
+    ]
+    | Callable[[Callable[Args, Result]], Callable[Args, Result]]
+    | Callable[Args, Result]
+):
+    """
+    Memoize the result of a function using a configurable cache.
 
     Parameters
     ----------
-    function: Callable[_Args, _Result]
-        function to wrap in cache, either sync or async
-    limit: int
-        limit of cache entries to keep, default is 1
-    expiration: float | None
-        entries expiration time in seconds, default is None (not expiring)
+    function : Callable[Args, Result] | None
+        The function to be memoized.
+        When used as a simple decorator (i.e., `@cache`), this is the decorated function.
+        Should be omitted when cache is called with configuration arguments.
+    limit : int | None
+        The maximum number of entries to keep in the cache.
+        Defaults to 1 if not specified.
+        Ignored when using custom cache implementations (read/write).
+    expiration : float | None
+        Time in seconds after which a cache entry expires and will be recomputed.
+        Defaults to None, meaning entries don't expire based on time.
+        Ignored when using custom cache implementations (read/write).
+    make_key : CacheMakeKey[Args, Key] | None
+        Function to generate a cache key from function arguments.
+        If None, uses a default implementation that handles most cases.
+        Required when using custom cache implementations (read/write).
+    read : CacheRead[Key, Result] | None
+        Custom asynchronous function to read values from cache.
+        Must be provided together with `write` and `make_key`.
+        Only available for async functions.
+    write : CacheWrite[Key, Result] | None
+        Custom asynchronous function to write values to cache.
+        Must be provided together with `read` and `make_key`.
+        Only available for async functions.
 
     Returns
     -------
-    Callable[[Callable[_Args, _Result]], Callable[_Args, _Result]] | Callable[_Args, _Result]
-        provided function wrapped in cache
+    Callable
+        If `function` is provided as a positional argument, returns the memoized function.
+        Otherwise returns a decorator that can be applied to a function to memoize it
+        with the given configuration.
+
+    Notes
+    -----
+    This decorator supports both synchronous and asynchronous functions.
+    The default implementation uses a simple in-memory LRU cache.
+    For asynchronous functions, you can provide custom cache implementations
+    via the `read` and `write` parameters.
+
+    The default cache is not thread-safe and should not be used in multi-threaded
+    applications without external synchronization.
+
+    Examples
+    --------
+    Simple usage as a decorator:
+
+    >>> @cache
+    ... def my_function(x: int) -> int:
+    ...     print("Function called")
+    ...     return x * 2
+    >>> my_function(5)
+    Function called
+    10
+    >>> my_function(5)  # Cache hit, function body not executed
+    10
+
+    With configuration parameters:
+
+    >>> @cache(limit=10, expiration=60.0)
+    ... def my_function(x: int) -> int:
+    ...     return x * 2
+
+    With custom cache for async functions:
+
+    >>> @cache(make_key=custom_key_maker, read=redis_read, write=redis_write)
+    ... async def fetch_data(user_id: str) -> dict:
+    ...     return await api_call(user_id)
     """
 
     def _wrap(function: Callable[Args, Result]) -> Callable[Args, Result]:
         if iscoroutinefunction(function):
-            return cast(
-                Callable[Args, Result],
-                _AsyncCache(
-                    function,
-                    limit=limit,
-                    expiration=expiration,
-                ),
-            )
+            if read is not None and write is not None and make_key is not None:
+                assert limit is None and expiration is None  # nosec: B101
+                return cast(
+                    Callable[Args, Result],
+                    _CustomCache(
+                        function,
+                        make_key=make_key,
+                        read=read,
+                        write=write,
+                    ),
+                )
+
+            else:
+                assert read is None and write is None  # nosec: B101
+                return cast(
+                    Callable[Args, Result],
+                    _AsyncCache(
+                        function,
+                        limit=limit if limit is not None else 1,
+                        expiration=expiration,
+                        make_key=cast(
+                            CacheMakeKey[Args, Hashable],
+                            make_key if make_key is not None else _default_make_key,
+                        ),
+                    ),
+                )
 
         else:
+            assert read is None and write is None, "Custom sync cache is not supported"  # nosec: B101
             return cast(
                 Callable[Args, Result],
                 _SyncCache(
                     function,
-                    limit=limit,
+                    limit=limit if limit is not None else 1,
                     expiration=expiration,
+                    make_key=cast(
+                        CacheMakeKey[Args, Hashable],
+                        make_key if make_key is not None else _default_make_key,
+                    ),
                 ),
             )
 
@@ -101,6 +225,7 @@ class _SyncCache[**Args, Result]:
         "_cached",
         "_function",
         "_limit",
+        "_make_key",
         "_next_expire_time",
     )
 
@@ -110,10 +235,13 @@ class _SyncCache[**Args, Result]:
         /,
         limit: int,
         expiration: float | None,
+        make_key: CacheMakeKey[Args, Hashable],
     ) -> None:
         self._function: Callable[Args, Result] = function
         self._cached: OrderedDict[Hashable, _CacheEntry[Result]] = OrderedDict()
         self._limit: int = limit
+        self._make_key: CacheMakeKey[Args, Hashable] = make_key
+
         if expiration := expiration:
 
             def next_expire_time() -> float | None:
@@ -135,27 +263,17 @@ class _SyncCache[**Args, Result]:
         owner: type | None = None,
         /,
     ) -> Callable[Args, Result]:
-        if owner is None or instance is None:
-            return self
-
-        else:
-            return mimic_function(
-                self._function,
-                within=partial(
-                    self.__method_call__,
-                    instance,
-                ),
-            )
+        assert owner is None and instance is None, "cache does not work for classes"  # nosec: B101
+        return self
 
     def __call__(
         self,
         *args: Args.args,
         **kwargs: Args.kwargs,
     ) -> Result:
-        key: Hashable = _make_key(
-            args=args,
-            kwds=kwargs,
-            typed=True,
+        key: Hashable = self._make_key(
+            *args,
+            **kwargs,
         )
 
         match self._cached.get(key):
@@ -164,7 +282,6 @@ class _SyncCache[**Args, Result]:
 
             case entry:
                 if (expire := entry[1]) and expire < monotonic():
-                    # if still running let it complete if able
                     del self._cached[key]  # continue the same way as if empty
 
                 else:
@@ -178,47 +295,11 @@ class _SyncCache[**Args, Result]:
         )
 
         if len(self._cached) > self._limit:
-            # if still running let it complete if able
+            # keep the size limit
             self._cached.popitem(last=False)
 
         return result
 
-    def __method_call__(
-        self,
-        __method_self: object,
-        *args: Args.args,
-        **kwargs: Args.kwargs,
-    ) -> Result:
-        key: Hashable = _make_key(
-            args=(ref(__method_self), *args),
-            kwds=kwargs,
-            typed=True,
-        )
-
-        match self._cached.get(key):
-            case None:
-                pass
-
-            case entry:
-                if (expire := entry[1]) and expire < monotonic():
-                    # if still running let it complete if able
-                    del self._cached[key]  # continue the same way as if empty
-
-                else:
-                    self._cached.move_to_end(key)
-                    return entry[0]
-
-        result: Result = self._function(__method_self, *args, **kwargs)  # pyright: ignore[reportUnknownVariableType, reportCallIssue]
-        self._cached[key] = _CacheEntry(
-            value=result,  # pyright: ignore[reportUnknownArgumentType]
-            expire=self._next_expire_time(),
-        )
-        if len(self._cached) > self._limit:
-            # if still running let it complete if able
-            self._cached.popitem(last=False)
-
-        return result  # pyright: ignore[reportUnknownArgumentType, reportUnknownVariableType]
-
 
 class _AsyncCache[**Args, Result]:
     __slots__ = (
@@ -233,19 +314,23 @@ class _AsyncCache[**Args, Result]:
         "_cached",
         "_function",
         "_limit",
+        "_make_key",
         "_next_expire_time",
     )
 
     def __init__(
         self,
-        function: Callable[Args, Coroutine[None, None, Result]],
+        function: Callable[Args, Coroutine[Any, Any, Result]],
         /,
         limit: int,
         expiration: float | None,
+        make_key: CacheMakeKey[Args, Hashable],
     ) -> None:
-        self._function: Callable[Args, Coroutine[None, None, Result]] = function
-        self._cached: OrderedDict[Hashable, _CacheEntry[Task[Result]]] = OrderedDict()
+        self._function: Callable[Args, Coroutine[Any, Any, Result]] = function
+        self._cached: OrderedDict[Hashable, _CacheEntry[Result]] = OrderedDict()
         self._limit: int = limit
+        self._make_key: CacheMakeKey[Args, Hashable] = make_key
+
         if expiration := expiration:
 
             def next_expire_time() -> float | None:
@@ -266,29 +351,18 @@ class _AsyncCache[**Args, Result]:
         instance: object | None,
         owner: type | None = None,
         /,
-    ) -> Callable[Args, Coroutine[None, None, Result]]:
-        if owner is None or instance is None:
-            return self
-
-        else:
-            return mimic_function(
-                self._function,
-                within=partial(
-                    self.__method_call__,
-                    instance,
-                ),
-            )
+    ) -> Callable[Args, Coroutine[Any, Any, Result]]:
+        assert owner is None and instance is None, "cache does not work for classes"  # nosec: B101
+        return self
 
     async def __call__(
         self,
         *args: Args.args,
         **kwargs: Args.kwargs,
     ) -> Result:
-        loop: AbstractEventLoop = get_running_loop()
-        key: Hashable = _make_key(
-            args=args,
-            kwds=kwargs,
-            typed=True,
+        key: Hashable = self._make_key(
+            *args,
+            **kwargs,
         )
 
         match self._cached.get(key):
@@ -297,60 +371,88 @@ class _AsyncCache[**Args, Result]:
 
             case entry:
                 if (expire := entry[1]) and expire < monotonic():
-                    # if still running let it complete if able
                     del self._cached[key]  # continue the same way as if empty
 
                 else:
                     self._cached.move_to_end(key)
-                    return await shield(entry[0])
+                    return entry[0]
 
-        task: Task[Result] = loop.create_task(self._function(*args, **kwargs))  # pyright: ignore[reportCallIssue]
+        result: Result = await self._function(*args, **kwargs)
         self._cached[key] = _CacheEntry(
-            value=task,
+            value=result,
             expire=self._next_expire_time(),
         )
         if len(self._cached) > self._limit:
-            # if still running let it complete if able
+            # keep the size limit
             self._cached.popitem(last=False)
 
-        return await shield(task)
+        return result
+
+
+class _CustomCache[**Args, Result, Key]:
+    __slots__ = (
+        "__annotations__",
+        "__defaults__",
+        "__doc__",
+        "__globals__",
+        "__kwdefaults__",
+        "__name__",
+        "__qualname__",
+        "__wrapped__",
+        "_expiration",
+        "_function",
+        "_make_key",
+        "_read",
+        "_write",
+    )
+
+    def __init__(
+        self,
+        function: Callable[Args, Coroutine[Any, Any, Result]],
+        /,
+        make_key: CacheMakeKey[Args, Key],
+        read: CacheRead[Key, Result],
+        write: CacheWrite[Key, Result],
+    ) -> None:
+        self._function: Callable[Args, Coroutine[Any, Any, Result]] = function
+        self._make_key: CacheMakeKey[Args, Key] = make_key
+        self._read: CacheRead[Key, Result] = read
+        self._write: CacheWrite[Key, Result] = write
 
-    async def __method_call__(
+        # mimic function attributes if able
+        mimic_function(function, within=self)
+
+    async def __call__(
         self,
-        __method_self: object,
         *args: Args.args,
         **kwargs: Args.kwargs,
     ) -> Result:
-        loop: AbstractEventLoop = get_running_loop()
-        key: Hashable = _make_key(
-            args=(ref(__method_self), *args),
-            kwds=kwargs,
-            typed=True,
+        key: Key = self._make_key(
+            *args,
+            **kwargs,
         )
 
-        match self._cached.get(key):
+        match await self._read(key):
             case None:
-                pass
-
-            case entry:
-                if (expire := entry[1]) and expire < monotonic():
-                    # if still running let it complete if able
-                    del self._cached[key]  # continue the same way as if empty
+                result: Result = await self._function(*args, **kwargs)
+                ctx.spawn(  # write the value asnychronously
+                    self._write,
+                    key=key,
+                    value=result,
+                )
 
-                else:
-                    self._cached.move_to_end(key)
-                    return await shield(entry[0])
+                return result
 
-        task: Task[Result] = loop.create_task(
-            self._function(__method_self, *args, **kwargs),  # pyright: ignore[reportCallIssue, reportUnknownArgumentType]
-        )
-        self._cached[key] = _CacheEntry(
-            value=task,
-            expire=self._next_expire_time(),
-        )
+            case entry:
+                return entry
 
-        if len(self._cached) > self._limit:
-            # if still running let it complete if able
-            self._cached.popitem(last=False)
 
-        return await shield(task)
+def _default_make_key[**Args](
+    *args: Args.args,
+    **kwargs: Args.kwargs,
+) -> Hashable:
+    return _make_key(
+        args=args,
+        kwds=kwargs,
+        typed=True,
+    )

haiway/helpers/retries.py

@@ -1,7 +1,7 @@
 from asyncio import CancelledError, iscoroutinefunction, sleep
 from collections.abc import Callable, Coroutine
 from time import sleep as sleep_sync
-from typing import cast, overload
+from typing import Any, cast, overload
 
 from haiway.context import ctx
 from haiway.utils import mimic_function
@@ -178,12 +178,12 @@ def _wrap_sync[**Args, Result](
 
 
 def _wrap_async[**Args, Result](
-    function: Callable[Args, Coroutine[None, None, Result]],
+    function: Callable[Args, Coroutine[Any, Any, Result]],
     *,
     limit: int,
     delay: Callable[[int, Exception], float] | float | None,
     catching: set[type[Exception]] | tuple[type[Exception], ...],
-) -> Callable[Args, Coroutine[None, None, Result]]:
+) -> Callable[Args, Coroutine[Any, Any, Result]]:
     assert limit > 0, "Limit has to be greater than zero"  # nosec: B101
 
     @mimic_function(function)

haiway/helpers/throttling.py

@@ -7,7 +7,7 @@ from collections import deque
 from collections.abc import Callable, Coroutine
 from datetime import timedelta
 from time import monotonic
-from typing import cast, overload
+from typing import Any, cast, overload
 
 from haiway.utils.mimic import mimic_function
 
@@ -18,9 +18,9 @@ __all__ = [
 
 @overload
 def throttle[**Args, Result](
-    function: Callable[Args, Coroutine[None, None, Result]],
+    function: Callable[Args, Coroutine[Any, Any, Result]],
     /,
-) -> Callable[Args, Coroutine[None, None, Result]]: ...
+) -> Callable[Args, Coroutine[Any, Any, Result]]: ...
 
 
 @overload
@@ -29,21 +29,21 @@ def throttle[**Args, Result](
     limit: int = 1,
     period: timedelta | float = 1,
 ) -> Callable[
-    [Callable[Args, Coroutine[None, None, Result]]], Callable[Args, Coroutine[None, None, Result]]
+    [Callable[Args, Coroutine[Any, Any, Result]]], Callable[Args, Coroutine[Any, Any, Result]]
 ]: ...
 
 
 def throttle[**Args, Result](
-    function: Callable[Args, Coroutine[None, None, Result]] | None = None,
+    function: Callable[Args, Coroutine[Any, Any, Result]] | None = None,
     *,
     limit: int = 1,
     period: timedelta | float = 1,
 ) -> (
     Callable[
-        [Callable[Args, Coroutine[None, None, Result]]],
-        Callable[Args, Coroutine[None, None, Result]],
+        [Callable[Args, Coroutine[Any, Any, Result]]],
+        Callable[Args, Coroutine[Any, Any, Result]],
     ]
-    | Callable[Args, Coroutine[None, None, Result]]
+    | Callable[Args, Coroutine[Any, Any, Result]]
 ):
     """\
     Throttle for function calls with custom limit and period time. \
@@ -53,7 +53,7 @@ def throttle[**Args, Result](
 
     Parameters
     ----------
-    function: Callable[Args, Coroutine[None, None, Result]]
+    function: Callable[Args, Coroutine[Any, Any, Result]]
         function to wrap in throttle
     limit: int
         limit of executions in given period, if no period was specified
@@ -63,17 +63,17 @@ def throttle[**Args, Result](
 
     Returns
     -------
-    Callable[[Callable[Args, Coroutine[None, None, Result]]], Callable[Args, Coroutine[None, None, Result]]] \
-    | Callable[Args, Coroutine[None, None, Result]]
+    Callable[[Callable[Args, Coroutine[Any, Any, Result]]], Callable[Args, Coroutine[Any, Any, Result]]] \
+    | Callable[Args, Coroutine[Any, Any, Result]]
         provided function wrapped in throttle
     """  # noqa: E501
 
     def _wrap(
-        function: Callable[Args, Coroutine[None, None, Result]],
-    ) -> Callable[Args, Coroutine[None, None, Result]]:
+        function: Callable[Args, Coroutine[Any, Any, Result]],
+    ) -> Callable[Args, Coroutine[Any, Any, Result]]:
         assert iscoroutinefunction(function)  # nosec: B101
         return cast(
-            Callable[Args, Coroutine[None, None, Result]],
+            Callable[Args, Coroutine[Any, Any, Result]],
             _AsyncThrottle(
                 function,
                 limit=limit,
@@ -107,12 +107,12 @@ class _AsyncThrottle[**Args, Result]:
 
     def __init__(
         self,
-        function: Callable[Args, Coroutine[None, None, Result]],
+        function: Callable[Args, Coroutine[Any, Any, Result]],
         /,
         limit: int,
         period: timedelta | float,
     ) -> None:
-        self._function: Callable[Args, Coroutine[None, None, Result]] = function
+        self._function: Callable[Args, Coroutine[Any, Any, Result]] = function
         self._entries: deque[float] = deque()
         self._lock: Lock = Lock()
         self._limit: int = limit

haiway/helpers/timeouted.py

@@ -1,5 +1,6 @@
 from asyncio import AbstractEventLoop, Future, Task, TimerHandle, get_running_loop
 from collections.abc import Callable, Coroutine
+from typing import Any
 
 from haiway.utils.mimic import mimic_function
 
@@ -12,8 +13,8 @@ def timeout[**Args, Result](
     timeout: float,
     /,
 ) -> Callable[
-    [Callable[Args, Coroutine[None, None, Result]]],
-    Callable[Args, Coroutine[None, None, Result]],
+    [Callable[Args, Coroutine[Any, Any, Result]]],
+    Callable[Args, Coroutine[Any, Any, Result]],
 ]:
     """\
     Timeout wrapper for a function call. \
@@ -34,8 +35,8 @@ def timeout[**Args, Result](
     """
 
     def _wrap(
-        function: Callable[Args, Coroutine[None, None, Result]],
-    ) -> Callable[Args, Coroutine[None, None, Result]]:
+        function: Callable[Args, Coroutine[Any, Any, Result]],
+    ) -> Callable[Args, Coroutine[Any, Any, Result]]:
         return _AsyncTimeout(
             function,
             timeout=timeout,
@@ -60,11 +61,11 @@ class _AsyncTimeout[**Args, Result]:
 
     def __init__(
         self,
-        function: Callable[Args, Coroutine[None, None, Result]],
+        function: Callable[Args, Coroutine[Any, Any, Result]],
         /,
         timeout: float,
     ) -> None:
-        self._function: Callable[Args, Coroutine[None, None, Result]] = function
+        self._function: Callable[Args, Coroutine[Any, Any, Result]] = function
         self._timeout: float = timeout
 
         # mimic function attributes if able

haiway/utils/always.py

@@ -37,7 +37,7 @@ def always[Value](
 def async_always[Value](
     value: Value,
     /,
-) -> Callable[..., Coroutine[None, None, Value]]:
+) -> Callable[..., Coroutine[Any, Any, Value]]:
     """
     Factory method creating async functions returning always the same value.
 
@@ -48,7 +48,7 @@ def async_always[Value](
 
     Returns
     -------
-    Callable[..., Coroutine[None, None, Value]]
+    Callable[..., Coroutine[Any, Any, Value]]
         async function ignoring arguments and always returning the provided value.
     """
 

{haiway-0.12.1.dist-info → haiway-0.13.1.dist-info}/METADATA

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: haiway
-Version: 0.12.1
+Version: 0.13.1
 Summary: Framework for dependency injection and state management within structured concurrency model.
 Project-URL: Homepage, https://miquido.com
 Project-URL: Repository, https://github.com/miquido/haiway.git
 Maintainer-email: Kacper Kaliński <kacper.kalinski@miquido.com>
 License: MIT License
         
-        Copyright (c) 2024 Miquido
+        Copyright (c) 2024-2025 Miquido
         
         Permission is hereby granted, free of charge, to any person obtaining a copy
         of this software and associated documentation files (the "Software"), to deal
@@ -40,12 +40,12 @@ Requires-Dist: pyright~=1.1; extra == 'dev'
 Requires-Dist: pytest-asyncio~=0.23; extra == 'dev'
 Requires-Dist: pytest-cov~=4.1; extra == 'dev'
 Requires-Dist: pytest~=7.4; extra == 'dev'
-Requires-Dist: ruff~=0.9; extra == 'dev'
+Requires-Dist: ruff~=0.11; extra == 'dev'
 Description-Content-Type: text/markdown
 
 # 🚗 haiway 🚕 🚚 🚙
 
-haiway is a framework helping to build better project codebase by leveraging concepts of structured concurrency and functional programming.
+haiway is a framework designed to facilitate the development of applications using the functional programming paradigm combined with structured concurrency concepts. Unlike traditional object-oriented frameworks, haiway emphasizes immutability, pure functions, and context-based state management, enabling developers to build scalable and maintainable applications. By leveraging context managers combined with context vars, haiway ensures safe state propagation in concurrent environments and simplifies dependency injection through function implementation propagation.
 
 ## 🖥️ Install
 
@@ -65,7 +65,7 @@ We welcome any feedback and suggestions! Feel free to open an issue or pull requ
 
 MIT License
 
-Copyright (c) 2024 Miquido
+Copyright (c) 2024-2025 Miquido
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{haiway-0.12.1.dist-info → haiway-0.13.1.dist-info}/RECORD

@@ -1,21 +1,21 @@
 haiway/__init__.py,sha256=ONC4Hk0GaPzhQ3oYmgh6Z4kJdXQiyJ8ZQcM_hCUz-IY,2045
 haiway/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 haiway/context/__init__.py,sha256=feqd0eJnGQwh4B8BZXpS0fQRE-DqoFCFOHipF1jOY8A,762
-haiway/context/access.py,sha256=3dloiRk4v3ljIJ8LkjW0Tj4vx6G_mDvjEy0lKLU3Wug,18963
+haiway/context/access.py,sha256=CXGe-qkKeG5352_Bo7D4UusnEEQ_SYmRG94RyK5fG8Q,18951
 haiway/context/disposables.py,sha256=vcsh8jRaJ8Q1ob7oh5LsrSPw9f5AMTcaD_p_Gb7tXAI,2588
 haiway/context/identifier.py,sha256=lz-FuspOtsaEsfb7QPrEVWYfbcMJgd3A6BGG3kLbaV0,3914
 haiway/context/logging.py,sha256=F3dr6MLjodg3MX5WTInxn3r3JuihG-giBzumI0GGUQw,5590
 haiway/context/metrics.py,sha256=N20XQtC8au_e_3iWrsZdej78YBEIWF44fdtWcZBWono,5223
-haiway/context/state.py,sha256=E3Z49XeE_EsXfYcPGtd-5_YLD5idK1WMMLZQ02of6cg,4554
-haiway/context/tasks.py,sha256=J1BFQJis_15SIXbFclppxL-AOIThg2KS4SX8Hg_-YRY,2828
+haiway/context/state.py,sha256=qskYoNwN5Ad0OgnyhL-PyGzTZltwVVdE9CEqWWn4lm8,4554
+haiway/context/tasks.py,sha256=MKfsa-921cIpQ_BKskwokjR27suCHkHZa3O9kOE8UOg,2826
 haiway/context/types.py,sha256=VvJA7wAPZ3ISpgyThVguioYUXqhHf0XkPfRd0M1ERiQ,142
-haiway/helpers/__init__.py,sha256=8XRJWNhidWuBKqRZ1Hyc2xqt7DeWLcoOs2V-oexl8VY,579
-haiway/helpers/asynchrony.py,sha256=-yJsttRhKw0GgnzMc0FqIigS5UJl_G0YgkK12V5IzJg,6292
-haiway/helpers/caching.py,sha256=mz8IMKs6KWWVY62PosPbNQ9sGstC6xCWAAWLYZT2oSg,10132
+haiway/helpers/__init__.py,sha256=ZKDlL3twDqXyI1a9FDgRy3m1-Dfycvke6BJ4C3CndEk,671
+haiway/helpers/asynchrony.py,sha256=YHLK5Hjc-5UWlQRypC11yHeEQyeAtHqrMoBTBfqQBvQ,6286
+haiway/helpers/caching.py,sha256=EU5usTHGDzf0SO3bMW4hHB9oZlLlE7BxO_2ckbjYBw8,13274
 haiway/helpers/metrics.py,sha256=lCSvat3IrkmytFdqTvsqkVqYcVOK_bByfwYAe0hJIWg,13614
-haiway/helpers/retries.py,sha256=gIkyUlqJLDYaxIZd3qzeqGFY9y5Gp8dgZLlZ6hs8hoc,7538
-haiway/helpers/throttling.py,sha256=RfQn8GGPqTuPWzA1CJvZvb1s00vryVpo-eqz5EY9vD4,4150
-haiway/helpers/timeouted.py,sha256=T2I2fThDuP_wDq_3QnZdEaUgAD16uRacbSF1fRnzAaE,3326
+haiway/helpers/retries.py,sha256=3m1SsJW_YY_HPufX9LEzcd_MEyRRFNXvSExLeEti8W8,7539
+haiway/helpers/throttling.py,sha256=r9HnUuo4nX36Pf-oMFHUJk-ZCDeXQ__JTDHlkSltRhA,4121
+haiway/helpers/timeouted.py,sha256=DthIm4ytKhmiIKf-pcO_vrO1X-ImZh-sLNCWcLY9gfw,3337
 haiway/helpers/tracing.py,sha256=8Gpcc_DguuHAdaxM4rGP0mB-S-8E7DKt7ZGym9f6x6Q,4018
 haiway/state/__init__.py,sha256=emTuwGFn7HyjyTJ_ass69J5jQIA7_WHO4teZz_dR05Y,355
 haiway/state/attributes.py,sha256=3chvq3ENoIX688RSYiqZnOCpxbzt-kQ2Wl8Fc3vVyMo,23311
@@ -28,7 +28,7 @@ haiway/types/default.py,sha256=h38-zFkbn_UPEiw1SdDF5rkObVmD9UJpmyhOgS1gQ9U,2208
 haiway/types/frozen.py,sha256=CZhFCXnWAKEhuWSfILxA8smfdpMd5Ku694ycfLh98R8,76
 haiway/types/missing.py,sha256=rDnyA2wxPkTbJl0L-zbo0owp7IJ04xkCIp6xD6wh8NI,1712
 haiway/utils/__init__.py,sha256=YBq9hYhrHFB-4d_M53A620-2KEz5SMU31GDBW6gXFnQ,804
-haiway/utils/always.py,sha256=2abp8Lm9rQkrfS3rm1Iqhb-IcWyVfH1BULab3KMxgOw,1234
+haiway/utils/always.py,sha256=u1tssiErzm0Q3ASc3CV1rLhcMQ54MjpMlC_bRJMQhK4,1230
 haiway/utils/collections.py,sha256=IzD-XSEyngKyzLTNG9sr7QjXIneoAzi3oRsDmbRHtzU,3276
 haiway/utils/env.py,sha256=-hI4CgLkzdyueuECVjm-TfR3lQjE2bDsc72w7vNC4nQ,5339
 haiway/utils/freezing.py,sha256=K34ZIMzbkpgkHKH-KF73plEbXExsajNRkRTYp9nJEf4,620
@@ -36,7 +36,7 @@ haiway/utils/logs.py,sha256=oDsc1ZdqKDjlTlctLbDcp9iX98Acr-1tdw-Pyg3DElo,1577
 haiway/utils/mimic.py,sha256=BkVjTVP2TxxC8GChPGyDV6UXVwJmiRiSWeOYZNZFHxs,1828
 haiway/utils/noop.py,sha256=qgbZlOKWY6_23Zs43OLukK2HagIQKRyR04zrFVm5rWI,344
 haiway/utils/queue.py,sha256=Tk1bXvuNbEgapeC3-h_PYBASqVjhEoL8mUvtJnM29xI,4000
-haiway-0.12.1.dist-info/METADATA,sha256=9FgAnUCIw62Vr7u8MOmDbriyyURb-5aOQVSjv1qwMs0,3857
-haiway-0.12.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-haiway-0.12.1.dist-info/licenses/LICENSE,sha256=GehQEW_I1pkmxkkj3NEa7rCTQKYBn7vTPabpDYJlRuo,1063
-haiway-0.12.1.dist-info/RECORD,,
+haiway-0.13.1.dist-info/METADATA,sha256=9YaEi2sxzl_QL76iqwkhmKrWJh_0EQsoaucu9Yf0eXo,4299
+haiway-0.13.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+haiway-0.13.1.dist-info/licenses/LICENSE,sha256=3phcpHVNBP8jsi77gOO0E7rgKeDeu99Pi7DSnK9YHoQ,1069
+haiway-0.13.1.dist-info/RECORD,,

{haiway-0.12.1.dist-info → haiway-0.13.1.dist-info}/licenses/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 Miquido
+Copyright (c) 2024-2025 Miquido
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -18,4 +18,4 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+SOFTWARE.