haiway 0.2.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

haiway/__init__.py

@@ -1,10 +1,12 @@
 from haiway.context import (
+    Disposable,
+    Disposables,
     MissingContext,
     MissingState,
     ScopeMetrics,
     ctx,
 )
-from haiway.helpers import Disposable, Disposables, asynchronous, cache, retry, throttle, timeout
+from haiway.helpers import asynchronous, cache, retry, throttle, timeout
 from haiway.state import State
 from haiway.types import (
     MISSING,

haiway/context/__init__.py

@@ -1,9 +1,12 @@
 from haiway.context.access import ctx
+from haiway.context.disposables import Disposable, Disposables
 from haiway.context.metrics import ScopeMetrics
 from haiway.context.types import MissingContext, MissingState
 
 __all__ = [
     "ctx",
+    "Disposable",
+    "Disposables",
     "MissingContext",
     "MissingState",
     "ScopeMetrics",

haiway/context/access.py

@@ -5,11 +5,13 @@ 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.disposables import Disposable, Disposables
 from haiway.context.metrics import MetricsContext, ScopeMetrics
 from haiway.context.state import StateContext
 from haiway.context.tasks import TaskGroupContext
@@ -23,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,
@@ -49,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,6 +141,7 @@ class ctx:
         name: str,
         /,
         *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,
@@ -114,9 +155,14 @@ class ctx:
         name: Value
             name of the scope context
 
-        *state: State
-            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\
@@ -138,14 +184,24 @@ 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,
         )
 

haiway/{helpers → context}/disposables.py

@@ -53,6 +53,9 @@ class Disposables:
         elif exceptions:
             raise exceptions[0]
 
+    def __bool__(self) -> bool:
+        return len(self._disposables) > 0
+
     async def __aenter__(self) -> Iterable[State]:
         return await self.initialize()
 

haiway/helpers/__init__.py

@@ -1,6 +1,5 @@
-from haiway.helpers.asynchronous import asynchronous
-from haiway.helpers.cached import cache
-from haiway.helpers.disposables import Disposable, Disposables
+from haiway.helpers.asynchrony import asynchronous
+from haiway.helpers.caching import cache
 from haiway.helpers.retries import retry
 from haiway.helpers.throttling import throttle
 from haiway.helpers.timeouted import timeout
@@ -8,8 +7,6 @@ from haiway.helpers.timeouted import timeout
 __all__ = [
     "asynchronous",
     "cache",
-    "Disposable",
-    "Disposables",
     "retry",
     "throttle",
     "timeout",

haiway/helpers/{asynchronous.py → asynchrony.py}

@@ -3,9 +3,9 @@ from collections.abc import Callable, Coroutine
 from concurrent.futures import Executor
 from contextvars import Context, copy_context
 from functools import partial
-from typing import Any, Literal, cast, overload
+from typing import Any, cast, overload
 
-from haiway.types.missing import MISSING, Missing, not_missing
+from haiway.types.missing import MISSING, Missing
 
 __all__ = [
     "asynchronous",
@@ -25,7 +25,7 @@ def asynchronous[**Args, Result]() -> (
 def asynchronous[**Args, Result](
     *,
     loop: AbstractEventLoop | None = None,
-    executor: Executor | Literal["default"],
+    executor: Executor,
 ) -> Callable[
     [Callable[Args, Result]],
     Callable[Args, Coroutine[None, None, Result]],
@@ -43,7 +43,7 @@ def asynchronous[**Args, Result](
     function: Callable[Args, Result] | None = None,
     /,
     loop: AbstractEventLoop | None = None,
-    executor: Executor | Literal["default"] | Missing = MISSING,
+    executor: Executor | Missing = MISSING,
 ) -> (
     Callable[
         [Callable[Args, Result]],
@@ -63,10 +63,9 @@ def asynchronous[**Args, Result](
     loop: AbstractEventLoop | None
         loop used to call the function. When None was provided the loop currently running while \
         executing the function will be used. Default is None.
-    executor: Executor | Literal["default"] | Missing
-        executor used to run the function. Specifying "default" uses a default loop executor.
-        When not provided (Missing) no executor will be used \
-        (function will by just wrapped as an async function without any executor)
+    executor: Executor | Missing
+        executor used to run the function. When not provided (Missing) default loop executor\
+         will be used.
 
     Returns
     -------
@@ -79,26 +78,11 @@ def asynchronous[**Args, Result](
     ) -> Callable[Args, Coroutine[None, None, Result]]:
         assert not iscoroutinefunction(wrapped), "Cannot wrap async function in executor"  # nosec: B101
 
-        if not_missing(executor):
-            return _ExecutorWrapper(
-                wrapped,
-                loop=loop,
-                executor=cast(Executor | None, None if executor == "default" else executor),
-            )
-
-        else:
-
-            async def wrapper(
-                *args: Args.args,
-                **kwargs: Args.kwargs,
-            ) -> Result:
-                return wrapped(
-                    *args,
-                    **kwargs,
-                )
-
-            _mimic_async(wrapped, within=wrapper)
-            return wrapper
+        return _ExecutorWrapper(
+            wrapped,
+            loop=loop,
+            executor=cast(Executor | None, None if executor is MISSING else executor),
+        )
 
     if function := function:
         return wrap(wrapped=function)

haiway/types/missing.py

@@ -46,20 +46,20 @@ class Missing(metaclass=MissingType):
         self,
         name: str,
     ) -> Any:
-        raise RuntimeError("Missing has no attributes")
+        raise AttributeError("Missing has no attributes")
 
     def __setattr__(
         self,
         __name: str,
         __value: Any,
     ) -> None:
-        raise RuntimeError("Missing can't be modified")
+        raise AttributeError("Missing can't be modified")
 
     def __delattr__(
         self,
         __name: str,
     ) -> None:
-        raise RuntimeError("Missing can't be modified")
+        raise AttributeError("Missing can't be modified")
 
 
 MISSING: Final[Missing] = Missing()

{haiway-0.2.0.dist-info → haiway-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: haiway
-Version: 0.2.0
+Version: 0.3.1
 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.2.0.dist-info → haiway-0.3.1.dist-info}/RECORD

@@ -1,15 +1,15 @@
-haiway/__init__.py,sha256=Yw4Oh1N-xv2R9C-caH91DxB5I5tWLMuqYefIWxwpCX0,1130
+haiway/__init__.py,sha256=tjFQ9bVnUHs2BMyCPxeNYxqHtqyIZQDk1Wk2nFB_G2U,1138
 haiway/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-haiway/context/__init__.py,sha256=8a2aiE9fmBBmkLL7_QzRKYdCac1ttt_KoPB62dWDDI8,236
-haiway/context/access.py,sha256=gVDUGvdX6yBUQjgVNotg7DugtqH1rE-efddEENBB16E,10672
+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=cZzbOjdodz4-CjCu2WqrTSJL5MqgaY10YRiWBizVZKA,418
-haiway/helpers/asynchronous.py,sha256=FYcV_ERrGy7f47y18oKeUk7fcbk-i_SOuPQ7lHhX5iI,6119
-haiway/helpers/cached.py,sha256=Ok_WE5Whe7XqnIuLZo4rNNBFeWap-aUWX799s4b1JAQ,9536
-haiway/helpers/disposables.py,sha256=zygeghLaQF77orawLpOjUOKKCsN1S5CwwVrNtS7A5G0,1696
+haiway/helpers/__init__.py,sha256=mXTpvTqRqmKiCE2ZHKDgSo8i9gRbEWGw-Qj2a_M0sD4,317
+haiway/helpers/asynchrony.py,sha256=FPqmFFRDtAn8migwYHFKViKHypNHZW3cJCrh9y03AwI,5526
+haiway/helpers/caching.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
@@ -19,7 +19,7 @@ haiway/state/structure.py,sha256=G-Ln72hoQtE0FmKHeZdNmXf_FA3f5-e5AGbmJ2yMNb4,700
 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/types/missing.py,sha256=xR5Hzk134_htlfac4OBWg6Xkobu71hF9CSVA3qeHBYY,1666
 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
@@ -28,8 +28,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=WGW8kSusIwRYHsYRIKD2CaqhhC1pUtVgtNHFDXDtYrw,2443
-haiway-0.2.0.dist-info/LICENSE,sha256=GehQEW_I1pkmxkkj3NEa7rCTQKYBn7vTPabpDYJlRuo,1063
-haiway-0.2.0.dist-info/METADATA,sha256=mKWhetnV8FpSXvtJra92P5bZHLo_UDZb2PjF-xf-2Kk,3872
-haiway-0.2.0.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
-haiway-0.2.0.dist-info/top_level.txt,sha256=_LdXVLzUzgkvAGQnQJj5kQfoFhpPW6EF4Kj9NapniLg,7
-haiway-0.2.0.dist-info/RECORD,,
+haiway-0.3.1.dist-info/LICENSE,sha256=GehQEW_I1pkmxkkj3NEa7rCTQKYBn7vTPabpDYJlRuo,1063
+haiway-0.3.1.dist-info/METADATA,sha256=ElVgToccvxi6C6UcuG3iqGKPAyJUcacRclp6YJ9A4hw,3872
+haiway-0.3.1.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
+haiway-0.3.1.dist-info/top_level.txt,sha256=_LdXVLzUzgkvAGQnQJj5kQfoFhpPW6EF4Kj9NapniLg,7
+haiway-0.3.1.dist-info/RECORD,,