+ +O|jXaRUtr0tRt^RIt^RIt^RIt^RIt^RIt^RIt^RIt^RI t ^RI t ^RI t ^RI t ^RIHtHtHtHtHtHt^RIt^RIt^RIt^RIt^RIt^RIt^RIt^RIt^RIt^RIt^RI t^RI!t^RI"t^RI#t#Rt'Rt(]PRPUR4t+]+'dV^RI,t-^RI.t.]-P^t0]-PbPdPft4!RR]04t5!RR ].Pl4t7M !R R 4t7]+t8R R lt9]9t:]^k!R R]PvPx4t=!RR]PvP|4t?!RR]PvPx4t@!RR]PvPx4tA]PPtCRtDRtERtFRtGRtHRtIRVRltJRWRRlltKRXRR lltLR!tMR"R#ltN!R$R%]P4tPRR&R^R'R'RR(RRRR] P]PP3R)R*lltSR+R,ltTR-R.ltURYR/R0lltVR1tWR2tXRWR3R4lltYRZR5R6lltZR[R7R8llt[R\R9R:llt\R;t]R<t^RWR=R>llt_R]R?R@llt`RAtaR^RBRClltbRDtcR_RERFlltdRGRHlteR`RIRJlltfRaRKRLlltg!RMRN]P4thRORPlti]PP]PPR^5RRRRR^^R']PP3 RQRRlltBR^5RRR^]hP3RSRTlltqR# ]$d ^RI%H&t#ELi;i)bzTalk to a DNS server.N)AnyCallableDictOptionalTuplecastcVfR#V\P!4, pVR8:d\PPhV#)N)timedns exceptionTimeout) expirationtimeouts& BC:\Users\alokc\chatbot\backend\venv\Lib\site-packages\dns/query.py _remainingr5s7499;&G#~mm### NcZVfR#\\P!4V,V4#N)minr )rrs&&r_expiration_for_this_attemptr>s# tyy{W$j 11rdohcFaa]tRt^LtoV3RltRRltRRltRtVtV;t #)_NetworkBackendcT<\SV`4W nWnW0nW@nR#r)super__init__ _local_port _resolver_bootstrap_address_family)selfresolver local_portbootstrap_addressfamily __class__s&&&&&rr_NetworkBackend.__init__Ms$ G  ) %N&7 #!Lrc.p\V4wrx\PPV4'dVP V4MVP eVP VP 4Mk\ V4pVPp V'd \PPV4p VPPWVR7p V P4pVFp \PPV 4p VfVP^8wd3VfRp\PPW@P3V 4p MRp \V \P V 4p\#RV4p\%V\PPW3V 4V4\'V4u# \*P,h \(dKi;i)N)r%lifetimez0.0.0.0g@)_compute_timesr inet is_addressappendrrr af_for_addressr resolve_name addressesrlow_level_address_tuple make_socketsocket SOCK_STREAMr_connect_CoreSyncStream Exceptionhttpcore ConnectError)r!hostportr local_addresssocket_optionsr0_rr%answersaddressafsourcesockattempt_expirations&&&&&& r connect_tcp_NetworkBackend.connect_tcpTsI*73MAxx""4((  &((4  !8!89$Z0  XX44]CF..55'6$--/ $XX,,W5 ,0@0@A0E$,(1  XX==&(8(892F"F &r6+=+=vFD)Ec:)V&88'"M* +400%%*'' '!s AF<< G  G c\hrNotImplementedError)r!pathrr=s&&&&rconnect_unix_socket#_NetworkBackend.connect_unix_socket}s & %r)rr rr)NNNNN) __name__ __module__ __qualname____firstlineno__rrErK__static_attributes____classdictcell__ __classcell__r& __classdict__s@@rrrLs "' (R & &rrcZaa]tRt^toR^RRRRR]P /V3RlltRtVtV;t #)_HTTPTransportr#r$Nr"r%c<Vf#Vf^RIpVPP4p\SV`!V/VB\ W1W$4VP nR#r) dns.resolverr"Resolverrrr_pool_network_backend) r!r#r$r"r%argskwargsr r&s &$$$$*, rr_HTTPTransport.__init__sO$5$=#<<002 G d -f -*9&7+DJJ 'r) rNrOrPrQr3 AF_UNSPECrrRrSrTrUs@@rrXrXs=  #      ##   rrXcTa]tRt^toR^RRRRR]P /RltRtRtVt R#) rXr#r$Nr"r%cR#rra)r!r#r$r"r%r^r_s&$$$$*,rrr`s rc\hrrH)r!r:r;rr<s&&&&&rrE_HTTPTransport.connect_tcp% %rra) rNrOrPrQr3rbrrErRrSrVs@rrXrXsB  #    ##  & &rcV^8dQhR\P\,R\PR\R\P/#)rAkindprotoreturn)r3 AddressFamilyint SocketKind)formats"r __annotate__rrsE**s"*   * * ]] *rc0\P!WV4#r)r3)rArkrls&&&rdefault_socket_factoryrts ==5 ))rc]tRt^tRtRtR#)UnexpectedSourcez=A DNS query response came from an unexpected address or port.raNrNrOrPrQ__doc__rRrarrrvrvsGrrvc]tRt^tRtRtR#) BadResponsezrseleventsrs&&&&& r _wait_forrsJr3==11bjjlQ6F  " " $ $  i** *F  i++ +F  LL $  G 499;.G#~mm+++zz'""--'' '# % $ $ $s)D7D7&A+D7D77 E c$\VRRRV4R#)TFNrsrs&&r_wait_for_readablers audJ/rc$\VRRRV4R#)FTNrrs&&r_wait_for_writablers adJ/rc&\PPW^,4p\PPW^,4pY48H;'dTR,TR,8H# \PPdR#i;i)rFNN)r r+ inet_ptonr SyntaxError)rAa1a2n1n2s&&& r_addresses_equalrst XX  qE * XX  qE * 8 ( (2"R&(( == $ $sA A--BBcV'gR#\WV4'gB\PPV^,4'dVR,VR,8XdR#V'dR#\ RV RV 24h)TrFzgot a response from z instead of )rr r+ is_multicastrv)rA from_address destinationignore_unexpecteds&&&&r_matches_destinationrsg +66 k!n--,r2BkRTo2U   |nL[MJ rTcHRpRp\PPV4pTpV'd<\PPV4pV'dWu8wd \ R4hMTpV'd)V'g!\PP V4pV'd"\PP Wa3V4pV'd"\PP W#3V4pWVV3# \d T'dhLi;i \d \ R4hi;i)Nz5different address families for source and destinationz3source_port specified but address family is unknown)r r+r.r7 ValueError any_for_afr1)wherer;rB source_portwhere_must_be_addressrArsafs&&&&& r_destination_and_sourcers BK XX $ $U + hh%%f- y KB6 TXX((,F hh66 7JBO  1162GL V $$?   !, TRS S Ts#!C0;D 0DDD D!cV^8dQhR\P\,R\PR\R,R\P/#)rjrAtyperBNrm)r3rnrorpr)rqs"rrrrrDsIs"    $J ]] rc\W^4pVPR4VeVPV4V# \dTP 4hi;i)a!Make a socket. This function uses the module's ``socket_factory`` to make a socket of the specified address family and type. *af*, a ``socket.AddressFamily`` or ``int`` is the address family, either ``socket.AF_INET`` or ``socket.AF_INET6``. *type*, a ``socket.SocketKind`` is the type of socket, e.g. ``socket.SOCK_DGRAM``, a datagram socket, or ``socket.SOCK_STREAM``, a stream socket. Note that the ``proto`` attribute of a socket is always zero with this API, so a datagram socket will always be a UDP socket, and a stream socket will always be a TCP socket. *source* is the source address and port to bind to, if any. The default is ``None`` which will bind to the wildcard address and a randomly chosen port. If not ``None``, it should be a (low-level) address tuple appropriate for *af*. F)socket_factory setblockingbindr7close)rArrBrs&&& rr2r2DsR, r#A e   FF6N    s '6Ac  V^8dQhR\P\,R\PR\P R\ PP\,R,R\R,R\P/#)rjrAr ssl_contextserver_hostnameNrBrm) r3rnrorpr SSLContextr nameNamestrrr)rqs"rrrrress''s"'   ''XX]]S(4/ ' $J '  ]] 'rc\WV4p\V\PP4'dVP 4pVP VRVR7#)aVMake a socket. This function uses the module's ``socket_factory`` to make a socket of the specified address family and type. *af*, a ``socket.AddressFamily`` or ``int`` is the address family, either ``socket.AF_INET`` or ``socket.AF_INET6``. *type*, a ``socket.SocketKind`` is the type of socket, e.g. ``socket.SOCK_DGRAM``, a datagram socket, or ``socket.SOCK_STREAM``, a stream socket. Note that the ``proto`` attribute of a socket is always zero with this API, so a datagram socket will always be a UDP socket, and a stream socket will always be a TCP socket. If *ssl_context* is not ``None``, then it specifies the SSL context to use, typically created with ``make_ssl_context()``. If *server_hostname* is not ``None``, then it is the hostname to use for server certificate validation. A valid hostname must be supplied if *ssl_context* requires hostname checking. *source* is the source address and port to bind to, if any. The default is ``None`` which will bind to the wildcard address and a randomly chosen port. If not ``None``, it should be a (low-level) address tuple appropriate for *af*. F)do_handshake_on_connectr)r2rr rrto_text wrap_socket)rArrrrBrCs&&&&& rmake_ssl_socketresT> r (D/388==11)113  " " %' # rc<Ve\WW4V4#\WV4#r)rr2)rArrBrrs&&&&&r _make_socketrs&rvNN2V,,rc6V^8dQhR\R,RR/#)rjr"dns.resolver.Resolverrm)r)rqs"rrrrrs"  ./  rcJVf^RIpVPP4pV#r)rZr"r[)r"r s& r_maybe_get_resolverrs$ <<((* Orc6]tRtRtRt^t^t^t^t^t ^t ^t Rt R#) HTTPVersionizzWhich version of HTTP should be used? DEFAULT will select the first version from the list [2, 1.1, 3] that is available. raN) rNrOrPrQrxDEFAULTHTTP_1H1HTTP_2H2HTTP_3H3rRrarrrrs, G F B F B F BrrFz /dns-queryc"V^8dQhR\PPR\R\R,R\ R\R,R\ R\ R \ R \R,R \R \ R \R,R\ \,\P,R\R,R\ R\R\PP/#)rjqrrNr;rBrone_rr_per_rrsetignore_trailingsessionrJpostr$verifyr"rr% http_versionrm) r messageMessagerfloatroboolrrrrr)rqs"rrrrrsL L  {{L L T\L   L $J L  L L L 4ZL  L  L TzL  3J 'L ./L  L !L " [[#L rc< \WWER4wpppTpVee\PPV4'd@V\P 8Xd RV RV V 2pMV\P 8Xd RV RV V 2p/pV f\PPV4pVPf \R4h\PPVP4'dVPp VPVR&VPe VPpV\P8Xg"V\P8Xd\ 'gV fe\#V 4p XPfQhV P%VPV4p\&P(!\+VP-444p V'd6\/V\P0P24'g \R 4h\5VV VVVVVVVV V VR 7 #\ 'g\6hV'd,\/V\8P:4'g \R 4hVP=4pR R /pV\P>\P39pV\P@\P39pVfRp^pMV^,pV^,pV'd\BPD!V4pM-\GVVVV VV V VR7p\8P:!VVV VR7pT;_uu_4pVfQhV 'd?VPIRR R\K\MV44/4VPOVVVVVR7pMM\PPR!V4PUR4pVPW4p VPYVVVRV /VR7pRRR4XPZ^8gVPZR8d(\V RVPZ RVP\ 24h\P^PaVP\VPbVPdVVR7p!VPfPi4V!n5VPmV!4'g\nhV!# +'giL;i)aReturn the response obtained after sending a query via DNS-over-HTTPS. *q*, a ``dns.message.Message``, the query to send. *where*, a ``str``, the nameserver IP address or the full URL. If an IP address is given, the URL will be constructed using the following schema: https://:/. *timeout*, a ``float`` or ``None``, the number of seconds to wait before the query times out. If ``None``, the default, wait forever. *port*, a ``int``, the port to send the query to. The default is 443. *source*, a ``str`` containing an IPv4 or IPv6 address, specifying the source address. The default is the wildcard address. *source_port*, an ``int``, the port from which to send the message. The default is 0. *one_rr_per_rrset*, a ``bool``. If ``True``, put each RR into its own RRset. *ignore_trailing*, a ``bool``. If ``True``, ignore trailing junk at end of the received message. *session*, an ``httpx.Client``. If provided, the client session to use to send the queries. *path*, a ``str``. If *where* is an IP address, then *path* will be used to construct the URL to send the DNS query to. *post*, a ``bool``. If ``True``, the default, POST method will be used. *bootstrap_address*, a ``str``, the IP address to use to bypass resolution. *verify*, a ``bool`` or ``str``. If a ``True``, then TLS certificate verification of the server is done using the default CA bundle; if ``False``, then no verification is done; if a `str` then it specifies the path to a certificate file or directory which will be used for verification. *resolver*, a ``dns.resolver.Resolver`` or ``None``, the resolver to use for resolution of hostnames in URLs. If not specified, a new resolver with a default configuration will be used; note this is *not* the default resolver as that resolver might have been configured to use DoH causing a chicken-and-egg problem. This parameter only has an effect if the HTTP library is httpx. *family*, an ``int``, the address family. If socket.AF_UNSPEC (the default), both A and AAAA records will be retrieved. *http_version*, a ``dns.query.HTTPVersion``, indicating which HTTP version to use. Returns a ``dns.message.Message``. FNzhttps://:z https://[z]:zno hostname in URL sni_hostnamez8session parameter must be a dns.quic.SyncQuicConnection.)rr connectionz)session parameter must be an httpx.Clientacceptzapplication/dns-message)r<http1http2rr#r$r"r%)rrr transportz content-typezcontent-length)headerscontentr extensions=r )rrparamsr+ responded with status code z Response body: keyring request_macrr)8rr r+r,r3AF_INETAF_INET6urllibparseurlparsehostnamerr;rrrhave_dohrr/randomchoicelistr0rquicSyncQuicConnection_http3r|httpxClientto_wirerr contextlib nullcontextrXupdaterlenrbase64urlsafe_b64encoderstripdecodeget status_coderr from_wirerrelapsed total_secondsr is_responserz)"rrrr;rBrrrrrJrr$rr"r%rrAr> the_sourceurlrparsedr?wirerh1h2r<r#cmrresponsetwirers"&&&&&&&&&&&&&&&& rhttpsrs%N2 V%RJ C ~#((--e44  UG1TF4&1C 6?? "eWBtfTF3CJ &&s+ ?? "12 2 88  v / / & )/J~ & ;; ";;D{~~% +++HH  $*84H??. ..++FOOVDG & d73D3D3F.G H  : SXX00  WX X           8 z'5<<88DEE 99;D23G +..+*=*=> >B +..+*=*=> >B  "1 ] 0:0F0Fw0O"'!/  \\Bv  w"""  NN"$=$c#d)n  ||% $H++D188>DKKME{{u~% #H+ >c!X%9%9C%?g1(2F2F1G 0 01 3    MM)'  A   + + -AF ==   H] s R /B R  R cdV^8dQhR\PPR\R\/#)rjrrrm)r rHeadersbytes)rqs"rrrrrs+#((**%ErcLVf\hVFwr#W!8XgK Vu# \hr)KeyError)rrheadervalues&& r _find_headerr$s)  >L! NrchV^8dQhR\PPR\R\RR/#)rjrpeerrrmN)r rrrr)rqs"rrrrrs8OO388++O3OeOOrc,\VR4pVf \R4h\V4pV^8d \R4hV^8gVR8d=Rp\V4^8dRVP 4,p\ V RV V 24hR# \ dL!i;i)s:statusNzno :status header in responsezstatus is negativerz: r)r$rrorr r7r)rr&rr#statuserrors&&& r _check_statusr+s * -E }9:: ZF z.// |v| t9q= t{{},D6!=fXeWMNN$   sB BBcV^8dQhR\PPR\R\R\R,R\ R\R,R\ R \ R \ R \ \,\P,R \ R \PPR,R\PP/ #)rjrrrrNr;rBrrrrrrrm) r rrrrrorrrrr)rqs"rrrrrs: :  {{: :  : T\ :  : $J : : : :  3J ':  : ++d2:  [[: rc @\PP'g \R4h\P P V4p V Pp V fQhV Pe V Pp^Vn VP4pV 'd\P!R4pM#\PPWRR7pTpT;_uu_4V 'dT pMXPWWV4p\V4wppVP!V4;_uu_4pVP#W.V 4VP%\'V44p\)VP+4W4RRR4\,P,!4pRRR4\P.P1VVP2VP4VVR7p\7XX, R4VnVP9V4'g\:hV# +'giL;i +'giL;i)z DNS-over-HTTP3 is not available.NT) verify_mode server_nameh3rr )r r have_quicr|rrrrr;idrrrSyncQuicManagerconnectr* make_streamsend_h3receiverr+rr rrrrmaxrrz)rrrrr;rBrrrrrr url_partsrrmanager the_managerthe_connectionstartrstreamfinishrs&&&&&&&&&&&& rrrs 88   677 %%c*I!!H   ~~!~~ AD 99;D5?5K5KD5Q((**+   'N(00VN-W5  ' ' 0 0F NN3d +>>*Z"89D &..*E 81    MM)'  A% %AF ==   H1 0 s&AH AG: &H : H H  H cbVPV4# \d\Y4K,i;i)zReads a datagram from the socket. A Timeout exception will be raised if the operation is not completed by the expiration time. )recvfromBlockingIOErrorr)rCmax_sizers&&&r _udp_recvrDs2  1==* * 1 t 0 1s ..cV'dVPW4#VPV4# \d\Y4KEi;i)zSends the specified datagram to destination over the socket. A Timeout exception will be raised if the operation is not completed by the expiration time. )sendtosendrBr)rCdatarrs&&&&r _udp_sendrIsC  1{{455yy& 1 t 0 1s---AAc V^8dQhR\R\PP\,R\R\ R,R\ \\ 3,/#)rjrCwhatrrNrmrr rrrrrro)rqs"rrrrrsV  ++   %   3: rc\V\PP4'dVP 4p\ P !4p\ WW#4pWT3#)aSend a DNS message to the specified UDP socket. *sock*, a ``socket``. *what*, a ``bytes`` or ``dns.message.Message``, the message to send. *destination*, a destination tuple appropriate for the address family of the socket, specifying where to send the query. *expiration*, a ``float`` or ``None``, the absolute time at which a timeout exception should be raised. If ``None``, no timeout will occur. Returns an ``(int, float)`` tuple of bytes sent and the sent time. )rr rrrr rI)rCrKrr sent_timens&&&& rsend_udprPsE,$ ++,,||~ I$k6A >rcV^8dQhR\R\R,R\R,R\R\R\\P P \PP3,R,R\R,R \R \R \R \PPR,R \/ #)rjrCrNrrrrrrraise_on_truncation ignore_errorsqueryrm) rrrrr rrtsigKeyrrr)rqs"rrrrrsg4g4 g4tg4 g4 g4  g4 #((--- . 5 g4g4g4g4g4 ;;   %g4 g4rc .Rp \VRV4wr\VPWV4'gK/\P!4p \P P V VVVVVR7pT 'dT eT PT4'gKT'dY3#YT 3# \P Pd>pT 'd0T e,T PTP 44'gRp?KhRp?i\dT 'dEKhi;i)aRead a DNS message from a UDP socket. *sock*, a ``socket``. *destination*, a destination tuple appropriate for the address family of the socket, specifying where the message is expected to arrive from. When receiving a response, this would be where the associated query was sent. *expiration*, a ``float`` or ``None``, the absolute time at which a timeout exception should be raised. If ``None``, no timeout will occur. *ignore_unexpected*, a ``bool``. If ``True``, ignore responses from unexpected sources. *one_rr_per_rrset*, a ``bool``. If ``True``, put each RR into its own RRset. *keyring*, a ``dict``, the keyring to use for TSIG. *request_mac*, a ``bytes`` or ``None``, the MAC of the request (for TSIG). *ignore_trailing*, a ``bool``. If ``True``, ignore trailing junk at end of the received message. *raise_on_truncation*, a ``bool``. If ``True``, raise an exception if the TC bit is set. Raises if the message is malformed, if network errors occur, of if there is a timeout. If *destination* is not ``None``, returns a ``(dns.message.Message, float)`` tuple of the received message and the received time. If *destination* is ``None``, returns a ``(dns.message.Message, float, tuple)`` tuple of the received message, the received time, and the address where the message arrived from. *ignore_errors*, a ``bool``. If various format errors or response mismatches occur, ignore them and keep listening for a valid response. The default is ``False``. *query*, a ``dns.message.Message`` or ``None``. If not ``None`` and *ignore_errors* is ``True``, check that the received message is a response to this query, and if not keep listening for a valid response. r)rrrrrRN) rDrr%r r rr Truncatedrr7)rCrrrrrrrrRrSrTrr received_timeres&&&&&&&&&&& r receive_udpr\s| D (ujA# KK4E      %%'!1 /$7 &A6 U.u7H7H7K7K  % %l3 31{{$$ %))!))+66   s*%B!!D0C87C88 DDDc.V^8dQhR\PPR\R\R,R\ R\R,R\ R\ R \ R \ R \ R \R,R \ R\PP/ #)rjrrrNr;rBrrrrrRrCrSrmr rrrrrorr)rqs"rrrrrsYY {{Y YT\Y  Y $J Y  YYYYY *YY [[Yrc VP4p \WWER4wrp\V4wppV 'd\P!V 4pM!V fQh\ V \ PV4pT;_uu_4p\VWV4\VVVVVVPVPVV V V4 wppVV, Vn V 'gVPV4'g\hVuuRRR4# +'giM;iQh)aReturn the response obtained after sending a query via UDP. *q*, a ``dns.message.Message``, the query to send *where*, a ``str`` containing an IPv4 or IPv6 address, where to send the message. *timeout*, a ``float`` or ``None``, the number of seconds to wait before the query times out. If ``None``, the default, wait forever. *port*, an ``int``, the port send the message to. The default is 53. *source*, a ``str`` containing an IPv4 or IPv6 address, specifying the source address. The default is the wildcard address. *source_port*, an ``int``, the port from which to send the message. The default is 0. *ignore_unexpected*, a ``bool``. If ``True``, ignore responses from unexpected sources. *one_rr_per_rrset*, a ``bool``. If ``True``, put each RR into its own RRset. *ignore_trailing*, a ``bool``. If ``True``, ignore trailing junk at end of the received message. *raise_on_truncation*, a ``bool``. If ``True``, raise an exception if the TC bit is set. *sock*, a ``socket.socket``, or ``None``, the socket to use for the query. If ``None``, the default, a socket is created. Note that if a socket is provided, it must be a nonblocking datagram socket, and the *source* and *source_port* are ignored. *ignore_errors*, a ``bool``. If various format errors or response mismatches occur, ignore them and keep listening for a valid response. The default is ``False``. Returns a ``dns.message.Message``. TN)rrr*rrr2r3 SOCK_DGRAMrPr\rmacr rrz)rrrr;rBrrrrrRrCrSrrAr begin_timerrrrrZs&&&&&&&&&&&& rudprcsp 99;D 7 V$!Rf .g6Z 0:0F0Ft0L~~ V.. 7 qDz2(     II EE      M+q!1!1 ) ,  s9A&C2 C22 D c^V^8dQhR\PPR\R\R,R\ R\R,R\ R\ R \ R \ R \R,R \R,R \ R\\PP\ 3,/ #)rjrrrNr;rBrrrrudp_socktcp_sockrSrm) r rrrrrorrr)rqs"rrrrrsU U  {{U U T\U   U $J U  U U U U DjU DjU U  3;;   $%U rc \VVVVVVVVVRV V 4 p V R3# \PPd\ TTTTTTTTT 4 p T R3u#i;i)aReturn the response to the query, trying UDP first and falling back to TCP if UDP results in a truncated response. *q*, a ``dns.message.Message``, the query to send *where*, a ``str`` containing an IPv4 or IPv6 address, where to send the message. *timeout*, a ``float`` or ``None``, the number of seconds to wait before the query times out. If ``None``, the default, wait forever. *port*, an ``int``, the port send the message to. The default is 53. *source*, a ``str`` containing an IPv4 or IPv6 address, specifying the source address. The default is the wildcard address. *source_port*, an ``int``, the port from which to send the message. The default is 0. *ignore_unexpected*, a ``bool``. If ``True``, ignore responses from unexpected sources. *one_rr_per_rrset*, a ``bool``. If ``True``, put each RR into its own RRset. *ignore_trailing*, a ``bool``. If ``True``, ignore trailing junk at end of the received message. *udp_sock*, a ``socket.socket``, or ``None``, the socket to use for the UDP query. If ``None``, the default, a socket is created. Note that if a socket is provided, it must be a nonblocking datagram socket, and the *source* and *source_port* are ignored for the UDP query. *tcp_sock*, a ``socket.socket``, or ``None``, the connected socket to use for the TCP query. If ``None``, the default, a socket is created. Note that if a socket is provided, it must be a nonblocking connected stream socket, and *where*, *source* and *source_port* are ignored for the TCP query. *ignore_errors*, a ``bool``. If various format errors or response mismatches occur while listening for UDP, ignore them and keep listening for a valid response. The default is ``False``. Returns a (``dns.message.Message``, tcp) tuple where tcp is ``True`` if and only if TCP was used. TF)rcr rrYtcp) rrrr;rBrrrrrerfrSrs &&&&&&&&&&&& rudp_with_fallbackrisr              %  ;;            $  s6AAc6RpV^8dAVPV4pVR8Xd \R4hV\V4,pW4, pKGV# \\P 3d\ Y4Kr\Pd\Y4Ki;i)zRead the specified number of bytes from sock. Keep trying until we either get the desired amount, or we hit EOF. A Timeout exception will be raised if the operation is not completed by the expiration time. rEOF) recvEOFErrorrrBrSSLWantReadErrorrSSLWantWriteErrorr)rCcountrrrOs&&& r _net_readrq7s A !) 1 % ACxuo% SVOE FA H  !5!56 1 t 0$$ 1 t 0 1s=A &B5B BBc^p\V4pW48dW0PWR4, pK"R# \\P3d\ Y4KM\P d\Y4Koi;i)zWrite the specified data to the socket. A Timeout exception will be raised if the operation is not completed by the expiration time. N)rrGrBrrorrnr)rCrHrcurrentls&&& r _net_writeruLsp G D A + 1 yyh0 0G  !6!67 1 t 0## 1 t 0 1s2&A>A>. A>=A>c V^8dQhR\R\PP\,R\ R,R\ \\ 3,/#)rjrCrKrNrmrL)rqs"rrrrr\sL$$ $ ++   %$ $ 3: $rc\V\PP4'dVP RR7pM"\ V4P ^R4V,p\P!4p\WV4\ V4V3#)a_Send a DNS message to the specified TCP socket. *sock*, a ``socket``. *what*, a ``bytes`` or ``dns.message.Message``, the message to send. *expiration*, a ``float`` or ``None``, the absolute time at which a timeout exception should be raised. If ``None``, no timeout will occur. Returns an ``(int, float)`` tuple of bytes sent and the sent time. T)prepend_lengthbig) rr rrrrto_bytesr ru)rCrKrtcpmsgrNs&&& rsend_tcpr|\sl$$ ++,,T2 T##Au-4 ItZ( K ##rcRV^8dQhR\R\R,R\R\\P P \PP3,R,R\R,R\R\\PP\3,/#) rjrCrNrrrrrm) rrrrr rrrUrVrrrr)rqs"rrrrrzs,, , ,,#((--- . 5 ,  ,  , 3;;   %&,rc\V^V4p\P!RV4wp\WV4p\P!4p \P P VVVVVR7p W3#)aRead a DNS message from a TCP socket. *sock*, a ``socket``. *expiration*, a ``float`` or ``None``, the absolute time at which a timeout exception should be raised. If ``None``, no timeout will occur. *one_rr_per_rrset*, a ``bool``. If ``True``, put each RR into its own RRset. *keyring*, a ``dict``, the keyring to use for TSIG. *request_mac*, a ``bytes`` or ``None``, the MAC of the request (for TSIG). *ignore_trailing*, a ``bool``. If ``True``, ignore trailing junk at end of the received message. Raises if the message is malformed, if network errors occur, of if there is a timeout. Returns a ``(dns.message.Message, float)`` tuple of the received message and the received time. !Hr)rqstructunpackr r rr) rCrrrrrldatartrrZrs &&&&&& r receive_tcprzsoB dAz *E ==u %DQ Tj )DIIKM  )'  A  rcbVPV4pV^8XdR#V\P\P\P39d:\ W4VP \P\P4pV^8wd!\V\P!V44hR#)rN) connect_exerrno EINPROGRESS EWOULDBLOCKEALREADYr getsockoptr3 SOL_SOCKETSO_ERROROSErrorosstrerror)rr@rerrs&&& rr5r5s} ,,w C ax u  %"3"3U^^DD1)ll6,,foo> axc2;;s+,,rc V^8dQhR\PPR\R\R,R\ R\R,R\ R\ R \ R \R,R \PP/ #) rjrrrNr;rBrrrrCrmr^)rqs"rrrrrsCC {{C CT\C  C $J C  CCC *C [[Crc VP4p \V4wrV'd\P!V4p M1\ WWER4wrpV fQh\ V \ PV4p T ;_uu_4pV'g\VXV 4\WV 4\WW`PVPV4wppVV , Vn VPV4'g\hVuuRRR4# +'giM;iQh)aUReturn the response obtained after sending a query via TCP. *q*, a ``dns.message.Message``, the query to send *where*, a ``str`` containing an IPv4 or IPv6 address, where to send the message. *timeout*, a ``float`` or ``None``, the number of seconds to wait before the query times out. If ``None``, the default, wait forever. *port*, an ``int``, the port send the message to. The default is 53. *source*, a ``str`` containing an IPv4 or IPv6 address, specifying the source address. The default is the wildcard address. *source_port*, an ``int``, the port from which to send the message. The default is 0. *one_rr_per_rrset*, a ``bool``. If ``True``, put each RR into its own RRset. *ignore_trailing*, a ``bool``. If ``True``, ignore trailing junk at end of the received message. *sock*, a ``socket.socket``, or ``None``, the connected socket to use for the query. If ``None``, the default, a socket is created. Note that if a socket is provided, it must be a nonblocking connected stream socket, and *where*, *port*, *source* and *source_port* are ignored. Returns a ``dns.message.Message``. TN)rr*rrrr2r3r4r5r|rrrar rrz)rrrr;rBrrrrCrrbrrrArrrrZs&&&&&&&&& rrhrhsV 99;D-g6Z 0:0F0Ft0L$; d% !&~~ V// 8 q Q Z 0*%( +YY M+}}Q    s 8A3C66 D cVP4R# \Pd\Y4K7\Pd\ Y4KYi;i)TN) do_handshakerrnrrorrs&&r_tls_handshakersJ  . NN  ## . q -$$ . q - .s AA AAcV^8dQhR\\,R\R\\,R,R\P/#)rjrcheck_hostnamealpnsNrm)rrrrr)rqs"rrrrrsA 3J 9t  ^^ rc \PPV4wr4\P!W4R7p\P P VnWnVRJd\PVn VeVPV4V#)a%Make an SSL context If *verify* is ``True``, the default, then certificate verification will occur using the standard CA roots. If *verify* is ``False``, then certificate verification will be disabled. If *verify* is a string which is a valid pathname, then if the pathname is a regular file, the CA roots will be taken from the file, otherwise if the pathname is a directory roots will be taken from the directory. If *check_hostname* is ``True``, the default, then the hostname of the server must be specified when connecting and the server's certificate must authorize the hostname. If ``False``, then hostname checking is disabled. *aplns* is ``None`` or a list of TLS ALPN (Application Layer Protocol Negotiation) strings to use in negotiation. For DNS-over-TLS, the right value is `["dot"]`. )cafilecapathF) r _tls_util#convert_verify_to_cafile_and_capathrcreate_default_context TLSVersionTLSv1_2minimum_versionr CERT_NONEr.set_alpn_protocols)rrrrrrs&&& rmake_ssl_contextrsq(]]FFvNNF,,FJK#&.."8"8K!/ "%--  &&u- rctV^8dQhR\R,R\\,R\P/#)rjrNrrm)rrrr)rqs"rrrrr's5JJ4ZJ)-J^^Jrc \WRJR.4#)Ndot)r)rrs&&r_make_dot_ssl_contextr's F4$?% IIrcV^8dQhR\PPR\R\R,R\ R\R,R\ R\ R \ R \PR,R \PR,R \R,R \ \,R\PP/ #)rjrrrNr;rBrrrrCrrrrm) r rrrrrorrrr)rqs"rrrrr-sii {{i iT\i  i $J i  iii --$ i$&i4Zi 3Ji [[irc DV'd\VVVVVVVVV4 #VP4p \V4wr\WWER4wpppVfQhV f\ WRJR.4p \ V\ PV V VR7;_uu_4p\VVV4\VV4\VW4\VWVPVPV4wppVV , VnVPV4'g\ hVuuRRR4# +'giM;iQh)aReturn the response obtained after sending a query via TLS. *q*, a ``dns.message.Message``, the query to send *where*, a ``str`` containing an IPv4 or IPv6 address, where to send the message. *timeout*, a ``float`` or ``None``, the number of seconds to wait before the query times out. If ``None``, the default, wait forever. *port*, an ``int``, the port send the message to. The default is 853. *source*, a ``str`` containing an IPv4 or IPv6 address, specifying the source address. The default is the wildcard address. *source_port*, an ``int``, the port from which to send the message. The default is 0. *one_rr_per_rrset*, a ``bool``. If ``True``, put each RR into its own RRset. *ignore_trailing*, a ``bool``. If ``True``, ignore trailing junk at end of the received message. *sock*, an ``ssl.SSLSocket``, or ``None``, the socket to use for the query. If ``None``, the default, a socket is created. Note that if a socket is provided, it must be a nonblocking connected SSL stream socket, and *where*, *port*, *source*, *source_port*, and *ssl_context* are ignored. *ssl_context*, an ``ssl.SSLContext``, the context to use when establishing a TLS connection. If ``None``, the default, creates one with the default configuration. *server_hostname*, a ``str`` containing the server's hostname. The default is ``None``, which means that no hostname is known, and if an SSL context is created, hostname checking will be disabled. *verify*, a ``bool`` or ``str``. If a ``True``, then TLS certificate verification of the server is done using the default CA bundle; if ``False``, then no verification is done; if a `str` then it specifies the path to a certificate file or directory which will be used for verification. Returns a ``dns.message.Message``. TNr)rrrB)rhrr*rrrr3r4r5rr|rrrar rrz)rrrr;rBrrrrCrrrrrbrrArrrrZs&&&&&&&&&&&& rtlsr-s:z            99;D-g6Z 7 V$!Rf >>&vd/JUGT  '    K,q*%D%( zQYY M+}}Q !    $  s A8D  D cV^8dQhR\PPR\R\R,R\ R\R,R\ R\ R \ R \PPR,R \ \,R \R,R \R,R\PP/ #)rjrrrNr;rBrrrrrrrrm) r rrrrrorrr)rqs"rrrrrs^ ^  {{^ ^ T\^   ^ $J ^  ^ ^ ^ ++d2^  3J^ Dj^ 4Z^  [[^ rc \PP'g \R4hV eV fT p ^VnVP 4p V'd\ P!R4p TpM"\PPWR7p T pT ;_uu_4V'gXPWWE4p\V4wppXPV4;_uu_4pVPV R4VP\V44p RRR4\P!4pRRR4\P P#V VP$VP&VVR7p\)XX, R4VnVP+V4'g\,hV# +'giL;i +'giL;i)a+Return the response obtained after sending a query via DNS-over-QUIC. *q*, a ``dns.message.Message``, the query to send. *where*, a ``str``, the nameserver IP address. *timeout*, a ``float`` or ``None``, the number of seconds to wait before the query times out. If ``None``, the default, wait forever. *port*, a ``int``, the port to send the query to. The default is 853. *source*, a ``str`` containing an IPv4 or IPv6 address, specifying the source address. The default is the wildcard address. *source_port*, an ``int``, the port from which to send the message. The default is 0. *one_rr_per_rrset*, a ``bool``. If ``True``, put each RR into its own RRset. *ignore_trailing*, a ``bool``. If ``True``, ignore trailing junk at end of the received message. *connection*, a ``dns.quic.SyncQuicConnection``. If provided, the connection to use to send the query. *verify*, a ``bool`` or ``str``. If a ``True``, then TLS certificate verification of the server is done using the default CA bundle; if ``False``, then no verification is done; if a `str` then it specifies the path to a certificate file or directory which will be used for verification. *hostname*, a ``str`` containing the server's hostname or ``None``. The default is ``None``, which means that no hostname is known, and if an SSL context is created, hostname checking will be disabled. This value is ignored if *url* is not ``None``. *server_hostname*, a ``str`` or ``None``. This item is for backwards compatibility only, and has the same meaning as *hostname*. Returns a ``dns.message.Message``. zDNS-over-QUIC is not available.N)r.r/Trr )r rr1rr2rrrr3r4r*r5rGr7rr rrrrr8rrz)rrrr;rBrrrrrrrrr:r<r;r=rr>r?rs&&&&&&&&&&&& rrrsjn 88   566"x'7" AD 99;D5?5K5KD5Q#((**+  (00VN-W5  ' ' 0 0F KKd #>>*Z"89D1    MM)'  A% %AF ==   H1 0 s%AF0-F F0 F- (F00 G c&]tRtRtRt^t^t^tRtR#)UDPModeizHow should UDP be used in an IXFR from :py:func:`inbound_xfr()`? NEVER means "never use UDP; always use TCP" TRY_FIRST means "try to use UDP but fall back to TCP if needed" ONLY means "raise ``dns.xfr.UseTCP`` if trying UDP does not succeed" raN) rNrOrPrQrxNEVER TRY_FIRSTONLYrRrarrrrs EI Drrc$V^8dQhR\PPR\P\P ,R\P PR\R,R\R,R\R,R\/#) rj txn_managerrrTserialNrrrm) r transactionTransactionManagerr3rrrrrorr)rqs"rrrrrs{1:1:331: }}s}}$1: ;;  1: $J 1: T\ 1:  1: 1:rc #"VP^,PpV\PP8HpVP 4pVP 4p \V\P4;'dVP\P8Hp V 'd\WRV4M3\P!R\V 44V ,p \WV4\P P#WW:4;_uu_4p Rp RpRpV 'g\%V4wppVe Ve VV8dTpV 'd\'VRV4wppM3\)V^V4p\P*!RV4wp\)VVV4p\P,P/VVP0VP2RVVV '*VR7pV P5V4p VxVP6pKVP0'd6Ve2VP8'g \P:P=R4hRRR4R# +'giR#;i5i)z'Given a socket, does the zone transfer.NrFrXT)rrxfrorigintsig_ctxmultirz missing TSIG)questionrdtyper rdatatypeIXFRfrom_wire_originrrr3rr`rIrpackrrurInboundr*rDrqrrrrraprocess_messagerhad_tsigr FormError)rrrTrrrris_ixfrrris_udpr{inbounddonerrr> mexpirationrwirerrts&&&&&& r _inbound_xfrrs^^A  % %F ***G  ) ) +F ==?D 6== ) I Iaff8I8I.IF !4,T3t9-41j) f = =(,-g6 Q "&;+C( &q%= !!Q 4}}T51!!Q 4 %% !II!!z!(& A**1-DGzzH ===Q]1:::--)).9 9= > = = =s>B!I$A)I H;&H;B8H;<H;H;1 I; I  Ic V^8dQhR\R\PP\,R\PP \,R\P P\,R\R,R\R\\PP\PP3,R,R \PP\,R,R \R \R,R \R,R \R\R\R\PP\,R\/#)rjrzonerrdclassrNr;rkeyname relativizer)rBrruse_udp keyalgorithmrm)rr rrr RdataType rdataclass RdataClassrrorrUrVrr)rqs"rrrrr;sAsGsG sG ((--# sG MM # #c )sG^^ & & , sG T\ sG  sG#((--- . 5sGXX]]S 4 'sGsGdlsG $JsGsG sGsG((--#%sG  !sGrc #"!RR\PP4p\V\4'd \P P V4p\PPPV4p\PPWV4pV\PP8XdVPVPV\PP \PP"RR7p\P$P RRRV R24pVP'V^4VeVP)WgVR 7\+WWR4wppp VfQh\-V 4wppV!W4pV 'd+V\PP8wd \/R 4hV 'd\0P2M\0P4p\7VVV 4;_uu_4p\9VVV4\;VVVWV4R jxL R R R 4R #L +'giR #;i5i) a/Return a generator for the responses to a zone transfer. *where*, a ``str`` containing an IPv4 or IPv6 address, where to send the message. *zone*, a ``dns.name.Name`` or ``str``, the name of the zone to transfer. *rdtype*, an ``int`` or ``str``, the type of zone transfer. The default is ``dns.rdatatype.AXFR``. ``dns.rdatatype.IXFR`` can be used to do an incremental transfer instead. *rdclass*, an ``int`` or ``str``, the class of the zone transfer. The default is ``dns.rdataclass.IN``. *timeout*, a ``float``, the number of seconds to wait for each response message. If None, the default, wait forever. *port*, an ``int``, the port send the message to. The default is 53. *keyring*, a ``dict``, the keyring to use for TSIG. *keyname*, a ``dns.name.Name`` or ``str``, the name of the TSIG key to use. *relativize*, a ``bool``. If ``True``, all names in the zone will be relativized to the zone origin. It is essential that the relativize setting matches the one specified to ``dns.zone.from_xfr()`` if using this generator to make a zone. *lifetime*, a ``float``, the total number of seconds to spend doing the transfer. If ``None``, the default, then there is no limit on the time the transfer may take. *source*, a ``str`` containing an IPv4 or IPv6 address, specifying the source address. The default is the wildcard address. *source_port*, an ``int``, the port from which to send the message. The default is 0. *serial*, an ``int``, the SOA serial number to use as the base for an IXFR diff sequence (only meaningful if *rdtype* is ``dns.rdatatype.IXFR``). *use_udp*, a ``bool``. If ``True``, use UDP (only meaningful for IXFR). *keyalgorithm*, a ``dns.name.Name`` or ``str``, the TSIG algorithm to use. Raises on errors, and so does the generator. Returns a generator of ``dns.message.Message`` objects. cZa]tRtRtoRtRtV3RlRltRtR V3RlRlltR t Vt R #) $xfr..DummyTransactionManageric\YV'd\PPMT3VnR#r)r remptyinfo)r!rrs&&&rr-xfr..DummyTransactionManager.__init__szSXX^^vVDIrcVP#rrr!s&rorigin_information7xfr..DummyTransactionManager.origin_informations 99 rcH<V^8dQhRS[PP/#)rjrm)r rr)rqrVs"rrr1xfr..DummyTransactionManager.__annotate__s & &s~~88 &rc\hrrHrs&r get_class.xfr..DummyTransactionManager.get_classrgrc\hrrHrs&rreader+xfr..DummyTransactionManager.readerrgrcN<V^8dQhRS[RS[PP/#)rj replacementrm)rr r Transaction)rqrVs"rrrrs) I Id Is7R7R Irch!RR4p\\PPV!44#)c,a]tRtRtoRtRtRtVtR#)Exfr..DummyTransactionManager.writer..DummyTransactionicR#rra)r!r^kws&*,rnopIxfr..DummyTransactionManager.writer..DummyTransaction.nopsrcVP#r)r)r!r>s&&r __getattr__Qxfr..DummyTransactionManager.writer..DummyTransaction.__getattr__s 88OrraN)rNrOrPrQrrrRrSrhs@rDummyTransactionrs$$rr)rr rr)r!rrs&& rwriter+xfr..DummyTransactionManager.writers) $ $335E5GH HrrN)F) rNrOrPrQrrrrrrRrSrhs@rDummyTransactionManagerrs1 W  & & & I I IrrT)createINSOAz. . z 0 0 0 0N) algorithmzcannot do a UDP AXFR)r rrrrr from_textrrmaker make_queryr find_rrset authorityrrrrdataadduse_tsigrr*rr3r`r4r2r5r)rrrrrr;rrrr)rBrrrrrrrrsetsoarArr>rtm sock_typers&&&&&&&&&&&&&&& rrr;sJI#//"D"DI.$xx!!$' ]] $ $ ) )& 1F tW5A ### KKs~~00#--2C2CD ii!!$fXX/FG #q 7| < 7 V$!Rf >>$X.OQ  2B6S]]////00%,!!&2D2DI RF + +qK,Aq&:FFF , +F , + +s6GI5I= H.H,H." I,H.. H? 9 IcV^8dQhR\R\PPR\PP R,R\ R\R,R\R,R\R,R \ R \R R/ #) rjrrrTNr;rr)rBrudp_moderm) rr rrrrrorr)rqs"rrrrrsII I33I ;;   %I  I T\ I dl I $JIII Irc Vf#\PPV4wr)M\PPV4p \ WWgR4wrpV fQh\ V4wrVP ^,P\PP8XdfV\P8wdQ\V \PV4;_uu_4p\WV 4\!WW)WM4Fp K RRR4R#\V \P&V4;_uu_4p\WV 4\!WW)WM4Fp K RRR4R# \PP"dT\P$8XdhMi;iRRR4K +'giL;i +'giR#;i)aMConduct an inbound transfer and apply it via a transaction from the txn_manager. *where*, a ``str`` containing an IPv4 or IPv6 address, where to send the message. *txn_manager*, a ``dns.transaction.TransactionManager``, the txn_manager for this transfer (typically a ``dns.zone.Zone``). *query*, the query to send. If not supplied, a default query is constructed using information from the *txn_manager*. *port*, an ``int``, the port send the message to. The default is 53. *timeout*, a ``float``, the number of seconds to wait for each response message. If None, the default, wait forever. *lifetime*, a ``float``, the total number of seconds to spend doing the transfer. If ``None``, the default, then there is no limit on the time the transfer may take. *source*, a ``str`` containing an IPv4 or IPv6 address, specifying the source address. The default is the wildcard address. *source_port*, an ``int``, the port from which to send the message. The default is 0. *udp_mode*, a ``dns.query.UDPMode``, determines how UDP is used for IXFRs. The default is ``dns.query.UDPMode.NEVER``, i.e. only use TCP. Other possibilities are ``dns.query.UDPMode.TRY_FIRST``, which means "try UDP but fallback to TCP if needed", and ``dns.query.UDPMode.ONLY``, which means "try UDP and raise ``dns.xfr.UseTCP`` if it does not succeed. Raises on errors. NT)r rrextract_serial_from_queryrr*rrrrrrr2r3r`r5rUseTCPrr4)rrrTr;rr)rBrrrrArr>rrs&&&&&&&&& r inbound_xfrrsk^ }'',,[92259 7 V$!Rf >>$X.OQ ~~a3==#5#55(gmm:S V.. 7 71 QZ 0 %E7A8 7 R++V 4 4,keWQA R 5 4 77>> w||+, +8 7 7 7 5 4 4s6 F)E+!F/5F F FF F, / G cV^8dQh/^\9dO\\P\,\P \.\P3,;R&#)rjr)__conditional_annotations__rr3rnrorp)rqs"rrrrrsIF C!2!2C8&--GGr)TrrM) NrNrFFTTN) NNFFNrFFFN) N5NrFFFFNF) NrNrFFFNNF)NFNrF)NrNrFFN)TTN) NUNrFFNNNT) NrNrFFNTNN)srrxrrenumrrrrr3rr urllib.parsertypingrrrrrr dns._featuresr dns._tls_util dns.exceptiondns.inet dns.messagedns.namedns.quic dns.rdatadns.rdataclass dns.rdatatypedns.transactiondns.tsigdns.xfrr ImportError dns._no_ssl_no_sslrr _featureshave _have_httpxhttpcore._backends.syncr8rNetworkBackend_CoreNetworkBackend _backendssync SyncStreamr6r HTTPTransportrXrrtrr DNSExceptionrvrrzr|rr TransferErrorr*rrrrrrr2rrrIntEnumrrbrrr$r+rrDrIrPr\rcrirqrur|rr5rhrrrrrrrrAXFRrrrUdefault_algorithmrrrr)rs@rr9s$   == 2 mm  ' ""11((--88O4&-4&l,,, & & * Hs}}11HG#--))GCMM & & CMM & & %% $(800 )  )%XB'V -   $,,  &!"!$(*.26"" + 3 3!L ^O": z 1 1:g4TYxU p * 1 $<,^-CL.DJ iX^ B  dll  1:n-0MM,>,>/2~~/@/@ 8<*.!(+(B(BsGr)- ! IIA4s:L L)(L)