Current File : //proc/self/root/lib/python3/dist-packages/jinja2/__pycache__/nodes.cpython-312.pyc
�

��g9��
�F�UdZddlZddlZddlZ	ddlmZddl	m
Z
ddlmZejr
ddlZddlmZej$dd	�
�Zej(ej*ej,ej.ej0ej2ej4d�Zej8eej<ej>ej>gej>ffe d<ejBejDejFd
�Z$ej8eej<ej>gej>ffe d<ejJejLejNejPejRejTd�d�d�Z+ej8eej<ej>ej>gej>ffe d<Gd�de,�Z-Gd�de.�Z/Gd�d�Z0dd	dejbe0de0fd�Z2Gd�d	e/��Z3Gd�d e3�Z4Gd!�d"e3�Z5Gd#�d$e3�Z6Gd%�d&e4�Z7Gd'�d(e4�Z8Gd)�d*e4�Z9Gd+�d,e4�Z:Gd-�d.e4�Z;Gd/�d0e4�Z<Gd1�d2e4�Z=Gd3�d4e4�Z>Gd5�d6e4�Z?Gd7�d8e4�Z@Gd9�d:e4�ZAGd;�d<e4�ZBGd=�d>e4�ZCGd?�d@e4�ZDGdA�dBe4�ZEGdC�dDe3�ZFGdE�dFeF�ZGGdG�dHeF�ZHGdI�dJeF�ZIGdK�dLeF�ZJGdM�dNeF�ZKGdO�dPeK�ZLGdQ�dReK�ZMGdS�dTeK�ZNGdU�dVeK�ZOGdW�dXeK�ZGdY�dZe5�ZPGd[�d\e5�ZQGd]�d^eF�ZRdej�d_d`ejbe0dej�ej�ej>ej8ej>ej>fffda�ZTGdb�dceF�ZUGdd�deeU�ZVGdf�dgeU�ZWGdh�dieF�ZXGdj�dkeF�ZYGdl�dmeF�ZZGdn�doeF�Z[Gdp�dqeF�Z\Gdr�dseF�Z]Gdt�due5�Z^Gdv�dweG�Z_Gdx�dyeG�Z`Gdz�d{eG�ZaGd|�d}eG�ZbGd~�deG�ZcGd��d�eG�ZdGd��d�eG�ZeGd��d�eG�ZfGd��d�eG�ZgGd��d�eH�ZhGd��d�eH�ZiGd��d�eH�ZjGd��d�eF�ZkGd��d�eF�ZlGd��d�eF�ZmGd��d�eF�ZnGd��d�eF�ZoGd��d�eF�ZpGd��d�eF�ZqGd��d�eF�ZrGd��d�e4�ZsGd��d�e4�ZtGd��d�e4�ZuGd��d�e4�ZvGd��d�e4�ZwGd��d�ew�Zxd�ej>d�ej>dd�fd��Zyezey�e/_{[yy#e$r
ddlmZY���wxYw)�z�AST nodes generated by the parser for the compiler. Also provides
some node tree helper functions used by the parser and compiler in order
to normalize nodes.
�N)�deque)�Markup�)�_PassArg)�Environment�
_NodeBound�Node)�bound)�*�/�//�**�%�+�-�_binop_to_func)�notrr�
_uaop_to_funcc�
�||vS�N���a�bs  �./usr/lib/python3/dist-packages/jinja2/nodes.py�<lambda>r.s
��q�A�v��c�
�||vSrrrs  rrr/s
��!�1�*�r)�eq�ne�gt�gteq�lt�lteq�in�notin�_cmpop_to_funcc��eZdZdZy)�
Impossiblez8Raised if the node could not perform a requested action.N��__name__�
__module__�__qualname__�__doc__rrrr)r)3s��Brr)c��eZdZdZd�Zy)�NodeTypez�A metaclass for nodes that handles the field and attribute
    inheritance.  fields and attributes from the parent class are
    automatically forwarded to the child.c��dD]�}g}|jt|r|dnt|d��|j|j|d��t	|�dksJd��t	|�t	t|��k(sJd��t
|�||<��|jdd�tj||||�S)	N)�fields�
attributesrrrz multiple inheritance not allowedzlayout conflict�abstractF)
�extend�getattr�object�get�len�set�tuple�
setdefault�type�__new__)�mcs�name�bases�d�attr�storages      rr>zNodeType.__new__<s���*�	%�D��G��N�N�7�u�5��8�&�$��K�L��N�N�1�5�5��r�?�+��u�:��?�F�$F�F�?��w�<�3�s�7�|�#4�4�G�6G�G�4��G�n�A�d�G�
	%�	
���Z��'��|�|�C��u�a�0�0rN)r+r,r-r.r>rrrr0r07s��-�	1rr0c���eZdZdZ	ddddej
eddfd�Zdejeejffd�Z
d	ejeejfddfd
�Zy)�EvalContextzcHolds evaluation time information.  Custom attributes can be attached
    to it in extensions.
    N�environmentr�
