cognite-toolkit 0.6.109__tar.gz → 0.6.111__tar.gz

{cognite_toolkit-0.6.109 → cognite_toolkit-0.6.111}/.github/pull_request_template.md

@@ -2,17 +2,13 @@
 
 Please describe the change you have made.
 
-## Changelog
+## Bump
 
 - [ ] Patch
 - [ ] Skip
 
-## cdf
+## Changelog
 
 ### Added/Changed/Improved/Removed/Fixed
 
 - My change
-
-## templates
-
-No changes.

{cognite_toolkit-0.6.109 → cognite_toolkit-0.6.111}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite_toolkit
-Version: 0.6.109
+Version: 0.6.111
 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.109 → cognite_toolkit-0.6.111}/cdf.toml

@@ -33,7 +33,7 @@ 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.109"
+version = "0.6.111"
 
 
 [library.toolkit-data]

{cognite_toolkit-0.6.109 → cognite_toolkit-0.6.111}/cognite_toolkit/_cdf_tk/apps/_migrate_app.py

@@ -18,7 +18,7 @@ from cognite_toolkit._cdf_tk.commands._migrate.creators import (
     InstanceSpaceCreator,
     SourceSystemCreator,
 )
-from cognite_toolkit._cdf_tk.commands._migrate.data_mapper import AssetCentricMapper
+from cognite_toolkit._cdf_tk.commands._migrate.data_mapper import AssetCentricMapper, ChartMapper
 from cognite_toolkit._cdf_tk.commands._migrate.migration_io import (
     AnnotationMigrationIO,
     AssetCentricMigrationIO,
@@ -28,12 +28,15 @@ from cognite_toolkit._cdf_tk.commands._migrate.selectors import (
     MigrateDataSetSelector,
     MigrationCSVFileSelector,
 )
+from cognite_toolkit._cdf_tk.storageio import ChartIO
+from cognite_toolkit._cdf_tk.storageio.selectors import ChartExternalIdSelector
 from cognite_toolkit._cdf_tk.utils.auth import EnvironmentVariables
 from cognite_toolkit._cdf_tk.utils.cli_args import parse_view_str
 from cognite_toolkit._cdf_tk.utils.interactive_select import (
     AssetInteractiveSelect,
     DataModelingSelect,
     FileMetadataInteractiveSelect,
+    InteractiveChartSelect,
     ResourceViewMappingInteractiveSelect,
 )
 from cognite_toolkit._cdf_tk.utils.useful_types import AssetCentricKind
@@ -54,6 +57,7 @@ class MigrateApp(typer.Typer):
         self.command("files")(self.files)
         self.command("annotations")(self.annotations)
         self.command("canvas")(self.canvas)
+        self.command("charts")(self.charts)
         # Uncomment when infield v2 config migration is ready
         # self.command("infield-configs")(self.infield_configs)
 
@@ -887,6 +891,68 @@ class MigrateApp(typer.Typer):
             )
         )
 
