Converter to return the matched tokens as a list - useful for returning tokens of :class:`ZeroOrMore` and :class:`OneOrMore` expressions. The

Token for matching words composed of allowed character sets. Parameters: - ``init_chars`` - string of all characters that should be used to

Helper to define a delimited list of expressions - the delimiter defaults to ','. By default, the list elements and delimiters can have interv

Token to exactly match a specified string. Example: .. doctest:: >>> Literal('abc').parse_string('abc') ParseResults([

Converter for ignoring the results of a parsed expression. Example: .. doctest:: >>> source = "a, b, c,d" >>> wd = Word(alp

r"""Token for matching strings that match a given regular expression. Defined with string specifying the regular expression in a form recogniz

Optional repetition of zero or more of the given expression. Parameters: - ``expr`` - expression that must match zero or more times

Exception thrown when a parse expression doesn't match the input string Example: .. testcode:: integer = Word(nums).set_name("

Token to exactly match a specified string as a keyword, that is, it must be immediately preceded and followed by whitespace or non-keywor

Forward declaration of an expression to be defined later - used for recursive grammars, such as algebraic infix notation. When the expres

Converter to concatenate all matching tokens to a single string. By default, the matching patterns must also be contiguous in the input string

Repetition of one or more of the given expression. Parameters: - ``expr`` - expression that must match one or more times - ``stop_o

Optional matching of the given expression. :param expr: expression that must match zero or more times :param default: (optional) - value

An empty token, will always match.

Structured parse results, to provide multiple means of access to the parsed data: - as a list (``len(results)``) - by list index (``resul

Converter to return a repetitive expression as a list, but also as a dictionary. Each element can also be referenced using the first token in

r""" Token for matching strings that are delimited by quoting characters. Defined with the following parameters: - ``quote_char`` - stri

Token for matching words composed of characters *not* in a given set (will include whitespace in matched characters if not listed in the provi

Token to match a specified string, ignoring case of letters. Note: the matched results will always be in the case of the given match stri

Token for skipping over all undefined text until the matched expression is found. :param expr: target expression marking the end of the

Matches if current position is at the end of a line within the parse string

Requires that at least one :class:`ParserElement` is found. If more than one expression matches, the first one listed is the one that will mat

Requires all given :class:`ParserElement` s to be found in the given order. Expressions may be separated by whitespace. May be constructe

Class to encapsulate undefined macro references

User-throwable exception thrown when inconsistent parse content is found; stops all parsing immediately

Matches if current position is at the end of the parse string

Runtime engine to execute TINY AST nodes. Responsibilities: - Manage I/O buffers (text-based input and output) - Maintain a simple variab

Caseless version of :class:`Keyword`. Example: .. doctest:: >>> CaselessKeyword("CMD")[1, ...].parse_string("cmd CMD Cmd10")

Lookahead matching of the given parse expression. ``FollowedBy`` does *not* advance the parsing position within the input string, it only veri

A token that will never match.

Special matching class for matching whitespace. Normally, whitespace is ignored by pyparsing grammars. This class is included when some whit

A single stack frame holding local variables and their types. Variables in TINY are stored per-frame; lookups search the current frame first,

Expression to match one or more expressions at a given indentation level. Useful for parsing text where structure is implied by indentation (

r"""Matches if current position is at the logical beginning of a line (after skipping whitespace) within the parse string Example: .. te

Requires that at least one :class:`ParserElement` is found. If two expressions match, the expression that matches the longest string will be u

Brainf*ck execution environment, with a memory array and pointer.

Parser to extract table info from BigQuery view definitions Based on the BNF and examples posted at https://cloud.google.com/bigquery/docs/re

A short-cut class for defining :class:`Word` ``(characters, exact=1)``, when defining a match of any single character in a string of character

Stores some state that persists between recursions into the element tree

Requires all given :class:`ParserElement` s to be found, but in any order. Expressions may be separated by whitespace. May be constructed usi

Acts like a functools.partial, but can be edited. In other words, it represents a type that hasn't yet been constructed.

State recorded for an individual pyparsing Element

A class for defining an infix notation parsers.

Lookahead to disallow matching with the given parse expression. ``NotAny`` does *not* advance the parsing position within the input strin

A null cache type for initialization of the packrat_cache class variable. If/when enable_packrat() is called, this null cache will be

Just like :class:`ParseFatalException`, but thrown internally when an :class:`ErrorStop<And._ErrorStop>` ('-' operator) indicates that pa

Tests the parser with some search queries tests contains a dictionary with tests and expected results.

Tests the parser with some search queries tests contains a dictionary with tests and expected results.

.. deprecated:: 3.0.0 Only used by the deprecated :meth:`ParserElement.validate`. Exception thrown by :class:`ParserElement.validate`

Using exception mechanism to propagate return value from within nested statements within a function.

Matches if current position is at the beginning of the parse string

Abstract subclass of :class:`ParseElementEnhance`, for converting parsed results.