cognite-neat 0.77.2__py3-none-any.whl → 0.77.4__py3-none-any.whl

cognite/neat/_version.py

@@ -1 +1 @@
-__version__ = "0.77.2"
+__version__ = "0.77.4"

cognite/neat/rules/analysis/_information_rules.py

@@ -13,23 +13,13 @@ from cognite.neat.rules.models.entities import ClassEntity, EntityTypes, ParentC
 from cognite.neat.rules.models.information import InformationClass, InformationProperty, InformationRules
 from cognite.neat.utils.utils import get_inheritance_path
 
-from ._base import BaseAnalysis, DataModelingScenario
+from ._base import BaseAnalysis
 
 
 class InformationArchitectRulesAnalysis(BaseAnalysis):
     def __init__(self, rules: InformationRules):
         self.rules = rules
 
-    @property
-    def data_modeling_scenario(self) -> DataModelingScenario:
-        if not self.rules.reference:
-            return DataModelingScenario.from_scratch
-
-        if self.rules.metadata.namespace == self.rules.reference.metadata.namespace:
-            return DataModelingScenario.extend_reference
-        else:
-            return DataModelingScenario.build_solution
-
     @property
     def referred_classes(self) -> set[ClassEntity]:
         return self.directly_referred_classes.union(self.inherited_referred_classes)
@@ -362,7 +352,7 @@ class InformationArchitectRulesAnalysis(BaseAnalysis):
 
         rules = cast(InformationRules, self.rules.reference if use_reference else self.rules)
 
-        if not rules.metadata.schema_ is not SchemaCompleteness.complete:
+        if rules.metadata.schema_ is not SchemaCompleteness.complete:
             raise ValueError("Rules are not complete cannot perform reduction!")
         class_as_dict = self.as_class_dict()
         class_parents_pairs = self.class_parent_pairs()

cognite/neat/rules/exporters/_rules2excel.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
 import itertools
-from datetime import datetime
+import json
+from datetime import datetime, timezone
 from pathlib import Path
 from types import GenericAlias
 from typing import Any, ClassVar, Literal, cast, get_args
@@ -14,14 +15,14 @@ from openpyxl.worksheet.worksheet import Worksheet
 from cognite.neat.rules._shared import Rules
 from cognite.neat.rules.models import (
     DataModelType,
-    DMSRules,
-    DomainRules,
     ExtensionCategory,
-    InformationRules,
     RoleTypes,
     SchemaCompleteness,
     SheetEntity,
 )
+from cognite.neat.rules.models.dms import DMSMetadata
+from cognite.neat.rules.models.domain import DomainMetadata
+from cognite.neat.rules.models.information import InformationMetadata
 
 from ._base import BaseExporter
 
@@ -34,9 +35,6 @@ class ExcelExporter(BaseExporter[Workbook]):
             on the different styles.
         output_role: The role to use for the exported spreadsheet. If provided, the rules will be converted to
             this role formate before being written to excel. If not provided, the role from the rules will be used.
-        new_model_id: The new model ID to use for the exported spreadsheet. This is only applicable if the input
-            rules have 'is_reference' set. If provided, the model ID will be used to automatically create the
-            new metadata sheet in the Excel file.
         dump_as: This determines how the rules are written to the Excel file. An Excel file has up to three sets of
            sheets: user, last, and reference. The user sheets are used for inputting rules from a user. The last sheets
            are used for the last version of the same model as the user, while the reference sheets are used for
@@ -49,6 +47,10 @@ class ExcelExporter(BaseExporter[Workbook]):
                change a model that has already been published to CDF and that model is in production.
              * "reference": The rules are written to the reference sheets. This is typically used when you want to build
                a new solution on top of an enterprise model.
+        new_model_id: The new model ID to use for the exported spreadsheet. This is only applicable if the input
+            rules have 'is_reference' set. If provided, the model ID will be used to automatically create the
+            new metadata sheet in the Excel file. The model id is expected to be a tuple of (prefix, title)
+            (space, external_id) for InformationRules and DMSRules respectively.
 
     The following styles are available:
 
