Ë äØjjDhãóô—UddlmZmZmZmZmZmZddlZddlm Z m Z mZmZm Z eefZe edfed<ed„dD««ZGd„d «ZGd „d«Zej,e«ej,e«y)é)ÚMutableMappingÚMappingÚMutableSequenceÚIteratorÚSequenceÚ ContainerN)ÚTupleÚAnyÚDictÚSetÚList.Ústr_typec#ó K—|]}|–—Œyw©N©)Ú.0Ú_s ú_/opt/eval-harness/bench_task/venv/lib/python3.12/site-packages/pip/_vendor/pyparsing/results.pyú rsèø€’˜aœ‘ùs‚rcóJ—eZdZUedefed<dgZdddefd„Zd„Zd„Z d„Z y ) Ú_ParseResultsWithOffsetÚParseResultsÚtupÚp1Úp2có—||f|_yr©r)Úselfrrs rÚ__init__z _ParseResultsWithOffset.__init__s €Ø.0°"¨Xˆócó —|j|Srr©rÚis rÚ__getitem__z#_ParseResultsWithOffset.__getitem__s€Øx‰x˜‰{Ðr có—|jSrr©rs rÚ__getstate__z$_ParseResultsWithOffset.__getstate__s€Øx‰xˆr có—|d|_y©Nrr)rÚargss rÚ__setstate__z$_ParseResultsWithOffset.__setstate__s €Ø˜‘7ˆr N)Ú__name__Ú __module__Ú__qualname__r ÚintÚ__annotations__Ú __slots__rr$r'r+rr rrrs;…Ø ˆ~˜sÐ"Ñ #Ó#Ø€Ið6˜>ð6¨só6òòór rcó—eZdZUdZdgdfZeedfed<eed<ded<e eed<e ed <eeed <eeefed<dZ Gd „de«Zd8d„Zddddefd„Zd„Zefd„Zd„Zde fd„Zdefd„Zde fd„Zdefd„Zdefd„Zd„Zd„Zd„Zde fd„Zd„Z d9d „Z!d!„Z"d"„Z#d#„Z$d$„Z%d%„Z&d:d&„Z'd:d'„Z(d;d(„Z)defd)„Z*defd*„Z+dra{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)r4r5r6r7r8r9có—eZdZdZdd„Zy)ú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|t«s-t|j›dt |«j›«‚tj|«S)Nz* may only be constructed with a list, not )Ú isinstanceÚlistÚ TypeErrorr,ÚtypeÚ__new__)ÚclsÚ containeds rrAzParseResults.List.__new__‰sT€ØÐ Ø ä˜i¬Ô.ÜØ—|‘|nÐ$NÌtÐT]Ë×OgÑOgÐNhÐióðô—<‘< Ó$Ð$r r)r,r-r.Ú__doc__rArr rr r;bs „ñ$ ôL %r r có^—t|t«r|Stj|«}d|_d|_t «|_|€g|_nOt|ttf«r1t|tj«r|ddgn t|«|_n|g|_t«|_ |Sr)r=rÚobjectrAr4r5Úsetr6r8r>Ú_generator_typer Údictr9)rBÚtoklistÚnameÚkwargsrs rrAzParseResults.__new__”s•€Ügœ|Ô,ØˆNÜ~‰~˜cÓ"ˆØˆŒ ØˆŒÜ›%ˆŒàˆ?ØˆDMÜ ˜¤$¬Ð!8Ô 9ô˜g¤|×'8Ñ'8Ô9ð™‘ä˜'“]ð Mð%˜IˆDŒMÜ›ˆŒ Øˆr TcóÞ—|||_|¶|dk7r°||t«rt|«}|s|h|_||_||j vrx||ttf«r|g}|rV||t«r#tt|j«d«||<ntt|d«d«||<|||_y |d||<yyyy#tttf$r||ur|||<Yy||_YywxYw)NÚr)r7r/Ústrr6r4r3rr@rrr8ÚKeyErrorr?Ú IndexError)rrJrKÚasListÚmodalr=s rrzParseResults.__init__«s €ñ ØˆŒØÐ ¨¢ Ù˜$¤Ô$Ü˜4“yÙØ#' &”ØˆDŒJØ˜d×/Ñ/Ñ/Ù˜g¬´$Ð'7Ô8Ø&˜iGÙÙ! '¬<Ô8Ü%<Ü(¨×)9Ñ)9Ó:¸Aó&˜˜Tš ô&=Ü(¨°©Ó4°aó&˜˜T™ ð(,D˜‘JÕ$ð.Ø%,¨Q¡Z˜˜Tš ð0ð !+Ðøô,%¤i´Ð<ò.Ø"¨$Ñ.Ø)0˜D ›Jà)-˜DžJð .úsÂ7CÃC,Ã"C,Ã+C,cóî—t|ttf«r|j|S||jvr|j |ddSt |j |Dcgc]}|d‘Œ c}«Scc}w)Néÿÿÿÿr)r=r/Úslicer8r6r9r)rr#Úvs rr$zParseResults.__getitem__Ìsj€Üaœ#œu˜Ô&Ø—=‘= Ñ#Ð#à˜Ÿ™Ñ'Ø—}‘} QÑ'¨Ñ+¨AÑ.Ð.ä#°4·=±=ÀÑ3CÖ$D¨a Q q£TÒ$DÓEÐEùÒ$DsÁA2cóŠ—||t«r;|jj|t««|gz|j|<|d}nf||tt f«r||j|<|}nA|jj|t««t|d«gz|j|<|}||t«r||_yyr)) rr9Úgetr>r/rVr8rr5)rÚkrWr=Úsubs rÚ__setitem__zParseResults.__setitem__Õs±€ÙaÔ0Ô1Ø#Ÿ}™}×0Ñ0°´D³FÓ;¸q¸cÑAˆDM‰M˜!ÑØA‘$‰CÙ ˜œC¤˜<Ô (Ø ˆDM‰M˜!ÑØ‰Cà#Ÿ}™}×0Ñ0°´D³FÓ;Ü'¨¨1Ó-ð?ñ ˆDM‰M˜!ÑðˆCÙcœ<Ô(ØˆCKð)r c óê—t|ttf«rÐt|j«}|j|=t|t«r|dkr||z }t||dz«}tt |j|«Ž«}|j«|jj«D]7\}}|D]-}t|«D]\}\}} t|| | |kDz «||<ŒŒ/Œ9y|j|=y)Nré) r=r/rVÚlenr8r>ÚrangeÚindicesÚreverser9ÚitemsÚ enumerater) rr#ÚmylenÚremovedrKÚoccurrencesÚjrZÚvalueÚpositions rÚ__delitem__zParseResults.__delitem__äsï€Üaœ#œu˜Ô&Ü˜Ÿ ™ Ó&ˆEØ— ‘ ˜aÐ ô˜!œSÔ!Øq’5Ø˜‘JAÜ˜!˜Q ™U“Oäœ5 !§)¡)¨EÓ"2Ð3Ó4ˆGØO‰OÔà%)§]¡]×%8Ñ%8Ó%:ò Ñ!kØ òAÜ09¸+Ó0FòÑ,˜Ñ,˜E 8Ü)@Ø! 8¨x¸!©|Ñ#<ó*˜ Ašñññ ð— ‘ ˜aÑ r Úreturncó—||jvSr©r9)rrZs rÚ__contains__zParseResults.__contains__ûs€ØD—M‘MÐ!Ð!r có,—t|j«Sr)r_r8r&s rÚ__len__zParseResults.__len__þs€Ü4—=‘=Ó!Ð!r có:—|jxs|jSr)r8r9r&s rÚ__bool__zParseResults.__bool__s€ØŸ ™ Ò6¨¯©Ð7Ð7Ð7r có,—t|j«Sr©Úiterr8r&s rÚ__iter__zParseResults.__iter__ó€ÜD—M‘MÓ"Ð"r có8—t|jddd…«S)NrUrur&s rÚ__reversed__zParseResults.__reversed__s€ÜD—M‘M¡$ B $Ñ'Ó(Ð(r có,—t|j«Sr)rvr9r&s rÚkeyszParseResults.keys rxr có6‡—ˆfd„‰j«D«S)Nc3ó(•K—|] }‰|–—Œywrr©rrZrs €rrz&ParseResults.values..søèø€Ò-˜AQ•Ñ-ùsƒ©r|r&s`rÚvalueszParseResults.values sø€Û- §¡£Ô-Ð-r có6‡—ˆfd„‰j«D«S)Nc3ó,•K—|]}|‰|f–—Œ ywrrrs €rrz%ParseResults.items..søèø€Ò2 D˜‘G”Ñ2ùsƒr€r&s`rrczParseResults.itemssø€Û2 d§i¡i£kÔ2Ð2r có—|jS)zš Since ``keys()`` returns an iterator, this method is helpful in bypassing code that looks for the existence of any defined results names.rnr&s rÚhaskeyszParseResults.haskeyss€ð—}‘}Ð$Ð$Ð$r cóì—|sdg}|j«D]\}}|dk(r|d|f}Œtd|›«‚t|dt«st |«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:: 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'] rUÚdefaultrz)pop() got an unexpected keyword argument r^)rcr?r=r/r_)rr*rLrZrWÚindexÚretÚdefaultvalues rÚpopzParseResults.pops¢€ñPØ4ˆDØ—L‘L“Nò S‰DˆAˆqØIŠ~Ø˜Q™ |‘äÐ"KÈAÈ5Ð QÓRÐRð Sô d˜1‘gœsÔ#¤s¨4£y°A¢~¸¸a¹ÀD¹Ø˜‘GˆEØu‘+ˆCØUØˆJà ™7ˆLØÐr có—||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)rÚkeyÚ default_values rrYzParseResults.getQs€ð$$‰;Ø˜‘9Ðà Ð r cóÖ—|jj||«|jj«D]0\}}t |«D]\}\}}t||||kDz«||<ŒŒ2y)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)r8Úinsertr9rcrdr)rrˆÚ ins_stringrKrgrZrirjs rrzParseResults.inserthst€ð" ‰ ×Ñ˜U JÔ/à!%§¡×!4Ñ!4Ó!6ò ÑˆD+Ü(1°+Ó(>ò Ñ$Ñ$E˜8Ü!8Ø˜8 x°%Ñ'7Ñ8ó"˜A’ñ ñ r có:—|jj|«y)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)r8Úappend)rÚitems rr“zParseResults.appends€ð ‰ ×Ñ˜TÕ"r có~—t|t«r|j|«y|jj |«y)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__r8Úextend)rÚitemseqs rr—zParseResults.extend’s,€ôgœ|Ô,ØM‰M˜'Õ"àM‰M× Ñ Õ)r cóV—|jdd…=|jj«y)z7 Clear all elements and results names. N)r8r9Úclearr&s rršzParseResults.clear¦s €ð M‰Mš!ÐØ ‰ ×ÑÕr cód— ||S#t$r|jd«rt|«‚YywxYw)NÚ__rN)rPÚ startswithÚAttributeError)rrKs rÚ__getattr__zParseResults.__getattr__s:€ð Ø˜‘:ÐøÜò Ø‰˜tÔ$Ü$ TÓ*Ð*Ùð ús‚‡%/®/có0—|j«}||z }|Sr)Úcopy)rÚotherr‰s rÚ__add__zParseResults.__add__µs€Øi‰i‹kˆØˆu‰ˆØˆ r cóÞ‡—|s|S|jr–t|j«Šˆfd„}|jj«}|Dcgc]&\}}|D]}|t |d||d««f‘ŒŒ(}}}}|D](\}}|||<t|dt«sŒ||d_Œ*|xj|jz c_|xj|jzc_|Scc}}}w)Ncó•—|dkr‰S|‰zSr)r)ÚaÚoffsets €rúz'ParseResults.__iadd__..Àsø€¨A°ªE &€°q¸6±z€r rr^) r9r_r8rcrr=rr5r6) rr¢Ú addoffsetÚ otheritemsrZÚvlistrWÚotherdictitemsr§s @rr–zParseResults.__iadd__ºsöø€ÙØˆKà>Š>Ü˜Ÿ™Ó'ˆFÛAˆIØŸ™×-Ñ-Ó/ˆJð!+÷ðáAuØòððÔ+¨A¨a©D±)¸A¸a¹D³/ÓBÒCðØCðˆNòð 'ò (‘1ØQ‘Ü˜a ™d¤LÕ1Ø#'Aa‘D•Lð (ð Š ˜Ÿ™Ñ' ØŠ˜5×+Ñ+Ñ+ØˆùôsÁ+C(cóV—t|t«r|dk(r|j«S||zSr))r=r/r¡)rr¢s rÚ__radd__zParseResults.__radd__Ðs*€ÜeœSÔ! e¨q¢jà—9‘9“;Ðð˜4‘<Ðr cón—t|«j›d|j›d|j«›dS)Nú(ú, ú))r@r,r8Úas_dictr&s rÚ__repr__zParseResults.__repr__Øs2€Üt“*×%Ñ%Ð& a¨¯ © Ð'8¸¸4¿<¹<»>Ð:JÈ!ÐLÐLr c ó²—ddj|jDcgc](}t|t«rt |«n t|«‘Œ*c}«zdzScc}w)Nú[r±ú])Újoinr8r=rrOÚreprr"s rÚ__str__zParseResults.__str__Ûs\€àØi‰ið"Ÿ]™]öàô)¨¬LÔ9”C˜”F¼tÀA»wÑFòóñ ðñ ð ùòs›-A cóÒ—g}|jD]U}|r|r|j|«t|t«r||j «z }Œ<|jt|««ŒW|Sr)r8r“r=rÚ _asStringListrO)rÚsepÚoutr”s rr¼zParseResults._asStringListçs^€ØˆØ—M‘Mò &ˆDÙ‘sØ— ‘ ˜3”Ü˜$¤Ô-Øt×)Ñ)Ó+Ñ+‘à— ‘ œ3˜t›9Õ%ð &ðˆ r có€—|jDcgc]$}t|t«r|j«n|‘Œ&c}Scc}w)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'] )r8r=rÚas_list)rÚress rrÀzParseResults.as_listòs<€ð"—}‘}ö àô(¨¬\Ô:ˆCK‰KŒMÀÑCò ð ùò s);cóR‡—ˆfd„Štˆfd„|j«D««S)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"} cóž•—t|t«r6|j«r|j«S|Dcgc] }‰|«‘Œc}S|Scc}wr)r=rr…r³)ÚobjrWÚto_items €rrÅz%ParseResults.as_dict..to_itemsAø€Ü˜#œ|Ô,Ø(+¯©¬ s—{‘{“}ÐTÐPSÖ;TÈ1¹GÀA½JÒ;TÐTà ùò.!søèø€Ò=©¨¨1Q™ › ”OÑ=ùsƒ)rIrc)rrÅs @rr³zParseResults.as_dicts!ø€ô* ôÓ=°· ± ³Ô=Ó=Ð=r cóð—t|j«}|jj«|_|j|_|xj |j zc_|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. )rr8r9r¡r5r6r4)rr‰s rr¡zParseResults.copy#sS€ô˜4Ÿ=™=Ó)ˆØ—}‘}×)Ñ)Ó+ˆŒØ—l‘lˆŒØŠ˜$Ÿ/™/Ñ)Ø—J‘JˆŒ Øˆ r có0—|j«}t|j«D]í\}}t|t«r|j«|j|<Œ4t|ttf«rŒKt|t«r]t|««x|j|<}|j«D]*\}}t|t«r|j«n|||<Œ,Œ¸t|t«sŒÉt|«d„|D««|j|<Œï|S)zL Returns a new deep copy of a :class:`ParseResults` object. c3ó`K—|]&}t|t«r|j«n|–—Œ(ywr)r=rÚdeepcopy)rrWs rrz(ParseResults.deepcopy..As)èø€ò-ØKL¤J¨q´,Ô$?A—J‘J”LÀQÓFñ-ùs‚,.)r¡rdr8r=rrÊrOÚbytesrr@rcr)rr‰r#rÄÚdestrZrWs rrÊzParseResults.deepcopy1së€ði‰i‹kˆä § ¡ Ó.ò ‰FˆAˆsÜ˜#œ|Ô,Ø#&§<¡<£>— ‘ ˜aÒ Ü˜C¤#¤u Ô.ØÜ˜C¤Ô0Ø*3¬$¨s«)«+Ð5— ‘ ˜aÑ 4ØŸI™I›KòQ‘DAqÜ.8¸¼LÔ.I˜aŸj™jœlÈqD˜’GñQä˜C¤Õ+Ø#,¤4¨£9ñ-ØPSô-ó$— ‘ ˜aÒ ð ðˆ r cóÐ‡—‰jr‰jS‰jr;‰j}|jj«}t ˆfd„|D«d«St‰«dk(rxt‰j«dk(r`t t ‰jj«««dddvr,t t ‰jj«««Sy)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óD•K—|]\}}|D] \}}|‰ur|–—ŒŒywrr)rrZr«rWÚlocrs €rrz(ParseResults.get_name..es=øèø€òá ˜˜5Ø"'òñ˜˜3Ø˜D‘yôðØñùsƒ Nr^r)rrU) r4r5r9rcÚnextr_rvrr|)rÚparÚparent_tokdict_itemss` rÚget_namezParseResults.get_nameFs¿ø€ð2:Š:Ø—:‘:ÐØ \Š\Ø"&§,¡,ˆCØ#&§<¡<×#5Ñ#5Ó#7Ð Üóà$8ôðóð ô ‹I˜ŠNÜD—M‘MÓ" aÒ'Ü”T˜$Ÿ-™-×.Ñ.Ó0Ó1Ó2°1Ñ5°aÑ8¸GÑCäœ˜TŸ]™]×/Ñ/Ó1Ó2Ó3Ð3àr có—g}d}|j|r|t|j««znd«|r€|j«rÈt d„|j«D««}|D]£\}} |r|j|«|j|›d|z›d|›d«t | t«rE| r(|j| j||||dz¬««Œo|jt| ««ŒŠ|jt| ««Œ¥td „|D««r–|} t| «D]†\} }t |t«rE|jd j|d|z| |d|dzz|j||||dz¬«««Œ[|jd|d|z| |d|dzzt|«fz«Œˆdj|«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|«|f–—Œywr)rO)rrZrWs rrz$ParseResults.dump..‘sèø€ÒD©t¨q°!¤ A£¨œ{ÑDùó‚z z- z: r^)ÚindentÚfullÚinclude_listÚ_depthc3ó<K—|]}t|t«–—Œywr)r=r)rÚvvs rrz$ParseResults.dump..¤sèø€Ò?°B”:˜b¤,×/Ñ?ùr×z {}{}[{}]: {}{}{}z %s%s[%d]: %s%s%s)r“rOrÀr…Úsortedrcr=rÚdumpr¹ÚanyrdÚformatr¸)rrØrÙrÚrÛr¾ÚNLrcrZrWr#rÝs rrßzParseResults.dumpvsÊ€ð*ˆØ ˆØ ‰ ±<6œC §¡£Ó/Ò/ÀRÔHâØ|‰|Œ~ÜÑD°t·z±z³|ÔDÓDØ!ò,‘DAqÙØŸ ™ 2œØ—J‘J & ¨4°&©=Ð):¸"¸Q¸C¸rÐBÔCÜ! !¤\Ô2ÙØŸJ™JØ !§¡Ø+1Ø)-Ø1=Ø+1°A©:ð !'ó!"õð ŸJ™J¤s¨1£vÕ.àŸ ™ ¤4¨£7Õ+ð#,ô$Ñ?¸$Ô?Ô?ØÜ& q›\ò‘EArÜ! "¤lÔ3ØŸ ™ Ø1×8Ñ8Ø &Ø!%¨¡Ø !Ø &Ø!%¨°!©Ñ!4Ø "§¡Ø+1Ø)-Ø1=Ø+1°A©:ð !(ó!"ó õð Ÿ ™ Ø1à &Ø!%¨¡Ø !Ø &Ø!%¨°!©Ñ!4Ü # B£ð ñõ ð%ð<w‰ws‹|Ðr cóR—tj|j«g|¢i|¤Žy)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 rräzParseResults.pprintÆs €ô2 ‰ d—l‘l“nÐ6 tÒ6¨vÓ6r có~—|j|jj«d|j|jffSr)r8r9r¡r6r4r&s rr'zParseResults.__getstate__âs9€àM‰Mà— ‘ ×"Ñ"Ó$ØØ—‘Ø— ‘ ð ð ð r cód—|\|_\|_}}|_t|«|_d|_yr)r8r9r4rGr6r5)rÚstaterÑÚinAccumNamess rr+zParseResults.__setstate__ís.€ØHMÑEˆŒ ÑE˜œ s¨L¸$¼*Ü˜lÓ+ˆŒØˆr có2—|j|jfSr)r8r4r&s rÚ__getnewargs__zParseResults.__getnewargs__òs€Ø}‰}˜dŸj™jÐ(Ð(r có^—tt|««t|j««zSr)Údirr@r>r|r&s rÚ__dir__zParseResults.__dir__õs €Ü”4˜“:‹¤ d§i¡i£kÓ!2Ñ2Ð2r c óÞ—d„}|g«}|j«D]A\}}t|t«r||j||¬«z }Œ-|||g|||«¬«z }ŒC|||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. cóZ— t|«t|t«S#t$rYywxYw)NF)rvr=rÚ Exception)rÄs rÚis_iterablez+ParseResults.from_dict..is_iterables4€ð 5ÜS” ô & c¬8Ó4Ð4Ð4øô ò Ùð ús‚ž *©*)rK)rKrR)rcr=rÚ from_dict)rBr¢rKrñr‰rZrWs rròzParseResults.from_dictøs€€ò 5ñ"‹gˆØ—K‘K“Mò ?‰DˆAˆqÜ˜!œWÔ%Øs—}‘} Q¨Q}Ó/Ñ/‘à‘s˜A˜3 Q©{¸1«~Ô>Ñ>‘ð ?ð ÐÙse $Ô'ˆCØˆ r )NNr)r¢rrlr)rlr)rN)rNTTr)>r,r-r.rDr3r r r0rOrÚboolr rr1r>rAr=rr$r\rkror/rqrsrrwrzr|rrcr…r‹rYrr“r—ršrŸr£r–r®r´rºr¼rÀrIr³r¡rÊrÓrßrär'r+rêríÚclassmethodròrRÚasDictÚgetNamerr rrr"s¼…ñ+ðZ&*¨2¨r N€L%˜˜S˜‘/Ó2àƒJØ ÓØC‘ÓØƒLØ3‰iÓØ3˜8‰nÓð€Iô0%ˆtô0%ódð0 ¨d¸$È:ó.òBFð,6ó ò!ð." ó"ð"˜ó"ð8˜$ó8ð#˜(ó#ð)˜hó)ò#ò.ò3ð%˜ó%ò6 óp!ò.ò2#ò"*ò(òóó ó, ðM˜#óMð ˜ó ó ð ˜ó ð(>˜ó>ó:óò*.ñ`NÈóNò`7ò8 òò )ò3ðóóðð4€FØ+Ø €FØ+Ø€GØ,r r)Úcollections.abcrrrrrrräÚtypingr r rrr rOrËrr@r0rHrrÚregisterrr rúrús}ð÷÷ðóß.Õ.à! 5˜\€ˆ%c Ñ Ó)Ù‘ 2”Ó'€÷ñ÷"v-ñv-ðr€×Ñ˜Ô%Ø€×Ñ˜Õ&r