template_name�returnc��||_t|j�r|j|�|_d|_y|j|_d|_y�NF)rG�callable�
autoescape�volatile)�selfrGrHs   r�__init__zEvalContext.__init__MsK��'����K�*�*�+�)�4�4�]�C�D�O���
�*�4�4�D�O���
rc�6�|jj�Sr)�__dict__�copy�rOs r�savezEvalContext.saveWs���}�}�!�!�#�#r�oldc�n�|jj�|jj|�yr)rR�clear�update)rOrVs  r�revertzEvalContext.revertZs$���
�
�����
�
���S�!rr)r+r,r-r.�t�Optional�strrP�Mapping�AnyrUrZrrrrFrFHst���
LP��(��9:���C���	
��$�a�i�i��Q�U�U�
�+�$�"�!�)�)�C����J�/�"�D�"rrF�node�ctxrIc�b�|�,|j�td��t|j�S|S)NzIif no eval context is passed, the node must have an attached environment.)rG�RuntimeErrorrF)r`ras  r�get_eval_contextrd_s=��
�{����#��)��
��4�+�+�,�,��Jrc
��eZdZUdZdZejedfed<dZ	ejedfed<dZ
eed<ejd	ed
<dejdejddfd
�Z		ddejejedejejedej ejeejffd�Z		ddejejedejejedej dfd�Zdej&edejefd�Zdej,ej&eejej&edffdej efd�Zdeddfd�Zddededdfd�Zd d�Zdejdefd�Zej<Zdefd�Zdefd�Z y)!r	a�Baseclass for all Jinja nodes.  There are a number of nodes available
    of different types.  There are four major types:

    -   :class:`Stmt`: statements
    -   :class:`Expr`: expressions
    -   :class:`Helper`: helper nodes
    -   :class:`Template`: the outermost wrapper node

    All nodes have fields and attributes.  Fields may be other nodes, lists,
    or arbitrary values.  Fields are passed to the constructor as regular
    positional arguments, attributes as keyword arguments.  Each node has
    two attributes: `lineno` (the line number of the node) and `environment`.
    The `environment` attribute is set at the end of the parsing process for
    all nodes automatically.
    r.r2��linenorGr3TrgrrGrINc	�z�|jrtd��|r�t|�t|j�k7r�|js!tt	|�j
�d���tt	|�j
�dt|j��dt|j�dk7rd����d����t
|j|�D]\}}t|||��|jD]}t|||j|d���!|r tdtt|������y)	Nz#abstract nodes are not instantiablez takes 0 argumentsz takes 0 or z	 argumentr�s�zunknown attribute )r4�	TypeErrorr9r2r=r+�zip�setattrr3�pop�next�iter)rOr2r3r@�argrCs      rrPz
Node.__init__�s/���=�=��A�B�B���6�{�c�$�+�+�.�.��{�{�#�t�D�z�':�':�&=�=O�$P�Q�Q���D�z�*�*�-�\�#�d�k�k�:J�9K��s�4�;�;�'7�1�'<��E�G���BD�E�G���!����f�5�
)�	��c���d�C�(�
)��O�O�	<�D��D�$�
���t�T� :�;�	<���0��d�:�6F�1G�0J�K�L�L�r�exclude�onlyc#�K�|jD]%}|�|�|�||vs|��||vs�	|t||�f���'y#t$rY�4wxYw�w)aZThis method iterates over all fields that are defined and yields
        ``(key, value)`` tuples.  Per default all fields are returned, but
        it's possible to limit that to some fields by providing the `only`
        parameter or to exclude some using the `exclude` parameter.  Both
        should be sets or tuples of field names.
        N)r2r6�AttributeError)rOrrrsr@s    r�iter_fieldszNode.iter_fields�sg�����K�K�		�D���T�\��'�D��,?��$��������d� 3�3�3�		��&����s*�A�A�8�A�	A�A�A�Ac#��K�|j||�D]G\}}t|t�r|D]}t|t�s�|����3t|t�s�D|���Iy�w)z�Iterates over all direct child nodes of the node.  This iterates
        over all fields and yields the values of they are nodes.  If the value
        of a field is a list all the nodes in that list are returned.
        N)rv�
isinstance�listr	)rOrrrs�_�item�ns      r�iter_child_nodeszNode.iter_child_nodes�sa�����'�'���6�	�G�A�t��$��%�� �A�!�!�T�*��� ��D�$�'��
�
	�s�>A �A �A �	node_typec�6�|j|�D]}|cSy)ziFind the first node of a given type.  If no such node exists the
        return value is `None`.
        N)�find_all)rOr~�results   r�findz	Node.find�s&���m�m�I�.�	�F��M�	�rc#�K�|j�D]+}t||�r|��|j|�Ed{����-y7��w)z�Find all the nodes of a given type.  If the type is a tuple,
        the check is performed for any of the tuple items.
        N)r}rxr�)rOr~�childs   rr�z
