Events

Retrieve an event by id

EventsAPI.retrieve(id: int | None = None, external_id: str | None = None) Event | None

Retrieve a single event by id.

Parameters
  • id (int | None) – ID

  • external_id (str | None) – External ID

Returns

Requested event or None if it does not exist.

Return type

Event | None

Examples

Get event by id:

>>> from cognite.client import CogniteClient
>>> client = CogniteClient()
>>> res = client.events.retrieve(id=1)

Get event by external id:

>>> from cognite.client import CogniteClient
>>> client = CogniteClient()
>>> res = client.events.retrieve(external_id="1")

Retrieve multiple events by id

EventsAPI.retrieve_multiple(ids: Sequence[int] | None = None, external_ids: SequenceNotStr[str] | None = None, ignore_unknown_ids: bool = False) EventList

Retrieve multiple events by id.

Parameters
  • ids (Sequence[int] | None) – IDs

  • external_ids (SequenceNotStr[str] | None) – External IDs

  • ignore_unknown_ids (bool) – Ignore IDs and external IDs that are not found rather than throw an exception.

Returns

The requested events.

Return type

EventList

Examples

Get events by id:

>>> from cognite.client import CogniteClient
>>> client = CogniteClient()
>>> res = client.events.retrieve_multiple(ids=[1, 2, 3])

Get events by external id:

>>> from cognite.client import CogniteClient
>>> client = CogniteClient()
>>> res = client.events.retrieve_multiple(external_ids=["abc", "def"])

List events

EventsAPI.list(start_time: dict[str, Any] | TimestampRange | None = None, end_time: dict[str, Any] | EndTimeFilter | None = None, active_at_time: dict[str, Any] | TimestampRange | None = None, type: str | None = None, subtype: str | None = None, metadata: dict[str, str] | None = None, asset_ids: Sequence[int] | None = None, asset_external_ids: SequenceNotStr[str] | None = None, asset_subtree_ids: int | Sequence[int] | None = None, asset_subtree_external_ids: str | SequenceNotStr[str] | None = None, data_set_ids: int | Sequence[int] | None = None, data_set_external_ids: str | SequenceNotStr[str] | None = None, source: str | None = None, created_time: dict[str, Any] | TimestampRange | None = None, last_updated_time: dict[str, Any] | TimestampRange | None = None, external_id_prefix: str | None = None, sort: SequenceNotStr[str] | None = None, partitions: int | None = None, limit: int | None = 25) EventList

List events

Parameters
  • start_time (dict[str, Any] | TimestampRange | None) – Range between two timestamps.

  • end_time (dict[str, Any] | EndTimeFilter | None) – Range between two timestamps.

  • active_at_time (dict[str, Any] | TimestampRange | None) – Event is considered active from its startTime to endTime inclusive. If startTime is null, event is never active. If endTime is null, event is active from startTime onwards. activeAtTime filter will match all events that are active at some point from min to max, from min, or to max, depending on which of min and max parameters are specified.

  • type (str | None) – Type of the event, e.g ‘failure’.

  • subtype (str | None) – Subtype of the event, e.g ‘electrical’.

  • metadata (dict[str, str] | None) – Customizable extra data about the event. String key -> String value.

  • asset_ids (Sequence[int] | None) – Asset IDs of related equipments that this event relates to.

  • asset_external_ids (SequenceNotStr[str] | None) – Asset External IDs of related equipment that this event relates to.

  • asset_subtree_ids (int | Sequence[int] | None) – Asset subtree id or list of asset subtree ids to filter on.

  • asset_subtree_external_ids (str | SequenceNotStr[str] | None) – Asset subtree external id or list of asset subtree external ids to filter on.

  • data_set_ids (int | Sequence[int] | None) – Return only events in the specified data set(s) with this id / these ids.

  • data_set_external_ids (str | SequenceNotStr[str] | None) – Return only events in the specified data set(s) with this external id / these external ids.

  • source (str | None) – The source of this event.

  • created_time (dict[str, Any] | TimestampRange | None) – Range between two timestamps. Possible keys are min and max, with values given as time stamps in ms.

  • last_updated_time (dict[str, Any] | TimestampRange | None) – Range between two timestamps. Possible keys are min and max, with values given as time stamps in ms.

  • external_id_prefix (str | None) – External Id provided by client. Should be unique within the project.

  • sort (SequenceNotStr[str] | None) – Sort by array of selected fields. Ex: [“startTime:desc’]. Default sort order is asc when omitted. Filter accepts following field names: startTime, endTime, createdTime, lastUpdatedTime. We only support 1 field for now.

  • partitions (int | None) – Retrieve events in parallel using this number of workers. Also requires limit=None to be passed. To prevent unexpected problems and maximize read throughput, API documentation recommends at most use 10 partitions. When using more than 10 partitions, actual throughout decreases. In future releases of the APIs, CDF may reject requests with more than 10 partitions.

  • limit (int | None) – Maximum number of events to return. Defaults to 25. Set to -1, float(“inf”) or None to return all items.

Returns

List of requested events

Return type

EventList

Examples

List events and filter on max start time:

>>> from cognite.client import CogniteClient
>>> client = CogniteClient()
>>> event_list = client.events.list(limit=5, start_time={"max": 1500000000})

Iterate over events:

>>> from cognite.client import CogniteClient
>>> client = CogniteClient()
>>> for event in client.events:
...     event # do something with the event

Iterate over chunks of events to reduce memory load:

>>> from cognite.client import CogniteClient
>>> client = CogniteClient()
>>> for event_list in client.events(chunk_size=2500):
...     event_list # do something with the events

Aggregate events

EventsAPI.aggregate(filter: EventFilter | dict | None = None) list[AggregateResult]

Aggregate events

Parameters

filter (EventFilter | dict | None) – Filter on events filter with exact match

Returns

List of event aggregates

Return type

list[AggregateResult]

Examples

Aggregate events:

>>> from cognite.client import CogniteClient
>>> client = CogniteClient()
>>> aggregate_type = client.events.aggregate(filter={"type": "failure"})

Aggregate Event Count

EventsAPI.aggregate_count(property: EventPropertyLike | None = None, advanced_filter: Filter | dict | None = None, filter: EventFilter | dict | None = None) int

Count of event matching the specified filters.

Parameters
  • property (EventPropertyLike | None) – If specified, Get an approximate number of Events with a specific property (property is not null) and matching the filters.

  • advanced_filter (Filter | dict | None) – The filter to narrow down the events to count.

  • filter (EventFilter | dict | None) – The filter to narrow down the events to count requiring exact match.

Returns

The number of events matching the specified filters and search.

Return type

int

Examples

Count the number of events in your CDF project:

>>> from cognite.client import CogniteClient
>>> client = CogniteClient()
>>> count = client.events.aggregate_count()

Count the number of workorder events in your CDF project:

>>> from cognite.client import CogniteClient
>>> from cognite.client.data_classes import filters
>>> from cognite.client.data_classes.events import EventProperty
>>> client = CogniteClient()
>>> is_workorder = filters.Equals(EventProperty.type, "workorder")
>>> workorder_count = client.events.aggregate_count(advanced_filter=is_workorder)

Aggregate Event Values Cardinality

EventsAPI.aggregate_cardinality_values(property: EventPropertyLike, advanced_filter: Filter | dict | None = None, aggregate_filter: AggregationFilter | dict | None = None, filter: EventFilter | dict | None = None) int

Find approximate property count for events.

Parameters
  • property (EventPropertyLike) – The property to count the cardinality of.

  • advanced_filter (Filter | dict | None) – The filter to narrow down the events to count cardinality.

  • aggregate_filter (AggregationFilter | dict | None) – The filter to apply to the resulting buckets.

  • filter (EventFilter | dict | None) – The filter to narrow down the events to count requiring exact match.

