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

cognite/neat/_version.py

@@ -1,2 +1,2 @@
-__version__ = "0.121.2"
+__version__ = "0.122.1"
 __engine__ = "^2.0.4"

cognite/neat/core/_constants.py

@@ -104,7 +104,7 @@ COGNITE_CONCEPTS = (
 
 DMS_LISTABLE_PROPERTY_LIMIT = 1000
 
-EXAMPLE_RULES = PACKAGE_DIRECTORY / "core" / "_data_model" / "examples"
+EXAMPLE_DATA_MODELS = PACKAGE_DIRECTORY / "core" / "_data_model" / "examples"
 EXAMPLE_GRAPHS = PACKAGE_DIRECTORY / "core" / "_instances" / "examples"
 
 DEFAULT_SPACE_URI = "http://purl.org/cognite/space/{space}#"

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

@@ -1,4 +1,4 @@
-"""Shortcut to rules catalog files"""
+"""Shortcut to data model catalog"""
 
 from pathlib import Path
 

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

@@ -34,6 +34,6 @@ def _repr_html_() -> str:
     )._repr_html_()
 
     return (
-        "<strong>Exporter</strong> An exporter converts Neat's representation of a data model called <em>Rules</em>"
+        "<strong>Exporter</strong> An exporter converts Neat's representation of a data model"
         f" into a schema/data model for a target format.<br />{table}"
     )

cognite/neat/core/_data_model/exporters/_data_model2instance_template.py

@@ -20,8 +20,8 @@ from ._base import BaseExporter
 
 class InstanceTemplateExporter(BaseExporter[ConceptualDataModel, Workbook]):
     """
-    Converts Information Rules to a templated spreadsheet meant for capturing
-    instances based on class definitions in the rules.
+    Converts conceptual data model to a templated spreadsheet meant for capturing
+    instances based on concept definitions in the data model.
 
     Args:
         no_rows: number of rows for processing, by default 1000
@@ -50,30 +50,30 @@ class InstanceTemplateExporter(BaseExporter[ConceptualDataModel, Workbook]):
 
     def export(
         self,
-        rules: ConceptualDataModel,
+        data_model: ConceptualDataModel,
     ) -> Workbook:
         workbook = Workbook()
 
         # Remove default sheet named "Sheet"
         workbook.remove(workbook["Sheet"])
 
-        for class_, properties in DataModelAnalysis(rules).properties_by_id_by_concept().items():
-            workbook.create_sheet(title=class_.suffix)
+        for concept, properties in DataModelAnalysis(data_model).properties_by_id_by_concept().items():
+            workbook.create_sheet(title=concept.suffix)
 
             # Add header rows
-            workbook[class_.suffix].append(["identifier", *list(properties.keys())])
+            workbook[concept.suffix].append(["identifier", *list(properties.keys())])
 
             if self.auto_identifier_type == "uuid":
-                _add_uuid_identifiers(workbook, class_.suffix, self.no_rows)
+                _add_uuid_identifiers(workbook, concept.suffix, self.no_rows)
             else:
                 # Default to index-based identifier
-                _add_index_identifiers(workbook, class_.suffix, self.no_rows)
+                _add_index_identifiers(workbook, concept.suffix, self.no_rows)
 
             for i, property_ in enumerate(properties.values()):
                 if property_.type_ == EntityTypes.object_property and self.add_drop_down_list:
                     _add_drop_down_list(
                         workbook,
-                        class_.suffix,
+                        concept.suffix,
                         get_column_letter(i + 2),
                         self.no_rows,
                         cast(ConceptEntity, property_.value_type).suffix,
@@ -85,9 +85,9 @@ class InstanceTemplateExporter(BaseExporter[ConceptualDataModel, Workbook]):
 
         return workbook
 
-    def export_to_file(self, rules: ConceptualDataModel, filepath: Path) -> None:
+    def export_to_file(self, data_model: ConceptualDataModel, filepath: Path) -> None:
         """Exports graph capturing sheet to excel file."""
-        data = self.export(rules)
+        data = self.export(data_model)
         try:
             data.save(filepath)
         finally:

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

@@ -17,7 +17,7 @@ __all__ = [
     "SubclassInferenceImporter",
 ]
 
-RulesImporters = (
+DataModelImporters = (
     OWLImporter
     | IMFImporter
     | DMSImporter
@@ -47,5 +47,5 @@ def _repr_html_() -> str:
 
     return (
         "<strong>Importer</strong> An importer reads data/schema/data model from a source"
-        f" and converts it into Neat's representation of a data model called <em>Rules</em>.<br />{table}"
+        f" and converts it into Neat's representation of a data model.<br />{table}"
     )

cognite/neat/core/_data_model/importers/_dict2data_model.py

@@ -7,7 +7,10 @@ from cognite.neat.core._data_model._shared import (
     ImportedDataModel,
     T_UnverifiedDataModel,
 )
-from cognite.neat.core._data_model.models import INPUT_RULES_BY_ROLE, RoleTypes
+from cognite.neat.core._data_model.models import (
+    UNVERIFIED_DATA_MODEL_BY_ROLE,
+    RoleTypes,
+)
 from cognite.neat.core._issues import IssueList, MultiValueError, NeatIssue
 from cognite.neat.core._issues.errors import (
     FileMissingRequiredFieldError,
@@ -44,16 +47,18 @@ class YAMLReader:
 
 
 class DictImporter(BaseImporter[T_UnverifiedDataModel]):
-    """Imports the rules from a YAML file.
+    """Imports the data model from a YAML file.
 
     Args:
         raw_data: The raw data to be imported.
 
     .. note::
 
-        YAML files are typically used for storing rules when checked into version control systems, e.g., git-history.
-        The advantage of using YAML files over Excel is that tools like git can show the differences between different
-        versions of the rules.
+        YAML files are typically used for storing data model when checked into version
+        control systems, e.g., git-history.
+        The advantage of using YAML files over Excel is that tools like git can
+        show the differences between different
+        versions of the data model.
 
     """
 
