Gecko [ v3.cesa.co.za ]

Name	Size	Permission	Date
__pycache__	[ DIR ]	drwxr-xr-x	2026-06-08 18:08
__pyinstaller	[ DIR ]	drwxr-xr-x	2026-06-08 18:08
grammars	[ DIR ]	drwxr-xr-x	2026-06-08 18:08
parsers	[ DIR ]	drwxr-xr-x	2026-06-08 18:08
tools	[ DIR ]	drwxr-xr-x	2026-06-08 18:08
LICENSE	1.03 KB	-rw-r--r--	1980-01-01 08:00
__init__.py	744 B	-rw-r--r--	1980-01-01 08:00
ast_utils.py	2.04 KB	-rw-r--r--	1980-01-01 08:00
common.py	2.83 KB	-rw-r--r--	1980-01-01 08:00
exceptions.py	10.68 KB	-rw-r--r--	1980-01-01 08:00
grammar.py	3.35 KB	-rw-r--r--	1980-01-01 08:00
indenter.py	3 KB	-rw-r--r--	1980-01-01 08:00
lark.py	27.09 KB	-rw-r--r--	1980-01-01 08:00
lexer.py	22.98 KB	-rw-r--r--	1980-01-01 08:00
load_grammar.py	52.23 KB	-rw-r--r--	1980-01-01 08:00
parse_tree_builder.py	13.78 KB	-rw-r--r--	1980-01-01 08:00
parser_frontends.py	9.82 KB	-rw-r--r--	1980-01-01 08:00
py.typed	0 B	-rw-r--r--	1980-01-01 08:00
reconstruct.py	3.63 KB	-rw-r--r--	1980-01-01 08:00
tree.py	8.04 KB	-rw-r--r--	1980-01-01 08:00
tree_matcher.py	5.86 KB	-rw-r--r--	1980-01-01 08:00
tree_templates.py	6 KB	-rw-r--r--	1980-01-01 08:00
utils.py	10.73 KB	-rw-r--r--	1980-01-01 08:00
visitors.py	20.6 KB	-rw-r--r--	1980-01-01 08:00

Rename

from copy import deepcopy
import sys
from types import ModuleType
from typing import Callable, Collection, Dict, Optional, TYPE_CHECKING

if TYPE_CHECKING:
    from .lark import PostLex
    from .lexer import Lexer
    from typing import Union, Type
    if sys.version_info >= (3, 8):
        from typing import Literal
    else:
        from typing_extensions import Literal
    if sys.version_info >= (3, 10):
        from typing import TypeAlias
    else:
        from typing_extensions import TypeAlias

from .utils import Serialize
from .lexer import TerminalDef, Token

###{standalone

_ParserArgType: 'TypeAlias' = 'Literal["earley", "lalr", "cyk", "auto"]'
_LexerArgType: 'TypeAlias' = 'Union[Literal["auto", "basic", "contextual", "dynamic", "dynamic_complete"], Type[Lexer]]'
_Callback = Callable[[Token], Token]

class LexerConf(Serialize):
    __serialize_fields__ = 'terminals', 'ignore', 'g_regex_flags', 'use_bytes', 'lexer_type'
    __serialize_namespace__ = TerminalDef,

terminals: Collection[TerminalDef]
    re_module: ModuleType
    ignore: Collection[str]
    postlex: 'Optional[PostLex]'
    callbacks: Dict[str, _Callback]
    g_regex_flags: int
    skip_validation: bool
    use_bytes: bool
    lexer_type: Optional[_LexerArgType]
    strict: bool

def __init__(self, terminals: Collection[TerminalDef], re_module: ModuleType, ignore: Collection[str]=(), postlex: 'Optional[PostLex]'=None,
                 callbacks: Optional[Dict[str, _Callback]]=None, g_regex_flags: int=0, skip_validation: bool=False, use_bytes: bool=False, strict: bool=False):
        self.terminals = terminals
        self.terminals_by_name = {t.name: t for t in self.terminals}
        assert len(self.terminals) == len(self.terminals_by_name)
        self.ignore = ignore
        self.postlex = postlex
        self.callbacks = callbacks or {}
        self.g_regex_flags = g_regex_flags
        self.re_module = re_module
        self.skip_validation = skip_validation
        self.use_bytes = use_bytes
        self.strict = strict
        self.lexer_type = None

def _deserialize(self):
        self.terminals_by_name = {t.name: t for t in self.terminals}

def __deepcopy__(self, memo=None):
        return type(self)(
            deepcopy(self.terminals, memo),
            self.re_module,
            deepcopy(self.ignore, memo),
            deepcopy(self.postlex, memo),
            deepcopy(self.callbacks, memo),
            deepcopy(self.g_regex_flags, memo),
            deepcopy(self.skip_validation, memo),
            deepcopy(self.use_bytes, memo),
        )

class ParserConf(Serialize):
    __serialize_fields__ = 'rules', 'start', 'parser_type'

def __init__(self, rules, callbacks, start):
        assert isinstance(start, list)
        self.rules = rules
        self.callbacks = callbacks
        self.start = start

self.parser_type = None

###}