datacontract-cli 1.1.3__tar.gz → 1.2.0__tar.gz

{datacontract_cli-1.1.3/datacontract_cli.egg-info → datacontract_cli-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datacontract-cli
-Version: 1.1.3
+Version: 1.2.0
 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@entropy-data.com>, Stefan Negele <stefan.negele@innoq.com>, Simon Harrer <simon.harrer@entropy-data.com>
 License-Expression: MIT
@@ -40,13 +40,13 @@ Requires-Dist: jsonschema<5.0.0,>=4.23.0
 Requires-Dist: pytz>=2024.1
 Requires-Dist: python-multipart<1.0.0,>=0.0.20
 Requires-Dist: rich<16.0,>=13.7
-Requires-Dist: sqlglot<31.0.0,>=26.6.0
+Requires-Dist: sqlglot<30.18,>=26.6.0
 Requires-Dist: python-dotenv<2.0.0,>=1.0.0
 Requires-Dist: boto3<2.0.0,>=1.34.41
 Requires-Dist: Jinja2<4.0.0,>=3.1.5
 Requires-Dist: jinja_partials<1.0.0,>=0.2.1
 Requires-Dist: datacontract-specification<2.0.0,>=1.2.3
-Requires-Dist: open-data-contract-standard<3.2.0,>=3.1.2
+Requires-Dist: open-data-contract-standard<3.3.0,>=3.2.0
 Requires-Dist: deepdiff<10.0.0,>=6.0.0
 Provides-Extra: avro
 Requires-Dist: avro==1.12.2; extra == "avro"
@@ -67,12 +67,13 @@ Requires-Dist: rich>=12.4.4; extra == "dataframe"
 Provides-Extra: databricks
 Requires-Dist: ibis-framework[databricks]<13.0.0,>=10.0.0; extra == "databricks"
 Requires-Dist: databricks-sql-connector<4.5.0,>=3.7.0; extra == "databricks"
-Requires-Dist: databricks-sdk<0.134.0; extra == "databricks"
+Requires-Dist: databricks-sdk<0.136.0; extra == "databricks"
 Requires-Dist: packaging<27.0,>=21.3; extra == "databricks"
 Provides-Extra: databricks-runtime
 Requires-Dist: datacontract-cli[databricks]; extra == "databricks-runtime"
 Provides-Extra: iceberg
-Requires-Dist: pyiceberg==0.11.1; extra == "iceberg"
+Requires-Dist: pyiceberg[pyarrow,rest-sigv4]==0.12.0; extra == "iceberg"
+Requires-Dist: datacontract-cli[duckdb]; extra == "iceberg"
 Provides-Extra: kafka
 Requires-Dist: datacontract-cli[duckdb,parquet]; extra == "kafka"
 Requires-Dist: confluent-kafka<3.0.0,>=2.6.0; extra == "kafka"
@@ -145,10 +146,10 @@ Requires-Dist: pre-commit<4.7.0,>=3.7.1; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
 Requires-Dist: pytest-xdist; extra == "dev"
-Requires-Dist: pymssql==2.3.13; extra == "dev"
+Requires-Dist: pymssql==2.4.0; extra == "dev"
 Requires-Dist: psycopg2-binary<3.0,>=2.9; extra == "dev"
 Requires-Dist: mysql-connector-python<26.8.0,>=8.0.30; extra == "dev"
-Requires-Dist: ruff==0.16.5; extra == "dev"
+Requires-Dist: ruff==0.16.6; extra == "dev"
 Requires-Dist: testcontainers[kafka,minio,mssql,mysql,postgres]==4.15.0; extra == "dev"
 Requires-Dist: trino==0.339.0; extra == "dev"
 Dynamic: license-file

{datacontract_cli-1.1.3 → datacontract_cli-1.2.0}/datacontract/api.py

@@ -20,7 +20,7 @@ from datacontract.model.changelog import ChangelogEntry
 from datacontract.model.exceptions import DataContractException, DefinitionResolutionError
 from datacontract.model.run import Check, ResultEnum, Run
 
-DATA_CONTRACT_EXAMPLE_PAYLOAD = """apiVersion: v3.1.0
+DATA_CONTRACT_EXAMPLE_PAYLOAD = """apiVersion: v3.2.0
 kind: DataContract
 id: orders
 name: Orders

{datacontract_cli-1.1.3 → datacontract_cli-1.2.0}/datacontract/breaking/detector.py

@@ -23,11 +23,38 @@ class BreakingChangeDetector:
     def detect(self, changelog: ChangelogResult) -> BreakingChangeResult:
         entries = [self._classify(entry) for entry in changelog.entries]
         # Nothing inside a newly added element can break a consumer: it did not exist before.
-        added = {entry.path for entry in entries if entry.change_type == ChangelogType.added}
+        added = {
+            entry.path
+            for entry in entries
+            if entry.change_type == ChangelogType.added
+            and (
+                entry.path.startswith("schema.")
+                and (len(entry.path.split(".")) == 2 or entry.path.split(".")[-2] == "properties")
+            )
+        }
+        removed_enums = {
+            entry.path
+            for entry in entries
+            if entry.change_type == ChangelogType.removed and entry.path.endswith(".enum")
+        }
+        # Stable IDs may change or swap without changing the set of allowed
+        # values. Match removed/updated values against additions in the same enum.
+        added_values = defaultdict(set)
+        for entry in entries:
+            if entry.rule_id == "enum-constraint-changed" and entry.path.endswith(".value"):
+                if entry.change_type in (ChangelogType.added, ChangelogType.updated):
+                    added_values[entry.path.rsplit(".enum.", 1)[0]].add(entry.new_value)
         for entry in entries:
             segments = entry.path.split(".")
             if any(".".join(segments[:i]) in added for i in range(1, len(segments))):
                 entry.level = BreakingChangeLevel.INFO
+            if entry.rule_id == "enum-constraint-changed":
+                if any(entry.path.startswith(path + ".") for path in removed_enums):
+                    entry.level = BreakingChangeLevel.INFO
+                elif entry.path.endswith(".value") and entry.old_value in added_values.get(
+                    entry.path.rsplit(".enum.", 1)[0], set()
+                ):
+                    entry.level = BreakingChangeLevel.INFO
         entries_by_prefix = defaultdict(list)
         for entry in entries:
             prefix = ""

{datacontract_cli-1.1.3 → datacontract_cli-1.2.0}/datacontract/breaking/rules.py

@@ -140,6 +140,43 @@ class MetadataFallbackRule(BreakingChangeRule):
         return RuleEvaluation(self.rule_id, BreakingChangeLevel.INFO, _change_message("contract", entry))
 
 
+class EnumConstraintRule(BreakingChangeRule):
+    rule_id = "enum-constraint-changed"
+
+    def evaluate(self, entry: ChangelogEntry) -> RuleEvaluation | None:
+        if not entry.path.startswith("schema.") or ".properties." not in entry.path:
+            return None
+        if entry.path.endswith(".enum"):
+            level = BreakingChangeLevel.ERROR if entry.type == ChangelogType.added else BreakingChangeLevel.INFO
+        elif (
+            ".enum." in entry.path
+            and entry.path.endswith(".value")
+            and ".customProperties." not in entry.path.rsplit(".enum.", 1)[1]
+            and ".authoritativeDefinitions." not in entry.path.rsplit(".enum.", 1)[1]
+        ):
+            level = BreakingChangeLevel.INFO if entry.type == ChangelogType.added else BreakingChangeLevel.ERROR
+        else:
+            return None
+        return RuleEvaluation(self.rule_id, level, _change_message("allowed values", entry))
+
+
+class VectorShapeRule(BreakingChangeRule):
+    rule_id = "vector-shape-changed"
+
+    def evaluate(self, entry: ChangelogEntry) -> RuleEvaluation | None:
+        if not entry.path.startswith("schema.") or not entry.path.endswith(
+            (".logicalTypeOptions.dimensions", ".logicalTypeOptions.elementType")
+        ):
+            return None
+        if entry.path.endswith(".elementType"):
+            old = entry.old_value or "float32"
+            new = entry.new_value or "float32"
+            level = BreakingChangeLevel.INFO if old == new else BreakingChangeLevel.ERROR
+        else:
+            level = BreakingChangeLevel.WARNING if entry.type == ChangelogType.removed else BreakingChangeLevel.ERROR
+        return RuleEvaluation(self.rule_id, level, _change_message("vector shape", entry))
+
+
 def _is_schema_property_path(segments: list[str]) -> bool:
     return len(segments) >= 3 and segments[0] == "schema" and segments[-2] == "properties"
 
@@ -192,5 +229,7 @@ DEFAULT_RULES: tuple[BreakingChangeRule, ...] = (
     UniqueConstraintRule(),
     KeyConstraintRule(),
     ValidationConstraintRule(),
+    EnumConstraintRule(),
+    VectorShapeRule(),
     MetadataFallbackRule(),
 )

{datacontract_cli-1.1.3 → datacontract_cli-1.2.0}/datacontract/changelog/normalize.py

@@ -44,6 +44,13 @@ Current hardcoded natural keys:
 schema[]                                SchemaObject   -> .name     (required: [name])
 schema[].properties[]                   SchemaProperty -> .name     (required: [name], recursive)
 slaProperties[]                          SLAProperty    -> .property
+slaProperties[].customProperties[]       CustomProperty -> .property
+slaProperties[].authoritativeDefinitions[] AuthoritativeDefinition -> .url
+schema[].properties[].enum[]             EnumValue      -> .value (or .id)
+schema[]/properties[].synonyms[]         Synonym        -> .synonym (or .id)
+schema[]/properties[].relationships[]    Relationship   -> .id, else from:to
+context.verifiedStatements[]             VerifiedStatement -> .question (or .id)
+context.constraints[]                    Constraint     -> .constraint (or .id)
 servers[]                                Server         -> .server
 servers[].roles[]                        Role           -> .role
 servers[].customProperties[]             CustomProperty -> .property
@@ -82,15 +89,41 @@ def _normalize_auth_defs(items: list[dict]) -> dict:
     return result
 
 
+def _normalize_keyed(items: list[dict], *keys: str) -> dict:
+    """Key a list of dicts by the first of ``keys`` an item carries, keeping the key in the value.
+
+    Falls back to the list index if none of the key fields is present.
+    """
+    result = {}
+    for i, item in enumerate(items):
+        key = next((str(item[k]) for k in keys if item.get(k) is not None), None) or f"__pos_{i}__"
+        result[key] = item
+    return result
+
+
+def _normalize_context(context) -> object:
+    """Key the lists of a context block; a plain-string context is returned unchanged."""
+    if not isinstance(context, dict):
+        return context
+    entry = dict(context)
+    if isinstance(entry.get("verifiedStatements"), list):
+        entry["verifiedStatements"] = _normalize_keyed(entry["verifiedStatements"], "id", "question")
+    if isinstance(entry.get("constraints"), list):
+        entry["constraints"] = _normalize_keyed(entry["constraints"], "id", "constraint")
+    return entry
+
+
 def _normalize_relationships(items: list[dict], schema_level: bool = True) -> dict:
-    """Key relationships by a stable composite key.
+    """Key relationships by their id (ODCS v3.2.0), else by a stable composite key.
 
     Schema-level: from:to composite. Property-level: to only.
     Falls back to positional index if key fields are absent.
     """
     result = {}
     for i, item in enumerate(items):
-        if schema_level:
+        if item.get("id"):
+            key = str(item["id"])
+        elif schema_level:
             from_val = str(item.get("from", ""))
             to_val = str(item.get("to", ""))
             key = f"{from_val}:{to_val}" if (from_val or to_val) else f"__pos_{i}__"
@@ -125,6 +158,12 @@ def _normalize_schema_fields(entry: dict, *, schema_level: bool) -> dict:
         entry["authoritativeDefinitions"] = _normalize_auth_defs(entry["authoritativeDefinitions"])
     if "relationships" in entry and isinstance(entry["relationships"], list):
         entry["relationships"] = _normalize_relationships(entry["relationships"], schema_level=schema_level)
+    if "synonyms" in entry and isinstance(entry["synonyms"], list):
+        entry["synonyms"] = _normalize_keyed(entry["synonyms"], "id", "synonym")
+    if "enum" in entry and isinstance(entry["enum"], list):
+        entry["enum"] = _normalize_keyed(entry["enum"], "id", "value")
+    if "context" in entry:
+        entry["context"] = _normalize_context(entry["context"])
     return entry
 
 
@@ -134,13 +173,30 @@ def _normalize_properties(properties: list[dict]) -> dict:
     for prop in properties:
         key = prop.get("name", prop.get("id", str(prop)))
         entry = {k: v for k, v in prop.items() if k != "name"}
-        if "properties" in entry and isinstance(entry["properties"], list):
-            entry["properties"] = _normalize_properties(entry["properties"])
+        entry = _normalize_property_children(entry)
         entry = _normalize_schema_fields(entry, schema_level=False)
         result[key] = entry
     return result
 
 
+def _normalize_property_children(entry: dict) -> dict:
+    """Recurse into the nested property definitions of a property: properties, items, map key and value."""
+    if "properties" in entry and isinstance(entry["properties"], list):
+        entry["properties"] = _normalize_properties(entry["properties"])
+    if isinstance(entry.get("items"), dict):
+        entry["items"] = _normalize_schema_fields(
+            _normalize_property_children(dict(entry["items"])), schema_level=False
+        )
+    if isinstance(entry.get("map"), dict):
+        entry["map"] = {
+            side: _normalize_schema_fields(_normalize_property_children(dict(definition)), schema_level=False)
+            if isinstance(definition, dict)
+            else definition
+            for side, definition in entry["map"].items()
+        }
+    return entry
+
+
 def normalize(contract: dict) -> dict:
     """Convert named lists to dicts keyed by their natural key field.
 
@@ -161,7 +217,16 @@ def normalize(contract: dict) -> dict:
         out["schema"] = normalized_schema
 
     if "slaProperties" in out and isinstance(out["slaProperties"], list):
-        out["slaProperties"] = _normalize_by(out["slaProperties"], "property")
+        sla_properties = _normalize_by(out["slaProperties"], "property")
+        for entry in sla_properties.values():
+            if isinstance(entry.get("customProperties"), list):
+                entry["customProperties"] = _normalize_by(entry["customProperties"], "property")
+            if isinstance(entry.get("authoritativeDefinitions"), list):
+                entry["authoritativeDefinitions"] = _normalize_auth_defs(entry["authoritativeDefinitions"])
+        out["slaProperties"] = sla_properties
+
+    if "context" in out:
+        out["context"] = _normalize_context(out["context"])
 
     if "servers" in out and isinstance(out["servers"], list):
         normalized_servers = {}

{datacontract_cli-1.1.3 → datacontract_cli-1.2.0}/datacontract/command_import.py

@@ -461,13 +461,29 @@ def import_spark(
 
 @import_app.command(
     name="iceberg",
-    epilog="Example: datacontract import iceberg --source schema.json --table orders --output datacontract.yaml",
+    epilog="Examples: datacontract import iceberg --source schema.json --table orders --output datacontract.yaml; "
+    "datacontract import iceberg --catalog-url https://polaris.example.com/api/catalog --namespace sales --table orders",
 )
 def import_iceberg(
-    source: Annotated[Optional[str], typer.Option(help="Path to the Iceberg schema JSON file.")] = None,
+    source: Annotated[
+        Optional[str], typer.Option(help="Path to the Iceberg schema JSON file. Omit to read from a REST catalog.")
+    ] = None,
     table: Annotated[
         Optional[str],
-        typer.Option(help="Table name to assign to the model created from the Iceberg schema."),
+        typer.Option(
+            help="Table name to assign to the model created from the Iceberg schema, or the table to load from the catalog."
+        ),
+    ] = None,
+    catalog_url: Annotated[
+        Optional[str],
+        typer.Option(help="REST catalog endpoint to load the table from (DATACONTRACT_ICEBERG_CATALOG_URL)."),
+    ] = None,
+    catalog: Annotated[Optional[str], typer.Option(help="Name of the catalog (DATACONTRACT_ICEBERG_CATALOG).")] = None,
+    namespace: Annotated[
+        Optional[str], typer.Option(help="Namespace of the table in the catalog (DATACONTRACT_ICEBERG_NAMESPACE).")
+    ] = None,
+    warehouse: Annotated[
+        Optional[str], typer.Option(help="Warehouse passed to the catalog (DATACONTRACT_ICEBERG_WAREHOUSE).")
     ] = None,
     output: output_option = None,
     schema: schema_option = None,
@@ -475,10 +491,20 @@ def import_iceberg(
     id: id_option = None,
     debug: debug_option = None,
 ):
-    """Import a data contract from an Iceberg schema."""
+    """Import a data contract from an Iceberg schema file or a REST catalog."""
     enable_debug_logging(debug)
     result = DataContract.import_from_source(
-        config=cli_config(), format="iceberg", source=source, schema=schema, iceberg_table=table, owner=owner, id=id
+        config=cli_config(),
+        format="iceberg",
+        source=source,
+        schema=schema,
+        iceberg_table=table,
+        iceberg_catalog_url=catalog_url,
+        iceberg_catalog=catalog,
+        iceberg_namespace=namespace,
+        iceberg_warehouse=warehouse,
+        owner=owner,
+        id=id,
     )
     _write_result(result, output)
 

{datacontract_cli-1.1.3 → datacontract_cli-1.2.0}/datacontract/config/settings.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 import logging
 import os
-import re
 from pathlib import Path
 
 from pydantic import Field, SecretStr
@@ -33,6 +32,7 @@ SERVER_OVERRIDE_OPTIONS = {
     "athena_catalog": "catalog",
     "athena_schema": "schema",
     "athena_staging_dir": "stagingDir",
+    "athena_workgroup": "workgroup",
     "bigquery_project": "project",
     "bigquery_dataset": "dataset",
     "databricks_server_hostname": "host",
@@ -40,6 +40,10 @@ SERVER_OVERRIDE_OPTIONS = {
     "databricks_schema": "schema",
     "duckdb_database": "database",
     "duckdb_schema": "schema",
+    "iceberg_catalog_url": "catalogUrl",
+    "iceberg_catalog": "catalog",
+    "iceberg_namespace": "namespace",
+    "iceberg_warehouse": "warehouse",
     "impala_host": "host",
     "impala_port": "port",
     "impala_database": "database",
@@ -104,6 +108,7 @@ class Config(BaseSettings):
     athena_catalog: str | None = None
     athena_schema: str | None = None
     athena_staging_dir: str | None = None
+    athena_workgroup: str | None = None
 
     # azure
     azure_connection_string: SecretStr | None = None
@@ -141,6 +146,19 @@ class Config(BaseSettings):
     gcs_key_id: str | None = None
     gcs_secret: SecretStr | None = None
 
+    # iceberg (REST catalog by default; data files use the s3_* options)
+    iceberg_catalog_type: str | None = None
+    iceberg_credential: SecretStr | None = None
+    iceberg_token: SecretStr | None = None
+    iceberg_s3_endpoint: str | None = None
+    iceberg_signing_name: str | None = None
+    iceberg_properties: str | None = None
+    # overrides for the contract's servers block
+    iceberg_catalog_url: str | None = None
+    iceberg_catalog: str | None = None
+    iceberg_namespace: str | None = None
+    iceberg_warehouse: str | None = None
+
     # impala
     impala_username: str | None = None
     impala_password: SecretStr | None = None
@@ -309,9 +327,10 @@ class Config(BaseSettings):
 
         Nested keys join with ``_`` to form the field name (``snowflake.username``
         → ``snowflake_username``); top-level scalars address the general options
-        (``max_errors``). ``${VAR}`` references in string values are replaced with
-        the environment variable's value at load time, so files can be committed
-        without holding secrets. Unknown option names raise a ValueError.
+        (``max_errors``). ``${VAR}`` and ``${VAR:-default}`` references in string
+        values are replaced with the environment variable's value at load time,
+        so files can be committed without holding secrets. Unknown option names
+        raise a ValueError.
         """
         import yaml
 
@@ -469,6 +488,9 @@ class Config(BaseSettings):
     def get_athena_staging_dir(self, required: bool = False) -> str | None:
         return self._str_option("athena_staging_dir", required)
 
+    def get_athena_workgroup(self, required: bool = False) -> str | None:
+        return self._str_option("athena_workgroup", required)
+
     # --- azure ---
     def get_azure_connection_string(self, required: bool = False) -> str | None:
         return self._str_option("azure_connection_string", required)
@@ -536,6 +558,37 @@ class Config(BaseSettings):
     def get_gcs_secret(self, required: bool = False) -> str | None:
         return self._str_option("gcs_secret", required)
 
+    # --- iceberg ---
+    def get_iceberg_catalog_type(self, required: bool = False) -> str | None:
+        return self._str_option("iceberg_catalog_type", required)
+
+    def get_iceberg_s3_endpoint(self, required: bool = False) -> str | None:
+        return self._str_option("iceberg_s3_endpoint", required)
+
+    def get_iceberg_signing_name(self, required: bool = False) -> str | None:
+        return self._str_option("iceberg_signing_name", required)
+
+    def get_iceberg_properties(self, required: bool = False) -> str | None:
+        return self._str_option("iceberg_properties", required)
+
+    def get_iceberg_credential(self, required: bool = False) -> str | None:
+        return self._str_option("iceberg_credential", required)
+
+    def get_iceberg_token(self, required: bool = False) -> str | None:
+        return self._str_option("iceberg_token", required)
+
+    def get_iceberg_catalog_url(self, required: bool = False) -> str | None:
+        return self._str_option("iceberg_catalog_url", required)
+
+    def get_iceberg_catalog(self, required: bool = False) -> str | None:
+        return self._str_option("iceberg_catalog", required)
+
+    def get_iceberg_namespace(self, required: bool = False) -> str | None:
+        return self._str_option("iceberg_namespace", required)
+
+    def get_iceberg_warehouse(self, required: bool = False) -> str | None:
+        return self._str_option("iceberg_warehouse", required)
+
     # --- impala ---
     def get_impala_username(self, required: bool = False) -> str | None:
         return self._str_option("impala_username", required)
@@ -909,18 +962,8 @@ def unknown_snowflake_env_names() -> list[str]:
     return sorted(name for name in os.environ if name.startswith("DATACONTRACT_SNOWFLAKE_") and name not in known)
 
 
-_ENV_REFERENCE = re.compile(r"\$\{([A-Za-z_][A-Za-z0-9_]*)\}")
-
-
 def _interpolate_env(value, path):
-    """Replace ``${VAR}`` references in string values with environment variable values."""
-    if not isinstance(value, str):
-        return value
-
-    def replace(match):
-        name = match.group(1)
-        if name not in os.environ:
-            raise ValueError(f"Environment variable {name} referenced in {path} is not set.")
-        return os.environ[name]
+    """Replace ``${VAR}`` and ``${VAR:-default}`` references in string values with environment variable values."""
+    from datacontract.config.variables import resolve_variables
 
-    return _ENV_REFERENCE.sub(replace, value)
+    return resolve_variables(value, source=f"config file {path}")

datacontract_cli-1.2.0/datacontract/config/variables.py

@@ -0,0 +1,133 @@
+"""Variable references in string values, per ODCS v3.2.0 (RFC 0050).
+
+Any string value in a data contract may contain ``${VAR_NAME}`` or, with an
+inline default, ``${VAR_NAME:-default}``. References are resolved from the
+process environment (which includes a loaded ``.env`` file) at the moment a
+value is *used*: when a connection is opened or a quality query is executed.
+The loaded contract itself is never mutated, so ``export`` and ``publish``
+write the references back verbatim.
+
+A reference to an unset or empty variable without a default is an error;
+an empty string is never substituted silently.
+"""
+
+import os
+import re
+
+from open_data_contract_standard.model import Server
+from pydantic import BaseModel
+
+_VARIABLE = re.compile(r"\$\{([A-Za-z_][A-Za-z0-9_]*)(?::-([^}]*))?\}")
+
+
+class UnresolvedVariableError(ValueError):
+    """A ``${VAR}`` reference names a variable that is unset and has no default."""
+
+    def __init__(self, name: str, source: str = ""):
+        self.name = name
+        where = f" in {source}" if source else ""
+        super().__init__(f"Variable {name} referenced{where} is not set.")
+
+
+def contains_variables(value) -> bool:
+    """True if ``value`` is a string holding at least one ``${VAR}`` reference."""
+    return isinstance(value, str) and _VARIABLE.search(value) is not None
+
+
+def resolve_variables(value, source: str = ""):
+    """Return ``value`` with every ``${VAR}`` reference replaced.
+
+    Non-string values pass through unchanged. ``source`` names the value in
+    the error message (``"server 'prod' host"``, ``"config file x.yaml"``).
+    """
+    if not isinstance(value, str):
+        return value
+
+    def replace(match: re.Match) -> str:
+        name, default = match.group(1), match.group(2)
+        env_value = os.environ.get(name)
+        if env_value:
+            return env_value
+        if default is not None:
+            return default
+        raise UnresolvedVariableError(name, source)
+
+    return _VARIABLE.sub(replace, value)
+
+
+def resolve_server_variables(server: Server) -> Server:
+    """Return a copy of ``server`` with the references in its string fields resolved.
+
+    ``port`` may hold a reference (the schema allows a string there for that
+    reason); a resolved all-digit port becomes an int again. Custom property
+    values are resolved too. The contract's server is not mutated.
+    """
+    updates = {}
+    for field in Server.model_fields:
+        value = getattr(server, field)
+        if contains_variables(value):
+            updates[field] = resolve_variables(value, source=f"server '{server.server}' {_field_name(field)}")
+    port = updates.get("port", server.port)
+    if isinstance(port, str) and port.isdigit():
+        updates["port"] = int(port)
+    if server.customProperties:
+        custom_properties = []
+        changed = False
+        for prop in server.customProperties:
+            if contains_variables(prop.value):
+                changed = True
+                prop = prop.model_copy(
+                    update={
+                        "value": resolve_variables(
+                            prop.value, source=f"server '{server.server}' custom property '{prop.property}'"
+                        )
+                    }
+                )
+            custom_properties.append(prop)
+        if changed:
+            updates["customProperties"] = custom_properties
+    return server.model_copy(update=updates) if updates else server
+
+
+def _field_name(field: str) -> str:
+    return "schema" if field == "schema_" else field
+
+
+# These fields document the contract rather than supply test inputs. SQL queries
+# resolve separately, after the engine substitutes its ${model}/${field} tokens;
+# servers resolve separately, after configuration overrides and server selection.
+_DEFERRED_FIELDS = {
+    "authoritativeDefinitions",
+    "businessName",
+    "context",
+    "description",
+    "examples",
+    "implementation",
+    "query",
+    "servers",
+    "synonyms",
+    "transformLogic",
+    "transformSourceObjects",
+}
+
+
+def resolve_runtime_variables(value, source: str = "contract"):
+    """Copy test inputs with variables resolved, recursively, without altering the contract.
+
+    Handles property names/types, enum values, logical type options, library
+    quality arguments, SLA values, and nested array/map definitions. Dictionary
+    keys are structural identifiers and are never interpolated.
+    """
+    if isinstance(value, BaseModel):
+        return value.model_copy(
+            update={
+                field: resolve_runtime_variables(getattr(value, field), f"{source}.{_field_name(field)}")
+                for field in type(value).model_fields
+                if field not in _DEFERRED_FIELDS
+            }
+        )
+    if isinstance(value, dict):
+        return {key: resolve_runtime_variables(item, f"{source}.{key}") for key, item in value.items()}
+    if isinstance(value, list):
+        return [resolve_runtime_variables(item, f"{source}[{index}]") for index, item in enumerate(value)]
+    return resolve_variables(value, source=source)

datacontract_cli-1.2.0/datacontract/editor_assets/VERSION

@@ -0,0 +1 @@
+0.1.13