sqlakit-lsp 0.3.0__tar.gz → 0.3.2__tar.gz

{sqlakit_lsp-0.3.0 → sqlakit_lsp-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlakit-lsp
-Version: 0.3.0
+Version: 0.3.2
 Summary: The language server for SQLAKit templates.
 Keywords: sqlalchemy,sqlakit,lsp,language-server,sql
 Author: Anton Ruhlov
@@ -41,7 +41,8 @@ templates. In a `.sql` template:
 - the macros' calls and the parameters coloured
 - a parameter no call of the project passes, marked, with a quick fix for a
   name close to one the calls pass
-- **Show rendered SQL**, the whole template as the SQL it writes
+- **Show rendered SQL**, the whole template as the SQL it writes, with `:name`
+  or with `?` for each parameter
 - the outline of a template, and a search for a macro or a template
 
 In Python, the template name in `db.sql("...")` completes and links to its

{sqlakit_lsp-0.3.0 → sqlakit_lsp-0.3.2}/README.md

@@ -14,7 +14,8 @@ templates. In a `.sql` template:
 - the macros' calls and the parameters coloured
 - a parameter no call of the project passes, marked, with a quick fix for a
   name close to one the calls pass
-- **Show rendered SQL**, the whole template as the SQL it writes
+- **Show rendered SQL**, the whole template as the SQL it writes, with `:name`
+  or with `?` for each parameter
 - the outline of a template, and a search for a macro or a template
 
 In Python, the template name in `db.sql("...")` completes and links to its

{sqlakit_lsp-0.3.0 → sqlakit_lsp-0.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sqlakit-lsp"
-version = "0.3.0"
+version = "0.3.2"
 description = "The language server for SQLAKit templates."
 readme = "README.md"
 license = "MIT"

{sqlakit_lsp-0.3.0 → sqlakit_lsp-0.3.2}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "sqlakit-lsp"
-version = "0.3.0"
+version = "0.3.2"
 description = "The language server for SQLAKit templates."
 readme = "README.md"
 license = "MIT"

sqlakit_lsp-0.3.2/sqlakit_lsp/_live.py

@@ -0,0 +1,92 @@
+"""Render a template with the project's own macros, in the project's Python.
+
+The server reads the project's code and never runs it, so a macro written in
+Python stays a call when it renders a template. **Show rendered SQL** asks for
+more: the server runs this file with the project's interpreter, which imports
+the modules of those macros, and prints the SQL as JSON.
+
+It reads its request as JSON on stdin, and imports nothing of the server: the
+project's environment has `sqlakit`, and not the server.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+from typing import Any
+
+
+class _Example:
+    """A value to render a template with: any path reads another of it."""
+
+    def __getattr__(self, _: str) -> _Example:
+        return self
+
+    def __getitem__(self, _: object) -> _Example:
+        return self
+
+    def __iter__(self) -> Any:  # noqa: ANN401
+        return iter((self,))
+
+    def __len__(self) -> int:
+        return 1
+
+    def __str__(self) -> str:
+        return "x"
+
+
+def _module(path: Path) -> tuple[Path, str]:
+    """Return the directory a module is imported from, and its dotted name."""
+    parts = [path.stem]
+    folder = path.parent
+    while (folder / "__init__.py").is_file():
+        parts.append(folder.name)
+        folder = folder.parent
+    return folder, ".".join(reversed(parts))
+
+
+def _preparer(dialect: str) -> Any:  # noqa: ANN401
+    import sqlalchemy as sa  # noqa: PLC0415
+    import sqlalchemy.engine.default  # noqa: PLC0415
+    import sqlalchemy.exc  # noqa: PLC0415
+
+    try:
+        return sa.engine.make_url(f"{dialect}://").get_dialect()().identifier_preparer
+    except sa.exc.NoSuchModuleError:
+        default = sa.engine.default.DefaultDialect()
+        default.name = dialect
+        return default.identifier_preparer
+
+
+def main() -> None:
+    request = json.load(sys.stdin)
+    from sqlakit._project import load_project  # noqa: PLC0415
+    from sqlakit._sql import Context, calls_kept, registered  # noqa: PLC0415
+
+    project = load_project(Path(request["root"]))
+    for file in request["modules"]:
+        folder, name = _module(Path(file))
+        if str(folder) not in sys.path:
+            sys.path.insert(0, str(folder))
+        try:
+            found = registered([name])
+        except Exception as error:  # noqa: BLE001 - the project's code raises anything
+            sys.stdout.write(
+                json.dumps({"error": f"{name} cannot be imported: {error}"}) + "\n"
+            )
+            return
+        project.templates.macros.update(
+            (key, macro) for key, macro in found.items() if key in request["macros"]
+        )
+    template = project.load(request["name"], request["source"])
+    values: dict[str, Any] = dict.fromkeys(template.parameters(), _Example())
+    values.update(dict.fromkeys(request["not_given"]))
+    dialect = request["dialect"]
+    with calls_kept():
+        sql = template.render(Context(dialect, _preparer(dialect), values)).strip()
+    sys.stdout.write(json.dumps({"sql": sql}) + "\n")
+
+
+if __name__ == "__main__":
+    main()

{sqlakit_lsp-0.3.0 → sqlakit_lsp-0.3.2}/sqlakit_lsp/_server.py

@@ -23,8 +23,10 @@ import asyncio
 import bisect
 import difflib
 import inspect
+import json
 import os
 import re
+import subprocess
 import tempfile
 import uuid
 from collections import OrderedDict
@@ -157,6 +159,66 @@ def _innermost(parts: Sequence[Any], offset: int) -> Any:  # noqa: ANN401
     return None
 
 
+_BOUND = re.compile(
+    rf"{_LITERAL}|(?<![:\w\\]):(?P<bound>[A-Za-z_]\w*)(?![\w:])", re.DOTALL
+)
+"""A placeholder of rendered SQL, and the strings and comments to skip."""
+
+_LIVE = Path(__file__).with_name("_live.py")
+"""The script the project's interpreter renders a template with."""
+
+_LIVE_SECONDS = 20
+"""How long a render with the project's macros may take: it imports them."""
+
+
+def _interpreter(root: Path) -> Path | None:
+    """Return the Python of the project's `.venv`, if it has one."""
+    for found in (
+        root / ".venv" / "bin" / "python",
+        root / ".venv" / "Scripts" / "python.exe",
+    ):
+        if found.is_file():
+            return found
+    return None
+
+
+def _run_live(root: Path, request: dict[str, Any]) -> tuple[str | None, str]:
+    """Render a template in the project's interpreter: the SQL, or why not."""
+    python = _interpreter(root)
+    if python is None:
+        return None, "the project has no .venv to run its macros in."
+    try:
+        done = subprocess.run(  # noqa: S603 - the project's own interpreter
+            [str(python), str(_LIVE)],
+            input=json.dumps(request),
+            capture_output=True,
+            text=True,
+            cwd=root,
+            timeout=_LIVE_SECONDS,
+            check=False,
+        )
+    except (OSError, subprocess.TimeoutExpired) as error:
+        return None, f"running {_relative(python, root)} failed: {error}"
+    try:
+        answer = json.loads(done.stdout.strip().splitlines()[-1])
+    except (IndexError, ValueError):
+        last = (done.stderr.strip().splitlines() or ["no output"])[-1]
+        return None, f"{_relative(python, root)} failed: {last}"
+    if "sql" in answer:
+        return answer["sql"], ""
+    return None, str(answer.get("error", "no SQL came back"))
+
+
+def _calls(parts: Sequence[Any]) -> Iterator[Any]:
+    """Yield every macro call of a read template, the ones in arguments too."""
+    for part in parts:
+        if isinstance(part, str):
+            continue
+        yield part
+        for argument in part.args:
+            yield from _calls(argument.parts)
+
+
 def _rendered(template: Any, dialect: str, values: dict[str, Any]) -> str | None:  # noqa: ANN401
     """Return the SQL a read template writes for these values, if it can.
 
@@ -327,6 +389,9 @@ _WORD = re.compile(r"\w+")
 SHOW = "Show rendered SQL"
 """The title of the action that shows a whole template as SQL."""
 
+SHOW_MARKED = "Show rendered SQL with ?"
+"""The title of the action that shows it with `?` for each parameter."""
+
 RENDER = "sqlakit.render"
 """The command that writes a whole template as SQL, for an editor to open."""
 
@@ -815,7 +880,13 @@ class _Assistant:
         """Return the whole template as the database gets it, on the project's dialect.
 
         Every parameter counts as given, so every optional part is there, and
-        stays a placeholder. A call that cannot be made so stays a call.
+        stays a placeholder. A parameter a built-in macro cannot take made up,
+        the column `tpl.order_by` sorts by, counts as not given.
+
+        The server reads the project's Python macros and does not run them, so
+        when the template calls one, it is rendered again by the project's own
+        interpreter, `.venv/bin/python`, which imports them. Without one, or
+        when that fails, the calls stay calls, and a comment on top says why.
         """
         name = self.project.name_of(path) or path.name
         dialect = self.project.dialect or "postgresql"
@@ -823,11 +894,102 @@ class _Assistant:
             template = self.compiled(name, source)
         except SQLAKitError as error:
             return f"-- {name} cannot be read: {error}\n"
-        values = dict.fromkeys(template.parameters(), _Example())
+        calls = list(_calls(template.parts))
+        values: dict[str, Any] = dict.fromkeys(template.parameters(), _Example())
+        values.update(dict.fromkeys(self._not_given(name, source, calls, dialect)))
         sql = _rendered(template, dialect, values)
         if sql is None:
             return f"-- {name} cannot be written with made-up values.\n"
-        return f"-- {name} on {dialect}\n{sql}\n"
+        namespace = self.project.templates.namespace
+        # A call of an included template is in the SQL too, and not in `calls`.
+        static = {
+            key: macro
+            for key, macro in self.project.templates.macros.items()
+            if isinstance(macro, StaticMacro)
+        }
+        kept = {
+            key: macro
+            for key, macro in static.items()
+            if re.search(rf"(?<![\w.]){namespace}\.{key}\s*\(", sql, re.IGNORECASE)
+        }
+        if not kept:
+            return f"-- {name} on {dialect}\n{sql}\n"
+        request = {
+            "root": str(self.project.root),
+            "name": name,
+            "source": source,
+            "dialect": dialect,
+            # Every one, as a macro may call another inside, as a file macro's SQL does.
+            "modules": sorted({str(macro.path) for macro in static.values()}),
+            "macros": sorted(static),
+            "not_given": sorted(key for key, value in values.items() if value is None),
+        }
+        run, problem = _run_live(self.project.root, request)
+        if run is not None:
+            return f"-- {name} on {dialect}\n{run}\n"
+        listed = ", ".join(f"{namespace}.{key}" for key in sorted(kept))
+        return f"-- {name} on {dialect}\n-- {listed} stays a call: {problem}\n{sql}\n"
+
+    def rendered_marked(self, path: Path, source: str) -> str:
+        """Return the rendered template with `?` for each parameter, in order.
+
+        A comment on top lists what each `?` stands for, as a driver that
+        takes `?` is given the values in that order.
+        """
+        text = self.rendered(path, source)
+        names: list[str] = []
+
+        def marked(found: re.Match[str]) -> str:
+            name = found.group("bound")
+            if name is None:
+                return found.group(0)
+            names.append(name)
+            return "?"
+
+        text = _BOUND.sub(marked, text)
+        if not names:
+            return text
+        first, _, rest = text.partition("\n")
+        listed = ", ".join(f":{name}" for name in names)
+        return f"{first}\n-- ? in order: {listed}\n{rest}"
+
+    def _not_given(
+        self, name: str, source: str, calls: Sequence[Any], dialect: str
+    ) -> set[str]:
+        """Return the parameters to render as not given.
+
+        They are those of a call of a built-in macro that cannot be made with a
+        made-up value, and can with none: `:sort` of `tpl.order_by`, whose value
+        must be a column it lists.
+        """
+        found: set[str] = set()
+        for call in calls:
+            if isinstance(self.project.templates.macros.get(call.name), StaticMacro):
+                continue
+            text = source[call.span[0] : call.span[1]]
+            try:
+                alone = self.compiled(name, text)
+            except SQLAKitError:
+                continue
+            names = alone.parameters()
+            given = _rendered(alone, dialect, dict.fromkeys(names, _Example()))
+            if names and self._kept(given, call.name):
+                missing = _rendered(alone, dialect, dict.fromkeys(names))
+                if not self._kept(missing, call.name):
+                    found.update(names)
+        return found
+
+    def _kept(self, sql: str | None, macro: str) -> bool:
+        """Whether a call rendered alone could not be made, and wrote itself.
+
+        It writes itself on one line, whatever lines it was written on.
+        """
+        if sql is None:
+            return True
+        namespace = re.escape(self.project.templates.namespace)
+        return bool(
+            re.match(rf"{namespace}\.{re.escape(macro)}\s*\(", sql, re.IGNORECASE)
+        )
 
     def holds_macros(self, path: Path) -> bool:
         """Whether a file defines macros: SQL macros, or the SQL of a file macro."""
@@ -911,7 +1073,7 @@ class _Assistant:
         missing = _rendered(alone, dialect, dict.fromkeys(names))
         # A call that cannot be made writes itself, which says nothing new.
         given, missing = (
-            None if one == text.strip() else one for one in (given, missing)
+            None if self._kept(one, call.name) else one for one in (given, missing)
         )
         if not names or given == missing:
             one = given or missing
@@ -2454,21 +2616,30 @@ def _server() -> Any:  # noqa: ANN401, C901, PLR0915 - a handler for each reques
         support = None if action is None else action.resolve_support
         return bool(support is not None and "edit" in support.properties)
 
-    def rendered_file(ls: LanguageServer, uri: str) -> tuple[Path, str]:
+    def rendered_file(
+        ls: LanguageServer, uri: str, *, marked: bool = False
+    ) -> tuple[Path, str]:
         """Return a new file for the rendered template, and what goes in it."""
         helper = assistant()
         path = _path(uri)
         source = ls.workspace.get_text_document(uri).source
         name = helper.project.name_of(path) or path.name if helper else path.name
-        text = helper.rendered(path, source) if helper else ""
+        if helper is None:
+            text = ""
+        elif marked:
+            text = helper.rendered_marked(path, source)
+        else:
+            text = helper.rendered(path, source)
         # A new file each time: the editor may still hold the one before.
         written = _RENDERED / uuid.uuid4().hex[:8] / name
         written.parent.mkdir(parents=True, exist_ok=True)
         return written, text
 
-    def rendered_edit(ls: LanguageServer, uri: str) -> types.WorkspaceEdit:
+    def rendered_edit(
+        ls: LanguageServer, uri: str, *, marked: bool = False
+    ) -> types.WorkspaceEdit:
         """Return an edit that makes the file of the rendered template."""
-        written, text = rendered_file(ls, uri)
+        written, text = rendered_file(ls, uri, marked=marked)
         target = written.as_uri()
         start = types.Position(0, 0)
         return types.WorkspaceEdit(
@@ -2502,14 +2673,18 @@ def _server() -> Any:  # noqa: ANN401, C901, PLR0915 - a handler for each reques
             return actions or None
         if not path.name.endswith(".sql"):
             return actions or None
-        action = types.CodeAction(title=SHOW, kind=types.CodeActionKind.Empty)
-        if shows_documents(ls):
-            action.command = types.Command(title=SHOW, command=RENDER, arguments=[uri])
-        elif resolves_edits(ls):
-            action.data = {"uri": uri}
-        else:
-            action.edit = rendered_edit(ls, uri)
-        return [*actions, action]
+        for title, marked in ((SHOW, False), (SHOW_MARKED, True)):
+            action = types.CodeAction(title=title, kind=types.CodeActionKind.Empty)
+            if shows_documents(ls):
+                action.command = types.Command(
+                    title=title, command=RENDER, arguments=[uri, marked]
+                )
+            elif resolves_edits(ls):
+                action.data = {"uri": uri, "marked": marked}
+            else:
+                action.edit = rendered_edit(ls, uri, marked=marked)
+            actions.append(action)
+        return actions
 
     def fixes(ls: LanguageServer, params: Any) -> list[types.CodeAction]:  # noqa: ANN401
         """Return a quick fix for each problem of ours the editor sends along.
@@ -2552,13 +2727,15 @@ def _server() -> Any:  # noqa: ANN401, C901, PLR0915 - a handler for each reques
         """Work out the edit of an action once the editor has chosen it."""
         data = action.data or {}
         if "uri" in data:
-            action.edit = rendered_edit(ls, data["uri"])
+            action.edit = rendered_edit(
+                ls, data["uri"], marked=bool(data.get("marked"))
+            )
         return action
 
     @server.command(RENDER)
-    async def render(ls: LanguageServer, uri: str) -> None:
+    async def render(ls: LanguageServer, uri: str, marked: bool = False) -> None:  # noqa: FBT001, FBT002 - a command's arguments come in order
         """Write the rendered template to a file, and have the editor open it."""
-        written, text = rendered_file(ls, uri)
+        written, text = rendered_file(ls, uri, marked=marked)
         written.write_text(text, encoding="utf-8")
         await ls.window_show_document_async(
             types.ShowDocumentParams(written.as_uri(), take_focus=True)