Node.find_all�sF�����*�*�,�	1�E��%��+����~�~�i�0�0�0�	1�
1�s�8A�A�Arac��t|g�}|rG|j�}d|jvr||_|j	|j��|r�G|S)aReset the context of a node and all child nodes.  Per default the
        parser will all generate nodes that have a 'load' context as it's the
        most common one.  This method is used in the parser to set assignment
        targets and other nodes to a store context.
        ra)r�popleftr2rar5r})rOra�todor`s    r�set_ctxzNode.set_ctx�sQ���d�V�}����<�<�>�D�����#�����K�K��-�-�/�0�	�
�r�overridec���t|g�}|rU|j�}d|jvr|j�|r||_|j	|j��|r�U|S)z.Set the line numbers of the node and children.rg)rr�r3rgr5r})rOrgr�r�r`s     r�
set_linenozNode.set_lineno�s[���d�V�}����<�<�>�D��4�?�?�*��;�;�&�(�"(�D�K��K�K��-�-�/�0���rc��t|g�}|r9|j�}||_|j|j	��|r�9|S)z"Set the environment for all nodes.)rr�rGr5r})rOrGr�r`s    r�set_environmentzNode.set_environment�sD���d�V�}����<�<�>�D�*�D���K�K��-�-�/�0���r�otherc��t|�t|�urtSt|j��t|j��k(Sr)r=�NotImplementedr;rv)rOr�s  r�__eq__zNode.__eq__�s?����:�T�%�[�(�!�!��T�%�%�'�(�E�%�2C�2C�2E�,F�F�Frc���dj�fd��jD��}t��j�d|�d�S)N�, c3�B�K�|]}|�dt�|d������y�w)�=N)r6)�.0rrOs  �r�	<genexpr>z Node.__repr__.<locals>.<genexpr>�s&�����T�1��s�!�G�D�!�T�$:�#=�>�T�s��(�))�joinr2r=r+)rO�args_strs` r�__repr__z
Node.__repr__�s9����9�9�T����T�T���t�*�%�%�&�a��z��3�3rc����dtjttjfddf��fd��g��|�dj	��S)Nr`rIc�T��t|t�s�jt|��y�jdt	|�j
�d��|js�jd�yt|j�D]�\}}|r�jd�t||�}t|t�rQ�jd�t|�D] \}}|r�jd��|��"�jd����|����jd�y)Nznodes.r�r�r��[�])
rxr	�append�reprr=r+r2�	enumerater6ry)r`�idx�field�valuer{�_dump�bufs     ��rr�zNode.dump.<locals>._dump�s�����d�D�)��
�
�4��:�&���J�J���T�
� 3� 3�4�A�6�7��;�;��
�
�3���'����4�
!�
��U���J�J�t�$���e�,���e�T�*��J�J�s�O�%.�u�%5�$�	��T���J�J�t�,��d��$��J�J�s�O��%�L�
!�
�J�J�s�Orrj)r[�Unionr	r_r�)rOr�r�s @@r�dumpz	Node.dump�sC���	�����a�e�e��,�	��	�0��
�d���w�w�s�|�r�NN)F)rGrrIr	)!r+r,r-r.r2r[�Tupler]�__annotations__r3r4�intr\r_rP�	Container�Iteratorrvr}�Typerr�r�r�r��boolr�r�r�r7�__hash__r�r�rrrr	r	js��� !#�F�A�G�G�C��H��"�$=�J�����S��!�=��H��K����M�*�*�M����M�Q�U�U�M�t�M�(15�-1�����A�K�K��,�-���j�j����S�)�*��
���A�G�G�C����J�'�	(�	�015�-1�����A�K�K��,�-���j�j����S�)�*��
���F�	�	�"�a�f�f�Z�0��Q�Z�Z�
�5K��	1�������
�!3�Q�W�W�Q�V�V�J�=O�QT�=T�5U�!U�V�	1�	
���J�	�	1��3��6��	��	��	��	��G�A�E�E�G�d�G����H�4�#�4��c�r)�	metaclassc��eZdZdZdZy)�StmtzBase node for all statements.TN�r+r,r-r.r4rrrr�r�s
��'��Hrr�c��eZdZdZdZy)�Helperz,Nodes that exist in a specific context only.TNr�rrrr�r�!s
��6��Hrr�c�:�eZdZUdZdZejeed<y)�TemplatezjNode that represents a template.  This must be the outermost node that
    is passed to the compiler.
    ��bodyr�N�	r+r,r-r.r2r[�Listr	r�rrrr�r�'s����F�
�&�&��,�rr�c�:�eZdZUdZdZejded<y)�Outputz�A node that holds multiple expressions which are then printed out.
    This is used both for the `print` statement and the regular template data.
    ��nodes�Exprr�N)r+r,r-r.r2r[r�r�rrrr�r�0s����F��6�6�&�>�rr�c� �eZdZUdZdZded<y)�Extendsz Represents an extends statement.)�templater�r�N)r+r,r-r.r2r�rrrr�r�9s��*�
�F��rr�c��eZdZUdZdZeed<eed<ejeed<ejeed<ejeed<e
ed<y	)
�ForaxThe for loop.  `target` is the target for the iteration (usually a
    :class:`Name` or :class:`Tuple`), `iter` the iterable.  `body` is a list
    of nodes that are used as loop-body, and `else_` a list of nodes for the
    `else` block.  If no else node exists it has to be an empty list.

    For filtered nodes an expression can be stored as `test`, otherwise `None`.
    )�targetrpr��else_�test�	recursiver�rpr�r�r�r�N)r+r,r-r.r2r	r�r[r�r\r�rrrr�r�@sI���F�F��L�
�J�
�&�&��,���6�6�$�<��
�*�*�T�
���Orr�c��eZdZUdZdZeed<ejeed<ejded<ejeed<y)�Ifz4If `test` is true, `body` is rendered, else `else_`.)r�r��elif_r�r�r�r�r�N)	r+r,r-r.r2r	r�r[r�rrrr�r�Rs9��>�
/�F�
�J�
�&�&��,���6�6�$�<���6�6�$�<�rr�c��eZdZUdZdZeed<ejded<ejded<eje	ed<y	)
�Macroz�A macro definition.  `name` is the name of the macro, `args` a list of
    arguments and `defaults` a list of defaults if there are any.  `body` is
    a list of nodes for the macro body.
    )r@�args�defaultsr�r@�Namer�r�r�r�N)
r+r,r-r.r2r]r�r[r�r	rrrr�r�\s=���
2�F�

�I�
�&�&��.���f�f�V�n��
�&�&��,�rr�c��eZdZUdZdZded<ejded<ejded<ejeed	<y
)�	CallBlockz�Like a macro without a name but a call instead.  `call` is called with
    the unnamed macro as `caller` argument this node holds.
    )�callr�r�r��Callr�r�r�r�r�r�N)	r+r,r-r.r2r�r[r�r	rrrr�r�is=���2�F�
�L�
�&�&��.���f�f�V�n��
�&�&��,�rr�c�D�eZdZUdZdZejeed<ded<y)�FilterBlockzNode for filter sections.)r��filterr��Filterr�Nr�rrrr�r�us��#�
�F�
�&�&��,���rr�c��eZdZUdZdZejded<ejded<ejeed<y)�Withz�Specific node for with statements.  In older versions of Jinja the
    with statement was implemented on the base of the `Scope` node instead.

    .. versionadded:: 2.9.3
    )�targets�valuesr�r�r�r�r�N)	r+r,r-r.r2r[r�r�r	rrrr�r�}s8���+�F�
