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

cognite_toolkit/_cdf_tk/commands/init.py

@@ -1,9 +1,231 @@
+import shutil
+import tempfile
+import traceback
+from collections.abc import Callable
+from dataclasses import dataclass
+from enum import Enum
+from pathlib import Path
+
+import questionary
+import typer
+from questionary import Choice
 from rich import print
 from rich.panel import Panel
 
-from ._base import ToolkitCommand
+from cognite_toolkit._cdf_tk.cdf_toml import CDFToml
+from cognite_toolkit._cdf_tk.commands._base import ToolkitCommand
+from cognite_toolkit._cdf_tk.commands.auth import AuthCommand
+from cognite_toolkit._cdf_tk.commands.collect import CollectCommand
+from cognite_toolkit._cdf_tk.commands.modules import ModulesCommand
+from cognite_toolkit._cdf_tk.commands.repo import RepoCommand
+from cognite_toolkit._cdf_tk.exceptions import ToolkitError
+from cognite_toolkit._cdf_tk.feature_flags import FeatureFlag
+
+
+class InitItemStatus(Enum):
+    """Status of an init checklist item"""
+
+    NONE = "none"
+    SUCCESSFUL = "successful"
+    FAILED = "failed"
+
+
+@dataclass
+class InitChecklistItem:
+    name: str
+    description: str
+    function: Callable[[], None]
+    status: InitItemStatus | None = None
+    mandatory: bool = False
+
+    def get_status_display(self) -> str:
+        if self.status == InitItemStatus.SUCCESSFUL:
+            return "✓"
+        elif self.status == InitItemStatus.FAILED:
+            return "✗"
+        else:
+            return "○"
+
+    def get_choice_title(self) -> str:
+        status_icon = self.get_status_display()
+        return f"{status_icon} {self.description} (required)" if self.mandatory else f"{status_icon} {self.description}"
 
 
 class InitCommand(ToolkitCommand):
