dbt-ls 0.1.1__py3-none-any.whl

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/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/column.py

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

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/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/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/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/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
+    ]

dbt_ls-0.1.1.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,12 @@
+dbt_ls/__init__.py,sha256=1PtsUfZKT5b7zko-etaPqum9HZVLDtv9MzgxU5_WDBA,6874
+dbt_ls/alias.py,sha256=jDDM2wmU47M76E49cuiURKZ7NIyIUJ-vX1xQePnmrMs,396
+dbt_ls/column.py,sha256=Pf_uZ5PZfLUc3TNCdbVbcdYcVa_UJjmbuF2fmoXQeM0,121
+dbt_ls/model.py,sha256=BZOrcZye8mEwT3doeRnKF0YJUcbLwpsiTFNDtj_yQBo,2690
+dbt_ls/pattern.py,sha256=-Wr82H_O0bNRTv6CFGm45LeCF_uc842l8Xmx5MiiJiA,1316
+dbt_ls/profiles.py,sha256=ivRNRctDaIlGU2YhdPF-oUZwBzXJzwQooJKkcEbjR00,2008
+dbt_ls/project.py,sha256=p0hGVAUjjzArBkbWgr23irFDuOHDO9wgUEEWf5-JMB0,511
+dbt_ls/source.py,sha256=nVoJdRJ3GJ6dyk9qPbt0gBH6Y4DfaKxFdkONkmAcWEU,2226
+dbt_ls-0.1.1.dist-info/METADATA,sha256=harh3ZezkOd-05TozPPePGilsigg9waf75NdFsq9CIo,528
+dbt_ls-0.1.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+dbt_ls-0.1.1.dist-info/entry_points.txt,sha256=18sOzg1GYOzOESCOT1JDK6HDd4iqMGffxR5WnvzdM2s,39
+dbt_ls-0.1.1.dist-info/RECORD,,

dbt_ls-0.1.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

dbt_ls-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+dbt-ls = dbt_ls:main