haiway 0.11.0__py3-none-any.whl → 0.12.0__py3-none-any.whl

haiway/context/tasks.py

@@ -1,8 +1,8 @@
 from asyncio import Task, TaskGroup, get_event_loop
 from collections.abc import Callable, Coroutine
-from contextvars import ContextVar, copy_context
+from contextvars import ContextVar, Token, copy_context
 from types import TracebackType
-from typing import final
+from typing import Any, final
 
 __all__ = [
     "TaskGroupContext",
@@ -33,15 +33,54 @@ class TaskGroupContext:
                 context=copy_context(),
             )
 
+    __slots__ = (
+        "_group",
+        "_token",
+    )
+
     def __init__(
         self,
     ) -> None:
-        self._group: TaskGroup = TaskGroup()
+        self._group: TaskGroup
+        object.__setattr__(
+            self,
+            "_group",
+            TaskGroup(),
+        )
+        self._token: Token[TaskGroup] | None
+        object.__setattr__(
+            self,
+            "_token",
+            None,
+        )
+
+    def __setattr__(
+        self,
+        name: str,
+        value: Any,
+    ) -> Any:
+        raise AttributeError(
+            f"Can't modify immutable {self.__class__.__qualname__},"
+            f" attribute - '{name}' cannot be modified"
+        )
+
+    def __delattr__(
+        self,
+        name: str,
+    ) -> None:
+        raise AttributeError(
+            f"Can't modify immutable {self.__class__.__qualname__},"
+            f" attribute - '{name}' cannot be deleted"
+        )
 
     async def __aenter__(self) -> None:
-        assert not hasattr(self, "_token"), "Context reentrance is not allowed"  # nosec: B101
+        assert self._token is None, "Context reentrance is not allowed"  # nosec: B101
         await self._group.__aenter__()
-        self._token = TaskGroupContext._context.set(self._group)
+        object.__setattr__(
+            self,
+            "_token",
+            TaskGroupContext._context.set(self._group),
+        )
 
     async def __aexit__(
         self,
@@ -49,9 +88,13 @@ class TaskGroupContext:
         exc_val: BaseException | None,
         exc_tb: TracebackType | None,
     ) -> None:
-        assert hasattr(self, "_token"), "Unbalanced context enter/exit"  # nosec: B101
+        assert self._token is not None, "Unbalanced context enter/exit"  # nosec: B101
         TaskGroupContext._context.reset(self._token)
-        del self._token
+        object.__setattr__(
+            self,
+            "_token",
+            None,
+        )
 
         try:
             await self._group.__aexit__(

haiway/helpers/asynchrony.py

@@ -107,6 +107,20 @@ def asynchronous[**Args, Result](
 
 
 class _ExecutorWrapper[**Args, Result]:
+    __slots__ = (
+        "__annotations__",
+        "__defaults__",
+        "__doc__",
+        "__globals__",
+        "__kwdefaults__",
+        "__name__",
+        "__qualname__",
+        "__wrapped__",
+        "_executor",
+        "_function",
+        "_loop",
+    )
+
     def __init__(
         self,
         function: Callable[Args, Result],

haiway/helpers/caching.py

@@ -89,6 +89,21 @@ class _CacheEntry[Entry](NamedTuple):
 
 
 class _SyncCache[**Args, Result]:
+    __slots__ = (
+        "__annotations__",
+        "__defaults__",
+        "__doc__",
+        "__globals__",
+        "__kwdefaults__",
+        "__name__",
+        "__qualname__",
+        "__wrapped__",
+        "_cached",
+        "_function",
+        "_limit",
+        "_next_expire_time",
+    )
+
     def __init__(
         self,
         function: Callable[Args, Result],
@@ -206,6 +221,21 @@ class _SyncCache[**Args, Result]:
 
 
 class _AsyncCache[**Args, Result]:
+    __slots__ = (
+        "__annotations__",
+        "__defaults__",
+        "__doc__",
+        "__globals__",
+        "__kwdefaults__",
+        "__name__",
+        "__qualname__",
+        "__wrapped__",
+        "_cached",
+        "_function",
+        "_limit",
+        "_next_expire_time",
+    )
+
     def __init__(
         self,
         function: Callable[Args, Coroutine[None, None, Result]],

haiway/helpers/metrics.py

@@ -14,6 +14,14 @@ __all_ = [
 
 
 class MetricsScopeStore:
+    __slots__ = (
+        "entered",
+        "exited",
+        "identifier",
+        "metrics",
+        "nested",
+    )
+
     def __init__(
         self,
         identifier: ScopeIdentifier,
@@ -100,6 +108,11 @@ class MetricsHolder:
             exit_scope=store_handler.exit_scope,
         )
 
+    __slots__ = (
+        "root_scope",
+        "scopes",
+    )
+
     def __init__(self) -> None:
         self.root_scope: ScopeIdentifier | None = None
         self.scopes: dict[ScopeIdentifier, MetricsScopeStore] = {}
@@ -187,6 +200,13 @@ class MetricsLogger:
             exit_scope=logger_handler.exit_scope,
         )
 
+    __slots__ = (
+        "items_limit",
+        "redact_content",
+        "root_scope",
+        "scopes",
+    )
+
     def __init__(
         self,
         items_limit: int | None,

haiway/helpers/throttling.py

@@ -89,6 +89,22 @@ def throttle[**Args, Result](
 
 
 class _AsyncThrottle[**Args, Result]:
+    __slots__ = (
+        "__annotations__",
+        "__defaults__",
+        "__doc__",
+        "__globals__",
+        "__kwdefaults__",
+        "__name__",
+        "__qualname__",
+        "__wrapped__",
+        "_entries",
+        "_function",
+        "_limit",
+        "_lock",
+        "_period",
+    )
+
     def __init__(
         self,
         function: Callable[Args, Coroutine[None, None, Result]],

haiway/helpers/timeouted.py

@@ -45,6 +45,19 @@ def timeout[**Args, Result](
 
 
 class _AsyncTimeout[**Args, Result]:
+    __slots__ = (
+        "__annotations__",
+        "__defaults__",
+        "__doc__",
+        "__globals__",
+        "__kwdefaults__",
+        "__name__",
+        "__qualname__",
+        "__wrapped__",
+        "_function",
+        "_timeout",
+    )
+
     def __init__(
         self,
         function: Callable[Args, Coroutine[None, None, Result]],

haiway/helpers/tracing.py

@@ -1,6 +1,6 @@
 from asyncio import iscoroutinefunction
 from collections.abc import Callable, Coroutine, Mapping, Sequence
-from typing import Any, Self, cast
+from typing import Any, Self, cast, overload
 
 from haiway.context import ctx
 from haiway.state import State
@@ -61,28 +61,53 @@ class ResultTrace(State):
     result: Any | Missing
 
 
+@overload
 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__,
-                ),
-            )
+) -> Callable[Args, Result]: ...
+
+
+@overload
+def traced[**Args, Result](
+    *,
+    label: str,
+) -> Callable[[Callable[Args, Result]], Callable[Args, Result]]: ...
 
-        else:
-            return _traced_sync(
-                function,
-                label=function.__name__,
-            )
 
-    else:  # do not trace on non debug runs
-        return function
+def traced[**Args, Result](
+    function: Callable[Args, Result] | None = None,
+    /,
+    *,
+    label: str | None = None,
+) -> Callable[[Callable[Args, Result]], Callable[Args, Result]] | Callable[Args, Result]:
+    def wrap(
+        wrapped: Callable[Args, Result],
+    ) -> Callable[Args, Result]:
+        if __debug__:
+            if iscoroutinefunction(wrapped):
+                return cast(
+                    Callable[Args, Result],
+                    _traced_async(
+                        wrapped,
+                        label=label or wrapped.__name__,
+                    ),
+                )
+
+            else:
+                return _traced_sync(
+                    wrapped,
+                    label=label or wrapped.__name__,
+                )
+
+        else:  # do not trace on non debug runs
+            return wrapped
+
+    if function := function:
+        return wrap(wrapped=function)
+
+    else:
+        return wrap
 
 
 def _traced_sync[**Args, Result](

haiway/state/attributes.py

@@ -14,6 +14,7 @@ from typing import (
     TypeVar,
     TypeVarTuple,
     _GenericAlias,  # pyright: ignore
+    final,
     get_args,
     get_origin,
     get_type_hints,
@@ -31,7 +32,15 @@ __all__ = [
 ]
 
 
+@final
 class AttributeAnnotation:
+    __slots__ = (
+        "arguments",
+        "extra",
+        "origin",
+        "required",
+    )
+
     def __init__(
         self,
         *,
@@ -49,6 +58,7 @@ class AttributeAnnotation:
             self.arguments = arguments
 
         self.required: bool = required
+
         self.extra: Mapping[str, Any]
         if extra is None:
             self.extra = {}
@@ -61,7 +71,11 @@ class AttributeAnnotation:
         required: bool,
         /,
     ) -> Self:
-        self.required = self.required and required
+        object.__setattr__(
+            self,
+            "required",
+            self.required and required,
+        )
 
         return self
 

haiway/state/path.py

@@ -41,6 +41,12 @@ class AttributePathComponent(ABC):
 
 @final
 class PropertyAttributePathComponent(AttributePathComponent):
+    __slots__ = (
+        "_access",
+        "_assigning",
+        "_name",
+    )
+
     def __init__[Root, Attribute](
         self,
         root: type[Root],
@@ -104,9 +110,43 @@ class PropertyAttributePathComponent(AttributePathComponent):
 
             return updated  # pyright: ignore[reportUnknownVariableType]
 
-        self._access: Callable[[Any], Any] = access
-        self._assigning: Callable[[Any, Any], Any] = assigning
-        self._name: str = name
+        self._access: Callable[[Any], Any]
+        object.__setattr__(
+            self,
+            "_access",
+            access,
+        )
+        self._assigning: Callable[[Any, Any], Any]
+        object.__setattr__(
+            self,
+            "_assigning",
+            assigning,
+        )
+        self._name: str
+        object.__setattr__(
+            self,
+            "_name",
+            name,
+        )
+
+    def __setattr__(
+        self,
+        name: str,
+        value: Any,
+    ) -> Any:
+        raise AttributeError(
+            f"Can't modify immutable {self.__class__.__qualname__},"
+            f" attribute - '{name}' cannot be modified"
+        )
+
+    def __delattr__(
+        self,
+        name: str,
+    ) -> None:
+        raise AttributeError(
+            f"Can't modify immutable {self.__class__.__qualname__},"
+            f" attribute - '{name}' cannot be deleted"
+        )
 
     def path_str(
         self,
@@ -137,6 +177,12 @@ class PropertyAttributePathComponent(AttributePathComponent):
 
 @final
 class SequenceItemAttributePathComponent(AttributePathComponent):
+    __slots__ = (
+        "_access",
+        "_assigning",
+        "_index",
+    )
+
     def __init__[Root: Sequence[Any], Attribute](
         self,
         root: type[Root],
@@ -182,9 +228,43 @@ class SequenceItemAttributePathComponent(AttributePathComponent):
             temp_list[index] = value
             return subject.__class__(temp_list)  # pyright: ignore[reportCallIssue, reportUnknownVariableType, reportUnknownMemberType]
 
-        self._access: Callable[[Any], Any] = access
-        self._assigning: Callable[[Any, Any], Any] = assigning
-        self._index: Any = index
+        self._access: Callable[[Any], Any]
+        object.__setattr__(
+            self,
+            "_access",
+            access,
+        )
+        self._assigning: Callable[[Any, Any], Any]
+        object.__setattr__(
+            self,
+            "_assigning",
+            assigning,
+        )
+        self._index: Any
+        object.__setattr__(
+            self,
+            "_index",
+            index,
+        )
+
+    def __setattr__(
+        self,
+        name: str,
+        value: Any,
+    ) -> Any:
+        raise AttributeError(
+            f"Can't modify immutable {self.__class__.__qualname__},"
+            f" attribute - '{name}' cannot be modified"
+        )
+
+    def __delattr__(
+        self,
+        name: str,
+    ) -> None:
+        raise AttributeError(
+            f"Can't modify immutable {self.__class__.__qualname__},"
+            f" attribute - '{name}' cannot be deleted"
+        )
 
     def path_str(
         self,
@@ -211,6 +291,12 @@ class SequenceItemAttributePathComponent(AttributePathComponent):
 
 @final
 class MappingItemAttributePathComponent(AttributePathComponent):
+    __slots__ = (
+        "_access",
+        "_assigning",
+        "_key",
+    )
+
     def __init__[Root: Mapping[Any, Any], Attribute](
         self,
         root: type[Root],
@@ -256,9 +342,43 @@ class MappingItemAttributePathComponent(AttributePathComponent):
             temp_dict[key] = value
             return subject.__class__(temp_dict)  # pyright: ignore[reportCallIssue, reportUnknownVariableType, reportUnknownMemberType]
 
-        self._access: Callable[[Any], Any] = access
-        self._assigning: Callable[[Any, Any], Any] = assigning
-        self._key: Any = key
+        self._access: Callable[[Any], Any]
+        object.__setattr__(
+            self,
+            "_access",
+            access,
+        )
+        self._assigning: Callable[[Any, Any], Any]
+        object.__setattr__(
+            self,
+            "_assigning",
+            assigning,
+        )
+        self._key: Any
+        object.__setattr__(
+            self,
+            "_key",
+            key,
+        )
+
+    def __setattr__(
+        self,
+        name: str,
+        value: Any,
+    ) -> Any:
+        raise AttributeError(
+            f"Can't modify immutable {self.__class__.__qualname__},"
+            f" attribute - '{name}' cannot be modified"
+        )
+
+    def __delattr__(
+        self,
+        name: str,
+    ) -> None:
+        raise AttributeError(
+            f"Can't modify immutable {self.__class__.__qualname__},"
+            f" attribute - '{name}' cannot be deleted"
+        )
 
     def path_str(
         self,
@@ -285,6 +405,12 @@ class MappingItemAttributePathComponent(AttributePathComponent):
 
 @final
 class AttributePath[Root, Attribute]:
+    __slots__ = (
+        "__attribute__",
+        "__components__",
+        "__root__",
+    )
+
     @overload
     def __init__(
         self,
@@ -311,9 +437,43 @@ class AttributePath[Root, Attribute]:
         attribute: type[Attribute],
     ) -> None:
         assert components or root == attribute  # nosec: B101
-        self.__root__: type[Root] = root
-        self.__attribute__: type[Attribute] = attribute
-        self.__components__: tuple[AttributePathComponent, ...] = components
+        self.__root__: type[Root]
+        object.__setattr__(
+            self,
+            "__root__",
+            root,
+        )
+        self.__attribute__: type[Attribute]
+        object.__setattr__(
+            self,
+            "__attribute__",
+            attribute,
+        )
+        self.__components__: tuple[AttributePathComponent, ...]
+        object.__setattr__(
+            self,
+            "__components__",
+            components,
+        )
+
+    def __setattr__(
+        self,
+        name: str,
+        value: Any,
+    ) -> Any:
+        raise AttributeError(
+            f"Can't modify immutable {self.__class__.__qualname__},"
+            f" attribute - '{name}' cannot be modified"
+        )
+
+    def __delattr__(
+        self,
+        name: str,
+    ) -> None:
+        raise AttributeError(
+            f"Can't modify immutable {self.__class__.__qualname__},"
+            f" attribute - '{name}' cannot be deleted"
+        )
 
     @property
     def components(self) -> Sequence[str]:

haiway/state/requirement.py

@@ -2,7 +2,6 @@ from collections.abc import Callable, Collection, Iterable
 from typing import Any, Literal, Self, cast, final
 
 from haiway.state.path import AttributePath
-from haiway.utils import freeze
 
 __all__ = [
     "AttributeRequirement",
@@ -142,6 +141,13 @@ class AttributeRequirement[Root]:
             check=check_contained_in,
         )
 
+    __slots__ = (
+        "_check",
+        "lhs",
+        "operator",
+        "rhs",
+    )
+
     def __init__(
         self,
         lhs: Any,
@@ -157,7 +163,12 @@ class AttributeRequirement[Root]:
         rhs: Any,
         check: Callable[[Root], None],
     ) -> None:
-        self.lhs: Any = lhs
+        self.lhs: Any
+        object.__setattr__(
+            self,
+            "lhs",
+            lhs,
+        )
         self.operator: Literal[
             "equal",
             "not_equal",
@@ -166,11 +177,24 @@ class AttributeRequirement[Root]:
             "contained_in",
             "and",
             "or",
-        ] = operator
-        self.rhs: Any = rhs
-        self._check: Callable[[Root], None] = check
-
-        freeze(self)
+        ]
+        object.__setattr__(
+            self,
+            "operator",
+            operator,
+        )
+        self.rhs: Any
+        object.__setattr__(
+            self,
+            "rhs",
+            rhs,
+        )
+        self._check: Callable[[Root], None]
+        object.__setattr__(
+            self,
+            "_check",
+            check,
+        )
 
     def __and__(
         self,
@@ -227,3 +251,22 @@ class AttributeRequirement[Root]:
         values: Iterable[Root],
     ) -> list[Root]:
         return [value for value in values if self.check(value, raise_exception=False)]
+
+    def __setattr__(
+        self,
+        name: str,
+        value: Any,
+    ) -> Any:
+        raise AttributeError(
+            f"Can't modify immutable {self.__class__.__qualname__},"
+            f" attribute - '{name}' cannot be modified"
+        )
+
+    def __delattr__(
+        self,
+        name: str,
+    ) -> None:
+        raise AttributeError(
+            f"Can't modify immutable {self.__class__.__qualname__},"
+            f" attribute - '{name}' cannot be deleted"
+        )