model2data 0.4.1__tar.gz → 0.4.3__tar.gz

{model2data-0.4.1 → model2data-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model2data
-Version: 0.4.1
+Version: 0.4.3
 Summary: Generate analytics-ready datasets from DBML models
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -122,7 +122,9 @@ flowchart LR
    (int, date, timestamp, ...), name-aware inference for everything else (`email`, `phone`,
    `city`, ...), foreign keys resolved against already-generated parent rows.
 3. **Scaffold.** Writes a complete dbt project around that data: CSV seeds, staging models with
-   `source`/`not_null`/`unique`/`relationships` tests, and a profile for DuckDB (zero-config,
+   `source`/`not_null`/`unique`/`relationships` tests, `accepted_values` tests for DBML
+   `Enum`-typed columns, singular SQL tests for composite primary/unique keys, table and column
+   `description:` fields pulled from DBML notes, and a profile for DuckDB (zero-config,
    file-based) or Postgres.
 
 ---
@@ -169,7 +171,7 @@ Connection details are read from environment variables (`MODEL2DATA_PG_HOST`, `M
 
 After generation, the CLI prints a short summary — tables and rows generated, relationships found in the DBML, and any columns that fell back to generic placeholder text because neither their type nor name could be matched.
 
-Pass `--unit-tests` to also generate deterministic dbt unit test fixtures (`tests/unit/test_stg_<table>.yml`) from the actually-generated seed rows:
+Pass `--unit-tests` to also generate deterministic dbt unit test fixtures (`models/staging/ut_stg_<table>.yml`) from the actually-generated seed rows:
 
 ```bash
 model2data --file examples/hackernews.dbml --rows 200 --seed 42 --unit-tests
@@ -186,32 +188,36 @@ The generated dbt project includes:
 ```
 dbt_{project_name}/
 ├── seeds/
-│   └── {project_name}/
+│   └── raw/
 │       ├── table1.csv
 │       └── table2.csv
 ├── models/
-│   └── {project_name}/
-│       └── staging/
-│           ├── __sources.yml
-│           ├── stg_table1.sql
-│           ├── stg_table1.yml
-│           └── ...
+│   └── staging/
+│       ├── __sources.yml
+│       ├── stg_table1.sql
+│       ├── stg_table1.yml
+│       ├── ut_stg_table1.yml  # only with --unit-tests
+│       └── ...
+├── data-tests/
+│   └── unique_combination_stg_table1_col_a_col_b.sql  # only for composite pk/unique keys
 ├── macros/
 │   └── generate_schema_name.sql
 ├── dbt_project.yml
 ├── profiles.yml  # DuckDB or Postgres config, depending on --adapter
-└── {project_name}.duckdb  # DuckDB adapter only
+└── {project_name}_profile.duckdb  # DuckDB adapter only
 ```
 
 - **Seeds**: CSV files with generated synthetic data.
 - **Staging Models**: Basic dbt models that load from seeds.
 - **Sources & Tests**: YAML configs defining sources and column tests (`not_null`, `unique`,
   `relationships`, and `accepted_values` for DBML `Enum`-typed columns). Table and column
-  `Note` text from the DBML becomes `description:` fields. Composite primary/unique keys
-  declared in an `indexes { }` block get a singular SQL test under `tests/`.
+  `Note` text from the DBML becomes `description:` fields.
+- **Composite key tests**: Composite primary/unique keys declared in an `indexes { }` block get
+  a singular SQL test under `data-tests/`, dbt's configured `test-paths`.
 - **Profiles**: Pre-configured for DuckDB (file-based) or Postgres (via env vars), with schema handling.
-- **Unit tests** (opt-in via `--unit-tests`): `tests/unit/test_stg_<table>.yml` fixtures built
-  from real generated rows. Requires dbt-core >= 1.8.
+- **Unit tests** (opt-in via `--unit-tests`): `models/staging/ut_stg_<table>.yml` fixtures built
+  from real generated rows, co-located with each staging model so dbt (which only parses unit
+  tests from `model-paths`) picks them up. Requires dbt-core >= 1.8.
 
 ---
 

{model2data-0.4.1 → model2data-0.4.3}/README.md

@@ -97,7 +97,9 @@ flowchart LR
    (int, date, timestamp, ...), name-aware inference for everything else (`email`, `phone`,
    `city`, ...), foreign keys resolved against already-generated parent rows.
 3. **Scaffold.** Writes a complete dbt project around that data: CSV seeds, staging models with
-   `source`/`not_null`/`unique`/`relationships` tests, and a profile for DuckDB (zero-config,
+   `source`/`not_null`/`unique`/`relationships` tests, `accepted_values` tests for DBML
+   `Enum`-typed columns, singular SQL tests for composite primary/unique keys, table and column
+   `description:` fields pulled from DBML notes, and a profile for DuckDB (zero-config,
    file-based) or Postgres.
 
 ---
@@ -144,7 +146,7 @@ Connection details are read from environment variables (`MODEL2DATA_PG_HOST`, `M
 
 After generation, the CLI prints a short summary — tables and rows generated, relationships found in the DBML, and any columns that fell back to generic placeholder text because neither their type nor name could be matched.
 
-Pass `--unit-tests` to also generate deterministic dbt unit test fixtures (`tests/unit/test_stg_<table>.yml`) from the actually-generated seed rows:
+Pass `--unit-tests` to also generate deterministic dbt unit test fixtures (`models/staging/ut_stg_<table>.yml`) from the actually-generated seed rows:
 
 ```bash
 model2data --file examples/hackernews.dbml --rows 200 --seed 42 --unit-tests
@@ -161,32 +163,36 @@ The generated dbt project includes:
 ```
 dbt_{project_name}/
 ├── seeds/
-│   └── {project_name}/
+│   └── raw/
 │       ├── table1.csv
 │       └── table2.csv
 ├── models/
-│   └── {project_name}/
-│       └── staging/
-│           ├── __sources.yml
-│           ├── stg_table1.sql
-│           ├── stg_table1.yml
-│           └── ...
+│   └── staging/
+│       ├── __sources.yml
+│       ├── stg_table1.sql
+│       ├── stg_table1.yml
+│       ├── ut_stg_table1.yml  # only with --unit-tests
+│       └── ...
+├── data-tests/
+│   └── unique_combination_stg_table1_col_a_col_b.sql  # only for composite pk/unique keys
 ├── macros/
 │   └── generate_schema_name.sql
 ├── dbt_project.yml
 ├── profiles.yml  # DuckDB or Postgres config, depending on --adapter
-└── {project_name}.duckdb  # DuckDB adapter only
+└── {project_name}_profile.duckdb  # DuckDB adapter only
 ```
 
 - **Seeds**: CSV files with generated synthetic data.
 - **Staging Models**: Basic dbt models that load from seeds.
 - **Sources & Tests**: YAML configs defining sources and column tests (`not_null`, `unique`,
   `relationships`, and `accepted_values` for DBML `Enum`-typed columns). Table and column
-  `Note` text from the DBML becomes `description:` fields. Composite primary/unique keys
-  declared in an `indexes { }` block get a singular SQL test under `tests/`.
+  `Note` text from the DBML becomes `description:` fields.
+- **Composite key tests**: Composite primary/unique keys declared in an `indexes { }` block get
+  a singular SQL test under `data-tests/`, dbt's configured `test-paths`.
 - **Profiles**: Pre-configured for DuckDB (file-based) or Postgres (via env vars), with schema handling.
-- **Unit tests** (opt-in via `--unit-tests`): `tests/unit/test_stg_<table>.yml` fixtures built
-  from real generated rows. Requires dbt-core >= 1.8.
+- **Unit tests** (opt-in via `--unit-tests`): `models/staging/ut_stg_<table>.yml` fixtures built
+  from real generated rows, co-located with each staging model so dbt (which only parses unit
+  tests from `model-paths`) picks them up. Requires dbt-core >= 1.8.
 
 ---
 

{model2data-0.4.1 → model2data-0.4.3}/model2data/cli.py

@@ -80,8 +80,8 @@ def main(
         False,
         "--unit-tests",
         help=(
-            "Also generate deterministic dbt unit test fixtures (tests/unit/) from the "
-            "generated seed rows. Requires dbt-core >= 1.8 to run."
+            "Also generate deterministic dbt unit test fixtures (models/staging/ut_stg_*.yml) "
+            "from the generated seed rows. Requires dbt-core >= 1.8 to run."
         ),
     ),
 ):

{model2data-0.4.1 → model2data-0.4.3}/model2data/dbt/project.py

@@ -13,7 +13,7 @@ def create_project_scaffold(dest: Path, project_name: str, profile_name: str) ->
     (dest / "seeds" / "raw").mkdir(parents=True, exist_ok=True)
     (dest / "analysis").mkdir(exist_ok=True)
     (dest / "macros").mkdir(exist_ok=True)
-    (dest / "tests").mkdir(exist_ok=True)
+    (dest / "data-tests").mkdir(exist_ok=True)
     (dest / "snapshots").mkdir(exist_ok=True)
 
     # dbt_project.yml

{model2data-0.4.1 → model2data-0.4.3}/model2data/dbt/tests.py

@@ -6,6 +6,9 @@ from typing import Any, Union
 import pandas as pd
 import yaml
 
+from model2data.generate.faker import is_free_text_type
+from model2data.generate.relationships import classify_refs
+
 
 def _yaml_field_lines(key: str, value: str, indent: str) -> list[str]:
     """Render `key: value` as safely-escaped YAML lines at the given indent."""
@@ -28,8 +31,23 @@ def generate_dbt_yml(dest: Path, tables: dict, refs: list[dict], source_name: st
     # -------------------------
     # Build foreign key map
     # -------------------------
+    # Only emit a `relationships` test for refs the generator actually makes
+    # FK-aware: direct FK refs (target column is a pk/"id"), plus attribute
+    # refs that ride along an existing FK between the same two tables (see
+    # generate.core's attribute-mirroring pass). An attribute ref with no
+    # accompanying FK is left as unrelated random data by the generator, so
+    # testing it against the parent table would be a guaranteed false
+    # failure.
+    fk_refs_classified, attribute_refs_classified = classify_refs(tables, refs)
+    fk_table_pairs = {(fk["source_table"], fk["target_table"]) for fk in fk_refs_classified}
+    eligible_refs = list(fk_refs_classified) + [
+        ref
+        for ref in attribute_refs_classified
+        if (ref["source_table"], ref["target_table"]) in fk_table_pairs
+    ]
+
     fk_map = defaultdict(list)
-    for ref in refs:
+    for ref in eligible_refs:
         fk_map[(ref["source_table"], ref["source_column"])].append(ref)
 
     # -------------------------
@@ -102,9 +120,10 @@ def generate_dbt_yml(dest: Path, tables: dict, refs: list[dict], source_name: st
                         lines.append(f"          - {test}")
                     elif "accepted_values" in test:
                         lines.append("          - accepted_values:")
-                        lines.append("              values:")
+                        lines.append("              arguments:")
+                        lines.append("                values:")
                         for value in test["accepted_values"]["values"]:
-                            lines.append(f"                - {value!r}")
+                            lines.append(f"                  - {value!r}")
                     else:
                         # relationships test with arguments
                         for k, v in test.items():
@@ -122,9 +141,47 @@ def generate_dbt_yml(dest: Path, tables: dict, refs: list[dict], source_name: st
     # -------------------------
     _generate_composite_key_tests(dest, tables)
 
+    # -------------------------
+    # Seed column-type overrides
+    # -------------------------
+    _generate_seed_config(dest, tables)
+
+
+def _generate_seed_config(dest: Path, tables: dict) -> None:
+    """
+    Force every free-text column (see `is_free_text_type`) to VARCHAR in
+    the seed loader config, instead of letting dbt/duckdb sniff the type
+    from CSV content. Some generated text is all-digit (EAN13 barcodes,
+    zero-padded postcodes, ...) and would otherwise be silently loaded as
+    an integer, overflowing or dropping leading zeros.
+    """
+    lines = ["version: 2", "", "seeds:"]
+    any_column_types = False
+
+    for table in tables.values():
+        column_types = {
+            col.name: "varchar" for col in table.columns if is_free_text_type(col.data_type)
+        }
+        if not column_types:
+            continue
+
+        any_column_types = True
+        lines.append(f"  - name: {table.name}")
+        lines.append("    config:")
+        lines.append("      column_types:")
+        for col_name, col_type in column_types.items():
+            lines.append(f"        {col_name}: {col_type}")
+
+    if not any_column_types:
+        return
+
+    seed_raw_path = dest / "seeds" / "raw"
+    seed_raw_path.mkdir(parents=True, exist_ok=True)
+    (seed_raw_path / "__seed_config.yml").write_text("\n".join(lines))
+
 
 def _generate_composite_key_tests(dest: Path, tables: dict) -> None:
-    tests_path = dest / "tests"
+    tests_path = dest / "data-tests"
     tests_path.mkdir(parents=True, exist_ok=True)
 
     for table in tables.values():
@@ -158,8 +215,12 @@ def generate_unit_tests(
 
     Since staging models are pure `select * from {{ source(...) }}` passthroughs,
     a handful of already-generated rows can serve as both `given` and `expect`.
+
+    Written alongside each staging model (under `model-paths`, which is where
+    dbt actually parses unit tests from) as `ut_stg_<table>.yml`, parallel to
+    the `stg_<table>.yml` schema file generated by `generate_dbt_yml`.
     """
-    unit_tests_path = dest / "tests" / "unit"
+    unit_tests_path = dest / "models" / "staging"
     unit_tests_path.mkdir(parents=True, exist_ok=True)
 
     for table in tables.values():
@@ -188,7 +249,7 @@ def generate_unit_tests(
             ]
         }
 
-        yml_file = unit_tests_path / f"test_{stg_name}.yml"
+        yml_file = unit_tests_path / f"ut_{stg_name}.yml"
         yml_file.write_text(yaml.safe_dump(unit_test, sort_keys=False, default_flow_style=False))
 
 

{model2data-0.4.1 → model2data-0.4.3}/model2data/generate/core.py

@@ -76,6 +76,7 @@ def generate_data_from_dbml(
             )
 
         df = pd.DataFrame(data)
+        df = _resolve_self_referencing_fks(df, table_def, table_name, fk_lookup, row_count)
         df = _deduplicate_composite_keys(df, table_def)
 
         # -----------------------------------------------------
@@ -110,6 +111,7 @@ def generate_data_from_dbml(
 
             df[child_column] = df[fk_column].map(lookup)
 
+        df = _coerce_integer_dtypes(df, table_def)
         generated[table_name] = df
 
     return generated
@@ -118,6 +120,25 @@ def generate_data_from_dbml(
 # ---------------------------------------------------------
 # Internal helpers
 # ---------------------------------------------------------
+def _coerce_integer_dtypes(df: pd.DataFrame, table_def: TableDef) -> pd.DataFrame:
+    """
+    Cast int/bigint/smallint-typed columns to pandas' nullable "Int64" dtype.
+
+    `generate_column_values` fills "empty" nullable columns with `None`
+    (absent an explicit default). Building a plain `pd.DataFrame` from a
+    Python list mixing ints and `None` silently upcasts that column to
+    float64, so whole numbers round-trip through the CSV seed as "70.0"
+    instead of "70" and blanks. Int64 keeps them as integers and renders
+    nulls as empty cells, matching the DBML-declared type.
+    """
+    for column in table_def.columns:
+        base_type = column.data_type.lower().split("(")[0].strip()
+        if any(key in base_type for key in ["int", "integer", "bigint", "smallint"]):
+            df[column.name] = df[column.name].astype("Int64")
+
+    return df
+
+
 def _deduplicate_composite_keys(
     df: pd.DataFrame,
     table_def: TableDef,
@@ -158,6 +179,45 @@ def _deduplicate_composite_keys(
     return df
 
 
+def _resolve_self_referencing_fks(
+    df: pd.DataFrame,
+    table_def: TableDef,
+    table_name: str,
+    fk_lookup: dict[tuple[str, str], tuple[str, str]],
+    row_count: int,
+) -> pd.DataFrame:
+    """
+    Re-generate any FK column that references its own table (e.g. a
+    `manager_id` on `employees` pointing back at `employees.id`) using the
+    table's own just-built parent column as the value pool.
+
+    These columns can't be resolved during the main per-column generation
+    pass above because the table isn't done building itself yet (its own
+    df isn't added to `generated` until the whole loop iteration finishes),
+    so `fk_series` falls through to None there and the column gets
+    unrelated random values instead. Once `df` exists we know the real
+    parent-column values and can fix it up here.
+    """
+    for column in table_def.columns:
+        fk_target = fk_lookup.get((table_name, column.name))
+        if not fk_target:
+            continue
+
+        parent_table, parent_column = fk_target
+        if parent_table != table_name or parent_column not in df.columns:
+            continue
+
+        ensure_unique = "pk" in column.settings
+        df[column.name] = generate_column_values(
+            column=column,
+            row_count=row_count,
+            fk_series=df[parent_column],
+            ensure_unique=ensure_unique,
+        )
+
+    return df
+
+
 def _determine_row_count(table_name: str, base_rows: int) -> int:
     """
     Return the base number of rows for all tables.

{model2data-0.4.1 → model2data-0.4.3}/model2data/generate/faker.py

@@ -62,6 +62,46 @@ _NAME_PATTERNS: list[tuple[str, Callable[[], object]]] = [
     ("summary", lambda: fake.text(max_nb_chars=160)),
 ]
 
+# DBML type substrings generate_column_values renders as a database-native
+# numeric/boolean/date/uuid value rather than arbitrary text. Shared with
+# `is_free_text_type` below so seed column-type config stays in sync with
+# actual generation.
+_STRUCTURED_TYPE_KEYS = (
+    "uuid",
+    "hash",
+    "int",
+    "integer",
+    "bigint",
+    "smallint",
+    "decimal",
+    "numeric",
+    "float",
+    "double",
+    "boolean",
+    "bool",
+    "date",
+    "time",
+    "timestamp",
+    "datetime",
+)
+
+
+def is_free_text_type(data_type: str) -> bool:
+    """
+    True for DBML types generate_column_values fills with arbitrary text
+    (name-pattern lookups, a literal Faker provider, or the generic
+    fallback) rather than a numeric/boolean/date/uuid value.
+
+    Used to force such seed columns to VARCHAR in the generated dbt
+    project: some Faker-produced text (EAN13 barcodes, postcodes with a
+    leading zero, ...) is entirely digits, which is enough for dbt's CSV
+    seed loader to mis-infer an integer column and either overflow or
+    silently strip meaningful leading zeros.
+    """
+    base_type = data_type.lower().split("(")[0].strip()
+    return not any(key in base_type for key in _STRUCTURED_TYPE_KEYS)
+
+
 # Column/table introspection helpers used by both generation and the
 # CLI's post-run summary, so the two stay in sync.
 _stats_state: dict[str, list[tuple[str, str]]] = {"unmapped": []}

{model2data-0.4.1 → model2data-0.4.3}/model2data/parse/dbml.py

@@ -68,17 +68,38 @@ def _parse_default_value(raw: str) -> Optional[object]:
     return None
 
 
+# Matches the "> table.column" / "< table.column" / "<> table.column" part of
+# an inline `ref: > table.column` column setting. Table/column names may be
+# bare, double-quoted, or backtick-quoted, mirroring the standalone `Ref {}`
+# block parser's identifier handling.
+_INLINE_REF_RE = re.compile(r"^(<>|[<>])\s*(\".*?\"|`.*?`|[\w]+)\.(\".*?\"|`.*?`|[\w]+)$")
+
+
+def _parse_inline_ref(value: str) -> Optional[dict]:
+    """Parse the value of a `ref:` column setting into operator + target table/column."""
+    match = _INLINE_REF_RE.match(value.strip())
+    if not match:
+        return None
+    operator, target_table, target_column = match.groups()
+    return {
+        "operator": operator,
+        "target_table": _strip_quotes(target_table),
+        "target_column": _strip_quotes(target_column),
+    }
+
+
 def _parse_column_settings(
     raw: Optional[str],
-) -> tuple[set[str], Optional[dict], Optional[str], Optional[object]]:
-    """Parse column settings, extracting note/description and default if present."""
+) -> tuple[set[str], Optional[dict], Optional[str], Optional[object], Optional[dict]]:
+    """Parse column settings, extracting note/description/default/inline ref if present."""
     if not raw:
-        return set(), None, None, None
+        return set(), None, None, None, None
 
     settings = set()
     note_dict = None
     description = None
     default_value = None
+    inline_ref = None
 
     # Split by comma, but be careful with nested structures
     parts = []
@@ -119,11 +140,13 @@ def _parse_column_settings(
         elif part.lower().startswith("default:"):
             default_str = part[len("default:") :].strip()
             default_value = _parse_default_value(default_str)
+        elif part.lower().startswith("ref:"):
+            inline_ref = _parse_inline_ref(part[len("ref:") :])
         else:
             # Regular setting (pk, not null, unique, etc.)
             settings.add(part.strip("'").strip('"').lower())
 
-    return settings, note_dict, description, default_value
+    return settings, note_dict, description, default_value, inline_ref
 
 
 # Many-to-many (`<>`) refs are captured but not fed into FK-based generation.
@@ -310,7 +333,7 @@ def parse_dbml(dbml_path: Path) -> tuple[dict[str, TableDef], list[dict]]:
             if len(col_type.split()) > 3:
                 continue
 
-            settings, note_dict, description, default_value = _parse_column_settings(
+            settings, note_dict, description, default_value, inline_ref = _parse_column_settings(
                 col_match.group(3)
             )
 
@@ -325,6 +348,42 @@ def parse_dbml(dbml_path: Path) -> tuple[dict[str, TableDef], list[dict]]:
                 )
             )
 
+            if inline_ref is not None:
+                target_table = inline_ref["target_table"]
+                target_column = inline_ref["target_column"]
+
+                if inline_ref["operator"] == "<>":
+                    many_to_many_refs.append(
+                        {
+                            "source_table": current_table.name,
+                            "source_column": col_name,
+                            "target_table": target_table,
+                            "target_column": target_column,
+                        }
+                    )
+                elif inline_ref["operator"] == "<":
+                    # "this column is referenced by target.column": the
+                    # target is the actual FK-holding (child) side, so it
+                    # becomes source; this column becomes target, mirroring
+                    # the standalone `Ref { a < b }` swap below.
+                    refs.append(
+                        {
+                            "source_table": target_table,
+                            "source_column": target_column,
+                            "target_table": current_table.name,
+                            "target_column": col_name,
+                        }
+                    )
+                else:
+                    refs.append(
+                        {
+                            "source_table": current_table.name,
+                            "source_column": col_name,
+                            "target_table": target_table,
+                            "target_column": target_column,
+                        }
+                    )
+
             continue
 
         # ----------------------

{model2data-0.4.1 → model2data-0.4.3}/model2data.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model2data
-Version: 0.4.1
+Version: 0.4.3
 Summary: Generate analytics-ready datasets from DBML models
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -122,7 +122,9 @@ flowchart LR
    (int, date, timestamp, ...), name-aware inference for everything else (`email`, `phone`,
    `city`, ...), foreign keys resolved against already-generated parent rows.
 3. **Scaffold.** Writes a complete dbt project around that data: CSV seeds, staging models with
-   `source`/`not_null`/`unique`/`relationships` tests, and a profile for DuckDB (zero-config,
+   `source`/`not_null`/`unique`/`relationships` tests, `accepted_values` tests for DBML
+   `Enum`-typed columns, singular SQL tests for composite primary/unique keys, table and column
+   `description:` fields pulled from DBML notes, and a profile for DuckDB (zero-config,
    file-based) or Postgres.
 
 ---
@@ -169,7 +171,7 @@ Connection details are read from environment variables (`MODEL2DATA_PG_HOST`, `M
 
 After generation, the CLI prints a short summary — tables and rows generated, relationships found in the DBML, and any columns that fell back to generic placeholder text because neither their type nor name could be matched.
 
-Pass `--unit-tests` to also generate deterministic dbt unit test fixtures (`tests/unit/test_stg_<table>.yml`) from the actually-generated seed rows:
+Pass `--unit-tests` to also generate deterministic dbt unit test fixtures (`models/staging/ut_stg_<table>.yml`) from the actually-generated seed rows:
 
 ```bash
 model2data --file examples/hackernews.dbml --rows 200 --seed 42 --unit-tests
@@ -186,32 +188,36 @@ The generated dbt project includes:
 ```
 dbt_{project_name}/
 ├── seeds/
-│   └── {project_name}/
+│   └── raw/
 │       ├── table1.csv
 │       └── table2.csv
 ├── models/
-│   └── {project_name}/
-│       └── staging/
-│           ├── __sources.yml
-│           ├── stg_table1.sql
-│           ├── stg_table1.yml
-│           └── ...
+│   └── staging/
+│       ├── __sources.yml
+│       ├── stg_table1.sql
+│       ├── stg_table1.yml
+│       ├── ut_stg_table1.yml  # only with --unit-tests
+│       └── ...
+├── data-tests/
+│   └── unique_combination_stg_table1_col_a_col_b.sql  # only for composite pk/unique keys
 ├── macros/
 │   └── generate_schema_name.sql
 ├── dbt_project.yml
 ├── profiles.yml  # DuckDB or Postgres config, depending on --adapter
-└── {project_name}.duckdb  # DuckDB adapter only
+└── {project_name}_profile.duckdb  # DuckDB adapter only
 ```
 
 - **Seeds**: CSV files with generated synthetic data.
 - **Staging Models**: Basic dbt models that load from seeds.
 - **Sources & Tests**: YAML configs defining sources and column tests (`not_null`, `unique`,
   `relationships`, and `accepted_values` for DBML `Enum`-typed columns). Table and column
-  `Note` text from the DBML becomes `description:` fields. Composite primary/unique keys
-  declared in an `indexes { }` block get a singular SQL test under `tests/`.
+  `Note` text from the DBML becomes `description:` fields.
+- **Composite key tests**: Composite primary/unique keys declared in an `indexes { }` block get
+  a singular SQL test under `data-tests/`, dbt's configured `test-paths`.
 - **Profiles**: Pre-configured for DuckDB (file-based) or Postgres (via env vars), with schema handling.
-- **Unit tests** (opt-in via `--unit-tests`): `tests/unit/test_stg_<table>.yml` fixtures built
-  from real generated rows. Requires dbt-core >= 1.8.
+- **Unit tests** (opt-in via `--unit-tests`): `models/staging/ut_stg_<table>.yml` fixtures built
+  from real generated rows, co-located with each staging model so dbt (which only parses unit
+  tests from `model-paths`) picks them up. Requires dbt-core >= 1.8.
 
 ---
 

{model2data-0.4.1 → model2data-0.4.3}/model2data.egg-info/SOURCES.txt

@@ -25,6 +25,7 @@ model2data/parse/dbml.py
 tests/test_cli.py
 tests/test_coverage_gaps.py
 tests/test_dbml_parser.py
+tests/test_dbt_integration.py
 tests/test_dbt_naming.py
 tests/test_dbt_project.py
 tests/test_dbt_tests.py

{model2data-0.4.1 → model2data-0.4.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "model2data"
-version = "0.4.1"
+version = "0.4.3"
 description = "Generate analytics-ready datasets from DBML models"
 readme = "README.md"
 requires-python = ">=3.10"

{model2data-0.4.1 → model2data-0.4.3}/tests/test_cli.py

@@ -577,7 +577,7 @@ def test_cli_all_output_messages_present(tmp_path):
 
 
 def test_cli_without_unit_tests_flag_creates_no_unit_test_dir(tmp_path):
-    """--unit-tests defaults to off: no tests/unit/ directory should appear."""
+    """--unit-tests defaults to off: no unit test YAML should appear."""
     dbml_file = tmp_path / "test.dbml"
     dbml_file.write_text(
         """
@@ -596,11 +596,11 @@ def test_cli_without_unit_tests_flag_creates_no_unit_test_dir(tmp_path):
         os.chdir(original_cwd)
 
     assert result.exit_code == 0
-    assert not (tmp_path / "dbt_test" / "tests" / "unit").exists()
+    assert not list((tmp_path / "dbt_test" / "models" / "staging").glob("ut_*.yml"))
 
 
 def test_cli_with_unit_tests_flag_generates_unit_test_yaml(tmp_path):
-    """--unit-tests writes tests/unit/test_stg_<table>.yml and prints the dbt-core note."""
+    """--unit-tests writes models/staging/ut_stg_<table>.yml and prints the dbt-core note."""
     dbml_file = tmp_path / "test.dbml"
     dbml_file.write_text(
         """
@@ -632,7 +632,7 @@ def test_cli_with_unit_tests_flag_generates_unit_test_yaml(tmp_path):
     assert result.exit_code == 0
     assert "dbt-core >= 1.8" in result.stdout
 
-    unit_yml = tmp_path / "dbt_test" / "tests" / "unit" / "test_stg_users.yml"
+    unit_yml = tmp_path / "dbt_test" / "models" / "staging" / "ut_stg_users.yml"
     assert unit_yml.exists()
 
     import yaml