cognite-neat 0.75.9__py3-none-any.whl → 0.76.1__py3-none-any.whl

cognite/neat/rules/models/rules/_dms_architect_rules.py

@@ -4,13 +4,18 @@ import re
 import sys
 import warnings
 from collections import defaultdict
+from collections.abc import Callable
 from datetime import datetime
 from typing import TYPE_CHECKING, Any, ClassVar, Literal, cast
 
 from cognite.client import data_modeling as dm
 from cognite.client.data_classes.data_modeling import PropertyType as CognitePropertyType
 from cognite.client.data_classes.data_modeling.containers import BTreeIndex
-from cognite.client.data_classes.data_modeling.views import SingleReverseDirectRelationApply, ViewPropertyApply
+from cognite.client.data_classes.data_modeling.views import (
+    SingleEdgeConnectionApply,
+    SingleReverseDirectRelationApply,
+    ViewPropertyApply,
+)
 from pydantic import Field, field_serializer, field_validator, model_serializer, model_validator
 from pydantic_core.core_schema import SerializationInfo, ValidationInfo
 from rdflib import Namespace
@@ -22,6 +27,7 @@ from cognite.neat.rules.models.entities import (
     ClassEntity,
     ContainerEntity,
     ContainerEntityList,
+    DMSNodeEntity,
     DMSUnknownEntity,
     ParentClassEntity,
     ReferenceEntity,
@@ -32,8 +38,18 @@ from cognite.neat.rules.models.entities import (
     ViewPropertyEntity,
 )
 from cognite.neat.rules.models.rules._domain_rules import DomainRules
-
-from ._base import BaseMetadata, BaseRules, ExtensionCategory, RoleTypes, SchemaCompleteness, SheetEntity, SheetList
+from cognite.neat.rules.models.wrapped_entities import DMSFilter, HasDataFilter, NodeTypeFilter
+
+from ._base import (
+    BaseMetadata,
+    BaseRules,
+    DataModelType,
+    ExtensionCategory,
+    RoleTypes,
+    SchemaCompleteness,
+    SheetEntity,
+    SheetList,
+)
 from ._dms_schema import DMSSchema, PipelineSchema
 from ._types import (
     ExternalIdType,
@@ -67,6 +83,7 @@ del subclasses  # cleanup namespace
 
 class DMSMetadata(BaseMetadata):
     role: ClassVar[RoleTypes] = RoleTypes.dms_architect
+    data_model_type: DataModelType = Field(DataModelType.solution, alias="dataModelType")
     schema_: SchemaCompleteness = Field(alias="schema")
     extension: ExtensionCategory = ExtensionCategory.addition
     space: ExternalIdType
@@ -86,8 +103,6 @@ class DMSMetadata(BaseMetadata):
     updated: datetime = Field(
         description=("Date of the data model update"),
     )
-    # MyPy does not account for the field validator below that sets the default value
-    default_view_version: VersionType = Field(None)  # type: ignore[assignment]
 
     @field_validator("*", mode="before")
     def strip_string(cls, value: Any) -> Any:
@@ -95,15 +110,22 @@ class DMSMetadata(BaseMetadata):
             return value.strip()
         return value
 
+    @field_serializer("schema_", "extension", "data_model_type", when_used="always")
+    @staticmethod
+    def as_string(value: SchemaCompleteness | ExtensionCategory | DataModelType) -> str:
+        return str(value)
+
     @field_validator("schema_", mode="plain")
-    def as_enum(cls, value: str) -> SchemaCompleteness:
+    def as_enum_schema(cls, value: str) -> SchemaCompleteness:
         return SchemaCompleteness(value)
 
-    @model_validator(mode="before")
-    def set_default_view_version_if_missing(cls, values):
-        if "default_view_version" not in values:
-            values["default_view_version"] = values["version"]
-        return values
+    @field_validator("extension", mode="plain")
+    def as_enum_extension(cls, value: str) -> ExtensionCategory:
+        return ExtensionCategory(value)
+
+    @field_validator("data_model_type", mode="plain")
+    def as_enum_model_type(cls, value: str) -> DataModelType:
+        return DataModelType(value)
 
     @field_validator("description", mode="before")
     def nan_as_none(cls, value):
@@ -116,6 +138,9 @@ class DMSMetadata(BaseMetadata):
             space=self.space,
         )
 
+    def as_data_model_id(self) -> dm.DataModelId:
+        return dm.DataModelId(space=self.space, external_id=self.external_id, version=self.version)
+
     def as_data_model(self) -> dm.DataModelApply:
         suffix = f"Creator: {', '.join(self.creator)}"
         if self.description:
@@ -162,44 +187,42 @@ class DMSMetadata(BaseMetadata):
 
 
 class DMSProperty(SheetEntity):
-    property_: PropertyType = Field(alias="Property")
-    relation: Literal["direct", "reversedirect", "multiedge"] | None = Field(None, alias="Relation")
+    view: ViewEntity = Field(alias="View")
+    view_property: str = Field(alias="View Property")
+    name: str | None = Field(alias="Name", default=None)
+    description: str | None = Field(alias="Description", default=None)
+    connection: Literal["direct", "edge", "reverse"] | None = Field(None, alias="Connection")
     value_type: DataType | ViewPropertyEntity | ViewEntity | DMSUnknownEntity = Field(alias="Value Type")
     nullable: bool | None = Field(default=None, alias="Nullable")
-    is_list: bool | None = Field(default=None, alias="IsList")
+    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: ContainerEntity | None = Field(None, alias="Container")
-    container_property: str | None = Field(None, alias="ContainerProperty")
-    view: ViewEntity = Field(alias="View")
-    view_property: str = Field(alias="ViewProperty")
+    container_property: str | None = Field(None, alias="Container Property")
     index: StrListType | None = Field(None, alias="Index")
     constraint: StrListType | None = Field(None, alias="Constraint")
+    class_: ClassEntity = Field(alias="Class (linage)")
+    property_: PropertyType = Field(alias="Property (linage)")
 
     @field_validator("nullable")
     def direct_relation_must_be_nullable(cls, value: Any, info: ValidationInfo) -> None:
-        if info.data.get("relation") == "direct" and value is False:
+        if info.data.get("connection") == "direct" and value is False:
             raise ValueError("Direct relation must be nullable")
         return value
 
-    @field_validator("container_property", "container")
-    def reverse_direct_relation_has_no_container(cls, value, info: ValidationInfo) -> None:
-        if info.data.get("relation") == "reversedirect" and value is not None:
-            raise ValueError(f"Reverse direct relation must not have container or container property, got {value}")
-        return value
-
     @field_validator("value_type", mode="after")
-    def relations_value_type(cls, value: DataType | ClassEntity, info: ValidationInfo) -> DataType | ClassEntity:
-        if (relation := info.data["relation"]) is None:
+    def connections_value_type(
+        cls, value: ViewPropertyEntity | ViewEntity | DMSUnknownEntity, info: ValidationInfo
+    ) -> DataType | ViewPropertyEntity | ViewEntity | DMSUnknownEntity:
+        if (connection := info.data.get("connection")) is None:
             return value
-        if not isinstance(value, ViewEntity | ViewPropertyEntity | DMSUnknownEntity):
-            raise ValueError(f"Relations must have a value type that points to another view, got {value}")
-        if relation == "reversedirect" and value.property_ is None:
-            # Todo fix this error message. It have the wrong syntax for how to have a property
+        if connection == "direct" and not isinstance(value, ViewEntity | DMSUnknownEntity):
+            raise ValueError(f"Direct relation must have a value type that points to a view, got {value}")
+        elif connection == "edge" and not isinstance(value, ViewEntity):
+            raise ValueError(f"Edge connection must have a value type that points to a view, got {value}")
+        elif connection == "reverse" and not isinstance(value, ViewPropertyEntity | ViewEntity):
             raise ValueError(
-                "Reverse direct relation must set what it is the reverse property of. "
-                f"Which property in {value.versioned_id} is this the reverse of? Expecting"
-                f"{value.versioned_id}:<property>"
+                f"Reverse connection must have a value type that points to a view or view property, got {value}"
             )
         return value
 
@@ -214,8 +237,11 @@ class DMSProperty(SheetEntity):
 
 class DMSContainer(SheetEntity):
     container: ContainerEntity = 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")
+    class_: ClassEntity = Field(alias="Class (linage)")
 
     def as_container(self) -> dm.ContainerApply:
         container_id = self.container.as_id()
@@ -240,9 +266,10 @@ class DMSContainer(SheetEntity):
             if isinstance(constraint_obj, dm.RequiresConstraint):
                 constraints.append(ContainerEntity.from_id(constraint_obj.require))
             # UniquenessConstraint it handled in the properties
+        container_entity = ContainerEntity.from_id(container.as_id())
         return cls(
-            class_=ClassEntity(prefix=container.space, suffix=container.external_id),
-            container=ContainerEntity(space=container.space, externalId=container.external_id),
+            class_=container_entity.as_class(),
+            container=container_entity,
             name=container.name or None,
             description=container.description,
             constraint=constraints or None,
@@ -251,10 +278,13 @@ class DMSContainer(SheetEntity):
 
 class DMSView(SheetEntity):
     view: ViewEntity = Field(alias="View")
+    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_: Literal["hasData", "nodeType"] | None = Field(None, alias="Filter")
-    in_model: bool = Field(True, alias="InModel")
+    filter_: HasDataFilter | NodeTypeFilter | None = Field(None, alias="Filter")
+    in_model: bool = Field(True, alias="In Model")
+    class_: ClassEntity = Field(alias="Class (linage)")
 
     def as_view(self) -> dm.ViewApply:
         view_id = self.view.as_id()
@@ -269,20 +299,17 @@ class DMSView(SheetEntity):
         )
 
     @classmethod
-    def from_view(cls, view: dm.ViewApply, data_model_view_ids: set[dm.ViewId]) -> "DMSView":
+    def from_view(cls, view: dm.ViewApply, in_model: bool) -> "DMSView":
+        view_entity = ViewEntity.from_id(view.as_id())
+        class_entity = view_entity.as_class(skip_version=True)
+
         return cls(
-            class_=ClassEntity(prefix=view.space, suffix=view.external_id),
-            view=ViewEntity(space=view.space, externalId=view.external_id, version=view.version),
+            class_=class_entity,
+            view=view_entity,
             description=view.description,
             name=view.name,
-            implements=[
-                ViewEntity(
-                    space=parent.space, externalId=parent.external_id, version=parent.version or _DEFAULT_VERSION
-                )
-                for parent in view.implements
-            ]
-            or None,
-            in_model=view.as_id() in data_model_view_ids,
+            implements=[ViewEntity.from_id(parent, _DEFAULT_VERSION) for parent in view.implements] or None,
+            in_model=in_model,
         )
 
 
@@ -293,6 +320,41 @@ class DMSRules(BaseRules):
     containers: SheetList[DMSContainer] | None = Field(None, alias="Containers")
     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(
+                issues.dms.SolutionOnTopOfSolutionModelWarning(
+                    metadata.as_data_model_id(), 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]:
+        if not (metadata := info.data.get("metadata")):
+            return value
+        model_version = metadata.version
+        if different_version := [view.view.as_id() for view in value if view.view.version != model_version]:
+            warnings.warn(issues.dms.ViewModelVersionNotMatchingWarning(different_version, model_version), stacklevel=2)
+        if different_space := [view.view.as_id() for view in value if view.view.space != metadata.space]:
+            warnings.warn(issues.dms.ViewModelSpaceNotMatchingWarning(different_space, metadata.space), stacklevel=2)
+        return value
+
+    @field_validator("views")
+    def matching_version(cls, value: SheetList[DMSView], info: ValidationInfo) -> SheetList[DMSView]:
+        if not (metadata := info.data.get("metadata")):
+            return value
+        model_version = metadata.version
+        if different_version := [view.view.as_id() for view in value if view.view.version != model_version]:
+            warnings.warn(issues.dms.ViewModelVersionNotMatchingWarning(different_version, model_version), stacklevel=2)
+        return value
+
     @model_validator(mode="after")
     def consistent_container_properties(self) -> "DMSRules":
         container_properties_by_id: dict[tuple[ContainerEntity, str], list[tuple[int, DMSProperty]]] = defaultdict(list)
@@ -439,7 +501,7 @@ class DMSRules(BaseRules):
             # Everything is allowed
             return self
         # Is an extension of an existing model.
-        user_schema = self.as_schema()
+        user_schema = self.as_schema(include_ref=False)
         ref_schema = self.reference.as_schema()
         new_containers = {container.as_id(): container for container in user_schema.containers}
         existing_containers = {container.as_id(): container for container in ref_schema.containers}
@@ -540,70 +602,20 @@ class DMSRules(BaseRules):
             raise issues.MultiValueError(errors)
         return self
 
-    @model_serializer(mode="plain", when_used="always")
-    def dms_rules_serialization(self, info: SerializationInfo) -> dict[str, Any]:
-        kwargs = vars(info)
-        default_space = f"{self.metadata.space}:"
-        default_version = f"version={self.metadata.default_view_version}"
-        default_version_wrapped = f"({default_version})"
-        properties = []
-        field_names = (
-            ["Class", "View", "Value Type", "Container"]
-            if info.by_alias
-            else ["class_", "view", "value_type", "container"]
-        )
-        value_type_name = "Value Type" if info.by_alias else "value_type"
-        for prop in self.properties:
-            dumped = prop.model_dump(**kwargs)
-            for field_name in field_names:
-                if value := dumped.get(field_name):
-                    dumped[field_name] = value.removeprefix(default_space).removesuffix(default_version_wrapped)
-            # Value type can have a property as well
-            dumped[value_type_name] = dumped[value_type_name].replace(default_version, "")
-            properties.append(dumped)
-
-        views = []
-        field_names = ["Class", "View", "Implements"] if info.by_alias else ["class_", "view", "implements"]
-        implements_name = "Implements" if info.by_alias else "implements"
-        for view in self.views:
-            dumped = view.model_dump(**kwargs)
-            for field_name in field_names:
-                if value := dumped.get(field_name):
-                    dumped[field_name] = value.removeprefix(default_space).removesuffix(default_version_wrapped)
-            if value := dumped.get(implements_name):
-                dumped[implements_name] = ",".join(
-                    parent.strip().removeprefix(default_space).removesuffix(default_version_wrapped)
-                    for parent in value.split(",")
-                )
-            views.append(dumped)
-
-        containers = []
-        field_names = ["Class", "Container"] if info.by_alias else ["class_", "container"]
-        constraint_name = "Constraint" if info.by_alias else "constraint"
-        for container in self.containers or []:
-            dumped = container.model_dump(**kwargs)
-            for field_name in field_names:
-                if value := dumped.get(field_name):
-                    dumped[field_name] = value.removeprefix(default_space).removesuffix(default_version_wrapped)
-                if value := dumped.get(constraint_name):
-                    dumped[constraint_name] = ",".join(
-                        constraint.strip().removeprefix(default_space).removesuffix(default_version_wrapped)
-                        for constraint in value.split(",")
-                    )
-            containers.append(dumped)
-
-        output = {
-            "Metadata" if info.by_alias else "metadata": self.metadata.model_dump(**kwargs),
-            "Properties" if info.by_alias else "properties": properties,
-            "Views" if info.by_alias else "views": views,
-            "Containers" if info.by_alias else "containers": containers,
-        }
-        if self.reference is not None:
-            output["Reference" if info.by_alias else "reference"] = self.reference.model_dump(**kwargs)
-        return output
-
-    def as_schema(self, include_pipeline: bool = False, instance_space: str | None = None) -> DMSSchema:
-        return _DMSExporter(include_pipeline, instance_space).to_schema(self)
+    @model_serializer(mode="wrap", when_used="always")
+    def dms_rules_serialization(
+        self,
+        handler: Callable,
+        info: SerializationInfo,
+    ) -> dict[str, Any]:
+        dumped = cast(dict[str, Any], handler(self, info))
+        space, version = self.metadata.space, self.metadata.version
+        return _DMSRulesSerializer(info, space, version).clean(dumped)
+
+    def as_schema(
+        self, include_ref: bool = False, include_pipeline: bool = False, instance_space: str | None = None
+    ) -> DMSSchema:
+        return _DMSExporter(self, include_ref, include_pipeline, instance_space).to_schema()
 
     def as_information_architect_rules(self) -> "InformationRules":
         return _DMSRulesConverter(self).as_information_architect_rules()
@@ -640,16 +652,30 @@ class _DMSExporter:
         instance_space (str): The space to use for the instance. Defaults to None,`Rules.metadata.space` will be used
     """
 
-    def __init__(self, include_pipeline: bool = False, instance_space: str | None = None):
+    def __init__(
+        self,
+        rules: DMSRules,
+        include_ref: bool = True,
+        include_pipeline: bool = False,
+        instance_space: str | None = None,
+    ):
+        self.include_ref = include_ref
         self.include_pipeline = include_pipeline
         self.instance_space = instance_space
+        self.rules = rules
+        self._ref_schema = rules.reference.as_schema() if rules.reference else None
+        if self._ref_schema:
+            # We skip version as that will always be missing in the reference
+            self._ref_views_by_id = {dm.ViewId(view.space, view.external_id): view for view in self._ref_schema.views}
+        else:
+            self._ref_views_by_id = {}
 
-    def to_schema(self, rules: DMSRules) -> DMSSchema:
-        container_properties_by_id, view_properties_by_id = self._gather_properties(rules)
-
-        containers = self._create_containers(rules.containers, container_properties_by_id)
+    def to_schema(self) -> DMSSchema:
+        rules = self.rules
+        container_properties_by_id, view_properties_by_id = self._gather_properties()
+        containers = self._create_containers(container_properties_by_id)
 
-        views, node_types = self._create_views_with_node_types(rules.views, view_properties_by_id)
+        views, node_types = self._create_views_with_node_types(view_properties_by_id)
 
         views_not_in_model = {view.view.as_id() for view in rules.views if not view.in_model}
         data_model = rules.metadata.as_data_model()
@@ -669,6 +695,16 @@ class _DMSExporter:
         )
         if self.include_pipeline:
             return PipelineSchema.from_dms(output, self.instance_space)
+
+        if self._ref_schema and self.include_ref:
+            output.frozen_ids.update(self._ref_schema.node_types.as_ids())
+            output.frozen_ids.update(self._ref_schema.views.as_ids())
+            output.frozen_ids.update(self._ref_schema.containers.as_ids())
+            output.node_types.extend(self._ref_schema.node_types)
+            output.views.extend(self._ref_schema.views)
+            output.containers.extend(self._ref_schema.containers)
+            output.data_models.extend(self._ref_schema.data_models)
+
         return output
 
     def _create_spaces(
@@ -692,11 +728,10 @@ class _DMSExporter:
 
     def _create_views_with_node_types(
         self,
-        dms_views: SheetList[DMSView],
         view_properties_by_id: dict[dm.ViewId, list[DMSProperty]],
     ) -> tuple[dm.ViewApplyList, dm.NodeApplyList]:
-        views = dm.ViewApplyList([dms_view.as_view() for dms_view in dms_views])
-        dms_view_by_id = {dms_view.view.as_id(): dms_view for dms_view in dms_views}
+        views = dm.ViewApplyList([dms_view.as_view() for dms_view in self.rules.views])
+        dms_view_by_id = {dms_view.view.as_id(): dms_view for dms_view in self.rules.views}
 
         for view in views:
             view_id = view.as_id()
@@ -704,193 +739,66 @@ class _DMSExporter:
             if not (view_properties := view_properties_by_id.get(view_id)):
                 continue
             for prop in view_properties:
-                view_property: ViewPropertyApply
-                if prop.is_list and prop.relation == "direct":
-                    # This is not yet supported in the CDF API, a warning has already been issued, here we convert it to
-                    # a multi-edge connection.
-                    if isinstance(prop.value_type, ViewEntity):
-                        source_view_id = prop.value_type.as_id()
-                    elif isinstance(prop.value_type, ViewPropertyEntity):
-                        source_view_id = prop.value_type.as_view_id()
-                    else:
-                        raise ValueError(
-                            "Direct relation must have a view as value type. "
-                            "This should have been validated in the rules"
-                        )
-                    view_property = dm.MultiEdgeConnectionApply(
-                        type=dm.DirectRelationReference(
-                            space=source_view_id.space,
-                            external_id=f"{prop.view.external_id}.{prop.view_property}",
-                        ),
-                        source=source_view_id,
-                        direction="outwards",
-                        name=prop.name,
-                        description=prop.description,
-                    )
-                elif prop.container and prop.container_property and prop.view_property:
-                    container_prop_identifier = prop.container_property
-                    extra_args: dict[str, Any] = {}
-                    if prop.relation == "direct" and isinstance(prop.value_type, ViewEntity):
-                        extra_args["source"] = prop.value_type.as_id()
-                    elif isinstance(prop.value_type, DMSUnknownEntity):
-                        extra_args["source"] = None
-                    elif prop.relation == "direct" and not isinstance(prop.value_type, ViewEntity):
-                        raise ValueError(
-                            "Direct relation must have a view as value type. "
-                            "This should have been validated in the rules"
-                        )
-                    view_property = dm.MappedPropertyApply(
-                        container=prop.container.as_id(),
-                        container_property_identifier=container_prop_identifier,
-                        name=prop.name,
-                        description=prop.description,
-                        **extra_args,
-                    )
-                elif prop.view and prop.view_property and prop.relation == "multiedge":
-                    if isinstance(prop.value_type, ViewEntity):
-                        source_view_id = prop.value_type.as_id()
-                    else:
-                        raise ValueError(
-                            "Multiedge relation must have a view as value type. "
-                            "This should have been validated in the rules"
-                        )
-                    if isinstance(prop.reference, ReferenceEntity):
-                        ref_view_prop = prop.reference.as_view_property_id()
-                        edge_type = dm.DirectRelationReference(
-                            space=ref_view_prop.source.space,
-                            external_id=f"{ref_view_prop.source.external_id}.{ref_view_prop.property}",
-                        )
-                    else:
-                        edge_type = dm.DirectRelationReference(
-                            space=source_view_id.space,
-                            external_id=f"{prop.view.external_id}.{prop.view_property}",
-                        )
-
-                    view_property = dm.MultiEdgeConnectionApply(
-                        type=edge_type,
-                        source=source_view_id,
-                        direction="outwards",
-                        name=prop.name,
-                        description=prop.description,
-                    )
-                elif prop.view and prop.view_property and prop.relation == "reversedirect":
-                    if isinstance(prop.value_type, ViewPropertyEntity):
-                        source_prop_id = prop.value_type.as_id()
-                        source_view_id = cast(dm.ViewId, source_prop_id.source)
-                    else:
-                        raise ValueError(
-                            "Reverse direct relation must have a view as value type. "
-                            "This should have been validated in the rules"
-                        )
-                    source_prop = prop.value_type.property_
-                    if source_prop is None:
-                        raise ValueError(
-                            "Reverse direct relation must set what it is the reverse property of. "
-                            f"Which property in {prop.value_type.versioned_id} is this the reverse of? Expecting "
-                            f"{prop.value_type.versioned_id}:<property>"
-                        )
-                    reverse_prop = next(
-                        (
-                            prop
-                            for prop in view_properties_by_id.get(source_view_id, [])
-                            if prop.property_ == source_prop
-                        ),
-                        None,
-                    )
-                    if reverse_prop and reverse_prop.relation == "direct" and reverse_prop.is_list:
-                        warnings.warn(
-                            issues.dms.ReverseOfDirectRelationListWarning(view_id, prop.property_), stacklevel=2
-                        )
-                        if isinstance(reverse_prop.reference, ReferenceEntity):
-                            ref_view_prop = reverse_prop.reference.as_view_property_id()
-                            edge_type = dm.DirectRelationReference(
-                                space=ref_view_prop.source.space,
-                                external_id=f"{ref_view_prop.source.external_id}.{ref_view_prop.property}",
-                            )
-                        else:
-                            edge_type = dm.DirectRelationReference(
-                                space=source_prop_id.source.space,
-                                external_id=f"{reverse_prop.view.external_id}.{reverse_prop.view_property}",
-                            )
-                        view_property = dm.MultiEdgeConnectionApply(
-                            type=edge_type,
-                            source=source_prop_id.source,  # type: ignore[arg-type]
-                            direction="inwards",
-                            name=prop.name,
-                            description=prop.description,
-                        )
-                    else:
-                        args: dict[str, Any] = dict(
-                            source=source_view_id,
-                            through=dm.PropertyId(source_prop_id.source, source_prop),
-                            description=prop.description,
-                            name=prop.name,
-                        )
-                        reverse_direct_cls: dict[
-                            bool | None,
-                            type[dm.MultiReverseDirectRelationApply] | type[SingleReverseDirectRelationApply],
-                        ] = {
-                            True: dm.MultiReverseDirectRelationApply,
-                            False: SingleReverseDirectRelationApply,
-                            None: dm.MultiReverseDirectRelationApply,
-                        }
-
-                        view_property = reverse_direct_cls[prop.is_list](**args)
-                elif prop.view and prop.view_property and prop.relation:
-                    warnings.warn(
-                        issues.dms.UnsupportedRelationWarning(view_id, prop.view_property, prop.relation), stacklevel=2
-                    )
-                    continue
-                else:
-                    continue
-                prop_id = prop.view_property
-                view.properties[prop_id] = view_property
+                view_property = self._create_view_property(prop, view_properties_by_id)
+                if view_property is not None:
+                    view.properties[prop.view_property] = view_property
 
-        node_types = dm.NodeApplyList([])
+        data_model_type = self.rules.metadata.data_model_type
+        unique_node_types: set[dm.NodeId] = set()
         parent_views = {parent for view in views for parent in view.implements or []}
         for view in views:
-            ref_containers = sorted(view.referenced_containers(), key=lambda c: c.as_tuple())
             dms_view = dms_view_by_id.get(view.as_id())
-            has_data = dm.filters.HasData(containers=list(ref_containers)) if ref_containers else None
-            if dms_view and isinstance(dms_view.reference, ReferenceEntity):
-                # If the view is a reference, we implement the reference view,
-                # and need the filter to match the reference
-                ref_view = dms_view.reference.as_view_id()
-                node_type = dm.filters.Equals(
-                    ["node", "type"], {"space": ref_view.space, "externalId": ref_view.external_id}
-                )
-            else:
-                node_type = dm.filters.Equals(["node", "type"], {"space": view.space, "externalId": view.external_id})
-            if view.as_id() in parent_views:
-                if dms_view and dms_view.filter_ == "nodeType":
+            dms_properties = view_properties_by_id.get(view.as_id(), [])
+            view_filter = self._create_view_filter(view, dms_view, data_model_type, dms_properties)
+
+            view.filter = view_filter.as_dms_filter()
+
+            if isinstance(view_filter, NodeTypeFilter):
+                unique_node_types.update(view_filter.nodes)
+                if view.as_id() in parent_views:
                     warnings.warn(issues.dms.NodeTypeFilterOnParentViewWarning(view.as_id()), stacklevel=2)
-                    view.filter = node_type
-                    node_types.append(dm.NodeApply(space=view.space, external_id=view.external_id, sources=[]))
+            elif isinstance(view_filter, HasDataFilter) and data_model_type == DataModelType.solution:
+                if dms_view and isinstance(dms_view.reference, ReferenceEntity):
+                    references = {dms_view.reference.as_view_id()}
+                elif any(True for prop in dms_properties if isinstance(prop.reference, ReferenceEntity)):
+                    references = {
+                        prop.reference.as_view_id()
+                        for prop in dms_properties
+                        if isinstance(prop.reference, ReferenceEntity)
+                    }
                 else:
-                    view.filter = has_data
-            elif has_data is None:
-                # Child filter without container properties
-                if dms_view and dms_view.filter_ == "hasData":
-                    warnings.warn(issues.dms.HasDataFilterOnNoPropertiesViewWarning(view.as_id()), stacklevel=2)
-                view.filter = node_type
-                node_types.append(dm.NodeApply(space=view.space, external_id=view.external_id, sources=[]))
-            else:
-                if dms_view and (dms_view.filter_ == "hasData" or dms_view.filter_ is None):
-                    # Default option
-                    view.filter = has_data
-                elif dms_view and dms_view.filter_ == "nodeType":
-                    view.filter = node_type
-                    node_types.append(dm.NodeApply(space=view.space, external_id=view.external_id, sources=[]))
-                else:
-                    view.filter = has_data
-        return views, node_types
+                    continue
+                warnings.warn(
+                    issues.dms.HasDataFilterOnViewWithReferencesWarning(view.as_id(), list(references)), stacklevel=2
+                )
+
+        return views, dm.NodeApplyList(
+            [dm.NodeApply(space=node.space, external_id=node.external_id) for node in unique_node_types]
+        )
+
+    @classmethod
+    def _create_edge_type_from_prop(cls, prop: DMSProperty) -> dm.DirectRelationReference:
+        if isinstance(prop.reference, ReferenceEntity):
+            ref_view_prop = prop.reference.as_view_property_id()
+            return cls._create_edge_type_from_view_id(cast(dm.ViewId, ref_view_prop.source), ref_view_prop.property)
+        else:
+            return cls._create_edge_type_from_view_id(prop.view.as_id(), prop.view_property)
+
+    @staticmethod
+    def _create_edge_type_from_view_id(view_id: dm.ViewId, property_: str) -> dm.DirectRelationReference:
+        return dm.DirectRelationReference(
+            space=view_id.space,
+            # This is the same convention as used when converting GraphQL to DMS
+            external_id=f"{view_id.external_id}.{property_}",
+        )
 
     def _create_containers(
         self,
-        dms_container: SheetList[DMSContainer] | None,
         container_properties_by_id: dict[dm.ContainerId, list[DMSProperty]],
     ) -> dm.ContainerApplyList:
-        containers = dm.ContainerApplyList([dms_container.as_container() for dms_container in dms_container or []])
+        containers = dm.ContainerApplyList(
+            [dms_container.as_container() for dms_container in self.rules.containers or []]
+        )
         container_to_drop = set()
         for container in containers:
             container_id = container.as_id()
@@ -906,26 +814,14 @@ class _DMSExporter:
                 else:
                     type_cls = dm.DirectRelation
 
-                prop_id = prop.container_property
-
-                if type_cls is dm.DirectRelation:
-                    container.properties[prop_id] = dm.ContainerProperty(
-                        type=dm.DirectRelation(),
-                        nullable=prop.nullable if prop.nullable is not None else True,
-                        default_value=prop.default,
-                        name=prop.name,
-                        description=prop.description,
-                    )
-                else:
-                    type_: CognitePropertyType
-                    type_ = type_cls(is_list=prop.is_list or False)
-                    container.properties[prop_id] = dm.ContainerProperty(
-                        type=type_,
-                        nullable=prop.nullable if prop.nullable is not None else True,
-                        default_value=prop.default,
-                        name=prop.name,
-                        description=prop.description,
-                    )
+                type_ = type_cls(is_list=prop.is_list or False)
+                container.properties[prop.container_property] = dm.ContainerProperty(
+                    type=type_,
+                    nullable=prop.nullable if prop.nullable is not None else True,
+                    default_value=prop.default,
+                    name=prop.name,
+                    description=prop.description,
+                )
 
             uniqueness_properties: dict[str, set[str]] = defaultdict(set)
             for prop in container_properties:
@@ -958,31 +854,175 @@ class _DMSExporter:
             [container for container in containers if container.as_id() not in container_to_drop]
         )
 
-    def _gather_properties(
-        self, rules: DMSRules
-    ) -> tuple[dict[dm.ContainerId, list[DMSProperty]], dict[dm.ViewId, list[DMSProperty]]]:
+    def _gather_properties(self) -> tuple[dict[dm.ContainerId, list[DMSProperty]], dict[dm.ViewId, list[DMSProperty]]]:
         container_properties_by_id: dict[dm.ContainerId, list[DMSProperty]] = defaultdict(list)
         view_properties_by_id: dict[dm.ViewId, list[DMSProperty]] = defaultdict(list)
-        for prop in rules.properties:
+        for prop in self.rules.properties:
             view_id = prop.view.as_id()
             view_properties_by_id[view_id].append(prop)
 
             if prop.container and prop.container_property:
-                if prop.relation == "direct" and prop.is_list:
-                    warnings.warn(
-                        issues.dms.DirectRelationListWarning(
-                            container_id=prop.container.as_id(),
-                            view_id=prop.view.as_id(),
-                            property=prop.container_property,
-                        ),
-                        stacklevel=2,
-                    )
-                    continue
                 container_id = prop.container.as_id()
                 container_properties_by_id[container_id].append(prop)
 
         return container_properties_by_id, view_properties_by_id
 
+    def _create_view_filter(
+        self,
+        view: dm.ViewApply,
+        dms_view: DMSView | None,
+        data_model_type: DataModelType,
+        dms_properties: list[DMSProperty],
+    ) -> DMSFilter:
+        selected_filter_name = (dms_view and dms_view.filter_ and dms_view.filter_.name) or ""
+        if dms_view and dms_view.filter_ and not dms_view.filter_.is_empty:
+            # Has Explicit Filter, use it
+            return dms_view.filter_
+
+        if data_model_type == DataModelType.solution and selected_filter_name in [NodeTypeFilter.name, ""]:
+            if (
+                dms_view
+                and isinstance(dms_view.reference, ReferenceEntity)
+                and not dms_properties
+                and (ref_view := self._ref_views_by_id.get(dms_view.reference.as_view_id()))
+                and ref_view.filter
+            ):
+                # No new properties, only reference, reuse the reference filter
+                return DMSFilter.from_dms_filter(ref_view.filter)
+            else:
+                referenced_node_ids = {
+                    prop.reference.as_node_entity()
+                    for prop in dms_properties
+                    if isinstance(prop.reference, ReferenceEntity)
+                }
+                if dms_view and isinstance(dms_view.reference, ReferenceEntity):
+                    referenced_node_ids.add(dms_view.reference.as_node_entity())
+                if referenced_node_ids:
+                    return NodeTypeFilter(inner=list(referenced_node_ids))
+
+        # Enterprise Model or (Solution + HasData)
+        ref_containers = view.referenced_containers()
+        if not ref_containers or selected_filter_name == HasDataFilter.name:
+            # Child filter without container properties
+            if selected_filter_name == HasDataFilter.name:
+                warnings.warn(issues.dms.HasDataFilterOnNoPropertiesViewWarning(view.as_id()), stacklevel=2)
+            return NodeTypeFilter(inner=[DMSNodeEntity(space=view.space, externalId=view.external_id)])
+        else:
+            # HasData or not provided (this is the default)
+            return HasDataFilter(inner=[ContainerEntity.from_id(id_) for id_ in ref_containers])
+
+    def _create_view_property(
+        self, prop: DMSProperty, view_properties_by_id: dict[dm.ViewId, list[DMSProperty]]
+    ) -> ViewPropertyApply | None:
+        if prop.container and prop.container_property:
+            container_prop_identifier = prop.container_property
+            extra_args: dict[str, Any] = {}
+            if prop.connection == "direct":
+                if isinstance(prop.value_type, ViewEntity):
+                    extra_args["source"] = prop.value_type.as_id()
+                elif isinstance(prop.value_type, DMSUnknownEntity):
+                    extra_args["source"] = None
+                else:
+                    # Should have been validated.
+                    raise ValueError(
+                        "If this error occurs it is a bug in NEAT, please report"
+                        f"Debug Info, Invalid valueType direct: {prop.model_dump_json()}"
+                    )
+            elif prop.connection is not None:
+                # Should have been validated.
+                raise ValueError(
+                    "If this error occurs it is a bug in NEAT, please report"
+                    f"Debug Info, Invalid connection: {prop.model_dump_json()}"
+                )
+            return dm.MappedPropertyApply(
+                container=prop.container.as_id(),
+                container_property_identifier=container_prop_identifier,
+                name=prop.name,
+                description=prop.description,
+                **extra_args,
+            )
+        elif prop.connection == "edge":
+            if isinstance(prop.value_type, ViewEntity):
+                source_view_id = prop.value_type.as_id()
+            else:
+                # Should have been validated.
+                raise ValueError(
+                    "If this error occurs it is a bug in NEAT, please report"
+                    f"Debug Info, Invalid valueType edge: {prop.model_dump_json()}"
+                )
+            edge_cls: type[dm.EdgeConnectionApply] = dm.MultiEdgeConnectionApply
+            # If is_list is not set, we default to a MultiEdgeConnection
+            if prop.is_list is False:
+                edge_cls = SingleEdgeConnectionApply
+
+            return edge_cls(
+                type=self._create_edge_type_from_prop(prop),
+                source=source_view_id,
+                direction="outwards",
+                name=prop.name,
+                description=prop.description,
+            )
+        elif prop.connection == "reverse":
+            reverse_prop_id: str | None = None
+            if isinstance(prop.value_type, ViewPropertyEntity):
+                source_view_id = prop.value_type.as_view_id()
+                reverse_prop_id = prop.value_type.property_
+            elif isinstance(prop.value_type, ViewEntity):
+                source_view_id = prop.value_type.as_id()
+            else:
+                # Should have been validated.
+                raise ValueError(
+                    "If this error occurs it is a bug in NEAT, please report"
+                    f"Debug Info, Invalid valueType reverse connection: {prop.model_dump_json()}"
+                )
+            reverse_prop: DMSProperty | None = None
+            if reverse_prop_id is not None:
+                reverse_prop = next(
+                    (
+                        prop
+                        for prop in view_properties_by_id.get(source_view_id, [])
+                        if prop.property_ == reverse_prop_id
+                    ),
+                    None,
+                )
+
+            if reverse_prop is None:
+                warnings.warn(
+                    issues.dms.ReverseRelationMissingOtherSideWarning(source_view_id, prop.view_property),
+                    stacklevel=2,
+                )
+
+            if reverse_prop is None or reverse_prop.connection == "edge":
+                inwards_edge_cls = (
+                    dm.MultiEdgeConnectionApply if prop.is_list in [True, None] else SingleEdgeConnectionApply
+                )
+                return inwards_edge_cls(
+                    type=self._create_edge_type_from_prop(reverse_prop or prop),
+                    source=source_view_id,
+                    name=prop.name,
+                    description=prop.description,
+                    direction="inwards",
+                )
+            elif reverse_prop_id and reverse_prop and reverse_prop.connection == "direct":
+                reverse_direct_cls = (
+                    dm.MultiReverseDirectRelationApply if prop.is_list is True else SingleReverseDirectRelationApply
+                )
+                return reverse_direct_cls(
+                    source=source_view_id,
+                    through=dm.PropertyId(source=source_view_id, property=reverse_prop_id),
+                    name=prop.name,
+                    description=prop.description,
+                )
+            else:
+                return None
+
+        elif prop.view and prop.view_property and prop.connection:
+            warnings.warn(
+                issues.dms.UnsupportedConnectionWarning(prop.view.as_id(), prop.view_property, prop.connection or ""),
+                stacklevel=2,
+            )
+        return None
+
 
 class _DMSRulesConverter:
     def __init__(self, dms: DMSRules):
@@ -1093,3 +1133,123 @@ class _DMSRulesConverter:
             suffix=container.suffix,
             property=property_.container_property,
         )
+
+
+class _DMSRulesSerializer:
+    # These are the fields that need to be cleaned from the default space and version
+    PROPERTIES_FIELDS: ClassVar[list[str]] = ["class_", "view", "value_type", "container"]
+    VIEWS_FIELDS: ClassVar[list[str]] = ["class_", "view", "implements"]
+    CONTAINERS_FIELDS: ClassVar[list[str]] = ["class_", "container"]
+
+    def __init__(self, info: SerializationInfo, default_space: str, default_version: str) -> None:
+        self.default_space = f"{default_space}:"
+        self.default_version = f"version={default_version}"
+        self.default_version_wrapped = f"({self.default_version})"
+
+        self.properties_fields = self.PROPERTIES_FIELDS
+        self.views_fields = self.VIEWS_FIELDS
+        self.containers_fields = self.CONTAINERS_FIELDS
+        self.prop_name = "properties"
+        self.view_name = "views"
+        self.container_name = "containers"
+        self.metadata_name = "metadata"
+        self.prop_view = "view"
+        self.prop_view_property = "view_property"
+        self.prop_value_type = "value_type"
+        self.view_view = "view"
+        self.view_implements = "implements"
+        self.container_container = "container"
+        self.container_constraint = "constraint"
+
+        if info.by_alias:
+            self.properties_fields = [
+                DMSProperty.model_fields[field].alias or field for field in self.properties_fields
+            ]
+            self.views_fields = [DMSView.model_fields[field].alias or field for field in self.views_fields]
+            self.container_fields = [
+                DMSContainer.model_fields[field].alias or field for field in self.containers_fields
+            ]
+            self.prop_view = DMSProperty.model_fields[self.prop_view].alias or self.prop_view
+            self.prop_view_property = DMSProperty.model_fields[self.prop_view_property].alias or self.prop_view_property
+            self.prop_value_type = DMSProperty.model_fields[self.prop_value_type].alias or self.prop_value_type
+            self.view_view = DMSView.model_fields[self.view_view].alias or self.view_view
+            self.view_implements = DMSView.model_fields[self.view_implements].alias or self.view_implements
+            self.container_container = (
+                DMSContainer.model_fields[self.container_container].alias or self.container_container
+            )
+            self.container_constraint = (
+                DMSContainer.model_fields[self.container_constraint].alias or self.container_constraint
+            )
+            self.prop_name = DMSRules.model_fields[self.prop_name].alias or self.prop_name
+            self.view_name = DMSRules.model_fields[self.view_name].alias or self.view_name
+            self.container_name = DMSRules.model_fields[self.container_name].alias or self.container_name
+            self.metadata_name = DMSRules.model_fields[self.metadata_name].alias or self.metadata_name
+
+        if isinstance(info.exclude, dict):
+            # Just for happy mypy
+            exclude = cast(dict, info.exclude)
+            self.exclude_properties = exclude.get("properties", {}).get("__all__", set())
+            self.exclude_views = exclude.get("views", {}).get("__all__", set()) or set()
+            self.exclude_containers = exclude.get("containers", {}).get("__all__", set()) or set()
+            self.metadata_exclude = exclude.get("metadata", set()) or set()
+            self.exclude_top = {k for k, v in exclude.items() if not v}
+        else:
+            self.exclude_top = set(info.exclude or {})
+            self.exclude_properties = set()
+            self.exclude_views = set()
+            self.exclude_containers = set()
+            self.metadata_exclude = set()
+
+    def clean(self, dumped: dict[str, Any]) -> dict[str, Any]:
+        # Sorting to get a deterministic order
+        dumped[self.prop_name] = sorted(
+            dumped[self.prop_name]["data"], key=lambda p: (p[self.prop_view], p[self.prop_view_property])
+        )
+        dumped[self.view_name] = sorted(dumped[self.view_name]["data"], key=lambda v: v[self.view_view])
+        if self.container_name in dumped:
+            dumped[self.container_name] = sorted(
+                dumped[self.container_name]["data"], key=lambda c: c[self.container_container]
+            )
+
+        for prop in dumped[self.prop_name]:
+            for field_name in self.properties_fields:
+                if value := prop.get(field_name):
+                    prop[field_name] = value.removeprefix(self.default_space).removesuffix(self.default_version_wrapped)
+            # Value type can have a property as well
+            prop[self.prop_value_type] = prop[self.prop_value_type].replace(self.default_version, "")
+            if self.exclude_properties:
+                for field in self.exclude_properties:
+                    prop.pop(field, None)
+
+        for view in dumped[self.view_name]:
+            for field_name in self.views_fields:
+                if value := view.get(field_name):
+                    view[field_name] = value.removeprefix(self.default_space).removesuffix(self.default_version_wrapped)
+            if value := view.get(self.view_implements):
+                view[self.view_implements] = ",".join(
+                    parent.strip().removeprefix(self.default_space).removesuffix(self.default_version_wrapped)
+                    for parent in value.split(",")
+                )
+            if self.exclude_views:
+                for field in self.exclude_views:
+                    view.pop(field, None)
+
+        for container in dumped[self.container_name]:
+            for field_name in self.containers_fields:
+                if value := container.get(field_name):
+                    container[field_name] = value.removeprefix(self.default_space)
+
+            if value := container.get(self.container_constraint):
+                container[self.container_constraint] = ",".join(
+                    constraint.strip().removeprefix(self.default_space) for constraint in value.split(",")
+                )
+            if self.exclude_containers:
+                for field in self.exclude_containers:
+                    container.pop(field, None)
+
+        if self.metadata_exclude:
+            for field in self.metadata_exclude:
+                dumped[self.metadata_name].pop(field, None)
+        for field in self.exclude_top:
+            dumped.pop(field, None)
+        return dumped