@@ -115,7 +120,7 @@ class DictImporter(BaseImporter[T_UnverifiedDataModel]):
 
         role_input = RoleTypes(metadata["role"])
         role_enum = RoleTypes(role_input)
-        data_model_cls = INPUT_RULES_BY_ROLE[role_enum]
+        data_model_cls = UNVERIFIED_DATA_MODEL_BY_ROLE[role_enum]
 
         data_model = cast(T_UnverifiedDataModel, data_model_cls.load(self.raw_data))
 

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

@@ -1,5 +1,5 @@
-from ._imf2rules import IMFImporter
-from ._inference2rules import InferenceImporter, SubclassInferenceImporter
-from ._owl2rules import OWLImporter
+from ._imf2data_model import IMFImporter
+from ._inference2rdata_model import InferenceImporter, SubclassInferenceImporter
+from ._owl2data_model import OWLImporter
 
 __all__ = ["IMFImporter", "InferenceImporter", "OWLImporter", "SubclassInferenceImporter"]

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

@@ -28,13 +28,13 @@ DEFAULT_RDF_DATA_MODEL_ID = ("neat_space", "RDFDataModel", "rdf")
 
 
 class BaseRDFImporter(BaseImporter[UnverifiedConceptualDataModel]):
-    """Baser RDF importers used for all rules importers that are using RDF as input.
+    """Baser RDF importers used for all data model importers that are using RDF as input.
 
     Args:
         issue_list: Issue list to store issues
-        graph: Knowledge graph
-        data_model_id: Data model id to be used for the imported rules
-        space: CDF Space to be used for the imported rules
+        graph: graph where instances are stored
+        data_model_id: Data model id to be used for the imported data model
+        space: CDF Space to be used for the imported data model
         language: Language for description and human readable entity names
 
 
@@ -119,18 +119,18 @@ class BaseRDFImporter(BaseImporter[UnverifiedConceptualDataModel]):
         self,
     ) -> ImportedDataModel[UnverifiedConceptualDataModel]:
         """
-        Creates `Rules` object from the data for target role.
+        Creates `ImportedDataModel` object from the data for target role.
         """
         if self.issue_list.has_errors:
             # In case there were errors during the import, the to_data_model method will return None
             self.issue_list.trigger_warnings()
             raise MultiValueError(self.issue_list.errors)
 
-        rules_dict = self._to_data_model_components()
+        data_model_dict = self._to_data_model_components()
 
-        rules = UnverifiedConceptualDataModel.load(rules_dict)
+        data_model = UnverifiedConceptualDataModel.load(data_model_dict)
         self.issue_list.trigger_warnings()
-        return ImportedDataModel(rules, {})
+        return ImportedDataModel(data_model, {})
 
     def _to_data_model_components(self) -> dict:
         raise NotImplementedError()

cognite/neat/core/_data_model/importers/_rdf/{_imf2rules.py → _imf2data_model.py}

@@ -1,5 +1,5 @@
 """This module performs importing of various formats to one of serializations for which
-there are loaders to TransformationRules pydantic class."""
+there are loaders to data model pydantic class."""
 
 from cognite.neat.core._data_model.importers._rdf._base import BaseRDFImporter
 from cognite.neat.core._data_model.importers._rdf._shared import (
@@ -75,7 +75,7 @@ PROPERTIES_QUERY = """
 
 
 class IMFImporter(BaseRDFImporter):
-    """Convert IMF Types provided as SHACL shapes to Input Rules."""
+    """Convert IMF Types provided as SHACL shapes to unverified data model."""
 
     @property
     def description(self) -> str:

cognite/neat/core/_data_model/importers/_rdf/{_inference2rules.py → _inference2rdata_model.py}

@@ -56,10 +56,10 @@ INSTANCE_PROPERTIES_DEFINITION = """SELECT ?property (count(?property) as ?occur
 
 
 class InferenceImporter(BaseRDFImporter):
-    """Infers rules from a triple store.
+    """Infers data model from instances stored as triples.
 
-    Rules inference through analysis of knowledge graph provided in various formats.
-    Use the factory methods to create a triple store from sources such as
+    Data model inference through analysis of knowledge graph provided in various formats.
+    Use the factory methods to create triples from sources such as
     RDF files, JSON files, YAML files, XML files, or directly from a graph store.
 
     ClassVars:
@@ -151,7 +151,7 @@ class InferenceImporter(BaseRDFImporter):
         """Convert RDF graph to dictionary defining data model and prefixes of the graph
 
         Args:
-            graph: RDF graph to be converted to TransformationRules object
+            graph: RDF graph to be converted to data model
             max_number_of_instance: Max number of instances to be considered for each class
 
         Returns:
@@ -218,7 +218,7 @@ class InferenceImporter(BaseRDFImporter):
                             resource_type="Property",
                             identifier=f"{concept_id}:{property_id}",
                             property_name=property_id,
-                            default_action="Remove the property from the rules",
+                            default_action="Remove the property from the data model",
                             recommended_action="Make sure that graph is complete",
                         )
 
@@ -300,11 +300,11 @@ class _ReadProperties:
 
 
 class SubclassInferenceImporter(BaseRDFImporter):
-    """Infer subclasses from a triple store.
+    """Infer subclasses from instances stored in a triple store.
 
-    Assumes that the graph already is connected to a schema. The classes should
-    match the RDF.type of the instances in the graph, while the subclasses should
-    match the NEAT.type of the instances in the graph.
+    Assumes that the instances already are connected to a schema. The classes should
+    match the RDF.type of the instances, while the subclasses should match the NEAT.type
+    of the instances.
 
     ClassVars:
         overwrite_data_types: Mapping of data types to be overwritten. The InferenceImporter will overwrite
@@ -357,26 +357,26 @@ class SubclassInferenceImporter(BaseRDFImporter):
         self,
         issue_list: IssueList,
         graph: Graph,
-        rules: ConceptualDataModel | None = None,
+        data_model: ConceptualDataModel | None = None,
         data_model_id: dm.DataModelId | tuple[str, str, str] | None = None,
         non_existing_node_type: UnknownEntity | AnyURI = DEFAULT_NON_EXISTING_NODE_TYPE,
     ) -> None:
-        if sum([1 for v in [rules, data_model_id] if v is not None]) != 1:
-            raise ValueError("Exactly one of rules or data_model_id must be provided.")
+        if sum([1 for v in [data_model, data_model_id] if v is not None]) != 1:
+            raise ValueError("Exactly one of data model or data_model_id must be provided.")
         if data_model_id is not None:
             identifier = data_model_id
-        elif rules is not None:
-            identifier = rules.metadata.as_data_model_id().as_tuple()  # type: ignore[assignment]
+        elif data_model is not None:
+            identifier = data_model.metadata.as_data_model_id().as_tuple()  # type: ignore[assignment]
         else:
-            raise ValueError("Exactly one of rules or data_model_id must be provided.")
+            raise ValueError("Exactly one of data model or data_model_id must be provided.")
         super().__init__(issue_list, graph, identifier, -1, non_existing_node_type, language="en")
-        self._rules = rules
+        self._data_model = data_model
 
     def _to_data_model_components(
         self,
     ) -> dict:
-        if self._rules:
-            prefixes = self._rules.prefixes.copy()
+        if self._data_model:
+            prefixes = self._data_model.prefixes.copy()
         else:
             prefixes = get_default_prefixes_and_namespaces()
 
@@ -384,9 +384,9 @@ class SubclassInferenceImporter(BaseRDFImporter):
         read_properties = self._read_class_properties_from_graph(parent_by_child)
         classes, properties = self._create_classes_properties(read_properties, prefixes)
 
-        if self._rules:
-            metadata = self._rules.metadata.model_dump()
-            default_space = self._rules.metadata.prefix
+        if self._data_model:
+            metadata = self._data_model.metadata.model_dump()
+            default_space = self._data_model.metadata.prefix
         else:
             metadata = self._default_metadata()
             default_space = metadata["space"]
@@ -400,8 +400,8 @@ class SubclassInferenceImporter(BaseRDFImporter):
     def _create_classes_properties(
         self, read_properties: list[_ReadProperties], prefixes: dict[str, Namespace]
     ) -> tuple[list[UnverifiedConcept], list[UnverifiedConceptualProperty]]:
-        if self._rules:
-            existing_classes = {class_.concept.suffix: class_ for class_ in self._rules.concepts}
+        if self._data_model:
+            existing_classes = {class_.concept.suffix: class_ for class_ in self._data_model.concepts}
         else:
             existing_classes = {}
         classes: list[UnverifiedConcept] = []
@@ -509,8 +509,8 @@ class SubclassInferenceImporter(BaseRDFImporter):
         for result_row in self.graph.query(self._ordered_class_query):
             type_uri, instance_count_literal = cast(tuple[URIRef, RdfLiteral], result_row)
             count_by_type[type_uri] = instance_count_literal.toPython()
-        if self._rules:
-            analysis = DataModelAnalysis(self._rules)
+        if self._data_model:
+            analysis = DataModelAnalysis(self._data_model)
             existing_class_properties = {
                 (class_entity.suffix, prop.property_): prop
                 for class_entity, properties in analysis.properties_by_concepts(
@@ -518,7 +518,7 @@ class SubclassInferenceImporter(BaseRDFImporter):
                 ).items()
                 for prop in properties
             }
-            existing_classes = {cls_.concept.suffix: cls_ for cls_ in self._rules.concepts}
+            existing_classes = {cls_.concept.suffix: cls_ for cls_ in self._data_model.concepts}
         else:
             existing_class_properties = {}
             existing_classes = {}

cognite/neat/core/_data_model/importers/_rdf/{_owl2rules.py → _owl2data_model.py}

@@ -1,5 +1,5 @@
 """This module performs importing of various formats to one of serializations for which
-there are loaders to TransformationRules pydantic class."""
+there are loaders to data model pydantic class."""
 
 from cognite.neat.core._data_model.importers._rdf._base import BaseRDFImporter
 from cognite.neat.core._data_model.importers._rdf._shared import (
@@ -47,20 +47,20 @@ PROPERTIES_QUERY = """
 
 
 class OWLImporter(BaseRDFImporter):
-    """Convert OWL ontology to tables/ transformation rules / Excel file.
+    """Convert OWL ontology to unverified data model.
 
         Args:
             filepath: Path to OWL ontology
 
     !!! Note
         OWL Ontologies are information models which completeness varies. As such, constructing functional
-        data model directly will often be impossible, therefore the produced Rules object will be ill formed.
-        To avoid this, neat will automatically attempt to make the imported rules compliant by adding default
+        data model directly will often be impossible, therefore the produced data model object will be ill formed.
+        To avoid this, neat will automatically attempt to make the imported data model compliant by adding default
         values for missing information, attaching dangling properties to default containers based on the
         property type, etc.
 
         One has to be aware that NEAT will be opinionated about how to make the ontology
-        compliant, and that the resulting rules may not be what you expect.
+        compliant, and that the resulting data model may not be what you expect.
 
     """
 

cognite/neat/core/_data_model/importers/_spreadsheet2data_model.py

@@ -1,7 +1,4 @@
-"""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 data_model based on which nodes that form the graph are made.
-"""
+"""This module performs importing of data model from spreadsheets."""
 
 import tempfile
 from collections import UserDict, defaultdict
@@ -20,8 +17,8 @@ from cognite.neat.core._data_model._shared import (
     T_UnverifiedDataModel,
 )
 from cognite.neat.core._data_model.models import (
-    INPUT_RULES_BY_ROLE,
-    VERIFIED_RULES_BY_ROLE,
+    UNVERIFIED_DATA_MODEL_BY_ROLE,
+    VERIFIED_DATA_MODEL_BY_ROLE,
     RoleTypes,
     SchemaCompleteness,
 )
@@ -58,8 +55,8 @@ MANDATORY_SHEETS_BY_ROLE: dict[RoleTypes, set[str]] = {
     role_type: {
         str(sheet_name)
         for sheet_name in (
-            VERIFIED_RULES_BY_ROLE.get(role_type).mandatory_fields(use_alias=True)  # type: ignore
-            if VERIFIED_RULES_BY_ROLE.get(role_type)
+            VERIFIED_DATA_MODEL_BY_ROLE.get(role_type).mandatory_fields(use_alias=True)  # type: ignore
+            if VERIFIED_DATA_MODEL_BY_ROLE.get(role_type)
             else []
         )
         if sheet_name is not None
@@ -280,7 +277,7 @@ class ExcelImporter(BaseImporter[T_UnverifiedDataModel]):
         original_role = user_read.role
         read_info_by_sheet = user_read.read_info_by_sheet
 
-        data_model_cls = INPUT_RULES_BY_ROLE[original_role]
+        data_model_cls = UNVERIFIED_DATA_MODEL_BY_ROLE[original_role]
         data_model = cast(T_UnverifiedDataModel, data_model_cls.load(sheets))
 
         # Delete the temporary file if it was created

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

@@ -10,18 +10,20 @@ from ._base_verified import DataModelType, ExtensionCategory, RoleTypes, SchemaC
 from .physical._unverified import UnverifiedPhysicalDataModel
 from .physical._verified import PhysicalDataModel
 
-INPUT_RULES_BY_ROLE: dict[RoleTypes, type[UnverifiedConceptualDataModel] | type[UnverifiedPhysicalDataModel]] = {
+UNVERIFIED_DATA_MODEL_BY_ROLE: dict[
+    RoleTypes, type[UnverifiedConceptualDataModel] | type[UnverifiedPhysicalDataModel]
+] = {
     RoleTypes.information: UnverifiedConceptualDataModel,
     RoleTypes.dms: UnverifiedPhysicalDataModel,
 }
-VERIFIED_RULES_BY_ROLE: dict[RoleTypes, type[ConceptualDataModel] | type[PhysicalDataModel]] = {
+VERIFIED_DATA_MODEL_BY_ROLE: dict[RoleTypes, type[ConceptualDataModel] | type[PhysicalDataModel]] = {
     RoleTypes.information: ConceptualDataModel,
     RoleTypes.dms: PhysicalDataModel,
 }
 
 
 __all__ = [
-    "INPUT_RULES_BY_ROLE",
+    "UNVERIFIED_DATA_MODEL_BY_ROLE",
     "ConceptualDataModel",
     "DMSSchema",
     "DataModelType",

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

@@ -27,29 +27,29 @@ if sys.version_info >= (3, 11):
 else:
     from typing_extensions import Self
 
-T_BaseRules = TypeVar("T_BaseRules", bound=BaseVerifiedDataModel)
-T_RuleModel = TypeVar("T_RuleModel", bound=SchemaModel)
+T_BaseDataModel = TypeVar("T_BaseDataModel", bound=BaseVerifiedDataModel)
+T_DataModel = TypeVar("T_DataModel", bound=SchemaModel)
 
 
 @dataclass
-class UnverifiedDataModel(Generic[T_BaseRules], ABC):
-    """Input rules are raw data that is not yet validated."""
+class UnverifiedDataModel(Generic[T_BaseDataModel], ABC):
+    """Input data model are raw data that is not yet validated."""
 
     @classmethod
     @abstractmethod
-    def _get_verified_cls(cls) -> type[T_BaseRules]:
+    def _get_verified_cls(cls) -> type[T_BaseDataModel]:
         raise NotImplementedError("This method should be implemented in the subclass.")
 
     @classmethod
     @overload
-    def load(cls: "type[T_InputRules]", data: dict[str, Any]) -> "T_InputRules": ...
+    def load(cls: "type[T_UnverifiedDataModel]", data: dict[str, Any]) -> "T_UnverifiedDataModel": ...
 
     @classmethod
     @overload
-    def load(cls: "type[T_InputRules]", data: None) -> None: ...
+    def load(cls: "type[T_UnverifiedDataModel]", data: None) -> None: ...
 
     @classmethod
-    def load(cls: "type[T_InputRules]", data: dict | None) -> "T_InputRules | None":
+    def load(cls: "type[T_UnverifiedDataModel]", data: dict | None) -> "T_UnverifiedDataModel | None":
         if data is None:
             return None
         return cls._load(data)
@@ -110,7 +110,7 @@ class UnverifiedDataModel(Generic[T_BaseRules], ABC):
     def _dataclass_fields(self) -> list[Field]:
         return list(fields(self))
 
-    def as_verified_data_model(self) -> T_BaseRules:
+    def as_verified_data_model(self) -> T_BaseDataModel:
         cls_ = self._get_verified_cls()
         return cls_.model_validate(self.dump())
 
@@ -127,14 +127,14 @@ class UnverifiedDataModel(Generic[T_BaseRules], ABC):
         return output
 
 
-T_InputRules = TypeVar("T_InputRules", bound=UnverifiedDataModel)
+T_UnverifiedDataModel = TypeVar("T_UnverifiedDataModel", bound=UnverifiedDataModel)
 
 
 @dataclass
-class UnverifiedComponent(ABC, Generic[T_RuleModel]):
+class UnverifiedComponent(ABC, Generic[T_DataModel]):
     @classmethod
     @abstractmethod
-    def _get_verified_cls(cls) -> type[T_RuleModel]:
+    def _get_verified_cls(cls) -> type[T_DataModel]:
         raise NotImplementedError("This method should be implemented in the subclass.")
 
     @classmethod

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

@@ -1,4 +1,4 @@
-"""This module contains the definition of `TransformationRules` pydantic model and all
+"""This module contains the definition of `DataModel` pydantic model and all
 its sub-models and validators.
 """
 
@@ -160,7 +160,7 @@ class BaseVerifiedMetadata(SchemaModel):
 
     creator: StrListType = Field(
         description=(
-            "List of contributors (comma seperated) to the data model creation, "
+            "List of contributors (comma separated) to the data model creation, "
             "typically information architects are considered as contributors."
         ),
     )
@@ -175,7 +175,7 @@ class BaseVerifiedMetadata(SchemaModel):
 
     source_id: URIRefType | None = Field(
         None,
-        description="Id of source that produced this rules",
+        description="Id of source that produced this data model",
         alias="sourceId",
     )
 
@@ -254,12 +254,7 @@ class BaseVerifiedMetadata(SchemaModel):
 
 class BaseVerifiedDataModel(SchemaModel, ABC):
     """
-    Rules is a core concept in `neat`. This represents fusion of data model
-    definitions and (optionally) the transformation rules used to transform the data/graph
-    from the source representation to the target representation defined by the data model.
-    The rules are defined in an Excel sheet and then parsed into a `Rules` object. The
-    `Rules` object is then used to generate data model and the `RDF` graph made of data
-    model instances.
+    Data Model is a core concept in `neat`.
 
     Args:
         metadata: Data model metadata
@@ -317,11 +312,11 @@ class BaseVerifiedDataModel(SchemaModel, ABC):
     ) -> dict[str, Any]:
         """Dump the model to a dictionary.
 
-        This is used in the Exporters to dump rules in the required format.
+        This is used in the Exporters to the dump data model in the required format.
 
         Args:
             entities_exclude_defaults: Whether to exclude default prefix (and version) for entities.
-                For example, given a class that is dumped as 'my_prefix:MyClass', if the prefix for the rules
+                For example, given a class that is dumped as 'my_prefix:MyClass', if the prefix for the data model
                 set in metadata.prefix = 'my_prefix', then this class will be dumped as 'MyClass' when this flag is set.
                 Defaults to True.
             sort: Whether to sort the entities in the output.

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

@@ -23,7 +23,7 @@ from ._verified import ConceptualDataModel, ConceptualProperty
 
 
 class ConceptualValidation:
-    """This class does all the validation of the Information rules that have dependencies
+    """This class does all the validation of the conceptual data model that have dependencies
     between components."""
 
     def __init__(

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

@@ -43,7 +43,7 @@ class ConceptualMetadata(BaseVerifiedMetadata):
     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")
+    physical: URIRef | str | None = Field(None, description="Link to the physical data model level")
 
 
 def _get_metadata(context: Any) -> ConceptualMetadata | None:
@@ -300,7 +300,7 @@ class ConceptualDataModel(BaseVerifiedDataModel):
             if view.conceptual in classes_by_neat_id:
                 classes_by_neat_id[view.conceptual].physical = neat_id
 
-    def as_dms_rules(self) -> "PhysicalDataModel":
+    def as_physical_data_model(self) -> "PhysicalDataModel":
         from cognite.neat.core._data_model.transformers._converters import (
             _ConceptualDataModelConverter,
         )

cognite/neat/core/_data_model/models/mapping/_classic2core.py

@@ -32,7 +32,7 @@ def load_classic_to_core_mapping(org_name: str | None, source_space: str, source
 
     read: ImportedDataModel[UnverifiedPhysicalDataModel] = DictImporter(loaded).to_data_model()
     if not isinstance(read.unverified_data_model, UnverifiedPhysicalDataModel):
-        raise NeatValueError(f"Expected DMS rules, but got {type(read.unverified_data_model).__name__}")
+        raise NeatValueError(f"Expected physical data model, but got {type(read.unverified_data_model).__name__}")
 
     verified = VerifyPhysicalDataModel(validate=False).transform(read)
 

cognite/neat/core/_data_model/models/physical/_exporter.py

@@ -63,15 +63,16 @@ from ._verified import (
 
 
 class _DMSExporter:
-    """The DMS Exporter is responsible for exporting the DMSRules to a DMSSchema.
+    """The DMS Exporter is responsible for exporting the physical data model to a DMSSchema.
 
-    This kept in this location such that it can be used by the DMSRules to validate the schema.
+    This kept in this location such that it can be used by the physical data model to validate the schema.
     (This module cannot have a dependency on the exporter module, as it would create a circular dependency.)
 
     Args
         include_pipeline (bool): If True, the pipeline will be included with the schema. Pipeline means the
             raw tables and transformations necessary to populate the data model.
-        instance_space (str): The space to use for the instance. Defaults to None,`Rules.metadata.space` will be used
+        instance_space (str): The space to use for the instance. Defaults to None,`
+            PhysicalDataModel.metadata.space` will be used
         remove_cdf_spaces(bool): The
     """