cognite-toolkit 0.7.46__py3-none-any.whl → 0.7.48__py3-none-any.whl

cognite_toolkit/_cdf_tk/client/api/views.py

@@ -0,0 +1,139 @@
+"""Views API for managing CDF data modeling views.
+
+Based on the API specification at:
+https://api-docs.cognite.com/20230101/tag/Views/operation/ApplyViews
+"""
+
+from collections.abc import Iterable, Sequence
+
+from cognite_toolkit._cdf_tk.client.cdf_client import CDFResourceAPI, Endpoint, PagedResponse
+from cognite_toolkit._cdf_tk.client.http_client import HTTPClient, ItemsSuccessResponse2, SuccessResponse2
+from cognite_toolkit._cdf_tk.client.request_classes.filters import ViewFilter
+from cognite_toolkit._cdf_tk.client.resource_classes.data_modeling import (
+    ViewReference,
+    ViewRequest,
+    ViewResponse,
+)
+
+
+class ViewsAPI(CDFResourceAPI[ViewReference, ViewRequest, ViewResponse]):
+    """API for managing CDF data modeling views.
+
+    Views use an apply/upsert pattern for create and update operations.
+    """
+
+    def __init__(self, http_client: HTTPClient) -> None:
+        super().__init__(
+            http_client=http_client,
+            method_endpoint_map={
+                "upsert": Endpoint(method="POST", path="/models/views", item_limit=100),
+                "retrieve": Endpoint(method="POST", path="/models/views/byids", item_limit=100),
+                "delete": Endpoint(method="POST", path="/models/views/delete", item_limit=100),
+                "list": Endpoint(method="GET", path="/models/views", item_limit=1000),
+            },
+        )
+
+    def _validate_page_response(
+        self, response: SuccessResponse2 | ItemsSuccessResponse2
+    ) -> PagedResponse[ViewResponse]:
+        return PagedResponse[ViewResponse].model_validate_json(response.body)
+
+    def create(self, items: Sequence[ViewRequest]) -> list[ViewResponse]:
+        """Apply (create or update) views in CDF.
+
+        Args:
+            items: List of ViewRequest objects to apply.
+
+        Returns:
+            List of applied ViewResponse objects.
+        """
+        return self._request_item_response(items, "upsert")
+
+    def update(self, items: Sequence[ViewRequest]) -> list[ViewResponse]:
+        """Apply (create or update) views in CDF.
+
+        Args:
+            items: List of ViewRequest objects to apply.
+        Returns:
+            List of applied ViewResponse objects.
+        """
+        return self._request_item_response(items, "upsert")
+
+    def retrieve(self, items: Sequence[ViewReference], include_inherited_properties: bool = True) -> list[ViewResponse]:
+        """Retrieve views from CDF.
+
+        Args:
+            items: List of ViewReference objects to retrieve.
+            include_inherited_properties: Whether to include inherited properties.
+
+        Returns:
+            List of retrieved ViewResponse objects.
+        """
+        return self._request_item_response(
+            items, method="retrieve", extra_body={"includeInheritedProperties": include_inherited_properties}
+        )
+
+    def delete(self, items: Sequence[ViewReference]) -> None:
+        """Delete views from CDF.
+
+        Args:
+            items: List of ViewReference objects to delete.
+        """
+        self._request_no_response(items, "delete")
+
+    def paginate(
+        self,
+        filter: ViewFilter | None = None,
+        limit: int = 100,
+        cursor: str | None = None,
+    ) -> PagedResponse[ViewResponse]:
+        """Get a page of views from CDF.
+
+        Args:
+            filter: ViewFilter to filter views.
+            limit: Maximum number of views to return.
+            cursor: Cursor for pagination.
+
+        Returns:
+            PagedResponse of ViewResponse objects.
+        """
+        return self._paginate(
+            cursor=cursor,
+            limit=limit,
+            params=filter.dump() if filter else None,
+        )
+
+    def iterate(
+        self,
+        filter: ViewFilter | None = None,
+        limit: int | None = None,
+    ) -> Iterable[list[ViewResponse]]:
+        """Iterate over all views in CDF.
+
+        Args:
+            filter: ViewFilter to filter views.
+            limit: Maximum total number of views to return.
+
+        Returns:
+            Iterable of lists of ViewResponse objects.
+        """
+        return self._iterate(
+            limit=limit,
+            params=filter.dump() if filter else None,
+        )
+
+    def list(
+        self,
+        filter: ViewFilter | None = None,
+        limit: int | None = None,
+    ) -> list[ViewResponse]:
+        """List all views in CDF.
+
+        Args:
+            filter: ViewFilter to filter views.
+            limit: Maximum total number of views to return.
+
+        Returns:
+            List of ViewResponse objects.
+        """
+        return self._list(limit=limit, params=filter.dump() if filter else None)

