cognite-neat 0.97.3__py3-none-any.whl → 0.99.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,29 @@ 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._client.data_classes.schema import DMSSchema
+from cognite.neat._constants import COGNITE_SPACES
 from cognite.neat._issues import MultiValueError
+from cognite.neat._issues.errors import NeatValueError
 from cognite.neat._issues.warnings import (
     PrincipleMatchingSpaceAndVersionWarning,
-    PrincipleSolutionBuildsOnEnterpriseWarning,
 )
 from cognite.neat._rules.models._base_rules import (
     BaseMetadata,
     BaseRules,
-    DataModelType,
-    ExtensionCategory,
+    ContainerProperty,
+    DataModelAspect,
     RoleTypes,
-    SchemaCompleteness,
     SheetList,
     SheetRow,
+    ViewProperty,
+    ViewRef,
 )
 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,68 +44,18 @@ from cognite.neat._rules.models.entities import (
     HasDataFilter,
     NodeTypeFilter,
     RawFilter,
-    ReferenceEntity,
     ReverseConnectionEntity,
-    URLEntity,
     ViewEntity,
     ViewEntityList,
 )
 
-from ._schema import DMSSchema
-
 _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 +105,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 +156,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 +164,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:
@@ -248,15 +183,21 @@ class DMSProperty(SheetRow):
             return value.dump(space=metadata.space, version=metadata.version, type=default_type)
         return str(value)
 
+    def as_container_reference(self) -> ContainerProperty:
+        if self.container is None or self.container_property is None:
+            raise NeatValueError("Accessing container reference without container and container property set")
+        return ContainerProperty(container=self.container, property_=self.container_property)
+
+    def as_view_reference(self) -> ViewProperty:
+        return ViewProperty(view=self.view, property_=self.view_property)
+
 
 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 +219,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 +245,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 +276,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,
@@ -356,10 +283,14 @@ class DMSView(SheetRow):
             version=view_id.version or _DEFAULT_VERSION,
             name=self.name or None,
             description=self.description,
+            filter=None if self.filter_ is None else self.filter_.as_dms_filter(),
             implements=implements,
             properties={},
         )
 
+    def as_view_reference(self) -> ViewRef:
+        return ViewRef(view=self.view)
+
 
 class DMSNode(SheetRow):
     node: DMSNodeEntity = Field(alias="Node")
@@ -408,24 +339,9 @@ 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
+    # This is a hack to allow the post_validation to be turned off when needed
+    # Will likely be moved completely out of the rules in the future
+    post_validate: bool = Field(default=True, exclude=True, repr=False)
 
     @field_validator("views")
     def matching_version_and_space(cls, value: SheetList[DMSView], info: ValidationInfo) -> SheetList[DMSView]:
@@ -462,6 +378,8 @@ class DMSRules(BaseRules):
     def post_validation(self) -> "DMSRules":
         from ._validation import DMSPostValidation
 
+        if not self.post_validate:
+            return self
         issue_list = DMSPostValidation(self).validate()
         if issue_list.warnings:
             issue_list.trigger_warnings()
@@ -472,11 +390,11 @@ class DMSRules(BaseRules):
     def as_schema(self, include_pipeline: bool = False, instance_space: str | None = None) -> DMSSchema:
         from ._exporter import _DMSExporter
 
-        return _DMSExporter(self, include_pipeline, instance_space).to_schema()
+        return _DMSExporter(self, instance_space).to_schema()
 
     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,
@@ -489,8 +407,27 @@ 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}"
-        ]
+    def imported_views_and_containers_ids(
+        self, include_model_views_with_no_properties: bool = True
+    ) -> tuple[set[dm.ViewId], set[dm.ContainerId]]:
+        existing_views = {view.view for view in self.views}
+        imported_views: set[dm.ViewId] = set()
+        for view in self.views:
+            for parent in view.implements or []:
+                if parent not in existing_views:
+                    imported_views.add(parent.as_id())
+        existing_containers = {container.container for container in self.containers or []}
+        imported_containers: set[dm.ContainerId] = set()
+        view_with_properties: set[ViewEntity] = set()
+        for prop in self.properties:
+            if prop.container and prop.container not in existing_containers:
+                imported_containers.add(prop.container.as_id())
+            if prop.view not in existing_views:
+                imported_views.add(prop.view.as_id())
+            view_with_properties.add(prop.view)
+
+        if include_model_views_with_no_properties:
+            extra_views = existing_views - view_with_properties
+            imported_views.update({view.as_id() for view in extra_views})
+
+        return imported_views, imported_containers

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

