Ë
    Q5ýj–O  ã                   ó°  — d dl Z d dlmZmZ d dlmZ d dlmZ d dlZ	d dl
Z	d dlZ	d dlZ	d dlZ	d dlZ	d dlZ	d dlZ	d dlZ	 G d„ de j$                  «      Z G d„ de	j(                  j*                  «      Ze	j,                  j,                   G d	„ d
e«      «       Z G d„ de	j0                  j2                  e	j4                  j6                     «      Z G d„ de	j:                  j<                  «      Z ed¬«       G d„ d«      «       Ze	j,                  j,                   G d„ de	j:                  j@                  «      «       Z! G d„ de	jD                  jF                  «      Z#y)é    N)ÚCallableÚMutableMapping)Ú	dataclass)Úcastc                   ó   — e Zd ZdZdZdZdZy)Ú	NodeFlagsa&  Flags that classify a node's role in the zone.

    ``ORIGIN`` is set on the zone origin node.

    ``DELEGATION`` is set at NS delegation points (not at the origin, and not
    on nodes beneath a delegation).

    ``GLUE`` is set on nodes that are proper subdomains of a delegation point.
    é   é   é   N)Ú__name__Ú
__module__Ú__qualname__Ú__doc__ÚORIGINÚ
DELEGATIONÚGLUE© ó    úG/root/telegram-saas/.venv/lib/python3.12/site-packages/dns/btreezone.pyr   r      s   „ ñð €FØ€JØ�Dr   r   c                   óP   ‡ — e Zd ZdZddgZd
dedz  fˆ fd„Zd„ Zd„ Zd„ Z	d	„ Z
ˆ xZS )ÚNodea8  A BTree zone node, extending :py:class:`dns.node.Node` with ``flags`` and
    ``id`` fields.

    .. attribute:: flags

       The node's role flags.

       :type: :py:class:`dns.btreezone.NodeFlags`

    .. attribute:: id

       The version id of the last write that touched this node.

       :type: int
    ÚflagsÚidNc                 óX   •— t         ‰| �  «        |€t        d«      }|| _        d| _        y )Nr   )ÚsuperÚ__init__r   r   r   )Úselfr   Ú	__class__s     €r   r   zNode.__init__A   s,   ø€ Ü‰ÑÔØˆ=ô ˜a“LˆEØˆŒ
Øˆ�r   c                 óB   — | j                   t        j                  z  dk7  S )zVReturn ``True`` if this node is an NS delegation point.

        :rtype: bool
        r   )r   r   r   ©r   s    r   Úis_delegationzNode.is_delegationK   s   € ð
 —
‘
œY×1Ñ1Ñ1°aÑ7Ð7r   c                 óB   — | j                   t        j                  z  dk7  S )zZReturn ``True`` if this node is beneath a delegation point.

        :rtype: bool
        r   )r   r   r   r    s    r   Úis_gluezNode.is_glueR   s   € ð
 —
‘
œYŸ^™^Ñ+°Ñ1Ð1r   c                 óB   — | j                   t        j                  z  dk7  S )zOReturn ``True`` if this node is the zone origin.

        :rtype: bool
        r   )r   r   r   r    s    r   Ú	is_originzNode.is_originY   s   € ð
 —
‘
œY×-Ñ-Ñ-°!Ñ3Ð3r   c                 ód   — | j                   t        j                  t        j                  z  z  dk7  S )zeReturn ``True`` if this node is at the origin or beneath a delegation.

        :rtype: bool
        r   )r   r   r   r   r    s    r   Úis_origin_or_gluezNode.is_origin_or_glue`   s'   € ð
 —
‘
œi×.Ñ.´·±Ñ?Ñ@ÀQÑFÐFr   ©N)r   r   r   r   Ú	__slots__r   r   r!   r#   r%   r'   Ú__classcell__©r   s   @r   r   r   .   s9   ø„ ñð  ˜$�€Iñ˜i¨$Ñ.õ ò8ò2ò4öGr   r   c                   ó
  ‡ — e Zd ZdZdefˆ fd„Zej                  j                  dfdej                  j                  dej                  j                  dej                  j                  ded	ej                  j                  f
ˆ fd
„Zej                  j                  dfdej                  j                  dej                  j                  dej                  j                  ded	ej                  j                  dz  f
ˆ fd„Zej                  j                  fdej                  j                  dej                  j                  dej                  j                  d	dfd„Zdej                  j                  d	dfd„Zd	efd„Zˆ xZS )ÚImmutableNodezbAn immutable :py:class:`dns.btreezone.Node`.

    Mutation methods raise :py:exc:`TypeError`.
    Únodec                 óú   •— t         ‰| �  «        |j                  | _        t        |j                  D �cg c]!  }t
        j                  j                  |«      ‘Œ# c}«      | _        |j                  | _        y c c}w r(   )	r   r   r   ÚtupleÚ	rdatasetsÚdnsÚrdatasetÚImmutableRdatasetr   )r   r.   Úrdsr   s      €r   r   zImmutableNode.__init__o   sY   ø€ Ü‰ÑÔØ—'‘'ˆŒÜØ<@¿N¹NÖK°SŒS�\‰\×+Ñ+¨CÕ0ÒKó
ˆŒð —Z‘Zˆ�
ùò Ls   ´&A8FÚrdclassÚrdtypeÚcoversÚcreateÚreturnc                 óB   •— |rt        d«      ‚t        ‰| �	  |||d«      S ©NÚ	immutableF)Ú	TypeErrorr   Úfind_rdataset©r   r6   r7   r8   r9   r   s        €r   r?   zImmutableNode.find_rdatasetw   s)   ø€ ñ Ü˜KÓ(Ð(Ü‰wÑ$ W¨f°f¸eÓDÐDr   Nc                 óB   •— |rt        d«      ‚t        ‰| �	  |||d«      S r<   )r>   r   Úget_rdatasetr@   s        €r   rB   zImmutableNode.get_rdataset‚   s)   ø€ ñ Ü˜KÓ(Ð(Ü‰wÑ# G¨V°V¸UÓCÐCr   c                 ó   — t        d«      ‚©Nr=   ©r>   )r   r6   r7   r8   s       r   Údelete_rdatasetzImmutableNode.delete_rdataset�   s   € ô ˜Ó$Ð$r   Úreplacementc                 ó   — t        d«      ‚rD   rE   )r   rG   s     r   Úreplace_rdatasetzImmutableNode.replace_rdataset•   s   € Ü˜Ó$Ð$r   c                  ó   — y)NTr   r    s    r   Úis_immutablezImmutableNode.is_immutable˜   s   € Ør   )r   r   r   r   r   r   r2   Ú	rdatatypeÚNONEÚ
rdataclassÚ
RdataClassÚ	RdataTypeÚboolr3   ÚRdatasetr?   rB   rF   rI   rK   r*   r+   s   @r   r-   r-   h   s„  ø„ ñð
 ˜Tõ  ð +.¯-©-×*<Ñ*<Øñ	Eà—‘×*Ñ*ð	Eð —‘×'Ñ'ð	Eð —‘×'Ñ'ð		Eð
 ð	Eð 
�‰×	Ñ	õ	Eð +.¯-©-×*<Ñ*<Øñ	Dà—‘×*Ñ*ð	Dð —‘×'Ñ'ð	Dð —‘×'Ñ'ð		Dð
 ð	Dð 
�‰×	Ñ	 Ñ	%õ	Dð +.¯-©-×*<Ñ*<ñ	%à—‘×*Ñ*ð%ð —‘×'Ñ'ð%ð —‘×'Ñ'ð	%ð
 
ó%ð%¨C¯L©L×,AÑ,Að %Àdó %ð˜d÷ r   r-   c                   ó¸   — e Zd ZdZdej
                  j                  deej
                  j                  dz  ef   fd„Z	dej
                  j                  defd„Z
y)ÚDelegationszíA sorted set of delegation-point names.

    Used by :py:class:`dns.btreezone.WritableVersion` and
    :py:class:`dns.btreezone.ImmutableVersion` to efficiently determine
    whether a given name is at or beneath a delegation point.
    Únamer:   Nc                 ób  — | j                  «       }|j                  |d¬«       |j                  «       }|€y|j                  «       }|j	                  |«      \  }}}|t
        j                  j                  j                  k(  }|s'|t
        j                  j                  j                  k(  r||fS y)a®  Get the delegation applicable to *name*, if it exists.

        :returns: A tuple of the delegation point name and a boolean which is
            ``True`` if *name* is a proper subdomain of the delegation point,
            or ``False`` if it is equal to the delegation point.  If there is
            no applicable delegation, returns ``(None, False)``.
        :rtype: tuple[:py:class:`dns.name.Name` or ``None``, bool]
        F©Úbefore)NF)
ÚcursorÚseekÚprevÚkeyÚfullcomparer2   rU   ÚNameRelationÚ	SUBDOMAINÚEQUAL)r   rU   rY   r[   ÚcutÚrelnÚ_Úis_subdomains           r   Úget_delegationzDelegations.get_delegation¤   s•   € ð —‘“ˆØ�‰�D ˆÔ'Ø�{‰{‹}ˆØˆ<ØØ�h‰h‹jˆØ×%Ñ% cÓ*‰
ˆˆa�ØœsŸx™x×4Ñ4×>Ñ>Ñ>ˆÙ˜4¤3§8¡8×#8Ñ#8×#>Ñ#>Ò>Ø˜Ð$Ð$àr   c                 óz   — | j                  «       }|j                  |d¬«       | j                  |«      \  }}|€y|S )z0Is *name* glue, i.e. is it beneath a delegation?FrW   )rY   rZ   re   )r   rU   rY   ra   rd   s        r   r#   zDelegations.is_glueº   s@   € à—‘“ˆØ�‰�D ˆÔ'Ø ×/Ñ/°Ó5Ñˆˆ\Øˆ;ØØÐr   )r   r   r   r   r2   rU   ÚNamer0   rQ   re   r#   r   r   r   rT   rT   œ   sU   „ ñð 3§8¡8§=¡=ð °U¸3¿8¹8¿=¹=È4Ñ;OÐQUÐ;UÑ5Vó ð,˜CŸH™HŸM™Mð ¨dô r   rT   c                   óÈ  ‡ — e Zd ZdZddej
                  j                  defˆ fd„Zdej                  j                  defd„Zdej                  j                  deej                  j                  ej                  j                  f   fˆ fd„Zdej                  j                  d	edd
fd„Zdej                  j                  dedd
fd„Zdej                  j                  dd
fd„Zdej                  j                  dej&                  j(                  dd
fd„Zdej                  j                  dej,                  j.                  dej,                  j.                  dd
fd„Zˆ xZS )ÚWritableVersiona‡  A mutable version of a :py:class:`dns.btreezone.Zone`.

    Extends :py:class:`dns.zone.WritableVersion` with a
    :py:class:`dns.btreezone.Delegations` index and automatic management of
    ``NodeFlags.ORIGIN``, ``NodeFlags.DELEGATION``, and ``NodeFlags.GLUE``
    flags on every node.

    Instances are created internally by the zone; callers should not
    construct them directly.
    ÚzonerG   c                 óŠ  •— t         ‰| �  |d«       |s¡t        |t        j                  j
                  «      sJ ‚|j                  d   }t        j                  j                  t        j                  j                  t        f   |j                  ¬«      | _        t        |j                  ¬«      | _        y t        «       | _        y )NTéÿÿÿÿ)Úoriginal)r   r   Ú
isinstancer2   Ú	versionedÚZoneÚ	_versionsÚbtreeÚ	BTreeDictrU   rg   r   ÚnodesrT   Údelegations)r   rj   rG   Úversionr   s       €r   r   zWritableVersion.__init__Ð   s’   ø€ Ü‰Ñ˜˜tÔ$ÙÜ˜d¤C§M¡M×$6Ñ$6Ô7Ð7Ð7Ø—n‘n RÑ(ˆGÜCFÇ9Á9×CVÑCVÜ—‘—‘œtÐ#ñDð !Ÿ™ôDˆDŒJô
  +°G×4GÑ4GÔHˆDÕä*›}ˆDÕr   rU   r:   c                 ó†   — | j                   j                  r|t        j                  j                  k(  S || j
                  k(  S r(   )rj   Ú
relativizer2   rU   ÚemptyÚorigin)r   rU   s     r   Ú
_is_originzWritableVersion._is_originÞ   s3   € ð �9‰9×ÒØœ3Ÿ8™8Ÿ>™>Ñ)Ð)à˜4Ÿ;™;Ñ&Ð&r   c                 ó¦  •— t         ‰| �  |«      \  }}t        t        |«      }| j	                  |«      r'|xj
                  t        j                  z  c_        ||fS | j                  j                  |«      r'|xj
                  t        j                  z  c_        ||fS || j                  v r#|xj
                  t        j                  z  c_        ||fS r(   )r   Ú_maybe_cow_with_namer   r   r{   r   r   r   ru   r#   r   r   )r   rU   r.   r   s      €r   r}   z$WritableVersion._maybe_cow_with_nameæ   s²   ø€ ô ‘WÑ1°$Ó7‰
ˆˆdÜ”D˜$ÓˆØ�?‰?˜4Ô Ø�JŠJœ)×*Ñ*Ñ*�Jð
 �dˆ|Ðð	 ×Ñ×%Ñ% dÔ+Ø�JŠJœ)Ÿ.™.Ñ(�Jð �dˆ|Ðð �T×%Ñ%Ñ%Ø�JŠJœ)×.Ñ.Ñ.�JØ�dˆ|Ðr   r#   Nc                 ó  — | j                   j                  «       }|j                  |d«       g }|r|nd}	 |j                  «       }|€�n£|j	                  «       }|j                  |«      s�n€|j                  «       }| j                  j                  |«       |�|j                  |«      sd}|�t        j                  }	nw|j                  | j                  j                  t        j                  j                   «      �.t        j"                  }	|}| j                  j%                  |«       nt        d«      }	|j&                  |	k(  r�Œ|| j(                  vr{t+        t,        | j                  j/                  «       «      }
| j0                  |
_        |
j2                  j5                  |j2                  «       | j(                  j%                  |«       |
}|	|_        |j7                  ||f«       �Œ·|D ]  \  }}|| j                   |<   Œ y)aÎ  Update the delegation and glue flags on proper subdomains of *name*.

        An added delegation obscures any descendant delegations.  Removing
        one exposes the first NS rdataset on each branch of its subtree.

        :param name: The delegation-point name whose subtree should be updated.
        :type name: :py:class:`dns.name.Name`
        :param is_glue: ``True`` to obscure the subtree; ``False`` to expose it.
        :type is_glue: bool
        FNr   )rt   rY   rZ   Únextr\   rd   Úvalueru   Údiscardr   r   rB   rj   r6   r2   rL   ÚNSr   Úaddr   Úchangedr   r   Únode_factoryr   r1   ÚextendÚappend)r   rU   r#   rY   Úupdatesra   ÚeltÚenamer.   r   Únew_nodes              r   Úupdate_glue_flagz WritableVersion.update_glue_flagó   s­  € ð —‘×"Ñ"Ó$ˆØ�‰�D˜%Ô ØˆÙ‰d 4ˆØØ—+‘+“-ˆCØˆ{ÙØ—G‘G“IˆEØ×%Ñ% dÔ+ÙØ—9‘9“;ˆDØ×Ñ×$Ñ$ UÔ+Øˆ u×'9Ñ'9¸#Ô'>Ø�ØˆÜ!Ÿ™‘Ø×"Ñ" 4§9¡9×#4Ñ#4´c·m±m×6FÑ6FÓGÐSÜ!×,Ñ,�Ø�Ø× Ñ ×$Ñ$ UÕ+ä! !›�Ø�z‰z˜UÒ"ÙØ˜DŸL™LÑ(Ü¤ d§i¡i×&<Ñ&<Ó&>Ó?�Ø"Ÿg™g�”Ø×"Ñ"×)Ñ)¨$¯.©.Ô9Ø—‘× Ñ  Ô'Ø�ØˆDŒJð
 �N‰N˜E 4˜=Ô)ñA ðB #ò 	%‰KˆE�4Ø $ˆD�J‰J�uÒñ	%r   r.   c                 ó.  — |j                  «        xr@ |j                  | j                  j                  t        j
                  j                  «      d u}|r`|xj                  t        j                  z  c_        || j                  vr.| j                  j                  |«       | j                  |d«       y y || j                  v rR|xj                  t        j                   z  c_        | j                  j                  |«       | j                  |d«       y y )NTF)r'   rB   rj   r6   r2   rL   r‚   r   r   r   ru   rƒ   rŒ   r�   )r   rU   r.   r!   s       r   Ú_update_delegationz"WritableVersion._update_delegation&  så   € à×&Ñ&Ó(Ð(ò SØ×!Ñ! $§)¡)×"3Ñ"3´S·]±]×5EÑ5EÓFÈdÐRð 	ñ Ø�JŠJœ)×.Ñ.Ñ.�JØ˜4×+Ñ+Ñ+Ø× Ñ ×$Ñ$ TÔ*Ø×%Ñ% d¨DÕ1ð ,ð �T×%Ñ%Ñ%Ø�JŠJœ9×/Ñ/Ð/Ñ/�JØ×Ñ×$Ñ$ TÔ*Ø×!Ñ! $¨Õ.ð &r   c                 ó(  — | j                  |«      }| j                  j                  |«      }|�d|| j                  v r-| j                  j	                  |«       | j                  |d«       | j                  |= | j                  j                  |«       yy)aÄ  Delete the node at *name*, updating delegation tracking as needed.

        If *name* is a delegation point, it is removed from the delegations
        index and any exposed descendant NS nodes become delegation points.
        Nodes beneath those delegations remain glue.  If *name* does not
        exist in the zone, this method is a no-op.

        :param name: The name of the node to delete.
        :type name: :py:class:`dns.name.Name`
        NF)Ú_validate_namert   Úgetru   r�   rŒ   r„   rƒ   )r   rU   r.   s      r   Údelete_nodezWritableVersion.delete_node5  s�   € ð ×"Ñ" 4Ó(ˆØ�z‰z�~‰~˜dÓ#ˆØÐØ�t×'Ñ'Ñ'Ø× Ñ ×(Ñ(¨Ô.Ø×%Ñ% d¨EÔ2Ø—
‘
˜4Ð Ø�L‰L×Ñ˜TÕ"ð r   r3   c                 óŽ   — | j                  |«      \  }}|j                  |«       | j                  |t        t        |«      «       y)a‚  Store *rdataset* at *name*, updating delegation flags as needed.

        If *rdataset* is an NS rdataset and *name* is not the origin or beneath
        an existing delegation, the ``DELEGATION`` flag is set on the node and
        the ``GLUE`` flag is set on all nodes in *name*'s subtree, obscuring
        any descendant delegations.  Replacing an NS rdataset with a CNAME
        removes the delegation and exposes descendant delegations.

        :param name: The owner name.
        :type name: :py:class:`dns.name.Name`
        :param rdataset: The rdataset to store.
        :type rdataset: :py:class:`dns.rdataset.Rdataset`
        N)r}   rI   rŽ   r   r   )r   rU   r3   r.   s       r   Úput_rdatasetzWritableVersion.put_rdatasetI  s=   € ð  ×.Ñ.¨tÓ4‰
ˆˆdØ×Ñ˜hÔ'Ø×Ñ ¤d¬4°Ó&6Õ7r   r7   r8   c                 óò   — | j                  |«      \  }}|j                  | j                  j                  ||«       | j	                  |t        t        |«      «       t        |«      dk(  r| j                  |= yy)a‡  Delete the rdataset with *rdtype* and *covers* at *name*.

        If the deleted rdataset was the NS rdataset at a delegation point,
        the ``DELEGATION`` flag is cleared from that node and any exposed
        descendant NS nodes become delegation points.  Nodes beneath those
        delegations remain glue.

        :param name: The owner name.
        :type name: :py:class:`dns.name.Name`
        :param rdtype: The rdata type to remove.
        :type rdtype: :py:class:`dns.rdatatype.RdataType`
        :param covers: The covered type (usually ``dns.rdatatype.NONE``).
        :type covers: :py:class:`dns.rdatatype.RdataType`
        r   N)	r}   rF   rj   r6   rŽ   r   r   Úlenrt   )r   rU   r7   r8   r.   s        r   rF   zWritableVersion.delete_rdataset]  sg   € ð( ×.Ñ.¨tÓ4‰
ˆˆdØ×Ñ˜TŸY™Y×.Ñ.°¸Ô?Ø×Ñ ¤d¬4°Ó&6Ô7Üˆt‹9˜Š>Ø—
‘
˜4Ñ ð r   )F)r   r   r   r   r2   rj   rp   rQ   r   rU   rg   r{   r0   r.   r   r}   rŒ   rŽ   r’   r3   rR   r”   rL   rP   rF   r*   r+   s   @r   ri   ri   Ä   sK  ø„ ñ	ñ-˜SŸX™XŸ]™]ð -¸õ -ð'˜sŸx™xŸ}™}ð '°ó 'ðØ—H‘H—M‘Mðà	ˆs�x‰x�}‰}˜cŸh™hŸm™mÐ+Ñ	,õð1% S§X¡X§]¡]ð 1%¸Tð 1%Àdó 1%ðf/ s§x¡x§}¡}ð /¸Dð /ÀTó /ð# §¡§¡ð #°$ó #ð(8Ø—H‘H—M‘Mð8Ø-0¯\©\×-BÑ-Bð8à	ó8ð(!à�h‰h�m‰mð!ð —‘×'Ñ'ð!ð —‘×'Ñ'ð	!ð
 
÷!r   ri   T)Úfrozenc                   óú   — e Zd ZU dZej
                  j                  ed<   ej
                  j                  ed<   ej
                  j                  dz  ed<   ej
                  j                  ed<   eed<   eed<   d	„ Z	y)
ÚBoundsaa  The result of a :py:meth:`~dns.btreezone.ImmutableVersion.bounds` query.

    Useful for constructing authoritative responses and for on-the-fly DNSSEC
    signatures.

    .. attribute:: name

       The queried name.

       :type: :py:class:`dns.name.Name`

    .. attribute:: left

       The greatest name in the zone that is less than or equal to ``name``.

       :type: :py:class:`dns.name.Name`

    .. attribute:: right

       The least name in the zone that is greater than ``name``, or ``None``
       if ``name`` is greater than every name in the zone.

       :type: :py:class:`dns.name.Name` or ``None``

    .. attribute:: closest_encloser

       The name with the greatest number of labels that is a common ancestor
       of ``name`` and is present in the zone (explicitly or as an implied
       empty non-terminal).

       :type: :py:class:`dns.name.Name`

    .. attribute:: is_equal

       ``True`` if ``name`` is present in the zone (i.e. ``name == left``).

       :type: bool

    .. attribute:: is_delegation

       ``True`` if the left bound is a delegation point.

       :type: bool
    rU   ÚleftNÚrightÚclosest_encloserÚis_equalr!   c           
      óº   — | j                   rd}nd}| j                  rd}nd}| j                  › d|› d| j                  › d| j                  › |› d| j
                  › �
