cognite-toolkit 0.7.71__py3-none-any.whl → 0.7.73__py3-none-any.whl

cognite_toolkit/_cdf_tk/builders/_raw.py

@@ -3,7 +3,7 @@ from collections.abc import Callable, Iterable, Sequence
 from typing import Any
 
 from cognite_toolkit._cdf_tk.builders import Builder
-from cognite_toolkit._cdf_tk.client.resource_classes.legacy.raw import RawDatabase
+from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import RawDatabaseId
 from cognite_toolkit._cdf_tk.cruds import RawDatabaseCRUD, RawTableCRUD, ResourceCRUD
 from cognite_toolkit._cdf_tk.data_classes import (
     BuildDestinationFile,
@@ -40,7 +40,7 @@ class RawBuilder(Builder):
                     entry_by_loader[RawDatabaseCRUD].append(item)
                 else:
                     entry_by_loader[RawTableCRUD].append(item)
-                    db_item = RawDatabaseCRUD.dump_id(RawDatabase(table_id.db_name))
+                    db_item = RawDatabaseCRUD.dump_id(RawDatabaseId(name=table_id.db_name))
                     hashable_db_item = tuple(db_item.items())
                     if hashable_db_item not in seen_databases:
                         seen_databases.add(hashable_db_item)

cognite_toolkit/_cdf_tk/client/_toolkit_client.py

@@ -11,7 +11,6 @@ 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 as RoboticsLegacyAPI
 from cognite_toolkit._cdf_tk.client.http_client import HTTPClient
 
 from .api.assets import AssetsAPI
@@ -80,7 +79,6 @@ 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 = 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)

cognite_toolkit/_cdf_tk/client/api/raw.py

@@ -2,10 +2,16 @@ from collections.abc import Iterable, Sequence
 
 from cognite_toolkit._cdf_tk.client.cdf_client import CDFResourceAPI, Endpoint, PagedResponse, ResponseItems
 from cognite_toolkit._cdf_tk.client.http_client import HTTPClient, ItemsSuccessResponse, SuccessResponse
-from cognite_toolkit._cdf_tk.client.resource_classes.raw import RAWDatabase, RAWTable
+from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import RawDatabaseId, RawTableId
+from cognite_toolkit._cdf_tk.client.resource_classes.raw import (
+    RAWDatabaseRequest,
+    RAWDatabaseResponse,
+    RAWTableRequest,
+    RAWTableResponse,
+)
 
 
-class RawDatabasesAPI(CDFResourceAPI[RAWDatabase, RAWDatabase, RAWDatabase]):
+class RawDatabasesAPI(CDFResourceAPI[RawDatabaseId, RAWDatabaseRequest, RAWDatabaseResponse]):
     """API for managing RAW databases in CDF.
 
     This API provides methods to create, list, and delete RAW databases.
@@ -21,13 +27,15 @@ class RawDatabasesAPI(CDFResourceAPI[RAWDatabase, RAWDatabase, RAWDatabase]):
             },
         )
 
-    def _validate_page_response(self, response: SuccessResponse | ItemsSuccessResponse) -> PagedResponse[RAWDatabase]:
-        return PagedResponse[RAWDatabase].model_validate_json(response.body)
+    def _validate_page_response(
+        self, response: SuccessResponse | ItemsSuccessResponse
+    ) -> PagedResponse[RAWDatabaseResponse]:
+        return PagedResponse[RAWDatabaseResponse].model_validate_json(response.body)
 
-    def _reference_response(self, response: SuccessResponse) -> ResponseItems[RAWDatabase]:
-        return ResponseItems[RAWDatabase].model_validate_json(response.body)
+    def _reference_response(self, response: SuccessResponse) -> ResponseItems[RAWDatabaseResponse]:
+        return ResponseItems[RAWDatabaseResponse].model_validate_json(response.body)
 
-    def create(self, items: Sequence[RAWDatabase]) -> list[RAWDatabase]:
+    def create(self, items: Sequence[RAWDatabaseRequest]) -> list[RAWDatabaseResponse]:
         """Create databases in CDF.
 
         Args:
@@ -38,20 +46,20 @@ class RawDatabasesAPI(CDFResourceAPI[RAWDatabase, RAWDatabase, RAWDatabase]):
         """
         return self._request_item_response(list(items), "create")
 
-    def delete(self, items: Sequence[RAWDatabase], recursive: bool = False) -> None:
+    def delete(self, items: Sequence[RawDatabaseId], recursive: bool = False) -> None:
         """Delete databases from CDF.
 
         Args:
             items: List of RAWDatabase objects to delete.
             recursive: Whether to delete tables within the database recursively.
         """
-        self._request_no_response(list(items), "delete", extra_body={"recursive": recursive})
+        self._request_no_response(items, "delete", extra_body={"recursive": recursive})
 
     def paginate(
         self,
         limit: int = 100,
         cursor: str | None = None,
-    ) -> PagedResponse[RAWDatabase]:
+    ) -> PagedResponse[RAWDatabaseResponse]:
         """Iterate over all databases in CDF.
 
         Args:
@@ -66,7 +74,7 @@ class RawDatabasesAPI(CDFResourceAPI[RAWDatabase, RAWDatabase, RAWDatabase]):
     def iterate(
         self,
         limit: int = 100,
-    ) -> Iterable[list[RAWDatabase]]:
+    ) -> Iterable[list[RAWDatabaseResponse]]:
         """Iterate over all databases in CDF.
 
         Args:
@@ -77,7 +85,7 @@ class RawDatabasesAPI(CDFResourceAPI[RAWDatabase, RAWDatabase, RAWDatabase]):
         """
         return self._iterate(limit=limit)
 
-    def list(self, limit: int | None = None) -> list[RAWDatabase]:
+    def list(self, limit: int | None = None) -> list[RAWDatabaseResponse]:
         """List all databases in CDF.
 
         Args:
@@ -89,7 +97,7 @@ class RawDatabasesAPI(CDFResourceAPI[RAWDatabase, RAWDatabase, RAWDatabase]):
         return self._list(limit=limit)
 
 
-class RawTablesAPI(CDFResourceAPI[RAWTable, RAWTable, RAWTable]):
+class RawTablesAPI(CDFResourceAPI[RawTableId, RAWTableRequest, RAWTableResponse]):
     """API for managing RAW tables in CDF.
 
     This API provides methods to create, list, and delete RAW tables within a database.
@@ -109,15 +117,17 @@ class RawTablesAPI(CDFResourceAPI[RAWTable, RAWTable, RAWTable]):
             },
         )
 
-    def _validate_page_response(self, response: SuccessResponse | ItemsSuccessResponse) -> PagedResponse[RAWTable]:
+    def _validate_page_response(
+        self, response: SuccessResponse | ItemsSuccessResponse
+    ) -> PagedResponse[RAWTableResponse]:
         """Parse a page response. Note: db_name must be injected separately."""
-        return PagedResponse[RAWTable].model_validate_json(response.body)
+        return PagedResponse[RAWTableResponse].model_validate_json(response.body)
 
-    def _reference_response(self, response: SuccessResponse) -> ResponseItems[RAWTable]:
+    def _reference_response(self, response: SuccessResponse) -> ResponseItems[RAWTableResponse]:
         """Parse a reference response. Note: db_name must be injected separately."""
-        return ResponseItems[RAWTable].model_validate_json(response.body)
+        return ResponseItems[RAWTableResponse].model_validate_json(response.body)
 
-    def create(self, items: Sequence[RAWTable], ensure_parent: bool = False) -> list[RAWTable]:
+    def create(self, items: Sequence[RAWTableRequest], ensure_parent: bool = False) -> list[RAWTableResponse]:
         """Create tables in a database in CDF.
 
         Args:
@@ -127,7 +137,7 @@ class RawTablesAPI(CDFResourceAPI[RAWTable, RAWTable, RAWTable]):
         Returns:
             List of created RAWTable objects.
         """
-        result: list[RAWTable] = []
+        result: list[RAWTableResponse] = []
         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.")
@@ -136,10 +146,11 @@ class RawTablesAPI(CDFResourceAPI[RAWTable, RAWTable, RAWTable]):
                 group, "create", params={"ensureParent": ensure_parent}, endpoint=endpoint
             )
             for table in created:
-                result.append(RAWTable(db_name=db_name, name=table.name))
+                table.db_name = db_name
+                result.append(table)
         return result
 
-    def delete(self, items: Sequence[RAWTable]) -> None:
+    def delete(self, items: Sequence[RawTableId]) -> None:
         """Delete tables from a database in CDF.
 
         Args:
@@ -156,7 +167,7 @@ class RawTablesAPI(CDFResourceAPI[RAWTable, RAWTable, RAWTable]):
         db_name: str,
         limit: int = 100,
         cursor: str | None = None,
-    ) -> PagedResponse[RAWTable]:
+    ) -> PagedResponse[RAWTableResponse]:
         """Iterate over all tables in a database in CDF.
 
         Args:
@@ -167,13 +178,16 @@ class RawTablesAPI(CDFResourceAPI[RAWTable, RAWTable, RAWTable]):
         Returns:
             PagedResponse of RAWTable objects.
         """
-        return self._paginate(cursor=cursor, limit=limit, endpoint_path=f"/raw/dbs/{db_name}/tables")
+        page = self._paginate(cursor=cursor, limit=limit, endpoint_path=f"/raw/dbs/{db_name}/tables")
+        for table in page.items:
+            table.db_name = db_name
+        return page
 
     def iterate(
         self,
         db_name: str,
         limit: int = 100,
-    ) -> Iterable[list[RAWTable]]:
+    ) -> Iterable[list[RAWTableResponse]]:
         """Iterate over all tables in a database in CDF.
 
         Args:
@@ -183,9 +197,12 @@ class RawTablesAPI(CDFResourceAPI[RAWTable, RAWTable, RAWTable]):
         Returns:
             Iterable of lists of RAWTable objects.
         """
-        return self._iterate(limit=limit, endpoint_path=f"/raw/dbs/{db_name}/tables")
+        for table in self._iterate(limit=limit, endpoint_path=f"/raw/dbs/{db_name}/tables"):
+            for t in table:
+                t.db_name = db_name
+            yield table
 
-    def list(self, db_name: str, limit: int | None = None) -> list[RAWTable]:
+    def list(self, db_name: str, limit: int | None = None) -> list[RAWTableResponse]:
         """List all tables in a database in CDF.
 
         Args:
@@ -195,7 +212,10 @@ class RawTablesAPI(CDFResourceAPI[RAWTable, RAWTable, RAWTable]):
         Returns:
             List of RAWTable objects.
         """
-        return self._list(limit, endpoint_path=f"/raw/dbs/{db_name}/tables")
+        listed = self._list(limit, endpoint_path=f"/raw/dbs/{db_name}/tables")
+        for table in listed:
+            table.db_name = db_name
+        return listed
 
 
 class RawAPI:

cognite_toolkit/_cdf_tk/client/api/robotics_capabilities.py

@@ -53,7 +53,7 @@ class CapabilitiesAPI(CDFResourceAPI[ExternalId, RobotCapabilityRequest, RobotCa
         """
         return self._request_item_response(items, "create")
 
-    def retrieve(self, items: Sequence[ExternalId]) -> list[RobotCapabilityResponse]:
+    def retrieve(self, items: Sequence[ExternalId], ignore_unknown_ids: bool = False) -> list[RobotCapabilityResponse]:
         """Retrieve capabilities from CDF.
 
         Args:
@@ -61,6 +61,8 @@ class CapabilitiesAPI(CDFResourceAPI[ExternalId, RobotCapabilityRequest, RobotCa
         Returns:
             List of retrieved RobotCapabilityResponse objects.
         """
+        if ignore_unknown_ids:
+            return self._request_item_split_retries(items, method="retrieve")
         return self._request_item_response(items, method="retrieve")
 
     def update(
@@ -77,13 +79,17 @@ class CapabilitiesAPI(CDFResourceAPI[ExternalId, RobotCapabilityRequest, RobotCa
         """
         return self._update(items, mode=mode)
 
-    def delete(self, items: Sequence[ExternalId]) -> None:
+    def delete(self, items: Sequence[ExternalId], ignore_unknown_ids: bool = False) -> None:
         """Delete capabilities from CDF.
 
         Args:
             items: List of ExternalId objects to delete.
+            ignore_unknown_ids: If True, ignores unknown IDs during deletion.
         """
-        self._request_no_response(items, "delete")
+        if ignore_unknown_ids:
+            self._request_item_split_retries_no_response(items, "delete")
+        else:
+            self._request_no_response(items, "delete")
 
     def paginate(
         self,

cognite_toolkit/_cdf_tk/client/api/robotics_data_postprocessing.py

@@ -64,14 +64,19 @@ class DataPostProcessingAPI(
         """
         return self._request_item_response(items, "create")
 
-    def retrieve(self, items: Sequence[ExternalId]) -> list[RobotDataPostProcessingResponse]:
+    def retrieve(
+        self, items: Sequence[ExternalId], ignore_unknown_ids: bool = False
+    ) -> list[RobotDataPostProcessingResponse]:
         """Retrieve data post-processing configurations from CDF.
 
         Args:
             items: List of ExternalId objects to retrieve.
+            ignore_unknown_ids: If True, ignores unknown IDs during retrieval.
         Returns:
             List of retrieved RobotDataPostProcessingResponse objects.
         """
+        if ignore_unknown_ids:
+            return self._request_item_split_retries(items, method="retrieve")
         return self._request_item_response(items, method="retrieve")
 
     def update(
@@ -88,13 +93,17 @@ class DataPostProcessingAPI(
         """
         return self._update(items, mode=mode)
 
-    def delete(self, items: Sequence[ExternalId]) -> None:
+    def delete(self, items: Sequence[ExternalId], ignore_unknown_ids: bool = False) -> None:
         """Delete data post-processing configurations from CDF.
 
         Args:
             items: List of ExternalId objects to delete.
+            ignore_unknown_ids: If True, ignores unknown IDs during deletion.
         """
-        self._request_no_response(items, "delete")
+        if ignore_unknown_ids:
+            self._request_item_split_retries_no_response(items, "delete")
+        else:
+            self._request_no_response(items, "delete")
 
     def paginate(
         self,

cognite_toolkit/_cdf_tk/client/api/robotics_frames.py

@@ -48,14 +48,17 @@ class FramesAPI(CDFResourceAPI[ExternalId, RobotFrameRequest, RobotFrameResponse
         """
         return self._request_item_response(items, "create")
 
-    def retrieve(self, items: Sequence[ExternalId]) -> list[RobotFrameResponse]:
+    def retrieve(self, items: Sequence[ExternalId], ignore_unknown_ids: bool = False) -> list[RobotFrameResponse]:
         """Retrieve frames from CDF.
 
         Args:
             items: List of ExternalId objects to retrieve.
+            ignore_unknown_ids: If True, ignores unknown IDs during retrieval.
         Returns:
             List of retrieved RobotFrameResponse objects.
         """
+        if ignore_unknown_ids:
+            return self._request_item_split_retries(items, method="retrieve")
         return self._request_item_response(items, method="retrieve")
 
     def update(
@@ -72,13 +75,17 @@ class FramesAPI(CDFResourceAPI[ExternalId, RobotFrameRequest, RobotFrameResponse
         """
         return self._update(items, mode=mode)
 
-    def delete(self, items: Sequence[ExternalId]) -> None:
+    def delete(self, items: Sequence[ExternalId], ignore_unknown_ids: bool = False) -> None:
         """Delete frames from CDF.
 
         Args:
             items: List of ExternalId objects to delete.
+            ignore_unknown_ids: If True, ignores unknown IDs during deletion.
         """
-        self._request_no_response(items, "delete")
+        if ignore_unknown_ids:
+            self._request_item_split_retries_no_response(items, "delete")
+        else:
+            self._request_no_response(items, "delete")
 
     def paginate(
         self,

cognite_toolkit/_cdf_tk/client/api/robotics_locations.py

@@ -53,14 +53,17 @@ class LocationsAPI(CDFResourceAPI[ExternalId, RobotLocationRequest, RobotLocatio
         """
         return self._request_item_response(items, "create")
 
-    def retrieve(self, items: Sequence[ExternalId]) -> list[RobotLocationResponse]:
+    def retrieve(self, items: Sequence[ExternalId], ignore_unknown_ids: bool = False) -> list[RobotLocationResponse]:
         """Retrieve locations from CDF.
 
         Args:
             items: List of ExternalId objects to retrieve.
+            ignore_unknown_ids: If True, ignores unknown IDs during retrieval.
         Returns:
             List of retrieved RobotLocationResponse objects.
         """
+        if ignore_unknown_ids:
+            return self._request_item_split_retries(items, method="retrieve")
         return self._request_item_response(items, method="retrieve")
 
     def update(
@@ -77,13 +80,17 @@ class LocationsAPI(CDFResourceAPI[ExternalId, RobotLocationRequest, RobotLocatio
         """
         return self._update(items, mode=mode)
 
-    def delete(self, items: Sequence[ExternalId]) -> None:
+    def delete(self, items: Sequence[ExternalId], ignore_unknown_ids: bool = False) -> None:
         """Delete locations from CDF.
 
         Args:
             items: List of ExternalId objects to delete.
+            ignore_unknown_ids: If True, ignores unknown IDs during deletion.
         """
-        self._request_no_response(items, "delete")
+        if ignore_unknown_ids:
+            self._request_item_split_retries_no_response(items, "delete")
+        else:
+            self._request_no_response(items, "delete")
 
     def paginate(
         self,

cognite_toolkit/_cdf_tk/client/api/robotics_maps.py

@@ -48,14 +48,17 @@ class MapsAPI(CDFResourceAPI[ExternalId, RobotMapRequest, RobotMapResponse]):
         """
         return self._request_item_response(items, "create")
 
-    def retrieve(self, items: Sequence[ExternalId]) -> list[RobotMapResponse]:
+    def retrieve(self, items: Sequence[ExternalId], ignore_unknown_ids: bool = False) -> list[RobotMapResponse]:
         """Retrieve maps from CDF.
 
         Args:
             items: List of ExternalId objects to retrieve.
+            ignore_unknown_ids: If True, ignores unknown IDs during retrieval.
         Returns:
             List of retrieved RobotMapResponse objects.
         """
+        if ignore_unknown_ids:
+            return self._request_item_split_retries(items, method="retrieve")
         return self._request_item_response(items, method="retrieve")
 
     def update(
@@ -72,13 +75,17 @@ class MapsAPI(CDFResourceAPI[ExternalId, RobotMapRequest, RobotMapResponse]):
         """
         return self._update(items, mode=mode)
 
-    def delete(self, items: Sequence[ExternalId]) -> None:
+    def delete(self, items: Sequence[ExternalId], ignore_unknown_ids: bool = False) -> None:
         """Delete maps from CDF.
 
         Args:
             items: List of ExternalId objects to delete.
+            ignore_unknown_ids: If True, ignores unknown IDs during deletion.
         """
-        self._request_no_response(items, "delete")
+        if ignore_unknown_ids:
+            self._request_item_split_retries_no_response(items, "delete")
+        else:
+            self._request_no_response(items, "delete")
 
     def paginate(
         self,

cognite_toolkit/_cdf_tk/client/api/robotics_robots.py

@@ -46,14 +46,17 @@ class RobotsAPI(CDFResourceAPI[DataSetId, RobotRequest, RobotResponse]):
         """
         return self._request_item_response(items, "create")
 
-    def retrieve(self, items: Sequence[DataSetId]) -> list[RobotResponse]:
+    def retrieve(self, items: Sequence[DataSetId], ignore_unknown_ids: bool = False) -> list[RobotResponse]:
         """Retrieve robots from CDF.
 
         Args:
             items: List of DataSetId objects to retrieve.
+            ignore_unknown_ids: If True, ignores unknown IDs during retrieval.
         Returns:
             List of retrieved RobotResponse objects.
         """
+        if ignore_unknown_ids:
+            return self._request_item_split_retries(items, method="retrieve")
         return self._request_item_response(items, method="retrieve")
 
     def update(
@@ -70,13 +73,17 @@ class RobotsAPI(CDFResourceAPI[DataSetId, RobotRequest, RobotResponse]):
         """
         return self._update(items, mode=mode)
 
-    def delete(self, items: Sequence[DataSetId]) -> None:
+    def delete(self, items: Sequence[DataSetId], ignore_unknown_ids: bool = False) -> None:
         """Delete robots from CDF.
 
         Args:
             items: List of DataSetId objects to delete.
+            ignore_unknown_ids: If True, ignores unknown IDs during deletion.
         """
-        self._request_no_response(items, "delete")
+        if ignore_unknown_ids:
+            self._request_item_split_retries_no_response(items, "delete")
+        else:
+            self._request_no_response(items, "delete")
 
     def paginate(
         self,

cognite_toolkit/_cdf_tk/client/http_client/_client.py

@@ -65,7 +65,7 @@ class HTTPClient:
         pool_connections: int = 10,
         pool_maxsize: int = 20,
         retry_status_codes: Set[int] = frozenset({408, 429, 502, 503, 504}),
-        split_items_status_codes: Set[int] = frozenset({400, 408, 409, 422, 502, 503, 504}),
+        split_items_status_codes: Set[int] = frozenset({400, 404, 408, 409, 422, 502, 503, 504}),
         console: Console | None = None,
     ):
         self.config = config

cognite_toolkit/_cdf_tk/client/http_client/_data_classes.py

@@ -23,6 +23,7 @@ class HTTPResult(BaseModel):
                 f"Request failed with status code {self.status_code}: {self.error.message}",
                 missing=self.error.missing,  # type: ignore[arg-type]
                 duplicated=self.error.duplicated,  # type: ignore[arg-type]
+                code=self.error.code,
             )
         elif isinstance(self, FailedRequest):
             raise ToolkitAPIError(f"Request failed with error: {self.error}")

cognite_toolkit/_cdf_tk/client/http_client/_exception.py

@@ -5,9 +5,14 @@ class ToolkitAPIError(Exception):
     """Base class for all exceptions raised by the Cognite Toolkit API client."""
 
     def __init__(
-        self, message: str, missing: list[dict[str, Any]] | None = None, duplicated: list[dict[str, Any]] | None = None
+        self,
+        message: str,
+        missing: list[dict[str, Any]] | None = None,
+        duplicated: list[dict[str, Any]] | None = None,
+        code: int | None = None,
     ) -> None:
         super().__init__(message)
         self.message = message
         self.missing = missing
         self.duplicated = duplicated
+        self.code = code

cognite_toolkit/_cdf_tk/client/resource_classes/identifiers.py

@@ -1,7 +1,7 @@
 from collections.abc import Sequence
 from typing import Annotated, Any, Literal
 
-from pydantic import Field, model_serializer, model_validator
+from pydantic import AliasChoices, Field, model_serializer, model_validator
 
 from cognite_toolkit._cdf_tk.client._resource_base import Identifier
 
@@ -65,6 +65,31 @@ class NameId(Identifier):
         return f"name='{self.name}'"
 
 
+class RawDatabaseId(Identifier):
+    name: str = Field(alias="name", validation_alias=AliasChoices("dbName", "name"))
+
+    def __str__(self) -> str:
+        return f"name='{self.name}'"
+
+    def dump(self, camel_case: bool = True, exclude_extra: bool = False) -> dict[str, Any]:
+        """Dump the resource to a dictionary.
+
+        Args:
+            camel_case (bool): Will be ignored. Included for compatibility.
+            exclude_extra (bool): Will be ignored. Included for compatibility.
+
+        """
+        return self.model_dump(mode="json", by_alias=False)
+
+
+class RawTableId(Identifier):
+    name: str
+    db_name: str
+
+    def __str__(self) -> str:
+        return f"dbName='{self.db_name}', name='{self.name}'"
+
+
 class WorkflowVersionId(Identifier):
     workflow_external_id: str
     version: str

cognite_toolkit/_cdf_tk/client/resource_classes/raw.py

@@ -1,12 +1,13 @@
 import sys
+from typing import Any
 
 from pydantic import Field
 
 from cognite_toolkit._cdf_tk.client._resource_base import (
-    Identifier,
     RequestResource,
     ResponseResource,
 )
+from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import RawDatabaseId, RawTableId
 
 if sys.version_info >= (3, 11):
     from typing import Self
@@ -14,31 +15,84 @@ else:
     from typing_extensions import Self
 
 
-class RAWDatabase(RequestResource, Identifier, ResponseResource["RAWDatabase"]):
+class RAWDatabaseRequest(RequestResource):
+    name: str = Field(alias="dbName")
+
+    def as_id(self) -> RawDatabaseId:
+        return RawDatabaseId(name=self.name)
+
+    # Override dump to always use by_alias=False since the API expects name='...'
+    def dump(self, camel_case: bool = True, exclude_extra: bool = False) -> dict[str, Any]:
+        """Dump the resource to a dictionary.
+
+        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.
+
+        """
+        if exclude_extra:
+            return self.model_dump(
+                mode="json",
+                by_alias=False,
+                exclude_unset=True,
+                exclude=set(self.__pydantic_extra__) if self.__pydantic_extra__ else None,
+            )
+        return self.model_dump(mode="json", by_alias=False, exclude_unset=True)
+
+
+class RAWDatabaseResponse(ResponseResource[RAWDatabaseRequest]):
     name: str
+    created_time: int
+
+    def as_request_resource(self) -> RAWDatabaseRequest:
+        return RAWDatabaseRequest.model_validate(self.dump(), extra="ignore")
 
-    def as_id(self) -> Self:
-        return self
+    def as_id(self) -> RawDatabaseId:
+        return RawDatabaseId(name=self.name)
 
-    def __str__(self) -> str:
-        return f"name='{self.name}'"
 
-    def as_request_resource(self) -> "RAWDatabase":
-        return type(self).model_validate(self.dump(), extra="ignore")
+class RAWTableRequest(RequestResource):
+    # This is a query parameter, so we exclude it from serialization.
+    db_name: str = Field(exclude=True)
+    name: str = Field(alias="tableName")
+
+    def as_id(self) -> RawTableId:
+        return RawTableId(db_name=self.db_name, name=self.name)
+
+    # Override dump to always use by_alias=False since the API expects name='...'
+    def dump(self, camel_case: bool = True, exclude_extra: bool = False) -> dict[str, Any]:
+        """Dump the resource to a dictionary.
+
+        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.
 
+        """
+        if exclude_extra:
+            return self.model_dump(
+                mode="json",
+                by_alias=False,
+                exclude_unset=True,
+                exclude=set(self.__pydantic_extra__) if self.__pydantic_extra__ else None,
+            )
+        return self.model_dump(mode="json", by_alias=False, exclude_unset=True)
 
-class RAWTable(RequestResource, Identifier, ResponseResource["RAWTable"]):
+
+class RAWTableResponse(ResponseResource[RAWTableRequest]):
     # This is a query parameter, so we exclude it from serialization.
     # Default to empty string to allow parsing from API responses (which don't include db_name).
     db_name: str = Field(default="", exclude=True)
     name: str
+    created_time: int
 
-    def as_id(self) -> Self:
-        return self
+    def as_request_resource(self) -> RAWTableRequest:
+        dumped = {**self.dump(), "dbName": self.db_name}
+        return RAWTableRequest.model_validate(dumped, extra="ignore")
 
-    def __str__(self) -> str:
-        return f"dbName='{self.db_name}', tableName='{self.name}'"
+    @classmethod
+    def _load(cls, resource: dict[str, Any]) -> Self:
+        """Load method to match CogniteResource signature."""
+        return cls.model_validate(resource, by_name=True)
 
-    def as_request_resource(self) -> "RAWTable":
-        dumped = {**self.dump(), "dbName": self.db_name}
-        return type(self).model_validate(dumped, extra="ignore")
+    def as_id(self) -> RawTableId:
+        return RawTableId(db_name=self.db_name, name=self.name)