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

cognite/neat/core/{_rules → _data_model}/transformers/_mapping.py

@@ -6,25 +6,29 @@ from typing import Any, ClassVar, Literal
 from cognite.client import data_modeling as dm
 
 from cognite.neat.core._client import NeatClient
+from cognite.neat.core._data_model.models import PhysicalDataModel, SheetList
+from cognite.neat.core._data_model.models.data_types import Enum
+from cognite.neat.core._data_model.models.entities import (
+    ConceptEntity,
+    ContainerEntity,
+    ViewEntity,
+)
+from cognite.neat.core._data_model.models.physical import (
+    PhysicalContainer,
+    PhysicalEnum,
+    PhysicalProperty,
+)
 from cognite.neat.core._issues.errors import (
     CDFMissingClientError,
     NeatValueError,
     ResourceNotFoundError,
 )
 from cognite.neat.core._issues.warnings import PropertyOverwritingWarning
-from cognite.neat.core._rules.models import DMSRules, SheetList
-from cognite.neat.core._rules.models.data_types import Enum
-from cognite.neat.core._rules.models.dms import DMSContainer, DMSEnum, DMSProperty
-from cognite.neat.core._rules.models.entities import (
-    ClassEntity,
-    ContainerEntity,
-    ViewEntity,
-)
 
-from ._base import VerifiedRulesTransformer
+from ._base import VerifiedDataModelTransformer
 
 
-class MapOntoTransformers(VerifiedRulesTransformer[DMSRules, DMSRules], ABC):
+class MapOntoTransformers(VerifiedDataModelTransformer[PhysicalDataModel, PhysicalDataModel], ABC):
     """Base class for transformers that map one rule onto another."""
 
     ...
@@ -33,7 +37,7 @@ class MapOntoTransformers(VerifiedRulesTransformer[DMSRules, DMSRules], ABC):
 class MapOneToOne(MapOntoTransformers):
     """Takes transform data models and makes it into an extension of the reference data model.
 
-    Note this transformer mutates the input rules.
+    Note this transformer mutates the input data model.
 
     The argument view_extension_mapping is a dictionary where the keys are views of this data model,
     and each value is the view of the reference data model that the view should extend. For example:
@@ -55,14 +59,17 @@ class MapOneToOne(MapOntoTransformers):
     """
 
     def __init__(
-        self, reference: DMSRules, view_extension_mapping: dict[str, str], default_extension: str | None = None
+        self,
+        reference: PhysicalDataModel,
+        view_extension_mapping: dict[str, str],
+        default_extension: str | None = None,
     ) -> None:
         self.reference = reference
         self.view_extension_mapping = view_extension_mapping
         self.default_extension = default_extension
 
-    def transform(self, rules: DMSRules) -> DMSRules:
-        solution: DMSRules = rules
+    def transform(self, data_model: PhysicalDataModel) -> PhysicalDataModel:
+        solution: PhysicalDataModel = data_model
         view_by_external_id = {view.view.external_id: view for view in solution.views}
         ref_view_by_external_id = {view.view.external_id: view for view in self.reference.views}
 
@@ -73,11 +80,11 @@ class MapOneToOne(MapOntoTransformers):
         if self.default_extension and self.default_extension not in ref_view_by_external_id:
             raise ValueError(f"Default extension view not in the reference data model {self.default_extension}")
 
-        properties_by_view_external_id: dict[str, dict[str, DMSProperty]] = defaultdict(dict)
+        properties_by_view_external_id: dict[str, dict[str, PhysicalProperty]] = defaultdict(dict)
         for prop in solution.properties:
             properties_by_view_external_id[prop.view.external_id][prop.view_property] = prop
 
-        ref_properties_by_view_external_id: dict[str, dict[str, DMSProperty]] = defaultdict(dict)
+        ref_properties_by_view_external_id: dict[str, dict[str, PhysicalProperty]] = defaultdict(dict)
         for prop in self.reference.properties:
             ref_properties_by_view_external_id[prop.view.external_id][prop.view_property] = prop
 
@@ -108,14 +115,15 @@ class MapOneToOne(MapOntoTransformers):
         return solution
 
 
-class RuleMapper(VerifiedRulesTransformer[DMSRules, DMSRules]):
+class PhysicalDataModelMapper(VerifiedDataModelTransformer[PhysicalDataModel, PhysicalDataModel]):
     """Maps properties and classes using the given mapping.
 
     Args:
-        mapping: The mapping to use represented as a DMSRules object.
+        mapping: The mapping to use represented as a physical data model object.
         data_type_conflict: How to handle data type conflicts. The default is "overwrite".
             A data type conflicts occurs when the data type of a property in the mapping is different from the
-            data type of the property in the input rules. If "overwrite" the data type in the input rules is overwritten
+            data type of the property in the input data model. If "overwrite" the data type
+            in the input data model is overwritten
             with the data type in the mapping.
     """
 
@@ -123,37 +131,41 @@ class RuleMapper(VerifiedRulesTransformer[DMSRules, DMSRules]):
         ["connection", "value_type", "min_count", "immutable", "max_count", "default", "index", "constraint"]
     )
 
-    def __init__(self, mapping: DMSRules, data_type_conflict: Literal["overwrite"] = "overwrite") -> None:
+    def __init__(
+        self,
+        mapping: PhysicalDataModel,
+        data_type_conflict: Literal["overwrite"] = "overwrite",
+    ) -> None:
         self.mapping = mapping
         self.data_type_conflict = data_type_conflict
 
-    def transform(self, rules: DMSRules) -> DMSRules:
+    def transform(self, data_model: PhysicalDataModel) -> PhysicalDataModel:
         if self.data_type_conflict != "overwrite":
             raise NeatValueError(f"Invalid data_type_conflict: {self.data_type_conflict}")
-        input_rules = rules
-        new_rules = input_rules.model_copy(deep=True)
+        input_data_model = data_model
+        new_data_model = input_data_model.model_copy(deep=True)
 
-        views_by_external_id = {view.view.external_id: view for view in new_rules.views}
+        views_by_external_id = {view.view.external_id: view for view in new_data_model.views}
         new_views: set[ViewEntity] = set()
         for mapping_view in self.mapping.views:
             if existing_view := views_by_external_id.get(mapping_view.view.external_id):
                 existing_view.implements = mapping_view.implements
             else:
-                # We need to add all the views in the mapping that are not in the input rules.
-                # This is to ensure that all ValueTypes are present in the resulting rules.
+                # We need to add all the views in the mapping that are not in the input data model.
+                # This is to ensure that all ValueTypes are present in the resulting data model.
                 # For example, if a property is a direct relation to an Equipment view, we need to add
-                # the Equipment view to the rules.
-                new_rules.views.append(mapping_view)
+                # the Equipment view to the data model.
+                new_data_model.views.append(mapping_view)
                 new_views.add(mapping_view.view)
 
         properties_by_view_property = {
-            (prop.view.external_id, prop.view_property): prop for prop in new_rules.properties
+            (prop.view.external_id, prop.view_property): prop for prop in new_data_model.properties
         }
-        existing_enum_collections = {item.collection for item in new_rules.enum or []}
-        mapping_enums_by_collection: dict[ClassEntity, list[DMSEnum]] = defaultdict(list)
+        existing_enum_collections = {item.collection for item in new_data_model.enum or []}
+        mapping_enums_by_collection: dict[ConceptEntity, list[PhysicalEnum]] = defaultdict(list)
         for item in self.mapping.enum or []:
             mapping_enums_by_collection[item.collection].append(item)
-        existing_containers = {container.container for container in new_rules.containers or []}
+        existing_containers = {container.container for container in new_data_model.containers or []}
         mapping_containers_by_id = {container.container: container for container in self.mapping.containers or []}
         for mapping_prop in self.mapping.properties:
             if existing_prop := properties_by_view_property.get(
@@ -163,7 +175,10 @@ class RuleMapper(VerifiedRulesTransformer[DMSRules, DMSRules]):
                 if conflicts and self.data_type_conflict == "overwrite":
                     warnings.warn(
                         PropertyOverwritingWarning(
-                            existing_prop.view.as_id(), "view", existing_prop.view_property, tuple(conflicts)
+                            existing_prop.view.as_id(),
+                            "view",
+                            existing_prop.view_property,
+                            tuple(conflicts),
                         ),
                         stacklevel=2,
                     )
@@ -177,24 +192,24 @@ class RuleMapper(VerifiedRulesTransformer[DMSRules, DMSRules]):
                 existing_prop.container = mapping_prop.container
                 existing_prop.container_property = mapping_prop.container_property
             elif isinstance(mapping_prop.value_type, ViewEntity):
-                # All connections must be included in the rules. This is to update the
+                # All connections must be included in the data model. This is to update the
                 # ValueTypes of the implemented views.
-                new_rules.properties.append(mapping_prop)
+                new_data_model.properties.append(mapping_prop)
             elif "guid" in mapping_prop.view_property.casefold():
                 # All guid properties are included. Theses are necessary to get an appropriate
                 # filter on the resulting view.
-                new_rules.properties.append(mapping_prop)
+                new_data_model.properties.append(mapping_prop)
             else:
-                # Skipping mapped properties that are not in the input rules.
+                # Skipping mapped properties that are not in the input data model.
                 continue
 
             if (
                 isinstance(mapping_prop.value_type, Enum)
                 and mapping_prop.value_type.collection not in existing_enum_collections
             ):
-                if not new_rules.enum:
-                    new_rules.enum = SheetList[DMSEnum]([])
-                new_rules.enum.extend(mapping_enums_by_collection[mapping_prop.value_type.collection])
+                if not new_data_model.enum:
+                    new_data_model.enum = SheetList[PhysicalEnum]([])
+                new_data_model.enum.extend(mapping_enums_by_collection[mapping_prop.value_type.collection])
 
             if (
                 mapping_prop.container
@@ -202,13 +217,15 @@ class RuleMapper(VerifiedRulesTransformer[DMSRules, DMSRules]):
                 and (new_container := mapping_containers_by_id.get(mapping_prop.container))
             ):
                 # Mapping can include new containers for GUID properties
-                if not new_rules.containers:
-                    new_rules.containers = SheetList[DMSContainer]([])
-                new_rules.containers.append(new_container)
+                if not new_data_model.containers:
+                    new_data_model.containers = SheetList[PhysicalContainer]([])
+                new_data_model.containers.append(new_container)
 
-        return new_rules
+        return new_data_model
 
-    def _find_overwrites(self, prop: DMSProperty, mapping_prop: DMSProperty) -> tuple[dict[str, Any], list[str]]:
+    def _find_overwrites(
+        self, prop: PhysicalProperty, mapping_prop: PhysicalProperty
+    ) -> tuple[dict[str, Any], list[str]]:
         """Finds the properties that need to be overwritten and returns them.
 
         In addition, conflicting properties are returned. Note that overwriting properties that are
@@ -240,7 +257,7 @@ class RuleMapper(VerifiedRulesTransformer[DMSRules, DMSRules]):
         return f"Mapping to {self.mapping.metadata.as_data_model_id()!r}."
 
 
-class AsParentPropertyId(VerifiedRulesTransformer[DMSRules, DMSRules]):
+class AsParentPropertyId(VerifiedDataModelTransformer[PhysicalDataModel, PhysicalDataModel]):
     """Looks up all view properties that map to the same container property,
     and changes the child view property id to match the parent property id.
     """
@@ -248,34 +265,36 @@ class AsParentPropertyId(VerifiedRulesTransformer[DMSRules, DMSRules]):
     def __init__(self, client: NeatClient | None = None) -> None:
         self._client = client
 
-    def transform(self, rules: DMSRules) -> DMSRules:
-        input_rules = rules
-        new_rules = input_rules.model_copy(deep=True)
+    def transform(self, data_model: PhysicalDataModel) -> PhysicalDataModel:
+        input_data_model = data_model
+        new_data_model = input_data_model.model_copy(deep=True)
 
-        path_by_view = self._inheritance_path_by_view(new_rules)
-        view_by_container_property = self._view_by_container_properties(new_rules)
+        path_by_view = self._inheritance_path_by_view(new_data_model)
+        view_by_container_property = self._view_by_container_properties(new_data_model)
 
         parent_view_property_by_container_property = self._get_parent_view_property_by_container_property(
             path_by_view, view_by_container_property
         )
 
-        for prop in new_rules.properties:
+        for prop in new_data_model.properties:
             if prop.container and prop.container_property:
                 if parent_name := parent_view_property_by_container_property.get(
                     (prop.container, prop.container_property)
                 ):
                     prop.view_property = parent_name
 
-        return new_rules
+        return new_data_model
 
     # Todo: Move into Probe class. Note this means that the Probe class must take a NeatClient as an argument.
-    def _inheritance_path_by_view(self, rules: DMSRules) -> dict[ViewEntity, list[ViewEntity]]:
-        parents_by_view: dict[ViewEntity, list[ViewEntity]] = {view.view: view.implements or [] for view in rules.views}
+    def _inheritance_path_by_view(self, data_model: PhysicalDataModel) -> dict[ViewEntity, list[ViewEntity]]:
+        parents_by_view: dict[ViewEntity, list[ViewEntity]] = {
+            view.view: view.implements or [] for view in data_model.views
+        }
 
         path_by_view: dict[ViewEntity, list[ViewEntity]] = {}
-        for view in rules.views:
+        for view in data_model.views:
             path_by_view[view.view] = self._get_inheritance_path(
-                view.view, parents_by_view, rules.metadata.as_data_model_id()
+                view.view, parents_by_view, data_model.metadata.as_data_model_id()
             )
         return path_by_view
 
@@ -312,13 +331,13 @@ class AsParentPropertyId(VerifiedRulesTransformer[DMSRules, DMSRules]):
         return inheritance_path
 
     def _view_by_container_properties(
-        self, rules: DMSRules
+        self, data_model: PhysicalDataModel
     ) -> dict[tuple[ContainerEntity, str], list[tuple[ViewEntity, str]]]:
         view_properties_by_container_properties: dict[tuple[ContainerEntity, str], list[tuple[ViewEntity, str]]] = (
             defaultdict(list)
         )
         view_with_properties: set[ViewEntity] = set()
-        for prop in rules.properties:
+        for prop in data_model.properties:
             if not prop.container or not prop.container_property:
                 continue
             view_properties_by_container_properties[(prop.container, prop.container_property)].append(
@@ -327,7 +346,7 @@ class AsParentPropertyId(VerifiedRulesTransformer[DMSRules, DMSRules]):
             view_with_properties.add(prop.view)
 
         # We need to look up all parent properties.
-        to_lookup = {view.view.as_id() for view in rules.views if view.view not in view_with_properties}
+        to_lookup = {view.view.as_id() for view in data_model.views if view.view not in view_with_properties}
         if to_lookup and self._client is None:
             raise CDFMissingClientError(
                 f"Views {to_lookup} are not in the data model. Please provide a client to lookup the views."

cognite/neat/core/_data_model/transformers/_verification.py

@@ -0,0 +1,120 @@
+from abc import ABC
+from typing import cast
+
+from cognite.neat.core._client import NeatClient
+from cognite.neat.core._data_model._shared import (
+    ImportedDataModel,
+    T_ImportedUnverifiedDataModel,
+    T_VerifiedDataModel,
+    VerifiedDataModel,
+)
+from cognite.neat.core._data_model.models import (
+    ConceptualDataModel,
+    PhysicalDataModel,
+    UnverifiedConceptualDataModel,
+    UnverifiedPhysicalDataModel,
+)
+from cognite.neat.core._data_model.models.conceptual import ConceptualValidation
+from cognite.neat.core._data_model.models.physical import PhysicalValidation
+from cognite.neat.core._issues import MultiValueError, catch_issues
+from cognite.neat.core._issues.errors import NeatTypeError, NeatValueError
+
+from ._base import DataModelTransformer
+
+
+class VerificationTransformer(DataModelTransformer[T_ImportedUnverifiedDataModel, T_VerifiedDataModel], ABC):
+    """Base class for all verification transformers."""
+
+    _data_model_cls: type[T_VerifiedDataModel]
+    _validation_cls: type
+
+    def __init__(self, validate: bool = True, client: NeatClient | None = None) -> None:
+        self.validate = validate
+        self._client = client
+
+    def transform(self, data_model: T_ImportedUnverifiedDataModel) -> T_VerifiedDataModel:
+        in_ = data_model.unverified_data_model
+        if in_ is None:
+            raise NeatValueError("Cannot verify rules. The reading of the rules failed.")
+        verified_data_model: T_VerifiedDataModel | None = None
+        # We need to catch issues as we use the error args to provide extra context for the errors/warnings
+        # For example, which row in the spreadsheet the error occurred.
+        with catch_issues(data_model.context) as issues:
+            data_model_cls = self._get_data_model_cls(data_model)
+            dumped = in_.dump()
+            verified_data_model = data_model_cls.model_validate(dumped)  # type: ignore[assignment]
+            if self.validate:
+                validation_cls = self._get_validation_cls(verified_data_model)  # type: ignore[arg-type]
+                if issubclass(validation_cls, PhysicalValidation):
+                    validation_issues = PhysicalValidation(
+                        cast(PhysicalDataModel, verified_data_model),
+                        self._client,
+                        data_model.context,
+                    ).validate()  # type: ignore[arg-type]
+                elif issubclass(validation_cls, ConceptualValidation):
+                    validation_issues = ConceptualValidation(verified_data_model, data_model.context).validate()  # type: ignore[arg-type]
+                else:
+                    raise NeatValueError("Unsupported rule type")
+                issues.extend(validation_issues)
+
+        # Raise issues which is expected to be handled outside of this method
+        issues.trigger_warnings()
+        if issues.has_errors:
+            raise MultiValueError(issues.errors)
+        if verified_data_model is None:
+            raise NeatValueError("Data model was not verified")
+        return verified_data_model
+
+    def _get_data_model_cls(self, in_: T_ImportedUnverifiedDataModel) -> type[T_VerifiedDataModel]:
+        return self._data_model_cls
+
+    def _get_validation_cls(self, data_model: T_VerifiedDataModel) -> type:
+        return self._validation_cls
+
+    @property
+    def description(self) -> str:
+        return "Verify data model"
+
+
+class VerifyPhysicalDataModel(
+    VerificationTransformer[ImportedDataModel[UnverifiedPhysicalDataModel], PhysicalDataModel]
+):
+    """Class to verify physical data model."""
+
+    _data_model_cls = PhysicalDataModel
+    _validation_cls = PhysicalValidation
+
+    def transform(self, data_model: ImportedDataModel[UnverifiedPhysicalDataModel]) -> PhysicalDataModel:
+        return super().transform(data_model)
+
+
+class VerifyConceptualDataModel(
+    VerificationTransformer[ImportedDataModel[UnverifiedConceptualDataModel], ConceptualDataModel]
+):
+    """Class to verify conceptual data model."""
+
+    _data_model_cls = ConceptualDataModel
+    _validation_cls = ConceptualValidation
+
+    def transform(self, data_model: ImportedDataModel[UnverifiedConceptualDataModel]) -> ConceptualDataModel:
+        return super().transform(data_model)
+
+
+class VerifyAnyDataModel(VerificationTransformer[T_ImportedUnverifiedDataModel, VerifiedDataModel]):
+    """Class to verify arbitrary data model"""
+
+    def _get_data_model_cls(self, in_: T_ImportedUnverifiedDataModel) -> type[VerifiedDataModel]:
+        if isinstance(in_.unverified_data_model, UnverifiedConceptualDataModel):
+            return ConceptualDataModel
+        elif isinstance(in_.unverified_data_model, UnverifiedPhysicalDataModel):
+            return PhysicalDataModel
+        else:
+            raise NeatTypeError(f"Unsupported data model type: {type(in_)}")
+
+    def _get_validation_cls(self, data_model: VerifiedDataModel) -> type:
+        if isinstance(data_model, ConceptualDataModel):
+            return ConceptualValidation
+        elif isinstance(data_model, PhysicalDataModel):
+            return PhysicalValidation
+        else:
+            raise NeatTypeError(f"Unsupported data model type: {type(data_model)}")

cognite/neat/core/{_graph → _instances}/extractors/_base.py

@@ -5,7 +5,7 @@ from typing import TYPE_CHECKING
 from rdflib import URIRef
 
 from cognite.neat.core._constants import DEFAULT_NAMESPACE
-from cognite.neat.core._rules.models import InformationRules
+from cognite.neat.core._data_model.models import ConceptualDataModel
 from cognite.neat.core._shared import Triple
 from cognite.neat.core._utils.auxiliary import class_html_doc
 
@@ -38,7 +38,7 @@ class KnowledgeGraphExtractor(BaseExtractor):
     """A knowledge graph extractor extracts triples with a schema"""
 
     @abstractmethod
-    def get_information_rules(self) -> InformationRules:
+    def get_conceptual_data_model(self) -> ConceptualDataModel:
         """Returns the information rules that the extractor uses."""
         raise NotImplementedError()
 

cognite/neat/core/{_graph → _instances}/extractors/_classic_cdf/_base.py

@@ -18,7 +18,7 @@ from rdflib import RDF, XSD, Literal, Namespace, URIRef
 from typing_extensions import Self
 
 from cognite.neat.core._constants import DEFAULT_NAMESPACE
-from cognite.neat.core._graph.extractors._base import BaseExtractor
+from cognite.neat.core._instances.extractors._base import BaseExtractor
 from cognite.neat.core._issues.errors import NeatValueError
 from cognite.neat.core._issues.warnings import CDFAuthWarning, NeatValueWarning
 from cognite.neat.core._shared import Triple

cognite/neat/core/{_graph → _instances}/extractors/_classic_cdf/_classic.py

@@ -14,12 +14,15 @@ from cognite.neat.core._constants import (
     DEFAULT_NAMESPACE,
     get_default_prefixes_and_namespaces,
 )
-from cognite.neat.core._graph.extractors._base import KnowledgeGraphExtractor
+from cognite.neat.core._data_model._shared import ImportedDataModel
+from cognite.neat.core._data_model.catalog import classic_model
+from cognite.neat.core._data_model.models import (
+    ConceptualDataModel,
+    UnverifiedConceptualDataModel,
+)
+from cognite.neat.core._instances.extractors._base import KnowledgeGraphExtractor
 from cognite.neat.core._issues.errors import NeatValueError, ResourceNotFoundError
 from cognite.neat.core._issues.warnings import CDFAuthWarning, NeatValueWarning
-from cognite.neat.core._rules._shared import ReadRules
-from cognite.neat.core._rules.catalog import classic_model
-from cognite.neat.core._rules.models import InformationInputRules, InformationRules
 from cognite.neat.core._shared import Triple
 from cognite.neat.core._utils.collection_ import chunker, iterate_progress_bar
 from cognite.neat.core._utils.rdf_ import remove_namespace_from_uri
@@ -205,15 +208,18 @@ class ClassicGraphExtractor(KnowledgeGraphExtractor):
 
         yield from self._extract_asset_parent_data_sets()
 
-    def get_information_rules(self) -> InformationRules:
+    def get_conceptual_data_model(self) -> ConceptualDataModel:
         # To avoid circular imports
-        from cognite.neat.core._rules.importers import ExcelImporter
+        from cognite.neat.core._data_model.importers import ExcelImporter
 
-        unverified = cast(ReadRules[InformationInputRules], ExcelImporter(classic_model).to_rules())
-        if unverified.rules is None:
+        unverified = cast(
+            ImportedDataModel[UnverifiedConceptualDataModel],
+            ExcelImporter(classic_model).to_data_model(),
+        )
+        if unverified.unverified_data_model is None:
             raise NeatValueError(f"Could not read the classic model rules from {classic_model}.")
 
-        verified = unverified.rules.as_verified_rules()
+        verified = unverified.unverified_data_model.as_verified_data_model()
         prefixes = get_default_prefixes_and_namespaces()
         instance_prefix: str | None = next((k for k, v in prefixes.items() if v == self._namespace), None)
         if instance_prefix is None:
@@ -228,8 +234,8 @@ class ClassicGraphExtractor(KnowledgeGraphExtractor):
             if is_snake_case:
                 prop_id = to_snake_case(prop_id)
             prop.instance_source = [self._namespace[prop_id]]
-        for cls_ in verified.classes:
-            cls_id = cls_.class_.suffix
+        for cls_ in verified.concepts:
+            cls_id = cls_.concept.suffix
             if is_snake_case:
                 cls_id = to_snake_case(cls_id)
             cls_.instance_source = self._namespace[cls_id]

cognite/neat/core/{_graph → _instances}/extractors/_dms_graph.py

@@ -7,18 +7,21 @@ from rdflib import Namespace, URIRef
 
 from cognite.neat.core._client import NeatClient
 from cognite.neat.core._constants import COGNITE_SPACES, DEFAULT_NAMESPACE
+from cognite.neat.core._data_model.importers import DMSImporter
+from cognite.neat.core._data_model.models import ConceptualDataModel, PhysicalDataModel
+from cognite.neat.core._data_model.models.conceptual import ConceptualProperty
+from cognite.neat.core._data_model.models.data_types import Json
+from cognite.neat.core._data_model.models.entities import UnknownEntity
+from cognite.neat.core._data_model.transformers import (
+    PhysicalToConceptual,
+    VerifyPhysicalDataModel,
+)
 from cognite.neat.core._issues import IssueList, NeatIssue, catch_warnings
 from cognite.neat.core._issues.warnings import (
     CDFAuthWarning,
     ResourceNotFoundWarning,
     ResourceRetrievalWarning,
 )
-from cognite.neat.core._rules.importers import DMSImporter
-from cognite.neat.core._rules.models import DMSRules, InformationRules
-from cognite.neat.core._rules.models.data_types import Json
-from cognite.neat.core._rules.models.entities import UnknownEntity
-from cognite.neat.core._rules.models.information import InformationProperty
-from cognite.neat.core._rules.transformers import DMSToInformation, VerifyDMSRules
 from cognite.neat.core._shared import Triple
 
 from ._base import KnowledgeGraphExtractor
@@ -47,8 +50,8 @@ class DMSGraphExtractor(KnowledgeGraphExtractor):
         self._str_to_ideal_type = str_to_ideal_type
 
         self._views: list[dm.View] | None = None
-        self._information_rules: InformationRules | None = None
-        self._dms_rules: DMSRules | None = None
+        self._conceptual_data_model: ConceptualDataModel | None = None
+        self._physical_data_model: PhysicalDataModel | None = None
 
     @classmethod
     def from_data_model_id(
@@ -164,32 +167,32 @@ class DMSGraphExtractor(KnowledgeGraphExtractor):
                     self._issues.append(ResourceNotFoundWarning(dm_view, "view", data_model_id, "data model"))
         return views
 
-    def get_information_rules(self) -> InformationRules:
-        """Returns the information rules that the extractor uses."""
-        if self._information_rules is None:
-            self._information_rules, self._dms_rules = self._create_rules()
-        return self._information_rules
+    def get_conceptual_data_model(self) -> ConceptualDataModel:
+        """Returns the conceptual data model that the extractor uses."""
+        if self._conceptual_data_model is None:
+            self._conceptual_data_model, self._physical_data_model = self._create_data_models()
+        return self._conceptual_data_model
 
-    def get_dms_rules(self) -> DMSRules:
-        """Returns the DMS rules that the extractor uses."""
-        if self._dms_rules is None:
-            self._information_rules, self._dms_rules = self._create_rules()
-        return self._dms_rules
+    def get_physical_data_model(self) -> PhysicalDataModel:
+        """Returns the physical data model that the extractor uses."""
+        if self._physical_data_model is None:
+            self._conceptual_data_model, self._physical_data_model = self._create_data_models()
+        return self._physical_data_model
 
     def get_issues(self) -> IssueList:
         """Returns the issues that occurred during the extraction."""
         return self._issues
 
-    def _create_rules(self) -> tuple[InformationRules, DMSRules]:
-        # The DMS and Information rules must be created together to link them property.
+    def _create_data_models(self) -> tuple[ConceptualDataModel, PhysicalDataModel]:
+        # The physical and conceptual data model must be created together to link them property.
         importer = DMSImporter.from_data_model(self._client, self._data_model)
-        unverified_dms = importer.to_rules()
-        if self._unpack_json and (dms_rules := unverified_dms.rules):
-            # Drop the JSON properties from the DMS rules as these are no longer valid.
+        imported_physical_data_model = importer.to_data_model()
+        if self._unpack_json and (unverified_physical_data_model := imported_physical_data_model.unverified_data_model):
+            # Drop the JSON properties from the physical data model as these are no longer valid.
             json_name = Json().name  # To avoid instantiating Json multiple times.
-            dms_rules.properties = [
+            unverified_physical_data_model.properties = [
                 prop
-                for prop in dms_rules.properties
+                for prop in unverified_physical_data_model.properties
                 if not (
                     (
                         isinstance(prop.value_type, Json)
@@ -202,23 +205,28 @@ class DMSGraphExtractor(KnowledgeGraphExtractor):
 
         with catch_warnings() as issues:
             # Any errors occur will be raised and caught outside the extractor.
-            verified_dms = VerifyDMSRules(client=self._client).transform(unverified_dms)
-            information_rules = DMSToInformation(self._namespace).transform(verified_dms)
+            verified_physical_data_model = VerifyPhysicalDataModel(client=self._client).transform(
+                imported_physical_data_model
+            )
+            verified_conceptual_data_model = PhysicalToConceptual(self._namespace).transform(
+                verified_physical_data_model
+            )
 
-        # We need to sync the metadata between the two rules, such that the `.sync_with_info_rules` method works.
-        information_rules.metadata.physical = verified_dms.metadata.identifier
-        verified_dms.metadata.logical = information_rules.metadata.identifier
-        verified_dms.sync_with_info_rules(information_rules)
+        # We need to sync the metadata between the two data model, such that the
+        # `.sync_with_conceptual_data_model` method works.
+        verified_conceptual_data_model.metadata.physical = verified_physical_data_model.metadata.identifier
+        verified_physical_data_model.metadata.conceptual = verified_conceptual_data_model.metadata.identifier
+        verified_physical_data_model.sync_with_conceptual_data_model(verified_conceptual_data_model)
 
-        # Adding startNode and endNode to the information rules for views that are used for edges.
-        classes_by_prefix = {cls_.class_.prefix: cls_ for cls_ in information_rules.classes}
+        # Adding startNode and endNode to the conceptual data model for views that are used for edges.
+        concepts_by_prefix = {concept.concept.prefix: concept for concept in verified_conceptual_data_model.concepts}
         for view in self._model_views:
-            if view.used_for == "edge" and view.external_id in classes_by_prefix:
-                cls_ = classes_by_prefix[view.external_id]
+            if view.used_for == "edge" and view.external_id in concepts_by_prefix:
+                cls_ = concepts_by_prefix[view.external_id]
                 for property_ in ("startNode", "endNode"):
-                    information_rules.properties.append(
-                        InformationProperty(
-                            class_=cls_.class_,
+                    verified_conceptual_data_model.properties.append(
+                        ConceptualProperty(
+                            concept=cls_.concept,
                             property_=property_,
                             value_type=UnknownEntity(),
                             min_count=0,
@@ -227,4 +235,4 @@ class DMSGraphExtractor(KnowledgeGraphExtractor):
                     )
 
         self._issues.extend(issues)
-        return information_rules, verified_dms
+        return verified_conceptual_data_model, verified_physical_data_model