cognite-toolkit 0.6.79__py3-none-any.whl → 0.6.80__py3-none-any.whl

cognite_toolkit/_cdf_tk/commands/_migrate/migration_io.py

@@ -0,0 +1,203 @@
+from collections.abc import Iterator, Mapping, Sequence
+from typing import ClassVar, cast
+
+from cognite.client.data_classes._base import (
+    T_WritableCogniteResource,
+)
+from cognite.client.data_classes.data_modeling import InstanceApply, NodeId
+
+from cognite_toolkit._cdf_tk.client import ToolkitClient
+from cognite_toolkit._cdf_tk.client.data_classes.pending_instances_ids import PendingInstanceId
+from cognite_toolkit._cdf_tk.constants import MISSING_EXTERNAL_ID, MISSING_INSTANCE_SPACE
+from cognite_toolkit._cdf_tk.exceptions import ToolkitNotImplementedError
+from cognite_toolkit._cdf_tk.storageio import (
+    HierarchyIO,
+    InstanceIO,
+    UploadableStorageIO,
+)
+from cognite_toolkit._cdf_tk.storageio._base import Page, UploadItem
+from cognite_toolkit._cdf_tk.utils.collection import chunker_sequence
+from cognite_toolkit._cdf_tk.utils.http_client import HTTPClient, HTTPMessage, ItemsRequest, SuccessResponseItems
+from cognite_toolkit._cdf_tk.utils.useful_types import (
+    AssetCentricKind,
+    AssetCentricType,
+    JsonVal,
+)
+
+from .data_classes import AssetCentricMapping, AssetCentricMappingList, MigrationMapping, MigrationMappingList
+from .data_model import INSTANCE_SOURCE_VIEW_ID
+from .selectors import AssetCentricMigrationSelector, MigrateDataSetSelector, MigrationCSVFileSelector
+
+
+class AssetCentricMigrationIO(
+    UploadableStorageIO[AssetCentricMigrationSelector, AssetCentricMapping[T_WritableCogniteResource], InstanceApply]
+):
+    KIND = "AssetCentricMigration"
+    SUPPORTED_DOWNLOAD_FORMATS = frozenset({".parquet", ".csv", ".ndjson"})
+    SUPPORTED_COMPRESSIONS = frozenset({".gz"})
+    SUPPORTED_READ_FORMATS = frozenset({".parquet", ".csv", ".ndjson", ".yaml", ".yml"})
+    CHUNK_SIZE = 1000
+    UPLOAD_ENDPOINT = InstanceIO.UPLOAD_ENDPOINT
+
+    PENDING_INSTANCE_ID_ENDPOINT_BY_KIND: ClassVar[Mapping[AssetCentricKind, str]] = {
+        "TimeSeries": "/timeseries/set-pending-instance-ids",
+        "FileMetadata": "/files/set-pending-instance-ids",
+    }
+
+    def __init__(self, client: ToolkitClient, skip_linking: bool = True) -> None:
+        super().__init__(client)
+        self.hierarchy = HierarchyIO(client)
+        self.skip_linking = skip_linking
+
+    def as_id(self, item: AssetCentricMapping) -> str:
+        return f"{item.mapping.resource_type}_{item.mapping.id}"
+
+    def stream_data(self, selector: AssetCentricMigrationSelector, limit: int | None = None) -> Iterator[Page]:
+        if isinstance(selector, MigrationCSVFileSelector):
+            iterator = self._stream_from_csv(selector, limit)
+        elif isinstance(selector, MigrateDataSetSelector):
+            iterator = self._stream_given_dataset(selector, limit)
+        else:
+            raise ToolkitNotImplementedError(f"Selector {type(selector)} is not supported for stream_data")
+        yield from (Page(worker_id="main", items=items) for items in iterator)
+
+    def _stream_from_csv(
+        self, selector: MigrationCSVFileSelector, limit: int | None = None
+    ) -> Iterator[Sequence[AssetCentricMapping[T_WritableCogniteResource]]]:
+        items = selector.items
+        if limit is not None:
+            items = MigrationMappingList(items[:limit])
+        chunk: list[AssetCentricMapping[T_WritableCogniteResource]] = []
+        for current_batch in chunker_sequence(items, self.CHUNK_SIZE):
+            resources = self.hierarchy.get_resource_io(selector.kind).retrieve(current_batch.get_ids())
+            for mapping, resource in zip(current_batch, resources, strict=True):
+                chunk.append(AssetCentricMapping(mapping=mapping, resource=resource))
+            if chunk:
+                yield chunk
+                chunk = []
+
+    def count(self, selector: AssetCentricMigrationSelector) -> int | None:
+        if isinstance(selector, MigrationCSVFileSelector):
+            return len(selector.items)
+        elif isinstance(selector, MigrateDataSetSelector):
+            return self.hierarchy.count(selector.as_asset_centric_selector())
+        else:
+            raise ToolkitNotImplementedError(f"Selector {type(selector)} is not supported for count")
+
+    def _stream_given_dataset(
+        self, selector: MigrateDataSetSelector, limit: int | None = None
+    ) -> Iterator[Sequence[AssetCentricMapping[T_WritableCogniteResource]]]:
+        asset_centric_selector = selector.as_asset_centric_selector()
+        for data_chunk in self.hierarchy.stream_data(asset_centric_selector, limit):
+            mapping_list = AssetCentricMappingList[T_WritableCogniteResource]([])
+            for resource in data_chunk.items:
+                # We know data_set_id is here as we are using a DataSetSelector
+                data_set_id = cast(int, resource.data_set_id)
+                space_source = self.client.migration.space_source.retrieve(data_set_id=data_set_id)
+                instance_space = space_source.instance_space if space_source else None
+                if instance_space is None:
+                    instance_space = MISSING_INSTANCE_SPACE
+                external_id = resource.external_id
+                if external_id is None:
+                    external_id = MISSING_EXTERNAL_ID.format(project=self.client.config.project, id=resource.id)
+                mapping = MigrationMapping(
+                    resource_type=self._kind_to_resource_type(selector.kind),
+                    instance_id=NodeId(
+                        space=instance_space,
+                        external_id=external_id,
+                    ),
+                    id=resource.id,
+                    data_set_id=resource.data_set_id,
+                    ingestion_view=selector.ingestion_mapping,
+                    preferred_consumer_view=selector.preferred_consumer_view,
+                )
+                mapping_list.append(AssetCentricMapping(mapping=mapping, resource=resource))
+            yield mapping_list
+
+    @staticmethod
+    def _kind_to_resource_type(kind: AssetCentricKind) -> AssetCentricType:
+        mapping: dict[AssetCentricKind, AssetCentricType] = {
+            "Assets": "asset",
+            "Events": "event",
+            "TimeSeries": "timeseries",
+            "FileMetadata": "file",
+        }
+        try:
+            return mapping[kind]
+        except KeyError as e:
+            raise ToolkitNotImplementedError(f"Kind '{kind}' is not supported") from e
+
+    def data_to_json_chunk(
+        self,
+        data_chunk: Sequence[AssetCentricMapping[T_WritableCogniteResource]],
+        selector: AssetCentricMigrationSelector | None = None,
+    ) -> list[dict[str, JsonVal]]:
+        return [item.dump() for item in data_chunk]
+
+    def json_to_resource(self, item_json: dict[str, JsonVal]) -> InstanceApply:
+        raise NotImplementedError()
+
+    def upload_items(
+        self,
+        data_chunk: Sequence[UploadItem[InstanceApply]],
+        http_client: HTTPClient,
+        selector: AssetCentricMigrationSelector | None = None,
+    ) -> Sequence[HTTPMessage]:
+        """Upload items by first linking them using files/set-pending-instance-ids and then uploading the instances."""
+        if self.skip_linking:
+            return list(super().upload_items(data_chunk, http_client, None))
+        elif selector is None:
+            raise ToolkitNotImplementedError(f"Selector must be provided for uploading {self.KIND} items.")
+        elif selector.kind not in self.PENDING_INSTANCE_ID_ENDPOINT_BY_KIND:
+            return list(super().upload_items(data_chunk, http_client, None))
+
+        pending_instance_id_endpoint = self.PENDING_INSTANCE_ID_ENDPOINT_BY_KIND[selector.kind]
+        results: list[HTTPMessage] = []
+        to_upload = self.link_asset_centric(data_chunk, http_client, results, pending_instance_id_endpoint)
+        if to_upload:
+            results.extend(list(super().upload_items(to_upload, http_client, None)))
+        return results
+
+    @classmethod
+    def link_asset_centric(
+        cls,
+        data_chunk: Sequence[UploadItem[InstanceApply]],
+        http_client: HTTPClient,
+        results: list[HTTPMessage],
+        pending_instance_id_endpoint: str,
+    ) -> Sequence[UploadItem[InstanceApply]]:
+        """Links asset-centric resources to their (uncreated) instances using the pending-instance-ids endpoint."""
+        config = http_client.config
+        successful_linked: set[str] = set()
+        for batch in chunker_sequence(data_chunk, cls.CHUNK_SIZE):
+            batch_results = http_client.request_with_retries(
+                message=ItemsRequest(
+                    endpoint_url=config.create_api_url(pending_instance_id_endpoint),
+                    method="POST",
+                    api_version="alpha",
+                    items=[
+                        UploadItem(source_id=item.source_id, item=cls.as_pending_instance_id(item.item))
+                        for item in batch
+                    ],
+                )
+            )
+            for res in batch_results:
+                if isinstance(res, SuccessResponseItems):
+                    successful_linked.update(res.ids)
+            results.extend(batch_results)
+        to_upload = [item for item in data_chunk if item.source_id in successful_linked]
+        return to_upload
+
+    @staticmethod
+    def as_pending_instance_id(item: InstanceApply) -> PendingInstanceId:
+        """Convert an InstanceApply to a PendingInstanceId for linking."""
+        source = next((source for source in item.sources if source.source == INSTANCE_SOURCE_VIEW_ID), None)
+        if source is None:
+            raise ValueError(f"Cannot extract ID from item of type {type(item).__name__!r}")
+        if not isinstance(source.properties["id"], int):
+            raise ValueError(f"Unexpected ID type: {type(source.properties['id']).__name__!r}")
+        id_ = source.properties["id"]
+        return PendingInstanceId(
+            pending_instance_id=NodeId(item.space, item.external_id),
+            id=id_,
+        )

cognite_toolkit/_cdf_tk/commands/_migrate/selectors.py

@@ -0,0 +1,66 @@
+from abc import ABC, abstractmethod
+from functools import cached_property
+from pathlib import Path
+from typing import Literal
+
+from cognite.client.data_classes.data_modeling import ViewId
+
+from cognite_toolkit._cdf_tk.commands._migrate.data_classes import MigrationMappingList
+from cognite_toolkit._cdf_tk.storageio import DataSelector
+from cognite_toolkit._cdf_tk.storageio.selectors import DataSetSelector
+from cognite_toolkit._cdf_tk.utils.useful_types import AssetCentricKind
+
+
+class AssetCentricMigrationSelector(DataSelector, ABC):
+    kind: AssetCentricKind
+
+    @abstractmethod
+    def get_ingestion_mappings(self) -> list[str]:
+        raise NotImplementedError()
+
+
+class MigrationCSVFileSelector(AssetCentricMigrationSelector):
+    type: Literal["migrationCSVFile"] = "migrationCSVFile"
+    datafile: Path
+
+    @property
+    def group(self) -> str:
+        return f"Migration_{self.kind}"
+
+    def __str__(self) -> str:
+        return f"file_{self.datafile.name}"
+
+    def get_ingestion_mappings(self) -> list[str]:
+        views = {item.get_ingestion_view() for item in self.items}
+        return sorted(views)
+
+    @cached_property
+    def items(self) -> MigrationMappingList:
+        return MigrationMappingList.read_csv_file(self.datafile, resource_type=self.kind)
+
+
+class MigrateDataSetSelector(AssetCentricMigrationSelector):
+    type: Literal["migrateDataSet"] = "migrateDataSet"
+    kind: AssetCentricKind
+    data_set_external_id: str
+    ingestion_mapping: str | None = None
+    preferred_consumer_view: ViewId | None = None
+
+    @property
+    def group(self) -> str:
+        return f"DataSet_{self.data_set_external_id}"
+
+    def __str__(self) -> str:
+        return self.kind
+
+    def get_schema_spaces(self) -> list[str] | None:
+        return None
+
+    def get_instance_spaces(self) -> list[str] | None:
+        return None
+
+    def get_ingestion_mappings(self) -> list[str]:
+        return [self.ingestion_mapping] if self.ingestion_mapping else []
+
+    def as_asset_centric_selector(self) -> DataSetSelector:
+        return DataSetSelector(data_set_external_id=self.data_set_external_id, kind=self.kind)

cognite_toolkit/_cdf_tk/commands/modules.py

@@ -4,7 +4,6 @@ import tempfile
 import zipfile
 from collections import Counter
 from hashlib import sha256
-from importlib import resources
 from pathlib import Path
 from types import TracebackType
 from typing import Any, Literal
@@ -23,8 +22,7 @@ from rich.rule import Rule
 from rich.table import Table
 from rich.tree import Tree
 
-import cognite_toolkit
-from cognite_toolkit._cdf_tk.cdf_toml import CDFToml
+from cognite_toolkit._cdf_tk.cdf_toml import CDFToml, Library
 from cognite_toolkit._cdf_tk.commands import _cli_commands as CLICommands
 from cognite_toolkit._cdf_tk.commands._base import ToolkitCommand
 from cognite_toolkit._cdf_tk.commands._changes import (
@@ -37,8 +35,8 @@ from cognite_toolkit._cdf_tk.commands._changes import (
     UpdateModuleVersion,
 )
 from cognite_toolkit._cdf_tk.constants import (
-    BUILTIN_MODULES,
     MODULES,
+    RESOURCES_PATH,
     SUPPORT_MODULE_UPGRADE_FROM_VERSION,
     EnvType,
 )
@@ -92,9 +90,15 @@ _FILE_DOWNLOADERS_BY_TYPE: dict[str, type[FileDownloader]] = {
 
 
 class ModulesCommand(ToolkitCommand):
-    def __init__(self, print_warning: bool = True, skip_tracking: bool = False, silent: bool = False):
+    def __init__(
+        self,
+        print_warning: bool = True,
+        skip_tracking: bool = False,
+        silent: bool = False,
+        module_source_dir: Path | None = None,
+    ):
         super().__init__(print_warning, skip_tracking, silent)
-        self._builtin_modules_path = Path(resources.files(cognite_toolkit.__name__)) / BUILTIN_MODULES  # type: ignore [arg-type]
+        self._module_source_dir: Path | None = module_source_dir
         self._temp_download_dir = Path(tempfile.gettempdir()) / MODULES
         if not self._temp_download_dir.exists():
             self._temp_download_dir.mkdir(parents=True, exist_ok=True)
@@ -282,7 +286,7 @@ class ModulesCommand(ToolkitCommand):
             destination.write_text(cdf_toml_content, encoding="utf-8")
 
     def create_cdf_toml(self, organization_dir: Path, env: EnvType = "dev") -> str:
-        cdf_toml_content = safe_read(self._builtin_modules_path / CDFToml.file_name)
+        cdf_toml_content = safe_read(RESOURCES_PATH / CDFToml.file_name)
         if organization_dir != Path.cwd():
             cdf_toml_content = cdf_toml_content.replace(
                 "#<PLACEHOLDER>",
@@ -302,6 +306,8 @@ default_organization_dir = "{organization_dir.name}"''',
         user_select: str | None = None,
         user_environments: list[str] | None = None,
         user_download_data: bool | None = None,
+        library_url: str | None = None,
+        library_checksum: str | None = None,
     ) -> None:
         if not organization_dir:
             new_line = "\n    "
@@ -315,7 +321,16 @@ default_organization_dir = "{organization_dir.name}"''',
 
         modules_root_dir = organization_dir / MODULES
 
-        packages, modules_source_path = self._get_available_packages()
+        if library_url:
+            if not library_checksum:
+                raise ToolkitRequiredValueError(
+                    "The '--library-checksum' is required when '--library-url' is provided."
+                )
+
+            user_library = Library(url=library_url, checksum=library_checksum)
+            packages, modules_source_path = self._get_available_packages(user_library)
+        else:
+            packages, modules_source_path = self._get_available_packages()
 
         if select_all:
             print(Panel("Instantiating all available modules"))
@@ -745,16 +760,22 @@ default_organization_dir = "{organization_dir.name}"''',
             modules_source_path=modules_source_path,
         )
 
-    def _get_available_packages(self) -> tuple[Packages, Path]:
+    def _get_available_packages(self, user_library: Library | None = None) -> tuple[Packages, Path]:
         """
         Returns a list of available packages, either from the CDF TOML file or from external libraries if the feature flag is enabled.
         If the feature flag is not enabled and no libraries are specified, it returns the built-in modules.
         """
 
         cdf_toml = CDFToml.load()
-        if Flags.EXTERNAL_LIBRARIES.is_enabled() and cdf_toml.libraries:
-            for library_name, library in cdf_toml.libraries.items():
+        if Flags.EXTERNAL_LIBRARIES.is_enabled() or user_library:
+            libraries = {"userdefined": user_library} if user_library else cdf_toml.libraries
+
+            for library_name, library in libraries.items():
                 try:
+                    additional_tracking_info = self._additional_tracking_info.setdefault("downloadedLibraryIds", [])
+                    if library_name not in additional_tracking_info:
+                        additional_tracking_info.append(library_name)
+
                     print(f"[green]Adding library {library_name} from {library.url}[/]")
                     # Extract filename from URL, fallback to library_name.zip if no filename found
                     from urllib.parse import urlparse
@@ -772,6 +793,18 @@ default_organization_dir = "{organization_dir.name}"''',
                         for warning in packages.warnings:
                             self.warn(warning)
                     self._validate_packages(packages, f"library {library_name}")
+
+                    # Track deployment pack download for each package and module
+                    for package in packages.values():
+                        downloaded_package_ids = self._additional_tracking_info.setdefault("downloadedPackageIds", [])
+                        if package.id and package.id not in downloaded_package_ids:
+                            downloaded_package_ids.append(package.id)
+
+                        downloaded_module_ids = self._additional_tracking_info.setdefault("downloadedModuleIds", [])
+                        for module in package.modules:
+                            if module.module_id and module.module_id not in downloaded_module_ids:
+                                downloaded_module_ids.append(module.module_id)
+
                     return packages, file_path.parent
                 except Exception as e:
                     if isinstance(e, ToolkitError):
@@ -785,9 +818,21 @@ default_organization_dir = "{organization_dir.name}"''',
             # If no libraries are specified or the flag is not enabled, load the built-in modules
             raise ValueError("No valid libraries found.")
         else:
-            packages = Packages.load(self._builtin_modules_path)
-            self._validate_packages(packages, "built-in modules")
-            return packages, self._builtin_modules_path
+            if user_library:
+                self.warn(
+                    MediumSeverityWarning(
+                        "External library provided but not enabled in cdf.toml. Please enable the feature flag and try again."
+                    )
+                )
+
+            if self._module_source_dir is None:
+                self.warn(
+                    MediumSeverityWarning("No external libraries and no local module source directory specified.")
+                )
+                return Packages(), Path(".")
+            packages = Packages.load(self._module_source_dir)
+            self._validate_packages(packages, self._module_source_dir.name)
+            return packages, self._module_source_dir
 
     def _validate_packages(self, packages: Packages, source_name: str) -> None:
         """

cognite_toolkit/_cdf_tk/constants.py

@@ -38,6 +38,7 @@ MODULES = "modules"
 REPO_FILES_DIR = "_repo_files"
 DOCKER_IMAGE_NAME = "cognite/toolkit"
 BUILD_FOLDER_ENCODING = "utf-8"
+RESOURCES = "_resources"
 
 ROOT_MODULES = [MODULES, CUSTOM_MODULES, COGNITE_MODULES, EXTERNAL_PACKAGE]
 MODULE_PATH_SEP = "/"
@@ -61,6 +62,7 @@ ROOT_PATH = Path(__file__).parent.parent
 COGNITE_MODULES_PATH = ROOT_PATH / COGNITE_MODULES
 MODULES_PATH = ROOT_PATH / MODULES
 BUILTIN_MODULES_PATH = ROOT_PATH / BUILTIN_MODULES
+RESOURCES_PATH = ROOT_PATH / RESOURCES
 SUPPORT_MODULE_UPGRADE_FROM_VERSION = "0.2.0"
 # This is used in the build directory to keep track of order and flatten the
 # module directory structure with accounting for duplicated names.
@@ -168,3 +170,4 @@ DATA_MANIFEST_STEM = "Manifest"
 
 # Migration Constants
 MISSING_INSTANCE_SPACE = "<InstanceSpaceMissing>"
+MISSING_EXTERNAL_ID = "INTERNAL_ID_project_{project}_id_{id}"

cognite_toolkit/_cdf_tk/feature_flags.py

@@ -29,10 +29,6 @@ class Flags(Enum):
         visible=True,
         description="Enables the support for repeating modules in the config file",
     )
-    POPULATE = FlagMetadata(
-        visible=True,
-        description="Enables support for the populate command",
-    )
     AGENTS = FlagMetadata(
         visible=True,
         description="Enables support for Atlas Agents and Agent Tools",

cognite_toolkit/_cdf_tk/storageio/_asset_centric.py

@@ -508,20 +508,20 @@ class HierarchyIO(ConfigurableStorageIO[AssetCentricSelector, AssetCentricResour
     def stream_data(
         self, selector: AssetCentricSelector, limit: int | None = None
     ) -> Iterable[Page[AssetCentricResource]]:
-        yield from self._get_io(selector).stream_data(selector, limit)
+        yield from self.get_resource_io(selector.kind).stream_data(selector, limit)
 
     def count(self, selector: AssetCentricSelector) -> int | None:
-        return self._get_io(selector).count(selector)
+        return self.get_resource_io(selector.kind).count(selector)
 
     def data_to_json_chunk(
         self, data_chunk: Sequence[AssetCentricResource], selector: AssetCentricSelector | None = None
     ) -> list[dict[str, JsonVal]]:
         if selector is None:
             raise ValueError(f"Selector must be provided to convert data to JSON chunk for {type(self).__name__}.)")
-        return self._get_io(selector).data_to_json_chunk(data_chunk, selector)
+        return self.get_resource_io(selector.kind).data_to_json_chunk(data_chunk, selector)
 
     def configurations(self, selector: AssetCentricSelector) -> Iterable[StorageIOConfig]:
-        yield from self._get_io(selector).configurations(selector)
+        yield from self.get_resource_io(selector.kind).configurations(selector)
 
-    def _get_io(self, selector: AssetCentricSelector) -> BaseAssetCentricIO:
-        return self._io_by_kind[selector.kind]
+    def get_resource_io(self, kind: str) -> BaseAssetCentricIO:
+        return self._io_by_kind[kind]

cognite_toolkit/_cdf_tk/storageio/_base.py

@@ -3,13 +3,13 @@ from collections.abc import Iterable, Mapping, Sequence, Sized
 from dataclasses import dataclass
 from typing import ClassVar, Generic, TypeVar
 
-from cognite.client.data_classes._base import CogniteObject, T_CogniteResource
+from cognite.client.data_classes._base import T_CogniteResource
 
 from cognite_toolkit._cdf_tk.client import ToolkitClient
 from cognite_toolkit._cdf_tk.exceptions import ToolkitNotImplementedError
 from cognite_toolkit._cdf_tk.utils.fileio import SchemaColumn
 from cognite_toolkit._cdf_tk.utils.http_client import HTTPClient, HTTPMessage, ItemsRequest
-from cognite_toolkit._cdf_tk.utils.useful_types import JsonVal
+from cognite_toolkit._cdf_tk.utils.useful_types import JsonVal, T_WriteCogniteResource
 
 from .selectors import DataSelector
 
@@ -35,9 +35,6 @@ class Page(Generic[T_CogniteResource], Sized):
         return len(self.items)
 
 
-T_WriteCogniteResource = TypeVar("T_WriteCogniteResource", bound=CogniteObject)
-
-
 @dataclass
 class UploadItem(Generic[T_WriteCogniteResource]):
     """An item to be uploaded to CDF, consisting of a source ID and the writable Cognite resource.

cognite_toolkit/_cdf_tk/utils/useful_types.py

@@ -3,7 +3,7 @@ from datetime import date, datetime
 from typing import Any, Literal, TypeAlias, TypeVar, get_args
 
 from cognite.client.data_classes import Asset, Event, FileMetadata, Sequence, TimeSeries
-from cognite.client.data_classes._base import WriteableCogniteResourceList
+from cognite.client.data_classes._base import CogniteObject, WriteableCogniteResourceList
 
 JsonVal: TypeAlias = None | str | int | float | bool | dict[str, "JsonVal"] | list["JsonVal"]
 
@@ -20,3 +20,5 @@ T_ID = TypeVar("T_ID", bound=Hashable)
 T_WritableCogniteResourceList = TypeVar("T_WritableCogniteResourceList", bound=WriteableCogniteResourceList)
 T_Value = TypeVar("T_Value")
 PrimitiveType: TypeAlias = str | int | float | bool
+
+T_WriteCogniteResource = TypeVar("T_WriteCogniteResource", bound=CogniteObject)

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

@@ -12,7 +12,7 @@ jobs:
     environment: dev
     name: Deploy
     container:
-      image: cognite/toolkit:0.6.79
+      image: cognite/toolkit:0.6.80
       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.6.79
+      image: cognite/toolkit:0.6.80
       env:
         CDF_CLUSTER: ${{ vars.CDF_CLUSTER }}
         CDF_PROJECT: ${{ vars.CDF_PROJECT }}

cognite_toolkit/_resources/cdf.toml

@@ -0,0 +1,13 @@
+[cdf]#<PLACEHOLDER>
+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.6.80"
+
+
+[plugins]
+run = true
+pull = false
+dump = false

cognite_toolkit/_version.py

@@ -1 +1 @@
-__version__ = "0.6.79"
+__version__ = "0.6.80"

{cognite_toolkit-0.6.79.dist-info → cognite_toolkit-0.6.80.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite_toolkit
-Version: 0.6.79
+Version: 0.6.80
 Summary: Official Cognite Data Fusion tool for project templates and configuration deployment
 Project-URL: Homepage, https://docs.cognite.com/cdf/deploy/cdf_toolkit/
 Project-URL: Changelog, https://github.com/cognitedata/toolkit/releases