haiway 0.8.4__py3-none-any.whl → 0.9.0__py3-none-any.whl

haiway/__init__.py

@@ -3,6 +3,7 @@ from haiway.context import (
     Disposables,
     MetricsContext,
     MetricsHandler,
+    MetricsReading,
     MetricsRecording,
     MetricsScopeEntering,
     MetricsScopeExiting,
@@ -13,6 +14,7 @@ from haiway.context import (
 )
 from haiway.helpers import (
     ArgumentsTrace,
+    MetricsHolder,
     MetricsLogger,
     ResultTrace,
     asynchronous,
@@ -61,7 +63,9 @@ __all__ = [
     "Disposables",
     "MetricsContext",
     "MetricsHandler",
+    "MetricsHolder",
     "MetricsLogger",
+    "MetricsReading",
     "MetricsRecording",
     "MetricsScopeEntering",
     "MetricsScopeExiting",

haiway/context/__init__.py

@@ -4,6 +4,7 @@ from haiway.context.identifier import ScopeIdentifier
 from haiway.context.metrics import (
     MetricsContext,
     MetricsHandler,
+    MetricsReading,
     MetricsRecording,
     MetricsScopeEntering,
     MetricsScopeExiting,
@@ -15,6 +16,7 @@ __all__ = [
     "Disposables",
     "MetricsContext",
     "MetricsHandler",
+    "MetricsReading",
     "MetricsRecording",
     "MetricsScopeEntering",
     "MetricsScopeExiting",

haiway/context/access.py

@@ -423,6 +423,62 @@ class ctx:
 
         MetricsContext.record(metric)
 
+    @overload
+    @staticmethod
+    async def read[Metric: State](
+        metric: type[Metric],
+        /,
+        *,
+        merged: bool = False,
+    ) -> Metric | None: ...
+
+    @overload
+    @staticmethod
+    async def read[Metric: State](
+        metric: type[Metric],
+        /,
+        *,
+        merged: bool = False,
+        default: Metric,
+    ) -> Metric: ...
+
+    @staticmethod
+    async def read[Metric: State](
+        metric: type[Metric],
+        /,
+        *,
+        merged: bool = False,
+        default: Metric | None = None,
+    ) -> Metric | None:
+        """
+        Read metric within current scope context.
+
+        Parameters
+        ----------
+        metric: type[Metric]
+            type of metric to be read from current context.
+
+        merged: bool
+            control wheather to merge metrics from nested scopes (True)\
+             or access only the current scope value (False) without combining them
+
+        default: Metric | None
+            default value to return when metric was not recorded yet.
+
+        Returns
+        -------
+        Metric | None
+        """
+
+        value: Metric | None = await MetricsContext.read(
+            metric,
+            merged=merged,
+        )
+        if value is None:
+            return default
+
+        return value
+
     @staticmethod
     def log_error(
         message: str,

haiway/context/metrics.py

@@ -9,6 +9,7 @@ from haiway.state import State
 __all__ = [
     "MetricsContext",
     "MetricsHandler",
+    "MetricsReading",
     "MetricsRecording",
     "MetricsScopeEntering",
     "MetricsScopeExiting",
@@ -25,6 +26,18 @@ class MetricsRecording(Protocol):
     ) -> None: ...
 
 
+@runtime_checkable
+class MetricsReading(Protocol):
+    async def __call__[Metric: State](
+        self,
+        scope: ScopeIdentifier,
+        /,
+        *,
+        metric: type[Metric],
+        merged: bool,
+    ) -> Metric | None: ...
+
+
 @runtime_checkable
 class MetricsScopeEntering(Protocol):
     def __call__[Metric: State](
@@ -45,6 +58,7 @@ class MetricsScopeExiting(Protocol):
 
 class MetricsHandler(State):
     record: MetricsRecording
+    read: MetricsReading
     enter_scope: MetricsScopeEntering
     exit_scope: MetricsScopeExiting
 
@@ -100,6 +114,30 @@ class MetricsContext:
                 exception=exc,
             )
 
+    @classmethod
+    async def read[Metric: State](
+        cls,
+        metric: type[Metric],
+        /,
+        merged: bool,
+    ) -> Metric | None:
+        try:  # catch exceptions - we don't wan't to blow up on metrics
+            metrics: Self = cls._context.get()
+
+            if metrics._metrics is not None:
+                return await metrics._metrics.read(
+                    metrics._scope,
+                    metric=metric,
+                    merged=merged,
+                )
+
+        except Exception as exc:
+            LoggerContext.log_error(
+                "Failed to read metric: %s",
+                metric.__qualname__,
+                exception=exc,
+            )
+
     def __init__(
         self,
         scope: ScopeIdentifier,

haiway/helpers/__init__.py

@@ -1,6 +1,6 @@
 from haiway.helpers.asynchrony import asynchronous, wrap_async
 from haiway.helpers.caching import cache
-from haiway.helpers.metrics import MetricsLogger
+from haiway.helpers.metrics import MetricsHolder, MetricsLogger
 from haiway.helpers.retries import retry
 from haiway.helpers.throttling import throttle
 from haiway.helpers.timeouted import timeout
@@ -8,6 +8,7 @@ from haiway.helpers.tracing import ArgumentsTrace, ResultTrace, traced
 
 __all__ = [
     "ArgumentsTrace",
+    "MetricsHolder",
     "MetricsLogger",
     "ResultTrace",
     "asynchronous",

haiway/helpers/asynchrony.py

@@ -30,12 +30,10 @@ def wrap_async[**Args, Result](
 
 
 @overload
-def asynchronous[**Args, Result]() -> (
-    Callable[
-        [Callable[Args, Result]],
-        Callable[Args, Coroutine[None, None, Result]],
-    ]
-): ...
+def asynchronous[**Args, Result]() -> Callable[
+    [Callable[Args, Result]],
+    Callable[Args, Coroutine[None, None, Result]],
+]: ...
 
 
 @overload

haiway/helpers/metrics.py

@@ -1,14 +1,15 @@
 from collections.abc import Sequence
 from itertools import chain
 from time import monotonic
-from typing import Any, Self, cast, final
+from typing import Any, Self, cast, final, overload
 
 from haiway.context import MetricsHandler, ScopeIdentifier, ctx
 from haiway.state import State
-from haiway.types import MISSING, Missing
+from haiway.types import MISSING
 
 __all_ = [
     "MetricsLogger",
+    "MetricsHolder",
 ]
 
 
@@ -32,25 +33,129 @@ class MetricsScopeStore:
     def finished(self) -> float:
         return self.exited is not None and all(nested.finished for nested in self.nested)
 
-    def merged(self) -> Sequence[State]:
-        merged_metrics: dict[type[State], State] = dict(self.metrics)
-        for element in chain.from_iterable(nested.merged() for nested in self.nested):
-            metric_type: type[State] = type(element)
-            current: State | Missing = merged_metrics.get(
-                metric_type,
-                MISSING,
-            )
+    @overload
+    def merged[Metric: State](
+        self,
+    ) -> Sequence[State]: ...
 
-            if current is MISSING:
-                continue  # do not merge to missing
+    @overload
+    def merged[Metric: State](
+        self,
+        metric: type[Metric],
+    ) -> Metric | None: ...
 
-            elif hasattr(current, "__add__"):
-                merged_metrics[metric_type] = current.__add__(element)  # pyright: ignore[reportUnknownMemberType, reportAttributeAccessIssue]
+    def merged[Metric: State](
+        self,
+        metric: type[Metric] | None = None,
+    ) -> Sequence[State] | Metric | None:
+        if metric is None:
+            merged_metrics: dict[type[State], State] = dict(self.metrics)
+            for nested in chain.from_iterable(nested.merged() for nested in self.nested):
+                metric_type: type[State] = type(nested)
+                current: State | None = merged_metrics.get(metric_type)
 
-            else:
-                merged_metrics[metric_type] = element
+                if current is None:
+                    merged_metrics[metric_type] = nested
+                    continue  # keep going
+
+                if hasattr(current, "__add__"):
+                    merged_metrics[metric_type] = current.__add__(nested)  # pyright: ignore[reportUnknownMemberType, reportAttributeAccessIssue]
+                    assert isinstance(merged_metrics[metric_type], State)  # nosec: B101
+                    continue  # keep going
+
+                break  # we have multiple value without a way to merge
+
+            return tuple(merged_metrics.values())
+
+        else:
+            merged_metric: State | None = self.metrics.get(metric)
+            for nested in self.nested:
+                nested_metric: Metric | None = nested.merged(metric)
+                if nested_metric is None:
+                    continue  # skip missing
+
+                if merged_metric is None:
+                    merged_metric = nested_metric
+                    continue  # keep going
+
+                if hasattr(merged_metric, "__add__"):
+                    merged_metric = merged_metric.__add__(nested_metric)  # pyright: ignore[reportUnknownMemberType, reportAttributeAccessIssue, reportUnknownVariableType]
+                    assert isinstance(merged_metric, metric)  # nosec: B101
+                    continue  # keep going
+
+                break  # we have multiple value without a way to merge
+
+            return cast(Metric | None, merged_metric)
+
+
+@final
+class MetricsHolder:
+    @classmethod
+    def handler(cls) -> MetricsHandler:
+        store_handler: Self = cls()
+        return MetricsHandler(
+            record=store_handler.record,
+            read=store_handler.read,
+            enter_scope=store_handler.enter_scope,
+            exit_scope=store_handler.exit_scope,
+        )
+
+    def __init__(self) -> None:
+        self.scopes: dict[ScopeIdentifier, MetricsScopeStore] = {}
+
+    def record(
+        self,
+        scope: ScopeIdentifier,
+        /,
+        metric: State,
+    ) -> None:
+        assert scope in self.scopes  # nosec: B101
+        metric_type: type[State] = type(metric)
+        metrics: dict[type[State], State] = self.scopes[scope].metrics
+        if (current := metrics.get(metric_type)) and hasattr(current, "__add__"):
+            metrics[type(metric)] = current.__add__(metric)  # pyright: ignore[reportUnknownMemberType, reportAttributeAccessIssue]
+
+        metrics[type(metric)] = metric
+
+    async def read[Metric: State](
+        self,
+        scope: ScopeIdentifier,
+        /,
+        *,
+        metric: type[Metric],
+        merged: bool,
+    ) -> Metric | None:
+        if merged:
+            return self.scopes[scope].merged(metric)
 
-        return tuple(merged_metrics.values())
+        else:
+            return cast(Metric | None, self.scopes[scope].metrics.get(metric))
+
+    def enter_scope[Metric: State](
+        self,
+        scope: ScopeIdentifier,
+        /,
+    ) -> None:
+        assert scope not in self.scopes  # nosec: B101
+        scope_metrics = MetricsScopeStore(scope)
+        self.scopes[scope] = scope_metrics
+        if not scope.is_root:  # root scopes have no actual parent
+            for key in self.scopes.keys():
+                if key.scope_id == scope.parent_id:
+                    self.scopes[key].nested.append(scope_metrics)
+                    return
+
+            ctx.log_debug(
+                "Attempting to enter nested scope metrics without entering its parent first"
+            )
+
+    def exit_scope[Metric: State](
+        self,
+        scope: ScopeIdentifier,
+        /,
+    ) -> None:
+        assert scope in self.scopes  # nosec: B101
+        self.scopes[scope].exited = monotonic()
 
 
 @final
@@ -67,6 +172,7 @@ class MetricsLogger:
         )
         return MetricsHandler(
             record=logger_handler.record,
+            read=logger_handler.read,
             enter_scope=logger_handler.enter_scope,
             exit_scope=logger_handler.exit_scope,
         )
@@ -100,6 +206,20 @@ class MetricsLogger:
         ):
             ctx.log_debug(f"Recorded metric:\n⎡ {type(metric).__qualname__}:{log}\n⌊")
 
+    async def read[Metric: State](
+        self,
+        scope: ScopeIdentifier,
+        /,
+        *,
+        metric: type[Metric],
+        merged: bool,
+    ) -> Metric | None:
+        if merged:
+            return self.scopes[scope].merged(metric)
+
+        else:
+            return cast(Metric | None, self.scopes[scope].metrics.get(metric))
+
     def enter_scope[Metric: State](
         self,
         scope: ScopeIdentifier,
@@ -145,6 +265,9 @@ def _tree_log(
     )
 
     for metric in metrics.merged():
+        if type(metric) not in metrics.metrics:
+            continue  # skip metrics not available in this scope
+
         metric_log: str = ""
         for key, value in vars(metric).items():
             if value_log := _value_log(
@@ -160,7 +283,7 @@ def _tree_log(
         if not metric_log:
             continue  # skip empty logs
 
-        log += f"\n⎡ •{type(metric).__qualname__}:{metric_log.replace("\n", "\n|  ")}\n⌊"
+        log += f"\n⎡ •{type(metric).__qualname__}:{metric_log.replace('\n', '\n|  ')}\n⌊"
 
     for nested in metrics.nested:
         nested_log: str = _tree_log(

{haiway-0.8.4.dist-info → haiway-0.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: haiway
-Version: 0.8.4
+Version: 0.9.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.8.4.dist-info → haiway-0.9.0.dist-info}/RECORD

@@ -1,18 +1,18 @@
-haiway/__init__.py,sha256=Llf80-CD62BLe-sI01SCctZqlawNlOwWUUoK0jV-_XQ,1755
+haiway/__init__.py,sha256=JoXmo8maenl0yVsE1CetmJjP80v0ifU2_5dJdzuzadg,1837
 haiway/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-haiway/context/__init__.py,sha256=FDPD92cVaZKbQoyXl8lO1GzrscfTSrvST_gtfxOxxcM,620
-haiway/context/access.py,sha256=7UfhtDCjkVtdLfdWc5nR58KwKI3r693LcjFAlRtYHa0,15653
+haiway/context/__init__.py,sha256=eRvuhifx7xCd-_6desgk55idzNpD5S5sprmCfGb3_9M,662
+haiway/context/access.py,sha256=RpTvs7107NoAxCgxxbp7BUThOM9gLXo_Vxv-JgDqW58,16954
 haiway/context/disposables.py,sha256=DZjnMp-wMfF-em2Wjhbm1MvXubNpuzFBT70BQNIxC7M,2019
 haiway/context/identifier.py,sha256=f5-vZOnhKZmYj__emS51WcgsJqfD_yz6ilr3GUo9z1k,2034
 haiway/context/logging.py,sha256=ptwgENuyw-WFgokVsYx9OXZGhJENuO_wgfVjcBryUKM,4251
-haiway/context/metrics.py,sha256=m3fFem_zukiWejmb9KPqgX1lyR8GxB_AgPSDRjfUmFk,3234
+haiway/context/metrics.py,sha256=Ve628X39u0rdLm0vYmVZt7aGeoEeRquR6f67vJIXClY,4213
 haiway/context/state.py,sha256=LCcFxXqDBu6prvPyPicN-ecONSNHyR56PfQ5u5jNFCU,3000
 haiway/context/tasks.py,sha256=h6OxLxHHqkw0LfQi81NtbsCKfACKxYRZAkDhlJTpqCM,1904
 haiway/context/types.py,sha256=VvJA7wAPZ3ISpgyThVguioYUXqhHf0XkPfRd0M1ERiQ,142
-haiway/helpers/__init__.py,sha256=a2x-geUNGKe8HqqmCCZO-6GNUic-bARSnKeUNJeWQpY,543
-haiway/helpers/asynchrony.py,sha256=rh_Hwo0MQHfKnw5dLUCFTAm3Fk3SVS8Or8cTcQFdPA8,6042
+haiway/helpers/__init__.py,sha256=8XRJWNhidWuBKqRZ1Hyc2xqt7DeWLcoOs2V-oexl8VY,579
+haiway/helpers/asynchrony.py,sha256=9lo9wT3G0TyPb4vfmTnWGBvB_eN6p6nIlj46_9Ag8fQ,6022
 haiway/helpers/caching.py,sha256=Ok_WE5Whe7XqnIuLZo4rNNBFeWap-aUWX799s4b1JAQ,9536
-haiway/helpers/metrics.py,sha256=Xre7t5ZfR3RnvpX6-9o8t1nWwtrmGJOuUeZ0dy8E0rc,8761
+haiway/helpers/metrics.py,sha256=0CDDEM3QZL35Wc3GteNoAeMuLDehJX06ukxLpNediq0,12813
 haiway/helpers/retries.py,sha256=gIkyUlqJLDYaxIZd3qzeqGFY9y5Gp8dgZLlZ6hs8hoc,7538
 haiway/helpers/throttling.py,sha256=zo0OwFq64si5KUwhd58cFHLmGAmYwRbFRJMbv9suhPs,3844
 haiway/helpers/timeouted.py,sha256=1xU09hQnFdj6p48BwZl5xUvtIr3zC0ZUXehkdrduCjs,3074
@@ -36,8 +36,8 @@ haiway/utils/mimic.py,sha256=BkVjTVP2TxxC8GChPGyDV6UXVwJmiRiSWeOYZNZFHxs,1828
 haiway/utils/noop.py,sha256=qgbZlOKWY6_23Zs43OLukK2HagIQKRyR04zrFVm5rWI,344
 haiway/utils/queue.py,sha256=oQ3GXCJ-PGNtMEr6EPdgqAvYZoj8lAa7Z2drBKBEoBM,2345
 haiway/utils/sequences.py,sha256=mXLAzH94HZHi0P7fF593FHNNTn1eNMRHA4Uxlr3UOu0,1064
-haiway-0.8.4.dist-info/LICENSE,sha256=GehQEW_I1pkmxkkj3NEa7rCTQKYBn7vTPabpDYJlRuo,1063
-haiway-0.8.4.dist-info/METADATA,sha256=kgICAuwSBcUZR47tc1Vtvj4EoRwPaWcQCRATc1epLMY,3894
-haiway-0.8.4.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-haiway-0.8.4.dist-info/top_level.txt,sha256=_LdXVLzUzgkvAGQnQJj5kQfoFhpPW6EF4Kj9NapniLg,7
-haiway-0.8.4.dist-info/RECORD,,
+haiway-0.9.0.dist-info/LICENSE,sha256=GehQEW_I1pkmxkkj3NEa7rCTQKYBn7vTPabpDYJlRuo,1063
+haiway-0.9.0.dist-info/METADATA,sha256=cyppQLkl2UkcV50wpqfFlMIxSXfMG6X2-Aip7C-gBTo,3894
+haiway-0.9.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+haiway-0.9.0.dist-info/top_level.txt,sha256=_LdXVLzUzgkvAGQnQJj5kQfoFhpPW6EF4Kj9NapniLg,7
+haiway-0.9.0.dist-info/RECORD,,