model2data 1.10.3__tar.gz → 1.10.4__tar.gz

{model2data-1.10.3/model2data.egg-info → model2data-1.10.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model2data
-Version: 1.10.3
+Version: 1.10.4
 Summary: Generate analytics-ready datasets from DBML models
 Author: JB Analytica
 License-Expression: MIT

{model2data-1.10.3 → model2data-1.10.4}/README.md

@@ -222,14 +222,14 @@ jobs:
 ```
 
 Inputs: `files` (glob, default `**/*.model2data.yml`), `version` (default: the release the tag
-points at, e.g. `1.10.3`; a specifier such as `>=1.10,<2` also works), `python-version` (3.12).
+points at, e.g. `1.10.4`; a specifier such as `>=1.10,<2` also works), `python-version` (3.12).
 
 **pre-commit**
 
 ```yaml
 repos:
   - repo: https://github.com/JB-Analytica/model2data
-    rev: v1.10.3
+    rev: v1.10.4
     hooks:
       - id: model2data-validate
 ```
@@ -243,7 +243,7 @@ model2data:
     - if: $CI_PIPELINE_SOURCE == "merge_request_event"
       changes: ["**/*.model2data.yml"]
   script:
-    - pip install model2data==1.10.3
+    - pip install model2data==1.10.4
     - model2data validate --glob "**/*.model2data.yml"
 ```
 

{model2data-1.10.3 → model2data-1.10.4}/model2data/generate/days.py

@@ -598,17 +598,26 @@ class _Engine:
             lone_country=lone,
         )
         if unique and pool is None and len(state):
-            values = self._avoid(values, set(state[column.name].dropna().tolist()), column)
+            values = self._avoid(values, set(state[column.name].dropna().tolist()), column, key)
         return values
 
-    def _avoid(self, values: list, taken: set, column: ColumnDef) -> list:
+    def _avoid(self, values: list, taken: set, column: ColumnDef, key: str) -> list:
         """Replace values that repeat one the table already holds."""
         taken = set(taken)
         out = []
+        repeats = 0
         for value in values:
             candidate = value
             if candidate is not None and candidate in taken:
-                if isinstance(value, str):
+                if column.enum_values:
+                    # A suffix would make it a value the enum does not have:
+                    # take a member no row holds yet, or keep the repeat.
+                    free = [m for m in column.enum_values if m not in taken]
+                    if free:
+                        candidate = random.choice(free)
+                    else:
+                        repeats += 1
+                elif isinstance(value, str):
                     counter = 1
                     while candidate in taken:
                         counter += 1
@@ -623,6 +632,10 @@ class _Engine:
             if candidate is not None:
                 taken.add(candidate)
             out.append(candidate)
+        if repeats:
+            self.warnings.append(
+                f"{key}.{column.name}: {repeats} duplicate value(s) on day {self.day}"
+            )
         return out
 
     # -- time ---------------------------------------------------------------

{model2data-1.10.3 → model2data-1.10.4}/model2data/generate/faker.py

@@ -796,6 +796,8 @@ def generate_column_values(
         # when it carried an explicit `null_rate`.
         if not force_not_null and "not null" not in column.settings and "pk" not in column.settings:
             _null_out(values, _null_fraction_for(column, row_count), column.default, row_count)
+        if ensure_unique:
+            values = _distinct_members(values, column.enum_values, unique_label)
         return values
 
     dtype = column.data_type.lower()
@@ -1150,6 +1152,33 @@ def _distinct_parent_values(fk_values: list, row_count: int, unique_label: str)
     return values
 
 
+def _distinct_members(values: list, members: list, unique_label: str) -> list:
+    """A unique enum column's values, each repeated member swapped for a free one.
+
+    Only a repeat is drawn again, after the ordinary draw and the null pass, so
+    a draw that already came out distinct keeps every byte (the determinism
+    promise); one with repeats used to fail its generated dbt `unique` test.
+    With fewer members than rows the rest stay repeated and are reported the
+    way `_deduplicate` reports a unique column it could not keep unique.
+    """
+    held = set(values)
+    free = [member for member in members if member not in held]
+    seen: set = set()
+    result = []
+    unresolved = 0
+    for value in values:
+        if value is not None and value in seen:
+            if free:
+                value = free.pop(random.randrange(len(free)))
+            else:
+                unresolved += 1
+        seen.add(value)
+        result.append(value)
+    if unresolved:
+        _duplicate_unique_columns.append(f"{unique_label}: {unresolved} duplicate value(s)")
+    return result
+
+
 # Faker's `text` reaches each word through five layers of provider methods,
 # copying the locale's word list twice per sentence on the way; a text column
 # spends most of a run's generation time there. `_text` and `_sentence` make

{model2data-1.10.3 → model2data-1.10.4/model2data.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model2data
-Version: 1.10.3
+Version: 1.10.4
 Summary: Generate analytics-ready datasets from DBML models
 Author: JB Analytica
 License-Expression: MIT

{model2data-1.10.3 → model2data-1.10.4}/pyproject.toml

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

{model2data-1.10.3 → model2data-1.10.4}/tests/test_cli_model.py

@@ -371,6 +371,37 @@ def test_validate_summary_agrees_with_its_count(tmp_path):
     assert "❌ 2 of 2 model files do not conform." in both.output
 
 
+UNIQUE_ENUM = """\
+model2data: 0.3.0
+name: u
+enums:
+  plan: [free, starter, pro, enterprise]
+tables:
+  plans:
+    columns:
+      id: {type: bigint, pk: true}
+      plan_name: {type: plan, unique: true, not_null: true}
+run: {rows: 10, rows_per_table: {plans: ROWS}, seed: 42, as_of: 2026-01-01}
+"""
+
+
+def test_a_unique_enum_with_a_member_per_row_writes_each_member_once(in_tmp):
+    model = _write(in_tmp, "u.model2data.yml", UNIQUE_ENUM.replace("ROWS", "4"))
+    result = runner.invoke(app, ["--file", str(model)])
+    assert result.exit_code == 0, result.output
+    plans = pd.read_csv(in_tmp / "dbt_u" / "seeds" / "raw" / "plans.csv")
+    assert sorted(plans["plan_name"]) == ["enterprise", "free", "pro", "starter"]
+    assert "Unique columns left with duplicate values" not in result.output
+
+
+def test_a_unique_enum_with_too_few_members_warns_in_the_summary(in_tmp):
+    model = _write(in_tmp, "u.model2data.yml", UNIQUE_ENUM.replace("ROWS", "6"))
+    result = runner.invoke(app, ["--file", str(model)])
+    assert result.exit_code == 0, result.output
+    assert "Unique columns left with duplicate values" in result.output
+    assert "plans.plan_name: 2 duplicate value(s)" in result.output
+
+
 def test_action_uses_setup_python_v6():
     import yaml
 

{model2data-1.10.3 → model2data-1.10.4}/tests/test_days.py

@@ -429,6 +429,32 @@ def test_a_unique_foreign_key_runs_out_of_parents_and_says_so():
     assert days[1].tables["passports"].state["person_id"].dropna().is_unique
 
 
+def test_a_unique_enum_takes_free_members_across_days_and_says_when_none_are_left():
+    members = ["a", "b", "c", "d", "e", "f"]
+    data = {
+        "model2data": "0.2.0",
+        "enums": {"slot": members},
+        "tables": {
+            "slots": {
+                "incremental": {"new_per_day": 2},
+                "columns": {
+                    "id": {"type": "bigint", "pk": True},
+                    "name": {"type": "slot", "unique": True, "not_null": True},
+                },
+            },
+        },
+    }
+    days = generate_days(from_dict(data), 2, base_rows=3, seed=4, as_of=AS_OF)
+    # Never a suffixed value the enum does not have.
+    for day in days:
+        assert set(day.tables["slots"].state["name"]) <= set(members)
+    # Day 1 still has three free members for its two rows.
+    assert days[1].tables["slots"].state["name"].is_unique
+    assert not days[1].warnings
+    # Day 2 has one free member for two rows: one repeat, said.
+    assert days[2].warnings == ["slots.name: 1 duplicate value(s) on day 2"]
+
+
 def test_the_model_roundtrips_with_incremental():
     model = load(DAILY)
     assert model.tables["orders"].incremental == Incremental(

{model2data-1.10.3 → model2data-1.10.4}/tests/test_generation.py

@@ -519,6 +519,70 @@ def test_unique_column_with_room_reports_nothing():
     assert get_duplicate_unique_columns() == []
 
 
+PLANS = ["free", "starter", "pro", "enterprise"]
+
+
+def _plans_table(settings: set[str]) -> dict[str, TableDef]:
+    return {
+        "plans": TableDef(
+            name="plans",
+            columns=[
+                ColumnDef("id", "bigint", {"pk"}),
+                ColumnDef("plan_name", "plan", settings, enum_values=PLANS),
+            ],
+        )
+    }
+
+
+def test_unique_enum_with_a_member_per_row_takes_each_member_once():
+    # The enum has exactly as many members as the table has rows: a draw
+    # without replacement, so every member appears once and none twice.
+    for seed in range(20):
+        df = generate_data_from_dbml(
+            _plans_table({"unique", "not null"}), [], base_rows=4, seed=seed
+        )["plans"]
+        assert sorted(df["plan_name"]) == sorted(PLANS), seed
+        assert get_duplicate_unique_columns() == []
+
+
+def test_unique_enum_with_more_members_than_rows_stays_unique():
+    df = generate_data_from_dbml(_plans_table({"unique", "not null"}), [], base_rows=3, seed=1)[
+        "plans"
+    ]
+    assert df["plan_name"].is_unique
+    assert set(df["plan_name"]) <= set(PLANS)
+    assert get_duplicate_unique_columns() == []
+
+
+def test_unique_enum_with_fewer_members_than_rows_is_reported():
+    df = generate_data_from_dbml(_plans_table({"unique", "not null"}), [], base_rows=6, seed=1)[
+        "plans"
+    ]
+    # Every member is used before any repeats, and the two repeats are said.
+    assert set(df["plan_name"]) == set(PLANS)
+    assert get_duplicate_unique_columns() == ["plans.plan_name: 2 duplicate value(s)"]
+
+
+def test_unique_enum_that_draws_distinct_keeps_the_bytes_of_the_plain_draw():
+    # The determinism promise: only a repeat is drawn again, so a seed whose
+    # ordinary draw already came out distinct gives the same table as before.
+    kept = 0
+    for seed in range(40):
+        plain = generate_data_from_dbml(_plans_table({"not null"}), [], base_rows=3, seed=seed)
+        unique = generate_data_from_dbml(
+            _plans_table({"unique", "not null"}), [], base_rows=3, seed=seed
+        )
+        if plain["plans"]["plan_name"].is_unique:
+            kept += 1
+            assert plain["plans"].equals(unique["plans"]), seed
+    assert kept
+
+
+def test_nullable_unique_enum_keeps_its_non_null_values_distinct():
+    df = generate_data_from_dbml(_plans_table({"unique"}), [], base_rows=4, seed=2)["plans"]
+    assert df["plan_name"].dropna().is_unique
+
+
 def test_resolvable_composite_key_reports_nothing():
     # The mirror of the test above: when the dedup pass genuinely succeeds,
     # the warning must stay silent (no false positives).