-    def execute(self) -> None:
-        print(Panel("This command is deprecated. Use 'cdf modules init' instead."))
+    organization_dir: Path | None
+
+    def __init__(self, print_warning: bool = True, skip_tracking: bool = False, silent: bool = False) -> None:
+        super().__init__(print_warning, skip_tracking, silent)
+        self.organization_dir = None
+
+    def execute(self, dry_run: bool = False) -> None:
+        print("\n")
+        print(
+            Panel(
+                "Go through the following steps to set up the Cognite Toolkit. You can re-run steps if you need to change something.",
+                title="Cognite Toolkit Setup",
+                style="green",
+                padding=(1, 2),
+            )
+        )
+
+        # Initialize checklist items
+        checklist_items = [
+            InitChecklistItem(
+                name="initToml",
+                description="Create toml file",
+                function=lambda: self._init_toml(dry_run=dry_run),
+                mandatory=True,
+            ),
+            InitChecklistItem(
+                name="initAuth",
+                description="Authentication",
+                function=lambda: self._init_auth(dry_run=dry_run),
+            ),
+            InitChecklistItem(
+                name="initModules",
+                description="Modules",
+                function=lambda: self._init_modules(dry_run=dry_run),
+            ),
+            InitChecklistItem(
+                name="initRepo",
+                description="Git repository",
+                function=lambda: self._init_repo(dry_run=dry_run),
+            ),
+            InitChecklistItem(
+                name="initDataCollection",
+                description="Usage statistics",
+                function=lambda: self._init_data_collection(dry_run=dry_run),
+            ),
+        ]
+
+        if CDFToml.load().is_loaded_from_file:
+            checklist_items[0].status = InitItemStatus.SUCCESSFUL
+            print("cdf.toml configuration file already exists. Skipping creation.")
+
+        # Main loop: keep showing checklist until user is done
+        while True:
+            # Build choices for questionary
+            choices = []
+            for item in checklist_items:
+                choices.append(
+                    Choice(
+                        title=item.get_choice_title(),
+                        value=item.name,
+                    )
+                )
+            # Check if all mandatory items are completed
+            mandatory_items = [item for item in checklist_items if item.mandatory]
+            all_mandatory_complete = all(item.status == InitItemStatus.SUCCESSFUL for item in mandatory_items)
+
+            choices.append(Choice(title="> Quit", value="__exit__"))
+
+            # Find the first item with status None to use as default
+            default_item = next((item for item in checklist_items if item.status is None), None)
+            default_value = default_item.name if default_item else "__exit__"
+
+            # Show checklist and get user selection
+            selected = questionary.select(
+                "Select a task:",
+                choices=choices,
+                default=default_value,
+            ).ask()
+
+            # User cancelled (Ctrl+C or similar)
+            if selected is None:
+                return
+
+            if selected == "__exit__":
+                if all_mandatory_complete:
+                    print("Setup complete!")
+                    break
+                else:
+                    incomplete_mandatory = [
+                        item.description for item in mandatory_items if item.status != InitItemStatus.SUCCESSFUL
+                    ]
+                    print(f"Warning: recommended item not completed: {', '.join(incomplete_mandatory)}")
+                    break
+
+            # Find the selected item
+            selected_item = next((item for item in checklist_items if item.name == selected), None)
+            if selected_item is None:
+                continue
+
+            # If item was already run, ask for confirmation to re-run
+            if selected_item.status is not None:
+                status_text = (
+                    "successfully. Re-run it?"
+                    if selected_item.status == InitItemStatus.SUCCESSFUL
+                    else "with failure. Retry?"
+                )
+                confirm = questionary.confirm(
+                    f"'{selected_item.description}' was already run {status_text}",
+                    default=False,
+                ).ask()
+                if not confirm:
+                    continue
+
+            try:
+                selected_item.function()
+                selected_item.status = InitItemStatus.SUCCESSFUL
+                print(f"✓ {selected_item.description} completed successfully")
+            except typer.Exit:
+                # typer.Exit is used for normal exits, treat as success
+                selected_item.status = InitItemStatus.SUCCESSFUL
+                print(f"✓ {selected_item.description} completed successfully")
+            except ToolkitError as e:
+                # Catch expected toolkit errors
+                selected_item.status = InitItemStatus.FAILED
+                print(f"✗ {selected_item.description} failed: {e}")
+            except Exception as e:
+                # Catch unexpected errors and log full traceback for debugging
+                selected_item.status = InitItemStatus.FAILED
+                print(f"✗ {selected_item.description} failed: {e}")
+                print(f"Unexpected error occurred. Full traceback:\n{traceback.format_exc()}")
+
+    def _init_toml(self, dry_run: bool = False) -> None:
+        if self.organization_dir is None:
+            self.organization_dir = ModulesCommand._prompt_organization_dir()
+        if dry_run:
+            print("Would initialize cdf.toml configuration file")
+            return
+        CDFToml.write(self.organization_dir, "dev")
+        FeatureFlag.flush()
+        print(f"cdf.toml configuration file initialized in {self.organization_dir}")
+
+    def _init_auth(self, dry_run: bool = False) -> None:
+        auth_command = AuthCommand()
+        auth_command.run(lambda: auth_command.init(no_verify=True, dry_run=dry_run))
+
+    def _init_modules(self, dry_run: bool = False) -> None:
+        with ModulesCommand() as modules_command:
+            if self.organization_dir is None:
+                self.organization_dir = ModulesCommand._prompt_organization_dir()
+            if dry_run:
+                organization_dir = Path(tempfile.mkdtemp(prefix="init_modules_", suffix=".tmp", dir=Path.cwd()))
+                modules_command.run(lambda: modules_command.init(organization_dir=organization_dir))
+                shutil.rmtree(organization_dir)
+            else:
+                modules_command.run(lambda: modules_command.init(organization_dir=self.organization_dir))
+
+    def _init_repo(self, dry_run: bool = False) -> None:
+        repo_command = RepoCommand()
+        repo_command.run(lambda: repo_command.init(cwd=Path.cwd(), host=None, verbose=False))
+
+    def _init_data_collection(self, dry_run: bool = False) -> None:
+        """Opt in to collect usage statistics"""
+
+        opt_in = questionary.confirm(
+            "Do you want to opt in to collect usage statistics? This will help us improve the Toolkit.",
+            default=True,
+        ).ask()
+        if dry_run:
+            print("Would opt in to collect data" if opt_in else "Would not opt in to collect data")
+            return
+
+        if opt_in:
+            collect_command = CollectCommand()
+            collect_command.run(lambda: collect_command.execute("opt-in"))
+        else:
+            collect_command = CollectCommand()
+            collect_command.run(lambda: collect_command.execute("opt-out"))

