datacontract-cli 1.0.12__tar.gz → 1.0.13__tar.gz

{datacontract_cli-1.0.12/datacontract_cli.egg-info → datacontract_cli-1.0.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datacontract-cli
-Version: 1.0.12
+Version: 1.0.13
 Summary: The datacontract CLI is an open source command-line tool for working with Data Contracts. It uses data contract YAML files to lint the data contract, connect to data sources and execute schema and quality tests, detect breaking changes, and export to different formats. The tool is written in Python. It can be used as a standalone CLI tool, in a CI/CD pipeline, or directly as a Python library.
 Author-email: Jochen Christ <jochen.christ@innoq.com>, Stefan Negele <stefan.negele@innoq.com>, Simon Harrer <simon.harrer@innoq.com>
 License-Expression: MIT
@@ -15,7 +15,7 @@ Requires-Dist: typer<0.27,>=0.18.0
 Requires-Dist: click<9.0.0,>=8.1.0
 Requires-Dist: pydantic<2.14.0,>=2.8.2
 Requires-Dist: pyyaml~=6.0.1
-Requires-Dist: ruamel.yaml<0.19,>=0.17
+Requires-Dist: ruamel.yaml<0.20,>=0.17
 Requires-Dist: requests<2.35,>=2.31
 Requires-Dist: truststore<1.0,>=0.10
 Requires-Dist: fastjsonschema<2.22.0,>=2.19.1
@@ -94,7 +94,7 @@ Provides-Extra: rdf
 Requires-Dist: rdflib==7.6.0; extra == "rdf"
 Provides-Extra: api
 Requires-Dist: fastapi<0.140.0,>=0.115.0; extra == "api"
-Requires-Dist: uvicorn<0.51.0,>=0.44.0; extra == "api"
+Requires-Dist: uvicorn<0.52.0,>=0.44.0; extra == "api"
 Provides-Extra: protobuf
 Requires-Dist: proto-schema-parser<3.0,>=1.0; extra == "protobuf"
 Provides-Extra: all
@@ -112,7 +112,7 @@ Requires-Dist: pytest-xdist; extra == "dev"
 Requires-Dist: pymssql==2.3.13; extra == "dev"
 Requires-Dist: psycopg2-binary<3.0,>=2.9; extra == "dev"
 Requires-Dist: mysql-connector-python<9.7.0,>=8.0.30; extra == "dev"
-Requires-Dist: ruff==0.15.20; extra == "dev"
+Requires-Dist: ruff==0.15.21; extra == "dev"
 Requires-Dist: testcontainers[kafka,minio,mssql,mysql,postgres]==4.14.2; extra == "dev"
 Requires-Dist: trino==0.338.0; extra == "dev"
 Dynamic: license-file

{datacontract_cli-1.0.12 → datacontract_cli-1.0.13}/datacontract/engines/checks/check_spec.py

@@ -30,6 +30,7 @@ class MetricType(str, Enum):
     FIELD_PRESENT = "field_present"
     FIELD_TYPE = "field_type"
     FIELD_PHYSICAL_TYPE = "field_physical_type"
+    FIELD_NESTED_TYPE = "field_nested_type"
     FRESHNESS = "freshness"
     RETENTION = "retention"
     CUSTOM_SQL = "custom_sql"

{datacontract_cli-1.0.12 → datacontract_cli-1.0.13}/datacontract/engines/checks/create_checks.py

@@ -22,6 +22,7 @@ from open_data_contract_standard.model import (
 )
 
 from datacontract.engines.checks.check_spec import CheckSpec, MetricType, Op, Threshold
+from datacontract.engines.checks.type_normalize import normalize_type_name
 from datacontract.engines.ibis.native_type import supports_native_type_introspection
 
 logger = logging.getLogger(__name__)
@@ -54,6 +55,51 @@ def to_schema_name(schema_object: SchemaObject, server_type: Optional[str]) -> s
     return schema_object.name
 
 
+def _scalar_element_type(prop: SchemaProperty, physical: bool) -> Optional[str]:
+    """The declared element type of an array of scalars, or None for anything else."""
+    if normalize_type_name(prop.logicalType or prop.physicalType) != "array" or prop.items is None:
+        return None
+    items = prop.items
+    if items.properties or items.items is not None:
+        return None
+    label = (items.physicalType or items.logicalType) if physical else (items.logicalType or items.physicalType)
+    if normalize_type_name(label) in ("object", "array"):
+        return None
+    return label
+
+
+def _declared_type_label(prop: SchemaProperty, physical: bool) -> Optional[str]:
+    """Render the declared type with its children, e.g. ``OBJECT(code VARCHAR(10), description VARCHAR)``."""
+    label = (prop.physicalType or prop.logicalType) if physical else (prop.logicalType or prop.physicalType)
+    base = normalize_type_name(label)
+    if base == "array" and prop.items is not None:
+        return f"{label}({_declared_type_label(prop.items, physical)})"
+    if base == "object" and prop.properties:
+        children = ", ".join(f"{child.name} {_declared_type_label(child, physical)}" for child in prop.properties)
+        return f"{label}({children})"
+    return label
+
+
+def _nested_type_check(model: str, field: str, prop: SchemaProperty, physical: bool) -> CheckSpec:
+    check_type = "field_nested_physical_type" if physical else "field_nested_type"
+    element = _scalar_element_type(prop, physical)
+    if element is not None:
+        name = f"Check that items of array {field} have {'physical type' if physical else 'type'} {element}"
+    else:
+        name = f"Check that nested {'physical types' if physical else 'types'} of {field} are correct"
+    return CheckSpec(
+        key=f"{model}__{field}__{check_type}",
+        category="schema",
+        type=check_type,
+        name=name,
+        model=model,
+        field=field,
+        metric=MetricType.FIELD_NESTED_TYPE,
+        expected_type_label=_declared_type_label(prop, physical),
+        expected_schema_property=prop,
+    )
+
+
 _PERCENT_UNITS = {"percent", "percentage", "%"}
 
 
@@ -172,6 +218,20 @@ def _to_schema_checks(schema_object: SchemaObject, server: Optional[Server]) ->
             )
         )
 
+        # The raw view cannot provide nested type checks
+        declared_base = normalize_type_name(prop.logicalType or prop.physicalType)
+        nested_checks_possible = (
+            check_types
+            and not uses_raw_view
+            and declared_base in ("object", "array")
+            and (bool(prop.properties) or prop.items is not None)
+        )
+        base_prop = (
+            SchemaProperty(name=prop.name, logicalType=prop.logicalType, physicalType=prop.physicalType)
+            if nested_checks_possible
+            else prop
+        )
+
         # A declared physicalType is checked against the column's real native
         # type in the platform catalog and takes precedence over logicalType,
         # but only on backends that expose a meaningful native type. Elsewhere
@@ -191,11 +251,13 @@ def _to_schema_checks(schema_object: SchemaObject, server: Optional[Server]) ->
                     expected_physical_type=prop.physicalType,
                     # Carried for the logicalType fallback when the native type
                     # cannot be read or the physicalType is cross-dialect.
-                    expected_schema_property=prop if prop.logicalType is not None else None,
+                    expected_schema_property=base_prop if prop.logicalType is not None else None,
                 )
             )
+            if nested_checks_possible:
+                checks.append(_nested_type_check(model, field, prop, physical=True))
         elif check_types and prop.logicalType is not None:
-            schema_prop, label = prop, prop.logicalType or ""
+            label = prop.logicalType or ""
             checks.append(
                 CheckSpec(
                     key=f"{model}__{field}__field_type",
@@ -207,9 +269,11 @@ def _to_schema_checks(schema_object: SchemaObject, server: Optional[Server]) ->
                     metric=MetricType.FIELD_TYPE,
                     expected_category=label,
                     expected_type_label=label,
-                    expected_schema_property=schema_prop,
+                    expected_schema_property=base_prop,
                 )
             )
+            if nested_checks_possible:
+                checks.append(_nested_type_check(model, field, prop, physical=False))
 
         if prop.required:
             checks.append(

{datacontract_cli-1.0.12 → datacontract_cli-1.0.13}/datacontract/engines/checks/physical_type_match.py

@@ -43,6 +43,31 @@ def _timestamp_family() -> set:
 
 _TIMESTAMP_FAMILY = _timestamp_family()
 
+# Each group is a single Snowflake type under different names, which its catalog
+# reports as the one canonical name (TEXT, NUMBER, FLOAT), so a contract declaring
+# any of the aliases must match its own column. Dialect-specific because elsewhere
+# (MySQL, SQL Server) TEXT and VARCHAR, or INT and DECIMAL, are distinct types.
+_SNOWFLAKE_FAMILIES = (
+    {exp.DataType.Type.VARCHAR, exp.DataType.Type.TEXT, exp.DataType.Type.NVARCHAR},
+    # exact numerics: INT/INTEGER/BIGINT/SMALLINT/TINYINT/BYTEINT/NUMERIC are NUMBER(38,0)
+    {
+        exp.DataType.Type.DECIMAL,
+        exp.DataType.Type.INT,
+        exp.DataType.Type.BIGINT,
+        exp.DataType.Type.SMALLINT,
+        exp.DataType.Type.TINYINT,
+    },
+    # approximate numerics: FLOAT/FLOAT4/FLOAT8/DOUBLE/REAL are all 64-bit FLOAT
+    {exp.DataType.Type.DOUBLE, exp.DataType.Type.FLOAT},
+)
+
+
+def _is_snowflake(dialect) -> bool:
+    if isinstance(dialect, str):
+        return dialect.lower() == "snowflake"
+    name = getattr(dialect, "__name__", None) or type(dialect).__name__
+    return name.lower() == "snowflake"
+
 
 def _parse(type_str: str, dialect) -> Optional[exp.DataType]:
     """Parse a type string into an ``exp.DataType`` for ``dialect``, or ``None``."""
@@ -132,12 +157,14 @@ def physical_type_matches(
         exp_dt.this == act_dt.this
         or {exp_dt.this, act_dt.this} <= _TIMESTAMP_FAMILY
         or (both_numeric and _base_sql(exp_dt, dialect) == _base_sql(act_dt, dialect))
+        or (_is_snowflake(dialect) and any({exp_dt.this, act_dt.this} <= family for family in _SNOWFLAKE_FAMILIES))
     )
     if not same_base:
         return False, f"expected physical type '{expected}' but the column is '{actual}'"
 
-    expected_params = _params(exp_dt)
-    if expected_params and expected_params != _params(act_dt):
+    # sqlglot fills in a dialect's default precision (a bare NUMBER parses as
+    # DECIMAL(38,0)), so what the contract declares is read off the raw string.
+    if _split_base(_normalize_raw(expected))[1] and _params(exp_dt) != _params(act_dt):
         return False, f"expected physical type '{expected}' but the column is '{actual}'"
 
     return True, ""

{datacontract_cli-1.0.12 → datacontract_cli-1.0.13}/datacontract/engines/checks/type_normalize.py

@@ -11,9 +11,12 @@ the actual type is structurally compatible with the expected one.
 from __future__ import annotations
 
 import re
+from typing import NamedTuple
 
 from open_data_contract_standard.model import SchemaProperty
 
+from datacontract.engines.checks.physical_type_match import physical_type_matches
+
 # logicalType marker for a field whose type the backend cannot describe: a
 # dynamically-typed column (ibis json: Snowflake VARIANT, Postgres JSONB,
 # BigQuery JSON) or an unsupported one (binary, geography). No declared type can
@@ -176,29 +179,42 @@ def schema_property_matches(expected: SchemaProperty | None, actual: SchemaPrope
     return True
 
 
-def schema_property_mismatch_reason(
-    expected: SchemaProperty | None,
-    actual: SchemaProperty | None,
-    path: str = "",
-) -> str:
-    """Return a human-readable description of the first structural mismatch and a count of other type errors, or '' if none."""
-    errors = schema_property_mismatch_reasons(expected, actual, path)
+class TypeMismatch(NamedTuple):
+    message: str
+    # False when the actual structure cannot be read (json / variant / untyped
+    # object): the declared type is neither confirmed nor refuted.
+    verifiable: bool
+
+
+def format_mismatch_reason(errors: list[TypeMismatch]) -> str:
+    """The first mismatch and a count of the other type errors, or '' if none."""
     num_errors = len(errors)
 
     if num_errors == 0:
         return ""
     elif num_errors == 1:
-        return errors[0]
+        return errors[0].message
     else:
-        return f"{errors[0]} (and {num_errors - 1} other error{'s' if num_errors > 2 else ''})"
+        return f"{errors[0].message} (and {num_errors - 1} other error{'s' if num_errors > 2 else ''})"
+
+
+def schema_property_mismatch_reason(
+    expected: SchemaProperty | None,
+    actual: SchemaProperty | None,
+    path: str = "",
+    dialect=None,
+) -> str:
+    """Return a human-readable description of the first structural mismatch and a count of other type errors, or '' if none."""
+    return format_mismatch_reason(schema_property_mismatch_reasons(expected, actual, path, dialect))
 
 
 def schema_property_mismatch_reasons(
     expected: SchemaProperty | None,
     actual: SchemaProperty | None,
     path: str = "",
-) -> list[str]:
-    errors: list[str] = []
+    dialect=None,
+) -> list[TypeMismatch]:
+    errors: list[TypeMismatch] = []
 
     if expected is None:
         return errors
@@ -206,7 +222,12 @@ def schema_property_mismatch_reasons(
     field_label = f"field '{path}'" if path else "column"
     if actual is None:
         exp_str = expected.logicalType or expected.physicalType
-        errors.append(f"{field_label}: expected type '{exp_str}' but the column type could not be determined")
+        errors.append(
+            TypeMismatch(
+                f"{field_label}: expected type '{exp_str}' but the column type could not be determined",
+                verifiable=False,
+            )
+        )
         return errors
     expected_base = normalize_type_name(expected.logicalType or expected.physicalType)
     actual_base = normalize_type_name(actual.logicalType or actual.physicalType)
@@ -218,30 +239,54 @@ def schema_property_mismatch_reasons(
         exp_str = expected.logicalType or expected.physicalType
         act_str = actual.physicalType or "unknown"
         errors.append(
-            f"{field_label}: has type '{act_str}', but the contract specifies '{exp_str}'. "
-            f"A '{act_str}' value has no verifiable logical type. "
-            f"If this is intentional, specify `physicalType: {act_str}`."
+            TypeMismatch(
+                f"{field_label}: has type '{act_str}', but the contract specifies '{exp_str}'. "
+                f"A '{act_str}' value has no verifiable logical type. "
+                f"If this is intentional, specify `physicalType: {act_str}`.",
+                verifiable=False,
+            )
         )
         return errors
 
+    # A leaf that declares a physicalType is compared against the column's real
+    # native type, where the backend reports one. The declared type wins over the
+    # logicalType, as it does for the column itself.
+    if expected_base not in ("object", "array") and expected.physicalType and actual.physicalType:
+        result, reason = physical_type_matches(expected.physicalType, actual.physicalType, dialect)
+        if result is True:
+            return errors
+        if result is False:
+            errors.append(TypeMismatch(f"{field_label}: {reason}", verifiable=True))
+            return errors
+        # The declared type names nothing in this dialect (a logical keyword such
+        # as `string`, or a type from another platform): fall back to the category
+        # comparison, and only give up when there is no logicalType to fall back on.
+        if expected.logicalType is None:
+            errors.append(TypeMismatch(f"{field_label}: {reason}", verifiable=False))
+            return errors
+
     if expected_base != actual_base and not (expected_base in _NUMERIC and actual_base in _NUMERIC):
         exp_str = expected.logicalType or expected.physicalType
         act_str = actual.logicalType or actual.physicalType
-        errors.append(f"{field_label}: expected type '{exp_str}' but got '{act_str}'")
+        errors.append(TypeMismatch(f"{field_label}: expected type '{exp_str}' but got '{act_str}'", verifiable=True))
         return errors
 
     if expected_base == "array":
         if expected.items is not None:
             child_path = f"{path}[]" if path else "[]"
-            errors.extend(schema_property_mismatch_reasons(expected.items, actual.items, child_path))
+            errors.extend(schema_property_mismatch_reasons(expected.items, actual.items, child_path, dialect))
 
     if expected_base == "object":
         if not expected.properties:
             return errors
         if actual.properties is None:
             errors.append(
-                f"{field_label}: declared with nested fields but the column is an untyped object "
-                "(map/variant) whose structure can't be verified; use a structured type or specify physicalType"
+                TypeMismatch(
+                    f"{field_label}: nested properties are declared but the column is an untyped object "
+                    "whose structure can't be verified. Use a structured type for your data or specify "
+                    "physicalType.",
+                    verifiable=False,
+                )
             )
             return errors
 
@@ -254,9 +299,9 @@ def schema_property_mismatch_reasons(
             act_field = actual_by_name.get(exp_field.name.lower())
 
             if act_field is None:
-                errors.append(f"field '{child_path}' is missing")
+                errors.append(TypeMismatch(f"field '{child_path}' is missing", verifiable=True))
                 continue
 
-            errors.extend(schema_property_mismatch_reasons(exp_field, act_field, child_path))
+            errors.extend(schema_property_mismatch_reasons(exp_field, act_field, child_path, dialect))
 
     return errors

{datacontract_cli-1.0.12 → datacontract_cli-1.0.13}/datacontract/engines/ibis/ibis_check_execute.py

@@ -18,7 +18,13 @@ from open_data_contract_standard.model import OpenDataContractStandard, SchemaPr
 
 from datacontract.engines.checks.check_spec import CheckSpec, MetricType
 from datacontract.engines.checks.physical_type_match import physical_type_matches
-from datacontract.engines.checks.type_normalize import schema_property_matches, schema_property_mismatch_reason
+from datacontract.engines.checks.type_normalize import (
+    format_mismatch_reason,
+    normalize_type_name,
+    schema_property_matches,
+    schema_property_mismatch_reason,
+    schema_property_mismatch_reasons,
+)
 from datacontract.engines.ibis.connections.connect import connect_ibis
 from datacontract.engines.ibis.dtype_category import ibis_dtype_to_schema_property
 from datacontract.engines.ibis.native_type import fetch_native_types, sqlglot_dialect
@@ -63,6 +69,8 @@ def _describe(spec: CheckSpec) -> str:
         return f"type({spec.field}) == {spec.expected_type_label}"
     if spec.metric == MetricType.FIELD_PHYSICAL_TYPE:
         return f"physical_type({spec.field}) == {spec.expected_physical_type}"
+    if spec.metric == MetricType.FIELD_NESTED_TYPE:
+        return f"nested_types({spec.field}) match the contract"
     if spec.metric == MetricType.FIELD_PRESENT:
         return f"present({spec.field})"
     if spec.threshold is not None:
@@ -201,7 +209,8 @@ def _run_model(
     # the real nested types from SHOW COLUMNS so field_type checks can recurse.
     structured_types = None
     if get_server_type(server) == "snowflake" and any(
-        spec.metric in (MetricType.FIELD_TYPE, MetricType.FIELD_PHYSICAL_TYPE) for spec in specs
+        spec.metric in (MetricType.FIELD_TYPE, MetricType.FIELD_PHYSICAL_TYPE, MetricType.FIELD_NESTED_TYPE)
+        for spec in specs
     ):
         structured_types = fetch_structured_types(con, server, t.get_name())
 
@@ -231,6 +240,8 @@ def _run_model(
                 _run_type(run, schema, columns, spec, structured_types)
             elif spec.metric == MetricType.FIELD_PHYSICAL_TYPE:
                 _run_physical_type(run, con, server, schema, columns, native_types, spec, structured_types)
+            elif spec.metric == MetricType.FIELD_NESTED_TYPE:
+                _run_nested_type(run, schema, columns, spec, structured_types, sqlglot_dialect(con))
             elif spec.metric in (MetricType.FRESHNESS, MetricType.RETENTION):
                 _run_freshness(run, t, columns, spec)
             elif spec.metric == MetricType.CUSTOM_SQL:
@@ -746,6 +757,74 @@ def _run_physical_type(
     _set_result(run, spec.key, ResultEnum.warning, f"{reason}; skipping the physical type check")
 
 
+def _run_nested_type(
+    run: Run,
+    schema,
+    columns,
+    spec: CheckSpec,
+    structured_types: dict[str, SchemaProperty] | None = None,
+    dialect=None,
+):
+    """Compare the children a property declares (``properties:`` / ``items:``) against
+    the column's real nested structure. The column's own type is the base check's job.
+    """
+    metric = spec.type
+    _set_impl(run, spec.key, f"nested types of '{spec.field}' match the contract", "introspection")
+    actual_col = columns.get(spec.field.lower())
+    if actual_col is None:
+        _set_diagnostics(run, spec.key, _diag(metric=metric, field=spec.field, expected=spec.expected_type_label))
+        _set_result(run, spec.key, ResultEnum.failed, f"Column '{spec.field}' is missing")
+        return
+
+    dtype = schema[actual_col]
+    structured_prop = structured_types.get(spec.field.lower()) if structured_types else None
+    actual_prop = structured_prop or ibis_dtype_to_schema_property(dtype)
+    actual_label = (structured_prop.physicalType if structured_prop else None) or str(dtype)
+    _set_diagnostics(
+        run,
+        spec.key,
+        _diag(metric=metric, field=spec.field, expected=spec.expected_type_label, actual=actual_label),
+    )
+
+    expected = spec.expected_schema_property
+    expected_base = normalize_type_name(expected.logicalType or expected.physicalType)
+    actual_base = normalize_type_name(actual_prop.logicalType or actual_prop.physicalType)
+    if actual_base is None:
+        # A dynamically-typed column (json / variant / jsonb) holds a different
+        # structure per row, so there is nothing to compare the children against.
+        _set_result(
+            run,
+            spec.key,
+            ResultEnum.warning,
+            f"The structure of the '{actual_label}' column '{spec.field}' cannot be read; "
+            f"skipping the nested type check",
+        )
+        return
+    if expected_base != actual_base:
+        # The base type check names the actual type; repeating it here would print
+        # the column's whole rendered structure.
+        _set_result(
+            run,
+            spec.key,
+            ResultEnum.failed,
+            f"Cannot verify the nested types of '{spec.field}': the column is not an {expected_base}",
+        )
+        return
+
+    errors = schema_property_mismatch_reasons(expected, actual_prop, spec.field, dialect)
+    if not errors:
+        _set_result(run, spec.key, ResultEnum.passed, None)
+        return
+    _update_diagnostics(run, spec.key, {"errors": [error.message for error in errors]})
+    verified = any(error.verifiable for error in errors)
+    _set_result(
+        run,
+        spec.key,
+        ResultEnum.failed if verified else ResultEnum.warning,
+        format_mismatch_reason(errors),
+    )
+
+
 def _run_freshness(run: Run, t, columns, spec: CheckSpec):
     import pandas as pd
 

{datacontract_cli-1.0.12 → datacontract_cli-1.0.13}/datacontract/engines/ibis/snowflake_structured_types.py

@@ -26,13 +26,18 @@ _LEAF_TYPES = {
 
 
 def _to_property(node: dict) -> SchemaProperty:
-    """Convert one ``data_type`` JSON node to a ``SchemaProperty``."""
+    """Convert one ``data_type`` JSON node to a ``SchemaProperty``.
+
+    Every node also carries its rendered native type, so a declared physicalType
+    can be checked against the column's real one down the whole tree.
+    """
+    native = _render_native(node)
     node_type = node.get("type")
     if node_type == "OBJECT":
         fields = node.get("fields")
         if not fields:
             # untyped OBJECT: same shape as the collapsed ibis map
-            return SchemaProperty(logicalType="object", properties=None)
+            return SchemaProperty(logicalType="object", physicalType=native, properties=None)
         properties = []
         for field in fields:
             name = field.get("fieldName")
@@ -48,19 +53,21 @@ def _to_property(node: dict) -> SchemaProperty:
                     properties=child.properties,
                 )
             )
-        return SchemaProperty(logicalType="object", properties=properties or None)
+        return SchemaProperty(logicalType="object", physicalType=native, properties=properties or None)
     if node_type == "ARRAY":
         element = node.get("elementType")
         # untyped ARRAY: no element type to recurse into
-        return SchemaProperty(logicalType="array", items=_to_property(element) if element else None)
+        return SchemaProperty(
+            logicalType="array", physicalType=native, items=_to_property(element) if element else None
+        )
     if node_type == "MAP":
         # dynamic keys can't be matched to named contract properties
-        return SchemaProperty(logicalType="object", properties=None)
+        return SchemaProperty(logicalType="object", physicalType=native, properties=None)
     logical = _LEAF_TYPES.get(node_type)
     if logical:
-        return SchemaProperty(logicalType=logical)
+        return SchemaProperty(logicalType=logical, physicalType=native)
     # VARIANT, BINARY, GEOGRAPHY, …: keep the Snowflake token for the failure message
-    return SchemaProperty(logicalType=UNKNOWN_LOGICAL_TYPE, physicalType=node_type)
+    return SchemaProperty(logicalType=UNKNOWN_LOGICAL_TYPE, physicalType=native)
 
 
 def has_nesting(prop: SchemaProperty) -> bool:
@@ -122,10 +129,7 @@ def fetch_structured_types(con, server: Server, table_name: str) -> dict[str, Sc
         except (TypeError, ValueError):
             continue
         prop = _to_property(node)
-        if has_nesting(prop):
-            # the real native type, for diagnostics the collapsed ibis dtype can't give
-            prop.physicalType = _render_native(node)
-        elif prop.logicalType != UNKNOWN_LOGICAL_TYPE:
+        if not has_nesting(prop) and prop.logicalType != UNKNOWN_LOGICAL_TYPE:
             # scalars and untyped OBJECT/ARRAY: the collapsed ibis dtype says the same
             continue
         # an unverifiable leaf (VARIANT, GEOGRAPHY, …) keeps its Snowflake token, which

{datacontract_cli-1.0.12 → datacontract_cli-1.0.13/datacontract_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datacontract-cli
-Version: 1.0.12
+Version: 1.0.13
 Summary: The datacontract CLI is an open source command-line tool for working with Data Contracts. It uses data contract YAML files to lint the data contract, connect to data sources and execute schema and quality tests, detect breaking changes, and export to different formats. The tool is written in Python. It can be used as a standalone CLI tool, in a CI/CD pipeline, or directly as a Python library.
 Author-email: Jochen Christ <jochen.christ@innoq.com>, Stefan Negele <stefan.negele@innoq.com>, Simon Harrer <simon.harrer@innoq.com>
 License-Expression: MIT
@@ -15,7 +15,7 @@ Requires-Dist: typer<0.27,>=0.18.0
 Requires-Dist: click<9.0.0,>=8.1.0
 Requires-Dist: pydantic<2.14.0,>=2.8.2
 Requires-Dist: pyyaml~=6.0.1
-Requires-Dist: ruamel.yaml<0.19,>=0.17
+Requires-Dist: ruamel.yaml<0.20,>=0.17
 Requires-Dist: requests<2.35,>=2.31
 Requires-Dist: truststore<1.0,>=0.10
 Requires-Dist: fastjsonschema<2.22.0,>=2.19.1
@@ -94,7 +94,7 @@ Provides-Extra: rdf
 Requires-Dist: rdflib==7.6.0; extra == "rdf"
 Provides-Extra: api
 Requires-Dist: fastapi<0.140.0,>=0.115.0; extra == "api"
-Requires-Dist: uvicorn<0.51.0,>=0.44.0; extra == "api"
+Requires-Dist: uvicorn<0.52.0,>=0.44.0; extra == "api"
 Provides-Extra: protobuf
 Requires-Dist: proto-schema-parser<3.0,>=1.0; extra == "protobuf"
 Provides-Extra: all
@@ -112,7 +112,7 @@ Requires-Dist: pytest-xdist; extra == "dev"
 Requires-Dist: pymssql==2.3.13; extra == "dev"
 Requires-Dist: psycopg2-binary<3.0,>=2.9; extra == "dev"
 Requires-Dist: mysql-connector-python<9.7.0,>=8.0.30; extra == "dev"
-Requires-Dist: ruff==0.15.20; extra == "dev"
+Requires-Dist: ruff==0.15.21; extra == "dev"
 Requires-Dist: testcontainers[kafka,minio,mssql,mysql,postgres]==4.14.2; extra == "dev"
 Requires-Dist: trino==0.338.0; extra == "dev"
 Dynamic: license-file

{datacontract_cli-1.0.12 → datacontract_cli-1.0.13}/datacontract_cli.egg-info/SOURCES.txt

@@ -255,6 +255,7 @@ tests/test_cli.py
 tests/test_connect_databricks.py
 tests/test_connect_sqlserver.py
 tests/test_connect_trino.py
+tests/test_create_checks_nested_type.py
 tests/test_create_checks_physical_type.py
 tests/test_data_contract.py
 tests/test_data_contract_checks.py

{datacontract_cli-1.0.12 → datacontract_cli-1.0.13}/datacontract_cli.egg-info/requires.txt

@@ -2,7 +2,7 @@ typer<0.27,>=0.18.0
 click<9.0.0,>=8.1.0
 pydantic<2.14.0,>=2.8.2
 pyyaml~=6.0.1
-ruamel.yaml<0.19,>=0.17
+ruamel.yaml<0.20,>=0.17
 requests<2.35,>=2.31
 truststore<1.0,>=0.10
 fastjsonschema<2.22.0,>=2.19.1
@@ -24,7 +24,7 @@ datacontract-cli[api,athena,azure,bigquery,csv,databricks,dbml,duckdb,excel,gcs,
 
 [api]
 fastapi<0.140.0,>=0.115.0
-uvicorn<0.51.0,>=0.44.0
+uvicorn<0.52.0,>=0.44.0
 
 [athena]
 ibis-framework[athena]<13.0.0,>=10.0.0
@@ -66,7 +66,7 @@ pytest-xdist
 pymssql==2.3.13
 psycopg2-binary<3.0,>=2.9
 mysql-connector-python<9.7.0,>=8.0.30
-ruff==0.15.20
+ruff==0.15.21
 testcontainers[kafka,minio,mssql,mysql,postgres]==4.14.2
 trino==0.338.0
 

{datacontract_cli-1.0.12 → datacontract_cli-1.0.13}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "datacontract-cli"
-version = "1.0.12"
+version = "1.0.13"
 description = "The datacontract CLI is an open source command-line tool for working with Data Contracts. It uses data contract YAML files to lint the data contract, connect to data sources and execute schema and quality tests, detect breaking changes, and export to different formats. The tool is written in Python. It can be used as a standalone CLI tool, in a CI/CD pipeline, or directly as a Python library."
 license = "MIT"
 readme = "README.md"
@@ -19,7 +19,7 @@ dependencies = [
   "click>=8.1.0,<9.0.0",
   "pydantic>=2.8.2,<2.14.0",
   "pyyaml~=6.0.1",
-  "ruamel.yaml>=0.17,<0.19",
+  "ruamel.yaml>=0.17,<0.20",
   "requests>=2.31,<2.35",
   "truststore>=0.10,<1.0",
   "fastjsonschema>=2.19.1,<2.22.0",
@@ -171,7 +171,7 @@ rdf = [
 
 api = [
   "fastapi>=0.115.0,<0.140.0",
-  "uvicorn>=0.44.0,<0.51.0",
+  "uvicorn>=0.44.0,<0.52.0",
 ]
 
 protobuf = [
@@ -200,7 +200,7 @@ dev = [
   # psycopg v3 and DuckDB's mysql extension respectively).
   "psycopg2-binary>=2.9,<3.0",
   "mysql-connector-python>=8.0.30,<9.7.0",
-  "ruff==0.15.20",
+  "ruff==0.15.21",
   "testcontainers[minio,postgres,kafka,mssql,mysql]==4.14.2",
   "trino==0.338.0",
 ]