cli-ih 0.6.3.1__py3-none-any.whl → 0.7.1__py3-none-any.whl

venv/Lib/site-packages/pip/_vendor/pygments/modeline.py

@@ -1,43 +0,0 @@
-"""
-    pygments.modeline
-    ~~~~~~~~~~~~~~~~~
-
-    A simple modeline parser (based on pymodeline).
-
-    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-import re
-
-__all__ = ['get_filetype_from_buffer']
-
-
-modeline_re = re.compile(r'''
-    (?: vi | vim | ex ) (?: [<=>]? \d* )? :
-    .* (?: ft | filetype | syn | syntax ) = ( [^:\s]+ )
-''', re.VERBOSE)
-
-
-def get_filetype_from_line(l): # noqa: E741
-    m = modeline_re.search(l)
-    if m:
-        return m.group(1)
-
-
-def get_filetype_from_buffer(buf, max_lines=5):
-    """
-    Scan the buffer for modelines and return filetype if one is found.
-    """
-    lines = buf.splitlines()
-    for line in lines[-1:-max_lines-1:-1]:
-        ret = get_filetype_from_line(line)
-        if ret:
-            return ret
-    for i in range(max_lines, -1, -1):
-        if i < len(lines):
-            ret = get_filetype_from_line(lines[i])
-            if ret:
-                return ret
-
-    return None

venv/Lib/site-packages/pip/_vendor/pygments/plugin.py

@@ -1,72 +0,0 @@
-"""
-    pygments.plugin
-    ~~~~~~~~~~~~~~~
-
-    Pygments plugin interface.
-
-    lexer plugins::
-
-        [pygments.lexers]
-        yourlexer = yourmodule:YourLexer
-
-    formatter plugins::
-
-        [pygments.formatters]
-        yourformatter = yourformatter:YourFormatter
-        /.ext = yourformatter:YourFormatter
-
-    As you can see, you can define extensions for the formatter
-    with a leading slash.
-
-    syntax plugins::
-
-        [pygments.styles]
-        yourstyle = yourstyle:YourStyle
-
-    filter plugin::
-
-        [pygments.filter]
-        yourfilter = yourfilter:YourFilter
-
-
-    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-from importlib.metadata import entry_points
-
-LEXER_ENTRY_POINT = 'pygments.lexers'
-FORMATTER_ENTRY_POINT = 'pygments.formatters'
-STYLE_ENTRY_POINT = 'pygments.styles'
-FILTER_ENTRY_POINT = 'pygments.filters'
-
-
-def iter_entry_points(group_name):
-    groups = entry_points()
-    if hasattr(groups, 'select'):
-        # New interface in Python 3.10 and newer versions of the
-        # importlib_metadata backport.
-        return groups.select(group=group_name)
-    else:
-        # Older interface, deprecated in Python 3.10 and recent
-        # importlib_metadata, but we need it in Python 3.8 and 3.9.
-        return groups.get(group_name, [])
-
-
-def find_plugin_lexers():
-    for entrypoint in iter_entry_points(LEXER_ENTRY_POINT):
-        yield entrypoint.load()
-
-
-def find_plugin_formatters():
-    for entrypoint in iter_entry_points(FORMATTER_ENTRY_POINT):
-        yield entrypoint.name, entrypoint.load()
-
-
-def find_plugin_styles():
-    for entrypoint in iter_entry_points(STYLE_ENTRY_POINT):
-        yield entrypoint.name, entrypoint.load()
-
-
-def find_plugin_filters():
-    for entrypoint in iter_entry_points(FILTER_ENTRY_POINT):
-        yield entrypoint.name, entrypoint.load()

venv/Lib/site-packages/pip/_vendor/pygments/regexopt.py

