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