pip._vendor.pyparsing.util Namespace Reference

Data Structures
class	_FifoCache
class	_UnboundedCache
class	LRUMemo
class	UnboundedMemo

Functions
int	col (int loc, str strg)
int	lineno (int loc, str strg)
str	line (int loc, str strg)
str	_escape_regex_range_chars (str s)
str	_collapse_string_to_ranges (Union[str, Iterable[str]] s, bool re_escape=True)
list	_flatten (list ll)
C	_make_synonym_function (str compat_name, C fn)
Callable[[Callable], C]	replaced_by_pep8 (C fn)

Variables
	_bslash = chr(92)
	C = TypeVar("C", bound=Callable)

Function Documentation

_collapse_string_to_ranges()

str _collapse_string_to_ranges ( Union[str, Iterable[str]]  s, bool   re_escape = True  )

protected

Definition at line 186 of file util.py.

) -> str:
    def is_consecutive(c):
        c_int = ord(c)
        is_consecutive.prev, prev = c_int, is_consecutive.prev
        if c_int - prev > 1:
            is_consecutive.value = next(is_consecutive.counter)
        return is_consecutive.value
 
    is_consecutive.prev = 0  # type: ignore [attr-defined]
    is_consecutive.counter = itertools.count()  # type: ignore [attr-defined]
    is_consecutive.value = -1  # type: ignore [attr-defined]
 
    def escape_re_range_char(c):
        return "\\" + c if c in r"\^-][" else c
 
    def no_escape_re_range_char(c):
        return c
 
    if not re_escape:
        escape_re_range_char = no_escape_re_range_char
 
    ret = []
    s = "".join(sorted(set(s)))
    if len(s) > 3:
        for _, chars in itertools.groupby(s, key=is_consecutive):
            first = last = next(chars)
            last = collections.deque(
                itertools.chain(iter([last]), chars), maxlen=1
            ).pop()
            if first == last:
                ret.append(escape_re_range_char(first))
            else:
                sep = "" if ord(last) == ord(first) + 1 else "-"
                ret.append(
                    f"{escape_re_range_char(first)}{sep}{escape_re_range_char(last)}"
                )
    else:
        ret = [escape_re_range_char(c) for c in s]
 
    return "".join(ret)
 
 

References i.

_escape_regex_range_chars()

str _escape_regex_range_chars ( str  s )

protected

Definition at line 177 of file util.py.

def _escape_regex_range_chars(s: str) -> str:
    # escape these chars: ^-[]
    for c in r"\^-[]":
        s = s.replace(c, _bslash + c)
    s = s.replace("\n", r"\n")
    s = s.replace("\t", r"\t")
    return str(s)
 
 

_flatten()

list _flatten ( list  ll )

protected

Definition at line 230 of file util.py.

def _flatten(ll: list) -> list:
    ret = []
    for i in ll:
        if isinstance(i, list):
            ret.extend(_flatten(i))
        else:
            ret.append(i)
    return ret
 
 

References i.

_make_synonym_function()

C _make_synonym_function ( str  compat_name, C  fn  )

protected

Definition at line 240 of file util.py.

def _make_synonym_function(compat_name: str, fn: C) -> C:
    # In a future version, uncomment the code in the internal _inner() functions
    # to begin emitting DeprecationWarnings.
 
    # Unwrap staticmethod/classmethod
    fn = getattr(fn, "__func__", fn)
 
    # (Presence of 'self' arg in signature is used by explain_exception() methods, so we take
    # some extra steps to add it if present in decorated function.)
    if "self" == list(inspect.signature(fn).parameters)[0]:
 
        @wraps(fn)
        def _inner(self, *args, **kwargs):
            # warnings.warn(
            #     f"Deprecated - use {fn.__name__}", DeprecationWarning, stacklevel=3
            # )
            return fn(self, *args, **kwargs)
 
    else:
 
        @wraps(fn)
        def _inner(*args, **kwargs):
            # warnings.warn(
            #     f"Deprecated - use {fn.__name__}", DeprecationWarning, stacklevel=3
            # )
            return fn(*args, **kwargs)
 
    _inner.__doc__ = f"""Deprecated - use :class:`{fn.__name__}`"""
    _inner.__name__ = compat_name
    _inner.__annotations__ = fn.__annotations__
    if isinstance(fn, types.FunctionType):
        _inner.__kwdefaults__ = fn.__kwdefaults__
    elif isinstance(fn, type) and hasattr(fn, "__init__"):
        _inner.__kwdefaults__ = fn.__init__.__kwdefaults__
    else:
        _inner.__kwdefaults__ = None
    _inner.__qualname__ = fn.__qualname__
    return cast(C, _inner)
 
 

