datacontract-cli 0.10.23__py3-none-any.whl → 0.10.40__py3-none-any.whl

datacontract/imports/unity_importer.py

@@ -1,14 +1,14 @@
 import json
 import os
-from typing import List, Optional
+from typing import List
 
 from databricks.sdk import WorkspaceClient
 from databricks.sdk.service.catalog import ColumnInfo, TableInfo
-from pyspark.sql import types
+from open_data_contract_standard.model import OpenDataContractStandard
 
 from datacontract.imports.importer import Importer
-from datacontract.imports.spark_importer import _field_from_struct_type
-from datacontract.model.data_contract_specification import DataContractSpecification, Field, Model
+from datacontract.imports.sql_importer import map_type_from_sql, to_physical_type_key
+from datacontract.model.data_contract_specification import DataContractSpecification, Field, Model, Server
 from datacontract.model.exceptions import DataContractException
 
 
@@ -18,8 +18,11 @@ class UnityImporter(Importer):
     """
 
     def import_source(
-        self, data_contract_specification: DataContractSpecification, source: str, import_args: dict
-    ) -> DataContractSpecification:
+        self,
+        data_contract_specification: DataContractSpecification | OpenDataContractStandard,
+        source: str,
+        import_args: dict,
+    ) -> DataContractSpecification | OpenDataContractStandard:
         """
         Import data contract specification from a source.
 
@@ -35,15 +38,14 @@ class UnityImporter(Importer):
         if source is not None:
             data_contract_specification = import_unity_from_json(data_contract_specification, source)
         else:
-            data_contract_specification = import_unity_from_api(
-                data_contract_specification, import_args.get("unity_table_full_name")
-            )
+            unity_table_full_name_list = import_args.get("unity_table_full_name")
+            data_contract_specification = import_unity_from_api(data_contract_specification, unity_table_full_name_list)
         return data_contract_specification
 
 
 def import_unity_from_json(
-    data_contract_specification: DataContractSpecification, source: str
-) -> DataContractSpecification:
+    data_contract_specification: DataContractSpecification | OpenDataContractStandard, source: str
+) -> DataContractSpecification | OpenDataContractStandard:
     """
     Import data contract specification from a JSON file.
 
@@ -71,39 +73,71 @@ def import_unity_from_json(
 
 
 def import_unity_from_api(
-    data_contract_specification: DataContractSpecification, unity_table_full_name: Optional[str] = None
+    data_contract_specification: DataContractSpecification, unity_table_full_name_list: List[str] = None
 ) -> DataContractSpecification:
     """
     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]
+    :param unity_table_full_name_list: The full name of the Unity table.
+    :type unity_table_full_name_list: list[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)
+        # print(f"Retrieving Unity Catalog schema for table: {unity_table_full_name}")
+        profile = os.getenv("DATACONTRACT_DATABRICKS_PROFILE")
+        host, token = os.getenv("DATACONTRACT_DATABRICKS_SERVER_HOSTNAME"), os.getenv("DATACONTRACT_DATABRICKS_TOKEN")
+        # print(f"Databricks host: {host}, token: {'***' if token else 'not set'}")
+        exception = DataContractException(
+            type="configuration",
+            name="Databricks configuration",
+            reason="",
+            engine="datacontract",
+        )
+        if not profile and not host and not token:
+            reason = "Either DATACONTRACT_DATABRICKS_PROFILE or both DATACONTRACT_DATABRICKS_SERVER_HOSTNAME and DATACONTRACT_DATABRICKS_TOKEN environment variables must be set"
+            exception.reason = reason
+            raise exception
+        if token and not host:
+            reason = "DATACONTRACT_DATABRICKS_SERVER_HOSTNAME environment variable is not set"
+            exception.reason = reason
+            raise exception
+        if host and not token:
+            reason = "DATACONTRACT_DATABRICKS_TOKEN environment variable is not set"
+            exception.reason = reason
+            raise exception
+        workspace_client = WorkspaceClient(profile=profile) if profile else WorkspaceClient(host=host, token=token)
     except Exception as e:
         raise DataContractException(
             type="schema",
             name="Retrieve unity catalog schema",
-            reason=f"Failed to retrieve unity catalog schema from databricks profile: {os.getenv('DATABRICKS_CONFIG_PROFILE')}",
+            reason="Failed to connect to unity catalog schema",
             engine="datacontract",
             original_exception=e,
         )
 
