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 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 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()
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 snapshot_controller(event):
try:
handler = EventHandler(event)
handler.update()
return
except Exception as e:
logger.exception('Event Save Exception: {}'.format(e))
raise e
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 main():
handler = EventHandler()
handler.add_threaded_function(gsheets_listener)
handler.add_threaded_function(timer_listener)
handler.register_action(GSheetsEvent, printer1)
handler.register_action(TimerEvent, printer1)
handler.register_action(TimerEvent, printer2)
handler.start(modules_conf_filepath, user_conf_filepath, max_workers=3)
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 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 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 __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 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, 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()
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 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 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():
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 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 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, canvas, starting_level):
self.canvas = canvas
self.clock = pygame.time.Clock()
self.images = self.load_images()
self.help_image = pygame.image.load(os.path.join('images', 'help.png'))
self.event_handler = EventHandler(self)
self.boids_need_food = False
self.state = enums.GameState.READ_INTRO
self.font = pygame.font.Font(os.path.join('fonts', 'Acme-Regular.ttf'),
Settings.font_size)
lines = """Your butterfly will be affected by the others around it and vice versa
But you do have some control over it. And, as the leader, you have the most influence
Left and right arrow keys to steer your butterfly
Up and down arrows keys to go faster and slower
Space bar to reset speed to normal
You can move to the next level once you have fullfilled your mission
You, and only you, can also go back to the previous level
Don't worry if you fly off the screen - wait and you'll get back
"""
self.help_lines = [line.strip() for line in lines.split('\n')]
self.time_keeper = None
self.recent_buttons = {}
self.food_sources = []
self.active_forces = {
'Separation',
'Alignment',
'Cohesion',
'Boundaries',
'Attractor',
}
self.levels = [
levels.Level01(self),
levels.Level02(self),
levels.Level03(self),
levels.Level04(self),
levels.Level05(self),
]
# Start at level starting_level - 1
# Zero index the level first
starting_level -= 1
self.level = self.levels[starting_level]
if starting_level > 0:
# Move the flock to the starting level
for boid in self.levels[0].flock.boids:
self.level.flock.boids.append(boid)
boid.flock = self.level.flock
self.levels[0].flock.boids = []
leader = self.levels[0].flock.leader
self.levels[0].flock.leader = None
self.level.flock.leader = leader
for level in self.levels[:starting_level + 1]:
level.leader_enters()
self.buttons = {
'ok': Button(self, 'ok', pygame.Vector2(1723, 915)),
'help': Button(self, 'help', pygame.Vector2(1723, 915)),
'pause': Button(self, 'pause', pygame.Vector2(1655, 915)),
'play': Button(self, 'play', pygame.Vector2(1655, 915)),
}
for name in 'help', 'pause', 'play':
self.buttons[name].visible = False
# In[20]:
print(root_directory)
paths = {
'user_id': user_id,
'workspace_directory': root_directory + '/workspaces',
'resource_directory': root_directory + '/resources',
'log_directory': 'D:/github' + '/log',
'test_data_directory': 'D:/github' + '/test_data',
'cache_directory': 'D:/github/w_vattenstatus/cache'
}
# In[21]:
t0 = time.time()
ekos = EventHandler(**paths)
print('-' * 50)
print('Time for request: {}'.format(time.time() - t0))
# ### Load existing workspace
# In[22]:
workspace_alias = 'kustzon_SE1'
ekos.print_workspaces()
# In[23]:
workspace_uuid = ekos.get_unique_id_for_alias(workspace_alias=workspace_alias)
print(workspace_uuid)
import asyncio
import json
import _thread
# from pprint import pprint
import configparser
from mattermostdriver import Driver
from event_handler import EventHandler
from question_handler import QuestionHandler
from queryDB import queryDB
from init import get_driver
config = configparser.ConfigParser()
config.read('config.ini')
event_handler = EventHandler()
question_handler = QuestionHandler()
class Listener:
def __init__(self, bot_name):
self.bot_name = bot_name
self.DIRECT_CHANNEL = "D"
self.EVENT_POSTED = "posted"
self.QUESTIONS_CHANNEL = "questions"
@asyncio.coroutine
def my_event_handler(self, message):
message = json.loads(message)
# pprint(message)
if 'event' in message.keys() and message['event'] == self.EVENT_POSTED:
# print(message)
def __init__(self, channel, pin_mode='BCM'):
super().__init__(channel, pin_mode)
self.event_handler = EventHandler()
# -*- coding: utf-8 -*-
from event_handler import EventHandler
def test1(earg=None):
print('test1')
def test2(earg=None):
print('test2')
evt = EventHandler()
evt.add_event_handler('str', test1)
