quickdbd-cli 0.4.3__py3-none-any.whl → 0.6.0__py3-none-any.whl

quickdbd_cli/__init__.py

@@ -1 +1 @@
-__version__ = "0.4.3"
+__version__ = "0.6.0"

quickdbd_cli/assets/syntax-reference.md

@@ -79,6 +79,7 @@ Declare a relationship once, in either direction.
 - Tags give tables a role and a header colour: `# @tag: gold, pii` above a table. Names like `dim_`, `fct_`, `stg_`, `int_`, `raw_` are tagged automatically.
 - `# @color gold #b8860b` sets a tag's colour (anywhere in any file).
 - Columns take tags too, on or above the column line: `discount decimal # @tag: added`. The row is tinted in the tag's colour; `added` is green, `removed` is red and struck through. Use them to mark proposed column changes for review.
+- `# @dbt: ../my_dbt_project` (anywhere in one file; the path is relative to that file) links a dbt project. Tables matching a model, seed, snapshot or source (`"source_name.table"`) by name get its yml description (shown before the comment), tags and `data_type` (for columns with no type). Where the schema and the yml disagree, `qdbd check` warns (`--strict` fails). `# @dbt: none` above a table skips it.
 
 ## Settings and layout sections
 
@@ -128,7 +129,7 @@ Ref: order_items.(order_id, region) > orders.(id, region)
 - Drawn: tables (`schema.table`, `public.users` = `users`), columns and types, `pk`, `null`, `unique`, `increment`, `default:`, indexes, `note`/`Note`, every `Ref` form (short, long, inline, composite, with `?` for an optional side), `TableGroup`, `headercolor`, `TablePartial`.
 - Accepted but not drawn: `Project`, `Enum` (the column shows the enum name as its type), `checks`, `records`, sticky notes, ref `delete:`/`update:`, `TableGroup` colours and notes.
 - `use` imports aren't followed: every file you give qdbd is read into one namespace.
-- `// @tag:` and `// @color` comments work; plain `//` comments are not documentation (use `note`).
+- `// @tag:`, `// @color` and `// @dbt:` comments work; plain `//` comments are not documentation (use `note`).
 
 # Notes
 

quickdbd_cli/cli.py

@@ -32,11 +32,12 @@ def _open(args) -> Project:
     return Project.open([Path(p) for p in args.paths], Path(args.layout) if getattr(args, "layout", None) else None)
 
 
+def _name(p: Path) -> str:
+    return p.stem if p.is_file() else (p.resolve().name or "diagram")
+
+
 def _title(project: Project) -> str:
-    if len(project.inputs) == 1:
-        p = project.inputs[0]
-        return p.stem if p.is_file() else (p.resolve().name or "diagram")
-    return "diagram"
+    return _name(project.inputs[0]) if len(project.inputs) == 1 else "diagram"
 
 
 def _github_annotation(d: Diagnostic, level: str) -> str:
@@ -57,14 +58,14 @@ def _symbols(schema: Schema) -> dict:
     tables = []
     for t in schema.tables.values():
         cols = [
-            {"name": c.name, "line": c.line, "type": c.type, "pk": c.pk, "fk": c.fk}
+            {"name": c.name, "line": c.line, "type": c.shown_type(), "pk": c.pk, "fk": c.fk}
             for c in t.columns.values()
             if not c.virtual
         ]
         end = t.end_line or max([t.line + 1] + [c["line"] for c in cols])
         table = {"name": t.name, "aliases": t.aliases, "file": t.path, "line": t.line, "endLine": end, "columns": cols}
-        if t.comments:
-            table["doc"] = "\n".join(t.comments)
+        if t.doc():
+            table["doc"] = t.doc()
         tables.append(table)
 
     def end(e) -> dict:
@@ -76,7 +77,30 @@ def _symbols(schema: Schema) -> dict:
     return {"tables": tables, "rels": rels}
 
 
+def _check_each(args) -> int:
+    """Check each PATH on its own, as ``build --site`` builds them; folders with no schema files are skipped."""
+    from .project import discover
+
+    if args.format == "json" or args.stdin_file:
+        print("error: --each can't be used with --format json or --stdin-file", file=sys.stderr)
+        return 2
+    code, checked = 0, 0
+    for p in args.paths:
+        if Path(p).is_dir() and not discover([Path(p)]):
+            print(f"Skipped {p}: no .txt or .dbml schema files", file=sys.stderr)
+            continue
+        print(f"{p}:")
+        code = max(code, cmd_check(argparse.Namespace(**{**vars(args), "paths": [p], "each": False})))
+        checked += 1
+    if not checked:
+        print("error: no schema files found in: " + ", ".join(args.paths), file=sys.stderr)
+        return 2
+    return code
+
+
 def cmd_check(args) -> int:
+    if args.each:
+        return _check_each(args)
     project = _open(args)
     overrides = None
     if args.stdin_file:
@@ -143,7 +167,52 @@ def _built_page(args) -> tuple[str, dict] | int:
     return render_page(model, pos, _title(project)), model
 
 
+def _build_site(args) -> int:
+    """One page per PATH plus an index linking them, in the folder ``args.site``."""
+    from urllib.parse import quote
+
+    from .html import render_index
+    from .project import discover
+
+    if args.layout:
+        print("error: --layout can't be used with --site: each PATH uses its own layout file", file=sys.stderr)
+        return 2
+    pages, seen, failed = [], {}, 0
+    for p in map(Path, args.paths):
+        if p.is_dir() and not discover([p]):
+            print(f"Skipped {p}: no .txt or .dbml schema files", file=sys.stderr)
+            continue
+        name = _name(p)
+        if name.lower() in seen or name.lower() == "index":
+            other = seen.get(name.lower(), "the index page")
+            print(f"error: {p} and {other} would both be written to {name}.html", file=sys.stderr)
+            return 2
+        seen[name.lower()] = p
+        res = _built_page(argparse.Namespace(**{**vars(args), "paths": [str(p)]}))
+        if isinstance(res, int):
+            failed = max(failed, res)
+            continue
+        pages.append((name, *res))
+    if failed:  # nothing is written, so a failed build never leaves a half-updated site
+        return failed
+    if not pages:
+        print("error: no schema files found in: " + ", ".join(args.paths), file=sys.stderr)
+        return 2
+    out = Path(args.site)
+    out.mkdir(parents=True, exist_ok=True)
+    index = []
+    for name, page, model in pages:
+        (out / f"{name}.html").write_text(page, encoding="utf-8")
+        index.append((name, quote(f"{name}.html"), len(model["tables"]), len(model["rels"])))
+        print(f"Wrote {out / f'{name}.html'} ({len(model['tables'])} tables, {len(model['rels'])} relationships)")
+    (out / "index.html").write_text(render_index(index), encoding="utf-8")
+    print(f"Wrote {out / 'index.html'} ({len(pages)} diagrams)")
+    return 0
+
+
 def cmd_build(args) -> int:
+    if args.site:
+        return _build_site(args)
     res = _built_page(args)
     if isinstance(res, int):
         return res
@@ -337,13 +406,13 @@ def cmd_convert(args) -> int:
         root = next((p for p in inputs if p.is_dir() and f.resolve().is_relative_to(p.resolve())), None)
         rel = f.resolve().relative_to(root.resolve()).as_posix() if root else f.name
         sources.append((str(f), rel, f.read_text(encoding="utf-8")))
-    schema = compile_sources([(d, t) for d, _, t in sources])
+    schema = compile_sources([(d, t) for d, _, t in sources], dbt=False)
     if not _print_diagnostics(schema, False):
         return 1
     res = convert.convert(sources, args.to, split_groups=to_dir)
     for w in res.warnings:
         print(w.format(), file=sys.stderr)
-    again = compile_sources(list(res.files.items()))
+    again = compile_sources(list(res.files.items()), dbt=False)
     if again.errors or convert.canonical(again, res.lost) != convert.canonical(schema, res.lost):
         for d in again.errors:
             print(d.format(), file=sys.stderr)
@@ -575,11 +644,20 @@ def build_parser() -> argparse.ArgumentParser:
         metavar="PATH",
         help="read this schema file's text from stdin instead of disk (an editor's unsaved buffer)",
     )
+    sp.add_argument(
+        "--each",
+        action="store_true",
+        help="check each PATH as its own schema, as build --site does (folders with no schema files are skipped)",
+    )
     sp.set_defaults(func=cmd_check)
 
     sp = sub.add_parser("build", help="write an interactive HTML diagram")
     paths(sp)
-    sp.add_argument("-o", "--output", default="diagram.html")
+    out = sp.add_mutually_exclusive_group()
+    out.add_argument("-o", "--output", default="diagram.html")
+    out.add_argument(
+        "--site", metavar="DIR", help="one page per PATH (named after it) plus an index.html linking them, in DIR"
+    )
     selectors(sp)
     sp.add_argument(
         "--diff-base", metavar="GIT_REF", help="colour tables/columns changed since this git ref (e.g. origin/main)"

quickdbd_cli/convert.py

@@ -38,7 +38,7 @@ class ConvertResult:
 
 def convert(sources: list[tuple[str, str, str]], to: str, split_groups: bool) -> ConvertResult:
     """``sources``: ``(display path, output-relative path, text)``. Files already in ``to`` are copied as is."""
-    schema, parses = compile_files([(d, t) for d, _, t in sources])
+    schema, parses = compile_files([(d, t) for d, _, t in sources], dbt=False)
     res = ConvertResult()
     for t in schema.tables.values():
         if t.id in schema.layout:
@@ -88,7 +88,10 @@ def canonical(schema: Schema, lost: set[tuple]) -> dict:
                 if ("col", t.name, c.name, k) in lost:
                     del col[k]
             cols[c.name] = col
-        table = {"cols": cols, "doc": _doc(t.comments), "aliases": t.aliases, "tags": t.tags, "dbt_tags": t.dbt_tags}
+        table = {
+            "cols": cols, "doc": _doc(t.comments), "aliases": t.aliases, "tags": t.tags, "dbt_tags": t.dbt_tags,
+            "dbt_skip": t.dbt_skip,
+        }  # fmt: skip
         for k in list(table):
             if ("table", t.name, k) in lost:
                 del table[k]
@@ -153,7 +156,9 @@ class _DbmlWriter:
                 self.warn(line, f"settings: [settings] {k.capitalize()} has no DBML equivalent; dropped")
         for tag, (color, _) in sorted(fp.colors.items()):
             lines.append(f"// @color {tag} {color}")
-        if fp.colors:
+        if fp.dbt:  # shortcut: kept as written, so it breaks if -o puts the file in another folder
+            lines.append(f"// @dbt: {fp.dbt[0]}")
+        if fp.colors or fp.dbt:
             lines.append("")
         for t in (t for t in self.schema.tables.values() if t.path == fp.path):
             lines += self.table(t)
@@ -170,6 +175,8 @@ class _DbmlWriter:
             out.append(f"// @tag: {', '.join(t.tags)}")
         if t.dbt_tags:
             out.append(f"// @dbt-tags: {', '.join(t.dbt_tags)}")
+        if t.dbt_skip:
+            out.append("// @dbt: none")
         head = f"Table {_dbml_name(t.name)}"
         if t.aliases:
             head += f" as {_dbml_name(t.aliases[0])}"
@@ -313,6 +320,8 @@ class _QuickdbdWriter:
             header.append(f"# enum {name}: {', '.join(values)}")
         for tag, (color, _) in sorted(fp.colors.items()):
             header.append(f"# @color {tag} {color}")
+        if fp.dbt:  # shortcut: kept as written, so it breaks if -o puts the file in another folder
+            header.append(f"# @dbt: {fp.dbt[0]}")
         if not self.split:
             for group, line in fp.groups.items():
                 self.warn(line, f"TableGroup {group}: QuickDBD groups tables by file (use -o DIR to split); dropped")
@@ -347,6 +356,8 @@ class _QuickdbdWriter:
             out.append(f"# @tag: {', '.join(t.tags)}")
         if t.dbt_tags:
             out.append(f"# @dbt-tags: {', '.join(t.dbt_tags)}")
+        if t.dbt_skip:
+            out.append("# @dbt: none")
         out.append(_qdbd_name(t.name) + (f" as {', '.join(t.aliases)}" if t.aliases else ""))
         out.append("-")
         for c in t.columns.values():

quickdbd_cli/dbml.py

@@ -16,7 +16,18 @@ import unicodedata
 from dataclasses import dataclass, field
 
 from .model import Column, Diagnostic, Table
-from .parser import COLOR_RE, HEX_RE, TAG_NAME_RE, TAG_RE, FileParse, PendingRel, encode, split_tags
+from .parser import (
+    COLOR_RE,
+    DBT_RE,
+    HEX_RE,
+    TAG_NAME_RE,
+    TAG_RE,
+    FileParse,
+    PendingRel,
+    encode,
+    is_dbt_none,
+    split_tags,
+)
 
 # Relationship operator -> (cardinality of the left end, of the right end). A `?` makes its own side optional.
 _BASE = {"-": ("one", "one"), "<>": ("many", "many"), ">": ("many", "one"), "<": ("one", "many")}
@@ -1287,7 +1298,9 @@ class _Interpreter:
         line = t.line - 1
         while line in self.comments and line not in self.code_lines:
             m = TAG_RE.match(self.comments[line])
-            if m:
+            if is_dbt_none(self.comments[line]):
+                t.dbt_skip = True
+            elif m:
                 target = t.dbt_tags if m.group(1).lower().startswith("dbt") else t.tags
                 target[:0] = [x for x in split_tags(m.group(2)) if x not in target]
             line -= 1
@@ -1306,10 +1319,17 @@ class _Interpreter:
 
     def colors(self) -> None:
         first_code = min(self.code_lines, default=0)
+
+        def directive(text: str) -> bool:
+            return bool(COLOR_RE.match(text) or (DBT_RE.match(text) and not is_dbt_none(text)))
+
         self.fp.general_comments = [
-            text for line, text in sorted(self.comments.items()) if line < first_code and not COLOR_RE.match(text)
+            text for line, text in sorted(self.comments.items()) if line < first_code and not directive(text)
         ]
         for line, text in sorted(self.comments.items()):
+            d = DBT_RE.match(text)
+            if d and not is_dbt_none(text):
+                self.fp.set_dbt(d.group(1), line)
             m = COLOR_RE.match(text)
             if not m:
                 continue

quickdbd_cli/dbt.py

@@ -174,10 +174,12 @@ def _comment_lines(text: str) -> list[str]:
     return out
 
 
-def _node_tags(n: dict) -> list[str]:
+def node_tags(n: dict) -> list[str]:
     """dbt tags (node-level and config), lowercased, in order, usable as qdbd tag names."""
     out: list[str] = []
-    raw = list(n.get("tags") or []) + list((n.get("config") or {}).get("tags") or [])
+    raw: list = []
+    for v in (n.get("tags"), (n.get("config") or {}).get("tags")):
+        raw += [v] if isinstance(v, str) else list(v or [])  # yml allows `tags: pii`
     for tag in raw:
         tag = re.sub(r"[^a-z0-9_.-]+", "-", str(tag).lower()).strip("-.")
         if tag and tag not in out:
@@ -243,7 +245,7 @@ class _Importer:
             name = self._base_name(n)
             if names[name] > 1:  # same name in two packages
                 name = f"{n.get('package_name')}.{name}"
-            t = Tbl(n["unique_id"], name, self._group(n), n.get("description") or "", tags=_node_tags(n))
+            t = Tbl(n["unique_id"], name, self._group(n), n.get("description") or "", tags=node_tags(n))
             self._columns(t, n)
             self.tables[t.uid] = t
             self.by_name.setdefault(n.get("name", "").lower(), []).append(t.uid)

quickdbd_cli/dbtyml.py

@@ -0,0 +1,275 @@
+"""`# @dbt: PATH`: descriptions, tags and types from a dbt project's yml, for hand-written schema files.
+
+No manifest.json is needed (dbt Cloud projects have none locally). qdbd reads ``dbt_project.yml`` and the yml, md
+and sql files under its resource paths (the root project only; ``dbt_packages/`` and ``target/`` are skipped).
+
+- Tables match models, seeds, snapshots and sources (``source_name.table_name``) by name, ignoring case;
+  columns match by name inside the matched table. ``# @dbt: none`` above a table opts it out.
+- The dbt description is shown before the schema file's own comment; ``{{ doc('x') }}`` is filled from
+  ``{% docs x %}`` blocks. Model and column tags rank below ``# @tag:`` and name prefixes. ``data_type`` fills
+  columns that have no type.
+- Drift is reported as warnings (``--strict`` fails on them): a table dbt doesn't have, a column only one side has,
+  a type that differs (by base type: ``varchar(50)`` and ``string`` agree).
+"""
+
+from __future__ import annotations
+
+import os
+import re
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from pathlib import Path
+
+import yaml
+
+from .dbt import node_tags, norm_type
+from .model import DbtInfo, Schema
+
+SKIP_DIRS = {"dbt_packages", "dbt_modules", "target", "logs", "node_modules"}
+WATCHED = (".yml", ".yaml", ".md", ".sql", ".py", ".csv")
+_DOC_REF = re.compile(r"""\{\{\s*doc\(\s*(?:['"][^'"]*['"]\s*,\s*)?['"]([^'"]+)['"]\s*\)\s*\}\}""")
+_DOCS_BLOCK = re.compile(r"\{%-?\s*docs\s+([\w.-]+)\s*-?%\}(.*?)\{%-?\s*enddocs\s*-?%\}", re.S)
+_SNAPSHOT = re.compile(r"\{%-?\s*snapshot\s+(\w+)\s*-?%\}")
+
+# Base types that mean the same thing across warehouses; sizes and precision are ignored.
+_FAMILIES = {
+    "int": "int integer int2 int4 int8 int16 int32 int64 smallint bigint tinyint byteint mediumint hugeint long short",
+    "decimal": "decimal numeric number dec bignumeric",
+    "float": "float float4 float8 float32 float64 double double_precision real",
+    "string": "string text varchar char character nvarchar nchar bpchar varchar2 nvarchar2 citext clob",
+    "bool": "bool boolean",
+    "timestamp": "timestamp timestamptz datetime datetime2 smalldatetime datetimeoffset timestamp_ntz timestamp_ltz "
+    "timestamp_tz",
+    "time": "time timetz",
+    "json": "json jsonb variant object super",
+    "binary": "binary varbinary bytes bytea blob",
+    "uuid": "uuid uniqueidentifier",
+    "array": "array list",
+}
+_BASE = {name: family for family, names in _FAMILIES.items() for name in names.split()}
+
+
+class DbtError(Exception):
+    pass
+
+
+@dataclass
+class DbtColumn:
+    name: str
+    description: str
+    data_type: str | None
+    tags: list[str]
+    line: int
+
+
+@dataclass
+class DbtModel:
+    name: str  # model / seed / snapshot name, or `source_name.table_name`
+    description: str
+    tags: list[str]
+    columns: dict[str, DbtColumn]  # by lowercased name
+    path: str  # yml file, relative to the project root
+    line: int
+
+
+@dataclass
+class DbtProject:
+    root: Path
+    models: dict[str, DbtModel] = field(default_factory=dict)  # by lowercased name
+    known: set[str] = field(default_factory=set)  # lowercased names that exist as files, documented or not
+    ambiguous: set[str] = field(default_factory=set)
+    docs: dict[str, str] = field(default_factory=dict)  # `{% docs name %}` blocks
+
+
+class _Loader(getattr(yaml, "CSafeLoader", yaml.SafeLoader)):  # type: ignore[misc]
+    """Records each mapping's line as `__line__`, so drift messages can point into the yml."""
+
+    def construct_mapping(self, node, deep=False):
+        m = super().construct_mapping(node, deep=deep)
+        m["__line__"] = node.start_mark.line + 1
+        return m
+
+
+# (path, parser) -> (mtime_ns, parsed): keeps `qdbd serve` recompiles cheap
+_cache: dict[tuple[Path, Callable], tuple[int, object]] = {}
+
+
+def _cached(path: Path, parse: Callable[[str], object]) -> object:
+    mtime = path.stat().st_mtime_ns
+    hit = _cache.get((path, parse))
+    if hit is None or hit[0] != mtime:
+        hit = _cache[(path, parse)] = (mtime, parse(path.read_text(encoding="utf-8")))
+    return hit[1]
+
+
+def _load_yaml(text: str) -> object:
+    return yaml.load(text, Loader=_Loader)  # a SafeLoader: no arbitrary Python objects
+
+
+def _yaml(path: Path, root: Path) -> object:
+    try:
+        return _cached(path, _load_yaml)
+    except yaml.YAMLError as e:
+        mark = getattr(e, "problem_mark", None)
+        where = f"{path.relative_to(root).as_posix()}:{mark.line + 1}" if mark else path.relative_to(root).as_posix()
+        raise DbtError(f"{where}: invalid YAML ({getattr(e, 'problem', None) or e})") from None
+
+
+def find_root(path: Path) -> Path:
+    """The dbt project a `# @dbt:` path names: its folder, or its dbt_project.yml."""
+    root = path.parent if path.name == "dbt_project.yml" else path
+    if not (root / "dbt_project.yml").is_file():
+        raise DbtError(f"no dbt_project.yml in {root}")
+    return root
+
+
+def _paths(root: Path) -> tuple[dict[str, list[Path]], list[Path]]:
+    """(resource kind -> folders, docs folders), from dbt_project.yml with dbt's defaults."""
+    cfg = _yaml(root / "dbt_project.yml", root)
+    cfg = cfg if isinstance(cfg, dict) else {}
+
+    def get(key: str, old: str | None = None, default: str | None = None) -> list[Path]:
+        v = cfg.get(key) or (cfg.get(old) if old else None) or ([default] if default else [])
+        out = []
+        for p in [v] if isinstance(v, str) else v:
+            # dbt resolves these inside the project; anything else (`/`, `../..`) would walk the whole disk
+            if not (root / str(p)).resolve().is_relative_to(root.resolve()):
+                raise DbtError(f"dbt_project.yml: {key} '{p}' is outside the project")
+            out.append(root / str(p))
+        return out
+
+    kinds = {
+        "model": get("model-paths", "source-paths", "models"),
+        "seed": get("seed-paths", "data-paths", "seeds"),
+        "snapshot": get("snapshot-paths", None, "snapshots"),
+    }
+    doc_dirs = get("docs-paths")
+    if not doc_dirs:  # dbt's default: every resource path
+        doc_dirs = [d for ds in kinds.values() for d in ds]
+        doc_dirs += get("analysis-paths", None, "analyses") + get("macro-paths", None, "macros")
+    return kinds, doc_dirs
+
+
+def _walk(dirs: list[Path], suffixes: tuple[str, ...]) -> list[Path]:
+    out: dict[Path, None] = {}
+    for d in dirs:
+        for dirpath, dirnames, filenames in os.walk(d):
+            dirnames[:] = sorted(n for n in dirnames if not n.startswith(".") and n not in SKIP_DIRS)
+            for n in sorted(filenames):
+                if n.lower().endswith(suffixes):
+                    out[Path(dirpath, n)] = None
+    return list(out)
+
+
+def watched_files(root: Path) -> list[Path]:
+    """Every file `load_project` reads (or may read once it exists), for `qdbd serve`'s change polling."""
+    kinds, doc_dirs = _paths(root)
+    return [root / "dbt_project.yml", *_walk([d for ds in kinds.values() for d in ds] + doc_dirs, WATCHED)]
+
+
+def _text(v: object) -> str:
+    return str(v).strip() if v is not None else ""
+
+
+def _column_name(v: object) -> str:
+    return _text(v).strip('"`')
+
+
+def load_project(root: Path) -> DbtProject:
+    kinds, doc_dirs = _paths(root)
+    project = DbtProject(root)
+    for p in _walk(kinds["model"], (".sql", ".py")):
+        project.known.add(p.stem.lower())
+    for p in _walk(kinds["seed"], (".csv",)):
+        project.known.add(p.stem.lower())
+    for p in _walk(kinds["snapshot"], (".sql",)):
+        project.known.update(m.lower() for m in _cached(p, _SNAPSHOT.findall))  # type: ignore[union-attr]
+    for p in _walk(doc_dirs, (".md",)):
+        for name, body in _cached(p, _DOCS_BLOCK.findall):  # type: ignore[union-attr]
+            project.docs[name] = body.strip()
+    for p in _walk([d for ds in kinds.values() for d in ds], (".yml", ".yaml")):
+        data = _yaml(p, root)
+        if not isinstance(data, dict):
+            continue
+        rel = p.relative_to(root).as_posix()
+        for key in ("models", "seeds", "snapshots"):
+            for n in data.get(key) or []:
+                if isinstance(n, dict) and n.get("name"):
+                    _add(project, _text(n["name"]), n, rel)
+        for src in data.get("sources") or []:
+            if not isinstance(src, dict) or not src.get("name"):
+                continue
+            for n in src.get("tables") or []:
+                if isinstance(n, dict) and n.get("name"):
+                    _add(project, f"{_text(src['name'])}.{_text(n['name'])}", n, rel)
+    return project
+
+
+def _add(project: DbtProject, name: str, n: dict, rel: str) -> None:
+    key = name.lower()
+    if key in project.models:
+        project.ambiguous.add(key)
+        return
+    cols: dict[str, DbtColumn] = {}
+    for c in n.get("columns") or []:
+        if isinstance(c, dict) and _column_name(c.get("name")):
+            cname = _column_name(c["name"])
+            dtype = _text(c.get("data_type")) or None
+            cols[cname.lower()] = DbtColumn(cname, _text(c.get("description")), dtype, node_tags(c), c["__line__"])
+    project.models[key] = DbtModel(name, _text(n.get("description")), node_tags(n), cols, rel, n["__line__"])
+    project.known.add(key)
+
+
+def base_type(t: str) -> str:
+    """`varchar(255)` -> `string`, `INTEGER` -> `int`: what two types must share to count as the same."""
+    s = re.split(r"[(<\[]", (norm_type(t) or "").lower())[0].strip("_ ")
+    return _BASE.get(s, s)
+
+
+Report = Callable[[str, int, str, str], None]  # (path, line, message, severity)
+
+
+def apply(schema: Schema, project: DbtProject, report: Report) -> None:
+    """Attach dbt descriptions, tags and types to the matching tables and columns, and report drift."""
+
+    def doc(text: str, path: str, line: int) -> str:
+        def sub(m: re.Match) -> str:
+            if m.group(1) in project.docs:
+                return project.docs[m.group(1)]
+            report(path, line, f"dbt: no docs block named '{m.group(1)}'", "warning")
+            return m.group(0)
+
+        return _DOC_REF.sub(sub, text)
+
+    for t in schema.tables.values():
+        key = t.name.lower()
+        if t.dbt_skip or key in project.ambiguous:
+            continue
+        m = project.models.get(key)
+        if m is None:
+            if key not in project.known:
+                report(
+                    t.path,
+                    t.line,
+                    f"dbt: no model, seed, snapshot or source named '{t.name}' "
+                    "(put '# @dbt: none' above the table if it isn't one)",
+                    "warning",
+                )
+            continue
+        t.dbt = DbtInfo(doc(m.description, t.path, t.line), list(m.tags))
+        cols = {c.name.lower(): c for c in t.columns.values() if not c.virtual}
+        for ckey, dc in m.columns.items():
+            c = cols.get(ckey)
+            if c is None:
+                msg = f"dbt: column '{dc.name}' ({m.path}:{dc.line}) is missing from '{t.name}'"
+                report(t.path, t.line, msg, "warning")
+                continue
+            c.dbt = DbtInfo(doc(dc.description, t.path, c.line), list(dc.tags), norm_type(dc.data_type))
+            if dc.data_type and c.type and not c.type_default and base_type(c.type) != base_type(dc.data_type):
+                msg = f"dbt: type '{c.type}' differs from data_type '{dc.data_type}' ({m.path}:{dc.line})"
+                report(t.path, c.line, msg, "warning")
+        if m.columns:
+            for ckey, c in cols.items():
+                if ckey not in m.columns:
+                    msg = f"dbt: column '{c.name}' is not in the yml for '{m.name}' ({m.path}:{m.line})"
+                    report(t.path, c.line, msg, "warning")

quickdbd_cli/diff.py

@@ -175,7 +175,7 @@ def sources_at_ref(ref: str, inputs: list[Path]) -> list[tuple[str, str]]:
 
 
 def schema_at_ref(ref: str, inputs: list[Path]) -> Schema:
-    return compile_sources(sources_at_ref(ref, inputs))
+    return compile_sources(sources_at_ref(ref, inputs), dbt=False)
 
 
 # --------------------------------------------------------------------------- output

quickdbd_cli/html.py

@@ -190,3 +190,28 @@ def render_page(
         f"<script>{_asset('viewer.js')}</script>"
         f"{scripts}</body></html>\n"
     )
+
+
+INDEX_CSS = (
+    ":root{color-scheme:light dark;--fg:#1f2328;--muted:#656d76;--bg:#fff;--line:#d0d7de}"
+    "@media (prefers-color-scheme:dark){:root{--fg:#e6edf3;--muted:#8d96a0;--bg:#0d1117;--line:#30363d}}"
+    "body{margin:0;background:var(--bg);color:var(--fg);font:15px/1.5 system-ui,sans-serif}"
+    "main{max-width:640px;margin:0 auto;padding:32px 16px}h1{font-size:20px;margin:0 0 16px}"
+    "ul{list-style:none;margin:0;padding:0}li{border-top:1px solid var(--line);padding:10px 0}"
+    "a{color:inherit;font-weight:600}span{color:var(--muted);margin-left:8px}"
+)
+
+
+def render_index(pages: list[tuple[str, str, int, int]], title: str = "Diagrams") -> str:
+    """``qdbd build --site``'s index: a link per (name, href, tables, relationships)."""
+    items = "".join(
+        f'<li><a href="{_escape(href)}">{_escape(name)}</a><span>{t} tables, {r} relationships</span></li>'
+        for name, href, t, r in pages
+    )
+    return (
+        '<!doctype html>\n<html lang="en"><head><meta charset="utf-8">'
+        '<meta name="viewport" content="width=device-width, initial-scale=1">'
+        '<meta name="generator" content="qdbd">'
+        f"{favicon()}<title>{_escape(title)}</title><style>{INDEX_CSS}</style></head>"
+        f"<body><main><h1>{_escape(title)}</h1><ul>{items}</ul></main></body></html>\n"
+    )

quickdbd_cli/measure.py

@@ -61,11 +61,12 @@ def _column_json(col: Column) -> dict:
     bold = col.pk or col.fk
     name_w = text_width(col.name, s["rowSize"], bold)
     bs = [{"t": b, "w": round(text_width(b, s["badgeSize"]) + 2 * s["badgePad"], 2)} for b in badges(col)]
-    type_w = text_width(col.type or "", s["rowSize"])
+    typ = col.shown_type() or ""
+    type_w = text_width(typ, s["rowSize"])
     out = {
         "id": col.id,
         "name": col.name,
-        "type": col.type or "",
+        "type": typ,
         "pk": col.pk,
         "fk": col.fk,
         "nullable": col.nullable,
@@ -77,10 +78,11 @@ def _column_json(col: Column) -> dict:
         "typeW": type_w,
         "badges": bs,
     }
-    if col.comments:
-        out["doc"] = "\n".join(col.comments)
-    if col.tags:
-        out["tags"] = list(col.tags)
+    if col.doc():
+        out["doc"] = col.doc()
+    tags = col.tags or (col.dbt.tags if col.dbt else [])
+    if tags:
+        out["tags"] = list(tags)
     return out
 
 
@@ -98,8 +100,8 @@ def table_json(table: Table) -> dict:
     w = max(round(w), s["minW"])
     h = s["headerH"] + len(cols) * s["rowH"] + s["bottomPad"]
     out = {"id": table.id, "name": table.name, "aliases": table.aliases, "w": w, "h": h, "nameW": name_w, "cols": cols}
-    if table.comments:
-        out["doc"] = "\n".join(table.comments)
+    if table.doc():
+        out["doc"] = table.doc()
     return out
 
 

quickdbd_cli/model.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
+from pathlib import Path
 
 VIRTUAL_FIELD = "qdbdvirtualfield"
 
@@ -31,6 +32,25 @@ class Diagnostic:
         return f"{self.path}:{self.line}: {self.severity}: {self.message}"
 
 
+@dataclass
+class DbtInfo:
+    """What a dbt project's yml says about a table or column. Kept apart from comments/type/tags, so
+    `qdbd convert` never writes it into schema files."""
+
+    doc: str = ""
+    tags: list[str] = field(default_factory=list)
+    type: str | None = None
+
+
+def merged_doc(dbt: DbtInfo | None, comments: list[str]) -> str:
+    """The dbt description first, then the schema file's comments (once, if they say the same)."""
+    own = "\n".join(comments)
+    theirs = dbt.doc if dbt else ""
+    if not theirs or " ".join(theirs.split()) == " ".join(own.split()):
+        return own
+    return theirs + ("\n" + own if own else "")
+
+
 @dataclass
 class Column:
     id: str
@@ -48,6 +68,16 @@ class Column:
     virtual: bool = False
     comments: list[str] = field(default_factory=list)
     tags: list[str] = field(default_factory=list)  # `# @tag: ...` comments
+    type_default: bool = False  # type came from the file's DefaultFieldType setting
+    dbt: DbtInfo | None = None  # from the dbt project's yml (`# @dbt: PATH`)
+
+    def shown_type(self) -> str | None:
+        if self.dbt and self.dbt.type and (self.type is None or self.type_default):
+            return self.dbt.type
+        return self.type
+
+    def doc(self) -> str:
+        return merged_doc(self.dbt, self.comments)
 
 
 @dataclass
@@ -64,6 +94,11 @@ class Table:
     group: str | None = None  # DBML TableGroup; else the explorer groups by file
     color: str | None = None  # DBML headercolor; beats tag colours
     end_line: int | None = None  # DBML: the closing `}` line
+    dbt_skip: bool = False  # `# @dbt: none` above the table
+    dbt: DbtInfo | None = None  # from the dbt project's yml (`# @dbt: PATH`)
+
+    def doc(self) -> str:
+        return merged_doc(self.dbt, self.comments)
 
 
 @dataclass
@@ -91,6 +126,7 @@ class Schema:
     diagnostics: list[Diagnostic] = field(default_factory=list)
     general_comments: list[str] = field(default_factory=list)
     tag_colors: dict[str, str] = field(default_factory=dict)  # `# @color TAG #hex`
+    dbt_root: Path | None = None  # the dbt project named by `# @dbt: PATH`
 
     @property
     def errors(self) -> list[Diagnostic]:

quickdbd_cli/parser.py

@@ -14,7 +14,9 @@ from __future__ import annotations
 
 import re
 from dataclasses import dataclass, field
+from pathlib import Path
 
+from . import dbtyml
 from .model import REL_TYPES, VIRTUAL_FIELD, Column, Diagnostic, End, Relationship, Schema, Table
 
 SECTIONS = ["tables", "settings", "layout"]
@@ -25,10 +27,16 @@ REJECT = "QuickDBD would reject this: "
 # qdbd directives live in comments, so files stay valid QuickDBD.
 TAG_RE = re.compile(r"^@(tags?|dbt-tags?)\s*:?\s*(.*)$", re.I)
 COLOR_RE = re.compile(r"^@colou?r\b\s*:?\s*(.*)$", re.I)
+DBT_RE = re.compile(r"^@dbt\s*:\s*(.*?)\s*$", re.I)  # `@dbt: PATH` (file) or `@dbt: none` (above a table)
 TAG_NAME_RE = re.compile(r"^[A-Za-z0-9_][A-Za-z0-9_.-]*$")
 HEX_RE = re.compile(r"^#(?:[0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$")
 
 
+def is_dbt_none(comment: str) -> bool:
+    m = DBT_RE.match(comment)
+    return bool(m) and m.group(1).lower() == "none"
+
+
 def split_tags(text: str) -> list[str]:
     out: list[str] = []
     for t in re.split(r"[\s,]+", text.strip()):
@@ -219,6 +227,13 @@ class FileParse:
     unmodelled: list[tuple[int, str]] = field(default_factory=list)  # DBML: (line, what) parsed, not drawn
     enums: dict[str, list[str]] = field(default_factory=dict)  # DBML: enum name -> values
     groups: dict[str, int] = field(default_factory=dict)  # DBML: TableGroup name -> line
+    dbt: tuple[str, int] | None = None  # `# @dbt: PATH`: (path as written, line)
+
+    def set_dbt(self, value: str, line: int) -> None:
+        if self.dbt and self.dbt[0] != value:
+            self.error(line, f"@dbt differs from line {self.dbt[1]} ('{self.dbt[0]}')")
+        elif not self.dbt:
+            self.dbt = (value, line)
 
     def error(self, line: int, msg: str) -> None:
         self.diagnostics.append(Diagnostic(self.path, line, msg, "error"))
@@ -254,6 +269,10 @@ class _FileParser:
                 full = re.search(r"#\s*(@colou?r\b.*)$", raw, re.I)
                 self._color(full.group(1).strip() if full else comment, lineno)
                 comment = None
+            m = DBT_RE.match(comment) if comment else None
+            if m and not is_dbt_none(comment):
+                self.fp.set_dbt(m.group(1), lineno)
+                comment = None
             if comment:
                 pending.append(comment)
             elif blank and not seen_data:
@@ -410,7 +429,9 @@ class _FileParser:
             table = Table(ident, caption, fp.path, e.line, aliases, {})
             for c in e.comments:
                 m = TAG_RE.match(c)
-                if not m:
+                if is_dbt_none(c):
+                    table.dbt_skip = True
+                elif not m:
                     table.comments.append(c)
                 elif m.group(1).lower().startswith("dbt"):
                     table.dbt_tags += [t for t in split_tags(m.group(2)) if t not in table.dbt_tags]
@@ -567,6 +588,7 @@ class _FileParser:
                 for c in t.columns.values():
                     if c.type is None and not c.virtual:
                         c.type = default_type
+                        c.type_default = True
         self.fp.layout_entries = sections["layout"]
         return self.fp
 
@@ -628,8 +650,9 @@ def parse_file(text: str, path: str = "<input>") -> FileParse:
 
 
 class _Resolver:
-    def __init__(self, files: list[FileParse]):
+    def __init__(self, files: list[FileParse], dbt: bool = True):
         self.files = files
+        self.dbt = dbt
         self.schema = Schema()
         self.aliases: dict[str, str] = {}
         self._diag: dict[str, list[Diagnostic]] = {f.path: f.diagnostics for f in files}
@@ -803,10 +826,29 @@ class _Resolver:
                     continue
                 s.layout[t.id] = (float(xs), float(ys))
 
+    def apply_dbt(self) -> None:
+        """`# @dbt: PATH`: descriptions, tags and types from that dbt project's yml, plus drift warnings."""
+        named = [(f, Path(f.path).parent / f.dbt[0], f.dbt[1]) for f in self.files if f.dbt]
+        if not named:
+            return
+        first, path, line = named[0]
+        for f, other, ln in named[1:]:
+            if other.resolve() != path.resolve():
+                self.error(f.path, ln, f"@dbt names a different dbt project than {first.path}:{line}")
+        try:
+            self.schema.dbt_root = dbtyml.find_root(path)  # set first: `qdbd serve` watches it even while broken
+            project = dbtyml.load_project(self.schema.dbt_root)
+        except (dbtyml.DbtError, OSError) as e:
+            self.error(first.path, line, f"dbt: {e}")
+            return
+        dbtyml.apply(self.schema, project, self.error)
+
     def run(self) -> Schema:
         self.merge()
         self.resolve_rels()
         self.parse_layout()
+        if self.dbt:
+            self.apply_dbt()
         diags = [d for f in self.files for d in self._diag.get(f.path, [])]
         order = {f.path: i for i, f in enumerate(self.files)}
         diags.sort(key=lambda d: (order.get(d.path, 0), d.line))
@@ -820,15 +862,17 @@ def _same_rel(r: Relationship, a: End, b: End) -> bool:
     )
 
 
-def compile_files(sources: list[tuple[str, str]]) -> tuple[Schema, list[FileParse]]:
+def compile_files(sources: list[tuple[str, str]], dbt: bool = True) -> tuple[Schema, list[FileParse]]:
     """Like ``compile_sources``, also returning each file's own parse (comments, settings, DBML extras)."""
     files = [parse_file(text, path) for path, text in sources]
-    return _Resolver(files).run(), files
+    return _Resolver(files, dbt).run(), files
+
 
+def compile_sources(sources: list[tuple[str, str]], dbt: bool = True) -> Schema:
+    """Compile ``[(path, text), ...]`` into one Schema (tables share one namespace).
 
-def compile_sources(sources: list[tuple[str, str]]) -> Schema:
-    """Compile ``[(path, text), ...]`` into one Schema (tables share one namespace)."""
-    return compile_files(sources)[0]
+    ``dbt=False`` skips `# @dbt:` (the yml is read from disk, which a converted or git-ref copy can't rely on)."""
+    return compile_files(sources, dbt)[0]
 
 
 def compile_text(text: str, path: str = "<input>") -> Schema:

quickdbd_cli/serve.py

@@ -1,12 +1,13 @@
 """`qdbd serve`: local live editor.
 
-Watches the schema files (mtime polling), recompiles on change and pushes a reload event to the
-page over Server-Sent Events. Dragged table positions are saved to the layout sidecar; the
-browser editor pane writes the .txt/.dbml files, refusing to overwrite a file changed on disk since
-the browser last loaded it. With ``read_only`` the page is the plain viewer plus live reload, and
-the server never writes anything. With ``embed`` (the VS Code extension's preview) the page is the
-viewer plus live reload; dragging still saves the layout, but files are only edited in VS Code. With
-``diff_base`` every reload is coloured by its changes since that git ref, like ``build --diff-base``.
+Watches the schema files and the dbt project a `# @dbt:` line names (mtime polling), recompiles on
+change and pushes a reload event to the page over Server-Sent Events. Dragged table positions are
+saved to the layout sidecar; the browser editor pane writes the .txt/.dbml files, refusing to
+overwrite a file changed on disk since the browser last loaded it. With ``read_only`` the page is
+the plain viewer plus live reload, and the server never writes anything. With ``embed`` (the VS Code
+extension's preview) the page is the viewer plus live reload; dragging still saves the layout, but
+files are only edited in VS Code. With ``diff_base`` every reload is coloured by its changes since
+that git ref, like ``build --diff-base``.
 """
 
 from __future__ import annotations
@@ -22,7 +23,7 @@ from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 from pathlib import Path
 from urllib.parse import urlsplit
 
-from . import diff, layout
+from . import dbtyml, diff, layout
 from .html import render_page
 from .parser import syntax_of
 from .project import Project, discover, display_path
@@ -43,16 +44,26 @@ class State:
         self.files: list[Path] = []
         # mtimes are strings: nanosecond integers exceed JavaScript's safe integer range.
         self.mtimes: dict[str, str] = {}
+        self.dbt_root: Path | None = None
         self.reload(initial=True)
 
     def _scan(self) -> dict[str, str]:
         self.files = discover(self.project.inputs)
         self.project.files = self.files
-        return {display_path(f): str(f.stat().st_mtime_ns) for f in self.files}
+        out = {display_path(f): str(f.stat().st_mtime_ns) for f in self.files}
+        if self.dbt_root:
+            try:
+                out.update({f"dbt:{f}": str(f.stat().st_mtime_ns) for f in dbtyml.watched_files(self.dbt_root)})
+            except (dbtyml.DbtError, OSError):
+                out["dbt:"] = "unreadable"
+        return out
 
     def reload(self, initial: bool = False) -> None:
         mtimes = self._scan()
         schema = self.project.compile()
+        if schema.dbt_root != self.dbt_root:  # a `# @dbt:` line was added, removed or changed
+            self.dbt_root = schema.dbt_root
+            mtimes = self._scan()
         diags = [
             {"path": d.path, "line": d.line, "message": d.message, "severity": d.severity, "text": d.format()}
             for d in schema.diagnostics

quickdbd_cli/tags.py

@@ -4,7 +4,7 @@ A table's tags come from the first source that has any:
 
 1. explicit ``# @tag: dim, pii`` comments;
 2. its name: ``dim_*`` / ``DimCustomer`` -> dim, ``fct_*`` -> fact, ``stg_*`` -> staging, ...;
-3. ``# @dbt-tags: ...`` comments written by ``qdbd import dbt``.
+3. dbt tags: ``# @dbt-tags: ...`` comments written by ``qdbd import dbt``, and the yml's tags (``# @dbt: PATH``).
 
 The header takes the colour of the table's first tag. ``# @color TAG #hex`` overrides the defaults, and a DBML
 ``headercolor`` beats both.
@@ -70,7 +70,7 @@ def table_tags(t: Table) -> list[str]:
     tag = name_tag(t.name)
     if tag:
         return [tag]
-    return list(t.dbt_tags)
+    return list(dict.fromkeys(t.dbt_tags + (t.dbt.tags if t.dbt else [])))
 
 
 def tag_colors(schema: Schema, tag_lists: Iterable[list[str]]) -> dict[str, str]:

{quickdbd_cli-0.4.3.dist-info → quickdbd_cli-0.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: quickdbd-cli
-Version: 0.4.3
+Version: 0.6.0
 Summary: Compile QuickDBD-syntax schema files into interactive HTML ER diagrams, with no table limit.
 Project-URL: Homepage, https://qdbd.dev/
 Project-URL: Documentation, https://qdbd.dev/guide/
@@ -25,6 +25,7 @@ Classifier: Topic :: Database
 Classifier: Topic :: Software Development :: Documentation
 Requires-Python: >=3.11
 Requires-Dist: mini-racer>=0.14
+Requires-Dist: pyyaml>=6
 Requires-Dist: resvg-py>=0.5
 Provides-Extra: dev
 Requires-Dist: fonttools>=4.50; extra == 'dev'
@@ -193,7 +194,7 @@ jobs:
     permissions: { contents: read, pull-requests: write }
     steps:
       - uses: actions/checkout@v4
-      - uses: MarkPhamm/quickdbd-cli@v0.4.2
+      - uses: MarkPhamm/quickdbd-cli@v0.6.0
         with:
           path: erd/                  # schema file(s) or folder(s)
           output: site/index.html

{quickdbd_cli-0.4.3.dist-info → quickdbd_cli-0.6.0.dist-info}/RECORD

@@ -1,23 +1,24 @@
-quickdbd_cli/__init__.py,sha256=Nyg0pmk5ea9-SLCAFEIF96ByFx4-TJFtrqYPN-Zn6g4,22
+quickdbd_cli/__init__.py,sha256=cID1jLnC_vj48GgMN6Yb1FA3JsQ95zNmCHmRYE8TFhY,22
 quickdbd_cli/__main__.py,sha256=E6Gls0DNz8GQK2K-kOUIx8cYhgANW_CH54VKrfCfs14,52
 quickdbd_cli/agent.py,sha256=LEuReTkwWDlRLs-GfQQMpMosHDFWbin0EAXRo73j-dA,37202
-quickdbd_cli/cli.py,sha256=kphlsJHzp-agb01rlw4PD2_SnriOtr-yRZPuW3I5B_E,30634
-quickdbd_cli/convert.py,sha256=1AYFm4YmEav_wZp7xCAcL7TsD3qC17Y1I5g6V_fyAU0,16682
-quickdbd_cli/dbml.py,sha256=tHJOtMm1PHx4-yqs6rncPqdDfbwPcW8F54j_kKlWkx0,59413
-quickdbd_cli/dbt.py,sha256=AMHzERmc8WfL1tBLX4bJdPVghIHrqrfx8nMDbZMrueY,23100
-quickdbd_cli/diff.py,sha256=UBiCE3dk_cN-xSRZFQoLiIIFh_FAVZUpLwsdtHG9eBo,9986
+quickdbd_cli/cli.py,sha256=Edv-kROpZOdHA1J1O_G7LrgzrqVJe5pxHJydNnYUs8M,33875
+quickdbd_cli/convert.py,sha256=7jhkXg4csH-sFfJeTYrDtYL-A3HzGojgZtizPsckO0w,17200
+quickdbd_cli/dbml.py,sha256=jCgGH5YH0JG1Necsjhru1PyE52wdlaJd8QAuqn5JIts,59828
+quickdbd_cli/dbt.py,sha256=0S7x7DpV6EcBTR6LJ62elZGMw-Guq-r3jULV1JWU5vs,23184
+quickdbd_cli/dbtyml.py,sha256=iFS1cxJUmJrKWfGd6zgFvoPV3C3in4eIF5sRgxUvhOw,11667
+quickdbd_cli/diff.py,sha256=RpoEe7rAFGhittdsHoIQvbFDaRPnvthYXjUH0PCfTxY,9997
 quickdbd_cli/export.py,sha256=XbSvWqFmhQHPcBtPHPit1SmhJ6qXrPyGlHYt7FpIMyo,3539
-quickdbd_cli/html.py,sha256=eZSECAaP-vxC_qGXOy0T7cXT7WkJeL7RixYvzMCDCZQ,8309
+quickdbd_cli/html.py,sha256=tcbxiUmKhKfpAb7Pke1AVSRPK5VWaw9znpOi_3mQkoQ,9634
 quickdbd_cli/jsrt.py,sha256=_sRkmUbgHDTwK272jeTNUwojfjUKAkv4UeD2E2u3H1A,3464
 quickdbd_cli/layout.py,sha256=2wrryJ-SSJbMlOdxmtCTzC2_zkTtvRVs-OuOBS1bGEQ,10856
 quickdbd_cli/mcp.py,sha256=ibUg1a50BBco-hZABdxTexGZi_gclFCdcBDalTvFar8,12350
-quickdbd_cli/measure.py,sha256=Nyk47FiJokPvTStKz23mgXkO0HnXKWOts90kp1gCjng,5969
-quickdbd_cli/model.py,sha256=lQcj89gDg2y4v_xhJX0_PWoWKGx0rg2emREVL_LA6uQ,3352
-quickdbd_cli/parser.py,sha256=MpWvYWNMIfl8PNKGDyVqVA_RUsuD21oZQqTT7yZd89g,33018
+quickdbd_cli/measure.py,sha256=M1Rnf8iLGI1o2ZpbblfPUcAlXItsjHB3zKKA-yd2fQs,5995
+quickdbd_cli/model.py,sha256=_TsWSjyF9N62xYuC-hJwk7VsQ2qGU40Af-_6oRrxhG0,4748
+quickdbd_cli/parser.py,sha256=bdM1KyVGBJKeVY3SUbrKswQ-xqNkaijraHTBqj_qqv0,35066
 quickdbd_cli/project.py,sha256=Iu6aXJNxCbM9KDRbLaxTb7SfbVDv7PkajzKZX4-XfDk,4570
-quickdbd_cli/serve.py,sha256=NqYAcfT4lySRckAG2tkrZwmRbzYDjdNh18Yh4Er_hPo,12271
+quickdbd_cli/serve.py,sha256=_3VHnHc2GRWVnzfowy-8rQNIULEr9DSQ-ylucEaPmtw,12801
 quickdbd_cli/share.py,sha256=njzF4HpQ-ymusLzzNb_ndvqWGlDaljx7TFP-mZj4lPU,4782
-quickdbd_cli/tags.py,sha256=fOMcz3N8YAIqh5uJJ3GuYMBCkfOViGRCVNb3Ufz63GM,4098
+quickdbd_cli/tags.py,sha256=8SjC9K4g8oBYvlFYUXwqRa7EGfheY0T52aGCovJ3nHE,4194
 quickdbd_cli/targets.py,sha256=zvge0c2_XOC13gnv2C_XMf_ZmDcpOFPzld2PoyOtyxU,8740
 quickdbd_cli/assets/Inter-Bold.ttf,sha256=KIMWCZseCkekcW0VkJgAXu98AGaSHzTjIAOT29sBlH8,420428
 quickdbd_cli/assets/Inter-Bold.woff2,sha256=-oiBJ7baAVtlVp8DUfO1w5GtkokElR8cIOn4RiqNleo,114840
@@ -31,13 +32,13 @@ quickdbd_cli/assets/font-metrics.json,sha256=sXSiElxQSK8md8IEePLwh16TTdAqKt9rV14
 quickdbd_cli/assets/icon.svg,sha256=z1KKpKN3dJbESzbC1EDS3NYOj9aKQw1pJfzwXFPg_M0,338
 quickdbd_cli/assets/render.js,sha256=WzxX_sUgdz0O4GgiaupKl8J_LI4YCqF9PUxzRbwebwo,31891
 quickdbd_cli/assets/style.css,sha256=mTkpexDcMilBtds2WRk6SYiCrIA1DpZLueKmm3pRQw0,18877
-quickdbd_cli/assets/syntax-reference.md,sha256=WERcsWjyrfeHQPgxQriWKBsqFJnmWTQ2oRZjKYAHhKc,5322
+quickdbd_cli/assets/syntax-reference.md,sha256=r-zMxIrtMLRhTa2QHANmlz4Z_t-8oN-5Rp66j4WzZU4,5743
 quickdbd_cli/assets/viewer.js,sha256=3rKXI80TNv9jF1dJNQa3Gpy0042yTcGfTz_8qg4h5WU,49676
-quickdbd_cli-0.4.3.dist-info/METADATA,sha256=Pqgb4PK2vhe2yV7UDNeeTxFdDcnSeZa_qeJXKEAdzEw,17704
-quickdbd_cli-0.4.3.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
-quickdbd_cli-0.4.3.dist-info/entry_points.txt,sha256=nRhiYYug-XOY95nWUmi4oanico3Zjkfqk2OHtIE6SQ0,47
-quickdbd_cli-0.4.3.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-quickdbd_cli-0.4.3.dist-info/licenses/NOTICE,sha256=pyv3BfIYiGzKLU4w-GcBe7GXoXxHqZ97Mf6Zpx_3_i0,2067
-quickdbd_cli-0.4.3.dist-info/licenses/src/quickdbd_cli/assets/Inter-LICENSE.txt,sha256=JiSB6ERSGzJvXs0FPlm5jIstp4yO4b27boF0MF5Uk1o,4380
-quickdbd_cli-0.4.3.dist-info/licenses/src/quickdbd_cli/assets/elk-LICENSE.md,sha256=Y36B9KG2tAeVNcSZ_KBeI4z3YFwf9bdtYNfafOlnAMk,14443
-quickdbd_cli-0.4.3.dist-info/RECORD,,
+quickdbd_cli-0.6.0.dist-info/METADATA,sha256=eziz_n7Q6_slikrg7LJnnjmNv2bmiESUG3eYw-G9Ai0,17729
+quickdbd_cli-0.6.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+quickdbd_cli-0.6.0.dist-info/entry_points.txt,sha256=nRhiYYug-XOY95nWUmi4oanico3Zjkfqk2OHtIE6SQ0,47
+quickdbd_cli-0.6.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+quickdbd_cli-0.6.0.dist-info/licenses/NOTICE,sha256=pyv3BfIYiGzKLU4w-GcBe7GXoXxHqZ97Mf6Zpx_3_i0,2067
+quickdbd_cli-0.6.0.dist-info/licenses/src/quickdbd_cli/assets/Inter-LICENSE.txt,sha256=JiSB6ERSGzJvXs0FPlm5jIstp4yO4b27boF0MF5Uk1o,4380
+quickdbd_cli-0.6.0.dist-info/licenses/src/quickdbd_cli/assets/elk-LICENSE.md,sha256=Y36B9KG2tAeVNcSZ_KBeI4z3YFwf9bdtYNfafOlnAMk,14443
+quickdbd_cli-0.6.0.dist-info/RECORD,,