cognite-neat 0.97.3__py3-none-any.whl → 0.98.0__py3-none-any.whl

cognite/neat/_rules/models/dms/_rules.py

@@ -1,7 +1,5 @@
-import math
 import warnings
 from collections.abc import Hashable
-from datetime import datetime
 from typing import Any, ClassVar, Literal
 
 import pandas as pd
@@ -10,31 +8,24 @@ from pydantic import Field, field_serializer, field_validator, model_validator
 from pydantic_core.core_schema import SerializationInfo, ValidationInfo
 from rdflib import URIRef
 
-from cognite.neat._constants import COGNITE_SPACES, DEFAULT_NAMESPACE
+from cognite.neat._constants import COGNITE_SPACES
 from cognite.neat._issues import MultiValueError
 from cognite.neat._issues.warnings import (
     PrincipleMatchingSpaceAndVersionWarning,
-    PrincipleSolutionBuildsOnEnterpriseWarning,
 )
 from cognite.neat._rules.models._base_rules import (
     BaseMetadata,
     BaseRules,
-    DataModelType,
-    ExtensionCategory,
+    DataModelAspect,
     RoleTypes,
-    SchemaCompleteness,
     SheetList,
     SheetRow,
 )
 from cognite.neat._rules.models._types import (
     ClassEntityType,
     ContainerEntityType,
-    DataModelExternalIdType,
     DmsPropertyType,
-    InformationPropertyType,
-    SpaceType,
     StrListType,
-    VersionType,
     ViewEntityType,
 )
 from cognite.neat._rules.models.data_types import DataType
@@ -48,9 +39,7 @@ from cognite.neat._rules.models.entities import (
     HasDataFilter,
     NodeTypeFilter,
     RawFilter,
-    ReferenceEntity,
     ReverseConnectionEntity,
-    URLEntity,
     ViewEntity,
     ViewEntityList,
 )
@@ -62,54 +51,8 @@ _DEFAULT_VERSION = "1"
 
 class DMSMetadata(BaseMetadata):
     role: ClassVar[RoleTypes] = RoleTypes.dms
-    data_model_type: DataModelType = Field(DataModelType.enterprise, alias="dataModelType")
-    schema_: SchemaCompleteness = Field(alias="schema")
-    extension: ExtensionCategory = ExtensionCategory.addition
-    space: SpaceType
-    name: str | None = Field(
-        None,
-        description="Human readable name of the data model",
-        min_length=1,
-        max_length=255,
-    )
-    description: str | None = Field(None, min_length=1, max_length=1024)
-    external_id: DataModelExternalIdType = Field(alias="externalId")
-    version: VersionType
-    creator: StrListType
-    created: datetime = Field(
-        description=("Date of the data model creation"),
-    )
-    updated: datetime = Field(
-        description=("Date of the data model update"),
-    )
-
-    @field_validator("*", mode="before")
-    def strip_string(cls, value: Any) -> Any:
-        if isinstance(value, str):
-            return value.strip()
-        return value
-
-    @field_serializer("schema_", "extension", "data_model_type", when_used="always")
-    def as_string(self, value: SchemaCompleteness | ExtensionCategory | DataModelType) -> str:
-        return str(value)
-
-    @field_validator("schema_", mode="plain")
-    def as_enum_schema(cls, value: str) -> SchemaCompleteness:
-        return SchemaCompleteness(value.strip())
-
-    @field_validator("extension", mode="plain")
-    def as_enum_extension(cls, value: str) -> ExtensionCategory:
-        return ExtensionCategory(value.strip())
-
-    @field_validator("data_model_type", mode="plain")
-    def as_enum_model_type(cls, value: str) -> DataModelType:
-        return DataModelType(value.strip())
-
-    @field_validator("description", mode="before")
-    def nan_as_none(cls, value):
-        if isinstance(value, float) and math.isnan(value):
-            return None
-        return value
+    aspect: ClassVar[DataModelAspect] = DataModelAspect.physical
+    logical: str | None = None
 
     def as_space(self) -> dm.SpaceApply:
         return dm.SpaceApply(
@@ -159,13 +102,15 @@ class DMSProperty(SheetRow):
     immutable: bool | None = Field(default=None, alias="Immutable")
     is_list: bool | None = Field(default=None, alias="Is List")
     default: str | int | dict | None = Field(None, alias="Default")
-    reference: URLEntity | ReferenceEntity | None = Field(default=None, alias="Reference", union_mode="left_to_right")
     container: ContainerEntityType | None = Field(None, alias="Container")
     container_property: DmsPropertyType | None = Field(None, alias="Container Property")
     index: StrListType | None = Field(None, alias="Index")
     constraint: StrListType | None = Field(None, alias="Constraint")
-    class_: ClassEntityType = Field(alias="Class (linage)")
-    property_: InformationPropertyType = Field(alias="Property (linage)")
+    logical: URIRef | None = Field(
+        None,
+        alias="Logical",
+        description="Used to make connection between physical and logical data model aspect",
+    )
 
     def _identifier(self) -> tuple[Hashable, ...]:
         return self.view, self.view_property
@@ -208,19 +153,6 @@ class DMSProperty(SheetRow):
             )
         return value
 
-    @field_serializer("reference", when_used="always")
-    def set_reference(self, value: Any, info: SerializationInfo) -> str | None:
-        if isinstance(info.context, dict) and info.context.get("as_reference") is True:
-            return str(
-                ReferenceEntity(
-                    prefix=self.view.prefix,
-                    suffix=self.view.suffix,
-                    version=self.view.version,
-                    property=self.view_property,
-                )
-            )
-        return str(value) if value is not None else None
-
     @field_serializer("value_type", when_used="always")
     def as_dms_type(self, value_type: DataType | EdgeEntity | ViewEntity, info: SerializationInfo) -> str:
         if isinstance(value_type, DataType):
@@ -229,7 +161,7 @@ class DMSProperty(SheetRow):
             return value_type.dump(space=metadata.space, version=metadata.version)
         return str(value_type)
 
-    @field_serializer("view", "container", "class_", when_used="unless-none")
+    @field_serializer("view", "container", when_used="unless-none")
     def remove_default_space(self, value: str, info: SerializationInfo) -> str:
         if (metadata := _metadata(info.context)) and isinstance(value, Entity):
             if info.field_name == "container" and info.context.get("as_reference") is True:
@@ -253,10 +185,8 @@ class DMSContainer(SheetRow):
     container: ContainerEntityType = Field(alias="Container")
     name: str | None = Field(alias="Name", default=None)
     description: str | None = Field(alias="Description", default=None)
-    reference: URLEntity | ReferenceEntity | None = Field(alias="Reference", default=None, union_mode="left_to_right")
     constraint: ContainerEntityList | None = Field(None, alias="Constraint")
     used_for: Literal["node", "edge", "all"] | None = Field("all", alias="Used For")
-    class_: ClassEntityType = Field(alias="Class (linage)")
 
     def _identifier(self) -> tuple[Hashable, ...]:
         return (self.container,)
@@ -278,13 +208,7 @@ class DMSContainer(SheetRow):
             used_for=self.used_for,
         )
 
-    @field_serializer("reference", when_used="always")
-    def set_reference(self, value: Any, info: SerializationInfo) -> str | None:
-        if isinstance(info.context, dict) and info.context.get("as_reference") is True:
-            return self.container.dump()
-        return str(value) if value is not None else None
-
-    @field_serializer("container", "class_", when_used="unless-none")
+    @field_serializer("container", when_used="unless-none")
     def remove_default_space(self, value: Any, info: SerializationInfo) -> str:
         if metadata := _metadata(info.context):
             if isinstance(value, DMSEntity):
@@ -310,21 +234,18 @@ class DMSView(SheetRow):
     name: str | None = Field(alias="Name", default=None)
     description: str | None = Field(alias="Description", default=None)
     implements: ViewEntityList | None = Field(None, alias="Implements")
-    reference: URLEntity | ReferenceEntity | None = Field(alias="Reference", default=None, union_mode="left_to_right")
     filter_: HasDataFilter | NodeTypeFilter | RawFilter | None = Field(None, alias="Filter")
     in_model: bool = Field(True, alias="In Model")
-    class_: ClassEntityType = Field(alias="Class (linage)")
+    logical: URIRef | None = Field(
+        None,
+        alias="Logical",
+        description="Used to make connection between physical and logical data model aspect",
+    )
 
     def _identifier(self) -> tuple[Hashable, ...]:
         return (self.view,)
 
-    @field_serializer("reference", when_used="always")
-    def set_reference(self, value: Any, info: SerializationInfo) -> str | None:
-        if isinstance(info.context, dict) and info.context.get("as_reference") is True:
-            return self.view.dump()
-        return str(value) if value is not None else None
-
-    @field_serializer("view", "class_", when_used="unless-none")
+    @field_serializer("view", when_used="unless-none")
     def remove_default_space(self, value: Any, info: SerializationInfo) -> str:
         if (metadata := _metadata(info.context)) and isinstance(value, Entity):
             return value.dump(prefix=metadata.space, version=metadata.version)
@@ -344,11 +265,6 @@ class DMSView(SheetRow):
     def as_view(self) -> dm.ViewApply:
         view_id = self.view.as_id()
         implements = [parent.as_id() for parent in self.implements or []] or None
-        if implements is None and isinstance(self.reference, ReferenceEntity):
-            # Fallback to the reference if no implements are provided
-            parent = self.reference.as_view_id()
-            if (parent.space, parent.external_id) != (view_id.space, view_id.external_id):
-                implements = [parent]
 
         return dm.ViewApply(
             space=view_id.space,
@@ -408,24 +324,6 @@ class DMSRules(BaseRules):
     containers: SheetList[DMSContainer] | None = Field(None, alias="Containers")
     enum: SheetList[DMSEnum] | None = Field(None, alias="Enum")
     nodes: SheetList[DMSNode] | None = Field(None, alias="Nodes")
-    last: "DMSRules | None" = Field(None, alias="Last", description="The previous version of the data model")
-    reference: "DMSRules | None" = Field(None, alias="Reference")
-
-    @field_validator("reference")
-    def check_reference_of_reference(cls, value: "DMSRules | None", info: ValidationInfo) -> "DMSRules | None":
-        if value is None:
-            return None
-        if value.reference is not None:
-            raise ValueError("Reference rules cannot have a reference")
-        if value.metadata.data_model_type == DataModelType.solution and (metadata := info.data.get("metadata")):
-            warnings.warn(
-                PrincipleSolutionBuildsOnEnterpriseWarning(
-                    f"The solution model {metadata.as_data_model_id()} is referencing another "
-                    f"solution model {value.metadata.as_data_model_id()}",
-                ),
-                stacklevel=2,
-            )
-        return value
 
     @field_validator("views")
     def matching_version_and_space(cls, value: SheetList[DMSView], info: ValidationInfo) -> SheetList[DMSView]:
@@ -476,7 +374,7 @@ class DMSRules(BaseRules):
 
     def _repr_html_(self) -> str:
         summary = {
-            "type": "Physical Data Model",
+            "aspect": self.metadata.aspect,
             "intended for": "DMS Architect",
             "name": self.metadata.name,
             "space": self.metadata.space,
@@ -488,9 +386,3 @@ class DMSRules(BaseRules):
         }
 
         return pd.DataFrame([summary]).T.rename(columns={0: ""})._repr_html_()  # type: ignore
-
-    @property
-    def id_(self) -> URIRef:
-        return DEFAULT_NAMESPACE[
-            f"data-model/verified/dms/{self.metadata.space}/{self.metadata.external_id}/{self.metadata.version}"
-        ]

cognite/neat/_rules/models/dms/_rules_input.py

@@ -5,13 +5,12 @@ from typing import Any, Literal
 
 import pandas as pd
 from cognite.client import data_modeling as dm
-from rdflib import URIRef
+from rdflib import Namespace, URIRef
 
 from cognite.neat._constants import DEFAULT_NAMESPACE
 from cognite.neat._rules.models._base_input import InputComponent, InputRules
 from cognite.neat._rules.models.data_types import DataType
 from cognite.neat._rules.models.entities import (
-    ClassEntity,
     ContainerEntity,
     DMSNodeEntity,
     DMSUnknownEntity,
@@ -27,17 +26,15 @@ from ._rules import _DEFAULT_VERSION, DMSContainer, DMSEnum, DMSMetadata, DMSNod
 
 @dataclass
 class DMSInputMetadata(InputComponent[DMSMetadata]):
-    schema_: Literal["complete", "partial", "extended"]
     space: str
     external_id: str
     creator: str
     version: str
-    extension: Literal["addition", "reshape", "rebuild"] = "addition"
-    data_model_type: Literal["solution", "enterprise"] = "solution"
     name: str | None = None
     description: str | None = None
     created: datetime | str | None = None
     updated: datetime | str | None = None
+    logical: str | None = None
 
     @classmethod
     def _get_verified_cls(cls) -> type[DMSMetadata]:
@@ -52,11 +49,9 @@ class DMSInputMetadata(InputComponent[DMSMetadata]):
         return output
 
     @classmethod
-    def from_data_model(cls, data_model: dm.DataModelApply, has_reference: bool) -> "DMSInputMetadata":
+    def from_data_model(cls, data_model: dm.DataModelApply) -> "DMSInputMetadata":
         description, creator = cls._get_description_and_creator(data_model.description)
         return cls(
-            schema_="complete",
-            data_model_type="solution" if has_reference else "enterprise",
             space=data_model.space,
             name=data_model.name or None,
             description=description,
@@ -80,14 +75,27 @@ class DMSInputMetadata(InputComponent[DMSMetadata]):
             description = None
         return description, creator
 
+    @property
+    def identifier(self) -> URIRef:
+        """Globally unique identifier for the data model.
+
+        !!! note
+            Unlike namespace, the identifier does not end with "/" or "#".
+
+        """
+        return DEFAULT_NAMESPACE[f"data-model/unverified/physical/{self.space}/{self.external_id}/{self.version}"]
+
+    @property
+    def namespace(self) -> Namespace:
+        """Namespace for the data model used for the entities in the data model."""
+        return Namespace(f"{self.identifier}/")
+
 
 @dataclass
 class DMSInputProperty(InputComponent[DMSProperty]):
     view: str
     view_property: str | None
     value_type: str | DataType | ViewEntity | DMSUnknownEntity
-    property_: str | None = None
-    class_: str | None = None
     name: str | None = None
     description: str | None = None
     connection: Literal["direct"] | ReverseConnectionEntity | EdgeEntity | str | None = None
@@ -95,11 +103,11 @@ class DMSInputProperty(InputComponent[DMSProperty]):
     immutable: bool | None = None
     is_list: bool | None = None
     default: str | int | dict | None = None
-    reference: str | None = None
     container: str | None = None
     container_property: str | None = None
     index: str | list[str] | None = None
     constraint: str | list[str] | None = None
+    logical: str | None = None
 
     @classmethod
     def _get_verified_cls(cls) -> type[DMSProperty]:
@@ -110,12 +118,6 @@ class DMSInputProperty(InputComponent[DMSProperty]):
         output["View"] = ViewEntity.load(self.view, space=default_space, version=default_version)
         output["Value Type"] = load_dms_value_type(self.value_type, default_space, default_version)
         output["Connection"] = load_connection(self.connection, default_space, default_version)
-        output["Property (linage)"] = self.property_ or self.view_property
-        output["Class (linage)"] = (
-            ClassEntity.load(self.class_ or self.view, prefix=default_space, version=default_version)
-            if self.class_ or self.view
-            else None
-        )
         output["Container"] = (
             ContainerEntity.load(self.container, space=default_space, version=default_version)
             if self.container
@@ -127,10 +129,8 @@ class DMSInputProperty(InputComponent[DMSProperty]):
 @dataclass
 class DMSInputContainer(InputComponent[DMSContainer]):
     container: str
-    class_: str | None = None
     name: str | None = None
     description: str | None = None
-    reference: str | None = None
     constraint: str | None = None
     used_for: Literal["node", "edge", "all"] | None = None
 
@@ -142,9 +142,6 @@ class DMSInputContainer(InputComponent[DMSContainer]):
         output = super().dump()
         container = ContainerEntity.load(self.container, space=default_space)
         output["Container"] = container
-        output["Class (linage)"] = (
-            ClassEntity.load(self.class_, prefix=default_space) if self.class_ else container.as_class()
-        )
         output["Constraint"] = (
             [ContainerEntity.load(constraint.strip(), space=default_space) for constraint in self.constraint.split(",")]
             if self.constraint
@@ -161,7 +158,6 @@ class DMSInputContainer(InputComponent[DMSContainer]):
             # UniquenessConstraint it handled in the properties
         container_entity = ContainerEntity.from_id(container.as_id())
         return cls(
-            class_=str(container_entity.as_class()),
             container=str(container_entity),
             name=container.name or None,
             description=container.description,
@@ -173,13 +169,12 @@ class DMSInputContainer(InputComponent[DMSContainer]):
 @dataclass
 class DMSInputView(InputComponent[DMSView]):
     view: str
-    class_: str | None = None
     name: str | None = None
     description: str | None = None
     implements: str | None = None
-    reference: str | None = None
     filter_: Literal["hasData", "nodeType", "rawFilter"] | None = None
     in_model: bool = True
+    logical: str | None = None
 
     @classmethod
     def _get_verified_cls(cls) -> type[DMSView]:
@@ -189,11 +184,6 @@ class DMSInputView(InputComponent[DMSView]):
         output = super().dump()
         view = ViewEntity.load(self.view, space=default_space, version=default_version)
         output["View"] = view
-        output["Class (linage)"] = (
-            ClassEntity.load(self.class_, prefix=default_space, version=default_version)
-            if self.class_
-            else view.as_class()
-        )
         output["Implements"] = (
             [
                 ViewEntity.load(implement, space=default_space, version=default_version)
@@ -207,10 +197,8 @@ class DMSInputView(InputComponent[DMSView]):
     @classmethod
     def from_view(cls, view: dm.ViewApply, in_model: bool) -> "DMSInputView":
         view_entity = ViewEntity.from_id(view.as_id())
-        class_entity = view_entity.as_class(skip_version=True)
 
         return cls(
-            class_=str(class_entity),
             view=str(view_entity),
             description=view.description,
             name=view.name,
@@ -261,8 +249,6 @@ class DMSInputRules(InputRules[DMSRules]):
     containers: list[DMSInputContainer] | None = None
     enum: list[DMSInputEnum] | None = None
     nodes: list[DMSInputNode] | None = None
-    last: "DMSInputRules | None" = None
-    reference: "DMSInputRules | None" = None
 
     @classmethod
     def _get_verified_cls(cls) -> type[DMSRules]:
@@ -271,18 +257,6 @@ class DMSInputRules(InputRules[DMSRules]):
     def dump(self) -> dict[str, Any]:
         default_space = self.metadata.space
         default_version = str(self.metadata.version)
-        reference: dict[str, Any] | None = None
-        if isinstance(self.reference, DMSInputRules):
-            reference = self.reference.dump()
-        elif isinstance(self.reference, DMSRules):
-            # We need to load through the DMSRulesInput to set the correct default space and version
-            reference = DMSInputRules.load(self.reference.model_dump()).dump()
-        last: dict[str, Any] | None = None
-        if isinstance(self.last, DMSInputRules):
-            last = self.last.dump()
-        elif isinstance(self.last, DMSRules):
-            # We need to load through the DMSRulesInput to set the correct default space and version
-            last = DMSInputRules.load(self.last.model_dump()).dump()
 
         return {
             "Metadata": self.metadata.dump(),
@@ -291,8 +265,6 @@ class DMSInputRules(InputRules[DMSRules]):
             "Containers": [container.dump(default_space) for container in self.containers or []] or None,
             "Enum": [enum.dump() for enum in self.enum or []] or None,
             "Nodes": [node_type.dump(default_space) for node_type in self.nodes or []] or None,
-            "Last": last,
-            "Reference": reference,
         }
 
     def _repr_html_(self) -> str:

cognite/neat/_rules/models/dms/_schema.py

@@ -539,6 +539,10 @@ class DMSSchema:
             raise ValueError(f"Cannot sort item of type {type(item)}")
 
     def validate(self) -> list[NeatError]:
+        # TODO: This type of validation should be done in NeatSession where all the
+        # schema components which are not part of Rules are imported and the model as
+        # the whole is validated.
+
         errors: set[NeatError] = set()
         defined_spaces = self.spaces.copy()
         defined_containers = self.containers.copy()
@@ -708,6 +712,13 @@ class DMSSchema:
         referenced_spaces |= {s.space for s in self.spaces.values()}
         return referenced_spaces
 
+    def referenced_container(self) -> set[dm.ContainerId]:
+        referenced_containers = {
+            container for view in self.views.values() for container in view.referenced_containers()
+        }
+        referenced_containers |= set(self.containers.keys())
+        return referenced_containers
+
     def as_read_model(self) -> dm.DataModel[dm.View]:
         if self.data_model is None:
             raise ValueError("Data model is not defined")

cognite/neat/_rules/models/dms/_validation.py

@@ -7,7 +7,6 @@ from cognite.neat._constants import COGNITE_MODELS, DMS_CONTAINER_PROPERTY_SIZE_
 from cognite.neat._issues import IssueList, NeatError, NeatIssue, NeatIssueList
 from cognite.neat._issues.errors import (
     PropertyDefinitionDuplicatedError,
-    ResourceChangedError,
     ResourceNotDefinedError,
 )
 from cognite.neat._issues.errors._properties import ReversedConnectionNotFeasibleError
@@ -20,7 +19,6 @@ from cognite.neat._issues.warnings.user_modeling import (
     NotNeatSupportedFilterWarning,
     ViewPropertyLimitWarning,
 )
-from cognite.neat._rules.models._base_rules import DataModelType, ExtensionCategory, SchemaCompleteness
 from cognite.neat._rules.models.data_types import DataType
 from cognite.neat._rules.models.entities import ContainerEntity, RawFilter
 from cognite.neat._rules.models.entities._single_value import (
@@ -55,12 +53,7 @@ class DMSPostValidation:
         self._validate_reverse_connections()
 
         self._referenced_views_and_containers_are_existing_and_proper_size()
-        if self.metadata.schema_ is SchemaCompleteness.extended:
-            self._validate_extension()
-        if self.metadata.schema_ is SchemaCompleteness.partial:
-            return self.issue_list
         dms_schema = self.rules.as_schema()
-        self.issue_list.extend(dms_schema.validate())
         self._validate_performance(dms_schema)
         return self.issue_list
 
@@ -160,9 +153,10 @@ class DMSPostValidation:
         self.issue_list.extend(errors)
 
     def _referenced_views_and_containers_are_existing_and_proper_size(self) -> None:
+        # TODO: Split this method and keep only validation that should be independent of
+        # whether view and/or container exist in the pydantic model instance
+        # other validation should be done through NeatSession.verify()
         defined_views = {view.view.as_id() for view in self.views}
-        if self.metadata.schema_ is SchemaCompleteness.extended and self.rules.last:
-            defined_views |= {view.view.as_id() for view in self.rules.last.views}
 
         property_count_by_view: dict[dm.ViewId, int] = defaultdict(int)
         errors: list[NeatIssue] = []
@@ -184,103 +178,9 @@ class DMSPostValidation:
         for view_id, count in property_count_by_view.items():
             if count > DMS_CONTAINER_PROPERTY_SIZE_LIMIT:
                 errors.append(ViewPropertyLimitWarning(view_id, count))
-        if self.metadata.schema_ is SchemaCompleteness.complete:
-            defined_containers = {container.container.as_id() for container in self.containers or []}
-            if self.metadata.data_model_type == DataModelType.solution and self.rules.reference:
-                defined_containers |= {
-                    container.container.as_id() for container in self.rules.reference.containers or []
-                }
 
-            for prop_no, prop in enumerate(self.properties):
-                if prop.container and (container_id := prop.container.as_id()) not in defined_containers:
-                    errors.append(
-                        ResourceNotDefinedError(
-                            identifier=container_id,
-                            resource_type="container",
-                            location="Containers Sheet",
-                            column_name="Container",
-                            row_number=prop_no,
-                            sheet_name="Properties",
-                        )
-                    )
-            for _container_no, container in enumerate(self.containers or []):
-                for constraint_no, constraint in enumerate(container.constraint or []):
-                    if constraint.as_id() not in defined_containers:
-                        errors.append(
-                            ResourceNotDefinedError(
-                                identifier=constraint.as_id(),
-                                resource_type="container",
-                                location="Containers Sheet",
-                                column_name="Constraint",
-                                row_number=constraint_no,
-                                sheet_name="Properties",
-                            )
-                        )
         self.issue_list.extend(errors)
 
-    def _validate_extension(self) -> None:
-        if self.metadata.schema_ is not SchemaCompleteness.extended:
-            return None
-        if not self.rules.last:
-            raise ValueError("The schema is set to 'extended', but no last rules are provided to validate against")
-        if self.metadata.extension is ExtensionCategory.rebuild:
-            # Everything is allowed
-            return None
-        user_schema = self.rules.as_schema()
-        new_containers = user_schema.containers.copy()
-
-        last_schema = self.rules.last.as_schema()
-        existing_containers = last_schema.containers.copy()
-
-        for container_id, container in new_containers.items():
-            existing_container = existing_containers.get(container_id)
-            if not existing_container or existing_container == container:
-                # No problem
-                continue
-            new_dumped = container.dump()
-            existing_dumped = existing_container.dump()
-            changed_attributes, changed_properties = self._changed_attributes_and_properties(
-                new_dumped, existing_dumped
-            )
-            self.issue_list.append(
-                ResourceChangedError(
-                    container_id,
-                    "container",
-                    changed_properties=frozenset(changed_properties),
-                    changed_attributes=frozenset(changed_attributes),
-                )
-            )
-
-        if self.metadata.extension is ExtensionCategory.reshape:
-            # Reshape allows changes to views
-            return None
-
-        new_views = user_schema.views.copy()
-        existing_views = last_schema.views.copy()
-        for view_id, view in new_views.items():
-            existing_view = existing_views.get(view_id)
-            if not existing_view or existing_view == view:
-                # No problem
-                continue
-            changed_attributes, changed_properties = self._changed_attributes_and_properties(
-                view.dump(), existing_view.dump()
-            )
-            existing_properties = existing_view.properties or {}
-            changed_properties = [prop for prop in changed_properties if prop in existing_properties]
-            changed_attributes = [attr for attr in changed_attributes if attr not in self.changeable_view_attributes]
-
-            if not changed_attributes and not changed_properties:
-                # Only added new properties, no problem
-                continue
-            self.issue_list.append(
-                ResourceChangedError(
-                    view_id,
-                    "view",
-                    changed_properties=frozenset(changed_properties),
-                    changed_attributes=frozenset(changed_attributes),
-                )
-            )
-
     def _validate_performance(self, dms_schema: DMSSchema) -> None:
         for view_id, view in dms_schema.views.items():
             mapped_containers = dms_schema._get_mapped_container_from_view(view_id)
@@ -320,7 +220,7 @@ class DMSPostValidation:
                     UndefinedViewWarning(
                         str(prop_.view),
                         str(prop_.value_type),
-                        prop_.property_,
+                        prop_.view_property,
                     )
                 )
 
@@ -329,7 +229,7 @@ class DMSPostValidation:
         if self.metadata.as_data_model_id() in COGNITE_MODELS:
             return None
 
-        properties_by_ids = {f"{prop_.view!s}.{prop_.property_}": prop_ for prop_ in self.properties}
+        properties_by_ids = {f"{prop_.view!s}.{prop_.view_property}": prop_ for prop_ in self.properties}
         reversed_by_ids = {
             id_: prop_
             for id_, prop_ in properties_by_ids.items()
@@ -339,11 +239,12 @@ class DMSPostValidation:
         for id_, prop_ in reversed_by_ids.items():
             source_id = f"{prop_.value_type!s}." f"{cast(ReverseConnectionEntity, prop_.connection).property_}"
             if source_id not in properties_by_ids:
+                print(f"source_id: {source_id}, first issue")
                 self.issue_list.append(
                     ReversedConnectionNotFeasibleError(
                         id_,
                         "reversed connection",
-                        prop_.property_,
+                        prop_.view_property,
                         str(prop_.view),
                         str(prop_.value_type),
                         cast(ReverseConnectionEntity, prop_.connection).property_,
@@ -351,11 +252,12 @@ class DMSPostValidation:
                 )
 
             elif source_id in properties_by_ids and properties_by_ids[source_id].value_type != prop_.view:
+                print(f"source_id: {source_id}, second issue")
                 self.issue_list.append(
                     ReversedConnectionNotFeasibleError(
                         id_,
                         "view property",
-                        prop_.property_,
+                        prop_.view_property,
                         str(prop_.view),
                         str(prop_.value_type),
                         cast(ReverseConnectionEntity, prop_.connection).property_,