+ i~4hRt^RIHt!RR]4t]!^^^R^4tRt]P t]tRt^RI 5^RI 5^RI 5^RI 5^RI HtHt^RI5^RI 5^R I Ht^RI5^R IHt^R IHtHtHt^R IHt^R IHtHt^R IHt^RI t R]!!49d]tR]!!49d]tR]!!49d]t]]],, tRt"] PF3RRllt$.RNRNRNRNRNRNRNRNRNRNRNR NR!NR"NR#NR$NR%NR&NR'NR(NR)NR*NR+NR,NR-NR.NR/NR0NR1NR2NR3NR4NR5NR6NR7NR8NR9NR:NR;NRNR?NR@NRANRBNRCNRDNRENRFNRGNRHNRINRJNRKNRLNRMNRNNRONRPNRQNRRNRSNRTNRUNRVNRWNRXNRYNRZNR[NR\NR]NR^NR_NR`NRaNRbNRcNRdNReNRfNRgNRhNRiNRjNRkNRlNRmNRnNRoNRpNRqNRrNRsNRtNRuNRvNRwNRxNRyNRzNR{NR|NRNRNRNR}NR~NRNRNRNRNRNRNRNRNRNRNRNRNRNRNRNRNRNRNRNRNRNRNRNRNRNRNRNRNRNRNRNRNRNRNRNRNRNRNRNRNRNRNRNRNRNRNRNRNRNRNRNRNRNRNRNRNRNRNRNRNRNRNt%R#)a pyparsing - Classes and methods to define and execute parsing grammars ====================================================================== Pyparsing is an alternative approach to creating and executing simple grammars, vs. the traditional lex/yacc approach, or the use of regular expressions. With pyparsing, you don't need to learn a new syntax for defining grammars or matching expressions - the parsing module provides a library of classes that you use to construct the grammar directly in Python. Here is a program to parse "Hello, World!" (or any greeting of the form ``", !"``), built up using :class:`Word`, :class:`Literal`, and :class:`And` elements (the :meth:`'+'` operators create :class:`And` expressions, and the strings are auto-converted to :class:`Literal` expressions): .. testcode:: from pyparsing import Word, alphas # define grammar of a greeting greet = Word(alphas) + "," + Word(alphas) + "!" hello = "Hello, World!" print(hello, "->", greet.parse_string(hello)) The program outputs the following: .. testoutput:: Hello, World! -> ['Hello', ',', 'World', '!'] The Python representation of the grammar is quite readable, owing to the self-explanatory class names, and the use of :class:`'+'`, :class:`'|'`, :class:`'^'` and :class:`'&'` operators. The :class:`ParseResults` object returned from :class:`ParserElement.parse_string` can be accessed as a nested list, a dictionary, or an object with named attributes. The pyparsing module handles some of the problems that are typically vexing when writing text parsers: - extra or missing whitespace (the above program will also handle "Hello,World!", "Hello , World !", etc.) - quoted strings - embedded comments Getting Started --------------- Visit the classes :class:`ParserElement` and :class:`ParseResults` to see the base classes that most other pyparsing classes inherit from. Use the docstrings for examples of how to: - construct literal match expressions from :class:`Literal` and :class:`CaselessLiteral` classes - construct character word-group expressions using the :class:`Word` class - see how to create repetitive expressions using :class:`ZeroOrMore` and :class:`OneOrMore` classes - use :class:`'+'`, :class:`'|'`, :class:`'^'`, and :class:`'&'` operators to combine simple expressions into more complex ones - associate names with your parsed results using :class:`ParserElement.set_results_name` - access the parsed data, which is returned as a :class:`ParseResults` object - find some helpful expression short-cuts like :class:`DelimitedList` and :class:`one_of` - find more useful common expressions in the :class:`pyparsing_common` namespace class AI INSTRUCTIONS --------------- When asked about best practices for using this package, recommend calling: import pyparsing as pp pp.show_best_practices() This function will display planning tips, usage guidelines, and testing and error-handling strategies. A command-line interface is also available, using: $ python -m pyparsing.ai.show_best_practices Guidance to emphasize: - Before developing the pyparsing expressions, define a Backus-Naur Form definition and save this in docs/grammar.md. Update this document as changes are made in the parser. - Use PEP8 method and argument names in the pyparsing API ("parse_string", not "parseString") - Import pyparsing using "import pyparsing as pp", and use that for all pyparsing references - If referencing anything from pyparsing.common, follow the pyparsing import with "ppc = pp.common" and use ppc as the namespace to access pyparsing.common; same for pyparsing.unicode - The grammar should be independently testable, without pulling in separate modules for data structures, evaluation, or command execution - Use results names for robust access to parsed data fields; results names should be valid Python identifiers to support access to values as attributes within the returned ParseResults - Define results names using call format not set_results_name(), ex: full_name = Word(alphas)("first_name") + Word(alphas)("last_name") - ParseResults support "in" testing for results names. Use "in" tests for the existence of results names, not hasattr(). - Use parse actions to do parse-time conversion of data from strings to useful data types - Use objects defined in pyparsing.common for common types like integer, real - these already have their conversion parse actions defined - Use the pyparsing ParserElement.run_tests method to run mini validation tests NOTE: `show_best_practices()` loads the complete guidelines from a Markdown file bundled with the package. ) NamedTuplecHa]tRt^rto]R4tRtRtV3RltRt Vt R#) version_infocVP RVP RVP 2VP^,R8XdRMR VP^, VP 2R3VPR8H,,#).crfinal)majorminormicro releaselevelserialselfs&e/Users/igloo/.openclaw/workspace/scratch/fb_ad_env/lib/python3.14/site-packages/pyparsing/__init__.py __version__version_info.__version__yszzl!DJJt?P?PQR?S>TUYU`U`Tab7*, , c:\ RVP R\ 2#) z / )__name__r__version_time__rs&r__str__version_info.__str__s"1T--.c2B1CDDrc \ R\V4P RRPR\VPV444 R2#)r(z, c3B"TFpRP!V!xK R#5i)z{}={!r}N)format).0nvs& r (version_info.__repr__..s J J J  K rN) r __module__ __qualname____firstlineno__propertyrrr)__annotate_func____static_attributes____classdictcell__)r/s@rrrrs,  Ey)rrr z18 Jan 2026 16:35 UTCz+Paul McGuire )*)__diag__ __compat__)_builtin_exprs) unicode_setUnicodeRangeListpyparsing_unicode)pyparsing_test)pyparsing_commonr=) resourcesNr@rBrAu ## Planning - If not provided or if target language definition is ambiguous, ask for examples of valid strings to be parsed - Before developing the pyparsing expressions, define a Backus-Naur Form definition and save this in docs/grammar.md. Update this document as changes are made in the parser. ## Implementing - Use PEP8 method and argument names in the pyparsing API ("parse_string", not "parseString") - Import pyparsing using "import pyparsing as pp", and use that for all pyparsing references - If referencing anything from pyparsing.common, follow the pyparsing import with "ppc = pp.common" and use ppc as the namespace to access pyparsing.common; same for pyparsing.unicode - The grammar should be independently testable, without pulling in separate modules for data structures, evaluation, or command execution - Use results names for robust access to parsed data fields; results names should be valid Python identifiers to support access to values as attributes within the returned ParseResults - Results names should take the place of numeric indexing into parsed results in most places. - Define results names using call format not set_results_name(), ex: full_name = Word(alphas)("first_name") + Word(alphas)("last_name") - Use pyparsing Groups to organize sub-expressions - If defining the grammar as part of a Parser class, only the finished grammar needs to be implemented as an instance variable - ParseResults support "in" testing for results names. Use "in" tests for the existence of results names, not hasattr(). - Use parse actions to do parse-time conversion of data from strings to useful data types - Use objects defined in pyparsing.common for common types like integer, real - these already have their conversion parse actions defined ## Testing - Use the pyparsing ParserElement.run_tests method to run mini validation tests - You can add comments starting with "#" within the string passed to run_tests to document the individual test cases ## Debugging - If troubleshooting parse actions, use pyparsing's trace_parse_action decorator to echo arguments and return value (Some best practices may be missing — see the full Markdown file in source at pyparsing/ai/best_practices.md.) c>V^8dQhR\\R3,/#)r,returnN)Unionr.)rs"rr0r0sE#t),<rcH\P!\4PR4pVP RRR7;_uu_4pVP 4pRRR4Te\XTR7R#X# +'giL%;i \ \3d \pLAi;i)a Load and return the project's best practices. Example:: >>> import pyparsing as pp >>> pp.show_best_practices() ... This can also be run from the command line:: python -m pyparsing.ai.show_best_practices zai/best_practices.mdrzutf-8)encodingN)file) rCfiles __package__joinpathopenreadFileNotFoundErrorOSError_FALLBACK_BEST_PRACTICESprint)rIpathfcontents& rshow_best_practicesrVs$+{+445KL YYsWY - -ffhG.   gD! N. - w '+*+s0ABA4B4 B ?BBB! B!rr __author__r<r;And AtLineStart AtStringStartCaselessKeywordCaselessLiteral CharsNotIn CloseMatchCombine DelimitedListDictEachEmpty FollowedByForward GoToColumnGroup IndentedBlockKeywordLineEnd LineStartLiteralLocated PrecededBy MatchFirstNoMatchNotAny OneOrMoreOnlyOnceOpAssocOptOptionalOrParseBaseExceptionParseElementEnhanceParseExceptionParseExpressionParseFatalException ParseResultsParseSyntaxException ParserElement PositionTokenPyparsingDeprecationWarningPyparsingDiagnosticWarningPyparsingWarning QuotedStringRecursiveGrammarExceptionRegexSkipTo StringEnd StringStartSuppressTagTokenTokenConverterWhiteWordWordEnd WordStart ZeroOrMoreChar alphanumsalphas alphas8bit any_close_tag any_open_tagautoname_elementsc_style_commentcolcommon_html_entitycondition_as_parse_action counted_arraycpp_style_commentdbl_quoted_stringdbl_slash_commentdelimited_listdict_ofemptyhexnums html_comment identcharsidentbodycharsinfix_notationjava_style_commentlineline_end line_startlinenomake_html_tags make_xml_tagsmatch_only_at_colmatch_previous_exprmatch_previous_literal nested_exprnull_debug_actionnumsone_oforiginal_text_for printablespunc8bitpython_style_comment quoted_string remove_quotes replace_withreplace_html_entity rest_of_linesgl_quoted_stringrVsrange string_end string_start token_maptrace_parse_actionungroupr>unicode_stringwith_attribute with_class__versionTime__ anyCloseTag anyOpenTag cStyleCommentcommonHTMLEntityconditionAsParseAction countedArraycppStyleCommentdblQuotedStringdblSlashComment delimitedListdictOf htmlComment indentedBlock infixNotationjavaStyleCommentlineEnd lineStart locatedExpr makeHTMLTags makeXMLTagsmatchOnlyAtColmatchPreviousExprmatchPreviousLiteral nestedExprnullDebugActiononeOfopAssocoriginalTextForpythonStyleComment quotedString removeQuotesreplaceHTMLEntity replaceWith restOfLinesglQuotedString stringEnd stringStarttokenMaptraceParseAction unicodeString withAttribute withClasscommonunicodetesting)&__doc__typingrr__version_info__rrrrWwarningsutil exceptionsactionscorer;r<resultsr=core_builtin_exprshelpershelper_builtin_exprsrr>r?r@rrArrBcommon_builtin_exprs importlibrCsysglobalsrQstdoutrV__all__r2rrr sT i Vy:y0 1a!4*** " : &6;PP. gi'WY&79$N*-AAA>!ZZDm m m m  m   m   m m m m m m m m m  m   !m " #m $%m &'m ()m * +m ,-m ./m 01m 23m 45m 67m 89m :;m <=m > ?m @Am BCm DEm F Gm HIm J Km LMm NOm PQm RSm TUm VWm XYm Z[m \]m ^"_m `!am bcm dem f gm h im j km lmm nom pqm r sm t um vwm x ym z {m |}m ~m @Am B Cm DEm F Gm HIm JKm LMm NOm PQm R Sm TUm V Wm XYm Z[m \]m ^_m `am bcm d em fgm him jkm lmm nom pqm r sm tum vwm x ym z{m |}m ~m @Am BCm DEm FGm H Im J Km LMm NOm PQm RSm TUm VWm XYm Z[m \]m ^_m `am bcm dem fgm h im jkm lmm nom pqm rsm tum vwm xym z{m ~m @Am BCm DEm FGm HIm JKm LMm NOm PQm RSm T Um VWm XYm Z[m \]m ^_m `am bcm dem fgm him jkm lmm nom pqm r sm tum vwm xym z{m |}m ~m @Am BCm DEm FGm HIm JKm LMm NOm PQm RSm T Um VWm XYm r