def __init__(self, map_screen, background_screen, text_screen):
"""
Constructor.
:param map_screen: Surface
:param background_screen: Surface
:param text_screen: Surface
"""
self.amount_of_enemies = 0
self.amount_of_empty_colonies = 0
self.map_to_load = None
self.race_manager = RaceManager()
self.human_players = []
self.players = []
self.map = Map(GUISettings.SCREEN_WIDTH, GUISettings.SCREEN_HEIGHT)
self.event_handler = EventHandler(self)
self.screen = map_screen
self.background_screen = background_screen
self.player_one = Player()
self.human_players.append(self.player_one)
self.sound_driver = SoundDriver()
self.map_loader = MapLoader(self)
self.text_screen = text_screen
self.running = True
self.map_manager = MapManager()
self.state = MainMenu(self)
self.menu = MenuSettings.MAIN_MENU(self)
def main():
logging.basicConfig(stream=sys.stderr, level=logging.DEBUG)
current_dir = os.path.dirname(__file__)
config = dict()
config_path = os.path.join(current_dir, "config.yml")
with open(config_path, "r") as stream:
config = yaml.safe_load(stream)
profiles_dir = os.path.join(current_dir, config['profiles_folder'])
file_map = {
pygame.K_KP0: 0,
pygame.K_KP1: 1,
pygame.K_KP2: 2,
pygame.K_KP3: 3,
pygame.K_KP4: 4,
pygame.K_KP5: 5,
pygame.K_KP6: 6,
pygame.K_KP7: 7,
pygame.K_KP8: 8,
pygame.K_KP9: 9,
}
soundboard = Soundboard(profiles_dir)
event_handler = EventHandler(soundboard, file_map)
while True:
event_handler.handle(pygame.event.get())
def test_3_on_noEventAddCallback(self):
def test_callback_1(sender, obj):
print("test_callback_1")
self.assertIsNone(EventHandler.on("test_emit_2", test_callback_1))
self.assertEqual(len(EventHandler.getEvents()), 2)
self.assertListEqual(["test_emit_1", "test_emit_2"], EventHandler.getEvents() )
self.assertEqual(EventHandler.getCallbackFuncs(EventHandler.getEvents()[1])[0].__name__ , "test_callback_1")
def __init__(self):
self.controller = Controller()
self.Handler = EventHandler(self.controller)
self.object_list = []
self.game_logic = GameLogic()
self.fps_clock = pygame.time.Clock()
self.fps = 60
self.neuralnet = NeuralNetHolder()
self.version = "v1.01"
def __init__(self, window, game):
self.window = window
self.game = game
self.screen = window.screen
self.state = GameState.MAIN_MENU
self.eventHandler = EventHandler(self.game)
self.objectHandler = ObjectHandler()
self.mapHandler = MapHandler(self.window)
self.loadMenu()
def __init__(self):
self.graph = DAG.DAG()
self.MiscVals = {
'Name': '',
'PlayerName': '',
'Profession': '',
'Level': 0,
'Experience': 0
}
self.Events = EventHandler()
def _send_manual_notification(self, sessionKey, user, post_data):
logger.info("_send_manual_notification started", )
logger.debug("user: {}".format(user))
logger.debug("post_data: {}".format(post_data))
notification = {}
notifications = []
query = {}
query['incident_id'] = post_data.get('incident_id')
logger.debug("Filter: {}".format(json.dumps(query)))
uri = '/servicesNS/nobody/alert_manager/storage/collections/data/incidents?query={}'.format(
urllib.parse.quote(json.dumps(query)))
serverResponse, incident = rest.simpleRequest(uri,
sessionKey=sessionKey)
logger.debug("Settings for incident: {}".format(incident))
incidents = json.loads(incident)
notification['alert'] = incidents[0].get("alert")
notification['incident'] = post_data.get('incident_id')
notification['event'] = post_data.get('event')
notification_message = post_data.get('notification_message')
recipients = post_data.get('recipients')
recipients_overwrite = post_data.get('recipients_overwrite')
logger.debug("recipients_overwrite: {}".format(recipients_overwrite))
notifications.append(notification.copy())
ic = IncidentContext(sessionKey, notification['incident'])
context = ic.getContext()
context.update({'notification_message': notification_message})
context.update({'recipients': recipients})
context.update({'recipients_overwrite': recipients_overwrite})
logger.debug("Notification context: {}".format(json.dumps(context)))
eh = EventHandler(sessionKey=sessionKey)
eh.handleEvent(alert=notification['alert'],
event=notification['event'],
incident=incidents[0],
context=ic.getContext())
logger.info("_send_manual_notification stopped")
return self.response('Manual notification executed', http.client.OK)
def run(self, total_servers: int, total_arrival: int) -> None:
""" Begin the simulation of a MMCC system. Process the information until
termination criteria is meet.
Params:
- total_servers :: The number of servers that can handle clients at
any one instance.
- total_arrival :: The total number of clients that can be handled
within the simulation.
"""
# Initialise the beginning parameters of the simulation
self.servers = Servers(total_servers) # Set up server handler
self.events = EventHandler() # Set up the event handler
startingEvent = Event("arrival", 0) # Construct the first event object
startingEvent.departure_time -= startingEvent.arrival_time # Reset times
startingEvent.arrival_time = 0 # Reset times
self.events.add(startingEvent) # Create the first event
# Begin iteration of events, record arrivals for checking
self.num_arrival = 0
while (self.num_arrival < total_arrival):
# Collect next event from the event handler
currentEvent = self.events.next()
# Update simulation time
self.sim_time = currentEvent.time()
if currentEvent.type == "arrival":
# Arrival event received
self.num_arrival += 1 # Record number of arrivals
# Create new arrival event
self.events.add(Event("arrival", currentEvent.time()))
# Check if any server is available
if not self.servers.isFree():
self.events.block(
currentEvent) # Arriving client is blocked
continue
# Begin serving the client.
currentEvent.servedBy(self.servers.allocate())
# All event handler to manage departure
self.events.add(currentEvent)
else:
# Departure event received
self.servers.deallocate(
currentEvent.servedBy()) # Free the server
self.events.depart(currentEvent) # Record departure
def __init__(self, app):
super().__init__()
self.app = app
self.setupUi(self)
self.show()
self.current_dir = os.path.dirname(__file__)
self.current_mode = "Merge"
self.event_handler = EventHandler(self)
self.current_tool = Merger(self)
self.current_files = []
self.setupProgramm()
def __init__(self, screen):
self.screen = screen
self.bm = BlockManager()
self.im = ItemManager()
self.em = EffectManager()
self.mm = MobManager()
self.player = Player(self)
self.mobs = []
self.eh = EventHandler(self)
self.level = Level('ark.json', self.screen, self)
self.gui = None
pygame.mixer.music.load('assets/music/theme.mp3')
pygame.mixer.music.play(-1)
def __init__(self,
transp=None,
host=None,
port=None,
addResource=True,
createSock=True,
eventType=SE.SipEvent):
EventHandler.__init__(self)
self.sock = None
self.transp = None
self.ip = None
self.port = None
self.remoteip = None
self.remoteport = None
self.timeout = None
self.state = NetworkEventHandler.NEH_NO_SOCK
self.pkgsize = Config.MAX_PKG_SIZE
self.data = None
self.old_data = None
self.eventType = eventType
if transp is None:
transp = Config.DEFAULT_NETWORK_TRANSPORT
if (transp.lower() == "udp" or transp.lower() == "tcp"):
self.setTransport(transp)
else:
raise SCException("NetworkEventHandler", "__init__",
"unsupported transport type")
if host is None:
host = Config.LOCAL_IP
if port is None:
port = int(Config.LOCAL_PORT)
if host.startswith("["):
host = host[1:]
if host.endswith("]"):
host = host[:len(host) - 1]
self.localip = host
self.localport = port
# Because we can not return another NEH instance if a new instance for
# the same triplet (transport, ip, port) was requested, we simply
# close the existing NEH and the create a new one
key = str(getTransportNumber(transp)) + str(host) + str(port) + "00"
if addResource and Config.resources.has_key(
'NEH') and Config.resources['NEH'].has_key(key):
Log.logDebug(
"NetworkEventHandler.init(): closing NEH which uses the same address (key '"
+ key + "') to prevent bind error", 3)
Config.resources['NEH'][key].close()
if createSock:
self.createSock(transp, host, port)
if addResource:
Config.resources['NEH'][key] = self
def __init__(self):
''' This function calls parents class, initialize infoWindow, load main window UI,
and call the clickOnDate function in eventHandler to get today's event list upon opening the GUI
Args:
none
Returns:
none
'''
self.eventHandler = EventHandler(self)
super(CalendarApp, self).__init__()
self.infoDialog = InfoWindow()
self.load_ui()
self.eventHandler.clickOnDate()
def __init__(self, _filename=None, _fixLF=True, addResource=True):
"""If a filename is given as parameter that file will be opened
for reading. If the second parameter is True single line-feeds will
be replaced by carriage-return line-feed while reading in and writing
to a file.
"""
EventHandler.__init__(self)
self.filename = None
self.fileobj = None
self.fixLF = _fixLF
if _filename is not None:
self.filename = _filename
self.openFile("r")
if addResource:
Config.resources['FEH'][self.filename] = self
def generate_java(canvas):
jname = canvas.statusbar.getState(StatusBar.MODEL)[1][0]
if not jname or jname == "Nonamed":
jname = tkFileDialog.asksaveasfilename(filetypes=[("Java source code",
"*.java")])
else:
if StringUtil.endswith(jname, ".py"):
jname = jname[:len(jname) - 3] + ".java"
jname = os.path.split(jname)[1]
jname = tkFileDialog.asksaveasfilename(initialfile=jname,
filetypes=[("Java source code",
"*.java")],
initialdir=canvas.codeGenDir)
if jname:
if StringUtil.endswith(jname, ".java"):
mname = jname[:len(jname) - 5] + ".des"
else:
mname = jname + ".java"
desc = generate_description(canvas, 0)["desc"]
eventhandler = EventHandler(mname, modeltext=desc)
g = JavaGenerator(eventhandler)
code = g.generate_code()
# Save .java file
jf = open(jname, "w")
jf.write(code)
jf.close()
# Print on success
print "Java code saved to: " + jname
def check_import_mdl(self, path, s, states):
if states[IMPORT_STATE] != None:
keys = states.keys()
keys.sort()
for subs in keys:
if not subs in StateProperties:
print 'WARNING: Importation state has substate(s). This may cause unexpected error.'
break
filename = DynamicEvaluateExpression(states[IMPORT_STATE])
params = {}
keys = states[PARAMETERS].keys()
keys.sort()
for k in keys:
p = states[PARAMETERS][k]
b = DynamicEvaluateExpression(p[1])
params[k] = [p[0], b]
stnum = self.get_state_num(self.eventhandler.append_path(path, s))
if not self.compiled_files.has_key(filename):
eh = EventHandler(filename, None, params, 0, 0, [], [], 0,
None, self.eventhandler.options)
self.required_models.append(eh)
self.compiled_files[filename] = eh.options[MODEL_NAME]
self.submodels[stnum] = eh.options[MODEL_NAME]
else:
self.submodels[stnum] = self.compiled_files[filename]
def __init__(self, device, grabbed=False):
self.dev = evdev.InputDevice(device)
self.eventHandler = EventHandler()
if grabbed:
self.dev.grab() #takes exclusive control over the keyboard
asyncio.get_event_loop().create_task(
self.keyboardHandler()) #starts the keyboad handler loop
def run(self, server_number: int, arrival_total: int):
"""
Run simulation with specified parameters
:param server_number: Number of servers
:param arrival_total: Number of events
"""
# Initialise Servers and EventHandler
self.servers = Servers(server_number)
self.events = EventHandler()
# Create and add initial event
starting_event = Event("arrival", 0)
starting_event.departure_time -= starting_event.arrival_time
starting_event.arrival_time = 0
self.events.add(starting_event)
# Run simulation until number of events handled
self.arrival_number = 0
while (self.arrival_number < arrival_total):
# Iterate to next event and update simulation time
current_event = self.events.next()
self.simulation_time = current_event.time()
# If arrival, update counter and add to appropriate list
if current_event.event_type == "arrival":
self.arrival_number += 1
self.events.add(Event("arrival", current_event.time()))
# If no servers free, block event
if not self.servers.is_free():
self.events.block(current_event)
continue
# Assign server to event
current_event.served_by(self.servers.allocate())
self.events.add(current_event)
# If departure, free server and depart
else:
self.servers.deallocate(current_event.served_by())
self.events.depart(current_event)
class Game:
def __init__(self, screen):
self.screen = screen
self.bm = BlockManager()
self.im = ItemManager()
self.em = EffectManager()
self.mm = MobManager()
self.player = Player(self)
self.mobs = []
self.eh = EventHandler(self)
self.level = Level('ark.json', self.screen, self)
self.gui = None
pygame.mixer.music.load('assets/music/theme.mp3')
pygame.mixer.music.play(-1)
def update(self):
self.level.update()
self.player.update()
for mob in self.mobs:
mob.update()
self.eh.handle(None)
def step(self, direction=None):
if direction is not None:
self.player.step(direction)
for mob in self.mobs:
mob.step()
def open_gui(self, gui, callback=None):
if callback is not None:
self.gui = gui.set_callback(callback)
else:
self.gui = gui
def render(self):
self.level.render()
self.player.render()
if self.gui is not None:
self.gui.render()
for mob in self.mobs:
mob.render()
def send_event(self, event):
self.eh.handle(event)
def __init__(self, _filename=None, addResource=True):
"""If a filename is given as parameter that file will be opened
for reading. If the second parameter is True single line-feeds will
be replaced by carriage-return line-feed while reading in and writing
to a file.
"""
EventHandler.__init__(self)
self.filename = None
self.fileobj = None
self.framenr = 0
if _filename is not None:
self.filename = _filename
self.openFile(mode="w")
if addResource:
if self.filename.endswith('.xml'):
fn = self.filename[:len(self.filename)-4]
else:
fn = self.filename
Config.resources['XMLEH'][fn] = self
def __init__(self, _filename=None, addResource=True):
"""If a filename is given as parameter that file will be opened
for reading. If the second parameter is True single line-feeds will
be replaced by carriage-return line-feed while reading in and writing
to a file.
"""
EventHandler.__init__(self)
self.filename = None
self.fileobj = None
self.framenr = 0
if _filename is not None:
self.filename = _filename
self.openFile(mode="w")
if addResource:
if self.filename.endswith('.xml'):
fn = self.filename[:len(self.filename) - 4]
else:
fn = self.filename
Config.resources['XMLEH'][fn] = self
def __init__(self):
self.root = Tk()
self.setUpMenu()
self.canvas = self.setUpCanvas(self.root, 800, 800)
self.canvas.pack()
self.graph = DrawableGraph ()
self.eventHandler = EventHandler(self.canvas)
self.root.mainloop()
def __init__(self, transp=None, host=None, port=None, addResource=True, createSock=True, eventType=SE.SipEvent):
EventHandler.__init__(self)
self.sock = None
self.transp = None
self.ip = None
self.port = None
self.remoteip = None
self.remoteport = None
self.timeout = None
self.state = NetworkEventHandler.NEH_NO_SOCK
self.pkgsize = Config.MAX_PKG_SIZE
self.data = None
self.old_data = None
self.eventType = eventType
if transp is None:
transp = Config.DEFAULT_NETWORK_TRANSPORT
if (transp.lower() == "udp" or transp.lower() == "tcp"):
self.setTransport(transp)
else:
raise SCException("NetworkEventHandler", "__init__", "unsupported transport type")
if host is None:
host = Config.LOCAL_IP
if port is None:
port = int(Config.LOCAL_PORT)
if host.startswith("["):
host = host[1:]
if host.endswith("]"):
host = host[:len(host)-1]
self.localip = host
self.localport = port
# Because we can not return another NEH instance if a new instance for
# the same triplet (transport, ip, port) was requested, we simply
# close the existing NEH and the create a new one
key = str(getTransportNumber(transp)) + str(host) + str(port) + "00"
if addResource and Config.resources.has_key('NEH') and Config.resources['NEH'].has_key(key):
Log.logDebug("NetworkEventHandler.init(): closing NEH which uses the same address (key '" + key + "') to prevent bind error", 3)
Config.resources['NEH'][key].close()
if createSock:
self.createSock(transp, host, port)
if addResource:
Config.resources['NEH'][key] = self
def simulate(canvas):
global theCanvas
theCanvas = canvas
mname = canvas.statusbar.getState(StatusBar.MODEL)[1][0]
if not mname:
mname = "Nonamed.des"
else:
if mname.endswith(".py"):
mname = mname[:len(mname) - 3]
mname = mname + ".des"
global sc
sc = generate_description(canvas, 0)
global debugger
debugger = Debugger()
global eventhandler
eventhandler = EventHandler(mname,
callback=debugger.EventDebugger,
use_gui=1,
modeltext=sc["desc"])
eventhandler.final.append("SVMAToM3Plugin.finalize_simulation()")
debugger.CustomizeEvent(event_callback, None, 1)
global root
root = canvas.ASGroot.listNodes
DefaultInterpreter.runsource("eventhandler=SVMAToM3Plugin.eventhandler")
DefaultInterpreter.runsource("debugger=SVMAToM3Plugin.debugger")
debugger.SetEventHandler(eventhandler)
eventhandler.run_initializer()
highlight_states(eventhandler.state, sc)
highlight_trans(eventhandler, sc, root)
# Cannot start the Tk mainloop again
# eventhandler.run_interactor()
DefaultInterpreter.runsource(
"setup_gui_debugger(eventhandler, debugger, 0, 0)")
class Application:
sorter = None
def __init__(self, window):
pygame.init()
self.window = window
self.event_handler = EventHandler()
self.renderer = Renderer(window)
self.data = Data(10, 300, 64)
self.buttons = [
RandomizeButton(BLACK, 25, 25, 125, 25, 'Randomize Data', WHITE,
self.data),
SorterButton(BLACK, 175, 25, 125, 25, 'Bubble Sort', WHITE,
BubbleSorter(self.renderer), self.data),
SorterButton(BLACK, 325, 25, 125, 25, 'Selection Sort', WHITE,
SelectionSorter(self.renderer), self.data),
SorterButton(BLACK, 475, 25, 125, 25, 'Insertion Sort', WHITE,
InsertionSorter(self.renderer), self.data),
SorterButton(BLACK, 625, 25, 125, 25, 'Merge Sort', WHITE,
MergeSorter(self.renderer), self.data),
SorterButton(BLACK, 775, 25, 125, 25, 'Quick Sort', WHITE,
QuickSorter(self.renderer), self.data)
]
self.event_handler.register_buttons(self.buttons)
self.renderer.register_buttons(self.buttons)
self.renderer.register_data(self.data)
def run(self):
while 1:
# check if any new events have occured
self.event_handler.handle_events()
# render window
self.renderer.refresh()
self.renderer.render_buttons()
self.renderer.render_data()
# update display
pygame.display.update()
def _update_incident(self, sessionKey, user, post_data):
logger.debug("START _update_incident()")
required = ['incident_data']
missing = [r for r in required if r not in post_data]
if missing:
return self.response(
"Missing required arguments: {}".format(missing),
http.client.BAD_REQUEST)
incident_data = post_data.pop('incident_data')
splunk.setDefault('sessionKey', sessionKey)
eh = EventHandler(sessionKey=sessionKey)
config = {}
config['index'] = 'main'
restconfig = entity.getEntities('configs/alert_manager',
count=-1,
sessionKey=sessionKey)
if len(restconfig) > 0:
if 'index' in restconfig['settings']:
config['index'] = restconfig['settings']['index']
logger.debug("Global settings: {}".format(config))
# Parse the JSON
incident_data = json.loads(incident_data)
# Select between updating multiple incidents (replace full document) and updating single incidents (attribute update)
if 'incident_ids' in incident_data and len(
incident_data['incident_ids']) > 1:
logger.info("do_update_incidents")
self._do_update_incidents(sessionKey, config, eh, incident_data,
user)
elif 'incident_ids' in incident_data and len(
incident_data['incident_ids']) == 1:
logger.info("do_update_incident")
self._do_update_incident(sessionKey, config, eh,
incident_data['incident_ids'][0],
incident_data, user)
else:
logger.info("do_update_incident")
self._do_update_incident(sessionKey, config, eh,
incident_data['incident_id'],
incident_data, user)
return self.response('Successfully updated incident(s).',
http.client.OK)
def __init__(self, window):
pygame.init()
self.window = window
self.event_handler = EventHandler()
self.renderer = Renderer(window)
self.data = Data(10, 300, 64)
self.buttons = [
RandomizeButton(BLACK, 25, 25, 125, 25, 'Randomize Data', WHITE,
self.data),
SorterButton(BLACK, 175, 25, 125, 25, 'Bubble Sort', WHITE,
BubbleSorter(self.renderer), self.data),
SorterButton(BLACK, 325, 25, 125, 25, 'Selection Sort', WHITE,
SelectionSorter(self.renderer), self.data),
SorterButton(BLACK, 475, 25, 125, 25, 'Insertion Sort', WHITE,
InsertionSorter(self.renderer), self.data),
SorterButton(BLACK, 625, 25, 125, 25, 'Merge Sort', WHITE,
MergeSorter(self.renderer), self.data),
SorterButton(BLACK, 775, 25, 125, 25, 'Quick Sort', WHITE,
QuickSorter(self.renderer), self.data)
]
self.event_handler.register_buttons(self.buttons)
self.renderer.register_buttons(self.buttons)
self.renderer.register_data(self.data)
def simulate(canvas):
global theCanvas
theCanvas=canvas
mname=canvas.statusbar.getState(StatusBar.MODEL)[1][0]
if not mname:
mname="Nonamed.des"
else:
if mname.endswith(".py"):
mname=mname[:len(mname)-3]
mname=mname+".des"
global sc
sc=generate_description(canvas, 0)
global debugger
debugger=Debugger()
global eventhandler
eventhandler=EventHandler(mname, callback=debugger.EventDebugger, use_gui=1, modeltext=sc["desc"])
eventhandler.final.append("SVMAToM3Plugin.finalize_simulation()")
debugger.CustomizeEvent(event_callback, None, 1)
global root
root=canvas.ASGroot.listNodes
DefaultInterpreter.runsource("eventhandler=SVMAToM3Plugin.eventhandler")
DefaultInterpreter.runsource("debugger=SVMAToM3Plugin.debugger")
debugger.SetEventHandler(eventhandler)
eventhandler.run_initializer()
highlight_states(eventhandler.state, sc)
highlight_trans(eventhandler, sc, root)
# Cannot start the Tk mainloop again
# eventhandler.run_interactor()
DefaultInterpreter.runsource("setup_gui_debugger(eventhandler, debugger, 0, 0)")
def main_loop():
json_data = open("config.json").read()
config = json.loads(json_data)
bot = telegram.Bot(token=config["TOKEN_BOT"])
logging_user = config['logging_user'] if 'logging_user' in config.keys() else None
updater = Updater(bot=bot)
dispatcher = updater.dispatcher
logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', level=logging.DEBUG)
sender_filter = SenderFilterService(config)
message_sender = MessageSender(bot, config, logging_user=logging_user)
event_handler = EventHandler(sender_filter, message_sender, config, logging_user=logging_user)
all_handler = MessageHandler(Filters.all, event_handler.handle_all)
dispatcher.add_handler(all_handler)
print 'waiting new messages...'
updater.start_polling()
def __init__(self):
try:
self.graph = pickle.load(open(FILE_LOCATION, "rb"))
LoggerSingleton() # Initialise the logger when creating from binary file
except:
self.graph = generateDemoGraph()
self.builder = Gtk.Builder()
self.builder.add_from_file("MainScreen.glade")
self.builder.connect_signals(EventHandler(self.graph, self))
self.MainWindow = self.builder.get_object("MainWindow")
self.LoginWindow = self.builder.get_object("LoginWindow")
self.ConversionWindow = self.builder.get_object("ConversionWindow")
self.AdminWindow = self.builder.get_object("AdminWindow")
self.LoginWindow.show_all()
def add_event_handler(self, evh, uri_base):
type = evh.getAttribute('type')
file = evh.getAttribute("file")
code = ""
if file == "":
# if no file attribute is specified, it must
# be inline code
code = evh.childNodes[0].data
else:
# get the code from the specified file
if not re.match("(http:|\/|file:)", file):
# the uri appears to be relative, so we
# append it to the base uri
file = urlparse.urljoin(uri_base, file)
try:
code = "".join(urllib.urlopen(file).readlines())
except:
self.error("couldn't open file %s" % file)
code = code.replace("\r\n", "\n")
self.event_handlers[type] = EventHandler(self, type, code, file)
def threadFunc(base_path, file_name):
EventHandler(base_path, file_name, upload_file)
#! /usr/bin/env python3
import sys
sys.path.append(",")
from pathlib import Path
from time import sleep
from watchdog.observers import Observer
from EventHandler import EventHandler
if __name__ == '__main__':
watch_path = Path.home() / 'C:/Users/mwiniarski/Downloads/cleaner'
destination_root = Path.home(
) / 'C:/Users/mwiniarski/Downloads/cleaner/holder of things'
event_handler = EventHandler(watch_path=watch_path,
destination_root=destination_root)
observer = Observer()
observer.schedule(event_handler, f'{watch_path}', recursive=True)
observer.start()
try:
while True:
sleep(60)
except KeyboardInterrupt:
observer.stop()
observer.join()
class App:
def __init__(self):
self.root = Tk()
self.setUpMenu()
self.canvas = self.setUpCanvas(self.root, 800, 800)
self.canvas.pack()
self.graph = DrawableGraph ()
self.eventHandler = EventHandler(self.canvas)
self.root.mainloop()
def setUpMenu(self):
menubar = Menu(self.root)
menubar.add_command(label="New Graph", command=self.newGraph)
menubar.add_command(label="Properties", command=self.properties)
menubar.add_command(label="Reset Graph", command = self.resetGraph)
algMenu = Menu(menubar, tearoff=0)
algMenu.add_command(label="Depth First Search", command=self.dfs)
algMenu.add_command(label="Breadth First Search", command=self.bfs)
algMenu.add_command(label="Prim's Algorithm", command=self.prims)
algMenu.add_command(label="Dijkstra's Algorithm", command=self.dijkstras)
menubar.add_cascade(label="Algorithms", menu=algMenu)
addMenu = Menu(menubar, tearoff=0)
addMenu.add_command(label="Vertices", command=self.addVertices)
addMenu.add_command(label="Edges", command=self.addEdges)
menubar.add_cascade(label="Add", menu=addMenu)
self.root.config(menu=menubar)
# Bind mouse click event to add a new vertex
def addVertices(self):
messagebox.showinfo("Add Vertex", "Click anywhere to add a vertex")
self.canvas.bind("<Button-1>", self.newVertex)
# Bind mouse click event to add a new edge
def addEdges(self):
messagebox.showinfo("Add Edge", "Select a start vertex and an end vertex")
self.canvas.bind("<Button-1>", self.newEdge)
# Wipe canvas, set graph attribute to a new graph
def newGraph(self):
self.canvas.delete("all")
self.graph = DrawableGraph()
self.canvas.unbind("<Button-1>")
# Colour all edges and vertices black
def resetGraph(self):
for v in self.graph:
v.setColour("black")
self.graph.drawGraph(self.canvas)
# Tell eventHandler to add a new edge
def newEdge(self, event):
self.eventHandler.newEdge(event, self.graph)
# Get properties back from eventHandler and display
def properties(self):
properties = self.eventHandler.handleProperties(self.graph)
# Graph has no edges or vertices, so do not show anything
if (properties != None):
PropertiesDialog(self.root, properties)
# Bind mouse click event to DFS
def dfs(self):
messagebox.showinfo("DFS", "Click on a start vertex")
self.canvas.bind("<Button-1>", self.handleDFS)
def handleDFS(self, event):
self.eventHandler.handleDFS(self.graph, event)
# Bind mouse click event to BFS
def bfs(self):
messagebox.showinfo("BFS", "Click on a start vertex")
self.canvas.bind("<Button-1>", self.handleBFS)
def handleBFS(self, event):
self.eventHandler.handleBFS(self.graph, event)
# Bind mouse click event to Prims
def prims(self):
messagebox.showinfo("Prims", "Click on a start vertex")
self.canvas.bind("<Button-1>", self.handlePrims)
def handlePrims(self, event):
self.eventHandler.handlePrims(self.graph, event)
# Bind mouse click event to Dijkstras
def dijkstras(self):
messagebox.showinfo("Dijkstras", "Click on a start vertex")
self.canvas.bind("<Button-1>", self.handleDijkstra)
def handleDijkstra(self, event):
self.eventHandler.handleDijkstra(self.graph, event)
def draw(self):
self.graph.drawGraph(self.canvas)
def setUpCanvas(self, master, width, height):
canvas = Canvas(master, width=width, height=height)
return canvas
def newVertex(self, event):
self.eventHandler.newVertex(event, self.graph)
if __name__ == '__main__':
#init config file
print "load global config file"
if len(sys.argv) < 2:
config.load("../conf/mymeego.conf")
else:
config.load(sys.argv[1])
#init mainloop
dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
# get session bus
bus = dbus.SessionBus()
mainloop = gobject.MainLoop()
event_handler = EventHandler(mainloop)
# init upnp ########
configfile = config.coherence_conf
if len(configfile) <= 0:
sys.exit("no coherence config file specified in config or else")
upnp = BackendUpnp(event_handler,configfile,config.device_name,config.device_type)
# end upnp init ####
# init closing signals
signal.signal(signal.SIGINT,close) # CTRL+C signal error
signal.signal(signal.SIGQUIT,close) # terminal quit
# init modules
dbus_module = DbusModule(event_handler,"dbus","org.mymeego.Ui","/org/mymeego/Ui","org.mymeego.Ui")
upnp_module = UpnpModule(event_handler,"upnp",upnp)
argn=argn+1
debugger=Debugger()
path_name=os.path.split(desc)
addpath=path_name[0]
name=path_name[1]
if len(addpath)>0:
sys.path=[addpath]+sys.path
params={}
while argn<len(sys.argv):
arg=sys.argv[argn]
argn=argn+1
param=ParseOption(arg)
if param!=None:
par=ParseParameter(param[0])
params[par[0]]=[par[1], param[1]]
try:
eventhandler=EventHandler(name, debugger.EventDebugger, params, use_gui, 1, haddition, taddition)
except FileNotFound, e:
print e
raise SystemExit
debugger.SetEventHandler(eventhandler)
if eventhandler.description:
print eventhandler.description
eventhandler.run_initializer()
eventhandler.run_interactor()
def eventHandlingTest():
print "event handler test set"
print "init test set"
event_handler = EventHandler()
# init modules
dbus_module = DbusModule(event_handler,"dbus","org.mymeego.Ui","/org/mymeego/Ui","org.mymeego.Ui")
upnp_module = UpnpModule(event_handler,"upnp")
worker_module = WorkerModule(event_handler,"worker")
#init commands
event_handler.addCommand(Command("ReturnUiData",dbus_module))
event_handler.addCommand(Command("DataRequest",worker_module)) # this is the default command from UI
event_handler.addCommand(Command("GetDeviceList",upnp_module))
event_handler.addCommand(Command("GetFileList",upnp_module))
event_handler.addCommand(Command("TransferFiles",upnp_module))
print "start tests"
event_handler.handleEvent(Event("DataRequest",1,"GetDeviceList"))
event_handler.handleEvent(Event("DataRequest",1,"GetFileList"))
event_handler.handleEvent(Event("DataRequest",1,"TransferFiles"))
event_handler.handleEvent(Event("ReturnUiData",1,"TransferFiles"))
parser = argparse.ArgumentParser('Settings for Morris Bot')
parser.add_argument('-T',
'--token',
help='Token which you got from your group admin.')
parser.add_argument(
'-Pl',
'--parser-login',
help=
'Login for your bot-account. Opens new feature like a parsing timetable')
parser.add_argument('-Pp',
'--parser-password',
help='Password for your bot-account.')
args = vars(parser.parse_args())
bot = EventHandler()
token = args.get('token')
# Creating group-class
group = Group()
group.auth(token)
group.connect_storage(DBProxy(Member))
bot.set_group(group)
# Setup account for bot. This is need for parsing group wall and timetable
account = BotAccount.get_account()
account.auth(args.get('parser-login'), args.get('parser-password'))
# Setup observers that handle commands
command_observer = IObserver.get_observer(CommandObserver)
params = {}
while argn < len(sys.argv):
arg = sys.argv[argn]
argn = argn + 1
param = ParseOption(arg)
if param != None:
par = ParseParameter(param[0])
params[par[0]] = [par[1], param[1]]
if command_only:
if len(name) > 4 and string.upper(name[len(name) - 4:]) == ".DES":
model_name = name[:len(name) - 4]
else:
model_name = name
else:
eventhandler = EventHandler(name, None, params, use_gui, 1,
haddition, taddition, 0)
model_name = eventhandler.options[MODEL_NAME]
code_type = string.lower(code_type)
info = {"time": None, "compile": None, "run": None, "file": None}
desc = [[], ["time", "Time spent on compilation: "],
["file", "File(s) generated: "], [],
["compile", "Command to compile the source: "],
["run", "Command to run the compiled code: "], []]
starttime = time.time()
if code_type == "java":
if not command_only:
from JavaGenerator import JavaGenerator
g = JavaGenerator(eventhandler)
g.generate()
class CalendarApp(QMainWindow):
'''This class contains the CalendarApp class(main window), it inherits the QMainWindow class in Pyside2'''
def __init__(self):
''' This function calls parents class, initialize infoWindow, load main window UI,
and call the clickOnDate function in eventHandler to get today's event list upon opening the GUI
Args:
none
Returns:
none
'''
self.eventHandler = EventHandler(self)
super(CalendarApp, self).__init__()
self.infoDialog = InfoWindow()
self.load_ui()
self.eventHandler.clickOnDate()
def showInfoDialog(self):
'''Shows the pop-up infoWindow when the called (upon bookPushbutton is clicked)
Args:
none
Returns:
none
'''
self.setEnabled(
False) #set main window to disable when showing the popup window
self.infoDialog.show() # show popup info window
#Bindind the UI components to listener(eventhandler)
def BindEventsHandler(self):
'''Binds the UI components to its listener - functions in EventHandler class
Args:
none
Returns:
none
'''
btn = self.window.findChild(QPushButton, 'bookPushButton')
btn.clicked.connect(self.eventHandler.bookPushButton_cliked)
self.calWidget = self.window.findChild(QCalendarWidget,
'calendarWidget')
self.calWidget.selectionChanged.connect(self.eventHandler.clickOnDate)
self.QListWidget = self.window.findChild(QListWidget, 'listWidget')
btn = self.infoDialog.findChild(QPushButton, 'sendButton')
btn.clicked.connect(self.eventHandler.sendPushButton_clicked)
btn = self.infoDialog.findChild(QPushButton, 'cancelButton')
btn.clicked.connect(self.eventHandler.cancelPushButton_clicked)
def load_ui(self):
'''Load the mainWindow.ui file and show it on screen.
Args:
none
Returns:
none
'''
loader = QUiLoader()
path = os.path.join(os.path.dirname(__file__), "mainWindow.ui")
ui_file = QFile(path)
ui_file.open(QFile.ReadOnly)
self.window = loader.load(ui_file, self)
ui_file.close()
self.BindEventsHandler()
self.window.show()
