cognite-toolkit 0.6.97__tar.gz → 0.6.99__tar.gz

{cognite_toolkit-0.6.97 → cognite_toolkit-0.6.99}/.vscode/launch.json

@@ -35,6 +35,18 @@
       "console": "integratedTerminal",
       "justMyCode": false
     },
+    {
+      "name": "cdf auth init",
+      "type": "debugpy",
+      "request": "launch",
+      "program": "./cdf-tk-dev.py",
+      "args": [
+        "auth",
+        "init"
+      ],
+      "console": "integratedTerminal",
+      "justMyCode": false
+    },
     {
       "name": "cdf run function local",
       "type": "debugpy",
@@ -188,6 +200,7 @@
         "clean",
         "--env", 
         "local",
+        "--verbose"
       ],
       "console": "integratedTerminal",
       "justMyCode": false
@@ -262,7 +275,7 @@
       "type": "debugpy",
       "request": "launch",
       "program": "./cdf-tk-dev.py",
-      "args": ["modules", "init"],
+      "args": ["modules", "init", "."],
       "console": "integratedTerminal",
       "justMyCode": false
     },

{cognite_toolkit-0.6.97 → cognite_toolkit-0.6.99}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite_toolkit
-Version: 0.6.97
+Version: 0.6.99
 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

{cognite_toolkit-0.6.97 → cognite_toolkit-0.6.99}/cdf.toml

@@ -27,11 +27,12 @@ v07 = true
 run = true
 purge = true
 dump = true
+dev = 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.6.97"
+version = "0.6.99"
 
 
 [library.toolkit-data]

{cognite_toolkit-0.6.97 → cognite_toolkit-0.6.99}/cognite_toolkit/_cdf.py

@@ -25,6 +25,7 @@ from cognite_toolkit._cdf_tk.apps import (
     AuthApp,
     CoreApp,
     DataApp,
+    DevApp,
     DumpApp,
     LandingApp,
     MigrateApp,
@@ -89,9 +90,13 @@ user_app = typer.Typer(**default_typer_kws, hidden=True)  # type: ignore [arg-ty
 landing_app = LandingApp(**default_typer_kws)
 
 _app.add_typer(AuthApp(**default_typer_kws), name="auth")
+_app.add_typer(RepoApp(**default_typer_kws), name="repo")
+
+
 if Plugins.run.value.is_enabled():
+    if Flags.v07.is_enabled():
+        print("The run plugin is deprecated and will be replaced by the dev plugin in v0.8.0.")
     _app.add_typer(RunApp(**default_typer_kws), name="run")
-_app.add_typer(RepoApp(**default_typer_kws), name="repo")
 
 if Plugins.dump.value.is_enabled():
     _app.add_typer(DumpApp(**default_typer_kws), name="dump")
@@ -99,6 +104,9 @@ if Plugins.dump.value.is_enabled():
 if Plugins.purge.value.is_enabled() and not Flags.v07.is_enabled():
     _app.add_typer(PurgeApp(**default_typer_kws), name="purge")
 
+if Plugins.dev.value.is_enabled() and Flags.v07.is_enabled():
+    _app.add_typer(DevApp(**default_typer_kws), name="dev")
+
 if Flags.PROFILE.is_enabled():
     _app.add_typer(ProfileApp(**default_typer_kws), name="profile")
 

{cognite_toolkit-0.6.97 → cognite_toolkit-0.6.99}/cognite_toolkit/_cdf_tk/apps/__init__.py

@@ -1,6 +1,7 @@
 from ._auth_app import AuthApp
 from ._core_app import CoreApp
 from ._data_app import DataApp
+from ._dev_app import DevApp
 from ._download_app import DownloadApp
 from ._dump_app import DumpApp
 from ._landing_app import LandingApp
@@ -16,6 +17,7 @@ __all__ = [
     "AuthApp",
     "CoreApp",
     "DataApp",
+    "DevApp",
     "DownloadApp",
     "DumpApp",
     "LandingApp",

{cognite_toolkit-0.6.97 → cognite_toolkit-0.6.99}/cognite_toolkit/_cdf_tk/apps/_core_app.py

@@ -345,7 +345,16 @@ class CoreApp(typer.Typer):
             list[str] | None,
             typer.Option(
                 "--include",
-                help=f"Specify which resource types to deploy, supported types: {AVAILABLE_DATA_TYPES}",
+                help=f"Specify which resource types to clean, supported types: {AVAILABLE_DATA_TYPES}",
+            ),
+        ] = None,
+        module: Annotated[
+            str | None,
+            typer.Option(
+                "--module",
+                "-m",
+                help="Specify name or path of the module to clean",
+                hidden=not Flags.v07.is_enabled(),
             ),
         ] = None,
         verbose: Annotated[
@@ -368,6 +377,8 @@ class CoreApp(typer.Typer):
                 build_env_name,
                 dry_run,
                 include,
+                module,
                 verbose,
+                all_modules=True if not Flags.v07.is_enabled() else False,
             )
         )

cognite_toolkit-0.6.99/cognite_toolkit/_cdf_tk/apps/_dev_app.py

@@ -0,0 +1,20 @@
+from typing import Any
+
+import typer
+from rich import print
+
+from ._run import RunApp
+
+
+class DevApp(typer.Typer):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self.callback(invoke_without_command=True)(self.main)
+        self.add_typer(RunApp(*args, **kwargs), name="run")
+
+    @staticmethod
+    def main(ctx: typer.Context) -> None:
+        """Commands to work with development."""
+        if ctx.invoked_subcommand is None:
+            print("Use [bold yellow]cdf dev --help[/] for more information.")
+        return None

{cognite_toolkit-0.6.97 → cognite_toolkit-0.6.99}/cognite_toolkit/_cdf_tk/client/_toolkit_client.py

@@ -19,6 +19,7 @@ from .api.migration import MigrationAPI
 from .api.project import ProjectAPI
 from .api.robotics import RoboticsAPI
 from .api.search import SearchAPI
+from .api.streams import StreamsAPI
 from .api.token import TokenAPI
 from .api.verify import VerifyAPI
 from .config import ToolkitClientConfig
@@ -47,6 +48,7 @@ class ToolkitClient(CogniteClient):
         self.charts = ChartsAPI(self._config, self._API_VERSION, self)
         self.project = ProjectAPI(config=toolkit_config, cognite_client=self)
         self.infield = InfieldAPI(http_client, self.console)
+        self.streams = StreamsAPI(http_client, self.console)
 
     @property
     def config(self) -> ToolkitClientConfig:

cognite_toolkit-0.6.99/cognite_toolkit/_cdf_tk/client/api/streams.py

@@ -0,0 +1,84 @@
+from collections.abc import Sequence
+
+from rich.console import Console
+
+from cognite_toolkit._cdf_tk.client.data_classes.api_classes import PagedResponse
+from cognite_toolkit._cdf_tk.client.data_classes.streams import StreamRequest, StreamResponse
+from cognite_toolkit._cdf_tk.utils.http_client import HTTPClient, ItemsRequest, ParamRequest
+
+
+class StreamsAPI:
+    ENDPOINT = "/streams"
+
+    def __init__(self, http_client: HTTPClient, console: Console) -> None:
+        self._http_client = http_client
+        self._console = console
+        self._config = http_client.config
+
+    def create(self, items: Sequence[StreamRequest]) -> list[StreamResponse]:
+        """Create one or more streams.
+
+        Args:
+            items: Sequence of StreamRequest items to create.
+
+        Returns:
+            List of created StreamResponse items.
+        """
+        responses = self._http_client.request_with_retries(
+            ItemsRequest(
+                endpoint_url=self._config.create_api_url(self.ENDPOINT),
+                method="POST",
+                items=list(items),
+            )
+        )
+        responses.raise_for_status()
+        return PagedResponse[StreamResponse].model_validate(responses.get_first_body()).items
+
+    def delete(self, external_id: str) -> None:
+        """Delete stream using its external ID.
+
+        Args:
+            external_id: External ID of the stream to delete.
+        """
+        responses = self._http_client.request_with_retries(
+            ParamRequest(
+                endpoint_url=self._config.create_api_url(f"{self.ENDPOINT}/{external_id}"),
+                method="DELETE",
+            )
+        )
+        responses.raise_for_status()
+
+    def list(self) -> list[StreamResponse]:
+        """List streams.
+
+        Returns:
+            StreamResponseList containing the listed streams.
+        """
+        responses = self._http_client.request_with_retries(
+            ParamRequest(
+                endpoint_url=self._config.create_api_url(self.ENDPOINT),
+                method="GET",
+            )
+        )
+        responses.raise_for_status()
+        return PagedResponse[StreamResponse].model_validate(responses.get_first_body()).items
+
+    def retrieve(self, external_id: str, include_statistics: bool = True) -> StreamResponse:
+        """Retrieve a stream by its external ID.
+
+        Args:
+            external_id: External ID of the stream to retrieve.
+            include_statistics: Whether to include usage statistics in the response.
+        Returns:
+            StreamResponse item.
+        """
+        responses = self._http_client.request_with_retries(
+            ParamRequest(
+                endpoint_url=self._config.create_api_url(f"{self.ENDPOINT}/{external_id}"),
+                method="GET",
+                parameters={"includeStatistics": include_statistics},
+            )
+        )
+        responses.raise_for_status()
+        response_body = responses.get_first_body()
+        return StreamResponse.model_validate(response_body)

cognite_toolkit-0.6.99/cognite_toolkit/_cdf_tk/client/data_classes/streams.py

@@ -0,0 +1,114 @@
+import sys
+from collections import UserList
+from typing import Any, Literal
+
+from cognite.client import CogniteClient
+
+from cognite_toolkit._cdf_tk.constants import StreamTemplateName
+from cognite_toolkit._cdf_tk.protocols import ResourceRequestListProtocol, ResourceResponseListProtocol
+
+from .base import BaseModelObject, RequestResource, ResponseResource
+
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
+
+class StreamRequest(RequestResource):
+    """Stream request resource class."""
+
+    external_id: str
+    settings: dict[Literal["template"], dict[Literal["name"], StreamTemplateName]]
+
+    def as_id(self) -> str:
+        return self.external_id
+
+
+class StreamRequestList(UserList[StreamRequest], ResourceRequestListProtocol):
+    """List of Stream request resources."""
+
+    _RESOURCE = StreamRequest
+    items: list[StreamRequest]
+
+    def __init__(self, initlist: list[StreamRequest] | None = None, **_: Any) -> None:
+        super().__init__(initlist or [])
+
+    def dump(self, camel_case: bool = True) -> list[dict[str, Any]]:
+        return [item.dump(camel_case) for item in self.items]
+
+    @classmethod
+    def load(cls, data: list[dict[str, Any]], cognite_client: CogniteClient | None = None) -> "StreamRequestList":
+        items = [StreamRequest.model_validate(item) for item in data]
+        return cls(items)
+
+
+class LifecycleObject(BaseModelObject):
+    """Lifecycle object."""
+
+    hot_phase_duration: str | None = None
+    data_deleted_after: str | None = None
+    retained_after_soft_delete: str
+
+
+class ResourceUsage(BaseModelObject):
+    """Resource quota with provisioned and consumed values."""
+
+    provisioned: int
+    consumed: int | None = None
+
+
+class LimitsObject(BaseModelObject):
+    """Limits object."""
+
+    max_records_total: ResourceUsage
+    max_giga_bytes_total: ResourceUsage
+    max_filtering_interval: str | None = None
+
+
+class StreamSettings(BaseModelObject):
+    """Stream settings object."""
+
+    lifecycle: LifecycleObject
+    limits: LimitsObject
+
+
+class StreamResponse(ResponseResource["StreamRequest"]):
+    """Stream response resource class."""
+
+    external_id: str
+    created_time: int
+    created_from_template: StreamTemplateName | None = None
+    type: Literal["Mutable", "Immutable"] | None = None
+    settings: StreamSettings | None = None
+
+    def as_request_resource(self) -> StreamRequest:
+        template_name = self.created_from_template or "BasicArchive"
+        return StreamRequest(
+            external_id=self.external_id,
+            settings={"template": {"name": template_name}},
+        )
+
+    def as_write(self) -> Self:
+        return self
+
+
+class StreamResponseList(UserList[StreamResponse], ResourceResponseListProtocol):
+    """List of Stream response resources."""
+
+    _RESOURCE = StreamResponse
+    data: list[StreamResponse]
+
+    def __init__(self, initlist: list[StreamResponse] | None = None, **_: Any) -> None:
+        super().__init__(initlist or [])
+
+    def dump(self, camel_case: bool = True) -> list[dict[str, Any]]:
+        return [item.dump(camel_case) for item in self.data]
+
+    @classmethod
+    def load(cls, data: list[dict[str, Any]], cognite_client: CogniteClient | None = None) -> "StreamResponseList":
+        items = [StreamResponse.model_validate(item) for item in data]
+        return cls(items)
+
+    def as_write(self) -> Self:
+        return self

{cognite_toolkit-0.6.97 → cognite_toolkit-0.6.99}/cognite_toolkit/_cdf_tk/client/testing.py

@@ -45,6 +45,7 @@ from .api.robotics.locations import LocationsAPI as RoboticsLocationsAPI
 from .api.robotics.maps import MapsAPI
 from .api.search import SearchAPI
 from .api.search_config import SearchConfigurationsAPI
+from .api.streams import StreamsAPI
 from .api.token import TokenAPI
 from .api.verify import VerifyAPI
 
@@ -117,6 +118,8 @@ class ToolkitClientMock(CogniteClientMock):
         self.time_series.data.synthetic = MagicMock(spec_set=SyntheticDatapointsAPI)
         self.time_series.subscriptions = MagicMock(spec_set=DatapointsSubscriptionAPI)
 
+        self.streams = MagicMock(spec=StreamsAPI)
+
         # This is a helper API, not a real API.
         self.token = TokenAPI(self)
         self.verify = MagicMock(spec_set=VerifyAPI)

{cognite_toolkit-0.6.97 → cognite_toolkit-0.6.99}/cognite_toolkit/_cdf_tk/commands/clean.py

@@ -2,6 +2,7 @@ import traceback
 from graphlib import TopologicalSorter
 from pathlib import Path
 
+import questionary
 from cognite.client.exceptions import CogniteAPIError, CogniteNotFoundError
 from cognite.client.utils.useful_types import SequenceNotStr
 from rich import print
