cognite-toolkit 0.7.39__py3-none-any.whl → 0.7.51__py3-none-any.whl

cognite_toolkit/_cdf_tk/client/resource_classes/robotics/__init__.py

@@ -0,0 +1,37 @@
+from ._capability import RobotCapability, RobotCapabilityRequest, RobotCapabilityResponse
+from ._common import MapType, Point3D, Quaternion, RobotType, Transform
+from ._data_post_processing import (
+    RobotDataPostProcessing,
+    RobotDataPostProcessingRequest,
+    RobotDataPostProcessingResponse,
+)
+from ._frame import RobotFrame, RobotFrameRequest, RobotFrameResponse
+from ._location import RobotLocation, RobotLocationRequest, RobotLocationResponse
+from ._map import RobotMap, RobotMapRequest, RobotMapResponse
+from ._robot import Robot, RobotRequest, RobotResponse
+
+__all__ = [
+    "MapType",
+    "Point3D",
+    "Quaternion",
+    "Robot",
+    "RobotCapability",
+    "RobotCapabilityRequest",
+    "RobotCapabilityResponse",
+    "RobotDataPostProcessing",
+    "RobotDataPostProcessingRequest",
+    "RobotDataPostProcessingResponse",
+    "RobotFrame",
+    "RobotFrameRequest",
+    "RobotFrameResponse",
+    "RobotLocation",
+    "RobotLocationRequest",
+    "RobotLocationResponse",
+    "RobotMap",
+    "RobotMapRequest",
+    "RobotMapResponse",
+    "RobotRequest",
+    "RobotResponse",
+    "RobotType",
+    "Transform",
+]

cognite_toolkit/_cdf_tk/client/resource_classes/robotics/_capability.py

@@ -0,0 +1,53 @@
+from typing import ClassVar
+
+from pydantic import JsonValue
+
+from cognite_toolkit._cdf_tk.client._resource_base import (
+    BaseModelObject,
+    ResponseResource,
+    UpdatableRequestResource,
+)
+from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import ExternalId
+
+
+class RobotCapability(BaseModelObject):
+    """Robot capabilities define what actions that robots can execute, including data capture (PTZ, PTZ-IR, 360)
+    and behaviors (e.g., docking).
+
+    Args:
+        name: RobotCapability name.
+        external_id: RobotCapability external id. Must be unique for the resource type.
+        method: RobotCapability method. The method is used to call the right functionality on the robot.
+        input_schema: Schema that defines what inputs are needed for the action.
+            The input are values that configure the action, e.g pan, tilt and zoom values.
+        data_handling_schema: Schema that defines how the data from a RobotCapability should be handled,
+            including upload instructions.
+        description: Description of RobotCapability. Textual description of the RobotCapability.
+    """
+
+    external_id: str
+    name: str
+    method: str
+    description: str | None = None
+
+    def as_id(self) -> ExternalId:
+        return ExternalId(external_id=self.external_id)
+
+
+class RobotCapabilityRequest(RobotCapability, UpdatableRequestResource):
+    """Request resource for creating or updating a RobotCapability."""
+
+    non_nullable_fields: ClassVar[frozenset[str]] = frozenset({"input_schema", "data_handling_schema"})
+    input_schema: dict[str, JsonValue] | None = None
+    data_handling_schema: dict[str, JsonValue] | None = None
+
+
+class RobotCapabilityResponse(RobotCapability, ResponseResource[RobotCapabilityRequest]):
+    """Response resource for a RobotCapability."""
+
+    # The response always has input_schema and data_handling_schema
+    input_schema: dict[str, JsonValue]
+    data_handling_schema: dict[str, JsonValue]
+
+    def as_request_resource(self) -> RobotCapabilityRequest:
+        return RobotCapabilityRequest.model_validate(self.dump(), extra="ignore")

cognite_toolkit/_cdf_tk/client/resource_classes/robotics/_common.py

@@ -0,0 +1,34 @@
+from typing import Literal
+
+from cognite_toolkit._cdf_tk.client._resource_base import BaseModelObject
+
+RobotType = Literal["SPOT", "ANYMAL", "DJI_DRONE", "TAUROB", "UNKNOWN"]
+MapType = Literal["WAYPOINTMAP", "THREEDMODEL", "TWODMAP", "POINTCLOUD"]
+
+
+class Point3D(BaseModelObject):
+    """A point in 3D space."""
+
+    x: float
+    y: float
+    z: float
+
+
+class Quaternion(Point3D):
+    """A quaternion representing orientation."""
+
+    w: float
+
+
+class Transform(BaseModelObject):
+    """Transform of the parent frame to the current frame.
+
+    Args:
+        parent_frame_external_id: The external id of the parent frame.
+        translation: Transform translation (Point3D).
+        orientation: Transform orientation as quaternion (Quaternion).
+    """
+
+    parent_frame_external_id: str
+    translation: Point3D
+    orientation: Quaternion

