cognite-toolkit 0.6.39__py3-none-any.whl → 0.7.30__py3-none-any.whl

cognite_toolkit/_cdf_tk/cdf_toml.py

@@ -9,7 +9,7 @@ from typing import Any, ClassVar
 from rich import print
 
 from cognite_toolkit import _version
-from cognite_toolkit._cdf_tk.constants import clean_name
+from cognite_toolkit._cdf_tk.constants import RESOURCES_PATH, EnvType, clean_name
 from cognite_toolkit._cdf_tk.exceptions import (
     ToolkitRequiredValueError,
     ToolkitTOMLFormatError,
@@ -78,17 +78,13 @@ class Library:
     url: str
     checksum: str
 
-    @classmethod
-    def load(cls, raw: dict[str, Any]) -> Self:
-        if "url" not in raw:
-            raise ValueError("Library configuration must contain 'url' field.")
-
-        if "checksum" not in raw:
-            raise ValueError("Library configuration must contain 'checksum' field.")
+    def __post_init__(self) -> None:
+        self._validate()
 
-        parsed_url = urllib.parse.urlparse(raw["url"])
+    def _validate(self) -> None:
+        parsed_url = urllib.parse.urlparse(self.url)
 
-        if not all([parsed_url.scheme, parsed_url.netloc]):
+        if not (parsed_url.scheme and parsed_url.netloc):
             raise ValueError("URL is missing scheme or network location (e.g., 'https://domain.com')")
 
         if parsed_url.scheme != "https":
@@ -97,6 +93,14 @@ class Library:
         if not parsed_url.path.casefold().endswith(".zip"):
             raise ValueError("URL must point to a .zip file.")
 
+    @classmethod
+    def load(cls, raw: dict[str, Any]) -> Self:
+        if "url" not in raw:
+            raise ValueError("Library configuration must contain 'url' field.")
+
+        if "checksum" not in raw:
+            raise ValueError("Library configuration must contain 'checksum' field.")
+
         return cls(**raw)
 
 
@@ -172,6 +176,25 @@ class CDFToml:
                 is_loaded_from_file=False,
             )
 
+    @classmethod
+    def write(cls, organization_dir: Path, env: EnvType = "dev", version: str = _version.__version__) -> None:
+        destination = Path.cwd() / CDFToml.file_name
+        if destination.exists():
+            print("cdf.toml file already exists. Skipping creation.")
+            return
+        cdf_toml_content = (RESOURCES_PATH / CDFToml.file_name).read_text(encoding="utf-8")
+        cdf_toml_content = cdf_toml_content.replace("0.0.0", version)
+        if organization_dir != Path.cwd():
+            cdf_toml_content = cdf_toml_content.replace(
+                "#<PLACEHOLDER>",
+                f'''
+default_organization_dir = "{organization_dir.name}"''',
+            )
+        else:
+            cdf_toml_content = cdf_toml_content.replace("#<PLACEHOLDER>", "")
+        cdf_toml_content = cdf_toml_content.replace("<DEFAULT_ENV_PLACEHOLDER>", env)
+        destination.write_text(cdf_toml_content, encoding="utf-8")
+
 
 def _read_toml(file_path: Path) -> dict[str, Any]:
     # TOML files are required to be UTF-8 encoded

cognite_toolkit/_cdf_tk/client/__init__.py

@@ -1,3 +1,4 @@
-from ._toolkit_client import ToolkitClient, ToolkitClientConfig
+from ._toolkit_client import ToolkitClient
+from .config import ToolkitClientConfig
 
 __all__ = ["ToolkitClient", "ToolkitClientConfig"]

cognite_toolkit/_cdf_tk/client/_toolkit_client.py

@@ -1,8 +1,9 @@
-from typing import Literal, cast
-from urllib.parse import urljoin
+from typing import cast
 
-from cognite.client import ClientConfig, CogniteClient
-from cognite.client.credentials import CredentialProvider
+from cognite.client import CogniteClient
+from rich.console import Console
+
+from cognite_toolkit._cdf_tk.utils.http_client import HTTPClient
 
 from .api.canvas import CanvasAPI
 from .api.charts import ChartsAPI
@@ -12,118 +13,48 @@ 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
 from .api.lookup import LookUpGroup
 from .api.migration import MigrationAPI
+from .api.project import ProjectAPI
 from .api.robotics import RoboticsAPI
 from .api.search import SearchAPI
+from .api.streams import StreamsAPI
+from .api.three_d import ThreeDAPI
 from .api.token import TokenAPI
 from .api.verify import VerifyAPI
+from .config import ToolkitClientConfig
 
 
-class ToolkitClientConfig(ClientConfig):
-    def __init__(
-        self,
-        client_name: str,
-        project: str,
-        credentials: CredentialProvider,
-        api_subversion: str | None = None,
-        base_url: str | None = None,
-        max_workers: int | None = None,
-        is_strict_validation: bool = True,
-        headers: dict[str, str] | None = None,
-        timeout: int | None = None,
-        file_transfer_timeout: int | None = None,
-        debug: bool = False,
-    ) -> None:
-        super().__init__(
-            client_name=client_name,
-            project=project,
-            credentials=credentials,
-            api_subversion=api_subversion,
-            base_url=base_url,
-            max_workers=max_workers,
-            headers=headers,
-            timeout=timeout,
-            file_transfer_timeout=file_transfer_timeout,
-            debug=debug,
-        )
-        self.is_strict_validation = is_strict_validation
-
-    @property
-    def cloud_provider(self) -> Literal["azure", "aws", "gcp", "unknown"]:
-        cdf_cluster = self.cdf_cluster
-        if cdf_cluster is None:
-            return "unknown"
-        elif cdf_cluster.startswith("az-") or cdf_cluster in {"azure-dev", "bluefield", "westeurope-1"}:
-            return "azure"
-        elif cdf_cluster.startswith("aws-") or cdf_cluster in {"orangefield"}:
-            return "aws"
-        elif cdf_cluster.startswith("gc-") or cdf_cluster in {
-            "greenfield",
-            "asia-northeast1-1",
-            "cognitedata-development",
-            "cognitedata-production",
-        }:
-            return "gcp"
-        else:
-            return "unknown"
-
-    @property
-    def is_private_link(self) -> bool:
-        if "cognitedata.com" not in self.base_url:
-            return False
-        subdomain = self.base_url.split("cognitedata.com", maxsplit=1)[0]
-        return "plink" in subdomain
-
-    def create_api_url(self, endpoint: str) -> str:
-        """Create a full API URL for the given endpoint.
-
-        Args:
-            endpoint (str): The API endpoint to append to the base URL.
-
-        Returns:
-            str: The full API URL.
-
-        Examples:
-            >>> config = ToolkitClientConfig(cluster="bluefield", project="my_project", ...)
-            >>> config.create_api_url("/models/instances")
-            "https://bluefield.cognitedata.com/api/v1/my_project/models/instances"
-        """
-        if not endpoint.startswith("/"):
-            endpoint = f"/{endpoint}"
-        return f"{self.base_url}/api/v1/projects/{self.project}{endpoint}"
-
-    def create_app_url(self, endpoint: str) -> str:
-        """Create a full App URL for the given endpoint.
-
-        Args:
-            endpoint (str): The App endpoint to append to the base URL.
-
-        Returns:
-            str: The full App URL.
+class ToolAPI:
+    """This is reimplemented CogniteAPIs in Toolkit"""
 
-        Examples:
-            >>> config = ToolkitClientConfig(cluster="bluefield", project="my_project", ...)
-            >>> config.create_app_url("/some/app/endpoint")
-            "https://bluefield.cognitedata.com/apps/v1/projects/my_project/some/app/endpoint"
-        """
-        if not endpoint:
-            raise ValueError("Endpoint must be a non-empty string")
-        if not endpoint.startswith("/"):
-            endpoint = f"/{endpoint}"
-        base_path = f"/apps/v1/projects/{self.project}{endpoint}"
-        return urljoin(self.base_url, base_path)
+    def __init__(self, http_client: HTTPClient, console: Console) -> None:
+        self.http_client = http_client
+        self.three_d = ThreeDAPI(http_client, console)
 
 
 class ToolkitClient(CogniteClient):
