datacontract-cli 0.10.12__py3-none-any.whl → 0.10.14__py3-none-any.whl

datacontract/imports/odcs_v3_importer.py

@@ -0,0 +1,309 @@
+import datetime
+import logging
+from typing import Any, Dict, List
+from venv import logger
+
+import yaml
+
+from datacontract.imports.importer import Importer
+from datacontract.lint.resources import read_resource
+from datacontract.model.data_contract_specification import (
+    Availability,
+    DataContractSpecification,
+    Info,
+    Model,
+    Field,
+    Retention,
+    Server,
+    ServiceLevel,
+    Terms,
+    DATACONTRACT_TYPES,
+)
+from datacontract.model.exceptions import DataContractException
+
+
+class OdcsImporter(Importer):
+    def import_source(
+        self, data_contract_specification: DataContractSpecification, source: str, import_args: dict
+    ) -> DataContractSpecification:
+        return import_odcs_v3(data_contract_specification, source)
+
+
+def import_odcs_v3(data_contract_specification: DataContractSpecification, source: str) -> DataContractSpecification:
+    source_str = read_resource(source)
+    return import_odcs_v3_from_str(data_contract_specification, source_str)
+
+
+def import_odcs_v3_from_str(
+    data_contract_specification: DataContractSpecification, source_str: str
+) -> DataContractSpecification:
+    try:
+        odcs_contract = yaml.safe_load(source_str)
+    except Exception as e:
+        raise DataContractException(
+            type="schema",
+            name="Parse ODCS contract",
+            reason=f"Failed to parse odcs contract from {source_str}",
+            engine="datacontract",
+            original_exception=e,
+        )
+
+    data_contract_specification.id = odcs_contract["id"]
+    data_contract_specification.info = import_info(odcs_contract)
+    data_contract_specification.servers = import_servers(odcs_contract)
+    data_contract_specification.terms = import_terms(odcs_contract)
+    data_contract_specification.servicelevels = import_servicelevels(odcs_contract)
+    data_contract_specification.models = import_models(odcs_contract)
+    data_contract_specification.tags = import_tags(odcs_contract)
+
+    return data_contract_specification
+
+
+def import_info(odcs_contract: Dict[str, Any]) -> Info:
+    info = Info()
+
+    info.title = odcs_contract.get("name") if odcs_contract.get("name") is not None else ""
+
+    if odcs_contract.get("version") is not None:
+        info.version = odcs_contract.get("version")
+
+    # odcs.description.purpose => datacontract.description
+    if odcs_contract.get("description") is not None and odcs_contract.get("description").get("purpose") is not None:
+        info.description = odcs_contract.get("description").get("purpose")
+
+    # odcs.domain => datacontract.owner
+    if odcs_contract.get("domain") is not None:
+        info.owner = odcs_contract.get("domain")
+
+    # add dataProduct as custom property
+    if odcs_contract.get("dataProduct") is not None:
+        info.dataProduct = odcs_contract.get("dataProduct")
+
+    # add tenant as custom property
+    if odcs_contract.get("tenant") is not None:
+        info.tenant = odcs_contract.get("tenant")
+
+    return info
+
+
+def import_servers(odcs_contract: Dict[str, Any]) -> Dict[str, Server] | None:
+    if odcs_contract.get("servers") is None:
+        return None
+    servers = {}
+    for odcs_server in odcs_contract.get("servers"):
+        server_name = odcs_server.get("server")
+        if server_name is None:
+            logger.warning("Server name is missing, skipping server")
+            continue
+
+        server = Server()
+        server.type = odcs_server.get("type")
+        server.description = odcs_server.get("description")
+        server.environment = odcs_server.get("environment")
+        server.format = odcs_server.get("format")
+        server.project = odcs_server.get("project")
+        server.dataset = odcs_server.get("dataset")
+        server.path = odcs_server.get("path")
+        server.delimiter = odcs_server.get("delimiter")
+        server.endpointUrl = odcs_server.get("endpointUrl")
+        server.location = odcs_server.get("location")
+        server.account = odcs_server.get("account")
+        server.database = odcs_server.get("database")
+        server.schema_ = odcs_server.get("schema")
+        server.host = odcs_server.get("host")
+        server.port = odcs_server.get("port")
+        server.catalog = odcs_server.get("catalog")
+        server.topic = odcs_server.get("topic")
+        server.http_path = odcs_server.get("http_path")
+        server.token = odcs_server.get("token")
+        server.dataProductId = odcs_server.get("dataProductId")
+        server.outputPortId = odcs_server.get("outputPortId")
+        server.driver = odcs_server.get("driver")
+        server.roles = odcs_server.get("roles")
+
+        servers[server_name] = server
+    return servers
+
+
+def import_terms(odcs_contract: Dict[str, Any]) -> Terms | None:
+    if odcs_contract.get("description") is None:
+        return None
+    if (
+        odcs_contract.get("description").get("usage") is not None
+        or odcs_contract.get("description").get("limitations") is not None
+        or odcs_contract.get("price") is not None
+    ):
+        terms = Terms()
+        if odcs_contract.get("description").get("usage") is not None:
+            terms.usage = odcs_contract.get("description").get("usage")
+        if odcs_contract.get("description").get("limitations") is not None:
+            terms.limitations = odcs_contract.get("description").get("limitations")
+        if odcs_contract.get("price") is not None:
+            terms.billing = f"{odcs_contract.get('price').get('priceAmount')} {odcs_contract.get('price').get('priceCurrency')} / {odcs_contract.get('price').get('priceUnit')}"
+
+        return terms
+    else:
+        return None
+
+
+def import_servicelevels(odcs_contract: Dict[str, Any]) -> ServiceLevel:
+    # find the two properties we can map (based on the examples)
+    sla_properties = odcs_contract.get("slaProperties") if odcs_contract.get("slaProperties") is not None else []
+    availability = next((p for p in sla_properties if p["property"] == "generalAvailability"), None)
+    retention = next((p for p in sla_properties if p["property"] == "retention"), None)
+
+    if availability is not None or retention is not None:
+        servicelevel = ServiceLevel()
+
+        if availability is not None:
+            value = availability.get("value")
+            if isinstance(value, datetime.datetime):
+                value = value.isoformat()
+            servicelevel.availability = Availability(description=value)
+
+        if retention is not None:
+            servicelevel.retention = Retention(period=f"{retention.get('value')}{retention.get('unit')}")
+
+        return servicelevel
+    else:
+        return None
+
+
+def get_server_type(odcs_contract: Dict[str, Any]) -> str | None:
+    servers = import_servers(odcs_contract)
+    if servers is None or len(servers) == 0:
+        return None
+    # get first server from map
+    server = next(iter(servers.values()))
+    return server.type
+
+
+def import_models(odcs_contract: Dict[str, Any]) -> Dict[str, Model]:
+    custom_type_mappings = get_custom_type_mappings(odcs_contract.get("customProperties"))
+
+    odcs_schemas = odcs_contract.get("schema") if odcs_contract.get("schema") is not None else []
+    result = {}
+
+    for odcs_schema in odcs_schemas:
+        schema_name = odcs_schema.get("name")
+        schema_physical_name = odcs_schema.get("physicalName")
+        schema_description = odcs_schema.get("description") if odcs_schema.get("description") is not None else ""
+        model_name = schema_physical_name if schema_physical_name is not None else schema_name
+        model = Model(description=" ".join(schema_description.splitlines()), type="table")
+        model.fields = import_fields(
+            odcs_schema.get("properties"), custom_type_mappings, server_type=get_server_type(odcs_contract)
+        )
+        model.title = schema_name
+        if odcs_schema.get("dataGranularityDescription") is not None:
+            model.config = {"dataGranularityDescription": odcs_schema.get("dataGranularityDescription")}
+        result[model_name] = model
+
+    return result
+
+
+def import_field_config(odcs_property: Dict[str, Any], server_type=None) -> Dict[str, Any]:
+    config = {}
+    if odcs_property.get("criticalDataElement") is not None:
+        config["criticalDataElement"] = odcs_property.get("criticalDataElement")
+    if odcs_property.get("encryptedName") is not None:
+        config["encryptedName"] = odcs_property.get("encryptedName")
+    if odcs_property.get("partitionKeyPosition") is not None:
+        config["partitionKeyPosition"] = odcs_property.get("partitionKeyPosition")
+    if odcs_property.get("partitioned") is not None:
+        config["partitioned"] = odcs_property.get("partitioned")
+
+    if odcs_property.get("customProperties") is not None and isinstance(odcs_property.get("customProperties"), list):
+        for item in odcs_property.get("customProperties"):
+            config[item["property"]] = item["value"]
+
+    physical_type = odcs_property.get("physicalType")
+    if physical_type is not None:
+        if server_type == "postgres" or server_type == "postgresql":
+            config["postgresType"] = physical_type
+        elif server_type == "bigquery":
+            config["bigqueryType"] = physical_type
+        elif server_type == "snowflake":
+            config["snowflakeType"] = physical_type
+        elif server_type == "redshift":
+            config["redshiftType"] = physical_type
+        elif server_type == "sqlserver":
+            config["sqlserverType"] = physical_type
+        elif server_type == "databricksType":
+            config["databricksType"] = physical_type
+        else:
+            config["physicalType"] = physical_type
+
+    return config
+
+
+def has_composite_primary_key(odcs_properties) -> bool:
+    primary_keys = [prop for prop in odcs_properties if prop.get("primaryKey") is not None and prop.get("primaryKey")]
+    return len(primary_keys) > 1
+
+
+def import_fields(
+    odcs_properties: Dict[str, Any], custom_type_mappings: Dict[str, str], server_type
+) -> Dict[str, Field]:
+    logger = logging.getLogger(__name__)
+    result = {}
+
+    if odcs_properties is None:
+        return result
+
+    for odcs_property in odcs_properties:
+        mapped_type = map_type(odcs_property.get("logicalType"), custom_type_mappings)
+        if mapped_type is not None:
+            property_name = odcs_property["name"]
+            description = odcs_property.get("description") if odcs_property.get("description") is not None else None
+            field = Field(
+                description=" ".join(description.splitlines()) if description is not None else None,
+                type=mapped_type,
+                title=odcs_property.get("businessName"),
+                required=not odcs_property.get("nullable") if odcs_property.get("nullable") is not None else False,
+                primary=odcs_property.get("primaryKey")
+                if not has_composite_primary_key(odcs_properties) and odcs_property.get("primaryKey") is not None
+                else False,
+                unique=odcs_property.get("unique"),
+                examples=odcs_property.get("examples") if odcs_property.get("examples") is not None else None,
+                classification=odcs_property.get("classification")
+                if odcs_property.get("classification") is not None
+                else "",
+                tags=odcs_property.get("tags") if odcs_property.get("tags") is not None else None,
+                quality=odcs_property.get("quality") if odcs_property.get("quality") is not None else [],
+                config=import_field_config(odcs_property, server_type),
+            )
+            result[property_name] = field
+        else:
+            logger.info(
+                f"Can't map {odcs_property.get('column')} to the Datacontract Mapping types, as there is no equivalent or special mapping. Consider introducing a customProperty 'dc_mapping_{odcs_property.get('logicalName')}' that defines your expected type as the 'value'"
+            )
+
+    return result
+
+
+def map_type(odcs_type: str, custom_mappings: Dict[str, str]) -> str | None:
+    t = odcs_type.lower()
+    if t in DATACONTRACT_TYPES:
+        return t
+    elif custom_mappings.get(t) is not None:
+        return custom_mappings.get(t)
+    else:
+        return None
+
+
+def get_custom_type_mappings(odcs_custom_properties: List[Any]) -> Dict[str, str]:
+    result = {}
+    if odcs_custom_properties is not None:
+        for prop in odcs_custom_properties:
+            if prop["property"].startswith("dc_mapping_"):
+                odcs_type_name = prop["property"].substring(11)
+                datacontract_type = prop["value"]
+                result[odcs_type_name] = datacontract_type
+
+    return result
+
+
+def import_tags(odcs_contract) -> List[str] | None:
+    if odcs_contract.get("tags") is None:
+        return None
+    return odcs_contract.get("tags")

