model2data 1.1.0__tar.gz → 1.2.0__tar.gz

{model2data-1.1.0/model2data.egg-info → model2data-1.2.0}/PKG-INFO

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

{model2data-1.1.0 → model2data-1.2.0}/README.md

@@ -39,7 +39,8 @@ access required.
 - **Privacy-safe.** Nothing but a schema definition goes in; nothing but synthetic data comes out.
 - **Realistic, not random.** Column names are matched against ~35 common patterns — `email`,
   `first_name`, `city`, `phone`, `company`, ... — so a column called `email` gets real-looking
-  emails, not `Lorem ipsum` text.
+  emails, not `Lorem ipsum` text. Type a column with any Faker provider (`billing_country state`,
+  `sku ean13`) to pick its generator outright when the name is wrong for the data.
 - **Relationship-preserving.** Foreign keys resolve to real parent rows; tables are generated in
   dependency order.
 - **Deterministic.** Pass `--seed` and the same schema always produces the same data — safe to
@@ -97,8 +98,9 @@ flowchart LR
 
 1. **Parse.** Reads tables, columns, types, and `Ref` relationships from a DBML file.
 2. **Generate.** Produces synthetic values per column — typed generation for known SQL types
-   (int, date, timestamp, ...), name-aware inference for everything else (`email`, `phone`,
-   `city`, ...), foreign keys resolved against already-generated parent rows.
+   (int, date, timestamp, ...), then a Faker provider named as the type (`sku ean13`), then
+   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 that
    `ref()` those seeds, `not_null`/`unique`/`relationships` tests, `accepted_values` tests for
    DBML `Enum`-typed columns, singular SQL tests for composite primary/unique keys, table and

{model2data-1.1.0 → model2data-1.2.0}/model2data/generate/faker.py

@@ -150,6 +150,33 @@ def _infer_by_name(column_name: str) -> Optional[Callable[[], object]]:
     return None
 
 
+# Type names that are ordinary SQL types first and Faker providers only by
+# coincidence. Someone typing `email text` means the SQL type, so these must
+# not count as a deliberate choice of provider -- otherwise the commonest
+# declaration in any schema would stop generating emails.
+_SQL_TYPES_SHADOWING_A_PROVIDER = frozenset({"text", "json", "jsonb", "xml", "binary", "year"})
+
+
+def _infer_by_type(base_type: str) -> Optional[Callable[[], object]]:
+    """The provider a column's declared type names, if it names one deliberately.
+
+    `sku ean13` and `home_state state` are the user saying which generator they
+    want, in the only place DBML gives them to say it. That has to outrank the
+    guess made from the column's name: a name pattern is inferred, a type is
+    declared, and `first_name email` silently generating first names -- the
+    type having no effect whatsoever -- is the single most confusing thing this
+    module did.
+    """
+    if base_type in _SQL_TYPES_SHADOWING_A_PROVIDER:
+        return None
+    try:
+        fake.format(base_type)
+    except (AttributeError, TypeError):
+        # Not a provider, or one that needs arguments: nothing was declared.
+        return None
+    return lambda: fake.format(base_type)
+
+
 # ---------------------------------------------------------
 # Public API
 # ---------------------------------------------------------
@@ -278,16 +305,16 @@ def generate_column_values(
         values = [_random_datetime().isoformat(sep=" ") for _ in range(row_count)]
 
     # -----------------------------------------------------
-    # Untyped / generic string columns: infer intent from the
-    # column name first (email, city, phone...), then fall back
-    # to a literal Faker provider name, then to a generic value.
+    # Untyped / generic string columns: honour a type that names
+    # a Faker provider (`sku ean13`), then infer intent from the
+    # column name (email, city, phone...), then a generic value.
     # -----------------------------------------------------
     else:
-        name_generator = _infer_by_name(column.name)
-        if name_generator is not None:
-            values = [name_generator() for _ in range(row_count)]
+        generator = _infer_by_type(base_type) or _infer_by_name(column.name)
+        if generator is not None:
+            values = [generator() for _ in range(row_count)]
             values = (
-                _deduplicate(values, name_generator, column_name=unique_label)
+                _deduplicate(values, generator, column_name=unique_label)
                 if ensure_unique
                 else values
             )

{model2data-1.1.0 → model2data-1.2.0/model2data.egg-info}/PKG-INFO

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

{model2data-1.1.0 → model2data-1.2.0}/pyproject.toml

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

{model2data-1.1.0 → model2data-1.2.0}/tests/test_faker_name_inference.py

@@ -82,6 +82,73 @@ class TestNameInference:
         assert result == ["x", "x", "x"]
 
 
+class TestTypeBeatsName:
+    """A declared Faker provider type outranks the guess made from the name.
+
+    DBML has one place to say which generator a column should use -- its type --
+    and until this held, a recognised column name silently overruled it:
+    `home_state state` generated countries and `first_name email` generated
+    first names, with the declared type having no effect at all.
+    """
+
+    def test_a_declared_provider_overrules_the_name_pattern(self):
+        values = generate_column_values(
+            ColumnDef(name="first_name", data_type="email", settings={"not null"}),
+            row_count=20,
+        )
+        assert all(EMAIL_RE.match(v) for v in values)
+
+    def test_a_column_can_be_typed_against_its_own_name(self):
+        # The case the feature exists for: a state column that isn't called one.
+        # Without this the `country` in its name won and it generated countries.
+        from faker.providers.address.en_US import Provider as UsAddress
+
+        values = generate_column_values(
+            ColumnDef(name="billing_country", data_type="state", settings={"not null"}),
+            row_count=40,
+        )
+        assert set(values) <= set(UsAddress.states)
+
+    def test_a_plain_sql_type_does_not_count_as_a_declaration(self):
+        # `text` and `json` are Faker providers by coincidence; a column typed
+        # that way means the SQL type, and its name must still be inferred.
+        for sql_type in ("text", "json", "varchar", "char(64)"):
+            values = generate_column_values(
+                ColumnDef(name="email", data_type=sql_type, settings={"not null"}),
+                row_count=10,
+            )
+            assert all(EMAIL_RE.match(v) for v in values), sql_type
+
+    def test_an_unknown_type_still_falls_back_to_the_name(self):
+        reset_stats()
+        values = generate_column_values(
+            ColumnDef(name="city", data_type="weird_custom_type", settings={"not null"}),
+            row_count=10,
+        )
+        assert all(isinstance(value, str) and value for value in values)
+        assert get_unmapped_columns() == []
+
+    def test_a_declared_provider_is_still_deduplicated_when_unique(self):
+        values = generate_column_values(
+            ColumnDef(name="first_name", data_type="email", settings={"not null", "unique"}),
+            row_count=50,
+            ensure_unique=True,
+        )
+        assert len(values) == len(set(values)) == 50
+
+    def test_structured_types_are_untouched_by_this(self):
+        # `date` and `boolean` are providers too, but they are decided long
+        # before either inference runs, and must keep their real Python types.
+        dates = generate_column_values(
+            ColumnDef(name="signup_date", data_type="date", settings={"not null"}), row_count=5
+        )
+        assert all(hasattr(value, "year") for value in dates)
+        flags = generate_column_values(
+            ColumnDef(name="is_active", data_type="boolean", settings={"not null"}), row_count=5
+        )
+        assert set(flags) <= {True, False}
+
+
 class TestEnumGeneration:
     def test_enum_values_only_ever_come_from_the_enum_set(self):
         allowed = {"active", "inactive", "pending"}