cognite-toolkit 0.7.70__py3-none-any.whl → 0.7.72__py3-none-any.whl

cognite_toolkit/_cdf_tk/client/resource_classes/instance_api.py

@@ -1,8 +1,14 @@
-from typing import Any, ClassVar, Literal, TypeAlias
+from abc import ABC, abstractmethod
+from typing import Any, ClassVar, Literal, TypeAlias, TypeVar
 
-from pydantic import ConfigDict, JsonValue, model_serializer
+from pydantic import model_validator
 
-from cognite_toolkit._cdf_tk.client._resource_base import BaseModelObject, Identifier, RequestResource
+from cognite_toolkit._cdf_tk.client._resource_base import (
+    BaseModelObject,
+    Identifier,
+    RequestResource,
+    ResponseResource,
+)
 
 InstanceType: TypeAlias = Literal["node", "edge"]
 
@@ -39,6 +45,9 @@ class TypedEdgeIdentifier(TypedInstanceIdentifier):
         return f"Edge({self.space}, {self.external_id})"
 
 
+T_TypedInstanceIdentifier = TypeVar("T_TypedInstanceIdentifier", bound=TypedInstanceIdentifier)
+
+
 class InstanceIdentifier(Identifier):
     space: str
     external_id: str
@@ -64,7 +73,7 @@ class InstanceResult(BaseModelObject):
         )
 
 
-class ViewReference(Identifier):
+class TypedViewReference(Identifier):
     type: Literal["view"] = "view"
     space: str
     external_id: str
@@ -88,108 +97,139 @@ class ViewReference(Identifier):
 #######################################################
 
 
-class InstanceRequestResource(RequestResource):
-    """This is a base class for resources that are Instances."""
+class WrappedInstanceRequest(RequestResource, ABC):
+    """This is a base class for resources that are Instances.
+    It is used to define resources that are
+    """
 
-    VIEW_ID: ClassVar[ViewReference]
+    VIEW_ID: ClassVar[TypedViewReference]
     instance_type: InstanceType
     space: str
     external_id: str
+    existing_version: int | None = None
 
-    def as_id(self) -> TypedInstanceIdentifier:
-        return TypedInstanceIdentifier(
-            instance_type=self.instance_type,
-            space=self.space,
-            external_id=self.external_id,
-        )
-
-    def as_request_item(self) -> "InstanceRequestItem":
-        return InstanceRequestItem(
-            instance_type=self.instance_type,
-            space=self.space,
-            external_id=self.external_id,
-            sources=[InstanceSource(source=self.VIEW_ID, resource=self)],
-        )
-
-
-class InstanceSource(BaseModelObject):
-    source: ViewReference
-    resource: InstanceRequestResource
+    def dump(
+        self, camel_case: bool = True, exclude_extra: bool = False, context: Literal["api", "toolkit"] = "api"
+    ) -> dict[str, Any]:
+        """Dump the resource to a dictionary.
 
-    @model_serializer(mode="plain")
-    def serialize_resource(self) -> dict[str, Any]:
-        properties: dict[str, JsonValue] = {}
-        for field_id, field in type(self.resource).model_fields.items():
-            if field_id in InstanceRequestResource.model_fields:
-                # Skip space, external_id, instance_type
-                continue
-            key = field.alias or field_id
-            properties[key] = self._serialize_property(getattr(self.resource, field_id))
+        Args:
+            camel_case (bool): Whether to use camelCase for the keys. Default is True.
+            exclude_extra (bool): Whether to exclude extra fields not defined in the model. Default is False.
+            context (Literal["api", "toolkit"]): The context in which the dump is used. Default is "api".
 
+        """
+        exclude: set[str] = set()
+        if exclude_extra:
+            exclude |= set(self.__pydantic_extra__) if self.__pydantic_extra__ else set()
+        if context == "api":
+            exclude.update({"existing_version", "instance_type", "space", "external_id"})
+        dumped = self.model_dump(mode="json", by_alias=camel_case, exclude_unset=True, exclude=exclude)
+        if context == "toolkit":
+            return dumped
         return {
-            "source": self.source.model_dump(by_alias=True),
-            "properties": properties,
+            "instanceType": self.instance_type,
+            "space": self.space,
+            "externalId": self.external_id,
+            "sources": [
+                {
+                    "source": self.VIEW_ID.dump(camel_case=camel_case, include_type=True),
+                    "properties": dumped,
+                }
+            ],
         }
 
-    @classmethod
-    def _serialize_property(cls, value: Any) -> JsonValue:
-        """Handles serialization of direct relations."""
-        if isinstance(value, InstanceRequestResource):
-            return {"space": value.space, "externalId": value.external_id}
-        elif isinstance(value, list):
-            return [cls._serialize_property(v) for v in value]
-        return value
 
+T_WrappedInstanceRequest = TypeVar("T_WrappedInstanceRequest", bound=WrappedInstanceRequest)
 
-class InstanceRequestItem(RequestResource):
-    model_config = ConfigDict(populate_by_name=True)
-    instance_type: InstanceType
-    space: str
-    external_id: str
-    existing_version: int | None = None
-    sources: list[InstanceSource] | None = None
-
-    def as_id(self) -> TypedInstanceIdentifier:
-        return TypedInstanceIdentifier(
-            instance_type=self.instance_type,
-            space=self.space,
-            external_id=self.external_id,
-        )
 
-
-class InstanceResponseItem(BaseModelObject):
+class WrappedInstanceResponse(ResponseResource[T_WrappedInstanceRequest], ABC):
+    VIEW_ID: ClassVar[TypedViewReference]
     instance_type: InstanceType
     space: str
     external_id: str
+
     version: int
-    type: TypedInstanceIdentifier | None = None
     created_time: int
     last_updated_time: int
     deleted_time: int | None = None
-    properties: dict[str, dict[str, dict[str, JsonValue]]] | None = None
 
-    def get_properties_for_source(
-        self, source: ViewReference, include_identifier: bool = False
-    ) -> dict[str, JsonValue]:
-        output: dict[str, JsonValue] = (
-            {"space": self.space, "externalId": self.external_id} if include_identifier else {}
-        )
-        if not self.properties:
-            return output
-        if source.space not in self.properties:
-            return output
-        space_properties = self.properties[source.space]
-        view_version = f"{source.external_id}/{source.version}"
-        output.update(space_properties.get(view_version, {}))
-        return output
+    @model_validator(mode="before")
+    def move_properties(cls, values: dict[str, Any]) -> dict[str, Any]:
+        """Move properties from sources to the top level."""
+        return move_properties(values, cls.VIEW_ID)
 
-    def as_id(self) -> TypedInstanceIdentifier:
-        return TypedInstanceIdentifier(
+
+def move_properties(values: dict[str, Any], view_id: TypedViewReference) -> dict[str, Any]:
+    """Help function to move properties from properties.space.externalId/version to the top level.
+
+    It is used in WrappedInstanceResponse to move properties from the response to the top level.
+    """
+    if "properties" not in values:
+        return values
+    values_copy = dict(values)
+    properties = values_copy.pop("properties")
+    if not isinstance(properties, dict) or view_id.space not in properties:
+        return values
+    view_properties = properties.pop(view_id.space)
+    identifier = f"{view_id.external_id}/{view_id.version}"
+    if not isinstance(view_properties, dict) or identifier not in view_properties:
+        return values
+    source_properties = view_properties.pop(identifier)
+    values_copy.update(source_properties)
+    return values_copy
+
+
+T_WrappedInstanceResponse = TypeVar("T_WrappedInstanceResponse", bound=WrappedInstanceResponse)
+
+
+class WrappedInstanceListRequest(RequestResource, ABC):
+    VIEW_ID: ClassVar[TypedViewReference]
+    instance_type: Literal["node"] = "node"
+    space: str
+    external_id: str
+
+    @abstractmethod
+    def dump_instances(self) -> list[dict[str, Any]]:
+        """Dumps the object to a list of instance request dictionaries."""
+        raise NotImplementedError()
+
+    def as_id(self) -> TypedNodeIdentifier:
+        return TypedNodeIdentifier(
             instance_type=self.instance_type,
             space=self.space,
             external_id=self.external_id,
         )
 
+    @abstractmethod
+    def as_ids(self) -> list[TypedInstanceIdentifier]:
+        """Convert the response to a list of typed instance identifiers."""
+        raise NotImplementedError()
+
+
+T_InstancesListRequest = TypeVar("T_InstancesListRequest", bound=WrappedInstanceListRequest)
+
+
+class WrappedInstanceListResponse(ResponseResource[T_InstancesListRequest], ABC):
+    VIEW_ID: ClassVar[TypedViewReference]
+    instance_type: Literal["node"] = "node"
+    space: str
+    external_id: str
+
+    @model_validator(mode="before")
+    @classmethod
+    def move_properties(cls, values: dict[str, Any]) -> dict[str, Any]:
+        """Move properties from sources to the top level."""
+        return move_properties(values, cls.VIEW_ID)
+
+    @abstractmethod
+    def as_ids(self) -> list[TypedInstanceIdentifier]:
+        """Convert the response to a list of typed instance identifiers."""
+        raise NotImplementedError()
+
+
+T_InstancesListResponse = TypeVar("T_InstancesListResponse", bound=WrappedInstanceListResponse)
+
 
 class NodeReference(BaseModelObject):
     space: str

cognite_toolkit/_cdf_tk/client/testing.py

@@ -23,15 +23,14 @@ from cognite_toolkit._cdf_tk.client.api.legacy.extended_functions import Extende
 from cognite_toolkit._cdf_tk.client.api.legacy.extended_raw import ExtendedRawAPI
 from cognite_toolkit._cdf_tk.client.api.legacy.extended_timeseries import ExtendedTimeSeriesAPI
 from cognite_toolkit._cdf_tk.client.api.legacy.location_filters import LocationFiltersAPI
-from cognite_toolkit._cdf_tk.client.api.legacy.robotics import (
-    CapabilitiesAPI,
-    DataPostProcessingAPI,
-    FramesAPI,
-    MapsAPI,
-    RoboticsAPI,
-)
-from cognite_toolkit._cdf_tk.client.api.legacy.robotics import LocationsAPI as RoboticsLocationsAPI
 from cognite_toolkit._cdf_tk.client.api.legacy.search_config import SearchConfigurationsAPI
+from cognite_toolkit._cdf_tk.client.api.robotics import RoboticsAPI
+from cognite_toolkit._cdf_tk.client.api.robotics_capabilities import CapabilitiesAPI
+from cognite_toolkit._cdf_tk.client.api.robotics_data_postprocessing import DataPostProcessingAPI
+from cognite_toolkit._cdf_tk.client.api.robotics_frames import FramesAPI
+from cognite_toolkit._cdf_tk.client.api.robotics_locations import LocationsAPI
+from cognite_toolkit._cdf_tk.client.api.robotics_maps import MapsAPI
+from cognite_toolkit._cdf_tk.client.api.robotics_robots import RobotsAPI
 
 from ._toolkit_client import ToolAPI
 from .api.assets import AssetsAPI
@@ -139,14 +138,6 @@ class ToolkitClientMock(CogniteClientMock):
         self.raw.rows = MagicMock(spec_set=RawRowsAPI)
         self.raw.tables = MagicMock(spec_set=RawTablesAPI)
 
-        self.robotics = MagicMock()
-        self.robotics.robots = MagicMock(spec=RoboticsAPI)
-        self.robotics.data_postprocessing = MagicMock(spec_set=DataPostProcessingAPI)
-        self.robotics.locations = MagicMock(spec_set=RoboticsLocationsAPI)
-        self.robotics.frames = MagicMock(spec_set=FramesAPI)
-        self.robotics.maps = MagicMock(spec_set=MapsAPI)
-        self.robotics.capabilities = MagicMock(spec_set=CapabilitiesAPI)
-
         self.data_modeling.instances = MagicMock(spec_set=ExtendedInstancesAPI)
 
         self.time_series = MagicMock(spec=ExtendedTimeSeriesAPI)
@@ -171,6 +162,13 @@ class ToolkitClientMock(CogniteClientMock):
         self.tool.hosted_extractors.destinations = MagicMock(spec_set=HostedExtractorDestinationsAPI)
         self.tool.hosted_extractors.mappings = MagicMock(spec_set=HostedExtractorMappingsAPI)
         self.tool.labels = MagicMock(spec_set=LabelsAPI)
+        self.tool.robotics = MagicMock(spec=RoboticsAPI)
+        self.tool.robotics.capabilities = MagicMock(spec_set=CapabilitiesAPI)
+        self.tool.robotics.data_postprocessing = MagicMock(spec_set=DataPostProcessingAPI)
+        self.tool.robotics.frames = MagicMock(spec_set=FramesAPI)
+        self.tool.robotics.locations = MagicMock(spec_set=LocationsAPI)
+        self.tool.robotics.maps = MagicMock(spec_set=MapsAPI)
+        self.tool.robotics.robots = MagicMock(spec_set=RobotsAPI)
         self.tool.security_categories = MagicMock(spec_set=SecurityCategoriesAPI)
         self.tool.sequences = MagicMock(spec_set=SequencesAPI)
         self.tool.transformations = MagicMock(spec_set=TransformationsAPI)

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/fieldops.py

@@ -8,13 +8,15 @@ from cognite.client.data_classes.data_modeling import NodeApplyResultList, NodeI
 from cognite.client.exceptions import CogniteAPIError
 from cognite.client.utils.useful_types import SequenceNotStr
 
+from cognite_toolkit._cdf_tk.client.resource_classes.data_modeling._instance import InstanceSlimDefinition
 from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import ExternalId
 from cognite_toolkit._cdf_tk.client.resource_classes.infield import (
-    InFieldCDMLocationConfig,
-    InfieldLocationConfig,
-    InfieldLocationConfigList,
+    InFieldCDMLocationConfigRequest,
+    InFieldCDMLocationConfigResponse,
+    InFieldLocationConfigRequest,
+    InFieldLocationConfigResponse,
 )
-from cognite_toolkit._cdf_tk.client.resource_classes.instance_api import InstanceResult, TypedNodeIdentifier
+from cognite_toolkit._cdf_tk.client.resource_classes.instance_api import TypedNodeIdentifier
 from cognite_toolkit._cdf_tk.client.resource_classes.legacy.apm_config_v1 import (
     APMConfig,
     APMConfigList,
@@ -34,7 +36,7 @@ from cognite_toolkit._cdf_tk.utils.diff_list import diff_list_hashable, diff_lis
 from .auth import GroupAllScopedCRUD
 from .classic import AssetCRUD
 from .data_organization import DataSetsCRUD
-from .datamodel import SpaceCRUD
+from .datamodel import SpaceCRUD, ViewCRUD
 from .group_scoped import GroupResourceScopedCRUD
 
 
@@ -247,10 +249,12 @@ class InfieldV1CRUD(ResourceCRUD[str, APMConfigWrite, APMConfig]):
 
 
 @final
-class InFieldLocationConfigCRUD(ResourceCRUD[TypedNodeIdentifier, InfieldLocationConfig, InfieldLocationConfig]):
+class InFieldLocationConfigCRUD(
+    ResourceCRUD[TypedNodeIdentifier, InFieldLocationConfigRequest, InFieldLocationConfigResponse]
+):
     folder_name = "cdf_applications"
-    resource_cls = InfieldLocationConfig
-    resource_write_cls = InfieldLocationConfig
+    resource_cls = InFieldLocationConfigResponse
+    resource_write_cls = InFieldLocationConfigRequest
     kind = "InFieldLocationConfig"
     yaml_cls = InfieldLocationConfigYAML
     dependencies = frozenset({SpaceCRUD, GroupAllScopedCRUD, GroupResourceScopedCRUD})
@@ -261,7 +265,7 @@ class InFieldLocationConfigCRUD(ResourceCRUD[TypedNodeIdentifier, InfieldLocatio
         return "infield location configs"
 
     @classmethod
-    def get_id(cls, item: InfieldLocationConfig | dict) -> TypedNodeIdentifier:
+    def get_id(cls, item: InFieldLocationConfigRequest | InFieldLocationConfigResponse | dict) -> TypedNodeIdentifier:
         if isinstance(item, dict):
             return TypedNodeIdentifier(space=item["space"], external_id=item["externalId"])
         return TypedNodeIdentifier(space=item.space, external_id=item.external_id)
@@ -275,7 +279,7 @@ class InFieldLocationConfigCRUD(ResourceCRUD[TypedNodeIdentifier, InfieldLocatio
 
     @classmethod
     def get_required_capability(
-        cls, items: Sequence[InfieldLocationConfig] | None, read_only: bool
+        cls, items: Sequence[InFieldLocationConfigRequest] | None, read_only: bool
     ) -> Capability | list[Capability]:
         if not items or items is None:
             return []
@@ -289,8 +293,10 @@ class InFieldLocationConfigCRUD(ResourceCRUD[TypedNodeIdentifier, InfieldLocatio
 
         return DataModelInstancesAcl(actions, DataModelInstancesAcl.Scope.SpaceID(instance_spaces))
 
-    def dump_resource(self, resource: InfieldLocationConfig, local: dict[str, Any] | None = None) -> dict[str, Any]:
-        dumped = resource.dump()
+    def dump_resource(
+        self, resource: InFieldLocationConfigResponse, local: dict[str, Any] | None = None
+    ) -> dict[str, Any]:
+        dumped = resource.as_request_resource().dump()
         local = local or {}
         dumped.pop("instanceType", None)
         if isinstance(cdf_dec := dumped.get("dataExplorationConfig"), dict):
@@ -305,33 +311,24 @@ class InFieldLocationConfigCRUD(ResourceCRUD[TypedNodeIdentifier, InfieldLocatio
 
         return dumped
 
-    def create(self, items: Sequence[InfieldLocationConfig]) -> list[InstanceResult]:
-        created = self.client.infield.config.apply(items)
-        config_ids = {config.as_id() for config in items}
-        # We filter out all the data exploration configs that were created along with the infield location configs
-        # as we only want to count the infield location configs here.
-        return [res for res in created if res.as_id() in config_ids]
+    def create(self, items: Sequence[InFieldLocationConfigRequest]) -> list[InstanceSlimDefinition]:
+        return self.client.infield.config.create(items)
 
-    def retrieve(self, ids: SequenceNotStr[TypedNodeIdentifier]) -> InfieldLocationConfigList:
-        return InfieldLocationConfigList(self.client.infield.config.retrieve(list(ids)))
+    def retrieve(self, ids: SequenceNotStr[TypedNodeIdentifier]) -> list[InFieldLocationConfigResponse]:
+        return self.client.infield.config.retrieve(list(ids))
 
-    def update(self, items: Sequence[InfieldLocationConfig]) -> Sized:
-        return self.create(items)
+    def update(self, items: Sequence[InFieldLocationConfigRequest]) -> Sized:
+        return self.client.infield.config.update(items)
 
     def delete(self, ids: SequenceNotStr[TypedNodeIdentifier]) -> int:
-        # We must retrieve the full resource to get hte DataExplorationConfig linked resource deleted as well.
-        retrieved = self.retrieve(list(ids))
-        # Then, we pass the entire resource to the delete method, which will delete both the InfieldLocationConfig
-        # and the linked DataExplorationConfig.
-        _ = self.client.infield.config.delete(retrieved)
-        return len(retrieved)
+        return len(self.client.infield.config.delete(list(ids)))
 
     def _iterate(
         self,
         data_set_external_id: str | None = None,
         space: str | None = None,
         parent_ids: list[Hashable] | None = None,
-    ) -> Iterable[InfieldLocationConfig]:
+    ) -> Iterable[InFieldLocationConfigResponse]:
         raise NotImplementedError(f"Iteration over {self.display_name} is not supported.")
 
     def diff_list(
@@ -350,14 +347,14 @@ class InFieldLocationConfigCRUD(ResourceCRUD[TypedNodeIdentifier, InfieldLocatio
 
 @final
 class InFieldCDMLocationConfigCRUD(
-    ResourceCRUD[TypedNodeIdentifier, InFieldCDMLocationConfig, InFieldCDMLocationConfig]
+    ResourceCRUD[TypedNodeIdentifier, InFieldCDMLocationConfigRequest, InFieldCDMLocationConfigResponse]
 ):
     folder_name = "cdf_applications"
-    resource_cls = InFieldCDMLocationConfig
-    resource_write_cls = InFieldCDMLocationConfig
+    resource_cls = InFieldCDMLocationConfigResponse
+    resource_write_cls = InFieldCDMLocationConfigRequest
     kind = "InFieldCDMLocationConfig"
     yaml_cls = InFieldCDMLocationConfigYAML
-    dependencies = frozenset({SpaceCRUD, GroupAllScopedCRUD, GroupResourceScopedCRUD})
+    dependencies = frozenset({SpaceCRUD, GroupAllScopedCRUD, GroupResourceScopedCRUD, ViewCRUD})
     _doc_url = "Instances/operation/applyNodeAndEdges"
 
     @property
@@ -365,7 +362,9 @@ class InFieldCDMLocationConfigCRUD(
         return "infield CDM location configs"
 
     @classmethod
-    def get_id(cls, item: InFieldCDMLocationConfig | dict) -> TypedNodeIdentifier:
+    def get_id(
+        cls, item: InFieldCDMLocationConfigRequest | InFieldCDMLocationConfigResponse | dict
+    ) -> TypedNodeIdentifier:
         if isinstance(item, dict):
             return TypedNodeIdentifier(space=item["space"], external_id=item["externalId"])
         return TypedNodeIdentifier(space=item.space, external_id=item.external_id)
@@ -379,7 +378,7 @@ class InFieldCDMLocationConfigCRUD(
 
     @classmethod
     def get_required_capability(
-        cls, items: Sequence[InFieldCDMLocationConfig] | None, read_only: bool
+        cls, items: Sequence[InFieldCDMLocationConfigRequest] | None, read_only: bool
     ) -> Capability | list[Capability]:
         if not items or items is None:
             return []
@@ -393,8 +392,10 @@ class InFieldCDMLocationConfigCRUD(
 
         return DataModelInstancesAcl(actions, DataModelInstancesAcl.Scope.SpaceID(instance_spaces))
 
-    def dump_resource(self, resource: InFieldCDMLocationConfig, local: dict[str, Any] | None = None) -> dict[str, Any]:
-        dumped = resource.as_write().dump()
+    def dump_resource(
+        self, resource: InFieldCDMLocationConfigResponse, local: dict[str, Any] | None = None
+    ) -> dict[str, Any]:
+        dumped = resource.as_request_resource().dump(context="toolkit")
         local = local or {}
         if "existingVersion" not in local:
             # Existing version is typically not set when creating nodes, but we get it back
@@ -403,27 +404,25 @@ class InFieldCDMLocationConfigCRUD(
         dumped.pop("instanceType", None)
         return dumped
 
-    def create(self, items: Sequence[InFieldCDMLocationConfig]) -> list[InstanceResult]:
-        return self.client.infield.cdm_config.apply(items)
+    def create(self, items: Sequence[InFieldCDMLocationConfigRequest]) -> list[InstanceSlimDefinition]:
+        return self.client.infield.cdm_config.create(items)
 
-    def retrieve(self, ids: SequenceNotStr[TypedNodeIdentifier]) -> list[InFieldCDMLocationConfig]:
+    def retrieve(self, ids: SequenceNotStr[TypedNodeIdentifier]) -> list[InFieldCDMLocationConfigResponse]:
         return self.client.infield.cdm_config.retrieve(list(ids))
 
-    def update(self, items: Sequence[InFieldCDMLocationConfig]) -> Sized:
+    def update(self, items: Sequence[InFieldCDMLocationConfigRequest]) -> Sized:
         return self.create(items)
 
     def delete(self, ids: SequenceNotStr[TypedNodeIdentifier]) -> int:
-        # We must retrieve the full resource to delete it.
-        retrieved = self.retrieve(list(ids))
-        _ = self.client.infield.cdm_config.delete(retrieved)
-        return len(retrieved)
+        deleted = self.client.infield.cdm_config.delete(list(ids))
+        return len(deleted)
 
     def _iterate(
         self,
         data_set_external_id: str | None = None,
         space: str | None = None,
         parent_ids: list[Hashable] | None = None,
-    ) -> Iterable[InFieldCDMLocationConfig]:
+    ) -> Iterable[InFieldCDMLocationConfigResponse]:
         raise NotImplementedError(f"Iteration over {self.display_name} is not supported.")
 
     def diff_list(