cognite_toolkit/_cdf_tk/commands/modules.py

@@ -34,6 +34,7 @@ from cognite_toolkit._cdf_tk.commands._changes import (
     UpdateDockerImageVersion,
     UpdateModuleVersion,
 )
+from cognite_toolkit._cdf_tk.commands._questionary_style import custom_style_fancy
 from cognite_toolkit._cdf_tk.constants import (
     MODULES,
     RESOURCES_PATH,
@@ -50,7 +51,6 @@ from cognite_toolkit._cdf_tk.data_classes import (
     Packages,
 )
 from cognite_toolkit._cdf_tk.exceptions import ToolkitError, ToolkitRequiredValueError, ToolkitValueError
-from cognite_toolkit._cdf_tk.feature_flags import Flags
 from cognite_toolkit._cdf_tk.hints import verify_module_directory
 from cognite_toolkit._cdf_tk.tk_warnings import MediumSeverityWarning
 from cognite_toolkit._cdf_tk.tk_warnings.other import HighSeverityWarning
@@ -64,20 +64,6 @@ if sys.version_info >= (3, 11):
     from typing import Self
 else:
     from typing_extensions import Self
-custom_style_fancy = questionary.Style(
-    [
-        ("qmark", "fg:#673ab7"),  # token in front of the question
-        ("question", "bold"),  # question text
-        ("answer", "fg:#f44336 bold"),  # submitted answer text behind the question
-        ("pointer", "fg:#673ab7 bold"),  # pointer used in select and checkbox prompts
-        ("highlighted", "fg:#673ab7 bold"),  # pointed-at choice in select and checkbox prompts
-        ("selected", "fg:#673ab7"),  # style for a selected item of a checkbox
-        ("separator", "fg:#cc5454"),  # separator in lists
-        ("instruction", ""),  # user instructions for select, rawselect, checkbox
-        ("text", ""),  # plain text
-        ("disabled", "fg:#858585 italic"),  # disabled choices for select and checkbox prompts
-    ]
-)
 
 INDENT = "  "
 POINTER = INDENT + "▶"
@@ -285,26 +271,7 @@ class ModulesCommand(ToolkitCommand):
             )
             safe_write(Path(organization_dir) / f"config.{environment}.yaml", config_init.dump_yaml_with_comments())
 
-        cdf_toml_content = self.create_cdf_toml(organization_dir, environments[0] if environments else "dev")
-
-        destination = Path.cwd() / CDFToml.file_name
-        if destination.exists():
-            print(f"{INDENT}[yellow]cdf.toml file already exists. Skipping creation.")
-        else:
-            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(RESOURCES_PATH / CDFToml.file_name)
-        if organization_dir != Path.cwd():
-            cdf_toml_content = cdf_toml_content.replace(
-                "#<PLACEHOLDER>",
-                f'''
-default_organization_dir = "{organization_dir.name}"''',
-            )
-        else:
-            cdf_toml_content = cdf_toml_content.replace("#<PLACEHOLDER>", "")
-        cdf_toml_content = cdf_toml_content.replace("<DEFAULT_ENV_PLACEHOLDER>", env)
-        return cdf_toml_content
+        CDFToml.write(organization_dir, environments[0] if environments else "dev")
 
     def init(
         self,
@@ -318,14 +285,7 @@ default_organization_dir = "{organization_dir.name}"''',
         library_checksum: str | None = None,
     ) -> None:
         if not organization_dir:
-            new_line = "\n    "
-            message = (
-                f"Which directory would you like to create templates in? (default: current directory){new_line}"
-                f"HINT Use an organization directory if you use the repository for more than Toolkit. "
-                f"If not, use the current (repository root) directory '.':"
-            )
-            organization_dir_raw = questionary.text(message=message, default="").ask()
-            organization_dir = Path(organization_dir_raw.strip())
+            organization_dir = ModulesCommand._prompt_organization_dir()
 
         modules_root_dir = organization_dir / MODULES
 
@@ -453,6 +413,21 @@ default_organization_dir = "{organization_dir.name}"''',
         if not is_interactive:
             raise typer.Exit()
 
+    @staticmethod
+    def _prompt_organization_dir() -> Path:
+        print(
+            "\n".join(
+                [
+                    "Enter an optional subdirectory for Toolkit content.",
+                    "    [bold yellow]HINT[/bold yellow] Use an organization directory if you use the repository for more than Toolkit.",
+                    "    [dim]The current directory is the default.[/dim]",
+                ]
+            )
+        )
+
+        organization_dir_raw = questionary.text(message="", default="").ask()
+        return Path(organization_dir_raw.strip())
+
     @staticmethod
     def _get_download_data(selected: Packages) -> bool:
         example_data = {
@@ -780,7 +755,8 @@ default_organization_dir = "{organization_dir.name}"''',
         """
 
         cdf_toml = CDFToml.load()
-        if (Flags.EXTERNAL_LIBRARIES.is_enabled() or user_library) and self._module_source_dir is None:
+
+        if self._module_source_dir is None:
             libraries = {"userdefined": user_library} if user_library else cdf_toml.libraries
 
             for library_name, library in libraries.items():

cognite_toolkit/_cdf_tk/commands/pull.py

@@ -29,13 +29,6 @@ from cognite_toolkit._cdf_tk.cruds import (
     ResourceCRUD,
     StreamlitCRUD,
 )
-from cognite_toolkit._cdf_tk.cruds._base_cruds import (
-    T_ID,
-    T_ResourceRequest,
-    T_ResourceRequestList,
-    T_ResourceResponse,
-    T_ResourceResponseList,
-)
 from cognite_toolkit._cdf_tk.data_classes import (
     BuildEnvironment,
     BuildVariable,
@@ -49,6 +42,7 @@ from cognite_toolkit._cdf_tk.data_classes import (
     YAMLComments,
 )
 from cognite_toolkit._cdf_tk.exceptions import ToolkitError, ToolkitMissingResourceError, ToolkitValueError
+from cognite_toolkit._cdf_tk.protocols import T_ResourceRequest, T_ResourceResponse
 from cognite_toolkit._cdf_tk.tk_warnings import LowSeverityWarning, MediumSeverityWarning
 from cognite_toolkit._cdf_tk.utils import (
     YAMLComment,
@@ -64,6 +58,7 @@ from cognite_toolkit._cdf_tk.utils.modules import (
     module_directory_from_path,
     parse_user_selected_modules,
 )
+from cognite_toolkit._cdf_tk.utils.useful_types import T_ID
 
 from ._base import ToolkitCommand
 from .build_cmd import BuildCommand
@@ -547,9 +542,7 @@ class PullCommand(ToolkitCommand):
 
     def _pull_resources(
         self,
-        loader: ResourceCRUD[
-            T_ID, T_ResourceRequest, T_ResourceResponse, T_ResourceRequestList, T_ResourceResponseList
-        ],
+        loader: ResourceCRUD[T_ID, T_ResourceRequest, T_ResourceResponse],
         resources: BuiltFullResourceList[T_ID],
         dry_run: bool,
         environment_variables: dict[str, str | None],
@@ -581,9 +574,7 @@ class PullCommand(ToolkitCommand):
         local_resource_by_id: dict[T_ID, dict[str, Any]],
         cdf_resource_by_id: dict[T_ID, T_ResourceResponse],
         file_results: ResourceDeployResult,
-        loader: ResourceCRUD[
-            T_ID, T_ResourceRequest, T_ResourceResponse, T_ResourceRequestList, T_ResourceResponseList
-        ],
+        loader: ResourceCRUD[T_ID, T_ResourceRequest, T_ResourceResponse],
     ) -> tuple[bool, dict[T_ID, dict[str, Any]]]:
         to_write: dict[T_ID, dict[str, Any]] = {}
         has_changes = False
@@ -612,9 +603,7 @@ class PullCommand(ToolkitCommand):
     @staticmethod
     def _get_local_resource_dict_by_id(
         resources: BuiltFullResourceList[T_ID],
-        loader: ResourceCRUD[
-            T_ID, T_ResourceRequest, T_ResourceResponse, T_ResourceRequestList, T_ResourceResponseList
-        ],
+        loader: ResourceCRUD[T_ID, T_ResourceRequest, T_ResourceResponse],
         environment_variables: dict[str, str | None],
     ) -> dict[T_ID, dict[str, Any]]:
         unique_destinations = {r.destination for r in resources if r.destination}
@@ -651,9 +640,7 @@ class PullCommand(ToolkitCommand):
         to_write: dict[T_ID, dict[str, Any]],
         resources: BuiltFullResourceList[T_ID],
         environment_variables: dict[str, str | None],
-        loader: ResourceCRUD[
-            T_ID, T_ResourceRequest, T_ResourceResponse, T_ResourceRequestList, T_ResourceResponseList
-        ],
+        loader: ResourceCRUD[T_ID, T_ResourceRequest, T_ResourceResponse],
         source_file: Path,
     ) -> tuple[str, dict[Path, str]]:
         # 1. Replace all variables with placeholders

cognite_toolkit/_cdf_tk/commands/resources.py

@@ -0,0 +1,179 @@
+import difflib
+from pathlib import Path
+from typing import cast
+
+import questionary
+import typer
+from questionary import Choice
+from rich import print
+
+from cognite_toolkit._cdf_tk.commands._base import ToolkitCommand
+from cognite_toolkit._cdf_tk.constants import MODULES
+from cognite_toolkit._cdf_tk.cruds import RESOURCE_CRUD_LIST, ResourceCRUD
+from cognite_toolkit._cdf_tk.data_classes import ModuleDirectories
+from cognite_toolkit._cdf_tk.resource_classes import ToolkitResource
+from cognite_toolkit._cdf_tk.utils.collection import humanize_collection
+from cognite_toolkit._cdf_tk.utils.file import yaml_safe_dump
+
+
+class ResourcesCommand(ToolkitCommand):
+    def __init__(self, print_warning: bool = True, skip_tracking: bool = False, silent: bool = False) -> None:
+        super().__init__(print_warning, skip_tracking, silent)
+
+    def _get_or_prompt_module_path(self, module: str | None, organization_dir: Path, verbose: bool) -> Path:
+        """
+        Check if the module exists in the organization directory and return the module path.
+        If module is not provided, ask the user to select or create a new module.
+        """
+        present_modules = ModuleDirectories.load(organization_dir, None)
+
+        if module:
+            for mod in present_modules:
+                if mod.name.casefold() == module.casefold():
+                    return mod.dir
+
+            if questionary.confirm(f"{module} module not found. Do you want to create a new one?").ask():
+                return organization_dir / MODULES / module
+
+            if verbose:
+                print(f"[red]Aborting as {module} module not found...[/red]")
+            else:
+                print("[red]Aborting...[/red]")
+            raise typer.Exit()
+
+        choices = [Choice(title=mod.name, value=mod.dir) for mod in present_modules]
+        choices.append(Choice(title="<Create new module>", value="NEW"))
+
+        selected = questionary.select("Select a module:", choices=choices).ask()
+
+        if selected == "NEW":
+            new_module_name = questionary.text("Enter name for new module:").ask()
+            if not new_module_name:
+                print("[red]No module name provided. Aborting...[/red]")
+                raise typer.Exit()
+            return organization_dir / MODULES / new_module_name
+
+        if not selected:
+            print("[red]No module selected. Aborting...[/red]")
+            raise typer.Exit()
+
+        return cast(Path, selected)
+
+    def _resolve_kinds(self, kinds: list[str] | None) -> list[type[ResourceCRUD]]:
+        """
+        Resolve kinds from list of strings or do an interactive selection.
+        """
+        all_cruds = {crud.kind.casefold(): crud for crud in RESOURCE_CRUD_LIST}
+
+        if not kinds:
+            sorted_cruds = sorted(RESOURCE_CRUD_LIST, key=lambda x: x.kind)
+            choices = [Choice(title=crud.kind, value=crud) for crud in sorted_cruds]
+
+            selected = questionary.select("Select resource type:", choices=choices).ask()
+            if not selected:
+                print("[red]No resource type selected. Aborting...[/red]")
+                raise typer.Exit()
+            return [selected]
+
+        resolved_cruds = []
+        for kind in kinds:
+            kind_lower = kind.casefold()
+            if kind_lower in all_cruds:
+                resolved_cruds.append(all_cruds[kind_lower])
+            else:
+                matches = difflib.get_close_matches(kind_lower, all_cruds.keys())
+                if matches:
+                    suggestion = all_cruds[matches[0]].kind
+                    print(f"[red]Unknown resource type '{kind}'. Did you mean '{suggestion}'?[/red]")
+                else:
+                    print(
+                        f"[red]Unknown resource type '{kind}'. "
+                        f"Available types: {humanize_collection(sorted([c.kind for c in RESOURCE_CRUD_LIST]))}[/red]"
+                    )
+                raise typer.Exit()
+
+        return resolved_cruds
+
+    def _create_resource_yaml_skeleton(self, yaml_cls: type[ToolkitResource]) -> dict[str, str]:
+        """
+        Build YAML skeleton from a Pydantic model class using JSON schema for better type information.
+        """
+        yaml_skeleton: dict[str, str] = {}
+        for field_name, field in yaml_cls.model_fields.items():
+            name = field.alias or field_name
+            description = field.description or name
+            if field.is_required():
+                yaml_skeleton[name] = f"(Required) {description}"
+            else:
+                yaml_skeleton[name] = description
+
+        return yaml_skeleton
+
+    def _get_resource_yaml_content(self, resource_crud: type[ResourceCRUD]) -> str:
+        """
+        Creates a new resource in the specified module using the resource_crud.yaml_cls.
+        """
+        yaml_header = (
+            f"# API docs: {resource_crud.doc_url()}\n"
+            f"# YAML reference: https://docs.cognite.com/cdf/deploy/cdf_toolkit/references/resource_library"
+        )
+        yaml_skeleton = self._create_resource_yaml_skeleton(resource_crud.yaml_cls)
+        yaml_contents = yaml_safe_dump(yaml_skeleton)
+        return yaml_header + "\n\n" + yaml_contents
+
+    def _create_resource_yaml_file(
+        self,
+        resource_crud: type[ResourceCRUD],
+        module_path: Path,
+        prefix: str | None = None,
+        verbose: bool = False,
+    ) -> None:
+        """
+        Creates a new resource YAML file in the specified module using the resource_crud.yaml_cls.
+        """
+        resource_dir: Path = module_path / resource_crud.folder_name
+        if resource_crud.sub_folder_name:
+            resource_dir = resource_dir / resource_crud.sub_folder_name
+
+        if not resource_dir.exists():
+            resource_dir.mkdir(parents=True, exist_ok=True)
+
+        final_prefix = prefix if prefix is not None else f"my_{resource_crud.kind}"
+        file_name = f"{final_prefix}.{resource_crud.kind}.yaml"
+        file_path: Path = resource_dir / file_name
+
+        if file_path.exists() and not questionary.confirm(f"{file_path.name} file already exists. Overwrite?").ask():
+            print("[red]Skipping...[/red]")
+            return
+
+        yaml_content = self._get_resource_yaml_content(resource_crud)
+        file_path.write_text(yaml_content)
+        if verbose:
+            print(
+                f"[green]{resource_crud.kind} Resource YAML file created successfully at {file_path.as_posix()}[/green]"
+            )
+        else:
+            print(f"[green]Created {file_path.as_posix()}[/green]")
+
+    def create(
+        self,
+        organization_dir: Path,
+        module_name: str | None = None,
+        kind: list[str] | None = None,
+        prefix: str | None = None,
+        verbose: bool = False,
+    ) -> None:
+        """
+        create resource YAMLs.
+
+        Args:
+            organization_dir: The directory of the organization.
+            module_name: The name of the module.
+            kind: The kind(s) of resource to create.
+            prefix: The prefix for the resource file.
+            verbose: Whether to print verbose output.
+        """
+        module_path = self._get_or_prompt_module_path(module_name, organization_dir, verbose)
+        resource_cruds = self._resolve_kinds(kind)
+        for crud in resource_cruds:
+            self._create_resource_yaml_file(crud, module_path, prefix, verbose)

cognite_toolkit/_cdf_tk/commands/run.py

@@ -30,7 +30,7 @@ from rich.progress import Progress
 from rich.table import Table
 
 from cognite_toolkit._cdf_tk.client import ToolkitClient, ToolkitClientConfig
-from cognite_toolkit._cdf_tk.client.data_classes.functions import FunctionScheduleID
+from cognite_toolkit._cdf_tk.client.data_classes.legacy.functions import FunctionScheduleID
 from cognite_toolkit._cdf_tk.constants import _RUNNING_IN_BROWSER
 from cognite_toolkit._cdf_tk.cruds import FunctionCRUD, FunctionScheduleCRUD, WorkflowVersionCRUD
 from cognite_toolkit._cdf_tk.cruds._resource_cruds.workflow import WorkflowTriggerCRUD

cognite_toolkit/_cdf_tk/constants.py

@@ -61,7 +61,7 @@ ROOT_PATH = Path(__file__).parent.parent
 COGNITE_MODULES_PATH = ROOT_PATH / COGNITE_MODULES
 MODULES_PATH = ROOT_PATH / MODULES
 RESOURCES_PATH = ROOT_PATH / RESOURCES
-SUPPORT_MODULE_UPGRADE_FROM_VERSION = "0.2.0"
+SUPPORT_MODULE_UPGRADE_FROM_VERSION = "0.4.0"
 # This is used in the build directory to keep track of order and flatten the
 # module directory structure with accounting for duplicated names.
 INDEX_PATTERN = re.compile("^[0-9]+\\.")
@@ -161,11 +161,30 @@ COGNITE_TIME_SERIES_CONTAINER = ContainerId("cdf_cdm", "CogniteTimeSeries")
 COGNITE_FILE_CONTAINER = ContainerId("cdf_cdm", "CogniteFile")
 CDF_UNIT_SPACE = "cdf_cdm_units"
 
+
+# Container properties that are read-only in DMS needs to be handled with extra care, as this aspect is not currently exposed by the API.
+READONLY_CONTAINER_PROPERTIES = {
+    ContainerId(space="cdf_cdm", external_id="CogniteAsset"): {
+        "assetHierarchy_path_last_updated_time",
+        "assetHierarchy_path",
+        "assetHierarchy_root",
+    },
+    ContainerId(space="cdf_cdm", external_id="CogniteFile"): {"isUploaded", "uploadedTime"},
+}
+
 # Data Plugin Constants
 DATA_DEFAULT_DIR = "data"
 DATA_RESOURCE_DIR = "resources"
 DATA_MANIFEST_STEM = "Manifest"
+DATA_MANIFEST_SUFFIX = f".{DATA_MANIFEST_STEM}.yaml"
 
+DATA_UPLOAD_URL = "https://docs.cognite.com/cdf/deploy/cdf_toolkit/guides/plugins/data_plugin/index"
 # Migration Constants
 MISSING_INSTANCE_SPACE = "<InstanceSpaceMissing>"
 MISSING_EXTERNAL_ID = "INTERNAL_ID_project_{project}_id_{id}"
+
+# Stream Template names
+STREAM_IMMUTABLE_TEMPLATE_NAME = frozenset(("ImmutableTestStream", "BasicArchive"))
+STREAM_MUTABLE_TEMPLATE_NAME = frozenset(("BasicLiveData",))
+
+StreamTemplateName: TypeAlias = Literal["ImmutableTestStream", "BasicArchive", "BasicLiveData"]