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

cognite_toolkit/_cdf_tk/client/data_classes/search_config.py

@@ -0,0 +1,224 @@
+from abc import ABC
+from dataclasses import dataclass
+from typing import Any
+
+from cognite.client import CogniteClient
+from cognite.client.data_classes._base import (
+    CogniteObject,
+    CogniteResourceList,
+    WriteableCogniteResource,
+    WriteableCogniteResourceList,
+)
+from typing_extensions import Self
+
+
+@dataclass(frozen=True)
+class ViewId(CogniteObject):
+    external_id: str
+    space: str
+
+    def __str__(self) -> str:
+        return f"({self.external_id}, {self.space})"
+
+    @classmethod
+    def _load(cls, resource: dict[str, Any], cognite_client: CogniteClient | None = None) -> Self:
+        return cls(
+            external_id=resource["externalId"],
+            space=resource["space"],
+        )
+
+
+@dataclass
+class SearchConfigViewProperty(CogniteObject):
+    property: str
+    disabled: bool | None = None
+    selected: bool | None = None
+    hidden: bool | None = None
+
+    @classmethod
+    def _load(cls, resource: dict[str, Any], cognite_client: CogniteClient | None = None) -> Self:
+        return cls(
+            property=resource["property"],
+            disabled=resource.get("disabled"),
+            selected=resource.get("selected"),
+            hidden=resource.get("hidden"),
+        )
+
+
+class SearchConfigCore(WriteableCogniteResource["SearchConfigWrite"], ABC):
+    """
+    Core model for a single Configuration.
+
+    Args:
+        view: The configuration for one specific view.
+        id: A server-generated ID for the object.
+        use_as_name: The name of property to use for the name column in the UI.
+        use_as_description: The name of property to use for the description column in the UI.
+        columns_layout: Array of column configurations per property.
+        filter_layout: Array of filter configurations per property.
+        properties_layout: Array of property configurations per property.
+    """
+
+    def __init__(
+        self,
+        view: ViewId,
+        id: int | None = None,
+        use_as_name: str | None = None,
+        use_as_description: str | None = None,
+        columns_layout: list[SearchConfigViewProperty] | None = None,
+        filter_layout: list[SearchConfigViewProperty] | None = None,
+        properties_layout: list[SearchConfigViewProperty] | None = None,
+    ) -> None:
+        self.view = view
+        self.id = id
+        self.use_as_name = use_as_name
+        self.use_as_description = use_as_description
+        self.columns_layout = columns_layout
+        self.filter_layout = filter_layout
+        self.properties_layout = properties_layout
+
+    def as_write(self) -> "SearchConfigWrite":
+        return SearchConfigWrite(
+            view=self.view,
+            id=self.id,
+            use_as_name=self.use_as_name,
+            use_as_description=self.use_as_description,
+            columns_layout=self.columns_layout,
+            filter_layout=self.filter_layout,
+            properties_layout=self.properties_layout,
+        )
+
+    def dump(self, camel_case: bool = True) -> dict[str, Any]:
+        output = super().dump(camel_case)
+        if self.columns_layout:
+            output["columnsLayout" if camel_case else "columns_layout"] = [
+                _data.dump(camel_case) for _data in self.columns_layout
+            ]
+        if self.filter_layout:
+            output["filterLayout" if camel_case else "filter_layout"] = [
+                _data.dump(camel_case) for _data in self.filter_layout
+            ]
+        if self.properties_layout:
+            output["propertiesLayout" if camel_case else "properties_layout"] = [
+                _data.dump(camel_case) for _data in self.properties_layout
+            ]
+        if self.view:
+            output["view"] = self.view.dump(camel_case)
+        return output
+
+
+class SearchConfigWrite(SearchConfigCore):
+    """
+    SearchConfig write/requst format.
+
+    Args:
+        view: The configuration for one specific view.
+        id: A server-generated ID for the object.
+        use_as_name: The name of property to use for the name column in the UI.
+        use_as_description: The name of property to use for the description column in the UI.
+        columns_layout: Array of column configurations per property.
+        filter_layout: Array of filter configurations per property.
+        properties_layout: Array of property configurations per property.
+    """
+
+    @classmethod
+    def _load(cls, resource: dict[str, Any], cognite_client: CogniteClient | None = None) -> Self:
+        return cls(
+            id=resource.get("id"),
+            view=ViewId.load(resource["view"]),
+            use_as_name=resource.get("useAsName"),
+            use_as_description=resource.get("useAsDescription"),
+            columns_layout=(
+                [SearchConfigViewProperty.load(item) for item in items]
+                if (items := resource.get("columnsLayout"))
+                else None
+            ),
+            filter_layout=(
+                [SearchConfigViewProperty.load(item) for item in items]
+                if (items := resource.get("filterLayout"))
+                else None
+            ),
+            properties_layout=(
+                [SearchConfigViewProperty.load(item) for item in items]
+                if (items := resource.get("propertiesLayout"))
+                else None
+            ),
+        )
+
+
+class SearchConfig(SearchConfigCore):
+    """
+    Response model for a single Configuration.
+
+    Args:
+        view: The configuration for one specific view.
+        id: A server-generated ID for the object.
+        created_time: The time when the search config was created.
+        updated_time: The time when the search config was last updated.
+        use_as_name: The name of property to use for the name column in the UI.
+        use_as_description: The name of property to use for the description column in the UI.
+        columns_layout: Array of column configurations per property.
+        filter_layout: Array of filter configurations per property.
+        properties_layout: Array of property configurations per property.
+    """
+
+    def __init__(
+        self,
+        view: ViewId,
+        id: int,
+        created_time: int,
+        updated_time: int,
+        use_as_name: str | None = None,
+        use_as_description: str | None = None,
+        columns_layout: list[SearchConfigViewProperty] | None = None,
+        filter_layout: list[SearchConfigViewProperty] | None = None,
+        properties_layout: list[SearchConfigViewProperty] | None = None,
+    ) -> None:
+        super().__init__(
+            view,
+            id,
+            use_as_name,
+            use_as_description,
+            columns_layout,
+            filter_layout,
+            properties_layout,
+        )
+        self.created_time = created_time
+        self.updated_time = updated_time
+
+    @classmethod
+    def _load(cls, resource: dict[str, Any], cognite_client: CogniteClient | None = None) -> Self:
+        return cls(
+            view=ViewId.load(resource["view"]),
+            id=resource["id"],
+            created_time=resource["createdTime"],
+            updated_time=resource["lastUpdatedTime"],
+            use_as_name=resource.get("useAsName"),
+            use_as_description=resource.get("useAsDescription"),
+            columns_layout=(
+                [SearchConfigViewProperty.load(item) for item in items]
+                if (items := resource.get("columnsLayout"))
+                else None
+            ),
+            filter_layout=(
+                [SearchConfigViewProperty.load(item) for item in items]
+                if (items := resource.get("filterLayout"))
+                else None
+            ),
+            properties_layout=(
+                [SearchConfigViewProperty.load(item) for item in items]
+                if (items := resource.get("propertiesLayout"))
+                else None
+            ),
+        )
+
+
+class SearchConfigWriteList(CogniteResourceList):
+    _RESOURCE = SearchConfigWrite
+
+
+class SearchConfigList(WriteableCogniteResourceList[SearchConfigWrite, SearchConfig]):
+    _RESOURCE = SearchConfig
+
+    def as_write(self) -> SearchConfigWriteList:
+        return SearchConfigWriteList([searchConfig.as_write() for searchConfig in self])

cognite_toolkit/_cdf_tk/client/data_classes/streamlit_.py

@@ -17,13 +17,13 @@ class _StreamlitCore(WriteableCogniteResource["StreamlitWrite"], ABC):
         external_id: str,
         name: str,
         creator: str,
-        entrypoint: str,
+        entrypoint: str | None = None,
         description: str | None = None,
         published: bool = False,
         theme: Literal["Light", "Dark"] = "Light",
         thumbnail: str | None = None,
         data_set_id: int | None = None,
-        cognite_toolkit_app_hash: str = "MISSING",
+        cognite_toolkit_app_hash: str | None = None,
     ) -> None:
         self.external_id = external_id
         self.name = name
@@ -43,11 +43,13 @@ class _StreamlitCore(WriteableCogniteResource["StreamlitWrite"], ABC):
             "name": self.name,
             "published": self.published,
             "theme": self.theme,
-            "entrypoint": self.entrypoint,
-            "cdf-toolkit-app-hash": self.cognite_toolkit_app_hash,
         }
         if self.thumbnail:
             metadata["thumbnail"] = self.thumbnail
+        if self.cognite_toolkit_app_hash:
+            metadata["cdf-toolkit-app-hash"] = self.cognite_toolkit_app_hash
+        if self.entrypoint:
+            metadata["entrypoint"] = self.entrypoint
         return {
             "external_id": self.external_id,
             "name": f"{self.name}-source.json",
@@ -64,7 +66,7 @@ class StreamlitWrite(_StreamlitCore):
             external_id=resource["externalId"],
             name=resource["name"],
             creator=resource["creator"],
-            entrypoint=resource["entrypoint"],
+            entrypoint=resource.get("entrypoint"),
             description=resource.get("description"),
             thumbnail=resource.get("thumbnail"),
             data_set_id=resource.get("dataSetId"),
@@ -90,15 +92,15 @@ class Streamlit(_StreamlitCore):
         external_id: str,
         name: str,
         creator: str,
-        entrypoint: str,
         created_time: int,
         last_updated_time: int,
+        entrypoint: str | None = None,
         description: str | None = None,
         published: bool = False,
         theme: Literal["Light", "Dark"] = "Light",
         thumbnail: str | None = None,
         data_set_id: int | None = None,
-        cognite_toolkit_app_hash: str = "MISSING",
+        cognite_toolkit_app_hash: str | None = None,
     ) -> None:
         super().__init__(
             external_id,
@@ -121,7 +123,7 @@ class Streamlit(_StreamlitCore):
             external_id=resource["externalId"],
             name=resource["name"],
             creator=resource["creator"],
-            entrypoint=resource["entrypoint"],
+            entrypoint=resource.get("entrypoint"),
             created_time=resource["createdTime"],
             last_updated_time=resource["lastUpdatedTime"],
             description=resource.get("description"),
@@ -129,7 +131,7 @@ class Streamlit(_StreamlitCore):
             data_set_id=resource.get("dataSetId"),
         )
         # Trick to avoid specifying defaults twice
