cognite-toolkit 0.7.39__py3-none-any.whl → 0.7.51__py3-none-any.whl

cognite_toolkit/_cdf_tk/client/resource_classes/group/group.py

@@ -0,0 +1,63 @@
+"""Group request and response classes.
+
+Based on the API specification at:
+https://api-docs.cognite.com/20230101/tag/Groups/operation/createGroups
+"""
+
+from typing import Literal
+
+from pydantic import Field
+
+from cognite_toolkit._cdf_tk.client._resource_base import (
+    BaseModelObject,
+    RequestResource,
+    ResponseResource,
+)
+from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import InternalId
+
+from .capability import GroupCapability
+
+
+class TokenAttributes(BaseModelObject):
+    """Token attributes for group."""
+
+    app_ids: list[str] | None = None
+
+
+class GroupAttributes(BaseModelObject):
+    """Attributes for a group."""
+
+    token: TokenAttributes | None = None
+
+
+class Group(BaseModelObject):
+    """Base class for Group resources."""
+
+    name: str
+    capabilities: list[GroupCapability] | None = None
+    metadata: dict[str, str] | None = None
+    attributes: GroupAttributes | None = None
+    source_id: str | None = None
+    members: list[str] | Literal["allUserAccounts"] | None = None
+
+
+class GroupRequest(Group, RequestResource):
+    """Group request resource for creating/updating groups."""
+
+    id: int | None = Field(default=None, exclude=True)
+
+    def as_id(self) -> InternalId:
+        if self.id is None:
+            raise ValueError("Cannot convert GroupRequest to InternalId when id is None")
+        return InternalId(id=self.id)
+
+
+class GroupResponse(Group, ResponseResource[GroupRequest]):
+    """Group response resource returned from API."""
+
+    id: int
+    is_deleted: bool = False
+    deleted_time: int | None = None
+
+    def as_request_resource(self) -> GroupRequest:
+        return GroupRequest.model_validate(self.dump(), extra="ignore")

cognite_toolkit/_cdf_tk/client/resource_classes/group/scopes.py

