cognite-toolkit 0.7.42__py3-none-any.whl → 0.7.43__py3-none-any.whl

cognite_toolkit/_cdf_tk/client/data_classes/data_modeling/_references.py

@@ -0,0 +1,78 @@
+from typing import Literal
+
+from pydantic import Field
+
+from cognite_toolkit._cdf_tk.client.data_classes.identifiers import Identifier
+
+
+class SpaceReference(Identifier):
+    space: str
+
+    def __str__(self) -> str:
+        return self.space
+
+
+class ContainerReference(Identifier):
+    type: Literal["container"] = Field("container", exclude=True)
+    space: str
+    external_id: str
+
+    def __str__(self) -> str:
+        return f"{self.space}:{self.external_id}"
+
+
+class ViewReference(Identifier):
+    type: Literal["view"] = Field("view", exclude=True)
+    space: str
+    external_id: str
+    version: str
+
+    def __str__(self) -> str:
+        return f"{self.space}:{self.external_id}(version={self.version})"
+
+
+class DataModelReference(Identifier):
+    space: str
+    external_id: str
+    version: str
+
+    def __str__(self) -> str:
+        return f"{self.space}:{self.external_id}(version={self.version})"
+
+
+class NodeReference(Identifier):
+    space: str
+    external_id: str
+
+    def __str__(self) -> str:
+        return f"{self.space}:{self.external_id}"
+
+
+class ContainerDirectReference(Identifier):
+    source: ContainerReference
+    identifier: str
+
+    def __str__(self) -> str:
+        return f"{self.source!s}.{self.identifier}"
+
+
+class ViewDirectReference(Identifier):
+    source: ViewReference
+    identifier: str
+
+    def __str__(self) -> str:
+        return f"{self.source!s}.{self.identifier}"
+
+
+class ContainerIndexReference(ContainerReference):
+    identifier: str
+
+    def __str__(self) -> str:
+        return f"{self.space}:{self.external_id}(index={self.identifier})"
+
+
+class ContainerConstraintReference(ContainerReference):
+    identifier: str
+
+    def __str__(self) -> str:
+        return f"{self.space}:{self.external_id}(constraint={self.identifier})"

cognite_toolkit/_cdf_tk/client/data_classes/data_modeling/_space.py

@@ -0,0 +1,26 @@
+from abc import ABC
+
+from cognite_toolkit._cdf_tk.client.data_classes.base import BaseModelObject, RequestResource, ResponseResource
+
+from ._references import SpaceReference
+
+
+class Space(BaseModelObject, ABC):
+    space: str
+    name: str | None = None
+    description: str | None = None
+
+    def as_id(self) -> SpaceReference:
+        return SpaceReference(space=self.space)
+
+
+class SpaceRequest(Space, RequestResource): ...
+
+
+class SpaceResponse(Space, ResponseResource[SpaceRequest]):
+    created_time: int
+    last_updated_time: int
+    is_global: bool
+
+    def as_request_resource(self) -> SpaceRequest:
+        return SpaceRequest.model_validate(self.model_dump(by_alias=True), extra="ignore")

cognite_toolkit/_cdf_tk/client/data_classes/data_modeling/_view.py

@@ -0,0 +1,143 @@
+from abc import ABC
+from typing import Any, Literal
+
+from pydantic import Field, JsonValue, field_serializer, model_validator
+from pydantic_core.core_schema import FieldSerializationInfo
+
+from cognite_toolkit._cdf_tk.client.data_classes.base import BaseModelObject, RequestResource, ResponseResource
+
+from ._data_types import DirectNodeRelation
+from ._references import ContainerReference, ViewReference
+from ._view_property import (
+    MultiReverseDirectRelationPropertyResponse,
+    SingleReverseDirectRelationPropertyResponse,
+    ViewCorePropertyRequest,
+    ViewCorePropertyResponse,
+    ViewRequestProperty,
+    ViewResponseProperty,
+)
+
+
+class View(BaseModelObject, ABC):
+    space: str
+    external_id: str
+    version: str
+    name: str | None = None
+    description: str | None = None
+    filter: JsonValue | None
+    implements: list[ViewReference] | None = None
+
+    def as_id(self) -> ViewReference:
+        return ViewReference(space=self.space, external_id=self.external_id, version=self.version)
+
+    @model_validator(mode="before")
+    def set_connection_type_on_primary_properties(cls, data: dict[str, Any]) -> dict[str, Any]:
+        if "properties" not in data:
+            return data
+        properties = data["properties"]
+        if not isinstance(properties, dict):
+            return data
+        # We assume all properties without connectionType are core properties.
+        # The reason we set connectionType is to make it easy for pydantic to discriminate the union.
+        # This also leads to better error messages, as if there is a union and pydantic does not know which
+        # type to pick it will give errors from all type in the union.
+        new_properties: dict[str, Any] = {}
+        for prop_id, prop in properties.items():
+            if isinstance(prop, dict) and "connectionType" not in prop:
+                prop_copy = prop.copy()
+                prop_copy["connectionType"] = "primary_property"
+                new_properties[prop_id] = prop_copy
+            else:
+                new_properties[prop_id] = prop
+        if new_properties:
+            new_data = data.copy()
+            new_data["properties"] = new_properties
+            return new_data
+
+        return data
+
+    @field_serializer("implements", mode="plain")
+    @classmethod
+    def serialize_implements(
+        cls, implements: list[ViewReference] | None, info: FieldSerializationInfo
+    ) -> list[dict[str, Any]] | None:
+        if implements is None:
+            return None
+        output: list[dict[str, Any]] = []
+        for view in implements:
+            dumped = view.model_dump(**vars(info))
+            dumped["type"] = "view"
+            output.append(dumped)
+        return output
+
+
+class ViewRequest(View, RequestResource):
+    properties: dict[str, ViewRequestProperty] = Field(
+        description="View with included properties and expected edges, indexed by a unique space-local identifier."
+    )
+
+    @property
+    def used_containers(self) -> set[ContainerReference]:
+        """Get all containers referenced by this view."""
+        return {prop.container for prop in self.properties.values() if isinstance(prop, ViewCorePropertyRequest)}
+
+
+class ViewResponse(View, ResponseResource[ViewRequest]):
+    properties: dict[str, ViewResponseProperty]
+
+    created_time: int
+    last_updated_time: int
+    writable: bool
+    queryable: bool
+    used_for: Literal["node", "edge", "all"]
+    is_global: bool
+    mapped_containers: list[ContainerReference]
+
+    def as_request_resource(self) -> ViewRequest:
+        dumped = self.model_dump(by_alias=True, exclude={"properties"})
+        properties: dict[str, Any] = {}
+        for key, value in self.properties.items():
+            if isinstance(value, ViewCorePropertyResponse) and isinstance(value.type, DirectNodeRelation):
+                # Special case. In the request the source of DirectNodeRelation is set on the Property object,
+                # while in the response it is set on the DirectNodeRelation object.
+                request_object = value.as_request().model_dump(by_alias=True)
+                request_object["source"] = value.type.source.model_dump(by_alias=True) if value.type.source else None
+                properties[key] = request_object
+            elif isinstance(
+                value,
+                ViewCorePropertyResponse
+                | SingleReverseDirectRelationPropertyResponse
+                | MultiReverseDirectRelationPropertyResponse,
+            ):
+                properties[key] = value.as_request().model_dump(by_alias=True)
+            else:
+                properties[key] = value.model_dump(by_alias=True)
+
+        dumped["properties"] = properties
+        return ViewRequest.model_validate(dumped, extra="ignore")
+
+    @field_serializer("mapped_containers", mode="plain")
+    @classmethod
+    def serialize_mapped_containers(
+        cls, mapped_containers: list[ContainerReference], info: FieldSerializationInfo
+    ) -> list[dict[str, Any]]:
+        return [container.model_dump(**vars(info)) | {"type": "container"} for container in mapped_containers]
+
+    @field_serializer("properties", mode="plain")
+    @classmethod
+    def serialize_properties_special_handling_direct_relation_with_source(
+        cls, properties: dict[str, ViewResponseProperty], info: FieldSerializationInfo
+    ) -> dict[str, dict[str, Any]]:
+        output: dict[str, dict[str, Any]] = {}
+        for prop_id, prop in properties.items():
+            output[prop_id] = prop.model_dump(**vars(info))
+            if (
+                isinstance(prop, ViewCorePropertyResponse)
+                and isinstance(prop.type, DirectNodeRelation)
+                and prop.type.source
+            ):
+                # We manually include the source as this is excluded by default. The reason why this is excluded
+                # is that the DirectNodeRelation is used for both request and response, and in the request the source
+                # does not exist on the DirectNodeRelation, but on the Property object.
+                output[prop_id]["type"]["source"] = prop.type.source.model_dump(**vars(info)) | {"type": "view"}
+        return output

