ifDh UddlmZmZmZmZmZmZddlZddlm Z m Z m Z m Z m Z eefZe edfed<eddDZGdd ZGd d ZejeejedS) )MutableMappingMappingMutableSequenceIteratorSequence ContainerN)TupleAnyDictSetList.str_typec#K|]}|VdSN).0_s O/var/www/html/env/lib/python3.11/site-packages/pip/_vendor/pyparsing/results.py rsarcReZdZUedefed<dgZdddefdZdZdZ dZ d S) _ParseResultsWithOffset ParseResultstupp1p2c||f|_dSrr)selfrrs r__init__z _ParseResultsWithOffset.__init__s.0"Xrc|j|Srrris r __getitem__z#_ParseResultsWithOffset.__getitem__sx{rc|jSrrrs r __getstate__z$_ParseResultsWithOffset.__getstate__s xrc |d|_dSNrr)rargss r __setstate__z$_ParseResultsWithOffset.__setstate__s7rN) __name__ __module__ __qualname__r int__annotations__ __slots__r r$r'r+rrrrrs ~s" ####I6>6s6666rrc.eZdZUdZdgdfZeedfed<eed<ded<e eed<e ed <e eed <e eefed <d Z Gd deZ d;dZddddefdZdZefdZdZde fdZdefdZde fdZdefdZdefdZdZdZdZde fdZdZ dd)Z)defd*Z*defd+Z+d?d-Z,defd.Z-de.fd/Z/d>d0Z0d>d1Z1d2Z2d@defd4Z3d5Z4d6Z5d7Z6d8Z7d9Z8e9dd:Z:e-Z; e/Z< e2Z=dS)Ara{Structured parse results, to provide multiple means of access to the parsed data: - as a list (``len(results)``) - by list index (``results[0], results[1]``, etc.) - by attribute (``results.`` - see :class:`ParserElement.set_results_name`) Example:: integer = Word(nums) date_str = (integer.set_results_name("year") + '/' + integer.set_results_name("month") + '/' + integer.set_results_name("day")) # equivalent form: # date_str = (integer("year") + '/' # + integer("month") + '/' # + integer("day")) # parse_string returns a ParseResults object result = date_str.parse_string("1999/12/31") def test(s, fn=repr): print(f"{s} -> {fn(eval(s))}") test("list(result)") test("result[0]") test("result['month']") test("result.day") test("'month' in result") test("'minutes' in result") test("result.dump()", str) prints:: list(result) -> ['1999', '/', '12', '/', '31'] result[0] -> '1999' result['month'] -> '12' result.day -> '31' 'month' in result -> True 'minutes' in result -> False result.dump() -> ['1999', '/', '12', '/', '31'] - day: '31' - month: '12' - year: '1999' Nr. _null_values_name_parent _all_names_modal_toklist_tokdict)r4r5r6r7r8r9ceZdZdZddZdS)ParseResults.Lista Simple wrapper class to distinguish parsed list results that should be preserved as actual Python lists, instead of being converted to :class:`ParseResults`:: LBRACK, RBRACK = map(pp.Suppress, "[]") element = pp.Forward() item = ppc.integer element_list = LBRACK + pp.DelimitedList(element) + RBRACK # add parse actions to convert from ParseResults to actual Python collection types def as_python_list(t): return pp.ParseResults.List(t.as_list()) element_list.add_parse_action(as_python_list) element <<= item | element_list element.run_tests(''' 100 [2,3,4] [[2, 1],3,4] [(2, 1),3,4] (2,3,4) ''', post_parse=lambda s, r: (r[0], type(r[0]))) prints:: 100 (100, ) [2,3,4] ([2, 3, 4], ) [[2, 1],3,4] ([[2, 1], 3, 4], ) (Used internally by :class:`Group` when `aslist=True`.) Nc|g}t|ts+t|jdt |jt|S)Nz* may only be constructed with a list, not ) isinstancelist TypeErrorr,type__new__)cls containeds rrAzParseResults.List.__new__sb  i.. |iitT]Ogii<<$$ $rr)r,r-r.__doc__rArrrr r;bs3$ $ L % % % % % %rr c t|tr|St|}d|_d|_t |_|g|_n^t|ttfr:t|tj r |ddgnt||_n|g|_t|_ |Sr)r=robjectrAr4r5setr6r8r>_generator_typer dictr9)rBtoklistnamekwargsrs rrAzParseResults.__new__s g| , , N~~c""  %% ?DMM $!8 9 9 &g|'899# ']] MM %IDM  rTc8|||_| |dkr||trt|}|s|h|_||_||jvr||t tfr|g}|rl||tr&tt|j d||<n&tt|dd||<|||_dS |d||<dS#tttf$r||ur|||<YdS||_YdSwxYwdSdSdS)Nr)r7r/strr6r4r3rr@rrr8KeyErrorr? IndexError)rrJrKasListmodalr=s rr zParseResults.__init__sr 9   z$$$ !4yy )#'&DJd///:g$'788(&iG.!z'<88%<()9::A&&T &=(44a&&T (,DJ$$$.%,QZT $i<..."$..)0DJJJJ)-DJJJJ .-   0/s C%% DDDct|ttfr |j|S||jvr|j|ddSt d|j|DS)Nrcg|] }|d S)rrrvs r z,ParseResults.__getitem__..s$D$D$DaQqT$D$D$Dr)r=r/slicer8r6r9rr"s rr$zParseResults.__getitem__sn a#u & & F=# #''}Q'+A..#$D$D4=3C$D$D$DEEErc||tr<|j|t|gz|j|<|d}nh||tt fr ||j|<|}nC|j|tt|dgz|j|<|}||tr ||_dSdSr)) rr9getr>r/rZr8rr5)rkrXr=subs r __setitem__zParseResults.__setitem__s :a0 1 1 #}00DFF;;qcADM! A$CC ZC< ( (  DM! CC#}00DFF;;'1--? DM! C :c< ( ( CKKK  rc t|ttfrt|j}|j|=t|tr|dkr||z }t||dz}t t ||}||j D]<\}}|D]4}t|D]"\}\}} t|| | |kz ||<#5=dS|j |=dS)Nr) r=r/rZlenr8r>rangeindicesreverser9items enumerater) rr#mylenremovedrK occurrencesjr]valuepositions r __delitem__zParseResults.__delitem__s1 a#u & & ! &&E a !S!! $q55JA!QUOO5!))E"2"2344G OO   %)]%8%8%:%:  !k A09+0F0F,,E8)@!8x!|#<** A   a   rreturnc||jvSrr9)rr]s r __contains__zParseResults.__contains__sDM!!rc*t|jSr)rbr8r&s r__len__zParseResults.__len__s4=!!!rc"|jp|j Sr)r8r9r&s r__bool__zParseResults.__bool__s 6777rc*t|jSriterr8r&s r__iter__zParseResults.__iter__DM"""rc<t|jdddS)NrUrxr&s r __reversed__zParseResults.__reversed__sDM$$B$'(((rc*t|jSr)ryr9r&s rkeyszParseResults.keys r{rcDfdDS)Nc3(K|] }|V dSrrrr]rs rrz&ParseResults.values..s'--AQ------rrr&s`rvalueszParseResults.values s%--------rcDfdDS)Nc3,K|]}||fVdSrrrs rrz%ParseResults.items..s+22DG 222222rrr&s`rrfzParseResults.itemss%2222diikk2222rc|j S)z Since ``keys()`` returns an iterator, this method is helpful in bypassing code that looks for the existence of any defined results names.rqr&s rhaskeyszParseResults.haskeyss}$$$rc2|sdg}|D]'\}}|dkr |d|f}td|t|dtst |dks |d|vr|d}||}||=|S|d}|S)a Removes and returns item at specified index (default= ``last``). Supports both ``list`` and ``dict`` semantics for ``pop()``. If passed no argument or an integer argument, it will use ``list`` semantics and pop tokens from the list of parsed tokens. If passed a non-integer argument (most likely a string), it will use ``dict`` semantics and pop the corresponding value from any defined results names. A second default return value argument is supported, just as in ``dict.pop()``. Example:: numlist = Word(nums)[...] print(numlist.parse_string("0 123 321")) # -> ['0', '123', '321'] def remove_first(tokens): tokens.pop(0) numlist.add_parse_action(remove_first) print(numlist.parse_string("0 123 321")) # -> ['123', '321'] label = Word(alphas) patt = label("LABEL") + Word(nums)[1, ...] print(patt.parse_string("AAB 123 321").dump()) # Use pop() in a parse action to remove named result (note that corresponding value is not # removed from list form of results) def remove_LABEL(tokens): tokens.pop("LABEL") return tokens patt.add_parse_action(remove_LABEL) print(patt.parse_string("AAB 123 321").dump()) prints:: ['AAB', '123', '321'] - LABEL: 'AAB' ['AAB', '123', '321'] rUdefaultrz)pop() got an unexpected keyword argument ra)rfr?r=r/rb)rr*rLr]rXindexret defaultvalues rpopzParseResults.popsP 4DLLNN S SDAqI~~Q| QA Q QRRR d1gs # # s4yyA~~aDGEu+CU J7L rc||vr||S|S)a^ Returns named result matching the given key, or if there is no such name, then returns the given ``default_value`` or ``None`` if no ``default_value`` is specified. Similar to ``dict.get()``. Example:: integer = Word(nums) date_str = integer("year") + '/' + integer("month") + '/' + integer("day") result = date_str.parse_string("1999/12/31") print(result.get("year")) # -> '1999' print(result.get("hour", "not specified")) # -> 'not specified' print(result.get("hour")) # -> None r)rkey default_values rr\zParseResults.getQs$ $;;9  rc|j|||jD]7\}}t |D]"\}\}}t ||||kz||<#8dS)a; Inserts new element at location index in the list of parsed tokens. Similar to ``list.insert()``. Example:: numlist = Word(nums)[...] print(numlist.parse_string("0 123 321")) # -> ['0', '123', '321'] # use a parse action to insert the parse location in the front of the parsed results def insert_locn(locn, tokens): tokens.insert(0, locn) numlist.add_parse_action(insert_locn) print(numlist.parse_string("0 123 321")) # -> [0, '0', '123', '321'] N)r8insertr9rfrgr)rr ins_stringrKrjr]rlrms rrzParseResults.inserths" UJ///!%!4!4!6!6   D+(1+(>(>  $$E8!88x%'78"" A   rc:|j|dS)a Add single element to end of ``ParseResults`` list of elements. Example:: numlist = Word(nums)[...] print(numlist.parse_string("0 123 321")) # -> ['0', '123', '321'] # use a parse action to compute the sum of the parsed integers, and add it to the end def append_sum(tokens): tokens.append(sum(map(int, tokens))) numlist.add_parse_action(append_sum) print(numlist.parse_string("0 123 321")) # -> ['0', '123', '321', 444] N)r8append)ritems rrzParseResults.appends  T"""""rct|tr||dS|j|dS)a Add sequence of elements to end of ``ParseResults`` list of elements. Example:: patt = Word(alphas)[1, ...] # use a parse action to append the reverse of the matched strings, to make a palindrome def make_palindrome(tokens): tokens.extend(reversed([t[::-1] for t in tokens])) return ''.join(tokens) patt.add_parse_action(make_palindrome) print(patt.parse_string("lskdj sdlkjf lksd")) # -> 'lskdjsdlkjflksddsklfjkldsjdksl' N)r=r__iadd__r8extend)ritemseqs rrzParseResults.extendsJ g| , , * MM' " " " " " M  ) ) ) ) )rcL|jdd=|jdS)z7 Clear all elements and results names. N)r8r9clearr&s rrzParseResults.clears, M!!!  rc~ ||S#t$r(|drt|YdSwxYw)N__rN)rP startswithAttributeError)rrKs r __getattr__zParseResults.__getattr__sU :    t$$ +$T***22 s  .<<otherc8|}||z }|Sr)copy)rrrs r__add__zParseResults.__add__siikk u  rc^|s|S|jrut|jfd|j}fd|D}|D]2\}}|||<t |dt r ||d_3|xj|jz c_|xj|jzc_|S)Nc|dkrn|zSr)r)aoffsets rz'ParseResults.__iadd__..sAEE&&q6zrc ng|]1\}}|D])}|t|d|df*2S)rra)r)rr]vlistrX addoffsets rrYz)ParseResults.__iadd__..sdAu+AaD))AaD//BBCrr)r9rbr8rfr=rr5r6)rr otheritemsotherdictitemsr]rXrrs @@rrzParseResults.__iadd__s K > (''FAAAAI--//J *N ' ( (1QadL11(#'AaDL '  5++ rcjt|tr|dkr|S||zSr))r=r/r)rrs r__radd__zParseResults.__radd__s6 eS ! ! eqjj99;; 4< rcjt|jd|jd|dS)N(, ))r@r,r8as_dictr&s r__repr__zParseResults.__repr__s4t**%LL LL4<<>>LLLLrcVddd|jDzdzS)N[rctg|]5}t|trt|nt|6Sr)r=rrOrepr)rr#s rrYz(ParseResults.__str__..sG)L99FCFFFtAwwr])joinr8r&s r__str__zParseResults.__str__sH ii!]   rrNcg}|jD]j}|r|r||t|tr||z }H|t |k|Sr)r8rr=r _asStringListrO)rsepoutrs rrzParseResults._asStringListsM & &D s  3$ -- &t))+++ 3t99%%%% rc$d|jDS)ax Returns the parse results as a nested list of matching tokens, all converted to strings. Example:: patt = Word(alphas)[1, ...] result = patt.parse_string("sldkj lsdkj sldkj") # even though the result prints in string-like form, it is actually a pyparsing ParseResults print(type(result), result) # -> ['sldkj', 'lsdkj', 'sldkj'] # Use as_list() to create an actual list result_list = result.as_list() print(type(result_list), result_list) # -> ['sldkj', 'lsdkj', 'sldkj'] cdg|]-}t|tr|n|.Sr)r=ras_list)rress rrYz(ParseResults.as_list..sC   (\:: CCKKMMM   r)r8r&s rrzParseResults.as_lists%  }    rchfdtfd|DS)a Returns the named parse results as a nested dictionary. Example:: integer = Word(nums) date_str = integer("year") + '/' + integer("month") + '/' + integer("day") result = date_str.parse_string('12/31/1999') print(type(result), repr(result)) # -> (['12', '/', '31', '/', '1999'], {'day': [('1999', 4)], 'year': [('12', 0)], 'month': [('31', 2)]}) result_dict = result.as_dict() print(type(result_dict), repr(result_dict)) # -> {'day': '1999', 'year': '12', 'month': '31'} # even though a ParseResults supports dict-like access, sometime you just need to have a dict import json print(json.dumps(result)) # -> Exception: TypeError: ... is not JSON serializable print(json.dumps(result.as_dict())) # -> {"month": "31", "day": "1999", "year": "12"} ct|tr6|r|n fd|DS|S)Nc&g|] }|Srr)rrXto_items rrYz9ParseResults.as_dict..to_item..s!;T;T;T1GGAJJ;T;T;Tr)r=rrr)objrs rrz%ParseResults.as_dict..to_itemsO#|,, (+ Ts{{}}};T;T;T;TPS;T;T;TT rc38K|]\}}||fVdSrr)rr]rXrs rrz'ParseResults.as_dict..!s3==1Q O======r)rIrf)rrs @rrzParseResults.as_dictsI*      ==== ======rct|j}|j|_|j|_|xj|jzc_|j|_|S)a Returns a new shallow copy of a :class:`ParseResults` object. `ParseResults` items contained within the source are shared with the copy. Use :class:`ParseResults.deepcopy()` to create a copy with its own separate content values. )rr8r9rr5r6r4)rrs rrzParseResults.copy#sQ4=))}))++ l  $/)J  rc|}t|jD]\}}t|tr||j|<8t|t tfrUt|trjt|x|j|<}| D]3\}}t|tr|n|||<4t|tr*t|d|D|j|<|S)zL Returns a new deep copy of a :class:`ParseResults` object. c3lK|]/}t|tr|n|V0dSr)r=rdeepcopyrWs rrz(ParseResults.deepcopy..AsN--KLJq,$?$?FAJJLLLQ------r) rrgr8r=rrrObytesrr@rfr)rrr#rdestr]rXs rrzParseResults.deepcopy1s<iikk ..  FAs#|,, #&<<>> a  C#u.. C00 *3$s))++5 a 4IIKKQQDAq.8L.I.IPajjlllqDGGQC++ #,499--PS---$$ a  rcjrjSjr<j}|j}t fd|DdSt dkrt jdkrtt t jdddvr3t t jSdS)a Returns the results name for this token expression. Useful when several different expressions might match at a particular location. Example:: integer = Word(nums) ssn_expr = Regex(r"\d\d\d-\d\d-\d\d\d\d") house_number_expr = Suppress('#') + Word(nums, alphanums) user_data = (Group(house_number_expr)("house_number") | Group(ssn_expr)("ssn") | Group(integer)("age")) user_info = user_data[1, ...] result = user_info.parse_string("22 111-22-3333 #221B") for item in result: print(item.get_name(), ':', item[0]) prints:: age : 22 ssn : 111-22-3333 house_number : 221B c3:K|]\}}|D] \}}|u |VdSrr)rr]rrXlocrs rrz(ParseResults.get_name..esS 5"'3Dyy!yyyy rNrar)rrU) r4r5r9rfnextrbryrr)rparparent_tokdict_itemss` rget_namezParseResults.get_nameFs2 : :  \ "&,C#&<#5#5#7#7 $8   IINNDM""a''T$-..00112215a8GCCT]//112233 34rrcXg}d}||r$|t|znd|r|rt d|D}|D]\}} |r||||d|zd|dt | trU| r0|| ||||dz|t| |t| td |Dr|} t| D]\} } t | trQ|d |d|z| |d|dzz| ||||dzk|d |d|z| |d|dzzt| fzd |S) aM Diagnostic method for listing out the contents of a :class:`ParseResults`. Accepts an optional ``indent`` argument so that this string can be embedded in a nested display of other data. Example:: integer = Word(nums) date_str = integer("year") + '/' + integer("month") + '/' + integer("day") result = date_str.parse_string('1999/12/31') print(result.dump()) prints:: ['1999', '/', '12', '/', '31'] - day: '31' - month: '12' - year: '1999'  rNc3>K|]\}}t||fVdSr)rO)rr]rXs rrz$ParseResults.dump..s0DDtq!A{DDDDDDrz z- z: ra)indentfull include_list_depthc3@K|]}t|tVdSr)r=r)rvvs rrz$ParseResults.dump..s,??B:b,//??????rz {}{}[{}]: {}{}{}z %s%s[%d]: %s%s%s)rrOrrsortedrfr=rdumpranyrgformatr) rrrrrrNLrfr]rXr#rs rrzParseResults.dumpvs*  <G6C ////RHHH 3 ||~~ ,DDtzz||DDDDD!,,DAq' 2JJ&B4&=BBQBBBCCC!!\22 , /JJ !+1)-1=+1A: !'!"!" JJs1vv.... 477++++??$????? &q\\EAr!"l33 188 &!% ! &!%!!4 "+1)-1=+1A: !(!"!"    1 &!% ! &!%!!4 #B     wws||rcTtj|g|Ri|dS)a$ Pretty-printer for parsed results as a list, using the `pprint `_ module. Accepts additional positional or keyword args as defined for `pprint.pprint `_ . Example:: ident = Word(alphas, alphanums) num = Word(nums) func = Forward() term = ident | num | Group('(' + func + ')') func <<= ident + Group(Optional(DelimitedList(term))) result = func.parse_string("fna a,b,(fnb c,d,200),100") result.pprint(width=40) prints:: ['fna', ['a', 'b', ['(', 'fnb', ['c', 'd', '200'], ')'], '100']] N)pprintr)rr*rLs rrzParseResults.pprints22  dllnn6t666v66666rc^|j|jd|j|jffSr)r8r9rr6r4r&s rr'zParseResults.__getstate__s4 M ""$$    rcn|\|_\|_}}|_t||_d|_dSr)r8r9r4rGr6r5)rstater inAccumNamess rr+zParseResults.__setstate__s5HME E sL$*l++ rc|j|jfSr)r8r4r&s r__getnewargs__zParseResults.__getnewargs__s}dj((rc~tt|t|zSr)dirr@r>rr&s r__dir__zParseResults.__dir__s)4::diikk!2!222rc  d}|g}|D]P\}}t|tr||||z }5|||g|||z }Q|||g|}|S)z Helper classmethod to construct a ``ParseResults`` from a ``dict``, preserving the name-value relations as results names. If an optional ``name`` argument is given, a nested ``ParseResults`` will be returned. cp t|t|t S#t$rYdSwxYw)NF)ryr=r Exception)rs r is_iterablez+ParseResults.from_dict..is_iterablesK 5S &c84444    uu s ' 55)rK)rKrR)rfr=r from_dict)rBrrKrrr]rXs rrzParseResults.from_dicts 5 5 5c"ggKKMM ? ?DAq!W%% ?s}}QQ}///ssA3Q{{1~~>>>>  #se$'''C r)NNr)rrror)ror)rN)rNTTr)>r,r-r.rDr3r r r0rOr boolr r r1r>rAr=r r$r_rnrrr/rtrvrrzr}rrrfrrr\rrrrrrrrrrrrrIrrrrrrr'r+rr classmethodrrRasDictgetNamerrrrr"s++Z&*2rNL%S/222 JJJ C LLL3i38nI0%0%0%0%0%t0%0%0%d0d$:....BFFF,6    !!!.""""""""""8$8888#(####)h))))###...333%%%%% 6 6 6 p!!!!.2###"***( ,    M#MMMM                (>>>>>:    *...`NNNNNN`7778     )))333[4F+ F+G,,rr)collections.abcrrrrrrrtypingr r r r r rOrrr@r0rHrrregisterrrrrsL ..............!5\%c )))$2''"v -v -v -v -v -v -v -v -r %%%&&&&&r