model2data 1.7.0__tar.gz → 1.7.3__tar.gz

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

@@ -1,10 +1,11 @@
 Metadata-Version: 2.4
 Name: model2data
-Version: 1.7.0
+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.0 → 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
@@ -159,7 +188,10 @@ model2data --file examples/ecommerce.dbml --rows 200 --seed 42 --table-seed orde
 ```
 
 `--locale` picks the country every generated person and address comes from (`en_US` by default);
-it's a per-run setting, so a table can't end up holding one Belgian and one American address:
+it's a per-run setting, so a table can't end up holding one Belgian and one American address. A
+`country` column that sits beside a `city`/`street`/`state`/`postcode` column always agrees with
+that place; a `country` column with none of those beside it isn't describing anyone's address, so
+it reads as an international mix instead, with the locale's own country the most common:
 
 ```bash
 model2data --file examples/ecommerce.dbml --rows 200 --seed 42 --locale nl_BE
@@ -425,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.0 → 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.0 → model2data-1.7.3}/model2data/generate/core.py

@@ -15,6 +15,7 @@ from model2data.generate.faker import (
     release_row_pools,
     reset_duplicate_unique_columns,
     reset_row_pools,
+    resolve_address_pool_field,
     set_locale,
 )
 from model2data.generate.hints import validate_hints
@@ -201,6 +202,12 @@ def generate_data_from_dbml(
             for column_name in key.get("columns") or []
         }
 
+        # A table's own shape, worked out before a single value is drawn: does
+        # this table have a `country` column with no `city`/`street`/`state`/
+        # `postcode` beside it to keep coherent with. See
+        # _lone_country_columns.
+        lone_country_columns = _lone_country_columns(table_def)
+
         # -----------------------
         # First pass: columns + FKs
         # -----------------------
@@ -230,6 +237,7 @@ def generate_data_from_dbml(
                 as_of=as_of,
                 time_profile=profile,
                 skew=skew,
+                lone_country=column.name in lone_country_columns,
             )
 
         df = pd.DataFrame(data)
@@ -275,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)
 
