haiway 0.1.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

haiway/__init__.py

@@ -1,20 +1,13 @@
 from haiway.context import (
-    Dependencies,
-    Dependency,
+    Disposable,
+    Disposables,
     MissingContext,
-    MissingDependency,
     MissingState,
     ScopeMetrics,
     ctx,
 )
-from haiway.helpers import (
-    asynchronous,
-    auto_retry,
-    cached,
-    throttle,
-    with_timeout,
-)
-from haiway.state import Structure
+from haiway.helpers import asynchronous, cache, retry, throttle, timeout
+from haiway.state import State
 from haiway.types import (
     MISSING,
     Missing,
@@ -45,11 +38,10 @@ __all__ = [
     "async_noop",
     "asynchronous",
     "AsyncQueue",
-    "auto_retry",
-    "cached",
+    "cache",
     "ctx",
-    "Dependencies",
-    "Dependency",
+    "Disposable",
+    "Disposables",
     "freeze",
     "frozenlist",
     "getenv_bool",
@@ -62,14 +54,14 @@ __all__ = [
     "Missing",
     "MISSING",
     "MissingContext",
-    "MissingDependency",
     "MissingState",
     "noop",
     "not_missing",
+    "retry",
     "ScopeMetrics",
     "setup_logging",
-    "Structure",
+    "State",
     "throttle",
+    "timeout",
     "when_missing",
-    "with_timeout",
 ]

haiway/context/__init__.py

@@ -1,14 +1,13 @@
 from haiway.context.access import ctx
-from haiway.context.dependencies import Dependencies, Dependency
+from haiway.context.disposables import Disposable, Disposables
 from haiway.context.metrics import ScopeMetrics
-from haiway.context.types import MissingContext, MissingDependency, MissingState
+from haiway.context.types import MissingContext, MissingState
 
 __all__ = [
     "ctx",
-    "Dependencies",
-    "Dependency",
+    "Disposable",
+    "Disposables",
     "MissingContext",
-    "MissingDependency",
     "MissingState",
     "ScopeMetrics",
 ]

haiway/context/access.py

@@ -5,16 +5,17 @@ from asyncio import (
 from collections.abc import (
     Callable,
     Coroutine,
+    Iterable,
 )
 from logging import Logger
 from types import TracebackType
 from typing import Any, final
 
-from haiway.context.dependencies import Dependencies, Dependency
+from haiway.context.disposables import Disposable, Disposables
 from haiway.context.metrics import MetricsContext, ScopeMetrics
 from haiway.context.state import StateContext
 from haiway.context.tasks import TaskGroupContext
-from haiway.state import Structure
+from haiway.state import State
 from haiway.utils import freeze
 
 __all__ = [
@@ -24,25 +25,41 @@ __all__ = [
 
 @final
 class ScopeContext:
-    def __init__(
+    def __init__(  # noqa: PLR0913
         self,
+        trace_id: str | None,
+        name: str,
+        logger: Logger | None,
+        state: tuple[State, ...],
+        disposables: Disposables | None,
         task_group: TaskGroupContext,
-        state: StateContext,
-        metrics: MetricsContext,
         completion: Callable[[ScopeMetrics], Coroutine[None, None, None]] | None,
     ) -> None:
         self._task_group: TaskGroupContext = task_group
-        self._state: StateContext = state
-        self._metrics: MetricsContext = metrics
+        self._logger: Logger | None = logger
+        self._trace_id: str | None = trace_id
+        self._name: str = name
+        self._state_context: StateContext
+        self._state: tuple[State, ...] = state
+        self._disposables: Disposables | None = disposables
+        self._metrics_context: MetricsContext
         self._completion: Callable[[ScopeMetrics], Coroutine[None, None, None]] | None = completion
 
         freeze(self)
 
     def __enter__(self) -> None:
         assert self._completion is None, "Can't enter synchronous context with completion"  # nosec: B101
+        assert self._disposables is None, "Can't enter synchronous context with disposables"  # nosec: B101
+
+        self._state_context = StateContext.updated(self._state)
+        self._metrics_context = MetricsContext.scope(
+            self._name,
+            logger=self._logger,
+            trace_id=self._trace_id,
+        )
 
-        self._state.__enter__()
-        self._metrics.__enter__()
+        self._state_context.__enter__()
+        self._metrics_context.__enter__()
 
     def __exit__(
         self,
@@ -50,49 +67,71 @@ class ScopeContext:
         exc_val: BaseException | None,
         exc_tb: TracebackType | None,
     ) -> None:
-        self._metrics.__exit__(
+        self._metrics_context.__exit__(
             exc_type=exc_type,
             exc_val=exc_val,
             exc_tb=exc_tb,
         )
 
-        self._state.__exit__(
+        self._state_context.__exit__(
             exc_type=exc_type,
             exc_val=exc_val,
             exc_tb=exc_tb,
         )
 
     async def __aenter__(self) -> None:
-        self._state.__enter__()
-        self._metrics.__enter__()
         await self._task_group.__aenter__()
 
+        if self._disposables:
+            self._state_context = StateContext.updated(
+                (*self._state, *await self._disposables.__aenter__())
+            )
+
+        else:
+            self._state_context = StateContext.updated(self._state)
+
+        self._metrics_context = MetricsContext.scope(
+            self._name,
+            logger=self._logger,
+            trace_id=self._trace_id,
+        )
+
+        self._state_context.__enter__()
+        self._metrics_context.__enter__()
+
     async def __aexit__(
         self,
         exc_type: type[BaseException] | None,
         exc_val: BaseException | None,
         exc_tb: TracebackType | None,
     ) -> None:
+        if self._disposables:
+            await self._disposables.__aexit__(
+                exc_type=exc_type,
+                exc_val=exc_val,
+                exc_tb=exc_tb,
+            )
+
         await self._task_group.__aexit__(
             exc_type=exc_type,
             exc_val=exc_val,
             exc_tb=exc_tb,
         )
 
-        self._metrics.__exit__(
+        self._metrics_context.__exit__(
             exc_type=exc_type,
             exc_val=exc_val,
             exc_tb=exc_tb,
         )
 
-        self._state.__exit__(
+        self._state_context.__exit__(
             exc_type=exc_type,
             exc_val=exc_val,
             exc_tb=exc_tb,
         )
 
         if completion := self._completion:
-            await completion(self._metrics._metrics)  # pyright: ignore[reportPrivateUsage]
+            await completion(self._metrics_context._metrics)  # pyright: ignore[reportPrivateUsage]
 
 
 @final
@@ -101,7 +140,8 @@ class ctx:
     def scope(
         name: str,
         /,
-        *state: Structure,
+        *state: State,
+        disposables: Disposables | Iterable[Disposable] | None = None,
         logger: Logger | None = None,
         trace_id: str | None = None,
         completion: Callable[[ScopeMetrics], Coroutine[None, None, None]] | None = None,
@@ -115,9 +155,14 @@ class ctx:
         name: Value
             name of the scope context
 
-        *state: Structure
-            state propagated within the scope context, will be merged with current if any\
-             by replacing current with provided on conflict
+        *state: State | Disposable
+            state propagated within the scope context, will be merged with current state by\
+             replacing current with provided on conflict.
+
+        disposables: Disposables | list[Disposable] | None
+            disposables consumed within the context when entered. Produced state will automatically\
+             be added to the scope state. Using asynchronous context is required if any disposables\
+             were provided.
 
         logger: Logger | None
             logger used within the scope context, when not provided current logger will be used\
@@ -139,20 +184,30 @@ class ctx:
             context object intended to enter context manager with it
         """
 
+        resolved_disposables: Disposables | None
+        match disposables:
+            case None:
+                resolved_disposables = None
+
+            case Disposables() as disposables:
+                resolved_disposables = disposables
+
+            case iterable:
+                resolved_disposables = Disposables(*iterable)
+
         return ScopeContext(
+            trace_id=trace_id,
+            name=name,
+            logger=logger,
+            state=state,
+            disposables=resolved_disposables,
             task_group=TaskGroupContext(),
-            metrics=MetricsContext.scope(
-                name,
-                logger=logger,
-                trace_id=trace_id,
-            ),
-            state=StateContext.updated(state),
             completion=completion,
         )
 
     @staticmethod
     def updated(
-        *state: Structure,
+        *state: State,
     ) -> StateContext:
         """
         Update scope context with given state. When called within an existing context\
@@ -160,7 +215,7 @@ class ctx:
 
         Parameters
         ----------
-        *state: Structure
+        *state: State
             state propagated within the updated scope context, will be merged with current if any\
              by replacing current with provided on conflict
 
@@ -215,28 +270,7 @@ class ctx:
             raise RuntimeError("Attempting to cancel context out of asyncio task")
 
     @staticmethod
-    async def dependency[DependencyType: Dependency](
-        dependency: type[DependencyType],
-        /,
-    ) -> DependencyType:
-        """
-        Access current dependency by its type.
-
-        Parameters
-        ----------
-        dependency: type[DependencyType]
-            type of requested dependency
-
-        Returns
-        -------
-        DependencyType
-            resolved dependency instance
-        """
-
-        return await Dependencies.dependency(dependency)
-
-    @staticmethod
-    def state[StateType: Structure](
+    def state[StateType: State](
         state: type[StateType],
         /,
         default: StateType | None = None,
@@ -261,7 +295,7 @@ class ctx:
         )
 
     @staticmethod
-    def record[Metric: Structure](
+    def record[Metric: State](
         metric: Metric,
         /,
         merge: Callable[[Metric, Metric], Metric] = lambda lhs, rhs: rhs,

haiway/context/disposables.py

@@ -0,0 +1,68 @@
+from asyncio import gather, shield
+from collections.abc import Iterable
+from types import TracebackType
+from typing import Protocol, final, runtime_checkable
+
+from haiway.state import State
+
+__all__ = [
+    "Disposable",
+    "Disposables",
+]
+
+
+@runtime_checkable
+class Disposable(Protocol):
+    async def initialize(self) -> State | None: ...
+    async def dispose(self) -> None: ...
+
+
+@final
+class Disposables:
+    def __init__(
+        self,
+        *disposables: Disposable,
+    ) -> None:
+        self._disposables: tuple[Disposable, ...] = disposables
+
+    async def initialize(self) -> Iterable[State]:
+        return [
+            state
+            for state in await gather(
+                *[disposable.initialize() for disposable in self._disposables],
+            )
+            if state is not None
+        ]
+
+    async def dispose(self) -> None:
+        results: list[BaseException | None] = await shield(
+            gather(
+                *[disposable.dispose() for disposable in self._disposables],
+                return_exceptions=True,
+            ),
+        )
+
+        self._disposables = ()
+        exceptions: list[BaseException] = [
+            exception for exception in results if exception is not None
+        ]
+
+        if len(exceptions) > 1:
+            raise BaseExceptionGroup("Disposing errors", exceptions)
+
+        elif exceptions:
+            raise exceptions[0]
+
+    def __bool__(self) -> bool:
+        return len(self._disposables) > 0
+
+    async def __aenter__(self) -> Iterable[State]:
+        return await self.initialize()
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        await self.dispose()

haiway/context/metrics.py

@@ -9,7 +9,7 @@ from types import TracebackType
 from typing import Any, Self, cast, final, overload
 from uuid import uuid4
 
-from haiway.state import Structure
+from haiway.state import State
 from haiway.utils import freeze
 
 __all__ = [
@@ -30,7 +30,7 @@ class ScopeMetrics:
         self.trace_id: str = trace_id or uuid4().hex
         self._label: str = f"{self.trace_id}|{scope}" if scope else self.trace_id
         self._logger: Logger = logger or getLogger(name=scope)
-        self._metrics: dict[type[Structure], Structure] = {}
+        self._metrics: dict[type[State], State] = {}
         self._nested: list[ScopeMetrics] = []
         self._timestamp: float = monotonic()
         self._completed: Future[float] = get_event_loop().create_future()
@@ -46,11 +46,11 @@ class ScopeMetrics:
     def metrics(
         self,
         *,
-        merge: Callable[[Structure, Structure], Structure] = lambda lhs, rhs: lhs,
-    ) -> list[Structure]:
-        metrics: dict[type[Structure], Structure] = copy(self._metrics)
+        merge: Callable[[State, State], State] = lambda lhs, rhs: lhs,
+    ) -> list[State]:
+        metrics: dict[type[State], State] = copy(self._metrics)
         for metric in chain.from_iterable(nested.metrics(merge=merge) for nested in self._nested):
-            metric_type: type[Structure] = type(metric)
+            metric_type: type[State] = type(metric)
             if current := metrics.get(metric_type):
                 metrics[metric_type] = merge(current, metric)
 
@@ -60,21 +60,21 @@ class ScopeMetrics:
         return list(metrics.values())
 
     @overload
-    def read[Metric: Structure](
+    def read[Metric: State](
         self,
         metric: type[Metric],
         /,
     ) -> Metric | None: ...
 
     @overload
-    def read[Metric: Structure](
+    def read[Metric: State](
         self,
         metric: type[Metric],
         /,
         default: Metric,
     ) -> Metric: ...
 
-    def read[Metric: Structure](
+    def read[Metric: State](
         self,
         metric: type[Metric],
         /,
@@ -82,7 +82,7 @@ class ScopeMetrics:
     ) -> Metric | None:
         return cast(Metric | None, self._metrics.get(metric, default))
 
-    def record[Metric: Structure](
+    def record[Metric: State](
         self,
         metric: Metric,
         /,
@@ -187,7 +187,7 @@ class MetricsContext:
             )
 
     @classmethod
-    def record[Metric: Structure](
+    def record[Metric: State](
         cls,
         metric: Metric,
         /,

haiway/context/state.py

@@ -4,7 +4,7 @@ from types import TracebackType
 from typing import Self, cast, final
 
 from haiway.context.types import MissingContext, MissingState
-from haiway.state import Structure
+from haiway.state import State
 from haiway.utils import freeze
 
 __all__ = [
@@ -17,28 +17,26 @@ __all__ = [
 class ScopeState:
     def __init__(
         self,
-        state: Iterable[Structure],
+        state: Iterable[State],
     ) -> None:
-        self._state: dict[type[Structure], Structure] = {
-            type(element): element for element in state
-        }
+        self._state: dict[type[State], State] = {type(element): element for element in state}
         freeze(self)
 
-    def state[State: Structure](
+    def state[StateType: State](
         self,
-        state: type[State],
+        state: type[StateType],
         /,
-        default: State | None = None,
-    ) -> State:
+        default: StateType | None = None,
+    ) -> StateType:
         if state in self._state:
-            return cast(State, self._state[state])
+            return cast(StateType, self._state[state])
 
         elif default is not None:
             return default
 
         else:
             try:
-                initialized: State = state()
+                initialized: StateType = state()
                 self._state[state] = initialized
                 return initialized
 
@@ -50,7 +48,7 @@ class ScopeState:
 
     def updated(
         self,
-        state: Iterable[Structure],
+        state: Iterable[State],
     ) -> Self:
         if state:
             return self.__class__(
@@ -69,12 +67,12 @@ class StateContext:
     _context = ContextVar[ScopeState]("StateContext")
 
     @classmethod
-    def current[State: Structure](
+    def current[StateType: State](
         cls,
-        state: type[State],
+        state: type[StateType],
         /,
-        default: State | None = None,
-    ) -> State:
+        default: StateType | None = None,
+    ) -> StateType:
         try:
             return cls._context.get().state(state, default=default)
 
@@ -84,7 +82,7 @@ class StateContext:
     @classmethod
     def updated(
         cls,
-        state: Iterable[Structure],
+        state: Iterable[State],
         /,
     ) -> Self:
         try:

haiway/context/types.py

@@ -1,6 +1,5 @@
 __all__ = [
     "MissingContext",
-    "MissingDependency",
     "MissingState",
 ]
 
@@ -9,9 +8,5 @@ class MissingContext(Exception):
     pass
 
 
-class MissingDependency(Exception):
-    pass
-
-
 class MissingState(Exception):
     pass

haiway/helpers/__init__.py

@@ -1,13 +1,13 @@
 from haiway.helpers.asynchronous import asynchronous
-from haiway.helpers.cache import cached
-from haiway.helpers.retry import auto_retry
+from haiway.helpers.cached import cache
+from haiway.helpers.retries import retry
 from haiway.helpers.throttling import throttle
-from haiway.helpers.timeout import with_timeout
+from haiway.helpers.timeouted import timeout
 
 __all__ = [
     "asynchronous",
-    "auto_retry",
-    "cached",
+    "cache",
+    "retry",
     "throttle",
-    "with_timeout",
+    "timeout",
 ]

haiway/helpers/{cache.py → cached.py}

@@ -9,26 +9,26 @@ from weakref import ref
 from haiway.utils.mimic import mimic_function
 
 __all__ = [
-    "cached",
+    "cache",
 ]
 
 
 @overload
-def cached[**Args, Result](
+def cache[**Args, Result](
     function: Callable[Args, Result],
     /,
 ) -> Callable[Args, Result]: ...
 
 
 @overload
-def cached[**Args, Result](
+def cache[**Args, Result](
     *,
     limit: int = 1,
     expiration: float | None = None,
 ) -> Callable[[Callable[Args, Result]], Callable[Args, Result]]: ...
 
 
-def cached[**Args, Result](
+def cache[**Args, Result](
     function: Callable[Args, Result] | None = None,
     *,
     limit: int = 1,

haiway/helpers/{retry.py → retries.py}

@@ -1,17 +1,18 @@
 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 haiway.context import ctx
 from haiway.utils import mimic_function
 
 __all__ = [
-    "auto_retry",
+    "retry",
 ]
 
 
 @overload
-def auto_retry[**Args, Result](
+def retry[**Args, Result](
     function: Callable[Args, Result],
     /,
 ) -> Callable[Args, Result]:
@@ -34,7 +35,7 @@ def auto_retry[**Args, Result](
 
 
 @overload
-def auto_retry[**Args, Result](
+def retry[**Args, Result](
     *,
     limit: int = 1,
     delay: Callable[[int, Exception], float] | float | None = None,
@@ -66,7 +67,7 @@ def auto_retry[**Args, Result](
     """
 
 
-def auto_retry[**Args, Result](
+def retry[**Args, Result](
     function: Callable[Args, Result] | None = None,
     *,
     limit: int = 1,
@@ -115,11 +116,12 @@ def auto_retry[**Args, Result](
                     catching=catching if isinstance(catching, set | tuple) else {catching},
                 ),
             )
+
         else:
-            assert delay is None, "Delay is not supported in sync wrapper"  # nosec: B101
             return _wrap_sync(
                 function,
                 limit=limit,
+                delay=delay,
                 catching=catching if isinstance(catching, set | tuple) else {catching},
             )
 
@@ -133,6 +135,7 @@ def _wrap_sync[**Args, Result](
     function: Callable[Args, Result],
     *,
     limit: int,
+    delay: Callable[[int, Exception], float] | float | None,
     catching: set[type[Exception]] | tuple[type[Exception], ...],
 ) -> Callable[Args, Result]:
     assert limit > 0, "Limit has to be greater than zero"  # nosec: B101
@@ -158,6 +161,16 @@ def _wrap_sync[**Args, Result](
                         exc,
                     )
 
+                    match delay:
+                        case None:
+                            continue
+
+                        case float(strict):
+                            sleep_sync(strict)
+
+                        case make_delay:  # type: Callable[[], float]
+                            sleep_sync(make_delay(attempt, exc))  # pyright: ignore[reportCallIssue, reportUnknownArgumentType]
+
                 else:
                     raise exc
 
@@ -199,10 +212,10 @@ def _wrap_async[**Args, Result](
                             continue
 
                         case float(strict):
-                            await sleep(delay=strict)
+                            await sleep(strict)
 
                         case make_delay:  # type: Callable[[], float]
-                            await sleep(delay=make_delay(attempt, exc))  # pyright: ignore[reportCallIssue, reportUnknownArgumentType]
+                            await sleep(make_delay(attempt, exc))  # pyright: ignore[reportCallIssue, reportUnknownArgumentType]
 
                 else:
                     raise exc

haiway/helpers/{timeout.py → timeouted.py}

@@ -4,11 +4,11 @@ from collections.abc import Callable, Coroutine
 from haiway.utils.mimic import mimic_function
 
 __all__ = [
-    "with_timeout",
+    "timeout",
 ]
 
 
-def with_timeout[**Args, Result](
+def timeout[**Args, Result](
     timeout: float,
     /,
 ) -> Callable[

haiway/state/__init__.py

@@ -1,8 +1,8 @@
 from haiway.state.attributes import AttributeAnnotation, attribute_annotations
-from haiway.state.structure import Structure
+from haiway.state.structure import State
 
 __all__ = [
     "attribute_annotations",
     "AttributeAnnotation",
-    "Structure",
+    "State",
 ]

haiway/state/attributes.py

@@ -52,7 +52,7 @@ def attribute_annotations(
 
     self_annotation = AttributeAnnotation(
         origin=cls,
-        arguments=[],  # ignore self arguments here, Structure will have them resolved at this stage
+        arguments=[],  # ignore self arguments here, State will have them resolved at this stage
     )
     localns: dict[str, Any] = {cls.__name__: cls}
     recursion_guard: dict[Any, AttributeAnnotation] = {cls: self_annotation}

haiway/state/structure.py

@@ -19,12 +19,12 @@ from haiway.state.validation import attribute_type_validator
 from haiway.types.missing import MISSING, Missing
 
 __all__ = [
-    "Structure",
+    "State",
 ]
 
 
 @final
-class StructureAttribute[Value]:
+class StateAttribute[Value]:
     def __init__(
         self,
         annotation: AttributeAnnotation,
@@ -48,7 +48,7 @@ class StructureAttribute[Value]:
     frozen_default=True,
     field_specifiers=(),
 )
-class StructureMeta(type):
+class StateMeta(type):
     def __new__(
         cls,
         /,
@@ -58,7 +58,7 @@ class StructureMeta(type):
         type_parameters: dict[str, Any] | None = None,
         **kwargs: Any,
     ) -> Any:
-        structure_type = type.__new__(
+        state_type = type.__new__(
             cls,
             name,
             bases,
@@ -66,28 +66,28 @@ class StructureMeta(type):
             **kwargs,
         )
 
-        attributes: dict[str, StructureAttribute[Any]] = {}
+        attributes: dict[str, StateAttribute[Any]] = {}
 
         if bases:  # handle base class
             for key, annotation in attribute_annotations(
-                structure_type,
+                state_type,
                 type_parameters=type_parameters,
             ).items():
                 # do not include ClassVars and dunder items
                 if ((get_origin(annotation) or annotation) is ClassVar) or key.startswith("__"):
                     continue
 
-                attributes[key] = StructureAttribute(
+                attributes[key] = StateAttribute(
                     annotation=annotation,
-                    default=getattr(structure_type, key, MISSING),
+                    default=getattr(state_type, key, MISSING),
                     validator=attribute_type_validator(annotation),
                 )
 
-        structure_type.__ATTRIBUTES__ = attributes  # pyright: ignore[reportAttributeAccessIssue]
-        structure_type.__slots__ = frozenset(attributes.keys())  # pyright: ignore[reportAttributeAccessIssue]
-        structure_type.__match_args__ = structure_type.__slots__  # pyright: ignore[reportAttributeAccessIssue]
+        state_type.__ATTRIBUTES__ = attributes  # pyright: ignore[reportAttributeAccessIssue]
+        state_type.__slots__ = frozenset(attributes.keys())  # pyright: ignore[reportAttributeAccessIssue]
+        state_type.__match_args__ = state_type.__slots__  # pyright: ignore[reportAttributeAccessIssue]
 
-        return structure_type
+        return state_type
 
 
 _types_cache: WeakValueDictionary[
@@ -99,12 +99,12 @@ _types_cache: WeakValueDictionary[
 ] = WeakValueDictionary()
 
 
-class Structure(metaclass=StructureMeta):
+class State(metaclass=StateMeta):
     """
     Base class for immutable data structures.
     """
 
-    __ATTRIBUTES__: ClassVar[dict[str, StructureAttribute[Any]]]
+    __ATTRIBUTES__: ClassVar[dict[str, StateAttribute[Any]]]
 
     def __class_getitem__(
         cls,
@@ -151,7 +151,7 @@ class Structure(metaclass=StructureMeta):
         name: str = f"{cls.__name__}[{parameter_names}]"
         bases: tuple[type[Self]] = (cls,)
 
-        parametrized_type: type[Self] = StructureMeta.__new__(
+        parametrized_type: type[Self] = StateMeta.__new__(
             cls.__class__,
             name=name,
             bases=bases,
@@ -211,7 +211,7 @@ class Structure(metaclass=StructureMeta):
         value: Any,
     ) -> Any:
         raise AttributeError(
-            f"Can't modify immutable structure {self.__class__.__qualname__},"
+            f"Can't modify immutable state {self.__class__.__qualname__},"
             f" attribute - '{name}' cannot be modified"
         )
 
@@ -220,7 +220,7 @@ class Structure(metaclass=StructureMeta):
         name: str,
     ) -> None:
         raise AttributeError(
-            f"Can't modify immutable structure {self.__class__.__qualname__},"
+            f"Can't modify immutable state {self.__class__.__qualname__},"
             f" attribute - '{name}' cannot be deleted"
         )
 

{haiway-0.1.0.dist-info → haiway-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: haiway
-Version: 0.1.0
+Version: 0.3.0
 Summary: Framework for dependency injection and state management within structured concurrency model.
 Maintainer-email: Kacper Kaliński <kacper.kalinski@miquido.com>
 License: MIT License

haiway-0.3.0.dist-info/RECORD

@@ -0,0 +1,35 @@
+haiway/__init__.py,sha256=tjFQ9bVnUHs2BMyCPxeNYxqHtqyIZQDk1Wk2nFB_G2U,1138
+haiway/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+haiway/context/__init__.py,sha256=21Y3zvRo1bHASZD6B_FNkU28k1-g88RdmUyqxvYXJxg,336
+haiway/context/access.py,sha256=E9aIC1RUupKk2LXik5qb13oHpW2s_tNQC0UxGcO9xr0,12761
+haiway/context/disposables.py,sha256=VQX9jVo1pjqkmOYzWpsbYyF45y0XtpjorIIaeMBCwTU,1771
+haiway/context/metrics.py,sha256=upkqUp47NymDJE8UQznr99AgaE9yw6i28l_cdCE1IeM,8612
+haiway/context/state.py,sha256=GxGwPQTK8FdSprBd83lQbA9veubp0o93_1Yk3gb7HMc,3000
+haiway/context/tasks.py,sha256=xXtXIUwXOra0EePTdkcEbMOmpWwFcO3hCRfR_IfvAHk,1978
+haiway/context/types.py,sha256=VvJA7wAPZ3ISpgyThVguioYUXqhHf0XkPfRd0M1ERiQ,142
+haiway/helpers/__init__.py,sha256=G8cbw11yb7VxGkAqjVmXPcYKR0eGe-UHa0LUtgHA3Jc,318
+haiway/helpers/asynchronous.py,sha256=FYcV_ERrGy7f47y18oKeUk7fcbk-i_SOuPQ7lHhX5iI,6119
+haiway/helpers/cached.py,sha256=Ok_WE5Whe7XqnIuLZo4rNNBFeWap-aUWX799s4b1JAQ,9536
+haiway/helpers/retries.py,sha256=gIkyUlqJLDYaxIZd3qzeqGFY9y5Gp8dgZLlZ6hs8hoc,7538
+haiway/helpers/throttling.py,sha256=zo0OwFq64si5KUwhd58cFHLmGAmYwRbFRJMbv9suhPs,3844
+haiway/helpers/timeouted.py,sha256=1xU09hQnFdj6p48BwZl5xUvtIr3zC0ZUXehkdrduCjs,3074
+haiway/state/__init__.py,sha256=dh7l_ZImy0uHHDGD-fzMhQFmz_ej8WU8WEE2OmIoyVM,204
+haiway/state/attributes.py,sha256=kkIYNlvWCM1NkgiCbE6gZDwgBVOk_TkmqWv67MmU0to,13399
+haiway/state/structure.py,sha256=G-Ln72hoQtE0FmKHeZdNmXf_FA3f5-e5AGbmJ2yMNb4,7003
+haiway/state/validation.py,sha256=V4Q94Ik4p9t7f-7EIwK3Q9Zki8VkLOjPIGWGwLRVCoc,2873
+haiway/types/__init__.py,sha256=cAJQzDgFi8AKRqpzY3HWrutaPR69tnJqeJK_mQVtYUk,252
+haiway/types/frozen.py,sha256=CZhFCXnWAKEhuWSfILxA8smfdpMd5Ku694ycfLh98R8,76
+haiway/types/missing.py,sha256=3t2bcZuw5fAKiycP-0Aly2TDUWtM3xyHy3KDCT91TLs,1660
+haiway/utils/__init__.py,sha256=UA9h8YDvYI5rYujvsIS9t5Q-SWYImmk30uhR_42flqs,608
+haiway/utils/always.py,sha256=2abp8Lm9rQkrfS3rm1Iqhb-IcWyVfH1BULab3KMxgOw,1234
+haiway/utils/env.py,sha256=lKPOBZWyRD_gQariDGBjVLYTm0740nytPCSQpK2oRyE,3136
+haiway/utils/immutable.py,sha256=K34ZIMzbkpgkHKH-KF73plEbXExsajNRkRTYp9nJEf4,620
+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=WGW8kSusIwRYHsYRIKD2CaqhhC1pUtVgtNHFDXDtYrw,2443
+haiway-0.3.0.dist-info/LICENSE,sha256=GehQEW_I1pkmxkkj3NEa7rCTQKYBn7vTPabpDYJlRuo,1063
+haiway-0.3.0.dist-info/METADATA,sha256=rABSQCD4Sboe2cC-p3hruWyxM0DrxggLozH0Ma-MIYM,3872
+haiway-0.3.0.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
+haiway-0.3.0.dist-info/top_level.txt,sha256=_LdXVLzUzgkvAGQnQJj5kQfoFhpPW6EF4Kj9NapniLg,7
+haiway-0.3.0.dist-info/RECORD,,

haiway/context/dependencies.py

@@ -1,61 +0,0 @@
-from abc import ABC, abstractmethod
-from asyncio import Lock, gather, shield
-from typing import ClassVar, Self, cast, final
-
-__all__ = [
-    "Dependencies",
-    "Dependency",
-]
-
-
-class Dependency(ABC):
-    @classmethod
-    @abstractmethod
-    async def prepare(cls) -> Self: ...
-
-    async def dispose(self) -> None:  # noqa: B027
-        pass
-
-
-@final
-class Dependencies:
-    _lock: ClassVar[Lock] = Lock()
-    _dependencies: ClassVar[dict[type[Dependency], Dependency]] = {}
-
-    def __init__(self) -> None:
-        raise NotImplementedError("Can't instantiate Dependencies")
-
-    @classmethod
-    async def dependency[Requested: Dependency](
-        cls,
-        dependency: type[Requested],
-        /,
-    ) -> Requested:
-        async with cls._lock:
-            if dependency not in cls._dependencies:
-                cls._dependencies[dependency] = await dependency.prepare()
-
-            return cast(Requested, cls._dependencies[dependency])
-
-    @classmethod
-    async def register(
-        cls,
-        dependency: Dependency,
-        /,
-    ) -> None:
-        async with cls._lock:
-            if current := cls._dependencies.get(dependency.__class__):
-                await current.dispose()
-
-            cls._dependencies[dependency.__class__] = dependency
-
-    @classmethod
-    async def dispose(cls) -> None:
-        async with cls._lock:
-            await shield(
-                gather(
-                    *[dependency.dispose() for dependency in cls._dependencies.values()],
-                    return_exceptions=False,
-                )
-            )
-            cls._dependencies.clear()

haiway-0.1.0.dist-info/RECORD

@@ -1,35 +0,0 @@
-haiway/__init__.py,sha256=20WZqVGbImtVKnZLFw1CU1usQbXjLSEHcu1J07OTEhA,1243
-haiway/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-haiway/context/__init__.py,sha256=iD_AjgtyJthrkF0Ys2vHxSDLDK54GkcLk-h33HyD4P0,383
-haiway/context/access.py,sha256=pdc0pZIwQlW24hDcojoE3lUrpC2zvyH-PtoOOGS7D9g,11263
-haiway/context/dependencies.py,sha256=US1TYM78AHujat9SxLKrP7Ow1dctdLN-OqEx3grBv0Y,1609
-haiway/context/metrics.py,sha256=OF06T9Er62SJPCZmQF9SnMW8lO9HGxDP3qUkvk6mXUo,8672
-haiway/context/state.py,sha256=aQgUE3tAWPEYgGv4P16Yk9RkOouY8UpkEpjhzv0AwkA,3014
-haiway/context/tasks.py,sha256=xXtXIUwXOra0EePTdkcEbMOmpWwFcO3hCRfR_IfvAHk,1978
-haiway/context/types.py,sha256=OS3d2A0F2CbOpz_hxAhBitSH2_Bs8Aw-kIL6mEBmZdw,214
-haiway/helpers/__init__.py,sha256=WBGQ3pF6EhCjEQLpMfpW7LwF5u-iR26fr9q6l7xTEJE,335
-haiway/helpers/asynchronous.py,sha256=FYcV_ERrGy7f47y18oKeUk7fcbk-i_SOuPQ7lHhX5iI,6119
-haiway/helpers/cache.py,sha256=oONE0xKIfhvPA_wnY8JV_2CtOeSrHAoNpu5n7t-jd8w,9540
-haiway/helpers/retry.py,sha256=qFeLvOiqAktF-awkh-hTdhyT2zf6kGV0VxAIBrUVdn0,7135
-haiway/helpers/throttling.py,sha256=zo0OwFq64si5KUwhd58cFHLmGAmYwRbFRJMbv9suhPs,3844
-haiway/helpers/timeout.py,sha256=iNfDotZ4G9rb_zEuEgzaZP37QqkkXQyEFHClA4Eckl0,3084
-haiway/state/__init__.py,sha256=sFEo9tWwMK5r6RR_D6d2xRL2Tcb7NgWIEUHx-FCbvbI,212
-haiway/state/attributes.py,sha256=DIjr8NAhabJJiHHiNc_t7-t9AncobiXg_JRZ3lJ-_G0,13403
-haiway/state/structure.py,sha256=AQIVz-DUBMFMgBHXbOvLrplmdSCmL3xRjCDwNhFTLV8,7079
-haiway/state/validation.py,sha256=V4Q94Ik4p9t7f-7EIwK3Q9Zki8VkLOjPIGWGwLRVCoc,2873
-haiway/types/__init__.py,sha256=cAJQzDgFi8AKRqpzY3HWrutaPR69tnJqeJK_mQVtYUk,252
-haiway/types/frozen.py,sha256=CZhFCXnWAKEhuWSfILxA8smfdpMd5Ku694ycfLh98R8,76
-haiway/types/missing.py,sha256=3t2bcZuw5fAKiycP-0Aly2TDUWtM3xyHy3KDCT91TLs,1660
-haiway/utils/__init__.py,sha256=UA9h8YDvYI5rYujvsIS9t5Q-SWYImmk30uhR_42flqs,608
-haiway/utils/always.py,sha256=2abp8Lm9rQkrfS3rm1Iqhb-IcWyVfH1BULab3KMxgOw,1234
-haiway/utils/env.py,sha256=lKPOBZWyRD_gQariDGBjVLYTm0740nytPCSQpK2oRyE,3136
-haiway/utils/immutable.py,sha256=K34ZIMzbkpgkHKH-KF73plEbXExsajNRkRTYp9nJEf4,620
-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=WGW8kSusIwRYHsYRIKD2CaqhhC1pUtVgtNHFDXDtYrw,2443
-haiway-0.1.0.dist-info/LICENSE,sha256=GehQEW_I1pkmxkkj3NEa7rCTQKYBn7vTPabpDYJlRuo,1063
-haiway-0.1.0.dist-info/METADATA,sha256=ZHdNdTn7cjJQUK6pK8onjkNS0QmOhjpFCWLsQyqQE0o,3872
-haiway-0.1.0.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
-haiway-0.1.0.dist-info/top_level.txt,sha256=_LdXVLzUzgkvAGQnQJj5kQfoFhpPW6EF4Kj9NapniLg,7
-haiway-0.1.0.dist-info/RECORD,,