android-notify 1.60.0__py3-none-any.whl → 1.60.1__py3-none-any.whl

venv/Lib/site-packages/pygments/formatters/svg.py

@@ -1,185 +0,0 @@
-"""
-    pygments.formatters.svg
-    ~~~~~~~~~~~~~~~~~~~~~~~
-
-    Formatter for SVG output.
-
-    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-from pygments.formatter import Formatter
-from pygments.token import Comment
-from pygments.util import get_bool_opt, get_int_opt
-
-__all__ = ['SvgFormatter']
-
-
-def escape_html(text):
-    """Escape &, <, > as well as single and double quotes for HTML."""
-    return text.replace('&', '&amp;').  \
-                replace('<', '&lt;').   \
-                replace('>', '&gt;').   \
-                replace('"', '&quot;'). \
-                replace("'", '&#39;')
-
-
-class2style = {}
-
-class SvgFormatter(Formatter):
-    """
-    Format tokens as an SVG graphics file.  This formatter is still experimental.
-    Each line of code is a ``<text>`` element with explicit ``x`` and ``y``
-    coordinates containing ``<tspan>`` elements with the individual token styles.
-
-    By default, this formatter outputs a full SVG document including doctype
-    declaration and the ``<svg>`` root element.
-
-    .. versionadded:: 0.9
-
-    Additional options accepted:
-
-    `nowrap`
-        Don't wrap the SVG ``<text>`` elements in ``<svg><g>`` elements and
-        don't add a XML declaration and a doctype.  If true, the `fontfamily`
-        and `fontsize` options are ignored.  Defaults to ``False``.
-
-    `fontfamily`
-        The value to give the wrapping ``<g>`` element's ``font-family``
-        attribute, defaults to ``"monospace"``.
-
-    `fontsize`
-        The value to give the wrapping ``<g>`` element's ``font-size``
-        attribute, defaults to ``"14px"``.
-
-    `linenos`
-        If ``True``, add line numbers (default: ``False``).
-
-    `linenostart`
-        The line number for the first line (default: ``1``).
-
-    `linenostep`
-        If set to a number n > 1, only every nth line number is printed.
-
-    `linenowidth`
-        Maximum width devoted to line numbers (default: ``3*ystep``, sufficient
-        for up to 4-digit line numbers. Increase width for longer code blocks).
-
-    `xoffset`
-        Starting offset in X direction, defaults to ``0``.
-
-    `yoffset`
-        Starting offset in Y direction, defaults to the font size if it is given
-        in pixels, or ``20`` else.  (This is necessary since text coordinates
-        refer to the text baseline, not the top edge.)
-
-    `ystep`
-        Offset to add to the Y coordinate for each subsequent line.  This should
-        roughly be the text size plus 5.  It defaults to that value if the text
-        size is given in pixels, or ``25`` else.
-
-    `spacehack`
-        Convert spaces in the source to ``&#160;``, which are non-breaking
-        spaces.  SVG provides the ``xml:space`` attribute to control how
-        whitespace inside tags is handled, in theory, the ``preserve`` value
-        could be used to keep all whitespace as-is.  However, many current SVG
-        viewers don't obey that rule, so this option is provided as a workaround
-        and defaults to ``True``.
-    """
-    name = 'SVG'
-    aliases = ['svg']
-    filenames = ['*.svg']
-
-    def __init__(self, **options):
-        Formatter.__init__(self, **options)
-        self.nowrap = get_bool_opt(options, 'nowrap', False)
-        self.fontfamily = options.get('fontfamily', 'monospace')
-        self.fontsize = options.get('fontsize', '14px')
-        self.xoffset = get_int_opt(options, 'xoffset', 0)
-        fs = self.fontsize.strip()
-        if fs.endswith('px'):
-            fs = fs[:-2].strip()
-        try:
-            int_fs = int(fs)
-        except ValueError:
-            int_fs = 20
-        self.yoffset = get_int_opt(options, 'yoffset', int_fs)
-        self.ystep = get_int_opt(options, 'ystep', int_fs + 5)
-        self.spacehack = get_bool_opt(options, 'spacehack', True)
-        self.linenos = get_bool_opt(options,'linenos',False)
-        self.linenostart = get_int_opt(options,'linenostart',1)
-        self.linenostep = get_int_opt(options,'linenostep',1)
-        self.linenowidth = get_int_opt(options,'linenowidth', 3*self.ystep)
-        self._stylecache = {}
-
-    def format_unencoded(self, tokensource, outfile):
-        """
-        Format ``tokensource``, an iterable of ``(tokentype, tokenstring)``
-        tuples and write it into ``outfile``.
-
-        For our implementation we put all lines in their own 'line group'.
-        """
-        x = self.xoffset
-        y = self.yoffset
-        if not self.nowrap:
-            if self.encoding:
-                outfile.write(f'<?xml version="1.0" encoding="{self.encoding}"?>\n')
-            else:
-                outfile.write('<?xml version="1.0"?>\n')
-            outfile.write('<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.0//EN" '
-                          '"http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/'
-                          'svg10.dtd">\n')
-            outfile.write('<svg xmlns="http://www.w3.org/2000/svg">\n')
-            outfile.write(f'<g font-family="{self.fontfamily}" font-size="{self.fontsize}">\n')
-
-        counter = self.linenostart
-        counter_step = self.linenostep
-        counter_style = self._get_style(Comment)
-        line_x = x
-
-        if self.linenos:
-            if counter % counter_step == 0:
-                outfile.write(f'<text x="{x+self.linenowidth}" y="{y}" {counter_style} text-anchor="end">{counter}</text>')
-            line_x += self.linenowidth + self.ystep
-            counter += 1
-
-        outfile.write(f'<text x="{line_x}" y="{y}" xml:space="preserve">')
-        for ttype, value in tokensource:
-            style = self._get_style(ttype)
-            tspan = style and '<tspan' + style + '>' or ''
-            tspanend = tspan and '</tspan>' or ''
-            value = escape_html(value)
-            if self.spacehack:
-                value = value.expandtabs().replace(' ', '&#160;')
-            parts = value.split('\n')
-            for part in parts[:-1]:
-                outfile.write(tspan + part + tspanend)
-                y += self.ystep
-                outfile.write('</text>\n')
-                if self.linenos and counter % counter_step == 0:
-                    outfile.write(f'<text x="{x+self.linenowidth}" y="{y}" text-anchor="end" {counter_style}>{counter}</text>')
-
-                counter += 1
-                outfile.write(f'<text x="{line_x}" y="{y}" ' 'xml:space="preserve">')
-            outfile.write(tspan + parts[-1] + tspanend)
-        outfile.write('</text>')
-
-        if not self.nowrap:
-            outfile.write('</g></svg>\n')
-
-    def _get_style(self, tokentype):
-        if tokentype in self._stylecache:
-            return self._stylecache[tokentype]
-        otokentype = tokentype
-        while not self.style.styles_token(tokentype):
-            tokentype = tokentype.parent
-        value = self.style.style_for_token(tokentype)
-        result = ''
-        if value['color']:
-            result = ' fill="#' + value['color'] + '"'
-        if value['bold']:
-            result += ' font-weight="bold"'
-        if value['italic']:
-            result += ' font-style="italic"'
-        self._stylecache[otokentype] = result
-        return result

venv/Lib/site-packages/pygments/formatters/terminal.py

@@ -1,127 +0,0 @@
-"""
-    pygments.formatters.terminal
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    Formatter for terminal output with ANSI sequences.
-
-    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-from pygments.formatter import Formatter
-from pygments.token import Keyword, Name, Comment, String, Error, \
-    Number, Operator, Generic, Token, Whitespace
-from pygments.console import ansiformat
-from pygments.util import get_choice_opt
-
-
-__all__ = ['TerminalFormatter']
-
-
-#: Map token types to a tuple of color values for light and dark
-#: backgrounds.
-TERMINAL_COLORS = {
-    Token:              ('',            ''),
-
-    Whitespace:         ('gray',   'brightblack'),
-    Comment:            ('gray',   'brightblack'),
-    Comment.Preproc:    ('cyan',        'brightcyan'),
-    Keyword:            ('blue',    'brightblue'),
-    Keyword.Type:       ('cyan',        'brightcyan'),
-    Operator.Word:      ('magenta',      'brightmagenta'),
-    Name.Builtin:       ('cyan',        'brightcyan'),
-    Name.Function:      ('green',   'brightgreen'),
-    Name.Namespace:     ('_cyan_',      '_brightcyan_'),
-    Name.Class:         ('_green_', '_brightgreen_'),
-    Name.Exception:     ('cyan',        'brightcyan'),
-    Name.Decorator:     ('brightblack',    'gray'),
-    Name.Variable:      ('red',     'brightred'),
-    Name.Constant:      ('red',     'brightred'),
-    Name.Attribute:     ('cyan',        'brightcyan'),
-    Name.Tag:           ('brightblue',        'brightblue'),
-    String:             ('yellow',       'yellow'),
-    Number:             ('blue',    'brightblue'),
-
-    Generic.Deleted:    ('brightred',        'brightred'),
-    Generic.Inserted:   ('green',  'brightgreen'),
-    Generic.Heading:    ('**',         '**'),
-    Generic.Subheading: ('*magenta*',   '*brightmagenta*'),
-    Generic.Prompt:     ('**',         '**'),
-    Generic.Error:      ('brightred',        'brightred'),
-
-    Error:              ('_brightred_',      '_brightred_'),
-}
-
-
-class TerminalFormatter(Formatter):
-    r"""
-    Format tokens with ANSI color sequences, for output in a text console.
-    Color sequences are terminated at newlines, so that paging the output
-    works correctly.
-
-    The `get_style_defs()` method doesn't do anything special since there is
-    no support for common styles.
-
-    Options accepted:
-
-    `bg`
-        Set to ``"light"`` or ``"dark"`` depending on the terminal's background
-        (default: ``"light"``).
-
-    `colorscheme`
-        A dictionary mapping token types to (lightbg, darkbg) color names or
-        ``None`` (default: ``None`` = use builtin colorscheme).
-
-    `linenos`
-        Set to ``True`` to have line numbers on the terminal output as well
-        (default: ``False`` = no line numbers).
-    """
-    name = 'Terminal'
-    aliases = ['terminal', 'console']
-    filenames = []
-
-    def __init__(self, **options):
-        Formatter.__init__(self, **options)
-        self.darkbg = get_choice_opt(options, 'bg',
-                                     ['light', 'dark'], 'light') == 'dark'
-        self.colorscheme = options.get('colorscheme', None) or TERMINAL_COLORS
-        self.linenos = options.get('linenos', False)
-        self._lineno = 0
-
-    def format(self, tokensource, outfile):
-        return Formatter.format(self, tokensource, outfile)
-
-    def _write_lineno(self, outfile):
-        self._lineno += 1
-        outfile.write("%s%04d: " % (self._lineno != 1 and '\n' or '', self._lineno))
-
-    def _get_color(self, ttype):
-        # self.colorscheme is a dict containing usually generic types, so we
-        # have to walk the tree of dots.  The base Token type must be a key,
-        # even if it's empty string, as in the default above.
-        colors = self.colorscheme.get(ttype)
-        while colors is None:
-            ttype = ttype.parent
-            colors = self.colorscheme.get(ttype)
-        return colors[self.darkbg]
-
-    def format_unencoded(self, tokensource, outfile):
-        if self.linenos:
-            self._write_lineno(outfile)
-
-        for ttype, value in tokensource:
-            color = self._get_color(ttype)
-
-            for line in value.splitlines(True):
-                if color:
-                    outfile.write(ansiformat(color, line.rstrip('\n')))
-                else:
-                    outfile.write(line.rstrip('\n'))
-                if line.endswith('\n'):
-                    if self.linenos:
-                        self._write_lineno(outfile)
-                    else:
-                        outfile.write('\n')
-
-        if self.linenos:
-            outfile.write("\n")

