def get_datanode(env, name, phy_node, datanode_conf, stage_log=sys.stdout):
if datanode_conf.datanode_xceive_stage_scheduler_generator is None:
xceive_stage = OnDemandStage(env, name + "_xceive", log_file=stage_log)
else:
xceive_scheduler = datanode_conf.datanode_xceive_stage_scheduler_generator(env)
xceive_cost_func = ScheduleUtil.get_cost_func(datanode_conf.datanode_xceive_stage_schedule_resource,
phy_node)
xceive_stage = Stage(env, name + "_xceive",
datanode_conf.datanode_xceive_stage_handlers,
xceive_scheduler, xceive_cost_func, log_file=stage_log)
if datanode_conf.datanode_packet_ack_stage_scheduler_generator is None:
packet_ack_stage = OnDemandStage(env, name + "_packet_ack", log_file=stage_log)
else:
packet_ack_scheduler = datanode_conf.datanode_packet_ack_stage_scheduler_generator(env)
packet_ack_cost_func = ScheduleUtil.get_cost_func(datanode_conf.datanode_packet_ack_stage_schedule_resource,
phy_node)
packet_ack_stage = Stage(env, name + "_packet_ack", datanode_conf.datanode_packet_responders,
packet_ack_scheduler, packet_ack_cost_func, log_file=stage_log)
xceive_stage.monitor_interval = datanode_conf.stage_monitor_interval
packet_ack_stage.monitor_interval = datanode_conf.stage_monitor_interval
datanode = SimpleDataNode(env, phy_node, xceive_stage, packet_ack_stage)
return datanode
def __init__(self, env, num_workers, resource_log, stage_log):
res1 = Resource(env, "r1", 1, 1, log_file=resource_log)
res1.monitor_interval = 0.1
scheduler = WFQScheduler(env, float('inf'))
stage1 = Stage(env,
"s1",
num_workers,
scheduler,
req_cost_func=lambda req: req.resource_profile[res1],
log_file=stage_log)
stage1.monitor_interval = 0.1
res2 = Resource(env, "r2", 100, 1, log_file=resource_log)
res2.monitor_interval = 0.1
scheduler = WFQScheduler(env, float('inf'))
stage2 = Stage(env,
"s2",
1,
scheduler,
req_cost_func=lambda req: req.resource_profile[res2],
log_file=stage_log)
stage2.monitor_interval = 0.1
self.env = env
self.stage1 = stage1
self.stage2 = stage2
self.res1 = res1
self.res2 = res2
def __init__(self, stabilisation_time=None, queue=None, parameters=None, filename='test'):
if parameters == None:
self.parameters = {'ax1_start': 0, 'ax1_stop': 10, 'ax1_step': 1,
'ax2_start': 0, 'ax2_stop': 10, 'ax2_step': 1,
'lockin_delay': None}
else:
self.parameters = parameters
self.ax1 = Stage(axis=2)
self.ax2 = Stage(axis=1)
self.lockin = Lockin(address="GPIB0::2::INSTR")
self.pulser = Pulser(address="GPIB0::6::INSTR")
ax1_steps = int(abs(self.parameters['ax1_start']-self.parameters['ax1_stop'])/self.parameters['ax1_step']+1)
ax2_steps = int(abs(self.parameters['ax2_start']-self.parameters['ax2_stop'])/self.parameters['ax2_step']+1)
self.results = np.zeros((ax1_steps, ax2_steps, 3))
self.elapsed_time = 0
self.queue = queue
self.filename = filename
self.file_written = False
self.stop_measurement = False
self.recomm_delay = self.lockin.get_timeconstant()*3*1000
if self.parameters['lockin_delay'] == None:
self.parameters['lockin_delay'] = self.recomm_delay
def new_stage(protocol, stage, valuation, mem):
new_valuation = new_stage_valuation(protocol, valuation, stage.disabled)
if is_stable_or_dead(protocol, new_valuation, stage.disabled):
return Stage(Formula(new_valuation),
new_valuation,
stage.disabled,
speed=Speed.ZERO,
parent=stage)
F, J = eventually_disabled(protocol, new_valuation, stage.disabled, mem)
# Compute new_formula (Φ) and new_disabled (T)
if len(F) > 0:
if len(J) > 0:
new_disabled = set(stage.disabled) | set(J)
new_formula = Formula(new_valuation, new_disabled)
if v_disabled(J, valuation):
new_formula.assert_valuation(valuation)
elif v_enabled(J, valuation):
K = posts_from_pres(protocol, new_valuation, J)
new_formula.assert_some_pair_present(K)
# Compute speed
if is_very_fast(protocol, new_valuation, stage.disabled):
new_speed = Speed.QUADRATIC
elif is_fast(protocol, new_valuation, stage.disabled):
new_speed = Speed.QUADRATIC_LOG
else:
new_speed = Speed.CUBIC
else:
new_disabled = set(stage.disabled) | set(F)
new_formula = Formula(new_valuation, new_disabled)
new_speed = Speed.POLYNOMIAL
else:
new_disabled = set(stage.disabled)
new_formula = Formula(new_valuation, new_disabled)
new_speed = Speed.EXPONENTIAL
I = compute_I(protocol, new_valuation, stage.disabled)
if any(valuation[Var(q)] is True for q in I):
L = compute_L(protocol, new_valuation, stage.disabled, I)
new_formula.assert_all_states_absent(I)
new_formula.assert_some_pair_present(L)
elif all(valuation[Var(q)] is False for q in I):
new_formula.assert_valuation(valuation)
else:
new_formula.assert_all_states_absent(I)
return Stage(new_formula,
new_valuation,
new_disabled,
speed=new_speed,
parent=stage)
def test_clear(self):
stage = Stage()
stage.add(dot)
stage.add(kriss)
stage.clear()
self.assertTrue(dot not in stage.array)
self.assertTrue(kriss not in stage.array)
def __init__(self, menu: Menu, lan):
self.figure = Figure([]) # type: Figure
self.stage = Stage() # type: Stage
self.stage.block_drawer = WiredBlockDrawer()
self.figure.block_drawer = GhostBlockDrawer()
self.menu = menu
self.lan = lan
def enter():
global stage, ground, hp, cookie, jelly, potion, jtrap, djtrap, strap
global scoreLabel, Label
global jelly_sound, item_sound, collide_sound
stage = Stage() # 스테이지
ground = Ground() # 바닥
hp = HP() # 체력
cookie = Cookie() # 캐릭터
game_world.add_object(stage, game_world.layer_bg)
game_world.add_object(ground, game_world.layer_bg)
game_world.add_object(hp, game_world.layer_bg)
game_world.add_object(cookie, game_world.layer_player)
# 점수
label = score.Label("Score: ", 50, get_canvas_height() - 50, 45, 0)
label.color = (255, 255, 255)
score.labels.append(label)
scoreLabel = label
# 사운드
jelly_sound = load_wav('jelly.wav')
jelly_sound.set_volume(32)
item_sound = load_wav('item.wav')
item_sound.set_volume(32)
collide_sound = load_wav('collide.wav')
collide_sound.set_volume(50)
def __init__(self):
self.masterClock = 0
self.arrivalTime = self.getNewArrivalTime()
self.stage = Stage()
self.cashierStage = CashierStage(0, 0, 3, 1, 25)
self.createFutureEventList()
self.createResultsTable()
def init_stages(self, cassandra_conf, stage_log):
assert isinstance(cassandra_conf, CassandraConf)
stg_name_list = Cassandra.get_all_stage_name_list()
for stg_name in stg_name_list:
cur_num_workers = cassandra_conf.get_stg_num_workers(stg_name)
cur_scheduler_generator = cassandra_conf.get_stg_scheduler_generator(stg_name)
cur_scheduler = cur_scheduler_generator(self.env)
cur_schedule_resource = cassandra_conf.get_stg_schedule_resource(stg_name)
cur_req_cost_func = self.get_req_cost_func(cur_schedule_resource)
[is_cur_stage_special, cur_stage_type_name, cur_stage_type_data_dict] = \
cassandra_conf.get_special_stage_constructor_additional_param_dict(stg_name)
cur_stage_name = self.pn_name + '_' + stg_name
if not is_cur_stage_special:
cur_stage = Stage(self.env, cur_stage_name, cur_num_workers, cur_scheduler,
cur_req_cost_func, log_file=stage_log)
else:
print 'stage:' + stg_name + ' is a ' + str(cur_stage_type_name) + 'scheduler:' + str(cur_scheduler)
cur_stage_kwargs_dict = self._get_basic_stage_init_dict(cur_stage_name, cur_num_workers, cur_scheduler,
cur_req_cost_func, stage_log)
cur_stage_kwargs_dict.update(cur_stage_type_data_dict)
self._transform_resource_str_to_real_obj(cur_stage_kwargs_dict)
cur_stage = Stage.create_special_stage(cur_stage_type_name, cur_stage_kwargs_dict)
cur_stage.set_monitor_interval(cassandra_conf.get_stg_monitor_interval())
self.__dict__.update({stg_name: cur_stage})
def stage1(self): self.initPlayers(self.numPlayers) self.deck.shuffle() stage1 = Stage(self.deck, self.players, self.printDetail, self.hazardsRemoved) self.hazardsRemoved = stage1.runStage(self.deck, self.strategyMap) # print(list(map(formatCard,self.hazardsRemoved))) return self.deck
def main():
atexit.register(killall)
args = parse_args()
setup_logging(args)
# read tool config
config = DFSConfig()
# setup show
show = Show(config, args.show_name)
if not show:
print('no such show %s', args.show_name)
sys.exit(1)
# setup stage
stage = Stage(show, args.stage_name)
if not stage:
print('could not load or create stage %s', args.stage_name)
sys.exit(1)
# setup joystick
joy = xbox.Joystick(debug=args.debug, config=config.joystick)
if args.check_mode:
sys.exit(0)
handler = DmxHandler(config, show, stage, joy)
# setup data handler, this is our callback loop
# as DMX data comes in constantly
wrapper = ClientWrapper()
rx = wrapper.Client()
rx.RegisterUniverse(config.input.universe, rx.REGISTER, handler.handle)
wrapper.Run()
def __init__(self):
pygame.init()
self.settings = Settings()
self.screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN)
self.settings.screen_width = self.screen.get_rect().width
self.settings.screen_height = self.screen.get_rect().height
self.settings.grid_width = (self.settings.screen_width -
200) // self.settings.num_column
self.settings.grid_height = (self.settings.screen_height -
200) // self.settings.num_row
pygame.display.set_caption("Kohki Hatori")
self.stage = Stage(self)
self.barriers = Barriers(self)
self.mirrors = Mirrors(self)
self.players = []
self.start_button = Button(self, "START")
self._create_environment()
self.constructing = True
self.cheating = False
self.real_game = False
self.end = False
self.bullets = []
self.turn_ended = True
self.no_bullet = True
self.player_moved = False
self.shooter = 0
self.text = Text(self)
self.game_active = False
self.end_button = Button(self, "END")
def game_condition(self):
"""
The other main loop of the game. When the fight_loop is complete, this loop checks to see if one the players
have achieved 2 points.
:return:
"""
random.seed()
selection = random.randint(0, 2)
if selection == 0:
stage = 'Sprites/Stages/TrainingRoom.png'
music = 'Sprites/sfx/bgm/bgmme37.ogg'
else:
stage = 'Sprites/Stages/sidewalks.png'
music = 'Sprites/sfx/bgm/bgmme42.ogg'
self.stage = Stage(stage, music)
while self.player_one_wins < 2 and self.player_two_wins < 2:
player_won = self.fight_loop()
if player_won == 1:
self.player_one_wins += 1
else:
self.player_two_wins += 1
self.round += 1
#print('player_one: ', self.player_one_wins, 'player_two: ', self.player_two_wins)
self.reset_booleans()
pygame.mixer.music.fadeout(2000)
pygame.time.wait(2000)
def get_cluster(env, phy_cluster, hdfs_conf, resource_log=sys.stdout, stage_log=sys.stdout):
"""
:param env:
:param phy_cluster: the PhysicalCluster HDFS run on; the first node will run NameNode; other nodes will run
DataNode
:param hdfs_conf: HDFSConf object
:param resource_log: opened file handle
:param stage_log: opened file handle
:return: newly constructed HDFS object
"""
assert len(phy_cluster.node_list) >= 2
namespace_lock_res = Resource(env, "namespace_lock", 1, 1, FIFOScheduler(env, float('inf')),
log_file=resource_log)
if hdfs_conf.namenode_scheduler_generator is None:
namenode_rpc_stage = OnDemandStage(env, "namenode_rpc", log_file=stage_log)
else:
namenode_scheduler = hdfs_conf.namenode_scheduler_generator(env)
namenode_rpc_stage = Stage(env, "namenode_rpc", hdfs_conf.namenode_handlers,
namenode_scheduler, log_file=stage_log)
namenode = NameNode(env, phy_cluster.node_list[0], namenode_rpc_stage, namespace_lock_res)
datanode_list = []
for phy_node in phy_cluster.node_list[1:]:
datanode = DataNode.get_datanode(env, "datanode_" + str(len(datanode_list)), phy_node,
hdfs_conf.datanode_conf, stage_log)
datanode_list.append(datanode)
hdfs = HDFS(env, namenode, datanode_list, hdfs_conf.replica)
return hdfs
def __init__(self, name, recipe, path):
self.name = name
# recipe defining the sequence of jobs to be performed
self.recipe = recipe
self.num_stages = self.recipe.num_stages
self.num_stageworkers = config.STAGE_SIZE
# Create buffers before and after each stage (hand-off points)
self.buffers = [Queue.Queue() for i in range(self.num_stages + 1)]
# The input buffer of the pipeline.
self.input = self.buffers[0]
# The output buffer of the pipeline
self.output = self.buffers[-1]
# Stage environment variables
self.stage_environ = dict(pipeline=self, path=path)
# Create stages and connect them to the buffers
self.stages = [Stage(name=self.recipe.stage_names[i],
WorkerClass=self.recipe.stage_types[i],
num_workers=self.num_stageworkers,
in_buffer=self.buffers[i],
out_buffer=self.buffers[i + 1],
seq_number=i,
**self.stage_environ) for i in range(self.num_stages)]
# jobnr is a simple counter of jobs that have been or still are processed
self.jobnr = 0
# Set state to inactive
# FIXME: isactive should be a descriptor and depend on stage's status
self.isactive = False
def enter():
global ground, character, stage, hp
global scoreLabel, Label
global jelly_sound, collide_sound, item_eat
character = Cookie()
stage = Stage()
ground = Ground()
hp = HP()
game_world.add_object(character, 1)
game_world.add_object(stage, 0)
game_world.add_object(ground, 0)
game_world.add_object(hp, 0)
label = score.Label("Score: ", 50, get_canvas_height() - 50, 45, 0)
label.color = (255, 255, 255)
score.labels.append(label)
scoreLabel = label
jelly_sound = load_wav('jelly.wav')
jelly_sound.set_volume(32)
item_eat = load_wav('item.wav')
item_eat.set_volume(32)
collide_sound = load_wav('collide.wav')
collide_sound.set_volume(50)
def stage4(self):
for player in self.players:
player.respawn()
self.deck.shuffle()
self.deck.cards += [100]
stage4 = Stage(self.deck, self.players, self.printDetail, self.hazardsRemoved)
self.hazardsRemoved = stage4.runStage(self.deck, self.strategyMap)
return self.deck
def test_playlist(self):
stage = Stage()
stage.add(dot)
stage.add(kriss)
stage.createplaylist("test")
stage.clear()
self.assertEqual(len(stage.array), 0)
stage.add("test.m3u")
self.assertMusicIn(stage)
def stage5(self):
for player in self.players:
player.respawn()
self.deck.shuffle()
self.deck.cards += [120]
stage5 = Stage(self.deck, self.players, self.printDetail, self.hazardsRemoved)
self.hazardsRemoved = stage5.runStage(self.deck, self.strategyMap)
if (self.printDetail):
print("Removed Hazards: ", list(map(formatCard,self.hazardsRemoved)))
return self.deck
def __init__(self, parent):
self.parent = parent
globalvars.asdf = 0
self.lagcount = 0
self.leftkeydown = 0
self.rightkeydown = 0
self.enemylist = []
self.list_enemys = EnemyManager()
self.stage = Stage(self.list_enemys, globalvars.player_list)
self.list_allie_shots = pygame.sprite.RenderUpdates()
self.enemy_shots = pygame.sprite.RenderUpdates()
def generate_tasks(self, user_id, job_profile):
this_job = Job(user_id)
stage_list = list()
sorted_stage_id = np.sort(job_profile.keys()) # todo check
for stage_id in sorted_stage_id:
this_stage = Stage(user_id, stage_id)
task_num = job_profile[stage_id]['Task_Num']
this_rdd = self.search_rdd_by_name('user%s_rdd%s' %
(user_id, stage_id))
parent_rdd_ids = job_profile[stage_id]['Parents']
start_time = float(job_profile[stage_id]['Start_Time'])
end_time = float(job_profile[stage_id]['End_Time'])
task_list = list()
peer_group = list() # for sticky policies
for task_id in range(0, task_num):
this_task = Task(user_id, stage_id, task_id)
# set start and end time
this_task.set_start_time(start_time)
this_task.set_end_time(end_time)
# set dependent blocks and update their ref counts.
dependent_blocks = list()
for parent_rdd_id in parent_rdd_ids:
parent_rdd = self.search_rdd_by_name(
'user%s_rdd%s' % (user_id, parent_rdd_id))
dependent_block_index = task_id % parent_rdd.partitions # Map the dependent block
dependent_block = parent_rdd.blocks[dependent_block_index]
dependent_block.add_ref_count()
dependent_blocks.append(dependent_block)
this_task.set_dependent_blocks(dependent_blocks)
# set peer-groups for LRC conservative policy
for dependent_block in dependent_blocks:
peer_group.append(dependent_block)
if (isinstance(self.cluster.block_manager.policy,
LRCConservativePolicy)):
self.cluster.block_manager.policy.add_peer_group(
peer_group)
peer_group = list()
# set produced_block
produced_block = this_rdd.blocks[task_id]
this_task.set_produced_block(produced_block)
task_list.append(this_task)
if (isinstance(self.cluster.block_manager.policy,
LRCAggressivePolicy)):
self.cluster.block_manager.policy.add_peer_group(peer_group)
this_stage.set_tasks(task_list)
stage_list.append(this_stage)
this_job.set_stages(stage_list)
self.job_list.append(this_job)
def test_shuffle(self):
stage = Stage()
for i in range(5):
stage.add(dot)
stage.add(kriss)
prev = copy.copy(stage.array)
stage.shuffle()
self.assertFalse(prev == stage.array)
prev.sort()
stage.array.sort()
self.assertTrue(prev == stage.array)
def Stage_draw(self, stage_id, stageTxt):
stage_file = stageTxt
stage = Stage(self.screen, stage_file, self.data)
pygame.mixer.music.load('sound/space.mp3') # 音楽ファイルの読み込み
pygame.mixer.music.play(-1) # 音楽の再生回数(ループ再生)
result = stage.loop()
if result[0] == EXIT:
self.exit()
elif result[0] == RETIRE:
return
self.StageResult_draw(stage_id, result)
def spawn_stage(self,
away_message,
effect_time=c.STAGE_SPAWN_TRANSITION,
callback=None):
try:
self.stage = Stage(self.screen, self, away_message)
self.stage.transition_in(effect_time, callback)
except Exception:
print("Could not spawn screensaver stage:\n")
traceback.print_exc()
self.grab_helper.release()
status.Active = False
self.cancel_timers()
def enter():
global cookie, stage, pet, game_timer, gameinfo, hp_time
game_timer = get_time()
hp_time = get_time()
cookie = Cookie()
gameinfo = GameInfo()
stage = Stage()
pet = Pet()
game_world.objects = [[], [], [], []]
game_world.add_object(stage, 0)
game_world.add_object(cookie, 1)
game_world.add_object(pet, 2)
game_world.add_object(gameinfo, 3)
def main():
global FPS
global gameDisplay
global clock
global stage
global player, player2
global current_frame
global font
global keyDict
# Framerate variables:
FPS = 60
clock = pygame.time.Clock()
current_frame = 0
# Initialize display:
# os.environ['SDL_VIDEO_CENTERED'] = '1'
pygame.init()
# gameDisplay = pygame.display.set_mode((0, 0), pygame.FULLSCREEN | pygame.HWSURFACE | pygame.DOUBLEBUF) # Run fullscreen
gameDisplay = pygame.display.set_mode(
(1440, 810)) # Run borderless windowed
pygame.mouse.set_visible(False)
pygame.display.set_caption('Comet')
font = pygame.font.Font(None, 30)
# Initialize the stage and add sprites:
stage = Stage(2) # 2 layers
player = stage.addSprite(Player(sprites.spaceship1, x=500, y=500))
# player2 = stage.addSprite(Player(sprites.spaceship2, x=500, y=500, keys=(pygame.K_UP, pygame.K_LEFT, pygame.K_DOWN, pygame.K_RIGHT, pygame.K_LCTRL)))
for _ in range(0):
stage.addSprite(Player(sprites.spaceship1, keys=(0, ) * 5))
keyDict = ConstructKeysDict()
# stage.setFocus(player)
stage.setBackground([[
"textures\\background\\debug00.png",
"textures\\background\\debug01.png",
"textures\\background\\debug20.png"
],
[
"textures\\background\\debug10.png",
"textures\\background\\debug11.png",
"textures\\background\\debug21.png"
],
[
"textures\\background\\debug02.png",
"textures\\background\\debug12.png",
"textures\\background\\debug22.png"
]])
# End of initialization
print(keyDict)
gameLoop()
def spawn_stage(self, away_message, callback=None):
"""
Create the Stage and begin fading it in. This may run quickly, in the case of
user-initiated activation, or slowly, when the session has gone idle.
"""
try:
self.stage = Stage(self, away_message)
self.stage.activate(callback)
except Exception:
print("Could not spawn screensaver stage:\n")
traceback.print_exc()
self.grab_helper.release()
status.Active = False
self.cancel_timers()
def init(cfg, sharedir):
"""
Initialize the GUI subsystem
"""
config.init(cfg, sharedir)
# expose methods and variables from stage to the gui subsystem
global stage, active, show_application, destroy_application, show_widget, load_theme
stage = Stage()
for key in stage.signals:
stage.signals[key].connect(signals[key].emit)
show_application = stage.show_application
destroy_application = stage.destroy_application
show_widget = stage.show_widget
load_theme = stage.load_theme
active = True
def __init__(self, lan):
pygame.init()
self.gravity = 0
self.rotated = 0
self.next_figure = self.get_random_figure()
self.figure = self.get_random_figure()
self.stage = Stage()
self.menu = Menu(self.stage, self.next_figure)
self.collision = Collision(self.stage)
self.move_x = 0
self.move_y = 0
if lan is None:
self.second_player = NoPlayer()
else:
self.second_player = LanSecondPlayer(self.menu, lan)
def main():
pygame.mixer.init()
pygame.init()
window = GameWindow("Tower Defense", 800, 600)
loader = ResourceLoader()
stage = Stage(loader.fetch("test.test"), 2, 2, window)
sprite = Sprite([loader.fetch("test.test")])
sprite.setPosition((0, 0))
sprite2 = Sprite([loader.fetch("test.test")])
sprite2.setPosition((-1, -1))
sprite.lookToward(sprite2)
stage.addSprite(sprite)
stage.addSprite(sprite2)
loader.fetch("test.pop").play()
window.addTickEvent(lambda t: stage.tick(t))
window.run()