�V�V�F�^��
�F�F�6�N��
�&�&��,�rr�c�X�eZdZUdZdZeed<eje	ed<e
ed<e
ed<y)�BlockzkA node that represents a block.

    .. versionchanged:: 3.0.0
        the `required` field was added.
    )r@r��scoped�requiredr@r�r�r�N)r+r,r-r.r2r]r�r[r�r	r�rrrr�r��s+���4�F�

�I�
�&�&��,���L��Nrr�c�4�eZdZUdZdZded<eed<eed<y)�Includez'A node that represents the include tag.)r��with_context�ignore_missingr�r�r�r�N)r+r,r-r.r2r�r�rrrr�r��s��1�
;�F������rr�c�4�eZdZUdZdZded<eed<eed<y)�Importz&A node that represents the import tag.)r�r�r�r�r�r�r�N)r+r,r-r.r2r�r]r�rrrr�r��s��0�
3�F����K��rr�c��eZdZUdZdZded<ejeje	eje	e	ffed<eed<y)�
FromImportaA node that represents the from import tag.  It's important to not
    pass unsafe names to the name attribute.  The compiler translates the
    attribute lookups directly into getattr calls and does *not* use the
    subscript callback of the interface.  As exported variables may not
    start with double underscores (which the parser asserts) this is not a
    problem for regular Jinja code, but if this node is used in an extension
    extra care must be taken.

    The list of names may contain tuples if aliases are wanted.
    )r��namesr�r�r�r�r�N)r+r,r-r.r2r�r[r�r�r]r�r�rrrr�r��sD��	�3�F����6�6�!�'�'�#�q�w�w�s�C�x�0�0�1�2�2��rr�c� �eZdZUdZdZeed<y)�ExprStmtzAA statement that evaluates an expression and discards the result.�r`r`N)r+r,r-r.r2r	r�rrrr�r��s��K�
�F�
�Jrr�c�*�eZdZUdZdZded<eed<y)�Assignz"Assigns an expression to a target.)r�r`r�r�r`N)r+r,r-r.r2r�r	rrrr�r��s��,�
�F��N�
�Jrr�c�h�eZdZUdZdZded<ejded<eje	ed<y)	�AssignBlockzAssigns a block to a target.)r�r�r�r�r�r�r�r�N)
r+r,r-r.r2r�r[r\r�r	rrrr�r��s,��&�
)�F��N�
�J�J�x� � �
�&�&��,�rr�c�`�eZdZdZdZddejedejfd�Z	de
fd�Zy)	r�zBaseclass for all expressions.TN�eval_ctxrIc��t��)anReturn the value of the expression as constant or raise
        :exc:`Impossible` if this was not possible.

        An :class:`EvalContext` can be provided, if none is given
        a default context is created which requires the nodes to have
        an attached environment.

        .. versionchanged:: 2.4
           the `eval_ctx` parameter was added.
        )r)�rOr�s  r�as_constz
Expr.as_const�s���l�rc��y)z8Check if it's possible to assign something to this node.FrrTs r�
can_assignzExpr.can_assign�s��rr)r+r,r-r.r4r[r\rFr_r�r�r�rrrr�r��s6��(��H�����K�!8��A�E�E���D�rr�c�x�eZdZUdZdZeed<eed<eed<dZdde	jed	e	jfd
�Z
y)�BinExprz%Baseclass for all binary expressions.)�left�rightr�r�operatorTNr�rIc�t�t||�}|jjr,|j|jjvr
t��t|j}	||jj|�|jj|��S#t$r}t�|�d}~wwxYwr)rdrG�	sandboxedr�intercepted_binopsr)rr�r�r�	Exception�rOr��f�es    rr�zBinExpr.as_const�s���#�D�(�3��
� � �*�*��
�
��!5�!5�!H�!H�H��,���4�=�=�)��	&��T�Y�Y�'�'��1�4�:�:�3F�3F�x�3P�Q�Q���	&��,�A�%��	&�s�#:B�	B7�'B2�2B7r�r+r,r-r.r2r�r�r]r4r[r\rFr_r�rrrr�r��s>��/�
�F�
�J��K��M��H�
&����K�!8�
&�A�E�E�
&rr�c�n�eZdZUdZdZeed<eed<dZd
de	jede	jfd	�Z
y)�	UnaryExprz$Baseclass for all unary expressions.r�r`rTNr�rIc�@�t||�}|jjr,|j|jjvr
t��t|j}	||jj|��S#t$r}t�|�d}~wwxYwr)
rdrGrr�intercepted_unopsr)rr`r�rrs    rr�zUnaryExpr.as_consts���#�D�(�3��
� � �*�*��
�
��!5�!5�!G�!G�G��,���$�-�-�(��	&��T�Y�Y�'�'��1�2�2���	&��,�A�%��	&�s�# B�	B�
B�Brr	rrrrrs9��.�
�F�
�J��M��H�
&����K�!8�
&�A�E�E�
&rrc�6�eZdZUdZdZeed<eed<defd�Zy)r�aLooks up a name or stores a value in a name.
    The `ctx` of the node can be one of the following values:

    -   `store`: store a value in the name
    -   `load`: load that name
    -   `param`: like `store` but if the name was defined as function parameter.
    )r@rar@rarIc��|jdvS)N>�None�True�none�true�False�false�r@rTs rr�zName.can_assign)s���y�y� R�R�RrN�	r+r,r-r.r2r]r�r�r�rrrr�r�s&����F�

�I�	�H�S�D�Srr�c�6�eZdZUdZdZeed<eed<defd�Zy)�NSRefz)Reference to a namespace value assignment)r@rCr@rCrIc��y)NTrrTs rr�zNSRef.can_assign4s��
rNrrrrrr-s ��3�
�F�

�I�

�I��D�rrc��eZdZdZdZy)�LiteralzBaseclass for literals.TNr�rrrrr<s
��!��Hrrc
���eZdZUdZdZejed<ddeje	dejfd�Z
e		d
dejdejed	d
ddfd��Z
y)�ConstaAll constant values.  The parser will return this node for simple
    constants such as ``42`` or ``"foo"`` but it can be used to store more
    complex values such as lists too.  Only constants with a safe
    representation (objects where ``eval(repr(x)) == x`` is true).
    �r�r�Nr�rIc��|jSrrr�s  rr�zConst.as_constLs���z�z�rrgrGzt.Optional[Environment]c�H�ddlm}||�s
t��||||��S)z�Return a const object if the value is representable as
        constant value in the generated code, otherwise it will raise
        an `Impossible` exception.
        r)�
has_safe_reprrf)�compilerr"r))�clsr�rgrGr"s     r�from_untrustedzConst.from_untrustedOs&��	,��U�#��,���5��[�A�Arrr�)r+r,r-r.r2r[r_r�r\rFr��classmethodr�r%rrrrrBs�����F��5�5�L�����K�!8��A�E�E���#'�15�	B��u�u�B��
�
�3��B�/�	B�

�B��Brrc�L�eZdZUdZdZeed<ddeje	defd�Z
y)	�TemplateDatazA constant template string.)�datar)Nr�rIc��t||�}|jr
t��|jrt	|j
�S|j
Sr)rdrNr)rMrr)r�s  rr�zTemplateData.as_constgsA��#�D�(�3������,������$�)�)�$�$��y�y�rr)r+r,r-r.r2r]r�r[r\rFr�rrrr(r(as+��%�
�F�

�I�����K�!8��C�rr(c��eZdZUdZdZejeed<e	ed<ddejedejejdffd	�Zdefd
�Zy)r�z�For loop unpacking and some other things like multiple arguments
    for subscripts.  Like for :class:`Name` `ctx` specifies if the tuple
    is used for loading the names or storing.
    )�itemsrar,raNr�rI.c�X��t|���t�fd�|jD��S)Nc3�@�K�|]}|j�����y�wr�r��r��xr�s  �rr�z!Tuple.as_const.<locals>.<genexpr>|s�����>�a�Q�Z�Z��)�>���)rdr;r,r�s `rr�zTuple.as_constzs$���#�D�(�3���>�4�:�:�>�>�>rc�J�|jD]}|j�r�yy)NFT)r,r�)rOr{s  rr�zTuple.can_assign~s'���J�J�	�D��?�?�$��	�rr)r+r,r-r.r2r[r�r�r�r]r\rFr�r_r�r�r�rrrr�r�ps[���
�F��6�6�$�<��	�H�?����K�!8�?�A�G�G�A�E�E�SV�J�DW�?��D�rr�c��eZdZUdZdZejeed<ddeje
dejejfd�Zy)	r�z&Any list literal such as ``[1, 2, 3]``�r,r,Nr�rIc�v�t||�}|jD�cgc]}|j|���c}Scc}wr)rdr,r�)rOr�r1s   rr�z
List.as_const�s/��#�D�(�3��.2�j�j�9���
�
�8�$�9�9��9s�6r)
r+r,r-r.r2r[r�r�r�r\rFr_r�rrrr�r��s@��0�
�F��6�6�$�<��:����K�!8�:�A�F�F�1�5�5�M�:rr�c��eZdZUdZdZejded<	d	deje	dejejejffd�Zy)
�DictzeAny dict literal such as ``{1: 2, 3: 4}``.  The items must be a list of
    :class:`Pair` nodes.
    r5�Pairr,Nr�rIc�X��t|���t�fd�|jD��S)Nc3�@�K�|]}|j�����y�wrr/r0s  �rr�z Dict.as_const.<locals>.<genexpr>�s�����=�Q�A�J�J�x�(�=�r2)rd�dictr,r�s `rr�z
Dict.as_const�s&���$�D�(�3���=�$�*�*�=�=�=rr)
r+r,r-r.r2r[r�r�r\rFr8r_r�rrrr8r8�sT����F��6�6�&�>��37�>��
�
�;�/�>�	
������q�u�u��	�>rr8c��eZdZUdZdZeed<eed<	d	deje	dejejejffd�Zy)
r9zA key, value pair for dicts.��keyr�r?r�Nr�rIc��t||�}|jj|�|jj|�fSr)rdr?r�r�r�s  rr�z
Pair.as_const�s9��$�D�(�3���x�x� � ��*�D�J�J�,?�,?��,I�I�Irr)
r+r,r-r.r2r�r�r[r\rFr�r_r�rrrr9r9�sO��&�
�F�	
�I��K�37�J��
�
�;�/�J�	
����������	�Jrr9c��eZdZUdZdZeed<eed<d	deje
dejeejffd�Z
y)
�Keywordz>A key, value pair for keyword arguments where key is a string.r>r?r�Nr�rIc�h�t||�}|j|jj|�fSr)rdr?r�r�r�s  rr�zKeyword.as_const�s,��#�D�(�3���x�x����,�,�X�6�6�6rr)r+r,r-r.r2r]r�r�r[r\rFr�r_r�rrrrBrB�sD��H�
�F�	�H��K�7����K�!8�7�A�G�G�C�QR�QV�QV�J�DW�7rrBc��eZdZUdZdZeed<eed<ejeed<d
deje	dejfd	�Zy)�CondExprzZA conditional expression (inline if expression).  (``{{
    foo if bar else baz }}``)
    )r��expr1�expr2r�rFrGNr�rIc���t||�}|jj|�r|jj|�S|j�
t��|jj|�Sr)rdr�r�rFrGr)r�s  rr�zCondExpr.as_const�s^��#�D�(�3���9�9���h�'��:�:�&�&�x�0�0��:�:���,���z�z�"�"�8�,�,rr)r+r,r-r.r2r�r�r[r\rFr_r�rrrrErE�sG���(�F�
�J��K��:�:�d���	-����K�!8�	-�A�E�E�	-rrE)�_FilterTestCommonr�r�c���|jD�cgc]}|j����}}t�fd�|jD��}|j�+	|j|jj���|j�/	|j|jj���||fS||fScc}w#t$r}t�|�d}~wwxYw#t$r}t�|�d}~wwxYw)Nc3�@�K�|]}|j�����y�wrr/r0s  �rr�z args_as_const.<locals>.<genexpr>�s�����<�1�!�*�*�X�&�<�r2)
r�r�r<�kwargs�dyn_argsr5rr)�
dyn_kwargsrY)r`r�r1r�rLrs `    r�
args_as_constrO�s����+/�)�)�4�Q�A�J�J�x� �4�D�4�
�<����<�
<�F��}�}� �	&��K�K��
�
�.�.�x�8�9����"�	&��M�M�$�/�/�2�2�8�<�=���<��4��<���5���	&��,�A�%��	&���	&��,�A�%��	&�s5�B>�*C�*C�	C�C�C�	C8�(C3�3C8c��eZdZUdZeed<eed<ejeed<eje	ed<ejeed<ejeed<dZdZd
d
eje
dejfd�Zy	)rI)r`r@r�rLrMrNr`r@r�rLrMrNTNr�rIc�@�t||�}|jr
t��|jr|jj
}n|jj}|j|j�}tj|�}|�|tjur
t��|jjr.t|dd�dustj|�r
t��t!||�\}}|j#d|j$j'|��|tj(ur|j#d|�n.|tjur|j#d|j�	||i|��S#t*$r}t�|�d}~wwxYw)N�jinja_async_variantFTr)rdrNr)�
_is_filterrG�filters�testsr8r@r�from_obj�context�is_asyncr6�inspect�iscoroutinefunctionrO�insertr`r��eval_contextr)rOr��env_map�func�pass_argr�rLrs        rr�z_FilterTestCommon.as_const�sU��#�D�(�3������,���?�?��*�*�2�2�G��*�*�0�0�G��{�{�4�9�9�%���$�$�T�*���<�8�x�'7�'7�7��,�����(�(��D�/��7�4�?��*�*�4�0��,��$�T�8�4���f����A�t�y�y�)�)�(�3�4��x�,�,�,��K�K��8�$�
��-�-�
-��K�K��8�/�/�0�	&���(��(�(���	&��,�A�%��	&�s�<F�	F�
F�Fr)r+r,r-r2r�r�r]r[r�r9r\r4rSrFr_r�rrrrIrI�su��
I�F�
�J�

�I�
�&�&��,��
�F�F�4�L���j�j�����
�
�4� � ��H��J�"&����K�!8�"&�A�E�E�"&rrIc���eZdZUdZej
eed<ddej
edejf�fd�
Z
�xZS)r�z�Apply a filter to an expression. ``name`` is the name of the
    filter, the other fields are the same as :class:`Call`.

    If ``node`` is ``None``, the filter is being used in a filter block
    and is applied to the content of the block.
    r`r�rIc�P��|j�
t��t�|�
|��S)N)r�)r`r)�superr�)rOr��	__class__s  �rr�zFilter.as_consts(����9�9���,���w����2�2rr)r+r,r-r.r[r\r�r�rFr_r��
__classcell__)rcs@rr�r�s>�����*�*�T�
��3����K�!8�3�A�E�E�3�3rr�c��eZdZdZdZy)�Testa/Apply a test to an expression. ``name`` is the name of the test,
    the other field are the same as :class:`Call`.

    .. versionchanged:: 3.0
        ``as_const`` shares the same logic for filters and tests. Tests
        check for volatile, async, and ``@pass_context`` etc.
        decorators.
    FN)r+r,r-r.rSrrrrfrf%s����Jrrfc��eZdZUdZdZeed<ejeed<eje	ed<ejeed<ejeed<y)	r�a/Calls an expression.  `args` is a list of arguments, `kwargs` a list
    of keyword arguments (list of :class:`Keyword` nodes), and `dyn_args`
    and `dyn_kwargs` has to be either `None` or a node that is used as
    node for dynamic positional (``*args``) or keyword (``**kwargs``)
    arguments.
    )r`r�rLrMrNr`r�rLrMrNN)r+r,r-r.r2r�r�r[r�rBr\rrrr�r�2sN���B�F�
�J�
�&�&��,��
�F�F�7�O���j�j�����
�
�4� � rr�c�t�eZdZUdZdZeed<eed<eed<d
deje
dejfd	�Zy)�Getitemz@Get an attribute or item from an expression and prefer the item.)r`rqrar`rqraNr�rIc�"�|jdk7r
t��t||�}	|jj	|j
j
|�|jj
|��S#t$r}t�|�d}~wwxYw�N�load)	rar)rdrG�getitemr`r�rqr�rOr�rs   rr�zGetitem.as_constJs���8�8�v���,��#�D�(�3��	&��'�'�/�/��	�	�"�"�8�,�d�h�h�.?�.?��.I��
���	&��,�A�%��	&�s�A
A5�5	B�>B	�	Br�
r+r,r-r.r2r�r�r]r[r\rFr_r�rrrririBs9��J�
#�F�
�J�	
�I�	�H�&����K�!8�&�A�E�E�&rric�t�eZdZUdZdZeed<eed<eed<d
deje
dejfd	�Zy)�GetattrznGet an attribute or item from an expression that is a ascii-only
    bytestring and prefer the attribute.
    )r`rCrar`rCraNr�rIc��|jdk7r
t��t||�}	|jj	|j
j
|�|j�S#t$r}t�|�d}~wwxYwrk)	rar)rdrGr6r`r�rCrrns   rr�zGetattr.as_constbsm���8�8�v���,��#�D�(�3��	&��'�'�/�/��	�	�0B�0B�8�0L�d�i�i�X�X���	&��,�A�%��	&�s�>A&�&	A?�/A:�:A?rrorrrrqrqXs=���%�F�
�J�

�I�	�H�	&����K�!8�	&�A�E�E�	&rrqc��eZdZUdZdZejeed<ejeed<ejeed<d
deje	de
fd	�Zy)�Slicez_Represents a slice object.  This must only be used as argument for
    :class:`Subscript`.
    )�start�stop�steprurvrwNr�rIc���t|���dtjtdtjtjf�fd�}t||j�||j�||j��S)N�objrIc�,��|�y|j��Srr/)ryr�s �r�constzSlice.as_const.<locals>.const{s����{���<�<��)�)r)	rdr[r\r�r_�slicerurvrw)rOr�r{s ` rr�zSlice.as_constxsd���#�D�(�3��	*�q�z�z�$�'�	*�A�J�J�q�u�u�,=�	*�
�U�4�:�:�&��d�i�i�(8�%��	�	�:J�K�Krr)r+r,r-r.r2r[r\r�r�rFr|r�rrrrtrtnsZ���'�F��:�:�d���
�*�*�T�
��
�*�*�T�
��L����K�!8�L�E�Lrrtc�f�eZdZUdZdZejeed<ddeje
defd�Zy)	�ConcatzXConcatenates the list of expressions provided after converting
    them to strings.
    r�r�Nr�rIc�d��t|���dj�fd�|jD��S)Nrjc3�R�K�|]}t|j������ y�wr)r]r�r0s  �rr�z"Concat.as_const.<locals>.<genexpr>�s�����E�Q�s�1�:�:�h�/�0�E�s�$')rdr�r�r�s `rr�zConcat.as_const�s(���#�D�(�3���w�w�E�$�*�*�E�E�Err)
r+r,r-r.r2r[r�r�r�r\rFr]r�rrrr~r~�s;����F��6�6�$�<��F����K�!8�F�C�Frr~c��eZdZUdZdZeed<ejded<d
deje
dejfd	�Zy)�CompareziCompares an expression with some other expressions.  `ops` must be a
    list of :class:`Operand`\s.
    )�expr�opsr��Operandr�Nr�rIc�*�t||�}|jj|�x}}	|jD]<}|jj|�}t	|j
||�}|sy|}�>	|S#t$r}t�|�d}~wwxYwrK)rdr�r�r�r'�oprr))rOr�r�r�r��	new_valuers       rr�zCompare.as_const�s���#�D�(�3�����+�+�H�5�5���
	&��h�h�
"���G�G�,�,�X�6�	�'����.�u�i�@��� �!��
"��
���	&��,�A�%��	&�s�AA9�2A9�9	B�B
�
Br)
r+r,r-r.r2r�r�r[r�r\rFr_r�rrrr�r��sB����F�
�J�	
���	�	������K�!8��A�E�E�rr�c�*�eZdZUdZdZeed<eed<y)r�z$Holds an operator and an expression.)r�r�r�r�N)r+r,r-r.r2r]r�r�rrrr�r��s��.�
�F��G�
�Jrr�c��eZdZdZdZy)�Mulz(Multiplies the left with the right node.rN�r+r,r-r.rrrrr�r��s
��2��Hrr�c��eZdZdZdZy)�Divz#Divides the left by the right node.rNr�rrrr�r��s
��-��Hrr�c��eZdZdZdZy)�FloorDivzbDivides the left by the right node and converts the
    result into an integer by truncating.
    r
Nr�rrrr�r��s����Hrr�c��eZdZdZdZy)�AddzAdd the left to the right node.rNr�rrrr�r��s
��)��Hrr�c��eZdZdZdZy)�Subz&Subtract the right from the left node.rNr�rrrr�r��s
��0��Hrr�c��eZdZdZdZy)�ModzLeft modulo right.rNr�rrrr�r��s
����Hrr�c��eZdZdZdZy)�PowzLeft to the power of right.rNr�rrrr�r��s
��%��Hrr�c�T�eZdZdZdZddejedejfd�Z	y)�AndzShort circuited AND.�andNr�rIc��t||�}|jj|�xr|jj|�Sr�rdr�r�rr�s  rr�zAnd.as_const�s7��#�D�(�3���y�y�!�!�(�+�M��
�
�0C�0C�H�0M�Mrr�
r+r,r-r.rr[r\rFr_r�rrrr�r��s-����H�N����K�!8�N�A�E�E�Nrr�c�T�eZdZdZdZddejedejfd�Z	y)�OrzShort circuited OR.�orNr�rIc��t||�}|jj|�xs|jj|�Srr�r�s  rr�zOr.as_const�s7��#�D�(�3���y�y�!�!�(�+�L�t�z�z�/B�/B�8�/L�Lrrr�rrrr�r��s-����H�M����K�!8�M�A�E�E�Mrr�c��eZdZdZdZy)�NotzNegate the expression.rNr�rrrr�r��s
�� ��Hrr�c��eZdZdZdZy)�NegzMake the expression negative.rNr�rrrr�r��s
��'��Hrr�c��eZdZdZdZy)�Posz8Make the expression positive (noop for most expressions)rNr�rrrr�r�s
��B��Hrr�c� �eZdZUdZdZeed<y)�EnvironmentAttributez�Loads an attribute from the environment object.  This is useful for
    extensions that want to call a callback stored on the environment.
    rr@N�r+r,r-r.r2r]r�rrrr�r�	s����F�

�Irr�c�*�eZdZUdZdZeed<eed<y)�ExtensionAttributez�Returns the attribute of an extension bound to the environment.
    The identifier is the identifier of the :class:`Extension`.

    This node is usually constructed by calling the
    :meth:`~jinja2.ext.Extension.attr` method on an extension.
    )�
identifierr@r�r@Nr�rrrr�r�s���$�F��O�

�Irr�c� �eZdZUdZdZeed<y)�ImportedNamea&If created with an import name the import name is returned on node
    access.  For example ``ImportedName('cgi.escape')`` returns the `escape`
    function from the cgi module on evaluation.  Imports are optimized by the
    compiler so there is no need to assign them to local variables.
    )�
importnamer�Nr�rrrr�r�s����F��Orr�c�(�eZdZUdZdZeed<dd�Zy)�InternalNamea6An internal name in the compiler.  You cannot create these nodes
    yourself but the parser provides a
    :meth:`~jinja2.parser.Parser.free_identifier` method that creates
    a new identifier for you.  This identifier is not available from the
    template and is not treated specially by the compiler.
    rr@Nc��td��)NzKCan't create internal names.  Use the `free_identifier` method on a parser.�rkrTs rrPzInternalName.__init__5s���
4�
�	
r)rIN)r+r,r-r.r2r]r�rPrrrr�r�*s����F�

�I�
rr�c�L�eZdZUdZdZeed<ddeje	de
fd�Zy)	�MarkSafez:Mark the wrapped expression as safe (wrap it as `Markup`).�r�r�Nr�rIc�b�t||�}t|jj|��Sr)rdrr�r�r�s  rr�zMarkSafe.as_constBs(��#�D�(�3���d�i�i�(�(��2�3�3rr)r+r,r-r.r2r�r�r[r\rFrr�rrrr�r�<s+��D�
�F�
�J�4����K�!8�4�F�4rr�c��eZdZUdZdZeed<	ddeje	dejeejffd�Z
y)	�MarkSafeIfAutoescapez�Mark the wrapped expression as safe (wrap it as `Markup`) but
    only if autoescaping is active.

    .. versionadded:: 2.5
    r�r�Nr�rIc��t||�}|jr
t��|jj	|�}|j
rt
|�S|Sr)rdrNr)r�r�rMr)rOr�r�s   rr�zMarkSafeIfAutoescape.as_constQsM��$�D�(�3������,���y�y�!�!�(�+������$�<���rr)r+r,r-r.r2r�r�r[r\rFr�rr_r�rrrr�r�GsG����F�
�J�37�	��
�
�;�/�	�	
��������	�	rr�c��eZdZdZy)�ContextReferenceaMReturns the current template context.  It can be used like a
    :class:`Name` node, with a ``'load'`` ctx and will return the
    current :class:`~jinja2.runtime.Context` object.

    Here an example that assigns the current template name to a
    variable named `foo`::

        Assign(Name('foo', ctx='store'),
               Getattr(ContextReference(), 'name'))

    This is basically equivalent to using the
    :func:`~jinja2.pass_context` decorator when using the high-level
    API, which causes a reference to the context to be passed as the
    first argument to a function.
    Nr*rrrr�r�]s��rr�c��eZdZdZy)�DerivedContextReferencez�Return the current template context including locals. Behaves
    exactly like :class:`ContextReference`, but includes local
    variables, such as from a ``for`` loop.

    .. versionadded:: 2.11
    Nr*rrrr�r�os��rr�c��eZdZdZy)�ContinuezContinue a loop.Nr*rrrr�r�xs��rr�c��eZdZdZy)�Breakz
Break a loop.Nr*rrrr�r�|s��rr�c�:�eZdZUdZdZejeed<y)�ScopezAn artificial scope.r�r�Nr�rrrr�r��s���
�F�
�&�&��,�rr�c�D�eZdZUdZdZeed<eje	ed<y)�OverlayScopea�An overlay scope for extensions.  This is a largely unoptimized scope
    that however can be used to introduce completely arbitrary variables into
    a sub scope from a dictionary or dictionary like object.  The `context`
    field has to evaluate to a dictionary object.

    Example usage::

        OverlayScope(context=self.call_method('get_context'),
                     body=[...])

    .. versionadded:: 2.10
    )rWr�rWr�N)
r+r,r-r.r2r�r�r[r�r	rrrr�r��s!���!�F�
�M�
�&�&��,�rr�c�:�eZdZUdZdZejeed<y)�EvalContextModifiera
Modifies the eval context.  For each option that should be modified,
    a :class:`Keyword` has to be added to the :attr:`options` list.

    Example to change the `autoescape` setting::

        EvalContextModifier(options=[Keyword('autoescape', Const(True))])
    )�optionsr�N)	r+r,r-r.r2r[r�rBr�rrrr�r��s����F�
�V�V�G�_�rr�c�:�eZdZUdZdZejeed<y)�ScopedEvalContextModifierz�Modifies the eval context and reverts it later.  Works exactly like
    :class:`EvalContextModifier` but will only modify the
    :class:`~jinja2.nodes.EvalContext` for nodes in the :attr:`body`.
    r�r�Nr�rrrr�r��s���
�F�
�&�&��,�rr�r�rLzte.NoReturnc��td��)Nzcan't create custom node typesr�)r�rLs  r�_failing_newr��s��
�4�
5�5r)|r.rYr�typingr[�collections.abcr�ImportError�collections�
markupsafer�utilsr�
TYPE_CHECKING�typing_extensions�terGr�TypeVarr�mul�truediv�floordiv�pow�mod�add�subrr8r]�Callabler_r��not_�pos�negrrr r!�ger#�ler'rr)r=r0rFr\rdr	r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�rr�rrrr(r�r�r9rBrEr�rOrIr�rfr�rirqrtr~r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r��staticmethodr>rrr�<module>r�s�������"�%����?�?�"�(�
�Q�Y�Y�|�6�
2�
�
���	�	�	�
�
�
�
�,�,�	���	���	���B�����s�A�J�J����q�u�u�~�q�u�u�'<�=�=�>���=�=�	���	���:�
�q�v�v�c�1�:�:�q�u�u�g�q�u�u�n�5�5�6���+�+�
�+�+�
�+�+��K�K�
�+�+��K�K�
�
$�	B�����s�A�J�J����q�u�u�~�q�u�u�'<�=�=�>�	�C��C�1�t�1�""�"�.�6���
�
�;�(?��K��n�X�n�b�4���T���t���T���d���$��$���
�D�
�	��	��$��
�4�
��D���d���T�����$�t���T���$���4��.&�d�&�2&��&�0S�4�S�"�D���d��B�G�B�>�7���G��*:�7�:�>�7�>�J�6�J�	7�f�	7�-�t�-�,�
�'�'�-�
.��:;�*�*�[�:Q���W�W�Q�V�V�A�E�E�]�A�F�F�1�5�5�!�%�%�<�0�
0�1��*-&��-&�`3�
�3�"
��
�
!�4�
!� &�d�&�,&�d�&�,L�D�L�*
F�T�
F��d��8�f���'���'���w���'���'���'���'��N�'�N�M��M��)���)���)���4��
��
��4��
�4�
�$4�t�4��4��,�t��$�d���t���D���D���4��&
�$�
�� 3��6����6����6�=�6� ��-�����[%�"�!�!�"�s�V�V �V 
¿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!