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

jaclang/vendor/cattrs/gen/_generics.py

@@ -5,8 +5,33 @@ from typing import TypeVar
 from .._compat import get_args, get_origin, is_generic
 
 
+def _tvar_has_default(tvar) -> bool:
+    """Does `tvar` have a default?
+
+    In CPython 3.13+ and typing_extensions>=4.12.0:
+    - TypeVars have a `no_default()` method for detecting
+      if a TypeVar has a default
+    - TypeVars with `default=None` have `__default__` set to `None`
+    - TypeVars with no `default` parameter passed
+      have `__default__` set to `typing(_extensions).NoDefault
+
+    On typing_exensions<4.12.0:
+    - TypeVars do not have a `no_default()` method for detecting
+      if a TypeVar has a default
+    - TypeVars with `default=None` have `__default__` set to `NoneType`
+    - TypeVars with no `default` parameter passed
+      have `__default__` set to `typing(_extensions).NoDefault
+    """
+    try:
+        return tvar.has_default()
+    except AttributeError:
+        # compatibility for typing_extensions<4.12.0
+        return getattr(tvar, "__default__", None) is not None
+
+
 def generate_mapping(cl: type, old_mapping: dict[str, type] = {}) -> dict[str, type]:
-    mapping = {}
+    """Generate a mapping of typevars to actual types for a generic class."""
+    mapping = dict(old_mapping)
 
     origin = get_origin(cl)
 
