From b7cf524e9869828ff85954cb731f7fee98bee8d9 Mon Sep 17 00:00:00 2001
From: jesopo
Date: Fri, 31 Aug 2018 12:55:52 +0100
Subject: Give modules event objects with "context"s, to facilitate purging all
 the event hooks for a module

---
 modules/accept_invite.py    |  5 ++---
 modules/admin.py            |  8 ++++----
 modules/auto_mode.py        |  8 ++++----
 modules/bitcoin.py          |  4 ++--
 modules/bitly.py            |  9 ++++----
 modules/books.py            |  6 +++---
 modules/channel_op.py       | 28 ++++++++++++-------------
 modules/channel_save.py     |  9 ++++----
 modules/check_mode.py       |  5 ++---
 modules/coins.py            | 18 ++++++++--------
 modules/commands.py         | 41 +++++++++++++++++++------------------
 modules/ctcp.py             |  6 +++---
 modules/define.py           |  4 ++--
 modules/dns.py              |  4 ++--
 modules/ducks.py            | 27 ++++++++++++------------
 modules/geoip.py            |  4 ++--
 modules/google.py           |  4 ++--
 modules/hash.py             |  4 ++--
 modules/haveibeenpwned.py   |  4 ++--
 modules/ids.py              |  6 +++---
 modules/imdb.py             |  4 ++--
 modules/in.py               |  6 +++---
 modules/join.py             |  8 ++++----
 modules/karma.py            | 17 +++++++--------
 modules/lastfm.py           |  6 +++---
 modules/nickname_aliases.py | 10 ++++-----
 modules/nickserv.py         |  6 +++---
 modules/nr.py               | 18 ++++++++--------
 modules/perform.py          |  4 ++--
 modules/permissions.py      | 20 +++++++++---------
 modules/pong.py             |  5 ++---
 modules/print_activity.py   | 34 +++++++++++++++---------------
 modules/quit.py             |  4 ++--
 modules/quotes.py           | 10 ++++-----
 modules/random_number.py    |  6 +++---
 modules/sasl.py             | 10 ++++-----
 modules/sed.py              | 13 ++++++------
 modules/seen.py             |  6 +++---
 modules/set.py              | 17 +++++++--------
 modules/signals.py          |  8 +++++---
 modules/soundcloud.py       |  4 ++--
 modules/spotify.py          |  4 ++--
 modules/stats.py            |  6 +++---
 modules/strax.py            |  4 ++--
 modules/telegram.py         | 11 +++++-----
 modules/tfl.py              | 14 ++++++-------
 modules/thesaurus.py        |  4 ++--
 modules/title.py            | 50 ++++++++++++++++++++++-----------------------
 modules/to.py               |  6 +++---
 modules/todo.py             |  8 ++++----
 modules/trakt.py            |  6 +++---
 modules/translate.py        |  4 ++--
 modules/twitter.py          |  4 ++--
 modules/upc.py              |  4 ++--
 modules/urbandictionary.py  |  4 ++--
 modules/weather.py          |  4 ++--
 modules/wikipedia.py        |  4 ++--
 modules/wolframalpha.py     |  6 +++---
 modules/words.py            | 12 +++++------
 modules/youtube.py          | 11 +++++-----
 60 files changed, 296 insertions(+), 290 deletions(-)

(limited to 'modules')

diff --git a/modules/accept_invite.py b/modules/accept_invite.py
index 57ba9d70..e25aea76 100644
--- a/modules/accept_invite.py
+++ b/modules/accept_invite.py
@@ -1,9 +1,8 @@
 
 
 class Module(object):
-    def __init__(self, bot):
-        bot.events.on("received").on("invite").hook(
-            self.on_invite)
+    def __init__(self, bot, events):
+        events.on("received").on("invite").hook(self.on_invite)
 
     def on_invite(self, event):
         if event["server"].get_setting("accept-invites", True):
diff --git a/modules/admin.py b/modules/admin.py
index 400c54df..5578febe 100644
--- a/modules/admin.py
+++ b/modules/admin.py
@@ -1,16 +1,16 @@
 
 
 class Module(object):
-    def __init__(self, bot):
+    def __init__(self, bot, events):
         self.bot = bot