-    convert_unity_schema(data_contract_specification, unity_schema)
+    for unity_table_full_name in unity_table_full_name_list:
+        try:
+            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"Unity table {unity_table_full_name} not found",
+                engine="datacontract",
+                original_exception=e,
+            )
+        data_contract_specification = convert_unity_schema(data_contract_specification, unity_schema)
 
     return data_contract_specification
 
 
 def convert_unity_schema(
-    data_contract_specification: DataContractSpecification, unity_schema: TableInfo
-) -> DataContractSpecification:
+    data_contract_specification: DataContractSpecification | OpenDataContractStandard, unity_schema: TableInfo
+) -> DataContractSpecification | OpenDataContractStandard:
     """
     Convert Unity schema to data contract specification.
 
@@ -117,6 +151,21 @@ def convert_unity_schema(
     if data_contract_specification.models is None:
         data_contract_specification.models = {}
 
+    if data_contract_specification.servers is None:
+        data_contract_specification.servers = {}
+
+    # Configure databricks server with catalog and schema from Unity table info
+    schema_name = unity_schema.schema_name
+    catalog_name = unity_schema.catalog_name
+    if catalog_name and schema_name:
+        server_name = "myserver"  # Default server name
+
+        data_contract_specification.servers[server_name] = Server(
+            type="databricks",
+            catalog=catalog_name,
+            schema=schema_name,
+        )
+
     fields = import_table_fields(unity_schema.columns)
 
     table_id = unity_schema.name or unity_schema.table_id
@@ -149,25 +198,22 @@ def import_table_fields(columns: List[ColumnInfo]) -> dict[str, Field]:
     imported_fields = {}
 
     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)
+        imported_fields[column.name] = _to_field(column)
 
     return imported_fields
 
 
-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)
+def _to_field(column: ColumnInfo) -> Field:
+    field = Field()
+    # The second condition evaluates for complex types (e.g. variant)
+    if column.type_name is not None or (column.type_name is None and column.type_text is not None):
+        sql_type = str(column.type_text)
+        field.type = map_type_from_sql(sql_type)
+    physical_type_key = to_physical_type_key("databricks")
+    field.config = {
+        physical_type_key: sql_type,
+    }
+    field.required = column.nullable is None or not column.nullable
+    field.description = column.comment if column.comment else None
+
+    return field

datacontract/init/init_template.py

@@ -3,7 +3,7 @@ import logging
 
 import requests
 
-DEFAULT_DATA_CONTRACT_INIT_TEMPLATE = "datacontract-1.1.0.init.yaml"
+DEFAULT_DATA_CONTRACT_INIT_TEMPLATE = "datacontract-1.2.1.init.yaml"
 
 
 def get_init_template(location: str = None) -> str:

datacontract/integration/entropy_data.py

@@ -0,0 +1,126 @@
+import os
+from urllib.parse import urlparse
+
+import requests
+
+from datacontract.model.run import Run
+
+# used to retrieve the HTML location of the published data contract or test results
+RESPONSE_HEADER_LOCATION_HTML = "location-html"
+
+
+def publish_test_results_to_entropy_data(run: Run, publish_url: str, ssl_verification: bool):
+    try:
+        host = publish_url
+        if publish_url is None:
+            # this url supports Data Mesh Manager and Data Contract Manager
+            host = _get_host()
+            url = "%s/api/test-results" % host
+        else:
+            url = publish_url
+
+        api_key = _get_api_key()
+
+        if run.dataContractId is None:
+            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()
+        # print("Request Body:", request_body)
+        response = requests.post(
+            url,
+            data=request_body,
+            headers=headers,
+            verify=ssl_verification,
+        )
+        # print("Status Code:", response.status_code)
+        # print("Response Body:", response.text)
+        if response.status_code != 200:
+            display_host = _extract_hostname(host)
+            run.log_error(f"Error publishing test results to {display_host}: {response.text}")
+            return
+        run.log_info("Published test results successfully")
+
+        location_html = response.headers.get(RESPONSE_HEADER_LOCATION_HTML)
+        if location_html is not None and len(location_html) > 0:
+            print(f"🚀 Open {location_html}")
+
+    except Exception as e:
+        run.log_error(f"Failed publishing test results. Error: {str(e)}")
+
+
+def publish_data_contract_to_entropy_data(data_contract_dict: dict, ssl_verification: bool):
+    try:
+        api_key = _get_api_key()
+        host = _get_host()
+        headers = {"Content-Type": "application/json", "x-api-key": api_key}
+        id = data_contract_dict["id"]
+        url = f"{host}/api/datacontracts/{id}"
+        response = requests.put(
+            url=url,
+            json=data_contract_dict,
+            headers=headers,
+            verify=ssl_verification,
+        )
+        if response.status_code != 200:
+            display_host = _extract_hostname(host)
+            print(f"Error publishing data contract to {display_host}: {response.text}")
+            exit(1)
+
+        print("✅ Published data contract successfully")
+
+        location_html = response.headers.get(RESPONSE_HEADER_LOCATION_HTML)
+        if location_html is not None and len(location_html) > 0:
+            print(f"🚀 Open {location_html}")
+
+    except Exception as e:
+        print(f"Failed publishing data contract. Error: {str(e)}")
+
+
+def _get_api_key() -> str:
+    """
+    Get API key from environment variables with fallback priority:
+    1. ENTROPY_DATA_API_KEY
+    2. DATAMESH_MANAGER_API_KEY
+    3. DATACONTRACT_MANAGER_API_KEY
+    """
+    api_key = os.getenv("ENTROPY_DATA_API_KEY")
+    if api_key is None:
+        api_key = os.getenv("DATAMESH_MANAGER_API_KEY")
+    if api_key is None:
+        api_key = os.getenv("DATACONTRACT_MANAGER_API_KEY")
+    if api_key is None:
+        raise Exception(
+            "Cannot publish, as neither ENTROPY_DATA_API_KEY, DATAMESH_MANAGER_API_KEY, nor DATACONTRACT_MANAGER_API_KEY is set"
+        )
+    return api_key
+
+
+def _get_host() -> str:
+    """
+    Get host from environment variables with fallback priority:
+    1. ENTROPY_DATA_HOST
+    2. DATAMESH_MANAGER_HOST
+    3. DATACONTRACT_MANAGER_HOST
+    4. Default: https://api.entropy-data.com
+    """
+    host = os.getenv("ENTROPY_DATA_HOST")
+    if host is None:
+        host = os.getenv("DATAMESH_MANAGER_HOST")
+    if host is None:
+        host = os.getenv("DATACONTRACT_MANAGER_HOST")
+    if host is None:
+        host = "https://api.entropy-data.com"
+    return host
+
+
+def _extract_hostname(url: str) -> str:
+    """
+    Extract the hostname (including subdomains and top-level domain) from a URL.
+
+    Examples:
+    - https://app.entropy-data.com/path -> app.entropy-data.com
+    - http://api.example.com:8080/api -> api.example.com
+    """
+    parsed = urlparse(url)
+    return parsed.netloc.split(":")[0] if parsed.netloc else url

datacontract/lint/resolve.py

@@ -1,11 +1,15 @@
+import importlib.resources as resources
 import logging
 import os
+import warnings
+from pathlib import Path
 
 import fastjsonschema
 import yaml
 from fastjsonschema import JsonSchemaValueException
+from open_data_contract_standard.model import OpenDataContractStandard
 
-from datacontract.imports.odcs_v3_importer import import_odcs_v3_from_str
+from datacontract.imports.odcs_v3_importer import import_from_odcs, parse_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
@@ -15,7 +19,8 @@ from datacontract.model.data_contract_specification import (
     DeprecatedQuality,
 )
 from datacontract.model.exceptions import DataContractException
-from datacontract.model.odcs import is_open_data_contract_standard
+from datacontract.model.odcs import is_open_data_contract_standard, is_open_data_product_standard
+from datacontract.model.run import ResultEnum
 
 
 def resolve_data_contract(
@@ -37,7 +42,35 @@ def resolve_data_contract(
     else:
         raise DataContractException(
             type="lint",
-            result="failed",
+            result=ResultEnum.failed,
+            name="Check that data contract YAML is valid",
+            reason="Data contract needs to be provided",
+            engine="datacontract",
+        )
+
+
+def resolve_data_contract_v2(
+    data_contract_location: str = None,
+    data_contract_str: str = None,
+    data_contract: DataContractSpecification | OpenDataContractStandard = None,
+    schema_location: str = None,
+    inline_definitions: bool = False,
+    inline_quality: bool = False,
+) -> DataContractSpecification | OpenDataContractStandard:
+    if data_contract_location is not None:
+        return resolve_data_contract_from_location_v2(
+            data_contract_location, schema_location, inline_definitions, inline_quality
+        )
+    elif data_contract_str is not None:
+        return _resolve_data_contract_from_str_v2(
+            data_contract_str, schema_location, inline_definitions, inline_quality
+        )
+    elif data_contract is not None:
+        return data_contract
+    else:
+        raise DataContractException(
+            type="lint",
+            result=ResultEnum.failed,
             name="Check that data contract YAML is valid",
             reason="Data contract needs to be provided",
             engine="datacontract",
@@ -58,13 +91,20 @@ def resolve_data_contract_dict(
     else:
         raise DataContractException(
             type="lint",
-            result="failed",
+            result=ResultEnum.failed,
             name="Check that data contract YAML is valid",
             reason="Data contract needs to be provided",
             engine="datacontract",
         )
 
 
+def resolve_data_contract_from_location_v2(
+    location, schema_location: str = None, inline_definitions: bool = False, inline_quality: bool = False
+) -> DataContractSpecification | OpenDataContractStandard:
+    data_contract_str = read_resource(location)
+    return _resolve_data_contract_from_str_v2(data_contract_str, schema_location, inline_definitions, inline_quality)
+
+
 def resolve_data_contract_from_location(
     location, schema_location: str = None, inline_definitions: bool = False, inline_quality: bool = False
 ) -> DataContractSpecification:
@@ -152,7 +192,7 @@ def _resolve_definition_ref(ref, spec) -> Definition:
     else:
         raise DataContractException(
             type="lint",
-            result="failed",
+            result=ResultEnum.failed,
             name="Check that data contract YAML is valid",
             reason=f"Cannot resolve reference {ref}",
             engine="datacontract",
@@ -165,7 +205,7 @@ def _find_by_path_in_spec(definition_path: str, spec: DataContractSpecification)
     if definition_key not in spec.definitions:
         raise DataContractException(
             type="lint",
-            result="failed",
+            result=ResultEnum.failed,
             name="Check that data contract YAML is valid",
             reason=f"Cannot resolve definition {definition_key}",
             engine="datacontract",
@@ -195,7 +235,7 @@ def _fetch_file(path) -> str:
     if not os.path.exists(path):
         raise DataContractException(
             type="export",
-            result="failed",
+            result=ResultEnum.failed,
             name="Check that data contract definition is valid",
             reason=f"Cannot resolve reference {path}",
             engine="datacontract",
@@ -230,7 +270,7 @@ def _get_quality_ref_file(quality_spec: str | object) -> str | object:
         if not os.path.exists(ref):
             raise DataContractException(
                 type="export",
-                result="failed",
+                result=ResultEnum.failed,
                 name="Check that data contract quality is valid",
                 reason=f"Cannot resolve reference {ref}",
                 engine="datacontract",
@@ -240,35 +280,83 @@ def _get_quality_ref_file(quality_spec: str | object) -> str | object:
     return quality_spec
 
 
+def _resolve_data_contract_from_str_v2(
+    data_contract_str, schema_location: str = None, inline_definitions: bool = False, inline_quality: bool = False
+) -> DataContractSpecification | OpenDataContractStandard:
+    yaml_dict = _to_yaml(data_contract_str)
+
+    if is_open_data_product_standard(yaml_dict):
+        logging.info("Cannot import ODPS, as not supported")
+        raise DataContractException(
+            type="schema",
+            result=ResultEnum.failed,
+            name="Parse ODCS contract",
+            reason="Cannot parse ODPS product",
+            engine="datacontract",
+        )
+
+    if is_open_data_contract_standard(yaml_dict):
+        logging.info("Importing ODCS v3")
+        # if ODCS, then validate the ODCS schema and import to DataContractSpecification directly
+        odcs = parse_odcs_v3_from_str(data_contract_str)
+        return odcs
+
+    logging.info("Importing DCS")
+    return _resolve_dcs_from_yaml_dict(inline_definitions, inline_quality, schema_location, yaml_dict)
+
+
 def _resolve_data_contract_from_str(
     data_contract_str, schema_location: str = None, inline_definitions: bool = False, inline_quality: bool = False
 ) -> DataContractSpecification:
     yaml_dict = _to_yaml(data_contract_str)
 
+    if schema_location is None:
+        if is_open_data_contract_standard(yaml_dict):
+            logging.info("Using ODCS 3.1.0 schema to validate data contract")
+            # TODO refactor this to a specific function
+            schema_location = resources.files("datacontract").joinpath("schemas", "odcs-3.1.0.schema.json")
+
+    _validate_json_schema(yaml_dict, schema_location)
+
     if is_open_data_contract_standard(yaml_dict):
         logging.info("Importing ODCS v3")
         # if ODCS, then validate the ODCS schema and import to DataContractSpecification directly
-        data_contract_specification = DataContractSpecification(dataContractSpecification="1.1.0")
-        return import_odcs_v3_from_str(data_contract_specification, source_str=data_contract_str)
-    else:
-        logging.info("Importing DCS")
+        odcs = parse_odcs_v3_from_str(data_contract_str)
+
+        data_contract_specification = DataContractSpecification(dataContractSpecification="1.2.1")
+        return import_from_odcs(data_contract_specification, odcs)
+
+    logging.info("Importing DCS")
+    return _resolve_dcs_from_yaml_dict(inline_definitions, inline_quality, schema_location, yaml_dict)
 
-    _validate_data_contract_specification_schema(yaml_dict, schema_location)
+
+def _resolve_dcs_from_yaml_dict(inline_definitions, inline_quality, schema_location, yaml_dict):
+    _validate_json_schema(yaml_dict, schema_location)
     data_contract_specification = yaml_dict
     spec = DataContractSpecification(**data_contract_specification)
-
     if inline_definitions:
         inline_definitions_into_data_contract(spec)
-    if spec.quality and inline_quality:
-        _resolve_quality_ref(spec.quality)
-
+    ## Suppress DeprecationWarning when accessing spec.quality,
+    ## iif it is in fact *not* used.
+    with warnings.catch_warnings(record=True) as recorded_warnings:
+        spec_quality = spec.quality
+    for w in recorded_warnings:
+        if not issubclass(w.category, DeprecationWarning) or spec_quality is not None:
+            warnings.warn_explicit(
+                message=w.message,
+                category=w.category,
+                filename=w.filename,
+                lineno=w.lineno,
+                source=w.source,
+            )
+    if spec_quality and inline_quality:
+        _resolve_quality_ref(spec_quality)
     return spec
 
 
 def _to_yaml(data_contract_str) -> dict:
     try:
-        yaml_dict = yaml.safe_load(data_contract_str)
-        return yaml_dict
+        return yaml.safe_load(data_contract_str)
     except Exception as e:
         logging.warning(f"Cannot parse YAML. Error: {str(e)}")
         raise DataContractException(
@@ -280,16 +368,17 @@ def _to_yaml(data_contract_str) -> dict:
         )
 
 
-def _validate_data_contract_specification_schema(data_contract_yaml, schema_location: str = None):
+def _validate_json_schema(yaml_str, schema_location: str | Path = None):
+    logging.debug(f"Linting data contract with schema at {schema_location}")
     schema = fetch_schema(schema_location)
     try:
-        fastjsonschema.validate(schema, data_contract_yaml, use_default=False)
+        fastjsonschema.validate(schema, yaml_str, use_default=False)
         logging.debug("YAML data is valid.")
     except JsonSchemaValueException as e:
         logging.warning(f"Data Contract YAML is invalid. Validation error: {e.message}")
         raise DataContractException(
             type="lint",
-            result="failed",
+            result=ResultEnum.failed,
             name="Check that data contract YAML is valid",
             reason=e.message,
             engine="datacontract",
@@ -298,7 +387,7 @@ def _validate_data_contract_specification_schema(data_contract_yaml, schema_loca
         logging.warning(f"Data Contract YAML is invalid. Validation error: {str(e)}")
         raise DataContractException(
             type="lint",
-            result="failed",
+            result=ResultEnum.failed,
             name="Check that data contract YAML is valid",
             reason=str(e),
             engine="datacontract",

datacontract/lint/schema.py

@@ -2,16 +2,18 @@ import importlib.resources as resources
 import json
 import logging
 import os
+from pathlib import Path
 from typing import Any, Dict
 
 import requests
 
 from datacontract.model.exceptions import DataContractException
+from datacontract.model.run import ResultEnum
 
-DEFAULT_DATA_CONTRACT_SCHEMA = "datacontract-1.1.0.schema.json"
+DEFAULT_DATA_CONTRACT_SCHEMA = "datacontract-1.2.1.schema.json"
 
 
-def fetch_schema(location: str = None) -> Dict[str, Any]:
+def fetch_schema(location: str | Path = None) -> Dict[str, Any]:
     """
     Fetch and return a JSON schema from a given location.
 
