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

venv/Lib/site-packages/pygments/lexers/algebra.py

@@ -1,299 +0,0 @@
-"""
-    pygments.lexers.algebra
-    ~~~~~~~~~~~~~~~~~~~~~~~
-
-    Lexers for computer algebra systems.
-
-    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-import re
-
-from pygments.lexer import Lexer, RegexLexer, bygroups, do_insertions, words
-from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
-    Number, Punctuation, Generic, Whitespace
-
-__all__ = ['GAPLexer', 'GAPConsoleLexer', 'MathematicaLexer', 'MuPADLexer',
-           'BCLexer']
-
-
-class GAPLexer(RegexLexer):
-    """
-    For GAP source code.
-    """
-    name = 'GAP'
-    url = 'https://www.gap-system.org'
-    aliases = ['gap']
-    filenames = ['*.g', '*.gd', '*.gi', '*.gap']
-    version_added = '2.0'
-
-    tokens = {
-        'root': [
-            (r'#.*$', Comment.Single),
-            (r'"(?:[^"\\]|\\.)*"', String),
-            (r'\(|\)|\[|\]|\{|\}', Punctuation),
-            (r'''(?x)\b(?:
-                if|then|elif|else|fi|
-                for|while|do|od|
-                repeat|until|
-                break|continue|
-                function|local|return|end|
-                rec|
-                quit|QUIT|
-                IsBound|Unbind|
-                TryNextMethod|
-                Info|Assert
-              )\b''', Keyword),
-            (r'''(?x)\b(?:
-                true|false|fail|infinity
-              )\b''',
-             Name.Constant),
-            (r'''(?x)\b(?:
-                (Declare|Install)([A-Z][A-Za-z]+)|
-                   BindGlobal|BIND_GLOBAL
-              )\b''',
-             Name.Builtin),
-            (r'\.|,|:=|;|=|\+|-|\*|/|\^|>|<', Operator),
-            (r'''(?x)\b(?:
-                and|or|not|mod|in
-              )\b''',
-             Operator.Word),
-            (r'''(?x)
-              (?:\w+|`[^`]*`)
-              (?:::\w+|`[^`]*`)*''', Name.Variable),
-            (r'[0-9]+(?:\.[0-9]*)?(?:e[0-9]+)?', Number),
-            (r'\.[0-9]+(?:e[0-9]+)?', Number),
-            (r'.', Text)
-        ],
-    }
-
-    def analyse_text(text):
-        score = 0.0
-
-        # Declaration part
-        if re.search(
-            r"(InstallTrueMethod|Declare(Attribute|Category|Filter|Operation" +
-            r"|GlobalFunction|Synonym|SynonymAttr|Property))", text
-        ):
-            score += 0.7
-
-        # Implementation part
-        if re.search(
-            r"(DeclareRepresentation|Install(GlobalFunction|Method|" +
-            r"ImmediateMethod|OtherMethod)|New(Family|Type)|Objectify)", text
-        ):
-            score += 0.7
-
-        return min(score, 1.0)
-
-
-class GAPConsoleLexer(Lexer):
-    """
-    For GAP console sessions. Modeled after JuliaConsoleLexer.
-    """
-    name = 'GAP session'
-    aliases = ['gap-console', 'gap-repl']
-    filenames = ['*.tst']
-    url = 'https://www.gap-system.org'
-    version_added = '2.14'
-    _example = "gap-repl/euclidean.tst"
-
-    def get_tokens_unprocessed(self, text):
-        gaplexer = GAPLexer(**self.options)
-        start = 0
-        curcode = ''
-        insertions = []
-        output = False
-        error = False
-
-        for line in text.splitlines(keepends=True):
-            if line.startswith('gap> ') or line.startswith('brk> '):
-                insertions.append((len(curcode), [(0, Generic.Prompt, line[:5])]))
-                curcode += line[5:]
-                output = False
-                error = False
-            elif not output and line.startswith('> '):
-                insertions.append((len(curcode), [(0, Generic.Prompt, line[:2])]))
-                curcode += line[2:]
-            else:
-                if curcode:
-                    yield from do_insertions(
-                        insertions, gaplexer.get_tokens_unprocessed(curcode))
-                    curcode = ''
-                    insertions = []
-                if line.startswith('Error, ') or error:
-                    yield start, Generic.Error, line
-                    error = True
-                else:
-                    yield start, Generic.Output, line
-                output = True
-            start += len(line)
-
-        if curcode:
-            yield from do_insertions(
-                insertions, gaplexer.get_tokens_unprocessed(curcode))
-
-    # the following is needed to distinguish Scilab and GAP .tst files
-    def analyse_text(text):
-        # GAP prompts are a dead give away, although hypothetical;y a
-        # file in another language could be trying to compare a variable
-        # "gap" as in "gap> 0.1". But that this should happen at the
-        # start of a line seems unlikely...
-        if re.search(r"^gap> ", text):
-            return 0.9
-        else:
-            return 0.0
-
-
-class MathematicaLexer(RegexLexer):
-    """
-    Lexer for Mathematica source code.
-    """
-    name = 'Mathematica'
-    url = 'http://www.wolfram.com/mathematica/'
-    aliases = ['mathematica', 'mma', 'nb']
-    filenames = ['*.nb', '*.cdf', '*.nbp', '*.ma']
-    mimetypes = ['application/mathematica',
-                 'application/vnd.wolfram.mathematica',
-                 'application/vnd.wolfram.mathematica.package',
-                 'application/vnd.wolfram.cdf']
-    version_added = '2.0'
-
-    # http://reference.wolfram.com/mathematica/guide/Syntax.html
-    operators = (
-        ";;", "=", "=.", "!=" "==", ":=", "->", ":>", "/.", "+", "-", "*", "/",
-        "^", "&&", "||", "!", "<>", "|", "/;", "?", "@", "//", "/@", "@@",
-        "@@@", "~~", "===", "&", "<", ">", "<=", ">=",
-    )
-
-    punctuation = (",", ";", "(", ")", "[", "]", "{", "}")
-
-    def _multi_escape(entries):
-        return '({})'.format('|'.join(re.escape(entry) for entry in entries))
-
-    tokens = {
-        'root': [
-            (r'(?s)\(\*.*?\*\)', Comment),
-
-            (r'([a-zA-Z]+[A-Za-z0-9]*`)', Name.Namespace),
-            (r'([A-Za-z0-9]*_+[A-Za-z0-9]*)', Name.Variable),
-            (r'#\d*', Name.Variable),
-            (r'([a-zA-Z]+[a-zA-Z0-9]*)', Name),
-
-            (r'-?\d+\.\d*', Number.Float),
-            (r'-?\d*\.\d+', Number.Float),
-            (r'-?\d+', Number.Integer),
-
-            (words(operators), Operator),
-            (words(punctuation), Punctuation),
-            (r'".*?"', String),
-            (r'\s+', Text.Whitespace),
-        ],
-    }
-
-
-class MuPADLexer(RegexLexer):
-    """
-    A MuPAD lexer.
-    Contributed by Christopher Creutzig <christopher@creutzig.de>.
-    """
-    name = 'MuPAD'
-    url = 'http://www.mupad.com'
-    aliases = ['mupad']
-    filenames = ['*.mu']
-    version_added = '0.8'
-
-    tokens = {
-        'root': [
-            (r'//.*?$', Comment.Single),
-            (r'/\*', Comment.Multiline, 'comment'),
-            (r'"(?:[^"\\]|\\.)*"', String),
-            (r'\(|\)|\[|\]|\{|\}', Punctuation),
-            (r'''(?x)\b(?:
-                next|break|end|
-                axiom|end_axiom|category|end_category|domain|end_domain|inherits|
-                if|%if|then|elif|else|end_if|
-                case|of|do|otherwise|end_case|
-                while|end_while|
-                repeat|until|end_repeat|
-                for|from|to|downto|step|end_for|
-                proc|local|option|save|begin|end_proc|
-                delete|frame
-              )\b''', Keyword),
-            (r'''(?x)\b(?:
-                DOM_ARRAY|DOM_BOOL|DOM_COMPLEX|DOM_DOMAIN|DOM_EXEC|DOM_EXPR|
-                DOM_FAIL|DOM_FLOAT|DOM_FRAME|DOM_FUNC_ENV|DOM_HFARRAY|DOM_IDENT|
-                DOM_INT|DOM_INTERVAL|DOM_LIST|DOM_NIL|DOM_NULL|DOM_POLY|DOM_PROC|
-                DOM_PROC_ENV|DOM_RAT|DOM_SET|DOM_STRING|DOM_TABLE|DOM_VAR
-              )\b''', Name.Class),
-            (r'''(?x)\b(?:
-                PI|EULER|E|CATALAN|
-                NIL|FAIL|undefined|infinity|
-                TRUE|FALSE|UNKNOWN
-              )\b''',
-             Name.Constant),
-            (r'\b(?:dom|procname)\b', Name.Builtin.Pseudo),
-            (r'\.|,|:|;|=|\+|-|\*|/|\^|@|>|<|\$|\||!|\'|%|~=', Operator),
-            (r'''(?x)\b(?:
-                and|or|not|xor|
-                assuming|
-                div|mod|
-                union|minus|intersect|in|subset
-              )\b''',
-             Operator.Word),
-            (r'\b(?:I|RDN_INF|RD_NINF|RD_NAN)\b', Number),
-            # (r'\b(?:adt|linalg|newDomain|hold)\b', Name.Builtin),
-            (r'''(?x)
-              ((?:[a-zA-Z_#][\w#]*|`[^`]*`)
-              (?:::[a-zA-Z_#][\w#]*|`[^`]*`)*)(\s*)([(])''',
-             bygroups(Name.Function, Text, Punctuation)),
-            (r'''(?x)
-              (?:[a-zA-Z_#][\w#]*|`[^`]*`)
-              (?:::[a-zA-Z_#][\w#]*|`[^`]*`)*''', Name.Variable),
-            (r'[0-9]+(?:\.[0-9]*)?(?:e[0-9]+)?', Number),
-            (r'\.[0-9]+(?:e[0-9]+)?', Number),
-            (r'\s+', Whitespace),
-            (r'.', Text)
-        ],
-        'comment': [
-            (r'[^/*]+', Comment.Multiline),
-            (r'/\*', Comment.Multiline, '#push'),
-            (r'\*/', Comment.Multiline, '#pop'),
-            (r'[*/]', Comment.Multiline)
-        ],
-    }
-
-
-class BCLexer(RegexLexer):
-    """
-    A BC lexer.
-    """
-    name = 'BC'
-    url = 'https://www.gnu.org/software/bc/'
-    aliases = ['bc']
-    filenames = ['*.bc']
-    version_added = '2.1'
-
-    tokens = {
-        'root': [
-            (r'/\*', Comment.Multiline, 'comment'),
-            (r'"(?:[^"\\]|\\.)*"', String),
-            (r'[{}();,]', Punctuation),
-            (words(('if', 'else', 'while', 'for', 'break', 'continue',
-                    'halt', 'return', 'define', 'auto', 'print', 'read',
-                    'length', 'scale', 'sqrt', 'limits', 'quit',
-                    'warranty'), suffix=r'\b'), Keyword),
-            (r'\+\+|--|\|\||&&|'
-             r'([-<>+*%\^/!=])=?', Operator),
-            # bc doesn't support exponential
-            (r'[0-9]+(\.[0-9]*)?', Number),
-            (r'\.[0-9]+', Number),
-            (r'.', Text)
-        ],
-        'comment': [
-            (r'[^*/]+', Comment.Multiline),
-            (r'\*/', Comment.Multiline, '#pop'),
-            (r'[*/]', Comment.Multiline)
-        ],
-    }

venv/Lib/site-packages/pygments/lexers/ambient.py

@@ -1,75 +0,0 @@
-"""
-    pygments.lexers.ambient
-    ~~~~~~~~~~~~~~~~~~~~~~~
-
-    Lexers for AmbientTalk language.
-
-    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-import re
-
-from pygments.lexer import RegexLexer, include, words, bygroups
-from pygments.token import Comment, Operator, Keyword, Name, String, \
-    Number, Punctuation, Whitespace
-
-__all__ = ['AmbientTalkLexer']
-
-
-class AmbientTalkLexer(RegexLexer):
-    """
-    Lexer for AmbientTalk source code.
-    """
-    name = 'AmbientTalk'
-    url = 'https://code.google.com/p/ambienttalk'
-    filenames = ['*.at']
-    aliases = ['ambienttalk', 'ambienttalk/2', 'at']
-    mimetypes = ['text/x-ambienttalk']
-    version_added = '2.0'
-
-    flags = re.MULTILINE | re.DOTALL
-
-    builtin = words(('if:', 'then:', 'else:', 'when:', 'whenever:', 'discovered:',
-                     'disconnected:', 'reconnected:', 'takenOffline:', 'becomes:',
-                     'export:', 'as:', 'object:', 'actor:', 'mirror:', 'taggedAs:',
-                     'mirroredBy:', 'is:'))
-    tokens = {
-        'root': [
-            (r'\s+', Whitespace),
-            (r'//.*?\n', Comment.Single),
-            (r'/\*.*?\*/', Comment.Multiline),
-            (r'(def|deftype|import|alias|exclude)\b', Keyword),
-            (builtin, Name.Builtin),
-            (r'(true|false|nil)\b', Keyword.Constant),
-            (r'(~|lobby|jlobby|/)\.', Keyword.Constant, 'namespace'),
-            (r'"(\\\\|\\[^\\]|[^"\\])*"', String),
-            (r'\|', Punctuation, 'arglist'),
-            (r'<:|[*^!%&<>+=,./?-]|:=', Operator),
-            (r"`[a-zA-Z_]\w*", String.Symbol),
-            (r"[a-zA-Z_]\w*:", Name.Function),
-            (r"[{}()\[\];`]", Punctuation),
-            (r'(self|super)\b', Name.Variable.Instance),
-            (r"[a-zA-Z_]\w*", Name.Variable),
-            (r"@[a-zA-Z_]\w*", Name.Class),
-            (r"@\[", Name.Class, 'annotations'),
-            include('numbers'),
-        ],
-        'numbers': [
-            (r'(\d+\.\d*|\d*\.\d+)([eE][+-]?[0-9]+)?', Number.Float),
-            (r'\d+', Number.Integer)
-        ],
-        'namespace': [
-            (r'[a-zA-Z_]\w*\.', Name.Namespace),
-            (r'[a-zA-Z_]\w*:', Name.Function, '#pop'),
-            (r'[a-zA-Z_]\w*(?!\.)', Name.Function, '#pop')
-        ],
-        'annotations': [
-            (r"(.*?)\]", Name.Class, '#pop')
-        ],
-        'arglist': [
-            (r'\|', Punctuation, '#pop'),
-            (r'(\s*)(,)(\s*)', bygroups(Whitespace, Punctuation, Whitespace)),
-            (r'[a-zA-Z_]\w*', Name.Variable),
-        ],
-    }

