_events_ = ['inform_error', 'authorize_done', 'create_session_done', 'query_profile_done', 'load_unload_profile_done',

'save_profile_done', 'get_mc_active_action_done','mc_brainmap_done', 'mc_action_sensitivity_done',

'mc_training_threshold_done', 'create_record_done', 'stop_record_done','warn_cortex_stop_all_sub',

'warn_record_post_processing_done', 'query_records_done', 'request_download_records_done',

'inject_marker_done', 'update_marker_done', 'export_record_done', 'new_data_labels',

'new_com_data', 'new_fe_data', 'new_eeg_data', 'new_mot_data', 'new_dev_data',

'new_met_data', 'new_pow_data', 'new_sys_data', 'sync_with_headset_clock_done']

def __init__(self, client_id, client_secret, debug_mode=False, **kwargs):

"""

self.session_id = ''

self.headset_id = ''

self.debug = debug_mode

self.debit = 10

self.license = ''

self.isHeadsetConnected = False

self.auto_create_session = True

if client_id == '':

raise ValueError('Empty your_app_client_id. Please fill in your_app_client_id before running the example.')

else:

self.client_id = client_id

if client_secret == '':

raise ValueError('Empty your_app_client_secret. Please fill in your_app_client_secret before running the example.')

else:

self.client_secret = client_secret

for key, value in kwargs.items():

print('init {0} - {1}'.format(key, value))

if key == 'license':

self.license = value

elif key == 'debit':

self.debit = value

elif key == 'headset_id':

self.headset_id = value

elif key == 'auto_create_session':

self.auto_create_session = value

def open(self):

url = "wss://localhost:6868"

# websocket.enableTrace(True)

self.ws = websocket.WebSocketApp(url,

on_message=self.on_message,

on_open = self.on_open,

on_error=self.on_error,

on_close=self.on_close)

thread_name = "WebsockThread:-{:%Y%m%d%H%M%S}".format(datetime.now())

# As default, a Emotiv self-signed certificate is required.

# If you don't want to use the certificate, please replace by the below line by sslopt={"cert_reqs": ssl.CERT_NONE}

file_dir_path = Path(__file__).resolve().parent

parent_dir_path = file_dir_path.parent

certificate_path = Path(parent_dir_path, 'certificates', 'rootCA.pem')

sslopt = {'ca_certs': str(certificate_path), "cert_reqs": ssl.CERT_REQUIRED}

self.websock_thread = threading.Thread(target=self.ws.run_forever, args=(None, sslopt), name=thread_name)

self.websock_thread .start()

self.websock_thread.join()

def close(self):

self.ws.close()

def set_wanted_headset(self, headset_id):

self.headset_id = headset_id

def set_wanted_profile(self, profile_name):

self.profile_name = profile_name

def on_open(self, *args, **kwargs):

print("websocket opened")

self.do_prepare_steps()

def on_error(self, *args):

if len(args) == 2:

print(str(args[1]))

def on_close(self, *args, **kwargs):

print("on_close")

print(args[1])

def handle_result(self, recv_dic):

if self.debug:

print(recv_dic)

req_id = recv_dic['id']

result_dic = recv_dic['result']

# Dictionary dispatch pattern for better readability and performance

handler = self._get_result_handler(req_id)

if handler:

handler(result_dic)

else:

print('No handling for response of request ' + str(req_id))

def _get_result_handler(self, req_id):

"""Return the appropriate handler function for the given request ID."""

handlers = {

HAS_ACCESS_RIGHT_ID: self._handle_has_access_right,

REQUEST_ACCESS_ID: self._handle_request_access,

AUTHORIZE_ID: self._handle_authorize,

QUERY_HEADSET_ID: self._handle_query_headset,

CREATE_SESSION_ID: self._handle_create_session,

SUB_REQUEST_ID: self._handle_sub_request,

UNSUB_REQUEST_ID: self._handle_unsub_request,

QUERY_PROFILE_ID: self._handle_query_profile,

SETUP_PROFILE_ID: self._handle_setup_profile,

GET_CURRENT_PROFILE_ID: self._handle_get_current_profile,

DISCONNECT_HEADSET_ID: self._handle_disconnect_headset,

MENTAL_COMMAND_ACTIVE_ACTION_ID: self._handle_mental_command_active_action,

MENTAL_COMMAND_TRAINING_THRESHOLD: self._handle_mental_command_training_threshold,

MENTAL_COMMAND_BRAIN_MAP_ID: self._handle_mental_command_brain_map,

SENSITIVITY_REQUEST_ID: self._handle_sensitivity_request,

QUERY_RECORDS_ID: self._handle_query_records,

REQUEST_DOWNLOAD_RECORDS_ID: self._handle_request_download_records,

CREATE_RECORD_REQUEST_ID: self._handle_create_record_request,

STOP_RECORD_REQUEST_ID: self._handle_stop_record_request,

EXPORT_RECORD_ID: self._handle_export_record,

INJECT_MARKER_REQUEST_ID: self._handle_inject_marker_request,

UPDATE_MARKER_REQUEST_ID: self._handle_update_marker_request,

SYNC_WITH_HEADSET_CLOCK_ID: self._handle_sync_with_headset_clock

}

return handlers.get(req_id)

def _handle_has_access_right(self, result_dic):

access_granted = result_dic['accessGranted']

if access_granted == True:

# authorize

self.authorize()

else:

# request access

self.request_access()

def _handle_request_access(self, result_dic):

access_granted = result_dic['accessGranted']

if access_granted == True:

# authorize

self.authorize()

else:

# wait approve from Emotiv Launcher

msg = result_dic['message']

warnings.warn(msg)

def _handle_authorize(self, result_dic):

print("Authorize successfully.")

self.auth = result_dic['cortexToken']

if self.auto_create_session:

#After successful authorization, the app will call the API refresh headset list for the first time

self.refresh_headset_list()

# query headsets

self.query_headset()

else:

self.emit('authorize_done')

def _handle_query_headset(self, result_dic):

self.headset_list = result_dic

found_headset = False

headset_status = ''

for ele in self.headset_list:

hs_id = ele['id']

status = ele['status']

connected_by = ele['connectedBy']

print('headsetId: {0}, status: {1}, connected_by: {2}'.format(hs_id, status, connected_by))

if self.headset_id != '' and self.headset_id == hs_id:

found_headset = True

headset_status = status

if len(self.headset_list) == 0:

self.isHeadsetConnected = False

warnings.warn("No headset available. Please turn on a headset.")

elif self.headset_id == '':

# set first headset is default headset

self.headset_id = self.headset_list[0]['id']

# call query headet again

self.query_headset()

elif found_headset == False:

warnings.warn("Can not found the headset " + self.headset_id + ". Please make sure the id is correct.")

elif found_headset == True:

if headset_status == 'connected':

self.isHeadsetConnected = True

# create session with the headset

self.create_session()

elif headset_status == 'discovered':

self.connect_headset(self.headset_id)

elif headset_status == 'connecting':

# wait 3 seconds and query headset again

time.sleep(3)

self.query_headset()

else:

warnings.warn('query_headset resp: Invalid connection status ' + headset_status)

def _handle_create_session(self, result_dic):

self.session_id = result_dic['id']

print("The session " + self.session_id + " is created successfully.")

self.emit('create_session_done', data=self.session_id)

def _handle_sub_request(self, result_dic):

# handle data label

for stream in result_dic['success']:

stream_name = stream['streamName']

stream_labels = stream['cols']

print('The data stream '+ stream_name + ' is subscribed successfully.')

# ignore com, fac and sys data label because they are handled in on_new_data

if stream_name != 'com' and stream_name != 'fac':

self.extract_data_labels(stream_name, stream_labels)

for stream in result_dic['failure']:

stream_name = stream['streamName']

stream_msg = stream['message']

print('The data stream '+ stream_name + ' is subscribed unsuccessfully. Because: ' + stream_msg)

def _handle_unsub_request(self, result_dic):

for stream in result_dic['success']:

stream_name = stream['streamName']

print('The data stream '+ stream_name + ' is unsubscribed successfully.')

for stream in result_dic['failure']:

stream_name = stream['streamName']

stream_msg = stream['message']

print('The data stream '+ stream_name + ' is unsubscribed unsuccessfully. Because: ' + stream_msg)

def _handle_query_profile(self, result_dic):

profile_list = []

for ele in result_dic:

if 'name' in ele:

profile_name = str(ele['name'])

read_only = ele['readOnly']

print('profile name :', profile_name, " readonly :", read_only)

profile_list.append(profile_name)

else:

print('Result does not contain name field.')

self.emit('query_profile_done', data=profile_list)

def _handle_setup_profile(self, result_dic):

action = result_dic['action']

if action == 'create':

profile_name = result_dic['name']

if profile_name == self.profile_name:

# load profile

self.setup_profile(profile_name, 'load')

elif action == 'load':

print('load profile successfully')

self.emit('load_unload_profile_done', isLoaded=True)

elif action == 'unload':

self.emit('load_unload_profile_done', isLoaded=False)

elif action == 'save':

self.emit('save_profile_done')

def _handle_get_current_profile(self, result_dic):

print(result_dic)

name = result_dic['name']

if name is None:

# no profile loaded with the headset

print('get_current_profile: no profile loaded with the headset ' + self.headset_id)

self.setup_profile(self.profile_name, 'load')

else:

loaded_by_this_app = result_dic['loadedByThisApp']

print('get current profile rsp: ' + name + ", loadedByThisApp: " + str(loaded_by_this_app))

if name != self.profile_name:

warnings.warn("There is profile " + name + " is loaded for headset " + self.headset_id)

elif loaded_by_this_app == True:

self.emit('load_unload_profile_done', isLoaded=True)

else:

self.setup_profile(self.profile_name, 'unload')

# warnings.warn("The profile " + name + " is loaded by other applications")

def _handle_disconnect_headset(self, result_dic):

print("Disconnect headset " + self.headset_id)

self.headset_id = ''

def _handle_mental_command_active_action(self, result_dic):

self.emit('get_mc_active_action_done', data=result_dic)

def _handle_mental_command_training_threshold(self, result_dic):

self.emit('mc_training_threshold_done', data=result_dic)

def _handle_mental_command_brain_map(self, result_dic):

self.emit('mc_brainmap_done', data=result_dic)

def _handle_sensitivity_request(self, result_dic):

self.emit('mc_action_sensitivity_done', data=result_dic)

def _handle_query_records(self, result_dic):

record_num = result_dic['count']

limit_num = result_dic['limit']

offset_num = result_dic['offset']

records = result_dic['records']

self.emit('query_records_done', data=records, count=record_num, limit=limit_num, offset=offset_num)

def _handle_request_download_records(self, result_dic):

self.emit('request_download_records_done', data=result_dic)

def _handle_create_record_request(self, result_dic):

self.record_id = result_dic['record']['uuid']

self.emit('create_record_done', data=result_dic['record'])

def _handle_stop_record_request(self, result_dic):

self.emit('stop_record_done', data=result_dic['record'])

def _handle_export_record(self, result_dic):

# handle data lable

success_export = []

for record in result_dic['success']:

record_id = record['recordId']

success_export.append(record_id)

for record in result_dic['failure']:

record_id = record['recordId']

failure_msg = record['message']

print('export_record resp failure cases: '+ record_id + ":" + failure_msg)

self.emit('export_record_done', data=success_export)

def _handle_inject_marker_request(self, result_dic):

self.emit('inject_marker_done', data=result_dic['marker'])

def _handle_update_marker_request(self, result_dic):

self.emit('update_marker_done', data=result_dic['marker'])

def _handle_sync_with_headset_clock(self, result_dic):

self.emit('sync_with_headset_clock_done', data=result_dic)

def handle_error(self, recv_dic):

req_id = recv_dic['id']

print('handle_error: request Id ' + str(req_id))

self.emit('inform_error', error_data=recv_dic['error'])

def handle_warning(self, warning_dic):

if self.debug:

print(warning_dic)

warning_code = warning_dic['code']

warning_msg = warning_dic['message']

# Dictionary dispatch pattern for better readability and performance

handler = self._get_warning_handler(warning_code)

if handler:

handler(warning_msg)

# Note: No else clause needed as some warning codes may not require handling

def _get_warning_handler(self, warning_code):

"""Return the appropriate handler function for the given warning code."""

handlers = {

ACCESS_RIGHT_GRANTED: self._handle_access_right_granted,

HEADSET_CONNECTED: self._handle_headset_connected,

CORTEX_AUTO_UNLOAD_PROFILE: self._handle_cortex_auto_unload_profile,

CORTEX_STOP_ALL_STREAMS: self._handle_cortex_stop_all_streams,

CORTEX_RECORD_POST_PROCESSING_DONE: self._handle_cortex_record_post_processing_done,

HEADSET_SCANNING_FINISHED: self._handle_headset_scanning_finished,

}

return handlers.get(warning_code)

def _handle_access_right_granted(self, warning_msg):

# call authorize again

self.authorize()

def _handle_headset_connected(self, warning_msg):

# query headset again then create session

self.query_headset()

def _handle_cortex_auto_unload_profile(self, warning_msg):

self.profile_name = ''

def _handle_cortex_stop_all_streams(self, warning_msg):

# print(warning_msg['behavior'])

session_id = warning_msg['sessionId']

if session_id == self.session_id:

self.emit('warn_cortex_stop_all_sub', data=session_id)

self.session_id = ''

def _handle_cortex_record_post_processing_done(self, warning_msg):

record_id = warning_msg['recordId']

self.emit('warn_record_post_processing_done', data=record_id)

def _handle_headset_scanning_finished(self, warning_msg):

# After headset scanning finishes, if no headset is connected yet, the app should call the controlDevice("refresh") again

# We recommend the app should NOT call controlDevice("refresh") when a headset is connected, to have the best data stream quality.

if (self.isHeadsetConnected == False):

self.refresh_headset_list()

def handle_stream_data(self, result_dic):

if result_dic.get('com') != None:

com_data = {}

com_data['action'] = result_dic['com'][0]

com_data['power'] = result_dic['com'][1]

com_data['time'] = result_dic['time']

self.emit('new_com_data', data=com_data)

elif result_dic.get('fac') != None:

fe_data = {}

fe_data['eyeAct'] = result_dic['fac'][0] #eye action

fe_data['uAct'] = result_dic['fac'][1] #upper action

fe_data['uPow'] = result_dic['fac'][2] #upper action power

fe_data['lAct'] = result_dic['fac'][3] #lower action

fe_data['lPow'] = result_dic['fac'][4] #lower action power

fe_data['time'] = result_dic['time']

self.emit('new_fe_data', data=fe_data)

elif result_dic.get('eeg') != None:

eeg_data = {}

eeg_data['eeg'] = result_dic['eeg']

eeg_data['eeg'].pop() # remove markers

eeg_data['time'] = result_dic['time']

self.emit('new_eeg_data', data=eeg_data)

elif result_dic.get('mot') != None:

mot_data = {}

mot_data['mot'] = result_dic['mot']

mot_data['time'] = result_dic['time']

self.emit('new_mot_data', data=mot_data)

elif result_dic.get('dev') != None:

dev_data = {}

dev_data['signal'] = result_dic['dev'][1]

dev_data['dev'] = result_dic['dev'][2]

dev_data['batteryPercent'] = result_dic['dev'][3]

dev_data['time'] = result_dic['time']

self.emit('new_dev_data', data=dev_data)

elif result_dic.get('met') != None:

met_data = {}

met_data['met'] = result_dic['met']

met_data['time'] = result_dic['time']

self.emit('new_met_data', data=met_data)

elif result_dic.get('pow') != None:

pow_data = {}

pow_data['pow'] = result_dic['pow']

pow_data['time'] = result_dic['time']

self.emit('new_pow_data', data=pow_data)

elif result_dic.get('sys') != None:

sys_data = result_dic['sys']

self.emit('new_sys_data', data=sys_data)

else :

print(result_dic)

def on_message(self, *args):

recv_dic = json.loads(args[1])

if 'sid' in recv_dic:

self.handle_stream_data(recv_dic)

elif 'result' in recv_dic:

self.handle_result(recv_dic)

elif 'error' in recv_dic:

self.handle_error(recv_dic)

elif 'warning' in recv_dic:

self.handle_warning(recv_dic['warning'])

else:

raise KeyError

def query_headset(self):

print('query headset --------------------------------')

query_headset_request = {

"jsonrpc": "2.0",

"id": QUERY_HEADSET_ID,

"method": "queryHeadsets",

"params": {}

}

if self.debug:

print('queryHeadsets request \n', json.dumps(query_headset_request, indent=4))

self.ws.send(json.dumps(query_headset_request, indent=4))

def connect_headset(self, headset_id):

print('connect headset --------------------------------')

connect_headset_request = {

"jsonrpc": "2.0",

"id": CONNECT_HEADSET_ID,

"method": "controlDevice",

"params": {

"command": "connect",

"headset": headset_id

}

}

if self.debug:

print('controlDevice request \n', json.dumps(connect_headset_request, indent=4))

self.ws.send(json.dumps(connect_headset_request, indent=4))

def request_access(self):

print('request access --------------------------------')

request_access_request = {

"jsonrpc": "2.0",

"method": "requestAccess",

"params": {

"clientId": self.client_id,

"clientSecret": self.client_secret

},

"id": REQUEST_ACCESS_ID

}

self.ws.send(json.dumps(request_access_request, indent=4))

def has_access_right(self):

print('check has access right --------------------------------')

has_access_request = {

"jsonrpc": "2.0",

"method": "hasAccessRight",

"params": {

"clientId": self.client_id,

"clientSecret": self.client_secret

},

"id": HAS_ACCESS_RIGHT_ID

}

self.ws.send(json.dumps(has_access_request, indent=4))

def authorize(self):

print('authorize --------------------------------')

authorize_request = {

"jsonrpc": "2.0",

"method": "authorize",

"params": {

"clientId": self.client_id,

"clientSecret": self.client_secret,

"license": self.license,

"debit": self.debit

},

"id": AUTHORIZE_ID

}

if self.debug:

print('auth request \n', json.dumps(authorize_request, indent=4))

self.ws.send(json.dumps(authorize_request))

def create_session(self):

if self.session_id != '':

warnings.warn("There is existed session " + self.session_id)

return

print('create session --------------------------------')

create_session_request = {

"jsonrpc": "2.0",

"id": CREATE_SESSION_ID,

"method": "createSession",

"params": {

"cortexToken": self.auth,

"headset": self.headset_id,

"status": "active"

}

}

if self.debug:

print('create session request \n', json.dumps(create_session_request, indent=4))

self.ws.send(json.dumps(create_session_request))

def close_session(self):

print('close session --------------------------------')

close_session_request = {

"jsonrpc": "2.0",

"id": CREATE_SESSION_ID,

"method": "updateSession",

"params": {

"cortexToken": self.auth,

"session": self.session_id,

"status": "close"

}

}

self.ws.send(json.dumps(close_session_request))

def get_cortex_info(self):

print('get cortex version --------------------------------')

get_cortex_info_request = {

"jsonrpc": "2.0",

"method": "getCortexInfo",

"id":GET_CORTEX_INFO_ID

}

self.ws.send(json.dumps(get_cortex_info_request))

"""

def do_prepare_steps(self):

print('do_prepare_steps--------------------------------')

# check access right

self.has_access_right()

def disconnect_headset(self):

print('disconnect headset --------------------------------')

disconnect_headset_request = {

"jsonrpc": "2.0",

"id": DISCONNECT_HEADSET_ID,

"method": "controlDevice",

"params": {

"command": "disconnect",

"headset": self.headset_id

}

}

self.ws.send(json.dumps(disconnect_headset_request))

def sub_request(self, stream):

print('subscribe request --------------------------------')

sub_request_json = {

"jsonrpc": "2.0",

"method": "subscribe",

"params": {

"cortexToken": self.auth,

"session": self.session_id,

"streams": stream

},

"id": SUB_REQUEST_ID

}

if self.debug:

print('subscribe request \n', json.dumps(sub_request_json, indent=4))

self.ws.send(json.dumps(sub_request_json))

def unsub_request(self, stream):

print('unsubscribe request --------------------------------')

unsub_request_json = {

"jsonrpc": "2.0",

"method": "unsubscribe",

"params": {

"cortexToken": self.auth,

"session": self.session_id,

"streams": stream

},

"id": UNSUB_REQUEST_ID

}

if self.debug:

print('unsubscribe request \n', json.dumps(unsub_request_json, indent=4))