@@ -36,19 +38,26 @@ def fetch_schema(location: str = None) -> Dict[str, Any]:
         schema_file = schemas.joinpath("schemas", DEFAULT_DATA_CONTRACT_SCHEMA)
         with schema_file.open("r") as file:
             schema = json.load(file)
-    elif location.startswith("http://") or location.startswith("https://"):
-        response = requests.get(location)
-        schema = response.json()
     else:
-        if not os.path.exists(location):
-            raise DataContractException(
-                type="lint",
-                name=f"Reading schema from {location}",
-                reason=f"The file '{location}' does not exist.",
-                engine="datacontract",
-                result="error",
-            )
-        with open(location, "r") as file:
-            schema = json.load(file)
+        # Convert Path objects to strings for string operations
+        location_str = str(location)
+
+        if location_str.startswith("http://") or location_str.startswith("https://"):
+            logging.debug(f"Downloading schema from {location_str}")
+            response = requests.get(location_str)
+            schema = response.json()
+        else:
+            if not os.path.exists(location):
+                raise DataContractException(
+                    type="lint",
+                    name=f"Reading schema from {location}",
+                    reason=f"The file '{location}' does not exist.",
+                    engine="datacontract",
+                    result=ResultEnum.error,
+                )
+
+            logging.debug(f"Loading JSON schema locally at {location}")
+            with open(location, "r") as file:
+                schema = json.load(file)
 
     return schema