cognite_toolkit/_cdf_tk/client/cdf_client/api.py

@@ -51,15 +51,20 @@ class CDFResourceAPI(Generic[T_Identifier, T_RequestResource, T_ResponseResource
     including creating, retrieving, deleting, and listing resources.
     """
 
-    def __init__(self, http_client: HTTPClient, method_endpoint_map: dict[APIMethod, Endpoint]) -> None:
+    def __init__(
+        self, http_client: HTTPClient, method_endpoint_map: dict[APIMethod, Endpoint], disable_gzip: bool = False
+    ) -> None:
         """Initialize the resource API.
 
         Args:
             http_client: The HTTP client to use for API requests.
             method_endpoint_map: A mapping of endpoint suffixes to their properties.
+            disable_gzip: Whether to disable gzip compression for requests. Defaults to False.
+                This is only used by the robotics API. If that API is dropped, this parameter can be removed.
         """
         self._http_client = http_client
         self._method_endpoint_map = method_endpoint_map
+        self._disable_gzip = disable_gzip
 
     @classmethod
     def _serialize_items(cls, items: Sequence[BaseModel]) -> list[dict[str, JsonValue]]:
@@ -151,6 +156,7 @@ class CDFResourceAPI(Generic[T_Identifier, T_RequestResource, T_ResponseResource
                 method=endpoint.method,
                 body_content={"items": serialization(chunk), **(extra_body or {})},  # type: ignore[dict-item]
                 parameters=request_params,
+                disable_gzip=self._disable_gzip,
             )
             response = self._http_client.request_single_retries(request)
             yield response.get_success_or_raise()
@@ -180,6 +186,27 @@ class CDFResourceAPI(Generic[T_Identifier, T_RequestResource, T_ResponseResource
             response_items.extend(self._validate_page_response(response).items)
         return response_items
 
+    def _request_item_split_retries_no_response(
+        self,
+        items: Sequence[_T_BaseModel],
+        method: APIMethod,
+        params: dict[str, Any] | None = None,
+        extra_body: dict[str, Any] | None = None,
+    ) -> None:
+        """Request items with retries, splitting on failures, without returning any response.
+
+        This method handles large batches of items by chunking them according to the endpoint's item limit.
+        If a single item fails, it splits the request into individual item requests to isolate the failure.
+
+        Args:
+            items: Sequence of items to request.
+            method: API method to use for the request.
+            params: Optional query parameters for the request.
+            extra_body: Optional additional body fields for the request.
+        """
+        list(self._chunk_requests_items_split_retries(items, method, params, extra_body))
+        return None
+
     def _chunk_requests_items_split_retries(
         self,
         items: Sequence[_T_BaseModel],
@@ -215,6 +242,7 @@ class CDFResourceAPI(Generic[T_Identifier, T_RequestResource, T_ResponseResource
                 parameters=request_params,
                 items=chunk,
                 extra_body_fields=extra_body,
+                disable_gzip=self._disable_gzip,
             )
             responses = self._http_client.request_items_retries(request)
             for response in responses:
@@ -230,12 +258,12 @@ class CDFResourceAPI(Generic[T_Identifier, T_RequestResource, T_ResponseResource
 
     @classmethod
     def _group_items_by_text_field(
-        cls, items: Sequence[_T_BaseModel], field_name: str
-    ) -> dict[str, list[_T_BaseModel]]:
+        cls, items: Sequence[_T_BaseModel], *field_names: str
+    ) -> dict[tuple[str, ...], list[_T_BaseModel]]:
         """Group items by a text field."""
-        grouped_items: dict[str, list[_T_BaseModel]] = defaultdict(list)
+        grouped_items: dict[tuple[str, ...], list[_T_BaseModel]] = defaultdict(list)
         for item in items:
-            key = str(getattr(item, field_name))
+            key = tuple(str(getattr(item, field_name)) for field_name in field_names)
             grouped_items[key].append(item)
         return grouped_items
 
@@ -287,6 +315,7 @@ class CDFResourceAPI(Generic[T_Identifier, T_RequestResource, T_ResponseResource
             method=endpoint.method,
             parameters=request_params,
             body_content=body,
+            disable_gzip=self._disable_gzip,
         )
         result = self._http_client.request_single_retries(request)
         response = result.get_success_or_raise()
@@ -316,9 +345,15 @@ class CDFResourceAPI(Generic[T_Identifier, T_RequestResource, T_ResponseResource
             next_cursor = page.next_cursor
 
     def _list(
-        self, limit: int | None = None, params: dict[str, Any] | None = None, endpoint_path: str | None = None
+        self,
+        limit: int | None = None,
+        params: dict[str, Any] | None = None,
+        endpoint_path: str | None = None,
+        body: dict[str, Any] | None = None,
     ) -> list[T_ResponseResource]:
         """List all resources, handling pagination automatically."""
         return [
-            item for batch in self._iterate(limit=limit, params=params, endpoint_path=endpoint_path) for item in batch
+            item
+            for batch in self._iterate(limit=limit, params=params, endpoint_path=endpoint_path, body=body)
+            for item in batch
         ]

cognite_toolkit/_cdf_tk/client/cdf_client/responses.py

@@ -2,6 +2,8 @@ from typing import Generic, TypeVar
 
 from pydantic import BaseModel, Field, JsonValue
 
+from cognite_toolkit._cdf_tk.client.resource_classes.graphql_data_model import GraphQLDataModelResponse
+
 T = TypeVar("T", bound=BaseModel)
 
 
@@ -25,3 +27,12 @@ class QueryResponse(BaseModel, Generic[T]):
     typing: dict[str, JsonValue] | None = None
     next_cursor: dict[str, str] = Field(alias="nextCursor")
     debug: dict[str, JsonValue] | None = None
+
+
+class GraphQLResponse(BaseModel):
+    data: GraphQLDataModelResponse
+    errors: list[dict[str, JsonValue]] | None = None
+
+
+class GraphQLUpsertResponse(BaseModel):
+    upsert_graph_ql_dml_version: GraphQLResponse = Field(alias="upsertGraphQlDmlVersion")

cognite_toolkit/_cdf_tk/client/http_client/_client.py

@@ -172,6 +172,7 @@ class HTTPClient:
         content_type: str = "application/json",
         accept: str = "application/json",
         content_length: int | None = None,
+        disable_gzip: bool = False,
     ) -> MutableMapping[str, str]:
         headers: MutableMapping[str, str] = {}
         headers["User-Agent"] = f"httpx/{httpx.__version__} {get_user_agent()}"
@@ -184,7 +185,7 @@ class HTTPClient:
         headers["x-cdp-sdk"] = f"CogniteToolkit:{get_current_toolkit_version()}"
         headers["x-cdp-app"] = self.config.client_name
         headers["cdf-version"] = api_version or self.config.api_subversion
-        if not global_config.disable_gzip and content_length is None:
+        if not global_config.disable_gzip and content_length is None and not disable_gzip:
             headers["Content-Encoding"] = "gzip"
         return headers
 
@@ -332,7 +333,9 @@ class HTTPClient:
                 raise TypeError(f"Unexpected result type: {type(result)}")
 
     def _make_request2(self, message: BaseRequestMessage) -> httpx.Response:
-        headers = self._create_headers(message.api_version, message.content_type, message.accept)
+        headers = self._create_headers(
+            message.api_version, message.content_type, message.accept, disable_gzip=message.disable_gzip
+        )
         return self.session.request(
             method=message.method,
             url=message.endpoint_url,

cognite_toolkit/_cdf_tk/client/http_client/_data_classes.py

@@ -307,6 +307,11 @@ class ItemsRequest(Generic[T_COVARIANT_ID], BodyRequest):
             connect_attempt=self.connect_attempt,
             read_attempt=self.read_attempt,
             status_attempt=status_attempts,
+            api_version=self.api_version,
+            content_type=self.content_type,
+            accept=self.accept,
+            content_length=self.content_length,
+            max_failures_before_abort=self.max_failures_before_abort,
         )
         first_half.tracker = tracker
         second_half = ItemsRequest[T_COVARIANT_ID](
@@ -317,6 +322,11 @@ class ItemsRequest(Generic[T_COVARIANT_ID], BodyRequest):
             connect_attempt=self.connect_attempt,
             read_attempt=self.read_attempt,
             status_attempt=status_attempts,
+            api_version=self.api_version,
+            content_type=self.content_type,
+            accept=self.accept,
+            content_length=self.content_length,
+            max_failures_before_abort=self.max_failures_before_abort,
         )
         second_half.tracker = tracker
         return [first_half, second_half]

cognite_toolkit/_cdf_tk/client/http_client/_data_classes2.py

@@ -77,6 +77,7 @@ class BaseRequestMessage(BaseModel, ABC):
     read_attempt: int = 0
     status_attempt: int = 0
     api_version: str | None = None
+    disable_gzip: bool = False
     content_type: str = "application/json"
     accept: str = "application/json"
 
@@ -106,13 +107,13 @@ class RequestMessage2(BaseRequestMessage):
         data: str | bytes | None = None
         if self.data_content is not None:
             data = self.data_content
-            if not global_config.disable_gzip:
+            if not global_config.disable_gzip and not self.disable_gzip:
                 data = gzip.compress(data)
         elif self.body_content is not None:
             # We serialize using pydantic instead of json.dumps. This is because pydantic is faster
             # and handles more complex types such as datetime, float('nan'), etc.
             data = _BODY_SERIALIZER.dump_json(self.body_content)
-            if not global_config.disable_gzip and isinstance(data, bytes):
+            if not global_config.disable_gzip and not self.disable_gzip and isinstance(data, bytes):
                 data = gzip.compress(data)
         return data
 
@@ -161,7 +162,7 @@ class ItemsRequest2(BaseRequestMessage):
         if self.extra_body_fields:
             body.update(self.extra_body_fields)
         res = _BODY_SERIALIZER.dump_json(body)
-        if not global_config.disable_gzip and isinstance(res, bytes):
+        if not global_config.disable_gzip and not self.disable_gzip and isinstance(res, bytes):
             return gzip.compress(res)
         return res
 

cognite_toolkit/_cdf_tk/client/request_classes/filters.py

@@ -1,5 +1,10 @@
 import sys
+from typing import Any, Literal
 
+from pydantic import Field
+
+from cognite_toolkit._cdf_tk.client.resource_classes.annotation import AnnotationStatus, AnnotationType
+from cognite_toolkit._cdf_tk.client.resource_classes.data_modeling import NodeReference, ViewReference
 from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import ExternalId, InternalId
 
 from .base import BaseModelRequest
@@ -36,3 +41,73 @@ class ClassicFilter(Filter):
             return None
         ids = id if isinstance(id, list) else [id]
         return [ExternalId(external_id=item) if isinstance(item, str) else InternalId(id=item) for item in ids]
+
+
+class DataModelingFilter(Filter):
+    space: str | None = None
+    include_global: bool | None = None
+
+
+class ContainerFilter(DataModelingFilter):
+    used_for: Literal["node", "edge", "record", "all"] | None
+
+
+class ViewFilter(DataModelingFilter):
+    include_inherited_properties: bool | None = None
+    all_versions: bool | None = None
+
+
+class DataModelFilter(DataModelingFilter):
+    inline_views: bool | None = None
+    all_versions: bool | None = None
+
+
+class InstanceFilter(Filter):
+    instance_type: Literal["node", "edge"] | None = None
+    source: ViewReference | None = None
+    space: list[str] | None = None
+
+    def dump(self, camel_case: bool = True) -> dict[str, Any]:
+        body: dict[str, Any] = {}
+        if self.instance_type is not None:
+            body["instanceType"] = self.instance_type
+        if self.source is not None:
+            body["sources"] = [{"source": self.source.dump()}]
+        if self.space is not None:
+            instance_type = self.instance_type or "node"
+            body["filter"] = {
+                "in": {
+                    "property": [instance_type, "space"],
+                    "values": self.space,
+                }
+            }
+        return body
+
+
+class AnnotationFilter(Filter):
+    annotated_resource_type: Literal["file", "threedmodel"]
+    annotated_resource_ids: list[ExternalId | InternalId]
+    annotation_type: AnnotationType | None = None
+    created_app: str | None = None
+    creating_app_version: str | None = None
+    creating_user: str | None = None
+    status: AnnotationStatus | None = None
+
+
+class ThreeDAssetMappingFilter(Filter): ...
+
+
+class ThreeDAssetMappingAssetIdFilter(ThreeDAssetMappingFilter):
+    asset_ids: list[int] = Field(max_length=100)
+
+
+class ThreeDAssetMappingAssetInstanceIdFilter(ThreeDAssetMappingFilter):
+    asset_instance_ids: list[NodeReference] = Field(max_length=100)
+
+
+class ThreeDAssetMapping3DNodeFilter(ThreeDAssetMappingFilter):
+    node_ids: list[int] = Field(max_length=100)
+
+
+class ThreeDAssetMappingTreeIndexFilter(ThreeDAssetMappingFilter):
+    tree_indexes: list[int] = Field(max_length=100)

cognite_toolkit/_cdf_tk/client/request_classes/graphql.py

@@ -0,0 +1,28 @@
+UPSERT_BODY = """
+mutation UpsertGraphQlDmlVersion($dmCreate: GraphQlDmlVersionUpsert!) {
+    upsertGraphQlDmlVersion(graphQlDmlVersion: $dmCreate) {
+        errors {
+            kind
+            message
+            hint
+            location {
+                start {
+                    line
+                    column
+                }
+            }
+        }
+        result {
+            space
+            externalId
+            version
+            name
+            description
+            graphQlDml
+            isGlobal
+            createdTime
+            lastUpdatedTime
+        }
+    }
+}
+"""

cognite_toolkit/_cdf_tk/client/resource_classes/agent.py

@@ -3,7 +3,6 @@ from typing import Annotated, Any, Literal
 from pydantic import BeforeValidator, Field
 
 from cognite_toolkit._cdf_tk.client.resource_classes.base import BaseModelObject, RequestResource, ResponseResource
-from tests.test_unit.test_cdf_tk.test_tk_warnings.test_warnings_metatest import get_all_subclasses
 
 from .identifiers import ExternalId
 
@@ -74,7 +73,14 @@ class UnknownAgentTool(AgentToolDefinition):
     ...
 
 
-KNOWN_TOOLS = {tool.type: tool for tool in get_all_subclasses(AgentToolDefinition) if hasattr(tool, "type")}
+# Mapping of known agent tool types to their classes
+KNOWN_TOOLS: dict[str, type[AgentToolDefinition]] = {
+    "askDocument": AskDocument,
+    "examineDataSemantically": ExamineDataSemantically,
+    "queryKnowledgeGraph": QueryKnowledgeGraph,
+    "queryTimeSeriesDatapoints": QueryTimeSeriesDatapoints,
+    "summarizeDocument": SummarizeDocument,
+}
 
 
 def _handle_unknown_tool(value: Any) -> Any:

cognite_toolkit/_cdf_tk/client/resource_classes/apm_config.py

@@ -0,0 +1,128 @@
+from typing import ClassVar, Literal
+
+from cognite_toolkit._cdf_tk.client.resource_classes.base import (
+    BaseModelObject,
+    RequestResource,
+    ResponseResource,
+)
+
+from .data_modeling import ViewReference
+from .identifiers import ExternalId
+
+
+class ThreeDModelIdentifier(BaseModelObject):
+    revision_id: int | None = None
+    model_id: int | None = None
+    name: str | None = None
+
+
+class ThreeDConfiguration(BaseModelObject):
+    full_weight_models: list[ThreeDModelIdentifier] | None = None
+    light_weight_models: list[ThreeDModelIdentifier] | None = None
+
+
+class ResourceFilters(BaseModelObject):
+    data_set_ids: list[int] | None = None
+    asset_subtree_external_ids: list[str] | None = None
+    root_asset_external_ids: list[str] | None = None
+    external_id_prefix: str | None = None
+    spaces: list[str] | None = None
+
+
+class RootLocationDataFilters(BaseModelObject):
+    general: ResourceFilters | None = None
+    assets: ResourceFilters | None = None
+    files: ResourceFilters | None = None
+    timeseries: ResourceFilters | None = None
+
+
+class ObservationFeatureToggles(BaseModelObject):
+    is_enabled: bool | None = None
+    is_write_back_enabled: bool | None = None
+    notifications_endpoint_external_id: str | None = None
+    attachments_endpoint_external_id: str | None = None
+
+
+class RootLocationFeatureToggles(BaseModelObject):
+    three_d: bool | None = None
+    trends: bool | None = None
+    documents: bool | None = None
+    workorders: bool | None = None
+    notifications: bool | None = None
+    media: bool | None = None
+    template_checklist_flow: bool | None = None
+    workorder_checklist_flow: bool | None = None
+    observations: ObservationFeatureToggles | None = None
+
+
+class ObservationConfigFieldProperty(BaseModelObject):
+    display_title: str | None = None
+    display_description: str | None = None
+    is_required: bool | None = None
+
+
+class ObservationConfigDropdownPropertyOption(BaseModelObject):
+    id: str | None = None
+    value: str | None = None
+    label: str | None = None
+
+
+class ObservationConfigDropdownProperty(ObservationConfigFieldProperty):
+    options: list[ObservationConfigDropdownPropertyOption] | None = None
+
+
+class ObservationsConfig(BaseModelObject):
+    files: ObservationConfigFieldProperty | None = None
+    description: ObservationConfigFieldProperty | None = None
+    asset: ObservationConfigFieldProperty | None = None
+    troubleshooting: ObservationConfigFieldProperty | None = None
+    type: ObservationConfigDropdownProperty | None = None
+    priority: ObservationConfigDropdownProperty | None = None
+
+
+class RootLocationConfiguration(BaseModelObject):
+    asset_external_id: str | None = None
+    external_id: str | None = None
+    display_name: str | None = None
+    three_d_configuration: ThreeDConfiguration | None = None
+    data_set_id: int | None = None
+    template_admins: list[str] | None = None  # list of Group Names
+    checklist_admins: list[str] | None = None  # list of Group Names
+    app_data_instance_space: str | None = None
+    source_data_instance_space: str | None = None
+    data_filters: RootLocationDataFilters | None = None
+    feature_toggles: RootLocationFeatureToggles | None = None
+    observations: ObservationsConfig | None = None
+
+
+class FeatureConfiguration(BaseModelObject):
+    root_location_configurations: list[RootLocationConfiguration] | None = None
+
+
+class APMConfig(BaseModelObject):
+    space: ClassVar[str] = "APM_Config"
+    view_ref: ClassVar[ViewReference] = ViewReference(space="APM_Config", external_id="APM_Config", version="1")
+    instance_type: Literal["node"] = "node"
+    external_id: str
+    name: str | None = None
+    app_data_space_id: str | None = None
+    app_data_space_version: str | None = None
+    customer_data_space_id: str | None = None
+    customer_data_space_version: str | None = None
+    feature_configuration: FeatureConfiguration | None = None
+
+    def as_id(self) -> ExternalId:
+        return ExternalId(external_id=self.external_id)
+
+
+class APMConfigRequest(APMConfig, RequestResource):
+    existing_version: int | None = None
+
+
+class APMConfigResponse(APMConfig, ResponseResource[APMConfigRequest]):
+    version: int
+    created_time: int
+    last_updated_time: int
+
+    def as_request_resource(self) -> APMConfigRequest:
+        return APMConfigRequest.model_validate(self.dump(), extra="ignore")

cognite_toolkit/_cdf_tk/client/resource_classes/cognite_file.py

@@ -0,0 +1,53 @@
+from datetime import datetime
+from typing import ClassVar, Literal
+
+from cognite_toolkit._cdf_tk.client.resource_classes.base import (
+    BaseModelObject,
+    RequestResource,
+    ResponseResource,
+)
+
+from .data_modeling import ViewReference
+from .instance_api import NodeReference, TypedNodeIdentifier
+
+
+class CogniteFile(BaseModelObject):
+    view_ref: ClassVar[ViewReference] = ViewReference(space="cdf_cdm", external_id="CogniteFile", version="v1")
+    instance_type: Literal["node"] = "node"
+    space: str
+    external_id: str
+    name: str | None = None
+    description: str | None = None
+    tags: list[str] | None = None
+    aliases: list[str] | None = None
+    source_id: str | None = None
+    source_context: str | None = None
+    source: NodeReference | None = None
+    source_created_time: datetime | None = None
+    source_updated_time: datetime | None = None
+    source_created_user: str | None = None
+    source_updated_user: str | None = None
+    assets: list[NodeReference] | None = None
+    mime_type: str | None = None
+    directory: str | None = None
+    category: NodeReference | None = None
+    type: NodeReference | None = None
+
+    def as_id(self) -> TypedNodeIdentifier:
+        return TypedNodeIdentifier(space=self.space, external_id=self.external_id)
+
+
+class CogniteFileRequest(CogniteFile, RequestResource):
+    existing_version: int | None = None
+
+
+class CogniteFileResponse(CogniteFile, ResponseResource[CogniteFileRequest]):
+    version: int
+    created_time: int
+    last_updated_time: int
+    is_uploaded: bool | None = None
+    uploaded_time: datetime | None = None
+    deleted_time: int | None = None
+
+    def as_request_resource(self) -> CogniteFileRequest:
+        return CogniteFileRequest.model_validate(self.dump(), extra="ignore")