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

cognite_toolkit/_cdf_tk/commands/build_v2/_module_parser.py

@@ -0,0 +1,138 @@
+from pathlib import Path
+
+from cognite_toolkit._cdf_tk.constants import EXCL_FILES, MODULES
+from cognite_toolkit._cdf_tk.cruds import CRUDS_BY_FOLDER_NAME, CRUDS_BY_FOLDER_NAME_INCLUDE_ALPHA
+from cognite_toolkit._cdf_tk.data_classes import IssueList
+from cognite_toolkit._cdf_tk.data_classes._issues import ModuleLoadingIssue
+from cognite_toolkit._cdf_tk.exceptions import ToolkitError
+from cognite_toolkit._cdf_tk.utils import humanize_collection, module_path_display_name
+
+
+class ModulesParser:
+    def __init__(self, organization_dir: Path, selected: list[str | Path] | None = None):
+        self.organization_dir = organization_dir
+        self.selected = selected
+
+    def parse(self) -> tuple[list[Path], IssueList]:
+        modules_root = self.organization_dir / MODULES
+        if not modules_root.exists():
+            raise ToolkitError(f"Module root directory '{modules_root}' not found")
+
+        module_paths: list[Path] = []
+        excluded_module_paths: list[Path] = []
+        issues: IssueList = IssueList()
+        for resource_file in self.organization_dir.glob("**/*.y*ml"):
+            if resource_file.name in EXCL_FILES:
+                continue
+
+            # Get the module folder for the resource file.
+            module_path = self._get_module_path_from_resource_file_path(resource_file)
+            if not module_path:
+                continue
+
+            # If the module has already been processed, skip it.
+            if module_path in module_paths or module_path in excluded_module_paths:
+                continue
+
+            # Skip the modules that do not match the selection
+            if not self._matches_selection(module_path, modules_root, self.selected):
+                excluded_module_paths.append(module_path)
+                continue
+
+            module_paths.append(module_path)
+
+        deepest_module_paths = self._find_modules_with_submodules(module_paths)
+        parent_module_paths = set(module_paths) - set(deepest_module_paths)
+        if parent_module_paths:
+            module_paths = deepest_module_paths
+            issues.extend(
+                ModuleLoadingIssue(
+                    message=f"Module {module_path_display_name(self.organization_dir, parent_module_path)!r} is skipped because it has submodules"
+                )
+                for parent_module_path in parent_module_paths
+            )
+
+        valid_module_paths: list[Path] = []
+        for module_path in module_paths:
+            valid_module_path, issue = self._check_resource_folder_content(module_path)
+            if issue:
+                issues.append(issue)
+            if valid_module_path:
+                valid_module_paths.append(valid_module_path)
+
+        return valid_module_paths, issues
+
+    def _get_module_path_from_resource_file_path(self, resource_file: Path) -> Path | None:
+        # recognize the module by containing a resource associated by a CRUD.
+        # Special case: if the resource folder is a subfolder of a CRUD, return the parent of the subfolder.
+        resource_folder = resource_file.parent
+        crud = next(iter(CRUDS_BY_FOLDER_NAME_INCLUDE_ALPHA.get(resource_folder.name, [])), None)
+        if crud:
+            # iterate over the parents of the resource folder until we find the module folder.
+            # This is to handle the special case of a subfolder of a CRUD, or yamls in for example function subfolders.
+            for p in resource_file.parents:
+                if p.name == crud.folder_name:
+                    return p.parent
+                if p.name == MODULES:
+                    return p
+        return None
+
+    def _check_resource_folder_content(self, module_path: Path) -> tuple[None | Path, ModuleLoadingIssue | None]:
+        resource_folder_names = {d.name for d in module_path.iterdir() if d.is_dir()}
+        unrecognized_resource_folder_names = resource_folder_names - CRUDS_BY_FOLDER_NAME.keys()
+
+        issue = (
+            ModuleLoadingIssue(
+                message=f"Module {module_path_display_name(self.organization_dir, module_path)!r} contains unrecognized resource folder(s): {humanize_collection(unrecognized_resource_folder_names)}"
+            )
+            if unrecognized_resource_folder_names
+            else None
+        )
+
+        has_valid_resource_folders = bool(resource_folder_names & CRUDS_BY_FOLDER_NAME.keys())
+        return (module_path if has_valid_resource_folders else None, issue)
+
+    def _matches_selection(self, module_path: Path, modules_root: Path, selected: list[str | Path] | None) -> bool:
+        if not selected:
+            return True
+
+        rel = module_path.relative_to(modules_root)
+        rel_parts = [p.lower() for p in rel.parts]
+        if not rel_parts:
+            # module_path is the modules_root itself
+            return False
+        name_lower = rel_parts[-1]
+        modules_lower = MODULES.lower()
+
+        for sel in selected:
+            sel_path = Path(sel) if isinstance(sel, str) else sel
+
+            sel_parts = [p.lower() for p in sel_path.parts]
+            if not sel_parts:
+                continue
+
+            if sel_parts[0] == modules_lower:
+                sel_parts = sel_parts[1:]
+
+            if not sel_parts:
+                return True
+
+            if len(sel_parts) == 1 and name_lower == sel_parts[0]:
+                return True
+
+            if rel_parts[: len(sel_parts)] == sel_parts:
+                return True
+
+        return False
+
+    def _find_modules_with_submodules(self, module_paths: list[Path]) -> list[Path]:
+        """Remove parent modules when they have submodules. Keep only the deepest modules."""
+        return [
+            module_path
+            for module_path in module_paths
+            if not any(
+                module_path in other_module_path.parents
+                for other_module_path in module_paths
+                if other_module_path != module_path
+            )
+        ]

cognite_toolkit/_cdf_tk/commands/build_v2/_modules_parser.py

@@ -0,0 +1,163 @@
+from pathlib import Path
+
+from cognite_toolkit._cdf_tk.constants import EXCL_FILES, MODULES
+from cognite_toolkit._cdf_tk.cruds import CRUDS_BY_FOLDER_NAME, CRUDS_BY_FOLDER_NAME_INCLUDE_ALPHA
+from cognite_toolkit._cdf_tk.data_classes import IssueList
+from cognite_toolkit._cdf_tk.data_classes._issues import ModuleLoadingIssue
+from cognite_toolkit._cdf_tk.exceptions import ToolkitError
+from cognite_toolkit._cdf_tk.utils import module_path_display_name
+
+
+class ModulesParser:
+    def __init__(self, organization_dir: Path, selected: list[str | Path] | None = None):
+        self.organization_dir = organization_dir
+        self.selected = selected
+        self.issues = IssueList()
+
+    def parse(self) -> list[Path]:
+        modules_root = self.organization_dir / MODULES
+        if not modules_root.exists():
+            raise ToolkitError(f"Module root directory '{modules_root.as_posix()}' not found")
+
+        module_paths: list[Path] = []
+        for resource_file in self.organization_dir.glob("**/*.y*ml"):
+            if resource_file.name in EXCL_FILES:
+                continue
+
+            # Get the module folder for the resource file.
+            module_path = self._get_module_path_from_resource_file_path(resource_file)
+            if not module_path:
+                continue
+
+            # If the module has already been processed, skip it.
+            if module_path in module_paths:
+                continue
+
+            module_paths.append(module_path)
+
+        deepest_module_paths = self._find_modules_with_submodules(module_paths)
+        parent_module_paths = set(module_paths) - set(deepest_module_paths)
+        if parent_module_paths:
+            module_paths = deepest_module_paths
+            self.issues.extend(
+                ModuleLoadingIssue(
+                    message=f"Module {module_path_display_name(self.organization_dir, parent_module_path)!r} is skipped because it has submodules",
+                )
+                for parent_module_path in parent_module_paths
+            )
+
+        all_module_paths = module_paths
+
+        if self.selected:
+            normalized_selected = self._normalize_selection(self.selected)
+            selected_module_paths = [
+                module_path
+                for module_path in all_module_paths
+                if self._matches_selection(module_path, modules_root, normalized_selected)
+            ]
+            for selected_module in self.selected:
+                normalized_selected_item = self._normalize_selection([selected_module])
+                has_match = any(
+                    self._matches_selection(found_module, modules_root, normalized_selected_item)
+                    for found_module in all_module_paths
+                )
+                if not has_match:
+                    self.issues.append(
+                        ModuleLoadingIssue(
+                            message=f"Module '{selected_module}' not found",
+                        )
+                    )
+
+            module_paths = selected_module_paths
+
+        valid_module_paths: list[Path] = []
+        for module_path in module_paths:
+            valid_module_path, issue = self._check_resource_folder_content(module_path)
+            if issue:
+                self.issues.append(issue)
+            if valid_module_path:
+                valid_module_paths.append(valid_module_path)
+
+        return valid_module_paths
+
+    def _get_module_path_from_resource_file_path(self, resource_file: Path) -> Path | None:
+        # recognize the module by traversing the parents of the resource file until we find a CRUD folder
+
+        for parent in resource_file.parents:
+            if parent.name in CRUDS_BY_FOLDER_NAME_INCLUDE_ALPHA:
+                # special case: if the crud is FunctionCRUD, the resource file has to be a direct descendent.
+                if parent.name == "functions" and resource_file.parent.name != "functions":
+                    return None
+                return parent.parent
+            if parent.name == MODULES:
+                return parent
+        return None
+
+    def _check_resource_folder_content(self, module_path: Path) -> tuple[None | Path, ModuleLoadingIssue | None]:
+        resource_folder_names = {d.name for d in module_path.iterdir() if d.is_dir()}
+        unrecognized_resource_folder_names = resource_folder_names - CRUDS_BY_FOLDER_NAME.keys()
+
+        issue = (
+            ModuleLoadingIssue(
+                message=f"Module {module_path_display_name(self.organization_dir, module_path)!r} contains unrecognized resource folder(s): {', '.join(unrecognized_resource_folder_names)}"
+            )
+            if unrecognized_resource_folder_names
+            else None
+        )
+
+        has_valid_resource_folders = bool(resource_folder_names & CRUDS_BY_FOLDER_NAME.keys())
+        return (module_path if has_valid_resource_folders else None, issue)
+
+    def _matches_selection(
+        self, module_path: Path, modules_root: Path, normalized_selected: list[tuple[str, ...]] | None
+    ) -> bool:
+        if not normalized_selected:
+            return True
+
+        rel = module_path.relative_to(modules_root)
+        rel_parts = tuple(p.lower() for p in rel.parts)
+        if not rel_parts:
+            # module_path is the modules_root itself
+            return False
+        name_lower = rel_parts[-1]
+
+        for sel_parts in normalized_selected:
+            if not sel_parts:
+                return True
+
+            if len(sel_parts) == 1 and name_lower == sel_parts[0]:
+                return True
+
+            if rel_parts[: len(sel_parts)] == sel_parts:
+                return True
+
+        return False
+
+    def _normalize_selection(self, selected: list[str | Path]) -> list[tuple[str, ...]]:
+        normalized: list[tuple[str, ...]] = []
+        modules_lower = MODULES.lower()
+        for sel in selected:
+            if isinstance(sel, Path):
+                sel_parts = sel.parts
+            else:
+                sel_parts = tuple(part for part in str(sel).replace("\\", "/").split("/") if part)
+
+            sel_parts_lower = tuple(part.lower() for part in sel_parts)
+            if sel_parts_lower and sel_parts_lower[0] == modules_lower:
+                sel_parts_lower = sel_parts_lower[1:]
+
+            normalized.append(sel_parts_lower)
+
+        return normalized
+
+    def _find_modules_with_submodules(self, module_paths: list[Path]) -> list[Path]:
+        """Remove parent modules when they have submodules. Keep only the deepest modules."""
+        return [
+            module_path
+            for module_path in module_paths
+            if not any(
+                module_path in other_module_path.parents
+                for other_module_path in module_paths
+                if other_module_path != module_path
+            )
+        ]

cognite_toolkit/_cdf_tk/commands/build_v2/build_cmd.py

@@ -0,0 +1,228 @@
+import re
+from itertools import groupby
+from pathlib import Path
+from typing import Any, Literal
+
+from rich import print
+from rich.panel import Panel
+
+from cognite_toolkit._cdf_tk.client import ToolkitClient
+from cognite_toolkit._cdf_tk.commands._base import ToolkitCommand
+from cognite_toolkit._cdf_tk.commands.build_cmd import BuildCommand as OldBuildCommand
+from cognite_toolkit._cdf_tk.commands.build_v2._modules_parser import ModulesParser
+from cognite_toolkit._cdf_tk.commands.build_v2.build_parameters import BuildParameters
+from cognite_toolkit._cdf_tk.commands.build_v2.data_classes._modules import Module
+from cognite_toolkit._cdf_tk.data_classes import BuildConfigYAML, BuildVariables, BuiltModuleList
+from cognite_toolkit._cdf_tk.data_classes._issues import Issue, IssueList
+from cognite_toolkit._cdf_tk.exceptions import ToolkitError
+from cognite_toolkit._cdf_tk.tk_warnings import ToolkitWarning, WarningList
+from cognite_toolkit._cdf_tk.utils.file import safe_rmtree
+from cognite_toolkit._version import __version__
+
+
+class BuildCommand(ToolkitCommand):
+    def __init__(self, print_warning: bool = True, skip_tracking: bool = False, silent: bool = False) -> None:
+        super().__init__(print_warning, skip_tracking, silent)
+        self.issues = IssueList()
+
+    def execute(
+        self,
+        verbose: bool,
+        base_dir: Path,
+        build_dir: Path,
+        selected: list[str | Path] | None,
+        build_env: str | None,
+        no_clean: bool,
+        client: ToolkitClient | None = None,
+        on_error: Literal["continue", "raise"] = "continue",
+    ) -> BuiltModuleList:
+        """
+        Build the resources into deployable artifacts in the build directory.
+        """
+
+        self.verbose = verbose
+        self.on_error = on_error
+
+        build_parameters = BuildParameters.load(
+            organization_dir=base_dir,
+            build_dir=build_dir,
+            build_env_name=build_env,
+            client=client,
+            user_selected=selected,
+        )
+
+        # Print the build input.
+        if self.verbose:
+            self._print_build_input(build_parameters)
+
+        # Tracking the project and cluster for the build.
+        if build_parameters.client:
+            self._additional_tracking_info.project = build_parameters.client.config.project
+            self._additional_tracking_info.cluster = build_parameters.client.config.cdf_cluster
+
+        # Load modules
+        modules_parser = ModulesParser(organization_dir=base_dir, selected=selected)
+        module_paths = modules_parser.parse()
+        module_loading_issues = modules_parser.issues
+        if module_loading_issues:
+            self.issues.extend(module_loading_issues)
+            self._print_or_log_issues_by_category(self.issues)
+            raise ToolkitError("Module loading issues encountered. Cannot continue. See above for details.")
+
+        # Load modules
+        if module_paths:
+            pass
+
+        # modules = [Module.load(path) for path in module_paths]
+        # for module in modules:
+        #    continue
+
+        # Logistics: clean and create build directory
+        if prepare_issues := self._prepare_target_directory(build_dir, not no_clean):
+            self.issues.extend(prepare_issues)
+
+        # Compile the configuration and variables,
+        # check syntax on module and resource level
+        # for any "compilation errors and warnings"
+        built_modules, build_integrity_issues = self._build_configuration(build_parameters)
+        if build_integrity_issues:
+            self.issues.extend(build_integrity_issues)
+
+        # This is where we would add any recommendations for the user to improve the build.
+        if build_quality_issues := self._verify_build_quality(built_modules):
+            self.issues.extend(build_quality_issues)
+
+        # Finally, print warnings grouped by category/code and location.
+        self._print_or_log_issues_by_category(self.issues)
+
+        return built_modules
+
+    def _print_build_input(self, build_input: BuildParameters) -> None:
+        print(
+            Panel(
+                f"Building {build_input.organization_dir!s}:\n  - Toolkit Version '{__version__!s}'\n"
+                f"  - Environment name {build_input.build_env_name!r}, validation-type {build_input.config.environment.validation_type!r}.\n"
+                f"  - Config '{build_input.config.filepath!s}'",
+                expand=False,
+            )
+        )
+
+    def _prepare_target_directory(self, build_dir: Path, clean: bool = False) -> IssueList:
+        """
+        Directory logistics
+        """
+        issues = IssueList()
+        if build_dir.exists() and any(build_dir.iterdir()):
+            if not clean:
+                raise ToolkitError("Build directory is not empty. Run without --no-clean to remove existing files.")
+
+            if self.verbose:
+                issues.append(Issue(code="BUILD_001"))
+            safe_rmtree(build_dir)
+        build_dir.mkdir(parents=True, exist_ok=True)
+        return issues
+
+    def _build_configuration(self, build_input: BuildParameters) -> tuple[BuiltModuleList, IssueList]:
+        issues = IssueList()
+        # Use build_input.modules directly (it is already filtered by selection)
+
+        old_build_command = OldBuildCommand(print_warning=False, skip_tracking=False)
+        built_modules = old_build_command.build_config(
+            build_dir=build_input.build_dir,
+            organization_dir=build_input.organization_dir,
+            config=build_input.config,
+            packages={},
+            clean=False,
+            verbose=self.verbose,
+            client=build_input.client,
+            progress_bar=False,
+            on_error=self.on_error,
+        )
+        # Copy tracking info from old command to self
+        self._additional_tracking_info.package_ids.update(old_build_command._additional_tracking_info.package_ids)
+        self._additional_tracking_info.module_ids.update(old_build_command._additional_tracking_info.module_ids)
+
+        # Collect warnings from the old build command and convert to issues
+        # Always convert warnings to issues, even if the list appears empty
+        # (WarningList might have custom __bool__ behavior)
+        if old_build_command.warning_list:
+            converted_issues = IssueList.from_warning_list(old_build_command.warning_list)
+            issues.extend(converted_issues)
+        return built_modules, issues
+
+    def _verify_build_quality(self, built_modules: BuiltModuleList) -> IssueList:
+        issues = IssueList()
+        return issues
+
+    def _write(self, build_input: BuildParameters) -> None:
+        # Write the build to the build directory.
+        # Track lines of code built.
+        raise NotImplementedError()
+
+    def _track(self, build_input: BuildParameters) -> None:
+        raise NotImplementedError()
+
+    def _print_or_log_issues_by_category(self, issues: IssueList) -> None:
+        issues_sorted = sorted(issues, key=self._issue_sort_key)
+        for code, grouped_issues in groupby(issues_sorted, key=lambda issue: issue.code or ""):
+            print(f"[bold]{code}[/]")
+            for issue in grouped_issues:
+                message = issue.message or ""
+                print(f"  - {message}")
+
+    def _issue_sort_key(self, issue: Issue) -> tuple[str, str]:
+        code = issue.code or ""
+        if not issue.message:
+            return code, ""
+        match = re.search(r"'([^']+)'", issue.message)
+        path = match.group(1) if match else issue.message
+        return code, path
+
+    # Delegate to old BuildCommand for backward compatibility with tests
+    def build_modules(
+        self,
+        modules: list[Module],
+        build_dir: Path,
+        variables: BuildVariables,
+        verbose: bool = False,
+        progress_bar: bool = False,
+        on_error: Literal["continue", "raise"] = "continue",
+    ) -> BuiltModuleList:
+        """Delegate to old BuildCommand for backward compatibility."""
+        old_cmd = OldBuildCommand()
+
+        built_modules = old_cmd.build_modules(modules, build_dir, variables, verbose, progress_bar, on_error)  # type: ignore[arg-type]
+        self._additional_tracking_info.package_ids.update(old_cmd._additional_tracking_info.package_ids)
+        self._additional_tracking_info.module_ids.update(old_cmd._additional_tracking_info.module_ids)
+        self.issues.extend(IssueList.from_warning_list(old_cmd.warning_list or WarningList[ToolkitWarning]()))
+        return built_modules
+
+    def build_config(
+        self,
+        build_dir: Path,
+        organization_dir: Path,
+        config: BuildConfigYAML,
+        packages: dict[str, list[str]],
+        clean: bool = False,
+        verbose: bool = False,
+        client: ToolkitClient | None = None,
+        progress_bar: bool = False,
+        on_error: Literal["continue", "raise"] = "continue",
+    ) -> BuiltModuleList:
+        """Delegate to old BuildCommand for backward compatibility."""
+        old_cmd = OldBuildCommand()
+        return old_cmd.build_config(
+            build_dir, organization_dir, config, packages, clean, verbose, client, progress_bar, on_error
+        )
+
+    def _replace_variables(
+        self,
+        resource_files: list[Path],
+        variables: BuildVariables,
+        resource_name: str,
+        module_dir: Path,
+        verbose: bool = False,
+    ) -> list[Any]:
+        """Delegate to old BuildCommand for backward compatibility."""
+        old_cmd = OldBuildCommand()
+        return old_cmd._replace_variables(resource_files, variables, resource_name, module_dir, verbose)

cognite_toolkit/_cdf_tk/commands/build_v2/build_parameters.py

@@ -0,0 +1,71 @@
+import sys
+from pathlib import Path
+
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
+from pydantic import BaseModel, ConfigDict
+
+from cognite_toolkit._cdf_tk.client import ToolkitClient
+from cognite_toolkit._cdf_tk.constants import DEFAULT_ENV
+from cognite_toolkit._cdf_tk.data_classes import (
+    BuildConfigYAML,
+)
+from cognite_toolkit._cdf_tk.tk_warnings import ToolkitWarning, WarningList
+from cognite_toolkit._cdf_tk.utils.modules import parse_user_selected_modules
+
+
+class BuildParameters(BaseModel):
+    """Input to the build process."""
+
+    # need this until we turn BuildConfigYaml and ToolkitClient into Pydantic models
+    model_config = ConfigDict(frozen=True, arbitrary_types_allowed=True)
+
+    organization_dir: Path
+    build_dir: Path
+    build_env_name: str
+    config: BuildConfigYAML
+    client: ToolkitClient | None = None
+    warnings: WarningList[ToolkitWarning] | None = None
+    user_selected: list[str | Path] | None = None
+
+    @classmethod
+    def load(
+        cls,
+        organization_dir: Path,
+        build_dir: Path,
+        build_env_name: str | None,
+        client: ToolkitClient | None,
+        user_selected: list[str | Path] | None = None,
+    ) -> Self:
+        resolved_org_dir = Path.cwd() if organization_dir in {Path("."), Path("./")} else organization_dir
+        resolved_env = build_env_name or DEFAULT_ENV
+        config, warnings = cls._load_config(resolved_org_dir, resolved_env, user_selected)
+        return cls(
+            organization_dir=resolved_org_dir,
+            build_dir=build_dir,
+            build_env_name=resolved_env,
+            config=config,
+            client=client,
+            warnings=warnings,
+            user_selected=user_selected,
+        )
+
+    @classmethod
+    def _load_config(
+        cls, organization_dir: Path, build_env_name: str, user_selected: list[str | Path] | None
+    ) -> tuple[BuildConfigYAML, WarningList[ToolkitWarning]]:
+        warnings: WarningList[ToolkitWarning] = WarningList[ToolkitWarning]()
+        if (organization_dir / BuildConfigYAML.get_filename(build_env_name or DEFAULT_ENV)).exists():
+            config = BuildConfigYAML.load_from_directory(organization_dir, build_env_name or DEFAULT_ENV)
+        else:
+            # Loads the default environment
+            config = BuildConfigYAML.load_default(organization_dir)
+        if user_selected:
+            config.environment.selected = list(set(parse_user_selected_modules(list(user_selected), organization_dir)))
+        config.set_environment_variables()
+        if environment_warning := config.validate_environment():
+            warnings.append(environment_warning)
+        return config, warnings

cognite_toolkit/_cdf_tk/commands/build_v2/data_classes/_modules.py

@@ -0,0 +1,27 @@
+import sys
+from pathlib import Path
+
+from pydantic import BaseModel, ConfigDict
+
+from cognite_toolkit._cdf_tk.data_classes._module_toml import ModuleToml
+
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
+
+class Module(BaseModel):
+    model_config = ConfigDict(
+        frozen=True,
+        validate_assignment=True,
+        arbitrary_types_allowed=True,
+    )
+
+    path: Path
+    definition: ModuleToml | None = None
+
+    @classmethod
+    def load(cls, path: Path) -> Self:
+        definition = ModuleToml.load(path / ModuleToml.filename) if (path / ModuleToml.filename).exists() else None
+        return cls(path=path, definition=definition)

cognite_toolkit/_cdf_tk/commands/build_v2/data_classes/_resource.py

@@ -0,0 +1,22 @@
+import sys
+from pathlib import Path
+
+from pydantic import BaseModel, ConfigDict
+
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
+
+class Resource(BaseModel):
+    model_config = ConfigDict(
+        frozen=True,
+        validate_assignment=True,
+    )
+
+    path: Path
+
+    @classmethod
+    def load(cls, path: Path) -> Self:
+        return cls(path=path)

cognite_toolkit/_cdf_tk/commands/dump_resource.py

@@ -52,10 +52,10 @@ from rich.console import Console
 from rich.panel import Panel
 
 from cognite_toolkit._cdf_tk.client import ToolkitClient
-from cognite_toolkit._cdf_tk.client.data_classes.location_filters import LocationFilterList
-from cognite_toolkit._cdf_tk.client.data_classes.search_config import SearchConfigList
-from cognite_toolkit._cdf_tk.client.data_classes.search_config import ViewId as SearchConfigViewId
-from cognite_toolkit._cdf_tk.client.data_classes.streamlit_ import Streamlit, StreamlitList
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.location_filters import LocationFilterList
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.search_config import SearchConfigList
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.search_config import ViewId as SearchConfigViewId
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.streamlit_ import Streamlit, StreamlitList
 from cognite_toolkit._cdf_tk.cruds import (
     AgentCRUD,
     ContainerCRUD,