@@ -40,8 +41,10 @@ from cognite_toolkit._cdf_tk.data_classes import (
 from cognite_toolkit._cdf_tk.data_classes._module_directories import ReadModule
 from cognite_toolkit._cdf_tk.exceptions import (
     ToolkitCleanResourceError,
+    ToolkitMissingModuleError,
     ToolkitNotADirectoryError,
     ToolkitValidationError,
+    ToolkitValueError,
 )
 from cognite_toolkit._cdf_tk.tk_warnings import (
     LowSeverityWarning,
@@ -185,6 +188,23 @@ class CleanCommand(ToolkitCommand):
                 self._verbose_print_drop(resource_drop_count, resource_ids, loader, dry_run)
         return nr_of_dropped
 
+    def _interactive_module_selection(self, built_modules: list[ReadModule] | None) -> list[ReadModule] | None:
+        if not built_modules:
+            return None
+        choices = [
+            questionary.Choice(title=built_module.dir.name, value=built_module) for built_module in built_modules
+        ]
+
+        selected_modules = questionary.checkbox(
+            "Which modules would you like to clean?",
+            instruction="Use arrow up/down, press space to select item(s) and enter to save",
+            choices=choices,
+        ).ask()
+
+        if not selected_modules:
+            return None
+        return selected_modules
+
     def _verbose_print_drop(
         self, drop_count: int, resource_ids: SequenceNotStr[T_ID], loader: ResourceContainerCRUD, dry_run: bool
     ) -> None:
@@ -204,6 +224,11 @@ class CleanCommand(ToolkitCommand):
             # Count is not supported
             print(f" {prefix} all {loader.item_name} from {loader.display_name}: {_print_ids_or_length(resource_ids)}.")
 
+    def _select_modules(self, clean_state: BuildEnvironment, module_str: str | None) -> list[ReadModule] | None:
+        if module_str:
+            return [module for module in clean_state.read_modules if module.dir.name == module_str]
+        return self._interactive_module_selection(clean_state.read_modules)
+
     def execute(
         self,
         env_vars: EnvironmentVariables,
@@ -211,7 +236,9 @@ class CleanCommand(ToolkitCommand):
         build_env_name: str | None,
         dry_run: bool,
         include: list[str] | None,
+        module_str: str | None,
         verbose: bool,
+        all_modules: bool = False,
     ) -> None:
         if not build_dir.exists():
             raise ToolkitNotADirectoryError(
@@ -245,9 +272,31 @@ class CleanCommand(ToolkitCommand):
         )
 
         if not build_dir.is_dir():
-            raise ToolkitNotADirectoryError(f"'{build_dir}'. Did you forget to run `cdf-tk build` first?")
+            raise ToolkitNotADirectoryError(f"'{build_dir}'. Did you forget to run `cdf build` first?")
+
+        selected_modules: list[ReadModule]
+        if all_modules:
+            selected_modules = clean_state.read_modules or []
+            if not selected_modules:
+                raise ToolkitValueError("No modules available to clean.")
+        elif module_str:
+            selected_modules = [module for module in clean_state.read_modules if module.dir.name == module_str]
+            if not selected_modules:
+                available_module_names = {module.dir.name for module in clean_state.read_modules}
+                raise ToolkitMissingModuleError(
+                    f"No modules matched the selection: {module_str}. Available modules: {sorted(available_module_names)}"
+                )
+        else:
+            selected_modules = self._interactive_module_selection(clean_state.read_modules) or []
+            if not selected_modules:
+                raise ToolkitValueError(
+                    "No module specified with the --module option and no modules selected interactively."
+                )
 
-        selected_loaders = self.get_selected_loaders(build_dir, clean_state.read_resource_folders, include)
+        selected_resource_folders = {
+            resource_folder for module in selected_modules for resource_folder in module.resource_directories
+        }
+        selected_loaders = self.get_selected_loaders(build_dir, selected_resource_folders, include)
 
         results = DeployResults([], "clean", dry_run=dry_run)
 
@@ -274,7 +323,7 @@ class CleanCommand(ToolkitCommand):
             result = self.clean_resources(
                 loader,
                 env_vars=env_vars,
-                read_modules=clean_state.read_modules,
+                read_modules=selected_modules,
                 drop=True,
                 dry_run=dry_run,
                 drop_data=True,

{cognite_toolkit-0.6.97 → cognite_toolkit-0.6.99}/cognite_toolkit/_cdf_tk/constants.py

@@ -169,3 +169,6 @@ DATA_MANIFEST_STEM = "Manifest"
 # Migration Constants
 MISSING_INSTANCE_SPACE = "<InstanceSpaceMissing>"
 MISSING_EXTERNAL_ID = "INTERNAL_ID_project_{project}_id_{id}"
+
+# Stream Template names
+StreamTemplateName: TypeAlias = Literal["ImmutableTestStream", "BasicArchive", "BasicLiveData"]

{cognite_toolkit-0.6.97 → cognite_toolkit-0.6.99}/cognite_toolkit/_cdf_tk/feature_flags.py

@@ -85,6 +85,10 @@ class Flags(Enum):
         visible=False,
         description="Enables features planned for Cognite Toolkit version 0.7.0",
     )
+    STREAMS = FlagMetadata(
+        visible=True,
+        description="Enables the support for the streams resources",
+    )
 
     def is_enabled(self) -> bool:
         return FeatureFlag.is_enabled(self)

{cognite_toolkit-0.6.97 → cognite_toolkit-0.6.99}/cognite_toolkit/_cdf_tk/plugins.py

@@ -18,6 +18,7 @@ class Plugins(Enum):
     run = Plugin("run", "plugin for Run command to execute Python scripts in CDF")
     dump = Plugin("dump", "plugin for Dump command to retrieve Asset resources from CDF")
     purge = Plugin("purge", "plugin for Purge command to remove datasets and spaces from CDF")
+    dev = Plugin("dev", "plugin for commands to develop modules in CDF")
 
     @staticmethod
     def list() -> dict[str, bool]:

cognite_toolkit-0.6.99/cognite_toolkit/_cdf_tk/resource_classes/streams.py

@@ -0,0 +1,29 @@
+from typing import Literal
+
+from pydantic import Field
+
+from cognite_toolkit._cdf_tk.constants import StreamTemplateName
+
+from .base import BaseModelResource, ToolkitResource
+
+
+class StreamSettings(BaseModelResource):
+    """Stream settings resource class."""
+
+    template: dict[Literal["name"], StreamTemplateName] = Field(
+        description="Reference to a template which should be used to define initial settings for the stream."
+    )
+
+
+class StreamYAML(ToolkitResource):
+    """Stream YAML resource class."""
+
+    external_id: str = Field(
+        description="The external ID of the stream.",
+        min_length=1,
+        max_length=100,
+        pattern="^[a-z]([a-z0-9_-]{0,98}[a-z0-9])?$",
+    )
+    settings: StreamSettings = Field(
+        description="Stream settings which should be applied to a stream.",
+    )

{cognite_toolkit-0.6.97 → cognite_toolkit-0.6.99}/cognite_toolkit/_repo_files/GitHub/.github/workflows/deploy.yaml

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

{cognite_toolkit-0.6.97 → cognite_toolkit-0.6.99}/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.6.97
+      image: cognite/toolkit:0.6.99
       env:
         CDF_CLUSTER: ${{ vars.CDF_CLUSTER }}
         CDF_PROJECT: ${{ vars.CDF_PROJECT }}

{cognite_toolkit-0.6.97 → cognite_toolkit-0.6.99}/cognite_toolkit/_resources/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.6.97"
+version = "0.6.99"
 
 [alpha_flags]
 external-libraries = true

cognite_toolkit-0.6.99/cognite_toolkit/_version.py

@@ -0,0 +1 @@
+__version__ = "0.6.99"

cognite_toolkit-0.6.99/last_changelog_entry.md

@@ -0,0 +1,11 @@
+## cdf 
+
+### Changed
+
+- [alpha] The clean command requires the module name to be passed as a
+parameter. If not, the user will be prompted to select modules
+interactively.
+
+## templates
+
+No changes.

cognite_toolkit-0.6.99/last_git_message.txt

@@ -0,0 +1,31 @@
+[CDF-26131] Clean module limit (#2191)
+
+# Description
+
+From v0.7, the clean command will require a `-m`/`--module` parameter.
+If not provided, the user will be required to select one or more modules
+interactively. This is to reduce the damage potential of an unintended
+`cdf clean` command.
+
+
+## Changelog
+
+- [x] Patch
+- [ ] Skip
+
+## cdf
+
+### Changed
+
+- [alpha] The clean command requires the module name to be passed as a
+parameter. If not, the user will be prompted to select modules
+interactively.
+
+## templates
+
+No changes.
+
+---------
+
+Co-authored-by: Anders Albert <60234212+doctrino@users.noreply.github.com>
+Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>

cognite_toolkit-0.6.99/last_version.txt

@@ -0,0 +1 @@
+0.6.98

{cognite_toolkit-0.6.97 → cognite_toolkit-0.6.99}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cognite_toolkit"
-version = "0.6.97"
+version = "0.6.99"
 description = "Official Cognite Data Fusion tool for project templates and configuration deployment"
 authors = [
     {name ="Cognite AS", email="support@cognite.com"}