S )Nú=ú<z zonecutÚ ú z < z; )r�   r!   rš   rU   r›   rœ   )r   ÚopÚzonecuts      r   Ú__str__zBounds.__str__®  se   € Ø�=Š=Ø‰BàˆBØ×ÒØ ‰GàˆGà�y‰yˆk˜˜2˜$˜a §	¡	˜{¨#¨d¯j©j¨\¸'¸À"Ø×$Ñ$Ð%ð'ð	
r   )
r   r   r   r   r2   rU   rg   Ú__annotations__rQ   r¥   r   r   r   r™   r™   x  sW   … ñ+ðZ �(‰(�-‰-ÓØ
�(‰(�-‰-ÓØ�8‰8�=‰=˜4ÑÓØ—h‘h—m‘mÓ#ØƒNØÓó
r   r™   c                   óŽ   ‡ — e Zd ZdZdej
                  j                  fˆ fd„Zdej                  j                  e
z  defd„Zˆ xZS )ÚImmutableVersionap  An immutable, committed version of a :py:class:`dns.btreezone.Zone`.

    In addition to the standard read-only zone API, provides the
    :py:meth:`bounds` method for DNSSEC and authoritative-response support.

    Instances are created internally when a
    :py:class:`dns.btreezone.WritableVersion` is committed; callers should
    not construct them directly.
    rv   c                 ót  •— t        |t        «      st        d«      ‚t        ‰| �  |j
                  d«       |j                  | _        |j                  | _        |j                  D ]8  }|j                  j                  |«      }|sŒ!t        |«      |j                  |<   Œ: t        t        t        j                  j                   t        j"                  j$                  f   |j                  «      | _	        | j                  j'                  «        |j(                  | _        | j(                  j'                  «        y )NzIa dns.btreezone.ImmutableVersion requires a dns.btreezone.WritableVersionT)rn   ri   Ú
