cognite-toolkit 0.5.97__py3-none-any.whl → 0.7.34__py3-none-any.whl

cognite_toolkit/_cdf_tk/{loaders/_resource_loaders/workflow_loaders.py → cruds/_resource_cruds/workflow.py}

@@ -15,7 +15,6 @@
 
 import json
 from collections.abc import Hashable, Iterable, Sequence
-from functools import lru_cache
 from graphlib import CycleError, TopologicalSorter
 from pathlib import Path
 from typing import Any, final
@@ -23,37 +22,36 @@ from typing import Any, final
 from cognite.client.data_classes import (
     ClientCredentials,
     Workflow,
-    WorkflowList,
     WorkflowTrigger,
-    WorkflowTriggerList,
     WorkflowTriggerUpsert,
-    WorkflowTriggerUpsertList,
     WorkflowUpsert,
-    WorkflowUpsertList,
     WorkflowVersion,
     WorkflowVersionId,
-    WorkflowVersionList,
     WorkflowVersionUpsert,
-    WorkflowVersionUpsertList,
 )
 from cognite.client.data_classes.capabilities import (
     Capability,
     WorkflowOrchestrationAcl,
 )
-from cognite.client.data_classes.workflows import SubworkflowReferenceParameters
+from cognite.client.data_classes.workflows import (
+    SubworkflowReferenceParameters,
+    WorkflowList,
+    WorkflowTriggerList,
+    WorkflowVersionList,
+)
 from cognite.client.exceptions import CogniteAuthError, CogniteNotFoundError
 from cognite.client.utils.useful_types import SequenceNotStr
 from rich import print
 from rich.console import Console
 
-from cognite_toolkit._cdf_tk._parameters import ANY_INT, ANY_STR, ANYTHING, ParameterSpec, ParameterSpecSet
 from cognite_toolkit._cdf_tk.client import ToolkitClient
+from cognite_toolkit._cdf_tk.cruds._base_cruds import ResourceCRUD
 from cognite_toolkit._cdf_tk.exceptions import (
     ResourceCreationError,
     ToolkitCycleError,
     ToolkitRequiredValueError,
 )
-from cognite_toolkit._cdf_tk.loaders._base_loaders import ResourceLoader
+from cognite_toolkit._cdf_tk.resource_classes import WorkflowTriggerYAML, WorkflowVersionYAML, WorkflowYAML
 from cognite_toolkit._cdf_tk.tk_warnings import (
     LowSeverityWarning,
     MissingReferencedWarning,
@@ -63,36 +61,33 @@ from cognite_toolkit._cdf_tk.utils import (
     calculate_secure_hash,
     humanize_collection,
     load_yaml_inject_variables,
-    to_directory_compatible,
+    sanitize_filename,
 )
 from cognite_toolkit._cdf_tk.utils.cdf import read_auth, try_find_error
-from cognite_toolkit._cdf_tk.utils.collection import chunker
 from cognite_toolkit._cdf_tk.utils.diff_list import diff_list_hashable, diff_list_identifiable
 
-from .auth_loaders import GroupAllScopedLoader
-from .data_organization_loaders import DataSetsLoader
-from .function_loaders import FunctionLoader
-from .group_scoped_loader import GroupResourceScopedLoader
-from .transformation_loaders import TransformationLoader
+from .auth import GroupAllScopedCRUD
+from .data_organization import DataSetsCRUD
+from .function import FunctionCRUD
+from .group_scoped import GroupResourceScopedCRUD
+from .transformation import TransformationCRUD
 
 
 @final
-class WorkflowLoader(ResourceLoader[str, WorkflowUpsert, Workflow, WorkflowUpsertList, WorkflowList]):
+class WorkflowCRUD(ResourceCRUD[str, WorkflowUpsert, Workflow]):
     folder_name = "workflows"
-    filename_pattern = r"^.*Workflow$"
     resource_cls = Workflow
     resource_write_cls = WorkflowUpsert
-    list_cls = WorkflowList
-    list_write_cls = WorkflowUpsertList
     kind = "Workflow"
     dependencies = frozenset(
         {
-            GroupAllScopedLoader,
-            TransformationLoader,
-            FunctionLoader,
-            DataSetsLoader,
+            GroupAllScopedCRUD,
+            TransformationCRUD,
+            FunctionCRUD,
+            DataSetsCRUD,
         }
     )
+    yaml_cls = WorkflowYAML
     _doc_base_url = "https://api-docs.cognite.com/20230101-beta/tag/"
     _doc_url = "Workflows/operation/CreateOrUpdateWorkflow"
 
@@ -141,23 +136,14 @@ class WorkflowLoader(ResourceLoader[str, WorkflowUpsert, Workflow, WorkflowUpser
             dumped["dataSetExternalId"] = self.client.lookup.data_sets.external_id(data_set_id)
         return dumped
 
-    def retrieve(self, ids: SequenceNotStr[str]) -> WorkflowList:
-        workflows = []
-        for ext_id in ids:
-            workflow = self.client.workflows.retrieve(external_id=ext_id)
-            if workflow:
-                workflows.append(workflow)
-        return WorkflowList(workflows)
+    def retrieve(self, ids: SequenceNotStr[str]) -> Sequence[Workflow]:
+        return self.client.workflows.retrieve(external_id=ids, ignore_unknown_ids=True)
 
-    def _upsert(self, items: WorkflowUpsert | WorkflowUpsertList) -> WorkflowList:
-        upserts = [items] if isinstance(items, WorkflowUpsert) else items
-        return WorkflowList([self.client.workflows.upsert(upsert) for upsert in upserts])
+    def create(self, items: Sequence[WorkflowUpsert]) -> WorkflowList:
+        return self.client.workflows.upsert(items)
 
-    def create(self, items: WorkflowUpsert | WorkflowUpsertList) -> WorkflowList:
-        return self._upsert(items)
-
-    def update(self, items: WorkflowUpsertList) -> WorkflowList:
-        return self._upsert(items)
+    def update(self, items: Sequence[WorkflowUpsert]) -> WorkflowList:
+        return self.client.workflows.upsert(items)
 
     def delete(self, ids: SequenceNotStr[str]) -> int:
         successes = 0
@@ -187,53 +173,25 @@ class WorkflowLoader(ResourceLoader[str, WorkflowUpsert, Workflow, WorkflowUpser
                 yield workflow
 
     @classmethod
-    @lru_cache(maxsize=1)
-    def get_write_cls_parameter_spec(cls) -> ParameterSpecSet:
-        spec = super().get_write_cls_parameter_spec()
-        spec.add(
-            ParameterSpec(
-                ("dataSetExternalId",),
-                frozenset({"str"}),
-                is_required=False,
-                _is_nullable=True,
-            )
-        )
-        spec.discard(
-            ParameterSpec(
-                ("dataSetId",),
-                frozenset({"str"}),
-                is_required=False,
-                _is_nullable=True,
-            )
-        )
-        return spec
-
-    @classmethod
-    def get_dependent_items(cls, item: dict) -> Iterable[tuple[type[ResourceLoader], Hashable]]:
+    def get_dependent_items(cls, item: dict) -> Iterable[tuple[type[ResourceCRUD], Hashable]]:
         """Returns all items that this item requires.
 
         For example, a TimeSeries requires a DataSet, so this method would return the
         DatasetLoader and identifier of that dataset.
         """
         if "dataSetExternalId" in item:
-            yield DataSetsLoader, item["dataSetExternalId"]
+            yield DataSetsCRUD, item["dataSetExternalId"]
 
 
 @final
-class WorkflowVersionLoader(
-    ResourceLoader[
-        WorkflowVersionId, WorkflowVersionUpsert, WorkflowVersion, WorkflowVersionUpsertList, WorkflowVersionList
-    ]
-):
+class WorkflowVersionCRUD(ResourceCRUD[WorkflowVersionId, WorkflowVersionUpsert, WorkflowVersion]):
     folder_name = "workflows"
-    filename_pattern = r"^.*WorkflowVersion$"
     resource_cls = WorkflowVersion
     resource_write_cls = WorkflowVersionUpsert
-    list_cls = WorkflowVersionList
-    list_write_cls = WorkflowVersionUpsertList
     kind = "WorkflowVersion"
-    dependencies = frozenset({WorkflowLoader})
-    parent_resource = frozenset({WorkflowLoader})
+    dependencies = frozenset({WorkflowCRUD})
+    parent_resource = frozenset({WorkflowCRUD})
+    yaml_cls = WorkflowVersionYAML
 
     _doc_base_url = "https://api-docs.cognite.com/20230101-beta/tag/"
     _doc_url = "Workflow-versions/operation/CreateOrUpdateWorkflowVersion"
@@ -344,9 +302,15 @@ class WorkflowVersionLoader(
             if task_id not in local_task_by_id:
                 continue
             local_task = local_task_by_id[task_id]
-            for default_key, default_value in [("retries", 3), ("timeout", 3600), ("onFailure", "abortWorkflow")]:
-                if default_key not in local_task and cdf_task.get(default_key) == default_value:
-                    del cdf_task[default_key]
+            for key, default_value in [("retries", 3), ("timeout", 3600), ("onFailure", "abortWorkflow")]:
+                if key not in local_task and cdf_task.get(key) == default_value:
+                    del cdf_task[key]
+                elif (
+                    key in local_task
+                    and local_task[key] is None
+                    and (cdf_task.get(key) == default_value or key not in cdf_task)
+                ):
+                    cdf_task[key] = None
 
             if local_task["type"] == "function" and cdf_task["type"] == "function":
                 cdf_parameters = cdf_task["parameters"]
@@ -360,15 +324,15 @@ class WorkflowVersionLoader(
                 cdf_parameters = cdf_task["parameters"]
                 local_parameters = local_task["parameters"]
                 if "transformation" in cdf_parameters and "transformation" in local_parameters:
-                    for default_key, default_transformation_value in [
+                    for key, default_transformation_value in [
                         ("concurrencyPolicy", "fail"),
                         ("useTransformationCredentials", False),
                     ]:
                         if (
-                            default_key not in local_parameters["transformation"]
-                            and cdf_parameters["transformation"].get(default_key) == default_transformation_value
+                            key not in local_parameters["transformation"]
+                            and cdf_parameters["transformation"].get(key) == default_transformation_value
                         ):
-                            del cdf_parameters["transformation"][default_key]
+                            del cdf_parameters["transformation"][key]
         return dumped
 
     def diff_list(
@@ -384,9 +348,9 @@ class WorkflowVersionLoader(
         return super().diff_list(local, cdf, json_path)
 
     @classmethod
-    def get_dependent_items(cls, item: dict) -> Iterable[tuple[type[ResourceLoader], Hashable]]:
+    def get_dependent_items(cls, item: dict) -> Iterable[tuple[type[ResourceCRUD], Hashable]]:
         if "workflowExternalId" in item:
-            yield WorkflowLoader, item["workflowExternalId"]
+            yield WorkflowCRUD, item["workflowExternalId"]
 
     @classmethod
     def check_item(cls, item: dict, filepath: Path, element_no: int | None) -> list[ToolkitWarning]:
@@ -415,28 +379,21 @@ class WorkflowVersionLoader(
         return warnings
 
     def retrieve(self, ids: SequenceNotStr[WorkflowVersionId]) -> WorkflowVersionList:
-        retrieved = WorkflowVersionList([])
         if not ids:
-            return retrieved
-        for chunk in chunker(ids, self._list_workflow_filter_limit):
-            retrieved_chunk = self.client.workflows.versions.list(chunk)
-            retrieved.extend(retrieved_chunk)
-        return retrieved
+            return WorkflowVersionList([])
+        return self.client.workflows.versions.retrieve(workflow_external_id=list(ids), ignore_unknown_ids=True)
 
-    def _upsert(self, items: WorkflowVersionUpsertList) -> WorkflowVersionList:
-        return WorkflowVersionList([self.client.workflows.versions.upsert(item) for item in items])
+    def _upsert(self, items: Sequence[WorkflowVersionUpsert]) -> WorkflowVersionList:
+        return self.client.workflows.versions.upsert(items)
 
-    def create(self, items: WorkflowVersionUpsertList) -> WorkflowVersionList:
+    def create(self, items: Sequence[WorkflowVersionUpsert]) -> WorkflowVersionList:
         upserted: list[WorkflowVersion] = []
         for item in self.topological_sort(items):
-            upserted.append(self.client.workflows.versions.upsert(item))
+            upserted.extend(self.client.workflows.versions.upsert([item]))
         return WorkflowVersionList(upserted)
 
-    def update(self, items: WorkflowVersionUpsertList) -> WorkflowVersionList:
-        updated = []
-        for item in items:
-            updated.append(self.client.workflows.versions.upsert(item))
-        return WorkflowVersionList(updated)
+    def update(self, items: Sequence[WorkflowVersionUpsert]) -> WorkflowVersionList:
+        return self._upsert(items)
 
     def delete(self, ids: SequenceNotStr[WorkflowVersionId]) -> int:
         successes = 0
@@ -458,48 +415,6 @@ class WorkflowVersionLoader(
         workflow_ids = [parent_id for parent_id in parent_ids if isinstance(parent_id, str)] if parent_ids else None
         return self.client.workflows.versions.list(limit=-1, workflow_version_ids=workflow_ids)  # type: ignore[arg-type]
 
-    @classmethod
-    @lru_cache(maxsize=1)
-    def get_write_cls_parameter_spec(cls) -> ParameterSpecSet:
-        spec = super().get_write_cls_parameter_spec()
-        # The Parameter class in the SDK class WorkflowVersion implementation is deviating from the API.
-        # So we need to modify the spec to match the API.
-        parameter_path = ("workflowDefinition", "tasks", ANY_INT, "parameters")
-        length = len(parameter_path)
-        for item in spec:
-            if len(item.path) >= length + 1 and item.path[:length] == parameter_path[:length]:
-                # Add extra ANY_STR layer
-                # The spec class is immutable, so we use this trick to modify it.
-                object.__setattr__(item, "path", (*item.path[:length], ANY_STR, *item.path[length:]))
-        spec.add(ParameterSpec((*parameter_path, ANY_STR), frozenset({"dict"}), is_required=True, _is_nullable=False))
-        # The depends on is implemented as a list of string in the SDK, but in the API spec it
-        # is a list of objects with one 'externalId' field.
-        spec.add(
-            ParameterSpec(
-                ("workflowDefinition", "tasks", ANY_INT, "dependsOn", ANY_INT, "externalId"),
-                frozenset({"str"}),
-                is_required=False,
-                _is_nullable=False,
-            )
-        )
-        spec.add(
-            ParameterSpec(
-                ("workflowDefinition", "tasks", ANY_INT, "type"),
-                frozenset({"str"}),
-                is_required=True,
-                _is_nullable=False,
-            )
-        )
-        spec.add(
-            ParameterSpec(
-                ("workflowDefinition", "tasks", ANY_INT, "parameters", "subworkflow", ANYTHING),
-                frozenset({"dict"}),
-                is_required=False,
-                _is_nullable=False,
-            )
-        )
-        return spec
-
     @classmethod
     def as_str(cls, id: WorkflowVersionId) -> str:
         if id.version is None:
@@ -509,7 +424,7 @@ class WorkflowVersionLoader(
         else:
             version = f"_v{id.version}"
 
-        return to_directory_compatible(f"{id.workflow_external_id}{version}")
+        return sanitize_filename(f"{id.workflow_external_id}{version}")
 
     @classmethod
     def topological_sort(cls, items: Sequence[WorkflowVersionUpsert]) -> list[WorkflowVersionUpsert]:
@@ -537,18 +452,14 @@ class WorkflowVersionLoader(
 
 
 @final
-class WorkflowTriggerLoader(
-    ResourceLoader[str, WorkflowTriggerUpsert, WorkflowTrigger, WorkflowTriggerUpsertList, WorkflowTriggerList]
-):
+class WorkflowTriggerCRUD(ResourceCRUD[str, WorkflowTriggerUpsert, WorkflowTrigger]):
     folder_name = "workflows"
-    filename_pattern = r"^.*WorkflowTrigger$"
     resource_cls = WorkflowTrigger
     resource_write_cls = WorkflowTriggerUpsert
-    list_cls = WorkflowTriggerList
-    list_write_cls = WorkflowTriggerUpsertList
     kind = "WorkflowTrigger"
-    dependencies = frozenset({WorkflowLoader, WorkflowVersionLoader, GroupResourceScopedLoader, GroupAllScopedLoader})
-    parent_resource = frozenset({WorkflowLoader})
+    dependencies = frozenset({WorkflowCRUD, WorkflowVersionCRUD, GroupResourceScopedCRUD, GroupAllScopedCRUD})
+    parent_resource = frozenset({WorkflowCRUD})
+    yaml_cls = WorkflowTriggerYAML
 
     _doc_url = "Workflow-triggers/operation/CreateOrUpdateTriggers"
 
@@ -591,10 +502,10 @@ class WorkflowTriggerLoader(
             WorkflowOrchestrationAcl.Scope.All(),
         )
 
-    def create(self, items: WorkflowTriggerUpsertList) -> WorkflowTriggerList:
+    def create(self, items: Sequence[WorkflowTriggerUpsert]) -> WorkflowTriggerList:
         return self._upsert(items)
 
-    def _upsert(self, items: WorkflowTriggerUpsertList) -> WorkflowTriggerList:
+    def _upsert(self, items: Sequence[WorkflowTriggerUpsert]) -> WorkflowTriggerList:
         created = WorkflowTriggerList([])
         for item in items:
             created.append(self._upsert_item(item))
@@ -614,7 +525,7 @@ class WorkflowTriggerLoader(
         lookup = set(ids)
         return WorkflowTriggerList([trigger for trigger in all_triggers if trigger.external_id in lookup])
 
-    def update(self, items: WorkflowTriggerUpsertList) -> WorkflowTriggerList:
+    def update(self, items: Sequence[WorkflowTriggerUpsert]) -> WorkflowTriggerList:
         return self._upsert(items)
 
     def delete(self, ids: SequenceNotStr[str]) -> int:
@@ -642,52 +553,13 @@ class WorkflowTriggerLoader(
         return triggers
 
     @classmethod
-    @lru_cache(maxsize=1)
-    def get_write_cls_parameter_spec(cls) -> ParameterSpecSet:
-        spec = super().get_write_cls_parameter_spec()
-        # Removed by the SDK
-        spec.add(
-            ParameterSpec(
-                ("triggerRule", "triggerType"),
-                frozenset({"str"}),
-                is_required=True,
-                _is_nullable=False,
-            )
-        )
-        spec.add(
-            ParameterSpec(
-                ("authentication",),
-                frozenset({"dict"}),
-                is_required=True,
-                _is_nullable=False,
-            )
-        )
-        spec.add(
-            ParameterSpec(
-                ("authentication", "clientId"),
-                frozenset({"str"}),
-                is_required=False,
-                _is_nullable=False,
-            )
-        )
-        spec.add(
-            ParameterSpec(
-                ("authentication", "clientSecret"),
-                frozenset({"str"}),
-                is_required=False,
-                _is_nullable=False,
-            )
-        )
-        return spec
-
-    @classmethod
-    def get_dependent_items(cls, item: dict) -> Iterable[tuple[type[ResourceLoader], Hashable]]:
+    def get_dependent_items(cls, item: dict) -> Iterable[tuple[type[ResourceCRUD], Hashable]]:
         """Returns all items that this item requires."""
         if "workflowExternalId" in item:
-            yield WorkflowLoader, item["workflowExternalId"]
+            yield WorkflowCRUD, item["workflowExternalId"]
 
             if "workflowVersion" in item:
-                yield WorkflowVersionLoader, WorkflowVersionId(item["workflowExternalId"], item["workflowVersion"])
+                yield WorkflowVersionCRUD, WorkflowVersionId(item["workflowExternalId"], item["workflowVersion"])
 
     def load_resource_file(
         self, filepath: Path, environment_variables: dict[str, str | None] | None = None
@@ -720,6 +592,13 @@ class WorkflowTriggerLoader(
         if isinstance(dumped.get("data"), str) and isinstance(local.get("data"), dict):
             dumped["data"] = json.loads(dumped["data"])
 
+        cdf_rule = dumped.get("triggerRule", {})
+        local_rule = local.get("triggerRule", {})
+        if cdf_rule.get("triggerType") == "schedule" and local_rule.get("triggerType") == "schedule":
+            if cdf_rule.get("timezone") == "UTC" and "timezone" not in local_rule:
+                # The server defaults to UTC if not set, so we remove it if the local does not have it set.
+                del cdf_rule["timezone"]
+
         if "authentication" in local:
             # Changes in auth will be detected by the hash. We need to do this to ensure
             # that the pull command works.

cognite_toolkit/_cdf_tk/{loaders → cruds}/_worker.py

@@ -1,17 +1,12 @@
 import re
 import warnings
-from collections.abc import Hashable
+from collections.abc import Hashable, Sequence
 from copy import deepcopy
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Generic, cast
 
 from cognite.client.data_classes import FunctionWrite
-from cognite.client.data_classes._base import (
-    T_CogniteResourceList,
-    T_WritableCogniteResource,
-    T_WriteClass,
-)
 from cognite.client.data_classes.capabilities import Capability
 from rich import print
 from rich.panel import Panel
@@ -19,32 +14,29 @@ from yaml import YAMLError
 
 from cognite_toolkit._cdf_tk.constants import TABLE_FORMATS
 from cognite_toolkit._cdf_tk.exceptions import ToolkitWrongResourceError, ToolkitYAMLFormatError
+from cognite_toolkit._cdf_tk.feature_flags import Flags
 from cognite_toolkit._cdf_tk.tk_warnings import EnvironmentVariableMissingWarning, catch_warnings
 from cognite_toolkit._cdf_tk.utils import to_diff
 
-from . import FunctionLoader
-from ._base_loaders import T_ID, ResourceLoader, T_WritableCogniteResourceList
+from . import FunctionCRUD
+from ._base_cruds import T_ID, ResourceCRUD, T_ResourceRequest, T_ResourceResponse
 
 if TYPE_CHECKING:
     from cognite_toolkit._cdf_tk.data_classes._module_directories import ReadModule
 
 
 @dataclass
-class CategorizedResources(Generic[T_ID, T_CogniteResourceList]):
-    to_create: T_CogniteResourceList
-    to_update: T_CogniteResourceList
-    to_delete: list[T_ID]
-    unchanged: T_CogniteResourceList
+class CategorizedResources(Generic[T_ID, T_ResourceRequest]):
+    to_create: list[T_ResourceRequest] = field(default_factory=list)
+    to_update: list[T_ResourceRequest] = field(default_factory=list)
+    to_delete: list[T_ID] = field(default_factory=list)
+    unchanged: list[T_ResourceRequest] = field(default_factory=list)
 
 
-class ResourceWorker(
-    Generic[T_ID, T_WriteClass, T_WritableCogniteResource, T_CogniteResourceList, T_WritableCogniteResourceList]
-):
+class ResourceWorker(Generic[T_ID, T_ResourceRequest, T_ResourceResponse]):
     def __init__(
         self,
-        loader: ResourceLoader[
-            T_ID, T_WriteClass, T_WritableCogniteResource, T_CogniteResourceList, T_WritableCogniteResourceList
-        ],
+        loader: ResourceCRUD[T_ID, T_ResourceRequest, T_ResourceResponse],
         action: str,
     ):
         self.loader = loader
@@ -56,12 +48,16 @@ class ResourceWorker(
     ) -> list[Path]:
         filepaths = self.loader.find_files(directory)
 
-        for read_module in read_modules or []:
-            if resource_dir := read_module.resource_dir_path(self.loader.folder_name):
-                # As of 05/11/24, Asset support csv and parquet files in addition to YAML.
-                # These table formats are not built, i.e., no variable replacement is done,
-                # so we load them directly from the source module.
-                filepaths.extend(self.loader.find_files(resource_dir, include_formats=TABLE_FORMATS))
+        if not Flags.v08.is_enabled():
+            for read_module in read_modules or []:
+                if resource_dir := read_module.resource_dir_path(self.loader.folder_name):
+                    # As of 05/11/24, Asset support csv and parquet files in addition to YAML.
+                    # These table formats are not built, i.e., no variable replacement is done,
+                    # so we load them directly from the source module.
+                    table_files = [
+                        file for file in self.loader.find_files(resource_dir) if file.suffix in TABLE_FORMATS
+                    ]
+                    filepaths.extend(table_files)
 
         if not sort:
             return filepaths
@@ -102,14 +98,13 @@ class ResourceWorker(
         self.validate_access(local_by_id, is_dry_run)
 
         # Lookup the existing resources in CDF
-        cdf_resources: T_WritableCogniteResourceList
         cdf_resources = self.loader.retrieve(list(local_by_id.keys()))
         return self.categorize_resources(local_by_id, cdf_resources, force_update, verbose)
 
     def load_resources(
         self, filepaths: list[Path], environment_variables: dict[str, str | None] | None, is_dry_run: bool
-    ) -> dict[T_ID, tuple[dict[str, Any], T_WriteClass]]:
-        local_by_id: dict[T_ID, tuple[dict[str, Any], T_WriteClass]] = {}  # type: ignore[assignment]
+    ) -> dict[T_ID, tuple[dict[str, Any], T_ResourceRequest]]:
+        local_by_id: dict[T_ID, tuple[dict[str, Any], T_ResourceRequest]] = {}
         # Load all resources from files, get ids, and remove duplicates.
         environment_variables = environment_variables or {}
         for filepath in filepaths:
@@ -145,10 +140,12 @@ class ResourceWorker(
                     warning.print_warning()
         return local_by_id
 
-    def validate_access(self, local_by_id: dict[T_ID, tuple[dict[str, Any], T_WriteClass]], is_dry_run: bool) -> None:
+    def validate_access(
+        self, local_by_id: dict[T_ID, tuple[dict[str, Any], T_ResourceRequest]], is_dry_run: bool
+    ) -> None:
         capabilities: Capability | list[Capability]
-        if isinstance(self.loader, FunctionLoader):
-            function_loader: FunctionLoader = self.loader
+        if isinstance(self.loader, FunctionCRUD):
+            function_loader: FunctionCRUD = self.loader
             function_items = cast(list[FunctionWrite], [item for _, item in local_by_id.values()])
             capabilities = function_loader.get_function_required_capabilities(function_items, read_only=is_dry_run)
         else:
@@ -160,17 +157,12 @@ class ResourceWorker(
 
     def categorize_resources(
         self,
-        local_by_id: dict[T_ID, tuple[dict[str, Any], T_WriteClass]],
-        cdf_resources: T_WritableCogniteResourceList,
+        local_by_id: dict[T_ID, tuple[dict[str, Any], T_ResourceRequest]],
+        cdf_resources: Sequence[T_ResourceResponse],
         force_update: bool,
         verbose: bool,
-    ) -> CategorizedResources:
-        resources: CategorizedResources[T_ID, T_CogniteResourceList] = CategorizedResources(
-            to_create=self.loader.list_write_cls([]),
-            to_update=self.loader.list_write_cls([]),
-            to_delete=[],
-            unchanged=self.loader.list_write_cls([]),
-        )
+    ) -> CategorizedResources[T_ID, T_ResourceRequest]:
+        resources: CategorizedResources[T_ID, T_ResourceRequest] = CategorizedResources()
         cdf_resource_by_id = {self.loader.get_id(resource): resource for resource in cdf_resources}
         for identifier, (local_dict, local_resource) in local_by_id.items():
             cdf_resource = cdf_resource_by_id.get(identifier)

cognite_toolkit/_cdf_tk/data_classes/__init__.py

@@ -32,6 +32,7 @@ from ._deploy_results import (
 from ._module_directories import ModuleDirectories, ModuleLocation
 from ._module_resources import ModuleResources
 from ._packages import Package, Packages
+from ._tracking_info import CommandTrackingInfo
 from ._yaml_comments import YAMLComments
 
 __all__ = [
@@ -47,6 +48,7 @@ __all__ = [
     "BuiltResource",
     "BuiltResourceFull",
     "BuiltResourceList",
+    "CommandTrackingInfo",
     "ConfigEntry",
     "ConfigYAMLs",
     "DatapointDeployResult",

cognite_toolkit/_cdf_tk/data_classes/_build_files.py

@@ -2,8 +2,8 @@ from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any
 
-from cognite_toolkit._cdf_tk.loaders import (
-    ResourceLoader,
+from cognite_toolkit._cdf_tk.cruds import (
+    ResourceCRUD,
 )
 from cognite_toolkit._cdf_tk.tk_warnings import (
     WarningList,
@@ -27,7 +27,7 @@ class BuildSourceFile:
 class BuildDestinationFile:
     path: Path
     loaded: list[dict[str, Any]] | dict[str, Any]
-    loader: type[ResourceLoader]
+    loader: type[ResourceCRUD]
     source: SourceLocation
     extra_sources: list[SourceLocation] | None
     warnings: WarningList[FileReadWarning] = field(default_factory=WarningList[FileReadWarning])