cognite-toolkit 0.7.47__tar.gz → 0.7.49__tar.gz

{cognite_toolkit-0.7.47 → cognite_toolkit-0.7.49}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite_toolkit
-Version: 0.7.47
+Version: 0.7.49
 Summary: Official Cognite Data Fusion tool for project templates and configuration deployment
 Author: Cognite AS
 Author-email: Cognite AS <support@cognite.com>

{cognite_toolkit-0.7.47 → cognite_toolkit-0.7.49}/cognite_toolkit/_cdf_tk/apps/_migrate_app.py

@@ -868,13 +868,13 @@ class MigrateApp(typer.Typer):
                 "performed to select the Canvas to migrate."
             ),
         ] = None,
-        skip_on_missing_ref: Annotated[
+        allow_missing_ref: Annotated[
             bool,
             typer.Option(
-                "--skip-on-missing-ref",
-                "-s",
-                help="If set, the migration will skip Canvases that reference resources that have not been migrated to data modeling. "
-                "If not set, the migration will continue but the result will exclude the missing references.",
+                "--allow-missing-ref",
+                "-a",
+                help="If set, the command will migrate Canvases that reference resources that have not been migrated to data modeling. "
+                "If not set, the migration will fail if any referenced resource are missing.",
             ),
         ] = False,
         log_dir: Annotated[
@@ -926,7 +926,7 @@ class MigrateApp(typer.Typer):
             lambda: cmd.migrate(
                 selected=selector,
                 data=CanvasIO(client, exclude_existing_version=True),
-                mapper=CanvasMapper(client, dry_run=dry_run, skip_on_missing_ref=skip_on_missing_ref),
+                mapper=CanvasMapper(client, dry_run=dry_run, skip_on_missing_ref=not allow_missing_ref),
                 log_dir=log_dir,
                 dry_run=dry_run,
                 verbose=verbose,

{cognite_toolkit-0.7.47 → cognite_toolkit-0.7.49}/cognite_toolkit/_cdf_tk/client/_toolkit_client.py

@@ -11,7 +11,7 @@ from cognite_toolkit._cdf_tk.client.api.legacy.extended_files import ExtendedFil
 from cognite_toolkit._cdf_tk.client.api.legacy.extended_functions import ExtendedFunctionsAPI
 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.robotics import RoboticsAPI
+from cognite_toolkit._cdf_tk.client.api.legacy.robotics import RoboticsAPI as RoboticsLegacyAPI
 from cognite_toolkit._cdf_tk.client.http_client import HTTPClient
 
 from .api.assets import AssetsAPI
@@ -26,6 +26,7 @@ from .api.lookup import LookUpGroup
 from .api.migration import MigrationAPI
 from .api.project import ProjectAPI
 from .api.raw import RawAPI
+from .api.robotics import RoboticsAPI
 from .api.search import SearchAPI
 from .api.security_categories import SecurityCategoriesAPI
 from .api.sequences import SequencesAPI
@@ -53,10 +54,11 @@ class ToolAPI:
         self.labels = LabelsAPI(http_client)
         self.filemetadata = FileMetadataAPI(http_client)
         self.raw = RawAPI(http_client)
+        self.robotics = RoboticsAPI(http_client)
         self.security_categories = SecurityCategoriesAPI(http_client)
         self.sequences = SequencesAPI(http_client)
         self.simulators = SimulatorsAPI(http_client)
-        self.three_d = ThreeDAPI(http_client, console)
+        self.three_d = ThreeDAPI(http_client)
         self.timeseries = TimeSeriesAPI(http_client)
         self.transformations = TransformationsAPI(http_client)
         self.workflows = WorkflowsAPI(http_client)
@@ -76,7 +78,7 @@ class ToolkitClient(CogniteClient):
         self.console = console or Console()
         self.tool = ToolAPI(http_client, self.console)
         self.search = SearchAPI(self._config, self._API_VERSION, self)
-        self.robotics = RoboticsAPI(self._config, self._API_VERSION, self)
+        self.robotics = RoboticsLegacyAPI(self._config, self._API_VERSION, self)
         self.dml = DMLAPI(self._config, self._API_VERSION, self)
         self.verify = VerifyAPI(self._config, self._API_VERSION, self)
         self.lookup = LookUpGroup(self._config, self._API_VERSION, self, self.console)
@@ -94,7 +96,7 @@ class ToolkitClient(CogniteClient):
         self.charts = ChartsAPI(self._config, self._API_VERSION, self)
         self.project = ProjectAPI(config=toolkit_config, cognite_client=self)
         self.infield = InfieldAPI(http_client, self.console)
-        self.streams = StreamsAPI(http_client, self.console)
+        self.streams = StreamsAPI(http_client)
 
     @property
     def config(self) -> ToolkitClientConfig:

cognite_toolkit-0.7.49/cognite_toolkit/_cdf_tk/client/api/instances.py

@@ -0,0 +1,139 @@
+from collections.abc import Iterable, Sequence
+from typing import Any, Literal
+
+from cognite_toolkit._cdf_tk.client.cdf_client import CDFResourceAPI, PagedResponse, ResponseItems
+from cognite_toolkit._cdf_tk.client.cdf_client.api import Endpoint
+from cognite_toolkit._cdf_tk.client.http_client import HTTPClient, ItemsSuccessResponse2, SuccessResponse2
+from cognite_toolkit._cdf_tk.client.request_classes.filters import InstanceFilter
+from cognite_toolkit._cdf_tk.client.resource_classes.data_modeling import (
+    InstanceRequest,
+    InstanceResponse,
+    ViewReference,
+)
+from cognite_toolkit._cdf_tk.client.resource_classes.instance_api import TypedInstanceIdentifier
+
+
+class InstancesAPI(CDFResourceAPI[TypedInstanceIdentifier, InstanceRequest, InstanceResponse]):
+    def __init__(self, http_client: HTTPClient) -> None:
+        super().__init__(
+            http_client=http_client,
+            method_endpoint_map={
+                "upsert": Endpoint(method="POST", path="/models/instances", item_limit=1000),
+                "retrieve": Endpoint(method="POST", path="/models/instances/byids", item_limit=1000),
+                "delete": Endpoint(method="POST", path="/models/instances/delete", item_limit=1000),
+                "list": Endpoint(method="POST", path="/models/instances/list", item_limit=1000),
+            },
+        )
+
+    def _validate_page_response(
+        self, response: SuccessResponse2 | ItemsSuccessResponse2
+    ) -> PagedResponse[InstanceResponse]:
+        return PagedResponse[InstanceResponse].model_validate_json(response.body)
+
+    def _validate_response(self, response: SuccessResponse2) -> ResponseItems[TypedInstanceIdentifier]:
+        return ResponseItems[TypedInstanceIdentifier].model_validate_json(response.body)
+
+    def create(self, items: Sequence[InstanceRequest]) -> list[InstanceResponse]:
+        """Create instances in CDF.
+
+        Args:
+            items: List of InstanceRequest objects to create.
+        Returns:
+            List of created InstanceResponse objects.
+        """
+        return self._request_item_response(items, "upsert")
+
+    def retrieve(
+        self, items: Sequence[TypedInstanceIdentifier], source: ViewReference | None = None
+    ) -> list[InstanceResponse]:
+        """Retrieve instances from CDF.
+
+        Args:
+            items: List of ExternalId objects to retrieve.
+            source: Optional ViewReference to specify the source view for the instances.
+        Returns:
+            List of retrieved InstanceResponse objects.
+        """
+        return self._request_item_response(
+            items, method="retrieve", extra_body={"sources": [{"source": source.dump()}]} if source else None
+        )
+
+    def delete(self, items: Sequence[TypedInstanceIdentifier]) -> list[TypedInstanceIdentifier]:
+        """Delete instances from CDF.
+
+        Args:
+            items: List of TypedInstanceIdentifier objects to delete.
+        """
+        response_items: list[TypedInstanceIdentifier] = []
+        for response in self._chunk_requests(items, "delete", self._serialize_items):
+            response_items.extend(self._validate_response(response).items)
+        return response_items
+
+    @staticmethod
+    def _create_sort_body(instance_type: Literal["node", "edge"] | None) -> list[dict]:
+        """We sort by space and externalId to get a stable sort order.
+
+        This is also more performant than sorting by using the default sort, which will sort on
+        internal CDF IDs. This will be slow if you have deleted a lot of instances, as they will be counted.
+        By sorting on space and externalId, we avoid this issue.
+        """
+        instance_type = instance_type or "node"
+        return [
+            {
+                "property": [instance_type, "space"],
+                "direction": "ascending",
+            },
+            {
+                "property": [instance_type, "externalId"],
+                "direction": "ascending",
+            },
+        ]
+
+    @classmethod
+    def _create_body(cls, filter: InstanceFilter | None) -> dict[str, Any]:
+        return {
+            **(filter.model_dump(exclude_none=True) if filter else {}),
+            "sort": cls._create_sort_body(filter.instance_type if filter else "node"),
+        }
+
+    def paginate(
+        self,
+        filter: InstanceFilter | None = None,
+        limit: int = 100,
+        cursor: str | None = None,
+    ) -> PagedResponse[InstanceResponse]:
+        """Iterate over all instances in CDF.
+
+        Args:
+           filter: InstanceFilter to filter instances.
+            limit: Maximum number of items to return.
+            cursor: Cursor for pagination.
+
+        Returns:
+            PagedResponse of InstanceResponse objects.
+        """
+        return self._paginate(
+            cursor=cursor,
+            limit=limit,
+            body=self._create_body(filter),
+        )
+
+    def iterate(self, filter: InstanceFilter | None = None, limit: int = 100) -> Iterable[list[InstanceResponse]]:
+        """Iterate over all instances in CDF.
+
+        Args:
+            filter: InstanceFilter to filter instances.
+            limit: Maximum number of items to return per page.
+
+        Returns:
+            Iterable of lists of InstanceResponse objects.
+        """
+        return self._iterate(limit=limit, body=self._create_body(filter))
+
+    def list(self, filter: InstanceFilter | None = None, limit: int | None = 100) -> list[InstanceResponse]:
+        """List all instances in CDF.
+
+        Returns:
+            List of InstanceResponse objects.
+        """
+        return self._list(limit=limit, body=self._create_body(filter))

cognite_toolkit-0.7.49/cognite_toolkit/_cdf_tk/client/api/location_filters.py

@@ -0,0 +1,177 @@
+from collections.abc import Iterable, Sequence
+
+from cognite_toolkit._cdf_tk.client.cdf_client import CDFResourceAPI, PagedResponse
+from cognite_toolkit._cdf_tk.client.cdf_client.api import Endpoint
+from cognite_toolkit._cdf_tk.client.http_client import (
+    HTTPClient,
+    ItemsSuccessResponse2,
+    RequestMessage2,
+    SuccessResponse2,
+)
+from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import InternalId
+from cognite_toolkit._cdf_tk.client.resource_classes.location_filter import (
+    LocationFilterRequest,
+    LocationFilterResponse,
+)
+from cognite_toolkit._cdf_tk.utils.collection import chunker_sequence
+
+
+class LocationFiltersAPI(CDFResourceAPI[InternalId, LocationFilterRequest, LocationFilterResponse]):
+    """API for managing Location Filters using the CDFResourceAPI pattern.
+
+    This API manages location filter configurations at:
+    /apps/v1/projects/{project}/storage/config/locationfilters
+    """
+
+    BASE_PATH = "/storage/config/locationfilters"
+
+    def __init__(self, http_client: HTTPClient) -> None:
+        super().__init__(
+            http_client=http_client,
+            method_endpoint_map={
+                "create": Endpoint(method="POST", path=self.BASE_PATH, item_limit=1),
+                "retrieve": Endpoint(method="POST", path=f"{self.BASE_PATH}/byids", item_limit=1000),
+                "update": Endpoint(method="PUT", path=f"{self.BASE_PATH}/{{id}}", item_limit=1),
+                "delete": Endpoint(method="DELETE", path=f"{self.BASE_PATH}/{{id}}", item_limit=1),
+                "list": Endpoint(method="POST", path=f"{self.BASE_PATH}/list", item_limit=1000),
+            },
+        )
+
+    def _make_url(self, path: str = "") -> str:
+        """Create the full URL for this resource endpoint using the apps URL format."""
+        return self._http_client.config.create_app_url(path)
+
+    def _validate_page_response(
+        self, response: SuccessResponse2 | ItemsSuccessResponse2
+    ) -> PagedResponse[LocationFilterResponse]:
+        return PagedResponse[LocationFilterResponse].model_validate_json(response.body)
+
+    def create(self, items: Sequence[LocationFilterRequest]) -> list[LocationFilterResponse]:
+        """Create a new location filter.
+
+        Args:
+            items: The location filter to create.
+
+        Returns:
+            The created location filter.
+        """
+        endpoint = self._method_endpoint_map["create"]
+        results: list[LocationFilterResponse] = []
+        for item in items:
+            request = RequestMessage2(
+                endpoint_url=self._make_url(endpoint.path),
+                method=endpoint.method,
+                body_content=item.model_dump(mode="json", by_alias=True),
+            )
+            result = self._http_client.request_single_retries(request)
+            response = result.get_success_or_raise()
+            results.append(LocationFilterResponse.model_validate_json(response.body))
+        return results
+
+    def retrieve(self, items: Sequence[InternalId]) -> list[LocationFilterResponse]:
+        """Retrieve a single location filter by ID.
+
+        Args:
+            items: The ID of the location filter to retrieve.
+
+        Returns:
+            The retrieved location filter.
+        """
+        endpoint = self._method_endpoint_map["retrieve"]
+        results: list[LocationFilterResponse] = []
+        for chunk in chunker_sequence(items, endpoint.item_limit):
+            request = RequestMessage2(
+                endpoint_url=self._make_url(endpoint.path),
+                method=endpoint.method,
+                body_content={"ids": [item.id for item in chunk]},
+            )
+            result = self._http_client.request_single_retries(request)
+            response = result.get_success_or_raise()
+            results.extend(self._validate_page_response(response).items)
+        return results
+
+    def update(self, items: Sequence[LocationFilterRequest]) -> list[LocationFilterResponse]:
+        """Update an existing location filter.
+
+        Args:
+            items: The updated location filter data.
+
+        Returns:
+            The updated location filter.
+        """
+        endpoint = self._method_endpoint_map["update"]
+        results: list[LocationFilterResponse] = []
+        for item in items:
+            if item.id is None:
+                raise ValueError("Item must have an ID for update operation.")
+            request = RequestMessage2(
+                endpoint_url=self._make_url(endpoint.path.format(id=item.id)),
+                method=endpoint.method,
+                body_content=item.model_dump(mode="json", by_alias=True),
+            )
+            result = self._http_client.request_single_retries(request)
+            response = result.get_success_or_raise()
+            parsed = LocationFilterResponse.model_validate_json(response.body)
+            parsed.id = item.id
+            results.append(parsed)
+        return results
+
+    def delete(self, items: Sequence[InternalId]) -> list[LocationFilterResponse]:
+        """Delete a location filter.
+
+        Args:
+            items: The ID of the location filter to delete.
+
+        Returns:
+            list[LocationFilterResponse]: The deleted location filters.
+        """
+        endpoint = self._method_endpoint_map["delete"]
+        results: list[LocationFilterResponse] = []
+        for item in items:
+            request = RequestMessage2(
+                endpoint_url=self._make_url(endpoint.path.format(id=item.id)),
+                method=endpoint.method,
+            )
+            result = self._http_client.request_single_retries(request)
+            response = result.get_success_or_raise()
+            results.append(LocationFilterResponse.model_validate_json(response.body))
+        return results
+
+    def paginate(
+        self,
+        flat: bool = True,
+    ) -> PagedResponse[LocationFilterResponse]:
+        """Get a single page of location filters.
+
+        Args:
+            flat: Whether to return a flat list (default True).
+
+        Returns:
+            PagedResponse of LocationFilterResponse objects.
+        """
+        return self._paginate(cursor=None, limit=100, body={"flat": flat})
+
+    def iterate(
+        self,
+        flat: bool = True,
+    ) -> Iterable[list[LocationFilterResponse]]:
+        """Iterate over all location filters.
+
+        Args:
+            flat: Whether to return a flat list (default True).
+
+        Returns:
+            Iterable of lists of LocationFilterResponse objects.
+        """
+        return self._iterate(limit=None, body={"flat": flat})
+
+    def list(self, flat: bool = True) -> list[LocationFilterResponse]:
+        """List all location filters.
+
+        Args:
+            flat: Whether to return a flat list (default True).
+
+        Returns:
+            List of LocationFilterResponse objects.
+        """
+        return self._list(limit=None, body={"flat": flat})

{cognite_toolkit-0.7.47 → cognite_toolkit-0.7.49}/cognite_toolkit/_cdf_tk/client/api/raw.py

@@ -128,7 +128,7 @@ class RawTablesAPI(CDFResourceAPI[RAWTable, RAWTable, RAWTable]):
             List of created RAWTable objects.
         """
         result: list[RAWTable] = []
-        for db_name, group in self._group_items_by_text_field(items, "db_name").items():
+        for (db_name,), group in self._group_items_by_text_field(items, "db_name").items():
             if not db_name:
                 raise ValueError("db_name must be set on all RAWTable items for creation.")
             endpoint = f"/raw/dbs/{db_name}/tables"
@@ -145,7 +145,7 @@ class RawTablesAPI(CDFResourceAPI[RAWTable, RAWTable, RAWTable]):
         Args:
             items: List of RAWTable objects to delete.
         """
-        for db_name, group in self._group_items_by_text_field(items, "db_name").items():
+        for (db_name,), group in self._group_items_by_text_field(items, "db_name").items():
             if not db_name:
                 raise ValueError("db_name must be set on all RAWTable items for deletion.")
             endpoint = f"/raw/dbs/{db_name}/tables/delete"

cognite_toolkit-0.7.49/cognite_toolkit/_cdf_tk/client/api/robotics.py

@@ -0,0 +1,19 @@
+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 cognite_toolkit._cdf_tk.client.http_client import HTTPClient
+
+
+class RoboticsAPI:
+    """API for Robotics resources."""
+
+    def __init__(self, http_client: HTTPClient) -> None:
+        self.capabilities = CapabilitiesAPI(http_client)
+        self.data_postprocessing = DataPostProcessingAPI(http_client)
+        self.frames = FramesAPI(http_client)
+        self.locations = LocationsAPI(http_client)
+        self.maps = MapsAPI(http_client)
+        self.robots = RobotsAPI(http_client)

cognite_toolkit-0.7.49/cognite_toolkit/_cdf_tk/client/api/robotics_capabilities.py

@@ -0,0 +1,127 @@
+from collections.abc import Iterable, Sequence
+from typing import Literal
+
+from cognite_toolkit._cdf_tk.client.cdf_client import CDFResourceAPI, PagedResponse, ResponseItems
+from cognite_toolkit._cdf_tk.client.cdf_client.api import Endpoint
+from cognite_toolkit._cdf_tk.client.http_client import HTTPClient, ItemsSuccessResponse2, SuccessResponse2
+from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import ExternalId
+from cognite_toolkit._cdf_tk.client.resource_classes.robotics._capability import (
+    RobotCapabilityRequest,
+    RobotCapabilityResponse,
+)
+
+
+class CapabilitiesAPI(CDFResourceAPI[ExternalId, RobotCapabilityRequest, RobotCapabilityResponse]):
+    """API for managing Capability resources in CDF."""
+
+    def __init__(self, http_client: HTTPClient) -> None:
+        super().__init__(
+            http_client=http_client,
+            method_endpoint_map={
+                "create": Endpoint(
+                    method="POST", path="/robotics/capabilities", item_limit=1000, concurrency_max_workers=1
+                ),
+                "retrieve": Endpoint(
+                    method="POST", path="/robotics/capabilities/byids", item_limit=1000, concurrency_max_workers=1
+                ),
+                "update": Endpoint(
+                    method="POST", path="/robotics/capabilities/update", item_limit=1000, concurrency_max_workers=1
+                ),
+                "delete": Endpoint(
+                    method="POST", path="/robotics/capabilities/delete", item_limit=1000, concurrency_max_workers=1
+                ),
+                "list": Endpoint(method="GET", path="/robotics/capabilities", item_limit=1000),
+            },
+            disable_gzip=True,
+        )
+
+    def _validate_page_response(
+        self, response: SuccessResponse2 | ItemsSuccessResponse2
+    ) -> PagedResponse[RobotCapabilityResponse]:
+        return PagedResponse[RobotCapabilityResponse].model_validate_json(response.body)
+
+    def _reference_response(self, response: SuccessResponse2) -> ResponseItems[ExternalId]:
+        return ResponseItems[ExternalId].model_validate_json(response.body)
+
+    def create(self, items: Sequence[RobotCapabilityRequest]) -> list[RobotCapabilityResponse]:
+        """Create capabilities in CDF.
+
+        Args:
+            items: List of RobotCapabilityRequest objects to create.
+        Returns:
+            List of created RobotCapabilityResponse objects.
+        """
+        return self._request_item_response(items, "create")
+
+    def retrieve(self, items: Sequence[ExternalId]) -> list[RobotCapabilityResponse]:
+        """Retrieve capabilities from CDF.
+
+        Args:
+            items: List of ExternalId objects to retrieve.
+        Returns:
+            List of retrieved RobotCapabilityResponse objects.
+        """
+        return self._request_item_response(items, method="retrieve")
+
+    def update(
+        self, items: Sequence[RobotCapabilityRequest], mode: Literal["patch", "replace"] = "replace"
+    ) -> list[RobotCapabilityResponse]:
+        """Update capabilities in CDF.
+
+        Args:
+            items: List of RobotCapabilityRequest objects to update.
+            mode: Update mode, either "patch" or "replace".
+
+        Returns:
+            List of updated RobotCapabilityResponse objects.
+        """
+        return self._update(items, mode=mode)
+
+    def delete(self, items: Sequence[ExternalId]) -> None:
+        """Delete capabilities from CDF.
+
+        Args:
+            items: List of ExternalId objects to delete.
+        """
+        self._request_no_response(items, "delete")
+
+    def paginate(
+        self,
+        limit: int = 100,
+        cursor: str | None = None,
+    ) -> PagedResponse[RobotCapabilityResponse]:
+        """Paginate over capabilities in CDF.
+
+        Args:
+            limit: Maximum number of items per page.
+            cursor: Cursor for pagination.
+
+        Returns:
+            PagedResponse of RobotCapabilityResponse objects.
+        """
+        return self._paginate(cursor=cursor, limit=limit)
+
+    def iterate(
+        self,
+        limit: int | None = 100,
+    ) -> Iterable[list[RobotCapabilityResponse]]:
+        """Iterate over all capabilities in CDF.
+
+        Args:
+            limit: Maximum number of items to return. None returns all.
+
+        Returns:
+            Iterable of lists of RobotCapabilityResponse objects.
+        """
+        return self._iterate(limit=limit)
+
+    def list(self, limit: int | None = 100) -> list[RobotCapabilityResponse]:
+        """List all capabilities in CDF.
+
+        Args:
+            limit: Maximum number of items to return. None returns all.
+
+        Returns:
+            List of RobotCapabilityResponse objects.
+        """
+        return self._list(limit=limit)