cognite-toolkit 0.7.30__py3-none-any.whl → 0.7.51__py3-none-any.whl

cognite_toolkit/_cdf_tk/commands/_migrate/issues.py

@@ -1,34 +1,45 @@
-import json
-from typing import Any, ClassVar
+from typing import Any, Literal
 
-from cognite.client.data_classes.data_modeling import NodeId
-from cognite.client.utils._identifier import InstanceId
-from cognite.client.utils._text import to_camel_case
 from pydantic import BaseModel, Field, field_serializer
+from pydantic.alias_generators import to_camel
 
-from cognite_toolkit._cdf_tk.client.data_classes.migration import AssetCentricId
-from cognite_toolkit._cdf_tk.utils.useful_types import JsonVal
+from cognite_toolkit._cdf_tk.client.resource_classes.data_modeling import NodeReference
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.migration import AssetCentricId
+from cognite_toolkit._cdf_tk.storageio.logger import LogEntry
 
 
-class MigrationObject(BaseModel, alias_generator=to_camel_case, extra="ignore", populate_by_name=True): ...
-
-
-class MigrationIssue(MigrationObject):
+class MigrationIssue(LogEntry):
     """Represents an issue encountered during migration."""
 
-    type: ClassVar[str]
-
-    def dump(self) -> dict[str, JsonVal]:
-        # Dump json to ensure it is serializable
-        dumped = json.loads(self.model_dump_json(by_alias=True))
-        dumped["type"] = self.type
-        return dumped
+    type: str
 
     @property
     def has_issues(self) -> bool:
         """Check if there are any issues recorded in this MigrationIssue."""
         return True
 
+    def dump(self) -> dict[str, Any]:
+        """Serialize the MigrationIssue to a dictionary."""
+        return self.model_dump(by_alias=True)
+
+
+class ThreeDModelMigrationIssue(MigrationIssue):
+    """Represents a 3D model migration issue encountered during migration.
+
+    Attributes:
+        model_external_id (str): The external ID of the 3D model that could not be migrated.
+    """
+
+    type: Literal["threeDModelMigration"] = "threeDModelMigration"
+    model_name: str
+    model_id: int
+    error_message: list[str] = Field(default_factory=list)
+
+    @property
+    def has_issues(self) -> bool:
+        """Check if there are any issues recorded in this ThreeDModelMigrationIssue."""
+        return bool(self.error_message)
+
 
 class ChartMigrationIssue(MigrationIssue):
     """Represents a chart migration issue encountered during migration.
@@ -37,7 +48,7 @@ class ChartMigrationIssue(MigrationIssue):
         chart_external_id (str): The external ID of the chart that could not be migrated.
     """
 
-    type: ClassVar[str] = "chartMigration"
+    type: Literal["chartMigration"] = "chartMigration"
     chart_external_id: str
     missing_timeseries_ids: list[int] = Field(default_factory=list)
     missing_timeseries_external_ids: list[str] = Field(default_factory=list)
@@ -52,7 +63,7 @@ class ChartMigrationIssue(MigrationIssue):
 
 
 class CanvasMigrationIssue(MigrationIssue):
-    type: ClassVar[str] = "canvasMigration"
+    type: Literal["canvasMigration"] = "canvasMigration"
     canvas_external_id: str
     canvas_name: str
     missing_reference_ids: list[AssetCentricId] = Field(default_factory=list)
@@ -66,7 +77,7 @@ class CanvasMigrationIssue(MigrationIssue):
 class ReadIssue(MigrationIssue):
     """Represents a read issue encountered during migration."""
 
-    type: ClassVar[str] = "read"
+    ...
 
 
 class ReadFileIssue(ReadIssue):
