cognite-toolkit 0.7.45__py3-none-any.whl → 0.7.46__py3-none-any.whl

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

@@ -0,0 +1,59 @@
+"""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 cognite_toolkit._cdf_tk.client.resource_classes.base import (
+    BaseModelObject,
+    RequestResource,
+    ResponseResource,
+)
+from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import NameId
+
+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
+
+    def as_id(self) -> NameId:
+        return NameId(name=self.name)
+
+
+class GroupRequest(Group, RequestResource):
+    """Group request resource for creating/updating groups."""
+
+    ...
+
+
+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_classes.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/{data_classes → resource_classes}/hosted_extractor_destination.py

@@ -1,4 +1,4 @@
-from cognite_toolkit._cdf_tk.client.data_classes.base import (
+from cognite_toolkit._cdf_tk.client.resource_classes.base import (
     BaseModelObject,
     RequestUpdateable,
     ResponseResource,

cognite_toolkit/_cdf_tk/client/{data_classes → resource_classes}/hosted_extractor_job.py

@@ -2,7 +2,7 @@ from typing import Annotated, Literal
 
 from pydantic import Field, JsonValue
 
-from cognite_toolkit._cdf_tk.client.data_classes.base import (
+from cognite_toolkit._cdf_tk.client.resource_classes.base import (
     BaseModelObject,
     RequestUpdateable,
     ResponseResource,

cognite_toolkit/_cdf_tk/client/{data_classes → resource_classes}/hosted_extractor_mapping.py

@@ -2,7 +2,7 @@ from typing import Annotated, Literal
 
 from pydantic import Field
 
-from cognite_toolkit._cdf_tk.client.data_classes.base import (
+from cognite_toolkit._cdf_tk.client.resource_classes.base import (
     BaseModelObject,
     RequestUpdateable,
     ResponseResource,

cognite_toolkit/_cdf_tk/client/{data_classes → resource_classes}/hosted_extractor_source/_auth.py

@@ -1,6 +1,6 @@
 from typing import Literal
 
-from cognite_toolkit._cdf_tk.client.data_classes.base import (
+from cognite_toolkit._cdf_tk.client.resource_classes.base import (
     BaseModelObject,
 )
 

cognite_toolkit/_cdf_tk/client/{data_classes → resource_classes}/hosted_extractor_source/_base.py

@@ -1,10 +1,10 @@
 from typing import Any, Literal
 
-from cognite_toolkit._cdf_tk.client.data_classes.base import (
+from cognite_toolkit._cdf_tk.client.resource_classes.base import (
     BaseModelObject,
     RequestUpdateable,
 )
-from cognite_toolkit._cdf_tk.client.data_classes.identifiers import ExternalId
+from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import ExternalId
 
 
 class SourceRequestDefinition(RequestUpdateable):

cognite_toolkit/_cdf_tk/client/{data_classes → resource_classes}/hosted_extractor_source/_certificate.py

@@ -1,4 +1,4 @@
-from cognite_toolkit._cdf_tk.client.data_classes.base import (
+from cognite_toolkit._cdf_tk.client.resource_classes.base import (
     BaseModelObject,
 )
 

cognite_toolkit/_cdf_tk/client/{data_classes → resource_classes}/hosted_extractor_source/_eventhub.py

@@ -1,6 +1,6 @@
 from typing import Literal
 
-from cognite_toolkit._cdf_tk.client.data_classes.base import (
+from cognite_toolkit._cdf_tk.client.resource_classes.base import (
     BaseModelObject,
     ResponseResource,
 )

cognite_toolkit/_cdf_tk/client/{data_classes → resource_classes}/hosted_extractor_source/_kafka.py

@@ -2,7 +2,7 @@ from typing import Literal
 
 from pydantic import Field
 
-from cognite_toolkit._cdf_tk.client.data_classes.base import (
+from cognite_toolkit._cdf_tk.client.resource_classes.base import (
     BaseModelObject,
     ResponseResource,
 )

cognite_toolkit/_cdf_tk/client/{data_classes → resource_classes}/hosted_extractor_source/_mqtt.py

@@ -1,6 +1,6 @@
 from typing import Literal
 
-from cognite_toolkit._cdf_tk.client.data_classes.base import (
+from cognite_toolkit._cdf_tk.client.resource_classes.base import (
     BaseModelObject,
     ResponseResource,
 )

cognite_toolkit/_cdf_tk/client/{data_classes → resource_classes}/hosted_extractor_source/_rest.py

@@ -2,7 +2,7 @@ from typing import Literal
 
 from pydantic import Field
 
-from cognite_toolkit._cdf_tk.client.data_classes.base import (
+from cognite_toolkit._cdf_tk.client.resource_classes.base import (
     BaseModelObject,
     ResponseResource,
 )

cognite_toolkit/_cdf_tk/client/{data_classes → resource_classes}/identifiers.py

@@ -3,7 +3,7 @@ from typing import Annotated, Literal
 
 from pydantic import Field
 
-from cognite_toolkit._cdf_tk.client.data_classes.base import Identifier
+from cognite_toolkit._cdf_tk.client.resource_classes.base import Identifier
 
 
 class InternalOrExternalIdDefinition(Identifier):

cognite_toolkit/_cdf_tk/client/{data_classes → resource_classes}/label.py

@@ -1,4 +1,4 @@
-from cognite_toolkit._cdf_tk.client.data_classes.base import (
+from cognite_toolkit._cdf_tk.client.resource_classes.base import (
     BaseModelObject,
     RequestResource,
     ResponseResource,

cognite_toolkit/_cdf_tk/client/{data_classes → resource_classes}/legacy/canvas.py

@@ -30,7 +30,7 @@ from cognite.client.data_classes.data_modeling.instances import (
     TypedNodeApply,
 )
 
-from cognite_toolkit._cdf_tk.client.data_classes.legacy.migration import AssetCentricId
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.migration import AssetCentricId
 from cognite_toolkit._cdf_tk.utils.useful_types import JsonVal
 
 if sys.version_info >= (3, 11):

cognite_toolkit/_cdf_tk/client/{data_classes → resource_classes}/legacy/charts.py

@@ -9,7 +9,7 @@ from cognite.client.data_classes._base import (
     WriteableCogniteResourceList,
 )
 
-from cognite_toolkit._cdf_tk.client.data_classes.charts_data import ChartData
+from cognite_toolkit._cdf_tk.client.resource_classes.charts_data import ChartData
 
 if sys.version_info >= (3, 11):
     from typing import Self

cognite_toolkit/_cdf_tk/client/resource_classes/location_filter.py

@@ -0,0 +1,77 @@
+from typing import Literal
+
+from cognite_toolkit._cdf_tk.client.resource_classes.base import BaseModelObject, RequestResource, ResponseResource
+
+from .data_modeling import DataModelReference
+from .identifiers import ExternalId, InternalId
+
+
+class LocationFilterScene(BaseModelObject):
+    """Scene configuration for a location filter."""
+
+    external_id: str
+    space: str
+
+
+class LocationFilterView(BaseModelObject):
+    """View identifier with entity type for location filter."""
+
+    external_id: str
+    space: str
+    version: str
+    represents_entity: Literal["MAINTENANCE_ORDER", "OPERATION", "NOTIFICATION", "ASSET"] | None = None
+
+
+class AssetCentricSubFilter(BaseModelObject):
+    """Sub-filter for asset-centric resource types."""
+
+    data_set_ids: list[int] | None = None
+    asset_subtree_ids: list[ExternalId | InternalId] | None = None
+    external_id_prefix: str | None = None
+
+
+class AssetCentricFilter(BaseModelObject):
+    """Filter definition for asset-centric resource types."""
+
+    assets: AssetCentricSubFilter | None = None
+    events: AssetCentricSubFilter | None = None
+    files: AssetCentricSubFilter | None = None
+    timeseries: AssetCentricSubFilter | None = None
+    sequences: AssetCentricSubFilter | None = None
+    data_set_ids: list[int] | None = None
+    asset_subtree_ids: list[ExternalId | InternalId] | None = None
+    external_id_prefix: str | None = None
+
+
+class LocationFilter(BaseModelObject):
+    """Base class for location filter with common fields."""
+
+    external_id: str
+    name: str
+    description: str | None = None
+    parent_id: int | None = None
+    data_models: list[DataModelReference] | None = None
+    instance_spaces: list[str] | None = None
+    scene: LocationFilterScene | None = None
+    asset_centric: AssetCentricFilter | None = None
+    views: list[LocationFilterView] | None = None
+    data_modeling_type: Literal["HYBRID", "DATA_MODELING_ONLY"] | None = None
+
+
+class LocationFilterRequest(LocationFilter, RequestResource):
+    """Request resource for creating/updating location filters."""
+
+    def as_id(self) -> ExternalId:
+        return ExternalId(external_id=self.external_id)
+
+
+class LocationFilterResponse(LocationFilter, ResponseResource[LocationFilterRequest]):
+    """Response resource for location filters."""
+
+    id: int
+    created_time: int
+    updated_time: int
+    locations: list["LocationFilterResponse"] | None = None
+
+    def as_request_resource(self) -> LocationFilterRequest:
+        return LocationFilterRequest.model_validate(self.dump(), extra="ignore")

cognite_toolkit/_cdf_tk/client/{data_classes → resource_classes}/raw.py

@@ -2,7 +2,7 @@ import sys
 
 from pydantic import Field
 
-from cognite_toolkit._cdf_tk.client.data_classes.base import (
+from cognite_toolkit._cdf_tk.client.resource_classes.base import (
     Identifier,
     RequestResource,
     ResponseResource,

cognite_toolkit/_cdf_tk/client/resource_classes/relationship.py

@@ -0,0 +1,43 @@
+from typing import Literal
+
+from cognite_toolkit._cdf_tk.client.resource_classes.base import BaseModelObject, RequestResource, ResponseResource
+
+from .identifiers import ExternalId
+
+
+class LabelRef(BaseModelObject):
+    """Reference to a label."""
+
+    external_id: str
+
+
+class Relationship(BaseModelObject):
+    """Base class for relationship with common fields."""
+
+    external_id: str
+    source_external_id: str
+    source_type: Literal["asset", "timeSeries", "file", "event", "sequence"]
+    target_external_id: str
+    target_type: Literal["asset", "timeSeries", "file", "event", "sequence"]
+    start_time: int | None = None
+    end_time: int | None = None
+    confidence: float | None = None
+    data_set_id: int | None = None
+    labels: list[LabelRef] | None = None
+
+
+class RelationshipRequest(Relationship, RequestResource):
+    """Request resource for creating/updating relationships."""
+
+    def as_id(self) -> ExternalId:
+        return ExternalId(external_id=self.external_id)
+
+
+class RelationshipResponse(Relationship, ResponseResource[RelationshipRequest]):
+    """Response resource for relationships."""
+
+    created_time: int
+    last_updated_time: int
+
+    def as_request_resource(self) -> RelationshipRequest:
+        return RelationshipRequest.model_validate(self.dump(), extra="ignore")

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

@@ -0,0 +1,37 @@
+from ._capability import RobotCapability, RobotCapabilityRequest, RobotCapabilityResponse
+from ._common import MapType, Point3D, Quaternion, RobotType, Transform
+from ._data_post_processing import (
+    RobotDataPostProcessing,
+    RobotDataPostProcessingRequest,
+    RobotDataPostProcessingResponse,
+)
+from ._frame import RobotFrame, RobotFrameRequest, RobotFrameResponse
+from ._location import RobotLocation, RobotLocationRequest, RobotLocationResponse
+from ._map import RobotMap, RobotMapRequest, RobotMapResponse
+from ._robot import Robot, RobotRequest, RobotResponse
+
+__all__ = [
+    "MapType",
+    "Point3D",
+    "Quaternion",
+    "Robot",
+    "RobotCapability",
+    "RobotCapabilityRequest",
+    "RobotCapabilityResponse",
+    "RobotDataPostProcessing",
+    "RobotDataPostProcessingRequest",
+    "RobotDataPostProcessingResponse",
+    "RobotFrame",
+    "RobotFrameRequest",
+    "RobotFrameResponse",
+    "RobotLocation",
+    "RobotLocationRequest",
+    "RobotLocationResponse",
+    "RobotMap",
+    "RobotMapRequest",
+    "RobotMapResponse",
+    "RobotRequest",
+    "RobotResponse",
+    "RobotType",
+    "Transform",
+]

cognite_toolkit/_cdf_tk/client/resource_classes/robotics/_capability.py

@@ -0,0 +1,53 @@
+from typing import ClassVar
+
+from pydantic import JsonValue
+
+from cognite_toolkit._cdf_tk.client.resource_classes.base import (
+    BaseModelObject,
+    RequestUpdateable,
+    ResponseResource,
+)
+from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import ExternalId
+
+
+class RobotCapability(BaseModelObject):
+    """Robot capabilities define what actions that robots can execute, including data capture (PTZ, PTZ-IR, 360)
+    and behaviors (e.g., docking).
+
+    Args:
+        name: RobotCapability name.
+        external_id: RobotCapability external id. Must be unique for the resource type.
+        method: RobotCapability method. The method is used to call the right functionality on the robot.
+        input_schema: Schema that defines what inputs are needed for the action.
+            The input are values that configure the action, e.g pan, tilt and zoom values.
+        data_handling_schema: Schema that defines how the data from a RobotCapability should be handled,
+            including upload instructions.
+        description: Description of RobotCapability. Textual description of the RobotCapability.
+    """
+
+    external_id: str
+    name: str
+    method: str
+    description: str | None = None
+
+    def as_id(self) -> ExternalId:
+        return ExternalId(external_id=self.external_id)
+
+
+class RobotCapabilityRequest(RobotCapability, RequestUpdateable):
+    """Request resource for creating or updating a RobotCapability."""
+
+    non_nullable_fields: ClassVar[frozenset[str]] = frozenset({"input_schema", "data_handling_schema"})
+    input_schema: dict[str, JsonValue] | None = None
+    data_handling_schema: dict[str, JsonValue] | None = None
+
+
+class RobotCapabilityResponse(RobotCapability, ResponseResource[RobotCapabilityRequest]):
+    """Response resource for a RobotCapability."""
+
+    # The response always has input_schema and data_handling_schema
+    input_schema: dict[str, JsonValue]
+    data_handling_schema: dict[str, JsonValue]
+
+    def as_request_resource(self) -> RobotCapabilityRequest:
+        return RobotCapabilityRequest.model_validate(self.dump(), extra="ignore")

cognite_toolkit/_cdf_tk/client/resource_classes/robotics/_common.py

@@ -0,0 +1,34 @@
+from typing import Literal
+
+from cognite_toolkit._cdf_tk.client.resource_classes.base import BaseModelObject
+
+RobotType = Literal["SPOT", "ANYMAL", "DJI_DRONE", "TAUROB", "UNKNOWN"]
+MapType = Literal["WAYPOINTMAP", "THREEDMODEL", "TWODMAP", "POINTCLOUD"]
+
+
+class Point3D(BaseModelObject):
+    """A point in 3D space."""
+
+    x: float
+    y: float
+    z: float
+
+
+class Quaternion(Point3D):
+    """A quaternion representing orientation."""
+
+    w: float
+
+
+class Transform(BaseModelObject):
+    """Transform of the parent frame to the current frame.
+
+    Args:
+        parent_frame_external_id: The external id of the parent frame.
+        translation: Transform translation (Point3D).
+        orientation: Transform orientation as quaternion (Quaternion).
+    """
+
+    parent_frame_external_id: str
+    translation: Point3D
+    orientation: Quaternion

cognite_toolkit/_cdf_tk/client/resource_classes/robotics/_data_post_processing.py

@@ -0,0 +1,49 @@
+from typing import ClassVar
+
+from pydantic import JsonValue
+
+from cognite_toolkit._cdf_tk.client.resource_classes.base import (
+    BaseModelObject,
+    RequestUpdateable,
+    ResponseResource,
+)
+from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import ExternalId
+
+
+class RobotDataPostProcessing(BaseModelObject):
+    """DataPostprocessing define types of data processing on data captured by the robot.
+    DataPostprocessing enables you to automatically process data captured by the robot.
+
+    Args:
+        name: DataPostProcessing name.
+        external_id: DataPostProcessing external id. Must be unique for the resource type.
+        method: DataPostProcessing method. The method is used to call the right functionality on the robot.
+        input_schema: Schema that defines what inputs are needed for the data postprocessing.
+            The input are values that configure the data postprocessing, e.g max and min values for a gauge.
+        description: Description of DataPostProcessing. Textual description of the DataPostProcessing.
+    """
+
+    external_id: str
+    name: str
+    method: str
+    description: str | None = None
+
+    def as_id(self) -> ExternalId:
+        return ExternalId(external_id=self.external_id)
+
+
+class RobotDataPostProcessingRequest(RobotDataPostProcessing, RequestUpdateable):
+    """Request resource for creating or updating a DataPostProcessing."""
+
+    non_nullable_fields: ClassVar[frozenset[str]] = frozenset({"input_schema"})
+    input_schema: dict[str, JsonValue] | None = None
+
+
+class RobotDataPostProcessingResponse(RobotDataPostProcessing, ResponseResource[RobotDataPostProcessingRequest]):
+    """Response resource for a DataPostProcessing."""
+
+    # The response always has input_schema
+    input_schema: dict[str, JsonValue]
+
+    def as_request_resource(self) -> RobotDataPostProcessingRequest:
+        return RobotDataPostProcessingRequest.model_validate(self.dump(), extra="ignore")