-    def __init__(self, config: ToolkitClientConfig | None = None, enable_set_pending_ids: bool = False) -> None:
+    def __init__(
+        self,
+        config: ToolkitClientConfig | None = None,
+        enable_set_pending_ids: bool = False,
+        console: Console | None = None,
+    ) -> None:
         super().__init__(config=config)
+        http_client = HTTPClient(self.config)
+        self.http_client = http_client
+        toolkit_config = ToolkitClientConfig.from_client_config(self.config)
+        self.console = console or Console()
+        self.tool = ToolAPI(http_client, self.console)
         self.search = SearchAPI(self._config, self._API_VERSION, self)
         self.robotics = RoboticsAPI(self._config, self._API_VERSION, self)
         self.dml = DMLAPI(self._config, self._API_VERSION, self)
         self.verify = VerifyAPI(self._config, self._API_VERSION, self)
-        self.lookup = LookUpGroup(self._config, self._API_VERSION, self)
-        self.functions: ExtendedFunctionsAPI = ExtendedFunctionsAPI(self._config, self._API_VERSION, self)
+        self.lookup = LookUpGroup(self._config, self._API_VERSION, self, self.console)
+        self.functions: ExtendedFunctionsAPI = ExtendedFunctionsAPI(
+            toolkit_config, self._API_VERSION, self, self.console
+        )
         self.data_modeling: ExtendedDataModelingAPI = ExtendedDataModelingAPI(self._config, self._API_VERSION, self)
         if enable_set_pending_ids:
             self.time_series: ExtendedTimeSeriesAPI = ExtendedTimeSeriesAPI(self._config, self._API_VERSION, self)
@@ -133,6 +64,9 @@ class ToolkitClient(CogniteClient):
         self.migration = MigrationAPI(self.data_modeling.instances)
         self.token = TokenAPI(self)
         self.charts = ChartsAPI(self._config, self._API_VERSION, self)
+        self.project = ProjectAPI(config=toolkit_config, cognite_client=self)
+        self.infield = InfieldAPI(http_client, self.console)
+        self.streams = StreamsAPI(http_client, self.console)
 
     @property
     def config(self) -> ToolkitClientConfig:

cognite_toolkit/_cdf_tk/client/api/canvas.py

@@ -98,7 +98,8 @@ class IndustrialCanvasAPI:
         result = self._instance_api.query(retrieve_query)
         if len(result["canvas"]) == 0:
             return None
-        return IndustrialCanvas.load(result)
+        # MyPy fails to understand that query result is a dict.
+        return IndustrialCanvas._load(result)  # type: ignore[arg-type]
 
     def update(self, canvas: IndustrialCanvasApply) -> InstancesApplyResultList:
         new_instance_ids = canvas.as_instance_ids(include_solution_tags=False)

cognite_toolkit/_cdf_tk/client/api/extended_functions.py

@@ -1,51 +1,32 @@
-import gzip
-import random
-import time
-from collections.abc import MutableMapping
-
-import requests
-from cognite.client import ClientConfig, CogniteClient, global_config
+from cognite.client import CogniteClient
 from cognite.client._api.functions import FunctionsAPI
-from cognite.client._http_client import HTTPClient, HTTPClientConfig, get_global_requests_session
+from cognite.client.config import global_config
 from cognite.client.data_classes import Function, FunctionWrite
-from cognite.client.utils import _json
-from cognite.client.utils._auxiliary import get_user_agent
-from requests.structures import CaseInsensitiveDict
+from cognite.client.utils.useful_types import SequenceNotStr
 from rich.console import Console
 
-from cognite_toolkit._cdf_tk.tk_warnings import HighSeverityWarning
-from cognite_toolkit._cdf_tk.utils._auxiliary import get_current_toolkit_version
+from cognite_toolkit._cdf_tk.client.config import ToolkitClientConfig
+from cognite_toolkit._cdf_tk.utils.collection import chunker
+from cognite_toolkit._cdf_tk.utils.http_client import HTTPClient, SimpleBodyRequest
 from cognite_toolkit._cdf_tk.utils.useful_types import JsonVal
 
 
 class ExtendedFunctionsAPI(FunctionsAPI):
     def __init__(
         self,
-        config: ClientConfig,
+        config: ToolkitClientConfig,
         api_version: str | None,
         cognite_client: CogniteClient,
+        console: Console | None = None,
     ) -> None:
         """
         Extended Functions API to include custom headers and payload preparation.
         """
         super().__init__(config, api_version, cognite_client)
-        session = get_global_requests_session()
-        # The HTTPClient in the parent class always retries 429 responses, but we want to handle that manually.
-        self._http_client_no_retry = HTTPClient(
-            config=HTTPClientConfig(
-                status_codes_to_retry=set(),
-                backoff_factor=0.5,
-                max_backoff_seconds=global_config.max_retry_backoff,
-                max_retries_total=global_config.max_retries,
-                max_retries_read=0,
-                max_retries_connect=global_config.max_retries_connect,
-                max_retries_status=0,
-            ),
-            session=session,
-            refresh_auth_header=self._refresh_auth_header,
-        )
+        self._toolkit_config = config
+        self._toolkit_http_client = HTTPClient(config, max_retries=global_config.max_retries, console=console)
 
-    def create_with_429_retry(self, function: FunctionWrite, console: Console | None = None) -> Function:
+    def create_with_429_retry(self, function: FunctionWrite) -> Function:
         """Create a function with manual retry handling for 429 Too Many Requests responses.
 
         This method is a workaround for scenarios where the function creation API is temporarily unavailable
@@ -58,75 +39,42 @@ class ExtendedFunctionsAPI(FunctionsAPI):
         Returns:
             Function: The created function object.
         """
-        headers = self._create_headers()
-        payload = self._prepare_payload({"items": [function.dump(camel_case=True)]})
-        _, full_url = self._resolve_url("POST", self._RESOURCE_PATH)
-        retry_count = 0
-        while True:
-            response = self._http_client_no_retry.request(
+        result = self._toolkit_http_client.request_with_retries(
+            message=SimpleBodyRequest(
+                endpoint_url=self._toolkit_config.create_api_url("/functions"),
                 method="POST",
-                url=full_url,
-                headers=headers,
-                data=payload,
-                timeout=self._config.timeout,
-                allow_redirects=False,
+                body_content={"items": [function.dump(camel_case=True)]},
             )
+        )
+        result.raise_for_status()
+        # We assume the API response is one item on a successful creation
+        return Function._load(result.get_first_body()["items"][0], cognite_client=self._cognite_client)  # type: ignore[arg-type,index]
 
-            match response.status_code:
-                case 200 | 201 | 202 | 204:
-                    return Function._load(response.json()["items"][0], cognite_client=self._cognite_client)
-                case 401:
-                    self._raise_no_project_access_error(response)
-                case 429 if retry_count < global_config.max_retries:
-                    try:
-                        retry_after = float(response.headers.get("Retry-After", 60))
-                    except ValueError:
-                        retry_after = 60.0 + random.uniform(-5, 5)
-                    HighSeverityWarning(f"Rate limit exceeded. Retrying after {retry_after} seconds.").print_warning(
-                        console=console
-                    )
-                    time.sleep(retry_after)
-                    retry_count += 1
-                    continue
-                case _:
-                    self._raise_api_error(response, {"items": function.dump(camel_case=True)})
+    def delete_with_429_retry(self, external_id: SequenceNotStr[str], ignore_unknown_ids: bool = False) -> None:
+        """Delete one or more functions with retry handling for 429 Too Many Requests responses.
 
-    def _create_headers(self) -> MutableMapping[str, str]:
-        headers: MutableMapping[str, str] = CaseInsensitiveDict()
-        headers.update(requests.utils.default_headers())
-        auth_name, auth_value = self._config.credentials.authorization_header()
-        headers[auth_name] = auth_value
-        headers["content-type"] = "application/json"
-        headers["accept"] = "application/json"
-        headers["x-cdp-sdk"] = f"CogniteToolkit:{get_current_toolkit_version()}"
-        headers["x-cdp-app"] = self._config.client_name
-        headers["cdf-version"] = self._config.api_subversion
-        if "User-Agent" in headers:
-            headers["User-Agent"] += f" {get_user_agent()}"
-        else:
-            headers["User-Agent"] = get_user_agent()
-        if not global_config.disable_gzip:
-            headers["Content-Encoding"] = "gzip"
-        return headers
+        This method is an improvement over the standard delete method in the FunctionsAPI.
 
-    @staticmethod
-    def _prepare_payload(body: JsonVal) -> str | bytes:
-        """
-        Prepare the payload for the HTTP request.
-        This method should be overridden in subclasses to customize the payload format.
-        """
-        data: str | bytes
-        try:
-            data = _json.dumps(body, allow_nan=False)
-        except ValueError as e:
-            # A lot of work to give a more human friendly error message when nans and infs are present:
-            msg = "Out of range float values are not JSON compliant"
-            if msg in str(e):  # exc. might e.g. contain an extra ": nan", depending on build (_json.make_encoder)
-                raise ValueError(f"{msg}. Make sure your data does not contain NaN(s) or +/- Inf!").with_traceback(
-                    e.__traceback__
-                ) from None
-            raise
 
-        if not global_config.disable_gzip:
-            data = gzip.compress(data.encode())
-        return data
+        Args:
+            external_id (SequenceNotStr[str]): The external IDs of the functions to delete.
+            ignore_unknown_ids (bool): Ignore IDs and external IDs that are not found.
+            console (Console | None): The rich console to use for printing warnings.
+
+        Returns:
+            None
+        """
+        for chunk in chunker(external_id, self._DELETE_LIMIT):
+            body_content: dict[str, JsonVal] = {
+                "items": [{"externalId": eid} for eid in chunk],
+            }
+            if ignore_unknown_ids:
+                body_content["ignoreUnknownIds"] = True
+            self._toolkit_http_client.request_with_retries(
+                message=SimpleBodyRequest(
+                    endpoint_url=self._toolkit_config.create_api_url("/functions/delete"),
+                    method="POST",
+                    body_content=body_content,
+                )
+            ).raise_for_status()
+        return None

cognite_toolkit/_cdf_tk/client/api/infield.py

@@ -0,0 +1,248 @@
+from collections.abc import Sequence
+from typing import Any, cast
+
+from rich.console import Console
+
+from cognite_toolkit._cdf_tk.client.data_classes.api_classes import PagedResponse, QueryResponse
+from cognite_toolkit._cdf_tk.client.data_classes.infield import (
+    DataExplorationConfig,
+    InFieldCDMLocationConfig,
+    InfieldLocationConfig,
+)
+from cognite_toolkit._cdf_tk.client.data_classes.instance_api import (
+    InstanceResponseItem,
+    InstanceResult,
+    NodeIdentifier,
+)
+from cognite_toolkit._cdf_tk.tk_warnings import HighSeverityWarning
+from cognite_toolkit._cdf_tk.utils.http_client import HTTPClient, ItemsRequest, SimpleBodyRequest
+
+
+class InfieldConfigAPI:
+    ENDPOINT = "/models/instances"
+    LOCATION_REF = "locationConfig"
+    EXPLORATION_REF = "explorerConfig"
+    # We know that this key exists and it has alias set.
+    DATA_EXPLORATION_PROP_ID = cast(str, InfieldLocationConfig.model_fields["data_exploration_config"].alias)
+
+    def __init__(self, http_client: HTTPClient, console: Console) -> None:
+        self._http_client = http_client
+        self._console = console
+        self._config = http_client.config
+
+    def apply(self, items: Sequence[InfieldLocationConfig]) -> list[InstanceResult]:
+        if len(items) > 500:
+            raise ValueError("Cannot apply more than 500 InfieldLocationConfig items at once.")
+
+        request_items = (
+            [item.as_request_item()]
+            if item.data_exploration_config is None
+            else [item.as_request_item(), item.data_exploration_config.as_request_item()]
+            for item in items
+        )
+        responses = self._http_client.request_with_retries(
+            ItemsRequest(
+                endpoint_url=self._config.create_api_url(self.ENDPOINT),
+                method="POST",
+                items=[item for sublist in request_items for item in sublist],
+            )
+        )
+        responses.raise_for_status()
+        return PagedResponse[InstanceResult].model_validate(responses.get_first_body()).items
+
+    def retrieve(self, items: Sequence[NodeIdentifier]) -> list[InfieldLocationConfig]:
+        if len(items) > 100:
+            raise ValueError("Cannot retrieve more than 100 InfieldLocationConfig items at once.")
+        if not items:
+            return []
+        responses = self._http_client.request_with_retries(
+            SimpleBodyRequest(
+                # We use the query endpoint to be able to retrieve linked DataExplorationConfig items
+                endpoint_url=self._config.create_api_url(f"{self.ENDPOINT}/query"),
+                method="POST",
+                body_content=self._retrieve_query(items),
+            )
+        )
+        responses.raise_for_status()
+        parsed_response = QueryResponse[InstanceResponseItem].model_validate(responses.get_first_body())
+        return self._parse_retrieve_response(parsed_response)
+
+    def delete(self, items: Sequence[InfieldLocationConfig]) -> list[NodeIdentifier]:
+        if len(items) > 500:
+            raise ValueError("Cannot delete more than 500 InfieldLocationConfig items at once.")
+
+        identifiers = (
+            [item.as_id()]
+            if item.data_exploration_config is None
+            else [item.as_id(), item.data_exploration_config.as_id()]
+            for item in items
+        )
+        responses = self._http_client.request_with_retries(
+            ItemsRequest(
+                endpoint_url=self._config.create_api_url(f"{self.ENDPOINT}/delete"),
+                method="POST",
+                items=[identifier for sublist in identifiers for identifier in sublist],
+            )
+        )
+        responses.raise_for_status()
+        return PagedResponse[NodeIdentifier].model_validate(responses.get_first_body()).items
+
+    @classmethod
+    def _retrieve_query(cls, items: Sequence[NodeIdentifier]) -> dict[str, Any]:
+        return {
+            "with": {
+                cls.LOCATION_REF: {
+                    "limit": len(items),
+                    "nodes": {
+                        "filter": {
+                            "instanceReferences": [
+                                {"space": item.space, "externalId": item.external_id} for item in items
+                            ]
+                        },
+                    },
+                },
+                cls.EXPLORATION_REF: {
+                    "nodes": {
+                        "from": "locationConfig",
+                        "direction": "outwards",
+                        "through": {
+                            "source": InfieldLocationConfig.VIEW_ID.dump(),
+                            "identifier": cls.DATA_EXPLORATION_PROP_ID,
+                        },
+                    }
+                },
+            },
+            "select": {
+                cls.LOCATION_REF: {
+                    "sources": [{"source": InfieldLocationConfig.VIEW_ID.dump(), "properties": ["*"]}],
+                },
+                cls.EXPLORATION_REF: {
+                    "sources": [{"source": DataExplorationConfig.VIEW_ID.dump(), "properties": ["*"]}],
+                },
+            },
+        }
+
+    def _parse_retrieve_response(
+        self, parsed_response: QueryResponse[InstanceResponseItem]
+    ) -> list[InfieldLocationConfig]:
+        data_exploration_results = (
+            DataExplorationConfig.model_validate(
+                item.get_properties_for_source(DataExplorationConfig.VIEW_ID, include_identifier=True)
+            )
+            for item in parsed_response.items[self.EXPLORATION_REF]
+        )
+        data_exploration_config_map = {(dec.space, dec.external_id): dec for dec in data_exploration_results}
+        result: list[InfieldLocationConfig] = []
+        for item in parsed_response.items[self.LOCATION_REF]:
+            properties = item.get_properties_for_source(InfieldLocationConfig.VIEW_ID, include_identifier=True)
+            data_exploration = properties.pop(self.DATA_EXPLORATION_PROP_ID, None)
+            if isinstance(data_exploration, dict):
+                space = data_exploration["space"]
+                external_id = data_exploration["externalId"]
+                if (space, external_id) not in data_exploration_config_map:
+                    HighSeverityWarning(
+                        f"{self.DATA_EXPLORATION_PROP_ID} with space '{space}' and externalId '{external_id}' referenced in InfieldLocationConfig '{properties['externalId']}' was not found in the retrieved results."
+                    ).print_warning(console=self._console)
+                else:
+                    # Pydantic allow already validated models to be assigned to fields
+                    properties[self.DATA_EXPLORATION_PROP_ID] = data_exploration_config_map[(space, external_id)]  # type: ignore[assignment,index]
+            else:
+                HighSeverityWarning(
+                    f"InfieldLocationConfig '{properties['externalId']}' is missing a valid {self.DATA_EXPLORATION_PROP_ID} reference."
+                ).print_warning(console=self._console)
+            result.append(InfieldLocationConfig.model_validate(properties))
+        return result
+
+
+class InFieldCDMConfigAPI:
+    ENDPOINT = "/models/instances"
+    LOCATION_REF = "cdmLocationConfig"
+
+    def __init__(self, http_client: HTTPClient, console: Console) -> None:
+        self._http_client = http_client
+        self._console = console
+        self._config = http_client.config
+
+    def apply(self, items: Sequence[InFieldCDMLocationConfig]) -> list[InstanceResult]:
+        if len(items) > 500:
+            raise ValueError("Cannot apply more than 500 InFieldCDMLocationConfig items at once.")
+
+        request_items = [item.as_request_item() for item in items]
+        responses = self._http_client.request_with_retries(
+            ItemsRequest(
+                endpoint_url=self._config.create_api_url(self.ENDPOINT),
+                method="POST",
+                items=request_items,  # type: ignore[arg-type]
+            )
+        )
+        responses.raise_for_status()
+        return PagedResponse[InstanceResult].model_validate(responses.get_first_body()).items
+
+    def retrieve(self, items: Sequence[NodeIdentifier]) -> list[InFieldCDMLocationConfig]:
+        if len(items) > 100:
+            raise ValueError("Cannot retrieve more than 100 InFieldCDMLocationConfig items at once.")
+        if not items:
+            return []
+        responses = self._http_client.request_with_retries(
+            SimpleBodyRequest(
+                endpoint_url=self._config.create_api_url(f"{self.ENDPOINT}/query"),
+                method="POST",
+                body_content=self._retrieve_query(items),
+            )
+        )
+        responses.raise_for_status()
+        parsed_response = QueryResponse[InstanceResponseItem].model_validate(responses.get_first_body())
+        return self._parse_retrieve_response(parsed_response)
+
+    def delete(self, items: Sequence[InFieldCDMLocationConfig]) -> list[NodeIdentifier]:
+        if len(items) > 500:
+            raise ValueError("Cannot delete more than 500 InFieldCDMLocationConfig items at once.")
+
+        identifiers: Sequence = [item.as_id() for item in items]
+        responses = self._http_client.request_with_retries(
+            ItemsRequest(
+                endpoint_url=self._config.create_api_url(f"{self.ENDPOINT}/delete"),
+                method="POST",
+                items=identifiers,  # type: ignore[arg-type]
+            )
+        )
+        responses.raise_for_status()
+        return PagedResponse[NodeIdentifier].model_validate(responses.get_first_body()).items
+
+    @classmethod
+    def _retrieve_query(cls, items: Sequence[NodeIdentifier]) -> dict[str, Any]:
+        return {
+            "with": {
+                cls.LOCATION_REF: {
+                    "limit": len(items),
+                    "nodes": {
+                        "filter": {
+                            "instanceReferences": [
+                                {"space": item.space, "externalId": item.external_id} for item in items
+                            ]
+                        },
+                    },
+                },
+            },
+            "select": {
+                cls.LOCATION_REF: {
+                    "sources": [{"source": InFieldCDMLocationConfig.VIEW_ID.dump(), "properties": ["*"]}],
+                },
+            },
+        }
+
+    def _parse_retrieve_response(
+        self, parsed_response: QueryResponse[InstanceResponseItem]
+    ) -> list[InFieldCDMLocationConfig]:
+        result: list[InFieldCDMLocationConfig] = []
+        for item in parsed_response.items[self.LOCATION_REF]:
+            properties = item.get_properties_for_source(InFieldCDMLocationConfig.VIEW_ID, include_identifier=True)
+            result.append(InFieldCDMLocationConfig.model_validate(properties))
+        return result
+
+
+class InfieldAPI:
+    def __init__(self, http_client: HTTPClient, console: Console) -> None:
+        self._http_client = http_client
+        self.config = InfieldConfigAPI(http_client, console)
+        self.cdm_config = InFieldCDMConfigAPI(http_client, console)