venv/Lib/site-packages/pygments/lexers/amdgpu.py

@@ -1,54 +0,0 @@
-"""
-    pygments.lexers.amdgpu
-    ~~~~~~~~~~~~~~~~~~~~~~
-
-    Lexers for the AMDGPU ISA assembly.
-
-    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-from pygments.lexer import RegexLexer, words
-from pygments.token import Name, Text, Keyword, Whitespace, Number, Comment
-
-import re
-
-__all__ = ['AMDGPULexer']
-
-
-class AMDGPULexer(RegexLexer):
-    """
-    For AMD GPU assembly.
-    """
-    name = 'AMDGPU'
-    aliases = ['amdgpu']
-    filenames = ['*.isa']
-    url = 'https://gpuopen.com/amd-isa-documentation'
-    version_added = '2.8'
-
-    flags = re.IGNORECASE
-
-    tokens = {
-        'root': [
-            (r'\s+', Whitespace),
-            (r'[\r\n]+', Text),
-            (r'(([a-z_0-9])*:([a-z_0-9])*)', Name.Attribute),
-            (r'(\[|\]|\(|\)|,|\:|\&)', Text),
-            (r'([;#]|//).*?\n', Comment.Single),
-            (r'((s_)?(scratch|ds|buffer|flat|image)_[a-z0-9_]+)', Keyword.Reserved),
-            (r'(_lo|_hi)', Name.Variable),
-            (r'(vmcnt|lgkmcnt|expcnt)', Name.Attribute),
-            (r'(attr[0-9].[a-z])', Name.Attribute),
-            (words((
-                'op', 'vaddr', 'vdata', 'off', 'soffset', 'srsrc', 'format',
-                'offset', 'offen', 'idxen', 'glc', 'dlc', 'slc', 'tfe', 'lds',
-                'lit', 'unorm'), suffix=r'\b'), Name.Attribute),
-            (r'(label_[a-z0-9]+)', Keyword),
-            (r'(_L[0-9]*)', Name.Variable),
-            (r'(s|v)_[a-z0-9_]+', Keyword),
-            (r'(v[0-9.]+|vcc|exec|v)', Name.Variable),
-            (r's[0-9.]+|s', Name.Variable),
-            (r'[0-9]+\.[^0-9]+', Number.Float),
-            (r'(0[xX][a-z0-9]+)|([0-9]+)', Number.Integer)
-        ]
-    }

venv/Lib/site-packages/pygments/lexers/ampl.py

@@ -1,87 +0,0 @@
-"""
-    pygments.lexers.ampl
-    ~~~~~~~~~~~~~~~~~~~~
-
-    Lexers for the AMPL language.
-
-    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-from pygments.lexer import RegexLexer, bygroups, using, this, words
-from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
-    Number, Punctuation, Whitespace
-
-__all__ = ['AmplLexer']
-
-
-class AmplLexer(RegexLexer):
-    """
-    For AMPL source code.
-    """
-    name = 'Ampl'
-    url = 'http://ampl.com/'
-    aliases = ['ampl']
-    filenames = ['*.run']
-    version_added = '2.2'
-
-    tokens = {
-        'root': [
-            (r'\n', Text),
-            (r'\s+', Whitespace),
-            (r'#.*?\n', Comment.Single),
-            (r'/[*](.|\n)*?[*]/', Comment.Multiline),
-            (words((
-                'call', 'cd', 'close', 'commands', 'data', 'delete', 'display',
-                'drop', 'end', 'environ', 'exit', 'expand', 'include', 'load',
-                'model', 'objective', 'option', 'problem', 'purge', 'quit',
-                'redeclare', 'reload', 'remove', 'reset', 'restore', 'shell',
-                'show', 'solexpand', 'solution', 'solve', 'update', 'unload',
-                'xref', 'coeff', 'coef', 'cover', 'obj', 'interval', 'default',
-                'from', 'to', 'to_come', 'net_in', 'net_out', 'dimen',
-                'dimension', 'check', 'complements', 'write', 'function',
-                'pipe', 'format', 'if', 'then', 'else', 'in', 'while', 'repeat',
-                'for'), suffix=r'\b'), Keyword.Reserved),
-            (r'(integer|binary|symbolic|ordered|circular|reversed|INOUT|IN|OUT|LOCAL)',
-             Keyword.Type),
-            (r'\".*?\"', String.Double),
-            (r'\'.*?\'', String.Single),
-            (r'[()\[\]{},;:]+', Punctuation),
-            (r'\b(\w+)(\.)(astatus|init0|init|lb0|lb1|lb2|lb|lrc|'
-             r'lslack|rc|relax|slack|sstatus|status|ub0|ub1|ub2|'
-             r'ub|urc|uslack|val)',
-             bygroups(Name.Variable, Punctuation, Keyword.Reserved)),
-            (r'(set|param|var|arc|minimize|maximize|subject to|s\.t\.|subj to|'
-             r'node|table|suffix|read table|write table)(\s+)(\w+)',
-             bygroups(Keyword.Declaration, Whitespace, Name.Variable)),
-            (r'(param)(\s*)(:)(\s*)(\w+)(\s*)(:)(\s*)((\w|\s)+)',
-             bygroups(Keyword.Declaration, Whitespace, Punctuation, Whitespace,
-                      Name.Variable, Whitespace, Punctuation, Whitespace, Name.Variable)),
-            (r'(let|fix|unfix)(\s*)((?:\{.*\})?)(\s*)(\w+)',
-             bygroups(Keyword.Declaration, Whitespace, using(this), Whitespace,
-                      Name.Variable)),
-            (words((
-                'abs', 'acos', 'acosh', 'alias', 'asin', 'asinh', 'atan', 'atan2',
-                'atanh', 'ceil', 'ctime', 'cos', 'exp', 'floor', 'log', 'log10',
-                'max', 'min', 'precision', 'round', 'sin', 'sinh', 'sqrt', 'tan',
-                'tanh', 'time', 'trunc', 'Beta', 'Cauchy', 'Exponential', 'Gamma',
-                'Irand224', 'Normal', 'Normal01', 'Poisson', 'Uniform', 'Uniform01',
-                'num', 'num0', 'ichar', 'char', 'length', 'substr', 'sprintf',
-                'match', 'sub', 'gsub', 'print', 'printf', 'next', 'nextw', 'prev',
-                'prevw', 'first', 'last', 'ord', 'ord0', 'card', 'arity',
-                'indexarity'), prefix=r'\b', suffix=r'\b'), Name.Builtin),
-            (r'(\+|\-|\*|/|\*\*|=|<=|>=|==|\||\^|<|>|\!|\.\.|:=|\&|\!=|<<|>>)',
-             Operator),
-            (words((
-                'or', 'exists', 'forall', 'and', 'in', 'not', 'within', 'union',
-                'diff', 'difference', 'symdiff', 'inter', 'intersect',
-                'intersection', 'cross', 'setof', 'by', 'less', 'sum', 'prod',
-                'product', 'div', 'mod'), suffix=r'\b'),
-             Keyword.Reserved),  # Operator.Name but not enough emphasized with that
-            (r'(\d+\.(?!\.)\d*|\.(?!.)\d+)([eE][+-]?\d+)?', Number.Float),
-            (r'\d+([eE][+-]?\d+)?', Number.Integer),
-            (r'[+-]?Infinity', Number.Integer),
-            (r'(\w+|(\.(?!\.)))', Text)
-        ]
-
-    }