References i.

Referenced by pip._vendor.pyparsing.util.replaced_by_pep8().

Here is the caller graph for this function:

col()

int col	(	int	loc,
		str	strg
	)

Returns current column within a string, counting newlines as line separators.
The first column is number 1.

Note: the default parsing behavior is to expand tabs in the input string
before starting the parsing process.  See
:class:`ParserElement.parse_string` for more
information on parsing strings containing ``<TAB>`` s, and suggested
methods to maintain a consistent view of the parsed string, the parse
location, and line and column positions within the parsed string.

Definition at line 40 of file util.py.

def col(loc: int, strg: str) -> int:
    """
    Returns current column within a string, counting newlines as line separators.
    The first column is number 1.
 
    Note: the default parsing behavior is to expand tabs in the input string
    before starting the parsing process.  See
    :class:`ParserElement.parse_string` for more
    information on parsing strings containing ``<TAB>`` s, and suggested
    methods to maintain a consistent view of the parsed string, the parse
    location, and line and column positions within the parsed string.
    """
    s = strg
    return 1 if 0 < loc < len(s) and s[loc - 1] == "\n" else loc - s.rfind("\n", 0, loc)
 
 
@lru_cache(maxsize=128)

References i.

line()

str line	(	int	loc,
		str	strg
	)

Returns the line of text containing loc within a string, counting newlines as line separators.

Definition at line 71 of file util.py.

def line(loc: int, strg: str) -> str:
    """
    Returns the line of text containing loc within a string, counting newlines as line separators.
    """
    last_cr = strg.rfind("\n", 0, loc)
    next_cr = strg.find("\n", loc)
    return strg[last_cr + 1 : next_cr] if next_cr >= 0 else strg[last_cr + 1 :]
 
 

References i.

lineno()

int lineno	(	int	loc,
		str	strg
	)

Returns current line number within a string, counting newlines as line separators.
The first line is number 1.

Note - the default parsing behavior is to expand tabs in the input string
before starting the parsing process.  See :class:`ParserElement.parse_string`
for more information on parsing strings containing ``<TAB>`` s, and
suggested methods to maintain a consistent view of the parsed string, the
parse location, and line and column positions within the parsed string.

Definition at line 57 of file util.py.

def lineno(loc: int, strg: str) -> int:
    """Returns current line number within a string, counting newlines as line separators.
    The first line is number 1.
 
    Note - the default parsing behavior is to expand tabs in the input string
    before starting the parsing process.  See :class:`ParserElement.parse_string`
    for more information on parsing strings containing ``<TAB>`` s, and
    suggested methods to maintain a consistent view of the parsed string, the
    parse location, and line and column positions within the parsed string.
    """
    return strg.count("\n", 0, loc) + 1
 
 
@lru_cache(maxsize=128)

References i.

replaced_by_pep8()

Callable[[Callable], C] replaced_by_pep8

(

C

fn

)

Decorator for pre-PEP8 compatibility synonyms, to link them to the new function.

Definition at line 280 of file util.py.

def replaced_by_pep8(fn: C) -> Callable[[Callable], C]:
    """
    Decorator for pre-PEP8 compatibility synonyms, to link them to the new function.
    """
    return lambda other: _make_synonym_function(other.__name__, fn)

References pip._vendor.pyparsing.util._make_synonym_function(), and i.

Here is the call graph for this function:

Variable Documentation

_bslash

_bslash = chr(92)

protected

Definition at line 10 of file util.py.

C

C = TypeVar("C", bound=Callable)

Definition at line 11 of file util.py.