cognite-toolkit 0.6.97__py3-none-any.whl → 0.7.30__py3-none-any.whl

cognite_toolkit/_cdf_tk/commands/about.py

@@ -0,0 +1,221 @@
+import platform
+import sys
+from pathlib import Path
+
+from rich import print
+from rich.table import Table
+
+from cognite_toolkit._cdf_tk.cdf_toml import CDFToml, _read_toml
+from cognite_toolkit._cdf_tk.commands._base import ToolkitCommand
+from cognite_toolkit._cdf_tk.constants import clean_name
+from cognite_toolkit._cdf_tk.feature_flags import Flags
+from cognite_toolkit._cdf_tk.plugins import Plugins
+from cognite_toolkit._cdf_tk.tk_warnings import LowSeverityWarning, MediumSeverityWarning
+from cognite_toolkit._version import __version__
+
+
+class AboutCommand(ToolkitCommand):
+    def execute(self, cwd: Path) -> None:
+        # Version information
+        print(f"\n[bold cyan]Cognite Toolkit[/bold cyan] version: [yellow]{__version__}[/yellow]")
+        print(f"Python version: {sys.version.split()[0]}")
+        print(f"Platform: {platform.system()} {platform.release()}")
+
+        # Check for cdf.toml in the current directory
+        cdf_toml_path = cwd / CDFToml.file_name
+
+        if cdf_toml_path.exists():
+            print(f"\n[bold green]Configuration file found:[/bold green] {cdf_toml_path}")
+
+            cdf_toml = CDFToml.load(cwd)
+
+            # We need to read the raw TOML to get original key names for plugins and alpha flags
+            raw_toml = _read_toml(cdf_toml_path)
+
+            self._check_unrecognized_sections(raw_toml)
+            self._display_plugins(cdf_toml, raw_toml)
+            self._display_alpha_flags(cdf_toml, raw_toml)
+            self._display_additional_config(cdf_toml)
+
+        else:
+            # Search for cdf.toml in subdirectories
+            found_files = self._search_cdf_toml(cwd)
+
+            if found_files:
+                print(f"\n[bold yellow]No cdf.toml found in current directory:[/bold yellow] {cwd}")
+                print("\n[bold]Found cdf.toml files in subdirectories:[/bold]")
+                for file in found_files:
+                    rel_path = file.relative_to(cwd)
+                    print(f"  • {rel_path}")
+                print(f"\n[bold cyan]Hint:[/bold cyan] Move one of these files to {cwd} or navigate to its directory.")
+            else:
+                print("\n[bold yellow]No cdf.toml found[/bold yellow] in current directory or subdirectories.")
+                print(f"Current directory: {cwd}")
+                print("\n[bold cyan]Hint:[/bold cyan] Run [yellow]cdf init[/yellow] to create a new project.")
+
+    def _check_unrecognized_sections(self, raw_toml: dict) -> None:
+        """Check for unrecognized tables in cdf.toml and warn about them."""
+        # Valid top-level tables in cdf.toml
+        valid_tables = {"cdf", "modules", "alpha_flags", "feature_flags", "plugins", "library"}
+
+        # Filter out empty keys, whitespace-only keys, and check for unrecognized tables
+        unrecognized_tables = [key for key in raw_toml.keys() if key and key.strip() and key not in valid_tables]
+
+        if unrecognized_tables:
+            print()
+
+        for table in unrecognized_tables:
+            # Try to find a matching valid table by stripping non-alphabetical characters
+            suggestion = self._find_similar_table(table, valid_tables)
+
+            message = f"Table '{table}' in cdf.toml is not recognized and will have no effect."
+            if suggestion:
+                message += f" Did you mean '{suggestion}'?"
+
+            self.warn(MediumSeverityWarning(message))
+
+    @staticmethod
+    def _find_similar_table(unrecognized: str, valid_tables: set[str]) -> str | None:
+        """Find a similar valid table by comparing alphabetical characters only.
+
+        Returns None if the unrecognized table is already valid or if no similar match is found.
+        """
+        # If it's already a valid table, return None (no suggestion needed)
+        if unrecognized in valid_tables:
+            return None
+
+        # Keep only alphabetical characters and lowercase
+        normalized_unrecognized = "".join(c for c in unrecognized if c.isalpha()).lower()
+
+        # First, try exact match (after normalization)
+        for valid in valid_tables:
+            normalized_valid = "".join(c for c in valid if c.isalpha()).lower()
+            if normalized_unrecognized == normalized_valid:
+                return valid
+
+        # If no match, check for singular/plural variations (missing 's')
+        for valid in valid_tables:
+            normalized_valid = "".join(c for c in valid if c.isalpha()).lower()
+
+            # Check if adding 's' to unrecognized matches valid (e.g., "plugin" -> "plugins")
+            if normalized_unrecognized + "s" == normalized_valid:
+                return valid
+
+        return None
+
+    def _display_plugins(self, cdf_toml: CDFToml, raw_toml: dict) -> None:
+        """Display all available plugins and their status."""
+        table = Table(title="Plugins", show_header=True)
+        table.add_column("Plugin", justify="left", style="cyan")
+        table.add_column("Status", justify="center")
+        table.add_column("Description", justify="left")
+
+        # Track which plugins we've seen
+        seen_plugins = set()
+
+        # Show all plugins from the enum
+        for plugin in Plugins:
+            plugin_name = plugin.value.name
+            cleaned_key = clean_name(plugin_name)
+            seen_plugins.add(cleaned_key)
+
+            is_enabled = cdf_toml.plugins.get(cleaned_key, False)
+            if is_enabled:
+                status = "[green]✓ enabled[/green]"
+            else:
+                status = "[dim]○ disabled[/dim]"
+
+            table.add_row(plugin_name, status, plugin.value.description)
+
+        print()
+        print(table)
+
+        # Show any unrecognized plugins from cdf.toml using original key names
+        raw_plugins = raw_toml.get("plugins", {})
+        unrecognized = []
+        for original_key, value in raw_plugins.items():
+            cleaned_key = clean_name(original_key)
+            if cleaned_key not in seen_plugins:
+                unrecognized.append((original_key, value))
+
+        for original_key, is_enabled in unrecognized:
+            status = "enabled" if is_enabled else "disabled"
+            self.warn(
+                LowSeverityWarning(f"Plugin '{original_key}' in cdf.toml is not recognized and will have no effect.")
+            )
+
+    def _display_alpha_flags(self, cdf_toml: CDFToml, raw_toml: dict) -> None:
+        """Display available alpha flags and their status."""
+        table = Table(title="Alpha Flags", show_header=True)
+        table.add_column("Flag", justify="left", style="yellow")
+        table.add_column("Status", justify="center")
+        table.add_column("Description", justify="left")
+
+        # Track which flags we've seen
+        seen_flags = set()
+
+        # Show flags from the enum that are either enabled or visible
+        for flag in Flags:
+            cleaned_key = clean_name(flag.name)
+            seen_flags.add(cleaned_key)
+
+            is_enabled = cdf_toml.alpha_flags.get(cleaned_key, False)
+
+            # Only show if enabled or visible
+            if is_enabled or flag.value.visible:
+                # Convert enum name to kebab-case for display
+                display_name = flag.name.lower().replace("_", "-")
+
+                if is_enabled:
+                    status = "[green]✓ enabled[/green]"
+                else:
+                    status = "[dim]○ disabled[/dim]"
+
+                table.add_row(display_name, status, flag.value.description)
+
+        print()
+        print(table)
+
+        # Show any unrecognized flags from cdf.toml using original key names
+        raw_flags = raw_toml.get("alpha_flags", {})
+        unrecognized = []
+        for original_key, value in raw_flags.items():
+            cleaned_key = clean_name(original_key)
+            if cleaned_key not in seen_flags:
+                unrecognized.append((original_key, value))
+
+        for original_key, is_enabled in unrecognized:
+            status = "enabled" if is_enabled else "disabled"
+            self.warn(
+                LowSeverityWarning(
+                    f"Alpha flag '{original_key}' in cdf.toml is not recognized and will have no effect."
+                )
+            )
+
+    def _display_additional_config(self, cdf_toml: CDFToml) -> None:
+        """Display additional configuration information."""
+        print("\n[bold]Additional Configuration:[/bold]")
+
+        print(f"  Default environment: [cyan]{cdf_toml.cdf.default_env}[/cyan]")
+
+        if cdf_toml.cdf.has_user_set_default_org:
+            print(f"  Default organization dir: [cyan]{cdf_toml.cdf.default_organization_dir}[/cyan]")
+
+        if cdf_toml.cdf.file_encoding:
+            print(f"  File encoding: [cyan]{cdf_toml.cdf.file_encoding}[/cyan]")
+
+        print(f"  Modules version: [cyan]{cdf_toml.modules.version}[/cyan]")
+
+        if cdf_toml.libraries:
+            print(f"  Configured libraries: [cyan]{len(cdf_toml.libraries)}[/cyan]")
+            for lib_name, lib_config in cdf_toml.libraries.items():
+                print(f"    • {lib_name}: [dim]{lib_config.url}[/dim]")
+
+    def _search_cdf_toml(self, cwd: Path) -> list[Path]:
+        """Search for cdf.toml files in immediate subdirectories (one level down)."""
+        try:
+            return sorted(
+                [potential_file for potential_file in cwd.glob(f"*/{CDFToml.file_name}") if potential_file.is_file()]
+            )
+        except PermissionError:
+            return []

