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

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

@@ -0,0 +1,176 @@
+"""
+    pygments.lexers.graphql
+    ~~~~~~~~~~~~~~~~~~~~~~~
+
+    Lexer for GraphQL, an open-source data query and manipulation
+    language for APIs.
+
+    More information:
+    https://graphql.org/
+
+    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.lexer import RegexLexer, words, include, bygroups, default
+from pygments.token import (Comment, Keyword, Name, Number, Punctuation, String,
+                            Whitespace)
+
+
+__all__ = ["GraphQLLexer"]
+
+OPERATION_TYPES = ("query", "mutation", "subscription")
+BUILTIN_TYPES = ("Int", "Float", "String", "Boolean", "ID")
+BOOLEAN_VALUES = ("true", "false", "null")
+KEYWORDS = (
+    "type",
+    "schema",
+    "extend",
+    "enum",
+    "scalar",
+    "implements",
+    "interface",
+    "union",
+    "input",
+    "directive",
+    "QUERY",
+    "MUTATION",
+    "SUBSCRIPTION",
+    "FIELD",
+    "FRAGMENT_DEFINITION",
+    "FRAGMENT_SPREAD",
+    "INLINE_FRAGMENT",
+    "SCHEMA",
+    "SCALAR",
+    "OBJECT",
+    "FIELD_DEFINITION",
+    "ARGUMENT_DEFINITION",
+    "INTERFACE",
+    "UNION",
+    "ENUM",
+    "ENUM_VALUE",
+    "INPUT_OBJECT",
+    "INPUT_FIELD_DEFINITION",
+)
+
+
+class GraphQLLexer(RegexLexer):
+    """
+    Lexer for GraphQL syntax
+    """
+    name = "GraphQL"
+    aliases = ["graphql"]
+    filenames = ["*.graphql"]
+    url = "https://graphql.org"
+    version_added = '2.16'
+
+    tokens = {
+        "ignored_tokens": [
+            (r"\s+", Whitespace),  # Whitespaces
+            (r"#.*$", Comment),
+            (",", Punctuation),  # Insignificant commas
+        ],
+        "value": [
+            include("ignored_tokens"),
+            (r"-?\d+(?![.eE])", Number.Integer, "#pop"),
+            (
+                r"-?\d+(\.\d+)?([eE][+-]?\d+)?",
+                Number.Float,
+                "#pop",
+            ),
+            (r'"', String, ("#pop", "string")),
+            (words(BOOLEAN_VALUES, suffix=r"\b"), Name.Builtin, "#pop"),
+            (r"\$[a-zA-Z_]\w*", Name.Variable, "#pop"),
+            (r"[a-zA-Z_]\w*", Name.Constant, "#pop"),
+            (r"\[", Punctuation, ("#pop", "list_value")),
+            (r"\{", Punctuation, ("#pop", "object_value")),
+        ],
+        "list_value": [
+            include("ignored_tokens"),
+            ("]", Punctuation, "#pop"),
+            default("value"),
+        ],
+        "object_value": [
+            include("ignored_tokens"),
+            (r"[a-zA-Z_]\w*", Name),
+            (r":", Punctuation, "value"),
+            (r"\}", Punctuation, "#pop"),
+        ],
+        "string": [
+            (r'\\(["\\/bfnrt]|u[a-fA-F0-9]{4})', String.Escape),
+            (r'[^\\"\n]+', String),  # all other characters
+            (r'"', String, "#pop"),
+        ],
+        "root": [
+            include("ignored_tokens"),
+            (words(OPERATION_TYPES, suffix=r"\b"), Keyword, "operation"),
+            (words(KEYWORDS, suffix=r"\b"), Keyword),
+            (r"\{", Punctuation, "selection_set"),
+            (r"fragment\b", Keyword, "fragment_definition"),
+        ],
+        "operation": [
+            include("ignored_tokens"),
+            (r"[a-zA-Z_]\w*", Name.Function),
+            (r"\(", Punctuation, "variable_definition"),
+            (r"\{", Punctuation, ("#pop", "selection_set")),
+        ],
+        "variable_definition": [
+            include("ignored_tokens"),
+            (r"\$[a-zA-Z_]\w*", Name.Variable),
+            (r"[\]!]", Punctuation),
+            (r":", Punctuation, "type"),
+            (r"=", Punctuation, "value"),
+            (r"\)", Punctuation, "#pop"),
+        ],
+        "type": [
+            include("ignored_tokens"),
+            (r"\[", Punctuation),
+            (words(BUILTIN_TYPES, suffix=r"\b"), Name.Builtin, "#pop"),
+            (r"[a-zA-Z_]\w*", Name.Class, "#pop"),
+        ],
+        "selection_set": [
+            include("ignored_tokens"),
+            (r"([a-zA-Z_]\w*)(\s*)(:)", bygroups(Name.Label, Whitespace, Punctuation)),
+            (r"[a-zA-Z_]\w*", Name),  # Field
+            (
+                r"(\.\.\.)(\s+)(on)\b",
+                bygroups(Punctuation, Whitespace, Keyword),
+                "inline_fragment",
+            ),
+            (r"\.\.\.", Punctuation, "fragment_spread"),
+            (r"\(", Punctuation, "arguments"),
+            (r"@[a-zA-Z_]\w*", Name.Decorator, "directive"),
+            (r"\{", Punctuation, "selection_set"),
+            (r"\}", Punctuation, "#pop"),
+        ],
+        "directive": [
+            include("ignored_tokens"),
+            (r"\(", Punctuation, ("#pop", "arguments")),
+        ],
+        "arguments": [
+            include("ignored_tokens"),
+            (r"[a-zA-Z_]\w*", Name),
+            (r":", Punctuation, "value"),
+            (r"\)", Punctuation, "#pop"),
+        ],
+        # Fragments
+        "fragment_definition": [
+            include("ignored_tokens"),
+            (r"[\]!]", Punctuation),  # For NamedType
+            (r"on\b", Keyword, "type"),
+            (r"[a-zA-Z_]\w*", Name.Function),
+            (r"@[a-zA-Z_]\w*", Name.Decorator, "directive"),
+            (r"\{", Punctuation, ("#pop", "selection_set")),
+        ],
+        "fragment_spread": [
+            include("ignored_tokens"),
+            (r"@[a-zA-Z_]\w*", Name.Decorator, "directive"),
+            (r"[a-zA-Z_]\w*", Name, "#pop"),  # Fragment name
+        ],
+        "inline_fragment": [
+            include("ignored_tokens"),
+            (r"[a-zA-Z_]\w*", Name.Class),  # Type condition
+            (r"@[a-zA-Z_]\w*", Name.Decorator, "directive"),
+            (r"\{", Punctuation, ("#pop", "selection_set")),
+        ],
+    }

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

@@ -0,0 +1,58 @@
+"""
+    pygments.lexers.graphviz
+    ~~~~~~~~~~~~~~~~~~~~~~~~
+
+    Lexer for the DOT language (graphviz).
+
+    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.lexer import RegexLexer, bygroups
+from pygments.token import Comment, Keyword, Operator, Name, String, Number, \
+    Punctuation, Whitespace
+
+
+__all__ = ['GraphvizLexer']
+
+
+class GraphvizLexer(RegexLexer):
+    """
+    For graphviz DOT graph description language.
+    """
+    name = 'Graphviz'
+    url = 'https://www.graphviz.org/doc/info/lang.html'
+    aliases = ['graphviz', 'dot']
+    filenames = ['*.gv', '*.dot']
+    mimetypes = ['text/x-graphviz', 'text/vnd.graphviz']
+    version_added = '2.8'
+    tokens = {
+        'root': [
+            (r'\s+', Whitespace),
+            (r'(#|//).*?$', Comment.Single),
+            (r'/(\\\n)?[*](.|\n)*?[*](\\\n)?/', Comment.Multiline),
+            (r'(?i)(node|edge|graph|digraph|subgraph|strict)\b', Keyword),
+            (r'--|->', Operator),
+            (r'[{}[\]:;,]', Punctuation),
+            (r'(\b\D\w*)(\s*)(=)(\s*)',
+                bygroups(Name.Attribute, Whitespace, Punctuation, Whitespace),
+                'attr_id'),
+            (r'\b(n|ne|e|se|s|sw|w|nw|c|_)\b', Name.Builtin),
+            (r'\b\D\w*', Name.Tag),  # node
+            (r'[-]?((\.[0-9]+)|([0-9]+(\.[0-9]*)?))', Number),
+            (r'"(\\"|[^"])*?"', Name.Tag),  # quoted node
+            (r'<', Punctuation, 'xml'),
+        ],
+        'attr_id': [
+            (r'\b\D\w*', String, '#pop'),
+            (r'[-]?((\.[0-9]+)|([0-9]+(\.[0-9]*)?))', Number, '#pop'),
+            (r'"(\\"|[^"])*?"', String.Double, '#pop'),
+            (r'<', Punctuation, ('#pop', 'xml')),
+        ],
+        'xml': [
+            (r'<', Punctuation, '#push'),
+            (r'>', Punctuation, '#pop'),
+            (r'\s+', Whitespace),
+            (r'[^<>\s]', Name.Tag),
+        ]
+    }

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