@@ -74,8 +76,8 @@ class ExcelExporter(BaseExporter[Workbook]):
         self,
         styling: Style = "default",
         output_role: RoleTypes | None = None,
-        new_model_id: tuple[str, str, str] | None = None,
         dump_as: DumpOptions = "user",
+        new_model_id: tuple[str, str] | None = None,
     ):
         if styling not in self.style_options:
             raise ValueError(f"Invalid styling: {styling}. Valid options are {self.style_options}")
@@ -106,9 +108,11 @@ class ExcelExporter(BaseExporter[Workbook]):
         dumped_last_rules: dict[str, Any] | None = None
         dumped_reference_rules: dict[str, Any] | None = None
         if self.dump_as != "user":
-            # Writes empty reference sheets
+            action = {"last": "update", "reference": "create"}[self.dump_as]
+            metadata_creator = _MetadataCreator(action, self.new_model_id)  # type: ignore[arg-type]
+
             dumped_user_rules = {
-                "Metadata": self._create_metadata_sheet_user_rules(rules),
+                "Metadata": metadata_creator.create(rules.metadata),
             }
 
             if self.dump_as == "last":
@@ -128,11 +132,11 @@ class ExcelExporter(BaseExporter[Workbook]):
         self._write_sheets(workbook, dumped_user_rules, rules)
         if dumped_last_rules:
             self._write_sheets(workbook, dumped_last_rules, rules, sheet_prefix="Last")
+            self._write_metadata_sheet(workbook, dumped_last_rules["Metadata"], sheet_prefix="Last")
 
         if dumped_reference_rules:
-            prefix = "Ref"
-            self._write_sheets(workbook, dumped_reference_rules, rules, sheet_prefix=prefix)
-            self._write_metadata_sheet(workbook, dumped_reference_rules["Metadata"], sheet_prefix=prefix)
+            self._write_sheets(workbook, dumped_reference_rules, rules, sheet_prefix="Ref")
+            self._write_metadata_sheet(workbook, dumped_reference_rules["Metadata"], sheet_prefix="Ref")
 
         if self._styling_level > 0:
             self._adjust_column_widths(workbook)
@@ -234,82 +238,67 @@ class ExcelExporter(BaseExporter[Workbook]):
                 sheet.column_dimensions[selected_column.column_letter].width = max(current, max_length + 0.5)
         return None
 
-    def _create_metadata_sheet_user_rules(self, rules: Rules) -> dict[str, Any]:
-        metadata: dict[str, Any] = {
-            field_alias: None for field_alias in rules.metadata.model_dump(by_alias=True).keys()
-        }
-        if "creator" in metadata:
-            metadata["creator"] = "YOUR NAME"
-
-        if isinstance(rules, DomainRules):
-            return metadata
-        elif isinstance(rules, DMSRules):
-            existing_model_id = (rules.metadata.space, rules.metadata.external_id, rules.metadata.version)
-        elif isinstance(rules, InformationRules):
-            existing_model_id = (rules.metadata.prefix, rules.metadata.name, rules.metadata.version)
-        else:
-            raise ValueError(f"Unsupported rules type: {type(rules)}")
-        existing_metadata = rules.metadata.model_dump(by_alias=True)
-        if isinstance(existing_metadata["created"], datetime):
-            metadata["created"] = existing_metadata["created"].replace(tzinfo=None)
-        if isinstance(existing_metadata["updated"], datetime):
-            metadata["updated"] = existing_metadata["updated"].replace(tzinfo=None)
-        # Excel does not support timezone in datetime strings
-        now_iso = datetime.now().replace(tzinfo=None).isoformat()
-        is_info = isinstance(rules, InformationRules)
-        is_dms = isinstance(rules, DMSRules)
-        is_extension = self.new_model_id is not None or rules.reference is not None
-        is_solution = rules.metadata.data_model_type == DataModelType.solution
-
-        if is_solution and self.new_model_id:
-            metadata["prefix" if is_info else "space"] = self.new_model_id[0]  # type: ignore[index]
-            metadata["title" if is_info else "externalId"] = self.new_model_id[1]  # type: ignore[index]
-            metadata["version"] = self.new_model_id[2]  # type: ignore[index]
-        elif is_solution and self.dump_as == "reference" and rules.reference:
-            metadata["prefix" if is_info else "space"] = "YOUR_PREFIX"
-            metadata["title" if is_info else "externalId"] = "YOUR_TITLE"
-            metadata["version"] = "1"
-        else:
-            metadata["prefix" if is_info else "space"] = existing_model_id[0]
-            metadata["title" if is_info else "externalId"] = existing_model_id[1]
-            metadata["version"] = existing_model_id[2]
-
-        if is_solution and is_info and self.new_model_id:
-            metadata["namespace"] = f"http://purl.org/{self.new_model_id[0]}/"  # type: ignore[index]
-        elif is_info:
-            metadata["namespace"] = existing_metadata["namespace"]
-
-        if is_solution and is_dms and self.new_model_id:
-            metadata["name"] = self.new_model_id[1]  # type: ignore[index]
-
-        if is_solution:
-            metadata["created"] = now_iso
-        else:
-            metadata["created"] = existing_metadata["created"]
-
-        if is_solution or is_extension:
-            metadata["updated"] = now_iso
-        else:
-            metadata["updated"] = existing_metadata["updated"]
 
-        if is_solution:
-            metadata["creator"] = "YOUR NAME"
-        else:
-            metadata["creator"] = existing_metadata["creator"]
-
-        if not is_solution:
-            metadata["description"] = existing_metadata["description"]
+class _MetadataCreator:
+    creator_name = "<YOUR NAME>"
 
-        if is_extension:
-            metadata["schema"] = SchemaCompleteness.extended.value
-        else:
-            metadata["schema"] = SchemaCompleteness.complete.value
-
-        if is_solution:
-            metadata["dataModelType"] = DataModelType.solution.value
+    def __init__(
+        self,
+        action: Literal["create", "update"],
+        new_model_id: tuple[str, str] | None = None,
+    ):
+        self.action = action
+        self.new_model_id = new_model_id or ("YOUR_PREFIX", "YOUR_TITLE")
+
+    def create(self, metadata: DomainMetadata | InformationMetadata | DMSMetadata) -> dict[str, Any]:
+        now = datetime.now(timezone.utc).replace(microsecond=0, tzinfo=None)
+        if self.action == "update":
+            output = json.loads(metadata.model_dump_json(by_alias=True))
+            # This is the same for Information and DMS
+            output["updated"] = now.isoformat()
+            output["schema"] = SchemaCompleteness.extended.value
+            output["extension"] = ExtensionCategory.addition.value
+            if value := output.get("creator"):
+                output["creator"] = f"{value}, {self.creator_name}"
+            else:
+                output["creator"] = self.creator_name
+            return output
+
+        # Action "create"
+        if isinstance(metadata, DomainMetadata):
+            output = {field_alias: None for field_alias in metadata.model_dump(by_alias=True).keys()}
+            output["role"] = metadata.role.value
+            output["creator"] = self.creator_name
+            return output
+
+        new_metadata = self._create_new_info(now)
+        if isinstance(metadata, DMSMetadata):
+            from cognite.neat.rules.models.information._converter import _InformationRulesConverter
+
+            output_metadata: DMSMetadata | InformationMetadata = _InformationRulesConverter._convert_metadata_to_dms(
+                new_metadata
+            )
+        elif isinstance(metadata, InformationMetadata):
+            output_metadata = new_metadata
         else:
-            metadata["dataModelType"] = DataModelType.enterprise.value
-
-        metadata["extension"] = ExtensionCategory.addition.value
-        metadata["role"] = (self.output_role and self.output_role.value) or rules.metadata.role.value
-        return metadata
+            raise ValueError(f"Bug in Neat: Unknown metadata type: {type(metadata)}")
+
+        created = json.loads(output_metadata.model_dump_json(by_alias=True))
+        created.pop("extension", None)
+        return created
+
+    def _create_new_info(self, now: datetime) -> InformationMetadata:
+        prefix = self.new_model_id[0]
+        return InformationMetadata(
+            data_model_type=DataModelType.solution,
+            schema_=SchemaCompleteness.complete,
+            extension=ExtensionCategory.addition,
+            prefix=prefix,
+            namespace=f"http://purl.org/neat/{prefix}/",  # type: ignore[arg-type]
+            description=None,
+            version="1",
+            created=now,
+            updated=now,
+            creator=[self.creator_name],
+            name=self.new_model_id[1],
+        )

cognite/neat/rules/importers/_dms2rules.py

@@ -61,8 +61,10 @@ class DMSImporter(BaseImporter):
         self.ref_metadata = ref_metadata
         self.issue_list = IssueList(read_issues)
         self._all_containers_by_id = schema.containers.copy()
+        self._all_view_ids = set(self.root_schema.views.keys())
         if self.root_schema.reference:
             self._all_containers_by_id.update(self.root_schema.reference.containers)
+            self._all_view_ids.update(self.root_schema.reference.views.keys())
 
     @classmethod
     def from_data_model_id(
@@ -100,15 +102,17 @@ class DMSImporter(BaseImporter):
         else:
             ref_model = None
 
-        try:
+        issue_list = IssueList()
+        with _handle_issues(issue_list) as result:
             schema = DMSSchema.from_data_model(client, user_model, ref_model)
-        except Exception as e:
-            return cls(DMSSchema(), [issues.importing.APIError(str(e))])
 
-        metadata = cls._create_metadata_from_model(user_model)
+        if result.result == "failure" or issue_list.has_errors:
+            return cls(DMSSchema(), issue_list)
+
+        metadata = cls._create_metadata_from_model(user_model, has_reference=ref_model is not None)
         ref_metadata = cls._create_metadata_from_model(ref_model) if ref_model else None
 
-        return cls(schema, [], metadata, ref_metadata)
+        return cls(schema, issue_list, metadata, ref_metadata)
 
     @classmethod
     def _find_model_in_list(
@@ -127,6 +131,7 @@ class DMSImporter(BaseImporter):
     def _create_metadata_from_model(
         cls,
         model: dm.DataModel[dm.View] | dm.DataModelApply,
+        has_reference: bool = False,
     ) -> DMSMetadata:
         description, creator = DMSMetadata._get_description_and_creator(model.description)
 
@@ -139,6 +144,7 @@ class DMSImporter(BaseImporter):
             updated = now
         return DMSMetadata(
             schema_=SchemaCompleteness.complete,
+            data_model_type=DataModelType.solution if has_reference else DataModelType.enterprise,
             extension=ExtensionCategory.addition,
             space=model.space,
             external_id=model.external_id,
@@ -198,16 +204,21 @@ class DMSImporter(BaseImporter):
                     **self._create_rule_components(
                         ref_model,
                         ref_schema,
-                        self.ref_metadata or self._create_default_metadata(list(ref_schema.views.values())),
+                        self.ref_metadata
+                        or self._create_default_metadata(list(ref_schema.views.values()), is_ref=True),
                         DataModelType.enterprise,
                     )
                 )
-                schema_completeness = SchemaCompleteness.extended
                 data_model_type = DataModelType.solution
 
             user_rules = DMSRules(
                 **self._create_rule_components(
-                    model, self.root_schema, self.metadata, data_model_type, schema_completeness
+                    model,
+                    self.root_schema,
+                    self.metadata,
+                    data_model_type,
+                    schema_completeness,
+                    has_reference=reference is not None,
                 ),
                 reference=reference,
             )
@@ -224,6 +235,7 @@ class DMSImporter(BaseImporter):
         metadata: DMSMetadata | None = None,
         data_model_type: DataModelType | None = None,
         schema_completeness: SchemaCompleteness | None = None,
+        has_reference: bool = False,
     ) -> dict[str, Any]:
         properties = SheetList[DMSProperty]()
         for view_id, view in schema.views.items():
@@ -238,7 +250,7 @@ class DMSImporter(BaseImporter):
             view.as_id() if isinstance(view, dm.View | dm.ViewApply) else view for view in data_model.views or []
         }
 
