haiway 0.25.1__py3-none-any.whl → 0.26.1__py3-none-any.whl

haiway/context/presets.py

@@ -1,32 +1,32 @@
+from asyncio import gather
 from collections.abc import Collection, Iterable, Mapping
 from contextvars import ContextVar, Token
 from types import TracebackType
 from typing import ClassVar, Protocol, Self, cast
 
 from haiway.context.disposables import Disposable, Disposables
+from haiway.context.state import StateContext
 from haiway.state import Immutable, State
-from haiway.types.default import Default
 
 __all__ = (
-    "ContextPresets",
-    "ContextPresetsRegistry",
-    "ContextPresetsRegistryContext",
+    "ContextPreset",
+    "ContextPresetRegistryContext",
 )
 
 
-class ContextPresetsStatePreparing(Protocol):
+class ContextPresetStatePreparing(Protocol):
     async def __call__(self) -> Iterable[State] | State: ...
 
 
-class ContextPresetsDisposablesPreparing(Protocol):
+class ContextPresetDisposablesPreparing(Protocol):
     async def __call__(self) -> Iterable[Disposable] | Disposable: ...
 
 
-class ContextPresets(Immutable):
+class ContextPreset(Immutable):
     """
     A configuration preset for context scopes.
 
-    ContextPresets allow you to define reusable combinations of state and disposables
+    ContextPreset allows you to define reusable combinations of state and disposables
     that can be applied to scopes by name. This provides a convenient way to manage
     complex application configurations and resource setups.
 
@@ -43,15 +43,15 @@ class ContextPresets(Immutable):
     Basic preset with static state:
 
     >>> from haiway import State
-    >>> from haiway.context import ContextPresets
+    >>> from haiway.context import ContextPreset
     >>>
     >>> class DatabaseConfig(State):
     ...     connection_string: str
     ...     pool_size: int = 10
     >>>
-    >>> db_preset = ContextPresets(
+    >>> db_preset = ContextPreset(
     ...     name="database",
-    ...     _state=[DatabaseConfig(connection_string="postgresql://localhost/app")]
+    ...     state=[DatabaseConfig(connection_string="postgresql://localhost/app")]
     ... )
 
     Preset with dynamic state factory:
@@ -60,9 +60,9 @@ class ContextPresets(Immutable):
     ...     # Load configuration from environment or config file
     ...     return DatabaseConfig(connection_string=os.getenv("DB_URL"))
     >>>
-    >>> dynamic_preset = ContextPresets(
+    >>> dynamic_preset = ContextPreset(
     ...     name="dynamic_db",
-    ...     _state=[load_config]
+    ...     state=[load_config]
     ... )
 
     Preset with disposables:
@@ -80,10 +80,10 @@ class ContextPresets(Immutable):
     >>> async def connection_factory():
     ...     return database_connection()
     >>>
-    >>> db_preset = ContextPresets(
+    >>> db_preset = ContextPreset(
     ...     name="database",
-    ...     _state=[DatabaseConfig(connection_string="...")],
-    ...     _disposables=[connection_factory]
+    ...     state=[DatabaseConfig(connection_string="...")],
+    ...     disposables=[connection_factory]
     ... )
 
     Using presets:
@@ -97,8 +97,31 @@ class ContextPresets(Immutable):
     """
 
     name: str
-    _state: Collection[ContextPresetsStatePreparing | State] = Default(())
-    _disposables: Collection[ContextPresetsDisposablesPreparing] = Default(())
+    _state: Collection[ContextPresetStatePreparing | State]
+    _disposables: Collection[ContextPresetDisposablesPreparing]
+
+    def __init__(
+        self,
+        name: str,
+        *,
+        state: Collection[ContextPresetStatePreparing | State] = (),
+        disposables: Collection[ContextPresetDisposablesPreparing] = (),
+    ) -> None:
+        object.__setattr__(
+            self,
+            "name",
+            name,
+        )
+        object.__setattr__(
+            self,
+            "_state",
+            state,
+        )
+        object.__setattr__(
+            self,
+            "_disposables",
+            disposables,
+        )
 
     def extended(
         self,
@@ -114,38 +137,38 @@ class ContextPresets(Immutable):
         Parameters
         ----------
         other : Self
-            Another ContextPresets instance to merge with this one.
+            Another ContextPreset instance to merge with this one.
 
         Returns
         -------
         Self
-            A new ContextPresets instance with combined state and disposables.
+            A new ContextPreset instance with combined state and disposables.
         """
         return self.__class__(
             name=self.name,
-            _state=(*self._state, *other._state),
-            _disposables=(*self._disposables, *other._disposables),
+            state=(*self._state, *other._state),
+            disposables=(*self._disposables, *other._disposables),
         )
 
     def with_state(
         self,
-        *state: ContextPresetsStatePreparing | State,
+        *state: ContextPresetStatePreparing | State,
     ) -> Self:
         """
         Create a new preset with additional state.
 
-        Returns a new ContextPresets instance with the provided state objects
+        Returns a new ContextPreset instance with the provided state objects
         or state factories added to the existing state collection.
 
         Parameters
         ----------
-        *state : ContextPresetsStatePreparing | State
+        *state : ContextPresetStatePreparing | State
             Additional state objects or state factory functions to include.
 
         Returns
         -------
         Self
-            A new ContextPresets instance with the additional state, or the
+            A new ContextPreset instance with the additional state, or the
             same instance if no state was provided.
         """
         if not state:
@@ -153,29 +176,29 @@ class ContextPresets(Immutable):
 
         return self.__class__(
             name=self.name,
-            _state=(*self._state, *state),
-            _disposables=self._disposables,
+            state=(*self._state, *state),
+            disposables=self._disposables,
         )
 
     def with_disposable(
         self,
-        *disposable: ContextPresetsDisposablesPreparing,
+        *disposable: ContextPresetDisposablesPreparing,
     ) -> Self:
         """
         Create a new preset with additional disposables.
 
-        Returns a new ContextPresets instance with the provided disposable
+        Returns a new ContextPreset instance with the provided disposable
         factory functions added to the existing disposables collection.
 
         Parameters
         ----------
-        *disposable : ContextPresetsDisposablesPreparing
+        *disposable : ContextPresetDisposablesPreparing
             Additional disposable factory functions to include.
 
         Returns
         -------
         Self
-            A new ContextPresets instance with the additional disposables, or the
+            A new ContextPreset instance with the additional disposables, or the
             same instance if no disposables were provided.
         """
         if not disposable:
@@ -183,8 +206,8 @@ class ContextPresets(Immutable):
 
         return self.__class__(
             name=self.name,
-            _state=self._state,
-            _disposables=(*self._disposables, *disposable),
+            state=self._state,
+            disposables=(*self._disposables, *disposable),
         )
 
     async def prepare(self) -> Disposables:
@@ -210,37 +233,48 @@ class ContextPresets(Immutable):
         This method is called automatically when using presets with ctx.scope(),
         so you typically don't need to call it directly.
         """
-        # Collect states directly
-        collected_states: list[State] = []
+        collected_state: Collection[State] = await self._collect_state()
+
+        collected_disposables: Collection[Disposable]
+        if collected_state:
+            # use available state immediately when preparing disposables
+            with StateContext.updated(collected_state):
+                collected_disposables = (
+                    DisposableState(_state=collected_state),
+                    *await self._collect_disposables(),
+                )
+
+        else:
+            collected_disposables = await self._collect_disposables()
+
+        return Disposables(*collected_disposables)
+
+    async def _collect_state(self) -> Collection[State]:
+        collected_state: list[State] = []
         for state in self._state:
             if isinstance(state, State):
-                collected_states.append(state)
+                collected_state.append(state)
+
             else:
                 resolved_state: Iterable[State] | State = await state()
                 if isinstance(resolved_state, State):
-                    collected_states.append(resolved_state)
+                    collected_state.append(resolved_state)
 
                 else:
-                    collected_states.extend(resolved_state)
-
-        collected_disposables: list[Disposable]
-        if collected_states:
-            collected_disposables = [DisposableState(_state=collected_states)]
+                    collected_state.extend(resolved_state)
 
-        else:
-            collected_disposables = []
+        return collected_state
 
-        for disposable in self._disposables:
-            resolved_disposable: Iterable[Disposable] | Disposable = await disposable()
-            if hasattr(resolved_disposable, "__aenter__") and hasattr(
-                resolved_disposable, "__aexit__"
-            ):
-                collected_disposables.append(cast(Disposable, resolved_disposable))
+    async def _collect_disposables(self) -> Collection[Disposable]:
+        collected_disposables: list[Disposable] = []
+        for disposable in await gather(*(factory() for factory in self._disposables)):
+            if hasattr(disposable, "__aenter__") and hasattr(disposable, "__aexit__"):
+                collected_disposables.append(cast(Disposable, disposable))
 
             else:
-                collected_disposables.extend(cast(Iterable[Disposable], resolved_disposable))
+                collected_disposables.extend(cast(Iterable[Disposable], disposable))
 
-        return Disposables(*collected_disposables)
+        return collected_disposables
 
 
 class DisposableState(Immutable):
@@ -258,55 +292,32 @@ class DisposableState(Immutable):
         pass
 
 
-class ContextPresetsRegistry(Immutable):
-    _presets: Mapping[str, ContextPresets]
-
-    def __init__(
-        self,
-        presets: Collection[ContextPresets],
-    ) -> None:
-        object.__setattr__(
-            self,
-            "_presets",
-            {preset.name: preset for preset in presets},
-        )
-
-    def select(
-        self,
-        name: str,
-        /,
-    ) -> ContextPresets | None:
-        return self._presets.get(name)
-
-
-class ContextPresetsRegistryContext(Immutable):
-    _context: ClassVar[ContextVar[ContextPresetsRegistry]] = ContextVar[ContextPresetsRegistry](
-        "ContextPresetsRegistryContext"
-    )
+class ContextPresetRegistryContext(Immutable):
+    _context: ClassVar[ContextVar[Self]] = ContextVar[Self]("ContextPresetRegistryContext")
 
     @classmethod
     def select(
         cls,
         name: str,
         /,
-    ) -> ContextPresets | None:
+    ) -> ContextPreset | None:
         try:
-            return cls._context.get().select(name)
+            return cls._context.get().preset(name)
 
         except LookupError:
             return None  # no presets
 
-    _registry: ContextPresetsRegistry
-    _token: Token[ContextPresetsRegistry] | None = None
+    _registry: Mapping[str, ContextPreset]
+    _token: Token[Self] | None = None
 
     def __init__(
         self,
-        registry: ContextPresetsRegistry,
+        presets: Iterable[ContextPreset],
     ) -> None:
         object.__setattr__(
             self,
             "_registry",
-            registry,
+            {preset.name: preset for preset in presets},
         )
         object.__setattr__(
             self,
@@ -314,12 +325,19 @@ class ContextPresetsRegistryContext(Immutable):
             None,
         )
 
+    def preset(
+        self,
+        name: str,
+        /,
+    ) -> ContextPreset | None:
+        return self._registry.get(name)
+
     def __enter__(self) -> None:
         assert self._token is None, "Context reentrance is not allowed"  # nosec: B101
         object.__setattr__(
             self,
             "_token",
-            ContextPresetsRegistryContext._context.set(self._registry),
+            ContextPresetRegistryContext._context.set(self),
         )
 
     def __exit__(
@@ -329,7 +347,7 @@ class ContextPresetsRegistryContext(Immutable):
         exc_tb: TracebackType | None,
     ) -> None:
         assert self._token is not None, "Unbalanced context enter/exit"  # nosec: B101
