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

cognite_toolkit/_cdf_tk/client/resource_classes/hosted_extractor_source/_kafka.py

@@ -0,0 +1,53 @@
+from typing import Literal
+
+from pydantic import Field
+
+from cognite_toolkit._cdf_tk.client._resource_base import (
+    BaseModelObject,
+    ResponseResource,
+)
+
+from ._auth import (
+    BasicAuthenticationRequest,
+    BasicAuthenticationResponse,
+    ClientCredentialAuthenticationRequest,
+    ClientCredentialAuthenticationResponse,
+    ScramShaAuthenticationRequest,
+    ScramShaAuthenticationResponse,
+)
+from ._base import SourceRequestDefinition, SourceResponseDefinition
+from ._certificate import AuthCertificateRequest, CACertificateRequest, CertificateResponse
+
+
+class KafkaBroker(BaseModelObject):
+    host: str
+    port: int
+
+
+class KafkaSource(BaseModelObject):
+    type: Literal["kafka"] = "kafka"
+    bootstrap_brokers: list[KafkaBroker]
+    use_tls: bool | None = None
+
+
+class KafkaSourceRequest(KafkaSource, SourceRequestDefinition):
+    authentication: (
+        BasicAuthenticationRequest | ClientCredentialAuthenticationRequest | ScramShaAuthenticationRequest | None
+    ) = Field(None, discriminator="type")
+    ca_certificate: CACertificateRequest | None = None
+    auth_certificate: AuthCertificateRequest | None = None
+
+
+class KafkaSourceResponse(
+    SourceResponseDefinition,
+    KafkaSource,
+    ResponseResource[KafkaSourceRequest],
+):
+    authentication: (
+        BasicAuthenticationResponse | ClientCredentialAuthenticationResponse | ScramShaAuthenticationResponse | None
+    ) = Field(None, discriminator="type")
+    ca_certificate: CertificateResponse | None = None
+    auth_certificate: CertificateResponse | None = None
+
+    def as_request_resource(self) -> KafkaSourceRequest:
+        return KafkaSourceRequest.model_validate(self.dump(), extra="ignore")

cognite_toolkit/_cdf_tk/client/resource_classes/hosted_extractor_source/_mqtt.py

@@ -0,0 +1,36 @@
+from typing import Literal
+
+from cognite_toolkit._cdf_tk.client._resource_base import (
+    BaseModelObject,
+    ResponseResource,
+)
+
+from ._auth import BasicAuthenticationRequest, BasicAuthenticationResponse
+from ._base import SourceRequestDefinition, SourceResponseDefinition
+from ._certificate import AuthCertificateRequest, CACertificateRequest, CertificateResponse
+
+
+class MQTTSource(BaseModelObject):
+    type: Literal["mqtt5", "mqtt3"]
+    host: str
+    port: int | None = None
+    use_tls: bool | None = None
+
+
+class MQTTSourceRequest(MQTTSource, SourceRequestDefinition):
+    authentication: BasicAuthenticationRequest | None = None
+    ca_certificate: CACertificateRequest | None = None
+    auth_certificate: AuthCertificateRequest | None = None
+
+
+class MQTTSourceResponse(
+    SourceResponseDefinition,
+    MQTTSource,
+    ResponseResource[MQTTSourceRequest],
+):
+    authentication: BasicAuthenticationResponse | None = None
+    ca_certificate: CertificateResponse | None = None
+    auth_certificate: CertificateResponse | None = None
+
+    def as_request_resource(self) -> MQTTSourceRequest:
+        return MQTTSourceRequest.model_validate(self.dump(), extra="ignore")

cognite_toolkit/_cdf_tk/client/resource_classes/hosted_extractor_source/_rest.py

@@ -0,0 +1,49 @@
+from typing import Literal
+
+from pydantic import Field
+
+from cognite_toolkit._cdf_tk.client._resource_base import (
+    BaseModelObject,
+    ResponseResource,
+)
+
+from ._auth import (
+    BasicAuthenticationRequest,
+    BasicAuthenticationResponse,
+    ClientCredentialAuthenticationRequest,
+    ClientCredentialAuthenticationResponse,
+    HTTPBasicAuthenticationRequest,
+    HTTPBasicAuthenticationResponse,
+)
+from ._base import SourceRequestDefinition, SourceResponseDefinition
+from ._certificate import AuthCertificateRequest, CACertificateRequest, CertificateResponse
+
+
+class RESTSource(BaseModelObject):
+    type: Literal["rest"] = "rest"
+    host: str
+    port: int | None = None
+
+
+class RESTSourceRequest(RESTSource, SourceRequestDefinition):
+    scheme: Literal["https", "http"] | None = None
+    authentication: (
+        BasicAuthenticationRequest | HTTPBasicAuthenticationRequest | ClientCredentialAuthenticationRequest | None
+    ) = Field(None, discriminator="type")
+    ca_certificate: CACertificateRequest | None = None
+    auth_certificate: AuthCertificateRequest | None = None
+
+
+class RESTSourceResponse(
+    SourceResponseDefinition,
+    RESTSource,
+    ResponseResource[RESTSourceRequest],
+):
+    authentication: (
+        BasicAuthenticationResponse | HTTPBasicAuthenticationResponse | ClientCredentialAuthenticationResponse | None
+    ) = Field(None, discriminator="type")
+    ca_certificate: CertificateResponse | None = None
+    auth_certificate: CertificateResponse | None = None
+
+    def as_request_resource(self) -> RESTSourceRequest:
+        return RESTSourceRequest.model_validate(self.dump(), extra="ignore")

cognite_toolkit/_cdf_tk/client/resource_classes/identifiers.py

@@ -0,0 +1,59 @@
+from collections.abc import Sequence
+from typing import Annotated, Literal
+
+from pydantic import Field
+
+from cognite_toolkit._cdf_tk.client._resource_base import Identifier
+
+
+class InternalOrExternalIdDefinition(Identifier):
+    type: str
+
+
+class InternalId(InternalOrExternalIdDefinition):
+    type: Literal["id"] = Field("id", exclude=True)
+    id: int
+
+    @classmethod
+    def from_ids(cls, ids: Sequence[int]) -> list["InternalId"]:
+        return [cls(id=id_) for id_ in ids]
+
+    def __str__(self) -> str:
+        return f"id={self.id}"
+
+
+class ExternalId(InternalOrExternalIdDefinition):
+    type: Literal["externalId"] = Field("externalId", exclude=True)
+    external_id: str
+
+    @classmethod
+    def from_external_ids(cls, external_ids: list[str]) -> list["ExternalId"]:
+        return [cls(external_id=ext_id) for ext_id in external_ids]
+
+    def __str__(self) -> str:
+        return f"externalId='{self.external_id}'"
+
+
+InternalOrExternalId = Annotated[InternalId | ExternalId, Field(discriminator="type")]
+
+
+class NameId(Identifier):
+    name: str
+
+    def __str__(self) -> str:
+        return f"name='{self.name}'"
+
+
+class WorkflowVersionId(Identifier):
+    workflow_external_id: str
+    version: str
+
+    def __str__(self) -> str:
+        return f"workflowExternalId='{self.workflow_external_id}', version='{self.version}'"
+
+
+class DataSetId(Identifier):
+    data_set_id: int
+
+    def __str__(self) -> str:
+        return f"dataSetId={self.data_set_id}"

cognite_toolkit/_cdf_tk/client/{data_classes → resource_classes}/infield.py

@@ -4,13 +4,13 @@ from typing import Any, ClassVar, Literal
 from pydantic import JsonValue, field_validator
 from pydantic_core.core_schema import ValidationInfo
 
+from cognite_toolkit._cdf_tk.client._resource_base import BaseResourceList, ResponseResource
 from cognite_toolkit._cdf_tk.protocols import (
     ResourceRequestListProtocol,
     ResourceResponseListProtocol,
 )
 from cognite_toolkit._cdf_tk.utils.text import sanitize_instance_external_id
 
-from .base import BaseResourceList, ResponseResource
 from .instance_api import InstanceRequestResource, ViewReference
 
 if sys.version_info >= (3, 11):

cognite_toolkit/_cdf_tk/client/{data_classes → resource_classes}/instance_api.py

@@ -2,7 +2,7 @@ from typing import Any, ClassVar, Literal, TypeAlias
 
 from pydantic import ConfigDict, JsonValue, model_serializer
 
-from .base import BaseModelObject, Identifier, RequestResource
+from cognite_toolkit._cdf_tk.client._resource_base import BaseModelObject, Identifier, RequestResource
 
 InstanceType: TypeAlias = Literal["node", "edge"]
 
@@ -14,19 +14,38 @@ class TypedInstanceIdentifier(Identifier):
     space: str
     external_id: str
 
+    def __str__(self) -> str:
+        return f"Instance({self.instance_type}, {self.space}, {self.external_id})"
+
+    def dump(self, camel_case: bool = True, include_type: bool = True) -> dict[str, Any]:
+        """Dump the resource to a dictionary.
+
+        This is the default serialization method for request resources.
+        """
+        return self.model_dump(mode="json", by_alias=camel_case, exclude_unset=not include_type)
+
 
 class TypedNodeIdentifier(TypedInstanceIdentifier):
     instance_type: Literal["node"] = "node"
 
+    def __str__(self) -> str:
+        return f"Node({self.space}, {self.external_id})"
+
 
 class TypedEdgeIdentifier(TypedInstanceIdentifier):
     instance_type: Literal["edge"] = "edge"
 
+    def __str__(self) -> str:
+        return f"Edge({self.space}, {self.external_id})"
+
 
 class InstanceIdentifier(Identifier):
     space: str
     external_id: str
 
+    def __str__(self) -> str:
+        return f"Instance({self.space}, {self.external_id})"
+
 
 class InstanceResult(BaseModelObject):
     instance_type: InstanceType
@@ -51,6 +70,16 @@ class ViewReference(Identifier):
     external_id: str
     version: str
 
+    def __str__(self) -> str:
+        return f"View({self.space}, {self.external_id}, v{self.version})"
+
+    def dump(self, camel_case: bool = True, include_type: bool = True) -> dict[str, Any]:
+        """Dump the resource to a dictionary.
+
+        This is the default serialization method for request resources.
+        """
+        return self.model_dump(mode="json", by_alias=camel_case, exclude_unset=not include_type)
+
 
 ######################################################
 # The classes below are helper classes for making instances request/responses.
@@ -160,3 +189,8 @@ class InstanceResponseItem(BaseModelObject):
             space=self.space,
             external_id=self.external_id,
         )
+
+
+class NodeReference(BaseModelObject):
+    space: str
+    external_id: str

cognite_toolkit/_cdf_tk/client/resource_classes/label.py

@@ -0,0 +1,27 @@
+from cognite_toolkit._cdf_tk.client._resource_base import (
+    BaseModelObject,
+    RequestResource,
+    ResponseResource,
+)
+
+from .identifiers import ExternalId
+
+
+class Label(BaseModelObject):
+    external_id: str
+    name: str
+    description: str | None = None
+    data_set_id: int | None = None
+
+    def as_id(self) -> ExternalId:
+        return ExternalId(external_id=self.external_id)
+
+
+class LabelRequest(Label, RequestResource): ...
+
+
+class LabelResponse(Label, ResponseResource[LabelRequest]):
+    created_time: int
+
+    def as_request_resource(self) -> LabelRequest:
+        return LabelRequest.model_validate(self.dump(), extra="ignore")

cognite_toolkit/_cdf_tk/client/{data_classes → resource_classes}/legacy/canvas.py

@@ -1,5 +1,6 @@
 import sys
 from abc import ABC
+from collections import defaultdict
 from collections.abc import Sequence
 from datetime import datetime, timezone
 from typing import Any, TypeVar
@@ -30,7 +31,7 @@ from cognite.client.data_classes.data_modeling.instances import (
     TypedNodeApply,
 )
 
-from cognite_toolkit._cdf_tk.client.data_classes.legacy.migration import AssetCentricId
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.migration import AssetCentricId
 from cognite_toolkit._cdf_tk.utils.useful_types import JsonVal
 
 if sys.version_info >= (3, 11):
@@ -905,54 +906,86 @@ class IndustrialCanvasApply(CogniteResource):
                 raise TypeError(f"Unexpected instance type: {type(instance)}")
         return ids
 
-    def dump(self, keep_existing_version: bool = True) -> dict[str, JsonVal]:
+    def dump(self, camel_case: bool = True, keep_existing_version: bool = True) -> dict[str, JsonVal]:
         """Dump the IndustrialCanvasApply to a dictionary."""
         return {
-            "canvas": self.canvas.dump(keep_existing_version=keep_existing_version),
+            "canvas": self.canvas.dump(camel_case=camel_case, keep_existing_version=keep_existing_version),
             "annotations": [
-                annotation.dump(keep_existing_version=keep_existing_version) for annotation in self.annotations
+                annotation.dump(camel_case=camel_case, keep_existing_version=keep_existing_version)
+                for annotation in self.annotations
             ],
             "containerReferences": [
-                container_ref.dump(keep_existing_version=keep_existing_version)
+                container_ref.dump(camel_case=camel_case, keep_existing_version=keep_existing_version)
                 for container_ref in self.container_references
             ],
             "fdmInstanceContainerReferences": [
-                fdm_instance_container_ref.dump(keep_existing_version=keep_existing_version)
+                fdm_instance_container_ref.dump(camel_case=camel_case, keep_existing_version=keep_existing_version)
                 for fdm_instance_container_ref in self.fdm_instance_container_references
             ],
             "solutionTags": [
-                solution_tag.dump(keep_existing_version=keep_existing_version) for solution_tag in self.solution_tags
+                solution_tag.dump(camel_case=camel_case, keep_existing_version=keep_existing_version)
+                for solution_tag in self.solution_tags
             ],
         }
 
     def create_backup(self) -> "IndustrialCanvasApply":
-        """Create a duplicate of the IndustrialCanvasApply instance."""
+        """Create a backup copy of the IndustrialCanvasApply instance with new IDs."""
         new_canvas_id = str(uuid4())
+
         new_canvas = CanvasApply._load(self.canvas.dump(keep_existing_version=False))
         new_canvas.external_id = new_canvas_id
         new_canvas.source_canvas_id = self.canvas.external_id
         new_canvas.updated_at = datetime.now(tz=timezone.utc)
         # Solution tags are not duplicated, they are reused
-        new_container = IndustrialCanvasApply(new_canvas, [], [], [], solution_tags=self.solution_tags)
+        canvas_backup = IndustrialCanvasApply(new_canvas, [], [], [], solution_tags=self.solution_tags)
         items: list[ContainerReferenceApply] | list[CanvasAnnotationApply] | list[FdmInstanceContainerReferenceApply]
         item_cls: type[CanvasAnnotationApply] | type[ContainerReferenceApply] | type[FdmInstanceContainerReferenceApply]
         new_item_list: list[NodeApply]
+        generator: dict[str, str] = defaultdict(lambda: str(uuid4()))
         for items, item_cls, new_item_list in [  # type: ignore[assignment]
-            (self.annotations, CanvasAnnotationApply, new_container.annotations),
-            (self.container_references, ContainerReferenceApply, new_container.container_references),
+            (self.annotations, CanvasAnnotationApply, canvas_backup.annotations),
+            (self.container_references, ContainerReferenceApply, canvas_backup.container_references),
             (
                 self.fdm_instance_container_references,
                 FdmInstanceContainerReferenceApply,
-                new_container.fdm_instance_container_references,
+                canvas_backup.fdm_instance_container_references,
             ),
         ]:
             for item in items:
                 # Serialize the item to create a new instance
                 new_item = item_cls._load(item.dump(keep_existing_version=False))
-                new_item.id_ = str(uuid4())
-                new_item.external_id = f"{new_canvas_id}_{new_item.external_id}"
+                new_item.id_ = generator[new_item.id_]
+                new_item.external_id = f"{new_canvas_id}_{new_item.id_}"
                 new_item_list.append(new_item)
-        return new_container
+
+        return canvas_backup.replace_ids(generator)
+
+    def replace_ids(self, id_mapping_old_by_new: dict[str, str]) -> "IndustrialCanvasApply":
+        """Replace IDs in the IndustrialCanvasApply instance based on the provided ID mapping.
+
+        Args:
+            id_mapping_old_by_new: A dictionary mapping old IDs to new IDs.
+        Returns:
+            A new IndustrialCanvasApply instance with IDs replaced according to the mapping.
+        """
+        # There can be references to the old IDs in properties, for example, in annotations
+        # the properties field there can be fromId and toId set.
+        # We don't know all the places the Canvas application will have undocumented references,
+        # so we do a recursive search and replace based on the id mapping we have created.
+        dumped_data = self.dump(camel_case=True)
+
+        def _replace_ids_recursively(data: Any, id_map: dict[str, str]) -> Any:
+            if isinstance(data, dict):
+                return {key: _replace_ids_recursively(value, id_map) for key, value in data.items()}
+            if isinstance(data, list):
+                return [_replace_ids_recursively(item, id_map) for item in data]
+            if isinstance(data, str) and data in id_map:
+                return id_map[data]
+            return data
+
+        updated_data = _replace_ids_recursively(dumped_data, id_mapping_old_by_new)
+
+        return IndustrialCanvasApply._load(updated_data)
 
     @classmethod
     def _load(cls, resource: dict[str, Any], cognite_client: CogniteClient | None = None) -> Self:

cognite_toolkit/_cdf_tk/client/{data_classes → resource_classes}/legacy/charts.py

@@ -9,7 +9,7 @@ from cognite.client.data_classes._base import (
     WriteableCogniteResourceList,
 )
 
-from cognite_toolkit._cdf_tk.client.data_classes.charts_data import ChartData
+from cognite_toolkit._cdf_tk.client.resource_classes.charts_data import ChartData
 
 if sys.version_info >= (3, 11):
     from typing import Self

cognite_toolkit/_cdf_tk/client/resource_classes/location_filter.py

@@ -0,0 +1,84 @@
+from typing import Literal
+
+from pydantic import Field
+
+from cognite_toolkit._cdf_tk.client._resource_base import BaseModelObject, RequestResource, ResponseResource
+
+from .data_modeling import DataModelReference
+from .identifiers import ExternalId, InternalId
+
+
+class LocationFilterScene(BaseModelObject):
+    """Scene configuration for a location filter."""
+
+    external_id: str
+    space: str
+
+
+class LocationFilterView(BaseModelObject):
+    """View identifier with entity type for location filter."""
+
+    external_id: str
+    space: str
+    version: str
+    represents_entity: Literal["MAINTENANCE_ORDER", "OPERATION", "NOTIFICATION", "ASSET"] | None = None
+
+
+class AssetCentricSubFilter(BaseModelObject):
+    """Sub-filter for asset-centric resource types."""
+
+    data_set_ids: list[int] | None = None
+    asset_subtree_ids: list[ExternalId | InternalId] | None = None
+    external_id_prefix: str | None = None
+
+
+class AssetCentricFilter(BaseModelObject):
+    """Filter definition for asset-centric resource types."""
+
+    assets: AssetCentricSubFilter | None = None
+    events: AssetCentricSubFilter | None = None
+    files: AssetCentricSubFilter | None = None
+    timeseries: AssetCentricSubFilter | None = None
+    sequences: AssetCentricSubFilter | None = None
+    data_set_ids: list[int] | None = None
+    asset_subtree_ids: list[ExternalId | InternalId] | None = None
+    external_id_prefix: str | None = None
+
+
+class LocationFilter(BaseModelObject):
+    """Base class for location filter with common fields."""
+
+    external_id: str
+    name: str
+    description: str | None = None
+    parent_id: int | None = None
+    data_models: list[DataModelReference] | None = None
+    instance_spaces: list[str] | None = None
+    scene: LocationFilterScene | None = None
+    asset_centric: AssetCentricFilter | None = None
+    views: list[LocationFilterView] | None = None
+    data_modeling_type: Literal["HYBRID", "DATA_MODELING_ONLY"] | None = None
+
+
+class LocationFilterRequest(LocationFilter, RequestResource):
+    """Request resource for creating/updating location filters."""
+
+    # This is not part of the request payload, but we need it to identify existing resources for updates.
+    id: int | None = Field(default=None, exclude=True)
+
+    def as_id(self) -> InternalId:
+        if self.id is None:
+            raise ValueError("Cannot get ID for LocationFilterRequest without 'id' set.")
+        return InternalId(id=self.id)
+
+
+class LocationFilterResponse(LocationFilter, ResponseResource[LocationFilterRequest]):
+    """Response resource for location filters."""
+
+    id: int
+    created_time: int
+    updated_time: int
+    locations: list["LocationFilterResponse"] | None = None
+
+    def as_request_resource(self) -> LocationFilterRequest:
+        return LocationFilterRequest.model_validate(self.dump(), extra="ignore")

cognite_toolkit/_cdf_tk/client/resource_classes/raw.py

@@ -0,0 +1,44 @@
+import sys
+
+from pydantic import Field
+
+from cognite_toolkit._cdf_tk.client._resource_base import (
+    Identifier,
+    RequestResource,
+    ResponseResource,
+)
+
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
+
+class RAWDatabase(RequestResource, Identifier, ResponseResource["RAWDatabase"]):
+    name: str
+
+    def as_id(self) -> Self:
+        return self
+
+    def __str__(self) -> str:
+        return f"name='{self.name}'"
+
+    def as_request_resource(self) -> "RAWDatabase":
+        return type(self).model_validate(self.dump(), extra="ignore")
+
+
+class RAWTable(RequestResource, Identifier, ResponseResource["RAWTable"]):
+    # This is a query parameter, so we exclude it from serialization.
+    # Default to empty string to allow parsing from API responses (which don't include db_name).
+    db_name: str = Field(default="", exclude=True)
+    name: str
+
+    def as_id(self) -> Self:
+        return self
+
+    def __str__(self) -> str:
+        return f"dbName='{self.db_name}', tableName='{self.name}'"
+
+    def as_request_resource(self) -> "RAWTable":
+        dumped = {**self.dump(), "dbName": self.db_name}
+        return type(self).model_validate(dumped, extra="ignore")

cognite_toolkit/_cdf_tk/client/resource_classes/relationship.py

@@ -0,0 +1,49 @@
+from typing import ClassVar, Literal
+
+from cognite_toolkit._cdf_tk.client._resource_base import (
+    BaseModelObject,
+    ResponseResource,
+    UpdatableRequestResource,
+)
+
+from .identifiers import ExternalId
+
+
+class LabelRef(BaseModelObject):
+    """Reference to a label."""
+
+    external_id: str
+
+
+class Relationship(BaseModelObject):
+    """Base class for relationship with common fields."""
+
+    external_id: str
+    source_external_id: str
+    source_type: Literal["asset", "timeSeries", "file", "event", "sequence"]
+    target_external_id: str
+    target_type: Literal["asset", "timeSeries", "file", "event", "sequence"]
+    start_time: int | None = None
+    end_time: int | None = None
+    confidence: float | None = None
+    data_set_id: int | None = None
+    labels: list[LabelRef] | None = None
+
+
+class RelationshipRequest(Relationship, UpdatableRequestResource):
+    """Request resource for creating/updating relationships."""
+
+    container_fields: ClassVar[frozenset[str]] = frozenset({"labels"})
+
+    def as_id(self) -> ExternalId:
+        return ExternalId(external_id=self.external_id)
+
+
+class RelationshipResponse(Relationship, ResponseResource[RelationshipRequest]):
+    """Response resource for relationships."""
+
+    created_time: int
+    last_updated_time: int
+
+    def as_request_resource(self) -> RelationshipRequest:
+        return RelationshipRequest.model_validate(self.dump(), extra="ignore")

cognite_toolkit/_cdf_tk/client/resource_classes/resource_view_mapping.py

@@ -0,0 +1,38 @@
+from typing import ClassVar, Literal
+
+from cognite_toolkit._cdf_tk.client._resource_base import (
+    BaseModelObject,
+    RequestResource,
+    ResponseResource,
+)
+
+from .data_modeling import ViewReference
+from .identifiers import ExternalId
+
+
+class ResourceViewMapping(BaseModelObject):
+    space: ClassVar[str] = "cognite_migration"
+    view_ref: ClassVar[ViewReference] = ViewReference(
+        space="cognite_migration", external_id="ResourceViewMapping", version="v1"
+    )
+    instance_type: Literal["node"] = "node"
+    external_id: str
+    resource_type: str
+    view_id: ViewReference
+    property_mapping: dict[str, str]
+
+    def as_id(self) -> ExternalId:
+        return ExternalId(external_id=self.external_id)
+
+
+class ResourceViewMappingRequest(ResourceViewMapping, RequestResource):
+    existing_version: int | None = None
+
+
+class ResourceViewMappingResponse(ResourceViewMapping, ResponseResource[ResourceViewMappingRequest]):
+    version: int
+    created_time: int
+    last_updated_time: int
+
+    def as_request_resource(self) -> ResourceViewMappingRequest:
+        return ResourceViewMappingRequest.model_validate(self.dump(), extra="ignore")