Data Modeling

Data Models

`AsyncCogniteClient.data_modeling.data_models.apply`(...)	Create or update one or more data model.
`AsyncCogniteClient.data_modeling.data_models.delete`(ids)	Delete one or more data model.
`AsyncCogniteClient.data_modeling.data_models.list`([...])	List data models.
`AsyncCogniteClient.data_modeling.data_models.retrieve`(ids)	Retrieve data_model(s) by id(s).

Data model data classes

class cognite.client.data_classes.data_modeling.data_models.DataModel( space: str, external_id: str, version: str, is_global: bool, last_updated_time: int, created_time: int, description: str | None, name: str | None, views: list[T_View] | None, )

Bases: DataModelCore, Generic[T_View]

A group of views. This is the read version of a Data Model

Parameters:

space (str) – The workspace for the data model, a unique identifier for the space.
external_id (str) – Combined with the space is the unique identifier of the data model.
version (str) – DMS version.
is_global (bool) – Whether this is a global data model.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
description (str | None) – Textual description of the data model
name (str | None) – Human readable name for the data model.
views (list[T_View] | None) – List of views included in this data model.

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.data_models.DataModelApply( space: str, external_id: str, version: str, description: str | None = None, name: str | None = None, views: Sequence[ViewId | ViewApply] | None = None, )

Bases: DataModelCore

A group of views. This is the write version of a Data Model.

Parameters:

space (str) – The workspace for the data model, a unique identifier for the space.
external_id (str) – Combined with the space is the unique identifier of the data model.
version (str) – DMS version.
description (str | None) – Textual description of the data model
name (str | None) – Human readable name for the data model.
views (Sequence[ViewId | ViewApply] | None) – List of views included in this data model.

as_write() → DataModelApply: Returns this DataModelApply instance.

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.data_models.DataModelApplyList( resources: Sequence[T_CogniteResource], )

Bases: CogniteResourceList[DataModelApply]

as_ids() → list[DataModelId]

Convert the list of data models to a list of data model ids.

Returns:: The list of data model ids.
Return type:: list[DataModelId]

class cognite.client.data_classes.data_modeling.data_models.DataModelCore( space: str, external_id: str, version: str, description: str | None, name: str | None, )

Bases: DataModelingSchemaResource[DataModelApply], ABC

A group of views.

Parameters:

space (str) – The workspace for the data model, a unique identifier for the space.
external_id (str) – Combined with the space is the unique identifier of the data model.
version (str) – DMS version.
description (str | None) – Textual description of the data model
name (str | None) – Human readable name for the data model.

class cognite.client.data_classes.data_modeling.data_models.DataModelFilter( space: str | None = None, inline_views: bool = False, all_versions: bool = False, include_global: bool = False, )

Bases: CogniteFilter

Represent the filer arguments for the list endpoint.

Parameters:

space (str | None) – The space to query
inline_views (bool) – Whether to expand the referenced views inline in the returned result.
all_versions (bool) – Whether to return all versions. If false, only the newest version is returned, which is determined based on the ‘createdTime’ field.
include_global (bool) – Whether to include global views.

class cognite.client.data_classes.data_modeling.data_models.DataModelList( resources: Sequence[T_CogniteResource], )

Bases: WriteableCogniteResourceList[DataModelApply, DataModel[T_View]]

as_apply() → DataModelApplyList

Convert the list of data models to a list of data model applies.

Returns:: The list of data model applies.
Return type:: DataModelApplyList

as_ids() → list[DataModelId]

Convert the list of data models to a list of data model ids.

Returns:: The list of data model ids.
Return type:: list[DataModelId]

latest_version( key: Literal['created_time', 'last_updated_time'] = 'created_time', ) → DataModel[T_View]

Get the data model in the list with the latest version. The latest version is determined based on the created_time or last_updated_time field.

Parameters:: key (Literal['created_time', 'last_updated_time']) – The field to use for determining the latest version.
Returns:: The data model with the latest version.
Return type:: DataModel[T_View]

class cognite.client.data_classes.data_modeling.data_models.DataModelsSort( property: Literal['space', 'external_id', 'name', 'description', 'version', 'created_time', 'last_updated_time'], direction: Literal['ascending', 'descending'] = 'ascending', nulls_first: bool = False, ): Bases: DataModelingSort

Spaces

`AsyncCogniteClient.data_modeling.spaces.apply`(spaces)	Create or patch one or more spaces.
`AsyncCogniteClient.data_modeling.spaces.delete`(spaces)	Delete one or more spaces.
`AsyncCogniteClient.data_modeling.spaces.list`([...])	List spaces.
`AsyncCogniteClient.data_modeling.spaces.retrieve`(spaces)	Retrieve one or more spaces.

Data classes

class cognite.client.data_classes.data_modeling.spaces.Space( space: str, is_global: bool, last_updated_time: int, created_time: int, description: str | None = None, name: str | None = None, )

Bases: SpaceCore

A workspace for data models and instances. This is the read version.

Parameters:

space (str) – A unique identifier for the space.
is_global (bool) – Whether the space is global or not.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
description (str | None) – Textual description of the space
name (str | None) – Human readable name for the space.

class cognite.client.data_classes.data_modeling.spaces.SpaceApply(space: str, description: str | None = None, name: str | None = None)

Bases: SpaceCore

A workspace for data models and instances. This is the write version

Parameters:

space (str) – A unique identifier for the space.
description (str | None) – Textual description of the space
name (str | None) – Human readable name for the space.

as_write() → SpaceApply: Returns this SpaceApply instance.

class cognite.client.data_classes.data_modeling.spaces.SpaceApplyList( resources: Sequence[T_CogniteResource], )

Bases: CogniteResourceList[SpaceApply]

as_ids() → list[str]

Converts all the spaces to a space id list.

Returns:: A list of space ids.
Return type:: list[str]

class cognite.client.data_classes.data_modeling.spaces.SpaceCore(space: str, description: str | None, name: str | None)

Bases: WritableDataModelingResource[SpaceApply], ABC

A workspace for data models and instances.

Parameters:

space (str) – A unique identifier for the space.
description (str | None) – Textual description of the space
name (str | None) – Human readable name for the space.

class cognite.client.data_classes.data_modeling.spaces.SpaceList( resources: Sequence[T_CogniteResource], )

Bases: WriteableCogniteResourceList[SpaceApply, Space]

as_apply() → SpaceApplyList

Converts all the spaces to a space apply list.

Returns:: A list of space applies.
Return type:: SpaceApplyList

as_ids() → list[str]

Converts all the spaces to a space id list.

Returns:: A list of space ids.
Return type:: list[str]

extend(other: Iterable[Any]) → None: S.extend(iterable) – extend sequence by appending elements from the iterable

get( space: str, ) → Space | None

Get a space object from this list by space ID.

Parameters:: space (str) – The space identifier to get.
Returns:: The requested space if present, else None
Return type:: Space | None

Views

`AsyncCogniteClient.data_modeling.views.apply`(view)	Create or update (upsert) one or more views.
`AsyncCogniteClient.data_modeling.views.delete`(ids)	Delete one or more views.
`AsyncCogniteClient.data_modeling.views.list`([...])	List views.
`AsyncCogniteClient.data_modeling.views.retrieve`(ids)	Retrieve a single view by id.

View data classes

class cognite.client.data_classes.data_modeling.views.ConnectionDefinition

Bases: ViewProperty, ABC

abstract dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.views.ConnectionDefinitionApply

Bases: ViewPropertyApply, ABC

abstract dump( camel_case: bool = True, ) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.views.EdgeConnection( type: DirectRelationReference, source: ViewId, name: str | None, description: str | None, edge_source: ViewId | None, direction: Literal['outwards', 'inwards'], )

Bases: ConnectionDefinition, ABC

Describes the edge(s) that are likely to exist to aid in discovery and documentation of the view. A listed edge is not required. i.e. It does not have to exist when included in this list. A connection has a max distance of one hop.

Parameters:

type (DirectRelationReference) – Reference to the node pointed to by the direct relation. The reference consists of a space and an external-id.
source (ViewId) – The target node(s) of this connection can be read through the view specified in ‘source’.
name (str | None) – Readable property name.
description (str | None) – Description of the content and suggested use for this property.
edge_source (ViewId | None) – The edge(s) of this connection can be read through the view specified in ‘edgeSource’.
direction (Literal['outwards', 'inwards']) – The direction of the edge. The outward direction is used to indicate that the edge points from the source to the target. The inward direction is used to indicate that the edge points from the target to the source.

abstract dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.views.EdgeConnectionApply( type: DirectRelationReference, source: ViewId, name: str | None = None, description: str | None = None, edge_source: ViewId | None = None, direction: Literal['outwards', 'inwards'] = 'outwards', )

Bases: ConnectionDefinitionApply, ABC

Describes the edge(s) that are likely to exist to aid in discovery and documentation of the view. A listed edge is not required. i.e. It does not have to exist when included in this list. A connection has a max distance of one hop.

It is called ‘EdgeConnection’ in the API spec.

Parameters:

type (DirectRelationReference) – Reference to the node pointed to by the direct relation. The reference consists of a space and an external-id.
source (ViewId) – The target node(s) of this connection can be read through the view specified in ‘source’.
name (str | None) – Readable property name.
description (str | None) – Description of the content and suggested use for this property.
edge_source (ViewId | None) – The edge(s) of this connection can be read through the view specified in ‘edgeSource’.
direction (Literal['outwards', 'inwards']) – The direction of the edge. The outward direction is used to indicate that the edge points from the source to the target. The inward direction is used to indicate that the edge points from the target to the source.

abstract dump(camel_case: bool = True) → dict

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.views.MappedProperty( container: 'ContainerId', container_property_identifier: 'str', type: 'PropertyType', nullable: 'bool', immutable: 'bool', auto_increment: 'bool', source: 'ViewId | None' = None, default_value: 'str | int | dict | None' = None, name: 'str | None' = None, description: 'str | None' = None, )

Bases: ViewProperty

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.views.MappedPropertyApply( container: 'ContainerId', container_property_identifier: 'str', name: 'str | None' = None, description: 'str | None' = None, source: 'ViewId | None' = None, )

Bases: ViewPropertyApply

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.views.MultiEdgeConnection( type: 'DirectRelationReference', source: 'ViewId', name: 'str | None', description: 'str | None', edge_source: 'ViewId | None', direction: "Literal['outwards', 'inwards']", )

Bases: EdgeConnection

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.views.MultiEdgeConnectionApply( type: 'DirectRelationReference', source: 'ViewId', name: 'str | None' = None, description: 'str | None' = None, edge_source: 'ViewId | None' = None, direction: "Literal['outwards', 'inwards']" = 'outwards', )

Bases: EdgeConnectionApply

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.views.MultiReverseDirectRelation( source: 'ViewId', through: 'PropertyId', name: 'str | None' = None, description: 'str | None' = None, )

Bases: ReverseDirectRelation

dump( camel_case: bool = True, ) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.views.MultiReverseDirectRelationApply( source: 'ViewId', through: 'PropertyId', name: 'str | None' = None, description: 'str | None' = None, )

Bases: ReverseDirectRelationApply

dump( camel_case: bool = True, ) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.views.ReverseDirectRelation( source: ViewId, through: PropertyId, name: str | None = None, description: str | None = None, )

Bases: ConnectionDefinition, ABC

Describes the direct relation(s) pointing to instances read through this view. This connection type is used to aid in discovery and documentation of the view

It is called ‘ReverseDirectRelationConnection’ in the API spec.

Parameters:

source (ViewId) – The node(s) containing the direct relation property can be read through the view specified in ‘source’.
through (PropertyId) – The view or container of the node containing the direct relation property.
name (str | None) – Readable property name.
description (str | None) – Description of the content and suggested use for this property.

abstract dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.views.ReverseDirectRelationApply( source: ViewId, through: PropertyId, name: str | None = None, description: str | None = None, )

Bases: ConnectionDefinitionApply, ABC

Describes the direct relation(s) pointing to instances read through this view. This connection type is used to aid in discovery and documentation of the view.

It is called ‘ReverseDirectRelationConnection’ in the API spec.

Parameters:

source (ViewId) – The node(s) containing the direct relation property can be read through the view specified in ‘source’.
through (PropertyId) – The view or container of the node containing the direct relation property.
name (str | None) – Readable property name.
description (str | None) – Description of the content and suggested use for this property.

abstract dump( camel_case: bool = True, ) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.views.SingleEdgeConnection( type: 'DirectRelationReference', source: 'ViewId', name: 'str | None', description: 'str | None', edge_source: 'ViewId | None', direction: "Literal['outwards', 'inwards']", )

Bases: EdgeConnection

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.views.SingleEdgeConnectionApply( type: 'DirectRelationReference', source: 'ViewId', name: 'str | None' = None, description: 'str | None' = None, edge_source: 'ViewId | None' = None, direction: "Literal['outwards', 'inwards']" = 'outwards', )

Bases: EdgeConnectionApply

dump( camel_case: bool = True, ) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

cognite.client.data_classes.data_modeling.views.SingleHopConnectionDefinition: alias of MultiEdgeConnection

cognite.client.data_classes.data_modeling.views.SingleHopConnectionDefinitionApply: alias of MultiEdgeConnectionApply

class cognite.client.data_classes.data_modeling.views.SingleReverseDirectRelation( source: 'ViewId', through: 'PropertyId', name: 'str | None' = None, description: 'str | None' = None, )

Bases: ReverseDirectRelation

dump( camel_case: bool = True, ) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.views.SingleReverseDirectRelationApply( source: 'ViewId', through: 'PropertyId', name: 'str | None' = None, description: 'str | None' = None, )

Bases: ReverseDirectRelationApply

dump( camel_case: bool = True, ) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.views.View( space: str, external_id: str, version: str, properties: dict[str, ViewProperty], last_updated_time: int, created_time: int, description: str | None, name: str | None, filter: Filter | None, implements: list[ViewId] | None, writable: bool, used_for: Literal['node', 'edge', 'all'], is_global: bool, )

Bases: ViewCore

A group of properties. Read only version.

Parameters:

space (str) – The workspace for the view, a unique identifier for the space.
external_id (str) – Combined with the space is the unique identifier of the view.
version (str) – DMS version.
properties (dict[str, ViewProperty]) – View with included properties and expected edges, indexed by a unique space-local identifier.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
description (str | None) – Textual description of the view
name (str | None) – Human readable name for the view.
filter (Filter | None) – A filter Domain Specific Language (DSL) used to create advanced filter queries.
implements (list[ViewId] | None) – References to the views from where this view will inherit properties and edges.
writable (bool) – Whether the view supports write operations.
used_for (Literal['node', 'edge', 'all']) – Does this view apply to nodes, edges or both.
is_global (bool) – Whether this is a global view.

as_apply() → ViewApply

Convert to a view applies.

Returns:: The view apply.
Return type:: ViewApply

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

referenced_containers() → set[ContainerId]

Helper function to get the set of containers referenced by this view.

Returns:: The set of containers referenced by this view.
Return type:: set[ContainerId]

class cognite.client.data_classes.data_modeling.views.ViewApply( space: str, external_id: str, version: str, description: str | None = None, name: str | None = None, filter: Filter | None = None, implements: list[ViewId] | None = None, properties: dict[str, ViewPropertyApply] | None = None, )

Bases: ViewCore

A group of properties. Write only version.

Parameters:

space (str) – The workspace for the view, a unique identifier for the space.
external_id (str) – Combined with the space is the unique identifier of the view.
version (str) – DMS version.
description (str | None) – Textual description of the view
name (str | None) – Human readable name for the view.
filter (Filter | None) – A filter Domain Specific Language (DSL) used to create advanced filter queries.
implements (list[ViewId] | None) – References to the views from where this view will inherit properties and edges.
properties (dict[str, ViewPropertyApply] | None) – No description.

Note

The order of elements (i.e., ViewId) in implements matters, as it indicates priority on how to handle collisions of same properties from different views. See docs on implemented property conflicts for more details.

as_write() → ViewApply: Returns this ViewApply instance.

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

referenced_containers() → set[ContainerId]

Helper function to get the set of containers referenced by this view.

Returns:: The set of containers referenced by this view.
Return type:: set[ContainerId]

class cognite.client.data_classes.data_modeling.views.ViewApplyList( resources: Sequence[T_CogniteResource], )

Bases: CogniteResourceList[ViewApply]

as_ids() → list[ViewId]

Returns the list of ViewIds

Returns:: The list of ViewIds
Return type:: list[ViewId]

referenced_containers() → set[ContainerId]

Helper function to get the set of containers referenced by this view.

Returns:: The set of containers referenced by this view.
Return type:: set[ContainerId]

class cognite.client.data_classes.data_modeling.views.ViewCore( space: str, external_id: str, version: str, description: str | None, name: str | None, filter: Filter | None, implements: list[ViewId] | None, )

Bases: DataModelingSchemaResource[ViewApply], ABC

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.views.ViewFilter( space: str | None = None, include_inherited_properties: bool = True, all_versions: bool = False, include_global: bool = False, )

Bases: CogniteFilter

Represent the filer arguments for the list endpoint.

Parameters:

space (str | None) – The space to query
include_inherited_properties (bool) – Whether to include properties inherited from views this view implements.
all_versions (bool) – Whether to return all versions. If false, only the newest version is returned, which is determined based on the ‘createdTime’ field.
include_global (bool) – Whether to include global views.

class cognite.client.data_classes.data_modeling.views.ViewList( resources: Sequence[T_CogniteResource], )

Bases: WriteableCogniteResourceList[ViewApply, View]

as_apply() → ViewApplyList

Convert to a view an apply list.

Returns:: The view apply list.
Return type:: ViewApplyList

as_ids() → list[ViewId]

Returns the list of ViewIds

Returns:: The list of ViewIds
Return type:: list[ViewId]

referenced_containers() → set[ContainerId]

Helper function to get the set of containers referenced by this view.

Returns:: The set of containers referenced by this view.
Return type:: set[ContainerId]

class cognite.client.data_classes.data_modeling.views.ViewProperty

Bases: CogniteResource, ABC

abstract dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.views.ViewPropertyApply

Bases: CogniteResource, ABC

abstract dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

Containers

`AsyncCogniteClient.data_modeling.containers.apply`(...)	Add or update (upsert) containers.
`AsyncCogniteClient.data_modeling.containers.delete`(ids)	Delete one or more containers.
`AsyncCogniteClient.data_modeling.containers.delete_constraints`(ids)	Delete one or more constraints.
`AsyncCogniteClient.data_modeling.containers.delete_indexes`(ids)	Delete one or more indexes.
`AsyncCogniteClient.data_modeling.containers.list`([...])	List containers.
`AsyncCogniteClient.data_modeling.containers.retrieve`(ids)	Retrieve one or more container by id(s).

Containers data classes

class cognite.client.data_classes.data_modeling.containers.BTreeIndex( state: Literal['current', 'failed', 'pending'], *, properties: list[str], cursorable: bool, )

Bases: Index

Read version of btree index with state information.

as_apply() → BTreeIndexApply: Return the write version of this index.

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.containers.BTreeIndexApply(properties: list[str], cursorable: bool = False)

Bases: IndexApply

Write version of btree index.

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.containers.Constraint(state: Literal['current', 'failed', 'pending'])

Bases: ConstraintCore, ABC

Read version of constraint with state information.

class cognite.client.data_classes.data_modeling.containers.ConstraintApply

Bases: ConstraintCore, ABC

Write version of constraint without state information.

as_apply() → ConstraintApply: Return this ConstraintApply instance.

class cognite.client.data_classes.data_modeling.containers.ConstraintCore

Bases: CogniteResource, ABC

Base class for constraints with shared functionality.

abstract as_apply() → ConstraintApply: Return the write version of this constraint.

abstract dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.containers.Container(space: str, external_id: str, description: str | None = None, name: str | None = None, *, properties: ~collections.abc.Mapping[str, ~cognite.client.data_classes.data_modeling.containers.ContainerProperty], constraints: ~collections.abc.Mapping[str, ~cognite.client.data_classes.data_modeling.containers.Constraint] = <factory>, indexes: ~collections.abc.Mapping[str, ~cognite.client.data_classes.data_modeling.containers.Index] = <factory>, is_global: bool, last_updated_time: int, created_time: int, used_for: ~typing.Literal['node', 'edge', 'all'])

Bases: ContainerCore

Represent the physical storage of data. This is the read format of the container

Parameters:

space (str) – The workspace for the container, a unique identifier for the space.
external_id (str) – Combined with the space is the unique identifier of the container.
description (str | None) – Textual description of the container
name (str | None) – Human readable name for the container.
properties (Mapping[str, ContainerProperty]) – We index the property by a local unique identifier.
constraints (Mapping[str, Constraint]) – Set of constraints to apply to the container
indexes (Mapping[str, Index]) – Set of indexes to apply to the container.
is_global (bool) – Whether this is a global container, i.e., one of the out-of-the-box models.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
used_for (Literal['node', 'edge', 'all']) – Should this operation apply to nodes, edges or both.

class cognite.client.data_classes.data_modeling.containers.ContainerApply(space: str, external_id: str, properties: ~collections.abc.Mapping[str, ~cognite.client.data_classes.data_modeling.containers.ContainerPropertyApply], description: str | None = None, name: str | None = None, constraints: ~collections.abc.Mapping[str, ~cognite.client.data_classes.data_modeling.containers.ConstraintApply] = <factory>, indexes: ~collections.abc.Mapping[str, ~cognite.client.data_classes.data_modeling.containers.IndexApply] = <factory>, used_for: ~typing.Literal['node', 'edge', 'all'] | None = None)

Bases: ContainerCore

Represent the physical storage of data. This is the write format of the container

Parameters:

space (str) – The workspace for the container, a unique identifier for the space.
external_id (str) – Combined with the space is the unique identifier of the container.
properties (Mapping[str, ContainerPropertyApply]) – We index the property by a local unique identifier.
description (str | None) – Textual description of the container
name (str | None) – Human readable name for the container.
constraints (Mapping[str, ConstraintApply]) – Set of constraints to apply to the container
indexes (Mapping[str, IndexApply]) – Set of indexes to apply to the container.
used_for (Literal['node', 'edge', 'all'] | None) – Should this operation apply to nodes, edges or both.

as_write() → ContainerApply: Returns this ContainerApply instance.

class cognite.client.data_classes.data_modeling.containers.ContainerApplyList( resources: Sequence[T_CogniteResource], )

Bases: CogniteResourceList[ContainerApply]

as_ids() → list[ContainerId]

Convert to a container id list.

Returns:: The container id list.
Return type:: list[ContainerId]

class cognite.client.data_classes.data_modeling.containers.ContainerCore(space: str, external_id: str, properties: ~collections.abc.Mapping[str, ~cognite.client.data_classes.data_modeling.containers.ContainerPropertyCore], description: str | None = None, name: str | None = None, constraints: ~collections.abc.Mapping[str, ~cognite.client.data_classes.data_modeling.containers.ConstraintCore] = <factory>, indexes: ~collections.abc.Mapping[str, ~cognite.client.data_classes.data_modeling.containers.IndexCore] = <factory>)

Bases: DataModelingSchemaResource[ContainerApply], ABC

Represent the physical storage of data. This is the base class for the read and write version.

Parameters:

space (str) – The workspace for the container, a unique identifier for the space.
external_id (str) – Combined with the space is the unique identifier of the container.
properties (Mapping[str, ContainerPropertyCore]) – We index the property by a local unique identifier.
description (str | None) – Textual description of the container
name (str | None) – Human readable name for the container.
constraints (Mapping[str, ConstraintCore]) – Set of constraints to apply to the container
indexes (Mapping[str, IndexCore]) – Set of indexes to apply to the container.

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.containers.ContainerList( resources: Sequence[T_CogniteResource], )

Bases: WriteableCogniteResourceList[ContainerApply, Container]

as_apply() → ContainerApplyList

Convert to a ContainerApply list.

Returns:: The container apply list.
Return type:: ContainerApplyList

as_ids() → list[ContainerId]

Convert to a container id list.

Returns:: The container id list.
Return type:: list[ContainerId]

class cognite.client.data_classes.data_modeling.containers.ContainerProperty( type: ~cognite.client.data_classes.data_modeling.data_types.PropertyType, nullable: bool = True, auto_increment: bool = False, name: str | None = None, default_value: str | int | float | bool | dict | None = None, description: str | None = None, immutable: bool = False, constraint_state: ~cognite.client.data_classes.data_modeling.containers.PropertyConstraintState = <factory>, )

Bases: ContainerPropertyCore

Read version of container property with state information.

as_apply() → ContainerPropertyApply: Return the write version of this property.

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

Bases: ContainerPropertyCore

Write version of container property.

as_apply() → ContainerPropertyApply: Return this ContainerPropertyApply instance.

Bases: CogniteResource, ABC

Base class for container properties with shared functionality.

abstract as_apply() → ContainerPropertyApply: Return the write version of this property.

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.containers.Index(state: Literal['current', 'failed', 'pending'])

Bases: IndexCore, ABC

Read version of index with state information.

class cognite.client.data_classes.data_modeling.containers.IndexApply

Bases: IndexCore, ABC

Write version of index without state information.

as_apply() → IndexApply: Return this IndexApply instance.

class cognite.client.data_classes.data_modeling.containers.IndexCore

Bases: CogniteResource, ABC

Base class for indexes with shared functionality.

abstract as_apply() → IndexApply: Return the write version of this index.

abstract dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.containers.InvertedIndex( state: Literal['current', 'failed', 'pending'], *, properties: list[str], )

Bases: Index

Read version of inverted index with state information.

as_apply() → InvertedIndexApply: Return the write version of this index.

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.containers.InvertedIndexApply(properties: list[str])

Bases: IndexApply

Write version of inverted index.

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.containers.PropertyConstraintState( nullability: "Literal['current', 'failed', 'pending'] | None" = None, max_list_size: "Literal['current', 'failed', 'pending'] | None" = None, max_text_size: "Literal['current', 'failed', 'pending'] | None" = None, )

Bases: CogniteResource

dump(camel_case: bool = True) → dict[str, str]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.containers.RequiresConstraint( state: Literal['current', 'failed', 'pending'], *, require: ContainerId, )

Bases: Constraint

Read version of requires constraint with state information.

as_apply() → RequiresConstraintApply: Return the write version of this constraint.

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.containers.RequiresConstraintApply( require: ContainerId, )

Bases: ConstraintApply

Write version of requires constraint.

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.containers.UniquenessConstraint( state: Literal['current', 'failed', 'pending'], properties: list[str], )

Bases: Constraint

Read version of uniqueness constraint with state information.

as_apply() → UniquenessConstraintApply: Return the write version of this constraint.

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.containers.UniquenessConstraintApply(properties: list[str])

Bases: ConstraintApply

Write version of uniqueness constraint.

dump( camel_case: bool = True, ) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

Instances

`AsyncCogniteClient.data_modeling.instances.aggregate`(...)	Aggregate data across nodes/edges.
`AsyncCogniteClient.data_modeling.instances.apply`([...])	Add or update (upsert) instances.
`AsyncCogniteClient.data_modeling.instances.delete`([...])	Delete one or more instances.
`AsyncCogniteClient.data_modeling.instances.histogram`(...)	Produces histograms for nodes/edges.
`AsyncCogniteClient.data_modeling.instances.inspect`([...])	Reverse lookup for instances.
`AsyncCogniteClient.data_modeling.instances.list`([...])	List instances.
`AsyncCogniteClient.data_modeling.instances.query`(query)	Advanced query interface for nodes/edges.
`AsyncCogniteClient.data_modeling.instances.retrieve`([...])	Retrieve one or more instance by id(s).
`AsyncCogniteClient.data_modeling.instances.retrieve_edges`(edges)	Retrieve one or more edges by id(s).
`AsyncCogniteClient.data_modeling.instances.retrieve_nodes`(nodes)	Retrieve one or more nodes by id(s).
`AsyncCogniteClient.data_modeling.instances.search`(view)	Search instances.
`AsyncCogniteClient.data_modeling.instances.subscribe`(...)	Subscribe to a query and get updates when the result set changes.
`AsyncCogniteClient.data_modeling.instances.sync`(query)	Subscription to changes for nodes/edges.

Example: Syncing instances to a local SQLite database

The following example demonstrates how to use the subscribe method to create a live, local replica of instances from a specific space in a SQLite database.

import asyncio
import json
import sqlite3
from typing import Optional

from cognite.client import AsyncCogniteClient
from cognite.client.config import ClientConfig
from cognite.client.data_classes.data_modeling import (
    QueryResult,
    QuerySync,
    NodeResultSetExpressionSync,
    SelectSync,
    SubscriptionContext,
)
from cognite.client.data_classes.filters import Equals


def sqlite_connection(db_name: str) -> sqlite3.Connection:
    return sqlite3.connect(db_name)


def bootstrap_sqlite(db_name: str) -> None:
    """Sets up the initial database schema if it doesn't exist."""
    with sqlite_connection(db_name) as connection:
        connection.execute(
            """
            CREATE TABLE IF NOT EXISTS instance (
                space TEXT,
                external_id TEXT,
                data JSON,
                PRIMARY KEY(space, external_id)
            )
            """
        )
        connection.execute(
            """
            CREATE TABLE IF NOT EXISTS cursor (
                space TEXT PRIMARY KEY,
                cursor TEXT
            )
            """
        )
        connection.commit()


async def sync_space_to_sqlite(
    async_client: AsyncCogniteClient, db_name: str, space_to_sync: str
) -> SubscriptionContext:
    """
    Sets up and starts a subscription to sync a space to a local SQLite database.
    """
    # 1. Read the last known cursor from the database.
    #    This is a blocking call, so we run it in a thread.
    def _get_cursor() -> Optional[str]:
        with sqlite_connection(db_name) as connection:
            result = connection.execute(
                "SELECT cursor FROM cursor WHERE space = ?", (space_to_sync,)
            ).fetchone()
            if result:
                print(f"Found existing cursor for space {space_to_sync!r}")
                return result[0]
            return None

    existing_cursor = await asyncio.to_thread(_get_cursor)

    query = QuerySync(
        with_={
            "nodes": NodeResultSetExpressionSync(
                filter=Equals(property=["node", "space"], value=space_to_sync)
            )
        },
        select={"nodes": SelectSync()},
        cursors={"nodes": existing_cursor},
    )

    # 2. Define the callback that will process each batch of results.
    #    The callback itself does not have to be async, but it is preferable.
    async def _sync_batch_to_sqlite(result: QueryResult) -> None:
        def _write_to_db() -> tuple[int, int]:
            # 3. Prepare all data in memory before opening the database
            #    connection to minimize lock time.
            inserts, deletes = [], []
            for node in result["nodes"]:
                if node.deleted_time is None:
                    inserts.append(
                        (node.space, node.external_id, json.dumps(node.dump()))
                    )
                else:
                    deletes.append((node.space, node.external_id))

            # 4. Perform all database operations within a single transaction
            #    to ensure data consistency.
            with sqlite_connection(db_name) as connection:
                # Note: Deletions must be processed before insertions. This ensures
                # that we don't lose an instance that has been deleted and re-created
                # in the same sync batch.
                connection.executemany(
                    "DELETE FROM instance WHERE space=? AND external_id=?", deletes
                )
                connection.executemany(
                    "INSERT INTO instance (space, external_id, data) VALUES (?, ?, ?) "
                    "ON CONFLICT(space, external_id) DO UPDATE SET data=excluded.data",
                    inserts,
                )
                # Finally, persist the cursor for this space.
                connection.execute(
                    "INSERT INTO cursor (space, cursor) VALUES (?, ?) "
                    "ON CONFLICT(space) DO UPDATE SET cursor=excluded.cursor",
                    (space_to_sync, result.cursors["nodes"]),
                )
                connection.commit()

            return len(inserts), len(deletes)

        # 5. Run the blocking database write operation in a separate thread.
        inserts, deletes = await asyncio.to_thread(_write_to_db)
        print(f"Wrote {inserts} nodes and deleted {deletes} nodes for space {space_to_sync!r}")

    # 6. Start the subscription and return the SubscriptionContext.
    return await async_client.data_modeling.instances.subscribe(query, _sync_batch_to_sqlite)


async def main():
    async_client = AsyncCogniteClient(ClientConfig(...))

    SQLITE_DB_NAME = "my_instances.db"
    SPACE_TO_SYNC = "my-awesome-space"

    bootstrap_sqlite(db_name=SQLITE_DB_NAME)

    print(f"Starting subscription for space: {SPACE_TO_SYNC!r}...")
    subscription = await sync_space_to_sqlite(
        async_client, db_name=SQLITE_DB_NAME, space_to_sync=SPACE_TO_SYNC
    )
    print("Subscription is live. Press Ctrl+C (or Cmd+C) to stop.")
    try:
        # Keep the application alive to allow the background subscription to run.
        while True:
            await asyncio.sleep(10)

    except asyncio.CancelledError:
        print("Main task cancelled.")
    finally:
        # Ensure we clean up and cancel the subscription task on exit.
        print("Stopping subscription...")
        subscription.cancel()
        # Give the task a moment to shut down gracefully
        await asyncio.sleep(1)
        print("Subscription stopped gracefully.")


if __name__ == "__main__":
    try:
        asyncio.run(main())
    except KeyboardInterrupt:
        pass

Instances core data classes

class cognite.client.data_classes.data_modeling.instances.DataModelingInstancesList( resources: Sequence[T_CogniteResource], )

Bases: WriteableCogniteResourceList[T_WriteClass, T_Instance], ABC

extend( other: Iterable[Any], ) → None: S.extend(iterable) – extend sequence by appending elements from the iterable

get( instance_id: InstanceId | tuple[str, str] | None = None, external_id: str | None = None, ) → T_Instance | None

Get an instance from this list by instance ID.

Parameters:

instance_id (InstanceId | tuple[str, str] | None) – The instance ID to get. A tuple on the form (space, external_id) is also accepted.
external_id (str | None) – The external ID of the instance to return. Will raise ValueError when ambiguous (in presence of multiple spaces).

Returns:

The requested instance if present, else None

Return type:

T_Instance | None

to_pandas( camel_case: bool = False, convert_timestamps: bool = True, expand_properties: bool = True, remove_property_prefix: bool = True, ) → pd.DataFrame

Convert the instance into a pandas DataFrame. Note that if the properties column is expanded and there are keys in the metadata that already exist in the DataFrame, then an error will be raised by pandas during joining.

Parameters:

camel_case (bool) – Convert column names to camel case (e.g. externalId instead of external_id). Does not apply to properties.
convert_timestamps (bool) – Convert known columns storing CDF timestamps (milliseconds since epoch) to datetime. Does not affect properties.
expand_properties (bool) – Expand the properties into separate columns.
remove_property_prefix (bool) – Attempt to remove the view ID prefix from columns names of expanded properties. Requires data to be from a single view and that all property names do not conflict with base properties (e.g. ‘space’ or ‘type’). In such cases, a warning is issued and the prefix is kept.

Returns:

The Cognite resource as a dataframe.

Return type:

pd.DataFrame

class cognite.client.data_classes.data_modeling.instances.Edge( space: str, external_id: str, version: int, type: DirectRelationReference | tuple[str, str], last_updated_time: int, created_time: int, start_node: DirectRelationReference | tuple[str, str], end_node: DirectRelationReference | tuple[str, str], deleted_time: int | None, properties: Properties | None, )

Bases: Instance[EdgeApply]

An Edge. This is the read version of the edge.

Parameters:

space (str) – The workspace for the edge, a unique identifier for the space.
external_id (str) – Combined with the space is the unique identifier of the edge.
version (int) – Current version of the edge.
type (DirectRelationReference | tuple[str, str]) – The type of edge.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
start_node (DirectRelationReference | tuple[str, str]) – Reference to the direct relation. The reference consists of a space and an external-id.
end_node (DirectRelationReference | tuple[str, str]) – Reference to the direct relation. The reference consists of a space and an external-id.
deleted_time (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds. Timestamp when the instance was soft deleted. Note that deleted instances are filtered out of query results, but present in sync results
properties (Properties | None) – No description.

as_apply() → EdgeApply

This is a convenience method for converting from the read version of the Edge to the write version (EdgeApply).

Warning

Properties can be read-only (e.g. if using auto-increment) and then the converted write edge will fail on ingestion.

Returns:: A write edge, EdgeApply, with all properties (even read-only) copied over.
Return type:: EdgeApply

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.instances.EdgeApply( space: str, external_id: str, type: DirectRelationReference | tuple[str, str], start_node: DirectRelationReference | tuple[str, str], end_node: DirectRelationReference | tuple[str, str], existing_version: int | None = None, sources: list[NodeOrEdgeData] | None = None, )

Bases: InstanceApply[EdgeApply]

An Edge. This is the write version of the edge.

Parameters:

space (str) – The workspace for the edge, a unique identifier for the space.
external_id (str) – Combined with the space is the unique identifier of the edge.
type (DirectRelationReference | tuple[str, str]) – The type of edge.
start_node (DirectRelationReference | tuple[str, str]) – Reference to the direct relation. The reference consists of a space and an external-id.
end_node (DirectRelationReference | tuple[str, str]) – Reference to the direct relation. The reference consists of a space and an external-id.
existing_version (int | None) – Fail the ingestion request if the node’s version is greater than or equal to this value. If no existingVersion is specified, the ingestion will always overwrite any existing data for the edge (for the specified container or edge). If existingVersion is set to 0, the upsert will behave as an insert, so it will fail the bulk if the item already exists. If skipOnVersionConflict is set on the ingestion request, then the item will be skipped instead of failing the ingestion request.
sources (list[NodeOrEdgeData] | None) – List of source properties to write. The properties are from the edge and/or container the container(s) making up this node.

as_write() → EdgeApply: Returns this EdgeApply instance

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.instances.EdgeApplyList( resources: Sequence[T_CogniteResource], )

Bases: CogniteResourceList[EdgeApply]

as_ids() → list[EdgeId]

Convert the list of edges to a list of edge ids.

Returns:: A list of edge ids.
Return type:: list[EdgeId]

class cognite.client.data_classes.data_modeling.instances.EdgeApplyResult( space: str, external_id: str, version: int, was_modified: bool, last_updated_time: int, created_time: int, )

Bases: InstanceApplyResult

An Edge. This represents the update on the edge.

Parameters:

space (str) – The workspace for the edge, a unique identifier for the space.
external_id (str) – Combined with the space is the unique identifier of the edge.
version (int) – Current version of the edge.
was_modified (bool) – Whether the edge was modified by the ingestion.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.

class cognite.client.data_classes.data_modeling.instances.EdgeApplyResultList( resources: Sequence[T_CogniteResource], )

Bases: CogniteResourceList[EdgeApplyResult]

as_ids() → list[EdgeId]

Convert the list of edges to a list of edge ids.

Returns:: A list of edge ids.
Return type:: list[EdgeId]

class cognite.client.data_classes.data_modeling.instances.EdgeList( resources: Sequence[T_Edge], typing: TypeInformation | None = None, debug: DebugInfo | None = None, )

Bases: DataModelingInstancesList[EdgeApply, T_Edge]

as_ids() → list[EdgeId]

Convert the list of edges to a list of edge ids.

Returns:: A list of edge ids.
Return type:: list[EdgeId]

as_write() → EdgeApplyList: Returns this EdgeList as a EdgeApplyList

dump_raw(camel_case: bool = True) → dict[str, Any]

This method dumps the list with extra information in addition to the items.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the list.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.instances.EdgeListWithCursor( resources: Sequence[T_Edge], cursor: str | None, typing: TypeInformation | None = None, debug: DebugInfo | None = None, )

Bases: EdgeList

extend( other: EdgeListWithCursor, ) → None: S.extend(iterable) – extend sequence by appending elements from the iterable

class cognite.client.data_classes.data_modeling.instances.InspectOperation: Bases: ABC

class cognite.client.data_classes.data_modeling.instances.InspectionResults( involved_views: list[ViewId] | None, involved_containers: list[ContainerId] | None, )

Bases: CogniteResource

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.instances.Instance( space: str, external_id: str, version: int, last_updated_time: int, created_time: int, instance_type: Literal['node', 'edge'], deleted_time: int | None, properties: Properties | None, )

Bases: WritableInstanceCore[T_CogniteResource], ABC

A node or edge. This is the read version of the instance.

Parameters:

space (str) – The workspace for the instance, a unique identifier for the space.
external_id (str) – Combined with the space is the unique identifier of the instance.
version (int) – Current version of the instance.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
instance_type (Literal['node', 'edge']) – The type of instance.
deleted_time (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds. Timestamp when the instance was soft deleted. Note that deleted instances are filtered out of query results, but present in sync results
properties (Properties | None) – Properties of the instance.

abstract as_apply() → InstanceApply: Convert the instance to an apply instance.

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

to_pandas( ignore: list[str] | None = None, camel_case: bool = False, convert_timestamps: bool = True, expand_properties: bool = True, remove_property_prefix: bool = True, ) → pd.DataFrame

Convert the instance into a pandas DataFrame.

Parameters:

ignore (list[str] | None) – List of row keys to skip when converting to a data frame. Is applied before expansions.
camel_case (bool) – Convert attribute names to camel case (e.g. externalId instead of external_id). Does not affect properties if expanded.
convert_timestamps (bool) – Convert known attributes storing CDF timestamps (milliseconds since epoch) to datetime. Does not affect properties.
expand_properties (bool) – Expand the properties into separate rows.
remove_property_prefix (bool) – Attempt to remove the view ID prefix from row names of expanded properties (in index). Requires data to be from a single view and that all property names do not conflict with base properties (e.g. ‘space’ or ‘type’). In such cases, a warning is issued and the prefix is kept.

Returns:

The dataframe.

Return type:

pd.DataFrame

class cognite.client.data_classes.data_modeling.instances.InstanceAggregationResult( aggregates: list[AggregatedNumberedValue], group: dict[str, str | int | float | bool], )

Bases: DataModelingResource

Represents instances aggregation results.

Parameters:

aggregates (list[AggregatedNumberedValue]) – List of aggregated values.
group (dict[str, str | int | float | bool]) – The grouping used for the aggregation.

dump( camel_case: bool = True, ) → dict[str, Any]

Dumps the aggregation results to a dictionary.

Parameters:: camel_case (bool) – Whether to convert the keys to camel case.
Returns:: A dictionary with the instance results.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.instances.InstanceAggregationResultList( resources: Sequence[T_CogniteResource], ): Bases: CogniteResourceList[InstanceAggregationResult]

class cognite.client.data_classes.data_modeling.instances.InstanceApply( space: str, external_id: str, instance_type: Literal['node', 'edge'] = 'node', existing_version: int | None = None, sources: list[NodeOrEdgeData] | None = None, )

Bases: WritableInstanceCore[T_CogniteResource], ABC

A node or edge. This is the write version of the instance.

Parameters:

space (str) – The workspace for the instance, a unique identifier for the space.
external_id (str) – Combined with the space is the unique identifier of the instance.
instance_type (Literal['node', 'edge']) – The type of instance.
existing_version (int | None) – Fail the ingestion request if the instance’s version is greater than or equal to this value. If no existingVersion is specified, the ingestion will always overwrite any existing data for the instance (for the specified container or instance). If existingVersion is set to 0, the upsert will behave as an insert, so it will fail the bulk if the instance already exists. If skipOnVersionConflict is set on the ingestion request, then the instance will be skipped instead of failing the ingestion request.
sources (list[NodeOrEdgeData] | None) – List of source properties to write. The properties are from the instance and/or container the container(s) making up this node.

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.instances.InstanceApplyResult( instance_type: Literal['node', 'edge'], space: str, external_id: str, version: int, was_modified: bool, last_updated_time: int, created_time: int, )

Bases: InstanceCore, ABC

A node or edge. This represents the update on the instance.

Parameters:

instance_type (Literal['node', 'edge']) – The type of instance.
space (str) – The workspace for the instance, a unique identifier for the space.
external_id (str) – Combined with the space is the unique identifier of the instance.
version (int) – DMS version of the instance.
was_modified (bool) – Whether the instance was modified by the ingestion.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.

class cognite.client.data_classes.data_modeling.instances.InstanceCore( space: str, external_id: str, instance_type: Literal['node', 'edge'], )

Bases: DataModelingResource, ABC

A node or edge

Parameters:

space (str) – The workspace for the instance, a unique identifier for the space.
external_id (str) – Combined with the space is the unique identifier of the instance.
instance_type (Literal['node', 'edge']) – The type of instance.

class cognite.client.data_classes.data_modeling.instances.InstanceInspectResult( space: str, external_id: str, instance_type: Literal['node', 'edge'], inspection_results: InspectionResults, )

Bases: CogniteResource

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.instances.InstanceInspectResultList( resources: Sequence[T_CogniteResource], ): Bases: CogniteResourceList[InstanceInspectResult]

class cognite.client.data_classes.data_modeling.instances.InstanceInspectResults( nodes: 'InstanceInspectResultList', edges: 'InstanceInspectResultList', ): Bases: object

class cognite.client.data_classes.data_modeling.instances.InstanceSort( property: list[str] | tuple[str, ...], direction: Literal['ascending', 'descending'] = 'ascending', nulls_first: bool | None = None, ): Bases: DataModelingSort

class cognite.client.data_classes.data_modeling.instances.InstancesApply( nodes: NodeApplyList, edges: EdgeApplyList, )

Bases: object

This represents the write request of an instance query

Parameters:

nodes (NodeApplyList) – A list of nodes.
edges (EdgeApplyList) – A list of edges.

class cognite.client.data_classes.data_modeling.instances.InstancesApplyResult( nodes: NodeApplyResultList, edges: EdgeApplyResultList, )

Bases: object

This represents the write result of an instance query

Parameters:

nodes (NodeApplyResultList) – A list of nodes.
edges (EdgeApplyResultList) – A list of edges.

class cognite.client.data_classes.data_modeling.instances.InstancesDeleteResult( nodes: list[NodeId], edges: list[EdgeId], )

Bases: object

This represents the delete result of an instance query

Parameters:

nodes (list[NodeId]) – A list of node ids.
edges (list[EdgeId]) – A list of edge ids.

class cognite.client.data_classes.data_modeling.instances.InstancesResult( nodes: NodeList[T_Node], edges: EdgeList[T_Edge], )

Bases: Generic[T_Node, T_Edge]

This represents the read result of an instance query

Parameters:

nodes (NodeList[T_Node]) – A list of nodes.
edges (EdgeList[T_Edge]) – A list of edges.

class cognite.client.data_classes.data_modeling.instances.InvolvedContainers: Bases: InspectOperation

class cognite.client.data_classes.data_modeling.instances.InvolvedViews(all_versions: 'bool' = False): Bases: InspectOperation

class cognite.client.data_classes.data_modeling.instances.Node( space: str, external_id: str, version: int, last_updated_time: int, created_time: int, deleted_time: int | None, properties: Properties | None, type: DirectRelationReference | tuple[str, str] | None, )

Bases: Instance[NodeApply]

A node. This is the read version of the node.

Parameters:

space (str) – The workspace for the node, a unique identifier for the space.
external_id (str) – Combined with the space is the unique identifier of the node.
version (int) – Current version of the node.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
deleted_time (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds. Timestamp when the instance was soft deleted. Note that deleted instances are filtered out of query results, but present in sync results
properties (Properties | None) – Properties of the node.
type (DirectRelationReference | tuple[str, str] | None) – Direct relation pointing to the type node.

as_apply() → NodeApply

This is a convenience method for converting from the read version of the Node to the write version (NodeApply).

Warning

Properties can be read-only and then the converted write node will fail on ingestion. Examples are auto-increment properties, or system-controlled ones like path or root (CogniteAsset), or isUploaded (CogniteFile).

Returns:: A write node, NodeApply, with all properties (even read-only) copied over.
Return type:: NodeApply

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.instances.NodeApply( space: str, external_id: str, existing_version: int | None = None, sources: list[NodeOrEdgeData] | None = None, type: DirectRelationReference | tuple[str, str] | None = None, )

Bases: InstanceApply[NodeApply]

A node. This is the write version of the node.

Parameters:

space (str) – The workspace for the node, a unique identifier for the space.
external_id (str) – Combined with the space is the unique identifier of the node.
existing_version (int | None) – Fail the ingestion request if the node’s version is greater than or equal to this value. If no existingVersion is specified, the ingestion will always overwrite any existing data for the edge (for the specified container or node). If existingVersion is set to 0, the upsert will behave as an insert, so it will fail the bulk if the item already exists. If skipOnVersionConflict is set on the ingestion request, then the item will be skipped instead of failing the ingestion request.
sources (list[NodeOrEdgeData] | None) – List of source properties to write. The properties are from the node and/or container the container(s) making up this node.
type (DirectRelationReference | tuple[str, str] | None) – Direct relation pointing to the type node.

as_write() → Self: Returns this NodeApply instance

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.instances.NodeApplyList( resources: Sequence[T_CogniteResource], )

Bases: CogniteResourceList[NodeApply]

as_ids() → list[NodeId]

Convert the list of nodes to a list of node ids.

Returns:: A list of node ids.
Return type:: list[NodeId]

class cognite.client.data_classes.data_modeling.instances.NodeApplyResult( space: str, external_id: str, version: int, was_modified: bool, last_updated_time: int, created_time: int, )

Bases: InstanceApplyResult

A node. This represents the update on the node.

Parameters:

space (str) – The workspace for the node, a unique identifier for the space.
external_id (str) – Combined with the space is the unique identifier of the node.
version (int) – Current version of the node.
was_modified (bool) – Whether the node was modified by the ingestion.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.

class cognite.client.data_classes.data_modeling.instances.NodeApplyResultList( resources: Sequence[T_CogniteResource], )

Bases: CogniteResourceList[NodeApplyResult]

as_ids() → list[NodeId]

Convert the list of nodes to a list of node ids.

Returns:: A list of node ids.
Return type:: list[NodeId]

class cognite.client.data_classes.data_modeling.instances.NodeList( resources: Sequence[T_Node], typing: TypeInformation | None = None, debug: DebugInfo | None = None, )

Bases: DataModelingInstancesList[NodeApply, T_Node]

as_ids() → list[NodeId]

Convert the list of nodes to a list of node ids.

Returns:: A list of node ids.
Return type:: list[NodeId]

as_write() → NodeApplyList: Returns this NodeList as a NodeApplyList

dump_raw(camel_case: bool = True) → dict[str, Any]

This method dumps the list with extra information in addition to the items.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the list.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.instances.NodeListWithCursor( resources: Sequence[T_Node], cursor: str | None, typing: TypeInformation | None = None, debug: DebugInfo | None = None, )

Bases: NodeList[T_Node]

extend( other: NodeListWithCursor, ) → None: S.extend(iterable) – extend sequence by appending elements from the iterable

Bases: CogniteResource

This represents the data values of a node or edge.

Parameters:

source (ContainerId | ViewId) – The container or view the node or edge property is in
properties (Mapping[str, PropertyValueWrite]) – The properties of the node or edge.

dump(camel_case: bool = True) → dict

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

get(k[, d]) → D[k] if k in D, else d. d defaults to None.

items() → a set-like object providing a view on D's items

keys() → a set-like object providing a view on D's keys

values() → an object providing a view on D's values

class cognite.client.data_classes.data_modeling.instances.PropertyOptions(identifier: str | None = None)

Bases: object

This is a descriptor class for instance properties in a typed class.

It is used when you have a property that has a different name in the Data Model compared to the name in the Python class.

Parameters:: identifier (str | None) – The name of the property in the Data Model. Defaults to the name of the property in the Python class.

class cognite.client.data_classes.data_modeling.instances.TargetUnit(property: 'str', unit: 'UnitReference | UnitSystemReference')

Bases: CogniteResource

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.instances.TypeInformation( data: dict[str, dict[str, dict[str, TypePropertyDefinition]]] | None = None, )

Bases: UserDict, CogniteResource

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

to_pandas() → pd.DataFrame

Convert the instance into a pandas DataFrame.

Parameters:

expand_metadata (bool) – Expand the metadata into separate rows (default: False).
metadata_prefix (str) – Prefix to use for the metadata rows, if expanded.
ignore (list[str] | None) – List of row keys to skip when converting to a data frame. Is applied before expansions.
camel_case (bool) – Convert attribute names to camel case (e.g. externalId instead of external_id). Does not affect custom data like metadata if expanded.
convert_timestamps (bool) – Convert known attributes storing CDF timestamps (milliseconds since epoch) to datetime. Does not affect custom data like metadata.

Returns:

The dataframe.

Return type:

pandas.DataFrame

class cognite.client.data_classes.data_modeling.instances.TypePropertyDefinition( type: 'PropertyType', nullable: 'bool' = True, auto_increment: 'bool' = False, immutable: 'bool' = False, default_value: 'str | int | dict | None' = None, name: 'str | None' = None, description: 'str | None' = None, )

Bases: CogniteResource

dump( camel_case: bool = True, return_flat_dict: bool = False, ) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.instances.TypedEdge( space: str, external_id: str, version: int, type: DirectRelationReference | tuple[str, str], last_updated_time: int, created_time: int, start_node: DirectRelationReference | tuple[str, str], end_node: DirectRelationReference | tuple[str, str], deleted_time: int | None, ): Bases: Edge, TypedInstance

class cognite.client.data_classes.data_modeling.instances.TypedEdgeApply( space: str, external_id: str, type: DirectRelationReference | tuple[str, str], start_node: DirectRelationReference | tuple[str, str], end_node: DirectRelationReference | tuple[str, str], existing_version: int | None = None, ): Bases: EdgeApply, TypedInstance

class cognite.client.data_classes.data_modeling.instances.TypedInstance: Bases: ABC

class cognite.client.data_classes.data_modeling.instances.TypedNode( space: str, external_id: str, version: int, last_updated_time: int, created_time: int, deleted_time: int | None, type: DirectRelationReference | tuple[str, str] | None, ): Bases: Node, TypedInstance

class cognite.client.data_classes.data_modeling.instances.TypedNodeApply( space: str, external_id: str, existing_version: int | None = None, type: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, )

Bases: NodeApply, TypedInstance

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.instances.WritableInstanceCore( space: str, external_id: str, instance_type: Literal['node', 'edge'], ): Bases: WritableDataModelingResource[T_CogniteResource], ABC

Instances query data classes

class cognite.client.data_classes.data_modeling.query.EdgeResultSetExpression( from_: str | None = None, filter: ~cognite.client.data_classes.filters.Filter | None = None, limit: int | None = None, sort: list[~cognite.client.data_classes.data_modeling.instances.InstanceSort] = <factory>, direction: ~typing.Literal['outwards', 'inwards'] = 'outwards', chain_to: ~typing.Literal['destination', 'source'] = 'destination', max_distance: int | None = None, node_filter: ~cognite.client.data_classes.filters.Filter | None = None, termination_filter: ~cognite.client.data_classes.filters.Filter | None = None, limit_each: int | None = None, post_sort: list[~cognite.client.data_classes.data_modeling.instances.InstanceSort] = <factory>, )

Bases: NodeOrEdgeResultSetExpression

Describes how to query for edges in the data model.

Parameters:

from (str | None) – Chain your result expression from this edge.
filter (Filter | None) – Filter the result set based on this filter.
limit (int | None) – Limit the result set to this number of instances.
sort (list[InstanceSort]) – Sort the result set based on this list of sort criteria.
direction (Literal['outwards', 'inwards']) – The direction to use when traversing.
chain_to (Literal['destination', 'source']) – Control which side of the edge to chain to. The chain_to option is only applicable if the result rexpression referenced in from contains edges. source will chain to start if you’re following edges outwards i.e direction=outwards. If you’re following edges inwards i.e direction=inwards, it will chain to end. destination (default) will chain to end if you’re following edges outwards i.e direction=outwards. If you’re following edges inwards i.e, direction=inwards, it will chain to start.
max_distance (int | None) – The largest - max - number of levels to traverse.
node_filter (Filter | None) – Filter the result set based on this filter.
termination_filter (Filter | None) – Filter the result set based on this filter.
limit_each (int | None) – Limit the number of returned edges for each of the source nodes in the result set. The indicated uniform limit applies to the result set from the referenced from. limitEach only has meaning when you also specify maxDistance=1 and from.
post_sort (list[InstanceSort]) – Sort the result set based on this list of sort criteria.

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.query.EdgeResultSetExpressionSync( from_: str | None = None, filter: ~cognite.client.data_classes.filters.Filter | None = None, limit: int | None = None, direction: ~typing.Literal['outwards', 'inwards'] = 'outwards', chain_to: ~typing.Literal['destination', 'source'] = 'destination', skip_already_deleted: bool = True, sync_mode: ~typing.Literal['one_phase', 'two_phase', 'no_backfill'] | None = None, backfill_sort: list[~cognite.client.data_classes.data_modeling.instances.InstanceSort] = <factory>, max_distance: int | None = None, node_filter: ~cognite.client.data_classes.filters.Filter | None = None, termination_filter: ~cognite.client.data_classes.filters.Filter | None = None, )

Bases: ResultSetExpressionSync

Describes how to query for edges in the data model.

Parameters:

from (str | None) – Chain your result expression from this edge.
filter (Filter | None) – Filter the result set based on this filter.
limit (int | None) – Limit the result set to this number of instances.
direction (Literal['outwards', 'inwards']) – The direction to use when traversing.
chain_to (Literal['destination', 'source']) – Control which side of the edge to chain to. The chain_to option is only applicable if the result rexpression referenced in from contains edges. source will chain to start if you’re following edges outwards i.e direction=outwards. If you’re following edges inwards i.e direction=inwards, it will chain to end. destination (default) will chain to end if you’re following edges outwards i.e direction=outwards. If you’re following edges inwards i.e, direction=inwards, it will chain to start.
skip_already_deleted (bool) – If set to False, the API will return instances that have been soft deleted before sync was initiated. Soft deletes that happen after the sync is initiated and a cursor generated, are always included in the result. Soft deleted instances are identified by having deletedTime set.
sync_mode (SyncMode | None) – Specify whether to sync instances in a single phase; in a backfill phase followed by live updates, or without any backfill. Only valid for sync operations.
backfill_sort (list[InstanceSort]) – Sort the result set during the backfill phase of a two phase sync. Only valid with sync_mode = “two_phase”. The sort must be backed by a cursorable index.
max_distance (int | None) – The largest - max - number of levels to traverse.
node_filter (Filter | None) – Filter the result set based on this filter.
termination_filter (Filter | None) – Filter the result set based on this filter.

dump( camel_case: bool = True, ) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.query.Intersection( intersection: 'Sequence[str | SetOperation]', except_: 'SequenceNotStr[str] | None' = None, limit: 'int | None' = None, )

Bases: SetOperation

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.query.NodeOrEdgeResultSetExpression( from_: 'str | None' = None, filter: 'Filter | None' = None, limit: 'int | None' = None, sort: 'list[InstanceSort]' = <factory>, direction: "Literal['outwards', 'inwards']" = 'outwards', chain_to: "Literal['destination', 'source']" = 'destination', ): Bases: ResultSetExpression, ABC

class cognite.client.data_classes.data_modeling.query.NodeResultSetExpression( from_: str | None = None, filter: Filter | None = None, sort: list[InstanceSort] | None = None, limit: int | None = None, through: list[str] | tuple[str, str, str] | PropertyId | None = None, direction: Literal['outwards', 'inwards'] = 'outwards', chain_to: Literal['destination', 'source'] = 'destination', )

Bases: NodeOrEdgeResultSetExpression

Describes how to query for nodes in the data model.

Parameters:

from (str | None) – Chain your result-expression based on this view.
filter (Filter | None) – Filter the result set based on this filter.
sort (list[InstanceSort] | None) – Sort the result set based on this list of sort criteria.
limit (int | None) – Limit the result set to this number of instances.
through (list[str] | tuple[str, str, str] | PropertyId | None) – Chain your result-expression through this container or view. The property must be a reference to a direct relation property. from_ must be defined. The tuple must be on the form (space, container, property) or (space, view/version, property).
direction (Literal['outwards', 'inwards']) – The direction to use when traversing direct relations. Only applicable when through is specified.
chain_to (Literal['destination', 'source']) – Control which side of the edge to chain to. The chain_to option is only applicable if the result rexpression referenced in from contains edges. source will chain to start if you’re following edges outwards i.e direction=outwards. If you’re following edges inwards i.e direction=inwards, it will chain to end. destination (default) will chain to end if you’re following edges outwards i.e direction=outwards. If you’re following edges inwards i.e, direction=inwards, it will chain to start.

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.query.NodeResultSetExpressionSync( from_: str | None = None, filter: Filter | None = None, limit: int | None = None, through: list[str] | tuple[str, str, str] | PropertyId | None = None, direction: Literal['outwards', 'inwards'] = 'outwards', chain_to: Literal['destination', 'source'] = 'destination', skip_already_deleted: bool = True, sync_mode: Literal['one_phase', 'two_phase', 'no_backfill'] | None = None, backfill_sort: list[InstanceSort] | None = None, )

Bases: ResultSetExpressionSync

Describes how to query for nodes in the data model.

Parameters:

from (str | None) – Chain your result-expression based on this view.
filter (Filter | None) – Filter the result set based on this filter.
limit (int | None) – Limit the result set to this number of instances.
through (list[str] | tuple[str, str, str] | PropertyId | None) – Chain your result-expression through this container or view. The property must be a reference to a direct relation property. from_ must be defined. The tuple must be on the form (space, container, property) or (space, view/version, property).
direction (Literal['outwards', 'inwards']) – The direction to use when traversing direct relations. Only applicable when through is specified.
chain_to (Literal['destination', 'source']) – Control which side of the edge to chain to. The chain_to option is only applicable if the result rexpression referenced in from contains edges. source will chain to start if you’re following edges outwards i.e direction=outwards. If you’re following edges inwards i.e direction=inwards, it will chain to end. destination (default) will chain to end if you’re following edges outwards i.e direction=outwards. If you’re following edges inwards i.e, direction=inwards, it will chain to start.
skip_already_deleted (bool) – If set to False, the API will return instances that have been soft deleted before sync was initiated. Soft deletes that happen after the sync is initiated and a cursor generated, are always included in the result. Soft deleted instances are identified by having deletedTime set.
sync_mode (Literal['one_phase', 'two_phase', 'no_backfill'] | None) – Specify whether to sync instances in a single phase; in a backfill phase followed by live updates, or without any backfill. Only valid for sync operations.
backfill_sort (list[InstanceSort] | None) – Sort the result set during the backfill phase of a two phase sync. Only valid with sync_mode = “two_phase”. The sort must be backed by a cursorable index.

dump( camel_case: bool = True, ) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.query.Query(with_: ~collections.abc.MutableMapping[str, ~cognite.client.data_classes.data_modeling.query._T_ResultSetExpression], select: ~collections.abc.MutableMapping[str, ~cognite.client.data_classes.data_modeling.query._T_Select], parameters: ~collections.abc.Mapping[str, str | int | float | bool | dict | list[str] | list[int] | list[float] | list[bool] | list[dict]] = <factory>, cursors: ~collections.abc.Mapping[str, str | None] = <factory>)

Bases: QueryBase[ResultSetExpression, Select]

Query allows you to do advanced queries on the data model.

Parameters:

with (MutableMapping[str, ResultSetExpression]) – A dictionary of result set expressions to use in the query. The keys are used to reference the result set expressions in the select and parameters.
select (MutableMapping[str, Select]) – A dictionary of select expressions to use in the query. The keys must match the keys in the with_ dictionary. The select expressions define which properties to include in the result set.
parameters (Mapping[str, PropertyValue]) – Values in filters can be parameterised. Parameters are provided as part of the query object, and referenced in the filter itself.
cursors (Mapping[str, str | None]) – A dictionary of cursors to use in the query. These allow for pagination.

class cognite.client.data_classes.data_modeling.query.QueryBase(with_: ~collections.abc.MutableMapping[str, ~cognite.client.data_classes.data_modeling.query._T_ResultSetExpression], select: ~collections.abc.MutableMapping[str, ~cognite.client.data_classes.data_modeling.query._T_Select], parameters: ~collections.abc.Mapping[str, str | int | float | bool | dict | list[str] | list[int] | list[float] | list[bool] | list[dict]] = <factory>, cursors: ~collections.abc.Mapping[str, str | None] = <factory>)

Bases: CogniteResource, ABC, Generic[_T_ResultSetExpression, _T_Select]

Abstract base class for normal queries and sync queries

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.query.QueryResult(*args: Any, **kwargs: Any): Bases: UserDict

class cognite.client.data_classes.data_modeling.query.QuerySync(with_: ~collections.abc.MutableMapping[str, ~cognite.client.data_classes.data_modeling.query._T_ResultSetExpression], select: ~collections.abc.MutableMapping[str, ~cognite.client.data_classes.data_modeling.query._T_Select], parameters: ~collections.abc.Mapping[str, str | int | float | bool | dict | list[str] | list[int] | list[float] | list[bool] | list[dict]] = <factory>, cursors: ~collections.abc.Mapping[str, str | None] = <factory>, allow_expired_cursors_and_accept_missed_deletes: bool = False)

Bases: QueryBase[ResultSetExpressionSync, SelectSync]

Sync allows you to do subscribe to changes in instances.

Parameters:

with (MutableMapping[str, ResultSetExpressionSync]) – A dictionary of result set expressions to use in the query. The keys are used to reference the result set expressions in the select and parameters.
select (MutableMapping[str, SelectSync]) – A dictionary of select expressions to use in the query. The keys must match the keys in the with_ dictionary. The select expressions define which properties to include in the result set.
parameters (Mapping[str, PropertyValue]) – Values in filters can be parameterised. Parameters are provided as part of the query object, and referenced in the filter itself.
cursors (Mapping[str, str | None]) – A dictionary of cursors to use in the query. These allow for pagination.
allow_expired_cursors_and_accept_missed_deletes (bool) – Sync cursors expire after 3 days because soft-deleted instances are cleaned up after this grace period, so a client using a cursor older than that risks missing deletes. If set to True, the API will allow the use of expired cursors.

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.query.ResultSetExpression: Bases: ResultSetExpressionBase, ABC

class cognite.client.data_classes.data_modeling.query.ResultSetExpressionBase: Bases: CogniteResource, ABC

class cognite.client.data_classes.data_modeling.query.ResultSetExpressionSync( from_: 'str | None' = None, filter: 'Filter | None' = None, limit: 'int | None' = None, direction: "Literal['outwards', 'inwards']" = 'outwards', chain_to: "Literal['destination', 'source']" = 'destination', skip_already_deleted: 'bool' = True, sync_mode: 'SyncMode | None' = None, backfill_sort: 'list[InstanceSort]' = <factory>, ): Bases: ResultSetExpressionBase, ABC

class cognite.client.data_classes.data_modeling.query.Select( sources: 'list[SourceSelector]' = <factory>, sort: 'list[InstanceSort]' = <factory>, limit: 'int | None' = None, )

Bases: SelectBase

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.query.SelectBase(sources: 'list[SourceSelector]' = <factory>)

Bases: CogniteResource, ABC

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.query.SelectSync(sources: 'list[SourceSelector]' = <factory>): Bases: SelectBase

class cognite.client.data_classes.data_modeling.query.SetOperation: Bases: ResultSetExpression, ABC

class cognite.client.data_classes.data_modeling.query.SourceSelector( source: 'ViewId', properties: 'list[str] | None' = None, target_units: 'list[TargetUnit] | None' = None, )

Bases: CogniteResource

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.query.Union( union: 'Sequence[str | SetOperation]', except_: 'SequenceNotStr[str] | None' = None, limit: 'int | None' = None, )

Bases: SetOperation

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.query.UnionAll( union_all: 'Sequence[str | SetOperation]', except_: 'SequenceNotStr[str] | None' = None, limit: 'int | None' = None, )

Bases: SetOperation

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

Data Modeling ID data classes

class cognite.client.data_classes.data_modeling.ids.AbstractDataclass(*args: 'Any', **kwargs: 'Any'): Bases: ABC

class cognite.client.data_classes.data_modeling.ids.ContainerId(space: 'str', external_id: 'str'): Bases: DataModelingId

class cognite.client.data_classes.data_modeling.ids.DataModelId(space: 'str', external_id: 'str', version: 'str | None' = None): Bases: VersionedDataModelingId

class cognite.client.data_classes.data_modeling.ids.DataModelingId(space: 'str', external_id: 'str'): Bases: AbstractDataclass

class cognite.client.data_classes.data_modeling.ids.EdgeId(space: 'str', external_id: 'str'): Bases: InstanceId

class cognite.client.data_classes.data_modeling.ids.IdLike(*args, **kwargs): Bases: Protocol

class cognite.client.data_classes.data_modeling.ids.NodeId(space: 'str', external_id: 'str'): Bases: InstanceId

class cognite.client.data_classes.data_modeling.ids.PropertyId(source: 'ViewId | ContainerId', property: 'str')

Bases: CogniteResource

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.ids.VersionedDataModelingId( space: 'str', external_id: 'str', version: 'str | None' = None, ): Bases: AbstractDataclass

class cognite.client.data_classes.data_modeling.ids.VersionedIdLike(*args, **kwargs): Bases: IdLike, Protocol

class cognite.client.data_classes.data_modeling.ids.ViewId(space: 'str', external_id: 'str', version: 'str | None' = None): Bases: VersionedDataModelingId

Statistics

`AsyncCogniteClient.data_modeling.statistics.project`()	Retrieve project-wide usage data and limits.
`AsyncCogniteClient.data_modeling.statistics.spaces.list`()	Retrieve usage for all spaces.
`AsyncCogniteClient.data_modeling.statistics.spaces.retrieve`(space)	Retrieve usage data and limits per space.

Data modeling statistics data classes

class cognite.client.data_classes.data_modeling.statistics.CountLimit(count: int, limit: int)

Bases: CogniteResource

Usage and limits for a specific resource in the data modeling API.

count

The current usage count for the resource.

Type:: int

limit

The maximum allowed limit for the resource.

Type:: int

class cognite.client.data_classes.data_modeling.statistics.InstanceStatistics( edges: int, soft_deleted_edges: int, nodes: int, soft_deleted_nodes: int, instances: int, instances_limit: int, soft_deleted_instances: int, soft_deleted_instances_limit: int, )

Bases: CogniteResource

Statistics for instances in the data modeling API.

edges

Number of edges in the project.

Type:: int

soft_deleted_edges

Number of soft-deleted edges in the project.

Type:: int

nodes

Number of nodes in the project.

Type:: int

soft_deleted_nodes

Number of soft-deleted nodes in the project.

Type:: int

instances

Total number of instances in the project.

Type:: int

instances_limit

Maximum number of instances allowed in the project.

Type:: int

soft_deleted_instances

Total number of soft-deleted instances in the project.

Type:: int

soft_deleted_instances_limit

Maximum number of soft-deleted instances allowed in the project.

Type:: int

class cognite.client.data_classes.data_modeling.statistics.ProjectStatistics( spaces: CountLimit, containers: CountLimit, views: CountLimit, data_models: CountLimit, container_properties: CountLimit, instances: InstanceStatistics, concurrent_read_limit: int, concurrent_write_limit: int, concurrent_delete_limit: int, )

Bases: CogniteResource

Statistics for a project in the data modeling API.

spaces

Usage and limits for spaces in the project

Type:: CountLimit

containers

Usage and limits for containers in the project

Type:: CountLimit

views

Usage and limits for views including all versions in the project

Type:: CountLimit

data_models

Usage and limits for data models including all versions in the project

Type:: CountLimit

container_properties

Usage and limits for sum of container properties in the project

Type:: CountLimit

instances

Usage and limits for number of instances in the project

Type:: InstanceStatistics

concurrent_read_limit

Maximum number of concurrent read operations allowed in the project

Type:: int

concurrent_write_limit

Maximum number of concurrent write operations allowed in the project

Type:: int

concurrent_delete_limit

Maximum number of concurrent delete operations allowed in the project

Type:: int

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.statistics.SpaceStatistics( space: str, containers: int, views: int, data_models: int, edges: int, soft_deleted_edges: int, nodes: int, soft_deleted_nodes: int, )

Bases: CogniteResource

Statistics for a space in the data modeling API.

space

The space name

Type:: str

containers

Number of containers in the space.

Type:: int

views

Number of views in the space.

Type:: int

data_models

Number of data models in the space.

Type:: int

nodes

Number of nodes in the space.

Type:: int

edges

Number of edges in the space.

Type:: int

soft_deleted_nodes

Number of soft-deleted nodes in the space.

Type:: int

soft_deleted_edges

Number of soft-deleted edges in the space.

Type:: int

class cognite.client.data_classes.data_modeling.statistics.SpaceStatisticsList( resources: Sequence[T_CogniteResource], ): Bases: CogniteResourceList[SpaceStatistics]

GraphQL

`AsyncCogniteClient.data_modeling.graphql.apply_dml`(id, dml)	Apply the DML for a given data model.
`AsyncCogniteClient.data_modeling.graphql.query`(id, ...)	Execute a GraphQl query against a given data model.

Core Data Model

class cognite.client.data_classes.data_modeling.cdm.v1.Cognite360Image( space: str, external_id: str, version: int, last_updated_time: int, created_time: int, *, translation_x: float | None = None, translation_y: float | None = None, translation_z: float | None = None, euler_rotation_x: float | None = None, euler_rotation_y: float | None = None, euler_rotation_z: float | None = None, scale_x: float | None = None, scale_y: float | None = None, scale_z: float | None = None, front: DirectRelationReference | None = None, back: DirectRelationReference | None = None, left: DirectRelationReference | None = None, right: DirectRelationReference | None = None, top: DirectRelationReference | None = None, bottom: DirectRelationReference | None = None, collection_360: DirectRelationReference | None = None, station_360: DirectRelationReference | None = None, taken_at: datetime | None = None, type: DirectRelationReference | None = None, deleted_time: int | None = None, )

Bases: _Cognite360ImageProperties, TypedNode

This represents the reading format of Cognite 360 image.

It is used when data is read from CDF.

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite 360 image.
version (int) – DMS version.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
translation_x (float | None) – The displacement of the object along the X-axis in the 3D coordinate system
translation_y (float | None) – The displacement of the object along the Y-axis in the 3D coordinate system
translation_z (float | None) – The displacement of the object along the Z-axis in the 3D coordinate system
euler_rotation_x (float | None) – The rotation of the object around the X-axis in radians
euler_rotation_y (float | None) – The rotation of the object around the Y-axis in radians
euler_rotation_z (float | None) – The rotation of the object around the Z-axis in radians
scale_x (float | None) – The scaling factor applied to the object along the X-axis
scale_y (float | None) – The scaling factor applied to the object along the Y-axis
scale_z (float | None) – The scaling factor applied to the object along the Z-axis
front (DirectRelationReference | None) – Direct relation to a file holding the front projection of the cube map
back (DirectRelationReference | None) – Direct relation to a file holding the back projection of the cube map
left (DirectRelationReference | None) – Direct relation to a file holding the left projection of the cube map
right (DirectRelationReference | None) – Direct relation to a file holding the right projection of the cube map
top (DirectRelationReference | None) – Direct relation to a file holding the top projection of the cube map
bottom (DirectRelationReference | None) – Direct relation to a file holding the bottom projection of the cube map
collection_360 (DirectRelationReference | None) – Direct relation to Cognite360ImageCollection
station_360 (DirectRelationReference | None) – Direct relation to Cognite3DGroup instance that groups different Cognite360Image instances to the same station
taken_at (datetime | None) – The timestamp when the 6 photos were taken
type (DirectRelationReference | None) – Direct relation pointing to the type node.
deleted_time (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds. Timestamp when the instance was soft deleted. Note that deleted instances are filtered out of query results, but present in sync results

class cognite.client.data_classes.data_modeling.cdm.v1.Cognite360ImageAnnotation( space: str, external_id: str, type: DirectRelationReference, start_node: DirectRelationReference, end_node: DirectRelationReference, version: int, last_updated_time: int, created_time: int, *, name: str | None = None, description: str | None = None, tags: list[str] | None = None, aliases: list[str] | None = None, source_id: str | None = None, source_context: str | None = None, source: DirectRelationReference | None = None, source_created_time: datetime | None = None, source_updated_time: datetime | None = None, source_created_user: str | None = None, source_updated_user: str | None = None, confidence: float | None = None, status: Literal['Approved', 'Rejected', 'Suggested'] | None = None, polygon: list[float] | None = None, format_version: str | None = None, deleted_time: int | None = None, )

Bases: _Cognite360ImageAnnotationProperties, TypedEdge

This represents the reading format of Cognite 360 image annotation.

It is used when data is read from CDF.

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite 360 image annotation.
type (DirectRelationReference) – The type of edge.
start_node (DirectRelationReference) – Reference to the direct relation. The reference consists of a space and an external-id.
end_node (DirectRelationReference) – Reference to the direct relation. The reference consists of a space and an external-id.
version (int) – DMS version.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
name (str | None) – Name of the instance
description (str | None) – Description of the instance
tags (list[str] | None) – Text based labels for generic use, limited to 1000
aliases (list[str] | None) – Alternative names for the node
source_id (str | None) – Identifier from the source system
source_context (str | None) – Context of the source id. For systems where the sourceId is globally unique, the sourceContext is expected to not be set.
source (DirectRelationReference | None) – Direct relation to a source system
source_created_time (datetime | None) – When the instance was created in source system (if available)
source_updated_time (datetime | None) – When the instance was last updated in the source system (if available)
source_created_user (str | None) – User identifier from the source system on who created the source data. This identifier is not guaranteed to match the user identifiers in CDF
source_updated_user (str | None) – User identifier from the source system on who last updated the source data. This identifier is not guaranteed to match the user identifiers in CDF
confidence (float | None) – The confidence that the annotation is a good match
status (Literal['Approved', 'Rejected', 'Suggested'] | None) – The status of the annotation
polygon (list[float] | None) – List of floats representing the polygon. Format depends on formatVersion
format_version (str | None) – Specifies the storage representation for the polygon
deleted_time (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds. Timestamp when the instance was soft deleted. Note that deleted instances are filtered out of query results, but present in sync results

class cognite.client.data_classes.data_modeling.cdm.v1.Cognite360ImageAnnotationApply(space: str, external_id: str, type: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str], start_node: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str], end_node: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str], *, name: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, description: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, tags: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, aliases: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_id: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_context: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_created_time: ~datetime.datetime | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_updated_time: ~datetime.datetime | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_created_user: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_updated_user: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, confidence: float | None | ~cognite.client._constants.Omitted = <Omitted parameter>, status: ~typing.Literal['Approved', 'Rejected', 'Suggested'] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, polygon: list[float] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, format_version: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, existing_version: int | None = None)

Bases: _Cognite360ImageAnnotationProperties, TypedEdgeApply

This represents the writing format of Cognite 360 image annotation.

It is used when data is written to CDF.

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite 360 image annotation.
type (DirectRelationReference | tuple[str, str]) – The type of edge.
start_node (DirectRelationReference | tuple[str, str]) – Reference to the direct relation. The reference consists of a space and an external-id.
end_node (DirectRelationReference | tuple[str, str]) – Reference to the direct relation. The reference consists of a space and an external-id.
name (str | None | Omitted) – Name of the instance
description (str | None | Omitted) – Description of the instance
tags (list[str] | None | Omitted) – Text based labels for generic use, limited to 1000
aliases (list[str] | None | Omitted) – Alternative names for the node
source_id (str | None | Omitted) – Identifier from the source system
source_context (str | None | Omitted) – Context of the source id. For systems where the sourceId is globally unique, the sourceContext is expected to not be set.
source (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation to a source system
source_created_time (datetime | None | Omitted) – When the instance was created in source system (if available)
source_updated_time (datetime | None | Omitted) – When the instance was last updated in the source system (if available)
source_created_user (str | None | Omitted) – User identifier from the source system on who created the source data. This identifier is not guaranteed to match the user identifiers in CDF
source_updated_user (str | None | Omitted) – User identifier from the source system on who last updated the source data. This identifier is not guaranteed to match the user identifiers in CDF
confidence (float | None | Omitted) – The confidence that the annotation is a good match
status (Literal['Approved', 'Rejected', 'Suggested'] | None | Omitted) – The status of the annotation
polygon (list[float] | None | Omitted) – List of floats representing the polygon. Format depends on formatVersion
format_version (str | None | Omitted) – Specifies the storage representation for the polygon
existing_version (int | None) – Fail the ingestion request if the edge’s version is greater than or equal to this value. If no existingVersion is specified, the ingestion will always overwrite any existing data for the edge (for the specified container or edge). If existingVersion is set to 0, the upsert will behave as an insert, so it will fail the bulk if the item already exists. If skipOnVersionConflict is set on the ingestion request, then the item will be skipped instead of failing the ingestion request.

class cognite.client.data_classes.data_modeling.cdm.v1.Cognite360ImageApply( space: str, external_id: str, *, translation_x: float | None | ~cognite.client._constants.Omitted = <Omitted parameter>, translation_y: float | None | ~cognite.client._constants.Omitted = <Omitted parameter>, translation_z: float | None | ~cognite.client._constants.Omitted = <Omitted parameter>, euler_rotation_x: float | None | ~cognite.client._constants.Omitted = <Omitted parameter>, euler_rotation_y: float | None | ~cognite.client._constants.Omitted = <Omitted parameter>, euler_rotation_z: float | None | ~cognite.client._constants.Omitted = <Omitted parameter>, scale_x: float | None | ~cognite.client._constants.Omitted = <Omitted parameter>, scale_y: float | None | ~cognite.client._constants.Omitted = <Omitted parameter>, scale_z: float | None | ~cognite.client._constants.Omitted = <Omitted parameter>, front: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, back: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, left: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, right: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, top: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, bottom: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, collection_360: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, station_360: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, taken_at: ~datetime.datetime | None | ~cognite.client._constants.Omitted = <Omitted parameter>, existing_version: int | None = None, type: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, )

Bases: _Cognite360ImageProperties, TypedNodeApply

This represents the writing format of Cognite 360 image.

It is used when data is written to CDF.

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite 360 image.
translation_x (float | None | Omitted) – The displacement of the object along the X-axis in the 3D coordinate system
translation_y (float | None | Omitted) – The displacement of the object along the Y-axis in the 3D coordinate system
translation_z (float | None | Omitted) – The displacement of the object along the Z-axis in the 3D coordinate system
euler_rotation_x (float | None | Omitted) – The rotation of the object around the X-axis in radians
euler_rotation_y (float | None | Omitted) – The rotation of the object around the Y-axis in radians
euler_rotation_z (float | None | Omitted) – The rotation of the object around the Z-axis in radians
scale_x (float | None | Omitted) – The scaling factor applied to the object along the X-axis
scale_y (float | None | Omitted) – The scaling factor applied to the object along the Y-axis
scale_z (float | None | Omitted) – The scaling factor applied to the object along the Z-axis
front (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation to a file holding the front projection of the cube map
back (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation to a file holding the back projection of the cube map
left (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation to a file holding the left projection of the cube map
right (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation to a file holding the right projection of the cube map
top (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation to a file holding the top projection of the cube map
bottom (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation to a file holding the bottom projection of the cube map
collection_360 (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation to Cognite360ImageCollection
station_360 (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation to Cognite3DGroup instance that groups different Cognite360Image instances to the same station
taken_at (datetime | None | Omitted) – The timestamp when the 6 photos were taken
existing_version (int | None) – Fail the ingestion request if the node’s version is greater than or equal to this value. If no existingVersion is specified, the ingestion will always overwrite any existing data for the node (for the specified container or node). If existingVersion is set to 0, the upsert will behave as an insert, so it will fail the bulk if the item already exists. If skipOnVersionConflict is set on the ingestion request, then the item will be skipped instead of failing the ingestion request.
type (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation pointing to the type node.

class cognite.client.data_classes.data_modeling.cdm.v1.Cognite360ImageCollection( space: str, external_id: str, version: int, last_updated_time: int, created_time: int, *, name: str | None = None, description: str | None = None, tags: list[str] | None = None, aliases: list[str] | None = None, status: Literal['Done', 'Failed', 'Processing', 'Queued'] | None = None, published: bool | None = None, revision_type: Literal['CAD', 'Image360', 'PointCloud'] | None = None, model_3d: DirectRelationReference | None = None, type: DirectRelationReference | None = None, deleted_time: int | None = None, )

Bases: _Cognite360ImageCollectionProperties, TypedNode

This represents the reading format of Cognite 360 image collection.

It is used when data is read from CDF.

Represents a logical collection of Cognite360Image instances

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite 360 image collection.
version (int) – DMS version.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
name (str | None) – Name of the instance
description (str | None) – Description of the instance
tags (list[str] | None) – Text based labels for generic use, limited to 1000
aliases (list[str] | None) – Alternative names for the node
status (Literal['Done', 'Failed', 'Processing', 'Queued'] | None) – The status field.
published (bool | None) – The published field.
revision_type (Literal['CAD', 'Image360', 'PointCloud'] | None) – The revision type field.
model_3d (DirectRelationReference | None) – The model 3d field.
type (DirectRelationReference | None) – Direct relation pointing to the type node.
deleted_time (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds. Timestamp when the instance was soft deleted. Note that deleted instances are filtered out of query results, but present in sync results

class cognite.client.data_classes.data_modeling.cdm.v1.Cognite360ImageCollectionApply( space: str, external_id: str, *, name: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, description: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, tags: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, aliases: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, status: ~typing.Literal['Done', 'Failed', 'Processing', 'Queued'] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, published: bool | None | ~cognite.client._constants.Omitted = <Omitted parameter>, revision_type: ~typing.Literal['CAD', 'Image360', 'PointCloud'] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, model_3d: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, existing_version: int | None = None, type: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, )

Bases: _Cognite360ImageCollectionProperties, TypedNodeApply

This represents the writing format of Cognite 360 image collection.

It is used when data is written to CDF.

Represents a logical collection of Cognite360Image instances

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite 360 image collection.
name (str | None | Omitted) – Name of the instance
description (str | None | Omitted) – Description of the instance
tags (list[str] | None | Omitted) – Text based labels for generic use, limited to 1000
aliases (list[str] | None | Omitted) – Alternative names for the node
status (Literal['Done', 'Failed', 'Processing', 'Queued'] | None | Omitted) – The status field.
published (bool | None | Omitted) – The published field.
revision_type (Literal['CAD', 'Image360', 'PointCloud'] | None | Omitted) – The revision type field.
model_3d (DirectRelationReference | tuple[str, str] | None | Omitted) – The model 3d field.
existing_version (int | None) – Fail the ingestion request if the node’s version is greater than or equal to this value. If no existingVersion is specified, the ingestion will always overwrite any existing data for the node (for the specified container or node). If existingVersion is set to 0, the upsert will behave as an insert, so it will fail the bulk if the item already exists. If skipOnVersionConflict is set on the ingestion request, then the item will be skipped instead of failing the ingestion request.
type (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation pointing to the type node.

class cognite.client.data_classes.data_modeling.cdm.v1.Cognite360ImageModel( space: str, external_id: str, version: int, last_updated_time: int, created_time: int, *, name: str | None = None, description: str | None = None, tags: list[str] | None = None, aliases: list[str] | None = None, model_type: Literal['CAD', 'Image360', 'PointCloud'] | None = None, thumbnail: DirectRelationReference | None = None, type: DirectRelationReference | None = None, deleted_time: int | None = None, )

Bases: _Cognite360ImageModelProperties, TypedNode

This represents the reading format of Cognite 360 image model.

It is used when data is read from CDF.

Navigational aid for traversing Cognite360ImageModel instances

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite 360 image model.
version (int) – DMS version.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
name (str | None) – Name of the instance
description (str | None) – Description of the instance
tags (list[str] | None) – Text based labels for generic use, limited to 1000
aliases (list[str] | None) – Alternative names for the node
model_type (Literal['CAD', 'Image360', 'PointCloud'] | None) – CAD, PointCloud or Image360
thumbnail (DirectRelationReference | None) – Thumbnail of the 3D model
type (DirectRelationReference | None) – Direct relation pointing to the type node.
deleted_time (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds. Timestamp when the instance was soft deleted. Note that deleted instances are filtered out of query results, but present in sync results

class cognite.client.data_classes.data_modeling.cdm.v1.Cognite360ImageModelApply( space: str, external_id: str, *, name: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, description: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, tags: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, aliases: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, model_type: ~typing.Literal['CAD', 'Image360', 'PointCloud'] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, thumbnail: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, existing_version: int | None = None, type: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, )

Bases: _Cognite360ImageModelProperties, TypedNodeApply

This represents the writing format of Cognite 360 image model.

It is used when data is written to CDF.

Navigational aid for traversing Cognite360ImageModel instances

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite 360 image model.
name (str | None | Omitted) – Name of the instance
description (str | None | Omitted) – Description of the instance
tags (list[str] | None | Omitted) – Text based labels for generic use, limited to 1000
aliases (list[str] | None | Omitted) – Alternative names for the node
model_type (Literal['CAD', 'Image360', 'PointCloud'] | None | Omitted) – CAD, PointCloud or Image360
thumbnail (DirectRelationReference | tuple[str, str] | None | Omitted) – Thumbnail of the 3D model
existing_version (int | None) – Fail the ingestion request if the node’s version is greater than or equal to this value. If no existingVersion is specified, the ingestion will always overwrite any existing data for the node (for the specified container or node). If existingVersion is set to 0, the upsert will behave as an insert, so it will fail the bulk if the item already exists. If skipOnVersionConflict is set on the ingestion request, then the item will be skipped instead of failing the ingestion request.
type (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation pointing to the type node.

class cognite.client.data_classes.data_modeling.cdm.v1.Cognite360ImageStation( space: str, external_id: str, version: int, last_updated_time: int, created_time: int, *, name: str | None = None, description: str | None = None, tags: list[str] | None = None, aliases: list[str] | None = None, group_type: Literal['Station360'] | None = None, type: DirectRelationReference | None = None, deleted_time: int | None = None, )

Bases: _Cognite360ImageStationProperties, TypedNode

This represents the reading format of Cognite 360 image station.

It is used when data is read from CDF.

A way to group images across collections. Used for creating visual scan history

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite 360 image station.
version (int) – DMS version.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
name (str | None) – Name of the instance
description (str | None) – Description of the instance
tags (list[str] | None) – Text based labels for generic use, limited to 1000
aliases (list[str] | None) – Alternative names for the node
group_type (Literal['Station360'] | None) – Type of group
type (DirectRelationReference | None) – Direct relation pointing to the type node.
deleted_time (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds. Timestamp when the instance was soft deleted. Note that deleted instances are filtered out of query results, but present in sync results

class cognite.client.data_classes.data_modeling.cdm.v1.Cognite360ImageStationApply( space: str, external_id: str, *, name: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, description: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, tags: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, aliases: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, group_type: ~typing.Literal['Station360'] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, existing_version: int | None = None, type: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, )

Bases: _Cognite360ImageStationProperties, TypedNodeApply

This represents the writing format of Cognite 360 image station.

It is used when data is written to CDF.

A way to group images across collections. Used for creating visual scan history

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite 360 image station.
name (str | None | Omitted) – Name of the instance
description (str | None | Omitted) – Description of the instance
tags (list[str] | None | Omitted) – Text based labels for generic use, limited to 1000
aliases (list[str] | None | Omitted) – Alternative names for the node
group_type (Literal['Station360'] | None | Omitted) – Type of group
existing_version (int | None) – Fail the ingestion request if the node’s version is greater than or equal to this value. If no existingVersion is specified, the ingestion will always overwrite any existing data for the node (for the specified container or node). If existingVersion is set to 0, the upsert will behave as an insert, so it will fail the bulk if the item already exists. If skipOnVersionConflict is set on the ingestion request, then the item will be skipped instead of failing the ingestion request.
type (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation pointing to the type node.

class cognite.client.data_classes.data_modeling.cdm.v1.Cognite3DModel( space: str, external_id: str, version: int, last_updated_time: int, created_time: int, *, name: str | None = None, description: str | None = None, tags: list[str] | None = None, aliases: list[str] | None = None, model_type: Literal['CAD', 'Image360', 'PointCloud'] | None = None, thumbnail: DirectRelationReference | None = None, type: DirectRelationReference | None = None, deleted_time: int | None = None, )

Bases: _Cognite3DModelProperties, TypedNode

This represents the reading format of Cognite 3D model.

It is used when data is read from CDF.

Groups revisions of 3D data of various kinds together (CAD, PointCloud, Image360)

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite 3D model.
version (int) – DMS version.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
name (str | None) – Name of the instance
description (str | None) – Description of the instance
tags (list[str] | None) – Text based labels for generic use, limited to 1000
aliases (list[str] | None) – Alternative names for the node
model_type (Literal['CAD', 'Image360', 'PointCloud'] | None) – CAD, PointCloud or Image360
thumbnail (DirectRelationReference | None) – Thumbnail of the 3D model
type (DirectRelationReference | None) – Direct relation pointing to the type node.
deleted_time (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds. Timestamp when the instance was soft deleted. Note that deleted instances are filtered out of query results, but present in sync results

class cognite.client.data_classes.data_modeling.cdm.v1.Cognite3DModelApply( space: str, external_id: str, *, name: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, description: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, tags: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, aliases: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, model_type: ~typing.Literal['CAD', 'Image360', 'PointCloud'] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, thumbnail: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, existing_version: int | None = None, type: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, )

Bases: _Cognite3DModelProperties, TypedNodeApply

This represents the writing format of Cognite 3D model.

It is used when data is written to CDF.

Groups revisions of 3D data of various kinds together (CAD, PointCloud, Image360)

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite 3D model.
name (str | None | Omitted) – Name of the instance
description (str | None | Omitted) – Description of the instance
tags (list[str] | None | Omitted) – Text based labels for generic use, limited to 1000
aliases (list[str] | None | Omitted) – Alternative names for the node
model_type (Literal['CAD', 'Image360', 'PointCloud'] | None | Omitted) – CAD, PointCloud or Image360
thumbnail (DirectRelationReference | tuple[str, str] | None | Omitted) – Thumbnail of the 3D model
existing_version (int | None) – Fail the ingestion request if the node’s version is greater than or equal to this value. If no existingVersion is specified, the ingestion will always overwrite any existing data for the node (for the specified container or node). If existingVersion is set to 0, the upsert will behave as an insert, so it will fail the bulk if the item already exists. If skipOnVersionConflict is set on the ingestion request, then the item will be skipped instead of failing the ingestion request.
type (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation pointing to the type node.

class cognite.client.data_classes.data_modeling.cdm.v1.Cognite3DObject( space: str, external_id: str, version: int, last_updated_time: int, created_time: int, *, name: str | None = None, description: str | None = None, tags: list[str] | None = None, aliases: list[str] | None = None, x_min: float | None = None, x_max: float | None = None, y_min: float | None = None, y_max: float | None = None, z_min: float | None = None, z_max: float | None = None, type: DirectRelationReference | None = None, deleted_time: int | None = None, )

Bases: _Cognite3DObjectProperties, TypedNode

This represents the reading format of Cognite 3D object.

It is used when data is read from CDF.

This is the virtual position representation of an object in the physical world, connecting an asset to one or more 3D resources

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite 3D object.
version (int) – DMS version.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
name (str | None) – Name of the instance
description (str | None) – Description of the instance
tags (list[str] | None) – Text based labels for generic use, limited to 1000
aliases (list[str] | None) – Alternative names for the node
x_min (float | None) – Lowest X value in bounding box
x_max (float | None) – Highest X value in bounding box
y_min (float | None) – Lowest Y value in bounding box
y_max (float | None) – Highest Y value in bounding box
z_min (float | None) – Lowest Z value in bounding box
z_max (float | None) – Highest Z value in bounding box
type (DirectRelationReference | None) – Direct relation pointing to the type node.
deleted_time (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds. Timestamp when the instance was soft deleted. Note that deleted instances are filtered out of query results, but present in sync results

class cognite.client.data_classes.data_modeling.cdm.v1.Cognite3DObjectApply( space: str, external_id: str, *, name: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, description: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, tags: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, aliases: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, x_min: float | None | ~cognite.client._constants.Omitted = <Omitted parameter>, x_max: float | None | ~cognite.client._constants.Omitted = <Omitted parameter>, y_min: float | None | ~cognite.client._constants.Omitted = <Omitted parameter>, y_max: float | None | ~cognite.client._constants.Omitted = <Omitted parameter>, z_min: float | None | ~cognite.client._constants.Omitted = <Omitted parameter>, z_max: float | None | ~cognite.client._constants.Omitted = <Omitted parameter>, existing_version: int | None = None, type: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, )

Bases: _Cognite3DObjectProperties, TypedNodeApply

This represents the writing format of Cognite 3D object.

It is used when data is written to CDF.

This is the virtual position representation of an object in the physical world, connecting an asset to one or more 3D resources

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite 3D object.
name (str | None | Omitted) – Name of the instance
description (str | None | Omitted) – Description of the instance
tags (list[str] | None | Omitted) – Text based labels for generic use, limited to 1000
aliases (list[str] | None | Omitted) – Alternative names for the node
x_min (float | None | Omitted) – Lowest X value in bounding box
x_max (float | None | Omitted) – Highest X value in bounding box
y_min (float | None | Omitted) – Lowest Y value in bounding box
y_max (float | None | Omitted) – Highest Y value in bounding box
z_min (float | None | Omitted) – Lowest Z value in bounding box
z_max (float | None | Omitted) – Highest Z value in bounding box
existing_version (int | None) – Fail the ingestion request if the node’s version is greater than or equal to this value. If no existingVersion is specified, the ingestion will always overwrite any existing data for the node (for the specified container or node). If existingVersion is set to 0, the upsert will behave as an insert, so it will fail the bulk if the item already exists. If skipOnVersionConflict is set on the ingestion request, then the item will be skipped instead of failing the ingestion request.
type (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation pointing to the type node.

class cognite.client.data_classes.data_modeling.cdm.v1.Cognite3DRevision( space: str, external_id: str, version: int, last_updated_time: int, created_time: int, *, status: Literal['Done', 'Failed', 'Processing', 'Queued'] | None = None, published: bool | None = None, revision_type: Literal['CAD', 'Image360', 'PointCloud'] | None = None, model_3d: DirectRelationReference | None = None, type: DirectRelationReference | None = None, deleted_time: int | None = None, )

Bases: _Cognite3DRevisionProperties, TypedNode

This represents the reading format of Cognite 3D revision.

It is used when data is read from CDF.

Shared revision information for various 3D data types. Normally not used directly, but through CognitePointCloudRevision, Image360Collection or CogniteCADRevision

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite 3D revision.
version (int) – DMS version.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
status (Literal['Done', 'Failed', 'Processing', 'Queued'] | None) – The status field.
published (bool | None) – The published field.
revision_type (Literal['CAD', 'Image360', 'PointCloud'] | None) – The revision type field.
model_3d (DirectRelationReference | None) – The model 3d field.
type (DirectRelationReference | None) – Direct relation pointing to the type node.
deleted_time (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds. Timestamp when the instance was soft deleted. Note that deleted instances are filtered out of query results, but present in sync results

class cognite.client.data_classes.data_modeling.cdm.v1.Cognite3DRevisionApply( space: str, external_id: str, *, status: ~typing.Literal['Done', 'Failed', 'Processing', 'Queued'] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, published: bool | None | ~cognite.client._constants.Omitted = <Omitted parameter>, revision_type: ~typing.Literal['CAD', 'Image360', 'PointCloud'] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, model_3d: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, existing_version: int | None = None, type: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, )

Bases: _Cognite3DRevisionProperties, TypedNodeApply

This represents the writing format of Cognite 3D revision.

It is used when data is written to CDF.

Shared revision information for various 3D data types. Normally not used directly, but through CognitePointCloudRevision, Image360Collection or CogniteCADRevision

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite 3D revision.
status (Literal['Done', 'Failed', 'Processing', 'Queued'] | None | Omitted) – The status field.
published (bool | None | Omitted) – The published field.
revision_type (Literal['CAD', 'Image360', 'PointCloud'] | None | Omitted) – The revision type field.
model_3d (DirectRelationReference | tuple[str, str] | None | Omitted) – The model 3d field.
existing_version (int | None) – Fail the ingestion request if the node’s version is greater than or equal to this value. If no existingVersion is specified, the ingestion will always overwrite any existing data for the node (for the specified container or node). If existingVersion is set to 0, the upsert will behave as an insert, so it will fail the bulk if the item already exists. If skipOnVersionConflict is set on the ingestion request, then the item will be skipped instead of failing the ingestion request.
type (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation pointing to the type node.

class cognite.client.data_classes.data_modeling.cdm.v1.Cognite3DTransformationEdge( space: str, external_id: str, type: DirectRelationReference, start_node: DirectRelationReference, end_node: DirectRelationReference, version: int, last_updated_time: int, created_time: int, *, translation_x: float | None = None, translation_y: float | None = None, translation_z: float | None = None, euler_rotation_x: float | None = None, euler_rotation_y: float | None = None, euler_rotation_z: float | None = None, scale_x: float | None = None, scale_y: float | None = None, scale_z: float | None = None, deleted_time: int | None = None, )

Bases: _Cognite3DTransformationProperties, TypedEdge

This represents the reading format of Cognite 3D transformation edge.

It is used when data is read from CDF.

The Cognite3DTransformation object defines a comprehensive 3D transformation, enabling precise adjustments to an object’s position, orientation, and size in the 3D coordinate system. It allows for the translation of objects along the three spatial axes, rotation around these axes using Euler angles, and scaling along each axis to modify the object’s dimensions. The object’s transformation is defined in “CDF space”, a coordinate system where the positive Z axis is the up direction

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite 3D transformation edge.
type (DirectRelationReference) – The type of edge.
start_node (DirectRelationReference) – Reference to the direct relation. The reference consists of a space and an external-id.
end_node (DirectRelationReference) – Reference to the direct relation. The reference consists of a space and an external-id.
version (int) – DMS version.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
translation_x (float | None) – The displacement of the object along the X-axis in the 3D coordinate system
translation_y (float | None) – The displacement of the object along the Y-axis in the 3D coordinate system
translation_z (float | None) – The displacement of the object along the Z-axis in the 3D coordinate system
euler_rotation_x (float | None) – The rotation of the object around the X-axis in radians
euler_rotation_y (float | None) – The rotation of the object around the Y-axis in radians
euler_rotation_z (float | None) – The rotation of the object around the Z-axis in radians
scale_x (float | None) – The scaling factor applied to the object along the X-axis
scale_y (float | None) – The scaling factor applied to the object along the Y-axis
scale_z (float | None) – The scaling factor applied to the object along the Z-axis
deleted_time (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds. Timestamp when the instance was soft deleted. Note that deleted instances are filtered out of query results, but present in sync results

class cognite.client.data_classes.data_modeling.cdm.v1.Cognite3DTransformationEdgeApply(space: str, external_id: str, type: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str], start_node: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str], end_node: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str], *, translation_x: float | None | ~cognite.client._constants.Omitted = <Omitted parameter>, translation_y: float | None | ~cognite.client._constants.Omitted = <Omitted parameter>, translation_z: float | None | ~cognite.client._constants.Omitted = <Omitted parameter>, euler_rotation_x: float | None | ~cognite.client._constants.Omitted = <Omitted parameter>, euler_rotation_y: float | None | ~cognite.client._constants.Omitted = <Omitted parameter>, euler_rotation_z: float | None | ~cognite.client._constants.Omitted = <Omitted parameter>, scale_x: float | None | ~cognite.client._constants.Omitted = <Omitted parameter>, scale_y: float | None | ~cognite.client._constants.Omitted = <Omitted parameter>, scale_z: float | None | ~cognite.client._constants.Omitted = <Omitted parameter>, existing_version: int | None = None)

Bases: _Cognite3DTransformationProperties, TypedEdgeApply

This represents the writing format of Cognite 3D transformation edge.

It is used when data is written to CDF.

The Cognite3DTransformation object defines a comprehensive 3D transformation, enabling precise adjustments to an object’s position, orientation, and size in the 3D coordinate system. It allows for the translation of objects along the three spatial axes, rotation around these axes using Euler angles, and scaling along each axis to modify the object’s dimensions. The object’s transformation is defined in “CDF space”, a coordinate system where the positive Z axis is the up direction

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite 3D transformation edge.
type (DirectRelationReference | tuple[str, str]) – The type of edge.
start_node (DirectRelationReference | tuple[str, str]) – Reference to the direct relation. The reference consists of a space and an external-id.
end_node (DirectRelationReference | tuple[str, str]) – Reference to the direct relation. The reference consists of a space and an external-id.
translation_x (float | None | Omitted) – The displacement of the object along the X-axis in the 3D coordinate system
translation_y (float | None | Omitted) – The displacement of the object along the Y-axis in the 3D coordinate system
translation_z (float | None | Omitted) – The displacement of the object along the Z-axis in the 3D coordinate system
euler_rotation_x (float | None | Omitted) – The rotation of the object around the X-axis in radians
euler_rotation_y (float | None | Omitted) – The rotation of the object around the Y-axis in radians
euler_rotation_z (float | None | Omitted) – The rotation of the object around the Z-axis in radians
scale_x (float | None | Omitted) – The scaling factor applied to the object along the X-axis
scale_y (float | None | Omitted) – The scaling factor applied to the object along the Y-axis
scale_z (float | None | Omitted) – The scaling factor applied to the object along the Z-axis
existing_version (int | None) – Fail the ingestion request if the edge’s version is greater than or equal to this value. If no existingVersion is specified, the ingestion will always overwrite any existing data for the edge (for the specified container or edge). If existingVersion is set to 0, the upsert will behave as an insert, so it will fail the bulk if the item already exists. If skipOnVersionConflict is set on the ingestion request, then the item will be skipped instead of failing the ingestion request.

class cognite.client.data_classes.data_modeling.cdm.v1.Cognite3DTransformationNode( space: str, external_id: str, version: int, last_updated_time: int, created_time: int, *, translation_x: float | None = None, translation_y: float | None = None, translation_z: float | None = None, euler_rotation_x: float | None = None, euler_rotation_y: float | None = None, euler_rotation_z: float | None = None, scale_x: float | None = None, scale_y: float | None = None, scale_z: float | None = None, type: DirectRelationReference | None = None, deleted_time: int | None = None, )

Bases: _Cognite3DTransformationProperties, TypedNode

This represents the reading format of Cognite 3D transformation node.

It is used when data is read from CDF.

The Cognite3DTransformation object defines a comprehensive 3D transformation, enabling precise adjustments to an object’s position, orientation, and size in the 3D coordinate system. It allows for the translation of objects along the three spatial axes, rotation around these axes using Euler angles, and scaling along each axis to modify the object’s dimensions. The object’s transformation is defined in “CDF space”, a coordinate system where the positive Z axis is the up direction

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite 3D transformation node.
version (int) – DMS version.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
translation_x (float | None) – The displacement of the object along the X-axis in the 3D coordinate system
translation_y (float | None) – The displacement of the object along the Y-axis in the 3D coordinate system
translation_z (float | None) – The displacement of the object along the Z-axis in the 3D coordinate system
euler_rotation_x (float | None) – The rotation of the object around the X-axis in radians
euler_rotation_y (float | None) – The rotation of the object around the Y-axis in radians
euler_rotation_z (float | None) – The rotation of the object around the Z-axis in radians
scale_x (float | None) – The scaling factor applied to the object along the X-axis
scale_y (float | None) – The scaling factor applied to the object along the Y-axis
scale_z (float | None) – The scaling factor applied to the object along the Z-axis
type (DirectRelationReference | None) – Direct relation pointing to the type node.
deleted_time (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds. Timestamp when the instance was soft deleted. Note that deleted instances are filtered out of query results, but present in sync results

class cognite.client.data_classes.data_modeling.cdm.v1.Cognite3DTransformationNodeApply( space: str, external_id: str, *, translation_x: float | None | ~cognite.client._constants.Omitted = <Omitted parameter>, translation_y: float | None | ~cognite.client._constants.Omitted = <Omitted parameter>, translation_z: float | None | ~cognite.client._constants.Omitted = <Omitted parameter>, euler_rotation_x: float | None | ~cognite.client._constants.Omitted = <Omitted parameter>, euler_rotation_y: float | None | ~cognite.client._constants.Omitted = <Omitted parameter>, euler_rotation_z: float | None | ~cognite.client._constants.Omitted = <Omitted parameter>, scale_x: float | None | ~cognite.client._constants.Omitted = <Omitted parameter>, scale_y: float | None | ~cognite.client._constants.Omitted = <Omitted parameter>, scale_z: float | None | ~cognite.client._constants.Omitted = <Omitted parameter>, existing_version: int | None = None, type: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, )

Bases: _Cognite3DTransformationProperties, TypedNodeApply

This represents the writing format of Cognite 3D transformation node.

It is used when data is written to CDF.

The Cognite3DTransformation object defines a comprehensive 3D transformation, enabling precise adjustments to an object’s position, orientation, and size in the 3D coordinate system. It allows for the translation of objects along the three spatial axes, rotation around these axes using Euler angles, and scaling along each axis to modify the object’s dimensions. The object’s transformation is defined in “CDF space”, a coordinate system where the positive Z axis is the up direction

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite 3D transformation node.
translation_x (float | None | Omitted) – The displacement of the object along the X-axis in the 3D coordinate system
translation_y (float | None | Omitted) – The displacement of the object along the Y-axis in the 3D coordinate system
translation_z (float | None | Omitted) – The displacement of the object along the Z-axis in the 3D coordinate system
euler_rotation_x (float | None | Omitted) – The rotation of the object around the X-axis in radians
euler_rotation_y (float | None | Omitted) – The rotation of the object around the Y-axis in radians
euler_rotation_z (float | None | Omitted) – The rotation of the object around the Z-axis in radians
scale_x (float | None | Omitted) – The scaling factor applied to the object along the X-axis
scale_y (float | None | Omitted) – The scaling factor applied to the object along the Y-axis
scale_z (float | None | Omitted) – The scaling factor applied to the object along the Z-axis
existing_version (int | None) – Fail the ingestion request if the node’s version is greater than or equal to this value. If no existingVersion is specified, the ingestion will always overwrite any existing data for the node (for the specified container or node). If existingVersion is set to 0, the upsert will behave as an insert, so it will fail the bulk if the item already exists. If skipOnVersionConflict is set on the ingestion request, then the item will be skipped instead of failing the ingestion request.
type (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation pointing to the type node.

class cognite.client.data_classes.data_modeling.cdm.v1.CogniteActivity( space: str, external_id: str, version: int, last_updated_time: int, created_time: int, *, name: str | None = None, description: str | None = None, tags: list[str] | None = None, aliases: list[str] | None = None, source_id: str | None = None, source_context: str | None = None, source: DirectRelationReference | None = None, source_created_time: datetime | None = None, source_updated_time: datetime | None = None, source_created_user: str | None = None, source_updated_user: str | None = None, start_time: datetime | None = None, end_time: datetime | None = None, scheduled_start_time: datetime | None = None, scheduled_end_time: datetime | None = None, assets: list[DirectRelationReference] | None = None, equipment: list[DirectRelationReference] | None = None, time_series: list[DirectRelationReference] | None = None, type: DirectRelationReference | None = None, deleted_time: int | None = None, )

Bases: _CogniteActivityProperties, TypedNode

This represents the reading format of Cognite activity.

It is used when data is read from CDF.

Represents activities. Activities typically happen over a period and have a start and end time.

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite activity.
version (int) – DMS version.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
name (str | None) – Name of the instance
description (str | None) – Description of the instance
tags (list[str] | None) – Text based labels for generic use, limited to 1000
aliases (list[str] | None) – Alternative names for the node
source_id (str | None) – Identifier from the source system
source_context (str | None) – Context of the source id. For systems where the sourceId is globally unique, the sourceContext is expected to not be set.
source (DirectRelationReference | None) – Direct relation to a source system
source_created_time (datetime | None) – When the instance was created in source system (if available)
source_updated_time (datetime | None) – When the instance was last updated in the source system (if available)
source_created_user (str | None) – User identifier from the source system on who created the source data. This identifier is not guaranteed to match the user identifiers in CDF
source_updated_user (str | None) – User identifier from the source system on who last updated the source data. This identifier is not guaranteed to match the user identifiers in CDF
start_time (datetime | None) – The actual start time of an activity (or similar that extends this)
end_time (datetime | None) – The actual end time of an activity (or similar that extends this)
scheduled_start_time (datetime | None) – The planned start time of an activity (or similar that extends this)
scheduled_end_time (datetime | None) – The planned end time of an activity (or similar that extends this)
assets (list[DirectRelationReference] | None) – A list of assets the activity is related to.
equipment (list[DirectRelationReference] | None) – A list of equipment the activity is related to.
time_series (list[DirectRelationReference] | None) – A list of time series the activity is related to.
type (DirectRelationReference | None) – Direct relation pointing to the type node.
deleted_time (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds. Timestamp when the instance was soft deleted. Note that deleted instances are filtered out of query results, but present in sync results

class cognite.client.data_classes.data_modeling.cdm.v1.CogniteActivityApply( space: str, external_id: str, *, name: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, description: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, tags: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, aliases: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_id: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_context: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_created_time: ~datetime.datetime | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_updated_time: ~datetime.datetime | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_created_user: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_updated_user: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, start_time: ~datetime.datetime | None | ~cognite.client._constants.Omitted = <Omitted parameter>, end_time: ~datetime.datetime | None | ~cognite.client._constants.Omitted = <Omitted parameter>, scheduled_start_time: ~datetime.datetime | None | ~cognite.client._constants.Omitted = <Omitted parameter>, scheduled_end_time: ~datetime.datetime | None | ~cognite.client._constants.Omitted = <Omitted parameter>, assets: list[~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str]] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, equipment: list[~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str]] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, time_series: list[~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str]] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, existing_version: int | None = None, type: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, )

Bases: _CogniteActivityProperties, TypedNodeApply

This represents the writing format of Cognite activity.

It is used when data is written to CDF.

Represents activities. Activities typically happen over a period and have a start and end time.

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite activity.
name (str | None | Omitted) – Name of the instance
description (str | None | Omitted) – Description of the instance
tags (list[str] | None | Omitted) – Text based labels for generic use, limited to 1000
aliases (list[str] | None | Omitted) – Alternative names for the node
source_id (str | None | Omitted) – Identifier from the source system
source_context (str | None | Omitted) – Context of the source id. For systems where the sourceId is globally unique, the sourceContext is expected to not be set.
source (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation to a source system
source_created_time (datetime | None | Omitted) – When the instance was created in source system (if available)
source_updated_time (datetime | None | Omitted) – When the instance was last updated in the source system (if available)
source_created_user (str | None | Omitted) – User identifier from the source system on who created the source data. This identifier is not guaranteed to match the user identifiers in CDF
source_updated_user (str | None | Omitted) – User identifier from the source system on who last updated the source data. This identifier is not guaranteed to match the user identifiers in CDF
start_time (datetime | None | Omitted) – The actual start time of an activity (or similar that extends this)
end_time (datetime | None | Omitted) – The actual end time of an activity (or similar that extends this)
scheduled_start_time (datetime | None | Omitted) – The planned start time of an activity (or similar that extends this)
scheduled_end_time (datetime | None | Omitted) – The planned end time of an activity (or similar that extends this)
assets (list[DirectRelationReference | tuple[str, str]] | None | Omitted) – A list of assets the activity is related to.
equipment (list[DirectRelationReference | tuple[str, str]] | None | Omitted) – A list of equipment the activity is related to.
time_series (list[DirectRelationReference | tuple[str, str]] | None | Omitted) – A list of time series the activity is related to.
existing_version (int | None) – Fail the ingestion request if the node’s version is greater than or equal to this value. If no existingVersion is specified, the ingestion will always overwrite any existing data for the node (for the specified container or node). If existingVersion is set to 0, the upsert will behave as an insert, so it will fail the bulk if the item already exists. If skipOnVersionConflict is set on the ingestion request, then the item will be skipped instead of failing the ingestion request.
type (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation pointing to the type node.

class cognite.client.data_classes.data_modeling.cdm.v1.CogniteAnnotation( space: str, external_id: str, type: DirectRelationReference, start_node: DirectRelationReference, end_node: DirectRelationReference, version: int, last_updated_time: int, created_time: int, *, name: str | None = None, description: str | None = None, tags: list[str] | None = None, aliases: list[str] | None = None, source_id: str | None = None, source_context: str | None = None, source: DirectRelationReference | None = None, source_created_time: datetime | None = None, source_updated_time: datetime | None = None, source_created_user: str | None = None, source_updated_user: str | None = None, confidence: float | None = None, status: Literal['Approved', 'Rejected', 'Suggested'] | None = None, deleted_time: int | None = None, )

Bases: _CogniteAnnotationProperties, TypedEdge

This represents the reading format of Cognite annotation.

It is used when data is read from CDF.

Annotation represents contextualization results or links

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite annotation.
type (DirectRelationReference) – The type of edge.
start_node (DirectRelationReference) – Reference to the direct relation. The reference consists of a space and an external-id.
end_node (DirectRelationReference) – Reference to the direct relation. The reference consists of a space and an external-id.
version (int) – DMS version.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
name (str | None) – Name of the instance
description (str | None) – Description of the instance
tags (list[str] | None) – Text based labels for generic use, limited to 1000
aliases (list[str] | None) – Alternative names for the node
source_id (str | None) – Identifier from the source system
source_context (str | None) – Context of the source id. For systems where the sourceId is globally unique, the sourceContext is expected to not be set.
source (DirectRelationReference | None) – Direct relation to a source system
source_created_time (datetime | None) – When the instance was created in source system (if available)
source_updated_time (datetime | None) – When the instance was last updated in the source system (if available)
source_created_user (str | None) – User identifier from the source system on who created the source data. This identifier is not guaranteed to match the user identifiers in CDF
source_updated_user (str | None) – User identifier from the source system on who last updated the source data. This identifier is not guaranteed to match the user identifiers in CDF
confidence (float | None) – The confidence that the annotation is a good match
status (Literal['Approved', 'Rejected', 'Suggested'] | None) – The status of the annotation
deleted_time (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds. Timestamp when the instance was soft deleted. Note that deleted instances are filtered out of query results, but present in sync results

class cognite.client.data_classes.data_modeling.cdm.v1.CogniteAnnotationApply(space: str, external_id: str, type: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str], start_node: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str], end_node: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str], *, name: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, description: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, tags: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, aliases: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_id: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_context: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_created_time: ~datetime.datetime | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_updated_time: ~datetime.datetime | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_created_user: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_updated_user: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, confidence: float | None | ~cognite.client._constants.Omitted = <Omitted parameter>, status: ~typing.Literal['Approved', 'Rejected', 'Suggested'] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, existing_version: int | None = None)

Bases: _CogniteAnnotationProperties, TypedEdgeApply

This represents the writing format of Cognite annotation.

It is used when data is written to CDF.

Annotation represents contextualization results or links

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite annotation.
type (DirectRelationReference | tuple[str, str]) – The type of edge.
start_node (DirectRelationReference | tuple[str, str]) – Reference to the direct relation. The reference consists of a space and an external-id.
end_node (DirectRelationReference | tuple[str, str]) – Reference to the direct relation. The reference consists of a space and an external-id.
name (str | None | Omitted) – Name of the instance
description (str | None | Omitted) – Description of the instance
tags (list[str] | None | Omitted) – Text based labels for generic use, limited to 1000
aliases (list[str] | None | Omitted) – Alternative names for the node
source_id (str | None | Omitted) – Identifier from the source system
source_context (str | None | Omitted) – Context of the source id. For systems where the sourceId is globally unique, the sourceContext is expected to not be set.
source (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation to a source system
source_created_time (datetime | None | Omitted) – When the instance was created in source system (if available)
source_updated_time (datetime | None | Omitted) – When the instance was last updated in the source system (if available)
source_created_user (str | None | Omitted) – User identifier from the source system on who created the source data. This identifier is not guaranteed to match the user identifiers in CDF
source_updated_user (str | None | Omitted) – User identifier from the source system on who last updated the source data. This identifier is not guaranteed to match the user identifiers in CDF
confidence (float | None | Omitted) – The confidence that the annotation is a good match
status (Literal['Approved', 'Rejected', 'Suggested'] | None | Omitted) – The status of the annotation
existing_version (int | None) – Fail the ingestion request if the edge’s version is greater than or equal to this value. If no existingVersion is specified, the ingestion will always overwrite any existing data for the edge (for the specified container or edge). If existingVersion is set to 0, the upsert will behave as an insert, so it will fail the bulk if the item already exists. If skipOnVersionConflict is set on the ingestion request, then the item will be skipped instead of failing the ingestion request.

class cognite.client.data_classes.data_modeling.cdm.v1.CogniteAsset( space: str, external_id: str, version: int, last_updated_time: int, created_time: int, *, object_3d: DirectRelationReference | None = None, name: str | None = None, description: str | None = None, tags: list[str] | None = None, aliases: list[str] | None = None, source_id: str | None = None, source_context: str | None = None, source: DirectRelationReference | None = None, source_created_time: datetime | None = None, source_updated_time: datetime | None = None, source_created_user: str | None = None, source_updated_user: str | None = None, parent: DirectRelationReference | None = None, root: DirectRelationReference | None = None, path: list[DirectRelationReference] | None = None, path_last_updated_time: datetime | None = None, asset_class: DirectRelationReference | None = None, asset_type: DirectRelationReference | None = None, type: DirectRelationReference | None = None, deleted_time: int | None = None, )

Bases: _CogniteAssetProperties, TypedNode

This represents the reading format of Cognite asset.

It is used when data is read from CDF.

Assets represent systems that support industrial functions or processes. Assets are often called ‘functional location’.

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite asset.
version (int) – DMS version.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
object_3d (DirectRelationReference | None) – Direct relation to an Object3D instance representing the 3D resource
name (str | None) – Name of the instance
description (str | None) – Description of the instance
tags (list[str] | None) – Text based labels for generic use, limited to 1000
aliases (list[str] | None) – Alternative names for the node
source_id (str | None) – Identifier from the source system
source_context (str | None) – Context of the source id. For systems where the sourceId is globally unique, the sourceContext is expected to not be set.
source (DirectRelationReference | None) – Direct relation to a source system
source_created_time (datetime | None) – When the instance was created in source system (if available)
source_updated_time (datetime | None) – When the instance was last updated in the source system (if available)
source_created_user (str | None) – User identifier from the source system on who created the source data. This identifier is not guaranteed to match the user identifiers in CDF
source_updated_user (str | None) – User identifier from the source system on who last updated the source data. This identifier is not guaranteed to match the user identifiers in CDF
parent (DirectRelationReference | None) – The parent of the asset.
root (DirectRelationReference | None) – An automatically updated reference to the top-level asset of the hierarchy.
path (list[DirectRelationReference] | None) – An automatically updated ordered list of this asset’s ancestors, starting with the root asset. Enables subtree filtering to find all assets under a parent.
path_last_updated_time (datetime | None) – The last time the path was updated for this asset.
asset_class (DirectRelationReference | None) – Specifies the class of the asset. It’s a direct relation to CogniteAssetClass.
asset_type (DirectRelationReference | None) – Specifies the type of the asset. It’s a direct relation to CogniteAssetType.
type (DirectRelationReference | None) – Direct relation pointing to the type node.
deleted_time (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds. Timestamp when the instance was soft deleted. Note that deleted instances are filtered out of query results, but present in sync results

class cognite.client.data_classes.data_modeling.cdm.v1.CogniteAssetApply( space: str, external_id: str, *, object_3d: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, name: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, description: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, tags: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, aliases: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_id: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_context: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_created_time: ~datetime.datetime | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_updated_time: ~datetime.datetime | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_created_user: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_updated_user: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, parent: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, asset_class: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, asset_type: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, existing_version: int | None = None, type: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, )

Bases: _CogniteAssetProperties, TypedNodeApply

This represents the writing format of Cognite asset.

It is used when data is written to CDF.

Assets represent systems that support industrial functions or processes. Assets are often called ‘functional location’.

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite asset.
object_3d (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation to an Object3D instance representing the 3D resource
name (str | None | Omitted) – Name of the instance
description (str | None | Omitted) – Description of the instance
tags (list[str] | None | Omitted) – Text based labels for generic use, limited to 1000
aliases (list[str] | None | Omitted) – Alternative names for the node
source_id (str | None | Omitted) – Identifier from the source system
source_context (str | None | Omitted) – Context of the source id. For systems where the sourceId is globally unique, the sourceContext is expected to not be set.
source (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation to a source system
source_created_time (datetime | None | Omitted) – When the instance was created in source system (if available)
source_updated_time (datetime | None | Omitted) – When the instance was last updated in the source system (if available)
source_created_user (str | None | Omitted) – User identifier from the source system on who created the source data. This identifier is not guaranteed to match the user identifiers in CDF
source_updated_user (str | None | Omitted) – User identifier from the source system on who last updated the source data. This identifier is not guaranteed to match the user identifiers in CDF
parent (DirectRelationReference | tuple[str, str] | None | Omitted) – The parent of the asset.
asset_class (DirectRelationReference | tuple[str, str] | None | Omitted) – Specifies the class of the asset. It’s a direct relation to CogniteAssetClass.
asset_type (DirectRelationReference | tuple[str, str] | None | Omitted) – Specifies the type of the asset. It’s a direct relation to CogniteAssetType.
existing_version (int | None) – Fail the ingestion request if the node’s version is greater than or equal to this value. If no existingVersion is specified, the ingestion will always overwrite any existing data for the node (for the specified container or node). If existingVersion is set to 0, the upsert will behave as an insert, so it will fail the bulk if the item already exists. If skipOnVersionConflict is set on the ingestion request, then the item will be skipped instead of failing the ingestion request.
type (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation pointing to the type node.

class cognite.client.data_classes.data_modeling.cdm.v1.CogniteAssetClass( space: str, external_id: str, version: int, last_updated_time: int, created_time: int, *, name: str | None = None, description: str | None = None, tags: list[str] | None = None, aliases: list[str] | None = None, code: str | None = None, standard: str | None = None, type: DirectRelationReference | None = None, deleted_time: int | None = None, )

Bases: _CogniteAssetClassProperties, TypedNode

This represents the reading format of Cognite asset clas.

It is used when data is read from CDF.

Represents the class of an asset.

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite asset clas.
version (int) – DMS version.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
name (str | None) – Name of the instance
description (str | None) – Description of the instance
tags (list[str] | None) – Text based labels for generic use, limited to 1000
aliases (list[str] | None) – Alternative names for the node
code (str | None) – A unique identifier for the class of asset.
standard (str | None) – A text string to specify which standard the class is from.
type (DirectRelationReference | None) – Direct relation pointing to the type node.
deleted_time (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds. Timestamp when the instance was soft deleted. Note that deleted instances are filtered out of query results, but present in sync results

class cognite.client.data_classes.data_modeling.cdm.v1.CogniteAssetClassApply( space: str, external_id: str, *, name: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, description: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, tags: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, aliases: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, code: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, standard: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, existing_version: int | None = None, type: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, )

Bases: _CogniteAssetClassProperties, TypedNodeApply

This represents the writing format of Cognite asset clas.

It is used when data is written to CDF.

Represents the class of an asset.

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite asset clas.
name (str | None | Omitted) – Name of the instance
description (str | None | Omitted) – Description of the instance
tags (list[str] | None | Omitted) – Text based labels for generic use, limited to 1000
aliases (list[str] | None | Omitted) – Alternative names for the node
code (str | None | Omitted) – A unique identifier for the class of asset.
standard (str | None | Omitted) – A text string to specify which standard the class is from.
existing_version (int | None) – Fail the ingestion request if the node’s version is greater than or equal to this value. If no existingVersion is specified, the ingestion will always overwrite any existing data for the node (for the specified container or node). If existingVersion is set to 0, the upsert will behave as an insert, so it will fail the bulk if the item already exists. If skipOnVersionConflict is set on the ingestion request, then the item will be skipped instead of failing the ingestion request.
type (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation pointing to the type node.

class cognite.client.data_classes.data_modeling.cdm.v1.CogniteAssetType( space: str, external_id: str, version: int, last_updated_time: int, created_time: int, *, name: str | None = None, description: str | None = None, tags: list[str] | None = None, aliases: list[str] | None = None, code: str | None = None, standard: str | None = None, asset_class: DirectRelationReference | None = None, type: DirectRelationReference | None = None, deleted_time: int | None = None, )

Bases: _CogniteAssetTypeProperties, TypedNode

This represents the reading format of Cognite asset type.

It is used when data is read from CDF.

Represents the type of an asset.

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite asset type.
version (int) – DMS version.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
name (str | None) – Name of the instance
description (str | None) – Description of the instance
tags (list[str] | None) – Text based labels for generic use, limited to 1000
aliases (list[str] | None) – Alternative names for the node
code (str | None) – A unique identifier for the type of asset.
standard (str | None) – A text string to specify which standard the type is from.
asset_class (DirectRelationReference | None) – Specifies the class the type belongs to. It’s a direct relation to CogniteAssetClass.
type (DirectRelationReference | None) – Direct relation pointing to the type node.
deleted_time (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds. Timestamp when the instance was soft deleted. Note that deleted instances are filtered out of query results, but present in sync results

class cognite.client.data_classes.data_modeling.cdm.v1.CogniteAssetTypeApply( space: str, external_id: str, *, name: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, description: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, tags: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, aliases: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, code: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, standard: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, asset_class: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, existing_version: int | None = None, type: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, )

Bases: _CogniteAssetTypeProperties, TypedNodeApply

This represents the writing format of Cognite asset type.

It is used when data is written to CDF.

Represents the type of an asset.

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite asset type.
name (str | None | Omitted) – Name of the instance
description (str | None | Omitted) – Description of the instance
tags (list[str] | None | Omitted) – Text based labels for generic use, limited to 1000
aliases (list[str] | None | Omitted) – Alternative names for the node
code (str | None | Omitted) – A unique identifier for the type of asset.
standard (str | None | Omitted) – A text string to specify which standard the type is from.
asset_class (DirectRelationReference | tuple[str, str] | None | Omitted) – Specifies the class the type belongs to. It’s a direct relation to CogniteAssetClass.
existing_version (int | None) – Fail the ingestion request if the node’s version is greater than or equal to this value. If no existingVersion is specified, the ingestion will always overwrite any existing data for the node (for the specified container or node). If existingVersion is set to 0, the upsert will behave as an insert, so it will fail the bulk if the item already exists. If skipOnVersionConflict is set on the ingestion request, then the item will be skipped instead of failing the ingestion request.
type (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation pointing to the type node.

class cognite.client.data_classes.data_modeling.cdm.v1.CogniteCADModel( space: str, external_id: str, version: int, last_updated_time: int, created_time: int, *, name: str | None = None, description: str | None = None, tags: list[str] | None = None, aliases: list[str] | None = None, model_type: Literal['CAD', 'Image360', 'PointCloud'] | None = None, thumbnail: DirectRelationReference | None = None, type: DirectRelationReference | None = None, deleted_time: int | None = None, )

Bases: _CogniteCADModelProperties, TypedNode

This represents the reading format of Cognite cad model.

It is used when data is read from CDF.

Navigational aid for traversing CogniteCADModel instances

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite cad model.
version (int) – DMS version.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
name (str | None) – Name of the instance
description (str | None) – Description of the instance
tags (list[str] | None) – Text based labels for generic use, limited to 1000
aliases (list[str] | None) – Alternative names for the node
model_type (Literal['CAD', 'Image360', 'PointCloud'] | None) – CAD, PointCloud or Image360
thumbnail (DirectRelationReference | None) – Thumbnail of the 3D model
type (DirectRelationReference | None) – Direct relation pointing to the type node.
deleted_time (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds. Timestamp when the instance was soft deleted. Note that deleted instances are filtered out of query results, but present in sync results

class cognite.client.data_classes.data_modeling.cdm.v1.CogniteCADModelApply( space: str, external_id: str, *, name: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, description: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, tags: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, aliases: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, model_type: ~typing.Literal['CAD', 'Image360', 'PointCloud'] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, thumbnail: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, existing_version: int | None = None, type: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, )

Bases: _CogniteCADModelProperties, TypedNodeApply

This represents the writing format of Cognite cad model.

It is used when data is written to CDF.

Navigational aid for traversing CogniteCADModel instances

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite cad model.
name (str | None | Omitted) – Name of the instance
description (str | None | Omitted) – Description of the instance
tags (list[str] | None | Omitted) – Text based labels for generic use, limited to 1000
aliases (list[str] | None | Omitted) – Alternative names for the node
model_type (Literal['CAD', 'Image360', 'PointCloud'] | None | Omitted) – CAD, PointCloud or Image360
thumbnail (DirectRelationReference | tuple[str, str] | None | Omitted) – Thumbnail of the 3D model
existing_version (int | None) – Fail the ingestion request if the node’s version is greater than or equal to this value. If no existingVersion is specified, the ingestion will always overwrite any existing data for the node (for the specified container or node). If existingVersion is set to 0, the upsert will behave as an insert, so it will fail the bulk if the item already exists. If skipOnVersionConflict is set on the ingestion request, then the item will be skipped instead of failing the ingestion request.
type (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation pointing to the type node.

class cognite.client.data_classes.data_modeling.cdm.v1.CogniteCADNode( space: str, external_id: str, version: int, last_updated_time: int, created_time: int, *, name: str | None = None, description: str | None = None, tags: list[str] | None = None, aliases: list[str] | None = None, object_3d: DirectRelationReference | None = None, model_3d: DirectRelationReference | None = None, cad_node_reference: str | None = None, revisions: list[DirectRelationReference] | None = None, tree_indexes: list[int] | None = None, sub_tree_sizes: list[int] | None = None, type: DirectRelationReference | None = None, deleted_time: int | None = None, )

Bases: _CogniteCADNodeProperties, TypedNode

This represents the reading format of Cognite cad node.

It is used when data is read from CDF.

Represents nodes from the 3D model that have been contextualized

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite cad node.
version (int) – DMS version.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
name (str | None) – Name of the instance
description (str | None) – Description of the instance
tags (list[str] | None) – Text based labels for generic use, limited to 1000
aliases (list[str] | None) – Alternative names for the node
object_3d (DirectRelationReference | None) – Direct relation to object3D grouping for this node
model_3d (DirectRelationReference | None) – Direct relation to Cognite3DModel
cad_node_reference (str | None) – Reference to a node within a CAD model from the 3D API
revisions (list[DirectRelationReference] | None) – List of direct relations to instances of Cognite3DRevision which this CogniteCADNode exists in.
tree_indexes (list[int] | None) – List of tree indexes in the same order as revisions. Used by Reveal and similar applications to map from CogniteCADNode to tree index
sub_tree_sizes (list[int] | None) – List of subtree sizes in the same order as revisions. Used by Reveal and similar applications to know how many nodes exists below this node in the hierarchy
type (DirectRelationReference | None) – Direct relation pointing to the type node.
deleted_time (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds. Timestamp when the instance was soft deleted. Note that deleted instances are filtered out of query results, but present in sync results

class cognite.client.data_classes.data_modeling.cdm.v1.CogniteCADNodeApply( space: str, external_id: str, *, name: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, description: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, tags: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, aliases: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, object_3d: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, model_3d: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, cad_node_reference: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, revisions: list[~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str]] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, tree_indexes: list[int] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, sub_tree_sizes: list[int] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, existing_version: int | None = None, type: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, )

Bases: _CogniteCADNodeProperties, TypedNodeApply

This represents the writing format of Cognite cad node.

It is used when data is written to CDF.

Represents nodes from the 3D model that have been contextualized

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite cad node.
name (str | None | Omitted) – Name of the instance
description (str | None | Omitted) – Description of the instance
tags (list[str] | None | Omitted) – Text based labels for generic use, limited to 1000
aliases (list[str] | None | Omitted) – Alternative names for the node
object_3d (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation to object3D grouping for this node
model_3d (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation to Cognite3DModel
cad_node_reference (str | None | Omitted) – Reference to a node within a CAD model from the 3D API
revisions (list[DirectRelationReference | tuple[str, str]] | None | Omitted) – List of direct relations to instances of Cognite3DRevision which this CogniteCADNode exists in.
tree_indexes (list[int] | None | Omitted) – List of tree indexes in the same order as revisions. Used by Reveal and similar applications to map from CogniteCADNode to tree index
sub_tree_sizes (list[int] | None | Omitted) – List of subtree sizes in the same order as revisions. Used by Reveal and similar applications to know how many nodes exists below this node in the hierarchy
existing_version (int | None) – Fail the ingestion request if the node’s version is greater than or equal to this value. If no existingVersion is specified, the ingestion will always overwrite any existing data for the node (for the specified container or node). If existingVersion is set to 0, the upsert will behave as an insert, so it will fail the bulk if the item already exists. If skipOnVersionConflict is set on the ingestion request, then the item will be skipped instead of failing the ingestion request.
type (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation pointing to the type node.

class cognite.client.data_classes.data_modeling.cdm.v1.CogniteCADRevision( space: str, external_id: str, version: int, last_updated_time: int, created_time: int, *, status: Literal['Done', 'Failed', 'Processing', 'Queued'] | None = None, published: bool | None = None, revision_type: Literal['CAD', 'Image360', 'PointCloud'] | None = None, model_3d: DirectRelationReference | None = None, revision_id: int | None = None, type: DirectRelationReference | None = None, deleted_time: int | None = None, )

Bases: _CogniteCADRevisionProperties, TypedNode

This represents the reading format of Cognite cad revision.

It is used when data is read from CDF.

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite cad revision.
version (int) – DMS version.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
status (Literal['Done', 'Failed', 'Processing', 'Queued'] | None) – The status field.
published (bool | None) – The published field.
revision_type (Literal['CAD', 'Image360', 'PointCloud'] | None) – The revision type field.
model_3d (DirectRelationReference | None) –
.
revision_id (int | None) – The 3D API revision identifier for this CAD model
type (DirectRelationReference | None) – Direct relation pointing to the type node.
deleted_time (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds. Timestamp when the instance was soft deleted. Note that deleted instances are filtered out of query results, but present in sync results

class cognite.client.data_classes.data_modeling.cdm.v1.CogniteCADRevisionApply( space: str, external_id: str, *, status: ~typing.Literal['Done', 'Failed', 'Processing', 'Queued'] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, published: bool | None | ~cognite.client._constants.Omitted = <Omitted parameter>, revision_type: ~typing.Literal['CAD', 'Image360', 'PointCloud'] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, model_3d: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, revision_id: int | None | ~cognite.client._constants.Omitted = <Omitted parameter>, existing_version: int | None = None, type: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, )

Bases: _CogniteCADRevisionProperties, TypedNodeApply

This represents the writing format of Cognite cad revision.

It is used when data is written to CDF.

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite cad revision.
status (Literal['Done', 'Failed', 'Processing', 'Queued'] | None | Omitted) – The status field.
published (bool | None | Omitted) – The published field.
revision_type (Literal['CAD', 'Image360', 'PointCloud'] | None | Omitted) – The revision type field.
model_3d (DirectRelationReference | tuple[str, str] | None | Omitted) –
.
revision_id (int | None | Omitted) – The 3D API revision identifier for this CAD model
existing_version (int | None) – Fail the ingestion request if the node’s version is greater than or equal to this value. If no existingVersion is specified, the ingestion will always overwrite any existing data for the node (for the specified container or node). If existingVersion is set to 0, the upsert will behave as an insert, so it will fail the bulk if the item already exists. If skipOnVersionConflict is set on the ingestion request, then the item will be skipped instead of failing the ingestion request.
type (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation pointing to the type node.

class cognite.client.data_classes.data_modeling.cdm.v1.CogniteCubeMap( space: str, external_id: str, version: int, last_updated_time: int, created_time: int, *, front: DirectRelationReference | None = None, back: DirectRelationReference | None = None, left: DirectRelationReference | None = None, right: DirectRelationReference | None = None, top: DirectRelationReference | None = None, bottom: DirectRelationReference | None = None, type: DirectRelationReference | None = None, deleted_time: int | None = None, )

Bases: _CogniteCubeMapProperties, TypedNode

This represents the reading format of Cognite cube map.

It is used when data is read from CDF.

The cube map holds references to 6 images in used to visually represent the surrounding environment

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite cube map.
version (int) – DMS version.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
front (DirectRelationReference | None) – Direct relation to a file holding the front projection of the cube map
back (DirectRelationReference | None) – Direct relation to a file holding the back projection of the cube map
left (DirectRelationReference | None) – Direct relation to a file holding the left projection of the cube map
right (DirectRelationReference | None) – Direct relation to a file holding the right projection of the cube map
top (DirectRelationReference | None) – Direct relation to a file holding the top projection of the cube map
bottom (DirectRelationReference | None) – Direct relation to a file holding the bottom projection of the cube map
type (DirectRelationReference | None) – Direct relation pointing to the type node.
deleted_time (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds. Timestamp when the instance was soft deleted. Note that deleted instances are filtered out of query results, but present in sync results

class cognite.client.data_classes.data_modeling.cdm.v1.CogniteCubeMapApply( space: str, external_id: str, *, front: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, back: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, left: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, right: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, top: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, bottom: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, existing_version: int | None = None, type: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, )

Bases: _CogniteCubeMapProperties, TypedNodeApply

This represents the writing format of Cognite cube map.

It is used when data is written to CDF.

The cube map holds references to 6 images in used to visually represent the surrounding environment

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite cube map.
front (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation to a file holding the front projection of the cube map
back (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation to a file holding the back projection of the cube map
left (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation to a file holding the left projection of the cube map
right (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation to a file holding the right projection of the cube map
top (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation to a file holding the top projection of the cube map
bottom (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation to a file holding the bottom projection of the cube map
existing_version (int | None) – Fail the ingestion request if the node’s version is greater than or equal to this value. If no existingVersion is specified, the ingestion will always overwrite any existing data for the node (for the specified container or node). If existingVersion is set to 0, the upsert will behave as an insert, so it will fail the bulk if the item already exists. If skipOnVersionConflict is set on the ingestion request, then the item will be skipped instead of failing the ingestion request.
type (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation pointing to the type node.

class cognite.client.data_classes.data_modeling.cdm.v1.CogniteDescribableEdge( space: str, external_id: str, type: DirectRelationReference, start_node: DirectRelationReference, end_node: DirectRelationReference, version: int, last_updated_time: int, created_time: int, *, name: str | None = None, description: str | None = None, tags: list[str] | None = None, aliases: list[str] | None = None, deleted_time: int | None = None, )

Bases: _CogniteDescribableProperties, TypedEdge

This represents the reading format of Cognite describable edge.

It is used when data is read from CDF.

The describable core concept is used as a standard way of holding the bare minimum of information about the instance

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite describable edge.
type (DirectRelationReference) – The type of edge.
start_node (DirectRelationReference) – Reference to the direct relation. The reference consists of a space and an external-id.
end_node (DirectRelationReference) – Reference to the direct relation. The reference consists of a space and an external-id.
version (int) – DMS version.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
name (str | None) – Name of the instance
description (str | None) – Description of the instance
tags (list[str] | None) – Text based labels for generic use, limited to 1000
aliases (list[str] | None) – Alternative names for the node
deleted_time (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds. Timestamp when the instance was soft deleted. Note that deleted instances are filtered out of query results, but present in sync results

class cognite.client.data_classes.data_modeling.cdm.v1.CogniteDescribableEdgeApply(space: str, external_id: str, type: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str], start_node: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str], end_node: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str], *, name: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, description: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, tags: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, aliases: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, existing_version: int | None = None)

Bases: _CogniteDescribableProperties, TypedEdgeApply

This represents the writing format of Cognite describable edge.

It is used when data is written to CDF.

The describable core concept is used as a standard way of holding the bare minimum of information about the instance

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite describable edge.
type (DirectRelationReference | tuple[str, str]) – The type of edge.
start_node (DirectRelationReference | tuple[str, str]) – Reference to the direct relation. The reference consists of a space and an external-id.
end_node (DirectRelationReference | tuple[str, str]) – Reference to the direct relation. The reference consists of a space and an external-id.
name (str | None | Omitted) – Name of the instance
description (str | None | Omitted) – Description of the instance
tags (list[str] | None | Omitted) – Text based labels for generic use, limited to 1000
aliases (list[str] | None | Omitted) – Alternative names for the node
existing_version (int | None) – Fail the ingestion request if the edge’s version is greater than or equal to this value. If no existingVersion is specified, the ingestion will always overwrite any existing data for the edge (for the specified container or edge). If existingVersion is set to 0, the upsert will behave as an insert, so it will fail the bulk if the item already exists. If skipOnVersionConflict is set on the ingestion request, then the item will be skipped instead of failing the ingestion request.

class cognite.client.data_classes.data_modeling.cdm.v1.CogniteDescribableNode( space: str, external_id: str, version: int, last_updated_time: int, created_time: int, *, name: str | None = None, description: str | None = None, tags: list[str] | None = None, aliases: list[str] | None = None, type: DirectRelationReference | None = None, deleted_time: int | None = None, )

Bases: _CogniteDescribableProperties, TypedNode

This represents the reading format of Cognite describable node.

It is used when data is read from CDF.

The describable core concept is used as a standard way of holding the bare minimum of information about the instance

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite describable node.
version (int) – DMS version.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
name (str | None) – Name of the instance
description (str | None) – Description of the instance
tags (list[str] | None) – Text based labels for generic use, limited to 1000
aliases (list[str] | None) – Alternative names for the node
type (DirectRelationReference | None) – Direct relation pointing to the type node.
deleted_time (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds. Timestamp when the instance was soft deleted. Note that deleted instances are filtered out of query results, but present in sync results

class cognite.client.data_classes.data_modeling.cdm.v1.CogniteDescribableNodeApply( space: str, external_id: str, *, name: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, description: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, tags: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, aliases: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, existing_version: int | None = None, type: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, )

Bases: _CogniteDescribableProperties, TypedNodeApply

This represents the writing format of Cognite describable node.

It is used when data is written to CDF.

The describable core concept is used as a standard way of holding the bare minimum of information about the instance

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite describable node.
name (str | None | Omitted) – Name of the instance
description (str | None | Omitted) – Description of the instance
tags (list[str] | None | Omitted) – Text based labels for generic use, limited to 1000
aliases (list[str] | None | Omitted) – Alternative names for the node
existing_version (int | None) – Fail the ingestion request if the node’s version is greater than or equal to this value. If no existingVersion is specified, the ingestion will always overwrite any existing data for the node (for the specified container or node). If existingVersion is set to 0, the upsert will behave as an insert, so it will fail the bulk if the item already exists. If skipOnVersionConflict is set on the ingestion request, then the item will be skipped instead of failing the ingestion request.
type (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation pointing to the type node.

class cognite.client.data_classes.data_modeling.cdm.v1.CogniteDiagramAnnotation( space: str, external_id: str, type: DirectRelationReference, start_node: DirectRelationReference, end_node: DirectRelationReference, version: int, last_updated_time: int, created_time: int, *, name: str | None = None, description: str | None = None, tags: list[str] | None = None, aliases: list[str] | None = None, source_id: str | None = None, source_context: str | None = None, source: DirectRelationReference | None = None, source_created_time: datetime | None = None, source_updated_time: datetime | None = None, source_created_user: str | None = None, source_updated_user: str | None = None, confidence: float | None = None, status: Literal['Approved', 'Rejected', 'Suggested'] | None = None, start_node_page_number: int | None = None, end_node_page_number: int | None = None, start_node_x_min: float | None = None, start_node_x_max: float | None = None, start_node_y_min: float | None = None, start_node_y_max: float | None = None, start_node_text: str | None = None, end_node_x_min: float | None = None, end_node_x_max: float | None = None, end_node_y_min: float | None = None, end_node_y_max: float | None = None, end_node_text: str | None = None, deleted_time: int | None = None, )

Bases: _CogniteDiagramAnnotationProperties, TypedEdge

This represents the reading format of Cognite diagram annotation.

It is used when data is read from CDF.

Annotation for diagrams

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite diagram annotation.
type (DirectRelationReference) – The type of edge.
start_node (DirectRelationReference) – Reference to the direct relation. The reference consists of a space and an external-id.
end_node (DirectRelationReference) – Reference to the direct relation. The reference consists of a space and an external-id.
version (int) – DMS version.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
name (str | None) – Name of the instance
description (str | None) – Description of the instance
tags (list[str] | None) – Text based labels for generic use, limited to 1000
aliases (list[str] | None) – Alternative names for the node
source_id (str | None) – Identifier from the source system
source_context (str | None) – Context of the source id. For systems where the sourceId is globally unique, the sourceContext is expected to not be set.
source (DirectRelationReference | None) – Direct relation to a source system
source_created_time (datetime | None) – When the instance was created in source system (if available)
source_updated_time (datetime | None) – When the instance was last updated in the source system (if available)
source_created_user (str | None) – User identifier from the source system on who created the source data. This identifier is not guaranteed to match the user identifiers in CDF
source_updated_user (str | None) – User identifier from the source system on who last updated the source data. This identifier is not guaranteed to match the user identifiers in CDF
confidence (float | None) – The confidence that the annotation is a good match
status (Literal['Approved', 'Rejected', 'Suggested'] | None) – The status of the annotation
start_node_page_number (int | None) – The number of the page on which this annotation is located in startNode File. The first page has number 1
end_node_page_number (int | None) – The number of the page on which this annotation is located in the endNode File if an endNode is present. The first page has number 1
start_node_x_min (float | None) – Value between [0,1]. Minimum abscissa of the bounding box (left edge). Must be strictly less than startNodeXMax
start_node_x_max (float | None) – Value between [0,1]. Maximum abscissa of the bounding box (right edge). Must be strictly more than startNodeXMin
start_node_y_min (float | None) – Value between [0,1]. Minimum ordinate of the bounding box (bottom edge). Must be strictly less than startNodeYMax
start_node_y_max (float | None) – Value between [0,1]. Maximum ordinate of the bounding box (top edge). Must be strictly more than startNodeYMin
start_node_text (str | None) – The text extracted from within the bounding box on the startNode
end_node_x_min (float | None) – Value between [0,1]. Minimum abscissa of the bounding box (left edge). Must be strictly less than endNodeXMax. Only applicable if an endNode is defined
end_node_x_max (float | None) – Value between [0,1]. Maximum abscissa of the bounding box (right edge). Must be strictly more than endNodeXMin. Only applicable if an endNode is defined
end_node_y_min (float | None) – Value between [0,1]. Minimum ordinate of the bounding box (bottom edge). Must be strictly less than endNodeYMax. Only applicable if an endNode is defined
end_node_y_max (float | None) – Value between [0,1]. Maximum ordinate of the bounding box (top edge). Must be strictly more than endNodeYMin. Only applicable if an endNode is defined
end_node_text (str | None) – The text extracted from within the bounding box on the endNode. Only applicable if an endNode is defined
deleted_time (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds. Timestamp when the instance was soft deleted. Note that deleted instances are filtered out of query results, but present in sync results

class cognite.client.data_classes.data_modeling.cdm.v1.CogniteDiagramAnnotationApply(space: str, external_id: str, type: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str], start_node: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str], end_node: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str], *, name: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, description: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, tags: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, aliases: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_id: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_context: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_created_time: ~datetime.datetime | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_updated_time: ~datetime.datetime | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_created_user: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_updated_user: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, confidence: float | None | ~cognite.client._constants.Omitted = <Omitted parameter>, status: ~typing.Literal['Approved', 'Rejected', 'Suggested'] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, start_node_page_number: int | None | ~cognite.client._constants.Omitted = <Omitted parameter>, end_node_page_number: int | None | ~cognite.client._constants.Omitted = <Omitted parameter>, start_node_x_min: float | None | ~cognite.client._constants.Omitted = <Omitted parameter>, start_node_x_max: float | None | ~cognite.client._constants.Omitted = <Omitted parameter>, start_node_y_min: float | None | ~cognite.client._constants.Omitted = <Omitted parameter>, start_node_y_max: float | None | ~cognite.client._constants.Omitted = <Omitted parameter>, start_node_text: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, end_node_x_min: float | None | ~cognite.client._constants.Omitted = <Omitted parameter>, end_node_x_max: float | None | ~cognite.client._constants.Omitted = <Omitted parameter>, end_node_y_min: float | None | ~cognite.client._constants.Omitted = <Omitted parameter>, end_node_y_max: float | None | ~cognite.client._constants.Omitted = <Omitted parameter>, end_node_text: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, existing_version: int | None = None)

Bases: _CogniteDiagramAnnotationProperties, TypedEdgeApply

This represents the writing format of Cognite diagram annotation.

It is used when data is written to CDF.

Annotation for diagrams

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite diagram annotation.
type (DirectRelationReference | tuple[str, str]) – The type of edge.
start_node (DirectRelationReference | tuple[str, str]) – Reference to the direct relation. The reference consists of a space and an external-id.
end_node (DirectRelationReference | tuple[str, str]) – Reference to the direct relation. The reference consists of a space and an external-id.
name (str | None | Omitted) – Name of the instance
description (str | None | Omitted) – Description of the instance
tags (list[str] | None | Omitted) – Text based labels for generic use, limited to 1000
aliases (list[str] | None | Omitted) – Alternative names for the node
source_id (str | None | Omitted) – Identifier from the source system
source_context (str | None | Omitted) – Context of the source id. For systems where the sourceId is globally unique, the sourceContext is expected to not be set.
source (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation to a source system
source_created_time (datetime | None | Omitted) – When the instance was created in source system (if available)
source_updated_time (datetime | None | Omitted) – When the instance was last updated in the source system (if available)
source_created_user (str | None | Omitted) – User identifier from the source system on who created the source data. This identifier is not guaranteed to match the user identifiers in CDF
source_updated_user (str | None | Omitted) – User identifier from the source system on who last updated the source data. This identifier is not guaranteed to match the user identifiers in CDF
confidence (float | None | Omitted) – The confidence that the annotation is a good match
status (Literal['Approved', 'Rejected', 'Suggested'] | None | Omitted) – The status of the annotation
start_node_page_number (int | None | Omitted) – The number of the page on which this annotation is located in startNode File. The first page has number 1
end_node_page_number (int | None | Omitted) – The number of the page on which this annotation is located in the endNode File if an endNode is present. The first page has number 1
start_node_x_min (float | None | Omitted) – Value between [0,1]. Minimum abscissa of the bounding box (left edge). Must be strictly less than startNodeXMax
start_node_x_max (float | None | Omitted) – Value between [0,1]. Maximum abscissa of the bounding box (right edge). Must be strictly more than startNodeXMin
start_node_y_min (float | None | Omitted) – Value between [0,1]. Minimum ordinate of the bounding box (bottom edge). Must be strictly less than startNodeYMax
start_node_y_max (float | None | Omitted) – Value between [0,1]. Maximum ordinate of the bounding box (top edge). Must be strictly more than startNodeYMin
start_node_text (str | None | Omitted) – The text extracted from within the bounding box on the startNode
end_node_x_min (float | None | Omitted) – Value between [0,1]. Minimum abscissa of the bounding box (left edge). Must be strictly less than endNodeXMax. Only applicable if an endNode is defined
end_node_x_max (float | None | Omitted) – Value between [0,1]. Maximum abscissa of the bounding box (right edge). Must be strictly more than endNodeXMin. Only applicable if an endNode is defined
end_node_y_min (float | None | Omitted) – Value between [0,1]. Minimum ordinate of the bounding box (bottom edge). Must be strictly less than endNodeYMax. Only applicable if an endNode is defined
end_node_y_max (float | None | Omitted) – Value between [0,1]. Maximum ordinate of the bounding box (top edge). Must be strictly more than endNodeYMin. Only applicable if an endNode is defined
end_node_text (str | None | Omitted) – The text extracted from within the bounding box on the endNode. Only applicable if an endNode is defined
existing_version (int | None) – Fail the ingestion request if the edge’s version is greater than or equal to this value. If no existingVersion is specified, the ingestion will always overwrite any existing data for the edge (for the specified container or edge). If existingVersion is set to 0, the upsert will behave as an insert, so it will fail the bulk if the item already exists. If skipOnVersionConflict is set on the ingestion request, then the item will be skipped instead of failing the ingestion request.

class cognite.client.data_classes.data_modeling.cdm.v1.CogniteEquipment( space: str, external_id: str, version: int, last_updated_time: int, created_time: int, *, name: str | None = None, description: str | None = None, tags: list[str] | None = None, aliases: list[str] | None = None, source_id: str | None = None, source_context: str | None = None, source: DirectRelationReference | None = None, source_created_time: datetime | None = None, source_updated_time: datetime | None = None, source_created_user: str | None = None, source_updated_user: str | None = None, asset: DirectRelationReference | None = None, serial_number: str | None = None, manufacturer: str | None = None, equipment_type: DirectRelationReference | None = None, files: list[DirectRelationReference] | None = None, type: DirectRelationReference | None = None, deleted_time: int | None = None, )

Bases: _CogniteEquipmentProperties, TypedNode

This represents the reading format of Cognite equipment.

It is used when data is read from CDF.

Equipment represents physical supplies or devices.

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite equipment.
version (int) – DMS version.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
name (str | None) – Name of the instance
description (str | None) – Description of the instance
tags (list[str] | None) – Text based labels for generic use, limited to 1000
aliases (list[str] | None) – Alternative names for the node
source_id (str | None) – Identifier from the source system
source_context (str | None) – Context of the source id. For systems where the sourceId is globally unique, the sourceContext is expected to not be set.
source (DirectRelationReference | None) – Direct relation to a source system
source_created_time (datetime | None) – When the instance was created in source system (if available)
source_updated_time (datetime | None) – When the instance was last updated in the source system (if available)
source_created_user (str | None) – User identifier from the source system on who created the source data. This identifier is not guaranteed to match the user identifiers in CDF
source_updated_user (str | None) – User identifier from the source system on who last updated the source data. This identifier is not guaranteed to match the user identifiers in CDF
asset (DirectRelationReference | None) – The asset the equipment is related to.
serial_number (str | None) – The serial number of the equipment.
manufacturer (str | None) – The manufacturer of the equipment.
equipment_type (DirectRelationReference | None) – Specifies the type of the equipment. It’s a direct relation to CogniteEquipmentType.
files (list[DirectRelationReference] | None) – A list of files the equipment relates to.
type (DirectRelationReference | None) – Direct relation pointing to the type node.
deleted_time (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds. Timestamp when the instance was soft deleted. Note that deleted instances are filtered out of query results, but present in sync results

class cognite.client.data_classes.data_modeling.cdm.v1.CogniteEquipmentApply( space: str, external_id: str, *, name: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, description: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, tags: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, aliases: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_id: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_context: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_created_time: ~datetime.datetime | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_updated_time: ~datetime.datetime | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_created_user: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_updated_user: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, asset: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, serial_number: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, manufacturer: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, equipment_type: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, files: list[~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str]] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, existing_version: int | None = None, type: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, )

Bases: _CogniteEquipmentProperties, TypedNodeApply

This represents the writing format of Cognite equipment.

It is used when data is written to CDF.

Equipment represents physical supplies or devices.

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite equipment.
name (str | None | Omitted) – Name of the instance
description (str | None | Omitted) – Description of the instance
tags (list[str] | None | Omitted) – Text based labels for generic use, limited to 1000
aliases (list[str] | None | Omitted) – Alternative names for the node
source_id (str | None | Omitted) – Identifier from the source system
source_context (str | None | Omitted) – Context of the source id. For systems where the sourceId is globally unique, the sourceContext is expected to not be set.
source (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation to a source system
source_created_time (datetime | None | Omitted) – When the instance was created in source system (if available)
source_updated_time (datetime | None | Omitted) – When the instance was last updated in the source system (if available)
source_created_user (str | None | Omitted) – User identifier from the source system on who created the source data. This identifier is not guaranteed to match the user identifiers in CDF
source_updated_user (str | None | Omitted) – User identifier from the source system on who last updated the source data. This identifier is not guaranteed to match the user identifiers in CDF
asset (DirectRelationReference | tuple[str, str] | None | Omitted) – The asset the equipment is related to.
serial_number (str | None | Omitted) – The serial number of the equipment.
manufacturer (str | None | Omitted) – The manufacturer of the equipment.
equipment_type (DirectRelationReference | tuple[str, str] | None | Omitted) – Specifies the type of the equipment. It’s a direct relation to CogniteEquipmentType.
files (list[DirectRelationReference | tuple[str, str]] | None | Omitted) – A list of files the equipment relates to.
existing_version (int | None) – Fail the ingestion request if the node’s version is greater than or equal to this value. If no existingVersion is specified, the ingestion will always overwrite any existing data for the node (for the specified container or node). If existingVersion is set to 0, the upsert will behave as an insert, so it will fail the bulk if the item already exists. If skipOnVersionConflict is set on the ingestion request, then the item will be skipped instead of failing the ingestion request.
type (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation pointing to the type node.

class cognite.client.data_classes.data_modeling.cdm.v1.CogniteEquipmentType( space: str, external_id: str, version: int, last_updated_time: int, created_time: int, *, name: str | None = None, description: str | None = None, tags: list[str] | None = None, aliases: list[str] | None = None, code: str | None = None, equipment_class: str | None = None, standard: str | None = None, standard_reference: str | None = None, type: DirectRelationReference | None = None, deleted_time: int | None = None, )

Bases: _CogniteEquipmentTypeProperties, TypedNode

This represents the reading format of Cognite equipment type.

It is used when data is read from CDF.

Represents the type of equipment.

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite equipment type.
version (int) – DMS version.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
name (str | None) – Name of the instance
description (str | None) – Description of the instance
tags (list[str] | None) – Text based labels for generic use, limited to 1000
aliases (list[str] | None) – Alternative names for the node
code (str | None) – A unique identifier for the type of equipment.
equipment_class (str | None) – Represents the class of equipment.
standard (str | None) – An identifier for the standard this equipment type is sourced from, for example, ISO14224.
standard_reference (str | None) – A reference to the source of the equipment standard.
type (DirectRelationReference | None) – Direct relation pointing to the type node.
deleted_time (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds. Timestamp when the instance was soft deleted. Note that deleted instances are filtered out of query results, but present in sync results

class cognite.client.data_classes.data_modeling.cdm.v1.CogniteEquipmentTypeApply( space: str, external_id: str, *, name: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, description: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, tags: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, aliases: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, code: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, equipment_class: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, standard: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, standard_reference: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, existing_version: int | None = None, type: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, )

Bases: _CogniteEquipmentTypeProperties, TypedNodeApply

This represents the writing format of Cognite equipment type.

It is used when data is written to CDF.

Represents the type of equipment.

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite equipment type.
name (str | None | Omitted) – Name of the instance
description (str | None | Omitted) – Description of the instance
tags (list[str] | None | Omitted) – Text based labels for generic use, limited to 1000
aliases (list[str] | None | Omitted) – Alternative names for the node
code (str | None | Omitted) – A unique identifier for the type of equipment.
equipment_class (str | None | Omitted) – Represents the class of equipment.
standard (str | None | Omitted) – An identifier for the standard this equipment type is sourced from, for example, ISO14224.
standard_reference (str | None | Omitted) – A reference to the source of the equipment standard.
existing_version (int | None) – Fail the ingestion request if the node’s version is greater than or equal to this value. If no existingVersion is specified, the ingestion will always overwrite any existing data for the node (for the specified container or node). If existingVersion is set to 0, the upsert will behave as an insert, so it will fail the bulk if the item already exists. If skipOnVersionConflict is set on the ingestion request, then the item will be skipped instead of failing the ingestion request.
type (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation pointing to the type node.

class cognite.client.data_classes.data_modeling.cdm.v1.CogniteFile( space: str, external_id: str, version: int, last_updated_time: int, created_time: int, *, name: str | None = None, description: str | None = None, tags: list[str] | None = None, aliases: list[str] | None = None, source_id: str | None = None, source_context: str | None = None, source: DirectRelationReference | None = None, source_created_time: datetime | None = None, source_updated_time: datetime | None = None, source_created_user: str | None = None, source_updated_user: str | None = None, assets: list[DirectRelationReference] | None = None, mime_type: str | None = None, directory: str | None = None, is_uploaded: bool | None = None, uploaded_time: datetime | None = None, category: DirectRelationReference | None = None, type: DirectRelationReference | None = None, deleted_time: int | None = None, )

Bases: _CogniteFileProperties, TypedNode

This represents the reading format of Cognite file.

It is used when data is read from CDF.

Represents files.

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite file.
version (int) – DMS version.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
name (str | None) – Name of the instance
description (str | None) – Description of the instance
tags (list[str] | None) – Text based labels for generic use, limited to 1000
aliases (list[str] | None) – Alternative names for the node
source_id (str | None) – Identifier from the source system
source_context (str | None) – Context of the source id. For systems where the sourceId is globally unique, the sourceContext is expected to not be set.
source (DirectRelationReference | None) – Direct relation to a source system
source_created_time (datetime | None) – When the instance was created in source system (if available)
source_updated_time (datetime | None) – When the instance was last updated in the source system (if available)
source_created_user (str | None) – User identifier from the source system on who created the source data. This identifier is not guaranteed to match the user identifiers in CDF
source_updated_user (str | None) – User identifier from the source system on who last updated the source data. This identifier is not guaranteed to match the user identifiers in CDF
assets (list[DirectRelationReference] | None) – A list of assets this file is related to.
mime_type (str | None) – The MIME type of the file.
directory (str | None) – Contains the path elements from the source (if the source system has a file system hierarchy or similar.)
is_uploaded (bool | None) – Specifies if the file content has been uploaded to Cognite Data Fusion or not.
uploaded_time (datetime | None) – The time the file upload completed.
category (DirectRelationReference | None) – Specifies the detected category the file belongs to. It’s a direct relation to an instance of CogniteFileCategory.
type (DirectRelationReference | None) – Direct relation pointing to the type node.
deleted_time (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds. Timestamp when the instance was soft deleted. Note that deleted instances are filtered out of query results, but present in sync results

class cognite.client.data_classes.data_modeling.cdm.v1.CogniteFileApply( space: str, external_id: str, *, name: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, description: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, tags: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, aliases: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_id: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_context: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_created_time: ~datetime.datetime | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_updated_time: ~datetime.datetime | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_created_user: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_updated_user: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, assets: list[~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str]] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, mime_type: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, directory: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, category: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, existing_version: int | None = None, type: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, )

Bases: _CogniteFileProperties, TypedNodeApply

This represents the writing format of Cognite file.

It is used when data is written to CDF.

Represents files.

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite file.
name (str | None | Omitted) – Name of the instance
description (str | None | Omitted) – Description of the instance
tags (list[str] | None | Omitted) – Text based labels for generic use, limited to 1000
aliases (list[str] | None | Omitted) – Alternative names for the node
source_id (str | None | Omitted) – Identifier from the source system
source_context (str | None | Omitted) – Context of the source id. For systems where the sourceId is globally unique, the sourceContext is expected to not be set.
source (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation to a source system
source_created_time (datetime | None | Omitted) – When the instance was created in source system (if available)
source_updated_time (datetime | None | Omitted) – When the instance was last updated in the source system (if available)
source_created_user (str | None | Omitted) – User identifier from the source system on who created the source data. This identifier is not guaranteed to match the user identifiers in CDF
source_updated_user (str | None | Omitted) – User identifier from the source system on who last updated the source data. This identifier is not guaranteed to match the user identifiers in CDF
assets (list[DirectRelationReference | tuple[str, str]] | None | Omitted) – A list of assets this file is related to.
mime_type (str | None | Omitted) – The MIME type of the file.
directory (str | None | Omitted) – Contains the path elements from the source (if the source system has a file system hierarchy or similar.)
category (DirectRelationReference | tuple[str, str] | None | Omitted) – Specifies the detected category the file belongs to. It’s a direct relation to an instance of CogniteFileCategory.
existing_version (int | None) – Fail the ingestion request if the node’s version is greater than or equal to this value. If no existingVersion is specified, the ingestion will always overwrite any existing data for the node (for the specified container or node). If existingVersion is set to 0, the upsert will behave as an insert, so it will fail the bulk if the item already exists. If skipOnVersionConflict is set on the ingestion request, then the item will be skipped instead of failing the ingestion request.
type (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation pointing to the type node.

class cognite.client.data_classes.data_modeling.cdm.v1.CogniteFileCategory( space: str, external_id: str, version: int, last_updated_time: int, created_time: int, *, code: str, name: str | None = None, description: str | None = None, tags: list[str] | None = None, aliases: list[str] | None = None, standard: str | None = None, standard_reference: str | None = None, type: DirectRelationReference | None = None, deleted_time: int | None = None, )

Bases: _CogniteFileCategoryProperties, TypedNode

This represents the reading format of Cognite file category.

It is used when data is read from CDF.

Represents the categories of files as determined by contextualization or categorization.

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite file category.
version (int) – DMS version.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
code (str) – An identifier for the category, for example, ‘AA’ for Accounting (from Norsok.)
name (str | None) – Name of the instance
description (str | None) – Description of the instance
tags (list[str] | None) – Text based labels for generic use, limited to 1000
aliases (list[str] | None) – Alternative names for the node
standard (str | None) – The name of the standard the category originates from, for example, ‘Norsok’.
standard_reference (str | None) – A reference to the source of the category standard.
type (DirectRelationReference | None) – Direct relation pointing to the type node.
deleted_time (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds. Timestamp when the instance was soft deleted. Note that deleted instances are filtered out of query results, but present in sync results

class cognite.client.data_classes.data_modeling.cdm.v1.CogniteFileCategoryApply( space: str, external_id: str, *, code: str, name: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, description: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, tags: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, aliases: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, standard: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, standard_reference: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, existing_version: int | None = None, type: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, )

Bases: _CogniteFileCategoryProperties, TypedNodeApply

This represents the writing format of Cognite file category.

It is used when data is written to CDF.

Represents the categories of files as determined by contextualization or categorization.

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite file category.
code (str) – An identifier for the category, for example, ‘AA’ for Accounting (from Norsok.)
name (str | None | Omitted) – Name of the instance
description (str | None | Omitted) – Description of the instance
tags (list[str] | None | Omitted) – Text based labels for generic use, limited to 1000
aliases (list[str] | None | Omitted) – Alternative names for the node
standard (str | None | Omitted) – The name of the standard the category originates from, for example, ‘Norsok’.
standard_reference (str | None | Omitted) – A reference to the source of the category standard.
existing_version (int | None) – Fail the ingestion request if the node’s version is greater than or equal to this value. If no existingVersion is specified, the ingestion will always overwrite any existing data for the node (for the specified container or node). If existingVersion is set to 0, the upsert will behave as an insert, so it will fail the bulk if the item already exists. If skipOnVersionConflict is set on the ingestion request, then the item will be skipped instead of failing the ingestion request.
type (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation pointing to the type node.

class cognite.client.data_classes.data_modeling.cdm.v1.CognitePointCloudModel( space: str, external_id: str, version: int, last_updated_time: int, created_time: int, *, name: str | None = None, description: str | None = None, tags: list[str] | None = None, aliases: list[str] | None = None, model_type: Literal['CAD', 'Image360', 'PointCloud'] | None = None, thumbnail: DirectRelationReference | None = None, type: DirectRelationReference | None = None, deleted_time: int | None = None, )

Bases: _CognitePointCloudModelProperties, TypedNode

This represents the reading format of Cognite point cloud model.

It is used when data is read from CDF.

Navigational aid for traversing CognitePointCloudModel instances

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite point cloud model.
version (int) – DMS version.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
name (str | None) – Name of the instance
description (str | None) – Description of the instance
tags (list[str] | None) – Text based labels for generic use, limited to 1000
aliases (list[str] | None) – Alternative names for the node
model_type (Literal['CAD', 'Image360', 'PointCloud'] | None) – CAD, PointCloud or Image360
thumbnail (DirectRelationReference | None) – Thumbnail of the 3D model
type (DirectRelationReference | None) – Direct relation pointing to the type node.
deleted_time (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds. Timestamp when the instance was soft deleted. Note that deleted instances are filtered out of query results, but present in sync results

class cognite.client.data_classes.data_modeling.cdm.v1.CognitePointCloudModelApply( space: str, external_id: str, *, name: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, description: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, tags: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, aliases: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, model_type: ~typing.Literal['CAD', 'Image360', 'PointCloud'] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, thumbnail: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, existing_version: int | None = None, type: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, )

Bases: _CognitePointCloudModelProperties, TypedNodeApply

This represents the writing format of Cognite point cloud model.

It is used when data is written to CDF.

Navigational aid for traversing CognitePointCloudModel instances

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite point cloud model.
name (str | None | Omitted) – Name of the instance
description (str | None | Omitted) – Description of the instance
tags (list[str] | None | Omitted) – Text based labels for generic use, limited to 1000
aliases (list[str] | None | Omitted) – Alternative names for the node
model_type (Literal['CAD', 'Image360', 'PointCloud'] | None | Omitted) – CAD, PointCloud or Image360
thumbnail (DirectRelationReference | tuple[str, str] | None | Omitted) – Thumbnail of the 3D model
existing_version (int | None) – Fail the ingestion request if the node’s version is greater than or equal to this value. If no existingVersion is specified, the ingestion will always overwrite any existing data for the node (for the specified container or node). If existingVersion is set to 0, the upsert will behave as an insert, so it will fail the bulk if the item already exists. If skipOnVersionConflict is set on the ingestion request, then the item will be skipped instead of failing the ingestion request.
type (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation pointing to the type node.

class cognite.client.data_classes.data_modeling.cdm.v1.CognitePointCloudRevision( space: str, external_id: str, version: int, last_updated_time: int, created_time: int, *, status: Literal['Done', 'Failed', 'Processing', 'Queued'] | None = None, published: bool | None = None, revision_type: Literal['CAD', 'Image360', 'PointCloud'] | None = None, model_3d: DirectRelationReference | None = None, revision_id: int | None = None, type: DirectRelationReference | None = None, deleted_time: int | None = None, )

Bases: _CognitePointCloudRevisionProperties, TypedNode

This represents the reading format of Cognite point cloud revision.

It is used when data is read from CDF.

Navigational aid for traversing CognitePointCloudRevision instances

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite point cloud revision.
version (int) – DMS version.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
status (Literal['Done', 'Failed', 'Processing', 'Queued'] | None) – The status field.
published (bool | None) – The published field.
revision_type (Literal['CAD', 'Image360', 'PointCloud'] | None) – The revision type field.
model_3d (DirectRelationReference | None) –
.
revision_id (int | None) – The 3D API revision identifier for this PointCloud model
type (DirectRelationReference | None) – Direct relation pointing to the type node.
deleted_time (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds. Timestamp when the instance was soft deleted. Note that deleted instances are filtered out of query results, but present in sync results

class cognite.client.data_classes.data_modeling.cdm.v1.CognitePointCloudRevisionApply( space: str, external_id: str, *, status: ~typing.Literal['Done', 'Failed', 'Processing', 'Queued'] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, published: bool | None | ~cognite.client._constants.Omitted = <Omitted parameter>, revision_type: ~typing.Literal['CAD', 'Image360', 'PointCloud'] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, model_3d: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, revision_id: int | None | ~cognite.client._constants.Omitted = <Omitted parameter>, existing_version: int | None = None, type: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, )

Bases: _CognitePointCloudRevisionProperties, TypedNodeApply

This represents the writing format of Cognite point cloud revision.

It is used when data is written to CDF.

Navigational aid for traversing CognitePointCloudRevision instances

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite point cloud revision.
status (Literal['Done', 'Failed', 'Processing', 'Queued'] | None | Omitted) – The status field.
published (bool | None | Omitted) – The published field.
revision_type (Literal['CAD', 'Image360', 'PointCloud'] | None | Omitted) – The revision type field.
model_3d (DirectRelationReference | tuple[str, str] | None | Omitted) –
.
revision_id (int | None | Omitted) – The 3D API revision identifier for this PointCloud model
existing_version (int | None) – Fail the ingestion request if the node’s version is greater than or equal to this value. If no existingVersion is specified, the ingestion will always overwrite any existing data for the node (for the specified container or node). If existingVersion is set to 0, the upsert will behave as an insert, so it will fail the bulk if the item already exists. If skipOnVersionConflict is set on the ingestion request, then the item will be skipped instead of failing the ingestion request.
type (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation pointing to the type node.

class cognite.client.data_classes.data_modeling.cdm.v1.CognitePointCloudVolume( space: str, external_id: str, version: int, last_updated_time: int, created_time: int, *, name: str | None = None, description: str | None = None, tags: list[str] | None = None, aliases: list[str] | None = None, object_3d: DirectRelationReference | None = None, model_3d: DirectRelationReference | None = None, volume_references: list[str] | None = None, revisions: list[DirectRelationReference] | None = None, volume_type: Literal['Box', 'Cylinder'] | None = None, volume: list[float] | None = None, format_version: str | None = None, type: DirectRelationReference | None = None, deleted_time: int | None = None, )

Bases: _CognitePointCloudVolumeProperties, TypedNode

This represents the reading format of Cognite point cloud volume.

It is used when data is read from CDF.

PointCloud volume definition

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite point cloud volume.
version (int) – DMS version.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
name (str | None) – Name of the instance
description (str | None) – Description of the instance
tags (list[str] | None) – Text based labels for generic use, limited to 1000
aliases (list[str] | None) – Alternative names for the node
object_3d (DirectRelationReference | None) – Direct relation to object3D grouping for this node
model_3d (DirectRelationReference | None) – Direct relation to Cognite3DModel instance
volume_references (list[str] | None) – Unique volume metric hashes used to access the 3D specialized data storage
revisions (list[DirectRelationReference] | None) – List of direct relations to revision information
volume_type (Literal['Box', 'Cylinder'] | None) – Type of volume (Cylinder or Box)
volume (list[float] | None) – Relevant coordinates for the volume type, 9 floats in total, that defines the volume
format_version (str | None) – Specifies the version the ‘volume’ field is following. Volume definition is today 9 floats (property volume)
type (DirectRelationReference | None) – Direct relation pointing to the type node.
deleted_time (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds. Timestamp when the instance was soft deleted. Note that deleted instances are filtered out of query results, but present in sync results

class cognite.client.data_classes.data_modeling.cdm.v1.CognitePointCloudVolumeApply( space: str, external_id: str, *, name: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, description: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, tags: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, aliases: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, object_3d: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, model_3d: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, volume_references: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, revisions: list[~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str]] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, volume_type: ~typing.Literal['Box', 'Cylinder'] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, volume: list[float] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, format_version: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, existing_version: int | None = None, type: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, )

Bases: _CognitePointCloudVolumeProperties, TypedNodeApply

This represents the writing format of Cognite point cloud volume.

It is used when data is written to CDF.

PointCloud volume definition

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite point cloud volume.
name (str | None | Omitted) – Name of the instance
description (str | None | Omitted) – Description of the instance
tags (list[str] | None | Omitted) – Text based labels for generic use, limited to 1000
aliases (list[str] | None | Omitted) – Alternative names for the node
object_3d (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation to object3D grouping for this node
model_3d (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation to Cognite3DModel instance
volume_references (list[str] | None | Omitted) – Unique volume metric hashes used to access the 3D specialized data storage
revisions (list[DirectRelationReference | tuple[str, str]] | None | Omitted) – List of direct relations to revision information
volume_type (Literal['Box', 'Cylinder'] | None | Omitted) – Type of volume (Cylinder or Box)
volume (list[float] | None | Omitted) – Relevant coordinates for the volume type, 9 floats in total, that defines the volume
format_version (str | None | Omitted) – Specifies the version the ‘volume’ field is following. Volume definition is today 9 floats (property volume)
existing_version (int | None) – Fail the ingestion request if the node’s version is greater than or equal to this value. If no existingVersion is specified, the ingestion will always overwrite any existing data for the node (for the specified container or node). If existingVersion is set to 0, the upsert will behave as an insert, so it will fail the bulk if the item already exists. If skipOnVersionConflict is set on the ingestion request, then the item will be skipped instead of failing the ingestion request.
type (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation pointing to the type node.

class cognite.client.data_classes.data_modeling.cdm.v1.CogniteSchedulable( space: str, external_id: str, version: int, last_updated_time: int, created_time: int, *, start_time: datetime | None = None, end_time: datetime | None = None, scheduled_start_time: datetime | None = None, scheduled_end_time: datetime | None = None, type: DirectRelationReference | None = None, deleted_time: int | None = None, )

Bases: _CogniteSchedulableProperties, TypedNode

This represents the reading format of Cognite schedulable.

It is used when data is read from CDF.

CogniteSchedulable represents the metadata about when an activity (or similar) starts and ends.

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite schedulable.
version (int) – DMS version.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
start_time (datetime | None) – The actual start time of an activity (or similar that extends this)
end_time (datetime | None) – The actual end time of an activity (or similar that extends this)
scheduled_start_time (datetime | None) – The planned start time of an activity (or similar that extends this)
scheduled_end_time (datetime | None) – The planned end time of an activity (or similar that extends this)
type (DirectRelationReference | None) – Direct relation pointing to the type node.
deleted_time (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds. Timestamp when the instance was soft deleted. Note that deleted instances are filtered out of query results, but present in sync results

class cognite.client.data_classes.data_modeling.cdm.v1.CogniteSchedulableApply( space: str, external_id: str, *, start_time: ~datetime.datetime | None | ~cognite.client._constants.Omitted = <Omitted parameter>, end_time: ~datetime.datetime | None | ~cognite.client._constants.Omitted = <Omitted parameter>, scheduled_start_time: ~datetime.datetime | None | ~cognite.client._constants.Omitted = <Omitted parameter>, scheduled_end_time: ~datetime.datetime | None | ~cognite.client._constants.Omitted = <Omitted parameter>, existing_version: int | None = None, type: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, )

Bases: _CogniteSchedulableProperties, TypedNodeApply

This represents the writing format of Cognite schedulable.

It is used when data is written to CDF.

CogniteSchedulable represents the metadata about when an activity (or similar) starts and ends.

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite schedulable.
start_time (datetime | None | Omitted) – The actual start time of an activity (or similar that extends this)
end_time (datetime | None | Omitted) – The actual end time of an activity (or similar that extends this)
scheduled_start_time (datetime | None | Omitted) – The planned start time of an activity (or similar that extends this)
scheduled_end_time (datetime | None | Omitted) – The planned end time of an activity (or similar that extends this)
existing_version (int | None) – Fail the ingestion request if the node’s version is greater than or equal to this value. If no existingVersion is specified, the ingestion will always overwrite any existing data for the node (for the specified container or node). If existingVersion is set to 0, the upsert will behave as an insert, so it will fail the bulk if the item already exists. If skipOnVersionConflict is set on the ingestion request, then the item will be skipped instead of failing the ingestion request.
type (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation pointing to the type node.

class cognite.client.data_classes.data_modeling.cdm.v1.CogniteSourceSystem( space: str, external_id: str, version: int, last_updated_time: int, created_time: int, *, name: str | None = None, description: str | None = None, tags: list[str] | None = None, aliases: list[str] | None = None, source_system_version: str | None = None, manufacturer: str | None = None, type: DirectRelationReference | None = None, deleted_time: int | None = None, )

Bases: _CogniteSourceSystemProperties, TypedNode

This represents the reading format of Cognite source system.

It is used when data is read from CDF.

The CogniteSourceSystem core concept is used to standardize the way source system is stored.

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite source system.
version (int) – DMS version.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
name (str | None) – Name of the instance
description (str | None) – Description of the instance
tags (list[str] | None) – Text based labels for generic use, limited to 1000
aliases (list[str] | None) – Alternative names for the node
source_system_version (str | None) – Version identifier for the source system
manufacturer (str | None) – Manufacturer of the source system
type (DirectRelationReference | None) – Direct relation pointing to the type node.
deleted_time (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds. Timestamp when the instance was soft deleted. Note that deleted instances are filtered out of query results, but present in sync results

class cognite.client.data_classes.data_modeling.cdm.v1.CogniteSourceSystemApply( space: str, external_id: str, *, name: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, description: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, tags: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, aliases: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_system_version: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, manufacturer: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, existing_version: int | None = None, type: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, )

Bases: _CogniteSourceSystemProperties, TypedNodeApply

This represents the writing format of Cognite source system.

It is used when data is written to CDF.

The CogniteSourceSystem core concept is used to standardize the way source system is stored.

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite source system.
name (str | None | Omitted) – Name of the instance
description (str | None | Omitted) – Description of the instance
tags (list[str] | None | Omitted) – Text based labels for generic use, limited to 1000
aliases (list[str] | None | Omitted) – Alternative names for the node
source_system_version (str | None | Omitted) – Version identifier for the source system
manufacturer (str | None | Omitted) – Manufacturer of the source system
existing_version (int | None) – Fail the ingestion request if the node’s version is greater than or equal to this value. If no existingVersion is specified, the ingestion will always overwrite any existing data for the node (for the specified container or node). If existingVersion is set to 0, the upsert will behave as an insert, so it will fail the bulk if the item already exists. If skipOnVersionConflict is set on the ingestion request, then the item will be skipped instead of failing the ingestion request.
type (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation pointing to the type node.

class cognite.client.data_classes.data_modeling.cdm.v1.CogniteSourceableEdge( space: str, external_id: str, type: DirectRelationReference, start_node: DirectRelationReference, end_node: DirectRelationReference, version: int, last_updated_time: int, created_time: int, *, source_id: str | None = None, source_context: str | None = None, source: DirectRelationReference | None = None, source_created_time: datetime | None = None, source_updated_time: datetime | None = None, source_created_user: str | None = None, source_updated_user: str | None = None, deleted_time: int | None = None, )

Bases: _CogniteSourceableProperties, TypedEdge

This represents the reading format of Cognite sourceable edge.

It is used when data is read from CDF.

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite sourceable edge.
type (DirectRelationReference) – The type of edge.
start_node (DirectRelationReference) – Reference to the direct relation. The reference consists of a space and an external-id.
end_node (DirectRelationReference) – Reference to the direct relation. The reference consists of a space and an external-id.
version (int) – DMS version.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
source_id (str | None) – Identifier from the source system
source_context (str | None) – Context of the source id. For systems where the sourceId is globally unique, the sourceContext is expected to not be set.
source (DirectRelationReference | None) – Direct relation to a source system
source_created_time (datetime | None) – When the instance was created in source system (if available)
source_updated_time (datetime | None) – When the instance was last updated in the source system (if available)
source_created_user (str | None) – User identifier from the source system on who created the source data. This identifier is not guaranteed to match the user identifiers in CDF
source_updated_user (str | None) – User identifier from the source system on who last updated the source data. This identifier is not guaranteed to match the user identifiers in CDF
deleted_time (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds. Timestamp when the instance was soft deleted. Note that deleted instances are filtered out of query results, but present in sync results

class cognite.client.data_classes.data_modeling.cdm.v1.CogniteSourceableEdgeApply(space: str, external_id: str, type: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str], start_node: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str], end_node: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str], *, source_id: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_context: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_created_time: ~datetime.datetime | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_updated_time: ~datetime.datetime | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_created_user: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_updated_user: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, existing_version: int | None = None)

Bases: _CogniteSourceableProperties, TypedEdgeApply

This represents the writing format of Cognite sourceable edge.

It is used when data is written to CDF.

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite sourceable edge.
type (DirectRelationReference | tuple[str, str]) – The type of edge.
start_node (DirectRelationReference | tuple[str, str]) – Reference to the direct relation. The reference consists of a space and an external-id.
end_node (DirectRelationReference | tuple[str, str]) – Reference to the direct relation. The reference consists of a space and an external-id.
source_id (str | None | Omitted) – Identifier from the source system
source_context (str | None | Omitted) – Context of the source id. For systems where the sourceId is globally unique, the sourceContext is expected to not be set.
source (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation to a source system
source_created_time (datetime | None | Omitted) – When the instance was created in source system (if available)
source_updated_time (datetime | None | Omitted) – When the instance was last updated in the source system (if available)
source_created_user (str | None | Omitted) – User identifier from the source system on who created the source data. This identifier is not guaranteed to match the user identifiers in CDF
source_updated_user (str | None | Omitted) – User identifier from the source system on who last updated the source data. This identifier is not guaranteed to match the user identifiers in CDF
existing_version (int | None) – Fail the ingestion request if the edge’s version is greater than or equal to this value. If no existingVersion is specified, the ingestion will always overwrite any existing data for the edge (for the specified container or edge). If existingVersion is set to 0, the upsert will behave as an insert, so it will fail the bulk if the item already exists. If skipOnVersionConflict is set on the ingestion request, then the item will be skipped instead of failing the ingestion request.

class cognite.client.data_classes.data_modeling.cdm.v1.CogniteSourceableNode( space: str, external_id: str, version: int, last_updated_time: int, created_time: int, *, source_id: str | None = None, source_context: str | None = None, source: DirectRelationReference | None = None, source_created_time: datetime | None = None, source_updated_time: datetime | None = None, source_created_user: str | None = None, source_updated_user: str | None = None, type: DirectRelationReference | None = None, deleted_time: int | None = None, )

Bases: _CogniteSourceableProperties, TypedNode

This represents the reading format of Cognite sourceable node.

It is used when data is read from CDF.

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite sourceable node.
version (int) – DMS version.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
source_id (str | None) – Identifier from the source system
source_context (str | None) – Context of the source id. For systems where the sourceId is globally unique, the sourceContext is expected to not be set.
source (DirectRelationReference | None) – Direct relation to a source system
source_created_time (datetime | None) – When the instance was created in source system (if available)
source_updated_time (datetime | None) – When the instance was last updated in the source system (if available)
source_created_user (str | None) – User identifier from the source system on who created the source data. This identifier is not guaranteed to match the user identifiers in CDF
source_updated_user (str | None) – User identifier from the source system on who last updated the source data. This identifier is not guaranteed to match the user identifiers in CDF
type (DirectRelationReference | None) – Direct relation pointing to the type node.
deleted_time (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds. Timestamp when the instance was soft deleted. Note that deleted instances are filtered out of query results, but present in sync results

class cognite.client.data_classes.data_modeling.cdm.v1.CogniteSourceableNodeApply( space: str, external_id: str, *, source_id: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_context: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_created_time: ~datetime.datetime | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_updated_time: ~datetime.datetime | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_created_user: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_updated_user: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, existing_version: int | None = None, type: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, )

Bases: _CogniteSourceableProperties, TypedNodeApply

This represents the writing format of Cognite sourceable node.

It is used when data is written to CDF.

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite sourceable node.
source_id (str | None | Omitted) – Identifier from the source system
source_context (str | None | Omitted) – Context of the source id. For systems where the sourceId is globally unique, the sourceContext is expected to not be set.
source (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation to a source system
source_created_time (datetime | None | Omitted) – When the instance was created in source system (if available)
source_updated_time (datetime | None | Omitted) – When the instance was last updated in the source system (if available)
source_created_user (str | None | Omitted) – User identifier from the source system on who created the source data. This identifier is not guaranteed to match the user identifiers in CDF
source_updated_user (str | None | Omitted) – User identifier from the source system on who last updated the source data. This identifier is not guaranteed to match the user identifiers in CDF
existing_version (int | None) – Fail the ingestion request if the node’s version is greater than or equal to this value. If no existingVersion is specified, the ingestion will always overwrite any existing data for the node (for the specified container or node). If existingVersion is set to 0, the upsert will behave as an insert, so it will fail the bulk if the item already exists. If skipOnVersionConflict is set on the ingestion request, then the item will be skipped instead of failing the ingestion request.
type (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation pointing to the type node.

class cognite.client.data_classes.data_modeling.cdm.v1.CogniteTimeSeries( space: str, external_id: str, version: int, last_updated_time: int, created_time: int, *, is_step: bool, time_series_type: Literal['numeric', 'string'], name: str | None = None, description: str | None = None, tags: list[str] | None = None, aliases: list[str] | None = None, source_id: str | None = None, source_context: str | None = None, source: DirectRelationReference | None = None, source_created_time: datetime | None = None, source_updated_time: datetime | None = None, source_created_user: str | None = None, source_updated_user: str | None = None, source_unit: str | None = None, unit: DirectRelationReference | None = None, assets: list[DirectRelationReference] | None = None, equipment: list[DirectRelationReference] | None = None, type: DirectRelationReference | None = None, deleted_time: int | None = None, )

Bases: _CogniteTimeSeriesProperties, TypedNode

This represents the reading format of Cognite time series.

It is used when data is read from CDF.

Represents a series of data points in time order.”

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite time series.
version (int) – DMS version.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
is_step (bool) – Specifies whether the time series is a step time series or not.
time_series_type (Literal['numeric', 'string']) – Specifies the data type of the data points.
name (str | None) – Name of the instance
description (str | None) – Description of the instance
tags (list[str] | None) – Text based labels for generic use, limited to 1000
aliases (list[str] | None) – Alternative names for the node
source_id (str | None) – Identifier from the source system
source_context (str | None) – Context of the source id. For systems where the sourceId is globally unique, the sourceContext is expected to not be set.
source (DirectRelationReference | None) – Direct relation to a source system
source_created_time (datetime | None) – When the instance was created in source system (if available)
source_updated_time (datetime | None) – When the instance was last updated in the source system (if available)
source_created_user (str | None) – User identifier from the source system on who created the source data. This identifier is not guaranteed to match the user identifiers in CDF
source_updated_user (str | None) – User identifier from the source system on who last updated the source data. This identifier is not guaranteed to match the user identifiers in CDF
source_unit (str | None) – The unit specified in the source system.
unit (DirectRelationReference | None) – The unit of the time series.
assets (list[DirectRelationReference] | None) – A list of assets the time series is related to.
equipment (list[DirectRelationReference] | None) – A list of equipment the time series is related to.
type (DirectRelationReference | None) – Direct relation pointing to the type node.
deleted_time (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds. Timestamp when the instance was soft deleted. Note that deleted instances are filtered out of query results, but present in sync results

class cognite.client.data_classes.data_modeling.cdm.v1.CogniteTimeSeriesApply(space: str, external_id: str, *, is_step: bool, time_series_type: ~typing.Literal['numeric', 'string'], name: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, description: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, tags: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, aliases: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_id: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_context: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_created_time: ~datetime.datetime | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_updated_time: ~datetime.datetime | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_created_user: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_updated_user: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_unit: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, unit: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, assets: list[~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str]] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, equipment: list[~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str]] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, existing_version: int | None = None, type: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>)

Bases: _CogniteTimeSeriesProperties, TypedNodeApply

This represents the writing format of Cognite time series.

It is used when data is written to CDF.

Represents a series of data points in time order.”

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite time series.
is_step (bool) – Specifies whether the time series is a step time series or not.
time_series_type (Literal['numeric', 'string']) – Specifies the data type of the data points.
name (str | None | Omitted) – Name of the instance
description (str | None | Omitted) – Description of the instance
tags (list[str] | None | Omitted) – Text based labels for generic use, limited to 1000
aliases (list[str] | None | Omitted) – Alternative names for the node
source_id (str | None | Omitted) – Identifier from the source system
source_context (str | None | Omitted) – Context of the source id. For systems where the sourceId is globally unique, the sourceContext is expected to not be set.
source (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation to a source system
source_created_time (datetime | None | Omitted) – When the instance was created in source system (if available)
source_updated_time (datetime | None | Omitted) – When the instance was last updated in the source system (if available)
source_created_user (str | None | Omitted) – User identifier from the source system on who created the source data. This identifier is not guaranteed to match the user identifiers in CDF
source_updated_user (str | None | Omitted) – User identifier from the source system on who last updated the source data. This identifier is not guaranteed to match the user identifiers in CDF
source_unit (str | None | Omitted) – The unit specified in the source system.
unit (DirectRelationReference | tuple[str, str] | None | Omitted) – The unit of the time series.
assets (list[DirectRelationReference | tuple[str, str]] | None | Omitted) – A list of assets the time series is related to.
equipment (list[DirectRelationReference | tuple[str, str]] | None | Omitted) – A list of equipment the time series is related to.
existing_version (int | None) – Fail the ingestion request if the node’s version is greater than or equal to this value. If no existingVersion is specified, the ingestion will always overwrite any existing data for the node (for the specified container or node). If existingVersion is set to 0, the upsert will behave as an insert, so it will fail the bulk if the item already exists. If skipOnVersionConflict is set on the ingestion request, then the item will be skipped instead of failing the ingestion request.
type (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation pointing to the type node.

class cognite.client.data_classes.data_modeling.cdm.v1.CogniteUnit( space: str, external_id: str, version: int, last_updated_time: int, created_time: int, *, name: str | None = None, description: str | None = None, tags: list[str] | None = None, aliases: list[str] | None = None, symbol: str | None = None, quantity: str | None = None, source: str | None = None, source_reference: str | None = None, type: DirectRelationReference | None = None, deleted_time: int | None = None, )

Bases: _CogniteUnitProperties, TypedNode

This represents the reading format of Cognite unit.

It is used when data is read from CDF.

Represents a single unit of measurement

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite unit.
version (int) – DMS version.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
name (str | None) – Name of the instance
description (str | None) – Description of the instance
tags (list[str] | None) – Text based labels for generic use, limited to 1000
aliases (list[str] | None) – Alternative names for the node
symbol (str | None) – The symbol for the unit of measurement
quantity (str | None) – Specifies the physical quantity the unit measures
source (str | None) – Source of the unit definition
source_reference (str | None) – Reference to the source of the unit definition
type (DirectRelationReference | None) – Direct relation pointing to the type node.
deleted_time (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds. Timestamp when the instance was soft deleted. Note that deleted instances are filtered out of query results, but present in sync results

class cognite.client.data_classes.data_modeling.cdm.v1.CogniteUnitApply( space: str, external_id: str, *, name: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, description: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, tags: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, aliases: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, symbol: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, quantity: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_reference: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, existing_version: int | None = None, type: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, )

Bases: _CogniteUnitProperties, TypedNodeApply

This represents the writing format of Cognite unit.

It is used when data is written to CDF.

Represents a single unit of measurement

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite unit.
name (str | None | Omitted) – Name of the instance
description (str | None | Omitted) – Description of the instance
tags (list[str] | None | Omitted) – Text based labels for generic use, limited to 1000
aliases (list[str] | None | Omitted) – Alternative names for the node
symbol (str | None | Omitted) – The symbol for the unit of measurement
quantity (str | None | Omitted) – Specifies the physical quantity the unit measures
source (str | None | Omitted) – Source of the unit definition
source_reference (str | None | Omitted) – Reference to the source of the unit definition
existing_version (int | None) – Fail the ingestion request if the node’s version is greater than or equal to this value. If no existingVersion is specified, the ingestion will always overwrite any existing data for the node (for the specified container or node). If existingVersion is set to 0, the upsert will behave as an insert, so it will fail the bulk if the item already exists. If skipOnVersionConflict is set on the ingestion request, then the item will be skipped instead of failing the ingestion request.
type (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation pointing to the type node.

class cognite.client.data_classes.data_modeling.cdm.v1.CogniteVisualizable( space: str, external_id: str, version: int, last_updated_time: int, created_time: int, *, object_3d: DirectRelationReference | None = None, type: DirectRelationReference | None = None, deleted_time: int | None = None, )

Bases: _CogniteVisualizableProperties, TypedNode

This represents the reading format of Cognite visualizable.

It is used when data is read from CDF.

CogniteVisualizable defines the standard way to reference a related 3D resource

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite visualizable.
version (int) – DMS version.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
object_3d (DirectRelationReference | None) – Direct relation to an Object3D instance representing the 3D resource
type (DirectRelationReference | None) – Direct relation pointing to the type node.
deleted_time (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds. Timestamp when the instance was soft deleted. Note that deleted instances are filtered out of query results, but present in sync results

class cognite.client.data_classes.data_modeling.cdm.v1.CogniteVisualizableApply( space: str, external_id: str, *, object_3d: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, existing_version: int | None = None, type: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, )

Bases: _CogniteVisualizableProperties, TypedNodeApply

This represents the writing format of Cognite visualizable.

It is used when data is written to CDF.

CogniteVisualizable defines the standard way to reference a related 3D resource

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite visualizable.
object_3d (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation to an Object3D instance representing the 3D resource
existing_version (int | None) – Fail the ingestion request if the node’s version is greater than or equal to this value. If no existingVersion is specified, the ingestion will always overwrite any existing data for the node (for the specified container or node). If existingVersion is set to 0, the upsert will behave as an insert, so it will fail the bulk if the item already exists. If skipOnVersionConflict is set on the ingestion request, then the item will be skipped instead of failing the ingestion request.
type (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation pointing to the type node.

Extractor Extensions

class cognite.client.data_classes.data_modeling.extractor_extensions.v1.CogniteExtractorData( space: str, external_id: str, version: int, last_updated_time: int, created_time: int, *, extracted_data: dict | None = None, type: DirectRelationReference | None = None, deleted_time: int | None = None, )

Bases: _CogniteExtractorDataProperties, TypedNode

This represents the reading format of Cognite extractor datum.

It is used when data is read from CDF.

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite extractor datum.
version (int) – DMS version.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
extracted_data (dict | None) – Unstructured information extracted from source system
type (DirectRelationReference | None) – Direct relation pointing to the type node.
deleted_time (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds. Timestamp when the instance was soft deleted. Note that deleted instances are filtered out of query results, but present in sync results

class cognite.client.data_classes.data_modeling.extractor_extensions.v1.CogniteExtractorDataApply( space: str, external_id: str, *, extracted_data: dict | None | ~cognite.client._constants.Omitted = <Omitted parameter>, existing_version: int | None = None, type: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, )

Bases: _CogniteExtractorDataProperties, TypedNodeApply

This represents the writing format of Cognite extractor datum.

It is used when data is written to CDF.

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite extractor datum.
extracted_data (dict | None | Omitted) – Unstructured information extracted from source system
existing_version (int | None) – Fail the ingestion request if the node’s version is greater than or equal to this value. If no existingVersion is specified, the ingestion will always overwrite any existing data for the node (for the specified container or node). If existingVersion is set to 0, the upsert will behave as an insert, so it will fail the bulk if the item already exists. If skipOnVersionConflict is set on the ingestion request, then the item will be skipped instead of failing the ingestion request.
type (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation pointing to the type node.

class cognite.client.data_classes.data_modeling.extractor_extensions.v1.CogniteExtractorFile( space: str, external_id: str, version: int, last_updated_time: int, created_time: int, *, name: str | None = None, description: str | None = None, tags: list[str] | None = None, aliases: list[str] | None = None, source_id: str | None = None, source_context: str | None = None, source: DirectRelationReference | None = None, source_created_time: datetime | None = None, source_updated_time: datetime | None = None, source_created_user: str | None = None, source_updated_user: str | None = None, assets: list[DirectRelationReference] | None = None, mime_type: str | None = None, directory: str | None = None, is_uploaded: bool | None = None, uploaded_time: datetime | None = None, category: DirectRelationReference | None = None, extracted_data: dict | None = None, type: DirectRelationReference | None = None, deleted_time: int | None = None, )

Bases: _CogniteExtractorFileProperties, TypedNode

This represents the reading format of Cognite extractor file.

It is used when data is read from CDF.

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite extractor file.
version (int) – DMS version.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
name (str | None) – Name of the instance
description (str | None) – Description of the instance
tags (list[str] | None) – Text based labels for generic use, limited to 1000
aliases (list[str] | None) – Alternative names for the node
source_id (str | None) – Identifier from the source system
source_context (str | None) – Context of the source id. For systems where the sourceId is globally unique, the sourceContext is expected to not be set.
source (DirectRelationReference | None) – Direct relation to a source system
source_created_time (datetime | None) – When the instance was created in source system (if available)
source_updated_time (datetime | None) – When the instance was last updated in the source system (if available)
source_created_user (str | None) – User identifier from the source system on who created the source data. This identifier is not guaranteed to match the user identifiers in CDF
source_updated_user (str | None) – User identifier from the source system on who last updated the source data. This identifier is not guaranteed to match the user identifiers in CDF
assets (list[DirectRelationReference] | None) – List of assets this file relates to
mime_type (str | None) – MIME type of the file
directory (str | None) – Contains the path elements from the source (for when the source system has a file system hierarchy or similar)
is_uploaded (bool | None) – Whether the file content has been uploaded to Cognite Data Fusion
uploaded_time (datetime | None) – Point in time when the file upload was completed and the file was made available
category (DirectRelationReference | None) – Direct relation to an instance of CogniteFileCategory representing the detected categorization/class for the file
extracted_data (dict | None) – Unstructured information extracted from source system
type (DirectRelationReference | None) – Direct relation pointing to the type node.
deleted_time (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds. Timestamp when the instance was soft deleted. Note that deleted instances are filtered out of query results, but present in sync results

class cognite.client.data_classes.data_modeling.extractor_extensions.v1.CogniteExtractorFileApply( space: str, external_id: str, *, name: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, description: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, tags: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, aliases: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_id: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_context: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_created_time: ~datetime.datetime | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_updated_time: ~datetime.datetime | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_created_user: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_updated_user: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, assets: list[~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str]] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, mime_type: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, directory: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, category: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, extracted_data: dict | None | ~cognite.client._constants.Omitted = <Omitted parameter>, existing_version: int | None = None, type: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, )

Bases: _CogniteExtractorFileProperties, TypedNodeApply

This represents the writing format of Cognite extractor file.

It is used when data is written to CDF.

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite extractor file.
name (str | None | Omitted) – Name of the instance
description (str | None | Omitted) – Description of the instance
tags (list[str] | None | Omitted) – Text based labels for generic use, limited to 1000
aliases (list[str] | None | Omitted) – Alternative names for the node
source_id (str | None | Omitted) – Identifier from the source system
source_context (str | None | Omitted) – Context of the source id. For systems where the sourceId is globally unique, the sourceContext is expected to not be set.
source (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation to a source system
source_created_time (datetime | None | Omitted) – When the instance was created in source system (if available)
source_updated_time (datetime | None | Omitted) – When the instance was last updated in the source system (if available)
source_created_user (str | None | Omitted) – User identifier from the source system on who created the source data. This identifier is not guaranteed to match the user identifiers in CDF
source_updated_user (str | None | Omitted) – User identifier from the source system on who last updated the source data. This identifier is not guaranteed to match the user identifiers in CDF
assets (list[DirectRelationReference | tuple[str, str]] | None | Omitted) – List of assets this file relates to
mime_type (str | None | Omitted) – MIME type of the file
directory (str | None | Omitted) – Contains the path elements from the source (for when the source system has a file system hierarchy or similar)
category (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation to an instance of CogniteFileCategory representing the detected categorization/class for the file
extracted_data (dict | None | Omitted) – Unstructured information extracted from source system
existing_version (int | None) – Fail the ingestion request if the node’s version is greater than or equal to this value. If no existingVersion is specified, the ingestion will always overwrite any existing data for the node (for the specified container or node). If existingVersion is set to 0, the upsert will behave as an insert, so it will fail the bulk if the item already exists. If skipOnVersionConflict is set on the ingestion request, then the item will be skipped instead of failing the ingestion request.
type (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation pointing to the type node.

class cognite.client.data_classes.data_modeling.extractor_extensions.v1.CogniteExtractorTimeSeries( space: str, external_id: str, version: int, last_updated_time: int, created_time: int, *, is_step: bool, time_series_type: Literal['numeric', 'string'], name: str | None = None, description: str | None = None, tags: list[str] | None = None, aliases: list[str] | None = None, source_id: str | None = None, source_context: str | None = None, source: DirectRelationReference | None = None, source_created_time: datetime | None = None, source_updated_time: datetime | None = None, source_created_user: str | None = None, source_updated_user: str | None = None, source_unit: str | None = None, unit: DirectRelationReference | None = None, assets: list[DirectRelationReference] | None = None, equipment: list[DirectRelationReference] | None = None, extracted_data: dict | None = None, type: DirectRelationReference | None = None, deleted_time: int | None = None, )

Bases: _CogniteExtractorTimeSeriesProperties, TypedNode

This represents the reading format of Cognite extractor time series.

It is used when data is read from CDF.

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite extractor time series.
version (int) – DMS version.
last_updated_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
created_time (int) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
is_step (bool) – Defines whether the time series is a step series or not.
time_series_type (Literal['numeric', 'string']) – Defines data type of the data points.
name (str | None) – Name of the instance
description (str | None) – Description of the instance
tags (list[str] | None) – Text based labels for generic use, limited to 1000
aliases (list[str] | None) – Alternative names for the node
source_id (str | None) – Identifier from the source system
source_context (str | None) – Context of the source id. For systems where the sourceId is globally unique, the sourceContext is expected to not be set.
source (DirectRelationReference | None) – Direct relation to a source system
source_created_time (datetime | None) – When the instance was created in source system (if available)
source_updated_time (datetime | None) – When the instance was last updated in the source system (if available)
source_created_user (str | None) – User identifier from the source system on who created the source data. This identifier is not guaranteed to match the user identifiers in CDF
source_updated_user (str | None) – User identifier from the source system on who last updated the source data. This identifier is not guaranteed to match the user identifiers in CDF
source_unit (str | None) – Unit as specified in the source system
unit (DirectRelationReference | None) – direct relation to the unit of the time series
assets (list[DirectRelationReference] | None) – The asset field.
equipment (list[DirectRelationReference] | None) – The equipment field.
extracted_data (dict | None) – Unstructured information extracted from source system
type (DirectRelationReference | None) – Direct relation pointing to the type node.
deleted_time (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds. Timestamp when the instance was soft deleted. Note that deleted instances are filtered out of query results, but present in sync results

class cognite.client.data_classes.data_modeling.extractor_extensions.v1.CogniteExtractorTimeSeriesApply(space: str, external_id: str, *, is_step: bool, time_series_type: ~typing.Literal['numeric', 'string'], name: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, description: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, tags: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, aliases: list[str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_id: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_context: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_created_time: ~datetime.datetime | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_updated_time: ~datetime.datetime | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_created_user: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_updated_user: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, source_unit: str | None | ~cognite.client._constants.Omitted = <Omitted parameter>, unit: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, assets: list[~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str]] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, equipment: list[~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str]] | None | ~cognite.client._constants.Omitted = <Omitted parameter>, extracted_data: dict | None | ~cognite.client._constants.Omitted = <Omitted parameter>, existing_version: int | None = None, type: ~cognite.client.data_classes.data_modeling.data_types.DirectRelationReference | tuple[str, str] | None | ~cognite.client._constants.Omitted = <Omitted parameter>)

Bases: _CogniteExtractorTimeSeriesProperties, TypedNodeApply

This represents the writing format of Cognite extractor time series.

It is used when data is written to CDF.

Parameters:

space (str) – The space where the node is located.
external_id (str) – The external id of the Cognite extractor time series.
is_step (bool) – Defines whether the time series is a step series or not.
time_series_type (Literal['numeric', 'string']) – Defines data type of the data points.
name (str | None | Omitted) – Name of the instance
description (str | None | Omitted) – Description of the instance
tags (list[str] | None | Omitted) – Text based labels for generic use, limited to 1000
aliases (list[str] | None | Omitted) – Alternative names for the node
source_id (str | None | Omitted) – Identifier from the source system
source_context (str | None | Omitted) – Context of the source id. For systems where the sourceId is globally unique, the sourceContext is expected to not be set.
source (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation to a source system
source_created_time (datetime | None | Omitted) – When the instance was created in source system (if available)
source_updated_time (datetime | None | Omitted) – When the instance was last updated in the source system (if available)
source_created_user (str | None | Omitted) – User identifier from the source system on who created the source data. This identifier is not guaranteed to match the user identifiers in CDF
source_updated_user (str | None | Omitted) – User identifier from the source system on who last updated the source data. This identifier is not guaranteed to match the user identifiers in CDF
source_unit (str | None | Omitted) – Unit as specified in the source system
unit (DirectRelationReference | tuple[str, str] | None | Omitted) – direct relation to the unit of the time series
assets (list[DirectRelationReference | tuple[str, str]] | None | Omitted) – The asset field.
equipment (list[DirectRelationReference | tuple[str, str]] | None | Omitted) – The equipment field.
extracted_data (dict | None | Omitted) – Unstructured information extracted from source system
existing_version (int | None) – Fail the ingestion request if the node’s version is greater than or equal to this value. If no existingVersion is specified, the ingestion will always overwrite any existing data for the node (for the specified container or node). If existingVersion is set to 0, the upsert will behave as an insert, so it will fail the bulk if the item already exists. If skipOnVersionConflict is set on the ingestion request, then the item will be skipped instead of failing the ingestion request.
type (DirectRelationReference | tuple[str, str] | None | Omitted) – Direct relation pointing to the type node.

Debugging Data Classes

class cognite.client.data_classes.data_modeling.debug.ContainersWithoutIndexesInvolvedNotice( category: "Literal['indexing']", code: "Literal['containersWithoutIndexesInvolved']", hint: 'str', level: "Literal['warning']", grade: "Literal['C']", result_expression: 'str | None', containers: 'list[ContainerId]', )

Bases: IndexingNotice

dump( camel_case: bool = True, ) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.debug.CursoringNotice(category: 'str', code: 'str', hint: 'str', level: 'str'): Bases: DebugNotice, ABC

class cognite.client.data_classes.data_modeling.debug.DebugInfo( notices: DebugNoticeList | None = None, translated_query: TranslatedQuery | None = None, plan: ExecutionPlan | None = None, )

Bases: CogniteResource

Contains the requested debug information.

Parameters:

notices (DebugNoticeList | None) – A list of notices that provide insights into the query’s execution. These can highlight potential performance issues, offer optimization suggestions, or explain aspects of the query processing. Each notice falls into a category, such as indexing, sorting, filtering, or cursoring, to help identify areas for improvement.
translated_query (TranslatedQuery | None) – The internal representation of the query.
plan (ExecutionPlan | None) – The execution plan for the query.

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.debug.DebugNotice(category: str, code: str, hint: str, level: str)

Bases: CogniteResource, ABC

A notice that provides insight into the query’s execution. It can highlight potential performance issues, offer an optimization suggestion, or explain an aspect of the query processing. Each notice falls into a category, such as indexing, sorting, filtering, or cursoring, to help identify areas for improvement.

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.debug.DebugNoticeList( resources: Sequence[T_CogniteResource], )

Bases: CogniteResourceList[DebugNotice]

get(*a: Any, **kw: Any) → NoReturn

Get an item from this list by id, external_id or instance_id.

Parameters:

id (int | None) – The id of the item to get.
external_id (str | None) – The external_id of the item to get.
instance_id (InstanceId | tuple[str, str] | None) – The instance_id of the item to get.

Returns:

The requested item if present, otherwise None.

Return type:

T_CogniteResource | None

class cognite.client.data_classes.data_modeling.debug.DebugParameters( *, emit_results: bool = True, timeout: int | None = None, include_translated_query: bool = False, include_plan: bool = False, profile: bool = False, )

Bases: object

Debug parameters for debugging and analyzing queries.

Parameters:

emit_results (bool) – Include the query result in the response. Using emit_results=False is required for advanced query analysis features.
timeout (int | None) – Query timeout in milliseconds. Can be used to override the default timeout when analysing queries. Requires emit_results=False.
include_translated_query (bool) – Include the internal representation of the query.
include_plan (bool) – Include the execution plan for the query.
profile (bool) – Most thorough level of query analysis. Requires emit_results=False.

class cognite.client.data_classes.data_modeling.debug.ExcessiveTimeoutNotice( category: "Literal['invalidDebugOptions']", code: "Literal['excessiveTimeout']", hint: 'str', level: "Literal['warning']", timeout: 'int', )

Bases: InvalidDebugOptionsNotice

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.debug.ExecutionPlan( full_plan: dict[str, Any], profiled: bool, by_identifier: dict[str, Any], )

Bases: CogniteResource

Execution plan for the query.

Parameters:

full_plan (dict[str, Any]) – The full execution plan.
profiled (bool) – The execution plan has been profiled.
by_identifier (dict[str, Any]) – The execution plan grouped by query identifiers.

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.debug.FilterMatchesCursorableSortNotice( category: "Literal['sorting']", code: "Literal['filterMatchesCursorableSort']", hint: 'str', level: "Literal['info']", grade: "Literal['A', 'B']", result_expression: 'str', sort: 'list[InstanceSort]', )

Bases: SortingNotice

dump( camel_case: bool = True, ) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.debug.FilteringNotice(category: 'str', code: 'str', hint: 'str', level: 'str'): Bases: DebugNotice, ABC

class cognite.client.data_classes.data_modeling.debug.IndexingNotice(category: 'str', code: 'str', hint: 'str', level: 'str'): Bases: DebugNotice, ABC

class cognite.client.data_classes.data_modeling.debug.IntractableDirectRelationsCursorNotice( category: "Literal['cursoring']", code: "Literal['intractableDirectRelationsCursor']", hint: 'str', level: "Literal['warning']", grade: "Literal['D']", result_expression: 'str', )

Bases: CursoringNotice

dump( camel_case: bool = True, ) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.debug.InvalidDebugOptionsNotice( category: 'str', code: 'str', hint: 'str', level: 'str', ): Bases: DebugNotice, ABC

class cognite.client.data_classes.data_modeling.debug.NoTimeoutWithResultsNotice( category: "Literal['invalidDebugOptions']", code: "Literal['noTimeoutWithResults']", hint: 'str', level: "Literal['warning']", ): Bases: InvalidDebugOptionsNotice

class cognite.client.data_classes.data_modeling.debug.SelectiveExternalIDFilterNotice( category: "Literal['filtering']", code: "Literal['selectiveExternalIDFilter']", hint: 'str', level: "Literal['info']", grade: "Literal['A']", result_expression: 'str', via_from: 'str | None', )

Bases: FilteringNotice

dump( camel_case: bool = True, ) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.debug.SignificantHasDataFiltersNotice( category: "Literal['filtering']", code: "Literal['significantHasDataFiltering']", hint: 'str', level: "Literal['warning']", grade: "Literal['C']", result_expression: 'str', containers: 'list[ContainerId]', )

Bases: FilteringNotice

dump( camel_case: bool = True, ) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.debug.SignificantPostFilteringNotice( category: "Literal['filtering']", code: "Literal['significantPostFiltering']", hint: 'str', level: "Literal['warning']", grade: "Literal['C']", result_expression: 'str', limit: 'int', max_involved_rows: 'int', )

Bases: FilteringNotice

dump( camel_case: bool = True, ) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.debug.SortNotBackedByIndexNotice( category: "Literal['sorting']", code: "Literal['sortNotBackedByIndex']", hint: 'str', level: "Literal['warning']", grade: "Literal['C']", result_expression: 'str', sort: 'list[InstanceSort]', )

Bases: SortingNotice

dump( camel_case: bool = True, ) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.debug.SortingNotice(category: 'str', code: 'str', hint: 'str', level: 'str'): Bases: DebugNotice, ABC

class cognite.client.data_classes.data_modeling.debug.TranslatedQuery( query: dict[str, Any], parameters: dict[str, Any], )

Bases: CogniteResource

Internal representation of query. Depends on postgres-controlled output, hence the generic dict types.

Parameters:

query (dict[str, Any]) – Parameterized query.
parameters (dict[str, Any]) – Parameter values for query.

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.debug.UnindexedThroughNotice( category: "Literal['indexing']", code: "Literal['unindexedThrough']", hint: 'str', level: "Literal['warning']", grade: "Literal['E']", result_expression: 'str', property: 'list[str]', )

Bases: IndexingNotice

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]

class cognite.client.data_classes.data_modeling.debug.UnknownDebugNotice( category: 'str', code: 'str', hint: 'str', level: 'str', data: 'dict[str, Any]', )

Bases: DebugNotice

dump(camel_case: bool = True) → dict[str, Any]

Dump the instance into a json serializable Python data type.

Parameters:: camel_case (bool) – Use camelCase for attribute names. Defaults to True.
Returns:: A dictionary representation of the instance.
Return type:: dict[str, Any]