cognite-toolkit 0.5.61__tar.gz → 0.5.63__tar.gz

{cognite_toolkit-0.5.61 → cognite_toolkit-0.5.63}/.vscode/launch.json

@@ -63,8 +63,6 @@
         "--override-env",
         "modules",
         "add",
-        "-o", 
-        "my_org"
       ],
       "console": "integratedTerminal",
       "justMyCode": false

{cognite_toolkit-0.5.61 → cognite_toolkit-0.5.63}/LIBRARIES.md

@@ -13,6 +13,7 @@ external-libraries = true
 
 [library.package_1]
 url = "https://raw.githubusercontent.com/cognitedata/toolkit-data/librarian/builtins.zip"
+checksum = "sha256:1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"
 
 ```
 
@@ -25,6 +26,9 @@ The library must be available over https. Authentication is not currently suppor
 To publish a library, create a repository that contains one or more downloadable zip files.
 The zip file must have the structure and content described below.
 
+The checksum is mandatory. It is used to verify the integrity of the downloaded zip file.
+It must be a SHA-256 checksum of the zip file.
+
 ### <package_1>.zip
 
 Zip file content must be structured like this:

{cognite_toolkit-0.5.61 → cognite_toolkit-0.5.63}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite_toolkit
-Version: 0.5.61
+Version: 0.5.63
 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 → cognite_toolkit-0.5.63}/README.md

@@ -18,7 +18,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 → cognite_toolkit-0.5.63}/cdf.toml

@@ -25,4 +25,4 @@ dump = true
 [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.63"

{cognite_toolkit-0.5.61 → cognite_toolkit-0.5.63}/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.63"
 
 
 [plugins]

{cognite_toolkit-0.5.61 → cognite_toolkit-0.5.63}/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-0.5.63/cognite_toolkit/_cdf_tk/apps/_profile_app.py

@@ -0,0 +1,66 @@
+from typing import Annotated, Any
+
+import typer
+from rich import print
+
+from cognite_toolkit._cdf_tk.commands import ProfileAssetCentricCommand, ProfileTransformationCommand
+from cognite_toolkit._cdf_tk.utils.auth import EnvironmentVariables
+
+
+class ProfileApp(typer.Typer):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self.callback(invoke_without_command=True)(self.main)
+        self.command("asset-centric")(self.asset_centric)
+        self.command("transformations")(self.transformations)
+
+    def main(self, ctx: typer.Context) -> None:
+        """Commands profile functionality"""
+        if ctx.invoked_subcommand is None:
+            print("Use [bold yellow]cdf profile --help[/] for more information.")
+
+    @staticmethod
+    def asset_centric(
+        ctx: typer.Context,
+        verbose: bool = False,
+    ) -> None:
+        """This command gives an overview over the metadata and labels for each of the asset-centric resources.
+        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 = ProfileAssetCentricCommand()
+        cmd.run(
+            lambda: cmd.asset_centric(
+                client,
+                verbose,
+            )
+        )
+
+    @staticmethod
+    def transformations(
+        destination: Annotated[
+            str,
+            typer.Option(
+                "--destination",
+                "-d",
+                help="Destination type the transformations data should be written to. This can be 'assets', 'events', 'files',"
+                "'timeseries', or 'sequences'.",
+            ),
+        ],
+        verbose: bool = False,
+    ) -> None:
+        """This command gives an overview over the transformations that write to the given destination.
+        It works by checking all transformations that writes to the given destination, lists the sources of the data,
+        and the target columns.
+        This is intended to show the flow of data from raw into CDF. This can, for example, be used to determine the
+        source of the data in a specific CDF resource.
+        """
+        client = EnvironmentVariables.create_from_environment().get_client()
+        cmd = ProfileTransformationCommand()
+        cmd.run(
+            lambda: cmd.transformation(
+                client,
+                destination,
+                verbose,
+            )
+        )

{cognite_toolkit-0.5.61 → cognite_toolkit-0.5.63}/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-0.5.63/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,
+        )