Your IP : 216.73.217.13
�
&�j~4 � � � d Z ddlmZ G d� de� Z eddddd� Zd Zej ZeZd
Zdd l � dd l
� dd l � dd l � dd l
mZmZ dd l� dd l
� dd
l
mZ dd l� dd
lmZ ddlmZmZmZ ddlmZ ddlm ZmZ ddl m Z ddl Z d e!� vreZd e!� vreZ d e!� vreZee ez z
ZdZ"e jF fde$e%df fd�Z&g d�Z'y)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 �\ � e Zd ZU eed< eed< eed< eed< eed< ed� � Zd� Zd� Z y )
� version_info�major�minor�micro� releaselevel�serialc �� � | j � d| j � d| j � �| j d dk( rdnd� | j d � | j � �df| j dk( z S )N�.r �c�r� �final)r r r r r
��selfs ��/build/snapcraft-certbot-54d6d23c1eba5f776fc280588daee8b3/parts/certbot/install/lib/python3.12/site-packages/pyparsing/__init__.py� __version__zversion_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 �: � t � d| j � dt � �S )N� z / )�__name__r �__version_time__r s r �__str__zversion_info.__str__� s" � ���1�T� -� -� .�c�2B�1C�D�Dr c � � t � dt | � j � ddj d� t | j | � D � � � d�S )Nr �(z, c 3 �: K � | ] } d j |� �� � y�w)z{}={!r}N)�format)�.0�nvs r � <genexpr>z(version_info.__repr__.<locals>.<genexpr>� s � �� �<u�WY�=M�Y�=M�=M�r�=R�<u�s ��))r �type�join�zip�_fieldsr s r �__repr__zversion_info.__repr__� sG � ���1�T�$�Z� 0� 0� 1��4�9�9�<u�]`�ae�am�am�os�]t�<u�3u�2v�vw�x�xr N)
r �
__module__� __qualname__�int�__annotations__�str�propertyr r r' � r r r r r s: � � �J� �J� �J��� �K�
�
� �
�E�yr 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_commonr5 )� resourcesNr8 r: r9 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.)
�returnc � � t j t � j d� }|j dd�� 5 }|j � }ddd� | �t | �� yS # 1 sw Y �xY w# t t f$ r t }Y �5w xY w)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)
r; �files� __package__�joinpath�open�read�FileNotFoundError�OSError�_FALLBACK_BEST_PRACTICES�print)r? �path�f�contents r �show_best_practicesrL � s� � �$+����{�+�4�4�5K�L��
�Y�Y�s�W�Y�
-� ���f�f�h�G� �
��
�g�D�!�� �N� � �� �w� '� +�*��+�s( �;A4 �A(�A4 �(A1�-A4 �4B � B )�r r �
__author__r4 r3 �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�punc8bitr: r9 r8 �python_style_comment�
quoted_string�
remove_quotes� replace_with�replace_html_entity� rest_of_line�sgl_quoted_stringrL �srange�
string_end� string_start� token_map�trace_parse_action�ungroupr6 �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� rM �warnings�util�
exceptions�actions�corer3 r4 �resultsr5 �core_builtin_exprs�helpers�helper_builtin_exprsr� r6 r7 r8 r� r9 r� r: �common_builtin_exprs� importlibr; �sys�globalsrG �stdout�Unionr, rL �__all__r. r r �<module>r s� ��i ��V �y�:� y�0 ��1�a��!�4� �*� � �*�*� �"��
:�
� � � � � &� � � 6� � ;� P� P� .�� �
� �g�i�'� ���W�Y�&� ���7�9�$� �N� �*�-A�A� A� � � �> !�Z�Z� �E�#�t�)�,<� �Dm �r