sqlakit-lsp 0.1.1__tar.gz → 0.2.0__tar.gz

{sqlakit_lsp-0.1.1 → sqlakit_lsp-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlakit-lsp
-Version: 0.1.1
+Version: 0.2.0
 Summary: The language server for SQLAKit templates.
 Keywords: sqlalchemy,sqlakit,lsp,language-server,sql
 Author: Anton Ruhlov

{sqlakit_lsp-0.1.1 → sqlakit_lsp-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sqlakit-lsp"
-version = "0.1.1"
+version = "0.2.0"
 description = "The language server for SQLAKit templates."
 readme = "README.md"
 license = "MIT"
@@ -131,7 +131,7 @@ dev = [
     "pytest>=9.1.1",
     "pytest-cov>=7.1.0",
     "anyio>=4.14.2",
-    "ty>=0.0.80",
+    "ty>=0.0.84",
     "ruff>=0.16.6",
     "poethepoet>=0.48.0",
     "codespell>=2.4.3",

{sqlakit_lsp-0.1.1 → sqlakit_lsp-0.2.0}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "sqlakit-lsp"
-version = "0.1.1"
+version = "0.2.0"
 description = "The language server for SQLAKit templates."
 readme = "README.md"
 license = "MIT"
@@ -22,8 +22,6 @@ classifiers = [
 ]
 requires-python = ">=3.11"
 dependencies = [
-    # The server reads the private modules of `sqlakit`, which a minor version
-    # may change.
     "sqlakit>=0.21.0,<0.23",
     "pygls>=2.1,<3",
 ]
@@ -51,7 +49,7 @@ dev = [
     "pytest>=9.1.1",
     "pytest-cov>=7.1.0",
     "anyio>=4.14.2",
-    "ty>=0.0.80",
+    "ty>=0.0.84",
     "ruff>=0.16.6",
     "poethepoet>=0.48.0",
     "codespell>=2.4.3",

{sqlakit_lsp-0.1.1 → sqlakit_lsp-0.2.0}/sqlakit_lsp/_server.py

@@ -23,16 +23,18 @@ import asyncio
 import bisect
 import difflib
 import inspect
+import os
 import re
 import tempfile
 import uuid
 from collections import OrderedDict
-from dataclasses import dataclass, field
-from functools import lru_cache
+from dataclasses import dataclass, field, replace
+from functools import cached_property, lru_cache
 from importlib.metadata import version
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
+import sqlakit
 import sqlalchemy as sa
 import sqlalchemy.engine.default
 import sqlalchemy.exc
@@ -421,6 +423,34 @@ class _Assistant:
         resolved = path.resolve()
         return any(resolved in files for files in self._files)
 
+    def _source(self, macro: Macro) -> Target | None:
+        """Return where a macro is written, in the project's own `sqlakit`.
+
+        A server that `uvx` runs imports `sqlakit` from a cache of its own. The
+        project holds the same version in `.venv`, which is the file to open.
+        """
+        target = _source_of(macro)
+        if target is None or self._library is None:
+            return target
+        try:
+            inside = target.path.resolve().relative_to(_LIBRARY)
+        except ValueError:
+            return target
+        return replace(target, path=self._library / inside)
+
+    @cached_property
+    def _library(self) -> Path | None:
+        """Return the project's `sqlakit` in `.venv`, when it is this version."""
+        installed = f"sqlakit-{version('sqlakit')}.dist-info"
+        for site in (
+            *self._root.glob(".venv/lib/python*/site-packages"),
+            self._root / ".venv/Lib/site-packages",
+        ):
+            library = site / "sqlakit"
+            if (site / installed).is_dir() and library.resolve() != _LIBRARY:
+                return library
+        return None
+
     def owns(self, path: Path) -> bool:
         """Whether a file is the project's own, where `walk` goes.
 
@@ -447,9 +477,27 @@ class _Assistant:
     def names(self) -> list[str]:
         """Every template's name, read once until `forget_files`."""
         if self._names is None:
-            self._names = self.project.templates.names()
+            self._names = sorted(self._on_disk())
         return self._names
 
+    def _on_disk(self) -> dict[str, Path]:
+        """Return each template's name and file, as `Templates.names` finds them.
+
+        One walk of the directories, in strings: a file made has the next
+        keystroke read them again, and paths cost more than the walk.
+        """
+        skipped = {str(path) for path in self._macro_files | self._macro_sql}
+        found: dict[str, Path] = {}
+        for root in self._template_roots:
+            start = len(str(root)) + 1
+            for directory, _, files in os.walk(root):
+                for file in files:
+                    written = os.path.join(directory, file)  # noqa: PTH118 - strings, for speed
+                    if file.endswith(".sql") and written not in skipped:
+                        name = written[start:].replace(os.sep, "/")
+                        found.setdefault(name, Path(written))
+        return found
+
     def defines_macros(self, path: Path) -> bool:
         """Whether a file defines a macro the project calls, its own or built in.
 
@@ -460,7 +508,7 @@ class _Assistant:
             self._sources = {
                 target.path.resolve()
                 for macro in self.project.templates.macros.values()
-                if (target := _source_of(macro)) is not None
+                if (target := self._source(macro)) is not None
             }
         return path.resolve() in self._sources
 
@@ -688,7 +736,7 @@ class _Assistant:
                     signature_of(macro, namespace),
                 )
                 for macro in self.project.templates.macros.values()
-                if (target := _source_of(macro)) is not None
+                if (target := self._source(macro)) is not None
             ]
             everything.extend(
                 (name, "template", Target(path, 0), "")
@@ -942,7 +990,7 @@ class _Assistant:
                 return None if path is None else Target(path, 0)
         macro = self.project.templates.macros.get(self._macro_at(source, offset) or "")
         if macro is not None:
-            return _source_of(macro)
+            return self._source(macro)
         if path is None:
             return None
         # The SQL of `@sql_macro("file.sql")` goes to its function.
@@ -963,7 +1011,7 @@ class _Assistant:
         if macro is None or sql is None:
             return None
         if Path(sql).resolve() == path.resolve():
-            return _source_of(macro)
+            return self._source(macro)
         statement = next(
             (one for one in sql_macros(Path(sql)) if one.name == macro.name), None
         )
@@ -1002,7 +1050,7 @@ class _Assistant:
             return next(
                 (
                     (start, end)
-                    for start, end, _ in _template_names(source)
+                    for start, end, _ in self._files_named(source, path)
                     if start <= offset <= end
                 ),
                 defined,
@@ -1100,25 +1148,46 @@ class _Assistant:
     def python_definition(
         self, source: str, offset: int, path: Path | None = None
     ) -> Target | None:
-        """Return the template the name under the offset reads.
+        """Return the file the name under the offset reads.
 
-        On the name of a `def` that defines a macro, that is the name itself.
+        That is a template in `db.sql("...")`, or the SQL of a macro in
+        `@sql_macro("...")`. On the name of a `def` that defines a macro, it is
+        the name itself.
         """
-        for start, end, name in _template_names(source):
+        for start, end, found in self._files_named(source, path):
             if start <= offset <= end:
-                found = self.project.path_of(name)
-                return None if found is None else Target(found, 0)
+                return Target(found, 0)
         return None if path is None else self._itself(path, source, offset)
 
+    def _files_named(
+        self, source: str, path: Path | None
+    ) -> list[tuple[int, int, Path]]:
+        """Return each file the Python names, where the name is, and the file.
+
+        A template is looked for under the template directories, and the SQL of
+        `@sql_macro("...")` next to the module, as `sql_macro` reads it.
+        """
+        found = [
+            (start, end, target)
+            for start, end, name in _template_names(source)
+            if (target := self.project.path_of(name)) is not None
+        ]
+        if path is not None:
+            found.extend(
+                (start, end, target)
+                for start, end, name in _sql_macro_files(source)
+                if (target := path.parent / name).is_file()
+            )
+        return found
+
     def links(self, path: Path, source: str) -> list[tuple[int, int, Path]]:
-        """Return each template the text names, where the name is, and its file."""
-        if self.reads_python(path):
-            named = _template_names(source)
-        else:
-            named = [
-                (found.start(1), found.end(1), found.group(1))
-                for found in self._include_path.finditer(source)
-            ]
+        """Return each file the text names, where the name is, and the file."""
+        if path.suffix == ".py":
+            return self._files_named(source, path)
+        named = [
+            (found.start(1), found.end(1), found.group(1))
+            for found in self._include_path.finditer(source)
+        ]
         return [
             (start, end, target)
             for start, end, name in named
@@ -1271,7 +1340,7 @@ class _Assistant:
     def declaration(self, name: str) -> Reference | None:
         """Return where a macro's name is written, for a list of its references."""
         macro = self.project.templates.macros.get(name)
-        if macro is None or (target := _source_of(macro)) is None:
+        if macro is None or (target := self._source(macro)) is None:
             return None
         text = _read(target.path)
         start = _line_span(text, target.line + 1)[0] + target.column
@@ -1300,7 +1369,7 @@ class _Assistant:
         sql = getattr(macro, "sql_path", None)
         if sql is not None and Path(sql).resolve() == path.resolve():
             return word
-        target = _source_of(macro)
+        target = self._source(macro)
         if target is None or target.path.resolve() != path.resolve():
             return None
         return word if target.line + 1 == line else None
@@ -1368,12 +1437,9 @@ class _Assistant:
         The paths are resolved, as the editor's open files are keyed.
         """
         if self._files is None:
-            named = {}
-            for name in self.names():
-                for root in self._template_roots:
-                    if (root / name).is_file():
-                        named[root / name] = name
-                        break
+            templates = self._on_disk()
+            self._names = sorted(templates)
+            named = {path: name for name, path in templates.items()}
             sql_files = [
                 *named,
                 *(path.resolve() for path in self.project.macro_files()),
@@ -1615,6 +1681,46 @@ def _template_names(source: str) -> list[tuple[int, int, str]]:
     return found
 
 
+def _sql_macro_files(source: str) -> list[tuple[int, int, str]]:
+    """Return where `@sql_macro("file.sql")` names its SQL, the quotes left out."""
+    if "sql_macro" not in source:
+        return []
+    try:
+        tree = ast.parse(source)
+    except SyntaxError:
+        return []
+    starts = _line_starts(source)
+    found = []
+    for node in ast.walk(tree):
+        if not isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef):
+            continue
+        for decorator in node.decorator_list:
+            if not (isinstance(decorator, ast.Call) and decorator.args):
+                continue
+            func = decorator.func
+            called = (
+                func.attr
+                if isinstance(func, ast.Attribute)
+                else getattr(func, "id", "")
+            )
+            name = decorator.args[0]
+            if not (
+                called == "sql_macro"
+                and isinstance(name, ast.Constant)
+                and isinstance(name.value, str)
+                and name.value.endswith(".sql")
+                and name.end_lineno is not None
+                and name.end_col_offset is not None
+            ):
+                continue
+            start = _char_offset(source, starts, name.lineno, name.col_offset)
+            end = _char_offset(source, starts, name.end_lineno, name.end_col_offset)
+            quote = source.find(name.value, start, end)
+            if quote >= 0:
+                found.append((quote, quote + len(name.value), name.value))
+    return found
+
+
 def _char_offset(source: str, starts: list[int], line: int, column: int) -> int:
     """Return the offset of a position `ast` gives, its column in UTF-8 bytes."""
     begin = starts[line - 1]
@@ -1673,6 +1779,9 @@ def _source_of(macro: Macro) -> Target | None:
 
 _DEF = re.compile(r"\s*(?:async\s+)?def\s+(\w+)")
 
+_LIBRARY = Path(sqlakit.__file__).resolve().parent
+"""The `sqlakit` this server imports."""
+
 
 @dataclass(frozen=True, slots=True)
 class _At: