def getData(day=None): if day is None: today = datetime.date.today() time_filter = today - datetime.timedelta(days=int(env('TIMEDELTA'))) else: time_filter = day # db config, connect to mariaDB-database hostname = 'localhost' username = env('DB_USERNAME') password = env('DB_PASSWORD') database = env('DB_DATABASE') port = int(env('DB_PORT')) # connect to db try: connection = mariadb.connect(host=hostname, user=username, password=password, database=database, port=port) except mariadb.Error as e: print(f"Error connecting to MariaDB Platform: {e}") sys.exit(1) # get data df = pd.read_sql_query( f"""SELECT * FROM {env('DB_TABLE')} WHERE eintragungsdatum = '{time_filter}' AND NOT region = 'Deutschland';""", connection) # close db connection connection.close() # return output return df
def __init__(self, envs=os.environ): """ Figures out the Consul client hostname based on whether or not we're using a local Consul agent. """ if env('CONSUL_AGENT', False, envs, fn=to_flag): self.host = 'localhost' else: self.host = env('CONSUL', 'consul', envs) self.client = pyconsul.Consul(host=self.host)
def download(): header = request.Head() header.addHeader('X-EBAY-API-CALL-NAME', 'GetCategories') header.addHeader('X-EBAY-API-APP-NAME', env('APP_NAME')) header.addHeader('X-EBAY-API-CERT-NAME', env('CERT_NAME')) header.addHeader('X-EBAY-API-DEV-NAME', env('EBAY_API_DEV_NAME')) header.addHeader('X-EBAY-API-SITEID', '0') header.addHeader('X-EBAY-API-COMPATIBILITY-LEVEL', '989') header.addHeader('Content-Type', 'text/xml') body = request.Body('ebayGetCategories', 'EBAY_AUTH_TOKEN').getXML() headers = header.getAll() ebayAPI = api.API('EBAY_API_URL') ebayAPI.requestXML(headers, body) ebayAPI.exportXML('GetCategories') return ebayAPI
def __init__(self): self.env = env() self.urlShort = urlShort() self.matches = {} self.r = '' self.matchLimit = 5 self.body = ''
def __init__(self, config): self.config = config self.env = env(self.config) from function_approximation import rnn_model np.random.seed(int(time.time())) os.environ["CUDA_VISIBLE_DEVICES"] = str(0) self.pv_agent = rnn_model.create_model_without_distributed(self.config)
def main(): q_value = {} max_step = 1000 model = Priority_model() params_dyna = DynaParamater() params_dyna.planning_steps = 5 params_dyna.alpha = 0.5 params_dyna.gamma = 0.95 en = env() backups, avg_list_reward = priority_sweeping(q_value, model, en, params_dyna, max_step) # print(backups) # print(avg_list_reward) df = pd.DataFrame({'x': range(max_step), 'y_1': avg_list_reward}) plt.xlabel("Time Slot") plt.ylabel("Time Average Cost") plt.plot('x', 'y_1', data=df, marker='o', markevery=int(max_step / 10), color='red', linewidth=1, label="planing") plt.legend() plt.grid() plt.show()
def __init__(self, num_stations, action_space, episode, threshold, collaboration): # Performance Metrics self.success_ratios = {} self.team_cumulative_rewards = {} self.timestamp = self.get_timestamp(True) self.result_dir = "./performance_log/" + self.timestamp + "/graphs/" if not os.path.exists(self.result_dir): os.makedirs(self.result_dir) # Env, Agent, and Key Attributes self.env = env(num_stations, 50, threshold) self.init_stocks = [] self.current_stocks = self.init_stocks self.num_stations = num_stations self.action_space = action_space self.q_tables = [] self.merged_table = 0 self.mode = "learn" self.collaboration = collaboration self.threshold = threshold for idx in range(num_stations): self.init_stocks.append(50) self.agent_manager = agent_manager(self.num_stations, self.action_space, self.init_stocks, self.collaboration) if type(episode) == int: self.eps = [episode]
def main(): en = env() dyna_params = DynaParamas() max_step = 10000 q_value = {} model = TrivialModel() result, avg_result = dyna_q(q_value, model, en, dyna_params, max_step) print(avg_result) df = pd.DataFrame({'x': range(max_step), 'y_1': avg_result}) plt.xlabel("Time Slot") plt.ylabel("Time Average Cost") plt.plot('x', 'y_1', data=df, marker='o', markevery=int(max_step / 10), color='red', linewidth=1, label="planing") plt.legend() plt.grid() plt.show()
def __init__(self, usrp_source, epsilon_threshold): gr.sync_block.__init__(self, name="RL_engine", in_sig=[numpy.float32], out_sig=None) self.usrp_source = usrp_source self.slot_interval = 0.5 self.sensing_duration = 0.02 self.time_factor = 1 self.sum_slots = -1 self.epsilon_threshold = epsilon_threshold self.average_power_dbm = 0.0 self.samp_rate = 1000000 self.N_samp = int((self.sensing_duration * self.samp_rate)) self.magnitude_sq = [] self.primary_user_status = { 'no_result': 0, 'not_detected': 1, 'detected': 2, } # 0: energy det. has no result, 1: PU not detected, 2: PU detected. #for RL self.RL_step_count = 0 self.avg_reward = 0 self.avg_window = 100 self.round_to_change_greedy = 300 self.env = env() self.RL = QLearningTable(actions=list(range(self.env.n_actions))) self.s = self.env.reset() # self.result=np.chararray((n_round,4),itemsize=10) #end for RL self.energy_det_status = self.primary_user_status['no_result'] currenttime = self.usrp_source.get_mboard_sensor("gps_time") self.start_time = time.time() self.slot_monitor()
def game(): global gamestate global result global action1 Env = env.env(1,10) while gamestate == 1: while True: screen.blit(grass,(0,0)) screen.blit(band,(600,0)) #text = font.render("Red Win",10,(0,0,0)) #screen.blit(text,(600,100)) if Env.done == False: for i in range(Env.size): for j in range(Env.size): count = Env.state[i][j] if( count % 10 == 1 ): if Env.R_Soldier[0].bullet_count > 0: screen.blit(redgun,(block*j,block*i)) else: screen.blit(rednogun,(block*j,block*i)) if( count/10 == 1 ): if Env.B_Soldier[0].bullet_count > 0: screen.blit(bluegun,(block*j,block*i)) else: screen.blit(bluenogun,(block*j,block*i)) if (Env.gameover() == True): gamestate = 2 if Env.win == 1: result = 1 elif Env.win == 0: result = 0 else: result = -1 break textRB = font.render("Red Bullet:" + str(Env.R_Soldier[0].bullet_count), 10, (255, 0, 0)) screen.blit(textRB, (620, 100)) textBB = font.render("Blue Bullet:" + str(Env.B_Soldier[0].bullet_count), 10, (0, 0, 255)) screen.blit(textBB, (620, 150)) distance = Env.calcdist(Env.R_Soldier[0], Env.B_Soldier[0]) textdis = font.render("distance:" + str(distance), 10, (0, 0, 0)) screen.blit(textdis, (620, 200)) textRR = font.render("Red Acc:"+str(round(Shoot.f1(distance),3)),10,(255,0,0)) screen.blit(textRR,(620,250)) textBR = font.render("Blue Acc:"+str(round(Shoot.f2(distance),3)),10,(0,0,255)) screen.blit(textBR,(620,300)) if len(Env.R_Soldier) > 0 and len(Env.B_Soldier)>0: time.sleep(0.5) dis = Env.calcdist(Env.R_Soldier[0], Env.B_Soldier[0]) action1 = Env.R_Soldier[0].act(dis,20,20) action2 = Env.B_Soldier[0].act(dis,21,21) Env.stepshoot(action1,action2) pygame.display.update()
def __init__(self, envs=os.environ): self.mysql_db = env('MYSQL_DATABASE', None, envs) self.mysql_user = env('MYSQL_USER', None, envs) self.mysql_password = env('MYSQL_PASSWORD', None, envs) self.mysql_root_password = env('MYSQL_ROOT_PASSWORD', '', envs) self.mysql_random_root_password = env('MYSQL_RANDOM_ROOT_PASSWORD', True, envs, to_flag) self.mysql_onetime_password = env('MYSQL_ONETIME_PASSWORD', False, envs, to_flag) self.repl_user = env('MYSQL_REPL_USER', None, envs) self.repl_password = env('MYSQL_REPL_PASSWORD', None, envs) self.datadir = env('MYSQL_DATADIR', '/var/lib/mysql', envs) self.pool_size = env('INNODB_BUFFER_POOL_SIZE', 0, envs, fn=int) # state self.ip = get_ip() self._conn = None self._query_buffer = OrderedDict()
def testppo(train, turn, battle, random_seed, nash_lower=20, nash_upper=20): a = args a.num_episode = train networkB = ppo(a) torch.manual_seed(10) np.random.seed(random_seed) Env = env.env(10) num_inputs = 4 red = [] blue = [] for i_turn in range(turn): red_win = 0 blue_win = 0 running_state = ZFilter((num_inputs, ), clip=5.0) for j in range(battle): stateR, stateB, RR, RB, done, _ = Env.reset() while Env.done == False: stateR_last = stateR stateB_last = stateB stateB = running_state(stateB) action_mean, action_logstd, value = networkB( Tensor(stateB).unsqueeze(0)) action, logprob = networkB.select_action( action_mean, action_logstd) action = action.data.numpy()[0] actionB = ou_ppo(np.argmax(action, axis=0), stateR_last, stateB_last, networkB.step) dis = Env.calcdist(Env.R_Soldier[0], Env.B_Soldier[0]) actionR = Env.R_Soldier[0].act(dis) next_stateR, next_state, reward_R, reward, done, _ = Env.stepshoot( actionR, actionB) stateR = next_stateR stateB = next_state if done: break if Env.win == 1: red_win += 1 elif Env.win == -1: blue_win += 1 else: red_win += 0.5 blue_win += 0.5 red.append(red_win) blue.append(blue_win) print("Turn: {} ,red win: {},blue win: {}".format( i_turn, red_win, blue_win)) print("-----------------") print("Blue Win: {},T test: {}".format(np.mean(blue), stats.ttest_rel(red, blue)))
def setRequesterCredentials(self, token): try: if isinstance(token, str) and self.root != None: for elem in self.root.iter(): if re.sub('{.*?}', '', elem.tag) == 'eBayAuthToken': elem.text = env(token) self.tree.write(self.path, encoding="utf-8", method="xml") #print('Set Requester Credentials') except Exception as e: raise
def default_env(*args, **kwargs): if not getattr(default_env, '_loaded', False): path = os.path.join( os.path.expanduser('~'), '.box.env', ) if os.path.isfile(path): dotenv.read_dotenv(path) default_env._loaded = True return dotenv.env(*args, **kwargs)
def __init__(self): self.env = env() self.SMTP_SERVER = "smtp.gmail.com" self.SMTP_PORT = 587 self.SMTP_USERNAME = self.env.sending_email self.SMTP_PASSWORD = self.env.email_pass self.EMAIL_TO = [self.env.revieving_email] self.EMAIL_FROM = self.env.sending_email self.EMAIL_SUBJECT = "" self.DATE_FORMAT = "%d/%m/%Y" self.EMAIL_SPACE = ", " self.DATA = ""
def __init__(self): self.connection = pymysql.connect( host=env('mysql','host','127.0.0.1'), user=env('mysql','user','root'), password=env('mysql','password', '123456'), db=env('mysql','db', 'test'), port=int(env('mysql','port', 3306)), cursorclass=pymysql.cursors.DictCursor, write_timeout=int(env('mysql','write_timeout', 60)), read_timeout=int(env('mysql','read_timeout', 30)) )
def on_status(self, status): """Called when a new status arrives""" data = status._json if data['user']['id_str'] not in self.twitter_ids: return True LOG.info( strftime("[%Y-%m-%d %H:%M:%S]", gmtime()) + " " + data['user']['screen_name'] + ' twittered.') for twitter_id in self.twitter_ids: if data['user']['id_str'] != twitter_id: worthPosting = False if env( 'includeReplyToUser' ): # other Twitter user tweeting to your followed Twitter user if data['in_reply_to_user_id_str'] == twitter_id: worthPosting = True else: worthPosting = True # your followed Twitter users tweeting to random Twitter users # (relevant if you only want status updates/opt out of conversations) if env('includeUserReply' ) is False and data['in_reply_to_user_id'] is not None: worthPosting = False if env('includeRetweet') is False: if 'retweeted_status' in data: worthPosting = False # retweet if not worthPosting: continue text, media_type, media_url = resolve_tweet(data) telegram_publish(text, media_type, media_url) return True
def td0(episodes): V = np.zeros((5, 7)) discount = 0.9 alpha = 0.2 for _ in np.arange(episodes): startingState = (3, 0) grid = env.env(startingState) terminate = 0 while terminate == 0: a = np.random.choice([1, 3, 5], p=[0.25, 0.5, 0.25]) s = grid.state (r, terminate) = grid.step(a) V[s] = V[s] + alpha * (r + discount * V[grid.state] - V[s]) return V
def __init__(self): self.env = env() self.n_actions = len(self.env.actions) self.n_feature = len(self.env.state) self.learning_rate = 0.01 self.gamma = 0.8 self.e_greedy = 0 self.e_greedy_increment = 0.0001 self.memory_size = 100000 self.batch_size = 10000 self.replace_target_iter = 500 self.output_graph = True self.double_q = True self.dueling = True pass
def telegram_publish(text, media_type, media_url): for x in env('TELEGRAM_BOT_GROUPS'): try: bot.send_message( x, text, 'Markdown', True # disable_web_page_preview ) if media_type == 'video' or media_type == 'gif': bot.send_video(x, media_url) elif media_type == 'photo': bot.send_photo(x, media_url) except Exception as err: print(err)
def authenhandler(req): global username, name e = env.env(req, 'provider1.example.com') password = req.get_basic_auth_pw() username = req.user if (username and password): for user in structures.InternalUser.InternalUser.dbLoad(e, e.con, query={'Username': username, 'Password': password}, orderBy=('Username',)): # Reverify password because of possible database case-insensitivity. if user.values['Username'].lower() == username.lower() and user.values['Password'] == password: name = user.values['Name'] break if (name): return apache.OK else: return apache.HTTP_UNAUTHORIZED
def load(self, envs=os.environ): """ Fetches the ContainerPilot config file and asks ContainerPilot to render it out so that all environment variables have been interpolated. """ self.path = env('CONTAINERPILOT', None, envs) log.debug("loading cp {}".format(self.path)) try: cfg = subprocess.check_output( ['containerpilot', '-config', self.path, '-template'], env=envs.copy()) except (subprocess.CalledProcessError, OSError) as ex: log.error('containerpilot -template returned error: %s', ex) raise (ex) config = json5.loads(cfg) self.config = config
def QLearningUsingEpsilonGreedy(episodes): Q = np.zeros((5, 7, 8)) discount = 0.9 alpha = 0.2 epsilon = 0.1 for _ in np.arange(episodes): startingState = (3, 0) grid = env.env(startingState) terminate = 0 while terminate == 0: s = grid.state if np.random.rand() > epsilon: a = np.argmax(Q[s[0], s[1], :]) else: a = np.random.choice([1, 3, 5], p=[0.25, 0.5, 0.25]) (r, terminate) = grid.step(a) Q[s[0], s[1], a] = Q[s[0], s[1], a] + alpha * (r + (discount * np.max( Q[grid.state[0], grid.state[1], :])) - Q[s[0], s[1], a]) return Q
tabla = fix_columns(tabla) tabla_h = fix_columns(tabla_h) tabla_wp = fix_columns(tabla_wp) tabla = tabla.astype({'response_time_avg' : 'float64'}) tabla = tabla.astype({'response_time_first' : 'float64'}) tabla = tabla.astype({'response_time_max' : 'float64'}) self.history = tabla_h self.webpath = tabla_wp self.tabla = tabla return tabla if __name__ == "__main__" : env() #Lista de parejas de fechas que representan un mes, empezando desde la fecha de entrada hasta la actualidad lista = fechas("2018-04-01").fechas engine = create_engine("postgresql+psycopg2://{user}:{contr}@{host}:{port}/{base}".format( user = os.environ['REDSHIFT_USER'], contr= os.environ["REDSHIFT_PASSWORD"], port= os.environ["REDSHIFT_PORT"], base= os.environ["REDSHIFT_DB"], host= os.environ["REDSHIFT_HOST"] ), connect_args={'options': '-csearch_path={schema}'.format( schema = os.environ["REDSHIFT_SCHEMA"] )}, echo = False) j = 0 t = [] h = [] w = []
import urllib2 import argparse import os import sys import logging import time DIRNAME = os.path.dirname(os.path.realpath(__file__)) sys.path.append(os.path.join(DIRNAME, '..', 'common')) RESTART_SCRIPT = os.path.join(DIRNAME, "restart_remote_fcgi.sh") import log import env siteconfig = os.path.join(DIRNAME, "..", "siteconfig.sh") var = env.env(siteconfig) SERVER_NAME = var["SERVER_NAME"] MAX_RETRIES = 30 class RestartWorkerError(Exception): pass def restart_remote_fcgi(server, username, sshport, request_url, logger, max_retries=MAX_RETRIES): # ssh username@server -p sshport, then executes restart_fcgi.sh on server # after executing restart_fcgi.sh on server, keeps requesting request_url # until the request succeeds (up to max_retries) logger.debug("Restarting FCGI workers on %s", server) logger.debug("max_retries = %d", max_retries) cmd = [RESTART_SCRIPT, username,
def ppo(args): Env = env.env(10) # env = gym.make(args.env_name) # num_inputs = env.observation_space.shape[0] # num_actions = env.action_space.shape[0] num_inputs = 4 num_actions = 10 # env.seed(args.seed) torch.manual_seed(args.seed) networkR = ActorCritic(num_inputs, num_actions, layer_norm=args.layer_norm) networkB = ActorCritic(num_inputs, num_actions, layer_norm=args.layer_norm) optimizerR = opt.Adam(networkR.parameters(), lr=args.lr) optimizerB = opt.Adam(networkB.parameters(), lr=args.lr) running_state = ZFilter((num_inputs, ), clip=5.0) # record average 1-round cumulative reward in every episode reward_record_R = [] reward_record_B = [] global_steps = 0 lr_now = args.lr clip_now = args.clip for i_episode in range(args.num_episode): # 当前策略更新 memoryR = Memory() memoryB = Memory() num_steps = 0 reward_list_R = [] reward_list_B = [] len_list = [] while num_steps < args.batch_size: stateR, stateB, _, _, _, _ = Env.reset() if args.state_norm: stateR = running_state(stateR) stateB = running_state(stateB) reward_sum_R = 0 reward_sum_B = 0 for t in range(args.max_step_per_round): action_mean_R, action_logstd_R, value_R = networkR( Tensor(stateR).unsqueeze(0)) action_mean_B, action_logstd_B, value_B = networkR( Tensor(stateB).unsqueeze(0)) actionR, logprobaR = networkR.select_action( action_mean_R, action_logstd_R) actionB, logprobaB = networkB.select_action( action_mean_B, action_logstd_B) actionR = actionR.data.numpy()[0] actionB = actionB.data.numpy()[0] actionR_real = np.argmax(actionR, axis=0) actionB_real = np.argmax(actionB, axis=0) if Env.R_Soldier[0].bullet_count == 0: actionR_real = actionR_real % 5 if Env.B_Soldier[0].bullet_count == 0: actionB_real = actionB_real % 5 logprobaR = logprobaR.data.numpy()[0] logprobaB = logprobaB.data.numpy()[0] dis = Env.calcdist(Env.R_Soldier[0], Env.B_Soldier[0]) #actionR = Env.R_Soldier[0].act(dis) next_state_R, next_state_B, reward_R, reward_B, done, _ = Env.stepshoot( actionR_real, actionB_real) reward_sum_R += reward_R reward_sum_B += reward_B if args.state_norm: next_state_R = running_state(next_state_R) next_state_B = running_state(next_state_B) mask = 0 if done else 1 memoryR.push(stateR, value_R, actionR, logprobaR, mask, next_state_R, reward_R) memoryB.push(stateB, value_B, actionB, logprobaB, mask, next_state_B, reward_B) if done: networkR.step += 1 networkB.step += 1 break stateR = next_state_R stateB = next_state_B num_steps += (t + 1) global_steps += (t + 1) reward_list_R.append(reward_sum_R) reward_list_B.append(reward_sum_B) len_list.append(t + 1) reward_record_R.append({ 'episode': i_episode, 'steps': global_steps, 'meanepreward': np.mean(reward_list_R), 'meaneplen': np.mean(len_list) }) reward_record_B.append({ 'episode': i_episode, 'steps': global_steps, 'meanepreward': np.mean(reward_list_B), 'meaneplen': np.mean(len_list) }) batchR = memoryR.sample() batchB = memoryB.sample() batch_size = len(memoryR) # Sample Parameters rewardsR = Tensor(batchR.reward) valuesR = Tensor(batchR.value) masksR = Tensor(batchR.mask) actionsR = Tensor(batchR.action) statesR = Tensor(batchR.state) oldlogprobaR = Tensor(batchR.logproba) rewardsB = Tensor(batchB.reward) valuesB = Tensor(batchB.value) masksB = Tensor(batchB.mask) actionsB = Tensor(batchB.action) statesB = Tensor(batchB.state) oldlogprobaB = Tensor(batchB.logproba) returnsR = Tensor(batch_size) deltasR = Tensor(batch_size) advantagesR = Tensor(batch_size) returnsB = Tensor(batch_size) deltasB = Tensor(batch_size) advantagesB = Tensor(batch_size) prev_return_R = 0 prev_value_R = 0 prev_advantage_R = 0 prev_return_B = 0 prev_value_B = 0 prev_advantage_B = 0 for i in reversed(range(batch_size)): returnsR[i] = rewardsR[i] + args.gamma * prev_return_R * masksR[i] deltasR[i] = rewardsR[ i] + args.gamma * prev_value_R * masksR[i] - valuesR[i] advantagesR[i] = deltasR[ i] + args.gamma * args.lamda * prev_advantage_R * masksR[i] returnsB[i] = rewardsB[i] + args.gamma * prev_return_B * masksB[i] deltasB[i] = rewardsB[ i] + args.gamma * prev_value_B * masksB[i] - valuesB[i] advantagesB[i] = deltasB[ i] + args.gamma * args.lamda * prev_advantage_B * masksB[i] prev_return_R = returnsR[i] prev_value_R = valuesR[i] prev_advantage_R = advantagesR[i] prev_return_B = returnsB[i] prev_value_B = valuesB[i] prev_advantage_B = advantagesB[i] if args.advantage_norm: advantagesR = (advantagesR - advantagesR.mean()) / (advantagesR.std() + EPS) advantagesB = (advantagesB - advantagesB.mean()) / (advantagesB.std() + EPS) for i_epoch in range( int(args.num_epoch * batch_size / args.minibatch_size)): # current batch sample minibatch_ind = np.random.choice(batch_size, args.minibatch_size, replace=False) minibatch_statesR = statesR[minibatch_ind] minibatch_actionsR = actionsR[minibatch_ind] minibatch_oldlogprobaR = oldlogprobaR[minibatch_ind] #print(minibatch_statesR,minibatch_actionsR) minibatch_newlogprobaR = networkR.get_logproba( minibatch_statesR, minibatch_actionsR) minibatch_advantagesR = advantagesR[minibatch_ind] minibatch_returnsR = returnsR[minibatch_ind] minibatch_newvaluesR = networkR._forward_critic( minibatch_statesR).flatten() minibatch_statesB = statesB[minibatch_ind] minibatch_actionsB = actionsB[minibatch_ind] minibatch_oldlogprobaB = oldlogprobaB[minibatch_ind] minibatch_newlogprobaB = networkB.get_logproba( minibatch_statesB, minibatch_actionsB) minibatch_advantagesB = advantagesB[minibatch_ind] minibatch_returnsB = returnsB[minibatch_ind] minibatch_newvaluesB = networkB._forward_critic( minibatch_statesB).flatten() ratioR = torch.exp(minibatch_newlogprobaR - minibatch_oldlogprobaR) ratioB = torch.exp(minibatch_newlogprobaB - minibatch_oldlogprobaB) surr1R = ratioR * minibatch_advantagesR surr2R = ratioR.clamp(1 - clip_now, 1 + clip_now) * minibatch_advantagesR loss_surrR = -torch.mean(torch.min(surr1R, surr2R)) surr1B = ratioB * minibatch_advantagesB surr2B = ratioB.clamp(1 - clip_now, 1 + clip_now) * minibatch_advantagesB loss_surrB = -torch.mean(torch.min(surr1B, surr2B)) # value clip in the paper,not work if args.lossvalue_norm: minibatch_return_6stdR = 6 * minibatch_returnsR.std() loss_valueR = torch.mean( (minibatch_newvaluesR - minibatch_returnsR).pow(2)) / minibatch_return_6stdR minibatch_return_6stdB = 6 * minibatch_returnsB.std() loss_valueB = torch.mean( (minibatch_newvaluesB - minibatch_returnsB).pow(2)) / minibatch_return_6stdB else: loss_valueR = torch.mean( (minibatch_newvaluesR - minibatch_returnsR).pow(2)) loss_valueB = torch.mean( (minibatch_newvaluesB - minibatch_returnsB).pow(2)) loss_entropyR = torch.mean( torch.exp(minibatch_newlogprobaR) * minibatch_newlogprobaR) loss_entropyB = torch.mean( torch.exp(minibatch_oldlogprobaB) * minibatch_newlogprobaB) total_lossR = loss_surrR + args.loss_coeff_value * loss_valueR + args.loss_coeff_entropy * loss_entropyR total_lossB = loss_surrB + args.loss_coeff_value * loss_valueB + args.loss_coeff_entropy * loss_entropyB optimizerR.zero_grad() optimizerB.zero_grad() total_lossR.backward() total_lossB.backward() optimizerR.step() optimizerB.step() if args.schedule_clip == 'linear': ep_ratio = 1 - (i_episode / args.num_episode) clip_now = args.clip * ep_ratio # adam learning rate if args.schedule_adam == 'linear': ep_ratio = 1 - (i_episode / args.num_episode) lr_now = args.lr * ep_ratio for g in optimizerR.param_groups: g['lr'] = lr_now for h in optimizerB.param_groups: h['lr'] = lr_now if i_episode % args.log_num_episode == 0: print('Episode: {} Red Reward: {:.4f} Red Loss = {:.4f} Blue Reward: {:.4f} Blue Loss = {:.4f}' \ .format(i_episode, ou_reward_ppo(reward_record_R[-1]['meanepreward'],networkR.step),total_lossR.data,ou_reward_ppo(reward_record_B[-1]['meanepreward'],networkB.step),total_lossB.data)) print('-----------------') return networkB
import time from string import Template import logging DIRNAME = os.path.dirname(os.path.realpath(__file__)) sys.path.append(os.path.join(DIRNAME, '..')) sys.path.append(os.path.join(DIRNAME, '..', '..', 'common')) import log import env import bouncer_process_manager from bouncer_process_manager import BouncerProcessManager remine_deps = os.path.join(DIRNAME, "..", "..", "apps", "redmine_app", "env.sh") var = env.env(remine_deps) INSTALL_REDMINE_PATH = var["INSTALL_REDMINE_PATH"] # TODO: Is it possible to modify the configuration of mongrel such that it only # handles one request at time? This would hopefully speed up the time it takes # restart mongrel and lead to lower memory foot print. # REDMINE_CMD_TEMPLATE_STR = 'mongrel_rails start -p $port -e production -c %s -P /tmp/mongrel$port.pid' % INSTALL_REDMINE_PATH # REDMINE_CMD_TEMPLATE_STR = '/usr/bin/ruby /home/fcgi_user/redmine-1.4.0/script/server mongrel -e production -p $1' REDMINE_CMD_TEMPLATE_STR = 'ruby %s/script/server mongrel -e production -p $port' \ % INSTALL_REDMINE_PATH class BouncerForRedmine(BouncerProcessManager): def start_worker(self, addr, port): '''Must attempt to launch the specified worker. Should return the popen object for the new worker
transfer_list_rule3=[] # repsonse time response_list_rule3=[] # reqeust details request_list=[] # tier infos tier_list=[] t0=time.time() warnings.filterwarnings('ignore') #progress=ProgressBar() if os.path.exists('./Heatmap_3rdrule_1000-123-temp46-fixgenreq-tempdesc10/')==False: os.mkdir('./Heatmap_3rdrule_1000-123-temp46-fixgenreq-tempdesc10/') env1=env(tier1) env2=env(tier2) env3=env(tier3) for turn in range(1000): print('%dth turn'%turn) t1=time.time() ## generate requests #Request=Req_generator(env1.tier,env2.tier,env3.tier) #Request=Request.loc[Request['request']==1] #req_limit=random.randint(170,230) #Request=Request.sample(frac=1)[0:req_limit] ## use same requests Request=pd.read_csv('./Requests_temp46_1000/req_%d.csv'%turn)
def __init__(self, Q): self.Q = Q self.env = env() self.Q[:, self.env.states.index(self.env.final_state)] = 0
#!/usr/bin/env python3 import sys, time, twitter, spotipy import datetime, traceback import mysql.connector import spotipy.util as util sys.path.append('../') from env import env e = env() alltime_playlist_uri = e.alltime_pl weekly_playlist_uri = e.weekly_pl twit = twitter.Api(consumer_key=e.twit_consumer_key, consumer_secret=e.twit_consumer_secret, access_token_key=e.twit_access_token_key, access_token_secret=e.twit_access_token_secret) mydb = mysql.connector.connect(host=e.mysql_host, user=e.mysql_user, passwd=e.mysql_pw, database=e.mysql_db) scope = 'playlist-modify-public playlist-modify-private' token = util.prompt_for_user_token(username=e.spot_username, scope=scope, client_id=e.spot_client_id, client_secret=e.spot_client_secret, redirect_uri=e.spot_redirect_uri)
def handler(req): e = env.env(req, 'provider1.example.com') auth = authenhandler(req) if auth != apache.OK: return(auth) module = formGet(e, 'module') action = formGet(e, 'action') if action: action = action.lower() # Redirect to SSL URL if e.requireSSL and req.server.port != 443: req.headers_out['Location'] = 'https://' + req.hostname + req.unparsed_uri req.status = apache.HTTP_MOVED_PERMANENTLY req.content_type = 'text/html' req.send_http_header() req.write("""<?xml version="1.0"?> <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en"> <head> <link href="styles.css" media="all" rel="stylesheet" type="text/css" /> <title>Redirecting...</title> </head> <body> <h1>Redirecting...</h1> <p>You are being redirected to: <a href="%(dest)s">%(dest)s</a></p> </body> </html>""" % {'dest': req.headers_out['Location'] }) return apache.OK req.content_type = 'text/html' req.send_http_header() req.write("""<?xml version="1.0"?> <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en"> <head> <link href="styles.css" media="all" rel="stylesheet" type="text/css" /> <title>Skime</title> </head> <body> <table class="top_header_table" summary="Top Header"> <colgroup> <col width="1*" /> <col width="*" /> </colgroup> <tr class="top_header_row1"> <td style="width: 1*;"><a href="/"><img src="images/logo.gif" alt="Skime" /></a></td> <td class="top_header_text">Skime</td> </tr> <tr class="top_header_row2"> <td colspan="2">User: """ + name + ' (' + username + ')' + """</td> </tr> </table> """) if not module: module = 'GeneralSearch' action = 'searchform' try: modFile = __import__('datamodules.'+module) modCls = eval('modFile.'+module+'.'+module) mod = modCls(e) req.write(mod.handleAction(e, action)) except: req.write('Uh-oh. Couldn\'t even load the standard module') req.write("</body></html>\n") return apache.OK
ADMINS = ( ('FEINHEIT Developers', '*****@*****.**'), ) MANAGERS = ADMINS DEFAULT_FROM_EMAIL = 'no-reply@${DOMAIN}' SERVER_EMAIL = '*****@*****.**' DATABASES = { 'default': dj_database_url.config(), } CACHES = { 'default': django_cache_url.config(), } SECRET_KEY = env('SECRET_KEY', required=True) FORCE_DOMAIN = env('FORCE_DOMAIN') ALLOWED_HOSTS = env('ALLOWED_HOSTS', required=True) TIME_ZONE = 'Europe/Zurich' LANGUAGE_CODE = 'de-ch' LANGUAGES = ( # ('en', 'English'), ('de', 'German'), # ('fr', 'French'), # ('it', 'Italian'), ) USE_I18N = True USE_L10N = True USE_TZ = True
#!/usr/bin/env python import env import os import sys if __name__ == "__main__": env.read_dotenv() if 'test' in sys.argv: os.environ['DJANGO_SETTINGS_MODULE'] = '${PROJECT_NAME}.settings.test' else: os.environ.setdefault("DJANGO_SETTINGS_MODULE", env.env("DJANGO_SETTINGS_MODULE", "${PROJECT_NAME}.settings.local")) from django.core.management import execute_from_command_line execute_from_command_line(sys.argv)
out.append(']),\n') out.append('FOREIGN KEY ([') out.append('],['.join([record.allFields[fieldName].dbName for fieldName in fields if record.allFields[fieldName].dbPrimaryKey])) out.append(']) REFERENCES [') out.append(record.dbTable) out.append(']\n') out.append(');\n') if record.dbMiscellaneous != '': out.append(record.dbMiscellaneous) return ''.join(out) e = env.env(None) tables = [] # # NOTE: # # Only one instance of a dynamic table should be added here. # This will be the top-level table with the non-dynamic properties. # # Round 1 if e.domain: import structures.Domain tables.append(structures.Domain.Domain) if e.equipmentClass: import structures.EquipmentClass
import urllib2 import json import re import random import httplib DIRNAME = os.path.dirname(os.path.realpath(__file__)) sys.path.append(os.path.join(DIRNAME, '..', '..', '..', 'common')) import log import env mediawiki_app = os.path.join(DIRNAME, "..", "env.sh") var = env.env(mediawiki_app) MEDIAWIKI_ATTACK_PAGES_RE = var["MEDIAWIKI_ATTACK_PAGES_RE"] attack_re = re.compile(MEDIAWIKI_ATTACK_PAGES_RE) siteconfig = os.path.join(DIRNAME, "..", "..", "..", "siteconfig.sh") var = env.env(siteconfig) SERVER_NAME = var["SERVER_NAME"] def getjson(url): try: response = urllib2.urlopen(url) except urllib2.URLError: sys.stderr.write("Error: Could not access %s. Perhaps MediaWiki is not running.\n\n" % SERVER_NAME) sys.exit(1) return json.loads(response.read())
from string import Template import logging DIRNAME = os.path.dirname(os.path.realpath(__file__)) sys.path.append(os.path.join(DIRNAME, '..')) sys.path.append(os.path.join(DIRNAME, '..', '..', 'common')) import log import env import bouncer_process_manager from bouncer_process_manager import BouncerProcessManager dependencies = os.path.join(DIRNAME, "..", "..", "dependencies", "env.sh") var = env.env(dependencies) PHP_CGI_VULN_BIN = var["PHP_CGI_VULN_BIN"] KILL_SQL_PHP = os.path.join(DIRNAME, "kill_sql.php") PHP_FCGI_CMD_TEMPLATE_STR = '%s -b $addr:$port' % PHP_CGI_VULN_BIN class BouncerForPhp(BouncerProcessManager): def start_worker(self, addr, port): '''Must attempt to launch the specified worker. Should return the popen object for the new worker or None, if the worker couldn't be be launched for some reason.''' cmd_str = Template(PHP_FCGI_CMD_TEMPLATE_STR).substitute( \ addr = addr, \ port = str(port) \ ) self.logger.debug("cmd_str='%s'" % cmd_str)
def mainLoop(): # Setting up Enviornment IE: Keys, and needed objs e = env() sp = spot(e) prev_tr_uri = str() state = 0 printed = False # This is the main loop that the program will run. # States and their associated value: # # no_user = 0 # prog_lt_tqp = 1 # tweet_song = 2 # prog_gt_tqp = 3 # wait_for_resume = 4 while True: # Spotify Authentication sp.update_obj(e) # No User if state == 0: if sp.sp_obj is not None: if not sp.ct_is_playing: state = 4 printed = False else: state = 1 printed = False else: check_printed(printed, state) state = 0 printed = True # Progress < 3/4 track Lenght elif state == 1 and sp.sp_obj is not None: if not sp.ct_is_playing: state = 4 printed = False elif (sp.ct_is_playing and (3 * sp.ct_length) / 4 < sp.ct_progress and not sp.tweeted and sp.ct_uri == prev_tr_uri): state = 2 printed = False else: # If the song is different from the previous song, then set tweeted to false if sp.ct_uri != prev_tr_uri: sp.tweeted = False prev_tr_uri = sp.ct_uri check_printed(printed, state) state = 1 printed = True # Tweet Song elif state == 2: # Apparently it is possible to get into this state without a valid obj if sp.sp_obj is not None and sp.ct_name == "": print( "[{}]\033[31mWaring!\u001b[0m: Spotify object exists but no data filled! Forcing state 0!" .format(get_curr_time())) state = 0 continue sp_obj_ready = sp tweet_song(sp_obj_ready, e, state) update_db(sp_obj_ready, e) prev_tr_uri = sp.ct_uri state = 3 printed = False sp_obj_ready = None # Progress > 3/4 track length && Tweeted elif state == 3 and sp.sp_obj is not None: if not sp.ct_is_playing: state = 4 printed = False elif sp.ct_uri != prev_tr_uri: state = 1 printed = False sp.tweeted = False else: check_printed(printed, state) state = 3 printed = True # Waiting for Playback to be Resumed elif state == 4 and sp.sp_obj is not None: if sp.ct_is_playing: if sp.tweeted: state = 3 printed = False else: state = 1 printed = False else: check_printed(printed, state) state = 4 printed = True # Correction for falling out of state, (Not State 0 but also sp_obj is None) # Essentially resetting to the default state else: state = 0 printed = False # Add a sleep(5) as to not spam either Api time.sleep(5)
class AtariProcessor(Processor): def process_reward(self, reward): return np.clip(reward, -100., 100.) parser = argparse.ArgumentParser() parser.add_argument('--mode', choices=['train', 'test'], default='train') parser.add_argument('--env-name', type=str, default='WHG') parser.add_argument('--weights', type=str, default=None) args = parser.parse_args() #env_name = "WHG" # Get the environment and extract the number of actions. #env = gym.make(args.env_name) env = env(4) np.random.seed(20) env.seed(20) nb_actions = env.action_space # Next, we build our model. We use the same model that was described by Mnih et al. (2015). model = Sequential() # (width, height, channels) model.add(Flatten(input_shape=( 1, 14, ))) model.add(Dense(64)) model.add(Activation('relu')) model.add(Dense(64))
if reRbe.search(section): rbe = reRbe.search(section).group() else: rbe = 0 if rePvc.search(section): pvc = rePvc.search(section).group(1) else: pvc = 0 if reVbr.search(section): vbr = (reVbr.search(section).group(1), reVbr.search(section).group(2)) else: vbr = (0,0) e = env.env(None, 'wiktel.com') cids = getCid(e, intPvcPart) if cids: cr = CustomerRecord() cr.dbLoad(e, {'CustomerID': cids[0]}) ma = cr.data[0][0] founds.append("ATM Int: " + str(atmInt) + ", Unnumbered Int: " + str(unnum) + ", RBE: " + str(rbe) + ", PVC: " + str(pvc) + ", VBR: " + str(vbr) + "\n" + "Name: " + ma.values['FirstName'] + " " + ma.values['LastName'] + " Company: " + ma.values['Company'] + " Billing Number: " + ma.values['BillingNumber'] + "\n") else: notFounds.append("ATM Int: " + str(atmInt) + ", Unnumbered Int: " + str(unnum) + ", RBE: " + str(rbe) + ", PVC: " + str(pvc) + ", VBR: " + str(vbr) + "\n" + 'No record found for interface ' + atmInt + '\n') f = file("dsl.txt", 'w') f.write("-- Not Found --\n") for x in notFounds: f.write(x)
type=validate.domain, help='Domain name') parser.add_argument( 'nice_name', type=validate.nice_name, help='Nice name') parser.add_argument( '-p', '--project-name', type=validate.project_name, help='Python module for the project [%(default)s]', default='box') parser.add_argument( '-s', '--server', type=validate.server, help='Server [%(default)s]', default=env.env('SERVER')) parser.add_argument( '-d', '--destination', type=str, help='The destination path for the project [./build/$DOMAIN_SLUG]') parser.add_argument( '--charge', action='store_true', help='Charge ahead, do not ask for confirmation') args = parser.parse_args() if not args.server: print(color( 'Either specify a server using --server or add a default value' ' for SERVER in ~/.box.env', 'red', True)) sys.exit(1)
from env import env print(env("secret")) print(env("app"))
import time from string import Template import logging DIRNAME = os.path.dirname(os.path.realpath(__file__)) sys.path.append(os.path.join(DIRNAME, '..')) sys.path.append(os.path.join(DIRNAME, '..', '..', 'common')) import log import env import bouncer_process_manager from bouncer_process_manager import BouncerProcessManager osqa_deps = os.path.join(DIRNAME, "..", "..", "apps", "osqa_app", "env.sh") var = env.env(osqa_deps) INSTALL_OSQA_PATH = var["INSTALL_OSQA_PATH"] OSQA_CMD_TEMPLATE_STR = 'python %s/manage.py run_gunicorn 0.0.0.0:$port' % INSTALL_OSQA_PATH class BouncerForOsqa(BouncerProcessManager): def start_worker(self, addr, port): '''Must attempt to launch the specified worker. Should return the popen object for the new worker or None, if the worker couldn't be be launched for some reason.''' cmd_str = Template(OSQA_CMD_TEMPLATE_STR).substitute( \ addr = addr, \ port = str(port) \ ) self.logger.debug("cmd_str='%s'" % cmd_str)