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

cognite_toolkit/_cdf_tk/client/resource_classes/data_modeling/_view_property.py

@@ -0,0 +1,152 @@
+from abc import ABC
+from typing import Annotated, Any, Literal
+
+from pydantic import Field, JsonValue, TypeAdapter, field_serializer
+from pydantic_core.core_schema import FieldSerializationInfo
+
+from cognite_toolkit._cdf_tk.client._resource_base import BaseModelObject
+
+from ._data_types import DataType
+from ._references import ContainerDirectReference, ContainerReference, NodeReference, ViewDirectReference, ViewReference
+
+
+class ViewPropertyDefinition(BaseModelObject, ABC):
+    connection_type: str
+
+
+class ViewCoreProperty(ViewPropertyDefinition, ABC):
+    # Core properties do not have connection type in the API, but we add it here such that
+    # we can use it as a discriminator in unions. The exclude=True ensures that it is not
+    # sent to the API.
+    connection_type: Literal["primary_property"] = Field(default="primary_property", exclude=True)
+    name: str | None = None
+    description: str | None = None
+    container: ContainerReference
+    container_property_identifier: str
+
+    @field_serializer("container", mode="plain")
+    @classmethod
+    def serialize_container(cls, container: ContainerReference, info: FieldSerializationInfo) -> dict[str, Any]:
+        return {**container.model_dump(**vars(info)), "type": "container"}
+
+
+class ViewCorePropertyRequest(ViewCoreProperty):
+    source: ViewReference | None = None
+
+    @field_serializer("source", mode="plain")
+    @classmethod
+    def serialize_source(cls, source: ViewReference | None, info: FieldSerializationInfo) -> dict[str, Any] | None:
+        if source is None:
+            return None
+        return {**source.model_dump(**vars(info)), "type": "view"}
+
+
+class ConstraintOrIndexState(BaseModelObject):
+    nullability: Literal["current", "pending", "failed"] | None = None
+    max_list_size: Literal["current", "pending", "failed"] | None = None
+    max_text_size: Literal["current", "pending", "failed"] | None = None
+
+
+class ViewCorePropertyResponse(ViewCoreProperty):
+    immutable: bool | None = None
+    nullable: bool | None = None
+    auto_increment: bool | None = None
+    default_value: str | int | bool | dict[str, JsonValue] | None = None
+    constraint_state: ConstraintOrIndexState
+    type: DataType
+
+    def as_request(self) -> ViewCorePropertyRequest:
+        return ViewCorePropertyRequest.model_validate(self.model_dump(by_alias=True))
+
+
+class ConnectionPropertyDefinition(ViewPropertyDefinition, ABC):
+    name: str | None = None
+    description: str | None = None
+
+
+class EdgeProperty(ConnectionPropertyDefinition, ABC):
+    source: ViewReference
+    type: NodeReference
+    edge_source: ViewReference | None = None
+    direction: Literal["outwards", "inwards"] = "outwards"
+
+    @field_serializer("source", "edge_source", mode="plain")
+    @classmethod
+    def serialize_source(cls, source: ViewReference | None, info: FieldSerializationInfo) -> dict[str, Any] | None:
+        if source is None:
+            return None
+        return {**source.model_dump(**vars(info)), "type": "view"}
+
+
+class SingleEdgeProperty(EdgeProperty):
+    connection_type: Literal["single_edge_connection"] = "single_edge_connection"
+
+
+class MultiEdgeProperty(EdgeProperty):
+    connection_type: Literal["multi_edge_connection"] = "multi_edge_connection"
+
+
+class ReverseDirectRelationProperty(ConnectionPropertyDefinition, ABC):
+    source: ViewReference
+    through: ContainerDirectReference | ViewDirectReference
+
+    @field_serializer("source", mode="plain")
+    @classmethod
+    def serialize_source(cls, source: ViewReference, info: FieldSerializationInfo) -> dict[str, Any]:
+        return {**source.model_dump(**vars(info)), "type": "view"}
+
+    @field_serializer("through", mode="plain")
+    @classmethod
+    def serialize_through(
+        cls, through: ContainerDirectReference | ViewDirectReference, info: FieldSerializationInfo
+    ) -> dict[str, Any]:
+        output = through.model_dump(**vars(info))
+        if isinstance(through, ContainerDirectReference):
+            output["source"]["type"] = "container"
+        else:
+            output["source"]["type"] = "view"
+        return output
+
+
+class SingleReverseDirectRelationPropertyRequest(ReverseDirectRelationProperty):
+    connection_type: Literal["single_reverse_direct_relation"] = "single_reverse_direct_relation"
+
+
+class MultiReverseDirectRelationPropertyRequest(ReverseDirectRelationProperty):
+    connection_type: Literal["multi_reverse_direct_relation"] = "multi_reverse_direct_relation"
+
+
+class SingleReverseDirectRelationPropertyResponse(ReverseDirectRelationProperty):
+    connection_type: Literal["single_reverse_direct_relation"] = "single_reverse_direct_relation"
+    targets_list: bool
+
+    def as_request(self) -> SingleReverseDirectRelationPropertyRequest:
+        return SingleReverseDirectRelationPropertyRequest.model_validate(self.model_dump(by_alias=True))
+
+
+class MultiReverseDirectRelationPropertyResponse(ReverseDirectRelationProperty):
+    connection_type: Literal["multi_reverse_direct_relation"] = "multi_reverse_direct_relation"
+    targets_list: bool
+
+    def as_request(self) -> MultiReverseDirectRelationPropertyRequest:
+        return MultiReverseDirectRelationPropertyRequest.model_validate(self.model_dump(by_alias=True))
+
+
+ViewRequestProperty = Annotated[
+    SingleEdgeProperty
+    | MultiEdgeProperty
+    | SingleReverseDirectRelationPropertyRequest
+    | MultiReverseDirectRelationPropertyRequest
+    | ViewCorePropertyRequest,
+    Field(discriminator="connection_type"),
+]
+ViewResponseProperty = Annotated[
+    SingleEdgeProperty
+    | MultiEdgeProperty
+    | SingleReverseDirectRelationPropertyResponse
+    | MultiReverseDirectRelationPropertyResponse
+    | ViewCorePropertyResponse,
+    Field(discriminator="connection_type"),
+]
+
+ViewRequestPropertyAdapter: TypeAdapter[ViewRequestProperty] = TypeAdapter(ViewRequestProperty)