cognite_toolkit/_cdf_tk/client/data_classes/data_modeling/_view_property.py

@@ -0,0 +1,152 @@
+from abc import ABC
+from typing import Annotated, Any, Literal
+
+from pydantic import Field, JsonValue, TypeAdapter, field_serializer
+from pydantic_core.core_schema import FieldSerializationInfo
+
+from cognite_toolkit._cdf_tk.client.data_classes.base import BaseModelObject
+
+from ._data_types import DataType
+from ._references import ContainerDirectReference, ContainerReference, NodeReference, ViewDirectReference, ViewReference
+
+
+class ViewPropertyDefinition(BaseModelObject, ABC):
+    connection_type: str
+
+
+class ViewCoreProperty(ViewPropertyDefinition, ABC):
+    # Core properties do not have connection type in the API, but we add it here such that
+    # we can use it as a discriminator in unions. The exclude=True ensures that it is not
+    # sent to the API.
+    connection_type: Literal["primary_property"] = Field(default="primary_property", exclude=True)
+    name: str | None = None
+    description: str | None = None
+    container: ContainerReference
+    container_property_identifier: str
+
+    @field_serializer("container", mode="plain")
+    @classmethod
+    def serialize_container(cls, container: ContainerReference, info: FieldSerializationInfo) -> dict[str, Any]:
+        return {**container.model_dump(**vars(info)), "type": "container"}
+
+
+class ViewCorePropertyRequest(ViewCoreProperty):
+    source: ViewReference | None = None
+
+    @field_serializer("source", mode="plain")
+    @classmethod
+    def serialize_source(cls, source: ViewReference | None, info: FieldSerializationInfo) -> dict[str, Any] | None:
+        if source is None:
+            return None
+        return {**source.model_dump(**vars(info)), "type": "view"}
+
+
+class ConstraintOrIndexState(BaseModelObject):
+    nullability: Literal["current", "pending", "failed"] | None = None
+    max_list_size: Literal["current", "pending", "failed"] | None = None
+    max_text_size: Literal["current", "pending", "failed"] | None = None
+
+
+class ViewCorePropertyResponse(ViewCoreProperty):
+    immutable: bool | None = None
+    nullable: bool | None = None
+    auto_increment: bool | None = None
+    default_value: str | int | bool | dict[str, JsonValue] | None = None
+    constraint_state: ConstraintOrIndexState
+    type: DataType
+
+    def as_request(self) -> ViewCorePropertyRequest:
+        return ViewCorePropertyRequest.model_validate(self.model_dump(by_alias=True))
+
+
+class ConnectionPropertyDefinition(ViewPropertyDefinition, ABC):
+    name: str | None = None
+    description: str | None = None
+
+
+class EdgeProperty(ConnectionPropertyDefinition, ABC):
+    source: ViewReference
+    type: NodeReference
+    edge_source: ViewReference | None = None
+    direction: Literal["outwards", "inwards"] = "outwards"
+
+    @field_serializer("source", "edge_source", mode="plain")
+    @classmethod
+    def serialize_source(cls, source: ViewReference | None, info: FieldSerializationInfo) -> dict[str, Any] | None:
+        if source is None:
+            return None
+        return {**source.model_dump(**vars(info)), "type": "view"}
+
+
+class SingleEdgeProperty(EdgeProperty):
+    connection_type: Literal["single_edge_connection"] = "single_edge_connection"
+
+
+class MultiEdgeProperty(EdgeProperty):
+    connection_type: Literal["multi_edge_connection"] = "multi_edge_connection"
+
+
+class ReverseDirectRelationProperty(ConnectionPropertyDefinition, ABC):
+    source: ViewReference
+    through: ContainerDirectReference | ViewDirectReference
+
+    @field_serializer("source", mode="plain")
+    @classmethod
+    def serialize_source(cls, source: ViewReference, info: FieldSerializationInfo) -> dict[str, Any]:
+        return {**source.model_dump(**vars(info)), "type": "view"}
+
+    @field_serializer("through", mode="plain")
+    @classmethod
+    def serialize_through(
+        cls, through: ContainerDirectReference | ViewDirectReference, info: FieldSerializationInfo
+    ) -> dict[str, Any]:
+        output = through.model_dump(**vars(info))
+        if isinstance(through, ContainerDirectReference):
+            output["source"]["type"] = "container"
+        else:
+            output["source"]["type"] = "view"
+        return output
+
+
+class SingleReverseDirectRelationPropertyRequest(ReverseDirectRelationProperty):
+    connection_type: Literal["single_reverse_direct_relation"] = "single_reverse_direct_relation"
+
+
+class MultiReverseDirectRelationPropertyRequest(ReverseDirectRelationProperty):
+    connection_type: Literal["multi_reverse_direct_relation"] = "multi_reverse_direct_relation"
+
+
+class SingleReverseDirectRelationPropertyResponse(ReverseDirectRelationProperty):
+    connection_type: Literal["single_reverse_direct_relation"] = "single_reverse_direct_relation"
+    targets_list: bool
+
+    def as_request(self) -> SingleReverseDirectRelationPropertyRequest:
+        return SingleReverseDirectRelationPropertyRequest.model_validate(self.model_dump(by_alias=True))
+
+
+class MultiReverseDirectRelationPropertyResponse(ReverseDirectRelationProperty):
+    connection_type: Literal["multi_reverse_direct_relation"] = "multi_reverse_direct_relation"
+    targets_list: bool
+
+    def as_request(self) -> MultiReverseDirectRelationPropertyRequest:
+        return MultiReverseDirectRelationPropertyRequest.model_validate(self.model_dump(by_alias=True))
+
+
+ViewRequestProperty = Annotated[
+    SingleEdgeProperty
+    | MultiEdgeProperty
+    | SingleReverseDirectRelationPropertyRequest
+    | MultiReverseDirectRelationPropertyRequest
+    | ViewCorePropertyRequest,
+    Field(discriminator="connection_type"),
+]
+ViewResponseProperty = Annotated[
+    SingleEdgeProperty
+    | MultiEdgeProperty
+    | SingleReverseDirectRelationPropertyResponse
+    | MultiReverseDirectRelationPropertyResponse
+    | ViewCorePropertyResponse,
+    Field(discriminator="connection_type"),
+]
+
+ViewRequestPropertyAdapter: TypeAdapter[ViewRequestProperty] = TypeAdapter(ViewRequestProperty)

