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

cognite_toolkit/_cdf_tk/data_classes/_build_variables.py

@@ -8,11 +8,11 @@ from functools import cached_property
 from pathlib import Path
 from typing import Any, Literal, SupportsIndex, overload
 
+from cognite_toolkit._cdf_tk.cruds._resource_cruds.transformation import TransformationCRUD
+from cognite_toolkit._cdf_tk.data_classes._module_directories import ModuleLocation
 from cognite_toolkit._cdf_tk.exceptions import ToolkitValueError
 from cognite_toolkit._cdf_tk.feature_flags import Flags
 
-from ._module_directories import ModuleLocation
-
 if sys.version_info >= (3, 11):
     from typing import Self
 else:
@@ -161,16 +161,19 @@ class BuildVariables(tuple, Sequence[BuildVariable]):
         ]
 
     @overload
-    def replace(self, content: str, file_suffix: str = ".yaml", use_placeholder: Literal[False] = False) -> str: ...
+    def replace(self, content: str, file_path: Path | None = None, use_placeholder: Literal[False] = False) -> str: ...
 
     @overload
     def replace(
-        self, content: str, file_suffix: str = ".yaml", use_placeholder: Literal[True] = True
+        self, content: str, file_path: Path | None = None, use_placeholder: Literal[True] = True
     ) -> tuple[str, dict[str, BuildVariable]]: ...
 
     def replace(
-        self, content: str, file_suffix: str = ".yaml", use_placeholder: bool = False
+        self, content: str, file_path: Path | None = None, use_placeholder: bool = False
     ) -> str | tuple[str, dict[str, BuildVariable]]:
+        # Extract file suffix from path, default to .yaml if not provided
+        file_suffix = file_path.suffix if file_path and file_path.suffix else ".yaml"
+
         variable_by_placeholder: dict[str, BuildVariable] = {}
         for variable in self:
             if not use_placeholder:
@@ -180,22 +183,125 @@ class BuildVariables(tuple, Sequence[BuildVariable]):
                 variable_by_placeholder[replace] = variable
 
             _core_pattern = rf"{{{{\s*{variable.key}\s*}}}}"
-            if file_suffix in {".yaml", ".yml", ".json"}:
-                # Preserve data types
-                pattern = _core_pattern
-                if isinstance(replace, str) and (replace.isdigit() or replace.endswith(":")):
-                    replace = f'"{replace}"'
-                    pattern = rf"'{_core_pattern}'|{_core_pattern}|" + rf'"{_core_pattern}"'
-                elif replace is None:
-                    replace = "null"
-                content = re.sub(pattern, str(replace), content)
+            if file_suffix == ".sql":
+                # For SQL files, convert lists to SQL-style tuples
+                if isinstance(replace, list):
+                    replace = self._format_list_as_sql_tuple(replace)
+                content = re.sub(_core_pattern, str(replace), content)
+            elif file_suffix in {".yaml", ".yml", ".json"}:
+                # Check if this is a transformation file (ends with Transformation.yaml/yml)
+                is_transformation_file = file_path is not None and f".{TransformationCRUD.kind}." in file_path.name
+                # Check if variable is within a query field (SQL context)
+                is_in_query_field = self._is_in_query_field(content, variable.key)
+
+                # For lists in query fields, use SQL-style tuples
+                # For transformation files, ensure SQL conversion is applied to query property variables
+                if is_transformation_file and is_in_query_field and isinstance(replace, list):
+                    replace = self._format_list_as_sql_tuple(replace)
+                    # Use simple pattern for SQL context (no YAML quoting needed)
+                    content = re.sub(_core_pattern, str(replace), content)
+                else:
+                    # Preserve data types for YAML
+                    pattern = _core_pattern
+                    if isinstance(replace, str) and (replace.isdigit() or replace.endswith(":")):
+                        replace = f'"{replace}"'
+                        pattern = rf"'{_core_pattern}'|{_core_pattern}|" + rf'"{_core_pattern}"'
+                    elif replace is None:
+                        replace = "null"
+                    content = re.sub(pattern, str(replace), content)
             else:
+                # For other file types, use simple string replacement
                 content = re.sub(_core_pattern, str(replace), content)
         if use_placeholder:
             return content, variable_by_placeholder
         else:
             return content
 
+    @staticmethod
+    def _is_transformation_file(file_path: Path) -> bool:
+        """Check if the file path indicates a transformation YAML file.
+
+        Transformation files are YAML files in the "transformations" folder.
+
+        Args:
+            file_path: The file path to check
+
+        Returns:
+            True if the file is a transformation YAML file
+        """
+        # Check if path contains "transformations" folder and ends with .yaml/.yml
+        path_str = file_path.as_posix().lower()
+        return "transformations" in path_str and file_path.suffix.lower() in {".yaml", ".yml"}
+
+    @staticmethod
+    def _format_list_as_sql_tuple(replace: list[Any]) -> str:
+        """Format a list as a SQL-style tuple string.
+
+        Args:
+            replace: The list to format
+
+        Returns:
+            SQL tuple string, e.g., "('A', 'B', 'C')" or "()" for empty lists
+        """
+        if not replace:
+            # Empty list becomes empty SQL tuple
+            return "()"
+        else:
+            # Format list as SQL tuple: ('A', 'B', 'C')
+            formatted_items = []
+            for item in replace:
+                if item is None:
+                    formatted_items.append("NULL")
+                elif isinstance(item, str):
+                    formatted_items.append(f"'{item}'")
+                else:
+                    formatted_items.append(str(item))
+            return f"({', '.join(formatted_items)})"
+
+    @staticmethod
+    def _is_in_query_field(content: str, variable_key: str) -> bool:
+        """Check if a variable is within a query field in YAML.
+
+        Assumes query is a top-level property. This detects various YAML formats:
+        - query: >-
+        - query: |
+        - query: "..."
+        - query: ...
+        """
+        lines = content.split("\n")
+        variable_pattern = rf"{{{{\s*{re.escape(variable_key)}\s*}}}}"
+        in_query_field = False
+
+        for line in lines:
+            # Check if this line starts a top-level query field
+            query_match = re.match(r"^query\s*:\s*(.*)$", line)
+            if query_match:
+                in_query_field = True
+                query_content_start = query_match.group(1).strip()
+
+                # Check if variable is on the same line as query: declaration
+                if re.search(variable_pattern, line):
+                    return True
+
+                # If query content starts on same line (not a block scalar), check it
+                if query_content_start and not query_content_start.startswith(("|", ">", "|-", ">-", "|+", ">+")):
+                    if re.search(variable_pattern, query_content_start):
+                        return True
+                continue
+
+            # Check if we're still in the query field
+            if in_query_field:
+                # If we hit another top-level property, we've exited the query field
+                if re.match(r"^\w+\s*:", line):
+                    in_query_field = False
+                    continue
+
+                # We're still in the query field, check for variable
+                if re.search(variable_pattern, line):
+                    return True
+
+        return False
+
     # Implemented to get correct type hints
     def __iter__(self) -> Iterator[BuildVariable]:
         return super().__iter__()

cognite_toolkit/_cdf_tk/data_classes/_built_modules.py

@@ -4,8 +4,8 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, SupportsIndex, overload
 
-from cognite_toolkit._cdf_tk.loaders import ResourceTypes
-from cognite_toolkit._cdf_tk.loaders._base_loaders import T_ID
+from cognite_toolkit._cdf_tk.cruds import ResourceTypes
+from cognite_toolkit._cdf_tk.cruds._base_cruds import T_ID
 
 from ._build_variables import BuildVariables
 from ._built_resources import (
@@ -30,6 +30,8 @@ class BuiltModule:
     warning_count: int
     status: str
     iteration: int
+    package_id: str | None = None
+    module_id: str | None = None
 
     @classmethod
     def load(cls, data: dict[str, Any]) -> Self:
@@ -44,6 +46,8 @@ class BuiltModule:
             warning_count=data.get("warning_count", 0),
             status=data.get("status", "Success"),
             iteration=data.get("iteration", 1),
+            package_id=data.get("package_id"),
+            module_id=data.get("module_id"),
         )
 
     def dump(self) -> dict[str, Any]:
@@ -57,6 +61,8 @@ class BuiltModule:
             "warning_count": self.warning_count,
             "status": self.status,
             "iteration": self.iteration,
+            "package_id": self.package_id,
+            "module_id": self.module_id,
         }
 
 
@@ -100,7 +106,7 @@ class BuiltModuleList(list, MutableSequence[BuiltModule]):
             resources = (
                 resource
                 for resource in resources
-                if (resource.source.path == selected or resource.source.path.is_relative_to(selected.absolute()))
+                if (resource.source.path == selected or self._are_relative(resource.source.path, selected))
             )
         if is_supported_file:
             # This is necessary as the destination file can be created from a source file that is not supported.
@@ -115,3 +121,7 @@ class BuiltModuleList(list, MutableSequence[BuiltModule]):
             for resource_dir, resources in module.resources.items():
                 resources_by_folder.setdefault(resource_dir, BuiltResourceList()).extend(resources)
         return resources_by_folder
+
+    @staticmethod
+    def _are_relative(filepath: Path, select_path: Path) -> bool:
+        return filepath.resolve().is_relative_to(select_path.resolve())

cognite_toolkit/_cdf_tk/data_classes/_built_resources.py

@@ -7,9 +7,9 @@ from functools import cached_property
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Generic, SupportsIndex, TypeVar, cast, overload
 
+from cognite_toolkit._cdf_tk.cruds import get_crud
+from cognite_toolkit._cdf_tk.cruds._base_cruds import T_ID, ResourceCRUD
 from cognite_toolkit._cdf_tk.exceptions import ToolkitMissingResourceError
-from cognite_toolkit._cdf_tk.loaders import get_loader
-from cognite_toolkit._cdf_tk.loaders._base_loaders import T_ID, ResourceLoader
 from cognite_toolkit._cdf_tk.utils import (
     calculate_directory_hash,
     calculate_hash,
@@ -100,10 +100,10 @@ class BuiltResource(Generic[T_ID]):
 
     @classmethod
     def load(cls, data: dict[str, Any], resource_folder: str) -> Self:
-        from cognite_toolkit._cdf_tk.loaders import ResourceLoader, get_loader
+        from cognite_toolkit._cdf_tk.cruds import ResourceCRUD, get_crud
 
         kind = data["kind"]
-        loader = cast(ResourceLoader, get_loader(resource_folder, kind))
+        loader = cast(ResourceCRUD, get_crud(resource_folder, kind))
         identifier = loader.get_id(data["identifier"])
 
         return cls(
@@ -115,9 +115,9 @@ class BuiltResource(Generic[T_ID]):
         )
 
     def dump(self, resource_folder: str, include_destination: bool = False) -> dict[str, Any]:
-        from cognite_toolkit._cdf_tk.loaders import ResourceLoader, get_loader
+        from cognite_toolkit._cdf_tk.cruds import ResourceCRUD, get_crud
 
-        loader = cast(ResourceLoader, get_loader(resource_folder, self.kind))
+        loader = cast(ResourceCRUD, get_crud(resource_folder, self.kind))
         dumped = loader.dump_id(self.identifier)
 
         output: dict[str, Any] = {
@@ -158,8 +158,8 @@ class BuiltResourceFull(BuiltResource[T_ID]):
     def load_resource_dict(
         self, environment_variables: dict[str, str | None], validate: bool = False
     ) -> dict[str, Any]:
-        content = self.build_variables.replace(safe_read(self.source.path))
-        loader = cast(ResourceLoader, get_loader(self.resource_dir, self.kind))
+        content = self.build_variables.replace(safe_read(self.source.path), self.source.path)
+        loader = cast(ResourceCRUD, get_crud(self.resource_dir, self.kind))
         raw = load_yaml_inject_variables(
             content,
             environment_variables,

cognite_toolkit/_cdf_tk/data_classes/_config_yaml.py

@@ -15,7 +15,6 @@ from rich import print
 from cognite_toolkit._cdf_tk.constants import (
     _RUNNING_IN_BROWSER,
     BUILD_ENVIRONMENT_FILE,
-    BUILTIN_MODULES,
     DEFAULT_CONFIG_FILE,
     DEFAULT_ENV,
     MODULES,
@@ -23,9 +22,9 @@ from cognite_toolkit._cdf_tk.constants import (
     SEARCH_VARIABLES_SUFFIX,
     EnvType,
 )
+from cognite_toolkit._cdf_tk.cruds import CRUDS_BY_FOLDER_NAME, RawDatabaseCRUD
 from cognite_toolkit._cdf_tk.exceptions import ToolkitEnvError, ToolkitMissingModuleError
 from cognite_toolkit._cdf_tk.hints import ModuleDefinition
-from cognite_toolkit._cdf_tk.loaders import LOADER_BY_FOLDER_NAME, RawDatabaseLoader
 from cognite_toolkit._cdf_tk.tk_warnings import (
     FileReadWarning,
     MediumSeverityWarning,
@@ -173,7 +172,7 @@ class BuildConfigYAML(ConfigYAMLCore, ConfigCore):
         self, built_modules: BuiltModuleList, selected_modules: ModuleDirectories
     ) -> "BuildEnvironment":
         return BuildEnvironment(
-            name=self.environment.name,  # type: ignore[arg-type]
+            name=self.environment.name,
             project=self.environment.project,
             validation_type=self.environment.validation_type,
             selected=self.environment.selected,
@@ -307,7 +306,7 @@ class BuildEnvironment(Environment):
     def check_source_files_changed(self) -> WarningList[FileReadWarning]:
         warning_list = WarningList[FileReadWarning]()
         for resource_folder, resources in self.built_resources.items():
-            if resource_folder == RawDatabaseLoader.folder_name:
+            if resource_folder == RawDatabaseCRUD.folder_name:
                 # We modify the hash for RawDatabaseLoader, so we skip checking the hash for this folder.
                 continue
             for resource in resources:
@@ -468,7 +467,7 @@ class InitConfigYAML(YAMLWithComments[tuple[str, ...], ConfigEntry], ConfigYAMLC
         """Loads all default.config.yaml files in the cognite root module."""
 
         default_files_iterable: Iterable[Path]
-        if cognite_root_module.name in ROOT_MODULES or cognite_root_module.name == BUILTIN_MODULES:
+        if cognite_root_module.name in ROOT_MODULES:
             default_files_iterable = cognite_root_module.glob(f"**/{DEFAULT_CONFIG_FILE}")
         else:
             default_files_iterable = itertools.chain(
@@ -497,7 +496,9 @@ class InitConfigYAML(YAMLWithComments[tuple[str, ...], ConfigEntry], ConfigYAMLC
         adds them to the config.yaml file.
 
         Args:
-            cognite_root_module: The root module for all cognite modules.
+            cognite_root_module: Path to the root directory containing all Cognite modules.
+            defaults_files: List of paths to default.config.yaml files to load.
+            ignore_patterns: Optional list of tuples containing patterns to ignore when loading defaults.
 
         Returns:
             self
@@ -510,6 +511,10 @@ class InitConfigYAML(YAMLWithComments[tuple[str, ...], ConfigEntry], ConfigYAMLC
             raw_file = safe_read(default_config)
             file_comments = self._extract_comments(raw_file, key_prefix=tuple(parts))
             file_data = cast(dict, read_yaml_content(raw_file))
+
+            # a file may exist, but contain just comments, thus the file_data is None
+            if file_data is None:
+                continue
             for key, value in file_data.items():
                 if len(parts) >= 1 and parts[0] in ROOT_MODULES:
                     key_path = (self._variables, *parts, key)
@@ -593,7 +598,7 @@ class InitConfigYAML(YAMLWithComments[tuple[str, ...], ConfigEntry], ConfigYAMLC
                 continue
             content = safe_read(filepath)
             key_parent = filepath.parent.relative_to(organization_dir).parts
-            if key_parent and key_parent[-1] in LOADER_BY_FOLDER_NAME:
+            if key_parent and key_parent[-1] in CRUDS_BY_FOLDER_NAME:
                 key_parent = key_parent[:-1]
 
             for match in re.findall(r"{{\s*([a-zA-Z0-9_]+)\s*}}", content):
@@ -612,7 +617,7 @@ class InitConfigYAML(YAMLWithComments[tuple[str, ...], ConfigEntry], ConfigYAMLC
                 # Remove module subfolders.
                 key_parent_list = list(key_parent)
                 for i in range(len(key_parent_list)):
-                    if key_parent_list[i] in LOADER_BY_FOLDER_NAME:
+                    if key_parent_list[i] in CRUDS_BY_FOLDER_NAME:
                         key_parent_list = key_parent_list[:i]
                         break
                 key_parent = tuple(key_parent_list)
@@ -635,7 +640,7 @@ class InitConfigYAML(YAMLWithComments[tuple[str, ...], ConfigEntry], ConfigYAMLC
         ] = defaultdict(list)
         count_by_variable_keys: dict[str, set[float | int | str | bool | tuple[Hashable] | None]] = defaultdict(set)
         for key, entry in self.items():
-            value = tuple(entry.value) if isinstance(entry.value, list) else entry.value  # type: ignore[arg-type]
+            value = tuple(entry.value) if isinstance(entry.value, list) else entry.value
             variables_by_key_value[(key[-1], value)].append(entry)
             count_by_variable_keys[key[-1]].add(value)
 

cognite_toolkit/_cdf_tk/data_classes/_module_directories.py

@@ -50,6 +50,20 @@ class ModuleLocation:
             return self.definition.title
         return None
 
+    @property
+    def module_id(self) -> str | None:
+        """The ID of the module."""
+        if self.definition:
+            return self.definition.id
+        return None
+
+    @property
+    def package_id(self) -> str | None:
+        """The ID of the package."""
+        if self.definition:
+            return self.definition.package_id
+        return None
+
     @property
     def relative_path(self) -> Path:
         """The relative path to the module."""
@@ -150,6 +164,8 @@ class ModuleLocation:
         return ReadModule(
             dir=self.dir,
             resource_directories=tuple(self.resource_directories),
+            module_id=self.module_id,
+            package_id=self.package_id,
         )
 
 
@@ -164,6 +180,8 @@ class ReadModule:
 
     dir: Path
     resource_directories: tuple[str, ...]
+    module_id: str | None
+    package_id: str | None
 
     def resource_dir_path(self, resource_folder: str) -> Path | None:
         """Returns the path to a resource in the module.
@@ -184,12 +202,16 @@ class ReadModule:
         return cls(
             dir=Path(data["dir"]),
             resource_directories=tuple(data["resource_directories"]),
+            module_id=data.get("module_id"),
+            package_id=data.get("package_id"),
         )
 
     def dump(self) -> dict[str, Any]:
         return {
             "dir": self.dir.as_posix(),
             "resource_directories": list(self.resource_directories),
+            "module_id": self.module_id,
+            "package_id": self.package_id,
         }
 
 

cognite_toolkit/_cdf_tk/data_classes/_module_resources.py

@@ -9,8 +9,8 @@ import yaml
 from cognite_toolkit import _version
 from cognite_toolkit._cdf_tk.cdf_toml import CDFToml
 from cognite_toolkit._cdf_tk.constants import DEFAULT_ENV
-from cognite_toolkit._cdf_tk.loaders import ResourceTypes
-from cognite_toolkit._cdf_tk.loaders._base_loaders import T_ID
+from cognite_toolkit._cdf_tk.cruds import ResourceTypes
+from cognite_toolkit._cdf_tk.cruds._base_cruds import T_ID
 from cognite_toolkit._cdf_tk.utils import (
     safe_write,
     tmp_build_directory,

cognite_toolkit/_cdf_tk/data_classes/_module_toml.py

@@ -35,10 +35,12 @@ class ExampleData:
 class ModuleToml:
     filename: ClassVar[str] = "module.toml"
     title: str | None
+    id: str | None = None
     dependencies: frozenset[str] = field(default_factory=frozenset)
     is_selected_by_default: bool = False
     data: list[ExampleData] = field(default_factory=list)
     extra_resources: list[Path] = field(default_factory=list)
+    package_id: str | None = None
 
     def __post_init__(self) -> None:
         for extra in self.extra_resources:
@@ -64,15 +66,20 @@ class ModuleToml:
             extra_resources = [Path(item["location"]) for item in data["extra_resources"] if "location" in item]
 
         title: str | None = None
+        id: str | None = None
         is_selected_by_default: bool = False
         if "module" in data:
             title = data["module"].get("title")
+            id = data["module"].get("id")
             is_selected_by_default = data["module"].get("is_selected_by_default", False)
+            package_id = data["module"].get("package_id")
 
         return cls(
             title=title,
+            id=id,
             dependencies=dependencies,
             is_selected_by_default=is_selected_by_default,
             data=example_data,
             extra_resources=extra_resources,
+            package_id=package_id,
         )

cognite_toolkit/_cdf_tk/data_classes/_packages.py

@@ -3,7 +3,9 @@ from collections.abc import ItemsView, Iterable, Iterator, KeysView, Mapping, Mu
 from dataclasses import dataclass, field
 from pathlib import Path
 
-from cognite_toolkit._cdf_tk.exceptions import ToolkitFileNotFoundError, ToolkitValueError
+from cognite_toolkit._cdf_tk.exceptions import ToolkitFileNotFoundError
+from cognite_toolkit._cdf_tk.tk_warnings.base import ToolkitWarning, WarningList
+from cognite_toolkit._cdf_tk.tk_warnings.other import LowSeverityWarning
 
 from ._module_directories import ModuleDirectories, ModuleLocation
 
@@ -23,12 +25,14 @@ class Package:
         name: the unique identifier of the package.
         title: The display name of the package.
         description: A description of the package.
+        id: An optional identifier for package statistics.
         modules: The modules that are part of the package.
     """
 
     name: str
     title: str
     description: str | None = None
+    id: str | None = None
     can_cherry_pick: bool = True
     modules: list[ModuleLocation] = field(default_factory=list)
 
@@ -43,12 +47,19 @@ class Package:
             name=name,
             title=package_definition["title"],
             description=package_definition.get("description"),
+            id=package_definition.get("id"),
             can_cherry_pick=package_definition.get("canCherryPick", True),
         )
 
 
 class Packages(dict, MutableMapping[str, Package]):
-    def __init__(self, packages: Iterable[Package] | Mapping[str, Package] | None = None) -> None:
+    warnings: WarningList[ToolkitWarning] | None = None
+
+    def __init__(
+        self,
+        packages: Iterable[Package] | Mapping[str, Package] | None = None,
+        warnings: WarningList[ToolkitWarning] | None = None,
+    ) -> None:
         if packages is None:
             super().__init__()
         elif isinstance(packages, Mapping):
@@ -56,6 +67,9 @@ class Packages(dict, MutableMapping[str, Package]):
         else:
             super().__init__({p.name: p for p in packages})
 
+        if warnings:
+            self.warnings = warnings
+
     @classmethod
     def load(
         cls,
@@ -82,20 +96,23 @@ class Packages(dict, MutableMapping[str, Package]):
 
         packages_with_modules: dict[str, Package] = {}
 
+        warnings = WarningList[ToolkitWarning]()
+
         for package_name, package_definition in package_definitions.items():
             packages_with_modules[package_name] = Package.load(package_name, package_definition)
             if modules := package_definition.get("modules"):
                 if isinstance(modules, list) and modules:
                     for module_path in modules:
                         if (module := module_by_relative_path.get(Path(module_path))) is None:
-                            available = sorted(str(m.relative_path) for m in module_directories)
-                            raise ToolkitValueError(
-                                f"Module '{module_path}' not found in the module directories.\n"
-                                f"Available modules: {available}"
+                            warnings.append(
+                                LowSeverityWarning(
+                                    f"Unable to load module '{module_path}'. The path may be wrong or the module may require an alpha flag that is not set."
+                                )
                             )
+                            continue
                         packages_with_modules[package_name].modules.append(module)
 
-        return cls(packages_with_modules)
+        return cls(packages_with_modules, warnings)
 
     # The methods are overloads to provide type hints for the methods.
     def items(self) -> ItemsView[str, Package]:  # type: ignore[override]

cognite_toolkit/_cdf_tk/data_classes/_tracking_info.py

@@ -0,0 +1,43 @@
+"""Data class for command tracking information."""
+
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class CommandTrackingInfo(BaseModel):
+    """Structured tracking information for CLI commands.
+
+    This model provides type-safe tracking information that can be collected
+    during command execution and sent to Mixpanel for analytics.
+
+    Attributes:
+        project: The CDF project name.
+        cluster: The CDF cluster name.
+        module_ids: List of module IDs that were deployed or built.
+        package_ids: List of package IDs that were deployed or built.
+        installed_module_ids: List of module IDs that were installed.
+        installed_package_ids: List of package IDs that were installed.
+        downloaded_library_ids: List of library IDs that were downloaded.
+        downloaded_package_ids: List of package IDs that were downloaded.
+        downloaded_module_ids: List of module IDs that were downloaded.
+    """
+
+    project: str | None = Field(default=None)
+    cluster: str | None = Field(default=None)
+    module_ids: set[str] = Field(default_factory=set, alias="moduleIds")
+    package_ids: set[str] = Field(default_factory=set, alias="packageIds")
+    installed_module_ids: set[str] = Field(default_factory=set, alias="installedModuleIds")
+    installed_package_ids: set[str] = Field(default_factory=set, alias="installedPackageIds")
+    downloaded_library_ids: set[str] = Field(default_factory=set, alias="downloadedLibraryIds")
+    downloaded_package_ids: set[str] = Field(default_factory=set, alias="downloadedPackageIds")
+    downloaded_module_ids: set[str] = Field(default_factory=set, alias="downloadedModuleIds")
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert the tracking info to a dictionary for Mixpanel.
+
+        Returns:
+            A dictionary with camelCase keys matching Mixpanel's expected format.
+            Default values are excluded.
+        """
+        return self.model_dump(mode="json", by_alias=True, exclude_defaults=True)

cognite_toolkit/_cdf_tk/exceptions.py

@@ -179,7 +179,10 @@ class UploadFileError(ToolkitError):
     pass
 
 
-class ResourceRetrievalError(ToolkitError): ...
+class ResourceRetrievalError(ToolkitError):
+    def __init__(self, message: str, resources: list[str] | None = None) -> None:
+        super().__init__(message)
+        self.resources = resources
 
 
 class ResourceCreationError(ToolkitError):
@@ -241,3 +244,9 @@ class ToolkitNotImplementedError(NotImplementedError, ToolkitError):
 
     def __str__(self) -> str:
         return f"ToolkitNotImplementedError: {self.message}"
+
+
+class ToolkitRuntimeError(RuntimeError, ToolkitError):
+    """General runtime error for toolkit operations."""
+
+    ...