haiway 0.7.1__py3-none-any.whl → 0.8.0__py3-none-any.whl

haiway/helpers/metrics.py

@@ -0,0 +1,307 @@
+from collections.abc import Sequence
+from itertools import chain
+from time import monotonic
+from typing import Any, Self, cast, final
+
+from haiway.context import MetricsHandler, ScopeIdentifier, ctx
+from haiway.state import State
+from haiway.types import MISSING, Missing
+
+__all_ = [
+    "MetricsLogger",
+]
+
+
+class MetricsScopeStore:
+    def __init__(
+        self,
+        identifier: ScopeIdentifier,
+        /,
+    ) -> None:
+        self.identifier: ScopeIdentifier = identifier
+        self.entered: float = monotonic()
+        self.metrics: dict[type[State], State] = {}
+        self.exited: float | None = None
+        self.nested: list[MetricsScopeStore] = []
+
+    @property
+    def time(self) -> float:
+        return (self.exited or monotonic()) - self.entered
+
+    @property
+    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,
+            )
+
+            if current is MISSING:
+                continue  # do not merge to missing
+
+            elif hasattr(current, "__add__"):
+                merged_metrics[metric_type] = current.__add__(element)  # pyright: ignore[reportUnknownMemberType, reportAttributeAccessIssue]
+
+            else:
+                merged_metrics[metric_type] = element
+
+        return tuple(merged_metrics.values())
+
+
+@final
+class MetricsLogger:
+    @classmethod
+    def handler(
+        cls,
+        items_limit: int | None = None,
+        item_character_limit: int | None = None,
+    ) -> MetricsHandler:
+        logger_handler: Self = cls(
+            items_limit=items_limit,
+            item_character_limit=item_character_limit,
+        )
+        return MetricsHandler(
+            record=logger_handler.record,
+            enter_scope=logger_handler.enter_scope,
+            exit_scope=logger_handler.exit_scope,
+        )
+
+    def __init__(
+        self,
+        items_limit: int | None = None,
+        item_character_limit: int | None = None,
+    ) -> None:
+        self.items_limit: int | None = items_limit
+        self.item_character_limit: int | None = item_character_limit
+        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
+        if __debug__:
+            if log := _state_log(
+                metric,
+                list_items_limit=self.items_limit,
+                item_character_limit=self.item_character_limit,
+            ):
+                ctx.log_info(f"Recorded:\n• {type(metric).__qualname__}:{log}")
+
+    def enter_scope[Metric: State](
+        self,
+        scope: ScopeIdentifier,
+        /,
+    ) -> None:
+        assert scope not in self.scopes  # nosec: B101
+        self.scopes[scope] = MetricsScopeStore(scope)
+
+    def exit_scope[Metric: State](
+        self,
+        scope: ScopeIdentifier,
+        /,
+    ) -> None:
+        assert scope in self.scopes  # nosec: B101
+        self.scopes[scope].exited = monotonic()
+
+        if __debug__:
+            if scope.is_root and self.scopes[scope].finished:
+                if log := _tree_log(
+                    self.scopes[scope],
+                    list_items_limit=self.items_limit,
+                    item_character_limit=self.item_character_limit,
+                ):
+                    ctx.log_info(log)
+
+
+def _tree_log(
+    metrics: MetricsScopeStore,
+    list_items_limit: int | None,
+    item_character_limit: int | None,
+) -> str:
+    log: str = f"@{metrics.identifier}({metrics.time:.2f}s):"
+
+    for metric in metrics.merged():
+        metric_log: str = ""
+        for key, value in vars(metric).items():
+            if value_log := _value_log(
+                value,
+                list_items_limit=list_items_limit,
+                item_character_limit=item_character_limit,
+            ):
+                metric_log += f"\n|  + {key}: {value_log}"
+
+            else:
+                continue  # skip missing values
+
+        if not metric_log:
+            continue  # skip empty logs
+
+        log += f"\n• {type(metric).__qualname__}:{metric_log}"
+
+    for nested in metrics.nested:
+        nested_log: str = _tree_log(
+            nested,
+            list_items_limit=list_items_limit,
+            item_character_limit=item_character_limit,
+        ).replace("\n", "\n|  ")
+
+        log += f"\n{nested_log}"
+
+    return log.strip()
+
+
+def _state_log(
+    value: State,
+    /,
+    list_items_limit: int | None,
+    item_character_limit: int | None,
+) -> str | None:
+    state_log: str = ""
+    for key, element in vars(value).items():
+        element_log: str | None = _value_log(
+            element,
+            list_items_limit=list_items_limit,
+            item_character_limit=item_character_limit,
+        )
+
+        if element_log:
+            state_log += f"\n|  + {key}: {element_log}"
+
+        else:
+            continue  # skip empty logs
+
+    if state_log:
+        return state_log.replace("\n", "\n|  ")
+
+    else:
+        return None  # skip empty logs
+
+
+def _dict_log(
+    value: dict[Any, Any],
+    /,
+    list_items_limit: int | None,
+    item_character_limit: int | None,
+) -> str | None:
+    dict_log: str = ""
+    for key, element in value.items():
+        element_log: str | None = _value_log(
+            element,
+            list_items_limit=list_items_limit,
+            item_character_limit=item_character_limit,
+        )
+        if element_log:
+            dict_log += f"\n|  + {key}: {element_log}"
+
+        else:
+            continue  # skip empty logs
+
+    if dict_log:
+        return dict_log.replace("\n", "\n|  ")
+
+    else:
+        return None  # skip empty logs
+
+
+def _list_log(
+    value: list[Any],
+    /,
+    list_items_limit: int | None,
+    item_character_limit: int | None,
+) -> str | None:
+    list_log: str = ""
+    enumerated: list[tuple[int, Any]] = list(enumerate(value))
+    if list_items_limit:
+        if list_items_limit > 0:
+            enumerated = enumerated[:list_items_limit]
+
+        else:
+            enumerated = enumerated[list_items_limit:]
+
+    for idx, element in enumerated:
+        element_log: str | None = _value_log(
+            element,
+            list_items_limit=list_items_limit,
+            item_character_limit=item_character_limit,
+        )
+        if element_log:
+            list_log += f"\n|  [{idx}] {element_log}"
+
+        else:
+            continue  # skip empty logs
+
+    if list_log:
+        return list_log.replace("\n", "\n|  ")
+
+    else:
+        return None  # skip empty logs
+
+
+def _raw_value_log(
+    value: Any,
+    /,
+    item_character_limit: int | None,
+) -> str | None:
+    if value is MISSING:
+        return None  # skip missing
+
+    value_log = str(value)
+    if not value_log:
+        return None  # skip empty logs
+
+    if (item_character_limit := item_character_limit) and len(value_log) > item_character_limit:
+        return value_log.replace("\n", " ")[:item_character_limit] + "..."
+
+    else:
+        return value_log.replace("\n", "\n|  ")
+
+
+def _value_log(
+    value: Any,
+    /,
+    list_items_limit: int | None,
+    item_character_limit: int | None,
+) -> str | None:
+    # try unpack dicts
+    if isinstance(value, dict):
+        return _dict_log(
+            cast(dict[Any, Any], value),
+            list_items_limit=list_items_limit,
+            item_character_limit=item_character_limit,
+        )
+
+    # try unpack lists
+    elif isinstance(value, list):
+        return _list_log(
+            cast(list[Any], value),
+            list_items_limit=list_items_limit,
+            item_character_limit=item_character_limit,
+        )
+
+    # try unpack state
+    elif isinstance(value, State):
+        return _state_log(
+            value,
+            list_items_limit=list_items_limit,
+            item_character_limit=item_character_limit,
+        )
+
+    else:
+        return _raw_value_log(
+            value,
+            item_character_limit=item_character_limit,
+        )

haiway/state/structure.py

@@ -91,7 +91,7 @@ class StateMeta(type):
                 ),
             )
 
-        state_type.__PARAMETERS__ = type_parameters  # pyright: ignore[reportAttributeAccessIssue]
+        state_type.__TYPE_PARAMETERS__ = type_parameters  # pyright: ignore[reportAttributeAccessIssue]
         state_type.__ATTRIBUTES__ = attributes  # pyright: ignore[reportAttributeAccessIssue]
         state_type.__slots__ = frozenset(attributes.keys())  # pyright: ignore[reportAttributeAccessIssue]
         state_type.__match_args__ = state_type.__slots__  # pyright: ignore[reportAttributeAccessIssue]
@@ -139,7 +139,7 @@ class StateMeta(type):
         # then check if we are parametrized
         checked_parameters: Mapping[str, Any] | None = getattr(
             self,
-            "__PARAMETERS__",
+            "__TYPE_PARAMETERS__",
             None,
         )
         if checked_parameters is None:
@@ -152,7 +152,7 @@ class StateMeta(type):
             # we can verify all of the attributes to check if we have common base
             available_parameters: Mapping[str, Any] | None = getattr(
                 subclass,
-                "__PARAMETERS__",
+                "__TYPE_PARAMETERS__",
                 None,
             )
 
@@ -204,7 +204,7 @@ class State(metaclass=StateMeta):
 
     _: ClassVar[Self]
     __IMMUTABLE__: ClassVar[EllipsisType] = ...
-    __PARAMETERS__: ClassVar[Mapping[str, Any] | None] = None
+    __TYPE_PARAMETERS__: ClassVar[Mapping[str, Any] | None] = None
     __ATTRIBUTES__: ClassVar[dict[str, StateAttribute[Any]]]
 
     @classmethod
@@ -213,7 +213,7 @@ class State(metaclass=StateMeta):
         type_argument: tuple[type[Any], ...] | type[Any],
     ) -> type[Self]:
         assert Generic in cls.__bases__, "Can't specialize non generic type!"  # nosec: B101
-        assert cls.__PARAMETERS__ is None, "Can't specialize already specialized type!"  # nosec: B101
+        assert cls.__TYPE_PARAMETERS__ is None, "Can't specialize already specialized type!"  # nosec: B101
 
         type_arguments: tuple[type[Any], ...]
         match type_argument:

{haiway-0.7.1.dist-info → haiway-0.8.0.dist-info}/METADATA

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

@@ -1,15 +1,18 @@
-haiway/__init__.py,sha256=GslXcxpiKSKmcWlsvj25X7uDZzuUDUUL8pxAKFqbvIs,1387
+haiway/__init__.py,sha256=W11mHfW3WnYhVAuNOHeEHVc-BQkOodHM9j4_o36j4dA,1669
 haiway/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-haiway/context/__init__.py,sha256=ZgQoQFUqfPDqeIbhS898C3dP02QzOCRmClVQpHaPTBA,336
-haiway/context/access.py,sha256=CB-F9Yd6EAoJIqzMQGid9szww7aFiti5z6x0T79LV7k,14098
+haiway/context/__init__.py,sha256=FDPD92cVaZKbQoyXl8lO1GzrscfTSrvST_gtfxOxxcM,620
+haiway/context/access.py,sha256=7UfhtDCjkVtdLfdWc5nR58KwKI3r693LcjFAlRtYHa0,15653
 haiway/context/disposables.py,sha256=DZjnMp-wMfF-em2Wjhbm1MvXubNpuzFBT70BQNIxC7M,2019
-haiway/context/metrics.py,sha256=z5p5ItzXhrYoF8lgC8u179oABBy66mPeCEJR_GKmrLg,10882
-haiway/context/state.py,sha256=GxGwPQTK8FdSprBd83lQbA9veubp0o93_1Yk3gb7HMc,3000
-haiway/context/tasks.py,sha256=xXtXIUwXOra0EePTdkcEbMOmpWwFcO3hCRfR_IfvAHk,1978
+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/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=iiFTjGnVf6dB7Gry5FuS5SFiU1lGI09JBTGoa3sozLI,473
+haiway/helpers/__init__.py,sha256=a2x-geUNGKe8HqqmCCZO-6GNUic-bARSnKeUNJeWQpY,543
 haiway/helpers/asynchrony.py,sha256=rh_Hwo0MQHfKnw5dLUCFTAm3Fk3SVS8Or8cTcQFdPA8,6042
 haiway/helpers/caching.py,sha256=Ok_WE5Whe7XqnIuLZo4rNNBFeWap-aUWX799s4b1JAQ,9536
+haiway/helpers/metrics.py,sha256=ERTpyryPqTnkLdXdDfP91jojUrloMVL-AAeoGa0Pjls,8711
 haiway/helpers/retries.py,sha256=gIkyUlqJLDYaxIZd3qzeqGFY9y5Gp8dgZLlZ6hs8hoc,7538
 haiway/helpers/throttling.py,sha256=zo0OwFq64si5KUwhd58cFHLmGAmYwRbFRJMbv9suhPs,3844
 haiway/helpers/timeouted.py,sha256=1xU09hQnFdj6p48BwZl5xUvtIr3zC0ZUXehkdrduCjs,3074
@@ -18,7 +21,7 @@ haiway/state/__init__.py,sha256=emTuwGFn7HyjyTJ_ass69J5jQIA7_WHO4teZz_dR05Y,355
 haiway/state/attributes.py,sha256=iQ7TJHnT3hlcYwKcxchXE56zU8WbOTJZhsVn_HocXBc,22903
 haiway/state/path.py,sha256=4vh-fYQv8_xRWjS0ErMQslKDWRI6-KVECAr8JhYk0UY,17503
 haiway/state/requirement.py,sha256=3iQqzp5Q7w6y5uClamJGH7S5Hib9pciuTAV27PP5lS8,6161
-haiway/state/structure.py,sha256=dqLXUJPnaQqdRxbNwtGgUqGNCA8EDPj16M3Ob_sEz5U,11837
+haiway/state/structure.py,sha256=KvWC9_gE9pjtyUAzcFnQ12K8SyBqwbdPK_z8D2xzqDs,11862
 haiway/state/validation.py,sha256=n5cHcJTbv3Zf-qs05yzuLJIMBReV_4yYVwcH6IL58N0,13836
 haiway/types/__init__.py,sha256=00Ulp2BxcIWm9vWXKQPodpFEwE8hpqj6OYgrNxelp5s,252
 haiway/types/frozen.py,sha256=CZhFCXnWAKEhuWSfILxA8smfdpMd5Ku694ycfLh98R8,76
@@ -31,8 +34,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=oQ3GXCJ-PGNtMEr6EPdgqAvYZoj8lAa7Z2drBKBEoBM,2345
-haiway-0.7.1.dist-info/LICENSE,sha256=GehQEW_I1pkmxkkj3NEa7rCTQKYBn7vTPabpDYJlRuo,1063
-haiway-0.7.1.dist-info/METADATA,sha256=XacjUXNqPQaTSoCxEcqcOcGgjAGr6uxBguhLwrEaIMM,3898
-haiway-0.7.1.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-haiway-0.7.1.dist-info/top_level.txt,sha256=_LdXVLzUzgkvAGQnQJj5kQfoFhpPW6EF4Kj9NapniLg,7
-haiway-0.7.1.dist-info/RECORD,,
+haiway-0.8.0.dist-info/LICENSE,sha256=GehQEW_I1pkmxkkj3NEa7rCTQKYBn7vTPabpDYJlRuo,1063
+haiway-0.8.0.dist-info/METADATA,sha256=Oe38AT-2rCTqdwbfogI_ji8zWHPW1DGaE62tLV46yVY,3898
+haiway-0.8.0.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+haiway-0.8.0.dist-info/top_level.txt,sha256=_LdXVLzUzgkvAGQnQJj5kQfoFhpPW6EF4Kj9NapniLg,7
+haiway-0.8.0.dist-info/RECORD,,