cognite_toolkit/_cdf_tk/client/data_classes/event.py

@@ -1,12 +1,15 @@
 from typing import ClassVar
 
-from cognite_toolkit._cdf_tk.client.data_classes.base import RequestUpdateable, ResponseResource
+from cognite_toolkit._cdf_tk.client.data_classes.base import (
+    BaseModelObject,
+    RequestUpdateable,
+    ResponseResource,
+)
 
 from .identifiers import ExternalId, InternalOrExternalId
 
 
-class EventRequest(RequestUpdateable):
-    container_fields: ClassVar[frozenset[str]] = frozenset({"metadata", "asset_ids"})
+class Event(BaseModelObject):
     external_id: str | None = None
     data_set_id: int | None = None
     start_time: int | None = None
@@ -24,20 +27,14 @@ class EventRequest(RequestUpdateable):
         return ExternalId(external_id=self.external_id)
 
 
-class EventResponse(ResponseResource[EventRequest]):
-    external_id: str | None = None
-    data_set_id: int | None = None
-    start_time: int | None = None
-    end_time: int | None = None
-    type: str | None = None
-    subtype: str | None = None
-    description: str | None = None
-    metadata: dict[str, str] | None = None
-    asset_ids: list[int] | None = None
-    source: str | None = None
+class EventRequest(Event, RequestUpdateable):
+    container_fields: ClassVar[frozenset[str]] = frozenset({"metadata", "asset_ids"})
+
+
+class EventResponse(Event, ResponseResource[EventRequest]):
     id: int
     created_time: int
     last_updated_time: int
 
     def as_request_resource(self) -> EventRequest:
-        return EventRequest.model_validate(self.dump())
+        return EventRequest.model_validate(self.dump(), extra="ignore")

cognite_toolkit/_cdf_tk/client/data_classes/filemetadata.py

@@ -2,15 +2,13 @@ from typing import ClassVar, Literal
 
 from pydantic import JsonValue
 
-from cognite_toolkit._cdf_tk.client.data_classes.base import RequestUpdateable, ResponseResource
+from cognite_toolkit._cdf_tk.client.data_classes.base import BaseModelObject, RequestUpdateable, ResponseResource
 
 from .identifiers import ExternalId
 from .instance_api import NodeReference
 
 
-class FileMetadataRequest(RequestUpdateable):
-    container_fields: ClassVar[frozenset[str]] = frozenset({"metadata", "labels", "asset_ids", "security_categories"})
-    non_nullable_fields: ClassVar[frozenset[str]] = frozenset({"asset_ids", "security_categories"})
+class FileMetadata(BaseModelObject):
     external_id: str | None = None
     name: str
     directory: str | None = None
@@ -31,26 +29,18 @@ class FileMetadataRequest(RequestUpdateable):
         return ExternalId(external_id=self.external_id)
 
 
-class FileMetadataResponse(ResponseResource[FileMetadataRequest]):
+class FileMetadataRequest(FileMetadata, RequestUpdateable):
+    container_fields: ClassVar[frozenset[str]] = frozenset({"metadata", "labels", "asset_ids", "security_categories"})
+    non_nullable_fields: ClassVar[frozenset[str]] = frozenset({"asset_ids", "security_categories"})
+
+
+class FileMetadataResponse(FileMetadata, ResponseResource[FileMetadataRequest]):
     created_time: int
     last_updated_time: int
     uploaded_time: int | None = None
     uploaded: bool
     id: int
-    external_id: str | None = None
-    name: str
-    directory: str | None = None
     instance_id: NodeReference | None = None
-    source: str | None = None
-    mime_type: str | None = None
-    metadata: dict[str, str] | None = None
-    asset_ids: list[int] | None = None
-    data_set_id: int | None = None
-    labels: list[dict[Literal["externalId"], str]] | None = None
-    geo_location: JsonValue | None = None
-    source_created_time: int | None = None
-    source_modified_time: int | None = None
-    security_categories: list[int] | None = None
 
     def as_request_resource(self) -> FileMetadataRequest:
         return FileMetadataRequest.model_validate(self.dump(), extra="ignore")

cognite_toolkit/_cdf_tk/client/data_classes/simulator_model.py

@@ -0,0 +1,50 @@
+from typing import Any, Literal
+
+from pydantic import Field
+
+from cognite_toolkit._cdf_tk.client.data_classes.base import RequestUpdateable, ResponseResource
+
+from .identifiers import ExternalId
+
+
+class SimulatorModelRequest(RequestUpdateable):
+    # The 'id' field is not part of the request when creating a new resource,
+    # but is needed when updating an existing resource.
+    id: int | None = Field(default=None, exclude=True)
+    external_id: str
+    simulator_external_id: str
+    name: str
+    description: str | None = None
+    data_set_id: int
+    type: str
+
+    def as_id(self) -> ExternalId:
+        return ExternalId(external_id=self.external_id)
+
+    def as_update(self, mode: Literal["patch", "replace"]) -> dict[str, Any]:
+        if self.id is None:
+            raise ValueError("id must be provided to create an update dictionary")
+        return {
+            "id": self.id,
+            "update": {
+                "name": {"set": self.name},
+                **{"description": {"set": self.description} if self.description is not None else {}},
+            },
+        }
+
+
+class SimulatorModelResponse(ResponseResource[SimulatorModelRequest]):
+    id: int
+    external_id: str
+    simulator_external_id: str
+    name: str
+    description: str | None = None
+    data_set_id: int
+    type: str | None = None
+    created_time: int
+    last_updated_time: int
+
+    def as_request_resource(self) -> SimulatorModelRequest:
+        if self.type is None:
+            raise ValueError("Cannot convert SimulatorModelResponse to SimulatorModelRequest when type is None")
+        return SimulatorModelRequest.model_validate(self.dump(), extra="ignore")

cognite_toolkit/_cdf_tk/client/data_classes/timeseries.py

@@ -1,14 +1,16 @@
 from typing import Any, ClassVar, Literal
 
-from cognite_toolkit._cdf_tk.client.data_classes.base import RequestUpdateable, ResponseResource
+from cognite_toolkit._cdf_tk.client.data_classes.base import (
+    BaseModelObject,
+    RequestUpdateable,
+    ResponseResource,
+)
 
 from .identifiers import ExternalId, InternalOrExternalId
 from .instance_api import NodeReference
 
 
-class TimeSeriesRequest(RequestUpdateable):
-    container_fields: ClassVar[frozenset[str]] = frozenset({"metadata", "security_categories"})
-    non_nullable_fields: ClassVar[frozenset[str]] = frozenset({"is_step"})
+class TimeSeries(BaseModelObject):
     external_id: str | None = None
     name: str | None = None
     is_string: bool = False
@@ -26,30 +28,25 @@ class TimeSeriesRequest(RequestUpdateable):
             raise ValueError("Cannot convert TimeSeriesRequest to ExternalId when external_id is None")
         return ExternalId(external_id=self.external_id)
 
+
+class TimeSeriesRequest(TimeSeries, RequestUpdateable):
+    container_fields: ClassVar[frozenset[str]] = frozenset({"metadata", "security_categories"})
+    non_nullable_fields: ClassVar[frozenset[str]] = frozenset({"is_step"})
+
     def as_update(self, mode: Literal["patch", "replace"]) -> dict[str, Any]:
         dumped = super().as_update(mode)
+        update = dumped["update"] if "update" in dumped else dumped
         # isString is immutable in CDF, so we remove it from update payloads
-        dumped.pop("isString", None)
+        update.pop("isString", None)
         return dumped
 
 
-class TimeSeriesResponse(ResponseResource[TimeSeriesRequest]):
+class TimeSeriesResponse(TimeSeries, ResponseResource[TimeSeriesRequest]):
     id: int
     instance_id: NodeReference | None = None
-    external_id: str | None = None
-    name: str | None = None
-    is_string: bool
-    metadata: dict[str, str] | None = None
-    unit: str | None = None
     type: str
-    unit_external_id: str | None = None
-    asset_id: int | None = None
-    is_step: bool
-    description: str | None = None
-    security_categories: list[int] | None = None
-    data_set_id: int | None = None
     created_time: int
     last_updated_time: int
 
     def as_request_resource(self) -> TimeSeriesRequest:
-        return TimeSeriesRequest.model_validate(self.dump())
+        return TimeSeriesRequest.model_validate(self.dump(), extra="ignore")

cognite_toolkit/_cdf_tk/client/testing.py

@@ -142,7 +142,7 @@ class ToolkitClientMock(CogniteClientMock):
         self.tool.three_d = MagicMock(spec=ThreeDAPI)
         self.tool.three_d.models = MagicMock(spec_set=ThreeDModelAPI)
         self.tool.assets = MagicMock(spec_set=AssetsAPI)
-        self.tool.time_series = MagicMock(spec_set=TimeSeriesAPI)
+        self.tool.timeseries = MagicMock(spec_set=TimeSeriesAPI)
         self.tool.events = MagicMock(spec_set=EventsAPI)
 
         self.streams = MagicMock(spec=StreamsAPI)

cognite_toolkit/_cdf_tk/commands/_migrate/conversion.py

@@ -1,7 +1,7 @@
 from collections.abc import Iterable, Mapping, Set
 from typing import Any, ClassVar, cast
 
-from cognite.client.data_classes import Annotation, Event, FileMetadata, TimeSeries
+from cognite.client.data_classes import Annotation, FileMetadata
 from cognite.client.data_classes.data_modeling import (
     DirectRelation,
     DirectRelationReference,
@@ -17,10 +17,12 @@ from cognite.client.utils._identifier import InstanceId
 
 from cognite_toolkit._cdf_tk.client import ToolkitClient
 from cognite_toolkit._cdf_tk.client.data_classes.asset import AssetResponse
+from cognite_toolkit._cdf_tk.client.data_classes.event import EventResponse
 from cognite_toolkit._cdf_tk.client.data_classes.legacy.migration import (
     AssetCentricId,
     ResourceViewMappingApply,
 )
+from cognite_toolkit._cdf_tk.client.data_classes.timeseries import TimeSeriesResponse
 from cognite_toolkit._cdf_tk.utils.collection import flatten_dict_json_path
 from cognite_toolkit._cdf_tk.utils.dtype_conversion import (
     asset_centric_convert_to_primary_property,
@@ -120,12 +122,12 @@ class DirectRelationCache:
                     source_ids.add(resource.source)
                 if resource.asset_ids:
                     asset_ids.update(resource.asset_ids)
-            elif isinstance(resource, Event):
+            elif isinstance(resource, EventResponse):
                 if resource.source:
                     source_ids.add(resource.source)
                 if resource.asset_ids:
                     asset_ids.update(resource.asset_ids)
-            elif isinstance(resource, TimeSeries):
+            elif isinstance(resource, TimeSeriesResponse):
                 if resource.asset_id is not None:
                     asset_ids.add(resource.asset_id)
         if asset_ids:
@@ -248,9 +250,9 @@ def _lookup_resource_type(resource_type: AssetCentricResourceExtended) -> AssetC
         return "asset"
     elif isinstance(resource_type, FileMetadata):
         return "file"
-    elif isinstance(resource_type, Event):
+    elif isinstance(resource_type, EventResponse):
         return "event"
-    elif isinstance(resource_type, TimeSeries):
+    elif isinstance(resource_type, TimeSeriesResponse):
         return "timeseries"
     elif isinstance(resource_type, Annotation):
         if resource_type.annotated_resource_type == "file" and resource_type.annotation_type in (