cognite-neat 0.97.2__py3-none-any.whl → 0.98.0__py3-none-any.whl

cognite/neat/_rules/models/information/_validation.py

@@ -4,10 +4,9 @@ from typing import cast
 
 from cognite.neat._issues import IssueList
 from cognite.neat._issues.errors import NeatValueError, ResourceNotDefinedError
+from cognite.neat._issues.warnings._models import UndefinedClassWarning
 from cognite.neat._rules._constants import EntityTypes
-from cognite.neat._rules.models._base_rules import DataModelType, SchemaCompleteness
 from cognite.neat._rules.models.entities import ClassEntity, UnknownEntity
-from cognite.neat._utils.rdf_ import get_inheritance_path
 
 from ._rules import InformationRules
 
@@ -24,72 +23,60 @@ class InformationPostValidation:
         self.issue_list = IssueList()
 
     def validate(self) -> IssueList:
-        if self.metadata.schema_ == SchemaCompleteness.partial:
-            return self.issue_list
-
-        if self.metadata.data_model_type == DataModelType.solution and not self.rules.reference:
-            raise ValueError("Reference data model is missing")
-
-        if self.metadata.schema_ == SchemaCompleteness.extended and not self.rules.last:
-            raise ValueError("Last version is missing")
-
-        self._dangling_classes()
-        self._referenced_parent_classes_exist()
+        self._namespaces_reassigned()
+        self._classes_without_properties()
+        self._parent_class_defined()
         self._referenced_classes_exist()
         self._referenced_value_types_exist()
-        self._namespaces_reassigned()
 
         return self.issue_list
 
-    def _dangling_classes(self) -> None:
+    def _classes_without_properties(self) -> None:
         # needs to be complete for this validation to pass
         defined_classes = {class_.class_ for class_ in self.classes}
         referred_classes = {property_.class_ for property_ in self.properties}
         class_parent_pairs = self._class_parent_pairs()
-        dangling_classes = set()
 
         if classes_without_properties := defined_classes.difference(referred_classes):
             for class_ in classes_without_properties:
-                # USE CASE: class has no direct properties and no parents
-                if class_ not in class_parent_pairs:
-                    dangling_classes.add(class_)
                 # USE CASE: class has no direct properties and no parents with properties
-                elif class_ not in class_parent_pairs and not any(
-                    parent in referred_classes for parent in get_inheritance_path(class_, class_parent_pairs)
-                ):
-                    dangling_classes.add(class_)
-
-        for class_ in dangling_classes:
-            self.issue_list.append(
-                NeatValueError(f"Class {class_} has no properties and is not a parent of any class with properties")
-            )
+                # and it is a class in the prefix of data model, as long as it is in the
+                # same prefix, meaning same space
+                if not class_parent_pairs[class_] and class_.prefix == self.metadata.prefix:
+                    self.issue_list.append(
+                        ResourceNotDefinedError[ClassEntity](
+                            resource_type="class",
+                            identifier=class_,
+                            location="Classes sheet",
+                        )
+                    )
 
-    def _referenced_parent_classes_exist(self) -> None:
-        # needs to be complete for this validation to pass
+    def _parent_class_defined(self) -> None:
+        """This is a validation to check if the parent class of a class is defined in the classes sheet."""
         class_parent_pairs = self._class_parent_pairs()
         classes = set(class_parent_pairs.keys())
         parents = set(itertools.chain.from_iterable(class_parent_pairs.values()))
 
         if undefined_parents := parents.difference(classes):
             for parent in undefined_parents:
-                # Todo: include row and column number
-                self.issue_list.append(
-                    ResourceNotDefinedError[ClassEntity](
-                        resource_type="class",
-                        identifier=parent,
-                        location="Classes sheet",
+                if parent.prefix != self.metadata.prefix:
+                    self.issue_list.append(UndefinedClassWarning(class_id=str(parent)))
+                else:
+                    self.issue_list.append(
+                        ResourceNotDefinedError[ClassEntity](
+                            resource_type="class",
+                            identifier=parent,
+                            location="Classes sheet",
+                        )
                     )
-                )
 
     def _referenced_classes_exist(self) -> None:
         # needs to be complete for this validation to pass
         defined_classes = {class_.class_ for class_ in self.classes}
-        referred_classes = {property_.class_ for property_ in self.properties}
+        classes_with_explicit_properties = {property_.class_ for property_ in self.properties}
 
         # USE CASE: models are complete
-        if self.metadata.schema_ == SchemaCompleteness.complete and (
-            missing_classes := referred_classes.difference(defined_classes)
-        ):
+        if missing_classes := classes_with_explicit_properties.difference(defined_classes):
             for class_ in missing_classes:
                 self.issue_list.append(
                     ResourceNotDefinedError[ClassEntity](
@@ -99,19 +86,6 @@ class InformationPostValidation:
                     )
                 )
 
-        # USE CASE: models are extended (user + last = complete)
-        if self.metadata.schema_ == SchemaCompleteness.extended:
-            defined_classes |= {class_.class_ for class_ in cast(InformationRules, self.rules.last).classes}
-            if missing_classes := referred_classes.difference(defined_classes):
-                for class_ in missing_classes:
-                    self.issue_list.append(
-                        ResourceNotDefinedError[ClassEntity](
-                            resource_type="class",
-                            identifier=class_,
-                            location="Classes sheet",
-                        )
-                    )
-
     def _referenced_value_types_exist(self) -> None:
         # adding UnknownEntity to the set of defined classes to handle the case where a property references an unknown
         defined_classes = {class_.class_ for class_ in self.classes} | {UnknownEntity()}
@@ -121,10 +95,7 @@ class InformationPostValidation:
             if property_.type_ == EntityTypes.object_property
         }
 
-        # USE CASE: models are complete
-        if self.metadata.schema_ == SchemaCompleteness.complete and (
-            missing_value_types := referred_object_types.difference(defined_classes)
-        ):
+        if missing_value_types := referred_object_types.difference(defined_classes):
             # Todo: include row and column number
             for missing in missing_value_types:
                 self.issue_list.append(
@@ -135,56 +106,17 @@ class InformationPostValidation:
                     )
                 )
 
-        # USE CASE: models are extended (user + last = complete)
-        if self.metadata.schema_ == SchemaCompleteness.extended:
-            defined_classes |= {class_.class_ for class_ in cast(InformationRules, self.rules.last).classes}
-            if missing_value_types := referred_object_types.difference(defined_classes):
-                # Todo: include row and column number
-                for missing in missing_value_types:
-                    self.issue_list.append(
-                        ResourceNotDefinedError(
-                            resource_type="class",
-                            identifier=cast(ClassEntity, missing),
-                            location="Classes sheet",
-                        )
-                    )
-
     def _class_parent_pairs(self) -> dict[ClassEntity, list[ClassEntity]]:
-        class_subclass_pairs: dict[ClassEntity, list[ClassEntity]] = {}
-
+        class_parent_pairs: dict[ClassEntity, list[ClassEntity]] = {}
         classes = self.rules.model_copy(deep=True).classes
 
-        # USE CASE: Solution model being extended (user + last + reference = complete)
-        if (
-            self.metadata.schema_ == SchemaCompleteness.extended
-            and self.metadata.data_model_type == DataModelType.solution
-        ):
-            classes += (
-                cast(InformationRules, self.rules.last).model_copy(deep=True).classes
-                + cast(InformationRules, self.rules.reference).model_copy(deep=True).classes
-            )
-
-        # USE CASE: Solution model being created from scratch (user + reference = complete)
-        elif (
-            self.metadata.schema_ == SchemaCompleteness.complete
-            and self.metadata.data_model_type == DataModelType.solution
-        ):
-            classes += cast(InformationRules, self.rules.reference).model_copy(deep=True).classes
-
-        # USE CASE: Enterprise model being extended (user + last = complete)
-        elif (
-            self.metadata.schema_ == SchemaCompleteness.extended
-            and self.metadata.data_model_type == DataModelType.enterprise
-        ):
-            classes += cast(InformationRules, self.rules.last).model_copy(deep=True).classes
-
         for class_ in classes:
-            class_subclass_pairs[class_.class_] = []
-            if class_.parent is None:
+            class_parent_pairs[class_.class_] = []
+            if class_.implements is None:
                 continue
-            class_subclass_pairs[class_.class_].extend(class_.parent)
+            class_parent_pairs[class_.class_].extend(class_.implements)
 
-        return class_subclass_pairs
+        return class_parent_pairs
 
     def _namespaces_reassigned(self) -> None:
         prefixes = self.rules.prefixes.copy()

cognite/neat/_rules/transformers/__init__.py

@@ -1,9 +1,7 @@
 from ._base import RulesPipeline, RulesTransformer
 from ._converters import (
-    AssetToInformation,
     ConvertToRules,
     DMSToInformation,
-    InformationToAsset,
     InformationToDMS,
     ReduceCogniteModel,
     SetIDDMSModel,
@@ -12,7 +10,7 @@ from ._converters import (
 )
 from ._mapping import MapOneToOne, RuleMapper
 from ._pipelines import ImporterPipeline
-from ._verification import VerifyAnyRules, VerifyAssetRules, VerifyDMSRules, VerifyInformationRules
+from ._verification import VerifyAnyRules, VerifyDMSRules, VerifyInformationRules
 
 __all__ = [
     "ImporterPipeline",
@@ -23,7 +21,6 @@ __all__ = [
     "ConvertToRules",
     "AssetToInformation",
     "DMSToInformation",
-    "VerifyAssetRules",
     "VerifyDMSRules",
     "VerifyInformationRules",
     "VerifyAnyRules",