@@ -0,0 +1,166 @@
+"""Scope definitions for Group capabilities.
+
+Based on the API specification at:
+https://api-docs.cognite.com/20230101/tag/Groups/operation/createGroups
+"""
+
+from typing import Annotated, Any, Literal, TypeAlias
+
+from pydantic import BeforeValidator, Field, TypeAdapter
+
+from cognite_toolkit._cdf_tk.client._resource_base import BaseModelObject
+from cognite_toolkit._cdf_tk.client.resource_classes.group._constants import SCOPE_NAME
+from cognite_toolkit._cdf_tk.utils._auxiliary import get_concrete_subclasses
+
+
+class ScopeDefinition(BaseModelObject):
+    """Base class for all scope definitions."""
+
+    scope_name: str
+
+
+class AllScope(ScopeDefinition):
+    """Scope that applies to all resources."""
+
+    scope_name: Literal["all"] = Field("all", exclude=True)
+
+
+class CurrentUserScope(ScopeDefinition):
+    """Scope that applies to the current user only."""
+
+    scope_name: Literal["currentuserscope"] = Field("currentuserscope", exclude=True)
+
+
+class DataSetScope(ScopeDefinition):
+    """Scope limited to specific data sets by ID."""
+
+    scope_name: Literal["datasetScope"] = Field("datasetScope", exclude=True)
+    ids: list[int]
+
+
+class IDScope(ScopeDefinition):
+    """Scope limited to specific resource IDs."""
+
+    scope_name: Literal["idScope"] = Field("idScope", exclude=True)
+    ids: list[int]
+
+
+class IDScopeLowerCase(ScopeDefinition):
+    """Scope limited to specific resource IDs (lowercase variant)."""
+
+    scope_name: Literal["idscope"] = Field("idscope", exclude=True)
+    ids: list[int]
+
+
+class SpaceIDScope(ScopeDefinition):
+    """Scope limited to specific spaces by ID."""
+
+    scope_name: Literal["spaceIdScope"] = Field("spaceIdScope", exclude=True)
+    space_ids: list[str]
+
+
+class AssetRootIDScope(ScopeDefinition):
+    """Scope limited to assets under specific root assets."""
+
+    scope_name: Literal["assetRootIdScope"] = Field("assetRootIdScope", exclude=True)
+    root_ids: list[int]
+
+
+class TableScope(ScopeDefinition):
+    """Scope limited to specific RAW tables."""
+
+    scope_name: Literal["tableScope"] = Field("tableScope", exclude=True)
+    dbs_to_tables: dict[str, list[str]]
+
+
+class ExtractionPipelineScope(ScopeDefinition):
+    """Scope limited to specific extraction pipelines."""
+
+    scope_name: Literal["extractionPipelineScope"] = Field("extractionPipelineScope", exclude=True)
+    ids: list[int]
+
+
+class InstancesScope(ScopeDefinition):
+    """Scope limited to specific instances."""
+
+    scope_name: Literal["instancesScope"] = Field("instancesScope", exclude=True)
+    instances: list[str]
+
+
+class PartitionScope(ScopeDefinition):
+    """Scope limited to specific partitions."""
+
+    scope_name: Literal["partition"] = Field("partition", exclude=True)
+    partition_ids: list[int]
+
+
+class ExperimentScope(ScopeDefinition):
+    """Scope limited to specific experiments."""
+
+    scope_name: Literal["experimentscope"] = Field("experimentscope", exclude=True)
+    experiments: list[str]
+
+
+class AppConfigScope(ScopeDefinition):
+    """Scope limited to specific app configurations."""
+
+    scope_name: Literal["appScope"] = Field("appScope", exclude=True)
+    apps: list[str]
+
+
+class PostgresGatewayUsersScope(ScopeDefinition):
+    """Scope limited to specific PostgreSQL gateway users."""
+
+    scope_name: Literal["usersScope"] = Field("usersScope", exclude=True)
+    usernames: list[str]
+
+
+class UnknownScope(ScopeDefinition):
+    """Fallback class for unknown scope definitions."""
+
+    scope_name: str
+
+
+def _get_scope_name(cls: type[ScopeDefinition]) -> str | None:
+    """Get the scope_name default value from a Pydantic model class."""
+    field = cls.model_fields.get("scope_name")
+    if field is not None and field.default is not None:
+        return field.default
+    return None
+
+
+_KNOWN_SCOPES = {
+    name: scope
+    for scope in get_concrete_subclasses(ScopeDefinition)
+    if (name := _get_scope_name(scope)) is not None and scope is not UnknownScope
+}
+
+
+def _handle_unknown_scope(value: Any) -> Any:
+    if isinstance(value, dict) and isinstance(scope_name := value.get(SCOPE_NAME), str):
+        scope_class = _KNOWN_SCOPES.get(scope_name)
+        if scope_class:
+            return TypeAdapter(scope_class).validate_python(value)
+    return UnknownScope.model_validate(value)
+
+
+Scope: TypeAlias = Annotated[
+    (
+        AllScope
+        | CurrentUserScope
+        | DataSetScope
+        | IDScope
+        | IDScopeLowerCase
+        | SpaceIDScope
+        | AssetRootIDScope
+        | TableScope
+        | ExtractionPipelineScope
+        | InstancesScope
+        | PartitionScope
+        | ExperimentScope
+        | AppConfigScope
+        | PostgresGatewayUsersScope
+        | UnknownScope
+    ),
+    BeforeValidator(_handle_unknown_scope),
+]

cognite_toolkit/_cdf_tk/client/resource_classes/hosted_extractor_destination.py

