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 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 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()