@@ -5,13 +5,13 @@ from typing import Any, Literal
 
 import pandas as pd
 from cognite.client import data_modeling as dm
-from rdflib import URIRef
+from cognite.client.data_classes.data_modeling import ContainerId, ViewId
+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 +27,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 +50,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 +76,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 +104,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 +119,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
@@ -123,14 +126,18 @@ class DMSInputProperty(InputComponent[DMSProperty]):
         )
         return output
 
+    def referenced_view(self, default_space: str, default_version: str) -> ViewEntity:
+        return ViewEntity.load(self.view, strict=True, space=default_space, version=default_version)
+
+    def referenced_container(self, default_space: str) -> ContainerEntity | None:
+        return ContainerEntity.load(self.container, strict=True, space=default_space) if self.container else None
+
 
 @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
 
@@ -140,11 +147,7 @@ class DMSInputContainer(InputComponent[DMSContainer]):
 
     def dump(self, default_space: str) -> dict[str, Any]:  # type: ignore[override]
         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["Container"] = self.as_entity_id(default_space)
         output["Constraint"] = (
             [ContainerEntity.load(constraint.strip(), space=default_space) for constraint in self.constraint.split(",")]
             if self.constraint
@@ -152,6 +155,9 @@ class DMSInputContainer(InputComponent[DMSContainer]):
         )
         return output
 
+    def as_entity_id(self, default_space: str) -> ContainerEntity:
+        return ContainerEntity.load(self.container, strict=True, space=default_space)
+
     @classmethod
     def from_container(cls, container: dm.ContainerApply) -> "DMSInputContainer":
         constraints: list[str] = []
@@ -161,7 +167,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 +178,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
+    filter_: Literal["hasData", "nodeType", "rawFilter"] | str | None = None
     in_model: bool = True
+    logical: str | None = None
 
     @classmethod
     def _get_verified_cls(cls) -> type[DMSView]:
@@ -187,30 +191,31 @@ class DMSInputView(InputComponent[DMSView]):
 
     def dump(self, default_space: str, default_version: str) -> dict[str, Any]:  # type: ignore[override]
         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"] = (
+        output["View"] = self.as_entity_id(default_space, default_version)
+        output["Implements"] = self._load_implements(default_space, default_version)
+        return output
+
+    def as_entity_id(self, default_space: str, default_version: str) -> ViewEntity:
+        return ViewEntity.load(self.view, strict=True, space=default_space, version=default_version)
+
+    def _load_implements(self, default_space: str, default_version: str) -> list[ViewEntity] | None:
+        return (
             [
-                ViewEntity.load(implement, space=default_space, version=default_version)
+                ViewEntity.load(implement, strict=True, space=default_space, version=default_version)
                 for implement in self.implements.split(",")
             ]
             if self.implements
             else None
         )
-        return output
+
+    def referenced_views(self, default_space: str, default_version: str) -> list[ViewEntity]:
+        return self._load_implements(default_space, default_version) or []
 
     @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 +266,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 +274,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 +282,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:
@@ -315,3 +304,30 @@ class DMSInputRules(InputRules[DMSRules]):
         return DEFAULT_NAMESPACE[
             f"data-model/unverified/dms/{self.metadata.space}/{self.metadata.external_id}/{self.metadata.version}"
         ]
+
+    def referenced_views_and_containers(self) -> tuple[set[ViewEntity], set[ContainerEntity]]:
+        default_space = self.metadata.space
+        default_version = self.metadata.version
+
+        containers: set[ContainerEntity] = set()
+        views = {parent for view in self.views for parent in view.referenced_views(default_space, default_version)}
+        for prop in self.properties:
+            views.add(prop.referenced_view(default_space, default_version))
+            if ref_container := prop.referenced_container(default_space):
+                containers.add(ref_container)
+
+        return views, containers
+
+    def as_view_entities(self) -> list[ViewEntity]:
+        return [view.as_entity_id(self.metadata.space, self.metadata.version) for view in self.views]
+
+    def as_container_entities(self) -> list[ContainerEntity]:
+        return [container.as_entity_id(self.metadata.space) for container in self.containers or []]
+
+    def imported_views_and_containers(self) -> tuple[set[ViewEntity], set[ContainerEntity]]:
+        views, containers = self.referenced_views_and_containers()
+        return views - set(self.as_view_entities()), containers - set(self.as_container_entities())
+
+    def imported_views_and_containers_ids(self) -> tuple[set[ViewId], set[ContainerId]]:
+        views, containers = self.imported_views_and_containers()
+        return {view.as_id() for view in views}, {container.as_id() for container in containers}