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)
