haiway 0.9.1__py3-none-any.whl → 0.10.1__py3-none-any.whl

haiway/__init__.py

@@ -28,6 +28,8 @@ from haiway.helpers import (
 from haiway.state import AttributePath, AttributeRequirement, State
 from haiway.types import (
     MISSING,
+    Default,
+    DefaultValue,
     Missing,
     frozenlist,
     is_missing,
@@ -39,6 +41,7 @@ from haiway.utils import (
     always,
     as_dict,
     as_list,
+    as_set,
     as_tuple,
     async_always,
     async_noop,
@@ -59,6 +62,8 @@ __all__ = [
     "AsyncQueue",
     "AttributePath",
     "AttributeRequirement",
+    "Default",
+    "DefaultValue",
     "Disposable",
     "Disposables",
     "MetricsContext",
@@ -78,6 +83,7 @@ __all__ = [
     "always",
     "as_dict",
     "as_list",
+    "as_set",
     "as_tuple",
     "async_always",
     "async_noop",

haiway/state/attributes.py

@@ -509,7 +509,10 @@ def _resolve_type_typeddict(
             self_annotation=resolved_attribute,
             recursion_guard=recursion_guard,
         ).update_required(key in annotation.__required_keys__)
-    resolved_attribute.extra = attributes
+    resolved_attribute.extra = {
+        "attributes": attributes,
+        "required": annotation.__required_keys__,
+    }
     return resolved_attribute
 
 

haiway/state/structure.py

@@ -1,5 +1,5 @@
 import typing
-from collections.abc import Mapping
+from collections.abc import Callable, Mapping
 from types import EllipsisType, GenericAlias
 from typing import (
     Any,
@@ -10,34 +10,55 @@ from typing import (
     cast,
     dataclass_transform,
     final,
+    overload,
 )
 from weakref import WeakValueDictionary
 
 from haiway.state.attributes import AttributeAnnotation, attribute_annotations
 from haiway.state.path import AttributePath
-from haiway.state.validation import (
-    AttributeValidation,
-    AttributeValidator,
-)
-from haiway.types import MISSING, Missing, not_missing
+from haiway.state.validation import AttributeValidation, AttributeValidator
+from haiway.types import MISSING, DefaultValue, Missing, not_missing
 
 __all__ = [
     "State",
 ]
 
 
+@overload
+def Default[Value](
+    value: Value,
+    /,
+) -> Value: ...
+
+
+@overload
+def Default[Value](
+    *,
+    factory: Callable[[], Value],
+) -> Value: ...
+
+
+def Default[Value](
+    value: Value | Missing = MISSING,
+    /,
+    *,
+    factory: Callable[[], Value] | Missing = MISSING,
+) -> Value:  # it is actually a DefaultValue, but type checker has to be fooled
+    return cast(Value, DefaultValue(value, factory=factory))
+
+
 @final
 class StateAttribute[Value]:
     def __init__(
         self,
         name: str,
         annotation: AttributeAnnotation,
-        default: Value | Missing,
+        default: DefaultValue[Value],
         validator: AttributeValidation[Value],
     ) -> None:
         self.name: str = name
         self.annotation: AttributeAnnotation = annotation
-        self.default: Value | Missing = default
+        self.default: DefaultValue[Value] = default
         self.validator: AttributeValidation[Value] = validator
 
     def validated(
@@ -45,13 +66,13 @@ class StateAttribute[Value]:
         value: Any | Missing,
         /,
     ) -> Value:
-        return self.validator(self.default if value is MISSING else value)
+        return self.validator(self.default() if value is MISSING else value)
 
 
 @dataclass_transform(
     kw_only_default=True,
     frozen_default=True,
-    field_specifiers=(),
+    field_specifiers=(DefaultValue,),
 )
 class StateMeta(type):
     def __new__(
@@ -81,7 +102,7 @@ class StateMeta(type):
             attributes[key] = StateAttribute(
                 name=key,
                 annotation=annotation.update_required(default is MISSING),
-                default=default,
+                default=_resolve_default(default),
                 validator=AttributeValidator.of(
                     annotation,
                     recursion_guard={
@@ -187,6 +208,18 @@ class StateMeta(type):
             return False  # we have different base / comparing to not parametrized
 
 
+def _resolve_default[Value](
+    value: DefaultValue[Value] | Value | Missing,
+) -> DefaultValue[Value]:
+    if isinstance(value, DefaultValue):
+        return cast(DefaultValue[Value], value)
+
+    return DefaultValue[Value](
+        value,
+        factory=MISSING,
+    )
+
+
 _types_cache: WeakValueDictionary[
     tuple[
         Any,

haiway/state/validation.py

@@ -86,6 +86,12 @@ class AttributeValidator[Type]:
         assert self.validation is not MISSING  # nosec: B101
         return self.validation(value)  # pyright: ignore[reportCallIssue, reportUnknownVariableType]
 
+    def __str__(self) -> str:
+        return f"Validator[{self.annotation}]"
+
+    def __repr__(self) -> str:
+        return f"Validator[{self.annotation}]"
+
 
 def _prepare_validator_of_any(
     annotation: AttributeAnnotation,
@@ -391,11 +397,12 @@ def _prepare_validator_of_typed_dict(
             case _:
                 raise TypeError(f"'{value}' is not matching expected type of 'str'")
 
+    formatted_type: str = str(annotation)
     values_validators: dict[str, AttributeValidation[Any]] = {
         key: AttributeValidator.of(element, recursion_guard=recursion_guard)
-        for key, element in annotation.extra.items()
+        for key, element in annotation.extra["attributes"].items()
     }
-    formatted_type: str = str(annotation)
+    required_values: Set[str] = annotation.extra["required"]
 
     def validator(
         value: Any,
@@ -406,8 +413,10 @@ def _prepare_validator_of_typed_dict(
                 validated: MutableMapping[str, Any] = {}
                 for key, validator in values_validators.items():
                     element: Any = elements.get(key, MISSING)
-                    if element is not MISSING:
-                        validated[key_validator(key)] = validator(element)
+                    if element is MISSING and key not in required_values:
+                        continue  # skip missing and not required
+
+                    validated[key_validator(key)] = validator(element)
 
                 # TODO: make sure dict is not mutable with MappingProxyType?
                 return validated

haiway/types/__init__.py

@@ -1,8 +1,11 @@
+from haiway.types.default import Default, DefaultValue
 from haiway.types.frozen import frozenlist
 from haiway.types.missing import MISSING, Missing, is_missing, not_missing, when_missing
 
 __all__ = [
     "MISSING",
+    "Default",
+    "DefaultValue",
     "Missing",
     "frozenlist",
     "is_missing",

haiway/types/default.py

@@ -0,0 +1,108 @@
+from collections.abc import Callable
+from typing import Any, cast, final, overload
+
+from haiway.types.missing import MISSING, Missing, not_missing
+from haiway.utils.always import always
+
+__all__ = [
+    "Default",
+    "DefaultValue",
+]
+
+
+@final
+class DefaultValue[Value]:
+    @overload
+    def __init__(
+        self,
+        value: Value,
+        /,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        /,
+        *,
+        factory: Callable[[], Value],
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        value: Value | Missing,
+        /,
+        *,
+        factory: Callable[[], Value] | Missing,
+    ) -> None: ...
+
+    def __init__(
+        self,
+        value: Value | Missing = MISSING,
+        /,
+        *,
+        factory: Callable[[], Value] | Missing = MISSING,
+    ) -> None:
+        assert (  # nosec: B101
+            value is MISSING or factory is MISSING
+        ), "Can't specify both default value and factory"
+
+        self._value: Callable[[], Value | Missing]
+        if not_missing(factory):
+            object.__setattr__(
+                self,
+                "_value",
+                factory,
+            )
+
+        else:
+            object.__setattr__(
+                self,
+                "_value",
+                always(value),
+            )
+
+    def __call__(self) -> Value | Missing:
+        return self._value()
+
+    def __setattr__(
+        self,
+        __name: str,
+        __value: Any,
+    ) -> None:
+        raise AttributeError("Missing can't be modified")
+
+    def __delattr__(
+        self,
+        __name: str,
+    ) -> None:
+        raise AttributeError("Missing can't be modified")
+
+
+@overload
+def Default[Value](
+    value: Value,
+    /,
+) -> Value: ...
+
+
+@overload
+def Default[Value](
+    *,
+    factory: Callable[[], Value],
+) -> Value: ...
+
+
+def Default[Value](
+    value: Value | Missing = MISSING,
+    /,
+    *,
+    factory: Callable[[], Value] | Missing = MISSING,
+) -> Value:  # it is actually a DefaultValue, but type checker has to be fooled most some cases
+    return cast(
+        Value,
+        DefaultValue(
+            value,
+            factory=factory,
+        ),
+    )

haiway/types/missing.py

@@ -85,6 +85,7 @@ def not_missing[Value](
 def when_missing[Value](
     check: Value | Missing,
     /,
+    *,
     value: Value,
 ) -> Value:
     if check is MISSING:

haiway/utils/__init__.py

@@ -1,18 +1,18 @@
 from haiway.utils.always import always, async_always
+from haiway.utils.collections import as_dict, as_list, as_set, as_tuple
 from haiway.utils.env import getenv_bool, getenv_float, getenv_int, getenv_str, load_env
-from haiway.utils.immutable import freeze
+from haiway.utils.freezing import freeze
 from haiway.utils.logs import setup_logging
-from haiway.utils.mappings import as_dict
 from haiway.utils.mimic import mimic_function
 from haiway.utils.noop import async_noop, noop
 from haiway.utils.queue import AsyncQueue
-from haiway.utils.sequences import as_list, as_tuple
 
 __all__ = [
     "AsyncQueue",
     "always",
     "as_dict",
     "as_list",
+    "as_set",
     "as_tuple",
     "async_always",
     "async_noop",

haiway/utils/collections.py

@@ -0,0 +1,108 @@
+from collections.abc import Mapping, Sequence, Set
+
+__all__ = [
+    "as_dict",
+    "as_list",
+    "as_set",
+    "as_tuple",
+]
+
+
+def as_list[T](
+    collection: Sequence[T],
+    /,
+) -> list[T]:
+    """
+    Converts any given Sequence into a list.
+
+    Parameters
+    ----------
+    collection : Sequence[T]
+        The input collection to be converted.
+
+    Returns
+    -------
+    list[T]
+        A new list containing all elements of the input collection,
+        or the original list if it was already one.
+    """
+    if isinstance(collection, list):
+        return collection
+
+    else:
+        return list(collection)
+
+
+def as_tuple[T](
+    collection: Sequence[T],
+    /,
+) -> tuple[T, ...]:
+    """
+    Converts any given Sequence into a tuple.
+
+    Parameters
+    ----------
+    collection : Sequence[T]
+        The input collection to be converted.
+
+    Returns
+    -------
+    tuple[T]
+        A new tuple containing all elements of the input collection,
+        or the original tuple if it was already one.
+    """
+    if isinstance(collection, tuple):
+        return collection
+
+    else:
+        return tuple(collection)
+
+
+def as_set[T](
+    collection: Set[T],
+    /,
+) -> set[T]:
+    """
+    Converts any given Set into a set.
+
+    Parameters
+    ----------
+    collection : Set[T]
+        The input collection to be converted.
+
+    Returns
+    -------
+    set[T]
+        A new set containing all elements of the input collection,
+        or the original set if it was already one.
+    """
+    if isinstance(collection, set):
+        return collection
+
+    else:
+        return set(collection)
+
+
+def as_dict[K, V](
+    collection: Mapping[K, V],
+    /,
+) -> dict[K, V]:
+    """
+    Converts any given Mapping into a dict.
+
+    Parameters
+    ----------
+    collection : Mapping[K, V]
+        The input collection to be converted.
+
+    Returns
+    -------
+    dict[K, V]
+        A new dict containing all elements of the input collection,
+        or the original dict if it was already one.
+    """
+    if isinstance(collection, dict):
+        return collection
+
+    else:
+        return dict(collection)

{haiway-0.9.1.dist-info → haiway-0.10.1.dist-info}/METADATA

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

@@ -1,4 +1,4 @@
-haiway/__init__.py,sha256=JoXmo8maenl0yVsE1CetmJjP80v0ifU2_5dJdzuzadg,1837
+haiway/__init__.py,sha256=IEUCyFYKT5IPHnkiUvDVZHdJeHqCaBnG8FhPD20Zgo8,1929
 haiway/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 haiway/context/__init__.py,sha256=eRvuhifx7xCd-_6desgk55idzNpD5S5sprmCfGb3_9M,662
 haiway/context/access.py,sha256=RpTvs7107NoAxCgxxbp7BUThOM9gLXo_Vxv-JgDqW58,16954
@@ -18,26 +18,26 @@ haiway/helpers/throttling.py,sha256=zo0OwFq64si5KUwhd58cFHLmGAmYwRbFRJMbv9suhPs,
 haiway/helpers/timeouted.py,sha256=1xU09hQnFdj6p48BwZl5xUvtIr3zC0ZUXehkdrduCjs,3074
 haiway/helpers/tracing.py,sha256=eQpkIoGSB51jRF8RcLaihvHX3VzJIRdyRxTx3I14Pzg,3346
 haiway/state/__init__.py,sha256=emTuwGFn7HyjyTJ_ass69J5jQIA7_WHO4teZz_dR05Y,355
-haiway/state/attributes.py,sha256=iQ7TJHnT3hlcYwKcxchXE56zU8WbOTJZhsVn_HocXBc,22903
+haiway/state/attributes.py,sha256=0gJbgOKiH79RNM9IW66NNWSWM29037yGTTpoln6vPvU,22984
 haiway/state/path.py,sha256=4vh-fYQv8_xRWjS0ErMQslKDWRI6-KVECAr8JhYk0UY,17503
 haiway/state/requirement.py,sha256=3iQqzp5Q7w6y5uClamJGH7S5Hib9pciuTAV27PP5lS8,6161
-haiway/state/structure.py,sha256=N8lh_yKyROm5GG1NjIxmidYttWZkYH0S3fhEpNIx5FY,11694
-haiway/state/validation.py,sha256=hbvzPVBD36AD_B5u9ER4A11vjaXR9LJLD8G2k8IE-AI,13492
-haiway/types/__init__.py,sha256=00Ulp2BxcIWm9vWXKQPodpFEwE8hpqj6OYgrNxelp5s,252
+haiway/state/structure.py,sha256=bSIj0S_HG-F1Z5GxSlY6VpGtrtiwG82-AIL_PL1lRLo,12465
+haiway/state/validation.py,sha256=r0EMIs-nvoXsmSA74oGu6Lrbw8lkzmseaY82_-E8ous,13814
+haiway/types/__init__.py,sha256=-j4uDN6ix3GBXLBqXC-k_QOJSDlO6zvNCxDej8vVzek,342
+haiway/types/default.py,sha256=IVQsNzDnfukL3-XlScYv2PgTcJ1x_BNP9i5UlS5oEbg,2179
 haiway/types/frozen.py,sha256=CZhFCXnWAKEhuWSfILxA8smfdpMd5Ku694ycfLh98R8,76
-haiway/types/missing.py,sha256=JiXo5xdi7H-PbIJr0fuK5wpOuQZhjrDYUkMlfIFcsaE,1705
-haiway/utils/__init__.py,sha256=pBeKpaPNfEHeKe8tT81JV-zADS1Qj32WnYcFP9ThtKk,749
+haiway/types/missing.py,sha256=rDnyA2wxPkTbJl0L-zbo0owp7IJ04xkCIp6xD6wh8NI,1712
+haiway/utils/__init__.py,sha256=O7qmAmUktX-X_5D1L5FJMeCFEiOVrrnyYSyiycm4nyg,739
 haiway/utils/always.py,sha256=2abp8Lm9rQkrfS3rm1Iqhb-IcWyVfH1BULab3KMxgOw,1234
+haiway/utils/collections.py,sha256=_MwB4o8sCZeAjrwry8Pu9JvGlt8m7O7MqWSFFmPjJ6k,2120
 haiway/utils/env.py,sha256=vlW21LEp8uOVNnUXpBfPtj3zKi9Kkjoemb_H5hQpYPQ,4433
-haiway/utils/immutable.py,sha256=K34ZIMzbkpgkHKH-KF73plEbXExsajNRkRTYp9nJEf4,620
+haiway/utils/freezing.py,sha256=K34ZIMzbkpgkHKH-KF73plEbXExsajNRkRTYp9nJEf4,620
 haiway/utils/logs.py,sha256=oDsc1ZdqKDjlTlctLbDcp9iX98Acr-1tdw-Pyg3DElo,1577
-haiway/utils/mappings.py,sha256=XxELxCpGEPfRERO54ySIbcV7t4Sxcb7NuQmyayU5GoY,555
 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.9.1.dist-info/LICENSE,sha256=GehQEW_I1pkmxkkj3NEa7rCTQKYBn7vTPabpDYJlRuo,1063
-haiway-0.9.1.dist-info/METADATA,sha256=V8r02s5eNu41YHlynIq3wUTpXRCVSYBoOSNusk1ckU8,3894
-haiway-0.9.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-haiway-0.9.1.dist-info/top_level.txt,sha256=_LdXVLzUzgkvAGQnQJj5kQfoFhpPW6EF4Kj9NapniLg,7
-haiway-0.9.1.dist-info/RECORD,,
+haiway-0.10.1.dist-info/LICENSE,sha256=GehQEW_I1pkmxkkj3NEa7rCTQKYBn7vTPabpDYJlRuo,1063
+haiway-0.10.1.dist-info/METADATA,sha256=0m2_QdvBq_XiPN3GiIYFIE0cXf8cVw5esT8kA6_K_5Y,3895
+haiway-0.10.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+haiway-0.10.1.dist-info/top_level.txt,sha256=_LdXVLzUzgkvAGQnQJj5kQfoFhpPW6EF4Kj9NapniLg,7
+haiway-0.10.1.dist-info/RECORD,,

haiway/utils/mappings.py

@@ -1,30 +0,0 @@
-from collections.abc import Mapping
-
-__all__ = [
-    "as_dict",
-]
-
-
-def as_dict[K, V](
-    mapping: Mapping[K, V],
-    /,
-) -> dict[K, V]:
-    """
-    Converts any given mapping into a dict.
-
-    Parameters
-    ----------
-    mapping : Mapping[K, V]
-        The input mapping to be converted.
-
-    Returns
-    -------
-    dict[K, V]
-        A new dict containing all elements of the input mapping,
-        or the original dict if it was already one.
-    """
-    if isinstance(mapping, dict):
-        return mapping
-
-    else:
-        return dict(mapping)

haiway/utils/sequences.py

@@ -1,56 +0,0 @@
-from collections.abc import Sequence
-
-__all__ = [
-    "as_list",
-    "as_tuple",
-]
-
-
-def as_list[T](
-    sequence: Sequence[T],
-    /,
-) -> list[T]:
-    """
-    Converts any given sequence into a list.
-
-    Parameters
-    ----------
-    sequence : Sequence[T]
-        The input sequence to be converted.
-
-    Returns
-    -------
-    list[T]
-        A new list containing all elements of the input sequence,
-        or the original list if it was already one.
-    """
-    if isinstance(sequence, list):
-        return sequence
-
-    else:
-        return list(sequence)
-
-
-def as_tuple[T](
-    sequence: Sequence[T],
-    /,
-) -> tuple[T, ...]:
-    """
-    Converts any given sequence into a tuple.
-
-    Parameters
-    ----------
-    sequence : Sequence[T]
-        The input sequence to be converted.
-
-    Returns
-    -------
-    tuple[T]
-        A new tuple containing all elements of the input sequence,
-        or the original tuple if it was already one.
-    """
-    if isinstance(sequence, tuple):
-        return sequence
-
-    else:
-        return tuple(sequence)