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

venv/Lib/site-packages/docutils/utils/_roman_numerals.py

@@ -1,264 +0,0 @@
-# $Id$
-# Author: Adam Turner.
-# Copyright: This module is placed in the public domain
-#            or under the `Zero Clause BSD licence`_,
-#            whichever is more permissive.
-#
-# .. _Zero Clause BSD licence: https://opensource.org/license/0BSD
-
-"""Conversion between integers and roman numerals."""
-
-from __future__ import annotations
-
-import sys
-
-TYPE_CHECKING = False
-if TYPE_CHECKING:
-    from typing import Final, final
-
-    from docutils.utils._typing import Self
-else:
-    from docutils.utils._typing import final
-
-
-__all__: Final = (
-    'MAX',
-    'MIN',
-    'InvalidRomanNumeralError',
-    'OutOfRangeError',
-    'RomanNumeral',
-)
-
-MIN: Final = 1
-"""The value of the smallest well-formed roman numeral."""
-
-# Note that 4,999 (MMMMCMXCIX) breaks one of the rules of Roman numerals,
-# that the same character may not appear more than thrice consecutively,
-# meaning the largest 'well-formed' Roman numeral is 3,999 (MMMCMXCIX).
-# We use 4,999 for backwards compatibility reasons.
-MAX: Final = 4_999
-"""The value of the largest well-formed roman numeral."""
-
-
-@final
-class OutOfRangeError(TypeError):
-    """Number out of range (must be between 1 and 4,999)."""
-
-
-@final
-class InvalidRomanNumeralError(ValueError):
-    """Not a valid Roman numeral."""
-
-    def __init__(self, value: str, *args: object) -> None:
-        msg = f'Invalid Roman numeral: {value}'
-        super().__init__(msg, *args)
-
-
-@final
-class RomanNumeral:
-    """A Roman numeral.
-
-    Only values between 1 and 4,999 are valid.
-    Stores the value internally as an ``int``.
-
-    >>> answer = RomanNumeral(42)
-    >>> print(answer.to_uppercase())
-    XLII
-    """
-
-    __slots__ = ('_value',)
-    _value: int
-
-    def __init__(self, value: int, /) -> None:
-        if not isinstance(value, int):
-            value_qualname = type(value).__qualname__
-            msg = f'RomanNumeral: an integer is required, not {value_qualname!r}'  # NoQA: E501
-            raise TypeError(msg)
-        if value < MIN or value > MAX:
-            msg = f'Number out of range (must be between 1 and 4,999). Got {value}.'  # NoQA: E501
-            raise OutOfRangeError(msg)
-        super().__setattr__('_value', value)
-
-    def __int__(self) -> int:
-        """Return the integer value of this numeral."""
-        return self._value
-
-    def __str__(self) -> str:
-        """Return the well-formed (uppercase) string for this numeral."""
-        return self.to_uppercase()
-
-    def __repr__(self) -> str:
-        """Return the string representation of this numeral."""
-        return f'{self.__class__.__name__}({self._value!r})'
-
-    def __eq__(self, other: object) -> bool:
-        """Return self == other."""
-        if isinstance(other, RomanNumeral):
-            return self._value == other._value
-        return NotImplemented
-
-    def __lt__(self, other: object) -> bool:
-        """Return self < other."""
-        if isinstance(other, RomanNumeral):
-            return self._value < other._value
-        return NotImplemented
-
-    def __hash__(self) -> int:
-        """Return the hashed value of this numeral."""
-        return hash(self._value)
-
-    def __setattr__(self, key: str, value: object) -> None:
-        """Implement setattr(self, name, value)."""
-        if key == '_value':
-            msg = f'Cannot set the {key!r} attribute.'
-            raise AttributeError(msg)
-        super().__setattr__(key, value)
-
-    def to_uppercase(self) -> str:
-        """Convert a ``RomanNumeral`` to an uppercase string.
-
-        >>> answer = RomanNumeral(42)
-        >>> assert answer.to_uppercase() == 'XLII'
-        """
-        out: list[str] = []
-        n = self._value
-        for value, name, _ in _ROMAN_NUMERAL_PREFIXES:
-            while n >= value:
-                n -= value
-                out.append(name)
-        return ''.join(out)
-
-    def to_lowercase(self) -> str:
-        """Convert a ``RomanNumeral`` to a lowercase string.
-
-        >>> answer = RomanNumeral(42)
-        >>> assert answer.to_lowercase() == 'xlii'
-        """
-        out: list[str] = []
-        n = self._value
-        for value, _, name in _ROMAN_NUMERAL_PREFIXES:
-            while n >= value:
-                n -= value
-                out.append(name)
-        return ''.join(out)
-
-    @classmethod
-    def from_string(cls, string: str, /) -> Self:
-        """Create a ``RomanNumeral`` from a well-formed string representation.
-
-        Returns ``RomanNumeral`` or raises ``InvalidRomanNumeralError``.
-
-        >>> answer = RomanNumeral.from_string('XLII')
-        >>> assert int(answer) == 42
-        """
-        # Not an empty string.
-        if not string or not isinstance(string, str):
-            raise InvalidRomanNumeralError(string)
-
-        # ASCII-only uppercase string.
-        if string.isascii() and string.isupper():
-            chars = string.encode('ascii')
-        elif string.isascii() and string.islower():
-            chars = string.upper().encode('ascii')
-        else:
-            # Either Non-ASCII or mixed-case ASCII.
-            raise InvalidRomanNumeralError(string)
-
-        # ASCII-only uppercase string only containing I, V, X, L, C, D, M.
-        if not frozenset(b'IVXLCDM').issuperset(chars):
-            raise InvalidRomanNumeralError(string)
-
-        result: int = 0
-        idx: int = 0
-
-        # Thousands: between 0 and 4 "M" characters at the start
-        for _ in range(4):
-            if chars[idx:idx + 1] == b'M':
-                result += 1000
-                idx += 1
-            else:
-                break
-        if len(chars) == idx:
-            return cls(result)
-
-        # Hundreds: 900 ("CM"), 400 ("CD"), 0-300 (0 to 3 "C" chars),
-        # or 500-800 ("D", followed by 0 to 3 "C" chars)
-        if chars[idx:idx + 2] == b'CM':
-            result += 900
-            idx += 2
-        elif chars[idx:idx + 2] == b'CD':
-            result += 400
-            idx += 2
-        else:
-            if chars[idx:idx + 1] == b'D':
-                result += 500
-                idx += 1
-            for _ in range(3):
-                if chars[idx:idx + 1] == b'C':
-                    result += 100
-                    idx += 1
-                else:
-                    break
-        if len(chars) == idx:
-            return cls(result)
-
-        # Tens: 90 ("XC"), 40 ("XL"), 0-30 (0 to 3 "X" chars),
-        # or 50-80 ("L", followed by 0 to 3 "X" chars)
-        if chars[idx:idx + 2] == b'XC':
-            result += 90
-            idx += 2
-        elif chars[idx:idx + 2] == b'XL':
-            result += 40
-            idx += 2
-        else:
-            if chars[idx:idx + 1] == b'L':
-                result += 50
-                idx += 1
-            for _ in range(3):
-                if chars[idx:idx + 1] == b'X':
-                    result += 10
-                    idx += 1
-                else:
-                    break
-        if len(chars) == idx:
-            return cls(result)
-
-        # Ones: 9 ("IX"), 4 ("IV"), 0-3 (0 to 3 "I" chars),
-        # or 5-8 ("V", followed by 0 to 3 "I" chars)
-        if chars[idx:idx + 2] == b'IX':
-            result += 9
-            idx += 2
-        elif chars[idx:idx + 2] == b'IV':
-            result += 4
-            idx += 2
-        else:
-            if chars[idx:idx + 1] == b'V':
-                result += 5
-                idx += 1
-            for _ in range(3):
-                if chars[idx:idx + 1] == b'I':
-                    result += 1
-                    idx += 1
-                else:
-                    break
-        if len(chars) == idx:
-            return cls(result)
-        raise InvalidRomanNumeralError(string)
-
-
-_ROMAN_NUMERAL_PREFIXES: Final = [
-    (1000, sys.intern('M'), sys.intern('m')),
-    (900, sys.intern('CM'), sys.intern('cm')),
-    (500, sys.intern('D'), sys.intern('d')),
-    (400, sys.intern('CD'), sys.intern('cd')),
-    (100, sys.intern('C'), sys.intern('c')),
-    (90, sys.intern('XC'), sys.intern('xc')),
-    (50, sys.intern('L'), sys.intern('l')),
-    (40, sys.intern('XL'), sys.intern('xl')),
-    (10, sys.intern('X'), sys.intern('x')),
-    (9, sys.intern('IX'), sys.intern('ix')),
-    (5, sys.intern('V'), sys.intern('v')),
-    (4, sys.intern('IV'), sys.intern('iv')),
-    (1, sys.intern('I'), sys.intern('i')),
-]
-"""Numeral value, uppercase character, and lowercase character."""

