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

cognite_toolkit/_cdf_tk/builders/_raw.py

@@ -4,6 +4,7 @@ from typing import Any
 
 from cognite_toolkit._cdf_tk.builders import Builder
 from cognite_toolkit._cdf_tk.client.data_classes.raw import RawDatabase
+from cognite_toolkit._cdf_tk.cruds import RawDatabaseCRUD, RawTableCRUD, ResourceCRUD
 from cognite_toolkit._cdf_tk.data_classes import (
     BuildDestinationFile,
     BuildSourceFile,
@@ -11,14 +12,13 @@ from cognite_toolkit._cdf_tk.data_classes import (
     SourceLocation,
     SourceLocationEager,
 )
-from cognite_toolkit._cdf_tk.loaders import RawDatabaseLoader, RawTableLoader, ResourceLoader
 from cognite_toolkit._cdf_tk.tk_warnings import ToolkitWarning
-from cognite_toolkit._cdf_tk.utils import calculate_str_or_file_hash
+from cognite_toolkit._cdf_tk.utils import calculate_hash
 from cognite_toolkit._cdf_tk.utils.file import yaml_safe_dump
 
 
 class RawBuilder(Builder):
-    _resource_folder = RawDatabaseLoader.folder_name
+    _resource_folder = RawDatabaseCRUD.folder_name
 
     def build(
         self, source_files: list[BuildSourceFile], module: ModuleLocation, console: Callable[[str], None] | None = None
@@ -29,22 +29,22 @@ class RawBuilder(Builder):
                 continue
             loaded_list = loaded if isinstance(loaded, list) else [loaded]
             seen_databases: set[tuple] = set()
-            entry_by_loader: dict[type[ResourceLoader], list[dict[str, Any]]] = defaultdict(list)
+            entry_by_loader: dict[type[ResourceCRUD], list[dict[str, Any]]] = defaultdict(list)
             has_split_table_and_database = False
 
             for item in loaded_list:
                 try:
-                    table_id = RawTableLoader.get_id(item)
+                    table_id = RawTableCRUD.get_id(item)
                 except KeyError:
                     seen_databases.add(tuple(item.items()))
-                    entry_by_loader[RawDatabaseLoader].append(item)
+                    entry_by_loader[RawDatabaseCRUD].append(item)
                 else:
-                    entry_by_loader[RawTableLoader].append(item)
-                    db_item = RawDatabaseLoader.dump_id(RawDatabase(table_id.db_name))
+                    entry_by_loader[RawTableCRUD].append(item)
+                    db_item = RawDatabaseCRUD.dump_id(RawDatabase(table_id.db_name))
                     hashable_db_item = tuple(db_item.items())
                     if hashable_db_item not in seen_databases:
                         seen_databases.add(hashable_db_item)
-                        entry_by_loader[RawDatabaseLoader].append(db_item)
+                        entry_by_loader[RawDatabaseCRUD].append(db_item)
                         has_split_table_and_database = True
 
             for loader, entries in entry_by_loader.items():
@@ -52,10 +52,10 @@ class RawBuilder(Builder):
                     continue
                 destination_path = self._create_destination_path(source_file.source.path, loader.kind)
 
-                if loader is RawDatabaseLoader and has_split_table_and_database:
+                if loader is RawDatabaseCRUD and has_split_table_and_database:
                     # We have inferred the database from a Table file, so we need to recalculate the hash
                     # in case we also inferred the database from another Table file
-                    new_hash = calculate_str_or_file_hash(
+                    new_hash = calculate_hash(
                         yaml_safe_dump(sorted(entries, key=lambda entry: entry["dbName"])),
                         shorten=True,
                     )

cognite_toolkit/_cdf_tk/builders/_streamlit.py

@@ -2,13 +2,13 @@ import shutil
 from collections.abc import Callable, Iterable, Sequence
 
 from cognite_toolkit._cdf_tk.builders import Builder
+from cognite_toolkit._cdf_tk.cruds import StreamlitCRUD
 from cognite_toolkit._cdf_tk.data_classes import (
     BuildDestinationFile,
     BuildSourceFile,
     ModuleLocation,
 )
 from cognite_toolkit._cdf_tk.exceptions import ToolkitFileExistsError, ToolkitNotADirectoryError, ToolkitValueError
-from cognite_toolkit._cdf_tk.loaders import StreamlitLoader
 from cognite_toolkit._cdf_tk.tk_warnings import (
     FileReadWarning,
     HighSeverityWarning,
@@ -20,7 +20,7 @@ from cognite_toolkit._cdf_tk.utils.file import safe_read
 
 
 class StreamlitBuilder(Builder):
-    _resource_folder = StreamlitLoader.folder_name
+    _resource_folder = StreamlitCRUD.folder_name
 
     def build(
         self, source_files: list[BuildSourceFile], module: ModuleLocation, console: Callable[[str], None] | None = None
@@ -39,7 +39,7 @@ class StreamlitBuilder(Builder):
                 continue
 
             warnings = WarningList[FileReadWarning]()
-            if loader is StreamlitLoader:
+            if loader is StreamlitCRUD:
                 warnings = self.copy_app_directory_to_build(source_file)
 
             destination_path = self._create_destination_path(source_file.source.path, loader.kind)
@@ -78,7 +78,7 @@ class StreamlitBuilder(Builder):
                 )
 
             requirements_file_content = safe_read(app_directory / "requirements.txt").splitlines()
-            missing_packages = StreamlitLoader._missing_recommended_requirements(requirements_file_content)
+            missing_packages = StreamlitCRUD._missing_recommended_requirements(requirements_file_content)
             if len(missing_packages) > 0:
                 warnings.append(StreamlitRequirementsWarning(app_directory / "requirements.txt", missing_packages))
 

cognite_toolkit/_cdf_tk/builders/_transformation.py

@@ -4,6 +4,7 @@ from typing import Any
 
 from cognite_toolkit._cdf_tk.builders import Builder
 from cognite_toolkit._cdf_tk.constants import BUILD_FOLDER_ENCODING
+from cognite_toolkit._cdf_tk.cruds import TransformationCRUD
 from cognite_toolkit._cdf_tk.data_classes import (
     BuildDestinationFile,
     BuildSourceFile,
@@ -11,13 +12,12 @@ from cognite_toolkit._cdf_tk.data_classes import (
     SourceLocation,
 )
 from cognite_toolkit._cdf_tk.exceptions import ToolkitYAMLFormatError
-from cognite_toolkit._cdf_tk.loaders import TransformationLoader
-from cognite_toolkit._cdf_tk.tk_warnings import ToolkitWarning
+from cognite_toolkit._cdf_tk.tk_warnings import HighSeverityWarning, ToolkitWarning
 from cognite_toolkit._cdf_tk.utils import safe_write
 
 
 class TransformationBuilder(Builder):
-    _resource_folder = TransformationLoader.folder_name
+    _resource_folder = TransformationCRUD.folder_name
 
     def build(
         self, source_files: list[BuildSourceFile], module: ModuleLocation, console: Callable[[str], None] | None = None
@@ -42,7 +42,7 @@ class TransformationBuilder(Builder):
             destination_path = self._create_destination_path(source_file.source.path, loader.kind)
 
             extra_sources: list[SourceLocation] | None = None
-            if loader is TransformationLoader:
+            if loader is TransformationCRUD:
                 extra_sources = self._add_query(loaded, source_file, query_files, destination_path)
 
             destination = BuildDestinationFile(
@@ -68,7 +68,7 @@ class TransformationBuilder(Builder):
         extra_sources: list[SourceLocation] = []
         for entry in loaded_list:
             try:
-                external_id = TransformationLoader.get_id(entry)
+                external_id = TransformationCRUD.get_id(entry)
             except KeyError:
                 # This will be validated later
                 continue
@@ -81,10 +81,13 @@ class TransformationBuilder(Builder):
                     f"Please remove one of the definitions, either the query property in {filepath} or the file {query_file}",
                 )
             elif "query" not in entry and query_file is None:
-                raise ToolkitYAMLFormatError(
-                    f"query property or is missing. It can be inline or a separate file named {filepath.stem}.sql or {external_id}.sql",
-                    filepath,
+                warning = HighSeverityWarning(
+                    f"query property or is missing in {filepath.as_posix()!r}. It can be inline or a separate file named {filepath.stem}.sql or {external_id}.sql",
                 )
+                if self.warn:
+                    self.warn(warning)
+                else:
+                    warning.print_warning()
             elif query_file is not None:
                 destination_path = self._create_destination_path(query_file.source.path, "Query")
                 safe_write(destination_path, query_file.content, encoding=BUILD_FOLDER_ENCODING)

cognite_toolkit/_cdf_tk/cdf_toml.py

@@ -1,7 +1,6 @@
-from __future__ import annotations
-
 import re
 import sys
+import urllib
 from contextlib import suppress
 from dataclasses import dataclass, field
 from pathlib import Path
@@ -10,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,
@@ -19,11 +18,14 @@ from cognite_toolkit._cdf_tk.exceptions import (
 from cognite_toolkit._cdf_tk.tk_warnings import MediumSeverityWarning
 
 if sys.version_info >= (3, 11):
+    from typing import Self
+
     import tomllib
     from tomllib import TOMLDecodeError
 else:
     import tomli as tomllib
     from tomli import TOMLDecodeError
+    from typing_extensions import Self
 
 
 @dataclass
@@ -35,7 +37,7 @@ class CLIConfig:
     has_user_set_default_env: bool = False
 
     @classmethod
-    def load(cls, raw: dict[str, Any], cwd: Path) -> CLIConfig:
+    def load(cls, raw: dict[str, Any], cwd: Path) -> Self:
         has_user_set_default_org = "default_organization_dir" in raw
         has_user_set_default_env = "default_env" in raw
         default_organization_dir = cwd / raw["default_organization_dir"] if has_user_set_default_org else Path.cwd()
@@ -54,22 +56,54 @@ class ModulesConfig:
     packages: dict[str, list[str]] = field(default_factory=dict)
 
     @classmethod
-    def load(cls, raw: dict[str, Any]) -> ModulesConfig:
+    def load(cls, raw: dict[str, Any]) -> Self:
         version = raw["version"]
         packages = raw.get("packages", {})
         if (
             version != _version.__version__
             and (len(sys.argv) > 2 and sys.argv[1:3] != ["modules", "upgrade"])
             and "--help" not in sys.argv
+            and version != "0.0.0"  # debugging mode
         ):
             raise ToolkitVersionError(
                 f"The version of the modules ({version}) does not match the version of the installed CLI "
-                f"({_version.__version__}). Please either run `cdf-tk modules upgrade` to upgrade the modules OR "
-                f"run `pip install cognite-toolkit=={version}` to downgrade cdf-tk CLI."
+                f"({_version.__version__}). Please run `cdf modules upgrade` to upgrade the modules OR "
+                f"run `pip install cognite-toolkit=={version}` to downgrade cdf CLI."
             )
         return cls(version=version, packages=packages)
 
 
+@dataclass
+class Library:
+    url: str
+    checksum: str
+
+    def __post_init__(self) -> None:
+        self._validate()
+
+    def _validate(self) -> None:
+        parsed_url = urllib.parse.urlparse(self.url)
+
+        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":
+            raise ValueError("URL must start with 'https'")
+
+        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)
+
+
 @dataclass
 class CDFToml:
     """This is the configuration for the CLI and Modules"""
@@ -80,11 +114,12 @@ class CDFToml:
     modules: ModulesConfig
     alpha_flags: dict[str, bool] = field(default_factory=dict)
     plugins: dict[str, bool] = field(default_factory=dict)
+    libraries: dict[str, Library] = field(default_factory=dict)
 
     is_loaded_from_file: bool = False
 
     @classmethod
-    def load(cls, cwd: Path | None = None, use_singleton: bool = True) -> CDFToml:
+    def load(cls, cwd: Path | None = None, use_singleton: bool = True) -> "CDFToml":
         """Loads the cdf.toml file from the given path. If use_singleton is True, the instance will be stored as a
         singleton and returned on subsequent calls."""
         global _CDF_TOML
@@ -114,7 +149,21 @@ class CDFToml:
             if "plugins" in raw:
                 plugins = {clean_name(k): v for k, v in raw["plugins"].items()}
 
-            instance = cls(cdf=cdf, modules=modules, alpha_flags=alpha_flags, plugins=plugins, is_loaded_from_file=True)
+            libraries = {}
+            for k, v in raw.get("library", {}).items():
+                try:
+                    libraries[k] = Library.load(v)
+                except Exception as e:
+                    raise ToolkitTOMLFormatError(f"Invalid library configuration for '{k}': {e.args[0]}") from e
+
+            instance = cls(
+                cdf=cdf,
+                modules=modules,
+                alpha_flags=alpha_flags,
+                plugins=plugins,
+                libraries=libraries,
+                is_loaded_from_file=True,
+            )
             if use_singleton:
                 _CDF_TOML = instance
             return instance
@@ -127,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/_constants.py

@@ -1 +1,2 @@
 DATA_MODELING_MAX_WRITE_WORKERS = 4
+DATA_MODELING_MAX_DELETE_WORKERS = 2

cognite_toolkit/_cdf_tk/client/_toolkit_client.py

@@ -1,88 +1,72 @@
-from __future__ import annotations
+from typing import cast
 
-from typing import Literal, cast
+from cognite.client import CogniteClient
+from rich.console import Console
 
-from cognite.client import ClientConfig, CogniteClient
-from cognite.client.credentials import CredentialProvider
+from cognite_toolkit._cdf_tk.utils.http_client import HTTPClient
 
-from .api.agents.agents import AgentsAPI
+from .api.canvas import CanvasAPI
+from .api.charts import ChartsAPI
 from .api.dml import DMLAPI
 from .api.extended_data_modeling import ExtendedDataModelingAPI
+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.location_filters import LocationFiltersAPI
+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
+class ToolAPI:
+    """This is reimplemented CogniteAPIs in Toolkit"""
 
-    @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 __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)
-        self.location_filters = LocationFiltersAPI(self._config, self._API_VERSION, self)
+        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.agents = AgentsAPI(self._config, self._API_VERSION, self)
-        self.data_modeling = ExtendedDataModelingAPI(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(self._config, self._API_VERSION, self)
+            self.time_series: ExtendedTimeSeriesAPI = ExtendedTimeSeriesAPI(self._config, self._API_VERSION, self)
+            self.files: ExtendedFileMetadataAPI = ExtendedFileMetadataAPI(self._config, self._API_VERSION, self)
+        self.raw: ExtendedRawAPI = ExtendedRawAPI(self._config, self._API_VERSION, self)
+        self.canvas = CanvasAPI(self.data_modeling.instances)
+        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

@@ -0,0 +1,185 @@
+from collections.abc import Iterable, Sequence
+from typing import Any, overload
+
+from cognite.client._constants import DEFAULT_LIMIT_READ
+from cognite.client.data_classes.data_modeling import (
+    EdgeId,
+    InstanceSort,
+    NodeApplyResultList,
+    NodeId,
+    NodeList,
+    filters,
+    query,
+)
+from cognite.client.data_classes.filters import Filter
+from cognite.client.exceptions import CogniteDuplicatedError
+from cognite.client.utils.useful_types import SequenceNotStr
+
+from cognite_toolkit._cdf_tk.client.data_classes.canvas import (
+    ANNOTATION_EDGE_TYPE,
+    CANVAS_INSTANCE_SPACE,
+    CONTAINER_REFERENCE_EDGE_TYPE,
+    FDM_CONTAINER_REFERENCE_EDGE_TYPE,
+    Canvas,
+    CanvasAnnotation,
+    CanvasApply,
+    CogniteSolutionTag,
+    ContainerReference,
+    FdmInstanceContainerReference,
+    IndustrialCanvas,
+    IndustrialCanvasApply,
+)
+from cognite_toolkit._cdf_tk.client.data_classes.instances import InstancesApplyResultList
+from cognite_toolkit._cdf_tk.exceptions import ToolkitValueError
+
+from .extended_data_modeling import ExtendedInstancesAPI
+
+
+class CanvasAPI:
+    def __init__(self, instance_api: ExtendedInstancesAPI) -> None:
+        self._instance_api = instance_api
+        self.instance_space = CANVAS_INSTANCE_SPACE
+        self.industrial = IndustrialCanvasAPI(instance_api)
+
+    def upsert(self, canvas: CanvasApply | Sequence[CanvasApply]) -> NodeApplyResultList:
+        return self._instance_api.apply(canvas).nodes
+
+    def delete(self, external_id: str | SequenceNotStr[str]) -> list[str]:
+        external_ids = [external_id] if isinstance(external_id, str) else external_id
+        result = self._instance_api.delete([NodeId(self.instance_space, item) for item in external_ids])
+        return [item.external_id for item in result.nodes]
+
+    @overload
+    def retrieve(self, external_id: str | None = None) -> Canvas | None: ...
+
+    @overload
+    def retrieve(self, external_id: SequenceNotStr[str]) -> NodeList[Canvas]: ...
+
+    def retrieve(self, external_id: str | SequenceNotStr[str] | None = None) -> Canvas | NodeList[Canvas] | None:
+        if isinstance(external_id, str):
+            return self._instance_api.retrieve_nodes(NodeId(self.instance_space, external_id), node_cls=Canvas)
+        elif isinstance(external_id, Iterable):
+            return self._instance_api.retrieve_nodes(
+                [NodeId(self.instance_space, item) for item in external_id], node_cls=Canvas
+            )
+        else:
+            raise TypeError(f"Expected str or SequenceNotStr[str], got {type(external_id)}")
+
+    def list(
+        self,
+        limit: int | None = DEFAULT_LIMIT_READ,
+        sort: Sequence[InstanceSort] | InstanceSort | None = None,
+        filter: Filter | dict[str, Any] | None = None,
+    ) -> NodeList[Canvas]:
+        return self._instance_api.list(
+            instance_type=Canvas, space=self.instance_space, limit=limit, sort=sort, filter=filter
+        )
+
+
+class IndustrialCanvasAPI:
+    def __init__(self, instance_api: ExtendedInstancesAPI) -> None:
+        self._instance_api = instance_api
+        self._APPLY_LIMIT = 1000  # Limit for applying instances in a single request
+
+    def create(self, canvas: IndustrialCanvasApply) -> InstancesApplyResultList:
+        instance_ids = canvas.as_instance_ids()
+        existing = self._instance_api.retrieve(
+            [node for node in instance_ids if isinstance(node, NodeId)],
+            edges=[edge for edge in instance_ids if isinstance(edge, EdgeId)],
+        )
+        if existing.nodes or existing.edges:
+            raise CogniteDuplicatedError(duplicated=existing.nodes.as_ids() + existing.edges.as_ids())
+        instances = canvas.as_instances()
+        self._validate_instance_count(len(instances))
+        return self._instance_api.apply_fast(instances)
+
+    def retrieve(self, external_id: str) -> IndustrialCanvas | None:
+        retrieve_query = self._retrieve_query(external_id)
+        result = self._instance_api.query(retrieve_query)
+        if len(result["canvas"]) == 0:
+            return None
+        # 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)
+        self._validate_instance_count(len(new_instance_ids))
+
+        existing = self.retrieve(external_id=canvas.as_id())
+        if existing is None:
+            raise ToolkitValueError(
+                f"Cannot update canvas. Industrial canvas with external ID '{canvas.as_id()}' does not exist."
+            )
+        existing_instance_ids = existing.as_write().as_instance_ids(include_solution_tags=False)
+        to_delete = set(existing_instance_ids) - set(new_instance_ids)
+        result = self._instance_api.apply_fast(canvas.as_instances())
+        if to_delete:
+            # Delete components that are not in the new canvas
+            self._instance_api.delete_fast(list(to_delete))
+        return result
+
+    def delete(self, canvas: IndustrialCanvasApply) -> list[NodeId | EdgeId]:
+        # Solution tags are used by multiple canvases, so we do not include them in the deletion.
+        return self._instance_api.delete_fast(canvas.as_instance_ids(include_solution_tags=False))
+
+    def _validate_instance_count(self, instance_count: int) -> None:
+        if instance_count > self._APPLY_LIMIT:
+            # Looking at the largest Canvas users I have not seen any larger than 500 components (node + edge)
+            # Creating a canvas with more than 1000 instances is more complex as it is not an atomic operation
+            # thus postponing that implementation for now.
+            raise ToolkitValueError(
+                f"Creating/Updating an industrial canvas with more than {self._APPLY_LIMIT // 2} components is not supported. "
+                "Please contact support if you need to create a larger canvas."
+            )
+
+    @classmethod
+    def _retrieve_query(cls, external_id: str) -> query.Query:
+        return query.Query(
+            with_={
+                "canvas": query.NodeResultSetExpression(
+                    filter=filters.InstanceReferences([(CANVAS_INSTANCE_SPACE, external_id)]),
+                    limit=1,
+                ),
+                "solutionTags": query.NodeResultSetExpression(
+                    from_="canvas",
+                    through=Canvas.get_source().as_property_ref("solutionTags"),
+                ),
+                "annotationEdges": query.EdgeResultSetExpression(
+                    from_="canvas",
+                    filter=filters.Equals(["edge", "type"], ANNOTATION_EDGE_TYPE.dump()),
+                    node_filter=filters.HasData(views=[CanvasAnnotation.get_source()]),
+                    direction="outwards",
+                ),
+                "containerReferenceEdges": query.EdgeResultSetExpression(
+                    from_="canvas",
+                    filter=filters.Equals(["edge", "type"], CONTAINER_REFERENCE_EDGE_TYPE.dump()),
+                    node_filter=filters.HasData(views=[ContainerReference.get_source()]),
+                    direction="outwards",
+                ),
+                "fdmInstanceContainerReferenceEdges": query.EdgeResultSetExpression(
+                    from_="canvas",
+                    filter=filters.Equals(
+                        ["edge", "type"],
+                        FDM_CONTAINER_REFERENCE_EDGE_TYPE.dump(),
+                    ),
+                    node_filter=filters.HasData(views=[FdmInstanceContainerReference.get_source()]),
+                    direction="outwards",
+                ),
+                "annotations": query.NodeResultSetExpression(from_="annotationEdges"),
+                "containerReferences": query.NodeResultSetExpression(from_="containerReferenceEdges"),
+                "fdmInstanceContainerReferences": query.NodeResultSetExpression(
+                    from_="fdmInstanceContainerReferenceEdges"
+                ),
+            },
+            select={
+                "canvas": query.Select([query.SourceSelector(Canvas.get_source(), properties=["*"])]),
+                "solutionTags": query.Select([query.SourceSelector(CogniteSolutionTag.get_source(), properties=["*"])]),
+                "annotations": query.Select([query.SourceSelector(CanvasAnnotation.get_source(), properties=["*"])]),
+                "containerReferences": query.Select(
+                    [query.SourceSelector(ContainerReference.get_source(), properties=["*"])]
+                ),
+                "fdmInstanceContainerReferences": query.Select(
+                    [query.SourceSelector(FdmInstanceContainerReference.get_source(), properties=["*"])]
+                ),
+            },
+        )