cognite_toolkit/_cdf_tk/client/resource_classes/robotics/_data_post_processing.py

@@ -0,0 +1,49 @@
+from typing import ClassVar
+
+from pydantic import JsonValue
+
+from cognite_toolkit._cdf_tk.client._resource_base import (
+    BaseModelObject,
+    ResponseResource,
+    UpdatableRequestResource,
+)
+from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import ExternalId
+
+
+class RobotDataPostProcessing(BaseModelObject):
+    """DataPostprocessing define types of data processing on data captured by the robot.
+    DataPostprocessing enables you to automatically process data captured by the robot.
+
+    Args:
+        name: DataPostProcessing name.
+        external_id: DataPostProcessing external id. Must be unique for the resource type.
+        method: DataPostProcessing method. The method is used to call the right functionality on the robot.
+        input_schema: Schema that defines what inputs are needed for the data postprocessing.
+            The input are values that configure the data postprocessing, e.g max and min values for a gauge.
+        description: Description of DataPostProcessing. Textual description of the DataPostProcessing.
+    """
+
+    external_id: str
+    name: str
+    method: str
+    description: str | None = None
+
+    def as_id(self) -> ExternalId:
+        return ExternalId(external_id=self.external_id)
+
+
+class RobotDataPostProcessingRequest(RobotDataPostProcessing, UpdatableRequestResource):
+    """Request resource for creating or updating a DataPostProcessing."""
+
+    non_nullable_fields: ClassVar[frozenset[str]] = frozenset({"input_schema"})
+    input_schema: dict[str, JsonValue] | None = None
+
+
+class RobotDataPostProcessingResponse(RobotDataPostProcessing, ResponseResource[RobotDataPostProcessingRequest]):
+    """Response resource for a DataPostProcessing."""
+
+    # The response always has input_schema
+    input_schema: dict[str, JsonValue]
+
+    def as_request_resource(self) -> RobotDataPostProcessingRequest:
+        return RobotDataPostProcessingRequest.model_validate(self.dump(), extra="ignore")

cognite_toolkit/_cdf_tk/client/resource_classes/robotics/_frame.py

@@ -0,0 +1,46 @@
+from typing import ClassVar
+
+from cognite_toolkit._cdf_tk.client._resource_base import (
+    BaseModelObject,
+    ResponseResource,
+    UpdatableRequestResource,
+)
+from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import ExternalId
+
+from ._common import Transform
+
+
+class RobotFrame(BaseModelObject):
+    """The frames resource represents coordinate frames, which are used to describe how maps are aligned with
+    respect to each other. For example, frames are used to describe the relative position of a context map
+    (e.g., a 3D model of a location) and a robot's navigation map. Frames are aligned with each other through
+    transforms, which consist of a translation (in meters) and rotation (quaternion).
+
+    Args:
+        name: Frame name.
+        external_id: Frame external id. Must be unique for the resource type.
+        transform: Transform of the parent frame to the current frame.
+    """
+
+    external_id: str
+    name: str
+    transform: Transform | None = None
+
+    def as_id(self) -> ExternalId:
+        return ExternalId(external_id=self.external_id)
+
+
+class RobotFrameRequest(RobotFrame, UpdatableRequestResource):
+    """Request resource for creating or updating a Frame."""
+
+    non_nullable_fields: ClassVar[frozenset[str]] = frozenset({"transform"})
+
+
+class RobotFrameResponse(RobotFrame, ResponseResource[RobotFrameRequest]):
+    """Response resource for a Frame."""
+
+    created_time: int
+    updated_time: int
+
+    def as_request_resource(self) -> RobotFrameRequest:
+        return RobotFrameRequest.model_validate(self.dump(), extra="ignore")

cognite_toolkit/_cdf_tk/client/resource_classes/robotics/_location.py

@@ -0,0 +1,36 @@
+from cognite_toolkit._cdf_tk.client._resource_base import BaseModelObject, ResponseResource, UpdatableRequestResource
+from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import ExternalId
+
+
+class RobotLocation(BaseModelObject):
+    """The Locations resource is used to specify the physical location of a robot. Robot missions are defined
+    for a specific location. In addition, the location is used to group Missions and Map resources.
+
+    Args:
+        name: Location name.
+        external_id: Location external id. Must be unique for the resource type.
+        description: Description of Location. Textual description of the Location.
+    """
+
+    external_id: str
+    name: str
+    description: str | None = None
+
+    def as_id(self) -> ExternalId:
+        return ExternalId(external_id=self.external_id)
+
+
+class RobotLocationRequest(RobotLocation, UpdatableRequestResource):
+    """Request resource for creating or updating a Location."""
+
+    ...
+
+
+class RobotLocationResponse(RobotLocation, ResponseResource[RobotLocationRequest]):
+    """Response resource for a Location."""
+
+    created_time: int
+    updated_time: int
+
+    def as_request_resource(self) -> RobotLocationRequest:
+        return RobotLocationRequest.model_validate(self.dump(), extra="ignore")

cognite_toolkit/_cdf_tk/client/resource_classes/robotics/_map.py

@@ -0,0 +1,65 @@
+from typing import ClassVar, Literal
+
+from pydantic import JsonValue
+
+from cognite_toolkit._cdf_tk.client._resource_base import (
+    BaseModelObject,
+    ResponseResource,
+    UpdatableRequestResource,
+)
+from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import ExternalId
+
+from ._common import MapType
+
+
+class RobotMap(BaseModelObject):
+    """The map resource allows defining both context maps and robot maps of a specific location. A context map is a
+    visual representation of a location, for example, a 3D model, a 2D floor plan, or a point cloud model.
+    A robot map is a representation of where a robot is able to navigate. Maps need to be aligned with respect
+    to each other using coordinate frames.
+
+    Args:
+        name: Map name.
+        external_id: Map external id. Must be unique for the resource type.
+        map_type: Map type.
+        description: Description of Map. Textual description of the Map.
+        frame_external_id: External id of the map's reference frame.
+        data: Map-specific data.
+        location_external_id: External id of the location.
+        scale: Uniform scaling factor, for example, for map unit conversion (centimeter to meter).
+    """
+
+    external_id: str
+    name: str
+    map_type: MapType
+    description: str | None = None
+    frame_external_id: str | None = None
+    data: dict[str, JsonValue] | None = None
+    location_external_id: str | None = None
+    scale: float | None = None
+
+    def as_id(self) -> ExternalId:
+        return ExternalId(external_id=self.external_id)
+
+
+class RobotMapRequest(RobotMap, UpdatableRequestResource):
+    """Request resource for creating or updating a RobotMap."""
+
+    non_nullable_fields: ClassVar[frozenset[str]] = frozenset(
+        {"description", "data", "frame_external_id", "location_external_id", "scale"}
+    )
+
+    def as_update(self, mode: Literal["patch", "replace"]) -> dict[str, JsonValue]:
+        update = super().as_update(mode)
+        update["update"].pop("mapType", None)
+        return update
+
+
+class RobotMapResponse(RobotMap, ResponseResource[RobotMapRequest]):
+    """Response resource for a RobotMap."""
+
+    created_time: int
+    updated_time: int
+
+    def as_request_resource(self) -> RobotMapRequest:
+        return RobotMapRequest.model_validate(self.dump(), extra="ignore")

cognite_toolkit/_cdf_tk/client/resource_classes/robotics/_robot.py

@@ -0,0 +1,58 @@
+from typing import Any, ClassVar, Literal
+
+from cognite_toolkit._cdf_tk.client._resource_base import (
+    BaseModelObject,
+    ResponseResource,
+    UpdatableRequestResource,
+)
+from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import DataSetId
+
+from ._common import RobotType
+
+
+class Robot(BaseModelObject):
+    """Robot contains information for a single robot, including capabilities, type, video streaming setup, etc.
+    These fields are updated every time a robot registers with Robotics Services and do not require manual changes.
+
+    Args:
+        name: Robot name.
+        capabilities: List of external ids for the capabilities the robot can perform.
+        robot_type: Type of robot.
+        data_set_id: The id of the data set this asset belongs to.
+        description: A brief description of the robot.
+        metadata: Custom, application-specific metadata. String key -> String value.
+        location_external_id: External id of the location.
+    """
+
+    name: str
+    capabilities: list[str]
+    robot_type: RobotType
+    data_set_id: int
+    description: str | None = None
+    metadata: dict[str, str] | None = None
+    location_external_id: str | None = None
+
+    def as_id(self) -> DataSetId:
+        return DataSetId(data_set_id=self.data_set_id)
+
+
+class RobotRequest(Robot, UpdatableRequestResource):
+    """Request resource for creating or updating a Robot."""
+
+    container_fields: ClassVar[frozenset[str]] = frozenset({"metadata"})
+    non_nullable_fields: ClassVar[frozenset[str]] = frozenset({"location_external_id", "description"})
+
+    def as_update(self, mode: Literal["patch", "replace"]) -> dict[str, Any]:
+        update = super().as_update(mode)
+        update["update"].pop("capabilities", None)
+        return update
+
+
+class RobotResponse(Robot, ResponseResource[RobotRequest]):
+    """Response resource for a Robot."""
+
+    created_time: int
+    updated_time: int
+
+    def as_request_resource(self) -> RobotRequest:
+        return RobotRequest.model_validate(self.dump(), extra="ignore")

cognite_toolkit/_cdf_tk/client/resource_classes/search_config.py

@@ -0,0 +1,54 @@
+from cognite_toolkit._cdf_tk.client._resource_base import BaseModelObject, RequestResource, ResponseResource
+
+from .identifiers import Identifier
+
+
+class SearchConfigViewId(Identifier):
+    """Identifier for a view in search configuration."""
+
+    space: str
+    external_id: str
+
+    def __str__(self) -> str:
+        return f"space='{self.space}', externalId='{self.external_id}'"
+
+
+class SearchConfigViewProperty(BaseModelObject):
+    """Configuration for a property in search configuration."""
+
+    property: str
+    disabled: bool | None = None
+    selected: bool | None = None
+    hidden: bool | None = None
+
+
+class SearchConfigBase(BaseModelObject):
+    """Base class for search configuration with common fields."""
+
+    view: SearchConfigViewId
+    use_as_name: str | None = None
+    use_as_description: str | None = None
+    columns_layout: list[SearchConfigViewProperty] | None = None
+    filter_layout: list[SearchConfigViewProperty] | None = None
+    properties_layout: list[SearchConfigViewProperty] | None = None
+
+    def as_id(self) -> SearchConfigViewId:
+        return self.view
+
+
+class SearchConfigRequest(SearchConfigBase, RequestResource):
+    """Request resource for creating/updating search configuration."""
+
+    # This is required when updating an existing search config
+    id: int | None = None
+
+
+class SearchConfigResponse(SearchConfigBase, ResponseResource[SearchConfigRequest]):
+    """Response resource for search configuration."""
+
+    id: int
+    created_time: int
+    last_updated_time: int
+
+    def as_request_resource(self) -> SearchConfigRequest:
+        return SearchConfigRequest.model_validate(self.dump(), extra="ignore")

cognite_toolkit/_cdf_tk/client/resource_classes/securitycategory.py

@@ -0,0 +1,24 @@
+from cognite_toolkit._cdf_tk.client._resource_base import (
+    BaseModelObject,
+    RequestResource,
+    ResponseResource,
+)
+
+from .identifiers import NameId
+
+
+class SecurityCategory(BaseModelObject):
+    name: str
+
+    def as_id(self) -> NameId:
+        return NameId(name=self.name)
+
+
+class SecurityCategoryRequest(SecurityCategory, RequestResource): ...
+
+
+class SecurityCategoryResponse(SecurityCategory, ResponseResource[SecurityCategoryRequest]):
+    id: int
+
+    def as_request_resource(self) -> SecurityCategoryRequest:
+        return SecurityCategoryRequest.model_validate(self.dump(), extra="ignore")

cognite_toolkit/_cdf_tk/client/resource_classes/sequence.py

@@ -0,0 +1,45 @@
+from typing import ClassVar, Literal
+
+from cognite_toolkit._cdf_tk.client._resource_base import (
+    BaseModelObject,
+    ResponseResource,
+    UpdatableRequestResource,
+)
+
+from .identifiers import ExternalId
+
+
+class SequenceColumn(BaseModelObject):
+    external_id: str
+    name: str | None = None
+    description: str | None = None
+    metadata: dict[str, str] | None = None
+    value_type: Literal["STRING", "DOUBLE", "LONG"] | None = None
+
+
+class Sequence(BaseModelObject):
+    external_id: str | None = None
+    name: str | None = None
+    description: str | None = None
+    asset_id: int | None = None
+    data_set_id: int | None = None
+    metadata: dict[str, str] | None = None
+    columns: list[SequenceColumn]
+
+    def as_id(self) -> ExternalId:
+        if self.external_id is None:
+            raise ValueError("Cannot convert Sequence to ExternalId when external_id is None")
+        return ExternalId(external_id=self.external_id)
+
+
+class SequenceRequest(Sequence, UpdatableRequestResource):
+    container_fields: ClassVar[frozenset[str]] = frozenset({"metadata", "columns"})
+
+
+class SequenceResponse(Sequence, ResponseResource[SequenceRequest]):
+    id: int
+    created_time: int
+    last_updated_time: int
+
+    def as_request_resource(self) -> SequenceRequest:
+        return SequenceRequest.model_validate(self.dump(), extra="ignore")

cognite_toolkit/_cdf_tk/client/resource_classes/sequence_rows.py

@@ -0,0 +1,56 @@
+from typing import Literal
+
+from cognite_toolkit._cdf_tk.client._resource_base import BaseModelObject, RequestResource, ResponseResource
+
+from .identifiers import ExternalId
+
+
+class SequenceColumn(BaseModelObject):
+    """Represents a column in a sequence."""
+
+    external_id: str
+    name: str | None = None
+    description: str | None = None
+    value_type: Literal["STRING", "DOUBLE", "LONG"] | None = None
+    metadata: dict[str, str] | None = None
+
+
+class SequenceRow(BaseModelObject):
+    """Represents a row in a sequence."""
+
+    row_number: int
+    values: list[str | int | float]
+
+
+class SequenceRows(BaseModelObject):
+    """Base class for sequence rows with common fields."""
+
+    rows: list[SequenceRow]
+
+
+class SequenceRowsRequest(SequenceRows, RequestResource):
+    """Request resource for inserting sequence rows."""
+
+    external_id: str
+    columns: list[str]
+
+    def as_id(self) -> ExternalId:
+        return ExternalId(external_id=self.external_id)
+
+
+class SequenceRowsResponse(SequenceRows, ResponseResource[SequenceRowsRequest]):
+    """Response resource for sequence rows.
+
+    Note: The CDF API for sequence rows typically doesn't return the standard
+    created_time/last_updated_time fields in the same way as other resources.
+    The response contains the sequence identification and the row data.
+    """
+
+    external_id: str | None = None
+    id: int
+    columns: list[SequenceColumn]
+
+    def as_request_resource(self) -> SequenceRowsRequest:
+        dumped = self.dump()
+        dumped["columns"] = [col.external_id for col in self.columns]
+        return SequenceRowsRequest.model_validate(dumped, extra="ignore")

cognite_toolkit/_cdf_tk/client/resource_classes/simulator_model.py

@@ -0,0 +1,50 @@
+from typing import Any, Literal
+
+from pydantic import Field
+
+from cognite_toolkit._cdf_tk.client._resource_base import ResponseResource, UpdatableRequestResource
+
+from .identifiers import ExternalId
+
+
+class SimulatorModelRequest(UpdatableRequestResource):
+    # The 'id' field is not part of the request when creating a new resource,
+    # but is needed when updating an existing resource.
+    id: int | None = Field(default=None, exclude=True)
+    external_id: str
+    simulator_external_id: str
+    name: str
+    description: str | None = None
+    data_set_id: int
+    type: str
+
+    def as_id(self) -> ExternalId:
+        return ExternalId(external_id=self.external_id)
+
+    def as_update(self, mode: Literal["patch", "replace"]) -> dict[str, Any]:
+        if self.id is None:
+            raise ValueError("id must be provided to create an update dictionary")
+        return {
+            "id": self.id,
+            "update": {
+                "name": {"set": self.name},
+                **{"description": {"set": self.description} if self.description is not None else {}},
+            },
+        }
+
+
+class SimulatorModelResponse(ResponseResource[SimulatorModelRequest]):
+    id: int
+    external_id: str
+    simulator_external_id: str
+    name: str
+    description: str | None = None
+    data_set_id: int
+    type: str | None = None
+    created_time: int
+    last_updated_time: int
+
+    def as_request_resource(self) -> SimulatorModelRequest:
+        if self.type is None:
+            raise ValueError("Cannot convert SimulatorModelResponse to SimulatorModelRequest when type is None")
+        return SimulatorModelRequest.model_validate(self.dump(), extra="ignore")