cognite-neat 0.88.0__py3-none-any.whl → 0.88.2__py3-none-any.whl

cognite/neat/rules/issues/__init__.py

@@ -1,9 +1,8 @@
 from cognite.neat.issues import MultiValueError
 
-from . import dms, fileread, formatters, importing, spreadsheet, spreadsheet_file
+from . import dms, fileread, spreadsheet, spreadsheet_file
 from .base import (
     DefaultPydanticError,
-    IssueList,
     NeatValidationError,
     ValidationIssue,
     ValidationWarning,
@@ -12,15 +11,12 @@ from .base import (
 __all__ = [
     "DefaultPydanticError",
     "MultiValueError",
-    "IssueList",
     "NeatValidationError",
     "ValidationIssue",
     "ValidationIssue",
     "ValidationWarning",
     "dms",
     "fileread",
-    "formatters",
-    "importing",
     "spreadsheet",
     "spreadsheet_file",
 ]

cognite/neat/rules/issues/base.py

@@ -4,14 +4,13 @@ from typing import Any
 
 from pydantic_core import ErrorDetails
 
-from cognite.neat.issues import MultiValueError, NeatError, NeatIssue, NeatIssueList, NeatWarning
+from cognite.neat.issues import MultiValueError, NeatError, NeatIssue, NeatWarning
 
 __all__ = [
     "ValidationIssue",
     "NeatValidationError",
     "DefaultPydanticError",
     "ValidationWarning",
-    "IssueList",
     "MultiValueError",
 ]
 
@@ -21,22 +20,7 @@ class ValidationIssue(NeatIssue, ABC): ...
 
 
 @dataclass(frozen=True)
-class NeatValidationError(NeatError, ValidationIssue, ABC):
-    @classmethod
-    def from_pydantic_errors(cls, errors: list[ErrorDetails], **kwargs) -> "list[NeatValidationError]":
-        """Convert a list of pydantic errors to a list of Error instances.
-
-        This is intended to be overridden in subclasses to handle specific error types.
-        """
-        all_errors: list[NeatValidationError] = []
-        for error in errors:
-            if isinstance(ctx := error.get("ctx"), dict) and isinstance(
-                multi_error := ctx.get("error"), MultiValueError
-            ):
-                all_errors.extend(multi_error.errors)  # type: ignore[arg-type]
-            else:
-                all_errors.append(DefaultPydanticError.from_pydantic_error(error))
-        return all_errors
+class NeatValidationError(NeatError, ValidationIssue, ABC): ...
 
 
 @dataclass(frozen=True)
@@ -77,6 +61,3 @@ class DefaultPydanticError(NeatValidationError):
 
 @dataclass(frozen=True)
 class ValidationWarning(NeatWarning, ValidationIssue, ABC): ...
-
-
-class IssueList(NeatIssueList[ValidationIssue]): ...

cognite/neat/rules/issues/dms.py

@@ -10,13 +10,6 @@ __all__ = [
     "DMSSchemaError",
     "DMSSchemaWarning",
     "IncompleteSchemaError",
-    "MissingSpaceError",
-    "MissingContainerError",
-    "MissingContainerPropertyError",
-    "MissingViewError",
-    "MissingParentViewError",
-    "MissingSourceViewError",
-    "MissingEdgeViewError",
     "DirectRelationMissingSourceWarning",
     "ViewModelVersionNotMatchingWarning",
     "ViewModelSpaceNotMatchingWarning",
@@ -87,133 +80,6 @@ class IncompleteSchemaError(DMSSchemaError):
         return output
 
 
-@dataclass(frozen=True)
-class MissingSpaceError(DMSSchemaError):
-    description = "The spaced referred to by the Container/View/Node/Edge/DataModel does not exist"
-    fix = "Create the space"
-    space: str
-    referred_by: dm.ContainerId | dm.ViewId | dm.NodeId | dm.EdgeId | dm.DataModelId
-
-    def message(self) -> str:
-        return f"The space {self.space} referred to by {self.referred_by} does not exist"
-
-    def dump(self) -> dict[str, Any]:
-        output = super().dump()
-        output["space"] = self.space
-        output["referred_by"] = self.referred_by
-        return output
-
-
-@dataclass(frozen=True)
-class MissingContainerError(DMSSchemaError):
-    description = "The container referred to by the View does not exist"
-    fix = "Create the container"
-    error_name: ClassVar[str] = "MissingContainer"
-    container: dm.ContainerId
-    referred_by: dm.ViewId | dm.ContainerId
-
-    def message(self) -> str:
-        return f"The container {self.container} referred to by {self.referred_by} does not exist"
-
-    def dump(self) -> dict[str, Any]:
-        output = super().dump()
-        output["container"] = self.container
-        output["referred_by"] = self.referred_by
-        return output
-
-
-@dataclass(frozen=True)
-class MissingContainerPropertyError(DMSSchemaError):
-    description = "The property referred to by the View does not exist in the container"
-    fix = "Create the property"
-    error_name: ClassVar[str] = "MissingContainerProperty"
-    container: dm.ContainerId
-    property: str
-    referred_by: dm.ViewId
-
-    def message(self) -> str:
-        return (
-            f"The property {self.property} referred to by the container {self.container} "
-            f"does not exist in {self.referred_by}"
-        )
-
-    def dump(self) -> dict[str, Any]:
-        output = super().dump()
-        output["container"] = self.container
-        output["property"] = self.property
-        output["referred_by"] = self.referred_by
-        return output
-
-
-@dataclass(frozen=True)
-class MissingViewError(DMSSchemaError):
-    description = "The view referred to by the View/DataModel does not exist"
-    fix = "Create the view"
-    error_name: ClassVar[str] = "MissingView"
-    view: dm.ViewId
-    referred_by: dm.DataModelId | dm.ViewId
-
-    def message(self) -> str:
-        return f"The view {self.view} referred to by {self.referred_by} does not exist"
-
-    def dump(self) -> dict[str, Any]:
-        output = super().dump()
-        output["view"] = self.view
-        output["referred_by"] = self.referred_by
-        return output
-
-
-@dataclass(frozen=True)
-class MissingParentViewError(MissingViewError):
-    description = "The parent view referred to by the View does not exist"
-    fix = "Create the parent view"
-    error_name: ClassVar[str] = "MissingParentView"
-    referred_by: dm.ViewId
-
-    def message(self) -> str:
-        return f"The parent view {self.view} referred to by {self.referred_by} does not exist"
-
-    def dump(self) -> dict[str, Any]:
-        output = super().dump()
-        output["referred_by"] = self.referred_by
-        return output
-
-
-@dataclass(frozen=True)
-class MissingSourceViewError(MissingViewError):
-    description = "The source view referred to by the View does not exist"
-    fix = "Create the source view"
-    error_name: ClassVar[str] = "MissingSourceView"
-    property: str
-    referred_by: dm.ViewId
-
-    def message(self) -> str:
-        return f"The source view {self.view} referred to by {self.referred_by}.{self.property} does not exist"
-
-    def dump(self) -> dict[str, Any]:
-        output = super().dump()
-        output["property"] = self.property
-        return output
-
-
-@dataclass(frozen=True)
-class MissingEdgeViewError(MissingViewError):
-    description = "The edge view referred to by the View does not exist"
-    fix = "Create the edge view"
-    error_name: ClassVar[str] = "MissingEdgeView"
-    property: str
-    referred_by: dm.ViewId
-
-    def message(self) -> str:
-        return f"The edge view {self.view} referred to by {self.referred_by}.{self.property} does not exist"
-
-    def dump(self) -> dict[str, Any]:
-        output = super().dump()
-        output["property"] = self.property
-        output["referred_by"] = self.referred_by
-        return output
-
-
 @dataclass(frozen=True)
 class DuplicatedViewInDataModelError(DMSSchemaError):
     description = "The view is duplicated in the DataModel"
@@ -432,6 +298,26 @@ class ChangingViewError(DMSSchemaError):
         return output
 
 
+@dataclass(frozen=True)
+class EntityIDNotDMSCompliantWarning(DMSSchemaWarning):
+    description = "The entity ID, {entity_id} of type {entity_type}, is not DMS compliant. Violating regex {regex}"
+    fix = "Change the entity ID to be DMS compliant"
+    error_name: ClassVar[str] = "EntityIDNotDMSCompliantWarning"
+    entity_id: str
+    entity_type: str
+    regex: str
+
+    def message(self) -> str:
+        return self.description.format(entity_id=self.entity_id, entity_type=self.entity_type, regex=self.regex)
+
+    def dump(self) -> dict[str, Any]:
+        output = super().dump()
+        output["entity_id"] = self.entity_id
+        output["dms_type"] = self.entity_type
+        output["regex"] = self.regex
+        return output
+
+
 @dataclass(frozen=True)
 class EmptyContainerWarning(DMSSchemaWarning):
     description = "The container is empty"

cognite/neat/rules/issues/ontology.py

@@ -0,0 +1,298 @@
+from abc import ABC
+from dataclasses import dataclass
+from typing import ClassVar
+
+from .base import NeatValidationError, ValidationWarning
+
+__all__ = [
+    "OntologyError",
+    "OntologyWarning",
+]
+
+
+@dataclass(frozen=True)
+class OntologyError(NeatValidationError, ABC): ...
+
+
+@dataclass(frozen=True)
+class OntologyWarning(ValidationWarning, ABC): ...
+
+
+@dataclass(frozen=True)
+class OntologyMultiLabeledPropertyWarning(OntologyWarning):
+    """This warning occurs when a property is given multiple labels, typically if the
+    same property is defined for different classes but different name is given
+
+    Args:
+        property_id: property id that raised warning due to multiple labels
+        names: list of names of property
+
+    Notes:
+        This would be automatically fixed by taking the first label (aka name) of the property.
+    """
+
+    description = (
+        "This warning occurs when a property is given multiple labels,"
+        " typically if the same property is defined for different "
+        "classes but different name is given."
+    )
+    fix = "This would be automatically fixed by taking the first label (aka name) of the property."
+
+    property_id: str
+    names: list[str] | None = None
+
+    def message(self) -> str:
+        message = (
+            "Property should have single preferred label (human readable name)."
+            f"Currently property '{self.property_id}' has multiple preferred labels: {', '.join(self.names or [])} !"
+            f"Only the first name, i.e. '{self.names[0] if self.names else ''}' will be considered!"
+        )
+        message += f"\nDescription: {self.description}"
+        message += f"\nFix: {self.fix}"
+        return message
+
+
+@dataclass(frozen=True)
+class OntologyMultiDefinitionPropertyWarning(OntologyWarning):
+    """This warning occurs when a property is given multiple human readable definitions,
+    typically if the same property is defined for different classes where each definition
+    is different.
+
+    Args:
+        property_id: property id that raised warning due to multiple definitions
+
+    Notes:
+        This would be automatically fixed by concatenating all definitions.
+    """
+
+    description = (
+        "This warning occurs when a property is given multiple human readable definitions,"
+        " typically if the same property is defined for different "
+        "classes where each definition is different."
+    )
+    fix = "This would be automatically fixed by concatenating all definitions."
+
+    property_id: str
+
+    def message(self):
+        message = (
+            f"Multiple definitions (aka comments) of property '{self.property_id}' detected."
+            " Definitions will be concatenated."
+        )
+        message += f"\nDescription: {self.description}"
+        message += f"\nFix: {self.fix}"
+        return message
+
+
+@dataclass(frozen=True)
+class OntologyMultiTypePropertyWarning(OntologyWarning):
+    """This warning occurs when a same property is define for two object/classes where
+    its expected value type is different in one definition, e.g. acts as an edge, while in
+    other definition acts as and attribute
+
+    Args:
+        property_id: property id that raised warning due to multi type definition
+        types: list of types of property
+
+    Notes:
+        If a property takes different value types for different objects, simply define
+        new property. It is bad practice to have multi type property!
+    """
+
+    description = (
+        "This warning occurs when a same property is define for two object/classes where"
+        " its expected value type is different in one definition, e.g. acts as an edge, while in "
+        "other definition acts as and attribute"
+    )
+    fix = "If a property takes different value types for different objects, simply define new property"
+
+    property_id: str
+    types: list[str] | None = None
+
+    def message(self) -> str:
+        message = (
+            "It is bad practice to have multi type property! "
+            f"Currently property '{self.property_id}' is defined as multi type property: {', '.join(self.types or [])}"
+        )
+        message += f"\nDescription: {self.description}"
+        message += f"\nFix: {self.fix}"
+        return message
+
+
+@dataclass(frozen=True)
+class OntologyMultiRangePropertyWarning(OntologyWarning):
+    """This warning occurs when a property takes range of values which consists of union
+    of multiple value types
+
+    Args:
+        property_id: property id that raised warning due to multi range definition
+        range_of_values: list of ranges that property takes
+
+    Notes:
+        If a property takes different range of values, simply define new property.
+    """
+
+    description = (
+        "This warning occurs when a property takes range of values which consists of union of multiple value types."
+    )
+    fix = "If a property takes different range of values, simply define new property"
+    property_id: str
+    range_of_values: list[str] | None = None
+
+    def message(self) -> str:
+        message = (
+            "It is bad practice to have property that take various range of values! "
+            f"Currently property '{self.property_id}' has multiple ranges: {', '.join(self.range_of_values or [])}"
+        )
+        message += f"\nDescription: {self.description}"
+        message += f"\nFix: {self.fix}"
+        return message
+
+
+@dataclass(frozen=True)
+class OntologyMultiDomainPropertyWarning(OntologyWarning):
+    """This warning occurs when a property is reused for more than one classes
+
+    Args:
+        property_id: property id that raised warning due to reuse definition
+        classes: list of classes that use the same property
+        verbose: flag that indicates whether to provide enhanced exception message, by default False
+
+    Notes:
+        No need to fix this, but make sure that property type is consistent across different
+        classes and that ideally takes the same range of values
+    """
+
+    description = "This warning occurs when a property is reused for more than one classes."
+    fix = (
+        "No need to fix this, but make sure that property type is consistent"
+        " across different classes and that ideally takes the same range of values"
+    )
+    property_id: str
+    classes: list[str] | None = None
+
+    def message(self) -> str:
+        message = (
+            f"Currently property '{self.property_id}' is defined for multiple classes: {', '.join(self.classes or [])}"
+        )
+        message += f"\nDescription: {self.description}"
+        message += f"\nFix: {self.fix}"
+        return message
+
+
+@dataclass(frozen=True)
+class PropertiesDefinedMultipleTimesError(OntologyError):
+    """This error is raised during export of Transformation Rules to DMS schema when
+    when properties are defined multiple times for the same class.
+
+    Args:
+        report: report on properties which are defined multiple times
+        verbose: flag that indicates whether to provide enhanced exception message, by default False
+
+    Notes:
+       Make sure to check validation report of Transformation Rules and fix DMS related warnings.
+    """
+
+    description = (
+        "This error is raised during export of Transformation Rules to "
+        "DMS schema when properties are defined multiple times for the same class."
+    )
+    fix = "Make sure to check validation report of Transformation Rules and fix DMS related warnings."
+
+    report: str
+
+    def message(self) -> str:
+        message = f"Following properties defined multiple times for the same class(es): {self.report}"
+
+        message += f"\nDescription: {self.description}"
+        message += f"\nFix: {self.fix}"
+        return message
+
+
+@dataclass(frozen=True)
+class PropertyDefinitionsNotForSamePropertyError(OntologyError):
+    """This error is raised if property definitions are not for linked to the same
+    property id when exporting rules to ontological representation.
+
+    Args:
+        verbose: flag that indicates whether to provide enhanced exception message, by default False
+    """
+
+    description = "This error is raised if property definitions are not for linked to the same property id"
+
+    def message(self):
+        message = "All definitions should have the same property_id! Aborting."
+
+        message += f"\nDescription: {self.description}"
+        return message
+
+
+@dataclass(frozen=True)
+class PrefixMissingError(OntologyError):
+    """Prefix, which is in the 'Metadata' sheet, is missing.
+
+    Args:
+        verbose: flag that indicates whether to provide enhanced exception message, by default False
+
+    """
+
+    description = "Prefix is missing from the 'Metadata' sheet."
+    example = "There is no prefix in the 'Metadata' sheet."
+    fix = "Specify the prefix if prefix in the 'Metadata' sheet."
+
+    def message(self) -> str:
+        message = "Missing prefix stored in 'Metadata' sheet."
+        message += f"\nDescription: {self.description}"
+        message += f"\nExample: {self.example}"
+        message += f"\nFix: {self.fix}"
+        return message
+
+
+@dataclass(frozen=True)
+class MissingDataModelPrefixOrNamespaceWarning(ValidationWarning):
+    """Prefix and/or namespace are missing in the 'Metadata' sheet
+
+    Args:
+        verbose: flag that indicates whether to provide enhanced exception message, by default False
+
+    Notes:
+    Add missing prefix and/or namespace in the 'Metadata' sheet
+    """
+
+    description = "Either prefix or namespace or both are missing in the 'Metadata' sheet"
+    fix = "Add missing prefix and/or namespace in the 'Metadata' sheet"
+
+    def message(self) -> str:
+        message = (
+            "Instances sheet is present but prefix and/or namespace are missing in 'Metadata' sheet."
+            "Instances sheet will not be processed!"
+        )
+        message += f"\nDescription: {self.description}"
+        message += f"\nFix: {self.fix}"
+        return message
+
+
+@dataclass(frozen=True)
+class MetadataSheetNamespaceNotDefinedError(OntologyError):
+    """namespace, which is in the 'Metadata' sheet, is not defined
+
+    Args:
+        namespace: namespace that raised exception
+        verbose: flag that indicates whether to provide enhanced exception message, by default False
+
+    Notes:
+        Check if `namespace` in the `Metadata` sheet is properly constructed as valid URL
+        containing only allowed characters.
+
+    """
+
+    description = "namespace, which is in the 'Metadata' sheet, is missing"
+    example: ClassVar[str] = "Example of a valid namespace 'http://www.w3.org/ns/sparql#'"
+    fix = "Define the 'namespace' in the 'Metadata' sheet."
+
+    def message(self) -> str:
+        message = "Missing namespace  in 'Metadata' sheet."
+        message += f"\nDescription: {self.description}"
+        message += f"\nExample: {self.example}"
+        message += f"\nFix: {self.fix}"
+        return message

cognite/neat/rules/issues/spreadsheet.py

@@ -9,7 +9,7 @@ from cognite.client.data_classes.data_modeling import ContainerId, ViewId
 from pydantic_core import ErrorDetails
 from rdflib import Namespace
 
-from cognite.neat.issues import MultiValueError
+from cognite.neat.issues import MultiValueError, NeatError
 from cognite.neat.utils.spreadsheet import SpreadsheetRead
 
 from .base import DefaultPydanticError, NeatValidationError
@@ -38,6 +38,7 @@ __all__ = [
     "MultiDefaultError",
     "MultiIndexError",
     "MultiUniqueConstraintError",
+    "RegexViolationError",
 ]
 
 
@@ -58,8 +59,8 @@ class InvalidSheetError(NeatValidationError, ABC):
         errors: list[ErrorDetails],
         read_info_by_sheet: dict[str, SpreadsheetRead] | None = None,
         **kwargs: Any,
-    ) -> "list[NeatValidationError]":
-        output: list[NeatValidationError] = []
+    ) -> "list[NeatError]":
+        output: list[NeatError] = []
         for error in errors:
             if raised_error := error.get("ctx", {}).get("error"):
                 if isinstance(raised_error, MultiValueError):
@@ -277,6 +278,24 @@ class PropertiesDefinedForUndefinedClassesError(NeatValidationError):
         )
 
 
