datacontract-cli 0.10.15__py3-none-any.whl → 0.10.16__py3-none-any.whl

datacontract/breaking/breaking.py

@@ -1,6 +1,6 @@
 from datacontract.breaking.breaking_rules import BreakingRules
 from datacontract.model.breaking_change import BreakingChange, Location, Severity
-from datacontract.model.data_contract_specification import Contact, Field, Info, Model, Quality, Terms
+from datacontract.model.data_contract_specification import Contact, DeprecatedQuality, Field, Info, Model, Terms
 
 
 def info_breaking_changes(
@@ -216,8 +216,8 @@ def terms_breaking_changes(
 
 
 def quality_breaking_changes(
-    old_quality: Quality,
-    new_quality: Quality,
+    old_quality: DeprecatedQuality,
+    new_quality: DeprecatedQuality,
     new_path: str,
     include_severities: [Severity],
 ) -> list[BreakingChange]:

datacontract/cli.py

@@ -221,7 +221,7 @@ def export(
     )
     # Don't interpret console markup in output.
     if output is None:
-        console.print(result, markup=False)
+        console.print(result, markup=False, soft_wrap=True)
     else:
         with output.open("w") as f:
             f.write(result)
@@ -298,7 +298,7 @@ def import_(
         iceberg_table=iceberg_table,
     )
     if output is None:
-        console.print(result.to_yaml())
+        console.print(result.to_yaml(), markup=False, soft_wrap=True)
     else:
         with output.open("w") as f:
             f.write(result.to_yaml())

datacontract/engines/soda/check_soda_execute.py

@@ -12,7 +12,7 @@ from datacontract.engines.soda.connections.sqlserver import to_sqlserver_soda_co
 from datacontract.engines.soda.connections.trino import to_trino_soda_configuration
 from datacontract.export.sodacl_converter import to_sodacl_yaml
 from datacontract.model.data_contract_specification import DataContractSpecification, Server
-from datacontract.model.run import Check, Log, Run
+from datacontract.model.run import Check, Log, ResultEnum, Run
 
 
 def check_soda_execute(run: Run, data_contract: DataContractSpecification, server: Server, spark, tmp_dir):
@@ -33,7 +33,7 @@ def check_soda_execute(run: Run, data_contract: DataContractSpecification, serve
                 Check(
                     type="general",
                     name="Check that format is supported",
-                    result="warning",
+                    result=ResultEnum.warning,
                     reason=f"Format {server.format} not yet supported by datacontract CLI",
                     engine="datacontract",
                 )
@@ -93,7 +93,7 @@ def check_soda_execute(run: Run, data_contract: DataContractSpecification, serve
             Check(
                 type="general",
                 name="Check that server type is supported",
-                result="warning",
+                result=ResultEnum.warning,
                 reason=f"Server type {server.type} not yet supported by datacontract CLI",
                 engine="datacontract-cli",
             )
@@ -182,5 +182,5 @@ def update_reason(check, c):
                 check.reason = diagnostics_text_split[1].strip()
                 # print(check.reason)
             break  # Exit the loop once the desired block is found
-    if c["diagnostics"]["fail"] is not None:
+    if "fail" in c["diagnostics"]:
         check.reason = f"Got: {c['diagnostics']['value']} Expected: {c['diagnostics']['fail']}"

datacontract/export/dbt_converter.py

@@ -1,4 +1,4 @@
-from typing import Dict
+from typing import Dict, Optional
 
 import yaml
 
@@ -52,14 +52,14 @@ def to_dbt_staging_sql(data_contract_spec: DataContractSpecification, model_name
         # TODO escape SQL reserved key words, probably dependent on server type
         columns.append(field_name)
     return f"""
-    select 
+    select
         {", ".join(columns)}
     from {{{{ source('{id}', '{model_name}') }}}}
 """
 
 
 def to_dbt_sources_yaml(data_contract_spec: DataContractSpecification, server: str = None):
-    source = {"name": data_contract_spec.id, "tables": []}
+    source = {"name": data_contract_spec.id}
     dbt = {
         "version": 2,
         "sources": [source],
@@ -69,24 +69,31 @@ def to_dbt_sources_yaml(data_contract_spec: DataContractSpecification, server: s
     if data_contract_spec.info.description is not None:
         source["description"] = data_contract_spec.info.description
     found_server = data_contract_spec.servers.get(server)
+    adapter_type = None
     if found_server is not None:
-        source["database"] = found_server.database
-        source["schema"] = found_server.schema_
+        adapter_type = found_server.type
+        if adapter_type == "bigquery":
+            source["database"] = found_server.project
+            source["schema"] = found_server.dataset
+        else:
+            source["database"] = found_server.database
+            source["schema"] = found_server.schema_
 
+    source["tables"] = []
     for model_key, model_value in data_contract_spec.models.items():
-        dbt_model = _to_dbt_source_table(model_key, model_value)
+        dbt_model = _to_dbt_source_table(model_key, model_value, adapter_type)
         source["tables"].append(dbt_model)
     return yaml.dump(dbt, indent=2, sort_keys=False, allow_unicode=True)
 
 
-def _to_dbt_source_table(model_key, model_value: Model) -> dict:
+def _to_dbt_source_table(model_key, model_value: Model, adapter_type: Optional[str]) -> dict:
     dbt_model = {
         "name": model_key,
     }
 
     if model_value.description is not None:
         dbt_model["description"] = model_value.description
-    columns = _to_columns(model_value.fields, False, False)
+    columns = _to_columns(model_value.fields, False, adapter_type)
     if columns:
         dbt_model["columns"] = columns
     return dbt_model
@@ -107,7 +114,7 @@ def _to_dbt_model(model_key, model_value: Model, data_contract_spec: DataContrac
         dbt_model["config"]["contract"] = {"enforced": True}
     if model_value.description is not None:
         dbt_model["description"] = model_value.description
-    columns = _to_columns(model_value.fields, _supports_constraints(model_type), True)
+    columns = _to_columns(model_value.fields, _supports_constraints(model_type), None)
     if columns:
         dbt_model["columns"] = columns
     return dbt_model
@@ -130,48 +137,47 @@ def _supports_constraints(model_type):
     return model_type == "table" or model_type == "incremental"
 
 
-def _to_columns(fields: Dict[str, Field], supports_constraints: bool, supports_datatype: bool) -> list:
+def _to_columns(fields: Dict[str, Field], supports_constraints: bool, adapter_type: Optional[str]) -> list:
     columns = []
     for field_name, field in fields.items():
-        column = _to_column(field, supports_constraints, supports_datatype)
-        column["name"] = field_name
+        column = _to_column(field_name, field, supports_constraints, adapter_type)
         columns.append(column)
     return columns
 
 
-def _to_column(field: Field, supports_constraints: bool, supports_datatype: bool) -> dict:
-    column = {}
-    dbt_type = convert_to_sql_type(field, "snowflake")
+def _to_column(field_name: str, field: Field, supports_constraints: bool, adapter_type: Optional[str]) -> dict:
+    column = {"name": field_name}
+    adapter_type = adapter_type or "snowflake"
+    dbt_type = convert_to_sql_type(field, adapter_type)
+
+    column["data_tests"] = []
     if dbt_type is not None:
-        if supports_datatype:
-            column["data_type"] = dbt_type
-        else:
-            column.setdefault("tests", []).append(
-                {"dbt_expectations.dbt_expectations.expect_column_values_to_be_of_type": {"column_type": dbt_type}}
-            )
+        column["data_type"] = dbt_type
+    else:
+        column["data_tests"].append(
+            {"dbt_expectations.dbt_expectations.expect_column_values_to_be_of_type": {"column_type": dbt_type}}
+        )
     if field.description is not None:
         column["description"] = field.description
     if field.required:
         if supports_constraints:
             column.setdefault("constraints", []).append({"type": "not_null"})
         else:
-            column.setdefault("tests", []).append("not_null")
+            column["data_tests"].append("not_null")
     if field.unique:
         if supports_constraints:
             column.setdefault("constraints", []).append({"type": "unique"})
         else:
-            column.setdefault("tests", []).append("unique")
+            column["data_tests"].append("unique")
     if field.enum is not None and len(field.enum) > 0:
-        column.setdefault("tests", []).append({"accepted_values": {"values": field.enum}})
+        column["data_tests"].append({"accepted_values": {"values": field.enum}})
     if field.minLength is not None or field.maxLength is not None:
         length_test = {}
         if field.minLength is not None:
             length_test["min_value"] = field.minLength
         if field.maxLength is not None:
             length_test["max_value"] = field.maxLength
-        column.setdefault("tests", []).append(
-            {"dbt_expectations.expect_column_value_lengths_to_be_between": length_test}
-        )
+        column["data_tests"].append({"dbt_expectations.expect_column_value_lengths_to_be_between": length_test})
     if field.pii is not None:
         column.setdefault("meta", {})["pii"] = field.pii
     if field.classification is not None:
@@ -180,9 +186,7 @@ def _to_column(field: Field, supports_constraints: bool, supports_datatype: bool
         column.setdefault("tags", []).extend(field.tags)
     if field.pattern is not None:
         # Beware, the data contract pattern is a regex, not a like pattern
-        column.setdefault("tests", []).append(
-            {"dbt_expectations.expect_column_values_to_match_regex": {"regex": field.pattern}}
-        )
+        column["data_tests"].append({"dbt_expectations.expect_column_values_to_match_regex": {"regex": field.pattern}})
     if (
         field.minimum is not None
         or field.maximum is not None
@@ -194,7 +198,7 @@ def _to_column(field: Field, supports_constraints: bool, supports_datatype: bool
             range_test["min_value"] = field.minimum
         if field.maximum is not None:
             range_test["max_value"] = field.maximum
-        column.setdefault("tests", []).append({"dbt_expectations.expect_column_values_to_be_between": range_test})
+        column["data_tests"].append({"dbt_expectations.expect_column_values_to_be_between": range_test})
     elif (
         field.exclusiveMinimum is not None
         or field.exclusiveMaximum is not None
@@ -207,18 +211,18 @@ def _to_column(field: Field, supports_constraints: bool, supports_datatype: bool
         if field.exclusiveMaximum is not None:
             range_test["max_value"] = field.exclusiveMaximum
         range_test["strictly"] = True
-        column.setdefault("tests", []).append({"dbt_expectations.expect_column_values_to_be_between": range_test})
+        column["data_tests"].append({"dbt_expectations.expect_column_values_to_be_between": range_test})
     else:
         if field.minimum is not None:
-            column.setdefault("tests", []).append(
+            column["data_tests"].append(
                 {"dbt_expectations.expect_column_values_to_be_between": {"min_value": field.minimum}}
             )
         if field.maximum is not None:
-            column.setdefault("tests", []).append(
+            column["data_tests"].append(
                 {"dbt_expectations.expect_column_values_to_be_between": {"max_value": field.maximum}}
             )
         if field.exclusiveMinimum is not None:
-            column.setdefault("tests", []).append(
+            column["data_tests"].append(
                 {
                     "dbt_expectations.expect_column_values_to_be_between": {
                         "min_value": field.exclusiveMinimum,
@@ -227,7 +231,7 @@ def _to_column(field: Field, supports_constraints: bool, supports_datatype: bool
                 }
             )
         if field.exclusiveMaximum is not None:
-            column.setdefault("tests", []).append(
+            column["data_tests"].append(
                 {
                     "dbt_expectations.expect_column_values_to_be_between": {
                         "max_value": field.exclusiveMaximum,
@@ -236,5 +240,8 @@ def _to_column(field: Field, supports_constraints: bool, supports_datatype: bool
                 }
             )
 
+        if not column["data_tests"]:
+            column.pop("data_tests")
+
     # TODO: all constraints
     return column

datacontract/export/exporter.py

@@ -40,6 +40,7 @@ class ExportFormat(str, Enum):
     sqlalchemy = "sqlalchemy"
     data_caterer = "data-caterer"
     dcs = "dcs"
+    iceberg = "iceberg"
 
     @classmethod
     def get_supported_formats(cls):

datacontract/export/exporter_factory.py

@@ -168,3 +168,7 @@ exporter_factory.register_lazy_exporter(
 exporter_factory.register_lazy_exporter(
     name=ExportFormat.dcs, module_path="datacontract.export.dcs_exporter", class_name="DcsExporter"
 )
+
+exporter_factory.register_lazy_exporter(
+    name=ExportFormat.iceberg, module_path="datacontract.export.iceberg_converter", class_name="IcebergExporter"
+)

datacontract/export/iceberg_converter.py

@@ -0,0 +1,188 @@
+from pyiceberg import types
+from pyiceberg.schema import Schema, assign_fresh_schema_ids
+
+from datacontract.export.exporter import Exporter
+from datacontract.model.data_contract_specification import (
+    DataContractSpecification,
+    Field,
+    Model,
+)
+
+
+class IcebergExporter(Exporter):
+    """
+    Exporter class for exporting data contracts to Iceberg schemas.
+    """
+
+    def export(
+        self,
+        data_contract: DataContractSpecification,
+        model,
+        server,
+        sql_server_type,
+        export_args,
+    ):
+        """
+        Export the given data contract model to an Iceberg schema.
+
+        Args:
+            data_contract (DataContractSpecification): The data contract specification.
+            model: The model to export, currently just supports one model.
+            server: Not used in this implementation.
+            sql_server_type: Not used in this implementation.
+            export_args: Additional arguments for export.
+
+        Returns:
+            str: A string representation of the Iceberg json schema.
+        """
+
+        return to_iceberg(data_contract, model)
+
+
+def to_iceberg(contract: DataContractSpecification, model: str) -> str:
+    """
+    Converts a DataContractSpecification into an Iceberg json schema string. JSON string follows https://iceberg.apache.org/spec/#appendix-c-json-serialization.
+
+    Args:
+        contract (DataContractSpecification): The data contract specification containing models.
+        model: The model to export, currently just supports one model.
+
+    Returns:
+        str: A string representation of the Iceberg json schema.
+    """
+    if model is None or model == "all":
+        if len(contract.models.items()) != 1:
+            # Iceberg doesn't have a way to combine multiple models into a single schema, an alternative would be to export json lines
+            raise Exception(f"Can only output one model at a time, found {len(contract.models.items())} models")
+        for model_name, model in contract.models.items():
+            schema = to_iceberg_schema(model)
+    else:
+        if model not in contract.models:
+            raise Exception(f"model {model} not found in contract")
+        schema = to_iceberg_schema(contract.models[model])
+
+    return schema.model_dump_json()
+
+
+def to_iceberg_schema(model: Model) -> types.StructType:
+    """
+    Convert a model to a Iceberg schema.
+
+    Args:
+        model (Model): The model to convert.
+
+    Returns:
+        types.StructType: The corresponding Iceberg schema.
+    """
+    iceberg_fields = []
+    primary_keys = []
+    for field_name, spec_field in model.fields.items():
+        iceberg_field = make_field(field_name, spec_field)
+        iceberg_fields.append(iceberg_field)
+
+        if spec_field.primaryKey:
+            primary_keys.append(iceberg_field.name)
+
+    schema = Schema(*iceberg_fields)
+
+    # apply non-0 field IDs so we can set the identifier fields for the schema
+    schema = assign_fresh_schema_ids(schema)
+    for field in schema.fields:
+        if field.name in primary_keys:
+            schema.identifier_field_ids.append(field.field_id)
+
+    return schema
+
+
+def make_field(field_name, field):
+    field_type = get_field_type(field)
+
+    # Note: might want to re-populate field_id from config['icebergFieldId'] if it exists, however, it gets
+    # complicated since field_ids impact the list and map element_ids, and the importer is not keeping track of those.
+    # Even if IDs are re-constituted, it seems like the SDK code would still reset them before any operation against a catalog,
+    # so it's likely not worth it.
+
+    # Note 2: field_id defaults to 0 to signify that the exporter is not attempting to populate meaningful values.
+    # also, the Iceberg sdk catalog code will re-set the fieldIDs prior to executing any table operations on the schema
+    # ref: https://github.com/apache/iceberg-python/pull/1072
+    return types.NestedField(field_id=0, name=field_name, field_type=field_type, required=field.required)
+
+
+def make_list(item):
+    field_type = get_field_type(item)
+
+    # element_id defaults to 0 to signify that the exporter is not attempting to populate meaningful values (see #make_field)
+    return types.ListType(element_id=0, element_type=field_type, element_required=item.required)
+
+
+def make_map(field):
+    key_type = get_field_type(field.keys)
+    value_type = get_field_type(field.values)
+
+    # key_id and value_id defaults to 0 to signify that the exporter is not attempting to populate meaningful values (see #make_field)
+    return types.MapType(
+        key_id=0, key_type=key_type, value_id=0, value_type=value_type, value_required=field.values.required
+    )
+
+
+def to_struct_type(fields: dict[str, Field]) -> types.StructType:
+    """
+    Convert a dictionary of fields to a Iceberg StructType.
+
+    Args:
+        fields (dict[str, Field]): The fields to convert.
+
+    Returns:
+        types.StructType: The corresponding Iceberg StructType.
+    """
+    struct_fields = []
+    for field_name, field in fields.items():
+        struct_field = make_field(field_name, field)
+        struct_fields.append(struct_field)
+    return types.StructType(*struct_fields)
+
+
+def get_field_type(field: Field) -> types.IcebergType:
+    """
+    Convert a field to a Iceberg IcebergType.
+
+    Args:
+        field (Field): The field to convert.
+
+    Returns:
+        types.IcebergType: The corresponding Iceberg IcebergType.
+    """
+    field_type = field.type
+    if field_type is None or field_type in ["null"]:
+        return types.NullType()
+    if field_type == "array":
+        return make_list(field.items)
+    if field_type == "map":
+        return make_map(field)
+    if field_type in ["object", "record", "struct"]:
+        return to_struct_type(field.fields)
+    if field_type in ["string", "varchar", "text"]:
+        return types.StringType()
+    if field_type in ["number", "decimal", "numeric"]:
+        precision = field.precision if field.precision is not None else 38
+        scale = field.scale if field.scale is not None else 0
+        return types.DecimalType(precision=precision, scale=scale)
+    if field_type in ["integer", "int"]:
+        return types.IntegerType()
+    if field_type in ["bigint", "long"]:
+        return types.LongType()
+    if field_type == "float":
+        return types.FloatType()
+    if field_type == "double":
+        return types.DoubleType()
+    if field_type == "boolean":
+        return types.BooleanType()
+    if field_type in ["timestamp", "timestamp_tz"]:
+        return types.TimestamptzType()
+    if field_type == "timestamp_ntz":
+        return types.TimestampType()
+    if field_type == "date":
+        return types.DateType()
+    if field_type == "bytes":
+        return types.BinaryType()
+    return types.BinaryType()

datacontract/export/odcs_v3_exporter.py

@@ -148,6 +148,10 @@ def to_odcs_schema(model_key, model_value: Model) -> dict:
     if properties:
         odcs_table["properties"] = properties
 
+    model_quality = to_odcs_quality_list(model_value.quality)
+    if len(model_quality) > 0:
+        odcs_table["quality"] = model_quality
+
     odcs_table["customProperties"] = []
     if model_value.model_extra is not None:
         for key, value in model_value.model_extra.items():
@@ -257,38 +261,48 @@ def to_property(field_name: str, field: Field) -> dict:
         del property["logicalTypeOptions"]
 
     if field.quality is not None:
-        quality_property = []
-        for quality in field.quality:
-            quality_dict = {"type": quality.type}
-            if quality.description is not None:
-                quality_dict["description"] = quality.description
-            if quality.query is not None:
-                quality_dict["query"] = quality.query
-            # dialect is not supported in v3.0.0
-            if quality.mustBe is not None:
-                quality_dict["mustBe"] = quality.mustBe
-            if quality.mustNotBe is not None:
-                quality_dict["mustNotBe"] = quality.mustNotBe
-            if quality.mustBeGreaterThan is not None:
-                quality_dict["mustBeGreaterThan"] = quality.mustBeGreaterThan
-            if quality.mustBeGreaterThanOrEqualTo is not None:
-                quality_dict["mustBeGreaterThanOrEqualTo"] = quality.mustBeGreaterThanOrEqualTo
-            if quality.mustBeLessThan is not None:
-                quality_dict["mustBeLessThan"] = quality.mustBeLessThan
-            if quality.mustBeLessThanOrEqualTo is not None:
-                quality_dict["mustBeLessThanOrEqualTo"] = quality.mustBeLessThanOrEqualTo
-            if quality.mustBeBetween is not None:
-                quality_dict["mustBeBetween"] = quality.mustBeBetween
-            if quality.mustNotBeBetween is not None:
-                quality_dict["mustNotBeBetween"] = quality.mustNotBeBetween
-            if quality.engine is not None:
-                quality_dict["engine"] = quality.engine
-            if quality.implementation is not None:
-                quality_dict["implementation"] = quality.implementation
-            quality_property.append(quality_dict)
+        quality_list = field.quality
+        quality_property = to_odcs_quality_list(quality_list)
         if len(quality_property) > 0:
             property["quality"] = quality_property
 
     # todo enum
 
     return property
+
+
+def to_odcs_quality_list(quality_list):
+    quality_property = []
+    for quality in quality_list:
+        quality_property.append(to_odcs_quality(quality))
+    return quality_property
+
+
+def to_odcs_quality(quality):
+    quality_dict = {"type": quality.type}
+    if quality.description is not None:
+        quality_dict["description"] = quality.description
+    if quality.query is not None:
+        quality_dict["query"] = quality.query
+    # dialect is not supported in v3.0.0
+    if quality.mustBe is not None:
+        quality_dict["mustBe"] = quality.mustBe
+    if quality.mustNotBe is not None:
+        quality_dict["mustNotBe"] = quality.mustNotBe
+    if quality.mustBeGreaterThan is not None:
+        quality_dict["mustBeGreaterThan"] = quality.mustBeGreaterThan
+    if quality.mustBeGreaterThanOrEqualTo is not None:
+        quality_dict["mustBeGreaterThanOrEqualTo"] = quality.mustBeGreaterThanOrEqualTo
+    if quality.mustBeLessThan is not None:
+        quality_dict["mustBeLessThan"] = quality.mustBeLessThan
+    if quality.mustBeLessThanOrEqualTo is not None:
+        quality_dict["mustBeLessThanOrEqualTo"] = quality.mustBeLessThanOrEqualTo
+    if quality.mustBeBetween is not None:
+        quality_dict["mustBeBetween"] = quality.mustBeBetween
+    if quality.mustNotBeBetween is not None:
+        quality_dict["mustNotBeBetween"] = quality.mustNotBeBetween
+    if quality.engine is not None:
+        quality_dict["engine"] = quality.engine
+    if quality.implementation is not None:
+        quality_dict["implementation"] = quality.implementation
+    return quality_dict

datacontract/export/sodacl_converter.py

@@ -200,9 +200,9 @@ def check_quality_list(model_name, field_name, quality_list: List[Quality]):
     for quality in quality_list:
         if quality.type == "sql":
             if field_name is None:
-                metric_name = f"{model_name}_{field_name}_quality_sql_{count}"
-            else:
                 metric_name = f"{model_name}_quality_sql_{count}"
+            else:
+                metric_name = f"{model_name}_{field_name}_quality_sql_{count}"
             threshold = to_sodacl_threshold(quality)
             query = prepare_query(quality, model_name, field_name)
             if query is None:
@@ -265,6 +265,7 @@ def to_sodacl_threshold(quality: Quality) -> str | None:
     return None
 
 
+# These are deprecated root-level quality specifications, use the model-level and field-level quality fields instead
 def add_quality_checks(sodacl, data_contract_spec):
     if data_contract_spec.quality is None:
         return

datacontract/imports/dbt_importer.py

@@ -3,7 +3,10 @@ from typing import TypedDict
 
 from dbt.artifacts.resources.v1.components import ColumnInfo
 from dbt.contracts.graph.manifest import Manifest
+from dbt.contracts.graph.nodes import GenericTestNode
+from dbt_common.contracts.constraints import ConstraintType
 
+from datacontract.imports.bigquery_importer import map_type_from_bigquery
 from datacontract.imports.importer import Importer
 from datacontract.model.data_contract_specification import DataContractSpecification, Field, Model
 
@@ -34,7 +37,7 @@ class DbtManifestImporter(Importer):
         return import_dbt_manifest(
             data_contract_specification=data_contract_specification,
             manifest=manifest,
-            dbt_nodes=import_args.get("dbt_nodes", []),
+            dbt_nodes=import_args.get("dbt_model", []),
             resource_types=import_args.get("resource_types", ["model"]),
         )
 
@@ -43,7 +46,9 @@ def read_dbt_manifest(manifest_path: str) -> Manifest:
     """Read a manifest from file."""
     with open(file=manifest_path, mode="r", encoding="utf-8") as f:
         manifest_dict: dict = json.load(f)
-    return Manifest.from_dict(manifest_dict)
+    manifest = Manifest.from_dict(manifest_dict)
+    manifest.build_parent_and_child_maps()
+    return manifest
 
 
 def import_dbt_manifest(
@@ -58,7 +63,7 @@ def import_dbt_manifest(
     """
     data_contract_specification.info.title = manifest.metadata.project_name
     data_contract_specification.info.dbt_version = manifest.metadata.dbt_version
-
+    adapter_type = manifest.metadata.adapter_type
     data_contract_specification.models = data_contract_specification.models or {}
     for model_contents in manifest.nodes.values():
         # Only intressted in processing models.
@@ -73,7 +78,12 @@ def import_dbt_manifest(
         dc_model = Model(
             description=model_contents.description,
             tags=model_contents.tags,
-            fields=create_fields(columns=model_contents.columns),
+            fields=create_fields(
+                manifest,
+                model_unique_id=model_contents.unique_id,
+                columns=model_contents.columns,
+                adapter_type=adapter_type,
+            ),
         )
 
         data_contract_specification.models[model_contents.name] = dc_model
@@ -81,14 +91,68 @@ def import_dbt_manifest(
     return data_contract_specification
 
 
-def create_fields(columns: dict[str, ColumnInfo]) -> dict[str, Field]:
-    fields = {
-        column.name: Field(
-            description=column.description,
-            type=column.data_type if column.data_type else "",
-            tags=column.tags,
-        )
-        for column in columns.values()
-    }
+def convert_data_type_by_adapter_type(data_type: str, adapter_type: str) -> str:
+    if adapter_type == "bigquery":
+        return map_type_from_bigquery(data_type)
+    return data_type
+
 
+def create_fields(
+    manifest: Manifest, model_unique_id: str, columns: dict[str, ColumnInfo], adapter_type: str
+) -> dict[str, Field]:
+    fields = {column.name: create_field(manifest, model_unique_id, column, adapter_type) for column in columns.values()}
     return fields
+
+
+def get_column_tests(manifest: Manifest, model_name: str, column_name: str) -> list[dict[str, str]]:
+    column_tests = []
+    model_node = manifest.nodes.get(model_name)
+    if not model_node:
+        raise ValueError(f"Model {model_name} not found in manifest.")
+
+    model_unique_id = model_node.unique_id
+    test_ids = manifest.child_map.get(model_unique_id, [])
+
+    for test_id in test_ids:
+        test_node = manifest.nodes.get(test_id)
+        if not test_node or test_node.resource_type != "test":
+            continue
+
+        if not isinstance(test_node, GenericTestNode):
+            continue
+
+        if test_node.column_name != column_name:
+            continue
+
+        if test_node.config.where is not None:
+            continue
+
+        column_tests.append(
+            {
+                "test_name": test_node.name,
+                "test_type": test_node.test_metadata.name,
+                "column": test_node.column_name,
+            }
+        )
+    return column_tests
+
+
+def create_field(manifest: Manifest, model_unique_id: str, column: ColumnInfo, adapter_type: str) -> Field:
+    column_type = convert_data_type_by_adapter_type(column.data_type, adapter_type) if column.data_type else ""
+    field = Field(
+        description=column.description,
+        type=column_type,
+        tags=column.tags,
+    )
+
+    all_tests = get_column_tests(manifest, model_unique_id, column.name)
+
+    required = False
+    if any(constraint.type == ConstraintType.not_null for constraint in column.constraints):
+        required = True
+    if [test for test in all_tests if test["test_type"] == "not_null"]:
+        required = True
+    if required:
+        field.required = required
+
+    return field

datacontract/imports/iceberg_importer.py

@@ -42,8 +42,19 @@ def import_iceberg(
 
     model = Model(type="table", title=table_name)
 
+    # Iceberg identifier_fields aren't technically primary keys since Iceberg doesn't support primary keys,
+    # but they are close enough that we can probably treat them as primary keys on the conversion.
+    # ref: https://iceberg.apache.org/spec/#identifier-field-ids
+    # this code WILL NOT support finding nested primary key fields.
+    identifier_fields_ids = schema.identifier_field_ids
+
     for field in schema.fields:
-        model.fields[field.name] = _field_from_nested_field(field)
+        model_field = _field_from_nested_field(field)
+
+        if field.field_id in identifier_fields_ids:
+            model_field.primaryKey = True
+
+        model.fields[field.name] = model_field
 
     data_contract_specification.models[table_name] = model
     return data_contract_specification

datacontract/imports/odcs_v3_importer.py

@@ -14,6 +14,7 @@ from datacontract.model.data_contract_specification import (
     Field,
     Info,
     Model,
+    Quality,
     Retention,
     Server,
     ServiceLevel,
@@ -193,6 +194,10 @@ def import_models(odcs_contract: Dict[str, Any]) -> Dict[str, Model]:
         model.fields = import_fields(
             odcs_schema.get("properties"), custom_type_mappings, server_type=get_server_type(odcs_contract)
         )
+        if odcs_schema.get("quality") is not None:
+            # convert dict to pydantic model
+
+            model.quality = [Quality.model_validate(q) for q in odcs_schema.get("quality")]
         model.title = schema_name
         if odcs_schema.get("dataGranularityDescription") is not None:
             model.config = {"dataGranularityDescription": odcs_schema.get("dataGranularityDescription")}

datacontract/lint/resolve.py

@@ -9,7 +9,11 @@ from datacontract.imports.odcs_v3_importer import import_odcs_v3_from_str
 from datacontract.lint.resources import read_resource
 from datacontract.lint.schema import fetch_schema
 from datacontract.lint.urls import fetch_resource
-from datacontract.model.data_contract_specification import DataContractSpecification, Definition, Quality
+from datacontract.model.data_contract_specification import (
+    DataContractSpecification,
+    Definition,
+    DeprecatedQuality,
+)
 from datacontract.model.exceptions import DataContractException
 from datacontract.model.odcs import is_open_data_contract_standard
 
@@ -156,7 +160,7 @@ def _fetch_file(path) -> str:
         return file.read()
 
 
-def _resolve_quality_ref(quality: Quality):
+def _resolve_quality_ref(quality: DeprecatedQuality):
     """
     Return the content of a ref file path
     @param quality data contract quality specification

datacontract/model/data_contract_specification.py

@@ -214,7 +214,8 @@ class Example(pyd.BaseModel):
     data: str | object = None
 
 
-class Quality(pyd.BaseModel):
+# Deprecated Quality class
+class DeprecatedQuality(pyd.BaseModel):
     type: str = None
     specification: str | object = None
 
@@ -287,7 +288,7 @@ class DataContractSpecification(pyd.BaseModel):
         default_factory=list,
         deprecated="Removed in Data Contract Specification " "v1.1.0. Use models.examples instead.",
     )
-    quality: Quality = pyd.Field(
+    quality: DeprecatedQuality = pyd.Field(
         default=None,
         deprecated="Removed in Data Contract Specification v1.1.0. Use " "model-level and field-level quality instead.",
     )

{datacontract_cli-0.10.15.dist-info → datacontract_cli-0.10.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: datacontract-cli
-Version: 0.10.15
+Version: 0.10.16
 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>
 Project-URL: Homepage, https://cli.datacontract.com
@@ -11,15 +11,15 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: typer<0.14,>=0.12
-Requires-Dist: pydantic<2.10.0,>=2.8.2
+Requires-Dist: typer<0.15,>=0.12
+Requires-Dist: pydantic<2.11.0,>=2.8.2
 Requires-Dist: pyyaml~=6.0.1
 Requires-Dist: requests<2.33,>=2.31
-Requires-Dist: fastapi==0.115.5
+Requires-Dist: fastapi==0.115.6
 Requires-Dist: uvicorn==0.32.1
-Requires-Dist: fastjsonschema<2.21.0,>=2.19.1
-Requires-Dist: fastparquet==2024.5.0
-Requires-Dist: python-multipart==0.0.12
+Requires-Dist: fastjsonschema<2.22.0,>=2.19.1
+Requires-Dist: fastparquet==2024.11.0
+Requires-Dist: python-multipart==0.0.19
 Requires-Dist: rich<13.10,>=13.7
 Requires-Dist: simple-ddl-parser==1.7.1
 Requires-Dist: duckdb==1.1.2
@@ -41,7 +41,7 @@ Requires-Dist: databricks-sql-connector<3.6.0,>=3.1.2; extra == "databricks"
 Requires-Dist: databricks-sdk<0.39.0,>=0.32.0; extra == "databricks"
 Requires-Dist: soda-core-spark[databricks]<3.5.0,>=3.3.1; extra == "databricks"
 Provides-Extra: iceberg
-Requires-Dist: pyiceberg==0.7.1; extra == "iceberg"
+Requires-Dist: pyiceberg==0.8.1; extra == "iceberg"
 Provides-Extra: kafka
 Requires-Dist: datacontract-cli[avro]; extra == "kafka"
 Requires-Dist: soda-core-spark-df<3.5.0,>=3.3.1; extra == "kafka"
@@ -66,16 +66,16 @@ Provides-Extra: all
 Requires-Dist: datacontract-cli[bigquery,databricks,dbml,dbt,iceberg,kafka,parquet,postgres,s3,snowflake,sqlserver,trino]; extra == "all"
 Provides-Extra: dev
 Requires-Dist: datacontract-cli[all]; extra == "dev"
-Requires-Dist: httpx==0.27.2; extra == "dev"
+Requires-Dist: httpx==0.28.1; extra == "dev"
 Requires-Dist: kafka-python; extra == "dev"
-Requires-Dist: moto==5.0.18; extra == "dev"
+Requires-Dist: moto==5.0.22; extra == "dev"
 Requires-Dist: pandas>=2.1.0; extra == "dev"
 Requires-Dist: pre-commit<4.1.0,>=3.7.1; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-xdist; extra == "dev"
-Requires-Dist: pymssql==2.3.1; extra == "dev"
+Requires-Dist: pymssql==2.3.2; extra == "dev"
 Requires-Dist: ruff; extra == "dev"
-Requires-Dist: testcontainers[kafka,minio,mssql,postgres]==4.8.2; extra == "dev"
+Requires-Dist: testcontainers[kafka,minio,mssql,postgres]==4.9.0; extra == "dev"
 Requires-Dist: trino==0.330.0; extra == "dev"
 
 # Data Contract CLI
@@ -841,7 +841,7 @@ models:
 │                    t-staging-sql|odcs|odcs_v2|odcs_v3|rdf|avro|protobuf                                                        │
 │                    |great-expectations|terraform|avro-idl|sql|sql-query                                                        │
 │                    |html|go|bigquery|dbml|spark|sqlalchemy|data-caterer                                                        │
-│                    |dcs]                                                                                                       │
+│                    |dcs|iceberg]                                                                                                       │
 │    --output        PATH                                                  Specify the file path where the exported data will be │
 │                                                                          saved. If no path is provided, the output will be     │
 │                                                                          printed to stdout.                                    │
@@ -902,6 +902,7 @@ Available export options:
 | `sqlalchemy`         | Export to SQLAlchemy Models                             | ✅      |
 | `data-caterer`       | Export to Data Caterer in YAML format                   | ✅      |
 | `dcs`                | Export to Data Contract Specification in YAML format    | ✅      |
+| `iceberg`            | Export to an Iceberg JSON Schema Definition             | partial |
 | Missing something?   | Please create an issue on GitHub                        | TBD    |
 
 
@@ -1025,6 +1026,63 @@ models:
     - **avroLogicalType**: Specifies the logical type of the field in Avro. In this example, it is `local-timestamp-micros`.
     - **avroDefault**: Specifies the default value for the field in Avro. In this example, it is 1672534861000000 which corresponds to ` 2023-01-01 01:01:01 UTC`.
 
+#### Iceberg
+
+Exports to an [Iceberg Table Json Schema Definition](https://iceberg.apache.org/spec/#appendix-c-json-serialization).
+
+This export only supports a single model export at a time because Iceberg's schema definition is for a single table and the exporter maps 1 model to 1 table, use the `--model` flag
+to limit your contract export to a single model.
+
+```bash
+ $ datacontract export --format iceberg --model orders https://datacontract.com/examples/orders-latest/datacontract.yaml --output /tmp/orders_iceberg.json
+ 
+ $ cat /tmp/orders_iceberg.json | jq '.'
+{
+  "type": "struct",
+  "fields": [
+    {
+      "id": 1,
+      "name": "order_id",
+      "type": "string",
+      "required": true
+    },
+    {
+      "id": 2,
+      "name": "order_timestamp",
+      "type": "timestamptz",
+      "required": true
+    },
+    {
+      "id": 3,
+      "name": "order_total",
+      "type": "long",
+      "required": true
+    },
+    {
+      "id": 4,
+      "name": "customer_id",
+      "type": "string",
+      "required": false
+    },
+    {
+      "id": 5,
+      "name": "customer_email_address",
+      "type": "string",
+      "required": true
+    },
+    {
+      "id": 6,
+      "name": "processed_timestamp",
+      "type": "timestamptz",
+      "required": true
+    }
+  ],
+  "schema-id": 0,
+  "identifier-field-ids": [
+    1
+  ]
+}
+```
 
 ### import
 

{datacontract_cli-0.10.15.dist-info → datacontract_cli-0.10.16.dist-info}/RECORD

@@ -1,9 +1,9 @@
 datacontract/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-datacontract/cli.py,sha256=F3MKhqNMW0pFh0B54ik4DeMECWJANAQ1mEm5a7yAtSc,16506
+datacontract/cli.py,sha256=jGvN_VI0r_RzRWuiBsFSGTZlcoMHnJnTT5niBG9XMU8,16552
 datacontract/data_contract.py,sha256=rw9klvbIoaOwtBflpspqDeOXs3YY4qlQXsuOBROAJT0,14669
 datacontract/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 datacontract/web.py,sha256=MePB-XJvTZObMzrk3tIW8-bAvk-QcEEt767RVos3Zoc,2105
-datacontract/breaking/breaking.py,sha256=jCYKEH410p9E9MUi1UQJhtIQWjPEHqYy9dC8Z1viYnY,20398
+datacontract/breaking/breaking.py,sha256=vUjPZzGsOF_ufTjdKa2T_gjQgPtZrZKytmcatkUr7ck,20428
 datacontract/breaking/breaking_rules.py,sha256=OPCBtUHd5erAvsdC8KChTHIAItJ5GZZqwT2KXmuIA1A,3914
 datacontract/catalog/catalog.py,sha256=wmv_2BBxHhNBlilAmQHHhNe4tK14DowkyIOVaQW2DWU,2691
 datacontract/engines/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -12,7 +12,7 @@ datacontract/engines/datacontract/check_that_datacontract_file_exists.py,sha256=
 datacontract/engines/fastjsonschema/check_jsonschema.py,sha256=PxDvH2T2bUbS-V6euENfwTIa_R-CMTZFxiRnyxvOTp4,9820
 datacontract/engines/fastjsonschema/s3/s3_read_files.py,sha256=vuz_hLF2VD8LR_prjQpPLBU8Is-iHLAvqp4KwclOv9I,1157
 datacontract/engines/soda/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-datacontract/engines/soda/check_soda_execute.py,sha256=nDmbI2luc8u68PyfBL7eZqI_TK4EwDnKnwrhpeSQQQo,7869
+datacontract/engines/soda/check_soda_execute.py,sha256=x7bkLj1i1LwNlUtnRsW07UX6oCH3u7kL8bVEggE2koE,7889
 datacontract/engines/soda/connections/bigquery.py,sha256=C-8kxmzpYe88bJp80ObHFLMh4rpnIjnUQ7XOj0Ke7lk,903
 datacontract/engines/soda/connections/dask.py,sha256=Yy6Et2n_vDVsdjtqyBWDSZt7mnjPzPk_MZ-92VZHfnY,1496
 datacontract/engines/soda/connections/databricks.py,sha256=lpMju-o_TzLZeF0EEVwePPr8JahqvFnj5xRYjF15fc8,561
@@ -29,21 +29,22 @@ datacontract/export/bigquery_converter.py,sha256=VSBdVGWrlar18ETzgNArxDzk8Zt5JcA
 datacontract/export/csv_type_converter.py,sha256=ZZuJwBgQnafZC7PPvAXsBf2IajPJq8TYZ1l8Qq0GYeI,1290
 datacontract/export/data_caterer_converter.py,sha256=MYUhoRjKSTpQFUZjc0CG6daPRpvm5j51wS0NUTSzQNU,5324
 datacontract/export/dbml_converter.py,sha256=Tqsjicvh-NyEnpfn2Lnrpbhn9SQBD8uGlZY6Sb0VBV8,4737
-datacontract/export/dbt_converter.py,sha256=0i6EPOdAnzQgV7MtQxHjxZlM4CdgJI3iygG9BvPuuy8,9389
+datacontract/export/dbt_converter.py,sha256=mcmNb7764oe2MUM5VaN_bD1ZblH2PienGVGi7MuXdBY,9646
 datacontract/export/dcs_exporter.py,sha256=RALQ7bLAjak7EsoFFL2GFX2Oju7pnCDPCdRN_wo9wHM,210
-datacontract/export/exporter.py,sha256=62ZO4Sn0V_QCxoShvjqZOBx2q0JLrsvoSfx37JhS2IQ,2979
-datacontract/export/exporter_factory.py,sha256=cdygE42dQeXik1rk0BZ8RbsjJwEJcMDFjgkRT9hn434,5569
+datacontract/export/exporter.py,sha256=TOwqV6NG0i87q-cm1WuyywWUsh5Gnc8gzAU857FeKYU,3003
+datacontract/export/exporter_factory.py,sha256=vUXXZqek0mblw7MRMmoBtW0wACIFHncMOS-bGsfnAUU,5726
 datacontract/export/go_converter.py,sha256=Ttvbfu3YU-3GBwRD6nwCsFyZuc_hiIvJD-Jg2sT5WLw,3331
 datacontract/export/great_expectations_converter.py,sha256=zMaHaj5DLj_Q_q-iFEa7EZHW-qHdFMxWL4MiMIFKV80,10505
 datacontract/export/html_export.py,sha256=ojazWrb0AwSc7Vr72M_otMo-3PA8mfi8tfIy9BCXk9o,2578
+datacontract/export/iceberg_converter.py,sha256=g18yJyExCVkzn8hR0dOOJt-h54cBSntrndUsPXqKeMA,6780
 datacontract/export/jsonschema_converter.py,sha256=2MT82MurcQQbrVDRj1kFsxnmFd9scNSfYI1upQSecl4,5631
 datacontract/export/odcs_v2_exporter.py,sha256=0nMI-zTENNs94bllm_Qv3V-8-QyS8jnBW1Be9fEJCmU,4679
-datacontract/export/odcs_v3_exporter.py,sha256=C1Ax4BYeIu_uet_gYYws-sZanE_voGLiuKNHHRjQaV4,12093
+datacontract/export/odcs_v3_exporter.py,sha256=cGBPTq7FchvYE-PmPcWQdU_iaU1jnVqFUKvJgAnzS3M,12249
 datacontract/export/pandas_type_converter.py,sha256=464pQ3JQKFQa1TO0HBNcEoZvQye_yUbY6jQtiBaphSc,1117
 datacontract/export/protobuf_converter.py,sha256=9K0fzBGbqlj9AhQumw2oq53hyn_QDCT3UlyH2uXJdC0,3192
 datacontract/export/pydantic_converter.py,sha256=1Lt9F8i6zyQYb44MyQtsXwCWWXYxZ47SmzArr_uPqsU,5579
 datacontract/export/rdf_converter.py,sha256=4gnKus37Geth4MJ3Ruc8AbnpD_Ll9OCx8oTIEKScvh8,6435
-datacontract/export/sodacl_converter.py,sha256=zLfQ2VVWYIcvpja3-amMeqUPtfaioX14-skhPteu3vc,10600
+datacontract/export/sodacl_converter.py,sha256=P-ZabX8beqksr33H3S-Plpq-6A5YmDB1Oss91kYA7Jo,10717
 datacontract/export/spark_converter.py,sha256=-6P2_VRFqGfSF7n_lJcD-fuY9Pv8qoH-ud6g8Zimpz4,7190
 datacontract/export/sql_converter.py,sha256=trQV5M76rZ4EpGj-0jkzr9PhGDmMC_RaxDFIAmx1BaQ,4801
 datacontract/export/sql_type_converter.py,sha256=MGTH1hXC90TLMEap1v_Fkahf4N6Ju8yf01pCT7wJrpg,11984
@@ -52,15 +53,15 @@ datacontract/export/terraform_converter.py,sha256=ExFoEvErVk-gBnWJiqC38SxDUmUEyd
 datacontract/imports/avro_importer.py,sha256=hpGvO6uv2zcupJC8-wC-c-vbjNb83IQ560a5F3MsEFA,9937
 datacontract/imports/bigquery_importer.py,sha256=7TcP9FDsIas5LwJZ-HrOPXZ-NuR056sxLfDDh3vjo8E,8419
 datacontract/imports/dbml_importer.py,sha256=PhEurAkqPerX1FR6zsks8RsMUpJJWWJojn2Msmcm60Y,3869
-datacontract/imports/dbt_importer.py,sha256=kzQsm_HrKybTr4SSyhZ5n9dHPbd9mg9ojdkRChywM0g,3237
+datacontract/imports/dbt_importer.py,sha256=FzG61jUzCRqsVzQPTwCW4AsgbJ3N5YpxzPXH6Jml1qo,5550
 datacontract/imports/glue_importer.py,sha256=fiJPkvfwOCsaKKCGW19-JM5CCGXZ2mkNrVtUzp2iw6g,8370
-datacontract/imports/iceberg_importer.py,sha256=OFSUgjWn3LQ9QKSAJprIKXAh8CLdKAR6U7QC8KB6fcE,5396
+datacontract/imports/iceberg_importer.py,sha256=vadGJVqQKgG-j8swUytZALFB8QjbGRqZPCcPcCy0vco,5923
 datacontract/imports/importer.py,sha256=oi_cybcOimEZ4Wc4EJW_2OQoAyErbadPo0foHdVeOmE,860
 datacontract/imports/importer_factory.py,sha256=QBW2tIuQ5Do56-Gtyh7fWLELcCeItYbK2FYq89K5oLw,3486
 datacontract/imports/jsonschema_importer.py,sha256=67H__XLugV4vguHrIqzW02dtx27zYTWnOms4D1ma3bk,4961
 datacontract/imports/odcs_importer.py,sha256=w1TumifVSDgSwsxWV2VmbdzHkb_3vNBKt6mEVE-P284,2042
 datacontract/imports/odcs_v2_importer.py,sha256=s6-WjEToeTvHxSCdkEsiPVGz7ZPahtVY90z7c56SI7A,7151
-datacontract/imports/odcs_v3_importer.py,sha256=TXutHthpl7DvMCS-HZ49Pvs1HKRLT_VWquXaXB8xIR8,12814
+datacontract/imports/odcs_v3_importer.py,sha256=1g3eqR5yR0VpW9XveMxDolk97HGlqc9RylEtDlP68ec,13016
 datacontract/imports/parquet_importer.py,sha256=W_0_16mX4stwDUt4GM2L7dnGmTpAySab5k13-OlTCCc,3095
 datacontract/imports/spark_importer.py,sha256=h2na1YtdJYu9Oz07tSvwx8L4RX6aLCCDVkAv-RTKyVA,5100
 datacontract/imports/sql_importer.py,sha256=0zZ7eHXg7xj843DZ14FBgUg2vzdJvP2he2ThSoaDtko,2890
@@ -70,7 +71,7 @@ datacontract/integration/datamesh_manager.py,sha256=RWIrOKXtyeiDSTRthsLOXV1PxTEX
 datacontract/integration/opentelemetry.py,sha256=oTIhP066qM2By9Evttq9LDUgFq3sr8In0ENdS1TIsz4,3827
 datacontract/lint/files.py,sha256=tg0vq_w4LQsEr_8A5qr4hUJmHeGalUpsXJXC1t-OGC0,471
 datacontract/lint/lint.py,sha256=Ew0n3ooXxmCVnUxJ_cDoacsD82QdMZYnKrxnG9J0sWQ,5077
-datacontract/lint/resolve.py,sha256=fzHcz5UolXvleSWJfctjvl4wGNTIgOuw9nz8gCLTtGM,9607
+datacontract/lint/resolve.py,sha256=32nlwY_Z3W0X8IffVypbVMyh8b9xnDpf_kpSHkPUjeA,9644
 datacontract/lint/resources.py,sha256=nfeZmORh1aP7EKpMKCmfbS04Te8pQ0nz64vJVkHOq3c,647
 datacontract/lint/schema.py,sha256=W7MJWWQk0qxtp5q4X3waDKUnGJVXVMBkbxXDG-A1-aw,1469
 datacontract/lint/urls.py,sha256=W7Edcd8Iw4NjokVtuSshEfzsXshQpuh_tpO73aM9dsM,2294
@@ -83,7 +84,7 @@ datacontract/lint/linters/notice_period_linter.py,sha256=6r413aEVOVHWJHb33-68ecV
 datacontract/lint/linters/quality_schema_linter.py,sha256=ZXFHlMLFV1GZejizbUdfW6-msffFECoDGNsdynaPnog,2182
 datacontract/lint/linters/valid_constraints_linter.py,sha256=qTFh1X3I9wOtAxuXlvbGesCQ3GQ6iWc-MT_ttIybRsw,4916
 datacontract/model/breaking_change.py,sha256=BIDEUo1U2CQLVT2-I5PyFttxAj6zQPI1UUkEoOOQXMY,2249
-datacontract/model/data_contract_specification.py,sha256=O5nraoORyUwEx-HZeBcVaBna3ZtfhFTV2Z_-U7vaE8g,7733
+datacontract/model/data_contract_specification.py,sha256=l94jYsC37aLpjASnMr8gzlPoDpUkdrVV-4hrQ_C9Lms,7780
 datacontract/model/exceptions.py,sha256=zW9NoyzwsND-c9UqgyTVuezUVGEc6KK1Uc2zl12loyo,1178
 datacontract/model/odcs.py,sha256=9PXwm72FASjNwteF1Jn591iP3-St0aq16Cpsk0PkEW8,389
 datacontract/model/run.py,sha256=NMPCSwjnICOjEycgYDgBUUXoj8lWfFp2DVxotzOvWv8,2809
@@ -97,9 +98,9 @@ datacontract/templates/partials/example.html,sha256=F1dWbHDIXQScgfs4OVgqM1lR4uV4
 datacontract/templates/partials/model_field.html,sha256=kh_ZIqJuayyxN-zDNIUPIoXOZeehGxXQxiImYB6G5qY,6946
 datacontract/templates/partials/server.html,sha256=WkWFbz1ZvhIAUQQhH5Lkwb0HZRW907ehEnFmJSkpquQ,6235
 datacontract/templates/style/output.css,sha256=F3oEhUpuv8kA_dWr4pJymBS_Ju6huIIZdLMkJzPzMmU,25647
-datacontract_cli-0.10.15.dist-info/LICENSE,sha256=23h64qnSeIZ0DKeziWAKC-zBCt328iSbRbWBrXoYRb4,2210
-datacontract_cli-0.10.15.dist-info/METADATA,sha256=Bj38D_3c0H1jVgDCweF0Poalj5iuFE5y3Xq7GJIEQ_I,95349
-datacontract_cli-0.10.15.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-datacontract_cli-0.10.15.dist-info/entry_points.txt,sha256=D3Eqy4q_Z6bHauGd4ppIyQglwbrm1AJnLau4Ppbw9Is,54
-datacontract_cli-0.10.15.dist-info/top_level.txt,sha256=VIRjd8EIUrBYWjEXJJjtdUgc0UAJdPZjmLiOR8BRBYM,13
-datacontract_cli-0.10.15.dist-info/RECORD,,
+datacontract_cli-0.10.16.dist-info/LICENSE,sha256=23h64qnSeIZ0DKeziWAKC-zBCt328iSbRbWBrXoYRb4,2210
+datacontract_cli-0.10.16.dist-info/METADATA,sha256=WsfUvT7wlIdpGUaP0I6QI9c7cREhUVlvQkx4klCcDeg,96776
+datacontract_cli-0.10.16.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+datacontract_cli-0.10.16.dist-info/entry_points.txt,sha256=D3Eqy4q_Z6bHauGd4ppIyQglwbrm1AJnLau4Ppbw9Is,54
+datacontract_cli-0.10.16.dist-info/top_level.txt,sha256=VIRjd8EIUrBYWjEXJJjtdUgc0UAJdPZjmLiOR8BRBYM,13
+datacontract_cli-0.10.16.dist-info/RECORD,,