Ë
    Q5ýj�‘  ã                   ó¶  — U d 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	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ddlZdZdZ G d„ dej4                  j6                  «      Z ej:                  d¬	«       G d
„ dej<                  j>                  «      «       Z edfde!de"de!e#z  de#fd„Z$edfde!e#z  fd„Z%d;de de&fd„Z'edfde!e#z  fd„Z(d;de de&fd„Z)dZ*dZ+d„ Z,d„ Z-d„ Z.ej^                  j`                  Z1ej^                  j^                   G d„ d «      «       Z2ej^                  j^                   G d!„ d"e2«      «       Z3i Z4e5e6ejn                  jp                  ejr                  jt                  f   ef   e;d#<   d$Z<da=d<d%„Z>d<d&„Z?	 	 	 	 d=d'ejn                  jp                  e#z  d(ejr                  jt                  e#z  d)ej€                  j‚                  e#z  d*ej<                  j„                  dz  d+e&d,ej<                  j„                  dz  d-ej<                  j†                  dz  de2fd.„ZD	 d>d'ejn                  jp                  e#z  d(ejr                  jt                  e#z  d/ejŠ                  jŒ                  d*ej<                  j„                  dz  de2f
d0„ZG	 d>d'ejn                  jp                  e#z  d(ejr                  jt                  e#z  d1e!d2e"d3e"d*ej<                  j„                  dz  de2fd4„ZH G d5„ d6ej4                  j6                  «      ZIdejn                  j”                  fd7ed(e"d8e#d9e&d'ejn                  jp                  ddfd:„ZKy)?z
DNS rdata.é    N)Úimport_module)ÚAnyé    Tc                   ó   — e Zd ZdZy)ÚNoRelativeRdataOrderingz°An attempt was made to do an ordered comparison of one or more
    rdata with relative names.  The only reliable way of sorting rdata
    is to use non-relativized rdata.

    N)Ú__name__Ú
__module__Ú__qualname__Ú__doc__© ó    úC/root/telegram-saas/.venv/lib/python3.12/site-packages/dns/rdata.pyr   r   5   s   „ òr   r   )Úfrozenc                   óf   — e Zd ZU dZdZeed<   dZeed<   dZ	e
ed<   dZeed	<   dZe
ed
<   dZeed<   y)Ú
RdataStyleaY  Rdata text styles

    An ``RdataStyle`` is also a :py:class:`dns.name.NameStyle`; see that class
    for a description of its options.

    .. attribute:: txt_is_utf8

        A ``bool``. If ``True``, TXT-like records will be treated as UTF-8 if
        they decode successfully, and the output string may contain any Unicode
        codepoint. If ``False`` (the default), TXT-like records are treated
        according to RFC 1035 rules.

    .. attribute:: base64_chunk_size

        An ``int`` (default 32). The chunk size for text representations that
        break base64 strings into chunks.

    .. attribute:: base64_chunk_separator

        A ``str`` (default ``" "``). The separator for text representations
        that break base64 strings into chunks.

    .. attribute:: hex_chunk_size

        An ``int`` (default 128). The chunk size for text representations that
        break hex strings into chunks.

    .. attribute:: hex_chunk_separator

        A ``str`` (default ``" "``). The separator for text representations
        that break hex strings into chunks.

    .. attribute:: truncate_crypto

        A ``bool`` (default ``False``). If ``True``, output of crypto types
        (e.g. DNSKEY) is altered to be human-readable in a debugging context,
        but the crypto content is removed. Use of this option will lose
        information.
    FÚtxt_is_utf8r   Úbase64_chunk_sizeú Úbase64_chunk_separatoré€   Úhex_chunk_sizeÚhex_chunk_separatorÚtruncate_cryptoN)r   r	   r
   r   r   ÚboolÚ__annotations__r   Úintr   Ústrr   r   r   r   r   r   r   r   =   sI   … ñ&ðP €K�ÓØÐ�sÓØ"%Ð˜CÓ%Ø€N�CÓØ"Ð˜Ó"Ø!€O�TÔ!r   r   ó    ÚdataÚ	chunksizeÚ	separatorÚreturnc           	      óþ   — t        |t        «      r|j                  «       }|s| j                  «       S |j	                  t        dt        | «      |«      D �cg c]
  }| |||z    ‘Œ c}«      j                  «       S c c}w )zXBreak a binary string into chunks of chunksize characters separated by
    a space.
    r   )Ú
isinstancer   ÚencodeÚdecodeÚjoinÚrangeÚlen)r   r    r!   Úis       r   Ú
_wordbreakr+   o   sl   € ô �)œSÔ!Ø×$Ñ$Ó&ˆ	ÙØ�{‰{‹}ÐØ�>‰>Ü*/°´3°t³9¸iÓ*HÖI Qˆˆa�!�i‘-Ò	 ÒIóç�fƒhðùÚIs   ÁA:r   c                 óp   — t        |t        «      r|j                  «       }t        | t	        ||¬«      «      S )zConvert a binary string into its hex encoding, broken up into chunks
    of chunksize characters separated by a separator.
    )r   r   )r$   Úbytesr&   Ú_styled_hexifyr   ©r   r    r!   Úkws       r   Ú_hexifyr1   ‚   s5   € ô �)œUÔ#Ø×$Ñ$Ó&ˆ	ÜØŒj¨YÀyÔQóð r   FÚstyleÚ	is_cryptoc                 óˆ   — |j                   r|ryt        t        j                  | «      |j                  |j
                  «      S )zuConvert a binary string into its hex encoding, broken up into chunks
    of characters separated by a separator.
    ú	[omitted])r   r+   ÚbinasciiÚhexlifyr   r   ©r   r2   r3   s      r   r.   r.   �   s?   € ð
 ×Ò¡ØÜÜ×Ñ˜ÓØ×ÑØ×!Ñ!óð r   c                 óp   — t        |t        «      r|j                  «       }t        | t	        ||¬«      «      S )z‚Convert a binary string into its base64 encoding, broken up into chunks
    of chunksize characters separated by a separator.
    )r   r   )r$   r-   r&   Ú_styled_base64ifyr   r/   s       r   Ú