@@ -77,7 +88,7 @@ class ReadFileIssue(ReadIssue):
         error (str | None): An optional error message providing additional details about the read issue.
     """
 
-    type: ClassVar[str] = "fileRead"
+    type: Literal["fileRead"] = "fileRead"
 
     row_no: int
     error: str | None = None
@@ -91,7 +102,7 @@ class ReadAPIIssue(ReadIssue):
         error (str | None): An optional error message providing additional details about the read issue.
     """
 
-    type: ClassVar[str] = "apiRead"
+    type: Literal["apiRead"] = "apiRead"
     asset_centric_id: AssetCentricId
     error: str | None = None
 
@@ -103,7 +114,7 @@ class ReadAPIIssue(ReadIssue):
         }
 
 
-class FailedConversion(MigrationObject):
+class FailedConversion(BaseModel, alias_generator=to_camel, extra="ignore", populate_by_name=True):
     """Represents a property that failed to convert during migration.
 
     Attributes:
@@ -117,7 +128,7 @@ class FailedConversion(MigrationObject):
     error: str
 
 
-class InvalidPropertyDataType(MigrationObject):
+class InvalidPropertyDataType(BaseModel, alias_generator=to_camel, extra="ignore", populate_by_name=True):
     """Represents a property with an invalid type during migration.
 
     Attributes:
@@ -142,9 +153,9 @@ class ConversionIssue(MigrationIssue):
         failed_conversions (list[FailedConversion]): List of properties that failed to convert with reasons.
     """
 
-    type: ClassVar[str] = "conversion"
+    type: Literal["conversion"] = "conversion"
     asset_centric_id: AssetCentricId
-    instance_id: InstanceId
+    instance_id: NodeReference
     missing_asset_centric_properties: list[str] = Field(default_factory=list)
     missing_instance_properties: list[str] = Field(default_factory=list)
     invalid_instance_property_types: list[InvalidPropertyDataType] = Field(default_factory=list)
@@ -163,10 +174,6 @@ class ConversionIssue(MigrationIssue):
             or self.missing_instance_space
         )
 
-    @field_serializer("instance_id")
-    def serialize_instance_id(self, instance_id: NodeId) -> dict[str, str]:
-        return instance_id.dump(include_instance_type=True)
-
     @field_serializer("asset_centric_id")
     def serialize_asset_centric_id(self, asset_centric_id: AssetCentricId) -> dict[str, Any]:
         return {
@@ -179,16 +186,10 @@ class WriteIssue(MigrationIssue):
     """Represents a write issue encountered during migration.
 
     Attributes:
-        instance_id (InstanceId): The InstanceId of the data model instance that could not be written.
         status_code (int): The HTTP status code returned during the write operation.
         message (str | None): An optional message providing additional details about the write issue.
     """
 
-    type: ClassVar[str] = "write"
-    instance_id: InstanceId
+    type: Literal["write"] = "write"
     status_code: int
     message: str | None = None
-
-    @field_serializer("instance_id")
-    def serialize_instance_id(self, instance_id: NodeId) -> dict[str, str]:
-        return instance_id.dump(include_instance_type=True)

cognite_toolkit/_cdf_tk/commands/_migrate/migration_io.py

@@ -1,29 +1,49 @@
 from collections.abc import Iterable, Iterator, Mapping, Sequence
-from typing import ClassVar, cast
+from typing import ClassVar, Literal, cast
 
 from cognite.client.data_classes import Annotation
 from cognite.client.data_classes.data_modeling import EdgeId, InstanceApply, NodeId
 
 from cognite_toolkit._cdf_tk.client import ToolkitClient
-from cognite_toolkit._cdf_tk.client.data_classes.pending_instances_ids import PendingInstanceId
+from cognite_toolkit._cdf_tk.client.http_client import (
+    FailedResponse,
+    HTTPClient,
+    HTTPMessage,
+    ItemsRequest,
+    RequestMessage2,
+    SuccessResponseItems,
+    ToolkitAPIError,
+)
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.pending_instances_ids import PendingInstanceId
+from cognite_toolkit._cdf_tk.client.resource_classes.three_d import (
+    AssetMappingClassicResponse,
+    AssetMappingDMRequest,
+    ThreeDModelResponse,
+)
+from cognite_toolkit._cdf_tk.commands._migrate.data_classes import ThreeDMigrationRequest
 from cognite_toolkit._cdf_tk.constants import MISSING_EXTERNAL_ID, MISSING_INSTANCE_SPACE
 from cognite_toolkit._cdf_tk.exceptions import ToolkitNotImplementedError, ToolkitValueError
 from cognite_toolkit._cdf_tk.storageio import (
     AnnotationIO,
     HierarchyIO,
     InstanceIO,
+    T_Selector,
     UploadableStorageIO,
 )
 from cognite_toolkit._cdf_tk.storageio._base import Page, UploadItem
+from cognite_toolkit._cdf_tk.storageio.selectors import (
+    ThreeDModelFilteredSelector,
+    ThreeDModelIdSelector,
+    ThreeDSelector,
+)
 from cognite_toolkit._cdf_tk.tk_warnings import MediumSeverityWarning
 from cognite_toolkit._cdf_tk.utils.collection import chunker_sequence
-from cognite_toolkit._cdf_tk.utils.http_client import HTTPClient, HTTPMessage, ItemsRequest, SuccessResponseItems
 from cognite_toolkit._cdf_tk.utils.useful_types import (
     AssetCentricKindExtended,
     AssetCentricType,
     JsonVal,
-    T_AssetCentricResource,
 )
+from cognite_toolkit._cdf_tk.utils.useful_types2 import T_AssetCentricResource
 
 from .data_classes import (
     AnnotationMapping,
@@ -58,7 +78,7 @@ class AssetCentricMigrationIO(
         self.skip_linking = skip_linking
 
     def as_id(self, item: AssetCentricMapping) -> str:
-        return f"{item.mapping.resource_type}_{item.mapping.id}"
+        return str(item.mapping.as_asset_centric_id())
 
     def stream_data(self, selector: AssetCentricMigrationSelector, limit: int | None = None) -> Iterator[Page]:
         if isinstance(selector, MigrationCSVFileSelector):
@@ -161,7 +181,7 @@ class AssetCentricMigrationIO(
 
         pending_instance_id_endpoint = self.PENDING_INSTANCE_ID_ENDPOINT_BY_KIND[selector.kind]
         results: list[HTTPMessage] = []
-        to_upload = self.link_asset_centric(data_chunk, http_client, results, pending_instance_id_endpoint)
+        to_upload = self.link_asset_centric(data_chunk, http_client, pending_instance_id_endpoint)
         if to_upload:
             results.extend(list(super().upload_items(to_upload, http_client, None)))
         return results
@@ -171,7 +191,6 @@ class AssetCentricMigrationIO(
         cls,
         data_chunk: Sequence[UploadItem[InstanceApply]],
         http_client: HTTPClient,
-        results: list[HTTPMessage],
         pending_instance_id_endpoint: str,
     ) -> Sequence[UploadItem[InstanceApply]]:
         """Links asset-centric resources to their (uncreated) instances using the pending-instance-ids endpoint."""
@@ -192,7 +211,6 @@ class AssetCentricMigrationIO(
             for res in batch_results:
                 if isinstance(res, SuccessResponseItems):
                     successful_linked.update(res.ids)
-            results.extend(batch_results)
         to_upload = [item for item in data_chunk if item.source_id in successful_linked]
         return to_upload
 
@@ -348,3 +366,204 @@ class AnnotationMigrationIO(
         selector: AssetCentricMigrationSelector | None = None,
     ) -> list[dict[str, JsonVal]]:
         raise NotImplementedError("Serializing Annotation Migrations to JSON is not supported.")
+
+
+class ThreeDMigrationIO(UploadableStorageIO[ThreeDSelector, ThreeDModelResponse, ThreeDMigrationRequest]):
+    """IO class for downloading and migrating 3D models.
+
+    Args:
+        client: The ToolkitClient to use for CDF interactions.
+        data_model_type: The type of 3D data model to download. Either "classic" or "DM".
+
+    """
+
+    KIND = "3DMigration"
+    SUPPORTED_DOWNLOAD_FORMATS = frozenset({".ndjson"})
+    SUPPORTED_COMPRESSIONS = frozenset({".gz"})
+    SUPPORTED_READ_FORMATS = frozenset({".ndjson"})
+    DOWNLOAD_LIMIT = 1000
+    CHUNK_SIZE = 1
+    UPLOAD_ENDPOINT = "/3d/migrate/models"
+    REVISION_ENDPOINT = "/3d/migrate/revisions"
+
+    def __init__(self, client: ToolkitClient, data_model_type: Literal["classic", "data modeling"] = "classic") -> None:
+        super().__init__(client)
+        self.data_model_type = data_model_type
+
+    def as_id(self, item: ThreeDModelResponse) -> str:
+        return item.name
+
+    def _is_selected(self, item: ThreeDModelResponse, included_models: set[int] | None) -> bool:
+        return self._is_correct_type(item) and (included_models is None or item.id in included_models)
+
+    def _is_correct_type(self, item: ThreeDModelResponse) -> bool:
+        if self.data_model_type == "classic":
+            return item.space is None
+        else:
+            return item.space is not None
+
+    def stream_data(self, selector: ThreeDSelector, limit: int | None = None) -> Iterable[Page[ThreeDModelResponse]]:
+        published: bool | None = None
+        if isinstance(selector, ThreeDModelFilteredSelector):
+            published = selector.published
+        included_models: set[int] | None = None
+        if isinstance(selector, ThreeDModelIdSelector):
+            included_models = set(selector.ids)
+        cursor: str | None = None
+        total = 0
+        while True:
+            request_limit = min(self.DOWNLOAD_LIMIT, limit - total) if limit is not None else self.DOWNLOAD_LIMIT
+            response = self.client.tool.three_d.models_classic.paginate(
+                published=published, include_revision_info=True, limit=request_limit, cursor=cursor
+            )
+            items = [item for item in response.items if self._is_selected(item, included_models)]
+            total += len(items)
+            if items:
+                yield Page(worker_id="main", items=items, next_cursor=response.next_cursor)
+            if response.next_cursor is None:
+                break
+            cursor = response.next_cursor
+
+    def count(self, selector: ThreeDSelector) -> int | None:
+        # There is no efficient way to count 3D models in CDF.
+        return None
+
+    def data_to_json_chunk(
+        self, data_chunk: Sequence[ThreeDModelResponse], selector: ThreeDSelector | None = None
+    ) -> list[dict[str, JsonVal]]:
+        raise NotImplementedError("Deserializing Annotation Migrations from JSON is not supported.")
+
+    def json_to_resource(self, item_json: dict[str, JsonVal]) -> ThreeDMigrationRequest:
+        raise NotImplementedError("Deserializing ThreeD Migrations from JSON is not supported.")
+
+    def upload_items(
+        self,
+        data_chunk: Sequence[UploadItem[ThreeDMigrationRequest]],
+        http_client: HTTPClient,
+        selector: ThreeDSelector | None = None,
+    ) -> Sequence[HTTPMessage]:
+        """Migrate 3D models by uploading them to the migrate/models endpoint."""
+        if len(data_chunk) > self.CHUNK_SIZE:
+            raise RuntimeError(f"Uploading more than {self.CHUNK_SIZE} 3D models at a time is not supported.")
+
+        results: list[HTTPMessage] = []
+        responses = http_client.request_with_retries(
+            message=ItemsRequest(
+                endpoint_url=self.client.config.create_api_url(self.UPLOAD_ENDPOINT),
+                method="POST",
+                items=list(data_chunk),
+            )
+        )
+        if (
+            failed_response := next((res for res in responses if isinstance(res, FailedResponse)), None)
+        ) and failed_response.status_code == 400:
+            raise ToolkitAPIError("3D model migration failed. You need to enable the 3D migration alpha feature flag.")
+
+        results.extend(responses)
+        success_ids = {id for res in responses if isinstance(res, SuccessResponseItems) for id in res.ids}
+        for data in data_chunk:
+            if data.source_id not in success_ids:
+                continue
+            revision = http_client.request_single_retries(
+                message=RequestMessage2(
+                    endpoint_url=self.client.config.create_api_url(self.REVISION_ENDPOINT),
+                    method="POST",
+                    body_content={"items": [data.item.revision.dump(camel_case=True)]},
+                )
+            )
+            results.append(revision.as_item_response(data.source_id))
+        return results
+
+
+class ThreeDAssetMappingMigrationIO(
+    UploadableStorageIO[ThreeDSelector, AssetMappingClassicResponse, AssetMappingDMRequest]
+):
+    KIND = "3DMigrationAssetMapping"
+    SUPPORTED_DOWNLOAD_FORMATS = frozenset({".ndjson"})
+    SUPPORTED_COMPRESSIONS = frozenset({".gz"})
+    SUPPORTED_READ_FORMATS = frozenset({".ndjson"})
+    DOWNLOAD_LIMIT = 1000
+    CHUNK_SIZE = 100
+    UPLOAD_ENDPOINT = "/3d/models/{modelId}/revisions/{revisionId}/mappings"
+
+    def __init__(self, client: ToolkitClient, object_3D_space: str, cad_node_space: str) -> None:
+        super().__init__(client)
+        self.object_3D_space = object_3D_space
+        self.cad_node_space = cad_node_space
+        # We can only migrate asset mappings for 3D models that are already migrated to data modeling.
+        self._3D_io = ThreeDMigrationIO(client, data_model_type="data modeling")
+
+    def as_id(self, item: AssetMappingClassicResponse) -> str:
+        return f"AssetMapping_{item.model_id!s}_{item.revision_id!s}_{item.asset_id!s}"
+
+    def stream_data(
+        self, selector: ThreeDSelector, limit: int | None = None
+    ) -> Iterable[Page[AssetMappingClassicResponse]]:
+        total = 0
+        for three_d_page in self._3D_io.stream_data(selector, None):
+            for model in three_d_page.items:
+                if model.last_revision_info is None or model.last_revision_info.revision_id is None:
+                    # No revisions, so no asset mappings to
+                    continue
+                cursor: str | None = None
+                while True:
+                    request_limit = (
+                        min(self.DOWNLOAD_LIMIT, limit - total) if limit is not None else self.DOWNLOAD_LIMIT
+                    )
+                    if limit is not None and total >= limit:
+                        return
+                    response = self.client.tool.three_d.asset_mappings_classic.paginate(
+                        model_id=model.id,
+                        revision_id=model.last_revision_info.revision_id,
+                        cursor=cursor,
+                        limit=request_limit,
+                    )
+                    items = response.items
+                    total += len(items)
+                    if items:
+                        yield Page(worker_id="main", items=items, next_cursor=response.next_cursor)
+                    if response.next_cursor is None:
+                        break
+                    cursor = response.next_cursor
+
+    def count(self, selector: ThreeDSelector) -> int | None:
+        # There is no efficient way to count 3D asset mappings in CDF.
+        return None
+
+    def upload_items(
+        self,
+        data_chunk: Sequence[UploadItem[AssetMappingDMRequest]],
+        http_client: HTTPClient,
+        selector: T_Selector | None = None,
+    ) -> Sequence[HTTPMessage]:
+        """Migrate 3D asset mappings by uploading them to the migrate/asset-mappings endpoint."""
+        if not data_chunk:
+            return []
+        # Assume all items in the chunk belong to the same model and revision, they should
+        # if the .stream_data method is used for downloading.
+        first = data_chunk[0]
+        model_id = first.item.model_id
+        revision_id = first.item.revision_id
+        endpoint = self.UPLOAD_ENDPOINT.format(modelId=model_id, revisionId=revision_id)
+        responses = http_client.request_with_retries(
+            ItemsRequest(
+                endpoint_url=self.client.config.create_api_url(endpoint),
+                method="POST",
+                items=list(data_chunk),
+                extra_body_fields={
+                    "dmsContextualizationConfig": {
+                        "object3DSpace": self.object_3D_space,
+                        "cadNodeSpace": self.cad_node_space,
+                    }
+                },
+            )
+        )
+        return responses
+
+    def json_to_resource(self, item_json: dict[str, JsonVal]) -> AssetMappingDMRequest:
+        raise NotImplementedError("Deserializing 3D Asset Mappings from JSON is not supported.")
+
+    def data_to_json_chunk(
+        self, data_chunk: Sequence[AssetMappingClassicResponse], selector: ThreeDSelector | None = None
+    ) -> list[dict[str, JsonVal]]:
+        raise NotImplementedError("Serializing 3D Asset Mappings to JSON is not supported.")

cognite_toolkit/_cdf_tk/commands/_profile.py

@@ -21,7 +21,7 @@ from rich.spinner import Spinner
 from rich.table import Table
 
 from cognite_toolkit._cdf_tk.client import ToolkitClient
-from cognite_toolkit._cdf_tk.client.data_classes.raw import RawProfileResults, RawTable
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.raw import RawProfileResults, RawTable
 from cognite_toolkit._cdf_tk.constants import MAX_ROW_ITERATION_RUN_QUERY
 from cognite_toolkit._cdf_tk.exceptions import ToolkitMissingDependencyError, ToolkitThrottledError, ToolkitValueError
 from cognite_toolkit._cdf_tk.utils.aggregators import (

cognite_toolkit/_cdf_tk/commands/_purge.py

@@ -16,6 +16,14 @@ from rich.console import Console
 from rich.panel import Panel
 
 from cognite_toolkit._cdf_tk.client import ToolkitClient
+from cognite_toolkit._cdf_tk.client.http_client import (
+    HTTPClient,
+    ItemsRequest,
+    ItemsRequest2,
+    ItemsSuccessResponse2,
+    SuccessResponseItems,
+)
+from cognite_toolkit._cdf_tk.client.resource_classes.instance_api import TypedInstanceIdentifier
 from cognite_toolkit._cdf_tk.cruds import (
     AssetCRUD,
     ContainerCRUD,
@@ -58,13 +66,6 @@ from cognite_toolkit._cdf_tk.utils.aggregators import (
     SequenceAggregator,
     TimeSeriesAggregator,
 )
-from cognite_toolkit._cdf_tk.utils.http_client import (
-    FailedRequestItems,
-    FailedResponseItems,
-    HTTPClient,
-    ItemsRequest,
-    SuccessResponseItems,
-)
 from cognite_toolkit._cdf_tk.utils.producer_worker import ProducerWorkerExecutor
 from cognite_toolkit._cdf_tk.utils.useful_types import JsonVal
 from cognite_toolkit._cdf_tk.utils.validate_access import ValidateAccess
@@ -714,21 +715,18 @@ class PurgeCommand(ToolkitCommand):
             results.deleted += len(items)
             return
 
-        responses = delete_client.request_with_retries(
-            ItemsRequest(
-                delete_client.config.create_api_url("/models/instances/delete"),
+        responses = delete_client.request_items_retries(
+            ItemsRequest2(
+                endpoint_url=delete_client.config.create_api_url("/models/instances/delete"),
                 method="POST",
-                # MyPy does not understand that InstanceId.load handles dict[str, JsonVal]
-                items=[DeleteItem(item=item, as_id_fun=InstanceId.load) for item in items],  # type: ignore[arg-type]
+                items=[TypedInstanceIdentifier._load(item) for item in items],
             )
         )
         for response in responses:
-            if isinstance(response, SuccessResponseItems):
+            if isinstance(response, ItemsSuccessResponse2):
                 results.deleted += len(response.ids)
-            elif isinstance(response, FailedResponseItems | FailedRequestItems):
-                results.failed += len(response.ids)
             else:
-                results.failed += len(items)
+                results.failed += len(response.ids)
 
     @staticmethod
     def _unlink_timeseries(

cognite_toolkit/_cdf_tk/commands/_upload.py

@@ -9,6 +9,7 @@ from cognite.client.data_classes.data_modeling import (
 from rich.console import Console
 
 from cognite_toolkit._cdf_tk.client import ToolkitClient
+from cognite_toolkit._cdf_tk.client.http_client import HTTPClient, ItemMessage, SuccessResponseItems
 from cognite_toolkit._cdf_tk.constants import DATA_MANIFEST_SUFFIX, DATA_RESOURCE_DIR
 from cognite_toolkit._cdf_tk.cruds import ViewCRUD
 from cognite_toolkit._cdf_tk.exceptions import ToolkitValueError
@@ -24,7 +25,6 @@ from cognite_toolkit._cdf_tk.storageio.selectors._instances import InstanceSpace
 from cognite_toolkit._cdf_tk.tk_warnings import HighSeverityWarning, MediumSeverityWarning, ToolkitWarning
 from cognite_toolkit._cdf_tk.utils.auth import EnvironmentVariables
 from cognite_toolkit._cdf_tk.utils.fileio import MultiFileReader
-from cognite_toolkit._cdf_tk.utils.http_client import HTTPClient, ItemMessage, SuccessResponseItems
 from cognite_toolkit._cdf_tk.utils.producer_worker import ProducerWorkerExecutor
 from cognite_toolkit._cdf_tk.utils.progress_tracker import ProgressTracker
 from cognite_toolkit._cdf_tk.utils.useful_types import JsonVal

cognite_toolkit/_cdf_tk/commands/build_cmd.py

@@ -11,10 +11,10 @@ from rich import print
 from rich.panel import Panel
 from rich.progress import track
 
-from cognite_toolkit._cdf_tk.builders import Builder, create_builder
+from cognite_toolkit._cdf_tk.builders import Builder, FunctionBuilder, create_builder
 from cognite_toolkit._cdf_tk.cdf_toml import CDFToml
 from cognite_toolkit._cdf_tk.client import ToolkitClient
-from cognite_toolkit._cdf_tk.client.data_classes.raw import RawDatabase
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.raw import RawDatabase
 from cognite_toolkit._cdf_tk.commands._base import ToolkitCommand
 from cognite_toolkit._cdf_tk.constants import (
     _RUNNING_IN_BROWSER,
@@ -33,6 +33,7 @@ from cognite_toolkit._cdf_tk.cruds import (
     DataSetsCRUD,
     ExtractionPipelineConfigCRUD,
     FileCRUD,
+    FunctionCRUD,
     LocationFilterCRUD,
     NodeCRUD,
     RawDatabaseCRUD,
@@ -415,6 +416,15 @@ class BuildCommand(ToolkitCommand):
 
             build_resources_by_folder[resource_name].extend(built_resources)
 
+            # Collect validation metrics from FunctionBuilder
+            if resource_name == FunctionCRUD.folder_name and isinstance(builder, FunctionBuilder):
+                self._additional_tracking_info.function_validation_count += builder.validation_count
+                self._additional_tracking_info.function_validation_failures += builder.validation_failures
+                self._additional_tracking_info.function_validation_credential_errors += (
+                    builder.validation_credential_errors
+                )
+                self._additional_tracking_info.function_validation_time_ms += builder.validation_time_ms
+
         return build_resources_by_folder
 
     def _get_builder(self, build_dir: Path, resource_name: str) -> Builder: