cognite-toolkit 0.7.72__tar.gz → 0.7.73__tar.gz

{cognite_toolkit-0.7.72 → cognite_toolkit-0.7.73}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite_toolkit
-Version: 0.7.72
+Version: 0.7.73
 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.72 → cognite_toolkit-0.7.73}/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-0.7.72 → cognite_toolkit-0.7.73}/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-0.7.72 → cognite_toolkit-0.7.73}/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-0.7.72 → cognite_toolkit-0.7.73}/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-0.7.72 → cognite_toolkit-0.7.73}/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-0.7.73/cognite_toolkit/_cdf_tk/client/resource_classes/raw.py

@@ -0,0 +1,98 @@
+import sys
+from typing import Any
+
+from pydantic import Field
+
+from cognite_toolkit._cdf_tk.client._resource_base import (
+    RequestResource,
+    ResponseResource,
+)
+from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import RawDatabaseId, RawTableId
+
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
+
+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) -> RawDatabaseId:
+        return RawDatabaseId(name=self.name)
+
+
+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 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_request_resource(self) -> RAWTableRequest:
+        dumped = {**self.dump(), "dbName": self.db_name}
+        return RAWTableRequest.model_validate(dumped, extra="ignore")
+
+    @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_id(self) -> RawTableId:
+        return RawTableId(db_name=self.db_name, name=self.name)

{cognite_toolkit-0.7.72 → cognite_toolkit-0.7.73}/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
@@ -24,6 +26,7 @@ from cognite_toolkit._cdf_tk.client.api.legacy.extended_raw import ExtendedRawAP
 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.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
@@ -134,9 +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.raw.tables = MagicMock(spec_set=LegacyRawTablesAPI)
 
         self.data_modeling.instances = MagicMock(spec_set=ExtendedInstancesAPI)
 
@@ -162,6 +165,9 @@ 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)

{cognite_toolkit-0.7.72 → cognite_toolkit-0.7.73}/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-0.7.72 → cognite_toolkit-0.7.73}/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-0.7.72 → cognite_toolkit-0.7.73}/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-0.7.72 → cognite_toolkit-0.7.73}/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):