model2data 1.7.1__tar.gz → 1.7.3__tar.gz

{model2data-1.7.1/model2data.egg-info → model2data-1.7.3}/PKG-INFO

@@ -1,10 +1,11 @@
 Metadata-Version: 2.4
 Name: model2data
-Version: 1.7.1
+Version: 1.7.3
 Summary: Generate analytics-ready datasets from DBML models
 Author: JB Analytica
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/JB-Analytica/model2data
+Project-URL: Studio, https://studio.jbanalytica.com
 Project-URL: Repository, https://github.com/JB-Analytica/model2data
 Project-URL: Issues, https://github.com/JB-Analytica/model2data/issues
 Project-URL: Changelog, https://github.com/JB-Analytica/model2data/blob/main/CHANGELOG.md
@@ -63,6 +64,11 @@ model2data --file examples/ecommerce.dbml --rows 200 --seed 42
 cd dbt_ecommerce && dbt build
 ```
 
+> **Prefer a browser?** [model2data studio](https://studio.jbanalytica.com) is the same
+> engine as a web app: write DBML, watch the entity diagram redraw as you type, see what every
+> column will generate before you generate it, then export CSVs or a runnable dbt project.
+> Nothing to install, free to start.
+
 That's a working analytics stack — real (synthetic) data, tested dbt models, queryable in
 DuckDB — from a schema file, in seconds:
 
@@ -118,6 +124,29 @@ access required.
 
 ---
 
+## model2data studio — the same engine, in the browser
+
+[**model2data studio**](https://studio.jbanalytica.com) puts everything on this page behind a
+web UI. It is built by JB Analytica on top of this library, it's the fastest way to try
+model2data, and it's the better fit while a schema is still being designed:
+
+- **Type DBML, see the diagram.** Syntax highlighting, autocomplete and live error checking; the
+  entity diagram redraws as you type. Click a column to trace what actually joins to it.
+- **See what you'll get before you generate.** Every column shows an example of the value it will
+  produce, and columns nothing recognises are marked — so placeholder data is visible rather than
+  silent.
+- **Generate and export.** Per-table row counts, then CSVs or a complete dbt project: the same
+  seeds, staging models, tests and DuckDB profile this CLI produces, reproducing the exact rows
+  you previewed.
+- **Share the model.** A share link that also embeds as a chrome-free diagram in a Notion,
+  Confluence or wiki page.
+
+Free to start, nothing to install: [studio.jbanalytica.com](https://studio.jbanalytica.com).
+The CLI stays the right tool for scripting, CI and fixtures you commit; the studio is where a
+model gets designed and shown.
+
+---
+
 ## Installation
 
 ```bash
@@ -323,4 +352,6 @@ MIT License. See LICENSE for details.
   <br>
   Built and maintained by <a href="https://www.jbanalytica.com"><strong>JB Analytica</strong></a> —
   Data & Analytics Engineering · Data Platform Architecture · Modern BI.
+  <br>
+  Try <a href="https://studio.jbanalytica.com"><strong>model2data studio</strong></a> — model2data in the browser, nothing to install.
 </p>

{model2data-1.7.1 → model2data-1.7.3}/README.md

@@ -26,6 +26,11 @@ model2data --file examples/ecommerce.dbml --rows 200 --seed 42
 cd dbt_ecommerce && dbt build
 ```
 
+> **Prefer a browser?** [model2data studio](https://studio.jbanalytica.com) is the same
+> engine as a web app: write DBML, watch the entity diagram redraw as you type, see what every
+> column will generate before you generate it, then export CSVs or a runnable dbt project.
+> Nothing to install, free to start.
+
 ---
 
 ## Why this exists
@@ -112,6 +117,30 @@ flowchart LR
 
 ---
 
+## model2data studio — the same engine, in the browser
+
+[**model2data studio**](https://studio.jbanalytica.com) puts everything on this page behind a
+web UI. It is built by JB Analytica on top of this library, it's the fastest way to try
+model2data, and it's the better fit while a schema is still being designed:
+
+- **Type DBML, see the diagram.** Syntax highlighting, autocomplete and live error checking; the
+  entity diagram redraws as you type. Click a column to trace what actually joins to it.
+- **See what you'll get before you generate.** Every column shows an example of the value it will
+  produce, and columns nothing recognises are marked — so placeholder data is visible rather than
+  silent.
+- **Generate and export.** Per-table row counts, then CSVs or a complete dbt project: the same
+  seeds, staging models, tests and DuckDB profile this CLI produces, reproducing the exact rows
+  you previewed.
+- **Share the model.** A share link that also embeds as a chrome-free diagram in a Notion,
+  Confluence or wiki page.
+
+Free to start, nothing to install: [studio.jbanalytica.com](https://studio.jbanalytica.com)
+([plans and pricing](https://www.jbanalytica.com/model2data/pricing/)).
+The CLI stays the right tool for scripting, CI and fixtures you commit; the studio is where a
+model gets designed and shown.
+
+---
+
 ## Installation
 
 ```bash
