D7net
Home
Console
Upload
information
Create File
Create Folder
About
Tools
:
/
lib
/
python3
/
dist-packages
/
pyparsing
/
__pycache__
/
Filename :
__init__.cpython-314.pyc
back
Copy
+ '[�i~4 � �h � R t ^ RIHt ! R R]4 t]! ^^^R^4 tRt]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 IH tHt ^ R I H t ^ RI t R]!! 4 9 d ]tR]!! 4 9 d ]t R]!! 4 9 d ]t]] ], , tRt"] PF 3R R llt$. RNRNRNRNRNRNRNR NR NR NR NR NR!NR"NR#NR$NR%NR&NR'NR(NR)NR*NR+NR,NR-NR.NR/NR0NR1NR2NR3NR4NR5NR6NR7NR8NR9NR:NR;NR<NR=NR>NR?NR@NRANRBNRCNRDNRENRFNRGNRHNRINRJNRKNRLNRMNRNNRONRPNRQNRRNRSNRTNRUNRVNRWNRXNRYNRZNR[NR\NR]NR^NR_NR`NRaNRbNRcNRdNReNRfNRgNRhNRiNRjNRkNRlNRmNRnNRoNRpNRqNRrNRsNRtNRuNRvNRwNRxNRyNRzNR{NR|NRNRNRNR}NR~NRNR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�NR�Nt%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 ``"<salutation>, <addressee>!"``), built up using :class:`Word`, :class:`Literal`, and :class:`And` elements (the :meth:`'+'<ParserElement.__add__>` 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:`'+'<And>`, :class:`'|'<MatchFirst>`, :class:`'^'<Or>` and :class:`'&'<Each>` 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:`'+'<And>`, :class:`'|'<MatchFirst>`, :class:`'^'<Or>`, and :class:`'&'<Each>` 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. )� NamedTuplec �H a � ] tR t^rt o ]R 4 tR tR tV 3R ltRt V t R# )� version_infoc � � V P R V P R V P 2V P ^ , R8X d RMR V P ^ , V P 2R3V P R8H , , # )�.�c�r� �final)�major�minor�micro� releaselevel�serial��selfs &�4/usr/lib/python3/dist-packages/pyparsing/__init__.py� __version__�version_info.__version__y s� � � �z�z�l�!�D�J�J�<�q���� � 5� �+�+�A�.�#�5�3�2�>�t�?P�?P�QR�?S�>T�UY�U`�U`�Ta�b��� � � �7�*�,� ,� � c �: � \ R V P R\ 2# )� z / )�__name__r �__version_time__r s &r �__str__�version_info.__str__� s" � ���1�T� -� -� .�c�2B�1C�D�Dr c � � \ R \ V 4 P RRP R \ V P V 4 4 4 R2# )r �(z, c 3 �B " � T F pR P ! V! x � K R# 5i)z{}={!r}N)�format)�.0�nvs & r � <genexpr>�(version_info.__repr__.<locals>.<genexpr>� s � � �<u�]t�WY�Y�=M�=M�r�=R�]t�s � �))r �type�join�zip�_fieldsr s &r �__repr__�version_info.__repr__� sG � ���1�T�$�Z� 0� 0� 1��4�9�9�<u�]`�ae�am�am�os�]t�<u�3u�2v�vw�x�xr c �V <� V ^8� d Qh/ S[ ;R& S[ ;R& S[ ;R& S[;R& S[ ;R& # )� r r r r r )�int�str)r � __classdict__s "�r � __annotate__�version_info.__annotate__r s> �� � � �J� � �J� � �J� � �� � �K� r � N) r � __module__� __qualname__�__firstlineno__�propertyr r r) �__annotate_func__�__static_attributes__�__classdictcell__)r/ s @r r r r s, �� � � � � � �E�y�) � r r r z18 Jan 2026 16:35 UTCz+Paul McGuire <ptmcg.gm+pyparsing@gmail.com>)�*)�__diag__� __compat__)�_builtin_exprs)� unicode_set�UnicodeRangeList�pyparsing_unicode)�pyparsing_test)�pyparsing_commonr= )� resourcesNr@ rB rA u� ## 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 ^8� d QhR\ \ R3, /# )r, �returnN)�Unionr. )r s "r r0 r0 � s � � � �E�#�t�)�,<� r c �H � \ P ! \ 4 P R4 pVP RRR7 ;_uu_ 4 pVP 4 pRRR4 T e \ XT R7 R# X# + ' g i L%; i \ \ 3 d \ p LAi ; i)a� Load and return the project's best practices. Example:: >>> import pyparsing as pp >>> pp.show_best_practices() <!-- This file contains instructions for best practices for developing parsers with pyparsing, and can be used by AI agents when generating Python code using pyparsing. --> ... This can also be run from the command line:: python -m pyparsing.ai.show_best_practices zai/best_practices.mdr zutf-8)�encodingN)�file) rC �files� __package__�joinpath�open�read�FileNotFoundError�OSError�_FALLBACK_BEST_PRACTICES�print)rI �path�f�contents & r �show_best_practicesrV � s� � �$+����{�+�4�4�5K�L�� �Y�Y�s�W�Y� -� -���f�f�h�G� .� �� �g�D�!�� �N� .� -�� �w� '� +�*��+�s0 �AB �A4�B �4 B �?B �B �B!� B!r r � __author__r< r; �And� AtLineStart� AtStringStart�CaselessKeyword�CaselessLiteral� CharsNotIn� CloseMatch�Combine� DelimitedList�Dict�Each�Empty� FollowedBy�Forward� GoToColumn�Group� IndentedBlock�Keyword�LineEnd� LineStart�Literal�Located� PrecededBy� MatchFirst�NoMatch�NotAny� OneOrMore�OnlyOnce�OpAssoc�Opt�Optional�Or�ParseBaseException�ParseElementEnhance�ParseException�ParseExpression�ParseFatalException� ParseResults�ParseSyntaxException� ParserElement� PositionToken�PyparsingDeprecationWarning�PyparsingDiagnosticWarning�PyparsingWarning� QuotedString�RecursiveGrammarException�Regex�SkipTo� StringEnd� StringStart�Suppress�Tag�Token�TokenConverter�White�Word�WordEnd� WordStart� ZeroOrMore�Char� alphanums�alphas� alphas8bit� any_close_tag� any_open_tag�autoname_elements�c_style_comment�col�common_html_entity�condition_as_parse_action� counted_array�cpp_style_comment�dbl_quoted_string�dbl_slash_comment�delimited_list�dict_of�empty�hexnums� html_comment� identchars�identbodychars�infix_notation�java_style_comment�line�line_end� line_start�lineno�make_html_tags� make_xml_tags�match_only_at_col�match_previous_expr�match_previous_literal� nested_expr�null_debug_action�nums�one_of�original_text_for� printables�punc8bit�python_style_comment� quoted_string� remove_quotes� replace_with�replace_html_entity� rest_of_line�sgl_quoted_stringrV �srange� string_end� string_start� token_map�trace_parse_action�ungroupr> �unicode_string�with_attribute� with_class�__versionTime__� anyCloseTag� anyOpenTag� cStyleComment�commonHTMLEntity�conditionAsParseAction� countedArray�cppStyleComment�dblQuotedString�dblSlashComment� delimitedList�dictOf� htmlComment� indentedBlock� infixNotation�javaStyleComment�lineEnd� lineStart� locatedExpr� makeHTMLTags� makeXMLTags�matchOnlyAtCol�matchPreviousExpr�matchPreviousLiteral� nestedExpr�nullDebugAction�oneOf�opAssoc�originalTextFor�pythonStyleComment� quotedString� removeQuotes�replaceHTMLEntity� replaceWith� restOfLine�sglQuotedString� stringEnd� stringStart�tokenMap�traceParseAction� unicodeString� withAttribute� withClass�common�unicode�testing)&�__doc__�typingr r �__version_info__r r r� rW �warnings�util� exceptions�actions�corer; r< �resultsr= �core_builtin_exprs�helpers�helper_builtin_exprsr� r> r? r@ r� rA r� rB �common_builtin_exprs� importlibrC �sys�globalsrQ �stdoutrV �__all__r2 r r �<module>r sT ��i ��V �y�:� y�0 ��1�a��!�4� �*� � �*�*� �"�� :� � � � � � &� � � 6� � ;� P� P� .�� � � �g�i�'� ���W�Y�&� ���7�9�$� �N� �*�-A�A� A� � � �> !�Z�Z� �Dm ��m ��m � �m � � m � � m � � m � �m � �m � �m � �m � �m � �m � �m � � m � � m � �!m �" �#m �$ �%m �& �'m �( �)m �* �+m �, �-m �. �/m �0 �1m �2 �3m �4 �5m �6 �7m �8 �9m �: �;m �< �=m �> �?m �@ �Am �B �Cm �D �Em �F �Gm �H �Im �J �Km �L �Mm �N �Om �P �Qm �R �Sm �T �Um �V �Wm �X �Ym �Z �[m �\ �]m �^ "�_m �` !�am �b �cm �d �em �f �gm �h �im �j �km �l �mm �n �om �p �qm �r �sm �t �um �v �wm �x �ym �z �{m �| �}m �~ �m �@ �Am �B �Cm �D �Em �F �Gm �H �Im �J �Km �L �Mm �N �Om �P �Qm �R �Sm �T �Um �V �Wm �X �Ym �Z �[m �\ �]m �^ �_m �` �am �b �cm �d �em �f �gm �h �im �j �km �l �mm �n �om �p �qm �r �sm �t �um �v �wm �x �ym �z �{m �| �}m �~ �m �@ �Am �B �Cm �D �Em �F �Gm �H �Im �J �Km �L �Mm �N �Om �P �Qm �R �Sm �T �Um �V �Wm �X �Ym �Z �[m �\ �]m �^ �_m �` �am �b �cm �d �em �f �gm �h �im �j �km �l �mm �n �om �p �qm �r �sm �t �um �v �wm �x �ym �z �{m �~ �m �@ �Am �B �Cm �D �Em �F �Gm �H �Im �J �Km �L �Mm �N �Om �P �Qm �R �Sm �T �Um �V �Wm �X �Ym �Z �[m �\ �]m �^ �_m �` �am �b �cm �d �em �f �gm �h �im �j �km �l �mm �n �om �p �qm �r �sm �t �um �v �wm �x �ym �z �{m �| �}m �~ �m �@ �Am �B �Cm �D �Em �F �Gm �H �Im �J �Km �L �Mm �N �Om �P �Qm �R �Sm �T �Um �V �Wm �X �Ym �r