> ## Documentation Index > Fetch the complete documentation index at: https://docs.cyberwave.com/llms.txt > Use this file to discover all available pages before exploring further. # DefaultApi # cyberwave.rest.DefaultApi All URIs are relative to *[http://localhost](http://localhost)* | Method | HTTP request | Description | | -------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------- | --------------------------------------- | | [**src\_app\_api\_alerts\_acknowledge\_alert**](#src_app_api_alerts_acknowledge_alert) | **POST** `/api/v1/alerts/{uuid}/acknowledge` | Acknowledge Alert | | [**src\_app\_api\_alerts\_create\_alert**](#src_app_api_alerts_create_alert) | **POST** /api/v1/alerts | Create Alert | | [**src\_app\_api\_alerts\_delete\_alert**](#src_app_api_alerts_delete_alert) | **DELETE** `/api/v1/alerts/{uuid}` | Delete Alert | | [**src\_app\_api\_alerts\_get\_alert**](#src_app_api_alerts_get_alert) | **GET** `/api/v1/alerts/{uuid}` | Get Alert | | [**src\_app\_api\_alerts\_list\_alerts**](#src_app_api_alerts_list_alerts) | **GET** /api/v1/alerts | List Alerts | | [**src\_app\_api\_alerts\_resolve\_alert**](#src_app_api_alerts_resolve_alert) | **POST** `/api/v1/alerts/{uuid}/resolve` | Resolve Alert | | [**src\_app\_api\_alerts\_silence\_alert**](#src_app_api_alerts_silence_alert) | **POST** `/api/v1/alerts/{uuid}/silence` | Silence Alert | | [**src\_app\_api\_alerts\_update\_alert**](#src_app_api_alerts_update_alert) | **PUT** `/api/v1/alerts/{uuid}` | Update Alert | | [**src\_app\_api\_assets\_check\_registry\_id\_availability**](#src_app_api_assets_check_registry_id_availability) | **GET** `/api/v1/assets/check-registry-id/{registry_id}` | Check Registry Id Availability | | [**src\_app\_api\_assets\_complete\_large\_glb\_upload**](#src_app_api_assets_complete_large_glb_upload) | **POST** `/api/v1/assets/{uuid}/complete-large-glb-upload` | Complete Large Glb Upload | | [**src\_app\_api\_assets\_create\_asset**](#src_app_api_assets_create_asset) | **POST** /api/v1/assets | Create Asset | | [**src\_app\_api\_assets\_create\_asset\_from\_prompt\_or\_image**](#src_app_api_assets_create_asset_from_prompt_or_image) | **POST** /api/v1/assets/create-from-prompt-or-image | Create Asset From Prompt Or Image | | [**src\_app\_api\_assets\_create\_asset\_with\_urdf**](#src_app_api_assets_create_asset_with_urdf) | **POST** /api/v1/assets/create-with-urdf | Create Asset With Urdf | | [**src\_app\_api\_assets\_delete\_asset**](#src_app_api_assets_delete_asset) | **DELETE** `/api/v1/assets/{uuid}` | Delete Asset | | [**src\_app\_api\_assets\_export\_asset**](#src_app_api_assets_export_asset) | **GET** `/api/v1/assets/{uuid}/export` | Export Asset | | [**src\_app\_api\_assets\_get\_asset**](#src_app_api_assets_get_asset) | **GET** `/api/v1/assets/{uuid}` | Get Asset | | [**src\_app\_api\_assets\_get\_asset\_controllers**](#src_app_api_assets_get_asset_controllers) | **GET** `/api/v1/assets/{uuid}/controllers` | Get Asset Controllers | | [**src\_app\_api\_assets\_get\_asset\_kinematics**](#src_app_api_assets_get_asset_kinematics) | **GET** `/api/v1/assets/{uuid}/kinematics` | Get Asset Kinematics | | [**src\_app\_api\_assets\_get\_asset\_universal\_schema**](#src_app_api_assets_get_asset_universal_schema) | **GET** `/api/v1/assets/{uuid}/universal-schema` | Get Asset Universal Schema | | [**src\_app\_api\_assets\_get\_asset\_universal\_schema\_at\_path**](#src_app_api_assets_get_asset_universal_schema_at_path) | **GET** `/api/v1/assets/{uuid}/universal-schema/at` | Get Asset Universal Schema At Path | | [**src\_app\_api\_assets\_get\_popular\_tags**](#src_app_api_assets_get_popular_tags) | **GET** /api/v1/assets/popular-tags | Get Popular Tags | | [**src\_app\_api\_assets\_get\_public\_vendors**](#src_app_api_assets_get_public_vendors) | **GET** /api/v1/assets/public-vendors | Get Public Vendors | | [**src\_app\_api\_assets\_import\_asset\_package**](#src_app_api_assets_import_asset_package) | **POST** /api/v1/assets/import | Import Asset Package | | [**src\_app\_api\_assets\_import\_catalog\_asset**](#src_app_api_assets_import_catalog_asset) | **POST** /api/v1/assets/import-catalog | Import Catalog Asset | | [**src\_app\_api\_assets\_initiate\_large\_glb\_upload**](#src_app_api_assets_initiate_large_glb_upload) | **POST** `/api/v1/assets/{uuid}/initiate-large-glb-upload` | Initiate Large Glb Upload | | [**src\_app\_api\_assets\_list\_assets**](#src_app_api_assets_list_assets) | **GET** /api/v1/assets | List Assets | | [**src\_app\_api\_assets\_llm\_generation**](#src_app_api_assets_llm_generation) | **POST** `/api/v1/assets/{uuid}/llm-generation` | Llm Generation | | [**src\_app\_api\_assets\_patch\_asset\_universal\_schema**](#src_app_api_assets_patch_asset_universal_schema) | **PATCH** `/api/v1/assets/{uuid}/universal-schema` | Patch Asset Universal Schema | | [**src\_app\_api\_assets\_rebuild\_asset\_universal\_schema**](#src_app_api_assets_rebuild_asset_universal_schema) | **POST** `/api/v1/assets/{uuid}/universal-schema/rebuild` | Rebuild Asset Universal Schema | | [**src\_app\_api\_assets\_set\_glb\_from\_attachment**](#src_app_api_assets_set_glb_from_attachment) | **POST** `/api/v1/assets/{uuid}/glb-from-attachment` | Set Glb From Attachment | | [**src\_app\_api\_assets\_update\_asset**](#src_app_api_assets_update_asset) | **PUT** `/api/v1/assets/{uuid}` | Update Asset | | [**src\_app\_api\_assets\_upload\_glb**](#src_app_api_assets_upload_glb) | **POST** `/api/v1/assets/{uuid}/glb-file` | Upload Glb | | [**src\_app\_api\_assets\_upload\_thumbnail\_file**](#src_app_api_assets_upload_thumbnail_file) | **POST** `/api/v1/assets/{uuid}/thumbnail-file` | Upload Thumbnail File | | [**src\_app\_api\_assets\_vlm\_generation**](#src_app_api_assets_vlm_generation) | **POST** `/api/v1/assets/{uuid}/vlm-generation` | Vlm Generation | | [**src\_app\_api\_attachments\_complete\_large\_attachment\_upload**](#src_app_api_attachments_complete_large_attachment_upload) | **POST** `/api/v1/attachments/{uuid}/complete-large-upload` | Complete Large Attachment Upload | | [**src\_app\_api\_attachments\_create\_attachment**](#src_app_api_attachments_create_attachment) | **POST** /api/v1/attachments | Create Attachment | | [**src\_app\_api\_attachments\_delete\_attachment**](#src_app_api_attachments_delete_attachment) | **DELETE** `/api/v1/attachments/{uuid}` | Delete Attachment | | [**src\_app\_api\_attachments\_download\_attachment**](#src_app_api_attachments_download_attachment) | **GET** `/api/v1/attachments/{uuid}/download` | Download Attachment | | [**src\_app\_api\_attachments\_get\_attachment**](#src_app_api_attachments_get_attachment) | **GET** `/api/v1/attachments/{uuid}` | Get Attachment | | [**src\_app\_api\_attachments\_initiate\_large\_attachment\_upload**](#src_app_api_attachments_initiate_large_attachment_upload) | **POST** `/api/v1/attachments/{uuid}/initiate-large-upload` | Initiate Large Attachment Upload | | [**src\_app\_api\_attachments\_list\_attachments**](#src_app_api_attachments_list_attachments) | **GET** /api/v1/attachments | List Attachments | | [**src\_app\_api\_attachments\_update\_attachment**](#src_app_api_attachments_update_attachment) | **PUT** `/api/v1/attachments/{uuid}` | Update Attachment | | [**src\_app\_api\_attachments\_upload\_attachment**](#src_app_api_attachments_upload_attachment) | **POST** `/api/v1/attachments/{uuid}/upload` | Upload Attachment | | [**src\_app\_api\_controller\_policies\_clone\_controller\_policy**](#src_app_api_controller_policies_clone_controller_policy) | **POST** `/api/v1/controller-policies/{uuid}/clone` | Clone Controller Policy | | [**src\_app\_api\_controller\_policies\_create\_controller\_policy**](#src_app_api_controller_policies_create_controller_policy) | **POST** /api/v1/controller-policies | Create Controller Policy | | [**src\_app\_api\_controller\_policies\_delete\_controller\_policy**](#src_app_api_controller_policies_delete_controller_policy) | **DELETE** `/api/v1/controller-policies/{uuid}` | Delete Controller Policy | | [**src\_app\_api\_controller\_policies\_execute\_controller\_policy**](#src_app_api_controller_policies_execute_controller_policy) | **POST** `/api/v1/controller-policies/{uuid}/execute` | Execute Controller Policy | | [**src\_app\_api\_controller\_policies\_get\_action\_from\_policy**](#src_app_api_controller_policies_get_action_from_policy) | **GET** `/api/v1/controller-policies/{uuid}/action` | Get Action From Policy | | [**src\_app\_api\_controller\_policies\_get\_controller\_policy**](#src_app_api_controller_policies_get_controller_policy) | **GET** `/api/v1/controller-policies/{uuid}` | Get Controller Policy | | [**src\_app\_api\_controller\_policies\_list\_controller\_policies**](#src_app_api_controller_policies_list_controller_policies) | **GET** /api/v1/controller-policies | List Controller Policies | | [**src\_app\_api\_controller\_policies\_update\_controller\_policy**](#src_app_api_controller_policies_update_controller_policy) | **PUT** `/api/v1/controller-policies/{uuid}` | Update Controller Policy | | [**src\_app\_api\_datasets\_create\_dataset**](#src_app_api_datasets_create_dataset) | **POST** /api/v1/datasets | Create Dataset | | [**src\_app\_api\_datasets\_delete\_dataset**](#src_app_api_datasets_delete_dataset) | **DELETE** `/api/v1/datasets/{uuid}` | Delete Dataset | | [**src\_app\_api\_datasets\_get\_dataset**](#src_app_api_datasets_get_dataset) | **GET** `/api/v1/datasets/{uuid}` | Get Dataset | | [**src\_app\_api\_datasets\_get\_dataset\_zip\_url**](#src_app_api_datasets_get_dataset_zip_url) | **GET** `/api/v1/datasets/{uuid}/zip` | Get Dataset Zip Url | | [**src\_app\_api\_datasets\_list\_datasets**](#src_app_api_datasets_list_datasets) | **GET** /api/v1/datasets | List Datasets | | [**src\_app\_api\_datasets\_remove\_episode\_from\_dataset**](#src_app_api_datasets_remove_episode_from_dataset) | **DELETE** `/api/v1/datasets/{uuid}/episodes/{episode_uuid}` | Remove Episode From Dataset | | [**src\_app\_api\_datasets\_update\_dataset**](#src_app_api_datasets_update_dataset) | **PUT** `/api/v1/datasets/{uuid}` | Update Dataset | | [**src\_app\_api\_edge\_nodes\_discover\_twins**](#src_app_api_edge_nodes_discover_twins) | **POST** /api/v1/edges/discover | Discover Twins | | [**src\_app\_api\_edge\_nodes\_get\_edge\_twins**](#src_app_api_edge_nodes_get_edge_twins) | **GET** `/api/v1/edges/{uuid}/twins` | Get Edge Twins | | [**src\_app\_api\_edge\_nodes\_pair\_twin\_to\_edge**](#src_app_api_edge_nodes_pair_twin_to_edge) | **POST** `/api/v1/edges/{uuid}/pair` | Pair Twin To Edge | | [**src\_app\_api\_edge\_nodes\_restart\_edge\_core**](#src_app_api_edge_nodes_restart_edge_core) | **POST** `/api/v1/edges/{uuid}/restart-core` | Restart Edge Core | | [**src\_app\_api\_edge\_nodes\_unpair\_twin\_from\_edge**](#src_app_api_edge_nodes_unpair_twin_from_edge) | **DELETE** `/api/v1/edges/{uuid}/twins/{twin_uuid}` | Unpair Twin From Edge | | [**src\_app\_api\_edge\_nodes\_update\_camera\_config**](#src_app_api_edge_nodes_update_camera_config) | **PUT** `/api/v1/edges/{uuid}/twins/{twin_uuid}/camera-config` | Update Camera Config | | [**src\_app\_api\_edges\_create\_edge**](#src_app_api_edges_create_edge) | **POST** /api/v1/edges | Create Edge | | [**src\_app\_api\_edges\_delete\_edge**](#src_app_api_edges_delete_edge) | **DELETE** `/api/v1/edges/{uuid}` | Delete Edge | | [**src\_app\_api\_edges\_get\_edge**](#src_app_api_edges_get_edge) | **GET** `/api/v1/edges/{uuid}` | Get Edge | | [**src\_app\_api\_edges\_get\_edges**](#src_app_api_edges_get_edges) | **GET** /api/v1/edges | Get Edges | | [**src\_app\_api\_edges\_update\_edge**](#src_app_api_edges_update_edge) | **PUT** `/api/v1/edges/{uuid}` | Update Edge | | [**src\_app\_api\_environments\_cancel\_environment\_invitation**](#src_app_api_environments_cancel_environment_invitation) | **DELETE** `/api/v1/environments/invitations/{invitation_uuid}` | Cancel Environment Invitation | | [**src\_app\_api\_environments\_create\_environment\_for\_project**](#src_app_api_environments_create_environment_for_project) | **POST** `/api/v1/projects/{uuid}/environments` | Create Environment For Project | | [**src\_app\_api\_environments\_create\_environment\_link**](#src_app_api_environments_create_environment_link) | **POST** `/api/v1/environments/{uuid}/create-link` | Create Environment Link | | [**src\_app\_api\_environments\_create\_environment\_simulation**](#src_app_api_environments_create_environment_simulation) | **POST** `/api/v1/environments/{uuid}/simulations` | Create Environment Simulation | | [**src\_app\_api\_environments\_create\_environment\_snapshot**](#src_app_api_environments_create_environment_snapshot) | **POST** `/api/v1/environments/{uuid}/snapshots` | Create Environment Snapshot | | [**src\_app\_api\_environments\_add\_environment\_waypoints**](#src_app_api_environments_add_environment_waypoints) | **POST** `/api/v1/environments/{uuid}/waypoints` | Add Environment Waypoints | | [**src\_app\_api\_environments\_create\_standalone\_environment**](#src_app_api_environments_create_standalone_environment) | **POST** /api/v1/environments | Create Standalone Environment | | [**src\_app\_api\_environments\_delete\_environment**](#src_app_api_environments_delete_environment) | **DELETE** `/api/v1/environments/{uuid}` | Delete Environment | | [**src\_app\_api\_environments\_delete\_environment\_for\_project**](#src_app_api_environments_delete_environment_for_project) | **DELETE** `/api/v1/projects/{project_uuid}/environments/{uuid}` | Delete Environment For Project | | [**src\_app\_api\_environments\_delete\_environment\_snapshot**](#src_app_api_environments_delete_environment_snapshot) | **DELETE** `/api/v1/environments/{uuid}/snapshots/{snapshot_uuid}` | Delete Environment Snapshot | | [**src\_app\_api\_environments\_delete\_environment\_waypoint**](#src_app_api_environments_delete_environment_waypoint) | **DELETE** `/api/v1/environments/{uuid}/waypoints/{waypoint_id}` | Delete Environment Waypoint | | [**src\_app\_api\_environments\_delete\_recording**](#src_app_api_environments_delete_recording) | **DELETE** `/api/v1/environments/{uuid}/recordings/{recording_uuid}` | Delete Recording | | [**src\_app\_api\_environments\_generate\_telemetry\_recording**](#src_app_api_environments_generate_telemetry_recording) | **POST** `/api/v1/environments/{uuid}/generate-recording` | Generate Telemetry Recording | | [**src\_app\_api\_environments\_get\_environment**](#src_app_api_environments_get_environment) | **GET** `/api/v1/environments/{uuid}` | Get Environment | | [**src\_app\_api\_environments\_get\_environment\_dirty\_twins**](#src_app_api_environments_get_environment_dirty_twins) | **GET** `/api/v1/environments/{uuid}/schema/dirty_twins` | Get Environment Dirty Twins | | [**src\_app\_api\_environments\_get\_environment\_waypoints**](#src_app_api_environments_get_environment_waypoints) | **GET** `/api/v1/environments/{uuid}/waypoints` | Get Environment Waypoints | | [**src\_app\_api\_environments\_get\_environment\_invitations**](#src_app_api_environments_get_environment_invitations) | **GET** `/api/v1/environments/{uuid}/invitations` | Get Environment Invitations | | [**src\_app\_api\_environments\_get\_environment\_mujoco\_scene**](#src_app_api_environments_get_environment_mujoco_scene) | **GET** `/api/v1/environments/{uuid}/mujoco-scene` | Get Environment Mujoco Scene | | [**src\_app\_api\_environments\_get\_environment\_mujoco\_scene\_xml**](#src_app_api_environments_get_environment_mujoco_scene_xml) | **GET** `/api/v1/environments/{uuid}/mujoco-scene.xml` | Get Environment Mujoco Scene Xml | | [**src\_app\_api\_environments\_get\_environment\_mujoco\_scene\_zip\_direct**](#src_app_api_environments_get_environment_mujoco_scene_zip_direct) | **GET** `/api/v1/environments/{uuid}/mujoco-scene.zip` | Get Environment Mujoco Scene Zip Direct | | [**src\_app\_api\_environments\_get\_environment\_recordings**](#src_app_api_environments_get_environment_recordings) | **GET** `/api/v1/environments/{uuid}/recordings` | Get Environment Recordings | | [**src\_app\_api\_environments\_get\_environment\_sessions**](#src_app_api_environments_get_environment_sessions) | **GET** `/api/v1/environments/{uuid}/sessions` | Get Environment Sessions | | [**src\_app\_api\_environments\_get\_environment\_sharing\_info\_endpoint**](#src_app_api_environments_get_environment_sharing_info_endpoint) | **GET** `/api/v1/environments/{uuid}/sharing` | Get Environment Sharing Info Endpoint | | [**src\_app\_api\_environments\_get\_environment\_simulations**](#src_app_api_environments_get_environment_simulations) | **GET** `/api/v1/environments/{uuid}/simulations` | Get Environment Simulations | | [**src\_app\_api\_environments\_get\_environment\_snapshot**](#src_app_api_environments_get_environment_snapshot) | **GET** `/api/v1/environments/{uuid}/snapshots/{snapshot_uuid}` | Get Environment Snapshot | | [**src\_app\_api\_environments\_get\_environment\_snapshot\_hash**](#src_app_api_environments_get_environment_snapshot_hash) | **GET** `/api/v1/environments/{uuid}/snapshot-hash` | Get Environment Snapshot Hash | | [**src\_app\_api\_environments\_get\_environment\_twins**](#src_app_api_environments_get_environment_twins) | **GET** `/api/v1/environments/{uuid}/twins` | Get Environment Twins | | [**src\_app\_api\_environments\_get\_environment\_universal\_schema**](#src_app_api_environments_get_environment_universal_schema) | **GET** `/api/v1/environments/{uuid}/universal-schema` | Get Environment Universal Schema | | [**src\_app\_api\_environments\_get\_environment\_universal\_schema\_json**](#src_app_api_environments_get_environment_universal_schema_json) | **GET** `/api/v1/environments/{uuid}/universal-schema.json` | Get Environment Universal Schema Json | | [**src\_app\_api\_environments\_get\_environment\_urdf\_bundle**](#src_app_api_environments_get_environment_urdf_bundle) | **GET** `/api/v1/environments/{uuid}/urdf-bundle` | Get Environment Urdf Bundle | | [**src\_app\_api\_environments\_get\_environment\_urdf\_scene**](#src_app_api_environments_get_environment_urdf_scene) | **GET** `/api/v1/environments/{uuid}/urdf-scene` | Get Environment Urdf Scene | | [**src\_app\_api\_environments\_get\_environment\_urdf\_scene\_zip\_direct**](#src_app_api_environments_get_environment_urdf_scene_zip_direct) | **GET** `/api/v1/environments/{uuid}/urdf-scene.zip` | Get Environment Urdf Scene Zip Direct | | [**src\_app\_api\_environments\_get\_my\_environment\_permissions**](#src_app_api_environments_get_my_environment_permissions) | **GET** `/api/v1/environments/{uuid}/my-permissions` | Get My Environment Permissions | | [**src\_app\_api\_environments\_get\_recording\_data**](#src_app_api_environments_get_recording_data) | **GET** `/api/v1/environments/{uuid}/recordings/{recording_uuid}/data` | Get Recording Data | | [**src\_app\_api\_environments\_import\_environment\_mujoco\_scene**](#src_app_api_environments_import_environment_mujoco_scene) | **POST** `/api/v1/environments/{uuid}/import/mujoco-scene` | Import Environment Mujoco Scene | | [**src\_app\_api\_environments\_import\_environment\_universal\_schema**](#src_app_api_environments_import_environment_universal_schema) | **POST** `/api/v1/environments/{uuid}/import/universal-schema` | Import Environment Universal Schema | | [**src\_app\_api\_environments\_import\_environment\_urdf**](#src_app_api_environments_import_environment_urdf) | **POST** `/api/v1/environments/{uuid}/import/urdf` | Import Environment Urdf | | [**src\_app\_api\_environments\_invite\_user\_to\_environment**](#src_app_api_environments_invite_user_to_environment) | **POST** `/api/v1/environments/{uuid}/invite` | Invite User To Environment | | [**src\_app\_api\_environments\_list\_all\_environments**](#src_app_api_environments_list_all_environments) | **GET** /api/v1/environments | List All Environments | | [**src\_app\_api\_environments\_list\_environment\_mission\_executions**](#src_app_api_environments_list_environment_mission_executions) | **GET** `/api/v1/environments/{uuid}/mission-executions` | List Environment Mission Executions | | [**src\_app\_api\_environments\_list\_environment\_snapshots**](#src_app_api_environments_list_environment_snapshots) | **GET** `/api/v1/environments/{uuid}/snapshots` | List Environment Snapshots | | [**src\_app\_api\_environments\_list\_environment\_task\_executions**](#src_app_api_environments_list_environment_task_executions) | **GET** `/api/v1/environments/{uuid}/task-executions` | List Environment Task Executions | | [**src\_app\_api\_environments\_list\_environments\_for\_project**](#src_app_api_environments_list_environments_for_project) | **GET** `/api/v1/projects/{uuid}/environments` | List Environments For Project | | [**src\_app\_api\_environments\_process\_all\_environment\_sessions**](#src_app_api_environments_process_all_environment_sessions) | **POST** `/api/v1/environments/{uuid}/process-all-sessions` | Process All Environment Sessions | | [**src\_app\_api\_environments\_remove\_user\_from\_environment**](#src_app_api_environments_remove_user_from_environment) | **DELETE** `/api/v1/environments/{uuid}/users/{user_id}` | Remove User From Environment | | [**src\_app\_api\_environments\_reset\_environment**](#src_app_api_environments_reset_environment) | **POST** `/api/v1/environments/{uuid}/reset` | Reset Environment | | [**src\_app\_api\_environments\_restore\_environment\_snapshot**](#src_app_api_environments_restore_environment_snapshot) | **PUT** `/api/v1/environments/{uuid}/snapshots/{snapshot_uuid}/restore` | Restore Environment Snapshot | | [**src\_app\_api\_environments\_revoke\_environment\_link**](#src_app_api_environments_revoke_environment_link) | **POST** `/api/v1/environments/{uuid}/revoke-link` | Revoke Environment Link | | [**src\_app\_api\_environments\_share\_environment\_with\_user**](#src_app_api_environments_share_environment_with_user) | **POST** `/api/v1/environments/{uuid}/share` | Share Environment With User | | [**src\_app\_api\_environments\_stop\_environment\_simulation**](#src_app_api_environments_stop_environment_simulation) | **POST** `/api/v1/environments/{uuid}/simulations/{simulation_id}/stop` | Stop Environment Simulation | | [**src\_app\_api\_environments\_update\_environment**](#src_app_api_environments_update_environment) | **PUT** `/api/v1/environments/{uuid}` | Update Environment | | [**src\_app\_api\_environments\_update\_environment\_for\_project**](#src_app_api_environments_update_environment_for_project) | **PUT** `/api/v1/projects/{project_uuid}/environments/{uuid}` | Update Environment For Project | | [**src\_app\_api\_environments\_update\_environment\_snapshot**](#src_app_api_environments_update_environment_snapshot) | **PUT** `/api/v1/environments/{uuid}/snapshots/{snapshot_uuid}` | Update Environment Snapshot | | [**src\_app\_api\_environments\_update\_recording\_metadata**](#src_app_api_environments_update_recording_metadata) | **PUT** `/api/v1/environments/{uuid}/recordings/{recording_uuid}` | Update Recording Metadata | | [**src\_app\_api\_episode\_create\_episode**](#src_app_api_episode_create_episode) | **POST** /api/v1/episodes | Create Episode | | [**src\_app\_api\_episode\_delete\_episode**](#src_app_api_episode_delete_episode) | **DELETE** `/api/v1/episodes/{uuid}` | Delete Episode | | [**src\_app\_api\_episode\_get\_episode**](#src_app_api_episode_get_episode) | **GET** `/api/v1/episodes/{uuid}` | Get Episode | | [**src\_app\_api\_episode\_list\_episode\_task\_names**](#src_app_api_episode_list_episode_task_names) | **GET** /api/v1/episodes/task-names | List Episode Task Names | | [**src\_app\_api\_episode\_list\_episodes**](#src_app_api_episode_list_episodes) | **GET** /api/v1/episodes | List Episodes | | [**src\_app\_api\_episode\_update\_episode**](#src_app_api_episode_update_episode) | **PUT** `/api/v1/episodes/{uuid}` | Update Episode | | [**src\_app\_api\_events\_create\_business\_event**](#src_app_api_events_create_business_event) | **POST** /api/v1/events | Create Business Event | | [**src\_app\_api\_events\_list\_live\_events**](#src_app_api_events_list_live_events) | **GET** /api/v1/events/live | List Live Events | | [**src\_app\_api\_executions\_get\_task\_execution**](#src_app_api_executions_get_task_execution) | **GET** `/api/v1/executions/{uuid}` | Get Task Execution | | [**src\_app\_api\_executions\_list\_task\_executions**](#src_app_api_executions_list_task_executions) | **GET** /api/v1/executions | List Task Executions | | [**src\_app\_api\_invitation\_router\_accept\_invitation\_endpoint**](#src_app_api_invitation_router_accept_invitation_endpoint) | **GET** `/api/v1/invitations/accept/{token}` | Accept Invitation Endpoint | | [**src\_app\_api\_invitation\_router\_get\_invitation\_info**](#src_app_api_invitation_router_get_invitation_info) | **GET** `/api/v1/invitations/info/{token}` | Get Invitation Info | | [**src\_app\_api\_keybindings\_create\_keybinding**](#src_app_api_keybindings_create_keybinding) | **POST** /api/v1/keybindings | Create Keybinding | | [**src\_app\_api\_keybindings\_delete\_keybinding**](#src_app_api_keybindings_delete_keybinding) | **DELETE** `/api/v1/keybindings/{uuid}` | Delete Keybinding | | [**src\_app\_api\_keybindings\_get\_keybinding**](#src_app_api_keybindings_get_keybinding) | **GET** `/api/v1/keybindings/{uuid}` | Get Keybinding | | [**src\_app\_api\_keybindings\_list\_keybindings**](#src_app_api_keybindings_list_keybindings) | **GET** /api/v1/keybindings | List Keybindings | | [**src\_app\_api\_keybindings\_update\_keybinding**](#src_app_api_keybindings_update_keybinding) | **PUT** `/api/v1/keybindings/{uuid}` | Update Keybinding | | [**src\_app\_api\_labs\_admin\_force\_end\_session**](#src_app_api_labs_admin_force_end_session) | **DELETE** `/api/v1/labs/milan-so101/admin/sessions/{session_uuid}` | Admin Force End Session | | [**src\_app\_api\_labs\_end\_milan\_lab\_session**](#src_app_api_labs_end_milan_lab_session) | **DELETE** /api/v1/labs/milan-so101/end-session | End Milan Lab Session | | [**src\_app\_api\_labs\_get\_admin\_lab\_overview**](#src_app_api_labs_get_admin_lab_overview) | **GET** /api/v1/labs/milan-so101/admin/sessions | Get Admin Lab Overview | | [**src\_app\_api\_labs\_get\_milan\_lab\_status**](#src_app_api_labs_get_milan_lab_status) | **GET** /api/v1/labs/milan-so101/status | Get Milan Lab Status | | [**src\_app\_api\_labs\_request\_milan\_lab\_access**](#src_app_api_labs_request_milan_lab_access) | **POST** /api/v1/labs/milan-so101/request-access | Request Milan Lab Access | | [**src\_app\_api\_maps\_create\_map**](#src_app_api_maps_create_map) | **POST** /api/v1/maps | Create Map | | [**src\_app\_api\_maps\_delete\_map**](#src_app_api_maps_delete_map) | **DELETE** `/api/v1/maps/{uuid}` | Delete Map | | [**src\_app\_api\_maps\_download\_map\_data**](#src_app_api_maps_download_map_data) | **GET** `/api/v1/maps/{uuid}/data` | Download Map Data | | [**src\_app\_api\_maps\_finalize\_stream\_map**](#src_app_api_maps_finalize_stream_map) | **POST** `/api/v1/maps/{uuid}/stream-finalize` | Finalize Stream Map | | [**src\_app\_api\_maps\_get\_map**](#src_app_api_maps_get_map) | **GET** `/api/v1/maps/{uuid}` | Get Map | | [**src\_app\_api\_maps\_get\_map\_image**](#src_app_api_maps_get_map_image) | **GET** `/api/v1/maps/{uuid}/image` | Get Map Image | | [**src\_app\_api\_maps\_list\_environment\_maps**](#src_app_api_maps_list_environment_maps) | **GET** `/api/v1/maps/environments/{uuid}` | List Environment Maps | | [**src\_app\_api\_maps\_list\_maps**](#src_app_api_maps_list_maps) | **GET** /api/v1/maps | List Maps | | [**src\_app\_api\_maps\_list\_twin\_maps**](#src_app_api_maps_list_twin_maps) | **GET** `/api/v1/maps/twins/{uuid}` | List Twin Maps | | [**src\_app\_api\_maps\_start\_map\_from\_stream**](#src_app_api_maps_start_map_from_stream) | **POST** /api/v1/maps/stream-start | Start Map From Stream | | [**src\_app\_api\_maps\_stop\_map\_from\_stream**](#src_app_api_maps_stop_map_from_stream) | **POST** /api/v1/maps/stream-stop | Stop Map From Stream | | [**src\_app\_api\_missions\_cancel\_mission\_execution**](#src_app_api_missions_cancel_mission_execution) | **POST** `/api/v1/twins/{twin_uuid}/missions/{mission_uuid}/executions/{uuid}/cancel` | Cancel Mission Execution | | [**src\_app\_api\_missions\_create\_mission**](#src_app_api_missions_create_mission) | **POST** `/api/v1/twins/{uuid}/missions` | Create Mission | | [**src\_app\_api\_missions\_delete\_mission**](#src_app_api_missions_delete_mission) | **DELETE** `/api/v1/twins/{twin_uuid}/missions/{uuid}` | Delete Mission | | [**src\_app\_api\_missions\_execute\_mission**](#src_app_api_missions_execute_mission) | **POST** `/api/v1/twins/{twin_uuid}/missions/{uuid}/execute` | Execute Mission | | [**src\_app\_api\_missions\_get\_mission**](#src_app_api_missions_get_mission) | **GET** `/api/v1/twins/{twin_uuid}/missions/{uuid}` | Get Mission | | [**src\_app\_api\_missions\_get\_mission\_execution**](#src_app_api_missions_get_mission_execution) | **GET** `/api/v1/twins/{twin_uuid}/missions/{mission_uuid}/executions/{uuid}` | Get Mission Execution | | [**src\_app\_api\_missions\_list\_mission\_executions**](#src_app_api_missions_list_mission_executions) | **GET** `/api/v1/twins/{twin_uuid}/missions/{uuid}/executions` | List Mission Executions | | [**src\_app\_api\_missions\_list\_missions**](#src_app_api_missions_list_missions) | **GET** `/api/v1/twins/{uuid}/missions` | List Missions | | [**src\_app\_api\_mlmodels\_create\_mlmodel**](#src_app_api_mlmodels_create_mlmodel) | **POST** /api/v1/mlmodels | Create Mlmodel | | [**src\_app\_api\_mlmodels\_delete\_mlmodel**](#src_app_api_mlmodels_delete_mlmodel) | **DELETE** `/api/v1/mlmodels/{uuid}` | Delete Mlmodel | | [**src\_app\_api\_mlmodels\_get\_mlmodel**](#src_app_api_mlmodels_get_mlmodel) | **GET** `/api/v1/mlmodels/{uuid}` | Get Mlmodel | | [**src\_app\_api\_mlmodels\_get\_mlmodel\_weights**](#src_app_api_mlmodels_get_mlmodel_weights) | **GET** `/api/v1/mlmodels/{uuid}/weights` | Get Mlmodel Weights | | [**src\_app\_api\_mlmodels\_list\_mlmodels**](#src_app_api_mlmodels_list_mlmodels) | **GET** /api/v1/mlmodels | List Mlmodels | | [**src\_app\_api\_mlmodels\_update\_mlmodel**](#src_app_api_mlmodels_update_mlmodel) | **PUT** `/api/v1/mlmodels/{uuid}` | Update Mlmodel | | [**src\_app\_api\_mltrainings\_create\_mltraining**](#src_app_api_mltrainings_create_mltraining) | **POST** /api/v1/mltrainings | Create Mltraining | | [**src\_app\_api\_mltrainings\_delete\_mltraining**](#src_app_api_mltrainings_delete_mltraining) | **DELETE** `/api/v1/mltrainings/{uuid}` | Delete Mltraining | | [**src\_app\_api\_mltrainings\_deploy\_mltraining**](#src_app_api_mltrainings_deploy_mltraining) | **POST** `/api/v1/mltrainings/{uuid}/deploy` | Deploy Mltraining | | [**src\_app\_api\_mltrainings\_get\_deployed\_mltrainings**](#src_app_api_mltrainings_get_deployed_mltrainings) | **GET** /api/v1/mltrainings/deployed | Get Deployed Mltrainings | | [**src\_app\_api\_mltrainings\_get\_mltraining**](#src_app_api_mltrainings_get_mltraining) | **GET** `/api/v1/mltrainings/{uuid}` | Get Mltraining | | [**src\_app\_api\_mltrainings\_list\_mltrainings\_for\_user\_workspaces**](#src_app_api_mltrainings_list_mltrainings_for_user_workspaces) | **GET** /api/v1/mltrainings | List Mltrainings For User Workspaces | | [**src\_app\_api\_mltrainings\_update\_mltraining**](#src_app_api_mltrainings_update_mltraining) | **PUT** `/api/v1/mltrainings/{uuid}` | Update Mltraining | | [**src\_app\_api\_navigation\_execute\_twin\_navigation**](#src_app_api_navigation_execute_twin_navigation) | **POST** `/api/v1/twins/{uuid}/navigation` | Execute Twin Navigation | | [**src\_app\_api\_projects\_create\_project**](#src_app_api_projects_create_project) | **POST** /api/v1/projects | Create Project | | [**src\_app\_api\_projects\_create\_project\_link**](#src_app_api_projects_create_project_link) | **POST** `/api/v1/projects/{uuid}/create-link` | Create Project Link | | [**src\_app\_api\_projects\_delete\_project**](#src_app_api_projects_delete_project) | **DELETE** `/api/v1/projects/{uuid}` | Delete Project | | [**src\_app\_api\_projects\_get\_my\_project\_permissions**](#src_app_api_projects_get_my_project_permissions) | **GET** `/api/v1/projects/{uuid}/my-permissions` | Get My Project Permissions | | [**src\_app\_api\_projects\_get\_project**](#src_app_api_projects_get_project) | **GET** `/api/v1/projects/{uuid}` | Get Project | | [**src\_app\_api\_projects\_get\_project\_shares**](#src_app_api_projects_get_project_shares) | **GET** `/api/v1/projects/{uuid}/shares` | Get Project Shares | | [**src\_app\_api\_projects\_invite\_user\_to\_project**](#src_app_api_projects_invite_user_to_project) | **POST** `/api/v1/projects/{uuid}/invite` | Invite User To Project | | [**src\_app\_api\_projects\_list\_projects**](#src_app_api_projects_list_projects) | **GET** /api/v1/projects | List Projects | | [**src\_app\_api\_projects\_revoke\_project\_link**](#src_app_api_projects_revoke_project_link) | **POST** `/api/v1/projects/{uuid}/revoke-link` | Revoke Project Link | | [**src\_app\_api\_projects\_share\_project**](#src_app_api_projects_share_project) | **POST** `/api/v1/projects/{uuid}/share` | Share Project | | [**src\_app\_api\_projects\_unshare\_project**](#src_app_api_projects_unshare_project) | **POST** `/api/v1/projects/{uuid}/unshare` | Unshare Project | | [**src\_app\_api\_projects\_update\_project**](#src_app_api_projects_update_project) | **PUT** `/api/v1/projects/{uuid}` | Update Project | | [**src\_app\_api\_tagged\_frames\_create\_tagged\_frames**](#src_app_api_tagged_frames_create_tagged_frames) | **POST** /api/v1/tagged-frames | Create Tagged Frames | | [**src\_app\_api\_tagged\_frames\_delete\_tagged\_frames**](#src_app_api_tagged_frames_delete_tagged_frames) | **DELETE** `/api/v1/tagged-frames/{uuid}` | Delete Tagged Frames | | [**src\_app\_api\_tagged\_frames\_get\_tagged\_frames**](#src_app_api_tagged_frames_get_tagged_frames) | **GET** `/api/v1/tagged-frames/{uuid}` | Get Tagged Frames | | [**src\_app\_api\_tagged\_frames\_list\_tagged\_frames**](#src_app_api_tagged_frames_list_tagged_frames) | **GET** /api/v1/tagged-frames | List Tagged Frames | | [**src\_app\_api\_tagged\_frames\_update\_tagged\_frames**](#src_app_api_tagged_frames_update_tagged_frames) | **PUT** `/api/v1/tagged-frames/{uuid}` | Update Tagged Frames | | [**src\_app\_api\_tasks\_cancel\_task\_execution**](#src_app_api_tasks_cancel_task_execution) | **POST** `/api/v1/tasks/executions/{uuid}/cancel` | Cancel Task Execution | | [**src\_app\_api\_tasks\_create\_task**](#src_app_api_tasks_create_task) | **POST** /api/v1/tasks | Create Task | | [**src\_app\_api\_tasks\_delete\_task**](#src_app_api_tasks_delete_task) | **DELETE** `/api/v1/tasks/{uuid}` | Delete Task | | [**src\_app\_api\_tasks\_execute\_task**](#src_app_api_tasks_execute_task) | **POST** `/api/v1/tasks/{uuid}/execute` | Execute Task | | [**src\_app\_api\_tasks\_get\_task**](#src_app_api_tasks_get_task) | **GET** `/api/v1/tasks/{uuid}` | Get Task | | [**src\_app\_api\_tasks\_get\_task\_execution**](#src_app_api_tasks_get_task_execution) | **GET** `/api/v1/tasks/executions/{uuid}` | Get Task Execution | | [**src\_app\_api\_tasks\_list\_task\_queue**](#src_app_api_tasks_list_task_queue) | **GET** /api/v1/tasks/queue | List Task Queue | | [**src\_app\_api\_tasks\_list\_tasks**](#src_app_api_tasks_list_tasks) | **GET** /api/v1/tasks | List Tasks | | [**src\_app\_api\_tasks\_update\_task**](#src_app_api_tasks_update_task) | **PUT** `/api/v1/tasks/{uuid}` | Update Task | | [**src\_app\_api\_twins\_create\_twin**](#src_app_api_twins_create_twin) | **POST** /api/v1/twins | Create Twin | | [**src\_app\_api\_twins\_delete\_twin**](#src_app_api_twins_delete_twin) | **DELETE** `/api/v1/twins/{uuid}` | Delete Twin | | [**src\_app\_api\_twins\_execute\_twin\_action**](#src_app_api_twins_execute_twin_action) | **POST** `/api/v1/twins/{uuid}/actions` | Execute Twin Action | | [**src\_app\_api\_twins\_get\_recording**](#src_app_api_twins_get_recording) | **GET** `/api/v1/twins/recordings/{recording_uuid}` | Get Recording | | [**src\_app\_api\_twins\_get\_twin**](#src_app_api_twins_get_twin) | **GET** `/api/v1/twins/{uuid}` | Get Twin | | [**src\_app\_api\_twins\_get\_twin\_action\_status**](#src_app_api_twins_get_twin_action_status) | **GET** `/api/v1/twins/{uuid}/actions/{action_id}` | Get Twin Action Status | | [**src\_app\_api\_twins\_get\_twin\_calibration**](#src_app_api_twins_get_twin_calibration) | **GET** `/api/v1/twins/{uuid}/calibration` | Get Twin Calibration | | [**src\_app\_api\_twins\_get\_twin\_connection\_history**](#src_app_api_twins_get_twin_connection_history) | **GET** `/api/v1/twins/{uuid}/connection-history` | Get Twin Connection History | | [**src\_app\_api\_twins\_get\_twin\_driver\_logs**](#src_app_api_twins_get_twin_driver_logs) | **GET** `/api/v1/twins/{uuid}/logs` | Get Twin Driver Logs | | [**src\_app\_api\_twins\_get\_twin\_latest\_frame**](#src_app_api_twins_get_twin_latest_frame) | **GET** `/api/v1/twins/{uuid}/latest-frame` | Get Twin Latest Frame | | [**src\_app\_api\_twins\_get\_twin\_latest\_metrics**](#src_app_api_twins_get_twin_latest_metrics) | **GET** `/api/v1/twins/{uuid}/metrics/latest` | Get Twin Latest Metrics | | [**src\_app\_api\_twins\_get\_twin\_links**](#src_app_api_twins_get_twin_links) | **GET** `/api/v1/twins/{uuid}/links` | Get Twin Links | | [**src\_app\_api\_twins\_get\_twin\_metrics**](#src_app_api_twins_get_twin_metrics) | **GET** `/api/v1/twins/{uuid}/metrics` | Get Twin Metrics | | [**src\_app\_api\_twins\_get\_twin\_motions**](#src_app_api_twins_get_twin_motions) | **GET** `/api/v1/twins/{uuid}/motions` | Get Twin Motions | | [**src\_app\_api\_twins\_get\_twin\_notebook**](#src_app_api_twins_get_twin_notebook) | **GET** `/api/v1/twins/{uuid}/notebook.ipynb` | Get Twin Notebook | | [**src\_app\_api\_twins\_get\_twin\_recordings**](#src_app_api_twins_get_twin_recordings) | **GET** `/api/v1/twins/{uuid}/recordings` | Get Twin Recordings | | [**src\_app\_api\_twins\_get\_twin\_relationships**](#src_app_api_twins_get_twin_relationships) | **GET** `/api/v1/twins/{uuid}/relationships` | Get Twin Relationships | | [**src\_app\_api\_twins\_get\_twin\_universal\_schema\_at\_path**](#src_app_api_twins_get_twin_universal_schema_at_path) | **GET** `/api/v1/twins/{uuid}/universal-schema/at` | Get Twin Universal Schema At Path | | [**src\_app\_api\_twins\_link\_occupancy\_map**](#src_app_api_twins_link_occupancy_map) | **POST** `/api/v1/twins/{uuid}/occupancy-map` | Link Occupancy Map | | [**src\_app\_api\_twins\_list\_all\_twins**](#src_app_api_twins_list_all_twins) | **GET** /api/v1/twins | List All Twins | | [**src\_app\_api\_twins\_patch\_twin\_universal\_schema**](#src_app_api_twins_patch_twin_universal_schema) | **PATCH** `/api/v1/twins/{uuid}/universal-schema` | Patch Twin Universal Schema | | [**src\_app\_api\_twins\_reload\_twin\_capabilities**](#src_app_api_twins_reload_twin_capabilities) | **POST** `/api/v1/twins/{uuid}/reload-capabilities` | Reload Twin Capabilities | | [**src\_app\_api\_twins\_reload\_twins\_capabilities\_bulk**](#src_app_api_twins_reload_twins_capabilities_bulk) | **POST** /api/v1/twins/reload-capabilities | Reload Twins Capabilities Bulk | | [**src\_app\_api\_twins\_sync\_twin\_with\_asset**](#src_app_api_twins_sync_twin_with_asset) | **POST** `/api/v1/twins/{uuid}/sync-with-asset` | Sync Twin With Asset | | [**src\_app\_api\_twins\_update\_twin**](#src_app_api_twins_update_twin) | **PUT** `/api/v1/twins/{uuid}` | Update Twin | | [**src\_app\_api\_twins\_update\_twin\_calibration**](#src_app_api_twins_update_twin_calibration) | **POST** `/api/v1/twins/{uuid}/calibration` | Update Twin Calibration | | [**src\_app\_api\_twins\_update\_twin\_state**](#src_app_api_twins_update_twin_state) | **PATCH** `/api/v1/twins/{uuid}/state` | Update Twin State | | [**src\_app\_api\_urdf\_create\_urdf\_project**](#src_app_api_urdf_create_urdf_project) | **POST** /api/v1/urdf-projects | Create Urdf Project | | [**src\_app\_api\_urdf\_delete\_urdf\_project**](#src_app_api_urdf_delete_urdf_project) | **DELETE** `/api/v1/urdf-projects/{uuid}` | Delete Urdf Project | | [**src\_app\_api\_urdf\_fix\_urdf\_project\_slug**](#src_app_api_urdf_fix_urdf_project_slug) | **POST** `/api/v1/urdf-projects/{uuid}/fix-slug` | Fix Urdf Project Slug | | [**src\_app\_api\_urdf\_get\_twin\_joint\_state**](#src_app_api_urdf_get_twin_joint_state) | **GET** `/api/v1/twins/{uuid}/joints/{joint_name}/state` | Get Twin Joint State | | [**src\_app\_api\_urdf\_get\_twin\_joint\_states**](#src_app_api_urdf_get_twin_joint_states) | **GET** `/api/v1/twins/{uuid}/joint_states` | Get Twin Joint States | | [**src\_app\_api\_urdf\_get\_twin\_joints**](#src_app_api_urdf_get_twin_joints) | **GET** `/api/v1/twins/{uuid}/joints` | Get Twin Joints | | [**src\_app\_api\_urdf\_get\_twin\_robot\_description**](#src_app_api_urdf_get_twin_robot_description) | **GET** `/api/v1/twins/{uuid}/robot_description` | Get Twin Robot Description | | [**src\_app\_api\_urdf\_get\_twin\_urdf\_raw**](#src_app_api_urdf_get_twin_urdf_raw) | **GET** `/api/v1/twins/{uuid}/urdf` | Get Twin Urdf Raw | | [**src\_app\_api\_urdf\_get\_urdf\_project**](#src_app_api_urdf_get_urdf_project) | **GET** `/api/v1/urdf-projects/{uuid}` | Get Urdf Project | | [**src\_app\_api\_urdf\_list\_urdf\_projects**](#src_app_api_urdf_list_urdf_projects) | **GET** /api/v1/urdf-projects | List Urdf Projects | | [**src\_app\_api\_urdf\_update\_twin\_joint\_state**](#src_app_api_urdf_update_twin_joint_state) | **PUT** `/api/v1/twins/{uuid}/joints/{joint_name}/state` | Update Twin Joint State | | [**src\_app\_api\_urdf\_update\_twin\_joint\_states**](#src_app_api_urdf_update_twin_joint_states) | **PUT** `/api/v1/twins/{uuid}/joint_states` | Update Twin Joint States | | [**src\_app\_api\_urdf\_update\_urdf\_project**](#src_app_api_urdf_update_urdf_project) | **PUT** `/api/v1/urdf-projects/{uuid}` | Update Urdf Project | | [**src\_app\_api\_urdf\_upload\_zip\_file**](#src_app_api_urdf_upload_zip_file) | **POST** `/api/v1/urdf-projects/{uuid}/zip-file` | Upload Zip File | | [**src\_app\_api\_workflows\_activate\_workflow**](#src_app_api_workflows_activate_workflow) | **POST** `/api/v1/workflows/{uuid}/activate` | Activate Workflow | | [**src\_app\_api\_workflows\_cancel\_workflow\_execution**](#src_app_api_workflows_cancel_workflow_execution) | **POST** `/api/v1/workflows/executions/{execution_uuid}/cancel` | Cancel Workflow Execution | | [**src\_app\_api\_workflows\_create\_workflow**](#src_app_api_workflows_create_workflow) | **POST** /api/v1/workflows | Create Workflow | | [**src\_app\_api\_workflows\_create\_workflow\_connection**](#src_app_api_workflows_create_workflow_connection) | **POST** `/api/v1/workflows/{uuid}/connections` | Create Workflow Connection | | [**src\_app\_api\_workflows\_create\_workflow\_node**](#src_app_api_workflows_create_workflow_node) | **POST** `/api/v1/workflows/{uuid}/nodes` | Create Workflow Node | | [**src\_app\_api\_workflows\_deactivate\_workflow**](#src_app_api_workflows_deactivate_workflow) | **POST** `/api/v1/workflows/{uuid}/deactivate` | Deactivate Workflow | | [**src\_app\_api\_workflows\_delete\_workflow**](#src_app_api_workflows_delete_workflow) | **DELETE** `/api/v1/workflows/{uuid}` | Delete Workflow | | [**src\_app\_api\_workflows\_delete\_workflow\_connection**](#src_app_api_workflows_delete_workflow_connection) | **DELETE** `/api/v1/workflows/{uuid}/connections/{connection_uuid}` | Delete Workflow Connection | | [**src\_app\_api\_workflows\_delete\_workflow\_node**](#src_app_api_workflows_delete_workflow_node) | **DELETE** `/api/v1/workflows/{uuid}/nodes/{node_uuid}` | Delete Workflow Node | | [**src\_app\_api\_workflows\_edge\_sync\_workflows**](#src_app_api_workflows_edge_sync_workflows) | **GET** `/api/v1/workflows/edge-sync/{twin_uuid}` | Edge Sync Workflows | | [**src\_app\_api\_workflows\_execute\_workflow**](#src_app_api_workflows_execute_workflow) | **POST** `/api/v1/workflows/{uuid}/execute` | Execute Workflow | | [**src\_app\_api\_workflows\_get\_execution\_by\_uuid**](#src_app_api_workflows_get_execution_by_uuid) | **GET** `/api/v1/workflows/executions/{execution_uuid}` | Get Execution By Uuid | | [**src\_app\_api\_workflows\_get\_node\_schema**](#src_app_api_workflows_get_node_schema) | **GET** `/api/v1/workflows/node-schemas/{node_type}` | Get Node Schema | | [**src\_app\_api\_workflows\_get\_node\_schemas**](#src_app_api_workflows_get_node_schemas) | **GET** /api/v1/workflows/node-schemas | Get Node Schemas | | [**src\_app\_api\_workflows\_get\_workflow**](#src_app_api_workflows_get_workflow) | **GET** `/api/v1/workflows/{uuid}` | Get Workflow | | [**src\_app\_api\_workflows\_get\_workflow\_execution**](#src_app_api_workflows_get_workflow_execution) | **GET** `/api/v1/workflows/{uuid}/executions/{execution_uuid}` | Get Workflow Execution | | [**src\_app\_api\_workflows\_get\_workflow\_node**](#src_app_api_workflows_get_workflow_node) | **GET** `/api/v1/workflows/{uuid}/nodes/{node_uuid}` | Get Workflow Node | | [**src\_app\_api\_workflows\_list\_workflow\_connections**](#src_app_api_workflows_list_workflow_connections) | **GET** `/api/v1/workflows/{uuid}/connections` | List Workflow Connections | | [**src\_app\_api\_workflows\_list\_workflow\_executions**](#src_app_api_workflows_list_workflow_executions) | **GET** `/api/v1/workflows/{uuid}/executions` | List Workflow Executions | | [**src\_app\_api\_workflows\_list\_workflow\_nodes**](#src_app_api_workflows_list_workflow_nodes) | **GET** `/api/v1/workflows/{uuid}/nodes` | List Workflow Nodes | | [**src\_app\_api\_workflows\_list\_workflows**](#src_app_api_workflows_list_workflows) | **GET** /api/v1/workflows | List Workflows | | [**src\_app\_api\_workflows\_update\_workflow**](#src_app_api_workflows_update_workflow) | **PUT** `/api/v1/workflows/{uuid}` | Update Workflow | | [**src\_app\_api\_workflows\_update\_workflow\_node**](#src_app_api_workflows_update_workflow_node) | **PUT** `/api/v1/workflows/{uuid}/nodes/{node_uuid}` | Update Workflow Node | | [**src\_app\_api\_workflows\_validate\_node\_inputs**](#src_app_api_workflows_validate_node_inputs) | **POST** `/api/v1/workflows/nodes/{node_uuid}/validate-inputs` | Validate Node Inputs | | [**src\_users\_api\_organizations\_add\_organization\_member\_by\_email**](#src_users_api_organizations_add_organization_member_by_email) | **POST** `/api/v1/users/organizations/{uuid}/members` | Add Organization Member By Email | | [**src\_users\_api\_organizations\_create\_organization**](#src_users_api_organizations_create_organization) | **POST** /api/v1/users/organizations | Create Organization | | [**src\_users\_api\_organizations\_delete\_organization**](#src_users_api_organizations_delete_organization) | **DELETE** `/api/v1/users/organizations/{uuid}` | Delete Organization | | [**src\_users\_api\_organizations\_get\_organization**](#src_users_api_organizations_get_organization) | **GET** `/api/v1/users/organizations/{uuid}` | Get Organization | | [**src\_users\_api\_organizations\_get\_organization\_by\_slug**](#src_users_api_organizations_get_organization_by_slug) | **GET** `/api/v1/users/organizations/by-slug/{slug}` | Get Organization By Slug | | [**src\_users\_api\_organizations\_list\_organization\_members**](#src_users_api_organizations_list_organization_members) | **GET** `/api/v1/users/organizations/{uuid}/members` | List Organization Members | | [**src\_users\_api\_organizations\_list\_organization\_workspaces**](#src_users_api_organizations_list_organization_workspaces) | **GET** `/api/v1/users/organizations/{uuid}/workspaces` | List Organization Workspaces | | [**src\_users\_api\_organizations\_list\_organizations**](#src_users_api_organizations_list_organizations) | **GET** /api/v1/users/organizations | List Organizations | | [**src\_users\_api\_organizations\_remove\_organization\_member**](#src_users_api_organizations_remove_organization_member) | **DELETE** `/api/v1/users/organizations/{uuid}/members/{user_uuid}` | Remove Organization Member | | [**src\_users\_api\_organizations\_update\_organization**](#src_users_api_organizations_update_organization) | **PUT** `/api/v1/users/organizations/{uuid}` | Update Organization | | [**src\_users\_api\_organizations\_update\_organization\_member\_role**](#src_users_api_organizations_update_organization_member_role) | **PUT** `/api/v1/users/organizations/{uuid}/members/{user_uuid}/role` | Update Organization Member Role | | [**src\_users\_api\_plans\_get\_plan**](#src_users_api_plans_get_plan) | **GET** /api/v1/users/plan | Get Plan | | [**src\_users\_api\_workspaces\_add\_workspace\_member\_by\_email**](#src_users_api_workspaces_add_workspace_member_by_email) | **POST** `/api/v1/users/workspaces/{uuid}/add-member` | Add Workspace Member By Email | | [**src\_users\_api\_workspaces\_check\_workspace\_slug**](#src_users_api_workspaces_check_workspace_slug) | **GET** `/api/v1/users/workspaces/check-slug/{slug}` | Check Workspace Slug | | [**src\_users\_api\_workspaces\_create\_workspace**](#src_users_api_workspaces_create_workspace) | **POST** /api/v1/users/workspaces | Create Workspace | | [**src\_users\_api\_workspaces\_delete\_workspace**](#src_users_api_workspaces_delete_workspace) | **DELETE** `/api/v1/users/workspaces/{uuid}` | Delete Workspace | | [**src\_users\_api\_workspaces\_get\_default\_workspace**](#src_users_api_workspaces_get_default_workspace) | **GET** /api/v1/users/workspaces/default | Get Default Workspace | | [**src\_users\_api\_workspaces\_get\_vendor\_description**](#src_users_api_workspaces_get_vendor_description) | **GET** `/api/v1/users/vendors/{slug}/description` | Get Vendor Description | | [**src\_users\_api\_workspaces\_get\_workspace**](#src_users_api_workspaces_get_workspace) | **GET** `/api/v1/users/workspaces/{uuid}` | Get Workspace | | [**src\_users\_api\_workspaces\_get\_workspace\_by\_slug**](#src_users_api_workspaces_get_workspace_by_slug) | **GET** `/api/v1/users/workspaces/by-slug/{slug}` | Get Workspace By Slug | | [**src\_users\_api\_workspaces\_leave\_team**](#src_users_api_workspaces_leave_team) | **DELETE** `/api/v1/users/workspaces/{team_uuid}/members/{uuid}/leave` | Leave Team | | [**src\_users\_api\_workspaces\_list\_team\_members**](#src_users_api_workspaces_list_team_members) | **GET** `/api/v1/users/workspaces/{team_uuid}/members` | List Team Members | | [**src\_users\_api\_workspaces\_list\_workspaces**](#src_users_api_workspaces_list_workspaces) | **GET** /api/v1/users/workspaces | List Workspaces | | [**src\_users\_api\_workspaces\_remove\_team\_member**](#src_users_api_workspaces_remove_team_member) | **DELETE** `/api/v1/users/workspaces/{team_uuid}/members/{uuid}` | Remove Team Member | | [**src\_users\_api\_workspaces\_remove\_workspace\_member**](#src_users_api_workspaces_remove_workspace_member) | **DELETE** `/api/v1/users/workspaces/{uuid}/members/{user_uuid}` | Remove Workspace Member | | [**src\_users\_api\_workspaces\_set\_default\_workspace**](#src_users_api_workspaces_set_default_workspace) | **POST** /api/v1/users/workspaces/default | Set Default Workspace | | [**src\_users\_api\_workspaces\_update\_workspace**](#src_users_api_workspaces_update_workspace) | **PUT** `/api/v1/users/workspaces/{uuid}` | Update Workspace | | [**src\_users\_api\_workspaces\_update\_workspace\_member\_role**](#src_users_api_workspaces_update_workspace_member_role) | **PUT** `/api/v1/users/workspaces/{uuid}/members/{user_uuid}/role` | Update Workspace Member Role | # **src\_app\_api\_alerts\_acknowledge\_alert** > AlertSchema src\_app\_api\_alerts\_acknowledge\_alert(uuid) Acknowledge Alert Mark an alert as acknowledged. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.alert_schema import AlertSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Acknowledge Alert api_response = api_instance.src_app_api_alerts_acknowledge_alert(uuid) print("The response of DefaultApi->src_app_api_alerts_acknowledge_alert:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_alerts_acknowledge_alert: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**AlertSchema**](/api-reference/rest/AlertSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_alerts\_create\_alert** > AlertSchema src\_app\_api\_alerts\_create\_alert(create\_alert\_schema) Create Alert Create a new alert. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.alert_schema import AlertSchema from cyberwave.rest.models.create_alert_schema import CreateAlertSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) create_alert_schema = cyberwave.rest.CreateAlertSchema() # CreateAlertSchema | try: # Create Alert api_response = api_instance.src_app_api_alerts_create_alert(create_alert_schema) print("The response of DefaultApi->src_app_api_alerts_create_alert:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_alerts_create_alert: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------------- | -------------------------------------------------------------- | ----------- | ----- | | **create\_alert\_schema** | [**CreateAlertSchema**](/api-reference/rest/CreateAlertSchema) | | | ### Return type [**AlertSchema**](/api-reference/rest/AlertSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_alerts\_delete\_alert** > src\_app\_api\_alerts\_delete\_alert(uuid) Delete Alert Delete an alert. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Delete Alert api_instance.src_app_api_alerts_delete_alert(uuid) except Exception as e: print("Exception when calling DefaultApi->src_app_api_alerts_delete_alert: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_alerts\_get\_alert** > AlertSchema src\_app\_api\_alerts\_get\_alert(uuid) Get Alert Get an alert by UUID. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.alert_schema import AlertSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Alert api_response = api_instance.src_app_api_alerts_get_alert(uuid) print("The response of DefaultApi->src_app_api_alerts_get_alert:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_alerts_get_alert: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**AlertSchema**](/api-reference/rest/AlertSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_alerts\_list\_alerts** > List\[AlertSchema] src\_app\_api\_alerts\_list\_alerts(workspace\_uuid=workspace\_uuid, twin\_uuid=twin\_uuid, environment\_uuid=environment\_uuid, status=status, severity=severity, limit=limit) List Alerts List alerts visible to the authenticated user. Filters: * workspace\_uuid: Filter by workspace * twin\_uuid: Filter by twin * environment\_uuid: Filter by environment * status: Filter by status (comma-separated, e.g. "active,acknowledged") * severity: Filter by severity (comma-separated, e.g. "error,critical") * limit: Max results (default 100) ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.alert_schema import AlertSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) workspace_uuid = 'workspace_uuid_example' # str | (optional) twin_uuid = 'twin_uuid_example' # str | (optional) environment_uuid = 'environment_uuid_example' # str | (optional) status = 'status_example' # str | (optional) severity = 'severity_example' # str | (optional) limit = 100 # int | (optional) (default to 100) try: # List Alerts api_response = api_instance.src_app_api_alerts_list_alerts(workspace_uuid=workspace_uuid, twin_uuid=twin_uuid, environment_uuid=environment_uuid, status=status, severity=severity, limit=limit) print("The response of DefaultApi->src_app_api_alerts_list_alerts:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_alerts_list_alerts: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | --------------------- | ------- | ----------- | ----------------------------- | | **workspace\_uuid** | **str** | | \[optional] | | **twin\_uuid** | **str** | | \[optional] | | **environment\_uuid** | **str** | | \[optional] | | **status** | **str** | | \[optional] | | **severity** | **str** | | \[optional] | | **limit** | **int** | | \[optional] \[default to 100] | ### Return type [**List\[AlertSchema\]**](/api-reference/rest/AlertSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_alerts\_resolve\_alert** > AlertSchema src\_app\_api\_alerts\_resolve\_alert(uuid) Resolve Alert Mark an alert as resolved. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.alert_schema import AlertSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Resolve Alert api_response = api_instance.src_app_api_alerts_resolve_alert(uuid) print("The response of DefaultApi->src_app_api_alerts_resolve_alert:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_alerts_resolve_alert: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**AlertSchema**](/api-reference/rest/AlertSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_alerts\_silence\_alert** > AlertSchema src\_app\_api\_alerts\_silence\_alert(uuid) Silence Alert Silence an alert workspace-wide without resolving the root cause. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.alert_schema import AlertSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Silence Alert api_response = api_instance.src_app_api_alerts_silence_alert(uuid) print("The response of DefaultApi->src_app_api_alerts_silence_alert:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_alerts_silence_alert: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**AlertSchema**](/api-reference/rest/AlertSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_alerts\_update\_alert** > AlertSchema src\_app\_api\_alerts\_update\_alert(uuid, update\_alert\_schema) Update Alert Update an alert's mutable fields. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.alert_schema import AlertSchema from cyberwave.rest.models.update_alert_schema import UpdateAlertSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | update_alert_schema = cyberwave.rest.UpdateAlertSchema() # UpdateAlertSchema | try: # Update Alert api_response = api_instance.src_app_api_alerts_update_alert(uuid, update_alert_schema) print("The response of DefaultApi->src_app_api_alerts_update_alert:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_alerts_update_alert: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------------- | -------------------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **update\_alert\_schema** | [**UpdateAlertSchema**](/api-reference/rest/UpdateAlertSchema) | | | ### Return type [**AlertSchema**](/api-reference/rest/AlertSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_assets\_check\_registry\_id\_availability** > src\_app\_api\_assets\_check\_registry\_id\_availability(registry\_id) Check Registry Id Availability Check if a registry\_id is available for use. Returns: - available: True if the registry\_id is not in use - registry\_id: The normalized registry\_id - suggestion: If not available, suggests an alternative ### Example ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) registry_id = 'registry_id_example' # str | try: # Check Registry Id Availability api_instance.src_app_api_assets_check_registry_id_availability(registry_id) except Exception as e: print("Exception when calling DefaultApi->src_app_api_assets_check_registry_id_availability: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ---------------- | ------- | ----------- | ----- | | **registry\_id** | **str** | | | ### Return type void (empty response body) ### Authorization No authorization required ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_assets\_complete\_large\_glb\_upload** > AssetSchema src\_app\_api\_assets\_complete\_large\_glb\_upload(uuid, complete\_large\_upload\_schema) Complete Large Glb Upload Complete a large GLB file upload for an asset. This moves the uploaded file to the asset's GLB field. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.asset_schema import AssetSchema from cyberwave.rest.models.complete_large_upload_schema import CompleteLargeUploadSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | complete_large_upload_schema = cyberwave.rest.CompleteLargeUploadSchema() # CompleteLargeUploadSchema | try: # Complete Large Glb Upload api_response = api_instance.src_app_api_assets_complete_large_glb_upload(uuid, complete_large_upload_schema) print("The response of DefaultApi->src_app_api_assets_complete_large_glb_upload:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_assets_complete_large_glb_upload: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ----------------------------------- | ------------------------------------------------------------------------------ | ----------- | ----- | | **uuid** | **str** | | | | **complete\_large\_upload\_schema** | [**CompleteLargeUploadSchema**](/api-reference/rest/CompleteLargeUploadSchema) | | | ### Return type [**AssetSchema**](/api-reference/rest/AssetSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_assets\_create\_asset** > AssetSchema src\_app\_api\_assets\_create\_asset(asset\_create\_schema) Create Asset ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.asset_create_schema import AssetCreateSchema from cyberwave.rest.models.asset_schema import AssetSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) asset_create_schema = cyberwave.rest.AssetCreateSchema() # AssetCreateSchema | try: # Create Asset api_response = api_instance.src_app_api_assets_create_asset(asset_create_schema) print("The response of DefaultApi->src_app_api_assets_create_asset:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_assets_create_asset: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------------- | -------------------------------------------------------------- | ----------- | ----- | | **asset\_create\_schema** | [**AssetCreateSchema**](/api-reference/rest/AssetCreateSchema) | | | ### Return type [**AssetSchema**](/api-reference/rest/AssetSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_assets\_create\_asset\_from\_prompt\_or\_image** > DeferredTaskExecutionResponseSchema src\_app\_api\_assets\_create\_asset\_from\_prompt\_or\_image(asset\_name, prompt=prompt, image\_url=image\_url, image\_bytes=image\_bytes, description=description, workspace\_uuid=workspace\_uuid, visibility=visibility) Create Asset From Prompt Or Image Create a mesh from a text prompt (and optionally an image). ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.deferred_task_execution_response_schema import DeferredTaskExecutionResponseSchema from cyberwave.rest.models.image_bytes import ImageBytes from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) asset_name = 'asset_name_example' # str | prompt = 'prompt_example' # str | (optional) image_url = 'image_url_example' # str | (optional) image_bytes = cyberwave.rest.ImageBytes() # ImageBytes | (optional) description = 'description_example' # str | (optional) workspace_uuid = 'workspace_uuid_example' # str | (optional) visibility = 'private' # str | (optional) (default to 'private') try: # Create Asset From Prompt Or Image api_response = api_instance.src_app_api_assets_create_asset_from_prompt_or_image(asset_name, prompt=prompt, image_url=image_url, image_bytes=image_bytes, description=description, workspace_uuid=workspace_uuid, visibility=visibility) print("The response of DefaultApi->src_app_api_assets_create_asset_from_prompt_or_image:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_assets_create_asset_from_prompt_or_image: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------- | ------------------------------------------------ | ----------- | ----------------------------------- | | **asset\_name** | **str** | | | | **prompt** | **str** | | \[optional] | | **image\_url** | **str** | | \[optional] | | **image\_bytes** | [**ImageBytes**](/api-reference/rest/ImageBytes) | | \[optional] | | **description** | **str** | | \[optional] | | **workspace\_uuid** | **str** | | \[optional] | | **visibility** | **str** | | \[optional] \[default to 'private'] | ### Return type [**DeferredTaskExecutionResponseSchema**](/api-reference/rest/DeferredTaskExecutionResponseSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/x-www-form-urlencoded * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_assets\_create\_asset\_with\_urdf** > src\_app\_api\_assets\_create\_asset\_with\_urdf(asset\_create\_with\_urdf\_schema) Create Asset With Urdf ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.asset_create_with_urdf_schema import AssetCreateWithURDFSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) asset_create_with_urdf_schema = cyberwave.rest.AssetCreateWithURDFSchema() # AssetCreateWithURDFSchema | try: # Create Asset With Urdf api_instance.src_app_api_assets_create_asset_with_urdf(asset_create_with_urdf_schema) except Exception as e: print("Exception when calling DefaultApi->src_app_api_assets_create_asset_with_urdf: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------------------------- | ------------------------------------------------------------------------------ | ----------- | ----- | | **asset\_create\_with\_urdf\_schema** | [**AssetCreateWithURDFSchema**](/api-reference/rest/AssetCreateWithURDFSchema) | | | ### Return type void (empty response body) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_assets\_delete\_asset** > src\_app\_api\_assets\_delete\_asset(uuid) Delete Asset ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Delete Asset api_instance.src_app_api_assets_delete_asset(uuid) except Exception as e: print("Exception when calling DefaultApi->src_app_api_assets_delete_asset: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_assets\_export\_asset** > src\_app\_api\_assets\_export\_asset(uuid) Export Asset Export an asset as a .cbw package (zip file). The .cbw package contains all asset data including: * Asset metadata, capabilities, and kinematics * GLB visualization file (if present) * Thumbnail (if present) * URDF project files (if present) * Attachments (if present) This endpoint supports both authenticated and anonymous access for public assets. ### Example ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Export Asset api_instance.src_app_api_assets_export_asset(uuid) except Exception as e: print("Exception when calling DefaultApi->src_app_api_assets_export_asset: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization No authorization required ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_assets\_get\_asset** > AssetSchema src\_app\_api\_assets\_get\_asset(uuid) Get Asset Get an asset by UUID or registry\_id. Supports both authenticated and anonymous access (for public assets). ### Example ```python theme={null} import cyberwave.rest from cyberwave.rest.models.asset_schema import AssetSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Asset api_response = api_instance.src_app_api_assets_get_asset(uuid) print("The response of DefaultApi->src_app_api_assets_get_asset:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_assets_get_asset: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**AssetSchema**](/api-reference/rest/AssetSchema) ### Authorization No authorization required ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_assets\_get\_asset\_controllers** > List\[ControllerPolicySchema] src\_app\_api\_assets\_get\_asset\_controllers(uuid) Get Asset Controllers ### Example ```python theme={null} import cyberwave.rest from cyberwave.rest.models.controller_policy_schema import ControllerPolicySchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Asset Controllers api_response = api_instance.src_app_api_assets_get_asset_controllers(uuid) print("The response of DefaultApi->src_app_api_assets_get_asset_controllers:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_assets_get_asset_controllers: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**List\[ControllerPolicySchema\]**](/api-reference/rest/ControllerPolicySchema) ### Authorization No authorization required ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_assets\_get\_asset\_kinematics** > Dict\[str, object] src\_app\_api\_assets\_get\_asset\_kinematics(uuid) Get Asset Kinematics Get asset kinematics by UUID or registry\_id. Supports both authenticated and anonymous access (for public assets). ### Example ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Asset Kinematics api_response = api_instance.src_app_api_assets_get_asset_kinematics(uuid) print("The response of DefaultApi->src_app_api_assets_get_asset_kinematics:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_assets_get_asset_kinematics: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type **Dict\[str, object]** ### Authorization No authorization required ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_assets\_get\_asset\_universal\_schema** > Dict\[str, object] src\_app\_api\_assets\_get\_asset\_universal\_schema(uuid) Get Asset Universal Schema Get the asset's universal schema as JSON (for download). Supports both authenticated and anonymous access (for public assets). ### Example ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Asset Universal Schema api_response = api_instance.src_app_api_assets_get_asset_universal_schema(uuid) print("The response of DefaultApi->src_app_api_assets_get_asset_universal_schema:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_assets_get_asset_universal_schema: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type **Dict\[str, object]** ### Authorization No authorization required ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_assets\_get\_asset\_universal\_schema\_at\_path** > Dict\[str, object] src\_app\_api\_assets\_get\_asset\_universal\_schema\_at\_path(uuid, path=path) Get Asset Universal Schema At Path Get value at a specific JSON Pointer path in the asset's universal schema. Supports both authenticated and anonymous access (for public assets). Query params: path: JSON Pointer path (e.g., /sensors/0, /extensions/cyberwave/capabilities) Returns: `{"path": "...", "value": }` ### Example ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | path = '' # str | (optional) (default to '') try: # Get Asset Universal Schema At Path api_response = api_instance.src_app_api_assets_get_asset_universal_schema_at_path(uuid, path=path) print("The response of DefaultApi->src_app_api_assets_get_asset_universal_schema_at_path:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_assets_get_asset_universal_schema_at_path: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ---------------------------- | | **uuid** | **str** | | | | **path** | **str** | | \[optional] \[default to ''] | ### Return type **Dict\[str, object]** ### Authorization No authorization required ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_assets\_get\_popular\_tags** > PopularTagsResponseSchema src\_app\_api\_assets\_get\_popular\_tags() Get Popular Tags Get the most popular tags from asset metadata. Results are cached for 1 hour for performance. ### Example ```python theme={null} import cyberwave.rest from cyberwave.rest.models.popular_tags_response_schema import PopularTagsResponseSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) try: # Get Popular Tags api_response = api_instance.src_app_api_assets_get_popular_tags() print("The response of DefaultApi->src_app_api_assets_get_popular_tags:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_assets_get_popular_tags: %s\n" % e) ``` ### Parameters This endpoint does not need any parameter. ### Return type [**PopularTagsResponseSchema**](/api-reference/rest/PopularTagsResponseSchema) ### Authorization No authorization required ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_assets\_get\_public\_vendors** > List\[Optional\[str]] src\_app\_api\_assets\_get\_public\_vendors() Get Public Vendors Get the list of vendors that have public assets. Used by frontend to whitelist vendor pages for unauthenticated access. Results are cached for 1 hour for performance. ### Example ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) try: # Get Public Vendors api_response = api_instance.src_app_api_assets_get_public_vendors() print("The response of DefaultApi->src_app_api_assets_get_public_vendors:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_assets_get_public_vendors: %s\n" % e) ``` ### Parameters This endpoint does not need any parameter. ### Return type **List\[Optional\[str]]** ### Authorization No authorization required ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_assets\_import\_asset\_package** > AssetSchema src\_app\_api\_assets\_import\_asset\_package(file, workspace\_uuid=workspace\_uuid, custom\_registry\_id=custom\_registry\_id) Import Asset Package Import an asset from a .cbw package file. The .cbw package should be a zip file created by the export endpoint, containing manifest.json, asset.json, and associated files. This allows transferring assets between Cyberwave instances. Parameters: file: The .cbw file to import workspace\_uuid: Optional target workspace UUID. If not provided, uses user's first workspace. custom\_registry\_id: Optional custom registry ID for the imported asset. If not provided, uses the original registry\_id from the package. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.asset_schema import AssetSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) file = None # bytearray | workspace_uuid = 'workspace_uuid_example' # str | (optional) custom_registry_id = 'custom_registry_id_example' # str | (optional) try: # Import Asset Package api_response = api_instance.src_app_api_assets_import_asset_package(file, workspace_uuid=workspace_uuid, custom_registry_id=custom_registry_id) print("The response of DefaultApi->src_app_api_assets_import_asset_package:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_assets_import_asset_package: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------------ | ------------- | ----------- | ----------- | | **file** | **bytearray** | | | | **workspace\_uuid** | **str** | | \[optional] | | **custom\_registry\_id** | **str** | | \[optional] | ### Return type [**AssetSchema**](/api-reference/rest/AssetSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: multipart/form-data * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_assets\_import\_catalog\_asset** > AssetSchema src\_app\_api\_assets\_import\_catalog\_asset(asset\_catalog\_import\_schema) Import Catalog Asset ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.asset_catalog_import_schema import AssetCatalogImportSchema from cyberwave.rest.models.asset_schema import AssetSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) asset_catalog_import_schema = cyberwave.rest.AssetCatalogImportSchema() # AssetCatalogImportSchema | try: # Import Catalog Asset api_response = api_instance.src_app_api_assets_import_catalog_asset(asset_catalog_import_schema) print("The response of DefaultApi->src_app_api_assets_import_catalog_asset:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_assets_import_catalog_asset: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ---------------------------------- | ---------------------------------------------------------------------------- | ----------- | ----- | | **asset\_catalog\_import\_schema** | [**AssetCatalogImportSchema**](/api-reference/rest/AssetCatalogImportSchema) | | | ### Return type [**AssetSchema**](/api-reference/rest/AssetSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_assets\_initiate\_large\_glb\_upload** > InitiateLargeUploadResponse src\_app\_api\_assets\_initiate\_large\_glb\_upload(uuid, initiate\_large\_upload\_schema) Initiate Large Glb Upload Initiate a large GLB file upload for an asset using Google Cloud signed URLs. This endpoint supports GLB files larger than 32MB. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.initiate_large_upload_response import InitiateLargeUploadResponse from cyberwave.rest.models.initiate_large_upload_schema import InitiateLargeUploadSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | initiate_large_upload_schema = cyberwave.rest.InitiateLargeUploadSchema() # InitiateLargeUploadSchema | try: # Initiate Large Glb Upload api_response = api_instance.src_app_api_assets_initiate_large_glb_upload(uuid, initiate_large_upload_schema) print("The response of DefaultApi->src_app_api_assets_initiate_large_glb_upload:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_assets_initiate_large_glb_upload: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ----------------------------------- | ------------------------------------------------------------------------------ | ----------- | ----- | | **uuid** | **str** | | | | **initiate\_large\_upload\_schema** | [**InitiateLargeUploadSchema**](/api-reference/rest/InitiateLargeUploadSchema) | | | ### Return type [**InitiateLargeUploadResponse**](/api-reference/rest/InitiateLargeUploadResponse) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_assets\_list\_assets** > List\[AssetListSchema] src\_app\_api\_assets\_list\_assets() List Assets ### Example ```python theme={null} import cyberwave.rest from cyberwave.rest.models.asset_list_schema import AssetListSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) try: # List Assets api_response = api_instance.src_app_api_assets_list_assets() print("The response of DefaultApi->src_app_api_assets_list_assets:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_assets_list_assets: %s\n" % e) ``` ### Parameters This endpoint does not need any parameter. ### Return type [**List\[AssetListSchema\]**](/api-reference/rest/AssetListSchema) ### Authorization No authorization required ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_assets\_llm\_generation** > LLMResponseSchema src\_app\_api\_assets\_llm\_generation(uuid, llm\_generation\_schema) Llm Generation ### Example ```python theme={null} import cyberwave.rest from cyberwave.rest.models.llm_generation_schema import LLMGenerationSchema from cyberwave.rest.models.llm_response_schema import LLMResponseSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | llm_generation_schema = cyberwave.rest.LLMGenerationSchema() # LLMGenerationSchema | try: # Llm Generation api_response = api_instance.src_app_api_assets_llm_generation(uuid, llm_generation_schema) print("The response of DefaultApi->src_app_api_assets_llm_generation:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_assets_llm_generation: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | --------------------------- | ------------------------------------------------------------------ | ----------- | ----- | | **uuid** | **str** | | | | **llm\_generation\_schema** | [**LLMGenerationSchema**](/api-reference/rest/LLMGenerationSchema) | | | ### Return type [**LLMResponseSchema**](/api-reference/rest/LLMResponseSchema) ### Authorization No authorization required ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_assets\_patch\_asset\_universal\_schema** > Dict\[str, object] src\_app\_api\_assets\_patch\_asset\_universal\_schema(uuid, universal\_schema\_patch\_schema) Patch Asset Universal Schema Update the asset's universal schema using JSON Pointer operations. This allows editing the asset schema, including: * /sensors (array of sensor objects) * /extensions/cyberwave/capabilities * /links, /joints, /actuators, etc. When capabilities are patched, they are validated using CapabilitiesValidator. Body: ```json theme={null} { "op": "add" | "replace", "path": "/sensors/0/parameters/id", "value": "my_camera" } ``` Returns: ```json theme={null} { "schema": "", "updated": { "op": "...", "path": "..." } } ``` ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.universal_schema_patch_schema import UniversalSchemaPatchSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | universal_schema_patch_schema = cyberwave.rest.UniversalSchemaPatchSchema() # UniversalSchemaPatchSchema | try: # Patch Asset Universal Schema api_response = api_instance.src_app_api_assets_patch_asset_universal_schema(uuid, universal_schema_patch_schema) print("The response of DefaultApi->src_app_api_assets_patch_asset_universal_schema:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_assets_patch_asset_universal_schema: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------------------------ | -------------------------------------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **universal\_schema\_patch\_schema** | [**UniversalSchemaPatchSchema**](/api-reference/rest/UniversalSchemaPatchSchema) | | | ### Return type **Dict\[str, object]** ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_assets\_rebuild\_asset\_universal\_schema** > Dict\[str, object] src\_app\_api\_assets\_rebuild\_asset\_universal\_schema(uuid, sync=sync) Rebuild Asset Universal Schema Trigger regeneration of an Asset's universal\_schema from its URDFProject. By default, queues a Celery task and returns immediately. Pass `?sync=true` to execute synchronously and block until complete (useful for local testing). Returns: ``` { "queued": bool, "asset_uuid": "...", "urdf_project_uuid": "...", } ``` ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | sync = False # bool | (optional) (default to False) try: # Rebuild Asset Universal Schema api_response = api_instance.src_app_api_assets_rebuild_asset_universal_schema(uuid, sync=sync) print("The response of DefaultApi->src_app_api_assets_rebuild_asset_universal_schema:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_assets_rebuild_asset_universal_schema: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | -------- | ----------- | ------------------------------- | | **uuid** | **str** | | | | **sync** | **bool** | | \[optional] \[default to False] | ### Return type **Dict\[str, object]** ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_assets\_set\_glb\_from\_attachment** > AssetSchema src\_app\_api\_assets\_set\_glb\_from\_attachment(uuid, asset\_glb\_from\_attachment\_schema) Set Glb From Attachment Set an asset's GLB file from an existing attachment. This is useful for processing workflows where an uploaded attachment gets converted/processed into the main GLB visualization file. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.asset_glb_from_attachment_schema import AssetGLBFromAttachmentSchema from cyberwave.rest.models.asset_schema import AssetSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | asset_glb_from_attachment_schema = cyberwave.rest.AssetGLBFromAttachmentSchema() # AssetGLBFromAttachmentSchema | try: # Set Glb From Attachment api_response = api_instance.src_app_api_assets_set_glb_from_attachment(uuid, asset_glb_from_attachment_schema) print("The response of DefaultApi->src_app_api_assets_set_glb_from_attachment:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_assets_set_glb_from_attachment: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ---------------------------------------- | ------------------------------------------------------------------------------------ | ----------- | ----- | | **uuid** | **str** | | | | **asset\_glb\_from\_attachment\_schema** | [**AssetGLBFromAttachmentSchema**](/api-reference/rest/AssetGLBFromAttachmentSchema) | | | ### Return type [**AssetSchema**](/api-reference/rest/AssetSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_assets\_update\_asset** > AssetSchema src\_app\_api\_assets\_update\_asset(uuid, asset\_update\_schema) Update Asset Update an asset by UUID or registry\_id. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.asset_schema import AssetSchema from cyberwave.rest.models.asset_update_schema import AssetUpdateSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | asset_update_schema = cyberwave.rest.AssetUpdateSchema() # AssetUpdateSchema | try: # Update Asset api_response = api_instance.src_app_api_assets_update_asset(uuid, asset_update_schema) print("The response of DefaultApi->src_app_api_assets_update_asset:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_assets_update_asset: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------------- | -------------------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **asset\_update\_schema** | [**AssetUpdateSchema**](/api-reference/rest/AssetUpdateSchema) | | | ### Return type [**AssetSchema**](/api-reference/rest/AssetSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_assets\_upload\_glb** > AssetSchema src\_app\_api\_assets\_upload\_glb(uuid, file) Upload Glb ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.asset_schema import AssetSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | file = None # bytearray | try: # Upload Glb api_response = api_instance.src_app_api_assets_upload_glb(uuid, file) print("The response of DefaultApi->src_app_api_assets_upload_glb:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_assets_upload_glb: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------------- | ----------- | ----- | | **uuid** | **str** | | | | **file** | **bytearray** | | | ### Return type [**AssetSchema**](/api-reference/rest/AssetSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: multipart/form-data * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_assets\_upload\_thumbnail\_file** > AssetSchema src\_app\_api\_assets\_upload\_thumbnail\_file(uuid, file) Upload Thumbnail File ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.asset_schema import AssetSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | file = None # bytearray | try: # Upload Thumbnail File api_response = api_instance.src_app_api_assets_upload_thumbnail_file(uuid, file) print("The response of DefaultApi->src_app_api_assets_upload_thumbnail_file:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_assets_upload_thumbnail_file: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------------- | ----------- | ----- | | **uuid** | **str** | | | | **file** | **bytearray** | | | ### Return type [**AssetSchema**](/api-reference/rest/AssetSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: multipart/form-data * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_assets\_vlm\_generation** > VLMResponseSchema src\_app\_api\_assets\_vlm\_generation(uuid, vlm\_generation\_schema) Vlm Generation Generate a response using a Vision Language Model (VLM) with the given prompt and image. This endpoint uses Google's Gemini 3 Pro vision model to analyze images and generate text responses based on the provided prompt. Args: request: The HTTP request uuid: The asset UUID (currently unused but kept for API consistency) payload: Contains the prompt and image\_url to analyze Returns: VLMResponseSchema with the model's text response ### Example ```python theme={null} import cyberwave.rest from cyberwave.rest.models.vlm_generation_schema import VLMGenerationSchema from cyberwave.rest.models.vlm_response_schema import VLMResponseSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | vlm_generation_schema = cyberwave.rest.VLMGenerationSchema() # VLMGenerationSchema | try: # Vlm Generation api_response = api_instance.src_app_api_assets_vlm_generation(uuid, vlm_generation_schema) print("The response of DefaultApi->src_app_api_assets_vlm_generation:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_assets_vlm_generation: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | --------------------------- | ------------------------------------------------------------------ | ----------- | ----- | | **uuid** | **str** | | | | **vlm\_generation\_schema** | [**VLMGenerationSchema**](/api-reference/rest/VLMGenerationSchema) | | | ### Return type [**VLMResponseSchema**](/api-reference/rest/VLMResponseSchema) ### Authorization No authorization required ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_attachments\_complete\_large\_attachment\_upload** > AttachmentSchema src\_app\_api\_attachments\_complete\_large\_attachment\_upload(uuid, complete\_large\_upload\_schema) Complete Large Attachment Upload Complete a large file upload for an attachment. This marks the uploaded file as the attachment's file. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.attachment_schema import AttachmentSchema from cyberwave.rest.models.complete_large_upload_schema import CompleteLargeUploadSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | complete_large_upload_schema = cyberwave.rest.CompleteLargeUploadSchema() # CompleteLargeUploadSchema | try: # Complete Large Attachment Upload api_response = api_instance.src_app_api_attachments_complete_large_attachment_upload(uuid, complete_large_upload_schema) print("The response of DefaultApi->src_app_api_attachments_complete_large_attachment_upload:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_attachments_complete_large_attachment_upload: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ----------------------------------- | ------------------------------------------------------------------------------ | ----------- | ----- | | **uuid** | **str** | | | | **complete\_large\_upload\_schema** | [**CompleteLargeUploadSchema**](/api-reference/rest/CompleteLargeUploadSchema) | | | ### Return type [**AttachmentSchema**](/api-reference/rest/AttachmentSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_attachments\_create\_attachment** > AttachmentSchema src\_app\_api\_attachments\_create\_attachment(attachment\_create\_schema) Create Attachment ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.attachment_create_schema import AttachmentCreateSchema from cyberwave.rest.models.attachment_schema import AttachmentSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) attachment_create_schema = cyberwave.rest.AttachmentCreateSchema() # AttachmentCreateSchema | try: # Create Attachment api_response = api_instance.src_app_api_attachments_create_attachment(attachment_create_schema) print("The response of DefaultApi->src_app_api_attachments_create_attachment:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_attachments_create_attachment: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------------------ | ------------------------------------------------------------------------ | ----------- | ----- | | **attachment\_create\_schema** | [**AttachmentCreateSchema**](/api-reference/rest/AttachmentCreateSchema) | | | ### Return type [**AttachmentSchema**](/api-reference/rest/AttachmentSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_attachments\_delete\_attachment** > src\_app\_api\_attachments\_delete\_attachment(uuid) Delete Attachment ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Delete Attachment api_instance.src_app_api_attachments_delete_attachment(uuid) except Exception as e: print("Exception when calling DefaultApi->src_app_api_attachments_delete_attachment: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_attachments\_download\_attachment** > src\_app\_api\_attachments\_download\_attachment(uuid) Download Attachment Download attachment file content. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Download Attachment api_instance.src_app_api_attachments_download_attachment(uuid) except Exception as e: print("Exception when calling DefaultApi->src_app_api_attachments_download_attachment: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_attachments\_get\_attachment** > AttachmentSchema src\_app\_api\_attachments\_get\_attachment(uuid) Get Attachment ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.attachment_schema import AttachmentSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Attachment api_response = api_instance.src_app_api_attachments_get_attachment(uuid) print("The response of DefaultApi->src_app_api_attachments_get_attachment:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_attachments_get_attachment: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**AttachmentSchema**](/api-reference/rest/AttachmentSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_attachments\_initiate\_large\_attachment\_upload** > InitiateLargeUploadResponse src\_app\_api\_attachments\_initiate\_large\_attachment\_upload(uuid, initiate\_large\_upload\_schema) Initiate Large Attachment Upload Initiate a large file upload for an attachment using Google Cloud signed URLs. This endpoint supports files larger than 32MB. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.initiate_large_upload_response import InitiateLargeUploadResponse from cyberwave.rest.models.initiate_large_upload_schema import InitiateLargeUploadSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | initiate_large_upload_schema = cyberwave.rest.InitiateLargeUploadSchema() # InitiateLargeUploadSchema | try: # Initiate Large Attachment Upload api_response = api_instance.src_app_api_attachments_initiate_large_attachment_upload(uuid, initiate_large_upload_schema) print("The response of DefaultApi->src_app_api_attachments_initiate_large_attachment_upload:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_attachments_initiate_large_attachment_upload: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ----------------------------------- | ------------------------------------------------------------------------------ | ----------- | ----- | | **uuid** | **str** | | | | **initiate\_large\_upload\_schema** | [**InitiateLargeUploadSchema**](/api-reference/rest/InitiateLargeUploadSchema) | | | ### Return type [**InitiateLargeUploadResponse**](/api-reference/rest/InitiateLargeUploadResponse) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_attachments\_list\_attachments** > List\[AttachmentSchema] src\_app\_api\_attachments\_list\_attachments() List Attachments ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.attachment_schema import AttachmentSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) try: # List Attachments api_response = api_instance.src_app_api_attachments_list_attachments() print("The response of DefaultApi->src_app_api_attachments_list_attachments:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_attachments_list_attachments: %s\n" % e) ``` ### Parameters This endpoint does not need any parameter. ### Return type [**List\[AttachmentSchema\]**](/api-reference/rest/AttachmentSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_attachments\_update\_attachment** > AttachmentSchema src\_app\_api\_attachments\_update\_attachment(uuid, attachment\_create\_schema) Update Attachment ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.attachment_create_schema import AttachmentCreateSchema from cyberwave.rest.models.attachment_schema import AttachmentSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | attachment_create_schema = cyberwave.rest.AttachmentCreateSchema() # AttachmentCreateSchema | try: # Update Attachment api_response = api_instance.src_app_api_attachments_update_attachment(uuid, attachment_create_schema) print("The response of DefaultApi->src_app_api_attachments_update_attachment:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_attachments_update_attachment: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------------------ | ------------------------------------------------------------------------ | ----------- | ----- | | **uuid** | **str** | | | | **attachment\_create\_schema** | [**AttachmentCreateSchema**](/api-reference/rest/AttachmentCreateSchema) | | | ### Return type [**AttachmentSchema**](/api-reference/rest/AttachmentSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_attachments\_upload\_attachment** > AttachmentSchema src\_app\_api\_attachments\_upload\_attachment(uuid, file) Upload Attachment ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.attachment_schema import AttachmentSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | file = None # bytearray | try: # Upload Attachment api_response = api_instance.src_app_api_attachments_upload_attachment(uuid, file) print("The response of DefaultApi->src_app_api_attachments_upload_attachment:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_attachments_upload_attachment: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------------- | ----------- | ----- | | **uuid** | **str** | | | | **file** | **bytearray** | | | ### Return type [**AttachmentSchema**](/api-reference/rest/AttachmentSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: multipart/form-data * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_controller\_policies\_clone\_controller\_policy** > ControllerPolicySchema src\_app\_api\_controller\_policies\_clone\_controller\_policy(uuid, workspace\_uuid=workspace\_uuid) Clone Controller Policy Clone a controller policy into the specified workspace (or user's default workspace). ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.controller_policy_schema import ControllerPolicySchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | workspace_uuid = 'workspace_uuid_example' # str | (optional) try: # Clone Controller Policy api_response = api_instance.src_app_api_controller_policies_clone_controller_policy(uuid, workspace_uuid=workspace_uuid) print("The response of DefaultApi->src_app_api_controller_policies_clone_controller_policy:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_controller_policies_clone_controller_policy: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------- | ------- | ----------- | ----------- | | **uuid** | **str** | | | | **workspace\_uuid** | **str** | | \[optional] | ### Return type [**ControllerPolicySchema**](/api-reference/rest/ControllerPolicySchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_controller\_policies\_create\_controller\_policy** > ControllerPolicySchema src\_app\_api\_controller\_policies\_create\_controller\_policy(controller\_policy\_create\_schema) Create Controller Policy Create a new controller policy. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.controller_policy_create_schema import ControllerPolicyCreateSchema from cyberwave.rest.models.controller_policy_schema import ControllerPolicySchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) controller_policy_create_schema = cyberwave.rest.ControllerPolicyCreateSchema() # ControllerPolicyCreateSchema | try: # Create Controller Policy api_response = api_instance.src_app_api_controller_policies_create_controller_policy(controller_policy_create_schema) print("The response of DefaultApi->src_app_api_controller_policies_create_controller_policy:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_controller_policies_create_controller_policy: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------------------------------------- | ------------------------------------------------------------------------------------ | ----------- | ----- | | **controller\_policy\_create\_schema** | [**ControllerPolicyCreateSchema**](/api-reference/rest/ControllerPolicyCreateSchema) | | | ### Return type [**ControllerPolicySchema**](/api-reference/rest/ControllerPolicySchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_controller\_policies\_delete\_controller\_policy** > Dict\[str, Optional\[bool]] src\_app\_api\_controller\_policies\_delete\_controller\_policy(uuid) Delete Controller Policy Delete a controller policy. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Delete Controller Policy api_response = api_instance.src_app_api_controller_policies_delete_controller_policy(uuid) print("The response of DefaultApi->src_app_api_controller_policies_delete_controller_policy:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_controller_policies_delete_controller_policy: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type **Dict\[str, Optional\[bool]]** ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_controller\_policies\_execute\_controller\_policy** > ControllerPolicyExecuteResponseSchema src\_app\_api\_controller\_policies\_execute\_controller\_policy(uuid, controller\_policy\_execute\_schema) Execute Controller Policy ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.controller_policy_execute_response_schema import ControllerPolicyExecuteResponseSchema from cyberwave.rest.models.controller_policy_execute_schema import ControllerPolicyExecuteSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | controller_policy_execute_schema = cyberwave.rest.ControllerPolicyExecuteSchema() # ControllerPolicyExecuteSchema | try: # Execute Controller Policy api_response = api_instance.src_app_api_controller_policies_execute_controller_policy(uuid, controller_policy_execute_schema) print("The response of DefaultApi->src_app_api_controller_policies_execute_controller_policy:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_controller_policies_execute_controller_policy: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | --------------------------------------- | -------------------------------------------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **controller\_policy\_execute\_schema** | [**ControllerPolicyExecuteSchema**](/api-reference/rest/ControllerPolicyExecuteSchema) | | | ### Return type [**ControllerPolicyExecuteResponseSchema**](/api-reference/rest/ControllerPolicyExecuteResponseSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_controller\_policies\_get\_action\_from\_policy** > str src\_app\_api\_controller\_policies\_get\_action\_from\_policy(uuid, instruction, twin\_uuid, camera\_twin\_uuid) Get Action From Policy Get action from an ML model policy based on instruction and twin state. Validates that the twins exist and the camera is live, then dispatches the actual execution to a Celery worker. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | instruction = 'instruction_example' # str | twin_uuid = 'twin_uuid_example' # str | camera_twin_uuid = 'camera_twin_uuid_example' # str | try: # Get Action From Policy api_response = api_instance.src_app_api_controller_policies_get_action_from_policy(uuid, instruction, twin_uuid, camera_twin_uuid) print("The response of DefaultApi->src_app_api_controller_policies_get_action_from_policy:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_controller_policies_get_action_from_policy: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ---------------------- | ------- | ----------- | ----- | | **uuid** | **str** | | | | **instruction** | **str** | | | | **twin\_uuid** | **str** | | | | **camera\_twin\_uuid** | **str** | | | ### Return type **str** ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_controller\_policies\_get\_controller\_policy** > ControllerPolicySchema src\_app\_api\_controller\_policies\_get\_controller\_policy(uuid) Get Controller Policy Get a specific controller policy by UUID. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.controller_policy_schema import ControllerPolicySchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Controller Policy api_response = api_instance.src_app_api_controller_policies_get_controller_policy(uuid) print("The response of DefaultApi->src_app_api_controller_policies_get_controller_policy:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_controller_policies_get_controller_policy: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**ControllerPolicySchema**](/api-reference/rest/ControllerPolicySchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_controller\_policies\_list\_controller\_policies** > List\[ControllerPolicySchema] src\_app\_api\_controller\_policies\_list\_controller\_policies(asset\_uuid=asset\_uuid, workspace\_uuid=workspace\_uuid) List Controller Policies List all controller policies visible to the authenticated user, optionally filtered by asset and workspace. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.controller_policy_schema import ControllerPolicySchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) asset_uuid = 'asset_uuid_example' # str | (optional) workspace_uuid = 'workspace_uuid_example' # str | (optional) try: # List Controller Policies api_response = api_instance.src_app_api_controller_policies_list_controller_policies(asset_uuid=asset_uuid, workspace_uuid=workspace_uuid) print("The response of DefaultApi->src_app_api_controller_policies_list_controller_policies:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_controller_policies_list_controller_policies: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------- | ------- | ----------- | ----------- | | **asset\_uuid** | **str** | | \[optional] | | **workspace\_uuid** | **str** | | \[optional] | ### Return type [**List\[ControllerPolicySchema\]**](/api-reference/rest/ControllerPolicySchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_controller\_policies\_update\_controller\_policy** > ControllerPolicySchema src\_app\_api\_controller\_policies\_update\_controller\_policy(uuid, controller\_policy\_update\_schema) Update Controller Policy Update an existing controller policy. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.controller_policy_schema import ControllerPolicySchema from cyberwave.rest.models.controller_policy_update_schema import ControllerPolicyUpdateSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | controller_policy_update_schema = cyberwave.rest.ControllerPolicyUpdateSchema() # ControllerPolicyUpdateSchema | try: # Update Controller Policy api_response = api_instance.src_app_api_controller_policies_update_controller_policy(uuid, controller_policy_update_schema) print("The response of DefaultApi->src_app_api_controller_policies_update_controller_policy:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_controller_policies_update_controller_policy: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------------------------------------- | ------------------------------------------------------------------------------------ | ----------- | ----- | | **uuid** | **str** | | | | **controller\_policy\_update\_schema** | [**ControllerPolicyUpdateSchema**](/api-reference/rest/ControllerPolicyUpdateSchema) | | | ### Return type [**ControllerPolicySchema**](/api-reference/rest/ControllerPolicySchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_datasets\_create\_dataset** > Dict\[str, object] src\_app\_api\_datasets\_create\_dataset(dataset\_create\_schema) Create Dataset Create a new dataset. This starts an async task to generate the parquet file. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.dataset_create_schema import DatasetCreateSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) dataset_create_schema = cyberwave.rest.DatasetCreateSchema() # DatasetCreateSchema | try: # Create Dataset api_response = api_instance.src_app_api_datasets_create_dataset(dataset_create_schema) print("The response of DefaultApi->src_app_api_datasets_create_dataset:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_datasets_create_dataset: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | --------------------------- | ------------------------------------------------------------------ | ----------- | ----- | | **dataset\_create\_schema** | [**DatasetCreateSchema**](/api-reference/rest/DatasetCreateSchema) | | | ### Return type **Dict\[str, object]** ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_datasets\_delete\_dataset** > Dict\[str, Optional\[bool]] src\_app\_api\_datasets\_delete\_dataset(uuid) Delete Dataset Soft delete a dataset by setting is\_deleted=True. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Delete Dataset api_response = api_instance.src_app_api_datasets_delete_dataset(uuid) print("The response of DefaultApi->src_app_api_datasets_delete_dataset:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_datasets_delete_dataset: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type **Dict\[str, Optional\[bool]]** ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_datasets\_get\_dataset** > DatasetSchema src\_app\_api\_datasets\_get\_dataset(uuid) Get Dataset Get a specific dataset by UUID. Generates signed URL for dataset parquet file if available. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.dataset_schema import DatasetSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Dataset api_response = api_instance.src_app_api_datasets_get_dataset(uuid) print("The response of DefaultApi->src_app_api_datasets_get_dataset:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_datasets_get_dataset: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**DatasetSchema**](/api-reference/rest/DatasetSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_datasets\_get\_dataset\_zip\_url** > DatasetZipUrlSchema src\_app\_api\_datasets\_get\_dataset\_zip\_url(uuid) Get Dataset Zip Url Get a signed URL for the dataset zip file. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.dataset_zip_url_schema import DatasetZipUrlSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Dataset Zip Url api_response = api_instance.src_app_api_datasets_get_dataset_zip_url(uuid) print("The response of DefaultApi->src_app_api_datasets_get_dataset_zip_url:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_datasets_get_dataset_zip_url: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**DatasetZipUrlSchema**](/api-reference/rest/DatasetZipUrlSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_datasets\_list\_datasets** > List\[DatasetSchema] src\_app\_api\_datasets\_list\_datasets() List Datasets List all datasets visible to the current user that are not deleted. Generates signed URLs for dataset parquet files. Query parameters: environment: Optional UUID to filter datasets by environment (filters datasets whose episodes contain twins from that environment). ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.dataset_schema import DatasetSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) try: # List Datasets api_response = api_instance.src_app_api_datasets_list_datasets() print("The response of DefaultApi->src_app_api_datasets_list_datasets:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_datasets_list_datasets: %s\n" % e) ``` ### Parameters This endpoint does not need any parameter. ### Return type [**List\[DatasetSchema\]**](/api-reference/rest/DatasetSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_datasets\_remove\_episode\_from\_dataset** > DatasetSchema src\_app\_api\_datasets\_remove\_episode\_from\_dataset(uuid, episode\_uuid) Remove Episode From Dataset Remove a single episode from a dataset. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.dataset_schema import DatasetSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | episode_uuid = 'episode_uuid_example' # str | try: # Remove Episode From Dataset api_response = api_instance.src_app_api_datasets_remove_episode_from_dataset(uuid, episode_uuid) print("The response of DefaultApi->src_app_api_datasets_remove_episode_from_dataset:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_datasets_remove_episode_from_dataset: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ----------------- | ------- | ----------- | ----- | | **uuid** | **str** | | | | **episode\_uuid** | **str** | | | ### Return type [**DatasetSchema**](/api-reference/rest/DatasetSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_datasets\_update\_dataset** > DatasetSchema src\_app\_api\_datasets\_update\_dataset(uuid, dataset\_update\_schema) Update Dataset Update a dataset. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.dataset_schema import DatasetSchema from cyberwave.rest.models.dataset_update_schema import DatasetUpdateSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | dataset_update_schema = cyberwave.rest.DatasetUpdateSchema() # DatasetUpdateSchema | try: # Update Dataset api_response = api_instance.src_app_api_datasets_update_dataset(uuid, dataset_update_schema) print("The response of DefaultApi->src_app_api_datasets_update_dataset:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_datasets_update_dataset: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | --------------------------- | ------------------------------------------------------------------ | ----------- | ----- | | **uuid** | **str** | | | | **dataset\_update\_schema** | [**DatasetUpdateSchema**](/api-reference/rest/DatasetUpdateSchema) | | | ### Return type [**DatasetSchema**](/api-reference/rest/DatasetSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_edge\_nodes\_discover\_twins** > DiscoveryResponseSchema src\_app\_api\_edge\_nodes\_discover\_twins(edge\_register\_schema) Discover Twins Discover all twins this edge device should serve. This endpoint auto-registers the edge if it does not exist and returns all twins that contain this edge fingerprint in Twin.metadata\["edge\_fingerprint"]. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.discovery_response_schema import DiscoveryResponseSchema from cyberwave.rest.models.edge_register_schema import EdgeRegisterSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) edge_register_schema = cyberwave.rest.EdgeRegisterSchema() # EdgeRegisterSchema | try: # Discover Twins api_response = api_instance.src_app_api_edge_nodes_discover_twins(edge_register_schema) print("The response of DefaultApi->src_app_api_edge_nodes_discover_twins:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_edge_nodes_discover_twins: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------------------------- | ---------------------------------------------------------------- | ----------- | ----- | | **edge\_register\_schema** | [**EdgeRegisterSchema**](/api-reference/rest/EdgeRegisterSchema) | | | ### Return type [**DiscoveryResponseSchema**](/api-reference/rest/DiscoveryResponseSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_edge\_nodes\_get\_edge\_twins** > List\[TwinBindingSchema] src\_app\_api\_edge\_nodes\_get\_edge\_twins(uuid) Get Edge Twins Get all twins bound to an edge. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.twin_binding_schema import TwinBindingSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Edge Twins api_response = api_instance.src_app_api_edge_nodes_get_edge_twins(uuid) print("The response of DefaultApi->src_app_api_edge_nodes_get_edge_twins:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_edge_nodes_get_edge_twins: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**List\[TwinBindingSchema\]**](/api-reference/rest/TwinBindingSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_edge\_nodes\_pair\_twin\_to\_edge** > TwinBindingSchema src\_app\_api\_edge\_nodes\_pair\_twin\_to\_edge(uuid, pair\_twin\_schema) Pair Twin To Edge Pair a twin to an edge. Pairing is persisted in twin metadata: * metadata\["edge\_fingerprint"] for identity/binding * metadata\["edge\_configs"] for runtime camera config ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.pair_twin_schema import PairTwinSchema from cyberwave.rest.models.twin_binding_schema import TwinBindingSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | pair_twin_schema = cyberwave.rest.PairTwinSchema() # PairTwinSchema | try: # Pair Twin To Edge api_response = api_instance.src_app_api_edge_nodes_pair_twin_to_edge(uuid, pair_twin_schema) print("The response of DefaultApi->src_app_api_edge_nodes_pair_twin_to_edge:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_edge_nodes_pair_twin_to_edge: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ---------------------- | -------------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **pair\_twin\_schema** | [**PairTwinSchema**](/api-reference/rest/PairTwinSchema) | | | ### Return type [**TwinBindingSchema**](/api-reference/rest/TwinBindingSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_edge\_nodes\_restart\_edge\_core** > EdgeCoreRestartResponseSchema src\_app\_api\_edge\_nodes\_restart\_edge\_core(uuid) Restart Edge Core Publish an MQTT restart command for the target edge-core instance. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.edge_core_restart_response_schema import EdgeCoreRestartResponseSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Restart Edge Core api_response = api_instance.src_app_api_edge_nodes_restart_edge_core(uuid) print("The response of DefaultApi->src_app_api_edge_nodes_restart_edge_core:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_edge_nodes_restart_edge_core: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**EdgeCoreRestartResponseSchema**](/api-reference/rest/EdgeCoreRestartResponseSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_edge\_nodes\_unpair\_twin\_from\_edge** > src\_app\_api\_edge\_nodes\_unpair\_twin\_from\_edge(uuid, twin\_uuid) Unpair Twin From Edge Remove a twin binding from an edge. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | twin_uuid = 'twin_uuid_example' # str | try: # Unpair Twin From Edge api_instance.src_app_api_edge_nodes_unpair_twin_from_edge(uuid, twin_uuid) except Exception as e: print("Exception when calling DefaultApi->src_app_api_edge_nodes_unpair_twin_from_edge: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------------- | ------- | ----------- | ----- | | **uuid** | **str** | | | | **twin\_uuid** | **str** | | | ### Return type void (empty response body) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_edge\_nodes\_update\_camera\_config** > src\_app\_api\_edge\_nodes\_update\_camera\_config(uuid, twin\_uuid, camera\_config\_update\_schema) Update Camera Config DEPRECATED: camera configs now live in Twin.metadata\["edge\_configs"] and must be updated via twin metadata writes. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.camera_config_update_schema import CameraConfigUpdateSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | twin_uuid = 'twin_uuid_example' # str | camera_config_update_schema = cyberwave.rest.CameraConfigUpdateSchema() # CameraConfigUpdateSchema | try: # Update Camera Config api_instance.src_app_api_edge_nodes_update_camera_config(uuid, twin_uuid, camera_config_update_schema) except Exception as e: print("Exception when calling DefaultApi->src_app_api_edge_nodes_update_camera_config: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ---------------------------------- | ---------------------------------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **twin\_uuid** | **str** | | | | **camera\_config\_update\_schema** | [**CameraConfigUpdateSchema**](/api-reference/rest/CameraConfigUpdateSchema) | | | ### Return type void (empty response body) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_edges\_create\_edge** > EdgeSchema src\_app\_api\_edges\_create\_edge(edge\_create\_schema) Create Edge ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.edge_create_schema import EdgeCreateSchema from cyberwave.rest.models.edge_schema import EdgeSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) edge_create_schema = cyberwave.rest.EdgeCreateSchema() # EdgeCreateSchema | try: # Create Edge api_response = api_instance.src_app_api_edges_create_edge(edge_create_schema) print("The response of DefaultApi->src_app_api_edges_create_edge:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_edges_create_edge: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------------ | ------------------------------------------------------------ | ----------- | ----- | | **edge\_create\_schema** | [**EdgeCreateSchema**](/api-reference/rest/EdgeCreateSchema) | | | ### Return type [**EdgeSchema**](/api-reference/rest/EdgeSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_edges\_delete\_edge** > src\_app\_api\_edges\_delete\_edge(uuid) Delete Edge ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Delete Edge api_instance.src_app_api_edges_delete_edge(uuid) except Exception as e: print("Exception when calling DefaultApi->src_app_api_edges_delete_edge: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_edges\_get\_edge** > EdgeSchema src\_app\_api\_edges\_get\_edge(uuid) Get Edge ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.edge_schema import EdgeSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Edge api_response = api_instance.src_app_api_edges_get_edge(uuid) print("The response of DefaultApi->src_app_api_edges_get_edge:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_edges_get_edge: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**EdgeSchema**](/api-reference/rest/EdgeSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_edges\_get\_edges** > List\[EdgeSchema] src\_app\_api\_edges\_get\_edges() Get Edges ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.edge_schema import EdgeSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) try: # Get Edges api_response = api_instance.src_app_api_edges_get_edges() print("The response of DefaultApi->src_app_api_edges_get_edges:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_edges_get_edges: %s\n" % e) ``` ### Parameters This endpoint does not need any parameter. ### Return type [**List\[EdgeSchema\]**](/api-reference/rest/EdgeSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_edges\_update\_edge** > EdgeSchema src\_app\_api\_edges\_update\_edge(uuid, edge\_create\_schema) Update Edge ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.edge_create_schema import EdgeCreateSchema from cyberwave.rest.models.edge_schema import EdgeSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | edge_create_schema = cyberwave.rest.EdgeCreateSchema() # EdgeCreateSchema | try: # Update Edge api_response = api_instance.src_app_api_edges_update_edge(uuid, edge_create_schema) print("The response of DefaultApi->src_app_api_edges_update_edge:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_edges_update_edge: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------------ | ------------------------------------------------------------ | ----------- | ----- | | **uuid** | **str** | | | | **edge\_create\_schema** | [**EdgeCreateSchema**](/api-reference/rest/EdgeCreateSchema) | | | ### Return type [**EdgeSchema**](/api-reference/rest/EdgeSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_cancel\_environment\_invitation** > Dict\[str, object] src\_app\_api\_environments\_cancel\_environment\_invitation(invitation\_uuid) Cancel Environment Invitation Cancel a pending invitation ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) invitation_uuid = 'invitation_uuid_example' # str | try: # Cancel Environment Invitation api_response = api_instance.src_app_api_environments_cancel_environment_invitation(invitation_uuid) print("The response of DefaultApi->src_app_api_environments_cancel_environment_invitation:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_cancel_environment_invitation: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------------------- | ------- | ----------- | ----- | | **invitation\_uuid** | **str** | | | ### Return type **Dict\[str, object]** ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_create\_environment\_for\_project** > EnvironmentSchema src\_app\_api\_environments\_create\_environment\_for\_project(uuid, environment\_create\_schema) Create Environment For Project ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.environment_create_schema import EnvironmentCreateSchema from cyberwave.rest.models.environment_schema import EnvironmentSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | environment_create_schema = cyberwave.rest.EnvironmentCreateSchema() # EnvironmentCreateSchema | try: # Create Environment For Project api_response = api_instance.src_app_api_environments_create_environment_for_project(uuid, environment_create_schema) print("The response of DefaultApi->src_app_api_environments_create_environment_for_project:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_create_environment_for_project: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------------------- | -------------------------------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **environment\_create\_schema** | [**EnvironmentCreateSchema**](/api-reference/rest/EnvironmentCreateSchema) | | | ### Return type [**EnvironmentSchema**](/api-reference/rest/EnvironmentSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_create\_environment\_link** > Dict\[str, object] src\_app\_api\_environments\_create\_environment\_link(uuid) Create Environment Link Create a shareable link for an environment ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Create Environment Link api_response = api_instance.src_app_api_environments_create_environment_link(uuid) print("The response of DefaultApi->src_app_api_environments_create_environment_link:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_create_environment_link: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type **Dict\[str, object]** ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_create\_environment\_simulation** > Dict\[str, object] src\_app\_api\_environments\_create\_environment\_simulation(uuid, simulation\_start\_schema=simulation\_start\_schema) Create Environment Simulation ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.simulation_start_schema import SimulationStartSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | simulation_start_schema = cyberwave.rest.SimulationStartSchema() # SimulationStartSchema | (optional) try: # Create Environment Simulation api_response = api_instance.src_app_api_environments_create_environment_simulation(uuid, simulation_start_schema=simulation_start_schema) print("The response of DefaultApi->src_app_api_environments_create_environment_simulation:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_create_environment_simulation: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ----------------------------- | ---------------------------------------------------------------------- | ----------- | ----------- | | **uuid** | **str** | | | | **simulation\_start\_schema** | [**SimulationStartSchema**](/api-reference/rest/SimulationStartSchema) | | \[optional] | ### Return type **Dict\[str, object]** ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_create\_environment\_snapshot** > EnvironmentSnapshotSchema src\_app\_api\_environments\_create\_environment\_snapshot(uuid, environment\_snapshot\_create\_schema) Create Environment Snapshot Create a new environment snapshot ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.environment_snapshot_create_schema import EnvironmentSnapshotCreateSchema from cyberwave.rest.models.environment_snapshot_schema import EnvironmentSnapshotSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | environment_snapshot_create_schema = cyberwave.rest.EnvironmentSnapshotCreateSchema() # EnvironmentSnapshotCreateSchema | try: # Create Environment Snapshot api_response = api_instance.src_app_api_environments_create_environment_snapshot(uuid, environment_snapshot_create_schema) print("The response of DefaultApi->src_app_api_environments_create_environment_snapshot:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_create_environment_snapshot: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ----------------------------------------- | ------------------------------------------------------------------------------------------ | ----------- | ----- | | **uuid** | **str** | | | | **environment\_snapshot\_create\_schema** | [**EnvironmentSnapshotCreateSchema**](/api-reference/rest/EnvironmentSnapshotCreateSchema) | | | ### Return type [**EnvironmentSnapshotSchema**](/api-reference/rest/EnvironmentSnapshotSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_add\_environment\_waypoints** > EnvironmentWaypointSchema\[] src\_app\_api\_environments\_add\_environment\_waypoints(uuid, environment\_waypoint\_bulk\_create\_schema) Add Environment Waypoints Append multiple waypoints to an environment. ### Parameters | Name | Type | Description | Notes | | ----------------------------------------------- | -------------------------------------------------------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **environment\_waypoint\_bulk\_create\_schema** | [**EnvironmentWaypointBulkCreateSchema**](/api-reference/rest/EnvironmentWaypointBulkCreateSchema) | | | ### Return type [**EnvironmentWaypointSchema\[\]**](/api-reference/rest/EnvironmentWaypointSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_delete\_environment\_waypoint** > EnvironmentWaypointSchema\[] src\_app\_api\_environments\_delete\_environment\_waypoint(uuid, waypoint\_id) Delete Environment Waypoint Delete a waypoint from an environment. ### Parameters | Name | Type | Description | Notes | | ---------------- | ------- | ----------- | ----- | | **uuid** | **str** | | | | **waypoint\_id** | **str** | | | ### Return type [**EnvironmentWaypointSchema\[\]**](/api-reference/rest/EnvironmentWaypointSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_get\_environment\_waypoints** > EnvironmentWaypointSchema\[] src\_app\_api\_environments\_get\_environment\_waypoints(uuid) Get Environment Waypoints List environment waypoints. ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**EnvironmentWaypointSchema\[\]**](/api-reference/rest/EnvironmentWaypointSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_create\_standalone\_environment** > EnvironmentSchema src\_app\_api\_environments\_create\_standalone\_environment(environment\_create\_schema) Create Standalone Environment ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.environment_create_schema import EnvironmentCreateSchema from cyberwave.rest.models.environment_schema import EnvironmentSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) environment_create_schema = cyberwave.rest.EnvironmentCreateSchema() # EnvironmentCreateSchema | try: # Create Standalone Environment api_response = api_instance.src_app_api_environments_create_standalone_environment(environment_create_schema) print("The response of DefaultApi->src_app_api_environments_create_standalone_environment:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_create_standalone_environment: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------------------- | -------------------------------------------------------------------------- | ----------- | ----- | | **environment\_create\_schema** | [**EnvironmentCreateSchema**](/api-reference/rest/EnvironmentCreateSchema) | | | ### Return type [**EnvironmentSchema**](/api-reference/rest/EnvironmentSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_delete\_environment** > src\_app\_api\_environments\_delete\_environment(uuid) Delete Environment ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Delete Environment api_instance.src_app_api_environments_delete_environment(uuid) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_delete_environment: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_delete\_environment\_for\_project** > src\_app\_api\_environments\_delete\_environment\_for\_project(project\_uuid, uuid) Delete Environment For Project ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) project_uuid = 'project_uuid_example' # str | uuid = 'uuid_example' # str | try: # Delete Environment For Project api_instance.src_app_api_environments_delete_environment_for_project(project_uuid, uuid) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_delete_environment_for_project: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ----------------- | ------- | ----------- | ----- | | **project\_uuid** | **str** | | | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_delete\_environment\_snapshot** > Dict\[str, object] src\_app\_api\_environments\_delete\_environment\_snapshot(uuid, snapshot\_uuid) Delete Environment Snapshot Delete a snapshot for an environment ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | snapshot_uuid = 'snapshot_uuid_example' # str | try: # Delete Environment Snapshot api_response = api_instance.src_app_api_environments_delete_environment_snapshot(uuid, snapshot_uuid) print("The response of DefaultApi->src_app_api_environments_delete_environment_snapshot:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_delete_environment_snapshot: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------ | ------- | ----------- | ----- | | **uuid** | **str** | | | | **snapshot\_uuid** | **str** | | | ### Return type **Dict\[str, object]** ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_delete\_recording** > Dict\[str, object] src\_app\_api\_environments\_delete\_recording(uuid, recording\_uuid) Delete Recording Delete a recording. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | recording_uuid = 'recording_uuid_example' # str | try: # Delete Recording api_response = api_instance.src_app_api_environments_delete_recording(uuid, recording_uuid) print("The response of DefaultApi->src_app_api_environments_delete_recording:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_delete_recording: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------- | ------- | ----------- | ----- | | **uuid** | **str** | | | | **recording\_uuid** | **str** | | | ### Return type **Dict\[str, object]** ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_generate\_telemetry\_recording** > RecordingGenerationResponseSchema src\_app\_api\_environments\_generate\_telemetry\_recording(uuid, payload) Generate Telemetry Recording Generate a Parquet recording containing telemetry data for a specific session. Payload should contain: * twin\_uuid: UUID of the twin * start\_timestamp: Start timestamp of the session (microseconds) * end\_timestamp: End timestamp of the session (microseconds) ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.payload import Payload from cyberwave.rest.models.recording_generation_response_schema import RecordingGenerationResponseSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | payload = cyberwave.rest.Payload() # Payload | try: # Generate Telemetry Recording api_response = api_instance.src_app_api_environments_generate_telemetry_recording(uuid, payload) print("The response of DefaultApi->src_app_api_environments_generate_telemetry_recording:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_generate_telemetry_recording: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ----------- | ------------------------------------------ | ----------- | ----- | | **uuid** | **str** | | | | **payload** | [**Payload**](/api-reference/rest/Payload) | | | ### Return type [**RecordingGenerationResponseSchema**](/api-reference/rest/RecordingGenerationResponseSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_get\_environment** > EnvironmentSchema src\_app\_api\_environments\_get\_environment(uuid) Get Environment ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.environment_schema import EnvironmentSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Environment api_response = api_instance.src_app_api_environments_get_environment(uuid) print("The response of DefaultApi->src_app_api_environments_get_environment:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_get_environment: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**EnvironmentSchema**](/api-reference/rest/EnvironmentSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_get\_environment\_dirty\_twins** > List\[Dict\[str, object]] src\_app\_api\_environments\_get\_environment\_dirty\_twins(uuid) Get Environment Dirty Twins List all twins in an environment whose snapshot schema is out of sync with their asset. Compares each twin's stored snapshot hash against the current asset schema hash. Returns list of dirty twin info with reasons. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Environment Dirty Twins api_response = api_instance.src_app_api_environments_get_environment_dirty_twins(uuid) print("The response of DefaultApi->src_app_api_environments_get_environment_dirty_twins:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_get_environment_dirty_twins: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type **List\[Dict\[str, object]]** ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_get\_environment\_invitations** > Dict\[str, object] src\_app\_api\_environments\_get\_environment\_invitations(uuid) Get Environment Invitations Get pending invitations for an environment ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Environment Invitations api_response = api_instance.src_app_api_environments_get_environment_invitations(uuid) print("The response of DefaultApi->src_app_api_environments_get_environment_invitations:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_get_environment_invitations: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type **Dict\[str, object]** ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_get\_environment\_mujoco\_scene** > src\_app\_api\_environments\_get\_environment\_mujoco\_scene(uuid) Get Environment Mujoco Scene Get MuJoCo scene ZIP file for an environment. Returns cached URL if available, otherwise triggers async generation. Cache format (new): * Success: `{"url": str, "created_at": str, "task_id": str, "status": "success"}` * Failure: `{"url": None, "created_at": str, "task_id": str, "status": "failed", "error": str}` * Legacy: Just the URL string (for backward compatibility) ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Environment Mujoco Scene api_instance.src_app_api_environments_get_environment_mujoco_scene(uuid) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_get_environment_mujoco_scene: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_get\_environment\_mujoco\_scene\_xml** > src\_app\_api\_environments\_get\_environment\_mujoco\_scene\_xml(uuid) Get Environment Mujoco Scene Xml Get self-contained MuJoCo scene xml for an environment. Composes schema from all twins' universal\_schemas and exports to MuJoCo XML. Note: Mesh file references will be absolute paths to converted files. For a complete scene with assets, use the /mujoco-scene endpoint to get a ZIP. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Environment Mujoco Scene Xml api_instance.src_app_api_environments_get_environment_mujoco_scene_xml(uuid) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_get_environment_mujoco_scene_xml: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_get\_environment\_mujoco\_scene\_zip\_direct** > src\_app\_api\_environments\_get\_environment\_mujoco\_scene\_zip\_direct(uuid) Get Environment Mujoco Scene Zip Direct Get MuJoCo scene ZIP for an environment (direct download). Returns a ZIP file containing: * mujoco\_scene.xml at the root * assets/: Directory with all required mesh files Composes schema from all twins and exports to MuJoCo format. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Environment Mujoco Scene Zip Direct api_instance.src_app_api_environments_get_environment_mujoco_scene_zip_direct(uuid) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_get_environment_mujoco_scene_zip_direct: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_get\_environment\_recordings** > Dict\[str, object] src\_app\_api\_environments\_get\_environment\_recordings(uuid) Get Environment Recordings Get all available recordings for an environment with pagination. Returns list of recording metadata excluding the recording\_path. Query params: * limit: Max number of records to return (default 50) * offset: Number of records to skip (default 0) ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Environment Recordings api_response = api_instance.src_app_api_environments_get_environment_recordings(uuid) print("The response of DefaultApi->src_app_api_environments_get_environment_recordings:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_get_environment_recordings: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type **Dict\[str, object]** ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_get\_environment\_sessions** > Dict\[str, object] src\_app\_api\_environments\_get\_environment\_sessions(uuid) Get Environment Sessions Get all recording sessions for an environment. Returns sessions for all twins in the environment, with start/end timestamps. This is the simplified session-based API that replaces the old twins-sessions endpoint. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Environment Sessions api_response = api_instance.src_app_api_environments_get_environment_sessions(uuid) print("The response of DefaultApi->src_app_api_environments_get_environment_sessions:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_get_environment_sessions: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type **Dict\[str, object]** ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_get\_environment\_sharing\_info\_endpoint** > Dict\[str, object] src\_app\_api\_environments\_get\_environment\_sharing\_info\_endpoint(uuid) Get Environment Sharing Info Endpoint Get environment sharing and ACL information ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Environment Sharing Info Endpoint api_response = api_instance.src_app_api_environments_get_environment_sharing_info_endpoint(uuid) print("The response of DefaultApi->src_app_api_environments_get_environment_sharing_info_endpoint:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_get_environment_sharing_info_endpoint: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type **Dict\[str, object]** ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_get\_environment\_simulations** > Dict\[str, object] src\_app\_api\_environments\_get\_environment\_simulations(uuid) Get Environment Simulations ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Environment Simulations api_response = api_instance.src_app_api_environments_get_environment_simulations(uuid) print("The response of DefaultApi->src_app_api_environments_get_environment_simulations:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_get_environment_simulations: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type **Dict\[str, object]** ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_get\_environment\_snapshot** > EnvironmentSnapshotSchema src\_app\_api\_environments\_get\_environment\_snapshot(uuid, snapshot\_uuid) Get Environment Snapshot Get a snapshot for an environment ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.environment_snapshot_schema import EnvironmentSnapshotSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | snapshot_uuid = 'snapshot_uuid_example' # str | try: # Get Environment Snapshot api_response = api_instance.src_app_api_environments_get_environment_snapshot(uuid, snapshot_uuid) print("The response of DefaultApi->src_app_api_environments_get_environment_snapshot:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_get_environment_snapshot: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------ | ------- | ----------- | ----- | | **uuid** | **str** | | | | **snapshot\_uuid** | **str** | | | ### Return type [**EnvironmentSnapshotSchema**](/api-reference/rest/EnvironmentSnapshotSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_get\_environment\_snapshot\_hash** > Dict\[str, Optional\[str]] src\_app\_api\_environments\_get\_environment\_snapshot\_hash(uuid) Get Environment Snapshot Hash Get the current snapshot hash key for an environment ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Environment Snapshot Hash api_response = api_instance.src_app_api_environments_get_environment_snapshot_hash(uuid) print("The response of DefaultApi->src_app_api_environments_get_environment_snapshot_hash:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_get_environment_snapshot_hash: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type **Dict\[str, Optional\[str]]** ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_get\_environment\_twins** > List\[TwinSchema] src\_app\_api\_environments\_get\_environment\_twins(uuid) Get Environment Twins Get twins in an environment with optional dynamic filters. Supports filtering on any field using query parameters with Django lookup syntax. Examples: * GET `/environments/{uuid}/twins?position_x**gte=0&position_x**lte=10` * GET `/environments/{uuid}/twins?capabilities\_\_locomotion_mode=wheeled` * GET `/environments/{uuid}/twins?metadata**power**battery_percent\_\_gte=20` * GET `/environments/{uuid}/twins?metadata**amr**navigation\_\_status=idle` * GET `/environments/{uuid}/twins?asset\_\_uuid=xxx` * GET `/environments/{uuid}/twins?capabilities**amr**vehicle_type=forklift` ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.twin_schema import TwinSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Environment Twins api_response = api_instance.src_app_api_environments_get_environment_twins(uuid) print("The response of DefaultApi->src_app_api_environments_get_environment_twins:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_get_environment_twins: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**List\[TwinSchema\]**](/api-reference/rest/TwinSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_get\_environment\_universal\_schema** > src\_app\_api\_environments\_get\_environment\_universal\_schema(uuid) Get Environment Universal Schema Get universal schema JSON file URL for an environment (cached). Returns cached URL if available, otherwise triggers async generation. Cache format: * Success: `{"url": str, "created_at": str, "task_id": str, "status": "success"}` * Failure: `{"url": None, "created_at": str, "task_id": str, "status": "failed", "error": str}` ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Environment Universal Schema api_instance.src_app_api_environments_get_environment_universal_schema(uuid) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_get_environment_universal_schema: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_get\_environment\_universal\_schema\_json** > src\_app\_api\_environments\_get\_environment\_universal\_schema\_json(uuid) Get Environment Universal Schema Json Get the universal schema JSON for an environment (direct download). Composes schema from all twins' universal\_schemas. Returns an HTTP attachment with JSON content. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Environment Universal Schema Json api_instance.src_app_api_environments_get_environment_universal_schema_json(uuid) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_get_environment_universal_schema_json: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_get\_environment\_urdf\_bundle** > src\_app\_api\_environments\_get\_environment\_urdf\_bundle(uuid) Get Environment Urdf Bundle Get environment URDF bundle URL for browser viewer (cached). Returns the URL to the extracted URDF bundle (scene.urdf + assets/) which can be loaded directly by the browser URDF viewer. The bundle is versioned by the environment's hash\_key, so changes to twin schemas will result in a new URL. Returns cached URL if available, otherwise triggers async generation. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Environment Urdf Bundle api_instance.src_app_api_environments_get_environment_urdf_bundle(uuid) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_get_environment_urdf_bundle: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_get\_environment\_urdf\_scene** > src\_app\_api\_environments\_get\_environment\_urdf\_scene(uuid) Get Environment Urdf Scene Get URDF scene ZIP file URL for an environment (cached). Returns cached URL if available, otherwise triggers async generation. Cache format: * Success: `{"url": str, "created_at": str, "task_id": str, "status": "success"}` * Failure: `{"url": None, "created_at": str, "task_id": str, "status": "failed", "error": str}` ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Environment Urdf Scene api_instance.src_app_api_environments_get_environment_urdf_scene(uuid) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_get_environment_urdf_scene: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_get\_environment\_urdf\_scene\_zip\_direct** > src\_app\_api\_environments\_get\_environment\_urdf\_scene\_zip\_direct(uuid) Get Environment Urdf Scene Zip Direct Get URDF scene ZIP for an environment (direct download). Returns a ZIP file containing: * scene.urdf: The complete URDF scene * assets/: Directory with all required mesh files Composes schema from all twins and exports to URDF format. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Environment Urdf Scene Zip Direct api_instance.src_app_api_environments_get_environment_urdf_scene_zip_direct(uuid) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_get_environment_urdf_scene_zip_direct: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_get\_my\_environment\_permissions** > PermissionsSchema src\_app\_api\_environments\_get\_my\_environment\_permissions(uuid) Get My Environment Permissions Get current user's permissions on this environment. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.permissions_schema import PermissionsSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get My Environment Permissions api_response = api_instance.src_app_api_environments_get_my_environment_permissions(uuid) print("The response of DefaultApi->src_app_api_environments_get_my_environment_permissions:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_get_my_environment_permissions: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**PermissionsSchema**](/api-reference/rest/PermissionsSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_get\_recording\_data** > Dict\[str, object] src\_app\_api\_environments\_get\_recording\_data(uuid, recording\_uuid, sample\_rate\_hz=sample\_rate\_hz) Get Recording Data Get sampled recording data for visualization. Returns timestamps and observation states sampled at the specified rate. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | recording_uuid = 'recording_uuid_example' # str | sample_rate_hz = 10 # int | (optional) (default to 10) try: # Get Recording Data api_response = api_instance.src_app_api_environments_get_recording_data(uuid, recording_uuid, sample_rate_hz=sample_rate_hz) print("The response of DefaultApi->src_app_api_environments_get_recording_data:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_get_recording_data: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------------------- | ------- | ----------- | ---------------------------- | | **uuid** | **str** | | | | **recording\_uuid** | **str** | | | | **sample\_rate\_hz** | **int** | | \[optional] \[default to 10] | ### Return type **Dict\[str, object]** ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_import\_environment\_mujoco\_scene** > ImportResultSchema src\_app\_api\_environments\_import\_environment\_mujoco\_scene(uuid, file, replace\_existing=replace\_existing) Import Environment Mujoco Scene Import twins into an environment from a MuJoCo scene file. Accepts either: * A .xml file (raw MJCF scene) * A .zip file containing mujoco\_scene.xml at the root The scene must have been exported by Cyberwave (must contain the extensions.cyberwave.twins registry in the XML comments/schema metadata). Multipart form field: file (.xml or .zip) Query param: replace\_existing (bool, default false) ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.import_result_schema import ImportResultSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | file = None # bytearray | replace_existing = False # bool | (optional) (default to False) try: # Import Environment Mujoco Scene api_response = api_instance.src_app_api_environments_import_environment_mujoco_scene(uuid, file, replace_existing=replace_existing) print("The response of DefaultApi->src_app_api_environments_import_environment_mujoco_scene:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_import_environment_mujoco_scene: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | --------------------- | ------------- | ----------- | ------------------------------- | | **uuid** | **str** | | | | **file** | **bytearray** | | | | **replace\_existing** | **bool** | | \[optional] \[default to False] | ### Return type [**ImportResultSchema**](/api-reference/rest/ImportResultSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: multipart/form-data * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_import\_environment\_universal\_schema** > ImportResultSchema src\_app\_api\_environments\_import\_environment\_universal\_schema(uuid, file, replace\_existing=replace\_existing) Import Environment Universal Schema Import twins into an environment from a Cyberwave universal schema JSON file. The JSON must contain an extensions.cyberwave.twins registry (i.e. it must have been exported by Cyberwave via GET `/{uuid}/universal-schema.json`). Multipart form field: file (.json) Query param: replace\_existing (bool, default false) ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.import_result_schema import ImportResultSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | file = None # bytearray | replace_existing = False # bool | (optional) (default to False) try: # Import Environment Universal Schema api_response = api_instance.src_app_api_environments_import_environment_universal_schema(uuid, file, replace_existing=replace_existing) print("The response of DefaultApi->src_app_api_environments_import_environment_universal_schema:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_import_environment_universal_schema: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | --------------------- | ------------- | ----------- | ------------------------------- | | **uuid** | **str** | | | | **file** | **bytearray** | | | | **replace\_existing** | **bool** | | \[optional] \[default to False] | ### Return type [**ImportResultSchema**](/api-reference/rest/ImportResultSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: multipart/form-data * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_import\_environment\_urdf** > ImportResultSchema src\_app\_api\_environments\_import\_environment\_urdf(uuid, file, replace\_existing=replace\_existing, asset\_uuid=asset\_uuid, asset\_registry\_id=asset\_registry\_id, position\_x=position\_x, position\_y=position\_y, position\_z=position\_z, rotation\_x=rotation\_x, rotation\_y=rotation\_y, rotation\_z=rotation\_z, rotation\_w=rotation\_w) Import Environment Urdf Import a single robot twin into an environment from a URDF file. The URDF describes one robot; you must identify the matching Cyberwave Asset via asset\_uuid or asset\_registry\_id so the twin can be linked correctly. Multipart form field: file (.urdf) Query params: asset\_uuid / asset\_registry\_id - required: identifies the Cyberwave Asset position\_x/y/z - world position for the spawned twin (default 0,0,0) rotation\_x/y/z/w - world orientation quaternion (default identity) replace\_existing - if true, delete existing twins first ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.import_result_schema import ImportResultSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | file = None # bytearray | replace_existing = False # bool | (optional) (default to False) asset_uuid = 'asset_uuid_example' # str | (optional) asset_registry_id = 'asset_registry_id_example' # str | (optional) position_x = 0.0 # float | (optional) (default to 0.0) position_y = 0.0 # float | (optional) (default to 0.0) position_z = 0.0 # float | (optional) (default to 0.0) rotation_x = 0.0 # float | (optional) (default to 0.0) rotation_y = 0.0 # float | (optional) (default to 0.0) rotation_z = 0.0 # float | (optional) (default to 0.0) rotation_w = 1.0 # float | (optional) (default to 1.0) try: # Import Environment Urdf api_response = api_instance.src_app_api_environments_import_environment_urdf(uuid, file, replace_existing=replace_existing, asset_uuid=asset_uuid, asset_registry_id=asset_registry_id, position_x=position_x, position_y=position_y, position_z=position_z, rotation_x=rotation_x, rotation_y=rotation_y, rotation_z=rotation_z, rotation_w=rotation_w) print("The response of DefaultApi->src_app_api_environments_import_environment_urdf:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_import_environment_urdf: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ----------------------- | ------------- | ----------- | ------------------------------- | | **uuid** | **str** | | | | **file** | **bytearray** | | | | **replace\_existing** | **bool** | | \[optional] \[default to False] | | **asset\_uuid** | **str** | | \[optional] | | **asset\_registry\_id** | **str** | | \[optional] | | **position\_x** | **float** | | \[optional] \[default to 0.0] | | **position\_y** | **float** | | \[optional] \[default to 0.0] | | **position\_z** | **float** | | \[optional] \[default to 0.0] | | **rotation\_x** | **float** | | \[optional] \[default to 0.0] | | **rotation\_y** | **float** | | \[optional] \[default to 0.0] | | **rotation\_z** | **float** | | \[optional] \[default to 0.0] | | **rotation\_w** | **float** | | \[optional] \[default to 1.0] | ### Return type [**ImportResultSchema**](/api-reference/rest/ImportResultSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: multipart/form-data * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_invite\_user\_to\_environment** > Dict\[str, object] src\_app\_api\_environments\_invite\_user\_to\_environment(uuid) Invite User To Environment Invite a non-existent user to an environment ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Invite User To Environment api_response = api_instance.src_app_api_environments_invite_user_to_environment(uuid) print("The response of DefaultApi->src_app_api_environments_invite_user_to_environment:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_invite_user_to_environment: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type **Dict\[str, object]** ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_list\_all\_environments** > List\[EnvironmentSchema] src\_app\_api\_environments\_list\_all\_environments() List All Environments ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.environment_schema import EnvironmentSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) try: # List All Environments api_response = api_instance.src_app_api_environments_list_all_environments() print("The response of DefaultApi->src_app_api_environments_list_all_environments:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_list_all_environments: %s\n" % e) ``` ### Parameters This endpoint does not need any parameter. ### Return type [**List\[EnvironmentSchema\]**](/api-reference/rest/EnvironmentSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_list\_environment\_mission\_executions** > List\[MissionExecutionSchema] src\_app\_api\_environments\_list\_environment\_mission\_executions(uuid, status=status, twin\_uuid=twin\_uuid, limit=limit) List Environment Mission Executions List mission executions for all twins in an environment. Args: uuid: Environment UUID status: Filter by status (pending, running, paused, completed, failed, cancelled) twin\_uuid: Filter by specific twin UUID limit: Maximum number of results (default 100) Returns: List of mission executions ordered by created\_at (newest first) ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.mission_execution_schema import MissionExecutionSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | status = 'status_example' # str | (optional) twin_uuid = 'twin_uuid_example' # str | (optional) limit = 100 # int | (optional) (default to 100) try: # List Environment Mission Executions api_response = api_instance.src_app_api_environments_list_environment_mission_executions(uuid, status=status, twin_uuid=twin_uuid, limit=limit) print("The response of DefaultApi->src_app_api_environments_list_environment_mission_executions:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_list_environment_mission_executions: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------------- | ------- | ----------- | ----------------------------- | | **uuid** | **str** | | | | **status** | **str** | | \[optional] | | **twin\_uuid** | **str** | | \[optional] | | **limit** | **int** | | \[optional] \[default to 100] | ### Return type [**List\[MissionExecutionSchema\]**](/api-reference/rest/MissionExecutionSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_list\_environment\_snapshots** > List\[EnvironmentSnapshotSchema] src\_app\_api\_environments\_list\_environment\_snapshots(uuid) List Environment Snapshots List all snapshots for an environment ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.environment_snapshot_schema import EnvironmentSnapshotSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # List Environment Snapshots api_response = api_instance.src_app_api_environments_list_environment_snapshots(uuid) print("The response of DefaultApi->src_app_api_environments_list_environment_snapshots:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_list_environment_snapshots: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**List\[EnvironmentSnapshotSchema\]**](/api-reference/rest/EnvironmentSnapshotSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_list\_environment\_task\_executions** > List\[TaskExecutionSchema] src\_app\_api\_environments\_list\_environment\_task\_executions(uuid, status=status, twin\_uuid=twin\_uuid, limit=limit) List Environment Task Executions List task executions for all twins in an environment. Args: uuid: Environment UUID status: Filter by status (pending, running, completed, failed, cancelled) twin\_uuid: Filter by specific twin UUID limit: Maximum number of results (default 100) Returns: List of task executions ordered by created\_at (newest first) ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.task_execution_schema import TaskExecutionSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | status = 'status_example' # str | (optional) twin_uuid = 'twin_uuid_example' # str | (optional) limit = 100 # int | (optional) (default to 100) try: # List Environment Task Executions api_response = api_instance.src_app_api_environments_list_environment_task_executions(uuid, status=status, twin_uuid=twin_uuid, limit=limit) print("The response of DefaultApi->src_app_api_environments_list_environment_task_executions:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_list_environment_task_executions: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------------- | ------- | ----------- | ----------------------------- | | **uuid** | **str** | | | | **status** | **str** | | \[optional] | | **twin\_uuid** | **str** | | \[optional] | | **limit** | **int** | | \[optional] \[default to 100] | ### Return type [**List\[TaskExecutionSchema\]**](/api-reference/rest/TaskExecutionSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_list\_environments\_for\_project** > List\[EnvironmentSchema] src\_app\_api\_environments\_list\_environments\_for\_project(uuid) List Environments For Project ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.environment_schema import EnvironmentSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # List Environments For Project api_response = api_instance.src_app_api_environments_list_environments_for_project(uuid) print("The response of DefaultApi->src_app_api_environments_list_environments_for_project:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_list_environments_for_project: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**List\[EnvironmentSchema\]**](/api-reference/rest/EnvironmentSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_process\_all\_environment\_sessions** > Dict\[str, object] src\_app\_api\_environments\_process\_all\_environment\_sessions(uuid) Process All Environment Sessions Process all recording sessions for all twins in the environment. This endpoint will: 1. Discover all twins in the environment 2. Find all sessions for each twin 3. Queue recording generation tasks for each session Returns information about queued tasks. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Process All Environment Sessions api_response = api_instance.src_app_api_environments_process_all_environment_sessions(uuid) print("The response of DefaultApi->src_app_api_environments_process_all_environment_sessions:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_process_all_environment_sessions: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type **Dict\[str, object]** ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_remove\_user\_from\_environment** > Dict\[str, object] src\_app\_api\_environments\_remove\_user\_from\_environment(uuid, user\_id) Remove User From Environment Remove user access from environment ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | user_id = 'user_id_example' # str | try: # Remove User From Environment api_response = api_instance.src_app_api_environments_remove_user_from_environment(uuid, user_id) print("The response of DefaultApi->src_app_api_environments_remove_user_from_environment:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_remove_user_from_environment: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------ | ------- | ----------- | ----- | | **uuid** | **str** | | | | **user\_id** | **str** | | | ### Return type **Dict\[str, object]** ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_reset\_environment** > Dict\[str, object] src\_app\_api\_environments\_reset\_environment(uuid) Reset Environment ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Reset Environment api_response = api_instance.src_app_api_environments_reset_environment(uuid) print("The response of DefaultApi->src_app_api_environments_reset_environment:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_reset_environment: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type **Dict\[str, object]** ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_restore\_environment\_snapshot** > EnvironmentSchema src\_app\_api\_environments\_restore\_environment\_snapshot(uuid, snapshot\_uuid) Restore Environment Snapshot Restore a snapshot for an environment ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.environment_schema import EnvironmentSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | snapshot_uuid = 'snapshot_uuid_example' # str | try: # Restore Environment Snapshot api_response = api_instance.src_app_api_environments_restore_environment_snapshot(uuid, snapshot_uuid) print("The response of DefaultApi->src_app_api_environments_restore_environment_snapshot:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_restore_environment_snapshot: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------ | ------- | ----------- | ----- | | **uuid** | **str** | | | | **snapshot\_uuid** | **str** | | | ### Return type [**EnvironmentSchema**](/api-reference/rest/EnvironmentSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_revoke\_environment\_link** > Dict\[str, object] src\_app\_api\_environments\_revoke\_environment\_link(uuid) Revoke Environment Link Revoke a shareable link for an environment ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Revoke Environment Link api_response = api_instance.src_app_api_environments_revoke_environment_link(uuid) print("The response of DefaultApi->src_app_api_environments_revoke_environment_link:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_revoke_environment_link: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type **Dict\[str, object]** ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_share\_environment\_with\_user** > Dict\[str, object] src\_app\_api\_environments\_share\_environment\_with\_user(uuid) Share Environment With User Share environment with a user by email ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Share Environment With User api_response = api_instance.src_app_api_environments_share_environment_with_user(uuid) print("The response of DefaultApi->src_app_api_environments_share_environment_with_user:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_share_environment_with_user: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type **Dict\[str, object]** ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_stop\_environment\_simulation** > Dict\[str, object] src\_app\_api\_environments\_stop\_environment\_simulation(uuid, simulation\_id) Stop Environment Simulation ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | simulation_id = 'simulation_id_example' # str | try: # Stop Environment Simulation api_response = api_instance.src_app_api_environments_stop_environment_simulation(uuid, simulation_id) print("The response of DefaultApi->src_app_api_environments_stop_environment_simulation:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_stop_environment_simulation: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------ | ------- | ----------- | ----- | | **uuid** | **str** | | | | **simulation\_id** | **str** | | | ### Return type **Dict\[str, object]** ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_update\_environment** > EnvironmentSchema src\_app\_api\_environments\_update\_environment(uuid, environment\_create\_schema) Update Environment ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.environment_create_schema import EnvironmentCreateSchema from cyberwave.rest.models.environment_schema import EnvironmentSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | environment_create_schema = cyberwave.rest.EnvironmentCreateSchema() # EnvironmentCreateSchema | try: # Update Environment api_response = api_instance.src_app_api_environments_update_environment(uuid, environment_create_schema) print("The response of DefaultApi->src_app_api_environments_update_environment:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_update_environment: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------------------- | -------------------------------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **environment\_create\_schema** | [**EnvironmentCreateSchema**](/api-reference/rest/EnvironmentCreateSchema) | | | ### Return type [**EnvironmentSchema**](/api-reference/rest/EnvironmentSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_update\_environment\_for\_project** > EnvironmentSchema src\_app\_api\_environments\_update\_environment\_for\_project(project\_uuid, uuid, environment\_create\_schema) Update Environment For Project ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.environment_create_schema import EnvironmentCreateSchema from cyberwave.rest.models.environment_schema import EnvironmentSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) project_uuid = 'project_uuid_example' # str | uuid = 'uuid_example' # str | environment_create_schema = cyberwave.rest.EnvironmentCreateSchema() # EnvironmentCreateSchema | try: # Update Environment For Project api_response = api_instance.src_app_api_environments_update_environment_for_project(project_uuid, uuid, environment_create_schema) print("The response of DefaultApi->src_app_api_environments_update_environment_for_project:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_update_environment_for_project: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------------------- | -------------------------------------------------------------------------- | ----------- | ----- | | **project\_uuid** | **str** | | | | **uuid** | **str** | | | | **environment\_create\_schema** | [**EnvironmentCreateSchema**](/api-reference/rest/EnvironmentCreateSchema) | | | ### Return type [**EnvironmentSchema**](/api-reference/rest/EnvironmentSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_update\_environment\_snapshot** > EnvironmentSnapshotSchema src\_app\_api\_environments\_update\_environment\_snapshot(uuid, snapshot\_uuid) Update Environment Snapshot Update a snapshot for an environment ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.environment_snapshot_schema import EnvironmentSnapshotSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | snapshot_uuid = 'snapshot_uuid_example' # str | try: # Update Environment Snapshot api_response = api_instance.src_app_api_environments_update_environment_snapshot(uuid, snapshot_uuid) print("The response of DefaultApi->src_app_api_environments_update_environment_snapshot:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_update_environment_snapshot: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------ | ------- | ----------- | ----- | | **uuid** | **str** | | | | **snapshot\_uuid** | **str** | | | ### Return type [**EnvironmentSnapshotSchema**](/api-reference/rest/EnvironmentSnapshotSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_environments\_update\_recording\_metadata** > TwinTelemetryMetadataSchema src\_app\_api\_environments\_update\_recording\_metadata(uuid, recording\_uuid, update\_recording\_metadata\_schema) Update Recording Metadata Update recording metadata (e.g., session name). ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.twin_telemetry_metadata_schema import TwinTelemetryMetadataSchema from cyberwave.rest.models.update_recording_metadata_schema import UpdateRecordingMetadataSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | recording_uuid = 'recording_uuid_example' # str | update_recording_metadata_schema = cyberwave.rest.UpdateRecordingMetadataSchema() # UpdateRecordingMetadataSchema | try: # Update Recording Metadata api_response = api_instance.src_app_api_environments_update_recording_metadata(uuid, recording_uuid, update_recording_metadata_schema) print("The response of DefaultApi->src_app_api_environments_update_recording_metadata:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_update_recording_metadata: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | --------------------------------------- | -------------------------------------------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **recording\_uuid** | **str** | | | | **update\_recording\_metadata\_schema** | [**UpdateRecordingMetadataSchema**](/api-reference/rest/UpdateRecordingMetadataSchema) | | | ### Return type [**TwinTelemetryMetadataSchema**](/api-reference/rest/TwinTelemetryMetadataSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_episode\_create\_episode** > EpisodeSchema src\_app\_api\_episode\_create\_episode(episode\_create\_schema) Create Episode Create a new episode. Timestamps in microseconds. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.episode_create_schema import EpisodeCreateSchema from cyberwave.rest.models.episode_schema import EpisodeSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) episode_create_schema = cyberwave.rest.EpisodeCreateSchema() # EpisodeCreateSchema | try: # Create Episode api_response = api_instance.src_app_api_episode_create_episode(episode_create_schema) print("The response of DefaultApi->src_app_api_episode_create_episode:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_episode_create_episode: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | --------------------------- | ------------------------------------------------------------------ | ----------- | ----- | | **episode\_create\_schema** | [**EpisodeCreateSchema**](/api-reference/rest/EpisodeCreateSchema) | | | ### Return type [**EpisodeSchema**](/api-reference/rest/EpisodeSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_episode\_delete\_episode** > Dict\[str, Optional\[bool]] src\_app\_api\_episode\_delete\_episode(uuid) Delete Episode Delete an episode. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Delete Episode api_response = api_instance.src_app_api_episode_delete_episode(uuid) print("The response of DefaultApi->src_app_api_episode_delete_episode:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_episode_delete_episode: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type **Dict\[str, Optional\[bool]]** ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_episode\_get\_episode** > EpisodeSchema src\_app\_api\_episode\_get\_episode(uuid) Get Episode Get a specific episode by UUID. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.episode_schema import EpisodeSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Episode api_response = api_instance.src_app_api_episode_get_episode(uuid) print("The response of DefaultApi->src_app_api_episode_get_episode:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_episode_get_episode: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**EpisodeSchema**](/api-reference/rest/EpisodeSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_episode\_list\_episode\_task\_names** > List\[Optional\[str]] src\_app\_api\_episode\_list\_episode\_task\_names() List Episode Task Names List distinct task names for episodes in the given environment (for autocomplete suggestions). ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) try: # List Episode Task Names api_response = api_instance.src_app_api_episode_list_episode_task_names() print("The response of DefaultApi->src_app_api_episode_list_episode_task_names:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_episode_list_episode_task_names: %s\n" % e) ``` ### Parameters This endpoint does not need any parameter. ### Return type **List\[Optional\[str]]** ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_episode\_list\_episodes** > List\[EpisodeSchema] src\_app\_api\_episode\_list\_episodes() List Episodes List all episodes visible to the current user. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.episode_schema import EpisodeSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) try: # List Episodes api_response = api_instance.src_app_api_episode_list_episodes() print("The response of DefaultApi->src_app_api_episode_list_episodes:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_episode_list_episodes: %s\n" % e) ``` ### Parameters This endpoint does not need any parameter. ### Return type [**List\[EpisodeSchema\]**](/api-reference/rest/EpisodeSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_episode\_update\_episode** > EpisodeSchema src\_app\_api\_episode\_update\_episode(uuid, episode\_update\_schema) Update Episode Update an episode. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.episode_schema import EpisodeSchema from cyberwave.rest.models.episode_update_schema import EpisodeUpdateSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | episode_update_schema = cyberwave.rest.EpisodeUpdateSchema() # EpisodeUpdateSchema | try: # Update Episode api_response = api_instance.src_app_api_episode_update_episode(uuid, episode_update_schema) print("The response of DefaultApi->src_app_api_episode_update_episode:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_episode_update_episode: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | --------------------------- | ------------------------------------------------------------------ | ----------- | ----- | | **uuid** | **str** | | | | **episode\_update\_schema** | [**EpisodeUpdateSchema**](/api-reference/rest/EpisodeUpdateSchema) | | | ### Return type [**EpisodeSchema**](/api-reference/rest/EpisodeSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_events\_create\_business\_event** > BusinessEventSchema src\_app\_api\_events\_create\_business\_event(business\_event\_create\_schema) Create Business Event Create a business event and trigger matching workflows. Sources: sensor, robot, edge\_node, workflow, user, system For ML model events, use source='edge\_node' or 'system' and include model details in the data field: `{"model": "yolo-v8", "version": "1.0", ...}` ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.business_event_create_schema import BusinessEventCreateSchema from cyberwave.rest.models.business_event_schema import BusinessEventSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) business_event_create_schema = cyberwave.rest.BusinessEventCreateSchema() # BusinessEventCreateSchema | try: # Create Business Event api_response = api_instance.src_app_api_events_create_business_event(business_event_create_schema) print("The response of DefaultApi->src_app_api_events_create_business_event:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_events_create_business_event: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ----------------------------------- | ------------------------------------------------------------------------------ | ----------- | ----- | | **business\_event\_create\_schema** | [**BusinessEventCreateSchema**](/api-reference/rest/BusinessEventCreateSchema) | | | ### Return type [**BusinessEventSchema**](/api-reference/rest/BusinessEventSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_events\_list\_live\_events** > BusinessEventListResponseSchema src\_app\_api\_events\_list\_live\_events(environment\_uuid=environment\_uuid, source=source, severity=severity, event\_type=event\_type, last\_timestamp\_ms=last\_timestamp\_ms, limit=limit) List Live Events Get recent business events for live visualization. Supports filtering by: * environment\_uuid: Filter by environment * source: Filter by source type (sensor, robot, edge\_node, workflow, user, system) * severity: Filter by severity level (DEBUG, INFO, WARNING, ERROR, CRITICAL) * event\_type: Filter by event type (exact match) * last\_timestamp\_ms: Get events after this timestamp (for polling) ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.business_event_list_response_schema import BusinessEventListResponseSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) environment_uuid = 'environment_uuid_example' # str | (optional) source = 'source_example' # str | (optional) severity = 'severity_example' # str | (optional) event_type = 'event_type_example' # str | (optional) last_timestamp_ms = 56 # int | (optional) limit = 100 # int | (optional) (default to 100) try: # List Live Events api_response = api_instance.src_app_api_events_list_live_events(environment_uuid=environment_uuid, source=source, severity=severity, event_type=event_type, last_timestamp_ms=last_timestamp_ms, limit=limit) print("The response of DefaultApi->src_app_api_events_list_live_events:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_events_list_live_events: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ----------------------- | ------- | ----------- | ----------------------------- | | **environment\_uuid** | **str** | | \[optional] | | **source** | **str** | | \[optional] | | **severity** | **str** | | \[optional] | | **event\_type** | **str** | | \[optional] | | **last\_timestamp\_ms** | **int** | | \[optional] | | **limit** | **int** | | \[optional] \[default to 100] | ### Return type [**BusinessEventListResponseSchema**](/api-reference/rest/BusinessEventListResponseSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_executions\_get\_task\_execution** > DeferredTaskExecutionResponseSchema src\_app\_api\_executions\_get\_task\_execution(uuid, workspace\_uuid) Get Task Execution Get a specific execution by UUID. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.deferred_task_execution_response_schema import DeferredTaskExecutionResponseSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | workspace_uuid = 'workspace_uuid_example' # str | try: # Get Task Execution api_response = api_instance.src_app_api_executions_get_task_execution(uuid, workspace_uuid) print("The response of DefaultApi->src_app_api_executions_get_task_execution:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_executions_get_task_execution: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------- | ------- | ----------- | ----- | | **uuid** | **str** | | | | **workspace\_uuid** | **str** | | | ### Return type [**DeferredTaskExecutionResponseSchema**](/api-reference/rest/DeferredTaskExecutionResponseSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_executions\_list\_task\_executions** > List\[DeferredTaskExecutionResponseSchema] src\_app\_api\_executions\_list\_task\_executions(workspace\_uuid) List Task Executions List all executions for a workspace. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.deferred_task_execution_response_schema import DeferredTaskExecutionResponseSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) workspace_uuid = 'workspace_uuid_example' # str | try: # List Task Executions api_response = api_instance.src_app_api_executions_list_task_executions(workspace_uuid) print("The response of DefaultApi->src_app_api_executions_list_task_executions:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_executions_list_task_executions: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------- | ------- | ----------- | ----- | | **workspace\_uuid** | **str** | | | ### Return type [**List\[DeferredTaskExecutionResponseSchema\]**](/api-reference/rest/DeferredTaskExecutionResponseSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_invitation\_router\_accept\_invitation\_endpoint** > Dict\[str, object] src\_app\_api\_invitation\_router\_accept\_invitation\_endpoint(token) Accept Invitation Endpoint Accept a user invitation via token ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) token = 'token_example' # str | try: # Accept Invitation Endpoint api_response = api_instance.src_app_api_invitation_router_accept_invitation_endpoint(token) print("The response of DefaultApi->src_app_api_invitation_router_accept_invitation_endpoint:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_invitation_router_accept_invitation_endpoint: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | --------- | ------- | ----------- | ----- | | **token** | **str** | | | ### Return type **Dict\[str, object]** ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_invitation\_router\_get\_invitation\_info** > Dict\[str, object] src\_app\_api\_invitation\_router\_get\_invitation\_info(token) Get Invitation Info Get invitation info without accepting it ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) token = 'token_example' # str | try: # Get Invitation Info api_response = api_instance.src_app_api_invitation_router_get_invitation_info(token) print("The response of DefaultApi->src_app_api_invitation_router_get_invitation_info:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_invitation_router_get_invitation_info: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | --------- | ------- | ----------- | ----- | | **token** | **str** | | | ### Return type **Dict\[str, object]** ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_keybindings\_create\_keybinding** > KeybindingSchema src\_app\_api\_keybindings\_create\_keybinding(keybinding\_create\_schema) Create Keybinding Create a new keybinding. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.keybinding_create_schema import KeybindingCreateSchema from cyberwave.rest.models.keybinding_schema import KeybindingSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) keybinding_create_schema = cyberwave.rest.KeybindingCreateSchema() # KeybindingCreateSchema | try: # Create Keybinding api_response = api_instance.src_app_api_keybindings_create_keybinding(keybinding_create_schema) print("The response of DefaultApi->src_app_api_keybindings_create_keybinding:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_keybindings_create_keybinding: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------------------ | ------------------------------------------------------------------------ | ----------- | ----- | | **keybinding\_create\_schema** | [**KeybindingCreateSchema**](/api-reference/rest/KeybindingCreateSchema) | | | ### Return type [**KeybindingSchema**](/api-reference/rest/KeybindingSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_keybindings\_delete\_keybinding** > src\_app\_api\_keybindings\_delete\_keybinding(uuid) Delete Keybinding Delete a keybinding. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Delete Keybinding api_instance.src_app_api_keybindings_delete_keybinding(uuid) except Exception as e: print("Exception when calling DefaultApi->src_app_api_keybindings_delete_keybinding: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_keybindings\_get\_keybinding** > KeybindingSchema src\_app\_api\_keybindings\_get\_keybinding(uuid) Get Keybinding Get a specific keybinding by UUID. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.keybinding_schema import KeybindingSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Keybinding api_response = api_instance.src_app_api_keybindings_get_keybinding(uuid) print("The response of DefaultApi->src_app_api_keybindings_get_keybinding:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_keybindings_get_keybinding: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**KeybindingSchema**](/api-reference/rest/KeybindingSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_keybindings\_list\_keybindings** > List\[KeybindingSchema] src\_app\_api\_keybindings\_list\_keybindings() List Keybindings List all keybindings for the authenticated user. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.keybinding_schema import KeybindingSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) try: # List Keybindings api_response = api_instance.src_app_api_keybindings_list_keybindings() print("The response of DefaultApi->src_app_api_keybindings_list_keybindings:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_keybindings_list_keybindings: %s\n" % e) ``` ### Parameters This endpoint does not need any parameter. ### Return type [**List\[KeybindingSchema\]**](/api-reference/rest/KeybindingSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_keybindings\_update\_keybinding** > KeybindingSchema src\_app\_api\_keybindings\_update\_keybinding(uuid, keybinding\_update\_schema) Update Keybinding Update an existing keybinding. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.keybinding_schema import KeybindingSchema from cyberwave.rest.models.keybinding_update_schema import KeybindingUpdateSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | keybinding_update_schema = cyberwave.rest.KeybindingUpdateSchema() # KeybindingUpdateSchema | try: # Update Keybinding api_response = api_instance.src_app_api_keybindings_update_keybinding(uuid, keybinding_update_schema) print("The response of DefaultApi->src_app_api_keybindings_update_keybinding:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_keybindings_update_keybinding: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------------------ | ------------------------------------------------------------------------ | ----------- | ----- | | **uuid** | **str** | | | | **keybinding\_update\_schema** | [**KeybindingUpdateSchema**](/api-reference/rest/KeybindingUpdateSchema) | | | ### Return type [**KeybindingSchema**](/api-reference/rest/KeybindingSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_labs\_admin\_force\_end\_session** > EndSessionResponseSchema src\_app\_api\_labs\_admin\_force\_end\_session(session\_uuid) Admin Force End Session Staff-only: force-end any session or remove a user from the queue. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.end_session_response_schema import EndSessionResponseSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) session_uuid = 'session_uuid_example' # str | try: # Admin Force End Session api_response = api_instance.src_app_api_labs_admin_force_end_session(session_uuid) print("The response of DefaultApi->src_app_api_labs_admin_force_end_session:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_labs_admin_force_end_session: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ----------------- | ------- | ----------- | ----- | | **session\_uuid** | **str** | | | ### Return type [**EndSessionResponseSchema**](/api-reference/rest/EndSessionResponseSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_labs\_end\_milan\_lab\_session** > EndSessionResponseSchema src\_app\_api\_labs\_end\_milan\_lab\_session() End Milan Lab Session End the user's active session or cancel their queue entry. If the user had an active session the next queued user is automatically promoted to active. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.end_session_response_schema import EndSessionResponseSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) try: # End Milan Lab Session api_response = api_instance.src_app_api_labs_end_milan_lab_session() print("The response of DefaultApi->src_app_api_labs_end_milan_lab_session:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_labs_end_milan_lab_session: %s\n" % e) ``` ### Parameters This endpoint does not need any parameter. ### Return type [**EndSessionResponseSchema**](/api-reference/rest/EndSessionResponseSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_labs\_get\_admin\_lab\_overview** > AdminLabOverviewSchema src\_app\_api\_labs\_get\_admin\_lab\_overview() Get Admin Lab Overview Staff-only: overview of active session, queue, and recent history. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.admin_lab_overview_schema import AdminLabOverviewSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) try: # Get Admin Lab Overview api_response = api_instance.src_app_api_labs_get_admin_lab_overview() print("The response of DefaultApi->src_app_api_labs_get_admin_lab_overview:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_labs_get_admin_lab_overview: %s\n" % e) ``` ### Parameters This endpoint does not need any parameter. ### Return type [**AdminLabOverviewSchema**](/api-reference/rest/AdminLabOverviewSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_labs\_get\_milan\_lab\_status** > LabStatusResponseSchema src\_app\_api\_labs\_get\_milan\_lab\_status() Get Milan Lab Status Get current status of the Milan SO101 lab for the requesting user. Returns whether the lab is free or in use, the user's session state (active / queued / none), queue position, and estimated wait time. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.lab_status_response_schema import LabStatusResponseSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) try: # Get Milan Lab Status api_response = api_instance.src_app_api_labs_get_milan_lab_status() print("The response of DefaultApi->src_app_api_labs_get_milan_lab_status:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_labs_get_milan_lab_status: %s\n" % e) ``` ### Parameters This endpoint does not need any parameter. ### Return type [**LabStatusResponseSchema**](/api-reference/rest/LabStatusResponseSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_labs\_request\_milan\_lab\_access** > LabAccessResponseSchema src\_app\_api\_labs\_request\_milan\_lab\_access(body) Request Milan Lab Access Request access to the Milan SO101 lab. * If the lab is free the user gets immediate access (10-min session). * If the lab is in use the user is added to the queue. * Idempotent: calling again while active/queued returns the existing session. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.lab_access_response_schema import LabAccessResponseSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) body = None # object | try: # Request Milan Lab Access api_response = api_instance.src_app_api_labs_request_milan_lab_access(body) print("The response of DefaultApi->src_app_api_labs_request_milan_lab_access:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_labs_request_milan_lab_access: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ---------- | ----------- | ----- | | **body** | **object** | | | ### Return type [**LabAccessResponseSchema**](/api-reference/rest/LabAccessResponseSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_maps\_create\_map** > MapDataSchema src\_app\_api\_maps\_create\_map(map\_type, twin\_uuid=twin\_uuid, environment\_uuid=environment\_uuid, resolution=resolution, origin\_x=origin\_x, origin\_y=origin\_y, origin\_z=origin\_z, origin\_roll=origin\_roll, origin\_pitch=origin\_pitch, origin\_yaw=origin\_yaw, metadata=metadata, file=file) Create Map Create/upload a new map. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.map_data_schema import MapDataSchema from cyberwave.rest.models.metadata import Metadata from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) map_type = 'map_type_example' # str | twin_uuid = 'twin_uuid_example' # str | (optional) environment_uuid = 'environment_uuid_example' # str | (optional) resolution = 3.4 # float | (optional) origin_x = 0.0 # float | (optional) (default to 0.0) origin_y = 0.0 # float | (optional) (default to 0.0) origin_z = 0.0 # float | (optional) (default to 0.0) origin_roll = 0.0 # float | (optional) (default to 0.0) origin_pitch = 0.0 # float | (optional) (default to 0.0) origin_yaw = 0.0 # float | (optional) (default to 0.0) metadata = cyberwave.rest.Metadata() # Metadata | (optional) file = None # bytearray | (optional) try: # Create Map api_response = api_instance.src_app_api_maps_create_map(map_type, twin_uuid=twin_uuid, environment_uuid=environment_uuid, resolution=resolution, origin_x=origin_x, origin_y=origin_y, origin_z=origin_z, origin_roll=origin_roll, origin_pitch=origin_pitch, origin_yaw=origin_yaw, metadata=metadata, file=file) print("The response of DefaultApi->src_app_api_maps_create_map:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_maps_create_map: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | --------------------- | -------------------------------------------- | ----------- | ----------------------------- | | **map\_type** | **str** | | | | **twin\_uuid** | **str** | | \[optional] | | **environment\_uuid** | **str** | | \[optional] | | **resolution** | **float** | | \[optional] | | **origin\_x** | **float** | | \[optional] \[default to 0.0] | | **origin\_y** | **float** | | \[optional] \[default to 0.0] | | **origin\_z** | **float** | | \[optional] \[default to 0.0] | | **origin\_roll** | **float** | | \[optional] \[default to 0.0] | | **origin\_pitch** | **float** | | \[optional] \[default to 0.0] | | **origin\_yaw** | **float** | | \[optional] \[default to 0.0] | | **metadata** | [**Metadata**](/api-reference/rest/Metadata) | | \[optional] | | **file** | **bytearray** | | \[optional] | ### Return type [**MapDataSchema**](/api-reference/rest/MapDataSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: multipart/form-data * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_maps\_delete\_map** > src\_app\_api\_maps\_delete\_map(uuid) Delete Map Delete a map. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Delete Map api_instance.src_app_api_maps_delete_map(uuid) except Exception as e: print("Exception when calling DefaultApi->src_app_api_maps_delete_map: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_maps\_download\_map\_data** > src\_app\_api\_maps\_download\_map\_data(uuid) Download Map Data Download map data file. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Download Map Data api_instance.src_app_api_maps_download_map_data(uuid) except Exception as e: print("Exception when calling DefaultApi->src_app_api_maps_download_map_data: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_maps\_finalize\_stream\_map** > MapDataSchema src\_app\_api\_maps\_finalize\_stream\_map(uuid, resolution=resolution, origin\_x=origin\_x, origin\_y=origin\_y, origin\_z=origin\_z, origin\_roll=origin\_roll, origin\_pitch=origin\_pitch, origin\_yaw=origin\_yaw, metadata=metadata, file=file) Finalize Stream Map Finalize a stream-started map by uploading the real map file. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.map_data_schema import MapDataSchema from cyberwave.rest.models.metadata import Metadata from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | resolution = 3.4 # float | (optional) origin_x = 3.4 # float | (optional) origin_y = 3.4 # float | (optional) origin_z = 3.4 # float | (optional) origin_roll = 3.4 # float | (optional) origin_pitch = 3.4 # float | (optional) origin_yaw = 3.4 # float | (optional) metadata = cyberwave.rest.Metadata() # Metadata | (optional) file = None # bytearray | (optional) try: # Finalize Stream Map api_response = api_instance.src_app_api_maps_finalize_stream_map(uuid, resolution=resolution, origin_x=origin_x, origin_y=origin_y, origin_z=origin_z, origin_roll=origin_roll, origin_pitch=origin_pitch, origin_yaw=origin_yaw, metadata=metadata, file=file) print("The response of DefaultApi->src_app_api_maps_finalize_stream_map:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_maps_finalize_stream_map: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ----------------- | -------------------------------------------- | ----------- | ----------- | | **uuid** | **str** | | | | **resolution** | **float** | | \[optional] | | **origin\_x** | **float** | | \[optional] | | **origin\_y** | **float** | | \[optional] | | **origin\_z** | **float** | | \[optional] | | **origin\_roll** | **float** | | \[optional] | | **origin\_pitch** | **float** | | \[optional] | | **origin\_yaw** | **float** | | \[optional] | | **metadata** | [**Metadata**](/api-reference/rest/Metadata) | | \[optional] | | **file** | **bytearray** | | \[optional] | ### Return type [**MapDataSchema**](/api-reference/rest/MapDataSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: multipart/form-data * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_maps\_get\_map** > MapDataSchema src\_app\_api\_maps\_get\_map(uuid) Get Map Get map metadata by UUID. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.map_data_schema import MapDataSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Map api_response = api_instance.src_app_api_maps_get_map(uuid) print("The response of DefaultApi->src_app_api_maps_get_map:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_maps_get_map: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**MapDataSchema**](/api-reference/rest/MapDataSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_maps\_get\_map\_image** > src\_app\_api\_maps\_get\_map\_image(uuid) Get Map Image Return the map data file converted to PNG (supports PGM, PBM, PPM, etc.). ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Map Image api_instance.src_app_api_maps_get_map_image(uuid) except Exception as e: print("Exception when calling DefaultApi->src_app_api_maps_get_map_image: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_maps\_list\_environment\_maps** > List\[MapDataSchema] src\_app\_api\_maps\_list\_environment\_maps(uuid) List Environment Maps List all maps in an environment (including maps from twins in that environment). ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.map_data_schema import MapDataSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # List Environment Maps api_response = api_instance.src_app_api_maps_list_environment_maps(uuid) print("The response of DefaultApi->src_app_api_maps_list_environment_maps:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_maps_list_environment_maps: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**List\[MapDataSchema\]**](/api-reference/rest/MapDataSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_maps\_list\_maps** > List\[MapDataSchema] src\_app\_api\_maps\_list\_maps() List Maps List all maps accessible to the user. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.map_data_schema import MapDataSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) try: # List Maps api_response = api_instance.src_app_api_maps_list_maps() print("The response of DefaultApi->src_app_api_maps_list_maps:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_maps_list_maps: %s\n" % e) ``` ### Parameters This endpoint does not need any parameter. ### Return type [**List\[MapDataSchema\]**](/api-reference/rest/MapDataSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_maps\_list\_twin\_maps** > List\[MapDataSchema] src\_app\_api\_maps\_list\_twin\_maps(uuid) List Twin Maps List maps for a specific twin. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.map_data_schema import MapDataSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # List Twin Maps api_response = api_instance.src_app_api_maps_list_twin_maps(uuid) print("The response of DefaultApi->src_app_api_maps_list_twin_maps:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_maps_list_twin_maps: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**List\[MapDataSchema\]**](/api-reference/rest/MapDataSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_maps\_start\_map\_from\_stream** > MapDataSchema src\_app\_api\_maps\_start\_map\_from\_stream(map\_stream\_start\_schema) Start Map From Stream Create a map entry to receive updates from a live stream. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.map_data_schema import MapDataSchema from cyberwave.rest.models.map_stream_start_schema import MapStreamStartSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) map_stream_start_schema = cyberwave.rest.MapStreamStartSchema() # MapStreamStartSchema | try: # Start Map From Stream api_response = api_instance.src_app_api_maps_start_map_from_stream(map_stream_start_schema) print("The response of DefaultApi->src_app_api_maps_start_map_from_stream:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_maps_start_map_from_stream: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------------------ | -------------------------------------------------------------------- | ----------- | ----- | | **map\_stream\_start\_schema** | [**MapStreamStartSchema**](/api-reference/rest/MapStreamStartSchema) | | | ### Return type [**MapDataSchema**](/api-reference/rest/MapDataSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_maps\_stop\_map\_from\_stream** > MapDataSchema src\_app\_api\_maps\_stop\_map\_from\_stream(map\_stream\_stop\_schema) Stop Map From Stream Queue a stop/finalize request for the active streaming map. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.map_data_schema import MapDataSchema from cyberwave.rest.models.map_stream_stop_schema import MapStreamStopSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) map_stream_stop_schema = cyberwave.rest.MapStreamStopSchema() # MapStreamStopSchema | try: # Stop Map From Stream api_response = api_instance.src_app_api_maps_stop_map_from_stream(map_stream_stop_schema) print("The response of DefaultApi->src_app_api_maps_stop_map_from_stream:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_maps_stop_map_from_stream: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ----------------------------- | ------------------------------------------------------------------ | ----------- | ----- | | **map\_stream\_stop\_schema** | [**MapStreamStopSchema**](/api-reference/rest/MapStreamStopSchema) | | | ### Return type [**MapDataSchema**](/api-reference/rest/MapDataSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_missions\_cancel\_mission\_execution** > src\_app\_api\_missions\_cancel\_mission\_execution(twin\_uuid, mission\_uuid, uuid) Cancel Mission Execution Cancel a mission execution. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) twin_uuid = 'twin_uuid_example' # str | mission_uuid = 'mission_uuid_example' # str | uuid = 'uuid_example' # str | try: # Cancel Mission Execution api_instance.src_app_api_missions_cancel_mission_execution(twin_uuid, mission_uuid, uuid) except Exception as e: print("Exception when calling DefaultApi->src_app_api_missions_cancel_mission_execution: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ----------------- | ------- | ----------- | ----- | | **twin\_uuid** | **str** | | | | **mission\_uuid** | **str** | | | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_missions\_create\_mission** > MissionSchema src\_app\_api\_missions\_create\_mission(uuid, create\_mission\_schema) Create Mission Create a mission definition (sequential task list). ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.create_mission_schema import CreateMissionSchema from cyberwave.rest.models.mission_schema import MissionSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | create_mission_schema = cyberwave.rest.CreateMissionSchema() # CreateMissionSchema | try: # Create Mission api_response = api_instance.src_app_api_missions_create_mission(uuid, create_mission_schema) print("The response of DefaultApi->src_app_api_missions_create_mission:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_missions_create_mission: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | --------------------------- | ------------------------------------------------------------------ | ----------- | ----- | | **uuid** | **str** | | | | **create\_mission\_schema** | [**CreateMissionSchema**](/api-reference/rest/CreateMissionSchema) | | | ### Return type [**MissionSchema**](/api-reference/rest/MissionSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_missions\_delete\_mission** > src\_app\_api\_missions\_delete\_mission(twin\_uuid, uuid) Delete Mission Delete a mission definition. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) twin_uuid = 'twin_uuid_example' # str | uuid = 'uuid_example' # str | try: # Delete Mission api_instance.src_app_api_missions_delete_mission(twin_uuid, uuid) except Exception as e: print("Exception when calling DefaultApi->src_app_api_missions_delete_mission: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------------- | ------- | ----------- | ----- | | **twin\_uuid** | **str** | | | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_missions\_execute\_mission** > MissionExecutionSchema src\_app\_api\_missions\_execute\_mission(twin\_uuid, uuid, create\_mission\_execution\_schema) Execute Mission Execute a mission (create a mission execution). ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.create_mission_execution_schema import CreateMissionExecutionSchema from cyberwave.rest.models.mission_execution_schema import MissionExecutionSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) twin_uuid = 'twin_uuid_example' # str | uuid = 'uuid_example' # str | create_mission_execution_schema = cyberwave.rest.CreateMissionExecutionSchema() # CreateMissionExecutionSchema | try: # Execute Mission api_response = api_instance.src_app_api_missions_execute_mission(twin_uuid, uuid, create_mission_execution_schema) print("The response of DefaultApi->src_app_api_missions_execute_mission:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_missions_execute_mission: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------------------------------------- | ------------------------------------------------------------------------------------ | ----------- | ----- | | **twin\_uuid** | **str** | | | | **uuid** | **str** | | | | **create\_mission\_execution\_schema** | [**CreateMissionExecutionSchema**](/api-reference/rest/CreateMissionExecutionSchema) | | | ### Return type [**MissionExecutionSchema**](/api-reference/rest/MissionExecutionSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_missions\_get\_mission** > MissionSchema src\_app\_api\_missions\_get\_mission(twin\_uuid, uuid) Get Mission Get a mission definition by UUID. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.mission_schema import MissionSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) twin_uuid = 'twin_uuid_example' # str | uuid = 'uuid_example' # str | try: # Get Mission api_response = api_instance.src_app_api_missions_get_mission(twin_uuid, uuid) print("The response of DefaultApi->src_app_api_missions_get_mission:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_missions_get_mission: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------------- | ------- | ----------- | ----- | | **twin\_uuid** | **str** | | | | **uuid** | **str** | | | ### Return type [**MissionSchema**](/api-reference/rest/MissionSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_missions\_get\_mission\_execution** > MissionExecutionSchema src\_app\_api\_missions\_get\_mission\_execution(twin\_uuid, mission\_uuid, uuid) Get Mission Execution Get a mission execution by UUID. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.mission_execution_schema import MissionExecutionSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) twin_uuid = 'twin_uuid_example' # str | mission_uuid = 'mission_uuid_example' # str | uuid = 'uuid_example' # str | try: # Get Mission Execution api_response = api_instance.src_app_api_missions_get_mission_execution(twin_uuid, mission_uuid, uuid) print("The response of DefaultApi->src_app_api_missions_get_mission_execution:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_missions_get_mission_execution: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ----------------- | ------- | ----------- | ----- | | **twin\_uuid** | **str** | | | | **mission\_uuid** | **str** | | | | **uuid** | **str** | | | ### Return type [**MissionExecutionSchema**](/api-reference/rest/MissionExecutionSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_missions\_list\_mission\_executions** > List\[MissionExecutionSchema] src\_app\_api\_missions\_list\_mission\_executions(twin\_uuid, uuid, status=status, limit=limit) List Mission Executions List executions for a mission definition. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.mission_execution_schema import MissionExecutionSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) twin_uuid = 'twin_uuid_example' # str | uuid = 'uuid_example' # str | status = 'status_example' # str | (optional) limit = 50 # int | (optional) (default to 50) try: # List Mission Executions api_response = api_instance.src_app_api_missions_list_mission_executions(twin_uuid, uuid, status=status, limit=limit) print("The response of DefaultApi->src_app_api_missions_list_mission_executions:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_missions_list_mission_executions: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------------- | ------- | ----------- | ---------------------------- | | **twin\_uuid** | **str** | | | | **uuid** | **str** | | | | **status** | **str** | | \[optional] | | **limit** | **int** | | \[optional] \[default to 50] | ### Return type [**List\[MissionExecutionSchema\]**](/api-reference/rest/MissionExecutionSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_missions\_list\_missions** > List\[MissionSchema] src\_app\_api\_missions\_list\_missions(uuid) List Missions List mission definitions for a twin. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.mission_schema import MissionSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # List Missions api_response = api_instance.src_app_api_missions_list_missions(uuid) print("The response of DefaultApi->src_app_api_missions_list_missions:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_missions_list_missions: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**List\[MissionSchema\]**](/api-reference/rest/MissionSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_mlmodels\_create\_mlmodel** > MLModelSchema src\_app\_api\_mlmodels\_create\_mlmodel(ml\_model\_create\_schema) Create Mlmodel Create a new ML model. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.ml_model_create_schema import MLModelCreateSchema from cyberwave.rest.models.ml_model_schema import MLModelSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) ml_model_create_schema = cyberwave.rest.MLModelCreateSchema() # MLModelCreateSchema | try: # Create Mlmodel api_response = api_instance.src_app_api_mlmodels_create_mlmodel(ml_model_create_schema) print("The response of DefaultApi->src_app_api_mlmodels_create_mlmodel:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_mlmodels_create_mlmodel: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ----------------------------- | ------------------------------------------------------------------ | ----------- | ----- | | **ml\_model\_create\_schema** | [**MLModelCreateSchema**](/api-reference/rest/MLModelCreateSchema) | | | ### Return type [**MLModelSchema**](/api-reference/rest/MLModelSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_mlmodels\_delete\_mlmodel** > src\_app\_api\_mlmodels\_delete\_mlmodel(uuid) Delete Mlmodel Delete an ML model. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Delete Mlmodel api_instance.src_app_api_mlmodels_delete_mlmodel(uuid) except Exception as e: print("Exception when calling DefaultApi->src_app_api_mlmodels_delete_mlmodel: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_mlmodels\_get\_mlmodel** > MLModelSchema src\_app\_api\_mlmodels\_get\_mlmodel(uuid) Get Mlmodel Get a specific ML model by UUID. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.ml_model_schema import MLModelSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Mlmodel api_response = api_instance.src_app_api_mlmodels_get_mlmodel(uuid) print("The response of DefaultApi->src_app_api_mlmodels_get_mlmodel:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_mlmodels_get_mlmodel: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**MLModelSchema**](/api-reference/rest/MLModelSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_mlmodels\_get\_mlmodel\_weights** > Dict\[str, Optional\[str]] src\_app\_api\_mlmodels\_get\_mlmodel\_weights(uuid) Get Mlmodel Weights Get a signed URL for downloading the ML model checkpoint weights. The checkpoint is expected to be a tar archive containing the model files (config.json, adapter files, etc.) from training. Returns: Dict with signed\_url and expires\_at fields ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Mlmodel Weights api_response = api_instance.src_app_api_mlmodels_get_mlmodel_weights(uuid) print("The response of DefaultApi->src_app_api_mlmodels_get_mlmodel_weights:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_mlmodels_get_mlmodel_weights: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type **Dict\[str, Optional\[str]]** ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_mlmodels\_list\_mlmodels** > List\[MLModelSchema] src\_app\_api\_mlmodels\_list\_mlmodels(deployment=deployment, edge\_compatible=edge\_compatible) List Mlmodels List all ML models for the authenticated user's workspace. Query params: deployment: Filter by deployment type (cloud, edge, hybrid) edge\_compatible: If true, return only edge or hybrid models ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.ml_model_schema import MLModelSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) deployment = 'deployment_example' # str | (optional) edge_compatible = True # bool | (optional) try: # List Mlmodels api_response = api_instance.src_app_api_mlmodels_list_mlmodels(deployment=deployment, edge_compatible=edge_compatible) print("The response of DefaultApi->src_app_api_mlmodels_list_mlmodels:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_mlmodels_list_mlmodels: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------------------- | -------- | ----------- | ----------- | | **deployment** | **str** | | \[optional] | | **edge\_compatible** | **bool** | | \[optional] | ### Return type [**List\[MLModelSchema\]**](/api-reference/rest/MLModelSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_mlmodels\_update\_mlmodel** > MLModelSchema src\_app\_api\_mlmodels\_update\_mlmodel(uuid, ml\_model\_update\_schema) Update Mlmodel Update an existing ML model. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.ml_model_schema import MLModelSchema from cyberwave.rest.models.ml_model_update_schema import MLModelUpdateSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | ml_model_update_schema = cyberwave.rest.MLModelUpdateSchema() # MLModelUpdateSchema | try: # Update Mlmodel api_response = api_instance.src_app_api_mlmodels_update_mlmodel(uuid, ml_model_update_schema) print("The response of DefaultApi->src_app_api_mlmodels_update_mlmodel:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_mlmodels_update_mlmodel: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ----------------------------- | ------------------------------------------------------------------ | ----------- | ----- | | **uuid** | **str** | | | | **ml\_model\_update\_schema** | [**MLModelUpdateSchema**](/api-reference/rest/MLModelUpdateSchema) | | | ### Return type [**MLModelSchema**](/api-reference/rest/MLModelSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_mltrainings\_create\_mltraining** > Response src\_app\_api\_mltrainings\_create\_mltraining(ml\_training\_create\_schema) Create Mltraining Create a new ML training. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.ml_training_create_schema import MLTrainingCreateSchema from cyberwave.rest.models.response import Response from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) ml_training_create_schema = cyberwave.rest.MLTrainingCreateSchema() # MLTrainingCreateSchema | try: # Create Mltraining api_response = api_instance.src_app_api_mltrainings_create_mltraining(ml_training_create_schema) print("The response of DefaultApi->src_app_api_mltrainings_create_mltraining:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_mltrainings_create_mltraining: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------------------------------- | ------------------------------------------------------------------------ | ----------- | ----- | | **ml\_training\_create\_schema** | [**MLTrainingCreateSchema**](/api-reference/rest/MLTrainingCreateSchema) | | | ### Return type [**Response**](/api-reference/rest/Response) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_mltrainings\_delete\_mltraining** > Dict\[str, object] src\_app\_api\_mltrainings\_delete\_mltraining(uuid) Delete Mltraining Delete an ML training. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Delete Mltraining api_response = api_instance.src_app_api_mltrainings_delete_mltraining(uuid) print("The response of DefaultApi->src_app_api_mltrainings_delete_mltraining:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_mltrainings_delete_mltraining: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type **Dict\[str, object]** ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_mltrainings\_deploy\_mltraining** > Dict\[str, object] src\_app\_api\_mltrainings\_deploy\_mltraining(uuid, ml\_training\_deploy\_schema) Deploy Mltraining Deploy a completed ML training to one or more twins. The deployment process: 1. Export the trained model weights 2. Create a new ControllerPolicy (type: mlmodel) with the trained model 3. Assign the controller policy to the specified twins TODO: Implement actual deployment logic: * Export trained model weights to storage * Create ControllerPolicy with type='mlmodel' and model reference * Update each twin's controller\_policy FK to the new policy * Optionally start inference service ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.ml_training_deploy_schema import MLTrainingDeploySchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | ml_training_deploy_schema = cyberwave.rest.MLTrainingDeploySchema() # MLTrainingDeploySchema | try: # Deploy Mltraining api_response = api_instance.src_app_api_mltrainings_deploy_mltraining(uuid, ml_training_deploy_schema) print("The response of DefaultApi->src_app_api_mltrainings_deploy_mltraining:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_mltrainings_deploy_mltraining: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------------------------------- | ------------------------------------------------------------------------ | ----------- | ----- | | **uuid** | **str** | | | | **ml\_training\_deploy\_schema** | [**MLTrainingDeploySchema**](/api-reference/rest/MLTrainingDeploySchema) | | | ### Return type **Dict\[str, object]** ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_mltrainings\_get\_deployed\_mltrainings** > List\[MLTrainingSchema] src\_app\_api\_mltrainings\_get\_deployed\_mltrainings() Get Deployed Mltrainings Get all deployed ML trainings for the authenticated user's workspaces. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.ml_training_schema import MLTrainingSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) try: # Get Deployed Mltrainings api_response = api_instance.src_app_api_mltrainings_get_deployed_mltrainings() print("The response of DefaultApi->src_app_api_mltrainings_get_deployed_mltrainings:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_mltrainings_get_deployed_mltrainings: %s\n" % e) ``` ### Parameters This endpoint does not need any parameter. ### Return type [**List\[MLTrainingSchema\]**](/api-reference/rest/MLTrainingSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_mltrainings\_get\_mltraining** > MLTrainingSchema src\_app\_api\_mltrainings\_get\_mltraining(uuid) Get Mltraining Get a specific ML training by UUID. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.ml_training_schema import MLTrainingSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Mltraining api_response = api_instance.src_app_api_mltrainings_get_mltraining(uuid) print("The response of DefaultApi->src_app_api_mltrainings_get_mltraining:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_mltrainings_get_mltraining: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**MLTrainingSchema**](/api-reference/rest/MLTrainingSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_mltrainings\_list\_mltrainings\_for\_user\_workspaces** > List\[MLTrainingSchema] src\_app\_api\_mltrainings\_list\_mltrainings\_for\_user\_workspaces() List Mltrainings For User Workspaces List all ML trainings for the authenticated user's workspaces. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.ml_training_schema import MLTrainingSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) try: # List Mltrainings For User Workspaces api_response = api_instance.src_app_api_mltrainings_list_mltrainings_for_user_workspaces() print("The response of DefaultApi->src_app_api_mltrainings_list_mltrainings_for_user_workspaces:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_mltrainings_list_mltrainings_for_user_workspaces: %s\n" % e) ``` ### Parameters This endpoint does not need any parameter. ### Return type [**List\[MLTrainingSchema\]**](/api-reference/rest/MLTrainingSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_mltrainings\_update\_mltraining** > MLTrainingSchema src\_app\_api\_mltrainings\_update\_mltraining(uuid, ml\_training\_update\_schema) Update Mltraining Update an ML training. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.ml_training_schema import MLTrainingSchema from cyberwave.rest.models.ml_training_update_schema import MLTrainingUpdateSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | ml_training_update_schema = cyberwave.rest.MLTrainingUpdateSchema() # MLTrainingUpdateSchema | try: # Update Mltraining api_response = api_instance.src_app_api_mltrainings_update_mltraining(uuid, ml_training_update_schema) print("The response of DefaultApi->src_app_api_mltrainings_update_mltraining:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_mltrainings_update_mltraining: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------------------------------- | ------------------------------------------------------------------------ | ----------- | ----- | | **uuid** | **str** | | | | **ml\_training\_update\_schema** | [**MLTrainingUpdateSchema**](/api-reference/rest/MLTrainingUpdateSchema) | | | ### Return type [**MLTrainingSchema**](/api-reference/rest/MLTrainingSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_navigation\_execute\_twin\_navigation** > TwinActionResponseSchema src\_app\_api\_navigation\_execute\_twin\_navigation(uuid, twin\_navigation\_command\_schema) Execute Twin Navigation ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.twin_action_response_schema import TwinActionResponseSchema from cyberwave.rest.models.twin_navigation_command_schema import TwinNavigationCommandSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | twin_navigation_command_schema = cyberwave.rest.TwinNavigationCommandSchema() # TwinNavigationCommandSchema | try: # Execute Twin Navigation api_response = api_instance.src_app_api_navigation_execute_twin_navigation(uuid, twin_navigation_command_schema) print("The response of DefaultApi->src_app_api_navigation_execute_twin_navigation:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_navigation_execute_twin_navigation: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------------------------- | ---------------------------------------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **twin\_navigation\_command\_schema** | [**TwinNavigationCommandSchema**](/api-reference/rest/TwinNavigationCommandSchema) | | | ### Return type [**TwinActionResponseSchema**](/api-reference/rest/TwinActionResponseSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_projects\_create\_project** > ProjectSchema src\_app\_api\_projects\_create\_project(project\_create\_schema) Create Project ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.project_create_schema import ProjectCreateSchema from cyberwave.rest.models.project_schema import ProjectSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) project_create_schema = cyberwave.rest.ProjectCreateSchema() # ProjectCreateSchema | try: # Create Project api_response = api_instance.src_app_api_projects_create_project(project_create_schema) print("The response of DefaultApi->src_app_api_projects_create_project:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_projects_create_project: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | --------------------------- | ------------------------------------------------------------------ | ----------- | ----- | | **project\_create\_schema** | [**ProjectCreateSchema**](/api-reference/rest/ProjectCreateSchema) | | | ### Return type [**ProjectSchema**](/api-reference/rest/ProjectSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_projects\_create\_project\_link** > src\_app\_api\_projects\_create\_project\_link(uuid, link\_share\_create\_schema) Create Project Link Create a shareable link for a project. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.link_share_create_schema import LinkShareCreateSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | link_share_create_schema = cyberwave.rest.LinkShareCreateSchema() # LinkShareCreateSchema | try: # Create Project Link api_instance.src_app_api_projects_create_project_link(uuid, link_share_create_schema) except Exception as e: print("Exception when calling DefaultApi->src_app_api_projects_create_project_link: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------------------- | ---------------------------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **link\_share\_create\_schema** | [**LinkShareCreateSchema**](/api-reference/rest/LinkShareCreateSchema) | | | ### Return type void (empty response body) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_projects\_delete\_project** > src\_app\_api\_projects\_delete\_project(uuid) Delete Project ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Delete Project api_instance.src_app_api_projects_delete_project(uuid) except Exception as e: print("Exception when calling DefaultApi->src_app_api_projects_delete_project: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_projects\_get\_my\_project\_permissions** > PermissionsSchema src\_app\_api\_projects\_get\_my\_project\_permissions(uuid) Get My Project Permissions Get current user's permissions on this project. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.permissions_schema import PermissionsSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get My Project Permissions api_response = api_instance.src_app_api_projects_get_my_project_permissions(uuid) print("The response of DefaultApi->src_app_api_projects_get_my_project_permissions:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_projects_get_my_project_permissions: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**PermissionsSchema**](/api-reference/rest/PermissionsSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_projects\_get\_project** > ProjectSchema src\_app\_api\_projects\_get\_project(uuid) Get Project ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.project_schema import ProjectSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Project api_response = api_instance.src_app_api_projects_get_project(uuid) print("The response of DefaultApi->src_app_api_projects_get_project:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_projects_get_project: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**ProjectSchema**](/api-reference/rest/ProjectSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_projects\_get\_project\_shares** > SharesResponseSchema src\_app\_api\_projects\_get\_project\_shares(uuid) Get Project Shares List all shares for a project. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.shares_response_schema import SharesResponseSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Project Shares api_response = api_instance.src_app_api_projects_get_project_shares(uuid) print("The response of DefaultApi->src_app_api_projects_get_project_shares:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_projects_get_project_shares: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**SharesResponseSchema**](/api-reference/rest/SharesResponseSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_projects\_invite\_user\_to\_project** > Dict\[str, object] src\_app\_api\_projects\_invite\_user\_to\_project(uuid) Invite User To Project Invite a non-existent user to a project. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Invite User To Project api_response = api_instance.src_app_api_projects_invite_user_to_project(uuid) print("The response of DefaultApi->src_app_api_projects_invite_user_to_project:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_projects_invite_user_to_project: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type **Dict\[str, object]** ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_projects\_list\_projects** > List\[ProjectSchema] src\_app\_api\_projects\_list\_projects() List Projects List all projects visible to the current user. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.project_schema import ProjectSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) try: # List Projects api_response = api_instance.src_app_api_projects_list_projects() print("The response of DefaultApi->src_app_api_projects_list_projects:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_projects_list_projects: %s\n" % e) ``` ### Parameters This endpoint does not need any parameter. ### Return type [**List\[ProjectSchema\]**](/api-reference/rest/ProjectSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_projects\_revoke\_project\_link** > src\_app\_api\_projects\_revoke\_project\_link(uuid, link\_share\_revoke\_schema) Revoke Project Link Revoke a shareable link. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.link_share_revoke_schema import LinkShareRevokeSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | link_share_revoke_schema = cyberwave.rest.LinkShareRevokeSchema() # LinkShareRevokeSchema | try: # Revoke Project Link api_instance.src_app_api_projects_revoke_project_link(uuid, link_share_revoke_schema) except Exception as e: print("Exception when calling DefaultApi->src_app_api_projects_revoke_project_link: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------------------- | ---------------------------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **link\_share\_revoke\_schema** | [**LinkShareRevokeSchema**](/api-reference/rest/LinkShareRevokeSchema) | | | ### Return type void (empty response body) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_projects\_share\_project** > ProjectShareResponseSchema src\_app\_api\_projects\_share\_project(uuid, share\_schema) Share Project Share a project with a user or team. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.project_share_response_schema import ProjectShareResponseSchema from cyberwave.rest.models.share_schema import ShareSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | share_schema = cyberwave.rest.ShareSchema() # ShareSchema | try: # Share Project api_response = api_instance.src_app_api_projects_share_project(uuid, share_schema) print("The response of DefaultApi->src_app_api_projects_share_project:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_projects_share_project: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ----------------- | -------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **share\_schema** | [**ShareSchema**](/api-reference/rest/ShareSchema) | | | ### Return type [**ProjectShareResponseSchema**](/api-reference/rest/ProjectShareResponseSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_projects\_unshare\_project** > ProjectShareResponseSchema src\_app\_api\_projects\_unshare\_project(uuid, share\_schema) Unshare Project Remove sharing permissions for a user or team. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.project_share_response_schema import ProjectShareResponseSchema from cyberwave.rest.models.share_schema import ShareSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | share_schema = cyberwave.rest.ShareSchema() # ShareSchema | try: # Unshare Project api_response = api_instance.src_app_api_projects_unshare_project(uuid, share_schema) print("The response of DefaultApi->src_app_api_projects_unshare_project:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_projects_unshare_project: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ----------------- | -------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **share\_schema** | [**ShareSchema**](/api-reference/rest/ShareSchema) | | | ### Return type [**ProjectShareResponseSchema**](/api-reference/rest/ProjectShareResponseSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_projects\_update\_project** > ProjectSchema src\_app\_api\_projects\_update\_project(uuid, project\_create\_schema) Update Project ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.project_create_schema import ProjectCreateSchema from cyberwave.rest.models.project_schema import ProjectSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | project_create_schema = cyberwave.rest.ProjectCreateSchema() # ProjectCreateSchema | try: # Update Project api_response = api_instance.src_app_api_projects_update_project(uuid, project_create_schema) print("The response of DefaultApi->src_app_api_projects_update_project:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_projects_update_project: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | --------------------------- | ------------------------------------------------------------------ | ----------- | ----- | | **uuid** | **str** | | | | **project\_create\_schema** | [**ProjectCreateSchema**](/api-reference/rest/ProjectCreateSchema) | | | ### Return type [**ProjectSchema**](/api-reference/rest/ProjectSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_tagged\_frames\_create\_tagged\_frames** > TaggedFramesSchema src\_app\_api\_tagged\_frames\_create\_tagged\_frames(tagged\_frames\_create\_schema) Create Tagged Frames Create a new tagged frames entry. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.tagged_frames_create_schema import TaggedFramesCreateSchema from cyberwave.rest.models.tagged_frames_schema import TaggedFramesSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) tagged_frames_create_schema = cyberwave.rest.TaggedFramesCreateSchema() # TaggedFramesCreateSchema | try: # Create Tagged Frames api_response = api_instance.src_app_api_tagged_frames_create_tagged_frames(tagged_frames_create_schema) print("The response of DefaultApi->src_app_api_tagged_frames_create_tagged_frames:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_tagged_frames_create_tagged_frames: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ---------------------------------- | ---------------------------------------------------------------------------- | ----------- | ----- | | **tagged\_frames\_create\_schema** | [**TaggedFramesCreateSchema**](/api-reference/rest/TaggedFramesCreateSchema) | | | ### Return type [**TaggedFramesSchema**](/api-reference/rest/TaggedFramesSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_tagged\_frames\_delete\_tagged\_frames** > src\_app\_api\_tagged\_frames\_delete\_tagged\_frames(uuid) Delete Tagged Frames Delete a tagged frames entry by UUID. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Delete Tagged Frames api_instance.src_app_api_tagged_frames_delete_tagged_frames(uuid) except Exception as e: print("Exception when calling DefaultApi->src_app_api_tagged_frames_delete_tagged_frames: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_tagged\_frames\_get\_tagged\_frames** > TaggedFramesSchema src\_app\_api\_tagged\_frames\_get\_tagged\_frames(uuid) Get Tagged Frames Get a specific tagged frames by UUID. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.tagged_frames_schema import TaggedFramesSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Tagged Frames api_response = api_instance.src_app_api_tagged_frames_get_tagged_frames(uuid) print("The response of DefaultApi->src_app_api_tagged_frames_get_tagged_frames:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_tagged_frames_get_tagged_frames: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**TaggedFramesSchema**](/api-reference/rest/TaggedFramesSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_tagged\_frames\_list\_tagged\_frames** > List\[TaggedFramesSchema] src\_app\_api\_tagged\_frames\_list\_tagged\_frames(recording\_uuid=recording\_uuid) List Tagged Frames List all tagged frames accessible by the user. Optionally filter by recording\_uuid. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.tagged_frames_schema import TaggedFramesSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) recording_uuid = 'recording_uuid_example' # str | (optional) try: # List Tagged Frames api_response = api_instance.src_app_api_tagged_frames_list_tagged_frames(recording_uuid=recording_uuid) print("The response of DefaultApi->src_app_api_tagged_frames_list_tagged_frames:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_tagged_frames_list_tagged_frames: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------- | ------- | ----------- | ----------- | | **recording\_uuid** | **str** | | \[optional] | ### Return type [**List\[TaggedFramesSchema\]**](/api-reference/rest/TaggedFramesSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_tagged\_frames\_update\_tagged\_frames** > TaggedFramesSchema src\_app\_api\_tagged\_frames\_update\_tagged\_frames(uuid, tagged\_frames\_update\_schema) Update Tagged Frames Update an existing tagged frames entry. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.tagged_frames_schema import TaggedFramesSchema from cyberwave.rest.models.tagged_frames_update_schema import TaggedFramesUpdateSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | tagged_frames_update_schema = cyberwave.rest.TaggedFramesUpdateSchema() # TaggedFramesUpdateSchema | try: # Update Tagged Frames api_response = api_instance.src_app_api_tagged_frames_update_tagged_frames(uuid, tagged_frames_update_schema) print("The response of DefaultApi->src_app_api_tagged_frames_update_tagged_frames:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_tagged_frames_update_tagged_frames: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ---------------------------------- | ---------------------------------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **tagged\_frames\_update\_schema** | [**TaggedFramesUpdateSchema**](/api-reference/rest/TaggedFramesUpdateSchema) | | | ### Return type [**TaggedFramesSchema**](/api-reference/rest/TaggedFramesSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_tasks\_cancel\_task\_execution** > src\_app\_api\_tasks\_cancel\_task\_execution(uuid) Cancel Task Execution Cancel a task execution. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Cancel Task Execution api_instance.src_app_api_tasks_cancel_task_execution(uuid) except Exception as e: print("Exception when calling DefaultApi->src_app_api_tasks_cancel_task_execution: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_tasks\_create\_task** > TaskSchema src\_app\_api\_tasks\_create\_task(create\_task\_schema) Create Task Create a reusable task definition. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.create_task_schema import CreateTaskSchema from cyberwave.rest.models.task_schema import TaskSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) create_task_schema = cyberwave.rest.CreateTaskSchema() # CreateTaskSchema | try: # Create Task api_response = api_instance.src_app_api_tasks_create_task(create_task_schema) print("The response of DefaultApi->src_app_api_tasks_create_task:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_tasks_create_task: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------------ | ------------------------------------------------------------ | ----------- | ----- | | **create\_task\_schema** | [**CreateTaskSchema**](/api-reference/rest/CreateTaskSchema) | | | ### Return type [**TaskSchema**](/api-reference/rest/TaskSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_tasks\_delete\_task** > src\_app\_api\_tasks\_delete\_task(uuid) Delete Task Delete a task. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Delete Task api_instance.src_app_api_tasks_delete_task(uuid) except Exception as e: print("Exception when calling DefaultApi->src_app_api_tasks_delete_task: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_tasks\_execute\_task** > TaskExecutionSchema src\_app\_api\_tasks\_execute\_task(uuid, execute\_task\_schema) Execute Task Execute a task on a twin (standalone, not part of mission). ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.execute_task_schema import ExecuteTaskSchema from cyberwave.rest.models.task_execution_schema import TaskExecutionSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | execute_task_schema = cyberwave.rest.ExecuteTaskSchema() # ExecuteTaskSchema | try: # Execute Task api_response = api_instance.src_app_api_tasks_execute_task(uuid, execute_task_schema) print("The response of DefaultApi->src_app_api_tasks_execute_task:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_tasks_execute_task: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------------- | -------------------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **execute\_task\_schema** | [**ExecuteTaskSchema**](/api-reference/rest/ExecuteTaskSchema) | | | ### Return type [**TaskExecutionSchema**](/api-reference/rest/TaskExecutionSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_tasks\_get\_task** > TaskSchema src\_app\_api\_tasks\_get\_task(uuid) Get Task Get a task by UUID. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.task_schema import TaskSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Task api_response = api_instance.src_app_api_tasks_get_task(uuid) print("The response of DefaultApi->src_app_api_tasks_get_task:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_tasks_get_task: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**TaskSchema**](/api-reference/rest/TaskSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_tasks\_get\_task\_execution** > TaskExecutionSchema src\_app\_api\_tasks\_get\_task\_execution(uuid) Get Task Execution ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.task_execution_schema import TaskExecutionSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Task Execution api_response = api_instance.src_app_api_tasks_get_task_execution(uuid) print("The response of DefaultApi->src_app_api_tasks_get_task_execution:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_tasks_get_task_execution: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**TaskExecutionSchema**](/api-reference/rest/TaskExecutionSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_tasks\_list\_task\_queue** > List\[TaskExecutionSchema] src\_app\_api\_tasks\_list\_task\_queue(status=status, environment\_uuid=environment\_uuid, twin\_uuid=twin\_uuid, task\_type=task\_type, limit=limit) List Task Queue List task executions (the order queue). Filters: * status: Filter by status (pending, queued, running, completed, failed, cancelled) Can be comma-separated for multiple: "pending,queued,running" * environment\_uuid: Filter by environment * twin\_uuid: Filter by specific twin * task\_type: Filter by task type (navigation, motion, mlmodel) * limit: Max results (default 100) Examples: * GET /tasks/queue?status=pending,queued,running (active queue) * GET /tasks/queue?status=running (currently executing) * GET /tasks/queue?environment\_uuid=xxx\&status=pending ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.task_execution_schema import TaskExecutionSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) status = 'status_example' # str | (optional) environment_uuid = 'environment_uuid_example' # str | (optional) twin_uuid = 'twin_uuid_example' # str | (optional) task_type = 'task_type_example' # str | (optional) limit = 100 # int | (optional) (default to 100) try: # List Task Queue api_response = api_instance.src_app_api_tasks_list_task_queue(status=status, environment_uuid=environment_uuid, twin_uuid=twin_uuid, task_type=task_type, limit=limit) print("The response of DefaultApi->src_app_api_tasks_list_task_queue:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_tasks_list_task_queue: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | --------------------- | ------- | ----------- | ----------------------------- | | **status** | **str** | | \[optional] | | **environment\_uuid** | **str** | | \[optional] | | **twin\_uuid** | **str** | | \[optional] | | **task\_type** | **str** | | \[optional] | | **limit** | **int** | | \[optional] \[default to 100] | ### Return type [**List\[TaskExecutionSchema\]**](/api-reference/rest/TaskExecutionSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_tasks\_list\_tasks** > List\[TaskSchema] src\_app\_api\_tasks\_list\_tasks(workspace\_uuid=workspace\_uuid, task\_type=task\_type) List Tasks List tasks in workspace. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.task_schema import TaskSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) workspace_uuid = 'workspace_uuid_example' # str | (optional) task_type = 'task_type_example' # str | (optional) try: # List Tasks api_response = api_instance.src_app_api_tasks_list_tasks(workspace_uuid=workspace_uuid, task_type=task_type) print("The response of DefaultApi->src_app_api_tasks_list_tasks:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_tasks_list_tasks: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------- | ------- | ----------- | ----------- | | **workspace\_uuid** | **str** | | \[optional] | | **task\_type** | **str** | | \[optional] | ### Return type [**List\[TaskSchema\]**](/api-reference/rest/TaskSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_tasks\_update\_task** > TaskSchema src\_app\_api\_tasks\_update\_task(uuid, update\_task\_schema) Update Task Update a task. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.task_schema import TaskSchema from cyberwave.rest.models.update_task_schema import UpdateTaskSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | update_task_schema = cyberwave.rest.UpdateTaskSchema() # UpdateTaskSchema | try: # Update Task api_response = api_instance.src_app_api_tasks_update_task(uuid, update_task_schema) print("The response of DefaultApi->src_app_api_tasks_update_task:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_tasks_update_task: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------------ | ------------------------------------------------------------ | ----------- | ----- | | **uuid** | **str** | | | | **update\_task\_schema** | [**UpdateTaskSchema**](/api-reference/rest/UpdateTaskSchema) | | | ### Return type [**TaskSchema**](/api-reference/rest/TaskSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_twins\_create\_twin** > TwinSchema src\_app\_api\_twins\_create\_twin(twin\_create\_schema) Create Twin ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.twin_create_schema import TwinCreateSchema from cyberwave.rest.models.twin_schema import TwinSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) twin_create_schema = cyberwave.rest.TwinCreateSchema() # TwinCreateSchema | try: # Create Twin api_response = api_instance.src_app_api_twins_create_twin(twin_create_schema) print("The response of DefaultApi->src_app_api_twins_create_twin:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_twins_create_twin: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------------ | ------------------------------------------------------------ | ----------- | ----- | | **twin\_create\_schema** | [**TwinCreateSchema**](/api-reference/rest/TwinCreateSchema) | | | ### Return type [**TwinSchema**](/api-reference/rest/TwinSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_twins\_delete\_twin** > src\_app\_api\_twins\_delete\_twin(uuid) Delete Twin ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Delete Twin api_instance.src_app_api_twins_delete_twin(uuid) except Exception as e: print("Exception when calling DefaultApi->src_app_api_twins_delete_twin: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_twins\_execute\_twin\_action** > TwinActionResponseSchema src\_app\_api\_twins\_execute\_twin\_action(uuid, twin\_action\_request\_schema) Execute Twin Action ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.twin_action_request_schema import TwinActionRequestSchema from cyberwave.rest.models.twin_action_response_schema import TwinActionResponseSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | twin_action_request_schema = cyberwave.rest.TwinActionRequestSchema() # TwinActionRequestSchema | try: # Execute Twin Action api_response = api_instance.src_app_api_twins_execute_twin_action(uuid, twin_action_request_schema) print("The response of DefaultApi->src_app_api_twins_execute_twin_action:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_twins_execute_twin_action: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | --------------------------------- | -------------------------------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **twin\_action\_request\_schema** | [**TwinActionRequestSchema**](/api-reference/rest/TwinActionRequestSchema) | | | ### Return type [**TwinActionResponseSchema**](/api-reference/rest/TwinActionResponseSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_twins\_get\_recording** > TwinConnectionEventSchema src\_app\_api\_twins\_get\_recording(recording\_uuid) Get Recording Get a specific recording by UUID. Returns TWIN\_RECORDING\_INFO event with full metadata. Includes signed\_url for mp4\_path if available. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.twin_connection_event_schema import TwinConnectionEventSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) recording_uuid = 'recording_uuid_example' # str | try: # Get Recording api_response = api_instance.src_app_api_twins_get_recording(recording_uuid) print("The response of DefaultApi->src_app_api_twins_get_recording:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_twins_get_recording: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------- | ------- | ----------- | ----- | | **recording\_uuid** | **str** | | | ### Return type [**TwinConnectionEventSchema**](/api-reference/rest/TwinConnectionEventSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_twins\_get\_twin** > TwinSchema src\_app\_api\_twins\_get\_twin(uuid) Get Twin ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.twin_schema import TwinSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Twin api_response = api_instance.src_app_api_twins_get_twin(uuid) print("The response of DefaultApi->src_app_api_twins_get_twin:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_twins_get_twin: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**TwinSchema**](/api-reference/rest/TwinSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_twins\_get\_twin\_action\_status** > TwinActionStatusSchema src\_app\_api\_twins\_get\_twin\_action\_status(uuid, action\_id) Get Twin Action Status ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.twin_action_status_schema import TwinActionStatusSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | action_id = 'action_id_example' # str | try: # Get Twin Action Status api_response = api_instance.src_app_api_twins_get_twin_action_status(uuid, action_id) print("The response of DefaultApi->src_app_api_twins_get_twin_action_status:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_twins_get_twin_action_status: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------------- | ------- | ----------- | ----- | | **uuid** | **str** | | | | **action\_id** | **str** | | | ### Return type [**TwinActionStatusSchema**](/api-reference/rest/TwinActionStatusSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_twins\_get\_twin\_calibration** > TwinJointCalibrationSchema src\_app\_api\_twins\_get\_twin\_calibration(uuid) Get Twin Calibration ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.twin_joint_calibration_schema import TwinJointCalibrationSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Twin Calibration api_response = api_instance.src_app_api_twins_get_twin_calibration(uuid) print("The response of DefaultApi->src_app_api_twins_get_twin_calibration:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_twins_get_twin_calibration: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**TwinJointCalibrationSchema**](/api-reference/rest/TwinJointCalibrationSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_twins\_get\_twin\_connection\_history** > List\[TwinConnectionEventSchema] src\_app\_api\_twins\_get\_twin\_connection\_history(uuid, limit=limit) Get Twin Connection History Get the connection history for a twin. Returns recent telemetry events like connected, disconnected, telemetry\_start, telemetry\_end. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.twin_connection_event_schema import TwinConnectionEventSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | limit = 20 # int | (optional) (default to 20) try: # Get Twin Connection History api_response = api_instance.src_app_api_twins_get_twin_connection_history(uuid, limit=limit) print("The response of DefaultApi->src_app_api_twins_get_twin_connection_history:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_twins_get_twin_connection_history: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | --------- | ------- | ----------- | ---------------------------- | | **uuid** | **str** | | | | **limit** | **int** | | \[optional] \[default to 20] | ### Return type [**List\[TwinConnectionEventSchema\]**](/api-reference/rest/TwinConnectionEventSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_twins\_get\_twin\_driver\_logs** > TwinDriverLogsResponseSchema src\_app\_api\_twins\_get\_twin\_driver\_logs(uuid, limit=limit, offset=offset) Get Twin Driver Logs Get persisted driver logs for a twin, newest-first. Query params: * limit: max rows to return (default 100, max 500) * offset: number of rows to skip (default 0) ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.twin_driver_logs_response_schema import TwinDriverLogsResponseSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | limit = 100 # int | (optional) (default to 100) offset = 0 # int | (optional) (default to 0) try: # Get Twin Driver Logs api_response = api_instance.src_app_api_twins_get_twin_driver_logs(uuid, limit=limit, offset=offset) print("The response of DefaultApi->src_app_api_twins_get_twin_driver_logs:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_twins_get_twin_driver_logs: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ---------- | ------- | ----------- | ----------------------------- | | **uuid** | **str** | | | | **limit** | **int** | | \[optional] \[default to 100] | | **offset** | **int** | | \[optional] \[default to 0] | ### Return type [**TwinDriverLogsResponseSchema**](/api-reference/rest/TwinDriverLogsResponseSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_twins\_get\_twin\_latest\_frame** > src\_app\_api\_twins\_get\_twin\_latest\_frame(uuid, mock=mock) Get Twin Latest Frame Get the latest frame from a twin's camera stream. Serves the frame directly from Redis without saving to permanent storage. For multi-camera twins, the media service stores frames with key `frame:{twin*uuid}*{sensor_id}:rgb:latest`. Pass ?sensor\_id=wrist\_camera to get a specific camera. Query params: * mock: if true, return a deterministic mock JPEG payload. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | mock = False # bool | (optional) (default to False) try: # Get Twin Latest Frame api_instance.src_app_api_twins_get_twin_latest_frame(uuid, mock=mock) except Exception as e: print("Exception when calling DefaultApi->src_app_api_twins_get_twin_latest_frame: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | -------- | ----------- | ------------------------------- | | **uuid** | **str** | | | | **mock** | **bool** | | \[optional] \[default to False] | ### Return type void (empty response body) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_twins\_get\_twin\_latest\_metrics** > src\_app\_api\_twins\_get\_twin\_latest\_metrics(uuid) Get Twin Latest Metrics Get the latest metrics snapshot for a twin. Returns the most recent metrics from Twin.metadata (current state) plus the timestamp of the last update. This is more efficient than querying historical data when you only need the current state. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Twin Latest Metrics api_instance.src_app_api_twins_get_twin_latest_metrics(uuid) except Exception as e: print("Exception when calling DefaultApi->src_app_api_twins_get_twin_latest_metrics: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_twins\_get\_twin\_links** > List\[Optional\[str]] src\_app\_api\_twins\_get\_twin\_links(uuid) Get Twin Links Get list of available links in a twin's schema for docking. Returns a list of link names that can be used as attachment points when docking other twins to this twin. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Twin Links api_response = api_instance.src_app_api_twins_get_twin_links(uuid) print("The response of DefaultApi->src_app_api_twins_get_twin_links:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_twins_get_twin_links: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type **List\[Optional\[str]]** ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_twins\_get\_twin\_metrics** > List\[TwinMetricsQuerySchema] src\_app\_api\_twins\_get\_twin\_metrics(uuid, start=start, end=end, limit=limit) Get Twin Metrics Get historical metrics for a twin. Returns time-series metrics data (battery level, navigation status, etc.) logged via MQTT from edge devices. Args: uuid: Twin UUID start: Start datetime (ISO format, e.g., "2026-01-01T00:00:00Z") end: End datetime (ISO format) limit: Max results (default 100, max 1000) Returns: List of metrics snapshots ordered by timestamp (newest first) Examples: GET `/twins/{uuid}/metrics` GET `/twins/{uuid}/metrics?start=2026-01-20T00:00:00Z&limit=500` GET `/twins/{uuid}/metrics?start=2026-01-01&end=2026-01-21` ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.twin_metrics_query_schema import TwinMetricsQuerySchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | start = 'start_example' # str | (optional) end = 'end_example' # str | (optional) limit = 100 # int | (optional) (default to 100) try: # Get Twin Metrics api_response = api_instance.src_app_api_twins_get_twin_metrics(uuid, start=start, end=end, limit=limit) print("The response of DefaultApi->src_app_api_twins_get_twin_metrics:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_twins_get_twin_metrics: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | --------- | ------- | ----------- | ----------------------------- | | **uuid** | **str** | | | | **start** | **str** | | \[optional] | | **end** | **str** | | \[optional] | | **limit** | **int** | | \[optional] \[default to 100] | ### Return type [**List\[TwinMetricsQuerySchema\]**](/api-reference/rest/TwinMetricsQuerySchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_twins\_get\_twin\_motions** > TwinMotionResponseSchema src\_app\_api\_twins\_get\_twin\_motions(uuid, environment\_uuid=environment\_uuid) Get Twin Motions ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.twin_motion_response_schema import TwinMotionResponseSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | environment_uuid = 'environment_uuid_example' # str | (optional) try: # Get Twin Motions api_response = api_instance.src_app_api_twins_get_twin_motions(uuid, environment_uuid=environment_uuid) print("The response of DefaultApi->src_app_api_twins_get_twin_motions:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_twins_get_twin_motions: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | --------------------- | ------- | ----------- | ----------- | | **uuid** | **str** | | | | **environment\_uuid** | **str** | | \[optional] | ### Return type [**TwinMotionResponseSchema**](/api-reference/rest/TwinMotionResponseSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_twins\_get\_twin\_notebook** > src\_app\_api\_twins\_get\_twin\_notebook(uuid) Get Twin Notebook Generate and serve a Jupyter notebook for this twin. This endpoint is public so Google Colab can fetch it directly. Usage: `https://colab.research.google.com/#fileId=/twins/{uuid}/notebook.ipynb` ### Example ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Twin Notebook api_instance.src_app_api_twins_get_twin_notebook(uuid) except Exception as e: print("Exception when calling DefaultApi->src_app_api_twins_get_twin_notebook: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization No authorization required ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_twins\_get\_twin\_recordings** > List\[TwinConnectionEventSchema] src\_app\_api\_twins\_get\_twin\_recordings(uuid) Get Twin Recordings Get all recordings for a twin. Returns TWIN\_RECORDING\_INFO events (parquet recordings) for camera twins. Only returns recordings that have mp4\_path (camera recordings). Includes signed\_url in metadata for each recording. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.twin_connection_event_schema import TwinConnectionEventSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Twin Recordings api_response = api_instance.src_app_api_twins_get_twin_recordings(uuid) print("The response of DefaultApi->src_app_api_twins_get_twin_recordings:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_twins_get_twin_recordings: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**List\[TwinConnectionEventSchema\]**](/api-reference/rest/TwinConnectionEventSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_twins\_get\_twin\_relationships** > List\[TwinRelationshipSchema] src\_app\_api\_twins\_get\_twin\_relationships(uuid) Get Twin Relationships MVP: Generate mock relationships based on twin names and environment ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.twin_relationship_schema import TwinRelationshipSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Twin Relationships api_response = api_instance.src_app_api_twins_get_twin_relationships(uuid) print("The response of DefaultApi->src_app_api_twins_get_twin_relationships:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_twins_get_twin_relationships: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**List\[TwinRelationshipSchema\]**](/api-reference/rest/TwinRelationshipSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_twins\_get\_twin\_universal\_schema\_at\_path** > Dict\[str, object] src\_app\_api\_twins\_get\_twin\_universal\_schema\_at\_path(uuid, path=path) Get Twin Universal Schema At Path Get value at a specific JSON Pointer path in the twin's universal schema. Query params: path: JSON Pointer path (e.g., /sensors/0, /extensions/cyberwave/capabilities) Returns: `{"path": "...", "value": }` ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | path = '' # str | (optional) (default to '') try: # Get Twin Universal Schema At Path api_response = api_instance.src_app_api_twins_get_twin_universal_schema_at_path(uuid, path=path) print("The response of DefaultApi->src_app_api_twins_get_twin_universal_schema_at_path:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_twins_get_twin_universal_schema_at_path: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ---------------------------- | | **uuid** | **str** | | | | **path** | **str** | | \[optional] \[default to ''] | ### Return type **Dict\[str, object]** ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_twins\_link\_occupancy\_map** > src\_app\_api\_twins\_link\_occupancy\_map(uuid, occupancy\_map\_create\_schema) Link Occupancy Map Link an occupancy-grid map to this twin, compute (or retrieve) the world->map transform, and send it to the edge via MQTT. The map must have been uploaded beforehand via `POST /maps` (with `map_type=occupancy_grid`). Flow: 1. Validate and associate the map with the twin. 2. If the environment already has a manually-set navigation transform, use it. Otherwise, attempt to auto-align the SLAM map with the 3D scene (currently mocked as identity). 3. Save the transform into `environment.settings.navigation`. 4. Publish the transform on the `occupancy-map-tf` MQTT topic so the edge waypoint bridge sets its `world -> map` TF. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.occupancy_map_create_schema import OccupancyMapCreateSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | occupancy_map_create_schema = cyberwave.rest.OccupancyMapCreateSchema() # OccupancyMapCreateSchema | try: # Link Occupancy Map api_instance.src_app_api_twins_link_occupancy_map(uuid, occupancy_map_create_schema) except Exception as e: print("Exception when calling DefaultApi->src_app_api_twins_link_occupancy_map: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ---------------------------------- | ---------------------------------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **occupancy\_map\_create\_schema** | [**OccupancyMapCreateSchema**](/api-reference/rest/OccupancyMapCreateSchema) | | | ### Return type void (empty response body) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_twins\_list\_all\_twins** > List\[TwinSchema] src\_app\_api\_twins\_list\_all\_twins() List All Twins ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.twin_schema import TwinSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) try: # List All Twins api_response = api_instance.src_app_api_twins_list_all_twins() print("The response of DefaultApi->src_app_api_twins_list_all_twins:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_twins_list_all_twins: %s\n" % e) ``` ### Parameters This endpoint does not need any parameter. ### Return type [**List\[TwinSchema\]**](/api-reference/rest/TwinSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_twins\_patch\_twin\_universal\_schema** > Dict\[str, object] src\_app\_api\_twins\_patch\_twin\_universal\_schema(uuid, twin\_universal\_schema\_patch\_schema) Patch Twin Universal Schema Update the twin's universal schema using JSON Pointer operations. This allows editing twin-specific schema overrides, such as: * /sensors (array of sensor objects) * /extensions/cyberwave/capabilities Note: Unlike Asset schema, Twin schema PATCH does NOT update a hash (twin schema is a snapshot, not authoritative). Body: ```json theme={null} { "op": "add" | "replace", "path": "/sensors/0/parameters/id", "value": "my_camera" } ``` Returns: ```json theme={null} { "schema": "", "updated": { "op": "...", "path": "..." } } ``` ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.twin_universal_schema_patch_schema import TwinUniversalSchemaPatchSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | twin_universal_schema_patch_schema = cyberwave.rest.TwinUniversalSchemaPatchSchema() # TwinUniversalSchemaPatchSchema | try: # Patch Twin Universal Schema api_response = api_instance.src_app_api_twins_patch_twin_universal_schema(uuid, twin_universal_schema_patch_schema) print("The response of DefaultApi->src_app_api_twins_patch_twin_universal_schema:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_twins_patch_twin_universal_schema: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------------------------------ | ---------------------------------------------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **twin\_universal\_schema\_patch\_schema** | [**TwinUniversalSchemaPatchSchema**](/api-reference/rest/TwinUniversalSchemaPatchSchema) | | | ### Return type **Dict\[str, object]** ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_twins\_reload\_twin\_capabilities** > Dict\[str, object] src\_app\_api\_twins\_reload\_twin\_capabilities(uuid) Reload Twin Capabilities Get capabilities from Twin.universal\_schema. Note: Capabilities are now derived from schema only, not cached in DB. This endpoint is kept for backward compatibility. Returns: ``` {"success": true, "capabilities": {...}} ``` ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Reload Twin Capabilities api_response = api_instance.src_app_api_twins_reload_twin_capabilities(uuid) print("The response of DefaultApi->src_app_api_twins_reload_twin_capabilities:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_twins_reload_twin_capabilities: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type **Dict\[str, object]** ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_twins\_reload\_twins\_capabilities\_bulk** > Dict\[str, object] src\_app\_api\_twins\_reload\_twins\_capabilities\_bulk(reload\_capabilities\_bulk\_schema) Reload Twins Capabilities Bulk Bulk reload capabilities for multiple twins. Filters: * environment\_uuid: Reload all twins in an environment * twin\_uuids: Reload specific twins by UUID If both are provided, twins must match both criteria. If neither is provided, returns error. Returns: ``` {"success": true, "updated_count": N, "failed_count": M, "errors": [...]} ``` ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.reload_capabilities_bulk_schema import ReloadCapabilitiesBulkSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) reload_capabilities_bulk_schema = cyberwave.rest.ReloadCapabilitiesBulkSchema() # ReloadCapabilitiesBulkSchema | try: # Reload Twins Capabilities Bulk api_response = api_instance.src_app_api_twins_reload_twins_capabilities_bulk(reload_capabilities_bulk_schema) print("The response of DefaultApi->src_app_api_twins_reload_twins_capabilities_bulk:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_twins_reload_twins_capabilities_bulk: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------------------------------------- | ------------------------------------------------------------------------------------ | ----------- | ----- | | **reload\_capabilities\_bulk\_schema** | [**ReloadCapabilitiesBulkSchema**](/api-reference/rest/ReloadCapabilitiesBulkSchema) | | | ### Return type **Dict\[str, object]** ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_twins\_sync\_twin\_with\_asset** > SyncWithAssetSchema src\_app\_api\_twins\_sync\_twin\_with\_asset(uuid) Sync Twin With Asset Sync twin metadata and universal\_schema with its parent asset. This updates the twin's metadata with the latest values from the asset for fields that are typically defined at the asset level (like locomotion\_animations). Fields that are twin-specific (like controller assignments) are preserved. Note: This also re-snapshots the twin's universal\_schema from the asset, overwriting any twin-specific schema edits made via PATCH `/api/v1/twins/{uuid}/universal-schema`. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.sync_with_asset_schema import SyncWithAssetSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Sync Twin With Asset api_response = api_instance.src_app_api_twins_sync_twin_with_asset(uuid) print("The response of DefaultApi->src_app_api_twins_sync_twin_with_asset:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_twins_sync_twin_with_asset: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**SyncWithAssetSchema**](/api-reference/rest/SyncWithAssetSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_twins\_update\_twin** > TwinSchema src\_app\_api\_twins\_update\_twin(uuid, twin\_create\_schema) Update Twin Update a twin's properties. Note: When changing the asset\_uuid, the twin's universal\_schema will be re-snapshotted from the new asset, overwriting any twin-specific schema edits made via PATCH `/api/v1/twins/{uuid}/universal-schema`. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.twin_create_schema import TwinCreateSchema from cyberwave.rest.models.twin_schema import TwinSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | twin_create_schema = cyberwave.rest.TwinCreateSchema() # TwinCreateSchema | try: # Update Twin api_response = api_instance.src_app_api_twins_update_twin(uuid, twin_create_schema) print("The response of DefaultApi->src_app_api_twins_update_twin:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_twins_update_twin: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------------ | ------------------------------------------------------------ | ----------- | ----- | | **uuid** | **str** | | | | **twin\_create\_schema** | [**TwinCreateSchema**](/api-reference/rest/TwinCreateSchema) | | | ### Return type [**TwinSchema**](/api-reference/rest/TwinSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_twins\_update\_twin\_calibration** > TwinJointCalibrationSchema src\_app\_api\_twins\_update\_twin\_calibration(uuid, twin\_joint\_calibration\_schema) Update Twin Calibration ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.twin_joint_calibration_schema import TwinJointCalibrationSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | twin_joint_calibration_schema = cyberwave.rest.TwinJointCalibrationSchema() # TwinJointCalibrationSchema | try: # Update Twin Calibration api_response = api_instance.src_app_api_twins_update_twin_calibration(uuid, twin_joint_calibration_schema) print("The response of DefaultApi->src_app_api_twins_update_twin_calibration:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_twins_update_twin_calibration: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------------------------ | -------------------------------------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **twin\_joint\_calibration\_schema** | [**TwinJointCalibrationSchema**](/api-reference/rest/TwinJointCalibrationSchema) | | | ### Return type [**TwinJointCalibrationSchema**](/api-reference/rest/TwinJointCalibrationSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_twins\_update\_twin\_state** > TwinSchema src\_app\_api\_twins\_update\_twin\_state(uuid, twin\_state\_update\_schema) Update Twin State ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.twin_schema import TwinSchema from cyberwave.rest.models.twin_state_update_schema import TwinStateUpdateSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | twin_state_update_schema = cyberwave.rest.TwinStateUpdateSchema() # TwinStateUpdateSchema | try: # Update Twin State api_response = api_instance.src_app_api_twins_update_twin_state(uuid, twin_state_update_schema) print("The response of DefaultApi->src_app_api_twins_update_twin_state:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_twins_update_twin_state: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------------------- | ---------------------------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **twin\_state\_update\_schema** | [**TwinStateUpdateSchema**](/api-reference/rest/TwinStateUpdateSchema) | | | ### Return type [**TwinSchema**](/api-reference/rest/TwinSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_urdf\_create\_urdf\_project** > URDFProjectSchema src\_app\_api\_urdf\_create\_urdf\_project(urdf\_project\_create\_schema) Create Urdf Project ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.urdf_project_create_schema import URDFProjectCreateSchema from cyberwave.rest.models.urdf_project_schema import URDFProjectSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) urdf_project_create_schema = cyberwave.rest.URDFProjectCreateSchema() # URDFProjectCreateSchema | try: # Create Urdf Project api_response = api_instance.src_app_api_urdf_create_urdf_project(urdf_project_create_schema) print("The response of DefaultApi->src_app_api_urdf_create_urdf_project:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_urdf_create_urdf_project: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | --------------------------------- | -------------------------------------------------------------------------- | ----------- | ----- | | **urdf\_project\_create\_schema** | [**URDFProjectCreateSchema**](/api-reference/rest/URDFProjectCreateSchema) | | | ### Return type [**URDFProjectSchema**](/api-reference/rest/URDFProjectSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_urdf\_delete\_urdf\_project** > src\_app\_api\_urdf\_delete\_urdf\_project(uuid) Delete Urdf Project ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Delete Urdf Project api_instance.src_app_api_urdf_delete_urdf_project(uuid) except Exception as e: print("Exception when calling DefaultApi->src_app_api_urdf_delete_urdf_project: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_urdf\_fix\_urdf\_project\_slug** > URDFProjectSchema src\_app\_api\_urdf\_fix\_urdf\_project\_slug(uuid, new\_slug, new\_main\_file\_path) Fix Urdf Project Slug Fix a URDF project's slug and main\_file\_path to match actual storage. This is useful when files exist in storage but the DB record points to the wrong location. Requires staff/superuser permissions. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.urdf_project_schema import URDFProjectSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | new_slug = 'new_slug_example' # str | new_main_file_path = 'new_main_file_path_example' # str | try: # Fix Urdf Project Slug api_response = api_instance.src_app_api_urdf_fix_urdf_project_slug(uuid, new_slug, new_main_file_path) print("The response of DefaultApi->src_app_api_urdf_fix_urdf_project_slug:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_urdf_fix_urdf_project_slug: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------------- | ------- | ----------- | ----- | | **uuid** | **str** | | | | **new\_slug** | **str** | | | | **new\_main\_file\_path** | **str** | | | ### Return type [**URDFProjectSchema**](/api-reference/rest/URDFProjectSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_urdf\_get\_twin\_joint\_state** > JointStateSchema src\_app\_api\_urdf\_get\_twin\_joint\_state(uuid, joint\_name) Get Twin Joint State ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.joint_state_schema import JointStateSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | joint_name = 'joint_name_example' # str | try: # Get Twin Joint State api_response = api_instance.src_app_api_urdf_get_twin_joint_state(uuid, joint_name) print("The response of DefaultApi->src_app_api_urdf_get_twin_joint_state:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_urdf_get_twin_joint_state: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | --------------- | ------- | ----------- | ----- | | **uuid** | **str** | | | | **joint\_name** | **str** | | | ### Return type [**JointStateSchema**](/api-reference/rest/JointStateSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_urdf\_get\_twin\_joint\_states** > JointStatesSchema src\_app\_api\_urdf\_get\_twin\_joint\_states(uuid) Get Twin Joint States ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.joint_states_schema import JointStatesSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Twin Joint States api_response = api_instance.src_app_api_urdf_get_twin_joint_states(uuid) print("The response of DefaultApi->src_app_api_urdf_get_twin_joint_states:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_urdf_get_twin_joint_states: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**JointStatesSchema**](/api-reference/rest/JointStatesSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_urdf\_get\_twin\_joints** > List\[JointSchema] src\_app\_api\_urdf\_get\_twin\_joints(uuid) Get Twin Joints ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.joint_schema import JointSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Twin Joints api_response = api_instance.src_app_api_urdf_get_twin_joints(uuid) print("The response of DefaultApi->src_app_api_urdf_get_twin_joints:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_urdf_get_twin_joints: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**List\[JointSchema\]**](/api-reference/rest/JointSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_urdf\_get\_twin\_robot\_description** > RobotDescriptionSchema src\_app\_api\_urdf\_get\_twin\_robot\_description(uuid) Get Twin Robot Description ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.robot_description_schema import RobotDescriptionSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Twin Robot Description api_response = api_instance.src_app_api_urdf_get_twin_robot_description(uuid) print("The response of DefaultApi->src_app_api_urdf_get_twin_robot_description:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_urdf_get_twin_robot_description: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**RobotDescriptionSchema**](/api-reference/rest/RobotDescriptionSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_urdf\_get\_twin\_urdf\_raw** > str src\_app\_api\_urdf\_get\_twin\_urdf\_raw(uuid) Get Twin Urdf Raw ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Twin Urdf Raw api_response = api_instance.src_app_api_urdf_get_twin_urdf_raw(uuid) print("The response of DefaultApi->src_app_api_urdf_get_twin_urdf_raw:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_urdf_get_twin_urdf_raw: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type **str** ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_urdf\_get\_urdf\_project** > URDFProjectSchema src\_app\_api\_urdf\_get\_urdf\_project(uuid) Get Urdf Project ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.urdf_project_schema import URDFProjectSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Urdf Project api_response = api_instance.src_app_api_urdf_get_urdf_project(uuid) print("The response of DefaultApi->src_app_api_urdf_get_urdf_project:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_urdf_get_urdf_project: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**URDFProjectSchema**](/api-reference/rest/URDFProjectSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_urdf\_list\_urdf\_projects** > List\[URDFProjectSchema] src\_app\_api\_urdf\_list\_urdf\_projects() List Urdf Projects ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.urdf_project_schema import URDFProjectSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) try: # List Urdf Projects api_response = api_instance.src_app_api_urdf_list_urdf_projects() print("The response of DefaultApi->src_app_api_urdf_list_urdf_projects:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_urdf_list_urdf_projects: %s\n" % e) ``` ### Parameters This endpoint does not need any parameter. ### Return type [**List\[URDFProjectSchema\]**](/api-reference/rest/URDFProjectSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_urdf\_update\_twin\_joint\_state** > JointStateSchema src\_app\_api\_urdf\_update\_twin\_joint\_state(uuid, joint\_name, joint\_state\_update\_schema) Update Twin Joint State ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.joint_state_schema import JointStateSchema from cyberwave.rest.models.joint_state_update_schema import JointStateUpdateSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | joint_name = 'joint_name_example' # str | joint_state_update_schema = cyberwave.rest.JointStateUpdateSchema() # JointStateUpdateSchema | try: # Update Twin Joint State api_response = api_instance.src_app_api_urdf_update_twin_joint_state(uuid, joint_name, joint_state_update_schema) print("The response of DefaultApi->src_app_api_urdf_update_twin_joint_state:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_urdf_update_twin_joint_state: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------------------------------- | ------------------------------------------------------------------------ | ----------- | ----- | | **uuid** | **str** | | | | **joint\_name** | **str** | | | | **joint\_state\_update\_schema** | [**JointStateUpdateSchema**](/api-reference/rest/JointStateUpdateSchema) | | | ### Return type [**JointStateSchema**](/api-reference/rest/JointStateSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_urdf\_update\_twin\_joint\_states** > JointStatesSchema src\_app\_api\_urdf\_update\_twin\_joint\_states(uuid, bulk\_joint\_states\_update\_schema) Update Twin Joint States ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.bulk_joint_states_update_schema import BulkJointStatesUpdateSchema from cyberwave.rest.models.joint_states_schema import JointStatesSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | bulk_joint_states_update_schema = cyberwave.rest.BulkJointStatesUpdateSchema() # BulkJointStatesUpdateSchema | try: # Update Twin Joint States api_response = api_instance.src_app_api_urdf_update_twin_joint_states(uuid, bulk_joint_states_update_schema) print("The response of DefaultApi->src_app_api_urdf_update_twin_joint_states:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_urdf_update_twin_joint_states: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | --------------------------------------- | ---------------------------------------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **bulk\_joint\_states\_update\_schema** | [**BulkJointStatesUpdateSchema**](/api-reference/rest/BulkJointStatesUpdateSchema) | | | ### Return type [**JointStatesSchema**](/api-reference/rest/JointStatesSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_urdf\_update\_urdf\_project** > URDFProjectSchema src\_app\_api\_urdf\_update\_urdf\_project(uuid, urdf\_project\_create\_schema) Update Urdf Project ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.urdf_project_create_schema import URDFProjectCreateSchema from cyberwave.rest.models.urdf_project_schema import URDFProjectSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | urdf_project_create_schema = cyberwave.rest.URDFProjectCreateSchema() # URDFProjectCreateSchema | try: # Update Urdf Project api_response = api_instance.src_app_api_urdf_update_urdf_project(uuid, urdf_project_create_schema) print("The response of DefaultApi->src_app_api_urdf_update_urdf_project:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_urdf_update_urdf_project: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | --------------------------------- | -------------------------------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **urdf\_project\_create\_schema** | [**URDFProjectCreateSchema**](/api-reference/rest/URDFProjectCreateSchema) | | | ### Return type [**URDFProjectSchema**](/api-reference/rest/URDFProjectSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_urdf\_upload\_zip\_file** > URDFProjectSchema src\_app\_api\_urdf\_upload\_zip\_file(uuid, file) Upload Zip File ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.urdf_project_schema import URDFProjectSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | file = None # bytearray | try: # Upload Zip File api_response = api_instance.src_app_api_urdf_upload_zip_file(uuid, file) print("The response of DefaultApi->src_app_api_urdf_upload_zip_file:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_urdf_upload_zip_file: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------------- | ----------- | ----- | | **uuid** | **str** | | | | **file** | **bytearray** | | | ### Return type [**URDFProjectSchema**](/api-reference/rest/URDFProjectSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: multipart/form-data * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_workflows\_activate\_workflow** > WorkflowSchema src\_app\_api\_workflows\_activate\_workflow(uuid) Activate Workflow Activate a workflow. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.workflow_schema import WorkflowSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Activate Workflow api_response = api_instance.src_app_api_workflows_activate_workflow(uuid) print("The response of DefaultApi->src_app_api_workflows_activate_workflow:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_workflows_activate_workflow: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**WorkflowSchema**](/api-reference/rest/WorkflowSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_workflows\_cancel\_workflow\_execution** > WorkflowExecutionSchema src\_app\_api\_workflows\_cancel\_workflow\_execution(execution\_uuid) Cancel Workflow Execution Cancel a running workflow execution. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.workflow_execution_schema import WorkflowExecutionSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) execution_uuid = 'execution_uuid_example' # str | try: # Cancel Workflow Execution api_response = api_instance.src_app_api_workflows_cancel_workflow_execution(execution_uuid) print("The response of DefaultApi->src_app_api_workflows_cancel_workflow_execution:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_workflows_cancel_workflow_execution: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------- | ------- | ----------- | ----- | | **execution\_uuid** | **str** | | | ### Return type [**WorkflowExecutionSchema**](/api-reference/rest/WorkflowExecutionSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_workflows\_create\_workflow** > WorkflowSchema src\_app\_api\_workflows\_create\_workflow(workflow\_create\_schema) Create Workflow Create a new workflow. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.workflow_create_schema import WorkflowCreateSchema from cyberwave.rest.models.workflow_schema import WorkflowSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) workflow_create_schema = cyberwave.rest.WorkflowCreateSchema() # WorkflowCreateSchema | try: # Create Workflow api_response = api_instance.src_app_api_workflows_create_workflow(workflow_create_schema) print("The response of DefaultApi->src_app_api_workflows_create_workflow:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_workflows_create_workflow: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ---------------------------- | -------------------------------------------------------------------- | ----------- | ----- | | **workflow\_create\_schema** | [**WorkflowCreateSchema**](/api-reference/rest/WorkflowCreateSchema) | | | ### Return type [**WorkflowSchema**](/api-reference/rest/WorkflowSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_workflows\_create\_workflow\_connection** > WorkflowConnectionSchema src\_app\_api\_workflows\_create\_workflow\_connection(uuid, workflow\_connection\_create\_schema) Create Workflow Connection Create a new connection between nodes. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.workflow_connection_create_schema import WorkflowConnectionCreateSchema from cyberwave.rest.models.workflow_connection_schema import WorkflowConnectionSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | workflow_connection_create_schema = cyberwave.rest.WorkflowConnectionCreateSchema() # WorkflowConnectionCreateSchema | try: # Create Workflow Connection api_response = api_instance.src_app_api_workflows_create_workflow_connection(uuid, workflow_connection_create_schema) print("The response of DefaultApi->src_app_api_workflows_create_workflow_connection:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_workflows_create_workflow_connection: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ---------------------------------------- | ---------------------------------------------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **workflow\_connection\_create\_schema** | [**WorkflowConnectionCreateSchema**](/api-reference/rest/WorkflowConnectionCreateSchema) | | | ### Return type [**WorkflowConnectionSchema**](/api-reference/rest/WorkflowConnectionSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_workflows\_create\_workflow\_node** > WorkflowNodeSchema src\_app\_api\_workflows\_create\_workflow\_node(uuid, workflow\_node\_create\_schema) Create Workflow Node Create a new node in a workflow. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.workflow_node_create_schema import WorkflowNodeCreateSchema from cyberwave.rest.models.workflow_node_schema import WorkflowNodeSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | workflow_node_create_schema = cyberwave.rest.WorkflowNodeCreateSchema() # WorkflowNodeCreateSchema | try: # Create Workflow Node api_response = api_instance.src_app_api_workflows_create_workflow_node(uuid, workflow_node_create_schema) print("The response of DefaultApi->src_app_api_workflows_create_workflow_node:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_workflows_create_workflow_node: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ---------------------------------- | ---------------------------------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **workflow\_node\_create\_schema** | [**WorkflowNodeCreateSchema**](/api-reference/rest/WorkflowNodeCreateSchema) | | | ### Return type [**WorkflowNodeSchema**](/api-reference/rest/WorkflowNodeSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_workflows\_deactivate\_workflow** > WorkflowSchema src\_app\_api\_workflows\_deactivate\_workflow(uuid) Deactivate Workflow Deactivate a workflow. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.workflow_schema import WorkflowSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Deactivate Workflow api_response = api_instance.src_app_api_workflows_deactivate_workflow(uuid) print("The response of DefaultApi->src_app_api_workflows_deactivate_workflow:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_workflows_deactivate_workflow: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**WorkflowSchema**](/api-reference/rest/WorkflowSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_workflows\_delete\_workflow** > src\_app\_api\_workflows\_delete\_workflow(uuid) Delete Workflow Delete a workflow. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Delete Workflow api_instance.src_app_api_workflows_delete_workflow(uuid) except Exception as e: print("Exception when calling DefaultApi->src_app_api_workflows_delete_workflow: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_workflows\_delete\_workflow\_connection** > src\_app\_api\_workflows\_delete\_workflow\_connection(uuid, connection\_uuid) Delete Workflow Connection Delete a workflow connection. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | connection_uuid = 'connection_uuid_example' # str | try: # Delete Workflow Connection api_instance.src_app_api_workflows_delete_workflow_connection(uuid, connection_uuid) except Exception as e: print("Exception when calling DefaultApi->src_app_api_workflows_delete_workflow_connection: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------------------- | ------- | ----------- | ----- | | **uuid** | **str** | | | | **connection\_uuid** | **str** | | | ### Return type void (empty response body) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_workflows\_delete\_workflow\_node** > src\_app\_api\_workflows\_delete\_workflow\_node(uuid, node\_uuid) Delete Workflow Node Delete a workflow node. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | node_uuid = 'node_uuid_example' # str | try: # Delete Workflow Node api_instance.src_app_api_workflows_delete_workflow_node(uuid, node_uuid) except Exception as e: print("Exception when calling DefaultApi->src_app_api_workflows_delete_workflow_node: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------------- | ------- | ----------- | ----- | | **uuid** | **str** | | | | **node\_uuid** | **str** | | | ### Return type void (empty response body) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_workflows\_edge\_sync\_workflows** > Dict\[str, object] src\_app\_api\_workflows\_edge\_sync\_workflows(twin\_uuid) Edge Sync Workflows Sync workflows for an edge node. Returns active workflows with camera\_frame triggers for the specified twin, along with resolved plugin requirements from MLModel metadata. Edge nodes call this to know: 1. Which workflows to run 2. Which plugins/models to install 3. What events to emit ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) twin_uuid = 'twin_uuid_example' # str | try: # Edge Sync Workflows api_response = api_instance.src_app_api_workflows_edge_sync_workflows(twin_uuid) print("The response of DefaultApi->src_app_api_workflows_edge_sync_workflows:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_workflows_edge_sync_workflows: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------------- | ------- | ----------- | ----- | | **twin\_uuid** | **str** | | | ### Return type **Dict\[str, object]** ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_workflows\_execute\_workflow** > WorkflowExecutionSchema src\_app\_api\_workflows\_execute\_workflow(uuid, workflow\_execute\_schema) Execute Workflow Manually trigger a workflow execution. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.workflow_execute_schema import WorkflowExecuteSchema from cyberwave.rest.models.workflow_execution_schema import WorkflowExecutionSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | workflow_execute_schema = cyberwave.rest.WorkflowExecuteSchema() # WorkflowExecuteSchema | try: # Execute Workflow api_response = api_instance.src_app_api_workflows_execute_workflow(uuid, workflow_execute_schema) print("The response of DefaultApi->src_app_api_workflows_execute_workflow:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_workflows_execute_workflow: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ----------------------------- | ---------------------------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **workflow\_execute\_schema** | [**WorkflowExecuteSchema**](/api-reference/rest/WorkflowExecuteSchema) | | | ### Return type [**WorkflowExecutionSchema**](/api-reference/rest/WorkflowExecutionSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_workflows\_get\_execution\_by\_uuid** > WorkflowExecutionSchema src\_app\_api\_workflows\_get\_execution\_by\_uuid(execution\_uuid) Get Execution By Uuid Get details of a specific execution by its UUID, including node executions. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.workflow_execution_schema import WorkflowExecutionSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) execution_uuid = 'execution_uuid_example' # str | try: # Get Execution By Uuid api_response = api_instance.src_app_api_workflows_get_execution_by_uuid(execution_uuid) print("The response of DefaultApi->src_app_api_workflows_get_execution_by_uuid:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_workflows_get_execution_by_uuid: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------- | ------- | ----------- | ----- | | **execution\_uuid** | **str** | | | ### Return type [**WorkflowExecutionSchema**](/api-reference/rest/WorkflowExecutionSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_workflows\_get\_node\_schema** > Dict\[str, object] src\_app\_api\_workflows\_get\_node\_schema(node\_type, node\_subtype=node\_subtype) Get Node Schema Get the schema for a specific node type. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) node_type = 'node_type_example' # str | node_subtype = 'node_subtype_example' # str | (optional) try: # Get Node Schema api_response = api_instance.src_app_api_workflows_get_node_schema(node_type, node_subtype=node_subtype) print("The response of DefaultApi->src_app_api_workflows_get_node_schema:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_workflows_get_node_schema: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ----------------- | ------- | ----------- | ----------- | | **node\_type** | **str** | | | | **node\_subtype** | **str** | | \[optional] | ### Return type **Dict\[str, object]** ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_workflows\_get\_node\_schemas** > List\[Dict\[str, object]] src\_app\_api\_workflows\_get\_node\_schemas() Get Node Schemas Get all available node type schemas with their input/output definitions. This is used by the frontend to display available node types and their I/O. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) try: # Get Node Schemas api_response = api_instance.src_app_api_workflows_get_node_schemas() print("The response of DefaultApi->src_app_api_workflows_get_node_schemas:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_workflows_get_node_schemas: %s\n" % e) ``` ### Parameters This endpoint does not need any parameter. ### Return type **List\[Dict\[str, object]]** ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_workflows\_get\_workflow** > WorkflowSchema src\_app\_api\_workflows\_get\_workflow(uuid) Get Workflow Get a specific workflow with its nodes and connections. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.workflow_schema import WorkflowSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Workflow api_response = api_instance.src_app_api_workflows_get_workflow(uuid) print("The response of DefaultApi->src_app_api_workflows_get_workflow:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_workflows_get_workflow: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**WorkflowSchema**](/api-reference/rest/WorkflowSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_workflows\_get\_workflow\_execution** > WorkflowExecutionSchema src\_app\_api\_workflows\_get\_workflow\_execution(uuid, execution\_uuid) Get Workflow Execution Get a specific execution for a workflow with full details including node executions. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.workflow_execution_schema import WorkflowExecutionSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | execution_uuid = 'execution_uuid_example' # str | try: # Get Workflow Execution api_response = api_instance.src_app_api_workflows_get_workflow_execution(uuid, execution_uuid) print("The response of DefaultApi->src_app_api_workflows_get_workflow_execution:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_workflows_get_workflow_execution: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------- | ------- | ----------- | ----- | | **uuid** | **str** | | | | **execution\_uuid** | **str** | | | ### Return type [**WorkflowExecutionSchema**](/api-reference/rest/WorkflowExecutionSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_workflows\_get\_workflow\_node** > WorkflowNodeSchema src\_app\_api\_workflows\_get\_workflow\_node(uuid, node\_uuid) Get Workflow Node Get a specific node. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.workflow_node_schema import WorkflowNodeSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | node_uuid = 'node_uuid_example' # str | try: # Get Workflow Node api_response = api_instance.src_app_api_workflows_get_workflow_node(uuid, node_uuid) print("The response of DefaultApi->src_app_api_workflows_get_workflow_node:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_workflows_get_workflow_node: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------------- | ------- | ----------- | ----- | | **uuid** | **str** | | | | **node\_uuid** | **str** | | | ### Return type [**WorkflowNodeSchema**](/api-reference/rest/WorkflowNodeSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_workflows\_list\_workflow\_connections** > List\[WorkflowConnectionSchema] src\_app\_api\_workflows\_list\_workflow\_connections(uuid) List Workflow Connections List all connections in a workflow. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.workflow_connection_schema import WorkflowConnectionSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # List Workflow Connections api_response = api_instance.src_app_api_workflows_list_workflow_connections(uuid) print("The response of DefaultApi->src_app_api_workflows_list_workflow_connections:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_workflows_list_workflow_connections: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**List\[WorkflowConnectionSchema\]**](/api-reference/rest/WorkflowConnectionSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_workflows\_list\_workflow\_executions** > List\[WorkflowExecutionSchema] src\_app\_api\_workflows\_list\_workflow\_executions(uuid) List Workflow Executions List all executions for a workflow. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.workflow_execution_schema import WorkflowExecutionSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # List Workflow Executions api_response = api_instance.src_app_api_workflows_list_workflow_executions(uuid) print("The response of DefaultApi->src_app_api_workflows_list_workflow_executions:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_workflows_list_workflow_executions: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**List\[WorkflowExecutionSchema\]**](/api-reference/rest/WorkflowExecutionSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_workflows\_list\_workflow\_nodes** > List\[WorkflowNodeSchema] src\_app\_api\_workflows\_list\_workflow\_nodes(uuid) List Workflow Nodes List all nodes in a workflow. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.workflow_node_schema import WorkflowNodeSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # List Workflow Nodes api_response = api_instance.src_app_api_workflows_list_workflow_nodes(uuid) print("The response of DefaultApi->src_app_api_workflows_list_workflow_nodes:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_workflows_list_workflow_nodes: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**List\[WorkflowNodeSchema\]**](/api-reference/rest/WorkflowNodeSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_workflows\_list\_workflows** > List\[WorkflowSchema] src\_app\_api\_workflows\_list\_workflows() List Workflows List all workflows for the authenticated user's workspace. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.workflow_schema import WorkflowSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) try: # List Workflows api_response = api_instance.src_app_api_workflows_list_workflows() print("The response of DefaultApi->src_app_api_workflows_list_workflows:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_workflows_list_workflows: %s\n" % e) ``` ### Parameters This endpoint does not need any parameter. ### Return type [**List\[WorkflowSchema\]**](/api-reference/rest/WorkflowSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_workflows\_update\_workflow** > WorkflowSchema src\_app\_api\_workflows\_update\_workflow(uuid, workflow\_update\_schema) Update Workflow Update a workflow. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.workflow_schema import WorkflowSchema from cyberwave.rest.models.workflow_update_schema import WorkflowUpdateSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | workflow_update_schema = cyberwave.rest.WorkflowUpdateSchema() # WorkflowUpdateSchema | try: # Update Workflow api_response = api_instance.src_app_api_workflows_update_workflow(uuid, workflow_update_schema) print("The response of DefaultApi->src_app_api_workflows_update_workflow:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_workflows_update_workflow: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ---------------------------- | -------------------------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **workflow\_update\_schema** | [**WorkflowUpdateSchema**](/api-reference/rest/WorkflowUpdateSchema) | | | ### Return type [**WorkflowSchema**](/api-reference/rest/WorkflowSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_workflows\_update\_workflow\_node** > WorkflowNodeSchema src\_app\_api\_workflows\_update\_workflow\_node(uuid, node\_uuid, workflow\_node\_update\_schema) Update Workflow Node Update a workflow node. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.workflow_node_schema import WorkflowNodeSchema from cyberwave.rest.models.workflow_node_update_schema import WorkflowNodeUpdateSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | node_uuid = 'node_uuid_example' # str | workflow_node_update_schema = cyberwave.rest.WorkflowNodeUpdateSchema() # WorkflowNodeUpdateSchema | try: # Update Workflow Node api_response = api_instance.src_app_api_workflows_update_workflow_node(uuid, node_uuid, workflow_node_update_schema) print("The response of DefaultApi->src_app_api_workflows_update_workflow_node:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_workflows_update_workflow_node: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ---------------------------------- | ---------------------------------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **node\_uuid** | **str** | | | | **workflow\_node\_update\_schema** | [**WorkflowNodeUpdateSchema**](/api-reference/rest/WorkflowNodeUpdateSchema) | | | ### Return type [**WorkflowNodeSchema**](/api-reference/rest/WorkflowNodeSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_app\_api\_workflows\_validate\_node\_inputs** > Dict\[str, object] src\_app\_api\_workflows\_validate\_node\_inputs(node\_uuid) Validate Node Inputs Validate that a node's input mappings are complete and correct. Returns validation status and any error messages. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) node_uuid = 'node_uuid_example' # str | try: # Validate Node Inputs api_response = api_instance.src_app_api_workflows_validate_node_inputs(node_uuid) print("The response of DefaultApi->src_app_api_workflows_validate_node_inputs:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_workflows_validate_node_inputs: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------------- | ------- | ----------- | ----- | | **node\_uuid** | **str** | | | ### Return type **Dict\[str, object]** ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_users\_api\_organizations\_add\_organization\_member\_by\_email** > AddMemberByEmailResponse src\_users\_api\_organizations\_add\_organization\_member\_by\_email(uuid, add\_member\_by\_email\_request) Add Organization Member By Email Add a member to an organization by email address. If user exists in Cyberwave, add them to the organization. If user doesn't exist, return user\_exists=False so frontend can show contact link. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.add_member_by_email_request import AddMemberByEmailRequest from cyberwave.rest.models.add_member_by_email_response import AddMemberByEmailResponse from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | add_member_by_email_request = cyberwave.rest.AddMemberByEmailRequest() # AddMemberByEmailRequest | try: # Add Organization Member By Email api_response = api_instance.src_users_api_organizations_add_organization_member_by_email(uuid, add_member_by_email_request) print("The response of DefaultApi->src_users_api_organizations_add_organization_member_by_email:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_users_api_organizations_add_organization_member_by_email: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ----------------------------------- | -------------------------------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **add\_member\_by\_email\_request** | [**AddMemberByEmailRequest**](/api-reference/rest/AddMemberByEmailRequest) | | | ### Return type [**AddMemberByEmailResponse**](/api-reference/rest/AddMemberByEmailResponse) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_users\_api\_organizations\_create\_organization** > Dict\[str, OrganizationSchema] src\_users\_api\_organizations\_create\_organization(organization\_create\_schema) Create Organization Create a new organization ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.organization_create_schema import OrganizationCreateSchema from cyberwave.rest.models.organization_schema import OrganizationSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) organization_create_schema = cyberwave.rest.OrganizationCreateSchema() # OrganizationCreateSchema | try: # Create Organization api_response = api_instance.src_users_api_organizations_create_organization(organization_create_schema) print("The response of DefaultApi->src_users_api_organizations_create_organization:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_users_api_organizations_create_organization: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------------------------------- | ---------------------------------------------------------------------------- | ----------- | ----- | | **organization\_create\_schema** | [**OrganizationCreateSchema**](/api-reference/rest/OrganizationCreateSchema) | | | ### Return type [**Dict\[str, OrganizationSchema\]**](/api-reference/rest/OrganizationSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_users\_api\_organizations\_delete\_organization** > src\_users\_api\_organizations\_delete\_organization(uuid) Delete Organization Delete an organization ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Delete Organization api_instance.src_users_api_organizations_delete_organization(uuid) except Exception as e: print("Exception when calling DefaultApi->src_users_api_organizations_delete_organization: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_users\_api\_organizations\_get\_organization** > Dict\[str, OrganizationSchema] src\_users\_api\_organizations\_get\_organization(uuid) Get Organization Retrieve an organization ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.organization_schema import OrganizationSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Organization api_response = api_instance.src_users_api_organizations_get_organization(uuid) print("The response of DefaultApi->src_users_api_organizations_get_organization:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_users_api_organizations_get_organization: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**Dict\[str, OrganizationSchema\]**](/api-reference/rest/OrganizationSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_users\_api\_organizations\_get\_organization\_by\_slug** > Dict\[str, OrganizationSchema] src\_users\_api\_organizations\_get\_organization\_by\_slug(slug) Get Organization By Slug ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.organization_schema import OrganizationSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) slug = 'slug_example' # str | try: # Get Organization By Slug api_response = api_instance.src_users_api_organizations_get_organization_by_slug(slug) print("The response of DefaultApi->src_users_api_organizations_get_organization_by_slug:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_users_api_organizations_get_organization_by_slug: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **slug** | **str** | | | ### Return type [**Dict\[str, OrganizationSchema\]**](/api-reference/rest/OrganizationSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_users\_api\_organizations\_list\_organization\_members** > OrgMembersResponse src\_users\_api\_organizations\_list\_organization\_members(uuid) List Organization Members List all members of an organization ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.org_members_response import OrgMembersResponse from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # List Organization Members api_response = api_instance.src_users_api_organizations_list_organization_members(uuid) print("The response of DefaultApi->src_users_api_organizations_list_organization_members:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_users_api_organizations_list_organization_members: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**OrgMembersResponse**](/api-reference/rest/OrgMembersResponse) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_users\_api\_organizations\_list\_organization\_workspaces** > Dict\[str, List\[OrganizationWorkspaceSchema]] src\_users\_api\_organizations\_list\_organization\_workspaces(uuid) List Organization Workspaces List all workspaces in an organization for authorized org users. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.organization_workspace_schema import OrganizationWorkspaceSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # List Organization Workspaces api_response = api_instance.src_users_api_organizations_list_organization_workspaces(uuid) print("The response of DefaultApi->src_users_api_organizations_list_organization_workspaces:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_users_api_organizations_list_organization_workspaces: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type **Dict\[str, List\[OrganizationWorkspaceSchema]]** ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_users\_api\_organizations\_list\_organizations** > Dict\[str, List\[OrganizationSchema]] src\_users\_api\_organizations\_list\_organizations() List Organizations List all organizations ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.organization_schema import OrganizationSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) try: # List Organizations api_response = api_instance.src_users_api_organizations_list_organizations() print("The response of DefaultApi->src_users_api_organizations_list_organizations:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_users_api_organizations_list_organizations: %s\n" % e) ``` ### Parameters This endpoint does not need any parameter. ### Return type **Dict\[str, List\[OrganizationSchema]]** ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_users\_api\_organizations\_remove\_organization\_member** > src\_users\_api\_organizations\_remove\_organization\_member(uuid, user\_uuid) Remove Organization Member Remove a member from an organization ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | user_uuid = 'user_uuid_example' # str | try: # Remove Organization Member api_instance.src_users_api_organizations_remove_organization_member(uuid, user_uuid) except Exception as e: print("Exception when calling DefaultApi->src_users_api_organizations_remove_organization_member: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------------- | ------- | ----------- | ----- | | **uuid** | **str** | | | | **user\_uuid** | **str** | | | ### Return type void (empty response body) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_users\_api\_organizations\_update\_organization** > Dict\[str, OrganizationSchema] src\_users\_api\_organizations\_update\_organization(uuid, organization\_update\_schema) Update Organization Update an organization ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.organization_schema import OrganizationSchema from cyberwave.rest.models.organization_update_schema import OrganizationUpdateSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | organization_update_schema = cyberwave.rest.OrganizationUpdateSchema() # OrganizationUpdateSchema | try: # Update Organization api_response = api_instance.src_users_api_organizations_update_organization(uuid, organization_update_schema) print("The response of DefaultApi->src_users_api_organizations_update_organization:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_users_api_organizations_update_organization: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------------------------------- | ---------------------------------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **organization\_update\_schema** | [**OrganizationUpdateSchema**](/api-reference/rest/OrganizationUpdateSchema) | | | ### Return type [**Dict\[str, OrganizationSchema\]**](/api-reference/rest/OrganizationSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_users\_api\_organizations\_update\_organization\_member\_role** > UpdateMemberRoleResponse src\_users\_api\_organizations\_update\_organization\_member\_role(uuid, user\_uuid, update\_member\_role\_request) Update Organization Member Role Update the role of an organization member. Only organization owner or admin can update roles. Cannot change the role of the organization owner. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.update_member_role_request import UpdateMemberRoleRequest from cyberwave.rest.models.update_member_role_response import UpdateMemberRoleResponse from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | user_uuid = 'user_uuid_example' # str | update_member_role_request = cyberwave.rest.UpdateMemberRoleRequest() # UpdateMemberRoleRequest | try: # Update Organization Member Role api_response = api_instance.src_users_api_organizations_update_organization_member_role(uuid, user_uuid, update_member_role_request) print("The response of DefaultApi->src_users_api_organizations_update_organization_member_role:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_users_api_organizations_update_organization_member_role: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | --------------------------------- | -------------------------------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **user\_uuid** | **str** | | | | **update\_member\_role\_request** | [**UpdateMemberRoleRequest**](/api-reference/rest/UpdateMemberRoleRequest) | | | ### Return type [**UpdateMemberRoleResponse**](/api-reference/rest/UpdateMemberRoleResponse) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_users\_api\_plans\_get\_plan** > PlanSchema src\_users\_api\_plans\_get\_plan() Get Plan Get the plan for the current user ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.plan_schema import PlanSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) try: # Get Plan api_response = api_instance.src_users_api_plans_get_plan() print("The response of DefaultApi->src_users_api_plans_get_plan:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_users_api_plans_get_plan: %s\n" % e) ``` ### Parameters This endpoint does not need any parameter. ### Return type [**PlanSchema**](/api-reference/rest/PlanSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_users\_api\_workspaces\_add\_workspace\_member\_by\_email** > AddMemberByEmailResponse src\_users\_api\_workspaces\_add\_workspace\_member\_by\_email(uuid, add\_member\_by\_email\_request) Add Workspace Member By Email Add a member to a workspace by email address. If user exists in Cyberwave, add them to the workspace. If user doesn't exist, return user\_exists=False so frontend can show contact link. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.add_member_by_email_request import AddMemberByEmailRequest from cyberwave.rest.models.add_member_by_email_response import AddMemberByEmailResponse from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | add_member_by_email_request = cyberwave.rest.AddMemberByEmailRequest() # AddMemberByEmailRequest | try: # Add Workspace Member By Email api_response = api_instance.src_users_api_workspaces_add_workspace_member_by_email(uuid, add_member_by_email_request) print("The response of DefaultApi->src_users_api_workspaces_add_workspace_member_by_email:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_users_api_workspaces_add_workspace_member_by_email: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ----------------------------------- | -------------------------------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **add\_member\_by\_email\_request** | [**AddMemberByEmailRequest**](/api-reference/rest/AddMemberByEmailRequest) | | | ### Return type [**AddMemberByEmailResponse**](/api-reference/rest/AddMemberByEmailResponse) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_users\_api\_workspaces\_check\_workspace\_slug** > SlugAvailabilitySchema src\_users\_api\_workspaces\_check\_workspace\_slug(slug) Check Workspace Slug Check if a workspace slug is available ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.slug_availability_schema import SlugAvailabilitySchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) slug = 'slug_example' # str | try: # Check Workspace Slug api_response = api_instance.src_users_api_workspaces_check_workspace_slug(slug) print("The response of DefaultApi->src_users_api_workspaces_check_workspace_slug:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_users_api_workspaces_check_workspace_slug: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **slug** | **str** | | | ### Return type [**SlugAvailabilitySchema**](/api-reference/rest/SlugAvailabilitySchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_users\_api\_workspaces\_create\_workspace** > WorkspaceSchema src\_users\_api\_workspaces\_create\_workspace(workspace\_create\_schema=workspace\_create\_schema) Create Workspace Create a workspace ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.workspace_create_schema import WorkspaceCreateSchema from cyberwave.rest.models.workspace_schema import WorkspaceSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) workspace_create_schema = cyberwave.rest.WorkspaceCreateSchema() # WorkspaceCreateSchema | (optional) try: # Create Workspace api_response = api_instance.src_users_api_workspaces_create_workspace(workspace_create_schema=workspace_create_schema) print("The response of DefaultApi->src_users_api_workspaces_create_workspace:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_users_api_workspaces_create_workspace: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ----------------------------- | ---------------------------------------------------------------------- | ----------- | ----------- | | **workspace\_create\_schema** | [**WorkspaceCreateSchema**](/api-reference/rest/WorkspaceCreateSchema) | | \[optional] | ### Return type [**WorkspaceSchema**](/api-reference/rest/WorkspaceSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_users\_api\_workspaces\_delete\_workspace** > src\_users\_api\_workspaces\_delete\_workspace(uuid) Delete Workspace Delete a workspace ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Delete Workspace api_instance.src_users_api_workspaces_delete_workspace(uuid) except Exception as e: print("Exception when calling DefaultApi->src_users_api_workspaces_delete_workspace: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_users\_api\_workspaces\_get\_default\_workspace** > WorkspaceSchema src\_users\_api\_workspaces\_get\_default\_workspace() Get Default Workspace Get the user's default workspace ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.workspace_schema import WorkspaceSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) try: # Get Default Workspace api_response = api_instance.src_users_api_workspaces_get_default_workspace() print("The response of DefaultApi->src_users_api_workspaces_get_default_workspace:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_users_api_workspaces_get_default_workspace: %s\n" % e) ``` ### Parameters This endpoint does not need any parameter. ### Return type [**WorkspaceSchema**](/api-reference/rest/WorkspaceSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_users\_api\_workspaces\_get\_vendor\_description** > VendorDescriptionSchema src\_users\_api\_workspaces\_get\_vendor\_description(slug) Get Vendor Description Get vendor description by slug (no authentication required) ### Example ```python theme={null} import cyberwave.rest from cyberwave.rest.models.vendor_description_schema import VendorDescriptionSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) slug = 'slug_example' # str | try: # Get Vendor Description api_response = api_instance.src_users_api_workspaces_get_vendor_description(slug) print("The response of DefaultApi->src_users_api_workspaces_get_vendor_description:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_users_api_workspaces_get_vendor_description: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **slug** | **str** | | | ### Return type [**VendorDescriptionSchema**](/api-reference/rest/VendorDescriptionSchema) ### Authorization No authorization required ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_users\_api\_workspaces\_get\_workspace** > WorkspaceResponseSchema src\_users\_api\_workspaces\_get\_workspace(uuid) Get Workspace Retrieve a workspace ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.workspace_response_schema import WorkspaceResponseSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Workspace api_response = api_instance.src_users_api_workspaces_get_workspace(uuid) print("The response of DefaultApi->src_users_api_workspaces_get_workspace:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_users_api_workspaces_get_workspace: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**WorkspaceResponseSchema**](/api-reference/rest/WorkspaceResponseSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_users\_api\_workspaces\_get\_workspace\_by\_slug** > WorkspaceSchema src\_users\_api\_workspaces\_get\_workspace\_by\_slug(slug) Get Workspace By Slug Retrieve a workspace by slug (public endpoint) ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.workspace_schema import WorkspaceSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) slug = 'slug_example' # str | try: # Get Workspace By Slug api_response = api_instance.src_users_api_workspaces_get_workspace_by_slug(slug) print("The response of DefaultApi->src_users_api_workspaces_get_workspace_by_slug:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_users_api_workspaces_get_workspace_by_slug: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **slug** | **str** | | | ### Return type [**WorkspaceSchema**](/api-reference/rest/WorkspaceSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_users\_api\_workspaces\_leave\_team** > src\_users\_api\_workspaces\_leave\_team(team\_uuid, uuid) Leave Team Leave a team ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) team_uuid = 'team_uuid_example' # str | uuid = 'uuid_example' # str | try: # Leave Team api_instance.src_users_api_workspaces_leave_team(team_uuid, uuid) except Exception as e: print("Exception when calling DefaultApi->src_users_api_workspaces_leave_team: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------------- | ------- | ----------- | ----- | | **team\_uuid** | **str** | | | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_users\_api\_workspaces\_list\_team\_members** > List\[TeamMemberResponse] src\_users\_api\_workspaces\_list\_team\_members(team\_uuid) List Team Members Get the members of a team ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.team_member_response import TeamMemberResponse from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) team_uuid = 'team_uuid_example' # str | try: # List Team Members api_response = api_instance.src_users_api_workspaces_list_team_members(team_uuid) print("The response of DefaultApi->src_users_api_workspaces_list_team_members:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_users_api_workspaces_list_team_members: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------------- | ------- | ----------- | ----- | | **team\_uuid** | **str** | | | ### Return type [**List\[TeamMemberResponse\]**](/api-reference/rest/TeamMemberResponse) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_users\_api\_workspaces\_list\_workspaces** > List\[WorkspaceSchema] src\_users\_api\_workspaces\_list\_workspaces() List Workspaces List all workspaces ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.workspace_schema import WorkspaceSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) try: # List Workspaces api_response = api_instance.src_users_api_workspaces_list_workspaces() print("The response of DefaultApi->src_users_api_workspaces_list_workspaces:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_users_api_workspaces_list_workspaces: %s\n" % e) ``` ### Parameters This endpoint does not need any parameter. ### Return type [**List\[WorkspaceSchema\]**](/api-reference/rest/WorkspaceSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_users\_api\_workspaces\_remove\_team\_member** > src\_users\_api\_workspaces\_remove\_team\_member(team\_uuid, uuid) Remove Team Member Delete a member from a team ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) team_uuid = 'team_uuid_example' # str | uuid = 'uuid_example' # str | try: # Remove Team Member api_instance.src_users_api_workspaces_remove_team_member(team_uuid, uuid) except Exception as e: print("Exception when calling DefaultApi->src_users_api_workspaces_remove_team_member: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------------- | ------- | ----------- | ----- | | **team\_uuid** | **str** | | | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_users\_api\_workspaces\_remove\_workspace\_member** > RemoveMemberResponse src\_users\_api\_workspaces\_remove\_workspace\_member(uuid, user\_uuid) Remove Workspace Member Remove a member from a workspace. Only workspace owner or organization owner can remove members. Cannot remove the workspace owner or the last member. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.remove_member_response import RemoveMemberResponse from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | user_uuid = 'user_uuid_example' # str | try: # Remove Workspace Member api_response = api_instance.src_users_api_workspaces_remove_workspace_member(uuid, user_uuid) print("The response of DefaultApi->src_users_api_workspaces_remove_workspace_member:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_users_api_workspaces_remove_workspace_member: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------------- | ------- | ----------- | ----- | | **uuid** | **str** | | | | **user\_uuid** | **str** | | | ### Return type [**RemoveMemberResponse**](/api-reference/rest/RemoveMemberResponse) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_users\_api\_workspaces\_set\_default\_workspace** > src\_users\_api\_workspaces\_set\_default\_workspace(workspace\_uuid) Set Default Workspace Set the user's default workspace ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) workspace_uuid = 'workspace_uuid_example' # str | try: # Set Default Workspace api_instance.src_users_api_workspaces_set_default_workspace(workspace_uuid) except Exception as e: print("Exception when calling DefaultApi->src_users_api_workspaces_set_default_workspace: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------- | ------- | ----------- | ----- | | **workspace\_uuid** | **str** | | | ### Return type void (empty response body) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_users\_api\_workspaces\_update\_workspace** > WorkspaceSchema src\_users\_api\_workspaces\_update\_workspace(uuid, workspace\_update\_schema) Update Workspace Update a workspace ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.workspace_schema import WorkspaceSchema from cyberwave.rest.models.workspace_update_schema import WorkspaceUpdateSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | workspace_update_schema = cyberwave.rest.WorkspaceUpdateSchema() # WorkspaceUpdateSchema | try: # Update Workspace api_response = api_instance.src_users_api_workspaces_update_workspace(uuid, workspace_update_schema) print("The response of DefaultApi->src_users_api_workspaces_update_workspace:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_users_api_workspaces_update_workspace: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ----------------------------- | ---------------------------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **workspace\_update\_schema** | [**WorkspaceUpdateSchema**](/api-reference/rest/WorkspaceUpdateSchema) | | | ### Return type [**WorkspaceSchema**](/api-reference/rest/WorkspaceSchema) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | # **src\_users\_api\_workspaces\_update\_workspace\_member\_role** > UpdateMemberRoleResponse src\_users\_api\_workspaces\_update\_workspace\_member\_role(uuid, user\_uuid, update\_member\_role\_request) Update Workspace Member Role Update the role of a workspace member. Only workspace owner or organization owner/admin can update roles. Cannot change the role of the workspace owner. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.update_member_role_request import UpdateMemberRoleRequest from cyberwave.rest.models.update_member_role_response import UpdateMemberRoleResponse from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | user_uuid = 'user_uuid_example' # str | update_member_role_request = cyberwave.rest.UpdateMemberRoleRequest() # UpdateMemberRoleRequest | try: # Update Workspace Member Role api_response = api_instance.src_users_api_workspaces_update_workspace_member_role(uuid, user_uuid, update_member_role_request) print("The response of DefaultApi->src_users_api_workspaces_update_workspace_member_role:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_users_api_workspaces_update_workspace_member_role: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | --------------------------------- | -------------------------------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **user\_uuid** | **str** | | | | **update\_member\_role\_request** | [**UpdateMemberRoleRequest**](/api-reference/rest/UpdateMemberRoleRequest) | | | ### Return type [**UpdateMemberRoleResponse**](/api-reference/rest/UpdateMemberRoleResponse) ### Authorization CustomTokenAuthentication ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - |