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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datacontract-cli
-Version: 1.0.10
+Version: 1.0.12
 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

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

@@ -90,6 +90,11 @@ def _raw_match(expected: str, actual: str) -> Optional[bool]:
     return True if not e_params else e == a
 
 
+def _base_sql(dtype: exp.DataType, dialect) -> str:
+    """Render the bare base type in ``dialect``, collapsing that dialect's aliases."""
+    return exp.DataType(this=dtype.this).sql(dialect=dialect).lower()
+
+
 def physical_type_matches(
     expected: Optional[str],
     actual: Optional[str],
@@ -122,7 +127,12 @@ def physical_type_matches(
             f"server under test; skipping the physical type check"
         )
 
-    same_base = exp_dt.this == act_dt.this or {exp_dt.this, act_dt.this} <= _TIMESTAMP_FAMILY
+    both_numeric = {exp_dt.this, act_dt.this} <= exp.DataType.NUMERIC_TYPES
+    same_base = (
+        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))
+    )
     if not same_base:
         return False, f"expected physical type '{expected}' but the column is '{actual}'"
 

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

@@ -14,6 +14,13 @@ import re
 
 from open_data_contract_standard.model import SchemaProperty
 
+# 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
+# be confirmed against it, so any expected type fails rather than silently passing.
+# Distinct from a missing field, which is what dropping it would look like.
+UNKNOWN_LOGICAL_TYPE = "__unknown__"
+
 
 def normalize_type_name(type_name: str | None) -> str | None:
     """Map a contract type name (logical or physical) to one of the 9 ODCS categories.
@@ -139,6 +146,8 @@ def schema_property_matches(expected: SchemaProperty | None, actual: SchemaPrope
     if expected_base is None:
         return True
     if actual_base is None:
+        # actual is unsupported or dynamically typed (json element/variant): a
+        # declared concrete type can't be confirmed against it, so it fails.
         return False
     if expected_base != actual_base and not (expected_base in _NUMERIC and actual_base in _NUMERIC):
         return False
@@ -151,6 +160,8 @@ def schema_property_matches(expected: SchemaProperty | None, actual: SchemaPrope
     if expected_base == "object":
         if not expected.properties:
             return True
+        # actual.properties is None for an untyped object (ibis map/variant): the
+        # empty lookup below fails every declared field, which is what we want.
         actual_by_name = {p.name.lower(): p for p in (actual.properties or []) if p.name}
         for exp_field in expected.properties:
             if not exp_field.name:
@@ -197,13 +208,22 @@ def schema_property_mismatch_reasons(
         exp_str = expected.logicalType or expected.physicalType
         errors.append(f"{field_label}: expected type '{exp_str}' but the column type could not be determined")
         return errors
-
     expected_base = normalize_type_name(expected.logicalType or expected.physicalType)
     actual_base = normalize_type_name(actual.logicalType or actual.physicalType)
 
     if expected_base is None:
         return errors
 
+    if actual_base is None:
+        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}`."
+        )
+        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
@@ -218,6 +238,12 @@ def schema_property_mismatch_reasons(
     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"
+            )
+            return errors
 
         actual_by_name = {p.name.lower(): p for p in (actual.properties or []) if p.name}
         for exp_field in expected.properties:

{datacontract_cli-1.0.10 → datacontract_cli-1.0.12}/datacontract/engines/ibis/dtype_category.py

@@ -6,6 +6,8 @@ from typing import TYPE_CHECKING
 
 from open_data_contract_standard.model import SchemaProperty
 
+from datacontract.engines.checks.type_normalize import UNKNOWN_LOGICAL_TYPE
+
 if TYPE_CHECKING:
     from ibis.expr.datatypes import DataType
 
@@ -48,13 +50,14 @@ def ibis_dtype_category(dtype) -> str:
     return "other"
 
 
-def ibis_dtype_to_schema_property(dtype: DataType) -> SchemaProperty | None:
+def ibis_dtype_to_schema_property(dtype: DataType) -> SchemaProperty:
     """Map an ibis DataType to a SchemaProperty for structural type comparison.
 
     Returns a ``SchemaProperty`` with ``logicalType`` set to one of the 9 ODCS
     categories, recursively populating ``properties`` for structs and ``items``
-    for arrays. Returns ``None`` for unsupported types (binary, map, null, etc.)
-    so the caller can skip comparison rather than raising a false failure.
+    for arrays. A type that carries no verifiable logical type (json, binary,
+    null, …) becomes ``UNKNOWN_LOGICAL_TYPE`` with the actual type kept in
+    ``physicalType``, so the failure message can name it.
     """
     try:
         if dtype.is_boolean():
@@ -74,20 +77,25 @@ def ibis_dtype_to_schema_property(dtype: DataType) -> SchemaProperty | None:
         if dtype.is_struct():
             properties = []
             for field_name, ftype in dtype.fields.items():
+                # an unverifiable field type is still a field: keep it, so it is not reported missing
                 child = ibis_dtype_to_schema_property(ftype)
-                if child is not None:
-                    properties.append(
-                        SchemaProperty(
-                            name=field_name,
-                            logicalType=child.logicalType,
-                            items=child.items,
-                            properties=child.properties,
-                        )
+                properties.append(
+                    SchemaProperty(
+                        name=field_name,
+                        logicalType=child.logicalType,
+                        physicalType=child.physicalType,
+                        items=child.items,
+                        properties=child.properties,
                     )
-            return SchemaProperty(logicalType="object", properties=properties if properties else None)
+                )
+            return SchemaProperty(logicalType="object", properties=properties)
         if dtype.is_array():
             element = ibis_dtype_to_schema_property(dtype.value_type)
             return SchemaProperty(logicalType="array", items=element)
+        if dtype.is_map():
+            # base is confirmable, inner values are not (yet)
+            return SchemaProperty(logicalType="object", properties=None)
     except AttributeError:
-        return None
-    return None
+        return SchemaProperty(logicalType=UNKNOWN_LOGICAL_TYPE)
+    # json holds a different type per row; binary and null have no ODCS category
+    return SchemaProperty(logicalType=UNKNOWN_LOGICAL_TYPE, physicalType=str(dtype))

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

@@ -14,7 +14,7 @@ import uuid
 from collections import defaultdict
 from typing import List, Optional
 
-from open_data_contract_standard.model import OpenDataContractStandard, Server
+from open_data_contract_standard.model import OpenDataContractStandard, SchemaProperty, Server
 
 from datacontract.engines.checks.check_spec import CheckSpec, MetricType
 from datacontract.engines.checks.physical_type_match import physical_type_matches
@@ -22,6 +22,7 @@ from datacontract.engines.checks.type_normalize import schema_property_matches,
 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
+from datacontract.engines.ibis.snowflake_structured_types import fetch_structured_types, has_nesting
 from datacontract.model.exceptions import DataContractException
 from datacontract.model.run import Check, ResultEnum, Run
 from datacontract.model.server import get_server_type
@@ -196,6 +197,14 @@ def _run_model(
     if any(spec.metric == MetricType.FIELD_PHYSICAL_TYPE for spec in specs):
         native_types = fetch_native_types(con, server, model)
 
+    # Snowflake collapses structured OBJECT/ARRAY nesting in the ibis dtype; read
+    # 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
+    ):
+        structured_types = fetch_structured_types(con, server, t.get_name())
+
     agg_exprs = []  # list[(spec, named_expr)]
     for spec in specs:
         try:
@@ -219,9 +228,9 @@ def _run_model(
             elif spec.metric == MetricType.FIELD_PRESENT:
                 _run_present(run, con, model, columns, spec)
             elif spec.metric == MetricType.FIELD_TYPE:
-                _run_type(run, schema, columns, spec)
+                _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)
+                _run_physical_type(run, con, server, schema, columns, native_types, spec, structured_types)
             elif spec.metric in (MetricType.FRESHNESS, MetricType.RETENTION):
                 _run_freshness(run, t, columns, spec)
             elif spec.metric == MetricType.CUSTOM_SQL:
@@ -615,7 +624,7 @@ def _run_present(run: Run, con, model: str, columns, spec: CheckSpec):
     )
 
 
-def _run_type(run: Run, schema, columns, spec: CheckSpec):
+def _run_type(run: Run, schema, columns, spec: CheckSpec, structured_types: dict[str, SchemaProperty] | None = None):
     _set_impl(
         run,
         spec.key,
@@ -628,11 +637,19 @@ def _run_type(run: Run, schema, columns, spec: CheckSpec):
         _set_result(run, spec.key, ResultEnum.failed, f"Column '{spec.field}' is missing")
         return
     dtype = schema[actual_col]
-    actual_prop = ibis_dtype_to_schema_property(dtype)
+    # Snowflake structured types come back collapsed from ibis; prefer the nested
+    # tree recovered from SHOW COLUMNS when available.
+    structured_prop = structured_types.get(spec.field.lower()) if structured_types else None
+    actual_prop = structured_prop or ibis_dtype_to_schema_property(dtype)
     _set_diagnostics(
         run,
         spec.key,
-        _diag(metric="field_type", field=spec.field, expected=spec.expected_type_label, actual=str(dtype)),
+        _diag(
+            metric="field_type",
+            field=spec.field,
+            expected=spec.expected_type_label,
+            actual=structured_prop.physicalType if structured_prop else str(dtype),
+        ),
     )
     if schema_property_matches(spec.expected_schema_property, actual_prop):
         _set_result(run, spec.key, ResultEnum.passed, None)
@@ -646,7 +663,16 @@ def _run_type(run: Run, schema, columns, spec: CheckSpec):
         )
 
 
-def _run_physical_type(run: Run, con, server, schema, columns, native_types, spec: CheckSpec):
+def _run_physical_type(
+    run: Run,
+    con,
+    server,
+    schema,
+    columns,
+    native_types,
+    spec: CheckSpec,
+    structured_types: dict[str, SchemaProperty] | None = None,
+):
     """Compare a column's real native type against the contract's physicalType.
 
     When the native type cannot be read for this backend, or the declared
