dbt-ls 0.1.1__tar.gz

dbt_ls-0.1.1/.github/workflows/ci.yml

@@ -0,0 +1,64 @@
+name: CI
+
+on:
+  push:
+    tags:
+      - '0.*'
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.10"
+
+      - name: Install project
+        run: pip install -e .
+
+      - name: Run tests
+        run: pytest -vv
+
+  build:
+    # Runs only when a version tag is pushed.
+    if: github.event_name == 'push' && startsWith(github.event.ref, 'refs/tags/')
+    needs:
+      - test
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.10"
+
+      - name: Install Hatch
+        run: pip install hatch
+
+      - name: Verify tag matches project version
+        run: |
+          VERSION="$(hatch version)"
+          TAG="${GITHUB_REF_NAME#v}"
+          echo "Project version: $VERSION"
+          echo "Tag version:     $TAG"
+          if [ "$VERSION" != "$TAG" ]; then
+            echo "::error::Tag '$GITHUB_REF_NAME' does not match project version '$VERSION'."
+            exit 1
+          fi
+
+      - name: Build
+        run: hatch build
+
+      - name: Upload build artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/

dbt_ls-0.1.1/.gitignore

@@ -0,0 +1,12 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+
+.act

dbt_ls-0.1.1/.python-version

@@ -0,0 +1 @@
+3.10

dbt_ls-0.1.1/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: dbt-ls
+Version: 0.1.1
+Summary: Add your description here
+Author-email: HuhtaLauri <huhta.lauri@gmail.com>
+Requires-Python: >=3.10
+Requires-Dist: black>=25.12.0
+Requires-Dist: dbt-core>1.5.1
+Requires-Dist: dbt-duckdb>=1.10.1
+Requires-Dist: hatch>=1.16.5
+Requires-Dist: ibis-framework[duckdb]>=12.0.0
+Requires-Dist: pygls>=2.1.1
+Requires-Dist: pytest>=9.0.3
+Requires-Dist: pyyaml>=6.0.3
+Description-Content-Type: text/markdown
+
+# DBT-Language-Server
+
+
+Prompt a hover tooltip what columns model returns

dbt_ls-0.1.1/README.md

@@ -0,0 +1,4 @@
+# DBT-Language-Server
+
+
+Prompt a hover tooltip what columns model returns

dbt_ls-0.1.1/logs/dbt.log

@@ -0,0 +1,16 @@
+19:25:59.543661 [debug] [MainThread]: Sending event: {'category': 'dbt', 'action': 'invocation', 'label': 'start', 'context': [<snowplow_tracker.self_describing_json.SelfDescribingJson object at 0x79235221d120>, <snowplow_tracker.self_describing_json.SelfDescribingJson object at 0x79235119a620>, <snowplow_tracker.self_describing_json.SelfDescribingJson object at 0x7923511992d0>]}
+
+
+============================== 19:25:59.550899 | 18c50a94-b7cb-46ec-a9b7-147a9d5c7e74 ==============================
+19:25:59.550899 [info ] [MainThread]: Running with dbt=1.11.11
+19:25:59.551726 [debug] [MainThread]: running dbt with arguments {'warn_error': 'None', 'no_print': 'None', 'debug': 'False', 'quiet': 'False', 'warn_error_options': 'WarnErrorOptionsV2(error=[], warn=[], silence=[])', 'log_format': 'default', 'indirect_selection': 'eager', 'empty': 'None', 'partial_parse': 'True', 'fail_fast': 'False', 'static_parser': 'True', 'invocation_command': 'dbt parse', 'target_path': 'None', 'log_path': 'logs', 'send_anonymous_usage_stats': 'True', 'introspect': 'True', 'printer_width': '80', 'version_check': 'True', 'log_cache_events': 'False', 'cache_selected_only': 'False', 'write_json': 'True', 'use_experimental_parser': 'False', 'profiles_dir': '/home/lauri/.dbt', 'use_colors': 'True'}
+19:25:59.552484 [error] [MainThread]: Encountered an error:
+Runtime Error
+  No dbt_project.yml found at expected path /home/lauri/repos/dbt-ls/dbt_project.yml
+  Verify that each entry within packages.yml (and their transitive dependencies) contains a file named dbt_project.yml
+  
+19:25:59.554119 [debug] [MainThread]: Resource report: {"command_name": "parse", "command_success": false, "command_wall_clock_time": 0.09467357, "process_in_blocks": "368", "process_kernel_time": 0.099586, "process_mem_max_rss": "98856", "process_out_blocks": "8", "process_user_time": 1.581434}
+19:25:59.554834 [debug] [MainThread]: Command `dbt parse` failed at 19:25:59.554691 after 0.10 seconds
+19:25:59.555425 [debug] [MainThread]: Sending event: {'category': 'dbt', 'action': 'invocation', 'label': 'end', 'context': [<snowplow_tracker.self_describing_json.SelfDescribingJson object at 0x79235221d120>, <snowplow_tracker.self_describing_json.SelfDescribingJson object at 0x792351198070>, <snowplow_tracker.self_describing_json.SelfDescribingJson object at 0x7923511992d0>]}
+19:25:59.555973 [debug] [MainThread]: Flushing usage events
+19:26:00.489373 [debug] [MainThread]: An error was encountered while trying to flush usage events

dbt_ls-0.1.1/pyproject.toml

@@ -0,0 +1,29 @@
+[project]
+name = "dbt-ls"
+version = "0.1.1"
+description = "Add your description here"
+readme = "README.md"
+authors = [
+    { name = "HuhtaLauri", email = "huhta.lauri@gmail.com" }
+]
+requires-python = ">=3.10"
+dependencies = [
+    "black>=25.12.0",
+    "dbt-core>1.5.1",
+    "dbt-duckdb>=1.10.1",
+    "hatch>=1.16.5",
+    "ibis-framework[duckdb]>=12.0.0",
+    "pygls>=2.1.1",
+    "pytest>=9.0.3",
+    "pyyaml>=6.0.3",
+]
+
+[project.scripts]
+dbt-ls = "dbt_ls:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.pytest.ini_options]
+testpaths = ["test"]

dbt_ls-0.1.1/src/dbt_ls/__init__.py

@@ -0,0 +1,201 @@
+from pygls.lsp.server import LanguageServer
+import logging
+import os
+import sys
+from lsprotocol import types
+from importlib.metadata import version
+from dbt_ls.pattern import completion_context, ref_model_at
+from dbt_ls.model import (
+    discover_models,
+    enrich_models_from_database,
+)
+from dbt_ls.source import discover_sources, enrich_sources_from_catalog
+from pathlib import Path
+from dbt_ls.alias import parse_aliases
+from dbt_ls.project import Project
+from dbt_ls.profiles import Profiles
+import debugpy
+import argparse
+
+logging.basicConfig(
+    stream=sys.stderr,
+    level=os.environ.get("DBT_LS_LOG_LEVEL", "DEBUG").upper(),
+    force=True,  # tear down pygls' root handler and use ours
+)
+
+logging.getLogger("pygls").setLevel(logging.WARNING)
+log = logging.getLogger("dbt_ls")
+
+__version__ = version("dbt-ls")
+
+server = LanguageServer("dbt-ls", __version__)
+
+
+def find_dbt_project_root(root: str) -> str:
+    for p in Path(root).rglob("dbt_project.yml"):
+        if "target" not in p.parts:
+            return str(p.parent)
+    return "."
+
+
+@server.feature(types.INITIALIZE)
+def on_initialize(params: types.InitializeParams):
+    global models
+    global sources
+    global dbt_root
+    global project
+
+    if params.root_path:
+        dbt_root = find_dbt_project_root(params.root_path)
+        project = Project(dbt_root)
+        catalog_path = Path(f"{dbt_root}/target/catalog.json")
+
+        profile = Profiles.locate(project.root)
+        profile_target = profile.resolve(project.profile) if profile else None
+
+        models = discover_models(root=params.root_path, model_paths=project.model_paths)
+        log.debug("Finished parsing documented models")
+        sources = discover_sources(params.root_path)
+        log.debug("Finished parsing documented sources")
+        sources = enrich_sources_from_catalog(sources, catalog_path)
+        log.debug("Finished parsing column info for sources from catalog")
+        database_models = enrich_models_from_database(
+            models, profile_target, project.root
+        )
+        if database_models:
+            models = database_models
+        log.debug("Finished parsing column info for models from database")
+
+
+@server.feature(
+    types.TEXT_DOCUMENT_COMPLETION,
+    types.CompletionOptions(trigger_characters=["'", '"', "(", "."]),
+)
+def completions(params: types.CompletionParams):
+    document = server.workspace.get_text_document(params.text_document.uri)
+    current_line = document.lines[params.position.line].strip()
+    pos = params.position
+    line = document.lines[pos.line] if pos.line < len(document.lines) else ""
+    line_prefix = line[: pos.character]
+
+    ctx = completion_context(line_prefix)
+    if ctx is None:
+        log.debug("no pattern matched for %r", current_line, " (early exit)")
+        return None
+
+    log.debug("completion @ %d:%d | line=%r", pos.line, pos.character, current_line)
+
+    kind, info = ctx
+
+    if kind == "ref":
+        log.info(
+            "REF path matched %r → serving %d models: %s",
+            current_line,
+            len(models),
+            [m.name for m in models[:15]],
+        )
+        return [
+            types.CompletionItem(
+                m.name,
+                kind=types.CompletionItemKind(18),
+                label_details=types.CompletionItemLabelDetails(
+                    m.path.split(dbt_root)[-1]
+                ),
+            )
+            for m in models
+        ]
+    elif kind == "source_name":
+        [log.debug(c) for m in (*models, *sources) for c in m.columns]
+        log.info(
+            "SOURCE path matched %r → serving %d sources: %s",
+            current_line,
+            len(sources),
+            [s.name for s in sources[:15]],
+        )
+        return [
+            types.CompletionItem(
+                s.name,
+                kind=types.CompletionItemKind(10),
+                label_details=types.CompletionItemLabelDetails(s.database),
+                insert_text=f'{s.source_name}", "{s.name}',
+                insert_text_format=types.InsertTextFormat.PlainText,
+            )
+            for s in sources
+        ]
+    elif kind == "column":
+        alias = info["alias"]
+        alias_map = parse_aliases(document.source)
+        model_name = alias_map.get(alias)
+        log.info("COLUMN path: alias=%r → model=%r", alias, model_name)
+
+        return [
+            types.CompletionItem(
+                label=c.name,
+                kind=types.CompletionItemKind(5),
+                label_details=types.CompletionItemLabelDetails(c.data_type),
+            )
+            for m in (*models, *sources)
+            for c in m.columns
+            if m.name == model_name
+        ]
+    else:
+        log.debug("no pattern matched for %r", current_line)
+        return []
+
+
+@server.feature(types.TEXT_DOCUMENT_DEFINITION)
+def definition(params: types.DefinitionParams):
+    """Jump from a ref('model') to that model's .sql file."""
+    document = server.workspace.get_text_document(params.text_document.uri)
+    pos = params.position
+    line = document.lines[pos.line] if pos.line < len(document.lines) else ""
+
+    model_name = ref_model_at(line, pos.character)
+    if model_name is None:
+        return None
+
+    target = next((m for m in models if m.name == model_name and m.path), None)
+    if target is None:
+        log.info("DEFINITION: no model file found for %r", model_name)
+        return None
+
+    log.info("DEFINITION: %r → %s", model_name, target.path)
+    start = types.Position(line=0, character=0)
+    return types.Location(
+        uri=Path(target.path).as_uri(),
+        range=types.Range(start=start, end=start),
+    )
+
+
+def main():
+    banner = f"""
+   ╔═══════════════════════════════════════╗
+   ║                                       ║
+   ║      _ _     _        _               ║
+   ║   __| | |__ | |_     | |___           ║
+   ║  / _` | '_ \\| __|____| / __|          ║
+   ║ | (_| | |_) | ||_____| \\__ \\          ║
+   ║  \\__,_|_.__/ \\__|    |_|___/          ║
+   ║                                       ║
+   ║   {__version__:^5} · Language Server · stdio     ║
+   ║                                       ║
+   ╚═══════════════════════════════════════╝
+    """
+    print(banner)
+
+    p = argparse.ArgumentParser()
+    p.add_argument("--tcp", action="store_true")
+    p.add_argument("--host", default="127.0.0.1")
+    p.add_argument("--port", type=int, default=8765)
+    args = p.parse_args()
+    if args.tcp:
+        debugpy.listen(("127.0.0.1", 5678))
+        debugpy.wait_for_client()
+        server.start_tcp(args.host, args.port)
+    else:
+        server.start_io()
+    logging.info("DBT Language Server started")
+
+
+if __name__ == "__main__":
+    main()