self.ws.send(json.dumps(unsub_request_json))

def extract_data_labels(self, stream_name, stream_cols):

labels = {}

labels['streamName'] = stream_name

data_labels = []

if stream_name == 'eeg':

# remove MARKERS

data_labels = stream_cols[:-1]

elif stream_name == 'dev':

# get cq header column except battery, signal and battery percent

data_labels = stream_cols[2]

else:

data_labels = stream_cols

labels['labels'] = data_labels

print(labels)

self.emit('new_data_labels', data=labels)

def query_profile(self):

print('query profile --------------------------------')

query_profile_json = {

"jsonrpc": "2.0",

"method": "queryProfile",

"params": {

"cortexToken": self.auth,

},

"id": QUERY_PROFILE_ID

}

if self.debug:

print('query profile request \n', json.dumps(query_profile_json, indent=4))

print('\n')

self.ws.send(json.dumps(query_profile_json))

def get_current_profile(self):

print('get current profile:')

get_profile_json = {

"jsonrpc": "2.0",

"method": "getCurrentProfile",

"params": {

"cortexToken": self.auth,

"headset": self.headset_id,

},

"id": GET_CURRENT_PROFILE_ID

}

if self.debug:

print('get current profile json:\n', json.dumps(get_profile_json, indent=4))