cognite_toolkit/_cdf_tk/client/resource_classes/dataset.py

@@ -0,0 +1,35 @@
+from typing import ClassVar
+
+from cognite_toolkit._cdf_tk.client._resource_base import (
+    BaseModelObject,
+    ResponseResource,
+    UpdatableRequestResource,
+)
+
+from .identifiers import ExternalId
+
+
+class DataSet(BaseModelObject):
+    external_id: str | None = None
+    name: str | None = None
+    description: str | None = None
+    metadata: dict[str, str] | None = None
+    write_protected: bool = False
+
+    def as_id(self) -> ExternalId:
+        if self.external_id is None:
+            raise ValueError("Cannot convert DataSet to ExternalId when external_id is None")
+        return ExternalId(external_id=self.external_id)
+
+
+class DataSetRequest(DataSet, UpdatableRequestResource):
+    container_fields: ClassVar[frozenset[str]] = frozenset({"metadata"})
+
+
+class DataSetResponse(DataSet, ResponseResource[DataSetRequest]):
+    id: int
+    created_time: int
+    last_updated_time: int
+
+    def as_request_resource(self) -> DataSetRequest:
+        return DataSetRequest.model_validate(self.dump(), extra="ignore")

cognite_toolkit/_cdf_tk/client/resource_classes/event.py

