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