-        ContextPresetsRegistryContext._context.reset(self._token)
+        ContextPresetRegistryContext._context.reset(self._token)  # pyright: ignore[reportArgumentType]
         object.__setattr__(
             self,
             "_token",

haiway/context/state.py

@@ -1,13 +1,11 @@
-from asyncio import iscoroutinefunction
-from collections.abc import Callable, Collection, Coroutine, Iterable, MutableMapping
+from collections.abc import Collection, Iterable, MutableMapping
 from contextvars import ContextVar, Token
 from threading import Lock
 from types import TracebackType
-from typing import Any, ClassVar, Self, cast, overload
+from typing import ClassVar, Self, cast
 
 from haiway.context.types import MissingContext, MissingState
 from haiway.state import Immutable, State
-from haiway.utils.mimic import mimic_function
 
 __all__ = (
     "ScopeState",
@@ -356,41 +354,3 @@ class StateContext(Immutable):
             "_token",
             None,
         )
-
-    @overload
-    def __call__[Result, **Arguments](
-        self,
-        function: Callable[Arguments, Coroutine[Any, Any, Result]],
-    ) -> Callable[Arguments, Coroutine[Any, Any, Result]]: ...
-
-    @overload
-    def __call__[Result, **Arguments](
-        self,
-        function: Callable[Arguments, Result],
-    ) -> Callable[Arguments, Result]: ...
-
-    def __call__[Result, **Arguments](
-        self,
-        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(
-                *args: Arguments.args,
-                **kwargs: Arguments.kwargs,
-            ) -> Result:
-                with self:
-                    return await function(*args, **kwargs)
-
-            return mimic_function(function, within=async_context)
-
-        else:
-
-            def sync_context(
-                *args: Arguments.args,
-                **kwargs: Arguments.kwargs,
-            ) -> Result:
-                with self:
-                    return function(*args, **kwargs)  # pyright: ignore[reportReturnType]
-
-            return mimic_function(function, within=sync_context)  # pyright: ignore[reportReturnType]

haiway/helpers/__init__.py

@@ -10,7 +10,6 @@ from haiway.helpers.observability import LoggerObservability
 from haiway.helpers.retries import retry
 from haiway.helpers.throttling import throttle
 from haiway.helpers.timeouting import timeout
-from haiway.helpers.tracing import traced
 
 __all__ = (
     "CacheMakeKey",
@@ -27,5 +26,4 @@ __all__ = (
     "stream_concurrently",
     "throttle",
     "timeout",
-    "traced",
 )

haiway/helpers/concurrent.py

@@ -3,8 +3,8 @@ from collections.abc import (
     AsyncIterable,
     AsyncIterator,
     Callable,
-    Collection,
     Coroutine,
+    Iterable,
     MutableSequence,
     Sequence,
 )
@@ -20,7 +20,7 @@ __all__ = (
 
 
 async def process_concurrently[Element](  # noqa: C901, PLR0912
-    source: AsyncIterator[Element],
+    source: AsyncIterable[Element],
     /,
     handler: Callable[[Element], Coroutine[Any, Any, None]],
     *,
@@ -80,8 +80,7 @@ async def process_concurrently[Element](  # noqa: C901, PLR0912
     assert concurrent_tasks > 0  # nosec: B101
     running: set[Task[None]] = set()
     try:
-        while True:
-            element: Element = await anext(source)
+        async for element in source:
             running.add(ctx.spawn(handler, element))
             if len(running) < concurrent_tasks:
                 continue  # keep spawning tasks
@@ -132,7 +131,7 @@ async def process_concurrently[Element](  # noqa: C901, PLR0912
 async def execute_concurrently[Element, Result](
     handler: Callable[[Element], Coroutine[Any, Any, Result]],
     /,
-    elements: Collection[Element],
+    elements: Iterable[Element],
     *,
     concurrent_tasks: int = 2,
 ) -> Sequence[Result]: ...
@@ -142,7 +141,7 @@ async def execute_concurrently[Element, Result](
 async def execute_concurrently[Element, Result](
     handler: Callable[[Element], Coroutine[Any, Any, Result]],
     /,
-    elements: Collection[Element],
+    elements: Iterable[Element],
     *,
     concurrent_tasks: int = 2,
     return_exceptions: Literal[True],
@@ -152,7 +151,7 @@ async def execute_concurrently[Element, Result](
 async def execute_concurrently[Element, Result](  # noqa: C901
     handler: Callable[[Element], Coroutine[Any, Any, Result]],
     /,
-    elements: Collection[Element],
+    elements: Iterable[Element],
     *,
     concurrent_tasks: int = 2,
     return_exceptions: bool = False,
@@ -175,8 +174,8 @@ async def execute_concurrently[Element, Result](  # noqa: C901
     ----------
     handler : Callable[[Element], Coroutine[Any, Any, Result]]
         A coroutine function that processes each element and returns a result.
-    elements : Collection[Element]
-        A collection of elements to process. The collection size determines
+    elements : Iterable[Element]
+        A source of elements to process. The source size determines
         the result sequence length.
     concurrent_tasks : int, default=2
         Maximum number of concurrent tasks. Must be greater than 0. Higher

haiway/helpers/files.py

@@ -188,7 +188,7 @@ class FileAccessing(Protocol):
     locking, and resource management.
     """
 
-    async def __call__(
+    def __call__(
         self,
         path: Path | str,
         create: bool,
@@ -275,7 +275,7 @@ def _close_file_handle(
     os.close(file_handle)
 
 
-async def _file_access_context(
+def _file_access_context(
     path: Path | str,
     create: bool,
     exclusive: bool,
@@ -375,7 +375,7 @@ class FileAccess(State):
     """
 
     @classmethod
-    async def open(
+    def open(
         cls,
         path: Path | str,
         create: bool = False,
@@ -412,7 +412,7 @@ class FileAccess(State):
             If the file cannot be opened with the specified parameters, or if
             a file is already open in the current context scope
         """
-        return await ctx.state(cls).accessing(
+        return ctx.state(cls).accessing(
             path,
             create=create,
             exclusive=exclusive,

{haiway-0.25.1.dist-info → haiway-0.26.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: haiway
-Version: 0.25.1
+Version: 0.26.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

{haiway-0.25.1.dist-info → haiway-0.26.1.dist-info}/RECORD

@@ -1,24 +1,23 @@
-haiway/__init__.py,sha256=czgQKokK8NkHBv80HrUV5T1LIvMF301u7ZnIAneq-rg,2123
+haiway/__init__.py,sha256=tJpU6TzK-o-Pt8joGrJah5eC08STVoRzvhXeLn3oTKo,2095
 haiway/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-haiway/context/__init__.py,sha256=5_4gad1PbSs1Swf9IyeOk6gDEDie8uTqXwm75FMyT2Q,1298
-haiway/context/access.py,sha256=aYEn28Zb64IbsE2MmNmLUsg4CxZfBuJX8GG65UakkAk,33029
+haiway/context/__init__.py,sha256=DKcf1AHGEqLWF8Kki30YKQ07GjonUjpAA8I51P4AxAg,1296
+haiway/context/access.py,sha256=g8WdrKNvg6sO3X7Km_9X9syafxS0Shm_EP-JKqRLyxI,31367
 haiway/context/disposables.py,sha256=7Jo-5qzS3UQvZUf4yOqUgfnueMg8I65jwHDp-4g6w54,7998
 haiway/context/identifier.py,sha256=ps7YM1ZnUrj66SPVyxqMhTRMaYOMNSb82J3FfMRVHm4,4690
 haiway/context/observability.py,sha256=rZoZT7g4ZM5_OKIFV0uA0rJodHxondw8X2bMSf_W6_s,20244
-haiway/context/presets.py,sha256=ho6tb87uDQ8lsmqSvbhEP6saVxZHgekzXGf1kklYahM,10181
-haiway/context/state.py,sha256=5-wVAWBOwoBXyXtLo6qv5dc-phBvXFbolBYohyC4puI,11354
+haiway/context/presets.py,sha256=NVRv-PzuzonxdzIEJmt8SRMRO0lUgKb-jR-2ixUtkzI,10760
+haiway/context/state.py,sha256=1oeON23_vaX7IgyckPcA5jWMXije93TNuSh0l9dQqNE,9920
 haiway/context/tasks.py,sha256=0LdoxkQW0op4-QhAA-IDQO0PQr6Q3Vp4mO5ssEFbclU,4930
 haiway/context/types.py,sha256=LoW8238TTdbUgmxyHDi0LVc8M8ZwTHLWKkAPttTsTeg,746
-haiway/helpers/__init__.py,sha256=J1WQdI2jD_zDP4azn9Me6hVvaBtz8kh9kTN-jDgDA5U,836
+haiway/helpers/__init__.py,sha256=gyKM1mWyuQwSx_2ajpI0UF1nA8l5D7wrzZOt9XUkWJA,780
 haiway/helpers/asynchrony.py,sha256=Ddj8UdXhVczAbAC-rLpyhWa4RJ_W2Eolo45Veorq7_4,5362
 haiway/helpers/caching.py,sha256=BqgcUGQSAmXsuLi5V8EwlZzuGyutHOn1V4k7BHsGKeg,14347
-haiway/helpers/concurrent.py,sha256=fU6je62XvbySylZKDgzC_AGKPC7Kimmd5SmkVpySBUo,13115
-haiway/helpers/files.py,sha256=L6vXd8gdgWx5jPL8azloU8IGoFq2xnxjMc4ufz-gdl4,11650
+haiway/helpers/concurrent.py,sha256=kTcm_wLAKqVQOKgTHIKwbkMX5hJ5GIXOAc5RRIUvbo4,13063
+haiway/helpers/files.py,sha256=MzGR-GF8FpBzSihDeen7wdxmX2R-JjAT1MB9aMW-8-g,11626
 haiway/helpers/observability.py,sha256=R4md41g7iTslzvtRaY5W9pgXqmuzJuGByjFb6vsO4W4,10994
 haiway/helpers/retries.py,sha256=OH__I9e-PUFxcSwuQLIzJ9F1MwXgbz1Ur4jEjJiOmjQ,8974
 haiway/helpers/throttling.py,sha256=KBWUSHdKVMC5_nRMmmoPNwfp-3AcerQ6OczJa9gNLM0,5796
 haiway/helpers/timeouting.py,sha256=GQ8-btb36f0Jq7TnorAPYXyKScNmf0nxHXCYxqGl-o8,3949
-haiway/helpers/tracing.py,sha256=NHipA5UlngwFcAaKhXg1jTuJ-ti6AqSNxE7u7-92vWo,5409
 haiway/opentelemetry/__init__.py,sha256=TV-1C14mDAtcHhFZ29ActFQdrGH6x5KuGV9w-JlKYJg,91
 haiway/opentelemetry/observability.py,sha256=uFgSuvwOgW7IbffROY6Kc4ZRJGoQV6rEWqIQltU_Iho,27365
 haiway/state/__init__.py,sha256=mtYgg2TojOBNjFsfoRjYkfZPDhKV5sPJXxDGFBvB8-0,417
@@ -41,7 +40,7 @@ haiway/utils/mimic.py,sha256=xaZiUKp096QFfdSw7cNIKEWt2UIS7vf880KF54gny38,1831
 haiway/utils/noop.py,sha256=U8ocfoCgt-pY0owJDPtrRrj53cabeIXH9qCKWMQnoRk,1336
 haiway/utils/queue.py,sha256=6v2u3pA6A44IuCCTOjmCt3yLyOcm7PCRnrIGo25j-1o,6402
 haiway/utils/stream.py,sha256=lXaeveTY0-AYG5xVzcQYaiC6SUD5fUtHoMXiQcrQAAM,5723
-haiway-0.25.1.dist-info/METADATA,sha256=ggU_T40b25Eqe886YvYy6VydW4iZRAzJ1U57u7QpUbU,4919
-haiway-0.25.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-haiway-0.25.1.dist-info/licenses/LICENSE,sha256=3phcpHVNBP8jsi77gOO0E7rgKeDeu99Pi7DSnK9YHoQ,1069
-haiway-0.25.1.dist-info/RECORD,,
+haiway-0.26.1.dist-info/METADATA,sha256=IEiaciUkopUmCqO7MxJZdfjUrELAI_tDRGBvFL8jUCg,4919
+haiway-0.26.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+haiway-0.26.1.dist-info/licenses/LICENSE,sha256=3phcpHVNBP8jsi77gOO0E7rgKeDeu99Pi7DSnK9YHoQ,1069
+haiway-0.26.1.dist-info/RECORD,,