o Ȑil@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 `/var/www/html/eduruby.in/lip-sync/lip-sync-env/lib/python3.10/site-packages/pyparsing/results.py srr c@s>eZdZUded<dgZdd d Zd d Zd dZddZdS)_ParseResultsWithOffsetztuple[ParseResults, int]tupp1 ParseResultsp2intreturnNonecCs||f|_dSr r)selfrrr r r__init__z _ParseResultsWithOffset.__init__cCs |j|Sr rrir r r __getitem__ z#_ParseResultsWithOffset.__getitem__cCs|jSr rrr r r __getstate__!sz$_ParseResultsWithOffset.__getstate__cGs|d|_dSNrr)rargsr r r __setstate__$rz$_ParseResultsWithOffset.__setstate__N)rrrrrr) __name__ __module__ __qualname____annotations__ __slots__rr r#r&r r r rrs   rc@seZdZUdZdgdfZded<ded<ded<d ed <d ed <d ed<ded<dZGdddeZdpddZ dddde fdqddZ ddZ e fddZ dd Zdrd!d"Zdsd$d%Zdrd&d'Zdtd)d*Zdtd+d,Zd-d.Zd/d0Zd1d2Zdrd3d4Zd5d6Zdud7d8Zd9d:Zd;d<Zd=d>Zd?d@ZdAdBZdvdDdEZdvdFdGZ dwdHdIZ!dxdJdKZ"dxdLdMZ#dydOdPZ$dQdRdzdUdVZ%d{dXdYZ&dwdZd[Z'dwd\d]Z(d|d_d`Z)d}dxdbdcZ*dddeZ+dfdgZ,dhdiZ-djdkZ.dldmZ/e0dudwdndoZ1e%Z2 e&Z3 e)Z4dS)~raStructured 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/r0r2r3r4c@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:|durg}t|tst|jdt|jt|S)Nz* may only be constructed with a list, not ) isinstancelist TypeErrorr'type__new__)cls containedr r rr9s  zParseResults.List.__new__r )r'r(r)__doc__r9r r r rListns;r=cKst|tr|St|}d|_d|_t|_|durg|_nt|t t fr8t|tj r2|ddgnt ||_n|g|_t |_ |Sr )r5robjectr9r.r/setr0r3r6_generator_typer=dictr4)r:toklistnamekwargsrr r rr9s   zParseResults.__new__Trrc Cs|||_|dus |dkrdS||trt|}|s|h|_||_||jvr(dS||ttfr2|g}|rV||trDt t|j d||<n t t|dd||<|||_dSz |d||<WdSt t t fyz||urt|||<YdS||_YdSw)Nr)r2rr-r0r.r,r r8rrr3KeyErrorr7 IndexError)rrBrCasListmodalr5r r rrs4     zParseResults.__init__cCsLt|ttfr |j|S||jvr|j|ddStdd|j|DS)NrcSsg|]}|dqS)rr rvr r r z,ParseResults.__getitem__..)r5rslicer3r0r4rrr r rr s   zParseResults.__getitem__cCs||tr|j|t|g|j|<|d}n!||ttfr'||j|<|}n|j|gt|dg|j|<|}||trC||_dSdSr$) rr4getr6rrOr3rr/)rkrLr5subr r r __setitem__s       zParseResults.__setitem__c Cst|ttfs |j|=dSt|j}|j|=t|tr*|dkr#||7}t||d}tt||}| |j D]}|D]}t |D]\}\}}t ||||k||<qFq@q.rkr"r r"rrX5zParseResults.valuescrl)Nc3s|] }||fVqdSr r rmr"r rr9sz%ParseResults.items..rnr"r r"ritems8rozParseResults.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.rar"r r rhaskeys;s zParseResults.haskeyscOs|sdg}|D]\}}|dkr|d|f}q td|t|dts2t|dks2|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'] rJdefaultrz)pop() got an unexpected keyword argument r )rpr7r5rrT)rr%rDrQrLindexret defaultvaluer r rpopAs.&zParseResults.popcCs||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_valuer r rrPszParseResults.getcCsN|j|||jD]}t|D]\}\}}t||||k||<qq dS)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)r3insertr4rXrYr)rrs ins_stringr\rQr^r_r r rrys  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)r3append)ritemr r rr{szParseResults.appendcCs(t|tr ||dS|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)r5r__iadd__r3extend)ritemseqr r rr~s zParseResults.extendcCs|jdd=|jdS)z7 Clear all elements and results names. N)r3r4clearr"r r rrs zParseResults.clearcCs2z||WSty|drt|YdSw)N__rE)rF startswithAttributeError)rrCr r r __getattr__s   zParseResults.__getattr__othercCs|}||7}|Sr )copy)rrrtr r r__add__szParseResults.__add__cs|s|S|jr7t|jfdd|j}fdd|D}|D]\}}|||<t|dtr6||d_q"|j|j7_|j|jO_|S)Ncs|dkrS|Sr$r )a)offsetr r rNz'ParseResults.__iadd__..c s4g|]\}}|D]}|t|d|dfqqS)rr )r)rrQvlistrL) addoffsetr rrMsz)ParseResults.__iadd__..r)r4rTr3rpr5rr/r0)rr otheritemsotherdictitemsrQrLr )rrrr}s"      zParseResults.__iadd__cCs"t|tr |dkr |S||Sr$)r5rr)rrr r r__radd__szParseResults.__radd__cCs"t|jd|jd|dS)N(, ))r8r'r3as_dictr"r r r__repr__$s"zParseResults.__repr__cCsdddd|jDdS)N[rcSs&g|]}t|tr t|nt|qSr )r5rr-repr)rrr r rrM+sz(ParseResults.__str__..])joinr3r"r r r__str__'szParseResults.__str__rEcCsLg}|jD]}|r|r||t|tr||7}q|t|q|Sr )r3r{r5r _asStringListr-)rsepoutr|r r rr3s   zParseResults._asStringListF)flattenrr6cs,fdd}|rg|SddjDS)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. c3sNtg}|r%|}t|tr||dddn|V|s dSdSri) collectionsdequepopleftr5r extendleft)prZto_visitZto_dor"r r flattened]s  z'ParseResults.as_list..flattenedcSs"g|] }t|tr |n|qSr )r5ras_list)rresr r rrMisz(ParseResults.as_list..)r3)rrrr r"rr>s  zParseResults.as_listrAcs&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"} cs0t|tr|r |Sfdd|DS|S)Ncsg|]}|qSr r rKto_itemr rrMrNz9ParseResults.as_dict..to_item..)r5rrqrobjrr rrs "z%ParseResults.as_dict..to_itemc3s |] \}}||fVqdSr r rrQrLrr rrz'ParseResults.as_dict..)rArpr"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. )rr3r4rr/r0r.)rrtr r rrs  zParseResults.copycCs|}t|jD]R\}}t|tr||j|<q t|ttfr"q t|trHt ||j|<}| D]\}}t|trB|n|||<q5q t|t r[t |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 )r5rdeepcopyrKr r rrs z(ParseResults.deepcopy..) rrYr3r5rrr-bytesrr8rpr)rrtrrdestrQrLr r rrs"    zParseResults.deepcopy str | NonecsjrjSjrj}|j}tfdd|DdStdkrBtjdkrBttjdddvrBttjSdS)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 )rrQrrLlocr"r rrsz(ParseResults.get_name..Nr r)rrJ) r.r/r4rpnextrTrgrXrk)rparZparent_tokdict_itemsr r"rget_names     zParseResults.get_namercCsg}d}||r|t|nd|sd|S|rktdd|D}|D]?\}} |r6||||d|d|dt| tsR|t | q+| s\|t| q+|| j ||||dd q+t d d|Dsyd|S|} d} d} t | D]O\} } t| tr| j ||||dd }|| || |d | d | || |d| q|| || |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'  rEcss |] \}}t||fVqdSr )r-rr r rrrz$ParseResults.dump..z z- z: r )indentfull include_list_depthcss|]}t|tVqdSr )r5r)rvvr r rr)srz]:) r{r-rrrqsortedrpr5rrdumpanyrY)rrrrrrNLrprQrLincrnlrrZvv_dumpr r rrsZ      22 zParseResults.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%rDr r rrAs zParseResults.pprintcCs|j|jd|j|jffSr )r3r4rr0r.r"r r rr#aszParseResults.__getstate__cCs*|\|_\|_}}|_t||_d|_dSr )r3r4r.r?r0r/)rstater inAccumNamesr r rr&ls  zParseResults.__setstate__cCs |j|jfSr )r3r.r"r r r__getnewargs__qs zParseResults.__getnewargs__cCstt|t|Sr )dirr8r6rkr"r r r__dir__tszParseResults.__dir__cCsrdd}|g}|D]\}}t|tr||j||d7}q |||g|||d7}q |dur7||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. cSs.zt|Wn tyYdSwt|t S)NF)rg Exceptionr5r rr r r is_iterables    z+ParseResults.from_dict..is_iterable)rC)rCrHN)rpr5r from_dict)r:rrCrrtrQrLr r rrws  zParseResults.from_dict)NN)rr)rr1)rr)rrr )rrrr)rr)rr-)rE)rr1rr6)rrA)rr)rETTr)5r'r(r)r<r,r*r+r6r=r9r5rr rSr`rbrdrerhrjrkrXrprqrvrPryr{r~rrrr}rrrrrrrrrrrr#r&rr classmethodrrHasDictgetNamer r r rr(st 3 G  '        >!       0 )   7N  r) __future__rrcollections.abcrrrrrrtypingrutilr r-rr r*r8r@rrregisterr r r rs&