sqlakit 0.21.0__tar.gz → 0.22.1__tar.gz

{sqlakit-0.21.0 → sqlakit-0.22.1}/PKG-INFO

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

{sqlakit-0.21.0 → sqlakit-0.22.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sqlakit"
-version = "0.21.0"
+version = "0.22.1"
 description = "A toolkit for SQLAlchemy applications."
 readme = "README.md"
 license = "MIT"

{sqlakit-0.21.0 → sqlakit-0.22.1}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "sqlakit"
-version = "0.21.0"
+version = "0.22.1"
 description = "A toolkit for SQLAlchemy applications."
 readme = "README.md"
 license = "MIT"

{sqlakit-0.21.0 → sqlakit-0.22.1}/sqlakit/_project.py

@@ -48,7 +48,7 @@ from .exceptions import (
 )
 
 if TYPE_CHECKING:
-    from collections.abc import Iterator
+    from collections.abc import Collection, Iterable, Iterator
 
 __all__ = ["Problem", "Project", "load_project"]
 
@@ -70,11 +70,13 @@ RESERVED = RESERVED_WORDS | POSTGRESQL_RESERVED_WORDS
 """Words a parameter cannot stand in for unquoted, on the databases linted most."""
 """Names SQL keeps for itself, which a linter cannot read a parameter as."""
 
-LINT_EXCLUDED = ("RF01", "AL05", "ST03")
+LINT_EXCLUDED = ("RF01", "RF02", "RF03", "AL05", "ST03")
 """Rules a `tpl.` call trips without anything being wrong with the template.
 
-`RF01` reads `tpl.if_set` as a column of a table named `tpl`, and `AL05` and
-`ST03` miss an alias or a CTE used only inside a macro's argument.
+`RF01` reads `tpl.if_set` as a column of a table named `tpl`. `RF02` and `RF03`,
+outside `sqruff`'s default rules, read a table a macro takes, `tpl.paid(o)`, as
+a column. `AL05` and `ST03` miss an alias or a CTE used only inside a macro's
+argument.
 """
 
 
@@ -212,7 +214,23 @@ class Project:
             if found.group("macro")
         ]
 
-    def placeholder_values(self) -> dict[str, str]:
+    def parameter_names(self) -> set[str]:
+        """Return the name of every `:parameter` the templates and macros read."""
+        names: set[str] = set()
+        for path in self._linted_files():
+            text = path.read_text(encoding="utf-8", errors="replace")
+            names.update(
+                found.group("param")
+                for found in _PARAMETER_IN_TEXT.finditer(text)
+                if found.group("param")
+            )
+        return names
+
+    def _linted_files(self) -> set[Path]:
+        paths = [self.path_of(name) for name in self.templates.names()]
+        return {*(one for one in paths if one is not None), *self.macro_files()}
+
+    def placeholder_values(self, reserved: Iterable[str] = ()) -> dict[str, str]:
         """Return a value for each parameter a linter cannot read by its name.
 
         With no value, the `placeholder` templater writes a parameter's name in
@@ -221,12 +239,14 @@ class Project:
         writes to, a linter reads only `@stage/path`,
         and inside `SAMPLE (...)` only a number. A name SQL reserves reads as
         neither, `LIMIT :limit` reading `LIMIT limit`, so it gets `1`, or its
-        name with `_` after it when a path follows, `:order.id`.
+        name with `_` after it when a path follows, `:order.id`. ``reserved``
+        adds the words a linter's dialect keeps beside those.
         """
         values: dict[str, str] = {}
-        paths = [self.path_of(name) for name in self.templates.names()]
-        for path in {*(one for one in paths if one is not None), *self.macro_files()}:
-            placeholders_of(path.read_text(encoding="utf-8", errors="replace"), values)
+        words = RESERVED | {word.lower() for word in reserved}
+        for path in self._linted_files():
+            text = path.read_text(encoding="utf-8", errors="replace")
+            placeholders_of(text, values, words)
         return dict(sorted(values.items()))
 
     def macro_files(self) -> list[Path]:
@@ -258,7 +278,9 @@ class Project:
         return found
 
 
-def placeholders_of(text: str, values: dict[str, str]) -> dict[str, str]:
+def placeholders_of(
+    text: str, values: dict[str, str], reserved: Collection[str] = RESERVED
+) -> dict[str, str]:
     """Add to ``values`` what a linter needs for each parameter of the text.
 
     See `Project.placeholder_values`, which reads every template with it.
@@ -276,7 +298,7 @@ def placeholders_of(text: str, values: dict[str, str]) -> dict[str, str]:
             values[param] = "@stage/path"
         elif SAMPLE_AFTER.search(before):
             values[param] = "10"
-        elif param.lower() in RESERVED:
+        elif param.lower() in reserved:
             # `COPY INTO :table` needs a name, and other positions a value.
             named = dotted or inline_position(before)
             values.setdefault(param, f"{param}_" if named else "1")

{sqlakit-0.21.0 → sqlakit-0.22.1}/sqlakit/_sql.py

@@ -1954,22 +1954,6 @@ def unless_set(value: Param, expr: Sql, otherwise: Sql = Sql("TRUE")) -> str:  #
     return _grouped(str(otherwise if _is_set(value.value) else expr))
 
 
-@sql_macro(optional=True, lazy=True)
-def when(value: Param, sql: Sql, *more: Sql) -> str:
-    """Write `sql` when the parameter holds a value, and nothing when it does not.
-
-    For a clause that is there or not, rather than a condition that is true or
-    not: `tpl.when(:team, JOIN teams AS t ON t.id = u.team_id)`. `if_set`
-    writes `TRUE` in its place, which only a condition can stand.
-
-    Everything after the parameter is the clause, commas and all:
-    `tpl.when(:limit, ORDER BY score DESC, created_at DESC LIMIT :limit)`.
-    """
-    if not _is_set(value.value):
-        return ""
-    return ", ".join(str(part) for part in (sql, *more))
-
-
 @sql_macro(optional=True)
 def array(ctx: Context, values: Param, type_name: Sql = Sql("")) -> str:  # noqa: B008
     """Write a list as an array, one parameter per value.
@@ -2580,7 +2564,6 @@ BUILTIN_MACROS: Mapping[str, Macro] = {
     for macro in (
         if_set,
         unless_set,
-        when,
         order_by,
         icontains,
         icollate,

{sqlakit-0.21.0 → sqlakit-0.22.1}/sqlakit/_sqruff.py

@@ -2,15 +2,20 @@
 
 The `placeholder` templater writes each `:name` as `name`. Where that reads as
 something else, `settings` gives the parameter a value; see
-`Project.placeholder_values`.
+`Project.placeholder_values`. Which names a dialect keeps for itself is asked
+of `sqruff`, when it is installed, since its dialects keep words SQLAlchemy's
+do not: `exclude` and `row` on SQLite.
 """
 
 from __future__ import annotations
 
 import json
 import re
+import shutil
+import subprocess
+import tempfile
 import tomllib
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 from ._project import LINT_EXCLUDED
 from .exceptions import ProjectConfigError
@@ -33,7 +38,7 @@ def stale(project: Project, pyproject: str) -> list[str]:
     """Return the tables of `pyproject.toml` that no longer read the templates."""
     sqruff = tomllib.loads(pyproject).get("tool", {}).get("sqruff", {})
     written = sqruff.get("templater", {}).get("placeholder", {})
-    values = project.placeholder_values()
+    values = project.placeholder_values(_kept(project, _dialect(sqruff, None, project)))
     checked = (
         ("[tool.sqruff.core]", "core" in sqruff),
         (
@@ -59,22 +64,21 @@ def settings(project: Project, pyproject: str, dialect: str | None) -> str:
     written = dict(sqruff.get("templater", {}).get("placeholder", {}))
     written.pop("param_style", None)
     text = pyproject
+    chosen = _dialect(sqruff, dialect, project)
     if "core" not in sqruff:
-        chosen = dialect or project.dialect
-        chosen = _DIALECTS.get(chosen or "", chosen)
         core = [
             "[tool.sqruff.core]",
             *([f'dialect = "{chosen}"'] if chosen else []),
             'templater = "placeholder"',
+            'rules = "all"',
             f'exclude_rules = "{",".join(LINT_EXCLUDED)}"',
         ]
         text = text.rstrip("\n") + "\n\n" + "\n".join(core) + "\n"
-    merged = dict(sorted({**written, **project.placeholder_values()}.items()))
+    values = project.placeholder_values(_kept(project, chosen))
+    merged = dict(sorted({**written, **values}.items()))
     table = "\n".join(
         [
             "[tool.sqruff.templater.placeholder]",
-            "# `sqlakit export sqruff` writes what the templates need, and keeps",
-            "# what you add.",
             'param_style = "colon"',
             *(f"{name} = {_toml_value(value)}" for name, value in merged.items()),
         ]
@@ -97,6 +101,64 @@ def settings(project: Project, pyproject: str, dialect: str | None) -> str:
     return written_out
 
 
+def _dialect(sqruff: dict, given: str | None, project: Project) -> str | None:
+    """Return the dialect `sqruff` reads the templates in, by its name."""
+    if "core" in sqruff:
+        # sqruff reads a table without a dialect as ANSI, and so does this.
+        written = sqruff["core"].get("dialect")
+        return written if isinstance(written, str) else None
+    chosen = given or project.dialect
+    return _DIALECTS.get(chosen or "", chosen)
+
+
+def _kept(project: Project, dialect: str | None) -> set[str]:
+    """Return the parameter names `sqruff` cannot read as a column in the dialect.
+
+    Each name is linted as `SELECT <name>;`, one to a line, in one run. Without
+    `sqruff` installed, the dialects of SQLAlchemy decide alone.
+    """
+    binary = shutil.which("sqruff")
+    names = sorted(project.parameter_names())
+    if binary is None or not names:
+        return set()
+    # JSON, as the report of its own is another shape on GitHub Actions.
+    command = [binary, "lint", "--parsing-errors", "--format", "json", "-"]
+    if dialect:
+        command[2:2] = ["--dialect", dialect]
+    source = "".join(f"SELECT {name};\n" for name in names)
+    # Away from the project, so no setting of its own changes the reading.
+    with tempfile.TemporaryDirectory() as empty:
+        found = subprocess.run(  # noqa: S603 - sqruff, found on the PATH
+            command,
+            input=source,
+            capture_output=True,
+            text=True,
+            cwd=empty,
+            check=False,
+        )
+    lines = {
+        problem["range"]["start"]["line"]
+        for problems in _report(found.stdout, found.stderr).values()
+        for problem in problems
+        # The name starts after `SELECT `, at the eighth character.
+        if problem.get("message") == "Unparsable section"
+        and problem["range"]["start"]["character"] == len("SELECT ") + 1
+    }
+    return {name for number, name in enumerate(names, 1) if number in lines}
+
+
+def _report(*outputs: str) -> dict[str, list[dict[str, Any]]]:
+    """Return the JSON report, from whichever stream `sqruff` wrote it to."""
+    for output in outputs:
+        try:
+            report = json.loads(output)
+        except json.JSONDecodeError:
+            continue
+        if isinstance(report, dict):
+            return report
+    return {}
+
+
 def _toml_value(value: object) -> str:
     """Return a value as TOML writes it: a string quoted, a flag in lower case."""
     if isinstance(value, bool):