cognite-toolkit 0.5.61__py3-none-any.whl → 0.5.62__py3-none-any.whl

cognite_toolkit/_builtin_modules/cdf.toml

@@ -4,7 +4,7 @@ default_env = "<DEFAULT_ENV_PLACEHOLDER>"
 [modules]
 # This is the version of the modules. It should not be changed manually.
 # It will be updated by the 'cdf modules upgrade' command.
-version = "0.5.61"
+version = "0.5.62"
 
 
 [plugins]

cognite_toolkit/_cdf_tk/apps/_modules_app.py

@@ -62,14 +62,14 @@ class ModulesApp(typer.Typer):
     ) -> None:
         """Initialize or upgrade a new CDF project with templates interactively."""
 
-        cmd = ModulesCommand()
-        cmd.run(
-            lambda: cmd.init(
-                organization_dir=organization_dir,
-                select_all=all,
-                clean=clean,
+        with ModulesCommand() as cmd:
+            cmd.run(
+                lambda: cmd.init(
+                    organization_dir=organization_dir,
+                    select_all=all,
+                    clean=clean,
+                )
             )
-        )
 
     def upgrade(
         self,
@@ -116,8 +116,8 @@ class ModulesApp(typer.Typer):
         ] = False,
     ) -> None:
         """Add one or more new module(s) to the project."""
-        cmd = ModulesCommand()
-        cmd.run(lambda: cmd.add(organization_dir=organization_dir))
+        with ModulesCommand() as cmd:
+            cmd.run(lambda: cmd.add(organization_dir=organization_dir))
 
     def pull(
         self,

cognite_toolkit/_cdf_tk/apps/_profile_app.py

@@ -3,7 +3,7 @@ from typing import Any
 import typer
 from rich import print
 
-from cognite_toolkit._cdf_tk.commands import ProfileCommand
+from cognite_toolkit._cdf_tk.commands import ProfileAssetCentricCommand
 from cognite_toolkit._cdf_tk.utils.auth import EnvironmentVariables
 
 
@@ -27,7 +27,7 @@ class ProfileApp(typer.Typer):
         This shows an approximation of unstructured data count. This can, for example, be used to estimate the
         effort to model this data in data modeling."""
         client = EnvironmentVariables.create_from_environment().get_client()
-        cmd = ProfileCommand()
+        cmd = ProfileAssetCentricCommand()
         cmd.run(
             lambda: cmd.asset_centric(
                 client,

cognite_toolkit/_cdf_tk/cdf_toml.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import re
 import sys
+import urllib
 from contextlib import suppress
 from dataclasses import dataclass, field
 from pathlib import Path
@@ -64,12 +65,39 @@ class ModulesConfig:
         ):
             raise ToolkitVersionError(
                 f"The version of the modules ({version}) does not match the version of the installed CLI "
-                f"({_version.__version__}). Please either run `cdf-tk modules upgrade` to upgrade the modules OR "
-                f"run `pip install cognite-toolkit=={version}` to downgrade cdf-tk CLI."
+                f"({_version.__version__}). Please run `cdf modules upgrade` to upgrade the modules OR "
+                f"run `pip install cognite-toolkit=={version}` to downgrade cdf CLI."
             )
         return cls(version=version, packages=packages)
 
 
+@dataclass
+class Library:
+    url: str
+    checksum: str
+
+    @classmethod
+    def load(cls, raw: dict[str, Any]) -> Library:
+        if "url" not in raw:
+            raise ValueError("Library configuration must contain 'url' field.")
+
+        if "checksum" not in raw:
+            raise ValueError("Library configuration must contain 'checksum' field.")
+
+        parsed_url = urllib.parse.urlparse(raw["url"])
+
+        if not all([parsed_url.scheme, parsed_url.netloc]):
+            raise ValueError("URL is missing scheme or network location (e.g., 'https://domain.com')")
+
+        if parsed_url.scheme != "https":
+            raise ValueError("URL must start with 'https'")
+
+        if not parsed_url.path.casefold().endswith(".zip"):
+            raise ValueError("URL must point to a .zip file.")
+
+        return cls(**raw)
+
+
 @dataclass
 class CDFToml:
     """This is the configuration for the CLI and Modules"""
@@ -80,6 +108,7 @@ class CDFToml:
     modules: ModulesConfig
     alpha_flags: dict[str, bool] = field(default_factory=dict)
     plugins: dict[str, bool] = field(default_factory=dict)
+    libraries: dict[str, Library] = field(default_factory=dict)
 
     is_loaded_from_file: bool = False
 
@@ -114,7 +143,21 @@ class CDFToml:
             if "plugins" in raw:
                 plugins = {clean_name(k): v for k, v in raw["plugins"].items()}
 
-            instance = cls(cdf=cdf, modules=modules, alpha_flags=alpha_flags, plugins=plugins, is_loaded_from_file=True)
+            libraries = {}
+            for k, v in raw.get("library", {}).items():
+                try:
+                    libraries[k] = Library.load(v)
+                except Exception as e:
+                    raise ToolkitTOMLFormatError(f"Invalid library configuration for '{k}': {e.args[0]}") from e
+
+            instance = cls(
+                cdf=cdf,
+                modules=modules,
+                alpha_flags=alpha_flags,
+                plugins=plugins,
+                libraries=libraries,
+                is_loaded_from_file=True,
+            )
             if use_singleton:
                 _CDF_TOML = instance
             return instance

cognite_toolkit/_cdf_tk/client/data_classes/canvas.py

@@ -0,0 +1,395 @@
+from datetime import datetime
+
+from cognite.client.data_classes.data_modeling import DirectRelationReference
+from cognite.client.data_classes.data_modeling.ids import ViewId
+from cognite.client.data_classes.data_modeling.instances import (
+    PropertyOptions,
+    TypedNode,
+    TypedNodeApply,
+)
+
+
+class _CanvasProperties:
+    created_by = PropertyOptions("createdBy")
+    updated_at = PropertyOptions("updatedAt")
+    updated_by = PropertyOptions("updatedBy")
+    is_locked = PropertyOptions("isLocked")
+    source_canvas_id = PropertyOptions("sourceCanvasId")
+    is_archived = PropertyOptions("isArchived")
+    solution_tags = PropertyOptions("solutionTags")
+
+    @classmethod
+    def get_source(cls) -> ViewId:
+        return ViewId("cdf_industrial_canvas", "Canvas", "v7")
+
+
+class CanvasApply(_CanvasProperties, TypedNodeApply):
+    """This represents the writing format of canvas.
+
+    It is used to when data is written to CDF.
+
+    Args:
+        space: The space where the node is located.
+        external_id: The external id of the canva.
+        name: The name or title of the canvas.
+        created_by: The user identifier of the user that created the canvas.
+        updated_at: The timestamp when the canvas was last updated.
+        updated_by: The user identifier of the user that last updated the canvas.
+        is_locked: The boolean state for handling canvas locking which is one-way operation from the user perspective
+        visibility: The application-level visibility of the canvas. Must be either 'public' or 'private' and, if not
+            set, the canvas is expected to be public.
+        source_canvas_id: The property for handling versioning. Example sourceCanvasId === selectedCanvas -> query all
+            versions of such canvas
+        is_archived: Boolean that indicates whether the canvas is archived.
+        context: Stores contextual data attached to the canvas, such as rules and pinned values.
+        solution_tags: The list of solution tags associated with the canvas.
+        existing_version: Fail the ingestion request if the node's version is greater than or equal to this value.
+            If no existingVersion is specified, the ingestion will always overwrite any existing data for the node
+            (for the specified container or node). If existingVersion is set to 0, the upsert will behave as an insert,
+            so it will fail the bulk if the item already exists. If skipOnVersionConflict is set on the ingestion
+            request, then the item will be skipped instead of failing the ingestion request.
+        type: Direct relation pointing to the type node.
+    """
+
+    def __init__(
+        self,
+        space: str,
+        external_id: str,
+        *,
+        name: str,
+        created_by: str,
+        updated_at: datetime,
+        updated_by: str,
+        is_locked: bool | None = None,
+        visibility: str | None = None,
+        source_canvas_id: str | None = None,
+        is_archived: bool | None = None,
+        context: list[dict] | None = None,
+        solution_tags: list[DirectRelationReference | tuple[str, str]] | None = None,
+        existing_version: int | None = None,
+        type: DirectRelationReference | tuple[str, str] | None = None,
+    ) -> None:
+        TypedNodeApply.__init__(self, space, external_id, existing_version, type)
+        self.name = name
+        self.created_by = created_by
+        self.updated_at = updated_at
+        self.updated_by = updated_by
+        self.is_locked = is_locked
+        self.visibility = visibility
+        self.source_canvas_id = source_canvas_id
+        self.is_archived = is_archived
+        self.context = context
+        self.solution_tags = (
+            [DirectRelationReference.load(solution_tag) for solution_tag in solution_tags] if solution_tags else None
+        )
+
+
+class Canvas(_CanvasProperties, TypedNode):
+    """This represents the reading format of canva.
+
+    It is used to when data is read from CDF.
+
+    Args:
+        space: The space where the node is located.
+        external_id: The external id of the canva.
+        version (int): DMS version.
+        last_updated_time (int): The number of milliseconds since 00:00:00 Thursday, 1 January 1970,
+            Coordinated Universal Time (UTC), minus leap seconds.
+        created_time (int): The number of milliseconds since 00:00:00 Thursday, 1 January 1970,
+            Coordinated Universal Time (UTC), minus leap seconds.
+        name: The name or title of the canvas.
+        created_by: The user identifier of the user that created the canvas.
+        updated_at: The timestamp when the canvas was last updated.
+        updated_by: The user identifier of the user that last updated the canvas.
+        is_locked: The boolean state for handling canvas locking which is one-way operation from the user perspective
+        visibility: The application-level visibility of the canvas. Must be either 'public' or 'private' and, if not
+            set, the canvas is expected to be public.
+        source_canvas_id: The property for handling versioning. Example sourceCanvasId === selectedCanvas -> query all
+            versions of such canvas
+        is_archived: Boolean that indicates whether the canvas is archived.
+        context: Stores contextual data attached to the canvas, such as rules and pinned values.
+        solution_tags: The list of solution tags associated with the canvas.
+        type: Direct relation pointing to the type node.
+        deleted_time: The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time
+            (UTC), minus leap seconds. Timestamp when the instance was soft deleted. Note that deleted instances
+            are filtered out of query results, but present in sync results
+    """
+
+    def __init__(
+        self,
+        space: str,
+        external_id: str,
+        version: int,
+        last_updated_time: int,
+        created_time: int,
+        *,
+        name: str,
+        created_by: str,
+        updated_at: datetime,
+        updated_by: str,
+        is_locked: bool | None = None,
+        visibility: str | None = None,
+        source_canvas_id: str | None = None,
+        is_archived: bool | None = None,
+        context: list[dict] | None = None,
+        solution_tags: list[DirectRelationReference] | None = None,
+        type: DirectRelationReference | None = None,
+        deleted_time: int | None = None,
+    ) -> None:
+        TypedNode.__init__(self, space, external_id, version, last_updated_time, created_time, deleted_time, type)
+        self.name = name
+        self.created_by = created_by
+        self.updated_at = updated_at
+        self.updated_by = updated_by
+        self.is_locked = is_locked
+        self.visibility = visibility
+        self.source_canvas_id = source_canvas_id
+        self.is_archived = is_archived
+        self.context = context
+        self.solution_tags = (
+            [DirectRelationReference.load(solution_tag) for solution_tag in solution_tags] if solution_tags else None
+        )
+
+    def as_write(self) -> CanvasApply:
+        return CanvasApply(
+            self.space,
+            self.external_id,
+            name=self.name,
+            created_by=self.created_by,
+            updated_at=self.updated_at,
+            updated_by=self.updated_by,
+            is_locked=self.is_locked,
+            visibility=self.visibility,
+            source_canvas_id=self.source_canvas_id,
+            is_archived=self.is_archived,
+            context=self.context,
+            solution_tags=self.solution_tags,  # type: ignore[arg-type]
+            existing_version=self.version,
+            type=self.type,
+        )
+
+
+class _CanvasAnnotationProperties:
+    id_ = PropertyOptions("id")
+    annotation_type = PropertyOptions("annotationType")
+    container_id = PropertyOptions("containerId")
+    is_selectable = PropertyOptions("isSelectable")
+    is_draggable = PropertyOptions("isDraggable")
+    is_resizable = PropertyOptions("isResizable")
+    properties_ = PropertyOptions("properties")
+
+    @classmethod
+    def get_source(cls) -> ViewId:
+        return ViewId("cdf_industrial_canvas", "CanvasAnnotation", "v1")
+
+
+class CanvasAnnotationApply(_CanvasAnnotationProperties, TypedNodeApply):
+    """This represents the writing format of canvas annotation.
+
+    It is used to when data is written to CDF.
+
+    Args:
+        space: The space where the node is located.
+        external_id: The external id of the canvas annotation.
+        id_: The unique identifier of the canvas annotation.
+        annotation_type: The type of the annotation. Must be one of rectangle, ellipse, polyline, text or sticky.
+        container_id: The optional ID of the container that the annotation is contained in.
+        is_selectable: Boolean that indicates whether the annotation is selectable.
+        is_draggable: Boolean that indicates whether the annotation is draggable.
+        is_resizable: Boolean that indicates whether the annotation is resizable.
+        properties_: Additional properties or configuration for the annotation.
+        existing_version: Fail the ingestion request if the node's version is greater than or equal to this value.
+            If no existingVersion is specified, the ingestion will always overwrite any existing data for the node
+            (for the specified container or node). If existingVersion is set to 0, the upsert will behave as an insert,
+            so it will fail the bulk if the item already exists. If skipOnVersionConflict is set on the ingestion
+            request, then the item will be skipped instead of failing the ingestion request.
+        type: Direct relation pointing to the type node.
+    """
+
+    def __init__(
+        self,
+        space: str,
+        external_id: str,
+        *,
+        id_: str,
+        annotation_type: str,
+        container_id: str | None = None,
+        is_selectable: bool | None = None,
+        is_draggable: bool | None = None,
+        is_resizable: bool | None = None,
+        properties_: dict | None = None,
+        existing_version: int | None = None,
+        type: DirectRelationReference | tuple[str, str] | None = None,
+    ) -> None:
+        TypedNodeApply.__init__(self, space, external_id, existing_version, type)
+        self.id_ = id_
+        self.annotation_type = annotation_type
+        self.container_id = container_id
+        self.is_selectable = is_selectable
+        self.is_draggable = is_draggable
+        self.is_resizable = is_resizable
+        self.properties_ = properties_
+
+
+class CanvasAnnotation(_CanvasAnnotationProperties, TypedNode):
+    """This represents the reading format of canvas annotation.
+
+    It is used to when data is read from CDF.
+
+    Args:
+        space: The space where the node is located.
+        external_id: The external id of the canvas annotation.
+        version (int): DMS version.
+        last_updated_time (int): The number of milliseconds since 00:00:00 Thursday, 1 January 1970,
+            Coordinated Universal Time (UTC), minus leap seconds.
+        created_time (int): The number of milliseconds since 00:00:00 Thursday, 1 January 1970,
+            Coordinated Universal Time (UTC), minus leap seconds.
+        id_: The unique identifier of the canvas annotation.
+        annotation_type: The type of the annotation. Must be one of rectangle, ellipse, polyline, text or sticky.
+        container_id: The optional ID of the container that the annotation is contained in.
+        is_selectable: Boolean that indicates whether the annotation is selectable.
+        is_draggable: Boolean that indicates whether the annotation is draggable.
+        is_resizable: Boolean that indicates whether the annotation is resizable.
+        properties_: Additional properties or configuration for the annotation.
+        type: Direct relation pointing to the type node.
+        deleted_time: The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time
+            (UTC), minus leap seconds. Timestamp when the instance was soft deleted. Note that deleted instances
+            are filtered out of query results, but present in sync results
+    """
+
+    def __init__(
+        self,
+        space: str,
+        external_id: str,
+        version: int,
+        last_updated_time: int,
+        created_time: int,
+        *,
+        id_: str,
+        annotation_type: str,
+        container_id: str | None = None,
+        is_selectable: bool | None = None,
+        is_draggable: bool | None = None,
+        is_resizable: bool | None = None,
+        properties_: dict | None = None,
+        type: DirectRelationReference | None = None,
+        deleted_time: int | None = None,
+    ) -> None:
+        TypedNode.__init__(self, space, external_id, version, last_updated_time, created_time, deleted_time, type)
+        self.id_ = id_
+        self.annotation_type = annotation_type
+        self.container_id = container_id
+        self.is_selectable = is_selectable
+        self.is_draggable = is_draggable
+        self.is_resizable = is_resizable
+        self.properties_ = properties_
+
+    def as_write(self) -> CanvasAnnotationApply:
+        return CanvasAnnotationApply(
+            self.space,
+            self.external_id,
+            id_=self.id_,
+            annotation_type=self.annotation_type,
+            container_id=self.container_id,
+            is_selectable=self.is_selectable,
+            is_draggable=self.is_draggable,
+            is_resizable=self.is_resizable,
+            properties_=self.properties_,
+            existing_version=self.version,
+            type=self.type,
+        )
+
+
+class _CogniteSolutionTagProperties:
+    @classmethod
+    def get_source(cls) -> ViewId:
+        return ViewId("cdf_apps_shared", "CogniteSolutionTag", "v1")
+
+
+class CogniteSolutionTagApply(_CogniteSolutionTagProperties, TypedNodeApply):
+    """This represents the writing format of Cognite solution tag.
+
+    It is used to when data is written to CDF.
+
+    Args:
+        space: The space where the node is located.
+        external_id: The external id of the Cognite solution tag.
+        name: Name of the solution tag/label
+        description: Description of the solution tag/label
+        color: Color of the solution tag/label
+        existing_version: Fail the ingestion request if the node's version is greater than or equal to this value.
+            If no existingVersion is specified, the ingestion will always overwrite any existing data for the node
+            (for the specified container or node). If existingVersion is set to 0, the upsert will behave as an insert,
+            so it will fail the bulk if the item already exists. If skipOnVersionConflict is set on the ingestion
+            request, then the item will be skipped instead of failing the ingestion request.
+        type: Direct relation pointing to the type node.
+    """
+
+    def __init__(
+        self,
+        space: str,
+        external_id: str,
+        *,
+        name: str,
+        description: str | None = None,
+        color: str | None = None,
+        existing_version: int | None = None,
+        type: DirectRelationReference | tuple[str, str] | None = None,
+    ) -> None:
+        TypedNodeApply.__init__(self, space, external_id, existing_version, type)
+        self.name = name
+        self.description = description
+        self.color = color
+
+
+class CogniteSolutionTag(_CogniteSolutionTagProperties, TypedNode):
+    """This represents the reading format of Cognite solution tag.
+
+    It is used to when data is read from CDF.
+
+    Args:
+        space: The space where the node is located.
+        external_id: The external id of the Cognite solution tag.
+        version (int): DMS version.
+        last_updated_time (int): The number of milliseconds since 00:00:00 Thursday, 1 January 1970,
+            Coordinated Universal Time (UTC), minus leap seconds.
+        created_time (int): The number of milliseconds since 00:00:00 Thursday, 1 January 1970,
+            Coordinated Universal Time (UTC), minus leap seconds.
+        name: Name of the solution tag/label
+        description: Description of the solution tag/label
+        color: Color of the solution tag/label
+        type: Direct relation pointing to the type node.
+        deleted_time: The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time
+            (UTC), minus leap seconds. Timestamp when the instance was soft deleted. Note that deleted instances
+            are filtered out of query results, but present in sync results
+    """
+
+    def __init__(
+        self,
+        space: str,
+        external_id: str,
+        version: int,
+        last_updated_time: int,
+        created_time: int,
+        *,
+        name: str,
+        description: str | None = None,
+        color: str | None = None,
+        type: DirectRelationReference | None = None,
+        deleted_time: int | None = None,
+    ) -> None:
+        TypedNode.__init__(self, space, external_id, version, last_updated_time, created_time, deleted_time, type)
+        self.name = name
+        self.description = description
+        self.color = color
+
+    def as_write(self) -> CogniteSolutionTagApply:
+        return CogniteSolutionTagApply(
+            self.space,
+            self.external_id,
+            name=self.name,
+            description=self.description,
+            color=self.color,
+            existing_version=self.version,
+            type=self.type,
+        )

cognite_toolkit/_cdf_tk/commands/__init__.py

@@ -1,6 +1,6 @@
 from ._migrate import MigrateTimeseriesCommand, MigrationPrepareCommand
 from ._populate import PopulateCommand
-from ._profile import ProfileCommand
+from ._profile import ProfileAssetCentricCommand
 from ._purge import PurgeCommand
 from .auth import AuthCommand
 from .build_cmd import BuildCommand
@@ -30,7 +30,7 @@ __all__ = [
     "MigrationPrepareCommand",
     "ModulesCommand",
     "PopulateCommand",
-    "ProfileCommand",
+    "ProfileAssetCentricCommand",
     "PullCommand",
     "PurgeCommand",
     "RepoCommand",

cognite_toolkit/_cdf_tk/commands/_profile.py

@@ -1,7 +1,12 @@
-from collections.abc import Callable
+from abc import ABC, abstractmethod
+from collections.abc import Callable, Mapping
 from concurrent.futures import ThreadPoolExecutor, as_completed
+from functools import cached_property
+from typing import ClassVar, Literal, TypeAlias, overload
 
 from cognite.client.exceptions import CogniteException
+from rich import box
+from rich.console import Console
 from rich.live import Live
 from rich.spinner import Spinner
 from rich.table import Table
@@ -23,108 +28,212 @@ from cognite_toolkit._cdf_tk.utils.aggregators import (
 from ._base import ToolkitCommand
 
 
-class ProfileCommand(ToolkitCommand):
-    class Columns:
-        Resource = "Resource"
-        Count = "Count"
-        MetadataKeyCount = "Metadata Key Count"
-        LabelCount = "Label Count"
-        Transformation = "Transformations"
+class WaitingAPICallClass:
+    def __bool__(self) -> bool:
+        return False
 
-    columns = (
-        Columns.Resource,
-        Columns.Count,
-        Columns.MetadataKeyCount,
-        Columns.LabelCount,
-        Columns.Transformation,
-    )
-    spinner_speed = 1.0
 
-    @classmethod
-    def asset_centric(
-        cls,
-        client: ToolkitClient,
-        verbose: bool = False,
-    ) -> list[dict[str, str]]:
-        aggregators: list[AssetCentricAggregator] = [
-            AssetAggregator(client),
-            EventAggregator(client),
-            FileAggregator(client),
-            TimeSeriesAggregator(client),
-            SequenceAggregator(client),
-            RelationshipAggregator(client),
-            LabelCountAggregator(client),
-        ]
-        results, api_calls = cls._create_initial_table(aggregators)
-        with Live(cls.create_profile_table(results), refresh_per_second=4) as live:
-            with ThreadPoolExecutor(max_workers=8) as executor:
-                future_to_cell = {
-                    executor.submit(api_calls[(index, col)]): (index, col)
-                    for index in range(len(aggregators))
-                    for col in cls.columns
-                    if (index, col) in api_calls
+WaitingAPICall = WaitingAPICallClass()
+
+PendingCellValue: TypeAlias = int | float | str | bool | None | WaitingAPICallClass
+CellValue: TypeAlias = int | float | str | bool | None
+PendingTable: TypeAlias = dict[tuple[str, str], PendingCellValue]
+
+
+class ProfileCommand(ToolkitCommand, ABC):
+    def __init__(self, print_warning: bool = True, skip_tracking: bool = False, silent: bool = False) -> None:
+        super().__init__(print_warning, skip_tracking, silent)
+        self.table_title = self.__class__.__name__.removesuffix("Command")
+
+    class Columns:  # Placeholder for columns, subclasses should define their own Columns class
+        ...
+
+    spinner_args: ClassVar[Mapping] = dict(name="arc", text="loading...", style="bold green", speed=1.0)
+
+    max_workers = 8
+    is_dynamic_table = False
+
+    @cached_property
+    def columns(self) -> tuple[str, ...]:
+        return (
+            tuple([attr for attr in self.Columns.__dict__.keys() if not attr.startswith("_")])
+            if hasattr(self, "Columns")
+            else tuple()
+        )
+
+    def create_profile_table(self, client: ToolkitClient) -> list[dict[str, CellValue]]:
+        console = Console()
+        with console.status("Setting up", spinner="aesthetic", speed=0.4) as _:
+            table = self.create_initial_table(client)
+        with (
+            Live(self.draw_table(table), refresh_per_second=4, console=console) as live,
+            ThreadPoolExecutor(max_workers=self.max_workers) as executor,
+        ):
+            while True:
+                current_calls = {
+                    executor.submit(self.call_api(row, col, client)): (row, col)
+                    for (row, col), cell in table.items()
+                    if cell is WaitingAPICall
                 }
-                for future in as_completed(future_to_cell):
-                    index, col = future_to_cell[future]
-                    results[index][col] = future.result()
-                    live.update(cls.create_profile_table(results))
-        return [{col: str(value) for col, value in row.items()} for row in results]
+                if not current_calls:
+                    break
+                for future in as_completed(current_calls):
+                    row, col = current_calls[future]
+                    try:
+                        result = future.result()
+                    except CogniteException as e:
+                        result = type(e).__name__
+                    table[(row, col)] = self.format_result(result, row, col)
+                    if self.is_dynamic_table:
+                        table = self.update_table(table, result, row, col)
+                    live.update(self.draw_table(table))
+        return self.as_record_format(table, allow_waiting_api_call=False)
 
-    @classmethod
-    def _create_initial_table(
-        cls, aggregators: list[AssetCentricAggregator]
-    ) -> tuple[list[dict[str, str | Spinner]], dict[tuple[int, str], Callable[[], str]]]:
-        rows: list[dict[str, str | Spinner]] = []
-        api_calls: dict[tuple[int, str], Callable[[], str]] = {}
-        for index, aggregator in enumerate(aggregators):
-            row: dict[str, str | Spinner] = {
-                cls.Columns.Resource: aggregator.display_name,
-                cls.Columns.Count: Spinner("arc", text="loading...", style="bold green", speed=cls.spinner_speed),
-            }
-            api_calls[(index, cls.Columns.Count)] = cls._call_api(aggregator.count)
-            count: str | Spinner = "-"
-            if isinstance(aggregator, MetadataAggregator):
-                count = Spinner("arc", text="loading...", style="bold green", speed=cls.spinner_speed)
-                api_calls[(index, cls.Columns.MetadataKeyCount)] = cls._call_api(aggregator.metadata_key_count)
-            row[cls.Columns.MetadataKeyCount] = count
+    @abstractmethod
+    def create_initial_table(self, client: ToolkitClient) -> PendingTable:
+        """
+        Create the initial table with placeholders for API calls.
+        Each cell that requires an API call should be initialized with WaitingAPICall.
+        """
+        raise NotImplementedError("Subclasses must implement create_initial_table.")
 
-            count = "-"
-            if isinstance(aggregator, LabelAggregator):
-                count = Spinner("arc", text="loading...", style="bold green", speed=cls.spinner_speed)
-                api_calls[(index, cls.Columns.LabelCount)] = cls._call_api(aggregator.label_count)
-            row[cls.Columns.LabelCount] = count
+    @abstractmethod
+    def call_api(self, row: str, col: str, client: ToolkitClient) -> Callable:
+        raise NotImplementedError("Subclasses must implement call_api.")
 
-            row[cls.Columns.Transformation] = Spinner(
-                "arc", text="loading...", style="bold green", speed=cls.spinner_speed
-            )
-            api_calls[(index, cls.Columns.Transformation)] = cls._call_api(aggregator.transformation_count)
+    def format_result(self, result: object, row: str, col: str) -> CellValue:
+        """
+        Format the result of an API call for display in the table.
+        This can be overridden by subclasses to customize formatting.
+        """
+        if isinstance(result, int | float | bool | str):
+            return result
+        raise NotImplementedError("Subclasses must implement format_result.")
 
-            rows.append(row)
-        return rows, api_calls
+    def update_table(
+        self,
+        current_table: PendingTable,
+        result: object,
+        row: str,
+        col: str,
+    ) -> PendingTable:
+        raise NotImplementedError("Subclasses must implement update_table.")
 
-    @classmethod
-    def create_profile_table(cls, rows: list[dict[str, str | Spinner]]) -> Table:
-        table = Table(
-            title="Asset Centric Profile",
+    def draw_table(self, table: PendingTable) -> Table:
+        rich_table = Table(
+            title=self.table_title,
             title_justify="left",
             show_header=True,
             header_style="bold magenta",
+            box=box.MINIMAL,
         )
-        for col in cls.columns:
-            table.add_column(col)
+        for col in self.columns:
+            rich_table.add_column(col)
+
+        rows = self.as_record_format(table)
 
         for row in rows:
-            table.add_row(*row.values())
-        return table
+            rich_table.add_row(*[self._as_cell(value) for value in row.values()])
+        return rich_table
+
+    @classmethod
+    @overload
+    def as_record_format(
+        cls, table: PendingTable, allow_waiting_api_call: Literal[True] = True
+    ) -> list[dict[str, PendingCellValue]]: ...
+
+    @classmethod
+    @overload
+    def as_record_format(
+        cls,
+        table: PendingTable,
+        allow_waiting_api_call: Literal[False],
+    ) -> list[dict[str, CellValue]]: ...
 
-    @staticmethod
-    def _call_api(call_fun: Callable[[], int]) -> Callable[[], str]:
-        def styled_callable() -> str:
-            try:
-                value = call_fun()
-            except CogniteException as e:
-                return type(e).__name__
+    @classmethod
+    def as_record_format(
+        cls,
+        table: PendingTable,
+        allow_waiting_api_call: bool = True,
+    ) -> list[dict[str, PendingCellValue]] | list[dict[str, CellValue]]:
+        rows: list[dict[str, PendingCellValue]] = []
+        row_indices: dict[str, int] = {}
+        for (row, col), value in table.items():
+            if value is WaitingAPICall and not allow_waiting_api_call:
+                value = None
+            if row not in row_indices:
+                row_indices[row] = len(rows)
+                rows.append({col: value})
             else:
-                return f"{value:,}"
+                rows[row_indices[row]][col] = value
+        return rows
+
+    def _as_cell(self, value: PendingCellValue) -> str | Spinner:
+        if isinstance(value, WaitingAPICallClass):
+            return Spinner(**self.spinner_args)
+        elif isinstance(value, int):
+            return f"{value:,}"
+        elif isinstance(value, float):
+            return f"{value:.2f}"
+        elif value is None:
+            return "-"
+        return str(value)
+
+
+class ProfileAssetCentricCommand(ProfileCommand):
+    def __init__(self, print_warning: bool = True, skip_tracking: bool = False, silent: bool = False) -> None:
+        super().__init__(print_warning, skip_tracking, silent)
+        self.table_title = "Asset Centric Profile"
+        self.aggregators: dict[str, AssetCentricAggregator] = {}
+
+    class Columns:
+        Resource = "Resource"
+        Count = "Count"
+        MetadataKeyCount = "Metadata Key Count"
+        LabelCount = "Label Count"
+        Transformation = "Transformations"
+
+    def asset_centric(self, client: ToolkitClient, verbose: bool = False) -> list[dict[str, CellValue]]:
+        self.aggregators.update(
+            {
+                agg.display_name: agg
+                for agg in [
+                    AssetAggregator(client),
+                    EventAggregator(client),
+                    FileAggregator(client),
+                    TimeSeriesAggregator(client),
+                    SequenceAggregator(client),
+                    RelationshipAggregator(client),
+                    LabelCountAggregator(client),
+                ]
+            }
+        )
+        return self.create_profile_table(client)
+
+    def create_initial_table(self, client: ToolkitClient) -> PendingTable:
+        table: dict[tuple[str, str], str | int | float | bool | None | WaitingAPICallClass] = {}
+        for index, aggregator in self.aggregators.items():
+            table[(index, self.Columns.Resource)] = aggregator.display_name
+            table[(index, self.Columns.Count)] = WaitingAPICall
+            if isinstance(aggregator, MetadataAggregator):
+                table[(index, self.Columns.MetadataKeyCount)] = WaitingAPICall
+            else:
+                table[(index, self.Columns.MetadataKeyCount)] = None
+            if isinstance(aggregator, LabelAggregator):
+                table[(index, self.Columns.LabelCount)] = WaitingAPICall
+            else:
+                table[(index, self.Columns.LabelCount)] = None
+            table[(index, self.Columns.Transformation)] = WaitingAPICall
+        return table
 
-        return styled_callable
+    def call_api(self, row: str, col: str, client: ToolkitClient) -> Callable:
+        aggregator = self.aggregators[row]
+        if col == self.Columns.Count:
+            return aggregator.count
+        elif col == self.Columns.MetadataKeyCount and isinstance(aggregator, MetadataAggregator):
+            return aggregator.metadata_key_count
+        elif col == self.Columns.LabelCount and isinstance(aggregator, LabelAggregator):
+            return aggregator.label_count
+        elif col == self.Columns.Transformation:
+            return aggregator.transformation_count
+        raise ValueError(f"Unknown column: {col} for row: {row}")

cognite_toolkit/_cdf_tk/commands/modules.py

@@ -1,12 +1,17 @@
 from __future__ import annotations
 
 import shutil
+import tempfile
+import zipfile
 from collections import Counter
+from hashlib import sha256
 from importlib import resources
 from pathlib import Path
+from types import TracebackType
 from typing import Any, Literal, Optional
 
 import questionary
+import requests
 import typer
 from packaging.version import Version
 from packaging.version import parse as parse_version
@@ -14,7 +19,7 @@ from rich import print
 from rich.markdown import Markdown
 from rich.padding import Padding
 from rich.panel import Panel
-from rich.progress import track
+from rich.progress import Progress, track
 from rich.rule import Rule
 from rich.table import Table
 from rich.tree import Tree
@@ -47,7 +52,8 @@ from cognite_toolkit._cdf_tk.data_classes import (
     Package,
     Packages,
 )
-from cognite_toolkit._cdf_tk.exceptions import ToolkitRequiredValueError, ToolkitValueError
+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.utils import humanize_collection, read_yaml_file
@@ -85,6 +91,28 @@ class ModulesCommand(ToolkitCommand):
     def __init__(self, print_warning: bool = True, skip_tracking: bool = False, silent: bool = False):
         super().__init__(print_warning, skip_tracking, silent)
         self._builtin_modules_path = Path(resources.files(cognite_toolkit.__name__)) / BUILTIN_MODULES  # type: ignore [arg-type]
+        self._temp_download_dir = Path(tempfile.gettempdir()) / "library_downloads"
+        if not self._temp_download_dir.exists():
+            self._temp_download_dir.mkdir(parents=True, exist_ok=True)
+
+    def __enter__(self) -> ModulesCommand:
+        """
+        Context manager to ensure the temporary download directory is cleaned up after use. It requires the command to be used in a `with` block.
+        """
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,  # Type of the exception
+        exc_value: BaseException | None,  # Exception instance
+        traceback: TracebackType | None,  # Traceback object
+    ) -> None:
+        """
+        Clean up the temporary download directory.
+        """
+
+        if self._temp_download_dir.exists():
+            safe_rmtree(self._temp_download_dir)
 
     @classmethod
     def _create_tree(cls, item: Packages) -> Tree:
@@ -128,6 +156,7 @@ class ModulesCommand(ToolkitCommand):
         downloader_by_repo: dict[str, FileDownloader] = {}
 
         extra_resources: set[Path] = set()
+
         for package_name, package in selected_packages.items():
             print(f"{INDENT}[{'yellow' if mode == 'clean' else 'green'}]Creating {package_name}[/]")
 
@@ -280,7 +309,8 @@ default_organization_dir = "{organization_dir.name}"''',
             organization_dir = Path(organization_dir_raw.strip())
 
         modules_root_dir = organization_dir / MODULES
-        packages = Packages().load(self._builtin_modules_path)
+
+        packages = self._get_available_packages()
 
         if select_all:
             print(Panel("Instantiating all available modules"))
@@ -680,9 +710,102 @@ default_organization_dir = "{organization_dir.name}"''',
             build_env = default.environment.validation_type
 
         existing_module_names = [module.name for module in ModuleResources(organization_dir, build_env).list()]
-        available_packages = Packages().load(self._builtin_modules_path)
-
+        available_packages = self._get_available_packages()
         added_packages = self._select_packages(available_packages, existing_module_names)
 
         download_data = self._get_download_data(added_packages)
         self._create(organization_dir, added_packages, environments, "update", download_data)
+
+    def _get_available_packages(self) -> Packages:
+        """
+        Returns a list of available packages, either from the CDF TOML file or from external libraries if the feature flag is enabled.
+        If the feature flag is not enabled and no libraries are specified, it returns the built-in modules.
+        """
+
+        cdf_toml = CDFToml.load()
+        if Flags.EXTERNAL_LIBRARIES.is_enabled() and cdf_toml.libraries:
+            for library_name, library in cdf_toml.libraries.items():
+                try:
+                    print(f"[green]Adding library {library_name}[/]")
+                    file_path = self._temp_download_dir / f"{library_name}.zip"
+                    self._download(library.url, file_path)
+                    self._validate_checksum(library.checksum, file_path)
+                    self._unpack(file_path)
+                    return Packages().load(file_path.parent)
+                except Exception as e:
+                    if isinstance(e, ToolkitError):
+                        raise e
+                    else:
+                        raise ToolkitError(
+                            f"An unexpected error occurred during downloading {library.url} to {file_path}: {e}"
+                        ) from e
+
+                    raise ToolkitError(f"Failed to add library {library_name}, {e}")
+            # If no libraries are specified or the flag is not enabled, load the built-in modules
+            raise ValueError("No valid libraries found.")
+        else:
+            return Packages.load(self._builtin_modules_path)
+
+    def _download(self, url: str, file_path: Path) -> None:
+        """
+        Downloads a file from a URL to the specified output path.
+        If the file already exists, it skips the download.
+        """
+        try:
+            response = requests.get(url, stream=True)
+            response.raise_for_status()  # Raise an exception for HTTP errors
+
+            total_size = int(response.headers.get("content-length", 0))
+
+            with Progress() as progress:
+                task = progress.add_task("Download", total=total_size)
+                with open(file_path, "wb") as f:
+                    for chunk in response.iter_content(chunk_size=8192):
+                        f.write(chunk)
+                        progress.update(task, advance=len(chunk))
+
+        except requests.exceptions.RequestException as e:
+            raise ToolkitError(f"Error downloading file from {url}: {e}") from e
+
+    def _validate_checksum(self, checksum: str, file_path: Path) -> None:
+        """
+        Compares the checksum of the downloaded file with the expected checksum.
+        """
+
+        if checksum.lower().startswith("sha256:"):
+            checksum = checksum[7:]
+        else:
+            raise ToolkitValueError(f"Unsupported checksum format: {checksum}. Expected 'sha256:' prefix")
+
+        chunk_size: int = 8192
+        sha256_hash = sha256()
+        try:
+            with open(file_path, "rb") as f:
+                # Read the file in chunks to handle large files efficiently
+                for chunk in iter(lambda: f.read(chunk_size), b""):
+                    sha256_hash.update(chunk)
+            calculated = sha256_hash.hexdigest()
+            if calculated != checksum:
+                raise ToolkitError(f"Checksum mismatch. Expected {checksum}, got {calculated}.")
+            else:
+                print("Checksum verified")
+        except Exception as e:
+            raise ToolkitError(f"Failed to calculate checksum for {file_path}: {e}") from e
+
+    def _unpack(self, file_path: Path) -> None:
+        """
+        Unzips the downloaded file to the specified output path.
+        If the file is not a zip file, it raises an error.
+        """
+        total_size = file_path.stat().st_size if file_path.exists() else 0
+
+        try:
+            with Progress() as progress:
+                unzip = progress.add_task("Unzipping", total=total_size)
+                with zipfile.ZipFile(file_path, "r") as zip_ref:
+                    zip_ref.extractall(file_path.parent)
+                    progress.update(unzip, advance=total_size)
+        except zipfile.BadZipFile as e:
+            raise ToolkitError(f"Error unpacking zip file {file_path}: {e}") from e
+        except Exception as e:
+            raise ToolkitError(f"An unexpected error occurred while unpacking {file_path}: {e}") from e

cognite_toolkit/_cdf_tk/data_classes/_packages.py

@@ -66,8 +66,8 @@ class Packages(dict, MutableMapping[str, Package]):
             root_module_dir: The module directories to load the packages from.
         """
 
-        package_definition_path = root_module_dir / "package.toml"
-        if not package_definition_path.exists():
+        package_definition_path = next(root_module_dir.rglob("packages.toml"), None)
+        if not package_definition_path or not package_definition_path.exists():
             raise ToolkitFileNotFoundError(f"Package manifest toml not found at {package_definition_path}")
         package_definitions = toml.loads(package_definition_path.read_text(encoding="utf-8"))["packages"]
 

cognite_toolkit/_cdf_tk/feature_flags.py

@@ -52,6 +52,10 @@ class Flags(Enum):
         "visible": True,
         "description": "Enables the migrate command",
     }
+    EXTERNAL_LIBRARIES: ClassVar[dict[str, Any]] = {  # type: ignore[misc]
+        "visible": True,
+        "description": "Enables the support for external libraries in the config file",
+    }
 
     def is_enabled(self) -> bool:
         return FeatureFlag.is_enabled(self)

cognite_toolkit/_repo_files/GitHub/.github/workflows/deploy.yaml

@@ -12,7 +12,7 @@ jobs:
     environment: dev
     name: Deploy
     container:
-      image: cognite/toolkit:0.5.61
+      image: cognite/toolkit:0.5.62
       env:
         CDF_CLUSTER: ${{ vars.CDF_CLUSTER }}
         CDF_PROJECT: ${{ vars.CDF_PROJECT }}

cognite_toolkit/_repo_files/GitHub/.github/workflows/dry-run.yaml

@@ -10,7 +10,7 @@ jobs:
     environment: dev
     name: Deploy Dry Run
     container:
-      image: cognite/toolkit:0.5.61
+      image: cognite/toolkit:0.5.62
       env:
         CDF_CLUSTER: ${{ vars.CDF_CLUSTER }}
         CDF_PROJECT: ${{ vars.CDF_PROJECT }}

cognite_toolkit/_version.py

@@ -1 +1 @@
-__version__ = "0.5.61"
+__version__ = "0.5.62"

cognite_toolkit/config.dev.yaml

@@ -0,0 +1,7 @@
+environment:
+  name: dev
+  project: consul-dev
+  validation-type: dev
+  selected:
+  - modules/
+variables: {}

{cognite_toolkit-0.5.61.dist-info → cognite_toolkit-0.5.62.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite_toolkit
-Version: 0.5.61
+Version: 0.5.62
 Summary: Official Cognite Data Fusion tool for project templates and configuration deployment
 Project-URL: Homepage, https://docs.cognite.com/cdf/deploy/cdf_toolkit/
 Project-URL: Changelog, https://github.com/cognitedata/toolkit/releases
@@ -52,7 +52,7 @@ It supports three different modes of operation:
 1. As an **interactive command-line tool** used alongside the Cognite Data Fusion web application to retrieve and
    push configuration of the different Cognite Data Fusion services like data sets, data models, transformations,
    and more. This mode also supports configuration of new Cognite Data Fusion projects to quickly get started.
-2. As tool to support the **project life-cyle by scripting and automating** configuration and management of Cognite Data
+2. As tool to support the **project life-cycle by scripting and automating** configuration and management of Cognite Data
    Fusion projects where CDF configurations are kept as yaml-files that can be checked into version
    control. This mode also supports DevOps workflows with development, staging, and production projects.
 3. As a **tool to deploy official Cognite project templates** to your Cognite Data Fusion project. The tool comes

{cognite_toolkit-0.5.61.dist-info → cognite_toolkit-0.5.62.dist-info}/RECORD

@@ -1,10 +1,11 @@
 cognite_toolkit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite_toolkit/_cdf.py,sha256=WWMslI-y2VbIYDMH19wnINebGwlOvAeYr-qkPRC1f68,5834
-cognite_toolkit/_version.py,sha256=2fDfDeXzFJgUAfD2DlfwQKyQL5RXhYlGGenxGvZPy-Q,23
+cognite_toolkit/_version.py,sha256=fTpVYKhDGFXtOWGEUIjMCKrmXus7JYNBnA_m_Tqs5cw,23
+cognite_toolkit/config.dev.yaml,sha256=CIDmi1OGNOJ-70h2BNCozZRmhvU5BfpZoh6Q04b8iMs,109
 cognite_toolkit/_builtin_modules/README.md,sha256=roU3G05E6ogP5yhw4hdIvVDKV831zCh2pzt9BVddtBg,307
 cognite_toolkit/_builtin_modules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cognite_toolkit/_builtin_modules/cdf.toml,sha256=7yvMb-WFWVEQdhExQScNNPHvwkUqPQIqjuLFA8ELywc,273
-cognite_toolkit/_builtin_modules/package.toml,sha256=RdY44Sxvh6sUtAkgp1dHID1mtqkOTzP_rbZL2Q27fYw,1147
+cognite_toolkit/_builtin_modules/cdf.toml,sha256=xO_fCIiJ0cPWc1BOJhKuQcAh1HOKcsYdSUVM-ktp4oE,273
+cognite_toolkit/_builtin_modules/packages.toml,sha256=RdY44Sxvh6sUtAkgp1dHID1mtqkOTzP_rbZL2Q27fYw,1147
 cognite_toolkit/_builtin_modules/bootcamp/README.md,sha256=iTVqoy3PLpC-xPi5pbuMIAEHILBSfWTGLexwa1AltpY,211
 cognite_toolkit/_builtin_modules/bootcamp/default.config.yaml,sha256=MqYTcRiz03bow4LT8E3jumnd_BsqC5SvjgYOVVkHGE0,93
 cognite_toolkit/_builtin_modules/bootcamp/module.toml,sha256=kdB-p9fQopXdkfnRJBsu9DCaKIfiIM4Y7-G8rtBqHWM,97
@@ -479,10 +480,10 @@ cognite_toolkit/_builtin_modules/sourcesystem/cdf_sharepoint/workflows/populatio
 cognite_toolkit/_builtin_modules/sourcesystem/cdf_sharepoint/workflows/trigger.WorkflowTrigger.yaml,sha256=9cfJenjYYm1O2IEY0P1jHohUgif6QHjbjp7UDoM2pCQ,253
 cognite_toolkit/_builtin_modules/sourcesystem/cdf_sharepoint/workflows/v1.WorkflowVersion.yaml,sha256=YgGGZKlEro-ViFtOCU9RYVqnjflJjkCU_nBgmCE0SQk,322
 cognite_toolkit/_cdf_tk/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cognite_toolkit/_cdf_tk/cdf_toml.py,sha256=Eg608y-ZIMcH5MaDmuH_TZba0JhBq0zrEaXOW-3llgA,6620
+cognite_toolkit/_cdf_tk/cdf_toml.py,sha256=e76CvC-KM0tOuDz181-vYciAeAm0h2I0-efkyj8yrtg,7955
 cognite_toolkit/_cdf_tk/constants.py,sha256=c722pX6JYm0LD69T-lF8eT6MarExBKgE2eiiij1H0_U,5750
 cognite_toolkit/_cdf_tk/exceptions.py,sha256=HJZ6kpQ0mJcXsueOyRLCesONiEx_G4QA-EkRuEwXvqo,5118
-cognite_toolkit/_cdf_tk/feature_flags.py,sha256=0WsbBbAW1f08rA0o-UlVL_pHIer-qoBVW5OfTAFSPcA,2549
+cognite_toolkit/_cdf_tk/feature_flags.py,sha256=dUtVp9OLpTXY9pk09_HMARUau81uio4_UDVfLC0JbEY,2743
 cognite_toolkit/_cdf_tk/hints.py,sha256=M832_PM_GcbkmOHtMGtujLW0qHfdmAr0fE66Zqp5YLI,6510
 cognite_toolkit/_cdf_tk/plugins.py,sha256=XpSVJnePU8Yd6r7_xAU7nj3p6dxVo83YE8kfsEbLUZ4,819
 cognite_toolkit/_cdf_tk/tracker.py,sha256=ZafqhkCe-CcWuj9fOa3i558ydFRDBpjnKVb1IvtHuAY,6306
@@ -499,9 +500,9 @@ cognite_toolkit/_cdf_tk/apps/_core_app.py,sha256=-4ABeNtC0cxw7XvCRouPzTvlmqsS0NR
 cognite_toolkit/_cdf_tk/apps/_dump_app.py,sha256=UXmB8oFwVLOmxJBlxxLIBMLPCLwdgyaFfuG6Ex-GZh4,25608
 cognite_toolkit/_cdf_tk/apps/_landing_app.py,sha256=v4t2ryxzFre7y9IkEPIDwmyJDO8VDIIv6hIcft5TjpQ,422
 cognite_toolkit/_cdf_tk/apps/_migrate_app.py,sha256=GRsOlqYAWB0rsZsdTJTGfjPm1OkbUq7xBrM4pzQRKoY,3708
-cognite_toolkit/_cdf_tk/apps/_modules_app.py,sha256=SQxUYa_w_MCP2fKOCzQoJJhxQw5bE4iSgYBZYduOgIQ,6596
+cognite_toolkit/_cdf_tk/apps/_modules_app.py,sha256=tjCP-QbuPYd7iw6dkxnhrrWf514Lr25_oVgSJyJcaL8,6642
 cognite_toolkit/_cdf_tk/apps/_populate_app.py,sha256=PGUqK_USOqdPCDvUJI-4ne9TN6EssC33pUbEeCmiLPg,2805
-cognite_toolkit/_cdf_tk/apps/_profile_app.py,sha256=c50iGKOaIj4_ySEOivmGkObqG13ru_paMPEQ29V_G6U,1293
+cognite_toolkit/_cdf_tk/apps/_profile_app.py,sha256=kceXE60pZz57cRr73DBbOUxShJ3R1tccUQ2L18zPJJw,1317
 cognite_toolkit/_cdf_tk/apps/_purge.py,sha256=RxlUx2vzOuxETBszARUazK8azDpZsf-Y_HHuG9PBVd4,4089
 cognite_toolkit/_cdf_tk/apps/_repo_app.py,sha256=jOf_s7oUWJqnRyz89JFiSzT2l8GlyQ7wqidHUQavGo0,1455
 cognite_toolkit/_cdf_tk/apps/_run.py,sha256=vAuPzYBYfAAFJ_0myn5AxFXG3BJWq8A0HKrhMZ7PaHI,8539
@@ -544,6 +545,7 @@ cognite_toolkit/_cdf_tk/client/data_classes/__init__.py,sha256=47DEQpj8HBSa-_TIm
 cognite_toolkit/_cdf_tk/client/data_classes/agent_tools.py,sha256=n26oUmKvRz4HwCJrVDXKsb_mepBr8VFah39TLWLXXAE,2609
 cognite_toolkit/_cdf_tk/client/data_classes/agents.py,sha256=7kNrUV2d95iyIpDg0ty6SegHLNrecZogLw9ew6rYU30,4866
 cognite_toolkit/_cdf_tk/client/data_classes/apm_config_v1.py,sha256=0bPq7R0qvdf8SMFS06kX7TXHIClDcJNHwdTBweQB-GU,20150
+cognite_toolkit/_cdf_tk/client/data_classes/canvas.py,sha256=yfckaS0JJQNF2PEL1VFLAiqdlLmy-hw1GTfH7UFsb9U,17463
 cognite_toolkit/_cdf_tk/client/data_classes/extendable_cognite_file.py,sha256=jFusjXtg769RMEMqQkqbkwn6nJN6tfjQqidEn3bj_yA,9722
 cognite_toolkit/_cdf_tk/client/data_classes/extended_timeseries.py,sha256=yAvJCHePO_JPhvx5UTQ_qUdCXC5t_aSQY6YxuMnkGIQ,5378
 cognite_toolkit/_cdf_tk/client/data_classes/functions.py,sha256=wF1IUDoDyhASfeeglJ-u52--SlthCp4hXK69TNCh_Nc,414
@@ -559,12 +561,12 @@ cognite_toolkit/_cdf_tk/client/data_classes/streamlit_.py,sha256=OGoMQ_K88F9vSZu
 cognite_toolkit/_cdf_tk/client/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite_toolkit/_cdf_tk/client/utils/_concurrency.py,sha256=z6gqFv-kw80DsEpbaR7sI0-_WvZdOdAsR4VoFvTqvyU,1309
 cognite_toolkit/_cdf_tk/client/utils/_http_client.py,sha256=oXNKrIaizG4WiSAhL_kSCHAuL4aaaEhCU4pOJGxh6Xs,483
-cognite_toolkit/_cdf_tk/commands/__init__.py,sha256=OsydnUZws0IrKoxLfMILfGgQIOH3eyUrY2yHRZMyiOQ,1171
+cognite_toolkit/_cdf_tk/commands/__init__.py,sha256=-9OGZp44naD2ACg4UjBQjc5wqlppll-BgeMd6scu6CQ,1195
 cognite_toolkit/_cdf_tk/commands/_base.py,sha256=3Zc3ffR8mjZ1eV7WrC-Y1sYmyMzdbbJDDmsiKEMEJwo,2480
 cognite_toolkit/_cdf_tk/commands/_changes.py,sha256=3bR_C8p02IW6apexwAAoXuneBM4RcUGdX6Hw_Rtx7Kg,24775
 cognite_toolkit/_cdf_tk/commands/_cli_commands.py,sha256=6nezoDrw3AkF8hANHjUILgTj_nbdzgT0siweaKI35Fk,1047
 cognite_toolkit/_cdf_tk/commands/_populate.py,sha256=59VXEFRc4521xhTmCuQnjgWNYE3z4TUkUq8YbFREDGc,12280
-cognite_toolkit/_cdf_tk/commands/_profile.py,sha256=8oIQkEKfs-k-SyDVoK3tTOAJJEr2_8ON3JNXeHiytH8,4864
+cognite_toolkit/_cdf_tk/commands/_profile.py,sha256=gZ1Ic0LBudnxH7QgQbK_rB9aL991po8VIAdbvUIiNHI,9182
 cognite_toolkit/_cdf_tk/commands/_purge.py,sha256=bE2ytMMlMuZc5xGyktKayvZ25x0kdzoKspjwgfab1Qs,26483
 cognite_toolkit/_cdf_tk/commands/_utils.py,sha256=_IfPBLyfOUc7ubbABiHPpg1MzNGNCxElQ-hmV-vfFDc,1271
 cognite_toolkit/_cdf_tk/commands/_virtual_env.py,sha256=45_aEPZJeyfGmS2Ph_lucaO7ujY7AF5L5N1K3UH3F0o,2216
@@ -577,7 +579,7 @@ cognite_toolkit/_cdf_tk/commands/dump_data.py,sha256=U_e-fEAEphpkJMlDTHQvQ1F0k3q
 cognite_toolkit/_cdf_tk/commands/dump_resource.py,sha256=Dt8jlkmtpRtzPDMEjKdpOJPFr92k7Mw-BWkRsE9CJ8s,20515
 cognite_toolkit/_cdf_tk/commands/featureflag.py,sha256=VPz7FrjVQFqjkz8BYTP2Np3k7BTLFMq_eooNSqmb2ms,1034
 cognite_toolkit/_cdf_tk/commands/init.py,sha256=M9Qs6OVw5mKS4HkWX9DbWwFES1l65J2G90AXqUpyO4c,1744
-cognite_toolkit/_cdf_tk/commands/modules.py,sha256=MrmZzviSrif2jAWtkuNmy8C2jSStqncgBkd7DgYt4oc,30553
+cognite_toolkit/_cdf_tk/commands/modules.py,sha256=lYImbi7eX07j2lbE_8xJ5uix9xa2lL6vBk7IzjGPlhw,35946
 cognite_toolkit/_cdf_tk/commands/pull.py,sha256=t7KQCxpoFDNBWTYPohK7chrRzPyAOGVmfaY7iBLnTqM,39286
 cognite_toolkit/_cdf_tk/commands/repo.py,sha256=vQfLMTzSnI4w6eYCQuMnZ_xXVAVjyLnST4Tmu2zgNfE,3874
 cognite_toolkit/_cdf_tk/commands/run.py,sha256=88AkfCdS4gXHA4I5ZhdU3HWWA5reOTGbfaauM-Yvp8o,37407
@@ -597,7 +599,7 @@ cognite_toolkit/_cdf_tk/data_classes/_deploy_results.py,sha256=BhGvCiuR2LI2DuJae
 cognite_toolkit/_cdf_tk/data_classes/_module_directories.py,sha256=wQ-hM-0onMrFHHFb3c-V9hFuN-FToEFVzCLG7UrzvbQ,11882
 cognite_toolkit/_cdf_tk/data_classes/_module_resources.py,sha256=SsZM3vwCqDbc1ejyFtuX-SOY9K_kLGBfIC7JTlQ7QnM,9160
 cognite_toolkit/_cdf_tk/data_classes/_module_toml.py,sha256=35VFoP_rLMUKhztrePt-uey0SgpVCYgSFuButHkrUq4,2731
-cognite_toolkit/_cdf_tk/data_classes/_packages.py,sha256=_ipFUQgEG19Tp1Rjts9Nw98EQ8b71gs6yFGdzGXtn9w,3689
+cognite_toolkit/_cdf_tk/data_classes/_packages.py,sha256=LX17FD_PKEl-QqALQaF3rbVBlnlB_y_lQaFOy8AoWe8,3738
 cognite_toolkit/_cdf_tk/data_classes/_yaml_comments.py,sha256=zfuDu9aAsb1ExeZBAJIqVaoqIZ050tO_oh3dApzlDwY,4937
 cognite_toolkit/_cdf_tk/loaders/__init__.py,sha256=9giALvw48KIry7WWdCUxA1AvlVFCAR0bOJ5tKAhy-Lk,6241
 cognite_toolkit/_cdf_tk/loaders/_base_loaders.py,sha256=sF9D7ImyHmjbLBGVM66D2xSmOj8XnG3LmDqlQQZRarQ,20502
@@ -695,12 +697,12 @@ cognite_toolkit/_repo_files/.gitignore,sha256=3exydcQPCJTldGFJoZy1RPHc1horbAprAo
 cognite_toolkit/_repo_files/AzureDevOps/.devops/README.md,sha256=OLA0D7yCX2tACpzvkA0IfkgQ4_swSd-OlJ1tYcTBpsA,240
 cognite_toolkit/_repo_files/AzureDevOps/.devops/deploy-pipeline.yml,sha256=KVBxW8urCRDtVlJ6HN-kYmw0NCpW6c4lD-nlxz9tZsQ,692
 cognite_toolkit/_repo_files/AzureDevOps/.devops/dry-run-pipeline.yml,sha256=Cp4KYraeWPjP8SnnEIbJoJnjmrRUwc982DPjOOzy2iM,722
-cognite_toolkit/_repo_files/GitHub/.github/workflows/deploy.yaml,sha256=hmFBWsDfhKKOMtypRrYzsPz6uWZMvXkNwL5NBTqFK0U,667
-cognite_toolkit/_repo_files/GitHub/.github/workflows/dry-run.yaml,sha256=-z_SCqC4MGAMS7x-671A3dDtBVxglLOqSNTdJp9DPQY,2430
+cognite_toolkit/_repo_files/GitHub/.github/workflows/deploy.yaml,sha256=aqocHZ1qaXChsxpsKtaDraQxQStn6YQCVV0UOIyCaP4,667
+cognite_toolkit/_repo_files/GitHub/.github/workflows/dry-run.yaml,sha256=PPtsCAloE4RBUuQTCjl79zVJGYJ_kWdNzm39LGTEHFA,2430
 cognite_toolkit/demo/__init__.py,sha256=-m1JoUiwRhNCL18eJ6t7fZOL7RPfowhCuqhYFtLgrss,72
 cognite_toolkit/demo/_base.py,sha256=63nWYI_MHU5EuPwEX_inEAQxxiD5P6k8IAmlgl4CxpE,8082
-cognite_toolkit-0.5.61.dist-info/METADATA,sha256=ftb50hXIWOi388QW7jdEkVE8eYkAIDfsTFO7j1yQDbM,4409
-cognite_toolkit-0.5.61.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-cognite_toolkit-0.5.61.dist-info/entry_points.txt,sha256=JlR7MH1_UMogC3QOyN4-1l36VbrCX9xUdQoHGkuJ6-4,83
-cognite_toolkit-0.5.61.dist-info/licenses/LICENSE,sha256=CW0DRcx5tL-pCxLEN7ts2S9g2sLRAsWgHVEX4SN9_Mc,752
-cognite_toolkit-0.5.61.dist-info/RECORD,,
+cognite_toolkit-0.5.62.dist-info/METADATA,sha256=fcozRCkXl52ZawHzq8cg2TzsyZllmyoAuH7eA3u5tNM,4410
+cognite_toolkit-0.5.62.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+cognite_toolkit-0.5.62.dist-info/entry_points.txt,sha256=JlR7MH1_UMogC3QOyN4-1l36VbrCX9xUdQoHGkuJ6-4,83
+cognite_toolkit-0.5.62.dist-info/licenses/LICENSE,sha256=CW0DRcx5tL-pCxLEN7ts2S9g2sLRAsWgHVEX4SN9_Mc,752
+cognite_toolkit-0.5.62.dist-info/RECORD,,