cognite-toolkit 0.7.72__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/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/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)

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/_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

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/transformation.py

@@ -65,7 +65,7 @@ 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, 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 (
@@ -186,8 +186,8 @@ class TransformationCRUD(ResourceCRUD[str, TransformationWrite, Transformation])
             if not isinstance(destination, dict):
                 return
             if destination.get("type") == "raw" and in_dict(("database", "table"), destination):
-                yield RawDatabaseCRUD, RawDatabase(destination["database"])
-                yield RawTableCRUD, RawTable(destination["database"], destination["table"])
+                yield RawDatabaseCRUD, RawDatabaseId(name=destination["database"])
+                yield RawTableCRUD, RawTableId(db_name=destination["database"], name=destination["table"])
             elif destination.get("type") in ("nodes", "edges") and (view := destination.get("view", {})):
                 if space := destination.get("instanceSpace"):
                     yield SpaceCRUD, space

cognite_toolkit/_repo_files/GitHub/.github/workflows/deploy.yaml

@@ -12,7 +12,7 @@ jobs:
     environment: dev
     name: Deploy
     container:
-      image: cognite/toolkit:0.7.72
+      image: cognite/toolkit:0.7.73
       env:
         CDF_CLUSTER: ${{ vars.CDF_CLUSTER }}
         CDF_PROJECT: ${{ vars.CDF_PROJECT }}

cognite_toolkit/_repo_files/GitHub/.github/workflows/dry-run.yaml

@@ -10,7 +10,7 @@ jobs:
     environment: dev
     name: Deploy Dry Run
     container:
-      image: cognite/toolkit:0.7.72
+      image: cognite/toolkit:0.7.73
       env:
         CDF_CLUSTER: ${{ vars.CDF_CLUSTER }}
         CDF_PROJECT: ${{ vars.CDF_PROJECT }}

cognite_toolkit/_resources/cdf.toml

@@ -4,7 +4,7 @@ default_env = "<DEFAULT_ENV_PLACEHOLDER>"
 [modules]
 # This is the version of the modules. It should not be changed manually.
 # It will be updated by the 'cdf modules upgrade' command.
-version = "0.7.72"
+version = "0.7.73"
 
 
 [plugins]

cognite_toolkit/_version.py

@@ -1 +1 @@
-__version__ = "0.7.72"
+__version__ = "0.7.73"

{cognite_toolkit-0.7.72.dist-info → cognite_toolkit-0.7.73.dist-info}/METADATA

@@ -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.dist-info → cognite_toolkit-0.7.73.dist-info}/RECORD

@@ -23,7 +23,7 @@ cognite_toolkit/_cdf_tk/builders/_datamodels.py,sha256=hN3fWQAktrWdaGAItZ0tHpBXq
 cognite_toolkit/_cdf_tk/builders/_file.py,sha256=ZRTlyb-MnmJhBhfPeQ9h7gM2T4nllyjonwYBj31cv1Q,3847
 cognite_toolkit/_cdf_tk/builders/_function.py,sha256=jrXZPSck6GVguChl1kiWRTbrsiLWjyC5FupNDvAZWek,7614
 cognite_toolkit/_cdf_tk/builders/_location.py,sha256=Ix26T6JSlmp_Ij3iKaClbBQtRF3hR-wDKkZu9B-NblA,3968
-cognite_toolkit/_cdf_tk/builders/_raw.py,sha256=3XjPHfzPRYRJ2QPP-D8S9uW2gppnzEdqyICBqwGRRXo,3265
+cognite_toolkit/_cdf_tk/builders/_raw.py,sha256=k5y21KglHJc7ewrdqPtH0mcbbuirTxUk_binUnfvMBg,3275
 cognite_toolkit/_cdf_tk/builders/_streamlit.py,sha256=WsrQTaTwuyewNJ2y04tA16iEK-bpr0cL4sup9-89H6o,4996
 cognite_toolkit/_cdf_tk/builders/_transformation.py,sha256=STB42zhzOW5M_-b8cKOQ_cegnr7FtMoMxZ87gPLXft4,4723
 cognite_toolkit/_cdf_tk/cdf_toml.py,sha256=VSWV9h44HusWIaKpWgjrOMrc3hDoPTTXBXlp6-NOrIM,9079
@@ -69,7 +69,7 @@ cognite_toolkit/_cdf_tk/client/api/location_filters.py,sha256=TBoIUCGbJC7vLn6SYX
 cognite_toolkit/_cdf_tk/client/api/lookup.py,sha256=c-cvtgfGGGYyk8ROcJu44qlo1ocqbk0o1zafCql79fU,17652
 cognite_toolkit/_cdf_tk/client/api/migration.py,sha256=wYwu5xzNS_-E_vJIOXxPWr6_iRsL9Mld2rLZtOeK9pQ,23106
 cognite_toolkit/_cdf_tk/client/api/project.py,sha256=IN6F2oWT_GBaNQhW8fWoVr-GBQMfncKV2Ibgxd3qRmA,1634
-cognite_toolkit/_cdf_tk/client/api/raw.py,sha256=MiFubP5b1F45yr0uTfb7V2aMVezuwKXQiueV_LkTgZs,7700
+cognite_toolkit/_cdf_tk/client/api/raw.py,sha256=1fcfNePkxd5FVnKwEoI0vqmRUjItghRUzBuWY9Ch6_A,8358
 cognite_toolkit/_cdf_tk/client/api/relationships.py,sha256=RpKav2wWoEmSfGNLsi_3Zh0yyEZ7XlmmKJyhUOlGIjg,4983
 cognite_toolkit/_cdf_tk/client/api/robotics.py,sha256=N32x6d4s4RNLrotAiYzBQMmXKRGS0pefjoQGkBmbSPI,969
 cognite_toolkit/_cdf_tk/client/api/robotics_capabilities.py,sha256=vd9qo9aYm-Y-p448cPRdq80uIPaWq-EK2Kaeob9YvN0,5112
@@ -102,8 +102,8 @@ cognite_toolkit/_cdf_tk/client/cdf_client/responses.py,sha256=0K_19_jXgTx_d657ld
 cognite_toolkit/_cdf_tk/client/config.py,sha256=weMR43z-gqHMn-Jqvfmh_nJ0HbgEdyeCGtISuEf3OuY,4269
 cognite_toolkit/_cdf_tk/client/http_client/__init__.py,sha256=_B_eB9yZ97ctfWFNrrK722R-WkMbktZECeiqZlUUee8,674
 cognite_toolkit/_cdf_tk/client/http_client/_client.py,sha256=dUC-8XsKwBelQbMFbyK_fOEh5qeu9HsNrWSJgdWXt44,15865
-cognite_toolkit/_cdf_tk/client/http_client/_data_classes.py,sha256=BX7_itzaKm9oXl-cQroTn6wZHb-b8EEFddsEYxfMuw4,5414
-cognite_toolkit/_cdf_tk/client/http_client/_exception.py,sha256=9dE5tm1qTviG93JppLql6ltlmAgm8TxWh9wWPdm0ITA,428
+cognite_toolkit/_cdf_tk/client/http_client/_data_classes.py,sha256=o8l8AZaoimapiC2-deusPUTpuji7rQ7QBxlSjWrNJiM,5452
+cognite_toolkit/_cdf_tk/client/http_client/_exception.py,sha256=0eN1bPmmqFtpfm5K3u1sUMRlRYdpqfPQ8egl6GqTego,511
 cognite_toolkit/_cdf_tk/client/http_client/_item_classes.py,sha256=Jjbvt0HjR9kcDpmFXsVRtwJvQqvEq6UOJO9xutSibr8,4454
 cognite_toolkit/_cdf_tk/client/http_client/_tracker.py,sha256=pu6oA-XpOeaOLdoeD_mGfJXC3BFGWfh5oGcRDpb6maw,1407
 cognite_toolkit/_cdf_tk/client/request_classes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -153,7 +153,7 @@ cognite_toolkit/_cdf_tk/client/resource_classes/hosted_extractor_source/_eventhu
 cognite_toolkit/_cdf_tk/client/resource_classes/hosted_extractor_source/_kafka.py,sha256=M9tEQWulhNDDxbkM0O5a7Xi1K5VkGM3MLFEft5XJVKs,1774
 cognite_toolkit/_cdf_tk/client/resource_classes/hosted_extractor_source/_mqtt.py,sha256=RJhR5eAEkRt8Ze2r0vwmEZ-2azbDxQSlmUFxD1o2Ovk,1265
 cognite_toolkit/_cdf_tk/client/resource_classes/hosted_extractor_source/_rest.py,sha256=OSiPMEH_dMCUC3L1QpIOmJSXyYYRlqt-_lHZpPTv9Sw,1729
-cognite_toolkit/_cdf_tk/client/resource_classes/identifiers.py,sha256=Bu_pgcuRQAQxG8jQAKh1Kn1XuUU0MM421I0ydzj9jSk,1990
+cognite_toolkit/_cdf_tk/client/resource_classes/identifiers.py,sha256=1HPKyLJaXpWF0R9x_bLy8PkdPB7zj861L9ODkJrAD9c,2730
 cognite_toolkit/_cdf_tk/client/resource_classes/infield.py,sha256=hpL79vuvKOVWap0GNr-VYxdqBQvvuu3EPQDL7a-MrjU,6932
 cognite_toolkit/_cdf_tk/client/resource_classes/instance_api.py,sha256=L5Qe6hqqFEIrw6JGK2DFvjQRH8N8fbJXFeQ51c5VH8s,7803
 cognite_toolkit/_cdf_tk/client/resource_classes/label.py,sha256=-w7VxTOmHZkgiEjQ-trGY2JOWo-ZU4nqhmM2UrpkhEI,650
@@ -178,7 +178,7 @@ cognite_toolkit/_cdf_tk/client/resource_classes/legacy/sequences.py,sha256=02d34
 cognite_toolkit/_cdf_tk/client/resource_classes/legacy/streamlit_.py,sha256=nEk00FH3i-px2r6ql4kk1VVL4sytjUn0_sTkEdDSHVc,6746
 cognite_toolkit/_cdf_tk/client/resource_classes/location_filter.py,sha256=GKvfTlnF_JiVrIAAgLZY5nElLvb9bhC5VqT4Jezml5Y,2838
 cognite_toolkit/_cdf_tk/client/resource_classes/project.py,sha256=smElRldxcG_M_yrFBxUW-ka6eQDgYApMBMESkljAri8,758
-cognite_toolkit/_cdf_tk/client/resource_classes/raw.py,sha256=4PrHSVvK0dD0VeCDjErLdNwHcu6pT4DUujk1dSaPt_o,1234
+cognite_toolkit/_cdf_tk/client/resource_classes/raw.py,sha256=T6pTykEp4KDk0cLqZikNeeb3oedmakOQ7h9YaT9Rm5U,3523
 cognite_toolkit/_cdf_tk/client/resource_classes/relationship.py,sha256=cqe45BYHZ_6ZNjlyglLNdQWm01jxxftUHSjBa1EYwZs,1421
 cognite_toolkit/_cdf_tk/client/resource_classes/resource_view_mapping.py,sha256=0A4U9EFo69hca5w6ddQNU9GNnzw8og0uC_rvi5k7j94,1159
 cognite_toolkit/_cdf_tk/client/resource_classes/robotics/__init__.py,sha256=AaXN4lmZNO6PwhOYLXuY4JZMpBGyW71MVKQlcdzEo2w,1125
@@ -202,7 +202,7 @@ cognite_toolkit/_cdf_tk/client/resource_classes/transformation.py,sha256=20W9OJQ
 cognite_toolkit/_cdf_tk/client/resource_classes/workflow.py,sha256=OGTNOZNA6xFDzimRIBYj935RYWYBv863tGXplSVAdMQ,687
 cognite_toolkit/_cdf_tk/client/resource_classes/workflow_trigger.py,sha256=NCuH4RKbOblDJ0v_T-n9_MxxX2jpAEG5nt-qXprOle4,1558
 cognite_toolkit/_cdf_tk/client/resource_classes/workflow_version.py,sha256=K0lJulTc8zg7-fB7Q2wDqAA6Qy9oTrhUD2WgLHlC5S8,4246
-cognite_toolkit/_cdf_tk/client/testing.py,sha256=1frcpC37GRTLBt2tJ1JzAr0_Vt7XuffomMgGrVNZA5Q,10242
+cognite_toolkit/_cdf_tk/client/testing.py,sha256=nbFwlk19s-3srU7E8NvcpTZS6P4fPc4yAegXcbACSEg,10641
 cognite_toolkit/_cdf_tk/client/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite_toolkit/_cdf_tk/client/utils/_concurrency.py,sha256=3GtQbKDaosyKHEt-KzxKK9Yie4TvZPdoou2vUk6dUa8,2298
 cognite_toolkit/_cdf_tk/client/utils/_http_client.py,sha256=oXNKrIaizG4WiSAhL_kSCHAuL4aaaEhCU4pOJGxh6Xs,483
@@ -232,7 +232,7 @@ cognite_toolkit/_cdf_tk/commands/_utils.py,sha256=UxMJW5QYKts4om5n6x2Tq2ihvfO9gW
 cognite_toolkit/_cdf_tk/commands/_virtual_env.py,sha256=GFAid4hplixmj9_HkcXqU5yCLj-fTXm4cloGD6U2swY,2180
 cognite_toolkit/_cdf_tk/commands/about.py,sha256=pEXNdCeJYONOalH8x-7QRsKLgj-9gdIqN16pPxA3bhg,9395
 cognite_toolkit/_cdf_tk/commands/auth.py,sha256=l_WW_tDgkpN_e0Aoc_3EYql_omYZTg5PBtMFCSbJ_b8,33780
-cognite_toolkit/_cdf_tk/commands/build_cmd.py,sha256=e9BwCdfc_QyEJLC5jxmmD_Tbvy7oL-fC6HBoaMyQbjU,29145
+cognite_toolkit/_cdf_tk/commands/build_cmd.py,sha256=qKIyrPhF-e_NQCJCyxw04Ip66RkMU3a08aDa4TpHkUk,29150
 cognite_toolkit/_cdf_tk/commands/build_v2/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite_toolkit/_cdf_tk/commands/build_v2/_module_parser.py,sha256=B_Ddt8oB3tWto0Ocja9kvWaoIZyt8Oa-ukuoptQBYww,5916
 cognite_toolkit/_cdf_tk/commands/build_v2/_modules_parser.py,sha256=se9IhfwtbvWusqNeN2BzDnUEK3j97sN4Yugoh5xlc5U,6782
@@ -253,15 +253,15 @@ cognite_toolkit/_cdf_tk/commands/run.py,sha256=ETOuPokyF8_mnwVYF8j3hSGiSxKZnRUOK
 cognite_toolkit/_cdf_tk/constants.py,sha256=TplKm2J9pGRHq7nAnLI0caTMHetS04OIz3hfq-jvGzo,7236
 cognite_toolkit/_cdf_tk/cruds/__init__.py,sha256=xABXmF_3BhfNMRpr9aF9PyUayx7tkhqvVmzrRAf8eRE,7073
 cognite_toolkit/_cdf_tk/cruds/_base_cruds.py,sha256=6I1P0kZKxX7CDHM3_xPNnMJQi_QEviE_XnhpM_PAULc,17652
-cognite_toolkit/_cdf_tk/cruds/_data_cruds.py,sha256=rGMtPSHRuOa8ov95JHKdKoScxb1BFoBHjE_-sW9lakM,8984
+cognite_toolkit/_cdf_tk/cruds/_data_cruds.py,sha256=UCifIIbfQ3-xWIyIsGb1BFrKSDcwGaqXYJkSpogN9-g,8987
 cognite_toolkit/_cdf_tk/cruds/_resource_cruds/__init__.py,sha256=TTO_GE8AfUb4ra2uROyjHj9wsaT-vKb0mU5I_WEchxc,3014
 cognite_toolkit/_cdf_tk/cruds/_resource_cruds/agent.py,sha256=2UjX0m85fw_zt4EpCm5Ihz2gE1AlgOgR8-7Pr8M2c4g,5128
-cognite_toolkit/_cdf_tk/cruds/_resource_cruds/auth.py,sha256=q_8l5wq6dQ6LNFcNQ0EoOJMF5NoFVtq-TaqmGh7CpZ0,24823
+cognite_toolkit/_cdf_tk/cruds/_resource_cruds/auth.py,sha256=Bwv8lVJDFeTlOFHqLZr2Odb9Gh8o3drnGT-w2v9aWJU,24794
 cognite_toolkit/_cdf_tk/cruds/_resource_cruds/classic.py,sha256=J55_iJcCHxt7NmaW58_7Njb77z23WzGbAcp0goZyBK4,26319
 cognite_toolkit/_cdf_tk/cruds/_resource_cruds/configuration.py,sha256=Yargg3pzjfd6grd_LACHjZIreuyqOWkEe2Bh_-cdan0,5822
 cognite_toolkit/_cdf_tk/cruds/_resource_cruds/data_organization.py,sha256=U0ItuoNr1KEtoFQAiIe-K19_72ht9-kGndFVgF-iC10,9524
 cognite_toolkit/_cdf_tk/cruds/_resource_cruds/datamodel.py,sha256=Deyx0iAxiGmw3jLuTA03Yf9Vx1YzehGSnOtg7i0JBPE,64878
-cognite_toolkit/_cdf_tk/cruds/_resource_cruds/extraction_pipeline.py,sha256=yzRGAp1h7G0LN1ix81ZXpq-QZw0qHAjlW8aNaI0ehT8,17712
+cognite_toolkit/_cdf_tk/cruds/_resource_cruds/extraction_pipeline.py,sha256=gC_voB24j0n1WRIGDPhOaEpcHTtFmawfeI29EzjosQo,17742
 cognite_toolkit/_cdf_tk/cruds/_resource_cruds/fieldops.py,sha256=yiMjkr1d0Dgw4WRMIk0XhGzvd-Rqo3Kd0wfBfbZV89A,20762
 cognite_toolkit/_cdf_tk/cruds/_resource_cruds/file.py,sha256=LvlukwvRIQm8cX-YWfTGVjO74ZnPMDGv3m5Cd7pfgx8,14977
 cognite_toolkit/_cdf_tk/cruds/_resource_cruds/function.py,sha256=OSJlIiqyBqbSiEf4w7EGflMAk9Yvc96J3VFkYZlk3zw,29605
@@ -270,14 +270,14 @@ cognite_toolkit/_cdf_tk/cruds/_resource_cruds/hosted_extractors.py,sha256=pRyClY
 cognite_toolkit/_cdf_tk/cruds/_resource_cruds/industrial_tool.py,sha256=iZJGzo02cVjs_9zcVobe84mkBe5HcTzFEZU7HAA1RZ0,7867
 cognite_toolkit/_cdf_tk/cruds/_resource_cruds/location.py,sha256=sOZunu027t-2ocuICqc2WgRYOMVYxc7n2fVgXmIfkmo,12226
 cognite_toolkit/_cdf_tk/cruds/_resource_cruds/migration.py,sha256=8-7QgL4g-DMJHwBbOFAg4QscMNA1RMCqHfZYQlSNKU4,4467
-cognite_toolkit/_cdf_tk/cruds/_resource_cruds/raw.py,sha256=T_j0vJp8URJGsKeTi_bYvnNtdte_Axw5htmsu0CfG88,12104
+cognite_toolkit/_cdf_tk/cruds/_resource_cruds/raw.py,sha256=r3hXvK9zmFwP0BwAM5PefpVnxX_O40dIzW3bgIH4apU,12508
 cognite_toolkit/_cdf_tk/cruds/_resource_cruds/relationship.py,sha256=TO2Y6TZJEGxyKv7EMOtyyALz3Wyigp0mwBSQVTL-D5A,6330
 cognite_toolkit/_cdf_tk/cruds/_resource_cruds/robotics.py,sha256=T24aBMldMKCAChIh-yyVtXTdjel3nLtpqHnpVUrkdxA,17284
 cognite_toolkit/_cdf_tk/cruds/_resource_cruds/simulators.py,sha256=LupOpIf8SCiOGA36T5Gkh-_VGpsI4B_vKjXqp3a9Eyk,5139
 cognite_toolkit/_cdf_tk/cruds/_resource_cruds/streams.py,sha256=tzloZdY1THodpkWIS4pOyq78ektTg1G7GdIf3A-TiJ4,2712
 cognite_toolkit/_cdf_tk/cruds/_resource_cruds/three_d_model.py,sha256=5jIRF2JqosVHyAi2Ek6H38K2FWcNqrbPOR6MTSIEAQI,7320
 cognite_toolkit/_cdf_tk/cruds/_resource_cruds/timeseries.py,sha256=k6E-BWU2RVJCzC_HAUhzbHzensvRt4b3vNa3GSvFr-M,23262
-cognite_toolkit/_cdf_tk/cruds/_resource_cruds/transformation.py,sha256=ZaC2VFjuGAfdvCozIAWIPhrpBk68HJ-q9VzJ_j7Fel4,35147
+cognite_toolkit/_cdf_tk/cruds/_resource_cruds/transformation.py,sha256=AZ1sBL1FfodY-tHDoBwE2Z0pxOJRkmFSvkuR0a4hzTQ,35174
 cognite_toolkit/_cdf_tk/cruds/_resource_cruds/workflow.py,sha256=dVkf7OpZHV2H7V3zRU4BzUqDxgAudiWBJPvGeydATCg,26035
 cognite_toolkit/_cdf_tk/cruds/_worker.py,sha256=QeZjziBCePilyI4WfTZvLfSHGT3qJGCMhugsoO1SVtU,9285
 cognite_toolkit/_cdf_tk/data_classes/__init__.py,sha256=kh4S_jNDDWdTjCCnd5r5PC7zrbdyDQkoOSEofTk6p8A,1788
@@ -422,13 +422,13 @@ cognite_toolkit/_repo_files/.gitignore,sha256=ip9kf9tcC5OguF4YF4JFEApnKYw0nG0vPi
 cognite_toolkit/_repo_files/AzureDevOps/.devops/README.md,sha256=OLA0D7yCX2tACpzvkA0IfkgQ4_swSd-OlJ1tYcTBpsA,240
 cognite_toolkit/_repo_files/AzureDevOps/.devops/deploy-pipeline.yml,sha256=brULcs8joAeBC_w_aoWjDDUHs3JheLMIR9ajPUK96nc,693
 cognite_toolkit/_repo_files/AzureDevOps/.devops/dry-run-pipeline.yml,sha256=OBFDhFWK1mlT4Dc6mDUE2Es834l8sAlYG50-5RxRtHk,723
-cognite_toolkit/_repo_files/GitHub/.github/workflows/deploy.yaml,sha256=mLX7mk67EbTTuk5nLeBVX5W00Qr5qws3m1rcDhNTS8I,667
-cognite_toolkit/_repo_files/GitHub/.github/workflows/dry-run.yaml,sha256=Em2NrLmzSXoC0unS0T7jScoXBvNIwiWiQqjpxrlZAqU,2430
-cognite_toolkit/_resources/cdf.toml,sha256=jUrBs9kaWCqrddLWO98ocy7A96nNsSHx8i4PgnORl7Q,475
-cognite_toolkit/_version.py,sha256=DQjgAhJ7BheUI8L_BTcTxlzhNLRwBDER7brNdQT-_MM,23
+cognite_toolkit/_repo_files/GitHub/.github/workflows/deploy.yaml,sha256=y92vr2Yf36Dw19nT74tdpb0WSJqmVH32XlvwVJylwMw,667
+cognite_toolkit/_repo_files/GitHub/.github/workflows/dry-run.yaml,sha256=ntDuqKOaKN8WEqkHxMaFh5867tTJgeU7hUxMsnda6GY,2430
+cognite_toolkit/_resources/cdf.toml,sha256=zGzMHHtMChwOWSI3UaxNDMrwpglXotfZrQaqVuX1tBo,475
+cognite_toolkit/_version.py,sha256=0qgJZKjPWJ5p3y1R3oknCsIey5b4BLuDg9x76OvjeIE,23
 cognite_toolkit/demo/__init__.py,sha256=-m1JoUiwRhNCL18eJ6t7fZOL7RPfowhCuqhYFtLgrss,72
 cognite_toolkit/demo/_base.py,sha256=6xKBUQpXZXGQ3fJ5f7nj7oT0s2n7OTAGIa17ZlKHZ5U,8052
-cognite_toolkit-0.7.72.dist-info/WHEEL,sha256=fAguSjoiATBe7TNBkJwOjyL1Tt4wwiaQGtNtjRPNMQA,80
-cognite_toolkit-0.7.72.dist-info/entry_points.txt,sha256=EtZ17K2mUjh-AY0QNU1CPIB_aDSSOdmtNI_4Fj967mA,84
-cognite_toolkit-0.7.72.dist-info/METADATA,sha256=l8cUtnFpX43L8JVOVMuH9b6dSrNRpAcHTzBYzUtDKB8,5026
-cognite_toolkit-0.7.72.dist-info/RECORD,,
+cognite_toolkit-0.7.73.dist-info/WHEEL,sha256=fAguSjoiATBe7TNBkJwOjyL1Tt4wwiaQGtNtjRPNMQA,80
+cognite_toolkit-0.7.73.dist-info/entry_points.txt,sha256=EtZ17K2mUjh-AY0QNU1CPIB_aDSSOdmtNI_4Fj967mA,84
+cognite_toolkit-0.7.73.dist-info/METADATA,sha256=90hbNfG8cEzWCXTAOpXTch7TGlEL2rr2IyH0Nwit_Ww,5026
+cognite_toolkit-0.7.73.dist-info/RECORD,,