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

cognite/neat/core/_data_model/importers/_rdf/_inference2rules.py

@@ -12,19 +12,19 @@ from rdflib import Literal as RdfLiteral
 
 from cognite.neat.core._config import GLOBAL_CONFIG
 from cognite.neat.core._constants import NEAT, get_default_prefixes_and_namespaces
-from cognite.neat.core._data_model.analysis import RulesAnalysis
+from cognite.neat.core._data_model.analysis import DataModelAnalysis
 from cognite.neat.core._data_model.models import ConceptualDataModel, data_types
 from cognite.neat.core._data_model.models.conceptual import (
-    ConceptualClass,
+    Concept,
     ConceptualMetadata,
-    UnverifiedConceptualClass,
+    UnverifiedConcept,
     UnverifiedConceptualProperty,
 )
 from cognite.neat.core._data_model.models.data_types import AnyURI
 from cognite.neat.core._data_model.models.entities._single_value import UnknownEntity
 from cognite.neat.core._issues import IssueList
 from cognite.neat.core._issues.warnings import PropertyValueTypeUndefinedWarning
-from cognite.neat.core._store import NeatGraphStore
+from cognite.neat.core._store import NeatInstanceStore
 from cognite.neat.core._store._provenance import INSTANCES_ENTITY
 from cognite.neat.core._utils.collection_ import iterate_progress_bar
 from cognite.neat.core._utils.rdf_ import remove_namespace_from_uri, uri_to_short_form
@@ -83,8 +83,8 @@ class InferenceImporter(BaseRDFImporter):
     @classmethod
     def from_graph_store(
         cls,
-        store: NeatGraphStore,
-        data_model_id: dm.DataModelId | tuple[str, str, str] = DEFAULT_INFERENCE_DATA_MODEL_ID,
+        store: NeatInstanceStore,
+        data_model_id: (dm.DataModelId | tuple[str, str, str]) = DEFAULT_INFERENCE_DATA_MODEL_ID,
         max_number_of_instance: int = -1,
         non_existing_node_type: UnknownEntity | AnyURI = DEFAULT_NON_EXISTING_NODE_TYPE,
         language: str = "en",
@@ -145,7 +145,7 @@ class InferenceImporter(BaseRDFImporter):
     ) -> "InferenceImporter":
         raise NotImplementedError("JSON file format is not supported yet.")
 
-    def _to_rules_components(
+    def _to_data_model_components(
         self,
     ) -> dict:
         """Convert RDF graph to dictionary defining data model and prefixes of the graph
@@ -158,33 +158,33 @@ class InferenceImporter(BaseRDFImporter):
             Tuple of data model and prefixes of the graph
         """
 
-        classes: dict[str, dict] = {}
+        concepts: dict[str, dict] = {}
         properties: dict[str, dict] = {}
         prefixes: dict[str, Namespace] = {}
         count_by_value_type_by_property: dict[str, dict[str, int]] = defaultdict(Counter)
 
         # Infers all the classes in the graph
-        for class_uri, no_instances in self.graph.query(ORDERED_CLASSES_QUERY):  # type: ignore[misc]
-            if (class_id := remove_namespace_from_uri(cast(URIRef, class_uri))) in classes:
+        for concept_uri, no_instances in self.graph.query(ORDERED_CLASSES_QUERY):  # type: ignore[misc]
+            if (concept_id := remove_namespace_from_uri(cast(URIRef, concept_uri))) in concepts:
                 # handles cases when class id is already present in classes
-                class_id = f"{class_id}_{len(classes) + 1}"
+                concept_id = f"{concept_id}_{len(concepts) + 1}"
 
-            classes[class_id] = {
-                "class_": class_id,
-                "uri": class_uri,
+            concepts[concept_id] = {
+                "concept": concept_id,
+                "uri": concept_uri,
                 "comment": f"Inferred from knowledge graph, where this class has <{no_instances}> instances",
             }
 
-            self._add_uri_namespace_to_prefixes(cast(URIRef, class_uri), prefixes)
+            self._add_uri_namespace_to_prefixes(cast(URIRef, concept_uri), prefixes)
 
         instances_query = (
             INSTANCES_OF_CLASS_QUERY if self.max_number_of_instance == -1 else INSTANCES_OF_CLASS_RICHNESS_ORDERED_QUERY
         )
 
-        classes_iterable = iterate_progress_bar(classes.items(), len(classes), "Inferring classes")
+        classes_iterable = iterate_progress_bar(concepts.items(), len(concepts), "Inferring classes")
 
         # Infers all the properties of the class
-        for class_id, class_definition in classes_iterable:
+        for concept_id, class_definition in classes_iterable:
             for (  # type: ignore[misc]
                 instance,
                 _,
@@ -216,7 +216,7 @@ class InferenceImporter(BaseRDFImporter):
 
                         issue = PropertyValueTypeUndefinedWarning(
                             resource_type="Property",
-                            identifier=f"{class_id}:{property_id}",
+                            identifier=f"{concept_id}:{property_id}",
                             property_name=property_id,
                             default_action="Remove the property from the rules",
                             recommended_action="Make sure that graph is complete",
@@ -225,10 +225,10 @@ class InferenceImporter(BaseRDFImporter):
                         if issue not in self.issue_list:
                             self.issue_list.append(issue)
 
-                    id_ = f"{class_id}:{property_id}"
+                    id_ = f"{concept_id}:{property_id}"
 
                     definition = {
-                        "class_": class_id,
+                        "concept": concept_id,
                         "property_": property_id,
                         "max_count": cast(RdfLiteral, occurrence).value,
                         "value_type": value_type_id,
@@ -265,7 +265,7 @@ class InferenceImporter(BaseRDFImporter):
 
         return {
             "metadata": self._default_metadata(),
-            "classes": list(classes.values()),
+            "concepts": list(concepts.values()),
             "properties": list(properties.values()),
             "prefixes": prefixes,
         }
@@ -372,7 +372,7 @@ class SubclassInferenceImporter(BaseRDFImporter):
         super().__init__(issue_list, graph, identifier, -1, non_existing_node_type, language="en")
         self._rules = rules
 
-    def _to_rules_components(
+    def _to_data_model_components(
         self,
     ) -> dict:
         if self._rules:
@@ -392,19 +392,19 @@ class SubclassInferenceImporter(BaseRDFImporter):
             default_space = metadata["space"]
         return {
             "metadata": metadata,
-            "classes": [cls.dump(default_space) for cls in classes],
+            "concepts": [cls.dump(default_space) for cls in classes],
             "properties": [prop.dump(default_space) for prop in properties],
             "prefixes": prefixes,
         }
 
     def _create_classes_properties(
         self, read_properties: list[_ReadProperties], prefixes: dict[str, Namespace]
-    ) -> tuple[list[UnverifiedConceptualClass], list[UnverifiedConceptualProperty]]:
+    ) -> tuple[list[UnverifiedConcept], list[UnverifiedConceptualProperty]]:
         if self._rules:
-            existing_classes = {class_.class_.suffix: class_ for class_ in self._rules.classes}
+            existing_classes = {class_.concept.suffix: class_ for class_ in self._rules.concepts}
         else:
             existing_classes = {}
-        classes: list[UnverifiedConceptualClass] = []
+        classes: list[UnverifiedConcept] = []
         properties_by_class_suffix_by_property_id: dict[str, dict[str, UnverifiedConceptualProperty]] = {}
 
         # Help for IDE
@@ -429,9 +429,9 @@ class SubclassInferenceImporter(BaseRDFImporter):
                 parent_suffix = remove_namespace_from_uri(parent_uri)
                 self._add_uri_namespace_to_prefixes(parent_uri, prefixes)
                 if parent_suffix not in existing_classes:
-                    classes.append(UnverifiedConceptualClass(class_=parent_suffix))
+                    classes.append(UnverifiedConcept(concept=parent_suffix))
                 else:
-                    classes.append(UnverifiedConceptualClass.load(existing_classes[parent_suffix].model_dump()))
+                    classes.append(UnverifiedConcept.load(existing_classes[parent_suffix].model_dump()))
             else:
                 shared_property_uris = set()
             shared_properties: dict[URIRef, list[_ReadProperties]] = defaultdict(list)
@@ -441,14 +441,14 @@ class SubclassInferenceImporter(BaseRDFImporter):
 
                 if class_suffix not in existing_classes:
                     classes.append(
-                        UnverifiedConceptualClass(
-                            class_=class_suffix,
+                        UnverifiedConcept(
+                            concept=class_suffix,
                             implements=parent_suffix,
                             instance_source=type_uri,
                         )
                     )
                 else:
-                    classes.append(UnverifiedConceptualClass.load(existing_classes[class_suffix].model_dump()))
+                    classes.append(UnverifiedConcept.load(existing_classes[class_suffix].model_dump()))
 
                 properties_by_id: dict[str, UnverifiedConceptualProperty] = {}
                 for property_uri, read_properties in properties_by_property_uri.items():
@@ -510,20 +510,20 @@ class SubclassInferenceImporter(BaseRDFImporter):
             type_uri, instance_count_literal = cast(tuple[URIRef, RdfLiteral], result_row)
             count_by_type[type_uri] = instance_count_literal.toPython()
         if self._rules:
-            analysis = RulesAnalysis(self._rules)
+            analysis = DataModelAnalysis(self._rules)
             existing_class_properties = {
                 (class_entity.suffix, prop.property_): prop
-                for class_entity, properties in analysis.properties_by_class(
+                for class_entity, properties in analysis.properties_by_concepts(
                     include_ancestors=True, include_different_space=True
                 ).items()
                 for prop in properties
             }
-            existing_classes = {cls_.class_.suffix: cls_ for cls_ in self._rules.classes}
+            existing_classes = {cls_.concept.suffix: cls_ for cls_ in self._rules.concepts}
         else:
             existing_class_properties = {}
             existing_classes = {}
         properties_by_class_by_subclass: list[_ReadProperties] = []
-        existing_class: ConceptualClass | None
+        existing_class: Concept | None
         total_instance_count = sum(count_by_type.values())
         iterable = count_by_type.items()
         if GLOBAL_CONFIG.use_iterate_bar_threshold and total_instance_count > GLOBAL_CONFIG.use_iterate_bar_threshold:
@@ -581,7 +581,7 @@ class SubclassInferenceImporter(BaseRDFImporter):
         first = read_properties[0]
         value_type = self._get_value_type(read_properties, prefixes)
         return UnverifiedConceptualProperty(
-            class_=class_suffix,
+            concept=class_suffix,
             property_=property_id,
             max_count=first.max_occurrence,
             value_type=value_type,

cognite/neat/core/_data_model/importers/_rdf/_owl2rules.py

@@ -3,20 +3,20 @@ there are loaders to TransformationRules pydantic class."""
 
 from cognite.neat.core._data_model.importers._rdf._base import BaseRDFImporter
 from cognite.neat.core._data_model.importers._rdf._shared import (
-    parse_classes,
+    parse_concepts,
     parse_properties,
 )
 
-CLASSES_QUERY = """SELECT ?class_ ?name ?description ?implements
+CLASSES_QUERY = """SELECT ?concept  ?name ?description ?implements
         WHERE {{
 
-        ?class_ a owl:Class .
-        OPTIONAL {{?class_ rdfs:subClassOf ?implements }}.
-        OPTIONAL {{?class_ rdfs:label|skos:prefLabel ?name }}.
-        OPTIONAL {{?class_ rdfs:comment|skos:definition ?description}} .
+        ?concept  a owl:Class .
+        OPTIONAL {{?concept  rdfs:subClassOf ?implements }}.
+        OPTIONAL {{?concept  rdfs:label|skos:prefLabel ?name }}.
+        OPTIONAL {{?concept  rdfs:comment|skos:definition ?description}} .
 
 
-        FILTER (!isBlank(?class_))
+        FILTER (!isBlank(?concept ))
         FILTER (!bound(?implements) || !isBlank(?implements))
 
         FILTER (!bound(?name) || LANG(?name) = "" || LANGMATCHES(LANG(?name), "{language}"))
@@ -27,11 +27,11 @@ CLASSES_QUERY = """SELECT ?class_ ?name ?description ?implements
 
 PROPERTIES_QUERY = """
 
-    SELECT ?class_ ?property_ ?name ?description ?value_type ?minCount ?maxCount ?default
+    SELECT ?concept  ?property_ ?name ?description ?value_type ?minCount ?maxCount ?default
     WHERE {{
         ?property_ a ?property_Type.
         FILTER (?property_Type IN (owl:ObjectProperty, owl:DatatypeProperty ) )
-        OPTIONAL {{?property_ rdfs:domain ?class_ }}.
+        OPTIONAL {{?property_ rdfs:domain ?concept  }}.
         OPTIONAL {{?property_ rdfs:range ?value_type }}.
         OPTIONAL {{?property_ rdfs:label|skos:prefLabel ?name }}.
         OPTIONAL {{?property_ rdfs:comment|skos:definition ?description}}.
@@ -64,10 +64,10 @@ class OWLImporter(BaseRDFImporter):
 
     """
 
-    def _to_rules_components(
+    def _to_data_model_components(
         self,
     ) -> dict:
-        classes, issue_list = parse_classes(self.graph, CLASSES_QUERY, self.language, self.issue_list)
+        concepts, issue_list = parse_concepts(self.graph, CLASSES_QUERY, self.language, self.issue_list)
         self.issue_list = issue_list
 
         # NeatError
@@ -76,7 +76,7 @@ class OWLImporter(BaseRDFImporter):
 
         components = {
             "Metadata": self._metadata,
-            "Classes": list(classes.values()) if classes else [],
+            "Concepts": list(concepts.values()) if concepts else [],
             "Properties": list(properties.values()) if properties else [],
         }
 

cognite/neat/core/_data_model/importers/_rdf/_shared.py

@@ -13,18 +13,18 @@ from cognite.neat.core._issues.warnings._resources import (
 from cognite.neat.core._utils.rdf_ import convert_rdflib_content
 
 
-def parse_classes(graph: Graph, query: str, language: str, issue_list: IssueList) -> tuple[dict, IssueList]:
-    """Parse classes from graph
+def parse_concepts(graph: Graph, query: str, language: str, issue_list: IssueList) -> tuple[dict, IssueList]:
+    """Parse concepts from graph
 
     Args:
-        graph: Graph containing classes definitions
+        graph: Graph containing concept definitions
         language: Language to use for parsing, by default "en"
 
     Returns:
         Dataframe containing owl classes
     """
 
-    classes: dict[str, dict] = {}
+    concepts: dict[str, dict] = {}
 
     query = prepareQuery(query.format(language=language), initNs={k: v for k, v in graph.namespaces()})
     expected_keys = [str(v) for v in query.algebra._vars]
@@ -33,42 +33,42 @@ def parse_classes(graph: Graph, query: str, language: str, issue_list: IssueList
         res: dict = convert_rdflib_content(cast(ResultRow, raw).asdict(), True)
         res = {key: res.get(key, None) for key in expected_keys}
 
-        class_id = res["class_"]
+        concept_id = res["concept"]
 
         # Safeguarding against incomplete semantic definitions
         if res["implements"] and isinstance(res["implements"], BNode):
             issue_list.append(
                 ResourceRetrievalWarning(
-                    class_id,
+                    concept_id,
                     "implements",
-                    error=("Unable to determine class that is being implemented"),
+                    error=("Unable to determine concept that is being implemented"),
                 )
             )
             continue
 
-        if class_id not in classes:
-            classes[class_id] = res
+        if concept_id not in concepts:
+            concepts[concept_id] = res
         else:
             # Handling implements
-            if classes[class_id]["implements"] and isinstance(classes[class_id]["implements"], list):
-                if res["implements"] not in classes[class_id]["implements"]:
-                    classes[class_id]["implements"].append(res["implements"])
+            if concepts[concept_id]["implements"] and isinstance(concepts[concept_id]["implements"], list):
+                if res["implements"] not in concepts[concept_id]["implements"]:
+                    concepts[concept_id]["implements"].append(res["implements"])
 
-            elif classes[class_id]["implements"] and isinstance(classes[class_id]["implements"], str):
-                classes[class_id]["implements"] = [classes[class_id]["implements"]]
+            elif concepts[concept_id]["implements"] and isinstance(concepts[concept_id]["implements"], str):
+                concepts[concept_id]["implements"] = [concepts[concept_id]["implements"]]
 
-                if res["implements"] not in classes[class_id]["implements"]:
-                    classes[class_id]["implements"].append(res["implements"])
+                if res["implements"] not in concepts[concept_id]["implements"]:
+                    concepts[concept_id]["implements"].append(res["implements"])
             elif res["implements"]:
-                classes[class_id]["implements"] = [res["implements"]]
+                concepts[concept_id]["implements"] = [res["implements"]]
 
-            handle_meta("class_", classes, class_id, res, "name", issue_list)
-            handle_meta("class_", classes, class_id, res, "description", issue_list)
+            handle_meta("concept", concepts, concept_id, res, "name", issue_list)
+            handle_meta("concept", concepts, concept_id, res, "description", issue_list)
 
-    if not classes:
-        issue_list.append(NeatValueError("Unable to parse classes"))
+    if not concepts:
+        issue_list.append(NeatValueError("Unable to parse concepts"))
 
-    return classes, issue_list
+    return concepts, issue_list
 
 
 def parse_properties(graph: Graph, query: str, language: str, issue_list: IssueList) -> tuple[dict, IssueList]:
@@ -94,12 +94,12 @@ def parse_properties(graph: Graph, query: str, language: str, issue_list: IssueL
         property_id = res["property_"]
 
         # Safeguarding against incomplete semantic definitions
-        if not res["class_"] or isinstance(res["class_"], BNode):
+        if not res["concept"] or isinstance(res["concept"], BNode):
             issue_list.append(
                 ResourceRetrievalWarning(
                     property_id,
                     "property",
-                    error=("Unable to determine to what class property is being defined"),
+                    error=("Unable to determine to what concept property is being defined"),
                 )
             )
             continue
@@ -115,7 +115,7 @@ def parse_properties(graph: Graph, query: str, language: str, issue_list: IssueL
             )
             continue
 
-        id_ = f"{res['class_']}.{res['property_']}"
+        id_ = f"{res['concept']}.{res['property_']}"
 
         if id_ not in properties:
             properties[id_] = res

cognite/neat/core/_data_model/importers/{_spreadsheet2rules.py → _spreadsheet2data_model.py}

@@ -1,18 +1,24 @@
 """This module performs importing of graph to TransformationRules pydantic class.
 In more details, it traverses the graph and abstracts class and properties, basically
-generating a list of rules based on which nodes that form the graph are made.
+generating a list of data_model based on which nodes that form the graph are made.
 """
 
+import tempfile
 from collections import UserDict, defaultdict
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Literal, cast
 
 import pandas as pd
+from openpyxl import load_workbook
+from openpyxl.worksheet.worksheet import Worksheet
 from pandas import ExcelFile
 from rdflib import Namespace, URIRef
 
-from cognite.neat.core._data_model._shared import ReadRules, T_InputRules
+from cognite.neat.core._data_model._shared import (
+    ImportedDataModel,
+    T_UnverifiedDataModel,
+)
 from cognite.neat.core._data_model.models import (
     INPUT_RULES_BY_ROLE,
     VERIFIED_RULES_BY_ROLE,
@@ -36,11 +42,11 @@ SOURCE_SHEET__TARGET_FIELD__HEADERS = [
         "Properties",
         "Properties",
         {
-            RoleTypes.information: ["Class", "Property"],
+            RoleTypes.information: ["Concept", "Property"],
             RoleTypes.dms: ["View", "View Property"],
         },
     ),
-    ("Classes", "Classes", ["Class"]),
+    ("Concepts", "Concepts", ["Concept"]),
     ("Containers", "Containers", ["Container"]),
     ("Views", "Views", ["View"]),
     ("Enum", "Enum", ["Collection"]),
@@ -242,8 +248,8 @@ class SpreadsheetReader:
         return sheets, read_info_by_sheet
 
 
-class ExcelImporter(BaseImporter[T_InputRules]):
-    """Import rules from an Excel file.
+class ExcelImporter(BaseImporter[T_UnverifiedDataModel]):
+    """Import data_model from an Excel file.
 
     Args:
         filepath (Path): The path to the Excel file.
@@ -252,14 +258,15 @@ class ExcelImporter(BaseImporter[T_InputRules]):
     def __init__(self, filepath: Path):
         self.filepath = filepath
 
-    def to_rules(self) -> ReadRules[T_InputRules]:
+    def to_data_model(self) -> ImportedDataModel[T_UnverifiedDataModel]:
         issue_list = IssueList(title=f"'{self.filepath.name}'")
         if not self.filepath.exists():
             raise FileNotFoundNeatError(self.filepath)
 
+        self.filepath = self._make_forward_compatible_spreadsheet(self.filepath)
+
         with pd.ExcelFile(self.filepath) as excel_file:
             user_reader = SpreadsheetReader(issue_list)
-
             user_read = user_reader.read(excel_file, self.filepath)
 
         issue_list.trigger_warnings()
@@ -267,15 +274,23 @@ class ExcelImporter(BaseImporter[T_InputRules]):
             raise MultiValueError(issue_list.errors)
 
         if user_read is None:
-            return ReadRules(None, {})
+            return ImportedDataModel(None, {})
 
         sheets = user_read.sheets
         original_role = user_read.role
         read_info_by_sheet = user_read.read_info_by_sheet
 
-        rules_cls = INPUT_RULES_BY_ROLE[original_role]
-        rules = cast(T_InputRules, rules_cls.load(sheets))
-        return ReadRules(rules, read_info_by_sheet)
+        data_model_cls = INPUT_RULES_BY_ROLE[original_role]
+        data_model = cast(T_UnverifiedDataModel, data_model_cls.load(sheets))
+
+        # Delete the temporary file if it was created
+        if "temp_neat_file" in self.filepath.name:
+            try:
+                self.filepath.unlink()
+            except Exception as e:
+                issue_list.append(FileReadError(self.filepath, f"Failed to delete temporary file: {e}"))
+
+        return ImportedDataModel(data_model, read_info_by_sheet)
 
     @property
     def description(self) -> str:
@@ -284,3 +299,48 @@ class ExcelImporter(BaseImporter[T_InputRules]):
     @property
     def source_uri(self) -> URIRef:
         return URIRef(f"file://{self.filepath.name}")
+
+    def _make_forward_compatible_spreadsheet(self, filepath: Path) -> Path:
+        """Makes the spreadsheet forward compatible by renaming legacy class with concept
+
+        Args:
+            filepath (Path): The path to the Excel file.
+
+        """
+
+        workbook = load_workbook(filepath)
+
+        if "Classes" in workbook.sheetnames:
+            print(
+                (
+                    "You are using a legacy spreadsheet format, "
+                    "which we will support until v1.0 of neat."
+                    " Please update your spreadsheet to the new format."
+                ),
+            )
+            _replace_class_with_concept_cell(workbook["Classes"])
+            sheet = workbook["Classes"]
+            sheet.title = "Concepts"
+
+            if "Properties" in workbook.sheetnames:
+                _replace_class_with_concept_cell(workbook["Properties"])
+
+            with tempfile.NamedTemporaryFile(prefix="temp_neat_file", suffix=".xlsx", delete=False) as temp_file:
+                workbook.save(temp_file.name)
+                return Path(temp_file.name)
+
+        else:
+            return filepath
+
+
+def _replace_class_with_concept_cell(sheet: Worksheet) -> None:
+    """
+    Replaces the word "Class" with "Concept" in the first row of the given sheet.
+
+    Args:
+        sheet (Worksheet): The sheet in which to replace the word "Class".
+    """
+    for row in sheet.iter_rows():
+        for cell in row:
+            if cell.value == "Class":
+                cell.value = "Concept"

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

@@ -7,30 +7,30 @@ from cognite.neat.core._data_model.models.conceptual._verified import (
 )
 
 from ._base_verified import DataModelType, ExtensionCategory, RoleTypes, SchemaCompleteness, SheetList, SheetRow
-from .dms._rules import DMSRules
-from .dms._rules_input import DMSInputRules
+from .physical._unverified import UnverifiedPhysicalDataModel
+from .physical._verified import PhysicalDataModel
 
-INPUT_RULES_BY_ROLE: dict[RoleTypes, type[UnverifiedConceptualDataModel] | type[DMSInputRules]] = {
+INPUT_RULES_BY_ROLE: dict[RoleTypes, type[UnverifiedConceptualDataModel] | type[UnverifiedPhysicalDataModel]] = {
     RoleTypes.information: UnverifiedConceptualDataModel,
-    RoleTypes.dms: DMSInputRules,
+    RoleTypes.dms: UnverifiedPhysicalDataModel,
 }
-VERIFIED_RULES_BY_ROLE: dict[RoleTypes, type[ConceptualDataModel] | type[DMSRules]] = {
+VERIFIED_RULES_BY_ROLE: dict[RoleTypes, type[ConceptualDataModel] | type[PhysicalDataModel]] = {
     RoleTypes.information: ConceptualDataModel,
-    RoleTypes.dms: DMSRules,
+    RoleTypes.dms: PhysicalDataModel,
 }
 
 
 __all__ = [
     "INPUT_RULES_BY_ROLE",
     "ConceptualDataModel",
-    "DMSInputRules",
-    "DMSRules",
     "DMSSchema",
     "DataModelType",
     "ExtensionCategory",
+    "PhysicalDataModel",
     "RoleTypes",
     "SchemaCompleteness",
     "SheetList",
     "SheetRow",
     "UnverifiedConceptualDataModel",
+    "UnverifiedPhysicalDataModel",
 ]

cognite/neat/core/_data_model/models/_base_unverified.py

@@ -110,7 +110,7 @@ class UnverifiedDataModel(Generic[T_BaseRules], ABC):
     def _dataclass_fields(self) -> list[Field]:
         return list(fields(self))
 
-    def as_verified_rules(self) -> T_BaseRules:
+    def as_verified_data_model(self) -> T_BaseRules:
         cls_ = self._get_verified_cls()
         return cls_.model_validate(self.dump())
 

cognite/neat/core/_data_model/models/_base_verified.py

@@ -30,7 +30,7 @@ from cognite.neat.core._constants import DEFAULT_NAMESPACE
 from cognite.neat.core._data_model.models._types import (
     ContainerEntityType,
     DataModelExternalIdType,
-    DmsPropertyType,
+    PhysicalPropertyType,
     SpaceType,
     StrListType,
     URIRefType,
@@ -438,7 +438,7 @@ ExtensionCategoryType = Annotated[
 # Immutable such that this can be used as a key in a dictionary
 class ContainerProperty(BaseModel, frozen=True):
     container: ContainerEntityType
-    property_: DmsPropertyType
+    property_: PhysicalPropertyType
 
 
 class ContainerDestinationProperty(ContainerProperty, frozen=True):
@@ -451,4 +451,4 @@ class ViewRef(BaseModel, frozen=True):
 
 
 class ViewProperty(ViewRef, frozen=True):
-    property_: DmsPropertyType
+    property_: PhysicalPropertyType

cognite/neat/core/_data_model/models/_types.py

@@ -23,14 +23,14 @@ from cognite.neat.core._data_model._constants import (
 )
 from cognite.neat.core._data_model.models.entities._multi_value import MultiValueTypeInfo
 from cognite.neat.core._data_model.models.entities._single_value import (
-    ClassEntity,
+    ConceptEntity,
     ContainerEntity,
     ViewEntity,
 )
 from cognite.neat.core._issues.errors import RegexViolationError
 from cognite.neat.core._issues.warnings import RegexViolationWarning
 
-Entities: TypeAlias = ClassEntity | ViewEntity | ContainerEntity
+Entities: TypeAlias = ConceptEntity | ViewEntity | ContainerEntity
 T_Entities = TypeVar("T_Entities", bound=Entities)
 
 
@@ -139,9 +139,9 @@ ConceptualPropertyType = Annotated[
     str,
     AfterValidator(_external_id_validation_factory(EntityTypes.conceptual_property, "Property column in properties")),
 ]
-DmsPropertyType = Annotated[
+PhysicalPropertyType = Annotated[
     str,
-    AfterValidator(_external_id_validation_factory(EntityTypes.dms_property, "Property column in properties")),
+    AfterValidator(_external_id_validation_factory(EntityTypes.physical_property, "Property column in properties")),
 ]
 
 
@@ -152,7 +152,7 @@ def _entity_validation(value: Entities, location: str) -> Entities:
     return value
 
 
-ClassEntityType = Annotated[ClassEntity, AfterValidator(lambda v: _entity_validation(v, "the Class column"))]
+ConceptEntityType = Annotated[ConceptEntity, AfterValidator(lambda v: _entity_validation(v, "the Class column"))]
 ViewEntityType = Annotated[ViewEntity, AfterValidator(lambda v: _entity_validation(v, "the View column"))]
 ContainerEntityType = Annotated[
     ContainerEntity, AfterValidator(lambda v: _entity_validation(v, "the Container column"))
@@ -161,7 +161,7 @@ ContainerEntityType = Annotated[
 
 def _multi_value_type_validation(value: MultiValueTypeInfo, location: str) -> MultiValueTypeInfo:
     for type_ in value.types:
-        if isinstance(type_, ClassEntity):
+        if isinstance(type_, ConceptEntity):
             _entity_validation(type_, location)
     return value