cognite-neat 0.121.1__py3-none-any.whl → 0.121.2__py3-none-any.whl

cognite/neat/core/_data_model/models/conceptual/__init__.py

@@ -1,24 +1,24 @@
 from ._unverified import (
-    UnverifiedConceptualClass,
+    UnverifiedConcept,
     UnverifiedConceptualDataModel,
     UnverifiedConceptualMetadata,
     UnverifiedConceptualProperty,
 )
-from ._validation import InformationValidation
+from ._validation import ConceptualValidation
 from ._verified import (
-    ConceptualClass,
+    Concept,
     ConceptualDataModel,
     ConceptualMetadata,
     ConceptualProperty,
 )
 
 __all__ = [
-    "ConceptualClass",
+    "Concept",
     "ConceptualDataModel",
     "ConceptualMetadata",
     "ConceptualProperty",
-    "InformationValidation",
-    "UnverifiedConceptualClass",
+    "ConceptualValidation",
+    "UnverifiedConcept",
     "UnverifiedConceptualDataModel",
     "UnverifiedConceptualMetadata",
     "UnverifiedConceptualProperty",

cognite/neat/core/_data_model/models/conceptual/_unverified.py

@@ -13,7 +13,7 @@ from cognite.neat.core._data_model.models._base_unverified import (
 )
 from cognite.neat.core._data_model.models.data_types import DataType
 from cognite.neat.core._data_model.models.entities import (
-    ClassEntity,
+    ConceptEntity,
     MultiValueTypeInfo,
     UnknownEntity,
     load_value_type,
@@ -21,7 +21,7 @@ from cognite.neat.core._data_model.models.entities import (
 from cognite.neat.core._utils.rdf_ import uri_display_name
 
 from ._verified import (
-    ConceptualClass,
+    Concept,
     ConceptualDataModel,
     ConceptualMetadata,
     ConceptualProperty,
@@ -68,7 +68,7 @@ class UnverifiedConceptualMetadata(UnverifiedComponent[ConceptualMetadata]):
             Unlike namespace, the identifier does not end with "/" or "#".
 
         """
-        return DEFAULT_NAMESPACE[f"data-model/unverified/logical/{self.space}/{self.external_id}/{self.version}"]
+        return DEFAULT_NAMESPACE[f"data-model/unverified/conceptual/{self.space}/{self.external_id}/{self.version}"]
 
     @property
     def namespace(self) -> Namespace:
@@ -78,9 +78,9 @@ class UnverifiedConceptualMetadata(UnverifiedComponent[ConceptualMetadata]):
 
 @dataclass
 class UnverifiedConceptualProperty(UnverifiedComponent[ConceptualProperty]):
-    class_: ClassEntity | str
+    concept: ConceptEntity | str
     property_: str
-    value_type: DataType | ClassEntity | MultiValueTypeInfo | UnknownEntity | str
+    value_type: DataType | ConceptEntity | MultiValueTypeInfo | UnknownEntity | str
     name: str | None = None
     description: str | None = None
     min_count: int | None = None
@@ -100,7 +100,7 @@ class UnverifiedConceptualProperty(UnverifiedComponent[ConceptualProperty]):
 
     def dump(self, default_prefix: str, **kwargs) -> dict[str, Any]:  # type: ignore
         output = super().dump()
-        output["Class"] = ClassEntity.load(self.class_, prefix=default_prefix)
+        output["Concept"] = ConceptEntity.load(self.concept, prefix=default_prefix)
         output["Value Type"] = load_value_type(self.value_type, default_prefix)
         return output
 
@@ -112,33 +112,33 @@ class UnverifiedConceptualProperty(UnverifiedComponent[ConceptualProperty]):
 
 
 @dataclass
-class UnverifiedConceptualClass(UnverifiedComponent[ConceptualClass]):
-    class_: ClassEntity | str
+class UnverifiedConcept(UnverifiedComponent[Concept]):
+    concept: ConceptEntity | str
     name: str | None = None
     description: str | None = None
-    implements: str | list[ClassEntity] | None = None
+    implements: str | list[ConceptEntity] | None = None
     instance_source: str | None = None
     neatId: str | URIRef | None = None
     # linking
     physical: str | URIRef | None = None
 
     @classmethod
-    def _get_verified_cls(cls) -> type[ConceptualClass]:
-        return ConceptualClass
+    def _get_verified_cls(cls) -> type[Concept]:
+        return Concept
 
     @property
-    def class_str(self) -> str:
-        return str(self.class_)
+    def concept_str(self) -> str:
+        return str(self.concept)
 
     def dump(self, default_prefix: str, **kwargs) -> dict[str, Any]:  # type: ignore
         output = super().dump()
-        parent: list[ClassEntity] | None = None
+        parent: list[ConceptEntity] | None = None
         if isinstance(self.implements, str):
             self.implements = self.implements.strip()
-            parent = [ClassEntity.load(parent, prefix=default_prefix) for parent in self.implements.split(",")]
+            parent = [ConceptEntity.load(parent, prefix=default_prefix) for parent in self.implements.split(",")]
         elif isinstance(self.implements, list):
-            parent = [ClassEntity.load(parent_, prefix=default_prefix) for parent_ in self.implements]
-        output["Class"] = ClassEntity.load(self.class_, prefix=default_prefix)
+            parent = [ConceptEntity.load(parent_, prefix=default_prefix) for parent_ in self.implements]
+        output["Concept"] = ConceptEntity.load(self.concept, prefix=default_prefix)
         output["Implements"] = parent
         return output
 
@@ -147,7 +147,7 @@ class UnverifiedConceptualClass(UnverifiedComponent[ConceptualClass]):
 class UnverifiedConceptualDataModel(UnverifiedDataModel[ConceptualDataModel]):
     metadata: UnverifiedConceptualMetadata
     properties: list[UnverifiedConceptualProperty] = field(default_factory=list)
-    classes: list[UnverifiedConceptualClass] = field(default_factory=list)
+    concepts: list[UnverifiedConcept] = field(default_factory=list)
     prefixes: dict[str, Namespace] | None = None
 
     @classmethod
@@ -160,7 +160,7 @@ class UnverifiedConceptualDataModel(UnverifiedDataModel[ConceptualDataModel]):
         return dict(
             Metadata=self.metadata.dump(),
             Properties=[prop.dump(default_prefix) for prop in self.properties],
-            Classes=[class_.dump(default_prefix) for class_ in self.classes],
+            Concepts=[concept.dump(default_prefix) for concept in self.concepts],
             Prefixes=self.prefixes,
         )
 
@@ -180,7 +180,7 @@ class UnverifiedConceptualDataModel(UnverifiedDataModel[ConceptualDataModel]):
             "external_id": self.metadata.external_id,
             "space": self.metadata.space,
             "version": self.metadata.version,
-            "classes": len(self.classes),
+            "concepts": len(self.concepts),
             "properties": len(self.properties),
         }
 

cognite/neat/core/_data_model/models/conceptual/_validation.py

@@ -1,8 +1,9 @@
 import itertools
 from collections import Counter, defaultdict
+from collections.abc import Iterable
 
 from cognite.neat.core._data_model._constants import PATTERNS, EntityTypes
-from cognite.neat.core._data_model.models.entities import ClassEntity, UnknownEntity
+from cognite.neat.core._data_model.models.entities import ConceptEntity, UnknownEntity
 from cognite.neat.core._data_model.models.entities._multi_value import MultiValueTypeInfo
 from cognite.neat.core._issues import IssueList
 from cognite.neat.core._issues.errors import NeatValueError
@@ -10,7 +11,7 @@ from cognite.neat.core._issues.errors._resources import (
     ResourceDuplicatedError,
     ResourceNotDefinedError,
 )
-from cognite.neat.core._issues.warnings._models import UndefinedClassWarning
+from cognite.neat.core._issues.warnings._models import UndefinedConceptWarning
 from cognite.neat.core._issues.warnings._resources import (
     ResourceNotDefinedWarning,
     ResourceRegexViolationWarning,
@@ -18,23 +19,23 @@ from cognite.neat.core._issues.warnings._resources import (
 from cognite.neat.core._utils.spreadsheet import SpreadsheetRead
 from cognite.neat.core._utils.text import humanize_collection
 
-from ._verified import ConceptualDataModel
+from ._verified import ConceptualDataModel, ConceptualProperty
 
 
-class InformationValidation:
+class ConceptualValidation:
     """This class does all the validation of the Information rules that have dependencies
     between components."""
 
     def __init__(
         self,
-        rules: ConceptualDataModel,
+        data_model: ConceptualDataModel,
         read_info_by_spreadsheet: dict[str, SpreadsheetRead] | None = None,
     ):
-        self.rules = rules
+        self.data_model = data_model
         self._read_info_by_spreadsheet = read_info_by_spreadsheet or {}
-        self._metadata = rules.metadata
-        self._properties = rules.properties
-        self._classes = rules.classes
+        self._metadata = data_model.metadata
+        self._properties = data_model.properties
+        self._concepts = data_model.concepts
         self.issue_list = IssueList()
 
     def validate(self) -> IssueList:
@@ -42,7 +43,7 @@ class InformationValidation:
         self._namespaces_reassigned()
         self._classes_without_properties()
         self._undefined_classes()
-        self._parent_class_defined()
+        self._parent_concept_defined()
         self._referenced_classes_exist()
         self._referenced_value_types_exist()
         self._regex_compliance_with_dms()
@@ -51,7 +52,7 @@ class InformationValidation:
 
     def _duplicated_resources(self) -> None:
         properties_sheet = self._read_info_by_spreadsheet.get("Properties")
-        classes_sheet = self._read_info_by_spreadsheet.get("Classes")
+        concepts_sheet = self._read_info_by_spreadsheet.get("Concepts")
 
         visited = defaultdict(list)
         for row_no, property_ in enumerate(self._properties):
@@ -75,9 +76,9 @@ class InformationValidation:
             )
 
         visited = defaultdict(list)
-        for row_no, class_ in enumerate(self._classes):
-            visited[class_._identifier()].append(
-                classes_sheet.adjusted_row_number(row_no) if classes_sheet else row_no + 1
+        for row_no, concept in enumerate(self._concepts):
+            visited[concept._identifier()].append(
+                concepts_sheet.adjusted_row_number(row_no) if concepts_sheet else row_no + 1
             )
 
         for identifier, rows in visited.items():
@@ -86,85 +87,85 @@ class InformationValidation:
             self.issue_list.append(
                 ResourceDuplicatedError(
                     identifier[0],
-                    "class",
+                    "concept",
                     (f"the Classes sheet at row {humanize_collection(rows)} if data model is read from a spreadsheet."),
                 )
             )
 
     def _classes_without_properties(self) -> None:
-        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()
+        defined_concepts = {concept.concept for concept in self._concepts}
+        referred_classes = {property_.concept for property_ in self._properties}
+        concept_parent_pairs = self._concept_parent_pairs()
 
-        if classes_without_properties := defined_classes.difference(referred_classes):
-            for class_ in classes_without_properties:
+        if concepts_without_properties := defined_concepts.difference(referred_classes):
+            for concept in concepts_without_properties:
                 # USE CASE: class has no direct properties and no parents 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:
+                if not concept_parent_pairs[concept] and concept.prefix == self._metadata.prefix:
                     self.issue_list.append(
                         ResourceNotDefinedWarning(
-                            resource_type="class",
-                            identifier=class_,
+                            resource_type="concept",
+                            identifier=concept,
                             location="Properties sheet",
                         )
                     )
 
     def _undefined_classes(self) -> None:
-        defined_classes = {class_.class_ for class_ in self._classes}
-        referred_classes = {property_.class_ for property_ in self._properties}
+        defined_concept = {concept.concept for concept in self._concepts}
+        referred_concepts = {property_.concept for property_ in self._properties}
 
-        if undefined_classes := referred_classes.difference(defined_classes):
-            for class_ in undefined_classes:
+        if undefined_concepts := referred_concepts.difference(defined_concept):
+            for concept in undefined_concepts:
                 self.issue_list.append(
                     ResourceNotDefinedError(
-                        identifier=class_,
-                        resource_type="class",
-                        location="Classes sheet",
+                        identifier=concept,
+                        resource_type="concept",
+                        location="Concepts sheet",
                     )
                 )
 
-    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()))
+    def _parent_concept_defined(self) -> None:
+        """This is a validation to check if the parent concept is defined."""
+        concept_parent_pairs = self._concept_parent_pairs()
+        concepts = set(concept_parent_pairs.keys())
+        parents = set(itertools.chain.from_iterable(concept_parent_pairs.values()))
 
-        if undefined_parents := parents.difference(classes):
+        if undefined_parents := parents.difference(concepts):
             for parent in undefined_parents:
                 if parent.prefix != self._metadata.prefix:
-                    self.issue_list.append(UndefinedClassWarning(class_id=str(parent)))
+                    self.issue_list.append(UndefinedConceptWarning(concept_id=str(parent)))
                 else:
                     self.issue_list.append(
                         ResourceNotDefinedWarning(
-                            resource_type="class",
+                            resource_type="concept",
                             identifier=parent,
-                            location="Classes sheet",
+                            location="Concepts 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}
-        classes_with_explicit_properties = {property_.class_ for property_ in self._properties}
+        defined_concept = {concept.concept for concept in self._concepts}
+        classes_with_explicit_properties = {property_.concept for property_ in self._properties}
 
         # USE CASE: models are complete
-        if missing_classes := classes_with_explicit_properties.difference(defined_classes):
-            for class_ in missing_classes:
+        if missing_classes := classes_with_explicit_properties.difference(defined_concept):
+            for concept in missing_classes:
                 self.issue_list.append(
                     ResourceNotDefinedWarning(
-                        resource_type="class",
-                        identifier=class_,
-                        location="Classes sheet",
+                        resource_type="concept",
+                        identifier=concept,
+                        location="Concepts 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()}
+        defined_classes = {concept.concept for concept in self._concepts} | {UnknownEntity()}
         referred_object_types = {
             property_.value_type
-            for property_ in self.rules.properties
+            for property_ in self.data_model.properties
             if property_.type_ == EntityTypes.object_property
         }
 
@@ -173,9 +174,9 @@ class InformationValidation:
             for missing in missing_value_types:
                 self.issue_list.append(
                     ResourceNotDefinedWarning(
-                        resource_type="class",
+                        resource_type="concept",
                         identifier=missing,
-                        location="Classes sheet",
+                        location="Concepts sheet",
                     )
                 )
 
@@ -183,28 +184,28 @@ class InformationValidation:
         """Check regex compliance with DMS of properties, classes and value types."""
 
         for prop_ in self._properties:
-            if not PATTERNS.dms_property_id_compliance.match(prop_.property_):
+            if not PATTERNS.physical_property_id_compliance.match(prop_.property_):
                 self.issue_list.append(
                     ResourceRegexViolationWarning(
                         prop_.property_,
                         "Property",
                         "Properties sheet, Property column",
-                        PATTERNS.dms_property_id_compliance.pattern,
+                        PATTERNS.physical_property_id_compliance.pattern,
                     )
                 )
-            if not PATTERNS.view_id_compliance.match(prop_.class_.suffix):
+            if not PATTERNS.view_id_compliance.match(prop_.concept.suffix):
                 self.issue_list.append(
                     ResourceRegexViolationWarning(
-                        prop_.class_,
-                        "Class",
-                        "Properties sheet, Class column",
+                        prop_.concept,
+                        "Concept",
+                        "Properties sheet, Concept column",
                         PATTERNS.view_id_compliance.pattern,
                     )
                 )
 
             # Handling Value Type
             if (
-                isinstance(prop_.value_type, ClassEntity)
+                isinstance(prop_.value_type, ConceptEntity)
                 and prop_.value_type != UnknownEntity()
                 and not PATTERNS.view_id_compliance.match(prop_.value_type.suffix)
             ):
@@ -219,7 +220,7 @@ class InformationValidation:
             if isinstance(prop_.value_type, MultiValueTypeInfo):
                 for value_type in prop_.value_type.types:
                     if (
-                        isinstance(prop_.value_type, ClassEntity)
+                        isinstance(prop_.value_type, ConceptEntity)
                         and prop_.value_type != UnknownEntity()
                         and not PATTERNS.view_id_compliance.match(value_type.suffix)
                     ):
@@ -232,44 +233,44 @@ class InformationValidation:
                             )
                         )
 
-        for class_ in self._classes:
-            if not PATTERNS.view_id_compliance.match(class_.class_.suffix):
+        for concepts in self._concepts:
+            if not PATTERNS.view_id_compliance.match(concepts.concept.suffix):
                 self.issue_list.append(
                     ResourceRegexViolationWarning(
-                        class_.class_,
-                        "Class",
-                        "Classes sheet, Class column",
+                        concepts.concept,
+                        "Concept",
+                        "Concepts sheet, Class column",
                         PATTERNS.view_id_compliance.pattern,
                     )
                 )
 
-            if class_.implements:
-                for parent in class_.implements:
+            if concepts.implements:
+                for parent in concepts.implements:
                     if not PATTERNS.view_id_compliance.match(parent.suffix):
                         self.issue_list.append(
                             ResourceRegexViolationWarning(
                                 parent,
-                                "Class",
-                                "Classes sheet, Implements column",
+                                "Concept",
+                                "Concepts sheet, Implements column",
                                 PATTERNS.view_id_compliance.pattern,
                             )
                         )
 
-    def _class_parent_pairs(self) -> dict[ClassEntity, list[ClassEntity]]:
-        class_parent_pairs: dict[ClassEntity, list[ClassEntity]] = {}
-        classes = self.rules.model_copy(deep=True).classes
+    def _concept_parent_pairs(self) -> dict[ConceptEntity, list[ConceptEntity]]:
+        concept_parent_pairs: dict[ConceptEntity, list[ConceptEntity]] = {}
+        concepts = self.data_model.model_copy(deep=True).concepts
 
-        for class_ in classes:
-            class_parent_pairs[class_.class_] = []
-            if class_.implements is None:
+        for concept in concepts:
+            concept_parent_pairs[concept.concept] = []
+            if concept.implements is None:
                 continue
-            class_parent_pairs[class_.class_].extend(class_.implements)
+            concept_parent_pairs[concept.concept].extend(concept.implements)
 
-        return class_parent_pairs
+        return concept_parent_pairs
 
     def _namespaces_reassigned(self) -> None:
-        prefixes = self.rules.prefixes.copy()
-        prefixes[self.rules.metadata.namespace.prefix] = self.rules.metadata.namespace
+        prefixes = self.data_model.prefixes.copy()
+        prefixes[self.data_model.metadata.namespace.prefix] = self.data_model.metadata.namespace
 
         if len(set(prefixes.values())) != len(prefixes):
             reused_namespaces = [value for value, count in Counter(prefixes.values()).items() if count > 1]
@@ -282,3 +283,12 @@ class InformationValidation:
                     "\nMake sure that each unique namespace is assigned to a unique prefix"
                 )
             )
+
+
+def duplicated_properties(
+    properties: Iterable[ConceptualProperty],
+) -> dict[tuple[ConceptEntity, str], list[tuple[int, ConceptualProperty]]]:
+    concept_properties_by_id: dict[tuple[ConceptEntity, str], list[tuple[int, ConceptualProperty]]] = defaultdict(list)
+    for prop_no, prop in enumerate(properties):
+        concept_properties_by_id[(prop.concept, prop.property_)].append((prop_no, prop))
+    return {k: v for k, v in concept_properties_by_id.items() if len(v) > 1}