hmdev-cli 1.0.1 → 1.0.3

package/python/.venv/Lib/site-packages/pip/_vendor/pygments/formatters/other.py

@@ -1,160 +0,0 @@
-"""
-    pygments.formatters.other
-    ~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    Other formatters: NullFormatter, RawTokenFormatter.
-
-    :copyright: Copyright 2006-2024 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-from pip._vendor.pygments.formatter import Formatter
-from pip._vendor.pygments.util import get_choice_opt
-from pip._vendor.pygments.token import Token
-from pip._vendor.pygments.console import colorize
-
-__all__ = ['NullFormatter', 'RawTokenFormatter', 'TestcaseFormatter']
-
-
-class NullFormatter(Formatter):
-    """
-    Output the text unchanged without any formatting.
-    """
-    name = 'Text only'
-    aliases = ['text', 'null']
-    filenames = ['*.txt']
-
-    def format(self, tokensource, outfile):
-        enc = self.encoding
-        for ttype, value in tokensource:
-            if enc:
-                outfile.write(value.encode(enc))
-            else:
-                outfile.write(value)
-
-
-class RawTokenFormatter(Formatter):
-    r"""
-    Format tokens as a raw representation for storing token streams.
-
-    The format is ``tokentype<TAB>repr(tokenstring)\n``. The output can later
-    be converted to a token stream with the `RawTokenLexer`, described in the
-    :doc:`lexer list <lexers>`.
-
-    Only two options are accepted:
-
-    `compress`
-        If set to ``'gz'`` or ``'bz2'``, compress the output with the given
-        compression algorithm after encoding (default: ``''``).
-    `error_color`
-        If set to a color name, highlight error tokens using that color.  If
-        set but with no value, defaults to ``'red'``.
-
-        .. versionadded:: 0.11
-
-    """
-    name = 'Raw tokens'
-    aliases = ['raw', 'tokens']
-    filenames = ['*.raw']
-
-    unicodeoutput = False
-
-    def __init__(self, **options):
-        Formatter.__init__(self, **options)
-        # We ignore self.encoding if it is set, since it gets set for lexer
-        # and formatter if given with -Oencoding on the command line.
-        # The RawTokenFormatter outputs only ASCII. Override here.
-        self.encoding = 'ascii'  # let pygments.format() do the right thing
-        self.compress = get_choice_opt(options, 'compress',
-                                       ['', 'none', 'gz', 'bz2'], '')
-        self.error_color = options.get('error_color', None)
-        if self.error_color is True:
-            self.error_color = 'red'
-        if self.error_color is not None:
-            try:
-                colorize(self.error_color, '')
-            except KeyError:
-                raise ValueError(f"Invalid color {self.error_color!r} specified")
-
-    def format(self, tokensource, outfile):
-        try:
-            outfile.write(b'')
-        except TypeError:
-            raise TypeError('The raw tokens formatter needs a binary '
-                            'output file')
-        if self.compress == 'gz':
-            import gzip
-            outfile = gzip.GzipFile('', 'wb', 9, outfile)
-
-            write = outfile.write
-            flush = outfile.close
-        elif self.compress == 'bz2':
-            import bz2
-            compressor = bz2.BZ2Compressor(9)
-
-            def write(text):
-                outfile.write(compressor.compress(text))
-
-            def flush():
-                outfile.write(compressor.flush())
-                outfile.flush()
-        else:
-            write = outfile.write
-            flush = outfile.flush
-
-        if self.error_color:
-            for ttype, value in tokensource:
-                line = b"%r\t%r\n" % (ttype, value)
-                if ttype is Token.Error:
-                    write(colorize(self.error_color, line))
-                else:
-                    write(line)
-        else:
-            for ttype, value in tokensource:
-                write(b"%r\t%r\n" % (ttype, value))
-        flush()
-
-
-TESTCASE_BEFORE = '''\
-    def testNeedsName(lexer):
-        fragment = %r
-        tokens = [
-'''
-TESTCASE_AFTER = '''\
-        ]
-        assert list(lexer.get_tokens(fragment)) == tokens
-'''
-
-
-class TestcaseFormatter(Formatter):
-    """
-    Format tokens as appropriate for a new testcase.
-
-    .. versionadded:: 2.0
-    """
-    name = 'Testcase'
-    aliases = ['testcase']
-
-    def __init__(self, **options):
-        Formatter.__init__(self, **options)
-        if self.encoding is not None and self.encoding != 'utf-8':
-            raise ValueError("Only None and utf-8 are allowed encodings.")
-
-    def format(self, tokensource, outfile):
-        indentation = ' ' * 12
-        rawbuf = []
-        outbuf = []
-        for ttype, value in tokensource:
-            rawbuf.append(value)
-            outbuf.append(f'{indentation}({ttype}, {value!r}),\n')
-
-        before = TESTCASE_BEFORE % (''.join(rawbuf),)
-        during = ''.join(outbuf)
-        after = TESTCASE_AFTER
-        if self.encoding is None:
-            outfile.write(before + during + after)
-        else:
-            outfile.write(before.encode('utf-8'))
-            outfile.write(during.encode('utf-8'))
-            outfile.write(after.encode('utf-8'))
-        outfile.flush()

package/python/.venv/Lib/site-packages/pip/_vendor/pygments/formatters/pangomarkup.py

@@ -1,83 +0,0 @@
-"""
-    pygments.formatters.pangomarkup
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    Formatter for Pango markup output.
-
-    :copyright: Copyright 2006-2024 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-from pip._vendor.pygments.formatter import Formatter
-
-
-__all__ = ['PangoMarkupFormatter']
-
-
-_escape_table = {
-    ord('&'): '&',
-    ord('<'): '&lt;',
-}
-
-
-def escape_special_chars(text, table=_escape_table):
-    """Escape & and < for Pango Markup."""
-    return text.translate(table)
-
-
-class PangoMarkupFormatter(Formatter):
-    """
-    Format tokens as Pango Markup code. It can then be rendered to an SVG.
-
-    .. versionadded:: 2.9
-    """
-
-    name = 'Pango Markup'
-    aliases = ['pango', 'pangomarkup']
-    filenames = []
-
-    def __init__(self, **options):
-        Formatter.__init__(self, **options)
-
-        self.styles = {}
-
-        for token, style in self.style:
-            start = ''
-            end = ''
-            if style['color']:
-                start += '<span fgcolor="#{}">'.format(style['color'])
-                end = '</span>' + end
-            if style['bold']:
-                start += '<b>'
-                end = '</b>' + end
-            if style['italic']:
-                start += '<i>'
-                end = '</i>' + end
-            if style['underline']:
-                start += '<u>'
-                end = '</u>' + end
-            self.styles[token] = (start, end)
-
-    def format_unencoded(self, tokensource, outfile):
-        lastval = ''
-        lasttype = None
-
-        outfile.write('<tt>')
-
-        for ttype, value in tokensource:
-            while ttype not in self.styles:
-                ttype = ttype.parent
-            if ttype == lasttype:
-                lastval += escape_special_chars(value)
-            else:
-                if lastval:
-                    stylebegin, styleend = self.styles[lasttype]
-                    outfile.write(stylebegin + lastval + styleend)
-                lastval = escape_special_chars(value)
-                lasttype = ttype
-
-        if lastval:
-            stylebegin, styleend = self.styles[lasttype]
-            outfile.write(stylebegin + lastval + styleend)
-
-        outfile.write('</tt>')

package/python/.venv/Lib/site-packages/pip/_vendor/pygments/formatters/rtf.py

@@ -1,349 +0,0 @@
-"""
-    pygments.formatters.rtf
-    ~~~~~~~~~~~~~~~~~~~~~~~
-
-    A formatter that generates RTF files.
-
-    :copyright: Copyright 2006-2024 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-from collections import OrderedDict
-from pip._vendor.pygments.formatter import Formatter
-from pip._vendor.pygments.style import _ansimap
-from pip._vendor.pygments.util import get_bool_opt, get_int_opt, get_list_opt, surrogatepair
-
-
-__all__ = ['RtfFormatter']
-
-
-class RtfFormatter(Formatter):
-    """
-    Format tokens as RTF markup. This formatter automatically outputs full RTF
-    documents with color information and other useful stuff. Perfect for Copy and
-    Paste into Microsoft(R) Word(R) documents.
-
-    Please note that ``encoding`` and ``outencoding`` options are ignored.
-    The RTF format is ASCII natively, but handles unicode characters correctly
-    thanks to escape sequences.
-
-    .. versionadded:: 0.6
-
-    Additional options accepted:
-
-    `style`
-        The style to use, can be a string or a Style subclass (default:
-        ``'default'``).
-
-    `fontface`
-        The used font family, for example ``Bitstream Vera Sans``. Defaults to
-        some generic font which is supposed to have fixed width.
-
-    `fontsize`
-        Size of the font used. Size is specified in half points. The
-        default is 24 half-points, giving a size 12 font.
-
-        .. versionadded:: 2.0
-
-    `linenos`
-        Turn on line numbering (default: ``False``).
-
-        .. versionadded:: 2.18
-
-    `lineno_fontsize`
-        Font size for line numbers. Size is specified in half points
-        (default: `fontsize`). 
-
-        .. versionadded:: 2.18
-
-    `lineno_padding`
-        Number of spaces between the (inline) line numbers and the
-        source code (default: ``2``).
-
-        .. versionadded:: 2.18
-
-    `linenostart`
-        The line number for the first line (default: ``1``).
-
-        .. versionadded:: 2.18
-
-    `linenostep`
-        If set to a number n > 1, only every nth line number is printed.
-
-        .. versionadded:: 2.18
-
-    `lineno_color`
-        Color for line numbers specified as a hex triplet, e.g. ``'5e5e5e'``. 
-        Defaults to the style's line number color if it is a hex triplet, 
-        otherwise ansi bright black.
-
-        .. versionadded:: 2.18
-
-    `hl_lines`
-        Specify a list of lines to be highlighted, as line numbers separated by
-        spaces, e.g. ``'3 7 8'``. The line numbers are relative to the input 
-        (i.e. the first line is line 1) unless `hl_linenostart` is set.
-
-        .. versionadded:: 2.18
-
-    `hl_color`
-        Color for highlighting the lines specified in `hl_lines`, specified as 
-        a hex triplet (default: style's `highlight_color`).
-
-        .. versionadded:: 2.18
-
-    `hl_linenostart`
-        If set to ``True`` line numbers in `hl_lines` are specified
-        relative to `linenostart` (default ``False``).
-
-        .. versionadded:: 2.18
-    """
-    name = 'RTF'
-    aliases = ['rtf']
-    filenames = ['*.rtf']
-
-    def __init__(self, **options):
-        r"""
-        Additional options accepted:
-
-        ``fontface``
-            Name of the font used. Could for example be ``'Courier New'``
-            to further specify the default which is ``'\fmodern'``. The RTF
-            specification claims that ``\fmodern`` are "Fixed-pitch serif
-            and sans serif fonts". Hope every RTF implementation thinks
-            the same about modern...
-
-        """
-        Formatter.__init__(self, **options)
-        self.fontface = options.get('fontface') or ''
-        self.fontsize = get_int_opt(options, 'fontsize', 0)
-        self.linenos = get_bool_opt(options, 'linenos', False)
-        self.lineno_fontsize = get_int_opt(options, 'lineno_fontsize',
-                                           self.fontsize)
-        self.lineno_padding = get_int_opt(options, 'lineno_padding', 2)
-        self.linenostart = abs(get_int_opt(options, 'linenostart', 1))
-        self.linenostep = abs(get_int_opt(options, 'linenostep', 1))
-        self.hl_linenostart = get_bool_opt(options, 'hl_linenostart', False)
-
-        self.hl_color = options.get('hl_color', '')
-        if not self.hl_color:
-            self.hl_color = self.style.highlight_color
-
-        self.hl_lines = []
-        for lineno in get_list_opt(options, 'hl_lines', []):
-            try:
-                lineno = int(lineno)
-                if self.hl_linenostart:
-                    lineno = lineno - self.linenostart + 1
-                self.hl_lines.append(lineno)
-            except ValueError:
-                pass
-
-        self.lineno_color = options.get('lineno_color', '')
-        if not self.lineno_color:
-            if  self.style.line_number_color == 'inherit':
-                # style color is the css value 'inherit'
-                # default to ansi bright-black
-                self.lineno_color = _ansimap['ansibrightblack']
-            else:
-                # style color is assumed to be a hex triplet as other
-                # colors in pygments/style.py
-                self.lineno_color = self.style.line_number_color
-
-        self.color_mapping = self._create_color_mapping()
-
-    def _escape(self, text):
-        return text.replace('\\', '\\\\') \
-                   .replace('{', '\\{') \
-                   .replace('}', '\\}')
-
-    def _escape_text(self, text):
-        # empty strings, should give a small performance improvement
-        if not text:
-            return ''
-
-        # escape text
-        text = self._escape(text)
-
-        buf = []
-        for c in text:
-            cn = ord(c)
-            if cn < (2**7):
-                # ASCII character
-                buf.append(str(c))
-            elif (2**7) <= cn < (2**16):
-                # single unicode escape sequence
-                buf.append('{\\u%d}' % cn)
-            elif (2**16) <= cn:
-                # RTF limits unicode to 16 bits.
-                # Force surrogate pairs
-                buf.append('{\\u%d}{\\u%d}' % surrogatepair(cn))
-
-        return ''.join(buf).replace('\n', '\\par')
-
-    @staticmethod
-    def hex_to_rtf_color(hex_color):
-        if hex_color[0] == "#":
-            hex_color = hex_color[1:]
-
-        return '\\red%d\\green%d\\blue%d;' % (
-                        int(hex_color[0:2], 16),
-                        int(hex_color[2:4], 16),
-                        int(hex_color[4:6], 16)
-                    )
-
-    def _split_tokens_on_newlines(self, tokensource):
-        """
-        Split tokens containing newline characters into multiple token
-        each representing a line of the input file. Needed for numbering
-        lines of e.g. multiline comments.
-        """
-        for ttype, value in tokensource:
-            if value == '\n':
-                yield (ttype, value)
-            elif "\n" in value:
-                lines = value.split("\n")
-                for line in lines[:-1]:
-                    yield (ttype, line+"\n")
-                if lines[-1]:
-                    yield (ttype, lines[-1])
-            else:
-                yield (ttype, value)
-
-    def _create_color_mapping(self):
-        """
-        Create a mapping of style hex colors to index/offset in
-        the RTF color table.
-        """
-        color_mapping = OrderedDict()
-        offset = 1
-
-        if self.linenos:
-            color_mapping[self.lineno_color] = offset
-            offset += 1
-
-        if self.hl_lines:
-            color_mapping[self.hl_color] = offset
-            offset += 1
-
-        for _, style in self.style:
-            for color in style['color'], style['bgcolor'], style['border']:
-                if color and color not in color_mapping:
-                    color_mapping[color] = offset
-                    offset += 1
-
-        return color_mapping
-
-    @property
-    def _lineno_template(self):
-        if self.lineno_fontsize != self.fontsize:
-            return '{{\\fs{} \\cf{} %s{}}}'.format(self.lineno_fontsize,
-                          self.color_mapping[self.lineno_color],
-                          " " * self.lineno_padding)
-
-        return '{{\\cf{} %s{}}}'.format(self.color_mapping[self.lineno_color],
-                      " " * self.lineno_padding)
-
-    @property
-    def _hl_open_str(self):
-        return rf'{{\highlight{self.color_mapping[self.hl_color]} '
-
-    @property
-    def _rtf_header(self):
-        lines = []
-        # rtf 1.8 header
-        lines.append('{\\rtf1\\ansi\\uc0\\deff0'
-                     '{\\fonttbl{\\f0\\fmodern\\fprq1\\fcharset0%s;}}'
-                     % (self.fontface and ' '
-                        + self._escape(self.fontface) or ''))
-
-        # color table
-        lines.append('{\\colortbl;')
-        for color, _ in self.color_mapping.items():
-            lines.append(self.hex_to_rtf_color(color))
-        lines.append('}')
-
-        # font and fontsize
-        lines.append('\\f0\\sa0')
-        if self.fontsize:
-            lines.append('\\fs%d' % self.fontsize)
-
-        # ensure Libre Office Writer imports and renders consecutive
-        # space characters the same width, needed for line numbering.
-        # https://bugs.documentfoundation.org/show_bug.cgi?id=144050
-        lines.append('\\dntblnsbdb')
-
-        return lines
-
-    def format_unencoded(self, tokensource, outfile):
-        for line in self._rtf_header:
-            outfile.write(line + "\n")
-
-        tokensource = self._split_tokens_on_newlines(tokensource)
-
-        # first pass of tokens to count lines, needed for line numbering
-        if self.linenos:
-            line_count = 0
-            tokens = [] # for copying the token source generator
-            for ttype, value in tokensource:
-                tokens.append((ttype, value))
-                if value.endswith("\n"):
-                    line_count += 1
-
-            # width of line number strings (for padding with spaces)
-            linenos_width = len(str(line_count+self.linenostart-1))
-
-            tokensource = tokens
-
-        # highlight stream
-        lineno = 1
-        start_new_line = True
-        for ttype, value in tokensource:
-            if start_new_line and lineno in self.hl_lines:
-                outfile.write(self._hl_open_str)
-
-            if start_new_line and self.linenos:
-                if (lineno-self.linenostart+1)%self.linenostep == 0:
-                    current_lineno = lineno + self.linenostart - 1
-                    lineno_str = str(current_lineno).rjust(linenos_width)
-                else:
-                    lineno_str = "".rjust(linenos_width)
-                outfile.write(self._lineno_template % lineno_str)
-
-            while not self.style.styles_token(ttype) and ttype.parent:
-                ttype = ttype.parent
-            style = self.style.style_for_token(ttype)
-            buf = []
-            if style['bgcolor']:
-                buf.append('\\cb%d' % self.color_mapping[style['bgcolor']])
-            if style['color']:
-                buf.append('\\cf%d' % self.color_mapping[style['color']])
-            if style['bold']:
-                buf.append('\\b')
-            if style['italic']:
-                buf.append('\\i')
-            if style['underline']:
-                buf.append('\\ul')
-            if style['border']:
-                buf.append('\\chbrdr\\chcfpat%d' %
-                           self.color_mapping[style['border']])
-            start = ''.join(buf)
-            if start:
-                outfile.write(f'{{{start} ')
-            outfile.write(self._escape_text(value))
-            if start:
-                outfile.write('}')
-            start_new_line = False
-
-            # complete line of input
-            if value.endswith("\n"):
-                # close line highlighting
-                if lineno in self.hl_lines:
-                    outfile.write('}')
-                # newline in RTF file after closing }
-                outfile.write("\n")
-
-                start_new_line = True
-                lineno += 1
-
-        outfile.write('}\n')