_base64ifyr;   ›   s5   € ô �)œUÔ#Ø×$Ñ$Ó&ˆ	ÜØŒj°	ÈYÔWóð r   c                 óˆ   — |j                   r|ryt        t        j                  | «      |j                  |j
                  «      S )zxConvert a binary string into its base64 encoding, broken up into chunks
    of characters separated by a separator.
    r5   )r   r+   Úbase64Ú	b64encoder   r   r8   s      r   r:   r:   ¦   s?   € ð
 ×Ò¡ØÜÜ×Ñ˜ÓØ×ÑØ×$Ñ$óð r   s   "\z"\c                 ó  — t        | t        «      r| j                  «       } t        | t        «      st        | «      } d}| D ]>  }|t        v r|dt        |«      z   z  }Œ|dk\  r|dk  r|t        |«      z  }Œ6|d|d›�z  }Œ@ |S )z7Escape the characters in a quoted string which need it.Ú ú\r   é   Ú03d)r$   r   r%   Ú	bytearrayÚ_escapedÚchr)ÚqstringÚtextÚcs      r   Ú	_escapifyrJ   º   sŽ   € ô �'œ3ÔØ—.‘.Ó"ˆÜ�gœyÔ)Ü˜GÓ$ˆà€DØò !ˆØ”‰=Ø�Dœ3˜q›6‘MÑ!‰DØ�$ŠY˜1˜tš8Ø”C˜“F‰N‰Dà�b˜˜3˜�LÑ ‰Dð!ð €Kr   c                 óÌ   — d}| D ]\  }|t         v r	|d|z   z  }Œt        |«      dk  sdt        |«      cxk  rdk  r"n n|j                  «       D ]  }|d|d›�z  }Œ ŒX||z  }Œ^ |S )z?Escape the characters in a Unicode quoted string which need it.r@   rA   r   rB   éŸ   rC   )Ú_unicode_escapedÚordr%   )rG   rH   rI   Úbs       r   Ú_escapify_unicoderP   Í   s…   € ð €DØò 	ˆØÔ Ñ Ø�D˜1‘HÑ‰DÜ�‹V�dŠ]˜d¤c¨!£fÔ4°Õ4ð —X‘X“Zò %�Ø˜"˜Q˜s˜G˜Ñ$‘ñ%ð �A‰I‰Dð	ð €Kr   c                 ól   — t        t        | «      dz
  dd«      D ]  }| |   dk7  sŒ| d|dz    c S  | dd S )z‹Determine the index of greatest byte that isn't all zeros, and
    return the bitmap that contains all the bytes less than that index.
    é   éÿÿÿÿr   )r(   r)   )Úwhatr*   s     r   Ú_truncate_bitmaprU   Þ   sM   € ô
 ”3�t“9˜q‘= " bÓ)ò #ˆØ�‰7�a‹<Ø˜˜A ™E�?Ò"ð#ð ��!ˆ9Ðr   c                   ó  — e Zd ZU dZg d¢ZdZedz  ed<   dej                  j                  dej                  j                  ddfd„Zd	„ Zd
„ Zd„ Zdej                  j                  fd„Zdefd„Z	 	 	 d@dej&                  j(                  dz  dededz  dedef
d„Zdedefd„Z	 	 	 dAdedej&                  j6                  dz  dej&                  j(                  dz  deddf
d„Z	 	 	 	 dBdedz  dej&                  j6                  dz  dej&                  j(                  dz  dededz  f
d„ZdCdej&                  j(                  dz  ddfd„ZdCdej&                  j(                  dz  defd„Z d„ Z!d„ Z"d„ Z#d„ Z$d „ Z%d!„ Z&d"„ Z'd#„ Z(d$„ Z)d%„ Z*e+	 	 	 d@dej                  j                  dej                  j                  d&ejX                  jZ                  dej&                  j(                  dz  ded'ej&                  j(                  dz  dd fd(„«       Z.e+	 dCdej                  j                  dej                  j                  d)ej^                  j`                  dej&                  j(                  dz  dd f
d*„«       Z1d+edd fd,„Z2e+d-„ «       Z3e+d.„ «       Z4e+	 	 	 dDd/ed0ed1edz  d2edef
d3„«       Z5e+d4„ «       Z6e+d5„ «       Z7e+d6„ «       Z8e+d7„ «       Z9e+d8„ «       Z:e+dEd9„«       Z;e+d:„ «       Z<e+d;„ «       Z=e+d<„ «       Z>e+d=„ «       Z?e+d>„ «       Z@e+d?„ «       ZAy)FÚRdataz#Base class for all DNS rdata types.)ÚrdclassÚrdtypeÚ	rdcommentNÚ_crypto_keep_first_nrX   rY   r"   c                 ój   — | j                  |«      | _        | j                  |«      | _        d| _        y)zåInitialize an rdata.

        :param rdclass: The rdata class.
        :type rdclass: :py:class:`dns.rdataclass.RdataClass`
        :param rdtype: The rdata type.
        :type rdtype: :py:class:`dns.rdatatype.RdataType`
        N)Ú_as_rdataclassrX   Ú_as_rdatatyperY   rZ   )ÚselfrX   rY   s      r   Ú__init__zRdata.__init__õ   s/   € ð ×*Ñ*¨7Ó3ˆŒØ×(Ñ(¨Ó0ˆŒØˆ�r   c                 óv   — t         j                  j                  d„ | j                  j                  D «       «      S )Nc              3   ó6   K  — | ]  }t        |d g «      –— Œ y­w)Ú	__slots__N)Úgetattr)Ú.0Úclss     r   ú	<genexpr>z'Rdata._get_all_slots.<locals>.<genexpr>  s   è ø€ ò -
Ø.1ŒG�C˜ b×)ñ-
ùs   ‚)Ú	itertoolsÚchainÚfrom_iterableÚ	__class__Ú__mro__©r_   s    r   Ú_get_all_slotszRdata._get_all_slots  s0   € Ü�‰×,Ñ,ñ -
Ø59·^±^×5KÑ5Kô-
ó 
ð 	
r   c                 óR   — i }| j                  «       D ]  }t        | |«      ||<   Œ |S ©N)rn   rd   )r_   ÚstateÚslots      r   Ú__getstate__zRdata.__getstate__  s6   € ð ˆØ×'Ñ'Ó)ò 	.ˆDÜ! $¨Ó-ˆE�$ŠKð	.àˆr   c                 óª   — |j                  «       D ]  \  }}t        j                  | ||«       Œ t        | d«      st        j                  | dd «       y y )NrZ   )ÚitemsÚobjectÚ__setattr__Úhasattr)r_   rq   rr   Úvals       r   Ú__setstate__zRdata.__setstate__  sP   € ØŸ™›ò 	0‰IˆD�#Ü×Ñ˜t T¨3Õ/ð	0ä�t˜[Ô)ô ×Ñ˜t [°$Õ7ð *r   c                 ó6   — t         j                  j                  S )a©  Return the type a Rdata covers.

        DNS SIG/RRSIG rdatas apply to a specific type; this type is
        returned by the covers() function.  If the rdata type is not
        SIG or RRSIG, dns.rdatatype.NONE is returned.  This is useful when
        creating rdatasets, allowing the rdataset to contain only RRSIGs
        of a particular type, e.g. RRSIG(NS).

        :rtype: :py:class:`dns.rdatatype.RdataType`
        )ÚdnsÚ	rdatatypeÚNONErm   s    r   ÚcoverszRdata.covers!  s   € ô �}‰}×!Ñ!Ð!r   c                 óB   — | j                  «       dz  | j                  z  S )zÊReturn a 32-bit type value, the least significant 16 bits of
        which are the ordinary DNS type, and the upper 16 bits of which are
        the "covered" type, if any.

        :rtype: int
        é   )r   rY   rm   s    r   Úextended_rdatatypezRdata.extended_rdatatype/  s   € ð �{‰{‹} Ñ" T§[¡[Ñ0Ð0r   ÚoriginÚ
relativizer2   r0   c                 ó†   — |€/|j                  «       }||d<   ||d<   t        j                  |«      }| j                  |«      S )zÉConvert an rdata to text format.

        :param style: If specified, overrides *origin* and *relativize*.
        :type style: :py:class:`dns.rdata.RdataStyle` or ``None``
        :rtype: str
        rƒ   r„   )Úcopyr   Úfrom_keywordsÚto_styled_text)r_   rƒ   r„   r2   r0   s        r   Úto_textzRdata.to_text9  sH   € ð ˆ=Ø—‘“ˆBØ!ˆBˆx‰LØ)ˆBˆ|ÑÜ×,Ñ,¨RÓ0ˆEØ×"Ñ" 5Ó)Ð)r   c                 ó   — t         ‚)z¼Convert an rdata to styled text format.

        See the documentation for :py:class:`dns.rdata.RdataStyle` for a description
        of the style parameters.

        :rtype: str
        ©ÚNotImplementedError©r_   r2   s     r   rˆ   zRdata.to_styled_textM  s
   € ô "Ð!r   ÚfileÚcompressÚcanonicalizec                 ó   — t         ‚rp   r‹   ©r_   rŽ   r�   rƒ   r�   s        r   Ú_to_wirezRdata._to_wireX  s
   € ô "Ð!r   c                 ó    — |r| j                  ||||«       yt        j                  «       }| j                  ||||«       |j                  «       S )zÁConvert an rdata to wire format.

        :returns: Wire-format bytes if no output file was specified, or ``None``
            if a file was provided.
        :rtype: bytes or ``None``
        N)r“   ÚioÚBytesIOÚgetvalue)r_   rŽ   r�   rƒ   r�   Úfs         r   Úto_wirezRdata.to_wirea  sG   € ñ ð
 �M‰M˜$ ¨&°,Ô?Øä—
‘
“ˆAØ�M‰M˜!˜X v¨|Ô<Ø—:‘:“<Ðr   ÚGenericRdatac                 óp   — | j                  |¬«      }|€J ‚t        | j                  | j                  |«      S )z‚Create a :py:class:`dns.rdata.GenericRdata` equivalent of this rdata.

        :rtype: :py:class:`dns.rdata.GenericRdata`
        )rƒ   )r™   rš   rX   rY   ©r_   rƒ   Úwires      r   Ú
to_genericzRdata.to_generic{  s7   € ð
 �|‰| 6ˆ|Ó*ˆØÐÐÐÜ˜DŸL™L¨$¯+©+°tÓ<Ð<r   c                 ó4   — | j                  |d¬«      }|€J ‚|S )zŒConvert rdata to a format suitable for digesting in hashes.  This
        is also the DNSSEC canonical form.

        :rtype: bytes
        T)rƒ   r�   )r™   rœ   s      r   Úto_digestablezRdata.to_digestable„  s'   € ð �|‰| 6¸ˆ|Ó=ˆØÐÐÐØˆr   c                 óˆ  — | j                  «       }|t        j                  j                  k(  rd}n%dt        j                  j	                  |«      z   dz   }dt        j
                  j	                  | j                  «      z   dz   t        j                  j	                  | j                  «      z   |z   dz   t        | «      z   dz   S )Nr@   ú(ú)z<DNS r   z rdata: ú>)	r   r|   r}   r~   r‰   Ú
rdataclassrX   rY   r   )r_   r   Úctexts      r   Ú__repr__zRdata.__repr__Ž  s¶   € Ø—‘“ˆØ”S—]‘]×'Ñ'Ò'Ø‰Eàœ#Ÿ-™-×/Ñ/°Ó7Ñ7¸#Ñ=ˆEàÜ�n‰n×$Ñ$ T§\¡\Ó2ñ3àñô �m‰m×#Ñ# D§K¡KÓ0ñ1ð ñ	ð
 ñô �$‹iñð ñð		
r   c                 ó"   — | j                  «       S rp   )r‰   rm   s    r   Ú__str__zRdata.__str__Ÿ  s   € Ø�|‰|‹~Ðr   c                 óò  — d}d}	 | j                  «       }d}	 |j                  «       }d}t        r	||k7  r|ryy|s|rt        ‚||k(  ry||kD  ryy# t        j                  j                  $ r4 t        r)| j                  t        j                  j
                  «      }d}Y Œ‰w xY w# t        j                  j                  $ r4 t        r)|j                  t        j                  j
                  «      }d}Y ŒÊw xY w)a  Compare an rdata with another rdata of the same rdtype and
        rdclass.

        For rdata with only absolute names:
            Return < 0 if self < other in the DNSSEC ordering, 0 if self
            == other, and > 0 if self > other.
        For rdata with at least one relative names:
            The rdata sorts before any rdata with only absolute names.
            When compared with another relative rdata, all names are
            made absolute as if they were relative to the root, as the
            proper origin is not available.  While this creates a stable
            ordering, it is NOT guaranteed to be the DNSSEC ordering.
            In the future, all ordering comparisons for rdata with
            relative names will be disallowed.
        r   FTrS   rR   r   )r    r|   ÚnameÚNeedAbsoluteNameOrOriginÚ_allow_relative_comparisonsÚrootr   )r_   ÚotherÚourÚtheirÚour_relativeÚtheir_relatives         r   Ú_cmpz
Rdata._cmp¢  sí   € ð" ˆØˆð	 Ø×$Ñ$Ó&ˆCØ ˆLð
	"Ø×'Ñ'Ó)ˆEØ"ˆNõ
 'Ø˜~Ò-ñ  ØàÙ™^Ü)Ð)Ø�%Š<ØØ�5Š[Øàøô5 �x‰x×0Ñ0ò 	 Ý*Ø×(Ñ(¬¯©¯©Ó7�ØŠLð	 ûô �x‰x×0Ñ0ò 	"Ý*Ø×+Ñ+¬C¯H©H¯M©MÓ:�Ø!ŠNð	"ús$   †A ™B% ÁAB"Â!B"Â%AC6Ã5C6c                 ó$  — t        |t        «      sy| j                  |j                  k7  s| j                  |j                  k7  ryd}d}	 | j	                  «       }	 |j	                  «       }||k7  ry||k(  S # t
        j                  j                  $ r. | j	                  t
        j                  j                  «      }d}Y Œfw xY w# t
        j                  j                  $ r. |j	                  t
        j                  j                  «      }d}Y Œ£w xY w)NFT)	r$   rW   rX   rY   r    r|   r«   r¬   r®   )r_   r¯   r²   r³   r°   r±   s         r   Ú__eq__zRdata.__eq__Ô  sç   € Ü˜%¤Ô'ØØ�<‰<˜5Ÿ=™=Ò(¨D¯K©K¸5¿<¹<Ò,GØØˆØˆð	 Ø×$Ñ$Ó&ˆCð	"Ø×'Ñ'Ó)ˆEð ˜>Ò)ØØ�e‰|Ðøô �x‰x×0Ñ0ò 	 Ø×$Ñ$¤S§X¡X§]¡]Ó3ˆCØŠLð	 ûô
 �x‰x×0Ñ0ò 	"Ø×'Ñ'¬¯©¯©Ó6ˆEØ!ŠNð	"ús&   Á
A6 ÁC Á6ACÃ CÃADÄDc                 ó®   — t        |t        «      sy| j                  |j                  k7  s| j                  |j                  k7  ry| j	                  |«       S )NT)r$   rW   rX   rY   r¶   ©r_   r¯   s     r   Ú__ne__zRdata.__ne__é  sC   € Ü˜%¤Ô'ØØ�<‰<˜5Ÿ=™=Ò(¨D¯K©K¸5¿<¹<Ò,GØØ—;‘;˜uÓ%Ð%Ð%r   c                 óº   — t        |t        «      r2| j                  |j                  k7  s| j                  |j                  k7  rt        S | j                  |«      dk  S ©Nr   ©r$   rW   rX   rY   ÚNotImplementedr´   r¸   s     r   Ú__lt__zRdata.__lt__ð  óF   € ä˜5¤%Ô(Ø�|‰|˜uŸ}™}Ò,Ø�{‰{˜eŸl™lÒ*ä!Ð!Ø�y‰y˜Ó !Ñ#Ð#r   c                 óº   — t        |t        «      r2| j                  |j                  k7  s| j                  |j                  k7  rt        S | j                  |«      dk  S r»   r¼   r¸   s     r   Ú__le__zRdata.__le__ù  óF   € ä˜5¤%Ô(Ø�|‰|˜uŸ}™}Ò,Ø�{‰{˜eŸl™lÒ*ä!Ð!Ø�y‰y˜Ó 1Ñ$Ð$r   c                 óº   — t        |t        «      r2| j                  |j                  k7  s| j                  |j                  k7  rt        S | j                  |«      dk\  S r»   r¼   r¸   s     r   Ú__ge__zRdata.__ge__  rÂ   r   c                 óº   — t        |t        «      r2| j                  |j                  k7  s| j                  |j                  k7  rt        S | j                  |«      dkD  S r»   r¼   r¸   s     r   Ú__gt__zRdata.__gt__  r¿   r   c                 óf   — t        | j                  t        j                  j                  «      «      S rp   )Úhashr    r|   r«   r®   rm   s    r   Ú__hash__zRdata.__hash__  s    € Ü�D×&Ñ&¤s§x¡x§}¡}Ó5Ó6Ð6r   ÚtokÚrelativize_toc                 ó   — t         ‚rp   r‹   )rf   rX   rY   rÊ   rƒ   r„   rË   s          r   Ú	from_textzRdata.from_text  s
   € ô "Ð!r   Úparserc                 ó   — t         ‚rp   r‹   ©rf   rX   rY   rÎ   rƒ   s        r   Úfrom_wire_parserzRdata.from_wire_parser#  s
   € ô "Ð!r   Úkwargsc                 ó¾  ‡ ‡— t        j                  ‰ j                  «      j                  }‰D ]\  }|dk(  rŒ	||vr&t	        d‰ j
                  j                  › d|› d�«      ‚|dv sŒ8t	        d‰ j
                  j                  › d|› d�«      ‚ ˆˆ fd„|D «       } ‰ j
                  |Ž }‰j                  d‰ j                  «      }|�t        j                  |d|«       |S )aµ  Create a new Rdata instance based on the instance replace was
        invoked on. It is possible to pass different parameters to
        override the corresponding properties of the base Rdata.

        Any field specific to the Rdata type can be replaced, but the
        *rdtype* and *rdclass* fields cannot.

        :returns: A new instance of the same :py:class:`Rdata` subclass as *self*.
        :rtype: :py:class:`Rdata`
        rZ   ú'z' object has no attribute '©rX   rY   zCannot overwrite 'z' attribute 'c              3   óV   •K  — | ]   }‰j                  |t        ‰|«      «      –— Œ" y ­wrp   )Úgetrd   )re   ÚkeyrÒ   r_   s     €€r   rg   z Rdata.replace.<locals>.<genexpr>L  s#   øè ø€ ÒJ¸�—
‘
˜3¤¨¨cÓ 2×3ÑJùs   ƒ&))ÚinspectÚ	signaturer`   Ú
parametersÚAttributeErrorrk   r   r×   rZ   rv   rw   )r_   rÒ   rÛ   rØ   ÚargsÚrdrZ   s   ``     r   ÚreplacezRdata.replace-  s÷   ù€ ô ×&Ñ& t§}¡}Ó5×@Ñ@ˆ
ð ò 
	ˆCØ�kÒ!ØØ˜*Ñ$Ü$Ø˜Ÿ™×/Ñ/Ð0Ð0KÈCÈ5ÐPQÐRóð ð Ð+Ò+Ü$Ø(¨¯©×)@Ñ)@Ð(AÀÈsÈeÐSTÐUóð ð
	ô K¸zÔJˆð ˆT�^‰^˜TÐ"ˆð —J‘J˜{¨D¯N©NÓ;ˆ	ØÐ Ü×Ñ˜r ;°	Ô:Øˆ	r   c                 óT   — t         j                  j                  j                  |«      S rp   )r|   r¥   Ú
RdataClassÚmake©rf   Úvalues     r   r]   zRdata._as_rdataclassZ  s   € ä�~‰~×(Ñ(×-Ñ-¨eÓ4Ð4r   c                 óT   — t         j                  j                  j                  |«      S rp   )r|   r}   Ú	RdataTyperâ   rã   s     r   r^   zRdata._as_rdatatype^  s   € ä�}‰}×&Ñ&×+Ñ+¨EÓ2Ð2r   rä   r%   Ú
max_lengthÚempty_okc                 ó,  — |r!t        |t        «      r|j                  «       }n:t        |t        «      rt	        |«      }nt        |t        «      r|}nt        d«      ‚|�t        |«      |kD  rt        d«      ‚|st        |«      dk(  rt        d«      ‚|S )Nz	not bytesztoo longr   zempty bytes not allowed)r$   r   r%   rD   r-   Ú
ValueErrorr)   )rf   rä   r%   rç   rè   Úbvalues         r   Ú	_as_byteszRdata._as_bytesb  sƒ   € ñ ”j ¬Ô,Ø—\‘\“^‰FÜ˜œyÔ)Ü˜5“\‰FÜ˜œuÔ%Ø‰Fä˜[Ó)Ð)ØÐ!¤c¨&£k°JÒ&>Ü˜ZÓ(Ð(ÙœC ›K¨1Ò,ÜÐ6Ó7Ð7Øˆr   c                 óÂ   — t        |t        «      rt        j                  j	                  |«      S t        |t        j                  j
                  «      st        d«      ‚|S )Nz
not a name)r$   r   r|   r«   rÍ   ÚNamerê   rã   s     r   Ú_as_namezRdata._as_namex  sE   € ô
 �eœSÔ!Ü—8‘8×%Ñ% eÓ,Ð,Ü˜E¤3§8¡8§=¡=Ô1Ü˜\Ó*Ð*Øˆr   c                 óf   — t        |t        «      st        d«      ‚|dk  s|dkD  rt        d«      ‚|S )Núnot an integerr   éÿ   znot a uint8©r$   r   rê   rã   s     r   Ú	_as_uint8zRdata._as_uint8ƒ  s5   € ä˜%¤Ô%ÜÐ-Ó.Ð.Ø�1Š9˜ šÜ˜]Ó+Ð+Øˆr   c                 óf   — t        |t        «      st        d«      ‚|dk  s|dkD  rt        d«      ‚|S )Nrñ   r   iÿÿ  znot a uint16ró   rã   s     r   Ú
_as_uint16zRdata._as_uint16‹  s5   € ä˜%¤Ô%ÜÐ-Ó.Ð.Ø�1Š9˜ šÜ˜^Ó,Ð,Øˆr   c                 óf   — t        |t        «      st        d«      ‚|dk  s|dkD  rt        d«      ‚|S )Nrñ   r   l   ÿÿ znot a uint32ró   rã   s     r   Ú
_as_uint32zRdata._as_uint32“  s6   € ä˜%¤Ô%ÜÐ-Ó.Ð.Ø�1Š9˜ 
Ò*Ü˜^Ó,Ð,Øˆr   c                 óf   — t        |t        «      st        d«      ‚|dk  s|dkD  rt        d«      ‚|S )Nrñ   r   l   ÿÿÿ znot a uint48ró   rã   s     r   Ú
_as_uint48zRdata._as_uint48›  s6   € ä˜%¤Ô%ÜÐ-Ó.Ð.Ø�1Š9˜ Ò/Ü˜^Ó,Ð,Øˆr   c                 ó„   — t        |t        «      st        d«      ‚|�||k  rt        d«      ‚|�||kD  rt        d«      ‚|S )Nrñ   zvalue too smallzvalue too largeró   )rf   rä   ÚlowÚhighs       r   Ú_as_intzRdata._as_int£  sL   € ä˜%¤Ô%ÜÐ-Ó.Ð.Øˆ?˜u sš{ÜÐ.Ó/Ð/ØÐ ¨¢ÜÐ.Ó/Ð/Øˆr   c                 óZ  — t        |t        «      rt        j                  j	                  |«      S t        |t
        «      rt        j                  j                  |«      S t        |t        j                  «      r)t        j                  j                  |j                  «      S t        d«      ‚)Nznot an IPv4 address)r$   r   r|   Úipv4r�   r-   Ú	inet_ntoaÚ	ipaddressÚIPv4AddressÚpackedrê   rã   s     r   Ú_as_ipv4_addresszRdata._as_ipv4_address­  óu   € ä�eœSÔ!Ü—8‘8×(Ñ(¨Ó/Ð/Ü˜œuÔ%Ü—8‘8×%Ñ% eÓ,Ð,Ü˜œy×4Ñ4Ô5Ü—8‘8×%Ñ% e§l¡lÓ3Ð3äÐ2Ó3Ð3r   c                 óZ  — t        |t        «      rt        j                  j	                  |«      S t        |t
        «      rt        j                  j                  |«      S t        |t        j                  «      r)t        j                  j                  |j                  «      S t        d«      ‚)Nznot an IPv6 address)r$   r   r|   Úipv6r�   r-   r  r  ÚIPv6Addressr  rê   rã   s     r   Ú_as_ipv6_addresszRdata._as_ipv6_address¸  r  r   c                 ó<   — t        |t        «      r|S t        d«      ‚)Nznot a boolean)r$   r   rê   rã   s     r   Ú_as_boolzRdata._as_boolÃ  s   € ä�eœTÔ"ØˆLä˜_Ó-Ð-r   c                 óì   — t        |t        «      r+| j                  |dt        j                  j
                  «      S t        |t        «      rt        j                  j                  |«      S t        d«      ‚)Nr   z	not a TTL)	r$   r   rþ   r|   ÚttlÚMAX_TTLr   rÍ   rê   rã   s     r   Ú_as_ttlzRdata._as_ttlÊ  sQ   € ä�eœSÔ!Ø—;‘;˜u a¬¯©¯©Ó9Ð9Ü˜œsÔ#Ü—7‘7×$Ñ$ UÓ+Ð+ä˜[Ó)Ð)r   c                 ó^   ‡— 	  ‰|«      fS # t         $ r t        ˆfd„|D «       «      cY S w xY w)Nc              3   ó.   •K  — | ]  } ‰|«      –— Œ y ­wrp   r   )re   ÚvÚas_values     €r   rg   z"Rdata._as_tuple.<locals>.<genexpr>Ü  s   øè ø€ Ò4¨™ !ŸÑ4ùs   ƒ)Ú	ExceptionÚtuple)rf   rä   r  s     `r   Ú	_as_tuplezRdata._as_tupleÓ  s9   ø€ ð	5ñ ˜U“OÐ%Ð%øÜò 	5ô Ó4¨eÔ4Ó4Ò4ð	5ús   ƒ Œ,«,c                 óF   — t        |«      }t        j                  |«       |S rp   )ÚlistÚrandomÚshuffle)rf   Úiterableru   s      r   Ú_processing_orderzRdata._processing_orderà  s   € ä�X“ˆÜ�‰�uÔØˆr   ©NTN©NNF)NNNFrp   )FNT)NN)Br   r	   r
   r   rc   r[   r   r   r|   r¥   rá   r}   ræ   r`   rn   rs   rz   r   r‚   r«   rî   r   r   r   r   r‰   rˆ   ÚCompressTyper“   r-   r™   rž   r    r§   r©   r´   r¶   r¹   r¾   rÁ   rÄ   rÆ   rÉ   ÚclassmethodÚ	tokenizerÚ	TokenizerrÍ   r�   ÚParserrÑ   rß   r]   r^   rì   rï   rô   rö   rø   rú   rþ   r  r
  r  r  r  r  r   r   r   rW   rW   í   s¦  … á-â2€Ià'+Ð˜# ™*Ó+ðà—‘×*Ñ*ðð —‘×'Ñ'ðð 
ó	ò"
ò
ò8ð"˜Ÿ™×/Ñ/ó "ð1 Có 1ð (,ØØ#'ñ	*à—‘—‘ Ñ$ð*ð ð*ð ˜DÑ ð	*ð
 ð*ð 
ó*ð(	" Jð 	"°3ó 	"ð 26Ø'+Ø"ñ"àð"ð —(‘(×'Ñ'¨$Ñ.ð"ð —‘—‘ Ñ$ð	"ð
 ð"ð 
ó"ð  Ø15Ø'+Ø"ñ à�D‰jð ð —(‘(×'Ñ'¨$Ñ.ð ð —‘—‘ Ñ$ð	 ð
 ð ð 
�‰ó ñ4= §¡§¡°Ñ!5ð =Àó =ñ C§H¡H§M¡M°DÑ$8ð ÀEó ò
ò"ò0òdò*&ò$ò%ò%ò$ò7ð ð (,ØØ.2ñ	"à—‘×*Ñ*ð	"ð —‘×'Ñ'ð	"ð �]‰]×$Ñ$ð		"ð
 —‘—‘ Ñ$ð	"ð ð	"ð —x‘x—}‘} tÑ+ð	"ð 
ò	"ó ð	"ð ð (,ñ"à—‘×*Ñ*ð"ð —‘×'Ñ'ð"ð —‘—‘ð	"ð
 —‘—‘ Ñ$ð"ð 
ò"ó ð"ð( ð (¨ó (ðZ ñ5ó ð5ð ñ3ó ð3ð ð Ø!%Øñàðð ðð ˜$‘Jð	ð
 ðð 
òó ðð* ñó ðð ñó ðð ñó ðð ñó ðð ñó ðð òó ðð ñ4ó ð4ð ñ4ó ð4ð ñ.ó ð.ð ñ*ó ð*ð ñ5ó ð5ð ñó ñr   rW   c                   ó  ‡ — e Zd ZdZdgZdej                  j                  dej                  j                  de
ddfˆ fd„Zdedefd	„Ze	 dd
„«       Zdd„Zddej$                  j&                  dz  dd fd„Zedd„«       Zˆ xZS )rš   z�Generic Rdata Class

    This class is used for rdata types for which we have no better
    implementation.  It implements the DNS "unknown RRs" scheme.
    r   rX   rY   r"   Nc                 ó4   •— t         ‰| �  ||«       || _        y rp   )Úsuperr`   r   )r_   rX   rY   r   rk   s       €r   r`   zGenericRdata.__init__ñ  s   ø€ ô 	‰Ñ˜ &Ô)Øˆ�	r   r2   c                 ób   — dt        | j                  «      › d�t        | j                  |«      z   S )Nz\# r   )r)   r   r.   r�   s     r   rˆ   zGenericRdata.to_styled_textú  s,   € ð ”c˜$Ÿ)™)“nÐ% QÐ'¬.¸¿¹ÀEÓ*JÑJÐJr   c                 ó”  — |j                  «       }|j                  «       r|j                  dk7  rt        j                  j                  d«      ‚|j                  «       }|j                  d«      j                  «       }	t        j                  |	«      }
t        |
«      |k7  rt        j                  j                  d«      ‚ | |||
«      S )Nú\#z$generic rdata does not start with \#Tz'generic rdata hex data has wrong length)r×   Úis_identifierrä   r|   Ú	exceptionÚSyntaxErrorÚget_intÚ!concatenate_remaining_identifiersr%   r6   Ú	unhexlifyr)   )rf   rX   rY   rÊ   rƒ   r„   rË   ÚtokenÚlengthÚhexr   s              r   rÍ   zGenericRdata.from_text   s¡   € ð —‘“	ˆØ×"Ñ"Ô$¨¯©°uÒ(<Ü—-‘-×+Ñ+Ð,SÓTÐTØ—‘“ˆØ×3Ñ3°DÓ9×@Ñ@ÓBˆÜ×!Ñ! #Ó&ˆÜˆt‹9˜ÒÜ—-‘-×+Ñ+Ð,UÓVÐVÙ�7˜F DÓ)Ð)r   c                 ó:   — |j                  | j                  «       y rp   )Úwriter   r’   s        r   r“   zGenericRdata._to_wire  s   € Ø�
‰
�4—9‘9Õr   rƒ   c                 ó   — | S rp   r   )r_   rƒ   s     r   rž   zGenericRdata.to_generic  s   € Øˆr   c                 ó2   —  | |||j                  «       «      S rp   )Úget_remainingrÐ   s        r   rÑ   zGenericRdata.from_wire_parser  s   € á�7˜F F×$8Ñ$8Ó$:Ó;Ð;r   r  r  rp   )r   r	   r
   r   rc   r|   r¥   rá   r}   ræ   r-   r`   r   r   rˆ   r!  rÍ   r“   r«   rî   rž   rÑ   Ú__classcell__)rk   s   @r   rš   rš   ç  sº   ø„ ñð �€Iðà—‘×*Ñ*ðð —‘×'Ñ'ðð ð	ð
 
