hJdZddlZddlZddlZddlZddlZddlZddlZddl ZgdZ ejdZ dZ GddeZGdd eZd Zd ZGd d eZy)a Parses replies from the control socket. **Module Overview:** :: convert - translates a ControlMessage into a particular response subclass ControlMessage - Message that's read from the control socket. |- SingleLineResponse - Simple tor response only including a single line of information. | |- from_str - provides a ControlMessage for the given string |- is_ok - response had a 250 status |- content - provides the parsed message content +- raw_content - unparsed socket data ControlLine - String subclass with methods for parsing controller responses. |- remainder - provides the unparsed content |- is_empty - checks if the remaining content is empty |- is_next_quoted - checks if the next entry is a quoted value |- is_next_mapping - checks if the next entry is a KEY=VALUE mapping |- peek_key - provides the key of the next entry |- pop - removes and returns the next entry +- pop_mapping - removes and returns the next entry as a KEY=VALUE mapping N) add_onioneventsgetinfogetconf protocolinfo authchallengeconvertControlMessage ControlLineSingleLineResponsez^(\S+)=c ddl}ddl}ddl}ddl}ddl}ddl}ddl}t|ts td|jjj|jjj|jjj |jj"j$|jj&j(|jj*j,|jj.j0t2d} ||}||_|j6di|y#t$rtd|zwxYw)aG Converts a :class:`~stem.response.ControlMessage` into a particular kind of tor response. This does an in-place conversion of the message from being a :class:`~stem.response.ControlMessage` to a subclass for its response type. Recognized types include... =================== ===== response_type Class =================== ===== **ADD_ONION** :class:`stem.response.add_onion.AddOnionResponse` **AUTHCHALLENGE** :class:`stem.response.authchallenge.AuthChallengeResponse` **EVENT** :class:`stem.response.events.Event` subclass **GETCONF** :class:`stem.response.getconf.GetConfResponse` **GETINFO** :class:`stem.response.getinfo.GetInfoResponse` **MAPADDRESS** :class:`stem.response.mapaddress.MapAddressResponse` **PROTOCOLINFO** :class:`stem.response.protocolinfo.ProtocolInfoResponse` **SINGLELINE** :class:`stem.response.SingleLineResponse` =================== ===== :param str response_type: type of tor response to convert to :param stem.response.ControlMessage message: message to be converted :param kwargs: optional keyword arguments to be passed to the parser method :raises: * :class:`stem.ProtocolError` the message isn't a proper response of that type * :class:`stem.InvalidArguments` the arguments given as input are invalid, this is can only be raised if the response_type is: **GETINFO**, **GETCONF** * :class:`stem.InvalidRequest` the arguments given as input are invalid, this is can only be raised if the response_type is: **MAPADDRESS** * :class:`stem.OperationFailed` if the action the event represents failed, this is can only be raised if the response_type is: **MAPADDRESS** * **TypeError** if argument isn't a :class:`~stem.response.ControlMessage` or response_type isn't supported rNz;Only able to convert stem.response.ControlMessage instances) ADD_ONION AUTHCHALLENGEEVENTGETCONFGETINFO MAPADDRESS PROTOCOLINFO SINGLELINEzUnsupported response type: %s)stem.response.add_onionstem.response.authchallengestem.response.eventsstem.response.getinfostem.response.getconfstem.response.mapaddressstem.response.protocolinfo isinstancer TypeErrorresponserAddOnionResponserAuthChallengeResponserEventrGetConfResponserGetInfoResponse mapaddressMapAddressResponserProtocolInfoResponser __class___parse_message) response_typemessagekwargsstemresponse_typesresponse_classs `/var/www/betterdocs.net/sherlock_api/venv/lib/python3.12/site-packages/stem/response/__init__.pyr r 9sN!$!# G^ , Q RR((99]]00FF ]] ! ! ' '}}$$44}}$$44--**==MM..CC$ .E#M2N%''"6" E 3mC DDEs D99EcjeZdZdZeddZddZdZddZddZ dZ d Z d Z d Z d Zd ZdZy)r a Message from the control socket. This is iterable and can be stringified for individual message components stripped of protocol formatting. Messages are never empty. :var int arrived_at: unix timestamp for when the message arrived .. versionchanged:: 1.7.0 Implemented equality and hashing. .. versionchanged:: 1.8.0 Moved **arrived_at** from the Event class up to this base ControlMessage. Nc X|r-|jds|dz }tjdd|}tjj t jtjjj||jdd}| t||fi||S)a Provides a ControlMessage for the given content. .. versionadded:: 1.1.0 .. versionchanged:: 1.6.0 Added the normalize argument. :param str content: message to construct the message from :param str msg_type: type of tor reply to parse the content as :param bool normalize: ensures expected carriage return and ending newline are present :param kwargs: optional keyword arguments to be passed to the parser method :returns: stem.response.ControlMessage instance  z([ ]?) z arrived_atN)r5) endswithresubr.socket recv_messageioBytesIOutil str_tools _to_bytespopr )contentmsg_type normalizer-msgs r1from_strzControlMessage.from_strs&   d #4{FG4g ++ " "2::dii.A.A.K.KG.T#Udjdndno{~BeC " DC h&v& Jc|s td|r|nttj|_||_||_d|_tjj|d|_ y)NzControlMessages can't be empty _raw_content) ValueErrorinttimer5_parsed_contentrH_strr.r= _hash_attr_hash)selfparsed_content raw_contentr5s r1__init__zControlMessage.__init__sV  7 88$.jC 4DDO)D#DDI%%dN;DJrFc<|jD] \}}}|dk(s yy)z Checks if any of our lines have a 250 response. :returns: **True** if any lines have a 250 response code, **False** otherwise 250TF)rL)rPcode_s r1is_okzControlMessage.is_oks.** a  rFc tjjrN|sL|jDcgc]2\}}}||tjj j |f4c}}}St|jScc}}}w)a Provides the parsed message content. These are entries of the form... :: (status_code, divider, content) **status_code** Three character code for the type of response (defined in section 4 of the control-spec). **divider** Single character to indicate if this is mid-reply, data, or an end to the message (defined in section 2.3 of the control-spec). **content** The following content is the actual payload of the line. For data entries the content is the full multi-line payload with newline linebreaks and leading periods unescaped. The **status_code** and **divider** are both strings (**bytes** in python 2.x and **unicode** in python 3.x). The **content** however is **bytes** if **get_bytes** is **True**. .. versionchanged:: 1.1.0 Added the get_bytes argument. :param bool get_bytes: provides **bytes** for the **content** rather than a **str** :returns: **list** of (str, str, str) tuples for the components of this message )r.prereq is_python_3rLr=r> _to_unicodelist)rP get_bytesrVdivrAs r1rAzControlMessage.contentslD {{ `d`t`t u uH\sT[tS$))--99'BC uu $&& ''vs7Bctjjr5|s3tjjj |j S|j S)a, Provides the unparsed content read from the control socket. .. versionchanged:: 1.1.0 Added the get_bytes argument. :param bool get_bytes: if **True** then this provides **bytes** rather than a **str** :returns: **str** of the socket data used to generate this message )r.rZr[r=r>r\rH)rPr^s r1rRzControlMessage.raw_contentsC {{  YY , ,T->-> ??   rFcp|jdjt||_|jS)z^ Content of the message, stripped of status code and divider protocol formatting. r4)rMjoinr]rPs r1__str__zControlMessage.__str__s,  yy))DJ'di 99rFc#K|jD]Z\}}}tjjr)tjj j |}t|\yw)a Provides :class:`~stem.response.ControlLine` instances for the content of the message. This is stripped of status codes and dividers, for instance... :: 250+info/names= desc/id/* -- Router descriptors by ID. desc/name/* -- Router descriptors by nickname. . 250 OK Would provide two entries... :: 1st - "info/names= desc/id/* -- Router descriptors by ID. desc/name/* -- Router descriptors by nickname." 2nd - "OK" NrLr.rZr[r=r>r\r )rPrWrAs r1__iter__zControlMessage.__iter__ sX.--! 1g  "))%%11':   !sA+A-c,t|jS)z* :returns: number of ControlLines )lenrLrcs r1__len__zControlMessage.__len__&s t## $$rFc|j|d}tjjr)tjj j |}t|S)zD :returns: :class:`~stem.response.ControlLine` at the index rf)rPindexrAs r1 __getitem__zControlMessage.__getitem__-sN ""5)!,G {{  ##//8g w rFc|jSN)rOrcs r1__hash__zControlMessage.__hash__9s ::rFcTt|trt|t|k(SdSNF)rr hashrPothers r1__eq__zControlMessage.__eq__<s#(25.(I4:e $TuTrFc||k( Srprrus r1__ne__zControlMessage.__ne__?su} rFrsrpF)__name__ __module__ __qualname____doc__ staticmethodrErSrXrArRrdrgrjrnrqrwryrrFr1r r sT > < %(N" !:%  UrFr cNeZdZdZdZdZdZdZd dZd dZ d Z dd Z dd Z y)r aR String subclass that represents a line of controller output. This behaves as a normal string with additional methods for parsing and popping entries from a space delimited series of elements like a stack. None of these additional methods effect ourselves as a string (which is still immutable). All methods are thread safe. c.tj||Srp)str__new__rPvalues r1rzControlLine.__new__Ms ;;tU ##rFcD||_tj|_yrp) _remainder threadingRLock_remainder_lockrs r1rSzControlLine.__init__PsDO$??,DrFc|jS)z Provides our unparsed content. This is an empty string after we've popped all entries. :returns: **str** of the unparsed content rrcs r1 remainderzControlLine.remainderTs ??rFc |jdk(S)z Checks if we have further content to pop or not. :returns: **True** if we have additional content, **False** otherwise rrcs r1is_emptyzControlLine.is_empty^s ??b  rFcLt|j|\}}|dk(xr|dk7S)z Checks if our next entry is a quoted value or not. :param bool escaped: unescapes the string :returns: **True** if the next entry can be parsed as a quoted value, **False** otherwise r)_get_quote_indicesr)rPescaped start_quote end_quotes r1is_next_quotedzControlLine.is_next_quotedgs-0IK !  / R/rFNc|j}tj|}|rE|r||jdk7ry|r)t ||\}}||j k(xr|dk7Syy)az Checks if our next entry is a KEY=VALUE mapping or not. :param str key: checks that the key matches this value, skipping the check if **None** :param bool quoted: checks that the mapping is to a quoted value :param bool escaped: unescapes the string :returns: **True** if the next entry can be parsed as a key=value mapping, **False** otherwise rFrT)rKEY_ARGmatchgroupsrend)rPkeyquotedrr key_matchrrs r1is_next_mappingzControlLine.is_next_mappingssmI i(I  ((*1-- !3Iw!G Yimmo-A)r/A rFcp|j}tj|}|r|jdSy)z Provides the key of the next entry, providing **None** if it isn't a key/value mapping. :returns: **str** with the next entry's key rN)rrrr)rPrrs r1peek_keyzControlLine.peek_keys5I i(I     "" rFc|j5t|j||d\}}||_|cdddS#1swYyxYw)aq Parses the next space separated entry, removing it and the space from our remaining content. Examples... :: >>> line = ControlLine("\"We're all mad here.\" says the grinning cat.") >>> print line.pop(True) "We're all mad here." >>> print line.pop() "says" >>> print line.remainder() "the grinning cat." >>> line = ControlLine("\"this has a \\\" and \\\\ in it\" foo=bar more_data") >>> print line.pop(True, True) "this has a \" and \\ in it" :param bool quoted: parses the next entry as a quoted value, removing the quotes :param bool escaped: unescapes the string :returns: **str** of the next space separated entry :raises: * **ValueError** if quoted is True without the value being quoted * **IndexError** if we don't have any remaining content left to parse FN)r _parse_entryr)rPrr next_entryrs r1r@zControlLine.popsE:   *4??FGUSj)!do s $;Ac|j5|jr tdtj |j }|st d|j z|jd}|j |jd}t||||\}}||_||fcdddS#1swYyxYw)a Parses the next space separated entry as a KEY=VALUE mapping, removing it and the space from our remaining content. .. versionchanged:: 1.6.0 Added the get_bytes argument. :param bool quoted: parses the value as being quoted, removing the quotes :param bool escaped: unescapes the string :param bool get_bytes: provides **bytes** for the **value** rather than a **str** :returns: **tuple** of the form (key, value) :raises: **ValueError** if this isn't a KEY=VALUE mapping or if quoted is **True** without the value being quoted :raises: **IndexError** if there's nothing to parse from the line no remaining content to parsez*the next entry isn't a KEY=VALUE mapping: rN) rr IndexErrorrrrrIrrr)rPrrr^rrrrs r1 pop_mappingzControlLine.pop_mappings&    899--0i EWXX    q !c//)--/"23i*9fgyQj)!do: s B B77Crz)NFF)FF)FFF) r{r|r}r~rrSrrrrrr@rrrFr1r r Cs5$-! 08 D"rFr c|dk(r tdd|}}|r5t||\}}|dk7s|dk(rtd|z|d|||dzd}}nd|vr|jdd\}}n|d}}|rat j |d}t jjr+|s)t jjj|}|r)t jjj|}||jfS) a Parses the next entry from the given space separated content. :param str line: content to be parsed :param bool quoted: parses the next entry as a quoted value, removing the quotes :param bool escaped: unescapes the string :returns: **tuple** of the form (entry, remainder) :raises: * **ValueError** if quoted is True without the next value being quoted * **IndexError** if there's nothing to parse from the line rrrrz%the next entry isn't a quoted value: N )rrrIsplitcodecs escape_decoder.rZr[r=r>r\r?lstrip)linerrr^rrrrs r1rrs  RZ 4 55di* / 7CKa9? >E FF%a 2Ii!mn4M J i'ooc15j)')j %%j1!4J {{ 99&&22:>j$$..z:J i&&( ))rFcgd}}tdD]`}|jd|dz}|r6|dk\r1||dz dk(r&|jd|dz}|dk\r ||dz dk(r&|j|bt|S)z Provides the indices of the next two quotes in the given content. :param str line: content to be parsed :param bool escaped: unescapes the string :returns: **tuple** of two ints, indices being -1 if a quote doesn't exist rrl"r\)rangefindappendtuple)rrindices quote_indexrWs r1rr"sR;' 8  a))Cq1K 1 kAo!6$!>ii[1_5  1 kAo!6$!> NN;   wrFceZdZdZddZdZy)r a Reply to a request that performs an action rather than querying data. These requests only contain a single line, which is 'OK' if successful, and a description of the problem if not. :var str code: status code for our line :var str message: content of the line cd|r|jddk(S|jdddk(S)a} Checks if the response code is "250". If strict is **True** then this checks if the response is "250 OK" :param bool strict: checks for a "250 OK" message if **True** :returns: * If strict is **False**: **True** if the response code is "250", **False** otherwise * If strict is **True**: **True** if the response is "250 OK", **False** otherwise r)rUrOKrU)rA)rPstricts r1rXzSingleLineResponse.is_okFs9 \\^A "4 44 <<>! Q 5 ((rFc|j}t|dkDrtjdt|dk(rtjd|d\|_}|_y)NrzReceived multi-line responserzReceived empty response)rArir. ProtocolErrorrVr,)rPrArWs r1r*z!SingleLineResponse._parse_messageWs]llnG 7|a   = >> W    8 99#*1: diDLrFNrz)r{r|r}r~rXr*rrFr1r r <s)".rFr )r~rr;r7rKr stem.socketr. stem.utilstem.util.str_tools__all__compilerr objectr rr rrr rrFr1rsy6   "**Z C#LAVAH`#`F9*x4#.#.rF