⚝
One Hat Cyber Team
⚝
Your IP:
216.73.216.144
Server IP:
157.245.143.252
Server:
Linux www 6.11.0-9-generic #9-Ubuntu SMP PREEMPT_DYNAMIC Mon Oct 14 13:19:59 UTC 2024 x86_64
Server Software:
nginx/1.26.0
PHP Version:
8.3.11
Buat File
|
Buat Folder
Eksekusi
Dir :
~
/
lib
/
python3
/
dist-packages
/
pyparsing
/
__pycache__
/
View File Name :
helpers.cpython-312.pyc
e fZ U d dl Zd dlZd dlZd dlZddlmZ ddl ddlm Z m Z m Z m Z dcddde dej e d ej e d e fd Zde d e fd Zde d e fd Z ddddddeej& e ef dededededed e fdZde de d e fdZ deddde d ed ed e fd Zde d e fd Zde d e fd Zd!d"d e f e d#d$eee f d%eee f d&ej e d'e d(e d e f d)Z e d* e d+ fd,Z d-eee f d e e e f fd.Z d-eee f d e e e f fd/Z!e e"d0< e e"d1< e e#e$e%d2z jM d3 \ Z'Z(ejR jT jW D ci c] \ } }| jY d4 | c}} Z- e.d5d6j_ e- z d7z jM d8 Z0d9 Z1 G d: d;e2 Z3ee ee ee ef ee ef f f Z4ee e4e5e3ej e6 f e e4e5e3f f Z7 e d! e d" fd<e d=e8e7 d>eee f d?eee f d e f d@Z9dg fdAZ: e; e.dB dCz jM dD Z< e.dE jM dF Z= e.dG j} jM dH Z? e.dI jM dJ Z@ e; e.dB dCz e@z jM dK ZA eAZB e.dL jM dM ZC eD j D cg c] } eF|e s | c}ZGe8e e"dN< dfddOdeee f dPeee f dQedRej e5 dSej e5 dTed e fdUZHe3ZIe'ZJe(ZKe0ZLe<ZMe=ZNe?ZOe@ZPeAZQeBZReCZS e dVeT ZU e dWeT ZH e dXe ZV e dYe ZW e dZe ZX e d[e ZY e d\e ZZ e d]e Z[ e d^e Z\ e d_e Z] e d`e! Z^ e dae1 Z_ e dbe9 Z`yc c}} w c c}w )g N )__diag__)*)_bslash_flatten_escape_regex_range_charsreplaced_by_pep8)intExprexprint_exprr returnc |xs |}t fd}| t t j d }n|j }|j d |j |d |z j d d S )a~ Helper to define a counted list of expressions. This helper defines a pattern of the form:: integer expr expr expr... where the leading integer tells how many expr expressions follow. The matched tokens returns the array of expr tokens as a list - the leading count token is suppressed. If ``int_expr`` is specified, it should be a pyparsing expression that produces an integer value. Example:: counted_array(Word(alphas)).parse_string('2 ab cd ef') # -> ['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|z n t z |d d = y Nr )Empty)sltn array_exprr s 3/usr/lib/python3/dist-packages/pyparsing/helpers.pycount_field_parse_actionz/counted_array.<locals>.count_field_parse_action@ s' aDQqEG3 aD c t | d S r )intr s r <lambda>z counted_array.<locals>.<lambda>H s AaD r arrayLenT)call_during_tryz(len) z...)ForwardWordnumsset_parse_actioncopyset_nameadd_parse_action)r r r r r s ` @r counted_arrayr' s R !GJ t*--.AB,,. Z 5t L j * *VD6+= >>r c t fd}| j |d j dt | z S )a9 Helper 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 |st z y t | dk( r |d z y t |j }t d |D z y )Nr r c 3 2 K | ] }t | y wN)Literal).0tts r <genexpr>zImatch_previous_literal.<locals>.copy_token_to_repeater.<locals>.<genexpr>l s /272; )r lenr as_listAnd)r r r tflatreps r copy_token_to_repeaterz6match_previous_literal.<locals>.copy_token_to_repeatera sP 57N q6Q; 1Q4K % s////r T callDuringTry(prev) )r r& r% str)r r6 r5 s @r match_previous_literalr; P sA )C 0 0ELLSY&' Jr c t | j }|z fd}| j |d j dt | z S )aW Helper 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 }|k7 rt | |d d| y )Nz Expected z, found)r r2 ParseException)r r r theseTokens matchTokenss r must_match_these_tokenszTmatch_previous_expr.<locals>.copy_token_to_repeater.<locals>.must_match_these_tokens sA "199;/Kk)$qIk]'+ G *r Tr7 )r r2 r# )r r r rB rA r5 s @r r6 z3match_previous_expr.<locals>.copy_token_to_repeater s. qyy{+ 4D Ir Tr7 r9 )r r$ r& r% r: )r e2r6 r5 s @r match_previous_exprrD s sV )C BBJC J 0ELLSY&' Jr FT)useRegex asKeywordstrscaseless use_regex as_keywordrE rF c H |xs |}|xr |}t |t r't j rt j dd |rd }d }|rt nt nd }d }|rt nt g }t | t r+t j t | } | j }n't | t r t | }n t! d |s t# S t% d |D rd } | t' | d z k ro|| } t) || d z d D ]? \ } } || | r || | z d z = n- || | s$|| | z d z = |j+ | | n | d z } | t' | d z k ro|r|rt, j. nd } t1 d |D r ddj3 d |D d}ndj3 d |D }|rd| d}t5 || j7 dj3 | }|r3|D ci c] }|j9 | c}|j; fd |S t? fd|D j7 dj3 | S c c}w # t, j< $ r t j dd Y cw xY w)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( S r+ )upperabs r r zone_of.<locals>.<lambda> s qwwyAGGI 5r c \ |j j | j S r+ )rO startswithrP s r r zone_of.<locals>.<lambda> s QWWY 1 1!'') <r c | |k( S r+ rP s r r zone_of.<locals>.<lambda> s qAvr c $ |j | S r+ )rT rP s r r zone_of.<locals>.<lambda> s Q\\!_r z7Invalid argument to one_of, expected string or iterablec 3 8 K | ] }t | d kD ywr Nr1 r- syms r r/ zone_of.<locals>.<genexpr> s +7C3s8a<7 r r Nc 3 8 K | ] }t | d k( ywrY rZ r[ s r r/ zone_of.<locals>.<genexpr> s 4GS3s8q=Gr] [ c 3 2 K | ] }t | y wr+ )r r[ s r r/ zone_of.<locals>.<genexpr> s "UWc#<S#AWr0 ]|c 3 F K | ] }t j | y wr+ )reescaper[ s r r/ zone_of.<locals>.<genexpr> s B'3 #'s !z\b(?:z)\b)flagsz | c 0 |d j S r lower)r r r symbol_maps r r zone_of.<locals>.<lambda> s Z! 5Mr z8Exception creating Regex for one_of, building MatchFirstc 3 . K | ] } | y wr+ rV )r- r\ parseElementClasss r r/ zone_of.<locals>.<genexpr> s @',s ) isinstancestr_typer %warn_on_multiple_string_args_to_oneofwarningswarnCaselessKeywordCaselessLiteralKeywordr, typingcastr: splitIterablelist TypeErrorNoMatchanyr1 enumerateinsertre IGNORECASEalljoinRegexr% rj r& error MatchFirst)rG rH rI rJ rE rF isequalmaskssymbolsicurjotherre_flagspattretr\ rm rk s @@r one_ofr s R 'ZI%IH 8X& : : ; 5</8Oo%,'0GgG$!{{3%**, D( #t*QRR y +7 ++ #g,""!*C %ga!eg&6 755#& A *e$ A *NN1e, 8 Q #g,"" )1 q 4G44277"UW"UUVVWXxx B' BB vS)H-66uzz'7JKC ;B B'3ciik3 .' B $$%MNJ @@ @ I I 7 C xx MMJWX s% B I4 I/$I4 /I4 4*J! J!keyvaluec B t t t | |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 OneOrMoreGroup)r r s r dict_ofr s J %e ,- ..r )asString as_stringr c 0 |xr |}t j d }|j }d|_ |d | z |d z }|rd }nd }|j | | j |_ |j t j |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 <b> bold <i>text</i> </b> 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:: ['<b> bold <i>text</i> </b>'] ['<i>text</i>'] c |S r+ rV )r locr s r r z#original_text_for.<locals>.<lambda>a s 3r F_original_start _original_endc 4 | |j |j S r+ )r r r r r s r r z#original_text_for.<locals>.<lambda>f s a(9(9AOO&Lr c R | |j d |j d g|d d y )Nr r popr s r extractTextz&original_text_for.<locals>.extractTexti s( aee -.1GHIAaDr )r r# r$ callPreparse ignoreExprssuppress_warning Diagnostics)warn_ungrouped_named_tokens_in_collection)r r r locMarker endlocMarker matchExprr s r original_text_forr = s D %IH(()>?I >>#L %L +,t3l?6SSIL J {+ , ,I { T TU r c 8 t | j d S )zkHelper to undo pyparsing's default grouping of And expressions, even if all but one are non-empty. c | d S r rV r s r r zungroup.<locals>.<lambda>v s 1Q4r )TokenConverterr& )r s r ungroupr r s $ 0 0 @@r c t j d }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 ``<TAB>`` 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 |S r+ rV )ssllr. s r r z locatedExpr.<locals>.<lambda> s "r locn_startr locn_end)r r# r r$ leaveWhitespace)r locators r locatedExprr y sV 6 g&&'<=G w- *',,. ( ( *: 6 7 r ()) ignoreExpropenerclosercontent ignore_exprr c ||k7 r|t k( r|n|}| |k( r t d |t | t rt |t rt j t | } t j t | }t | dk( rt | dk( r|It t | t | |z t j z d z j d }nt j t | |z t j z j d z }n|\t t | t! | z t! | z t t j d z j d }nct t t! | t! | z t t j d z j d }n t d t# }|6|t% t' | t) ||z |z z t' | z z }n2|t% t' | t) ||z z t' | z z }|j+ d | | 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 sameNr )exactc ( | d j S r stripr s r r z nested_expr.<locals>.<lambda> 1 r c ( | d j S r r r s r r z nested_expr.<locals>.<lambda> r r c ( | d j S r r r s r r z nested_expr.<locals>.<lambda> r r c ( | d j S r r r s r r z nested_expr.<locals>.<lambda> r r zOopening and closing arguments must be strings if no content expression is givenznested z expression) quoted_string ValueErrorrn ro rv rw r: r1 Combiner CharsNotIn ParserElementDEFAULT_WHITE_CHARSr# emptyr$ r, r r Suppress ZeroOrMorer% errmsg)r r r r r r s r nested_exprr so V [ $.-/$A[z IJJ fh 'Jvx,H[[f-F[[f-F6{a CK1$4 ) %! 'K ( &-2S2S S&' '&'=> $jjlZ -*K*KK.&&'=> ?G ) %! 'K &v . / &v . / ) )J)JRS T U '&'=> &! $V_ , &v . / ( )J)JRS T U '&'=> a )C V z*s*:W*D E EQWHX X hv&C'M)BBXfEUUVVLL76(6(+67CJ Jr <>c t | t r| t | | } n | j t t t dz }|rt j j t }| | d z t t t |t d z |z z t ddg d j d z |z }nt j j t t t" d z }| | d z t t t |j d t t d |z z z t ddg d j d z |z }t% t' d | z d z d }|j) d d |j+ fd |ddj- j/ dd j1 j3 z j) d d }|_ |_ t7 | |_ ||fS )zRInternal helper to construct opening and closing tag expressions, given a tag name)rH z_-:tag=/F)defaultr c |d dk( S Nr r rV r s r r z_makeTags.<locals>.<lambda>1 ! r r ) exclude_charsc ( | d j S r ri r s r r z_makeTags.<locals>.<lambda>? s qtzz|r c |d dk( S r rV r s r r z_makeTags.<locals>.<lambda>E r r z</)adjacentr c | j ddj j dd j j z | j S )Nstartr` : ) __setitem__r replacetitlerx r$ )r resnames r r z_makeTags.<locals>.<lambda>N sD !-- bgggooc3 7 = = ? E E GH H!&&( r endr` r r ) rn ro ru namer! alphas alphanumsdbl_quoted_stringr$ r# remove_quotesr r r r Optr printablesr r, r% r& r r r rx r SkipTotag_body) tagStrxml suppress_LT suppress_GT tagAttrName tagAttrValueopenTagcloseTagr s @r _makeTagsr ! s7 &(#c'2++vy5 01K (--/@@ O Um :eK(3-$?,$N OPQ R (c#w'0AA+ %))+<<]Kd cO Um #445KL hsml :;< (c#w'0AA+ wt}v-3eDH q ^$ S1779??ABBhG9A GKHL hj)G H r tag_strc t | d S )aP Helper 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 = '<td>More info at the <a href="https://github.com/pyparsing/pyparsing/wiki">pyparsing</a> wiki page</td>' # 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 <A> 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 Fr r s r make_html_tagsr [ s 0 We $$r c t | d S )zHelper 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` Tr r s r make_xml_tagsr v s Wd ##r any_open_tag any_close_tagz_:zany tag;z &(?P<entity>rc z);zcommon HTML entityc @ t j |j S )zRHelper parser action to replace common HTML entities with their special characters)_htmlEntityMapgetentityr s r replace_html_entityr s ahh ''r c e Zd ZdZdZdZy)OpAssoczvEnumeration of operator associativity - used in constructing InfixNotationOperatorSpec for :class:`infix_notation`r rL N)__name__ __module__ __qualname____doc__LEFTRIGHTrV r r r r s T D Er r base_exprop_listlparrparc 0 G d dt }d|_ t }t |t r t | }t |t r t | }t |t rt |t s| t ||z |z z }n | ||z |z z }|D ] }|dz dd \ }} } } t |t rt j | }t j t | }| dk( r<t |t t f rt | dk7 r t d |\ } } | | d }n| d }d | cxk rdk st d t d | t j" t j$ fvr t d t j' | }t j t | }| t j" u r| d k( r |||z t ||d z z }nU| dk( rC|% |||z |z t |||z d z z }n) |||z t |d z }n | dk( r || z |z z |z t |t) | |z | z |z z z }n| t j$ u r| d k( r@t |t* s t+ | } ||j, |z t ||z z }nz| dk( rD|$ |||z |z t |||z d z z }nO |||z t ||d z z }n1| dk( r, || z |z z |z t || z |z | z |z z }| r7t | t t f r j. | nj/ | ||z j1 | z }|} ||z }|S )a Helper method for constructing grammars of expressions made up of operators working in a precedence hierarchy. Operators may be unary or binary, left- or right-associative. Parse actions can also be attached to operator expressions. The generated parser will also recognize the use of parentheses to override operator precedences (see example below). Note: if you define a deep operator list, you may see performance issues when using infix_notation. See :class:`ParserElement.enable_packrat` for a mechanism to potentially improve your parser performance. Parameters: - ``base_expr`` - expression representing the most basic operand to be used in the expression - ``op_list`` - list of tuples, one for each operator precedence level in the expression grammar; each tuple is of the form ``(op_expr, num_operands, right_left_assoc, (optional)parse_action)``, where: - ``op_expr`` is the pyparsing expression for the operator; may also be a string, which will be converted to a Literal; if ``num_operands`` is 3, ``op_expr`` is a tuple of two expressions, for the two operators separating the 3 terms - ``num_operands`` is the number of terms for this operator (must be 1, 2, or 3) - ``right_left_assoc`` is the indicator whether the operator is right or left associative, using the pyparsing-defined constants ``OpAssoc.RIGHT`` and ``OpAssoc.LEFT``. - ``parse_action`` is the parse action to be associated with expressions matching this operator expression (the parse action tuple member may be omitted); if the parse action is passed a tuple or list of functions, this is equivalent to calling ``set_parse_action(*fn)`` (:class:`ParserElement.set_parse_action`) - ``lpar`` - expression for matching left-parentheses; if passed as a str, then will be parsed as ``Suppress(lpar)``. If lpar is passed as an expression (such as ``Literal('(')``), then it will be kept in the parsed results, and grouped with them. (default= ``Suppress('(')``) - ``rpar`` - expression for matching right-parentheses; if passed as a str, then will be parsed as ``Suppress(rpar)``. If rpar is passed as an expression (such as ``Literal(')')``), then it will be kept in the parsed results, and grouped with them. (default= ``Suppress(')')``) Example:: # simple example of four-function arithmetic with ints and # variable names integer = pyparsing_common.signed_integer varname = pyparsing_common.identifier arith_expr = infix_notation(integer | varname, [ ('-', 1, OpAssoc.RIGHT), (one_of('* /'), 2, OpAssoc.LEFT), (one_of('+ -'), 2, OpAssoc.LEFT), ]) arith_expr.run_tests(''' 5+3*6 (5+3)*6 -2--11 ''', full_dump=False) prints:: 5+3*6 [[5, '+', [3, '*', 6]]] (5+3)*6 [[[5, '+', 3], '*', 6]] (5+x)*y [[[5, '+', 'x'], '*', 'y']] -2--11 [[['-', 2], '-', ['-', 11]]] c e Zd ZddZy)infix_notation.<locals>._FBc B | j j || |g fS r+ )r try_parse)selfinstringr doActionss r parseImplz%infix_notation.<locals>._FB.parseImpl s II # .7Nr NT)r r r r" rV r r _FBr s r r$ z FollowedBy>r+ N rL z@if numterms=3, opExpr must be a tuple or list of two expressionsz termr z6operator must be unary (1), binary (2), or ternary (3)z2operator must indicate right or left associativity)r .)rL .) FollowedByr r rn r: r r ro r _literalStringClassrv rw tuplerz r1 r r r r r% r r r r# setName)r r r r r$ r lastExproperDefopExprarityrightLeftAssocpaopExpr1opExpr2 term_namethisExprr s r infix_notationr5 s lj !CL )C$ ~$ ~ tX &:dH+E uTCZ$%6 77 s T 12 -4w->,C)~r fh '"66v>F]F3 A: fudm4F q8H V & GW")G9E2I!(%(IEQ UV V UV V ',, !> > QR R"))"4"4Y"?;;w1 W\\ )z 6 1 2U8fVn;T5U U !% #Hv$5$@ AE FX$5v#>>E !I !$Hx$7 85&AQ;R RI! w&1G;hF (Yw/AG/Kh/V%WWX Y w}} ,z!&#. [F h 6 7%@Q:R R !% #Hv$5$@ AE FX$5v#>>E !I !$Hx$7 85 8F#33< !I ! w&1G;hF (W,x7'AHLM N "udm,* **B/**2.i(*33I>>} ~ HC Jr c | j dd fd fd}fd}fd}t t j d j }t t j | z j d }t j | j d } t j | j d } |r?t t | |z t | t | z t | z z | z } nDt t | t | t | z t | z z t | z } | j fd | j fd | j t t z | j d 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 d d y NrV ) backup_stacks indentStacks r reset_stackz"indentedBlock.<locals>.reset_stack s &r* Ar c |t | k\ ry t || }|d k7 r"|d kD r t | |d t | |d y )Nr9 zillegal nestingznot a peer entry)r1 colr? r r r curColr; s r checkPeerIndentz&indentedBlock.<locals>.checkPeerIndent sY A; Q [_ $ B'$Q+<== A'9: : %r c j t || }|d kD rj | y t | |d )Nr9 znot a subentry)r> appendr? r? s r checkSubIndentz%indentedBlock.<locals>.checkSubIndent s8 Q KO # v & A'78 8r c |t | k\ ry t || }r|v s t | |d |d k rj y y )Nznot an unindentr9 )r1 r> r? r r? s r checkUnindentz$indentedBlock.<locals>.checkUnindent sQ A; Q+ 5 A'89 9 KO # OO $r z INDENTr` UNINDENTc 6 r j d xr d S d S r8 r )r: s r r z indentedBlock.<locals>.<lambda> s - !!"%.$ITIr c S r+ rV )rQ rR cdr< s r r z indentedBlock.<locals>.<lambda> s kmr zindented block)rC r LineEndset_whitespace_charssuppressr r# r% r r r& set_fail_actionignorer ) blockStatementExprr; indentr: rA rD rF NLrG PEERUNDENTsmExprr< s ` ` @r indentedBlockrX ] s~ l Q (+;9 7911%8AAC DBg00 @@ J J8 TF 7 # #O 4 = =b AD W % %m 4 = =j IF G u%7 883r7BC D Gu%7 883r7BC D&k I ;< g 12 ??+ ,,r z/\*(?:[^*]|\*(?!/))*z*/zC style commentz<!--[\s\S]*?-->z HTML commentz.*z rest of linez//(?:\\\n|[^\n])*z // commentzC++ style commentz#.*zPython style comment_builtin_exprsallow_trailing_delimdelimcombineminmaxr[ c $ t | ||||| S )z/(DEPRECATED - use :class:`DelimitedList` class)rZ ) DelimitedList)r r\ r] r^ r_ r[ s r delimited_listrb s eWc3=Q r delimitedListrb countedArraymatchPreviousLiteralmatchPreviousExproneOfdictOforiginalTextFor nestedExpr makeHTMLTags makeXMLTagsreplaceHTMLEntity infixNotationr+ )FTFr# ),FNN)a html.entitieshtmlre sysrv r` r coreutilr r r r r Optionalr' r; rD Unionry r: boolr r r r r r r r r Tupler r __annotations__r! r r r% r r entitieshtml5itemsrstripr r r common_html_entityr Enumr InfixNotationOperatorArgTyper ParseActionInfixNotationOperatorSpecListr5 rX r c_style_comment html_commentleave_whitespace rest_of_linedbl_slash_commentcpp_style_commentjava_style_commentpython_style_commentvarsvaluesrn rY rb opAssoc anyOpenTag anyCloseTagcommonHTMLEntity cStyleComment htmlComment restOfLinedblSlashCommentcppStyleCommentjavaStyleCommentpythonStyleCommentra rc rd re rf rg rh ri rj rk rl rm rn )kvs 00r <module>r s 049? /3 9? 9?oom,9? __] + 9? 9?x = F!m ! !L { { $c) *{{ { { { { {|%/ %/} %/ %/R ,02EI2 2$(2>B22jA- AM A m H ),(+.2!. B !. B #}$ %B #}$ %B __] +B B B BJ (0}(3- 7 t% 3 % &% =- '(%6$ 3 % &$ =- '($ ,T!"++I6 m 04}}/B/B/H/H/JK/Jtq!!((3-"/JK>CHH^,DDtKLUU ( d %3eM3$6 7}c?Q9R RSS " $ $ & $ $ '/sm&.sm n n + ,n ]" #n ]" # n nb ;?b L-` % 784?@II $'(11.A &U|,,.77G ./88 F 1 !"T),== ( P& $ V}--.DE 0 v}}' !*Q ">A']# (+ $ $ "' ]" # m# $ " % ##% ) -@ !"2MB > '(>@VW $%8:MN &) (G ,"#46GH lK 8 ? }m< $%8:MN .A ] L@ 's ? O5 O; O;