+@dataclass(frozen=True)
+class RegexViolationError(NeatValidationError):
+    description = "Value, {value} failed regex, {regex}, validation."
+    fix = "Make sure that the name follows the regex pattern."
+
+    value: str
+    regex: str
+
+    def dump(self) -> dict[str, str]:
+        output = super().dump()
+        output["value"] = self.value
+        output["regex"] = self.regex
+        return output
+
+    def message(self) -> str:
+        return self.description.format(value=self.value, regex=self.regex)
+
+
 @dataclass(frozen=True)
 class ClassNoPropertiesNoParentError(NeatValidationError):
     description = "Class has no properties and no parents."
@@ -295,6 +314,35 @@ class ClassNoPropertiesNoParentError(NeatValidationError):
         return f"Class {self.classes[0]} have no direct or inherited properties. This may be a mistake."
 
 
+@dataclass(frozen=True)
+class DefaultValueTypeNotProperError(NeatValidationError):
+    """This exceptions is raised when default value type is not proper, i.e. it is not
+    according to the expected value type set in Rules.
+
+
+    Args:
+        default_value_type: default value type that raised exception
+        expected_value_type: expected value type that raised exception
+
+    """
+
+    description = (
+        "This exceptions is raised when default value type is not proper, i.e. it is not "
+        "according to the expected value type set in Rules."
+    )
+    property_id: str
+    default_value_type: str
+    expected_value_type: str
+
+    def message(self) -> str:
+        message = (
+            f"Default value for property {self.property_id} is of type {self.default_value_type} "
+            f"which is different from the expected value type {self.expected_value_type}!"
+        )
+        message += f"\nDescription: {self.description}"
+        return message
+
+
 @dataclass(frozen=True)
 class AssetRulesHaveCircularDependencyError(NeatValidationError):
     description = "Asset rules have circular dependencies."