print('\n')

self.ws.send(json.dumps(get_profile_json))

def setup_profile(self, profile_name, status):

print('setup profile: ' + status + ' -------------------------------- ')

setup_profile_json = {

"jsonrpc": "2.0",

"method": "setupProfile",

"params": {

"cortexToken": self.auth,

"headset": self.headset_id,

"profile": profile_name,

"status": status

},

"id": SETUP_PROFILE_ID

}

if self.debug:

print('setup profile json:\n', json.dumps(setup_profile_json, indent=4))

print('\n')

self.ws.send(json.dumps(setup_profile_json))

def train_request(self, detection, action, status):

print('train request --------------------------------')

train_request_json = {

"jsonrpc": "2.0",

"method": "training",

"params": {

"cortexToken": self.auth,

"detection": detection,

"session": self.session_id,

"action": action,

"status": status

},

"id": TRAINING_ID

}

if self.debug:

print('training request:\n', json.dumps(train_request_json, indent=4))

print('\n')

self.ws.send(json.dumps(train_request_json))

def query_records(self, query_params):

print('query records --------------------------------')

params_val = {"cortexToken": self.auth}

for key, value in query_params.items():

params_val.update({key: value})

query_records_request = {

"jsonrpc": "2.0",

"method": "queryRecords",

"params": params_val,

"id": QUERY_RECORDS_ID

}

if self.debug:

print('query records request:\n', json.dumps(query_records_request, indent=4))

self.ws.send(json.dumps(query_records_request))

def request_download_records(self, recordIds):

print('request to download records --------------------------------')

params_val = {"cortexToken": self.auth, 'recordIds': recordIds}

download_records_request = {

"jsonrpc": "2.0",

"method": "requestToDownloadRecordData",

"params": params_val,

"id": REQUEST_DOWNLOAD_RECORDS_ID

}

if self.debug:

print('requestToDownloadRecordData request:\n', json.dumps(download_records_request, indent=4))

self.ws.send(json.dumps(download_records_request))

def create_record(self, title, **kwargs):

print('create record --------------------------------')

if (len(title) == 0):

warnings.warn('Empty record_title. Please fill the record_title before running script.')

# close socket

self.close()

return

params_val = {"cortexToken": self.auth, "session": self.session_id, "title": title}

for key, value in kwargs.items():

params_val.update({key: value})

create_record_request = {

"jsonrpc": "2.0",

"method": "createRecord",

"params": params_val,

"id": CREATE_RECORD_REQUEST_ID

}

if self.debug:

print('create record request:\n', json.dumps(create_record_request, indent=4))

self.ws.send(json.dumps(create_record_request))

def stop_record(self):

print('stop record --------------------------------')

stop_record_request = {

"jsonrpc": "2.0",

"method": "stopRecord",

"params": {

"cortexToken": self.auth,

"session": self.session_id

},

"id": STOP_RECORD_REQUEST_ID

}

if self.debug:

print('stop record request:\n', json.dumps(stop_record_request, indent=4))

self.ws.send(json.dumps(stop_record_request))

def export_record(self, folder, stream_types, export_format, record_ids,

version, **kwargs):

print('export record --------------------------------: ')

#validate destination folder

if (len(folder) == 0):

warnings.warn('Invalid folder parameter. Please set a writable destination folder for exporting data.')

# close socket

self.close()

return

params_val = {"cortexToken": self.auth,

"folder": folder,

"format": export_format,

"streamTypes": stream_types,

"recordIds": record_ids}

if export_format == 'CSV':

params_val.update({'version': version})

for key, value in kwargs.items():

params_val.update({key: value})

export_record_request = {

"jsonrpc": "2.0",

"id":EXPORT_RECORD_ID,

"method": "exportRecord",

"params": params_val

}

if self.debug:

print('export record request \n',

json.dumps(export_record_request, indent=4))

self.ws.send(json.dumps(export_record_request))

def inject_marker_request(self, time, value, label, **kwargs):

print('inject marker --------------------------------')

params_val = {"cortexToken": self.auth,

"session": self.session_id,

"time": time,

"value": value,

"label":label}

for key, value in kwargs.items():

params_val.update({key: value})

inject_marker_request = {

"jsonrpc": "2.0",

"id": INJECT_MARKER_REQUEST_ID,

"method": "injectMarker",

"params": params_val

}

if self.debug:

print('inject marker request \n', json.dumps(inject_marker_request, indent=4))

self.ws.send(json.dumps(inject_marker_request))

def update_marker_request(self, marker_id, time, **kwargs):

print('update marker --------------------------------')

params_val = {"cortexToken": self.auth,

"session": self.session_id,

"markerId": marker_id,

"time": time}

for key, value in kwargs.items():

params_val.update({key: value})

update_marker_request = {

"jsonrpc": "2.0",

"id": UPDATE_MARKER_REQUEST_ID,

"method": "updateMarker",

"params": params_val

}

if self.debug:

print('update marker request \n', json.dumps(update_marker_request, indent=4))

self.ws.send(json.dumps(update_marker_request))

def get_mental_command_action_sensitivity(self, profile_name):

print('get mental command sensitivity ------------------')

sensitivity_request = {

"id": SENSITIVITY_REQUEST_ID,

"jsonrpc": "2.0",

"method": "mentalCommandActionSensitivity",

"params": {

"cortexToken": self.auth,

"profile": profile_name,

"status": "get"

}

}

if self.debug:

print('get mental command sensitivity \n', json.dumps(sensitivity_request, indent=4))

self.ws.send(json.dumps(sensitivity_request))

def set_mental_command_action_sensitivity(self, profile_name, values):

print('set mental command sensitivity ------------------')

sensitivity_request = {