cognite-neat 0.125.1__py3-none-any.whl → 0.126.1__py3-none-any.whl

cognite/neat/_data_model/deployer/_differ.py

@@ -0,0 +1,113 @@
+from abc import ABC, abstractmethod
+from typing import Generic
+
+from cognite.neat._utils.useful_types import T_Item
+
+from .data_classes import (
+    AddedField,
+    ChangedField,
+    FieldChange,
+    FieldChanges,
+    RemovedField,
+    SeverityType,
+)
+
+
+class ItemDiffer(Generic[T_Item], ABC):
+    """A generic class for comparing two items of the same type and reporting the differences."""
+
+    @abstractmethod
+    def diff(self, current: T_Item, new: T_Item) -> list[FieldChange]:
+        """Compare two items and return a list of changes.
+
+        Args:
+            current: The resource as it is in CDF.
+            new: The resource as it is desired to be.
+
+        Returns:
+            A list of changes between the two resources.
+        """
+        raise NotImplementedError()
+
+    @classmethod
+    def _diff_name_description(cls, current: T_Item, new: T_Item) -> list[FieldChange]:
+        changes: list[FieldChange] = []
+        if hasattr(current, "name") and hasattr(new, "name"):
+            if current.name != new.name:
+                changes.append(
+                    ChangedField(
+                        item_severity=SeverityType.SAFE,
+                        field_path="name",
+                        current_value=current.name,
+                        new_value=new.name,
+                    )
+                )
+        if hasattr(current, "description") and hasattr(new, "description"):
+            if current.description != new.description:
+                changes.append(
+                    ChangedField(
+                        item_severity=SeverityType.SAFE,
+                        field_path="description",
+                        current_value=current.description,
+                        new_value=new.description,
+                    )
+                )
+        return changes
+
+
+def field_differences(
+    parent_path: str,
+    current: dict[str, T_Item] | None,
+    new: dict[str, T_Item] | None,
+    add_severity: SeverityType,
+    remove_severity: SeverityType,
+    differ: ItemDiffer[T_Item],
+) -> list[FieldChange]:
+    """Diff two containers of items.
+
+    A container is for example the properties, constraints, or indexes of a container,
+    properties of a space, views of a data model, etc.
+
+    Args:
+        parent_path: The JSON path to the container being compared.
+        current: The items as they are in CDF.
+        new: The items as they are desired to be.
+        add_severity: The severity to assign to added items.
+        remove_severity: The severity to assign to removed items.
+        differ: The differ to use for comparing individual items.
+
+    """
+    changes: list[FieldChange] = []
+    current_map = current or {}
+    new_map = new or {}
+    current_keys = set(current_map.keys())
+    new_keys = set(new_map.keys())
+
+    for key in sorted(new_keys - current_keys):
+        item_path = f"{parent_path}.{key}"
+        changes.append(
+            AddedField(
+                item_severity=add_severity,
+                field_path=item_path,
+                new_value=new_map[key],
+            )
+        )
+
+    for key in sorted(current_keys - new_keys):
+        changes.append(
+            RemovedField(
+                item_severity=remove_severity,
+                field_path=f"{parent_path}.{key}",
+                current_value=current_map[key],
+            )
+        )
+
+    for key in sorted(current_keys & new_keys):
+        item_path = f"{parent_path}.{key}"
+        cdf_item = current_map[key]
+        desired_item = new_map[key]
+        diffs = differ.diff(cdf_item, desired_item)
+        if diffs:
+            changes.append(FieldChanges(field_path=item_path, changes=diffs))
+
+    return changes

cognite/neat/_data_model/deployer/_differ_container.py

