jaclang 0.6.1__py3-none-any.whl → 0.7.0__py3-none-any.whl

jaclang/vendor/cattrs/preconf/bson.py

@@ -0,0 +1,107 @@
+"""Preconfigured converters for bson."""
+from base64 import b85decode, b85encode
+from datetime import date, datetime
+from typing import Any, Type, TypeVar, Union
+
+from bson import DEFAULT_CODEC_OPTIONS, CodecOptions, Int64, ObjectId, decode, encode
+
+from cattrs._compat import AbstractSet, is_mapping
+from cattrs.gen import make_mapping_structure_fn
+
+from ..converters import BaseConverter, Converter
+from ..strategies import configure_union_passthrough
+from . import validate_datetime
+
+T = TypeVar("T")
+
+
+class Base85Bytes(bytes):
+    """A subclass to help with binary key encoding/decoding."""
+
+
+class BsonConverter(Converter):
+    def dumps(
+        self,
+        obj: Any,
+        unstructure_as: Any = None,
+        check_keys: bool = False,
+        codec_options: CodecOptions = DEFAULT_CODEC_OPTIONS,
+    ) -> bytes:
+        return encode(
+            self.unstructure(obj, unstructure_as=unstructure_as),
+            check_keys=check_keys,
+            codec_options=codec_options,
+        )
+
+    def loads(
+        self,
+        data: bytes,
+        cl: Type[T],
+        codec_options: CodecOptions = DEFAULT_CODEC_OPTIONS,
+    ) -> T:
+        return self.structure(decode(data, codec_options=codec_options), cl)
+
+
+def configure_converter(converter: BaseConverter):
+    """
+    Configure the converter for use with the bson library.
+
+    * sets are serialized as lists
+    * byte mapping keys are base85-encoded into strings when unstructuring, and reverse
+    * non-string, non-byte mapping keys are coerced into strings when unstructuring
+    * a deserialization hook is registered for bson.ObjectId by default
+    """
+
+    def gen_unstructure_mapping(cl: Any, unstructure_to=None):
+        key_handler = str
+        args = getattr(cl, "__args__", None)
+        if args:
+            if issubclass(args[0], str):
+                key_handler = None
+            elif issubclass(args[0], bytes):
+
+                def key_handler(k):
+                    return b85encode(k).decode("utf8")
+
+        return converter.gen_unstructure_mapping(
+            cl, unstructure_to=unstructure_to, key_handler=key_handler
+        )
+
+    def gen_structure_mapping(cl: Any):
+        args = getattr(cl, "__args__", None)
+        if args and issubclass(args[0], bytes):
+            h = make_mapping_structure_fn(cl, converter, key_type=Base85Bytes)
+        else:
+            h = make_mapping_structure_fn(cl, converter)
+        return h
+
+    converter.register_structure_hook(Base85Bytes, lambda v, _: b85decode(v))
+    converter._unstructure_func.register_func_list(
+        [(is_mapping, gen_unstructure_mapping, True)]
+    )
+    converter._structure_func.register_func_list(
+        [(is_mapping, gen_structure_mapping, True)]
+    )
+
+    converter.register_structure_hook(ObjectId, lambda v, _: ObjectId(v))
+    configure_union_passthrough(
+        Union[str, bool, int, float, None, bytes, datetime, ObjectId, Int64], converter
+    )
+
+    # datetime inherits from date, so identity unstructure hook used
+    # here to prevent the date unstructure hook running.
+    converter.register_unstructure_hook(datetime, lambda v: v)
+    converter.register_structure_hook(datetime, validate_datetime)
+    converter.register_unstructure_hook(date, lambda v: v.isoformat())
+    converter.register_structure_hook(date, lambda v, _: date.fromisoformat(v))
+
+
+def make_converter(*args: Any, **kwargs: Any) -> BsonConverter:
+    kwargs["unstruct_collection_overrides"] = {
+        AbstractSet: list,
+        **kwargs.get("unstruct_collection_overrides", {}),
+    }
+    res = BsonConverter(*args, **kwargs)
+    configure_converter(res)
+
+    return res

jaclang/vendor/cattrs/preconf/cbor2.py