@@ -0,0 +1,34 @@
+from cognite_toolkit._cdf_tk.client._resource_base import (
+    BaseModelObject,
+    ResponseResource,
+    UpdatableRequestResource,
+)
+
+from .identifiers import ExternalId
+
+
+class Credentials(BaseModelObject):
+    nonce: str
+
+
+class HostedExtractorDestination(BaseModelObject):
+    external_id: str
+    target_data_set_id: int | None = None
+
+    def as_id(self) -> ExternalId:
+        return ExternalId(external_id=self.external_id)
+
+
+class HostedExtractorDestinationRequest(HostedExtractorDestination, UpdatableRequestResource):
+    credentials: Credentials | None = None
+
+
+class HostedExtractorDestinationResponse(
+    HostedExtractorDestination, ResponseResource[HostedExtractorDestinationRequest]
+):
+    session_id: int | None = None
+    created_time: int
+    last_updated_time: int
+
+    def as_request_resource(self) -> HostedExtractorDestinationRequest:
+        return HostedExtractorDestinationRequest.model_validate(self.dump(), extra="ignore")

cognite_toolkit/_cdf_tk/client/resource_classes/hosted_extractor_job.py

@@ -0,0 +1,134 @@
+from typing import Annotated, Literal
+
+from pydantic import Field, JsonValue
+
+from cognite_toolkit._cdf_tk.client._resource_base import (
+    BaseModelObject,
+    ResponseResource,
+    UpdatableRequestResource,
+)
+
+from .identifiers import ExternalId
+
+
+class JobFormatDefinition(BaseModelObject):
+    type: str
+
+
+class PrefixConfig(BaseModelObject):
+    from_topic: bool | None = None
+    prefix: str | None = None
+
+
+class SpaceRef(BaseModelObject):
+    space: str
+
+
+class CogniteFormat(JobFormatDefinition):
+    type: Literal["cognite"] = "cognite"
+    encoding: str | None = None
+    compression: str | None = None
+    prefix: PrefixConfig | None = None
+    data_models: list[SpaceRef] | None = None
+
+
+class CustomFormat(JobFormatDefinition):
+    type: Literal["custom"] = "custom"
+    encoding: str | None = None
+    compression: str | None = None
+    mapping_id: str
+
+
+class RockwellFormat(JobFormatDefinition):
+    type: Literal["rockwell"] = "rockwell"
+    encoding: str | None = None
+    compression: str | None = None
+    prefix: PrefixConfig | None = None
+    data_models: list[SpaceRef] | None = None
+
+
+class ValueFormat(JobFormatDefinition):
+    type: Literal["value"] = "value"
+    encoding: str | None = None
+    compression: str | None = None
+    prefix: PrefixConfig | None = None
+    data_models: list[SpaceRef] | None = None
+
+
+JobFormat = Annotated[
+    CogniteFormat | CustomFormat | RockwellFormat | ValueFormat,
+    Field(discriminator="type"),
+]
+
+
+class IncrementalLoadDefinition(BaseModelObject):
+    type: str
+
+
+class BodyIncrementalLoad(IncrementalLoadDefinition):
+    type: Literal["body"] = "body"
+    value: str
+
+
+class NextUrlIncrementalLoad(IncrementalLoadDefinition):
+    type: Literal["nextUrl"] = "nextUrl"
+    value: str
+
+
+class HeaderIncrementalLoad(IncrementalLoadDefinition):
+    type: Literal["headerValue"] = "headerValue"
+    key: str
+    value: str
+
+
+class QueryParamIncrementalLoad(IncrementalLoadDefinition):
+    type: Literal["queryParam"] = "queryParam"
+    key: str
+    value: str
+
+
+class MQTTConfig(BaseModelObject):
+    topic_filter: str
+
+
+class KafkaConfig(BaseModelObject):
+    topic: str
+    partitions: int | None = None
+
+
+class RestConfig(BaseModelObject):
+    interval: Literal["5m", "15m", "1h", "6h", "12h", "1d"]
+    path: str
+    method: Literal["get", "post"] | None = None
+    body: JsonValue | None = None
+    query: dict[str, str] | None = None
+    headers: dict[str, str] | None = None
+    incremental_load: BodyIncrementalLoad | HeaderIncrementalLoad | QueryParamIncrementalLoad | None = Field(
+        None, discriminator="type"
+    )
+    pagination: (
+        BodyIncrementalLoad | NextUrlIncrementalLoad | HeaderIncrementalLoad | QueryParamIncrementalLoad | None
+    ) = Field(None, discriminator="type")
+
+
+class HostedExtractorJob(BaseModelObject):
+    external_id: str
+    destination_id: str
+    source_id: str
+    format: JobFormat
+    config: MQTTConfig | KafkaConfig | RestConfig
+
+    def as_id(self) -> ExternalId:
+        return ExternalId(external_id=self.external_id)
+
+
+class HostedExtractorJobRequest(HostedExtractorJob, UpdatableRequestResource): ...
+
+
+class HostedExtractorJobResponse(HostedExtractorJob, ResponseResource[HostedExtractorJobRequest]):
+    status: str | None = None
+    created_time: int
+    last_updated_time: int
+
+    def as_request_resource(self) -> HostedExtractorJobRequest:
+        return HostedExtractorJobRequest.model_validate(self.dump(), extra="ignore")

cognite_toolkit/_cdf_tk/client/resource_classes/hosted_extractor_mapping.py

@@ -0,0 +1,72 @@
+from typing import Annotated, Literal
+
+from pydantic import Field
+
+from cognite_toolkit._cdf_tk.client._resource_base import (
+    BaseModelObject,
+    ResponseResource,
+    UpdatableRequestResource,
+)
+
+from .identifiers import ExternalId
+
+
+class Mapping(BaseModelObject):
+    expression: str
+
+
+class MappingInputDefinition(BaseModelObject):
+    type: str
+
+
+class ProtobufFile(BaseModelObject):
+    file_name: str
+    content: str
+
+
+class ProtobufInput(BaseModelObject):
+    type: Literal["protobuf"] = "protobuf"
+    message_name: str
+    files: list[ProtobufFile]
+
+
+class CSVInput(BaseModelObject):
+    type: Literal["csv"] = "csv"
+    delimiter: str = ","
+    custom_keys: list[str] | None = None
+
+
+class XMLInput(BaseModelObject):
+    type: Literal["xml"] = "xml"
+
+
+class JSONInput(BaseModelObject):
+    type: Literal["json"] = "json"
+
+
+MappingInput = Annotated[
+    ProtobufInput | CSVInput | XMLInput | JSONInput,
+    Field(discriminator="type"),
+]
+
+
+class HostedExtractorMapping(BaseModelObject):
+    external_id: str
+    mapping: Mapping
+    published: bool
+
+    def as_id(self) -> ExternalId:
+        return ExternalId(external_id=self.external_id)
+
+
+class HostedExtractorMappingRequest(HostedExtractorMapping, UpdatableRequestResource):
+    input: MappingInput | None = None
+
+
+class HostedExtractorMappingResponse(HostedExtractorMapping, ResponseResource[HostedExtractorMappingRequest]):
+    input: MappingInput
+    created_time: int
+    last_updated_time: int
+
+    def as_request_resource(self) -> HostedExtractorMappingRequest:
+        return HostedExtractorMappingRequest.model_validate(self.dump(), extra="ignore")

cognite_toolkit/_cdf_tk/client/resource_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/resource_classes/hosted_extractor_source/_auth.py

@@ -0,0 +1,63 @@
+from typing import Literal
+
+from cognite_toolkit._cdf_tk.client._resource_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/resource_classes/hosted_extractor_source/_base.py

@@ -0,0 +1,26 @@
+from typing import Any, Literal
+
+from cognite_toolkit._cdf_tk.client._resource_base import (
+    BaseModelObject,
+    UpdatableRequestResource,
+)
+from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import ExternalId
+
+
+class SourceRequestDefinition(UpdatableRequestResource):
+    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/resource_classes/hosted_extractor_source/_certificate.py

@@ -0,0 +1,20 @@
+from cognite_toolkit._cdf_tk.client._resource_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/resource_classes/hosted_extractor_source/_eventhub.py

@@ -0,0 +1,31 @@
+from typing import Literal
+
+from cognite_toolkit._cdf_tk.client._resource_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")