omextra 0.0.0.dev423__py3-none-any.whl → 0.0.0.dev425__py3-none-any.whl

omextra/sql/parsing/_antlr/MinisqlVisitor.py

@@ -0,0 +1,292 @@
+# type: ignore
+# ruff: noqa
+# flake8: noqa
+# @omlish-generated
+# Generated from Minisql.g4 by ANTLR 4.13.2
+from omlish.text.antlr._runtime._all import *
+if "." in __name__:
+    from .MinisqlParser import MinisqlParser
+else:
+    from MinisqlParser import MinisqlParser
+
+# This class defines a complete generic visitor for a parse tree produced by MinisqlParser.
+
+class MinisqlVisitor(ParseTreeVisitor):
+
+    # Visit a parse tree produced by MinisqlParser#singleStmt.
+    def visitSingleStmt(self, ctx:MinisqlParser.SingleStmtContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#select.
+    def visitSelect(self, ctx:MinisqlParser.SelectContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#cteSelect.
+    def visitCteSelect(self, ctx:MinisqlParser.CteSelectContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#cte.
+    def visitCte(self, ctx:MinisqlParser.CteContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#unionSelect.
+    def visitUnionSelect(self, ctx:MinisqlParser.UnionSelectContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#unionItem.
+    def visitUnionItem(self, ctx:MinisqlParser.UnionItemContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#primarySelect.
+    def visitPrimarySelect(self, ctx:MinisqlParser.PrimarySelectContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#allSelectItem.
+    def visitAllSelectItem(self, ctx:MinisqlParser.AllSelectItemContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#exprSelectItem.
+    def visitExprSelectItem(self, ctx:MinisqlParser.ExprSelectItemContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#expr.
+    def visitExpr(self, ctx:MinisqlParser.ExprContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#unaryBooleanExpr.
+    def visitUnaryBooleanExpr(self, ctx:MinisqlParser.UnaryBooleanExprContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#predicatedBooleanExpr.
+    def visitPredicatedBooleanExpr(self, ctx:MinisqlParser.PredicatedBooleanExprContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#binaryBooleanExpr.
+    def visitBinaryBooleanExpr(self, ctx:MinisqlParser.BinaryBooleanExprContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#castBooleanExpr.
+    def visitCastBooleanExpr(self, ctx:MinisqlParser.CastBooleanExprContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#cmpPredicate.
+    def visitCmpPredicate(self, ctx:MinisqlParser.CmpPredicateContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#isNullPredicate.
+    def visitIsNullPredicate(self, ctx:MinisqlParser.IsNullPredicateContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#inListPredicate.
+    def visitInListPredicate(self, ctx:MinisqlParser.InListPredicateContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#inSelectPredicate.
+    def visitInSelectPredicate(self, ctx:MinisqlParser.InSelectPredicateContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#likePredicate.
+    def visitLikePredicate(self, ctx:MinisqlParser.LikePredicateContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#arithValueExpr.
+    def visitArithValueExpr(self, ctx:MinisqlParser.ArithValueExprContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#unaryValueExpr.
+    def visitUnaryValueExpr(self, ctx:MinisqlParser.UnaryValueExprContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#primaryValueExpr.
+    def visitPrimaryValueExpr(self, ctx:MinisqlParser.PrimaryValueExprContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#functionCallExpr.
+    def visitFunctionCallExpr(self, ctx:MinisqlParser.FunctionCallExprContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#starFunctionCallExpr.
+    def visitStarFunctionCallExpr(self, ctx:MinisqlParser.StarFunctionCallExprContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#caseExpr.
+    def visitCaseExpr(self, ctx:MinisqlParser.CaseExprContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#selectExpr.
+    def visitSelectExpr(self, ctx:MinisqlParser.SelectExprContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#parenExpr.
+    def visitParenExpr(self, ctx:MinisqlParser.ParenExprContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#simplePrimaryExpr.
+    def visitSimplePrimaryExpr(self, ctx:MinisqlParser.SimplePrimaryExprContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#simpleExpr.
+    def visitSimpleExpr(self, ctx:MinisqlParser.SimpleExprContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#caseItem.
+    def visitCaseItem(self, ctx:MinisqlParser.CaseItemContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#over.
+    def visitOver(self, ctx:MinisqlParser.OverContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#sortItem.
+    def visitSortItem(self, ctx:MinisqlParser.SortItemContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#aliasedRelation.
+    def visitAliasedRelation(self, ctx:MinisqlParser.AliasedRelationContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#joinRelation.
+    def visitJoinRelation(self, ctx:MinisqlParser.JoinRelationContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#selectRelation.
+    def visitSelectRelation(self, ctx:MinisqlParser.SelectRelationContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#tableRelation.
+    def visitTableRelation(self, ctx:MinisqlParser.TableRelationContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#parenRelation.
+    def visitParenRelation(self, ctx:MinisqlParser.ParenRelationContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#groupBy.
+    def visitGroupBy(self, ctx:MinisqlParser.GroupByContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#qualifiedName.
+    def visitQualifiedName(self, ctx:MinisqlParser.QualifiedNameContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#identList.
+    def visitIdentList(self, ctx:MinisqlParser.IdentListContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#ident.
+    def visitIdent(self, ctx:MinisqlParser.IdentContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#quotedIdent.
+    def visitQuotedIdent(self, ctx:MinisqlParser.QuotedIdentContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#integerNumber.
+    def visitIntegerNumber(self, ctx:MinisqlParser.IntegerNumberContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#decimalNumber.
+    def visitDecimalNumber(self, ctx:MinisqlParser.DecimalNumberContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#floatNumber.
+    def visitFloatNumber(self, ctx:MinisqlParser.FloatNumberContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#string.
+    def visitString(self, ctx:MinisqlParser.StringContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#null.
+    def visitNull(self, ctx:MinisqlParser.NullContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#true.
+    def visitTrue(self, ctx:MinisqlParser.TrueContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#false.
+    def visitFalse(self, ctx:MinisqlParser.FalseContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#setQuantifier.
+    def visitSetQuantifier(self, ctx:MinisqlParser.SetQuantifierContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#joinType.
+    def visitJoinType(self, ctx:MinisqlParser.JoinTypeContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#cmpOp.
+    def visitCmpOp(self, ctx:MinisqlParser.CmpOpContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#arithOp.
+    def visitArithOp(self, ctx:MinisqlParser.ArithOpContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#unaryOp.
+    def visitUnaryOp(self, ctx:MinisqlParser.UnaryOpContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#unquotedIdent.
+    def visitUnquotedIdent(self, ctx:MinisqlParser.UnquotedIdentContext):
+        return self.visitChildren(ctx)
+
+
+
+del MinisqlParser

omextra/sql/parsing/parsing.py

@@ -0,0 +1,120 @@
+# ruff: noqa: N802 N803
+import typing as ta
+
+from omlish import check
+from omlish.sql import queries as no
+from omlish.text.antlr import runtime as antlr4
+from omlish.text.antlr.delimit import DelimitingLexer
+from omlish.text.antlr.errors import SilentRaisingErrorListener
+
+from ._antlr.MinisqlLexer import MinisqlLexer  # type: ignore
+from ._antlr.MinisqlParser import MinisqlParser  # type: ignore
+from ._antlr.MinisqlVisitor import MinisqlVisitor  # type: ignore
+
+
+##
+
+
+class _ParseVisitor(MinisqlVisitor):
+    def visit(self, ctx: antlr4.ParserRuleContext):
+        check.isinstance(ctx, antlr4.ParserRuleContext)
+        node = ctx.accept(self)
+        return node
+
+    def aggregateResult(self, aggregate, nextResult):
+        if aggregate is not None:
+            check.none(nextResult)
+            return aggregate
+        else:
+            check.none(aggregate)
+            return nextResult
+
+    #
+
+    def visitExprSelectItem(self, ctx: MinisqlParser.ExprSelectItemContext):
+        value = self.visit(ctx.expr())
+        label = self.visit(ctx.ident()) if ctx.ident() is not None else None
+        return no.ExprSelectItem(value, label)
+
+    def visitIntegerNumber(self, ctx: MinisqlParser.IntegerNumberContext):
+        return no.Literal(int(ctx.INTEGER_VALUE().getText()))
+
+    def visitPrimarySelect(self, ctx: MinisqlParser.PrimarySelectContext):
+        items = [self.visit(i) for i in ctx.selectItem()]
+        relations = [self.visit(r) for r in ctx.relation()]
+        where = self.visit(ctx.where) if ctx.where is not None else None
+        return no.Select(
+            items=items,
+            from_=check.single(relations) if relations else None,
+            where=where,
+        )
+
+    def visitQuotedIdent(self, ctx: MinisqlParser.QuotedIdentContext):
+        name = unquote(ctx.QUOTED_IDENT().getText(), '"')
+        return no.Ident(name)
+
+    def visitUnquotedIdent(self, ctx: MinisqlParser.UnquotedIdentContext):
+        return no.Ident(ctx.getText())
+
+
+##
+
+
+def create_parser(buf: str) -> MinisqlParser:
+    lexer = MinisqlLexer(antlr4.InputStream(buf))
+    lexer.removeErrorListeners()
+    lexer.addErrorListener(SilentRaisingErrorListener())
+
+    stream = antlr4.CommonTokenStream(lexer)
+    stream.fill()
+
+    parser = MinisqlParser(stream)
+    parser.removeErrorListeners()
+    parser.addErrorListener(SilentRaisingErrorListener())
+
+    return parser
+
+
+##
+
+
+def parse_stmt(buf: str, **kwargs) -> no.Stmt:
+    parser = create_parser(buf, **kwargs)
+    node = _ParseVisitor().visit(parser.singleStmt())
+    return check.isinstance(node, no.Stmt)
+
+
+class _DelimitingLexer(DelimitingLexer, MinisqlLexer):
+    pass
+
+
+def split_stmts(buf: str) -> ta.Sequence[str]:
+    lexer = _DelimitingLexer(
+        antlr4.InputStream(buf),
+        delimiter_token=MinisqlParser.DELIMITER,
+        delimiters=[';'],
+    )
+    lexer.removeErrorListeners()
+    lexer.addErrorListener(SilentRaisingErrorListener())
+
+    lst, part = lexer.split()
+    if part.strip():
+        raise ValueError(part)
+
+    return [s for s, _ in lst]
+
+
+def parse_stmts(buf: str, **kwargs) -> ta.Sequence[no.Stmt]:
+    return [parse_stmt(sb, **kwargs) for sb in split_stmts(buf)]
+
+
+##
+
+
+def quote(val: str, q: str) -> str:
+    return q + val.replace(q, q * 2) + q
+
+
+def unquote(val: str, q: str) -> str:
+    check.arg(val.startswith(q) and val.endswith(q))
+    return val[1:-1].replace(q * 2, q)

omextra/text/antlr/cli/__main__.py

@@ -0,0 +1,11 @@
+from omdev.cli import CliModule
+
+
+# @omlish-manifest
+_CLI_MODULE = CliModule('antlr', __name__)
+
+
+if __name__ == '__main__':
+    from .cli import _main  # noqa
+
+    _main()

omextra/text/antlr/cli/cli.py

@@ -0,0 +1,62 @@
+import logging
+import re
+import subprocess
+import sys
+
+from omlish.argparse import all as ap
+from omlish.logs import all as logs
+
+from .consts import ANTLR_RUNTIME_PACKAGE
+from .gen import GenPy
+from .gen import get_jar_path
+
+
+log = logging.getLogger(__name__)
+
+
+##
+
+
+class Cli(ap.Cli):
+    @ap.cmd()
+    def jar(self) -> None:
+        print(get_jar_path())
+
+    @ap.cmd()
+    def latest(self) -> None:
+        o, _ = subprocess.Popen(
+            [
+                sys.executable,
+                '-m', 'pip',
+                'index', 'versions',
+                ANTLR_RUNTIME_PACKAGE,
+            ],
+            stdout=subprocess.PIPE,
+        ).communicate()
+        tl = o.decode().splitlines()[0]
+        m = re.fullmatch(rf'{ANTLR_RUNTIME_PACKAGE} \((?P<version>[^)]+)\)', tl)
+        if m is None:
+            raise ValueError(f'Failed to parse version: {tl}')
+        v = m.groupdict()['version']
+        print(v)
+
+    #
+
+    @ap.cmd(
+        ap.arg('roots', nargs='+'),
+    )
+    def gen(self) -> None:
+        gp = GenPy(
+            self.args.roots,
+        )
+        gp.run()
+
+
+def _main() -> None:
+    logs.configure_standard_logging(logging.INFO)
+    cli = Cli()
+    cli()
+
+
+if __name__ == '__main__':
+    _main()

omextra/text/antlr/cli/consts.py

@@ -0,0 +1,7 @@
+ANTLR_VERSION = '4.13.2'
+ANTLR_JAR_NAME = f'antlr-{ANTLR_VERSION}-complete.jar'
+ANTLR_JAR_URL = f'https://www.antlr.org/download/{ANTLR_JAR_NAME}'
+ANTLR_RUNTIME_PACKAGE = 'antlr4-python3-runtime'
+ANTLR_GITHUB_REPO = 'antlr/antlr4'
+
+ANTLR_RUNTIME_VENDOR = 'omlish.text.antlr._runtime._all'

omextra/text/antlr/cli/gen.py

@@ -0,0 +1,188 @@
+"""
+TODO:
+ - mtime cmp
+ - parallelism
+"""
+import logging
+import os.path
+import re
+import shutil
+import subprocess
+import typing as ta
+
+from omdev.cache import data as dcache
+from omlish import check
+from omlish import lang
+from omlish.os.paths import is_path_in_dir
+
+from .consts import ANTLR_JAR_URL
+from .consts import ANTLR_RUNTIME_VENDOR
+
+
+log = logging.getLogger(__name__)
+
+
+##
+
+
+ANTLR_JAR_CACHE = dcache.UrlSpec(ANTLR_JAR_URL)
+
+
+@lang.cached_function
+def get_jar_path() -> str:
+    return dcache.default().get(ANTLR_JAR_CACHE)
+
+
+##
+
+
+def _find_dirs(*base_paths: str, filter: ta.Callable[[str], bool] = lambda _: True) -> ta.Sequence[str]:  # noqa
+    return sorted(
+        os.path.join(dp, dn)
+        for base_path in base_paths
+        for dp, dns, fns in os.walk(base_path)
+        for dn in dns
+        if filter(dn)
+    )
+
+
+def _find_files(*base_paths: str, filter: ta.Callable[[str], bool] = lambda _: True) -> ta.Sequence[str]:  # noqa
+    return sorted(
+        os.path.join(dp, fn)
+        for base_path in base_paths
+        for dp, dns, fns in os.walk(base_path)
+        for fn in fns
+        if filter(fn)
+    )
+
+
+class GenPy:
+    def __init__(
+            self,
+            root_dirs: str,  # noqa
+            *,
+            out_subdir: str = '_antlr',
+            runtime_import: str = ANTLR_RUNTIME_VENDOR,
+            jar_path: str | None = None,
+            # parallelism: int | None = None,
+    ) -> None:
+        super().__init__()
+
+        check.non_empty_str(out_subdir)
+        check.arg(not os.path.isabs(out_subdir) and '.' not in out_subdir and '/' not in out_subdir)
+
+        self._root_dirs = frozenset(check.non_empty_str(rd) for rd in check.not_isinstance(root_dirs, str))
+        self._out_subdir = out_subdir
+        self._runtime_import = runtime_import
+        self._given_jar_path = jar_path
+
+    #
+
+    def _rmtree(self, tgt: str) -> None:  # noqa
+        if not any(is_path_in_dir(rd, tgt) for rd in self._root_dirs):
+            raise RuntimeError(f'Refusing to delete {tgt!r} outside of {self._root_dirs!r}')
+        shutil.rmtree(tgt)
+
+    #
+
+    @lang.cached_function
+    def jar_path(self) -> str:
+        if (gjp := self._given_jar_path) is not None:
+            return gjp
+        return get_jar_path()
+
+    #
+
+    def process_g4(self, g4_file: str) -> None:
+        ap = os.path.abspath(g4_file)
+        check.state(os.path.isfile(ap))
+
+        od = os.path.join(os.path.dirname(ap), self._out_subdir)
+        os.makedirs(od, exist_ok=True)
+
+        log.info('Compiling grammar %s', g4_file)
+
+        try:
+            subprocess.check_call([
+                'java',
+                '-jar', self.jar_path(),
+                '-Dlanguage=Python3',
+                '-visitor',
+                '-o', self._out_subdir,
+                os.path.basename(g4_file),
+            ], cwd=os.path.dirname(ap))
+
+        except Exception:  # noqa
+            log.exception('Exception in grammar %s', g4_file)
+            raise
+
+    def process_py(self, py_file: str) -> None:
+        ap = os.path.abspath(py_file)
+        with open(ap) as f:
+            in_lines = list(f)
+
+        pfp = py_file.split(os.sep)
+        arp = ANTLR_RUNTIME_VENDOR.split('.')
+        if (cpl := lang.common_prefix_len(pfp, arp)) > 0:
+            pkg_depth = len(os.path.normpath(py_file).split(os.path.sep))
+            antlr_imp = '.'.join([*([''] * (pkg_depth - cpl)), *arp[cpl:]])
+        else:
+            antlr_imp = ANTLR_RUNTIME_VENDOR
+
+        out_lines = [
+            '# type: ignore\n',
+            '# ruff: noqa\n',
+            '# flake8: noqa\n',
+            '# @omlish-generated\n',
+        ]
+
+        for l in in_lines:
+            l = re.sub(r'^(from antlr4)(.*)', rf'from {antlr_imp}\2', l)
+            out_lines.append(l)
+
+        with open(ap, 'w') as f:
+            f.write(''.join(out_lines))
+
+    def process_dir(self, dir: str) -> None:  # noqa
+        log.info('Processing directory %s', dir)
+
+        ad = os.path.join(dir, self._out_subdir)
+        if os.path.exists(ad):
+            self._rmtree(ad)
+
+        for f in os.listdir(dir):
+            fp = os.path.join(dir, f)
+            if not os.path.isfile(fp) or not f.endswith('.g4'):
+                continue
+
+            self.process_g4(fp)
+
+        if not os.path.exists(ad):
+            return
+
+        ip = os.path.join(ad, '__init__.py')
+        check.state(not os.path.exists(ip))
+
+        for f in list(os.listdir(ad)):
+            fp = os.path.join(ad, f)
+            if not os.path.isfile(fp):
+                continue
+
+            if f.split('.')[-1] in ('interp', 'tokens'):
+                os.unlink(fp)
+
+            elif f != '__init__.py' and f.endswith('.py'):
+                self.process_py(fp)
+
+        with open(ip, 'w'):
+            pass
+
+    def run(self) -> None:
+        dns = _find_dirs(*self._root_dirs, filter=lambda dn: os.path.basename(dn) == '_antlr')
+        for dn in dns:
+            self._rmtree(dn)
+
+        fns = _find_files(*self._root_dirs, filter=lambda fn: fn.endswith('.g4'))
+        fds = {os.path.dirname(fn) for fn in fns}
+        for dn in sorted(fds):
+            self.process_dir(dn)