@@ -0,0 +1,47 @@
+"""Preconfigured converters for cbor2."""
+from datetime import date, datetime, timezone
+from typing import Any, Type, TypeVar, Union
+
+from cbor2 import dumps, loads
+
+from cattrs._compat import AbstractSet
+
+from ..converters import BaseConverter, Converter
+from ..strategies import configure_union_passthrough
+
+T = TypeVar("T")
+
+
+class Cbor2Converter(Converter):
+    def dumps(self, obj: Any, unstructure_as: Any = None, **kwargs: Any) -> bytes:
+        return dumps(self.unstructure(obj, unstructure_as=unstructure_as), **kwargs)
+
+    def loads(self, data: bytes, cl: Type[T], **kwargs: Any) -> T:
+        return self.structure(loads(data, **kwargs), cl)
+
+
+def configure_converter(converter: BaseConverter):
+    """
+    Configure the converter for use with the cbor2 library.
+
+    * datetimes are serialized as timestamp floats
+    * sets are serialized as lists
+    """
+    converter.register_unstructure_hook(datetime, lambda v: v.timestamp())
+    converter.register_structure_hook(
+        datetime, lambda v, _: datetime.fromtimestamp(v, timezone.utc)
+    )
+    converter.register_unstructure_hook(date, lambda v: v.isoformat())
+    converter.register_structure_hook(date, lambda v, _: date.fromisoformat(v))
+    configure_union_passthrough(Union[str, bool, int, float, None, bytes], converter)
+
+
+def make_converter(*args: Any, **kwargs: Any) -> Cbor2Converter:
+    kwargs["unstruct_collection_overrides"] = {
+        AbstractSet: list,
+        **kwargs.get("unstruct_collection_overrides", {}),
+    }
+    res = Cbor2Converter(*args, **kwargs)
+    configure_converter(res)
+
+    return res

jaclang/vendor/cattrs/preconf/json.py

@@ -0,0 +1,52 @@
+"""Preconfigured converters for the stdlib json."""
+from base64 import b85decode, b85encode
+from datetime import date, datetime
+from json import dumps, loads
+from typing import Any, Type, TypeVar, Union
+
+from cattrs._compat import AbstractSet, Counter
+
+from ..converters import BaseConverter, Converter
+from ..strategies import configure_union_passthrough
+
+T = TypeVar("T")
+
+
+class JsonConverter(Converter):
+    def dumps(self, obj: Any, unstructure_as: Any = None, **kwargs: Any) -> str:
+        return dumps(self.unstructure(obj, unstructure_as=unstructure_as), **kwargs)
+
+    def loads(self, data: Union[bytes, str], cl: Type[T], **kwargs: Any) -> T:
+        return self.structure(loads(data, **kwargs), cl)
+
+
+def configure_converter(converter: BaseConverter):
+    """
+    Configure the converter for use with the stdlib json module.
+
+    * bytes are serialized as base64 strings
+    * datetimes are serialized as ISO 8601
+    * counters are serialized as dicts
+    * sets are serialized as lists
+    """
+    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))
+    configure_union_passthrough(Union[str, bool, int, float, None, bytes], converter)
+
+
+def make_converter(*args: Any, **kwargs: Any) -> JsonConverter:
+    kwargs["unstruct_collection_overrides"] = {
+        AbstractSet: list,
+        Counter: dict,
+        **kwargs.get("unstruct_collection_overrides", {}),
+    }
+    res = JsonConverter(*args, **kwargs)
+    configure_converter(res)
+
+    return res

jaclang/vendor/cattrs/preconf/msgpack.py

@@ -0,0 +1,51 @@
+"""Preconfigured converters for msgpack."""
+from datetime import date, datetime, time, timezone
+from typing import Any, Type, TypeVar, Union
+
+from msgpack import dumps, loads
+
+from cattrs._compat import AbstractSet
+
+from ..converters import BaseConverter, Converter
+from ..strategies import configure_union_passthrough
+
+T = TypeVar("T")
+
+
+class MsgpackConverter(Converter):
+    def dumps(self, obj: Any, unstructure_as: Any = None, **kwargs: Any) -> bytes:
+        return dumps(self.unstructure(obj, unstructure_as=unstructure_as), **kwargs)
+
+    def loads(self, data: bytes, cl: Type[T], **kwargs: Any) -> T:
+        return self.structure(loads(data, **kwargs), cl)
+
+
+def configure_converter(converter: BaseConverter):
+    """
+    Configure the converter for use with the msgpack library.
+
+    * datetimes are serialized as timestamp floats
+    * sets are serialized as lists
+    """
+    converter.register_unstructure_hook(datetime, lambda v: v.timestamp())
+    converter.register_structure_hook(
+        datetime, lambda v, _: datetime.fromtimestamp(v, timezone.utc)
+    )
+    converter.register_unstructure_hook(
+        date, lambda v: datetime.combine(v, time(tzinfo=timezone.utc)).timestamp()
+    )
+    converter.register_structure_hook(
+        date, lambda v, _: datetime.fromtimestamp(v, timezone.utc).date()
+    )
+    configure_union_passthrough(Union[str, bool, int, float, None, bytes], converter)
+
+
+def make_converter(*args: Any, **kwargs: Any) -> MsgpackConverter:
+    kwargs["unstruct_collection_overrides"] = {
+        AbstractSet: list,
+        **kwargs.get("unstruct_collection_overrides", {}),
+    }
+    res = MsgpackConverter(*args, **kwargs)
+    configure_converter(res)
+
+    return res

jaclang/vendor/cattrs/preconf/orjson.py

@@ -0,0 +1,82 @@
+"""Preconfigured converters for orjson."""
+from base64 import b85decode, b85encode
+from datetime import date, datetime
+from enum import Enum
+from typing import Any, Type, TypeVar, Union
+
+from orjson import dumps, loads
+
+from cattrs._compat import AbstractSet, is_mapping
+
+from ..converters import BaseConverter, Converter
+from ..fns import identity
+from ..strategies import configure_union_passthrough
+
+T = TypeVar("T")
+
+
+class OrjsonConverter(Converter):
+    def dumps(self, obj: Any, unstructure_as: Any = None, **kwargs: Any) -> bytes:
+        return dumps(self.unstructure(obj, unstructure_as=unstructure_as), **kwargs)
+
+    def loads(self, data: Union[bytes, bytearray, memoryview, str], cl: Type[T]) -> T:
+        return self.structure(loads(data), cl)
+
+
+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
+    * sets are serialized as lists
+    * string enum mapping keys have special handling
+    * mapping keys are coerced into strings when unstructuring
+    """
+    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):
+        key_handler = str
+        args = getattr(cl, "__args__", None)
+        if args:
+            if issubclass(args[0], str) and issubclass(args[0], Enum):
+
+                def key_handler(v):
+                    return v.value
+
+            else:
+                # It's possible the handler for the key type has been overridden.
+                # (For example base85 encoding for bytes.)
+                # In that case, we want to use the override.
+
+                kh = converter._unstructure_func.dispatch(args[0])
+                if kh != identity:
+                    key_handler = kh
+
+        return converter.gen_unstructure_mapping(
+            cl, unstructure_to=unstructure_to, key_handler=key_handler
+        )
+
+    converter._unstructure_func.register_func_list(
+        [(is_mapping, gen_unstructure_mapping, True)]
+    )
+    configure_union_passthrough(Union[str, bool, int, float, None], converter)
+
+
+def make_converter(*args: Any, **kwargs: Any) -> OrjsonConverter:
+    kwargs["unstruct_collection_overrides"] = {
+        AbstractSet: list,
+        **kwargs.get("unstruct_collection_overrides", {}),
+    }
+    res = OrjsonConverter(*args, **kwargs)
+    configure_converter(res)
+
+    return res

jaclang/vendor/cattrs/preconf/pyyaml.py

@@ -0,0 +1,60 @@
+"""Preconfigured converters for pyyaml."""
+from datetime import date, datetime
+from typing import Any, Type, TypeVar, Union
+
+from yaml import safe_dump, safe_load
+
+from cattrs._compat import FrozenSetSubscriptable
+
+from ..converters import BaseConverter, Converter
+from ..strategies import configure_union_passthrough
+from . import validate_datetime
+
+T = TypeVar("T")
+
+
+def validate_date(v, _):
+    if not isinstance(v, date):
+        raise ValueError(f"Expected date, got {v}")
+    return v
+
+
+class PyyamlConverter(Converter):
+    def dumps(self, obj: Any, unstructure_as: Any = None, **kwargs: Any) -> str:
+        return safe_dump(self.unstructure(obj, unstructure_as=unstructure_as), **kwargs)
+
+    def loads(self, data: str, cl: Type[T]) -> T:
+        return self.structure(safe_load(data), cl)
+
+
+def configure_converter(converter: BaseConverter):
+    """
+    Configure the converter for use with the pyyaml library.
+
+    * frozensets are serialized as lists
+    * string enums are converted into strings explicitly
+    * datetimes and dates are validated
+    """
+    converter.register_unstructure_hook(
+        str, lambda v: v if v.__class__ is str else v.value
+    )
+
+    # datetime inherits from date, so identity unstructure hook used
+    # here to prevent the date unstructure hook running.
+    converter.register_unstructure_hook(datetime, lambda v: v)
+    converter.register_structure_hook(datetime, validate_datetime)
+    converter.register_structure_hook(date, validate_date)
+    configure_union_passthrough(
+        Union[str, bool, int, float, None, bytes, datetime, date], converter
+    )
+
+
+def make_converter(*args: Any, **kwargs: Any) -> PyyamlConverter:
+    kwargs["unstruct_collection_overrides"] = {
+        FrozenSetSubscriptable: list,
+        **kwargs.get("unstruct_collection_overrides", {}),
+    }
+    res = PyyamlConverter(*args, **kwargs)
+    configure_converter(res)
+
+    return res

jaclang/vendor/cattrs/preconf/tomlkit.py

@@ -0,0 +1,85 @@
+"""Preconfigured converters for tomlkit."""
+from base64 import b85decode, b85encode
+from datetime import date, datetime
+from enum import Enum
+from operator import attrgetter
+from typing import Any, Type, TypeVar, Union
+
+from tomlkit import dumps, loads
+from tomlkit.items import Float, Integer, String
+
+from cattrs._compat import AbstractSet, is_mapping
+
+from ..converters import BaseConverter, Converter
+from ..strategies import configure_union_passthrough
+from . import validate_datetime
+
+T = TypeVar("T")
+_enum_value_getter = attrgetter("_value_")
+
+
+class TomlkitConverter(Converter):
+    def dumps(self, obj: Any, unstructure_as: Any = None, **kwargs: Any) -> str:
+        return dumps(self.unstructure(obj, unstructure_as=unstructure_as), **kwargs)
+
+    def loads(self, data: str, cl: Type[T]) -> T:
+        return self.structure(loads(data), cl)
+
+
+def configure_converter(converter: BaseConverter):
+    """
+    Configure the converter for use with the tomlkit library.
+
+    * bytes are serialized as base85 strings
+    * sets are serialized as lists
+    * tuples are serializas as lists
+    * mapping keys are coerced into strings when unstructuring
+    """
+    converter.register_structure_hook(bytes, lambda v, _: b85decode(v))
+    converter.register_unstructure_hook(
+        bytes, lambda v: (b85encode(v) if v else b"").decode("utf8")
+    )
+
+    def gen_unstructure_mapping(cl: Any, unstructure_to=None):
+        key_handler = str
+        args = getattr(cl, "__args__", None)
+        if args:
+            # Currently, tomlkit has inconsistent behavior on 3.11
+            # so we paper over it here.
+            # https://github.com/sdispater/tomlkit/issues/237
+            if issubclass(args[0], str):
+                key_handler = _enum_value_getter if issubclass(args[0], Enum) else None
+            elif issubclass(args[0], bytes):
+
+                def key_handler(k: bytes):
+                    return b85encode(k).decode("utf8")
+
+        return converter.gen_unstructure_mapping(
+            cl, unstructure_to=unstructure_to, key_handler=key_handler
+        )
+
+    converter._unstructure_func.register_func_list(
+        [(is_mapping, gen_unstructure_mapping, True)]
+    )
+
+    # datetime inherits from date, so identity unstructure hook used
+    # here to prevent the date unstructure hook running.
+    converter.register_unstructure_hook(datetime, lambda v: v)
+    converter.register_structure_hook(datetime, validate_datetime)
+    converter.register_unstructure_hook(date, lambda v: v.isoformat())
+    converter.register_structure_hook(date, lambda v, _: date.fromisoformat(v))
+    configure_union_passthrough(
+        Union[str, String, bool, int, Integer, float, Float], converter
+    )
+
+
+def make_converter(*args: Any, **kwargs: Any) -> TomlkitConverter:
+    kwargs["unstruct_collection_overrides"] = {
+        AbstractSet: list,
+        tuple: list,
+        **kwargs.get("unstruct_collection_overrides", {}),
+    }
+    res = TomlkitConverter(*args, **kwargs)
+    configure_converter(res)
+
+    return res

jaclang/vendor/cattrs/preconf/ujson.py

@@ -0,0 +1,52 @@
+"""Preconfigured converters for ujson."""
+from base64 import b85decode, b85encode
+from datetime import date, datetime
+from typing import Any, AnyStr, Type, TypeVar, Union
+
+from ujson import dumps, loads
+
+from cattrs._compat import AbstractSet
+
+from ..converters import BaseConverter, Converter
+from ..strategies import configure_union_passthrough
+
+T = TypeVar("T")
+
+
+class UjsonConverter(Converter):
+    def dumps(self, obj: Any, unstructure_as: Any = None, **kwargs: Any) -> str:
+        return dumps(self.unstructure(obj, unstructure_as=unstructure_as), **kwargs)
+
+    def loads(self, data: AnyStr, cl: Type[T], **kwargs: Any) -> T:
+        return self.structure(loads(data, **kwargs), cl)
+
+
+def configure_converter(converter: BaseConverter):
+    """
+    Configure the converter for use with the ujson library.
+
+    * bytes are serialized as base64 strings
+    * datetimes are serialized as ISO 8601
+    * sets are serialized as lists
+    """
+    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))
+    configure_union_passthrough(Union[str, bool, int, float, None], converter)
+
+
+def make_converter(*args: Any, **kwargs: Any) -> UjsonConverter:
+    kwargs["unstruct_collection_overrides"] = {
+        AbstractSet: list,
+        **kwargs.get("unstruct_collection_overrides", {}),
+    }
+    res = UjsonConverter(*args, **kwargs)
+    configure_converter(res)
+
+    return res

jaclang/vendor/cattrs/strategies/__init__.py

@@ -0,0 +1,11 @@
+"""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
+
+__all__ = [
+    "configure_tagged_union",
+    "configure_union_passthrough",
+    "include_subclasses",
+    "use_class_methods",
+]

jaclang/vendor/cattrs/strategies/_class_methods.py

@@ -0,0 +1,64 @@
+"""Strategy for using class-specific (un)structuring methods."""
+
+from inspect import signature
+from typing import Any, Callable, Optional, Type, TypeVar
+
+from cattrs import BaseConverter
+
+T = TypeVar("T")
+
+
+def use_class_methods(
+    converter: BaseConverter,
+    structure_method_name: Optional[str] = None,
+    unstructure_method_name: Optional[str] = None,
+) -> None:
+    """
+    Configure the converter such that dedicated methods are used for (un)structuring
+    the instance of a class if such methods are available. The default (un)structuring
+    will be applied if such an (un)structuring methods cannot be found.
+
+    :param converter: The `Converter` on which this strategy is applied. You can use
+        :class:`cattrs.BaseConverter` or any other derived class.
+    :param structure_method_name: Optional string with the name of the class method
+        which should be used for structuring. If not provided, no class method will be
+        used for structuring.
+    :param unstructure_method_name: Optional string with the name of the class method
+        which should be used for unstructuring. If not provided, no class method will
+        be used for unstructuring.
+
+    If you want to (un)structured nested objects, just append a converter parameter
+    to your (un)structuring methods and you will receive the converter there.
+
+    .. versionadded:: 23.2.0
+    """
+
+    if structure_method_name:
+
+        def make_class_method_structure(cl: Type[T]) -> Callable[[Any, Type[T]], T]:
+            fn = getattr(cl, structure_method_name)
+            n_parameters = len(signature(fn).parameters)
+            if n_parameters == 1:
+                return lambda v, _: fn(v)
+            if n_parameters == 2:
+                return lambda v, _: fn(v, converter)
+            raise TypeError("Provide a class method with one or two arguments.")
+
+        converter.register_structure_hook_factory(
+            lambda t: hasattr(t, structure_method_name), make_class_method_structure
+        )
+
+    if unstructure_method_name:
+
+        def make_class_method_unstructure(cl: Type[T]) -> Callable[[T], T]:
+            fn = getattr(cl, unstructure_method_name)
+            n_parameters = len(signature(fn).parameters)
+            if n_parameters == 1:
+                return fn
+            if n_parameters == 2:
+                return lambda self_: fn(self_, converter)
+            raise TypeError("Provide a method with no or one argument.")
+
+        converter.register_unstructure_hook_factory(
+            lambda t: hasattr(t, unstructure_method_name), make_class_method_unstructure
+        )