cognite_toolkit/_cdf_tk/commands/auth.py

@@ -26,6 +26,7 @@ import questionary
 from cognite.client.data_classes.capabilities import (
     AssetsAcl,
     Capability,
+    ExtractionConfigsAcl,
     FunctionsAcl,
     GroupsAcl,
     ProjectsAcl,
@@ -46,6 +47,7 @@ from cognite_toolkit._cdf_tk.constants import (
     TOOLKIT_DEMO_GROUP_NAME,
     TOOLKIT_SERVICE_PRINCIPAL_GROUP_NAME,
 )
+from cognite_toolkit._cdf_tk.cruds import ExtractionPipelineConfigCRUD
 from cognite_toolkit._cdf_tk.exceptions import (
     AuthenticationError,
     AuthorizationError,
@@ -95,16 +97,6 @@ class AuthCommand(ToolkitCommand):
             raise AuthenticationError(f"Unable to verify the credentials.\n{e}")
 
         print("[green]The credentials are valid.[/green]")
-        if no_verify:
-            return
-        print(
-            Panel(
-                "Running verification, 'cdf auth verify'...",
-                title="",
-                expand=False,
-            )
-        )
-        self.verify(client, dry_run)
 
     def _store_dotenv(self, env_vars: EnvironmentVariables) -> None:
         new_env_file = env_vars.create_dotenv_file()
@@ -444,8 +436,23 @@ class AuthCommand(ToolkitCommand):
             crud = crud_cls.create_loader(client)
             if crud.prerequisite_warning() is not None:
                 continue
-            capability = crud_cls.get_required_capability(None, read_only=False)
-            capabilities = capability if isinstance(capability, list) else [capability]
+            if isinstance(crud, ExtractionPipelineConfigCRUD):
+                # The Extraction Pipeline Config CRUD requires special handling.
+                # The .get_required_capability is used in the DeployCommand as well. Since, there is no way to no
+                # the extraction pipeline ID or dataSetId from an ExtractionPipelineConfigWrite object, we do not
+                # check those there. If we returned the full capability, it would always have to be all scoped.
+                # That is too restrictive in the deploy command, so we return an empty list, essentially not checking
+                # anything there. Here, we want to add the all scoped capability, so that the Toolkit group gets the
+                # correct capability.
+                capabilities: list[Capability] = [
+                    ExtractionConfigsAcl(
+                        [ExtractionConfigsAcl.Action.Read, ExtractionConfigsAcl.Action.Write],
+                        ExtractionConfigsAcl.Scope.All(),
+                    )
+                ]
+            else:
+                capability = crud_cls.get_required_capability(None, read_only=False)
+                capabilities = capability if isinstance(capability, list) else [capability]
             for cap in capabilities:
                 if project_type == "DATA_MODELING_ONLY" and isinstance(cap, AssetsAcl | RelationshipsAcl):
                     continue

cognite_toolkit/_cdf_tk/commands/build_cmd.py

@@ -20,7 +20,6 @@ from cognite_toolkit._cdf_tk.constants import (
     _RUNNING_IN_BROWSER,
     BUILD_FOLDER_ENCODING,
     DEFAULT_ENV,
-    DEV_ONLY_MODULES,
     HINT_LEAD_TEXT,
     ROOT_MODULES,
     TEMPLATE_VARS_FILE_SUFFIXES,
@@ -59,10 +58,7 @@ from cognite_toolkit._cdf_tk.data_classes import (
     SourceLocationLazy,
 )
 from cognite_toolkit._cdf_tk.exceptions import (
-    ToolkitDuplicatedModuleError,
-    ToolkitEnvError,
     ToolkitError,
-    ToolkitMissingModuleError,
     ToolkitYAMLFormatError,
 )
 from cognite_toolkit._cdf_tk.hints import Hint, ModuleDefinition, verify_module_directory
@@ -89,6 +85,7 @@ from cognite_toolkit._cdf_tk.utils.file import safe_rmtree
 from cognite_toolkit._cdf_tk.utils.modules import parse_user_selected_modules
 from cognite_toolkit._cdf_tk.validation import (
     validate_data_set_is_set,
+    validate_module_selection,
     validate_modules_variables,
     validate_resource_yaml_pydantic,
 )
@@ -207,7 +204,11 @@ class BuildCommand(ToolkitCommand):
 
         user_selected_modules = config.environment.get_selected_modules(packages)
         modules = ModuleDirectories.load(organization_dir, user_selected_modules)
-        self._validate_modules(modules, config, packages, user_selected_modules, organization_dir)
+        module_warnings = validate_module_selection(modules, config, packages, user_selected_modules, organization_dir)
+        if module_warnings:
+            self.warning_list.extend(module_warnings)
+            if self.print_warning:
+                print(str(module_warnings))
 
         if verbose:
             self.console("Selected packages:")
@@ -358,6 +359,15 @@ class BuildCommand(ToolkitCommand):
         for resource_name, resource_files in module.source_paths_by_resource_folder.items():
             source_files = self._replace_variables(resource_files, module_variables, resource_name, module.dir, verbose)
 
+            if resource_name == "data_models":
+                resource_name = "data_modeling"
+                self.warn(
+                    MediumSeverityWarning(
+                        "The resource folder 'data_models' is deprecated and will be removed in v1.0. "
+                        "Please rename the folder to 'data_modeling'."
+                    )
+                )
+
             builder = self._get_builder(build_dir, resource_name)
 
             built_resources = BuiltResourceList[Hashable]()
@@ -413,62 +423,6 @@ class BuildCommand(ToolkitCommand):
         builder = self._builder_by_resource_folder[resource_name]
         return builder
 
-    def _validate_modules(
-        self,
-        modules: ModuleDirectories,
-        config: BuildConfigYAML,
-        packages: dict[str, list[str]],
-        selected_modules: set[str | Path],
-        organization_dir: Path,
-    ) -> None:
-        # Validations: Ambiguous selection.
-        selected_names = {s for s in config.environment.selected if isinstance(s, str)}
-        if duplicate_modules := {
-            module_name: paths
-            for module_name, paths in modules.as_path_by_name().items()
-            if len(paths) > 1 and module_name in selected_names
-        }:
-            # If the user has selected a module by name, and there are multiple modules with that name, raise an error.
-            # Note, if the user uses a path to select a module, this error will not be raised.
-            raise ToolkitDuplicatedModuleError(
-                f"Ambiguous module selected in config.{config.environment.name}.yaml:", duplicate_modules
-            )
-        # Package Referenced Modules Exists
-        for package, package_modules in packages.items():
-            if package not in selected_names:
-                # We do not check packages that are not selected.
-                # Typically, the user will delete the modules that are irrelevant for them;
-                # thus we only check the selected packages.
-                continue
-            if missing_packages := set(package_modules) - modules.available_names:
-                ToolkitMissingModuleError(
-                    f"Package {package} defined in {CDFToml.file_name!s} is referring "
-                    f"the following missing modules {missing_packages}."
-                )
-
-        # Selected modules does not exists
-        if missing_modules := set(selected_modules) - modules.available:
-            hint = ModuleDefinition.long(missing_modules, organization_dir)
-            raise ToolkitMissingModuleError(
-                f"The following selected modules are missing, please check path: {missing_modules}.\n{hint}"
-            )
-
-        # Nothing is Selected
-        if not modules.selected:
-            raise ToolkitEnvError(
-                f"No selected modules specified in {config.filepath!s}, have you configured "
-                f"the environment ({config.environment.name})?"
-            )
-
-        dev_modules = modules.available_names & DEV_ONLY_MODULES
-        if dev_modules and config.environment.validation_type != "dev":
-            self.warn(
-                MediumSeverityWarning(
-                    "The following modules should [bold]only[/bold] be used a in CDF Projects designated as dev (development): "
-                    f"{humanize_collection(dev_modules)!r}",
-                )
-            )
-
     def _replace_variables(
         self,
         resource_files: Sequence[Path],

cognite_toolkit/_cdf_tk/commands/clean.py

@@ -1,7 +1,9 @@
 import traceback
+from collections.abc import Sequence
 from graphlib import TopologicalSorter
 from pathlib import Path
 
+import questionary
 from cognite.client.exceptions import CogniteAPIError, CogniteNotFoundError
 from cognite.client.utils.useful_types import SequenceNotStr
 from rich import print
@@ -23,14 +25,7 @@ from cognite_toolkit._cdf_tk.cruds import (
     ResourceCRUD,
     ResourceWorker,
 )
-from cognite_toolkit._cdf_tk.cruds._base_cruds import (
-    T_ID,
-    Loader,
-    T_ResourceRequest,
-    T_ResourceRequestList,
-    T_ResourceResponse,
-    T_ResourceResponseList,
-)
+from cognite_toolkit._cdf_tk.cruds._base_cruds import Loader
 from cognite_toolkit._cdf_tk.data_classes import (
     BuildEnvironment,
     DeployResults,
@@ -40,9 +35,12 @@ from cognite_toolkit._cdf_tk.data_classes import (
 from cognite_toolkit._cdf_tk.data_classes._module_directories import ReadModule
 from cognite_toolkit._cdf_tk.exceptions import (
     ToolkitCleanResourceError,
+    ToolkitMissingModuleError,
     ToolkitNotADirectoryError,
     ToolkitValidationError,
+    ToolkitValueError,
 )
+from cognite_toolkit._cdf_tk.protocols import T_ResourceRequest, T_ResourceResponse
 from cognite_toolkit._cdf_tk.tk_warnings import (
     LowSeverityWarning,
     MediumSeverityWarning,
@@ -54,6 +52,7 @@ from cognite_toolkit._cdf_tk.utils import (
     read_yaml_file,
 )
 from cognite_toolkit._cdf_tk.utils.auth import EnvironmentVariables
+from cognite_toolkit._cdf_tk.utils.useful_types import T_ID
 
 from ._utils import _print_ids_or_length
 
@@ -63,9 +62,7 @@ AVAILABLE_DATA_TYPES: tuple[str, ...] = tuple(CRUDS_BY_FOLDER_NAME)
 class CleanCommand(ToolkitCommand):
     def clean_resources(
         self,
-        loader: ResourceCRUD[
-            T_ID, T_ResourceRequest, T_ResourceResponse, T_ResourceRequestList, T_ResourceResponseList
-        ],
+        loader: ResourceCRUD[T_ID, T_ResourceRequest, T_ResourceResponse],
         env_vars: EnvironmentVariables,
         read_modules: list[ReadModule],
         dry_run: bool = False,
@@ -136,7 +133,7 @@ class CleanCommand(ToolkitCommand):
             return ResourceDeployResult(name=loader.display_name)
 
     def _delete_resources(
-        self, loaded_resources: T_ResourceResponseList, loader: ResourceCRUD, dry_run: bool, verbose: bool
+        self, loaded_resources: Sequence[T_ResourceResponse], loader: ResourceCRUD, dry_run: bool, verbose: bool
     ) -> int:
         nr_of_deleted = 0
         resource_ids = loader.get_ids(loaded_resources)
@@ -161,7 +158,11 @@ class CleanCommand(ToolkitCommand):
         return nr_of_deleted
 
     def _drop_data(
-        self, loaded_resources: T_ResourceResponseList, loader: ResourceContainerCRUD, dry_run: bool, verbose: bool
+        self,
+        loaded_resources: Sequence[T_ResourceResponse],
+        loader: ResourceContainerCRUD,
+        dry_run: bool,
+        verbose: bool,
     ) -> int:
         nr_of_dropped = 0
         resource_ids = loader.get_ids(loaded_resources)
@@ -185,6 +186,23 @@ class CleanCommand(ToolkitCommand):
                 self._verbose_print_drop(resource_drop_count, resource_ids, loader, dry_run)
         return nr_of_dropped
 
+    def _interactive_module_selection(self, built_modules: list[ReadModule] | None) -> list[ReadModule] | None:
+        if not built_modules:
+            return None
+        choices = [
+            questionary.Choice(title=built_module.dir.name, value=built_module) for built_module in built_modules
+        ]
+
+        selected_modules = questionary.checkbox(
+            "Which modules would you like to clean?",
+            instruction="Use arrow up/down, press space to select item(s) and enter to save",
+            choices=choices,
+        ).ask()
+
+        if not selected_modules:
+            return None
+        return selected_modules
+
     def _verbose_print_drop(
         self, drop_count: int, resource_ids: SequenceNotStr[T_ID], loader: ResourceContainerCRUD, dry_run: bool
     ) -> None:
@@ -204,6 +222,11 @@ class CleanCommand(ToolkitCommand):
             # Count is not supported
             print(f" {prefix} all {loader.item_name} from {loader.display_name}: {_print_ids_or_length(resource_ids)}.")
 
+    def _select_modules(self, clean_state: BuildEnvironment, module_str: str | None) -> list[ReadModule] | None:
+        if module_str:
+            return [module for module in clean_state.read_modules if module.dir.name == module_str]
+        return self._interactive_module_selection(clean_state.read_modules)
+
     def execute(
         self,
         env_vars: EnvironmentVariables,
@@ -211,7 +234,9 @@ class CleanCommand(ToolkitCommand):
         build_env_name: str | None,
         dry_run: bool,
         include: list[str] | None,
+        module_str: str | None,
         verbose: bool,
+        all_modules: bool = False,
     ) -> None:
         if not build_dir.exists():
             raise ToolkitNotADirectoryError(
@@ -245,9 +270,31 @@ class CleanCommand(ToolkitCommand):
         )
 
         if not build_dir.is_dir():
-            raise ToolkitNotADirectoryError(f"'{build_dir}'. Did you forget to run `cdf-tk build` first?")
+            raise ToolkitNotADirectoryError(f"'{build_dir}'. Did you forget to run `cdf build` first?")
+
+        selected_modules: list[ReadModule]
+        if all_modules:
+            selected_modules = clean_state.read_modules or []
+            if not selected_modules:
+                raise ToolkitValueError("No modules available to clean.")
+        elif module_str:
+            selected_modules = [module for module in clean_state.read_modules if module.dir.name == module_str]
+            if not selected_modules:
+                available_module_names = {module.dir.name for module in clean_state.read_modules}
+                raise ToolkitMissingModuleError(
+                    f"No modules matched the selection: {module_str}. Available modules: {sorted(available_module_names)}"
+                )
+        else:
+            selected_modules = self._interactive_module_selection(clean_state.read_modules) or []
+            if not selected_modules:
+                raise ToolkitValueError(
+                    "No module specified with the --module option and no modules selected interactively."
+                )
 
-        selected_loaders = self.get_selected_loaders(build_dir, clean_state.read_resource_folders, include)
+        selected_resource_folders = {
+            resource_folder for module in selected_modules for resource_folder in module.resource_directories
+        }
+        selected_loaders = self.get_selected_loaders(build_dir, selected_resource_folders, include)
 
         results = DeployResults([], "clean", dry_run=dry_run)
 
@@ -274,7 +321,7 @@ class CleanCommand(ToolkitCommand):
             result = self.clean_resources(
                 loader,
                 env_vars=env_vars,
-                read_modules=clean_state.read_modules,
+                read_modules=selected_modules,
                 drop=True,
                 dry_run=dry_run,
                 drop_data=True,

cognite_toolkit/_cdf_tk/commands/deploy.py

@@ -1,4 +1,4 @@
-from collections.abc import Hashable
+from collections.abc import Hashable, Sequence
 from graphlib import TopologicalSorter
 from pathlib import Path
 from typing import overload
@@ -15,6 +15,7 @@ from cognite_toolkit._cdf_tk.commands.clean import CleanCommand
 from cognite_toolkit._cdf_tk.constants import (
     _RUNNING_IN_BROWSER,
     BUILD_ENVIRONMENT_FILE,
+    DATA_UPLOAD_URL,
     HINT_LEAD_TEXT,
 )
 from cognite_toolkit._cdf_tk.cruds import (
@@ -45,13 +46,12 @@ from cognite_toolkit._cdf_tk.exceptions import (
 )
 from cognite_toolkit._cdf_tk.protocols import (
     T_ResourceRequest,
-    T_ResourceRequestList,
     T_ResourceResponse,
-    T_ResourceResponseList,
 )
 from cognite_toolkit._cdf_tk.tk_warnings import EnvironmentVariableMissingWarning
 from cognite_toolkit._cdf_tk.tk_warnings.base import WarningList, catch_warnings
 from cognite_toolkit._cdf_tk.tk_warnings.other import (
+    HighSeverityWarning,
     LowSeverityWarning,
     ToolkitDependenciesIncludedWarning,
 )
@@ -292,6 +292,15 @@ class DeployCommand(ToolkitCommand):
             read_modules = build.read_modules
         output_results = DeployResults([], "deploy", dry_run=dry_run) if results is None else results
         for loader_cls in ordered_loaders:
+            if issubclass(loader_cls, DataCRUD):
+                self.warn(
+                    HighSeverityWarning(
+                        f"Uploading {loader_cls.kind} data is deprecated and will be removed in v0.8. "
+                        f"Use the `cdf data upload dir` command instead. See [{DATA_UPLOAD_URL}]({DATA_UPLOAD_URL}) for more information about "
+                        "the upload command."
+                    )
+                )
+
             loader = loader_cls.create_loader(client, build_dir)
             resource_result: DeployResult | None
             if isinstance(loader, ResourceCRUD):
@@ -327,9 +336,7 @@ class DeployCommand(ToolkitCommand):
 
     def deploy_resource_type(
         self,
-        loader: ResourceCRUD[
-            T_ID, T_ResourceRequest, T_ResourceResponse, T_ResourceRequestList, T_ResourceResponseList
-        ],
+        loader: ResourceCRUD[T_ID, T_ResourceRequest, T_ResourceResponse],
         env_vars: EnvironmentVariables,
         read_modules: list[ReadModule] | None = None,
         dry_run: bool = False,
@@ -391,10 +398,8 @@ class DeployCommand(ToolkitCommand):
 
     def actual_deploy(
         self,
-        resources: CategorizedResources[T_ID, T_ResourceResponseList],
-        loader: ResourceCRUD[
-            T_ID, T_ResourceRequest, T_ResourceResponse, T_ResourceRequestList, T_ResourceResponseList
-        ],
+        resources: CategorizedResources[T_ID, T_ResourceRequest],
+        loader: ResourceCRUD[T_ID, T_ResourceRequest, T_ResourceResponse],
         env_var_warnings: WarningList | None = None,
     ) -> ResourceDeployResult:
         environment_variable_warning_by_id = {
@@ -425,10 +430,8 @@ class DeployCommand(ToolkitCommand):
 
     @staticmethod
     def dry_run_deploy(
-        resources: CategorizedResources[T_ID, T_ResourceResponseList],
-        loader: ResourceCRUD[
-            T_ID, T_ResourceRequest, T_ResourceResponse, T_ResourceRequestList, T_ResourceResponseList
-        ],
+        resources: CategorizedResources[T_ID, T_ResourceRequest],
+        loader: ResourceCRUD[T_ID, T_ResourceRequest, T_ResourceResponse],
         has_done_drop: bool,
         has_dropped_data: bool,
     ) -> ResourceDeployResult:
@@ -459,7 +462,7 @@ class DeployCommand(ToolkitCommand):
 
     @staticmethod
     def _verbose_print(
-        resources: CategorizedResources[T_ID, T_ResourceResponseList],
+        resources: CategorizedResources[T_ID, T_ResourceRequest],
         loader: ResourceCRUD,
         dry_run: bool,
     ) -> None:
@@ -483,7 +486,7 @@ class DeployCommand(ToolkitCommand):
 
     def _create_resources(
         self,
-        resources: T_ResourceResponseList,
+        resources: Sequence[T_ResourceRequest],
         loader: ResourceCRUD,
         environment_variable_warning_by_id: dict[Hashable, EnvironmentVariableMissingWarning],
     ) -> int:
@@ -506,7 +509,7 @@ class DeployCommand(ToolkitCommand):
 
     def _update_resources(
         self,
-        resources: T_ResourceResponseList,
+        resources: Sequence[T_ResourceRequest],
         loader: ResourceCRUD,
         environment_variable_warning_by_id: dict[Hashable, EnvironmentVariableMissingWarning],
     ) -> int: