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

jaclang/vendor/attr/_cmp.py

@@ -4,7 +4,7 @@
 import functools
 import types
 
-from ._make import _make_ne
+from ._make import __ne__
 
 
 _operation_names = {"eq": "==", "lt": "<", "le": "<=", "gt": ">", "ge": ">="}
@@ -26,21 +26,31 @@ def cmp_using(
     The resulting class will have a full set of ordering methods if at least
     one of ``{lt, le, gt, ge}`` and ``eq``  are provided.
 
-    :param Optional[callable] eq: `callable` used to evaluate equality of two
-        objects.
-    :param Optional[callable] lt: `callable` used to evaluate whether one
-        object is less than another object.
-    :param Optional[callable] le: `callable` used to evaluate whether one
-        object is less than or equal to another object.
-    :param Optional[callable] gt: `callable` used to evaluate whether one
-        object is greater than another object.
-    :param Optional[callable] ge: `callable` used to evaluate whether one
-        object is greater than or equal to another object.
+    Args:
+        eq (typing.Callable | None):
+            Callable used to evaluate equality of two objects.
 
-    :param bool require_same_type: When `True`, equality and ordering methods
-        will return `NotImplemented` if objects are not of the same type.
+        lt (typing.Callable | None):
+            Callable used to evaluate whether one object is less than another
+            object.
 
-    :param Optional[str] class_name: Name of class. Defaults to 'Comparable'.
+        le (typing.Callable | None):
+            Callable used to evaluate whether one object is less than or equal
+            to another object.
+
+        gt (typing.Callable | None):
+            Callable used to evaluate whether one object is greater than
+            another object.
+
+        ge (typing.Callable | None):
+            Callable used to evaluate whether one object is greater than or
+            equal to another object.
+
+        require_same_type (bool):
+            When `True`, equality and ordering methods will return
+            `NotImplemented` if objects are not of the same type.
+
+        class_name (str | None): Name of class. Defaults to "Comparable".
 
     See `comparison` for more details.
 
@@ -61,7 +71,7 @@ def cmp_using(
     if eq is not None:
         has_eq_function = True
         body["__eq__"] = _make_operator("eq", eq)
-        body["__ne__"] = _make_ne()
+        body["__ne__"] = __ne__
 
     if lt is not None:
         num_order_functions += 1

jaclang/vendor/attr/_cmp.pyi

@@ -1,13 +1,13 @@
-from typing import Any, Callable, Optional, Type
+from typing import Any, Callable
 
 _CompareWithType = Callable[[Any, Any], bool]
 
 def cmp_using(
-    eq: Optional[_CompareWithType] = ...,
-    lt: Optional[_CompareWithType] = ...,
-    le: Optional[_CompareWithType] = ...,
-    gt: Optional[_CompareWithType] = ...,
-    ge: Optional[_CompareWithType] = ...,
+    eq: _CompareWithType | None = ...,
+    lt: _CompareWithType | None = ...,
+    le: _CompareWithType | None = ...,
+    gt: _CompareWithType | None = ...,
+    ge: _CompareWithType | None = ...,
     require_same_type: bool = ...,
     class_name: str = ...,
-) -> Type: ...
+) -> type: ...

jaclang/vendor/attr/_compat.py

@@ -10,19 +10,26 @@ from typing import _GenericAlias
 
 
 PYPY = platform.python_implementation() == "PyPy"
-PY_3_8_PLUS = sys.version_info[:2] >= (3, 8)
 PY_3_9_PLUS = sys.version_info[:2] >= (3, 9)
-PY310 = sys.version_info[:2] >= (3, 10)
+PY_3_10_PLUS = sys.version_info[:2] >= (3, 10)
+PY_3_11_PLUS = sys.version_info[:2] >= (3, 11)
 PY_3_12_PLUS = sys.version_info[:2] >= (3, 12)
+PY_3_13_PLUS = sys.version_info[:2] >= (3, 13)
+PY_3_14_PLUS = sys.version_info[:2] >= (3, 14)
 
 
-if sys.version_info < (3, 8):
-    try:
-        from typing_extensions import Protocol
-    except ImportError:  # pragma: no cover
-        Protocol = object
+if PY_3_14_PLUS:  # pragma: no cover
+    import annotationlib
+
+    _get_annotations = annotationlib.get_annotations
+
 else:
-    from typing import Protocol  # noqa: F401
+
+    def _get_annotations(cls):
+        """
+        Get annotations for *cls*.
+        """
+        return cls.__dict__.get("__annotations__", {})
 
 
 class _AnnotationExtractor:

jaclang/vendor/attr/_config.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 
-__all__ = ["set_run_validators", "get_run_validators"]
+__all__ = ["get_run_validators", "set_run_validators"]
 
 _run_validators = True
 

jaclang/vendor/attr/_funcs.py

@@ -4,7 +4,7 @@
 import copy
 
 from ._compat import PY_3_9_PLUS, get_generic_base
-from ._make import NOTHING, _obj_setattr, fields
+from ._make import _OBJ_SETATTR, NOTHING, fields
 from .exceptions import AttrsAttributeNotFoundError
 
 
@@ -21,34 +21,44 @@ def asdict(
 
     Optionally recurse into other *attrs*-decorated classes.
 
-    :param inst: Instance of an *attrs*-decorated class.
-    :param bool recurse: Recurse into classes that are also
-        *attrs*-decorated.
-    :param callable filter: A callable whose return code determines whether an
-        attribute or element is included (``True``) or dropped (``False``).  Is
-        called with the `attrs.Attribute` as the first argument and the
-        value as the second argument.
-    :param callable dict_factory: A callable to produce dictionaries from.  For
-        example, to produce ordered dictionaries instead of normal Python
-        dictionaries, pass in ``collections.OrderedDict``.
-    :param bool retain_collection_types: Do not convert to ``list`` when
-        encountering an attribute whose type is ``tuple`` or ``set``.  Only
-        meaningful if ``recurse`` is ``True``.
-    :param Optional[callable] value_serializer: A hook that is called for every
-        attribute or dict key/value.  It receives the current instance, field
-        and value and must return the (updated) value.  The hook is run *after*
-        the optional *filter* has been applied.
-
-    :rtype: return type of *dict_factory*
-
-    :raise attrs.exceptions.NotAnAttrsClassError: If *cls* is not an *attrs*
-        class.
+    Args:
+        inst: Instance of an *attrs*-decorated class.
+
+        recurse (bool): Recurse into classes that are also *attrs*-decorated.
+
+        filter (~typing.Callable):
+            A callable whose return code determines whether an attribute or
+            element is included (`True`) or dropped (`False`).  Is called with
+            the `attrs.Attribute` as the first argument and the value as the
+            second argument.
+
+        dict_factory (~typing.Callable):
+            A callable to produce dictionaries from.  For example, to produce
+            ordered dictionaries instead of normal Python dictionaries, pass in
+            ``collections.OrderedDict``.
+
+        retain_collection_types (bool):
+            Do not convert to `list` when encountering an attribute whose type
+            is `tuple` or `set`.  Only meaningful if *recurse* is `True`.
+
+        value_serializer (typing.Callable | None):
+            A hook that is called for every attribute or dict key/value.  It
+            receives the current instance, field and value and must return the
+            (updated) value.  The hook is run *after* the optional *filter* has
+            been applied.
+
+    Returns:
+        Return type of *dict_factory*.
+
+    Raises:
+        attrs.exceptions.NotAnAttrsClassError:
+            If *cls* is not an *attrs* class.
 
     ..  versionadded:: 16.0.0 *dict_factory*
     ..  versionadded:: 16.1.0 *retain_collection_types*
     ..  versionadded:: 20.3.0 *value_serializer*
-    ..  versionadded:: 21.3.0 If a dict has a collection for a key, it is
-        serialized as a tuple.
+    ..  versionadded:: 21.3.0
+        If a dict has a collection for a key, it is serialized as a tuple.
     """
     attrs = fields(inst.__class__)
     rv = dict_factory()
@@ -206,24 +216,33 @@ def astuple(
 
     Optionally recurse into other *attrs*-decorated classes.
 
-    :param inst: Instance of an *attrs*-decorated class.
-    :param bool recurse: Recurse into classes that are also
-        *attrs*-decorated.
-    :param callable filter: A callable whose return code determines whether an
-        attribute or element is included (``True``) or dropped (``False``).  Is
-        called with the `attrs.Attribute` as the first argument and the
-        value as the second argument.
-    :param callable tuple_factory: A callable to produce tuples from.  For
-        example, to produce lists instead of tuples.
-    :param bool retain_collection_types: Do not convert to ``list``
-        or ``dict`` when encountering an attribute which type is
-        ``tuple``, ``dict`` or ``set``.  Only meaningful if ``recurse`` is
-        ``True``.
-
-    :rtype: return type of *tuple_factory*
-
-    :raise attrs.exceptions.NotAnAttrsClassError: If *cls* is not an *attrs*
-        class.
+    Args:
+        inst: Instance of an *attrs*-decorated class.
+
+        recurse (bool):
+            Recurse into classes that are also *attrs*-decorated.
+
+        filter (~typing.Callable):
+            A callable whose return code determines whether an attribute or
+            element is included (`True`) or dropped (`False`).  Is called with
+            the `attrs.Attribute` as the first argument and the value as the
+            second argument.
+
+        tuple_factory (~typing.Callable):
+            A callable to produce tuples from. For example, to produce lists
+            instead of tuples.
+
+        retain_collection_types (bool):
+            Do not convert to `list` or `dict` when encountering an attribute
+            which type is `tuple`, `dict` or `set`. Only meaningful if
+            *recurse* is `True`.
+
+    Returns:
+        Return type of *tuple_factory*
+
+    Raises:
+        attrs.exceptions.NotAnAttrsClassError:
+            If *cls* is not an *attrs* class.
 
     ..  versionadded:: 16.2.0
     """
@@ -248,15 +267,17 @@ def astuple(
             elif isinstance(v, (tuple, list, set, frozenset)):
                 cf = v.__class__ if retain is True else list
                 items = [
-                    astuple(
-                        j,
-                        recurse=True,
-                        filter=filter,
-                        tuple_factory=tuple_factory,
-                        retain_collection_types=retain,
+                    (
+                        astuple(
+                            j,
+                            recurse=True,
+                            filter=filter,
+                            tuple_factory=tuple_factory,
+                            retain_collection_types=retain,
+                        )
+                        if has(j.__class__)
+                        else j
                     )
-                    if has(j.__class__)
-                    else j
                     for j in v
                 ]
                 try:
@@ -272,20 +293,24 @@ def astuple(
                 rv.append(
                     df(
                         (
-                            astuple(
-                                kk,
-                                tuple_factory=tuple_factory,
-                                retain_collection_types=retain,
-                            )
-                            if has(kk.__class__)
-                            else kk,
-                            astuple(
-                                vv,
-                                tuple_factory=tuple_factory,
-                                retain_collection_types=retain,
-                            )
-                            if has(vv.__class__)
-                            else vv,
+                            (
+                                astuple(
+                                    kk,
+                                    tuple_factory=tuple_factory,
+                                    retain_collection_types=retain,
+                                )
+                                if has(kk.__class__)
+                                else kk
+                            ),
+                            (
+                                astuple(
+                                    vv,
+                                    tuple_factory=tuple_factory,
+                                    retain_collection_types=retain,
+                                )
+                                if has(vv.__class__)
+                                else vv
+                            ),
                         )
                         for kk, vv in v.items()
                     )
@@ -302,10 +327,14 @@ def has(cls):
     """
     Check whether *cls* is a class with *attrs* attributes.
 
-    :param type cls: Class to introspect.
-    :raise TypeError: If *cls* is not a class.
+    Args:
+        cls (type): Class to introspect.
+
+    Raises:
+        TypeError: If *cls* is not a class.
 
-    :rtype: bool
+    Returns:
+        bool:
     """
     attrs = getattr(cls, "__attrs_attrs__", None)
     if attrs is not None:
@@ -334,20 +363,25 @@ def assoc(inst, **changes):
 
     .. _`edge cases`: https://github.com/python-attrs/attrs/issues/251
 
-    :param inst: Instance of a class with *attrs* attributes.
-    :param changes: Keyword changes in the new copy.
+    Args:
+        inst: Instance of a class with *attrs* attributes.
 
-    :return: A copy of inst with *changes* incorporated.
+        changes: Keyword changes in the new copy.
 
-    :raise attrs.exceptions.AttrsAttributeNotFoundError: If *attr_name*
-        couldn't be found on *cls*.
-    :raise attrs.exceptions.NotAnAttrsClassError: If *cls* is not an *attrs*
-        class.
+    Returns:
+        A copy of inst with *changes* incorporated.
+
+    Raises:
+        attrs.exceptions.AttrsAttributeNotFoundError:
+            If *attr_name* couldn't be found on *cls*.
+
+        attrs.exceptions.NotAnAttrsClassError:
+            If *cls* is not an *attrs* class.
 
     ..  deprecated:: 17.1.0
-        Use `attrs.evolve` instead if you can.
-        This function will not be removed du to the slightly different approach
-        compared to `attrs.evolve`.
+        Use `attrs.evolve` instead if you can. This function will not be
+        removed du to the slightly different approach compared to
+        `attrs.evolve`, though.
     """
     new = copy.copy(inst)
     attrs = fields(inst.__class__)
@@ -356,109 +390,60 @@ def assoc(inst, **changes):
         if a is NOTHING:
             msg = f"{k} is not an attrs attribute on {new.__class__}."
             raise AttrsAttributeNotFoundError(msg)
-        _obj_setattr(new, k, v)
+        _OBJ_SETATTR(new, k, v)
     return new
 
 
-def evolve(*args, **changes):
+def resolve_types(
+    cls, globalns=None, localns=None, attribs=None, include_extras=True
+):
     """
-    Create a new instance, based on the first positional argument with
-    *changes* applied.
+    Resolve any strings and forward annotations in type annotations.
 
-    :param inst: Instance of a class with *attrs* attributes.
-    :param changes: Keyword changes in the new copy.
+    This is only required if you need concrete types in :class:`Attribute`'s
+    *type* field. In other words, you don't need to resolve your types if you
+    only use them for static type checking.
 
-    :return: A copy of inst with *changes* incorporated.
+    With no arguments, names will be looked up in the module in which the class
+    was created. If this is not what you want, for example, if the name only
+    exists inside a method, you may pass *globalns* or *localns* to specify
+    other dictionaries in which to look up these names. See the docs of
+    `typing.get_type_hints` for more details.
 
-    :raise TypeError: If *attr_name* couldn't be found in the class
-        ``__init__``.
-    :raise attrs.exceptions.NotAnAttrsClassError: If *cls* is not an *attrs*
-        class.
+    Args:
+        cls (type): Class to resolve.
 
-    .. versionadded:: 17.1.0
-    .. deprecated:: 23.1.0
-       It is now deprecated to pass the instance using the keyword argument
-       *inst*. It will raise a warning until at least April 2024, after which
-       it will become an error. Always pass the instance as a positional
-       argument.
-    """
-    # Try to get instance by positional argument first.
-    # Use changes otherwise and warn it'll break.
-    if args:
-        try:
-            (inst,) = args
-        except ValueError:
-            msg = f"evolve() takes 1 positional argument, but {len(args)} were given"
-            raise TypeError(msg) from None
-    else:
-        try:
-            inst = changes.pop("inst")
-        except KeyError:
-            msg = "evolve() missing 1 required positional argument: 'inst'"
-            raise TypeError(msg) from None
-
-        import warnings
-
-        warnings.warn(
-            "Passing the instance per keyword argument is deprecated and "
-            "will stop working in, or after, April 2024.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
+        globalns (dict | None): Dictionary containing global variables.
 
-    cls = inst.__class__
-    attrs = fields(cls)
-    for a in attrs:
-        if not a.init:
-            continue
-        attr_name = a.name  # To deal with private attributes.
-        init_name = a.alias
-        if init_name not in changes:
-            changes[init_name] = getattr(inst, attr_name)
+        localns (dict | None): Dictionary containing local variables.
 
-    return cls(**changes)
+        attribs (list | None):
+            List of attribs for the given class. This is necessary when calling
+            from inside a ``field_transformer`` since *cls* is not an *attrs*
+            class yet.
 
+        include_extras (bool):
+            Resolve more accurately, if possible. Pass ``include_extras`` to
+            ``typing.get_hints``, if supported by the typing module. On
+            supported Python versions (3.9+), this resolves the types more
+            accurately.
 
-def resolve_types(
-    cls, globalns=None, localns=None, attribs=None, include_extras=True
-):
-    """
-    Resolve any strings and forward annotations in type annotations.
+    Raises:
+        TypeError: If *cls* is not a class.
 
-    This is only required if you need concrete types in `Attribute`'s *type*
-    field. In other words, you don't need to resolve your types if you only
-    use them for static type checking.
+        attrs.exceptions.NotAnAttrsClassError:
+            If *cls* is not an *attrs* class and you didn't pass any attribs.
 
-    With no arguments, names will be looked up in the module in which the class
-    was created. If this is not what you want, e.g. if the name only exists
-    inside a method, you may pass *globalns* or *localns* to specify other
-    dictionaries in which to look up these names. See the docs of
-    `typing.get_type_hints` for more details.
+        NameError: If types cannot be resolved because of missing variables.
 
-    :param type cls: Class to resolve.
-    :param Optional[dict] globalns: Dictionary containing global variables.
-    :param Optional[dict] localns: Dictionary containing local variables.
-    :param Optional[list] attribs: List of attribs for the given class.
-        This is necessary when calling from inside a ``field_transformer``
-        since *cls* is not an *attrs* class yet.
-    :param bool include_extras: Resolve more accurately, if possible.
-        Pass ``include_extras`` to ``typing.get_hints``, if supported by the
-        typing module. On supported Python versions (3.9+), this resolves the
-        types more accurately.
-
-    :raise TypeError: If *cls* is not a class.
-    :raise attrs.exceptions.NotAnAttrsClassError: If *cls* is not an *attrs*
-        class and you didn't pass any attribs.
-    :raise NameError: If types cannot be resolved because of missing variables.
-
-    :returns: *cls* so you can use this function also as a class decorator.
-        Please note that you have to apply it **after** `attrs.define`. That
-        means the decorator has to come in the line **before** `attrs.define`.
+    Returns:
+        *cls* so you can use this function also as a class decorator. Please
+        note that you have to apply it **after** `attrs.define`. That means the
+        decorator has to come in the line **before** `attrs.define`.
 
     ..  versionadded:: 20.1.0
     ..  versionadded:: 21.1.0 *attribs*
     ..  versionadded:: 23.1.0 *include_extras*
-
     """
     # Since calling get_type_hints is expensive we cache whether we've
     # done it already.
@@ -474,7 +459,7 @@ def resolve_types(
         for field in fields(cls) if attribs is None else attribs:
             if field.name in hints:
                 # Since fields have been frozen we must work around it.
-                _obj_setattr(field, "type", hints[field.name])
+                _OBJ_SETATTR(field, "type", hints[field.name])
         # We store the class we resolved so that subclasses know they haven't
         # been resolved.
         cls.__attrs_types_resolved__ = cls