Returns

The number of properties matching the specified filter.

Return type

int

Examples:

Count the number of types of events in your CDF project:

>>> from cognite.client import CogniteClient
>>> from cognite.client.data_classes.events import EventProperty
>>> client = CogniteClient()
>>> type_count = client.events.aggregate_cardinality_values(EventProperty.type)

Count the number of types of events linked to asset 123 in your CDF project:

>>> from cognite.client import CogniteClient
>>> from cognite.client.data_classes import filters
>>> from cognite.client.data_classes.events import EventProperty
>>> client = CogniteClient()
>>> is_asset = filters.ContainsAny(EventProperty.asset_ids, 123)
>>> plain_text_author_count = client.events.aggregate_cardinality_values(EventProperty.type, advanced_filter=is_asset)

Aggregate Event Property Cardinality

EventsAPI.aggregate_cardinality_properties(path: EventPropertyLike, advanced_filter: Filter | dict | None = None, aggregate_filter: AggregationFilter | dict | None = None, filter: EventFilter | dict | None = None) int

Find approximate paths count for events.

Parameters
  • path (EventPropertyLike) – The scope in every document to aggregate properties. The only value allowed now is [“metadata”]. It means to aggregate only metadata properties (aka keys).

  • advanced_filter (Filter | dict | None) – The filter to narrow down the events to count cardinality.

  • aggregate_filter (AggregationFilter | dict | None) – The filter to apply to the resulting buckets.

  • filter (EventFilter | dict | None) – The filter to narrow down the events to count requiring exact match.

Returns

The number of properties matching the specified filters and search.

Return type

int

Examples

Count the number of metadata keys for events in your CDF project:

>>> from cognite.client import CogniteClient
>>> from cognite.client.data_classes.events import EventProperty
>>> client = CogniteClient()
>>> type_count = client.events.aggregate_cardinality_properties(EventProperty.metadata)

Aggregate Event Unique Values

EventsAPI.aggregate_unique_values(filter: EventFilter | dict | None = None, property: EventPropertyLike | None = None, advanced_filter: Filter | dict | None = None, aggregate_filter: AggregationFilter | dict | None = None) UniqueResultList

Get unique properties with counts for events.

Parameters
  • filter (EventFilter | dict | None) – The filter to narrow down the events to count requiring exact match.

  • property (EventPropertyLike | None) – The property name(s) to apply the aggregation on.

  • advanced_filter (Filter | dict | None) – The filter to narrow down the events to consider.

  • aggregate_filter (AggregationFilter | dict | None) – The filter to apply to the resulting buckets.

Returns

List of unique values of events matching the specified filters and search.

Return type

UniqueResultList

Examples:

Get the unique types with count of events in your CDF project:

>>> from cognite.client import CogniteClient
>>> from cognite.client.data_classes.events import EventProperty
>>> client = CogniteClient()
>>> result = client.events.aggregate_unique_values(EventProperty.type)
>>> print(result.unique)

Get the unique types of events after 2020-01-01 in your CDF project:

>>> from cognite.client import CogniteClient
>>> from cognite.client.data_classes import filters
>>> from cognite.client.data_classes.events import EventProperty
>>> from cognite.client.utils import timestamp_to_ms
>>> from datetime import datetime
>>> client = CogniteClient()
>>> is_after_2020 = filters.Range(EventProperty.start_time, gte=timestamp_to_ms(datetime(2020, 1, 1)))
>>> result = client.events.aggregate_unique_values(EventProperty.type, advanced_filter=is_after_2020)
>>> print(result.unique)

Get the unique types of events after 2020-01-01 in your CDF project, but exclude all types that start with “planned”:

>>> from cognite.client import CogniteClient
>>> from cognite.client.data_classes.events import EventProperty
>>> from cognite.client.data_classes import aggregations
>>> client = CogniteClient()
>>> agg = aggregations
>>> not_planned = agg.Not(agg.Prefix("planned"))
>>> is_after_2020 = filters.Range(EventProperty.start_time, gte=timestamp_to_ms(datetime(2020, 1, 1)))
>>> result = client.events.aggregate_unique_values(EventProperty.type, advanced_filter=is_after_2020, aggregate_filter=not_planned)
>>> print(result.unique)

Aggregate Event Unique Properties

EventsAPI.aggregate_unique_properties(path: EventPropertyLike, advanced_filter: Filter | dict | None = None, aggregate_filter: AggregationFilter | dict | None = None, filter: EventFilter | dict | None = None) UniqueResultList

Get unique paths with counts for events.

Parameters
  • path (EventPropertyLike) – The scope in every document to aggregate properties. The only value allowed now is [“metadata”]. It means to aggregate only metadata properties (aka keys).

  • advanced_filter (Filter | dict | None) – The filter to narrow down the events to count cardinality.

  • aggregate_filter (AggregationFilter | dict | None) – The filter to apply to the resulting buckets.

  • filter (EventFilter | dict | None) – The filter to narrow down the events to count requiring exact match.

Returns

List of unique values of events matching the specified filters and search.

Return type

UniqueResultList

Examples

Get the unique metadata keys with count of events in your CDF project:

>>> from cognite.client import CogniteClient
>>> from cognite.client.data_classes.events import EventProperty
>>> client = CogniteClient()
>>> result = client.events.aggregate_unique_properties(EventProperty.metadata)
>>> print(result.unique)

Search for events

EventsAPI.search(description: str | None = None, filter: EventFilter | dict | None = None, limit: int = 25) EventList

Search for events Primarily meant for human-centric use-cases and data exploration, not for programs, since matching and ordering may change over time. Use the list function if stable or exact matches are required.

Parameters
  • description (str | None) – Fuzzy match on description.

  • filter (EventFilter | dict | None) – Filter to apply. Performs exact match on these fields.

  • limit (int) – Maximum number of results to return.

Returns

List of requested events

Return type

EventList

Examples

Search for events:

>>> from cognite.client import CogniteClient
>>> client = CogniteClient()
>>> res = client.events.search(description="some description")

Create events

EventsAPI.create(event: Sequence[Event] | Sequence[EventWrite]) EventList
EventsAPI.create(event: Event | EventWrite) Event

Create one or more events.

Parameters

event (Event | EventWrite | Sequence[Event] | Sequence[EventWrite]) – Event or list of events to create.

Returns

Created event(s)

Return type

Event | EventList

Examples

Create new events:

>>> from cognite.client import CogniteClient
>>> from cognite.client.data_classes import EventWrite
>>> client = CogniteClient()
>>> events = [EventWrite(start_time=0, end_time=1), EventWrite(start_time=2, end_time=3)]
>>> res = client.events.create(events)

Delete events

EventsAPI.delete(id: int | Sequence[int] | None = None, external_id: str | SequenceNotStr[str] | None = None, ignore_unknown_ids: bool = False) None

Delete one or more events

Parameters
  • id (int | Sequence[int] | None) – Id or list of ids

  • external_id (str | SequenceNotStr[str] | None) – External ID or list of external ids

  • ignore_unknown_ids (bool) – Ignore IDs and external IDs that are not found rather than throw an exception.

Examples

Delete events by id or external id:

>>> from cognite.client import CogniteClient
>>> client = CogniteClient()
>>> client.events.delete(id=[1,2,3], external_id="3")

Update events

EventsAPI.update(item: Sequence[Event | EventWrite | EventUpdate]) EventList
EventsAPI.update(item: Event | EventWrite | EventUpdate) Event

Update one or more events

Parameters

item (Event | EventWrite | EventUpdate | Sequence[Event | EventWrite | EventUpdate]) – Event(s) to update

Returns

Updated event(s)

Return type

Event | EventList

Examples

Update an event that you have fetched. This will perform a full update of the event:

>>> from cognite.client import CogniteClient
>>> client = CogniteClient()
>>> event = client.events.retrieve(id=1)
>>> event.description = "New description"
>>> res = client.events.update(event)

Perform a partial update on a event, updating the description and adding a new field to metadata:

>>> from cognite.client import CogniteClient
>>> from cognite.client.data_classes import EventUpdate
>>> client = CogniteClient()
>>> my_update = EventUpdate(id=1).description.set("New description").metadata.add({"key": "value"})
>>> res = client.events.update(my_update)

Upsert events

EventsAPI.upsert(item: Sequence[Event | EventWrite], mode: Literal['patch', 'replace'] = 'patch') EventList
EventsAPI.upsert(item: Event | EventWrite, mode: Literal['patch', 'replace'] = 'patch') Event
Upsert events, i.e., update if it exists, and create if it does not exist.

Note this is a convenience method that handles the upserting for you by first calling update on all items, and if any of them fail because they do not exist, it will create them instead.

For more details, see Upsert.

Parameters
  • item (Event | EventWrite | Sequence[Event | EventWrite]) – Event or list of events to upsert.

  • mode (Literal["patch", "replace"]) – Whether to patch or replace in the case the events are existing. If you set ‘patch’, the call will only update fields with non-null values (default). Setting ‘replace’ will unset any fields that are not specified.

Returns

The upserted event(s).

Return type

Event | EventList

Examples

Upsert for events:

>>> from cognite.client import CogniteClient
>>> from cognite.client.data_classes import Event
>>> client = CogniteClient()
>>> existing_event = client.events.retrieve(id=1)
>>> existing_event.description = "New description"
>>> new_event = Event(external_id="new_event", description="New event")
>>> res = client.events.upsert([existing_event, new_event], mode="replace")

Filter events

EventsAPI.filter(filter: Filter | dict, sort: SortSpec | list[SortSpec] | None = None, limit: int | None = 25) EventList

Advanced filter events

Advanced filter lets you create complex filtering expressions that combine simple operations, such as equals, prefix, exists, etc., using boolean operators and, or, and not. It applies to basic fields as well as metadata.

Parameters
  • filter (Filter | dict) – Filter to apply.

  • sort (SortSpec | list[SortSpec] | None) – The criteria to sort by. Can be up to two properties to sort by default to ascending order.

  • limit (int | None) – Maximum number of results to return. Defaults to 25. Set to -1, float(“inf”) or None to return all items.

Returns

List of events that match the filter criteria.

Return type

EventList

Examples

Find all events that has external id with prefix “workorder” and the word ‘failure’ in the description, and sort by start time descending:

>>> from cognite.client import CogniteClient
>>> from cognite.client.data_classes import filters as flt
>>> client = CogniteClient()
>>> is_workorder = flt.Prefix("external_id", "workorder")
>>> has_failure = flt.Search("description", "failure")
>>> res = client.events.filter(
...     filter=flt.And(is_workorder, has_failure), sort=("start_time", "desc"))

Note that you can check the API documentation above to see which properties you can filter on with which filters.

To make it easier to avoid spelling mistakes and easier to look up available properties for filtering and sorting, you can also use the EventProperty and SortableEventProperty enums.

>>> from cognite.client import CogniteClient
>>> from cognite.client.data_classes import filters as flt
>>> from cognite.client.data_classes.events import EventProperty, SortableEventProperty
>>> client = CogniteClient()
>>> is_workorder = flt.Prefix(EventProperty.external_id, "workorder")
>>> has_failure = flt.Search(EventProperty.description, "failure")
>>> res = client.events.filter(
...     filter=flt.And(is_workorder, has_failure),
...     sort=(SortableEventProperty.start_time, "desc"))

Events Data classes

class cognite.client.data_classes.events.EndTimeFilter(max: int | None = None, min: int | None = None, is_null: bool | None = None, **_: Any)

Bases: CogniteObject

Either range between two timestamps or isNull filter condition.

Parameters
  • max (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.

  • min (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.

  • is_null (bool | None) – Set to true if you want to search for data with field value not set, false to search for cases where some value is present.

  • **_ (Any) – No description.

class cognite.client.data_classes.events.Event(external_id: str | None = None, data_set_id: int | None = None, start_time: int | None = None, end_time: int | None = None, type: str | None = None, subtype: str | None = None, description: str | None = None, metadata: dict[str, str] | None = None, asset_ids: Sequence[int] | None = None, source: str | None = None, id: int | None = None, last_updated_time: int | None = None, created_time: int | None = None, cognite_client: CogniteClient | None = None)

Bases: EventCore

An event represents something that happened at a given interval in time, e.g a failure, a work order etc. This is the reading version of the Event class. It is used when retrieving existing events.

Parameters
  • external_id (str | None) – The external ID provided by the client. Must be unique for the resource type.

  • data_set_id (int | None) – The id of the dataset this event belongs to.

  • start_time (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.

  • end_time (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.

  • type (str | None) – Type of the event, e.g. ‘failure’.

  • subtype (str | None) – SubType of the event, e.g. ‘electrical’.

  • description (str | None) – Textual description of the event.

  • metadata (dict[str, str] | None) – Custom, application-specific metadata. String key -> String value. Limits: Maximum length of key is 128 bytes, value 128000 bytes, up to 256 key-value pairs, of total size at most 200000.

  • asset_ids (Sequence[int] | None) – Asset IDs of equipment that this event relates to.

  • source (str | None) – The source of this event.

  • id (int | None) – A server-generated ID for the object.

  • last_updated_time (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.

  • created_time (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.

  • cognite_client (CogniteClient | None) – The client to associate with this object.

as_write() EventWrite

Returns this Event in its writing version.

class cognite.client.data_classes.events.EventCore(external_id: str | None = None, data_set_id: int | None = None, start_time: int | None = None, end_time: int | None = None, type: str | None = None, subtype: str | None = None, description: str | None = None, metadata: dict[str, str] | None = None, asset_ids: Sequence[int] | None = None, source: str | None = None)

Bases: WriteableCogniteResource[EventWrite], ABC

An event represents something that happened at a given interval in time, e.g a failure, a work order etc.

Parameters
  • external_id (str | None) – The external ID provided by the client. Must be unique for the resource type.

  • data_set_id (int | None) – The id of the dataset this event belongs to.

  • start_time (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.

  • end_time (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.

  • type (str | None) – Type of the event, e.g. ‘failure’.

  • subtype (str | None) – SubType of the event, e.g. ‘electrical’.

  • description (str | None) – Textual description of the event.

  • metadata (dict[str, str] | None) – Custom, application-specific metadata. String key -> String value. Limits: Maximum length of key is 128 bytes, value 128000 bytes, up to 256 key-value pairs, of total size at most 200000.

  • asset_ids (Sequence[int] | None) – Asset IDs of equipment that this event relates to.

  • source (str | None) – The source of this event.

class cognite.client.data_classes.events.EventFilter(start_time: dict[str, Any] | TimestampRange | None = None, end_time: dict[str, Any] | EndTimeFilter | None = None, active_at_time: dict[str, Any] | TimestampRange | None = None, metadata: dict[str, str] | None = None, asset_ids: Sequence[int] | None = None, asset_external_ids: SequenceNotStr[str] | None = None, asset_subtree_ids: Sequence[dict[str, Any]] | None = None, data_set_ids: Sequence[dict[str, Any]] | None = None, source: str | None = None, type: str | None = None, subtype: str | None = None, created_time: dict[str, Any] | TimestampRange | None = None, last_updated_time: dict[str, Any] | TimestampRange | None = None, external_id_prefix: str | None = None)

Bases: CogniteFilter

Filter on events filter with exact match

Parameters
  • start_time (dict[str, Any] | TimestampRange | None) – Range between two timestamps.

  • end_time (dict[str, Any] | EndTimeFilter | None) – Either range between two timestamps or isNull filter condition.

  • active_at_time (dict[str, Any] | TimestampRange | None) – Event is considered active from its startTime to endTime inclusive. If startTime is null, event is never active. If endTime is null, event is active from startTime onwards. activeAtTime filter will match all events that are active at some point from min to max, from min, or to max, depending on which of min and max parameters are specified.

  • metadata (dict[str, str] | None) – Custom, application specific metadata. String key -> String value. Limits: Maximum length of key is 128 bytes, value 128000 bytes, up to 256 key-value pairs, of total size at most 200000.

  • asset_ids (Sequence[int] | None) – Asset IDs of equipment that this event relates to.

  • asset_external_ids (SequenceNotStr[str] | None) – Asset External IDs of equipment that this event relates to.

  • asset_subtree_ids (Sequence[dict[str, Any]] | None) – Only include events that have a related asset in a subtree rooted at any of these assetIds (including the roots given). If the total size of the given subtrees exceeds 100,000 assets, an error will be returned.

  • data_set_ids (Sequence[dict[str, Any]] | None) – Only include events that belong to these datasets.

  • source (str | None) – The source of this event.

  • type (str | None) – Type of the event, e.g ‘failure’.

  • subtype (str | None) – SubType of the event, e.g ‘electrical’.

  • created_time (dict[str, Any] | TimestampRange | None) – Range between two timestamps.

  • last_updated_time (dict[str, Any] | TimestampRange | None) – Range between two timestamps.

  • external_id_prefix (str | None) – Filter by this (case-sensitive) prefix for the external ID.

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.events.EventList(resources: Collection[Any], cognite_client: CogniteClient | None = None)

Bases: WriteableCogniteResourceList[EventWrite, Event], IdTransformerMixin

class cognite.client.data_classes.events.EventProperty(value)

Bases: EnumProperty

An enumeration.

class cognite.client.data_classes.events.EventUpdate(id: int | None = None, external_id: str | None = None)

Bases: CogniteUpdate

Changes will be applied to event.

Parameters
  • id (int) – A server-generated ID for the object.

  • external_id (str) – The external ID provided by the client. Must be unique for the resource type.

class cognite.client.data_classes.events.EventWrite(external_id: str | None = None, data_set_id: int | None = None, start_time: int | None = None, end_time: int | None = None, type: str | None = None, subtype: str | None = None, description: str | None = None, metadata: dict[str, str] | None = None, asset_ids: Sequence[int] | None = None, source: str | None = None)

Bases: EventCore

An event represents something that happened at a given interval in time, e.g a failure, a work order etc. This is the writing version of the Event class. It is used when creating new events.

Parameters
  • external_id (str | None) – The external ID provided by the client. Must be unique for the resource type.

  • data_set_id (int | None) – The id of the dataset this event belongs to.

  • start_time (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.

  • end_time (int | None) – The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.

  • type (str | None) – Type of the event, e.g. ‘failure’.

  • subtype (str | None) – SubType of the event, e.g. ‘electrical’.

  • description (str | None) – Textual description of the event.

  • metadata (dict[str, str] | None) – Custom, application-specific metadata. String key -> String value. Limits: Maximum length of key is 128 bytes, value 128000 bytes, up to 256 key-value pairs, of total size at most 200000.

  • asset_ids (Sequence[int] | None) – Asset IDs of equipment that this event relates to.

  • source (str | None) – The source of this event.

as_write() EventWrite

Returns self.

class cognite.client.data_classes.events.EventWriteList(resources: Collection[Any], cognite_client: CogniteClient | None = None)

Bases: CogniteResourceList[EventWrite], ExternalIDTransformerMixin

class cognite.client.data_classes.events.SortableEventProperty(value)

Bases: EnumProperty

An enumeration.