cognite-toolkit 0.6.84__py3-none-any.whl → 0.6.86__py3-none-any.whl

cognite_toolkit/_cdf_tk/storageio/_asset_centric.py

@@ -67,7 +67,14 @@ from cognite_toolkit._cdf_tk.utils.useful_types import (
     T_WritableCogniteResourceList,
 )
 
-from ._base import ConfigurableStorageIO, Page, StorageIOConfig, TableStorageIO, UploadableStorageIO, UploadItem
+from ._base import (
+    ConfigurableStorageIO,
+    Page,
+    StorageIOConfig,
+    TableStorageIO,
+    UploadableStorageIO,
+    UploadItem,
+)
 from .selectors import AssetCentricSelector, AssetSubtreeSelector, DataSetSelector
 
 
@@ -179,6 +186,19 @@ class BaseAssetCentricIO(
             asset_ids.update(item.asset_ids or [])
         self.client.lookup.assets.external_id(list(asset_ids))
 
+    def data_to_row(
+        self, data_chunk: Sequence[T_WritableCogniteResource], selector: AssetCentricSelector | None = None
+    ) -> list[dict[str, JsonVal]]:
+        rows: list[dict[str, JsonVal]] = []
+        for chunk in self.data_to_json_chunk(data_chunk, selector):
+            if "metadata" in chunk and isinstance(chunk["metadata"], dict):
+                metadata = chunk.pop("metadata")
+                # MyPy does understand that metadata is a dict here due to the check above.
+                for key, value in metadata.items():  # type: ignore[union-attr]
+                    chunk[f"metadata.{key}"] = value
+            rows.append(chunk)
+        return rows
+
 
 class AssetIO(BaseAssetCentricIO[str, AssetWrite, Asset, AssetWriteList, AssetList]):
     KIND = "Assets"

cognite_toolkit/_cdf_tk/storageio/_base.py

@@ -230,3 +230,19 @@ class TableStorageIO(StorageIO[T_Selector, T_CogniteResource], ABC):
 
         """
         raise NotImplementedError()
+
+    @abstractmethod
+    def data_to_row(
+        self, data_chunk: Sequence[T_CogniteResource], selector: T_Selector | None = None
+    ) -> list[dict[str, JsonVal]]:
+        """Convert a chunk of data to a row-based JSON-compatible format.
+
+        Args:
+            data_chunk: The chunk of data to convert, which should be a writable Cognite resource list.
+            selector: Optional selection criteria to identify the data. This is required for some storage types.
+
+        Returns:
+            A list of dictionaries representing the data in a JSON-compatible format.
+
+        """
+        raise NotImplementedError()

cognite_toolkit/_cdf_tk/utils/aggregators.py

@@ -106,6 +106,15 @@ class AssetCentricAggregator(ABC):
                 seen.add(int_id)
         return ids
 
+    def _to_dataset_id(self, data_set_external_id: str | list[str] | None) -> list[int] | None:
+        """Converts data set external IDs to data set IDs."""
+        dataset_id: list[int] | None = None
+        if data_set_external_id is not None:
+            if isinstance(data_set_external_id, str):
+                data_set_external_id = [data_set_external_id]
+            dataset_id = self.client.lookup.data_sets.id(data_set_external_id, allow_empty=False)
+        return dataset_id
+
 
 class MetadataAggregator(AssetCentricAggregator, ABC, Generic[T_CogniteFilter]):
     filter_cls: type[T_CogniteFilter]
@@ -386,9 +395,10 @@ class RelationshipAggregator(AssetCentricAggregator):
     def count(
         self, hierarchy: str | list[str] | None = None, data_set_external_id: str | list[str] | None = None
     ) -> int:
-        if hierarchy is not None or data_set_external_id is not None:
+        if hierarchy is not None:
             raise NotImplementedError()
-        results = relationship_aggregate_count(self.client)
+        dataset_id = self._to_dataset_id(data_set_external_id)
+        results = relationship_aggregate_count(self.client, dataset_id)
         return sum(result.count for result in results)
 
     def used_data_sets(self, hierarchy: str | None = None) -> list[str]:
@@ -405,9 +415,10 @@ class LabelCountAggregator(AssetCentricAggregator):
     def count(
         self, hierarchy: str | list[str] | None = None, data_set_external_id: str | list[str] | None = None
     ) -> int:
-        if hierarchy is not None or data_set_external_id is not None:
+        if hierarchy is not None:
             raise NotImplementedError()
-        return label_aggregate_count(self.client)
+        data_set_id = self._to_dataset_id(data_set_external_id)
+        return label_aggregate_count(self.client, data_set_id)
 
     def used_data_sets(self, hierarchy: str | None = None) -> list[str]:
         raise NotImplementedError()

cognite_toolkit/_cdf_tk/utils/producer_worker.py

@@ -235,7 +235,7 @@ class ProducerWorkerExecutor(Generic[T_Download, T_Processed]):
                 break
             except Exception as e:
                 self._error_event.set()
-                self.error_message = str(e)
+                self.error_message = f"{type(e).__name__} {e!s}"
                 self.error_traceback = traceback.format_exc()
                 self.console.print(f"[red]Error[/red] occurred while {self.download_description}: {self.error_message}")
                 break
@@ -275,7 +275,7 @@ class ProducerWorkerExecutor(Generic[T_Download, T_Processed]):
                 continue
             except Exception as e:
                 self._error_event.set()
-                self.error_message = str(e)
+                self.error_message = f"{type(e).__name__} {e!s}"
                 self.error_traceback = traceback.format_exc()
                 self.console.print(f"[red]Error[/red] occurred while {self.process_description}: {self.error_message}")
                 break
@@ -297,7 +297,7 @@ class ProducerWorkerExecutor(Generic[T_Download, T_Processed]):
                 continue
             except Exception as e:
                 self._error_event.set()
-                self.error_message = str(e)
+                self.error_message = f"{type(e).__name__} {e!s}"
                 self.error_traceback = traceback.format_exc()
                 self.console.print(f"[red]Error[/red] occurred while {self.write_description}: {self.error_message}")
                 break

cognite_toolkit/_cdf_tk/utils/validate_access.py

@@ -1,19 +1,32 @@
 from collections.abc import Sequence
-from typing import Literal
+from typing import Literal, TypeAlias, overload
 
 from cognite.client.data_classes.capabilities import (
+    AllScope,
     AssetsAcl,
     Capability,
     DataModelInstancesAcl,
     DataModelsAcl,
+    DataSetScope,
+    EventsAcl,
+    ExtractionPipelinesAcl,
     FilesAcl,
+    LabelsAcl,
+    RelationshipsAcl,
+    SequencesAcl,
+    ThreeDAcl,
     TimeSeriesAcl,
+    TransformationsAcl,
+    WorkflowOrchestrationAcl,
 )
 
 from cognite_toolkit._cdf_tk.client import ToolkitClient
 from cognite_toolkit._cdf_tk.exceptions import AuthorizationError
+from cognite_toolkit._cdf_tk.tk_warnings import HighSeverityWarning
 from cognite_toolkit._cdf_tk.utils import humanize_collection
 
+Action: TypeAlias = Literal["read", "write"]
+
 
 class ValidateAccess:
     def __init__(self, client: ToolkitClient, default_operation: str) -> None:
@@ -21,12 +34,12 @@ class ValidateAccess:
         self.default_operation = default_operation
 
     def data_model(
-        self, action: Sequence[Literal["read", "write"]], spaces: set[str] | None = None, operation: str | None = None
+        self, action: Sequence[Action], spaces: set[str] | None = None, operation: str | None = None
     ) -> list[str] | None:
         """Validate access to data models.
 
         Args:
-            action (Sequence[Literal["read", "write"]]): The actions to validate access for.
+            action (Sequence[Action]): The actions to validate access for.
             spaces (Set[str] | None): The space IDs to check access for. If None, checks access for all spaces.
             operation (str | None): The operation being performed, used for error messages.
 
@@ -38,7 +51,7 @@ class ValidateAccess:
             AuthorizationError: If the user does not have permission to perform the specified action on the given space.
         """
         operation = operation or self.default_operation
-        model_scopes, actions_str = self._set_up_read_write(
+        model_scopes = self._get_scopes(
             action, DataModelsAcl.Action.Read, DataModelsAcl.Action.Write, operation, "data models"
         )
         if len(model_scopes) != 1:
@@ -51,19 +64,20 @@ class ValidateAccess:
                 return model_scope.space_ids
             if missing := spaces - set(model_scope.space_ids):
                 raise AuthorizationError(
-                    f"You have no permission to {actions_str} the {humanize_collection(missing)!r} space(s). This is required to {operation}."
+                    f"You have no permission to {humanize_collection(action)} the {humanize_collection(missing)!r} "
+                    f"space(s). This is required to {operation}."
                 )
             return None
         else:
             raise ValueError(f"Unexpected data model scope type: {type(model_scope)}. Expected SpaceID or All.")
 
     def instances(
-        self, action: Sequence[Literal["read", "write"]], spaces: set[str] | None = None, operation: str | None = None
+        self, action: Sequence[Action], spaces: set[str] | None = None, operation: str | None = None
     ) -> list[str] | None:
         """Validate access to data model instances.
 
         Args:
-            action (Sequence[Literal["read", "write"]]): The actions to validate access for.
+            action (Sequence[Action]): The actions to validate access for.
             spaces (Set[str] | None): The space IDs to check access for. If None, checks access for all spaces.
             operation (str | None): The operation being performed, used for error messages.
 
@@ -75,7 +89,7 @@ class ValidateAccess:
             AuthorizationError: If the user does not have permission to perform the specified action on the given space.
         """
         operation = operation or self.default_operation
-        instance_scopes, action_str = self._set_up_read_write(
+        instance_scopes = self._get_scopes(
             action, DataModelInstancesAcl.Action.Read, DataModelInstancesAcl.Action.Write, operation, "instances"
         )
         if len(instance_scopes) != 1:
@@ -88,7 +102,8 @@ class ValidateAccess:
                 return instance_scope.space_ids
             if missing := spaces - set(instance_scope.space_ids):
                 raise AuthorizationError(
-                    f"You have no permission to {action_str} instances in the {humanize_collection(missing)!r} space(s). This is required to {operation} instances."
+                    f"You have no permission to {humanize_collection(action)} instances in the "
+                    f"{humanize_collection(missing)!r} space(s). This is required to {operation} instances."
                 )
             return None
         elif isinstance(instance_scope, DataModelInstancesAcl.Scope.All):
@@ -98,12 +113,37 @@ class ValidateAccess:
                 f"Unexpected data model instance scope type: {type(instance_scope)}. Expected SpaceID or All."
             )
 
+    @overload
+    def dataset_data(
+        self,
+        action: Sequence[Action],
+        dataset_ids: set[int],
+        operation: str | None = None,
+        missing_access: Literal["raise", "warn"] = "raise",
+    ) -> None: ...
+
+    @overload
     def dataset_data(
         self,
-        action: Sequence[Literal["read", "write"]],
+        action: Sequence[Action],
+        dataset_ids: None = None,
+        operation: str | None = None,
+        missing_access: Literal["raise", "warn"] = "raise",
+    ) -> (
+        dict[Literal["assets", "events", "time series", "files", "relationships", "labels", "3D models"], list[int]]
+        | None
+    ): ...
+
+    def dataset_data(
+        self,
+        action: Sequence[Action],
         dataset_ids: set[int] | None = None,
         operation: str | None = None,
-    ) -> list[int] | None:
+        missing_access: Literal["raise", "warn"] = "raise",
+    ) -> (
+        dict[Literal["assets", "events", "time series", "files", "relationships", "labels", "3D models"], list[int]]
+        | None
+    ):
         """Validate access to dataset data.
 
         Dataset data resources are:
@@ -117,23 +157,69 @@ class ValidateAccess:
         - 3D models
 
         Args:
-            action (Sequence[Literal["read", "write"]]): The actions to validate access for
+            action (Sequence[Action]): The actions to validate access for
             dataset_ids (Set[int] | None): The dataset IDs to check access for. If None, checks access for all datasets.
-            operation (str | None): The operation being performed, used for error messages.
+            operation (str | None): The operation being performed, used for error and warning messages.
+            missing_access (Literal["raise", "warn"]): Whether to raise an error or warn when access is missing for specified datasets.
+
         Returns:
-            list[int] | None: Returns a list of dataset IDs if access is limited to these datasets, or None if access is granted to all datasets.
+            dict[
+                Literal["assets", "events", "time series", "files", "relationships", "labels", "3D models"], list[int]
+            ] | None:
+                If dataset_ids is None, returns a dictionary with keys as dataset data resource names and values as lists of dataset IDs the user has access to.
+                If dataset_ids is provided, returns None if the user has access to all specified datasets for all dataset data resources.
         Raises:
             ValueError: If the client.token.get_scope() returns an unexpected dataset data scope type.
             AuthorizationError: If the user does not have permission to perform the specified action on the given dataset.
         """
-        raise NotImplementedError()
+        acls: list[tuple[str, list[Capability.Action], list[Capability.Action]]] = [
+            ("assets", [AssetsAcl.Action.Read], [AssetsAcl.Action.Write]),
+            ("events", [EventsAcl.Action.Read], [EventsAcl.Action.Write]),
+            ("time series", [TimeSeriesAcl.Action.Read], [TimeSeriesAcl.Action.Write]),
+            ("files", [FilesAcl.Action.Read], [FilesAcl.Action.Write]),
+            ("sequences", [SequencesAcl.Action.Read], [SequencesAcl.Action.Write]),
+            ("relationships", [RelationshipsAcl.Action.Read], [RelationshipsAcl.Action.Write]),
+            ("labels", [LabelsAcl.Action.Read], [LabelsAcl.Action.Write]),
+            (
+                "3D models",
+                [ThreeDAcl.Action.Read],
+                [ThreeDAcl.Action.Create, ThreeDAcl.Action.Update, ThreeDAcl.Action.Delete],
+            ),
+        ]
+        # MyPy does not understand that with the acl above, we get the correct return value.
+        return self._dataset_access_check(  # type: ignore[return-value]
+            action,
+            dataset_ids=dataset_ids,
+            operation=operation,
+            acls=acls,
+            missing_access=missing_access,
+        )
 
+    @overload
     def dataset_configurations(
         self,
-        action: Sequence[Literal["read", "write"]],
+        action: Sequence[Action],
+        dataset_ids: set[int],
+        operation: str | None = None,
+        missing_access: Literal["raise", "warn"] = "raise",
+    ) -> None: ...
+
+    @overload
+    def dataset_configurations(
+        self,
+        action: Sequence[Action],
+        dataset_ids: None = None,
+        operation: str | None = None,
+        missing_access: Literal["raise", "warn"] = "raise",
+    ) -> dict[Literal["transformations", "workflows", "extraction pipelines"], list[int]] | None: ...
+
+    def dataset_configurations(
+        self,
+        action: Sequence[Action],
         dataset_ids: set[int] | None = None,
         operation: str | None = None,
-    ) -> list[int] | None:
+        missing_access: Literal["raise", "warn"] = "raise",
+    ) -> dict[Literal["transformations", "workflows", "extraction pipelines"], list[int]] | None:
         """Validate access configuration resources.
 
         Configuration resources are:
@@ -142,26 +228,92 @@ class ValidateAccess:
         - Extraction pipelines
 
         Args:
-            action (Sequence[Literal["read", "write"]]): The actions to validate access for
+            action (Sequence[Action]): The actions to validate access for
             dataset_ids (Set[int] | None): The dataset IDs to check access for. If None, checks access for all datasets.
-            operation (str | None): The operation being performed, used for error messages.
+            operation (str | None): The operation being performed, used for error and warning messages.
+            missing_access (Literal["raise", "warn"]): Whether to raise an error or warn when access is missing for specified datasets.
+
         Returns:
-            list[int] | None: Returns a list of dataset IDs if access is limited to these datasets, or None if access is granted to all datasets.
+            dict[Literal["transformations", "workflows", "extraction pipelines"], list[int] | None]:
+                If dataset_ids is None, returns a dictionary with keys as configuration resource names and values as lists of dataset IDs the user has access to.
+                If dataset_ids is provided, returns None if the user has access to all specified datasets for all configuration resources.
+
         Raises:
             ValueError: If the client.token.get_scope() returns an unexpected dataset configuration scope type.
             AuthorizationError: If the user does not have permission to perform the specified action on the given dataset.
         """
-        raise NotImplementedError()
+        acls: list[tuple[str, list[Capability.Action], list[Capability.Action]]] = [
+            ("transformations", [TransformationsAcl.Action.Read], [TransformationsAcl.Action.Write]),
+            ("workflows", [WorkflowOrchestrationAcl.Action.Read], [WorkflowOrchestrationAcl.Action.Write]),
+            ("extraction pipelines", [ExtractionPipelinesAcl.Action.Read], [ExtractionPipelinesAcl.Action.Write]),
+        ]
+        # MyPy does not understand that with the acl above, we get the correct return value.
+        return self._dataset_access_check(  # type: ignore[return-value]
+            action,
+            dataset_ids=dataset_ids,
+            operation=operation,
+            acls=acls,
+            missing_access=missing_access,
+        )
+
+    def _dataset_access_check(
+        self,
+        action: Sequence[Action],
+        dataset_ids: set[int] | None,
+        operation: str | None,
+        missing_access: Literal["raise", "warn"],
+        acls: Sequence[tuple[str, list[Capability.Action], list[Capability.Action]]],
+    ) -> dict[str, list[int]] | None:
+        need_access_to = set(dataset_ids) if dataset_ids is not None else None
+        no_access: list[str] = []
+        output: dict[str, list[int]] = {}
+        for name, read_actions, write_actions in acls:
+            actions = [
+                acl_action for word in action for acl_action in {"read": read_actions, "write": write_actions}[word]
+            ]
+            scopes = self.client.token.get_scope(actions)
+            if scopes is None:
+                no_access.append(name)
+                continue
+            # First check for 'all' scope
+            for scope in scopes:
+                if isinstance(scope, AllScope):
+                    break
+            else:
+                # No 'all' scope found, check dataset scopes
+                for scope in scopes:
+                    if isinstance(scope, DataSetScope):
+                        if need_access_to is None:
+                            output[name] = scope.ids
+                            break
+                        missing_data_set = need_access_to - set(scope.ids)
+                        if missing_data_set:
+                            no_access.append(name)
+                            break
+        operation = operation or self.default_operation
+        if no_access:
+            message = f"You have no permission to {humanize_collection(action)} {humanize_collection(no_access)}."
+            if dataset_ids:
+                dataset_external_ids = self.client.lookup.data_sets.external_id(list(dataset_ids))
+                plural = "s" if len(dataset_external_ids) > 1 else ""
+                message = f"{message[:-1]} on dataset{plural} {humanize_collection(dataset_external_ids)}."
+            if missing_access == "raise":
+                raise AuthorizationError(f"{message} This is required to {operation}.")
+            else:
+                HighSeverityWarning(f"{message}. You will have limited functionality to {operation}.").print_warning()
+        elif dataset_ids is not None:
+            return None
+        return output or None
 
     def timeseries(
         self,
-        action: Sequence[Literal["read", "write"]],
+        action: Sequence[Action],
         dataset_ids: set[int] | None = None,
         operation: str | None = None,
     ) -> dict[str, list[str]] | None:
         """Validate access to time series.
         Args:
-            action (Sequence[Literal["read", "write"]]): The actions to validate access for.
+            action (Sequence[Action]): The actions to validate access for.
             dataset_ids (Set[int] | None): The dataset IDs to check access for. If None, checks access for all datasets.
             operation (str | None): The operation being performed, used for error messages.
         Returns:
@@ -171,7 +323,7 @@ class ValidateAccess:
             AuthorizationError: If the user does not have permission to perform the specified action on the given dataset or time series.
         """
         operation = operation or self.default_operation
-        timeseries_scopes, actions_str = self._set_up_read_write(
+        timeseries_scopes = self._get_scopes(
             action, TimeSeriesAcl.Action.Read, TimeSeriesAcl.Action.Write, operation, "time series"
         )
 
@@ -185,7 +337,7 @@ class ValidateAccess:
                     if not missing:
                         return None
             raise AuthorizationError(
-                f"You have no permission to {actions_str} time series in dataset {humanize_collection(missing)}. This is required to {operation}."
+                f"You have no permission to {humanize_collection(action)} time series in dataset {humanize_collection(missing)}. This is required to {operation}."
             )
         output: dict[str, list[str]] = {}
         for scope in timeseries_scopes:
@@ -204,14 +356,14 @@ class ValidateAccess:
 
     def files(
         self,
-        action: Sequence[Literal["read", "write"]],
+        action: Sequence[Action],
         dataset_ids: set[int] | None = None,
         operation: str | None = None,
     ) -> dict[str, list[str]] | None:
         """Validate access to files.
 
         Args:
-            action (Sequence[Literal["read", "write"]]): The actions to validate access for
+            action (Sequence[Action]): The actions to validate access for
             dataset_ids (Set[int] | None): The dataset IDs to check access for. If None, checks access for all datasets.
             operation (str | None): The operation being performed, used for error messages.
         Returns:
@@ -222,9 +374,7 @@ class ValidateAccess:
                 dataset.
         """
         operation = operation or self.default_operation
-        file_scopes, actions_str = self._set_up_read_write(
-            action, FilesAcl.Action.Read, FilesAcl.Action.Write, operation, "files"
-        )
+        file_scopes = self._get_scopes(action, FilesAcl.Action.Read, FilesAcl.Action.Write, operation, "files")
         if isinstance(file_scopes[0], FilesAcl.Scope.All):
             return None
         if dataset_ids is not None:
@@ -235,7 +385,8 @@ class ValidateAccess:
                     if not missing:
                         return None
             raise AuthorizationError(
-                f"You have no permission to {actions_str} files in dataset {humanize_collection(missing)}. This is required to {operation}."
+                f"You have no permission to {humanize_collection(action)} files in dataset "
+                f"{humanize_collection(missing)}. This is required to {operation}."
             )
         output: dict[str, list[str]] = {}
         for scope in file_scopes:
@@ -247,13 +398,13 @@ class ValidateAccess:
 
     def assets(
         self,
-        action: Sequence[Literal["read", "write"]],
+        action: Sequence[Action],
         dataset_ids: set[int] | None = None,
         operation: str | None = None,
     ) -> dict[str, list[str]] | None:
         """Validate access to assets.
         Args:
-            action (Sequence[Literal["read", "write"]]): The actions to validate access for
+            action (Sequence[Action]): The actions to validate access for
             dataset_ids (Set[int] | None): The dataset IDs to check access for. If None, checks access for all datasets.
             operation (str | None): The operation being performed, used for error messages.
         Returns:
@@ -265,9 +416,7 @@ class ValidateAccess:
                 dataset.
         """
         operation = operation or self.default_operation
-        asset_scopes, actions_str = self._set_up_read_write(
-            action, AssetsAcl.Action.Read, AssetsAcl.Action.Write, operation, "assets"
-        )
+        asset_scopes = self._get_scopes(action, AssetsAcl.Action.Read, AssetsAcl.Action.Write, operation, "assets")
         if isinstance(asset_scopes[0], AssetsAcl.Scope.All):
             return None
         if dataset_ids is not None:
@@ -278,7 +427,8 @@ class ValidateAccess:
                     if not missing:
                         return None
             raise AuthorizationError(
-                f"You have no permission to {actions_str} assets in dataset(s) {humanize_collection(missing)}. This is required to {operation}."
+                f"You have no permission to {humanize_collection(action)} assets in dataset(s) "
+                f"{humanize_collection(missing)}. This is required to {operation}."
             )
         output: dict[str, list[str]] = {}
         for scope in asset_scopes:
@@ -288,19 +438,31 @@ class ValidateAccess:
                 raise ValueError(f"Unexpected asset scope type: {type(scope)}. Expected DataSet or All.")
         return output
 
-    def _set_up_read_write(
+    def _get_scopes(
         self,
-        action: Sequence[Literal["read", "write"]],
+        action: Sequence[Action],
         read: Capability.Action,
         write: Capability.Action,
         operation: str,
         name: str,
-    ) -> tuple[list[Capability.Scope], str]:
-        actions_str = humanize_collection(action, bind_word="and")
+    ) -> list[Capability.Scope]:
+        """Helper method to get scopes for the given action.
+
+        Args:
+            action (Sequence[Action]): The actions to validate access for.
+            read (Capability.Action): The read action.
+            write (Capability.Action): The write action.
+            operation (str): The operation being performed, used for error messages.
+            name (str): The name of the resource being accessed, used for error messages.
+
+        Returns:
+            list[Capability.Scope]: The scopes for the given action.
+        """
         actions = [{"read": read, "write": write}[a] for a in action]
         scopes = self.client.token.get_scope(actions)
         if scopes is None:
             raise AuthorizationError(
-                f"You have no permission to {actions_str} {name}. This is required to {operation}."
+                f"You have no permission to {humanize_collection(action, bind_word='and')} {name}. "
+                f"This is required to {operation}."
             )
-        return scopes, actions_str
+        return scopes

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

@@ -12,7 +12,7 @@ jobs:
     environment: dev
     name: Deploy
     container:
-      image: cognite/toolkit:0.6.84
+      image: cognite/toolkit:0.6.86
       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.84
+      image: cognite/toolkit:0.6.86
       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.6.84"
+version = "0.6.86"
 
 [alpha_flags]
 external-libraries = true

cognite_toolkit/_version.py

@@ -1 +1 @@
-__version__ = "0.6.84"
+__version__ = "0.6.86"

{cognite_toolkit-0.6.84.dist-info → cognite_toolkit-0.6.86.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite_toolkit
-Version: 0.6.84
+Version: 0.6.86
 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