@@ -428,4 +457,6 @@ MIT License. See LICENSE for details.
   <br>
   Built and maintained by <a href="https://www.jbanalytica.com"><strong>JB Analytica</strong></a> —
   Data & Analytics Engineering · Data Platform Architecture · Modern BI.
+  <br>
+  Try <a href="https://studio.jbanalytica.com"><strong>model2data studio</strong></a> — model2data in the browser, nothing to install.
 </p>

{model2data-1.7.1 → model2data-1.7.3}/README_PYPI.md

@@ -19,6 +19,11 @@ model2data --file examples/ecommerce.dbml --rows 200 --seed 42
 cd dbt_ecommerce && dbt build
 ```
 
+> **Prefer a browser?** [model2data studio](https://studio.jbanalytica.com) is the same
+> engine as a web app: write DBML, watch the entity diagram redraw as you type, see what every
+> column will generate before you generate it, then export CSVs or a runnable dbt project.
+> Nothing to install, free to start.
+
 That's a working analytics stack — real (synthetic) data, tested dbt models, queryable in
 DuckDB — from a schema file, in seconds:
 
@@ -74,6 +79,29 @@ access required.
 
 ---
 
+## model2data studio — the same engine, in the browser
+
+[**model2data studio**](https://studio.jbanalytica.com) puts everything on this page behind a
+web UI. It is built by JB Analytica on top of this library, it's the fastest way to try
+model2data, and it's the better fit while a schema is still being designed:
+
+- **Type DBML, see the diagram.** Syntax highlighting, autocomplete and live error checking; the
+  entity diagram redraws as you type. Click a column to trace what actually joins to it.
+- **See what you'll get before you generate.** Every column shows an example of the value it will
+  produce, and columns nothing recognises are marked — so placeholder data is visible rather than
+  silent.
+- **Generate and export.** Per-table row counts, then CSVs or a complete dbt project: the same
+  seeds, staging models, tests and DuckDB profile this CLI produces, reproducing the exact rows
+  you previewed.
+- **Share the model.** A share link that also embeds as a chrome-free diagram in a Notion,
+  Confluence or wiki page.
+
+Free to start, nothing to install: [studio.jbanalytica.com](https://studio.jbanalytica.com).
+The CLI stays the right tool for scripting, CI and fixtures you commit; the studio is where a
+model gets designed and shown.
+
+---
+
 ## Installation
 
 ```bash
@@ -279,4 +307,6 @@ MIT License. See LICENSE for details.
   <br>
   Built and maintained by <a href="https://www.jbanalytica.com"><strong>JB Analytica</strong></a> —
   Data & Analytics Engineering · Data Platform Architecture · Modern BI.
+  <br>
+  Try <a href="https://studio.jbanalytica.com"><strong>model2data studio</strong></a> — model2data in the browser, nothing to install.
 </p>

{model2data-1.7.1 → model2data-1.7.3}/model2data/generate/core.py

@@ -283,19 +283,23 @@ def generate_data_from_dbml(
                 continue
 
             # find FK linking child → parent
-            fk_column = next(
+            fk_ref = next(
                 (
-                    r["source_column"]
+                    r
                     for r in fk_refs
                     if r["source_table"] == table_name and r["target_table"] == parent_table
                 ),
                 None,
             )
+            if fk_ref is None:
+                continue
 
-            if not fk_column or fk_column not in df.columns:
+            fk_column = fk_ref["source_column"]
+            parent_key = fk_ref["target_column"]
+            if fk_column not in df.columns or parent_key not in parent_df.columns:
                 continue
 
-            lookup = parent_df.groupby("id")[parent_column].first().to_dict()
+            lookup = parent_df.groupby(parent_key)[parent_column].first().to_dict()
 
             df[child_column] = df[fk_column].map(lookup)
 

model2data-1.7.3/model2data/generate/relationships.py

@@ -0,0 +1,95 @@
+from typing import Dict, List, Optional, Tuple
+
+from model2data.parse.dbml import ColumnDef, TableDef
+
+
+# ---------------------------------------------------------
+# Public API
+# ---------------------------------------------------------
+def classify_refs(
+    tables: Dict[str, TableDef],
+    refs: List[Dict],
+) -> Tuple[List[Dict], List[Dict]]:
+    """
+    Classify references into:
+        - fk_refs: Foreign keys (target column is a key of its table)
+        - attribute_refs: Non-FK dependencies (mirroring parent attributes)
+
+    A Ref onto a primary key, or a column named "id", is always a foreign key.
+    A Ref onto a unique column is one too -- dbt projects commonly declare
+    their keys with `unique` + `not_null` tests rather than a primary key
+    constraint -- unless the child already has a primary-key FK to the same
+    parent. Then it stays an attribute ref and is mirrored through that FK, so
+    `orders.customer_email > customers.email` next to
+    `orders.customer_id > customers.id` keeps the email the customer's own.
+    """
+    kinds = [_key_kind(tables, ref) for ref in refs]
+    pk_pairs = {
+        (ref["source_table"], ref["target_table"])
+        for ref, kind in zip(refs, kinds, strict=True)
+        if kind == "pk"
+    }
+
+    fk_refs = []
+    attribute_refs = []
+    for ref, kind in zip(refs, kinds, strict=True):
+        pair = (ref["source_table"], ref["target_table"])
+        if kind == "pk" or (kind == "unique" and pair not in pk_pairs):
+            fk_refs.append(ref)
+        else:
+            attribute_refs.append(ref)
+
+    return fk_refs, attribute_refs
+
+
+def _key_kind(tables: Dict[str, TableDef], ref: Dict) -> Optional[str]:
+    """Whether the column a Ref points at is a "pk", a "unique" key, or neither (None)."""
+    table = tables.get(ref["target_table"])
+    if table is None:
+        return None
+    column = next((c for c in table.columns if c.name == ref["target_column"]), None)
+    if column is None:
+        return None
+    if _is_primary_key(table, column):
+        return "pk"
+    if _is_unique(table, column):
+        return "unique"
+    return None
+
+
+def _single_column_keys(table: TableDef, key_type: str) -> set:
+    return {
+        key["columns"][0]
+        for key in table.composite_keys
+        if key["type"] == key_type and len(key["columns"]) == 1
+    }
+
+
+def _is_primary_key(table: TableDef, column: ColumnDef) -> bool:
+    return (
+        "pk" in column.settings
+        or "primary key" in column.settings
+        or column.name.lower() == "id"
+        or column.name in _single_column_keys(table, "pk")
+    )
+
+
+def _is_unique(table: TableDef, column: ColumnDef) -> bool:
+    return "unique" in column.settings or column.name in _single_column_keys(table, "unique")
+
+
+def build_fk_lookup(fk_refs: List[Dict]) -> Dict[Tuple[str, str], Tuple[str, str]]:
+    """
+    Build a lookup dictionary for FK relationships.
+
+    Returns:
+        {
+            (child_table, child_column): (parent_table, parent_column)
+        }
+    """
+    lookup: Dict[Tuple[str, str], Tuple[str, str]] = {}
+    for ref in fk_refs:
+        key = (ref["source_table"], ref["source_column"])
+        value = (ref["target_table"], ref["target_column"])
+        lookup[key] = value
+    return lookup

{model2data-1.7.1 → model2data-1.7.3/model2data.egg-info}/PKG-INFO

@@ -1,10 +1,11 @@
 Metadata-Version: 2.4
 Name: model2data
-Version: 1.7.1
+Version: 1.7.3
 Summary: Generate analytics-ready datasets from DBML models
 Author: JB Analytica
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/JB-Analytica/model2data
+Project-URL: Studio, https://studio.jbanalytica.com
 Project-URL: Repository, https://github.com/JB-Analytica/model2data
 Project-URL: Issues, https://github.com/JB-Analytica/model2data/issues
 Project-URL: Changelog, https://github.com/JB-Analytica/model2data/blob/main/CHANGELOG.md
@@ -63,6 +64,11 @@ model2data --file examples/ecommerce.dbml --rows 200 --seed 42
 cd dbt_ecommerce && dbt build
 ```
 
+> **Prefer a browser?** [model2data studio](https://studio.jbanalytica.com) is the same
+> engine as a web app: write DBML, watch the entity diagram redraw as you type, see what every
+> column will generate before you generate it, then export CSVs or a runnable dbt project.
+> Nothing to install, free to start.
+
 That's a working analytics stack — real (synthetic) data, tested dbt models, queryable in
 DuckDB — from a schema file, in seconds:
 
@@ -118,6 +124,29 @@ access required.
 
 ---
 
+## model2data studio — the same engine, in the browser
+
+[**model2data studio**](https://studio.jbanalytica.com) puts everything on this page behind a
+web UI. It is built by JB Analytica on top of this library, it's the fastest way to try
+model2data, and it's the better fit while a schema is still being designed:
+
+- **Type DBML, see the diagram.** Syntax highlighting, autocomplete and live error checking; the
+  entity diagram redraws as you type. Click a column to trace what actually joins to it.
+- **See what you'll get before you generate.** Every column shows an example of the value it will
+  produce, and columns nothing recognises are marked — so placeholder data is visible rather than
+  silent.
+- **Generate and export.** Per-table row counts, then CSVs or a complete dbt project: the same
+  seeds, staging models, tests and DuckDB profile this CLI produces, reproducing the exact rows
+  you previewed.
+- **Share the model.** A share link that also embeds as a chrome-free diagram in a Notion,
+  Confluence or wiki page.
+
+Free to start, nothing to install: [studio.jbanalytica.com](https://studio.jbanalytica.com).
+The CLI stays the right tool for scripting, CI and fixtures you commit; the studio is where a
+model gets designed and shown.
+
+---
+
 ## Installation
 
 ```bash
@@ -323,4 +352,6 @@ MIT License. See LICENSE for details.
   <br>
   Built and maintained by <a href="https://www.jbanalytica.com"><strong>JB Analytica</strong></a> —
   Data & Analytics Engineering · Data Platform Architecture · Modern BI.
+  <br>
+  Try <a href="https://studio.jbanalytica.com"><strong>model2data studio</strong></a> — model2data in the browser, nothing to install.
 </p>

{model2data-1.7.1 → model2data-1.7.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "model2data"
-version = "1.7.1"
+version = "1.7.3"
 description = "Generate analytics-ready datasets from DBML models"
 readme = "README_PYPI.md"
 requires-python = ">=3.10"
@@ -60,6 +60,7 @@ dev = [
 
 [project.urls]
 Homepage = "https://github.com/JB-Analytica/model2data"
+Studio = "https://studio.jbanalytica.com"
 Repository = "https://github.com/JB-Analytica/model2data"
 Issues = "https://github.com/JB-Analytica/model2data/issues"
 Changelog = "https://github.com/JB-Analytica/model2data/blob/main/CHANGELOG.md"

{model2data-1.7.1 → model2data-1.7.3}/tests/test_dbt_tests.py

@@ -638,3 +638,41 @@ def test_generic_tests_nest_parameters_under_arguments(tmp_path):
     assert set(relationships) == {"arguments"}, "params must live under `arguments:`"
     assert relationships["arguments"]["to"] == "ref('stg_customers')"
     assert relationships["arguments"]["field"] == "id"
+
+
+def test_relationships_test_emitted_for_ref_onto_unique_non_pk_column(tmp_path):
+    """A key declared with `unique` + `not null` rather than `pk` is still a
+    foreign-key target: the generator draws the child from the parent's
+    values, so the project gets the relationships test that proves it.
+    """
+    tables = {
+        "customers": TableDef(
+            name="customers",
+            columns=[ColumnDef("customer_id", "int", {"not null", "unique"})],
+        ),
+        "orders": TableDef(
+            name="orders",
+            columns=[
+                ColumnDef("order_id", "int", {"not null", "unique"}),
+                ColumnDef("customer_id", "int", {"not null"}),
+            ],
+        ),
+    }
+    refs = [
+        {
+            "source_table": "orders",
+            "source_column": "customer_id",
+            "target_table": "customers",
+            "target_column": "customer_id",
+        }
+    ]
+    generate_dbt_yml(tmp_path, tables, refs, source_name="shop")
+
+    stg_yaml = yaml.safe_load((tmp_path / "models" / "staging" / "stg_orders.yml").read_text())
+    orders_col = next(c for c in stg_yaml["models"][0]["columns"] if c["name"] == "customer_id")
+    relationship_test = next(
+        t["relationships"]
+        for t in orders_col["tests"]
+        if isinstance(t, dict) and "relationships" in t
+    )
+    assert relationship_test["arguments"]["field"] == "customer_id"

{model2data-1.7.1 → model2data-1.7.3}/tests/test_generation.py

@@ -958,3 +958,168 @@ def test_row_overrides_are_deterministic_with_a_seed():
 
     assert first["users"].equals(second["users"])
     assert first["orders"].equals(second["orders"])
+
+
+def _customers_and_orders_on_a_unique_key() -> tuple[dict, list[dict]]:
+    # The shape a dbt import produces when the key is declared with
+    # `unique` + `not_null` tests rather than a primary key constraint.
+    tables = {
+        "customers": TableDef(
+            name="customers",
+            columns=[
+                ColumnDef("customer_id", "int", {"not null", "unique"}),
+                ColumnDef("name", "varchar"),
+            ],
+        ),
+        "orders": TableDef(
+            name="orders",
+            columns=[
+                ColumnDef("order_id", "int", {"not null", "unique"}),
+                ColumnDef("customer_id", "int", {"not null"}),
+            ],
+        ),
+    }
+    refs = [
+        {
+            "source_table": "orders",
+            "source_column": "customer_id",
+            "target_table": "customers",
+            "target_column": "customer_id",
+        }
+    ]
+    return tables, refs
+
+
+def test_ref_onto_a_unique_non_pk_column_is_a_foreign_key():
+    # At the default 100 rows the column's own integer range is wider than the
+    # parent's keys, so a ref treated as unrelated data fails the dbt
+    # relationships test on about half of all seeds.
+    tables, refs = _customers_and_orders_on_a_unique_key()
+    for seed in range(42, 62):
+        data = generate_data_from_dbml(tables, refs, base_rows=100, seed=seed)
+        parent_keys = set(data["customers"]["customer_id"])
+        assert set(data["orders"]["customer_id"]) <= parent_keys, seed
+
+
+def test_ref_onto_a_unique_index_column_is_a_foreign_key():
+    tables, refs = _customers_and_orders_on_a_unique_key()
+    tables["customers"].columns[0].settings = {"not null"}
+    tables["customers"].composite_keys = [{"columns": ["customer_id"], "type": "unique"}]
+    for seed in range(42, 47):
+        data = generate_data_from_dbml(tables, refs, base_rows=100, seed=seed)
+        parent_keys = set(data["customers"]["customer_id"])
+        assert set(data["orders"]["customer_id"]) <= parent_keys, seed
+
+
+def test_ref_onto_a_unique_column_beside_a_pk_fk_is_still_mirrored():
+    tables = {
+        "customers": TableDef(
+            name="customers",
+            columns=[
+                ColumnDef("id", "int", {"pk"}),
+                ColumnDef("email", "varchar", {"unique"}),
+            ],
+        ),
+        "orders": TableDef(
+            name="orders",
+            columns=[
+                ColumnDef("id", "int", {"pk"}),
+                ColumnDef("customer_id", "int"),
+                ColumnDef("customer_email", "varchar"),
+            ],
+        ),
+    }
+    refs = [
+        {
+            "source_table": "orders",
+            "source_column": "customer_id",
+            "target_table": "customers",
+            "target_column": "id",
+        },
+        {
+            "source_table": "orders",
+            "source_column": "customer_email",
+            "target_table": "customers",
+            "target_column": "email",
+        },
+    ]
+    data = generate_data_from_dbml(tables, refs, base_rows=50, seed=7)
+    email_of = data["customers"].set_index("id")["email"]
+    orders = data["orders"]
+    assert orders["customer_email"].equals(orders["customer_id"].map(email_of))
+
+
+def test_mirroring_goes_through_a_foreign_key_onto_a_non_id_key():
+    tables, refs = _customers_and_orders_on_a_unique_key()
+    tables["orders"].columns.append(ColumnDef("customer_name", "varchar"))
+    refs.append(
+        {
+            "source_table": "orders",
+            "source_column": "customer_name",
+            "target_table": "customers",
+            "target_column": "name",
+        }
+    )
+    data = generate_data_from_dbml(tables, refs, base_rows=50, seed=7)
+    name_of = data["customers"].set_index("customer_id")["name"]
+    orders = data["orders"]
+    assert orders["customer_name"].equals(orders["customer_id"].map(name_of))
+
+
+def test_mirroring_is_skipped_when_the_fk_column_is_not_in_the_child_table():
+    # A Ref naming a child column the table doesn't declare still classifies
+    # as a foreign key; the mirror that would ride on it has nothing to read.
+    tables = {
+        "customers": TableDef(
+            name="customers",
+            columns=[ColumnDef("id", "int", {"pk"}), ColumnDef("name", "varchar")],
+        ),
+        "orders": TableDef(
+            name="orders",
+            columns=[ColumnDef("id", "int", {"pk"}), ColumnDef("customer_name", "varchar")],
+        ),
+    }
+    refs = [
+        {
+            "source_table": "orders",
+            "source_column": "customer_id",
+            "target_table": "customers",
+            "target_column": "id",
+        },
+        {
+            "source_table": "orders",
+            "source_column": "customer_name",
+            "target_table": "customers",
+            "target_column": "name",
+        },
+    ]
+    data = generate_data_from_dbml(tables, refs, base_rows=20, seed=3)
+    orders = data["orders"]
+    assert "customer_id" not in orders.columns
+    assert not orders["customer_name"].isin(data["customers"]["name"]).all()
+
+
+def test_attribute_ref_without_fk_is_skipped_when_the_parent_is_generated_first():
+    # Tables with no FK between them are generated in name order, so here the
+    # parent ("accounts") already exists when the child's mirror pass runs and
+    # it is the missing FK, not the missing parent, that skips the mirror.
+    tables = {
+        "accounts": TableDef(
+            name="accounts",
+            columns=[ColumnDef("id", "int", {"pk"}), ColumnDef("name", "varchar")],
+        ),
+        "orders": TableDef(
+            name="orders",
+            columns=[ColumnDef("id", "int", {"pk"}), ColumnDef("account_name", "varchar")],
+        ),
+    }
+    refs = [
+        {
+            "source_table": "orders",
+            "source_column": "account_name",
+            "target_table": "accounts",
+            "target_column": "name",
+        }
+    ]
+    data = generate_data_from_dbml(tables, refs, base_rows=20, seed=2)
+    assert not data["orders"]["account_name"].isin(data["accounts"]["name"]).all()

model2data-1.7.1/model2data/generate/relationships.py

@@ -1,52 +0,0 @@
-from typing import Dict, List, Tuple
-
-from model2data.parse.dbml import TableDef
-
-
-# ---------------------------------------------------------
-# Public API
-# ---------------------------------------------------------
-def classify_refs(
-    tables: Dict[str, TableDef],
-    refs: List[Dict],
-) -> Tuple[List[Dict], List[Dict]]:
-    """
-    Classify references into:
-        - fk_refs: Foreign keys (target column looks like a PK)
-        - attribute_refs: Non-FK dependencies (mirroring parent attributes)
-    """
-    fk_refs = []
-    attribute_refs = []
-
-    for ref in refs:
-        target_table = tables.get(ref["target_table"])
-        target_col = None
-        if target_table:
-            target_col = next(
-                (c for c in target_table.columns if c.name == ref["target_column"]), None
-            )
-
-        # FK if target column is a primary key or named "id"
-        if target_col and ("pk" in target_col.settings or target_col.name.lower() == "id"):
-            fk_refs.append(ref)
-        else:
-            attribute_refs.append(ref)
-
-    return fk_refs, attribute_refs
-
-
-def build_fk_lookup(fk_refs: List[Dict]) -> Dict[Tuple[str, str], Tuple[str, str]]:
-    """
-    Build a lookup dictionary for FK relationships.
-
-    Returns:
-        {
-            (child_table, child_column): (parent_table, parent_column)
-        }
-    """
-    lookup: Dict[Tuple[str, str], Tuple[str, str]] = {}
-    for ref in fk_refs:
-        key = (ref["source_table"], ref["source_column"])
-        value = (ref["target_table"], ref["target_column"])
-        lookup[key] = value
-    return lookup