Inheritance diagram for pip._vendor.pyparsing.core.Regex:

Collaboration diagram for pip._vendor.pyparsing.core.Regex:

Public Member Functions
	__init__ (self, Any pattern, Union[re.RegexFlag, int] flags=0, bool as_group_list=False, bool as_match=False, *bool asGroupList=False, bool asMatch=False)

	re (self)

	re_match (self)

	mayReturnEmpty (self)

	parseImpl (self, instring, loc, doActions=True)

	parseImplAsGroupList (self, instring, loc, doActions=True)

	parseImplAsMatch (self, instring, loc, doActions=True)

ParserElement	sub (self, str repl)

Public Member Functions inherited from pip._vendor.pyparsing.core.ParserElement
	using_each (cls, seq, **class_kwargs)

"ParserElement"	suppress_warning (self, Diagnostics warning_type)

	visit_all (self)

"ParserElement"	copy (self)

"ParserElement"	set_results_name (self, str name, bool list_all_matches=False, *bool listAllMatches=False)

"ParserElement"	set_break (self, bool break_flag=True)

"ParserElement"	set_parse_action (self, ParseAction fns, *kwargs)

"ParserElement"	add_parse_action (self, ParseAction fns, *kwargs)

"ParserElement"	add_condition (self, ParseCondition fns, *kwargs)

"ParserElement"	set_fail_action (self, ParseFailAction fn)

int	preParse (self, str instring, int loc)

	postParse (self, instring, loc, tokenlist)

int	try_parse (self, str instring, int loc, *bool raise_fatal=False, bool do_actions=False)

bool	can_parse_next (self, str instring, int loc, bool do_actions=False)

ParseResults	parse_string (self, str instring, bool parse_all=False, *bool parseAll=False)

Generator[Tuple[ParseResults, int, int], None, None]	scan_string (self, str instring, int max_matches=_MAX_INT, bool overlap=False, *bool debug=False, int maxMatches=_MAX_INT)

str	transform_string (self, str instring, *bool debug=False)

ParseResults	search_string (self, str instring, int max_matches=_MAX_INT, *bool debug=False, int maxMatches=_MAX_INT)

Generator[str, None, None]	split (self, str instring, int maxsplit=_MAX_INT, bool include_separators=False, *includeSeparators=False)

"ParserElement"	__add__ (self, other)

"ParserElement"	__radd__ (self, other)

"ParserElement"	__sub__ (self, other)

"ParserElement"	__rsub__ (self, other)

"ParserElement"	__mul__ (self, other)

"ParserElement"	__rmul__ (self, other)

"ParserElement"	__or__ (self, other)

"ParserElement"	__ror__ (self, other)

"ParserElement"	__xor__ (self, other)

"ParserElement"	__rxor__ (self, other)

"ParserElement"	__and__ (self, other)

"ParserElement"	__rand__ (self, other)

"ParserElement"	__invert__ (self)

	__getitem__ (self, key)

"ParserElement"	__call__ (self, typing.Optional[str] name=None)

"ParserElement"	suppress (self)

"ParserElement"	ignore_whitespace (self, bool recursive=True)

"ParserElement"	leave_whitespace (self, bool recursive=True)

"ParserElement"	set_whitespace_chars (self, Union[Set[str], str] chars, bool copy_defaults=False)

"ParserElement"	parse_with_tabs (self)

"ParserElement"	ignore (self, "ParserElement" other)

"ParserElement"	set_debug_actions (self, DebugStartAction start_action, DebugSuccessAction success_action, DebugExceptionAction exception_action)

"ParserElement"	set_debug (self, bool flag=True, bool recurse=False)

str	default_name (self)

"ParserElement"	set_name (self, str name)

str	name (self)

str	__str__ (self)

str	__repr__ (self)

"ParserElement"	streamline (self)

List["ParserElement"]	recurse (self)

None	validate (self, validateTrace=None)

ParseResults	parse_file (self, Union[str, Path, TextIO] file_or_filename, str encoding="utf-8", bool parse_all=False, *bool parseAll=False)

	__eq__ (self, other)

	__hash__ (self)

bool	matches (self, str test_string, bool parse_all=True, *bool parseAll=True)

Tuple[bool, List[Tuple[str, Union[ParseResults, Exception]]]]	run_tests (self, Union[str, List[str]] tests, bool parse_all=True, typing.Optional[Union["ParserElement", str]] comment="#", bool full_dump=True, bool print_results=True, bool failure_tests=False, typing.Optional[Callable[[str, ParseResults], str]] post_parse=None, typing.Optional[TextIO] file=None, bool with_line_numbers=False, *bool parseAll=True, bool fullDump=True, bool printResults=True, bool failureTests=False, typing.Optional[Callable[[str, ParseResults], str]] postParse=None)

None	create_diagram (self, Union[TextIO, Path, str] output_html, int vertical=3, bool show_results_names=False, bool show_groups=False, bool embed=False, **kwargs)

	setResultsName (self)

	setBreak (self)

	setParseAction (self)

	addParseAction (self)

	addCondition (self)

	setFailAction (self)

	tryParse (self)

	parseString (self)

	scanString (self)

	transformString (self)

	searchString (self)

	ignoreWhitespace (self)

	leaveWhitespace (self)

	setWhitespaceChars (self)

	parseWithTabs (self)

	setDebugActions (self)

	setDebug (self)

	setName (self)

	parseFile (self)

	runTests (self)

