�

�% g��
��dZd
dl
mZ
d
dlmZ
d
dlmZmZmZm	Z	m
Z
mZ
erd
dlm
Z

d
dlZd
dlZd
dlZd
dlmZ
eGd�d	e
��Zy)
z4
typing.Protocol classes for jsonschema interfaces.
�)
�annotations)
�Mapping)�
TYPE_CHECKING�Any�ClassVar�Iterable�Protocol�runtime_checkable)
�_typingN)
�ValidationErrorc
��eZ
dZUd
Zded<ded<ded<ded<d	ed
<ded<	d							dd�Zedd��Zdd�Zdd�Z	dd�Z
dd�Zdd�Zy
)�	Validatora�
    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.
    zClassVar[Mapping]�META_SCHEMA�
VALIDATORSz ClassVar[jsonschema.TypeChecker]�TYPE_CHECKERz"ClassVar[jsonschema.FormatChecker]�FORMAT_CHECKERz
_typing.id_of�ID_OF�Mapping | bool�schemaNc
��y�
N�)�selfr�registry�format_checkers    �9/usr/lib/python3.12/site-packages/jsonschema/protocols.py�__init__zValidator.__init__qs��	�c
��y
)z�
        Validate the given schema against the validator's `META_SCHEMA`.

        Raises:

            `jsonschema.exceptions.SchemaError`:

                if the schema is invalid
        Nr)�clsrs  r�check_schemazValidator.check_schemay��rc
��y
)a�

        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
        Nr)r�instance�types   r�is_typezValidator.is_type�r"rc
��y
)a

        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
        Nr�rr$s  r�is_validzValidator.is_valid�r"rc
��y
)a]
        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.
        Nrr(s  r�iter_errorszValidator.iter_errors�r"rc
��y
)a�

        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
        Nrr(s  r�validatezValidator.validate�r"rc

��y
)al
        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)
        Nr)r�kwargss  r�evolvezValidator.evolve�r"rr)rrrz%referencing.jsonschema.SchemaRegistryrzjsonschema.FormatChecker | None�return�None)rrr1r2)r$rr%�strr1�bool)r$rr1r4)r$rr1zIterable[ValidationError])r$rr1r2)r1r)
�__name__�
__module__�__qualname__�__doc__�__annotations__r�classmethodr!r&r)r+r-r0rrrrr-s���)�Z
#�"�
"�!�3�2�7�6���
��;?�	���8��8�	�

���	��	��2��*�"rr)r8�
__future__r�collections.abcr�typingrrrrr	r
�
jsonschemar�jsonschema.validators�referencing.jsonschema�referencing�jsonschema.exceptionsrrrrr�<module>rC
sN�


�
�
#�#�
�
��"�� �!�1��x
��x
��x
r