-        for key in ["theme", "app_hash"]:
+        for key in ["theme"]:
             if key in resource:
                 args[key] = resource[key]
         if "cogniteToolkitAppHash" in resource:
@@ -148,8 +150,6 @@ class Streamlit(_StreamlitCore):
             dumped.update(dumped.pop("metadata"))
         if "cdf-toolkit-app-hash" in dumped:
             dumped["cogniteToolkitAppHash"] = dumped.pop("cdf-toolkit-app-hash")
-        if "entrypoint" not in dumped:
-            dumped["entrypoint"] = "MISSING"
         return cls._load(dumped)
 
     def as_write(self) -> StreamlitWrite:

cognite_toolkit/_cdf_tk/client/data_classes/streams.py

@@ -0,0 +1,90 @@
+from typing import Literal
+
+from cognite_toolkit._cdf_tk.constants import StreamTemplateName
+from cognite_toolkit._cdf_tk.protocols import (
+    ResourceRequestListProtocol,
+    ResourceResponseListProtocol,
+)
+
+from .base import BaseModelObject, BaseResourceList, RequestResource, ResponseResource
+
+
+class StreamRequest(RequestResource):
+    """Stream request resource class."""
+
+    external_id: str
+    settings: dict[Literal["template"], dict[Literal["name"], StreamTemplateName]]
+
+    def as_id(self) -> str:
+        return self.external_id
+
+
+class StreamRequestList(BaseResourceList[StreamRequest], ResourceRequestListProtocol):
+    """List of Stream request resources."""
+
+    _RESOURCE = StreamRequest
+
+
+class LifecycleObject(BaseModelObject):
+    """Lifecycle object."""
+
+    hot_phase_duration: str | None = None
+    data_deleted_after: str | None = None
+    retained_after_soft_delete: str
+
+
+class ResourceUsage(BaseModelObject):
+    """Resource quota with provisioned and consumed values."""
+
+    provisioned: int
+    consumed: int | None = None
+
+
+class LimitsObject(BaseModelObject):
+    """Limits object."""
+
+    max_records_total: ResourceUsage
+    max_giga_bytes_total: ResourceUsage
+    max_filtering_interval: str | None = None
+
+
+class StreamSettings(BaseModelObject):
+    """Stream settings object."""
+
+    lifecycle: LifecycleObject
+    limits: LimitsObject
+
+
+class StreamResponse(ResponseResource["StreamRequest"]):
+    """Stream response resource class."""
+
+    external_id: str
+    created_time: int
+    created_from_template: StreamTemplateName
+    type: Literal["Mutable", "Immutable"]
+    settings: StreamSettings | None = None
+
+    def as_request_resource(self) -> StreamRequest:
+        return StreamRequest.model_validate(
+            {
+                "externalId": self.external_id,
+                "settings": {"template": {"name": self.created_from_template}},
+            }
+        )
+
+    def as_write(self) -> StreamRequest:
+        return StreamRequest.model_validate(
+            {
+                "externalId": self.external_id,
+                "settings": {"template": {"name": self.created_from_template}},
+            }
+        )
+
+
+class StreamResponseList(BaseResourceList[StreamResponse], ResourceResponseListProtocol):
+    """List of Stream response resources."""
+
+    _RESOURCE = StreamResponse
+
+    def as_write(self) -> StreamRequestList:
+        return StreamRequestList([item.as_write() for item in self.data])

