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': []})