dbt_ls-0.1.1/src/dbt_ls/alias.py

@@ -0,0 +1,12 @@
+import re
+
+
+def parse_aliases(text: str) -> dict[str, str]:
+    aliases = {}
+    for match in re.finditer(r"""\{{\s*ref\((['"])(\w+)\1\)\s*}}\s+(\w+)""", text):
+        aliases[match.group(3)] = match.group(2)
+    for match in re.finditer(
+        r"""\{{\s*source\((['"])(\w+)\1,\s*(['"])(\w+)\3\)\s*}}\s+(\w+)""", text
+    ):
+        aliases[match.group(5)] = match.group(4)
+    return aliases

dbt_ls-0.1.1/src/dbt_ls/column.py

@@ -0,0 +1,7 @@
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class Column:
+    name: str
+    data_type: str | None = None

dbt_ls-0.1.1/src/dbt_ls/model.py

@@ -0,0 +1,94 @@
+from dataclasses import dataclass
+from pathlib import Path
+from dbt_ls.column import Column
+import json
+from dbt_ls.profiles import ProfileTarget
+import ibis
+from ibis.expr.schema import Schema
+from ibis.expr.types.relations import (
+    Table,
+)
+from dbt_ls.profiles import DuckDBTarget, DatabaseTarget
+
+
+@dataclass(frozen=True)
+class Model:
+    name: str
+    path: str
+    columns: tuple[Column, ...] = ()
+
+
+def discover_models(root: str, model_paths: list[str]) -> list[Model]:
+    return [
+        Model(name=p.stem, path=str(p))
+        for model_path in model_paths
+        for p in (Path(root) / model_path).rglob("*.sql")
+    ]
+
+
+def enrich_models_from_catalog(models: list[Model], catalog_path: Path) -> list[Model]:
+    path = Path(catalog_path)
+    if not path.is_file():
+        return models
+
+    catalog = json.loads(path.read_text())
+    nodes = catalog.get("nodes", {})
+
+    # Build a lookup: model name -> columns
+    columns_by_name: dict[str, tuple[Column, ...]] = {}
+    for node in nodes.values():
+        if not node.get("unique_id", "").startswith("model."):
+            continue
+        name = node["metadata"]["name"]
+        columns_by_name[name] = tuple(
+            Column(name=c["name"], data_type=c.get("type"))
+            for c in node.get("columns", {}).values()
+        )
+
+    return [
+        Model(name=m.name, path=m.path, columns=columns_by_name.get(m.name, m.columns))
+        for m in models
+    ]
+
+
+def get_duckdb_models(
+    models: list[Model], profile_target: DuckDBTarget, project_root: str | Path
+) -> list[Model] | None:
+    ibis.set_backend("duckdb")
+
+    connection_path = (
+        profile_target.path
+        if Path(profile_target.path).is_absolute()
+        else Path(project_root).joinpath(profile_target.path)
+    )
+    con = ibis.duckdb.connect(connection_path)
+
+    con = ibis.duckdb.connect("myproject/" + profile_target.path)
+    columns_by_name: dict[str, tuple[Column, ...]] = {}
+
+    tables = con.list_tables()
+    for t in tables:
+        table: Table = con.table(t)
+        schema: Schema = table.schema()
+
+        columns_by_name[t] = tuple(
+            Column(name=name, data_type=str(dtype)) for name, dtype in schema.items()
+        )
+
+    return [
+        Model(name=m.name, path=m.path, columns=columns_by_name.get(m.name, ()))
+        for m in models
+    ]
+
+
+def enrich_models_from_database(
+    models: list[Model],
+    profile_target: DuckDBTarget | DatabaseTarget,
+    project_root: str | Path,
+) -> list[Model] | None:
+    match profile_target:
+        case DuckDBTarget():
+            return get_duckdb_models(models, profile_target, project_root)
+        case _:
+            print("here")
+            return None

dbt_ls-0.1.1/src/dbt_ls/pattern.py

@@ -0,0 +1,36 @@
+import re
+
+
+REF_RE = re.compile(r"""ref\(\s*(?P<q>['"])(?P<model>[^'"]*)$""")
+# Full ref('model') call, used to find the model the cursor is *inside of*.
+REF_FULL_RE = re.compile(r"""ref\(\s*['"](?P<model>[^'"]+)['"]""")
+SOURCE_RE = re.compile(
+    r"""source\(\s*(?P<q1>['"])(?P<src>[^'"]*)"""
+    r"""(?:(?P=q1)\s*,\s*(?P<q2>['"])(?P<tbl>[^'"]*))?$"""
+)
+COLUMN_RE = re.compile(r"(?P<alias>[a-zA-Z_]\w*)\.(?P<col>[a-zA-Z0-9_]*)$")
+
+
+def completion_context(line_prefix: str):
+    """What is the cursor currently completing? None if not in a ref/source."""
+    if m := SOURCE_RE.search(line_prefix):
+        # second arg started -> completing the table within a known source
+        if m.group("tbl") is not None:
+            return ("source_table", {"source": m.group("src")})
+        # still in first arg -> completing the source name
+        return ("source_name", {})
+    if m := REF_RE.search(line_prefix):
+        return ("ref", {})
+    if m := COLUMN_RE.search(line_prefix):
+        return ("column", {"alias": m.group("alias")})
+    return None
+
+
+def ref_model_at(line: str, character: int) -> str | None:
+    """
+    Check if cursor is on a model
+    """
+    for m in REF_FULL_RE.finditer(line):
+        if m.start("model") <= character <= m.end("model"):
+            return m.group("model")
+    return None

dbt_ls-0.1.1/src/dbt_ls/profiles.py

@@ -0,0 +1,74 @@
+from pathlib import Path
+from dataclasses import dataclass, fields
+import yaml
+from typing import Any
+
+
+@dataclass(kw_only=True)
+class ProfileTarget:
+    type: str
+    threads: int = 1
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "ProfileTarget":
+        target_cls = _TARGET_REGISTRY.get(data.get("type", ""), cls)
+        allowed = {f.name for f in fields(target_cls)}
+        return target_cls(**{k: v for k, v in data.items() if k in allowed})
+
+
+@dataclass(kw_only=True)
+class DuckDBTarget(ProfileTarget):
+    path: str
+
+    # def __post_init__(self):
+    #     if not Path(self.path).is_absolute():
+    #         self.path = str(Path("root").joinpath(self.path))
+
+
+@dataclass(kw_only=True)
+class DatabaseTarget(ProfileTarget):
+    user: str
+    password: str
+    host: str
+    port: int
+    dbname: str
+
+
+_TARGET_REGISTRY: dict[str, type[ProfileTarget]] = {
+    "duckdb": DuckDBTarget,
+    "postgres": DatabaseTarget,
+}
+
+
+class Profiles:
+    def __init__(self, path: Path):
+        self.path = path
+        self.config: dict[str, Any] = yaml.safe_load(self.path.read_text()) or {}
+
+    @classmethod
+    def locate(cls, project_root: str) -> "Profiles | None":
+        candidate = cls._search_dirs(project_root)
+        if not candidate:
+            return None
+        if candidate.exists():
+            return cls(candidate)
+
+        return None
+
+    @staticmethod
+    def _search_dirs(project_root: str) -> Path | None:
+        profile_paths = [Path(project_root), Path.home().joinpath(".dbt")]
+
+        for profile_path in profile_paths:
+            if Path(profile_path.joinpath("profiles.yml")).exists():
+                return Path(profile_path.joinpath("profiles.yml"))
+
+        return None
+
+    def resolve(self, profile_name: str, target: str | None = None) -> ProfileTarget:
+        if not target:
+            target = self.config[profile_name]["target"]
+
+        profile_target = self.config[profile_name]["outputs"][target]
+
+        return ProfileTarget.from_dict(profile_target)