@@ -1,91 +0,0 @@
-"""
-    pygments.regexopt
-    ~~~~~~~~~~~~~~~~~
-
-    An algorithm that generates optimized regexes for matching long lists of
-    literal strings.
-
-    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-import re
-from re import escape
-from os.path import commonprefix
-from itertools import groupby
-from operator import itemgetter
-
-CS_ESCAPE = re.compile(r'[\[\^\\\-\]]')
-FIRST_ELEMENT = itemgetter(0)
-
-
-def make_charset(letters):
-    return '[' + CS_ESCAPE.sub(lambda m: '\\' + m.group(), ''.join(letters)) + ']'
-
-
-def regex_opt_inner(strings, open_paren):
-    """Return a regex that matches any string in the sorted list of strings."""
-    close_paren = open_paren and ')' or ''
-    # print strings, repr(open_paren)
-    if not strings:
-        # print '-> nothing left'
-        return ''
-    first = strings[0]
-    if len(strings) == 1:
-        # print '-> only 1 string'
-        return open_paren + escape(first) + close_paren
-    if not first:
-        # print '-> first string empty'
-        return open_paren + regex_opt_inner(strings[1:], '(?:') \
-            + '?' + close_paren
-    if len(first) == 1:
-        # multiple one-char strings? make a charset
-        oneletter = []
-        rest = []
-        for s in strings:
-            if len(s) == 1:
-                oneletter.append(s)
-            else:
-                rest.append(s)
-        if len(oneletter) > 1:  # do we have more than one oneletter string?
-            if rest:
-                # print '-> 1-character + rest'
-                return open_paren + regex_opt_inner(rest, '') + '|' \
-                    + make_charset(oneletter) + close_paren
-            # print '-> only 1-character'
-            return open_paren + make_charset(oneletter) + close_paren
-    prefix = commonprefix(strings)
-    if prefix:
-        plen = len(prefix)
-        # we have a prefix for all strings
-        # print '-> prefix:', prefix
-        return open_paren + escape(prefix) \
-            + regex_opt_inner([s[plen:] for s in strings], '(?:') \
-            + close_paren
-    # is there a suffix?
-    strings_rev = [s[::-1] for s in strings]
-    suffix = commonprefix(strings_rev)
-    if suffix:
-        slen = len(suffix)
-        # print '-> suffix:', suffix[::-1]
-        return open_paren \
-            + regex_opt_inner(sorted(s[:-slen] for s in strings), '(?:') \
-            + escape(suffix[::-1]) + close_paren
-    # recurse on common 1-string prefixes
-    # print '-> last resort'
-    return open_paren + \
-        '|'.join(regex_opt_inner(list(group[1]), '')
-                 for group in groupby(strings, lambda s: s[0] == first[0])) \
-        + close_paren
-
-
-def regex_opt(strings, prefix='', suffix=''):
-    """Return a compiled regex that matches any string in the given list.
-
-    The strings to match must be literal strings, not regexes.  They will be
-    regex-escaped.
-
-    *prefix* and *suffix* are pre- and appended to the final regex.
-    """
-    strings = sorted(strings)
-    return prefix + regex_opt_inner(strings, '(') + suffix

venv/Lib/site-packages/pip/_vendor/pygments/scanner.py

@@ -1,104 +0,0 @@
-"""
-    pygments.scanner
-    ~~~~~~~~~~~~~~~~
-
-    This library implements a regex based scanner. Some languages
-    like Pascal are easy to parse but have some keywords that
-    depend on the context. Because of this it's impossible to lex
-    that just by using a regular expression lexer like the
-    `RegexLexer`.
-
-    Have a look at the `DelphiLexer` to get an idea of how to use
-    this scanner.
-
-    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-import re
-
-
-class EndOfText(RuntimeError):
-    """
-    Raise if end of text is reached and the user
-    tried to call a match function.
-    """
-
-
-class Scanner:
-    """
-    Simple scanner
-
-    All method patterns are regular expression strings (not
-    compiled expressions!)
-    """
-
-    def __init__(self, text, flags=0):
-        """
-        :param text:    The text which should be scanned
-        :param flags:   default regular expression flags
-        """
-        self.data = text
-        self.data_length = len(text)
-        self.start_pos = 0
-        self.pos = 0
-        self.flags = flags
-        self.last = None
-        self.match = None
-        self._re_cache = {}
-
-    def eos(self):
-        """`True` if the scanner reached the end of text."""
-        return self.pos >= self.data_length
-    eos = property(eos, eos.__doc__)
-
-    def check(self, pattern):
-        """
-        Apply `pattern` on the current position and return
-        the match object. (Doesn't touch pos). Use this for
-        lookahead.
-        """
-        if self.eos:
-            raise EndOfText()
-        if pattern not in self._re_cache:
-            self._re_cache[pattern] = re.compile(pattern, self.flags)
-        return self._re_cache[pattern].match(self.data, self.pos)
-
-    def test(self, pattern):
-        """Apply a pattern on the current position and check
-        if it patches. Doesn't touch pos.
-        """
-        return self.check(pattern) is not None
-
-    def scan(self, pattern):
-        """
-        Scan the text for the given pattern and update pos/match
-        and related fields. The return value is a boolean that
-        indicates if the pattern matched. The matched value is
-        stored on the instance as ``match``, the last value is
-        stored as ``last``. ``start_pos`` is the position of the
-        pointer before the pattern was matched, ``pos`` is the
-        end position.
-        """
-        if self.eos:
-            raise EndOfText()
-        if pattern not in self._re_cache:
-            self._re_cache[pattern] = re.compile(pattern, self.flags)
-        self.last = self.match
-        m = self._re_cache[pattern].match(self.data, self.pos)
-        if m is None:
-            return False
-        self.start_pos = m.start()
-        self.pos = m.end()
-        self.match = m.group()
-        return True
-
-    def get_char(self):
-        """Scan exactly one char."""
-        self.scan('.')
-
-    def __repr__(self):
-        return '<%s %d/%d>' % (
-            self.__class__.__name__,
-            self.pos,
-            self.data_length
-        )

venv/Lib/site-packages/pip/_vendor/pygments/sphinxext.py

@@ -1,247 +0,0 @@
-"""
-    pygments.sphinxext
-    ~~~~~~~~~~~~~~~~~~
-
-    Sphinx extension to generate automatic documentation of lexers,
-    formatters and filters.
-
-    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-import sys
-
-from docutils import nodes
-from docutils.statemachine import ViewList
-from docutils.parsers.rst import Directive
-from sphinx.util.nodes import nested_parse_with_titles
-
-
-MODULEDOC = '''
-.. module:: %s
-
-%s
-%s
-'''
-
-LEXERDOC = '''
-.. class:: %s
-
-    :Short names: %s
-    :Filenames:   %s
-    :MIME types:  %s
-
-    %s
-
-    %s
-
-'''
-
-FMTERDOC = '''
-.. class:: %s
-
-    :Short names: %s
-    :Filenames: %s
-
-    %s
-
-'''
-
-FILTERDOC = '''
-.. class:: %s
-
-    :Name: %s
-
-    %s
-
-'''
-
-
-class PygmentsDoc(Directive):
-    """
-    A directive to collect all lexers/formatters/filters and generate
-    autoclass directives for them.
-    """
-    has_content = False
-    required_arguments = 1
-    optional_arguments = 0
-    final_argument_whitespace = False
-    option_spec = {}
-
-    def run(self):
-        self.filenames = set()
-        if self.arguments[0] == 'lexers':
-            out = self.document_lexers()
-        elif self.arguments[0] == 'formatters':
-            out = self.document_formatters()
-        elif self.arguments[0] == 'filters':
-            out = self.document_filters()
-        elif self.arguments[0] == 'lexers_overview':
-            out = self.document_lexers_overview()
-        else:
-            raise Exception('invalid argument for "pygmentsdoc" directive')
-        node = nodes.compound()
-        vl = ViewList(out.split('\n'), source='')
-        nested_parse_with_titles(self.state, vl, node)
-        for fn in self.filenames:
-            self.state.document.settings.record_dependencies.add(fn)
-        return node.children
-
-    def document_lexers_overview(self):
-        """Generate a tabular overview of all lexers.
-
-        The columns are the lexer name, the extensions handled by this lexer
-        (or "None"), the aliases and a link to the lexer class."""
-        from pip._vendor.pygments.lexers._mapping import LEXERS
-        from pip._vendor.pygments.lexers import find_lexer_class
-        out = []
-
-        table = []
-
-        def format_link(name, url):
-            if url:
-                return f'`{name} <{url}>`_'
-            return name
-
-        for classname, data in sorted(LEXERS.items(), key=lambda x: x[1][1].lower()):
-            lexer_cls = find_lexer_class(data[1])
-            extensions = lexer_cls.filenames + lexer_cls.alias_filenames
-
-            table.append({
-                'name': format_link(data[1], lexer_cls.url),
-                'extensions': ', '.join(extensions).replace('*', '\\*').replace('_', '\\') or 'None',
-                'aliases': ', '.join(data[2]),
-                'class': f'{data[0]}.{classname}'
-            })
-
-        column_names = ['name', 'extensions', 'aliases', 'class']
-        column_lengths = [max([len(row[column]) for row in table if row[column]])
-                          for column in column_names]
-
-        def write_row(*columns):
-            """Format a table row"""
-            out = []
-            for length, col in zip(column_lengths, columns):
-                if col:
-                    out.append(col.ljust(length))
-                else:
-                    out.append(' '*length)
-
-            return ' '.join(out)
-
-        def write_seperator():
-            """Write a table separator row"""
-            sep = ['='*c for c in column_lengths]
-            return write_row(*sep)
-
-        out.append(write_seperator())
-        out.append(write_row('Name', 'Extension(s)', 'Short name(s)', 'Lexer class'))
-        out.append(write_seperator())
-        for row in table:
-            out.append(write_row(
-                row['name'],
-                row['extensions'],
-                row['aliases'],
-                f':class:`~{row["class"]}`'))
-        out.append(write_seperator())
-
-        return '\n'.join(out)
-
-    def document_lexers(self):
-        from pip._vendor.pygments.lexers._mapping import LEXERS
-        from pip._vendor import pygments
-        import inspect
-        import pathlib
-
-        out = []
-        modules = {}
-        moduledocstrings = {}
-        for classname, data in sorted(LEXERS.items(), key=lambda x: x[0]):
-            module = data[0]
-            mod = __import__(module, None, None, [classname])
-            self.filenames.add(mod.__file__)
-            cls = getattr(mod, classname)
-            if not cls.__doc__:
-                print(f"Warning: {classname} does not have a docstring.")
-            docstring = cls.__doc__
-            if isinstance(docstring, bytes):
-                docstring = docstring.decode('utf8')
-
-            example_file = getattr(cls, '_example', None)
-            if example_file:
-                p = pathlib.Path(inspect.getabsfile(pygments)).parent.parent /\
-                    'tests' / 'examplefiles' / example_file
-                content = p.read_text(encoding='utf-8')
-                if not content:
-                    raise Exception(
-                        f"Empty example file '{example_file}' for lexer "
-                        f"{classname}")
-
-                if data[2]:
-                    lexer_name = data[2][0]
-                    docstring += '\n\n    .. admonition:: Example\n'
-                    docstring += f'\n      .. code-block:: {lexer_name}\n\n'
-                    for line in content.splitlines():
-                        docstring += f'          {line}\n'
-
-            if cls.version_added:
-                version_line = f'.. versionadded:: {cls.version_added}'
-            else:
-                version_line = ''
-
-            modules.setdefault(module, []).append((
-                classname,
-                ', '.join(data[2]) or 'None',
-                ', '.join(data[3]).replace('*', '\\*').replace('_', '\\') or 'None',
-                ', '.join(data[4]) or 'None',
-                docstring,
-                version_line))
-            if module not in moduledocstrings:
-                moddoc = mod.__doc__
-                if isinstance(moddoc, bytes):
-                    moddoc = moddoc.decode('utf8')
-                moduledocstrings[module] = moddoc
-
-        for module, lexers in sorted(modules.items(), key=lambda x: x[0]):
-            if moduledocstrings[module] is None:
-                raise Exception(f"Missing docstring for {module}")
-            heading = moduledocstrings[module].splitlines()[4].strip().rstrip('.')
-            out.append(MODULEDOC % (module, heading, '-'*len(heading)))
-            for data in lexers:
-                out.append(LEXERDOC % data)
-
-        return ''.join(out)
-
-    def document_formatters(self):
-        from pip._vendor.pygments.formatters import FORMATTERS
-
-        out = []
-        for classname, data in sorted(FORMATTERS.items(), key=lambda x: x[0]):
-            module = data[0]
-            mod = __import__(module, None, None, [classname])
-            self.filenames.add(mod.__file__)
-            cls = getattr(mod, classname)
-            docstring = cls.__doc__
-            if isinstance(docstring, bytes):
-                docstring = docstring.decode('utf8')
-            heading = cls.__name__
-            out.append(FMTERDOC % (heading, ', '.join(data[2]) or 'None',
-                                   ', '.join(data[3]).replace('*', '\\*') or 'None',
-                                   docstring))
-        return ''.join(out)
-
-    def document_filters(self):
-        from pip._vendor.pygments.filters import FILTERS
-
-        out = []
-        for name, cls in FILTERS.items():
-            self.filenames.add(sys.modules[cls.__module__].__file__)
-            docstring = cls.__doc__
-            if isinstance(docstring, bytes):
-                docstring = docstring.decode('utf8')
-            out.append(FILTERDOC % (cls.__name__, name, docstring))
-        return ''.join(out)
-
-
-def setup(app):
-    app.add_directive('pygmentsdoc', PygmentsDoc)