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

cognite/neat/core/{_rules/models/information → _data_model/models/conceptual}/_validation.py

@@ -1,36 +1,41 @@
 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 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
 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,
 )
-from cognite.neat.core._rules._constants import PATTERNS, EntityTypes
-from cognite.neat.core._rules.models.entities import ClassEntity, UnknownEntity
-from cognite.neat.core._rules.models.entities._multi_value import MultiValueTypeInfo
 from cognite.neat.core._utils.spreadsheet import SpreadsheetRead
 from cognite.neat.core._utils.text import humanize_collection
 
-from ._rules import InformationRules
+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: InformationRules, read_info_by_spreadsheet: dict[str, SpreadsheetRead] | None = None):
-        self.rules = rules
+    def __init__(
+        self,
+        data_model: ConceptualDataModel,
+        read_info_by_spreadsheet: dict[str, SpreadsheetRead] | None = None,
+    ):
+        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:
@@ -38,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()
@@ -47,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):
@@ -71,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():
@@ -82,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
         }
 
@@ -169,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",
                     )
                 )
 
@@ -179,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)
             ):
@@ -215,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)
                     ):
@@ -228,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]
@@ -278,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}

cognite/neat/core/{_rules/models/information/_rules.py → _data_model/models/conceptual/_verified.py}

@@ -8,63 +8,63 @@ from pydantic_core.core_schema import SerializationInfo
 from rdflib import Namespace, URIRef
 
 from cognite.neat.core._constants import get_default_prefixes_and_namespaces
-from cognite.neat.core._issues.errors import PropertyDefinitionError
-from cognite.neat.core._rules._constants import EntityTypes
-from cognite.neat.core._rules.models._base_rules import (
-    BaseMetadata,
-    BaseRules,
-    DataModelAspect,
+from cognite.neat.core._data_model._constants import EntityTypes
+from cognite.neat.core._data_model.models._base_verified import (
+    BaseVerifiedDataModel,
+    BaseVerifiedMetadata,
+    DataModelLevel,
     RoleTypes,
     SheetList,
     SheetRow,
 )
-from cognite.neat.core._rules.models._types import (
-    ClassEntityType,
-    InformationPropertyType,
+from cognite.neat.core._data_model.models._types import (
+    ConceptEntityType,
+    ConceptualPropertyType,
     MultiValueTypeType,
     URIRefType,
 )
 
 # NeatIdType,
-from cognite.neat.core._rules.models.data_types import DataType
-from cognite.neat.core._rules.models.entities import (
-    ClassEntity,
+from cognite.neat.core._data_model.models.data_types import DataType
+from cognite.neat.core._data_model.models.entities import (
     ClassEntityList,
-    Entity,
+    ConceptEntity,
+    ConceptualEntity,
     UnknownEntity,
 )
+from cognite.neat.core._issues.errors import PropertyDefinitionError
 
 if TYPE_CHECKING:
-    from cognite.neat.core._rules.models import DMSRules
+    from cognite.neat.core._data_model.models import PhysicalDataModel
 
 
-class InformationMetadata(BaseMetadata):
+class ConceptualMetadata(BaseVerifiedMetadata):
     role: ClassVar[RoleTypes] = RoleTypes.information
-    aspect: ClassVar[DataModelAspect] = DataModelAspect.logical
+    level: ClassVar[DataModelLevel] = DataModelLevel.conceptual
 
     # Linking to Conceptual and Physical data model aspects
     physical: URIRef | str | None = Field(None, description="Link to the physical data model aspect")
-    conceptual: URIRef | str | None = Field(None, description="Link to the conceptual data model aspect")
 
 
-def _get_metadata(context: Any) -> InformationMetadata | None:
-    if isinstance(context, dict) and isinstance(context.get("metadata"), InformationMetadata):
+def _get_metadata(context: Any) -> ConceptualMetadata | None:
+    if isinstance(context, dict) and isinstance(context.get("metadata"), ConceptualMetadata):
         return context["metadata"]
     return None
 
 
-class InformationClass(SheetRow):
+class Concept(SheetRow):
     """
-    Class is a category of things that share a common set of attributes and relationships.
+    Concept is a category of things that share a common set of attributes and relationships.
 
     Args:
-        class_: The class ID of the class.
+        concept: An ID of the concept.
         description: A description of the class.
         implements: Which classes the current class implements.
     """
 
-    class_: ClassEntityType = Field(
-        alias="Class", description="Class id being defined, use strongly advise `PascalCase` usage."
+    concept: ConceptEntityType = Field(
+        alias="Concept",
+        description="Concept id being defined, use strongly advise `PascalCase` usage.",
     )
     name: str | None = Field(alias="Name", default=None, description="Human readable name of the class.")
     description: str | None = Field(alias="Description", default=None, description="Short description of the class.")
@@ -82,14 +82,13 @@ class InformationClass(SheetRow):
         None,
         description="Link to the class representation in the physical data model aspect",
     )
-    conceptual: URIRefType | None = Field(None, description="Link to the conceptual data model aspect")
 
     def _identifier(self) -> tuple[Hashable, ...]:
-        return (self.class_,)
+        return (self.concept,)
 
-    @field_serializer("class_", when_used="unless-none")
+    @field_serializer("concept", when_used="unless-none")
     def remove_default_prefix(self, value: Any, info: SerializationInfo) -> str:
-        if (metadata := _get_metadata(info.context)) and isinstance(value, Entity):
+        if (metadata := _get_metadata(info.context)) and isinstance(value, ConceptualEntity):
             return value.dump(prefix=metadata.prefix, version=metadata.version)
         return str(value)
 
@@ -98,22 +97,22 @@ class InformationClass(SheetRow):
         if isinstance(value, list) and (metadata := _get_metadata(info.context)):
             return ",".join(
                 (
-                    class_.dump(prefix=metadata.prefix, version=metadata.version)
-                    if isinstance(class_, Entity)
-                    else str(class_)
+                    concept.dump(prefix=metadata.prefix, version=metadata.version)
+                    if isinstance(concept, ConceptualEntity)
+                    else str(concept)
                 )
-                for class_ in value
+                for concept in value
             )
         return ",".join(str(value) for value in value)
 
 
-class InformationProperty(SheetRow):
+class ConceptualProperty(SheetRow):
     """
-    A property is a characteristic of a class. It is a named attribute of a class that describes a range of values
-    or a relationship to another class.
+    A property is a characteristic of a concept. It is a named attribute of a concept
+    that describes a range of values or a relationship to another concept.
 
     Args:
-        class_: Class ID to which property belongs
+        concept: Concept ID to which property belongs
         property_: Property ID of the property
         name: Property name.
         value_type: Type of value property will hold (data or link to another class)
@@ -124,15 +123,17 @@ class InformationProperty(SheetRow):
               knowledge graph. Defaults to None (no transformation)
     """
 
-    class_: ClassEntityType = Field(
-        alias="Class", description="Class id that the property is defined for, strongly advise `PascalCase` usage."
+    concept: ConceptEntityType = Field(
+        alias="Concept",
+        description="Concept id that the property is defined for, strongly advise `PascalCase` usage.",
     )
-    property_: InformationPropertyType = Field(
-        alias="Property", description="Property id, strongly advised to `camelCase` usage."
+    property_: ConceptualPropertyType = Field(
+        alias="Property",
+        description="Property id, strongly advised to `camelCase` usage.",
     )
     name: str | None = Field(alias="Name", default=None, description="Human readable name of the property.")
     description: str | None = Field(alias="Description", default=None, description="Short description of the property.")
-    value_type: DataType | ClassEntityType | MultiValueTypeType | UnknownEntity = Field(
+    value_type: DataType | ConceptEntityType | MultiValueTypeType | UnknownEntity = Field(
         alias="Value Type",
         union_mode="left_to_right",
         description="Value type that the property can hold. It takes either subset of XSD type or a class defined.",
@@ -168,10 +169,9 @@ class InformationProperty(SheetRow):
         None,
         description="Link to the class representation in the physical data model aspect",
     )
-    conceptual: URIRefType | None = Field(None, description="Link to the conceptual data model aspect")
 
     def _identifier(self) -> tuple[Hashable, ...]:
-        return self.class_, self.property_
+        return self.concept, self.property_
 
     @field_validator("max_count", mode="before")
     def parse_max_count(cls, value: int | float | None) -> int | float | None:
@@ -203,7 +203,7 @@ class InformationProperty(SheetRow):
                 # this value_type.python does not seems correct. Need to check this further
                 except Exception:
                     raise PropertyDefinitionError(
-                        self.class_,
+                        self.concept,
                         "Class",
                         self.property_,
                         f"Default value {self.default} is not of type {self.value_type.python}",  # type: ignore
@@ -222,9 +222,9 @@ class InformationProperty(SheetRow):
             return None
         return value
 
-    @field_serializer("class_", "value_type", when_used="unless-none")
+    @field_serializer("concept", "value_type", when_used="unless-none")
     def remove_default_prefix(self, value: Any, info: SerializationInfo) -> str:
-        if (metadata := _get_metadata(info.context)) and isinstance(value, Entity):
+        if (metadata := _get_metadata(info.context)) and isinstance(value, ConceptualEntity):
             return value.dump(prefix=metadata.prefix, version=metadata.version)
         return str(value)
 
@@ -233,20 +233,20 @@ class InformationProperty(SheetRow):
         """Type of property based on value type. Either data (attribute) or object (edge) property."""
         if isinstance(self.value_type, DataType):
             return EntityTypes.data_property
-        elif isinstance(self.value_type, ClassEntity):
+        elif isinstance(self.value_type, ConceptEntity):
             return EntityTypes.object_property
         else:
             return EntityTypes.undefined
 
 
-class InformationRules(BaseRules):
-    metadata: InformationMetadata = Field(alias="Metadata", description="Metadata for the logical data model")
-    properties: SheetList[InformationProperty] = Field(alias="Properties", description="List of properties")
-    classes: SheetList[InformationClass] = Field(alias="Classes", description="List of classes")
+class ConceptualDataModel(BaseVerifiedDataModel):
+    metadata: ConceptualMetadata = Field(alias="Metadata", description="Metadata for the conceptual data model")
+    properties: SheetList[ConceptualProperty] = Field(alias="Properties", description="List of properties")
+    concepts: SheetList[Concept] = Field(alias="Concepts", description="List of concepts")
     prefixes: dict[str, Namespace] = Field(
         alias="Prefixes",
         default_factory=get_default_prefixes_and_namespaces,
-        description="the definition of the prefixes that are used in the semantic data model",
+        description="the definition of the prefixes that are used in the conceptual data model",
     )
 
     @field_validator("prefixes", mode="before")
@@ -258,15 +258,15 @@ class InformationRules(BaseRules):
         return values
 
     @model_validator(mode="after")
-    def set_neat_id(self) -> "InformationRules":
+    def set_neat_id(self) -> "ConceptualDataModel":
         namespace = self.metadata.namespace
 
-        for class_ in self.classes:
-            if not class_.neatId:
-                class_.neatId = namespace[class_.class_.suffix]
+        for concept in self.concepts:
+            if not concept.neatId:
+                concept.neatId = namespace[concept.concept.suffix]
         for property_ in self.properties:
             if not property_.neatId:
-                property_.neatId = namespace[f"{property_.class_.suffix}/{property_.property_}"]
+                property_.neatId = namespace[f"{property_.concept.suffix}/{property_.property_}"]
 
         return self
 
@@ -275,50 +275,50 @@ class InformationRules(BaseRules):
 
         namespace = self.metadata.namespace
 
-        for class_ in self.classes:
-            class_.neatId = namespace[class_.class_.suffix]
+        for concept in self.concepts:
+            concept.neatId = namespace[concept.concept.suffix]
         for property_ in self.properties:
-            property_.neatId = namespace[f"{property_.class_.suffix}/{property_.property_}"]
+            property_.neatId = namespace[f"{property_.concept.suffix}/{property_.property_}"]
 
-    def sync_with_dms_rules(self, dms_rules: "DMSRules") -> None:
+    def sync_with_physical_data_model(self, physical_data_model: "PhysicalDataModel") -> None:
         # Sync at the metadata level
-        if dms_rules.metadata.logical == self.metadata.identifier:
-            self.metadata.physical = dms_rules.metadata.identifier
+        if physical_data_model.metadata.conceptual == self.metadata.identifier:
+            self.metadata.physical = physical_data_model.metadata.identifier
         else:
             # if models are not linked to start with, we skip
             return None
 
-        info_properties_by_neat_id = {prop.neatId: prop for prop in self.properties}
-        dms_properties_by_neat_id = {prop.neatId: prop for prop in dms_rules.properties}
-        for neat_id, prop in dms_properties_by_neat_id.items():
-            if prop.logical in info_properties_by_neat_id:
-                info_properties_by_neat_id[prop.logical].physical = neat_id
-
-        info_classes_by_neat_id = {cls.neatId: cls for cls in self.classes}
-        dms_views_by_neat_id = {view.neatId: view for view in dms_rules.views}
-        for neat_id, view in dms_views_by_neat_id.items():
-            if view.logical in info_classes_by_neat_id:
-                info_classes_by_neat_id[view.logical].physical = neat_id
-
-    def as_dms_rules(self) -> "DMSRules":
-        from cognite.neat.core._rules.transformers._converters import (
-            _InformationRulesConverter,
+        conceptual_properties_by_neat_id = {prop.neatId: prop for prop in self.properties}
+        physical_properties_by_neat_id = {prop.neatId: prop for prop in physical_data_model.properties}
+        for neat_id, prop in physical_properties_by_neat_id.items():
+            if prop.conceptual in conceptual_properties_by_neat_id:
+                conceptual_properties_by_neat_id[prop.conceptual].physical = neat_id
+
+        classes_by_neat_id = {cls.neatId: cls for cls in self.concepts}
+        views_by_neat_id = {view.neatId: view for view in physical_data_model.views}
+        for neat_id, view in views_by_neat_id.items():
+            if view.conceptual in classes_by_neat_id:
+                classes_by_neat_id[view.conceptual].physical = neat_id
+
+    def as_dms_rules(self) -> "PhysicalDataModel":
+        from cognite.neat.core._data_model.transformers._converters import (
+            _ConceptualDataModelConverter,
         )
 
-        return _InformationRulesConverter(self).as_dms_rules()
+        return _ConceptualDataModelConverter(self).as_physical_data_model()
 
     @classmethod
     def display_type_name(cls) -> str:
-        return "VerifiedInformationModel"
+        return "VerifiedConceptualDataModel"
 
     def _repr_html_(self) -> str:
         summary = {
-            "type": "Logical Data Model",
-            "intended for": "Information Architect",
+            "level": self.metadata.level,
+            "intended for": "Domain Expert and/or Information Architect",
             "name": self.metadata.name,
             "external_id": self.metadata.external_id,
             "version": self.metadata.version,
-            "classes": len(self.classes),
+            "concepts": len(self.concepts),
             "properties": len(self.properties),
         }