@@ -0,0 +1,354 @@
+from cognite.neat._data_model.models.dms import (
+    BtreeIndex,
+    ConstraintDefinition,
+    ContainerPropertyDefinition,
+    ContainerRequest,
+    EnumProperty,
+    EnumValue,
+    FloatProperty,
+    IndexDefinition,
+    ListablePropertyTypeDefinition,
+    PropertyTypeDefinition,
+    RequiresConstraintDefinition,
+    TextProperty,
+    UniquenessConstraintDefinition,
+)
+from cognite.neat._data_model.models.dms._data_types import Unit
+
+from ._differ import ItemDiffer, field_differences
+from .data_classes import (
+    AddedField,
+    ChangedField,
+    FieldChange,
+    FieldChanges,
+    RemovedField,
+    SeverityType,
+)
+
+
+class ContainerDiffer(ItemDiffer[ContainerRequest]):
+    def diff(self, current: ContainerRequest, new: ContainerRequest) -> list[FieldChange]:
+        changes = self._diff_name_description(current, new)
+
+        if current.used_for != new.used_for:
+            changes.append(
+                ChangedField(
+                    item_severity=SeverityType.BREAKING,
+                    field_path="usedFor",
+                    current_value=current.used_for,
+                    new_value=new.used_for,
+                )
+            )
+        changes.extend(
+            field_differences(
+                "properties",
+                current.properties,
+                new.properties,
+                add_severity=SeverityType.SAFE,
+                remove_severity=SeverityType.BREAKING,
+                differ=ContainerPropertyDiffer(),
+            )
+        )
+        changes.extend(
+            # MyPy fails to understand that ConstraintDefinition and Constraint are compatible here
+            field_differences(  # type: ignore[misc]
+                "constraints",
+                current.constraints,
+                new.constraints,
+                add_severity=SeverityType.SAFE,
+                remove_severity=SeverityType.WARNING,
+                differ=ConstraintDiffer(),
+            )
+        )
+        changes.extend(
+            # MyPy fails to understand that IndexDefinition and Index are compatible here
+            field_differences(  # type: ignore[misc]
+                "indexes",
+                current.indexes,
+                new.indexes,
+                add_severity=SeverityType.SAFE,
+                remove_severity=SeverityType.WARNING,
+                differ=IndexDiffer(),
+            )
+        )
+
+        return changes
+
+
+class ContainerPropertyDiffer(ItemDiffer[ContainerPropertyDefinition]):
+    def diff(self, current: ContainerPropertyDefinition, new: ContainerPropertyDefinition) -> list[FieldChange]:
+        changes = self._diff_name_description(current, new)
+        diffs = DataTypeDiffer().diff(current.type, new.type)
+        if diffs:
+            changes.append(FieldChanges(field_path="type", changes=diffs))
+
+        if current.immutable != new.immutable:
+            changes.append(
+                ChangedField(
+                    item_severity=SeverityType.BREAKING,
+                    field_path="immutable",
+                    current_value=current.immutable,
+                    new_value=new.immutable,
+                )
+            )
+
+        if current.nullable != new.nullable:
+            changes.append(
+                ChangedField(
+                    item_severity=SeverityType.BREAKING,
+                    field_path="nullable",
+                    current_value=current.nullable,
+                    new_value=new.nullable,
+                )
+            )
+        if current.auto_increment != new.auto_increment:
+            changes.append(
+                ChangedField(
+                    item_severity=SeverityType.BREAKING,
+                    field_path="autoIncrement",
+                    current_value=current.auto_increment,
+                    new_value=new.auto_increment,
+                )
+            )
+
+        if current.default_value != new.default_value:
+            changes.append(
+                ChangedField(
+                    item_severity=SeverityType.BREAKING,
+                    field_path="defaultValue",
+                    current_value=str(current.default_value),
+                    new_value=str(new.default_value),
+                )
+            )
+        return changes
+
+
+class ConstraintDiffer(ItemDiffer[ConstraintDefinition]):
+    def diff(self, current: ConstraintDefinition, new: ConstraintDefinition) -> list[FieldChange]:
+        changes: list[FieldChange] = []
+        if current.constraint_type != new.constraint_type:
+            changes.append(
+                ChangedField(
+                    item_severity=SeverityType.WARNING,
+                    field_path="constraintType",
+                    current_value=current.constraint_type,
+                    new_value=new.constraint_type,
+                )
+            )
+        if (
+            isinstance(current, RequiresConstraintDefinition)
+            and isinstance(new, RequiresConstraintDefinition)
+            and current.require != new.require
+        ):
+            changes.append(
+                ChangedField(
+                    item_severity=SeverityType.WARNING,
+                    field_path="require",
+                    current_value=str(current.require),
+                    new_value=str(new.require),
+                )
+            )
+        elif isinstance(current, UniquenessConstraintDefinition) and isinstance(new, UniquenessConstraintDefinition):
+            # The order of the properties matter.
+            if current.properties != new.properties:
+                changes.append(
+                    ChangedField(
+                        item_severity=SeverityType.WARNING,
+                        field_path="properties",
+                        current_value=str(current.properties),
+                        new_value=str(new.properties),
+                    )
+                )
+            if current.by_space != new.by_space:
+                changes.append(
+                    ChangedField(
+                        item_severity=SeverityType.WARNING,
+                        field_path="bySpace",
+                        current_value=current.by_space,
+                        new_value=new.by_space,
+                    )
+                )
+            return changes
+        return changes
+
+
+class IndexDiffer(ItemDiffer[IndexDefinition]):
+    def diff(self, current: IndexDefinition, new: IndexDefinition) -> list[FieldChange]:
+        changes: list[FieldChange] = []
+        if current.index_type != new.index_type:
+            changes.append(
+                ChangedField(
+                    item_severity=SeverityType.WARNING,
+                    field_path="indexType",
+                    current_value=current.index_type,
+                    new_value=new.index_type,
+                )
+            )
+        else:
+            if current.properties != new.properties:
+                changes.append(
+                    ChangedField(
+                        item_severity=SeverityType.WARNING,
+                        field_path="properties",
+                        current_value=str(current.properties),
+                        new_value=str(new.properties),
+                    )
+                )
+        if isinstance(current, BtreeIndex) and isinstance(new, BtreeIndex):
+            if current.cursorable != new.cursorable:
+                changes.append(
+                    ChangedField(
+                        item_severity=SeverityType.WARNING,
+                        field_path="cursorable",
+                        current_value=current.cursorable,
+                        new_value=new.cursorable,
+                    )
+                )
+            if current.by_space != new.by_space:
+                changes.append(
+                    ChangedField(
+                        item_severity=SeverityType.WARNING,
+                        field_path="bySpace",
+                        current_value=current.by_space,
+                        new_value=new.by_space,
+                    )
+                )
+        return changes
+
+
+class DataTypeDiffer(ItemDiffer[PropertyTypeDefinition]):
+    def diff(self, current: PropertyTypeDefinition, new: PropertyTypeDefinition) -> list[FieldChange]:
+        changes: list[FieldChange] = []
+        if current.type != new.type:
+            changes.append(
+                ChangedField(
+                    item_severity=SeverityType.BREAKING,
+                    field_path="type",
+                    current_value=current.type,
+                    new_value=new.type,
+                )
+            )
+        if isinstance(current, ListablePropertyTypeDefinition) and isinstance(new, ListablePropertyTypeDefinition):
+            changes.extend(self._check_listable_property(current, new))
+
+        if isinstance(current, TextProperty) and isinstance(new, TextProperty):
+            changes.extend(self._check_text_property(current, new))
+
+        if isinstance(current, FloatProperty) and isinstance(new, FloatProperty):
+            changes.extend(self._check_float_unit(current.unit, new.unit))
+
+        if isinstance(current, EnumProperty) and isinstance(new, EnumProperty):
+            changes.extend(self._check_enum_property(current, new))
+
+        return changes
+
+    def _check_listable_property(
+        self, current: ListablePropertyTypeDefinition, new: ListablePropertyTypeDefinition
+    ) -> list[FieldChange]:
+        changes: list[FieldChange] = []
+        if current.list != new.list:
+            changes.append(
+                ChangedField(
+                    item_severity=SeverityType.BREAKING,
+                    field_path="list",
+                    current_value=current.list,
+                    new_value=new.list,
+                )
+            )
+        if current.max_list_size != new.max_list_size:
+            changes.append(
+                ChangedField(
+                    item_severity=SeverityType.BREAKING
+                    if new.max_list_size is not None
+                    and current.max_list_size is not None
+                    and new.max_list_size < current.max_list_size
+                    else SeverityType.WARNING,
+                    field_path="maxListSize",
+                    current_value=current.max_list_size,
+                    new_value=new.max_list_size,
+                )
+            )
+        return changes
+
+    def _check_float_unit(self, current: Unit | None, new: Unit | None) -> list[FieldChange]:
+        if current is not None and new is None:
+            return [RemovedField(field_path="unit", item_severity=SeverityType.WARNING, current_value=current)]
+        elif current is None and new is not None:
+            return [AddedField(field_path="unit", item_severity=SeverityType.WARNING, new_value=new)]
+        elif current is not None and new is not None:
+            changes: list[FieldChange] = []
+            if current.external_id != new.external_id:
+                changes.append(
+                    ChangedField(
+                        item_severity=SeverityType.WARNING,
+                        field_path="externalId",
+                        current_value=current.external_id,
+                        new_value=new.external_id,
+                    )
+                )
+            if current.source_unit != new.source_unit:
+                changes.append(
+                    ChangedField(
+                        item_severity=SeverityType.WARNING,
+                        field_path="sourceUnit",
+                        current_value=current.source_unit,
+                        new_value=new.source_unit,
+                    )
+                )
+            if changes:
+                return [FieldChanges(field_path="unit", changes=changes)]
+        return []  # No changes
+
+    def _check_text_property(self, current: TextProperty, new: TextProperty) -> list[FieldChange]:
+        changes: list[FieldChange] = []
+        if current.max_text_size != new.max_text_size:
+            changes.append(
+                ChangedField(
+                    item_severity=SeverityType.BREAKING
+                    if new.max_text_size is not None
+                    and current.max_text_size is not None
+                    and new.max_text_size < current.max_text_size
+                    else SeverityType.WARNING,
+                    field_path="maxTextSize",
+                    current_value=current.max_text_size,
+                    new_value=new.max_text_size,
+                )
+            )
+        if current.collation != new.collation:
+            changes.append(
+                ChangedField(
+                    item_severity=SeverityType.WARNING,
+                    field_path="collation",
+                    current_value=current.collation,
+                    new_value=new.collation,
+                )
+            )
+        return changes
+
+    def _check_enum_property(self, current: EnumProperty, new: EnumProperty) -> list[FieldChange]:
+        changes: list[FieldChange] = []
+        if current.unknown_value != new.unknown_value:
+            changes.append(
+                ChangedField(
+                    item_severity=SeverityType.WARNING,
+                    field_path="unknownValue",
+                    current_value=current.unknown_value,
+                    new_value=new.unknown_value,
+                )
+            )
+        changes.extend(
+            field_differences(
+                "values",
+                current.values,
+                new.values,
+                add_severity=SeverityType.SAFE,
+                remove_severity=SeverityType.BREAKING,
+                differ=EnumValueDiffer(),
+            )
+        )
+        return changes
+
+
+class EnumValueDiffer(ItemDiffer[EnumValue]):
+    def diff(self, current: EnumValue, new: EnumValue) -> list[FieldChange]:
+        return self._diff_name_description(current, new)

cognite/neat/_data_model/deployer/_differ_data_model.py

@@ -0,0 +1,29 @@
+from cognite.neat._data_model.models.dms import (
+    DataModelRequest,
+)
+
+from ._differ import ItemDiffer
+from .data_classes import (
+    ChangedField,
+    FieldChange,
+    SeverityType,
+)
+
+
+class DataModelDiffer(ItemDiffer[DataModelRequest]):
+    def diff(self, current: DataModelRequest, new: DataModelRequest) -> list[FieldChange]:
+        changes: list[FieldChange] = self._diff_name_description(current, new)
+        if current.views != new.views:
+            # Change of order is considered a change.
+            current_views = set(current.views or [])
+            new_views = set(new.views or [])
+            changes.append(
+                ChangedField(
+                    field_path="views",
+                    item_severity=SeverityType.SAFE if current_views <= new_views else SeverityType.BREAKING,
+                    current_value=str(current.views),
+                    new_value=str(new.views),
+                )
+            )
+
+        return changes

cognite/neat/_data_model/deployer/_differ_space.py

@@ -0,0 +1,9 @@
+from cognite.neat._data_model.models.dms import SpaceRequest
+
+from ._differ import ItemDiffer
+from .data_classes import FieldChange
+
+
+class SpaceDiffer(ItemDiffer[SpaceRequest]):
+    def diff(self, cdf_space: SpaceRequest, desired_space: SpaceRequest) -> list[FieldChange]:
+        return self._diff_name_description(cdf_space, desired_space)

