cognite-toolkit 0.5.60__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.60"
+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",