datacontract-cli 0.10.35__py3-none-any.whl → 0.10.36__py3-none-any.whl

datacontract/lint/linters/field_reference_linter.py

@@ -1,47 +0,0 @@
-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.
-
-    """
-
-    @property
-    def name(self):
-        return "Field references existing field"
-
-    @property
-    def id(self) -> str:
-        return "field-reference"
-
-    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():
-                if field.references:
-                    reference_hierarchy = field.references.split(".")
-                    if len(reference_hierarchy) != 2:
-                        result = result.with_error(
-                            f"Field '{field_name}' in model '{model_name}'"
-                            f" references must follow the model.field syntax and refer to a field in a model in this data contract."
-                        )
-                        continue
-                    ref_model = reference_hierarchy[0]
-                    ref_field = reference_hierarchy[1]
-
-                    if ref_model not in contract.models:
-                        result = result.with_error(
-                            f"Field '{field_name}' in model '{model_name}' 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}'."
-                            )
-        return result

datacontract/lint/linters/notice_period_linter.py

@@ -1,55 +0,0 @@
-import re
-
-from datacontract.model.data_contract_specification import DataContractSpecification
-
-from ..lint import Linter, LinterResult
-
-
-class NoticePeriodLinter(Linter):
-    @property
-    def name(self) -> str:
-        return "noticePeriod in ISO8601 format"
-
-    @property
-    def id(self) -> str:
-        return "notice-period"
-
-    # Regex matching the "simple" ISO8601 duration format
-    simple = re.compile(
-        r"""P             # Introduces period
-        (:?[0-9\.,]+Y)?   # Number of years
-        (:?[0-9\.,]+M)?   # Number of months
-        (:?[0-9\.,]+W)?   # Number of weeks
-        (:?[0-9\.,]+D)?   # Number of days
-        (:?               # Time part (optional)
-          T               # Always starts with T
-          (:?[0-9\.,]+H)? # Number of hours
-          (:?[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}")
-
-    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.")
-        period = contract.terms.noticePeriod
-        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.")
-        if period == "P":
-            return LinterResult.erroneous(
-                "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/valid_constraints_linter.py

@@ -1,100 +0,0 @@
-from datacontract.model.data_contract_specification import DataContractSpecification, Field
-
-from ..lint import Linter, LinterResult
-
-
-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.
-
-    """
-
-    valid_types_for_constraint = {
-        "pattern": set(["string", "text", "varchar"]),
-        "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"]
-        ),
-    }
-
-    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,
-        ):
-            case (True, True, _, _) if min > max:
-                return LinterResult.erroneous(
-                    f"Minimum {min} is greater than maximum {max} on field '{field_name}' in model '{model_name}'."
-                )
-            case (_, _, True, True) if xmin >= xmax:
-                return LinterResult.erroneous(
-                    f"Exclusive minimum {xmin} is greater than exclusive"
-                    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}'."
-                )
-            case (True, _, True, _):
-                return LinterResult.erroneous(
-                    f"Both exclusive and non-exclusive minimum are "
-                    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}'."
-                )
-        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 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 '{field_name}' in model '{model_name}'."
-            )
-        return result
-
-    @property
-    def name(self):
-        return "Fields use valid constraints"
-
-    @property
-    def id(self):
-        return "field-constraints"
-
-    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():
-                    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}'."
-                        )
-                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