venv/Lib/site-packages/pygments/formatters/terminal256.py

@@ -1,338 +0,0 @@
-"""
-    pygments.formatters.terminal256
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    Formatter for 256-color terminal output with ANSI sequences.
-
-    RGB-to-XTERM color conversion routines adapted from xterm256-conv
-    tool (http://frexx.de/xterm-256-notes/data/xterm256-conv2.tar.bz2)
-    by Wolfgang Frisch.
-
-    Formatter version 1.
-
-    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-# TODO:
-#  - Options to map style's bold/underline/italic/border attributes
-#    to some ANSI attrbutes (something like 'italic=underline')
-#  - An option to output "style RGB to xterm RGB/index" conversion table
-#  - An option to indicate that we are running in "reverse background"
-#    xterm. This means that default colors are white-on-black, not
-#    black-on-while, so colors like "white background" need to be converted
-#    to "white background, black foreground", etc...
-
-from pygments.formatter import Formatter
-from pygments.console import codes
-from pygments.style import ansicolors
-
-
-__all__ = ['Terminal256Formatter', 'TerminalTrueColorFormatter']
-
-
-class EscapeSequence:
-    def __init__(self, fg=None, bg=None, bold=False, underline=False, italic=False):
-        self.fg = fg
-        self.bg = bg
-        self.bold = bold
-        self.underline = underline
-        self.italic = italic
-
-    def escape(self, attrs):
-        if len(attrs):
-            return "\x1b[" + ";".join(attrs) + "m"
-        return ""
-
-    def color_string(self):
-        attrs = []
-        if self.fg is not None:
-            if self.fg in ansicolors:
-                esc = codes[self.fg.replace('ansi','')]
-                if ';01m' in esc:
-                    self.bold = True
-                # extract fg color code.
-                attrs.append(esc[2:4])
-            else:
-                attrs.extend(("38", "5", "%i" % self.fg))
-        if self.bg is not None:
-            if self.bg in ansicolors:
-                esc = codes[self.bg.replace('ansi','')]
-                # extract fg color code, add 10 for bg.
-                attrs.append(str(int(esc[2:4])+10))
-            else:
-                attrs.extend(("48", "5", "%i" % self.bg))
-        if self.bold:
-            attrs.append("01")
-        if self.underline:
-            attrs.append("04")
-        if self.italic:
-            attrs.append("03")
-        return self.escape(attrs)
-
-    def true_color_string(self):
-        attrs = []
-        if self.fg:
-            attrs.extend(("38", "2", str(self.fg[0]), str(self.fg[1]), str(self.fg[2])))
-        if self.bg:
-            attrs.extend(("48", "2", str(self.bg[0]), str(self.bg[1]), str(self.bg[2])))
-        if self.bold:
-            attrs.append("01")
-        if self.underline:
-            attrs.append("04")
-        if self.italic:
-            attrs.append("03")
-        return self.escape(attrs)
-
-    def reset_string(self):
-        attrs = []
-        if self.fg is not None:
-            attrs.append("39")
-        if self.bg is not None:
-            attrs.append("49")
-        if self.bold or self.underline or self.italic:
-            attrs.append("00")
-        return self.escape(attrs)
-
-
-class Terminal256Formatter(Formatter):
-    """
-    Format tokens with ANSI color sequences, for output in a 256-color
-    terminal or console.  Like in `TerminalFormatter` color sequences
-    are terminated at newlines, so that paging the output works correctly.
-
-    The formatter takes colors from a style defined by the `style` option
-    and converts them to nearest ANSI 256-color escape sequences. Bold and
-    underline attributes from the style are preserved (and displayed).
-
-    .. versionadded:: 0.9
-
-    .. versionchanged:: 2.2
-       If the used style defines foreground colors in the form ``#ansi*``, then
-       `Terminal256Formatter` will map these to non extended foreground color.
-       See :ref:`AnsiTerminalStyle` for more information.
-
-    .. versionchanged:: 2.4
-       The ANSI color names have been updated with names that are easier to
-       understand and align with colornames of other projects and terminals.
-       See :ref:`this table <new-ansi-color-names>` for more information.
-
-
-    Options accepted:
-
-    `style`
-        The style to use, can be a string or a Style subclass (default:
-        ``'default'``).
-
-    `linenos`
-        Set to ``True`` to have line numbers on the terminal output as well
-        (default: ``False`` = no line numbers).
-    """
-    name = 'Terminal256'
-    aliases = ['terminal256', 'console256', '256']
-    filenames = []
-
-    def __init__(self, **options):
-        Formatter.__init__(self, **options)
-
-        self.xterm_colors = []
-        self.best_match = {}
-        self.style_string = {}
-
-        self.usebold = 'nobold' not in options
-        self.useunderline = 'nounderline' not in options
-        self.useitalic = 'noitalic' not in options
-
-        self._build_color_table()  # build an RGB-to-256 color conversion table
-        self._setup_styles()  # convert selected style's colors to term. colors
-
-        self.linenos = options.get('linenos', False)
-        self._lineno = 0
-
-    def _build_color_table(self):
-        # colors 0..15: 16 basic colors
-
-        self.xterm_colors.append((0x00, 0x00, 0x00))  # 0
-        self.xterm_colors.append((0xcd, 0x00, 0x00))  # 1
-        self.xterm_colors.append((0x00, 0xcd, 0x00))  # 2
-        self.xterm_colors.append((0xcd, 0xcd, 0x00))  # 3
-        self.xterm_colors.append((0x00, 0x00, 0xee))  # 4
-        self.xterm_colors.append((0xcd, 0x00, 0xcd))  # 5
-        self.xterm_colors.append((0x00, 0xcd, 0xcd))  # 6
-        self.xterm_colors.append((0xe5, 0xe5, 0xe5))  # 7
-        self.xterm_colors.append((0x7f, 0x7f, 0x7f))  # 8
-        self.xterm_colors.append((0xff, 0x00, 0x00))  # 9
-        self.xterm_colors.append((0x00, 0xff, 0x00))  # 10
-        self.xterm_colors.append((0xff, 0xff, 0x00))  # 11
-        self.xterm_colors.append((0x5c, 0x5c, 0xff))  # 12
-        self.xterm_colors.append((0xff, 0x00, 0xff))  # 13
-        self.xterm_colors.append((0x00, 0xff, 0xff))  # 14
-        self.xterm_colors.append((0xff, 0xff, 0xff))  # 15
-
-        # colors 16..232: the 6x6x6 color cube
-
-        valuerange = (0x00, 0x5f, 0x87, 0xaf, 0xd7, 0xff)
-
-        for i in range(217):
-            r = valuerange[(i // 36) % 6]
-            g = valuerange[(i // 6) % 6]
-            b = valuerange[i % 6]
-            self.xterm_colors.append((r, g, b))
-
-        # colors 233..253: grayscale
-
-        for i in range(1, 22):
-            v = 8 + i * 10
-            self.xterm_colors.append((v, v, v))
-
-    def _closest_color(self, r, g, b):
-        distance = 257*257*3  # "infinity" (>distance from #000000 to #ffffff)
-        match = 0
-
-        for i in range(0, 254):
-            values = self.xterm_colors[i]
-
-            rd = r - values[0]
-            gd = g - values[1]
-            bd = b - values[2]
-            d = rd*rd + gd*gd + bd*bd
-
-            if d < distance:
-                match = i
-                distance = d
-        return match
-
-    def _color_index(self, color):
-        index = self.best_match.get(color, None)
-        if color in ansicolors:
-            # strip the `ansi/#ansi` part and look up code
-            index = color
-            self.best_match[color] = index
-        if index is None:
-            try:
-                rgb = int(str(color), 16)
-            except ValueError:
-                rgb = 0
-
-            r = (rgb >> 16) & 0xff
-            g = (rgb >> 8) & 0xff
-            b = rgb & 0xff
-            index = self._closest_color(r, g, b)
-            self.best_match[color] = index
-        return index
-
-    def _setup_styles(self):
-        for ttype, ndef in self.style:
-            escape = EscapeSequence()
-            # get foreground from ansicolor if set
-            if ndef['ansicolor']:
-                escape.fg = self._color_index(ndef['ansicolor'])
-            elif ndef['color']:
-                escape.fg = self._color_index(ndef['color'])
-            if ndef['bgansicolor']:
-                escape.bg = self._color_index(ndef['bgansicolor'])
-            elif ndef['bgcolor']:
-                escape.bg = self._color_index(ndef['bgcolor'])
-            if self.usebold and ndef['bold']:
-                escape.bold = True
-            if self.useunderline and ndef['underline']:
-                escape.underline = True
-            if self.useitalic and ndef['italic']:
-                escape.italic = True
-            self.style_string[str(ttype)] = (escape.color_string(),
-                                             escape.reset_string())
-
-    def _write_lineno(self, outfile):
-        self._lineno += 1
-        outfile.write("%s%04d: " % (self._lineno != 1 and '\n' or '', self._lineno))
-
-    def format(self, tokensource, outfile):
-        return Formatter.format(self, tokensource, outfile)
-
-    def format_unencoded(self, tokensource, outfile):
-        if self.linenos:
-            self._write_lineno(outfile)
-
-        for ttype, value in tokensource:
-            not_found = True
-            while ttype and not_found:
-                try:
-                    # outfile.write( "<" + str(ttype) + ">" )
-                    on, off = self.style_string[str(ttype)]
-
-                    # Like TerminalFormatter, add "reset colors" escape sequence
-                    # on newline.
-                    spl = value.split('\n')
-                    for line in spl[:-1]:
-                        if line:
-                            outfile.write(on + line + off)
-                        if self.linenos:
-                            self._write_lineno(outfile)
-                        else:
-                            outfile.write('\n')
-
-                    if spl[-1]:
-                        outfile.write(on + spl[-1] + off)
-
-                    not_found = False
-                    # outfile.write( '#' + str(ttype) + '#' )
-
-                except KeyError:
-                    # ottype = ttype
-                    ttype = ttype.parent
-                    # outfile.write( '!' + str(ottype) + '->' + str(ttype) + '!' )
-
-            if not_found:
-                outfile.write(value)
-
-        if self.linenos:
-            outfile.write("\n")
-
-
-
-class TerminalTrueColorFormatter(Terminal256Formatter):
-    r"""
-    Format tokens with ANSI color sequences, for output in a true-color
-    terminal or console.  Like in `TerminalFormatter` color sequences
-    are terminated at newlines, so that paging the output works correctly.
-
-    .. versionadded:: 2.1
-
-    Options accepted:
-
-    `style`
-        The style to use, can be a string or a Style subclass (default:
-        ``'default'``).
-    """
-    name = 'TerminalTrueColor'
-    aliases = ['terminal16m', 'console16m', '16m']
-    filenames = []
-
-    def _build_color_table(self):
-        pass
-
-    def _color_tuple(self, color):
-        try:
-            rgb = int(str(color), 16)
-        except ValueError:
-            return None
-        r = (rgb >> 16) & 0xff
-        g = (rgb >> 8) & 0xff
-        b = rgb & 0xff
-        return (r, g, b)
-
-    def _setup_styles(self):
-        for ttype, ndef in self.style:
-            escape = EscapeSequence()
-            if ndef['color']:
-                escape.fg = self._color_tuple(ndef['color'])
-            if ndef['bgcolor']:
-                escape.bg = self._color_tuple(ndef['bgcolor'])
-            if self.usebold and ndef['bold']:
-                escape.bold = True
-            if self.useunderline and ndef['underline']:
-                escape.underline = True
-            if self.useitalic and ndef['italic']:
-                escape.italic = True
-            self.style_string[str(ttype)] = (escape.true_color_string(),
-                                             escape.reset_string())