cognite-toolkit 0.7.43__py3-none-any.whl → 0.7.44__py3-none-any.whl

cognite_toolkit/_cdf_tk/client/data_classes/hosted_extractor_source/__init__.py

@@ -0,0 +1,63 @@
+from typing import Annotated
+
+from pydantic import Field, TypeAdapter
+
+from ._auth import (
+    BasicAuthenticationRequest,
+    BasicAuthenticationResponse,
+    ClientCredentialAuthenticationRequest,
+    ClientCredentialAuthenticationResponse,
+    HTTPBasicAuthenticationRequest,
+    HTTPBasicAuthenticationResponse,
+    ScramShaAuthenticationRequest,
+    ScramShaAuthenticationResponse,
+)
+from ._certificate import AuthCertificateRequest, CACertificateRequest, CertificateResponse
+from ._eventhub import EventHubSourceRequest, EventHubSourceResponse
+from ._kafka import KafkaBroker, KafkaSourceRequest, KafkaSourceResponse
+from ._mqtt import MQTTSourceRequest, MQTTSourceResponse
+from ._rest import RESTSourceRequest, RESTSourceResponse
+
+HostedExtractorSourceRequestUnion = Annotated[
+    KafkaSourceRequest | EventHubSourceRequest | MQTTSourceRequest | RESTSourceRequest,
+    Field(discriminator="type"),
+]
+
+HostedExtractorSourceRequest: TypeAdapter[HostedExtractorSourceRequestUnion] = TypeAdapter(
+    HostedExtractorSourceRequestUnion
+)
+
+HostedExtractorSourceResponseUnion = Annotated[
+    KafkaSourceResponse | EventHubSourceResponse | MQTTSourceResponse | RESTSourceResponse,
+    Field(discriminator="type"),
+]
+
+HostedExtractorSourceResponse: TypeAdapter[HostedExtractorSourceResponseUnion] = TypeAdapter(
+    HostedExtractorSourceResponseUnion
+)
+
+
+__all__ = [
+    "AuthCertificateRequest",
+    "BasicAuthenticationRequest",
+    "BasicAuthenticationResponse",
+    "CACertificateRequest",
+    "CertificateResponse",
+    "ClientCredentialAuthenticationRequest",
+    "ClientCredentialAuthenticationResponse",
+    "EventHubSourceRequest",
+    "EventHubSourceResponse",
+    "HTTPBasicAuthenticationRequest",
+    "HTTPBasicAuthenticationResponse",
+    "HostedExtractorSourceRequest",
+    "HostedExtractorSourceResponse",
+    "KafkaBroker",
+    "KafkaSourceRequest",
+    "KafkaSourceResponse",
+    "MQTTSourceRequest",
+    "MQTTSourceResponse",
+    "RESTSourceRequest",
+    "RESTSourceResponse",
+    "ScramShaAuthenticationRequest",
+    "ScramShaAuthenticationResponse",
+]

cognite_toolkit/_cdf_tk/client/data_classes/hosted_extractor_source/_auth.py

@@ -0,0 +1,63 @@
+from typing import Literal
+
+from cognite_toolkit._cdf_tk.client.data_classes.base import (
+    BaseModelObject,
+)
+
+
+class AuthenticationRequestDefinition(BaseModelObject):
+    type: str
+
+
+class AuthenticationResponseDefinition(BaseModelObject):
+    type: str
+
+
+class BasicAuthentication(BaseModelObject):
+    type: Literal["basic"] = "basic"
+    username: str
+
+
+class BasicAuthenticationRequest(BasicAuthentication, AuthenticationRequestDefinition):
+    password: str | None = None
+
+
+class BasicAuthenticationResponse(BasicAuthentication, AuthenticationResponseDefinition): ...
+
+
+class ClientCredentialAuthentication(BaseModelObject):
+    type: Literal["clientCredential"] = "clientCredential"
+    client_id: str
+    token_url: str
+    scopes: str
+    default_expires_in: str | None = None
+
+
+class ClientCredentialAuthenticationRequest(ClientCredentialAuthentication, AuthenticationRequestDefinition):
+    client_secret: str
+
+
+class ClientCredentialAuthenticationResponse(ClientCredentialAuthentication, AuthenticationResponseDefinition): ...
+
+
+class ScramShaAuthentication(BaseModelObject):
+    type: Literal["scramSha256", "scramSha512"]
+    username: str
+
+
+class ScramShaAuthenticationRequest(ScramShaAuthentication, AuthenticationRequestDefinition):
+    password: str
+
+
+class ScramShaAuthenticationResponse(ScramShaAuthentication, AuthenticationResponseDefinition): ...
+
+
+class HTTPBasicAuthenticationRequest(AuthenticationRequestDefinition):
+    type: Literal["header", "query"]
+    key: str
+    value: str
+
+
+class HTTPBasicAuthenticationResponse(AuthenticationResponseDefinition):
+    type: Literal["header", "query"]
+    key: str

cognite_toolkit/_cdf_tk/client/data_classes/hosted_extractor_source/_base.py

@@ -0,0 +1,26 @@
+from typing import Any, Literal
+
+from cognite_toolkit._cdf_tk.client.data_classes.base import (
+    BaseModelObject,
+    RequestUpdateable,
+)
+from cognite_toolkit._cdf_tk.client.data_classes.identifiers import ExternalId
+
+
+class SourceRequestDefinition(RequestUpdateable):
+    type: str
+    external_id: str
+
+    def as_id(self) -> ExternalId:
+        return ExternalId(external_id=self.external_id)
+
+    def as_update(self, mode: Literal["patch", "replace"]) -> dict[str, Any]:
+        output = super().as_update(mode)
+        output["type"] = self.type
+        return output
+
+
+class SourceResponseDefinition(BaseModelObject):
+    external_id: str
+    created_time: int
+    last_updated_time: int

cognite_toolkit/_cdf_tk/client/data_classes/hosted_extractor_source/_certificate.py

@@ -0,0 +1,20 @@
+from cognite_toolkit._cdf_tk.client.data_classes.base import (
+    BaseModelObject,
+)
+
+
+class CACertificateRequest(BaseModelObject):
+    type: str
+    certificate: str
+
+
+class AuthCertificateRequest(BaseModelObject):
+    key: str
+    key_password: str | None = None
+    type: str
+    certificate: str
+
+
+class CertificateResponse(BaseModelObject):
+    thumbprint: str
+    expires_at: int

cognite_toolkit/_cdf_tk/client/data_classes/hosted_extractor_source/_eventhub.py

@@ -0,0 +1,31 @@
+from typing import Literal
+
+from cognite_toolkit._cdf_tk.client.data_classes.base import (
+    BaseModelObject,
+    ResponseResource,
+)
+
+from ._auth import BasicAuthenticationRequest, BasicAuthenticationResponse
+from ._base import SourceRequestDefinition, SourceResponseDefinition
+
+
+class EventHubSource(BaseModelObject):
+    type: Literal["eventHub"] = "eventHub"
+    host: str
+    event_hub_name: str
+    consumer_group: str | None = None
+
+
+class EventHubSourceRequest(EventHubSource, SourceRequestDefinition):
+    authentication: BasicAuthenticationRequest | None = None
+
+
+class EventHubSourceResponse(
+    SourceResponseDefinition,
+    EventHubSource,
+    ResponseResource[EventHubSourceRequest],
+):
+    authentication: BasicAuthenticationResponse | None = None
+
+    def as_request_resource(self) -> EventHubSourceRequest:
+        return EventHubSourceRequest.model_validate(self.dump(), extra="ignore")

cognite_toolkit/_cdf_tk/client/data_classes/hosted_extractor_source/_kafka.py

@@ -0,0 +1,53 @@
+from typing import Literal
+
+from pydantic import Field
+
+from cognite_toolkit._cdf_tk.client.data_classes.base import (
+    BaseModelObject,
+    ResponseResource,
+)
+
+from ._auth import (
+    BasicAuthenticationRequest,
+    BasicAuthenticationResponse,
+    ClientCredentialAuthenticationRequest,
+    ClientCredentialAuthenticationResponse,
+    ScramShaAuthenticationRequest,
+    ScramShaAuthenticationResponse,
+)
+from ._base import SourceRequestDefinition, SourceResponseDefinition
+from ._certificate import AuthCertificateRequest, CACertificateRequest, CertificateResponse
+
+
+class KafkaBroker(BaseModelObject):
+    host: str
+    port: int
+
+
+class KafkaSource(BaseModelObject):
+    type: Literal["kafka"] = "kafka"
+    bootstrap_brokers: list[KafkaBroker]
+    use_tls: bool | None = None
+
+
+class KafkaSourceRequest(KafkaSource, SourceRequestDefinition):
+    authentication: (
+        BasicAuthenticationRequest | ClientCredentialAuthenticationRequest | ScramShaAuthenticationRequest | None
+    ) = Field(None, discriminator="type")
+    ca_certificate: CACertificateRequest | None = None
+    auth_certificate: AuthCertificateRequest | None = None
+
+
+class KafkaSourceResponse(
+    SourceResponseDefinition,
+    KafkaSource,
+    ResponseResource[KafkaSourceRequest],
+):
+    authentication: (
+        BasicAuthenticationResponse | ClientCredentialAuthenticationResponse | ScramShaAuthenticationResponse | None
+    ) = Field(None, discriminator="type")
+    ca_certificate: CertificateResponse | None = None
+    auth_certificate: CertificateResponse | None = None
+
+    def as_request_resource(self) -> KafkaSourceRequest:
+        return KafkaSourceRequest.model_validate(self.dump(), extra="ignore")