datacontract/lint/urls.py

@@ -28,10 +28,22 @@ def fetch_resource(url: str):
 def _set_api_key(headers, url):
     hostname = urlparse(url).hostname
 
+    entropy_data_api_key = os.getenv("ENTROPY_DATA_API_KEY")
     datamesh_manager_api_key = os.getenv("DATAMESH_MANAGER_API_KEY")
     datacontract_manager_api_key = os.getenv("DATACONTRACT_MANAGER_API_KEY")
 
-    if hostname == "datamesh-manager.com" or hostname.endswith(".datamesh-manager.com"):
+    if hostname == "entropy-data.com" or hostname.endswith(".entropy-data.com"):
+        if entropy_data_api_key is None or entropy_data_api_key == "":
+            print("Error: Entropy Data API key is not set. Set env variable ENTROPY_DATA_API_KEY.")
+            raise DataContractException(
+                type="lint",
+                name=f"Reading data contract from {url}",
+                reason="Error: Entropy Data API key is not set. Set env variable ENTROPY_DATA_API_KEY.",
+                engine="datacontract",
+                result="error",
+            )
+        headers["x-api-key"] = entropy_data_api_key
+    elif hostname == "datamesh-manager.com" or hostname.endswith(".datamesh-manager.com"):
         if datamesh_manager_api_key is None or datamesh_manager_api_key == "":
             print("Error: Data Mesh Manager API key is not set. Set env variable DATAMESH_MANAGER_API_KEY.")
             raise DataContractException(
@@ -54,7 +66,9 @@ def _set_api_key(headers, url):
             )
         headers["x-api-key"] = datacontract_manager_api_key
 
-    if datamesh_manager_api_key is not None and datamesh_manager_api_key != "":
-        headers["x-api-key"] = datamesh_manager_api_key
     if datacontract_manager_api_key is not None and datacontract_manager_api_key != "":
         headers["x-api-key"] = datacontract_manager_api_key
+    if datamesh_manager_api_key is not None and datamesh_manager_api_key != "":
+        headers["x-api-key"] = datamesh_manager_api_key
+    if entropy_data_api_key is not None and entropy_data_api_key != "":
+        headers["x-api-key"] = entropy_data_api_key