-        metadata = metadata or DMSMetadata.from_data_model(data_model)
+        metadata = metadata or DMSMetadata.from_data_model(data_model, has_reference)
         if data_model_type is not None:
             metadata.data_model_type = data_model_type
         if schema_completeness is not None:
@@ -258,12 +270,13 @@ class DMSImporter(BaseImporter):
         )
 
     @classmethod
-    def _create_default_metadata(cls, views: Sequence[dm.View | dm.ViewApply]) -> DMSMetadata:
+    def _create_default_metadata(cls, views: Sequence[dm.View | dm.ViewApply], is_ref: bool = False) -> DMSMetadata:
         now = datetime.now().replace(microsecond=0)
         space = Counter(view.space for view in views).most_common(1)[0][0]
         return DMSMetadata(
             schema_=SchemaCompleteness.complete,
             extension=ExtensionCategory.addition,
+            data_model_type=DataModelType.enterprise if is_ref else DataModelType.solution,
             space=space,
             external_id="Unknown",
             version="0.1.0",
@@ -361,7 +374,7 @@ class DMSImporter(BaseImporter):
         elif isinstance(prop, dm.MappedPropertyApply):
             container_prop = self._container_prop_unsafe(cast(dm.MappedPropertyApply, prop))
             if isinstance(container_prop.type, dm.DirectRelation):
-                if prop.source is None:
+                if prop.source is None or prop.source not in self._all_view_ids:
                     # The warning is issued when the DMS Rules are created.
                     return DMSUnknownEntity()
                 else:

cognite/neat/rules/importers/_dtdl2rules/dtdl_importer.py

@@ -134,6 +134,7 @@ class DTDLImporter(BaseImporter):
 
         metadata = self._default_metadata()
         metadata["schema"] = self._schema_completeness.value
+
         if self.title:
             metadata["title"] = to_pascal(self.title)
         try:

cognite/neat/rules/importers/_spreadsheet2rules.py

@@ -22,6 +22,7 @@ from cognite.neat.rules.models import (
     SchemaCompleteness,
 )
 from cognite.neat.rules.models.dms import DMSRulesInput
+from cognite.neat.rules.models.information import InformationRulesInput
 from cognite.neat.utils.auxiliary import local_import
 from cognite.neat.utils.spreadsheet import SpreadsheetRead, read_individual_sheet
 
@@ -110,17 +111,27 @@ class SpreadsheetReader:
         self.required = required
         self.metadata = metadata
         self._sheet_prefix = sheet_prefix
+        self._seen_files: set[Path] = set()
+        self._seen_sheets: set[str] = set()
 
     @property
     def metadata_sheet_name(self) -> str:
         return f"{self._sheet_prefix}Metadata"
 
+    @property
+    def seen_sheets(self) -> set[str]:
+        if not self._seen_files:
+            raise ValueError("No files have been read yet.")
+        return self._seen_sheets
+
     def sheet_names(self, role: RoleTypes) -> set[str]:
         names = MANDATORY_SHEETS_BY_ROLE[role]
         return {f"{self._sheet_prefix}{sheet_name}" for sheet_name in names if sheet_name != "Metadata"}
 
     def read(self, filepath: Path) -> None | ReadResult:
         with pd.ExcelFile(filepath) as excel_file:
+            self._seen_files.add(filepath)
+            self._seen_sheets.update(map(str, excel_file.sheet_names))
             metadata: MetadataRaw | None
             if self.metadata is not None:
                 metadata = self.metadata
@@ -212,20 +223,20 @@ class ExcelImporter(BaseImporter):
             issue_list.append(issues.spreadsheet_file.SpreadsheetNotFoundError(self.filepath))
             return self._return_or_raise(issue_list, errors)
 
-        user_read = SpreadsheetReader(issue_list).read(self.filepath)
+        user_reader = SpreadsheetReader(issue_list)
+        user_read = user_reader.read(self.filepath)
         if user_read is None or issue_list.has_errors:
             return self._return_or_raise(issue_list, errors)
 
         last_read: ReadResult | None = None
+        if any(sheet_name.startswith("Last") for sheet_name in user_reader.seen_sheets):
+            last_read = SpreadsheetReader(issue_list, required=False, sheet_prefix="Last").read(self.filepath)
         reference_read: ReadResult | None = None
-        if user_read.schema == SchemaCompleteness.extended:
-            # Last does not have its own metadata sheet. It is the same as the user's metadata sheet.
-            last_read = SpreadsheetReader(
-                issue_list, required=False, metadata=user_read.metadata, sheet_prefix="Last"
-            ).read(self.filepath)
+        if any(sheet_name.startswith("Ref") for sheet_name in user_reader.seen_sheets):
             reference_read = SpreadsheetReader(issue_list, sheet_prefix="Ref").read(self.filepath)
-            if issue_list.has_errors:
-                return self._return_or_raise(issue_list, errors)
+
+        if issue_list.has_errors:
+            return self._return_or_raise(issue_list, errors)
 
         if reference_read and user_read.role != reference_read.role:
             issue_list.append(issues.spreadsheet_file.RoleMismatchError(self.filepath))
@@ -253,6 +264,8 @@ class ExcelImporter(BaseImporter):
             rules: Rules
             if rules_cls is DMSRules:
                 rules = DMSRulesInput.load(sheets).as_rules()
+            elif rules_cls is InformationRules:
+                rules = InformationRulesInput.load(sheets).as_rules()
             else:
                 rules = rules_cls.model_validate(sheets)  # type: ignore[attr-defined]
 

cognite/neat/rules/issues/dms.py

@@ -30,6 +30,7 @@ __all__ = [
     "HasDataFilterAppliedToTooManyContainersWarning",
     "ReverseRelationMissingOtherSideWarning",
     "NodeTypeFilterOnParentViewWarning",
+    "MissingViewInModelWarning",
     "ChangingContainerError",
     "ChangingViewError",
 ]
@@ -293,6 +294,24 @@ class ViewMapsToTooManyContainersWarning(DMSSchemaWarning):
         return output
 
 
+@dataclass(frozen=True)
+class MissingViewInModelWarning(DMSSchemaWarning):
+    description = "The data model contains view pointing to views not present in the data model"
+    fix = "Add the view(s) to the data model"
+    error_name: ClassVar[str] = "MissingViewInModel"
+    data_model_id: dm.DataModelId
+    view_ids: set[dm.ViewId]
+
+    def message(self) -> str:
+        return f"The view(s) {self.view_ids} are missing in the data model {self.data_model_id}"
+
+    def dump(self) -> dict[str, Any]:
+        output = super().dump()
+        output["data_model_id"] = self.data_model_id.dump()
+        output["view_id"] = [view_id.dump() for view_id in self.view_ids]
+        return output
+
+
 @dataclass(frozen=True)
 class ContainerPropertyUsedMultipleTimesError(DMSSchemaError):
     description = "The container property is used multiple times by the same view property"

cognite/neat/rules/issues/importing.py

@@ -1,5 +1,6 @@
 from abc import ABC
 from dataclasses import dataclass
+from typing import Any
 
 from .base import NeatValidationError, ValidationWarning
 
@@ -23,6 +24,7 @@ __all__ = [
     "MissingIdentifierError",
     "UnsupportedPropertyTypeError",
     "APIError",
+    "FailedImportWarning",
 ]
 
 
@@ -259,6 +261,20 @@ class APIWarning(ModelImportWarning):
         return {"error_message": self.error_message}
 
 
+@dataclass(frozen=True)
+class FailedImportWarning(ModelImportWarning):
+    description = "Failed to import part of the model."
+    fix = "No fix is available."
+
+    identifier: set[str]
+
+    def message(self) -> str:
+        return f"Failed to import: {self.identifier}. This will be skipped."
+
+    def dump(self) -> dict[str, Any]:
+        return {"identifier": list(self.identifier)}
+
+
 @dataclass(frozen=True)
 class ModelImportError(NeatValidationError, ABC):
     description = "An error was raised during importing."

cognite/neat/rules/issues/spreadsheet.py

@@ -10,7 +10,7 @@ from pydantic_core import ErrorDetails
 
 from cognite.neat.utils.spreadsheet import SpreadsheetRead
 
-from .base import DefaultPydanticError, MultiValueError, NeatValidationError, ValidationWarning
+from .base import DefaultPydanticError, MultiValueError, NeatValidationError
 
 if sys.version_info >= (3, 11):
     from typing import Self
@@ -27,7 +27,7 @@ __all__ = [
     "InvalidRowUnknownSheetError",
     "NonExistingContainerError",
     "NonExistingViewError",
-    "ClassNoPropertiesNoParentsWarning",
+    "ClassNoPropertiesNoParentError",
     "InconsistentContainerDefinitionError",
     "MultiValueTypeError",
     "MultiValueIsListError",
@@ -239,7 +239,26 @@ class NonExistingViewError(InvalidPropertyError):
 
 
 @dataclass(frozen=True)
-class ClassNoPropertiesNoParentsWarning(ValidationWarning):
+class PropertiesDefinedForUndefinedClassesError(NeatValidationError):
+    description = "Properties are defined for undefined classes."
+    fix = "Make sure to define class in the Classes sheet."
+
+    classes: list[str]
+
+    def dump(self) -> dict[str, list[str]]:
+        output = super().dump()
+        output["classes"] = self.classes
+        return output
+
+    def message(self) -> str:
+        return (
+            f"Classes {', '.join(self.classes)} have properties assigned to them, but"
+            " they are not defined in the Classes sheet."
+        )
+
+
+@dataclass(frozen=True)
+class ClassNoPropertiesNoParentError(NeatValidationError):
     description = "Class has no properties and no parents."
     fix = "Check if the class should have properties or parents."
 
@@ -252,8 +271,44 @@ class ClassNoPropertiesNoParentsWarning(ValidationWarning):
 
     def message(self) -> str:
         if len(self.classes) > 1:
-            return f"Classes {', '.join(self.classes)} have no properties and no parents. This may be a mistake."
-        return f"Class {self.classes[0]} has no properties and no parents. This may be a mistake."
+            return f"Classes {', '.join(self.classes)} have no direct or inherited properties. This may be a mistake."
+        return f"Class {self.classes[0]} have no direct or inherited properties. This may be a mistake."
+
+
+@dataclass(frozen=True)
+class ParentClassesNotDefinedError(NeatValidationError):
+    description = "Parent classes are not defined."
+    fix = "Check if the parent classes are defined in Classes sheet."
+
+    classes: list[str]
+
+    def dump(self) -> dict[str, list[str]]:
+        output = super().dump()
+        output["classes"] = self.classes
+        return output
+
+    def message(self) -> str:
+        if len(self.classes) > 1:
+            return f"Parent classes {', '.join(self.classes)} are not defined. This may be a mistake."
+        return f"Parent classes {', '.join(self.classes[0])} are not defined. This may be a mistake."
+
+
+@dataclass(frozen=True)
+class ValueTypeNotDefinedError(NeatValidationError):
+    description = "Value types referred by properties are not defined in Rules."
+    fix = "Make sure that all value types are defined in Rules."
+
+    value_types: list[str]
+
+    def dump(self) -> dict[str, list[str]]:
+        output = super().dump()
+        output["classes"] = self.value_types
+        return output
+
+    def message(self) -> str:
+        if len(self.value_types) > 1:
+            return f"Value types {', '.join(self.value_types)} are not defined. This may be a mistake."
+        return f"Value types {', '.join(self.value_types[0])} are not defined. This may be a mistake."
 
 
 @dataclass(frozen=True)

cognite/neat/rules/models/_base.py

@@ -38,6 +38,12 @@ else:
 METADATA_VALUE_MAX_LENGTH = 5120
 
 
+def _add_alias(data: dict[str, Any], base_model: type[BaseModel]) -> None:
+    for field_name, field_ in base_model.model_fields.items():
+        if field_name not in data and field_.alias in data:
+            data[field_name] = data[field_.alias]
+
+
 def replace_nan_floats_with_default(values: dict, model_fields: dict[str, FieldInfo]) -> dict:
     output = {}
     for field_name, value in values.items():