cognite_toolkit/_cdf_tk/client/data_classes/three_d.py

@@ -0,0 +1,53 @@
+from typing import Literal
+
+from .base import BaseModelObject, RequestResource, ResponseResource
+
+
+class NodeReference(BaseModelObject):
+    space: str
+    external_id: str
+
+
+class RevisionStatus(BaseModelObject):
+    status: Literal["Queued", "Processing", "Done", "Failed"] | None = None
+    revision_id: int | None = None
+    created_time: int | None = None
+    revision_count: int | None = None
+    types: list[str] | None = None
+
+
+class ThreeDModelRequest(RequestResource):
+    name: str
+
+    def as_id(self) -> str:
+        return self.name
+
+
+class ThreeDModelClassicRequest(ThreeDModelRequest):
+    data_set_id: int | None = None
+    metadata: dict[str, str] | None = None
+
+    def as_id(self) -> str:
+        return self.name
+
+
+class ThreeDModelDMSRequest(ThreeDModelRequest):
+    space: str
+    type: Literal["CAD", "PointCloud", "Image360"]
+    thumbnail_reference: NodeReference | None = None
+
+
+class ThreeDModelResponse(ResponseResource[ThreeDModelRequest]):
+    name: str
+    id: int
+    created_time: int
+    data_set_id: int | None = None
+    metadata: dict[str, str] | None = None
+    space: str | None = None
+    last_revision_info: RevisionStatus | None = None
+
+    def as_request_resource(self) -> ThreeDModelRequest:
+        if self.space is None:
+            return ThreeDModelClassicRequest._load(self.dump())
+        else:
+            return ThreeDModelDMSRequest._load(self.dump())

cognite_toolkit/_cdf_tk/client/testing.py

@@ -3,28 +3,59 @@ from contextlib import contextmanager
 from typing import Any
 from unittest.mock import MagicMock
 
+from cognite.client._api.datapoints import DatapointsAPI
+from cognite.client._api.datapoints_subscriptions import DatapointsSubscriptionAPI
+from cognite.client._api.functions import FunctionCallsAPI, FunctionSchedulesAPI
+from cognite.client._api.raw import RawDatabasesAPI, RawRowsAPI, RawTablesAPI
+from cognite.client._api.synthetic_time_series import SyntheticDatapointsAPI
 from cognite.client.testing import CogniteClientMock
+from rich.console import Console
 
 from cognite_toolkit._cdf_tk.client._toolkit_client import ToolkitClient
 
+from ._toolkit_client import ToolAPI
+from .api.canvas import CanvasAPI, IndustrialCanvasAPI
+from .api.charts import ChartsAPI
 from .api.dml import DMLAPI
+from .api.extended_data_modeling import ExtendedInstancesAPI
+from .api.extended_files import ExtendedFileMetadataAPI
+from .api.extended_functions import ExtendedFunctionsAPI
+from .api.extended_raw import ExtendedRawAPI
+from .api.extended_timeseries import ExtendedTimeSeriesAPI
+from .api.infield import InfieldAPI, InFieldCDMConfigAPI, InfieldConfigAPI
 from .api.location_filters import LocationFiltersAPI
 from .api.lookup import (
     AssetLookUpAPI,
     DataSetLookUpAPI,
+    EventLookUpAPI,
     ExtractionPipelineLookUpAPI,
+    FileMetadataLookUpAPI,
+    FunctionLookUpAPI,
     LocationFiltersLookUpAPI,
     LookUpGroup,
     SecurityCategoriesLookUpAPI,
     TimeSeriesLookUpAPI,
 )
