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

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

@@ -1,18 +1,30 @@
 """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 cognite.client.utils._importing import local_import
+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 (
+    ImportedDataModel,
+    T_UnverifiedDataModel,
+)
+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 +32,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
 
@@ -37,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"]),
@@ -243,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.
@@ -253,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()
@@ -268,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:
@@ -286,30 +300,47 @@ class ExcelImporter(BaseImporter[T_InputRules]):
     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
 
-class GoogleSheetImporter(BaseImporter[T_InputRules]):
-    """Import rules from a Google Sheet.
+        Args:
+            filepath (Path): The path to the Excel file.
 
-    .. warning::
+        """
 
-        This importer is experimental and may not work as expected.
+        workbook = load_workbook(filepath)
 
-    Args:
-        sheet_id (str): The Google Sheet ID.
-        skiprows (int): The number of rows to skip when reading the Google Sheet.
-    """
+        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"
 
-    def __init__(self, sheet_id: str, skiprows: int = 1):
-        self.sheet_id = sheet_id
-        self.skiprows = skiprows
+            if "Properties" in workbook.sheetnames:
+                _replace_class_with_concept_cell(workbook["Properties"])
 
-    def to_rules(self) -> ReadRules[T_InputRules]:
-        raise NotImplementedError("Google Sheet Importer is not yet implemented.")
+            with tempfile.NamedTemporaryFile(prefix="temp_neat_file", suffix=".xlsx", delete=False) as temp_file:
+                workbook.save(temp_file.name)
+                return Path(temp_file.name)
 
-    def _get_sheets(self) -> dict[str, pd.DataFrame]:
-        local_import("gspread", "google")
-        import gspread  # type: ignore[import]
+        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.
 
-        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()}
+    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

@@ -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 .physical._unverified import UnverifiedPhysicalDataModel
+from .physical._verified import PhysicalDataModel
+
+INPUT_RULES_BY_ROLE: dict[RoleTypes, type[UnverifiedConceptualDataModel] | type[UnverifiedPhysicalDataModel]] = {
+    RoleTypes.information: UnverifiedConceptualDataModel,
+    RoleTypes.dms: UnverifiedPhysicalDataModel,
+}
+VERIFIED_RULES_BY_ROLE: dict[RoleTypes, type[ConceptualDataModel] | type[PhysicalDataModel]] = {
+    RoleTypes.information: ConceptualDataModel,
+    RoleTypes.dms: PhysicalDataModel,
+}
+
+
+__all__ = [
+    "INPUT_RULES_BY_ROLE",
+    "ConceptualDataModel",
+    "DMSSchema",
+    "DataModelType",
+    "ExtensionCategory",
+    "PhysicalDataModel",
+    "RoleTypes",
+    "SchemaCompleteness",
+    "SheetList",
+    "SheetRow",
+    "UnverifiedConceptualDataModel",
+    "UnverifiedPhysicalDataModel",
+]

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
@@ -110,7 +110,7 @@ class InputRules(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())
 
@@ -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,18 +27,18 @@ 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,
+    PhysicalPropertyType,
     SpaceType,
     StrListType,
     URIRefType,
     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]]:
@@ -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/{_rules → _data_model}/models/_types.py

@@ -14,23 +14,23 @@ from pydantic import (
 )
 from pydantic.functional_serializers import PlainSerializer
 