@@ -0,0 +1,40 @@
+from typing import ClassVar
+
+from cognite_toolkit._cdf_tk.client._resource_base import (
+    BaseModelObject,
+    ResponseResource,
+    UpdatableRequestResource,
+)
+
+from .identifiers import ExternalId, InternalOrExternalId
+
+
+class Event(BaseModelObject):
+    external_id: str | None = None
+    data_set_id: int | None = None
+    start_time: int | None = None
+    end_time: int | None = None
+    type: str | None = None
+    subtype: str | None = None
+    description: str | None = None
+    metadata: dict[str, str] | None = None
+    asset_ids: list[int] | None = None
+    source: str | None = None
+
+    def as_id(self) -> InternalOrExternalId:
+        if self.external_id is None:
+            raise ValueError("Cannot convert EventRequest to ExternalId when external_id is None")
+        return ExternalId(external_id=self.external_id)
+
+
+class EventRequest(Event, UpdatableRequestResource):
+    container_fields: ClassVar[frozenset[str]] = frozenset({"metadata", "asset_ids"})
+
+
+class EventResponse(Event, ResponseResource[EventRequest]):
+    id: int
+    created_time: int
+    last_updated_time: int
+
+    def as_request_resource(self) -> EventRequest:
+        return EventRequest.model_validate(self.dump(), extra="ignore")

cognite_toolkit/_cdf_tk/client/resource_classes/extraction_pipeline.py

@@ -0,0 +1,59 @@
+from typing import ClassVar
+
+from cognite_toolkit._cdf_tk.client._resource_base import (
+    BaseModelObject,
+    ResponseResource,
+    UpdatableRequestResource,
+)
+
+from .identifiers import ExternalId
+
+
+class RawTable(BaseModelObject):
+    db_name: str
+    table_name: str
+
+
+class Contact(BaseModelObject):
+    name: str | None = None
+    email: str | None = None
+    role: str | None = None
+    send_notification: bool | None = None
+
+
+class NotificationConfig(BaseModelObject):
+    allowed_not_seen_range_in_minutes: int | None = None
+
+
+class ExtractionPipeline(BaseModelObject):
+    external_id: str
+    name: str
+    description: str | None = None
+    data_set_id: int
+    raw_tables: list[RawTable] | None = None
+    schedule: str | None = None
+    contacts: list[Contact] | None = None
+    metadata: dict[str, str] | None = None
+    source: str | None = None
+    documentation: str | None = None
+    notification_config: NotificationConfig | None = None
+    created_by: str | None = None
+
+    def as_id(self) -> ExternalId:
+        return ExternalId(external_id=self.external_id)
+
+
+class ExtractionPipelineRequest(ExtractionPipeline, UpdatableRequestResource):
+    container_fields: ClassVar[frozenset[str]] = frozenset({"raw_tables", "contacts", "metadata"})
+    non_nullable_fields: ClassVar[frozenset[str]] = frozenset(
+        {"documentation", "source", "notification_config", "schedule", "description"}
+    )
+
+
+class ExtractionPipelineResponse(ExtractionPipeline, ResponseResource[ExtractionPipelineRequest]):
+    id: int
+    created_time: int
+    last_updated_time: int
+
+    def as_request_resource(self) -> ExtractionPipelineRequest:
+        return ExtractionPipelineRequest.model_validate(self.dump(), extra="ignore")

cognite_toolkit/_cdf_tk/client/resource_classes/filemetadata.py

@@ -0,0 +1,52 @@
+from typing import ClassVar, Literal
+
+from pydantic import Field, JsonValue
+
+from cognite_toolkit._cdf_tk.client._resource_base import BaseModelObject, ResponseResource, UpdatableRequestResource
+
+from .identifiers import ExternalId
+from .instance_api import NodeReference
+
+
+class FileMetadata(BaseModelObject):
+    external_id: str | None = None
+    name: str
+    directory: str | None = None
+    source: str | None = None
+    mime_type: str | None = None
+    metadata: dict[str, str] | None = None
+    asset_ids: list[int] | None = None
+    data_set_id: int | None = None
+    labels: list[dict[Literal["externalId"], str]] | None = None
+    geo_location: JsonValue | None = None
+    source_created_time: int | None = None
+    source_modified_time: int | None = None
+    security_categories: list[int] | None = None
+
+    def as_id(self) -> ExternalId:
+        if self.external_id is None:
+            raise ValueError("Cannot convert FileMetadataRequest to ExternalId when external_id is None")
+        return ExternalId(external_id=self.external_id)
+
+
+class FileMetadataRequest(FileMetadata, UpdatableRequestResource):
+    container_fields: ClassVar[frozenset[str]] = frozenset({"metadata", "labels", "asset_ids", "security_categories"})
+    non_nullable_fields: ClassVar[frozenset[str]] = frozenset({"asset_ids", "security_categories"})
+    # This field is not part of the request when creating or updating a resource
+    # but we added it here for convenience so that it is available when converting
+    # from response to request.
+    instance_id: NodeReference | None = Field(default=None, exclude=True)
+
+
+class FileMetadataResponse(FileMetadata, ResponseResource[FileMetadataRequest]):
+    created_time: int
+    last_updated_time: int
+    uploaded_time: int | None = None
+    uploaded: bool
+    id: int
+    instance_id: NodeReference | None = None
+    # This field is required in the upload endpoint response, but not in any other file metadata response
+    upload_url: str | None = None
+
+    def as_request_resource(self) -> FileMetadataRequest:
+        return FileMetadataRequest.model_validate(self.dump(), extra="ignore")

cognite_toolkit/_cdf_tk/client/resource_classes/function.py

@@ -0,0 +1,53 @@
+from typing import Literal, TypeAlias
+
+from cognite_toolkit._cdf_tk.client._resource_base import BaseModelObject, RequestResource, ResponseResource
+
+from .identifiers import ExternalId
+
+FunctionStatus: TypeAlias = Literal["Queued", "Deploying", "Ready", "Failed"]
+
+
+class FunctionBase(BaseModelObject):
+    """Base class for Function with common fields."""
+
+    external_id: str | None = None
+    name: str
+    file_id: int
+    description: str | None = None
+    owner: str | None = None
+    function_path: str | None = None
+    secrets: dict[str, str] | None = None
+    env_vars: dict[str, str] | None = None
+    cpu: float | None = None
+    memory: float | None = None
+    runtime: Literal["py310", "py311", "py312"] | None = None
+    runtime_version: str | None = None
+    metadata: dict[str, str] | None = None
+    index_url: str | None = None
+    extra_index_urls: list[str] | None = None
+
+
+class FunctionRequest(FunctionBase, RequestResource):
+    """Request resource for creating/updating functions."""
+
+    def as_id(self) -> ExternalId:
+        if self.external_id is None:
+            raise ValueError("Cannot create ExternalId: external_id is None")
+        return ExternalId(external_id=self.external_id)
+
+
+class FunctionAPIError(BaseModelObject):
+    code: int
+    message: str
+
+
+class FunctionResponse(FunctionBase, ResponseResource[FunctionRequest]):
+    """Response resource for functions."""
+
+    id: int
+    created_time: int
+    status: FunctionStatus | None = None
+    error: FunctionAPIError | None = None
+
+    def as_request_resource(self) -> FunctionRequest:
+        return FunctionRequest.model_validate(self.dump(), extra="ignore")

cognite_toolkit/_cdf_tk/client/resource_classes/function_schedule.py

@@ -0,0 +1,65 @@
+from pydantic import Field, JsonValue
+
+from cognite_toolkit._cdf_tk.client._resource_base import (
+    BaseModelObject,
+    Identifier,
+    RequestResource,
+    ResponseResource,
+)
+from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import InternalId
+
+
+class FunctionScheduleId(Identifier):
+    """Identifier for a function schedule."""
+
+    function_external_id: str
+    name: str
+
+    def __str__(self) -> str:
+        return f"functionExternalId='{self.function_external_id}', name='{self.name}'"
+
+
+class FunctionScheduleCredentials(BaseModelObject):
+    """Credentials for function schedule authentication."""
+
+    client_id: str
+    client_secret: str
+
+
+class FunctionSchedule(BaseModelObject):
+    """Base class for function schedule with common fields."""
+
+    name: str
+    cron_expression: str
+    description: str | None = None
+    data: dict[str, JsonValue] | None = None
+
+
+class FunctionScheduleRequest(FunctionSchedule, RequestResource):
+    """Request resource for creating/updating function schedules."""
+
+    # The 'id' field is not part of the request when creating a new resource,
+    # but is needed when deleting an existing resource.
+    id: int | None = Field(default=None, exclude=True)
+    function_id: int
+    function_external_id: str | None = Field(None, exclude=True)
+    nonce: str
+
+    def as_id(self) -> InternalId:
+        if self.id is None:
+            raise ValueError("Cannot convert FunctionScheduleRequest to InternalId when id is None")
+        return InternalId(id=self.id)
+
+
+class FunctionScheduleResponse(FunctionSchedule, ResponseResource[FunctionScheduleRequest]):
+    """Response resource for function schedules."""
+
+    id: int
+    created_time: int
+    when: str
+    function_id: int | None = None
+    function_external_id: str | None = None
+    session_id: int | None = None
+
+    def as_request_resource(self) -> FunctionScheduleRequest:
+        raise NotImplementedError("Cannot convert to request resource as 'nonce' is missing.")