cognite_toolkit/_cdf_tk/client/data_classes/hosted_extractor_source/_mqtt.py

@@ -0,0 +1,36 @@
+from typing import Literal
+
+from cognite_toolkit._cdf_tk.client.data_classes.base import (
+    BaseModelObject,
+    ResponseResource,
+)
+
+from ._auth import BasicAuthenticationRequest, BasicAuthenticationResponse
+from ._base import SourceRequestDefinition, SourceResponseDefinition
+from ._certificate import AuthCertificateRequest, CACertificateRequest, CertificateResponse
+
+
+class MQTTSource(BaseModelObject):
+    type: Literal["mqtt5", "mqtt3"]
+    host: str
+    port: int | None = None
+    use_tls: bool | None = None
+
+
+class MQTTSourceRequest(MQTTSource, SourceRequestDefinition):
+    authentication: BasicAuthenticationRequest | None = None
+    ca_certificate: CACertificateRequest | None = None
+    auth_certificate: AuthCertificateRequest | None = None
+
+
+class MQTTSourceResponse(
+    SourceResponseDefinition,
+    MQTTSource,
+    ResponseResource[MQTTSourceRequest],
+):
+    authentication: BasicAuthenticationResponse | None = None
+    ca_certificate: CertificateResponse | None = None
+    auth_certificate: CertificateResponse | None = None
+
+    def as_request_resource(self) -> MQTTSourceRequest:
+        return MQTTSourceRequest.model_validate(self.dump(), extra="ignore")

cognite_toolkit/_cdf_tk/client/data_classes/hosted_extractor_source/_rest.py

@@ -0,0 +1,49 @@
+from typing import Literal
+
+from pydantic import Field
+
+from cognite_toolkit._cdf_tk.client.data_classes.base import (
+    BaseModelObject,
+    ResponseResource,
+)
+
+from ._auth import (
+    BasicAuthenticationRequest,
+    BasicAuthenticationResponse,
+    ClientCredentialAuthenticationRequest,
+    ClientCredentialAuthenticationResponse,
+    HTTPBasicAuthenticationRequest,
+    HTTPBasicAuthenticationResponse,
+)
+from ._base import SourceRequestDefinition, SourceResponseDefinition
+from ._certificate import AuthCertificateRequest, CACertificateRequest, CertificateResponse
+
+
+class RESTSource(BaseModelObject):
+    type: Literal["rest"] = "rest"
+    host: str
+    port: int | None = None
+
+
+class RESTSourceRequest(RESTSource, SourceRequestDefinition):
+    scheme: Literal["https", "http"] | None = None
+    authentication: (
+        BasicAuthenticationRequest | HTTPBasicAuthenticationRequest | ClientCredentialAuthenticationRequest | None
+    ) = Field(None, discriminator="type")
+    ca_certificate: CACertificateRequest | None = None
+    auth_certificate: AuthCertificateRequest | None = None
+
+
+class RESTSourceResponse(
+    SourceResponseDefinition,
+    RESTSource,
+    ResponseResource[RESTSourceRequest],
+):
+    authentication: (
+        BasicAuthenticationResponse | HTTPBasicAuthenticationResponse | ClientCredentialAuthenticationResponse | None
+    ) = Field(None, discriminator="type")
+    ca_certificate: CertificateResponse | None = None
+    auth_certificate: CertificateResponse | None = None
+
+    def as_request_resource(self) -> RESTSourceRequest:
+        return RESTSourceRequest.model_validate(self.dump(), extra="ignore")

cognite_toolkit/_cdf_tk/client/data_classes/identifiers.py

@@ -42,3 +42,11 @@ class NameId(Identifier):
 
     def __str__(self) -> str:
         return f"name='{self.name}'"
