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

jaclang/vendor/cattrs/_compat.py

@@ -1,39 +1,62 @@
 import sys
 from collections import deque
+from collections.abc import Mapping as AbcMapping
+from collections.abc import MutableMapping as AbcMutableMapping
 from collections.abc import MutableSet as AbcMutableSet
 from collections.abc import Set as AbcSet
-from dataclasses import MISSING
+from dataclasses import MISSING, Field, is_dataclass
 from dataclasses import fields as dataclass_fields
-from dataclasses import is_dataclass
+from functools import partial
+from inspect import signature as _signature
 from typing import AbstractSet as TypingAbstractSet
-from typing import Any, Deque, Dict, Final, FrozenSet, List
+from typing import (
+    Any,
+    Deque,
+    Dict,
+    Final,
+    FrozenSet,
+    List,
+    Literal,
+    NewType,
+    Optional,
+    Protocol,
+    Tuple,
+    Type,
+    Union,
+    get_args,
+    get_origin,
+    get_type_hints,
+)
 from typing import Mapping as TypingMapping
 from typing import MutableMapping as TypingMutableMapping
 from typing import MutableSequence as TypingMutableSequence
 from typing import MutableSet as TypingMutableSet
-from typing import NewType, Optional, Protocol
 from typing import Sequence as TypingSequence
 from typing import Set as TypingSet
-from typing import Tuple, get_args, get_origin, get_type_hints
 
-from attrs import NOTHING, Attribute, Factory
+from attrs import NOTHING, Attribute, Factory, resolve_types
 from attrs import fields as attrs_fields
-from attrs import resolve_types
+from attrs import fields_dict as attrs_fields_dict
 
 __all__ = [
+    "ANIES",
+    "adapted_fields",
+    "fields_dict",
     "ExceptionGroup",
     "ExtensionsTypedDict",
-    "TypedDict",
-    "TypeAlias",
+    "get_type_alias_base",
+    "has",
+    "is_type_alias",
     "is_typeddict",
+    "TypeAlias",
+    "TypedDict",
 ]
 
 try:
     from typing_extensions import TypedDict as ExtensionsTypedDict
-except ImportError:
+except ImportError:  # pragma: no cover
     ExtensionsTypedDict = None
 
-
 if sys.version_info >= (3, 11):
     from builtins import ExceptionGroup
 else:
@@ -41,22 +64,59 @@ else:
 
 try:
     from typing_extensions import is_typeddict as _is_typeddict
-except ImportError:
+except ImportError:  # pragma: no cover
     assert sys.version_info >= (3, 10)
     from typing import is_typeddict as _is_typeddict
 
 try:
     from typing_extensions import TypeAlias
-except ImportError:
+except ImportError:  # pragma: no cover
     assert sys.version_info >= (3, 11)
     from typing import TypeAlias
 
+LITERALS = {Literal}
+try:
+    from typing_extensions import Literal as teLiteral
+
+    LITERALS.add(teLiteral)
+except ImportError:  # pragma: no cover
+    pass
+
+# On some Python versions, `typing_extensions.Any` is different than
+# `typing.Any`.
+try:
+    from typing_extensions import Any as teAny
+
+    ANIES = frozenset([Any, teAny])
+except ImportError:  # pragma: no cover
+    ANIES = frozenset([Any])
+
+NoneType = type(None)
+
+
+def is_optional(typ: Type) -> bool:
+    return is_union_type(typ) and NoneType in typ.__args__ and len(typ.__args__) == 2
+
 
 def is_typeddict(cls):
     """Thin wrapper around typing(_extensions).is_typeddict"""
     return _is_typeddict(getattr(cls, "__origin__", cls))
 
 
+def is_type_alias(type: Any) -> bool:
+    """Is this a PEP 695 type alias?"""
+    return False
+
+
+def get_type_alias_base(type: Any) -> Any:
+    """
+    What is this a type alias of?
+
+    Works only on 3.12+.
+    """
+    return type.__value__
+
+
 def has(cls):
     return hasattr(cls, "__attrs_attrs__") or hasattr(cls, "__dataclass_fields__")
 
@@ -70,10 +130,14 @@ def fields(type):
     try:
         return type.__attrs_attrs__
     except AttributeError:
