@motiadev/core 0.2.1-beta.57 → 0.2.1-beta.59

package/python_modules/lib/python3.11/site-packages/jsonschema/exceptions.py

@@ -1,484 +0,0 @@
-"""
-Validation errors, and some surrounding helpers.
-"""
-from __future__ import annotations
-
-from collections import defaultdict, deque
-from pprint import pformat
-from textwrap import dedent, indent
-from typing import TYPE_CHECKING, Any, ClassVar
-import heapq
-import warnings
-
-from attrs import define
-from referencing.exceptions import Unresolvable as _Unresolvable
-
-from jsonschema import _utils
-
-if TYPE_CHECKING:
-    from collections.abc import Iterable, Mapping, MutableMapping, Sequence
-
-    from jsonschema import _types
-
-WEAK_MATCHES: frozenset[str] = frozenset(["anyOf", "oneOf"])
-STRONG_MATCHES: frozenset[str] = frozenset()
-
-_unset = _utils.Unset()
-
-
-def _pretty(thing: Any, prefix: str):
-    """
-    Format something for an error message as prettily as we currently can.
-    """
-    return indent(pformat(thing, width=72, sort_dicts=False), prefix).lstrip()
-
-
-def __getattr__(name):
-    if name == "RefResolutionError":
-        warnings.warn(
-            _RefResolutionError._DEPRECATION_MESSAGE,
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        return _RefResolutionError
-    raise AttributeError(f"module {__name__} has no attribute {name}")
-
-
-class _Error(Exception):
-
-    _word_for_schema_in_error_message: ClassVar[str]
-    _word_for_instance_in_error_message: ClassVar[str]
-
-    def __init__(
-        self,
-        message: str,
-        validator: str = _unset,  # type: ignore[assignment]
-        path: Iterable[str | int] = (),
-        cause: Exception | None = None,
-        context=(),
-        validator_value: Any = _unset,
-        instance: Any = _unset,
-        schema: Mapping[str, Any] | bool = _unset,  # type: ignore[assignment]
-        schema_path: Iterable[str | int] = (),
-        parent: _Error | None = None,
-        type_checker: _types.TypeChecker = _unset,  # type: ignore[assignment]
-    ) -> None:
-        super().__init__(
-            message,
-            validator,
-            path,
-            cause,
-            context,
-            validator_value,
-            instance,
-            schema,
-            schema_path,
-            parent,
-        )
-        self.message = message
-        self.path = self.relative_path = deque(path)
-        self.schema_path = self.relative_schema_path = deque(schema_path)
-        self.context = list(context)
-        self.cause = self.__cause__ = cause
-        self.validator = validator
-        self.validator_value = validator_value
-        self.instance = instance
-        self.schema = schema
-        self.parent = parent
-        self._type_checker = type_checker
-
-        for error in context:
-            error.parent = self
-
-    def __repr__(self) -> str:
-        return f"<{self.__class__.__name__}: {self.message!r}>"
-
-    def __str__(self) -> str:
-        essential_for_verbose = (
-            self.validator, self.validator_value, self.instance, self.schema,
-        )
-        if any(m is _unset for m in essential_for_verbose):
-            return self.message
-
-        schema_path = _utils.format_as_index(
-            container=self._word_for_schema_in_error_message,
-            indices=list(self.relative_schema_path)[:-1],
-        )
-        instance_path = _utils.format_as_index(
-            container=self._word_for_instance_in_error_message,
-            indices=self.relative_path,
-        )
-        prefix = 16 * " "
-
-        return dedent(
-            f"""\
-            {self.message}
-
-            Failed validating {self.validator!r} in {schema_path}:
-                {_pretty(self.schema, prefix=prefix)}
-
-            On {instance_path}:
-                {_pretty(self.instance, prefix=prefix)}
-            """.rstrip(),
-        )
-
-    @classmethod
-    def create_from(cls, other: _Error):
-        return cls(**other._contents())
-
-    @property
-    def absolute_path(self) -> Sequence[str | int]:
-        parent = self.parent
-        if parent is None:
-            return self.relative_path
-
-        path = deque(self.relative_path)
-        path.extendleft(reversed(parent.absolute_path))
-        return path
-
-    @property
-    def absolute_schema_path(self) -> Sequence[str | int]:
-        parent = self.parent
-        if parent is None:
-            return self.relative_schema_path
-
-        path = deque(self.relative_schema_path)
-        path.extendleft(reversed(parent.absolute_schema_path))
-        return path
-
-    @property
-    def json_path(self) -> str:
-        path = "$"
-        for elem in self.absolute_path:
-            if isinstance(elem, int):
-                path += "[" + str(elem) + "]"
-            else:
-                path += "." + elem
-        return path
-
-    def _set(
-        self,
-        type_checker: _types.TypeChecker | None = None,
-        **kwargs: Any,
-    ) -> None:
-        if type_checker is not None and self._type_checker is _unset:
-            self._type_checker = type_checker
-
-        for k, v in kwargs.items():
-            if getattr(self, k) is _unset:
-                setattr(self, k, v)
-
-    def _contents(self):
-        attrs = (
-            "message", "cause", "context", "validator", "validator_value",
-            "path", "schema_path", "instance", "schema", "parent",
-        )
-        return {attr: getattr(self, attr) for attr in attrs}
-
-    def _matches_type(self) -> bool:
-        try:
-            # We ignore this as we want to simply crash if this happens
-            expected = self.schema["type"]  # type: ignore[index]
-        except (KeyError, TypeError):
-            return False
-
-        if isinstance(expected, str):
-            return self._type_checker.is_type(self.instance, expected)
-
-        return any(
-            self._type_checker.is_type(self.instance, expected_type)
-            for expected_type in expected
-        )
-
-
-class ValidationError(_Error):
-    """
-    An instance was invalid under a provided schema.
-    """
-
-    _word_for_schema_in_error_message = "schema"
-    _word_for_instance_in_error_message = "instance"
-
-
-class SchemaError(_Error):
-    """
-    A schema was invalid under its corresponding metaschema.
-    """
-
-    _word_for_schema_in_error_message = "metaschema"
-    _word_for_instance_in_error_message = "schema"
-
-
-@define(slots=False)
-class _RefResolutionError(Exception):
-    """
-    A ref could not be resolved.
-    """
-
-    _DEPRECATION_MESSAGE = (
-        "jsonschema.exceptions.RefResolutionError is deprecated as of version "
-        "4.18.0. If you wish to catch potential reference resolution errors, "
-        "directly catch referencing.exceptions.Unresolvable."
-    )
-
-    _cause: Exception
-
-    def __eq__(self, other):
-        if self.__class__ is not other.__class__:
-            return NotImplemented  # pragma: no cover -- uncovered but deprecated  # noqa: E501
-        return self._cause == other._cause
-
-    def __str__(self) -> str:
-        return str(self._cause)
-
-
-class _WrappedReferencingError(_RefResolutionError, _Unresolvable):  # pragma: no cover -- partially uncovered but to be removed  # noqa: E501
-    def __init__(self, cause: _Unresolvable):
-        object.__setattr__(self, "_wrapped", cause)
-
-    def __eq__(self, other):
-        if other.__class__ is self.__class__:
-            return self._wrapped == other._wrapped
-        elif other.__class__ is self._wrapped.__class__:
-            return self._wrapped == other
-        return NotImplemented
-
-    def __getattr__(self, attr):
-        return getattr(self._wrapped, attr)
-
-    def __hash__(self):
-        return hash(self._wrapped)
-
-    def __repr__(self):
-        return f"<WrappedReferencingError {self._wrapped!r}>"
-
-    def __str__(self):
-        return f"{self._wrapped.__class__.__name__}: {self._wrapped}"
-
-
-class UndefinedTypeCheck(Exception):
-    """
-    A type checker was asked to check a type it did not have registered.
-    """
-
-    def __init__(self, type: str) -> None:
-        self.type = type
-
-    def __str__(self) -> str:
-        return f"Type {self.type!r} is unknown to this type checker"
-
-
-class UnknownType(Exception):
-    """
-    A validator was asked to validate an instance against an unknown type.
-    """
-
-    def __init__(self, type, instance, schema):
-        self.type = type
-        self.instance = instance
-        self.schema = schema
-
-    def __str__(self):
-        prefix = 16 * " "
-
-        return dedent(
-            f"""\
-            Unknown type {self.type!r} for validator with schema:
-                {_pretty(self.schema, prefix=prefix)}
-
-            While checking instance:
-                {_pretty(self.instance, prefix=prefix)}
-            """.rstrip(),
-        )
-
-
-class FormatError(Exception):
-    """
-    Validating a format failed.
-    """
-
-    def __init__(self, message, cause=None):
-        super().__init__(message, cause)
-        self.message = message
-        self.cause = self.__cause__ = cause
-
-    def __str__(self):
-        return self.message
-
-
-class ErrorTree:
-    """
-    ErrorTrees make it easier to check which validations failed.
-    """
-
-    _instance = _unset
-
-    def __init__(self, errors: Iterable[ValidationError] = ()):
-        self.errors: MutableMapping[str, ValidationError] = {}
-        self._contents: Mapping[str, ErrorTree] = defaultdict(self.__class__)
-
-        for error in errors:
-            container = self
-            for element in error.path:
-                container = container[element]
-            container.errors[error.validator] = error
-
-            container._instance = error.instance
-
-    def __contains__(self, index: str | int):
-        """
-        Check whether ``instance[index]`` has any errors.
-        """
-        return index in self._contents
-
-    def __getitem__(self, index):
-        """
-        Retrieve the child tree one level down at the given ``index``.
-
-        If the index is not in the instance that this tree corresponds
-        to and is not known by this tree, whatever error would be raised
-        by ``instance.__getitem__`` will be propagated (usually this is
-        some subclass of `LookupError`.
-        """
-        if self._instance is not _unset and index not in self:
-            self._instance[index]
-        return self._contents[index]
-
-    def __setitem__(self, index: str | int, value: ErrorTree):
-        """
-        Add an error to the tree at the given ``index``.
-
-        .. deprecated:: v4.20.0
-
-            Setting items on an `ErrorTree` is deprecated without replacement.
-            To populate a tree, provide all of its sub-errors when you
-            construct the tree.
-        """
-        warnings.warn(
-            "ErrorTree.__setitem__ is deprecated without replacement.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        self._contents[index] = value  # type: ignore[index]
-
-    def __iter__(self):
-        """
-        Iterate (non-recursively) over the indices in the instance with errors.
-        """
-        return iter(self._contents)
-
-    def __len__(self):
-        """
-        Return the `total_errors`.
-        """
-        return self.total_errors
-
-    def __repr__(self):
-        total = len(self)
-        errors = "error" if total == 1 else "errors"
-        return f"<{self.__class__.__name__} ({total} total {errors})>"
-
-    @property
-    def total_errors(self):
-        """
-        The total number of errors in the entire tree, including children.
-        """
-        child_errors = sum(len(tree) for _, tree in self._contents.items())
-        return len(self.errors) + child_errors
-
-
-def by_relevance(weak=WEAK_MATCHES, strong=STRONG_MATCHES):
-    """
-    Create a key function that can be used to sort errors by relevance.
-
-    Arguments:
-        weak (set):
-            a collection of validation keywords to consider to be
-            "weak".  If there are two errors at the same level of the
-            instance and one is in the set of weak validation keywords,
-            the other error will take priority. By default, :kw:`anyOf`
-            and :kw:`oneOf` are considered weak keywords and will be
-            superseded by other same-level validation errors.
-
-        strong (set):
-            a collection of validation keywords to consider to be
-            "strong"
-
-    """
-
-    def relevance(error):
-        validator = error.validator
-        return (                        # prefer errors which are ...
-            -len(error.path),           # 'deeper' and thereby more specific
-            error.path,                 # earlier (for sibling errors)
-            validator not in weak,      # for a non-low-priority keyword
-            validator in strong,        # for a high priority keyword
-            not error._matches_type(),  # at least match the instance's type
-        )                               # otherwise we'll treat them the same
-
-    return relevance
-
-
-relevance = by_relevance()
-"""
-A key function (e.g. to use with `sorted`) which sorts errors by relevance.
-
-Example:
-
-.. code:: python
-
-    sorted(validator.iter_errors(12), key=jsonschema.exceptions.relevance)
-"""
-
-
-def best_match(errors, key=relevance):
-    """
-    Try to find an error that appears to be the best match among given errors.
-
-    In general, errors that are higher up in the instance (i.e. for which
-    `ValidationError.path` is shorter) are considered better matches,
-    since they indicate "more" is wrong with the instance.
-
-    If the resulting match is either :kw:`oneOf` or :kw:`anyOf`, the
-    *opposite* assumption is made -- i.e. the deepest error is picked,
-    since these keywords only need to match once, and any other errors
-    may not be relevant.
-
-    Arguments:
-        errors (collections.abc.Iterable):
-
-            the errors to select from. Do not provide a mixture of
-            errors from different validation attempts (i.e. from
-            different instances or schemas), since it won't produce
-            sensical output.
-
-        key (collections.abc.Callable):
-
-            the key to use when sorting errors. See `relevance` and
-            transitively `by_relevance` for more details (the default is
-            to sort with the defaults of that function). Changing the
-            default is only useful if you want to change the function
-            that rates errors but still want the error context descent
-            done by this function.
-
-    Returns:
-        the best matching error, or ``None`` if the iterable was empty
-
-    .. note::
-
-        This function is a heuristic. Its return value may change for a given
-        set of inputs from version to version if better heuristics are added.
-
-    """
-    best = max(errors, key=key, default=None)
-    if best is None:
-        return
-
-    while best.context:
-        # Calculate the minimum via nsmallest, because we don't recurse if
-        # all nested errors have the same relevance (i.e. if min == max == all)
-        smallest = heapq.nsmallest(2, best.context, key=key)
-        if len(smallest) == 2 and key(smallest[0]) == key(smallest[1]):  # noqa: PLR2004
-            return best
-        best = smallest[0]
-    return best

package/python_modules/lib/python3.11/site-packages/jsonschema/protocols.py

@@ -1,229 +0,0 @@
-"""
-typing.Protocol classes for jsonschema interfaces.
-"""
-
-# for reference material on Protocols, see
-#   https://www.python.org/dev/peps/pep-0544/
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any, ClassVar, Protocol, runtime_checkable
-
-# in order for Sphinx to resolve references accurately from type annotations,
-# it needs to see names like `jsonschema.TypeChecker`
-# therefore, only import at type-checking time (to avoid circular references),
-# but use `jsonschema` for any types which will otherwise not be resolvable
-if TYPE_CHECKING:
-    from collections.abc import Iterable, Mapping
-
-    import referencing.jsonschema
-
-    from jsonschema import _typing
-    from jsonschema.exceptions import ValidationError
-    import jsonschema
-    import jsonschema.validators
-
-# For code authors working on the validator protocol, these are the three
-# use-cases which should be kept in mind:
-#
-# 1. As a protocol class, it can be used in type annotations to describe the
-#    available methods and attributes of a validator
-# 2. It is the source of autodoc for the validator documentation
-# 3. It is runtime_checkable, meaning that it can be used in isinstance()
-#    checks.
-#
-# Since protocols are not base classes, isinstance() checking is limited in
-# its capabilities. See docs on runtime_checkable for detail
-
-
-@runtime_checkable
-class Validator(Protocol):
-    """
-    The protocol to which all validator classes adhere.
-
-    Arguments:
-
-        schema:
-
-            The schema that the validator object will validate with.
-            It is assumed to be valid, and providing
-            an invalid schema can lead to undefined behavior. See
-            `Validator.check_schema` to validate a schema first.
-
-        registry:
-
-            a schema registry that will be used for looking up JSON references
-
-        resolver:
-
-            a resolver that will be used to resolve :kw:`$ref`
-            properties (JSON references). If unprovided, one will be created.
-
-            .. deprecated:: v4.18.0
-
-                `RefResolver <_RefResolver>` has been deprecated in favor of
-                `referencing`, and with it, this argument.
-
-        format_checker:
-
-            if provided, a checker which will be used to assert about
-            :kw:`format` properties present in the schema. If unprovided,
-            *no* format validation is done, and the presence of format
-            within schemas is strictly informational. Certain formats
-            require additional packages to be installed in order to assert
-            against instances. Ensure you've installed `jsonschema` with
-            its `extra (optional) dependencies <index:extras>` when
-            invoking ``pip``.
-
-    .. deprecated:: v4.12.0
-
-        Subclassing validator classes now explicitly warns this is not part of
-        their public API.
-
-    """
-
-    #: An object representing the validator's meta schema (the schema that
-    #: describes valid schemas in the given version).
-    META_SCHEMA: ClassVar[Mapping]
-
-    #: A mapping of validation keywords (`str`\s) to functions that
-    #: validate the keyword with that name. For more information see
-    #: `creating-validators`.
-    VALIDATORS: ClassVar[Mapping]
-
-    #: A `jsonschema.TypeChecker` that will be used when validating
-    #: :kw:`type` keywords in JSON schemas.
-    TYPE_CHECKER: ClassVar[jsonschema.TypeChecker]
-
-    #: A `jsonschema.FormatChecker` that will be used when validating
-    #: :kw:`format` keywords in JSON schemas.
-    FORMAT_CHECKER: ClassVar[jsonschema.FormatChecker]
-
-    #: A function which given a schema returns its ID.
-    ID_OF: _typing.id_of
-
-    #: The schema that will be used to validate instances
-    schema: Mapping | bool
-
-    def __init__(
-        self,
-        schema: Mapping | bool,
-        registry: referencing.jsonschema.SchemaRegistry,
-        format_checker: jsonschema.FormatChecker | None = None,
-    ) -> None:
-        ...
-
-    @classmethod
-    def check_schema(cls, schema: Mapping | bool) -> None:
-        """
-        Validate the given schema against the validator's `META_SCHEMA`.
-
-        Raises:
-
-            `jsonschema.exceptions.SchemaError`:
-
-                if the schema is invalid
-
-        """
-
-    def is_type(self, instance: Any, type: str) -> bool:
-        """
-        Check if the instance is of the given (JSON Schema) type.
-
-        Arguments:
-
-            instance:
-
-                the value to check
-
-            type:
-
-                the name of a known (JSON Schema) type
-
-        Returns:
-
-            whether the instance is of the given type
-
-        Raises:
-
-            `jsonschema.exceptions.UnknownType`:
-
-                if ``type`` is not a known type
-
-        """
-
-    def is_valid(self, instance: Any) -> bool:
-        """
-        Check if the instance is valid under the current `schema`.
-
-        Returns:
-
-            whether the instance is valid or not
-
-        >>> schema = {"maxItems" : 2}
-        >>> Draft202012Validator(schema).is_valid([2, 3, 4])
-        False
-
-        """
-
-    def iter_errors(self, instance: Any) -> Iterable[ValidationError]:
-        r"""
-        Lazily yield each of the validation errors in the given instance.
-
-        >>> schema = {
-        ...     "type" : "array",
-        ...     "items" : {"enum" : [1, 2, 3]},
-        ...     "maxItems" : 2,
-        ... }
-        >>> v = Draft202012Validator(schema)
-        >>> for error in sorted(v.iter_errors([2, 3, 4]), key=str):
-        ...     print(error.message)
-        4 is not one of [1, 2, 3]
-        [2, 3, 4] is too long
-
-        .. deprecated:: v4.0.0
-
-            Calling this function with a second schema argument is deprecated.
-            Use `Validator.evolve` instead.
-        """
-
-    def validate(self, instance: Any) -> None:
-        """
-        Check if the instance is valid under the current `schema`.
-
-        Raises:
-
-            `jsonschema.exceptions.ValidationError`:
-
-                if the instance is invalid
-
-        >>> schema = {"maxItems" : 2}
-        >>> Draft202012Validator(schema).validate([2, 3, 4])
-        Traceback (most recent call last):
-            ...
-        ValidationError: [2, 3, 4] is too long
-
-        """
-
-    def evolve(self, **kwargs) -> Validator:
-        """
-        Create a new validator like this one, but with given changes.
-
-        Preserves all other attributes, so can be used to e.g. create a
-        validator with a different schema but with the same :kw:`$ref`
-        resolution behavior.
-
-        >>> validator = Draft202012Validator({})
-        >>> validator.evolve(schema={"type": "number"})
-        Draft202012Validator(schema={'type': 'number'}, format_checker=None)
-
-        The returned object satisfies the validator protocol, but may not
-        be of the same concrete class! In particular this occurs
-        when a :kw:`$ref` occurs to a schema with a different
-        :kw:`$schema` than this one (i.e. for a different draft).
-
-        >>> validator.evolve(
-        ...     schema={"$schema": Draft7Validator.META_SCHEMA["$id"]}
-        ... )
-        Draft7Validator(schema=..., format_checker=None)
-        """