@@ -25,8 +50,6 @@ def generate_mapping(cl: type, old_mapping: dict[str, type] = {}) -> dict[str, t
                 continue
             mapping[p.__name__] = t
 
-        if not mapping:
-            return dict(old_mapping)
     elif is_generic(cl):
         # Origin is None, so this may be a subclass of a generic class.
         orig_bases = cl.__orig_bases__
@@ -34,9 +57,22 @@ def generate_mapping(cl: type, old_mapping: dict[str, type] = {}) -> dict[str, t
             if not hasattr(base, "__args__"):
                 continue
             base_args = base.__args__
-            if not hasattr(base.__origin__, "__parameters__"):
+            if hasattr(base.__origin__, "__parameters__"):
+                base_params = base.__origin__.__parameters__
+            elif any(_tvar_has_default(base_arg) for base_arg in base_args):
+                # TypeVar with a default e.g. PEP 696
+                # https://www.python.org/dev/peps/pep-0696/
+                # Extract the defaults for the TypeVars and insert
+                # them into the mapping
+                mapping_params = [
+                    (base_arg, base_arg.__default__)
+                    for base_arg in base_args
+                    if _tvar_has_default(base_arg)
+                ]
+                base_params, base_args = zip(*mapping_params)
+            else:
                 continue
-            base_params = base.__origin__.__parameters__
+
             for param, arg in zip(base_params, base_args):
                 mapping[param.__name__] = arg
 

jaclang/vendor/cattrs/gen/_lc.py

@@ -1,9 +1,10 @@
 """Line-cache functionality."""
+
 import linecache
-from typing import Any, List
+from typing import List
 
 
-def generate_unique_filename(cls: Any, func_name: str, lines: List[str] = []) -> str:
+def generate_unique_filename(cls: type, func_name: str, lines: List[str] = []) -> str:
     """
     Create a "filename" suitable for a function being generated.
 

jaclang/vendor/cattrs/gen/_shared.py

@@ -1,51 +1,58 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Callable
+from typing import TYPE_CHECKING, Any
 
 from attrs import NOTHING, Attribute, Factory
 
 from .._compat import is_bare_final
+from ..dispatch import StructureHook
 from ..fns import raise_error
 
-if TYPE_CHECKING:  # pragma: no cover
-    from cattr.converters import BaseConverter
+if TYPE_CHECKING:
+    from ..converters import BaseConverter
 
 
 def find_structure_handler(
     a: Attribute, type: Any, c: BaseConverter, prefer_attrs_converters: bool = False
-) -> Callable[[Any, Any], Any] | None:
+) -> StructureHook | None:
     """Find the appropriate structure handler to use.
 
     Return `None` if no handler should be used.
     """
-    if a.converter is not None and prefer_attrs_converters:
-        # If the user as requested to use attrib converters, use nothing
-        # so it falls back to that.
-        handler = None
-    elif a.converter is not None and not prefer_attrs_converters and type is not None:
-        handler = c._structure_func.dispatch(type)
-        if handler == raise_error:
+    try:
+        if a.converter is not None and prefer_attrs_converters:
+            # If the user as requested to use attrib converters, use nothing
+            # so it falls back to that.
             handler = None
-    elif type is not None:
-        if (
-            is_bare_final(type)
-            and a.default is not NOTHING
-            and not isinstance(a.default, Factory)
+        elif (
+            a.converter is not None and not prefer_attrs_converters and type is not None
         ):
-            # This is a special case where we can use the
-            # type of the default to dispatch on.
-            type = a.default.__class__
-            handler = c._structure_func.dispatch(type)
-            if handler == c._structure_call:
-                # Finals can't really be used with _structure_call, so
-                # we wrap it so the rest of the toolchain doesn't get
-                # confused.
-
-                def handler(v, _, _h=handler):
-                    return _h(v, type)
-
+            handler = c.get_structure_hook(type, cache_result=False)
+            if handler == raise_error:
+                handler = None
+        elif type is not None:
+            if (
+                is_bare_final(type)
+                and a.default is not NOTHING
+                and not isinstance(a.default, Factory)
+            ):
+                # This is a special case where we can use the
+                # type of the default to dispatch on.
+                type = a.default.__class__
+                handler = c.get_structure_hook(type, cache_result=False)
+                if handler == c._structure_call:
+                    # Finals can't really be used with _structure_call, so
+                    # we wrap it so the rest of the toolchain doesn't get
+                    # confused.
+
+                    def handler(v, _, _h=handler):
+                        return _h(v, type)
+
+            else:
+                handler = c.get_structure_hook(type, cache_result=False)
         else:
-            handler = c._structure_func.dispatch(type)
-    else:
-        handler = c.structure
-    return handler
+            handler = c.structure
+        return handler
+    except RecursionError:
+        # This means we're dealing with a reference cycle, so use late binding.
+        return c.structure

jaclang/vendor/cattrs/gen/typeddicts.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import re
 import sys
-from typing import TYPE_CHECKING, Any, Callable, TypeVar
+from typing import TYPE_CHECKING, Any, Callable, Literal, TypeVar
 
 from attrs import NOTHING, Attribute
 
@@ -50,10 +50,8 @@ from ._generics import generate_mapping
 from ._lc import generate_unique_filename
 from ._shared import find_structure_handler
 
-if TYPE_CHECKING:  # pragma: no cover
-    from typing_extensions import Literal
-
-    from cattr.converters import BaseConverter
+if TYPE_CHECKING:
+    from ..converters import BaseConverter
 
 __all__ = ["make_dict_unstructure_fn", "make_dict_structure_fn"]
 
@@ -124,21 +122,22 @@ def make_dict_unstructure_fn(
                 break
             handler = None
             t = a.type
-            nrb = get_notrequired_base(t)
-            if nrb is not NOTHING:
-                t = nrb
 
             if isinstance(t, TypeVar):
                 if t.__name__ in mapping:
                     t = mapping[t.__name__]
                 else:
+                    # Unbound typevars use late binding.
                     handler = converter.unstructure
             elif is_generic(t) and not is_bare(t) and not is_annotated(t):
                 t = deep_copy_with(t, mapping)
 
             if handler is None:
+                nrb = get_notrequired_base(t)
+                if nrb is not NOTHING:
+                    t = nrb
                 try:
-                    handler = converter._unstructure_func.dispatch(t)
+                    handler = converter.get_unstructure_hook(t)
                 except RecursionError:
                     # There's a circular reference somewhere down the line
                     handler = converter.unstructure
@@ -170,9 +169,6 @@ def make_dict_unstructure_fn(
                 handler = override.unstruct_hook
             else:
                 t = a.type
-                nrb = get_notrequired_base(t)
-                if nrb is not NOTHING:
-                    t = nrb
 
                 if isinstance(t, TypeVar):
                     if t.__name__ in mapping:
@@ -183,8 +179,11 @@ def make_dict_unstructure_fn(
                     t = deep_copy_with(t, mapping)
 
                 if handler is None:
+                    nrb = get_notrequired_base(t)
+                    if nrb is not NOTHING:
+                        t = nrb
                     try:
-                        handler = converter._unstructure_func.dispatch(t)
+                        handler = converter.get_unstructure_hook(t)
                     except RecursionError:
                         # There's a circular reference somewhere down the line
                         handler = converter.unstructure
@@ -208,7 +207,7 @@ def make_dict_unstructure_fn(
                 # No default or no override.
                 lines.append(f"  res['{kn}'] = {invoke}")
             else:
-                lines.append(f"  if '{kn}' in instance: res['{kn}'] = {invoke}")
+                lines.append(f"  if '{attr_name}' in instance: res['{kn}'] = {invoke}")
 
         internal_arg_line = ", ".join([f"{i}={i}" for i in internal_arg_parts])
         if internal_arg_line:
@@ -277,9 +276,6 @@ def make_dict_structure_fn(
             mapping = generate_mapping(base, mapping)
             break
 
-    if isinstance(cl, TypeVar):
-        cl = mapping.get(cl.__name__, cl)
-
     cl_name = cl.__name__
     fn_name = "structure_" + cl_name
 
@@ -332,15 +328,19 @@ def make_dict_structure_fn(
             if override.omit:
                 continue
             t = a.type
-            nrb = get_notrequired_base(t)
-            if nrb is not NOTHING:
-                t = nrb
 
             if isinstance(t, TypeVar):
                 t = mapping.get(t.__name__, t)
             elif is_generic(t) and not is_bare(t) and not is_annotated(t):
                 t = deep_copy_with(t, mapping)
 
+            nrb = get_notrequired_base(t)
+            if nrb is not NOTHING:
+                t = nrb
+
+            if is_generic(t) and not is_bare(t) and not is_annotated(t):
+                t = deep_copy_with(t, mapping)
+
             # For each attribute, we try resolving the type here and now.
             # If a type is manually overwritten, this function should be
             # regenerated.
@@ -365,16 +365,11 @@ def make_dict_structure_fn(
             tn = f"__c_type_{ix}"
             internal_arg_parts[tn] = t
 
-            if handler:
-                if handler == converter._structure_call:
-                    internal_arg_parts[struct_handler_name] = t
-                    lines.append(f"{i}res['{an}'] = {struct_handler_name}(o['{kn}'])")
-                else:
-                    lines.append(
-                        f"{i}res['{an}'] = {struct_handler_name}(o['{kn}'], {tn})"
-                    )
+            if handler == converter._structure_call:
+                internal_arg_parts[struct_handler_name] = t
+                lines.append(f"{i}res['{an}'] = {struct_handler_name}(o['{kn}'])")
             else:
-                lines.append(f"{i}res['{an}'] = o['{kn}']")
+                lines.append(f"{i}res['{an}'] = {struct_handler_name}(o['{kn}'], {tn})")
             if override.rename is not None:
                 lines.append(f"{i}del res['{kn}']")
             i = i[:-2]
@@ -410,42 +405,38 @@ def make_dict_structure_fn(
                 continue
 
             t = a.type
-            nrb = get_notrequired_base(t)
-            if nrb is not NOTHING:
-                t = nrb
 
             if isinstance(t, TypeVar):
                 t = mapping.get(t.__name__, t)
             elif is_generic(t) and not is_bare(t) and not is_annotated(t):
                 t = deep_copy_with(t, mapping)
 
-            # For each attribute, we try resolving the type here and now.
-            # If a type is manually overwritten, this function should be
-            # regenerated.
-            if t is not None:
-                handler = converter._structure_func.dispatch(t)
+            nrb = get_notrequired_base(t)
+            if nrb is not NOTHING:
+                t = nrb
+
+            if override.struct_hook is not None:
+                handler = override.struct_hook
             else:
-                handler = converter.structure
+                # For each attribute, we try resolving the type here and now.
+                # If a type is manually overwritten, this function should be
+                # regenerated.
+                handler = converter.get_structure_hook(t)
 
             kn = an if override.rename is None else override.rename
             allowed_fields.add(kn)
 
-            if handler:
-                struct_handler_name = f"__c_structure_{ix}"
-                internal_arg_parts[struct_handler_name] = handler
-                if handler == converter._structure_call:
-                    internal_arg_parts[struct_handler_name] = t
-                    invocation_line = (
-                        f"  res['{an}'] = {struct_handler_name}(o['{kn}'])"
-                    )
-                else:
-                    tn = f"__c_type_{ix}"
-                    internal_arg_parts[tn] = t
-                    invocation_line = (
-                        f"  res['{an}'] = {struct_handler_name}(o['{kn}'], {tn})"
-                    )
+            struct_handler_name = f"__c_structure_{ix}"
+            internal_arg_parts[struct_handler_name] = handler
+            if handler == converter._structure_call:
+                internal_arg_parts[struct_handler_name] = t
+                invocation_line = f"  res['{an}'] = {struct_handler_name}(o['{kn}'])"
             else:
-                invocation_line = f"  res['{an}'] = o['{kn}']"
+                tn = f"__c_type_{ix}"
+                internal_arg_parts[tn] = t
+                invocation_line = (
+                    f"  res['{an}'] = {struct_handler_name}(o['{kn}'], {tn})"
+                )
 
             lines.append(invocation_line)
             if override.rename is not None:
@@ -467,13 +458,13 @@ def make_dict_structure_fn(
                 elif is_generic(t) and not is_bare(t) and not is_annotated(t):
                     t = deep_copy_with(t, mapping)
 
-                # For each attribute, we try resolving the type here and now.
-                # If a type is manually overwritten, this function should be
-                # regenerated.
-                if t is not None:
-                    handler = converter._structure_func.dispatch(t)
+                if override.struct_hook is not None:
+                    handler = override.struct_hook
                 else:
-                    handler = converter.structure
+                    # For each attribute, we try resolving the type here and now.
+                    # If a type is manually overwritten, this function should be
+                    # regenerated.
+                    handler = converter.get_structure_hook(t)
 
                 struct_handler_name = f"__c_structure_{ix}"
                 internal_arg_parts[struct_handler_name] = handler
@@ -482,20 +473,17 @@ def make_dict_structure_fn(
                 kn = an if override.rename is None else override.rename
                 allowed_fields.add(kn)
                 post_lines.append(f"  if '{kn}' in o:")
-                if handler:
-                    if handler == converter._structure_call:
-                        internal_arg_parts[struct_handler_name] = t
-                        post_lines.append(
-                            f"    res['{ian}'] = {struct_handler_name}(o['{kn}'])"
-                        )
-                    else:
-                        tn = f"__c_type_{ix}"
-                        internal_arg_parts[tn] = t
-                        post_lines.append(
-                            f"    res['{ian}'] = {struct_handler_name}(o['{kn}'], {tn})"
-                        )
+                if handler == converter._structure_call:
+                    internal_arg_parts[struct_handler_name] = t
+                    post_lines.append(
+                        f"    res['{ian}'] = {struct_handler_name}(o['{kn}'])"
+                    )
                 else:
-                    post_lines.append(f"    res['{ian}'] = o['{kn}']")
+                    tn = f"__c_type_{ix}"
+                    internal_arg_parts[tn] = t
+                    post_lines.append(
+                        f"    res['{ian}'] = {struct_handler_name}(o['{kn}'], {tn})"
+                    )
                 if override.rename is not None:
                     lines.append(f"  res.pop('{override.rename}', None)")
 
@@ -562,7 +550,12 @@ if sys.version_info >= (3, 11):
 elif sys.version_info >= (3, 9):
     from typing_extensions import Annotated, NotRequired, Required, get_args
 
+    # Note that there is no `typing.Required` on 3.9 and 3.10, only in
+    # `typing_extensions`. Therefore, `typing.TypedDict` will not honor this
+    # annotation, only `typing_extensions.TypedDict`.
+
     def _required_keys(cls: type) -> set[str]:
+        """Our own processor for required keys."""
         if _is_extensions_typeddict(cls):
             return cls.__required_keys__
 
@@ -570,8 +563,9 @@ elif sys.version_info >= (3, 9):
         # gathering required keys. *sigh*
         own_annotations = cls.__dict__.get("__annotations__", {})
         required_keys = set()
-        for base in cls.__mro__[1:]:
-            required_keys |= _required_keys(base)
+        # On 3.8 - 3.10, typing.TypedDict doesn't put typeddict superclasses
+        # in the MRO, therefore we cannot handle non-required keys properly
+        # in some situations. Oh well.
         for key in getattr(cls, "__required_keys__", []):
             annotation_type = own_annotations[key]
             annotation_origin = get_origin(annotation_type)
@@ -581,9 +575,7 @@ elif sys.version_info >= (3, 9):
                     annotation_type = annotation_args[0]
                     annotation_origin = get_origin(annotation_type)
 
-            if annotation_origin is Required:
-                required_keys.add(key)
-            elif annotation_origin is NotRequired:
+            if annotation_origin is NotRequired:
                 pass
             elif cls.__total__:
                 required_keys.add(key)
@@ -595,25 +587,20 @@ else:
     # On 3.8, typing.TypedDicts do not have __required_keys__.
 
     def _required_keys(cls: type) -> set[str]:
+        """Our own processor for required keys."""
         if _is_extensions_typeddict(cls):
             return cls.__required_keys__
 
         own_annotations = cls.__dict__.get("__annotations__", {})
         required_keys = set()
-        superclass_keys = set()
-        for base in cls.__mro__[1:]:
-            required_keys |= _required_keys(base)
-            superclass_keys |= base.__dict__.get("__annotations__", {}).keys()
         for key in own_annotations:
-            if key in superclass_keys:
-                continue
             annotation_type = own_annotations[key]
+
+            if is_annotated(annotation_type):
+                # If this is `Annotated`, we need to get the origin twice.
+                annotation_type = get_origin(annotation_type)
+
             annotation_origin = get_origin(annotation_type)
-            if annotation_origin is Annotated:
-                annotation_args = get_args(annotation_type)
-                if annotation_args:
-                    annotation_type = annotation_args[0]
-                    annotation_origin = get_origin(annotation_type)
 
             if annotation_origin is Required:
                 required_keys.add(key)

jaclang/vendor/cattrs/preconf/__init__.py

@@ -1,7 +1,27 @@
+import sys
 from datetime import datetime
+from typing import Any, Callable, TypeVar
+
+if sys.version_info[:2] < (3, 10):
+    from typing_extensions import ParamSpec
+else:
+    from typing import ParamSpec
 
 
 def validate_datetime(v, _):
     if not isinstance(v, datetime):
         raise Exception(f"Expected datetime, got {v}")
     return v
+
+
+T = TypeVar("T")
+P = ParamSpec("P")
+
+
+def wrap(_: Callable[P, Any]) -> Callable[[Callable[..., T]], Callable[P, T]]:
+    """Wrap a `Converter` `__init__` in a type-safe way."""
+
+    def impl(x: Callable[..., T]) -> Callable[P, T]:
+        return x
+
+    return impl

jaclang/vendor/cattrs/preconf/bson.py

@@ -1,4 +1,5 @@
 """Preconfigured converters for bson."""
+
 from base64 import b85decode, b85encode
 from datetime import date, datetime
 from typing import Any, Type, TypeVar, Union
@@ -9,8 +10,9 @@ from cattrs._compat import AbstractSet, is_mapping
 from cattrs.gen import make_mapping_structure_fn
 
 from ..converters import BaseConverter, Converter
+from ..dispatch import StructureHook
 from ..strategies import configure_union_passthrough
-from . import validate_datetime
+from . import validate_datetime, wrap
 
 T = TypeVar("T")
 
@@ -67,7 +69,7 @@ def configure_converter(converter: BaseConverter):
             cl, unstructure_to=unstructure_to, key_handler=key_handler
         )
 
-    def gen_structure_mapping(cl: Any):
+    def gen_structure_mapping(cl: Any) -> StructureHook:
         args = getattr(cl, "__args__", None)
         if args and issubclass(args[0], bytes):
             h = make_mapping_structure_fn(cl, converter, key_type=Base85Bytes)
@@ -76,12 +78,8 @@ def configure_converter(converter: BaseConverter):
         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_unstructure_hook_factory(is_mapping, gen_unstructure_mapping)
+    converter.register_structure_hook_factory(is_mapping, gen_structure_mapping)
 
     converter.register_structure_hook(ObjectId, lambda v, _: ObjectId(v))
     configure_union_passthrough(
@@ -96,6 +94,7 @@ def configure_converter(converter: BaseConverter):
     converter.register_structure_hook(date, lambda v, _: date.fromisoformat(v))
 
 
+@wrap(BsonConverter)
 def make_converter(*args: Any, **kwargs: Any) -> BsonConverter:
     kwargs["unstruct_collection_overrides"] = {
         AbstractSet: list,

jaclang/vendor/cattrs/preconf/cbor2.py

@@ -1,4 +1,5 @@
 """Preconfigured converters for cbor2."""
+
 from datetime import date, datetime, timezone
 from typing import Any, Type, TypeVar, Union
 
@@ -8,6 +9,7 @@ from cattrs._compat import AbstractSet
 
 from ..converters import BaseConverter, Converter
 from ..strategies import configure_union_passthrough
+from . import wrap
 
 T = TypeVar("T")
 
@@ -36,6 +38,7 @@ def configure_converter(converter: BaseConverter):
     configure_union_passthrough(Union[str, bool, int, float, None, bytes], converter)
 
 
+@wrap(Cbor2Converter)
 def make_converter(*args: Any, **kwargs: Any) -> Cbor2Converter:
     kwargs["unstruct_collection_overrides"] = {
         AbstractSet: list,

jaclang/vendor/cattrs/preconf/json.py

@@ -1,13 +1,14 @@
 """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 .._compat import AbstractSet, Counter
 from ..converters import BaseConverter, Converter
 from ..strategies import configure_union_passthrough
+from . import wrap
 
 T = TypeVar("T")
 
@@ -24,10 +25,12 @@ def configure_converter(converter: BaseConverter):
     """
     Configure the converter for use with the stdlib json module.
 
-    * bytes are serialized as base64 strings
+    * bytes are serialized as base85 strings
     * datetimes are serialized as ISO 8601
     * counters are serialized as dicts
     * sets are serialized as lists
+    * union passthrough is configured for unions of strings, bools, ints,
+      floats and None
     """
     converter.register_unstructure_hook(
         bytes, lambda v: (b85encode(v) if v else b"").decode("utf8")
@@ -37,9 +40,10 @@ def configure_converter(converter: BaseConverter):
     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)
+    configure_union_passthrough(Union[str, bool, int, float, None], converter)
 
 
+@wrap(JsonConverter)
 def make_converter(*args: Any, **kwargs: Any) -> JsonConverter:
     kwargs["unstruct_collection_overrides"] = {
         AbstractSet: list,

jaclang/vendor/cattrs/preconf/msgpack.py

@@ -1,4 +1,5 @@
 """Preconfigured converters for msgpack."""
+
 from datetime import date, datetime, time, timezone
 from typing import Any, Type, TypeVar, Union
 
@@ -8,6 +9,7 @@ from cattrs._compat import AbstractSet
 
 from ..converters import BaseConverter, Converter
 from ..strategies import configure_union_passthrough
+from . import wrap
 
 T = TypeVar("T")
 
@@ -40,6 +42,7 @@ def configure_converter(converter: BaseConverter):
     configure_union_passthrough(Union[str, bool, int, float, None, bytes], converter)
 
 
+@wrap(MsgpackConverter)
 def make_converter(*args: Any, **kwargs: Any) -> MsgpackConverter:
     kwargs["unstruct_collection_overrides"] = {
         AbstractSet: list,