@@ -0,0 +1,103 @@
+"""
+    pygments.lexers.gsql
+    ~~~~~~~~~~~~~~~~~~~~
+
+    Lexers for TigerGraph GSQL graph query 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, bygroups, using, this, words
+from pygments.token import Keyword, Punctuation, Comment, Operator, Name, \
+    String, Number, Whitespace
+
+__all__ = ["GSQLLexer"]
+
+
+class GSQLLexer(RegexLexer):
+
+    """
+    For GSQL queries (version 3.x).
+    """
+
+    name = 'GSQL'
+    url = 'https://docs.tigergraph.com/dev/gsql-ref'
+    aliases = ['gsql']
+    filenames = ['*.gsql']
+    version_added = '2.10'
+
+    flags = re.MULTILINE | re.IGNORECASE
+
+    tokens = {
+        'root': [
+            include('comment'),
+            include('keywords'),
+            include('clauses'),
+            include('accums'),
+            include('relations'),
+            include('strings'),
+            include('whitespace'),
+            include('barewords'),
+            include('operators'),
+        ],
+        'comment': [
+            (r'\#.*', Comment.Single),
+            (r'/\*(.|\n)*?\*/', Comment.Multiline),
+        ],
+        'keywords': [
+            (words((
+                'ACCUM', 'AND', 'ANY', 'API', 'AS', 'ASC', 'AVG', 'BAG', 'BATCH',
+                'BETWEEN', 'BOOL', 'BOTH', 'BREAK', 'BY', 'CASE', 'CATCH', 'COALESCE',
+                'COMPRESS', 'CONTINUE', 'COUNT', 'CREATE', 'DATETIME', 'DATETIME_ADD',
+                'DATETIME_SUB', 'DELETE', 'DESC', 'DISTRIBUTED', 'DO', 'DOUBLE',
+                'EDGE', 'ELSE', 'END', 'ESCAPE', 'EXCEPTION', 'FALSE', 'FILE',
+                'FILTER', 'FLOAT', 'FOREACH', 'FOR', 'FROM', 'GRAPH', 'GROUP',
+                'GSQL_INT_MAX', 'GSQL_INT_MIN', 'GSQL_UINT_MAX', 'HAVING', 'IF',
+                'IN', 'INSERT', 'INT', 'INTERPRET', 'INTERSECT', 'INTERVAL', 'INTO',
+                'IS', 'ISEMPTY', 'JSONARRAY', 'JSONOBJECT', 'LASTHOP', 'LEADING',
+                'LIKE', 'LIMIT', 'LIST', 'LOAD_ACCUM', 'LOG', 'MAP', 'MATCH', 'MAX',
+                'MIN', 'MINUS', 'NOT', 'NOW', 'NULL', 'OFFSET', 'OR', 'ORDER', 'PATH',
+                'PER', 'PINNED', 'POST_ACCUM', 'POST-ACCUM', 'PRIMARY_ID', 'PRINT',
+                'QUERY', 'RAISE', 'RANGE', 'REPLACE', 'RESET_COLLECTION_ACCUM',
+                'RETURN', 'RETURNS', 'RUN', 'SAMPLE', 'SELECT', 'SELECT_VERTEX',
+                'SET', 'SRC', 'STATIC', 'STRING', 'SUM', 'SYNTAX', 'TARGET',
+                'TAGSTGT', 'THEN', 'TO', 'TO_CSV', 'TO_DATETIME', 'TRAILING',
+                'TRIM', 'TRUE', 'TRY', 'TUPLE', 'TYPEDEF', 'UINT', 'UNION', 'UPDATE',
+                'VALUES', 'VERTEX', 'WHEN', 'WHERE', 'WHILE', 'WITH'),
+                   prefix=r'(?<!\.)', suffix=r'\b'), Keyword),
+        ],
+        'clauses': [
+            (words(('accum', 'having', 'limit', 'order', 'postAccum', 'sample', 'where')),
+             Name.Builtin),
+        ],
+        'accums': [
+            (words(('andaccum', 'arrayaccum', 'avgaccum', 'bagaccum', 'bitwiseandaccum',
+                    'bitwiseoraccum', 'groupbyaccum', 'heapaccum', 'listaccum',
+                    'MapAccum', 'maxaccum', 'minaccum', 'oraccum', 'setaccum',
+                    'sumaccum')), Name.Builtin),
+        ],
+        'relations': [
+            (r'(-\s?)(\(.*\:\w?\))(\s?-)', bygroups(Operator, using(this), Operator)),
+            (r'->|<-', Operator),
+            (r'[.*{}\[\]\<\>\_]', Punctuation),
+        ],
+        'strings': [
+            (r'"([^"\\]|\\.)*"', String),
+            (r'@{1,2}\w+', Name.Variable),
+        ],
+        'whitespace': [
+            (r'\s+', Whitespace),
+        ],
+        'barewords': [
+            (r'[a-z]\w*', Name),
+            (r'(\d+\.\d+|\d+)', Number),
+        ],
+        'operators': [
+            (r'\$|[^0-9|\/|\-](\-\=|\+\=|\*\=|\\\=|\=|\=\=|\=\=\=|'
+             r'\+|\-|\*|\\|\+\=|\>|\<)[^\>|\/]', Operator),
+            (r'(\||\(|\)|\,|\;|\=|\-|\+|\*|\/|\>|\<|\:)', Operator),
+        ],
+    }

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

@@ -0,0 +1,73 @@
+"""
+    pygments.lexers.hare
+    ~~~~~~~~~~~~~~~~~~~~
+
+    Lexers for the Hare language.
+
+    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.lexer import RegexLexer, include, words
+from pygments.token import Comment, Operator, Keyword, Name, String, \
+    Number, Punctuation, Whitespace
+
+__all__ = ['HareLexer']
+
+class HareLexer(RegexLexer):
+    """
+    Lexer for the Hare programming language.
+    """
+    name = 'Hare'
+    url = 'https://harelang.org/'
+    aliases = ['hare']
+    filenames = ['*.ha']
+    mimetypes = ['text/x-hare']
+    version_added = '2.19'
+
+    _ws = r'(?:\s|//.*?\n|/[*].*?[*]/)+'
+    _ws1 = r'\s*(?:/[*].*?[*]/\s*)?'
+
+    tokens = {
+        'whitespace': [
+            (r'^use.*;', Comment.Preproc),
+            (r'@[a-z]+', Comment.Preproc),
+            (r'\n', Whitespace),
+            (r'\s+', Whitespace),
+            (r'//.*?$', Comment.Single),
+        ],
+        'statements': [
+            (r'"', String, 'string'),
+            (r'`[^`]*`', String),
+            (r"'(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|[^\\\'\n])'", String.Char),
+            (r'(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+[LlUu]*', Number.Float),
+            (r'(\d+\.\d*|\.\d+|\d+[fF])[fF]?', Number.Float),
+            (r'0x[0-9a-fA-F]+[LlUu]*', Number.Hex),
+            (r'0o[0-7]+[LlUu]*', Number.Oct),
+            (r'\d+[zui]?(\d+)?', Number.Integer),
+            (r'[~!%^&*+=|?:<>/-]', Operator),
+            (words(('as', 'is', '=>', '..', '...')), Operator),
+            (r'[()\[\],.{};]+', Punctuation),
+            (words(('abort', 'align', 'alloc', 'append', 'assert', 'case',
+                'const', 'def', 'defer', 'delete', 'else', 'enum', 'export',
+                'fn', 'for', 'free', 'if', 'let', 'len', 'match', 'offset',
+                'return', 'static', 'struct', 'switch', 'type', 'union',
+                'yield', 'vastart', 'vaarg', 'vaend'),
+                suffix=r'\b'), Keyword),
+            (r'(bool|int|uint|uintptr|u8|u16|u32|u64|i8|i16|i32|i64|f32|f64|null|done|never|void|nullable|rune|size|valist)\b',
+             Keyword.Type),
+            (r'(true|false|null)\b', Name.Builtin),
+            (r'[a-zA-Z_]\w*', Name),
+        ],
+        'string': [
+            (r'"', String, '#pop'),
+            (r'\\([\\abfnrtv"\']|x[a-fA-F0-9]{2,4}|'
+             r'u[a-fA-F0-9]{4}|U[a-fA-F0-9]{8}|[0-7]{1,3})', String.Escape),
+            (r'[^\\"\n]+', String),  # all other characters
+            (r'\\', String),  # stray backslash
+        ],
+        'root': [
+            include('whitespace'),
+            include('statements'),
+        ],
+    }