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

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/simulator_model.py

@@ -0,0 +1,50 @@
+from typing import Any, Literal
+
+from pydantic import Field
+
+from cognite_toolkit._cdf_tk.client.data_classes.base import RequestUpdateable, ResponseResource
+
+from .identifiers import ExternalId
+
+
+class SimulatorModelRequest(RequestUpdateable):
+    # The 'id' field is not part of the request when creating a new resource,
+    # but is needed when updating an existing resource.
+    id: int | None = Field(default=None, exclude=True)
+    external_id: str
+    simulator_external_id: str
+    name: str
+    description: str | None = None
+    data_set_id: int
+    type: str
+
+    def as_id(self) -> ExternalId:
+        return ExternalId(external_id=self.external_id)
+
+    def as_update(self, mode: Literal["patch", "replace"]) -> dict[str, Any]:
+        if self.id is None:
+            raise ValueError("id must be provided to create an update dictionary")
+        return {
+            "id": self.id,
+            "update": {
+                "name": {"set": self.name},
+                **{"description": {"set": self.description} if self.description is not None else {}},
+            },
+        }
+
+
+class SimulatorModelResponse(ResponseResource[SimulatorModelRequest]):
+    id: int
+    external_id: str
+    simulator_external_id: str
+    name: str
+    description: str | None = None
+    data_set_id: int
+    type: str | None = None
+    created_time: int
+    last_updated_time: int
+
+    def as_request_resource(self) -> SimulatorModelRequest:
+        if self.type is None:
+            raise ValueError("Cannot convert SimulatorModelResponse to SimulatorModelRequest when type is None")
+        return SimulatorModelRequest.model_validate(self.dump(), extra="ignore")

cognite_toolkit/_cdf_tk/client/data_classes/timeseries.py

@@ -1,14 +1,16 @@
 from typing import Any, ClassVar, Literal
 
-from cognite_toolkit._cdf_tk.client.data_classes.base import RequestUpdateable, ResponseResource
+from cognite_toolkit._cdf_tk.client.data_classes.base import (
+    BaseModelObject,
+    RequestUpdateable,
+    ResponseResource,
+)
 
 from .identifiers import ExternalId, InternalOrExternalId
 from .instance_api import NodeReference
 
 
-class TimeSeriesRequest(RequestUpdateable):
-    container_fields: ClassVar[frozenset[str]] = frozenset({"metadata", "security_categories"})
-    non_nullable_fields: ClassVar[frozenset[str]] = frozenset({"is_step"})
+class TimeSeries(BaseModelObject):
     external_id: str | None = None
     name: str | None = None
     is_string: bool = False
@@ -26,30 +28,25 @@ class TimeSeriesRequest(RequestUpdateable):
             raise ValueError("Cannot convert TimeSeriesRequest to ExternalId when external_id is None")
         return ExternalId(external_id=self.external_id)
 
+
+class TimeSeriesRequest(TimeSeries, RequestUpdateable):
+    container_fields: ClassVar[frozenset[str]] = frozenset({"metadata", "security_categories"})
+    non_nullable_fields: ClassVar[frozenset[str]] = frozenset({"is_step"})
+
     def as_update(self, mode: Literal["patch", "replace"]) -> dict[str, Any]:
         dumped = super().as_update(mode)
+        update = dumped["update"] if "update" in dumped else dumped
         # isString is immutable in CDF, so we remove it from update payloads
-        dumped.pop("isString", None)
+        update.pop("isString", None)
         return dumped
 
 
-class TimeSeriesResponse(ResponseResource[TimeSeriesRequest]):
+class TimeSeriesResponse(TimeSeries, ResponseResource[TimeSeriesRequest]):
     id: int
     instance_id: NodeReference | None = None
-    external_id: str | None = None
-    name: str | None = None
-    is_string: bool
-    metadata: dict[str, str] | None = None
-    unit: str | None = None
     type: str
-    unit_external_id: str | None = None
-    asset_id: int | None = None
-    is_step: bool
-    description: str | None = None
-    security_categories: list[int] | None = None
-    data_set_id: int | None = None
     created_time: int
     last_updated_time: int
 
     def as_request_resource(self) -> TimeSeriesRequest:
-        return TimeSeriesRequest.model_validate(self.dump())
+        return TimeSeriesRequest.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")

cognite_toolkit/_cdf_tk/client/data_classes/workflow_trigger.py

@@ -0,0 +1,63 @@
+from typing import Annotated, Literal
+
+from pydantic import Field, JsonValue
+
+from cognite_toolkit._cdf_tk.client.data_classes.base import (
+    BaseModelObject,
+    RequestResource,
+    ResponseResource,
+)
+
+from .identifiers import ExternalId
+
+
+class TriggerRuleDefinition(BaseModelObject):
+    trigger_type: str
+
+
+class ScheduleTriggerRule(BaseModelObject):
+    trigger_type: Literal["schedule"] = "schedule"
+    cron_expression: str
+    timezone: str | None = None
+
+
+class DataModelingTriggerRule(BaseModelObject):
+    trigger_type: Literal["dataModeling"] = "dataModeling"
+    data_modeling_query: JsonValue
+    batch_size: int
+    batch_timeout: int
+
+
+TriggerRule = Annotated[
+    ScheduleTriggerRule | DataModelingTriggerRule,
+    Field(discriminator="trigger_type"),
+]
+
+
+class NonceCredentials(BaseModelObject):
+    nonce: str
+
+
+class WorkflowTrigger(BaseModelObject):
+    external_id: str
+    trigger_rule: TriggerRule
+    workflow_external_id: str
+    workflow_version: str
+    input: JsonValue | None = None
+    metadata: dict[str, str] | None = None
+
+    def as_id(self) -> ExternalId:
+        return ExternalId(external_id=self.external_id)
+
+
+class WorkflowTriggerRequest(WorkflowTrigger, RequestResource):
+    authentication: NonceCredentials
+
+
+class WorkflowTriggerResponse(WorkflowTrigger, ResponseResource[WorkflowTriggerRequest]):
+    created_time: int
+    last_updated_time: int
+    is_paused: bool
+
+    def as_request_resource(self) -> WorkflowTriggerRequest:
+        return WorkflowTriggerRequest.model_validate(self.dump(), extra="ignore")