datacontract-cli 0.9.7__py3-none-any.whl → 0.9.8__py3-none-any.whl

datacontract/lint/linters/description_linter.py

@@ -1,6 +1,5 @@
+from datacontract.model.data_contract_specification import DataContractSpecification
 from ..lint import Linter, LinterResult
-from datacontract.model.data_contract_specification import\
-    DataContractSpecification, Model
 
 
 class DescriptionLinter(Linter):
@@ -14,30 +13,22 @@ class DescriptionLinter(Linter):
     def id(self) -> str:
         return "description"
 
-    def lint_implementation(
-        self,
-        contract: DataContractSpecification
-    ) -> LinterResult:
+    def lint_implementation(self, contract: DataContractSpecification) -> LinterResult:
         result = LinterResult()
         if not contract.info or not contract.info.description:
-            result = result.with_error(
-                f"Contract has empty description.")
-        for (model_name, model) in contract.models.items():
+            result = result.with_error("Contract has empty description.")
+        for model_name, model in contract.models.items():
             if not model.description:
-                result = result.with_error(
-                    f"Model '{model_name}' has empty description."
-                )
-            for (field_name, field) in model.fields.items():
+                result = result.with_error(f"Model '{model_name}' has empty description.")
+            for field_name, field in model.fields.items():
                 if not field.description:
                     result = result.with_error(
-                        f"Field '{field_name}' in model '{model_name}'"
-                        f" has empty description.")
-        for (definition_name, definition) in contract.definitions.items():
+                        f"Field '{field_name}' in model '{model_name}'" f" has empty description."
+                    )
+        for definition_name, definition in contract.definitions.items():
             if not definition.description:
-                result = result.with_error(
-                    f"Definition '{definition_name}' has empty description.")
-        for (index, example) in enumerate(contract.examples):
+                result = result.with_error(f"Definition '{definition_name}' has empty description.")
+        for index, example in enumerate(contract.examples):
             if not example.description:
-                result = result.with_error(
-                    f"Example {index + 1} has empty description.")
+                result = result.with_error(f"Example {index + 1} has empty description.")
         return result

datacontract/lint/linters/example_model_linter.py

@@ -1,14 +1,15 @@
 import csv
-import yaml
-import json
 import io
+import json
+
+import yaml
 
+from datacontract.model.data_contract_specification import \
+    DataContractSpecification, Example
 from ..lint import Linter, LinterResult
-from datacontract.model.data_contract_specification import DataContractSpecification, Example
 
 
 class ExampleModelLinter(Linter):
-
     @property
     def name(self) -> str:
         return "Example(s) match model"
@@ -37,42 +38,39 @@ class ExampleModelLinter(Linter):
                     raise NotImplementedError(f"Unknown type {example.type}")
         else:
             # Checked in lint_implementation, shouldn't happen.
-            raise NotImplementedError("Can't lint object examples.") 
+            raise NotImplementedError("Can't lint object examples.")
 
-    def lint_implementation(
-        self,
-        contract: DataContractSpecification
-    ) -> LinterResult:
+    def lint_implementation(self, contract: DataContractSpecification) -> LinterResult:
         """Check whether the example(s) headers match the model.
 
-          This linter checks whether the example's fields match the model
-          fields, and whether all required fields of the model are present in
-          the example.
+        This linter checks whether the example's fields match the model
+        fields, and whether all required fields of the model are present in
+        the example.
         """
         result = LinterResult()
         examples = contract.examples
         models = contract.models
         examples_with_model = []
-        for (index, example) in enumerate(examples):
+        for index, example in enumerate(examples):
             if example.model not in models:
-                result = result.with_error(
-                    f"Example {index + 1} has non-existent model '{example.model}'")
+                result = result.with_error(f"Example {index + 1} has non-existent model '{example.model}'")
             else:
-                examples_with_model.append(
-                    (index, example, models.get(example.model)))
-        for (index, example, model) in examples_with_model:
+                examples_with_model.append((index, example, models.get(example.model)))
+        for index, example, model in examples_with_model:
             if example.type == "custom":
-                result = result.with_warning(f"Example {index + 1} has type"
-                                             " \"custom\", cannot check model"
-                                             " conformance")
+                result = result.with_warning(
+                    f"Example {index + 1} has type" ' "custom", cannot check model' " conformance"
+                )
             elif not isinstance(example.data, str):
-                result = result.with_warning(f"Example {index + 1} is not a "
-                    "string example, can only lint string examples for now.")
+                result = result.with_warning(
+                    f"Example {index + 1} is not a " "string example, can only lint string examples for now."
+                )
             elif model.type == "object":
                 result = result.with_warning(
                     f"Example {index + 1} uses a "
                     f"model '{example.model}' with type 'object'. Linting is "
-                    "currently only supported for 'table' models")
+                    "currently only supported for 'table' models"
+                )
             else:
                 if example.type in ("csv", "yaml", "json"):
                     headers = self.get_example_headers(example)
@@ -80,13 +78,14 @@ class ExampleModelLinter(Linter):
                         if example_header not in model.fields:
                             result = result.with_error(
                                 f"Example {index + 1} has field '{example_header}'"
-                                f" that's not contained in model '{example.model}'")
-                    for (field_name, field_value) in model.fields.items():
+                                f" that's not contained in model '{example.model}'"
+                            )
+                    for field_name, field_value in model.fields.items():
                         if field_name not in headers and field_value.required:
                             result = result.with_error(
                                 f"Example {index + 1} is missing field '{field_name}'"
-                                f" required by model '{example.model}'")
+                                f" required by model '{example.model}'"
+                            )
                 else:
-                    result = result.with_error(f"Example {index + 1} has unknown type"                        
-                                               f"{example.type}")
+                    result = result.with_error(f"Example {index + 1} has unknown type" f"{example.type}")
         return result

datacontract/lint/linters/field_pattern_linter.py

@@ -1,13 +1,16 @@
 import re
 
+from datacontract.model.data_contract_specification import \
+    DataContractSpecification
 from ..lint import Linter, LinterResult
-from datacontract.model.data_contract_specification import DataContractSpecification
+
 
 class FieldPatternLinter(Linter):
     """Checks that all patterns defined for fields are correct Python regex
-      syntax.
+    syntax.
 
     """
+
     @property
     def name(self):
         return "Field pattern is correct regex"
@@ -16,13 +19,10 @@ class FieldPatternLinter(Linter):
     def id(self) -> str:
         return "field-pattern"
 
-    def lint_implementation(
-        self,
-        contract: DataContractSpecification
-    ) -> LinterResult:
+    def lint_implementation(self, contract: DataContractSpecification) -> LinterResult:
         result = LinterResult()
-        for (model_name, model) in contract.models.items():
-            for (field_name, field) in model.fields.items():
+        for model_name, model in contract.models.items():
+            for field_name, field in model.fields.items():
                 if field.pattern:
                     try:
                         re.compile(field.pattern)

datacontract/lint/linters/field_reference_linter.py

@@ -1,11 +1,13 @@
-from ..lint import Linter, LinterResult
 from datacontract.model.data_contract_specification import DataContractSpecification
+from ..lint import Linter, LinterResult
+
 
 class FieldReferenceLinter(Linter):
     """Checks that all references definitions in fields refer to existing
-      fields.
+    fields.
 
     """
+
     @property
     def name(self):
         return "Field references existing field"
@@ -14,24 +16,23 @@ class FieldReferenceLinter(Linter):
     def id(self) -> str:
         return "field-reference"
 
-    def lint_implementation(
-        self,
-        contract: DataContractSpecification
-    ) -> LinterResult:
+    def lint_implementation(self, contract: DataContractSpecification) -> LinterResult:
         result = LinterResult()
-        for (model_name, model) in contract.models.items():
-            for (field_name, field) in model.fields.items():
+        for model_name, model in contract.models.items():
+            for field_name, field in model.fields.items():
                 if field.references:
                     (ref_model, ref_field) = field.references.split(".", maxsplit=2)
                     if ref_model not in contract.models:
                         result = result.with_error(
                             f"Field '{field_name}' in model '{model_name}'"
-                            f" references non-existing model '{ref_model}'.")
+                            f" references non-existing model '{ref_model}'."
+                        )
                     else:
                         ref_model_obj = contract.models[ref_model]
                         if ref_field not in ref_model_obj.fields:
                             result = result.with_error(
                                 f"Field '{field_name}' in model '{model_name}'"
                                 f" references non-existing field '{ref_field}'"
-                                f" in model '{ref_model}'.")
+                                f" in model '{ref_model}'."
+                            )
         return result

datacontract/lint/linters/notice_period_linter.py

@@ -1,7 +1,9 @@
 import re
 
+from datacontract.model.data_contract_specification import \
+    DataContractSpecification
 from ..lint import Linter, LinterResult
-from datacontract.model.data_contract_specification import DataContractSpecification
+
 
 class NoticePeriodLinter(Linter):
     @property
@@ -25,17 +27,13 @@ class NoticePeriodLinter(Linter):
           (:?[0-9\.,]+M)? # Number of minutes
           (:?[0-9\.,]+S)? # Number of seconds
         )?
-        """, re.VERBOSE
-        )
-    datetime_basic = re.compile(
-        r"P\d{8}T\d{6}")
-    datetime_extended = re.compile(
-        r"P\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}")
+        """,
+        re.VERBOSE,
+    )
+    datetime_basic = re.compile(r"P\d{8}T\d{6}")
+    datetime_extended = re.compile(r"P\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}")
 
-    def lint_implementation(
-        self,
-        contract: DataContractSpecification
-    ) -> LinterResult:
+    def lint_implementation(self, contract: DataContractSpecification) -> LinterResult:
         """Check whether the notice period is specified using ISO8601 duration syntax."""
         if not contract.terms:
             return LinterResult.cautious("No terms defined.")
@@ -43,17 +41,15 @@ class NoticePeriodLinter(Linter):
         if not period:
             return LinterResult.cautious("No notice period defined.")
         if not period.startswith("P"):
-            return LinterResult.erroneous(
-                f"Notice period '{period}' is not a valid"
-                 "ISO8601 duration.")
+            return LinterResult.erroneous(f"Notice period '{period}' is not a valid" "ISO8601 duration.")
         if period == "P":
             return LinterResult.erroneous(
-                f"Notice period 'P' is not a valid"
-                 "ISO8601 duration, requires at least one"
-                 "duration to be specified.")
-        if (not self.simple.fullmatch(period) and
-            not self.datetime_basic.fullmatch(period) and
-            not self.datetime_extended.fullmatch(period)):
-            return LinterResult.erroneous(
-                f"Notice period '{period}' is not a valid ISO8601 duration.")
+                "Notice period 'P' is not a valid" "ISO8601 duration, requires at least one" "duration to be specified."
+            )
+        if (
+            not self.simple.fullmatch(period)
+            and not self.datetime_basic.fullmatch(period)
+            and not self.datetime_extended.fullmatch(period)
+        ):
+            return LinterResult.erroneous(f"Notice period '{period}' is not a valid ISO8601 duration.")
         return LinterResult()

datacontract/lint/linters/primary_field_linter.py

@@ -1,8 +1,10 @@
-from ..lint import Linter, LinterResult
 from datacontract.model.data_contract_specification import DataContractSpecification
+from ..lint import Linter, LinterResult
+
 
 class PrimaryFieldUniqueRequired(Linter):
     """Checks that all fields defined as primary are also defined as unique and required."""
+
     @property
     def name(self) -> str:
         return "Model primary fields unique and required"
@@ -11,20 +13,16 @@ class PrimaryFieldUniqueRequired(Linter):
     def id(self) -> str:
         return "notice-period"
 
-    def lint_implementation(
-            self,
-            contract: DataContractSpecification
-    ) -> LinterResult:
+    def lint_implementation(self, contract: DataContractSpecification) -> LinterResult:
         if not contract.models:
             return LinterResult.cautious("No models defined on contract.")
         result = LinterResult()
-        for (model_name, model) in contract.models.items():
-            for (field_name, field) in model.fields.items():
-                if (field.primary
-                    and not field.required
-                    and not field.unique):
+        for model_name, model in contract.models.items():
+            for field_name, field in model.fields.items():
+                if field.primary and not field.required and not field.unique:
                     result = result.with_error(
                         f"Field '{field_name}' in model '{model_name}'"
-                         " is marked as primary, but not as unique"
-                         " and required.")
+                        " is marked as primary, but not as unique"
+                        " and required."
+                    )
         return result

datacontract/lint/linters/quality_schema_linter.py

@@ -1,12 +1,11 @@
 import yaml
 
-from ..lint import Linter, LinterResult
-from datacontract.model.data_contract_specification import\
+from datacontract.model.data_contract_specification import \
     DataContractSpecification, Model
+from ..lint import Linter, LinterResult
 
 
 class QualityUsesSchemaLinter(Linter):
-
     @property
     def name(self) -> str:
         return "Quality check(s) use model"
@@ -15,23 +14,21 @@ class QualityUsesSchemaLinter(Linter):
     def id(self) -> str:
         return "quality-schema"
 
-    def lint_sodacl(self, check, models: dict[str, Model]) ->\
-            LinterResult:
+    def lint_sodacl(self, check, models: dict[str, Model]) -> LinterResult:
         result = LinterResult()
         for sodacl_check in check.keys():
-            table_name = sodacl_check[len("checks for "):]
+            table_name = sodacl_check[len("checks for ") :]
             if table_name not in models:
-                result = result.with_error(
-                    f"Quality check on unknown model '{table_name}'")
+                result = result.with_error(f"Quality check on unknown model '{table_name}'")
         return result
 
-    def lint_montecarlo(self, check, models: dict[str, Model]) ->\
-            LinterResult:
-        return LinterResult().with_warning(
-            "Linting montecarlo checks is not currently implemented")
+    def lint_montecarlo(self, check, models: dict[str, Model]) -> LinterResult:
+        return LinterResult().with_warning("Linting montecarlo checks is not currently implemented")
+
+    def lint_great_expectations(self, check, models: dict[str, Model]) -> LinterResult:
+        return LinterResult().with_warning("Linting great expectations checks is not currently implemented")
 
-    def lint_implementation(self, contract: DataContractSpecification) ->\
-            LinterResult:
+    def lint_implementation(self, contract: DataContractSpecification) -> LinterResult:
         result = LinterResult()
         models = contract.models
         check = contract.quality
@@ -45,12 +42,11 @@ class QualityUsesSchemaLinter(Linter):
             check_specification = check.specification
         match check.type:
             case "SodaCL":
-                result = result.combine(
-                    self.lint_sodacl(check_specification, models))
+                result = result.combine(self.lint_sodacl(check_specification, models))
             case "montecarlo":
-                result = result.combine(
-                    self.lint_montecarlo(check_specification, models))
+                result = result.combine(self.lint_montecarlo(check_specification, models))
+            case "great-expectations":
+                result = result.combine(self.lint_great_expectations(check_specification, models))
             case _:
-                result = result.with_warning("Can't lint quality check "
-                                             f"with type '{check.type}'")
+                result = result.with_warning("Can't lint quality check " f"with type '{check.type}'")
         return result

datacontract/lint/linters/valid_constraints_linter.py

@@ -1,17 +1,16 @@
+from datacontract.model.data_contract_specification import DataContractSpecification, Field
 from ..lint import Linter, LinterResult
-from datacontract.model.data_contract_specification import\
-    DataContractSpecification, Field
 
 
 class ValidFieldConstraintsLinter(Linter):
     """Check validity of field constraints.
 
-      More precisely, check that only numeric constraints are specified on
-      fields of numeric type and string constraints on fields of string type.
-      Additionally, the linter checks that defined constraints make sense.
-      Minimum values should not be greater than maximum values, exclusive and
-      non-exclusive minimum and maximum should not be combined and string
-      pattern and format should not be combined.
+    More precisely, check that only numeric constraints are specified on
+    fields of numeric type and string constraints on fields of string type.
+    Additionally, the linter checks that defined constraints make sense.
+    Minimum values should not be greater than maximum values, exclusive and
+    non-exclusive minimum and maximum should not be combined and string
+    pattern and format should not be combined.
 
     """
 
@@ -20,52 +19,60 @@ class ValidFieldConstraintsLinter(Linter):
         "format": set(["string", "text", "varchar"]),
         "minLength": set(["string", "text", "varchar"]),
         "maxLength": set(["string", "text", "varchar"]),
-        "minimum": set(["int", "integer", "number", "decimal", "numeric",
-                        "long", "bigint", "float", "double"]),
-        "exclusiveMinimum": set(["int", "integer", "number", "decimal", "numeric",
-                                 "long", "bigint", "float", "double"]),
-        "maximum": set(["int", "integer", "number", "decimal", "numeric",
-                        "long", "bigint", "float", "double"]),
-        "exclusiveMaximum": set(["int", "integer", "number", "decimal", "numeric",
-                                 "long", "bigint", "float", "double"]),
+        "minimum": set(["int", "integer", "number", "decimal", "numeric", "long", "bigint", "float", "double"]),
+        "exclusiveMinimum": set(
+            ["int", "integer", "number", "decimal", "numeric", "long", "bigint", "float", "double"]
+        ),
+        "maximum": set(["int", "integer", "number", "decimal", "numeric", "long", "bigint", "float", "double"]),
+        "exclusiveMaximum": set(
+            ["int", "integer", "number", "decimal", "numeric", "long", "bigint", "float", "double"]
+        ),
     }
 
     def check_minimum_maximum(self, field: Field, field_name: str, model_name: str) -> LinterResult:
         (min, max, xmin, xmax) = (field.minimum, field.maximum, field.exclusiveMinimum, field.exclusiveMaximum)
-        match ("minimum" in field.model_fields_set, "maximum" in field.model_fields_set,
-               "exclusiveMinimum" in field.model_fields_set, "exclusiveMaximum" in field.model_fields_set):
+        match (
+            "minimum" in field.model_fields_set,
+            "maximum" in field.model_fields_set,
+            "exclusiveMinimum" in field.model_fields_set,
+            "exclusiveMaximum" in field.model_fields_set,
+        ):
             case (True, True, _, _) if min > max:
                 return LinterResult.erroneous(
-                    f"Minimum {min} is greater than maximum {max} on "
-                    f"field '{field_name}' in model '{model_name}'.")
+                    f"Minimum {min} is greater than maximum {max} on " f"field '{field_name}' in model '{model_name}'."
+                )
             case (_, _, True, True) if xmin >= xmax:
-                  return LinterResult.erroneous(
+                return LinterResult.erroneous(
                     f"Exclusive minimum {xmin} is greater than exclusive"
-                    f" maximum {xmax} on field '{field_name}' in model '{model_name}'.")
+                    f" maximum {xmax} on field '{field_name}' in model '{model_name}'."
+                )
             case (True, True, True, True):
                 return LinterResult.erroneous(
                     f"Both exclusive and non-exclusive minimum and maximum are "
-                    f"defined on field '{field_name}' in model '{model_name}'.")
+                    f"defined on field '{field_name}' in model '{model_name}'."
+                )
             case (True, _, True, _):
                 return LinterResult.erroneous(
                     f"Both exclusive and non-exclusive minimum are "
-                    f"defined on field '{field_name}' in model '{model_name}'.")
+                    f"defined on field '{field_name}' in model '{model_name}'."
+                )
             case (_, True, _, True):
                 return LinterResult.erroneous(
                     f"Both exclusive and non-exclusive maximum are "
-                    f"defined on field '{field_name}' in model '{model_name}'.")
+                    f"defined on field '{field_name}' in model '{model_name}'."
+                )
         return LinterResult()
 
     def check_string_constraints(self, field: Field, field_name: str, model_name: str) -> LinterResult:
         result = LinterResult()
         if field.minLength and field.maxLength and field.minLength > field.maxLength:
             result = result.with_error(
-                f"Minimum length is greater that maximum length on"
-                f" field '{field_name}' in model '{model_name}'.")
+                f"Minimum length is greater that maximum length on" f" field '{field_name}' in model '{model_name}'."
+            )
         if field.pattern and field.format:
             result = result.with_error(
-                f"Both a pattern and a format are defined for field"
-                f" '{field_name}' in model '{model_name}'.")
+                f"Both a pattern and a format are defined for field" f" '{field_name}' in model '{model_name}'."
+            )
         return result
 
     @property
@@ -76,19 +83,17 @@ class ValidFieldConstraintsLinter(Linter):
     def id(self):
         return "field-constraints"
 
-    def lint_implementation(
-            self,
-            contract: DataContractSpecification
-    ) -> LinterResult:
+    def lint_implementation(self, contract: DataContractSpecification) -> LinterResult:
         result = LinterResult()
-        for (model_name, model) in contract.models.items():
-            for (field_name, field) in model.fields.items():
-                for (_property, allowed_types) in self.valid_types_for_constraint.items():
+        for model_name, model in contract.models.items():
+            for field_name, field in model.fields.items():
+                for _property, allowed_types in self.valid_types_for_constraint.items():
                     if _property in field.model_fields_set and field.type not in allowed_types:
                         result = result.with_error(
                             f"Forbidden constraint '{_property}' defined on field "
                             f"'{field_name}' in model '{model_name}'. Field type "
-                            f"is '{field.type}'.")
+                            f"is '{field.type}'."
+                        )
                 result = result.combine(self.check_minimum_maximum(field, field_name, model_name))
                 result = result.combine(self.check_string_constraints(field, field_name, model_name))
         return result

datacontract/lint/resolve.py

@@ -17,7 +17,7 @@ def resolve_data_contract(
     data_contract_str: str = None,
     data_contract: DataContractSpecification = None,
     schema_location: str = None,
-    inline_definitions: bool = False
+    inline_definitions: bool = False,
 ) -> DataContractSpecification:
     if data_contract_location is not None:
         return resolve_data_contract_from_location(data_contract_location, schema_location, inline_definitions)
@@ -30,14 +30,13 @@ def resolve_data_contract(
             type="lint",
             result="failed",
             name="Check that data contract YAML is valid",
-            reason=f"Data contract needs to be provided",
+            reason="Data contract needs to be provided",
             engine="datacontract",
         )
 
 
 def resolve_data_contract_from_location(
-    location, schema_location: str = None,
-    inline_definitions: bool = False
+    location, schema_location: str = None, inline_definitions: bool = False
 ) -> DataContractSpecification:
     if location.startswith("http://") or location.startswith("https://"):
         data_contract_str = fetch_resource(location)
@@ -57,10 +56,9 @@ def inline_definitions_into_data_contract(spec: DataContractSpecification):
             field.ref_obj = definition
 
             for field_name in field.model_fields.keys():
-                if (field_name in definition.model_fields_set and
-                    field_name not in field.model_fields_set):
-                    setattr(field, field_name,
-                            getattr(definition, field_name))
+                if field_name in definition.model_fields_set and field_name not in field.model_fields_set:
+                    setattr(field, field_name, getattr(definition, field_name))
+
 
 def resolve_ref(ref, definitions) -> Definition:
     if ref.startswith("http://") or ref.startswith("https://"):
@@ -82,8 +80,7 @@ def resolve_ref(ref, definitions) -> Definition:
 
 
 def resolve_data_contract_from_str(
-    data_contract_str, schema_location: str = None,
-    inline_definitions: bool = False
+    data_contract_str, schema_location: str = None, inline_definitions: bool = False
 ) -> DataContractSpecification:
     data_contract_yaml_dict = to_yaml(data_contract_str)
     validate(data_contract_yaml_dict, schema_location)

datacontract/lint/schema.py

@@ -7,7 +7,6 @@ from datacontract.model.exceptions import DataContractException
 
 
 def fetch_schema(location: str = None):
-
     if location is None:
         location = "https://datacontract.com/datacontract.schema.json"
 
@@ -21,8 +20,8 @@ def fetch_schema(location: str = None):
                 name=f"Reading schema from {location}",
                 reason=f"The file '{location}' does not exist.",
                 engine="datacontract",
-                result="error"
+                result="error",
             )
-        with open(location, 'r') as file:
+        with open(location, "r") as file:
             file_content = file.read()
         return json.loads(file_content)

datacontract/lint/urls.py

@@ -20,22 +20,21 @@ def fetch_resource(url: str):
             name=f"Reading data contract from {url}",
             reason=f"Cannot read resource from URL {url}. Response status is {response.status_code}",
             engine="datacontract",
-            result="error"
+            result="error",
         )
 
 
 def _set_api_key(headers, url):
     if ".datamesh-manager.com/" not in url:
         return
-    datamesh_manager_api_key = os.getenv('DATAMESH_MANAGER_API_KEY')
+    datamesh_manager_api_key = os.getenv("DATAMESH_MANAGER_API_KEY")
     if datamesh_manager_api_key is None or datamesh_manager_api_key == "":
-        print(f"Error: Data Mesh Manager API Key is not set. Set env variable DATAMESH_MANAGER_API_KEY.")
+        print("Error: Data Mesh Manager API Key is not set. Set env variable DATAMESH_MANAGER_API_KEY.")
         raise DataContractException(
             type="lint",
             name=f"Reading data contract from {url}",
             reason="Error: Data Mesh Manager API Key is not set. Set env variable DATAMESH_MANAGER_API_KEY.",
             engine="datacontract",
-            result="error"
+            result="error",
         )
     headers["x-api-key"] = datamesh_manager_api_key
-