Exception thrown when parse expressions don't match class; supported attributes by name are: - lineno - returns the line number of the ex

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

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

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

Repetition of one or more of the given expression. Parameters: - expr - expression that must match one or more times - stopOn - (defaul

Converter for ignoring the results of a parsed expression. Example:: source = "a, b, c,d" wd = Word(alphas) wd_list1 = w

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

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

Token for matching words composed of allowed character sets. Defined with string containing all allowed initial characters, an optional string

An empty token, will always match.

Token to exactly match a specified string. Example:: Literal('blah').parseString('blah') # -> ['blah'] Literal('blah').parseStr

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

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

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

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

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

Raise an error when issue with solving Cloudflare challenge

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

Raise an exception for bad or missing Parameter.

Raise an exception for captcha provider taking too long.

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

Raise an exception for invalid job id.

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

Badly packed source or general error. Argument is a meaningful description.

Raise an error for error from API response.

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

Requires that at least one :class:`ParseExpression` is found. If two expressions match, the first one listed is the one that will match. May b

Encapsulates the AES block cipher. You generally should not need this. Use the AESModeOfOperation classes below instead.

Raise an error for captcha provider unable to report bad solve.

Raise an exception for external services that cannot be reached

A counter object for the Counter (CTR) mode of operation. To create a custom counter, you can usually just override the increment method.

Accepts bytes of ciphertext and returns decrypted plaintext.

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

Accepts bytes of plaintext and returns encrypted ciphertext.

Token to exactly match a specified string as a keyword, that is, it must be immediately followed by a non-keyword character. Compare with :cl

r"""Matches if current position is at the beginning of a line within the parse string Example:: test = '''\ AAA this line

A token that will never match.

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

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

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

exception thrown by :class:`ParserElement.validate` if the grammar could be improperly recursive

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

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

Functor for a given base. Will efficiently convert strings to natural numbers.

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

Super-class for AES modes of operation that require blocks.

AES Cipher-Block Chaining Mode of Operation. o The Initialization Vector (IV) o Block-cipher, so data must be padded to 16 byte boundaries

AES Cipher Feedback Mode of Operation. o A stream-cipher, so input does not need to be padded to blocks, but does need to be padded to segment

AES Counter Mode of Operation. o A stream-cipher, so input does not need to be padded to blocks, allowing arbitrary length data. o The cou

AES Electronic Codebook Mode of Operation. o Block-cipher, so data must be padded to 16 byte boundaries Security Notes: o This mode is no

AES Output Feedback Mode of Operation. o A stream-cipher, so input does not need to be padded to blocks, allowing arbitrary length data. o

Super-class for AES modes of operation that segment data.

Super-class for AES modes of operation that are stream-ciphers.

Unicode set for Arabic Unicode Character Range

The super-class for objects to handle chunking a stream of bytes into the appropriate block size for the underlying mode of operation and appl

Unicode set for combined Chinese, Japanese, and Korean (CJK) Unicode Character Range

Raise an error for captcha provider account problem.

Base exception class for cloudscraper captcha Providers

Caseless version of :class:`Keyword`. Example:: OneOrMore(CaselessKeyword("CMD")).parseString("cmd CMD Cmd10") # -> ['CMD', 'CMD']

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

Unicode set for Chinese Unicode Character Range

A variation on :class:`Literal` which matches "close" matches, that is, strings with at most 'n' mismatching characters. :class:`CloseMatch` t

Raise an error for problem extracting Captcha paramters from Cloudflare payload

Raise an exception for no Captcha provider loaded for Cloudflare.

Raise an error when detected new Cloudflare challenge

Raise an exception for Cloudflare code 1020 block

Base exception class for cloudscraper for Cloudflare

Raise an error for problem extracting IUAM paramters from Cloudflare payload

Raise an exception for recursive depth protection

Unicode set for Cyrillic Unicode Character Range