datacontract/imports/spark_importer.py

@@ -80,6 +80,8 @@ def _field_from_struct_type(spark_field: types.StructField) -> Field:
     """
     field = Field()
     field.required = not spark_field.nullable
+    field.description = spark_field.metadata.get("comment")
+
     return _type_from_data_type(field, spark_field.dataType)
 
 
@@ -121,7 +123,7 @@ def _data_type_from_spark(spark_type: types.DataType) -> str:
     """
     if isinstance(spark_type, types.StringType):
         return "string"
-    elif isinstance(spark_type, types.IntegerType):
+    elif isinstance(spark_type, (types.IntegerType, types.ShortType)):
         return "integer"
     elif isinstance(spark_type, types.LongType):
         return "long"
@@ -149,5 +151,7 @@ def _data_type_from_spark(spark_type: types.DataType) -> str:
         return "decimal"
     elif isinstance(spark_type, types.NullType):
         return "null"
+    elif isinstance(spark_type, types.VarcharType):
+        return "varchar"
     else:
         raise ValueError(f"Unsupported Spark type: {spark_type}")

datacontract/imports/unity_importer.py

@@ -1,17 +1,37 @@
 import json
-import requests
 import os
-import typing
+from typing import List, Optional
+
+from pyspark.sql import types
+from databricks.sdk import WorkspaceClient
+from databricks.sdk.service.catalog import TableInfo, ColumnInfo
 
 from datacontract.imports.importer import Importer
