def test_009_bind_callbacks(self): event_name = 'newCoolEvent' eh = EventHandler(event_name) def callback1(*args): pass self.assertFalse(eh.is_callback_in_event(event_name, callback1)) output = io.StringIO() eh = EventHandler(event_name, verbose=True, stream_output=output) with self.assertRaises(EventHandler.Exceptions.EventNotAllowedError) as context: # Impossible to link to a not registered callback, will raie error eh.link(callback1, 'onNotRegisteredEvent') self.assertTrue(eh.link(callback1, event_name)) self.assertFalse(eh.link(callback1, event_name)) output = str(output.getvalue()) self.assertTrue(callback1.__name__ in output) self.assertTrue(event_name in output) self.assertTrue(eh.is_callback_in_event(event_name, callback1)) # tries to link not callable event self.assertFalse(eh.link('not_callable', event_name))
def test_010_unbind_callbacks(self): event_name = 'newCoolEvent' eh = EventHandler(event_name) def callback1(*args): pass self.assertTrue(eh.link(callback1, event_name)) self.assertTrue(eh.unlink(callback1, event_name)) # Test already unregistered event output = io.StringIO() eh = EventHandler(event_name, verbose=True, stream_output=output) self.assertFalse(eh.unlink(callback1, event_name)) self.assertTrue(eh.link(callback1, event_name)) self.assertFalse(eh.link(callback1, event_name)) value = output.getvalue() self.assertTrue(callback1.__name__ in value) self.assertTrue(event_name in value) # Test try unregister not exists event self.assertFalse(eh.unlink(callback1, 'inexistentEventName')) value = output.getvalue() print(output) for event in eh.event_list: self.assertTrue(event in value)
def test_006_event_registration(self): eh = EventHandler() event_name = 'onMyCoolEventHappens' self.assertFalse(eh.is_event_registered(event_name)) self.assertTrue(eh.register_event(event_name)) self.assertTrue(eh.is_event_registered(event_name)) eh = EventHandler('one', 'two', 'three', verbose=True) self.assertTrue(eh.is_event_registered('three')) self.assertFalse(eh.register_event('one'))
def test_011_fire_event(self): event_name = 'newCoolEvent' eh = EventHandler(event_name) def callback1(*args, **kwargs): self.assertEqual(args[0], 1) self.assertEqual(args[1], 2) self.assertEqual(args[2], 3) self.assertEqual(kwargs['extra'], 0) self.assertTrue(eh.link(callback1, event_name)) self.assertTrue(eh.fire(event_name, 1, 2, 3, extra=0)) def will_fail_callback(number1, number2, number3, extra=0): return number1 / extra self.assertTrue(eh.link(will_fail_callback, event_name)) with self.assertRaises(ZeroDivisionError) as context: eh.fire(event_name, 1, 2, 3, extra=0) # Set callback fail toleration eh.verbose = True eh.tolerate_exceptions = True output = io.StringIO() eh.stream_output = output self.assertFalse(eh.fire(event_name, 1, 2, 3, extra=0)) value = output.getvalue() self.assertTrue('WARNING' in value) self.assertTrue(will_fail_callback.__name__ in value)
def test_002_initiaization_with_events(self): # Test init with args. eh = EventHandler('MyEvent') self.assertEqual(eh.count_events, 1) self.assertFalse(eh.verbose) # checks verbose is false self.assertFalse(eh.tolerate_exceptions) # checks no exception toleration self.assertIsNotNone(eh.stream_output)
def test_001_initialization_args(self): # Test init on no args eh = EventHandler() self.assertEqual(eh.count_events, 0) # checks there is no events self.assertFalse(eh.verbose) # checks verbose is false self.assertFalse(eh.tolerate_exceptions) # checks no exception toleration self.assertIsNotNone(eh.stream_output)
def test_007_event_unregistration(self): eh = EventHandler() event_name = 'onMyCoolEventHappens' self.assertFalse(eh.is_event_registered(event_name)) self.assertTrue(eh.register_event(event_name)) self.assertTrue(eh.is_event_registered(event_name)) eh.unregister_event(event_name) self.assertFalse(eh.unregister_event('one'))
def test_005_initialization_file_to_verbose(self): with open('test.txt', '+w') as f: eh = EventHandler(stream_output=f, verbose=True) self.assertEqual('test.txt', eh.stream_output.name) instance_id = str(hex(id(eh))) f.close() with open('test.txt', 'r') as f: content = f.read() self.assertTrue((instance_id in content)) f.close() os.remove('test.txt')
def _plotit(self): rows = 5 cols = 6 if not self._legendflag: self.fig, (self._heatax, self._matax) = plt.subplots(1, 2) else: gs = gridspec.GridSpec(rows, cols) # self._matax = plt.subplot2grid( (rows, cols), ( 0, 0), rowspan=rows, colspan=2) # self._heatax = plt.subplot2grid( (rows, cols), ( 0, 4), rowspan=rows, colspan=2) # self._legax = plt.subplot2grid( (rows, cols), ( 0, 2), rowspan=3, colspan=2) # self.cont_dir = plt.subplot2grid( (rows, cols), ( 3, 2), colspan=2) self._matax = plt.subplot(gs[ :, :2]) self._heatax = plt.subplot(gs[ :, 4:]) self._legax = plt.subplot(gs[ :3, 2:4]) self.cont_dir = plt.subplot(gs[ -1, 2]) self.cont_dir.set_title('sort on click by') self._plot_legend() self._matpatches = [] self.fig = self._matax.figure self.fig.tight_layout() self.fig.canvas.set_window_title('binderfinder Matrix {} -- {}'.format(__version__, self.filename)) self.fig.subplots_adjust(top=0.90) # self.fig.suptitle(self.filename) plt.figtext(0.07, 0.03, self.filename) self._matimg = self._matax.imshow(self._matrix, interpolation='none') self._heatimg = self._heatax.imshow(np.zeros(self._matrix.shape[:2]), interpolation='none', vmin=0, vmax=1, cmap=self._heatmap_color) plt.colorbar(mappable=self._heatimg, ax=self._heatax) self._update_matrixdata() self._set_ticks(self.subnames, self.typnames) # self._check_color = RadioButtons(self.cont_rgb, ('R', 'G', 'B', 'mean'), (False, False, True)) self._check_dir = RadioButtons(self.cont_dir, ('row', 'col', 'both')) self._event_handler = EventHandler(self.fig, self, debug=self._debugflag) # spacer between stats and data self._plot_spacer() # remove spines for ax in (self._matax, self._heatax): # for line in ('top', 'bottom', 'left', 'right'): # ax.spines[l].set_visible(False) for spine in ax.spines.values(): spine.set_visible(False)
def run_module(module_name, args, controller, socks_port, stats): """ Run an exitmap module over all available exit relays. """ logger.info("Running module '%s'." % module_name) stats.modules_run += 1 try: module = __import__("modules.%s" % module_name, fromlist=[module_name]) except ImportError as err: logger.error("Failed to load module because: %s" % err) return # Let module perform one-off setup tasks. if hasattr(module, "setup"): logger.debug("Calling module's setup() function.") module.setup() exit_destinations = select_exits(args, module) exit_relays = list(exit_destinations.keys()) random.shuffle(exit_relays) count = len(exit_relays) stats.total_circuits += count if count < 1: raise error.ExitSelectionError("Exit selection yielded %d exits " "but need at least one." % count) handler = EventHandler(controller, module, socks_port, stats, exit_destinations=exit_destinations) controller.add_event_listener(handler.new_event, EventType.CIRC, EventType.STREAM) duration = count * args.build_delay logger.info("Scan is estimated to take around %s." % datetime.timedelta(seconds=duration)) logger.info("Beginning to trigger %d circuit creation(s)." % count) iter_exit_relays(exit_relays, controller, stats, args)
def test_012_string_representation(self): eh = EventHandler('one') def check__str__output(): instance_id = str(hex(id(eh))) self.assertTrue(instance_id in eh.__str__()) self.assertTrue(f'verbose={eh.verbose}' in eh.__str__()) self.assertTrue(f'tolerate_exceptions={eh.tolerate_exceptions}' in eh.__str__()) for event in eh.event_list: self.assertTrue(event in eh.__str__()) for callback in eh.event_list: self.assertTrue(callback in eh.__str__()) def callback1_in_one(): pass def callback2_in_one(): pass def callback3_in_one(): pass def callback1_in_two(): pass def callback2_in_two(): pass def callback1_in_three(): pass self.assertTrue(eh.link(callback1_in_one, 'one')) check__str__output() self.assertTrue(eh.link(callback2_in_one, 'one')) check__str__output() self.assertTrue(eh.link(callback3_in_one, 'one')) check__str__output() self.assertTrue(eh.register_event('two')) self.assertTrue(eh.link(callback1_in_two, 'two')) check__str__output() self.assertTrue(eh.link(callback2_in_two, 'two')) check__str__output() self.assertTrue(eh.register_event('three')) self.assertTrue(eh.link(callback1_in_three, 'three')) check__str__output() self.assertTrue(eh.unregister_event('three')) check__str__output() self.assertTrue(eh.unlink(callback2_in_two, 'two'))
def __init__(self, x, y): self.board_size = min(x, y) self.piece_size = self.board_size // 8 self.bg_image = Image.open("./resources/images/chessboard.png") self.og_pieces = self.load_piece_images() self.pieces = self.og_pieces self.board = self.bg_image.copy() self.play_board = self.board.copy() self.env = ChessEnvironment() self.root = tk.Tk(className="Chess") self.root.geometry("{}x{}".format(x, y)) self.eh = EventHandler(self) self.root.bind("<Configure>", self.eh.on_configure) self.root.bind("<Return>", self.eh.on_confirm) self.tk_image = ImageTk.PhotoImage(self.play_board) self.board_label = tk.Label(self.root, image=self.tk_image) self.board_label.place(relx=0.05, rely=0.05) self.game_label = tk.Label(self.root, text="Game playing") self.game_label.place(relx=0.05, rely=0.96) self.move_var = tk.StringVar() self.move_var.set("") self.move_var.trace("w", self.eh.check_move) self.move_box = tk.Entry(self.root, textvariable=self.move_var) self.move_box.place(relx=0.15, rely=0.01) self.move_label = tk.Label(self.root, text="NOT a valid move") self.move_label.place(relx=0.25, rely=0.01) self.random_move_button = tk.Button( self.root, text="Random Move", command=self.eh.on_random_move ) self.random_move_button.place(relx=0.35, rely=0.01) self.start_button = tk.Button( self.root, text="New Game", command=self.eh.on_start ) self.start_button.place(relx=0.05, rely=0.01) self.root.mainloop() self.on_resize()
def __init__(self): """Initialize the chat room.""" self.__messages = [] # Stores users messages self.__users = { 'bot': [] } # Stores a dictionary with registered usernames # Define the event handler and make it public outside the class to let externals subscriptions to events. self.event_handler = EventHandler( 'onNewuser', 'onMessage') # Note that events names are cased sensitive. # You can set any number of unique events and asing any number of unique callbacks to fire per event. # Is not necessary define events names during initialization, also you can register the event names during # run time using register_event method. # Lets link some internal class methods to those events as callbacks. # Limits are available resources. self.event_handler.link(self.__on_newuser_join, 'onNewuser') self.event_handler.link(self.__on_message, 'onMessage')
def __init__(self, bgcolor=pygame.Color('White'), size=(400, 400), foodspawnrange=(200, 700)): pygame.init() self.window = pygame.display.set_mode(size) self.window.fill(bgcolor) pygame.display.set_icon(pygame.image.load('images/favicon.png')) pygame.display.set_caption("Snake") self.objects = [] self.clock = Clock() self.bgcolor = bgcolor self.eventhandler = EventHandler() self.run = True self.foodspawn = foodspawnrange self.nextfood = -randint(*self.foodspawn) self.size = size self.pause = False self.deaths = {} self.events = []
def run_module(module_name, args, controller, stats): """ Run an exitmap module over all available exit relays. """ logger.info("Running module '%s'." % module_name) stats.modules_run += 1 try: module = __import__("modules.%s" % module_name, fromlist=[module_name]) except ImportError as err: logger.error("Failed to load module because: %s" % err) return exit_relays = select_exits(args, module) count = len(exit_relays) stats.total_circuits += count if count < 1: raise error.ExitSelectionError("Exit selection yielded %d exits " "but need at least one." % count) handler = EventHandler(controller, module.probe, stats) controller.add_event_listener(handler.new_event, EventType.CIRC, EventType.STREAM) logger.debug("Circuit creation delay of %.3f seconds will account for " "total delay of %.3f seconds." % (args.build_delay, count * args.build_delay)) before = datetime.datetime.now() logger.debug("Beginning to trigger %d circuit creation(s)." % count) consensus = util.get_consensus_path(args) fingerprints = relayselector.get_fingerprints(consensus) # Start building a circuit for every exit relay we got. for i, exit_relay in enumerate(exit_relays): # Determine the hops in our next circuit. if args.first_hop: hops = [args.first_hop, exit_relay] else: all_hops = list(fingerprints) all_hops.remove(exit_relay) first_hop = random.choice(all_hops) logger.debug("Using random first hop %s for circuit." % first_hop) hops = [first_hop, exit_relay] assert len(hops) > 1 try: controller.new_circuit(hops) except stem.ControllerError as err: stats.failed_circuits += 1 logger.debug("Circuit with exit relay \"%s\" could not be " "created: %s" % (exit_relay, err)) if i != (count - 1): time.sleep(args.build_delay) logger.info("Done triggering circuit creations after %s." % str(datetime.datetime.now() - before))
#! /usr/bin/env python3 from pathlib import Path from time import sleep from watchdog.observers import Observer from eventhandler import EventHandler if __name__ == '__main__': watch_path = Path.home() / 'Desktop' destination_root = Path.home() / 'Desktop/benjaminlewis' 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()
import gi gi.require_version('Gtk', '3.0') from gi.repository import Gtk from settings import Settings from remote import Remote from setup import Setup from eventhandler import EventHandler builder = Gtk.Builder() handler = EventHandler(builder) builder.add_from_file("view/remote.glade") builder.connect_signals(handler) settings = Settings() # attempt to load user defined settings user_defined = settings.GetSettings() if user_defined is not None: remoteWin = Remote(user_defined) kodi = remoteWin.load_window(builder) handler.initKodiObj(kodi) else: setupWin = Setup() setupWin.load_window(builder) Gtk.main()
def test_004_initialization_tolerate_execeptions(self): eh = EventHandler(tolerate_callbacks_exceptions=True) self.assertTrue(eh.tolerate_exceptions) eh = EventHandler(tolerate_callbacks_exceptions=False) self.assertFalse(eh.tolerate_exceptions)
def test_003_initialization_verbose(self): eh = EventHandler(verbose=True) self.assertTrue(eh.verbose) eh = EventHandler(verbose=False) self.assertFalse(eh.verbose)
def test_015_test__rep(self): eh = EventHandler('one', 'two', 'three') self.assertEqual(eh.__str__(), eh.__repr__())
def test_014_test_events_tuple(self): eh = EventHandler('one', 'two', 'three') self.assertDictEqual(eh.events, {'one': [], 'two': [], 'three': []}) self.assertTrue(eh.clear_events()) self.assertDictEqual(eh.events, {})
def setUp(self): events = [] self.my_service = EventHandler(events)
pnlc.ObjectListBox(0, 10, layout, size=calculuteAbsoluteSize((20, 90)))) selectorArea = pnlc.ObjectListBox(80, 10, layout, size=calculuteAbsoluteSize((20, 90))) objlist.append(selectorArea) objlist.append( pnlc.ObjectListBox(0, 0, layout, size=calculuteAbsoluteSize((100, 5)))) for img in glob.glob("./img/*.png"): selectorArea.addImg(img, "text") print(selectorArea is objlist[1]) print(selectorArea.getobjlist() == objlist[1].getobjlist()) eventhandler = EventHandler(objlist) if pygame.font.get_init(): font = pygame.font.Font(pygame.font.get_default_font(), FONTSIZE) def showmousepos(pos): text = font.render("x : " + str(pos[0]) + "\n y = " + str(pos[1]), True, (50, 12, 50)) window.blit(text, pos) if __name__ == '__main__': while running: eventhandler.show() showmousepos(pygame.mouse.get_pos()) pygame.display.update()
import time from renderer import Renderer from config import gameConfig from paddle import Paddle from eventhandler import EventHandler from keyreader import KeyReader from ball import Ball from spritestore import store from collisionchecker import collisionChecker # Bug - ball bounces the wrong way and passes through the paddle when hitting the top of it renderer = Renderer(gameConfig) eventHandler = EventHandler() keyReader = KeyReader() yBoundary = gameConfig.sHeight - 30 yMin = 30 xBoundary = gameConfig.sWidth - 30 xMin = 30 paddle_player1 = Paddle(yBoundary, xMin, yMin) paddle_player2 = Paddle(yBoundary, xBoundary - 20, yMin) ball = Ball(xBoundary, yBoundary, xMin, yBoundary - 50) renderer.initialize() store.register(paddle_player1) store.register(paddle_player2) store.register(ball)
from eventhandler import EventHandler if __name__ == '__main__': d = EventHandler() d.contextSwitchEvent()
def handler(self, options=None): handlerlist = [""] * len(self.pathlist) for i in range(len(handlerlist)): handlerlist[i] = EventHandler(options) return handlerlist
def sbserver(): global run_daemon run_daemon = True conf = {} if (not start_config_default(conf)): return 1 if (not start_config_params(conf)): return 1 if (not start_config_get(conf)): return 1 start_log(conf) linfo('starting %s process' % conf['general']['name']) if (not start_config_check(conf)): return 1 signal(SIGHUP, sig_handler) signal(SIGTERM, sig_handler) if (conf['general']['daemon'] == 'yes'): ldebug('%s process starting in daemon mode' % conf['general']['name']) ret = start_daemon() if (ret != 0): lcritic('failed to start %s daemon' % conf['general']['name']) os.exit(ret) ldebug('started %s process with pid: %d' % (conf['general']['name'], os.getpid())) eventhandler = EventHandler() plugins = start_modules(conf) plugins['EventHandler'] = {} plugins['EventHandler']['type'] = (0, ) plugins['EventHandler']['object'] = eventhandler for plugin in plugins: if (0 in plugins[plugin]['type']): ldebug('start system plugin %s' % plugin) plugins[plugin]['object'].config(conf) plugins[plugin]['object'].plugins(plugins) plugins[plugin]['object'].start() elif (1 in plugins[plugin]['type']): ldebug('start listener plugin %s' % plugin) plugins[plugin]['object'].config(conf) plugins[plugin]['object'].plugins(plugins) plugins[plugin]['object'].start() elif (2 in plugins[plugin]['type']): ldebug('start handler plugin %s' % plugin) plugins[plugin]['object'].config(conf) plugins[plugin]['object'].plugins(plugins) plugins[plugin]['object'].start() while (run_daemon): sleep(0.5) for plugin in plugins: if (2 in plugins[plugin]['type']): ldebug('stop handler plugin %s' % plugin) plugins[plugin]['object'].stop() if (1 in plugins[plugin]['type']): ldebug('stop listener plugin %s' % plugin) plugins[plugin]['object'].stop() if (0 in plugins[plugin]['type']): ldebug('stop system plugin %s' % plugin) plugins[plugin]['object'].stop() sleep(1) linfo('exiting %s process' % conf['general']['name']) return 1
def __init__(self): self.predictor = Predictor() self.notificator = EventHandler('add_notify')
#!flask/bin/python from flask import Flask, jsonify, abort, make_response, request from eventhandler import EventHandler app = Flask(__name__) events = [] my_service = EventHandler(events) @app.route('/feeds/api/v1.0/events') def get_last_ten(): last_events = my_service.get_last_ten() if not last_events: return "No events yet" return jsonify({'events': last_events}) @app.route('/feeds/api/v1.0/events/<string:event_field>/<string:event_value>') def get_last_by_field(event_field, event_value): events_by_field = my_service.get_last_by_field(event_field, event_value) if not events_by_field: return "No events yet" return jsonify({'events': events_by_field}) @app.route('/feeds/api/v1.0/events', methods=['POST']) def add_event():
def test_013_test_events_tuple(self): eh = EventHandler('one', 'two', 'three') self.assertDictEqual(eh.events, {'one': [], 'two': [], 'three': []})