cognite-toolkit 0.5.44__py3-none-any.whl → 0.7.34__py3-none-any.whl

cognite_toolkit/_cdf_tk/resource_classes/instance.py

@@ -0,0 +1,93 @@
+from pydantic import Field, JsonValue
+
+from cognite_toolkit._cdf_tk.constants import INSTANCE_EXTERNAL_ID_PATTERN, SPACE_FORMAT_PATTERN
+
+from .base import BaseModelResource, ToolkitResource
+from .container_field_definitions import ContainerReference
+from .view_field_definitions import ViewReference
+
+
+class NodeType(BaseModelResource):
+    space: str = Field(
+        description="The space where the instance is located.",
+        min_length=1,
+        max_length=43,
+        pattern=SPACE_FORMAT_PATTERN,
+    )
+    external_id: str = Field(
+        description="External-id of the instance.",
+        min_length=1,
+        max_length=256,
+        pattern=INSTANCE_EXTERNAL_ID_PATTERN,
+    )
+
+
+class InstanceSource(BaseModelResource):
+    source: ViewReference | ContainerReference = Field(
+        description="Reference to the view or container from where this source is inherited.",
+    )
+    properties: dict[str, JsonValue] | None = Field(
+        default=None,
+        description="Properties included in the source.",
+    )
+
+
+class NodeYAML(ToolkitResource):
+    space: str = Field(
+        description="The space where the node is located.",
+        min_length=1,
+        max_length=43,
+        pattern=SPACE_FORMAT_PATTERN,
+    )
+    external_id: str = Field(
+        description="External-id of the node.",
+        min_length=1,
+        max_length=256,
+        pattern=INSTANCE_EXTERNAL_ID_PATTERN,
+    )
+    type: NodeType | None = Field(
+        default=None,
+        description="The type of the node, defined by a direct relation to another node.",
+    )
+    sources: list[InstanceSource] | None = Field(
+        default=None,
+        description="List of sources (views) and their properties for this node.",
+    )
+    existing_version: int | None = Field(
+        default=None,
+        description="Fail the ingestion request if the node version is greater than this value.",
+        ge=0,
+    )
+
+
+class EdgeYAML(ToolkitResource):
+    space: str = Field(
+        description="Id of the space that the edge belongs to.",
+        min_length=1,
+        max_length=43,
+        pattern=SPACE_FORMAT_PATTERN,
+    )
+    external_id: str = Field(
+        description="External-id of the edge.",
+        min_length=1,
+        max_length=256,
+        pattern=INSTANCE_EXTERNAL_ID_PATTERN,
+    )
+    type: NodeType = Field(
+        description="The type of the edge, defined by a direct relation to another edge.",
+    )
+    sources: list[InstanceSource] | None = Field(
+        default=None,
+        description="List of sources (views) and their properties for this edge.",
+    )
+    existing_version: int | None = Field(
+        default=None,
+        description="Version of the edge.",
+        ge=0,
+    )
+    start_node: NodeType = Field(
+        description="Reference to the node at the start of the edge.",
+    )
+    end_node: NodeType = Field(
+        description="Reference to the node at the end of the edge.",
+    )

cognite_toolkit/_cdf_tk/resource_classes/location.py

@@ -26,7 +26,7 @@ class LocationFilterViewId(BaseModelResource):
 
 
 class AssetCentricFields(BaseModelResource):
-    data_set_external_id: list[str] | None = Field(default=None, description="The list of data set external IDs")
+    data_set_external_ids: list[str] | None = Field(default=None, description="The list of data set external IDs")
     asset_subtree_external_ids: list[dict[Literal["externalId"], str]] | None = Field(
         default=None, description="External IDs of the asset."
     )

cognite_toolkit/_cdf_tk/resource_classes/migration.py

@@ -0,0 +1,28 @@
+from typing import Literal
+
+from pydantic import Field
+
+from cognite_toolkit._cdf_tk.constants import INSTANCE_EXTERNAL_ID_PATTERN
+
+from .base import ToolkitResource
+from .view_field_definitions import ViewReference
+
+
+class ResourceViewMappingYAML(ToolkitResource):
+    external_id: str = Field(
+        description="External-id of the mapping.",
+        min_length=1,
+        max_length=256,
+        pattern=INSTANCE_EXTERNAL_ID_PATTERN,
+    )
+    resource_type: Literal["asset", "event", "file", "timeSeries", "sequence", "assetAnnotation", "fileAnnotation"] = (
+        Field(
+            description="The type of the resource to map to the view.",
+        )
+    )
+    view_id: ViewReference = Field(
+        description="The view to map the resource to.",
+    )
+    property_mapping: dict[str, str] = Field(
+        description="A dictionary mapping from resource property to view property.",
+    )

cognite_toolkit/_cdf_tk/resource_classes/raw_database_table.py

@@ -4,10 +4,14 @@ from .base import ToolkitResource
 
 
 class DatabaseYAML(ToolkitResource):
-    db_name: str | list[str] = Field(description="The name or list of names of the database.")
+    db_name: str = Field(
+        description="The name of the database.",
+        min_length=1,
+        max_length=32,
+    )
 
 
-class TableYAML(ToolkitResource):
+class TableYAML(ToolkitResource, populate_by_name=True):
     db_name: str = Field(
         description="The name of the database.",
         min_length=1,

cognite_toolkit/_cdf_tk/resource_classes/relationship.py

@@ -0,0 +1,50 @@
+from typing import Literal
+
+from pydantic import Field
+
+from .base import BaseModelResource, ToolkitResource
+
+
+class LabelRefYAML(BaseModelResource):
+    externalId: str = Field(
+        description="The external ID of the label.",
+        max_length=255,
+    )
+
+
+class RelationshipYAML(ToolkitResource):
+    external_id: str = Field(
+        description="The external ID provided by the client.",
+        max_length=255,
+    )
+    source_external_id: str = Field(
+        description="The external ID of the resource that is the relationship source.",
+    )
+    source_type: Literal["asset", "timeSeries", "file", "event", "sequence"] = Field(
+        description="The resource type of the relationship source. Must be one of the specified values."
+    )
+    target_external_id: str = Field(
+        description="The external ID of the resource that is the relationship target.",
+    )
+    target_type: Literal["asset", "timeSeries", "file", "event", "sequence"] = Field(
+        description="The resource type of the relationship target. Must be one of the specified values."
+    )
+    start_time: int | None = Field(
+        None,
+        description="The time, in milliseconds since Jan. 1, 1970, when the relationship became active. If there is no startTime, the relationship is active from the beginning of time until endTime.",
+        ge=0,
+    )
+    end_time: int | None = Field(
+        None,
+        description="The time, in milliseconds since Jan. 1, 1970, when the relationship became inactive. If there is no endTime, the relationship is active until the end of time.",
+        ge=0,
+    )
+    confidence: float | None = Field(
+        None, description="A number between 0 and 1 that indicates the confidence in the relationship.", ge=0, le=1
+    )
+    data_set_external_id: str | None = Field(
+        None, description="The external ID of the data set that the relationship belongs to.", max_length=255
+    )
+    labels: list[LabelRefYAML] | None = Field(
+        None, description="A list of labels that the relationship belongs to.", max_length=10
+    )

cognite_toolkit/_cdf_tk/resource_classes/robotics/__init__.py

@@ -0,0 +1,13 @@
+from .capability import RobotCapabilityYAML
+from .data_postprocessing import RobotDataPostProcessingYAML
+from .frame import RobotFrameYAML
+from .location import RobotLocationYAML
+from .map import RobotMapYAML
+
+__all__ = [
+    "RobotCapabilityYAML",
+    "RobotDataPostProcessingYAML",
+    "RobotFrameYAML",
+    "RobotLocationYAML",
+    "RobotMapYAML",
+]

cognite_toolkit/_cdf_tk/resource_classes/robotics/capability.py

@@ -0,0 +1,19 @@
+from pydantic import Field, JsonValue
+
+from cognite_toolkit._cdf_tk.resource_classes.base import ToolkitResource
+
+
+class RobotCapabilityYAML(ToolkitResource):
+    name: str = Field(description="Robot capability name.")
+    external_id: str = Field(description="RobotCapability external id.", max_length=256)
+    method: str = Field(description="RobotCapability method, used to call the right functionality on the robot.")
+    input_schema: dict[str, JsonValue] | None = Field(
+        default=None, description="Schema that defines what inputs are needed for configuring the action."
+    )
+    data_handling_schema: dict[str, JsonValue] | None = Field(
+        default=None, description="Schema that defines how the data from a RobotCapability should be handled."
+    )
+    description: str | None = Field(
+        default=None,
+        description="Textual description of the RobotCapability.",
+    )

cognite_toolkit/_cdf_tk/resource_classes/robotics/data_postprocessing.py

@@ -0,0 +1,15 @@
+from pydantic import Field, JsonValue
+
+from cognite_toolkit._cdf_tk.resource_classes.base import ToolkitResource
+
+
+class RobotDataPostProcessingYAML(ToolkitResource):
+    name: str = Field(description="DataProcessing name.")
+    external_id: str = Field(
+        description="DataProcessing external id. Must be unique for the resource type.",
+    )
+    method: str = Field(description="DataProcessing method, to call the right functionality on the robot.")
+    input_schema: dict[str, JsonValue] | None = Field(
+        default=None, description="Schema that defines what inputs are needed for the data postprocessing."
+    )
+    description: str | None = Field(default=None, description="Textual description of the DataProcessing.")

cognite_toolkit/_cdf_tk/resource_classes/robotics/frame.py

@@ -0,0 +1,25 @@
+from pydantic import Field
+
+from cognite_toolkit._cdf_tk.resource_classes.base import BaseModelResource, ToolkitResource
+
+
+class Translation(BaseModelResource):
+    x: float = Field(description="X coordinate")
+    y: float = Field(description="Y coordinate")
+    z: float = Field(description="Z coordinate")
+
+
+class Orientation(Translation):
+    w: float = Field(description="W coordinate")
+
+
+class Transform(BaseModelResource):
+    parent_frame_external_id: str = Field(description="Parent frame external id.")
+    translation: Translation = Field(description="Translation")
+    orientation: Orientation = Field(description="Orientation")
+
+
+class RobotFrameYAML(ToolkitResource):
+    name: str = Field(description="Robot frame name.")
+    external_id: str = Field(description="RobotFrame external id.", max_length=256)
+    transform: Transform | None = Field(default=None, description="Transform")

cognite_toolkit/_cdf_tk/resource_classes/robotics/location.py

@@ -0,0 +1,12 @@
+from pydantic import Field
+
+from cognite_toolkit._cdf_tk.resource_classes.base import ToolkitResource
+
+
+class RobotLocationYAML(ToolkitResource):
+    name: str = Field(description="Location name.")
+    external_id: str = Field(description="Location external id. Must be unique for the resource type.", max_length=256)
+    description: str | None = Field(
+        default=None,
+        description="Description of Location. Textual description of the Location.",
+    )

cognite_toolkit/_cdf_tk/resource_classes/robotics/map.py

@@ -0,0 +1,16 @@
+from typing import Literal
+
+from pydantic import Field, JsonValue
+
+from cognite_toolkit._cdf_tk.resource_classes.base import ToolkitResource
+
+
+class RobotMapYAML(ToolkitResource):
+    name: str = Field(description="Map name.")
+    external_id: str = Field(description="Map external id.", max_length=256)
+    map_type: Literal["WAYPOINTMAP", "THREEDMODEL", "TWODMAP", "POINTCLOUD"] = Field(description="Map type.")
+    description: str | None = Field(default=None, description="Description of Map. Textual description of the Map.")
+    frame_external_id: str | None = Field(default=None, description="External id of the map's reference frame.")
+    data: dict[str, JsonValue] | None = Field(default=None, description="Map-specific data.")
+    location_external_id: str | None = Field(default=None, description="External id of the location.")
+    scale: float | None = Field(default=None, description="Uniform scaling factor.", ge=0.0, le=1.0)

cognite_toolkit/_cdf_tk/resource_classes/search_config.py

@@ -0,0 +1,30 @@
+from typing import ClassVar
+
+from pydantic import Field
+
+from cognite_toolkit._cdf_tk.client.data_classes.search_config import SearchConfigWrite
+
+from .base import BaseModelResource, ToolkitResource
+
+
+class ViewId(BaseModelResource):
+    space: str
+    external_id: str
+
+
+class PropertyConfig(BaseModelResource):
+    property_name: str = Field(alias="property")
+    disabled: bool | None = None
+    selected: bool | None = None
+    hidden: bool | None = None
+
+
+class SearchConfigYAML(ToolkitResource):
+    _cdf_resource: ClassVar[type[SearchConfigWrite]] = SearchConfigWrite
+
+    view: ViewId
+    use_as_name: str | None = None
+    use_as_description: str | None = None
+    columns_layout: list[PropertyConfig] | None = None
+    filter_layout: list[PropertyConfig] | None = None
+    properties_layout: list[PropertyConfig] | None = None

cognite_toolkit/_cdf_tk/resource_classes/sequence.py

@@ -0,0 +1,107 @@
+from typing import Literal
+
+from pydantic import Field, model_validator
+
+from .base import BaseModelResource, ToolkitResource
+
+
+class SequenceColumnDTO(BaseModelResource):
+    external_id: str = Field(
+        description="The external ID of the column.",
+        max_length=255,
+    )
+    name: str | None = Field(
+        default=None,
+        description="The name of the column.",
+        max_length=255,
+    )
+    description: str | None = Field(
+        default=None,
+        description="The description of the column.",
+        max_length=1000,
+    )
+    metadata: dict[str, str] | None = Field(
+        default=None,
+        description="Custom, application-specific metadata.",
+        max_length=256,
+    )
+    value_type: Literal["STRING", "string", "DOUBLE", "double", "LONG", "long"] | None = Field(
+        default=None,
+        description="What type the datapoints in a column will have.",
+    )
+
+
+class SequenceYAML(ToolkitResource):
+    external_id: str = Field(
+        description="The external ID provided by the client.",
+        max_length=255,
+    )
+    name: str | None = Field(
+        default=None,
+        description="The name of the sequence.",
+        max_length=255,
+    )
+    description: str | None = Field(
+        default=None,
+        description="The description of the sequence.",
+        max_length=1000,
+    )
+    data_set_external_id: str | None = Field(
+        default=None,
+        description="The external ID of the data set that the sequence associated with.",
+    )
+    asset_external_id: str | None = Field(
+        default=None,
+        description="The external ID of the asset that the sequence associated with.",
+    )
+    metadata: dict[str, str] | None = Field(
+        default=None,
+        description="Custom, application-specific metadata.",
+        max_length=256,
+    )
+    columns: list[SequenceColumnDTO] = Field(
+        description="List of column definitions.",
+        min_length=1,
+        max_length=400,
+    )
+
+
+class SequenceRowDTO(BaseModelResource):
+    row_number: int = Field(
+        description="The row number of the row.",
+        ge=0,
+    )
+    values: list[str | int | float | None] = Field(
+        description="List of values in the order defined in the columns field",
+        min_length=1,
+        max_length=400,
+    )
+
+
+class SequenceRowYAML(ToolkitResource):
+    external_id: str = Field(
+        description="The external ID provided by the client.",
+        max_length=256,
+    )
+    columns: list[str] = Field(
+        description="List of column definitions.",
+        min_length=1,
+        max_length=200,
+    )
+    rows: list[SequenceRowDTO] = Field(
+        description="List of row definitions.",
+        min_length=1,
+        max_length=10000,
+    )
+
+    @model_validator(mode="after")
+    def validate_values_match_columns(self) -> "SequenceRowYAML":
+        """Validate that the number of values in each row matches the number of columns."""
+        total_columns = len(self.columns)
+        for i, row in enumerate(self.rows):
+            if len(row.values) != total_columns:
+                raise ValueError(
+                    f"Row number {row.row_number} has {len(row.values)} value(s). "
+                    f"Each row must have exactly {total_columns} value(s) which is the same as the number of column(s)."
+                )
+        return self

cognite_toolkit/_cdf_tk/resource_classes/space.py

@@ -1,9 +1,9 @@
 from pydantic import Field, field_validator
 
-from .base import ToolkitResource
+from cognite_toolkit._cdf_tk.constants import FORBIDDEN_SPACES, SPACE_FORMAT_PATTERN
+from cognite_toolkit._cdf_tk.utils.collection import humanize_collection
 
-SPACE_FORMAT_PATTERN = r"^[a-zA-Z][a-zA-Z0-9_-]{0,41}[a-zA-Z0-9]?$"
-FORBIDDEN_SPACES = {"space", "cdf", "dms", "pg3", "shared", "system", "node", "edge"}
+from .base import ToolkitResource
 
 
 class SpaceYAML(ToolkitResource):
@@ -21,5 +21,5 @@ class SpaceYAML(ToolkitResource):
     def check_forbidden_space_value(cls, val: str) -> str:
         """Check the space name not present in forbidden set"""
         if val in FORBIDDEN_SPACES:
-            raise ValueError(f"'{val}' is a reserved space. Reserved Spaces: {', '.join(FORBIDDEN_SPACES)}")
+            raise ValueError(f"'{val}' is a reserved space. Reserved Spaces: {humanize_collection(FORBIDDEN_SPACES)}")
         return val

cognite_toolkit/_cdf_tk/resource_classes/streamlit_.py

@@ -0,0 +1,26 @@
+from typing import Literal
+
+from pydantic import Field
+
+from .base import ToolkitResource
+
+
+class StreamlitYAML(ToolkitResource):
+    external_id: str = Field(
+        max_length=255,
+        description="The external ID of the Streamlit app.",
+    )
+    name: str = Field(
+        description="The name of the Streamlit app.",
+        min_length=1,
+        max_length=255,
+    )
+    creator: str = Field(description="The creator of the Streamlit app.")
+    entrypoint: str | None = Field(None, description="Path to the entrypoint file of the Streamlit app.")
+    description: str | None = Field(None, description="The description of the Streamlit app.")
+    published: bool = Field(False, description="Whether the Streamlit app is published or not.")
+    theme: Literal["Light", "Dark"] = Field("Light", description="The theme of the Streamlit app.")
+    thumbnail: str | None = Field(None, description="URL to the thumbnail image of the Streamlit app.")
+    data_set_external_id: str | None = Field(
+        None, description="The external ID of the data set to associate with the app."
+    )

cognite_toolkit/_cdf_tk/resource_classes/streams.py

@@ -0,0 +1,29 @@
+from typing import Literal
+
+from pydantic import Field
+
+from cognite_toolkit._cdf_tk.constants import StreamTemplateName
+
+from .base import BaseModelResource, ToolkitResource
+
+
+class StreamSettings(BaseModelResource):
+    """Stream settings resource class."""
+
+    template: dict[Literal["name"], StreamTemplateName] = Field(
+        description="Reference to a template which should be used to define initial settings for the stream."
+    )
+
+
+class StreamYAML(ToolkitResource):
+    """Stream YAML resource class."""
+
+    external_id: str = Field(
+        description="The external ID of the stream.",
+        min_length=1,
+        max_length=100,
+        pattern="^[a-z]([a-z0-9_-]{0,98}[a-z0-9])?$",
+    )
+    settings: StreamSettings = Field(
+        description="Stream settings which should be applied to a stream.",
+    )

cognite_toolkit/_cdf_tk/resource_classes/transformation_destination.py

@@ -143,7 +143,7 @@ class DataModelSource(Destination):
     _destination_type = "instances"
     type: Literal["instances"] = "instances"
     data_model: DataModelInfo = Field(description="Target data model info.")
-    instance_space: str = Field(description="The space where the instances will be created.")
+    instance_space: str | None = Field(None, description="The space where the instances will be created.")
 
 
 class ViewDataSource(Destination):

cognite_toolkit/_cdf_tk/resource_classes/transformation_notification.py

@@ -0,0 +1,8 @@
+from pydantic import Field
+
+from .base import ToolkitResource
+
+
+class TransformationNotificationYAML(ToolkitResource):
+    destination: str = Field(description="Email address where notifications should be sent.")
+    transformation_external_id: str = Field(description="Transformation external ID to subscribe.")

cognite_toolkit/_cdf_tk/resource_classes/transformations.py

@@ -4,22 +4,11 @@ from cognite.client.data_classes import TransformationWrite
 from pydantic import Field, field_validator, model_serializer
 from pydantic_core.core_schema import SerializationInfo, SerializerFunctionWrapHandler
 
-from .base import BaseModelResource, ToolkitResource
+from .authentication import AuthenticationClientIdSecret, OIDCCredential
+from .base import ToolkitResource
 from .transformation_destination import Destination
 
 
-class AuthenticationClientIdSecret(BaseModelResource):
-    client_id: str = Field(description="Client Id.")
-    client_secret: str = Field(description="Client Secret.")
-
-
-class OIDCCredential(AuthenticationClientIdSecret):
-    scopes: str | list[str] | None = Field(default=None, description="Scopes for the authentication.")
-    token_uri: str = Field(description="OAuth token url.")
-    cdf_project_name: str = Field(description="CDF project name.")
-    audience: str | None = Field(default=None, description="Audience for the authentication.")
-
-
 class TransformationYAML(ToolkitResource):
     _cdf_resource = TransformationWrite
     external_id: str = Field(description="The external ID provided by the client.")