ValueErrorr   r   rj   r   rz   r„   rt   r‘   r-   r   r   r2   rU   rg   r.   r   Úmake_immutableru   )r   rv   rU   r.   r   s       €r   r   zImmutableVersion.__init__É  så   ø€ Ü˜'¤?Ô3Üð0óð ô 	‰Ñ˜Ÿ™ tÔ,Ø—*‘*ˆŒØ—n‘nˆŒØ—O‘Oò 	:ˆDØ—=‘=×$Ñ$ TÓ*ˆDÚÜ&3°DÓ&9�—‘˜dÒ#ð	:ô œ.¬¯©¯©¼¿¹¿¹Ð)EÑFÈÏÉÓVˆŒ
Ø�
‰
×!Ñ!Ô#Ø"×.Ñ.ˆÔØ×Ñ×'Ñ'Õ)r   rU   r:   c                 ó  — | j                   €J ‚| j                  j                  | j                   «      }| j                  j                  |«      }| j                  j	                  |«      \  }}|�|}d}n|}d}t        t        j                  j                  | j                  «      j                  «       }|j                  |d«       |j                  «       }|€J ‚|j                  «        	 |j                  «       }	|	�|	j                  «       j                  «       snŒ2|j!                  «       j#                  |«      }
|	�"|	j!                  «       }|j#                  |«      }n(t        j$                  j&                  dt)        |«      f}d}t        j$                  j+                  |t-        |
d   |d   «       d «      }t/        ||j!                  «       |||
d   t        j$                  j0                  j2                  k(  |«      S )a  Return the bounds of *name* in its zone.

        The bounds information is useful when making an authoritative response, as
        it can be used to determine whether the query name is at or beneath a delegation
        point.  The other data in the :py:class:`dns.btreezone.Bounds` object is useful
        for making on-the-fly DNSSEC signatures.

        The left bound of *name* is *name* itself if it is in the zone, or the greatest
        predecessor which is in the zone.

        The right bound of *name* is the least successor of *name*, or ``None`` if
        no name in the zone is greater than *name*.

        The closest encloser of *name* is *name* itself, if *name* is in the zone;
        otherwise it is the name with the largest number of labels in common with
        *name* that is in the zone, either explicitly or by the implied existence
        of empty non-terminals.

        The *is_equal* field of the result is ``True`` if and only if *name* is equal
        to its left bound.

        The *is_delegation* field of the result is ``True`` if and only if the left
        bound is a delegation point.

        :param name: The name to look up.
        :type name: :py:class:`dns.name.Name` or str
        :rtype: :py:class:`dns.btreezone.Bounds`
        NTFrl   r
   r   )rz   rj   r�   ru   re   r   r2   rr   rs   rt   rY   rZ   r[   r   r€   r#   r\   r]   rU   ÚNAMERELN_COMMONANCESTORr–   rg   Úmaxr™   r^   r`   )r   rU   rz   ra   rc   Útargetr!   Úcrš   r›   Úleft_comparisonÚ	right_keyÚright_comparisonrœ   s                 r   ÚboundszImmutableVersion.boundsÛ  sÆ  € ð: �{‰{Ð&Ð&Ð&à—‘×)Ñ)¨$¯+©+Ó6ˆØ�y‰y×'Ñ'¨Ó-ˆØ×!Ñ!×0Ñ0°Ó6‰ˆˆQØˆ?ØˆFØ ‰MàˆFØ!ˆMÜ”—‘×$Ñ$ d§j¡jÓ1×8Ñ8Ó:ˆØ	�‰ˆv�uÔØ�v‰v‹xˆØÐÐÐØ	�‰ŒØØ—F‘F“HˆEØˆ} E§K¡K£M×$9Ñ$9Ô$;Øð ð Ÿ(™(›*×0Ñ0°Ó6ˆØÐØŸ	™	›ˆIØ(×4Ñ4°TÓ:Ñô —‘×0Ñ0ØÜ�F“ð Ðð
 ˆIÜŸ8™8Ÿ=™=Ø”#�o aÑ(Ð*:¸1Ñ*=Ó>Ð>Ð@ÐAó
Ðô ØØ�H‰H‹JØØØ˜AÑ¤#§(¡(×"7Ñ"7×"=Ñ"=Ñ=Øó
ð 	
r   )r   r   r   r   r2   rj   ÚVersionr   rU   rg   Ústrr™   r´   r*   r+   s   @r   r¨   r¨   ½  sA   ø„ ñð* §¡× 0Ñ 0õ *ð$F
˜3Ÿ8™8Ÿ=™=¨3Ñ.ð F
°6÷ F
r   r¨   c                   ór  — e Zd ZU dZeZeg ej                  j                  f   e	d<    e
eg eej                  j                  ej                  j                  f   f   ej                  j                  ej                  j                  ef   «      Zeg eej                  j                  ej                  j                  f   f   e	d<   eZeej&                  j(                  egej&                  j,                  f   dz  e	d<   eZeej&                  j,                  gej&                  j,                  f   dz  e	d<   y)rp   aó  A versioned DNS zone backed by a BTree.

    Extends :py:class:`dns.versioned.Zone` with:

    - **Sorted iteration order**: names are always visited in DNS canonical order.
    - **Automatic flag tracking**: every node is tagged with
      :py:class:`dns.btreezone.NodeFlags` (``ORIGIN``, ``DELEGATION``,
      ``GLUE``) as rdatasets are added and removed.
    - **Efficient copy-on-write versioning**: the underlying
      :py:class:`dns.btree.BTreeDict` shares structure between versions so
      that creating a new version is cheap.
    - **DNSSEC / authoritative-response support**: committed versions expose
      :py:meth:`~dns.btreezone.ImmutableVersion.bounds`, which returns the
      nearest names and closest encloser for any query name.
    r…   Úmap_factoryNÚwritable_version_factoryÚimmutable_version_factory)r   r   r   r   r   r…   r   r2   r.   r¦   r   r   rU   rg   rr   rs   r¸   ri   r¹   rj   rp   rQ   rµ   r¨   rº   r   r   r   rp   rp   $  s  … ñð  15€L�(˜2˜sŸx™xŸ}™}Ð,Ñ-Ó4ÙNRØ��^ C§H¡H§M¡M°3·8±8·=±=Ð$@ÑAÐAÑBØ�	‰	×Ñ˜CŸH™HŸM™M¨4Ð/Ñ0óO€K�˜"˜n¨S¯X©X¯]©]¸C¿H¹H¿M¹MÐ-IÑJÐJÑKó ð 	ð Ø�#—(‘(—-‘- Ð&¨¯©×(8Ñ(8Ð8Ñ9¸DÑ@óð 	ð ˜x¨¯©×)9Ñ)9Ð(:¸C¿H¹H×<LÑ<LÐ(LÑMÐPTÑTô r   rp   )$ÚenumÚcollections.abcr   r   Údataclassesr   Útypingr   Ú	dns.btreer2   Údns.immutableÚdns.nameÚdns.nodeÚdns.rdataclassÚdns.rdatasetÚdns.rdatatypeÚdns.versionedÚdns.zoneÚIntFlagr   r.   r   r=   r-   rr   ÚBTreeSetrU   rg   rT   rj   ri   r™   rµ   r¨   ro   rp   r   r   r   ú<module>rÊ      s#  ðó ß 4Ý !Ý ã Û Û Û Û Û Û Û Û ô�—‘ô ô 7Gˆ3�8‰8�=‰=ô 7Gðt ‡�×Ñô0�Dó 0ó ð0ôf%�#—)‘)×$Ñ$ S§X¡X§]¡]Ñ3ô %ôPq!�c—h‘h×.Ñ.ô q!ñh �$Ô÷A
ð A
ó ðA
ðH ‡�×Ñôc
�s—x‘x×'Ñ'ó c
ó ðc
ôLˆ3�=‰=×Ñõ r   