cognite_toolkit/_cdf_tk/client/resource_classes/graphql_data_model.py

@@ -0,0 +1,40 @@
+from cognite_toolkit._cdf_tk.client._resource_base import (
+    BaseModelObject,
+    RequestResource,
+    ResponseResource,
+)
+
+from .data_modeling import DataModelReference, ViewReference
+
+
+class GraphQLDataModel(BaseModelObject):
+    """Base class for GraphQL data model with common fields."""
+
+    space: str
+    external_id: str
+    version: str
+    name: str | None = None
+    description: str | None = None
+
+
+class GraphQLDataModelRequest(GraphQLDataModel, RequestResource):
+    """Request resource for creating/updating GraphQL data models."""
+
+    previous_version: str | None = None
+    dml: str | None = None
+    preserve_dml: bool | None = None
+
+    def as_id(self) -> DataModelReference:
+        return DataModelReference(space=self.space, external_id=self.external_id, version=self.version)
+
+
+class GraphQLDataModelResponse(GraphQLDataModel, ResponseResource[GraphQLDataModelRequest]):
+    """Response resource for GraphQL data models."""
+
+    is_global: bool
+    created_time: int
+    last_updated_time: int
+    views: list[ViewReference] | None = None
+
+    def as_request_resource(self) -> GraphQLDataModelRequest:
+        return GraphQLDataModelRequest.model_validate(self.dump(), extra="ignore")

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

@@ -0,0 +1,187 @@
+"""Group data classes for the Cognite API Groups endpoint.
+
+Based on the API specification at:
+https://api-docs.cognite.com/20230101/tag/Groups/operation/createGroups
+"""
+
+from .acls import (
+    Acl,
+    AgentsAcl,
+    AnalyticsAcl,
+    AnnotationsAcl,
+    AppConfigAcl,
+    AssetsAcl,
+    AuditlogAcl,
+    DataModelInstancesAcl,
+    DataModelsAcl,
+    DataSetsAcl,
+    DiagramParsingAcl,
+    DigitalTwinAcl,
+    DocumentFeedbackAcl,
+    DocumentPipelinesAcl,
+    EntityMatchingAcl,
+    EventsAcl,
+    ExperimentsAcl,
+    ExtractionConfigsAcl,
+    ExtractionPipelinesAcl,
+    ExtractionRunsAcl,
+    FilePipelinesAcl,
+    FilesAcl,
+    FunctionsAcl,
+    GeospatialAcl,
+    GeospatialCrsAcl,
+    GroupsAcl,
+    HostedExtractorsAcl,
+    LabelsAcl,
+    LegacyGenericsAcl,
+    LegacyModelHostingAcl,
+    LocationFiltersAcl,
+    MonitoringTasksAcl,
+    NotificationsAcl,
+    PipelinesAcl,
+    PostgresGatewayAcl,
+    ProjectsAcl,
+    RawAcl,
+    RelationshipsAcl,
+    RoboticsAcl,
+    SAPWritebackAcl,
+    SAPWritebackRequestsAcl,
+    ScheduledCalculationsAcl,
+    SecurityCategoriesAcl,
+    SeismicAcl,
+    SequencesAcl,
+    SessionsAcl,
+    SimulatorsAcl,
+    StreamRecordsAcl,
+    StreamsAcl,
+    TemplateGroupsAcl,
+    TemplateInstancesAcl,
+    ThreeDAcl,
+    TimeSeriesAcl,
+    TimeSeriesSubscriptionsAcl,
+    TransformationsAcl,
+    TypesAcl,
+    UnknownAcl,
+    UserProfilesAcl,
+    VideoStreamingAcl,
+    VisionModelAcl,
+    WellsAcl,
+    WorkflowOrchestrationAcl,
+)
+from .capability import (
+    GroupCapability,
+    ProjectUrlNames,
+)
+from .group import (
+    Group,
+    GroupAttributes,
+    GroupRequest,
+    GroupResponse,
+    TokenAttributes,
+)
+from .scopes import (
+    AllScope,
+    AppConfigScope,
+    AssetRootIDScope,
+    CurrentUserScope,
+    DataSetScope,
+    ExperimentScope,
+    ExtractionPipelineScope,
+    IDScope,
+    IDScopeLowerCase,
+    InstancesScope,
+    PartitionScope,
+    PostgresGatewayUsersScope,
+    Scope,
+    ScopeDefinition,
+    SpaceIDScope,
+    TableScope,
+)
+
+__all__ = [
+    "Acl",
+    "AgentsAcl",
+    "AllScope",
+    "AnalyticsAcl",
+    "AnnotationsAcl",
+    "AppConfigAcl",
+    "AppConfigScope",
+    "AssetRootIDScope",
+    "AssetsAcl",
+    "AuditlogAcl",
+    "CurrentUserScope",
+    "DataModelInstancesAcl",
+    "DataModelsAcl",
+    "DataSetScope",
+    "DataSetsAcl",
+    "DiagramParsingAcl",
+    "DigitalTwinAcl",
+    "DocumentFeedbackAcl",
+    "DocumentPipelinesAcl",
+    "EntityMatchingAcl",
+    "EventsAcl",
+    "ExperimentScope",
+    "ExperimentsAcl",
+    "ExtractionConfigsAcl",
+    "ExtractionPipelineScope",
+    "ExtractionPipelinesAcl",
+    "ExtractionRunsAcl",
+    "FilePipelinesAcl",
+    "FilesAcl",
+    "FunctionsAcl",
+    "GeospatialAcl",
+    "GeospatialCrsAcl",
+    "Group",
+    "GroupAttributes",
+    "GroupCapability",
+    "GroupRequest",
+    "GroupResponse",
+    "GroupsAcl",
+    "HostedExtractorsAcl",
+    "IDScope",
+    "IDScopeLowerCase",
+    "InstancesScope",
+    "LabelsAcl",
+    "LegacyGenericsAcl",
+    "LegacyModelHostingAcl",
+    "LocationFiltersAcl",
+    "MonitoringTasksAcl",
+    "NotificationsAcl",
+    "PartitionScope",
+    "PipelinesAcl",
+    "PostgresGatewayAcl",
+    "PostgresGatewayUsersScope",
+    "ProjectUrlNames",
+    "ProjectsAcl",
+    "RawAcl",
+    "RelationshipsAcl",
+    "RoboticsAcl",
+    "SAPWritebackAcl",
+    "SAPWritebackRequestsAcl",
+    "ScheduledCalculationsAcl",
+    "Scope",
+    "ScopeDefinition",
+    "SecurityCategoriesAcl",
+    "SeismicAcl",
+    "SequencesAcl",
+    "SessionsAcl",
+    "SimulatorsAcl",
+    "SpaceIDScope",
+    "StreamRecordsAcl",
+    "StreamsAcl",
+    "TableScope",
+    "TemplateGroupsAcl",
+    "TemplateInstancesAcl",
+    "ThreeDAcl",
+    "TimeSeriesAcl",
+    "TimeSeriesSubscriptionsAcl",
+    "TokenAttributes",
+    "TransformationsAcl",
+    "TypesAcl",
+    "UnknownAcl",
+    "UserProfilesAcl",
+    "VideoStreamingAcl",
+    "VisionModelAcl",
+    "WellsAcl",
+    "WorkflowOrchestrationAcl",
+]

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

@@ -0,0 +1,2 @@
+ACL_NAME = "acl_name"
+SCOPE_NAME = "scope_name"