def main(argv):
'''Run the Protocol Regression Test Suite'''
do_setup = False
env_yaml = 'environment.yaml'
try:
opts, args = getopt.getopt(argv, 'hse:', ['setup', 'env='])
except getopt.GetoptError:
print 'proto-rt.py -s <do setup> -e <environment_file>'
sys.exit(2)
for opt, args in opts:
if opt == '-h':
print 'proto-rt.py -s <do setup> -e <environment_file>'
sys.exit(0)
elif opt in ('-e', '--env'):
env_yaml = args
elif opt in ('-s', '--setup'):
do_setup = True
env.load(env_yaml)
testrig.log_times('starting up')
# Now run the tests
cmd = './testrig.py ' + ' '.join(argv)
# FIXME: We are stacking the output up in the background!
retval = run_it(cmd)
# Clean-up the worst of it
if retval != 0:
testrig.test_umount_root()
testrig.log_times('wrapping up')
def main(argv):
'''Test the above functionality'''
command = env.pdshare_ctl + ' list'
env.load('environment.yaml')
retval = run_cmd('dd', command)
print 'The retval = ' + str(retval) + ' for the command ' + command
retval = mount('client', env.env['paths']['mount'], 'dd', '/')
print 'The retval = ' + str(retval) + ' for the mount'
if retval != 0:
sys.exit(1)
retval = umount('client', env.env['paths']['mount'])
print 'The retval = ' + str(retval) + ' for the umount'
def __init__(self, parser):
"""Constructs Emscripten configuration command"""
PlatformConfigurationCommand.__init__(
self,
'Emscripten',
parser, ['Unix Makefiles'], ['opengl'],
toolchain=env.load().emscripten_toolchain)
def __init__(self, parser):
"""Constructs Android configuration command"""
PlatformConfigurationCommand.__init__(
self,
'Android',
parser, ['Unix Makefiles'], ['opengl'],
toolchain=env.load().android_toolchain)
def main(argv):
'''Test the defaults for running fstest'''
env_yaml = 'environment.yaml'
try:
opts, args = getopt.getopt(argv, 'he:', ['env='])
except getopt.GetoptError:
print __file__ + ' -e <environment_file>'
sys.exit(2)
for opt, args in opts:
if opt == '-h':
print __file__ + ' -e <environment_file>'
sys.exit(0)
elif opt in ('-e', '--env'):
env_yaml = args
env.load(env_yaml)
test_fstest()
def main(argv):
"""Test the defaults for running cthon"""
env_yaml = "environment.yaml"
try:
opts, args = getopt.getopt(argv, "he:", ["env="])
except getopt.GetoptError:
print __file__ + " -e <environment_file>"
sys.exit(2)
for opt, args in opts:
if opt == "-h":
print __file__ + " -e <environment_file>"
sys.exit(0)
elif opt in ("-e", "--env"):
env_yaml = args
env.load(env_yaml)
test_cthon()
def main(argv):
'''Run the Protocol Regression Test Suite'''
do_setup = False
env_yaml = 'environment.yaml'
try:
opts, args = getopt.getopt(argv, 'hse:', ['setup', 'env='])
except getopt.GetoptError:
print 'testrig.py -s <do setup> -e <environment_file>'
sys.exit(2)
for opt, args in opts:
if opt == '-h':
print 'testrig.py -s <do setup> -e <environment_file>'
sys.exit(0)
elif opt in ('-e', '--env'):
env_yaml = args
elif opt in ('-s', '--setup'):
do_setup = True
env.load(env_yaml)
if do_setup:
test_pass('Setting up the dd, ds, and client with necessary software and directories', setup.init)
else:
print 'Skipping setting up the dd, ds, and client with necessary software and directories'
'''
log_times('starting up')
reset_protod(True, True)
share_tests()
mtime_test()
cthon_tests()
fstest_tests()
xfstests_tests()
reset_protod(True, True)
log_times('wrapping up')
'''
xfstests_tests()
return 0
def __init__(self, parser):
"""Constructs iOS configuration command"""
PlatformConfigurationCommand.__init__(
self,
'iOS',
parser, ['Xcode'], ['opengl'],
toolchain=env.load().ios_toolchain)
parser.add_argument('--identifier',
help='a bundle identifier to be used.')
parser.add_argument('--codesign',
nargs='+',
help='code sign identity name')
def __init__(self,
parser,
platforms,
generators=[],
fallback_generator=None):
"""Constructs a third party install command"""
cmake.Command.__init__(self,
parser,
generators,
output_dir=None,
source_dir=None)
self._platforms = platforms
self._env = env.load()
self._options = None
self._fallback_generator = fallback_generator
# Load external libraries descriptor
with open(os.path.join(self.env.home, 'Externals',
'Externals.yml')) as fh:
self._externals = yaml.load(fh.read())
# Add libraries to command line options
for external in self._externals:
name = external['name']
parser.add_argument(
'--no-%s' % name.lower(),
help='do not build a %s.' % name,
action='store_true',
default=False,
)
# Add platforms to command line options
for platform in platforms:
parser.add_argument(
'--no-%s' % platform.lower(),
help='do not bootstrap for %s.' % platform,
action='store_true',
default=False,
)
parser.add_argument(
'--no-build',
help='skips engine build and installation process',
action='store_true',
default=False,
)
parser.set_defaults(function=self.bootstrap)
def train_episode(self):
"""Train process of single episode."""
rewards = 0
step = 0
self.environment, _ = env.load(load_scheduler=False)
while not self.environment.terminated():
# observe state and predict action
observation = self.environment.summary()
action_index = self.dqn_train.get_action(observation, self.epsilon)
task_index, node_index = self._explain(action_index)
# invalid action, proceed to the next timestep
if task_index < 0 or node_index < 0:
self.environment.timestep()
continue
scheduled_task = self.environment.queue[task_index]
scheduled_node = self.environment.nodes[node_index]
scheduled = scheduled_node.schedule(scheduled_task)
if not scheduled:
self.environment.timestep()
continue
# apply action, calculate reward and train model
del self.environment.queue[task_index]
prev_observation = observation
reward = self.environment.reward()
observation = self.environment.summary()
rewards = rewards + reward
exp = {
's': prev_observation,
'a': action_index,
'r': reward,
's2': observation,
'done': self.environment.terminated()
}
self.dqn_train.add_experience(exp)
self.dqn_train.train(self.dqn_target)
step += 1
# copy weights from train model to target model periodically
if step % self.copy_steps == 0:
self.dqn_target.copy_weights(self.dqn_train)
# save model periodically
if step % self.save_steps == 0:
self.dqn_target.save_weights()
return rewards
"""Entrance."""
import env
if __name__ == '__main__':
environment, scheduler = env.load()
while not environment.terminated():
environment.plot()
actions = scheduler.schedule()
print(actions)
print('END')
lorder = np.argsort(lnames)
comb_pli = np.empty_like(plis[subj])
comb_pli[:] = np.NaN
for b in range(num_bands):
for p in range(num_perms):
M = mirror(plis[subj][p, b, :, :])
for l, label in enumerate(lorder):
for l2, label2 in enumerate(lorder):
comb_pli[p, b, l, l2] = M[label, label2]
sorted_plis[subj] = comb_pli
lnames.sort()
return sorted_plis, lnames
def get_null_distributions(plis):
# returns a null distribution per subject x band that is computed taking the mean over ROIs. Format is dict['subj'][perms x bands]
rplis = {}
for subj, data in plis.iteritems():
rplis[subj] = np.nanmax(stats.nanmean(data, axis=-1), axis=-1)
return rplis
res = env.load(env.results + 'good_plis_all_chl.5_lp58_hp.5_visual.npz')
plis = res['plis']
res = env.load(env.results + 'selected_voxels_all_chl.5_lp58_hp.5_visual.npz')
adhd, labels = combine_data(list(res['good_adhds']), res['labels'], plis)
nv, labels = combine_data(list(res['good_nvs']), res['labels'], plis)
fid = open(subjs_fname, 'r')
subjs = [line.rstrip() for line in fid]
nfid = open(nvs_fname, 'r')
afid = open(adhds_fname, 'r')
pfid = open(persistent_fname, 'r')
rfid = open(remitted_fname, 'r')
adhds = [line.rstrip() for line in afid]
nvs = [line.rstrip() for line in nfid]
persistent = [line.rstrip() for line in pfid]
remitted = [line.rstrip() for line in rfid]
sx = np.recfromcsv(sx_fname)
hi = [rec[2] for s in subjs for rec in sx if rec[0] == s]
inatt = [rec[1] for s in subjs for rec in sx if rec[0] == s]
res = env.load(ica_fname)
time_pts = 241
nv_power = []
adhd_power = []
per_power = []
rem_power = []
cnt = 0
# split the subjects into their respective groups
for s in subjs:
subj_power = np.mean(res['band_ICs'][:, :, cnt:cnt + time_pts], axis=2)
cnt += time_pts
if s in nvs:
nv_power.append(subj_power)
else:
adhd_power.append(subj_power)
if s in persistent:
def __init__(self,
platform,
parser,
generators,
rendering_backend,
toolchain=None):
"""Constructs a platform configuration command"""
# Load active environment
self._env = env.load()
cmake.Command.__init__(self,
parser,
generators,
prefix_path=os.path.join(
self.env.dependencies, platform))
command_line.add_component(
parser,
'pch',
description=
'generate a build system that uses precompiled headers.',
default=False)
command_line.add_component(
parser,
'composer',
description='do not build the Composer tool.',
default=False)
command_line.add_component(
parser,
'relight',
description='do not build the Relight lightmapping library.',
default=False)
command_line.add_component(parser,
'tests',
description='do not build unit tests.',
default=False)
command_line.add_component(parser,
'examples',
description='do not build examples.')
command_line.add_component(parser,
'sound',
description='build with no sound support.')
command_line.add_component(
parser,
'renderer',
description='build with no rendering support.',
options=rendering_backend)
# Add third party libraries options
self._libraries = [
'TIFF', 'jsoncpp', 'Zlib', 'Box2D', 'GTest', 'PNG', 'Lua', 'Ogg',
'Vorbis', 'OpenAL', 'cURL'
]
for lib in self._libraries:
command_line.add_library(parser, lib)
self._toolchain = toolchain
parser.set_defaults(function=self.configure)
def install():
component = None
# warn the user before performing any action.
warning()
# display some stuff.
env.display(env.HEADER_NONE, "", env.OPTION_NONE)
env.display(env.HEADER_OK,
"installing kaneton binaries on the boot device",
env.OPTION_NONE)
# generates the grub menu file.
menu()
# depending on the boot mode and boot device, install the kaneton binaries
# and the grub menu file.
if env._BOOT_MODE_ == "peripheral":
if env.load(g_menu, env._MDEVICE_, "/boot/grub/menu.lst",
env.OPTION_DEVICE) != 0:
env.display(env.HEADER_ERROR,
"unable to load the menu.lst file",
env.OPTION_NONE)
sys.exit(42)
for component in g_components:
if not env.path(component, env.OPTION_EXIST):
env.display(env.HEADER_ERROR, " " + component, env.OPTION_NONE)
else:
if env.load(component, env._MDEVICE_, "/modules/",
env.OPTION_DEVICE) != 0:
env.display(env.HEADER_ERROR,
"unable to load the component '" + component + "'",
env.OPTION_NONE)
sys.exit(42)
env.display(env.HEADER_OK, " " + component, env.OPTION_NONE)
elif env._BOOT_MODE_ == "network":
if env.load(g_menu, env._MDEVICE_, "/boot/grub/menu.lst",
env.OPTION_DEVICE) != 0:
env.display(env.HEADER_ERROR,
"unable to load the menu.lst file",
env.OPTION_NONE)
sys.exit(42)
for component in g_components:
if not env.path(component, env.OPTION_EXIST):
env.display(env.HEADER_ERROR, " " + component, env.OPTION_NONE)
else:
env.copy(component, env._TFTP_DIRECTORY_, env.OPTION_NONE)
env.display(env.HEADER_OK, " " + component, env.OPTION_NONE)
elif env._BOOT_MODE_ == "image":
if env.load(g_menu, env._IMAGE_, "/boot/grub/menu.lst",
env.OPTION_IMAGE) != 0:
env.display(env.HEADER_ERROR,
"unable to load the menu.lst file",
env.OPTION_NONE)
sys.exit(42)
for component in g_components:
if not env.path(component, env.OPTION_EXIST):
env.display(env.HEADER_ERROR, " " + component, env.OPTION_NONE)
else:
if env.load(component, env._IMAGE_, "/modules/",
env.OPTION_IMAGE) != 0:
env.display(env.HEADER_ERROR,
"unable to load the component '" + component + "'",
env.OPTION_NONE)
sys.exit(42)
env.display(env.HEADER_OK, " " + component, env.OPTION_NONE)
else:
env.display(env.HEADER_ERROR, "unknown boot mode '" + env._BOOT_MODE_ +
"'", env.OPTION_NONE)
sys.exit(42)
author: Ian Brault <*****@*****.**>
created: 19 May 2018
"""
import os
import re
from urllib.parse import unquote_plus
from aiohttp import web
from twilio.rest import Client
import env
from logger import log
# load environment variables
env.load()
# set up Twilio client
twilio_num = os.getenv('TWILIO_NUM')
twilio_sid = os.getenv('TWILIO_SID')
twilio_tok = os.getenv('TWILIO_TOKEN')
twilio_client = Client(twilio_sid, twilio_tok)
def is_mfa_sms(msg):
"""
check if a received SMS contains MFA passcodes
@param msg (str): SMS message contents
@return (bool)
"""
return msg.startswith("SMS passcodes: ")
Classifies between ADHD and NV based on band power
"""
# Authors: Gustavo Sudre, 01/2013
import numpy as np
from sklearn.ensemble import RandomForestClassifier
from sklearn import cross_validation
from scipy import stats
import env
from sklearn.feature_selection import RFECV
from sklearn.svm import SVC
from sklearn.feature_selection import SelectPercentile, f_classif
res = env.load(env.results + "roi_power_chl.5_lp58_hp.5_th3500e15.npz")
subjs = list(res["good_nvs"]) + list(res["good_adhds"])
num_roi = 68
num_band = 5
labels = np.empty([len(subjs)])
for s, subj in enumerate(subjs):
if any(subj in i for i in res["good_adhds"]):
labels[s] = -1
else:
labels[s] = 1
### BAND PSD FEATURES ###
band_psd = np.empty([len(subjs), num_roi * num_band])
band_psd[:] = np.NaN
def install():
component = None
# warn the user before performing any action.
warning()
# display some stuff.
env.display(env.HEADER_NONE, "", env.OPTION_NONE)
env.display(env.HEADER_OK,
"installing kaneton binaries on the boot device",
env.OPTION_NONE)
# generates the grub menu file.
menu()
# depending on the boot mode and boot device, install the kaneton binaries
# and the grub menu file.
if env._BOOT_MODE_ == "peripheral":
if env.load(g_menu, env._MDEVICE_, "/boot/grub/menu.lst",
env.OPTION_DEVICE) != 0:
env.display(env.HEADER_ERROR, "unable to load the menu.lst file",
env.OPTION_NONE)
sys.exit(42)
for component in g_components:
if not env.path(component, env.OPTION_EXIST):
env.display(env.HEADER_ERROR, " " + component,
env.OPTION_NONE)
else:
if env.load(component, env._MDEVICE_, "/modules/",
env.OPTION_DEVICE) != 0:
env.display(
env.HEADER_ERROR,
"unable to load the component '" + component + "'",
env.OPTION_NONE)
sys.exit(42)
env.display(env.HEADER_OK, " " + component, env.OPTION_NONE)
elif env._BOOT_MODE_ == "network":
if env.load(g_menu, env._MDEVICE_, "/boot/grub/menu.lst",
env.OPTION_DEVICE) != 0:
env.display(env.HEADER_ERROR, "unable to load the menu.lst file",
env.OPTION_NONE)
sys.exit(42)
for component in g_components:
if not env.path(component, env.OPTION_EXIST):
env.display(env.HEADER_ERROR, " " + component,
env.OPTION_NONE)
else:
env.copy(component, env._TFTP_DIRECTORY_, env.OPTION_NONE)
env.display(env.HEADER_OK, " " + component, env.OPTION_NONE)
elif env._BOOT_MODE_ == "image":
if env.load(g_menu, env._IMAGE_, "/boot/grub/menu.lst",
env.OPTION_IMAGE) != 0:
env.display(env.HEADER_ERROR, "unable to load the menu.lst file",
env.OPTION_NONE)
sys.exit(42)
for component in g_components:
if not env.path(component, env.OPTION_EXIST):
env.display(env.HEADER_ERROR, " " + component,
env.OPTION_NONE)
else:
if env.load(component, env._IMAGE_, "/modules/",
env.OPTION_IMAGE) != 0:
env.display(
env.HEADER_ERROR,
"unable to load the component '" + component + "'",
env.OPTION_NONE)
sys.exit(42)
env.display(env.HEADER_OK, " " + component, env.OPTION_NONE)
else:
env.display(env.HEADER_ERROR,
"unknown boot mode '" + env._BOOT_MODE_ + "'",
env.OPTION_NONE)
sys.exit(42)
from flask import Flask, request
import mysql.connector
from mysql.connector import Error
from env import load
import json
import os
app = Flask(__name__)
load()
try:
connection = mysql.connector.connect(host=os.environ['HOST'],
user=os.environ['USER'],
password=os.environ['PASSWORD'],
database=os.environ['DATABASE'])
if connection.is_connected():
cursor = connection.cursor()
except Error as e:
print("Error while connecting to MySQL", e)
@app.route('/')
def add_user():
sql_insert_query = """ INSERT INTO `users` (`id`, `name`, `age`) VALUES (0,'Luciano Albis', 34)"""
cursor.execute(sql_insert_query)
connection.commit()
return 'User add!'
@app.route('/list_user')
def setUp(self):
load('.env')
os.environ['KIT_DEBUG'] = '0'
self.msg = Message("TEST_TOPIC", [{'bn': 'TEST_', 'n': 'ING', 'u': 'test', 'vs': 'testing'}])
def main(argv): '''Test the basic functionality in this module''' env.load() delete_all_shares() create_all_shares() list_all_shares()
Classifies between ADHD and NV based on band power
"""
# Authors: Gustavo Sudre, 01/2013
import numpy as np
from sklearn.ensemble import RandomForestClassifier
from sklearn import cross_validation
from scipy import stats
import env
from sklearn.feature_selection import RFECV
from sklearn.svm import SVC
from sklearn.feature_selection import SelectPercentile, f_classif
res = env.load(env.results + 'roi_power_chl.5_lp58_hp.5_th3500e15.npz')
subjs = list(res['good_nvs']) + list(res['good_adhds'])
num_roi = 68
num_band = 5
labels = np.empty([len(subjs)])
for s, subj in enumerate(subjs):
if any(subj in i for i in res['good_adhds']):
labels[s] = -1
else:
labels[s] = 1
### BAND PSD FEATURES ###
band_psd = np.empty([len(subjs), num_roi * num_band])
band_psd[:] = np.NaN
