h @%SSKJr SSKrSSKJr SSKrSSKrSSKJrJrJ r J r J r J r J r Jr SSKJrJr SSKJr SSKrSSKrSSKrSSKrSSKrSSKJr SSKrSSKrSSKJr SS KJr SS K J!r! SS K"J#r# S S K$J%r%J&r&J'r'J(r(J)r)J*r*J+r,J-r.J/r/ S SK07 S SK17 S SK2J3r3J4r4 S SK5J6r6 \Rnr8\9\:4r;S\"SS\'5r?"SS\5r@SSjrASSjrBSSjrCC'SSjrD\D"\R\RRS55(a\C"5 \H\I\J\K\L\M\N\O\P\Q\R1 rS\RrU\M\V\4rW\ \3\ \34rX\ \/\Y4\\3/\Y4\\V\3/\Y4\\9\V\3/\Y44rZ\\9\VS\[/S4r\\\9\VS\Y/S4r]\\9\V\VS\3\Y/S4r^\\9\VS\[\Y/S4r_\R\R-rbS \\x5rz"S?S@\z5r{"SASB\z5r|\z\vl}"SCSD\x5r~"SESF\z5r"SGSH\~5r"SISJ\x5r"SKSL\x5r"SMSN\5r"SOSP\x5r"SQSR\x5r"SSST\x5r"SUSV\x5r"SWSX\x5r"SYSZ\5r"S[S\\5r"S]S^\5r"S_S`\5r"SaSb\5r"ScSd\5r"SeSf\5r"SgSh\x5r"SiSj\v5r"SkSl\5r"SmSn\5r"SoSp\5r"SqSr\5r"SsSt\v5r"SuSv\5r"SwSx\5r"SySz\5r"S{S|\5r"S}S~\5r"SS\5r"SS\5r"SS\5r"SS\5r"SS\5r"SS\5r"SS5r"SS\5r\r"SS\5r"SS\5r"SS\5r"SS\5r"SS\5r"SS\5r"SS\5rSSjr\{"5GR[S5r\"5GR[S5r\"5GR[S5r\"5GR[S5r\"5GR[S5r\"S5GRgS5r\"S5GRgS5r\"S5GRgS5r\\-\-\"SS S9-r\"\\"S5-\-5r\z"S5\"S5GRsS5-\"\"\\-55GRsS5-\z"S5-rSSjrSSjrSSjr\"\"S5S-5GR[S5r\"\"S5S-5GR[S5r\"\"S5S-GR[S5\"S5S-GR[S5-5GR[S5r\"\"S\GRS9S-GR[S5\"S\GRS9S-GR[S5- \"S5S-GR[S5- \"S5S-GR[S5- 5GR[S5r\"S\R+5-5GR[S5r\"S5r\"S5r\"5GR5Vs/sHn\"U\v5(dMUPM snrS\3RDZSL CMSs#B/B/B5,B5;B;B;r<c8\rSrSrSrSrSrSrSrSr Sr S r S r S r g ) Diagnostics}a_ Diagnostic configuration (all default to disabled) - ``warn_multiple_tokens_in_named_alternation`` - flag to enable warnings when a results name is defined on a :class:`MatchFirst` or :class:`Or` expression with one or more :class:`And` subexpressions - ``warn_ungrouped_named_tokens_in_collection`` - flag to enable warnings when a results name is defined on a containing expression with ungrouped subexpressions that also have results names - ``warn_name_set_on_empty_Forward`` - flag to enable warnings when a :class:`Forward` is defined with a results name, but has no contents defined - ``warn_on_parse_using_empty_Forward`` - flag to enable warnings when a :class:`Forward` is defined in a grammar but has never had an expression attached to it - ``warn_on_assignment_to_Forward`` - flag to enable warnings when a :class:`Forward` is defined but is overwritten by assigning using ``'='`` instead of ``'<<='`` or ``'<<'`` - ``warn_on_multiple_string_args_to_oneof`` - flag to enable warnings when :class:`one_of` is incorrectly called with multiple str arguments - ``enable_debug_on_named_expressions`` - flag to auto-enable debug on all subsequent calls to :class:`ParserElement.set_name` Diagnostics are enabled/disabled by calling :class:`enable_diag` and :class:`disable_diag`. All warnings can be enabled by calling :class:`enable_all_warnings`. rrr*N)r+r,r-r.r/rMrNrOrPrQrRrSrTr7r*rIr:rXrX}s9.12-01-%&"()%$%!,-)/0,()%rIrXcB[RUR5 g)zG Enable a global pyparsing diagnostic flag (see :class:`Diagnostics`). N)r<rDrF diag_enums r: enable_diagrcs OOINN#rIcB[RUR5 g)zH Disable a global pyparsing diagnostic flag (see :class:`Diagnostics`). N)r<disablerFras r: disable_diagrfs Y^^$rIc,[R5 g)zM Enable all global pyparsing diagnostic warnings (see :class:`Diagnostics`). N)r<rGr*rIr:rGrGs   "rIcJ[U5nUHnUS-RS5SSupEpgnUR5RS5(dU(dU(dU(aUS:XaSnMaUR5RS5(dMUS;dMSnM U$) Nz:::::r]i pyparsingT)rkF)boolr5lowerr3) cmd_line_warn_options warn_env_varrDwarn_optw_action w_message w_categoryw_modulew_lines r:_should_enable_warningsrws, F)=E=NO2OF* MrIPYPARSINGENABLEALLWARNINGS ParserElementstralphas identcharsidentbodychars 0123456789nums ABCDEFabcdefhexnums alphanumsrl printablesc"\rSrSrSrSSjrSrg)_ParseActionIndexErrorz Internal wrapper around IndexError so that IndexErrors raised inside parse actions aren't misinterpreted as IndexErrors raised inside ParserElement parseImpl methods. cXlX lgrB)msgexc)selfrrs r:__init___ParseActionIndexError.__init__s "%rI)rrN)rrzr BaseExceptionrKrL)r+r,r-r.r/rr7r*rIr:rrs  &rIrztraceback.StackSummary_trim_arity_call_liner*cH^^^^T[;aU4Sj$SmSmSn[=(d [R"SS9Sq[=(d [S[SU-4qUUUU4S jn[ TS [ TS 5R 5nXClTRUlU$) zAdecorator to trim function calls to match the arity of the targetc>T"U5$rBr*)sltfuncs r:_trim_arity..s tAwrIrF rZlimitrch>T(aT "UT S6$T "UT S6nSmU$![a`nT(aeURn[R"USS9nUSnUSS/SSS[:HnAU(aT T :a T S- m SnAMreSnAf[ a n[ SU5RS5eSnAff=f)NrTrZrrz!IndexError raised in parse action) TypeError __traceback__ traceback extract_tbpa_call_line_synth IndexErrorrwith_traceback) argsrettetbframes frame_summarytrim_arity_type_errorie found_arityrr max_limits r:wrapper_trim_arity..wrappers ef& & 'DL)"   ))B&11"A>F$*2JM&r*+B/37II*, 9,!QJE$ ',7 .&' 's'  B1ABB B1B,,B1r+ __class__)_single_arg_builtinsrr extract_stackrgetattrr+r/)rr LINE_DIFFr func_namerrs`` @@r: _trim_arityrs ##&& EK I2YY5L5LST5UVX5Y+o0Ea0HJ_`aJbenJn/o ' 'Jj'$ *D*M*MNI llGO NrIc^^^UbUOSmU(a[O[m[T5m[T5UUU4Sj5nU$)a Function to convert a simple predicate function that returns ``True`` or ``False`` into a parse action. Can be used in places when a parse action is required and :class:`ParserElement.add_condition` cannot be used (such as when adding a condition to an operator level in :class:`infix_notation`). Optional keyword arguments: - ``message`` - define a custom message to be used in the raised exception - ``fatal`` - if True, will raise :class:`ParseFatalException` to stop parsing immediately; otherwise will raise :class:`ParseException` zfailed user-defined conditioncF>[T"XU55(d T"XT5egrB)rm)rrrexc_typefnrs r:pa%condition_as_parse_action..paUs&BqQK  1% %!rI)ParseFatalExceptionParseExceptionrr)rmessagefatalrrrs` @@r:condition_as_parse_actionrAsB ('.MC&+"H RB 2Y&& IrIcU(aSOSn[USUSUS[X5S[X5S[X5SS S [X533 5 g) NrrlMatch z at loc (,z) z ^>)printlinenocolline)instringlocexpr cache_hit cache_hit_strs r:_default_start_debug_actionr]sp%C"M oVD6#as8M7NaPSTWPbOcdc$%&Qs3)**+ -rIc\U(aSOSn[USUSUR535 g)NrrlzMatched z -> )ras_list)rstartlocendlocrtoksrrs r:_default_success_debug_actionrjs-%C"M ]O8D6dlln-= >?rIc lU(aSOSn[USUS[U5RSU35 g)Nrrlrz failed, z raised: )rtyper+)rrrrrrs r:_default_exception_debug_actionrvs7%C"M ]O6$yc1C1C0DIcU STrIcg)zG'Do-nothing' debug action, to suppress debugging output during parsing.Nr*)rs r:null_debug_actionrrIc\rSrSr%SrSrS\S'SrS\S'S rS \S '\ SS j5r \ SS j5r \ S5r "SS\5rSSSjjr\S5r\R&S5rSSjrSrSSjrSSS.SSjjjrSSSjjrSSSjjrSSjrSSjrSSjrSSjrSS jrSS!jrSSS"jjr S#r!SSS$jjr"SSS%.SS&jjr#SSS'jjr$\%"5r&0r'S(\S)'"S*S+\(RR5r*"S,S-\+5r,\,"5r-S+\S.'\%"5r.S/S//r/SSS0jjr0\"r1\ SS1j5r2Sr3Sr4\ SS2j5r5\ SSS3.SS4jjj5r6\ SSS3.SS5jjj5r7SSS6.SS7jjjr8\9SS4S\9S8.SS9jjjr:SS:.SS;jjr;\94S\9S8.SS<jjjr<\9S4SS=.SS>jjjr=SS?jr>SS@jr?SSAjr@SSBjrASSCjrBSSDjrCSSEjrDSSFjrESSGjrFSSHjrGSSIjrHSSJjrISSKjrJS rKSLrLSSSMjjrMSSNjrNSSSOjjrOSSSPjjrPSSSQjjrQSSRjrRSSSjrSSSTjrTSSSUjjrU\SSVj5rV\WSSWj5rXSSXjrY\SSYj5rZ\ZR&SSZj5rZSS[jr[SS\jr\SS]jr]SS^jr^S_r_SSS`jjr`SSS6.SSajjjraSbrbScrcSSS6.SSdjjjrdSSSSSS Se.SSfjjjreSSSgjjrf\ "\g"Sh\ 55rh\ "\g"Si\ 55ri\ "\g"Sj\555rj\ "\g"Sk\655rk\ "\g"Sl\755rl\ "\g"Sm\255rm\g"Sn\5rn\g"So\5ro\g"Sp\5rp\g"Sq\5rq\g"Sr\5rr\g"Ss\5rs\g"St\#5rt\g"Su\85ru\g"Sv\:5rv\g"Sw\;5rw\g"Sx\<5rx\g"Sy\O5ry\g"Sz\P5rz\g"S{\Q5r{\g"S|\R5r|\g"S}\T5r}\g"S~\U5r~\g"S\Y5r\g"S\a5r\g"S\e5r\g"S\$5r\VrSrg )ryiz)Abstract base level parser element class.z rzDEFAULT_WHITE_CHARSFrmverbose_stacktraceNr_literalStringClassczU[l[H&nUR(dM[ U5UlM( g)a Overrides the default whitespace chars Example:: # default whitespace chars are space, and newline Word(alphas)[1, ...].parse_string("abc def\nghi jkl") # -> ['abc', 'def', 'ghi', 'jkl'] # change to just treat newline as significant ParserElement.set_default_whitespace_chars(" \t") Word(alphas)[1, ...].parse_string("abc def\nghi jkl") # -> ['abc', 'def'] N)ryr_builtin_exprscopyDefaultWhiteCharsset whiteChars)charsrs r:set_default_whitespace_chars*ParserElement.set_default_whitespace_charss/-2 )#D)))"%e*#rIcU[lg)a Set class to be used for inclusion of string literals into a parser. Example:: # default literal class used is Literal integer = Word(nums) date_str = integer("year") + '/' + integer("month") + '/' + integer("day") date_str.parse_string("1999/12/31") # -> ['1999', '/', '12', '/', '31'] # change to Suppress ParserElement.inline_literals_using(Suppress) date_str = integer("year") + '/' + integer("month") + '/' + integer("day") date_str.parse_string("1999/12/31") # -> ['1999', '12', '31'] N)ryr)rEs r:inline_literals_using#ParserElement.inline_literals_usings (-0 )rIc+>^^# UU4SjU5ShvN gN7f)z Yields a sequence of ``class(obj, **class_kwargs)`` for obj in seq. Example:: LPAR, RPAR, LBRACE, RBRACE, SEMI = Suppress.using_each("(){};") c36># UHnT"U40TD6v M g7frBr*)r8obj class_kwargsrEs r: +ParserElement.using_each..s<C,|,sNr*)rEseqrs` `r: using_eachParserElement.using_eachs=<<(;+;##D99rIcUcU$UR5nURS5(aUSSnSnXlU(+UlU$)NrrT)r-endswithrr )rrFr3newselfs r:r2ParserElement._setResultsNameMsM <K))+ ==  9D# "#33rITc^U(a#URmSU4SjjnTUlX lU$[URS5(aURRUlU$)z Method to invoke the Python pdb debugger when this element is about to be parsed. Set ``break_flag`` to ``True`` to enable, ``False`` to disable. c*>[5 T"XX#5$rB) breakpoint)rr do_actions callPreParse _parseMethods r:breaker(ParserElement.set_break..breakeras #H:LLrI_originalParseMethodTT)_parserBhasattr)r break_flagr@r?s @r: set_breakParserElement.set_breakXsW ;;L M ,8G (!K T[["8 9 9++::DK rIcL[U5S/:XaURR5 U$[SU55(d [ S5eUVs/sHn[ U5PM snURSS&UR SUR SS55UlU$s snf)a Define one or more actions to perform when successfully matching parse element definition. Parse actions can be called to perform data conversions, do extra validation, update external data structures, or enhance or replace the parsed tokens. Each parse action ``fn`` is a callable method with 0-3 arguments, called as ``fn(s, loc, toks)`` , ``fn(loc, toks)`` , ``fn(toks)`` , or just ``fn()`` , where: - ``s`` = the original string being parsed (see note below) - ``loc`` = the location of the matching substring - ``toks`` = a list of the matched tokens, packaged as a :class:`ParseResults` object The parsed tokens are passed to the parse action as ParseResults. They can be modified in place using list-style append, extend, and pop operations to update the parsed list elements; and with dictionary-style item set and del operations to add, update, or remove any named results. If the tokens are modified in place, it is not necessary to return them with a return statement. Parse actions can also completely replace the given tokens, with another ``ParseResults`` object, or with some entirely different object (common for parse actions that perform data conversions). A convenient way to build a new parse result is to define the values using a dict, and then create the return value using :class:`ParseResults.from_dict`. If None is passed as the ``fn`` parse action, all previously added parse actions for this expression are cleared. Optional keyword arguments: - ``call_during_try`` = (default= ``False``) indicate if parse action should be run during lookaheads and alternate testing. For parse actions that have side effects, it is important to only call the parse action once it is determined that it is being called as part of a successful parse. For parse actions that perform additional validation, then call_during_try should be passed as True, so that the validation code is included in the preliminary "try" parses. Note: the default parsing behavior is to expand tabs in the input string before starting the parsing process. See :class:`parse_string` for more information on parsing strings containing ```` s, and suggested methods to maintain a consistent view of the parsed string, the parse location, and line and column positions within the parsed string. Example:: # parse dates in the form YYYY/MM/DD # use parse action to convert toks from str to int at parse time def convert_to_int(toks): return int(toks[0]) # use a parse action to verify that the date is a valid date def is_valid_date(instring, loc, toks): from datetime import date year, month, day = toks[::2] try: date(year, month, day) except ValueError: raise ParseException(instring, loc, "invalid date given") integer = Word(nums) date_str = integer + '/' + integer + '/' + integer # add parse actions integer.set_parse_action(convert_to_int) date_str.set_parse_action(is_valid_date) # note that integer fields are now ints, not strings date_str.run_tests(''' # successful parse - note that integer fields were converted to ints 1999/12/31 # fail - invalid date 1999/13/31 ''') Nc38# UHn[U5v M g7frB)callable)r8rs r:r1ParserElement.set_parse_action..s.#B8B<<#zparse actions must be callablecall_during_tryrF)rrclearallrrgetrrfnskwargsrs r:set_parse_actionParserElement.set_parse_actionlsV 9     " " $K.#...<= =9<=2{2=#ZZ vzz/5A  >sB!cU=RUVs/sHn[U5PM sn- slUR=(d" URSURSS55UlU$s snf)z Add one or more parse actions to expression's list of parse actions. See :class:`set_parse_action`. See examples in :class:`copy`. rNrF)rrrrQrRs r:add_parse_actionParserElement.add_parse_actionsb s;s[_s;;!// 6:: vzz/5A4  = 2000, message="Only support years 2000 and later") date_str = year_int + '/' + integer + '/' + integer result = date_str.parse_string("1999/12/31") # -> Exception: Only support years 2000 and later (at char 0), (line:1, col:1) rrF)rrrNr)rrrrzrQrmrrRs r: add_conditionParserElement.add_conditions.B    # #) 9 56vzz'59: "// 6:: vzz/5A4  rIcXlU$)a Define action to perform if parsing fails at this expression. Fail acton fn is a callable function that takes the arguments ``fn(s, loc, expr, err)`` where: - ``s`` = string being parsed - ``loc`` = location where expression match was attempted and failed - ``expr`` = the parse expression that failed - ``err`` = the exception thrown The function returns no value. It may throw :class:`ParseFatalException` if it is desired to stop parsing immediately.)r)rrs r:set_fail_actionParserElement.set_fail_actions rIcUR(dU$SnURVs/sHoDRPM nnUnU(a,SnUHnU"X5up(SnM X&:XaU$UnU(aM,U$s snf![a M<f=fNTF)rrDr) rrr exprsFoundeignore_expr_fnslast_loc ignore_fndummys r:_skipIgnorablesParserElement._skipIgnorablessJ -1-=-=>-=88-=>J, %.x%= %) - Hj ?&sA2 A77 BBcUR(aURX5nUR(a8[U5nURnX#:aXU;aUS- nX#:a XU;aMU$Nr)rrhrlenr)rrrinstrlen white_charss r:preParseParserElement.preParsesd   &&x5C   8}H//K.X]k%Aq.X]k%A rIc U/4$rBr*rrrr=s r: parseImplParserElement.parseImpl& BwrIcU$rBr*rrr tokenlists r: postParseParserElement.postParse)srIc .URn[U5nU(dUR(aU(a#UR(aUR X5nOUnUnUR R (aUR R XUS5 UR(dXv:aURXU5up)OURXU5up)OnU(a#UR(aUR X5nOUnUnUR(dXv:aURXU5up)OURXU5up)URXU 5n [XR UR"UR$S9n UR&(aU(dUR((aU(aqUR&H_n U "XU 5n U cMXLdM[U UR UR"=(a [+U [[,45UR$S9n Ma OoUR&H_n U "XU 5n U cMXLdM[U UR UR"=(a [+U [[,45UR$S9n Ma U(a9UR R.(aUR R/XX U S5 X+4$![a [XURU5ef=f![acn UR R(aUR RUWX S5 UR(aURUWX 5 eSn A ff=f![a [XURU5ef=f![an [S5nXeSn A ff=f![a>n UR R(aUR RXX S5 eSn A ff=f![an [S5nXeSn A ff=f)NF)asListmodalz exception raised in parse action)rrlrrror rr rsrrr  Exceptionrryr rrr rr isinstancerr)rrrr=r> debugging len_instringpre_loc tokens_starttokenserr ret_tokensrparse_action_excrs r: _parseNoCacheParserElement._parseNoCache-sJJ 8}  D$5$5"mmH:G!G& $$..%%//eT%%)@X&*nnX &S V#'..J"OKC 1 1--6"L!!W%<T"&..J"OKC#nnX K v6! $$T__DDUDU    t/A/A"..<%' %KF "-&2J)5 & $ 0 0'+(M$.v d7K$L&*&7&7 *J/.**B8!#HJ!G )f.F%1" ,,#'??$I *6L$3G H"&"3"3 & +   ,,!!--Cz5a&X,XT[[RVWWX $$//%%00 ,5??OOHlDF $"T(dSST *<"01S"TC"%;<!((33))44$Du &8,-OP!78sAHITMISSlookupcacherpeloc_resultrs r: _parseCacheParserElement._parseCaches9 #Z@  - -!//EIIf%E***11$71<7! ..xjWE IIfQxq#&FG . -11#6!;6::$"3"3"="=))33H4SW3XeY//zzd&7&7&B&B! --88 (td9  K%KU3 c#9:EB',Qxq%(f::$"3"3"?"?))55$F&D6 |S. -*IIfllBGG&<=% )! K!%M. -sA I/&H8)I/+AI/3H=AI/I+A.I/I6I/ H: )H55H::I/= I I/ I  I/ II/II/ I,)I/+I,,I// I=c[RR5 S/[[R5-[RSS&[R R5 gNr)ryrrOrlrrr*rIr: reset_cacheParserElement.reset_cachesO##))+01sS  - -6 0 ))!, %%++-rIc[R5 S[lS[l[R[lg)z Disables active Packrat or Left Recursion parsing and their memoization This method also works if neither Packrat nor Left Recursion are enabled. This makes it safe to call before activating Packrat nor Left Recursion to clear any previous settings. FN)ryr_left_recursion_enabled_packratEnabledrrDr*rIr:disable_memoization!ParserElement.disable_memoizations. !!#05 -(- %,:: rI)forcecU(a[R5 O [R(a [S5eUc[ 5[lO'US:a[ US9[lO[SU35eS[lg)ao Enables "bounded recursion" parsing, which allows for both direct and indirect left-recursion. During parsing, left-recursive :class:`Forward` elements are repeatedly matched with a fixed recursion depth that is gradually increased until finding the longest match. Example:: import pyparsing as pp pp.ParserElement.enable_left_recursion() E = pp.Forward("E") num = pp.Word(pp.nums) # match `num`, or `num '+' num`, or `num '+' num '+' num`, ... E <<= E + '+' - num | num print(E.parse_string("1+2+3")) Recursion search naturally memoizes matches of ``Forward`` elements and may thus skip reevaluation of parse actions during backtracking. This may break programs with parse actions which rely on strict ordering of side-effects. Parameters: - ``cache_size_limit`` - (default=``None``) - memoize at most this many ``Forward`` elements during matching; if ``None`` (the default), memoize all ``Forward`` elements. Bounded Recursion parsing works similar but not identical to Packrat parsing, thus the two cannot be used together. Use ``force=True`` to disable any previous, conflicting settings. 0Packrat and Bounded Recursion are not compatibleNr)capacityz Memo size of T) ryrr RuntimeError_UnboundedMemor_LRUMemoNotImplementedErrorrcache_size_limitrs r:enable_left_recursion#ParserElement.enable_left_recursionslH   - - /  * *QR R  #,:,N,OM )% 6F5G&HI I04 -rIcFU(a[R5 O [R(a [S5e[R(agS[lUc[ 5[lO[U5[l[R[l g)a Enables "packrat" parsing, which adds memoizing to the parsing logic. Repeated parse attempts at the same string location (which happens often in many complex grammars) can immediately return a cached value, instead of re-executing parsing/validating code. Memoizing is done of both valid results and parsing exceptions. Parameters: - ``cache_size_limit`` - (default= ``128``) - if an integer value is provided will limit the size of the packrat cache; if None is passed, then the cache size will be unbounded; if 0 is passed, the cache will be effectively disabled. This speedup may break existing programs that use parse actions that have side-effects. For this reason, packrat parsing is disabled when you first import pyparsing. To activate the packrat feature, your program must call the class method :class:`ParserElement.enable_packrat`. For best results, call ``enable_packrat()`` immediately after importing pyparsing. Example:: import pyparsing pyparsing.ParserElement.enable_packrat() Packrat parsing works similar but not identical to Bounded Recursion parsing, thus the two cannot be used together. Use ``force=True`` to disable any previous, conflicting settings. rNT) ryrrrrrrrrrDrs r:enable_packratParserElement.enable_packratOsjD   - - /  2 2QR R  ( ( (, %  #*9*;M '*45E*FM ',88 rI)parseAllcvU=(d Un[R5 UR(dUR5 URHnUR5 M UR (dUR 5nURUS5upVU(aFURX5n[5[5RS5-nURX5 U$![anUReSnAf[a,n [R(aeU R!S5eSn A ff=f)a@ Parse a string with respect to the parser definition. This function is intended as the primary interface to the client code. :param instring: The input string to be parsed. :param parse_all: If set, the entire input string must match the grammar. :param parseAll: retained for pre-PEP8 compatibility, will be removed in a future release. :raises ParseException: Raised if ``parse_all`` is set and the input string does not match the whole grammar. :returns: the parsed data as a :class:`ParseResults` object, which may be accessed as a `list`, a `dict`, or an object with attributes if the given parser includes results names. If the input string is required to match the entire grammar, ``parse_all`` flag must be set to ``True``. This is also equivalent to ending the grammar with :class:`StringEnd`\ (). To report proper column numbers, ``parse_string`` operates on a copy of the input string where all tabs are converted to spaces (8 spaces per tab, as per the default in ``string.expandtabs``). If the input string contains tabs and the grammar uses parse actions that use the ``loc`` argument to index into the string being parsed, one can ensure a consistent view of the input string by doing one of the following: - calling ``parse_with_tabs`` on your grammar before calling ``parse_string`` (see :class:`parse_with_tabs`), - define your parse action using the full ``(s,loc,toks)`` signature, and reference the input string using the parse action's ``s`` argument, or - explicitly expand the tabs in your input string before calling ``parse_string``. Examples: By default, partial matches are OK. >>> res = Word('a').parse_string('aaaaabaaa') >>> print(res) ['aaaaa'] The parsing behavior varies by the inheriting class of this abstract class. Please refer to the children directly to see more examples. It raises an exception if parse_all flag is set and instring does not match the whole grammar. >>> res = Word('a').parse_string('aaaaabaaa', parse_all=True) Traceback (most recent call last): ... pyparsing.ParseException: Expected end of text, found 'b' (at char 5), (line:1, col:6) rFN)ryrr  streamlinerr expandtabsrDroEmpty StringEnd set_debugrrrrr) rr parse_allrrcrrsepa_excrs r: parse_stringParserElement.parse_stringsZ(!!# OO !!A LLN"}}**,H ++h2KCmmH2Wy{44U;; ((M& ** ! +//$$T* *  +s%A!C)) D83 C?? D8 'D33D8)r maxMatchesc## [Xb5nUR(dUR5 URHnUR5 M UR(d[ U5R 5n[U5nSn U(a9[5n URU lURU l U Rn O URn URn [R5 Sn X::aX:a|U "X5nU "XSS9unnX:aPU S- n U(a[UR5UUS.5 UX4v U(aU "X5nUU :aUn OU S- n O Un OUS-n X::aX:aMzgggg![ a WS-n N!f=f!["a,n[R$(aeUR'S5eSnAff=f7f)a Scan the input string for expression matches. Each match will return the matching tokens, start location, and end location. May be called with optional ``max_matches`` argument, to clip scanning after 'n' matches are found. If ``overlap`` is specified, then overlapping matches will be reported. Note that the start and end locations are reported relative to the string being parsed. See :class:`parse_string` for more information on parsing strings with embedded tabs. Example:: source = "sldjf123lsdjjkf345sldkjf879lkjsfd987" print(source) for tokens, start, end in Word(alphas).scan_string(source): print(' '*start + '^'*(end-start)) print(' '*start + tokens[0]) prints:: sldjf123lsdjjkf345sldkjf879lkjsfd987 ^^^^^ sldjf ^^^^^^^ lsdjjkf ^^^^^^ sldkjf ^^^^^^ lkjsfd rFr>r)rstartendN)minr rrrrzrrlrrrorDry resetCacherr|rrrr)rr max_matchesoverlapalways_skip_whitespacerrrcrmr preparser preparseFnparseFnmatchesprelocnextLocrnextlocrs r: scan_stringParserElement.scan_stringsP1  OO !!A LLN"}}8}//1Hx= !I$($4$4I !#'??I "++JJ++  "$ +/g&:)",X";F'.hU&SOGV}1  !.4mmo-3+2!"%f55"&0&?G&}&- #q")C$qj;/g&:/&:/ &% 1*C%0" +//$$T* *  +sOC5G8 FFA%F<GFFFF G 'GG  Grc/nSnSUlURXS9HupVnXd:aURXU5 UnU(dM)[U[5(aX5R 5- nMR[U[ 5(a([U[5(dURU5 MURU5 M URXS5 UVs/sH o(dM UPM nnSR[U5Vs/sHn[U5PM sn5$s snfs snf![a,n [R(aeU RS5eSn A ff=f)a Extension to :class:`scan_string`, to modify matching text with modified tokens that may be returned from a parse action. To use ``transform_string``, define a grammar and attach a parse action to it that modifies the returned token list. Invoking ``transform_string()`` on a target string will then scan for matches, and replace the matched text patterns according to the logic in the parse action. ``transform_string()`` returns the resulting transformed string. Example:: wd = Word(alphas) wd.set_parse_action(lambda toks: toks[0].title()) print(wd.transform_string("now is the winter of our discontent made glorious summer by this sun of york.")) prints:: Now Is The Winter Of Our Discontent Made Glorious Summer By This Sun Of York. rTrNrl)rrrrr rrr#r%joinrrzrryrr) rrroutlastErrrcors r:transform_stringParserElement.transform_string)s*(  +++H+Ba9JJxa01a..99;&C8,,Z85L5LJJqMJJqMC JJx' (!'cQ1cC'77HSM:MqCFM:; ;(:! +//$$T* *  +s<C D+ D!%D!+D+D&D+! D++ E!5'EE!c [XB5n[URXSUS9VVVs/sHupVnUPM snnn5$s snnnf![a,n[R (aeUR S5eSnAff=f)a< Another extension to :class:`scan_string`, simplifying the access to the tokens found to match the given parse expression. May be called with optional ``max_matches`` argument, to clip searching after 'n' matches are found. Example:: # a capitalized word starts with an uppercase letter, followed by zero or more lowercase letters cap_word = Word(alphas.upper(), alphas.lower()) print(cap_word.search_string("More than Iron, more than Lead, more than Gold I need Electricity")) # the sum() builtin can be used to merge results into a single ParseResults object print(sum(cap_word.search_string("More than Iron, more than Lead, more than Gold I need Electricity"))) prints:: [['More'], ['Iron'], ['Lead'], ['Gold'], ['I'], ['Electricity']] ['More', 'Iron', 'Lead', 'Gold', 'I', 'Electricity'] F)rrN)rr rrryrr) rrrrrrrrcrs r: search_stringParserElement.search_string\s81  +$(#3#3 URW$4$$a$ " +//$$T* *  +s%A? AA A<'A77A<)includeSeparatorsc## U=(d UnSnURXS9HupgnXUv U(aUSv UnM XSv g7f)a Generator method to split a string using the given expression as a separator. May be called with optional ``maxsplit`` argument, to limit the number of splits; and the optional ``include_separators`` argument (default= ``False``), if the separating matching text should be included in the split results. Example:: punc = one_of(list(".,;:/-!?")) print(list(punc.split("This, this?, this sentence, is badly punctuated!"))) prints:: ['This', ' this', '', ' this sentence', ' is badly punctuated', ''] r)rN)r) rrmaxsplitinclude_separatorsrlastrrrcs r:r5ParserElement.splits]..C1C'''GGA!" " d D H uosAAcU[La [U5$[U[5(aUR U5n[U[ 5(d[ $[X/5$)a Implementation of ``+`` operator - returns :class:`And`. Adding strings to a :class:`ParserElement` converts them to :class:`Literal`\ s by default. Example:: greet = Word(alphas) + "," + Word(alphas) + "!" hello = "Hello, World!" print(hello, "->", greet.parse_string(hello)) prints:: Hello, World! -> ['Hello', ',', 'World', '!'] ``...`` may be used as a parse expression as a short form of :class:`SkipTo`:: Literal('start') + ... + Literal('end') is equivalent to:: Literal('start') + SkipTo('end')("_skipped*") + Literal('end') Note that the skipped text is returned with '_skipped' as a results name, and to support having multiple skips in the same parser, the value returned is a list of all skipped text. )Ellipsis _PendingSkiprr#rryNotImplementedAndrothers r:__add__ParserElement.__add__sT6 H % % eX & &,,U3E%//! !D=!!rIcU[La[U5"S5U-$[U[5(aUR U5n[U[ 5(d[ $X-$)zT Implementation of ``+`` operator when left operand is not a :class:`ParserElement` _skipped*)rSkipTorr#rryrrs r:__radd__ParserElement.__radd__sX H $< ,t3 3 eX & &,,U3E%//! !|rIc[U[5(aURU5n[U[5(d[$U[ R 5-U-$)zH Implementation of ``-`` operator, returns :class:`And` with error stop )rr#rryrr _ErrorStoprs r:__sub__ParserElement.__sub__sK eX & &,,U3E%//! !cnn&&..rIc[U[5(aURU5n[U[5(d[$X- $)zT Implementation of ``-`` operator when left operand is not a :class:`ParserElement` rr#rryrrs r:__rsub__ParserElement.__rsub__< eX & &,,U3E%//! !|rIc^^U[LaSnO1[U[5(aUSS[4:XaSUSS-S-SSn[U[[45(d[$[U[5(aUSp2O[SU55nUS -SSnUScSUS4n[US[5(aBUSc<USS:Xa [ T5$USS:Xa [ T5$TUS-[ T5-$[US[5(a![US[5(a Uup#X2-nO[$US:a [S 5eUS:a [S 5eX#s=:XaS:XaO O [/5$U(aGUU4S jmU(a.US:Xa TT"U5-nU$[T/U-5T"U5-nU$T"U5nU$US:XaTnU$[T/U-5nU$) ae Implementation of ``*`` operator, allows use of ``expr * 3`` in place of ``expr + expr + expr``. Expressions may also be multiplied by a 2-integer tuple, similar to ``{min, max}`` multipliers in regular expressions. Tuples may also include ``None`` as in: - ``expr*(n, None)`` or ``expr*(n, )`` is equivalent to ``expr*n + ZeroOrMore(expr)`` (read as "at least n instances of ``expr``") - ``expr*(None, n)`` is equivalent to ``expr*(0, n)`` (read as "0 to n instances of ``expr``") - ``expr*(None, None)`` is equivalent to ``ZeroOrMore(expr)`` - ``expr*(1, None)`` is equivalent to ``OneOrMore(expr)`` Note that ``expr*(None, n)`` does not raise an exception if more than n exprs exist in the input stream; that is, ``expr*(None, n)`` does not enforce a maximum number of expr occurrences. If this behavior is desired, then write ``expr*(None, n) + ~expr`` )rNNrrrBrZrc3:# UHo[LaUOSv M g7frB)r)r8rs r:r(ParserElement.__mul__..sJEq0!d:Es)NNz/cannot multiply ParserElement by negative valuez@second tuple value must be greater or equal to first tuple valuecT>US:a[TT"US- 5-5$[T5$rk)Opt)nmakeOptionalListrs r:r!/ParserElement.__mul__..makeOptionalList*s.q5t&6q1u&==>>t9$rI) rrrrr ZeroOrMore OneOrMore ValueErrorr)rr  minElements optElementsrr!s` @r:__mul__ParserElement.__mul__s* H E u % %%){*BE!"I%/!4E%#u..! ! eS ! !',aJEJJE\)2A.EQxE!H %(C((U1X-=8q=%d++8q=$T?*%(?Z-===E!Hc**z%(C/H/H+0( * %% ?NO O ?R   * *r7N  % !#!1+!>>C tf{236F{6SSC '{3  a 4&;./ rIc$URU5$rB)r(rs r:__rmul__ParserElement.__rmul__>s||E""rIcU[La [USS9$[U[5(a"US:Xa [ U5$UR U5n[U[ 5(d[$[X/5$)z@ Implementation of ``|`` operator - returns :class:`MatchFirst` T) must_skiprl) rrrr#rrryr MatchFirstrs r:__or__ParserElement.__or__Asg H 5 5 eX & &{4y ,,U3E%//! !4-((rIc[U[5(aURU5n[U[5(d[$X-$)zT Implementation of ``|`` operator when left operand is not a :class:`ParserElement` rrs r:__ror__ParserElement.__ror__QrrIc[U[5(aURU5n[U[5(d[$[ X/5$)z8 Implementation of ``^`` operator - returns :class:`Or` )rr#rryrOrrs r:__xor__ParserElement.__xor__[sA eX & &,,U3E%//! !4-  rIc[U[5(aURU5n[U[5(d[$X- $)zT Implementation of ``^`` operator when left operand is not a :class:`ParserElement` rrs r:__rxor__ParserElement.__rxor__errIc[U[5(aURU5n[U[5(d[$[ X/5$)z: Implementation of ``&`` operator - returns :class:`Each` )rr#rryrEachrs r:__and__ParserElement.__and__osA eX & &,,U3E%//! !TM""rIc[U[5(aURU5n[U[5(d[$X-$)zT Implementation of ``&`` operator when left operand is not a :class:`ParserElement` rrs r:__rand__ParserElement.__rand__yrrIc[U5$)z< Implementation of ``~`` operator - returns :class:`NotAny` )NotAnyrs r: __invert__ParserElement.__invert__sd|rIcSn[5n[U[5(aURURp1UcSnSnOQ[U[ 5(a<[US[5(a$USUSR4USRp1Sn[U[ 5(aU4n[U5 [U5S:a2[S USS [U5S :aS [U5S 3OS S35eU[ USS5-n[R"[U5nU(aURU5 U$![a X4nNf=f)a  use ``[]`` indexing notation as a short form for expression repetition: - ``expr[n]`` is equivalent to ``expr*n`` - ``expr[m, n]`` is equivalent to ``expr*(m, n)`` - ``expr[n, ...]`` or ``expr[n,]`` is equivalent to ``expr*n + ZeroOrMore(expr)`` (read as "at least n instances of ``expr``") - ``expr[..., n]`` is equivalent to ``expr*(0, n)`` (read as "0 to n instances of ``expr``") - ``expr[...]`` and ``expr[0, ...]`` are equivalent to ``ZeroOrMore(expr)`` - ``expr[1, ...]`` is equivalent to ``OneOrMore(expr)`` ``None`` may be used in place of ``...``. Note that ``expr[..., n]`` and ``expr[m, n]`` do not raise an exception if more than ``n`` ``expr``\ s exist in the input stream. If this behavior is desired, then write ``expr[..., n] + ~expr``. For repetition with a stop_on expression, use slice notation: - ``expr[...: end_expr]`` and ``expr[0, ...: end_expr]`` are equivalent to ``ZeroOrMore(expr, stop_on=end_expr)`` - ``expr[1, ...: end_expr]`` is equivalent to ``OneOrMore(expr, stop_on=end_expr)`` FN.TrrrrZz'only 1 or 2 index arguments supported (r]z... []rl))NoMatchrslicerstoprr#iterrrltypingr _MultipleMatchstopOn)rkeystop_on_definedstop_onrs r: __getitem__ParserElement.__getitem__sC6 ) c5 ! !99chh{"O U # # 3r7E(B(BFCFLL13q6;;"O c8 $ $&C  I s8a<9#bq'Z]^aZbefZfU3s8*TUCVlnBoopq  U3r7^#kk.#.  JJw   *C s+ D== E  E cJUbURU5$UR5$)a Shortcut for :class:`set_results_name`, with ``list_all_matches=False``. If ``name`` is given with a trailing ``'*'`` character, then ``list_all_matches`` will be passed as ``True``. If ``name`` is omitted, same as calling :class:`copy`. Example:: # these are equivalent userdata = Word(alphas).set_results_name("name") + Word(nums + "-").set_results_name("socsecno") userdata = Word(alphas)("name") + Word(nums + "-")("socsecno") )r2r-rrFs r:__call__ParserElement.__call__s'  ''- -yy{rIc[U5$)zv Suppresses the output of this :class:`ParserElement`; useful to keep punctuation from cluttering up returned output. )Suppressrs r:suppressParserElement.suppresss ~rIcSUlU$)z Enables the skipping of whitespace before matching the characters in the :class:`ParserElement`'s defined pattern. :param recursive: If ``True`` (the default), also enable whitespace skipping in child elements (if any) Trr recursives r:ignore_whitespaceParserElement.ignore_whitespaces# rIcSUlU$)aT Disables the skipping of whitespace before matching the characters in the :class:`ParserElement`'s defined pattern. This is normally only used internally by the pyparsing module, but may be needed in some whitespace-sensitive grammars. :param recursive: If true (the default), also disable whitespace skipping in child elements (if any) Fr_r`s r:leave_whitespaceParserElement.leave_whitespaces$ rIc@SUl[U5UlX lU$)z( Overrides the default whitespace chars T)rrrr)rr copy_defaultss r:set_whitespace_chars"ParserElement.set_whitespace_charss" #e*%2" rIcSUlU$)z Overrides default behavior to expand ```` s to spaces before parsing the input string. Must be called before ``parse_string`` when the input grammar contains elements that match ```` characters. T)rrs r:parse_with_tabsParserElement.parse_with_tabss   rIc,[U[5(a [U5n[U[5(a,XR;aURR U5 U$URR [UR 555 U$)a Define expression to be ignored (e.g., comments) while doing pattern matching; may be called repeatedly, to define multiple comment or other ignorable patterns. Example:: patt = Word(alphas)[...] patt.parse_string('ablaj /* comment */ lskjd') # -> ['ablaj'] patt.ignore(c_style_comment) patt.parse_string('ablaj /* comment */ lskjd') # -> ['ablaj', 'lskjd'] )rr#r[rrr-rs r:ignoreParserElement.ignore st eX & &UOE eX & &,,,  ''.     # #HUZZ\$: ; rIcURU=(d [U=(d [U=(d [5UlSUlU$)a Customize display of debugging messages while doing pattern matching: - ``start_action`` - method to be called when an expression is about to be parsed; should have the signature ``fn(input_string: str, location: int, expression: ParserElement, cache_hit: bool)`` - ``success_action`` - method to be called when an expression has successfully parsed; should have the signature ``fn(input_string: str, start_location: int, end_location: int, expression: ParserELement, parsed_tokens: ParseResults, cache_hit: bool)`` - ``exception_action`` - method to be called when expression fails to parse; should have the signature ``fn(input_string: str, location: int, expression: ParserElement, exception: Exception, cache_hit: bool)`` T)rrrrr r)r start_actionsuccess_actionexception_actions r:set_debug_actionsParserElement.set_debug_actions's@$!--  77  ;;  ? ?    rIcU(a)UR5HnURUSS9 M U$U(a!UR[[[ 5 U$SUlU$)a Enable display of debugging messages while doing pattern matching. Set ``flag`` to ``True`` to enable, ``False`` to disable. Set ``recurse`` to ``True`` to set the debug flag on this expression and all sub-expressions. Example:: wd = Word(alphas).set_name("alphaword") integer = Word(nums).set_name("numword") term = wd | integer # turn on debugging for wd wd.set_debug() term[1, ...].parse_string("abc 123 xyz 890") prints:: Match alphaword at loc 0(1,1) Matched alphaword -> ['abc'] Match alphaword at loc 3(1,4) Exception raised:Expected alphaword (at char 4), (line:1, col:5) Match alphaword at loc 7(1,8) Matched alphaword -> ['xyz'] Match alphaword at loc 11(1,12) Exception raised:Expected alphaword (at char 12), (line:1, col:13) Match alphaword at loc 15(1,16) Exception raised:Expected alphaword (at char 15), (line:1, col:16) The output shown is that produced by the default debug actions - custom debug actions can be specified using :class:`set_debug_actions`. Prior to attempting to match the ``wd`` expression, the debugging message ``"Match at loc (,)"`` is shown. Then if the parse succeeds, a ``"Matched"`` message is shown, or an ``"Exception raised"`` message is shown. Also note the use of :class:`set_name` to assign a human-readable name to the expression, which makes debugging and exception messages easier to understand - for instance, the default name created for the :class:`Word` expression without calling ``set_name`` is ``"W:(A-Za-z)"``. F)r&)r*rrurrrr)rflagr&rs r:rParserElement.set_debugAs]L (tU3)K   " "+-/  DJ rIc^URcUR5UlUR$rB)r_generateDefaultNamers r: default_nameParserElement.default_namevs+    $ $ 9 9 ;D    rIcg)zW Child classes must define this method, which defines how the ``default_name`` is set. Nr*rs r:r{"ParserElement._generateDefaultName|rrIcXlS[U53Ul[R(aUR USL5 U$)ao Define name for this expression, makes debugging and exception messages clearer. If `__diag__.enable_debug_on_named_expressions` is set to True, setting a name will also enable debug for this expression. If `name` is None, clears any custom name for this expression, and clears the debug flag is it was enabled via `__diag__.enable_debug_on_named_expressions`. Example:: integer = Word(nums) integer.parse_string("ABC") # -> Exception: Expected W:(0-9) (at char 0), (line:1, col:1) integer.set_name("integer") integer.parse_string("ABC") # -> Exception: Expected integer (at char 0), (line:1, col:1) Expected N)rrzr r<rTrrWs r:set_nameParserElement.set_names:"!#d)-  5 5 NN4t+ , rIcLURb UR$UR$rB)rr|rs r:rFParserElement.names"#'//"=tT4CTCTTrIc&URU5 grB)r)rnew_names r:rFrs hrIcUR$rBrFrs r:__str__ParserElement.__str__s yyrIc[U5$rBrzrs r:__repr__ParserElement.__repr__s 4yrIc"SUlSUlU$NT)r rrs r:rParserElement.streamlines  rIc/$rBr*rs r:r&ParserElement.recurse rIcfUSSU/-nUR5HnURU5 M grB)r&_checkRecursionrparseElementListsubRecCheckListrcs r:rParserElement._checkRecursions1*1-6A  o . rIcZ[R"S[SS9 UR/5 g)zZ Check defined expressions for valid structure, check for infinite recursive definitions. ZParserElement.validate() is deprecated, and should not be used to check for left recursionrZ stacklevelN)warningsr?DeprecationWarningr)r validateTraces r:validateParserElement.validates)  h  R rIcU=(d Un[R"[U5nUR5nURWU5$![aU [R"[ U5n[ USUS9nUR5nSSS5 M_!,(df  Nn=ff=f![a,n[R(aeURS5eSnAff=f)z Execute the parse expression on the given file or filename. If a filename is specified (instead of a file object), the entire file is opened, read, and closed before parsing. rencodingN) rNr r readAttributeErrorrzopenrrryrr)rfile_or_filenamerrr file_contentsfrs r: parse_fileParserElement.parse_files(y )%{{63CD ,113M  +$$]H= =  )%{{30@A &h?1 ! @??? ) " +//$$T* *  +s@+A B- 0B*;B B* B& !B*&B*- C#7'CC#cXLag[U[5(aURUSS9$[U[5(a[ U5[ U5:H$g)NTrF)rr#rryvarsrs r:__eq__ParserElement.__eq__sM = x ( (<<<6 6 } - -:e, ,rIc[U5$rB)idrs r:__hash__ParserElement.__hash__s $xrIcnU=(a UnUR[U5US9 g![a gf=f)a Method for quick testing of a parser against a test string. Good for simple inline microtests of sub expressions while building up larger parser. Parameters: - ``test_string`` - to test against this expression for a match - ``parse_all`` - (default= ``True``) - flag to pass to :class:`parse_string` when running tests Example:: expr = Word(nums) assert expr.matches("100") rTF)rrzr)r test_stringrrs r:rParserElement.matchess@")     c+.(  C!  s ' 44)rfullDump printResults failureTestsryc   SSKJn U =(a Un U =(a Un U =(a Un U =(d Un U=(d Un[U[5(ad[R "[ U5n[U5RnUR5R5Vs/sH nU"U5PM nnUSLnU(a;[U[5(a&[R "[ U5n[U5n[R "[U5nUc[RnURn/n/nSn[S5R![#S55R%[&5nSnSnUGHnU(aUR)US5(dU(a2U(d+UR+U (aUR-U5OU5 M[U(dMdUU(aUR/U5OS 3U (aUR-U5OU/nUR15 UR3UR5U55nUR7UU S 9nU=(a U (+nUb}U"UU5nUbP[U[85(a UR+UR;55 OZUR+[ U55 O?UR+UR;55 OUR+UR;U S 95 UR+S 5 U (aU"SR/U55 UR+UU45 GM UU4$s snf![<a^nUR+UR;U S 95 UR+UR>S [U5R>S U35 SnANSnAff=f![@an[U[B5(aSOS n UR+URE55 UR+SU U35 [RF(a/URI[JRL"URN55 U=(a U nUnSnAGNjSnAf[<Gan!Sn"U!RNn#[Q[JRR"U#55n$U$HTun%n&U%RTRVU&4[X:XdM([[U$5Sn'U"SU'RTR\<S3- n" O UR+U"S [U!5R>S U!35 [RF(a/URI[JRL"U!RN55 U=(a U nU!nSn!A!GNSn!A!ff=f)a Execute the parse expression on a series of test strings, showing each test, the parsed results or where the parse failed. Quick and easy way to run a parse expression against a list of sample strings. Parameters: - ``tests`` - a list of separate test strings, or a multiline string of test strings - ``parse_all`` - (default= ``True``) - flag to pass to :class:`parse_string` when running tests - ``comment`` - (default= ``'#'``) - expression for indicating embedded comments in the test string; pass None to disable comment filtering - ``full_dump`` - (default= ``True``) - dump results as list followed by results names in nested outline; if False, only dump nested list - ``print_results`` - (default= ``True``) prints test output to stdout - ``failure_tests`` - (default= ``False``) indicates if these tests are expected to fail parsing - ``post_parse`` - (default= ``None``) optional callback for successful parse results; called as `fn(test_string, parse_results)` and returns a string to be added to the test output - ``file`` - (default= ``None``) optional file-like object to which test output will be written; if None, will default to ``sys.stdout`` - ``with_line_numbers`` - default= ``False``) show test strings with line and column numbers Returns: a (success, results) tuple, where success indicates that all tests succeeded (or failed if ``failure_tests`` is True), and the results contain a list of lines of each test's output Example:: number_expr = pyparsing_common.number.copy() result = number_expr.run_tests(''' # unsigned integer 100 # negative integer -100 # float with scientific notation 6.02e23 # integer with scientific notation 1e-12 ''') print("Success" if result[0] else "Failed!") result = number_expr.run_tests(''' # stray character 100Z # missing leading digit before '.' -.100 # too many '.' 3.14.159 ''', failure_tests=True) print("Success" if result[0] else "Failed!") prints:: # unsigned integer 100 [100] # negative integer -100 [-100] # float with scientific notation 6.02e23 [6.02e+23] # integer with scientific notation 1e-12 [1e-12] Success # stray character 100Z ^ FAIL: Expected end of text (at char 3), (line:1, col:4) # missing leading digit before '.' -.100 ^ FAIL: Expected {real number with scientific notation | real number | signed integer} (at char 0), (line:1, col:1) # too many '.' 3.14.159 ^ FAIL: Expected end of text (at char 4), (line:1, col:5) Success Each test string must be on a single line. If you want to test a string that spans multiple lines, create a test like this:: expr.run_tests(r"this is a test\n of strings that spans \n 3 lines") (Note that this is a raw string literal, you must include the leading ``'r'``.) r)pyparsing_testNT\n uFrlr)fullz failed: : z(FATAL) zFAIL: zFAIL-EXCEPTIONrz (raised in parse action rI)/testingrrr#rNr rzrstriprstrip splitlinesLiteralrysysstdoutwriterX replace_withro quoted_stringrrwith_line_numbersrrOrlstriprr dumpr~r+rrexplainrr%r format_tbrrMwalk_tbf_code co_filenamernextco_name)(rtestsrcomment full_dump print_results failure_tests post_parsefilerrrrrryr line_strip test_linecomment_specifiedprint_ allResultscommentssuccessNLBOMnlstrrrrpp_valuercrrrtagritrrnext_fs( r: run_testsParserElement.run_testssj ,) ) #5 #4} + eX & &KKU+Ee**J%>(ST;LN44Q7RS'(%**X.CD7H003aC NN / ;'' 6**1*A6"6,&6( #,Q#7#/)(LAA # 8==? ; # 3x= 9JJv{{}5JJv{{{9: JJrNtyy~&   q&k *EH ""mYP% 6;;H;#=> (112)DG