-        bot.events.on("received").on("command").on("changenickname"
+        events.on("received").on("command").on("changenickname"
             ).hook(self.change_nickname, permission="changenickname",
             min_args=1, help="Change my nickname", usage="<nickname>")
-        bot.events.on("received").on("command").on("raw"
+        events.on("received").on("command").on("raw"
             ).hook(self.raw, permission="raw", min_args=1,
             help="Send a raw IRC line through the bot",
             usage="<raw line>")
-        bot.events.on("received").on("command").on("part"
+        events.on("received").on("command").on("part"
             ).hook(self.part, permission="part", min_args=1,
             help="Part from a channel",
             usage="<#channel>")
diff --git a/modules/auto_mode.py b/modules/auto_mode.py
index 2c33f260..3e800591 100644
--- a/modules/auto_mode.py
+++ b/modules/auto_mode.py
@@ -1,16 +1,16 @@
 import Utils
 
 class Module(object):
-    def __init__(self, bot):
+    def __init__(self, bot, events):
         self.bot = bot
 
-        bot.events.on("postboot").on("configure").on(
+        events.on("postboot").on("configure").on(
             "channelset").assure_call(setting="automode",
             help="Disable/Enable automode",
             validate=Utils.bool_or_none)
 
-        bot.events.on("channel").on("mode").hook(self.on_mode)
-        bot.events.on("received").on("join").hook(self.on_join)
+        events.on("channel").on("mode").hook(self.on_mode)
+        events.on("received").on("join").hook(self.on_join)
 
     def on_mode(self, event):
         if event["channel"].get_setting("automode", False):
diff --git a/modules/bitcoin.py b/modules/bitcoin.py
index 17408322..f15c5266 100644
--- a/modules/bitcoin.py
+++ b/modules/bitcoin.py
@@ -2,9 +2,9 @@ import Utils
 
 class Module(object):
     _name = "BTC"
-    def __init__(self, bot):
+    def __init__(self, bot, events):
         self.bot = bot
-        bot.events.on("received").on("command").on("btc").hook(
+        events.on("received").on("command").on("btc").hook(
             self.btc, help="Get the exchange rate of bitcoins",
             usage="[currency]")
 
diff --git a/modules/bitly.py b/modules/bitly.py
index f31ca347..05489fb0 100644
--- a/modules/bitly.py
+++ b/modules/bitly.py
@@ -7,10 +7,11 @@ URL_BITLYSHORTEN = "https://api-ssl.bitly.com/v3/shorten"
 REGEX_URL = re.compile("https?://", re.I)
 
 class Module(object):
-    def __init__(self, bot):
+    def __init__(self, bot, events):
         self.bot = bot
-        bot.events.on("get").on("shortlink").hook(self.shortlink)
-        bot.events.on("received").on("command").on("shorten"
+        self.events = events
+        events.on("get").on("shortlink").hook(self.shortlink)
+        events.on("received").on("command").on("shorten"
             ).hook(self.shorten, min_args=1, help="Shorten a URL.",
             usage="<url>")
 
@@ -25,7 +26,7 @@ class Module(object):
             return data["data"]["url"]
 
     def shorten(self, event):
-        link = self.bot.events.on("get").on("shortlink"
+        link = self.events.on("get").on("shortlink"
             ).call_for_result(url=event["args"])
         if link:
             event["stdout"].write("Short URL: %s" % link)
diff --git a/modules/books.py b/modules/books.py
index 5f7c0627..9c94c656 100644
--- a/modules/books.py
+++ b/modules/books.py
@@ -7,12 +7,12 @@ REGEX_BOOKID = re.compile("id=([\w\-]+)")
 
 class Module(object):
     _name = "ISBN"
-    def __init__(self, bot):
+    def __init__(self, bot, events):
         self.bot = bot
-        bot.events.on("received").on("command").on("isbn").hook(
+        events.on("received").on("command").on("isbn").hook(
             self.isbn, help="Get book information from a provided ISBN",
             min_args=1, usage="<isbn>")
-        bot.events.on("received").on("command").on("book").hook(
+        events.on("received").on("command").on("book").hook(
             self.book, help="Get book information from a provided title",
             min_args=1, usage="<book title>")
 
diff --git a/modules/channel_op.py b/modules/channel_op.py
index b488f224..9e20d693 100644
--- a/modules/channel_op.py
+++ b/modules/channel_op.py
@@ -2,57 +2,57 @@ import Utils
 
 class Module(object):
     _name = "Channel Op"
-    def __init__(self, bot):
+    def __init__(self, bot, events):
         self.bot = bot
-        bot.events.on("received").on("command").on("kick", "k"
+        events.on("received").on("command").on("kick", "k"
             ).hook(self.kick, channel_only=True, require_mode="o",
             min_args=1, help="Kick a user from the channel",
             usage="<nickname> [reason]")
 
-        bot.events.on("received").on("command").on("ban"
+        events.on("received").on("command").on("ban"
             ).hook(self.ban, channel_only=True, require_mode="o",
             min_args=1, help="Ban a user/hostmask from the channel",
             usage="<nickname/hostmask>")
-        bot.events.on("received").on("command").on("unban"
+        events.on("received").on("command").on("unban"
             ).hook(self.unban, channel_only=True, require_mode="o",
             min_args=1, help="Unban a user/hostmask from the channel",
             usage="<nickname/hostmask>")
 
-        bot.events.on("received").on("command").on("kickban", "kb"
+        events.on("received").on("command").on("kickban", "kb"
             ).hook(self.kickban, channel_only=True, require_mode="o",
             min_args=1, help="Kickban a user from the channel",
             usage="<nickanme> [reason]")
 
-        bot.events.on("received").on("command").on("op"
+        events.on("received").on("command").on("op"
             ).hook(self.op, channel_only=True, require_mode="o",
             help="Give +o to a user", usage="[nickname]")
-        bot.events.on("received").on("command").on("deop"
+        events.on("received").on("command").on("deop"
             ).hook(self.deop, channel_only=True, require_mode="o",
             help="Take +o from a user", usage="[nickname]")
 
-        bot.events.on("received").on("command").on("voice"
+        events.on("received").on("command").on("voice"
             ).hook(self.voice, channel_only=True, require_mode="o",
             help="Give +v to a user", usage="[nickname]")
-        bot.events.on("received").on("command").on("devoice"
+        events.on("received").on("command").on("devoice"
             ).hook(self.devoice, channel_only=True, require_mode="o",
             help="Take +v from a user", usage="[nickname]")
 
-        bot.events.on("received").on("message").on("channel").hook(
+        events.on("received").on("message").on("channel").hook(
             self.highlight_spam)
 
-        bot.events.on("postboot").on("configure").on(
+        events.on("postboot").on("configure").on(
             "channelset").assure_call(setting="highlight-spam-threshold",
             help="Set the number of nicknames in a message that "
             "qualifies as spam", validate=Utils.int_or_none)
-        bot.events.on("postboot").on("configure").on(
+        events.on("postboot").on("configure").on(
             "channelset").assure_call(setting="highlight-spam-protection",
             help="Enable/Disable highlight spam protection",
             validate=Utils.bool_or_none)
-        bot.events.on("postboot").on("configure").on(
+        events.on("postboot").on("configure").on(
             "channelset").assure_call(setting="highlight-spam-ban",
             help="Enable/Disable banning highlight spammers "
             "instead of just kicking", validate=Utils.bool_or_none)
-        bot.events.on("postboot").on("configure").on(
+        events.on("postboot").on("configure").on(
             "channelset").assure_call(setting="ban-format",
             help="Set ban format ($n = nick, $u = username, $h = hostname)")
 
diff --git a/modules/channel_save.py b/modules/channel_save.py
index c70d8751..afbd4200 100644
--- a/modules/channel_save.py
+++ b/modules/channel_save.py
@@ -1,11 +1,10 @@
 
 
 class Module(object):
-    def __init__(self, bot):
-        bot.events.on("received.numeric.001").hook(
-            self.on_connect)
-        bot.events.on("self.join").hook(self.on_join)
-        bot.events.on("self.kick").hook(self.on_kick)
+    def __init__(self, bot, events):
+        events.on("received.numeric.001").hook(self.on_connect)
+        events.on("self.join").hook(self.on_join)
+        events.on("self.kick").hook(self.on_kick)
 
     def on_connect(self, event):
         channels =  event["server"].get_setting("autojoin", [])
diff --git a/modules/check_mode.py b/modules/check_mode.py
index a7a8e788..4fb2b783 100644
--- a/modules/check_mode.py
+++ b/modules/check_mode.py
@@ -1,10 +1,9 @@
 
 
 class Module(object):
-    def __init__(self, bot):
+    def __init__(self, bot, events):
         self.bot = bot
-        bot.events.on("preprocess").on("command").hook(
-            self.preprocess_command)
+        events.on("preprocess").on("command").hook(self.preprocess_command)
 
     def preprocess_command(self, event):
         if event["is_channel"] and event["hook"].kwargs.get(
diff --git a/modules/coins.py b/modules/coins.py
index 4fa0377e..307f171f 100644
--- a/modules/coins.py
+++ b/modules/coins.py
@@ -26,26 +26,26 @@ THIRD_COLUMN = list(range(1, 37))[2::3]
 REGEX_STREET = re.compile("street([1-9]|1[0-2])$")
 
 class Module(object):
-    def __init__(self, bot):
+    def __init__(self, bot, events):
         self.bot = bot
-        bot.events.on("received.command.coins").hook(self.coins,
+        events.on("received.command.coins").hook(self.coins,
             help="Show how many coins you have")
-        bot.events.on("received").on("command").on("resetcoins").hook(
+        events.on("received").on("command").on("resetcoins").hook(
             self.reset_coins, permission="resetcoins",
             min_args=1, help=
             "Reset a specified user's coins to %s" % str(DECIMAL_ZERO),
             usage="<target>")
-        bot.events.on("received.command.richest").hook(
+        events.on("received.command.richest").hook(
             self.richest, help="Show the top 10 richest users")
-        bot.events.on("received.command.redeemcoins").hook(
+        events.on("received.command.redeemcoins").hook(
             self.redeem_coins, help="Redeem free coins")
-        bot.events.on("received.command.flip").hook(self.flip,
+        events.on("received.command.flip").hook(self.flip,
             help="Bet coins on a coin flip", usage=
             "heads|tails <coin amount>", min_args=2, protect_registered=True)
-        bot.events.on("received.command.sendcoins").hook(
+        events.on("received.command.sendcoins").hook(
             self.send, min_args=2, help="Send coins to a user",
             usage="<nickname> <amount>", authenticated=True)
-        bot.events.on("received.command.roulette").hook(
+        events.on("received.command.roulette").hook(
             self.roulette, min_args=2, help="Spin the roulette wheel",
             usage="<type> <amount>", protect_registered=True)
 
@@ -53,7 +53,7 @@ class Module(object):
         until_next_hour = 60-now.second
         until_next_hour += ((60-(now.minute+1))*60)
 
-        bot.events.on("timer").on("coin-interest").hook(self.interest)
+        events.on("timer").on("coin-interest").hook(self.interest)
         bot.add_timer("coin-interest", INTEREST_INTERVAL, persist=False,
             next_due=time.time()+until_next_hour)
 
diff --git a/modules/commands.py b/modules/commands.py
index fbce393d..5084f690 100644
--- a/modules/commands.py
+++ b/modules/commands.py
@@ -45,27 +45,28 @@ class StdErr(Out):
             self.module_name, Utils.FONT_RESET)
 
 class Module(object):
-    def __init__(self, bot):
+    def __init__(self, bot, events):
         self.bot = bot
-        bot.events.on("received").on("message").on("channel").hook(
+        self.events = events
+        events.on("received").on("message").on("channel").hook(
             self.channel_message)
-        bot.events.on("received").on("message").on("private").hook(
+        events.on("received").on("message").on("private").hook(
             self.private_message)
-        bot.events.on("received").on("command").on("help").hook(self.help,
+        events.on("received").on("command").on("help").hook(self.help,
             help="Show help for commands", usage="<command>")
-        bot.events.on("received").on("command").on("usage").hook(self.usage,
+        events.on("received").on("command").on("usage").hook(self.usage,
             help="Show usage help for commands", min_args=1,
             usage="<command>")
-        bot.events.on("received").on("command").on("more").hook(self.more,
+        events.on("received").on("command").on("more").hook(self.more,
             help="Get more output from the last command", skip_out=True)
 
-        bot.events.on("postboot").on("configure").on(
+        events.on("postboot").on("configure").on(
             "channelset").assure_call(setting="command-prefix",
             help="Set the command prefix used in this channel")
 
-        bot.events.on("new").on("user", "channel").hook(self.new)
-        bot.events.on("send").on("stdout").hook(self.send_stdout)
-        bot.events.on("send").on("stderr").hook(self.send_stderr)
+        events.on("new").on("user", "channel").hook(self.new)
+        events.on("send").on("stdout").hook(self.send_stdout)
+        events.on("send").on("stderr").hook(self.send_stderr)
 
     def new(self, event):
         if "user" in event:
@@ -76,10 +77,10 @@ class Module(object):
         target.last_stderr = None
 
     def has_command(self, command):
-        return command.lower() in self.bot.events.on("received").on(
+        return command.lower() in self.events.on("received").on(
             "command").get_children()
     def get_hook(self, command):
-        return self.bot.events.on("received").on("command").on(command
+        return self.events.on("received").on("command").on(command
             ).get_hooks()[0]
 
     def is_highlight(self, server, s):
@@ -108,7 +109,7 @@ class Module(object):
             stdout, stderr = StdOut(module_name, target), StdErr(module_name,
                 target)
 
-            returns = self.bot.events.on("preprocess").on("command"
+            returns = self.events.on("preprocess").on("command"
                 ).call(hook=hook, user=event["user"], server=event["server"],
                 target=target, is_channel=is_channel)
             for returned in returns:
@@ -129,7 +130,7 @@ class Module(object):
                 args = " ".join(args_split)
                 server = event["server"]
                 user = event["user"]
-                self.bot.events.on("received").on("command").on(command
+                self.events.on("received").on("command").on(command
                     ).call_limited(1, user=user, server=server,
                     target=target, buffer=buffer, args=args,
                     args_split=args_split, stdout=stdout, stderr=stderr,
@@ -162,9 +163,9 @@ class Module(object):
     def help(self, event):
         if event["args"]:
             command = event["args_split"][0].lower()
-            if command in self.bot.events.on("received").on(
+            if command in self.events.on("received").on(
                     "command").get_children():
-                hooks = self.bot.events.on("received").on("command").on(command).get_hooks()
+                hooks = self.events.on("received").on("command").on(command).get_hooks()
                 if hooks and "help" in hooks[0].kwargs:
                     event["stdout"].write("%s: %s" % (command, hooks[0].kwargs["help"]))
                 else:
@@ -173,8 +174,8 @@ class Module(object):
                 event["stderr"].write("Unknown command '%s'" % command)
         else:
             help_available = []
-            for child in self.bot.events.on("received").on("command").get_children():
-                hooks = self.bot.events.on("received").on("command").on(child).get_hooks()
+            for child in self.events.on("received").on("command").get_children():
+                hooks = self.events.on("received").on("command").on(child).get_hooks()
                 if hooks and "help" in hooks[0].kwargs:
                     help_available.append(child)
             help_available = sorted(help_available)
@@ -182,9 +183,9 @@ class Module(object):
 
     def usage(self, event):
         command = event["args_split"][0].lower()
-        if command in self.bot.events.on("received").on(
+        if command in self.events.on("received").on(
                 "command").get_children():
-            hooks = self.bot.events.on("received").on("command").on(command).get_hooks()
+            hooks = self.events.on("received").on("command").on(command).get_hooks()
             if hooks and "usage" in hooks[0].kwargs:
                 event["stdout"].write("Usage: %s %s" % (command, hooks[0].kwargs["usage"]))
             else:
diff --git a/modules/ctcp.py b/modules/ctcp.py
index 031b39cd..5320369a 100644
--- a/modules/ctcp.py
+++ b/modules/ctcp.py
@@ -1,10 +1,10 @@
 import datetime
 
 class Module(object):
-    def __init__(self, bot):
-        bot.events.on("received").on("message").on("private").hook(
-            self.private_message)
+    def __init__(self, bot, events):
         self.bot = bot
+        events.on("received").on("message").on("private").hook(
+            self.private_message)
 
     def private_message(self, event):
         if event["message"][0] == "\x01" and event["message"][-1] == "\x01":
diff --git a/modules/define.py b/modules/define.py
index c5e62b6a..6f17164c 100644
--- a/modules/define.py
+++ b/modules/define.py
@@ -5,9 +5,9 @@ import Utils
 URL_WORDNIK = "http://api.wordnik.com:80/v4/word.json/%s/definitions"
 
 class Module(object):
-    def __init__(self, bot):
+    def __init__(self, bot, events):
         self.bot = bot
-        bot.events.on("received").on("command").on("define").hook(
+        events.on("received").on("command").on("define").hook(
             self.define, help="Define a provided term",
             usage="<phrase>")
 
diff --git a/modules/dns.py b/modules/dns.py
index 2935e1bf..43499601 100644
--- a/modules/dns.py
+++ b/modules/dns.py
@@ -2,8 +2,8 @@ import socket
 
 class Module(object):
     _name = "DNS"
-    def __init__(self, bot):
-        bot.events.on("received").on("command").on("dns").hook(
+    def __init__(self, bot, events):
+        events.on("received").on("command").on("dns").hook(
             self.dns, min_args=1,
             help="Get all addresses for a given hostname (IPv4/IPv6)",
             usage="<hostname>")
diff --git a/modules/ducks.py b/modules/ducks.py
index 685a49f9..d67c2608 100644
--- a/modules/ducks.py
+++ b/modules/ducks.py
@@ -7,23 +7,24 @@ DUCK_LAST_SEEN = datetime.datetime.now()
 
 
 class Module(object):
-    def __init__(self, bot):
+    def __init__(self, bot, events):
         self.log = IRCLogging.Log
         self.bot = bot
+        self.events = events
         self.active_duck = 0
 
-        bot.events.on("received.command.bef").hook(self.duck_bef,
+        events.on("received.command.bef").hook(self.duck_bef,
                                                    help="Befriend a duck!")
-        bot.events.on("received.command.bang").hook(self.duck_bang,
+        events.on("received.command.bang").hook(self.duck_bang,
                                                     help="Shoot a duck! Meanie.")
-        bot.events.on("received.command.decoy").hook(self.set_decoy,
+        events.on("received.command.decoy").hook(self.set_decoy,
                                                      help="Be a sneaky fellow and make a decoy duck.")
 
-        # bot.events.on("received.command.friends").hook(self.duck_friends,
+        # events.on("received.command.friends").hook(self.duck_friends,
         #                                             help="See who the friendliest people to ducks are!")
-        # bot.events.on("received.command.killers").hook(self.duck_killers,
+        # events.on("received.command.killers").hook(self.duck_killers,
         #                                             help="See who shoots the most amount of ducks.")
-        # bot.events.on("received.command.ducks").hook(self.duck_list,
+        # events.on("received.command.ducks").hook(self.duck_list,
         #                                              help="Shows a list of the most popular duck superstars.")
 
         now = datetime.datetime.now()
@@ -35,22 +36,22 @@ class Module(object):
         tricky = next_duck_time - now.second
         tricky += ((next_duck_time - (now.minute + 1)) * 2)
 
-        bot.events.on("postboot").on("configure").on(
+        events.on("postboot").on("configure").on(
             "channelset").assure_call(setting="ducks-enabled",
                                       help="Toggles ducks! (1 or 0)")
 
-        bot.events.on("postboot").on("configure").on(
+        events.on("postboot").on("configure").on(
             "channelset").assure_call(setting="min-duck-time",
                                       help="Minimum seconds before a duck is summoned")
 
-        bot.events.on("postboot").on("configure").on(
+        events.on("postboot").on("configure").on(
             "channelset").assure_call(setting="max-duck-time",
                                       help="Max seconds before a duck is summoned")
 
-        bot.events.on("timer").on("duck-appear").hook(self.show_duck)
+        events.on("timer").on("duck-appear").hook(self.show_duck)
         bot.add_timer("duck-appear", next_duck_time, persist=False)
 
-        bot.events.on("received.numeric.366").hook(self.bootstrap)
+        events.on("received.numeric.366").hook(self.bootstrap)
 
     def bootstrap(self, event):
         for server in self.bot.servers.values():
@@ -198,7 +199,7 @@ class Module(object):
 
     def set_decoy(self, event):
         next_decoy_time = self.decoy_time()
-        self.bot.events.on("timer").on("duck-decoy").hook(self.duck_decoy)
+        self.events.on("timer").on("duck-decoy").hook(self.duck_decoy)
         self.bot.add_timer("duck-decoy", next_decoy_time, persist=False)
 
 # def coins(self, event):
diff --git a/modules/geoip.py b/modules/geoip.py
index 7615575c..bd874d76 100644
--- a/modules/geoip.py
+++ b/modules/geoip.py
@@ -4,8 +4,8 @@ URL_GEOIP = "http://ip-api.com/json/%s"
 
 class Module(object):
     _name = "GeoIP"
-    def __init__(self, bot):
-        bot.events.on("received").on("command").on("geoip").hook(
+    def __init__(self, bot, events):
+        events.on("received").on("command").on("geoip").hook(
             self.geoip, min_args=1,
             help="Get geoip data on a given IPv4/IPv6 address",
             usage="<IP>")
diff --git a/modules/google.py b/modules/google.py
index b8d5c653..632c5fd2 100644
--- a/modules/google.py
+++ b/modules/google.py
@@ -6,9 +6,9 @@ import Utils
 URL_GOOGLESEARCH = "https://www.googleapis.com/customsearch/v1"
 
 class Module(object):
-    def __init__(self, bot):
+    def __init__(self, bot, events):
         self.bot = bot
-        bot.events.on("received").on("command").on("google",
+        events.on("received").on("command").on("google",
             "g").hook(self.google, help="Google feeling lucky",
             usage="[search term]")
 
diff --git a/modules/hash.py b/modules/hash.py
index 86657bd1..19f0591f 100644
--- a/modules/hash.py
+++ b/modules/hash.py
@@ -1,9 +1,9 @@
 import hashlib
 
 class Module(object):
-    def __init__(self, bot):
+    def __init__(self, bot, events):
         self.bot = bot
-        bot.events.on("received").on("command").on("hash"
+        events.on("received").on("command").on("hash"
             ).hook(self.hash, min_args=2, help="Hash a string",
             usage="<algo> <string>")
 
diff --git a/modules/haveibeenpwned.py b/modules/haveibeenpwned.py
index fa10129c..854f69f3 100644
--- a/modules/haveibeenpwned.py
+++ b/modules/haveibeenpwned.py
@@ -4,8 +4,8 @@ URL_HAVEIBEENPWNEDAPI = "https://haveibeenpwned.com/api/v2/breachedaccount/%s"
 URL_HAVEIBEENPWNED = "https://haveibeenpwned.com/"
 
 class Module(object):
-    def __init__(self, bot):
-        bot.events.on("received").on("command").on("beenpwned").hook(
+    def __init__(self, bot, events):
+        events.on("received").on("command").on("beenpwned").hook(
             self.beenpwned, min_args=1,
             help="Find out if a username, email or similar has appeared "
             "in any hacked databases", usage="<username/email>")
diff --git a/modules/ids.py b/modules/ids.py
index c8bd8042..0c8ba0bf 100644
--- a/modules/ids.py
+++ b/modules/ids.py
@@ -2,10 +2,10 @@
 
 class Module(object):
     _name = "IDs"
-    def __init__(self, bot):
-        bot.events.on("received.command.myid").hook(self.my_id,
+    def __init__(self, bot, events):
+        events.on("received.command.myid").hook(self.my_id,
             help="Show your user ID")
-        bot.events.on("received.command.channelid").hook(
+        events.on("received.command.channelid").hook(
             self.channel_id, channel_only=True,
             help="Show the current channel's ID")
 
diff --git a/modules/imdb.py b/modules/imdb.py
index c24b4c0a..71458638 100644
--- a/modules/imdb.py
+++ b/modules/imdb.py
@@ -8,9 +8,9 @@ URL_IMDBTITLE = "http://imdb.com/title/%s"
 
 class Module(object):
     _name = "IMDb"
-    def __init__(self, bot):
+    def __init__(self, bot, events):
         self.bot = bot
-        bot.events.on("received").on("command").on("imdb").hook(
+        events.on("received").on("command").on("imdb").hook(
             self.imdb, min_args=1,
             help="Search for a given title on IMDb",
             usage="<movie/tv title>")
diff --git a/modules/in.py b/modules/in.py
index 4f4aef51..2ac6a9bc 100644
--- a/modules/in.py
+++ b/modules/in.py
@@ -5,12 +5,12 @@ SECONDS_MAX = Utils.SECONDS_WEEKS*8
 SECONDS_MAX_DESCRIPTION = "8 weeks"
 
 class Module(object):
-    def __init__(self, bot):
+    def __init__(self, bot, events):
         self.bot = bot
-        bot.events.on("received").on("command").on("in").hook(
+        events.on("received").on("command").on("in").hook(
             self.in_command, min_args=2,
             help="Set a reminder", usage="<time> <message>")
-        bot.events.on("timer").on("in").hook(self.timer_due)
+        events.on("timer").on("in").hook(self.timer_due)
 
     def in_command(self, event):
         seconds = Utils.from_pretty_time(event["args_split"][0])
diff --git a/modules/join.py b/modules/join.py
index 3a95d1c7..1596e020 100644
--- a/modules/join.py
+++ b/modules/join.py
@@ -1,8 +1,8 @@
 
 
 class Module(object):
-	def __init__(self, bot):
-		bot.events.on("received").on("numeric").on("001").hook(self.do_join)
+    def __init__(self, bot, events):
+        events.on("received").on("numeric").on("001").hook(self.do_join)
 
-	def do_join(self, event):
-		event["server"].send_join("#bitbot")
+    def do_join(self, event):
+        event["server"].send_join("#bitbot")
diff --git a/modules/karma.py b/modules/karma.py
index e92b2c60..40911e1b 100644
--- a/modules/karma.py
+++ b/modules/karma.py
@@ -5,20 +5,21 @@ REGEX_KARMA = re.compile("(.*)(\+{2,}|\-{2,})$")
 KARMA_DELAY_SECONDS = 3
 
 class Module(object):
-    def __init__(self, bot):
+    def __init__(self, bot, events):
         self.bot = bot
-        bot.events.on("new").on("user").hook(self.new_user)
-        bot.events.on("received").on("message").on("channel").hook(
+        self.events = events
+        events.on("new").on("user").hook(self.new_user)
+        events.on("received").on("message").on("channel").hook(
             self.channel_message)
-        bot.events.on("received").on("command").on("karma").hook(
+        events.on("received").on("command").on("karma").hook(
             self.karma, help="Get your or someone else's karma",
             usage="[target]")
-        bot.events.on("received").on("command").on("resetkarma").hook(
+        events.on("received").on("command").on("resetkarma").hook(
             self.reset_karma, permission="resetkarma",
             min_args=1, help="Reset a specified karma to 0",
             usage="<target>")
 
-        bot.events.on("postboot").on("configure").on(
+        events.on("postboot").on("configure").on(
             "channelset").assure_call(setting="karma-verbose",
             help="Disable/Enable automatically responding to karma changes",
             validate=Utils.bool_or_none)
@@ -46,13 +47,13 @@ class Module(object):
                     else:
                         event["server"].del_setting(setting)
                     if verbose:
-                        self.bot.events.on("send").on("stdout").call(
+                        self.events.on("send").on("stdout").call(
                             module_name="Karma", target=event["channel"],
                             message="%s now has %d karma" % (target, karma))
                     event["user"].last_karma = time.time()
                 elif verbose:
                     if target:
-                        self.bot.events.on("send").on("stderr").call(module_name="Karma",
+                        self.events.on("send").on("stderr").call(module_name="Karma",
                             target=event["channel"], message="You cannot change your own karma")
             elif verbose:
                 event["stderr"].write("Try again in a couple of seconds")
diff --git a/modules/lastfm.py b/modules/lastfm.py
index e8a2545e..328a79a6 100644
--- a/modules/lastfm.py
+++ b/modules/lastfm.py
@@ -5,14 +5,14 @@ import Utils
 URL_SCROBBLER = "http://ws.audioscrobbler.com/2.0/"
 
 class Module(object):
-    def __init__(self, bot):
+    def __init__(self, bot, events):
         self.bot = bot
 
-        bot.events.on("postboot").on("configure").on(
+        events.on("postboot").on("configure").on(
             "set").assure_call(setting="lastfm",
             help="Set username on last.fm")
 
-        bot.events.on("received").on("command").on("np",
+        events.on("received").on("command").on("np",
             "listening", "nowplaying").hook(self.np,
             help="Get the last listened to track from a user",
             usage="[username]")
diff --git a/modules/nickname_aliases.py b/modules/nickname_aliases.py
index 22af8d8c..a77cd926 100644
--- a/modules/nickname_aliases.py
+++ b/modules/nickname_aliases.py
@@ -22,13 +22,13 @@ def del_setting(user, setting):
 
 class Module(object):
     _name = "Aliases"
-    def __init__(self, bot):
+    def __init__(self, bot, events):
         self.bot = bot
-        bot.events.on("new").on("user").hook(self.new_user)
-        bot.events.on("received").on("nick").hook(self.nickname_change)
-        bot.events.on("received").on("command").on("alias").hook(
+        events.on("new").on("user").hook(self.new_user)
+        events.on("received").on("nick").hook(self.nickname_change)
+        events.on("received").on("command").on("alias").hook(
             self.alias)
-        #bot.events.on("received").on("command").on("mainalias").hook(
+        #events.on("received").on("command").on("mainalias").hook(
         #    self.main_alias)
 
     def new_user(self, event):
diff --git a/modules/nickserv.py b/modules/nickserv.py
index 7abd67e3..779bc955 100644
--- a/modules/nickserv.py
+++ b/modules/nickserv.py
@@ -2,10 +2,10 @@ import base64
 import EventManager
 
 class Module(object):
-    def __init__(self, bot):
-        bot.events.on("received").on("numeric").on("001"
+    def __init__(self, bot, events):
+        events.on("received").on("numeric").on("001"
             ).hook(self.on_connect, priority=EventManager.PRIORITY_URGENT)
-        bot.events.on("received").on("command").on("setnickserv"
+        events.on("received").on("command").on("setnickserv"
             ).hook(self.set_nickserv, min_args=1, permission="setnickserv",
             help="Set bot's nickserv password", usage="<password>",
             private_only=True)
diff --git a/modules/nr.py b/modules/nr.py
index 7716b567..59df34c6 100644
--- a/modules/nr.py
+++ b/modules/nr.py
@@ -20,29 +20,29 @@ class Module(object):
     PASSENGER_ACTIVITIES = ["U", "P", "R"]
     COLOURS = [Utils.COLOR_LIGHTBLUE, Utils.COLOR_GREEN, Utils.COLOR_RED, Utils.COLOR_CYAN, Utils.COLOR_LIGHTGREY, Utils.COLOR_ORANGE]
 
-    def __init__(self, bot):
+    def __init__(self, bot, events):
         self.bot = bot
         self._client = None
-        bot.events.on("received").on("command").on("nrtrains"
+        events.on("received").on("command").on("nrtrains"
             ).hook(self.trains, min_args=1,
             help="Get train/bus services for a station (Powered by NRE)",
             usage="<crs_id>")
-        bot.events.on("received").on("command").on("nrservice"
+        events.on("received").on("command").on("nrservice"
             ).hook(self.service, min_args=1,
             help="Get train service information for a UID, headcode or RID (Powered by NRE)",
             usage="<service_id>")
-        bot.events.on("received").on("command").on("nrhead"
+        events.on("received").on("command").on("nrhead"
             ).hook(self.head, min_args=1,
             help="Get information for a given headcode/UID/RID (Powered by NRE)",
             usage="<headcode>")
-        bot.events.on("received").on("command").on("nrcode"
+        events.on("received").on("command").on("nrcode"
             ).hook(self.service_code, min_args=1,
             help="Get the text for a given delay/cancellation code (Powered by NRE)",
             usage="<code>")
-        bot.events.on("telegram").on("command").on("nrtrains").hook(self.trains)
-        bot.events.on("telegram").on("command").on("nrcode").hook(self.service_code)
-        bot.events.on("telegram").on("command").on("nrhead").hook(self.head)
-        bot.events.on("telegram").on("command").on("nrservice").hook(self.service)
+        events.on("telegram").on("command").on("nrtrains").hook(self.trains)
+        events.on("telegram").on("command").on("nrcode").hook(self.service_code)
+        events.on("telegram").on("command").on("nrhead").hook(self.head)
+        events.on("telegram").on("command").on("nrservice").hook(self.service)
 
     @property
     def client(self):
diff --git a/modules/perform.py b/modules/perform.py
index 65d0eb23..224efdcb 100644
--- a/modules/perform.py
+++ b/modules/perform.py
@@ -1,8 +1,8 @@
 import EventManager
 
 class Module(object):
-    def __init__(self, bot):
-        bot.events.on("received").on("numeric").on("001").hook(
+    def __init__(self, bot, events):
+        events.on("received").on("numeric").on("001").hook(
             self.on_connect, priority=EventManager.PRIORITY_URGENT)
 
     def on_connect(self, event):
diff --git a/modules/permissions.py b/modules/permissions.py
index 23eb4dbf..e23a230e 100644
--- a/modules/permissions.py
+++ b/modules/permissions.py
@@ -5,26 +5,26 @@ REQUIRES_IDENTIFY = ("You need to be identified to use that command "
  "(/msg %s register | /msg %s identify)")
 
 class Module(object):
-    def __init__(self, bot):
+    def __init__(self, bot, events):
         self.bot = bot
-        bot.events.on("new").on("user").hook(self.new_user)
-        bot.events.on("preprocess").on("command").hook(
+        events.on("new").on("user").hook(self.new_user)
+        events.on("preprocess").on("command").hook(
             self.preprocess_command)
-        bot.events.on("received").on("part").hook(self.on_part)
-        bot.events.on("received").on("command").on("identify"
+        events.on("received").on("part").hook(self.on_part)
+        events.on("received").on("command").on("identify"
             ).hook(self.identify, private_only=True, min_args=1,
             usage="<password>", help="Identify yourself")
-        bot.events.on("received").on("command").on("register"
+        events.on("received").on("command").on("register"
             ).hook(self.register, private_only=True, min_args=1,
             usage="<password>", help="Register your nickname")
-        bot.events.on("received.command.logout").hook(self.logout,
+        events.on("received.command.logout").hook(self.logout,
              private_only=True, help="Sign out from the bot")
 
-        bot.events.on("received.command.mypermissions").hook(
+        events.on("received.command.mypermissions").hook(
             self.my_permissions, authenticated=True)
-        bot.events.on("received.command.givepermission").hook(
+        events.on("received.command.givepermission").hook(
             self.give_permission, min_args=2, permission="givepermission")
-        bot.events.on("received.command.removepermission").hook(
+        events.on("received.command.removepermission").hook(
             self.remove_permission, min_args=2, permission="removepermission")
 
     def new_user(self, event):
diff --git a/modules/pong.py b/modules/pong.py
index 7090b79f..4feb35f1 100644
--- a/modules/pong.py
+++ b/modules/pong.py
@@ -1,9 +1,8 @@
 
 
 class Module(object):
-    def __init__(self, bot):
-        bot.events.on("received.command.ping").hook(
-            self.pong, help="Ping pong!")
+    def __init__(self, bot, events):
+        events.on("received.command.ping").hook(self.pong, help="Ping pong!")
 
     def pong(self, event):
         event["stdout"].write("Pong!")
diff --git a/modules/print_activity.py b/modules/print_activity.py
index 8ec55026..48495b46 100644
--- a/modules/print_activity.py
+++ b/modules/print_activity.py
@@ -2,37 +2,37 @@ import datetime
 import EventManager
 
 class Module(object):
-    def __init__(self, bot):
+    def __init__(self, bot, events):
         self.bot = bot
 
-        bot.events.on("received").on("message").on("channel").hook(
+        events.on("received").on("message").on("channel").hook(
             self.channel_message, priority=EventManager.PRIORITY_HIGH)
-        bot.events.on("self").on("message").on("channel").hook(
+        events.on("self").on("message").on("channel").hook(
             self.self_channel_message)
 
-        bot.events.on("received").on("notice").on("channel").hook(
+        events.on("received").on("notice").on("channel").hook(
             self.channel_notice, priority=EventManager.PRIORITY_HIGH)
-        bot.events.on("received").on("notice").on("private").hook(
+        events.on("received").on("notice").on("private").hook(
             self.private_notice, priority=EventManager.PRIORITY_HIGH)
-        bot.events.on("received").on("server-notice").hook(
+        events.on("received").on("server-notice").hook(
             self.server_notice, priority=EventManager.PRIORITY_HIGH)
 
-        bot.events.on("received").on("join").hook(self.join)
-        bot.events.on("self").on("join").hook(self.self_join)
+        events.on("received").on("join").hook(self.join)
+        events.on("self").on("join").hook(self.self_join)
 
-        bot.events.on("received").on("part").hook(self.part)
-        bot.events.on("self").on("part").hook(self.self_part)
+        events.on("received").on("part").hook(self.part)
+        events.on("self").on("part").hook(self.self_part)
 
-        bot.events.on("received").on("nick").hook(self.on_nick)
-        bot.events.on("self").on("nick").hook(self.on_nick)
+        events.on("received").on("nick").hook(self.on_nick)
+        events.on("self").on("nick").hook(self.on_nick)
 
-        bot.events.on("received").on("quit").hook(self.on_quit)
+        events.on("received").on("quit").hook(self.on_quit)
 
-        bot.events.on("received").on("kick").hook(self.kick)
-        bot.events.on("self").on("kick").hook(self.self_kick)
+        events.on("received").on("kick").hook(self.kick)
+        events.on("self").on("kick").hook(self.self_kick)
 
-        bot.events.on("received").on("topic").hook(self.on_topic)
-        bot.events.on("received").on("numeric").on("333").hook(self.on_333)
+        events.on("received").on("topic").hook(self.on_topic)
+        events.on("received").on("numeric").on("333").hook(self.on_333)
 
     def print_line(self, event, line, channel=None):
         timestamp = datetime.datetime.now().isoformat()
diff --git a/modules/quit.py b/modules/quit.py
index b41bb143..1658aa0e 100644
--- a/modules/quit.py
+++ b/modules/quit.py
@@ -55,8 +55,8 @@ QUOTES = {
 }
 
 class Module(object):
-    def __init__(self, bot):
-        bot.events.on("get.quit-quote").hook(self.quote)
+    def __init__(self, bot, events):
+        events.on("get.quit-quote").hook(self.quote)
 
     def quote(self, event):
         quote = random.choice(list(QUOTES.items()))
diff --git a/modules/quotes.py b/modules/quotes.py
index d09bba58..69b1d79b 100644
--- a/modules/quotes.py
+++ b/modules/quotes.py
@@ -1,21 +1,21 @@
 import random, time
 
 class Module(object):
-    def __init__(self, bot):
+    def __init__(self, bot, events):
         self.bot = bot
-        bot.events.on("received").on("command").on("quoteadd",
+        events.on("received").on("command").on("quoteadd",
             "qadd").hook(self.quote_add, min_args=1,
             help="Added a quote to a category",
             usage="<category> = <quote>")
-        bot.events.on("received").on("command").on("quoteget",
+        events.on("received").on("command").on("quoteget",
             "qget").hook(self.quote_get, min_args=1,
             help="Find a quote within a category",
             usage="<category> = <search>")
-        bot.events.on("received").on("command").on("quotedel",
+        events.on("received").on("command").on("quotedel",
             "qdel").hook(self.quote_del, min_args=1,
             help="Delete a quote from a category",
             usage="<category> = <quote>")
-        bot.events.on("received").on("command").on("quote",
+        events.on("received").on("command").on("quote",
             "q").hook(self.quote, min_args=1,
             help="Get a random quote from a category",
             usage="<category>")
diff --git a/modules/random_number.py b/modules/random_number.py
index 170ba1bb..14cc6da7 100644
--- a/modules/random_number.py
+++ b/modules/random_number.py
@@ -2,11 +2,11 @@ import random, uuid
 
 class Module(object):
     _name = "Random"
-    def __init__(self, bot):
-        bot.events.on("received").on("command").on("random",
+    def __init__(self, bot, events):
+        events.on("received").on("command").on("random",
             "rand").hook(self.random, help="Get a random number",
             usage="[start] [end]")
-        bot.events.on("received").on("command").on("guid"
+        events.on("received").on("command").on("guid"
             ).hook(self.guid, help="Get a random guid")
 
     def random(self, event):
diff --git a/modules/sasl.py b/modules/sasl.py
index 7889640e..b9219292 100644
--- a/modules/sasl.py
+++ b/modules/sasl.py
@@ -1,12 +1,12 @@
 import base64
 
 class Module(object):
-    def __init__(self, bot):
+    def __init__(self, bot, events):
         self.bot = bot
-        bot.events.on("preprocess.connect").hook(self.preprocess_connect)
-        bot.events.on("received.cap").hook(self.on_cap)
-        bot.events.on("received.authenticate").hook(self.on_authenticate)
-        bot.events.on("received.numeric").on(
+        events.on("preprocess.connect").hook(self.preprocess_connect)
+        events.on("received.cap").hook(self.on_cap)
+        events.on("received.authenticate").hook(self.on_authenticate)
+        events.on("received.numeric").on(
             "902", "903", "904", "905", "906", "907", "908").hook(self.on_90x)
 
     def preprocess_connect(self, event):
diff --git a/modules/sed.py b/modules/sed.py
index 5c2d7ea4..c276d4d1 100644
--- a/modules/sed.py
+++ b/modules/sed.py
@@ -5,16 +5,17 @@ REGEX_SPLIT = re.compile("(?<!\\\\)/")
 REGEX_SED = re.compile("^s/")
 
 class Module(object):
-    def __init__(self, bot):
+    def __init__(self, bot, events):
         self.bot = bot
-        bot.events.on("received").on("message").on("channel").hook(
+        self.events = events
+        events.on("received").on("message").on("channel").hook(
             self.channel_message)
 
-        bot.events.on("postboot").on("configure").on(
+        events.on("postboot").on("configure").on(
             "channelset").assure_call(setting="sed",
             help="Disable/Enable sed in a channel",
             validate=Utils.bool_or_none)
-        bot.events.on("postboot").on("configure").on(
+        events.on("postboot").on("configure").on(
             "channelset").assure_call(setting="sed-sender-only",
             help="Disable/Enable sed only looking at the messages "
             "sent by the user", validate=Utils.bool_or_none)
@@ -49,7 +50,7 @@ class Module(object):
                 pattern = re.compile(sed_split[1], regex_flags)
             except:
                 traceback.print_exc()
-                self.bot.events.on("send").on("stderr").call(target=event[
+                self.events.on("send").on("stderr").call(target=event[
                     "channel"], module_name="Sed", server=event["server"],
                     message="Invalid regex in pattern")
                 return
@@ -66,6 +67,6 @@ class Module(object):
                     prefix = "* %s" % line.sender
                 else:
                     prefix = "<%s>" % line.sender
-                self.bot.events.on("send").on("stdout").call(target=event[
+                self.events.on("send").on("stdout").call(target=event[
                     "channel"], module_name="Sed", server=event["server"],
                     message="%s %s" % (prefix, new_message))
diff --git a/modules/seen.py b/modules/seen.py
index 750b06e4..222d30b5 100644
--- a/modules/seen.py
+++ b/modules/seen.py
@@ -2,10 +2,10 @@ import time
 import Utils
 
 class Module(object):
-    def __init__(self, bot):
-        bot.events.on("received").on("message").on("channel"
+    def __init__(self, bot, events):
+        events.on("received").on("message").on("channel"
             ).hook(self.channel_message)
-        bot.events.on("received").on("command").on("seen").hook(
+        events.on("received").on("command").on("seen").hook(
             self.seen, min_args=1,
             help="Find out when a user was last seen",
             usage="<username>")
diff --git a/modules/set.py b/modules/set.py
index 0f73d70c..23abea9b 100644
--- a/modules/set.py
+++ b/modules/set.py
@@ -1,31 +1,32 @@
 
 
 class Module(object):
-    def __init__(self, bot):
+    def __init__(self, bot, events):
         self.bot = bot
         self.settings = {}
         self.channel_settings = {}
-        bot.events.on("postboot").on("configure").on("set").hook(
+
+        events.on("postboot").on("configure").on("set").hook(
             self.postboot_set, replay=True)
-        bot.events.on("postboot").on("configure").on("channelset"
+        events.on("postboot").on("configure").on("channelset"
             ).hook(self.postboot_channelset, replay=True)
 
-        bot.events.on("received").on("command").on("set").hook(
+        events.on("received").on("command").on("set").hook(
             self.set, help="Set a specified user setting",
             usage="<setting> <value>")
-        bot.events.on("received").on("command").on("get").hook(
+        events.on("received").on("command").on("get").hook(
             self.get, help="Get a specified user setting",
             usage="<setting>", min_args=1)
 
-        bot.events.on("received").on("command").on("channelset"
+        events.on("received").on("command").on("channelset"
             ).hook(self.channel_set, channel_only=True,
             help="Set a specified setting for the current channel",
             usage="<setting> <value>", require_mode="o")
-        bot.events.on("received").on("command").on("channelsetoverride"
+        events.on("received").on("command").on("channelsetoverride"
             ).hook(self.channel_set, channel_only=True,
             help="Set a specified setting for the current channel",
             usage="<setting> <value>", permission="channelsetoverride")
-        bot.events.on("received").on("command").on("channelget"
+        events.on("received").on("command").on("channelget"
             ).hook(self.channel_get, channel_only=True,
             help="Get a specified setting for the current channel",
             usage="<setting>", min_args=1, require_mode="o")
diff --git a/modules/signals.py b/modules/signals.py
index 3ab6966a..cbc22429 100644
--- a/modules/signals.py
+++ b/modules/signals.py
@@ -1,19 +1,21 @@
 import signal
 
 class Module(object):
-    def __init__(self, bot):
+    def __init__(self, bot, events):
         self.bot = bot
+        self.events = events
         signal.signal(signal.SIGINT, self.SIGINT)
         signal.signal(signal.SIGUSR1, self.SIGUSR1)
 
     def SIGINT(self, signum, frame):
         print()
-        self.bot.events.on("signal").on("interrupt").call(signum=signum, frame=frame)
+        self.events.on("signal").on("interrupt").call(signum=signum,
+            frame=frame)
 
         for server in self.bot.servers.values():
             reason = "Leaving"
             if server.get_setting("quit-quote", True):
-                reason = self.bot.events.on("get.quit-quote"
+                reason = self.events.on("get.quit-quote"
                     ).call_for_result(default="Leaving")
             server.send_quit(reason)
             self.bot.register_write(server)
diff --git a/modules/soundcloud.py b/modules/soundcloud.py
index 2bdd4276..c8481043 100644
--- a/modules/soundcloud.py
+++ b/modules/soundcloud.py
@@ -9,9 +9,9 @@ REGEX_SOUNDCLOUD = "https?://soundcloud.com/([^/]+)/([^/]+)"
 
 class Module(object):
     _name = "SoundCloud"
-    def __init__(self, bot):
+    def __init__(self, bot, events):
         self.bot = bot
-        bot.events.on("received").on("command").on("soundcloud", "sc"
+        events.on("received").on("command").on("soundcloud", "sc"
             ).hook(self.soundcloud, help="Search SoundCloud")
 
     def soundcloud(self, event):
diff --git a/modules/spotify.py b/modules/spotify.py
index 64ba2c2f..31040135 100644
--- a/modules/spotify.py
+++ b/modules/spotify.py
@@ -4,8 +4,8 @@ import Utils
 URL_SPOTIFY = "https://api.spotify.com/v1/search"
 
 class Module(object):
-    def __init__(self, bot):
-        bot.events.on("received").on("command").on("spotify").hook(
+    def __init__(self, bot, events):
+        events.on("received").on("command").on("spotify").hook(
             self.spotify, help="Search for a track on spotify",
             min_args=1)
 
diff --git a/modules/stats.py b/modules/stats.py
index 09468327..7ba19e43 100644
--- a/modules/stats.py
+++ b/modules/stats.py
@@ -2,12 +2,12 @@ import time
 import Utils
 
 class Module(object):
-    def __init__(self, bot):
+    def __init__(self, bot, events):
         self.boot_time = time.time()
         self.bot = bot
-        bot.events.on("received").on("command").on("uptime"
+        events.on("received").on("command").on("uptime"
             ).hook(self.uptime, help="Show my uptime")
-        bot.events.on("received").on("command").on("stats"
+        events.on("received").on("command").on("stats"
             ).hook(self.stats, help="Show my network/channel/user stats")
 
     def uptime(self, event):
diff --git a/modules/strax.py b/modules/strax.py
index 144d729a..26cecd07 100644
--- a/modules/strax.py
+++ b/modules/strax.py
@@ -2,8 +2,8 @@ import random
 
 
 class Module(object):
-    def __init__(self, bot):
-        bot.events.on("received.command.strax").hook(
+    def __init__(self, bot, events):
+        events.on("received.command.strax").hook(
             self.strax, help="Suggests a glorious method of battle for the glory of the Sontaran Empire, through IRC!")
 
     def strax(self, event):
diff --git a/modules/telegram.py b/modules/telegram.py
index cecbd16e..5639666b 100644
--- a/modules/telegram.py
+++ b/modules/telegram.py
@@ -8,11 +8,12 @@ from threading import Thread
 class Module(Thread):
     _name = "telegram"
 
-    def __init__(self, dolphin):
-        key = dolphin.config.get("telegram-api-key")
+    def __init__(self, bot, events):
+        key = bot.config.get("telegram-api-key")
         if not key: return
 
-        self.dolphin = dolphin
+        self.bot = bot
+        self.events = events
 
         self.updater = Updater(key)
         self.dispatcher = self.updater.dispatcher
@@ -23,7 +24,7 @@ class Module(Thread):
         self.dispatcher.add_handler(command_handler)
 
         self.updater.start_polling()
-        dolphin.events.on("signal").on("interrupt").hook(self.sigint)
+        events.on("signal").on("interrupt").hook(self.sigint)
 
     def start(self, bot, update):
         bot.send_message(chat_id=update.message.chat_id, text="`Dolphin, but Telegram`", parse_mode="Markdown")
@@ -45,7 +46,7 @@ class Module(Thread):
             "stderr": IOWrapper(bot, message.chat_id, message.message_id),
             "external": True,
             }
-        self.dolphin.events.on("telegram").on("command").on(command).call(**data)
+        self.events.on("telegram").on("command").on(command).call(**data)
 
     def sigint(self, event):
         self.updater.stop()
diff --git a/modules/tfl.py b/modules/tfl.py
index 2a017f1d..72862db6 100644
--- a/modules/tfl.py
+++ b/modules/tfl.py
@@ -20,30 +20,30 @@ PLATFORM_TYPES = ["Northbound", "Southbound", "Eastbound", "Westbound", "Inner R
 
 class Module(object):
     _name = "TFL"
-    def __init__(self, bot):
+    def __init__(self, bot, events):
         self.bot = bot
         self.result_map = {}
-        bot.events.on("received").on("command").on("tflbus"
+        events.on("received").on("command").on("tflbus"
             ).hook(self.bus, min_args=1,
             help="Get bus due times for a TfL bus stop",
             usage="<stop_id>")
-        bot.events.on("received").on("command").on("tflline"
+        events.on("received").on("command").on("tflline"
             ).hook(self.line,
             help="Get line status for TfL underground lines",
             usage="<line_name>")
-        bot.events.on("received").on("command").on("tflsearch"
+        events.on("received").on("command").on("tflsearch"
             ).hook(self.search, min_args=1,
             help="Get a list of TfL stop IDs for a given name",
             usage="<name>")
-        bot.events.on("received").on("command").on("tflvehicle"
+        events.on("received").on("command").on("tflvehicle"
             ).hook(self.vehicle, min_args=1,
             help="Get information for a given vehicle",
             usage="<ID>")
-        bot.events.on("received").on("command").on("tflstop"
+        events.on("received").on("command").on("tflstop"
             ).hook(self.stop, min_args=1,
             help="Get information for a given stop",
             usage="<stop_id>")
-        bot.events.on("received").on("command").on("tflservice"
+        events.on("received").on("command").on("tflservice"
             ).hook(self.service, min_args=1,
             help="Get service information and arrival estimates",
             usage="<service index>")
diff --git a/modules/thesaurus.py b/modules/thesaurus.py
index 2580c191..6f91cec4 100644
--- a/modules/thesaurus.py
+++ b/modules/thesaurus.py
@@ -5,9 +5,9 @@ import Utils
 URL_THESAURUS = "http://words.bighugelabs.com/api/2/%s/%s/json"
 
 class Module(object):
-    def __init__(self, bot):
+    def __init__(self, bot, events):
         self.bot = bot
-        bot.events.on("received").on("command").on("synonym",
+        events.on("received").on("command").on("synonym",
             "antonym").hook(self.thesaurus, min_args=1,
             help="Get synonyms/antonyms for a provided phrase",
             usage="<word> [type]")
diff --git a/modules/title.py b/modules/title.py
index df19a6ec..7852f64c 100644
--- a/modules/title.py
+++ b/modules/title.py
@@ -4,30 +4,30 @@ import Utils
 REGEX_URL = re.compile("https?://\S+", re.I)
 
 class Module(object):
-	def __init__(self, bot):
-		bot.events.on("received").on("command").on("title", "t").hook(
-			self.title, help="Get the title of the provided or most "
+    def __init__(self, bot, events):
+        events.on("received").on("command").on("title", "t").hook(
+            self.title, help="Get the title of the provided or most "
             "recent URL.", usage="[URL]")
 
-	def title(self, event):
-		url = None
-		if len(event["args"]) > 0:
-			url = event["args_split"][0]
-		else:
-			url = event["buffer"].find(REGEX_URL)
-			if url:
-				url = re.search(REGEX_URL, url.message).group(0)
-		if not url:
-			event["stderr"].write("No URL provided/found.")
-			return
-		soup = Utils.get_url(url, soup=True)
-		if not soup:
-			event["stderr"].write("Failed to get URL.")
-			return
-		title = soup.title
-		if title:
-			title = title.text.replace("\n", " ").replace("\r", ""
-				).replace("  ", " ").strip()
-			event["stdout"].write(title)
-		else:
-			event["stderr"].write("No title found.")
+    def title(self, event):
+        url = None
+        if len(event["args"]) > 0:
+            url = event["args_split"][0]
+        else:
+            url = event["buffer"].find(REGEX_URL)
+            if url:
+                url = re.search(REGEX_URL, url.message).group(0)
+        if not url:
+            event["stderr"].write("No URL provided/found.")
+            return
+        soup = Utils.get_url(url, soup=True)
+        if not soup:
+            event["stderr"].write("Failed to get URL.")
+            return
+        title = soup.title
+        if title:
+            title = title.text.replace("\n", " ").replace("\r", ""
+                ).replace("  ", " ").strip()
+            event["stdout"].write(title)
+        else:
+            event["stderr"].write("No title found.")
diff --git a/modules/to.py b/modules/to.py
index 24009efd..89abc477 100644
--- a/modules/to.py
+++ b/modules/to.py
@@ -1,11 +1,11 @@
 import EventManager
 
 class Module(object):
-    def __init__(self, bot):
-        bot.events.on("received").on("message").on("channel"
+    def __init__(self, bot, events):
+        events.on("received").on("message").on("channel"
             ).hook(self.channel_message,
             priority=EventManager.PRIORITY_MEDIUM)
-        bot.events.on("received").on("command").on("to").hook(
+        events.on("received").on("command").on("to").hook(
             self.to, min_args=2, help=("Relay a message to a "
             "user the next time they talk in a channel"),
             channel_only=True, usage="<username> <message>")
diff --git a/modules/todo.py b/modules/todo.py
index 2224bbb2..8c1ead32 100644
--- a/modules/todo.py
+++ b/modules/todo.py
@@ -1,15 +1,15 @@
 
 
 class Module(object):
-    def __init__(self, bot):
+    def __init__(self, bot, events):
         self.bot = bot
-        bot.events.on("received").on("command").on("todo").hook(
+        events.on("received").on("command").on("todo").hook(
             self.todo, help="Find out what's in your todo list",
             usage="[item number]")
-        bot.events.on("received").on("command").on("todoadd").hook(
+        events.on("received").on("command").on("todoadd").hook(
             self.todo_add, min_args=1, help="Add something to your todo list",
             usage="<description>")
-        bot.events.on("received").on("command").on("tododel").hook(
+        events.on("received").on("command").on("tododel").hook(
             self.todo_del, min_args=1, help="Remove something from your "
             "todo list", usage="<item number>")
 
diff --git a/modules/trakt.py b/modules/trakt.py
index b3c36d3d..3f8f2019 100644
--- a/modules/trakt.py
+++ b/modules/trakt.py
@@ -6,14 +6,14 @@ URL_TRAKT = "https://api-v2launch.trakt.tv/users/%s/watching"
 URL_TRAKTSLUG = "https://trakt.tv/%s/%s"
 
 class Module(object):
-    def __init__(self, bot):
+    def __init__(self, bot, events):
         self.bot = bot
-        bot.events.on("received").on("command").on("nowwatching",
+        events.on("received").on("command").on("nowwatching",
             "nw").hook(self.now_watching,
             help="Get what you or another user is now watching "
             "on trakt.tv", usage="[username]")
 
-        bot.events.on("postboot").on("configure").on("set"
+        events.on("postboot").on("configure").on("set"
             ).assure_call(setting="trakt", help="Set username on trakt.tv")
 
     def now_watching(self, event):
diff --git a/modules/translate.py b/modules/translate.py
index a4b72785..bcc8830b 100644
--- a/modules/translate.py
+++ b/modules/translate.py
@@ -6,8 +6,8 @@ URL_LANGUAGES = "https://cloud.google.com/translate/docs/languages"
 REGEX_LANGUAGES = re.compile("(\w+)?:(\w+)? ")
 
 class Module(object):
-    def __init__(self, bot):
-        bot.events.on("received").on("command").on("translate", "tr").hook(
+    def __init__(self, bot, events):
+        events.on("received").on("command").on("translate", "tr").hook(
             self.translate, help="Translate the provided phrase or the "
             "last line seen.", usage="[phrase]")
 
diff --git a/modules/twitter.py b/modules/twitter.py
index d5b451db..84f63137 100644
--- a/modules/twitter.py
+++ b/modules/twitter.py
@@ -11,9 +11,9 @@ REGEX_TWITTERURL = re.compile(
     "https?://(?:www\.)?twitter.com/[^/]+/status/(\d+)", re.I)
 
 class Module(object):
-    def __init__(self, bot):
+    def __init__(self, bot, events):
         self.bot = bot
-        bot.events.on("received").on("command").on("twitter", "tw"
+        events.on("received").on("command").on("twitter", "tw"
             ).hook(self.twitter, help="Find a tweet",
             usage="[@username/URL/ID]")
 
diff --git a/modules/upc.py b/modules/upc.py
index 37588481..720dfa49 100644
--- a/modules/upc.py
+++ b/modules/upc.py
@@ -4,9 +4,9 @@ UPCITEMDB_URL = "https://api.upcitemdb.com/prod/trial/lookup"
 
 class Module(object):
     _name = "UPC"
-    def __init__(self, bot):
+    def __init__(self, bot, events):
         self.bot = bot
-        bot.events.on("received").on("command").on(
+        events.on("received").on("command").on(
             "upc", "ean", "gtin").hook(
             self.upc, min_args=1, usage="<UPC|EAN>",
             help="Look up a product by UPC or EAN")
diff --git a/modules/urbandictionary.py b/modules/urbandictionary.py
index d2bcc441..cd5e87e2 100644
--- a/modules/urbandictionary.py
+++ b/modules/urbandictionary.py
@@ -5,8 +5,8 @@ URL_URBANDICTIONARY = "http://api.urbandictionary.com/v0/define"
 REGEX_DEFNUMBER = re.compile("-n(\d+) \S+")
 
 class Module(object):
-    def __init__(self, bot):
-        bot.events.on("received").on("command").on("urbandictionary", "ud"
+    def __init__(self, bot, events):
+        events.on("received").on("command").on("urbandictionary", "ud"
             ).hook(self.ud, min_args=1,
             help="Get the definition of a provided term",
             usage="<term>")
diff --git a/modules/weather.py b/modules/weather.py
index 53fce200..20630ab4 100644
--- a/modules/weather.py
+++ b/modules/weather.py
@@ -5,9 +5,9 @@ import Utils
 URL_WEATHER = "http://api.openweathermap.org/data/2.5/weather"
 
 class Module(object):
-    def __init__(self, bot):
+    def __init__(self, bot, events):
         self.bot = bot
-        bot.events.on("received").on("command").on("weather").hook(
+        events.on("received").on("command").on("weather").hook(
             self.weather, min_args=1,
             help="Get current weather data for a provided location",
             usage="<location>")
diff --git a/modules/wikipedia.py b/modules/wikipedia.py
index 98f61714..4d1585fe 100644
--- a/modules/wikipedia.py
+++ b/modules/wikipedia.py
@@ -3,9 +3,9 @@ import Utils
 URL_WIKIPEDIA = "https://en.wikipedia.org/w/api.php"
 
 class Module(object):
-    def __init__(self, bot):
+    def __init__(self, bot, events):
         self.bot = bot
-        bot.events.on("received").on("command").on("wiki", "wi"
+        events.on("received").on("command").on("wiki", "wi"
             ).hook(self.wikipedia, min_args=1)
 
     def wikipedia(self, event):
diff --git a/modules/wolframalpha.py b/modules/wolframalpha.py
index 059408d7..32de1e58 100644
--- a/modules/wolframalpha.py
+++ b/modules/wolframalpha.py
@@ -8,12 +8,12 @@ REGEX_CHARHEX = re.compile("\\\\:(\S{4})")
 
 class Module(object):
     _name = "Wolfram|Alpha"
-    def __init__(self, bot):
-        bot.events.on("received").on("command").on("wolframalpha", "wa"
+    def __init__(self, bot, events):
+        self.bot = bot
+        events.on("received").on("command").on("wolframalpha", "wa"
             ).hook(self.wa, min_args=1, help=
             "Evauate a given string on Wolfram|Alpha",
             usage="<query>")
-        self.bot = bot
 
     def wa(self, event):
         soup = Utils.get_url(URL_WA, get_params={"input": event["args"],
diff --git a/modules/words.py b/modules/words.py
index 502bee3b..1cb432b0 100644
--- a/modules/words.py
+++ b/modules/words.py
@@ -2,21 +2,21 @@ import time
 import Utils
 
 class Module(object):
-    def __init__(self, bot):
+    def __init__(self, bot, events):
         self.bot = bot
-        bot.events.on("received").on("message").on("channel"
+        events.on("received").on("message").on("channel"
             ).hook(self.channel_message)
-        bot.events.on("self").on("message").on("channel"
+        events.on("self").on("message").on("channel"
             ).hook(self.self_channel_message)
-        bot.events.on("received").on("command").on("words"
+        events.on("received").on("command").on("words"
             ).hook(self.words, channel_only=True,
             usage="<nickname>", help=
             "See how many words you or the given nickname have used")
-        bot.events.on("received").on("command").on("trackword"
+        events.on("received").on("command").on("trackword"
             ).hook(self.track_word, min_args=1,
             help="Start tracking a word", usage="<word>",
             permission="track-word")
-        bot.events.on("received").on("command").on("wordusers"
+        events.on("received").on("command").on("wordusers"
             ).hook(self.word_users, min_args=1,
             help="Show who has used a tracked word the most",
             usage="<word>")
diff --git a/modules/youtube.py b/modules/youtube.py
index df965ec0..1ffd4db5 100644
--- a/modules/youtube.py
+++ b/modules/youtube.py
@@ -17,15 +17,16 @@ ARROW_UP = "▲"
 ARROW_DOWN = "▼"
 
 class Module(object):
-    def __init__(self, bot):
+    def __init__(self, bot, events):
         self.bot = bot
-        bot.events.on("received").on("command").on("yt", "youtube"
+        self.events = events
+        events.on("received").on("command").on("yt", "youtube"
             ).hook(self.yt,
             help="Find a video on youtube", usage="[query]")
-        bot.events.on("received").on("message").on("channel").hook(
+        events.on("received").on("message").on("channel").hook(
             self.channel_message)
 
-        bot.events.on("postboot").on("configure").on(
+        events.on("postboot").on("configure").on(
             "channelset").assure_call(setting="auto-youtube",
             help="Disable/Enable automatically getting info from youtube URLs",
             validate=Utils.bool_or_none)
@@ -102,6 +103,6 @@ class Module(object):
             youtube_id = match.group(1)
             video_details = self.video_details(youtube_id)
             if video_details:
-                self.bot.events.on("send").on("stdout").call(target=event[
+                self.events.on("send").on("stdout").call(target=event[
                     "channel"], message=video_details, module_name="Youtube",
                     server=event["server"])
-- 
cgit v1.3.1-10-gc9f91