cognite-toolkit 0.7.41__tar.gz → 0.7.43__tar.gz

{cognite_toolkit-0.7.41 → cognite_toolkit-0.7.43}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite_toolkit
-Version: 0.7.41
+Version: 0.7.43
 Summary: Official Cognite Data Fusion tool for project templates and configuration deployment
 Author: Cognite AS
 Author-email: Cognite AS <support@cognite.com>

{cognite_toolkit-0.7.41 → cognite_toolkit-0.7.43}/cognite_toolkit/_cdf_tk/client/_toolkit_client.py

@@ -36,7 +36,7 @@ class ToolAPI:
         self.http_client = http_client
         self.three_d = ThreeDAPI(http_client, console)
         self.assets = AssetsAPI(http_client)
-        self.time_series = TimeSeriesAPI(http_client)
+        self.timeseries = TimeSeriesAPI(http_client)
         self.events = EventsAPI(http_client)
 
 

{cognite_toolkit-0.7.41 → cognite_toolkit-0.7.43}/cognite_toolkit/_cdf_tk/client/api/events.py

@@ -1,5 +1,5 @@
 from collections.abc import Sequence
-from typing import Literal
+from typing import Any, Literal
 
 from cognite_toolkit._cdf_tk.client.cdf_client import CDFResourceAPI, PagedResponse, ResponseItems
 from cognite_toolkit._cdf_tk.client.cdf_client.api import Endpoint
@@ -75,15 +75,33 @@ class EventsAPI(CDFResourceAPI[InternalOrExternalId, EventRequest, EventResponse
 
     def iterate(
         self,
+        data_set_external_ids: list[str] | None = None,
+        asset_subtree_external_ids: list[str] | None = None,
         limit: int = 100,
         cursor: str | None = None,
     ) -> PagedResponse[EventResponse]:
         """Iterate over all events in CDF.
 
+        Args:
+            data_set_external_ids: Filter by data set external IDs.
+            asset_subtree_external_ids: Filter by asset subtree external IDs.
+            limit: Maximum number of items to return.
+            cursor: Cursor for pagination.
+
         Returns:
             PagedResponse of EventResponse objects.
         """
-        return self._iterate(cursor=cursor, limit=limit)
+        filter_: dict[str, Any] = {}
+        if asset_subtree_external_ids:
+            filter_["assetSubtreeIds"] = [{"externalId": ext_id} for ext_id in asset_subtree_external_ids]
+        if data_set_external_ids:
+            filter_["dataSetIds"] = [{"externalId": ds_id} for ds_id in data_set_external_ids]
+
+        return self._iterate(
+            cursor=cursor,
+            limit=limit,
+            body={"filter": filter_ or None},
+        )
 
     def list(
         self,

{cognite_toolkit-0.7.41 → cognite_toolkit-0.7.43}/cognite_toolkit/_cdf_tk/client/api/timeseries.py

@@ -1,5 +1,5 @@
 from collections.abc import Sequence
-from typing import Literal
+from typing import Any, Literal
 
 from cognite_toolkit._cdf_tk.client.cdf_client import CDFResourceAPI, PagedResponse, ResponseItems
 from cognite_toolkit._cdf_tk.client.cdf_client.api import Endpoint
@@ -83,15 +83,33 @@ class TimeSeriesAPI(CDFResourceAPI[InternalOrExternalId, TimeSeriesRequest, Time
 
     def iterate(
         self,
+        data_set_external_ids: list[str] | None = None,
+        asset_subtree_external_ids: list[str] | None = None,
         limit: int = 100,
         cursor: str | None = None,
     ) -> PagedResponse[TimeSeriesResponse]:
         """Iterate over all time series in CDF.
 
+        Args:
+            data_set_external_ids: Filter by data set external IDs.
+            asset_subtree_external_ids: Filter by asset subtree external IDs.
+            limit: Maximum number of items to return.
+            cursor: Cursor for pagination.
+
         Returns:
             PagedResponse of TimeSeriesResponse objects.
         """
-        return self._iterate(cursor=cursor, limit=limit)
+        filter_: dict[str, Any] = {}
+        if asset_subtree_external_ids:
+            filter_["assetSubtreeIds"] = [{"externalId": ext_id} for ext_id in asset_subtree_external_ids]
+        if data_set_external_ids:
+            filter_["dataSetIds"] = [{"externalId": ds_id} for ds_id in data_set_external_ids]
+
+        return self._iterate(
+            cursor=cursor,
+            limit=limit,
+            body={"filter": filter_ or None},
+        )
 
     def list(
         self,

{cognite_toolkit-0.7.41 → cognite_toolkit-0.7.43}/cognite_toolkit/_cdf_tk/client/data_classes/agent.py

@@ -98,29 +98,26 @@ AgentTool = Annotated[
 ]
 
 
-class AgentRequest(RequestResource):
+class Agent(BaseModelObject):
     external_id: str
     name: str
     description: str | None = None
     instructions: str | None = None
     model: str = "azure/gpt-4o-mini"
     tools: list[AgentTool] | None = None
-    runtime_version: str | None = None
 
     def as_id(self) -> ExternalId:
         return ExternalId(external_id=self.external_id)
 
 
-class AgentResponse(ResponseResource[AgentRequest]):
+class AgentRequest(Agent, RequestResource):
+    runtime_version: str | None = None
+
+
+class AgentResponse(Agent, ResponseResource[AgentRequest]):
     created_time: int
     last_updated_time: int
     owner_id: str
-    external_id: str
-    name: str
-    description: str | None = None
-    instructions: str | None = None
-    model: str = "azure/gpt-4o-mini"
-    tools: list[AgentTool] | None = None
     runtime_version: str
 
     def as_request_resource(self) -> AgentRequest:

{cognite_toolkit-0.7.41 → cognite_toolkit-0.7.43}/cognite_toolkit/_cdf_tk/client/data_classes/asset.py

@@ -7,9 +7,7 @@ from cognite_toolkit._cdf_tk.client.data_classes.base import BaseModelObject, Re
 from .identifiers import ExternalId
 
 
-class AssetRequest(RequestUpdateable):
-    container_fields: ClassVar[frozenset[str]] = frozenset({"metadata", "labels"})
-    non_nullable_fields: ClassVar[frozenset[str]] = frozenset({"parent_id", "parent_external_id"})
+class Asset(BaseModelObject):
     external_id: str | None = None
     name: str
     parent_id: int | None = None
@@ -27,28 +25,23 @@ class AssetRequest(RequestUpdateable):
         return ExternalId(external_id=self.external_id)
 
 
+class AssetRequest(Asset, RequestUpdateable):
+    container_fields: ClassVar[frozenset[str]] = frozenset({"metadata", "labels"})
+    non_nullable_fields: ClassVar[frozenset[str]] = frozenset({"parent_id", "parent_external_id"})
+
+
 class AssetAggregateItem(BaseModelObject):
     child_count: int
     depth: int
     path: list[dict[Literal["id"], int]]
 
 
-class AssetResponse(ResponseResource[AssetRequest]):
+class AssetResponse(Asset, ResponseResource[AssetRequest]):
     created_time: int
     last_updated_time: int
     root_id: int
     aggregates: AssetAggregateItem | None = None
     id: int
-    external_id: str | None = None
-    name: str
-    parent_id: int | None = None
-    parent_external_id: str | None = None
-    description: str | None = None
-    metadata: dict[str, str] | None = None
-    data_set_id: int | None = None
-    source: str | None = None
-    labels: list[dict[Literal["externalId"], str]] | None = None
-    geo_location: dict[str, JsonValue] | None = None
 
     def as_request_resource(self) -> AssetRequest:
         return AssetRequest.model_validate(self.dump(), extra="ignore")

{cognite_toolkit-0.7.41 → cognite_toolkit-0.7.43}/cognite_toolkit/_cdf_tk/client/data_classes/base.py

@@ -18,7 +18,7 @@ class BaseModelObject(BaseModel):
     """Base class for all object. This includes resources and nested objects."""
 
     # We allow extra fields to support forward compatibility.
-    model_config = ConfigDict(alias_generator=to_camel, extra="allow")
+    model_config = ConfigDict(alias_generator=to_camel, extra="allow", populate_by_name=True)
 
     def dump(self, camel_case: bool = True) -> dict[str, Any]:
         """Dump the resource to a dictionary.
@@ -30,7 +30,7 @@ class BaseModelObject(BaseModel):
     @classmethod
     def _load(cls, resource: dict[str, Any]) -> Self:
         """Load method to match CogniteResource signature."""
-        return cls.model_validate(resource)
+        return cls.model_validate(resource, by_alias=True)
 
 
 class Identifier(BaseModelObject):

cognite_toolkit-0.7.43/cognite_toolkit/_cdf_tk/client/data_classes/data_modeling/__init__.py

@@ -0,0 +1,148 @@
+from ._constraints import (
+    Constraint,
+    ConstraintAdapter,
+    ConstraintDefinition,
+    RequiresConstraintDefinition,
+    UniquenessConstraintDefinition,
+)
+from ._container import (
+    Container,
+    ContainerPropertyDefinition,
+    ContainerRequest,
+    ContainerResponse,
+)
+from ._data_model import DataModelRequest, DataModelResponse
+from ._data_types import (
+    BooleanProperty,
+    DataType,
+    DataTypeAdapter,
+    DateProperty,
+    DirectNodeRelation,
+    EnumProperty,
+    EnumValue,
+    FileCDFExternalIdReference,
+    Float32Property,
+    Float64Property,
+    FloatProperty,
+    Int32Property,
+    Int64Property,
+    JSONProperty,
+    ListablePropertyTypeDefinition,
+    PropertyTypeDefinition,
+    SequenceCDFExternalIdReference,
+    TextProperty,
+    TimeseriesCDFExternalIdReference,
+    TimestampProperty,
+    Unit,
+)
+from ._indexes import (
+    BtreeIndex,
+    Index,
+    IndexAdapter,
+    IndexDefinition,
+    InvertedIndex,
+)
+from ._references import (
+    ContainerConstraintReference,
+    ContainerDirectReference,
+    ContainerIndexReference,
+    ContainerReference,
+    DataModelReference,
+    NodeReference,
+    SpaceReference,
+    ViewDirectReference,
+    ViewReference,
+)
+from ._space import Space, SpaceRequest, SpaceResponse
+from ._view import View, ViewRequest, ViewResponse
+from ._view_property import (
+    ConnectionPropertyDefinition,
+    ConstraintOrIndexState,
+    EdgeProperty,
+    MultiEdgeProperty,
+    MultiReverseDirectRelationPropertyRequest,
+    MultiReverseDirectRelationPropertyResponse,
+    ReverseDirectRelationProperty,
+    SingleEdgeProperty,
+    SingleReverseDirectRelationPropertyRequest,
+    SingleReverseDirectRelationPropertyResponse,
+    ViewCoreProperty,
+    ViewCorePropertyRequest,
+    ViewCorePropertyResponse,
+    ViewPropertyDefinition,
+    ViewRequestProperty,
+    ViewRequestPropertyAdapter,
+    ViewResponseProperty,
+)
+
+__all__ = [
+    "BooleanProperty",
+    "BtreeIndex",
+    "ConnectionPropertyDefinition",
+    "Constraint",
+    "ConstraintAdapter",
+    "ConstraintDefinition",
+    "ConstraintOrIndexState",
+    "Container",
+    "ContainerConstraintReference",
+    "ContainerDirectReference",
+    "ContainerIndexReference",
+    "ContainerPropertyDefinition",
+    "ContainerReference",
+    "ContainerRequest",
+    "ContainerResponse",
+    "DataModelReference",
+    "DataModelRequest",
+    "DataModelResponse",
+    "DataType",
+    "DataTypeAdapter",
+    "DateProperty",
+    "DirectNodeRelation",
+    "EdgeProperty",
+    "EnumProperty",
+    "EnumValue",
+    "FileCDFExternalIdReference",
+    "Float32Property",
+    "Float64Property",
+    "FloatProperty",
+    "Index",
+    "IndexAdapter",
+    "IndexDefinition",
+    "Int32Property",
+    "Int64Property",
+    "InvertedIndex",
+    "JSONProperty",
+    "ListablePropertyTypeDefinition",
+    "MultiEdgeProperty",
+    "MultiReverseDirectRelationPropertyRequest",
+    "MultiReverseDirectRelationPropertyResponse",
+    "NodeReference",
+    "PropertyTypeDefinition",
+    "RequiresConstraintDefinition",
+    "ReverseDirectRelationProperty",
+    "SequenceCDFExternalIdReference",
+    "SingleEdgeProperty",
+    "SingleReverseDirectRelationPropertyRequest",
+    "SingleReverseDirectRelationPropertyResponse",
+    "Space",
+    "SpaceReference",
+    "SpaceRequest",
+    "SpaceResponse",
+    "TextProperty",
+    "TimeseriesCDFExternalIdReference",
+    "TimestampProperty",
+    "UniquenessConstraintDefinition",
+    "Unit",
+    "View",
+    "ViewCoreProperty",
+    "ViewCorePropertyRequest",
+    "ViewCorePropertyResponse",
+    "ViewDirectReference",
+    "ViewPropertyDefinition",
+    "ViewReference",
+    "ViewRequest",
+    "ViewRequestProperty",
+    "ViewRequestPropertyAdapter",
+    "ViewResponse",
+    "ViewResponseProperty",
+]

cognite_toolkit-0.7.43/cognite_toolkit/_cdf_tk/client/data_classes/data_modeling/_constraints.py

@@ -0,0 +1,37 @@
+from abc import ABC
+from typing import Annotated, Any, Literal
+
+from pydantic import Field, TypeAdapter, field_serializer
+from pydantic_core.core_schema import FieldSerializationInfo
+
+from cognite_toolkit._cdf_tk.client.data_classes.base import BaseModelObject
+
+from ._references import ContainerReference
+
+
+class ConstraintDefinition(BaseModelObject, ABC):
+    constraint_type: str
+
+
+class UniquenessConstraintDefinition(ConstraintDefinition):
+    constraint_type: Literal["uniqueness"] = "uniqueness"
+    properties: list[str]
+    by_space: bool | None = None
+
+
+class RequiresConstraintDefinition(ConstraintDefinition):
+    constraint_type: Literal["requires"] = "requires"
+    require: ContainerReference
+
+    @field_serializer("require", mode="plain")
+    @classmethod
+    def serialize_require(cls, require: ContainerReference, info: FieldSerializationInfo) -> dict[str, Any]:
+        return {**require.model_dump(**vars(info)), "type": "container"}
+
+
+Constraint = Annotated[
+    UniquenessConstraintDefinition | RequiresConstraintDefinition,
+    Field(discriminator="constraint_type"),
+]
+
+ConstraintAdapter: TypeAdapter[Constraint] = TypeAdapter(Constraint)

cognite_toolkit-0.7.43/cognite_toolkit/_cdf_tk/client/data_classes/data_modeling/_container.py

@@ -0,0 +1,50 @@
+from abc import ABC
+from typing import Literal
+
+from pydantic import JsonValue
+
+from cognite_toolkit._cdf_tk.client.data_classes.base import BaseModelObject, RequestResource, ResponseResource
+
+from ._constraints import Constraint
+from ._data_types import DataType
+from ._indexes import Index
+from ._references import ContainerReference
+
+
+class ContainerPropertyDefinition(BaseModelObject):
+    immutable: bool | None = None
+    nullable: bool | None = None
+    auto_increment: bool | None = None
+    default_value: str | int | float | bool | dict[str, JsonValue] | None = None
+    description: str | None = None
+    name: str | None = None
+    type: DataType
+
+
+class Container(BaseModelObject, ABC):
+    space: str
+    external_id: str
+    name: str | None = None
+    description: str | None = None
+    used_for: Literal["node", "edge", "all"] | None = None
+    properties: dict[str, ContainerPropertyDefinition]
+    constraints: dict[str, Constraint] | None = None
+    indexes: dict[str, Index] | None = None
+
+    def as_id(self) -> ContainerReference:
+        return ContainerReference(
+            space=self.space,
+            external_id=self.external_id,
+        )
+
+
+class ContainerRequest(Container, RequestResource): ...
+
+
+class ContainerResponse(Container, ResponseResource[ContainerRequest]):
+    created_time: int
+    last_updated_time: int
+    is_global: bool
+
+    def as_request_resource(self) -> "ContainerRequest":
+        return ContainerRequest.model_validate(self.model_dump(by_alias=True))

cognite_toolkit-0.7.43/cognite_toolkit/_cdf_tk/client/data_classes/data_modeling/_data_model.py

@@ -0,0 +1,73 @@
+from abc import ABC
+from typing import Any
+
+from pydantic import field_serializer
+from pydantic_core.core_schema import FieldSerializationInfo
+
+from cognite_toolkit._cdf_tk.client.data_classes.base import BaseModelObject, RequestResource, ResponseResource
+
+from ._references import DataModelReference, ViewReference
+from ._view import ViewResponse
+
+
+class DataModel(BaseModelObject, ABC):
+    """Cognite Data Model resource.
+
+    Data models group and structure views into reusable collections.
+    A data model contains a set of views where the node types can
+    refer to each other with direct relations and edges.
+    """
+
+    space: str
+    external_id: str
+    version: str
+    description: str | None = None
+
+    def as_id(self) -> DataModelReference:
+        return DataModelReference(
+            space=self.space,
+            external_id=self.external_id,
+            version=self.version,
+        )
+
+
+class DataModelRequest(DataModel, RequestResource):
+    views: list[ViewReference] | None = None
+
+    @field_serializer("views", mode="plain")
+    @classmethod
+    def serialize_views(
+        cls, views: list[ViewReference] | None, info: FieldSerializationInfo
+    ) -> list[dict[str, Any]] | None:
+        if views is None:
+            return None
+        return [{**view.model_dump(**vars(info)), "type": "view"} for view in views]
+
+
+class DataModelResponse(DataModel, ResponseResource[DataModelRequest]):
+    views: list[ViewReference] | None = None
+    created_time: int
+    last_updated_time: int
+    is_global: bool
+
+    def as_request_resource(self) -> DataModelRequest:
+        return DataModelRequest.model_validate(self.model_dump(by_alias=True), extra="ignore")
+
+    @field_serializer("views", mode="plain")
+    @classmethod
+    def serialize_views(
+        cls, views: list[ViewReference] | None, info: FieldSerializationInfo
+    ) -> list[dict[str, Any]] | None:
+        if views is None:
+            return None
+        return [{**view.model_dump(**vars(info)), "type": "view"} for view in views]
+
+
+class DataModelResponseWithViews(DataModel, ResponseResource[DataModelRequest]):
+    views: list[ViewResponse] | None = None
+    created_time: int
+    last_updated_time: int
+    is_global: bool
+
+    def as_request_resource(self) -> DataModelRequest:
+        return DataModelRequest.model_validate(self.model_dump(by_alias=True), extra="ignore")

cognite_toolkit-0.7.43/cognite_toolkit/_cdf_tk/client/data_classes/data_modeling/_data_types.py

@@ -0,0 +1,116 @@
+from abc import ABC
+from typing import Annotated, Literal
+
+from pydantic import Field, TypeAdapter
+
+from cognite_toolkit._cdf_tk.client.data_classes.base import BaseModelObject
+
+from ._references import ContainerReference, ViewReference
+
+
+class PropertyTypeDefinition(BaseModelObject, ABC):
+    type: str
+
+
+class ListablePropertyTypeDefinition(PropertyTypeDefinition, ABC):
+    list: bool | None = None
+    max_list_size: int | None = None
+
+
+class TextProperty(ListablePropertyTypeDefinition):
+    type: Literal["text"] = "text"
+    max_text_size: int | None = None
+    collation: str | None = None
+
+
+class Unit(BaseModelObject):
+    external_id: str
+    source_unit: str | None = None
+
+
+class FloatProperty(ListablePropertyTypeDefinition, ABC):
+    unit: Unit | None = None
+
+
+class Float32Property(FloatProperty):
+    type: Literal["float32"] = "float32"
+
+
+class Float64Property(FloatProperty):
+    type: Literal["float64"] = "float64"
+
+
+class BooleanProperty(ListablePropertyTypeDefinition):
+    type: Literal["boolean"] = "boolean"
+
+
+class Int32Property(ListablePropertyTypeDefinition):
+    type: Literal["int32"] = "int32"
+
+
+class Int64Property(ListablePropertyTypeDefinition):
+    type: Literal["int64"] = "int64"
+
+
+class TimestampProperty(ListablePropertyTypeDefinition):
+    type: Literal["timestamp"] = "timestamp"
+
+
+class DateProperty(ListablePropertyTypeDefinition):
+    type: Literal["date"] = "date"
+
+
+class JSONProperty(ListablePropertyTypeDefinition):
+    type: Literal["json"] = "json"
+
+
+class TimeseriesCDFExternalIdReference(ListablePropertyTypeDefinition):
+    type: Literal["timeseries"] = "timeseries"
+
+
+class FileCDFExternalIdReference(ListablePropertyTypeDefinition):
+    type: Literal["file"] = "file"
+
+
+class SequenceCDFExternalIdReference(ListablePropertyTypeDefinition):
+    type: Literal["sequence"] = "sequence"
+
+
+class DirectNodeRelation(ListablePropertyTypeDefinition):
+    type: Literal["direct"] = "direct"
+    container: ContainerReference | None = None
+    # This property is only available in the response object. It will be ignored in the request object.
+    # In the request object, use ViewCoreProperty.source instead.
+    source: ViewReference | None = Field(None, exclude=True)
+
+
+class EnumValue(BaseModelObject):
+    name: str | None = None
+    description: str | None = None
+
+
+class EnumProperty(PropertyTypeDefinition):
+    type: Literal["enum"] = "enum"
+    unknown_value: str | None = None
+    values: dict[str, EnumValue]
+
+
+DataType = Annotated[
+    TextProperty
+    | Float32Property
+    | Float64Property
+    | BooleanProperty
+    | Int32Property
+    | Int64Property
+    | TimestampProperty
+    | DateProperty
+    | JSONProperty
+    | TimeseriesCDFExternalIdReference
+    | FileCDFExternalIdReference
+    | SequenceCDFExternalIdReference
+    | EnumProperty
+    | DirectNodeRelation,
+    Field(discriminator="type"),
+]
+
+DataTypeAdapter: TypeAdapter[DataType] = TypeAdapter(DataType)

cognite_toolkit-0.7.43/cognite_toolkit/_cdf_tk/client/data_classes/data_modeling/_indexes.py

@@ -0,0 +1,26 @@
+from abc import ABC
+from typing import Annotated, Literal
+
+from pydantic import Field, TypeAdapter
+
+from cognite_toolkit._cdf_tk.client.data_classes.base import BaseModelObject
+
+
+class IndexDefinition(BaseModelObject, ABC):
+    index_type: str
+    properties: list[str]
+
+
+class BtreeIndex(IndexDefinition):
+    index_type: Literal["btree"] = "btree"
+    by_space: bool | None = None
+    cursorable: bool | None = None
+
+
+class InvertedIndex(IndexDefinition):
+    index_type: Literal["inverted"] = "inverted"
+
+
+Index = Annotated[BtreeIndex | InvertedIndex, Field(discriminator="index_type")]
+
+IndexAdapter: TypeAdapter[Index] = TypeAdapter(Index)