-        try:
-            return dataclass_fields(type)
-        except AttributeError:
-            raise Exception("Not an attrs or dataclass class.") from None
+        return dataclass_fields(type)
+
+
+def fields_dict(type) -> Dict[str, Union[Attribute, Field]]:
+    """Return the fields_dict for attrs and dataclasses."""
+    if is_dataclass(type):
+        return {f.name: f for f in dataclass_fields(type)}
+    return attrs_fields_dict(type)
 
 
 def adapted_fields(cl) -> List[Attribute]:
@@ -89,12 +153,14 @@ def adapted_fields(cl) -> List[Attribute]:
         return [
             Attribute(
                 attr.name,
-                attr.default
-                if attr.default is not MISSING
-                else (
-                    Factory(attr.default_factory)
-                    if attr.default_factory is not MISSING
-                    else NOTHING
+                (
+                    attr.default
+                    if attr.default is not MISSING
+                    else (
+                        Factory(attr.default_factory)
+                        if attr.default_factory is not MISSING
+                        else NOTHING
+                    )
                 ),
                 None,
                 True,
@@ -104,6 +170,7 @@ def adapted_fields(cl) -> List[Attribute]:
                 True,
                 type=type_hints.get(attr.name, attr.type),
                 alias=attr.name,
+                kw_only=getattr(attr, "kw_only", False),
             )
             for attr in attrs
         ]
@@ -129,7 +196,7 @@ def is_hetero_tuple(type: Any) -> bool:
 
 
 def is_protocol(type: Any) -> bool:
-    return issubclass(type, Protocol) and getattr(type, "_is_protocol", False)
+    return is_subclass(type, Protocol) and getattr(type, "_is_protocol", False)
 
 
 def is_bare_final(type) -> bool:
@@ -148,18 +215,20 @@ def get_final_base(type) -> Optional[type]:
 OriginAbstractSet = AbcSet
 OriginMutableSet = AbcMutableSet
 
+signature = _signature
+
+if sys.version_info >= (3, 10):
+    signature = partial(_signature, eval_str=True)
+
 if sys.version_info >= (3, 9):
     from collections import Counter
-    from collections.abc import Mapping as AbcMapping
-    from collections.abc import MutableMapping as AbcMutableMapping
     from collections.abc import MutableSequence as AbcMutableSequence
     from collections.abc import MutableSet as AbcMutableSet
     from collections.abc import Sequence as AbcSequence
     from collections.abc import Set as AbcSet
     from types import GenericAlias
-    from typing import Annotated
-    from typing import Counter as TypingCounter
     from typing import (
+        Annotated,
         Generic,
         TypedDict,
         Union,
@@ -168,15 +237,21 @@ if sys.version_info >= (3, 9):
         _SpecialGenericAlias,
         _UnionGenericAlias,
     )
+    from typing import Counter as TypingCounter
 
     try:
         # Not present on 3.9.0, so we try carefully.
         from typing import _LiteralGenericAlias
 
         def is_literal(type) -> bool:
-            return type.__class__ is _LiteralGenericAlias
+            return type in LITERALS or (
+                isinstance(
+                    type, (_GenericAlias, _LiteralGenericAlias, _SpecialGenericAlias)
+                )
+                and type.__origin__ in LITERALS
+            )
 
-    except ImportError:
+    except ImportError:  # pragma: no cover
 
         def is_literal(_) -> bool:
             return False
@@ -197,10 +272,17 @@ if sys.version_info >= (3, 9):
     def is_tuple(type):
         return (
             type in (Tuple, tuple)
-            or (type.__class__ is _GenericAlias and issubclass(type.__origin__, Tuple))
+            or (type.__class__ is _GenericAlias and is_subclass(type.__origin__, Tuple))
             or (getattr(type, "__origin__", None) is tuple)
         )
 
+    if sys.version_info >= (3, 12):
+        from typing import TypeAliasType
+
+        def is_type_alias(type: Any) -> bool:
+            """Is this a PEP 695 type alias?"""
+            return isinstance(type, TypeAliasType)
+
     if sys.version_info >= (3, 10):
 
         def is_union_type(obj):
@@ -243,11 +325,19 @@ if sys.version_info >= (3, 9):
             return None
 
     def get_notrequired_base(type) -> "Union[Any, Literal[NOTHING]]":
+        if is_annotated(type):
+            # Handle `Annotated[NotRequired[int]]`
+            type = get_args(type)[0]
         if get_origin(type) in (NotRequired, Required):
             return get_args(type)[0]
         return NOTHING
 
     def is_sequence(type: Any) -> bool:
+        """A predicate function for sequences.
+
+        Matches lists, sequences, mutable sequences, deques and homogenous
+        tuples.
+        """
         origin = getattr(type, "__origin__", None)
         return (
             type
@@ -266,7 +356,7 @@ if sys.version_info >= (3, 9):
                 type.__class__ is _GenericAlias
                 and (
                     (origin is not tuple)
-                    and issubclass(origin, TypingSequence)
+                    and is_subclass(origin, TypingSequence)
                     or origin is tuple
                     and type.__args__[1] is ...
                 )
@@ -278,26 +368,34 @@ if sys.version_info >= (3, 9):
     def is_deque(type):
         return (
             type in (deque, Deque)
-            or (type.__class__ is _GenericAlias and issubclass(type.__origin__, deque))
+            or (type.__class__ is _GenericAlias and is_subclass(type.__origin__, deque))
             or (getattr(type, "__origin__", None) is deque)
         )
 
-    def is_mutable_set(type):
+    def is_mutable_set(type: Any) -> bool:
+        """A predicate function for (mutable) sets.
+
+        Matches built-in sets and sets from the typing module.
+        """
         return (
             type in (TypingSet, TypingMutableSet, set)
             or (
                 type.__class__ is _GenericAlias
-                and issubclass(type.__origin__, TypingMutableSet)
+                and is_subclass(type.__origin__, TypingMutableSet)
             )
             or (getattr(type, "__origin__", None) in (set, AbcMutableSet, AbcSet))
         )
 
-    def is_frozenset(type):
+    def is_frozenset(type: Any) -> bool:
+        """A predicate function for frozensets.
+
+        Matches built-in frozensets and frozensets from the typing module.
+        """
         return (
             type in (FrozenSet, frozenset)
             or (
                 type.__class__ is _GenericAlias
-                and issubclass(type.__origin__, FrozenSet)
+                and is_subclass(type.__origin__, FrozenSet)
             )
             or (getattr(type, "__origin__", None) is frozenset)
         )
@@ -307,18 +405,17 @@ if sys.version_info >= (3, 9):
             not hasattr(type, "__origin__") and not hasattr(type, "__args__")
         )
 
-    def is_mapping(type):
+    def is_mapping(type: Any) -> bool:
+        """A predicate function for mappings."""
         return (
             type in (dict, Dict, TypingMapping, TypingMutableMapping, AbcMutableMapping)
             or (
                 type.__class__ is _GenericAlias
-                and issubclass(type.__origin__, TypingMapping)
+                and is_subclass(type.__origin__, TypingMapping)
             )
-            or (
-                getattr(type, "__origin__", None)
-                in (dict, AbcMutableMapping, AbcMapping)
+            or is_subclass(
+                getattr(type, "__origin__", type), (dict, AbcMutableMapping, AbcMapping)
             )
-            or issubclass(type, dict)
         )
 
     def is_counter(type):
@@ -327,12 +424,12 @@ if sys.version_info >= (3, 9):
             or getattr(type, "__origin__", None) is Counter
         )
 
-    def is_generic(obj) -> bool:
-        """Whether obj is a generic type."""
+    def is_generic(type) -> bool:
+        """Whether `type` is a generic type."""
         # Inheriting from protocol will inject `Generic` into the MRO
         # without `__orig_bases__`.
-        return isinstance(obj, (_GenericAlias, GenericAlias)) or (
-            is_subclass(obj, Generic) and hasattr(obj, "__orig_bases__")
+        return isinstance(type, (_GenericAlias, GenericAlias)) or (
+            is_subclass(type, Generic) and hasattr(type, "__orig_bases__")
         )
 
     def copy_with(type, args):
@@ -340,12 +437,16 @@ if sys.version_info >= (3, 9):
         if is_annotated(type):
             # typing.Annotated requires a special case.
             return Annotated[args]
+        if isinstance(args, tuple) and len(args) == 1:
+            # Some annotations can't handle 1-tuples.
+            args = args[0]
         return type.__origin__[args]
 
     def get_full_type_hints(obj, globalns=None, localns=None):
         return get_type_hints(obj, globalns, localns, include_extras=True)
 
 else:
+    # 3.8
     Set = TypingSet
     AbstractSet = TypingAbstractSet
     MutableSet = TypingMutableSet
@@ -368,7 +469,7 @@ else:
 
     def is_tuple(type):
         return type in (Tuple, tuple) or (
-            type.__class__ is _GenericAlias and issubclass(type.__origin__, Tuple)
+            type.__class__ is _GenericAlias and is_subclass(type.__origin__, Tuple)
         )
 
     def is_union_type(obj):
@@ -391,7 +492,7 @@ else:
             type.__class__ is _GenericAlias
             and (
                 type.__origin__ not in (Union, Tuple, tuple)
-                and issubclass(type.__origin__, TypingSequence)
+                and is_subclass(type.__origin__, TypingSequence)
             )
             or (type.__origin__ in (Tuple, tuple) and type.__args__[1] is ...)
         )
@@ -399,24 +500,32 @@ else:
     def is_deque(type: Any) -> bool:
         return (
             type in (deque, Deque)
-            or (type.__class__ is _GenericAlias and issubclass(type.__origin__, deque))
+            or (type.__class__ is _GenericAlias and is_subclass(type.__origin__, deque))
             or type.__origin__ is deque
         )
 
-    def is_mutable_set(type):
-        return type is set or (
-            type.__class__ is _GenericAlias and issubclass(type.__origin__, MutableSet)
+    def is_mutable_set(type) -> bool:
+        return type in (set, TypingAbstractSet) or (
+            type.__class__ is _GenericAlias
+            and is_subclass(type.__origin__, (MutableSet, TypingAbstractSet))
         )
 
     def is_frozenset(type):
         return type is frozenset or (
-            type.__class__ is _GenericAlias and issubclass(type.__origin__, FrozenSet)
+            type.__class__ is _GenericAlias and is_subclass(type.__origin__, FrozenSet)
         )
 
-    def is_mapping(type):
-        return type in (TypingMapping, dict) or (
-            type.__class__ is _GenericAlias
-            and issubclass(type.__origin__, TypingMapping)
+    def is_mapping(type: Any) -> bool:
+        """A predicate function for mappings."""
+        return (
+            type in (TypingMapping, dict)
+            or (
+                type.__class__ is _GenericAlias
+                and is_subclass(type.__origin__, TypingMapping)
+            )
+            or is_subclass(
+                getattr(type, "__origin__", type), (dict, AbcMutableMapping, AbcMapping)
+            )
         )
 
     bare_generic_args = {
@@ -438,10 +547,10 @@ else:
             or getattr(type, "__origin__", None) is ColCounter
         )
 
-    from typing import Literal
-
     def is_literal(type) -> bool:
-        return type.__class__ is _GenericAlias and type.__origin__ is Literal
+        return type in LITERALS or (
+            isinstance(type, _GenericAlias) and type.__origin__ in LITERALS
+        )
 
     def is_generic(obj):
         return isinstance(obj, _GenericAlias) or (
@@ -453,6 +562,10 @@ else:
         return type.copy_with(args)
 
     def get_notrequired_base(type) -> "Union[Any, Literal[NOTHING]]":
+        if is_annotated(type):
+            # Handle `Annotated[NotRequired[int]]`
+            type = get_origin(type)
+
         if get_origin(type) in (NotRequired, Required):
             return get_args(type)[0]
         return NOTHING
@@ -461,5 +574,6 @@ else:
         return get_type_hints(obj, globalns, localns)
 
 
-def is_generic_attrs(type):
+def is_generic_attrs(type) -> bool:
+    """Return True for both specialized (A[int]) and unspecialized (A) generics."""
     return is_generic(type) and has(type.__origin__)

jaclang/vendor/cattrs/_generics.py

@@ -12,9 +12,11 @@ def deep_copy_with(t, mapping: Mapping[str, Any]):
         args = (args[0],)
     new_args = (
         tuple(
-            mapping[a.__name__]
-            if hasattr(a, "__name__") and a.__name__ in mapping
-            else (deep_copy_with(a, mapping) if is_generic(a) else a)
+            (
+                mapping[a.__name__]
+                if hasattr(a, "__name__") and a.__name__ in mapping
+                else (deep_copy_with(a, mapping) if is_generic(a) else a)
+            )
             for a in args
         )
         + rest