cognite-neat 0.90.2__py3-none-any.whl → 0.92.0__py3-none-any.whl

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

@@ -1,13 +1,13 @@
 import math
 import sys
 import warnings
+from collections.abc import Hashable
 from datetime import datetime
 from typing import TYPE_CHECKING, Any, ClassVar, Literal
 
 from cognite.client import data_modeling as dm
 from pydantic import Field, field_serializer, field_validator, model_validator
-from pydantic.main import IncEx
-from pydantic_core.core_schema import ValidationInfo
+from pydantic_core.core_schema import SerializationInfo, ValidationInfo
 
 from cognite.neat.issues import MultiValueError
 from cognite.neat.issues.warnings import (
@@ -21,8 +21,8 @@ from cognite.neat.rules.models._base_rules import (
     ExtensionCategory,
     RoleTypes,
     SchemaCompleteness,
-    SheetEntity,
     SheetList,
+    SheetRow,
 )
 from cognite.neat.rules.models._types import (
     ExternalIdType,
@@ -35,9 +35,11 @@ from cognite.neat.rules.models.entities import (
     ClassEntity,
     ContainerEntity,
     ContainerEntityList,
+    DMSEntity,
     DMSNodeEntity,
     DMSUnknownEntity,
     EdgeEntity,
+    Entity,
     HasDataFilter,
     NodeTypeFilter,
     RawFilter,
@@ -91,8 +93,7 @@ class DMSMetadata(BaseMetadata):
         return value
 
     @field_serializer("schema_", "extension", "data_model_type", when_used="always")
-    @staticmethod
-    def as_string(value: SchemaCompleteness | ExtensionCategory | DataModelType) -> str:
+    def as_string(self, value: SchemaCompleteness | ExtensionCategory | DataModelType) -> str:
         return str(value)
 
     @field_validator("schema_", mode="plain")
@@ -144,7 +145,13 @@ class DMSMetadata(BaseMetadata):
         return self.space
 
 
-class DMSProperty(SheetEntity):
+def _metadata(context: Any) -> DMSMetadata | None:
+    if isinstance(context, dict) and isinstance(context.get("metadata"), DMSMetadata):
+        return context["metadata"]
+    return None
+
+
+class DMSProperty(SheetRow):
     view: ViewEntity = Field(alias="View")
     view_property: str = Field(alias="View Property")
     name: str | None = Field(alias="Name", default=None)
@@ -163,6 +170,9 @@ class DMSProperty(SheetEntity):
     class_: ClassEntity = Field(alias="Class (linage)")
     property_: PropertyType = Field(alias="Property (linage)")
 
+    def _identifier(self) -> tuple[Hashable, ...]:
+        return self.view, self.view_property
+
     @field_validator("nullable")
     def direct_relation_must_be_nullable(cls, value: Any, info: ValidationInfo) -> None:
         if info.data.get("connection") == "direct" and value is False:
@@ -183,16 +193,46 @@ class DMSProperty(SheetEntity):
             raise ValueError(f"Reverse connection must have a value type that points to a view, got {value}")
         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")
-    @staticmethod
-    def as_dms_type(value_type: DataType | EdgeEntity | ViewEntity) -> str:
+    def as_dms_type(self, value_type: DataType | EdgeEntity | ViewEntity, info: SerializationInfo) -> str:
         if isinstance(value_type, DataType):
             return value_type._suffix_extra_args(value_type.dms._type)
-        else:
-            return str(value_type)
+        elif isinstance(value_type, EdgeEntity | ViewEntity) and (metadata := _metadata(info.context)):
+            return value_type.dump(space=metadata.space, version=metadata.version)
+        return str(value_type)
+
+    @field_serializer("view", "container", "class_", 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:
+                # When dumping as reference, the container should keep the default space for easy copying
+                # over to user sheets.
+                return value.dump()
+            return value.dump(prefix=metadata.space, version=metadata.version)
+        return str(value)
+
+    @field_serializer("connection", when_used="unless-none")
+    def remove_defaults(self, value: Any, info: SerializationInfo) -> str:
+        if isinstance(value, Entity) and (metadata := _metadata(info.context)):
+            default_type = f"{metadata.space}{self.view.external_id}.{self.view_property}"
+            return value.dump(space=metadata.space, version=metadata.version, type=default_type)
+        return str(value)
 
 
-class DMSContainer(SheetEntity):
+class DMSContainer(SheetRow):
     container: ContainerEntity = Field(alias="Container")
     name: str | None = Field(alias="Name", default=None)
     description: str | None = Field(alias="Description", default=None)
@@ -201,6 +241,9 @@ class DMSContainer(SheetEntity):
     used_for: Literal["node", "edge", "all"] | None = Field("all", alias="Used For")
     class_: ClassEntity = Field(alias="Class (linage)")
 
+    def _identifier(self) -> tuple[Hashable, ...]:
+        return (self.container,)
+
     def as_container(self) -> dm.ContainerApply:
         container_id = self.container.as_id()
         constraints: dict[str, dm.Constraint] = {}
@@ -218,8 +261,34 @@ class DMSContainer(SheetEntity):
             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")
+    def remove_default_space(self, value: Any, info: SerializationInfo) -> str:
+        if metadata := _metadata(info.context):
+            if isinstance(value, DMSEntity):
+                return value.dump(space=metadata.space, version=metadata.version)
+            elif isinstance(value, Entity):
+                return value.dump(prefix=metadata.space, version=metadata.version)
+        return str(value)
+
+    @field_serializer("constraint", when_used="unless-none")
+    def remove_default_spaces(self, value: Any, info: SerializationInfo) -> str:
+        if isinstance(value, list) and (metadata := _metadata(info.context)):
+            return ",".join(
+                constraint.dump(space=metadata.space, version=metadata.version)
+                if isinstance(constraint, DMSEntity)
+                else str(constraint)
+                for constraint in value
+            )
+        return ",".join(str(value) for value in value)
+
 
-class DMSView(SheetEntity):
+class DMSView(SheetRow):
     view: ViewEntity = Field(alias="View")
     name: str | None = Field(alias="Name", default=None)
     description: str | None = Field(alias="Description", default=None)
@@ -229,6 +298,32 @@ class DMSView(SheetEntity):
     in_model: bool = Field(True, alias="In Model")
     class_: ClassEntity = Field(alias="Class (linage)")
 
+    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")
+    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)
+        return str(value)
+
+    @field_serializer("implements", when_used="unless-none")
+    def remove_default_spaces(self, value: Any, info: SerializationInfo) -> str:
+        if isinstance(value, list) and (metadata := _metadata(info.context)):
+            return ",".join(
+                parent.dump(space=metadata.space, version=metadata.version)
+                if isinstance(parent, DMSEntity)
+                else str(parent)
+                for parent in value
+            )
+        return ",".join(str(value) for value in value) if isinstance(value, list) else value
+
     def as_view(self) -> dm.ViewApply:
         view_id = self.view.as_id()
         implements = [parent.as_id() for parent in self.implements or []] or None
@@ -249,12 +344,15 @@ class DMSView(SheetEntity):
         )
 
 
-class DMSNode(SheetEntity):
+class DMSNode(SheetRow):
     node: DMSNodeEntity = Field(alias="Node")
     usage: Literal["type", "collection"] = Field(alias="Usage")
     name: str | None = Field(alias="Name", default=None)
     description: str | None = Field(alias="Description", default=None)
 
+    def _identifier(self) -> tuple[Hashable, ...]:
+        return (self.node,)
+
     def as_node(self) -> dm.NodeApply:
         if self.usage == "type":
             return dm.NodeApply(space=self.node.space, external_id=self.node.external_id)
@@ -263,13 +361,28 @@ class DMSNode(SheetEntity):
         else:
             raise ValueError(f"Unknown usage {self.usage}")
 
+    @field_serializer("node", when_used="unless-none")
+    def remove_default_space(self, value: Any, info: SerializationInfo) -> str:
+        if isinstance(value, DMSEntity) and (metadata := _metadata(info.context)):
+            return value.dump(space=metadata.space, version=metadata.version)
+        return str(value)
+
 
-class DMSEnum(SheetEntity):
+class DMSEnum(SheetRow):
     collection: ClassEntity = Field(alias="Collection")
     value: str = Field(alias="Value")
     name: str | None = Field(alias="Name", default=None)
     description: str | None = Field(alias="Description", default=None)
 
+    def _identifier(self) -> tuple[Hashable, ...]:
+        return self.collection, self.value
+
+    @field_serializer("collection", when_used="unless-none")
+    def remove_default_space(self, value: Any, info: SerializationInfo) -> str:
+        if isinstance(value, DMSEntity) and (metadata := _metadata(info.context)):
+            return value.dump(space=metadata.space, version=metadata.version)
+        return str(value)
+
 
 class DMSRules(BaseRules):
     metadata: DMSMetadata = Field(alias="Metadata")
@@ -331,38 +444,6 @@ class DMSRules(BaseRules):
             raise MultiValueError(issue_list.errors)
         return self
 
-    def dump(
-        self,
-        mode: Literal["python", "json"] = "python",
-        by_alias: bool = False,
-        exclude: IncEx = None,
-        exclude_none: bool = False,
-        exclude_unset: bool = False,
-        exclude_defaults: bool = False,
-        as_reference: bool = False,
-    ) -> dict[str, Any]:
-        from ._serializer import _DMSRulesSerializer
-
-        dumped = self.model_dump(
-            mode=mode,
-            by_alias=by_alias,
-            exclude=exclude,
-            exclude_none=exclude_none,
-            exclude_unset=exclude_unset,
-            exclude_defaults=exclude_defaults,
-        )
-        space, version = self.metadata.space, self.metadata.version
-        serializer = _DMSRulesSerializer(by_alias, space, version)
-        clean = serializer.clean(dumped, as_reference)
-        last = "Last" if by_alias else "last"
-        if last_dump := clean.get(last):
-            clean[last] = serializer.clean(last_dump, False)
-        reference = "Reference" if by_alias else "reference"
-        if self.reference and (ref_dump := clean.get(reference)):
-            space, version = self.reference.metadata.space, self.reference.metadata.version
-            clean[reference] = _DMSRulesSerializer(by_alias, space, version).clean(ref_dump, True)
-        return clean
-
     def as_schema(self, include_pipeline: bool = False, instance_space: str | None = None) -> DMSSchema:
         from ._exporter import _DMSExporter
 

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

@@ -201,7 +201,7 @@ class DMSPostValidation:
             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[dm.ContainerId](
+                        ResourceNotDefinedError(
                             identifier=container_id,
                             resource_type="container",
                             location="Containers Sheet",
@@ -214,7 +214,7 @@ class DMSPostValidation:
                 for constraint_no, constraint in enumerate(container.constraint or []):
                     if constraint.as_id() not in defined_containers:
                         errors.append(
-                            ResourceNotDefinedError[dm.ContainerId](
+                            ResourceNotDefinedError(
                                 identifier=constraint.as_id(),
                                 resource_type="container",
                                 location="Containers Sheet",

cognite/neat/rules/models/domain.py

@@ -1,9 +1,9 @@
 import math
+from collections.abc import Hashable
 from dataclasses import dataclass, field
-from typing import Any, ClassVar
+from typing import ClassVar
 
-from pydantic import Field, field_serializer, field_validator, model_serializer
-from pydantic_core.core_schema import SerializationInfo
+from pydantic import Field, field_serializer, field_validator
 
 from cognite.neat.rules.models.data_types import DataType
 from cognite.neat.rules.models.entities import ClassEntity, ClassEntityList
@@ -13,8 +13,8 @@ from ._base_rules import (
     BaseMetadata,
     BaseRules,
     RoleTypes,
-    SheetEntity,
     SheetList,
+    SheetRow,
 )
 from ._types import PropertyType, StrOrListType
 
@@ -30,7 +30,7 @@ class DomainMetadata(BaseMetadata):
         return "domain"
 
 
-class DomainProperty(SheetEntity):
+class DomainProperty(SheetRow):
     class_: ClassEntity = Field(alias="Class")
     property_: PropertyType = Field(alias="Property")
     name: str | None = Field(alias="Name", default=None)
@@ -39,6 +39,9 @@ class DomainProperty(SheetEntity):
     min_count: int | None = Field(alias="Min Count", default=None)
     max_count: int | float | None = Field(alias="Max Count", default=None)
 
+    def _identifier(self) -> tuple[Hashable, ...]:
+        return self.class_, self.property_
+
     @field_serializer("max_count", when_used="json-unless-none")
     def serialize_max_count(self, value: int | float | None) -> int | float | None | str:
         if isinstance(value, float) and math.isinf(value):
@@ -52,12 +55,19 @@ class DomainProperty(SheetEntity):
         return value
 
 
-class DomainClass(SheetEntity):
+class DomainClass(SheetRow):
     class_: ClassEntity = Field(alias="Class")
     name: str | None = Field(alias="Name", default=None)
     description: str | None = Field(None, alias="Description")
     parent: ClassEntityList | None = Field(alias="Parent Class")
 
+    def _identifier(self) -> tuple[Hashable, ...]:
+        return (self.class_,)
+
+    @field_serializer("parent", when_used="unless-none")
+    def serialize_parent(self, value: list[ClassEntity]) -> str:
+        return ",".join([str(entry) for entry in value])
+
 
 class DomainRules(BaseRules):
     metadata: DomainMetadata = Field(alias="Metadata")
@@ -66,19 +76,6 @@ class DomainRules(BaseRules):
     last: "DomainRules | None" = Field(None, alias="Last")
     reference: "DomainRules | None" = Field(None, alias="Reference")
 
-    @model_serializer(mode="plain", when_used="always")
-    def domain_rules_serializer(self, info: SerializationInfo) -> dict[str, Any]:
-        kwargs = vars(info)
-        output: dict[str, Any] = {
-            "Metadata" if info.by_alias else "metadata": self.metadata.model_dump(**kwargs),
-            "Properties" if info.by_alias else "properties": [prop.model_dump(**kwargs) for prop in self.properties],
-        }
-        if self.classes or not info.exclude_none:
-            output["Classes" if info.by_alias else "classes"] = [
-                cls.model_dump(**kwargs) for cls in self.classes or []
-            ] or None
-        return output
-
 
 @dataclass
 class DomainInputMetadata(InputComponent[DomainMetadata]):

cognite/neat/rules/models/entities/_single_value.py

@@ -58,7 +58,7 @@ class Entity(BaseModel, extra="ignore"):
         elif isinstance(data, str) and data == str(Unknown):
             return UnknownEntity(prefix=Undefined, suffix=Unknown)
         if defaults and isinstance(defaults, dict):
-            # This is is a trick to pass in default values
+            # This is a trick to pass in default values
             return cls.model_validate({_PARSE: data, "defaults": defaults})
         else:
             return cls.model_validate(data)
@@ -123,8 +123,8 @@ class Entity(BaseModel, extra="ignore"):
                 extra_args[key] = annotation.load(extra_args[key], **defaults)  # type: ignore[union-attr, assignment]
         return dict(prefix=prefix, suffix=suffix, **extra_args)
 
-    def dump(self) -> str:
-        return str(self)
+    def dump(self, **defaults: Any) -> str:
+        return self._as_str(**defaults)
 
     def as_tuple(self) -> tuple[str, ...]:
         # We haver overwritten the serialization to str, so we need to do it manually
@@ -164,17 +164,22 @@ class Entity(BaseModel, extra="ignore"):
 
     @property
     def id(self) -> str:
+        return self._as_str()
+
+    def _as_str(self, **defaults: Any) -> str:
         # We have overwritten the serialization to str, so we need to do it manually
-        model_dump = [
-            (field.alias or field_name, v)
+        model_dump = {
+            field.alias or field_name: v.dump(**defaults) if isinstance(v, Entity) else v
             for field_name, field in self.model_fields.items()
             if (v := getattr(self, field_name)) is not None and field_name not in {"prefix", "suffix"}
-        ]
-        if len(model_dump) == 1:
-            args = f"{model_dump[0][0]}={model_dump[0][1]}"
-        else:
-            args = ",".join([f"{k}={v}" for k, v in model_dump])
-        if self.prefix == Undefined:
+        }
+        if isinstance(defaults, dict):
+            for key, value in defaults.items():
+                if key in model_dump and value == defaults.get(key):
+                    del model_dump[key]
+
+        args = ",".join(f"{k}={v}" for k, v in model_dump.items())
+        if self.prefix == Undefined or (isinstance(defaults, dict) and self.prefix == defaults.get("prefix")):
             base_id = str(self.suffix)
         else:
             base_id = f"{self.prefix}:{self.suffix!s}"
@@ -269,6 +274,11 @@ class DMSEntity(Entity, Generic[T_ID], ABC):
     prefix: str = Field(alias="space")
     suffix: str = Field(alias="externalId")
 
+    def dump(self, **defaults: Any) -> str:
+        if isinstance(defaults, dict) and "space" in defaults:
+            defaults["prefix"] = defaults.pop("space")
+        return super().dump(**defaults)
+
     @classmethod
     def load(cls: "type[T_DMSEntity]", data: Any, **defaults) -> "T_DMSEntity | DMSUnknownEntity":  # type: ignore[override]
         if isinstance(data, str) and data == str(Unknown):
@@ -407,6 +417,10 @@ class EdgeEntity(DMSEntity[None]):
     properties: ViewEntity | None = None
     direction: Literal["outwards", "inwards"] = "outwards"
 
+    def dump(self, **defaults: Any) -> str:
+        # Add default direction
+        return super().dump(**defaults, direction="outwards")
+
     def as_id(self) -> None:
         return None
 

cognite/neat/rules/models/entities/_types.py

@@ -41,11 +41,6 @@ def _generate_cdf_resource_list(v: Any) -> list[AssetEntity | RelationshipEntity
 ClassEntityList = Annotated[
     list[ClassEntity],
     BeforeValidator(_split_str),
-    PlainSerializer(
-        _join_str,
-        return_type=str,
-        when_used="unless-none",
-    ),
 ]
 
 
@@ -63,11 +58,6 @@ CdfResourceEntityList = Annotated[
 ContainerEntityList = Annotated[
     list[ContainerEntity],
     BeforeValidator(_split_str),
-    PlainSerializer(
-        _join_str,
-        return_type=str,
-        when_used="unless-none",
-    ),
 ]
 
 ViewEntityList = Annotated[

cognite/neat/rules/models/information/_rules.py

@@ -1,10 +1,11 @@
 import math
 import sys
+from collections.abc import Hashable
 from datetime import datetime
-from typing import TYPE_CHECKING, Any, ClassVar, Literal
+from typing import TYPE_CHECKING, Any, ClassVar
 
 from pydantic import Field, field_serializer, field_validator, model_validator
-from pydantic.main import IncEx
+from pydantic_core.core_schema import SerializationInfo
 from rdflib import Namespace
 
 from cognite.neat.constants import get_default_prefixes
@@ -18,8 +19,8 @@ from cognite.neat.rules.models._base_rules import (
     MatchType,
     RoleTypes,
     SchemaCompleteness,
-    SheetEntity,
     SheetList,
+    SheetRow,
 )
 from cognite.neat.rules.models._rdfpath import (
     RDFPath,
@@ -37,6 +38,7 @@ from cognite.neat.rules.models.data_types import DataType
 from cognite.neat.rules.models.entities import (
     ClassEntity,
     ClassEntityList,
+    Entity,
     EntityTypes,
     MultiValueTypeInfo,
     ReferenceEntity,
@@ -115,7 +117,13 @@ class InformationMetadata(BaseMetadata):
         return self.prefix
 
 
-class InformationClass(SheetEntity):
+def _get_metadata(context: Any) -> InformationMetadata | None:
+    if isinstance(context, dict) and isinstance(context.get("metadata"), InformationMetadata):
+        return context["metadata"]
+    return None
+
+
+class InformationClass(SheetRow):
     """
     Class is a category of things that share a common set of attributes and relationships.
 
@@ -135,8 +143,34 @@ class InformationClass(SheetEntity):
     match_type: MatchType | None = Field(alias="Match Type", default=None)
     comment: str | None = Field(alias="Comment", default=None)
 
-
-class InformationProperty(SheetEntity):
+    def _identifier(self) -> tuple[Hashable, ...]:
+        return (self.class_,)
+
+    @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.class_.dump()
+        return str(value) if value is not None else None
+
+    @field_serializer("class_", when_used="unless-none")
+    def remove_default_prefix(self, value: Any, info: SerializationInfo) -> str:
+        if (metadata := _get_metadata(info.context)) and isinstance(value, Entity):
+            return value.dump(prefix=metadata.prefix, version=metadata.version)
+        return str(value)
+
+    @field_serializer("parent", when_used="unless-none")
+    def remove_default_prefixes(self, value: Any, info: SerializationInfo) -> str:
+        if isinstance(value, list) and (metadata := _get_metadata(info.context)):
+            return ",".join(
+                parent.dump(prefix=metadata.prefix, version=metadata.version)
+                if isinstance(parent, Entity)
+                else str(parent)
+                for parent in value
+            )
+        return ",".join(str(value) for value in value)
+
+
+class InformationProperty(SheetRow):
     """
     A property is a characteristic of a class. It is a named attribute of a class that describes a range of values
     or a relationship to another class.
@@ -171,15 +205,13 @@ class InformationProperty(SheetEntity):
     comment: str | None = Field(alias="Comment", default=None)
     inherited: bool = Field(
         default=False,
+        exclude=True,
         alias="Inherited",
         description="Flag to indicate if the property is inherited, only use for internal purposes",
     )
 
-    @field_serializer("max_count", when_used="json-unless-none")
-    def serialize_max_count(self, value: int | float | None) -> int | float | None | str:
-        if isinstance(value, float) and math.isinf(value):
-            return None
-        return value
+    def _identifier(self) -> tuple[Hashable, ...]:
+        return self.class_, self.property_
 
     @field_validator("max_count", mode="before")
     def parse_max_count(cls, value: int | float | None) -> int | float | None:
@@ -233,6 +265,31 @@ class InformationProperty(SheetEntity):
                     ) from None
         return self
 
+    @field_serializer("max_count", when_used="json-unless-none")
+    def serialize_max_count(self, value: int | float | None) -> int | float | None | str:
+        if isinstance(value, float) and math.isinf(value):
+            return None
+        return value
+
+    @field_serializer("reference", when_used="always")
+    def set_reference(self, value: Any, info: SerializationInfo) -> str | None:
+        # When rules as dumped as reference, we set the reference to the class
+        if isinstance(info.context, dict) and info.context.get("as_reference") is True:
+            return str(
+                ReferenceEntity(
+                    prefix=str(self.class_.prefix),
+                    suffix=self.class_.suffix,
+                    property=self.property_,
+                )
+            )
+        return str(value) if value is not None else None
+
+    @field_serializer("class_", "value_type", when_used="unless-none")
+    def remove_default_prefix(self, value: Any, info: SerializationInfo) -> str:
+        if (metadata := _get_metadata(info.context)) and isinstance(value, Entity):
+            return value.dump(prefix=metadata.prefix, version=metadata.version)
+        return str(value)
+
     @property
     def type_(self) -> EntityTypes:
         """Type of property based on value type. Either data (attribute) or object (edge) property."""
@@ -307,38 +364,6 @@ class InformationRules(BaseRules):
             raise issue_list.as_exception()
         return self
 
-    def dump(
-        self,
-        mode: Literal["python", "json"] = "python",
-        by_alias: bool = False,
-        exclude: IncEx = None,
-        exclude_none: bool = False,
-        exclude_unset: bool = False,
-        exclude_defaults: bool = False,
-        as_reference: bool = False,
-    ) -> dict[str, Any]:
-        from ._serializer import _InformationRulesSerializer
-
-        dumped = self.model_dump(
-            mode=mode,
-            by_alias=by_alias,
-            exclude=exclude,
-            exclude_none=exclude_none,
-            exclude_unset=exclude_unset,
-            exclude_defaults=exclude_defaults,
-        )
-        prefix = self.metadata.prefix
-        serializer = _InformationRulesSerializer(by_alias, prefix)
-        cleaned = serializer.clean(dumped, as_reference)
-        last = "Last" if by_alias else "last"
-        if last_dump := cleaned.get(last):
-            cleaned[last] = serializer.clean(last_dump, False)
-        reference = "Reference" if by_alias else "reference"
-        if self.reference and (ref_dump := cleaned.get(reference)):
-            prefix = self.reference.metadata.prefix
-            cleaned[reference] = _InformationRulesSerializer(by_alias, prefix).clean(ref_dump, True)
-        return cleaned
-
     def as_dms_rules(self) -> "DMSRules":
         from cognite.neat.rules.transformers._converters import _InformationRulesConverter