haiway 0.13.0__py3-none-any.whl → 0.14.0__py3-none-any.whl

haiway/__init__.py

@@ -40,6 +40,7 @@ from haiway.types import (
 )
 from haiway.utils import (
     AsyncQueue,
+    AsyncStream,
     always,
     as_dict,
     as_list,
@@ -63,6 +64,7 @@ __all__ = [
     "MISSING",
     "ArgumentsTrace",
     "AsyncQueue",
+    "AsyncStream",
     "AttributePath",
     "AttributeRequirement",
     "Default",

haiway/context/access.py

@@ -11,7 +11,6 @@ from collections.abc import (
     Coroutine,
     Iterable,
 )
-from contextvars import Context, copy_context
 from logging import Logger
 from types import TracebackType
 from typing import Any, final, overload
@@ -24,6 +23,7 @@ from haiway.context.state import StateContext
 from haiway.context.tasks import TaskGroupContext
 from haiway.state import State
 from haiway.utils import mimic_function
+from haiway.utils.stream import AsyncStream
 
 __all__ = [
     "ctx",
@@ -37,7 +37,6 @@ class ScopeContext:
         "_identifier",
         "_logger_context",
         "_metrics_context",
-        "_state",
         "_state_context",
         "_task_group_context",
     )
@@ -67,13 +66,12 @@ class ScopeContext:
         )
         # postponing task group creation to include only when needed
         self._task_group_context: TaskGroupContext
-        # postponing state creation to include disposables state when prepared
+        # prepare state context to capture current state
         self._state_context: StateContext
-        self._state: tuple[State, ...]
         object.__setattr__(
             self,
-            "_state",
-            state,
+            "_state_context",
+            StateContext.updated(state),
         )
         self._disposables: Disposables | None
         object.__setattr__(
@@ -115,12 +113,6 @@ class ScopeContext:
         assert self._disposables is None, "Can't enter synchronous context with disposables"  # nosec: B101
         self._identifier.__enter__()
         self._logger_context.__enter__()
-        # lazily initialize state
-        object.__setattr__(
-            self,
-            "_state_context",
-            StateContext.updated(self._state),
-        )
         self._state_context.__enter__()
         self._metrics_context.__enter__()
 
@@ -169,24 +161,17 @@ class ScopeContext:
 
         # lazily initialize state to include disposables results
         if self._disposables is not None:
+            assert self._state_context._token is None  # nosec: B101
             object.__setattr__(
                 self,
                 "_state_context",
-                StateContext.updated(
-                    (
-                        *self._state,
-                        *await self._disposables.__aenter__(),
-                    )
+                StateContext(
+                    state=self._state_context._state.updated(
+                        await self._disposables.__aenter__(),
+                    ),
                 ),
             )
 
-        else:
-            object.__setattr__(
-                self,
-                "_state_context",
-                StateContext.updated(self._state),
-            )
-
         self._state_context.__enter__()
         self._metrics_context.__enter__()
 
@@ -238,8 +223,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 +234,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 +357,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 +368,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
@@ -401,12 +386,12 @@ class ctx:
         return TaskGroupContext.run(function, *args, **kwargs)
 
     @staticmethod
-    def stream[Result, **Arguments](
-        source: Callable[Arguments, AsyncGenerator[Result, None]],
+    def stream[Element, **Arguments](
+        source: Callable[Arguments, AsyncGenerator[Element, None]],
         /,
         *args: Arguments.args,
         **kwargs: Arguments.kwargs,
-    ) -> AsyncIterator[Result]:
+    ) -> AsyncIterator[Element]:
         """
         Stream results produced by a generator within the proper context state.
 
@@ -427,25 +412,22 @@ class ctx:
             iterator for accessing generated results
         """
 
-        # prepare context snapshot
-        context_snapshot: Context = copy_context()
-
-        # prepare nested context
-        streaming_context: ScopeContext = ctx.scope(
-            getattr(
-                source,
-                "__name__",
-                "streaming",
-            )
-        )
+        output_stream = AsyncStream[Element]()
 
-        async def generator() -> AsyncGenerator[Result, None]:
-            async with streaming_context:
+        @ctx.scope("stream")
+        async def stream() -> None:
+            try:
                 async for result in source(*args, **kwargs):
-                    yield result
+                    await output_stream.send(result)
+
+            except BaseException as exc:
+                output_stream.finish(exception=exc)
+
+            else:
+                output_stream.finish()
 
-        # finally return it as an iterator
-        return context_snapshot.run(generator)
+        TaskGroupContext.run(stream)
+        return output_stream
 
     @staticmethod
     def check_cancellation() -> None:
@@ -488,7 +470,7 @@ class ctx:
         StateType
             resolved state instance
         """
-        return StateContext.current(
+        return StateContext.state(
             state,
             default=default,
         )

haiway/context/state.py

@@ -92,7 +92,7 @@ class StateContext:
     _context = ContextVar[ScopeState]("StateContext")
 
     @classmethod
-    def current[StateType: State](
+    def state[StateType: State](
         cls,
         state: type[StateType],
         /,

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

@@ -3,12 +3,15 @@ from collections import OrderedDict
 from collections.abc import Callable, Coroutine, Hashable
 from functools import _make_key  # pyright: ignore[reportPrivateUsage]
 from time import monotonic
-from typing import NamedTuple, Protocol, cast, overload
+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",
 ]
 
@@ -59,7 +62,7 @@ def cache[**Args, Result, Key](
     read: CacheRead[Key, Result],
     write: CacheWrite[Key, Result],
 ) -> 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]]
 ]: ...
 
 
@@ -73,8 +76,8 @@ def cache[**Args, Result, Key](  # noqa: PLR0913
     write: CacheWrite[Key, Result] | None = None,
 ) -> (
     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[[Callable[Args, Result]], Callable[Args, Result]]
     | Callable[Args, Result]
@@ -317,13 +320,13 @@ class _AsyncCache[**Args, Result]:
 
     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._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
@@ -348,7 +351,7 @@ class _AsyncCache[**Args, Result]:
         instance: object | None,
         owner: type | None = None,
         /,
-    ) -> Callable[Args, Coroutine[None, None, Result]]:
+    ) -> Callable[Args, Coroutine[Any, Any, Result]]:
         assert owner is None and instance is None, "cache does not work for classes"  # nosec: B101
         return self
 
@@ -405,13 +408,13 @@ class _CustomCache[**Args, Result, Key]:
 
     def __init__(
         self,
-        function: Callable[Args, Coroutine[None, None, Result]],
+        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[None, None, Result]] = function
+        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

haiway/helpers/metrics.py

@@ -15,6 +15,7 @@ __all_ = [
 
 class MetricsScopeStore:
     __slots__ = (
+        "allow_exit",
         "entered",
         "exited",
         "identifier",
@@ -31,6 +32,7 @@ class MetricsScopeStore:
         self.entered: float = monotonic()
         self.metrics: dict[type[State], State] = {}
         self.exited: float | None = None
+        self.allow_exit: bool = False
         self.nested: list[MetricsScopeStore] = []
 
     @property
@@ -115,7 +117,7 @@ class MetricsHolder:
 
     def __init__(self) -> None:
         self.root_scope: ScopeIdentifier | None = None
-        self.scopes: dict[ScopeIdentifier, MetricsScopeStore] = {}
+        self.scopes: dict[str, MetricsScopeStore] = {}
 
     def record(
         self,
@@ -124,10 +126,10 @@ class MetricsHolder:
         metric: State,
     ) -> None:
         assert self.root_scope is not None  # nosec: B101
-        assert scope in self.scopes  # nosec: B101
+        assert scope.scope_id in self.scopes  # nosec: B101
 
         metric_type: type[State] = type(metric)
-        metrics: dict[type[State], State] = self.scopes[scope].metrics
+        metrics: dict[type[State], State] = self.scopes[scope.scope_id].metrics
         if (current := metrics.get(metric_type)) and hasattr(current, "__add__"):
             metrics[type(metric)] = current.__add__(metric)  # pyright: ignore[reportUnknownMemberType, reportAttributeAccessIssue]
 
@@ -142,29 +144,29 @@ class MetricsHolder:
         merged: bool,
     ) -> Metric | None:
         assert self.root_scope is not None  # nosec: B101
-        assert scope in self.scopes  # nosec: B101
+        assert scope.scope_id in self.scopes  # nosec: B101
 
         if merged:
-            return self.scopes[scope].merged(metric)
+            return self.scopes[scope.scope_id].merged(metric)
 
         else:
-            return cast(Metric | None, self.scopes[scope].metrics.get(metric))
+            return cast(Metric | None, self.scopes[scope.scope_id].metrics.get(metric))
 
     def enter_scope[Metric: State](
         self,
         scope: ScopeIdentifier,
         /,
     ) -> None:
-        assert scope not in self.scopes  # nosec: B101
+        assert scope.scope_id not in self.scopes  # nosec: B101
         scope_metrics = MetricsScopeStore(scope)
-        self.scopes[scope] = scope_metrics
+        self.scopes[scope.scope_id] = scope_metrics
 
         if self.root_scope is None:
             self.root_scope = scope
 
         else:
             for key in self.scopes.keys():
-                if key.scope_id == scope.parent_id:
+                if key == scope.parent_id:
                     self.scopes[key].nested.append(scope_metrics)
                     return
 
@@ -177,8 +179,18 @@ class MetricsHolder:
         scope: ScopeIdentifier,
         /,
     ) -> None:
-        assert scope in self.scopes  # nosec: B101
-        self.scopes[scope].exited = monotonic()
+        assert self.root_scope is not None  # nosec: B101
+        assert scope.scope_id in self.scopes  # nosec: B101
+
+        self.scopes[scope.scope_id].allow_exit = True
+
+        if not all(nested.exited for nested in self.scopes[scope.scope_id].nested):
+            return  # not completed yet
+
+        self.scopes[scope.scope_id].exited = monotonic()
+
+        if scope != self.root_scope and self.scopes[scope.parent_id].allow_exit:
+            self.exit_scope(self.scopes[scope.parent_id].identifier)
 
 
 @final
@@ -213,7 +225,7 @@ class MetricsLogger:
         redact_content: bool,
     ) -> None:
         self.root_scope: ScopeIdentifier | None = None
-        self.scopes: dict[ScopeIdentifier, MetricsScopeStore] = {}
+        self.scopes: dict[str, MetricsScopeStore] = {}
         self.items_limit: int | None = items_limit
         self.redact_content: bool = redact_content
 
@@ -224,10 +236,10 @@ class MetricsLogger:
         metric: State,
     ) -> None:
         assert self.root_scope is not None  # nosec: B101
-        assert scope in self.scopes  # nosec: B101
+        assert scope.scope_id in self.scopes  # nosec: B101
 
         metric_type: type[State] = type(metric)
-        metrics: dict[type[State], State] = self.scopes[scope].metrics
+        metrics: dict[type[State], State] = self.scopes[scope.scope_id].metrics
         if (current := metrics.get(metric_type)) and hasattr(current, "__add__"):
             metrics[type(metric)] = current.__add__(metric)  # pyright: ignore[reportUnknownMemberType, reportAttributeAccessIssue]
 
@@ -248,29 +260,29 @@ class MetricsLogger:
         merged: bool,
     ) -> Metric | None:
         assert self.root_scope is not None  # nosec: B101
-        assert scope in self.scopes  # nosec: B101
+        assert scope.scope_id in self.scopes  # nosec: B101
 
         if merged:
-            return self.scopes[scope].merged(metric)
+            return self.scopes[scope.scope_id].merged(metric)
 
         else:
-            return cast(Metric | None, self.scopes[scope].metrics.get(metric))
+            return cast(Metric | None, self.scopes[scope.scope_id].metrics.get(metric))
 
     def enter_scope[Metric: State](
         self,
         scope: ScopeIdentifier,
         /,
     ) -> None:
-        assert scope not in self.scopes  # nosec: B101
+        assert scope.scope_id not in self.scopes  # nosec: B101
         scope_metrics = MetricsScopeStore(scope)
-        self.scopes[scope] = scope_metrics
+        self.scopes[scope.scope_id] = scope_metrics
 
         if self.root_scope is None:
             self.root_scope = scope
 
         else:
             for key in self.scopes.keys():
-                if key.scope_id == scope.parent_id:
+                if key == scope.parent_id:
                     self.scopes[key].nested.append(scope_metrics)
                     return
 
@@ -283,12 +295,22 @@ class MetricsLogger:
         scope: ScopeIdentifier,
         /,
     ) -> None:
-        assert scope in self.scopes  # nosec: B101
-        self.scopes[scope].exited = monotonic()
+        assert self.root_scope is not None  # nosec: B101
+        assert scope.scope_id in self.scopes  # nosec: B101
+
+        self.scopes[scope.scope_id].allow_exit = True
+
+        if not all(nested.exited for nested in self.scopes[scope.scope_id].nested):
+            return  # not completed yet
+
+        self.scopes[scope.scope_id].exited = monotonic()
+
+        if scope != self.root_scope and self.scopes[scope.parent_id].allow_exit:
+            self.exit_scope(self.scopes[scope.parent_id].identifier)
 
-        if scope == self.root_scope and self.scopes[scope].finished:
+        elif scope == self.root_scope and self.scopes[self.root_scope.scope_id].finished:
             if log := _tree_log(
-                self.scopes[scope],
+                self.scopes[scope.scope_id],
                 list_items_limit=self.items_limit,
                 redact_content=self.redact_content,
             ):

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/__init__.py

@@ -13,9 +13,11 @@ from haiway.utils.logs import setup_logging
 from haiway.utils.mimic import mimic_function
 from haiway.utils.noop import async_noop, noop
 from haiway.utils.queue import AsyncQueue
+from haiway.utils.stream import AsyncStream
 
 __all__ = [
     "AsyncQueue",
+    "AsyncStream",
     "always",
     "as_dict",
     "as_list",

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/utils/stream.py

@@ -0,0 +1,97 @@
+from asyncio import (
+    AbstractEventLoop,
+    CancelledError,
+    Future,
+    get_running_loop,
+)
+from collections.abc import AsyncIterator
+
+__all__ = [
+    "AsyncStream",
+]
+
+
+class AsyncStream[Element](AsyncIterator[Element]):
+    def __init__(
+        self,
+        loop: AbstractEventLoop | None = None,
+    ) -> None:
+        self._loop: AbstractEventLoop = loop or get_running_loop()
+        self._ready: Future[None] = self._loop.create_future()
+        self._waiting: Future[Element] | None = None
+        self._finish_reason: BaseException | None = None
+
+    @property
+    def finished(self) -> bool:
+        return self._finish_reason is not None
+
+    async def send(
+        self,
+        element: Element,
+        /,
+    ) -> None:
+        if self._finish_reason is not None:
+            return  # already finished
+
+        # wait for readiness
+        await self._ready
+        # we could finish while waiting
+        if self._finish_reason is not None:
+            return  # already finished
+
+        assert self._waiting is not None and not self._waiting.done()  # nosec: B101
+        # send the element
+        self._waiting.set_result(element)
+        # and create new readiness future afterwards
+        self._ready = self._loop.create_future()
+
+    def finish(
+        self,
+        exception: BaseException | None = None,
+    ) -> None:
+        if self.finished:
+            return  # already finished, ignore
+
+        self._finish_reason = exception or StopAsyncIteration()
+
+        if not self._ready.done():
+            if get_running_loop() is not self._loop:
+                self._loop.call_soon_threadsafe(
+                    self._ready.set_result,
+                    None,
+                )
+
+            else:
+                self._ready.set_result(None)
+
+        if self._waiting is not None and not self._waiting.done():
+            if get_running_loop() is not self._loop:
+                self._loop.call_soon_threadsafe(
+                    self._waiting.set_exception,
+                    self._finish_reason,
+                )
+
+            else:
+                self._waiting.set_exception(self._finish_reason)
+
+    def cancel(self) -> None:
+        self.finish(exception=CancelledError())
+
+    async def __anext__(self) -> Element:
+        assert self._waiting is None, "AsyncStream can't be reused"  # nosec: B101
+
+        if self._finish_reason:
+            raise self._finish_reason
+
+        try:
+            assert not self._ready.done()  # nosec: B101
+            # create new waiting future
+            self._waiting = self._loop.create_future()
+            # and notify readiness
+            self._ready.set_result(None)
+            # and wait for the result
+            return await self._waiting
+
+        finally:
+            # cleanup waiting future
+            self._waiting = None

{haiway-0.13.0.dist-info → haiway-0.14.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: haiway
-Version: 0.13.0
+Version: 0.14.0
 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

{haiway-0.13.0.dist-info → haiway-0.14.0.dist-info}/RECORD

@@ -1,21 +1,21 @@
-haiway/__init__.py,sha256=ONC4Hk0GaPzhQ3oYmgh6Z4kJdXQiyJ8ZQcM_hCUz-IY,2045
+haiway/__init__.py,sha256=RhW9HOIAVQ3srQ-v23tPghJ20dWcn_uAyt8U8Hhn868,2081
 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=1Oq70pcp54bC9NNp-zMocDewVJpcZgepi99_xeqz98o,18502
 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=qskYoNwN5Ad0OgnyhL-PyGzTZltwVVdE9CEqWWn4lm8,4554
-haiway/context/tasks.py,sha256=J1BFQJis_15SIXbFclppxL-AOIThg2KS4SX8Hg_-YRY,2828
+haiway/context/state.py,sha256=7pXb5gvyPOWiRbxX-sSfO-hjaHcTUIp_uTKhjaSLeRo,4552
+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=iy2upZnlpLWc1FjQP0EjAu8j-Vl0yHZmIZ93K6Gc-yY,13232
-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/__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=VNxgPgV8pgt-51f2CANy1IVx8VMYIAxT3F849t3IeQs,14604
+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
@@ -27,8 +27,8 @@ haiway/types/__init__.py,sha256=-j4uDN6ix3GBXLBqXC-k_QOJSDlO6zvNCxDej8vVzek,342
 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/__init__.py,sha256=JYo5EVquL2BCBsHtvySPTio_x5hSVDJCfu_naWzbqKE,867
+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,8 @@ 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.13.0.dist-info/METADATA,sha256=vlLkeTbiQjf4ilZEEqTwrj18ZzgFzl_rPSHExuTxb0A,4299
-haiway-0.13.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-haiway-0.13.0.dist-info/licenses/LICENSE,sha256=3phcpHVNBP8jsi77gOO0E7rgKeDeu99Pi7DSnK9YHoQ,1069
-haiway-0.13.0.dist-info/RECORD,,
+haiway/utils/stream.py,sha256=Vqyi0EwcupkVyKQ7eple6z9DkcbSHkE-6yMw85mak9Q,2832
+haiway-0.14.0.dist-info/METADATA,sha256=e01xN8K8-d8RiPRaV2ibtsxEHfITllUZmxZA_VzEpBs,4299
+haiway-0.14.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+haiway-0.14.0.dist-info/licenses/LICENSE,sha256=3phcpHVNBP8jsi77gOO0E7rgKeDeu99Pi7DSnK9YHoQ,1069
+haiway-0.14.0.dist-info/RECORD,,