+    @staticmethod
+    def charts(
+        ctx: typer.Context,
+        external_id: Annotated[
+            list[str] | None,
+            typer.Argument(
+                help="The external ID of the Chart to migrate. If not provided, an interactive selection will be "
+                "performed to select the Charts to migrate."
+            ),
+        ] = None,
+        log_dir: Annotated[
+            Path,
+            typer.Option(
+                "--log-dir",
+                "-l",
+                help="Path to the directory where migration logs will be stored.",
+            ),
+        ] = Path(f"migration_logs_{TODAY}"),
+        dry_run: Annotated[
+            bool,
+            typer.Option(
+                "--dry-run",
+                "-d",
+                help="If set, the migration will not be executed, but only a report of "
+                "what would be done is printed. This is useful for checking that all time series referenced by the Charts "
+                "have been migrated to the new data modeling resources in CDF.",
+            ),
+        ] = False,
+        verbose: Annotated[
+            bool,
+            typer.Option(
+                "--verbose",
+                "-v",
+                help="Turn on to get more verbose output when running the command",
+            ),
+        ] = False,
+    ) -> None:
+        """Migrate Charts from time series references to data modeling in CDF.
+
+        This command expects that the CogniteMigration data model is already deployed, and that the Mapping view
+        is populated with the mapping from time series to the new data modeling resources.
+        """
+        client = EnvironmentVariables.create_from_environment().get_client()
+
+        selected_external_ids: list[str]
+        if external_id:
+            selected_external_ids = external_id
+        else:
+            selected_external_ids = InteractiveChartSelect(client).select_external_ids()
+
+        cmd = MigrationCommand()
+        cmd.run(
+            lambda: cmd.migrate(
+                selected=ChartExternalIdSelector(external_ids=tuple(selected_external_ids)),
+                data=ChartIO(client),
+                mapper=ChartMapper(client),
+                log_dir=log_dir,
+                dry_run=dry_run,
+                verbose=verbose,
+            )
+        )
+
     @staticmethod
     def infield_configs(
         ctx: typer.Context,

{cognite_toolkit-0.6.109 → cognite_toolkit-0.6.111}/cognite_toolkit/_cdf_tk/client/data_classes/charts_data.py

@@ -135,6 +135,26 @@ class ChartCoreTimeseries(BaseChartElement):
     view_reference: ViewId | None = None
     display_mode: str | None = None
 
+    def dump(self, camel_case: bool = True) -> dict[str, Any]:
+        data = super().dump(camel_case=camel_case)
+        if self.node_reference:
+            key = "nodeReference" if camel_case else "node_reference"
+            data[key] = self.node_reference.dump(include_instance_type=False)
+        if self.view_reference:
+            key = "viewReference" if camel_case else "view_reference"
+            data[key] = self.view_reference.dump(include_type=False)
+        return data
+
+    @classmethod
+    def _load(cls, resource: dict[str, Any], cognite_client: CogniteClient | None = None) -> Self:
+        """Load a ChartCoreTimeseries object from a dictionary."""
+        instance = super()._load(resource, cognite_client=cognite_client)
+        if "nodeReference" in resource:
+            instance.node_reference = NodeId.load(resource["nodeReference"])
+        if "viewReference" in resource:
+            instance.view_reference = ViewId.load(resource["viewReference"])
+        return instance
+
 
 @dataclass
 class ChartTimeseries(BaseChartElement):

cognite_toolkit-0.6.111/cognite_toolkit/_cdf_tk/commands/_migrate/data_mapper.py

@@ -0,0 +1,251 @@
+from abc import ABC, abstractmethod
+from collections.abc import Sequence
+from typing import Generic, cast
+from uuid import uuid4
+
+from cognite.client.data_classes._base import (
+    T_CogniteResource,
+)
+from cognite.client.data_classes.data_modeling import (
+    EdgeApply,
+    InstanceApply,
+    NodeApply,
+    NodeId,
+    View,
+    ViewId,
+)
+
+from cognite_toolkit._cdf_tk.client import ToolkitClient
+from cognite_toolkit._cdf_tk.client.data_classes.charts import Chart, ChartWrite
+from cognite_toolkit._cdf_tk.client.data_classes.charts_data import (
+    ChartCoreTimeseries,
+    ChartSource,
+    ChartTimeseries,
+)
+from cognite_toolkit._cdf_tk.client.data_classes.migration import ResourceViewMappingApply
+from cognite_toolkit._cdf_tk.commands._migrate.conversion import DirectRelationCache, asset_centric_to_dm
+from cognite_toolkit._cdf_tk.commands._migrate.data_classes import AssetCentricMapping
+from cognite_toolkit._cdf_tk.commands._migrate.default_mappings import create_default_mappings
+from cognite_toolkit._cdf_tk.commands._migrate.issues import ChartMigrationIssue, ConversionIssue, MigrationIssue
+from cognite_toolkit._cdf_tk.commands._migrate.selectors import AssetCentricMigrationSelector
+from cognite_toolkit._cdf_tk.constants import MISSING_INSTANCE_SPACE
+from cognite_toolkit._cdf_tk.exceptions import ToolkitValueError
+from cognite_toolkit._cdf_tk.storageio._base import T_Selector, T_WriteCogniteResource
+from cognite_toolkit._cdf_tk.storageio.selectors import ChartSelector
+from cognite_toolkit._cdf_tk.utils import humanize_collection
+from cognite_toolkit._cdf_tk.utils.useful_types import (
+    T_AssetCentricResourceExtended,
+)
+
+
+class DataMapper(Generic[T_Selector, T_CogniteResource, T_WriteCogniteResource], ABC):
+    def prepare(self, source_selector: T_Selector) -> None:
+        """Prepare the data mapper with the given source selector.
+
+        Args:
+            source_selector: The selector for the source data.
+
+        """
+        # Override in subclass if needed.
+        pass
+
+    @abstractmethod
+    def map(
+        self, source: Sequence[T_CogniteResource]
+    ) -> Sequence[tuple[T_WriteCogniteResource | None, MigrationIssue]]:
+        """Map a chunk of source data to the target format.
+
+        Args:
+            source: The source data chunk to be mapped.
+
+        Returns:
+            A tuple containing the mapped data and a list of any issues encountered during mapping.
+
+        """
+        raise NotImplementedError("Subclasses must implement this method.")
+
+
+class AssetCentricMapper(
+    DataMapper[AssetCentricMigrationSelector, AssetCentricMapping[T_AssetCentricResourceExtended], InstanceApply]
+):
+    def __init__(self, client: ToolkitClient) -> None:
+        self.client = client
+        self._ingestion_view_by_id: dict[ViewId, View] = {}
+        self._view_mapping_by_id: dict[str, ResourceViewMappingApply] = {}
+        self._direct_relation_cache = DirectRelationCache(client)
+
+    def prepare(self, source_selector: AssetCentricMigrationSelector) -> None:
+        ingestion_view_ids = source_selector.get_ingestion_mappings()
+        ingestion_views = self.client.migration.resource_view_mapping.retrieve(ingestion_view_ids)
+        defaults = {mapping.external_id: mapping for mapping in create_default_mappings()}
+        # Custom mappings from CDF override the default mappings
+        self._view_mapping_by_id = defaults | {view.external_id: view.as_write() for view in ingestion_views}
+        missing_mappings = set(ingestion_view_ids) - set(self._view_mapping_by_id.keys())
+        if missing_mappings:
+            raise ToolkitValueError(
+                f"The following ingestion views were not found: {humanize_collection(missing_mappings)}"
+            )
+
+        view_ids = list({mapping.view_id for mapping in self._view_mapping_by_id.values()})
+        views = self.client.data_modeling.views.retrieve(view_ids)
+        self._ingestion_view_by_id = {view.as_id(): view for view in views}
+        missing_views = set(view_ids) - set(self._ingestion_view_by_id.keys())
+        if missing_views:
+            raise ToolkitValueError(
+                f"The following ingestion views were not found in Data Modeling: {humanize_collection(missing_views)}"
+            )
+
+    def map(
+        self, source: Sequence[AssetCentricMapping[T_AssetCentricResourceExtended]]
+    ) -> Sequence[tuple[InstanceApply | None, ConversionIssue]]:
+        """Map a chunk of asset-centric data to InstanceApplyList format."""
+        # We update the direct relation cache in bulk for all resources in the chunk.
+        self._direct_relation_cache.update(item.resource for item in source)
+        output: list[tuple[InstanceApply | None, ConversionIssue]] = []
+        for item in source:
+            instance, conversion_issue = self._map_single_item(item)
+            output.append((instance, conversion_issue))
+        return output
+
+    def _map_single_item(
+        self, item: AssetCentricMapping[T_AssetCentricResourceExtended]
+    ) -> tuple[NodeApply | EdgeApply | None, ConversionIssue]:
+        mapping = item.mapping
+        ingestion_view = mapping.get_ingestion_view()
+        try:
+            view_source = self._view_mapping_by_id[ingestion_view]
+            view_properties = self._ingestion_view_by_id[view_source.view_id].properties
+        except KeyError as e:
+            raise RuntimeError(
+                f"Failed to lookup mapping or view for ingestion view '{ingestion_view}'. Did you forget to call .prepare()?"
+            ) from e
+        instance, conversion_issue = asset_centric_to_dm(
+            item.resource,
+            instance_id=mapping.instance_id,
+            view_source=view_source,
+            view_properties=view_properties,
+            direct_relation_cache=self._direct_relation_cache,
+        )
+        if mapping.instance_id.space == MISSING_INSTANCE_SPACE:
+            conversion_issue.missing_instance_space = f"Missing instance space for dataset ID {mapping.data_set_id!r}"
+        return instance, conversion_issue
+
+
+class ChartMapper(DataMapper[ChartSelector, Chart, ChartWrite]):
+    def __init__(self, client: ToolkitClient) -> None:
+        self.client = client
+
+    def map(self, source: Sequence[Chart]) -> Sequence[tuple[ChartWrite | None, MigrationIssue]]:
+        self._populate_cache(source)
+        output: list[tuple[ChartWrite | None, MigrationIssue]] = []
+        for item in source:
+            mapped_item, issue = self._map_single_item(item)
+            output.append((mapped_item, issue))
+        return output
+
+    def _populate_cache(self, source: Sequence[Chart]) -> None:
+        """Populate the internal cache with timeseries from the source charts.
+
+        Note that the consumption views are also cached as part of the timeseries lookup.
+        """
+        timeseries_ids: set[int] = set()
+        timeseries_external_ids: set[str] = set()
+        for chart in source:
+            for item in chart.data.time_series_collection or []:
+                if item.ts_id:
+                    timeseries_ids.add(item.ts_id)
+                if item.ts_external_id:
+                    timeseries_external_ids.add(item.ts_external_id)
+        if timeseries_ids:
+            self.client.migration.lookup.time_series(list(timeseries_ids))
+        if timeseries_external_ids:
+            self.client.migration.lookup.time_series(external_id=list(timeseries_external_ids))
+
+    def _map_single_item(self, item: Chart) -> tuple[ChartWrite | None, ChartMigrationIssue]:
+        issue = ChartMigrationIssue(chart_external_id=item.external_id)
+        time_series_collection = item.data.time_series_collection or []
+        timeseries_core_collection = self._create_timeseries_core_collection(time_series_collection, issue)
+        if issue.has_issues:
+            return None, issue
+
+        updated_source_collection = self._update_source_collection(
+            item.data.source_collection or [], time_series_collection, timeseries_core_collection
+        )
+
+        mapped_chart = item.as_write()
+        mapped_chart.data.core_timeseries_collection = timeseries_core_collection
+        mapped_chart.data.time_series_collection = None
+        mapped_chart.data.source_collection = updated_source_collection
+        return mapped_chart, issue
+
+    def _create_timeseries_core_collection(
+        self, time_series_collection: list[ChartTimeseries], issue: ChartMigrationIssue
+    ) -> list[ChartCoreTimeseries]:
+        timeseries_core_collection: list[ChartCoreTimeseries] = []
+        for ts_item in time_series_collection or []:
+            node_id, consumer_view_id = self._get_node_id_consumer_view_id(ts_item)
+
+            if node_id is None:
+                if ts_item.ts_id is not None:
+                    issue.missing_timeseries_ids.append(ts_item.ts_id)
+                elif ts_item.ts_external_id is not None:
+                    issue.missing_timeseries_external_ids.append(ts_item.ts_external_id)
+                else:
+                    issue.missing_timeseries_identifier.append(ts_item.id or "unknown")
+                continue
+
+            core_timeseries = self._create_new_timeseries_core(ts_item, node_id, consumer_view_id)
+            timeseries_core_collection.append(core_timeseries)
+        return timeseries_core_collection
+
+    def _create_new_timeseries_core(
+        self, ts_item: ChartTimeseries, node_id: NodeId, consumer_view_id: ViewId | None
+    ) -> ChartCoreTimeseries:
+        dumped = ts_item.dump(camel_case=True)
+        for asset_centric_key in ["tsId", "tsExternalId", "originalUnit"]:
+            dumped.pop(asset_centric_key, None)
+
+        dumped["nodeReference"] = node_id
+        dumped["viewReference"] = consumer_view_id
+        new_uuid = str(uuid4())
+        dumped["id"] = new_uuid
+        dumped["type"] = "coreTimeseries"
+        core_timeseries = ChartCoreTimeseries._load(dumped)
+        return core_timeseries
+
+    def _get_node_id_consumer_view_id(self, ts_item: ChartTimeseries) -> tuple[NodeId | None, ViewId | None]:
+        """Look up the node ID and consumer view ID for a given timeseries item.
+
+        Prioritizes lookup by internal ID, then by external ID.
+
+        Args:
+            ts_item: The ChartTimeseries item to look up.
+
+        Returns:
+            A tuple containing the consumer view ID and node ID, or None if not found.
+        """
+        node_id: NodeId | None = None
+        consumer_view_id: ViewId | None = None
+        for id_name, id_value in [("id", ts_item.ts_id), ("external_id", ts_item.ts_external_id)]:
+            if id_value is None:
+                continue
+            arg = {id_name: id_value}
+            node_id = self.client.migration.lookup.time_series(**arg)  # type: ignore[arg-type]
+            consumer_view_id = self.client.migration.lookup.time_series.consumer_view(**arg)  # type: ignore[arg-type]
+            if node_id is not None:
+                break
+        return node_id, consumer_view_id
+
+    def _update_source_collection(
+        self,
+        source_collection: list[ChartSource],
+        time_series_collection: list[ChartTimeseries],
+        timeseries_core_collection: list[ChartCoreTimeseries],
+    ) -> list[ChartSource]:
+        remove_ids = {ts_item.id for ts_item in time_series_collection if ts_item.id is not None}
+        updated_source_collection = [ts_item for ts_item in source_collection if ts_item.id not in remove_ids]
+        for core_ts_item in timeseries_core_collection:
+            # We cast there two as we set them in the _create_timeseries_core_collection method
+            new_source_item = ChartSource(id=cast(str, core_ts_item.id), type=cast(str, core_ts_item.type))
+            updated_source_collection.append(new_source_item)
+        return updated_source_collection

{cognite_toolkit-0.6.109 → cognite_toolkit-0.6.111}/cognite_toolkit/_cdf_tk/commands/_migrate/issues.py

@@ -30,6 +30,27 @@ class MigrationIssue(MigrationObject):
         return True
 
 
+class ChartMigrationIssue(MigrationIssue):
+    """Represents a chart migration issue encountered during migration.
+
+    Attributes:
+        chart_external_id (str): The external ID of the chart that could not be migrated.
+    """
+
+    type: ClassVar[str] = "chartMigration"
+    chart_external_id: str
+    missing_timeseries_ids: list[int] = Field(default_factory=list)
+    missing_timeseries_external_ids: list[str] = Field(default_factory=list)
+    missing_timeseries_identifier: list[str] = Field(default_factory=list)
+
+    @property
+    def has_issues(self) -> bool:
+        """Check if there are any issues recorded in this ChartMigrationIssue."""
+        return bool(
+            self.missing_timeseries_ids or self.missing_timeseries_external_ids or self.missing_timeseries_identifier
+        )
+
+
 class ReadIssue(MigrationIssue):
     """Represents a read issue encountered during migration."""
 

{cognite_toolkit-0.6.109 → cognite_toolkit-0.6.111}/cognite_toolkit/_repo_files/GitHub/.github/workflows/deploy.yaml

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

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

{cognite_toolkit-0.6.109 → cognite_toolkit-0.6.111}/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.109"
+version = "0.6.111"
 
 [alpha_flags]
 external-libraries = true

cognite_toolkit-0.6.111/cognite_toolkit/_version.py

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

{cognite_toolkit-0.6.109 → cognite_toolkit-0.6.111}/dev.py

@@ -18,8 +18,6 @@ from rich import print
 
 REPO_ROOT = Path(__file__).parent
 CHANGELOG = REPO_ROOT / "CHANGELOG.cdf-tk.md"
-TEMPLATE_CHANGELOG = REPO_ROOT / "CHANGELOG.templates.md"
-TBD_HEADING = "## TBD"
 IMAGE_NAME = "cognite/toolkit"
 CDF_TOML = REPO_ROOT / "cdf.toml"
 
@@ -121,23 +119,14 @@ def create_changelog_entry() -> None:
     if not changelog_items[1:]:
         print(f"Trying to {version_bump} bump but no changes found in the changelog.")
         raise SystemExit(1)
-    if not _is_header(changelog_items[1], level=2, text="cdf"):
-        print("The first header in the changelog must be '## cdf'.")
+    if not _is_header(changelog_items[1], level=2, text="Changelog"):
+        print("The first header in the changelog must be '## Changelog'.")
         raise SystemExit(1)
-    cdf_entries = list(itertools.takewhile(lambda x: not _is_header(x, level=2), changelog_items[2:]))
-    _validate_entries(cdf_entries, "cdf")
-    no = next((no for no, item in enumerate(changelog_items) if _is_header(item, level=2, text="templates")), None)
-    if no is None:
-        print("No '## templates' section found in the changelog.")
-        raise SystemExit(1)
-    if not changelog_items[no + 1 :]:
-        print("No template entries found in the changelog.")
-        raise SystemExit(1)
-    template_entries = list(changelog_items[no + 1 :])
-    _validate_entries(template_entries, "templates")
+    change_entries = list(itertools.takewhile(lambda x: not _is_header(x, level=2), changelog_items[2:]))
+    _validate_entries(change_entries, "Changelog")
 
-    changelog_entry = changelog_text.split("## cdf")[1]
-    CHANGELOG_ENTRY_FILE.write_text(f"## cdf {changelog_entry}", encoding="utf-8")
+    changelog_entry = changelog_text.split("## Changelog")[1]
+    CHANGELOG_ENTRY_FILE.write_text(f"## Changelog {changelog_entry}", encoding="utf-8")
     print(f"Changelog entry written to {CHANGELOG_ENTRY_FILE}.")
 
 
@@ -146,11 +135,11 @@ def _read_last_commit_message() -> tuple[list[marko.element.Element], str]:
     if "This PR was generated by [Mend Renovate]" in last_git_message:
         print("Skipping Renovate PR.")
         changelog_text = "- [ ] Patch\n- [ ] Minor\n- [x] Skip\n"
-    elif "## Changelog" not in last_git_message:
-        print("No changelog entry found in the last commit message.")
+    elif "## Bump" not in last_git_message:
+        print("No bump entry found in the last commit message.")
         raise SystemExit(1)
     else:
-        changelog_text = last_git_message.split("## Changelog")[1].strip()
+        changelog_text = last_git_message.split("## Bump")[1].strip()
 
     if "-----" in changelog_text:
         # Co-authors section

cognite_toolkit-0.6.111/last_changelog_entry.md

@@ -0,0 +1,5 @@
+## Changelog 
+
+### Added
+
+- [alpha] Support for migrating charts, `cdf migrate charts`.

cognite_toolkit-0.6.111/last_git_message.txt

@@ -0,0 +1,18 @@
+[CDF-24983] 📈Activate charts migration (#2222)
+
+# Description
+
+<img width="1535" height="362" alt="image"
+src="https://github.com/user-attachments/assets/1f445187-3f91-453d-9c39-3282539cac6c"
+/>
+
+## Bump
+
+- [x] Patch
+- [ ] Skip
+
+## Changelog
+
+### Added
+
+- [alpha] Support for migrating charts, `cdf migrate charts`.

cognite_toolkit-0.6.111/last_version.txt

@@ -0,0 +1 @@
+0.6.110

{cognite_toolkit-0.6.109 → cognite_toolkit-0.6.111}/pyproject.toml

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