Current File : //proc/self/root/usr/lib/python3/dist-packages/jsonschema/__pycache__/validators.cpython-312.pyc
�

`��dc����UdZddlmZddlmZddlmZddlmZddl	m
Z
ddlmZm
Z
mZmZddlmZdd	lmZdd
lZdd
lZdd
lZdd
lZdd
lZdd
lZddlmZmZmZmZmZmZej@�Z!iZ"de#d
<ejH�Z%gZ&de#d<d�Z'd�Z(d�Z)d�Z*dd
ejVejXe)e
d�fd�Z-				dXd�Z.e-ej^d�idej`�dejb�dejd�dejf�dejh�dejj�dejl�d ejn�d!ejp�dejr�d"ejt�d#ejv�d$ejx�d%ejz�d&ej|�d'ej~�d(ej��ej�ej�ej�ej�d)��ej�ej�dd*�ej��+�ZHe-ej^d,�idej`�dejb�dejd�d-ej��d.ej��dej��dejl�d!ejp�dejr�d"ejt�d#ejv�d/ej��d$ejx�d%ejz�d&ej|�d0ej��d'ej~�ejjej�ej�ej�ej�ej�ej�ej�ej�d1�	�ej�ej�d,d2�ej��+�ZUe-ej^d3�idej`�dejb�dejd�d-ej��d.ej��d4ej��d5ej��dej��dejl�d6ej��d7ej��d!ejp�dej��d"ejt�d#ejv�d/ej��d$ej��ejzej|ej�ej�ejjej�ej�ej�ej�ej�ej�ej�ej�ej�d8��ej�ej�d3ej��9�Z`e-ej^d:�idej`�dejb�dejd�d-ej��d.ej��d4ej��d5ej��dej��dejl�d6ej��d7ej��d!ejp�d;ej��dej��d"ejt�d#ejv�d/ej��ej�ejzej|ej�ej�ejjej�ej�ej�ej�ej�ej�ej�ej�ej�d<��ej�ej�d:ej��9�Zde-ej^d=�id>ej��dej`�dejb�dejd�d-ej��d.ej��d4ej��d5ej��d?ej��d@ej��dejl�d6ej��d7ej��d!ejp�d;ej��dej��d"ejt�id#ejv�d/ej��d$ej��d%ejz�d&ej|�d0ej��d'ej��dAejj�dBej��dCej��d(ej��dDej��dEej��dFej��dGej��dHej��dIej���ej�ej�dJ��ej�ej�d=�K�Zme-ej^dL�idMej��dej`�dejb�dejd�d-ej��d.ej��d4ej��d5ej��d?ej��d@ej��dejl�d6ej��d7ej��d!ejp�d;ej��dej��d"ejt�id#ejv�d/ej��d$ej��d%ejz�d&ej|�d0ej��d'ej��dAejj�dBej��dCej��d(ej��dDej��dNej��dEej��dFej��dGej��dHej���ej�ej�ej�dO��ejVejXdL�K�ZqeqZrGdP�dQes�ZtdRZudS�ZvdT�ZwdU�ZxdYdV�Zye!fdW�Zzy
)ZzQ
Creation and extension of validators, with implementations for existing drafts.
�)�annotations)�deque)�Sequence)�	lru_cache)�methodcaller)�unquote�	urldefrag�urljoin�urlsplit)�urlopen)�warnN)�_format�_legacy_validators�_types�_utils�_validators�
exceptionszdict[str, typing.Any]�_VALIDATORSzlist[tuple[str, typing.Any]]�
_VOCABULARIESc��|dk(r$tjdtd��ddlm}|S|dk(r"tjdtd��t
S|d	k(r"tjd
td��tStdt�d|����)
N�	ErrorTreezkImporting ErrorTree from jsonschema.validators is deprecated. Instead import it from jsonschema.exceptions.���
stacklevelr)r�
validatorszvAccessing jsonschema.validators.validators is deprecated. Use jsonschema.validators.validator_for with a given schema.�meta_schemaszxAccessing jsonschema.validators.meta_schemas is deprecated. Use jsonschema.validators.validator_for with a given schema.zmodule z has no attribute )	�warningsr
�DeprecationWarning�jsonschema.exceptionsrr�
_META_SCHEMAS�AttributeError�__name__)�namers  �7/usr/lib/python3/dist-packages/jsonschema/validators.py�__getattr__r%%s����{���
�
�
<���		
�	4���	
��	��
�
�
K���		
���	
��	��
�
�
K���		
���
�7�8�*�,>�t�f�E�
F�F�c����fd�}|S)a�
    Register the decorated validator for a ``version`` of the specification.

    Registered validators and their meta schemas will be considered when
    parsing :kw:`$schema` keywords' URIs.

    Arguments:

        version (str):

            An identifier to use as the version's name

    Returns:

        collections.abc.Callable:

            a class decorator to decorate the validator with the version
    c�b��|t�<|j|j�}|t|<|S�N)r�ID_OF�META_SCHEMAr )�cls�meta_schema_id�versions  �r$�
_validateszvalidates.<locals>._validatesVs.���"��G�����3�?�?�3��(+�
�n�%��
r&�)r.r/s` r$�	validatesr1Bs���(�
�r&c�8�|dus|dury|jdd�S)zB
    Return the ID of a schema for recent JSON Schema drafts.
    TF��$id��get��schemas r$�_id_ofr9^s%����~��5����:�:�e�R� � r&c��ts6tjtjd�j	��t
j	�D��cgc]\}}||jf��c}}tzScc}}w)N�vocabularies)r�extendr�load_schema�itemsr r+)�id�	validators  r$�_store_schema_listrAgsd������V�/�/��?�E�E�G�H�9F�9L�9L�9N��(5��I��Y�
"�
"�#������s�A7r0r>c	�������	�|�	tjG��	����fd�d��}|�R|j�jdd�jdd�}|�d�x|_|_t
|�|�}|S)as
    Create a new validator class.

    Arguments:

        meta_schema (collections.abc.Mapping):

            the meta schema for the new validator class

        validators (collections.abc.Mapping):

            a mapping from names to callables, where each callable will
            validate the schema property with the given name.

            Each callable should take 4 arguments:

                1. a validator instance,
                2. the value of the property being validated within the
                   instance
                3. the instance
                4. the schema

        version (str):

            an identifier for the version that this validator class will
            validate. If provided, the returned validator class will
            have its ``__name__`` set to include the version, and also
            will have `jsonschema.validators.validates` automatically
            called for the given version.

        type_checker (jsonschema.TypeChecker):

            a type checker, used when applying the :kw:`type` keyword.

            If unprovided, a `jsonschema.TypeChecker` will be created
            with a set of default types typical of JSON Schema drafts.

        format_checker (jsonschema.FormatChecker):

            a format checker, used when applying the :kw:`format` keyword.

            If unprovided, a `jsonschema.FormatChecker` will be created
            with a set of default formats typical of JSON Schema drafts.

        id_of (collections.abc.Callable):

            A function that given a schema, returns its ID.

        applicable_validators (collections.abc.Callable):

            A function that given a schema, returns the list of
            applicable validators (validation keywords and callables)
            which will be used to validate the instance.

    Returns:

        a new `jsonschema.protocols.Validator` class
    c�"��eZdZeW��ZeW��ZW�ZW�ZeW��Z	e
jej��Ze
jdd��Ze
jd��Z�fd�Zed��Zd�Zd��fd	�	Zdd
�Zd�Zd�Zdd
�Zy)�create.<locals>.Validator)�reprNF)�defaultrE�rFc�l��|j�'tj|j���|_yy)N)�id_of)�resolver�RefResolver�from_schemar8)�selfrIs �r$�__attrs_post_init__z-create.<locals>.Validator.__attrs_post_init__�s3����}�}�$� +� 7� 7��K�K��!8�!��
�%r&c��||j�j|�D] }tjj	|��yr))r+�iter_errorsr�SchemaError�create_from)r,r8�errors   r$�check_schemaz&create.<locals>.Validator.check_schema�s>���S�_�_�-�9�9�&�A�
@�� �,�,�8�8��?�?�
@r&c�(�|j}|jd|j�}t||��}t	j
|�D]>}|js�|j}|ddk7r|n|dd}||vs�0t||�||<�@|di|��S)Nr8rGr�_�r0)	�	__class__�
setdefaultr8�
validator_for�attr�fields�initr#�getattr)rM�changesr,r8�NewValidator�field�	attr_name�	init_names        r$�evolvez create.<locals>.Validator.evolve�s����.�.�C��'�'��$�+�+�>�F�(���=�L����S�)�
B���z�z��!�J�J�	�)2�1���)<�I�)�A�B�-�	��G�+�)0��y�)A�G�I�&�

B� �*�'�*�*r&c	3��K�|�tjdtd��n|j}|dury|dur t	j
d|��dd||����y�
|�}|r|jj|�	�	|�D]|\}}|jj|�}|��$|||||�xsd}|D]E}|j|||||j�	�|d
vr|jj|�|���G�~	|r|jj�yy#|r|jj�wwxYw�w)Nz�Passing a schema to Validator.iter_errors is deprecated and will be removed in a future release. Call validator.evolve(schema=new_schema).iter_errors(...) instead.rrTFzFalse schema does not allow )r@�validator_value�instancer8r0)r@rfrgr8�type_checker>�if�$ref)rr
rr8r�ValidationErrorrJ�
push_scope�
VALIDATORSr6�_set�TYPE_CHECKER�schema_path�
appendleft�	pop_scope)rMrg�_schema�scope�k�vr@�errorsrS�applicable_validatorsrIs         ��r$rPz%create.<locals>.Validator.iter_errors�sh������"��
�
�4�
'� �	��+�+���$����E�!� �0�0�2�8�,�?�"�$(�%�"�����'�N�E���
�
�(�(��/�
.�1�'�:�$�D�A�q� $��� 3� 3�A� 6�I� �(� �&�t�Q��'�B�H�b�F�!'�$���
�
�&'�,-�%-�#*�)-�):�):�#���N�2�!�-�-�8�8��;�#��$�
$�&��M�M�+�+�-���5��M�M�+�+�-��s�A:E�>BD$�E�$E�Ec3��K�|j|��j|�D]@}|�|jj|�|�|jj|�|���By�w)Nr7)rdrP�pathrqrp)rMrgr8rzrprSs      r$�descendz!create.<locals>.Validator.descendsb�������F��3�?�?��I�
���#��J�J�)�)�$�/��*��%�%�0�0��=���
�s�A&A(c�4�|j|i|��D]}|�yr))rP)rM�args�kwargsrSs    r$�validatez"create.<locals>.Validator.validates(��)��)�)�4�:�6�:�
����
r&c��	|jj||�S#tj$r"tj|||j
��wxYwr))ro�is_typer�UndefinedTypeCheck�UnknownTyper8)rMrg�types   r$r�z!create.<locals>.Validator.is_type!sQ��
J��(�(�0�0��4�@�@���0�0�
J� �,�,�T�8�T�[�[�I�I�
J�s	��5Ac��|�.tjdtd��|j|��}t	|j|�d�}|duS)Nz�Passing a schema to Validator.is_valid is deprecated and will be removed in a future release. Call validator.evolve(schema=new_schema).is_valid(...) instead.rrr7)rr
rrd�nextrP)rMrgrsrSs    r$�is_validz"create.<locals>.Validator.is_valid'sT���"��
�
�#�
'� �	��{�{�'�{�2����)�)�(�3�T�:�E��D�=� r&r))NN)r"�
__module__�__qualname__�dictrmr+ro�FORMAT_CHECKER�staticmethodr*r[�ib�reprlibrEr8rJ�format_checkerrN�classmethodrTrdrPr{rr�r�)rx�format_checker_argrI�meta_schemarhrs������r$�	ValidatorrD�s�����*�%�
��;�'��#��+���U�#������g�l�l�+���4�7�7�4�e�4�� �����.��	�
�	@�
�	@�	+�$3	.�j	�	�	J�	!r&r�� r3�-)r[�s�title�replacer"r�r1)
r�rr.rhr�rIrxr��safer�s
`` ` ``  @r$�creater�os����H(��	�V�V�@!�@!��@!�D���}�}��&�&�s�B�/�7�7��R�@��9=��i�6H�H�	��Y�3�&�I�g�&�y�1�	��r&c���t|j�}|j|�|�|j}|�|j}t|j|||||j��S)a�
    Create a new validator class by extending an existing one.

    Arguments:

        validator (jsonschema.protocols.Validator):

            an existing validator class

        validators (collections.abc.Mapping):

            a mapping of new validator callables to extend with, whose
            structure is as in `create`.

            .. note::

                Any validator callables with the same name as an
                existing one will (silently) replace the old validator
                callable entirely, effectively overriding any validation
                done in the "parent" validator class.

                If you wish to instead extend the behavior of a parent's
                validator callable, delegate and call it directly in
                the new validator function by retrieving it using
                ``OldValidator.VALIDATORS["validation_keyword_name"]``.

        version (str):

            a version for the new validator class

        type_checker (jsonschema.TypeChecker):

            a type checker, used when applying the :kw:`type` keyword.

            If unprovided, the type checker of the extended
            `jsonschema.protocols.Validator` will be carried along.

        format_checker (jsonschema.FormatChecker):

            a format checker, used when applying the :kw:`format` keyword.

            If unprovided, the format checker of the extended
            `jsonschema.protocols.Validator` will be carried along.

    Returns:

        a new `jsonschema.protocols.Validator` class extending the one
        provided

    .. note:: Meta Schemas

        The new validator class will have its parent's meta schema.

        If you wish to change or extend the meta schema in the new
        validator class, modify ``META_SCHEMA`` directly on the returned
        class. Note that no implicit copying is done, so a copy should
        likely be made before modifying it, in order to not affect the
        old validator.
    )r�rr.rhr�rI)r�rm�updateror�r�r+r*)r@rr.rhr��all_validatorss      r$r<r<@sn��F�)�.�.�/�N����*�%��� �-�-����"�1�1����)�)�!��!�%��o�o�
�r&�draft3rj�additionalItems�additionalProperties�dependencies�disallow�divisibleBy�enum�extends�format�maxItems�	maxLength�maximum�minItems�	minLength�minimum�pattern)�patternProperties�
propertiesr��uniqueItemsc�&�|jdd�S�Nr?r3r5r7s r$�<lambda>r��������D�"�-�r&)r�rrhr�r.rIrx�draft4�allOf�anyOf�
maxProperties�
minProperties)	�
multipleOf�not�oneOfr�r�r��requiredr�r�c�&�|jdd�Sr�r5r7s r$r�r��r�r&�draft6�const�contains�exclusiveMaximum�exclusiveMinimum)r�r�r�r�r�r�r�r�r�r��
propertyNamesr�r�r�)r�rrhr�r.rx�draft7ri)r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�zdraft2019-09z
$recursiveRef�dependentRequired�dependentSchemasr�r�r�r�r�r�r�r��unevaluatedItems)�unevaluatedPropertiesr�)r�rrhr�r.zdraft2020-12z$dynamicRef�prefixItems)r�r�r�c��eZdZdZ					dd�Zeefd��Zd�Zd�Z	e
d��Ze
d��Ze
jd	��Ze
jd
��Zd�Ze�d��Ze�d
��Zd�Zd�Zd�Zd�Zy)rKa�
    Resolve JSON References.

    Arguments:

        base_uri (str):

            The URI of the referring document

        referrer:

            The actual referring document

        store (dict):

            A mapping from URIs to documents to cache

        cache_remote (bool):

            Whether remote refs should be cached after first resolution

        handlers (dict):

            A mapping from URI schemes to functions that should be used
            to retrieve them

        urljoin_cache (:func:`functools.lru_cache`):

            A cache that will be used for caching the results of joining
            the resolution scope to subscopes.

        remote_cache (:func:`functools.lru_cache`):

            A cache that will be used for caching the results of
            resolved remote URLs.

    Attributes:

        cache_remote (bool):

            Whether remote refs should be cached after first resolution
    Nc�l�|�td�t�}|�td�|j�}||_||_t|�|_|g|_tjt��|_|jj|�||j|<||_
||_y)Ni)rr
�resolve_from_url�referrer�cache_remoter��handlers�
_scopes_stackr�URIDictrA�storer��_urljoin_cache�
_remote_cache)rM�base_urir�r�r�r��
urljoin_cache�remote_caches        r$�__init__zRefResolver.__init__�s���� �+�I�d�O�G�4�M���*�9�T�?�4�+@�+@�A�L� ��
�(����X���
�&�Z����^�^�$6�$8�9��
��
�
���%� �'��
�
�8��+���)��r&c�$�||||�|d�|��S)z�
        Construct a resolver from a JSON schema object.

        Arguments:

            schema:

                the referring schema

        Returns:

            `RefResolver`
        )r�r�r0)r,r8rIr}r~s     r$rLzRefResolver.from_schema�s�� �T�E�&�M�F�L�V�L�Lr&c�n�|jj|j|j|��y)z�
        Enter a given sub-scope.

        Treats further dereferences as being performed underneath the
        given scope.
        N)r��appendr��resolution_scope�rMrts  r$rlzRefResolver.push_scope�s.��	
���!�!����� 5� 5�u�=�	
r&c�~�	|jj�y#t$rtjd��wxYw)z�
        Exit the most recent entered scope.

        Treats further dereferences as being performed underneath the
        original scope.

        Don't call this method more times than `push_scope` has been
        called.
        znFailed to pop the scope from an empty stack. `pop_scope()` should only be called once for every `push_scope()`N)r��pop�
IndexErrorr�RefResolutionError�rMs r$rrzRefResolver.pop_scope�s@��	����"�"�$���	��/�/�!��
�	�s��<c� �|jdS)z8
        Retrieve the current resolution scope.
        ���)r�r�s r$r�zRefResolver.resolution_scopes��
�!�!�"�%�%r&c�6�t|j�\}}|S)zL
        Retrieve the current base URI, not including any fragment.
        )r	r�)rM�urirVs   r$r�zRefResolver.base_uris��
�4�0�0�1���Q��
r&c#�K�tjdtd��|j|�	d��|j	�y#|j	�wxYw�w)zT
        Temporarily enter the given scope for the duration of the context.
        zVjsonschema.RefResolver.in_scope is deprecated and will be removed in a future release.�rN)rr
rrlrrr�s  r$�in_scopezRefResolver.in_scopesI����
	�
�
�
+���		
�	
�����	���N�N���D�N�N��s�.A�A�A�A�Ac#�K�|j|�\}}|j|�	|��|j�y#|j�wxYw�w)z�
        Resolve the given ``ref`` and enter its resolution scope.

        Exits the scope on exit of this context manager.

        Arguments:

            ref (str):

                The reference to resolve
        N)�resolverlrr)rM�ref�url�resolveds    r$�	resolvingzRefResolver.resolving!sD�������S�)�
��X������	��N��N�N���D�N�N��s�&A�>�A�A�Ac�(�|j�|Sr))�_get_subschemas_cache)rM�keys  r$�_find_in_referrerzRefResolver._find_in_referrer6s���)�)�+�C�0�0r&c��tD�cic]}|g��}}t|jt�D]\}}||j	|��|Scc}wr))�_SUBSCHEMAS_KEYWORDS�_search_schemar��_match_subschema_keywordsr�)rMr��cache�keyword�	subschemas     r$r�z!RefResolver._get_subschemas_cache9s\��$8�9�S��b��9��9�"0��M�M�4�#
�	-��G�Y�
�'�N�!�!�)�,�	-����:s�
A
c��|j�d}|syt|�\}}|D]^}|j|j|d�}|j	d�|j	d�k(s�F|r|j||�}||fcSy)Nr4�/)r�r	r�r��rstrip�resolve_fragment)rMr��
subschemasr��fragmentr��
target_uris       r$�_find_in_subschemaszRefResolver._find_in_subschemasBs����/�/�1�%�8�
���!�#��
��X�#�	&�I��,�,��%�%�y��'7��J�� � ��%����C��8�� $� 5� 5�i�� J�I��I�~�%�	&�r&c��|j|j|�jd�}|j|�}|�|S||j	|�fS)z.
        Resolve the given reference.
        r�)r�r�r�rr�)rMr�r��matchs    r$r�zRefResolver.resolveRsX���!�!�$�"7�"7��=�D�D�S�I���(�(��-�����L��D�&�&�s�+�+�+r&c��t|�\}}|r	|j|}n|j}|j||�S#t$r<	|j|�}n&#t$r}tj|��d}~wwxYwY�VwxYw)z(
        Resolve the given URL.
        N)	r	r��KeyError�resolve_remote�	Exceptionrr�r�r�)rMr�r�document�excs     r$r�zRefResolver.resolve_from_url^s���"�#��
��X��
=��:�:�c�?���}�}�H��$�$�X�x�8�8���
=�=�#�2�2�3�7�H�� �=�$�7�7��<�<��=���
=�s5�A�	B�
A�B�	A?�%A:�:A?�?B�Bc�F��|jd�}|s�S�|jur
|j}n�fd�}dD]}||�D]}|||k(s�|ccS�dD] }||�D]}d|z||k(s�|ccS�"|rt|�j	d�ng}|D]F}|jdd�jdd�}t
�t�r	t|�}	�|��H�S#t$rY�wxYw#ttf$rtjd	|����wxYw)
z�
        Resolve a ``fragment`` within the referenced ``document``.

        Arguments:

            document:

                The referent document

            fragment (str):

                a URI fragment to resolve within it
        r�c3�L�K�t�t|��Ed{���y7��wr))r��_match_keyword)r�r
s �r$�findz*RefResolver.resolve_fragment.<locals>.find�s�����)�(�N�3�4G�H�H�H�s�$�"�$)�$anchor�$dynamicAnchor)r?r4�#z~1z~0�~zUnresolvable JSON pointer: )�lstripr�r�r�splitr��
isinstancer�int�
ValueError�	TypeError�LookupErrorrr�)rMr
rrr�r��parts�parts `      r$r�zRefResolver.resolve_fragmentpsd����?�?�3�'����O��t�}�}�$��)�)�D�
I�5�	%�G�!�'�]�
%�	��y��1�1�$�$�
%�	%�%�	%�G�!�'�]�
%�	���>�Y�w�%7�7�$�$�
%�	%�19���!�'�'��,�b���	�D��<�<��c�*�2�2�4��=�D��(�H�-���t�9�D�
�#�D�>��	� ���"������{�+�
� �3�3�1�(��>���
�s�C)� C8�)	C5�4C5�8(D c���	ddl}t|�j}||jvr|j||�}nl|dvr"|r |j|�j
�}nFt|�5}t
j|j�jd��}ddd�|jr|j|<S#t$rd}Y��wxYw#1swY�7xYw)a�
        Resolve a remote ``uri``.

        If called directly, does not check the store first, but after
        retrieving the document at the specified URI it will be saved in
        the store if :attr:`cache_remote` is True.

        .. note::

            If the requests_ library is present, ``jsonschema`` will use it to
            request the remote ``uri``, so that the correct encoding is
            detected and used.

            If it isn't, or if the scheme of the ``uri`` is not ``http`` or
            ``https``, UTF-8 is assumed.

        Arguments:

            uri (str):

                The URI to resolve

        Returns:

            The retrieved document

        .. _requests: https://pypi.org/project/requests/
        rN)�http�httpszutf-8)
�requests�ImportErrorr�schemer�r6�jsonr�loads�read�decoder�r�)rMr�r r"�resultr�s      r$rzRefResolver.resolve_remote�s���:	���#��%�%���T�]�]�"�*�T�]�]�6�*�3�/�F�
�(�
(�X��\�\�#�&�+�+�-�F����
@�����C�H�H�J�$5�$5�g�$>�?��
@����$�D�J�J�s�O��
��%�	��H�	��
@�
@�s�C�03C�C�C�C")r0Tr0NN)r"r�r��__doc__r�r�r9rLrlrr�propertyr�r��
contextlib�contextmanagerr�r�r�rr�rr�r�r�rr0r&r$rKrK�s���)�^�����*�6�'-�M��M�"	
��&�&��&����������� ������(1��[�����[�
��
�
,�9�$6�p1r&rK)r4r?rrc����fd�}|S)Nc3� �K��|vr|��yy�wr)r0��valuer�s �r$�matcherz_match_keyword.<locals>.matcher�s������e���K��s�r0)r�r0s` r$rr�s�����Nr&c#�8K�tD]
}||vs�||f���y�wr))r�r.s  r$r�r��s'����'�!���e���5�.� �!�s��	c#��K�t|g�}|rT|j�}t|t�s�#||�Ed{���|j	|j��|r�Syy7�(�w)zBreadth-first search routine.N)rr�rr��
extendleft�values)r8r0r4r/s    r$r�r��sW����
�F�8�_�F�
��
�
����%��&���5�>�!�!����%�,�,�.�)��	"�s�;A(�A&�%A(�$A(c��|�t|�}|j|�||g|��i|��}tj|j	|��}|�|�y)a�
    Validate an instance under the given schema.

        >>> validate([2, 3, 4], {"maxItems": 2})
        Traceback (most recent call last):
            ...
        ValidationError: [2, 3, 4] is too long

    :func:`validate` will first verify that the provided schema is
    itself valid, since not doing so can lead to less obvious error
    messages and fail in less obvious or consistent ways.

    If you know you have a valid schema already, especially if you
    intend to validate multiple instances with the same schema, you
    likely would prefer using the `Validator.validate` method directly
    on a specific validator (e.g. ``Draft7Validator.validate``).


    Arguments:

        instance:

            The instance to validate

        schema:

            The schema to validate with

        cls (Validator):

            The class that will be used to validate the instance.

    If the ``cls`` argument is not provided, two things will happen
    in accordance with the specification. First, if the schema has a
    :kw:`$schema` keyword containing a known meta-schema [#]_ then the
    proper validator will be used. The specification recommends that
    all schemas contain :kw:`$schema` properties for this reason. If no
    :kw:`$schema` property is found, the default validator class is the
    latest released draft.

    Any other provided positional and keyword arguments will be passed
    on when instantiating the ``cls``.

    Raises:

        `jsonschema.exceptions.ValidationError` if the instance
            is invalid

        `jsonschema.exceptions.SchemaError` if the schema itself
            is invalid

    .. rubric:: Footnotes
    .. [#] known by a validator registered with
        `jsonschema.validators.validates`
    N)rZrTr�
best_matchrP)rgr8r,r}r~r@rSs       r$rr�sa��p�{��F�#�����V���F�,�T�,�V�,�I��!�!�)�"7�"7��"A�B�E�����r&c��|turtn|}|dus|dusd|vr|S|dtvr|turtdtd��tj|d|�S)a
    Retrieve the validator class appropriate for validating the given schema.

    Uses the :kw:`$schema` keyword that should be present in the given
    schema to look up the appropriate validator class.

    Arguments:

        schema (collections.abc.Mapping or bool):

            the schema to look at

        default:

            the default to return if the appropriate validator class
            cannot be determined.

            If unprovided, the default is to return the latest supported
            draft.
    TFz$schemaz�The metaschema specified by $schema was not found. Using the latest draft to validate, but this will raise an error in the future.rr)�_UNSET�_LATEST_VERSIONr r
rr6)r8rF�DefaultValidators   r$rZrZ;sr��,+2�V�*;����
��~��5��I�V�,C���
�i��
�-��f���.�#��
����V�I�.�0@�A�Ar&)r0NNNr)){r(�
__future__r�collectionsr�collections.abcr�	functoolsr�operatorr�urllib.parserr	r
r�urllib.requestrrr
r*r#r��typingr[�
jsonschemarrrrrr�Unsetr8r�__annotations__r�r rr%r1r9rA�draft202012_type_checker�draft202012_format_checkerr�r<r=r�r�r��dependencies_draft3�disallow_draft3r�r��extends_draft3r��items_draft3_draft4r�r��maximum_draft3_draft4r�r��minimum_draft3_draft4r�r��properties_draft3�type_draft3r��draft3_type_checker�draft3_format_checker�ignore_ref_siblings�Draft3Validatorr�r��!dependencies_draft4_draft6_draft7r�r��not_r�r�r�r��draft4_type_checker�draft4_format_checker�Draft4Validatorr��contains_draft6_draft7r�r��items_draft6_draft7_draft201909r�r�r��draft6_type_checker�draft6_format_checker�Draft6Validator�if_�draft7_type_checker�draft7_format_checker�Draft7Validator�recursiveRefr�r�r�r�r��draft201909_type_checker�draft201909_format_checker�Draft201909Validator�
dynamicRefr>r��Draft202012Validatorr9�objectrKr�rr�r�rrZr0r&r$�<module>ris�
���#��$��!�>�>�"�����
�����
������%'��
"�'����� �
�.0�
�+�0�G�:�8!�����0�0��5�5�
�&�w�/�N�f����Q�h�"��"�"�8�,��������;�6�6��	�� @� @��	�*�>�>�	�
	�&�6�6��	�{�-�-�
�	�� � ��	�%�4�4��	�+�$�$��	�#�7�7��	�K�(�(��	�[�*�*��	�%�;�;��	�K�(�(��	�[�*�*�� 	�%�;�;�!�"	�;�&�&�#�$)�:�:�(�:�:�"�.�.�"�.�.�+�.�+�+��0�0��
-�,�@�@�;��@�"��"�"�8�,��������;�6�6��	�� @� @��	��"�"�	�
	��"�"��	�*�L�L�
�	�� � ��	�+�$�$��	�#�7�7��	�K�(�(��	�[�*�*��	��2�2��	�%�;�;��	�K�(�(��	�[�*�*�� 	��2�2�!�"	�%�;�;�#�$"�,�,�����"�"��&�&�(�:�:�!�,�,��(�(�� � �"�.�.�5�8�+�+��0�0��
-�,�@�@�E#��J�"��"�"�8�,� ����� ��;�6�6� �	�� @� @� �	��"�"�	 �
	��"�"� �	��"�"�
 �	�&�=�=� �	�*�L�L� �	�� � � �	�K�8�8� �	�K�8�8� �	�+�$�$� �	�#�C�C� �	�K�(�(� �	�[�*�*� � 	��2�2�! �"	�;�&�&�# �$ �(�(� �*�*�$�2�2��&�&�!�,�,�����"�"��&�&�(�:�:�!�,�,�$�2�2��(�(�� � �"�.�.�? �B�+�+��0�0��,�@�@�M'��R�"��"�"�8�,�!�����!��;�6�6�!�	�� @� @�!�	��"�"�	!�
	��"�"�!�	��"�"�
!�	�&�=�=�!�	�*�L�L�!�	�� � �!�	�K�8�8�!�	�K�8�8�!�	�+�$�$�!�	
�k�o�o�!�	�#�C�C�!�	�K�(�(�!� 	�[�*�*�!!�"	��2�2�#!�$�&�&��(�(� �*�*�$�2�2��&�&�!�,�,�����"�"��&�&�(�:�:�!�,�,�$�2�2��(�(�� � �"�.�.�A!�D�+�+��0�0��,�@�@�O(��T�"��"�"�>�2�%��+�8�8�%�����%�	�;�6�6�%�	�� @� @�	%�
	��"�"�%�	��"�"�
%�	��"�"�%�	�K�(�(�%�	�[�:�:�%�	�K�8�8�%�	�� � �%�	�K�8�8�%�	�K�8�8�%�	�+�$�$�%�	
�k�o�o�%� 	�#�C�C�!%�"	�K�(�(�#%�$	�[�*�*�%%�&	��2�2�'%�(	�;�&�&�)%�*	�K�(�(�+%�,	�[�*�*�-%�.	��2�2�/%�0	�;�&�&�1%�2	�k�,�,�3%�4	�{���5%�6	��"�"�7%�8	�;�&�&�9%�:	�[�:�:�;%�<	�k�,�,�=%�>	��2�2�?%�@	�K�(�(�A%�B	�� � �C%�D	�K�8�8�E%�F"-�!B�!B�"�.�.�I%�L�0�0��5�5��U+��Z�"��"�"�>�2�&��{�-�-�&�����&�	�;�6�6�&�	�� @� @�	&�
	��"�"�&�	��"�"�
&�	��"�"�&�	�K�(�(�&�	�[�:�:�&�	�K�8�8�&�	�� � �&�	�K�8�8�&�	�K�8�8�&�	�+�$�$�&�	
�k�o�o�&� 	��"�"�!&�"	�K�(�(�#&�$	�[�*�*�%&�&	��2�2�'&�(	�;�&�&�)&�*	�K�(�(�+&�,	�[�*�*�-&�.	��2�2�/&�0	�;�&�&�1&�2	�k�,�,�3&�4	�{���5&�6	��"�"�7&�8	�;�&�&�9&�:	�[�:�:�;&�<	�{�.�.�=&�>	�k�,�,�?&�@	��2�2�A&�B	�K�(�(�C&�D	�� � �E&�F(�8�8�!,�!B�!B�"�.�.�K&�N�0�0��5�5��W,��\'��O�&�O�d
B���!�*�?�D#)�%Br&
¿Qué es la limpieza dental de perros? - Clínica veterinaria


Es la eliminación del sarro y la placa adherida a la superficie de los dientes mediante un equipo de ultrasonidos que garantiza la integridad de las piezas dentales a la vez que elimina en profundidad cualquier resto de suciedad.

A continuación se procede al pulido de los dientes mediante una fresa especial que elimina la placa bacteriana y devuelve a los dientes el aspecto sano que deben tener.

Una vez terminado todo el proceso, se mantiene al perro en observación hasta que se despierta de la anestesia, bajo la atenta supervisión de un veterinario.

¿Cada cuánto tiempo tengo que hacerle una limpieza dental a mi perro?

A partir de cierta edad, los perros pueden necesitar una limpieza dental anual o bianual. Depende de cada caso. En líneas generales, puede decirse que los perros de razas pequeñas suelen acumular más sarro y suelen necesitar una atención mayor en cuanto a higiene dental.


Riesgos de una mala higiene


Los riesgos más evidentes de una mala higiene dental en los perros son los siguientes:

  • Cuando la acumulación de sarro no se trata, se puede producir una inflamación y retracción de las encías que puede descalzar el diente y provocar caídas.
  • Mal aliento (halitosis).
  • Sarro perros
  • Puede ir a más
  • Las bacterias de la placa pueden trasladarse a través del torrente circulatorio a órganos vitales como el corazón ocasionando problemas de endocarditis en las válvulas. Las bacterias pueden incluso acantonarse en huesos (La osteomielitis es la infección ósea, tanto cortical como medular) provocando mucho dolor y una artritis séptica).

¿Cómo se forma el sarro?

El sarro es la calcificación de la placa dental. Los restos de alimentos, junto con las bacterias presentes en la boca, van a formar la placa bacteriana o placa dental. Si la placa no se retira, al mezclarse con la saliva y los minerales presentes en ella, reaccionará formando una costra. La placa se calcifica y se forma el sarro.

El sarro, cuando se forma, es de color blanquecino pero a medida que pasa el tiempo se va poniendo amarillo y luego marrón.

Síntomas de una pobre higiene dental
La señal más obvia de una mala salud dental canina es el mal aliento.

Sin embargo, a veces no es tan fácil de detectar
Y hay perros que no se dejan abrir la boca por su dueño. Por ejemplo…

Recientemente nos trajeron a la clínica a un perro que parpadeaba de un ojo y decía su dueño que le picaba un lado de la cara. Tenía molestias y dificultad para comer, lo que había llevado a sus dueños a comprarle comida blanda (que suele ser un poco más cara y llevar más contenido en grasa) durante medio año. Después de una exploración oftalmológica, nos dimos cuenta de que el ojo tenía una úlcera en la córnea probablemente de rascarse . Además, el canto lateral del ojo estaba inflamado. Tenía lo que en humanos llamamos flemón pero como era un perro de pelo largo, no se le notaba a simple vista. Al abrirle la boca nos llamó la atención el ver una muela llena de sarro. Le realizamos una radiografía y encontramos una fístula que llegaba hasta la parte inferior del ojo.

Le tuvimos que extraer la muela. Tras esto, el ojo se curó completamente con unos colirios y una lentilla protectora de úlcera. Afortunadamente, la úlcera no profundizó y no perforó el ojo. Ahora el perro come perfectamente a pesar de haber perdido una muela.

¿Cómo mantener la higiene dental de tu perro?
Hay varias maneras de prevenir problemas derivados de la salud dental de tu perro.

Limpiezas de dientes en casa
Es recomendable limpiar los dientes de tu perro semanal o diariamente si se puede. Existe una gran variedad de productos que se pueden utilizar:

Pastas de dientes.
Cepillos de dientes o dedales para el dedo índice, que hacen más fácil la limpieza.
Colutorios para echar en agua de bebida o directamente sobre el diente en líquido o en spray.

En la Clínica Tus Veterinarios enseñamos a nuestros clientes a tomar el hábito de limpiar los dientes de sus perros desde que son cachorros. Esto responde a nuestro compromiso con la prevención de enfermedades caninas.

Hoy en día tenemos muchos clientes que limpian los dientes todos los días a su mascota, y como resultado, se ahorran el dinero de hacer limpiezas dentales profesionales y consiguen una mejor salud de su perro.


Limpiezas dentales profesionales de perros y gatos

Recomendamos hacer una limpieza dental especializada anualmente. La realizamos con un aparato de ultrasonidos que utiliza agua para quitar el sarro. Después, procedemos a pulir los dientes con un cepillo de alta velocidad y una pasta especial. Hacemos esto para proteger el esmalte.

La frecuencia de limpiezas dentales necesaria varía mucho entre razas. En general, las razas grandes tienen buena calidad de esmalte, por lo que no necesitan hacerlo tan a menudo e incluso pueden pasarse la vida sin requerir una limpieza. Sin embargo, razas pequeñas como el Yorkshire o el Maltés, deben hacérselas todos los años desde cachorros si se quiere conservar sus piezas dentales.

Otro factor fundamental es la calidad del pienso. Algunas marcas han diseñado croquetas que limpian la superficie del diente y de la muela al masticarse.

Ultrasonido para perros

¿Se necesita anestesia para las limpiezas dentales de perros y gatos?

La limpieza dental en perros no es una técnica que pueda practicarse sin anestesia general , aunque hay veces que los propietarios no quieren anestesiar y si tiene poco sarro y el perro es muy bueno se puede intentar…… , pero no se va a poder pulir ni acceder a todas la zona de la boca …. Además los limpiadores dentales van a irrigar agua y hay riesgo de aspiración a vías respiratorias si no se realiza una anestesia correcta con intubación traqueal . En resumen , sin anestesia no se va hacer una correcta limpieza dental.

Tampoco sirve la sedación ya que necesitamos que el animal esté totalmente quieto, y el veterinario tenga un acceso completo a todas sus piezas dentales y encías.

Alimentos para la limpieza dental

Hay que tener cierto cuidado a la hora de comprar determinados alimentos porque no todos son saludables. Algunos tienen demasiado contenido graso, que en exceso puede causar problemas cardiovasculares y obesidad.

Los mejores alimentos para los dientes son aquellos que están elaborados por empresas farmacéuticas y llevan componentes químicos con tratamientos específicos para el diente del perro. Esto implica no solo limpieza a través de la acción mecánica de morder sino también un tratamiento antibacteriano para prevenir el sarro.

Conclusión

Si eres como la mayoría de dueños, por falta de tiempo , es probable que no estés prestando la suficiente atención a la limpieza dental de tu perro. Por eso te animamos a que comiences a limpiar los dientes de tu perro y consideres atender a su higiene bucal con frecuencia.

Estas simples medidas pueden conllevar a que tu perro tenga una vida más larga y mucho más saludable.

Si te resulta imposible introducir un cepillo de dientes a tu perro en la boca, pásate con él por clínica Tus Veterinarios y te explicamos cómo hacerlo.

Necesitas hacer una limpieza dental profesional a tu mascota?
Llámanos al 622575274 o contacta con nosotros

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

¡Hola!