venv/Lib/site-packages/docutils/utils/_typing.py

@@ -1,39 +0,0 @@
-# Copyright: This module has been placed in the public domain.
-# Author: Adam Turner
-
-"""Private helpers for the ``typing`` module."""
-
-from __future__ import annotations
-
-TYPE_CHECKING = False
-if TYPE_CHECKING:
-    import sys
-    from collections.abc import Callable
-    from typing import Any, Final, TypeVar, final, overload
-
-    if sys.version_info[:2] >= (3, 11):
-        from typing import Self
-    else:
-        from typing_extensions import Self  # NoQA: F401
-
-    if sys.version_info[:2] >= (3, 12):
-        from typing import TypeAlias
-    else:
-        from typing_extensions import TypeAlias  # NoQA: F401
-
-    _F = TypeVar("_F", bound=Callable[..., Any])
-    _T = TypeVar('_T')
-else:
-
-    # Runtime replacement for ``typing.final``.
-    def final(f: _T) -> _T:
-        return f
-
-    def _overload_inner(*args, **kwds):
-        raise NotImplementedError
-
-    # Runtime replacement for ``typing.overload``.
-    def overload(func: _F) -> _F:
-        return _overload_inner
-
-__all__: Final = ('final', 'overload')

venv/Lib/site-packages/docutils/utils/code_analyzer.py

@@ -1,140 +0,0 @@
-# :Author: Georg Brandl; Lea Wiemann; Günter Milde
-# :Date: $Date: 2025-05-20 17:48:27 +0200 (Di, 20. Mai 2025) $
-# :Copyright: This module has been placed in the public domain.
-
-"""Lexical analysis of formal languages (i.e. code) using Pygments."""
-
-from __future__ import annotations
-
-__docformat__ = 'reStructuredText'
-
-try:
-    import pygments
-    from pygments.lexers import get_lexer_by_name
-    from pygments.formatters.html import _get_ttype_class
-    with_pygments = True
-except ImportError:
-    with_pygments = False
-
-from docutils import ApplicationError
-
-# Filter the following token types from the list of class arguments:
-unstyled_tokens = ['token',  # Token (base token type)
-                   'text',   # Token.Text
-                   '']       # short name for Token and Text
-# (Add, e.g., Token.Punctuation with ``unstyled_tokens += 'punctuation'``.)
-
-
-class LexerError(ApplicationError):
-    pass
-
-
-class Lexer:
-    """Parse `code` lines and yield "classified" tokens.
-
-    Arguments
-
-      code       -- string of source code to parse,
-      language   -- formal language the code is written in,
-      tokennames -- either 'long', 'short', or 'none' (see below).
-
-    Merge subsequent tokens of the same token-type.
-
-    Iterating over an instance yields the tokens as ``(tokentype, value)``
-    tuples. The value of `tokennames` configures the naming of the tokentype:
-
-      'long':  downcased full token type name,
-      'short': short name defined by pygments.token.STANDARD_TYPES
-               (= class argument used in pygments html output),
-      'none':  skip lexical analysis.
-    """
-
-    def __init__(self, code, language, tokennames='short') -> None:
-        """
-        Set up a lexical analyzer for `code` in `language`.
-        """
-        self.code = code
-        self.language = language
-        self.tokennames = tokennames
-        self.lexer = None
-        # get lexical analyzer for `language`:
-        if language in ('', 'text') or tokennames == 'none':
-            return
-        if not with_pygments:
-            raise LexerError('Cannot analyze code. '
-                             'Pygments package not found.')
-        try:
-            self.lexer = get_lexer_by_name(self.language)
-        except pygments.util.ClassNotFound:
-            raise LexerError('Cannot analyze code. '
-                             'No Pygments lexer found for "%s".' % language)
-        # self.lexer.add_filter('tokenmerge')
-        # Since version 1.2. (released Jan 01, 2010) Pygments has a
-        # TokenMergeFilter. # ``self.merge(tokens)`` in __iter__ could
-        # be replaced by ``self.lexer.add_filter('tokenmerge')`` in __init__.
-        # However, `merge` below also strips a final newline added by pygments.
-        #
-        # self.lexer.add_filter('tokenmerge')
-
-    def merge(self, tokens):
-        """Merge subsequent tokens of same token-type.
-
-           Also strip the final newline (added by pygments).
-        """
-        tokens = iter(tokens)
-        (lasttype, lastval) = next(tokens)
-        for ttype, value in tokens:
-            if ttype is lasttype:
-                lastval += value
-            else:
-                yield lasttype, lastval
-                (lasttype, lastval) = (ttype, value)
-        lastval = lastval.removesuffix('\n')
-        if lastval:
-            yield lasttype, lastval
-
-    def __iter__(self):
-        """Parse self.code and yield "classified" tokens.
-        """
-        if self.lexer is None:
-            yield [], self.code
-            return
-        tokens = pygments.lex(self.code, self.lexer)
-        for tokentype, value in self.merge(tokens):
-            if self.tokennames == 'long':  # long CSS class args
-                classes = str(tokentype).lower().split('.')
-            else:  # short CSS class args
-                classes = [_get_ttype_class(tokentype)]
-            classes = [cls for cls in classes if cls not in unstyled_tokens]
-            yield classes, value
-
-
-class NumberLines:
-    """Insert linenumber-tokens at the start of every code line.
-
-    Arguments
-
-       tokens    -- iterable of ``(classes, value)`` tuples
-       startline -- first line number
-       endline   -- last line number
-
-    Iterating over an instance yields the tokens with a
-    ``(['ln'], '<the line number>')`` token added for every code line.
-    Multi-line tokens are split."""
-
-    def __init__(self, tokens, startline, endline) -> None:
-        self.tokens = tokens
-        self.startline = startline
-        # pad linenumbers, e.g. endline == 100 -> fmt_str = '%3d '
-        self.fmt_str = f'%{len(str(endline))}d '
-
-    def __iter__(self):
-        lineno = self.startline
-        yield ['ln'], self.fmt_str % lineno
-        for ttype, value in self.tokens:
-            lines = value.split('\n')
-            for line in lines[:-1]:
-                yield ttype, line + '\n'
-                lineno += 1
-                yield ['ln'], self.fmt_str % lineno
-            yield ttype, lines[-1]

venv/Lib/site-packages/docutils/utils/math/__init__.py

@@ -1,77 +0,0 @@
-# :Id: $Id: __init__.py 10136 2025-05-20 15:48:27Z milde $
-# :Author: Guenter Milde.
-# :License: Released under the terms of the `2-Clause BSD license`_, in short:
-#
-#    Copying and distribution of this file, with or without modification,
-#    are permitted in any medium without royalty provided the copyright
-#    notice and this notice are preserved.
-#    This file is offered as-is, without any warranty.
-#
-# .. _2-Clause BSD license: https://opensource.org/licenses/BSD-2-Clause
-
-"""
-This is the Docutils (Python Documentation Utilities) "math" sub-package.
-
-It contains various modules for conversion between different math formats
-(LaTeX, MathML, HTML).
-
-:math2html:    LaTeX math -> HTML conversion from eLyXer
-:latex2mathml: LaTeX math -> presentational MathML
-:unichar2tex:  Unicode character to LaTeX math translation table
-:tex2unichar:  LaTeX math to Unicode character translation dictionaries
-:mathalphabet2unichar:  LaTeX math alphabets to Unicode character translation
-:tex2mathml_extern: Wrapper for 3rd party TeX -> MathML converters
-"""
-
-from __future__ import annotations
-
-__docformat__ = 'reStructuredText'
-
-# helpers for Docutils math support
-# =================================
-
-
-class MathError(ValueError):
-    """Exception for math syntax and math conversion errors.
-
-    The additional attribute `details` may hold a list of Docutils
-    nodes suitable as children for a ``<system_message>``.
-    """
-    def __init__(self, msg, details=[]) -> None:
-        super().__init__(msg)
-        self.details = details
-
-
-def toplevel_code(code):
-    """Return string (LaTeX math) `code` with environments stripped out."""
-    chunks = code.split(r'\begin{')
-    return r'\begin{'.join(chunk.split(r'\end{')[-1]
-                           for chunk in chunks)
-
-
-def pick_math_environment(code, numbered=False):
-    """Return the right math environment to display `code`.
-
-    The test simply looks for line-breaks (``\\``) outside environments.
-    Multi-line formulae are set with ``align``, one-liners with
-    ``equation``.
-
-    If `numbered` evaluates to ``False``, the "starred" versions are used
-    to suppress numbering.
-    """
-    if toplevel_code(code).find(r'\\') >= 0:
-        env = 'align'
-    else:
-        env = 'equation'
-    if not numbered:
-        env += '*'
-    return env
-
-
-def wrap_math_code(code, as_block) -> str:
-    # Wrap math-code in mode-switching TeX command/environment.
-    # If `as_block` is True, use environment for displayed equation(s).
-    if as_block:
-        env = pick_math_environment(code)
-        return '\\begin{%s}\n%s\n\\end{%s}' % (env, code, env)
-    return '$%s$' % code