@@ -303,6 +315,31 @@ def generate_data_from_dbml(
 # ---------------------------------------------------------
 # Internal helpers
 # ---------------------------------------------------------
+def _lone_country_columns(table_def: TableDef) -> set[str]:
+    """Names of this table's *lone* country columns.
+
+    A `country` column reads as the locale's own country on every row when it
+    sits beside a `city`/`street`/`state`/`postcode` column -- together they
+    describe one place, and the country has to agree with the rest of it.
+    Alone, repeating that same country on every row reads as a single-country
+    customer base rather than an international one, so
+    `generate_column_values` draws it from a home-heavy mix instead (see
+    `faker._HOME_COUNTRY_SHARE`). `country` columns don't count as company
+    for each other -- only a *different* address-pool field does.
+    """
+    address_fields = {
+        column.name: field
+        for column in table_def.columns
+        for field in [resolve_address_pool_field(column)]
+        if field is not None
+    }
+    country_columns = {name for name, field in address_fields.items() if field == "country"}
+    if not country_columns:
+        return set()
+    has_place_column = any(field != "country" for field in address_fields.values())
+    return set() if has_place_column else country_columns
+
+
 def _coerce_integer_dtypes(df: pd.DataFrame, table_def: TableDef) -> pd.DataFrame:
     """
     Cast int/bigint/smallint-typed columns to pandas' nullable "Int64" dtype.

{model2data-1.7.0 → model2data-1.7.3}/model2data/generate/faker.py

@@ -505,6 +505,42 @@ def _infer_by_type(base_type: str) -> Optional[_Provider]:
     return lambda: fake.format(base_type)
 
 
+def resolve_address_pool_field(column: ColumnDef) -> Optional[str]:
+    """The address-pool field (`street`, `full`, `city`, `state`, `postcode`,
+    `country`) this column would draw from, if any -- else None.
+
+    Same declared-type-then-name precedence `generate_column_values`'s own
+    untyped-column branch uses (`_infer_by_type` before `_infer_by_name`),
+    narrowed to the address pool. Exposed for `generate.core` to tell a
+    *lone* country column -- the only address-pool-shaped column in its
+    table -- from one that sits beside a `city`/`street`/`state`/`postcode`
+    column, before a single value of the table has been generated.
+
+    Restricted to columns that would actually reach that branch: an enum
+    column, or one whose type is a structured (int/date/uuid/...) type, never
+    gets there in `generate_column_values` -- and `_infer_by_type` probes an
+    unrecognized type by actually calling it (`fake.format(base_type)`), so
+    running it over a `date` or `int` column here would consume real draws
+    from the shared RNG and shift every value generated after it, breaking
+    reproducibility for reasons invisible to whoever hits it.
+    """
+    if column.enum_values or not is_free_text_type(column.data_type):
+        return None
+    base_type = column.data_type.lower().split("(")[0].strip()
+    generator = _infer_by_type(base_type) or _infer_by_name(column.name)
+    if isinstance(generator, _FromRow) and generator.pool == "address":
+        return generator.field
+    return None
+
+
+# A lone country column (see resolve_address_pool_field's caller) mixes the
+# locale's own country in with the rest of the world rather than repeating it
+# on every row. 0.6 is a default, not a claim about any real market -- a
+# business selling internationally still has a home market, and most of its
+# rows are plausibly it, but "most" is not "all".
+_HOME_COUNTRY_SHARE = 0.6
+
+
 def _column_time_profile(
     column: ColumnDef, time_profile: Optional[TimeProfile]
 ) -> Optional[TimeProfile]:
@@ -580,6 +616,7 @@ def generate_column_values(
     as_of: AsOf = None,
     time_profile: Optional[TimeProfile] = None,
     skew: float = 0.0,
+    lone_country: bool = False,
 ) -> list:
     """
     Generate synthetic values for a single column.
@@ -591,6 +628,16 @@ def generate_column_values(
     every path that draws a value -- the main pass, the self-referencing FK
     repair, the composite-key retry -- draws it the same way.
 
+    `lone_country` tells the address-pool branch this column is the *only*
+    address-shaped column in its table (see
+    `generate.core._lone_country_columns`). A `country` column that sits
+    beside a `city`/`street`/`state`/`postcode` column still reads that
+    place's own country, byte-identical to earlier releases; a lone one
+    instead draws a home-heavy mix of the locale's country and the wider
+    world, since "Belgium" on every row of a customers table with no other
+    address column reads as a single-country customer base rather than an
+    international one.
+
     `as_of` is the date every generated date and timestamp is placed relative
     to, defaulting to today. Pass it to make a seeded run reproduce on any
     later day rather than only on the day it first ran.
@@ -629,6 +676,7 @@ def generate_column_values(
             as_of=as_of,
             time_profile=time_profile,
             skew=skew,
+            lone_country=lone_country,
         )
         values = random.choices(pool, k=row_count)
         if not force_not_null and "not null" not in column.settings and "pk" not in column.settings:
@@ -827,8 +875,18 @@ def generate_column_values(
     else:
         generator = _infer_by_type(base_type) or _infer_by_name(column.name)
         if isinstance(generator, _FromRow):
-            rows = _row_pool(generator.pool, table_name, row_count)
-            values = [getattr(rows[index], generator.field) for index in range(row_count)]
+            if lone_country and generator.pool == "address" and generator.field == "country":
+                # No sibling city/street/state/postcode column to keep this
+                # one coherent with, so it isn't "this row's place" at all --
+                # draw a home-heavy mix instead of repeating the locale's own
+                # country on every row.
+                values = [
+                    _country_name if random.random() < _HOME_COUNTRY_SHARE else fake.country()
+                    for _ in range(row_count)
+                ]
+            else:
+                rows = _row_pool(generator.pool, table_name, row_count)
+                values = [getattr(rows[index], generator.field) for index in range(row_count)]
             if ensure_unique:
                 values = _deduplicate_identity(values)
         elif generator is not None:

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.0 → model2data-1.7.3/model2data.egg-info}/PKG-INFO

@@ -1,10 +1,11 @@
 Metadata-Version: 2.4
 Name: model2data
-Version: 1.7.0
+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.0 → model2data-1.7.3}/model2data.egg-info/SOURCES.txt

@@ -39,6 +39,7 @@ tests/test_dbt_tests.py
 tests/test_distributions.py
 tests/test_faker_name_inference.py
 tests/test_generation.py
+tests/test_lone_country.py
 tests/test_options.py
 tests/test_release_stress.py
 tests/test_row_identity.py

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "model2data"
-version = "1.7.0"
+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.0 → 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.0 → 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.3/tests/test_lone_country.py

@@ -0,0 +1,132 @@
+"""A lone `country` column reads as an international mix, not one repeated
+country.
+
+Since 1.3.0 every row draws one address from a per-table pool, and that
+pool's country is always the locale's own -- right when a sibling
+city/street/state/postcode column needs it to agree, wrong when `country` is
+the only address-shaped column in the table. These tests pin: the mix (a
+majority-but-not-all home-country share, several distinct countries), that a
+sibling place column switches it back off, that a declared `country` type
+behaves like the name, and that `distinct`/`null_rate`/determinism/locale
+keep working the same way they do everywhere else.
+"""
+
+from model2data.generate.core import generate_data_from_dbml
+from model2data.parse.dbml import ColumnDef, TableDef
+
+
+def _customers_table(*extra_columns: ColumnDef) -> TableDef:
+    return TableDef(
+        name="customers",
+        columns=[
+            ColumnDef(name="id", data_type="int", settings={"pk"}),
+            ColumnDef(name="country", data_type="varchar", settings={"not null"}),
+            *extra_columns,
+        ],
+    )
+
+
+class TestLoneCountryColumn:
+    def test_lone_country_column_reads_as_an_international_mix(self):
+        df = generate_data_from_dbml(
+            tables={"customers": _customers_table()},
+            refs=[],
+            base_rows=500,
+            seed=1,
+            locale="nl_BE",
+        )["customers"]
+
+        counts = df["country"].value_counts(normalize=True)
+        assert len(counts) >= 5
+
+        home_share = counts.get("Belgium", 0.0)
+        assert 0.5 <= home_share <= 0.7
+        assert counts.idxmax() == "Belgium"
+
+    def test_a_sibling_place_column_keeps_the_country_single(self):
+        df = generate_data_from_dbml(
+            tables={
+                "customers": _customers_table(
+                    ColumnDef(name="city", data_type="varchar", settings={"not null"})
+                )
+            },
+            refs=[],
+            base_rows=200,
+            seed=2,
+            locale="nl_BE",
+        )["customers"]
+
+        assert set(df["country"]) == {"Belgium"}
+
+    def test_declared_country_type_behaves_like_the_name(self):
+        df = generate_data_from_dbml(
+            tables={
+                "customers": TableDef(
+                    name="customers",
+                    columns=[
+                        ColumnDef(name="id", data_type="int", settings={"pk"}),
+                        # Named generically; the *declared type* is what
+                        # says "country".
+                        ColumnDef(name="hq", data_type="country", settings={"not null"}),
+                    ],
+                )
+            },
+            refs=[],
+            base_rows=500,
+            seed=3,
+            locale="nl_BE",
+        )["customers"]
+
+        counts = df["hq"].value_counts(normalize=True)
+        assert len(counts) >= 5
+        assert 0.5 <= counts.get("Belgium", 0.0) <= 0.7
+
+    def test_distinct_hint_still_bounds_the_pool(self):
+        df = generate_data_from_dbml(
+            tables={
+                "customers": TableDef(
+                    name="customers",
+                    columns=[
+                        ColumnDef(name="id", data_type="int", settings={"pk"}),
+                        ColumnDef(
+                            name="country",
+                            data_type="varchar",
+                            settings={"not null"},
+                            note={"distinct": 3},
+                        ),
+                    ],
+                )
+            },
+            refs=[],
+            base_rows=300,
+            seed=4,
+            locale="nl_BE",
+        )["customers"]
+
+        assert df["country"].nunique() <= 3
+
+    def test_same_seed_reproduces_the_same_mix(self):
+        def run():
+            return generate_data_from_dbml(
+                tables={"customers": _customers_table()},
+                refs=[],
+                base_rows=200,
+                seed=5,
+                locale="nl_BE",
+            )["customers"]
+
+        first_run, second_run = run(), run()
+        assert list(first_run["country"]) == list(second_run["country"])
+
+    def test_default_locale_also_produces_a_mix(self):
+        df = generate_data_from_dbml(
+            tables={"customers": _customers_table()},
+            refs=[],
+            base_rows=500,
+            seed=6,
+        )["customers"]
+
+        counts = df["country"].value_counts(normalize=True)
+        assert len(counts) >= 5
+        assert 0.5 <= counts.get("United States", 0.0) <= 0.7
+        assert counts.idxmax() == "United States"

model2data-1.7.0/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