mxikUddlmZddlZddlmZmZmZmZmZddl Z ddl m Z ddl m Z mZmZeefZded<ed d DZedZd ed <Gd dZGddZej4eej4ey)) annotationsN)MutableMappingMappingMutableSequenceIteratorIterable)Any)deprecate_argument _is_iterable_flattenztuple[type, ...]str_typec# K|]}|ywN).0_s H/home/htdocs/ttos/venv/lib/python3.12/site-packages/pyparsing/results.py rsas rslice NULL_SLICEc8eZdZUded<dgZddZdZdZdZy) _ParseResultsWithOffsetztuple[ParseResults, int]tupc||f|_yrr)selfp1p2s r__init__z _ParseResultsWithOffset.__init__s .0"Xc |j|Srrris r __getitem__z#_ParseResultsWithOffset.__getitem__sxx{r!c|jSrrrs r __getstate__z$_ParseResultsWithOffset.__getstate__"s xxr!c|d|_yNrr)rargss r __setstate__z$_ParseResultsWithOffset.__setstate__%s 7r!N)r ParseResultsrintreturnNone) __name__ __module__ __qualname____annotations__ __slots__r r%r(r,rr!rrrs# !!I6r!rceZdZUdZdgdfZded<ded<ded<d ed <d ed <d ed<ded<dZGddeZd>dZ dddde f d?dZ dZ e fdZ dZd@dZdAdZd@dZdBdZdBdZdZd Zd!Zd@d"Zd#ZdCd$Zd%Zd&Zd'Zd(Zd)ZdDd*ZdDd+Z dEd,Z!dFd-Z"dFd.Z#dGd/Z$d0d1dHd2Z%dId3Z&dEd4Z'dEd5Z(dJd6Z)dKdFd7Z*d8Z+d9Z,d:Z-d;Z.d<Z/e0dCdEd=Z1e%Z2 e&Z3 e)Z4y)Lr-aStructured 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: .. testcode:: 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: .. testoutput:: 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' Nrztuple[Any, ...] _null_valuesstr_name_parentzset[str] _all_namesbool_modalz list[Any]_toklistzdict[str, Any]_tokdict)r9r:r;r=r>r?ceZdZdZddZy)ParseResults.Lista9 Simple wrapper class to distinguish parsed list results that should be preserved as actual Python lists, instead of being converted to :class:`ParseResults`: .. testcode:: import pyparsing as pp ppc = pp.common LBRACK, RBRACK, LPAR, RPAR = pp.Suppress.using_each("[]()") element = pp.Forward() item = ppc.integer item_list = pp.DelimitedList(element) element_list = LBRACK + item_list + RBRACK | LPAR + item_list + RPAR element <<= item | element_list # add parse action to convert from ParseResults # to actual Python collection types @element_list.add_parse_action def as_python_list(t): return pp.ParseResults.List(t.as_list()) element.run_tests(''' 100 [2,3,4] [[2, 1],3,4] [(2, 1),3,4] (2,3,4) ([2, 3], 4) ''', post_parse=lambda s, r: (r[0], type(r[0])) ) prints: .. testoutput:: :options: +NORMALIZE_WHITESPACE 100 (100, ) [2,3,4] ([2, 3, 4], ) [[2, 1],3,4] ([[2, 1], 3, 4], ) [(2, 1),3,4] ([[2, 1], 3, 4], ) (2,3,4) ([2, 3, 4], ) ([2, 3], 4) ([[2, 3], 4], ) (Used internally by :class:`Group` when `aslist=True`.) Nc|g}t|ts-t|jdt |jtj |S)Nz* may only be constructed with a list, not ) isinstancelist TypeErrorr1type__new__)cls containeds rrGzParseResults.List.__new__sT  i.||n$NtT]OgOgNhi<<$ $r!r)r1r2r3__doc__rGrr!rListrAos 9 v %r!rKc ^t|tr|Stj|}d|_d|_t |_|g|_nOt|ttfr1t|tjr|ddgn t||_n|g|_t|_ |Sr)rCr-objectrGr9r:setr;r>rD_generator_typerKdictr?)rHtoklistnamekwargsrs rrGzParseResults.__new__s g| ,N~~c"  % ?DM $!8 9g|'8'89 '] M %IDM  r!Tc t|ddd}|xr|}|||_||dk(ry||tr t|}|s|h|_||_||j vry||ttfr|g}|rV||tr#tt|jd||<ntt|dd||<|||_y |d||<y#tttf$r||ur|||<Yy||_YywxYw)NasListTaslist)new_namer)r r=r.r8r;r9r7rrFr-rr>KeyErrorrE IndexError)rrQrRrVmodalrCrSrUs rr zParseResults.__init__s$FHdXN"F  <42:  dC t9D#fDO d'' '  g$/ 0iG '<04\'BRBR5SUVWT 4\'!*5MqQT #DJ   " DJ)Z0 "d"$T !  "sCD6D?Dct|ttfr|j|S||jvr|j |ddSt |j |Dcgc]}|d c}Scc}w)Nr)rCr.rr>r;r?r-)rr$vs rr%zParseResults.__getitem__sj a#u &==# # DOO #==#B'* *4==+;r-r:)rkr^rCsubs r __setitem__zParseResults.__setitem__s a0 1#}}00DF;qcADMM! A$C C< ( DMM! C#}}00B7'1-; DMM! C c< (CK )r!c ,t|ttfs|j|=y|tk(r|j j yt|j }|j |=t|tr|dkr||z }t||dz}tt|j|}|j|jjD]4}|D]-}t|D]\}\}}t||||kDz ||</6y)Nrr )rCr.rr?rr>clearlenrDrangeindicesreversevalues enumerater) rr$mylenremoved occurrencesjravaluepositions r __delitem__zParseResults.__delitem__s!c5\* a  ? MM   ! DMM" MM!  a 1uU aQAuaii./0==//1 K ,5k,B(A(x%<x8a<8&KN  r!c||jvSrr?)rras r __contains__zParseResults.__contains__2sDMM!!r!c,t|jSr)rfr>r's r__len__zParseResults.__len__5s4==!!r!c:|jxs |j Sr)r>r?r's r__bool__zParseResults.__bool__8s 6777r!c,t|jSriterr>r's r__iter__zParseResults.__iter__;DMM""r!c8t|jdddS)Nr]r{r's r __reversed__zParseResults.__reversed__>sDMM$B$'((r!c,t|jSr)r|r?r's rkeyszParseResults.keysAr~r!c6fdjDS)Nc3(K|] }| ywrrrrars rrz&ParseResults.values..Es-AQ-srr's`rrjzParseResults.valuesDs---r!c6fdjDS)Nc3,K|] }||f ywrrrs rrz%ParseResults.items..Hs2DG 2srr's`ritemszParseResults.itemsGs2diik22r!c|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.rtr's rhaskeyszParseResults.haskeysJs}}$$$r!c|sdg}|jD]\}}|dk(r|d|f}td|t|dtst |dk(s|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: .. doctest:: >>> 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) [W:(0-9)]... >>> 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()) ['AAB', '123', '321'] - LABEL: 'AAB' >>> # 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) {W:(A-Za-z) {W:(0-9)}...} >>> print(patt.parse_string("AAB 123 321").dump()) ['AAB', '123', '321'] r]defaultrz)pop() got an unexpected keyword argument r )rrErCr.rf)rr+rSrar^indexret defaultvalues rpopzParseResults.popPs\4DLLN SDAqI~Q|"KA5 QRR  S d1gs #s4yA~aDGEu+CU J7L r!c||vr||S|S)as 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: .. doctest:: >>> integer = Word(nums) >>> date_str = integer("year") + '/' + integer("month") + '/' + integer("day") >>> result = date_str.parse_string("1999/12/31") >>> result.get("year") '1999' >>> result.get("hour", "not specified") 'not specified' >>> result.get("hour") r)rkey default_values rr`zParseResults.gets. $;9  r!c|jj|||jjD]-}t |D]\}\}}t ||||kDz||</y)a Inserts new element at location index in the list of parsed tokens. Similar to ``list.insert()``. Example: .. doctest:: >>> 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) [W:(0-9)]... >>> print(numlist.parse_string("0 123 321")) [0, '0', '123', '321'] N)r>insertr?rjrkr)rr ins_stringrnrarprqs rrzParseResults.insertso2 UJ/==//1 K(1+(> $$E8!88x%'78" A  r!c:|jj|y)a Add single element to end of ``ParseResults`` list of elements. Example: .. doctest:: >>> 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) [W:(0-9)]... >>> print(numlist.parse_string("0 123 321")) ['0', '123', '321', 444] N)r>append)ritems rrzParseResults.appends, T"r!c~t|tr|j|y|jj |y)as Add sequence of elements to end of :class:`ParseResults` list of elements. Example: .. testcode:: 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")) prints: .. testoutput:: ['lskdjsdlkjflksddsklfjkldsjdksl'] N)rCr-__iadd__r>extend)ritemseqs rrzParseResults.extends,2 g| , MM' " MM  )r!cV|jdd=|jjy)z7 Clear all elements and results names. N)r>r?rer's rrezParseResults.clears  MM!  r!cd ||S#t$r|jdr t|YywxYw)N__rX)rY startswithAttributeError)rrRs r __getattr__zParseResults.__getattr__s: :  t$$T** s %//c0|j}||z }|Sr)copy)rotherrs r__add__zParseResults.__add__siik u  r!c|s|S|jrt|jfd}|jj}|Dcgc]&\}}|D]}|t |d||df(}}}}|D](\}}|||<t |dt s||d_*|xj|jz c_|xj|jzc_|Scc}}}w)Nc|dkrS|zSr*r)aoffsets rz'ParseResults.__iadd__..sAE&q6zr!rr ) r?rfr>rrrCr-r:r;) rr addoffset otheritemsravlistr^otherdictitemsrs @rrzParseResults.__iadd__sK >>'FAI--/J!+Au+AaD)AaD/BCCN ' (1QadL1#'AaDL ( '  5+++ s +C(cVt|tr|dk(r|jS||zSr*)rCr.r)rrs r__radd__zParseResults.__radd__+s* eS !eqj99; 4< r!cnt|jd|jd|jdS)N(, ))rFr1r>as_dictr's r__repr__zParseResults.__repr__3s2t*%%&a '84<<>:J!LLr!c ddj|jDcgc](}t|tr t |n t |*c}zdzScc}w)N[r])joinr>rCr-r8reprr#s r__str__zParseResults.__str__6s\ ii"]])L9CFtAwF   s-A cg}|jD]U}|r|r|j|t|tr||j z }<|jt |W|Sr)r>rrCr- _asStringListr8)rsepoutrs rrzParseResults._asStringListBs^MM &Ds 3$ -t))++ 3t9%  & r!F)flattenc|r gt|S|jDcgc]$}t|tr|j n|&c}Scc}w)a Returns the parse results as a nested list of matching tokens, all converted to strings. If ``flatten`` is True, all the nesting levels in the returned list are collapsed. Example: .. doctest:: >>> 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 >>> type(result) >>> print(result) ['sldkj', 'lsdkj', 'sldkj'] .. doctest:: >>> # Use as_list() to create an actual list >>> result_list = result.as_list() >>> type(result_list) >>> print(result_list) ['sldkj', 'lsdkj', 'sldkj'] .. versionchanged:: 3.2.0 New ``flatten`` argument. )r r>rCr-as_list)rrress rrzParseResults.as_listMsP> $Xd^$ $ ==",C!> CG s)A cRfdtfd|jDS)ac Returns the named parse results as a nested dictionary. Example: .. doctest:: >>> integer = pp.Word(pp.nums) >>> date_str = integer("year") + '/' + integer("month") + '/' + integer("day") >>> result = date_str.parse_string('1999/12/31') >>> type(result) >>> result ParseResults(['1999', '/', '12', '/', '31'], {'year': '1999', 'month': '12', 'day': '31'}) >>> result_dict = result.as_dict() >>> type(result_dict) >>> result_dict {'year': '1999', 'month': '12', 'day': '31'} >>> # even though a ParseResults supports dict-like access, >>> # sometime you just need to have a dict >>> import json >>> print(json.dumps(result)) Traceback (most recent call last): TypeError: Object of type ParseResults is not JSON serializable >>> print(json.dumps(result.as_dict())) {"year": "1999", "month": "12", "day": "31"} ct|tr6|jr|jS|Dcgc] }| c}S|Scc}wr)rCr-rr)objr^to_items rrz%ParseResults.as_dict..to_itemsA#|,(+ s{{}TPS;T1GAJ;TT .s=1Q O=s)rPr)rrs @rrzParseResults.as_dictts"B  = ===r!ct|j}|jj|_|j|_|xj |j zc_|j |_|S)a Returns a new shallow copy of a :class:`ParseResults` object. :class:`ParseResults` items contained within the source are shared with the copy. Use :meth:`ParseResults.deepcopy` to create a copy with its own separate content values. )r-r>r?rr:r;r9)rrs rrzParseResults.copysS4==)}}))+ ll  $//)JJ  r!c0|j}t|jD]\}}t|tr|j |j|<4t|t tfrKt|tr]t|x|j|<}|jD]*\}}t|tr|j n|||<,t|tst|d|D|j|<|S)zm Returns a new deep copy of a :class:`ParseResults` object. .. versionadded:: 3.1.0 c3`K|]&}t|tr|jn|(ywr)rCr-deepcopy)rr^s rrz(ParseResults.deepcopy..s),KLJq,$?AJJLQF,s,.) rrkr>rCr-rr8bytesrrFrr)rrr$rdestrar^s rrzParseResults.deepcopys iik . FAs#|,"%,,. QC#u.C0)2c4 Q$IIKQDAq.8L.IajjlqDGQC*"+$s),PS,# Q  r!cjr jSjr;j}|jj}t fd|DdSt dk(rxt jdk(r`t t jjdddvr,t t jjSy)aG Returns the results name for this token expression. Useful when several different expressions might match at a particular location. Example: .. testcode:: 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: .. testoutput:: age : 22 ssn : 111-22-3333 house_number : 221B c3DK|]\}}|D] \}}|ur|ywrr)rrarr^locrs rrz(ParseResults.get_name..s= 5"'3Dys Nr r)rr]) r9r:r?rnextrfr|rjr)rparparent_tokdict_itemss` rget_namezParseResults.get_names@ ::::  \\ $ C#&<<#5#5#7 $8   INDMM"a'T$--..01215a8GCT]]//123 3r!cg}d}|j|r|t|jznd|sdj|S|j rt d|j D}|D]\}} |r|j||j|d|zd|dt| ts|jt| `| s|jt| }|j| j||||dztd |Dsdj|S|} d} d} t| D]\} } t| trE| j||||dz}|j| || |zd | d | || |dzz| [|j| || |zd | d | || |dzz| dj|S) as 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: .. testcode:: integer = Word(nums) date_str = integer("year") + '/' + integer("month") + '/' + integer("day") result = date_str.parse_string('1999/12/31') print(result.dump()) prints: .. testoutput:: ['1999', '/', '12', '/', '31'] - day: '31' - month: '12' - year: '1999'  rXc3<K|]\}}t||fywr)r8)rrar^s rrz$ParseResults.dump..s@41aCFA;@z z- z: r )indentfull include_list_depthc3<K|]}t|tywr)rCr-)rvvs rrz$ParseResults.dump../s?B:b,/?rrz]:) rr8rrrsortedrrCr-rdumpanyrk)rrrrrrNLrrar^incrnlr$rvv_dumps rrzParseResults.dumps2  <6C //RH773<  <<>@4::<@@E 1JJrN fXtf}%6b2>?!!\2JJtAw'JJs1v& FF%!%1%z  (?$??773<   q\ EAr"l+''!!-!A: "  d6(4&=/1#RtF8DFUVJDWCXY`Xab d6(4&=/1#RtF8DFUVJDWCXY[X\]  wws|r!cRtj|jg|i|y)aF Pretty-printer for parsed results as a list, using the `pprint `_ module. Accepts additional positional or keyword args as defined for `pprint.pprint `_ . Example: .. testcode:: 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: .. testoutput:: ['fna', ['a', 'b', ['(', 'fnb', ['c', 'd', '200'], ')'], '100']] N)pprintr)rr+rSs rrzParseResults.pprintGs :  dlln6t6v6r!c~|j|jjd|j|jffSr)r>r?rr;r9r's rr(zParseResults.__getstate__gs9 MM ""$    r!cd|\|_\|_}}|_t||_d|_yr)r>r?r9rNr;r:)rstater inAccumNamess rr,zParseResults.__setstate__rs.HME E sL$*l+ r!c2|j|jfSr)r>r9r's r__getnewargs__zParseResults.__getnewargs__ws}}djj((r!c^tt|t|jzSr)dirrFrDrr's r__dir__zParseResults.__dir__zs 4:diik!222r!c |g}|jD]D\}}t|tr||j||z }-|||g|t |z }F| ||g|}|S)z Helper classmethod to construct a :class:`ParseResults` from a ``dict``, preserving the name-value relations as results names. If an optional ``name`` argument is given, a nested :class:`ParseResults` will be returned. )rR)rRrV)rrCr from_dictr )rHrrRrrar^s rrzParseResults.from_dict}s}"gKKM @DAq!W%s}}QQ}//sA3Q|A??  @  se$'C r!)NN)r/r0)r/r<)r/r.)r/rr)rr-r/r-)r/r-)r/r8)rX)rr<r/rD)r/rP)r/z str | None)rXTTr)5r1r2r3rJr7r4r5rDrKrGrCr r%rcrrrurwryr}rrrjrrrr`rrrrerrrrrrrrrrrrrrr(r,rr classmethodrrUasDictgetNamerr!rr-r-)sw1f&*2rNL/2 J  LIE%tE%N2  ." ."`>,6 :""8#)#.3% < |!8B#0*< , M   */%N'>R .5nL\7@   )3 FFGr!r-) __future__r collectionscollections.abcrrrrrrtypingr utilr r r r8rrr4rFrOrrrr-registerrr!rrs#<<"5\ )2'$K E"s s l %&r!