cognite-toolkit 0.5.44__py3-none-any.whl → 0.7.34__py3-none-any.whl

cognite_toolkit/_cdf_tk/client/data_classes/capabilities.py

@@ -0,0 +1,170 @@
+from typing import TypeVar
+
+from cognite.client.data_classes.capabilities import (
+    AllScope,
+    AppConfigScope,
+    AssetRootIDScope,
+    Capability,
+    CurrentUserScope,
+    DataSetScope,
+    ExperimentsScope,
+    ExtractionPipelineScope,
+    IDScope,
+    IDScopeLowerCase,
+    InstancesScope,
+    LegacyDataModelScope,
+    LegacySpaceScope,
+    PartitionScope,
+    PostgresGatewayUsersScope,
+    SpaceIDScope,
+    TableScope,
+)
+
+T_Scope = TypeVar("T_Scope", bound=Capability.Scope)
+
+
+def scope_intersection(scope1: T_Scope, scope2: T_Scope | None) -> Capability.Scope | None:
+    """Returns the intersection of two scopes.
+    If both scopes are None, returns None.
+    If one scope is None, returns None (intersection with nothing is nothing).
+    If both scopes are the same, returns that scope.
+    If scopes are different types, raise an ValueError.
+    """
+    if scope2 is None:
+        return None
+    if type(scope1) is not type(scope2):
+        raise ValueError("Cannot intersect scopes of different types")
+    if isinstance(scope1, AllScope) and isinstance(scope2, AllScope):
+        return AllScope()
+    elif isinstance(scope1, AppConfigScope) and isinstance(scope2, AppConfigScope):
+        if apps := sorted(set(scope1.apps) & set(scope2.apps)):
+            return AppConfigScope(apps=apps)
+        return None
+    elif isinstance(scope1, DataSetScope) and isinstance(scope2, DataSetScope):
+        if ids := sorted(set(scope1.ids) & set(scope2.ids)):
+            return DataSetScope(ids=ids)
+        return None
+    elif isinstance(scope1, IDScope) and isinstance(scope2, IDScope):
+        if ids := sorted(set(scope1.ids) & set(scope2.ids)):
+            return IDScope(ids=ids)
+        return None
+    elif isinstance(scope1, IDScopeLowerCase) and isinstance(scope2, IDScopeLowerCase):
+        if ids := sorted(set(scope1.ids) & set(scope2.ids)):
+            return IDScopeLowerCase(ids=ids)
+        return None
+    elif isinstance(scope1, SpaceIDScope) and isinstance(scope2, SpaceIDScope):
+        if intersection_space_ids := sorted(set(scope1.space_ids) & set(scope2.space_ids)):
+            return SpaceIDScope(space_ids=intersection_space_ids)
+        return None
+    elif isinstance(scope1, AssetRootIDScope) and isinstance(scope2, AssetRootIDScope):
+        if intersection_root_ids := sorted(set(scope1.root_ids) & set(scope2.root_ids)):
+            return AssetRootIDScope(root_ids=intersection_root_ids)
+        return None
+    elif isinstance(scope1, CurrentUserScope) and isinstance(scope2, CurrentUserScope):
+        return CurrentUserScope()
+    elif isinstance(scope1, ExtractionPipelineScope) and isinstance(scope2, ExtractionPipelineScope):
+        if intersection_ids := sorted(set(scope1.ids) & set(scope2.ids)):
+            return ExtractionPipelineScope(ids=intersection_ids)
+        return None
+    elif isinstance(scope1, TableScope) and isinstance(scope2, TableScope):
+        intersection_tables = set(scope1.dbs_to_tables.keys()) & set(scope2.dbs_to_tables.keys())
+        if intersection_tables:
+            return TableScope(
+                dbs_to_tables={
+                    db: sorted(set(scope1.dbs_to_tables[db]) & set(scope2.dbs_to_tables[db]))
+                    for db in sorted(intersection_tables)
+                }
+            )
+        return None
+    elif isinstance(scope1, InstancesScope) and isinstance(scope2, InstancesScope):
+        if intersection_instances := sorted(set(scope1.instances) & set(scope2.instances)):
+            return InstancesScope(instances=intersection_instances)
+        return None
+    elif isinstance(scope1, PartitionScope) and isinstance(scope2, PartitionScope):
+        if intersection_partition_ids := sorted(set(scope1.partition_ids) & set(scope2.partition_ids)):
+            return PartitionScope(partition_ids=intersection_partition_ids)
+        return None
+    elif isinstance(scope1, LegacySpaceScope) and isinstance(scope2, LegacySpaceScope):
+        if intersection_external_ids := sorted(set(scope1.external_ids) & set(scope2.external_ids)):
+            return LegacySpaceScope(external_ids=intersection_external_ids)
+        return None
+    elif isinstance(scope1, LegacyDataModelScope) and isinstance(scope2, LegacyDataModelScope):
+        if intersection_external_ids := sorted(set(scope1.external_ids) & set(scope2.external_ids)):
+            return LegacyDataModelScope(external_ids=intersection_external_ids)
+        return None
+    elif isinstance(scope1, ExperimentsScope) and isinstance(scope2, ExperimentsScope):
+        if intersection_experiments := sorted(set(scope1.experiments) & set(scope2.experiments)):
+            return ExperimentsScope(experiments=intersection_experiments)
+        return None
+    elif isinstance(scope1, PostgresGatewayUsersScope) and isinstance(scope2, PostgresGatewayUsersScope):
+        if intersection_usernames := sorted(set(scope1.usernames) & set(scope2.usernames)):
+            return PostgresGatewayUsersScope(usernames=intersection_usernames)
+        return None
+    else:
+        raise TypeError(f"Unknown scope type {type(scope1)!r}")
+
+
+def scope_union(scope1: T_Scope, scope2: T_Scope | None) -> Capability.Scope:
+    """
+    Returns the union of two scopes.
+    If both scopes are None, returns None.
+    If one scope is None, returns the other scope.
+    If both scopes are the same, returns the union of the two scopes.
+    If scopes are different types, raise an ValueError.
+    """
+    if scope2 is None:
+        return scope1
+    if type(scope1) is not type(scope2):
+        raise ValueError("Cannot union scopes of different types")
+    if isinstance(scope1, AllScope) or isinstance(scope2, AllScope):
+        return AllScope()
+    elif isinstance(scope1, AppConfigScope) and isinstance(scope2, AppConfigScope):
+        return AppConfigScope(apps=sorted(set(scope1.apps) | set(scope2.apps)))
+    elif isinstance(scope1, DataSetScope) and isinstance(scope2, DataSetScope):
+        return DataSetScope(ids=sorted(set(scope1.ids) | set(scope2.ids)))
+    elif isinstance(scope1, IDScope) and isinstance(scope2, IDScope):
+        return IDScope(ids=sorted(set(scope1.ids) | set(scope2.ids)))
+    elif isinstance(scope1, IDScopeLowerCase) and isinstance(scope2, IDScopeLowerCase):
+        return IDScopeLowerCase(ids=sorted(set(scope1.ids) | set(scope2.ids)))
+    elif isinstance(scope1, SpaceIDScope) and isinstance(scope2, SpaceIDScope):
+        return SpaceIDScope(space_ids=sorted(set(scope1.space_ids) | set(scope2.space_ids)))
+    elif isinstance(scope1, AssetRootIDScope) and isinstance(scope2, AssetRootIDScope):
+        return AssetRootIDScope(root_ids=sorted(set(scope1.root_ids) | set(scope2.root_ids)))
+    elif isinstance(scope1, CurrentUserScope) and isinstance(scope2, CurrentUserScope):
+        return CurrentUserScope()
+    elif isinstance(scope1, ExtractionPipelineScope) and isinstance(scope2, ExtractionPipelineScope):
+        return ExtractionPipelineScope(ids=sorted(set(scope1.ids) | set(scope2.ids)))
+    elif isinstance(scope1, TableScope) and isinstance(scope2, TableScope):
+        union_tables = set(scope1.dbs_to_tables.keys()) | set(scope2.dbs_to_tables.keys())
+        return TableScope(
+            dbs_to_tables={
+                db: sorted(set(scope1.dbs_to_tables.get(db, [])) | set(scope2.dbs_to_tables.get(db, [])))
+                for db in sorted(union_tables)
+            }
+        )
+    elif isinstance(scope1, InstancesScope) and isinstance(scope2, InstancesScope):
+        return InstancesScope(
+            instances=sorted(set(scope1.instances) | set(scope2.instances)),
+        )
+    elif isinstance(scope1, PartitionScope) and isinstance(scope2, PartitionScope):
+        return PartitionScope(
+            partition_ids=sorted(set(scope1.partition_ids) | set(scope2.partition_ids)),
+        )
+    elif isinstance(scope1, LegacySpaceScope) and isinstance(scope2, LegacySpaceScope):
+        return LegacySpaceScope(
+            external_ids=sorted(set(scope1.external_ids) | set(scope2.external_ids)),
+        )
+    elif isinstance(scope1, LegacyDataModelScope) and isinstance(scope2, LegacyDataModelScope):
+        return LegacyDataModelScope(
+            external_ids=sorted(set(scope1.external_ids) | set(scope2.external_ids)),
+        )
+    elif isinstance(scope1, ExperimentsScope) and isinstance(scope2, ExperimentsScope):
+        return ExperimentsScope(
+            experiments=sorted(set(scope1.experiments) | set(scope2.experiments)),
+        )
+    elif isinstance(scope1, PostgresGatewayUsersScope) and isinstance(scope2, PostgresGatewayUsersScope):
+        return PostgresGatewayUsersScope(
+            usernames=sorted(set(scope1.usernames) | set(scope2.usernames)),
+        )
+    else:
+        raise TypeError(f"Unknown scope type {type(scope1)!r}")

cognite_toolkit/_cdf_tk/client/data_classes/charts.py

@@ -0,0 +1,114 @@
+import sys
+from abc import ABC
+from typing import Any, Literal, TypeAlias
+
+from cognite.client import CogniteClient
+from cognite.client.data_classes._base import (
+    CogniteResourceList,
+    WriteableCogniteResource,
+    WriteableCogniteResourceList,
+)
+
+from cognite_toolkit._cdf_tk.client.data_classes.charts_data import ChartData
+
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
+Visibility: TypeAlias = Literal["PUBLIC", "PRIVATE"]
+
+
+class ChartCore(WriteableCogniteResource["ChartWrite"], ABC):
+    """Base class for the Chart data model.
+
+    Args:
+        external_id (str): Unique identifier for the chart.
+        visibility (Visibility): Visibility of the chart, either 'PUBLIC' or 'PRIVATE'.
+        data (ChartData): The data associated with the chart.
+    """
+
+    def __init__(self, external_id: str, visibility: Visibility, data: ChartData) -> None:
+        self.external_id = external_id
+        self.visibility = visibility
+        self.data = data
+
+    def dump(self, camel_case: bool = True) -> dict[str, Any]:
+        """Convert the chart to a dictionary representation."""
+        output = super().dump(camel_case=camel_case)
+        output["data"] = self.data.model_dump(mode="json", by_alias=camel_case, exclude_unset=True)
+        return output
+
+
+class ChartWrite(ChartCore):
+    """A chart that can be written to the CDF.
+
+    Args:
+        external_id (str): Unique identifier for the chart.
+        visibility (Visibility): Visibility of the chart, either 'PUBLIC' or 'PRIVATE'.
+        data (ChartData): The data associated with the chart.
+
+    """
+
+    def as_write(self) -> "ChartWrite":
+        return self
+
+    @classmethod
+    def _load(cls, resource: dict[str, Any], cognite_client: CogniteClient | None = None) -> Self:
+        return cls(
+            external_id=resource["externalId"],
+            visibility=resource["visibility"],
+            data=ChartData._load(resource["data"]),
+        )
+
+
+class Chart(ChartCore):
+    """A chart that can be read from the CDF.
+
+    Args:
+        external_id (str): Unique identifier for the chart.
+        created_time (int): Timestamp when the chart was created.
+        last_updated_time (int): Timestamp when the chart was last updated.
+        visibility (Visibility): Visibility of the chart, either 'PUBLIC' or 'PRIVATE'.
+        data (ChartData): The data associated with the chart.
+        owner_id (str): The ID of the user who owns the chart.
+    """
+
+    def __init__(
+        self,
+        external_id: str,
+        created_time: int,
+        last_updated_time: int,
+        visibility: Visibility,
+        data: ChartData,
+        owner_id: str,
+    ) -> None:
+        super().__init__(external_id, visibility, data)
+        self.created_time = created_time
+        self.last_updated_time = last_updated_time
+        self.owner_id = owner_id
+
+    def as_write(self) -> ChartWrite:
+        return ChartWrite(external_id=self.external_id, visibility=self.visibility, data=self.data)
+
+    @classmethod
+    def _load(cls, resource: dict[str, Any], cognite_client: CogniteClient | None = None) -> Self:
+        return cls(
+            external_id=resource["externalId"],
+            created_time=resource["createdTime"],
+            last_updated_time=resource["lastUpdatedTime"],
+            visibility=resource["visibility"],
+            data=ChartData._load(resource["data"]),
+            owner_id=resource["ownerId"],
+        )
+
+
+class ChartWriteList(CogniteResourceList):
+    _RESOURCE = ChartWrite
+
+
+class ChartList(WriteableCogniteResourceList[ChartWrite, Chart]):
+    _RESOURCE = Chart
+
+    def as_write(self) -> ChartWriteList:
+        return ChartWriteList([item.as_write() for item in self])

cognite_toolkit/_cdf_tk/client/data_classes/charts_data.py

@@ -0,0 +1,184 @@
+from typing import Any
+
+from cognite.client.data_classes.data_modeling import NodeId, ViewId
+from pydantic import JsonValue, field_serializer, field_validator
+
+from .base import BaseModelObject
+
+
+class UserInfo(BaseModelObject):
+    id: str | None = None
+    email: str | None = None
+    display_name: str | None = None
+
+
+class ChartSettings(BaseModelObject):
+    show_y_axis: bool = True
+    show_min_max: bool = True
+    show_gridlines: bool = True
+    merge_units: bool = False
+
+
+class ThresholdFilter(BaseModelObject):
+    min_unit: str | None = None
+    max_unit: str | None = None
+
+
+class ChartCall(BaseModelObject):
+    id: str | None = None
+    hash: int | None = None
+    call_id: str | None = None
+    call_date: int | None = None
+    status: str | None = None
+
+
+class SubSetting(BaseModelObject):
+    auto_align: bool | None = None
+
+
+class ChartPosition(BaseModelObject):
+    x: float | None = None
+    y: float | None = None
+
+
+class FlowElement(BaseModelObject):
+    id: str | None = None
+    type: str | None = None
+    position: ChartPosition | None = None
+    data: JsonValue | None = None
+    source: str | None = None
+    target: str | None = None
+    source_handle: str | None = None
+    target_handle: str | None = None
+
+
+class Flow(BaseModelObject):
+    zoom: float | None = None
+    elements: list[FlowElement] | None = None
+    position: tuple[float | None, float | None] | None = None
+
+
+class ChartElement(BaseModelObject):
+    id: str | None = None
+    type: str | None = None
+
+
+class ChartSource(ChartElement): ...
+
+
+class ChartCoreTimeseries(ChartElement):
+    node_reference: NodeId | None = None
+    view_reference: ViewId | None = None
+    display_mode: str | None = None
+    color: str | None = None
+    created_at: int | None = None
+    enabled: bool | None = None
+    interpolation: str | None = None
+    line_style: str | None = None
+    line_weight: float | None = None
+    name: str | None = None
+    preferred_unit: str | None = None
+    range: list[float | None] | None = None
+
+    @field_serializer("node_reference", when_used="always")
+    def serialize_node_reference(self, node_reference: NodeId | None) -> dict[str, Any] | None:
+        if node_reference:
+            return node_reference.dump(include_instance_type=False)
+        return None
+
+    @field_serializer("view_reference", when_used="always")
+    def serialize_view_reference(self, view_reference: ViewId | None) -> dict[str, Any] | None:
+        if view_reference:
+            return view_reference.dump(include_type=False)
+        return None
+
+    @field_validator("node_reference", mode="before")
+    @classmethod
+    def validate_node_reference(cls, value: Any) -> NodeId | None:
+        if value is None or isinstance(value, NodeId):
+            return value
+        return NodeId.load(value)
+
+    @field_validator("view_reference", mode="before")
+    @classmethod
+    def validate_view_reference(cls, value: Any) -> ViewId | None:
+        if value is None or isinstance(value, ViewId):
+            return value
+        return ViewId.load(value)
+
+
+class ChartTimeseries(ChartElement):
+    color: str | None = None
+    created_at: int | None = None
+    enabled: bool | None = None
+    interpolation: str | None = None
+    line_style: str | None = None
+    line_weight: float | None = None
+    name: str | None = None
+    preferred_unit: str | None = None
+    range: list[float | None] | None = None
+    unit: str | None = None
+    ts_id: int | None = None
+    ts_external_id: str | None = None
+    display_mode: str | None = None
+    original_unit: str | None = None
+    description: str | None = None
+
+
+class ChartWorkflow(ChartElement):
+    version: str | None = None
+    name: str | None = None
+    color: str | None = None
+    enabled: bool | None = None
+    line_weight: float | None = None
+    line_style: str | None = None
+    interpolation: str | None = None
+    unit: str | None = None
+    preferred_unit: str | None = None
+    range: list[float | None] | None = None
+    created_at: int | None = None
+    settings: SubSetting | None = None
+    flow: Flow | None = None
+    calls: list[ChartCall] | None = None
+
+
+class ChartThreshold(ChartElement):
+    visible: bool | None = None
+    name: str | None = None
+    source_id: str | None = None
+    upper_limit: float | None = None
+    filter: ThresholdFilter | None = None
+    calls: list[ChartCall] | None = None
+
+
+class ChartScheduledCalculation(ChartElement):
+    color: str | None = None
+    created_at: int | None = None
+    description: str | None = None
+    enabled: bool | None = None
+    interpolation: str | None = None
+    line_style: str | None = None
+    line_weight: float | None = None
+    name: str | None = None
+    preferred_unit: str | None = None
+    range: list[float | None] | None = None
+    unit: str | None = None
+    version: str | None = None
+    settings: SubSetting | None = None
+    flow: Flow | None = None
+
+
+class ChartData(BaseModelObject):
+    version: int | None = None
+    name: str | None = None
+    date_from: str | None = None
+    date_to: str | None = None
+    user_info: UserInfo | None = None
+    live_mode: bool | None = None
+    time_series_collection: list[ChartTimeseries] | None = None
+    core_timeseries_collection: list[ChartCoreTimeseries] | None = None
+    workflow_collection: list[ChartWorkflow] | None = None
+    source_collection: list[ChartSource] | None = None
+    threshold_collection: list[ChartThreshold] | None = None
+    scheduled_calculation_collection: list[ChartScheduledCalculation] | None = None
+    settings: ChartSettings | None = None

cognite_toolkit/_cdf_tk/client/data_classes/extendable_cognite_file.py

@@ -1,6 +1,5 @@
-from __future__ import annotations
-
 import itertools
+import sys
 from datetime import datetime
 from typing import Any, Literal
 
@@ -10,6 +9,11 @@ from cognite.client.data_classes.data_modeling import DirectRelationReference, V
 from cognite.client.data_classes.data_modeling.cdm.v1 import CogniteFile, CogniteFileApply
 from cognite.client.utils._text import to_camel_case
 
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
 
 class ExtendableCogniteFileApply(CogniteFileApply):
     def __init__(
@@ -118,7 +122,7 @@ class ExtendableCogniteFileApply(CogniteFileApply):
         return output
 
     @classmethod
-    def _load(cls, resource: dict[str, Any], cognite_client: CogniteClient | None = None) -> ExtendableCogniteFileApply:
+    def _load(cls, resource: dict[str, Any], cognite_client: CogniteClient | None = None) -> Self:
         base_props = cls._load_base_properties(resource)
         properties = cls._load_properties(resource)
         loaded_keys = {to_camel_case(p) for p in itertools.chain(base_props.keys(), properties.keys())} | {
@@ -198,7 +202,7 @@ class ExtendableCogniteFile(CogniteFile):
         return ViewId(space="cdf_cdm", external_id="CogniteFile", version="v1")
 
     @classmethod
-    def _load(cls, resource: dict[str, Any], cognite_client: CogniteClient | None = None) -> ExtendableCogniteFile:
+    def _load(cls, resource: dict[str, Any], cognite_client: CogniteClient | None = None) -> Self:
         base_props = cls._load_base_properties(resource)
         all_properties = resource.get("properties", {})
         # There should only be one source in one view

cognite_toolkit/_cdf_tk/client/data_classes/extended_filemetadata.py

@@ -0,0 +1,108 @@
+import sys
+from collections.abc import Sequence
+from typing import Any
+
+from cognite.client import CogniteClient
+from cognite.client.data_classes import GeoLocation, Label
+from cognite.client.data_classes.data_modeling import NodeId
+from cognite.client.data_classes.files import FileMetadata, FileMetadataList
+
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
+
+class ExtendedFileMetadata(FileMetadata):
+    """Extended FileMetadata with pending instance ID support.
+    Args:
+        external_id (str | None): The external ID provided by the client. Must be unique for the resource type.
+        instance_id (NodeId | None): The Instance ID for the file. (Only applicable for files created in DMS)
+        name (str | None): Name of the file.
+        source (str | None): The source of the file.
+        mime_type (str | None): File type. E.g., text/plain, application/pdf, ...
+        metadata (dict[str, str] | None): Custom, application-specific metadata. String key -> String value. Limits: Maximum length of key is 32 bytes, value 512 bytes, up to 16 key-value pairs.
+        directory (str | None): Directory associated with the file. It must be an absolute, unix-style path.
+        asset_ids (Sequence[int] | None): No description.
+        data_set_id (int | None): The dataSet ID for the item.
+        labels (Sequence[Label] | None): A list of the labels associated with this resource item.
+        geo_location (GeoLocation | None): The geographic metadata of the file.
+        source_created_time (int | None): The timestamp for when the file was originally created in the source system.
+        source_modified_time (int | None): The timestamp for when the file was last modified in the source system.
+        security_categories (Sequence[int] | None): The security category IDs required to access this file.
+        id (int | None): A server-generated ID for the object.
+        uploaded (bool | None): Whether the actual file is uploaded. This field is returned only by the API, it has no effect in a post body.
+        uploaded_time (int | None): The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
+        created_time (int | None): The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
+        last_updated_time (int | None): The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
+        pending_instance_id( NodeId | None): The pending instance ID for the file, used in upgrading files from asset centric to data modeling.
+        cognite_client (CogniteClient | None): The client to associate with this object.
+    """
+
+    def __init__(
+        self,
+        external_id: str | None = None,
+        instance_id: NodeId | None = None,
+        name: str | None = None,
+        source: str | None = None,
+        mime_type: str | None = None,
+        metadata: dict[str, str] | None = None,
+        directory: str | None = None,
+        asset_ids: Sequence[int] | None = None,
+        data_set_id: int | None = None,
+        labels: Sequence[Label] | None = None,
+        geo_location: GeoLocation | None = None,
+        source_created_time: int | None = None,
+        source_modified_time: int | None = None,
+        security_categories: Sequence[int] | None = None,
+        id: int | None = None,
+        uploaded: bool | None = None,
+        uploaded_time: int | None = None,
+        created_time: int | None = None,
+        last_updated_time: int | None = None,
+        pending_instance_id: NodeId | None = None,
+        cognite_client: CogniteClient | None = None,
+    ) -> None:
+        super().__init__(
+            external_id=external_id,
+            instance_id=instance_id,
+            name=name,
+            directory=directory,
+            source=source,
+            mime_type=mime_type,
+            metadata=metadata,
+            asset_ids=asset_ids,
+            data_set_id=data_set_id,
+            labels=labels,
+            geo_location=geo_location,
+            source_created_time=source_created_time,
+            source_modified_time=source_modified_time,
+            security_categories=security_categories,
+            id=id,
+            uploaded=uploaded,
+            uploaded_time=uploaded_time,
+            created_time=created_time,
+            last_updated_time=last_updated_time,
+            cognite_client=cognite_client,
+        )
+        self.pending_instance_id = pending_instance_id
+
+    @classmethod
+    def _load(cls, resource: dict[str, Any], cognite_client: CogniteClient | None = None) -> Self:
+        instance = super()._load(resource, cognite_client)
+        if isinstance(instance.pending_instance_id, dict):
+            instance.pending_instance_id = NodeId.load(instance.pending_instance_id)
+        return instance
+
+    def dump(self, camel_case: bool = True) -> dict[str, Any]:
+        """Dump the object to a dictionary"""
+        output = super().dump(camel_case=camel_case)
+        if self.pending_instance_id is not None:
+            output["pendingInstanceId" if camel_case else "pending_instance_id"] = self.pending_instance_id.dump(
+                camel_case=camel_case, include_instance_type=False
+            )
+        return output
+
+
+class ExtendedFileMetadataList(FileMetadataList):
+    _RESOURCE = ExtendedFileMetadata  # type: ignore[assignment]