Parse a string with respect to the parser definition. This function is intended as the primary interface to the client code.

Define name for this expression, makes debugging and exception messages clearer. If `__diag__.enable_debug_on_named_expressions` is s

Define one or more actions to perform when successfully matching parse element definition. Parse actions can be called to perform da

Add one or more parse actions to expression's list of parse actions. See :class:`set_parse_action`. See examples in :class:`copy`.

Returns the parse results as a nested list of matching tokens, all converted to strings. If ``flatten`` is True, all the nesting leve

Diagnostic method for listing out the contents of a :class:`ParseResults`. Accepts an optional ``indent`` argument so that th

Unit test assertion to compare a :class:`ParseResults` object with an optional ``expected_list``, and compare any defined res

Generator method to split a string using the given expression as a separator. May be called with optional ``maxsplit`` argument, to l

Add single element to end of ``ParseResults`` list of elements. Example: .. doctest:: >>> numlist = Word(nums)[

Execute the parse expression on a series of test strings, showing each test, the parsed results or where the parse failed. Quick and

Helper to quickly define a set of alternative :class:`Literal` s, and makes sure to do longest-first testing when there is a conflict, regardl

Returns a copy of this expression. Generally only used internally by pyparsing.

Convenience wrapper assert to test a parser element and input string, and assert that the resulting :meth:`ParseResults.as_li

Simple wrapper to print out the exceptions raised after assertRaises

Scan the input string for expression matches. Each match will return the matching tokens, start location, and end location. May be

Define name for referencing matching tokens as a nested attribute of the returned parse results. Normally, results names are

Yields a sequence of ``class(obj, **class_kwargs)`` for obj in seq. Example: .. testcode:: LPAR, RPAR, LBRACE,

Define expression to be ignored (e.g., comments) while doing pattern matching; may be called repeatedly, to define multiple comment o

Another extension to :class:`scan_string`, simplifying the access to the tokens found to match the given parse expression. May be ca

Extension to :class:`scan_string`, to modify matching text with modified tokens that may be returned from a parse action. To use ``t

Add an expression to the list of expressions related to this ParseExpression instance.

Create a railroad diagram for the parser. Parameters: - ``output_html`` (str or file-like object) - output target for gener

Add sequence of elements to end of :class:`ParseResults` list of elements. Example: .. testcode:: patt = Word(a

If you call this function in the same way that you would call the constructor, it will store the arguments as you expect. For example

Extends ``leave_whitespace`` defined in base class.

Enables "packrat" parsing, which adds memoizing to the parsing logic. Repeated parse attempts at the same string location (which happ

Method to translate the Python internal traceback into a list of the pyparsing expressions that caused the exception to be raised.

Removes and returns item at specified index (default= ``last``). Supports both ``list`` and ``dict`` semantics for ``pop()``. If

Returns current column within a string, counting newlines as line separators. The first column is number 1. Note: the default parsing be

Add a boolean predicate function to expression's list of parse actions. See :class:`set_parse_action` for function call signatures. Unlike ``s

Returns the named parse results as a nested dictionary. Example: .. doctest:: >>> integer = pp.Word(pp.nums)

Pretty-printer for parsed results as a list, using the `pprint <https://docs.python.org/3/library/pprint.html>`_ module. Acce

Enable display of debugging messages while doing pattern matching. Set ``flag`` to ``True`` to enable, ``False`` to disable.

Helpful method for debugging a parser - prints a string with line and column numbers. (Line and column numbers are 1-based by default

Simple wrapper to print out the warnings raised after assertWarns

Extends ``ignore_whitespace`` defined in base class.

r""" Overrides the default whitespace chars Example: .. doctest:: # default whitespace chars are space, <TAB> a

r"""Helper to easily define string ranges for use in :class:`Word` construction. Borrows syntax from regexp ``'[]'`` string range definitions:

a pyparsing Word expression for an identifier using this range's definitions for identchars and identbodychars

r""" Return :class:`Regex` with an attached parse action to transform the parsed result as if called using `re.sub(expr, repl, string)

Parse the Tiny program, build the main AST node, execute it, and capture stdout. Returns (return_value, stdout_text).

Return the TinyNode subclass matching `type_name`. Iterates over direct subclasses. If deeper inheritance hierarchies are created, th

Helper method for constructing grammars of expressions made up of operators working in a precedence hierarchy. Operators may be unary or bina

Execute this node against the given engine. Subclasses must implement this method.

Parse a TINY source string and return structured ParseResults. Args: text: Source code to parse.

Return the line of text where the exception occurred.

Disables active Packrat or Left Recursion parsing and their memoization This method also works if neither Packrat nor Left Recursion

Return the 1-based line number of text where the exception occurred.

Convert a pyparsing element tree into a list of diagrams. This is the recommended entrypoint to diagram creation if you want to access the Ra

Evaluate an expression built by pyparsing's infix_notation and tokens. Accepts primitives (int/float/str), identifiers (str that is a declare

Construct an instance from a parser `ParseResults` group.

Generate an intermediate list of NamedDiagrams from a pyparsing expression.

Inserts new element at location index in the list of parsed tokens. Similar to ``list.insert()``. Example: .. doct

Create a regular expression string from a list of words, collapsing by common prefixes and optional suffixes. Calls itself recursively t

r""" Take a string or list of single-character strings, and return a string of the consecutive characters in that string collapsed into gr

Utility to simplify mass-naming of parser elements, for generating railroad diagram with named subdiagrams.

Return the 1-based column on the line of text where the exception occurred.

Enables "bounded recursion" parsing, which allows for both direct and indirect left-recursion. During parsing, left-recursive :class:

Set class to be used for inclusion of string literals into a parser. Example: .. doctest:: :options: +NORMALIZE

Overrides the default whitespace chars

Suppress warnings emitted for a particular diagnostic on this expression. Example: .. doctest:: >>> label = pp

Return a numeric value for v following Tiny semantics. Rules: - If v is already an int or float, return it unchanged (no float coerci

Convenience wrapper assert to test a parser element and input string, and assert that the resulting :meth:`ParseResults.as_di