Buckets:

MisterAI
/

LocalAI_Demo_backends

Files

xet

MisterAI/LocalAI_Demo_backends / cpu-diffusers /venv /lib /python3.10 /site-packages /pygments /lexers /cel.py

MisterAI

28 days ago

download

raw

5.06 kB

"""
    pygments.lexers.cel
    ~~~~~~~~~~~~~~~~~~~
    Lexer for CEL (Common Expression Language).
    :copyright: Copyright 2006-present by the Pygments team, see AUTHORS.
    :license: BSD, see LICENSE for details.
"""

__all__ = ['CELLexer']

import re

from pygments.lexer import RegexLexer, words
from pygments.token import (
    Comment, Keyword, Name, Number, Operator, Punctuation, String, Whitespace,
)


class CELLexer(RegexLexer):
    """Lexer for CEL (Common Expression Language)."""

    name = 'CEL'
    aliases = ['cel']
    filenames = ['*.cel']
    mimetypes = []
    url = 'https://cel.dev'
    version_added = '2.21'

    flags = re.MULTILINE | re.UNICODE

    # Escape sequence per the CEL spec:
    #   \a \b \f \n \r \t \v \\ \" \' \` \?
    #   \xHH or \XHH  (exactly 2 hex digits)
    #   \uHHHH        (exactly 4 hex digits)
    #   \UHHHHHHHH    (exactly 8 hex digits)
    #   \OOO          (3-digit octal, first digit 0-3)
    #   \.            (fallback for unknown escapes)
    _ESCAPE = r"""\\(?:[abfnrtv\\"'`?]|[xX][0-9a-fA-F]{2}|u[0-9a-fA-F]{4}|U[0-9a-fA-F]{8}|[0-3][0-7][0-7]|.)"""

    # Raw prefix: r/R alone, or b/B combined with r/R in either order
    _RAW = r'(?:[bB][rR]|[rR][bB]|[rR])'

    tokens = {
        'root': [
            (r'\s+', Whitespace),
            # CEL only has line comments; no block comments.
            (r'//.*$', Comment.Single),

            # Bytes and string literals.
            # Raw variants (no escape processing) must be tried before
            # non-raw so that br/rb/r prefixes are consumed greedily.
            # Triple-quoted raw (br""", rb""", r""")
            (_RAW + r'"""', String, 'triple-double-raw'),
            (_RAW + r"'''", String, 'triple-single-raw'),
            # Triple-quoted non-raw with optional b prefix (b""" or """)
            (r'[bB]?"""', String, 'triple-double'),
            (r"[bB]?'''", String, 'triple-single'),
            # Single-line raw
            (_RAW + r'"[^"\r\n]*"', String),
            (_RAW + r"'[^'\r\n]*'", String),
            # Single-line non-raw with optional b prefix
            (r'[bB]?"', String, 'double-string'),
            (r"[bB]?'", String, 'single-string'),

            # Numbers.
            # uint_literal: integer (decimal or hex) followed by u/U suffix.
            (r'(?:0[xX][0-9a-fA-F]+|0|[1-9][0-9]*)[uU]', Number.Integer),
            # float_literal: the grammar requires digits on both sides of the
            # decimal point for the dotted form — `1.` is not valid CEL.
            (r'(?:[0-9]+\.[0-9]+(?:[eE][+-]?[0-9]+)?'
             r'|[0-9]+[eE][+-]?[0-9]+'
             r'|\.[0-9]+(?:[eE][+-]?[0-9]+)?)',
             Number.Float),
            # int_literal: hex or decimal.
            (r'0[xX][0-9a-fA-F]+|0|[1-9][0-9]*', Number.Integer),

            # Reserved keywords (may not appear as identifiers).
            (words((
                'as', 'break', 'const', 'continue', 'else', 'for',
                'function', 'if', 'import', 'let', 'loop', 'namespace',
                'package', 'return', 'var', 'void', 'while',
            ), suffix=r'\b'), Keyword.Reserved),
            # `in` is a comparison operator keyword.
            (r'in\b', Keyword),
            # Built-in literal constants.
            (words(('true', 'false', 'null'), suffix=r'\b'), Keyword.Constant),

            # Logical and comparison operators.
            (r'&&|\|\|', Operator),
            (r'==|!=|<=|>=', Operator),
            # Arithmetic, unary, ternary, and remaining comparison operators.
            (r'[+\-*/%<>!?]', Operator),

            # Punctuation: brackets, comma, dot, colon.
            (r'[(){}\[\]]', Punctuation),
            (r'[,.]', Punctuation),
            (r':', Punctuation),

            # Identifiers: start with letter or underscore (Unicode-aware).
            (r'[^\W\d]\w*', Name),
        ],

        # Raw triple-quoted (no escape tokens; content is one big String).
        'triple-double-raw': [
            (r'"""', String, '#pop'),
            (r'"(?!"")', String),
            (r'[^"]+', String),
        ],
        'triple-single-raw': [
            (r"'''", String, '#pop'),
            (r"'(?!'')", String),
            (r"[^']+", String),
        ],

        # Non-raw triple-quoted (escape sequences highlighted separately).
        'triple-double': [
            (r'"""', String, '#pop'),
            (_ESCAPE, String.Escape),
            (r'"(?!"")', String),
            (r'[^"\\]+', String),
        ],
        'triple-single': [
            (r"'''", String, '#pop'),
            (_ESCAPE, String.Escape),
            (r"'(?!'')", String),
            (r"[^'\\]+", String),
        ],

        # Single-line non-raw strings (cannot span lines).
        'double-string': [
            (r'"', String, '#pop'),
            (_ESCAPE, String.Escape),
            (r'[^"\\\r\n]+', String),
        ],
        'single-string': [
            (r"'", String, '#pop'),
            (_ESCAPE, String.Escape),
            (r"[^'\\\r\n]+", String),
        ],
    }