dbt_ls-0.1.1/src/dbt_ls/project.py

@@ -0,0 +1,21 @@
+import yaml
+import os
+
+
+class Project:
+    def __init__(self, root: str = "."):
+        self.root = root
+        self.config = self._load_config()
+
+    def _load_config(self) -> dict:
+        path = os.path.join(self.root, "dbt_project.yml")
+        with open(path) as f:
+            return yaml.safe_load(f) or {}
+
+    @property
+    def model_paths(self) -> list[str]:
+        return self.config.get("model-paths", [])
+
+    @property
+    def profile(self) -> str:
+        return self.config.get("profile", "")

dbt_ls-0.1.1/src/dbt_ls/source.py

@@ -0,0 +1,71 @@
+from dataclasses import dataclass
+import yaml
+from pathlib import Path
+import json
+
+from dbt_ls.column import Column
+
+
+@dataclass(frozen=True)
+class SourceTable:
+    name: str
+    source_name: str
+    database: str | None = None
+    schema: str | None = None
+    columns: tuple[Column, ...] = ()
+
+
+def discover_sources(root: str) -> list:
+    sources = []
+    for p in Path(root).rglob("*.yml"):
+        if "target" in p.parts or not p.is_file():
+            continue
+        doc = yaml.safe_load(p.read_text())
+        if not doc or "sources" not in doc:
+            continue
+        for src in doc["sources"]:
+            source_name = src.get("name", "")
+            for table in src.get("tables", []):
+                sources.append(
+                    SourceTable(
+                        name=table["name"],
+                        source_name=source_name,
+                        database=src.get("database"),
+                        schema=src.get("schema"),
+                        columns=tuple(
+                            [
+                                Column(name=c["name"], data_type=c.get("data_type"))
+                                for c in table.get("columns", [])
+                            ]
+                        ),
+                    )
+                )
+    return sources
+
+
+def enrich_sources_from_catalog(
+    sources: list[SourceTable], catalog_path: Path
+) -> list[SourceTable]:
+    path = Path(catalog_path)
+    if not path.is_file():
+        return sources
+    catalog = json.loads(path.read_text())
+    catalog_sources = catalog.get("sources", {})
+    # Build a lookup: source name -> columns
+    columns_by_name: dict[str, tuple[Column, ...]] = {}
+    for source in catalog_sources.values():
+        if not source.get("unique_id", "").startswith("source."):
+            continue
+        name = source["metadata"]["name"]
+        columns_by_name[name] = tuple(
+            Column(name=c["name"], data_type=c.get("type"))
+            for c in source.get("columns", {}).values()
+        )
+    return [
+        SourceTable(
+            name=s.name,
+            source_name=s.source_name,
+            columns=columns_by_name.get(s.name) or s.columns,
+        )
+        for s in sources
+    ]