def __init__(self):
self.headers = {}
self.objects = None
self.count = 0
self.tick = time.time()
self.maxEventsInBuffer = 100
self.stream_types = {}
self.is_first_for_type = {
"met": True,
"eeg": True,
"fac": True,
"mot": True,
}
self.c = Cortex(user, debug_mode=False)
self.c.do_prepare_steps()
self.time_slice = 0
self.time_data = {
'engagement': {},
'excitement': {},
'stress': {},
'relaxation': {},
'interest': {},
'focus': {}
}
self.time_slice_averages = {}
class Record():
def __init__(self):
self.c = Cortex(user, debug_mode=True)
self.c.do_prepare_steps()
def create_record_then_export(self, record_name, record_description,
record_length_s, record_export_folder,
record_export_data_types,
record_export_format, record_export_version):
self.c.create_record(record_name, record_description)
self.wait(record_length_s)
self.c.stop_record()
self.c.disconnect_headset()
self.c.export_record(record_export_folder, record_export_data_types,
record_export_format, record_export_version,
[self.c.record_id])
def wait(self, record_length_s):
print('start recording -------------------------')
length = 0
while length < record_length_s:
print('recording at {0} s'.format(length))
time.sleep(1)
length += 1
print('end recording -------------------------')
def func(self):
url = "wss://localhost:6868"
user = {
"license": "",
"client_id": "",
"client_secret": "",
"debit": 100,
"number_row_data": 10
}
self.count = 0
self.cortex = Cortex(url, user)
self.headset_id = self.cortex.query_headset()
self.cortex.connect_headset()
self.cortex.request_access()
auth = self.cortex.authorize()
self.cortex.create_session(auth, self.headset_id)
status = 'load'
profile_name = 'skshreyas'
self.cortex.setup_profile(profile_name, status)
stream_list = ['com']
self.lis = []
self.cortex.subscribe(stream_list)
while True:
resp = self.cortex.ws.recv()
res = json.loads(resp)
mentalCommandList = res['com']
action = mentalCommandList[0]
#print(action)
self.FocusChanger(action)
class Subcribe():
def __init__(self):
self.c = Cortex(user, debug_mode=True)
self.c.do_prepare_steps()
def sub(self, streams):
self.c.sub_request(streams)
def __init__(self, logging_groups=['Default', 'Cortex']):
Cortex.__init__(self, 'SOUL', logging_groups)
# The following is parsing the defines.txt to get the app specific data
defines = utils.parse_defines(
utils.read_txt("../database/cortex/soul.txt"))
self.delay = eval(defines['delay'])
def __init__(self, screen, logging_groups=['Default', 'Cortex']):
Cortex.__init__(self, 'Collector', logging_groups)
# Current collection platform
self.platform = GroupMe_Web(screen, logging_groups)
# The following is parsing the defines.txt to get the app specific data
defines = utils.parse_defines(
utils.read_txt("../database/cortex/collector.txt"))
self.alias_dict = eval(defines['member_alias'])
class LiveAdvance():
def __init__(self):
self.c = Cortex(user, debug_mode=True)
self.c.do_prepare_steps()
def live(self, profile_name):
print('begin live mode ----------------------------------')
self.c.setup_profile(profile_name=profile_name, status='load')
self.c.sub_request(stream=['com'])
def get_sensitivity(self, profile_name):
self.c.get_mental_command_action_sensitivity(profile_name)
def set_sensitivity(self, profile_name, values):
self.c.set_mental_command_action_sensitivity(profile_name, values)
def start_chart(data):
# print('received message: ' + str(data), flush=sys.stdout)
chart_cortex = Cortex(user)
PROFILE_NAME = "RealBCI"
STREAM = "pow"
chart_cortex.do_prepare_steps()
chart_cortex.setup_profile(PROFILE_NAME, 'load')
chart_cortex.sub_request(stream=[STREAM], emit=emit)
def run(req: dict):
payload = req["payload"]
instances = payload["instances"]
exp_name = payload["exp_name"]
run_id = None
if "run_id" in payload:
run_id = payload["run_id"]
# if model is not loaded
client = Cortex.client(api_endpoint=req["apiEndpoint"], project=req["projectId"], token=req["token"])
model_ctx[exp_name] = init_model(exp_name, run_id, client, req["projectId"])
# retrieve model from the context
model_obj = model_ctx[exp_name]
# using encoder from model object
encoder = model_obj["encoder"]
instances = np.array(instances, dtype=object)
instances = instances if instances.ndim == 2 else np.reshape(instances, (1, -1))
instances = encoder(instances)
# predict
predictions = model_obj["model"].predict(instances)
scores = model_obj["model"].predict_proba(instances)
labels = model_obj["model"].classes_
return {
"payload": {
"predictions": predictions.tolist(),
"scores": scores.tolist(),
"labels": labels.tolist()
}
}
def main():
with open('cred.json') as json_file:
user = json.load(json_file)
cortex = Cortex(user, True)
# do_stuff(cortex)
record = Record(cortex)
record.run()
def run(request_body: dict):
# Get agent/skill activation request body
api_endpoint = request_body["apiEndpoint"]
project = request_body["projectId"]
token = request_body["token"]
connection_name = request_body["payload"]["connection_name"]
query = request_body["payload"]["query"]
try:
# Create Cortex client
client = Cortex.client(api_endpoint=api_endpoint, project=project, token=token)
# Get connection and create mongo client
connection = client.get_connection(connection_name)
params = dict(map(lambda l: (l['name'], l['value']), connection['params']))
mongo = MongoClient(params["uri"])
# Use connection
database = params.get("database")
collection = params.get("collection")
if database and collection:
result = list(mongo[database][collection].find(query))
else:
result = {"error": "collection, database and query must be provided"}
except Exception as e:
result = {"error": str(e)}
logger.exception(e)
# Return result
return {'payload': result}
def domain_controller(params: dict):
# initialise the Cortex client
api_endpoint = params.get('apiEndpoint')
token = params.get('token')
project_id = params.get('projectId')
client = Cortex.client(api_endpoint=api_endpoint,
token=token,
project=project_id)
# # get secrets keys
# os.environ["AWS_SECRET_ACCESS_KEY"] = str(client.get_secret("awssecretkey"))
# os.environ["AWS_ACCESS_KEY_ID"] = str(client.get_secret("awspublickey"))
# just in case there are old environment variables for hadron
for key in os.environ.keys():
if key.startswith('HADRON'):
del os.environ[key]
# extract the payload
payload = params.get('payload', {})
# get the domain contract repo from the payload
uri_pm_repo = payload.get('domain_contract_repo')
if not isinstance(uri_pm_repo, str):
raise KeyError(
"The message parameters passed do not have the mandatory 'domain_contract_repo' payload key"
)
# extract any extra kwargs
hadron_kwargs = payload.get('hadron_kwargs', {})
# export and pop any environment variable from the kwargs
for key in hadron_kwargs.copy().keys():
if str(key).isupper():
os.environ[key] = hadron_kwargs.pop(key)
# pop the run_controller attributes from the kwargs
run_book = hadron_kwargs.pop('runbook', None)
mod_tasks = hadron_kwargs.pop('mod_tasks', None)
repeat = hadron_kwargs.pop('repeat', None)
sleep = hadron_kwargs.pop('sleep', None)
run_time = hadron_kwargs.pop('run_time', None)
run_cycle_report = hadron_kwargs.pop('run_cycle_report', None)
source_check_uri = hadron_kwargs.pop('source_check_uri', None)
# instantiate the Controller passing any remaining kwargs
controller = Controller.from_env(uri_pm_repo=uri_pm_repo,
default_save=False,
has_contract=True,
**hadron_kwargs)
# run the controller nano services.
controller.run_controller(run_book=run_book,
mod_tasks=mod_tasks,
repeat=repeat,
sleep=sleep,
run_time=run_time,
source_check_uri=source_check_uri,
run_cycle_report=run_cycle_report)
class TrainAdvance():
def __init__(self):
self.c = Cortex(user, debug_mode=True)
self.c.do_prepare_steps()
def get_active_action(self, profile_name):
self.c.get_mental_command_active_action(profile_name)
def get_command_brain_map(self, profile_name):
self.c.get_mental_command_brain_map(profile_name)
def get_training_threshold(self):
self.c.get_mental_command_training_threshold(profile_name)
def delete(req: dict):
payload = req['payload']
client = Cortex.client(api_endpoint=req["apiEndpoint"],
project=req["projectId"],
token=req["token"])
session_id = None
if "session_id" in payload:
session_id = payload["session_id"]
else:
return {'payload': "session_id is required"}
result = SessionClient(client).delete_session(session_id, req["projectId"])
return {"payload": result}
def start(req: dict):
payload = req['payload']
client = Cortex.client(api_endpoint=req["apiEndpoint"],
project=req["projectId"],
token=req["token"])
ttl = None
description = "No description given"
if "ttl" in payload:
ttl = payload["ttl"]
if "description" in payload:
description = payload["description"]
session_client = SessionClient(client)
session = session_client.start_session(ttl, description, req["projectId"])
return {'payload': {"session_id": session}}
def record():
try:
app.app_cortex = Cortex(user)
app.app_cortex.do_prepare_steps()
app.app_cortex.create_record(record_name, record_description)
response = app.response_class(response=json.dumps(
{"record_id": app.app_cortex.record_id}),
status=200,
mimetype='application/json')
return response
except Exception as e:
print(e, flush=sys.stdout)
response = app.response_class(response=json.dumps(
{"error": 'Get Error'}),
status=400,
mimetype='applica tion/json')
return response
def run(request_body: dict):
# Get agent/skill activation request body
api_endpoint = request_body["apiEndpoint"]
project = request_body["projectId"]
token = request_body["token"]
experiment_name = request_body["payload"]["experiment_name"]
instance = request_body["payload"]["instance"]
# Create Cortex client and get experiment
client = Cortex.client(api_endpoint=api_endpoint, project=project, token=token)
experiment = client.experiment(experiment_name)
# Get model from last experiment run
exp_run = experiment.last_run()
model = exp_run.get_artifact('model')
# Return model predict
return {'payload': model.predict(instance).tolist()}
def put(req: dict):
payload = req['payload']
client = Cortex.client(api_endpoint=req["apiEndpoint"],
project=req["projectId"],
token=req["token"])
session_id = None
if "session_id" in payload:
session_id = payload["session_id"]
else:
return {'payload': "session_id is required"}
data = {}
if "data" in payload:
data = payload["data"]
else:
return {'payload': "data is required"}
result = SessionClient(client).put_session_data(session_id, data,
req["projectId"])
return {"payload": result}
def process(params):
# create a Cortex client instance from the job's parameters
client = Cortex.client(api_endpoint=params['apiEndpoint'], token=params['token'])
# get the agent payload
payload = params.get('payload',{})
# You can print logs to the console these are collected by docker/k8s
print(f'Got payload: {payload}')
# use the `client` instance to use Cortex client libraries
content_client = ManagedContentClient(client);
if 'activationId' in params:
file_name = f'jobchain-data-{params["activationId"]}'
else:
#
file_name = f'jobchain-data-{int(time.time())}'
# Read `recordCount` from payload, have a default value of raising an Exception is recommended.
record_count = payload.get('recordCount', 1000)
# This is streaming the records to Cortex's managed content
content_client.upload_streaming(file_name, datagen_stream(record_count), 'application/x-jsonlines')
print(f'Wrote datafile to managed content key: {file_name}')
def get(req: dict):
payload = req['payload']
client = Cortex.client(api_endpoint=req["apiEndpoint"],
project=req["projectId"],
token=req["token"])
session_id = None
if "session_id" in payload:
session_id = payload["session_id"]
else:
return {'payload': "session_id is required"}
key = None
if "key" in payload:
key = payload["key"]
if len(key) < 1:
key = None
session_client = SessionClient(client)
session = session_client.get_session_data(session_id, key,
req["projectId"])
return {'payload': session}
def process(params):
# create a Cortex client instance from the job's parameters
client = Cortex.client(api_endpoint=params['apiEndpoint'],
token=params['token'])
# get he agent payload
payload = params['payload']
# You can print logs to the console these are collected by docker/k8s
print(f'Got payload: {payload}')
if 'activationId' in params:
content_key = f'jobchain-data-{params["activationId"]}'
else:
if 'datafileKey' not in payload:
raise Exception("'datafileKey' is required in the payload")
content_key = payload['datafileKey']
print(f'Fetching datafile from managed content: {content_key}')
# use the `client` instance to use Cortex client libraries
content_client = ManagedContentClient(client)
# This is streaming the records to Cortex's managed content
# if this was called as part of an agent
content = content_client.download(content_key)
df = pd.read_json(content, lines=True)
counts = df['color'].value_counts()
print(f'{counts.to_json()}')
def load_model(api_endpoint: str, token: str, project_id: str,
experiment_name: str, run_id: str, artifact_key: str):
global model
if not experiment_name:
raise ValueError(
"experiment-name is required if a model is not initialized")
# Initialize Cortex Client
client = Cortex.client(api_endpoint=api_endpoint,
token=token,
project=project_id)
# Load Model from the experiment run
logging.info("Loading model artifacts from experiment run...")
try:
experiment = client.experiment(experiment_name)
run = experiment.get_run(run_id) if run_id else experiment.last_run()
model = run.get_artifact(artifact_key)
except Exception as e:
logging.error("Error: Failed to load model: {}".format(e))
raise
logging.info("Model Loaded!")
def test():
cortex = Cortex(None)
cortex.do_prepare_steps()
def train(params):
project = params['projectId']
# create a Cortex client instance from the job's parameters
client = Cortex.client(api_endpoint=params['apiEndpoint'], project=project, token=params['token'])
payload = params['payload']
# Read connection
connection_name = payload['connection_name']
print(f'Reading connection {connection_name}')
connection = client.get_connection(connection_name)
# Download training data using connection
download_training_data(connection)
print(f'Downloaded training data for {connection_name}')
random.seed(0)
np.random.seed(0)
# Load dataset
data = pd.read_csv('german_credit_eval.csv')
# Separate outcome
y = data['outcome']
x = data.drop('outcome', axis=1)
# Bring in test and training data
x_train, x_test, y_train, y_test = train_test_split(x, y, random_state=0)
# Create an encoder
cat_columns = [
'checkingstatus',
'history',
'purpose',
'savings',
'employ',
'status',
'others',
'property',
'age',
'otherplans',
'housing',
'job',
'telephone',
'foreign'
]
encoder = CatEncoder(cat_columns, x, normalize=True)
encoded_x_train = encoder(x_train.values)
encoded_x_test = encoder(x_test.values)
# Train a decision tree model
dtree = DecisionTreeClassifier(criterion='entropy', random_state=0)
dtree.fit(encoded_x_train, y_train.values)
dtree_acc = dtree.score(encoded_x_test, y_test.values)
# Train a multi-layer perceptron model
mlp = MLPClassifier(hidden_layer_sizes=(20, 20), max_iter=2000)
mlp.fit(encoded_x_train, y_train.values)
mlp_acc = mlp.score(encoded_x_test, y_test.values)
# Train a support vector machine model
SVM = svm.SVC(gamma='scale', probability=True)
SVM.fit(encoded_x_train, y_train.values)
svm_acc = SVM.score(encoded_x_test, y_test.values)
# Train a logistic regression model
logit = LogisticRegression(random_state=0, solver='lbfgs')
logit.fit(encoded_x_train, y_train.values)
logit_acc = logit.score(encoded_x_test, y_test.values)
# Save model meta-data
model_name = payload["model_name"]
save_model(client, project, model_name, payload.get("model_title", ""), payload.get("model_description", ""),
payload.get("model_source", ""), payload.get("model_type", ""), payload.get("model_status", ""), payload.get("model_tags", []))
# Save models as pickle files and Save experiments
pickle_model(dtree, encoder, 'Decision Tree', dtree_acc, 'Basic Decision Tree model', 'german_credit_dtree.pkl')
pickle_model(logit, encoder, 'LOGIT', logit_acc, 'Basic LOGIT model', 'german_credit_logit.pkl')
pickle_model(mlp, encoder, 'MLP', mlp_acc, 'Basic MLP model', 'german_credit_mlp.pkl')
pickle_model(SVM, encoder, 'SVM', svm_acc, 'Basic SVM model', 'german_credit_svm.pkl')
save_experiment(client, 'gc_dtree_exp', 'german_credit_dtree.pkl', 'DecisionTreeClassifier', model_name, project)
save_experiment(client, 'gc_logit_exp', 'german_credit_logit.pkl', 'LogisticRegression', model_name, project)
save_experiment(client, 'gc_mlp_exp', 'german_credit_mlp.pkl', 'MLPClassifier', model_name, project)
save_experiment(client, 'gc_svm_exp', 'german_credit_svm.pkl', 'SVM', model_name, project)
def __init__(self):
self.c = Cortex(user, debug_mode=True)
self.c.do_prepare_steps()
class Marker():
def __init__(self):
self.c = Cortex(user, debug_mode=True)
self.c.do_prepare_steps()
def add_markers(self, marker_numbers):
for m in range(marker_numbers):
marker_time = time.time() * 1000
print('add marker at : ', marker_time)
marker = {
"label": str(m),
"value": "test_marker",
"port": "python-app",
"time": marker_time
}
self.c.inject_marker_request(marker)
# add marker each seconds
time.sleep(3)
def demo_add_marker(self, record_export_folder, marker_numbers):
# create record
record_name = 'demo marker'
record_description = 'demo marker'
self.c.create_record(record_name, record_description)
self.add_markers(marker_numbers)
self.c.stop_record()
self.c.disconnect_headset()
# export record
record_export_data_types = ['EEG', 'MOTION', 'PM', 'BP']
record_export_format = 'CSV'
record_export_version = 'V2'
self.c.export_record(record_export_folder, record_export_data_types,
record_export_format, record_export_version,
[self.c.record_id])
# Save model
pickle.dump(clf, open(local_pickle_file, "wb"))
# The starting point for the job
if __name__ == '__main__':
# Get agent/skill activation request body
request_body = json.loads(sys.argv[1])
api_endpoint = request_body["apiEndpoint"]
project = request_body["projectId"]
token = request_body["token"]
experiment_name = request_body["payload"]["experiment_name"]
train_and_save_model()
# Create Cortex client and create experiment
client = Cortex.client(api_endpoint=api_endpoint,
project=project,
token=token)
experiment = client.experiment(experiment_name)
# Upload model to experiment run in Cortex
model = open(local_pickle_file, "rb")
run = experiment.start_run()
run.log_artifact_stream("model", model)
run.set_meta("algo", "RandomForestClassifier Model")
print(
f'Created experiment "{experiment_name}". Started Run {run.id}. Logged RandomForestClassifier model.'
)
from pyboy import PyBoy
import ctypes
from time import sleep
import os
from command_handler import command_handler
from cca_handler import cca_handler
from pyboy_controller import pyboy_controller
import time
# Initialize our variables
use_csv = True
# TEMP: feel free to change how I do this. I say 'if not using csv then use emotiv' here and in #EACHFRAMEPOG - Matt
# NOTE: still will save a csv file even though I am reading from a csv file
if not use_csv:
cortex = Cortex(None)
cortex.do_prepare_steps()
generator = cortex.sub_request(['eeg'])
# generator = cortex.sub_request_pow(['pow'])
next(generator).queue
data_columns = ["P7", "O1", "O2", "P8", "TIME"]
# data_columns = ["O1/theta","O1/alpha","O1/betaL","O1/betaH","O1/gamma",
# "O2/theta","O2/alpha","O2/betaL","O2/betaH","O2/gamma", "TIME"]
# CSV CONTROL
if use_csv:
recording_data = pd.read_csv('old_bad_recordings/first_target_0.csv')
record_length = len(recording_data.index)
channels = ['P7', 'O1', 'O2', 'P8'] # only data channels
row_index = 0
class Train():
def __init__(self):
self.c = Cortex(user, debug_mode=True)
self.c.do_prepare_steps()
def train(self, profile_name, training_action, number_of_train):
stream = ['sys']
self.c.sub_request(stream)
profiles = self.c.query_profile()
if profile_name not in profiles:
status = 'create'
self.c.setup_profile(profile_name, status)
status = 'load'
self.c.setup_profile(profile_name, status)
print('begin train -----------------------------------')
num_train = 0
while num_train < number_of_train:
num_train = num_train + 1
print('start training {0} time {1} ---------------'.format(
training_action, num_train))
print('\n')
status = 'start'
self.c.train_request(detection='mentalCommand',
action=training_action,
status=status)
print('accept {0} time {1} ---------------'.format(
training_action, num_train))
print('\n')
status = 'accept'
self.c.train_request(detection='mentalCommand',
action=training_action,
status=status)
print('save trained action')
status = "save"
self.c.setup_profile(profile_name, status)
status = 'unload'
self.c.setup_profile(profile_name, status)
def live(self, profile_name):
print('begin live mode ----------------------------------')
# load profile
status = 'load'
self.c.setup_profile(profile_name, status)
# sub 'com' stream and view live mode
stream = ['com']
self.c.sub_request(stream)
class Subcribe():
def __init__(self):
self.headers = {}
self.objects = None
self.count = 0
self.tick = time.time()
self.maxEventsInBuffer = 100
self.stream_types = {}
self.is_first_for_type = {
"met": True,
"eeg": True,
"fac": True,
"mot": True,
}
self.c = Cortex(user, debug_mode=False)
self.c.do_prepare_steps()
self.time_slice = 0
self.time_data = {
'engagement': {},
'excitement': {},
'stress': {},
'relaxation': {},
'interest': {},
'focus': {}
}
self.time_slice_averages = {}
def add_cognitive_data_to_time_aggregation(self, event):
right_now = time.time()
current_time = str(right_now * 1000)
td = self.time_data
for key in td.keys():
new_value = event.get(key, None)
if new_value:
td[key][current_time] = new_value
self.time_slice_averages = {}
for key in td.keys():
ds = td[key]
keepers = {}
for t in ds.keys():
last_time = float(t) / 1000
if (right_now - last_time) <= 30:
keepers[t] = ds[t]
td[key] = keepers
vals = keepers.values()
self.time_slice_averages[key] = sum(vals) / len(vals)
event["last_30s"] = self.time_slice_averages
def prepare_metadata(self):
metadata = self.c.session_context["result"]
del metadata["recordIds"]
del metadata["recording"]
del metadata["id"]
headset = metadata["headset"]
del headset["motionSensors"]
del headset["sensors"]
del metadata["license"]
del metadata["performanceMetrics"]
del metadata["stopped"]
del metadata["streams"]
if self.c.user_id is None:
self.c.user_id = metadata["owner"]
self.c.device_id = headset["id"]
self.c.component_id = headset[
"virtualHeadsetId"] or "00000000-0000-0000-0000-000000000000"
del metadata["owner"]
del headset["id"]
del headset["virtualHeadsetId"]
def create_records_structure(self):
o = {
"id": str(uuid.uuid4()),
"sessionId": self.c.session_id,
"userId": self.c.user_id,
"deviceId": self.c.device_id.lower(),
"componentId": self.c.component_id,
"ts": datetime.datetime.now().isoformat(),
"metadata": {},
"eeg": [],
"cognitive": [],
"facial": [],
"motion": [],
}
metadata = self.c.session_context["result"]
o["metadata"] = metadata
return o
def publish_records(self):
my_keys = [
'engagement', 'excitement', 'stress', 'relaxation', 'interest',
'focus'
]
if len(self.objects['cognitive']) > 0:
event_data = self.objects
rows = self.objects['cognitive']
for x in range(len(rows)):
row = rows[x]
vals = []
for y in range(len(my_keys)):
k = my_keys[y]
vals.append(str(row[k]))
print(','.join(vals))
# print(json.dumps(event_data, indent=4))
send_kinesis(kinesis_client, kinesis_stream_name,
kinesis_shard_count, event_data) # send it!
self.objects = self.create_records_structure()
self.count = 0
self.tick = time.time()
def has_all_keys(self, record, keys):
answer = True
for k in keys:
answer = (answer and (k in record)) or False
return answer
def add_event(self, event, stream_name, sid):
if stream_name == 'met':
self.objects['cognitive'].append(event)
elif stream_name == 'eeg':
self.objects['eeg'].append(event)
elif stream_name == 'fac':
self.objects['facial'].append(event)
elif stream_name == 'mot':
self.objects['motion'].append(event)
def map_met(self, event):
if not event['engagementEnabled']:
del event['engagement']
if not event['excitementEnabled']:
del event['excitement']
del event['excitementLast1Min']
if not event['stressEnabled']:
del event['stress']
if not event['relaxationEnabled']:
del event['relaxation']
if not event['interestEnabled']:
del event['interest']
if not event['focusEnabled']:
del event['focus']
del event['engagementEnabled']
del event['excitementEnabled']
del event['stressEnabled']
del event['relaxationEnabled']
del event['interestEnabled']
del event['focusEnabled']
self.add_cognitive_data_to_time_aggregation(event)
def map_eeg(self, event):
if not event['hasMarkers']:
del event['markers']
del event['hasMarkers']
else:
event['hasMarkers'] = True
if not event['wasInterpolated']:
del event['wasInterpolated']
else:
event['wasInterpolated'] = True
def map_mot(self, e):
if not e['wasInterpolated']:
del e['wasInterpolated']
else:
e['wasInterpolated'] = True
def is_facial_data_redundant(self, event):
recent_facial_records = self.objects['facial']
if len(recent_facial_records) <= 0:
return False
last_facial_record = recent_facial_records[len(recent_facial_records) -
1]
compare_fields = [
"eyes", "upperFace", "upperFacePower", "lowerFace",
"lowerFacePower"
]
is_identical = True
for field in compare_fields:
if not (event[field] == last_facial_record[field]):
is_identical = False
return is_identical
def is_data_sample_relevant(self, event):
n = event['n']
# Get every 10th record using mathematics modulo
return (n % 5) == 0
def map_event(self, record, stream_name):
event = {}
sid = record['sid']
time_value = record['time']
headers = self.headers[stream_name]
if stream_name in record:
metrics = record[stream_name]
for i in range(len(headers)):
key = headers[i]
mapped_key = field_name_mapping[key] or key
val = metrics[i]
event[mapped_key] = val
event['ts'] = time_value
if stream_name == 'met':
self.map_met(event)
elif stream_name == 'eeg':
if self.is_data_sample_relevant(event):
self.map_eeg(event)
else:
event = None
elif stream_name == 'mot':
if self.is_data_sample_relevant(event):
self.map_mot(event)
else:
event = None
elif stream_name == 'fac':
if self.is_facial_data_redundant(event):
event = None
return event, sid
def get_record_type(self, record):
record_type = None
if 'eeg' in record: record_type = 'eeg'
elif 'mot' in record: record_type = 'mot'
elif 'fac' in record: record_type = 'fac'
elif 'met' in record: record_type = 'met'
return record_type
def process_headers(self, record):
header_data = record and record['result'] and record['result'][
'success']
for i in range(len(header_data)):
header = header_data[i]
cols = header['cols']
stream_name = header['streamName']
self.headers[stream_name] = cols
def on_data_received(self, data):
try:
record = json.loads(data)
except e as Error:
print(e)
sid = None
stream_name = None
# if the data record has a 'sid' field at the top level, then it is a summary
record_type = self.get_record_type(record)
if record_type:
self.count = self.count + 1
event, sid = self.map_event(record, record_type)
if event:
self.add_event(event, record_type, sid)
current_time = time.time()
# if (self.count >= self.maxEventsInBuffer) or ((current_time - self.tick) >= 1):
if (current_time - self.tick) >= 1:
self.publish_records()
else:
# Otherwise this is a special header record with all of the columns defined
self.process_headers(record)
def start(self, user_id, streams):
if self.c.ready_to_use:
self.c.user_id = user_id
self.prepare_metadata()
self.c.add_callback(self.on_data_received)
self.count = 0
self.objects = self.create_records_structure()
print(','.join([
'engagement', 'excitement', 'stress', 'relaxation', 'interest',
'focus'
]))
self.c.sub_request(streams)
