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

cognite/neat/core/{_rules → _data_model}/importers/_dtdl2rules/dtdl_converter.py

@@ -1,17 +1,7 @@
 from collections import Counter
 from collections.abc import Callable, Sequence
 
-from cognite.neat.core._issues import IssueList
-from cognite.neat.core._issues.errors import (
-    PropertyTypeNotSupportedError,
-    ResourceMissingIdentifierError,
-    ResourceNotFoundError,
-)
-from cognite.neat.core._issues.warnings import (
-    PropertyTypeNotSupportedWarning,
-    ResourceTypeNotSupportedWarning,
-)
-from cognite.neat.core._rules.importers._dtdl2rules.spec import (
+from cognite.neat.core._data_model.importers._dtdl2rules.spec import (
     DTMI,
     Command,
     CommandV2,
@@ -28,24 +18,34 @@ from cognite.neat.core._rules.importers._dtdl2rules.spec import (
     Telemetry,
     TelemetryV2,
 )
-from cognite.neat.core._rules.models.data_types import (
+from cognite.neat.core._data_model.models.conceptual import (
+    UnverifiedConceptualClass,
+    UnverifiedConceptualProperty,
+)
+from cognite.neat.core._data_model.models.data_types import (
     _DATA_TYPE_BY_NAME,
     DataType,
     Json,
     String,
 )
-from cognite.neat.core._rules.models.entities import ClassEntity
-from cognite.neat.core._rules.models.information import (
-    InformationInputClass,
-    InformationInputProperty,
+from cognite.neat.core._data_model.models.entities import ClassEntity
+from cognite.neat.core._issues import IssueList
+from cognite.neat.core._issues.errors import (
+    PropertyTypeNotSupportedError,
+    ResourceMissingIdentifierError,
+    ResourceNotFoundError,
+)
+from cognite.neat.core._issues.warnings import (
+    PropertyTypeNotSupportedWarning,
+    ResourceTypeNotSupportedWarning,
 )
 
 
 class _DTDLConverter:
     def __init__(self, issues: IssueList | None = None) -> None:
         self.issues = IssueList(issues or [])
-        self.properties: list[InformationInputProperty] = []
-        self.classes: list[InformationInputClass] = []
+        self.properties: list[UnverifiedConceptualProperty] = []
+        self.classes: list[UnverifiedConceptualClass] = []
         self._item_by_id: dict[DTMI, DTDLBase] = {}
 
         self._method_by_type = {
@@ -103,7 +103,7 @@ class _DTDLConverter:
             )
 
     def convert_interface(self, item: Interface, _: str | None) -> None:
-        class_ = InformationInputClass(
+        class_ = UnverifiedConceptualClass(
             class_=item.id_.as_class_id(),
             name=item.display_name,
             description=item.description,
@@ -137,7 +137,7 @@ class _DTDLConverter:
         if value_type is None:
             return None
 
-        prop = InformationInputProperty(
+        prop = UnverifiedConceptualProperty(
             class_=ClassEntity.load(parent),
             property_=item.name,
             name=item.display_name,
@@ -182,7 +182,7 @@ class _DTDLConverter:
         value_type = self.schema_to_value_type(item.request.schema_, item)
         if value_type is None:
             return
-        prop = InformationInputProperty(
+        prop = UnverifiedConceptualProperty(
             class_=ClassEntity.load(parent),
             property_=item.name,
             name=item.display_name,
@@ -201,7 +201,7 @@ class _DTDLConverter:
         value_type = self.schema_to_value_type(item.schema_, item)
         if value_type is None:
             return
-        prop = InformationInputProperty(
+        prop = UnverifiedConceptualProperty(
             class_=ClassEntity.load(parent),
             property_=item.name,
             name=item.display_name,
@@ -230,7 +230,7 @@ class _DTDLConverter:
                 )
                 value_type = Json()
 
-            prop = InformationInputProperty(
+            prop = UnverifiedConceptualProperty(
                 class_=ClassEntity.load(parent),
                 property_=item.name,
                 name=item.display_name,
@@ -254,7 +254,7 @@ class _DTDLConverter:
             )
             return None
 
-        class_ = InformationInputClass(
+        class_ = UnverifiedConceptualClass(
             class_=item.id_.as_class_id(),
             name=item.display_name,
             description=item.description,
@@ -265,7 +265,7 @@ class _DTDLConverter:
             value_type = self.schema_to_value_type(field_.schema_, item)
             if value_type is None:
                 continue
-            prop = InformationInputProperty(
+            prop = UnverifiedConceptualProperty(
                 class_=class_.class_,
                 name=field_.name,
                 description=field_.description,

cognite/neat/core/{_rules → _data_model}/importers/_dtdl2rules/dtdl_importer.py

@@ -5,6 +5,16 @@ from pathlib import Path
 
 from pydantic import ValidationError
 
+from cognite.neat.core._data_model._shared import ReadRules
+from cognite.neat.core._data_model.importers._base import BaseImporter
+from cognite.neat.core._data_model.importers._dtdl2rules.dtdl_converter import _DTDLConverter
+from cognite.neat.core._data_model.importers._dtdl2rules.spec import (
+    DTDL_CLS_BY_TYPE_BY_SPEC,
+    DTDLBase,
+    Interface,
+)
+from cognite.neat.core._data_model.models import UnverifiedConceptualDataModel
+from cognite.neat.core._data_model.models.conceptual import UnverifiedConceptualMetadata
 from cognite.neat.core._issues import IssueList, MultiValueError, NeatIssue
 from cognite.neat.core._issues.warnings import (
     FileItemNotSupportedWarning,
@@ -13,20 +23,10 @@ from cognite.neat.core._issues.warnings import (
     FileTypeUnexpectedWarning,
     NeatValueWarning,
 )
-from cognite.neat.core._rules._shared import ReadRules
-from cognite.neat.core._rules.importers._base import BaseImporter
-from cognite.neat.core._rules.importers._dtdl2rules.dtdl_converter import _DTDLConverter
-from cognite.neat.core._rules.importers._dtdl2rules.spec import (
-    DTDL_CLS_BY_TYPE_BY_SPEC,
-    DTDLBase,
-    Interface,
-)
-from cognite.neat.core._rules.models import InformationInputRules
-from cognite.neat.core._rules.models.information import InformationInputMetadata
 from cognite.neat.core._utils.text import humanize_collection, to_pascal_case
 
 
-class DTDLImporter(BaseImporter[InformationInputRules]):
+class DTDLImporter(BaseImporter[UnverifiedConceptualDataModel]):
     """Importer from Azure Digital Twin - DTDL (Digital Twin Definition Language).
 
     This importer supports DTDL v2.0 and v3.0.
@@ -126,7 +126,7 @@ class DTDLImporter(BaseImporter[InformationInputRules]):
                             items.append(item)
         return cls(items, zip_file.stem, read_issues=issues)
 
-    def to_rules(self) -> ReadRules[InformationInputRules]:
+    def to_rules(self) -> ReadRules[UnverifiedConceptualDataModel]:
         converter = _DTDLConverter(self._read_issues)
 
         converter.convert(self._items)
@@ -143,8 +143,8 @@ class DTDLImporter(BaseImporter[InformationInputRules]):
         else:
             metadata["space"] = most_common_prefix
 
-        rules = InformationInputRules(
-            metadata=InformationInputMetadata.load(metadata),
+        rules = UnverifiedConceptualDataModel(
+            metadata=UnverifiedConceptualMetadata.load(metadata),
             properties=converter.properties,
             classes=converter.classes,
         )

cognite/neat/core/{_rules → _data_model}/importers/_dtdl2rules/spec.py

@@ -15,7 +15,7 @@ from typing import TYPE_CHECKING, Any, ClassVar, Literal, TypeAlias
 from pydantic import BaseModel, Field, field_validator, model_serializer, model_validator
 from pydantic.fields import FieldInfo
 
-from cognite.neat.core._rules.models.entities import ClassEntity
+from cognite.neat.core._data_model.models.entities import ClassEntity
 
 if TYPE_CHECKING:
     from pydantic.type_adapter import IncEx

cognite/neat/core/{_rules → _data_model}/importers/_rdf/_base.py

@@ -7,15 +7,17 @@ from rdflib import Graph, Namespace, URIRef
 from typing_extensions import Self
 
 from cognite.neat.core._constants import get_default_prefixes_and_namespaces
+from cognite.neat.core._data_model._shared import ReadRules
+from cognite.neat.core._data_model.importers._base import BaseImporter
+from cognite.neat.core._data_model.models._base_verified import RoleTypes
+from cognite.neat.core._data_model.models.conceptual import (
+    UnverifiedConceptualDataModel,
+)
+from cognite.neat.core._data_model.models.data_types import AnyURI
+from cognite.neat.core._data_model.models.entities import UnknownEntity
 from cognite.neat.core._issues import IssueList, MultiValueError
 from cognite.neat.core._issues.errors import FileReadError
 from cognite.neat.core._issues.errors._general import NeatValueError
-from cognite.neat.core._rules._shared import ReadRules
-from cognite.neat.core._rules.importers._base import BaseImporter
-from cognite.neat.core._rules.models._base_rules import RoleTypes
-from cognite.neat.core._rules.models.data_types import AnyURI
-from cognite.neat.core._rules.models.entities import UnknownEntity
-from cognite.neat.core._rules.models.information import InformationInputRules
 from cognite.neat.core._store import NeatGraphStore
 from cognite.neat.core._utils.rdf_ import get_namespace
 
@@ -25,7 +27,7 @@ DEFAULT_NON_EXISTING_NODE_TYPE = AnyURI()
 DEFAULT_RDF_DATA_MODEL_ID = ("neat_space", "RDFDataModel", "rdf")
 
 
-class BaseRDFImporter(BaseImporter[InformationInputRules]):
+class BaseRDFImporter(BaseImporter[UnverifiedConceptualDataModel]):
     """Baser RDF importers used for all rules importers that are using RDF as input.
 
     Args:
@@ -115,7 +117,7 @@ class BaseRDFImporter(BaseImporter[InformationInputRules]):
 
     def to_rules(
         self,
-    ) -> ReadRules[InformationInputRules]:
+    ) -> ReadRules[UnverifiedConceptualDataModel]:
         """
         Creates `Rules` object from the data for target role.
         """
@@ -126,7 +128,7 @@ class BaseRDFImporter(BaseImporter[InformationInputRules]):
 
         rules_dict = self._to_rules_components()
 
-        rules = InformationInputRules.load(rules_dict)
+        rules = UnverifiedConceptualDataModel.load(rules_dict)
         self.issue_list.trigger_warnings()
         return ReadRules(rules, {})
 

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

@@ -1,8 +1,8 @@
 """This module performs importing of various formats to one of serializations for which
 there are loaders to TransformationRules pydantic class."""
 
-from cognite.neat.core._rules.importers._rdf._base import BaseRDFImporter
-from cognite.neat.core._rules.importers._rdf._shared import (
+from cognite.neat.core._data_model.importers._rdf._base import BaseRDFImporter
+from cognite.neat.core._data_model.importers._rdf._shared import (
     parse_classes,
     parse_properties,
 )

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

@@ -12,18 +12,18 @@ 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.models import ConceptualDataModel, data_types
+from cognite.neat.core._data_model.models.conceptual import (
+    ConceptualClass,
+    ConceptualMetadata,
+    UnverifiedConceptualClass,
+    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._rules.analysis import RulesAnalysis
-from cognite.neat.core._rules.models import InformationRules, data_types
-from cognite.neat.core._rules.models.data_types import AnyURI
-from cognite.neat.core._rules.models.entities._single_value import UnknownEntity
-from cognite.neat.core._rules.models.information import (
-    InformationClass,
-    InformationInputClass,
-    InformationInputProperty,
-    InformationMetadata,
-)
 from cognite.neat.core._store import NeatGraphStore
 from cognite.neat.core._store._provenance import INSTANCES_ENTITY
 from cognite.neat.core._utils.collection_ import iterate_progress_bar
@@ -272,7 +272,7 @@ class InferenceImporter(BaseRDFImporter):
 
     def _default_metadata(self) -> dict[str, Any]:
         now = datetime.now(timezone.utc)
-        return InformationMetadata(
+        return ConceptualMetadata(
             space=self.data_model_id.space,
             external_id=self.data_model_id.external_id,
             version=cast(str, self.data_model_id.version),
@@ -357,7 +357,7 @@ class SubclassInferenceImporter(BaseRDFImporter):
         self,
         issue_list: IssueList,
         graph: Graph,
-        rules: InformationRules | None = None,
+        rules: 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:
@@ -399,13 +399,13 @@ class SubclassInferenceImporter(BaseRDFImporter):
 
     def _create_classes_properties(
         self, read_properties: list[_ReadProperties], prefixes: dict[str, Namespace]
-    ) -> tuple[list[InformationInputClass], list[InformationInputProperty]]:
+    ) -> tuple[list[UnverifiedConceptualClass], list[UnverifiedConceptualProperty]]:
         if self._rules:
             existing_classes = {class_.class_.suffix: class_ for class_ in self._rules.classes}
         else:
             existing_classes = {}
-        classes: list[InformationInputClass] = []
-        properties_by_class_suffix_by_property_id: dict[str, dict[str, InformationInputProperty]] = {}
+        classes: list[UnverifiedConceptualClass] = []
+        properties_by_class_suffix_by_property_id: dict[str, dict[str, UnverifiedConceptualProperty]] = {}
 
         # Help for IDE
         type_uri: URIRef
@@ -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(InformationInputClass(class_=parent_suffix))
+                    classes.append(UnverifiedConceptualClass(class_=parent_suffix))
                 else:
-                    classes.append(InformationInputClass.load(existing_classes[parent_suffix].model_dump()))
+                    classes.append(UnverifiedConceptualClass.load(existing_classes[parent_suffix].model_dump()))
             else:
                 shared_property_uris = set()
             shared_properties: dict[URIRef, list[_ReadProperties]] = defaultdict(list)
@@ -441,16 +441,16 @@ class SubclassInferenceImporter(BaseRDFImporter):
 
                 if class_suffix not in existing_classes:
                     classes.append(
-                        InformationInputClass(
+                        UnverifiedConceptualClass(
                             class_=class_suffix,
                             implements=parent_suffix,
                             instance_source=type_uri,
                         )
                     )
                 else:
-                    classes.append(InformationInputClass.load(existing_classes[class_suffix].model_dump()))
+                    classes.append(UnverifiedConceptualClass.load(existing_classes[class_suffix].model_dump()))
 
-                properties_by_id: dict[str, InformationInputProperty] = {}
+                properties_by_id: dict[str, UnverifiedConceptualProperty] = {}
                 for property_uri, read_properties in properties_by_property_uri.items():
                     if property_uri in shared_property_uris:
                         shared_properties[property_uri].extend(read_properties)
@@ -523,7 +523,7 @@ class SubclassInferenceImporter(BaseRDFImporter):
             existing_class_properties = {}
             existing_classes = {}
         properties_by_class_by_subclass: list[_ReadProperties] = []
-        existing_class: InformationClass | None
+        existing_class: ConceptualClass | 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:
@@ -577,10 +577,10 @@ class SubclassInferenceImporter(BaseRDFImporter):
         property_uri: URIRef,
         property_id: str,
         prefixes: dict[str, Namespace],
-    ) -> InformationInputProperty:
+    ) -> UnverifiedConceptualProperty:
         first = read_properties[0]
         value_type = self._get_value_type(read_properties, prefixes)
-        return InformationInputProperty(
+        return UnverifiedConceptualProperty(
             class_=class_suffix,
             property_=property_id,
             max_count=first.max_occurrence,
@@ -606,7 +606,7 @@ class SubclassInferenceImporter(BaseRDFImporter):
 
     def _default_metadata(self) -> dict[str, Any]:
         now = datetime.now(timezone.utc)
-        return InformationMetadata(
+        return ConceptualMetadata(
             space=self.data_model_id.space,
             external_id=self.data_model_id.external_id,
             version=cast(str, self.data_model_id.version),

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

@@ -1,8 +1,8 @@
 """This module performs importing of various formats to one of serializations for which
 there are loaders to TransformationRules pydantic class."""
 
-from cognite.neat.core._rules.importers._rdf._base import BaseRDFImporter
-from cognite.neat.core._rules.importers._rdf._shared import (
+from cognite.neat.core._data_model.importers._rdf._base import BaseRDFImporter
+from cognite.neat.core._data_model.importers._rdf._shared import (
     parse_classes,
     parse_properties,
 )

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

@@ -9,10 +9,16 @@ from pathlib import Path
 from typing import Literal, cast
 
 import pandas as pd
-from cognite.client.utils._importing import local_import
 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.models import (
+    INPUT_RULES_BY_ROLE,
+    VERIFIED_RULES_BY_ROLE,
+    RoleTypes,
+    SchemaCompleteness,
+)
 from cognite.neat.core._issues import IssueList, MultiValueError
 from cognite.neat.core._issues.errors import (
     FileMissingRequiredFieldError,
@@ -20,13 +26,6 @@ from cognite.neat.core._issues.errors import (
     FileReadError,
 )
 from cognite.neat.core._issues.warnings import FileMissingRequiredFieldWarning
-from cognite.neat.core._rules._shared import ReadRules, T_InputRules
-from cognite.neat.core._rules.models import (
-    INPUT_RULES_BY_ROLE,
-    VERIFIED_RULES_BY_ROLE,
-    RoleTypes,
-    SchemaCompleteness,
-)
 from cognite.neat.core._utils.spreadsheet import SpreadsheetRead, read_individual_sheet
 from cognite.neat.core._utils.text import humanize_collection
 
@@ -285,31 +284,3 @@ class ExcelImporter(BaseImporter[T_InputRules]):
     @property
     def source_uri(self) -> URIRef:
         return URIRef(f"file://{self.filepath.name}")
-
-
-class GoogleSheetImporter(BaseImporter[T_InputRules]):
-    """Import rules from a Google Sheet.
-
-    .. warning::
-
-        This importer is experimental and may not work as expected.
-
-    Args:
-        sheet_id (str): The Google Sheet ID.
-        skiprows (int): The number of rows to skip when reading the Google Sheet.
-    """
-
-    def __init__(self, sheet_id: str, skiprows: int = 1):
-        self.sheet_id = sheet_id
-        self.skiprows = skiprows
-
-    def to_rules(self) -> ReadRules[T_InputRules]:
-        raise NotImplementedError("Google Sheet Importer is not yet implemented.")
-
-    def _get_sheets(self) -> dict[str, pd.DataFrame]:
-        local_import("gspread", "google")
-        import gspread  # type: ignore[import]
-
-        client_google = gspread.service_account()
-        google_sheet = client_google.open_by_key(self.sheet_id)
-        return {worksheet.title: pd.DataFrame(worksheet.get_all_records()) for worksheet in google_sheet.worksheets()}

cognite/neat/core/{_rules → _data_model}/importers/_yaml2rules.py

@@ -3,6 +3,8 @@ from typing import Any, cast
 
 import yaml
 
+from cognite.neat.core._data_model._shared import ReadRules, T_InputRules
+from cognite.neat.core._data_model.models import INPUT_RULES_BY_ROLE, RoleTypes
 from cognite.neat.core._issues import IssueList, MultiValueError, NeatIssue
 from cognite.neat.core._issues.errors import (
     FileMissingRequiredFieldError,
@@ -12,8 +14,6 @@ from cognite.neat.core._issues.errors import (
     FileTypeUnexpectedError,
 )
 from cognite.neat.core._issues.warnings import NeatValueWarning
-from cognite.neat.core._rules._shared import ReadRules, T_InputRules
-from cognite.neat.core._rules.models import INPUT_RULES_BY_ROLE, RoleTypes
 
 from ._base import BaseImporter
 

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

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

cognite/neat/core/{_rules/models/_base_input.py → _data_model/models/_base_unverified.py}

@@ -1,15 +1,15 @@
-"""Module for base classes for the input models.
+"""Module for base classes for the unverified models.
 
-The philosophy of the input models is:
+The philosophy of the unverified data models is:
 
-* Provide an easy way to input rules. The type hints are made to be human-friendly, for example, Literal instead of
-  Enum.
+* Provide an easy way to read data model into neat. The type hints are made to be human-friendly,
+  for example, Literal instead of Enum.
 * The .dump() method should fill out defaults and have shortcuts. For example, if the prefix is not provided for
   a class, then the prefix from the metadata is used. For views, if the class is not provided, it is assumed to
   be the same as the view.
 
-The base classes are to make it easy to create the input models with default behavior. They are also used for
-testing to ensure that input models correctly map to the verified rules models.
+The base classes are to make it easy to create the unverified data models with default behavior.
+They are also used for testing to ensure that unverified models correctly map to the verified models.
 """
 
 import sys
@@ -20,19 +20,19 @@ from typing import Any, Generic, TypeVar, Union, cast, get_args, get_origin, ove
 
 import pandas as pd
 
-from ._base_rules import BaseRules, SchemaModel
+from ._base_verified import BaseVerifiedDataModel, SchemaModel
 
 if sys.version_info >= (3, 11):
     from typing import Self
 else:
     from typing_extensions import Self
 
-T_BaseRules = TypeVar("T_BaseRules", bound=BaseRules)
+T_BaseRules = TypeVar("T_BaseRules", bound=BaseVerifiedDataModel)
 T_RuleModel = TypeVar("T_RuleModel", bound=SchemaModel)
 
 
 @dataclass
-class InputRules(Generic[T_BaseRules], ABC):
+class UnverifiedDataModel(Generic[T_BaseRules], ABC):
     """Input rules are raw data that is not yet validated."""
 
     @classmethod
@@ -127,11 +127,11 @@ class InputRules(Generic[T_BaseRules], ABC):
         return output
 
 
-T_InputRules = TypeVar("T_InputRules", bound=InputRules)
+T_InputRules = TypeVar("T_InputRules", bound=UnverifiedDataModel)
 
 
 @dataclass
-class InputComponent(ABC, Generic[T_RuleModel]):
+class UnverifiedComponent(ABC, Generic[T_RuleModel]):
     @classmethod
     @abstractmethod
     def _get_verified_cls(cls) -> type[T_RuleModel]:

cognite/neat/core/{_rules/models/_base_rules.py → _data_model/models/_base_verified.py}

@@ -27,7 +27,7 @@ from pydantic_core import core_schema
 from rdflib import Namespace, URIRef
 
 from cognite.neat.core._constants import DEFAULT_NAMESPACE
-from cognite.neat.core._rules.models._types import (
+from cognite.neat.core._data_model.models._types import (
     ContainerEntityType,
     DataModelExternalIdType,
     DmsPropertyType,
@@ -37,8 +37,8 @@ from cognite.neat.core._rules.models._types import (
     VersionType,
     ViewEntityType,
 )
-from cognite.neat.core._rules.models.data_types import DataType
-from cognite.neat.core._rules.models.entities import (
+from cognite.neat.core._data_model.models.data_types import DataType
+from cognite.neat.core._data_model.models.entities import (
     EdgeEntity,
     ReverseConnectionEntity,
     ViewEntity,
@@ -99,7 +99,7 @@ class DataModelType(StrEnum):
     enterprise = "enterprise"
 
 
-class DataModelAspect(StrEnum):
+class DataModelLevel(StrEnum):
     conceptual = "conceptual"
     logical = "logical"
     physical = "physical"
@@ -134,13 +134,13 @@ class SchemaModel(BaseModel):
         return value
 
 
-class BaseMetadata(SchemaModel):
+class BaseVerifiedMetadata(SchemaModel):
     """
     Metadata model for data model
     """
 
     role: ClassVar[RoleTypes] = Field(description="Role of the person creating the data model")
-    aspect: ClassVar[DataModelAspect] = Field(description="Aspect of the data model")
+    level: ClassVar[DataModelLevel] = Field(description="Aspect of the data model")
     space: SpaceType = Field(description="The space where the data model is defined")
     external_id: DataModelExternalIdType = Field(
         alias="externalId", description="External identifier for the data model"
@@ -223,7 +223,7 @@ class BaseMetadata(SchemaModel):
             Unlike namespace, the identifier does not end with "/" or "#".
 
         """
-        return DEFAULT_NAMESPACE[f"data-model/verified/{self.aspect}/{self.space}/{self.external_id}/{self.version}"]
+        return DEFAULT_NAMESPACE[f"data-model/verified/{self.level}/{self.space}/{self.external_id}/{self.version}"]
 
     @property
     def namespace(self) -> Namespace:
@@ -237,7 +237,7 @@ class BaseMetadata(SchemaModel):
         return repr(self.as_data_model_id())
 
     @classmethod
-    def default(cls) -> "BaseMetadata":
+    def default(cls) -> "BaseVerifiedMetadata":
         """Returns a default instance of the metadata model."""
         now = datetime.now()
         return cls(
@@ -252,7 +252,7 @@ class BaseMetadata(SchemaModel):
         )
 
 
-class BaseRules(SchemaModel, ABC):
+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
@@ -265,7 +265,7 @@ class BaseRules(SchemaModel, ABC):
         metadata: Data model metadata
     """
 
-    metadata: BaseMetadata
+    metadata: BaseVerifiedMetadata
 
     @classmethod
     def headers_by_sheet(cls, by_alias: bool = False) -> dict[str, list[str]]: