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

cognite_toolkit/_cdf_tk/apps/_purge.py

@@ -8,7 +8,6 @@ from rich import print
 
 from cognite_toolkit._cdf_tk.commands import PurgeCommand
 from cognite_toolkit._cdf_tk.exceptions import ToolkitValueError
-from cognite_toolkit._cdf_tk.feature_flags import Flags
 from cognite_toolkit._cdf_tk.storageio.selectors import (
     InstanceFileSelector,
     InstanceSelector,
@@ -31,8 +30,7 @@ class PurgeApp(typer.Typer):
         self.callback(invoke_without_command=True)(self.main)
         self.command("dataset")(self.purge_dataset)
         self.command("space")(self.purge_space)
-        if Flags.PURGE_INSTANCES.is_enabled() or Flags.v07.is_enabled():
-            self.command("instances")(self.purge_instances)
+        self.command("instances")(self.purge_instances)
 
     def main(self, ctx: typer.Context) -> None:
         """Commands deleting data from Cognite Data Fusion."""
@@ -48,21 +46,11 @@ class PurgeApp(typer.Typer):
                 help="External id of the dataset to purge. If not provided, interactive mode will be used.",
             ),
         ] = None,
-        include_dataset: Annotated[
-            bool,
-            typer.Option(
-                "--include-dataset",
-                "-i",
-                help="Whether to archive the dataset itself after purging its contents.",
-                hidden=Flags.v07.is_enabled(),
-            ),
-        ] = False,
         archive_dataset: Annotated[
             bool,
             typer.Option(
                 "--archive-dataset",
                 help="Whether to archive the dataset itself after purging its contents.",
-                hidden=not Flags.v07.is_enabled(),
             ),
         ] = False,
         skip_data: Annotated[
@@ -73,7 +61,6 @@ class PurgeApp(typer.Typer):
                 help="Skip deleting the data in the dataset, only delete configurations. The resources that are "
                 "considered data are: time series, event, files, assets, sequences, relationships, "
                 "labels, and 3D Models",
-                hidden=not Flags.v07.is_enabled(),
             ),
         ] = False,
         include_configurations: Annotated[
@@ -82,7 +69,6 @@ class PurgeApp(typer.Typer):
                 "--include-configurations",
                 "-c",
                 help="Include configurations, workflows, extraction pipelines and transformations in the purge.",
-                hidden=not Flags.v07.is_enabled(),
             ),
         ] = False,
         asset_recursive: Annotated[
@@ -92,7 +78,6 @@ class PurgeApp(typer.Typer):
                 "-a",
                 help="When deleting assets, delete all child assets recursively. CAVEAT: This can lead to assets"
                 " not in the selected dataset being deleted if they are children of assets in the dataset.",
-                hidden=not Flags.v07.is_enabled(),
             ),
         ] = False,
         dry_run: Annotated[
@@ -128,39 +113,28 @@ class PurgeApp(typer.Typer):
             # Is Interactive
             interactive = AssetInteractiveSelect(client, operation="purge")
             external_id = interactive.select_data_set(allow_empty=False)
-            if Flags.v07.is_enabled():
-                skip_data = not questionary.confirm(
-                    "Delete data in the dataset (time series, events, files, assets, sequences, relationships, labels, 3D models)?",
-                    default=True,
-                ).ask()
-                include_configurations = questionary.confirm(
-                    "Delete configurations (workflows, extraction pipelines and transformations) in the dataset?",
-                    default=False,
-                ).ask()
-                asset_recursive = questionary.confirm(
-                    "When deleting assets, delete all child assets recursively? (WARNING: This can lead "
-                    "to assets not in the selected dataset being deleted if they are children of assets in the dataset.)",
-                    default=False,
-                ).ask()
+            skip_data = not questionary.confirm(
+                "Delete data in the dataset (time series, events, files, assets, sequences, relationships, labels, 3D models)?",
+                default=True,
+            ).ask()
+            include_configurations = questionary.confirm(
+                "Delete configurations (workflows, extraction pipelines and transformations) in the dataset?",
+                default=False,
+            ).ask()
+            asset_recursive = questionary.confirm(
+                "When deleting assets, delete all child assets recursively? (WARNING: This can lead "
+                "to assets not in the selected dataset being deleted if they are children of assets in the dataset.)",
+                default=False,
+            ).ask()
             archive_dataset = questionary.confirm("Archive the dataset itself after purging?", default=False).ask()
             dry_run = questionary.confirm("Dry run?", default=True).ask()
             verbose = questionary.confirm("Verbose?", default=True).ask()
 
-            user_options = [archive_dataset, dry_run, verbose]
-            if Flags.v07.is_enabled():
-                user_options.extend([skip_data, include_configurations, asset_recursive])
+            user_options = [archive_dataset, dry_run, verbose, skip_data, include_configurations, asset_recursive]
 
             if any(selected is None for selected in user_options):
                 raise typer.Abort("Aborted by user.")
 
-        else:
-            archive_dataset = archive_dataset if Flags.v07.is_enabled() else include_dataset
-
-        if not Flags.v07.is_enabled():
-            skip_data = False
-            include_configurations = True
-            asset_recursive = False
-
         cmd.run(
             lambda: cmd.dataset(
                 client,
@@ -197,7 +171,6 @@ class PurgeApp(typer.Typer):
             typer.Option(
                 "--delete-datapoints",
                 help="Delete datapoints linked to CogniteTimeSeries nodes in the space.",
-                hidden=not Flags.v07.is_enabled(),
             ),
         ] = False,
         delete_file_content: Annotated[
@@ -205,7 +178,6 @@ class PurgeApp(typer.Typer):
             typer.Option(
                 "--delete-file-content",
                 help="Delete file content linked to CogniteFile nodes in the space.",
-                hidden=not Flags.v07.is_enabled(),
             ),
         ] = False,
         dry_run: Annotated[

cognite_toolkit/_cdf_tk/apps/_run.py

@@ -23,9 +23,15 @@ class RunApp(typer.Typer):
         self.command("workflow")(self.run_workflow)
         self.add_typer(RunFunctionApp(*args, **kwargs), name="function")
 
+    @staticmethod
+    def _print_deprecation_warning() -> None:
+        """Print deprecation warning for the run plugin."""
+        print("The run plugin is deprecated and will be replaced by the dev plugin in v0.8.0.")
+
     @staticmethod
     def main(ctx: typer.Context) -> None:
         """Commands to execute processes in CDF."""
+        RunApp._print_deprecation_warning()
         if ctx.invoked_subcommand is None:
             print("Use [bold yellow]cdf run --help[/] for more information.")
 
@@ -51,6 +57,7 @@ class RunApp(typer.Typer):
         ] = False,
     ) -> None:
         """This command will run the specified transformation using a one-time session."""
+        RunApp._print_deprecation_warning()
         cmd = RunTransformationCommand()
         client = EnvironmentVariables.create_from_environment().get_client()
         cmd.run(lambda: cmd.run_transformation(client, external_id))
@@ -108,6 +115,7 @@ class RunApp(typer.Typer):
         ] = False,
     ) -> None:
         """This command will run the specified workflow."""
+        RunApp._print_deprecation_warning()
         cmd = RunWorkflowCommand()
         env_vars = EnvironmentVariables.create_from_environment()
         cmd.run(lambda: cmd.run_workflow(env_vars, organization_dir, env_name, external_id, version, wait))
@@ -123,6 +131,7 @@ class RunFunctionApp(typer.Typer):
     @staticmethod
     def main(ctx: typer.Context) -> None:
         """Commands to execute function."""
+        RunApp._print_deprecation_warning()
         if ctx.invoked_subcommand is None:
             print("Use [bold yellow]cdf run function --help[/] for more information.")
 
@@ -178,6 +187,7 @@ class RunFunctionApp(typer.Typer):
         ] = False,
     ) -> None:
         """This command will run the specified function locally."""
+        RunApp._print_deprecation_warning()
         cmd = RunFunctionCommand()
         env_vars = EnvironmentVariables.create_from_environment()
         cmd.run(
@@ -243,6 +253,7 @@ class RunFunctionApp(typer.Typer):
         ] = False,
     ) -> None:
         """This command will run the specified function (assuming it is deployed) in CDF."""
+        RunApp._print_deprecation_warning()
         cmd = RunFunctionCommand()
         env_vars = EnvironmentVariables.create_from_environment()
         cmd.run(lambda: cmd.run_cdf(env_vars, organization_dir, env_name, external_id, schedule, wait))

cognite_toolkit/_cdf_tk/apps/_upload_app.py

@@ -1,10 +1,12 @@
 from pathlib import Path
 from typing import Annotated, Any
 
+import questionary
 import typer
+from questionary import Choice
 
 from cognite_toolkit._cdf_tk.commands import UploadCommand
-from cognite_toolkit._cdf_tk.constants import DATA_DEFAULT_DIR
+from cognite_toolkit._cdf_tk.constants import DATA_DEFAULT_DIR, DATA_MANIFEST_SUFFIX, DATA_RESOURCE_DIR
 from cognite_toolkit._cdf_tk.utils.auth import EnvironmentVariables
 
 DEFAULT_INPUT_DIR = Path.cwd() / DATA_DEFAULT_DIR
@@ -14,20 +16,28 @@ class UploadApp(typer.Typer):
     def __init__(self, *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
         self.callback(invoke_without_command=True)(self.upload_main)
+        self.command("dir")(self.upload_dir)
 
     @staticmethod
-    def upload_main(
+    def upload_main(ctx: typer.Context) -> None:
+        """Commands to upload data to CDF."""
+        if ctx.invoked_subcommand is None:
+            print("Use [bold yellow]cdf upload --help[/] for more information.")
+        return None
+
+    @staticmethod
+    def upload_dir(
         ctx: typer.Context,
         input_dir: Annotated[
-            Path,
+            Path | None,
             typer.Argument(
-                help="The directory containing the data to upload.",
+                help="The directory containing the data to upload. If not specified, an interactive prompt will ask for the directory.",
                 exists=True,
                 file_okay=False,
                 dir_okay=True,
                 resolve_path=True,
             ),
-        ],
+        ] = None,
         dry_run: Annotated[
             bool,
             typer.Option(
@@ -43,7 +53,7 @@ class UploadApp(typer.Typer):
                 "-r",
                 help="If set, the command will look for resource configuration files in adjacent folders and create them if they do not exist.",
             ),
-        ] = True,
+        ] = False,
         verbose: Annotated[
             bool,
             typer.Option(
@@ -55,6 +65,35 @@ class UploadApp(typer.Typer):
     ) -> None:
         """Commands to upload data to CDF."""
         cmd = UploadCommand()
+        if input_dir is None:
+            input_candidate = sorted({p.parent for p in DEFAULT_INPUT_DIR.rglob(f"**/*{DATA_MANIFEST_SUFFIX}")})
+            if not input_candidate:
+                typer.echo(f"No data manifests found in default directory: {DEFAULT_INPUT_DIR}")
+                raise typer.Exit(code=1)
+            input_dir = questionary.select(
+                "Select the input directory containing the data to upload:",
+                choices=[Choice(str(option.name), value=option) for option in input_candidate],
+            ).ask()
+            if input_dir is None:
+                typer.echo("No input directory selected. Exiting.")
+                raise typer.Exit(code=1)
+            dry_run = questionary.confirm("Proceed with dry run?", default=dry_run).ask()
+            if dry_run is None:
+                typer.echo("No selection made for dry run. Exiting.")
+                raise typer.Exit(code=1)
+            resource_dir = Path(input_dir) / DATA_RESOURCE_DIR
+            if resource_dir.exists():
+                if resource_dir.is_relative_to(Path.cwd()):
+                    display_name = resource_dir.relative_to(Path.cwd()).as_posix()
+                else:
+                    display_name = resource_dir.as_posix()
+
+                deploy_resources = questionary.confirm(
+                    f"Deploy resources found in {display_name!r}?", default=deploy_resources
+                ).ask()
+                if deploy_resources is None:
+                    typer.echo("No selection made for deploying resources. Exiting.")
+                    raise typer.Exit(code=1)
 
         client = EnvironmentVariables.create_from_environment().get_client()
         cmd.run(

cognite_toolkit/_cdf_tk/builders/__init__.py

@@ -3,7 +3,7 @@ from pathlib import Path
 
 from cognite_toolkit._cdf_tk.tk_warnings import ToolkitWarning
 
-from ._base import Builder, DefaultBuilder, get_loader
+from ._base import Builder, DefaultBuilder, get_resource_crud
 from ._datamodels import DataModelBuilder
 from ._file import FileBuilder
 from ._function import FunctionBuilder
@@ -36,5 +36,5 @@ __all__ = [
     "StreamlitBuilder",
     "TransformationBuilder",
     "create_builder",
-    "get_loader",
+    "get_resource_crud",
 ]

cognite_toolkit/_cdf_tk/builders/_base.py

@@ -2,14 +2,12 @@ import difflib
 from abc import ABC, abstractmethod
 from collections.abc import Callable, Iterable, Sequence
 from pathlib import Path
-from typing import Any, ClassVar, cast
+from typing import Any, ClassVar
 
 from cognite_toolkit._cdf_tk.constants import INDEX_PATTERN
 from cognite_toolkit._cdf_tk.cruds import (
-    CRUDS_BY_FOLDER_NAME,
+    RESOURCE_CRUD_BY_FOLDER_NAME,
     GroupCRUD,
-    RawDatabaseCRUD,
-    RawTableCRUD,
     ResourceCRUD,
 )
 from cognite_toolkit._cdf_tk.data_classes import (
@@ -31,7 +29,6 @@ from cognite_toolkit._cdf_tk.tk_warnings.fileread import (
 )
 from cognite_toolkit._cdf_tk.utils import (
     humanize_collection,
-    safe_read,
 )
 
 
@@ -103,34 +100,31 @@ class Builder(ABC):
         return destination_path
 
     def _get_loader(self, source_path: Path) -> tuple[None, ToolkitWarning] | tuple[type[ResourceCRUD], None]:
-        return get_loader(source_path, self.resource_folder)
+        return get_resource_crud(source_path, self.resource_folder)
 
 
-def get_loader(
-    source_path: Path,
-    resource_folder: str,
-    force_pattern: bool = False,
+def get_resource_crud(
+    source_path: Path, resource_folder: str
 ) -> tuple[None, ToolkitWarning] | tuple[type[ResourceCRUD], None]:
-    folder_loaders = CRUDS_BY_FOLDER_NAME.get(resource_folder, [])
-    if not folder_loaders:
+    """Get the appropriate CRUD class for the given source file and resource folder."""
+    folder_cruds = RESOURCE_CRUD_BY_FOLDER_NAME.get(resource_folder, [])
+    if not folder_cruds:
         return None, ToolkitNotSupportedWarning(
             f"resource of type {resource_folder!r} in {source_path.name}.",
-            details=f"Available resources are: {', '.join(CRUDS_BY_FOLDER_NAME.keys())}",
+            details=f"Available resources are: {humanize_collection(RESOURCE_CRUD_BY_FOLDER_NAME.keys())}",
         )
 
-    loaders = [
-        loader for loader in folder_loaders if loader.is_supported_file(source_path, force_pattern=force_pattern)
-    ]
-    if len(loaders) == 0:
+    crud_candidates = [crud_cls for crud_cls in folder_cruds if crud_cls.is_supported_file(source_path)]
+    if len(crud_candidates) == 0:
         suggestion: str | None = None
         if "." in source_path.stem:
             core, kind = source_path.stem.rsplit(".", 1)
-            match = difflib.get_close_matches(kind, [loader.kind for loader in folder_loaders])
+            match = difflib.get_close_matches(kind, [crud_cls.kind for crud_cls in folder_cruds])
             if match:
                 suggested_name = f"{core}.{match[0]}{source_path.suffix}"
                 suggestion = f"Did you mean to call the file {suggested_name!r}?"
         else:
-            kinds = [loader.kind for loader in folder_loaders]
+            kinds = [crud.kind for crud in folder_cruds]
             if len(kinds) == 1:
                 suggestion = f"Did you mean to call the file '{source_path.stem}.{kinds[0]}{source_path.suffix}'?"
             else:
@@ -139,30 +133,22 @@ def get_loader(
                     f"the resource type. Supported types are: {humanize_collection(kinds)}."
                 )
         return None, UnknownResourceTypeWarning(source_path, suggestion)
-    elif len(loaders) > 1 and all(loader.folder_name == "raw" for loader in loaders):
-        # Raw files can be ambiguous, so we need to check the content.
-        # If there is a tableName field, it is a table, otherwise it is a database.
-        if any(
-            line.strip().startswith("tableName:") or line.strip().startswith("- tableName:")
-            for line in safe_read(source_path).splitlines()
-        ):
-            return RawTableCRUD, None
-        else:
-            return RawDatabaseCRUD, None
-    elif len(loaders) > 1 and all(issubclass(loader, GroupCRUD) for loader in loaders):
-        # There are two group loaders, one for resource scoped and one for all scoped.
+    elif len(crud_candidates) > 1 and all(issubclass(loader, GroupCRUD) for loader in crud_candidates):
+        # There are two group cruds, one for resource scoped and one for all scoped.
         return GroupCRUD, None
-    elif len(loaders) > 1:
-        names = humanize_collection(
-            [f"'{source_path.stem}.{loader.kind}{source_path.suffix}'" for loader in loaders], bind_word="or"
-        )
-        raise AmbiguousResourceFileError(
-            f"Ambiguous resource file {source_path.name} in {resource_folder} folder. "
-            f"Unclear whether it is {humanize_collection([loader.kind for loader in loaders], bind_word='or')}."
-            f"\nPlease name the file {names}."
-        )
-
-    return cast(type[ResourceCRUD], loaders[0]), None
+    elif len(crud_candidates) == 1:
+        return crud_candidates[0], None
+
+    # This is unreachable with our current ResourceCRUD classes. We have tests that is exhaustive over
+    # all ResourceCRUDs to ensure this.
+    names = humanize_collection(
+        [f"'{source_path.stem}.{loader.kind}{source_path.suffix}'" for loader in crud_candidates], bind_word="or"
+    )
+    raise AmbiguousResourceFileError(
+        f"Ambiguous resource file {source_path.name} in {resource_folder} folder. "
+        f"Unclear whether it is {humanize_collection([crud_cls.kind for crud_cls in crud_candidates], bind_word='or')}."
+        f"\nPlease name the file {names}."
+    )
 
 
 class DefaultBuilder(Builder):

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,
@@ -176,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/_toolkit_client.py

@@ -19,23 +19,42 @@ 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 ToolAPI:
+    """This is reimplemented CogniteAPIs in Toolkit"""
+
+    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()
+        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.console)
-        self.functions: ExtendedFunctionsAPI = ExtendedFunctionsAPI(toolkit_config, self._API_VERSION, self)
+        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)
@@ -47,6 +66,7 @@ class ToolkitClient(CogniteClient):
         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/extended_functions.py

@@ -17,15 +17,16 @@ class ExtendedFunctionsAPI(FunctionsAPI):
         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)
         self._toolkit_config = config
-        self._toolkit_http_client = HTTPClient(config, max_retries=global_config.max_retries)
+        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
@@ -43,16 +44,13 @@ class ExtendedFunctionsAPI(FunctionsAPI):
                 endpoint_url=self._toolkit_config.create_api_url("/functions"),
                 method="POST",
                 body_content={"items": [function.dump(camel_case=True)]},
-            ),
-            console=console,
+            )
         )
         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]
 
-    def delete_with_429_retry(
-        self, external_id: SequenceNotStr[str], ignore_unknown_ids: bool = False, console: Console | None = None
-    ) -> None:
+    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.
 
         This method is an improvement over the standard delete method in the FunctionsAPI.
@@ -77,7 +75,6 @@ class ExtendedFunctionsAPI(FunctionsAPI):
                     endpoint_url=self._toolkit_config.create_api_url("/functions/delete"),
                     method="POST",
                     body_content=body_content,
-                ),
-                console=console,
+                )
             ).raise_for_status()
         return None

cognite_toolkit/_cdf_tk/client/api/infield.py

@@ -4,7 +4,11 @@ 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, InfieldLocationConfig
+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,
@@ -150,7 +154,95 @@ class InfieldConfigAPI:
         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)