main title

.pacsˆjjˆ|dƒS)Nr)rr&)rù)r¼rÇrrr¿N s)r´r2r3r4ÚSyntaxErrorrµrâræ)rÇr¼r¿r)r¼rÇrr&5 s z Regex.sub) rrrrßrÉrår¶r·rÔr&rr)rrrDÆs- c s[eZdZdZdddddd‡fdd†Zddd„Z‡fd d †Z‡S)rBa& Token for matching strings that are delimited by quoting characters. Defined with the following parameters: - quoteChar - string of one or more characters defining the quote delimiting string - escChar - character to escape quotes, typically backslash (default= ``None``) - escQuote - special quote sequence to escape an embedded quote string (such as SQL's ``""`` to escape an embedded ``"``) (default= ``None``) - multiline - boolean indicating whether quotes can span multiple lines (default= ``False``) - unquoteResults - boolean indicating whether the matched text should be unquoted (default= ``True``) - endQuoteChar - string of one or more characters defining the end of the quote delimited string (default= ``None`` => same as quoteChar) - convertWhitespaceEscapes - convert escaped whitespace (``'\t'``, ``'\n'``, etc.) to actual whitespace (default= ``True``) Example:: qs = QuotedString('"') print(qs.searchString('lsjdf "This is the quote" sldjf')) complex_qs = QuotedString('{{', endQuoteChar='}}') print(complex_qs.searchString('lsjdf {{This is the "quote"}} sldjf')) sql_qs = QuotedString('"', escQuote='""') print(sql_qs.searchString('lsjdf "This is the quote with ""embedded"" quotes" sldjf')) prints:: [['This is the quote']] [['This is the "quote"']] [['This is the quote with "embedded" quotes']] NFTcs"ttˆƒjƒ|jƒ}|sDtjdtddƒtƒ‚|dkrY|}n1|jƒ}|sŠtjdtddƒtƒ‚|ˆ_t |ƒˆ_ |dˆ_|ˆ_t |ƒˆ_ |ˆ_|ˆ_|ˆ_|ˆ_|rNtjtjBˆ_dtjˆjƒtˆjdƒ|dk r>t|ƒpAdfˆ_nPdˆ_dtjˆjƒtˆjdƒ|dk r‘t|ƒp”dfˆ_t ˆjƒd krÿˆjd dj‡fdd †tt ˆjƒd ddƒDƒƒd7_|r!ˆjdtj|ƒ7_|r\ˆjdtj|ƒ7_tjˆjƒdˆ_ˆjdtjˆjƒ7_y:tjˆjˆjƒˆ_ˆjˆ_ˆjjˆ_Wn5t j!k rìtjdˆjtddƒ‚YnXt"ˆƒˆ_#dˆj#ˆ_$dˆ_%dˆ_&dS)Nz$quoteChar cannot be the empty stringr/r“z'endQuoteChar cannot be the empty stringrz%s(?:[^%s%s]r¶z%s(?:[^%s\n\r%s]r”z|(?:z)|(?:c3sB|]8}dtjˆjd|…ƒtˆj|ƒfVqdS)z%s[^%s]N)rr¢ÚendQuoteCharr )rrû)rÇrrr§¡ sz(QuotedString.__init__..ú)z|(?:%s)z|(?:%s.)z(.)z)*%sz$invalid pattern (%s) passed to Regexz Expected FTr•)'rzrBrÉr×r2r3r4r½Ú quoteCharrÒÚquoteCharLenÚfirstQuoteCharr¾ÚendQuoteCharLenÚescCharÚescQuoteÚunquoteResultsÚconvertWhitespaceEscapesrÚ MULTILINEÚDOTALLr±r¢r r°rÖr(ÚescCharReplacePatternr£r¡r€r¤r²r³r¥rrÈrÇrÂ)rÇrÀrÄrÅÚ multilinerÆr¾rÇ)r)rÇrrÉy sd ( %E zQuotedString.__init__c Cs>|||jkr%|j||ƒp(d}|sIt|||j|ƒ‚|jƒ}|jƒ}|jr4||j|j…}t |t ƒr4d|krò|jròdddddddd i}x,|jƒD]\}}|j ||ƒ}qÐW|jrtj|jd |ƒ}|jr4|j |j|jƒ}||fS)NrÑz\tú z\nréz\fúz\rú z\g<1>)rÂr¤r<rÈrr®rÆrÁrÃršrrÇr+rrÄrr&rÊrÅr¾) rÇr“rÃrÚrvr¤Úws_mapÚwslitÚwscharrrrråº s(+ zQuotedString.parseImplcs[ytt|ƒjƒSWntk r+YnX|jdkrTd|j|jf|_|jS)Nz.quoted string, starting with %s ending with %s)rzrBrÔr‡r¼rÀr¾)rÇ)rrrrÔÝ s zQuotedString.__str__)rrrrßrÉrårÔrr)rrrBR s & @#csReZdZdZddd‡fdd†Zddd„Z‡fd d †Z‡S)r%aüToken for matching words composed of characters *not* in a given set (will include whitespace in matched characters if not listed in the provided exclusion set - see example). Defined with string containing all disallowed characters, and an optional minimum, maximum, and/or exact length. The default value for ``min`` is 1 (a minimum value < 1 is not valid); the default values for ``max`` and ``exact`` are 0, meaning no maximum or exact length restriction. Example:: # define a comma-separated-value as anything that is not a ',' csv_value = CharsNotIn(',') print(delimitedList(csv_value).parseString("dkls,lsdkjf,s12 34,@!#,213")) prints:: ['dkls', 'lsdkjf', 's12 34', '@!#', '213'] r”rcsÃtt|ƒjƒd|_||_|dkr=tdƒ‚||_|dkr^||_n t|_|dkr…||_||_t |ƒ|_ d|j |_|jdk|_d|_ dS)NFr”zfcannot specify a minimum length < 1; use Optional(CharsNotIn()) if zero-length char group is permittedrz Expected )rzr%rÉr¿ÚnotCharsr;rržryr¥rrÈrÂrÇ)rÇrÒr¦r§r¨)rrrrÉý s zCharsNotIn.__init__TcCsÌ|||jkr+t|||j|ƒ‚|}|d7}|j}t||jt|ƒƒ}x*||krŒ|||krŒ|d7}qcW|||jkr¸t|||j|ƒ‚||||…fS)Nr”)rÒr<rÈr¦ržrÒr)rÇr“rÃrÚrÚnotcharsÚmaxlenrrrrås zCharsNotIn.parseImplcs„ytt|ƒjƒSWntk r+YnX|jdkr}t|jƒdkrmd|jdd…|_nd|j|_|jS)Nr«z !W:(%s...)z!W:(%s))rzr%rÔr‡r¼rÒrÒ)rÇ)rrrrÔ&s zCharsNotIn.__str__)rrrrßrÉrårÔrr)rrr%é sc.sÓeZdZdZdddddddd d ddd ddddddddddddddddddd d!d"d#d$d%d&d'd(d)d*d+d,d-d.d/iZd0d1d2d2‡fd3d4†Zd5d6d7„Z‡S)8rKa™Special matching class for matching whitespace. Normally, whitespace is ignored by pyparsing grammars. This class is included when some whitespace structures are significant. Define with a string containing the whitespace characters to be matched; default is ``" \t\r\n"``. Also takes optional ``min``, ``max``, and ``exact`` arguments, as defined for the :class:`Word` class. râzrÌzrézrÎzrÍzõÂ zuáš€zuá Žzuâ€€z uâ€z uâ€‚z uâ€ƒz uâ€„zuâ€…zuâ€†zuâ€‡zuâ€ˆzuâ€‰zuâ€Šzuâ€‹zuâ€¯zuâŸzuã€€zz r”rcsÏttˆƒjƒ|ˆ_ˆjdj‡fdd†ˆjDƒƒƒdjdd„ˆjDƒƒˆ_dˆ_dˆjˆ_ |ˆ_ |dkr¤|ˆ_n tˆ_|dkrË|ˆ_|ˆ_ dS)Nr¶c3s$|]}|ˆjkr|VqdS)N)Ú matchWhite)rr¹)rÇrrr§Ysz!White.__init__..css|]}tj|VqdS)N)rKÚ whiteStrs)rr¹rrrr§[sTz Expected r) rzrKrÉrÖrKrÖrÀrrÂrÈrržry)rÇÚwsr¦r§r¨)r)rÇrrÉVs ," zWhite.__init__TcCsÌ|||jkr+t|||j|ƒ‚|}|d7}||j}t|t|ƒƒ}x-||krŒ|||jkrŒ|d7}q`W|||jkr¸t|||j|ƒ‚||||…fS)Nr”)rÖr<rÈržr¦rÒr)rÇr“rÃrÚrr‘rrrråjs "zWhite.parseImpl)rrrrßr×rÉrårr)rrrK4s4cs"eZdZ‡fdd†Z‡S)Ú_PositionTokencs8tt|ƒjƒ|jj|_d|_d|_dS)NTF)rzrÙrÉrrrrÂrÇ)rÇ)rrrrÉ{s z_PositionToken.__init__)rrrrÉrr)rrrÙzsrÙcsCeZdZdZ‡fdd†Zdd„Zddd„Z‡S) r,zaToken to advance to a specific column of input text; useful for tabular report scraping. cs tt|ƒjƒ||_dS)N)rzr,rÉrW)rÇÚcolno)rrrrÉ…szGoToColumn.__init__cCsˆt||ƒ|jkr„t|ƒ}|jr?|j||ƒ}xB||krƒ||jƒrƒt||ƒ|jkrƒ|d7}qBW|S)Nr”)rWrÒrÄrìÚisspace)rÇr“rÃrîrrrrï‰s 7zGoToColumn.preParseTcCs^t||ƒ}||jkr3t||d|ƒ‚||j|}|||…}||fS)NzText not in expected column)rWr<)rÇr“rÃrÚÚthiscolÚnewlocr¤rrrrå’szGoToColumn.parseImpl)rrrrßrÉrïrårr)rrr,s cs7eZdZdZ‡fdd†Zddd„Z‡S)r0a±Matches if current position is at the beginning of a line within the parse string Example:: test = '''\ AAA this line AAA and this line AAA but not this one B AAA and definitely not this one ''' for t in (LineStart() + 'AAA' + restOfLine).searchString(test): print(t) prints:: ['AAA', ' this line'] ['AAA', ' and this line'] cs tt|ƒjƒd|_dS)NzExpected start of line)rzr0rÉrÈ)rÇ)rrrrÉ±szLineStart.__init__TcCs;t||ƒdkr|gfSt|||j|ƒ‚dS)Nr”)rWr<rÈ)rÇr“rÃrÚrrrråµs zLineStart.parseImpl)rrrrßrÉrårr)rrr0›scs7eZdZdZ‡fdd†Zddd„Z‡S)r/zTMatches if current position is at the end of a line within the parse string cs<tt|ƒjƒ|jtjjddƒƒd|_dS)Nrér¶zExpected end of line)rzr/rÉrKrAr³rrÈ)rÇ)rrrrÉ¾szLineEnd.__init__TcCs‡|t|ƒkrK||dkr0|ddfSt|||j|ƒ‚n8|t|ƒkrk|dgfSt|||j|ƒ‚dS)Nrér”)rÒr<rÈ)rÇr“rÃrÚrrrråÃszLineEnd.parseImpl)rrrrßrÉrårr)rrr/ºscs7eZdZdZ‡fdd†Zddd„Z‡S)rGzLMatches if current position is at the beginning of the parse string cs tt|ƒjƒd|_dS)NzExpected start of text)rzrGrÉrÈ)rÇ)rrrrÉÒszStringStart.__init__TcCsF|dkr<||j|dƒkr<t|||j|ƒ‚|gfS)Nr)rïr<rÈ)rÇr“rÃrÚrrrråÖszStringStart.parseImpl)rrrrßrÉrårr)rrrGÎscs7eZdZdZ‡fdd†Zddd„Z‡S)rFzBMatches if current position is at the end of the parse string cs tt|ƒjƒd|_dS)NzExpected end of text)rzrFrÉrÈ)rÇ)rrrrÉàszStringEnd.__init__TcCs…|t|ƒkr-t|||j|ƒ‚nT|t|ƒkrM|dgfS|t|ƒkri|gfSt|||j|ƒ‚dS)Nr”)rÒr<rÈ)rÇr“rÃrÚrrrråäs zStringEnd.parseImpl)rrrrßrÉrårr)rrrFÝscs:eZdZdZe‡fdd†Zddd„Z‡S)rNayMatches if the current position is at the beginning of a Word, and is not preceded by any character in a given set of ``wordChars`` (default= ``printables``). To emulate the ```` behavior of regular expressions, use ``WordStart(alphanums)``. ``WordStart`` will also match at the beginning of the string being parsed, or at the beginning of a line. cs/tt|ƒjƒt|ƒ|_d|_dS)NzNot at the start of a word)rzrNrÉrðÚ wordCharsrÈ)rÇrÞ)rrrrÉ÷szWordStart.__init__TcCsX|dkrN||d|jks6|||jkrNt|||j|ƒ‚|gfS)Nrr”)rÞr<rÈ)rÇr“rÃrÚrrrråüs zWordStart.parseImpl)rrrrßrtrÉrårr)rrrNîscs:eZdZdZe‡fdd†Zddd„Z‡S)rMa_Matches if the current position is at the end of a Word, and is not followed by any character in a given set of ``wordChars`` (default= ``printables``). To emulate the ```` behavior of regular expressions, use ``WordEnd(alphanums)``. ``WordEnd`` will also match at the end of the string being parsed, or at the end of a line. cs8tt|ƒjƒt|ƒ|_d|_d|_dS)NFzNot at the end of a word)rzrMrÉrðrÞr¿rÈ)rÇrÞ)rrrrÉs zWordEnd.__init__TcCspt|ƒ}|dkrf||krf|||jksN||d|jkrft|||j|ƒ‚|gfS)Nrr”)rÒrÞr<rÈ)rÇr“rÃrÚrîrrrråszWordEnd.parseImpl)rrrrßrtrÉrårr)rrrMscs¯eZdZdZd‡fdd†Zdd„Zdd„Z‡fd d †Z‡fdd†Z‡fd d†Z ddd„Z ‡fdd†Zd‡fdd†Z‡S)r=z]Abstract subclass of ParserElement, for combining and post-processing parsed tokens. Fcsttˆƒj|ƒt|tƒr1t|ƒ}t|tƒrXˆj|ƒgˆ_n±t|t ƒrv|gˆ_n“t|t ƒrÕt|ƒ}tdd„|DƒƒrÃ‡fdd†|Dƒ}t|ƒˆ_n4yt|ƒˆ_Wntk r|gˆ_YnXdˆ_ dS)Ncss|]}t|tƒVqdS)N)ršr)rr”rrrr§*sz+ParseExpression.__init__..c3s3|])}t|tƒr'ˆj|ƒn|VqdS)N)ršrr¶)rrê)rÇrrr§+sF)rzr=rÉršrrrr¶ÚexprsrAr rr rË)rÇrßrÍ)r)rÇrrÉs" zParseExpression.__init__cCs|jj|ƒd|_|S)N)rßrìr¼)rÇrRrrrrì4s zParseExpression.appendcCsDd|_dd„|jDƒ|_x|jD]}|jƒq,W|S)z€Extends ``leaveWhitespace`` defined in base class, and also invokes ``leaveWhitespace`` on all contained expressions.FcSsg|]}|jƒ‘qSr)rQ)rrêrrrr=s z3ParseExpression.leaveWhitespace..)r¿rßrJ)rÇrêrrrrJ9s zParseExpression.leaveWhitespacecs¡t|tƒr_||jkrtt|ƒj|ƒxf|jD]}|j|jdƒq>Wn>tt|ƒj|ƒx%|jD]}|j|jdƒqW|S)Nr”r•r•)ršrHrÄrzr=rMrß)rÇrRrê)rrrrMBszParseExpression.ignorecsdytt|ƒjƒSWntk r+YnX|jdkr]d|jjt|jƒf|_|jS)Nz%s:(%s)) rzr=rÔr‡r¼rrr¥rß)rÇ)rrrrÔNs "zParseExpression.__str__cs†tt|ƒjƒx|jD]}|jƒqWt|jƒdkro|jd}t||jƒrÙ|jrÙ|jdkrÙ|j rÙ|jdd…|jdg|_d|_ |j|jO_|j|jO_|jd}t||jƒro|jro|jdkro|j ro|jdd…|jdd…|_d|_ |j|jO_|j|jO_dt |ƒ|_|S)Nr“rr”z Expected r•r•)rzr=rrßrÒršrrºr½rÅr¼rÂrÇr¥rÈ)rÇrêrR)rrrrXs0 $ ' zParseExpression.streamlineNcCs[|dk r|ngdd…|g}x|jD]}|j|ƒq3W|jgƒdS)N)rßrUrS)rÇrTÚtmprêrrrrUzs)zParseExpression.validatecs2tt|ƒjƒ}dd„|jDƒ|_|S)NcSsg|]}|jƒ‘qSr)rQ)rrêrrrr‚s z(ParseExpression.copy..)rzr=rQrß)rÇr¤)rrrrQ€szParseExpression.copycstjrfxZ|jD]O}t|tƒr|jrtjdjd|t |ƒj |jƒddƒqWtt|ƒj ||ƒS)Nz]{0}: setting results name {1!r} on {2} expression collides with {3!r} on contained expressionrr/r‘)rrrßršrAr½r2r3rírÝrrzr=rÒ)rÇrrÓrê)rrrrÒ…s zParseExpression._setResultsName) rrrrßrÉrìrJrMrÔrrUrQrÒrr)rrr=s "cs†eZdZdZGdd„deƒZd‡fdd†Z‡fdd†Zdd d „Zdd„Z d d„Z dd„Z‡S)r"a Requires all given :class:`ParseExpression` s to be found in the given order. Expressions may be separated by whitespace. May be constructed using the ``'+'`` operator. May also be constructed using the ``'-'`` operator, which will suppress backtracking. Example:: integer = Word(nums) name_expr = OneOrMore(Word(alphas)) expr = And([integer("id"), name_expr("name"), integer("age")]) # more easily written as: expr = integer("id") + name_expr("name") + integer("age") cs"eZdZ‡fdd†Z‡S)zAnd._ErrorStopcs3ttj|ƒj||Žd|_|jƒdS)Nú-)rzr"r5rÉrrJ)rÇrÆrD)rrrrÉ¦s zAnd._ErrorStop.__init__)rrrrÉrr)rrr5¥sr5Tcs6t|ƒ}|rÇt|krÇg}xt|ƒD]‚\}}|tkr¦|t|ƒdkr—tƒ||djd}|jt|ƒdƒƒq³tdƒ‚q1|j|ƒq1W||dd….rTr•)rr0rñrÒr)rßrìrEr‡rzr"rÉrãrÂrKrÀr¿rË)rÇrßrÍràrûr”Ú skipto_arg)rrrrÉ«s zAnd.__init__cs|jrãtdd„|jdd…Dƒƒrãx˜t|jdd…ƒD]}\}}|dkrdqIt|tƒrI|jrIt|jd tƒrI|jd |j|d|jd.r”cSs"g|]}|dk r|‘qS)Nr)rrêrrrrËs z"And.streamline..css|]}|jVqdS)N)rÂ)rrêrrrr§Îsr•r•r•r•r•)rßrrñršr=r1rzr"rrãrÂ)rÇrûrê)rrrr¿s &#zAnd.streamlinec CsS|jdj|||ddƒ\}}d}x|jdd…D]}t|tjƒrcd}qB|ry|j|||ƒ\}}Wq)tk rŸ‚Yq)tk rÛ}zd|_tj|ƒ‚WYdd}~Xq)t k r t|t |ƒ|j|ƒ‚Yq)Xn|j|||ƒ\}}|s;|jƒrB||7}qBW||fS)NrrÛFr”T) rßrßršr"r5r@r:rïrÌr!rÒrÈrB) rÇr“rÃrÚÚ resultlistÚ errorStoprêÚ exprtokensrËrrrråÑs(( ! &z And.parseImplcCs+t|tƒr|j|ƒ}|j|ƒS)N)ršrr¶rì)rÇrRrrrrMêszAnd.__iadd__cCsF|dd…|g}x(|jD]}|j|ƒ|js!Pq!WdS)N)rßrSrÂ)rÇrÚsubRecCheckListrêrrrrSïs zAnd.checkRecursioncCsVt|dƒr|jS|jdkrOddjdd„|jDƒƒd|_|jS)NrÚ{râcss|]}t|ƒVqdS)N)r¥)rrêrrrr§ûszAnd.__str__..Ú})r:rr¼rÖrß)rÇrrrrÔös *zAnd.__str__)rrrrßr)r5rÉrrårMrSrÔrr)rrr"“scs…eZdZdZd‡fdd†Z‡fdd†Zddd „Zd d„Zdd „Zdd„Z d‡fdd†Z ‡S)r9a¿Requires that at least one :class:`ParseExpression` is found. If two expressions match, the expression that matches the longest string will be used. May be constructed using the ``'^'`` operator. Example:: # construct Or using '^' operator number = Word(nums) ^ Combine(Word(nums) + '.' + Word(nums)) print(number.searchString("123 3.1416 789")) prints:: [['123'], ['3.1416'], ['789']] FcsQtt|ƒj||ƒ|jrDtdd„|jDƒƒ|_n d|_dS)Ncss|]}|jVqdS)N)rÂ)rrêrrrr§szOr.__init__..T)rzr9rÉrßrrÂ)rÇrßrÍ)rrrrÉs "zOr.__init__cs?tt|ƒjƒtjr;tdd„|jDƒƒ|_|S)Ncss|]}|jVqdS)N)r¾)rrêrrrr§sz Or.streamline..)rzr9rr!Úcollect_all_And_tokensrrßr¾)rÇ)rrrrs z Or.streamlineTcCsOd}d}g}xÖ|jD]Ë}y|j||ƒ}Wn™tk r†} z,d| _| j|krt| }| j}WYdd} ~ Xqtk rÓt|ƒ|krÏt|t|ƒ|j|ƒ}t|ƒ}YqX|j||fƒqW|r|j dt dƒddƒ|s4|dd} | j|||ƒSd }xÈ|D]À\}} ||dkra|Sy| j|||ƒ\}}WnLtk rÎ} z,d| _| j|kr¼| }| j}WYdd} ~ XqAX||krå||fS||dkrA||f}qAW|dkr|S|dk r6|j|_|‚nt||d|ƒ‚dS)Nr”rHrr*Tz no defined alternatives to matchr•r•)r•Nr•)r•N) rßrýr<rïrÃr!rÒrÈrìÚsortrrßr¾)rÇr“rÃrÚÚ maxExcLocÚmaxExceptionr#rêÚloc2rúÚ best_exprÚlongestÚloc1Úexpr1r˜rrrråsT zOr.parseImplcCs+t|tƒr|j|ƒ}|j|ƒS)N)ršrr¶rì)rÇrRrrrÚ__ixor__[szOr.__ixor__cCsVt|dƒr|jS|jdkrOddjdd„|jDƒƒd|_|jS)Nrrçz ^ css|]}t|ƒVqdS)N)r¥)rrêrrrr§eszOr.__str__..rè)r:rr¼rÖrß)rÇrrrrÔ`s *z Or.__str__cCs<|dd…|g}x|jD]}|j|ƒq!WdS)N)rßrS)rÇrrærêrrrrSiszOr.checkRecursioncsstjrZtjrZtdd„|jDƒƒrZtjdjd|t |ƒj ƒddƒtt|ƒj ||ƒS)Ncss|]}t|tƒVqdS)N)ršr")rrêrrrr§qsz%Or._setResultsName..z–{0}: setting results name {1!r} on {2} expression may only return a single token for an And alternative, in future will return the full list of tokensrr/r‘)r!rérrrrßr2r3rírÝrrzr9rÒ)rÇrrÓ)rrrrÒns zOr._setResultsName)rrrrßrÉrråròrÔrSrÒrr)rrr9s= cs…eZdZdZd‡fdd†Z‡fdd†Zddd „Zd d„Zdd „Zdd„Z d‡fdd†Z ‡S)r3a¸Requires that at least one :class:`ParseExpression` is found. If two expressions match, the first one listed is the one that will match. May be constructed using the ``'|'`` operator. Example:: # construct MatchFirst using '|' operator # watch the order of expressions to match number = Word(nums) | Combine(Word(nums) + '.' + Word(nums)) print(number.searchString("123 3.1416 789")) # Fail! -> [['123'], ['3'], ['1416'], ['789']] # put more selective expression first number = Combine(Word(nums) + '.' + Word(nums)) | Word(nums) print(number.searchString("123 3.1416 789")) # Better -> [['123'], ['3.1416'], ['789']] FcsQtt|ƒj||ƒ|jrDtdd„|jDƒƒ|_n d|_dS)Ncss|]}|jVqdS)N)rÂ)rrêrrrr§sz&MatchFirst.__init__..T)rzr3rÉrßrrÂ)rÇrßrÍ)rrrrÉŒs "zMatchFirst.__init__cs?tt|ƒjƒtjr;tdd„|jDƒƒ|_|S)Ncss|]}|jVqdS)N)r¾)rrêrrrr§–sz(MatchFirst.streamline..)rzr3rr!rérrßr¾)rÇ)rrrr“s zMatchFirst.streamlineTc Cs d}d}x÷|jD]¶}y|j|||ƒ}|SWqtk r~}z#|j|krl|}|j}WYdd}~Xqtk rËt|ƒ|krÇt|t|ƒ|j|ƒ}t|ƒ}YqXqW|dk rñ|j|_|‚nt||d|ƒ‚dS)Nr”z no defined alternatives to matchr•)rßrßr<rÃr!rÒrÈr¾) rÇr“rÃrÚrërìrêr¤rúrrrrå™s$ zMatchFirst.parseImplcCs+t|tƒr|j|ƒ}|j|ƒS)N)ršrr¶rì)rÇrRrrrÚ__ior__±szMatchFirst.__ior__cCsVt|dƒr|jS|jdkrOddjdd„|jDƒƒd|_|jS)Nrrçz | css|]}t|ƒVqdS)N)r¥)rrêrrrr§»sz%MatchFirst.__str__..rè)r:rr¼rÖrß)rÇrrrrÔ¶s *zMatchFirst.__str__cCs<|dd…|g}x|jD]}|j|ƒq!WdS)N)rßrS)rÇrrærêrrrrS¿szMatchFirst.checkRecursioncsstjrZtjrZtdd„|jDƒƒrZtjdjd|t |ƒj ƒddƒtt|ƒj ||ƒS)Ncss|]}t|tƒVqdS)N)ršr")rrêrrrr§Çsz-MatchFirst._setResultsName..z–{0}: setting results name {1!r} on {2} expression may only return a single token for an And alternative, in future will return the full list of tokensrr/r‘)r!rérrrrßr2r3rírÝrrzr3rÒ)rÇrrÓ)rrrrÒÄs zMatchFirst._setResultsName)rrrrßrÉrrårórÔrSrÒrr)rrr3{s csdeZdZdZd‡fdd†Z‡fdd†Zddd„Zd d „Zdd„Z‡S) r(asRequires all given :class:`ParseExpression` s to be found, but in any order. Expressions may be separated by whitespace. May be constructed using the ``'&'`` operator. Example:: color = oneOf("RED ORANGE YELLOW GREEN BLUE PURPLE BLACK WHITE BROWN") shape_type = oneOf("SQUARE CIRCLE TRIANGLE STAR HEXAGON OCTAGON") integer = Word(nums) shape_attr = "shape:" + shape_type("shape") posn_attr = "posn:" + Group(integer("x") + ',' + integer("y"))("posn") color_attr = "color:" + color("color") size_attr = "size:" + integer("size") # use Each (using operator '&') to accept attributes in any order # (shape and posn are required, color and size are optional) shape_spec = shape_attr & posn_attr & Optional(color_attr) & Optional(size_attr) shape_spec.runTests(''' shape: SQUARE color: BLACK posn: 100, 120 shape: CIRCLE size: 50 color: BLUE posn: 50,80 color:GREEN size:20 shape:TRIANGLE posn:20,40 ''' ) prints:: shape: SQUARE color: BLACK posn: 100, 120 ['shape:', 'SQUARE', 'color:', 'BLACK', 'posn:', ['100', ',', '120']] - color: BLACK - posn: ['100', ',', '120'] - x: 100 - y: 120 - shape: SQUARE shape: CIRCLE size: 50 color: BLUE posn: 50,80 ['shape:', 'CIRCLE', 'size:', '50', 'color:', 'BLUE', 'posn:', ['50', ',', '80']] - color: BLUE - posn: ['50', ',', '80'] - x: 50 - y: 80 - shape: CIRCLE - size: 50 color: GREEN size: 20 shape: TRIANGLE posn: 20,40 ['color:', 'GREEN', 'size:', '20', 'shape:', 'TRIANGLE', 'posn:', ['20', ',', '40']] - color: GREEN - posn: ['20', ',', '40'] - x: 20 - y: 40 - shape: TRIANGLE - size: 20 TcsWtt|ƒj||ƒtdd„|jDƒƒ|_d|_d|_d|_dS)Ncss|]}|jVqdS)N)rÂ)rrêrrrr§sz Each.__init__..T) rzr(rÉrãrßrÂr¿ÚinitExprGroupsr¾)rÇrßrÍ)rrrrÉ s z Each.__init__cs6tt|ƒjƒtdd„|jDƒƒ|_|S)Ncss|]}|jVqdS)N)rÂ)rrêrrrr§sz"Each.streamline..)rzr(rrãrßrÂ)rÇ)rrrrszEach.streamlinec sž|jrÇtdd„|jDƒƒ|_dd„|jDƒ}dd„|jDƒ}|||_dd„|jDƒ|_dd„|jDƒ|_dd„|jDƒ|_|j|j7_d |_|}|jdd…}|jdd…‰g}d } xæ| rç|ˆ|j|j} g}x| D]•}y|j||ƒ}Wnt k rj|j |ƒYq-X|j |jjt|ƒ|ƒƒ||kr©|j |ƒq-|ˆkr-ˆj |ƒq-Wt|ƒt| ƒkrd } qW|r djdd„|Dƒƒ} t ||d | ƒ‚|‡fdd†|jDƒ7}g}x6|D].}|j|||ƒ\}}|j |ƒqMWt|tgƒƒ}||fS)Ncss3|])}t|tƒrt|jƒ|fVqdS)N)ršr8r`r”)rrêrrrr§sz!Each.parseImpl..cSs(g|]}t|tƒr|j‘qSr)ršr8r”)rrêrrrrs z"Each.parseImpl..cSs5g|]+}|jrt|ttfƒr|‘qSr)rÂršr8rD)rrêrrrrs cSs(g|]}t|tƒr|j‘qSr)ršrOr”)rrêrrrrs cSs(g|]}t|tƒr|j‘qSr)ršr6r”)rrêrrrrs cSs.g|]$}t|tttfƒs|‘qSr)ršr8rOr6)rrêrrrrs FTz, css|]}t|ƒVqdS)N)r¥)rrêrrrr§9sz*Missing one or more required elements (%s)cs4g|]*}t|tƒr|jˆkr|‘qSr)ršr8r”)rrê)ÚtmpOptrrr=s )rôrrßÚopt1mapÚ optionalsÚmultioptionalsÚ multirequiredÚrequiredrýr<rìrór`ÚremoverÒrÖrßÚsumr?)rÇr“rÃrÚÚopt1Úopt2ÚtmpLocÚtmpReqdÚ matchOrderÚkeepMatchingÚtmpExprsÚfailedrêÚmissingrãr–ÚfinalResultsr)rõrråsP " zEach.parseImplcCsVt|dƒr|jS|jdkrOddjdd„|jDƒƒd|_|jS)Nrrçz & css|]}t|ƒVqdS)N)r¥)rrêrrrr§LszEach.__str__..rè)r:rr¼rÖrß)rÇrrrrÔGs *zEach.__str__cCs<|dd…|g}x|jD]}|j|ƒq!WdS)N)rßrS)rÇrrærêrrrrSPszEach.checkRecursion) rrrrßrÉrrårÔrSrr)rrr(Ñs81 cs—eZdZdZd‡fdd†Zddd„Zdd „Z‡fd d†Z‡fdd †Zdd„Z ddd„Z ‡fdd†Z‡S)r;zfAbstract subclass of :class:`ParserElement`, for combining and post-processing parsed tokens. Fcsßtt|ƒj|ƒt|tƒr^t|jtƒrI|j|ƒ}n|jt|ƒƒ}||_ d|_ |dk rÛ|j|_|j|_|j |jƒ|j|_|j|_|j|_|jj|jƒdS)N)rzr;rÉršrÚ issubclassr¶rIr1r”r¼rÇrÂrKrÀr¿r¾rËrÄrN)rÇr”rÍ)rrrrÉZs zParseElementEnhance.__init__TcCsG|jdk r+|jj|||ddƒStd||j|ƒ‚dS)NrÛFr¶)r”rßr<rÈ)rÇr“rÃrÚrrrrålszParseElementEnhance.parseImplcCs;d|_|jjƒ|_|jdk r7|jjƒ|S)NF)r¿r”rQrJ)rÇrrrrJrs z#ParseElementEnhance.leaveWhitespacecst|tƒr]||jkr™tt|ƒj|ƒ|jdk r™|jj|jdƒn<tt|ƒj|ƒ|jdk r™|jj|jdƒ|S)Nr”r•r•)ršrHrÄrzr;rMr”)rÇrR)rrrrMyszParseElementEnhance.ignorecs3tt|ƒjƒ|jdk r/|jjƒ|S)N)rzr;rr”)rÇ)rrrr…s zParseElementEnhance.streamlinecCsY||krt||gƒ‚|dd…|g}|jdk rU|jj|ƒdS)N)rCr”rS)rÇrrærrrrS‹s z"ParseElementEnhance.checkRecursionNcCsY|dkrg}|dd…|g}|jdk rH|jj|ƒ|jgƒdS)N)r”rUrS)rÇrTràrrrrU’szParseElementEnhance.validatecssytt|ƒjƒSWntk r+YnX|jdkrl|jdk rld|jjt|jƒf|_|jS)Nz%s:(%s)) rzr;rÔr‡r¼r”rrr¥)rÇ)rrrrÔšs "zParseElementEnhance.__str__)rrrrßrÉrårJrMrrSrUrÔrr)rrr;Vscs7eZdZdZ‡fdd†Zddd„Z‡S)r*abLookahead matching of the given parse expression. ``FollowedBy`` does *not* advance the parsing position within the input string, it only verifies that the specified parse expression matches at the current position. ``FollowedBy`` always returns a null token list. If any results names are defined in the lookahead expression, those *will* be returned for access by name. Example:: # use FollowedBy to match a label only if it is followed by a ':' data_word = Word(alphas) label = data_word + FollowedBy(':') attr_expr = Group(label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join)) OneOrMore(attr_expr).parseString("shape: SQUARE color: BLACK posn: upper left").pprint() prints:: [['shape', 'SQUARE'], ['color', 'BLACK'], ['posn', 'upper left']] cs#tt|ƒj|ƒd|_dS)NT)rzr*rÉrÂ)rÇr”)rrrrÉ»szFollowedBy.__init__TcCs8|jj||d|ƒ\}}|dd…=||fS)NrÚ)r”rß)rÇr“rÃrÚÚ_r¤rrrrå¿s! zFollowedBy.parseImpl)rrrrßrÉrårr)rrr*¥scs=eZdZdZd‡fdd†Zdddd„Z‡S) r2apLookbehind matching of the given parse expression. ``PrecededBy`` does not advance the parsing position within the input string, it only verifies that the specified parse expression matches prior to the current position. ``PrecededBy`` always returns a null token list, but if a results name is defined on the given expression, it is returned. Parameters: - expr - expression that must match prior to the current parse location - retreat - (default= ``None``) - (int) maximum number of characters to lookbehind prior to the current parse location If the lookbehind expression is a string, Literal, Keyword, or a Word or CharsNotIn with a specified exact or maximum length, then the retreat parameter is not required. Otherwise, retreat must be specified to give a maximum number of characters to look back from the current parse position for a lookbehind match. Example:: # VB-style variable names with type prefixes int_var = PrecededBy("#") + pyparsing_common.identifier str_var = PrecededBy("$") + pyparsing_common.identifier Ncs-tt|ƒj|ƒ|jƒjƒ|_d|_d|_d|_t|t ƒrmt |ƒ}d|_nt|ttfƒr—|j }d|_nWt|ttfƒrÐ|jtkrÐ|j}d|_nt|tƒrîd}d|_||_dt |ƒ|_d|_|jjdd„ƒdS)NTFrznot preceded by cSs|jtddƒƒS)N)r2r#)rªr»r˜rrrr™ùsz%PrecededBy.__init__..)rzr2rÉr”rJrÂrÇr¨ršrœrÒr1r.rrLr%ržryrÙÚretreatrÈr¿rºrì)rÇr”r )rrrrÉäs* $ zPrecededBy.__init__rTcCs0|jrX||jkr-t|||jƒ‚||j}|jj||ƒ\}}nÎ|jtƒ}|td||jƒ|…}t|||jƒ} x†tdt ||jdƒdƒD][} y&|j|t |ƒ| ƒ\}}Wn+tk r}z|} WYdd}~XqÁXPqÁW| ‚||fS)Nrr”)r¨r r<rÈr”rßrFr§r(r¦rÒr:)rÇr“rÃrÚrrr¤Ú test_exprÚinstring_sliceÚ last_exprrUÚpberrrråûs *&zPrecededBy.parseImpl)rrrrßrÉrårr)rrr2ÈscsCeZdZdZ‡fdd†Zddd„Zdd„Z‡S) r5a¹Lookahead to disallow matching with the given parse expression. ``NotAny`` does *not* advance the parsing position within the input string, it only verifies that the specified parse expression does *not* match at the current position. Also, ``NotAny`` does *not* skip over leading whitespace. ``NotAny`` always returns a null token list. May be constructed using the '~' operator. Example:: AND, OR, NOT = map(CaselessKeyword, "AND OR NOT".split()) # take care not to mistake keywords for identifiers ident = ~(AND | OR | NOT) + Word(alphas) boolean_term = Optional(NOT) + ident # very crude boolean expression - to support parenthesis groups and # operation hierarchy, use infixNotation boolean_expr = boolean_term + ZeroOrMore((AND | OR) + boolean_term) # integers that are followed by "." are actually floats integer = Word(nums) + ~Char(".") csBtt|ƒj|ƒd|_d|_dt|jƒ|_dS)NFTzFound unwanted token, )rzr5rÉr¿rÂr¥r”rÈ)rÇr”)rrrrÉ*s zNotAny.__init__TcCs7|jj||ƒr-t|||j|ƒ‚|gfS)N)r”rþr<rÈ)rÇr“rÃrÚrrrrå1szNotAny.parseImplcCsFt|dƒr|jS|jdkr?dt|jƒd|_|jS)Nrz~{rè)r:rr¼r¥r”)rÇrrrrÔ6s zNotAny.__str__)rrrrßrÉrårÔrr)rrr5scsUeZdZd‡fdd†Zdd„Zddd„Zd ‡fd d†Z‡S)Ú_MultipleMatchNcsTtt|ƒj|ƒd|_|}t|tƒrC|j|ƒ}|j|ƒdS)NT)rzrrÉr¾ršrr¶ÚstopOn)rÇr”rÚender)rrrrÉ@s z_MultipleMatch.__init__cCs>t|tƒr|j|ƒ}|dk r1|nd|_|S)N)ršrr¶Ú not_ender)rÇrrrrrHsz_MultipleMatch.stopOnTcCs|jj}|j}|jdk }|r6|jj}|rI|||ƒ||||ddƒ\}}y{|j} xi|r‹|||ƒ| r£|||ƒ} n|} ||| |ƒ\}}|sÓ|jƒrx||7}qxWWnttfk rüYnX||fS)NrÛF) r”rßrìrrýrÄrBr<r!)rÇr“rÃrÚÚself_expr_parseÚself_skip_ignorablesÚcheck_enderÚ try_not_enderrùÚhasIgnoreExprsr÷Ú tmptokensrrrråNs, z_MultipleMatch.parseImplFcs•tjr|xp|jgt|jdgƒD]O}t|tƒr)|jr)tjdj d|t |ƒj|jƒddƒq)Wtt |ƒj||ƒS)Nrßz]{0}: setting results name {1!r} on {2} expression collides with {3!r} on contained expressionrr/r‘)rrr”r¯ršrAr½r2r3rírÝrrzrrÒ)rÇrrÓrê)rrrrÒks &z_MultipleMatch._setResultsName)rrrrÉrrårÒrr)rrr?src@s"eZdZdZdd„ZdS)r6ajRepetition of one or more of the given expression. Parameters: - expr - expression that must match one or more times - stopOn - (default= ``None``) - expression for a terminating sentinel (only required if the sentinel would ordinarily match the repetition expression) Example:: data_word = Word(alphas) label = data_word + FollowedBy(':') attr_expr = Group(label + Suppress(':') + OneOrMore(data_word).setParseAction(' '.join)) text = "shape: SQUARE posn: upper left color: BLACK" OneOrMore(attr_expr).parseString(text).pprint() # Fail! read 'color' as data instead of next label -> [['shape', 'SQUARE color']] # use stopOn attribute for OneOrMore to avoid reading label string as part of the data attr_expr = Group(label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join)) OneOrMore(attr_expr).parseString(text).pprint() # Better -> [['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'BLACK']] # could also be written as (attr_expr * (1,)).parseString(text).pprint() cCsFt|dƒr|jS|jdkr?dt|jƒd|_|jS)Nrrçz}...)r:rr¼r¥r”)rÇrrrrÔ“s zOneOrMore.__str__N)rrrrßrÔrrrrr6yscsLeZdZdZd‡fdd†Zd‡fdd†Zdd „Z‡S) rOakOptional repetition of zero or more of the given expression. Parameters: - expr - expression that must match zero or more times - stopOn - (default= ``None``) - expression for a terminating sentinel (only required if the sentinel would ordinarily match the repetition expression) Example: similar to :class:`OneOrMore` Ncs)tt|ƒj|d|ƒd|_dS)NrT)rzrOrÉrÂ)rÇr”r)rrrrÉ§szZeroOrMore.__init__TcsIy tt|ƒj|||ƒSWn"ttfk rD|gfSYnXdS)N)rzrOrår<r!)rÇr“rÃrÚ)rrrrå«s zZeroOrMore.parseImplcCsFt|dƒr|jS|jdkr?dt|jƒd|_|jS)Nrr\z]...)r:rr¼r¥r”)rÇrrrrÔ±s zZeroOrMore.__str__)rrrrßrÉrårÔrr)rrrOœs c@s.eZdZdd„ZeZdd„ZdS)Ú _NullTokencCsdS)NFr)rÇrrrr5¼sz_NullToken.__bool__cCsdS)Nr¶r)rÇrrrrÔ¿sz_NullToken.__str__N)rrrr5r‹rÔrrrrr»srcsOeZdZdZeƒZe‡fdd†Zddd„Zdd„Z‡S) r8aGOptional matching of the given expression. Parameters: - expr - expression that must match zero or more times - default (optional) - value to be returned if the optional expression is not found. Example:: # US postal code can be a 5-digit zip, plus optional 4-digit qualifier zip = Combine(Word(nums, exact=5) + Optional('-' + Word(nums, exact=4))) zip.runTests(''' # traditional ZIP code 12345 # ZIP+4 form 12101-0001 # invalid ZIP 98765- ''') prints:: # traditional ZIP code 12345 ['12345'] # ZIP+4 form 12101-0001 ['12101-0001'] # invalid ZIP 98765- ^ FAIL: Expected end of text (at char 5), (line:1, col:6) csAtt|ƒj|ddƒ|jj|_||_d|_dS)NrÍFT)rzr8rÉr”r¾rIrÂ)rÇr”rC)rrrrÉés zOptional.__init__TcCs¨y(|jj|||ddƒ\}}Wnsttfk r|j|jk r“|jjr„t|jgƒ}|j||jj ['3', '.', '1416'] # will also erroneously match the following print(real.parseString('3. 1416')) # -> ['3', '.', '1416'] real = Combine(Word(nums) + '.' + Word(nums)) print(real.parseString('3.1416')) # -> ['3.1416'] # no match when there are internal spaces print(real.parseString('3. 1416')) # -> Exception: Expected W:(0123...) r¶TcsNtt|ƒj|ƒ|r&|jƒ||_d|_||_d|_dS)NT)rzr&rÉrJÚadjacentr¿Ú joinStringrË)rÇr”r)r()rrrrÉs zCombine.__init__cs6|jrtj||ƒntt|ƒj|ƒ|S)N)r(rArMrzr&)rÇrR)rrrrM s zCombine.ignorecCsn|jƒ}|dd…=|tdj|j|jƒƒgd|jƒ7}|jrf|jƒrf|gS|SdS)Nr¶r)rQr?rÖr^r)rÉr½rB)rÇr“rÃrðÚretToksrrrrñs 1zCombine.postParse)rrrrßrÉrMrñrr)rrr&îs cs4eZdZdZ‡fdd†Zdd„Z‡S)r-aConverter to return the matched tokens as a list - useful for returning tokens of :class:`ZeroOrMore` and :class:`OneOrMore` expressions. Example:: ident = Word(alphas) num = Word(nums) term = ident | num func = ident + Optional(delimitedList(term)) print(func.parseString("fn a, b, 100")) # -> ['fn', 'a', 'b', '100'] func = ident + Group(Optional(delimitedList(term))) print(func.parseString("fn a, b, 100")) # -> ['fn', ['a', 'b', '100']] cs#tt|ƒj|ƒd|_dS)NT)rzr-rÉr¾)rÇr”)rrrrÉ*szGroup.__init__cCs|gS)Nr)rÇr“rÃrðrrrrñ.szGroup.postParse)rrrrßrÉrñrr)rrr-scs4eZdZdZ‡fdd†Zdd„Z‡S)r'a?Converter to return a repetitive expression as a list, but also as a dictionary. Each element can also be referenced using the first token in the expression as its key. Useful for tabular report scraping when the first column can be used as a item key. Example:: data_word = Word(alphas) label = data_word + FollowedBy(':') attr_expr = Group(label + Suppress(':') + OneOrMore(data_word).setParseAction(' '.join)) text = "shape: SQUARE posn: upper left color: light blue texture: burlap" attr_expr = (label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join)) # print attributes as plain groups print(OneOrMore(attr_expr).parseString(text).dump()) # instead of OneOrMore(expr), parse using Dict(OneOrMore(Group(expr))) - Dict will auto-assign names result = Dict(OneOrMore(Group(attr_expr))).parseString(text) print(result.dump()) # access named fields as dict entries, or output as dict print(result['shape']) print(result.asDict()) prints:: ['shape', 'SQUARE', 'posn', 'upper left', 'color', 'light blue', 'texture', 'burlap'] [['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'light blue'], ['texture', 'burlap']] - color: light blue - posn: upper left - shape: SQUARE - texture: burlap SQUARE {'color': 'light blue', 'posn': 'upper left', 'texture': 'burlap', 'shape': 'SQUARE'} See more examples at :class:`ParseResults` of accessing fields by results name. cs#tt|ƒj|ƒd|_dS)NT)rzr'rÉr¾)rÇr”)rrrrÉXsz Dict.__init__cCsNx3t|ƒD]%\}}t|ƒdkr.q |d}t|tƒr]t|dƒjƒ}t|ƒdkr…td|ƒ||> entering method-name(line:, , )"``. When the parse action completes, the decorator will print ``"<<"`` followed by the returned value, or any exception that the parse action raised. Example:: wd = Word(alphas) @traceParseAction def remove_duplicate_chars(tokens): return ''.join(sorted(set(''.join(tokens)))) wds = OneOrMore(wd).setParseAction(remove_duplicate_chars) print(wds.parseString("slkdjs sld sldd sdlf sdljf")) prints:: >>entering remove_duplicate_chars(line: 'slkdjs sld sldd sdlf sdljf', 0, (['slkdjs', 'sld', 'sldd', 'sdlf', 'sdljf'], {})) <>entering %s(line: '%s', %d, %r) z<.z)rÀrrÎ)r[r5r)r[rr€¡s ú,cCsxt|ƒdt|ƒdt|ƒd}|rSt|t||ƒƒj|ƒS|tt|ƒ|ƒj|ƒSdS)aÎHelper to define a delimited list of expressions - the delimiter defaults to ','. By default, the list elements and delimiters can have intervening whitespace, and comments, but this can be overridden by passing ``combine=True`` in the constructor. If ``combine`` is set to ``True``, the matching tokens are returned as a single token string, with the delimiters included; otherwise, the matching tokens are returned as a list of tokens, with the delimiters suppressed. Example:: delimitedList(Word(alphas)).parseString("aa,bb,cc") # -> ['aa', 'bb', 'cc'] delimitedList(Word(hexnums), delim=':', combine=True).parseString("AA:BB:CC:DD:EE") # -> ['AA:BB:CC:DD:EE'] z [râz]...N)r¥r&rOrÑrH)r”ÚdelimÚcombineÚdlNamerrrr^Ñs,!cs“tƒ‰‡‡fdd†}|dkrHttƒjdd„ƒ}n|jƒ}|jdƒ|j|ddƒ|ˆjd tˆƒ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 ``intExpr`` is specified, it should be a pyparsing expression that produces an integer value. Example:: countedArray(Word(alphas)).parseString('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 binaryConstant = Word('01').setParseAction(lambda t: int(t[0], 2)) countedArray(Word(alphas), intExpr=binaryConstant).parseString('10 ab cd ef') # -> ['ab', 'cd'] cs;|d}ˆ|r,ttˆg|ƒƒp5ttƒ>gS)Nr)r-r"ra)rªr»r˜r8)Ú arrayExprr”rrÚcountFieldParseActionþs -z+countedArray..countFieldParseActionNcSst|dƒS)Nr)r—)r˜rrrr™szcountedArray..ÚarrayLenrÌTz(len) z...)r+rLrpr¡rQrÑrær¥)r”ÚintExprr;r)r:r”rrZæs cCsMg}x@|D]8}t|tƒr8|jt|ƒƒq |j|ƒq W|S)N)ršrrNr(rì)ÚLr¤rûrrrr( s r(csItƒ‰‡fdd†}|j|ddƒˆjdt|ƒƒˆS)a4Helper 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 = matchPreviousLiteral(first) matchExpr = 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:`matchPreviousExpr`. Do *not* use with packrat parsing enabled. csf|rWt|ƒdkr'ˆ|d>qbt|jƒƒ}ˆtdd„|Dƒƒ>nˆtƒ>dS)Nr”rcss|]}t|ƒVqdS)N)r1)rÚttrrrr§*szDmatchPreviousLiteral..copyTokenToRepeater..)rÒr(rr"r))rªr»r˜Útflat)ÚreprrÚcopyTokenToRepeater#sz1matchPreviousLiteral..copyTokenToRepeaterrÌTz(prev) )r+rærÑr¥)r”rBr)rArrms cs_tƒ‰|jƒ}ˆ|K‰‡fdd†}|j|ddƒˆjdt|ƒƒˆS)aTHelper 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 = matchPreviousExpr(first) matchExpr = 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. cs;t|jƒƒ‰‡fdd†}ˆj|ddƒdS)Ncs4t|jƒƒ}|ˆkr0tdddƒ‚dS)Nr¶r)r(rr<)rªr»r˜ÚtheseTokens)ÚmatchTokensrrÚmustMatchTheseTokensEszLmatchPreviousExpr..copyTokenToRepeater..mustMatchTheseTokensrÌT)r(rr¡)rªr»r˜rE)rA)rDrrBCsz.matchPreviousExpr..copyTokenToRepeaterrÌTz(prev) )r+rQrærÑr¥)r”Úe2rBr)rArrl1s cCsUx$dD]}|j|t|ƒ}qW|jddƒ}|jddƒ}t|ƒS)Nz\^-[]réz\nrÌz\t)rÚ_bslashr¥)rªr¹rrrr Ns r cs—t|tƒr"tjdddƒ|rUdd„}dd„}|rLtnt‰n*dd„}dd„}|rytnt‰g}t|tƒr£|jƒ}n4t|t ƒrÁt |ƒ}ntjd tddƒ|sätƒS|sd }xª|t |ƒdkrœ||}xƒt||dd…ƒD]]\} } || |ƒr\||| d=Pq.||| ƒr.||| d=|j|| ƒPq.W|d7}qóW|p¦|rh|rhyt |ƒt d j|ƒƒkr tdd jdd„|Dƒƒƒjdj|ƒƒStdjdd„|Dƒƒƒjdj|ƒƒSWn(tk rgtjdtddƒYnXt‡fdd†|Dƒƒjdj|ƒƒS)aƒHelper to quickly define a set of alternative Literals, 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 - (default= ``False``) - treat all literals as caseless - useRegex - (default= ``True``) - as an optimization, will generate a Regex object; otherwise, will generate a :class:`MatchFirst` object (if ``caseless=True`` or ``asKeyword=True``, or if creating a :class:`Regex` raises an exception) - asKeyword - (default=``False``) - enforce Keyword-style matching on the generated expressions Example:: comp_oper = oneOf("< = > <= >= !=") var = Word(alphas) number = Word(nums) term = var | number comparison_expr = term + comp_oper + term print(comparison_expr.searchString("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 oneOf, pass choices as a list or space-delimited stringr/r“cSs|jƒ|jƒkS)N)r‡)rTÚbrrrr™{szoneOf..cSs|jƒj|jƒƒS)N)r‡r)rTrHrrrr™|scSs ||kS)Nr)rTrHrrrr™scSs |j|ƒS)N)r)rTrHrrrr™€sz6Invalid argument to oneOf, expected string or iterablerr”Nr¶z[%s]css|]}t|ƒVqdS)N)r )rÚsymrrrr§£szoneOf..z | ú|css|]}tj|ƒVqdS)N)rr¢)rrIrrrr§¥sz7Exception creating Regex for oneOf, building MatchFirstc3s|]}ˆ|ƒVqdS)Nr)rrI)ÚparseElementClassrrr§«s)ršrr2r3r#r$r.r1r«r rr4r4rÒrñrJrÖrDrÑr‡r3)Ústrsr†ÚuseRegexrŸÚisequalÚmasksÚsymbolsrûÚcurr/rRr)rKrrqVsR '!66 cCsttt||ƒƒƒ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, stopOn=label).setParseAction(' '.join)) print(OneOrMore(attr_expr).parseString(text).dump()) attr_label = label attr_value = Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join) # similar to Dict, but simpler call format result = dictOf(attr_label, attr_value).parseString(text) print(result.dump()) print(result['shape']) print(result.shape) # object attribute access works too print(result.asDict()) 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'} )r'r6r-)rHr0rrrr_s%cCs…tƒjdd„ƒ}|jƒ}d|_|dƒ||dƒ}|r\dd„}ndd„}|j|ƒ|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 astring containing the original parsed text. If the optional ``asString`` 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:`originalTextFor` contains expressions with defined results names, you must set ``asString`` to ``False`` if you want to preserve those results name values. Example:: src = "this is test bold text normal text " for tag in ("b", "i"): opener, closer = makeHTMLTags(tag) patt = originalTextFor(opener + SkipTo(closer) + closer) print(patt.searchString(src)[0]) prints:: [' bold text '] ['text'] cSs|S)Nr)rªrÃr˜rrrr™ñsz!originalTextFor..FÚ_original_startÚ _original_endcSs||j|j…S)N)rRrS)rªr»r˜rrrr™öscSs3||jdƒ|jdƒ…g|dd….extractText)r)r¡rQrËrÄ)r”ÚasStringÚ locMarkerÚendlocMarkerÚ matchExprrTrrrr…Ôs cCst|ƒjdd„ƒS)zkHelper to undo pyparsing's default grouping of And expressions, even if all but one are non-empty. cSs|dS)Nrr)r˜rrrr™szungroup..)rJræ)r”rrrr†þscCsHtƒjdd„ƒ}t|dƒ|dƒ|jƒjƒdƒƒS)a±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.parseWithTabs` Example:: wd = Word(alphas) for match in locatedExpr(wd).searchString("ljsdf123lksdjjf123lkkjj1222"): print(match) prints:: [[0, 'ljsdf', 5]] [[8, 'lksdjjf', 15]] [[18, 'lkkjj', 23]] cSs|S)Nr)rªr»r˜rrrr™szlocatedExpr..Ú locn_startr0Úlocn_end)r)r¡r-rQrJ)r”Úlocatorrrrrˆsz\[]-*.$+^?()~ r¨cCs|ddS)Nrr”r)rªr»r˜rrrr™(sr™z\\0?[xX][0-9a-fA-F]+cCs tt|djdƒdƒƒS)Nrz\0xrá)Úunichrr—rj)rªr»r˜rrrr™)sz \\0[0-7]+cCs!tt|ddd…dƒƒS)Nrr”é)r\r—)rªr»r˜rrrr™*sz\]rár\rãÚnegateÚbodyr]csYdd„‰y0dj‡fdd†tj|ƒjDƒƒSWntk rTdSYnXdS)aHelper to easily define string ranges for use in Word construction. Borrows syntax from regexp '[]' string range definitions:: srange("[0-9]") -> "0123456789" srange("[a-z]") -> "abcdefghijklmnopqrstuvwxyz" srange("[a-z$_]") -> "abcdefghijklmnopqrstuvwxyz$_" The input string must be enclosed in []'s, and the returned string is the expanded character set joined into a single string. The values enclosed in the []'s may be: - a single character - an escaped character with a leading backslash (such as ``\-`` or ``\]``) - an escaped hex character with a leading ``'\x'`` (``\x21``, which is a ``'!'`` character) (``\0x##`` is also supported for backwards compatibility) - an escaped octal character with a leading ``'\0'`` (``\041``, which is a ``'!'`` character) - a range of any of the above, separated by a dash (``'a-z'``, etc.) - any combination of the above (``'aeiouy'``, ``'a-zA-Z0-9_$'``, etc.) cSsNt|tƒs|Sdjdd„tt|dƒt|dƒdƒDƒƒS)Nr¶css|]}t|ƒVqdS)N)r\)rr¹rrrr§Isz+srange....rr”)ršr?rÖr(Úord)Úprrrr™Iszsrange..r¶c3s|]}ˆ|ƒVqdS)Nr)rÚpart)Ú _expandedrrr§Kszsrange..N)rÖÚ_reBracketExprrr_r‡)rªr)rcrr}/s 0 cs‡fdd†}|S)zoHelper method for defining parse actions that require matching at a specific column in the input text. cs/t||ƒˆkr+t||dˆƒ‚dS)Nzmatched token not at column %d)rWr<)rÚlocnr˜)r8rrÚ verifyColSsz!matchOnlyAtCol..verifyColr)r8rfr)r8rrkOscs‡fdd†S)aµHelper method for common parse actions that simply return a literal value. Especially useful when used with :class:`transformString` (). Example:: num = Word(nums).setParseAction(lambda toks: int(toks[0])) na = oneOf("N/A NA").setParseAction(replaceWith(math.nan)) term = na | num OneOrMore(term).parseString("324 234 N/A 234") # -> [324, 234, nan, 234] csˆgS)Nr)rªr»r˜)ÚreplStrrrr™eszreplaceWith..r)rgr)rgrrzXs cCs|ddd…S)aHelper parse action for removing quotation marks from parsed quoted strings. Example:: # by default, quotation marks are included in parsed results quotedString.parseString("'Now is the Winter of our Discontent'") # -> ["'Now is the Winter of our Discontent'"] # use removeQuotes to strip quotation marks from parsed results quotedString.setParseAction(removeQuotes) quotedString.parseString("'Now is the Winter of our Discontent'") # -> ["Now is the Winter of our Discontent"] rr”r•r)rªr»r˜rrrrxgs cse‡‡fdd†}y"tˆdtˆdƒjƒ}Wntk rWtˆƒ}YnX||_|S)aLHelper to define a parse action by mapping a function to all elements of a ParseResults list. If any additional args are passed, they are forwarded to the given function as additional arguments after the token, as in ``hex_integer = Word(hexnums).setParseAction(tokenMap(int, 16))``, which will convert the parsed data to an integer using base 16. Example (compare the last to example in :class:`ParserElement.transformString`:: hex_ints = OneOrMore(Word(hexnums)).setParseAction(tokenMap(int, 16)) hex_ints.runTests(''' 00 11 22 aa FF 0a 0d 1a ''') upperword = Word(alphas).setParseAction(tokenMap(str.upper)) OneOrMore(upperword).runTests(''' my kingdom for a horse ''') wd = Word(alphas).setParseAction(tokenMap(str.title)) OneOrMore(wd).setParseAction(' '.join).runTests(''' now is the winter of our discontent made glorious summer by this sun of york ''') prints:: 00 11 22 aa FF 0a 0d 1a [0, 17, 34, 170, 255, 10, 13, 26] my kingdom for a horse ['MY', 'KINGDOM', 'FOR', 'A', 'HORSE'] now is the winter of our discontent made glorious summer by this sun of york ['Now Is The Winter Of Our Discontent Made Glorious Summer By This Sun Of York'] cs‡‡fdd†|DƒS)Ncsg|]}ˆ|ˆŒ‘qSrr)rÚtokn)rÆr›rrr›s z(tokenMap..pa..r)rªr»r˜)rÆr›rrr¿šsztokenMap..parr)r¯rr‡rœ)r›rÆr¿r²r)rÆr›rr‹vs$ cCst|ƒjƒS)N)r¥r‡)r˜rrrr™¦scCst|ƒjƒS)N)r¥Úlower)r˜rrrr™ªsrgrhcst|tƒr+|‰t|d|ƒ}n |j‰tttdƒ}|rÅtjƒj t ƒ}||dƒttt |tdƒ|ƒƒƒtdddgƒdƒj d d „ƒ|}n”tjƒj t ƒttddƒB}||dƒttt |j tƒttdƒ|ƒƒƒƒtdddgƒdƒj d d „ƒ|}ttdƒ|dddƒ}|jdˆƒ|j‡fdd †ƒ|ddjˆjddƒjƒjƒƒƒjdˆƒ}ˆ|_ˆ|_t|ƒƒ|_||fS)zRInternal helper to construct opening and closing tag expressions, given a tag namer†z_-:Útagú=ú/rCFracSs|ddkS)Nrrlr)rªr»r˜rrrr™¾sz_makeTags..r—rhcSs|ddkS)Nrrlr)rªr»r˜rrrr™Æszcs;|jddjˆjddƒjƒjƒƒ|jƒƒS)Nrr¶ú:râ)r'rÖrÚtitler«rQ)r˜)Úresnamerrr™Ìsrr¶rmrâz)ršrr.rrLrRrQr\rQr¡rxr'rOr-rHr8rwrtr`r&Ú_LrÑrærÖrrnr«rjrEÚtag_body)ÚtagStrÚxmlÚsuppress_LTÚsuppress_GTÚtagAttrNameÚtagAttrValueÚopenTagÚcloseTagr)rorÚ _makeTags®s$ c%o > rzcCs t|dƒS)aKHelper 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' # makeHTMLTags returns pyparsing expressions for the opening and # closing tags as a 2-tuple a, a_end = makeHTMLTags("A") link_expr = a + SkipTo(a_end)("link_text") + a_end for link in link_expr.searchString(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)rz)rrrrrriÓscCs 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:`makeHTMLTags` T)rz)rrrrrrjëscsN|r|dd…‰n|jƒ‰dd„ˆDƒ‰‡fdd†}|S)a7Helper to create a validating parse action to be used with start tags created with :class:`makeXMLTags` or :class:`makeHTMLTags`. Use ``withAttribute`` to qualify a starting tag with a required attribute value, to avoid false matches on common tags such as ```` or ``

