sqlakit 0.22.2__tar.gz → 0.22.4__tar.gz

{sqlakit-0.22.2 → sqlakit-0.22.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlakit
-Version: 0.22.2
+Version: 0.22.4
 Summary: A toolkit for SQLAlchemy applications.
 Keywords: sqlalchemy,database,orm,sql,asyncio
 Author: Anton Ruhlov

{sqlakit-0.22.2 → sqlakit-0.22.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sqlakit"
-version = "0.22.2"
+version = "0.22.4"
 description = "A toolkit for SQLAlchemy applications."
 readme = "README.md"
 license = "MIT"
@@ -201,6 +201,7 @@ dev = [
     "dirty-equals>=0.11",
     "codespell>=2.4.3",
     "sqruff>=0.40.0",
+    "sqlfluff>=4.3.0",
 ]
 docs = [
     "mkdocs>=1.6.1,<2",

{sqlakit-0.22.2 → sqlakit-0.22.4}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "sqlakit"
-version = "0.22.2"
+version = "0.22.4"
 description = "A toolkit for SQLAlchemy applications."
 readme = "README.md"
 license = "MIT"
@@ -77,6 +77,7 @@ dev = [
     "dirty-equals>=0.11",
     "codespell>=2.4.3",
     "sqruff>=0.40.0",
+    "sqlfluff>=4.3.0",
 ]
 docs = [
     "mkdocs>=1.6.1,<2",

{sqlakit-0.22.2 → sqlakit-0.22.4}/sqlakit/_cli.py

@@ -5,17 +5,20 @@ from __future__ import annotations
 import argparse
 import json
 import os
+import shutil
 import sys
 from pathlib import Path
 
+from . import _sql_formatter
+from ._linters import LINTERS, dialect_of, settings, stale
 from ._project import Problem, Project, load_project
 from ._pycharm import DIALECTS, ddl, dialects
+from ._render import import_macros, rendered, unparsed
 from ._sql import NAMESPACE, registered, signature_of
-from ._sqruff import settings, stale
 from .exceptions import MacroDefinitionError, ProjectConfigError, UnknownImportPathError
 
 
-def main(argv: list[str] | None = None) -> int:
+def main(argv: list[str] | None = None) -> int:  # noqa: PLR0911 - one return a command
     """Run a command, and return what the shell should make of it."""
     parser = argparse.ArgumentParser(prog="sqlakit", description="SQLAKit.")
     commands = parser.add_subparsers(dest="command", required=True)
@@ -51,11 +54,36 @@ def main(argv: list[str] | None = None) -> int:
         help="a directory in the project, the current one by default",
     )
     check.add_argument("--format", choices=("text", "json"), default="text")
+    check.add_argument(
+        "--lint",
+        choices=tuple(LINTERS),
+        help="also render every template, running the project's macros, and "
+        "fail where the linter cannot parse the SQL",
+    )
+    check.add_argument(
+        "--dialect", help="the dialect to render for, in place of the project's"
+    )
+
+    render = commands.add_parser(
+        "render",
+        help="write every template as the SQL it renders, for a linter to read",
+    )
+    render.add_argument(
+        "--out", required=True, help="the directory to write the rendered SQL into"
+    )
+    render.add_argument(
+        "--project",
+        default=".",
+        help="a directory in the project, the current one by default",
+    )
+    render.add_argument(
+        "--dialect", help="the dialect to render for, in place of the project's"
+    )
 
     export = commands.add_parser(
         "export", help="write what another tool needs to read the templates"
     )
-    export.add_argument("tool", choices=("sqruff", "pycharm"))
+    export.add_argument("tool", choices=(*LINTERS, "sql-formatter", "pycharm"))
     export.add_argument(
         "--project",
         default=".",
@@ -72,11 +100,34 @@ def main(argv: list[str] | None = None) -> int:
 
     arguments = parser.parse_args(argv)
     if arguments.command == "check":
-        return _check(Path(arguments.project), json_output=arguments.format == "json")
+        return _check(
+            Path(arguments.project),
+            json_output=arguments.format == "json",
+            lint=arguments.lint,
+            dialect=arguments.dialect,
+        )
+    if arguments.command == "render":
+        return _render(
+            Path(arguments.project), Path(arguments.out), dialect=arguments.dialect
+        )
     if arguments.command == "export":
-        export = _export_pycharm if arguments.tool == "pycharm" else _export_sqruff
-        return export(
-            Path(arguments.project), dialect=arguments.dialect, check=arguments.check
+        if arguments.tool == "sql-formatter":
+            return _export_sql_formatter(
+                Path(arguments.project),
+                dialect=arguments.dialect,
+                check=arguments.check,
+            )
+        if arguments.tool == "pycharm":
+            return _export_pycharm(
+                Path(arguments.project),
+                dialect=arguments.dialect,
+                check=arguments.check,
+            )
+        return _export_linter(
+            arguments.tool,
+            Path(arguments.project),
+            dialect=arguments.dialect,
+            check=arguments.check,
         )
     if arguments.command == "macros":
         return _macros(
@@ -133,11 +184,14 @@ def _load(directory: Path, *, json_output: bool = False) -> Project | None:
         return None
 
 
-def _check(directory: Path, *, json_output: bool) -> int:
+def _check(
+    directory: Path, *, json_output: bool, lint: str | None, dialect: str | None
+) -> int:
     """Print what is wrong with the project's templates, and fail if anything is.
 
-    The exit is 1 for problems in the templates, and 2 for a project that cannot
-    be read, or holds no template to check.
+    With a linter, every template is rendered too, and what it cannot parse is
+    a problem. The exit is 1 for problems in the templates, and 2 for a project
+    that cannot be read, holds no template to check, or cannot be linted.
     """
     project = _load(directory, json_output=json_output)
     if project is None:
@@ -148,6 +202,12 @@ def _check(directory: Path, *, json_output: bool) -> int:
         _say(json.dumps({"error": message}) if json_output else message)
         return 2
     problems = list(project.problems())
+    if lint is not None:
+        try:
+            problems.extend(_lint(project, lint, dialect))
+        except _CannotRenderError as error:
+            _say(json.dumps({"error": str(error)}) if json_output else str(error))
+            return 2
     if json_output:
         _say(json.dumps([_as_json(problem) for problem in problems], indent=2))
     else:
@@ -165,21 +225,132 @@ def _check(directory: Path, *, json_output: bool) -> int:
     return 1 if problems else 0
 
 
-def _export_sqruff(directory: Path, *, dialect: str | None, check: bool) -> int:
-    """Write the `sqruff` settings that read the templates into `pyproject.toml`."""
+_WRITTEN = {"given": "every parameter given", "not_given": "no parameter given"}
+
+
+class _CannotRenderError(Exception):
+    """Why the templates cannot be rendered, or the rendering linted."""
+
+
+def _lint(project: Project, name: str, given: str | None) -> list[Problem]:
+    """Return where the linter cannot parse what the templates render.
+
+    Raises:
+        _CannotRenderError: if the linter cannot read the templates as the
+            project is set up.
+
+    """
+    linter = LINTERS[name]
+    if shutil.which(name) is None:
+        problem = f"`{name}` is not installed, so the rendered SQL cannot be linted"
+        raise _CannotRenderError(problem)
+    pyproject = project.root / "pyproject.toml"
+    text = pyproject.read_text(encoding="utf-8") if pyproject.exists() else ""
+    if stale(linter, project, text):
+        problem = (
+            f"the `{name}` settings do not read the templates: run "
+            f"`sqlakit export {name}` first"
+        )
+        raise _CannotRenderError(problem)
+    configured = dialect_of(linter, text)
+    chosen = _dialect_to_render(project, given, configured)
+    if configured is not None and configured != chosen:
+        problem = (
+            f"the templates render on {chosen}, and `{name}` reads {configured}: "
+            f"pass --dialect {configured}, or set the dialect in `[tool.{name}.core]`"
+        )
+        raise _CannotRenderError(problem)
+    try:
+        import_macros(project)
+    except Exception as error:
+        problem = (
+            f"the project's macros cannot be imported: {type(error).__name__}: {error}"
+        )
+        raise _CannotRenderError(problem) from error
+    return unparsed(project, linter, chosen)
+
+
+def _dialect_to_render(
+    project: Project, given: str | None, configured: str | None = None
+) -> str:
+    """Return the dialect to render the templates on.
+
+    `--dialect` wins, then the one the project's database URL names, then the
+    one a linter's settings read in. A macro writes by `ctx.dialect`, so a
+    guess would render SQL the database never gets.
+
+    Raises:
+        _CannotRenderError: if nothing names one.
+
+    """
+    chosen = given or project.dialect or configured
+    if chosen is None:
+        problem = (
+            "the code names no database URL to take the dialect from: pass --dialect"
+        )
+        raise _CannotRenderError(problem)
+    return chosen.lower()
+
+
+def _render(directory: Path, out: Path, *, dialect: str | None) -> int:
+    """Write each template twice, rendered with its parameters given and not.
+
+    The project's Python macros are imported and run, so what they write is
+    in the SQL. Exit 1 when a template cannot be rendered.
+    """
+    project = _load(directory)
+    if project is None:
+        return 2
+    try:
+        import_macros(project)
+    except Exception as error:  # noqa: BLE001 - the project's code raises anything
+        _say(
+            f"the project's macros cannot be imported: {type(error).__name__}: {error}"
+        )
+        return 2
+    try:
+        chosen = _dialect_to_render(project, dialect)
+    except _CannotRenderError as error:
+        _say(str(error))
+        return 2
+    problems = 0
+    count = 0
+    for one in rendered(project, chosen):
+        if one.sql is None:
+            problems += 1
+            _say(f"{one.name} ({one.variant}): {one.problem}")
+            continue
+        target = out / f"{one.name.removesuffix('.sql')}.{one.variant}.sql"
+        target.parent.mkdir(parents=True, exist_ok=True)
+        header = [f"-- {one.name} on {chosen}, {_WRITTEN[one.variant]}"]
+        if one.kept:
+            header.append(
+                f"-- {', '.join(one.kept)} could not be made, and stays a call"
+            )
+        target.write_text("\n".join(header) + "\n" + one.sql, encoding="utf-8")
+        count += 1
+    _say(f"wrote {count} files to {_relative(out)}")
+    return 1 if problems else 0
+
+
+def _export_linter(
+    name: str, directory: Path, *, dialect: str | None, check: bool
+) -> int:
+    """Write the settings of `sqruff` or `sqlfluff` that read the templates."""
+    linter = LINTERS[name]
     project = _load(directory)
     if project is None:
         return 2
     pyproject = project.root / "pyproject.toml"
     text = pyproject.read_text(encoding="utf-8") if pyproject.exists() else ""
     if check:
-        tables = stale(project, text)
+        tables = stale(linter, project, text)
         if tables:
-            _say(f"{', '.join(tables)} out of date: run `sqlakit export sqruff`")
+            _say(f"{', '.join(tables)} out of date: run `sqlakit export {name}`")
             return 1
         return 0
     try:
-        written = settings(project, text, dialect)
+        written = settings(linter, project, text, dialect)
     except ProjectConfigError as error:
         _say(str(error))
         return 2
@@ -188,6 +359,28 @@ def _export_sqruff(directory: Path, *, dialect: str | None, check: bool) -> int:
     return 0
 
 
+def _export_sql_formatter(directory: Path, *, dialect: str | None, check: bool) -> int:
+    """Write the `.sql-formatter.json` that reads `:name` as a parameter."""
+    project = _load(directory)
+    if project is None:
+        return 2
+    path = project.root / _sql_formatter.FILE
+    written = path.read_text(encoding="utf-8") if path.exists() else None
+    if check:
+        if _sql_formatter.stale(written):
+            _say(f"{_relative(path)} out of date: run `sqlakit export sql-formatter`")
+            return 1
+        return 0
+    try:
+        text = _sql_formatter.config(project, written, dialect)
+    except ProjectConfigError as error:
+        _say(str(error))
+        return 2
+    path.write_text(text, encoding="utf-8")
+    _say(f"wrote {_relative(path)}")
+    return 0
+
+
 def _export_pycharm(directory: Path, *, dialect: str | None, check: bool) -> int:
     """Write what PyCharm needs into `.idea/`: the macros as DDL, and the dialect."""
     project = _load(directory)