Public Attributes
	reString

	flags

	pattern

	errmsg

	mayIndexError

	asGroupList

	asMatch

	parseImpl

Public Attributes inherited from pip._vendor.pyparsing.core.ParserElement
	saveAsList

	skipWhitespace

	whiteChars

	copyDefaultWhiteChars

	keepTabs

	debug

	streamlined

	mayIndexError

	errmsg

	modalResults

	debugActions

	callPreparse

	callDuringTry

	parseAction

	failAction

	resultsName

	customName

Protected Member Functions
str	_generateDefaultName (self)

Protected Member Functions inherited from pip._vendor.pyparsing.core.ParserElement
	_setResultsName (self, name, listAllMatches=False)

int	_skipIgnorables (self, str instring, int loc)

Tuple[int, ParseResults]	_parseNoCache (self, instring, loc, doActions=True, callPreParse=True)

Tuple[int, ParseResults]	_parseCache (self, instring, loc, doActions=True, callPreParse=True)

	_checkRecursion (self, parseElementList)

Protected Attributes
	_re

Protected Attributes inherited from pip._vendor.pyparsing.core.ParserElement
	_parse

	_defaultName

Additional Inherited Members
Static Public Member Functions inherited from pip._vendor.pyparsing.core.ParserElement
None	set_default_whitespace_chars (str chars)

None	inline_literals_using (type cls)

None	reset_cache ()

None	disable_memoization ()

None	enable_left_recursion (typing.Optional[int] cache_size_limit=None, *force=False)

None	enable_packrat (int cache_size_limit=128, *bool force=False)

	inlineLiteralsUsing ()

	setDefaultWhitespaceChars ()

	enableLeftRecursion ()

	enablePackrat ()

Static Public Attributes inherited from pip._vendor.pyparsing.core.ParserElement
str	DEFAULT_WHITE_CHARS = " \n\t\r"

bool	verbose_stacktrace = False

	recursion_lock = RLock()

dict	recursion_memos = {}

tuple	packrat_cache

	packrat_cache_lock = RLock()

list	packrat_cache_stats = [0, 0]

bool	canParseNext = can_parse_next

None	resetCache = reset_cache

str	defaultName = default_name

Static Protected Attributes inherited from pip._vendor.pyparsing.core.ParserElement
type	_literalStringClass = None

Tuple[int, ParseResults]	_parse = _parseNoCache

bool	_packratEnabled = False

bool	_left_recursion_enabled = False

Detailed Description

Token for matching strings that match a given regular
expression. Defined with string specifying the regular expression in
a form recognized by the stdlib Python  `re module <https://docs.python.org/3/library/re.html>`_.
If the given regex contains named groups (defined using ``(?P<name>...)``),
these will be preserved as named :class:`ParseResults`.

If instead of the Python stdlib ``re`` module you wish to use a different RE module
(such as the ``regex`` module), you can do so by building your ``Regex`` object with
a compiled RE that was compiled using ``regex``.

Example::

    realnum = Regex(r"[+-]?\d+\.\d*")
    # ref: https://stackoverflow.com/questions/267399/how-do-you-match-only-valid-roman-numerals-with-a-regular-expression
    roman = Regex(r"M{0,4}(CM|CD|D?{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})")

    # named fields in a regex will be returned as named results
    date = Regex(r'(?P<year>\d{4})-(?P<month>\d\d?)-(?P<day>\d\d?)')

    # the Regex class will accept re's compiled using the regex module
    import regex
    parser = pp.Regex(regex.compile(r'[0-9]'))

Constructor & Destructor Documentation

◆ init()

pip._vendor.pyparsing.core.Regex.__init__	(		self,
		Any	pattern,
		Union[re.RegexFlag, int]	flags = `0`,
		bool	as_group_list = `False`,
		bool	as_match = `False`,
		*bool	asGroupList = `False`,
		bool	asMatch = `False`
	)

The parameters ``pattern`` and ``flags`` are passed
to the ``re.compile()`` function as-is. See the Python
`re module <https://docs.python.org/3/library/re.html>`_ module for an
explanation of the acceptable patterns and flags.

Reimplemented from pip._vendor.pyparsing.core.Token.

Member Function Documentation

◆ _generateDefaultName()

str pip._vendor.pyparsing.core.Regex._generateDefaultName ( self )

protected

Child classes must define this method, which defines how the ``default_name`` is set.

Reimplemented from pip._vendor.pyparsing.core.Token.

◆ mayReturnEmpty()

pip._vendor.pyparsing.core.Regex.mayReturnEmpty ( self )

Reimplemented from pip._vendor.pyparsing.core.ParserElement.

◆ parseImpl()

pip._vendor.pyparsing.core.Regex.parseImpl	(	self,
		instring,
		loc,
		doActions = `True`
	)

Reimplemented from pip._vendor.pyparsing.core.ParserElement.

◆ sub()

ParserElement pip._vendor.pyparsing.core.Regex.sub	(		self,
		str	repl
	)

    Return :class:`Regex` with an attached parse action to transform the parsed
    result as if called using `re.sub(expr, repl, string) <https://docs.python.org/3/library/re.html#re.sub>`_.

    Example::

        make_html = Regex(r"(\w+):(.*?):").sub(r"<\1>\2</\1>")
        print(make_html.transform_string("h1:main title:"))
        # prints "<h1>main title</h1>"

The documentation for this class was generated from the following file:

docs/help/help-venv/lib/python3.12/site-packages/pip/_vendor/pyparsing/core.py

Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Additional Inherited Members