``. Call ``withAttribute`` with a series of attribute names and values. Specify the list of filter attributes names and values as: - keyword arguments, as in ``(align="right")``, or - as an explicit dict with ``**`` operator, when an attribute name is also a Python reserved word, as in ``**{"class":"Customer", "align":"right"}`` - a list of name-value tuples, as in ``(("ns1:class", "Customer"), ("ns2:align", "right"))`` For attribute names with a namespace prefix, you must use the second form. Attribute names are matched insensitive to upper/lower case. If just testing for ``class`` (with or without a namespace), use :class:`withClass`. To verify that the attribute exists, but without specifying a value, pass ``withAttribute.ANY_VALUE`` as the value. Example:: html = '''

1 4 0 1 0

1,3 2,3 1,1

this has no type

''' div,div_end = makeHTMLTags("div") # only match div tag having a type attribute with value "grid" div_grid = div().setParseAction(withAttribute(type="grid")) grid_expr = div_grid + SkipTo(div | div_end)("body") for grid_header in grid_expr.searchString(html): print(grid_header.body) # construct a match with any div tag having a type attribute, regardless of the value div_any_type = div().setParseAction(withAttribute(type=withAttribute.ANY_VALUE)) div_expr = div_any_type + SkipTo(div | div_end)("body") for div_header in div_expr.searchString(html): print(div_header.body) prints:: 1 4 0 1 0 1 4 0 1 0 1,3 2,3 1,1 NcSs"g|]\}}||f‘qSrr)rr%r"rrrr/s z!withAttribute..csxxˆD]p\}}||kr5t||d|ƒ‚|tjkr|||krt||d||||fƒ‚qWdS)Nzno matching attribute z+attribute '%s' has value '%s', must be '%s')r<rƒÚ ANY_VALUE)rªr»rùÚattrNameÚ attrValue)Úattrsrrr¿0szwithAttribute..pa)r+)rÆÚattrDictr¿r)r~rrƒós8cCs&|rd|nd}t||iS)aÉSimplified version of :class:`withAttribute` when matching on a div class - made difficult because ``class`` is a reserved word in Python. Example:: html = '''

Some text

1 4 0 1 0

1,3 2,3 1,1

this <div> has no class