haiway 0.20.0__py3-none-any.whl → 0.21.0__py3-none-any.whl

haiway/__init__.py

@@ -5,15 +5,8 @@ from haiway.context import (
     MissingState,
     Observability,
     ObservabilityAttribute,
-    ObservabilityAttributesRecording,
     ObservabilityContext,
-    ObservabilityEventRecording,
     ObservabilityLevel,
-    ObservabilityLogRecording,
-    ObservabilityMetricRecording,
-    ObservabilityScopeEntering,
-    ObservabilityScopeExiting,
-    ObservabilityTraceIdentifying,
     ScopeContext,
     ScopeIdentifier,
     StateContext,
@@ -28,7 +21,6 @@ from haiway.helpers import (
     throttle,
     timeout,
     traced,
-    wrap_async,
 )
 from haiway.state import AttributePath, AttributeRequirement, State
 from haiway.types import (
@@ -36,7 +28,6 @@ from haiway.types import (
     Default,
     DefaultValue,
     Missing,
-    frozenlist,
     is_missing,
     not_missing,
     when_missing,
@@ -51,14 +42,12 @@ from haiway.utils import (
     as_tuple,
     async_always,
     async_noop,
-    freeze,
     getenv_base64,
     getenv_bool,
     getenv_float,
     getenv_int,
     getenv_str,
     load_env,
-    mimic_function,
     noop,
     setup_logging,
     without_missing,
@@ -80,15 +69,8 @@ __all__ = (
     "MissingState",
     "Observability",
     "ObservabilityAttribute",
-    "ObservabilityAttributesRecording",
     "ObservabilityContext",
-    "ObservabilityEventRecording",
     "ObservabilityLevel",
-    "ObservabilityLogRecording",
-    "ObservabilityMetricRecording",
-    "ObservabilityScopeEntering",
-    "ObservabilityScopeExiting",
-    "ObservabilityTraceIdentifying",
     "ScopeContext",
     "ScopeIdentifier",
     "State",
@@ -103,8 +85,6 @@ __all__ = (
     "asynchronous",
     "cache",
     "ctx",
-    "freeze",
-    "frozenlist",
     "getenv_base64",
     "getenv_bool",
     "getenv_float",
@@ -112,7 +92,6 @@ __all__ = (
     "getenv_str",
     "is_missing",
     "load_env",
-    "mimic_function",
     "noop",
     "not_missing",
     "process_concurrently",
@@ -123,5 +102,4 @@ __all__ = (
     "traced",
     "when_missing",
     "without_missing",
-    "wrap_async",
 )

haiway/helpers/__init__.py

@@ -1,4 +1,4 @@
-from haiway.helpers.asynchrony import asynchronous, wrap_async
+from haiway.helpers.asynchrony import asynchronous
 from haiway.helpers.caching import CacheMakeKey, CacheRead, CacheWrite, cache
 from haiway.helpers.concurrent import process_concurrently
 from haiway.helpers.observability import LoggerObservability
@@ -19,5 +19,4 @@ __all__ = (
     "throttle",
     "timeout",
     "traced",
-    "wrap_async",
 )

haiway/helpers/asynchrony.py

@@ -7,51 +7,16 @@ from typing import Any, cast, overload
 
 from haiway.types.missing import MISSING, Missing
 
-__all__ = (
-    "asynchronous",
-    "wrap_async",
-)
-
-
-def wrap_async[**Args, Result](
-    function: Callable[Args, Coroutine[Any, Any, Result]] | Callable[Args, Result],
-    /,
-) -> Callable[Args, Coroutine[Any, Any, Result]]:
-    """
-    Convert a synchronous function to an asynchronous one if it isn't already.
-
-    Takes a function that may be either synchronous or asynchronous and ensures it
-    returns a coroutine. If the input function is already asynchronous, it is returned
-    unchanged. If it's synchronous, it wraps it in an async function that executes
-    the original function and returns its result.
-
-    Parameters
-    ----------
-    function: Callable[Args, Coroutine[Any, Any, Result]] | Callable[Args, Result]
-        The function to ensure is asynchronous, can be either sync or async
-
-    Returns
-    -------
-    Callable[Args, Coroutine[Any, Any, Result]]
-        An asynchronous function that returns a coroutine
-    """
-    if iscoroutinefunction(function):
-        return function
-
-    else:
-
-        async def async_function(*args: Args.args, **kwargs: Args.kwargs) -> Result:
-            return cast(Callable[Args, Result], function)(*args, **kwargs)
-
-        _mimic_async(function, within=async_function)
-        return async_function
+__all__ = ("asynchronous",)
 
 
 @overload
-def asynchronous[**Args, Result]() -> Callable[
-    [Callable[Args, Result]],
-    Callable[Args, Coroutine[Any, Any, Result]],
-]: ...
+def asynchronous[**Args, Result]() -> (
+    Callable[
+        [Callable[Args, Result]],
+        Callable[Args, Coroutine[Any, Any, Result]],
+    ]
+): ...
 
 
 @overload
@@ -142,11 +107,18 @@ def asynchronous[**Args, Result](
     ) -> Callable[Args, Coroutine[Any, Any, Result]]:
         assert not iscoroutinefunction(wrapped), "Cannot wrap async function in executor"  # nosec: B101
 
-        return _ExecutorWrapper(
-            wrapped,
-            loop=loop,
-            executor=cast(Executor | None, None if executor is MISSING else executor),
-        )
+        async def asynchronous(
+            *args: Args.args,
+            **kwargs: Args.kwargs,
+        ) -> Result:
+            context: Context = copy_context()
+            return await (loop or get_running_loop()).run_in_executor(
+                cast(Executor | None, None if executor is MISSING else executor),
+                context.run,
+                partial(wrapped, *args, **kwargs),
+            )
+
+        return _mimic_async(wrapped, within=asynchronous)
 
     if function := function:
         return wrap(wrapped=function)
@@ -155,77 +127,6 @@ def asynchronous[**Args, Result](
         return wrap
 
 
-class _ExecutorWrapper[**Args, Result]:
-    __slots__ = (
-        "__annotations__",
-        "__defaults__",
-        "__doc__",
-        "__globals__",
-        "__kwdefaults__",
-        "__name__",
-        "__qualname__",
-        "__wrapped__",
-        "_executor",
-        "_function",
-        "_loop",
-    )
-
-    def __init__(
-        self,
-        function: Callable[Args, Result],
-        /,
-        loop: AbstractEventLoop | None,
-        executor: Executor | None,
-    ) -> None:
-        self._function: Callable[Args, Result] = function
-        self._loop: AbstractEventLoop | None = loop
-        self._executor: Executor | None = executor
-
-        # mimic function attributes if able
-        _mimic_async(function, within=self)
-
-    async def __call__(
-        self,
-        *args: Args.args,
-        **kwargs: Args.kwargs,
-    ) -> Result:
-        context: Context = copy_context()
-        return await (self._loop or get_running_loop()).run_in_executor(
-            self._executor,
-            context.run,
-            partial(self._function, *args, **kwargs),
-        )
-
-    def __get__(
-        self,
-        instance: object,
-        owner: type | None = None,
-        /,
-    ) -> Callable[Args, Coroutine[Any, Any, Result]]:
-        if owner is None:
-            return self
-
-        else:
-            return _mimic_async(
-                self._function,
-                within=partial(
-                    self.__method_call__,
-                    instance,
-                ),
-            )
-
-    async def __method_call__(
-        self,
-        __method_self: object,
-        *args: Args.args,
-        **kwargs: Args.kwargs,
-    ) -> Result:
-        return await (self._loop or get_running_loop()).run_in_executor(
-            self._executor,
-            partial(self._function, __method_self, *args, **kwargs),
-        )
-
-
 def _mimic_async[**Args, Result](
     function: Callable[Args, Result],
     /,

haiway/helpers/concurrent.py

@@ -8,7 +8,7 @@ from haiway.context import ctx
 __all__ = ("process_concurrently",)
 
 
-async def process_concurrently[Element](  # noqa: C901
+async def process_concurrently[Element](  # noqa: C901, PLR0912
     source: AsyncIterator[Element],
     /,
     handler: Callable[[Element], Coroutine[Any, Any, None]],
@@ -37,12 +37,16 @@ async def process_concurrently[Element](  # noqa: C901
     assert concurrent_tasks > 0  # nosec: B101
     running: set[Task[None]] = set()
     try:
-        while element := await anext(source, None):
+        while True:
+            element: Element = await anext(source)
+            running.add(ctx.spawn(handler, element))
             if len(running) < concurrent_tasks:
-                running.add(ctx.spawn(handler, element))
                 continue  # keep spawning tasks
 
-            completed, running = await wait(running, return_when=FIRST_COMPLETED)
+            completed, running = await wait(
+                running,
+                return_when=FIRST_COMPLETED,
+            )
 
             for task in completed:
                 if exc := task.exception():
@@ -61,14 +65,21 @@ async def process_concurrently[Element](  # noqa: C901
 
         raise exc
 
+    except StopAsyncIteration:
+        pass  # just stop and proceed to finally
+
     finally:
-        completed, _ = await wait(running, return_when=ALL_COMPLETED)
-        for task in completed:
-            if exc := task.exception():
-                if not ignore_exceptions:
-                    raise exc
-
-                ctx.log_error(
-                    f"Concurrent processing error - {type(exc)}: {exc}",
-                    exception=exc,
-                )
+        if running:
+            completed, _ = await wait(
+                running,
+                return_when=ALL_COMPLETED,
+            )
+            for task in completed:
+                if exc := task.exception():
+                    if not ignore_exceptions:
+                        raise exc
+
+                    ctx.log_error(
+                        f"Concurrent processing error - {type(exc)}: {exc}",
+                        exception=exc,
+                    )

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 Any, cast, overload
+from typing import Any, overload
 
 from haiway.utils.mimic import mimic_function
 
@@ -97,14 +97,38 @@ def throttle[**Args, Result](
         function: Callable[Args, Coroutine[Any, Any, Result]],
     ) -> Callable[Args, Coroutine[Any, Any, Result]]:
         assert iscoroutinefunction(function)  # nosec: B101
-        return cast(
-            Callable[Args, Coroutine[Any, Any, Result]],
-            _AsyncThrottle(
-                function,
-                limit=limit,
-                period=period,
-            ),
-        )
+        entries: deque[float] = deque()
+        lock: Lock = Lock()
+        throttle_period: float
+        match period:
+            case timedelta() as delta:
+                throttle_period = delta.total_seconds()
+
+            case period_seconds:
+                throttle_period = period_seconds
+
+        async def throttle(
+            *args: Args.args,
+            **kwargs: Args.kwargs,
+        ) -> Result:
+            async with lock:
+                time_now: float = monotonic()
+                while entries:  # cleanup old entries
+                    if entries[0] + throttle_period <= time_now:
+                        entries.popleft()
+
+                    else:
+                        break
+
+                if len(entries) >= limit:
+                    await sleep(entries[0] - time_now)
+
+                entries.append(monotonic())
+
+            return await function(*args, **kwargs)
+
+        # mimic function attributes if able
+        return mimic_function(function, within=throttle)
 
     if function := function:
         return _wrap(function)

haiway/state/requirement.py

@@ -199,7 +199,7 @@ class AttributeRequirement[Root]:
 
         def check_contains_any(root: Root) -> None:
             checked: Any = cast(AttributePath[Root, Parameter], path)(root)
-            if any(element in checked for element in value):
+            if not any(element in checked for element in value):
                 raise ValueError(
                     f"{checked} does not contain any of {value} for '{path.__repr__()}'"
                 )

haiway/state/structure.py

@@ -551,6 +551,14 @@ class State(metaclass=StateMeta):
             case _:
                 raise TypeError(f"Expected '{cls.__name__}', received '{type(value).__name__}'")
 
+    @classmethod
+    def from_mapping(
+        cls,
+        value: Mapping[str, Any],
+        /,
+    ) -> Self:
+        return cls(**value)
+
     def __init__(
         self,
         **kwargs: Any,

haiway/types/__init__.py

@@ -1,5 +1,4 @@
 from haiway.types.default import Default, DefaultValue
-from haiway.types.frozen import frozenlist
 from haiway.types.missing import MISSING, Missing, is_missing, not_missing, when_missing
 
 __all__ = (
@@ -7,7 +6,6 @@ __all__ = (
     "Default",
     "DefaultValue",
     "Missing",
-    "frozenlist",
     "is_missing",
     "not_missing",
     "when_missing",

{haiway-0.20.0.dist-info → haiway-0.21.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: haiway
-Version: 0.20.0
+Version: 0.21.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
@@ -42,13 +42,17 @@ Requires-Dist: pytest-cov~=6.1; extra == 'dev'
 Requires-Dist: pytest~=8.3; extra == 'dev'
 Requires-Dist: ruff~=0.11; extra == 'dev'
 Provides-Extra: opentelemetry
-Requires-Dist: opentelemetry-api; extra == 'opentelemetry'
-Requires-Dist: opentelemetry-exporter-otlp-proto-grpc; extra == 'opentelemetry'
-Requires-Dist: opentelemetry-sdk; extra == 'opentelemetry'
+Requires-Dist: opentelemetry-api~=1.33; extra == 'opentelemetry'
+Requires-Dist: opentelemetry-exporter-otlp-proto-grpc~=1.33; extra == 'opentelemetry'
+Requires-Dist: opentelemetry-sdk~=1.33; extra == 'opentelemetry'
 Description-Content-Type: text/markdown
 
 # 🚗 haiway 🚕 🚚 🚙
 
+![Python Version](https://img.shields.io/badge/Python-3.12+-blue)
+![License](https://img.shields.io/badge/License-MIT-green)
+![CodeRabbit Pull Request Reviews](https://img.shields.io/coderabbit/prs/github/miquido/haiway?utm_source=oss&utm_medium=github&utm_campaign=miquido%2Fhaiway&labelColor=171717&color=FF570A&link=https%3A%2F%2Fcoderabbit.ai&label=CodeRabbit+Reviews)
+
 haiway is a framework designed to facilitate the development of applications using the functional programming paradigm combined with structured concurrency concepts. Unlike traditional object-oriented frameworks, haiway emphasizes immutability, pure functions, and context-based state management, enabling developers to build scalable and maintainable applications. By leveraging context managers combined with context vars, haiway ensures safe state propagation in concurrent environments and simplifies dependency injection through function implementation propagation.
 
 ## 🖥️ Install

{haiway-0.20.0.dist-info → haiway-0.21.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-haiway/__init__.py,sha256=swH9O_-cvHnZ8hC2AyxxL02M8cGldI0f_Be_l9C1rUY,2479
+haiway/__init__.py,sha256=keuz9FN8VqLamqrzvjK2IAjkdyyFcnboDrB9xkFPgXk,1861
 haiway/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 haiway/context/__init__.py,sha256=1N_SvdPkTfIZDZybm3y0rY2dGrDLWTm0ryzUz2XD4f8,1174
 haiway/context/access.py,sha256=lDvkMoqUOwzBt-P8mI-VggS2wrP_BJLmYrArdj8z4SE,21644
@@ -8,13 +8,13 @@ haiway/context/observability.py,sha256=gLKbMPNvt5ozrfyc4TGahN8A_dFFtyCjUIMZu9_wZ
 haiway/context/state.py,sha256=tRJRvd07XObhdayz-1OcNxABqcHQRD_k_yUGsn72wDU,9541
 haiway/context/tasks.py,sha256=pScFgeiyrXSJRDFZiYbBLi3k_DHkSlhB8rgAnYtgyrU,4925
 haiway/context/types.py,sha256=VDWXJySihfvSSPzY09PaGk6j5S9HgmAUboBGCZ8o_4k,766
-haiway/helpers/__init__.py,sha256=_A-JYAPemd-2o4NxxchaZENu8gANL8QDxK5ADzInXUU,670
-haiway/helpers/asynchrony.py,sha256=2NtuMklKHyU2o7H_Y_wyN6mxa13wdgI6yETjPbgSHPA,8136
+haiway/helpers/__init__.py,sha256=WzQFUHAX0NtpbdKycHywTyxfMGmid91y0vfmdIHX-NE,640
+haiway/helpers/asynchrony.py,sha256=FGJA4BhTa5qcA9PTxsloC5mReoSfkEY6uieLU2K3bCs,5376
 haiway/helpers/caching.py,sha256=BqgcUGQSAmXsuLi5V8EwlZzuGyutHOn1V4k7BHsGKeg,14347
-haiway/helpers/concurrent.py,sha256=04pWpS7qOQDD1pa2ifhFwedPcl4sRinhe-KgyDe5GF0,2296
+haiway/helpers/concurrent.py,sha256=xGMcan_tiETAHQs1YFmgYpA4YMFo6rIbFKvNeMlRFG8,2551
 haiway/helpers/observability.py,sha256=3G0eRE1WYTGRujS0mxzYbLR4MlKnoYllE8cu2Eb_23w,11073
 haiway/helpers/retries.py,sha256=52LA85HejTiSmCmTMAA9c8oUqD_VnhbTn1b3kwlU52c,9032
-haiway/helpers/throttling.py,sha256=hwhruBXepve2TJA4vsaO4WwTFkclt5eNiZ8U0mo-mlI,5015
+haiway/helpers/throttling.py,sha256=KBWUSHdKVMC5_nRMmmoPNwfp-3AcerQ6OczJa9gNLM0,5796
 haiway/helpers/timeouted.py,sha256=GQ8-btb36f0Jq7TnorAPYXyKScNmf0nxHXCYxqGl-o8,3949
 haiway/helpers/tracing.py,sha256=NHipA5UlngwFcAaKhXg1jTuJ-ti6AqSNxE7u7-92vWo,5409
 haiway/opentelemetry/__init__.py,sha256=TV-1C14mDAtcHhFZ29ActFQdrGH6x5KuGV9w-JlKYJg,91
@@ -22,12 +22,11 @@ haiway/opentelemetry/observability.py,sha256=5fsHsFgjcxUcA0hIOM18lVvVdYSRO91ER52
 haiway/state/__init__.py,sha256=AaMqlMhO4zKS_XNevy3A7BHh5PxmguA-Sk_FnaNDY1Q,355
 haiway/state/attributes.py,sha256=sububiFP23aBB8RGk6OvTUp7BEY6S0kER_uHC09yins,26733
 haiway/state/path.py,sha256=bv5MI3HmUyku78k0Sz5lc7Q_Bay53iom1l3AL5KZs-4,32143
-haiway/state/requirement.py,sha256=_tA6CPyFX6WTjJ0Yk2jeMs-At17ex8Yl8y1-s24idas,12793
-haiway/state/structure.py,sha256=wZqTcX3BaKbjMSKjAukPHfR9A_nQibLW9i_BWpWUVYs,23118
+haiway/state/requirement.py,sha256=NbXL7JrB-zGE6KShcRRtq-wJbKu5lHlhFdmfhyJZdkc,12797
+haiway/state/structure.py,sha256=KKIId-mrHAzGjYKKlvnlscMijVZVM8nDLnAwCFn1sTc,23259
 haiway/state/validation.py,sha256=eDOZKRrfd-dmdbqoHcLacdCVKmVCEpwt239EG6ljNF8,23557
-haiway/types/__init__.py,sha256=73DMgf60Ftf1gLRCSQG66Nyu3_QFjdRJggBtS4-RQkY,342
+haiway/types/__init__.py,sha256=jFr5kf36SvVGdgngvik6_HzG8YNa3NVsdDDSqxVuGm4,281
 haiway/types/default.py,sha256=59chcOaoGqI2to08RamCCLluimfYbJp5xbYl3fWaLrM,4153
-haiway/types/frozen.py,sha256=Zb9P0IpB-YgOrnHwiGqPk8AvyH-ABX7jajS9m3kzjBk,701
 haiway/types/missing.py,sha256=bVlOJN0Z04gALKj01Ah6_sWbC94mwRatdEcW7neLAsY,4188
 haiway/utils/__init__.py,sha256=HOylRgBEa0uNxEuPBupaJ28l4wEQiy98cGJi2Gtirr4,972
 haiway/utils/always.py,sha256=dd6jDQ1j4DpJjTKO1J2Tv5xS8X1LnMC4kQ0D7DtKUvw,1230
@@ -40,7 +39,7 @@ haiway/utils/mimic.py,sha256=L5AS4WEL2aPMZAQZlvLvRzHl0cipI7ivky60_eL4iwY,1822
 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.20.0.dist-info/METADATA,sha256=QbQTKdDVsoT878zfWl1NwrbEPo8z5dPvC1EO29OiBMk,4527
-haiway-0.20.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-haiway-0.20.0.dist-info/licenses/LICENSE,sha256=3phcpHVNBP8jsi77gOO0E7rgKeDeu99Pi7DSnK9YHoQ,1069
-haiway-0.20.0.dist-info/RECORD,,
+haiway-0.21.0.dist-info/METADATA,sha256=WzaFZVy8PEbnLUC-Hqy6YUcPcStmzj3KVdM6sE4DdM0,4919
+haiway-0.21.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+haiway-0.21.0.dist-info/licenses/LICENSE,sha256=3phcpHVNBP8jsi77gOO0E7rgKeDeu99Pi7DSnK9YHoQ,1069
+haiway-0.21.0.dist-info/RECORD,,

haiway/types/frozen.py

@@ -1,21 +0,0 @@
-__all__ = ("frozenlist",)
-
-type frozenlist[Value] = tuple[Value, ...]
-"""
-A type alias for an immutable sequence of values.
-
-This type represents an immutable list-like structure (implemented as a tuple)
-that can be used when an immutable sequence is required. It provides the same
-indexing and iteration capabilities as a list, but cannot be modified after creation.
-
-The generic parameter Value specifies the type of elements stored in the sequence.
-
-Examples
---------
-```python
-items: frozenlist[int] = (1, 2, 3)  # Create a frozen list of integers
-first_item = items[0]               # Access elements by index
-for item in items:                  # Iterate over elements
-    process(item)
-```
-"""