a hl@sUddlmZddlZddlmZmZmZmZmZddl Z ddl m Z ddl m Z eefZded<ed d d DZGd d d ZGdddZeeeedS)) annotationsN)MutableMappingMappingMutableSequenceIteratorIterable)Any)replaced_by_pep8ztuple[type, ...]str_typeccs|] }|VqdSN).0_r r ^/mounts/lovelace/software/anaconda3/envs/py39/lib/python3.9/site-packages/pyparsing/results.py rr c@sFeZdZUded<dgZddddddZd d Zd d Zd dZdS)_ParseResultsWithOffsetztuple[ParseResults, int]tup ParseResultsintNone)p1p2returncCs||f|_dSr r)selfrrr r r__init__sz _ParseResultsWithOffset.__init__cCs |j|Sr rrir r r __getitem__sz#_ParseResultsWithOffset.__getitem__cCs|jSr rrr r r __getstate__!sz$_ParseResultsWithOffset.__getstate__cGs|d|_dSNrr)rargsr r r __setstate__$sz$_ParseResultsWithOffset.__setstate__N) __name__ __module__ __qualname____annotations__ __slots__rr r"r%r r r rrs rc@sHeZdZUdZdgdfZded<ded<ded<d ed <d ed <d ed<ded<dZGdddeZdpddZ dddde fddddZ ddZ e fddZ dd Zd dd!d"Zd#dd$d%Zd dd&d'Zd(dd)d*Zd(dd+d,Zd-d.Zd/d0Zd1d2Zd dd3d4Zd5d6Zdqd7d8Zd9d:Zd;d<Zd=d>Zd?d@ZdAdBZdddCdDdEZdddCdFdGZ dddHdIZ!dddJdKZ"dddLdMZ#drdOdPZ$dQdRd dSdTdUdVZ%dWddXdYZ&dddZd[Z'ddd\d]Z(d^dd_d`Z)dsdddbdcZ*dddeZ+dfdgZ,dhdiZ-djdkZ.dldmZ/e0dtdddndoZ1e%Z2e&Z3e)Z4dS)uraStructured 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' Nr ztuple[Any, ...] _null_valuesstr_name_parentzset[str] _all_namesbool_modalz list[Any]_toklistzdict[str, Any]_tokdict)r-r.r/r1r2r3c@seZdZdZdddZdS)zParseResults.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`.) NcCs:|dur g}t|ts0t|jdt|jt|S)Nz* may only be constructed with a list, not ) isinstancelist TypeErrorr&type__new__)clsZ containedr r rr8s zParseResults.List.__new__)N)r&r'r(__doc__r8r r r rListns;r;cKst|tr|St|}d|_d|_t|_|durrz,ParseResults.__getitem__..)r4rslicer2r/r3rrr r rr s   zParseResults.__getitem__cCs||tr0|j|t|g|j|<|d}nB||ttfrN||j|<|}n$|j|gt|dg|j|<|}||tr||_dSr#) rr3getr5rrKr2rr.)rkrIr4subr r r __setitem__s      zParseResults.__setitem__c Cst|ttfs|j|=dSt|j}|j|=t|trT|dkrF||7}t||d}tt||}| |j D]:}|D]0}t |D]"\}\}}t ||||k||<qqqxdS)Nrr ) r4rrKr3lenr2r5rangeindicesreversevalues enumerater) rrZmylenZremoved occurrencesjrMvaluepositionr r r __delitem__ s"   zParseResults.__delitem__cCs ||jvSr r3)rrMr r r __contains__#szParseResults.__contains__rcCs t|jSr )rPr2r!r r r__len__&szParseResults.__len__cCs|jp |j Sr )r2r3r!r r r__bool__)szParseResults.__bool__rcCs t|jSr iterr2r!r r r__iter__,szParseResults.__iter__cCst|jdddSNrGr_r!r r r __reversed__/szParseResults.__reversed__cCs t|jSr )r`r3r!r r rkeys2szParseResults.keyscsfddDS)Nc3s|]}|VqdSr r rrMr!r rr6rz&ParseResults.values..rdr!r r!rrT5szParseResults.valuescsfddDS)Nc3s|]}||fVqdSr r rer!r rr9rz%ParseResults.items..rfr!r r!ritems8szParseResults.itemscCs |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.r[r!r r rhaskeys;szParseResults.haskeyscOs|s dg}|D],\}}|dkr0|d|f}qtd|qt|dtsft|dksf|d|vr|d}||}||=|S|d}|SdS)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'] rGdefaultrz)pop() got an unexpected keyword argument r N)rgr6r4rrP)rr$rBrMrIindexretZ defaultvaluer r rpopAs.&zParseResults.popcCs||vr||S|SdS)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") Nr )rkey default_valuer r rrLszParseResults.getcCsN|j|||jD]0}t|D]"\}\}}t||||k||<q$qdS)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)r2insertr3rTrUr)rrjZ ins_stringrVrMrXrYr r rros  zParseResults.insertcCs|j|dS)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)r2append)ritemr r rrpszParseResults.appendcCs&t|tr||n |j|dS)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)r4r__iadd__r2extend)rZitemseqr r rrss  zParseResults.extendcCs|jdd=|jdS)z7 Clear all elements and results names. N)r2r3clearr!r r rrts zParseResults.clearcCs6z ||WSty0|dr*t|YdS0dS)N__rC)rD startswithAttributeError)rrAr r r __getattr__s    zParseResults.__getattr__)otherrcCs|}||7}|Sr )copy)rryrkr r r__add__szParseResults.__add__cs|s|S|jrnt|jfdd|j}fdd|D}|D](\}}|||<t|dtrD||d_qD|j|j7_|j|jO_|S)Ncs|dkr S|Sr#r )a)offsetr r rz'ParseResults.__iadd__..c s4g|],\}}|D]}|t|d|dfqqS)rr )r)rrMvlistrI) addoffsetr rrJsz)ParseResults.__iadd__..r)r3rPr2rgr4rr.r/)rryZ otheritemsZotherdictitemsrMrIr )rr}rrrs       zParseResults.__iadd__cCs&t|tr|dkr|S||SdSr#)r4rrz)rryr r r__radd__szParseResults.__radd__cCs"t|jd|jd|dS)N(, ))r7r&r2as_dictr!r r r__repr__$szParseResults.__repr__cCsdddd|jDdS)N[rcSs&g|]}t|trt|nt|qSr )r4rr,repr)rrr r rrJ+sz(ParseResults.__str__..])joinr2r!r r r__str__'szParseResults.__str__rCcCsLg}|jD]<}|r |r ||t|tr8||7}q |t|q |Sr )r2rpr4r _asStringListr,)rsepoutrqr r rr3s   zParseResults._asStringListF)flattenr5)rrcs0fdd}|rg|SddjDSdS)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. c3sFtg}|rB|}t|tr:||dddq|VqdSrb) collectionsdequepopleftr4r extendleft)prZto_visitZto_dor!r r flattened]s  z'ParseResults.as_list..flattenedcSs"g|]}t|tr|n|qSr )r4ras_list)rresr r rrJisz(ParseResults.as_list..N)r2)rrrr r!rr>s   zParseResults.as_listr?cs&fddtfdd|DS)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"} cs4t|tr,|r|Sfdd|DS|SdS)Ncsg|] }|qSr r rHto_itemr rrJrz9ParseResults.as_dict..to_item..)r4rrhrobjrr rrs "z%ParseResults.as_dict..to_itemc3s|]\}}||fVqdSr r rrMrIrr rrrz'ParseResults.as_dict..)r?rgr!r rrrns! zParseResults.as_dictcCs:t|j}|j|_|j|_|j|jO_|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. )rr2r3rzr.r/r-)rrkr r rrzs   zParseResults.copycCs|}t|jD]\}}t|tr4||j|<qt|ttfrDqt|trt ||j|<}| D]"\}}t|tr|n|||<qjqt|t rt |dd|D|j|<q|S)zm Returns a new deep copy of a :class:`ParseResults` object. .. versionadded:: 3.1.0 css$|]}t|tr|n|VqdSr )r4rdeepcopyrHr r rrsz(ParseResults.deepcopy..) rzrUr2r4rrr,bytesrr7rgr)rrkrrdestrMrIr r rrs    zParseResults.deepcopyz str | Nonecsjr jSjr:j}|j}tfdd|DdStdkrtjdkrttjdddvrttjSdSdS)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 c3s,|]$\}}|D]\}}|ur|VqqdSr r )rrMrrIlocr!r rrs z(ParseResults.get_name..Nr r)rrG) r-r.r3rgnextrPr`rTrd)rparZparent_tokdict_itemsr r!rget_names&     zParseResults.get_namercCsg}d}||r |t|nd|s4d|S|rtdd|D}|D]~\}} |rl||||d|d|dt| ts|t | qV| s|t| qV|| j ||||dd qVt d d|Dsd|S|} d} d} t | D]\} } t| trl| j ||||dd }|| || |d | d | || |d| n:|| || |d | d | || |d| qd|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'  rCcss|]\}}t||fVqdSr )r,rr r rrrz$ParseResults.dump..z z- z: r )indentfull include_list_depthcss|]}t|tVqdSr )r4r)rvvr r rr)rrz]:) rpr,rrrhsortedrgr4rrdumpanyrU)rrrrrrNLrgrMrIincrnlrrZvv_dumpr r rrsZ      22zParseResults.dumpcOs tj|g|Ri|dS)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$rBr r rrAszParseResults.pprintcCs|j|jd|j|jffSr )r2r3rzr/r-r!r r rr"aszParseResults.__getstate__cCs*|\|_\|_}}|_t||_d|_dSr )r2r3r-r=r/r.)rstaterZ inAccumNamesr r rr%ls zParseResults.__setstate__cCs |j|jfSr )r2r-r!r r r__getnewargs__qszParseResults.__getnewargs__cCstt|t|Sr )dirr7r5rdr!r r r__dir__tszParseResults.__dir__cCsrdd}|g}|D]>\}}t|tr>||j||d7}q|||g|||d7}q|durn||g|d}|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. cSs2z t|Wnty YdS0t|t SdS)NF)r` Exceptionr4r rr r r is_iterables   z+ParseResults.from_dict..is_iterable)rA)rArFN)rgr4r from_dict)r9ryrArrkrMrIr r rrws  zParseResults.from_dict)NN)N)rC)rCTTr)N)5r&r'r(r:r+r)r*r5r;r8r4rr rOrZr\r]r^rarcrdrTrgrhrlrLrorprsrtrxr{rrrrrrrrrzrrrrr"r%rr classmethodrrFZasDictgetNamer r r rr(sn 3 G  ' > ! 0)7N  r) __future__rrcollections.abcrrrrrrtypingrutilr r,rr r)r7r>rrregisterr r r rs$