-from cognite.neat.core._issues.errors import RegexViolationError
-from cognite.neat.core._issues.warnings import RegexViolationWarning
-from cognite.neat.core._rules._constants import (
+from cognite.neat.core._data_model._constants import (
     DATA_MODEL_COMPLIANCE_REGEX,
     PATTERNS,
     PREFIX_COMPLIANCE_REGEX,
     VERSION_COMPLIANCE_REGEX,
     EntityTypes,
 )
-from cognite.neat.core._rules.models.entities._multi_value import MultiValueTypeInfo
-from cognite.neat.core._rules.models.entities._single_value import (
-    ClassEntity,
+from cognite.neat.core._data_model.models.entities._multi_value import MultiValueTypeInfo
+from cognite.neat.core._data_model.models.entities._single_value import (
+    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)
 
 
@@ -135,13 +135,13 @@ SpaceType = Annotated[
     AfterValidator(_external_id_validation_factory(EntityTypes.space, "")),
 ]
 
-InformationPropertyType = Annotated[
+ConceptualPropertyType = Annotated[
     str,
-    AfterValidator(_external_id_validation_factory(EntityTypes.information_property, "Property column in properties")),
+    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
 

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

@@ -0,0 +1,25 @@
+from ._unverified import (
+    UnverifiedConcept,
+    UnverifiedConceptualDataModel,
+    UnverifiedConceptualMetadata,
+    UnverifiedConceptualProperty,
+)
+from ._validation import ConceptualValidation
+from ._verified import (
+    Concept,
+    ConceptualDataModel,
+    ConceptualMetadata,
+    ConceptualProperty,
+)
+
+__all__ = [
+    "Concept",
+    "ConceptualDataModel",
+    "ConceptualMetadata",
+    "ConceptualProperty",
+    "ConceptualValidation",
+    "UnverifiedConcept",
+    "UnverifiedConceptualDataModel",
+    "UnverifiedConceptualMetadata",
+    "UnverifiedConceptualProperty",
+]

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

@@ -7,26 +7,29 @@ from cognite.client import data_modeling as dm
 from rdflib import Namespace, URIRef
 
 from cognite.neat.core._constants import DEFAULT_NAMESPACE
-from cognite.neat.core._rules.models._base_input import InputComponent, InputRules
-from cognite.neat.core._rules.models.data_types import DataType
-from cognite.neat.core._rules.models.entities import (
-    ClassEntity,
+from cognite.neat.core._data_model.models._base_unverified import (
+    UnverifiedComponent,
+    UnverifiedDataModel,
+)
+from cognite.neat.core._data_model.models.data_types import DataType
+from cognite.neat.core._data_model.models.entities import (
+    ConceptEntity,
     MultiValueTypeInfo,
     UnknownEntity,
     load_value_type,
 )
 from cognite.neat.core._utils.rdf_ import uri_display_name
 
-from ._rules import (
-    InformationClass,
-    InformationMetadata,
-    InformationProperty,
-    InformationRules,
+from ._verified import (
+    Concept,
+    ConceptualDataModel,
+    ConceptualMetadata,
+    ConceptualProperty,
 )
 
 
 @dataclass
-class InformationInputMetadata(InputComponent[InformationMetadata]):
+class UnverifiedConceptualMetadata(UnverifiedComponent[ConceptualMetadata]):
     space: str
     external_id: str
     version: str
@@ -36,12 +39,11 @@ class InformationInputMetadata(InputComponent[InformationMetadata]):
     created: datetime | str | None = None
     updated: datetime | str | None = None
     physical: str | URIRef | None = None
-    conceptual: str | URIRef | None = None
     source_id: str | URIRef | None = None
 
     @classmethod
-    def _get_verified_cls(cls) -> type[InformationMetadata]:
-        return InformationMetadata
+    def _get_verified_cls(cls) -> type[ConceptualMetadata]:
+        return ConceptualMetadata
 
     def dump(self, **kwargs: Any) -> dict[str, Any]:
         output = super().dump()
@@ -66,7 +68,7 @@ class InformationInputMetadata(InputComponent[InformationMetadata]):
             Unlike namespace, the identifier does not end with "/" or "#".
 
         """
-        return DEFAULT_NAMESPACE[f"data-model/unverified/logical/{self.space}/{self.external_id}/{self.version}"]
+        return DEFAULT_NAMESPACE[f"data-model/unverified/conceptual/{self.space}/{self.external_id}/{self.version}"]
 
     @property
     def namespace(self) -> Namespace:
@@ -75,10 +77,10 @@ class InformationInputMetadata(InputComponent[InformationMetadata]):
 
 
 @dataclass
-class InformationInputProperty(InputComponent[InformationProperty]):
-    class_: ClassEntity | str
+class UnverifiedConceptualProperty(UnverifiedComponent[ConceptualProperty]):
+    concept: ConceptEntity | str
     property_: str
-    value_type: DataType | ClassEntity | MultiValueTypeInfo | UnknownEntity | str
+    value_type: DataType | ConceptEntity | MultiValueTypeInfo | UnknownEntity | str
     name: str | None = None
     description: str | None = None
     min_count: int | None = None
@@ -91,65 +93,66 @@ class InformationInputProperty(InputComponent[InformationProperty]):
 
     # linking
     physical: str | URIRef | None = None
-    conceptual: str | URIRef | None = None
 
     @classmethod
-    def _get_verified_cls(cls) -> type[InformationProperty]:
-        return InformationProperty
+    def _get_verified_cls(cls) -> type[ConceptualProperty]:
+        return ConceptualProperty
 
     def dump(self, default_prefix: str, **kwargs) -> dict[str, Any]:  # type: ignore
         output = super().dump()
-        output["Class"] = ClassEntity.load(self.class_, prefix=default_prefix)
+        output["Concept"] = ConceptEntity.load(self.concept, prefix=default_prefix)
         output["Value Type"] = load_value_type(self.value_type, default_prefix)
         return output
 
-    def copy(self, update: dict[str, Any], default_prefix: str) -> "InformationInputProperty":
-        return cast(InformationInputProperty, type(self)._load({**self.dump(default_prefix), **update}))
+    def copy(self, update: dict[str, Any], default_prefix: str) -> "UnverifiedConceptualProperty":
+        return cast(
+            UnverifiedConceptualProperty,
+            type(self)._load({**self.dump(default_prefix), **update}),
+        )
 
 
 @dataclass
-class InformationInputClass(InputComponent[InformationClass]):
-    class_: ClassEntity | str
+class UnverifiedConcept(UnverifiedComponent[Concept]):
+    concept: ConceptEntity | str
     name: str | None = None
     description: str | None = None
-    implements: str | list[ClassEntity] | None = None
+    implements: str | list[ConceptEntity] | None = None
     instance_source: str | None = None
     neatId: str | URIRef | None = None
     # linking
     physical: str | URIRef | None = None
-    conceptual: str | URIRef | None = None
 
     @classmethod
-    def _get_verified_cls(cls) -> type[InformationClass]:
-        return InformationClass
+    def _get_verified_cls(cls) -> type[Concept]:
+        return Concept
 
     @property
-    def class_str(self) -> str:
-        return str(self.class_)
+    def concept_str(self) -> str:
+        return str(self.concept)
 
     def dump(self, default_prefix: str, **kwargs) -> dict[str, Any]:  # type: ignore
         output = super().dump()
-        parent: list[ClassEntity] | None = None
+        parent: list[ConceptEntity] | None = None
         if isinstance(self.implements, str):
             self.implements = self.implements.strip()
-            parent = [ClassEntity.load(parent, prefix=default_prefix) for parent in self.implements.split(",")]
+            parent = [ConceptEntity.load(parent, prefix=default_prefix) for parent in self.implements.split(",")]
         elif isinstance(self.implements, list):
-            parent = [ClassEntity.load(parent_, prefix=default_prefix) for parent_ in self.implements]
-        output["Class"] = ClassEntity.load(self.class_, prefix=default_prefix)
+            parent = [ConceptEntity.load(parent_, prefix=default_prefix) for parent_ in self.implements]
+        output["Concept"] = ConceptEntity.load(self.concept, prefix=default_prefix)
         output["Implements"] = parent
         return output
 
 
 @dataclass
-class InformationInputRules(InputRules[InformationRules]):
-    metadata: InformationInputMetadata
-    properties: list[InformationInputProperty] = field(default_factory=list)
-    classes: list[InformationInputClass] = field(default_factory=list)
+class UnverifiedConceptualDataModel(UnverifiedDataModel[ConceptualDataModel]):
+    metadata: UnverifiedConceptualMetadata
+    properties: list[UnverifiedConceptualProperty] = field(default_factory=list)
+    concepts: list[UnverifiedConcept] = field(default_factory=list)
     prefixes: dict[str, Namespace] | None = None
 
     @classmethod
-    def _get_verified_cls(cls) -> type[InformationRules]:
-        return InformationRules
+    def _get_verified_cls(cls) -> type[ConceptualDataModel]:
+        return ConceptualDataModel
 
     def dump(self) -> dict[str, Any]:
         default_prefix = self.metadata.prefix
@@ -157,7 +160,7 @@ class InformationInputRules(InputRules[InformationRules]):
         return dict(
             Metadata=self.metadata.dump(),
             Properties=[prop.dump(default_prefix) for prop in self.properties],
-            Classes=[class_.dump(default_prefix) for class_ in self.classes],
+            Concepts=[concept.dump(default_prefix) for concept in self.concepts],
             Prefixes=self.prefixes,
         )
 
@@ -177,7 +180,7 @@ class InformationInputRules(InputRules[InformationRules]):
             "external_id": self.metadata.external_id,
             "space": self.metadata.space,
             "version": self.metadata.version,
-            "classes": len(self.classes),
+            "concepts": len(self.concepts),
             "properties": len(self.properties),
         }