def __init__(self, directory, sha=None, clone=False):
self.directory = os.path.abspath(directory)
self.clone = clone
self.peers = []
self.dampen = {}
self.aka = {} # mapping of addr's to peer-ids
self.loops = {}
self.closed = False
if self.clone:
self.git = None
self.sha = sha
else:
self.git = Git(self.directory)
self.sha = self.git.root
self.short_sha = self.sha[:7]
if self.index.has_key(self.sha):
raise Exception("Swarm already exists for %s" % self.directory)
self.index[self.sha] = self
EventLoop.register(self)
print timestamp(), self, "Registered", self.sha
lpd.LPD.update()
def main(): loop = EventLoop() keybinder = XKeyBinder(loop) config.activate_key_bindings(keybinder) loop.run()
def on_readable(self):
buf = self.fd.read(1024)
if buf:
for line in buf.split('\n'):
if line == '':
continue
print timestamp(), self, repr(line.rstrip())
return
#print timestamp(), self, "EOF"
# If we waitpid() with os.WNOHANG, sometimes our waitpid() syscall will
# execute before our child process has had a chance to exit(), in which
# case it returns the PID as 0. As we can be reasonably assured that
# the child will exit soon now that it has closed sdout, let's risk
# blocking.
#(pid, exitcode) = os.waitpid(self.pid, os.WNOHANG)
(pid, exitcode) = os.waitpid(self.pid, 0)
assert pid == self.pid
print timestamp(), self, "exit", exitcode
self.exitcode = exitcode
self.closed = True
EventLoop.unregister(self)
def run(self):
play_menu = Menu(self.game_screen)
high_score_menu = HighScoreScreen(self.game_screen, self.hold_score)
intro_ghost_chase = Intro(self.game_screen)
event_iterator = EventLoop(loop_running=True, actions={pygame.MOUSEBUTTONDOWN: play_menu.check_buttons})
while event_iterator.loop_running:
self.tick_component.tick(60)
event_iterator.check_events()
self.game_screen.fill(PlayGame.game_color)
if not play_menu.high_score_menu:
intro_ghost_chase.update()
intro_ghost_chase.blit()
play_menu.blit()
else:
high_score_menu.blit()
high_score_menu.check_done()
if play_menu.ready_to_play:
pygame.mixer.music.stop()
self.play_game()
for g in self.pacman_ghosts:
g.reset_speed()
play_menu.ready_to_play = False
self.hold_score.save_high_scores()
high_score_menu.prep_images()
high_score_menu.position()
elif not pygame.mixer.music.get_busy():
pygame.mixer.music.play(-1)
pygame.display.flip()
def __init__(self, host, port, listen_port):
if [ x for x in self.index if x.host == host and x.port == port ]:
raise Exception("Tracker already exists for %s:%d" % (host, port))
self.closed = False
self.host = host # Tracker's hostname
self.port = port # Tracker's port
self.listen_port = listen_port # Our port, to announce
self.swarms = {} # Map of Swarm objects to announcement expire times
self.transaction_id = random.randint(0, 2**32)
self.key = random.randint(0, 2**32)
self.state = STATE_SOCK
self.sock = None
self.sock_next_attempt = 0
self.current_swarm = None
self.conn_id = None
self.conn_id_expires = 0
self.conn_id_next_attempt = 0
self.conn_id_retry = 0
self.announce_next_attempt = 0
self.announce_retry = 0
self.unmute_time = 0
self.index.append(self)
EventLoop.register(self)
print timestamp(), self, "Registered"
def __init__(self, app, doc_file=''):
UCDocPresenter.__init__(self, config, app.appdata)
self.app = app
self.eventloop = EventLoop(self)
self.selection = Selection(self)
if doc_file:
self.load(doc_file)
self.doc_name = os.path.basename(self.doc_file)
else:
self.new()
self.doc_name = self.app.get_new_docname()
self.cms = self.app.default_cms
self.api = PresenterAPI(self)
self.docarea = DocArea(self.app, self)
self.canvas = self.docarea.canvas
self.api.view = self.canvas
self.app.mw.add_tab(self.docarea)
self.eventloop.connect(self.eventloop.DOC_MODIFIED, self.modified)
self.traced_objects = [
self.eventloop, self.api, self.docarea.hruler, self.docarea.vruler,
self.docarea.corner, self.docarea, self.canvas.renderer,
self.canvas, self.selection, self
]
def play(self, inputs):
eloop = EventLoop(finished=False)
eloop.movePLAYER(self.player, inputs)
self.player.setFITNESS()
self.fitness = self.player.fitness
print(self.fitness)
def main():
loop = EventLoop()
keybinder = XKeyBinder(loop)
config.activate_key_bindings(keybinder)
loop.run()
def play(self):
eventloop = EventLoop(finished=False)
while not eventloop.finished:
self.clock.tick(30)
eventloop.check_events(self.player)
self.player.update()
self.update_screen()
def play(self):
eloop = EventLoop(finished=False)
while not eloop.finished:
eloop.checkEvents(self)
self.updateScreen()
# self.check_events()
self.player_update()
def play(self):
eloop = EventLoop(finished=False)
while not eloop.finished:
eloop.check_events(self.pacman, self.start_rect)
self.update_screen()
self.pacman.update()
for ghost in self.ghost:
ghost.update()
def play(self):
eloop = EventLoop(self.ai_settings.finished, self.ai_settings.display_lives)
self.load_data()
while not eloop.finished:
eloop.check_events(self.ai_settings, self.menu, self.mario)
self.mario.update(self.map.rock, self.map.metal, self.map.stone, self.map.brick, self.map.q, self.map.pipe,
self.map.pipe_1, self.map.coins)
self.update_screen()
self.sb.check_high_score(self.sb)
def __init__(self, addr, backlog=5):
sock = socket.socket()
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.bind(addr)
sock.listen(backlog)
sock.setblocking(False)
self.sock = sock
self.addr = sock.getsockname()
EventLoop.register(self)
print timestamp(), self, "Listening"
def play(self):
eloop = EventLoop(self.ai_settings.finished)
while not eloop.finished:
eloop.check_events(self.ai_settings, self.menu, self.pacman)
self.pacman.check_dot_collision(self.ai_settings, self.maze.dots,
self.maze.pills, self.sb)
self.sb.check_high_score(self.sb)
self.update_screen()
self.pacman.check_wall_collision(self.maze.bricks)
self.pacman.update()
self.ghost.update_ghost(self.pacman, self.maze.nodes)
def __init__(self, port, announce_time=600, sock_attempt_time=5):
if self.index:
raise Exception("An instance already exists?")
self.port = port
self.announce_time = announce_time
self.sock_attempt_time = sock_attempt_time
self.last_sock_attempt = 0
self.sock = None
self.open_socket()
self.index.append(self)
EventLoop.register(self)
def play(self):
# sleep(4)
#pygame.mixer.Sound.play(self.intro)
sleep(1)
eventloop = EventLoop(finished=False)
pygame.mixer.Sound.play(self.intro)
while not eventloop.finished:
#self.clock.tick(60)
eventloop.check_events(self.screen, self.player, self.sb, self.play_button, self.stats, self.set)
self.player.update()
self.update_screen()
def close(self):
if self.closed:
return
self.closed = True
print timestamp(), self, "I was asked to close? Ok..."
EventLoop.unregister(self)
try:
self.fd.close()
os.killpg(self.pid, signal.SIGTERM)
self.popen.wait()
except Exception:
traceback.print_exc()
print
def play(self):
# self.displayname = Button(self.screen, "Portal Pacman")
self.displayname.rect.centery -= 300
self.displayname.msg_image_rect.center = self.displayname.rect.center
# self.highscore_button = Button(self.screen, "Portal Pacman")
self.highscore_button.rect.centery += 330
self.highscore_button.msg_image_rect.center = self.highscore_button.rect.center
# self.play_button = Button(self.screen, "Portal Pacman")
self.play_button.rect.centery += 280
self.play_button.msg_image_rect.center = self.play_button.rect.center
hs_file = open("score.txt", "r")
self.ai_settings.hs = int(hs_file.read())
hs_file.close()
msgg = 'The high score is ' + str(self.ai_settings.hs)
self.score = Button(self.screen, msgg)
self.score.rect.centery -= 150
self.score.msg_image_rect.center = self.score.rect.center
self.ghosts.intro()
self.pacman.intro()
self.blues = pygame.mixer.Sound('sounds/blueghosts.wav')
eloop = EventLoop(finished=False)
while not eloop.finished:
eloop.check_events(self.ai_settings, self.pacman, self.maze,
self.play_button, self.highscore_button,
self.back, self.ghosts, self.blues, self.sb)
if self.ai_settings.score > self.ai_settings.hs and self.ai_settings.game_active:
self.ai_settings.hs = self.ai_settings.score
msgg = 'The high score is ' + str(self.ai_settings.hs)
score = Button(self.screen, msgg)
score.rect.centery += 150
score.msg_image_rect.center = score.rect.center
if len(self.maze.dots) == 1:
self.maze = Maze(self.screen,
mazefile='map.txt',
brickfile='square',
portalfile='square',
shieldfile='shield',
pointfile='point',
dotfile='dot',
powerpillfile='powerpill')
self.pacman.reset()
self.ghosts.reset()
self.ai_settings.level += 1
if not self.ai_settings.game_active:
pygame.mouse.set_visible(True)
self.update_screen()
def drop(self):
if self.closed:
return
self.closed = True
del self.index[self.sha]
EventLoop.unregister(self)
print timestamp(), self, "Dropping (and %d peers)" % len(self.peers)
# We need to make a copy of self.peers, because when peers are closed,
# they'll be modifying the list as we iterate through it. This was a
# an *extremely* annoying bug to track down.
for x in list(self.peers):
print "Closing", x
x.close()
def play(self):
eloop = EventLoop(self.settings, self.pacman, finished=False)
while not self.stats.game_active:
if self.settings.high_score_screen:
self.menu.high_scores()
else:
self.menu.start_menu(self.play_button, self.high_scores_button)
self.check_events()
pygame.display.update()
while not eloop.finished:
self.check_events()
eloop.check_events()
self.check_collision()
self.update_screen()
def __init__(self, app, doc_file=''): UCDocPresenter.__init__(self, config, app.appdata) self.app = app self.eventloop = EventLoop(self) self.selection = Selection(self) if doc_file: self.load(doc_file) self.doc_name = os.path.basename(self.doc_file) else: self.new() self.doc_name = self.app.get_new_docname() self.cms = self.app.default_cms self.api = PresenterAPI(self) self.docarea = DocArea(self.app, self) self.canvas = self.docarea.canvas self.api.view = self.canvas self.app.mw.add_tab(self.docarea) self.eventloop.connect(self.eventloop.DOC_MODIFIED, self.modified) self.traced_objects = [ self.eventloop, self.api, self.docarea.hruler, self.docarea.vruler, self.docarea.corner, self.docarea, self.canvas.renderer, self.canvas, self.selection, self ]
def play(self):
eloop = EventLoop(finished=False)
while not eloop.finished:
eloop.check_events(self.screen, self.player, self.maze, self.stats,
self.button)
if self.stats.game_active:
eloop.check_wall_collision(self.player, self.maze)
eloop.check_pill_collision(self.player, self.maze, self.stats)
eloop.check_killpill_collision(self.player, self.maze,
self.stats)
self.player.update()
self.update_screen()
self.check_high_score()
self.score_board = Scoreboard(self.screen, self.stats)
self.score_board.prep_high_score()
def play(self):
eloop = EventLoop(self.ai_settings.finished,
self.ai_settings.display_lives)
self.load_data()
while not eloop.finished:
eloop.check_events(self.ai_settings, self.menu, self.mario)
self.mario.update(self.map.rock, self.map.metal, self.map.stone,
self.map.brick, self.map.q, self.map.pipe,
self.map.pipe_1, self.map.coins)
self.enemies.update()
self.powerups.update()
self.update_screen()
self.sb.check_high_score(self.sb)
if self.enemies.g_rect.left == self.ai_settings.screen_width:
Mobs(self.ai_settings, self.screen, self.map, self)
def play(self):
clock = pygame.time.Clock()
eloop = EventLoop(finished=False)
while not eloop.finished:
eloop.check_events(self.settings, self.stats, self.player, self.pb, self.maze)
self.menu.prep_screen()
if self.stats.game_active:
self.player.update(self.maze)
self.red.update(self.maze)
self.blue.update(self.maze)
self.orange.update(self.maze)
self.pink.update(self.maze)
self.display_game()
clock.tick(20)
def close(self):
if self.closed:
return
self.closed = True
#print timestamp(), self, "Closing"
try:
self.sock.close()
except Exception:
traceback.print_exc()
if self.eof:
self.peer.proxy_close(self, cancel=False)
else:
self.peer.proxy_close(self, cancel=True)
EventLoop.unregister(self)
def __init__(self, peer, tag, cmd):
self.tag = tag
self.peer = peer
self.cmd = cmd
self.popen = Popen(cmd, stdout=PIPE, stderr=STDOUT, preexec_fn=os.setsid)
self.pid = self.popen.pid
self.fd = self.popen.stdout
self.eof = False
self.closed = False
# Set non-blocking
flags = fcntl.fcntl(self.fd, fcntl.F_GETFL)
flags |= os.O_NONBLOCK
fcntl.fcntl(self.fd, fcntl.F_SETFL, flags)
print timestamp(), self, "Running", repr(' '.join(cmd))
EventLoop.register(self)
def close(self):
if self.closed:
return
self.closed = True
print timestamp(), self, "Closing Connection"
try:
self.sock.close()
except Exception:
traceback.print_exc()
try:
self.peer.close()
except Exception:
traceback.print_exc()
EventLoop.unregister(self)
def runserver():
logging.basicConfig(level=logging.INFO,
format='%(asctime)s %(levelname)-8s %(message)s',
datefmt='%Y-%m-%d %H:%M:%S')
parse = argparse.ArgumentParser("Server Options")
parse.add_argument("-p", "--port", default=settings.PORT, type=int, help="set listen port")
args = parse.parse_args()
port = args.port
loop = EventLoop()
chat_server = ChatServer(settings.ADDR, port)
chat_server.add_to_loop(loop)
try:
loop.run()
except (KeyboardInterrupt, IOError, OSError) as e:
logging.error(e)
import traceback
traceback.print_exc()
def __init__(self):
pygame.init()
self.screen = pygame.display.set_mode((680, 740))
pygame.display.set_caption("Pacman Portal")
self.maze = Maze(self.screen,
mazefile='maze.txt',
brickfile='square',
portalfile='close_portal',
shieldfile='shield',
powerfile='powerpil',
pointsfile='points',
foodfile='cherry')
self.menu = Startup(self.screen, 'title.png', 'playbutton.png')
self.pacman = Pacman(self.screen)
self.ghosts = Ghosts(self.screen)
self.eloop = EventLoop(finished=False)
def play_game(self):
event_iterator = EventLoop(loop_running=True, actions={**self.pacman_player.event_map, **self.game_actions})
self.next_level.set_show_transition()
self.lost_game = False
if self.pacman_player.dead:
self.pacman_player.revive()
self.hold_score.reset_level()
self.lives_left.reset_counter()
self.rebuild_maze()
while event_iterator.loop_running:
self.tick_component.tick(60)
event_iterator.check_events()
self.update_screen()
if self.lost_game:
pygame.mixer.stop()
self.hold_score.reset_level()
event_iterator.loop_running = False
def test_invalid_config(path_args: Dict[str, pathlib.Path]):
evtloop = EventLoop()
args = {
'config_file': str(path_args['moonraker.conf']),
'log_file': "",
'software_version': "moonraker-pytest"
}
with pytest.raises(ConfigError):
Server(args, None, evtloop)
def run(destaddrs, timeout, output):
eventloop = EventLoop()
for destaddr in destaddrs:
eventloop.add_dispatcher(UDPProbe(destaddr, output))
eventloop.add_dispatcher(ICMPHandler(destaddr))
eventloop.run(timeout)
def close(self):
if self.closed:
return
self.closed = True
self.reap_children()
if self.children:
print timestamp(), self, "Shutting down, but still children:", self.children
try:
self.sock.close()
except Exception:
traceback.print_exc()
EventLoop.unregister(self)
for x in self.children:
if not x.closed:
x.close()
def setUp(self):
self.ctx = zmq.Context.instance()
self.control = self.ctx.socket(zmq.DEALER)
self.eventloop = EventLoop(self.ctx,
"inproc://eventloop-control",
"MOEX")
self.control.connect("inproc://eventloop-control")
self.eventloop.start()
def runclient():
logging.basicConfig(level=logging.INFO,
format='%(asctime)s %(levelname)-8s %(message)s',
datefmt='%Y-%m-%d %H:%M:%S')
parse = argparse.ArgumentParser("Client Options")
parse.add_argument("-a", "--addr", default=settings.ADDR, type=str, help="set connect address")
parse.add_argument("-p", "--port", default=settings.PORT, type=int, help="set connect port")
args = parse.parse_args()
addr = args.addr
port = args.port
loop = EventLoop()
chat_client = ChatClient(addr, port)
chat_client.add_to_loop(loop)
try:
loop.run()
except (KeyboardInterrupt, IOError, OSError) as e:
logging.error(e)
import traceback
traceback.print_exc()
def main():
# Load the database of items we know about.
global db
db = ImageDatabase(options)
# Initialize the camera object we'll use to take pictures.
global camera
camera = Camera(options.video_source,
options.video_width,
options.video_height,
options.video_fps)
with open(get_sound('shutter.raw'), 'rb') as f:
global SHUTTER_TONE
SHUTTER_TONE = f.read()
# Set up the audio devices if they are configured
if options.audio_out_device:
audioutils.ALSA_SPEAKER = options.audio_out_device
if options.audio_in_device:
audioutils.ALSA_MICROPHONE = options.audio_in_device
# If log path is set, make sure the corresponding directory exists.
if options.log_path and not os.path.isdir(options.log_path):
os.makedirs(options.log_path)
# If --web-server was specified, run a web server in a separate process
# to expose the files in that directory.
# Note that we're using port 80, assuming we'll always run as root.
if options.web_server:
subprocess.Popen(['python', '-m', 'SimpleHTTPServer', '80'],
cwd=options.web_server_root)
# Monitor the button for events
global eventloop
eventloop = EventLoop()
eventloop.monitor_gpio_button(options.gpio_pin, button_handler,
doubleclick_speed=0)
# If you don't have a button, use --cmd-ui to monitor the keyboard instead.
if options.cmd_ui:
# Print instructions.
keyboard_handler()
# Monitor it on the event loop.
eventloop.monitor_console(keyboard_handler, prompt="Command: ")
# Let the user know we're ready
ready()
# Run the event loop forever
eventloop.loop()
class Game:
BLACK = (0, 0, 0)
def __init__(self):
pygame.init()
self.screen = pygame.display.set_mode((680, 740))
pygame.display.set_caption("Pacman Portal")
self.maze = Maze(self.screen,
mazefile='maze.txt',
brickfile='square',
portalfile='close_portal',
shieldfile='shield',
powerfile='powerpil',
pointsfile='points',
foodfile='cherry')
self.menu = Startup(self.screen, 'title.png', 'playbutton.png')
self.pacman = Pacman(self.screen)
self.ghosts = Ghosts(self.screen)
self.eloop = EventLoop(finished=False)
def __str__(self):
return 'Game(Pacman Portal),maze='
def play(self):
while not self.eloop.finished:
self.eloop.check_events(self.pacman)
self.pacman.update()
# if self.game_active:
self.update_screen()
def update_screen(self):
self.screen.fill(Game.BLACK)
self.maze.blitme()
self.pacman.blit_pac()
self.ghosts.blit_ghost()
# if not self.eloop.game_active:
# self.menu.draw_menu()
pygame.display.flip()
def __init__(self, listener, sock, addr, peer):
sock.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 1024*128)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 1024*128)
self.listener = listener
self.auth = listener.auth
self.sock = sock
self.addr = addr
self.peer = peer
self.readbuf = ''
self.bytes_read = 0
self.request = ''
self.idle_timeout = time.time()
self.sent_header = False
self.eof = False
self.closed = False
self.id_ = None
self.filename = None
#print timestamp(), self, "Incomming connection from", self.addr
EventLoop.register(self)
def test_config_and_log_warnings(path_args: Dict[str, pathlib.Path]):
evtloop = EventLoop()
args = {
'config_file': str(path_args['moonraker.conf']),
'log_file': "",
'software_version': "moonraker-pytest",
'log_warning': "Log Warning Test",
'config_warning': "Config Warning Test"
}
expected = ["Log Warning Test", "Config Warning Test"]
server = Server(args, None, evtloop)
assert server.warnings == expected
def main():
ev = EventLoop()
#ev.run_coroutine(timed_print)
#ev.run_coroutine(read_text)
#ev.run_coroutine(wait_for_other_coroutine)
ev.run_coroutine(writable)
ev.loop()
def play(self):
while True:
mloop = MenuLoop(self.screen,
self.stats,
finished=False,
highscore_screen=False)
while not mloop.finished:
mloop.check_events()
mloop.update()
self.update_menu_screen(mloop)
if mloop.highscore_screen == True:
while mloop.highscore_screen:
mloop.check_highscore_events()
mloop.update_highscore_screen()
self.update_highscore_screen(mloop)
self.maze = Maze(self.screen, self.mazefile, 'square', 'shield',
'left_bigman_1', 'powerpill', 'tablet',
'up_clyde_1', 'up_pinky_1', 'up_inky_1',
'up_blinky_1', self.stats)
eloop = EventLoop(self.maze, self.screen, finished=False)
while not eloop.finished:
eloop.check_events()
eloop.update(self.settings, self.screen, self.stats)
self.update_screen()
def main():
# Monitor the button for events.
global eventloop
eventloop = EventLoop()
eventloop.monitor_gpio_button(args.gpio_pin,
button_handler,
doubleclick_speed=0)
say("Device is in Service Mode. Press button to navigate through the menu. "
"Long press to enter the menu section or perform an action.")
# Read current configuration values.
with open(args.config_path) as config_file:
for line in config_file:
key, value = line.partition("=")[::2]
# Ignore empty lines.
key = key.strip()
if key:
config[key] = value.strip()
logger.info('Current environment variables: %s', config)
ready()
# Run the event loop forever.
eventloop.loop()
def __init__(self, peer, sock, addr):
if sock is None:
# No sock argument means outbound connection
sock = socket.socket()
sock.setblocking(False)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 1024*128)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 1024*128)
self.connected = False
else:
self.connected = True
self.peer = peer
self.sock = sock
self.addr = addr
self.host = addr[0]
self.port = addr[1]
self.readbuf = ''
self.parse_state = STATE_START
self.parse_len = 0
self.helo = False
self.last_read_time = time.time()
self.last_ping_time = time.time()
self.closed = False
if not self.connected:
print timestamp(), self, "Connecting to", self.addr
try:
self.sock.connect(self.addr)
except socket.error as e:
if e.errno != errno.EINPROGRESS:
raise
else:
print timestamp(), self, "Connected immediately?"
self.on_connect()
EventLoop.register(self)
def send_helo(self):
l = [ x for x in EventLoop.list() if isinstance(x, listener.Listener) ]
assert len(l) == 1
port = l[0].addr[1]
self.send('helo',
protocol='p2p-git',
major=config.major_version,
minor=config.minor_version,
swarmid=self.swarm.sha,
peerid=self.my_peerid,
port=port,
client='mainline-' + str(config.version),
)
def __init__(self, peer, port=0, backlog=4):
sock = socket.socket()
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.bind(('127.0.0.1', port))
sock.listen(backlog)
sock.setblocking(False)
self.peer = peer
self.sock = sock
self.addr = sock.getsockname()
self.closed = False
# Generate a random username and password for authentication. We're
# binding to localhost, but this prevents another user on the system
# from hijacking our connection.
self.auth = '%s:%s' % (base64.b32encode(os.urandom(10)), base64.b32encode(os.urandom(10)))
self.url = 'http://%s@%s:%d/' % (self.auth, self.addr[0], self.addr[1])
self.children = []
self.set_env()
EventLoop.register(self)
print timestamp(), self, "Proxy URL", self.url
def play(self):
eloop = EventLoop(finished=False)
while not eloop.finished:
while not self.stats.game_active:
self.play_button.draw_button()
eloop.check_events(self.pacman, self.play_button, self.stats)
eloop.check_events(self.pacman, self.play_button, self.stats)
self.pacman.update(self.maze, self.pac_group)
self.update_screen()
def play(self):
clock = pygame.time.Clock()
eloop = EventLoop(finished=False)
while not eloop.finished:
eloop.check_events(self.screen, self.pacman, self.startup)
if self.startup.playing:
pygame.mixer.music.stop()
if not self.settings.flag_chomp:
self.settings.chomp_music()
self.settings.flag_chomp = True
self.settings.chomp_music()
self.pacman.update(self.maze, self.settings, self.stats, self.sb, self.red, self.blue, self.orange,
self.pink)
self.red.update(self.maze, self.settings, self.stats, self.pacman, self.startup, self.blue, self.pink,
self.orange, self.sb)
self.blue.update(self.maze, self.settings, self.stats, self.pacman, self.startup, self.red, self.pink,
self.orange, self.sb)
self.orange.update(self.maze, self.settings, self.stats, self.pacman, self.startup, self.blue,
self.pink, self.red, self.sb)
self.pink.update(self.maze, self.settings, self.stats, self.pacman, self.startup, self.blue, self.red,
self.orange, self.sb)
self.update_screen()
clock.tick(155)
def base_server(path_args: Dict[str, pathlib.Path],
event_loop: asyncio.AbstractEventLoop) -> Iterator[Server]:
evtloop = EventLoop()
args = {
'config_file': str(path_args['moonraker.conf']),
'log_file': str(path_args.get("moonraker.log", "")),
'software_version': "moonraker-pytest"
}
ql = logger = None
if args["log_file"]:
ql, logger, warning = utils.setup_logging(args)
if warning:
args["log_warning"] = warning
yield Server(args, logger, evtloop)
if ql is not None:
ql.stop()
def showLAST(self, inputs):
clock = pygame.time.Clock()
eloop = EventLoop(finished=False)
eloop.movePLAYER(self.player, inputs)
self.player.setFITNESS()
self.fitness = self.player.fitness
print(self.fitness)
while not eloop.finished:
eloop.check_events(self.settings, self.player, self.maze, inputs)
self.player.update(self.maze)
self.display_game()
clock.tick(20)
def play(self):
# Starts the game
eloop = EventLoop(self.screen,
self.settings,
self.play_button,
self.score_button,
self.maze,
self.stats,
self.sb,
self.pacman,
self.pac,
self.ghosts,
self.points,
self.pills,
self.fruits,
self.portal,
finished=False)
# loops while not finished
while not eloop.finished:
# Check events
eloop.check_events()
if self.stats.game_active:
# spawns fruits at random times
if self.delay == self.timer:
self.maze.create_fruit(self.stats.fruit_count)
if self.stats.fruit_count >= 3:
self.stats.fruit_count = 0
else:
self.stats.fruit_count += 1
self.delay = 0
self.timer = random.randint(3000, 5001)
else:
self.delay += 1
# deletes fruit after a period of time
if self.count == self.timer2:
self.fruits.empty()
self.count = 0
else:
self.count += 1
# updates sprites
self.pac.update()
self.ghosts.update()
self.portal.update()
# Checks for collision
eloop.check_collisions()
self.update_screen()
def play(self):
eloop = EventLoop(self.ai_settings.finished)
self.load_data()
while not eloop.finished:
eloop.check_events(self.ai_settings, self.menu, self.pacman)
self.pacman.check_dot_collision(self.ai_settings, self.maze.dots,
self.maze.pills, self.sb)
self.sb.check_high_score(self.sb)
self.update_screen()
self.pacman.check_wall_collision(self.maze.bricks)
self.pinky.check_wall_collision(self.maze.bricks)
self.inky.check_wall_collision(self.maze.bricks)
self.blinky.check_wall_collision(self.maze.bricks)
self.clyde.check_wall_collision(self.maze.bricks)
self.pacman.update()
self.ghosts.update()
eloop.update_collisions(self.ai_settings, self.pacman, self.ghosts,
self.maze)
from eventloop import EventLoop
from common import config_reader
import logging
import sys, os
if __name__ == "__main__":
cookie, tiebaName = config_reader()
logging.basicConfig(filename='log.txt', level=logging.DEBUG, format='%(asctime)s %(message)s')
eventLoop = EventLoop(tiebaName, cookie)
while True:
try:
eventLoop.loop()
except Exception as e:
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
logging.warning("Error :{0} of {1} on {2}:{3} ".format(str(e), exc_type, fname, exc_tb.tb_lineno))
# Copyright (c) 2012 Cheery
#
# See the file license.txt for copying permission.
from eventloop import EventLoop, InputManager
devices = InputManager()
def onadd(device):
print "[*] %r" % device
def onevent(timestamp, type, code, value):
print device, timestamp, type, code, value
device.onevent = onevent
def onremove(device):
print "[ ] %r" % device
devices.onadd = onadd
devices.onremove = onremove
eventloop = EventLoop(devices)
eventloop.run(1 / 60.0)
self.sock.connect(('localhost', 1234))
def fileno(self):
return self.sock.fileno()
def onRead(self):
msg = self.sock.recv(1000).decode('utf-8')
print(msg)
def send(self, msg):
self.sock.send(msg)
class Input():
def __init__(self, sock):
self.sock = sock
def fileno(self):
return sys.stdin.fileno()
def onRead(self):
msg = sys.stdin.readline().encode('utf-8')
self.sock.send(msg)
sock = Connection()
inputReader = Input(sock)
eventLoop = EventLoop()
eventLoop.addReader(sock)
eventLoop.addReader(inputReader)
eventLoop.runForever()
if event is None: return if not isinstance(event, self.xcb.xproto.KeyPressEvent): continue (keycode, modifiers) = (event.detail, event.state) try: (func, args, kwargs) = self.bindings[(keycode, modifiers)] except KeyError: continue func(*args, **kwargs) if __name__ == '__main__': from eventloop import EventLoop loop = EventLoop() bindings = XKeyBindings(loop) def foo(): print 'FOO!!!' def bar(): print 'BAR!!!' def baz(): print 'BAZ!!!' loop.stop() bindings.bind_key(0, 'parenleft', foo) bindings.bind_key(0, 'parenright', bar) bindings.bind_key(0, 'Escape', baz) loop.run()
Should print [0, 2, 4, 8, 10] after 5 seconds (because the last Promise from the given list
fulfills after 5 seconds)
"""
list_of_promises = [Promise.delayed(6-i, 2*i) for i in range(6)];
Promise.all(list_of_promises).then(my_print);
def test6():
"""
Tests foreach.
Should print 1, [delay 1s], 2, [delay 2s], 3, [delay 3s], 4
"""
def f(x):
print('%d'%x)
return Promise.delayed(x, x)
Promise.foreach([1, 2, 3, 4], f)
e = EventLoop()
e.start()
#p = Promise(print_inc_wait());
#pdb.set_trace();
#test1()
#test2()
#test3()
#test4()
#test5()
test6()
"""
list_of_promises = [Promise.delayed(5-i, 2*i) for i in range(5)]
Promise.all(list_of_promises).then(my_print)
def test6():
"""
Tests foreach.
Should print 1, [delay 1s], 2, [delay 2s], 3, [delay 3s], 4
"""
def f(x):
print('%d'%x)
return Promise.delayed(x, x)
Promise.foreach([1, 2, 3, 4], f)
e = EventLoop()
e.start()
#test1()
#test2()
#test3()
#test4()
#test5()
#test6()
input("Press return to exit\n");
e.stop()
# -*- coding: utf-8 -*-
'''
Created on 04/03/2013
@author: Cuble Desarrollo
'''
from eventloop import EventLoop
def event1():
print "event1"
if __name__ == "__main__":
el = EventLoop()
el.queue.put("event1")
el.queue.put("event1")
el.queue.put("event1")
el.queue.put("event1")
el.add_handler("event1", event1)
el.start()
print "Started"
#!/usr/bin/env python
'''
'''
import argparse
import zmq
from eventloop import EventLoop
if __name__ == '__main__':
parser = argparse.ArgumentParser(description='Quotesource that streams quotes from csv-files')
parser.add_argument('--exchange-id', help='Specifies exchange ID for all streams', required=True)
parser.add_argument('--control-ep', help='Specifies control endpoint', required=True)
parser.add_argument('--naive-delta', action='store_true', help='Enables naive delta calculation (upticks are buy, downticks are sell)')
args = parser.parse_args()
config = {'naive-delta' : False}
if args.naive_delta:
config['naive-delta'] = True
ctx = zmq.Context.instance()
loop = EventLoop(ctx, args.control_ep, args.exchange_id, config)
loop.start()
loop.wait()
class DocPresenter(UCDocPresenter): saved = True eventloop = None docarea = None canvas = None selection = None traced_objects = None def __init__(self, app, doc_file=''): UCDocPresenter.__init__(self, config, app.appdata) self.app = app self.eventloop = EventLoop(self) self.selection = Selection(self) if doc_file: self.load(doc_file) self.doc_name = os.path.basename(self.doc_file) else: self.new() self.doc_name = self.app.get_new_docname() self.cms = self.app.default_cms self.api = PresenterAPI(self) self.docarea = DocArea(self.app, self) self.canvas = self.docarea.canvas self.api.view = self.canvas self.app.mw.add_tab(self.docarea) self.eventloop.connect(self.eventloop.DOC_MODIFIED, self.modified) self.traced_objects = [ self.eventloop, self.api, self.docarea.hruler, self.docarea.vruler, self.docarea.corner, self.docarea, self.canvas.renderer, self.canvas, self.selection, self ] def close(self): if not self.docarea is None: self.app.mw.remove_tab(self.docarea) UCDocPresenter.close(self) for obj in self.traced_objects: fields = obj.__dict__ items = fields.keys() for item in items: fields[item] = None def modified(self, *args): self.saved = False self.set_title() events.emit(events.DOC_MODIFIED, self) def reflect_saving(self): self.saved = True self.set_title() self.api.save_mark() events.emit(events.DOC_SAVED, self) def set_title(self): if self.saved: title = self.doc_name else: title = self.doc_name + '*' self.app.mw.set_tab_title(self.docarea, title) def set_doc_file(self, doc_file, doc_name=''): self.doc_file = doc_file if doc_name: self.doc_name = doc_name else: self.doc_name = os.path.basename(self.doc_file) self.set_title() def save(self): try: if config.make_backup: if os.path.lexists(self.doc_file): if os.path.lexists(self.doc_file + '~'): os.remove(self.doc_file + '~') os.rename(self.doc_file, self.doc_file + '~') UCDocPresenter.save(self, self.doc_file) except IOError: errtype, value, traceback = sys.exc_info() raise IOError(errtype, value, traceback) self.reflect_saving()