cognite/neat/_data_model/deployer/_differ_view.py

@@ -0,0 +1,194 @@
+from cognite.neat._data_model.models.dms import (
+    ViewPropertyDefinition,
+    ViewRequest,
+)
+from cognite.neat._data_model.models.dms._view_property import (
+    EdgeProperty,
+    ReverseDirectRelationProperty,
+    ViewCoreProperty,
+)
+
+from ._differ import ItemDiffer, field_differences
+from .data_classes import (
+    ChangedField,
+    FieldChange,
+    SeverityType,
+)
+
+
+class ViewDiffer(ItemDiffer[ViewRequest]):
+    def diff(self, current: ViewRequest, new: ViewRequest) -> list[FieldChange]:
+        changes: list[FieldChange] = self._diff_name_description(current, new)
+
+        if current.filter != new.filter:
+            changes.append(
+                ChangedField(
+                    field_path="filter",
+                    item_severity=SeverityType.BREAKING,
+                    new_value=str(new.filter),
+                    current_value=str(current.filter),
+                )
+            )
+        if current.implements != new.implements:
+            # Note that order of implements list is significant
+            changes.append(
+                ChangedField(
+                    field_path="implements",
+                    item_severity=SeverityType.BREAKING,
+                    new_value=str(new.implements),
+                    current_value=str(current.implements),
+                )
+            )
+        changes.extend(
+            # MyPy fails to recognize that ViewPropertyDefinition and
+            # the union ViewRequestProperty are the same here.
+            field_differences(  # type: ignore[misc]
+                "properties",
+                current.properties,
+                new.properties,
+                add_severity=SeverityType.SAFE,
+                remove_severity=SeverityType.BREAKING,
+                differ=ViewPropertyDiffer(),
+            )
+        )
+
+        return changes
+
+
+class ViewPropertyDiffer(ItemDiffer[ViewPropertyDefinition]):
+    def diff(
+        self,
+        current: ViewPropertyDefinition,
+        new: ViewPropertyDefinition,
+    ) -> list[FieldChange]:
+        changes: list[FieldChange] = self._diff_name_description(current, new)
+        if current.connection_type != new.connection_type:
+            changes.append(
+                ChangedField(
+                    field_path="connectionType",
+                    item_severity=SeverityType.BREAKING,
+                    new_value=new.connection_type,
+                    current_value=current.connection_type,
+                )
+            )
+        elif isinstance(current, ViewCoreProperty) and isinstance(new, ViewCoreProperty):
+            changes.extend(self._diff_core_property(current, new))
+
+        elif isinstance(current, EdgeProperty) and isinstance(new, EdgeProperty):
+            changes.extend(self._diff_edge_property(current, new))
+
+        elif isinstance(current, ReverseDirectRelationProperty) and isinstance(new, ReverseDirectRelationProperty):
+            changes.extend(self._diff_reverse_direct_relation_property(current, new))
+
+        return changes
+
+    def _diff_core_property(
+        self,
+        current: ViewCoreProperty,
+        new: ViewCoreProperty,
+    ) -> list[FieldChange]:
+        changes: list[FieldChange] = []
+
+        if current.container != new.container:
+            changes.append(
+                ChangedField(
+                    field_path="container",
+                    # Todo check container type.
+                    item_severity=SeverityType.BREAKING,
+                    new_value=new.container,
+                    current_value=current.container,
+                )
+            )
+        if current.container_property_identifier != new.container_property_identifier:
+            changes.append(
+                ChangedField(
+                    field_path="containerPropertyIdentifier",
+                    # Todo check container property type.
+                    item_severity=SeverityType.BREAKING,
+                    new_value=new.container_property_identifier,
+                    current_value=current.container_property_identifier,
+                )
+            )
+        if current.source != new.source:
+            changes.append(
+                ChangedField(
+                    field_path="source",
+                    item_severity=SeverityType.BREAKING,
+                    new_value=new.source,
+                    current_value=current.source,
+                )
+            )
+
+        return changes
+
+    def _diff_edge_property(
+        self,
+        current: EdgeProperty,
+        new: EdgeProperty,
+    ) -> list[FieldChange]:
+        changes: list[FieldChange] = []
+        if current.source != new.source:
+            changes.append(
+                ChangedField(
+                    field_path="source",
+                    item_severity=SeverityType.BREAKING,
+                    new_value=new.source,
+                    current_value=current.source,
+                )
+            )
+        if current.type != new.type:
+            changes.append(
+                ChangedField(
+                    field_path="type",
+                    item_severity=SeverityType.BREAKING,
+                    new_value=new.type,
+                    current_value=current.type,
+                )
+            )
+        if current.edge_source != new.edge_source:
+            changes.append(
+                ChangedField(
+                    field_path="edgeSource",
+                    item_severity=SeverityType.BREAKING,
+                    new_value=new.edge_source,
+                    current_value=current.edge_source,
+                )
+            )
+        if current.direction != new.direction:
+            changes.append(
+                ChangedField(
+                    field_path="direction",
+                    item_severity=SeverityType.BREAKING,
+                    new_value=new.direction,
+                    current_value=current.direction,
+                )
+            )
+        return changes
+
+    def _diff_reverse_direct_relation_property(
+        self,
+        current: ReverseDirectRelationProperty,
+        new: ReverseDirectRelationProperty,
+    ) -> list[FieldChange]:
+        changes: list[FieldChange] = []
+        if current.source != new.source:
+            changes.append(
+                ChangedField(
+                    field_path="source",
+                    item_severity=SeverityType.BREAKING,
+                    new_value=new.source,
+                    current_value=current.source,
+                )
+            )
+
+        if current.through != new.through:
+            changes.append(
+                ChangedField(
+                    field_path="through",
+                    item_severity=SeverityType.BREAKING,
+                    new_value=new.through,
+                    current_value=current.through,
+                )
+            )
+
+        return changes