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

haiway/__init__.py

@@ -6,7 +6,16 @@ from haiway.context import (
     ScopeMetrics,
     ctx,
 )
-from haiway.helpers import asynchronous, cache, retry, throttle, timeout
+from haiway.helpers import (
+    ArgumentsTrace,
+    ResultTrace,
+    asynchronous,
+    cache,
+    retry,
+    throttle,
+    timeout,
+    traced,
+)
 from haiway.state import State
 from haiway.types import (
     MISSING,
@@ -34,6 +43,7 @@ from haiway.utils import (
 
 __all__ = [
     "always",
+    "ArgumentsTrace",
     "async_always",
     "async_noop",
     "asynchronous",
@@ -57,11 +67,13 @@ __all__ = [
     "MissingState",
     "noop",
     "not_missing",
+    "ResultTrace",
     "retry",
     "ScopeMetrics",
     "setup_logging",
     "State",
     "throttle",
     "timeout",
+    "traced",
     "when_missing",
 ]

haiway/context/metrics.py

@@ -10,6 +10,7 @@ from typing import Any, Self, cast, final, overload
 from uuid import uuid4
 
 from haiway.state import State
+from haiway.types import MISSING, Missing, not_missing
 from haiway.utils import freeze
 
 __all__ = [
@@ -28,7 +29,13 @@ class ScopeMetrics:
         logger: Logger | None,
     ) -> None:
         self.trace_id: str = trace_id or uuid4().hex
-        self._label: str = f"{self.trace_id}|{scope}" if scope else self.trace_id
+        self.identifier: str = uuid4().hex
+        self.label: str = scope
+        self._logger_prefix: str = (
+            f"[{self.trace_id}] [{scope}] [{self.identifier}]"
+            if scope
+            else f"[{self.trace_id}] [{self.identifier}]"
+        )
         self._logger: Logger = logger or getLogger(name=scope)
         self._metrics: dict[type[State], State] = {}
         self._nested: list[ScopeMetrics] = []
@@ -41,21 +48,29 @@ class ScopeMetrics:
         self._complete()  # ensure completion on deinit
 
     def __str__(self) -> str:
-        return self._label
+        return f"{self.label}[{self.identifier}]@[{self.trace_id}]"
 
     def metrics(
         self,
         *,
-        merge: Callable[[State, State], State] = lambda lhs, rhs: lhs,
+        merge: Callable[[State | Missing, State], State | Missing] | None = None,
     ) -> list[State]:
+        if not merge:
+            return list(self._metrics.values())
+
         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[State] = type(metric)
-            if current := metrics.get(metric_type):
-                metrics[metric_type] = merge(current, metric)
+            merged: State | Missing = merge(
+                metrics.get(  # current
+                    metric_type,
+                    MISSING,
+                ),
+                metric,  # received
+            )
 
-            else:
-                metrics[metric_type] = metric
+            if not_missing(merged):
+                metrics[metric_type] = merged
 
         return list(metrics.values())
 
@@ -145,7 +160,7 @@ class ScopeMetrics:
     ) -> None:
         self._logger.log(
             level,
-            f"[{self}] {message}",
+            f"{self._logger_prefix} {message}",
             *args,
             exc_info=exception,
         )

haiway/helpers/__init__.py

@@ -1,13 +1,17 @@
-from haiway.helpers.asynchronous import asynchronous
-from haiway.helpers.cached import cache
+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
+from haiway.helpers.tracing import ArgumentsTrace, ResultTrace, traced
 
 __all__ = [
+    "ArgumentsTrace",
     "asynchronous",
     "cache",
+    "ResultTrace",
     "retry",
     "throttle",
     "timeout",
+    "traced",
 ]

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/helpers/tracing.py

@@ -0,0 +1,136 @@
+from asyncio import iscoroutinefunction
+from collections.abc import Callable, Coroutine
+from typing import Any, Self, cast
+
+from haiway.context import ctx
+from haiway.state import State
+from haiway.types import MISSING, Missing
+from haiway.utils import mimic_function
+
+__all__ = [
+    "traced",
+    "ArgumentsTrace",
+    "ResultTrace",
+]
+
+
+class ArgumentsTrace(State):
+    if __debug__:
+
+        @classmethod
+        def of(cls, *args: Any, **kwargs: Any) -> Self:
+            return cls(
+                args=args if args else MISSING,
+                kwargs=kwargs if kwargs else MISSING,
+            )
+
+    else:  # remove tracing for non debug runs to prevent accidental secret leaks
+
+        @classmethod
+        def of(cls, *args: Any, **kwargs: Any) -> Self:
+            return cls(
+                args=MISSING,
+                kwargs=MISSING,
+            )
+
+    args: tuple[Any, ...] | Missing
+    kwargs: dict[str, Any] | Missing
+
+
+class ResultTrace(State):
+    if __debug__:
+
+        @classmethod
+        def of(
+            cls,
+            value: Any,
+            /,
+        ) -> Self:
+            return cls(result=value)
+
+    else:  # remove tracing for non debug runs to prevent accidental secret leaks
+
+        @classmethod
+        def of(
+            cls,
+            value: Any,
+            /,
+        ) -> Self:
+            return cls(result=MISSING)
+
+    result: Any | Missing
+
+
+def traced[**Args, Result](
+    function: Callable[Args, Result],
+    /,
+) -> Callable[Args, Result]:
+    if __debug__:
+        if iscoroutinefunction(function):
+            return cast(
+                Callable[Args, Result],
+                _traced_async(
+                    function,
+                    label=function.__name__,
+                ),
+            )
+        else:
+            return _traced_sync(
+                function,
+                label=function.__name__,
+            )
+
+    else:  # do not trace on non debug runs
+        return function
+
+
+def _traced_sync[**Args, Result](
+    function: Callable[Args, Result],
+    /,
+    label: str,
+) -> Callable[Args, Result]:
+    def traced(
+        *args: Args.args,
+        **kwargs: Args.kwargs,
+    ) -> Result:
+        with ctx.scope(label):
+            ctx.record(ArgumentsTrace.of(*args, **kwargs))
+            try:
+                result: Result = function(*args, **kwargs)
+                ctx.record(ResultTrace.of(result))
+                return result
+
+            except BaseException as exc:
+                ctx.record(ResultTrace.of(exc))
+                raise exc
+
+    return mimic_function(
+        function,
+        within=traced,
+    )
+
+
+def _traced_async[**Args, Result](
+    function: Callable[Args, Coroutine[Any, Any, Result]],
+    /,
+    label: str,
+) -> Callable[Args, Coroutine[Any, Any, Result]]:
+    async def traced(
+        *args: Args.args,
+        **kwargs: Args.kwargs,
+    ) -> Result:
+        with ctx.scope(label):
+            ctx.record(ArgumentsTrace.of(*args, **kwargs))
+            try:
+                result: Result = await function(*args, **kwargs)
+                ctx.record(ResultTrace.of(result))
+                return result
+
+            except BaseException as exc:
+                ctx.record(ResultTrace.of(exc))
+                raise exc
+
+    return mimic_function(
+        function,
+        within=traced,
+    )

haiway/state/validation.py

@@ -11,7 +11,7 @@ __all__ = [
 ]
 
 
-def attribute_type_validator(
+def attribute_type_validator(  # noqa: PLR0911
     annotation: AttributeAnnotation,
     /,
 ) -> Callable[[Any], Any]:
@@ -31,6 +31,10 @@ def attribute_type_validator(
         case typing.Any:
             return _any_validator
 
+        # typed dicts fail on type checks
+        case typed_dict if typing.is_typeddict(typed_dict):
+            return _prepare_typed_dict_validator(typed_dict)
+
         case type() as other_type:
             return _prepare_type_validator(other_type)
 
@@ -123,3 +127,23 @@ def _prepare_type_validator(
                 )
 
     return type_validator
+
+
+def _prepare_typed_dict_validator(
+    validated_type: type[Any],
+    /,
+) -> Callable[[Any], Any]:
+    def typed_dict_validator(
+        value: Any,
+    ) -> Any:
+        match value:
+            case value if isinstance(value, dict):
+                # for typed dicts check only if that is a dict
+                return value  # pyright: ignore[reportUnknownVariableType]
+
+            case _:
+                raise TypeError(
+                    f"Type '{type(value)}' is not matching expected type '{validated_type}'"
+                )
+
+    return typed_dict_validator

haiway/types/missing.py

@@ -27,6 +27,9 @@ class Missing(metaclass=MissingType):
     Type representing absence of a value. Use MISSING constant for its value.
     """
 
+    __slots__ = ()
+    __match_args__ = ()
+
     def __bool__(self) -> bool:
         return False
 
@@ -42,24 +45,24 @@ class Missing(metaclass=MissingType):
     def __repr__(self) -> str:
         return "MISSING"
 
-    def __getattribute__(
+    def __getattr__(
         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.3.0.dist-info → haiway-0.3.2.dist-info}/METADATA

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

@@ -1,25 +1,26 @@
-haiway/__init__.py,sha256=tjFQ9bVnUHs2BMyCPxeNYxqHtqyIZQDk1Wk2nFB_G2U,1138
+haiway/__init__.py,sha256=hLc3-FDmNQEV4r-RLOiGjWtYSk7krU8vRMBaZyRU08g,1267
 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/metrics.py,sha256=TGZzNrmGPolAwVb1mBEF10mXRyVyBq-MHTucAokNuhY,9105
 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/__init__.py,sha256=YYEORuo3xyce5_kGjfQVyaQHyp1dBh3ZlrZavR0hQzk,443
+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
+haiway/helpers/tracing.py,sha256=yiK8MdDyX_fmpK9Zu5-IiZae5E8ReKQtRBBenXIPVqQ,3326
 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/state/validation.py,sha256=Z6kp_KjTnnP9eVWsLmzKkEQLZkhFCOSphjdbr6VxLFQ,3628
 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=JiXo5xdi7H-PbIJr0fuK5wpOuQZhjrDYUkMlfIFcsaE,1705
 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 +29,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.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-0.3.2.dist-info/LICENSE,sha256=GehQEW_I1pkmxkkj3NEa7rCTQKYBn7vTPabpDYJlRuo,1063
+haiway-0.3.2.dist-info/METADATA,sha256=Ze8RmuhIj2Ck3SVea8h3VbaTSf43_Y57oISLZKytNOA,3872
+haiway-0.3.2.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+haiway-0.3.2.dist-info/top_level.txt,sha256=_LdXVLzUzgkvAGQnQJj5kQfoFhpPW6EF4Kj9NapniLg,7
+haiway-0.3.2.dist-info/RECORD,,

{haiway-0.3.0.dist-info → haiway-0.3.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.2.0)
+Generator: setuptools (75.3.0)
 Root-Is-Purelib: true
 Tag: py3-none-any