cyberwave.rest.DefaultApi

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):

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

Return type

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):

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):

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):

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

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):

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

Return type

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):

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]

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):

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

Return type

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):

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

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):

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

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):

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

Return type

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):

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):

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

Return type

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):

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):

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

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):

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]

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):

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

Return type

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):

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

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):

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):

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

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):

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

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):

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]

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):

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

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):

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

Return type

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):

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

Return type

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):

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]

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):

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

Return type

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):

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

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):

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):

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

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):

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

Return type

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):

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):

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

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):

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]

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):

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

Return type

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):

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):

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

Return type

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):

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):

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		[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):

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

Return type

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

Return type

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[]

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[]

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):

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

Return type

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):

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):

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):

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):

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):

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

Return type

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):

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

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):

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):

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):

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):

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):

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):

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):

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):

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):

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):

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

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):

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):

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]

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):

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):

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):

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):

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):

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):

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

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):

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	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):

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	Notes
uuid	str
file	bytearray
replace_existing	bool	[optional] [default to False]

Return type

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):

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	Notes
uuid	str
file	bytearray
replace_existing	bool	[optional] [default to False]

Return type

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):

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	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

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):

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):

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]

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):

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	Notes
uuid	str
status	str	[optional]
twin_uuid	str	[optional]
limit	int	[optional] [default to 100]

Return type

List[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):

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]

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):

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	Notes
uuid	str
status	str	[optional]
twin_uuid	str	[optional]
limit	int	[optional] [default to 100]

Return type

List[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):

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]

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:

Discover all twins in the environment
Find all sessions for each twin
Queue recording generation tasks for each session

Returns information about queued tasks.

Example

Api Key Authentication (CustomTokenAuthentication):

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):

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):

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):

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

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):

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):

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):

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):

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

Return type

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):

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

Return type

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):

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

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):

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

Return type

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):

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

Return type

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):

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):

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

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):

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):

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]

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):

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

Return type

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):

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

Return type

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):

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	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

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):

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

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):

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]

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):

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):

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):

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

Return type

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):

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):

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

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):

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]

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):

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

Return type

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):

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

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):

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

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):

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

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):

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

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):

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

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):

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	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	[optional]
file	bytearray	[optional]

Return type

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):

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):

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):

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	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	[optional]
file	bytearray	[optional]

Return type

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):

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

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):

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):

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]

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):

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]

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):

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]

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):

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

Return type

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):

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

Return type

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):

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):

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

Return type

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):

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):

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

Return type

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):

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

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):

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

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):

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	Notes
twin_uuid	str
uuid	str
status	str	[optional]
limit	int	[optional] [default to 50]

Return type

List[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):

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]

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):

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

Return type

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):

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):

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

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):

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):

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]

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):

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

Return type

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):

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

Return type

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):

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:

Export the trained model weights
Create a new ControllerPolicy (type: mlmodel) with the trained model
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):

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

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):

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]

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):

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

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):

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]

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):

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

Return type

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):

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

Return type

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):

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

Return type

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):

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

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):

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):

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

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):

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

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):

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

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):

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):

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]

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):

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

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):

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

Return type

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):

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

Return type

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):

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

Return type

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):

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

Return type

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):

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):

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

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):

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]

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):

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

Return type

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):

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):

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

Return type

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):

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):

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

Return type

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):

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

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):

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

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):

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	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]

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):

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]

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):

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

Return type

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):

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

Return type

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):

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):

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

Return type

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):

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

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):

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

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):

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

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):

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

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):

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]

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):

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	Notes
uuid	str
limit	int	[optional] [default to 100]
offset	int	[optional] [default to 0]

Return type

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):

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):

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):

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):

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	Notes
uuid	str
start	str	[optional]
end	str	[optional]
limit	int	[optional] [default to 100]

Return type

List[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):

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

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=<api_url>/twins/{uuid}/notebook.ipynb

Example

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):

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]

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):

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]

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": <any json>}

Example

Api Key Authentication (CustomTokenAuthentication):

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:

Validate and associate the map with the twin.
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).
Save the transform into environment.settings.navigation.
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):

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

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):

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]

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:

{
    "op": "add" | "replace",
    "path": "/sensors/0/parameters/id",
    "value": "my_camera"
}

Returns:

{ "schema": "<updated schema>", "updated": { "op": "...", "path": "..." } }

Example

Api Key Authentication (CustomTokenAuthentication):

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

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):

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):

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

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):

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

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):

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

Return type

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):

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

Return type

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):

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

Return type

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):

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

Return type

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):

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):

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

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):

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

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):

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

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):

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]

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):

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

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):

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):

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

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):

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]

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):

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

Return type

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):

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

Return type

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):

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

Return type

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):

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

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):

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

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):

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

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):

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

Return type

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):

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

Return type

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):

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

Return type

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):

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

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):

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):

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):

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:

Which workflows to run
Which plugins/models to install
What events to emit

Example

Api Key Authentication (CustomTokenAuthentication):

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):

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

Return type

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):

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

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):

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):

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):

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

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):

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

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):

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

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):

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]

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):

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]

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):

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]

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):

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]

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):

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

Return type

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):

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

Return type

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):

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):

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

Return type

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):

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

Return type

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):

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):

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

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):

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

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):

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

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):

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):

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):

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):

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

Return type

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):

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

Return type

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):

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

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):

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

Return type

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):

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

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):

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		[optional]

Return type

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):

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):

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

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

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

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):

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

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):

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

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):

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):

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]

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):

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]

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):

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):

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

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):

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):

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

Return type