cognite-toolkit 0.7.67__py3-none-any.whl → 0.7.68__py3-none-any.whl

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/hosted_extractors.py

@@ -4,33 +4,36 @@ from typing import Any
 
 from cognite.client.data_classes import ClientCredentials
 from cognite.client.data_classes.capabilities import Capability, HostedExtractorsAcl
-from cognite.client.data_classes.hosted_extractors import (
-    Destination,
-    DestinationList,
-    DestinationWrite,
-    EventHubSourceWrite,
-    Job,
-    JobList,
-    JobWrite,
-    KafkaSourceWrite,
-    Mapping,
-    MappingList,
-    MappingWrite,
-    Source,
-    SourceList,
-    SourceWrite,
-)
-from cognite.client.data_classes.hosted_extractors.sources import (
-    AuthenticationWrite,
-    BasicAuthenticationWrite,
-    RESTClientCredentialsAuthenticationWrite,
-    RestSourceWrite,
-    _MQTTSourceWrite,
-)
 from cognite.client.utils.useful_types import SequenceNotStr
 from rich.console import Console
 
 from cognite_toolkit._cdf_tk.client import ToolkitClient
+from cognite_toolkit._cdf_tk.client.resource_classes.hosted_extractor_destination import (
+    HostedExtractorDestinationRequest,
+    HostedExtractorDestinationResponse,
+)
+from cognite_toolkit._cdf_tk.client.resource_classes.hosted_extractor_job import (
+    HostedExtractorJobRequest,
+    HostedExtractorJobResponse,
+)
+from cognite_toolkit._cdf_tk.client.resource_classes.hosted_extractor_mapping import (
+    HostedExtractorMappingRequest,
+    HostedExtractorMappingResponse,
+)
+from cognite_toolkit._cdf_tk.client.resource_classes.hosted_extractor_source import (
+    BasicAuthenticationRequest,
+    ClientCredentialAuthenticationRequest,
+    EventHubSourceRequest,
+    HostedExtractorSourceRequest,
+    HostedExtractorSourceRequestUnion,
+    HostedExtractorSourceResponseUnion,
+    HTTPBasicAuthenticationRequest,
+    KafkaSourceRequest,
+    MQTTSourceRequest,
+    RESTSourceRequest,
+    ScramShaAuthenticationRequest,
+)
+from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import ExternalId
 from cognite_toolkit._cdf_tk.cruds._base_cruds import ResourceCRUD
 from cognite_toolkit._cdf_tk.exceptions import ToolkitNotSupported
 from cognite_toolkit._cdf_tk.resource_classes import (
@@ -44,33 +47,35 @@ from cognite_toolkit._cdf_tk.tk_warnings import HighSeverityWarning
 from .data_organization import DataSetsCRUD
 
 
-class HostedExtractorSourceCRUD(ResourceCRUD[str, SourceWrite, Source]):
+class HostedExtractorSourceCRUD(
+    ResourceCRUD[ExternalId, HostedExtractorSourceRequestUnion, HostedExtractorSourceResponseUnion]
+):
     folder_name = "hosted_extractors"
-    resource_cls = Source
-    resource_write_cls = SourceWrite
+    resource_cls = HostedExtractorSourceResponseUnion  # type: ignore[assignment]
+    resource_write_cls = HostedExtractorSourceRequestUnion  # type: ignore[assignment]
     kind = "Source"
     yaml_cls = HostedExtractorSourceYAML
     _doc_base_url = "https://api-docs.cognite.com/20230101-alpha/tag/"
     _doc_url = "Sources/operation/create_sources"
-    _SupportedSources = (_MQTTSourceWrite, KafkaSourceWrite, RestSourceWrite, EventHubSourceWrite)
+    _SupportedSources = (MQTTSourceRequest, KafkaSourceRequest, RESTSourceRequest, EventHubSourceRequest)
 
     @property
     def display_name(self) -> str:
         return "hosted extractor sources"
 
     @classmethod
-    def get_id(cls, item: SourceWrite | Source | dict) -> str:
+    def get_id(cls, item: HostedExtractorSourceRequestUnion | HostedExtractorSourceResponseUnion | dict) -> ExternalId:
         if isinstance(item, dict):
-            return item["externalId"]
-        return item.external_id
+            return ExternalId(external_id=item["externalId"])
+        return ExternalId(external_id=item.external_id)
 
     @classmethod
-    def dump_id(cls, id: str) -> dict[str, Any]:
-        return {"externalId": id}
+    def dump_id(cls, id: ExternalId) -> dict[str, Any]:
+        return id.dump()
 
     @classmethod
     def get_required_capability(
-        cls, items: Sequence[SourceWrite] | None, read_only: bool
+        cls, items: Sequence[HostedExtractorSourceRequestUnion] | None, read_only: bool
     ) -> Capability | list[Capability]:
         if not items and items is not None:
             return []
@@ -86,17 +91,19 @@ class HostedExtractorSourceCRUD(ResourceCRUD[str, SourceWrite, Source]):
             HostedExtractorsAcl.Scope.All(),
         )
 
-    def create(self, items: Sequence[SourceWrite]) -> SourceList:
-        return self.client.hosted_extractors.sources.create(items)
+    def create(self, items: Sequence[HostedExtractorSourceRequestUnion]) -> list[HostedExtractorSourceResponseUnion]:
+        return self.client.tool.hosted_extractors.sources.create(list(items))
 
-    def retrieve(self, ids: SequenceNotStr[str]) -> SourceList:
-        return self.client.hosted_extractors.sources.retrieve(external_ids=ids, ignore_unknown_ids=True)
+    def retrieve(self, ids: SequenceNotStr[ExternalId]) -> list[HostedExtractorSourceResponseUnion]:
+        return self.client.tool.hosted_extractors.sources.retrieve(list(ids), ignore_unknown_ids=True)
 
-    def update(self, items: Sequence[SourceWrite]) -> SourceList:
-        return self.client.hosted_extractors.sources.update(items, mode="replace")
+    def update(self, items: Sequence[HostedExtractorSourceRequestUnion]) -> list[HostedExtractorSourceResponseUnion]:
+        return self.client.tool.hosted_extractors.sources.update(list(items), mode="replace")
 
-    def delete(self, ids: SequenceNotStr[str]) -> int:
-        self.client.hosted_extractors.sources.delete(ids, ignore_unknown_ids=True)
+    def delete(self, ids: SequenceNotStr[ExternalId]) -> int:
+        if not ids:
+            return 0
+        self.client.tool.hosted_extractors.sources.delete(list(ids), ignore_unknown_ids=True)
         return len(ids)
 
     def _iterate(
@@ -104,50 +111,62 @@ class HostedExtractorSourceCRUD(ResourceCRUD[str, SourceWrite, Source]):
         data_set_external_id: str | None = None,
         space: str | None = None,
         parent_ids: list[Hashable] | None = None,
-    ) -> Iterable[Source]:
-        return iter(self.client.hosted_extractors.sources)
+    ) -> Iterable[HostedExtractorSourceResponseUnion]:
+        for sources in self.client.tool.hosted_extractors.sources.iterate():
+            yield from sources
 
-    def dump_resource(self, resource: Source, local: dict[str, Any] | None = None) -> dict[str, Any]:
+    def dump_resource(
+        self, resource: HostedExtractorSourceResponseUnion, local: dict[str, Any] | None = None
+    ) -> dict[str, Any]:
         HighSeverityWarning(
             "Sources will always be considered different, and thus will always be redeployed."
         ).print_warning()
-        return self.dump_id(resource.external_id)
+        return self.dump_id(self.get_id(resource))
 
