Ë R`iö–ãó‚—UddlZddlZddlZddlZddlmZddlddlm Z m Z mZmZ dcddœde deje d eje d e fd„Zde d e fd„Zde d e fd „Z dddddœdeej&eefdededededed e fd„Zde de d e fd„Z deddœde deded e fd„Zde d e fd„Zde d e fd „Zd!d"de«fe«d#œd$eee fd%eee fd&eje d'e d(e d e fd)„Zed*«ed+«fd,„Zd-eee fd ee e ffd.„Z d-eee fd ee e ffd/„Z!e e"d0<e e"d1<e e#e$e%d2z«jMd3««\Z'Z(ejRjTjW«Dcic]\}}|jYd4«|“Œc}}Z-e.d5d6j_e-«zd7z«jMd8«Z0d9„Z1Gd:„d;e2«Z3ee eeee efee efffZ4eee4e5e3eje6fee4e5e3ffZ7ed!«ed"«fdeee fd?eee fd e f d@„Z9dgfdA„Z:e;e.dB«dCz«jMdD«Z< e.dE«jMdF«Z= e.dG«j}«jMdH«Z?e.dI«jMdJ«Z@ e;e.dB«dCze@z«jMdK«ZA eAZB e.dL«jMdM«ZC eD«j‹«Dcgc]}eF|e «sŒ |‘Œc}ZGe8e e"dN< dfddOœdeee fdPeee fdQedReje5dSeje5dTed e fdU„ZHe3ZIe'ZJe(ZKe0ZLe ['ab', 'cd'] # in this parser, the leading integer value is given in binary, # '10' indicating that 2 values are in the array binary_constant = Word('01').set_parse_action(lambda t: int(t[0], 2)) counted_array(Word(alphas), int_expr=binary_constant).parse_string('10 ab cd ef') # -> ['ab', 'cd'] # if other fields must be parsed after the count but before the # list items, give the fields results names and they will # be preserved in the returned ParseResults: count_with_metadata = integer + Word(alphas)("type") typed_array = counted_array(Word(alphanums), int_expr=count_with_metadata)("items") result = typed_array.parse_string("3 bool True True False") print(result.dump()) # prints # ['True', 'True', 'False'] # - items: ['True', 'True', 'False'] # - type: 'bool' cóB•—|d}‰|r‰|zn t«zŠ|dd…=y©Nr)ÚEmpty)ÚsÚlÚtÚnÚ array_exprrs €€ú/builddir/build/BUILDROOT/alt-python312-pip-23.3.1-3.el8.x86_64/opt/alt/python312/lib/python3.12/site-packages/pip/_vendor/pyparsing/helpers.pyÚcount_field_parse_actionz/counted_array..count_field_parse_action@s'ø€à ˆa‰DˆØ¡Q˜˜qš¬E«GÑ3ˆ à Ša‰Dócó—t|d«Sr)Úint©rs rÚzcounted_array..Hs€¼¸A¸a¹D¼ rÚarrayLenT)Úcall_during_tryz(len) z...)ÚForwardÚWordÚnumsÚset_parse_actionÚcopyÚset_nameÚadd_parse_actionÚstr)rrr rrs` @rÚ counted_arrayr(s‰ù€ðRÒ!˜€GÜ“€Jõð€Ü”t“*×-Ñ-Ñ.AÓB‰à—,‘,“.ˆØ×ÑZÔ Ø×ÑÐ5ÀtÐÔLØjÑ ×*Ñ*¨8´c¸$³iÑ+?À%Ñ+GÓHÐHrcó†‡—t«Šˆfd„}|j|d¬«‰jdt|«z«‰S)a9Helper to define an expression that is indirectly defined from the tokens matched in a previous expression, that is, it looks for a 'repeat' of a previous expression. For example:: first = Word(nums) second = match_previous_literal(first) match_expr = first + ":" + second will match ``"1:1"``, but not ``"1:2"``. Because this matches a previous literal, will also match the leading ``"1:1"`` in ``"1:10"``. If this is not desired, use :class:`match_previous_expr`. Do *not* use with packrat parsing enabled. có°•—|rFt|«dk(r ‰|dzyt|j««}‰td„|D««zy‰t «zy)Nrrc3ó2K—|]}t|«–—Œyw©N)ÚLiteral)Ú.0Útts rÚ zImatch_previous_literal..copy_token_to_repeater..hsèø€Ð7±¨2œ7 2Ÿ;±ùó‚)ÚlenrÚas_listÚAndr)rrrÚtflatÚreps €rÚcopy_token_to_repeaterz6match_previous_literal..copy_token_to_repeaterasJø€ÙÜ1‹v˜Š{Øq˜‘t“ô! §¡£Ó-Ø”sÑ7±Ó7Ó7Ó7à”5“7‹NrT©Ú callDuringTryú(prev) )r r&r%r')rr7r6s @rÚmatch_previous_literalr;PsAø€ô‹)€Cô ð ×ÑÐ0ÀÐÔEØ‡LLœS ›YÑ&Ô'Ø€Jrcó°‡—t«Š|j«}‰|zŠˆfd„}|j|d¬«‰jdt |«z«‰S)aWHelper to define an expression that is indirectly defined from the tokens matched in a previous expression, that is, it looks for a 'repeat' of a previous expression. For example:: first = Word(nums) second = match_previous_expr(first) match_expr = first + ":" + second will match ``"1:1"``, but not ``"1:2"``. Because this matches by expressions, will *not* match the leading ``"1:1"`` in ``"1:10"``; the expressions are evaluated first, and then compared, so ``"1"`` is compared with ``"10"``. Do *not* use with packrat parsing enabled. cój•‡—t|j««Šˆfd„}‰j|d¬«y)Ncóh•—t|j««}|‰k7rt||d‰›d|›«‚y)Nz Expected z, found)rr3ÚParseException)rrrÚtheseTokensÚmatchTokenss €rÚmust_match_these_tokenszTmatch_previous_expr..copy_token_to_repeater..must_match_these_tokens‡sAø€Ü" 1§9¡9£;Ó/ˆKØ˜kÒ)Ü$Øq˜I k ]°'¸+¸ÐGóðð*rTr8)rr3r#)rrrrBrAr6s @€rr7z3match_previous_expr..copy_token_to_repeater„s.ù€Ü˜qŸy™y›{Ó+ˆô ð ×ÑÐ4ÀDÐÕIrTr8r:)r r$r&r%r')rÚe2r7r6s @rÚmatch_previous_exprrDqsVø€ô‹)€CØ ‰‹€BØˆBJ€Cô Jð ×ÑÐ0ÀÐÔEØ‡LLœS ›YÑ&Ô'Ø€JrFT)ÚuseRegexÚ asKeywordÚstrsÚcaselessÚ use_regexÚ as_keywordrErFcóH‡‡—|xs|}|xr|}t|t«r'tjrtjdd¬«|rd„}d„}|rtntŠnd„}d„}|rtntŠg}t|t«r+tjt|«}|j«}n't|t«rt|«}nt!d«‚|s t#«St%d „|D««r‚d } | t'|«dz kro|| } t)|| dzd«D]?\}}||| «r|| |zdz=n-|| |«sŒ$|| |zdz=|j+| |«n| dz } | t'|«dz krŒo|rÆ|rt,j.nd } t1d „|D««rddj3d„|D««›d}ndj3d„|D««}|rd|›d}t5|| ¬«j7dj3|««}|r3|Dcic]}|j9«|“Œc}Š|j;ˆfd„«|St?ˆfd„|D««j7dj3|««Scc}w#t,j<$rtjdd¬«YŒcwxYw)a!Helper to quickly define a set of alternative :class:`Literal` s, and makes sure to do longest-first testing when there is a conflict, regardless of the input order, but returns a :class:`MatchFirst` for best performance. Parameters: - ``strs`` - a string of space-delimited literals, or a collection of string literals - ``caseless`` - treat all literals as caseless - (default= ``False``) - ``use_regex`` - as an optimization, will generate a :class:`Regex` object; otherwise, will generate a :class:`MatchFirst` object (if ``caseless=True`` or ``as_keyword=True``, or if creating a :class:`Regex` raises an exception) - (default= ``True``) - ``as_keyword`` - enforce :class:`Keyword`-style matching on the generated expressions - (default= ``False``) - ``asKeyword`` and ``useRegex`` are retained for pre-PEP8 compatibility, but will be removed in a future release Example:: comp_oper = one_of("< = > <= >= !=") var = Word(alphas) number = Word(nums) term = var | number comparison_expr = term + comp_oper + term print(comparison_expr.search_string("B = 12 AA=23 B<=AA AA>12")) prints:: [['B', '=', '12'], ['AA', '=', '23'], ['B', '<=', 'AA'], ['AA', '>', '12']] z`More than one string argument passed to one_of, pass choices as a list or space-delimited stringé)Ú stacklevelcóD—|j«|j«k(Sr,)Úupper©ÚaÚbs rrzone_of..Ìs€˜qŸw™w›y¨A¯G©G«IÒ5rcó\—|j«j|j««Sr,)rOÚ startswithrPs rrzone_of..Ís€˜QŸW™W›Y×1Ñ1°!·'±'³)Ô.Ðs€˜q Ašvrcó$—|j|«Sr,)rTrPs rrzone_of..Ñs€˜QŸ\™\¨!œ_rz7Invalid argument to one_of, expected string or iterablec3ó8K—|]}t|«dkD–—Œyw©rN©r2©r.Úsyms rr0zone_of..ásèø€Ð +¡7˜CŒ3ˆs‹8a<¡7ùó‚rrNc3ó8K—|]}t|«dk(–—ŒywrYrZr[s rr0zone_of..ôsèø€Ð4©G S”3s“8˜q•=©Gùr]Ú[Úc3ó2K—|]}t|«–—Œywr,)rr[s rr0zone_of..ösèø€Ð"UÉWÀcÔ#<¸S×#AÉWùr1Ú]Ú|c3óFK—|]}tj|«–—Œywr,)ÚreÚescaper[s rr0zone_of..øsèø€ÐB¹'°3¤§ ¡ ¨#§¹'ùs‚!z\b(?:z)\b)Úflagsz | có0•—‰|dj«Sr©Úlower)rrrÚ symbol_maps €rrzone_of..sø€°ZÀÀ!ÁÇ Á ÃÒ5Mrz8Exception creating Regex for one_of, building MatchFirstc3ó.•K—|]}‰|«–—Œywr,rV)r.r\ÚparseElementClasss €rr0zone_of..søèø€Ð@¹°Ñ'¨×,¹ùsƒ) Ú isinstanceÚstr_typerÚ%warn_on_multiple_string_args_to_oneofÚwarningsÚwarnÚCaselessKeywordÚCaselessLiteralÚKeywordr-ÚtypingÚcastr'ÚsplitÚIterableÚlistÚ TypeErrorÚNoMatchÚanyr2Ú enumerateÚinsertreÚ IGNORECASEÚallÚjoinÚRegexr%rjr&ÚerrorÚ MatchFirst)rGrHrIrJrErFÚisequalÚmasksÚsymbolsÚiÚcurÚjÚotherÚre_flagsÚpattÚretr\rmrks @@rÚone_ofr•sžù€ðRÒ'˜Z€IØÒ%˜I€Hô 8œXÔ&Ü×:Ò:ä ‰ ð ;àð ô ñÙ5ˆÙ<ˆÙ/8O¼oÑá%ˆÙ,ˆÙ'0G´gÐà€GÜ$œÔ!Ü{‰{œ3 Ó%ˆØ—*‘*“,‰Ü Dœ(Ô #Üt“*‰äÐQÓRÐRÙÜ‹yÐôÑ +¡7Ó +Ô+Ø ˆØ”#g“, Ñ"Ò"Ø˜!‘*ˆCÜ% g¨a°!©e¨gÐ&6Ö7‘5Ù˜5 #Ô&Ø A¡¨¡ Ð*ÙÙ˜3 Õ&Ø A¡¨¡ Ð*Ø—N‘N 1 eÔ,Ùð8ðQ‘ð”#g“, Ñ"Ó"ñÙ)1œŸ š °qˆð ÜÑ4©GÓ4Ô4à˜2Ÿ7™7Ñ"UÉWÓ"UÓUÐVÐVWÐX‘à—x‘xÑB¹'ÓBÓBñØ ˜v SÐ)ä˜ HÔ-×6Ñ6°u·z±zÀ'Ó7JÓKˆCáñ;BÓB¹'°3˜cŸi™i›k¨3Ñ.¸'ÑB Ø×$Ñ$Ó%MÔNàˆJôÓ@¹Ó@Ó@×IÑIØ ‰ 7ÓóðùòCøô x‰xò ÜM‰MØJÐWXð ö ð ús%ÆBI4ÈI/È$I4É/I4É4*J!Ê J!ÚkeyÚvaluecóB—ttt||z«««S)aøHelper to easily and clearly define a dictionary by specifying the respective patterns for the key and value. Takes care of defining the :class:`Dict`, :class:`ZeroOrMore`, and :class:`Group` tokens in the proper order. The key pattern can include delimiting markers or punctuation, as long as they are suppressed, thereby leaving the significant key text. The value pattern can include named results, so that the :class:`Dict` results can include named token fields. Example:: text = "shape: SQUARE posn: upper left color: light blue texture: burlap" attr_expr = (label + Suppress(':') + OneOrMore(data_word, stop_on=label).set_parse_action(' '.join)) print(attr_expr[1, ...].parse_string(text).dump()) attr_label = label attr_value = Suppress(':') + OneOrMore(data_word, stop_on=label).set_parse_action(' '.join) # similar to Dict, but simpler call format result = dict_of(attr_label, attr_value).parse_string(text) print(result.dump()) print(result['shape']) print(result.shape) # object attribute access works too print(result.as_dict()) prints:: [['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'light blue'], ['texture', 'burlap']] - color: 'light blue' - posn: 'upper left' - shape: 'SQUARE' - texture: 'burlap' SQUARE SQUARE {'color': 'light blue', 'shape': 'SQUARE', 'posn': 'upper left', 'texture': 'burlap'} )ÚDictÚ OneOrMoreÚGroup)r‘r’s rÚdict_ofr—s€ôJ” œ% e¡Ó,Ó-Ó.Ð.r)ÚasStringÚ as_stringr˜có0—|xr|}t«jd„«}|j«}d|_|d«|z|d«z}|rd„}nd„}|j|«|j|_|jtj«|S)a Helper to return the original, untokenized text for a given expression. Useful to restore the parsed fields of an HTML start tag into the raw tag text itself, or to revert separate tokens with intervening whitespace back to the original matching input text. By default, returns a string containing the original parsed text. If the optional ``as_string`` argument is passed as ``False``, then the return value is a :class:`ParseResults` containing any results names that were originally matched, and a single token containing the original matched text from the input string. So if the expression passed to :class:`original_text_for` contains expressions with defined results names, you must set ``as_string`` to ``False`` if you want to preserve those results name values. The ``asString`` pre-PEP8 argument is retained for compatibility, but will be removed in a future release. Example:: src = "this is test bold text normal text " for tag in ("b", "i"): opener, closer = make_html_tags(tag) patt = original_text_for(opener + ... + closer) print(patt.search_string(src)[0]) prints:: [' bold text '] ['text'] có—|Sr,rV)rÚlocrs rrz#original_text_for.._s€¹3rFÚ_original_startÚ _original_endcó4—||j|jSr,)rrž©rrrs rrz#original_text_for..ds€ a¨×(9Ñ(9¸A¿O¹OÑ&LrcóR—||jd«|jd«g|ddy)Nrrž©Úpopr s rÚextractTextz&original_text_for..extractTextgs(€Øa—e‘eÐ-Ó.°·±°Ó1GÐHÐIˆA‰a‰Dr)rr#r$ÚcallPreparseÚignoreExprsÚsuppress_warningÚDiagnosticsÚ)warn_ungrouped_named_tokens_in_collection)rr™r˜Ú locMarkerÚendlocMarkerÚ matchExprr¤s rÚoriginal_text_forr;s–€ðDÒ%˜I€Hä“×(Ñ(Ñ)>Ó?€IØ—>‘>Ó#€LØ %€LÔÙÐ+Ó,¨tÑ3±lÀ?Ó6SÑS€IÙÙL‰ò Jð×Ñ˜{Ô+Ø ×,Ñ,€IÔØ ×Ñœ{×TÑTÔUØÐrcó8—t|«jd„«S)zkHelper to undo pyparsing's default grouping of And expressions, even if all but one are non-empty. có—|dSrrVrs rrzungroup..ts€¸1¸Qº4r)ÚTokenConverterr&)rs rÚungroupr±ps€ô˜$Ó×0Ñ0±Ó@Ð@rcó´—t«jd„«}t|d«|d«z|j«j «d«z«S)a (DEPRECATED - future code should use the :class:`Located` class) Helper to decorate a returned token with its starting and ending locations in the input string. This helper adds the following results names: - ``locn_start`` - location where matched expression begins - ``locn_end`` - location where matched expression ends - ``value`` - the actual parsed results Be careful if the input text contains ```` characters, you may want to call :class:`ParserElement.parse_with_tabs` Example:: wd = Word(alphas) for match in locatedExpr(wd).search_string("ljsdf123lksdjjf123lkkjj1222"): print(match) prints:: [[0, 'ljsdf', 5]] [[8, 'lksdjjf', 15]] [[18, 'lkkjj', 23]] có—|Sr,rV)ÚssÚllr/s rrzlocatedExpr..’s€¹"rÚ locn_startr’Úlocn_end)rr#r–r$ÚleaveWhitespace)rÚlocators rÚlocatedExprrºwsV€ô6‹g×&Ñ&Ñ'<Ó=€GÜÙÓÙ ˆw‹-ñ à *ˆ',‰,‹.× (Ñ (Ó *¨:Ó 6ñ 7óðrÚ(Ú))Ú ignoreExprÚopenerÚcloserÚcontentÚignore_exprr½c óô—||k7r|t«k(r|n|}||k(rtd«‚|€Ãt|t«r§t|t«r–t j t|«}t j t|«}t|«dk(ržt|«dk(r|Itt|t||ztjzd¬«z««jd„«}ntj«t||ztjz«jd„«z}nÁ|\tt|t!|«zt!|«zttjd¬«z««jd„«}ncttt!|«t!|«zttjd¬«z««jd„«}ntd«‚t#«}|6|t%t'|«t)||z|z«zt'|«z«z}n2|t%t'|«t)||z«zt'|«z«z}|j+d |›|›d «|S)a& Helper method for defining nested lists enclosed in opening and closing delimiters (``"("`` and ``")"`` are the default). Parameters: - ``opener`` - opening character for a nested list (default= ``"("``); can also be a pyparsing expression - ``closer`` - closing character for a nested list (default= ``")"``); can also be a pyparsing expression - ``content`` - expression for items within the nested lists (default= ``None``) - ``ignore_expr`` - expression for ignoring opening and closing delimiters (default= :class:`quoted_string`) - ``ignoreExpr`` - this pre-PEP8 argument is retained for compatibility but will be removed in a future release If an expression is not provided for the content argument, the nested expression will capture all whitespace-delimited content between delimiters as a list of separate values. Use the ``ignore_expr`` argument to define expressions that may contain opening or closing characters that should not be treated as opening or closing characters for nesting, such as quoted_string or a comment expression. Specify multiple expressions using an :class:`Or` or :class:`MatchFirst`. The default is :class:`quoted_string`, but if no expressions are to be ignored, then pass ``None`` for this argument. Example:: data_type = one_of("void int short long char float double") decl_data_type = Combine(data_type + Opt(Word('*'))) ident = Word(alphas+'_', alphanums+'_') number = pyparsing_common.number arg = Group(decl_data_type + ident) LPAR, RPAR = map(Suppress, "()") code_body = nested_expr('{', '}', ignore_expr=(quoted_string | c_style_comment)) c_function = (decl_data_type("type") + ident("name") + LPAR + Opt(DelimitedList(arg), [])("args") + RPAR + code_body("body")) c_function.ignore(c_style_comment) source_code = ''' int is_odd(int x) { return (x%2); } int dec_to_hex(char hchar) { if (hchar >= '0' && hchar <= '9') { return (ord(hchar)-ord('0')); } else { return (10+ord(hchar)-ord('A')); } } ''' for func in c_function.search_string(source_code): print("%(name)s (%(type)s) args: %(args)s" % func) prints:: is_odd (int) args: [['int', 'x']] dec_to_hex (int) args: [['char', 'hchar']] z.opening and closing strings cannot be the samer)Úexactcó(—|dj«Sr©Ústriprs rrznested_expr..÷ó€°°1±·±´rcó(—|dj«SrrÅrs rrznested_expr..ûrÇrcó(—|dj«SrrÅrs rrznested_expr..rÇrcó(—|dj«SrrÅrs rrznested_expr.. rÇrzOopening and closing arguments must be strings if no content expression is givenznested z expression)Ú quoted_stringÚ ValueErrorrnrorvrwr'r2ÚCombiner•Ú CharsNotInÚ ParserElementÚDEFAULT_WHITE_CHARSr#Úemptyr$r-r r–ÚSuppressÚ ZeroOrMorer%)r¾r¿rÀrÁr½rs rÚnested_exprrÔšs`€ðV[Ò Ø$.´-³/Ò$A‘[Àzˆ Ø ÒÜÐIÓJÐJØÜfœhÕ'¬J°v¼xÕ,HÜ—[‘[¤ fÓ-ˆFÜ—[‘[¤ fÓ-ˆFÜ6‹{˜aÒ¤C¨£K°1Ò$4ØÐ)Ü%Ü!Ø'˜KÜ(Ø &¨¡´-×2SÑ2SÑ SØ&'ôñóó÷'Ñ&Ñ'=Ó>òô$Ÿj™j›l¬ZØ ™¬-×*KÑ*KÑKó.ç&Ñ&Ñ'=Ó>ñ?‘GðÐ)Ü%Ü!Ø'˜KÜ& v›Ð.ñ/ä& v›Ð.ñ/ô)¬×)JÑ)JÐRSÔTñUóó÷'Ñ&Ñ'=Ó>ñô&Ü!Ü$ V›_Ð,Ü& v›Ð.ñ/ä(¬×)JÑ)JÐRSÔTñUóó÷'Ñ&Ñ'=Ó>ñ ôØaóð ô‹)€CØÐØ”ÜVÓœz¨*°sÑ*:¸WÑ*DÓEÑEÌÐQWÓHXÑXó ñ ‰ð ””h˜vÓ&¬°C¸'±MÓ)BÑBÄXÈfÓEUÑUÓVÑVˆØ‡L‚L©V²VÐ<Ô=Ø€JrÚ<Ú>c óŠ‡—t|t«r|Št||¬«}n|jŠt t tdz«}|rˆtj«jt«}||d«zttt|td«z|z«««ztddg¬«d«jd „«z|z}n²t j«jt«t t"d ¬«z}||d«zttt|jd„«ttd«|z«z«««ztddg¬«d«jd „«z|z}t%t'd«|zd zd¬«}|j)d‰z«|j+ˆfd„«|ddj-‰j/dd«j1«j3««z«j)d‰z«}‰|_‰|_t7|««|_||fS)zRInternal helper to construct opening and closing tag expressions, given a tag name)rHz_-:ÚtagÚ=Ú/F)ÚdefaultrÑcó—|ddk(S©NrrÚrVr s rrz_makeTags..-ó€ !¡¨¢rrÖ)Ú exclude_charscó(—|dj«Srrirs rrz_makeTags..;s€¸qÀ¹t¿z¹z¼|rcó—|ddk(SrÝrVr s rrz_makeTags..ArÞrzc óÀ•—|jddj‰jdd«j«j ««z|j««S)NÚstartr`Ú:Ú )Ú__setitem__r‚ÚreplaceÚtitlerxr$)rÚresnames €rrz_makeTags..JsDø€!—-‘-Øb—g‘g˜gŸo™o¨c°3Ó7×=Ñ=Ó?×EÑEÓGÓHÑHÈ!Ï&É&Ë(ô rÚendr`råræz)rnroruÚnamer!ÚalphasÚ alphanumsÚdbl_quoted_stringr$r#Ú remove_quotesr”rÓr–rÒÚOptrËÚ printablesrÍr-r%r&r‚rèrérxrØÚSkipToÚtag_body) ÚtagStrÚxmlÚsuppress_LTÚsuppress_GTÚtagAttrNameÚtagAttrValueÚopenTagÚcloseTagrês @rÚ _makeTagsrýs1ø€ä&œ(Ô#ØˆÜ˜¨c¨'Ô2‰à—+‘+ˆä”vœy¨5Ñ0Ó1€KÙ Ü(×-Ñ-Ó/×@Ñ@ÄÓOˆàÙU‹mñ ä”:œe K´(¸3³-Ñ$?À,Ñ$NÓOÓPÓQñ Rð(Œc# ˜wÔ'¨Ó0×AÑAÙ+óñ ðñ ñ ô%×)Ñ)Ó+×<Ñ<¼]ÓKÌdÜ côO ñ ˆð ÙU‹mñ äÜÜØ#×4Ñ4Ñ5KÓLÜœh s›m¨lÑ:Ó;ñ<óóóñ ð(Œc# ˜wÔ'¨Ó0×AÑAÙ+óñ ðñ ð ô ”w˜t“} vÑ-°Ñ3¸eÔD€Hà×ÑV˜gÑ%Ô&à×Ñó ôñ Ø —‘˜Ÿ™¨¨SÓ1×7Ñ7Ó9×?Ñ?ÓAÓBÑBóçhˆw˜Ñ Ó!ð ð€G„KØ€H„LÜ™h›jÓ)€GÔØHÐÐrÚtag_strcó—t|d«S)aPHelper to construct opening and closing tag expressions for HTML, given a tag name. Matches tags in either upper or lower case, attributes with namespaces and with quoted or unquoted values. Example:: text = 'More info at the pyparsing wiki page' # make_html_tags returns pyparsing expressions for the opening and # closing tags as a 2-tuple a, a_end = make_html_tags("A") link_expr = a + SkipTo(a_end)("link_text") + a_end for link in link_expr.search_string(text): # attributes in the tag (like "href" shown here) are # also accessible as named results print(link.link_text, '->', link.href) prints:: pyparsing -> https://github.com/pyparsing/pyparsing/wiki F©rý©rþs rÚmake_html_tagsrWs€ô0W˜eÓ$Ð$rcó—t|d«S)z½Helper to construct opening and closing tag expressions for XML, given a tag name. Matches tags only in the given upper/lower case. Example: similar to :class:`make_html_tags` Trrs rÚ make_xml_tagsrrs€ôW˜dÓ#Ð#rÚany_open_tagÚ any_close_tagz_:zany tagÚ;z&(?Prcz);zcommon HTML entitycó@—tj|j«S)zRHelper parser action to replace common HTML entities with their special characters)Ú_htmlEntityMapÚgetÚentityr s rÚreplace_html_entityr‰s€ä×Ñ˜aŸh™hÓ'Ð'rcó—eZdZdZdZdZy)ÚOpAssoczvEnumeration of operator associativity - used in constructing InfixNotationOperatorSpec for :class:`infix_notation`rrLN)Ú__name__Ú __module__Ú__qualname__Ú__doc__ÚLEFTÚRIGHTrVrrrrŽs„ñTð €DØ ErrÚ base_exprÚop_listÚlparÚrparc óH—Gd„dt«}d|_t«}t|t«rt|«}t|t«rt|«}t|t «rt|t «s|t ||z|z«z}n|||z|zz}t|«D]÷\}}|dzdd\} } }}t| t«rtj| «} tjt| «} | dk(r._FBcóB—|jj||«|gfSr,)rÚ try_parse)ÚselfÚinstringrœÚ doActionss rÚ parseImplz%infix_notation.._FB.parseImplÿs€ØI‰I×Ñ ¨#Ô.Ø˜7ˆNrN©T)rrrr!rVrrÚ_FBrþs„ô rr#zFollowedBy>r,NéérLz@if numterms=3, opExpr must be a tuple or list of two expressionsz termrz6operator must be unary (1), binary (2), or ternary (3)z2operator must indicate right or left associativity)r.)rL.)Ú FollowedByrr rnr'rÒr–r~rorÏÚ_literalStringClassrvrwÚtuplerzr2rÌrrrr%r•rñrr#ÚsetName)rrrrr#rÚlastExprr‰ÚoperDefÚopExprÚarityÚrightLeftAssocÚpaÚopExpr1ÚopExpr2Ú term_nameÚthisExprr¬s rÚinfix_notationr4¨sè€ôlŒjôð !€C„Lä ‹)€CÜ$œÔÜ˜‹~ˆÜ$œÔÜ˜‹~ˆô tœXÔ&¬:°d¼HÔ+EØœu T¨C¡Z°$Ñ%6Ó7Ñ7‰à s¡ ¨TÑ 1Ñ2ˆô ×(‰ ˆˆ7Ø-4°wÑ->ÀÀÐ,CÑ)ˆ~ rÜfœhÔ'Ü"×6Ñ6°vÓ>ˆFÜ—‘œ]¨FÓ3ˆØAŠ:Ü˜f¤u¬d mÔ4¼¸F»ÀqÒ8HÜ ØVóðð &ÑˆGWØ"˜) G 9¨EÐ2‰Ià!˜( %Ð(ˆIàEŒ˜QŠÜÐUÓVÐVðÜÐUÓVÐVà¤'§,¡,´· ± Ð!>Ñ>ÜÐQÓRÐRä")£)×"4Ñ"4°YÓ"?ˆÜ—;‘;œw¨Ó1ˆØœWŸ\™\Ñ)Ø˜ŠzÙ ¨6Ñ 1Ó2´U¸8ÀfÈVÁnÑ;TÓ5UÑU’ Ø˜!’ØÐ%Ù # H¨vÑ$5¸Ñ$@Ó AÄEØ F¨XÑ$5°vÑ#>Ñ>óEñ!’Iñ!$ H¨xÑ$7Ó 8¼5ÀÈ&ÑAQÓ;RÑ R’IØ˜!“ÙØ˜wÑ&¨Ñ1°GÑ;¸hÑFóä˜(¤Y¨w¸Ñ/AÀGÑ/KÈhÑ/VÓ%WÑWÓXñY‘ ðœwŸ}™}Ñ ,Ø˜Šzä! &¬#Ô.Ü ›[FÙ §¡¨hÑ 6Ó7¼%ÀÈÑ@QÓ:RÑR‘ Ø˜!’ØÐ%Ù # H¨vÑ$5¸Ñ$@Ó AÄEØ F¨XÑ$5°vÑ#>Ñ>óEñ!‘Iñ!$ H¨xÑ$7Ó 8¼5Ø 8¨FÑ#3Ñ3ó<ñ!‘Ið˜!’ÙØ˜wÑ&¨Ñ1°GÑ;¸hÑFóä˜( WÑ,¨xÑ7¸'ÑAÀHÑLÓMñN ñÜ˜"œu¤d˜mÔ,Ø* ×*Ñ*¨BÒ/à×*Ñ*¨2Ô.Øi (Ñ*×3Ñ3°IÓ>Ñ>ˆØŠð})ð~ˆHÑ€CØ€Jrc ó|‡‡‡—‰j‰dd«ˆˆfd„Šˆfd„}ˆfd„}ˆfd„}tt«jd«j ««}t«t«j |«zjd«}t«j |«jd«} t«j |«jd «} |r?tt|«|zt| t|«zt|«z«z| z«}nDtt|«t| t|«zt|«z«zt| «z«}|jˆfd „«|jˆfd„«|jtt«z«|jd«S) aš (DEPRECATED - use :class:`IndentedBlock` class instead) Helper method for defining space-delimited indentation blocks, such as those used to define block statements in Python source code. Parameters: - ``blockStatementExpr`` - expression defining syntax of statement that is repeated within the indented block - ``indentStack`` - list created by caller to manage indentation stack (multiple ``statementWithIndentedBlock`` expressions within a single grammar should share a common ``indentStack``) - ``indent`` - boolean indicating whether block must be indented beyond the current level; set to ``False`` for block of left-most statements (default= ``True``) A valid block must contain at least one ``blockStatement``. (Note that indentedBlock uses internal parse actions which make it incompatible with packrat parsing.) Example:: data = ''' def A(z): A1 B = 100 G = A2 A2 A3 B def BB(a,b,c): BB1 def BBA(): bba1 bba2 bba3 C D def spam(x,y): def eggs(z): pass ''' indentStack = [1] stmt = Forward() identifier = Word(alphas, alphanums) funcDecl = ("def" + identifier + Group("(" + Opt(delimitedList(identifier)) + ")") + ":") func_body = indentedBlock(stmt, indentStack) funcDef = Group(funcDecl + func_body) rvalue = Forward() funcCall = Group(identifier + "(" + Opt(delimitedList(rvalue)) + ")") rvalue << (funcCall | identifier | Word(nums)) assignment = Group(identifier + "=" + rvalue) stmt << (funcDef | assignment | identifier) module_body = stmt[1, ...] parseTree = module_body.parseString(data) parseTree.pprint() prints:: [['def', 'A', ['(', 'z', ')'], ':', [['A1'], [['B', '=', '100']], [['G', '=', 'A2']], ['A2'], ['A3']]], 'B', ['def', 'BB', ['(', 'a', 'b', 'c', ')'], ':', [['BB1'], [['def', 'BBA', ['(', ')'], ':', [['bba1'], ['bba2'], ['bba3']]]]]], 'C', 'D', ['def', 'spam', ['(', 'x', 'y', ')'], ':', [[['def', 'eggs', ['(', 'z', ')'], ':', [['pass']]]]]]] Ncó•—‰d‰ddy©NéÿÿÿÿrV)Ú backup_stacksÚindentStacks€€rÚreset_stackz"indentedBlock..reset_stack±sø€Ø& rÑ*ˆ‘A‰rcó•—|t|«k\ryt||«}|‰dk7r"|‰dkDr t||d«‚t||d«‚y)Nr8zillegal nestingznot a peer entry)r2Úcolr?©rrrÚcurColr:s €rÚcheckPeerIndentz&indentedBlock..checkPeerIndent´sYø€Ø”A“Š;ØÜQ˜“ˆØ[ ‘_Ò$Ø˜ B™Ò'Ü$ Q¨Ð+<Ó=Ð=Ü AÐ'9Ó:Ð:ð%rcój•—t||«}|‰dkDr‰j|«yt||d«‚)Nr8znot a subentry)r=Úappendr?r>s €rÚcheckSubIndentz%indentedBlock..checkSubIndent½s8ø€ÜQ˜“ˆØK ‘OÒ#Ø×Ñ˜vÕ&ä AÐ'7Ó8Ð8rcó”•—|t|«k\ryt||«}‰r|‰vs t||d«‚|‰dkr‰j«yy)Nznot an unindentr8)r2r=r?r£r>s €rÚ checkUnindentz$indentedBlock..checkUnindentÄsQø€Ø”A“Š;ØÜQ˜“ˆÙ ¨+Ñ 5Ü AÐ'8Ó9Ð9ØK ‘OÒ#ØO‰OÕð$rz ÚINDENTr`ÚUNINDENTcó6•—‰r‰jd«xrdSdSr7r¢)r9s€rrzindentedBlock..ásø€±- ×!Ñ! "Ó%Ò.¨$ÐIÀTÐIrcó•—‰«Sr,rV)rQrRÚcÚdr;s €rrzindentedBlock..ãsø€©k¬mrzindented block)rBr•ÚLineEndÚset_whitespace_charsÚsuppressrr#r%r–rñr&Úset_fail_actionÚignorer) ÚblockStatementExprr:Úindentr9r@rCrEÚNLrFÚPEERÚUNDENTÚsmExprr;s ` ` @rÚ indentedBlockrWYs~ú€ðl×Ñ˜¡Q˜Ô(õ+ô;ô9ôô ”7“9×1Ñ1°%Ó8×AÑAÓCÓ D€BÜ‹gœ›×0Ñ0°Ó@Ñ@× JÑ JÈ8Ó T€FÜ‹7×#Ñ# OÓ4×=Ñ=¸bÓA€DÜ ‹W× %Ñ % mÓ 4× =Ñ =¸jÓ I€FÙ ÜÜ‹GØñ ä˜œuÐ%7Ó8Ñ8¼3¸r»7ÑBÓCñ Dðñ ó ‰ôÜ‹GÜ˜œuÐ%7Ó8Ñ8¼3¸r»7ÑBÓCñ Dä&‹kñ ó ˆð×ÑÛIôð×ÑÓ;Ô<Ø×Ñœg¬« Ñ1Ô2Ø?‰?Ð+Ó,Ð,rz/\*(?:[^*]|\*(?!/))*z*/zC style commentzzHTML commentz.*zrest of linez//(?:\\\n|[^\n])*z // commentzC++ style commentz#.*zPython style commentÚ_builtin_exprs©Úallow_trailing_delimÚdelimÚcombineÚminÚmaxrZcó$—t||||||¬«S)z/(DEPRECATED - use :class:`DelimitedList` class)rY)Ú DelimitedList)rr[r\r]r^rZs rÚdelimited_listra s€ôØˆeW˜c 3Ð=Qôðrcó—yr,rVrVrrÚ delimitedListrc&ó€Ørcó—yr,rVrVrrrara)s€Ørcó—yr,rVrVrrÚcountedArrayrg,ó€Ørcó—yr,rVrVrrÚmatchPreviousLiteralrj/s€Ørcó—yr,rVrVrrÚmatchPreviousExprrl2ó€Ørcó—yr,rVrVrrÚoneOfro5s€Ø rcó—yr,rVrVrrÚdictOfrq8s€Ørcó—yr,rVrVrrÚoriginalTextForrs;s€Ørcó—yr,rVrVrrÚ nestedExprru>s€Ørcó—yr,rVrVrrÚmakeHTMLTagsrwArhrcó—yr,rVrVrrÚmakeXMLTagsryDs€Ørcó—yr,rVrVrrÚreplaceHTMLEntityr{Grmrcó—yr,rVrVrrÚ infixNotationr}Jrdrr,)FTFr")Ú,FNN)aÚ html.entitiesÚhtmlreÚsysrvr`rÚcoreÚutilrrrr rÏÚOptionalr(r;rDÚUnionryr'Úboolrr—rr±rºrËrÔrÒrýÚTuplerrÚ__annotations__r!rírîr%rrÚentitiesÚhtml5ÚitemsÚrstripr rƒr‚Úcommon_html_entityrÚEnumrÚInfixNotationOperatorArgTyperÚParseActionÚInfixNotationOperatorSpecÚListr4rWrÍÚc_style_commentÚhtml_commentÚleave_whitespaceÚrest_of_lineÚdbl_slash_commentÚcpp_style_commentÚjava_style_commentÚpython_style_commentÚvarsÚvaluesrnrXraÚopAssocÚ anyOpenTagÚanyCloseTagÚcommonHTMLEntityÚ cStyleCommentÚhtmlCommentÚ restOfLineÚdblSlashCommentÚcppStyleCommentÚjavaStyleCommentÚpythonStyleCommentr`rcrgrjrlrorqrsrurwryr{r})ÚkÚvs00rÚrªsæðäÛ Û Û åÜ÷óð04ð9Ið/3ò 9IØ ð9Iào‰o˜mÑ,ð9Ið_‰_˜]Ñ +ð 9Ið ó9Iðx ð°=óðB!˜mð!° ó!ðLØØð {ðØò{Ø —‘ Ñ$ cÐ)Ñ *ð{àð{ðð{ðð {ðð {ðð{ðó{ð|%/ð%/ }ð%/¸ó%/ðR,0ð2ØEIò2Ø ð2Ø$(ð2Ø>Bð2àó2ðjA-ðA MóAð mð ¨ ó ðH),Ø(+Ø.2Ù!.£ð @ñ!.£ò @Ø#}Ð$Ñ%ð@à#}Ð$Ñ%ð@ð_‰_˜]Ñ +ð@ðð @ðð @ðó@ñF(0°£}Á(È3Ã-ó7ðt%Ø 3˜ Ð%Ñ &ð%à ˆ=˜-Ð'Ñ(ó%ð6$Ø 3˜ Ð%Ñ &ð$à ˆ=˜-Ð'Ñ(ó$ðÓØÓÙ,Ùˆ˜TÑ!Ó"×+Ñ+¨IÓ6óÑ€ˆmð04¯}©}×/BÑ/B×/HÑ/HÔ/JÔKÑ/J¡t q¨!!—(‘(˜3“- Ñ"Ð/JÒK€Ù˜>¨C¯H©H°^Ó,DÑDÀtÑKÓL×UÑUØóÐò (ô ˆdôð %Ø3˜˜e M°3Ð$6Ñ7¸¸}ÈcÐ?QÑ9RÐRÑSÐSñ Ðð"Ø Ø$ØØØ‰˜Ñ$ð &ñð Ø$ØØð ñð ñÐñ$'/¨s£mÙ&.¨s£mñ nØðnà Ð+Ñ ,ðnð]Ð"Ñ #ðnð]Ð"Ñ #ð nð ónðb;?ÈbóL-ñ`™%Ð 7Ó8¸4Ñ?Ó@×IÑIØó€ð$áÐ'Ó(×1Ñ1°.ÓA€Ø&áU‹|×,Ñ,Ó.×7Ñ7¸ÓG€ÙÐ.Ó/×8Ñ8¸ÓFÐØ1áÙ Ð !Ó" TÑ)Ð,=Ñ=óç (ÐÓððPà&ÐØ$á˜V“}×-Ñ-Ð.DÓEÐØ0ñ‹v}‰}Œó'Ùˆ!¡*¨Q° Õ">‚Aˆñ'€]Ñ#óð(+ØØ $Ø $ðð"'òØ ]Ð"Ñ #ðàmÐ#Ñ$ðððð ‰˜Ñ ð ð ‰˜Ñ ððððóð"€Ø € Ø€Ø%ÐØ€ Ø€Ø € Ø#€Ø#€Ø%ÐØ)Ðá-Ó Ùó!Øá-Ó Ùó!Øá-Ó Ùó!ØáÐ(Ó)Ùó*ØáÐ%Ó&Ùó'Øá&ÓÙóØá'ÓÙóØáÐ#Ó$Ùó%Øá+ÓÙóØá.Ó!Ùó"Øá-Ó Ùó!ØáÐ%Ó&Ùó'Øá.Ó!Ùó"ÙùóQLùò@'sÅ?P6Ì P<ÌP<