haiway 0.8.4__tar.gz → 0.9.0__tar.gz

{haiway-0.8.4/src/haiway.egg-info → haiway-0.9.0}/PKG-INFO

@@ -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 → haiway-0.9.0}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "haiway"
 description = "Framework for dependency injection and state management within structured concurrency model."
-version = "0.8.4"
+version = "0.9.0"
 readme = "README.md"
 maintainers = [
   { name = "Kacper Kaliński", email = "kacper.kalinski@miquido.com" },

{haiway-0.8.4 → haiway-0.9.0}/src/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-0.8.4 → haiway-0.9.0}/src/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-0.8.4 → haiway-0.9.0}/src/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-0.8.4 → haiway-0.9.0}/src/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-0.8.4 → haiway-0.9.0}/src/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-0.8.4 → haiway-0.9.0}/src/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-0.8.4 → haiway-0.9.0}/src/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 → haiway-0.9.0/src/haiway.egg-info}/PKG-INFO

@@ -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.9.0/src/haiway.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+guidelines
+haiway

{haiway-0.8.4 → haiway-0.9.0}/tests/test_auto_retry.py

@@ -61,7 +61,7 @@ async def test_logs_issue_with_errors():
         assert executions == 2
         assert logs.output == [
             f"ERROR:root:Attempting to retry {compute.__name__}"
-            f" which failed due to an error: {FakeException("fake")}"
+            f" which failed due to an error: {FakeException('fake')}"
         ]
 
 
@@ -260,7 +260,7 @@ async def test_async_logs_issue_with_errors():
         await compute("expected")
         assert executions == 2
         assert logs.output[0].startswith(
-            f"ERROR:root:Attempting to retry {compute.__name__}" " which failed due to an error"
+            f"ERROR:root:Attempting to retry {compute.__name__} which failed due to an error"
         )
 
 

haiway-0.8.4/src/haiway.egg-info/top_level.txt

@@ -1 +0,0 @@
-haiway