def runBenchmark(outdir, experiment): Aim.sepservers0 = ['euler10', 'euler11'] Aim.sepservers1 = [] srvObserver = Observer('AIM server started') storageClients = [] ## start storages storageClients = startStorage() print "Storage started" # Populate outfile = "{}/{}_population.db".format(outdir, sqliteOut(False)) aimObserver = Observer("AIM") aimClients = startAimServers([aimObserver]) #aimObserver.waitFor(len(Aim.sepservers0) + len(Aim.sepservers1) + len(Aim.rtaservers0) + len(Aim.rtaservers1)) time.sleep(2) populationClient = startSepClient(True, outfile) populationClient.join() experiment() for aimClient in aimClients: aimClient.kill() aimClient.join() for client in storageClients: client.kill() for client in storageClients: client.join()
def enable_bot_and_player(_game): player = Player(settings.PLAYER_SKINS[0], 175, 100, 290, "Player") bot = Bot(settings.BOT_SKINS[0], 75, 200, 300, 290, "Bot") obs_player = Observer(player, [wall]) obs_bot = Observer(bot, [wall]) player.obs = obs_player bot.set_target(wall) bot.obs = obs_bot _game.player = player _game.add_object(bot)
def __init__(self): Observer().__init__() #variables for health, attack values, weapons, location, and weapon index #gave player extra helth to make the game longer self.health = randint(200,250) self.attackValue = randint(10,20) self.weapons = [] self.location = [0, 0] self.currentWeaponIndex = 0 #randomly populate the weapons inventory for index in range(0,10): weaponType = randint(0, 3) if weaponType == 0: self.weapons.insert(index, HersheyKiss()) self.weapons[index].addObs(self) elif weaponType == 1: self.weapons.insert(index, SourStraw()) self.weapons[index].addObs(self) elif weaponType == 2: self.weapons.insert(index, ChocolateBar()) self.weapons[index].addObs(self) elif weaponType == 3: self.weapons.insert(index, NerdBomb()) self.weapons[index].addObs(self) #set the current weapon to be the first weapon in the inventory self.currentWeapon = self.weapons[0]
def __init__(self): rospy.init_node('STATE') self.is_sitl = rospy.get_param('~is_sitl', False) self.is_airsim = rospy.get_param('~is_airsim', False) self.observer = Observer(self.is_sitl, self.is_airsim) self.rate = 1.0 self.pub_diag = rospy.Publisher('/system_diagnostics', Diagnostics, queue_size=1) self.srv_cmd_state = rospy.Service('set_mode', SetMode, self.set_mode_callback) rospy.wait_for_service('/MOVE/clear_costmaps') self.clear_costmaps_srv = rospy.ServiceProxy('/MOVE/clear_costmaps', Empty) rospy.loginfo('Starting state observer...') self.diag = Diagnostics()
def __init__(self, system, store, limit_time=40000, verbose=False): self.__time = 0 self.__limit_time = limit_time self.__system = system self.__store = store self.__observer = Observer()
def run_simulation(P=0, Q=0, lying_function=lie_on_every_packet, length_of_path=5, total_ticks=50): client_to_server_path = Path(length_of_path, "Client", "Server") server_to_client_path = Path(length_of_path, "Server", "Client") client = Client(0, P, lying_function) server = Server(0, Q, lying_function) observer = Observer() current_tick = 1 while (current_tick <= total_ticks): # add_packet_to_path() pops off the bit that has # reached the end of the path bit_reaching_server = client_to_server_path.add(client.cur_spin) bit_reaching_client = server_to_client_path.add(server.cur_spin) # update value of spin bit for client and server # this will be set next tick client.cur_spin = bit_reaching_client server.cur_spin = bit_reaching_server print("Tick:"), print(current_tick) client_to_server_path.pretty_print() server_to_client_path.pretty_print(True) # measurements are sampled from midpoint of path observer.add_measurement(client_to_server_path) current_tick += 1 print("Final RTT is %.2f") % observer.measure_rtt()
def __init__(self, conf_args): super(BasicGenerator, self).__init__(conf_args) self._prg = None self._observer = Observer() self._solve_opts = [ "-t {0}".format(self._args.threads), "--project", # "--opt-mode=optN", "-n {0}".format(self._args.num) ] if self._args.random: self._solve_opts.extend([ '--rand-freq={}'.format(self._args.rand_freq), '--sign-def={}'.format(self._args.sign_def), '--seed={}'.format(self._args.seed) ]) if self._args.solve_opts: self._solve_opts.extend(self._args.solve_opts) self._inits = None self._object_counters = {} self._instance_count = 0 self._instances = [] self.dest_dirs = [] if self._args.cluster_x is None: self._cluster_x = int((self._args.grid_x - 2 + 0.5) / 2) else: self._cluster_x = self._args.cluster_x if self._args.cluster_y is None: self._cluster_y = int((self._args.grid_y - 4 + 0.5) / 2) else: self._cluster_y = self._args.cluster_y
def __init__(self,sizex,sizey,pits,diffy,agent,o1=Observer()): self.agent= agent self.o1 = o1 self.sizex= sizex self.sizey= sizey self.pits= pits self.diffy= diffy self.numberboard=findmap(self.sizex,self.sizey,self.pits,self.diffy) printgrid(self.numberboard,sizex,sizey) self.start_invis_board = tolistofset(self.numberboard,self.sizex,self.sizey) self.ob=Observer() self.g = Game() self.g.subscribeObserver(o1) self.g.subscribeObserver(self.ob) self.g.startGame(self.start_invis_board) self.stepcount=0 self.win=False
def listen(self): ''' The listen function is called during initialisation of the class & the application. It initialises the process of starting to listen to card taps on the reader. ''' self.monitor = CardMonitor() self.observer = Observer(self) self.monitor.addObserver(self.observer)
def main(): print("Band is starting!") scheduler = Scheduler() eddystone_sender = Broadcaster('https://thu-band.org') eddystone_scanner = Observer('https://thu-band.org') try: scheduler.run(eddystone_sender, eddystone_scanner) except: return
def __init__(self, **kwargs): self.blinker = False self.ob = Observer() self.group_list = self.ob.get_observing_group_list() self.created_group_id_list = [] self.lamp_list = [""] * self.show_num self.set_lamp_list() super(MainPanel, self).__init__(**kwargs) Clock.schedule_interval(self.observing, 15) Clock.schedule_interval(self.set_blinker, 0.5)
async def setup( port: int, config_endpoint: Optional[str] = "http://127.0.0.1:8500", ): cfg = await get_config(port, config_endpoint) app = web.Application() app['cfg'] = cfg observer = Observer() app['observer'] = observer ws_manager = ws.WebsocketManager(broadcast=observer.notify_observers) json_inst = await build_installation(cfg['cfg']) inst = Installation.unmarshal(json_inst) app['inst'] = inst hm = HeadManager() app['head_manager'] = hm app['grid'] = Grid(-10, -10, 10, 10, (400, 400), installation=inst) # TODO: not global! asyncio.ensure_future(app['grid'].decay()) boss_routes.setup_routes(app, ws_manager) orchestrator = Orchestrator( inst=inst, head_manager=hm, broadcast=observer.notify_observers, ) fp_manager = FocalPointManager( broadcast=observer.notify_observers, inst=inst, grid=app['grid'], ) observer.register_observer(orchestrator) observer.register_observer(fp_manager) # perhaps not the best place observer.register_observer(ws_manager) tm = text_manager.text_manager( head_manager=hm, broadcast=observer.notify_observers, ) util.create_task(tm) for redis in cfg['redis_servers']: asyncio.ensure_future( run_redis(redis, broadcast=observer.notify_observers)) return app
def conduct_game(self): logger.info("The players in the game are " + str(self.player_names)) self.start_game() logger.info("Initial moves have finished.") self.perform_game() logger.info("The game has now finished.") obs = Observer() obs.observe_game_state(self.game_state) referee_game_management.end_game(self)
def main(): observer = Observer() fuzzifier = Fuzzifier(observer) inferrer = Inferrer(fuzzifier) defuzzifier = Defuzzifier(inferrer) observer.observe() fuzzifier.fuzzify() inferrer.infer() defuzzifier.defuzzify() print("Time should be {0} minutes".format(defuzzifier.crisp_time()))
def check_new_event(self, planet_list): """Watch periodically for any new incoming fleet""" fleet_observer = Observer(planet_list, self.navigate) while True: try: self.mutex.acquire() self.is_event_over = fleet_observer.check_new_event() except Exception: print("ERROR check_new_event") finally: self.mutex.release() time.sleep(self.DELAY)
def main(): loop = asyncio.get_event_loop() observer = Observer() app = loop.run_until_complete( text_manager( HeadManager(), broadcast=observer.notify_observers, )) loop.run_forever()
def init_game_with_data(self, data): o1 = Observer() sizex = data.gridX sizey = data.gridY pits = int(data.pits) diffy = self.num_difficulty(data.difficulty) start_invis_board = tolistofset(findmap(sizex, sizey, pits, diffy), sizex, sizey) g1 = Game() g1.subscribeObserver(o1) g1.startGame(start_invis_board) self.observer = o1 return g1
def __init__(self): self.ob = Observer() self.timer = RepeatedTimer(7200, self.ob.ob_all) self.cmd_list = { "help": self._help, "status": self._status, "list": self._list, "delete": self._delete, "admin-status": self._admin_status, "admin-list": self._admin_list, "admin-run": self._admin_run } self.ob.init_checker()
def subjectify(file_path: str) -> Observer: """ Creates a new observer that live-updates a given json file (where the file is "subjected" to updates within the observer). """ content = load_or_create(file_path) # Write the current state to the loaded file when a change happens def callback(root: Observer, name: str, value: Any) -> bool: with open(file_path, 'w+') as file: json.dump(root.to_dict(), file) return Observer(content, callback, path.splitext(path.basename(file_path))[0])
def __init__(self, system, agent, limit_time=40000, verbose=False): """Environment constructor Args: system (System): Systems that will be perform in the environment agent (Agent): Agent which will solve the problem limit_time (int, optional): Simulation limit time. Defaults to 40000. verbose (bool, optional): Verbose mode. Defaults to False. """ self.__time = 0 self.__limit_time = limit_time self.__system = system self.__agent = agent self.__observer = Observer()
def main() : o1 = Observer() sizex= int(input("Sizex: ")) sizey= int(input("Sizey: ")) pits= int(input("The number of pits: ")) diffy= int(input("The difficulty: ")) start_invis_board = tolistofset(findmap(sizex,sizey,pits,diffy),sizex,sizey) g1 = Game() g1.subscribeObserver(o1) g1.startGame(start_invis_board) nextMove = '' while(1): x=g1.robot_position[0] y=g1.robot_position[1] for i in range(sizex): for j in range(sizey): if len(g1.visible_board[sizex-i-1][j])==0 and (sizex-i-1!=x or j!=y): print("00000", end=" ") elif not (sizex-i-1!=x or j!=y): print("here!",end=" ") else: print("{}".format(g1.visible_board[sizex-i-1][j].difference({}).pop()), end=" ") print("") nextMove = input("Next Move: ") if nextMove == "move_up": g1.moveRobotUp() elif nextMove == "move_down": g1.moveRobotDown() elif nextMove == "move_right": g1.moveRobotRight() elif nextMove == "move_left": g1.moveRobotLeft() elif nextMove == "move_right": g1.moveRobotRight() elif nextMove == "shoot_up": g1.shootArrowUp() elif nextMove == "shoot_down": g1.shootArrowDown() elif nextMove == "shoot_right": g1.shootArrowRight() elif nextMove == "shoot_left": g1.shootArrowLeft() else: print("INVALID MOVE, exiting...") return return 0
def __iter__(self): # Create the packet information generator pkt_info_gen = Observer(source=self.source) # Extract each packet information from the network interface or pcap file for pkt_info in pkt_info_gen: if pkt_info is not None: # Check if the packet belongs to an existent flow or create a new one self.consume(pkt_info) for export in self.__exports: yield export self.__exports = [] # Terminate the streamer self.terminate() for export in self.__exports: yield export self.__exports = []
def __init__(self, settings_tuple): """ Initialize simulation area. """ self.screen_len_new = DISPLAY self.screen = pg.display.set_mode(DISPLAY, pg.RESIZABLE) pg.display.set_caption("Fire in tunnel") self.bg = pg.Surface(DISPLAY) self.bg.fill(c.BLUE) self.observer = Observer(0, 2) self.tunnel = Tunnel(settings_tuple) self.camera = Camera(camera_configure, settings_tuple[1] + 60, WIN_HEIGHT) self.settings_tuple = settings_tuple
def parse_observer(self, observer_dict: Dict) -> Observer: """Parse a single observer object from JSON dictionary. Args: observer_dict (Dict): JSON dictionary containing the observer info. Returns: Observer: The actual observer class. """ # parse observer fields condition = self.parse_condition(observer_dict['condition']) observe_people = observer_dict['observe_people'] observe_families = observer_dict['observe_families'] observe_communities = observer_dict['observe_communities'] return Observer(condition, observe_people, observe_families, observe_communities)
def duster(settings, model_id, zone_id): assert ONLY_MODEL_2 and model_id == 2, "ONLY HAVE HYDRO DATA FOR MODEL_IDX=2" print(f"M{model_id} (Z{zone_id}) loading input...(slow for now)") p = load_particle(settings["particle_inputfile"], \ settings["hydrorun_inputfile"], \ model_id, zone_id) output_d = f"output_M{model_id:03d}" os.makedirs(output_d, exist_ok=True) output_f = os.path.join(output_d, f"dust{zone_id:04}") net = Network(settings["network_file"]) print( f"M{model_id} (Z{zone_id}) loaded, beginnging run: output[{output_f}]") gas = SNGas(p, net) step = Stepper(gas, net) spec = SolverSpec(time_start = p.times[p.first_idx], time_bound = p.times[p.last_idx], absolute_tol = settings["abs_tol"], \ relative_tol = settings["rel_tol"], max_timestep = settings["max_dt"]) print(f"time_start = {p.times[p.first_idx]}") solv = Solver(spec, step) obs = Observer(output_f, net, gas, step, solv, settings) msg = f"M{model_id} (Z{zone_id}) ok" try: solv(obs) except Exception as e: msg = f"M{model_id} (Z{zone_id}) did not finish ok\n{repr(e)}" print(msg) traceback.print_exc(file=sys.stdout) # obs.dump(solv._steps) finally: # obs.runout(solv._steps, settings["align_tend_value"], res=settings["align_tend_resolution"]) ## TIMING from stepper import S_DEBUG, S_FASTMATH, S_NOPYTHON, S_PARALLEL print( f"DEBUG={S_DEBUG}, NOPYTHON={S_NOPYTHON}, FASTMATH={S_FASTMATH}, PARALLEL={S_PARALLEL}" ) return msg
def main(): env = gym.make("FightingiceDataNoFrameskip-v0", java_env_path="/home/rurito/lesson/ken/FTG4.50") # HACK: aciontから自動で取ってこれるようにしておく action_size = 56 learning_rate = 0.1 batch_size = 10 episode = 3 gamma = 0.1 greedy_value = 0.3 p2 = "MctsAi" env = Observer(env, p2) agent = DQNAgent(learning_rate, action_size, greedy_value) agent.model.load_model('param.hdf5') # agent = RoleBaseAgent() trainer = Trainer(env, agent) trainer.train(episode, batch_size, gamma)
def execute(self): logging.info("Setting up observer '{}'".format(self._cmd_info["name"])) profile = profiles.get_profile_by_name(self._cmd_info["profile"]) store = self._setup_store(self._cmd_info["store"]) assessor = AdAssessor() for json in self._cmd_info["criteria"]: assessor.add_criterion(AdCriterion.from_json(json)) notification_server = NotificationServer( ) # Add an empty notification server observer = Observer( url=self._cmd_info["url"], profile=profile, # Setup the actual observer store=store, assessor=assessor, notifications=notification_server, update_interval=self._cmd_info["interval"], name=self._cmd_info["name"]) self._server.add_observer(observer)
def main(): incrementer = Incrementer(1) # Equivalent to Multiplier(2) doubler = Doubler() squarer = Exponentiator(2) observer = Observer() incrementer.subscribe(doubler.double) doubler.subscribe(squarer) squarer.subscribe(observer) for i in range(10): # Call the first modifier in the chain, and let the delegates handle the rest incrementer(i) incrementer.unsubscribe(doubler.double) doubler.unsubscribe(squarer) squarer.unsubscribe(observer)
def __init__(self, shape, name="", use_opengl=False): """ Parameters ---------- shape : tuple of ints Width and height of screen name : str (optional) name of game (will be shown above window) """ self.use_opengl = use_opengl if use_opengl: self.camera = Camera() self._obs = Observer(self) self.waiting = False self.name = name self.shape = np.array(shape) self.time = time() self.ms_per_frame = 30
def main() : o1 = Observer() start_invis_board = [[set() for j in range(4)] for i in range(4)] start_invis_board[2][0].add("LiveWumpus") start_invis_board[2][1].add("Gold") start_invis_board[0][2].add("Pit") start_invis_board[2][2].add("Pit") start_invis_board[3][3].add("Pit") g1 = Game() g1.subscribeObserver(o1) g1.startGame(start_invis_board) nextMove = '' while(1): nextMove = input("Next Move: ") if nextMove == "move_up": g1.moveRobotUp() elif nextMove == "move_down": g1.moveRobotDown() elif nextMove == "move_right": g1.moveRobotRight() elif nextMove == "move_left": g1.moveRobotLeft() elif nextMove == "move_right": g1.moveRobotRight() elif nextMove == "shoot_up": g1.shootArrowUp() elif nextMove == "shoot_down": g1.shootArrowDown() elif nextMove == "shoot_right": g1.shootArrowRight() elif nextMove == "shoot_left": g1.shootArrowLeft() else: print("INVALID MOVE, exiting...") return print("") return 0