Xet Storage Details

Size:: 5.06 kB
Xet hash:: 94cb92cf02a32f94908cb2f722e021e36b197a4681be1830f5456ef6a8ad1095

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.

	"""
	pygments.lexers.cel
	~~~~~~~~~~~~~~~~~~~

	Lexer for CEL (Common Expression Language).

	:copyright: Copyright 2006-present by the Pygments team, see AUTHORS.
	:license: BSD, see LICENSE for details.
	"""

	__all__ = ['CELLexer']

	import re

	from pygments.lexer import RegexLexer, words
	from pygments.token import (
	Comment, Keyword, Name, Number, Operator, Punctuation, String, Whitespace,
	)


	class CELLexer(RegexLexer):
	"""Lexer for CEL (Common Expression Language)."""

	name = 'CEL'
	aliases = ['cel']
	filenames = ['*.cel']
	mimetypes = []
	url = 'https://cel.dev'
	version_added = '2.21'

	flags = re.MULTILINE \| re.UNICODE

	# Escape sequence per the CEL spec:
	# \a \b \f \n \r \t \v \\ \" \' \` \?
	# \xHH or \XHH (exactly 2 hex digits)
	# \uHHHH (exactly 4 hex digits)
	# \UHHHHHHHH (exactly 8 hex digits)
	# \OOO (3-digit octal, first digit 0-3)
	# \. (fallback for unknown escapes)
	_ESCAPE = r"""\\(?:[abfnrtv\\"'`?]\|[xX][0-9a-fA-F]{2}\|u[0-9a-fA-F]{4}\|U[0-9a-fA-F]{8}\|[0-3][0-7][0-7]\|.)"""

	# Raw prefix: r/R alone, or b/B combined with r/R in either order
	_RAW = r'(?:[bB][rR]\|[rR][bB]\|[rR])'

	tokens = {
	'root': [
	(r'\s+', Whitespace),
	# CEL only has line comments; no block comments.
	(r'//.*$', Comment.Single),

	# Bytes and string literals.
	# Raw variants (no escape processing) must be tried before
	# non-raw so that br/rb/r prefixes are consumed greedily.
	# Triple-quoted raw (br""", rb""", r""")
	(_RAW + r'"""', String, 'triple-double-raw'),
	(_RAW + r"'''", String, 'triple-single-raw'),
	# Triple-quoted non-raw with optional b prefix (b""" or """)
	(r'[bB]?"""', String, 'triple-double'),
	(r"[bB]?'''", String, 'triple-single'),
	# Single-line raw
	(_RAW + r'"[^"\r\n]*"', String),
	(_RAW + r"'[^'\r\n]*'", String),
	# Single-line non-raw with optional b prefix
	(r'[bB]?"', String, 'double-string'),
	(r"[bB]?'", String, 'single-string'),

	# Numbers.
	# uint_literal: integer (decimal or hex) followed by u/U suffix.
	(r'(?:0[xX][0-9a-fA-F]+\|0\|[1-9][0-9]*)[uU]', Number.Integer),
	# float_literal: the grammar requires digits on both sides of the
	# decimal point for the dotted form — `1.` is not valid CEL.
	(r'(?:[0-9]+\.[0-9]+(?:[eE][+-]?[0-9]+)?'
	r'\|[0-9]+[eE][+-]?[0-9]+'
	r'\|\.[0-9]+(?:[eE][+-]?[0-9]+)?)',
	Number.Float),
	# int_literal: hex or decimal.
	(r'0[xX][0-9a-fA-F]+\|0\|[1-9][0-9]*', Number.Integer),

	# Reserved keywords (may not appear as identifiers).
	(words((
	'as', 'break', 'const', 'continue', 'else', 'for',
	'function', 'if', 'import', 'let', 'loop', 'namespace',
	'package', 'return', 'var', 'void', 'while',
	), suffix=r'\b'), Keyword.Reserved),
	# `in` is a comparison operator keyword.
	(r'in\b', Keyword),
	# Built-in literal constants.
	(words(('true', 'false', 'null'), suffix=r'\b'), Keyword.Constant),

	# Logical and comparison operators.
	(r'&&\|\\|\\|', Operator),
	(r'==\|!=\|<=\|>=', Operator),
	# Arithmetic, unary, ternary, and remaining comparison operators.
	(r'[+\-*/%<>!?]', Operator),

	# Punctuation: brackets, comma, dot, colon.
	(r'[(){}\[\]]', Punctuation),
	(r'[,.]', Punctuation),
	(r':', Punctuation),

	# Identifiers: start with letter or underscore (Unicode-aware).
	(r'[^\W\d]\w*', Name),
	],

	# Raw triple-quoted (no escape tokens; content is one big String).
	'triple-double-raw': [
	(r'"""', String, '#pop'),
	(r'"(?!"")', String),
	(r'[^"]+', String),
	],
	'triple-single-raw': [
	(r"'''", String, '#pop'),
	(r"'(?!'')", String),
	(r"[^']+", String),
	],

	# Non-raw triple-quoted (escape sequences highlighted separately).
	'triple-double': [
	(r'"""', String, '#pop'),
	(_ESCAPE, String.Escape),
	(r'"(?!"")', String),
	(r'[^"\\]+', String),
	],
	'triple-single': [
	(r"'''", String, '#pop'),
	(_ESCAPE, String.Escape),
	(r"'(?!'')", String),
	(r"[^'\\]+", String),
	],

	# Single-line non-raw strings (cannot span lines).
	'double-string': [
	(r'"', String, '#pop'),
	(_ESCAPE, String.Escape),
	(r'[^"\\\r\n]+', String),
	],
	'single-string': [
	(r"'", String, '#pop'),
	(_ESCAPE, String.Escape),
	(r"[^'\\\r\n]+", String),
	],
	}