+from .api.migration import (
+    CreatedSourceSystemAPI,
+    InstanceSourceAPI,
+    LookupAPI,
+    MigrationAPI,
+    MigrationLookupAPI,
+    ResourceViewMappingAPI,
+)
+from .api.project import ProjectAPI
 from .api.robotics import RoboticsAPI
 from .api.robotics.capabilities import CapabilitiesAPI
 from .api.robotics.data_postprocessing import DataPostProcessingAPI
 from .api.robotics.frames import FramesAPI
 from .api.robotics.locations import LocationsAPI as RoboticsLocationsAPI
 from .api.robotics.maps import MapsAPI
-from .api.statistics import StatisticsAPI
+from .api.search import SearchAPI
+from .api.search_config import SearchConfigurationsAPI
+from .api.streams import StreamsAPI
+from .api.three_d import ThreeDAPI, ThreeDModelAPI
+from .api.token import TokenAPI
 from .api.verify import VerifyAPI
 
 
@@ -39,22 +70,53 @@ class ToolkitClientMock(CogniteClientMock):
             super().__init__(*args, **kwargs)
             return None
         super().__init__(*args, **kwargs)
+        self.console = Console()
         # Developer note:
         # - Please add your mocked APIs in chronological order
         # - For nested APIs:
         #   - Add spacing above and below
         #   - Use `spec=MyAPI` only for "top level"
         #   - Use `spec_set=MyNestedAPI` for all nested APIs
+        self.canvas = MagicMock(spec=CanvasAPI)
+        self.canvas.industrial = MagicMock(spec_set=IndustrialCanvasAPI)
+        self.charts = MagicMock(spec_set=ChartsAPI)
+        self.files = MagicMock(spec_set=ExtendedFileMetadataAPI)
+        self.functions = MagicMock(spec=ExtendedFunctionsAPI)
+        self.functions.calls = MagicMock(spec_set=FunctionCallsAPI)
+        self.functions.schedules = MagicMock(spec_set=FunctionSchedulesAPI)
+        self.infield = MagicMock(spec=InfieldAPI)
+        self.infield.config = MagicMock(spec_set=InfieldConfigAPI)
+        self.infield.cdm_config = MagicMock(spec_set=InFieldCDMConfigAPI)
+
+        self.project = MagicMock(spec_set=ProjectAPI)
 
+        self.search = MagicMock(spec=SearchAPI)
+        self.search.locations = MagicMock(spec_set=LocationFiltersAPI)
+        self.search.configurations = MagicMock(spec_set=SearchConfigurationsAPI)
         self.dml = MagicMock(spec_set=DMLAPI)
-        self.location_filters = MagicMock(spec_set=LocationFiltersAPI)
         self.lookup = MagicMock(spec=LookUpGroup)
         self.lookup.data_sets = MagicMock(spec_set=DataSetLookUpAPI)
         self.lookup.assets = MagicMock(spec_set=AssetLookUpAPI)
         self.lookup.time_series = MagicMock(spec_set=TimeSeriesLookUpAPI)
+        self.lookup.files = MagicMock(spec_set=FileMetadataLookUpAPI)
+        self.lookup.events = MagicMock(spec_set=EventLookUpAPI)
         self.lookup.security_categories = MagicMock(spec_set=SecurityCategoriesLookUpAPI)
         self.lookup.location_filters = MagicMock(spec_set=LocationFiltersLookUpAPI)
         self.lookup.extraction_pipelines = MagicMock(spec_set=ExtractionPipelineLookUpAPI)
+        self.lookup.functions = MagicMock(spec_set=FunctionLookUpAPI)
+        self.migration = MagicMock(spec=MigrationAPI)
+        self.migration.instance_source = MagicMock(spec_set=InstanceSourceAPI)
+        self.migration.lookup = MagicMock(spec=MigrationLookupAPI)
+        self.migration.lookup.assets = MagicMock(spec_set=LookupAPI)
+        self.migration.lookup.events = MagicMock(spec_set=LookupAPI)
+        self.migration.lookup.files = MagicMock(spec_set=LookupAPI)
+        self.migration.lookup.time_series = MagicMock(spec_set=LookupAPI)
+        self.migration.resource_view_mapping = MagicMock(spec_set=ResourceViewMappingAPI)
+        self.migration.created_source_system = MagicMock(spec_set=CreatedSourceSystemAPI)
+        self.raw = MagicMock(spec=ExtendedRawAPI)
+        self.raw.databases = MagicMock(spec_set=RawDatabasesAPI)
+        self.raw.rows = MagicMock(spec_set=RawRowsAPI)
+        self.raw.tables = MagicMock(spec_set=RawTablesAPI)
 
         self.robotics = MagicMock()
         self.robotics.robots = MagicMock(spec=RoboticsAPI)
@@ -64,14 +126,29 @@ class ToolkitClientMock(CogniteClientMock):
         self.robotics.maps = MagicMock(spec_set=MapsAPI)
         self.robotics.capabilities = MagicMock(spec_set=CapabilitiesAPI)
 
-        self.data_modeling.statistics = MagicMock(spec_set=StatisticsAPI)
+        self.data_modeling.instances = MagicMock(spec_set=ExtendedInstancesAPI)
+
+        self.time_series = MagicMock(spec=ExtendedTimeSeriesAPI)
+        self.time_series.data = MagicMock(spec=DatapointsAPI)
+        self.time_series.data.synthetic = MagicMock(spec_set=SyntheticDatapointsAPI)
+        self.time_series.subscriptions = MagicMock(spec_set=DatapointsSubscriptionAPI)
+
+        self.tool = MagicMock(spec=ToolAPI)
+        self.tool.three_d = MagicMock(spec=ThreeDAPI)
+        self.tool.three_d.models = MagicMock(spec_set=ThreeDModelAPI)
+
+        self.streams = MagicMock(spec=StreamsAPI)
 
+        # This is a helper API, not a real API.
+        self.token = TokenAPI(self)
         self.verify = MagicMock(spec_set=VerifyAPI)
 
 
 @contextmanager
 def monkeypatch_toolkit_client() -> Iterator[ToolkitClientMock]:
     toolkit_client_mock = ToolkitClientMock()
-    ToolkitClient.__new__ = lambda *args, **kwargs: toolkit_client_mock  # type: ignore[method-assign]
-    yield toolkit_client_mock
-    ToolkitClient.__new__ = lambda cls, *args, **kwargs: object.__new__(cls)  # type: ignore[method-assign]
+    try:
+        ToolkitClient.__new__ = lambda *args, **kwargs: toolkit_client_mock  # type: ignore[method-assign]
+        yield toolkit_client_mock
+    finally:
+        ToolkitClient.__new__ = lambda cls, *args, **kwargs: object.__new__(cls)  # type: ignore[method-assign]

cognite_toolkit/_cdf_tk/client/utils/_concurrency.py

@@ -2,9 +2,10 @@ from concurrent.futures import ThreadPoolExecutor
 
 from cognite.client.utils._concurrency import ConcurrencySettings, TaskExecutor
 
-from cognite_toolkit._cdf_tk.client._constants import DATA_MODELING_MAX_WRITE_WORKERS
+from cognite_toolkit._cdf_tk.client._constants import DATA_MODELING_MAX_DELETE_WORKERS, DATA_MODELING_MAX_WRITE_WORKERS
 
 _DATA_MODELING_WRITE_THREAD_POOL_EXECUTOR_SINGLETON: ThreadPoolExecutor
+_DATA_MODELING_DELETE_THREAD_POOL_EXECUTOR_SINGLETON: ThreadPoolExecutor
 
 
 class ToolkitConcurrencySettings(ConcurrencySettings):
@@ -33,3 +34,25 @@ class ToolkitConcurrencySettings(ConcurrencySettings):
                 DATA_MODELING_MAX_WRITE_WORKERS
             )
         return executor
+
+    @classmethod
+    def get_data_modeling_delete_executor(cls) -> TaskExecutor:
+        """
+        The data modeling delete backend has different concurrency limits compared with the rest of CDF.
+        Thus, we use a dedicated executor for these endpoints to match the backend requirements.
+
+        Returns:
+            TaskExecutor: The data modeling delete executor.
+        """
+        if cls.uses_mainthread():
+            return cls.get_mainthread_executor()
+
+        global _DATA_MODELING_DELETE_THREAD_POOL_EXECUTOR_SINGLETON
+        try:
+            executor = _DATA_MODELING_DELETE_THREAD_POOL_EXECUTOR_SINGLETON
+        except NameError:
+            # TPE has not been initialized
+            executor = _DATA_MODELING_DELETE_THREAD_POOL_EXECUTOR_SINGLETON = ThreadPoolExecutor(
+                DATA_MODELING_MAX_DELETE_WORKERS
+            )
+        return executor