jaclang 0.7.34__py3-none-any.whl → 0.8.0__py3-none-any.whl

jaclang/vendor/cattrs/preconf/msgspec.py

@@ -0,0 +1,185 @@
+"""Preconfigured converters for msgspec."""
+
+from __future__ import annotations
+
+from base64 import b64decode
+from datetime import date, datetime
+from enum import Enum
+from functools import partial
+from typing import Any, Callable, TypeVar, Union, get_type_hints
+
+from attrs import has as attrs_has
+from attrs import resolve_types
+from msgspec import Struct, convert, to_builtins
+from msgspec.json import Encoder, decode
+
+from .._compat import (
+    fields,
+    get_args,
+    get_origin,
+    has,
+    is_bare,
+    is_mapping,
+    is_sequence,
+)
+from ..cols import is_namedtuple
+from ..converters import BaseConverter, Converter
+from ..dispatch import UnstructureHook
+from ..fns import identity
+from ..gen import make_hetero_tuple_unstructure_fn
+from ..strategies import configure_union_passthrough
+from . import wrap
+
+T = TypeVar("T")
+
+__all__ = ["MsgspecJsonConverter", "configure_converter", "make_converter"]
+
+
+class MsgspecJsonConverter(Converter):
+    """A converter specialized for the _msgspec_ library."""
+
+    #: The msgspec encoder for dumping.
+    encoder: Encoder = Encoder()
+
+    def dumps(self, obj: Any, unstructure_as: Any = None, **kwargs: Any) -> bytes:
+        """Unstructure and encode `obj` into JSON bytes."""
+        return self.encoder.encode(
+            self.unstructure(obj, unstructure_as=unstructure_as), **kwargs
+        )
+
+    def get_dumps_hook(
+        self, unstructure_as: Any, **kwargs: Any
+    ) -> Callable[[Any], bytes]:
+        """Produce a `dumps` hook for the given type."""
+        unstruct_hook = self.get_unstructure_hook(unstructure_as)
+        if unstruct_hook in (identity, to_builtins):
+            return self.encoder.encode
+        return self.dumps
+
+    def loads(self, data: bytes, cl: type[T], **kwargs: Any) -> T:
+        """Decode and structure `cl` from the provided JSON bytes."""
+        return self.structure(decode(data, **kwargs), cl)
+
+    def get_loads_hook(self, cl: type[T]) -> Callable[[bytes], T]:
+        """Produce a `loads` hook for the given type."""
+        return partial(self.loads, cl=cl)
+
+
+def configure_converter(converter: Converter) -> None:
+    """Configure the converter for the msgspec library.
+
+    * bytes are serialized as base64 strings, directly by msgspec
+    * datetimes and dates are passed through to be serialized as RFC 3339 directly
+    * enums are passed through to msgspec directly
+    * union passthrough configured for str, bool, int, float and None
+    """
+    configure_passthroughs(converter)
+
+    converter.register_unstructure_hook(Struct, to_builtins)
+    converter.register_unstructure_hook(Enum, to_builtins)
+
+    converter.register_structure_hook(Struct, convert)
+    converter.register_structure_hook(bytes, lambda v, _: b64decode(v))
+    converter.register_structure_hook(datetime, lambda v, _: convert(v, datetime))
+    converter.register_structure_hook(date, lambda v, _: date.fromisoformat(v))
+    configure_union_passthrough(Union[str, bool, int, float, None], converter)
+
+
+@wrap(MsgspecJsonConverter)
+def make_converter(*args: Any, **kwargs: Any) -> MsgspecJsonConverter:
+    res = MsgspecJsonConverter(*args, **kwargs)
+    configure_converter(res)
+    return res
+
+
+def configure_passthroughs(converter: Converter) -> None:
+    """Configure optimizing passthroughs.
+
+    A passthrough is when we let msgspec handle something automatically.
+    """
+    converter.register_unstructure_hook(bytes, to_builtins)
+    converter.register_unstructure_hook_factory(is_mapping, mapping_unstructure_factory)
+    converter.register_unstructure_hook_factory(is_sequence, seq_unstructure_factory)
+    converter.register_unstructure_hook_factory(has, attrs_unstructure_factory)
+    converter.register_unstructure_hook_factory(
+        is_namedtuple, namedtuple_unstructure_factory
+    )
+
+
+def seq_unstructure_factory(type, converter: Converter) -> UnstructureHook:
+    """The msgspec unstructure hook factory for sequences."""
+    if is_bare(type):
+        type_arg = Any
+    else:
+        args = get_args(type)
+        type_arg = args[0]
+    handler = converter.get_unstructure_hook(type_arg, cache_result=False)
+
+    if handler in (identity, to_builtins):
+        return handler
+    return converter.gen_unstructure_iterable(type)
+
+
+def mapping_unstructure_factory(type, converter: BaseConverter) -> UnstructureHook:
+    """The msgspec unstructure hook factory for mappings."""
+    if is_bare(type):
+        key_arg = Any
+        val_arg = Any
+        key_handler = converter.get_unstructure_hook(key_arg, cache_result=False)
+        value_handler = converter.get_unstructure_hook(val_arg, cache_result=False)
+    else:
+        args = get_args(type)
+        if len(args) == 2:
+            key_arg, val_arg = args
+        else:
+            # Probably a Counter
+            key_arg, val_arg = args, Any
+        key_handler = converter.get_unstructure_hook(key_arg, cache_result=False)
+        value_handler = converter.get_unstructure_hook(val_arg, cache_result=False)
+
+    if key_handler in (identity, to_builtins) and value_handler in (
+        identity,
+        to_builtins,
+    ):
+        return to_builtins
+    return converter.gen_unstructure_mapping(type)
+
+
+def attrs_unstructure_factory(type: Any, converter: Converter) -> UnstructureHook:
+    """Choose whether to use msgspec handling or our own."""
+    origin = get_origin(type)
+    attribs = fields(origin or type)
+    if attrs_has(type) and any(isinstance(a.type, str) for a in attribs):
+        resolve_types(type)
+        attribs = fields(origin or type)
+
+    if any(
+        attr.name.startswith("_")
+        or (
+            converter.get_unstructure_hook(attr.type, cache_result=False)
+            not in (identity, to_builtins)
+        )
+        for attr in attribs
+    ):
+        return converter.gen_unstructure_attrs_fromdict(type)
+
+    return to_builtins
+
+
+def namedtuple_unstructure_factory(
+    type: type[tuple], converter: BaseConverter
+) -> UnstructureHook:
+    """A hook factory for unstructuring namedtuples, modified for msgspec."""
+
+    if all(
+        converter.get_unstructure_hook(t) in (identity, to_builtins)
+        for t in get_type_hints(type).values()
+    ):
+        return identity
+
+    return make_hetero_tuple_unstructure_fn(
+        type,
+        converter,
+        unstructure_to=tuple,
+        type_args=tuple(get_type_hints(type).values()),
+    )

jaclang/vendor/cattrs/preconf/orjson.py

@@ -1,16 +1,19 @@
 """Preconfigured converters for orjson."""
+
 from base64 import b85decode, b85encode
 from datetime import date, datetime
 from enum import Enum
+from functools import partial
 from typing import Any, Type, TypeVar, Union
 
 from orjson import dumps, loads
 
-from cattrs._compat import AbstractSet, is_mapping
-
+from .._compat import AbstractSet, is_mapping
+from ..cols import is_namedtuple, namedtuple_unstructure_factory
 from ..converters import BaseConverter, Converter
 from ..fns import identity
 from ..strategies import configure_union_passthrough
+from . import wrap
 
 T = TypeVar("T")
 
@@ -28,19 +31,21 @@ def configure_converter(converter: BaseConverter):
     Configure the converter for use with the orjson library.
 
     * bytes are serialized as base85 strings
-    * datetimes are serialized as ISO 8601
+    * datetimes and dates are passed through to be serialized as RFC 3339 by orjson
+    * typed namedtuples are serialized as lists
     * sets are serialized as lists
     * string enum mapping keys have special handling
     * mapping keys are coerced into strings when unstructuring
+
+    .. versionchanged: 24.1.0
+        Add support for typed namedtuples.
     """
     converter.register_unstructure_hook(
         bytes, lambda v: (b85encode(v) if v else b"").decode("utf8")
     )
     converter.register_structure_hook(bytes, lambda v, _: b85decode(v))
 
-    converter.register_unstructure_hook(datetime, lambda v: v.isoformat())
     converter.register_structure_hook(datetime, lambda v, _: datetime.fromisoformat(v))
-    converter.register_unstructure_hook(date, lambda v: v.isoformat())
     converter.register_structure_hook(date, lambda v, _: date.fromisoformat(v))
 
     def gen_unstructure_mapping(cl: Any, unstructure_to=None):
@@ -57,7 +62,7 @@ def configure_converter(converter: BaseConverter):
                 # (For example base85 encoding for bytes.)
                 # In that case, we want to use the override.
 
-                kh = converter._unstructure_func.dispatch(args[0])
+                kh = converter.get_unstructure_hook(args[0])
                 if kh != identity:
                     key_handler = kh
 
@@ -66,11 +71,19 @@ def configure_converter(converter: BaseConverter):
         )
 
     converter._unstructure_func.register_func_list(
-        [(is_mapping, gen_unstructure_mapping, True)]
+        [
+            (is_mapping, gen_unstructure_mapping, True),
+            (
+                is_namedtuple,
+                partial(namedtuple_unstructure_factory, unstructure_to=tuple),
+                "extended",
+            ),
+        ]
     )
     configure_union_passthrough(Union[str, bool, int, float, None], converter)
 
 
+@wrap(OrjsonConverter)
 def make_converter(*args: Any, **kwargs: Any) -> OrjsonConverter:
     kwargs["unstruct_collection_overrides"] = {
         AbstractSet: list,

jaclang/vendor/cattrs/preconf/pyyaml.py

@@ -1,14 +1,16 @@
 """Preconfigured converters for pyyaml."""
+
 from datetime import date, datetime
+from functools import partial
 from typing import Any, Type, TypeVar, Union
 
 from yaml import safe_dump, safe_load
 
-from cattrs._compat import FrozenSetSubscriptable
-
+from .._compat import FrozenSetSubscriptable
+from ..cols import is_namedtuple, namedtuple_unstructure_factory
 from ..converters import BaseConverter, Converter
 from ..strategies import configure_union_passthrough
-from . import validate_datetime
+from . import validate_datetime, wrap
 
 T = TypeVar("T")
 
@@ -34,6 +36,10 @@ def configure_converter(converter: BaseConverter):
     * frozensets are serialized as lists
     * string enums are converted into strings explicitly
     * datetimes and dates are validated
+    * typed namedtuples are serialized as lists
+
+    .. versionchanged: 24.1.0
+        Add support for typed namedtuples.
     """
     converter.register_unstructure_hook(
         str, lambda v: v if v.__class__ is str else v.value
@@ -44,11 +50,17 @@ def configure_converter(converter: BaseConverter):
     converter.register_unstructure_hook(datetime, lambda v: v)
     converter.register_structure_hook(datetime, validate_datetime)
     converter.register_structure_hook(date, validate_date)
+
+    converter.register_unstructure_hook_factory(is_namedtuple)(
+        partial(namedtuple_unstructure_factory, unstructure_to=tuple)
+    )
+
     configure_union_passthrough(
         Union[str, bool, int, float, None, bytes, datetime, date], converter
     )
 
 
+@wrap(PyyamlConverter)
 def make_converter(*args: Any, **kwargs: Any) -> PyyamlConverter:
     kwargs["unstruct_collection_overrides"] = {
         FrozenSetSubscriptable: list,

jaclang/vendor/cattrs/preconf/tomlkit.py

@@ -1,4 +1,5 @@
 """Preconfigured converters for tomlkit."""
+
 from base64 import b85decode, b85encode
 from datetime import date, datetime
 from enum import Enum
@@ -12,7 +13,7 @@ from cattrs._compat import AbstractSet, is_mapping
 
 from ..converters import BaseConverter, Converter
 from ..strategies import configure_union_passthrough
-from . import validate_datetime
+from . import validate_datetime, wrap
 
 T = TypeVar("T")
 _enum_value_getter = attrgetter("_value_")
@@ -73,6 +74,7 @@ def configure_converter(converter: BaseConverter):
     )
 
 
+@wrap(TomlkitConverter)
 def make_converter(*args: Any, **kwargs: Any) -> TomlkitConverter:
     kwargs["unstruct_collection_overrides"] = {
         AbstractSet: list,

jaclang/vendor/cattrs/preconf/ujson.py

@@ -1,4 +1,5 @@
 """Preconfigured converters for ujson."""
+
 from base64 import b85decode, b85encode
 from datetime import date, datetime
 from typing import Any, AnyStr, Type, TypeVar, Union
@@ -9,6 +10,7 @@ from cattrs._compat import AbstractSet
 
 from ..converters import BaseConverter, Converter
 from ..strategies import configure_union_passthrough
+from . import wrap
 
 T = TypeVar("T")
 
@@ -41,6 +43,7 @@ def configure_converter(converter: BaseConverter):
     configure_union_passthrough(Union[str, bool, int, float, None], converter)
 
 
+@wrap(UjsonConverter)
 def make_converter(*args: Any, **kwargs: Any) -> UjsonConverter:
     kwargs["unstruct_collection_overrides"] = {
         AbstractSet: list,

jaclang/vendor/cattrs/strategies/__init__.py

@@ -1,4 +1,5 @@
 """High level strategies for converters."""
+
 from ._class_methods import use_class_methods
 from ._subclasses import include_subclasses
 from ._unions import configure_tagged_union, configure_union_passthrough

jaclang/vendor/cattrs/strategies/_class_methods.py

@@ -3,7 +3,7 @@
 from inspect import signature
 from typing import Any, Callable, Optional, Type, TypeVar
 
-from cattrs import BaseConverter
+from .. import BaseConverter
 
 T = TypeVar("T")
 

jaclang/vendor/cattrs/strategies/_subclasses.py

@@ -1,37 +1,43 @@
 """Strategies for customizing subclass behaviors."""
+
+from __future__ import annotations
+
 from gc import collect
-from typing import Any, Callable, Dict, List, Optional, Tuple, Type, Union
+from typing import Any, Callable, TypeVar, Union
 
-from ..converters import BaseConverter, Converter
+from ..converters import BaseConverter
 from ..gen import AttributeOverride, make_dict_structure_fn, make_dict_unstructure_fn
 from ..gen._consts import already_generating
 
 
-def _make_subclasses_tree(cl: Type) -> List[Type]:
+def _make_subclasses_tree(cl: type) -> list[type]:
     return [cl] + [
         sscl for scl in cl.__subclasses__() for sscl in _make_subclasses_tree(scl)
     ]
 
 
-def _has_subclasses(cl: Type, given_subclasses: Tuple[Type, ...]) -> bool:
+def _has_subclasses(cl: type, given_subclasses: tuple[type, ...]) -> bool:
     """Whether the given class has subclasses from `given_subclasses`."""
     actual = set(cl.__subclasses__())
     given = set(given_subclasses)
     return bool(actual & given)
 
 
-def _get_union_type(cl: Type, given_subclasses_tree: Tuple[Type]) -> Optional[Type]:
+def _get_union_type(cl: type, given_subclasses_tree: tuple[type]) -> type | None:
     actual_subclass_tree = tuple(_make_subclasses_tree(cl))
     class_tree = tuple(set(actual_subclass_tree) & set(given_subclasses_tree))
     return Union[class_tree] if len(class_tree) >= 2 else None
 
 
+C = TypeVar("C", bound=BaseConverter)
+
+
 def include_subclasses(
-    cl: Type,
-    converter: Converter,
-    subclasses: Optional[Tuple[Type, ...]] = None,
-    union_strategy: Optional[Callable[[Any, BaseConverter], Any]] = None,
-    overrides: Optional[Dict[str, AttributeOverride]] = None,
+    cl: type,
+    converter: C,
+    subclasses: tuple[type, ...] | None = None,
+    union_strategy: Callable[[Any, C], Any] | None = None,
+    overrides: dict[str, AttributeOverride] | None = None,
 ) -> None:
     """
     Configure the converter so that the attrs/dataclass `cl` is un/structured as if it
@@ -54,6 +60,9 @@ def include_subclasses(
         :func:`cattrs.gen.override`) to customize un/structuring.
 
     .. versionadded:: 23.1.0
+    .. versionchanged:: 24.1.0
+       When overrides are not provided, hooks for individual classes are retrieved from
+       the converter instead of generated with no overrides, using converter defaults.
     """
     # Due to https://github.com/python-attrs/attrs/issues/1047
     collect()
@@ -62,9 +71,6 @@ def include_subclasses(
     else:
         parent_subclass_tree = tuple(_make_subclasses_tree(cl))
 
-    if overrides is None:
-        overrides = {}
-
     if union_strategy is None:
         _include_subclasses_without_union_strategy(
             cl, converter, parent_subclass_tree, overrides
@@ -77,9 +83,9 @@ def include_subclasses(
 
 def _include_subclasses_without_union_strategy(
     cl,
-    converter: Converter,
-    parent_subclass_tree: Tuple[Type],
-    overrides: Dict[str, AttributeOverride],
+    converter: BaseConverter,
+    parent_subclass_tree: tuple[type],
+    overrides: dict[str, AttributeOverride] | None,
 ):
     # The iteration approach is required if subclasses are more than one level deep:
     for cl in parent_subclass_tree:
@@ -95,8 +101,12 @@ def _include_subclasses_without_union_strategy(
         def cls_is_cl(cls, _cl=cl):
             return cls is _cl
 
-        base_struct_hook = make_dict_structure_fn(cl, converter, **overrides)
-        base_unstruct_hook = make_dict_unstructure_fn(cl, converter, **overrides)
+        if overrides is not None:
+            base_struct_hook = make_dict_structure_fn(cl, converter, **overrides)
+            base_unstruct_hook = make_dict_unstructure_fn(cl, converter, **overrides)
+        else:
+            base_struct_hook = converter.get_structure_hook(cl)
+            base_unstruct_hook = converter.get_unstructure_hook(cl)
 
         if subclass_union is None:
 
@@ -104,7 +114,7 @@ def _include_subclasses_without_union_strategy(
                 return _base_hook(val, _cl)
 
         else:
-            dis_fn = converter._get_dis_func(subclass_union)
+            dis_fn = converter._get_dis_func(subclass_union, overrides=overrides)
 
             def struct_hook(
                 val: dict,
@@ -130,7 +140,7 @@ def _include_subclasses_without_union_strategy(
             _c=converter,
             _cl=cl,
             _base_hook=base_unstruct_hook,
-        ) -> Dict:
+        ) -> dict:
             """
             If val is an instance of the class `cl`, use the hook.
 
@@ -147,10 +157,10 @@ def _include_subclasses_without_union_strategy(
 
 
 def _include_subclasses_with_union_strategy(
-    converter: Converter,
-    union_classes: Tuple[Type, ...],
-    union_strategy: Callable[[Any, BaseConverter], Any],
-    overrides: Dict[str, AttributeOverride],
+    converter: C,
+    union_classes: tuple[type, ...],
+    union_strategy: Callable[[Any, C], Any],
+    overrides: dict[str, AttributeOverride] | None,
 ):
     """
     This function is tricky because we're dealing with what is essentially a circular
@@ -176,8 +186,12 @@ def _include_subclasses_with_union_strategy(
         # manipulate the _already_generating set to force runtime dispatch.
         already_generating.working_set = set(union_classes) - {cl}
         try:
-            unstruct_hook = make_dict_unstructure_fn(cl, converter, **overrides)
-            struct_hook = make_dict_structure_fn(cl, converter, **overrides)
+            if overrides is not None:
+                unstruct_hook = make_dict_unstructure_fn(cl, converter, **overrides)
+                struct_hook = make_dict_structure_fn(cl, converter, **overrides)
+            else:
+                unstruct_hook = converter.get_unstructure_hook(cl, cache_result=False)
+                struct_hook = converter.get_structure_hook(cl, cache_result=False)
         finally:
             already_generating.working_set = set()
         original_unstruct_hooks[cl] = unstruct_hook
@@ -202,8 +216,8 @@ def _include_subclasses_with_union_strategy(
         converter.register_structure_hook_func(cls_is_cl, hook)
 
     union_strategy(final_union, converter)
-    unstruct_hook = converter._unstructure_func.dispatch(final_union)
-    struct_hook = converter._structure_func.dispatch(final_union)
+    unstruct_hook = converter.get_unstructure_hook(final_union)
+    struct_hook = converter.get_structure_hook(final_union)
 
     for cl in union_classes:
         # In the second pass, we overwrite the hooks with the union hook.
@@ -216,7 +230,7 @@ def _include_subclasses_with_union_strategy(
         if len(subclasses) > 1:
             u = Union[subclasses]  # type: ignore
             union_strategy(u, converter)
-            struct_hook = converter._structure_func.dispatch(u)
+            struct_hook = converter.get_structure_hook(u)
 
             def sh(payload: dict, _, _u=u, _s=struct_hook) -> cl:
                 return _s(payload, _u)

jaclang/vendor/cattrs/strategies/_unions.py

@@ -1,9 +1,9 @@
 from collections import defaultdict
-from typing import Any, Callable, Dict, Optional, Type, Union
+from typing import Any, Callable, Dict, Literal, Type, Union
 
 from attrs import NOTHING
 
-from cattrs import BaseConverter, Converter
+from cattrs import BaseConverter
 from cattrs._compat import get_newtype_base, is_literal, is_subclass, is_union_type
 
 __all__ = [
@@ -20,10 +20,10 @@ def default_tag_generator(typ: Type) -> str:
 
 def configure_tagged_union(
     union: Any,
-    converter: Converter,
+    converter: BaseConverter,
     tag_generator: Callable[[Type], str] = default_tag_generator,
     tag_name: str = "_type",
-    default: Optional[Type] = NOTHING,
+    default: Union[Type, Literal[NOTHING]] = NOTHING,
 ) -> None:
     """
     Configure the converter so that `union` (which should be a union) is
@@ -50,8 +50,8 @@ def configure_tagged_union(
     exact_cl_unstruct_hooks = {}
     for cl in args:
         tag = tag_generator(cl)
-        struct_handler = converter._structure_func.dispatch(cl)
-        unstruct_handler = converter._unstructure_func.dispatch(cl)
+        struct_handler = converter.get_structure_hook(cl)
+        unstruct_handler = converter.get_unstructure_hook(cl)
 
         def structure_union_member(val: dict, _cl=cl, _h=struct_handler) -> cl:
             return _h(val, _cl)
@@ -65,7 +65,7 @@ def configure_tagged_union(
     cl_to_tag = {cl: tag_generator(cl) for cl in args}
 
     if default is not NOTHING:
-        default_handler = converter._structure_func.dispatch(default)
+        default_handler = converter.get_structure_hook(default)
 
         def structure_default(val: dict, _cl=default, _h=default_handler):
             return _h(val, _cl)
@@ -84,27 +84,50 @@ def configure_tagged_union(
         return res
 
     if default is NOTHING:
+        if getattr(converter, "forbid_extra_keys", False):
 
-        def structure_tagged_union(
-            val: dict, _, _tag_to_cl=tag_to_hook, _tag_name=tag_name
-        ) -> union:
-            val = val.copy()
-            return _tag_to_cl[val.pop(_tag_name)](val)
+            def structure_tagged_union(
+                val: dict, _, _tag_to_cl=tag_to_hook, _tag_name=tag_name
+            ) -> union:
+                val = val.copy()
+                return _tag_to_cl[val.pop(_tag_name)](val)
+
+        else:
+
+            def structure_tagged_union(
+                val: dict, _, _tag_to_cl=tag_to_hook, _tag_name=tag_name
+            ) -> union:
+                return _tag_to_cl[val[_tag_name]](val)
 
     else:
+        if getattr(converter, "forbid_extra_keys", False):
+
+            def structure_tagged_union(
+                val: dict,
+                _,
+                _tag_to_hook=tag_to_hook,
+                _tag_name=tag_name,
+                _dh=default_handler,
+                _default=default,
+            ) -> union:
+                if _tag_name in val:
+                    val = val.copy()
+                    return _tag_to_hook[val.pop(_tag_name)](val)
+                return _dh(val, _default)
 
-        def structure_tagged_union(
-            val: dict,
-            _,
-            _tag_to_hook=tag_to_hook,
-            _tag_name=tag_name,
-            _dh=default_handler,
-            _default=default,
-        ) -> union:
-            if _tag_name in val:
-                val = val.copy()
-                return _tag_to_hook[val.pop(_tag_name)](val)
-            return _dh(val, _default)
+        else:
+
+            def structure_tagged_union(
+                val: dict,
+                _,
+                _tag_to_hook=tag_to_hook,
+                _tag_name=tag_name,
+                _dh=default_handler,
+                _default=default,
+            ) -> union:
+                if _tag_name in val:
+                    return _tag_to_hook[val[_tag_name]](val)
+                return _dh(val, _default)
 
     converter.register_unstructure_hook(union, unstructure_tagged_union)
     converter.register_structure_hook(union, structure_tagged_union)

jaclang/vendor/cattrs/v.py

@@ -1,4 +1,5 @@
 """Cattrs validation."""
+
 from typing import Callable, List, Union
 
 from .errors import (

jaclang/vendor/cattrs-24.1.3.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip