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