+from datacontract.imports.spark_importer import _field_from_struct_type
 from datacontract.model.data_contract_specification import DataContractSpecification, Model, Field
 from datacontract.model.exceptions import DataContractException
 
 
 class UnityImporter(Importer):
+    """
+    UnityImporter class for importing data contract specifications from Unity Catalog.
+    """
+
     def import_source(
         self, data_contract_specification: DataContractSpecification, source: str, import_args: dict
     ) -> DataContractSpecification:
+        """
+        Import data contract specification from a source.
+
+        :param data_contract_specification: The data contract specification to be imported.
+        :type data_contract_specification: DataContractSpecification
+        :param source: The source from which to import the data contract specification.
+        :type source: str
+        :param import_args: Additional arguments for the import process.
+        :type import_args: dict
+        :return: The imported data contract specification.
+        :rtype: DataContractSpecification
+        """
         if source is not None:
             data_contract_specification = import_unity_from_json(data_contract_specification, source)
         else:
@@ -24,9 +44,21 @@ class UnityImporter(Importer):
 def import_unity_from_json(
     data_contract_specification: DataContractSpecification, source: str
 ) -> DataContractSpecification:
+    """
+    Import data contract specification from a JSON file.
+
+    :param data_contract_specification: The data contract specification to be imported.
+    :type data_contract_specification: DataContractSpecification
+    :param source: The path to the JSON file.
+    :type source: str
+    :return: The imported data contract specification.
+    :rtype: DataContractSpecification
+    :raises DataContractException: If there is an error parsing the JSON file.
+    """
     try:
         with open(source, "r") as file:
-            unity_schema = json.loads(file.read())
+            json_contents = json.loads(file.read())
+            unity_schema = TableInfo.from_dict(json_contents)
     except json.JSONDecodeError as e:
         raise DataContractException(
             type="schema",
@@ -39,114 +71,103 @@ def import_unity_from_json(
 
 
 def import_unity_from_api(
-    data_contract_specification: DataContractSpecification, unity_table_full_name: typing.Optional[str] = None
+    data_contract_specification: DataContractSpecification, unity_table_full_name: Optional[str] = None
 ) -> DataContractSpecification:
-    databricks_instance = os.getenv("DATABRICKS_IMPORT_INSTANCE")
-    access_token = os.getenv("DATABRICKS_IMPORT_ACCESS_TOKEN")
-
-    if not databricks_instance or not access_token:
-        print("Missing environment variables for Databricks instance or access token.")
-        print("Both, $DATABRICKS_IMPORT_INSTANCE and $DATABRICKS_IMPORT_ACCESS_TOKEN must be set.")
-        exit(1)  # Exit if variables are not set
-
-    api_url = f"{databricks_instance}/api/2.1/unity-catalog/tables/{unity_table_full_name}"
-
-    headers = {"Authorization": f"Bearer {access_token}"}
-    response = requests.get(api_url, headers=headers)
-
-    if response.status_code != 200:
+    """
+    Import data contract specification from Unity Catalog API.
+
+    :param data_contract_specification: The data contract specification to be imported.
+    :type data_contract_specification: DataContractSpecification
+    :param unity_table_full_name: The full name of the Unity table.
+    :type unity_table_full_name: Optional[str]
+    :return: The imported data contract specification.
+    :rtype: DataContractSpecification
+    :raises DataContractException: If there is an error retrieving the schema from the API.
+    """
+    try:
+        workspace_client = WorkspaceClient()
+        unity_schema: TableInfo = workspace_client.tables.get(unity_table_full_name)
+    except Exception as e:
         raise DataContractException(
             type="schema",
             name="Retrieve unity catalog schema",
-            reason=f"Failed to retrieve unity catalog schema from databricks instance: {response.status_code} {response.text}",
+            reason=f"Failed to retrieve unity catalog schema from databricks profile: {os.getenv('DATABRICKS_CONFIG_PROFILE')}",
             engine="datacontract",
+            original_exception=e,
         )
 
-    convert_unity_schema(data_contract_specification, response.json())
+    convert_unity_schema(data_contract_specification, unity_schema)
 
     return data_contract_specification
 
 
 def convert_unity_schema(
-    data_contract_specification: DataContractSpecification, unity_schema: dict
+    data_contract_specification: DataContractSpecification, unity_schema: TableInfo
 ) -> DataContractSpecification:
+    """
+    Convert Unity schema to data contract specification.
+
+    :param data_contract_specification: The data contract specification to be converted.
+    :type data_contract_specification: DataContractSpecification
+    :param unity_schema: The Unity schema to be converted.
+    :type unity_schema: TableInfo
+    :return: The converted data contract specification.
+    :rtype: DataContractSpecification
+    """
     if data_contract_specification.models is None:
         data_contract_specification.models = {}
 
-    fields = import_table_fields(unity_schema.get("columns"))
+    fields = import_table_fields(unity_schema.columns)
 
-    table_id = unity_schema.get("table_id")
+    table_id = unity_schema.name or unity_schema.table_id
 
     data_contract_specification.models[table_id] = Model(fields=fields, type="table")
 
-    if unity_schema.get("name") is not None:
-        data_contract_specification.models[table_id].title = unity_schema.get("name")
+    if unity_schema.name:
+        data_contract_specification.models[table_id].title = unity_schema.name
+
+    if unity_schema.comment:
+        data_contract_specification.models[table_id].description = unity_schema.comment
 
     return data_contract_specification
 
 
-def import_table_fields(table_fields):
+def import_table_fields(columns: List[ColumnInfo]) -> dict[str, Field]:
+    """
+    Import table fields from Unity schema columns.
+
+    Here we are first converting the `ColumnInfo.type_json` to a Spark StructField object
+    so we can leave the complexity of the Spark field types to the Spark JSON schema parser,
+    then re-use the logic in `datacontract.imports.spark_importer` to convert the StructField
+    into a Field object.
+
+    :param columns: The list of Unity schema columns.
+    :type columns: List[ColumnInfo]
+    :return: A dictionary of imported fields.
+    :rtype: dict[str, Field]
+    """
     imported_fields = {}
-    for field in table_fields:
-        field_name = field.get("name")
-        imported_fields[field_name] = Field()
-        imported_fields[field_name].required = field.get("nullable") == "false"
-        imported_fields[field_name].description = field.get("comment")
-
-        # databricks api 2.1 specifies that type_name can be any of:
-        # BOOLEAN | BYTE | SHORT | INT | LONG | FLOAT | DOUBLE | DATE | TIMESTAMP | TIMESTAMP_NTZ | STRING
-        # | BINARY | DECIMAL | INTERVAL | ARRAY | STRUCT | MAP | CHAR | NULL | USER_DEFINED_TYPE | TABLE_TYPE
-        if field.get("type_name") in ["INTERVAL", "ARRAY", "STRUCT", "MAP", "USER_DEFINED_TYPE", "TABLE_TYPE"]:
-            # complex types are not supported, yet
-            raise DataContractException(
-                type="schema",
-                result="failed",
-                name="Map unity type to data contract type",
-                reason=f"type ${field.get('type_name')} is not supported yet for unity import",
-                engine="datacontract",
-            )
 
-        imported_fields[field_name].type = map_type_from_unity(field.get("type_name"))
+    for column in columns:
+        struct_field: types.StructField = _type_json_to_spark_field(column.type_json)
+        imported_fields[column.name] = _field_from_struct_type(struct_field)
 
     return imported_fields
 
 
-def map_type_from_unity(type_str: str):
-    if type_str == "BOOLEAN":
-        return "boolean"
-    elif type_str == "BYTE":
-        return "bytes"
-    elif type_str == "SHORT":
-        return "int"
-    elif type_str == "INT":
-        return "int"
-    elif type_str == "LONG":
-        return "long"
-    elif type_str == "FLOAT":
-        return "float"
-    elif type_str == "DOUBLE":
-        return "double"
-    elif type_str == "DATE":
-        return "date"
-    elif type_str == "TIMESTAMP":
-        return "timestamp"
-    elif type_str == "TIMESTAMP_NTZ":
-        return "timestamp_ntz"
-    elif type_str == "STRING":
-        return "string"
-    elif type_str == "BINARY":
-        return "bytes"
-    elif type_str == "DECIMAL":
-        return "decimal"
-    elif type_str == "CHAR":
-        return "varchar"
-    elif type_str == "NULL":
-        return "null"
-    else:
-        raise DataContractException(
-            type="schema",
-            result="failed",
-            name="Map unity type to data contract type",
-            reason=f"Unsupported type {type_str} in unity json definition.",
-            engine="datacontract",
-        )
+def _type_json_to_spark_field(type_json: str) -> types.StructField:
+    """
+    Parses a JSON string representing a Spark field and returns a StructField object.
+
+    The reason we do this is to leverage the Spark JSON schema parser to handle the
+    complexity of the Spark field types. The field `type_json` in the Unity API is
+    the output of a `StructField.jsonValue()` call.
+
+    :param type_json: The JSON string representing the Spark field.
+    :type type_json: str
+
+    :return: The StructField object.
+    :rtype: types.StructField
+    """
+    type_dict = json.loads(type_json)
+    return types.StructField.fromJson(type_dict)

datacontract/integration/datamesh_manager.py

@@ -23,7 +23,7 @@ def publish_test_results_to_datamesh_manager(run: Run, publish_url: str):
             )
 
         if run.dataContractId is None:
-            raise Exception("Cannot publish run results, as data contract ID is unknown")
+            raise Exception("Cannot publish run results for unknown data contract ID")
 
         headers = {"Content-Type": "application/json", "x-api-key": api_key}
         request_body = run.model_dump_json()

datacontract/lint/resolve.py

@@ -5,11 +5,13 @@ import fastjsonschema
 import yaml
 from fastjsonschema import JsonSchemaValueException
 
-from datacontract.lint.files import read_file
+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.exceptions import DataContractException
+from datacontract.model.odcs import is_open_data_contract_standard
 
 
 def resolve_data_contract(
@@ -41,10 +43,7 @@ def resolve_data_contract(
 def resolve_data_contract_from_location(
     location, schema_location: str = None, inline_definitions: bool = False, inline_quality: bool = False
 ) -> DataContractSpecification:
-    if location.startswith("http://") or location.startswith("https://"):
-        data_contract_str = fetch_resource(location)
-    else:
-        data_contract_str = read_file(location)
+    data_contract_str = read_resource(location)
     return _resolve_data_contract_from_str(data_contract_str, schema_location, inline_definitions, inline_quality)
 
 
@@ -114,7 +113,16 @@ def _resolve_definition_ref(ref, spec) -> Definition:
 
 def _find_by_path_in_spec(definition_path: str, spec: DataContractSpecification):
     path_elements = definition_path.split("/")
-    definition = spec.definitions[path_elements[2]]
+    definition_key = path_elements[2]
+    if definition_key not in spec.definitions:
+        raise DataContractException(
+            type="lint",
+            result="failed",
+            name="Check that data contract YAML is valid",
+            reason=f"Cannot resolve definition {definition_key}",
+            engine="datacontract",
+        )
+    definition = spec.definitions[definition_key]
     definition = _find_subfield_in_definition(definition, path_elements[3:])
     return definition
 
@@ -187,10 +195,16 @@ def _get_quality_ref_file(quality_spec: str | object) -> str | object:
 def _resolve_data_contract_from_str(
     data_contract_str, schema_location: str = None, inline_definitions: bool = False, inline_quality: bool = False
 ) -> DataContractSpecification:
-    data_contract_yaml_dict = _to_yaml(data_contract_str)
-    _validate(data_contract_yaml_dict, schema_location)
+    yaml_dict = _to_yaml(data_contract_str)
+
+    if is_open_data_contract_standard(yaml_dict):
+        # if ODCS, then validate the ODCS schema and import to DataContractSpecification directly
+        data_contract_specification = DataContractSpecification(dataContractSpecification="0.9.3")
+        return import_odcs_v3_from_str(data_contract_specification, source_str=data_contract_str)
 
-    spec = DataContractSpecification(**data_contract_yaml_dict)
+    _validate_data_contract_specification_schema(yaml_dict, schema_location)
+    data_contract_specification = yaml_dict
+    spec = DataContractSpecification(**data_contract_specification)
 
     if inline_definitions:
         inline_definitions_into_data_contract(spec)
@@ -215,7 +229,7 @@ def _to_yaml(data_contract_str):
         )
 
 
-def _validate(data_contract_yaml, schema_location: str = None):
+def _validate_data_contract_specification_schema(data_contract_yaml, schema_location: str = None):
     schema = fetch_schema(schema_location)
     try:
         fastjsonschema.validate(schema, data_contract_yaml)