def main(): initialize() eventHandler = EventHandler() frameRateHandler = FrameRateHandler(60) squareSize = 100 totalSize = squareSize * 3 offsetY = squareSize offsetX = 0 backColor = Color(0, 0, 0) mainSurface = pygame.display.set_mode( (totalSize + offsetX, totalSize + offsetY)) gameBoard = GameBoard(0, offsetY, eventHandler, mainSurface) while True: frameRateHandler.updateStart() eventHandler.update() if eventHandler.quit or eventHandler.keys.release[K_ESCAPE]: break gameBoard.update() mainSurface.fill(backColor) gameBoard.draw() pygame.display.flip() frameRateHandler.updateEnd()
class Main(object): def __init__(self, params): self.ctx = zmq.Context() self.pool = Pool(processes=mp.cpu_count()) self.config = Config(params=params) self.logger = MEHLogger(self.config) self.plugin_provider = PluginProvider(self.config, self.logger) self.event_handler = EventHandler(self.plugin_provider, self.logger) def start(self): self.logger.info('Connecting to MISP-ZMQ Server at %s:%s' % (self.config.misp_host, self.config.misp_port)) s = self.ctx.socket(zmq.SUB) s.connect('tcp://%s:%s' % (self.config.misp_host, self.config.misp_port)) s.setsockopt(zmq.SUBSCRIBE, b'') self.logger.info('MISP-Server connection established.') self.logger.info('Subscribed and listening for MISP-Messages...') while True: msg = s.recv_multipart() self.logger.info('New MISP-Message received.') Process(target=self.process, args=msg).start() s.close() self.logger.info("Connection closed!") def process(self, msg): self.event_handler.process(msg)
def __init__(self, params): self.ctx = zmq.Context() self.pool = Pool(processes=mp.cpu_count()) self.config = Config(params=params) self.logger = MEHLogger(self.config) self.plugin_provider = PluginProvider(self.config, self.logger) self.event_handler = EventHandler(self.plugin_provider, self.logger)
class FetcherRunner(object): def __init__(self): """ """ self.config = _parse_args() self.context = _create_context(self.config) self.set_debug_mode(False) def register_fetcher(self, fetcher_handle): self.fetcher_handle = fetcher_handle def set_debug_mode(self, mode=True): self.debug = mode def start(self): self.event_handler = EventHandler(self) self.event_handler.register_callback( self.context.send_with_norm_policy_and_repo) job_generator = JobGenerator(self) try: joblet = gevent.spawn_link_exception(job_generator.job_updater) eventlet = gevent.spawn_link_exception( self.event_handler.event_queue_handler) gevent.joinall([joblet, eventlet]) except gevent.GreenletExit, err: logging.warn(err) except Exception, err: logging.warn(err)
def run_game(): # Initialize pygame, settings, and screen object. pygame.mixer.pre_init(44100, -16, 2, 2048) pygame.mixer.init() pygame.init() game_settings = GameSettings() screen = pygame.display.set_mode((game_settings.screen_width, game_settings.screen_height)) pygame.display.set_caption("Pac Man Portal") # Open sprite sheet sprite_sheet = SpriteSheet(file_name='images/spritesheet.png') # Make the Play and Scores button. play_button = Button(screen=screen, msg="Play", order=0) score_button = Button(screen=screen, msg="High Scores", order=1) # Open high score file try: high_score_file = open("high_score_file.txt", "r+") except FileNotFoundError: high_score_file = open("high_score_file.txt", "w+") # Open maze layout file maze_file = open('mazelayout.txt', 'r') # Make sound manager sounds = Sounds() # Initialize game stats and scoreboard stats = GameStats(game_settings=game_settings) sb = Scoreboard(screen=screen, game_settings=game_settings, stats=stats, sprite_sheet=sprite_sheet, high_score_file=high_score_file, sounds=sounds) # Initialize pacman pacman = Pacman(screen=screen, game_settings=game_settings, stats=stats, sb=sb, image_list=sprite_sheet.pacman_image, death_anim_list=sprite_sheet.pacman_death_image, sounds=sounds) # Initialize maze maze = Maze(screen=screen, game_settings=game_settings, maze_file=maze_file, sprite_sheet=sprite_sheet, pacman=pacman, sounds=sounds) # Initialize the event handler event_handler = EventHandler(pacman=pacman, play_button=play_button, score_button=score_button, stats=stats, sb=sb, maze=maze, sounds=sounds) # Initialize the display manager display = Display(screen=screen, game_settings=game_settings, stats=stats, sb=sb, sprite_sheet=sprite_sheet, play_button=play_button, score_button=score_button, maze=maze, pacman=pacman, event_handler=event_handler, sounds=sounds) # Start the main loop for the game while True: event_handler.check_events() if stats.game_active: pacman.update(maze=maze, display=display) maze.update_ghosts() maze.update_bullets() maze.update_portals() display.update_screen()
def snapshot_controller(event): try: handler = EventHandler(event) handler.update() return except Exception as e: logger.exception('Event Save Exception: {}'.format(e)) raise e
def get(self): """ Show all msg captions """ self.checkSession(self.request.headers.get('Cookie'), False) self.insertMenu() self.insertTemplate('tpl_events_menu.html') self.event = db.GqlQuery("SELECT * FROM DBEvent where date >= :today", today = db.datetime.date.today()) EventHandler.get(self) self.drawPage()
def initDatabase(clearDatabase: bool = False): """ Initializes events database. Can optionally clear previously existing data. Args: clearDatabase (bool, optional): to true to clear previously existing data. Defaults to False. """ eHandler = EventHandler() eHandler.createDatabase(clearDatabase)
def get(self): """ Show all msg captions """ self.checkSession(self.request.headers.get('Cookie'), False) self.insertMenu() self.insertTemplate('tpl_events_menu.html') self.event = db.GqlQuery("SELECT * FROM DBEvent where date >= :today", today=db.datetime.date.today()) EventHandler.get(self) self.drawPage()
def get(self): """ Show all msg captions """ self.checkSession(self.request.headers.get('Cookie')) self.insertMenu() self.insertTemplate('tpl_events_menu.html') self.insertContent("<h1>Вы создали события:</h1><br>") self.event = db.GqlQuery("SELECT * FROM DBEvent where userid = :userid", userid = self.Session['userid'], today=db.datetime.date.today()) EventHandler.get(self) self.drawPage()
def insertEvent(eventType: str, eventTitle: str, eventDescription: str): """ Inserts an event into the database. Args: eventType (str): Type of the event eventTitle (str): Title of the event eventDescription (str): Description of the event """ eHandler = EventHandler() eHandler.insertEvent(eventType, eventTitle, eventDescription)
def getAllEvents(): """ Retrieves all the events stored in the database.add() Returns: list: List containing the events stored in the table. Each event is a dictionary """ eHandler = EventHandler() all_events = eHandler.getAllEvents() return all_events
def get(self): """ Show all msg captions """ self.checkSession(self.request.headers.get('Cookie')) self.insertMenu() self.insertTemplate('tpl_events_menu.html') self.insertContent("<h1>Вы создали события:</h1><br>") self.event = db.GqlQuery( "SELECT * FROM DBEvent where userid = :userid", userid=self.Session['userid'], today=db.datetime.date.today()) EventHandler.get(self) self.drawPage()
def run(self): self.init_models() self.init_state_machine() self.init_controllers() self.event_handler = EventHandler(name='EventHandler', native_mode=self.native_mode) self.event_handler.initialize(self, self.controllers['idle']) self.event_handler.start() while True: # logging.debug('MainApp.run: state - {}'.format(self.state_machine.state)) time.sleep(1) self.send_time_signal()
def __init__(self, piece_name = None): self.playing = True self.paused = False self.game_over = False self.running = True self.player = Piece(piece_name, list(PIECE_STAGE_STARTING_POSITION)) self.player.offset_piece() self.next_piece = Piece() self.score = Score() self.bottom_pieces = BottomPieces(self) self.draw = DrawGame(self) self.event_handler = EventHandler(self) self.lower_piece_data = {n:int(48 - 2.4 * n) for n in range(21)} # TODO: explain
def __init__(self): super(self.__class__, self).__init__() self.setupUi(self) self.setFixedSize(self.width(), self.height()) self.activeMenu = -1 # current active menu page number self.log = logging.getLogger('GUI') self.lamps = {} self.heater = None self.icons = { 'heat': QIcon(':i_heat.png'), 'cold': QIcon(':i_cold.png'), } link.addCommand("TER_READ", config_ex.getJson) self.linkThread = link.LinkThread() self.linkThread.start() config_ex.configWorkerInit(self.reinitButtons) if config_ex.isInitialized() == True: config_ex.initDevices() self.initButtons(config_ex.getButtonsConfig()) self.log.info("Device is initialized!") else: self.log.warning("Device NOT initialized!") self.showInitScreen() return self.menu = [self.btnManual, self.btnAuto, self.btnDiag] self.menu[0].clicked.connect(lambda: self.displayView(0)) self.menu[1].clicked.connect(lambda: self.displayView(1)) self.menu[2].clicked.connect(lambda: self.displayView(2)) self.displayView(0) self.initStyles() self.guiClicker = gui_clicker.GuiClicker() self.guiClicker.setUpdateSignal(self.updateButtonStyle) self.guiClicker.start() self.diagThread = DiagThread() self.diagThread.update.connect(self.updateDiagPage) self.diagThread.start() self.evt = EventHandler(config_ex.loadData(), self.guiClicker, self.diagThread) self.evt.start() if config.getPlatform() == 'rpi': self.showFullScreen()
def start(self): self.event_handler = EventHandler(self) self.event_handler.register_callback( self.context.send_with_norm_policy_and_repo) job_generator = JobGenerator(self) try: joblet = gevent.spawn_link_exception(job_generator.job_updater) eventlet = gevent.spawn_link_exception( self.event_handler.event_queue_handler) gevent.joinall([joblet, eventlet]) except gevent.GreenletExit, err: logging.warn(err)
def run_game(): """main game function""" # Initialize game and create a screen object. pygame.init() screen = pygame.display.set_mode((1200, 800)) pygame.display.set_caption("Sidescroller") screen_rect = screen.get_rect() #Initialize settings settings = Settings() # Screen handles H = screen_rect.height W = screen_rect.width HH = H / 2 HW = W / 2 # Initialize entity manager ent_manager = EntityManager(screen) # Initialize stars sky = Sky(screen, ent_manager, 10) sky.makeStars(speed=0) # Load main character COLS, ROWS, CELL, HANDLE = 2, 4, 5, 4 player1 = PlayerEntity(screen, 60, HH, "sprites/rocket_ship4x2.png", COLS, ROWS, CELL, HANDLE, -90) ent_manager.add_entity(player1) # Initialize event handler event_handler = EventHandler(player1, ent_manager, screen) # Start the main loop for the game. while True: """main game-loop""" # Watch for keyboard and mouse events. event_handler.check_events() # Redraw background screen.fill(settings.bg_color) ent_manager.update_entities() ent_manager.draw_entities() # Make the most recently drawn screen visible. pygame.display.flip()
def __init__(self, *args, **kw): super(Gui, self).__init__(*args, **kw) self.Center() self.SetMinSize(self.GetSize()) self.SetBackgroundColour(colour=wx.WHITE) self.scrolled_panel = scrolled.ScrolledPanel(self, -1, size=(914, 650), pos=(420, 0), style=wx.SUNKEN_BORDER) self.scrolled_panel.SetBackgroundColour(wx.WHITE) self.bitmap = wx.StaticBitmap(parent=self.scrolled_panel) self.text_area = wx.TextCtrl(self, -1, style=wx.TE_MULTILINE | wx.BORDER_SUNKEN | wx.TE_READONLY | wx.TE_RICH2) self.text_area.SetSize((400, 600)) self.text_area.SetFont(wx.Font(13, wx.DEFAULT, wx.NORMAL, wx.NORMAL)) self.text_area.AppendText("Nothing have done yet!" + "\n\n") self.text_area.SetToolTip('Saída') self.factor = 1 self.evt = EventHandler(self) # main sizer mainSizer = wx.GridSizer(1, 2, 1, 1) mainSizer.Add(self.text_area, 0, wx.EXPAND) mainSizer.Add(self.scrolled_panel, 0, wx.EXPAND) # finally give the sizer to the frame self.SetSizer(mainSizer) self.Layout()
def event_controller(event): try: handler = EventHandler(event) handler.apply() return None except ItemRanShort as e: """ AWS Stepfunctionsの場合、CustomErrorをraiseする raise e または AWS AppSyncなどでErrorをpublish()するなど """ publish(event) return None except Exception as e: logger.exception('Event Save Exception: {}'.format(e)) raise e
def getEventsByFilter(query_parameters): """ Retrieves all the events matching the specified filters for the 'date', 'eventType' and 'eventTitle' parameters. Args: query_parameters (dict): Dictionary containing the filter specifications. Only the keys 'date', 'eventType' and 'eventTitle' will be processed. Returns: list: List of containing the events stored in the table. Each event is a dictionary """ eHandler = EventHandler() events = eHandler.getEventByFilter(query_parameters) return events
def event_handler(): user_network = UserNetwork() user_network.follow(b'1', b'2') user_network.follow(b'1', b'4') return EventHandler({ b'1': Mock(), b'2': Mock(), b'3': Mock() }, user_network)
def run(self): """ Begin the simulation of a MMCC system. Process the information until termination criteria is meet. """ # Initialise the beginning parameters of the simulation servers = Servers(self.total_servers) # Set up server handler self.event_handler = EventHandler() # Set up the event handler start_event = Event("arrival", 0) # Construct the first event object start_event.departure_time -= start_event.arrival_time # Reset times start_event.arrival_time = 0 # Reset times self.event_handler.add(start_event) # Create the first event # Begin iteration of events, record arrivals for checking self.count_arrival = 0 while self.count_arrival < self.total_arrival: # Collect next event from the event handler current_event = self.event_handler.next() # Update simulation time self.sim_time = current_event.time() if current_event.type == "arrival": # Create new arrival event self.event_handler.add(Event('arrival', current_event.time())) # Record number of arrivals self.count_arrival += 1 # Check if any server is available if not servers.is_free(): self.event_handler.block(current_event) continue # Begin serving the client. current_event.served_by(servers.allocate()) # All event handler to manage departure self.event_handler.add(current_event) else: # Departure event received servers.deallocate(current_event.served_by()) self.event_handler.depart(current_event)
def run_game(): """main game function""" # Initialize game and create a screen object. pygame.init() screen = pygame.display.set_mode((1200, 800)) pygame.display.set_caption("Sidescroller") screen_rect = screen.get_rect() #Initialize settings settings = Settings() # Screen handles H = screen_rect.height W = screen_rect.width HH = H / 2 HW = W / 2 # Initialize entity manager ent_manager = EntityManager(screen) # Initialize event handler event_handler = EventHandler(ent_manager, screen) # create raindrops and add them to entity manager to be drawn drops = grid_of_drops(screen, 2) for drop in drops: ent_manager.add_entity(drop) # Start the main loop for the game. while True: """main game-loop""" # Watch for keyboard and mouse events. event_handler.check_events() # Redraw background screen.fill(settings.bg_color) ent_manager.update_entities() ent_manager.draw_entities() # Make the most recently drawn screen visible. pygame.display.flip()
def main(): initialize() eventHandler = EventHandler() frameRateHandler = FrameRateHandler(60) meshDict = loadMeshes() backColor = Color(0, 0, 0) mainSurface = pygame.display.set_mode((1280, 720)) objectHandler = ObjectHandler(eventHandler, frameRateHandler, mainSurface, meshDict) interfaceHandler = InterfaceHandler(objectHandler) tankMesh = RawMesh([ ("body", [(8, 0), (40, 0), (48, 8), (48, 40), (40, 48), (8, 48), (0, 40), (0, 8)]), ("gun", [(0, 0), (45, 0), (45, 10), (0, 10)], (5, 5)) ]) playerMesh = Mesh(tankMesh, (0, 0)) while True: frameRateHandler.updateStart() eventHandler.update() if eventHandler.quit or eventHandler.keys.release[K_ESCAPE]: break objectHandler.update() mainSurface.fill(backColor) objectHandler.draw() interfaceHandler.draw() pygame.display.flip() frameRateHandler.updateEnd()
def __init__(self, device=0, bus=0, interval=0.5, loop_flag=1): self.event_handler = EventHandler() if isinstance(interval, int): self.loop_interval = interval elif isinstance(interval, float): self.loop_interval = interval else: print(interval, 'is not suppoerted. Please give an integer or float interval value.') if loop_flag == True or loop_flag == False: self.loop_flag = loop_flag else: print(loop_flag, 'is not suppoerted. Please give a False(0) or True(1).') super().__init__(self, device, bus)
def __init__(self, address=None, bus=1, interval=0.5, loop_flag=1): assert address is not None, 'Please select address.' self.event_handler = EventHandler() if isinstance(interval, int): self.loop_interval = interval elif isinstance(interval, float): self.loop_interval = interval else: print(interval, 'is not suppoerted. Please give an integer or float interval value.') if loop_flag == True or loop_flag == False: self.loop_flag = loop_flag else: print(loop_flag, 'is not suppoerted. Please give a False(0) or True(1).') super().__init__(self, address, bus)
def __init__(self, path, box): self.path = path self.box = box self.observer = Observer() self.observer.schedule(EventHandler(self.box), path=self.path, recursive=True) self.observer.start() print('>>> Watcher :: Watching', self.path) try: while True: time.sleep(1) except KeyboardInterrupt: self.observer.stop() self.observer.join()
class EventSpiSensor(SpiSensorConf, EventDrivenIo, SensorException): """This class is for the event driven sensors""" def __init__(self, device=0, bus=0): super().__init__(device, bus) self.event_handlers = EventHandler() def add_event_handler(self, event, handler): # This method is for add event handler. # eventを指定して、そのイベントにメソッドを追加する self.event_handlers.add(event, handler) def run(self): self.sensor_thread = threading.Thread(target=self.sensor_method, args()) def sensor_thread(self, user_method): while True: # ポーリングで特定のレジスタを読んでくる # センサーで読み取ってくる値 = イベントの値 # ここでの問題は計算式に入れる前の値をセンサーはとってくるので、イベントをしっかり設定する必要あり assert read_method is not None, 'Please gave sensing method.' self.sensor_value = sensor_method() # ユーザ定義のセンシングメソッドを実行 if self.sensor_value in self.event_handlers.events.keys(): # keyの中に取得してきた値があれば、そのキーに対応したメソッドをよぶ self.event_handlers(self.sensor_value) else: # それ以外の場合otherをキーとするメソッドを呼ぶ self.event_handlers('other') def read(self, addr, byte=1): return self.spi.readByte(addr, byte) def write(self, addr, byte=1, values, mode='byte'): if mode == 'byte': self.spi.writeBytes(addr, values) elif mode == 'xfer' return self.xfer2(values) def remove_event_handler(self, event): self.event_handlers.remove() def user_method(self): # 値を取得するセンシングメソッドを記述 pass def exception_method(self): self.event_handlers.remove() self.spi.close()
def main(): config = Config() parser = argparse.ArgumentParser() parser.add_argument('-td', '--test-dataset', help='Walk through dataset \ and test while preprocessing', action='store_true') parser.add_argument('-e', '--execute', help='Execute', action='store_true') parser.add_argument('-t', '--train', help='Train Model', action='store_true') parser.add_argument('-wp', '--word-parser', help='Listen to microphone parse the word', action='store_true') parser.add_argument('-p', '--predict', help='Predict Audiofile', nargs='+') args = parser.parse_args() if args.test_dataset: datahandler = DataHandler() print("Test Passed") return if args.execute: from event_handler import EventHandler eh = EventHandler() word_parser(eh) if args.train: model = Model() model.train() if args.predict: model = Model() datahandler = DataHandler(noActualLoad=True) result_prob = model.predict(args.predict, datahandler.getClasses()) for fname, rp in zip(args.predict, result_prob): print("%s\t%s\twith Probabity %f" % (fname, rp[0], rp[1])) if args.word_parser: word_parser()
def __init__(self, event, jenkins_master , config='config.yaml'): EventHandler.__init__(self, event) self.log.debug('Initialize JenkinsSlackHandler') self.config = yaml.load(open(config).read())['jenkins-flow-analyzer'] self.jenkins_master = jenkins_master
print("") # Load the configuration from the YAML file... Configuration.load_configuration("hb-downloader-settings.yaml") Configuration.parse_command_line() Configuration.dump_configuration() Configuration.push_configuration() validation_status, message = Configuration.validate_configuration() if not validation_status: logger.display_message(False, "Error", message) exit("Invalid configuration. Please check your command line arguments and" "hb-downloader-settings.yaml.") # Initialize the event handlers. EventHandler.initialize() hapi = HumbleApi(ConfigData.auth_sess_cookie) if not hapi.check_login(): exit("Login to humblebundle.com failed." " Please verify your authentication cookie") logger.display_message(False, "Processing", "Downloading order list.") game_keys = hapi.get_gamekeys() logger.display_message(False, "Processing", "%s orders found." % (len(game_keys))) if ConfigData.action == "download": Action.batch_download(hapi, game_keys) else:
def run_game(): # Initialize pygame, settings, and screen object. pygame.mixer.pre_init(44100, -16, 2, 2048) pygame.mixer.init() pygame.init() clock = pygame.time.Clock() clock.tick(60) ai_settings = Settings() screen = pygame.display.set_mode( (ai_settings.screen_width, ai_settings.screen_height)) pygame.display.set_caption("Alien Invader") # Import sprite sheet sprite_sheet = SpriteSheet(file_name='images/spritesheet.png') # Make the Play and Scores button. play_button = Button(screen=screen, msg="Play", order=0) score_button = Button(screen=screen, msg="High Scores", order=1) # Open high score file try: high_score_file = open("high_score_file.txt", "r+") except FileNotFoundError: high_score_file = open("high_score_file.txt", "w+") # Make sound manager sounds = Sounds() # Create an instance to store game statistics and create a scoreboard. stats = GameStats(ai_settings=ai_settings) sb = Scoreboard(ai_settings=ai_settings, screen=screen, stats=stats, sprite_sheet=sprite_sheet, high_score_file=high_score_file) # Make the game objects. ship = Ship(ai_settings=ai_settings, screen=screen, sprite_sheet=sprite_sheet, stats=stats, sb=sb, sounds=sounds) explosions = Group() barriers = [] fleet = Fleet(ai_settings=ai_settings, screen=screen, sprite_sheet=sprite_sheet, sounds=sounds) bullets = Bullets(ai_settings=ai_settings, screen=screen, sprite_sheet=sprite_sheet, stats=stats, sb=sb, ship=ship, fleet=fleet, barriers=barriers, explosions=explosions, sounds=sounds) # Make the event handler event_handler = EventHandler(ai_settings=ai_settings, play_button=play_button, score_button=score_button, stats=stats, sb=sb, ship=ship, bullets=bullets, fleet=fleet, sounds=sounds) # Make the display manager display = Display(ai_settings=ai_settings, screen=screen, sprite_sheet=sprite_sheet, play_button=play_button, score_button=score_button, stats=stats, sb=sb, ship=ship, bullets=bullets, fleet=fleet, barriers=barriers, explosions=explosions, event_handler=event_handler) # Start the main loop for the game. while True: event_handler.check_events(display=display) if stats.game_active: ship.update() bullets.update_bullets(display=display) fleet.update_aliens(ship=ship, display=display, bullets=bullets) fleet.update_ufos() display.update_screen()
def __init__(self): self.event_handler = EventHandler()
class EventComposer(object): # Metadata # Test issue.getInfo params_issue_get_info = {"apiCall": "issue.getInfo", "in_params": (("issueID",'184671',),) } # Test issue.getOpen params_issue_get_open = {"apiCall": "issue.getOpen", "in_params": (("productID", "solid",),) } # Test issue.getAllForProduct params_issue_get_all_for_product = {"apiCall": "issue.getAllForProduct", "in_params": (("productID", "solid",), ("fromDate", "2012-03-16 12:00",),) } # Test issue.getAllForMethod params_issue_get_all_for_method = {"apiCall": "issue.getAllForMethod", "in_params": (("methodUri", "http://www.alert-project.eu/ontologies/alert.owl#Method1", "http://www.alert-project.eu/ontologies/alert.owl#Method10",),) } # Test commit.getAllForProduct params_commit_get_all_for_product = {"apiCall": "commit.getAllForProduct", "in_params": (("productID", "solid",), ("fromDate","2012-01-13 12:00",),) } # Test commit.getInfo params_commit_get_info = {"apiCall": "commit.getInfo", "in_params": (("commitUri", "http://www.alert-project.eu/ontologies/alert_scm.owl#Commit5",),) } # Test method.getAllForIdentity params_method_get_all_for_identity = {"apiCall": "method.getAllForIdentity", "in_params": (("uuid","ivano",),) } # Test developers recommendation header_devs_recomm = {'name': "ALERT.Search.Recommender."+\ "IdentitiesRecommendationRequest", 'id': 5478, 'type': "request", 'api': None } params_devs_recommend = {"issues": ( (291250,"owl#1"), (290735, "owl#2"),) } # Test issues recommendation header_issues_recomm = {'name': "ALERT.Search.Recommender."+\ "IssueRecommendationRequest", 'id': 5478, 'type': "request", 'api': None } params_issues_recommend = {"identities": ("ff9dc34d-774e-47ad-"+\ "9eab-07c46ab3e765", "ff0df1c4-4c8d-4703-97ea-267d83b4ac08",) } # Test KEUI similar threads params_similar_threads = {"type": "similarThreads", "threadId": -1, "bugId": 55, "count": 50, "itemDataSnipLen" : 200, "includeItemIds": "True", "includeItemData": "True", "includeOnlyFirstInThread": "True", "maxCount": 50, "offset": 0, "includePeopleData" : "True" } params_issues_for_keywords = {'keywords': ('solid',), "offset": 0, "maxCount": 100, 'resultData': 'itemData', "includeAttachments": 1, 'sortBy': 'dateDesc', 'itemDataSnipLen': 200, 'snipMatchKeywords': 1, 'keywordMatchOffset': 25, 'includePeopleData':0 } topic_req_metadata = 'ALERT.Search.APICallRequest' topic_req_issues_recomm = 'ALERT.Search.Recommender.'+\ 'IssueRecommendationRequest' topic_req_devs_recomm = "ALERT.Search.Recommender."+\ "IdentitiesRecommendationRequest" topic_req_keui = "ALERT.Search.KEUIRequest" topic_res_keui = "ALERT.KEUI.Response" topic_res_metadata = "ALERT.Metadata.APICallResponse" topic_res_issues_recomm = "ALERT.Recommender.IssueRecommendation" topic_res_devs_recomm = "ALERT.Recommender.IdentityRecommendation" def __init__(self): self.event_handler = EventHandler() # SERIALIZATION TESTS def serial_recommendation(self, header, params, printed, message, topic_name): if printed: self._print_event(header,params) if message and topic_name is not None: #for index in range(1,11): #self._publish_event(header, params, topic_name) return self._get_event(header, params) def serial_metadata(self, header, params, printed, message, topic_name): if header is None: header = {'name': "ALERT.Search.APICallRequest", 'id': 5476, 'type': "request", 'api': 'apiRequest'} if printed: self._print_event(header,params) if message and topic_name is not None: #for index in range(1,11): #self._publish_event(header, params, topic_name) return self._get_event(header, params) def serial_keui(self, header, params, printed, message, topic_name): if header is None: if 'type' in params: header = {'name': "ALERT.Search.KEUIRequest", 'id': 5478, 'type': "request", 'api': "customQuery"} elif 'keywords' in params: header = {'name': "ALERT.Search.KEUIRequest", 'id': 5478, 'type': "request", 'api': "generalQuery"} if printed: self._print_event(header,params) if message and topic_name is not None: #for index in range(1,11): # self._publish_event(header, params, topic_name) return self._get_event(header, params) # DESERIALIZATION TESTS def deserial_recommendation(self, event_name, event): #res = [] self.event_handler.load_event(event) #if event_name == 'identity.Recommendation': #print "Deserializing socrates event: " #print "[" #for person in self.event_handler.entity: #print "(" + person.get_name() + "," #print person.get_user_id() + "), " #res.append((person.get_name(), person.get_user_id())) #print "]" #elif event_name == 'issue.Recommendation': #print self.event_handler.entity return self.event_handler.entity def deserial_metadata(self, event_name, event): print "line 0: deserial_metadata" # DELETEME self.event_handler.load_event(event) return self.event_handler.entity # Depending on the event type, response list will contain the # event name (first item in list) plus a tuple of dicts, with all # parameters from the response message payload # Uncomment the following lines for tracing #if event_name == 'issue.getInfo': #print "Issue ID is: " + self.event_handler.entity.get_issue_id() #print "Issue description: " +\ #self.event_handler.entity.get_description() #print "Reporter name is: " +\ #self.event_handler.entity.get_reporter().get_name() #print "Reporter email is: " +\ #self.event_handler.entity.get_reporter().get_email() #print "Reporter id is: " +\ #self.event_handler.entity.get_reporter().get_user_id() #print "Assignee name is: " +\ #self.event_handler.entity.get_assigned_to().get_name() #print "Assignee email is: " +\ #self.event_handler.entity.get_assigned_to().get_email() #print "Assignee id is: " +\ #self.event_handler.entity.get_assigned_to().get_user_id() #print "Issue URL: " + self.event_handler.entity.get_issue_url() #elif event_name == 'issue.getOpen': #for item in self.event_handler.entity: #print "Issue Id: " + item.get_issue_id() #print "Issue desc: " + item.get_description() #print "Issue URL: " + item.get_issue_url() #elif event_name == 'issue.getAllForProduct': #for item in self.event_handler.entity: #print "Issue Id: " + item.get_issue_id() #print "Issue desc: " + item.get_description() #print "Issue URL: " + item.get_issue_url() #elif event_name == 'commit.getAllForProduct': #for commit in self.event_handler.entity: #print "Commit message: " + commit.get_commitMessage() +\ #" with date: " + commit.get_commitDate() #def deserial_metadata(self, event_name, message): #pass def deserial_keui(self, event_name, event): self.event_handler.load_event(event) # For similarThreads return list of tuples # (threads, similarity coef. and item ids) # For issuesForKeywords list of dicts # each dict carry issue info return self.event_handler.entity # UTILITY METHODS def send_recv_metadata(self, bus_url, params): """ Routine to interact with Metadata service via ActiveMQ bus """ get_info_msg = self.serial_metadata(None, params, False, True, self.topic_req_metadata) #Uncomment to trace #print get_info_msg bquery = BusQuery(bus_url, self.topic_req_metadata, get_info_msg, self.topic_res_metadata) result = bquery.run() return result def send_recv_recommender(self, bus_url, params, option): """ Routine to interact with Recommendation service via ActiveMQ bus option == 'devs' : recommend developers to solve an issue option == 'issues' : recommend issues to a developer """ if option == 'devs': header = self.header_devs_recomm topic_req = self.topic_req_devs_recomm topic_res = self.topic_res_devs_recomm elif option == 'issues': header = self.header_issues_recomm topic_req = self.topic_res_issues_recomm topic_res = self.topic_req_issues_recomm get_info_msg = self.serial_recommendation(header, params, False, True, topic_req) #Uncomment to trace #print get_info_msg bquery = BusQuery(bus_url, topic_req, get_info_msg, topic_res) result = bquery.run() return result def send_recv_keui(self, bus_url, params): """ Routine to interact with KEUI via ActiveMQ """ get_info_msg = self.serial_keui(None, params, False, True, self.topic_req_keui) #Uncomment to trace #print get_info_msg bquery = BusQuery(bus_url, self.topic_req_keui, get_info_msg, self.topic_res_keui) result = bquery.run() return result def _publish_event(self, header, params, topic_name): # pub = EventPublisher(topic_name) # pub.publishMessage(etree.tostring( # self.event_handler.serialize_event( # header['name'], header['id'], # header['type'], header['api'], # params), # pretty_print = True)) #pub.finish() pass def _print_event(self, header, params): print etree.tostring(self.event_handler.serialize_event( header['name'], header['id'], header['type'], header['api'], params), pretty_print = True) def _get_event(self, header, params): return etree.tostring(self.event_handler.serialize_event( header['name'], header['id'], header['type'], header['api'], params), pretty_print = True)
def main(): device = InputDevice('/dev/input/event0') handler = EventHandler() for event in device.read_loop(): handler.handle(event)
# Seed random random.seed() # Initialize PyGame pygame.init() pygame.display.set_caption('Ants') # Initialize screen size = (700, 700) surface = pygame.display.set_mode(size) # Initialize simulation with the surface and grid size sim = Simulation(surface, 75) # Initialize event handler e_handler = EventHandler() # Define colors WHITE = (255, 255, 255) BLACK = ( 0, 0, 0) # Used to manage how fast the screen updates clock = pygame.time.Clock() while sim.is_running: # print(frame_count) # Main event loop for event in pygame.event.get(): e_handler.process_event(sim, event)