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

cognite_toolkit/_cdf_tk/client/testing.py

@@ -6,7 +6,9 @@ from unittest.mock import MagicMock
 from cognite.client._api.datapoints import DatapointsAPI
 from cognite.client._api.datapoints_subscriptions import DatapointsSubscriptionAPI
 from cognite.client._api.functions import FunctionCallsAPI, FunctionSchedulesAPI
-from cognite.client._api.raw import RawDatabasesAPI, RawRowsAPI, RawTablesAPI
+from cognite.client._api.raw import RawDatabasesAPI as LegacyRawDatabasesAPI
+from cognite.client._api.raw import RawRowsAPI
+from cognite.client._api.raw import RawTablesAPI as LegacyRawTablesAPI
 from cognite.client._api.simulators import SimulatorModelsAPI, SimulatorsAPI
 from cognite.client._api.synthetic_time_series import SyntheticDatapointsAPI
 from cognite.client.testing import CogniteClientMock
@@ -23,15 +25,15 @@ 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.raw import RawAPI, RawDatabasesAPI, RawTablesAPI
+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
@@ -135,17 +137,9 @@ class ToolkitClientMock(CogniteClientMock):
         self.migration.resource_view_mapping = MagicMock(spec_set=ResourceViewMappingAPI)
         self.migration.created_source_system = MagicMock(spec_set=CreatedSourceSystemAPI)
         self.raw = MagicMock(spec=ExtendedRawAPI)
-        self.raw.databases = MagicMock(spec_set=RawDatabasesAPI)
+        self.raw.databases = MagicMock(spec_set=LegacyRawDatabasesAPI)
         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.raw.tables = MagicMock(spec_set=LegacyRawTablesAPI)
 
         self.data_modeling.instances = MagicMock(spec_set=ExtendedInstancesAPI)
 
@@ -171,6 +165,16 @@ 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.raw = MagicMock(spec=RawAPI)
+        self.tool.raw.databases = MagicMock(spec_set=RawDatabasesAPI)
+        self.tool.raw.tables = MagicMock(spec_set=RawTablesAPI)
+        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/commands/build_cmd.py

@@ -14,7 +14,7 @@ from rich.progress import track
 from cognite_toolkit._cdf_tk.builders import Builder, FunctionBuilder, create_builder
 from cognite_toolkit._cdf_tk.cdf_toml import CDFToml
 from cognite_toolkit._cdf_tk.client import ToolkitClient
-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.commands._base import ToolkitCommand
 from cognite_toolkit._cdf_tk.constants import (
     _RUNNING_IN_BROWSER,
@@ -606,7 +606,7 @@ class BuildCommand(ToolkitCommand):
             if identifier:
                 identifier_kind_pairs.append((identifier, item_loader.kind))
                 if first_seen := self._ids_by_resource_type[item_loader].get(identifier):
-                    if isinstance(identifier, RawDatabase):
+                    if isinstance(identifier, RawDatabaseId):
                         # RawDatabases are picked up from both RawTables and RawDatabases files. Note it is not possible
                         # to define a raw table without also defining the raw database. Thus, it is impossible to
                         # avoid duplicated RawDatabase warnings if you have multiple RawTables files.

cognite_toolkit/_cdf_tk/cruds/_data_cruds.py

@@ -8,7 +8,7 @@ from cognite.client.data_classes import FileMetadataWrite
 
 from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import ExternalId
 from cognite_toolkit._cdf_tk.client.resource_classes.legacy.extendable_cognite_file import ExtendableCogniteFileApply
-from cognite_toolkit._cdf_tk.client.resource_classes.legacy.raw import RawTable
+from cognite_toolkit._cdf_tk.client.resource_classes.raw import RAWTableResponse
 from cognite_toolkit._cdf_tk.constants import BUILD_FOLDER_ENCODING
 from cognite_toolkit._cdf_tk.protocols import (
     T_ResourceRequest,
@@ -167,7 +167,7 @@ class RawFileCRUD(DataCRUD):
         for resource in state.built_resources[self.folder_name]:
             if resource.kind != RawTableCRUD.kind:
                 continue
-            table = cast(RawTable, resource.identifier)
+            table = cast(RAWTableResponse, resource.identifier)
             datafile = next(
                 (
                     resource.source.path.with_suffix(f".{file_type}")
@@ -210,7 +210,7 @@ class RawFileCRUD(DataCRUD):
                 continue
 
             self.client.raw.rows.insert_dataframe(
-                db_name=table.db_name, table_name=table.table_name, dataframe=data, ensure_parent=False
+                db_name=table.db_name, table_name=table.name, dataframe=data, ensure_parent=False
             )
             yield (
                 (f" Inserted {len(data):,} rows of {len(data.columns):,} columns from '{datafile!s}' into {table!r}."),

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/auth.py

@@ -41,8 +41,7 @@ from rich.console import Console
 from rich.markup import escape
 
 from cognite_toolkit._cdf_tk.client import ToolkitClient
-from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import ExternalId
-from cognite_toolkit._cdf_tk.client.resource_classes.legacy.raw import RawDatabase, RawTable
+from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import ExternalId, RawDatabaseId, RawTableId
 from cognite_toolkit._cdf_tk.cruds._base_cruds import ResourceCRUD
 from cognite_toolkit._cdf_tk.exceptions import ToolkitWrongResourceError
 from cognite_toolkit._cdf_tk.resource_classes import GroupYAML, SecurityCategoriesYAML
@@ -161,12 +160,12 @@ class GroupCRUD(ResourceCRUD[str, GroupWrite, Group]):
                                 yield DataSetsCRUD, data_set_id
                     if table_ids := scope.get(cap.TableScope._scope_name, []):
                         for db_name, tables in table_ids.get("dbsToTables", {}).items():
-                            yield RawDatabaseCRUD, RawDatabase(db_name)
+                            yield RawDatabaseCRUD, RawDatabaseId(name=db_name)
                             if isinstance(tables, list):
-                                yield from ((RawTableCRUD, RawTable(db_name, table)) for table in tables)
+                                yield from ((RawTableCRUD, RawTableId(db_name=db_name, name=table)) for table in tables)
                             elif isinstance(tables, dict) and "tables" in tables:
                                 for table in tables["tables"]:
-                                    yield RawTableCRUD, RawTable(db_name, table)
+                                    yield RawTableCRUD, RawTableId(db_name=db_name, name=table)
                     if extraction_pipeline_ids := scope.get(cap.ExtractionPipelineScope._scope_name, []):
                         if isinstance(extraction_pipeline_ids, dict) and "ids" in extraction_pipeline_ids:
                             for extraction_pipeline_id in extraction_pipeline_ids["ids"]:

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/extraction_pipeline.py

@@ -35,7 +35,7 @@ from cognite.client.data_classes.extractionpipelines import (
 from cognite.client.exceptions import CogniteAPIError, CogniteDuplicatedError, CogniteNotFoundError
 from cognite.client.utils.useful_types import SequenceNotStr
 
-from cognite_toolkit._cdf_tk.client.resource_classes.legacy.raw import RawDatabase, RawTable
+from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import RawDatabaseId, RawTableId
 from cognite_toolkit._cdf_tk.constants import BUILD_FOLDER_ENCODING
 from cognite_toolkit._cdf_tk.cruds._base_cruds import ResourceCRUD
 from cognite_toolkit._cdf_tk.exceptions import (
@@ -124,9 +124,9 @@ class ExtractionPipelineCRUD(ResourceCRUD[str, ExtractionPipelineWrite, Extracti
                 if db := entry.get("dbName"):
                     if db not in seen_databases:
                         seen_databases.add(db)
-                        yield RawDatabaseCRUD, RawDatabase(db_name=db)
+                        yield RawDatabaseCRUD, RawDatabaseId(name=db)
                     if "tableName" in entry:
-                        yield RawTableCRUD, RawTable._load(entry)
+                        yield RawTableCRUD, RawTableId(db_name=db, name=entry["tableName"])
 
     def load_resource(self, resource: dict[str, Any], is_dry_run: bool = False) -> ExtractionPipelineWrite:
         if ds_external_id := resource.pop("dataSetExternalId", None):

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/raw.py

@@ -17,7 +17,7 @@ import itertools
 from collections import defaultdict
 from collections.abc import Hashable, Iterable, Sequence
 from pathlib import Path
-from typing import Any, cast, final
+from typing import Any, final
 
 from cognite.client.data_classes.capabilities import (
     Capability,
@@ -29,11 +29,13 @@ from rich import print
 from rich.console import Console
 
 from cognite_toolkit._cdf_tk.client import ToolkitClient
-from cognite_toolkit._cdf_tk.client.resource_classes.legacy.raw import (
-    RawDatabase,
-    RawDatabaseList,
-    RawTable,
-    RawTableList,
+from cognite_toolkit._cdf_tk.client.http_client import ToolkitAPIError
+from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import NameId, RawDatabaseId, RawTableId
+from cognite_toolkit._cdf_tk.client.resource_classes.raw import (
+    RAWDatabaseRequest,
+    RAWDatabaseResponse,
+    RAWTableRequest,
+    RAWTableResponse,
 )
 from cognite_toolkit._cdf_tk.cruds._base_cruds import ResourceContainerCRUD, ResourceCRUD
 from cognite_toolkit._cdf_tk.resource_classes import DatabaseYAML, TableYAML
@@ -42,11 +44,11 @@ from .auth import GroupAllScopedCRUD
 
 
 @final
-class RawDatabaseCRUD(ResourceContainerCRUD[RawDatabase, RawDatabase, RawDatabase]):
+class RawDatabaseCRUD(ResourceContainerCRUD[RawDatabaseId, RAWDatabaseRequest, RAWDatabaseResponse]):
     item_name = "raw tables"
     folder_name = "raw"
-    resource_cls = RawDatabase
-    resource_write_cls = RawDatabase
+    resource_cls = RAWDatabaseResponse
+    resource_write_cls = RAWDatabaseRequest
     kind = "Database"
     yaml_cls = DatabaseYAML
     dependencies = frozenset({GroupAllScopedCRUD})
@@ -63,7 +65,7 @@ class RawDatabaseCRUD(ResourceContainerCRUD[RawDatabase, RawDatabase, RawDatabas
 
     @classmethod
     def get_required_capability(
-        cls, items: Sequence[RawDatabase] | None, read_only: bool
+        cls, items: Sequence[RAWDatabaseRequest] | None, read_only: bool
     ) -> Capability | list[Capability]:
         if not items and items is not None:
             return []
@@ -78,86 +80,89 @@ class RawDatabaseCRUD(ResourceContainerCRUD[RawDatabase, RawDatabase, RawDatabas
         if items:
             tables_by_database: dict[str, list[str]] = {}
             for item in items:
-                tables_by_database[item.db_name] = []
+                tables_by_database[item.name] = []
 
             scope = RawAcl.Scope.Table(dict(tables_by_database)) if tables_by_database else RawAcl.Scope.All()
 
         return RawAcl(actions, scope)
 
     @classmethod
-    def get_id(cls, item: RawDatabase | dict) -> RawDatabase:
+    def get_id(cls, item: RAWDatabaseResponse | RAWDatabaseRequest | dict) -> RawDatabaseId:
         if isinstance(item, dict):
-            return RawDatabase(item["dbName"])
-        return item
+            return RawDatabaseId.model_validate(item)
+        return RawDatabaseId(name=item.name)
 
     @classmethod
-    def dump_id(cls, id: RawDatabase) -> dict[str, Any]:
-        return {"dbName": id.db_name}
+    def dump_id(cls, id: RawDatabaseId) -> dict[str, Any]:
+        return {"dbName": id.name}
 
-    def create(self, items: Sequence[RawDatabase]) -> RawDatabaseList:
-        database_list = self.client.raw.databases.create([db.db_name for db in items])
-        return RawDatabaseList([RawDatabase(db_name=db.name) for db in database_list if db.name])
+    def dump_resource(self, resource: RAWDatabaseResponse, local: dict[str, Any] | None = None) -> dict[str, Any]:
+        return {"dbName": resource.name}
 
-    def retrieve(self, ids: SequenceNotStr[RawDatabase]) -> RawDatabaseList:
-        database_list = self.client.raw.databases.list(limit=-1)
-        target_dbs = {db.db_name for db in ids}
-        return RawDatabaseList([RawDatabase(db_name=db.name) for db in database_list if db.name in target_dbs])
+    def create(self, items: Sequence[RAWDatabaseRequest]) -> list[RAWDatabaseResponse]:
+        return self.client.tool.raw.databases.create(items)
 
-    def delete(self, ids: SequenceNotStr[RawDatabase]) -> int:
-        db_names = [table.db_name for table in ids]
+    def retrieve(self, ids: SequenceNotStr[RawDatabaseId]) -> list[RAWDatabaseResponse]:
+        database_list = self.client.tool.raw.databases.list(limit=None)
+        target_dbs = {db.name for db in ids}
+        return [db for db in database_list if db.name in target_dbs]
+
+    def delete(self, ids: SequenceNotStr[RawDatabaseId]) -> int:
+        ids_list = list(ids)
         try:
-            self.client.raw.databases.delete(db_names)
-        except CogniteAPIError as e:
+            self.client.tool.raw.databases.delete(ids_list)
+        except ToolkitAPIError as e:
             # Bug in API, missing is returned as failed
-            if e.failed and (db_names := [name for name in db_names if name not in e.failed]):
-                self.client.raw.databases.delete(db_names)
+            if e.missing and (remaining := [db for db in ids_list if db.name not in e.missing]):
+                self.client.tool.raw.databases.delete(remaining)
             elif e.code == 404 and "not found" in e.message and "database" in e.message:
                 return 0
             else:
                 raise e
-        return len(db_names)
+        return len(ids_list)
 
     def _iterate(
         self,
         data_set_external_id: str | None = None,
         space: str | None = None,
         parent_ids: list[Hashable] | None = None,
-    ) -> Iterable[RawDatabase]:
-        return (RawDatabase(db_name=cast(str, db.name)) for db in self.client.raw.databases)
+    ) -> Iterable[RAWDatabaseResponse]:
+        for databases in self.client.tool.raw.databases.iterate():
+            yield from databases
 
-    def count(self, ids: SequenceNotStr[RawDatabase]) -> int:
+    def count(self, ids: SequenceNotStr[RawDatabaseId]) -> int:
         nr_of_tables = 0
-        for db_name, raw_tables in itertools.groupby(sorted(ids, key=lambda x: x.db_name), key=lambda x: x.db_name):
+        for db_name, raw_tables in itertools.groupby(sorted(ids, key=lambda x: x.name), key=lambda x: x.name):
             try:
-                tables = self.client.raw.tables.list(db_name=db_name, limit=-1)
+                tables = self.client.tool.raw.tables.list(db_name=db_name, limit=None)
             except CogniteAPIError as e:
                 if db_name in {item.get("name") for item in e.missing or []}:
                     continue
                 raise e
-            nr_of_tables += len(tables.data)
+            nr_of_tables += len(tables)
         return nr_of_tables
 
-    def drop_data(self, ids: SequenceNotStr[RawDatabase]) -> int:
+    def drop_data(self, ids: SequenceNotStr[RawDatabaseId]) -> int:
         nr_of_tables = 0
-        for db_name, raw_tables in itertools.groupby(sorted(ids, key=lambda x: x.db_name), key=lambda x: x.db_name):
+        for db_name, raw_tables in itertools.groupby(sorted(ids, key=lambda x: x.name), key=lambda x: x.name):
             try:
-                existing = self.client.raw.tables.list(db_name=db_name, limit=-1).as_names()
-            except CogniteAPIError as e:
+                existing = self.client.tool.raw.tables.list(db_name=db_name, limit=None)
+            except ToolkitAPIError as e:
                 if db_name in {item.get("name") for item in e.missing or []}:
                     continue
                 raise e
             if existing:
-                self.client.raw.tables.delete(db_name=db_name, name=existing)
+                self.client.tool.raw.tables.delete([table.as_id() for table in existing])
                 nr_of_tables += len(existing)
         return nr_of_tables
 
 
 @final
-class RawTableCRUD(ResourceContainerCRUD[RawTable, RawTable, RawTable]):
+class RawTableCRUD(ResourceContainerCRUD[RawTableId, RAWTableRequest, RAWTableResponse]):
     item_name = "raw rows"
     folder_name = "raw"
-    resource_cls = RawTable
-    resource_write_cls = RawTable
+    resource_cls = RAWTableResponse
+    resource_write_cls = RAWTableRequest
     kind = "Table"
     yaml_cls = TableYAML
     support_update = False
@@ -175,7 +180,7 @@ class RawTableCRUD(ResourceContainerCRUD[RawTable, RawTable, RawTable]):
 
     @classmethod
     def get_required_capability(
-        cls, items: Sequence[RawTable] | None, read_only: bool
+        cls, items: Sequence[RAWTableRequest] | None, read_only: bool
     ) -> Capability | list[Capability]:
         if not items and items is not None:
             return []
@@ -190,75 +195,70 @@ class RawTableCRUD(ResourceContainerCRUD[RawTable, RawTable, RawTable]):
         if items:
             tables_by_database = defaultdict(list)
             for item in items:
-                tables_by_database[item.db_name].append(item.table_name)
+                tables_by_database[item.db_name].append(item.name)
 
             scope = RawAcl.Scope.Table(dict(tables_by_database)) if tables_by_database else RawAcl.Scope.All()
 
         return RawAcl(actions, scope)
 
     @classmethod
-    def get_id(cls, item: RawTable | dict) -> RawTable:
+    def get_id(cls, item: RAWTableResponse | RAWTableRequest | dict) -> RawTableId:
         if isinstance(item, dict):
             if missing := tuple(k for k in {"dbName", "tableName"} if k not in item):
                 # We need to raise a KeyError with all missing keys to get the correct error message.
                 raise KeyError(*missing)
-            return RawTable(item["dbName"], item["tableName"])
-        return item
+            return RawTableId(db_name=item["dbName"], name=item["tableName"])
+        return RawTableId(db_name=item.db_name, name=item.name)
 
     @classmethod
-    def dump_id(cls, id: RawTable) -> dict[str, Any]:
-        return {"dbName": id.db_name, "tableName": id.table_name}
+    def dump_id(cls, id: RawTableId) -> dict[str, Any]:
+        return {"dbName": id.db_name, "tableName": id.name}
 
     @classmethod
     def get_dependent_items(cls, item: dict) -> Iterable[tuple[type[ResourceCRUD], Hashable]]:
         if "dbName" in item:
-            yield RawDatabaseCRUD, RawDatabase(item["dbName"])
-
-    def create(self, items: Sequence[RawTable]) -> RawTableList:
-        created = RawTableList([])
-        for db_name, raw_tables in itertools.groupby(sorted(items, key=lambda x: x.db_name), key=lambda x: x.db_name):
-            tables = [table.table_name for table in raw_tables]
-            new_tables = self.client.raw.tables.create(db_name=db_name, name=tables)
-            created.extend([RawTable(db_name=db_name, table_name=cast(str, table.name)) for table in new_tables])
-        return created
-
-    def retrieve(self, ids: SequenceNotStr[RawTable]) -> RawTableList:
-        retrieved = RawTableList([])
+            yield RawDatabaseCRUD, RawDatabaseId(name=item["dbName"])
+
+    def dump_resource(self, resource: RAWTableResponse, local: dict[str, Any] | None = None) -> dict[str, Any]:
+        return {"dbName": resource.db_name, "tableName": resource.name}
+
+    def create(self, items: Sequence[RAWTableRequest]) -> list[RAWTableResponse]:
+        return self.client.tool.raw.tables.create(items)
+
+    def retrieve(self, ids: SequenceNotStr[RawTableId]) -> list[RAWTableResponse]:
+        retrieved: list[RAWTableResponse] = []
         for db_name, raw_tables in itertools.groupby(sorted(ids, key=lambda x: x.db_name), key=lambda x: x.db_name):
-            expected_tables = {table.table_name for table in raw_tables}
+            expected_tables = {table.name for table in raw_tables}
             try:
-                tables = self.client.raw.tables.list(db_name=db_name, limit=-1)
-            except CogniteAPIError as e:
+                tables = self.client.tool.raw.tables.list(db_name=db_name, limit=None)
+            except ToolkitAPIError as e:
                 if db_name in {item.get("name") for item in e.missing or []}:
                     continue
                 raise e
-            retrieved.extend(
-                [RawTable(db_name=db_name, table_name=table.name) for table in tables if table.name in expected_tables]
-            )
+            retrieved.extend(table for table in tables if table.name in expected_tables)
         return retrieved
 
-    def delete(self, ids: SequenceNotStr[RawTable]) -> int:
+    def delete(self, ids: SequenceNotStr[RawTableId]) -> int:
         count = 0
         for db_name, raw_tables in itertools.groupby(sorted(ids, key=lambda x: x.db_name), key=lambda x: x.db_name):
-            tables = [table.table_name for table in raw_tables if table.table_name]
-            if tables:
+            tables_to_delete = [table for table in raw_tables if table.name]
+            if tables_to_delete:
                 try:
-                    self.client.raw.tables.delete(db_name=db_name, name=tables)
-                except CogniteAPIError as e:
+                    self.client.tool.raw.tables.delete(tables_to_delete)
+                except ToolkitAPIError as e:
                     if e.code != 404:
                         raise e
-                    # Missing is returned as failed
-                    missing = {item.get("name") for item in (e.missing or [])}.union(set(e.failed or []))
+                    missing = {item.get("name") for item in (e.missing or [])}
                     if "not found" in e.message and "database" in e.message:
                         continue
-                    elif tables := [name for name in tables if name not in missing]:
-                        self.client.raw.tables.delete(db_name=db_name, name=tables)
-                    elif not tables:
+                    elif remaining := [t for t in tables_to_delete if t.name not in missing]:
+                        self.client.tool.raw.tables.delete(remaining)
+                    elif not remaining:
                         # Table does not exist.
                         continue
                     else:
                         raise e
-                count += len(tables)
+                count += len(tables_to_delete)
         return count
 
     def _iterate(
@@ -266,28 +266,36 @@ class RawTableCRUD(ResourceContainerCRUD[RawTable, RawTable, RawTable]):
         data_set_external_id: str | None = None,
         space: str | None = None,
         parent_ids: list[Hashable] | None = None,
-    ) -> Iterable[RawTable]:
-        for parent_id in parent_ids or (RawDatabase(cast(str, db.name)) for db in self.client.raw.databases):
-            if not isinstance(parent_id, RawDatabase):
+    ) -> Iterable[RAWTableResponse]:
+        if parent_ids is None:
+            dbs = self.client.tool.raw.databases.list(limit=None)
+            parent_ids = [RawDatabaseId(name=db.name) for db in dbs]
+        for parent_id in parent_ids:
+            if not isinstance(parent_id, NameId):
                 continue
-            for table in self.client.raw.tables(parent_id.db_name):
-                yield RawTable(db_name=parent_id.db_name, table_name=cast(str, table.name))
+            for tables in self.client.tool.raw.tables.iterate(db_name=parent_id.name):
+                yield from tables
 
-    def count(self, ids: SequenceNotStr[RawTable]) -> int:
+    def count(self, ids: SequenceNotStr[RawTableId]) -> int:
         if not self._printed_warning:
             print("  [bold green]INFO:[/] Raw rows do not support count (there is no aggregation method).")
             self._printed_warning = True
         return -1
 
-    def drop_data(self, ids: SequenceNotStr[RawTable]) -> int:
+    def drop_data(self, ids: SequenceNotStr[RawTableId]) -> int:
         for db_name, raw_tables in itertools.groupby(sorted(ids, key=lambda x: x.db_name), key=lambda x: x.db_name):
             try:
-                existing = set(self.client.raw.tables.list(db_name=db_name, limit=-1).as_names())
+                existing_tables = self.client.tool.raw.tables.list(db_name=db_name, limit=None)
+                existing_names = {table.name for table in existing_tables}
             except CogniteAPIError as e:
                 if db_name in {item.get("name") for item in e.missing or []}:
                     continue
                 raise e
-            tables = [table.table_name for table in raw_tables if table.table_name in existing]
-            if tables:
-                self.client.raw.tables.delete(db_name=db_name, name=tables)
+            tables_to_delete = [
+                RAWTableResponse(db_name=db_name, name=table.name)
+                for table in raw_tables
+                if table.name in existing_names
+            ]
+            if tables_to_delete:
+                self.client.tool.raw.tables.delete([table.as_id() for table in tables_to_delete])
         return -1