-    def load_resource(self, resource: dict[str, Any], is_dry_run: bool = False) -> SourceWrite:
-        loaded = super().load_resource(resource, is_dry_run=is_dry_run)
+    def load_resource(self, resource: dict[str, Any], is_dry_run: bool = False) -> HostedExtractorSourceRequestUnion:
+        loaded = HostedExtractorSourceRequest.validate_python(resource)
         if not isinstance(loaded, self._SupportedSources):
             # We need to explicitly check for the supported types as we need to ensure that we know
             # what the sensitive strings are for each type of source.
-            # Technically, we could support any new source type added to the cognite-sdk, but
+            # Technically, we could support any new source type, but
             # we would risk printing sensitive strings in the terminal.
             raise ToolkitNotSupported(
-                f"Hosted extractor source type {type(loaded).__name__} is not supported."
+                f"Hosted extractor source type {type(loaded).__name__} is not supported. "
                 f"Please contact support to request support for this source type."
             )
         return loaded
 
-    def sensitive_strings(self, item: SourceWrite) -> Iterable[str]:
-        if isinstance(item, _MQTTSourceWrite | KafkaSourceWrite | RestSourceWrite) and item.authentication:
+    def sensitive_strings(self, item: HostedExtractorSourceRequestUnion) -> Iterable[str]:
+        if isinstance(item, MQTTSourceRequest | KafkaSourceRequest | RESTSourceRequest) and item.authentication:
             yield from self._sensitive_auth_strings(item.authentication)
         if (
-            isinstance(item, _MQTTSourceWrite | KafkaSourceWrite)
+            isinstance(item, MQTTSourceRequest | KafkaSourceRequest)
             and item.auth_certificate
             and item.auth_certificate.key_password
         ):
             yield item.auth_certificate.key_password
 
     @staticmethod
-    def _sensitive_auth_strings(auth: AuthenticationWrite) -> Iterable[str]:
-        if isinstance(auth, BasicAuthenticationWrite):
+    def _sensitive_auth_strings(
+        auth: BasicAuthenticationRequest
+        | ClientCredentialAuthenticationRequest
+        | ScramShaAuthenticationRequest
+        | HTTPBasicAuthenticationRequest,
+    ) -> Iterable[str]:
+        if isinstance(auth, BasicAuthenticationRequest | ScramShaAuthenticationRequest) and auth.password:
             yield auth.password
-        elif isinstance(auth, RESTClientCredentialsAuthenticationWrite):
+        elif isinstance(auth, ClientCredentialAuthenticationRequest):
             yield auth.client_secret
+        elif isinstance(auth, HTTPBasicAuthenticationRequest):
+            yield auth.value
 
 
-class HostedExtractorDestinationCRUD(ResourceCRUD[str, DestinationWrite, Destination]):
+class HostedExtractorDestinationCRUD(
+    ResourceCRUD[ExternalId, HostedExtractorDestinationRequest, HostedExtractorDestinationResponse]
+):
     folder_name = "hosted_extractors"
-    resource_cls = Destination
-    resource_write_cls = DestinationWrite
+    resource_cls = HostedExtractorDestinationResponse
+    resource_write_cls = HostedExtractorDestinationRequest
     dependencies = frozenset({DataSetsCRUD})
     kind = "Destination"
     _doc_base_url = "https://api-docs.cognite.com/20230101-alpha/tag/"
@@ -163,18 +182,18 @@ class HostedExtractorDestinationCRUD(ResourceCRUD[str, DestinationWrite, Destina
         return "hosted extractor destinations"
 
     @classmethod
-    def get_id(cls, item: DestinationWrite | Destination | dict) -> str:
+    def get_id(cls, item: HostedExtractorDestinationRequest | HostedExtractorDestinationResponse | dict) -> ExternalId:
         if isinstance(item, dict):
-            return item["externalId"]
-        return item.external_id
+            return ExternalId(external_id=item["externalId"])
+        return ExternalId(external_id=item.external_id)
 
     @classmethod
-    def dump_id(cls, id: str) -> dict[str, Any]:
-        return {"externalId": id}
+    def dump_id(cls, id: ExternalId) -> dict[str, Any]:
+        return id.dump()
 
     @classmethod
     def get_required_capability(
-        cls, items: Sequence[DestinationWrite] | None, read_only: bool
+        cls, items: Sequence[HostedExtractorDestinationRequest] | None, read_only: bool
     ) -> Capability | list[Capability]:
         if not items and items is not None:
             return []
@@ -190,17 +209,19 @@ class HostedExtractorDestinationCRUD(ResourceCRUD[str, DestinationWrite, Destina
             HostedExtractorsAcl.Scope.All(),
         )
 
-    def create(self, items: Sequence[DestinationWrite]) -> DestinationList:
-        return self.client.hosted_extractors.destinations.create(items)
+    def create(self, items: Sequence[HostedExtractorDestinationRequest]) -> list[HostedExtractorDestinationResponse]:
+        return self.client.tool.hosted_extractors.destinations.create(list(items))
 
-    def retrieve(self, ids: SequenceNotStr[str]) -> DestinationList:
-        return self.client.hosted_extractors.destinations.retrieve(external_ids=ids, ignore_unknown_ids=True)
+    def retrieve(self, ids: SequenceNotStr[ExternalId]) -> list[HostedExtractorDestinationResponse]:
+        return self.client.tool.hosted_extractors.destinations.retrieve(list(ids), ignore_unknown_ids=True)
 
-    def update(self, items: Sequence[DestinationWrite]) -> DestinationList:
-        return self.client.hosted_extractors.destinations.update(items, mode="replace")
+    def update(self, items: Sequence[HostedExtractorDestinationRequest]) -> list[HostedExtractorDestinationResponse]:
+        return self.client.tool.hosted_extractors.destinations.update(list(items), mode="replace")
 
-    def delete(self, ids: SequenceNotStr[str]) -> int:
-        self.client.hosted_extractors.destinations.delete(ids, ignore_unknown_ids=True)
+    def delete(self, ids: SequenceNotStr[ExternalId]) -> int:
+        if not ids:
+            return 0
+        self.client.tool.hosted_extractors.destinations.delete(list(ids), ignore_unknown_ids=True)
         return len(ids)
 
     def _iterate(
@@ -208,13 +229,14 @@ class HostedExtractorDestinationCRUD(ResourceCRUD[str, DestinationWrite, Destina
         data_set_external_id: str | None = None,
         space: str | None = None,
         parent_ids: list[Hashable] | None = None,
-    ) -> Iterable[Destination]:
-        return iter(self.client.hosted_extractors.destinations)
+    ) -> Iterable[HostedExtractorDestinationResponse]:
+        for destinations in self.client.tool.hosted_extractors.destinations.iterate():
+            yield from destinations
 
-    def load_resource(self, resource: dict[str, Any], is_dry_run: bool = False) -> DestinationWrite:
+    def load_resource(self, resource: dict[str, Any], is_dry_run: bool = False) -> HostedExtractorDestinationRequest:
         if raw_auth := resource.pop("credentials", None):
             credentials = ClientCredentials._load(raw_auth)
-            self._authentication_by_id[self.get_id(resource)] = credentials
+            self._authentication_by_id[self.get_id(resource).external_id] = credentials
             if is_dry_run:
                 resource["credentials"] = {"nonce": "dummy_nonce"}
             else:
@@ -222,30 +244,33 @@ class HostedExtractorDestinationCRUD(ResourceCRUD[str, DestinationWrite, Destina
                 resource["credentials"] = {"nonce": session.nonce}
         if ds_external_id := resource.pop("targetDataSetExternalId", None):
             resource["targetDataSetId"] = self.client.lookup.data_sets.id(ds_external_id, is_dry_run)
-        return DestinationWrite._load(resource)
+        return HostedExtractorDestinationRequest.model_validate(resource)
 
-    def dump_resource(self, resource: Destination, local: dict[str, Any] | None = None) -> dict[str, Any]:
+    def dump_resource(
+        self, resource: HostedExtractorDestinationResponse, local: dict[str, Any] | None = None
+    ) -> dict[str, Any]:
         HighSeverityWarning(
             "Destinations will always be considered different, and thus will always be redeployed."
         ).print_warning()
-        return self.dump_id(resource.external_id)
+        return self.dump_id(self.get_id(resource))
 
     @classmethod
     def get_dependent_items(cls, item: dict) -> Iterable[tuple[type[ResourceCRUD], Hashable]]:
         if "targetDataSetId" in item:
             yield DataSetsCRUD, item["targetDataSetId"]
 
-    def sensitive_strings(self, item: DestinationWrite) -> Iterable[str]:
-        yield item.credentials.nonce
+    def sensitive_strings(self, item: HostedExtractorDestinationRequest) -> Iterable[str]:
+        if item.credentials:
+            yield item.credentials.nonce
         id_ = self.get_id(item)
-        if id_ in self._authentication_by_id:
-            yield self._authentication_by_id[id_].client_secret
+        if id_.external_id in self._authentication_by_id:
+            yield self._authentication_by_id[id_.external_id].client_secret
 
 
-class HostedExtractorJobCRUD(ResourceCRUD[str, JobWrite, Job]):
+class HostedExtractorJobCRUD(ResourceCRUD[ExternalId, HostedExtractorJobRequest, HostedExtractorJobResponse]):
     folder_name = "hosted_extractors"
-    resource_cls = Job
-    resource_write_cls = JobWrite
+    resource_cls = HostedExtractorJobResponse
+    resource_write_cls = HostedExtractorJobRequest
     dependencies = frozenset({HostedExtractorSourceCRUD, HostedExtractorDestinationCRUD})
     kind = "Job"
     yaml_cls = HostedExtractorJobYAML
@@ -257,18 +282,18 @@ class HostedExtractorJobCRUD(ResourceCRUD[str, JobWrite, Job]):
         return "hosted extractor jobs"
 
     @classmethod
-    def get_id(cls, item: JobWrite | Job | dict) -> str:
+    def get_id(cls, item: HostedExtractorJobRequest | HostedExtractorJobResponse | dict) -> ExternalId:
         if isinstance(item, dict):
-            return item["externalId"]
-        return item.external_id
+            return ExternalId(external_id=item["externalId"])
+        return ExternalId(external_id=item.external_id)
 
     @classmethod
-    def dump_id(cls, id: str) -> dict[str, Any]:
-        return {"externalId": id}
+    def dump_id(cls, id: ExternalId) -> dict[str, Any]:
+        return id.dump()
 
     @classmethod
     def get_required_capability(
-        cls, items: Sequence[JobWrite] | None, read_only: bool
+        cls, items: Sequence[HostedExtractorJobRequest] | None, read_only: bool
     ) -> Capability | list[Capability]:
         if not items and items is not None:
             return []
@@ -284,24 +309,28 @@ class HostedExtractorJobCRUD(ResourceCRUD[str, JobWrite, Job]):
             HostedExtractorsAcl.Scope.All(),
         )
 
-    def dump_resource(self, resource: Job, local: dict[str, Any] | None = None) -> dict[str, Any]:
-        dumped = resource.as_write().dump()
+    def dump_resource(
+        self, resource: HostedExtractorJobResponse, local: dict[str, Any] | None = None
+    ) -> dict[str, Any]:
+        dumped = resource.as_request_resource().dump()
         local = local or {}
         if not dumped.get("config") and "config" not in local:
             dumped.pop("config", None)
         return dumped
 
-    def create(self, items: Sequence[JobWrite]) -> JobList:
-        return self.client.hosted_extractors.jobs.create(items)
+    def create(self, items: Sequence[HostedExtractorJobRequest]) -> list[HostedExtractorJobResponse]:
+        return self.client.tool.hosted_extractors.jobs.create(list(items))
 
-    def retrieve(self, ids: SequenceNotStr[str]) -> JobList:
-        return self.client.hosted_extractors.jobs.retrieve(external_ids=ids, ignore_unknown_ids=True)
+    def retrieve(self, ids: SequenceNotStr[ExternalId]) -> list[HostedExtractorJobResponse]:
+        return self.client.tool.hosted_extractors.jobs.retrieve(list(ids), ignore_unknown_ids=True)
 
-    def update(self, items: Sequence[JobWrite]) -> JobList:
-        return self.client.hosted_extractors.jobs.update(items, mode="replace")
+    def update(self, items: Sequence[HostedExtractorJobRequest]) -> list[HostedExtractorJobResponse]:
+        return self.client.tool.hosted_extractors.jobs.update(list(items), mode="replace")
 
-    def delete(self, ids: SequenceNotStr[str]) -> int:
-        self.client.hosted_extractors.jobs.delete(ids, ignore_unknown_ids=True)
+    def delete(self, ids: SequenceNotStr[ExternalId]) -> int:
+        if not ids:
+            return 0
+        self.client.tool.hosted_extractors.jobs.delete(list(ids), ignore_unknown_ids=True)
         return len(ids)
 
     def _iterate(
@@ -309,21 +338,24 @@ class HostedExtractorJobCRUD(ResourceCRUD[str, JobWrite, Job]):
         data_set_external_id: str | None = None,
         space: str | None = None,
         parent_ids: list[Hashable] | None = None,
-    ) -> Iterable[Job]:
-        return iter(self.client.hosted_extractors.jobs)
+    ) -> Iterable[HostedExtractorJobResponse]:
+        for jobs in self.client.tool.hosted_extractors.jobs.iterate():
+            yield from jobs
 
     @classmethod
     def get_dependent_items(cls, item: dict) -> Iterable[tuple[type[ResourceCRUD], Hashable]]:
         if "sourceId" in item:
-            yield HostedExtractorSourceCRUD, item["sourceId"]
+            yield HostedExtractorSourceCRUD, ExternalId(external_id=item["sourceId"])
         if "destinationId" in item:
-            yield HostedExtractorDestinationCRUD, item["destinationId"]
+            yield HostedExtractorDestinationCRUD, ExternalId(external_id=item["destinationId"])
 
 
-class HostedExtractorMappingCRUD(ResourceCRUD[str, MappingWrite, Mapping]):
+class HostedExtractorMappingCRUD(
+    ResourceCRUD[ExternalId, HostedExtractorMappingRequest, HostedExtractorMappingResponse]
+):
     folder_name = "hosted_extractors"
-    resource_cls = Mapping
-    resource_write_cls = MappingWrite
+    resource_cls = HostedExtractorMappingResponse
+    resource_write_cls = HostedExtractorMappingRequest
     # This is not an explicit dependency, however, adding it here as mapping will should be deployed after source.
     dependencies = frozenset({HostedExtractorSourceCRUD})
     kind = "Mapping"
@@ -336,18 +368,18 @@ class HostedExtractorMappingCRUD(ResourceCRUD[str, MappingWrite, Mapping]):
         return "hosted extractor mappings"
 
     @classmethod
-    def get_id(cls, item: MappingWrite | Mapping | dict) -> str:
+    def get_id(cls, item: HostedExtractorMappingRequest | HostedExtractorMappingResponse | dict) -> ExternalId:
         if isinstance(item, dict):
-            return item["externalId"]
-        return item.external_id
+            return ExternalId(external_id=item["externalId"])
+        return ExternalId(external_id=item.external_id)
 
     @classmethod
-    def dump_id(cls, id: str) -> dict[str, Any]:
-        return {"externalId": id}
+    def dump_id(cls, id: ExternalId) -> dict[str, Any]:
+        return id.dump()
 
     @classmethod
     def get_required_capability(
-        cls, items: Sequence[MappingWrite] | None, read_only: bool
+        cls, items: Sequence[HostedExtractorMappingRequest] | None, read_only: bool
     ) -> Capability | list[Capability]:
         if not items and items is not None:
             return []
@@ -363,17 +395,19 @@ class HostedExtractorMappingCRUD(ResourceCRUD[str, MappingWrite, Mapping]):
             HostedExtractorsAcl.Scope.All(),
         )
 
-    def create(self, items: Sequence[MappingWrite]) -> MappingList:
-        return self.client.hosted_extractors.mappings.create(items)
+    def create(self, items: Sequence[HostedExtractorMappingRequest]) -> list[HostedExtractorMappingResponse]:
+        return self.client.tool.hosted_extractors.mappings.create(list(items))
 
-    def retrieve(self, ids: SequenceNotStr[str]) -> MappingList:
-        return self.client.hosted_extractors.mappings.retrieve(external_ids=ids, ignore_unknown_ids=True)
+    def retrieve(self, ids: SequenceNotStr[ExternalId]) -> list[HostedExtractorMappingResponse]:
+        return self.client.tool.hosted_extractors.mappings.retrieve(list(ids), ignore_unknown_ids=True)
 
-    def update(self, items: Sequence[MappingWrite]) -> MappingList:
-        return self.client.hosted_extractors.mappings.update(items)
+    def update(self, items: Sequence[HostedExtractorMappingRequest]) -> list[HostedExtractorMappingResponse]:
+        return self.client.tool.hosted_extractors.mappings.update(list(items), mode="replace")
 
-    def delete(self, ids: SequenceNotStr[str]) -> int:
-        self.client.hosted_extractors.mappings.delete(ids, ignore_unknown_ids=True)
+    def delete(self, ids: SequenceNotStr[ExternalId]) -> int:
+        if not ids:
+            return 0
+        self.client.tool.hosted_extractors.mappings.delete(list(ids), ignore_unknown_ids=True)
         return len(ids)
 
     def _iterate(
@@ -381,5 +415,6 @@ class HostedExtractorMappingCRUD(ResourceCRUD[str, MappingWrite, Mapping]):
         data_set_external_id: str | None = None,
         space: str | None = None,
         parent_ids: list[Hashable] | None = None,
-    ) -> Iterable[Mapping]:
-        return iter(self.client.hosted_extractors.mappings)
+    ) -> Iterable[HostedExtractorMappingResponse]:
+        for mappings in self.client.tool.hosted_extractors.mappings.iterate():
+            yield from mappings

cognite_toolkit/_repo_files/GitHub/.github/workflows/deploy.yaml

@@ -12,7 +12,7 @@ jobs:
     environment: dev
     name: Deploy
     container:
-      image: cognite/toolkit:0.7.67
+      image: cognite/toolkit:0.7.68
       env:
         CDF_CLUSTER: ${{ vars.CDF_CLUSTER }}
         CDF_PROJECT: ${{ vars.CDF_PROJECT }}

cognite_toolkit/_repo_files/GitHub/.github/workflows/dry-run.yaml

@@ -10,7 +10,7 @@ jobs:
     environment: dev
     name: Deploy Dry Run
     container:
-      image: cognite/toolkit:0.7.67
+      image: cognite/toolkit:0.7.68
       env:
         CDF_CLUSTER: ${{ vars.CDF_CLUSTER }}
         CDF_PROJECT: ${{ vars.CDF_PROJECT }}

cognite_toolkit/_resources/cdf.toml

@@ -4,7 +4,7 @@ default_env = "<DEFAULT_ENV_PLACEHOLDER>"
 [modules]
 # This is the version of the modules. It should not be changed manually.
 # It will be updated by the 'cdf modules upgrade' command.
-version = "0.7.67"
+version = "0.7.68"
 
 
 [plugins]

cognite_toolkit/_version.py

@@ -1 +1 @@
-__version__ = "0.7.67"
+__version__ = "0.7.68"

{cognite_toolkit-0.7.67.dist-info → cognite_toolkit-0.7.68.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite_toolkit
-Version: 0.7.67
+Version: 0.7.68
 Summary: Official Cognite Data Fusion tool for project templates and configuration deployment
 Author: Cognite AS
 Author-email: Cognite AS <support@cognite.com>