@@ -668,7 +694,13 @@ def _run_physical_type(run: Run, con, server, schema, columns, native_types, spe
         _set_result(run, spec.key, ResultEnum.failed, f"Column '{spec.field}' is missing")
         return
 
-    actual_native = native_types.get(spec.field.lower()) if native_types else None
+    # The catalog reports a structured OBJECT/ARRAY as its bare token, dropping the
+    # nested types; the tree recovered from SHOW COLUMNS renders the real native type.
+    structured_prop = structured_types.get(spec.field.lower()) if structured_types else None
+    if structured_prop is not None and has_nesting(structured_prop):
+        actual_native = structured_prop.physicalType
+    else:
+        actual_native = native_types.get(spec.field.lower()) if native_types else None
     _set_diagnostics(
         run,
         spec.key,
@@ -697,16 +729,17 @@ def _run_physical_type(run: Run, con, server, schema, columns, native_types, spe
     # logicalType category check when the property declares one.
     fallback = spec.expected_schema_property
     if fallback is not None and fallback.logicalType is not None:
-        actual_prop = ibis_dtype_to_schema_property(schema[actual_col])
+        actual_prop = structured_prop or ibis_dtype_to_schema_property(schema[actual_col])
         if schema_property_matches(fallback, actual_prop):
             _set_result(run, spec.key, ResultEnum.passed, None)
         else:
             mismatch = schema_property_mismatch_reason(fallback, actual_prop)
+            actual_label = actual_native or schema[actual_col]
             _set_result(
                 run,
                 spec.key,
                 ResultEnum.failed,
-                mismatch or f"Expected type '{fallback.logicalType}' but column is '{schema[actual_col]}'",
+                mismatch or f"Expected type '{fallback.logicalType}' but column is '{actual_label}'",
             )
         return
 

{datacontract_cli-1.0.10 → datacontract_cli-1.0.12}/datacontract/engines/ibis/native_type.py

@@ -124,6 +124,10 @@ def _rows(con, query: str):
     try:
         if hasattr(cursor, "fetchall"):
             return list(cursor.fetchall())
+        # The pyspark backend (also used for databricks with a Spark session)
+        # returns a DataFrame; iterating it would yield Column objects.
+        if hasattr(cursor, "collect"):
+            return list(cursor.collect())
         # Some backends (e.g. BigQuery) return an iterable result set
         # (RowIterator) instead of a DBAPI cursor.
         return list(cursor)

datacontract_cli-1.0.12/datacontract/engines/ibis/snowflake_structured_types.py

@@ -0,0 +1,134 @@
+"""Rebuild Snowflake structured OBJECT/ARRAY nesting, which ibis collapses, from SHOW COLUMNS."""
+
+from __future__ import annotations
+
+import json
+
+from open_data_contract_standard.model import SchemaProperty, Server
+
+from datacontract.engines.checks.type_normalize import UNKNOWN_LOGICAL_TYPE
+from datacontract.engines.ibis.native_type import _quote, _rows
+
+# SHOW COLUMNS leaf ``type`` tokens -> ODCS logical type. FIXED and REAL both map
+# to "number" (the comparator treats integer/number as compatible). Tokens not
+# listed (BINARY, GEOGRAPHY, VARIANT, …) carry no verifiable logical type.
+_LEAF_TYPES = {
+    "FIXED": "number",
+    "REAL": "number",
+    "TEXT": "string",
+    "BOOLEAN": "boolean",
+    "DATE": "date",
+    "TIME": "time",
+    "TIMESTAMP_NTZ": "timestamp",
+    "TIMESTAMP_LTZ": "timestamp",
+    "TIMESTAMP_TZ": "timestamp",
+}
+
+
+def _to_property(node: dict) -> SchemaProperty:
+    """Convert one ``data_type`` JSON node to a ``SchemaProperty``."""
+    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)
+        properties = []
+        for field in fields:
+            name = field.get("fieldName")
+            if not name:
+                continue
+            child = _to_property(field.get("fieldType") or {})
+            properties.append(
+                SchemaProperty(
+                    name=name,
+                    logicalType=child.logicalType,
+                    physicalType=child.physicalType,
+                    items=child.items,
+                    properties=child.properties,
+                )
+            )
+        return SchemaProperty(logicalType="object", 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)
+    if node_type == "MAP":
+        # dynamic keys can't be matched to named contract properties
+        return SchemaProperty(logicalType="object", properties=None)
+    logical = _LEAF_TYPES.get(node_type)
+    if logical:
+        return SchemaProperty(logicalType=logical)
+    # VARIANT, BINARY, GEOGRAPHY, …: keep the Snowflake token for the failure message
+    return SchemaProperty(logicalType=UNKNOWN_LOGICAL_TYPE, physicalType=node_type)
+
+
+def has_nesting(prop: SchemaProperty) -> bool:
+    """True only when the property is a structured OBJECT/ARRAY worth substituting."""
+    return bool(prop.properties) or prop.items is not None
+
+
+def _render_native(node: dict) -> str:
+    """Render one ``data_type`` JSON node back to its Snowflake type string."""
+    node_type = node.get("type")
+    if node_type == "OBJECT":
+        fields = node.get("fields")
+        if not fields:
+            return "OBJECT"
+        rendered = [
+            f"{field['fieldName']} {_render_native(field.get('fieldType') or {})}"
+            for field in fields
+            if field.get("fieldName")
+        ]
+        return "OBJECT({})".format(", ".join(rendered)) if rendered else "OBJECT"
+    if node_type == "ARRAY":
+        element = node.get("elementType")
+        return "ARRAY({})".format(_render_native(element)) if element else "ARRAY"
+    if node_type == "MAP":
+        key, value = node.get("keyType"), node.get("valueType")
+        if key and value:
+            return "MAP({}, {})".format(_render_native(key), _render_native(value))
+        return "MAP"
+    if node_type == "FIXED":
+        return "NUMBER({},{})".format(node.get("precision", 38), node.get("scale", 0))
+    if node_type == "REAL":
+        return "FLOAT"
+    if node_type == "TEXT":
+        length = node.get("length")
+        return f"VARCHAR({length})" if length is not None else "VARCHAR"
+    return str(node_type)
+
+
+def fetch_structured_types(con, server: Server, table_name: str) -> dict[str, SchemaProperty] | None:
+    """Return ``{column_name_lower: SchemaProperty}`` for the columns whose real type
+    the collapsed ibis dtype does not convey: structured OBJECT/ARRAY, and leaves with
+    no verifiable logical type. Other columns are omitted. Any failure returns ``None``.
+    """
+    quoted_table = '"{}"'.format(table_name.replace('"', '""'))
+    path = ".".join(part for part in (server.database, server.schema_, quoted_table) if part)
+    identifier = "IDENTIFIER('{}')".format(_quote(path))
+    rows = _rows(con, f"SHOW COLUMNS IN TABLE {identifier}")
+    if not rows:
+        return None
+
+    # SHOW COLUMNS columns: table_name, schema_name, column_name, data_type, ...
+    result: dict[str, SchemaProperty] = {}
+    for row in rows:
+        column_name, data_type = row[2], row[3]
+        if not column_name or not data_type:
+            continue
+        try:
+            node = json.loads(data_type)
+        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:
+            # scalars and untyped OBJECT/ARRAY: the collapsed ibis dtype says the same
+            continue
+        # an unverifiable leaf (VARIANT, GEOGRAPHY, …) keeps its Snowflake token, which
+        # the ibis dtype renders as the useless 'json'
+        result[str(column_name).lower()] = prop
+    return result or None

{datacontract_cli-1.0.10 → datacontract_cli-1.0.12}/datacontract/imports/bigquery_importer.py

@@ -261,9 +261,9 @@ def map_type_from_bigquery(bigquery_type_str: str) -> str:
         "STRING": "string",
         "BYTES": "array",
         "INTEGER": "integer",
-        "INT64": "integer",
+        "INT64": "integer",  # for dbt-bigquery
         "FLOAT": "number",
-        "FLOAT64": "number",
+        "FLOAT64": "number",  # for dbt-bigquery
         "BOOLEAN": "boolean",
         "BOOL": "boolean",
         "TIMESTAMP": "timestamp",
@@ -274,6 +274,7 @@ def map_type_from_bigquery(bigquery_type_str: str) -> str:
         "BIGNUMERIC": "number",
         "GEOGRAPHY": "object",
         "JSON": "object",
+        "INTERVAL": "string",
     }
 
     if bigquery_type_str in type_mapping:

{datacontract_cli-1.0.10 → datacontract_cli-1.0.12}/datacontract/lint/resolve.py

@@ -206,15 +206,18 @@ def _resolve_definition(url: str, type_: str) -> SchemaProperty:
     if url in _definition_cache:
         return _definition_cache[url]
 
-    target_url, headers = _build_request(url, type_)
+    target_url, headers, host_hint = _build_request(url, type_)
 
     try:
         response = requests.get(target_url, headers=headers, timeout=10)
     except requests.RequestException as e:
-        raise _definition_resolution_error(url, target_url, str(e), original_exception=e)
+        raise _definition_resolution_error(url, target_url, str(e), original_exception=e, hint=host_hint)
 
     if response.status_code != 200:
-        raise _definition_resolution_error(url, target_url, f"HTTP {response.status_code} {response.reason}")
+        # 401/403 here almost always means the configured host is the wrong
+        # deployment for this IRI, so surface the ENTROPY_DATA_HOST hint.
+        hint = host_hint if response.status_code in (401, 403) else None
+        raise _definition_resolution_error(url, target_url, f"HTTP {response.status_code} {response.reason}", hint=hint)
 
     try:
         definition = SchemaProperty.model_validate_json(response.content)
@@ -227,8 +230,13 @@ def _resolve_definition(url: str, type_: str) -> SchemaProperty:
     return definition
 
 
-def _build_request(url: str, type_: str) -> tuple[str, dict[str, str]]:
-    """Return the URL to fetch and the headers to use for a given reference.
+def _build_request(url: str, type_: str) -> tuple[str, dict[str, str], str | None]:
+    """Return the URL to fetch, the headers to use, and an optional host hint.
+
+    The third element is a copy-pasteable ENTROPY_DATA_HOST suggestion that
+    callers append to any auth/transport error from the lookup. It is only set
+    for the off-host semantics IRI case below, where a host mismatch is the most
+    common reason the lookup fails (401/403); it is None otherwise.
 
     Three cases:
       - URL on the configured host (relative path or matching absolute URL):
@@ -252,25 +260,26 @@ def _build_request(url: str, type_: str) -> tuple[str, dict[str, str]]:
         api_key = _get_api_key_or_none()
         if api_key is not None:
             headers["x-api-key"] = api_key
-        return direct_url, headers
+        return direct_url, headers, None
 
     if type_ == "definition":
         # Third-party REST URL: fetch anonymously, no IRI fallback.
-        return direct_url, headers
+        return direct_url, headers, None
 
     # Off-host semantics reference: IRI lookup against the configured host.
+    host_hint = _host_mismatch_hint(url, configured_host)
     api_key = _get_api_key_or_none()
     if api_key is None:
         raise _definition_resolution_error(
             url,
             f"{configured_host.rstrip('/')}/api/semantics",
-            "the reference looks like an IRI (host does not match the configured "
-            "entropy-data host); resolving an IRI goes through /api/semantics which "
-            "requires an API key (set ENTROPY_DATA_API_KEY)",
+            "the reference looks like an IRI, so it is resolved through /api/semantics, "
+            "which requires an API key: set ENTROPY_DATA_API_KEY",
+            hint=host_hint,
         )
     headers["x-api-key"] = api_key
     lookup_url = f"{configured_host.rstrip('/')}/api/semantics?iri={quote(url, safe='')}"
-    return lookup_url, headers
+    return lookup_url, headers, host_hint
 
 
 def _apply_definition_to_property(prop: SchemaProperty, definition: SchemaProperty):
@@ -291,10 +300,29 @@ def _hosts_match(url: str, host: str) -> bool:
     return urlparse(url).netloc == urlparse(host).netloc
 
 
+def _host_mismatch_hint(url: str, configured_host: str) -> str:
+    """Actionable hint for the usual cause of a failed IRI lookup: the
+    configured entropy-data host (default https://api.entropy-data.com) is not
+    the deployment that serves this IRI. Names the exact ENTROPY_DATA_HOST value
+    to set -- derived from the IRI's own host -- so the fix is copy-pasteable
+    instead of leaving the user to guess that the host, not the API key, is wrong.
+    """
+    iri = urlparse(url)
+    suggested = f"{iri.scheme}://{iri.netloc}" if iri.scheme and iri.netloc else iri.netloc
+    return (
+        f"the IRI's host '{iri.netloc}' does not match the configured entropy-data host "
+        f"'{urlparse(configured_host).netloc}'; if your contract is served from "
+        f"'{iri.netloc}', set ENTROPY_DATA_HOST={suggested} so the /api/semantics lookup "
+        f"and your API key target that deployment"
+    )
+
+
 def _definition_resolution_error(
-    url: str, target_url: str, detail: str, original_exception: Exception | None = None
+    url: str, target_url: str, detail: str, original_exception: Exception | None = None, hint: str | None = None
 ) -> DataContractException:
     reason = f"Could not resolve business definition '{url}' from {target_url}: {detail}"
+    if hint:
+        reason = f"{reason} — {hint}"
     logging.warning(reason)
     return DataContractException(
         type="lint",

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datacontract-cli
-Version: 1.0.10
+Version: 1.0.12
 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

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

@@ -133,6 +133,7 @@ datacontract/engines/ibis/__init__.py
 datacontract/engines/ibis/dtype_category.py
 datacontract/engines/ibis/ibis_check_execute.py
 datacontract/engines/ibis/native_type.py
+datacontract/engines/ibis/snowflake_structured_types.py
 datacontract/engines/ibis/connections/__init__.py
 datacontract/engines/ibis/connections/connect.py
 datacontract/engines/ibis/connections/duckdb_connection.py
@@ -328,6 +329,7 @@ tests/test_require_env.py
 tests/test_resolve.py
 tests/test_resolve_definitions.py
 tests/test_roundtrip_jsonschema.py
+tests/test_snowflake_structured_types.py
 tests/test_sql_type_converter_physicaltype.py
 tests/test_test_api.py
 tests/test_test_athena_iceberg.py

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

@@ -1,6 +1,6 @@
 [project]
 name = "datacontract-cli"
-version = "1.0.10"
+version = "1.0.12"
 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"