API reference

Replay FPS is usually capped between 5 - 15 FPS depending on Replay configuration.
When the source .mp4 file(s) are at much higher FPS then that, this allows to convert them to lower FPS.
Videos are converted and stored at the same location as the source video.

Constructor

Deprecated, will be removed. Use C{app_is_running} or C{wait} functions instead.

Deprecated, will be removed. Use C{app_is_running} instead.

Deprecated, will be removed. Use C{wait} instead.

Invoking this function will sleep current thread for B{time} seconds.

If C{self.running -> False}, returns immediately. If App is stopped midway through C{self.wait}, likewise returns immediately.

Should be preferred over C{time.sleep} in all use cases, as C{time.sleep} will not be interrupted if App is stopped, often causing unexpected behaviour.

@param time: Time to sleep for, given in seconds. Negative values are interpreted as 0.
@type time: float | int

Entrypoint of the App. Must be defined by the user.

Optional method, is executed after L{on_start()} returns.

Can be used as a second entrypoint to the App.

Method for cleanup of threads/processes, is called when:
    - App is stopped by Agent (e.g. due to a request to Stop from the Cloud)
    - App stops on its own - for example by calling C{exit()}
    - App throws an uncaught exception

Should be used to quickly and gracefully stop all execution. Not defining this method properly, such as not joining all threads that were started in C{self.on_start()} often results in undefined behaviour.
Not called when C{os._exit()} is called.

Optional. Is called when an Event is uploaded to cloud. UploadedEvent argument contains information about the uploaded Event.

Is not called if Event is rejected by Agent

@param event: Object containing information about the uploaded event.
@type event: L{UploadedEvent}

Is called when the Agent receives a new configuration. New configuration is loaded into the CONFIGURATION variable.
A dictionary containing configuration changes [:param: configuration_changes] is provided so that user can decide proper behavior when this
method is overriden.
Default behavior is app restart. Override this method if you want to change the behavior.

@param configuration_changes: Dictionary containing configuration changes.
@type configuration_changes: dict

Is called when Devices assigned to the app have changed.

Stops the App.

Restarts the App. This blocks execution until Agent stops the App. App is then started.

Requests the Agent to restart Host. Blocks execution until request is resolved.

Requests the Agent to shutdown Host. Blocks execution until request is resolved.

Launch script uses this method to start the App.

Sends a classification for an Event with id equal to {event_id}.

Publishes device info. C{device_info} needs to be a properly formatted dictionary.

@param device_info: Dictionary containing device info
@type device_info: dict

Publishes device stats. C{device_stats} needs to be a properly formatted dictionary.

@param device_stats: Dictionary containing device stats
@type device_stats: dict

ID of specific session, can be None

Response payload, structure defined by user

Sends a notification to the FE server.

@param key: Used to define different types of notifications
@type key: str
@param payload: Content of the notification
@type payload: str | list | dict | None
@param target: If target is a valid session ID, notification is sent to the specific session. If None, notification is broadcast.
@type target: str | None

Sends a request to the FE server and blocks until a response is received or until timeout. 

@param key: Used to define different types of requests
@type key: str
@param payload: Content of the request
@type payload: str | list | dict | None
@param target: If target is a valid session ID, request is sent to the specific session. If None, request is broadcast.
@type target: str | None
@param timeoutSeconds: Timeout length in seconds.
@type timeoutSeconds: float | int

Sends an asynchronous request to the FE server, calls a callback on the response if a response is received before timeout.

@param key: Used to define different types of requests
@type key: str
@param payload: Content of the request
@type payload: str | list | dict | None
@param target: If target is a valid session ID, request is sent to the specific session. If None, request is broadcast.
@type target: str | None
@param timeoutSeconds: Timeout length in seconds.
@type timeoutSeconds: float | int
@param on_response: Callback to be invoked on the response. 
@type on_response: Callable[[Any], None]

Sets callbacks for session start & end, notifications and requests from the FE server.

@param session_start: Callback for "session started" messages from FE
@type session_start: Callable
@param session_end: Callback for "session ended" messages from FE
@type session_end: Callable
@param notification: Callback for notifications from FE
@type notification: Callable
@param request: Callback for requests from FE
@type request: Callable

Sets the device change callback. 

This function will be called each time configuration of any assigned device changes.
@param devices_changed_cb: Callback for requests from FE
@type devices_changed_cb: Callable

String denoting type of the device, allowed values: ["oak"]

Dictionary containing various information about the device

Agent is actively communicating with the device. In the case of DepthAI devices, this means a pipeline is running on the device.

Agent is not actively communicating with the device. Either device is disconnected or no App is running on it.

Agent is connecting to the device. Occurs when an App is initializing on the device, but full communication is not yet going on.

Agent is trying to obtain info about device state. Occurs when Agent is starting up.

Creates a new empty Event.

@return: An empty Event of type L{FutureEvent}

Uploads an Event.

@param event: Event to be uploaded.
@type event: L{FutureEvent}

Creates and immediately uploads an Event with a single frame. Does not allow for full customization of the Event.

@param imagedata: The encoded frame bytes
@type imagedata: bytes | bytearray
@param camera_serial: Serial number (MxID) of camera that took the picture
@type camera_serial: str
@param title: Optional title for the Event
@type title: str | NoneType
@param frame_name: Optional name for the frame, does not define the filename
@type frame_name: str | NoneType
@param frame_metadata: metadata of valid format will be visualized over the frame in the cloud. Optional.
@type frame_metadata: dict | NoneType

Creates and immediately uploads an Event with a single video. Does not allow for full customization of the Event.

@param video: The encoded video bytes. Encoding must be H264.
@type video: bytes | bytearray
@param title: Optional title for the Event
@type title: str | NoneType
@param video_name: Optional name for the video, does not define the filename
@type video_name: str | NoneType
@param video_metadata: Metadata of valid format will be visualized over the video in the cloud. Optional.
@type video_metadata: dict | NoneType

Creates and immediately uploads an Event with a file of arbitrary type. Does not allow for full customization of the Event.

@param binary_data: The file in bytes
@type binary_data: bytes | bytearray
@param title: Optional title for the Event
@type title: str | NoneType
@param file_name: Optional name for the file, does not define the filename
@type file_name: str | NoneType

Creates and immediately uploads an Event with a single string. Does not allow for full customization of the Event.

@param text: The text in string form
@type text: str
@param text: The text in string form
@type text: str
@param title: Optional title for the Event
@type title: str | NoneType
@param text_name: Optional name for the text
@type text_name: str | NoneType

ID of the Event

Path to the folder of the Event in the App's container. Added frames, files & videos are stored in this folder.

Title of the Event in the Cloud. Set to "Event" + UUID by default.

Adds a video to the Event.

@param _bytes: Bytes of the encoded video. Must be H264 format.
@type _bytes: bytes | bytearray
@param name: Optional - Name of the video
@type name: str | NoneType
@param metadata: Optional - Metadata to be overlayed over the video. List length must be equal to number of frames in the video.
@type metadata: list
@param filename: Optional - can define name of the video file on Host.
@type filename: str | NoneType
@param camera_serial: Optional - Serial number (MxID) of camera that took the video
@type camera_serial: str

Adds a frame to the Event.

@param _bytes: Bytes of the encoded frame
@type _bytes: bytes | bytearray
@param camera_serial: Optional - Serial number (MxID) of camera that took the frame
@type camera_serial: str
@param name: Optional - Name of the frame
@type name: str | NoneType
@param metadata: Optional - Metadata to be overlayed over the frame
@type metadata: list
@param filename: Optional - can define name of the frame file on Host.
@type filename: str | NoneType

Adds a file to the Event.

@param _bytes: Bytes of the file.
@type _bytes: bytes | bytearray
@param name: Optional - Name of the file in the cloud
@type name: str | NoneType
@param filename: Optional - can define name of the file saved on Host.
@type filename: str | NoneType

Adds an existing file to the Event.

@param filename: Path to the file to be added.
@type filename: Path | str
@param copy: If True, the file will be copied to the Event folder. If False, the file will be moved to the Event folder.
@type copy: bool
@param name: Optional - Name of the file in the cloud
@type name: str | NoneType

Sets the title of the Event.

@param title: Title for the Event
@type title: str | NoneType

Sets the metadata of the Event.

@param metadata: Dictionary containing the metadata
@type metadata: dict

Adds a tag to the Event.

Cannot add more than 10 tags to one Event.

@param tag: The tag string
@type tag: str

Adds multiple tags to the Event.

Cannot add more than 10 tags to one Event.

@param tags: A list of tags
@type tags: List[str]

Sets the tags of the Event.

An Event cannot have more than 10 tags.

@param tags: A list of tags
@type tags: List[str]

Decides whether Event should be kept after upload, C{False} by default.

Sets the keep after upload property.

Example usage:

>>> self.keep_after_upload = True

If set to True, Event will not be uploaded. C{False} by default.

Sets the keep after upload property.

Example usage:

>>> self.keep_after_upload = True

Decides whether Event should be kept when storage space is low, C{False} by default.

Sets the keep when space low property.

Example usage:

>>> self.keep_when_space_low = True

Domain of the robot

Token which allows limited time access to the Event

ID of the Event

URL of the Event, accessible only with credentials

Object allowing public access

List of tags of the Event

Creates a stream and returns its L{StreamHandle}

@param camera_serial: Serial number (MxID) of camera requesting the stream
@type camera_serial: str
@param unique_key: Key identifying the stream. Must be unique for each created stream, else an exception is thrown.
@type unique_key: str
@param description: Name of the stream in the cloud. Does not have to be unique.
@type description: str

Deletes a stream and its L{StreamHandle}.

@param stream: key of stream to be destroyed
@type stream: L{StreamHandle}

Destroys streams corresponding to {stream_ids}, throws if any of the corresponding streams does not exist.

@param stream_ids: Keys of streams to be destroyed
@type stream_ids: List[str]

Destroys all streams.

Unique Key identifying the stream

Serial number (MxID) of camera the stream is registered for

Name of the stream in the cloud

Used to send a frame with a corresponding timestamp. Optionally, metadata to be rendered over the frame can be included.

@param video_data: Bytes of the encoded frame. Encoding must be H264.
@type video_data: bytes | bytearray
@param timestamp: Timestamp of the frame. Does not have to correspond to when frame was taken on device, but must be increasing with each subsequent frame.
@type timestamp: int