+
+
+class WorkflowVersionId(Identifier):
+    workflow_external_id: str
+    version: str
+
+    def __str__(self) -> str:
+        return f"workflowExternalId='{self.workflow_external_id}', version='{self.version}'"

cognite_toolkit/_cdf_tk/client/data_classes/label.py

@@ -0,0 +1,27 @@
+from cognite_toolkit._cdf_tk.client.data_classes.base import (
+    BaseModelObject,
+    RequestResource,
+    ResponseResource,
+)
+
+from .identifiers import ExternalId
+
+
+class Label(BaseModelObject):
+    external_id: str
+    name: str
+    description: str | None = None
+    data_set_id: int | None = None
+
+    def as_id(self) -> ExternalId:
+        return ExternalId(external_id=self.external_id)
+
+
+class LabelRequest(Label, RequestResource): ...
+
+
+class LabelResponse(Label, ResponseResource[LabelRequest]):
+    created_time: int
+
+    def as_request_resource(self) -> LabelRequest:
+        return LabelRequest.model_validate(self.dump(), extra="ignore")

cognite_toolkit/_cdf_tk/client/data_classes/raw.py

@@ -28,8 +28,9 @@ class RAWDatabase(RequestResource, Identifier, ResponseResource["RAWDatabase"]):
 
 
 class RAWTable(RequestResource, Identifier, ResponseResource["RAWTable"]):
-    # This is a query parameter, so we exclude it from serialization
-    db_name: str = Field(exclude=True)
+    # This is a query parameter, so we exclude it from serialization.
+    # Default to empty string to allow parsing from API responses (which don't include db_name).
+    db_name: str = Field(default="", exclude=True)
     name: str
 
     def as_id(self) -> Self:

cognite_toolkit/_cdf_tk/client/data_classes/securitycategory.py

@@ -0,0 +1,24 @@
+from cognite_toolkit._cdf_tk.client.data_classes.base import (
+    BaseModelObject,
+    RequestResource,
+    ResponseResource,
+)
+
+from .identifiers import NameId
+
+
+class SecurityCategory(BaseModelObject):
+    name: str
+
+    def as_id(self) -> NameId:
+        return NameId(name=self.name)
+
+
+class SecurityCategoryRequest(SecurityCategory, RequestResource): ...
+
+
+class SecurityCategoryResponse(SecurityCategory, ResponseResource[SecurityCategoryRequest]):
+    id: int
+
+    def as_request_resource(self) -> SecurityCategoryRequest:
+        return SecurityCategoryRequest.model_validate(self.dump(), extra="ignore")

cognite_toolkit/_cdf_tk/client/data_classes/sequence.py

@@ -0,0 +1,45 @@
+from typing import ClassVar, Literal
+
+from cognite_toolkit._cdf_tk.client.data_classes.base import (
+    BaseModelObject,
+    RequestUpdateable,
+    ResponseResource,
+)
+
+from .identifiers import ExternalId
+
+
+class SequenceColumn(BaseModelObject):
+    external_id: str
+    name: str | None = None
+    description: str | None = None
+    metadata: dict[str, str] | None = None
+    value_type: Literal["STRING", "DOUBLE", "LONG"] | None = None
+
+
+class Sequence(BaseModelObject):
+    external_id: str | None = None
+    name: str | None = None
+    description: str | None = None
+    asset_id: int | None = None
+    data_set_id: int | None = None
+    metadata: dict[str, str] | None = None
+    columns: list[SequenceColumn]
+
+    def as_id(self) -> ExternalId:
+        if self.external_id is None:
+            raise ValueError("Cannot convert Sequence to ExternalId when external_id is None")
+        return ExternalId(external_id=self.external_id)
+
+
+class SequenceRequest(Sequence, RequestUpdateable):
+    container_fields: ClassVar[frozenset[str]] = frozenset({"metadata", "columns"})
+
+
+class SequenceResponse(Sequence, ResponseResource[SequenceRequest]):
+    id: int
+    created_time: int
+    last_updated_time: int
+
+    def as_request_resource(self) -> SequenceRequest:
+        return SequenceRequest.model_validate(self.dump(), extra="ignore")

cognite_toolkit/_cdf_tk/client/data_classes/transformation.py

@@ -0,0 +1,140 @@
+from typing import Annotated, ClassVar, Literal
+
+from pydantic import Field, JsonValue
+
+from cognite_toolkit._cdf_tk.client.data_classes.base import (
+    BaseModelObject,
+    RequestUpdateable,
+    ResponseResource,
+)
+
+from .identifiers import ExternalId
+
+
+class NonceCredentials(BaseModelObject):
+    nonce: str
+
+
+class DestinationDefinition(BaseModelObject):
+    type: str
+
+
+class DataModelInfo(BaseModelObject):
+    space: str
+    external_id: str
+    version: str
+    destination_type: str
+    destination_relationship_from_type: str | None = None
+
+
+class ViewInfo(BaseModelObject):
+    space: str
+    external_id: str
+    version: str
+
+
+class EdgeType(BaseModelObject):
+    space: str
+    external_id: str
+
+
+class AssetCentricDataSource(DestinationDefinition):
+    type: Literal[
+        "assets",
+        "events",
+        "asset_hierarchy",
+        "datapoints",
+        "string_datapoints",
+        "timeseries",
+        "sequences",
+        "files",
+        "labels",
+        "relationships",
+        "data_sets",
+    ]
+
+
+class DataModelSource(DestinationDefinition):
+    type: Literal["instances"] = "instances"
+    data_model: DataModelInfo
+    instance_space: str | None = None
+
+
+class ViewDataSource(DestinationDefinition):
+    type: Literal["nodes", "edges"]
+    view: ViewInfo
+    edge_type: EdgeType | None = None
+    instance_space: str | None = None
+
+
+class RawDataSource(DestinationDefinition):
+    type: Literal["raw_tables"] = "raw_tables"
+    database: str
+    table: str
+
+
+class SequenceRowDataSource(DestinationDefinition):
+    type: Literal["sequence_rows"] = "sequence_rows"
+    external_id: str
+
+
+Destination = Annotated[
+    AssetCentricDataSource | DataModelSource | ViewDataSource | RawDataSource | SequenceRowDataSource,
+    Field(discriminator="type"),
+]
+
+
+class BlockedInfo(BaseModelObject):
+    reason: str
+    created_time: int
+
+
+class SessionInfo(BaseModelObject):
+    client_id: str
+    session_id: str
+    project_name: str
+
+
+class Transformation(BaseModelObject):
+    external_id: str
+    name: str
+    ignore_null_fields: bool
+    data_set_id: int | None = None
+    tags: list[str] | None = None
+
+    def as_id(self) -> ExternalId:
+        return ExternalId(external_id=self.external_id)
+
+
+class TransformationRequest(Transformation, RequestUpdateable):
+    container_fields: ClassVar[frozenset[str]] = frozenset({"tags"})
+    non_nullable_fields: ClassVar[frozenset[str]] = frozenset({"is_public", "query", "destination"})
+    query: str | None = None
+    conflict_mode: str | None = None
+    destination: Destination | None = None
+    source_nonce: NonceCredentials | None = None
+    destination_nonce: NonceCredentials | None = None
+    is_public: bool | None = None
+
+
+class TransformationResponse(Transformation, ResponseResource[TransformationRequest]):
+    id: int
+    created_time: int
+    last_updated_time: int
+    query: str
+    is_public: bool
+    conflict_mode: str
+    destination: Destination
+    blocked: BlockedInfo | None = None
+    owner: str
+    owner_is_current_user: bool
+    has_source_oidc_credentials: bool
+    has_destination_oidc_credentials: bool
+    source_session: SessionInfo | None = None
+    destination_session: SessionInfo | None = None
+    last_finished_job: dict[str, JsonValue] | None = None
+    running_job: dict[str, JsonValue] | None = None
+    schedule: dict[str, JsonValue] | None = None
+
+    def as_request_resource(self) -> TransformationRequest:
+        return TransformationRequest.model_validate(self.dump(), extra="ignore")

cognite_toolkit/_cdf_tk/client/data_classes/workflow.py

@@ -0,0 +1,27 @@
+from cognite_toolkit._cdf_tk.client.data_classes.base import (
+    BaseModelObject,
+    RequestResource,
+    ResponseResource,
+)
+
+from .identifiers import ExternalId
+
+
+class Workflow(BaseModelObject):
+    external_id: str
+    description: str | None = None
+    data_set_id: int | None = None
+
+    def as_id(self) -> ExternalId:
+        return ExternalId(external_id=self.external_id)
+
+
+class WorkflowRequest(Workflow, RequestResource): ...
+
+
+class WorkflowResponse(Workflow, ResponseResource[WorkflowRequest]):
+    created_time: int
+    last_updated_time: int
+
+    def as_request_resource(self) -> WorkflowRequest:
+        return WorkflowRequest.model_validate(self.dump(), extra="ignore")