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

cognite/neat/_version.py

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

cognite/neat/rules/exporters/_rules2excel.py

@@ -116,17 +116,17 @@ class ExcelExporter(BaseExporter[Workbook]):
             }
 
             if self.dump_as == "last":
-                dumped_last_rules = rules.model_dump(by_alias=True)
+                dumped_last_rules = rules.dump(by_alias=True)
                 if rules.reference:
-                    dumped_reference_rules = rules.reference.model_dump(by_alias=True)
+                    dumped_reference_rules = rules.reference.dump(by_alias=True, as_reference=True)
             elif self.dump_as == "reference":
-                dumped_reference_rules = rules.reference_self().model_dump(by_alias=True)
+                dumped_reference_rules = rules.dump(by_alias=True, as_reference=True)
         else:
-            dumped_user_rules = rules.model_dump(by_alias=True)
+            dumped_user_rules = rules.dump(by_alias=True)
             if rules.last:
-                dumped_last_rules = rules.last.model_dump(by_alias=True)
+                dumped_last_rules = rules.last.dump(by_alias=True)
             if rules.reference:
-                dumped_reference_rules = rules.reference.model_dump(by_alias=True)
+                dumped_reference_rules = rules.reference.dump(by_alias=True, as_reference=True)
 
         self._write_metadata_sheet(workbook, dumped_user_rules["Metadata"])
         self._write_sheets(workbook, dumped_user_rules, rules)

cognite/neat/rules/exporters/_rules2yaml.py

@@ -69,10 +69,10 @@ class YAMLExporter(BaseExporter[str]):
         rules = self._convert_to_output_role(rules, self.output_role)
         # model_dump_json ensures that the output is in JSON format,
         # if we don't do this, we will get Enums and other types that are not serializable to YAML
-        json_output = rules.model_dump_json()
+        json_output = rules.dump(mode="json")
         if self.output == "json":
-            return json_output
+            return json.dumps(json_output)
         elif self.output == "yaml":
-            return yaml.safe_dump(json.loads(json_output))
+            return yaml.safe_dump(json_output)
         else:
             raise ValueError(f"Invalid output: {self.output}. Valid options are {self.format_option}")

cognite/neat/rules/models/_base.py

@@ -7,10 +7,9 @@ from __future__ import annotations
 import math
 import sys
 import types
-from abc import abstractmethod
 from collections.abc import Callable, Iterator
 from functools import wraps
-from typing import Annotated, Any, ClassVar, Generic, TypeAlias, TypeVar
+from typing import Annotated, Any, ClassVar, Generic, Literal, TypeAlias, TypeVar
 
 import pandas as pd
 from pydantic import (
@@ -26,13 +25,12 @@ from pydantic import (
     model_validator,
 )
 from pydantic.fields import FieldInfo
+from pydantic.main import IncEx
 
 if sys.version_info >= (3, 11):
     from enum import StrEnum
-    from typing import Self
 else:
     from backports.strenum import StrEnum
-    from typing_extensions import Self
 
 
 METADATA_VALUE_MAX_LENGTH = 5120
@@ -259,26 +257,33 @@ class BaseRules(RuleModel):
 
     Args:
         metadata: Data model metadata
-        classes: Classes defined in the data model
-        properties: Class properties defined in the data model with accompanying transformation rules
-                    to transform data from source to target representation
-        prefixes: Prefixes used in the data model. Defaults to PREFIXES
-        instances: Instances defined in the data model. Defaults to None
         validators_to_skip: List of validators to skip. Defaults to []
     """
 
     metadata: BaseMetadata
 
-    @abstractmethod
-    def reference_self(self) -> 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]:
+        """Dump the model to a dictionary.
+
+        This is used in the Exporters to dump rules in the required format.
         """
-        Returns a copy of the rules with reference fields set to itself
-
-        For example, if the rules have a property with a reference field, then
-        the reference field will be set to the property itself. This is used when
-        exporting a reference model.
-        """
-        raise NotImplementedError
+        return self.model_dump(
+            mode=mode,
+            by_alias=by_alias,
+            exclude=exclude,
+            exclude_none=exclude_none,
+            exclude_unset=exclude_unset,
+            exclude_defaults=exclude_defaults,
+        )
 
 
 # An sheet entity is either a class or a property.

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

@@ -1,5 +1,6 @@
 import warnings
 from collections import defaultdict
+from collections.abc import Sequence
 from typing import Any, cast
 
 from cognite.client.data_classes import data_modeling as dm
@@ -11,7 +12,7 @@ from cognite.client.data_classes.data_modeling.views import (
 )
 
 from cognite.neat.rules import issues
-from cognite.neat.rules.models._base import DataModelType
+from cognite.neat.rules.models._base import DataModelType, ExtensionCategory, SchemaCompleteness
 from cognite.neat.rules.models.data_types import DataType
 from cognite.neat.rules.models.entities import (
     ContainerEntity,
@@ -58,19 +59,83 @@ class _DMSExporter:
         else:
             self._ref_views_by_id = {}
 
+        self.is_addition = (
+            rules.metadata.schema_ is SchemaCompleteness.extended
+            and rules.metadata.extension is ExtensionCategory.addition
+        )
+        self.is_reshape = (
+            rules.metadata.schema_ is SchemaCompleteness.extended
+            and rules.metadata.extension is ExtensionCategory.reshape
+        )
+        self.is_rebuild = (
+            rules.metadata.schema_ is SchemaCompleteness.extended
+            and rules.metadata.extension is ExtensionCategory.rebuild
+        )
+
     def to_schema(self) -> DMSSchema:
         rules = self.rules
-        container_properties_by_id, view_properties_by_id = self._gather_properties()
+        container_properties_by_id, view_properties_by_id = self._gather_properties(list(self.rules.properties))
+
+        # If we are reshaping or rebuilding, and there are no properties in the current rules, we will
+        # include those properties from the last rules.
+        if rules.last and (self.is_reshape or self.is_rebuild):
+            selected_views = {view.view for view in rules.views}
+            selected_properties = [
+                prop
+                for prop in rules.last.properties
+                if prop.view in selected_views and prop.view.as_id() not in view_properties_by_id
+            ]
+            self._update_with_properties(
+                selected_properties, container_properties_by_id, view_properties_by_id, include_new_containers=True
+            )
+
+        # We need to include the properties from the last rules as well to create complete containers and view
+        # depending on the type of extension.
+        if rules.last and self.is_addition:
+            selected_properties = [
+                prop for prop in rules.last.properties if (prop.view.as_id() in view_properties_by_id)
+            ]
+            self._update_with_properties(selected_properties, container_properties_by_id, view_properties_by_id)
+        elif rules.last and (self.is_reshape or self.is_rebuild):
+            selected_properties = [
+                prop
+                for prop in rules.last.properties
+                if prop.container and prop.container.as_id() in container_properties_by_id
+            ]
+            self._update_with_properties(selected_properties, container_properties_by_id, None)
+
         containers = self._create_containers(container_properties_by_id)
 
         views, node_types = self._create_views_with_node_types(view_properties_by_id)
 
+        last_schema: DMSSchema | None = None
+        if self.rules.last:
+            last_schema = self.rules.last.as_schema()
+            # Remove the views that are in the current model, last + current should equal the full model
+            # without any duplicates
+            last_schema.views = ViewApplyDict(
+                {view_id: view for view_id, view in last_schema.views.items() if view_id not in views}
+            )
+            last_schema.containers = ContainerApplyDict(
+                {
+                    container_id: container
+                    for container_id, container in last_schema.containers.items()
+                    if container_id not in containers
+                }
+            )
+
         views_not_in_model = {view.view.as_id() for view in rules.views if not view.in_model}
+        if rules.last and self.is_addition:
+            views_not_in_model.update({view.view.as_id() for view in rules.last.views if not view.in_model})
+
         data_model = rules.metadata.as_data_model()
-        data_model.views = sorted(
-            [view_id for view_id in views.keys() if view_id not in views_not_in_model],
-            key=lambda v: v.as_tuple(),  # type: ignore[union-attr]
-        )
+
+        data_model_views = [view_id for view_id in views if view_id not in views_not_in_model]
+        if last_schema and self.is_addition:
+            data_model_views.extend([view_id for view_id in last_schema.views if view_id not in views_not_in_model])
+
+        # Sorting to ensure deterministic order
+        data_model.views = sorted(data_model_views, key=lambda v: v.as_tuple())  # type: ignore[union-attr]
 
         spaces = self._create_spaces(rules.metadata, containers, views, data_model)
 
@@ -86,8 +151,8 @@ class _DMSExporter:
 
         if self._ref_schema:
             output.reference = self._ref_schema
-        if self.rules.last:
-            output.last = self.rules.last.as_schema()
+        if last_schema:
+            output.last = last_schema
         return output
 
     def _create_spaces(
@@ -113,8 +178,18 @@ class _DMSExporter:
         self,
         view_properties_by_id: dict[dm.ViewId, list[DMSProperty]],
     ) -> tuple[ViewApplyDict, NodeApplyDict]:
-        views = ViewApplyDict([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}
+        input_views = list(self.rules.views)
+        if self.rules.last:
+            existing = {view.view.as_id() for view in input_views}
+            modified_views = [
+                v
+                for v in self.rules.last.views
+                if v.view.as_id() in view_properties_by_id and v.view.as_id() not in existing
+            ]
+            input_views.extend(modified_views)
+
+        views = ViewApplyDict([dms_view.as_view() for dms_view in input_views])
+        dms_view_by_id = {dms_view.view.as_id(): dms_view for dms_view in input_views}
 
         for view_id, view in views.items():
             view.properties = {}
@@ -177,9 +252,17 @@ class _DMSExporter:
         self,
         container_properties_by_id: dict[dm.ContainerId, list[DMSProperty]],
     ) -> ContainerApplyDict:
-        containers = dm.ContainerApplyList(
-            [dms_container.as_container() for dms_container in self.rules.containers or []]
-        )
+        containers = list(self.rules.containers or [])
+        if self.rules.last:
+            existing = {container.container.as_id() for container in containers}
+            modified_containers = [
+                c
+                for c in self.rules.last.containers or []
+                if c.container.as_id() in container_properties_by_id and c.container.as_id() not in existing
+            ]
+            containers.extend(modified_containers)
+
+        containers = dm.ContainerApplyList([dms_container.as_container() for dms_container in containers])
         container_to_drop = set()
         for container in containers:
             container_id = container.as_id()
@@ -233,10 +316,13 @@ class _DMSExporter:
                 }
         return ContainerApplyDict([container for container in containers if container.as_id() not in container_to_drop])
 
-    def _gather_properties(self) -> tuple[dict[dm.ContainerId, list[DMSProperty]], dict[dm.ViewId, list[DMSProperty]]]:
+    @staticmethod
+    def _gather_properties(
+        properties: Sequence[DMSProperty],
+    ) -> 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 self.rules.properties:
+        for prop in properties:
             view_id = prop.view.as_id()
             view_properties_by_id[view_id].append(prop)
 
@@ -246,6 +332,32 @@ class _DMSExporter:
 
         return container_properties_by_id, view_properties_by_id
 
+    @classmethod
+    def _update_with_properties(
+        cls,
+        selected_properties: Sequence[DMSProperty],
+        container_properties_by_id: dict[dm.ContainerId, list[DMSProperty]],
+        view_properties_by_id: dict[dm.ViewId, list[DMSProperty]] | None,
+        include_new_containers: bool = False,
+    ) -> None:
+        view_properties_by_id = view_properties_by_id or {}
+        last_container_properties_by_id, last_view_properties_by_id = cls._gather_properties(selected_properties)
+
+        for container_id, properties in last_container_properties_by_id.items():
+            # Only add the container properties that are not already present, and do not overwrite.
+            if (container_id in container_properties_by_id) or include_new_containers:
+                existing = {prop.container_property for prop in container_properties_by_id.get(container_id, [])}
+                container_properties_by_id[container_id].extend(
+                    [prop for prop in properties if prop.container_property not in existing]
+                )
+
+        if view_properties_by_id:
+            for view_id, properties in last_view_properties_by_id.items():
+                existing = {prop.view_property for prop in view_properties_by_id[view_id]}
+                view_properties_by_id[view_id].extend(
+                    [prop for prop in properties if prop.view_property not in existing]
+                )
+
     def _create_view_filter(
         self,
         view: dm.ViewApply,
@@ -291,8 +403,9 @@ class _DMSExporter:
             # HasData or not provided (this is the default)
             return HasDataFilter(inner=[ContainerEntity.from_id(id_) for id_ in ref_containers])
 
+    @classmethod
     def _create_view_property(
-        self, prop: DMSProperty, view_properties_by_id: dict[dm.ViewId, list[DMSProperty]]
+        cls, 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
@@ -336,7 +449,7 @@ class _DMSExporter:
                 edge_cls = SingleEdgeConnectionApply
 
             return edge_cls(
-                type=self._create_edge_type_from_prop(prop),
+                type=cls._create_edge_type_from_prop(prop),
                 source=source_view_id,
                 direction="outwards",
                 name=prop.name,
@@ -377,7 +490,7 @@ class _DMSExporter:
                     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),
+                    type=cls._create_edge_type_from_prop(reverse_prop or prop),
                     source=source_view_id,
                     name=prop.name,
                     description=prop.description,

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

@@ -2,13 +2,13 @@ import math
 import re
 import sys
 import warnings
-from collections.abc import Callable
 from datetime import datetime
-from typing import TYPE_CHECKING, Any, ClassVar, Literal, cast
+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_serializer, model_validator
-from pydantic_core.core_schema import SerializationInfo, ValidationInfo
+from pydantic import Field, field_serializer, field_validator, model_validator
+from pydantic.main import IncEx
+from pydantic_core.core_schema import ValidationInfo
 
 from cognite.neat.rules import issues
 from cognite.neat.rules.issues import MultiValueError
@@ -49,9 +49,9 @@ if TYPE_CHECKING:
     from cognite.neat.rules.models.information._rules import InformationRules
 
 if sys.version_info >= (3, 11):
-    from typing import Self
+    pass
 else:
-    from typing_extensions import Self
+    pass
 
 _DEFAULT_VERSION = "1"
 
@@ -264,13 +264,20 @@ class DMSView(SheetEntity):
 
     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,
             external_id=view_id.external_id,
             version=view_id.version or _DEFAULT_VERSION,
             name=self.name or None,
             description=self.description,
-            implements=[parent.as_id() for parent in self.implements or []] or None,
+            implements=implements,
             properties={},
         )
 
@@ -334,17 +341,37 @@ class DMSRules(BaseRules):
             raise MultiValueError([error for error in issue_list if isinstance(error, issues.NeatValidationError)])
         return self
 
-    @model_serializer(mode="wrap", when_used="always")
-    def dms_rules_serialization(
+    def dump(
         self,
-        handler: Callable,
-        info: SerializationInfo,
+        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 = cast(dict[str, Any], handler(self, info))
+        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
-        return _DMSRulesSerializer(info, space, version).clean(dumped)
+        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
@@ -360,19 +387,3 @@ class DMSRules(BaseRules):
         from ._converter import _DMSRulesConverter
 
         return _DMSRulesConverter(self).as_domain_rules()
-
-    def reference_self(self) -> Self:
-        new_rules = self.model_copy(deep=True)
-        for prop in new_rules.properties:
-            prop.reference = ReferenceEntity(
-                prefix=prop.view.prefix, suffix=prop.view.suffix, version=prop.view.version, property=prop.property_
-            )
-        view: DMSView
-        for view in new_rules.views:
-            view.reference = ReferenceEntity(
-                prefix=view.view.prefix, suffix=view.view.suffix, version=view.view.version
-            )
-        container: DMSContainer
-        for container in new_rules.containers or []:
-            container.reference = ReferenceEntity(prefix=container.container.prefix, suffix=container.container.suffix)
-        return new_rules

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

@@ -1,9 +1,8 @@
 from typing import Any, ClassVar, cast
 
-from pydantic_core.core_schema import SerializationInfo
-
 from cognite.neat.rules.models import DMSRules
 from cognite.neat.rules.models.dms import DMSContainer, DMSProperty, DMSView
+from cognite.neat.rules.models.entities import ReferenceEntity, ViewEntity
 
 
 class _DMSRulesSerializer:
@@ -12,7 +11,7 @@ class _DMSRulesSerializer:
     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:
+    def __init__(self, by_alias: bool, 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})"
@@ -25,14 +24,16 @@ class _DMSRulesSerializer:
         self.container_name = "containers"
         self.metadata_name = "metadata"
         self.prop_view = "view"
+        self.prop_container = "container"
         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"
+        self.reference = "Reference" if by_alias else "reference"
 
-        if info.by_alias:
+        if by_alias:
             self.properties_fields = [
                 DMSProperty.model_fields[field].alias or field for field in self.properties_fields
             ]
@@ -41,6 +42,7 @@ class _DMSRulesSerializer:
                 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_container = DMSProperty.model_fields[self.prop_container].alias or self.prop_container
             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
@@ -56,22 +58,7 @@ class _DMSRulesSerializer:
             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]:
+    def clean(self, dumped: dict[str, Any], as_reference: bool) -> 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])
@@ -83,16 +70,29 @@ class _DMSRulesSerializer:
             dumped.pop(self.container_name, None)
 
         for prop in dumped[self.prop_name]:
+            if as_reference:
+                view_entity = cast(ViewEntity, ViewEntity.load(prop[self.prop_view]))
+                prop[self.reference] = str(
+                    ReferenceEntity(
+                        prefix=view_entity.prefix,
+                        suffix=view_entity.suffix,
+                        version=view_entity.version,
+                        property=prop[self.prop_view_property],
+                    )
+                )
             for field_name in self.properties_fields:
+                if as_reference and field_name == self.prop_container:
+                    # When dumping as reference, the container should keep the default space for easy copying
+                    # over to user sheets.
+                    continue
                 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]:
+            if as_reference:
+                view[self.reference] = view[self.view_view]
             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)
@@ -101,11 +101,10 @@ class _DMSRulesSerializer:
                     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.get(self.container_name, []):
+            if as_reference:
+                container[self.reference] = container[self.container_container]
             for field_name in self.containers_fields:
                 if value := container.get(field_name):
                     container[field_name] = value.removeprefix(self.default_space)
@@ -114,13 +113,4 @@ class _DMSRulesSerializer:
                 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

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

@@ -1,5 +1,5 @@
 from collections import defaultdict
-from typing import Any
+from typing import Any, ClassVar
 
 from cognite.client import data_modeling as dm
 
@@ -18,6 +18,10 @@ class DMSPostValidation:
     """This class does all the validation of the DMS rules that have dependencies between
     components."""
 
+    # When checking for changes extension=addition, we need to check if the new view has changed.
+    # For example, changing the filter is allowed, but changing the properties is not.
+    changeable_view_attributes: ClassVar[set[str]] = {"filter"}
+
     def __init__(self, rules: DMSRules):
         self.rules = rules
         self.metadata = rules.metadata
@@ -212,6 +216,13 @@ class DMSPostValidation:
             changed_attributes, changed_properties = self._changed_attributes_and_properties(
                 view.dump(), existing_view.dump()
             )
+            existing_properties = existing_view.properties or {}
+            changed_properties = [prop for prop in changed_properties if prop in existing_properties]
+            changed_attributes = [attr for attr in changed_attributes if attr not in self.changeable_view_attributes]
+
+            if not changed_attributes and not changed_properties:
+                # Only added new properties, no problem
+                continue
             self.issue_list.append(
                 issues.dms.ChangingViewError(
                     view_id=view_id,

cognite/neat/rules/models/domain.py

@@ -9,8 +9,8 @@ from cognite.neat.rules.models.entities import ClassEntity, ParentEntityList
 
 from ._base import (
     BaseMetadata,
+    BaseRules,
     RoleTypes,
-    RuleModel,
     SheetEntity,
     SheetList,
 )
@@ -51,7 +51,7 @@ class DomainClass(SheetEntity):
     parent: ParentEntityList | None = Field(alias="Parent Class")
 
 
-class DomainRules(RuleModel):
+class DomainRules(BaseRules):
     metadata: DomainMetadata = Field(alias="Metadata")
     properties: SheetList[DomainProperty] = Field(alias="Properties")
     classes: SheetList[DomainClass] | None = Field(None, alias="Classes")
@@ -70,7 +70,3 @@ class DomainRules(RuleModel):
                 cls.model_dump(**kwargs) for cls in self.classes or []
             ] or None
         return output
-
-    def reference_self(self) -> "DomainRules":
-        """DomainRules does not have reference field, so it returns a copy of itself."""
-        return self.model_copy(deep=True)

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

@@ -3,6 +3,8 @@ from collections import defaultdict
 from typing import TYPE_CHECKING, Literal
 
 from cognite.neat.rules.models._base import (
+    ExtensionCategory,
+    SchemaCompleteness,
     SheetList,
 )
 from cognite.neat.rules.models.data_types import DataType
@@ -25,7 +27,20 @@ if TYPE_CHECKING:
 
 class _InformationRulesConverter:
     def __init__(self, information: InformationRules):
-        self.information = information
+        self.rules = information
+        self.is_addition = (
+            self.rules.metadata.schema_ is SchemaCompleteness.extended
+            and self.rules.metadata.extension is ExtensionCategory.addition
+        )
+        self.is_reshape = (
+            self.rules.metadata.schema_ is SchemaCompleteness.extended
+            and self.rules.metadata.extension is ExtensionCategory.reshape
+        )
+        if self.rules.last:
+            self.last_classes = {class_.class_: class_ for class_ in self.rules.last.classes}
+        else:
+            self.last_classes = {}
+        self._created_classes_from: dict[ClassEntity, ClassEntity] = {}
 
     def as_domain_rules(self) -> DomainRules:
         raise NotImplementedError("DomainRules not implemented yet")
@@ -38,13 +53,13 @@ class _InformationRulesConverter:
             DMSView,
         )
 
-        info_metadata = self.information.metadata
+        info_metadata = self.rules.metadata
         default_version = info_metadata.version
         default_space = self._to_space(info_metadata.prefix)
         metadata = self._convert_metadata_to_dms(info_metadata)
 
         properties_by_class: dict[str, list[DMSProperty]] = defaultdict(list)
-        for prop in self.information.properties:
+        for prop in self.rules.properties:
             properties_by_class[prop.class_.versioned_id].append(
                 self._as_dms_property(prop, default_space, default_version)
             )
@@ -58,11 +73,11 @@ class _InformationRulesConverter:
                 reference=cls_.reference,
                 implements=self._get_view_implements(cls_, info_metadata),
             )
-            for cls_ in self.information.classes
+            for cls_ in self.rules.classes
         ]
 
         classes_without_properties: set[str] = set()
-        for class_ in self.information.classes:
+        for class_ in self.rules.classes:
             properties: list[DMSProperty] = properties_by_class.get(class_.class_.versioned_id, [])
             if not properties or all(
                 isinstance(prop.value_type, ViewPropertyEntity) and prop.connection != "direct" for prop in properties
@@ -70,7 +85,16 @@ class _InformationRulesConverter:
                 classes_without_properties.add(class_.class_.versioned_id)
 
         containers: list[DMSContainer] = []
-        for class_ in self.information.classes:
+        classes = list(self.rules.classes)
+        for new_class_entity, created_from in self._created_classes_from.items():
+            # We create new classes in case metadata is set to addition or reshape
+            # and the class was present in the last schema to avoid creating
+            # a changed container and instead create a new one.
+            created_class = self.last_classes[created_from].copy(deep=True)
+            created_class.class_ = new_class_entity
+            classes.append(created_class)
+
+        for class_ in classes:
             if class_.class_.versioned_id in classes_without_properties:
                 continue
             containers.append(
@@ -95,8 +119,8 @@ class _InformationRulesConverter:
             ),
             views=SheetList[DMSView](data=views),
             containers=SheetList[DMSContainer](data=containers),
-            last=self.information.last.as_dms_architect_rules() if self.information.last else None,
-            reference=self.information.reference.as_dms_architect_rules() if self.information.reference else None,
+            last=self.rules.last.as_dms_architect_rules() if self.rules.last else None,
+            reference=self.rules.reference.as_dms_architect_rules() if self.rules.reference else None,
         )
 
     @classmethod
@@ -119,8 +143,7 @@ class _InformationRulesConverter:
             updated=metadata.updated,
         )
 
-    @classmethod
-    def _as_dms_property(cls, prop: InformationProperty, default_space: str, default_version: str) -> "DMSProperty":
+    def _as_dms_property(self, prop: InformationProperty, default_space: str, default_version: str) -> "DMSProperty":
         """This creates the first"""
 
         from cognite.neat.rules.models.dms._rules import DMSProperty
@@ -148,9 +171,9 @@ class _InformationRulesConverter:
             nullable = None
         elif relation == "direct":
             nullable = True
-            container, container_property = cls._get_container(prop, default_space)
+            container, container_property = self._get_container(prop, default_space)
         else:
-            container, container_property = cls._get_container(prop, default_space)
+            container, container_property = self._get_container(prop, default_space)
 
         return DMSProperty(
             class_=prop.class_,
@@ -179,13 +202,20 @@ class _InformationRulesConverter:
             prefix = f"{prefix[:-1]}1"
         return prefix
 
-    @classmethod
-    def _get_container(cls, prop: InformationProperty, default_space: str) -> tuple[ContainerEntity, str]:
+    def _get_container(self, prop: InformationProperty, default_space: str) -> tuple[ContainerEntity, str]:
         if isinstance(prop.reference, ReferenceEntity):
             return (
                 prop.reference.as_container_entity(default_space),
                 prop.reference.property_ or prop.property_,
             )
+        elif (self.is_addition or self.is_reshape) and prop.class_ in self.last_classes:
+            # We need to create a new container for the property, as we cannot change
+            # the existing container in the last schema
+            class_entity = prop.class_.copy()
+            class_entity.suffix = self._bump_suffix(class_entity.suffix)
+            if class_entity not in self._created_classes_from:
+                self._created_classes_from[class_entity] = prop.class_
+            return class_entity.as_container_entity(default_space), prop.property_
         else:
             return prop.class_.as_container_entity(default_space), prop.property_
 
@@ -201,3 +231,12 @@ class _InformationRulesConverter:
 
         implements.extend([parent.as_view_entity(metadata.prefix, metadata.version) for parent in cls_.parent or []])
         return implements
+
+    @staticmethod
+    def _bump_suffix(suffix: str) -> str:
+        suffix_number = re.search(r"\d+$", suffix)
+
+        if suffix_number:
+            return suffix[: suffix_number.start()] + str(int(suffix_number.group()) + 1)
+        else:
+            return f"{suffix}2"

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

@@ -1,11 +1,10 @@
 import math
 import sys
-from collections.abc import Callable
 from datetime import datetime
-from typing import TYPE_CHECKING, Any, ClassVar, cast
+from typing import TYPE_CHECKING, Any, ClassVar, Literal, cast
 
-from pydantic import Field, field_serializer, field_validator, model_serializer, model_validator
-from pydantic_core.core_schema import SerializationInfo
+from pydantic import Field, field_serializer, field_validator, model_validator
+from pydantic.main import IncEx
 from rdflib import Namespace
 
 from cognite.neat.constants import PREFIXES
@@ -13,12 +12,12 @@ from cognite.neat.rules import exceptions, issues
 from cognite.neat.rules.issues.base import MultiValueError
 from cognite.neat.rules.models._base import (
     BaseMetadata,
+    BaseRules,
     DataModelType,
     ExtensionCategory,
     ExtensionCategoryType,
     MatchType,
     RoleTypes,
-    RuleModel,
     SchemaCompleteness,
     SheetEntity,
     SheetList,
@@ -51,7 +50,6 @@ from cognite.neat.rules.models.entities import (
     Undefined,
     UnknownEntity,
     URLEntity,
-    _UndefinedType,
 )
 
 if TYPE_CHECKING:
@@ -259,7 +257,7 @@ class InformationProperty(SheetEntity):
         return self.max_count != 1
 
 
-class InformationRules(RuleModel):
+class InformationRules(BaseRules):
     metadata: InformationMetadata = Field(alias="Metadata")
     properties: SheetList[InformationProperty] = Field(alias="Properties")
     classes: SheetList[InformationClass] = Field(alias="Classes")
@@ -304,14 +302,37 @@ class InformationRules(RuleModel):
             raise MultiValueError([error for error in issue_list if isinstance(error, issues.NeatValidationError)])
         return self
 
-    @model_serializer(mode="wrap", when_used="always")
-    def information_rules_serializer(self, handler: Callable, info: SerializationInfo) -> dict[str, Any]:
+    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 = cast(dict[str, Any], handler(self, info))
+        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
-
-        return _InformationRulesSerializer(info, prefix).clean(dumped)
+        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_domain_rules(self) -> DomainRules:
         from ._converter import _InformationRulesConverter
@@ -322,26 +343,3 @@ class InformationRules(RuleModel):
         from ._converter import _InformationRulesConverter
 
         return _InformationRulesConverter(self).as_dms_architect_rules()
-
-    def reference_self(self) -> "InformationRules":
-        new_self = self.model_copy(deep=True)
-        for prop in new_self.properties:
-            prop.reference = ReferenceEntity(
-                prefix=(
-                    prop.class_.prefix if not isinstance(prop.class_.prefix, _UndefinedType) else self.metadata.prefix
-                ),
-                suffix=prop.class_.suffix,
-                version=prop.class_.version,
-                property=prop.property_,
-            )
-
-        for cls_ in new_self.classes:
-            cls_.reference = ReferenceEntity(
-                prefix=(
-                    cls_.class_.prefix if not isinstance(cls_.class_.prefix, _UndefinedType) else self.metadata.prefix
-                ),
-                suffix=cls_.class_.suffix,
-                version=cls_.class_.version,
-            )
-
-        return new_self

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

@@ -1,8 +1,7 @@
-from typing import Any, ClassVar, cast
-
-from pydantic_core.core_schema import SerializationInfo
+from typing import Any, ClassVar
 
 from cognite.neat.rules.models import InformationRules
+from cognite.neat.rules.models.entities import ClassEntity, ReferenceEntity
 from cognite.neat.rules.models.information import InformationClass, InformationProperty
 
 
@@ -11,7 +10,7 @@ class _InformationRulesSerializer:
     PROPERTIES_FIELDS: ClassVar[list[str]] = ["class_", "value_type"]
     CLASSES_FIELDS: ClassVar[list[str]] = ["class_"]
 
-    def __init__(self, info: SerializationInfo, default_prefix: str) -> None:
+    def __init__(self, by_alias: bool, default_prefix: str) -> None:
         self.default_prefix = f"{default_prefix}:"
 
         self.properties_fields = self.PROPERTIES_FIELDS
@@ -25,7 +24,8 @@ class _InformationRulesSerializer:
         self.prop_property = "property_"
         self.prop_class = "class_"
 
-        if info.by_alias:
+        self.reference = "Reference" if by_alias else "reference"
+        if by_alias:
             self.properties_fields = [
                 InformationProperty.model_fields[field].alias or field for field in self.properties_fields
             ]
@@ -38,20 +38,7 @@ class _InformationRulesSerializer:
             self.prop_property = InformationProperty.model_fields[self.prop_property].alias or self.prop_property
             self.prop_class = InformationProperty.model_fields[self.prop_class].alias or self.prop_class
 
-        if isinstance(info.exclude, dict):
-            # Just for happy mypy
-            exclude = cast(dict, info.exclude)
-            self.metadata_exclude = exclude.get("metadata", set()) or set()
-            self.exclude_classes = exclude.get("classes", {}).get("__all__", set()) or set()
-            self.exclude_properties = exclude.get("properties", {}).get("__all__", 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_classes = set()
-            self.metadata_exclude = set()
-
-    def clean(self, dumped: dict[str, Any]) -> dict[str, Any]:
+    def clean(self, dumped: dict[str, Any], as_reference: bool) -> 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_class], p[self.prop_property])
@@ -59,15 +46,21 @@ class _InformationRulesSerializer:
         dumped[self.class_name] = sorted(dumped[self.class_name]["data"], key=lambda v: v[self.prop_class])
 
         for prop in dumped[self.prop_name]:
+            if as_reference:
+                class_entity = ClassEntity.load(prop[self.prop_class])
+                prop[self.reference] = str(
+                    ReferenceEntity(
+                        prefix=str(class_entity.prefix), suffix=class_entity.suffix, property=prop[self.prop_property]
+                    )
+                )
+
             for field_name in self.properties_fields:
                 if value := prop.get(field_name):
                     prop[field_name] = value.removeprefix(self.default_prefix)
 
-            if self.exclude_properties:
-                for field in self.exclude_properties:
-                    prop.pop(field, None)
-
         for class_ in dumped[self.class_name]:
+            if as_reference:
+                class_[self.reference] = class_[self.prop_class]
             for field_name in self.classes_fields:
                 if value := class_.get(field_name):
                     class_[field_name] = value.removeprefix(self.default_prefix)
@@ -77,9 +70,4 @@ class _InformationRulesSerializer:
                     parent.strip().removeprefix(self.default_prefix) for parent in value.split(",")
                 )
 
-        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

cognite/neat/workflows/steps/lib/current/rules_importer.py

@@ -222,9 +222,9 @@ class DMSToRules(Step):
                 f"or 'my_space:my_data_model', failed to parse space from {datamodel_id_str}"
             )
             return FlowMessage(error_text=error_text, step_execution_status=StepExecutionStatus.ABORT_AND_FAIL)
-        ref_datamodel_str = self.configs.get("Reference data model id")
+        ref_datamodel_str = self.configs.get("Reference data model id", "")
         ref_model_id: DataModelId | None = None
-        if ref_datamodel_str is not None:
+        if ref_datamodel_str:
             ref_model = DataModelEntity.load(ref_datamodel_str)
             if isinstance(ref_model, DMSUnknownEntity):
                 error_text = (

{cognite_neat-0.77.4.dist-info → cognite_neat-0.77.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cognite-neat
-Version: 0.77.4
+Version: 0.77.5
 Summary: Knowledge graph transformation
 Home-page: https://cognite-neat.readthedocs-hosted.com/
 License: Apache-2.0

{cognite_neat-0.77.4.dist-info → cognite_neat-0.77.5.dist-info}/RECORD

@@ -1,5 +1,5 @@
 cognite/neat/__init__.py,sha256=v-rRiDOgZ3sQSMQKq0vgUQZvpeOkoHFXissAx6Ktg84,61
-cognite/neat/_version.py,sha256=UI_UQyLNbZGZ2bCbRSUVSxQLP1GDhHBmVI29h7BNFAE,23
+cognite/neat/_version.py,sha256=qY2z4RU9yzLy_Bl8YNKQzEiLp4FK9g2uX6Bc6Mk1LO8,23
 cognite/neat/app/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite/neat/app/api/asgi/metrics.py,sha256=nxFy7L5cChTI0a-zkCiJ59Aq8yLuIJp5c9Dg0wRXtV0,152
 cognite/neat/app/api/configuration.py,sha256=2U5M6M252swvQPQyooA1EBzFUZNtcTmuSaywfJDgckM,4232
@@ -166,9 +166,9 @@ cognite/neat/rules/exporters/__init__.py,sha256=Gn3CjkVKHJF9Po1ZPH4wAJ-sRW9up7b2
 cognite/neat/rules/exporters/_base.py,sha256=m63iw8xjlZbZAxGL8mn7pjGf1pW3rVv8C20_RSiu4t0,1511
 cognite/neat/rules/exporters/_models.py,sha256=vRd0P_YsrZ1eaAGGHfdTeFunaqHdaa0ZtnWiVZBR1nc,1976
 cognite/neat/rules/exporters/_rules2dms.py,sha256=US2IO4YTJSF_CDzau1dTpXyeHntJWVSPkMCQoUoKeC0,13688
-cognite/neat/rules/exporters/_rules2excel.py,sha256=GvvjZB2Ayue08s5b6JPB1xGltp-MA7QmNk9rk1a54LE,14244
+cognite/neat/rules/exporters/_rules2excel.py,sha256=HvUdXYHxfLMijYWdTnfqCsw3Izf8S-XDSve-2ZbqF8Y,14248
 cognite/neat/rules/exporters/_rules2ontology.py,sha256=NWS3cn2927LQqW_PdQ-92OLIlmIKGNk7xh5yOMAyj94,20120
-cognite/neat/rules/exporters/_rules2yaml.py,sha256=sOSdnTJ5mXuyAJECdNnNsX6oLvgETptkpgPUQbK0n2w,3026
+cognite/neat/rules/exporters/_rules2yaml.py,sha256=GA8eUYRxUfIU6IMvlyGO5JidkOD5eUKSbH3qAiFiaCg,3026
 cognite/neat/rules/exporters/_validation.py,sha256=OlKIyf4nhSDehJwFHDQ8Zdf6HpNfW7dSe2s67eywHu4,4078
 cognite/neat/rules/importers/__init__.py,sha256=zqNbGpvdVhYkLjWx1i9dJ3FXzYGtuQyTydUYsj-BndQ,408
 cognite/neat/rules/importers/_base.py,sha256=GUiJrYwJ25thI71iS9hCeP_iSZ0Vv8ou3z6MfD07FAk,4274
@@ -194,7 +194,7 @@ cognite/neat/rules/issues/importing.py,sha256=l0VKmOWN-qyvOMukNAVJZrN2WGD2YcGXeC
 cognite/neat/rules/issues/spreadsheet.py,sha256=1NZQ3a_zCtErAoMKzEt5UMJsukaysoOVmW7WUF6JK1s,15825
 cognite/neat/rules/issues/spreadsheet_file.py,sha256=YCp0Pk_TsiqYuOPdWpjUpre-zvi2c5_MvrC_dxw10YY,4964
 cognite/neat/rules/models/__init__.py,sha256=aqhQUidHYgOk5_iqdi6s72s2g8qyMRFXShYzh-ctNpw,782
-cognite/neat/rules/models/_base.py,sha256=D9MQElY9baxmf-BJpuLYl3R3h_wIOdrBTufMThRx_Jo,11126
+cognite/neat/rules/models/_base.py,sha256=oQ8f0bvdythJ2m54K1jl2OXEuEZ4N8JqHDXyhCPBVbY,11010
 cognite/neat/rules/models/_rdfpath.py,sha256=RoHnfWufjnDtwJh7UUzWKoJz8luvX7Gb5SDQORfkQTE,11030
 cognite/neat/rules/models/_types/__init__.py,sha256=l1tGxzE7ezNHIL72AoEvNHN2IFuitxOLxiHJG__s6t4,305
 cognite/neat/rules/models/_types/_base.py,sha256=2GhLUE1ukV8X8SGL_JDxpbWGZyAvOnSqAE6JmDh5wbI,929
@@ -202,19 +202,19 @@ cognite/neat/rules/models/_types/_field.py,sha256=74WfCSVbTubpK4n4VsysQqCch6VI8I
 cognite/neat/rules/models/data_types.py,sha256=lanwkhwG8iHKfjYfia4v2SBTJrMeXOsqaVkVEP2QMXs,6078
 cognite/neat/rules/models/dms/__init__.py,sha256=Wzyqzz2ZIjpUbDg04CMuuIAw-f2A02DayNeqO9R-2Hw,491
 cognite/neat/rules/models/dms/_converter.py,sha256=QaJT0z0Yo4gkG9tHPZkU8idF8PK7c-tDahbyIT-WJQU,5959
-cognite/neat/rules/models/dms/_exporter.py,sha256=u1E53704ly1cH6-tM3EKT7Vksq1JFlrbTfQI33qR1wc,18984
-cognite/neat/rules/models/dms/_rules.py,sha256=WyaUsIWM0a-SytRZ-5n2f_AFXwyV_brzzHqmq7O_n0I,15690
+cognite/neat/rules/models/dms/_exporter.py,sha256=pWUt3z8qk71eZ-YO8NdKbVOaWaIKl8bSdEuRU591gU4,24486
+cognite/neat/rules/models/dms/_rules.py,sha256=iqoPilY3tov3GvJ9N3K3go6xy9kiiMt9vEZ2hQK5_V8,16070
 cognite/neat/rules/models/dms/_rules_input.py,sha256=apDDTQll9UAyYL5gS2vDxHsujWrGBilTp7lK2kzJWO8,13467
 cognite/neat/rules/models/dms/_schema.py,sha256=A4z8CINmLQgWzHoScxejRPMRo40ngKlyp1gOdPto8yU,43808
-cognite/neat/rules/models/dms/_serializer.py,sha256=JeaTIOERpYY1Demihqg0OHJ1EvBrPMBIF1EPjeOgGDA,6669
-cognite/neat/rules/models/dms/_validation.py,sha256=k2UcLlo_WU6iO-p_wjHToiLExVc22KGLP3lBuW8I_EA,12963
-cognite/neat/rules/models/domain.py,sha256=13OhG-XavE5ipU2ICaYaUhz60volkuVfbJrsp0PhaUU,2993
+cognite/neat/rules/models/dms/_serializer.py,sha256=iqp2zyyf8jEcU-R3PERuN8nu248xIqyxiWj4owAn92g,6406
+cognite/neat/rules/models/dms/_validation.py,sha256=TUmBxfSB42lsgIKVIDPPbaTaJ8TKi-gTbayqgPAmnfs,13656
+cognite/neat/rules/models/domain.py,sha256=tkKcHvDXnZ5IkOr1wHiuNBtE1h8OCFmf6GZSqzHzxjI,2814
 cognite/neat/rules/models/entities.py,sha256=iBG84Jr1qQ7PvkMJUJzJ1oWApeONb1IACixdJSztUhk,16395
 cognite/neat/rules/models/information/__init__.py,sha256=HR6g8xgyU53U7Ck8pPdbT70817Q4NC1r1pCRq5SA8iw,291
-cognite/neat/rules/models/information/_converter.py,sha256=TxVYzR41Rhejf7ep73oqMRNFPOdxAbamoEWnvsnXbng,8040
-cognite/neat/rules/models/information/_rules.py,sha256=JuP0RAmTju5WwDJJAoTI-gogRRBBa8eCf-SE2k8FGlQ,13365
+cognite/neat/rules/models/information/_converter.py,sha256=qJl95-gPz6MwKLZpHyY_CIqf-ebZalHWZyYnsqr_FWc,9960
+cognite/neat/rules/models/information/_rules.py,sha256=tdCjvAtqnFzEo2zcx-BZHmvjSs28gVun2wz8UaT-AOA,13268
 cognite/neat/rules/models/information/_rules_input.py,sha256=IZp_Wnrac0nVaHKth1YttWQOs-kULGKLMtngNQFY40A,10147
-cognite/neat/rules/models/information/_serializer.py,sha256=M4vOr0tgrD-n_pir-VDHwclgAjbBOu2HKsxt_PTGO7g,3989
+cognite/neat/rules/models/information/_serializer.py,sha256=yti9I_xJruxrib66YIBInhze___Io-oPTQH6uWDumPE,3503
 cognite/neat/rules/models/information/_validation.py,sha256=Is2GzL2lZU3A5zPu3NjvlXfmIU2_Y10C5Nxi5Denz4g,7528
 cognite/neat/rules/models/wrapped_entities.py,sha256=ThhjnNNrpgz0HeORIQ8Q894trxP73P7T_TuZj6qH2CU,7157
 cognite/neat/utils/__init__.py,sha256=l5Nyqhqo25bcQXCOb_lk01cr-UXsG8cczz_y_I0u6bg,68
@@ -258,7 +258,7 @@ cognite/neat/workflows/steps/lib/current/graph_extractor.py,sha256=vW9UpJScx5dFV
 cognite/neat/workflows/steps/lib/current/graph_loader.py,sha256=HfGg1HRZhbV58TFu89FTjKeUxGsbCYLeFJIQFDN_pQM,2341
 cognite/neat/workflows/steps/lib/current/graph_store.py,sha256=r7VTxdaz8jJQU7FJbnRDMxvEYbSAZFNMABhPyfNwiFk,6295
 cognite/neat/workflows/steps/lib/current/rules_exporter.py,sha256=BWscuNvTu_u6QQSxkVz4X4A1wAHW2Kfku8lhgrIK51M,23886
-cognite/neat/workflows/steps/lib/current/rules_importer.py,sha256=BmbLsly6ZRhMJ48RAoVXVK7H3JTKRtR40SD9-qcQdi4,11459
+cognite/neat/workflows/steps/lib/current/rules_importer.py,sha256=oGIBh9iFYP3w_K0kLpM-OKTw70R1Mw_opD62MGkCJlk,11451
 cognite/neat/workflows/steps/lib/current/rules_validator.py,sha256=LwF9lXlnuPOxDSsOMMTHBi2BHc5rk08IF5zahS9yQuw,4844
 cognite/neat/workflows/steps/lib/io/__init__.py,sha256=k7IPbIq3ey19oRc5sA_15F99-O6dxzqbm1LihGRRo5A,32
 cognite/neat/workflows/steps/lib/io/io_steps.py,sha256=QAGypoi1vP32BRiIgBZ0B4qsbFMcwhzpRiVUUnWysLA,16874
@@ -275,8 +275,8 @@ cognite/neat/workflows/steps_registry.py,sha256=fkTX14ZA7_gkUYfWIlx7A1XbCidvqR23
 cognite/neat/workflows/tasks.py,sha256=dqlJwKAb0jlkl7abbY8RRz3m7MT4SK8-7cntMWkOYjw,788
 cognite/neat/workflows/triggers.py,sha256=_BLNplzoz0iic367u1mhHMHiUrCwP-SLK6_CZzfODX0,7071
 cognite/neat/workflows/utils.py,sha256=gKdy3RLG7ctRhbCRwaDIWpL9Mi98zm56-d4jfHDqP1E,453
-cognite_neat-0.77.4.dist-info/LICENSE,sha256=W8VmvFia4WHa3Gqxq1Ygrq85McUNqIGDVgtdvzT-XqA,11351
-cognite_neat-0.77.4.dist-info/METADATA,sha256=WCnAyTXFO9SjdNMcEdoyjwic7YAm8nsAg0kTXDfjsyU,9316
-cognite_neat-0.77.4.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-cognite_neat-0.77.4.dist-info/entry_points.txt,sha256=61FPqiWb25vbqB0KI7znG8nsg_ibLHBvTjYnkPvNFso,50
-cognite_neat-0.77.4.dist-info/RECORD,,
+cognite_neat-0.77.5.dist-info/LICENSE,sha256=W8VmvFia4WHa3Gqxq1Ygrq85McUNqIGDVgtdvzT-XqA,11351
+cognite_neat-0.77.5.dist-info/METADATA,sha256=8A4oJpmya7kNRyOtbaNpOp-4CsSiyc8TLv30rckLsq4,9316
+cognite_neat-0.77.5.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+cognite_neat-0.77.5.dist-info/entry_points.txt,sha256=61FPqiWb25vbqB0KI7znG8nsg_ibLHBvTjYnkPvNFso,50
+cognite_neat-0.77.5.dist-info/RECORD,,