õðKàðKð 
óKð àOSò*ó ð*óñ §¡§¡°Ñ!5ð Àó ð ò<ó ô<r   rš   Ú_rdata_classeszdns.rdtypesc                 óØ  — t         j                  | |f«      }|sÀt         j                  t        j                  j                  |f«      }|s�t
        r‰t        j                  j                  | «      }t        j                  j                  |«      }|j                  dd«      }	 t        dj                  t        ||g«      «      }t        ||«      }|t         | |f<   |s|rt        }|t         | |f<   |S # t        $ ro 	 t        dj                  t        d|g«      «      }t        ||«      }|t         t        j                  j                  |f<   |t         | |f<   n# t        $ r Y nw xY wY ŒŽw xY w)Nú-Ú_ú.ÚANY)r:  r×   r|   r¥   r?  Ú_dynamic_load_allowedr‰   r}   rß   r   r'   Ú_module_prefixrd   ÚImportErrorrš   )rX   rY   Úuse_genericrf   Úrdclass_textÚrdtype_textÚmods          r   Úget_rdata_classrG     sN  € Ü
×
Ñ
˜g vÐ.Ó
/€CÙÜ× Ñ ¤#§.¡.×"4Ñ"4°fÐ!=Ó>ˆÙÕ,ÜŸ>™>×1Ñ1°'Ó:ˆLÜŸ-™-×/Ñ/°Ó7ˆKØ%×-Ñ-¨c°3Ó7ˆKðÜ#Ø—H‘Hœn¨l¸KÐHÓIó�ô ˜c ;Ó/�Ø47” ¨Ð0Ñ1ñ ‘;ÜˆØ,/Œ˜ Ð(Ñ)Ø€Jøô ò ðÜ'¨¯©´.À%ÈÐ1UÓ(VÓW�CÜ! # {Ó3�CØCF”N¤C§N¡N×$6Ñ$6¸Ð#?Ñ@Ø8;”N G¨VÐ#4Ò5øÜ"ò Ùðüðús7   Â"8C1 Ã1	E)Ã;AEÅE)Å	E#Å E)Å"E#Å#E)Å(E)c                 ó  — t         j                  j                  D ]'  }t        t         j                  j
                  |d«       Œ) t        t         j                  j                  t         j                  j                  d«       | rdayy)a  Load all rdata types for which dnspython has a non-generic implementation.

    Normally dnspython loads DNS rdatatype implementations on demand, but in some
    specialized cases loading all types at an application-controlled time is preferred.

    :param disable_dynamic_load: If ``True`` (the default), dnspython will not
        attempt to use its dynamic loading mechanism if an unknown type is
        subsequently encountered, and will simply use the ``GenericRdata``
        class.
    :type disable_dynamic_load: bool
    FN)	r|   r}   ræ   rG  r¥   ÚINÚCHÚAr@  )Údisable_dynamic_loadrY   s     r   Úload_all_typesrM  <  sc   € ô —-‘-×)Ñ)ò :ˆÜœŸ™×)Ñ)¨6°5Õ9ð:ô
 ”C—N‘N×%Ñ%¤s§}¡}§¡¸Ô>Ùð !&Ñð	 r   rX   rY   rÊ   rƒ   r„   rË   Ú
idna_codecc           
      óÚ  — t        |t        «      r!t        j                  j	                  ||¬«      }t        |t        j                  j                  «      st        d«      ‚t        j                  j                  j                  | «      } t        j                  j                  j                  |«      }t        | |«      }|€J ‚t        j                  j                  t        j                  j                  «      5  d}|t        k7  rû|j!                  «       }	|j#                  |	«       |	j%                  «       rÊ|	j&                  dk(  r»t        j)                  | |||||«      }
t+        | ||
j,                  dt/        |
j,                  «      «      }|j1                  «       }||
j,                  k7  rt        j                  j                  d«      ‚|xs |}|r/|�-t+        | ||
j,                  dt/        |
j,                  «      |«      }|€|j)                  | |||||«      }|j3                  «       }	|	j4                  �!t6        j9                  |d|	j4                  «       |cddd«       S # 1 sw Y   yxY w)a«  Build an rdata object from text format.

    This function attempts to dynamically load a class which
    implements the specified rdata class and type.  If there is no
    class-and-type-specific implementation, the GenericRdata class
    is used.

    Once a class is chosen, its from_text() class method is called
    with the parameters to this function.

    If *tok* is a ``str``, then a tokenizer is created and the string
    is used as its input.

    :param rdclass: The rdata class.
    :type rdclass: :py:class:`dns.rdataclass.RdataClass` or ``str``
    :param rdtype: The rdata type.
    :type rdtype: :py:class:`dns.rdatatype.RdataType` or ``str``
    :param tok: The tokenizer or input string.
    :type tok: :py:class:`dns.tokenizer.Tokenizer` or ``str``
    :param origin: The origin to use for relative names.
    :type origin: :py:class:`dns.name.Name` or ``None``
    :param relativize: If ``True``, names will be relativized. Default is ``True``.
    :type relativize: bool
    :param relativize_to: The origin to use when relativizing. Defaults to *origin*.
    :type relativize_to: :py:class:`dns.name.Name` or ``None``
    :param idna_codec: The IDNA encoder/decoder to use when creating a tokenizer.
        If ``None``, the default IDNA 2003 codec is used.
    :type idna_codec: :py:class:`dns.name.IDNACodec` or ``None``
    :returns: An instance of the chosen :py:class:`Rdata` subclass.
    :rtype: :py:class:`Rdata`

    )rN  z#tok must be a string or a TokenizerNr*  r   z9compressed data in generic syntax form of known rdatatyperZ   )r$   r   r|   r"  r#  rê   r¥   rá   râ   r}   ræ   rG  r,  ÚExceptionWrapperr-  rš   r×   Úungetr+  rä   rÍ   Ú	from_wirer   r)   r™   Úget_eol_as_tokenÚcommentrv   rw   )rX   rY   rÊ   rƒ   r„   rË   rN  rf   Úrdatar1  ÚgrdataÚrwireÚrelativize_origins                r   rÍ   rÍ   V  s  € ôR �#”sÔÜ�m‰m×%Ñ% c°jÐ%ÓAˆÜ�cœ3Ÿ=™=×2Ñ2Ô3ÜÐ>Ó?Ð?Ü�n‰n×'Ñ'×,Ñ,¨WÓ5€GÜ�]‰]×$Ñ$×)Ñ)¨&Ó1€FÜ
˜' 6Ó
*€CØˆ?Ðˆ?Ü	�‰×	'Ñ	'¬¯©×(AÑ(AÓ	Bñ /ØˆØ”,Òà—G‘G“IˆEØ�I‰I�eÔØ×"Ñ"Ô$¨¯©¸Ò)=ô &×/Ñ/Ø˜V S¨&°*¸mó�ô " '¨6°6·;±;ÀÄ3ÀvÇ{Á{ÓCSÓT�ð Ÿ™›�Ø˜FŸK™KÒ'ÜŸ-™-×3Ñ3ð-óð ð %2Ò$;°VÐ!ÙÐ"3Ð"?Ü%ØØØŸ™ØÜ˜FŸK™KÓ(Ø)ó�Eð ˆ=Ø—M‘MØ˜  f¨j¸-óˆEð ×$Ñ$Ó&ˆØ�=‰=Ð$Ü×Ñ˜u k°5·=±=ÔAØ÷_/÷ /ò /ús   Ã:EI!É!I*rÎ   c                 óˆ  — t         j                  j                  j                  | «      } t         j                  j
                  j                  |«      }t        | |«      }|€J ‚t         j                  j                  t         j                  j                  «      5  |j                  | |||«      cddd«       S # 1 sw Y   yxY w)a™  Build an rdata object from wire format

    This function attempts to dynamically load a class which
    implements the specified rdata class and type.  If there is no
    class-and-type-specific implementation, the GenericRdata class
    is used.

    Once a class is chosen, its from_wire() class method is called
    with the parameters to this function.

    :param rdclass: The rdata class.
    :type rdclass: :py:class:`dns.rdataclass.RdataClass` or ``str``
    :param rdtype: The rdata type.
    :type rdtype: :py:class:`dns.rdatatype.RdataType` or ``str``
    :param parser: The wire format parser, restricted to the rdata length.
    :type parser: :py:class:`dns.wire.Parser`
    :param origin: If not ``None``, names will be relativized to this origin.
    :type origin: :py:class:`dns.name.Name` or ``None``
    :returns: An instance of the chosen :py:class:`Rdata` subclass.
    :rtype: :py:class:`Rdata`
    N)r|   r¥   rá   râ   r}   ræ   rG  r,  rP  Ú	FormErrorrÑ   )rX   rY   rÎ   rƒ   rf   s        r   rÑ   rÑ   ¹  s—   € ô8 �n‰n×'Ñ'×,Ñ,¨WÓ5€GÜ�]‰]×$Ñ$×)Ñ)¨&Ó1€FÜ
˜' 6Ó
*€CØˆ?Ðˆ?Ü	�‰×	'Ñ	'¬¯©×(?Ñ(?Ó	@ñ EØ×#Ñ# G¨V°V¸VÓD÷E÷ Eò Eús   ÂB8Â8Cr�   ÚcurrentÚrdlenc                 ó¬   — t         j                  j                  ||«      }|j                  |«      5  t	        | |||«      cddd«       S # 1 sw Y   yxY w)a
  Build an rdata object from wire format

    This function attempts to dynamically load a class which
    implements the specified rdata class and type.  If there is no
    class-and-type-specific implementation, the GenericRdata class
    is used.

    Once a class is chosen, its from_wire() class method is called
    with the parameters to this function.

    :param rdclass: The rdata class.
    :type rdclass: :py:class:`dns.rdataclass.RdataClass` or ``str``
    :param rdtype: The rdata type.
    :type rdtype: :py:class:`dns.rdatatype.RdataType` or ``str``
    :param wire: The wire-format message.
    :type wire: bytes
    :param current: The offset of the start of the rdata in *wire*.
    :type current: int
    :param rdlen: The length of the rdata in wire format.
    :type rdlen: int
    :param origin: If not ``None``, names will be relativized to this origin.
    :type origin: :py:class:`dns.name.Name` or ``None``
    :returns: An instance of the chosen :py:class:`Rdata` subclass.
    :rtype: :py:class:`Rdata`
    N)r|   r�   r$  Úrestrict_torÑ   )rX   rY   r�   r[  r\  rƒ   rÎ   s          r   rR  rR  Ý  sN   € ôB �X‰X�_‰_˜T 7Ó+€FØ	×	Ñ	˜EÓ	"ñ AÜ ¨°¸Ó@÷A÷ Aò Aús   ²A
Á
Ac                   ó   — e Zd ZdZddhZdZy)ÚRdatatypeExistszDNS rdatatype already exists.rX   rY   zKThe rdata type with class {rdclass:d} and rdtype {rdtype:d} already exists.N)r   r	   r
   r   Úsupp_kwargsÚfmtr   r   r   r`  r`    s   „ Ù'à˜hÐ'€Kð	ñ r   r`  ÚimplementationrE  Úis_singletonc                 ó®  — t         j                  j                  j                  |«      }t	        ||«      }|t
        k7  st         j                  j                  |«      rt        ||¬«      ‚t        | t        «      rt        | t        «      r| }nt        | |j                  dd«      «      }|t        ||f<   t         j                  j                  |||«       y)ao  Dynamically register a module to handle an rdatatype.

    :param implementation: A subclass of :py:class:`dns.rdata.Rdata` implementing
        the type, or a module containing such a class named by its text form.
    :param rdtype: The rdatatype to register.
    :type rdtype: int
    :param rdtype_text: The textual form of the rdatatype.
    :type rdtype_text: str
    :param is_singleton: If ``True``, RRsets of this type can have only one member.
    :type is_singleton: bool
    :param rdclass: The rdata class, or ``dns.rdataclass.ANY`` for all classes.
    :type rdclass: :py:class:`dns.rdataclass.RdataClass`
    rÕ   r<  r=  N)r|   r}   ræ   râ   rG  rš   Úis_metatyper`  r$   ÚtypeÚ
issubclassrW   rd   rß   r:  Úregister_type)rc  rY   rE  rd  rX   Úexisting_clsÚimpclasss          r   ri  ri    s¦   € ô* �]‰]×$Ñ$×)Ñ)¨&Ó1€FÜ" 7¨FÓ3€LØ”|Ò#¤s§}¡}×'@Ñ'@ÀÔ'HÜ g°fÔ=Ð=Ü�.¤$Ô'¬J°~ÄuÔ,MØ!‰ä˜>¨;×+>Ñ+>¸sÀCÓ+HÓIˆØ(0„N�G˜VÐ$Ñ%Ü‡M�M×Ñ ¨°\ÕBr   )F)T)NTNNrp   )Lr   r=   r6   ÚdataclassesrÙ   r•   r  rh   r  Ú	importlibr   Útypingr   Údns.exceptionr|   Údns.immutableÚdns.ipv4Údns.ipv6Údns.nameÚdns.rdataclassÚdns.rdatatypeÚdns.tokenizerÚdns.ttlÚdns.wireÚ
_chunksizer­   r,  ÚDNSExceptionr   Ú	dataclassr«   Ú	NameStyler   r-   r   r   r+   r1   r   r.   r;   r:   rE   rM   rJ   rP   rU   Ú	immutableÚconstifyÚ	_constifyrW   rš   r:  Údictr  r¥   rá   r}   ræ   r   rA  r@  rG  rM  r"  r#  rî   Ú	IDNACodecrÍ   r�   r$  rÑ   rR  r`  rI  ri  r   r   r   ú<module>r‚     s  ðò$ ã Û Û Û Û 	Û Û Û Ý #Ý ã Û Û Û Û Û Û Û Û Û à€
ð #Ð ô˜cŸm™m×8Ñ8ô ð €×Ñ˜dÔ#ô."�—‘×#Ñ#ó ."ó $ð."ðd #-ÀtñØ
ðØðØ9>À¹ðàóð& 'Àñ °5¸3±;ó ñ 
ð °tó ð  *ÀCñ °e¸c±kó ñ :ð ¸$ó ð  €ØÐ òò&ò"ð �M‰M×"Ñ"€	ð ‡�×Ñ÷vð vó ðvðr ‡�×Ñô.<�5ó .<ó ð.<ðd ð ��U˜3Ÿ>™>×4Ñ4°c·m±m×6MÑ6MÐMÑNÐPSÐSÑTó ð €ØÐ óó8&ð< $(ØØ*.Ø,0ñ`Ø�^‰^×&Ñ&¨Ñ,ð`à�M‰M×#Ñ# cÑ)ð`ð 
�‰×	 Ñ	  3Ñ	&ð`ð �H‰H�M‰M˜DÑ ð	`ð
 ð`ð —8‘8—=‘= 4Ñ'ð`ð —‘×"Ñ" TÑ)ð`ð ó`ðN $(ñ	!EØ�^‰^×&Ñ&¨Ñ,ð!Eà�M‰M×#Ñ# cÑ)ð!Eð �H‰H�O‰Oð!Eð �H‰H�M‰M˜DÑ ð	!Eð
 ó!EðT $(ñ#AØ�^‰^×&Ñ&¨Ñ,ð#Aà�M‰M×#Ñ# cÑ)ð#Að ð#Að ð	#Að
 ð#Að �H‰H�M‰M˜DÑ ð#Að ó#AôL�c—m‘m×0Ñ0ô ð Ø),¯©×):Ñ):ñCØðCàðCð ðCð ð	Cð
 �^‰^×&Ñ&ðCð 
ôCr   