diff --git a/cloudbot/clients/irc.py b/cloudbot/clients/irc.py
index 6d87147f..165cc4a4 100644
--- a/cloudbot/clients/irc.py
+++ b/cloudbot/clients/irc.py
@@ -178,7 +178,7 @@ def get_channel_key(
         channel: str,
         default: Optional[str] = None,
         *,
-        set_key: bool = True
+        set_key: bool = True,
     ) -> Optional[str]:
         if channel in self._channel_keys:
             key = self._channel_keys[channel]
diff --git a/cloudbot/event.py b/cloudbot/event.py
index 5ae5921a..338b6a44 100644
--- a/cloudbot/event.py
+++ b/cloudbot/event.py
@@ -65,7 +65,7 @@ def __init__(
         irc_command=None,
         irc_paramlist=None,
         irc_ctcp_text=None,
-        irc_tags=None
+        irc_tags=None,
     ):
         """
         All of these parameters except for `bot` and `hook` are optional.
@@ -169,8 +169,8 @@ def __iter__(self) -> Iterator[str]:
     def __getitem__(self, item: str) -> Any:
         try:
             return getattr(self, item)
-        except AttributeError:
-            raise KeyError(item)
+        except AttributeError as e:
+            raise KeyError(item) from e
 
     async def prepare(self):
         """
@@ -268,7 +268,9 @@ def message(self, message, target=None):
         """
         if target is None:
             if self.chan is None:
-                raise ValueError("Target must be specified when chan is not assigned")
+                raise ValueError(
+                    "Target must be specified when chan is not assigned"
+                )
 
             target = self.chan
 
@@ -295,11 +297,15 @@ def reply(self, *messages, target=None):
         reply_ping = self.conn.config.get("reply_ping", True)
         if target is None:
             if self.chan is None:
-                raise ValueError("Target must be specified when chan is not assigned")
+                raise ValueError(
+                    "Target must be specified when chan is not assigned"
+                )
 
             target = self.chan
 
-        if not messages:  # if there are no messages specified, don't do anything
+        if (
+            not messages
+        ):  # if there are no messages specified, don't do anything
             return
 
         if target == self.nick or not reply_ping:
@@ -317,7 +323,9 @@ def action(self, message, target=None):
         """
         if target is None:
             if self.chan is None:
-                raise ValueError("Target must be specified when chan is not assigned")
+                raise ValueError(
+                    "Target must be specified when chan is not assigned"
+                )
 
             target = self.chan
 
@@ -331,7 +339,9 @@ def ctcp(self, message, ctcp_type, target=None):
         """
         if target is None:
             if self.chan is None:
-                raise ValueError("Target must be specified when chan is not assigned")
+                raise ValueError(
+                    "Target must be specified when chan is not assigned"
+                )
 
             target = self.chan
 
@@ -349,7 +359,9 @@ def notice(self, message, target=None):
         avoid_notices = self.conn.config.get("avoid_notices", False)
         if target is None:
             if self.nick is None:
-                raise ValueError("Target must be specified when nick is not assigned")
+                raise ValueError(
+                    "Target must be specified when nick is not assigned"
+                )
 
             target = self.nick
 
@@ -360,17 +372,19 @@ def notice(self, message, target=None):
             self.conn.notice(target, message)
 
     def has_permission(self, permission, notice=True):
-        """ returns whether or not the current user has a given permission
+        """returns whether or not the current user has a given permission
         :type permission: str
         :rtype: bool
         """
         if not self.mask:
             raise ValueError("has_permission requires mask is not assigned")
 
-        return self.conn.permissions.has_perm_mask(self.mask, permission, notice=notice)
+        return self.conn.permissions.has_perm_mask(
+            self.mask, permission, notice=notice
+        )
 
     async def check_permission(self, permission, notice=True):
-        """ returns whether or not the current user has a given permission
+        """returns whether or not the current user has a given permission
         :type permission: str
         :type notice: bool
         :rtype: bool
@@ -379,7 +393,9 @@ async def check_permission(self, permission, notice=True):
             return True
 
         for perm_hook in self.bot.plugin_manager.perm_hooks[permission]:
-            ok, res = await self.bot.plugin_manager.internal_launch(perm_hook, self)
+            ok, res = await self.bot.plugin_manager.internal_launch(
+                perm_hook, self
+            )
             if ok and res:
                 return True
 
@@ -440,7 +456,7 @@ def __init__(
         irc_raw=None,
         irc_prefix=None,
         irc_command=None,
-        irc_paramlist=None
+        irc_paramlist=None,
     ):
         """
         :param text: The arguments for the command
@@ -520,7 +536,7 @@ def __init__(
         irc_raw=None,
         irc_prefix=None,
         irc_command=None,
-        irc_paramlist=None
+        irc_paramlist=None,
     ):
         """
         :param: match: The match objected returned by the regex search method
@@ -567,7 +583,9 @@ async def prepare(self):
             try:
                 self.parsed_line = Message.parse(self.line)
             except Exception:
-                logger.exception("Unable to parse line requested by hook %s", self.hook)
+                logger.exception(
+                    "Unable to parse line requested by hook %s", self.hook
+                )
                 self.parsed_line = None
 
     def prepare_threaded(self):
@@ -577,7 +595,9 @@ def prepare_threaded(self):
             try:
                 self.parsed_line = Message.parse(self.line)
             except Exception:
-                logger.exception("Unable to parse line requested by hook %s", self.hook)
+                logger.exception(
+                    "Unable to parse line requested by hook %s", self.hook
+                )
                 self.parsed_line = None
 
     @property
@@ -593,7 +613,7 @@ def __init__(
         launched_event=None,
         result=None,
         error=None,
-        **kwargs
+        **kwargs,
     ):
         super().__init__(*args, **kwargs)
         self.launched_hook = launched_hook
diff --git a/cloudbot/permissions.py b/cloudbot/permissions.py
index 20023f45..48a5cb73 100644
--- a/cloudbot/permissions.py
+++ b/cloudbot/permissions.py
@@ -24,7 +24,8 @@ def __init__(self, conn):
         """
         logger.info(
             "[%s|permissions] Created permission manager for %s.",
-            conn.name, conn.name
+            conn.name,
+            conn.name,
         )
 
         # stuff
@@ -43,7 +44,8 @@ def reload(self):
         self.perm_users = {}
         logger.info(
             "[%s|permissions] Reloading permissions for %s.",
-            self.name, self.name
+            self.name,
+            self.name,
         )
         groups = self.config.get("permissions", {})
         # work out the permissions and users each group has
@@ -53,7 +55,8 @@ def reload(self):
                     "[%s|permissions] Warning! Non-lower-case group %r in "
                     "config. This will cause problems when setting "
                     "permissions using the bot's permissions commands",
-                    self.name, key
+                    self.name,
+                    key,
                 )
             key = key.lower()
             self.group_perms[key] = []
@@ -72,15 +75,14 @@ def reload(self):
 
         logger.debug(
             "[%s|permissions] Group permissions: %s",
-            self.name, self.group_perms
+            self.name,
+            self.group_perms,
         )
         logger.debug(
-            "[%s|permissions] Group users: %s",
-            self.name, self.group_users
+            "[%s|permissions] Group users: %s", self.name, self.group_users
         )
         logger.debug(
-            "[%s|permissions] Permission users: %s",
-            self.name, self.perm_users
+            "[%s|permissions] Permission users: %s", self.name, self.perm_users
         )
 
     def has_perm_mask(self, user_mask, perm, notice=True):
@@ -105,7 +107,9 @@ def has_perm_mask(self, user_mask, perm, notice=True):
                 if notice:
                     logger.info(
                         "[%s|permissions] Allowed user %s access to %s",
-                        self.name, user_mask, perm
+                        self.name,
+                        user_mask,
+                        perm,
                     )
                 return True
 
@@ -198,7 +202,9 @@ def remove_group_user(self, group, user_mask):
                 if group not in config_groups:
                     logger.warning(
                         "[%s|permissions] Can't remove user from group due to"
-                        " upper-case group names!", self.name)
+                        " upper-case group names!",
+                        self.name,
+                    )
                     continue
                 config_group = config_groups.get(group)
                 config_users = config_group.get("users")
diff --git a/cloudbot/util/__init__.py b/cloudbot/util/__init__.py
index d7363182..8d693889 100644
--- a/cloudbot/util/__init__.py
+++ b/cloudbot/util/__init__.py
@@ -1,4 +1,5 @@
 # CONSTANTS
-ATTR_PREFIX = '_cloudbot'
-HOOK_ATTR = ATTR_PREFIX + '_hook'
-LOADED_ATTR = ATTR_PREFIX + '_loaded'
+
+ATTR_PREFIX = "_cloudbot"
+HOOK_ATTR = ATTR_PREFIX + "_hook"
+LOADED_ATTR = ATTR_PREFIX + "_loaded"
diff --git a/cloudbot/util/colors.py b/cloudbot/util/colors.py
index 725ccf1f..315479dc 100644
--- a/cloudbot/util/colors.py
+++ b/cloudbot/util/colors.py
@@ -65,28 +65,23 @@
     "dark_gray": "14",
     "grey": "15",
     "gray": "15",
-    "random": ""  # Special keyword, generate a random number.
+    "random": "",  # Special keyword, generate a random number.
 }
 
 IRC_FORMATTING_DICT = {
     "colour": "\x03",
     "color": "\x03",
-
     "bold": "\x02",
     "b": "\x02",
-
     "underlined": "\x1F",
     "underline": "\x1F",
     "ul": "\x1F",
-
     "italics": "\x1D",
     "italic": "\x1D",
     "i": "\x1D",
-
     "reverse": "\x16",
-
     "reset": "\x0F",
-    "clear": "\x0F"
+    "clear": "\x0F",
 }
 
 COLOR_RE = re.compile(r"\$\(.*?\)", re.I)
@@ -102,11 +97,17 @@ def get_color(colour, return_formatted=True):
     colour = colour.lower()
 
     if colour not in IRC_COLOUR_DICT:
-        raise KeyError("The colour '{}' is not in the list of available colours.".format(colour))
+        raise KeyError(
+            "The colour '{}' is not in the list of available colours.".format(
+                colour
+            )
+        )
 
     if colour == "random":  # Special keyword for a random colour
         rand = randint(0, 15)
-        if rand < 10:  # Prepend '0' before colour so it always is double digits.
+        if (
+            rand < 10
+        ):  # Prepend '0' before colour so it always is double digits.
             rand = "0" + str(rand)
         rand = str(rand)
 
@@ -126,7 +127,11 @@ def get_format(formatting):
     """
 
     if formatting.lower() not in IRC_FORMATTING_DICT:
-        raise KeyError("The formatting '{}' is not found in the list of available formats.".format(formatting))
+        raise KeyError(
+            "The formatting '{}' is not found in the list of available formats.".format(
+                formatting
+            )
+        )
 
     return IRC_FORMATTING_DICT[formatting.lower()]
 
@@ -169,6 +174,7 @@ def parse(string):
 
 # Formatting stripping.
 
+
 def strip(string):
     """
     Removes all $() syntax formatting codes from the input string and returns it.
@@ -190,7 +196,7 @@ def strip_irc(string):
     :rtype str
     """
 
-    return IRC_COLOR_RE.sub('', string)
+    return IRC_COLOR_RE.sub("", string)
 
 
 def strip_all(string):
@@ -205,6 +211,7 @@ def strip_all(string):
 
 # Internal use
 
+
 def _convert(string):
     if not string.startswith("$(") and not string.endswith(")"):
         return string
diff --git a/cloudbot/util/filesize.py b/cloudbot/util/filesize.py
index a08fb18b..75f2ab32 100644
--- a/cloudbot/util/filesize.py
+++ b/cloudbot/util/filesize.py
@@ -53,48 +53,48 @@
 """
 
 traditional = (
-    (1024 ** 5, 'P'),
-    (1024 ** 4, 'T'),
-    (1024 ** 3, 'G'),
-    (1024 ** 2, 'M'),
-    (1024 ** 1, 'K'),
-    (1024 ** 0, 'B'),
+    (1024 ** 5, "P"),
+    (1024 ** 4, "T"),
+    (1024 ** 3, "G"),
+    (1024 ** 2, "M"),
+    (1024 ** 1, "K"),
+    (1024 ** 0, "B"),
 )
 
 alternative = (
-    (1024 ** 5, ' PB'),
-    (1024 ** 4, ' TB'),
-    (1024 ** 3, ' GB'),
-    (1024 ** 2, ' MB'),
-    (1024 ** 1, ' KB'),
-    (1024 ** 0, (' byte', ' bytes')),
+    (1024 ** 5, " PB"),
+    (1024 ** 4, " TB"),
+    (1024 ** 3, " GB"),
+    (1024 ** 2, " MB"),
+    (1024 ** 1, " KB"),
+    (1024 ** 0, (" byte", " bytes")),
 )
 
 verbose = (
-    (1024 ** 5, (' petabyte', ' petabytes')),
-    (1024 ** 4, (' terabyte', ' terabytes')),
-    (1024 ** 3, (' gigabyte', ' gigabytes')),
-    (1024 ** 2, (' megabyte', ' megabytes')),
-    (1024 ** 1, (' kilobyte', ' kilobytes')),
-    (1024 ** 0, (' byte', ' bytes')),
+    (1024 ** 5, (" petabyte", " petabytes")),
+    (1024 ** 4, (" terabyte", " terabytes")),
+    (1024 ** 3, (" gigabyte", " gigabytes")),
+    (1024 ** 2, (" megabyte", " megabytes")),
+    (1024 ** 1, (" kilobyte", " kilobytes")),
+    (1024 ** 0, (" byte", " bytes")),
 )
 
 iec = (
-    (1024 ** 5, 'Pi'),
-    (1024 ** 4, 'Ti'),
-    (1024 ** 3, 'Gi'),
-    (1024 ** 2, 'Mi'),
-    (1024 ** 1, 'Ki'),
-    (1024 ** 0, ''),
+    (1024 ** 5, "Pi"),
+    (1024 ** 4, "Ti"),
+    (1024 ** 3, "Gi"),
+    (1024 ** 2, "Mi"),
+    (1024 ** 1, "Ki"),
+    (1024 ** 0, ""),
 )
 
 si = (
-    (1000 ** 5, 'P'),
-    (1000 ** 4, 'T'),
-    (1000 ** 3, 'G'),
-    (1000 ** 2, 'M'),
-    (1000 ** 1, 'K'),
-    (1000 ** 0, 'B'),
+    (1000 ** 5, "P"),
+    (1000 ** 4, "T"),
+    (1000 ** 3, "G"),
+    (1000 ** 2, "M"),
+    (1000 ** 1, "K"),
+    (1000 ** 0, "B"),
 )
 
 # re.I style aliases
diff --git a/cloudbot/util/formatting.py b/cloudbot/util/formatting.py
index 0cb8f06b..7935509f 100644
--- a/cloudbot/util/formatting.py
+++ b/cloudbot/util/formatting.py
@@ -56,63 +56,64 @@
 IRC_COLOR_RE = re.compile(r"(\x03(\d+,\d+|\d)|[\x0f\x02\x16\x1f])")
 
 REPLACEMENTS = {
-    'a': 'ä',
-    'b': 'Б',
-    'c': 'ċ',
-    'd': 'đ',
-    'e': 'ë',
-    'f': 'ƒ',
-    'g': 'ġ',
-    'h': 'ħ',
-    'i': 'í',
-    'j': 'ĵ',
-    'k': 'ķ',
-    'l': 'ĺ',
-    'm': 'ṁ',
-    'n': 'ñ',
-    'o': 'ö',
-    'p': 'ρ',
-    'q': 'ʠ',
-    'r': 'ŗ',
-    's': 'š',
-    't': 'ţ',
-    'u': 'ü',
-    'v': '',
-    'w': 'ω',
-    'x': 'χ',
-    'y': 'ÿ',
-    'z': 'ź',
-    'A': 'Å',
-    'B': 'Β',
-    'C': 'Ç',
-    'D': 'Ď',
-    'E': 'Ē',
-    'F': 'Ḟ',
-    'G': 'Ġ',
-    'H': 'Ħ',
-    'I': 'Í',
-    'J': 'Ĵ',
-    'K': 'Ķ',
-    'L': 'Ĺ',
-    'M': 'Μ',
-    'N': 'Ν',
-    'O': 'Ö',
-    'P': 'Р',
-    'Q': 'Ｑ',
-    'R': 'Ŗ',
-    'S': 'Š',
-    'T': 'Ţ',
-    'U': 'Ů',
-    'V': 'Ṿ',
-    'W': 'Ŵ',
-    'X': 'Χ',
-    'Y': 'Ỳ',
-    'Z': 'Ż'
+    "a": "ä",
+    "b": "Б",
+    "c": "ċ",
+    "d": "đ",
+    "e": "ë",
+    "f": "ƒ",
+    "g": "ġ",
+    "h": "ħ",
+    "i": "í",
+    "j": "ĵ",
+    "k": "ķ",
+    "l": "ĺ",
+    "m": "ṁ",
+    "n": "ñ",
+    "o": "ö",
+    "p": "ρ",
+    "q": "ʠ",
+    "r": "ŗ",
+    "s": "š",
+    "t": "ţ",
+    "u": "ü",
+    "v": "",
+    "w": "ω",
+    "x": "χ",
+    "y": "ÿ",
+    "z": "ź",
+    "A": "Å",
+    "B": "Β",
+    "C": "Ç",
+    "D": "Ď",
+    "E": "Ē",
+    "F": "Ḟ",
+    "G": "Ġ",
+    "H": "Ħ",
+    "I": "Í",
+    "J": "Ĵ",
+    "K": "Ķ",
+    "L": "Ĺ",
+    "M": "Μ",
+    "N": "Ν",
+    "O": "Ö",
+    "P": "Р",
+    "Q": "Ｑ",
+    "R": "Ŗ",
+    "S": "Š",
+    "T": "Ţ",
+    "U": "Ů",
+    "V": "Ṿ",
+    "W": "Ŵ",
+    "X": "Χ",
+    "Y": "Ỳ",
+    "Z": "Ż",
 }
 
 
 # Classes
 
+
 class HTMLTextExtractor(HTMLParser):
     """
     Takes HTML and provides cleaned and stripped text.
@@ -126,11 +127,12 @@ def handle_data(self, d):
         self.result.append(d)
 
     def get_text(self):
-        return ''.join(self.result)
+        return "".join(self.result)
 
 
 # Functions
 
+
 def strip_html(to_strip):
     """
     Takes HTML and returns cleaned and stripped text.
@@ -151,7 +153,7 @@ def munge(text, count=0):
     for n, c in enumerate(text):
         rep = REPLACEMENTS.get(c)
         if rep:
-            text = text[:n] + rep + text[n + 1:]
+            text = text[:n] + rep + text[n + 1 :]
             reps += 1
             if reps == count:
                 break
@@ -178,7 +180,7 @@ def multi_replace(text, word_dic):
     then returns the changed text
     :rtype str
     """
-    rc = re.compile('|'.join(map(re.escape, word_dic)))
+    rc = re.compile("|".join(map(re.escape, word_dic)))
 
     def translate(match):
         return word_dic[match.group(0)]
@@ -190,7 +192,7 @@ def translate(match):
 multiword_replace = multi_replace
 
 
-def truncate_words(content, length=10, suffix='...'):
+def truncate_words(content, length=10, suffix="..."):
     """
     Truncates a string after a certain number of words.
     :rtype str
@@ -202,7 +204,7 @@ def truncate_words(content, length=10, suffix='...'):
     return " ".join(split[:length]) + suffix
 
 
-def truncate(content, length=100, suffix='...', sep=' '):
+def truncate(content, length=100, suffix="...", sep=" "):
     """
     Truncates a string after a certain number of characters.
     Function always tries to truncate on a word boundary.
@@ -227,38 +229,38 @@ def chunk_str(content, length=420):
 
     def chunk(c, l):
         while c:
-            out = (c + ' ')[:l].rsplit(' ', 1)[0]
-            c = c[len(out):].strip()
+            out = (c + " ")[:l].rsplit(" ", 1)[0]
+            c = c[len(out) :].strip()
             yield out
 
     return list(chunk(content, length))
 
 
-def pluralize(num=0, text=''):  # pragma: no cover
+def pluralize(num=0, text=""):  # pragma: no cover
     """
     Takes a number and a string, and pluralizes that string using the number and combines the results.
     :rtype: str
     """
     warnings.warn(
         "formatting.pluralize() is deprecated, please use one of the other formatting.pluralize_*() functions",
-        DeprecationWarning
+        DeprecationWarning,
     )
     return pluralize_suffix(num, text)
 
 
-def pluralise(num=0, text=''):  # pragma: no cover
+def pluralise(num=0, text=""):  # pragma: no cover
     """
     Takes a number and a string, and pluralizes that string using the number and combines the results.
     :rtype: str
     """
     warnings.warn(
         "formatting.pluralise() is deprecated, please use one of the other formatting.pluralise_*() functions",
-        DeprecationWarning
+        DeprecationWarning,
     )
     return pluralise_suffix(num, text)
 
 
-def pluralize_suffix(num=0, text='', suffix='s'):
+def pluralize_suffix(num=0, text="", suffix="s"):
     """
     Takes a number and a string, and pluralizes that string using the number and combines the results.
     :rtype: str
@@ -277,29 +279,29 @@ def pluralize_select(count, single, plural):
 
 
 def pluralize_auto(count, thing):
-    if thing.endswith('us'):
-        return pluralize_select(count, thing, thing[:-2] + 'i')
+    if thing.endswith("us"):
+        return pluralize_select(count, thing, thing[:-2] + "i")
 
-    if thing.endswith('is'):
-        return pluralize_select(count, thing, thing[:-2] + 'es')
+    if thing.endswith("is"):
+        return pluralize_select(count, thing, thing[:-2] + "es")
 
-    if thing.endswith(('s', 'ss', 'sh', 'ch', 'x', 'z')):
-        return pluralize_suffix(count, thing, 'es')
+    if thing.endswith(("s", "ss", "sh", "ch", "x", "z")):
+        return pluralize_suffix(count, thing, "es")
 
-    if thing.endswith(('f', 'fe')):
-        return pluralize_select(count, thing, thing.rsplit('f', 1)[0] + 'ves')
+    if thing.endswith(("f", "fe")):
+        return pluralize_select(count, thing, thing.rsplit("f", 1)[0] + "ves")
 
-    if thing.endswith('y') and thing[-2:-1].lower() not in "aeiou":
-        return pluralize_select(count, thing, thing[:-1] + 'ies')
+    if thing.endswith("y") and thing[-2:-1].lower() not in "aeiou":
+        return pluralize_select(count, thing, thing[:-1] + "ies")
 
-    if thing.endswith('y') and thing[-2:-1].lower() in "aeiou":
+    if thing.endswith("y") and thing[-2:-1].lower() in "aeiou":
         return pluralize_suffix(count, thing)
 
-    if thing.endswith('o'):
-        return pluralize_suffix(count, thing, 'es')
+    if thing.endswith("o"):
+        return pluralize_suffix(count, thing, "es")
 
-    if thing.endswith('on'):
-        return pluralize_select(count, thing, thing[:-2] + 'a')
+    if thing.endswith("on"):
+        return pluralize_select(count, thing, thing[:-2] + "a")
 
     return pluralize_suffix(count, thing)
 
@@ -319,7 +321,9 @@ def dict_format(args, formats):
             # Check if values can be mapped
             m = f.format(**args)
             # Insert match and number of matched values (max matched values if already in dict)
-            matches[m] = max([matches.get(m, 0), len(re.findall(r'({.*?\})', f))])
+            matches[m] = max(
+                [matches.get(m, 0), len(re.findall(r"({.*?\})", f))]
+            )
         except KeyError:
             continue
 
@@ -332,8 +336,11 @@ def dict_format(args, formats):
 
 # DJANGO LICENCE
 
-split_re = re.compile(r"""((?:[^\s'"]*(?:(?:"(?:[^"\\]|\\.)*" | '(?:["""
-                      r"""^'\\]|\\.)*')[^\s'"]*)+) | \S+)""", re.VERBOSE)
+split_re = re.compile(
+    r"""((?:[^\s'"]*(?:(?:"(?:[^"\\]|\\.)*" | '(?:["""
+    r"""^'\\]|\\.)*')[^\s'"]*)+) | \S+)""",
+    re.VERBOSE,
+)
 
 
 def smart_split(text):
@@ -355,7 +362,7 @@ def smart_split(text):
         yield bit.group(0)
 
 
-def get_text_list(list_, last_word='or'):
+def get_text_list(list_, last_word="or"):
     """
     >>> get_text_list(['a', 'b', 'c', 'd'])
     'a, b, c or d'
@@ -369,15 +376,17 @@ def get_text_list(list_, last_word='or'):
     ''
     """
     if not list_:
-        return ''
+        return ""
 
     if len(list_) == 1:
         return list_[0]
 
-    return '%s %s %s' % (
+    return "%s %s %s" % (
         # Translators: This string is used as a separator between list elements
-        ', '.join([i for i in list_][:-1]),
-        last_word, list_[-1])
+        ", ".join([i for i in list_][:-1]),
+        last_word,
+        list_[-1],
+    )
 
 
 def gen_markdown_table(headers, rows):
@@ -389,9 +398,11 @@ def gen_markdown_table(headers, rows):
     rotated = zip(*reversed(rows))
 
     sizes = tuple(map(lambda l: max(max(map(len, l)), 3), rotated))
-    rows.insert(1, tuple(('-' * size) for size in sizes))
+    rows.insert(1, tuple(("-" * size) for size in sizes))
     lines = [
-        "| {} |".format(' | '.join(cell.ljust(sizes[i]) for i, cell in enumerate(row)))
+        "| {} |".format(
+            " | ".join(cell.ljust(sizes[i]) for i, cell in enumerate(row))
+        )
         for row in rows
     ]
-    return '\n'.join(lines)
+    return "\n".join(lines)
diff --git a/cloudbot/util/func_utils.py b/cloudbot/util/func_utils.py
index 90f49a89..66dc368d 100644
--- a/cloudbot/util/func_utils.py
+++ b/cloudbot/util/func_utils.py
@@ -16,7 +16,9 @@ def call_with_args(func, arg_data):
     sig = inspect.signature(func, follow_wrapped=False)
     try:
         args = [
-            arg_data[key] for key in sig.parameters.keys() if not key.startswith("_")
+            arg_data[key]
+            for key in sig.parameters.keys()
+            if not key.startswith("_")
         ]
     except KeyError as e:
         raise ParameterError(e.args[0], arg_data.keys()) from e
diff --git a/cloudbot/util/http.py b/cloudbot/util/http.py
index f71ec3db..7efbf92e 100644
--- a/cloudbot/util/http.py
+++ b/cloudbot/util/http.py
@@ -17,15 +17,20 @@
 # security
 parser = etree.XMLParser(resolve_entities=False, no_network=True)
 
-ua_cloudbot = 'Cloudbot/DEV http://github.com/CloudDev/CloudBot'
-
-ua_firefox = 'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:17.0) Gecko/17.0' \
-             ' Firefox/17.0'
-ua_old_firefox = 'Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; ' \
-                 'rv:1.8.1.6) Gecko/20070725 Firefox/2.0.0.6'
-ua_internetexplorer = 'Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)'
-ua_chrome = 'Mozilla/5.0 (X11; Linux i686) AppleWebKit/537.4 (KHTML, ' \
-            'like Gecko) Chrome/22.0.1229.79 Safari/537.4'
+ua_cloudbot = "Cloudbot/DEV http://github.com/CloudDev/CloudBot"
+
+ua_firefox = (
+    "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:17.0) Gecko/17.0" " Firefox/17.0"
+)
+ua_old_firefox = (
+    "Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; "
+    "rv:1.8.1.6) Gecko/20070725 Firefox/2.0.0.6"
+)
+ua_internetexplorer = "Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)"
+ua_chrome = (
+    "Mozilla/5.0 (X11; Linux i686) AppleWebKit/537.4 (KHTML, "
+    "like Gecko) Chrome/22.0.1229.79 Safari/537.4"
+)
 
 jar = http.cookiejar.CookieJar()
 
@@ -54,7 +59,7 @@ def parse_soup(text, features=None, **kwargs):
     'test'
     """
     if features is None:
-        features = 'lxml'
+        features = "lxml"
 
     return BeautifulSoup(text, features=features, **kwargs)
 
@@ -83,8 +88,18 @@ def get_json(*args, **kwargs):
     return json.loads(get(*args, **kwargs))
 
 
-def open_request(url, query_params=None, user_agent=None, post_data=None, referer=None, get_method=None, cookies=False,
-                 timeout=None, headers=None, **kwargs):
+def open_request(
+    url,
+    query_params=None,
+    user_agent=None,
+    post_data=None,
+    referer=None,
+    get_method=None,
+    cookies=False,
+    timeout=None,
+    headers=None,
+    **kwargs,
+):
     if query_params is None:
         query_params = {}
 
@@ -104,13 +119,15 @@ def open_request(url, query_params=None, user_agent=None, post_data=None, refere
         for header_key, header_value in headers.items():
             request.add_header(header_key, header_value)
 
-    request.add_header('User-Agent', user_agent)
+    request.add_header("User-Agent", user_agent)
 
     if referer is not None:
-        request.add_header('Referer', referer)
+        request.add_header("Referer", referer)
 
     if cookies:
-        opener = urllib.request.build_opener(urllib.request.HTTPCookieProcessor(jar))
+        opener = urllib.request.build_opener(
+            urllib.request.HTTPCookieProcessor(jar)
+        )
     else:
         opener = urllib.request.build_opener()
 
@@ -121,17 +138,34 @@ def open_request(url, query_params=None, user_agent=None, post_data=None, refere
 
 
 # noinspection PyShadowingBuiltins
-def open(url, query_params=None, user_agent=None, post_data=None,
-         referer=None, get_method=None, cookies=False, timeout=None, headers=None,
-         **kwargs):  # pylint: disable=locally-disabled, redefined-builtin  # pragma: no cover
+def open(
+    url,
+    query_params=None,
+    user_agent=None,
+    post_data=None,
+    referer=None,
+    get_method=None,
+    cookies=False,
+    timeout=None,
+    headers=None,
+    **kwargs,
+):  # pylint: disable=locally-disabled, redefined-builtin  # pragma: no cover
     warnings.warn(
         "http.open() is deprecated, use http.open_request() instead.",
-        DeprecationWarning
+        DeprecationWarning,
     )
 
     return open_request(
-        url, query_params=query_params, user_agent=user_agent, post_data=post_data, referer=referer,
-        get_method=get_method, cookies=cookies, timeout=timeout, headers=headers, **kwargs
+        url,
+        query_params=query_params,
+        user_agent=user_agent,
+        post_data=post_data,
+        referer=referer,
+        get_method=get_method,
+        cookies=cookies,
+        timeout=timeout,
+        headers=headers,
+        **kwargs,
     )
 
 
@@ -145,8 +179,9 @@ def prepare_url(url, queries):
 
         query = dict(urllib.parse.parse_qsl(query))
         query.update(queries)
-        query = urllib.parse.urlencode(dict((to_utf8(key), to_utf8(value))
-                                            for key, value in query.items()))
+        query = urllib.parse.urlencode(
+            dict((to_utf8(key), to_utf8(value)) for key, value in query.items())
+        )
 
         url = urllib.parse.urlunsplit((scheme, netloc, path, query, fragment))
 
@@ -163,7 +198,7 @@ def to_utf8(s):
     b'1'
     """
     if isinstance(s, str):
-        return s.encode('utf8', 'ignore')
+        return s.encode("utf8", "ignore")
 
     if isinstance(s, bytes):
         return bytes(s)
diff --git a/cloudbot/util/irc.py b/cloudbot/util/irc.py
index da96961a..0de64a71 100644
--- a/cloudbot/util/irc.py
+++ b/cloudbot/util/irc.py
@@ -28,7 +28,9 @@ class ChannelMode:
     type = attr.ib(type=ModeType)
 
     def has_param(self, adding: bool) -> bool:
-        return self.type in PARAM_MODE_TYPES or (self.type is ModeType.C and adding)
+        return self.type in PARAM_MODE_TYPES or (
+            self.type is ModeType.C and adding
+        )
 
 
 @attr.s(hash=True)
@@ -58,7 +60,9 @@ class StatusMode(ChannelMode):
 
     @classmethod
     def make(cls, prefix: str, char: str, level: int) -> "StatusMode":
-        return cls(prefix=prefix, level=level, character=char, type=ModeType.Status)
+        return cls(
+            prefix=prefix, level=level, character=char, type=ModeType.Status
+        )
 
 
 def parse_mode_string(
diff --git a/cloudbot/util/pager.py b/cloudbot/util/pager.py
index db08a88e..c06e5ebc 100644
--- a/cloudbot/util/pager.py
+++ b/cloudbot/util/pager.py
@@ -125,7 +125,12 @@ def handle_lookup(self, text) -> List[str]:
 
 
 def paginated_list(
-    data, delim=" \u2022 ", suffix='...', max_len=256, page_size=2, pager_cls=Pager
+    data,
+    delim=" \u2022 ",
+    suffix="...",
+    max_len=256,
+    page_size=2,
+    pager_cls=Pager,
 ):
     """
     >>> list(paginated_list(['abc', 'def']))
@@ -145,7 +150,7 @@ def get_delim():
         if lines[-1]:
             return delim
 
-        return ''
+        return ""
 
     for item in data:
         if len(item) > max_len:
diff --git a/cloudbot/util/sequence.py b/cloudbot/util/sequence.py
index 80daffa2..d56a7368 100644
--- a/cloudbot/util/sequence.py
+++ b/cloudbot/util/sequence.py
@@ -11,4 +11,4 @@ def chunk_iter(data, chunk_size):
     :return: An iterable of all the chunks of the sequence
     """
     for i in range(0, len(data), chunk_size):
-        yield data[i:i + chunk_size]
+        yield data[i : i + chunk_size]
diff --git a/cloudbot/util/text.py b/cloudbot/util/text.py
index 5ff7d00e..f5e5c772 100644
--- a/cloudbot/util/text.py
+++ b/cloudbot/util/text.py
@@ -1,6 +1,6 @@
 from typing import Optional
 
-__all__ = ('parse_bool',)
+__all__ = ("parse_bool",)
 
 _STR_TO_BOOL = {
     "yes": True,
diff --git a/cloudbot/util/textgen.py b/cloudbot/util/textgen.py
index c91876c9..61567ad6 100644
--- a/cloudbot/util/textgen.py
+++ b/cloudbot/util/textgen.py
@@ -49,7 +49,9 @@
 
 
 class TextGenerator(object):
-    def __init__(self, templates, parts, default_templates=None, variables=None):
+    def __init__(
+        self, templates, parts, default_templates=None, variables=None
+    ):
         self.templates = templates
         self.default_templates = default_templates
         self.parts = parts
@@ -77,7 +79,9 @@ def generate_string(self, template=None):
         If no templates are specified, use a random template from the default_templates list.
         """
         if self.default_templates:
-            text = self.templates[template or random.choice(self.default_templates)]
+            text = self.templates[
+                template or random.choice(self.default_templates)
+            ]
         else:
             text = random.choice(self.templates)
 
diff --git a/cloudbot/util/timeformat.py b/cloudbot/util/timeformat.py
index 76f7faa6..0fe46a5d 100644
--- a/cloudbot/util/timeformat.py
+++ b/cloudbot/util/timeformat.py
@@ -94,7 +94,7 @@ def time_since(d, now=None, count=2, accuracy=6, simple=False):
 
     if since <= 0:
         # d is in the future compared to now, stop processing.
-        return '0 ' + 'minutes'
+        return "0 " + "minutes"
 
     # pass the number in seconds on to format_time to make the output string
     return format_time(since, count, accuracy, simple)
@@ -170,14 +170,14 @@ def format(self, simple=True, skip_empty=True, count=3):
 
 
 class TimeUnits:
-    SECOND = TimeUnit(1, 's', 'second', 'seconds')
-    MINUTE = TimeUnit(60 * SECOND, 'm', 'minute', 'minutes')
-    HOUR = TimeUnit(60 * MINUTE, 'h', 'hour', 'hours')
-    DAY = TimeUnit(24 * HOUR, 'd', 'day', 'days')
-    MONTH = TimeUnit(30 * DAY, 'M', 'month', 'months')
-    YEAR = TimeUnit(365 * DAY, 'y', 'year', 'years')
-    DECADE = TimeUnit(10 * YEAR, 'D', 'decade', 'decades')
-    CENTURY = TimeUnit(10 * DECADE, 'c', 'century', 'centuries')
+    SECOND = TimeUnit(1, "s", "second", "seconds")
+    MINUTE = TimeUnit(60 * SECOND, "m", "minute", "minutes")
+    HOUR = TimeUnit(60 * MINUTE, "h", "hour", "hours")
+    DAY = TimeUnit(24 * HOUR, "d", "day", "days")
+    MONTH = TimeUnit(30 * DAY, "M", "month", "months")
+    YEAR = TimeUnit(365 * DAY, "y", "year", "years")
+    DECADE = TimeUnit(10 * YEAR, "D", "decade", "decades")
+    CENTURY = TimeUnit(10 * DECADE, "c", "century", "centuries")
 
     units = (CENTURY, DECADE, YEAR, MONTH, DAY, HOUR, MINUTE, SECOND)
 
diff --git a/cloudbot/util/timeparse.py b/cloudbot/util/timeparse.py
index 25e29825..23cf6cd8 100644
--- a/cloudbot/util/timeparse.py
+++ b/cloudbot/util/timeparse.py
@@ -37,56 +37,58 @@
 
 import re
 
-SIGN = r'(?P<sign>[+|-])?'
+SIGN = r"(?P<sign>[+|-])?"
 
 # YEARS      = r'(?P<years>\d+)\s*(?:ys?|yrs?.?|years?)'
 # MONTHS     = r'(?P<months>\d+)\s*(?:mos?.?|mths?.?|months?)'
-WEEKS = r'(?P<weeks>[\d.]+)\s*(?:w|wks?|weeks?)'
-DAYS = r'(?P<days>[\d.]+)\s*(?:d|dys?|days?)'
-HOURS = r'(?P<hours>[\d.]+)\s*(?:h|hrs?|hours?)'
-MINS = r'(?P<mins>[\d.]+)\s*(?:m|(mins?)|(minutes?))'
-SECS = r'(?P<secs>[\d.]+)\s*(?:s|secs?|seconds?)'
-SEPARATORS = r'[,/]'
-SEC_CLOCK = r':(?P<secs>\d{2}(?:\.\d+)?)'
-MIN_CLOCK = r'(?P<mins>\d{1,2}):(?P<secs>\d{2}(?:\.\d+)?)'
-HOUR_CLOCK = r'(?P<hours>\d+):(?P<mins>\d{2}):(?P<secs>\d{2}(?:\.\d+)?)'
-DAY_CLOCK = (r'(?P<days>\d+):(?P<hours>\d{2}):'
-             r'(?P<mins>\d{2}):(?P<secs>\d{2}(?:\.\d+)?)')
-
-OPT = lambda x: r'(?:{x})?'.format(x=x)
-OPT_SEP = lambda x: r'(?:{x}\s*(?:{SEPARATORS}\s*)?)?'.format(
-    x=x, SEPARATORS=SEPARATORS)
+WEEKS = r"(?P<weeks>[\d.]+)\s*(?:w|wks?|weeks?)"
+DAYS = r"(?P<days>[\d.]+)\s*(?:d|dys?|days?)"
+HOURS = r"(?P<hours>[\d.]+)\s*(?:h|hrs?|hours?)"
+MINS = r"(?P<mins>[\d.]+)\s*(?:m|(mins?)|(minutes?))"
+SECS = r"(?P<secs>[\d.]+)\s*(?:s|secs?|seconds?)"
+SEPARATORS = r"[,/]"
+SEC_CLOCK = r":(?P<secs>\d{2}(?:\.\d+)?)"
+MIN_CLOCK = r"(?P<mins>\d{1,2}):(?P<secs>\d{2}(?:\.\d+)?)"
+HOUR_CLOCK = r"(?P<hours>\d+):(?P<mins>\d{2}):(?P<secs>\d{2}(?:\.\d+)?)"
+DAY_CLOCK = (
+    r"(?P<days>\d+):(?P<hours>\d{2}):"
+    r"(?P<mins>\d{2}):(?P<secs>\d{2}(?:\.\d+)?)"
+)
+
+OPT = lambda x: r"(?:{x})?".format(x=x)
+OPT_SEP = lambda x: r"(?:{x}\s*(?:{SEPARATORS}\s*)?)?".format(
+    x=x, SEPARATORS=SEPARATORS
+)
 
 TIME_FORMATS = [
-    r'{WEEKS}\s*{DAYS}\s*{HOURS}\s*{MINS}\s*{SECS}'.format(
+    r"{WEEKS}\s*{DAYS}\s*{HOURS}\s*{MINS}\s*{SECS}".format(
         # YEARS=OPT_SEP(YEARS),
         # MONTHS=OPT_SEP(MONTHS),
         WEEKS=OPT_SEP(WEEKS),
         DAYS=OPT_SEP(DAYS),
         HOURS=OPT_SEP(HOURS),
         MINS=OPT_SEP(MINS),
-        SECS=OPT(SECS)),
-    r'{MIN_CLOCK}'.format(
-        MIN_CLOCK=MIN_CLOCK),
-    r'{WEEKS}\s*{DAYS}\s*{HOUR_CLOCK}'.format(
-        WEEKS=OPT_SEP(WEEKS),
-        DAYS=OPT_SEP(DAYS),
-        HOUR_CLOCK=HOUR_CLOCK),
-    r'{DAY_CLOCK}'.format(
-        DAY_CLOCK=DAY_CLOCK),
-    r'{SEC_CLOCK}'.format(
-        SEC_CLOCK=SEC_CLOCK),
+        SECS=OPT(SECS),
+    ),
+    r"{MIN_CLOCK}".format(MIN_CLOCK=MIN_CLOCK),
+    r"{WEEKS}\s*{DAYS}\s*{HOUR_CLOCK}".format(
+        WEEKS=OPT_SEP(WEEKS), DAYS=OPT_SEP(DAYS), HOUR_CLOCK=HOUR_CLOCK
+    ),
+    r"{DAY_CLOCK}".format(DAY_CLOCK=DAY_CLOCK),
+    r"{SEC_CLOCK}".format(SEC_CLOCK=SEC_CLOCK),
 ]
 
-MULTIPLIERS = dict([
-    # ('years',  60 * 60 * 24 * 365),
-    # ('months', 60 * 60 * 24 * 30),
-    ('weeks', 60 * 60 * 24 * 7),
-    ('days', 60 * 60 * 24),
-    ('hours', 60 * 60),
-    ('mins', 60),
-    ('secs', 1)
-])
+MULTIPLIERS = dict(
+    [
+        # ('years',  60 * 60 * 24 * 365),
+        # ('months', 60 * 60 * 24 * 30),
+        ("weeks", 60 * 60 * 24 * 7),
+        ("days", 60 * 60 * 24),
+        ("hours", 60 * 60),
+        ("mins", 60),
+        ("secs", 1),
+    ]
+)
 
 
 def _interpret_as_minutes(string, mdict):
@@ -99,16 +101,20 @@ def _interpret_as_minutes(string, mdict):
     >>> pprint.pprint(_interpret_as_minutes('1:24', {'secs': '24', 'mins': '1'}))
     {'hours': '1', 'mins': '24'}
     """
-    has_keys = mdict.get('hours') is None and mdict.get('days') is None and mdict.get('weeks') is None
-    if string.count(':') == 1 and '.' not in string and has_keys:
-        mdict['hours'] = mdict['mins']
-        mdict['mins'] = mdict['secs']
-        mdict.pop('secs')
+    has_keys = (
+        mdict.get("hours") is None
+        and mdict.get("days") is None
+        and mdict.get("weeks") is None
+    )
+    if string.count(":") == 1 and "." not in string and has_keys:
+        mdict["hours"] = mdict["mins"]
+        mdict["mins"] = mdict["secs"]
+        mdict.pop("secs")
 
     return mdict
 
 
-def time_parse(string, granularity='seconds'):
+def time_parse(string, granularity="seconds"):
     """
     Parse a time expression, returning it as a number of seconds.  If
     possible, the return value will be an `int`; if this is not
@@ -146,28 +152,43 @@ def time_parse(string, granularity='seconds'):
     >>> time_parse('1:30', granularity='minutes')
     5400
     """
-    match = re.match(r'\s*' + SIGN + r'\s*(?P<unsigned>.*)$', string)
-    sign = -1 if match.groupdict()['sign'] == '-' else 1
-    string = match.groupdict()['unsigned']
+    match = re.match(r"\s*" + SIGN + r"\s*(?P<unsigned>.*)$", string)
+    sign = -1 if match.groupdict()["sign"] == "-" else 1
+    string = match.groupdict()["unsigned"]
     for timefmt in TIME_FORMATS:
-        match = re.match(r'\s*' + timefmt + r'\s*$', string, re.I)
+        match = re.match(r"\s*" + timefmt + r"\s*$", string, re.I)
         if match and match.group(0).strip():
             mdict = match.groupdict()
-            if granularity == 'minutes':
+            if granularity == "minutes":
                 mdict = _interpret_as_minutes(string, mdict)
             # if all of the fields are integer numbers
             if all(v.isdigit() for v in list(mdict.values()) if v):
-                return sign * sum([MULTIPLIERS[k] * int(v, 10) for (k, v) in
-                                   list(mdict.items()) if v is not None])
+                return sign * sum(
+                    [
+                        MULTIPLIERS[k] * int(v, 10)
+                        for (k, v) in list(mdict.items())
+                        if v is not None
+                    ]
+                )
 
             # if SECS is an integer number
-            if mdict.get('secs') is None or mdict['secs'].isdigit():
+            if mdict.get("secs") is None or mdict["secs"].isdigit():
                 # we will return an integer
-                return (
-                    sign * int(sum([MULTIPLIERS[k] * float(v) for (k, v) in
-                                    list(mdict.items()) if k != 'secs' and v is not None])) +
-                    (int(mdict['secs'], 10) if mdict['secs'] else 0))
+                return sign * int(
+                    sum(
+                        [
+                            MULTIPLIERS[k] * float(v)
+                            for (k, v) in list(mdict.items())
+                            if k != "secs" and v is not None
+                        ]
+                    )
+                ) + (int(mdict["secs"], 10) if mdict["secs"] else 0)
 
             # SECS is a float, we will return a float
-            return sign * sum([MULTIPLIERS[k] * float(v) for (k, v) in
-                               list(mdict.items()) if v is not None])
+            return sign * sum(
+                [
+                    MULTIPLIERS[k] * float(v)
+                    for (k, v) in list(mdict.items())
+                    if v is not None
+                ]
+            )
diff --git a/cloudbot/util/web.py b/cloudbot/util/web.py
index 9a2ded90..d9d509f1 100644
--- a/cloudbot/util/web.py
+++ b/cloudbot/util/web.py
@@ -20,15 +20,15 @@
 from typing import Optional
 
 import requests
-from requests import RequestException, Response, PreparedRequest, HTTPError
+from requests import HTTPError, PreparedRequest, RequestException, Response
 
 # Constants
-DEFAULT_SHORTENER = 'is.gd'
-DEFAULT_PASTEBIN = ''
+DEFAULT_SHORTENER = "is.gd"
+DEFAULT_PASTEBIN = ""
 
-HASTEBIN_SERVER = 'https://hastebin.com'
+HASTEBIN_SERVER = "https://hastebin.com"
 
-logger = logging.getLogger('cloudbot')
+logger = logging.getLogger("cloudbot")
 
 
 # Shortening / pasting
@@ -53,7 +53,7 @@ def should_use(self):
             if self.working:
                 return True
 
-            if (time.time() - self.last_check) > (5*60):
+            if (time.time() - self.last_check) > (5 * 60):
                 # It's been 5 minutes, try again
                 self.working = True
                 return True
@@ -79,16 +79,13 @@ def get(self, name):
     def get_item(self, name):
         return self._items.get(name)
 
-    def get_working(self) -> Optional['Item']:
-        working = [
-            item for item in self._items.values()
-            if item.should_use
-        ]
+    def get_working(self) -> Optional["Item"]:
+        working = [item for item in self._items.values() if item.should_use]
 
         if not working:
             return None
 
-        return min(working, key=attrgetter('uses'))
+        return min(working, key=attrgetter("uses"))
 
     def remove(self, name):
         del self._items[name]
@@ -137,7 +134,7 @@ class NoPasteException(Exception):
     """No pastebins succeeded"""
 
 
-def paste(data, ext='txt', service=DEFAULT_PASTEBIN, raise_on_no_paste=False):
+def paste(data, ext="txt", service=DEFAULT_PASTEBIN, raise_on_no_paste=False):
     if service:
         impl = pastebins.get_item(service)
     else:
@@ -174,7 +171,7 @@ class ServiceHTTPError(ServiceError):
     def __init__(self, message: str, response: Response):
         super().__init__(
             response.request,
-            '[HTTP {}] {}'.format(response.status_code, message)
+            "[HTTP {}] {}".format(response.status_code, message),
         )
         self.message = message
         self.response = response
@@ -203,10 +200,10 @@ def expand(self, url):
         except RequestException as e:
             raise ServiceError(e.request, "Connection error occurred") from e
 
-        if 'location' in r.headers:
-            return r.headers['location']
+        if "location" in r.headers:
+            return r.headers["location"]
 
-        raise ServiceHTTPError('That URL does not exist', r)
+        raise ServiceHTTPError("That URL does not exist", r)
 
 
 class Pastebin:
@@ -225,9 +222,9 @@ def paste(self, data, ext):
 
 class Isgd(Shortener):
     def shorten(self, url, custom=None, key=None):
-        p = {'url': url, 'shorturl': custom, 'format': 'json'}
+        p = {"url": url, "shorturl": custom, "format": "json"}
         try:
-            r = requests.get('http://is.gd/create.php', params=p)
+            r = requests.get("http://is.gd/create.php", params=p)
             r.raise_for_status()
         except HTTPError as e:
             r = e.response
@@ -237,15 +234,15 @@ def shorten(self, url, custom=None, key=None):
 
         j = r.json()
 
-        if 'shorturl' in j:
-            return j['shorturl']
+        if "shorturl" in j:
+            return j["shorturl"]
 
-        raise ServiceHTTPError(j['errormessage'], r)
+        raise ServiceHTTPError(j["errormessage"], r)
 
     def expand(self, url):
-        p = {'shorturl': url, 'format': 'json'}
+        p = {"shorturl": url, "format": "json"}
         try:
-            r = requests.get('http://is.gd/forward.php', params=p)
+            r = requests.get("http://is.gd/forward.php", params=p)
             r.raise_for_status()
         except HTTPError as e:
             r = e.response
@@ -255,19 +252,24 @@ def expand(self, url):
 
         j = r.json()
 
-        if 'url' in j:
-            return j['url']
+        if "url" in j:
+            return j["url"]
 
-        raise ServiceHTTPError(j['errormessage'], r)
+        raise ServiceHTTPError(j["errormessage"], r)
 
 
 class Googl(Shortener):
     def shorten(self, url, custom=None, key=None):
-        h = {'content-type': 'application/json'}
-        k = {'key': key}
-        p = {'longUrl': url}
+        h = {"content-type": "application/json"}
+        k = {"key": key}
+        p = {"longUrl": url}
         try:
-            r = requests.post('https://www.googleapis.com/urlshortener/v1/url', params=k, data=json.dumps(p), headers=h)
+            r = requests.post(
+                "https://www.googleapis.com/urlshortener/v1/url",
+                params=k,
+                data=json.dumps(p),
+                headers=h,
+            )
             r.raise_for_status()
         except HTTPError as e:
             r = e.response
@@ -277,15 +279,17 @@ def shorten(self, url, custom=None, key=None):
 
         j = r.json()
 
-        if 'error' not in j:
-            return j['id']
+        if "error" not in j:
+            return j["id"]
 
-        raise ServiceHTTPError(j['error']['message'], r)
+        raise ServiceHTTPError(j["error"]["message"], r)
 
     def expand(self, url):
-        p = {'shortUrl': url}
+        p = {"shortUrl": url}
         try:
-            r = requests.get('https://www.googleapis.com/urlshortener/v1/url', params=p)
+            r = requests.get(
+                "https://www.googleapis.com/urlshortener/v1/url", params=p
+            )
             r.raise_for_status()
         except HTTPError as e:
             r = e.response
@@ -295,17 +299,17 @@ def expand(self, url):
 
         j = r.json()
 
-        if 'error' not in j:
-            return j['longUrl']
+        if "error" not in j:
+            return j["longUrl"]
 
-        raise ServiceHTTPError(j['error']['message'], r)
+        raise ServiceHTTPError(j["error"]["message"], r)
 
 
 class Gitio(Shortener):
     def shorten(self, url, custom=None, key=None):
-        p = {'url': url, 'code': custom}
+        p = {"url": url, "code": custom}
         try:
-            r = requests.post('http://git.io', data=p)
+            r = requests.post("http://git.io", data=p)
             r.raise_for_status()
         except HTTPError as e:
             r = e.response
@@ -314,9 +318,9 @@ def shorten(self, url, custom=None, key=None):
             raise ServiceError(e.request, "Connection error occurred") from e
 
         if r.status_code == requests.codes.created:
-            s = r.headers['location']
+            s = r.headers["location"]
             if custom and custom not in s:
-                raise ServiceHTTPError('That URL is already in use', r)
+                raise ServiceHTTPError("That URL is already in use", r)
 
             return s
 
@@ -335,7 +339,7 @@ def paste(self, data, ext):
             encoded = data
 
         try:
-            r = requests.post(self.url + '/documents', data=encoded)
+            r = requests.post(self.url + "/documents", data=encoded)
             r.raise_for_status()
         except HTTPError as e:
             r = e.response
@@ -346,13 +350,13 @@ def paste(self, data, ext):
             j = r.json()
 
             if r.status_code is requests.codes.ok:
-                return '{}/{}.{}'.format(self.url, j['key'], ext)
+                return "{}/{}.{}".format(self.url, j["key"], ext)
 
-            raise ServiceHTTPError(j['message'], r)
+            raise ServiceHTTPError(j["message"], r)
 
 
-pastebins.register('hastebin', Hastebin(HASTEBIN_SERVER))
+pastebins.register("hastebin", Hastebin(HASTEBIN_SERVER))
 
-shorteners.register('git.io', Gitio())
-shorteners.register('goo.gl', Googl())
-shorteners.register('is.gd', Isgd())
+shorteners.register("git.io", Gitio())
+shorteners.register("goo.gl", Googl())
+shorteners.register("is.gd", Isgd())
diff --git a/format_json.py b/format_json.py
index 40b1dc3d..33ad5f10 100644
--- a/format_json.py
+++ b/format_json.py
@@ -6,13 +6,13 @@
 import json
 from pathlib import Path
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     path = Path().resolve()
 
     for file in path.rglob("*.json"):
         print(file)
-        with file.open(encoding='utf8') as f:
+        with file.open(encoding="utf8") as f:
             data = json.load(f, object_pairs_hook=collections.OrderedDict)
 
-        with file.open('w', encoding='utf8') as f:
+        with file.open("w", encoding="utf8") as f:
             print(json.dumps(data, indent=4), file=f)
diff --git a/plugins/admin_channel.py b/plugins/admin_channel.py
index 5a36f275..b8c0d35f 100644
--- a/plugins/admin_channel.py
+++ b/plugins/admin_channel.py
@@ -36,13 +36,15 @@ def mode_cmd(mode, text, text_inp, chan, nick, event, mode_warn=True):
         target = split[0]
 
     event.notice("Attempting to {} {} in {}...".format(text, target, channel))
-    event.admin_log(MODE_CMD_LOG.format(
-        nick=nick,
-        cmd=text,
-        mode=mode,
-        target=target,
-        channel=channel,
-    ))
+    event.admin_log(
+        MODE_CMD_LOG.format(
+            nick=nick,
+            cmd=text,
+            mode=mode,
+            target=target,
+            channel=channel,
+        )
+    )
     event.conn.send("MODE {} {} {}".format(channel, mode, target))
 
     return True
@@ -60,12 +62,14 @@ def mode_cmd_no_target(mode, text, text_inp, chan, event, mode_warn=True):
         channel = chan
 
     event.notice("Attempting to {} {}...".format(text, channel))
-    event.admin_log(MODE_CMD_NO_TARGET_LOG.format(
-        nick=event.nick,
-        cmd=text,
-        mode=mode,
-        channel=channel,
-    ))
+    event.admin_log(
+        MODE_CMD_NO_TARGET_LOG.format(
+            nick=event.nick,
+            cmd=text,
+            mode=mode,
+            channel=channel,
+        )
+    )
     event.conn.send("MODE {} {}".format(channel, mode))
     return True
 
@@ -108,7 +112,7 @@ def quiet(text, chan, nick, event):
     if mode_cmd("+q", "quiet", text, chan, nick, event, False):
         return
 
-    if not do_extban('m', "quiet", text, chan, nick, event, True):
+    if not do_extban("m", "quiet", text, chan, nick, event, True):
         event.notice("Unable to set +q or a mute extban on this network.")
 
 
@@ -118,7 +122,7 @@ def unquiet(text, chan, nick, event):
     if mode_cmd("-q", "unquiet", text, chan, nick, event, False):
         return
 
-    if not do_extban('m', "unquiet", text, chan, nick, event, False):
+    if not do_extban("m", "unquiet", text, chan, nick, event, False):
         event.notice("Unable to unset +q or a mute extban on this network.")
 
 
@@ -149,7 +153,7 @@ def deop(text, chan, nick, event):
 @hook.command(permissions=["op_topic", "op", "chanop"])
 def topic(text, conn, chan, nick, event):
     """[channel] <topic> - changes the topic to <topic> in [channel], or in the caller's channel
-     if no channel is specified"""
+    if no channel is specified"""
     split = text.split(" ")
     if split[0].startswith("#"):
         msg = " ".join(split[1:])
@@ -198,9 +202,9 @@ def remove(text, chan, conn, nick, event):
     else:
         reason = "requested by {}.".format(nick)
     out = "REMOVE {} {} :{}".format(user, chan, reason)
-    event.admin_log(REMOVE_LOG.format(
-        nick=nick, target=user, channel=chan, reason=reason
-    ))
+    event.admin_log(
+        REMOVE_LOG.format(nick=nick, target=user, channel=chan, reason=reason)
+    )
     conn.send(out)
 
 
diff --git a/plugins/animal_gifs.py b/plugins/animal_gifs.py
index 22a5771b..238a40cc 100644
--- a/plugins/animal_gifs.py
+++ b/plugins/animal_gifs.py
@@ -17,8 +17,11 @@
 
 def get_gifs(url):
     soup = get_soup(url)
-    container = soup.find('div', class_="row")
-    gifs = [urljoin(url, elem["data-src"]) for elem in container.find_all('img', {'data-src': True})]
+    container = soup.find("div", class_="row")
+    gifs = [
+        urljoin(url, elem["data-src"])
+        for elem in container.find_all("img", {"data-src": True})
+    ]
     return gifs
 
 
diff --git a/plugins/badwords.py b/plugins/badwords.py
index 892a9310..d008b78b 100644
--- a/plugins/badwords.py
+++ b/plugins/badwords.py
@@ -1,22 +1,23 @@
 import re
 from collections import defaultdict
+from typing import Dict, List
 
-from sqlalchemy import Table, Column, String, PrimaryKeyConstraint, select
+from sqlalchemy import Column, PrimaryKeyConstraint, String, Table, select
 
 from cloudbot import hook
 from cloudbot.event import EventType
 from cloudbot.util import database
 
 table = Table(
-    'badwords',
+    "badwords",
     database.metadata,
-    Column('word', String),
-    Column('nick', String),
-    Column('chan', String),
-    PrimaryKeyConstraint('word', 'chan')
+    Column("word", String),
+    Column("nick", String),
+    Column("chan", String),
+    PrimaryKeyConstraint("word", "chan"),
 )
 
-badcache = defaultdict(list)
+badcache: Dict[str, List[str]] = defaultdict(list)
 
 
 class BadwordMatcher:
@@ -37,7 +38,8 @@ def load_bad(db):
         words.append(word)
 
     new_regex = re.compile(
-        r'(\s|^|[^\w\s])({0})(\s|$|[^\w\s])'.format('|'.join(words)), re.IGNORECASE
+        r"(\s|^|[^\w\s])({0})(\s|$|[^\w\s])".format("|".join(words)),
+        re.IGNORECASE,
     )
 
     matcher.regex = new_regex
@@ -51,7 +53,7 @@ def add_bad(text, nick, db):
     """<word> <channel> - adds a bad word to the auto kick list must specify a channel with each word"""
     splt = text.lower().split(None, 1)
     word, channel = splt
-    if not channel.startswith('#'):
+    if not channel.startswith("#"):
         return "Please specify a valid channel name after the bad word."
 
     word = re.escape(word)
@@ -62,9 +64,9 @@ def add_bad(text, nick, db):
         )
 
     if len(badcache[channel]) >= 10:
-        return "There are too many words listed for channel {}. Please remove a word using .rmbad before adding " \
-               "anymore. For a list of bad words use .listbad".format(
-            channel
+        return (
+            "There are too many words listed for channel {}. Please remove a word using .rmbad before adding "
+            "anymore. For a list of bad words use .listbad".format(channel)
         )
 
     db.execute(table.insert().values(word=word, nick=nick, chan=channel))
@@ -79,10 +81,14 @@ def del_bad(text, db):
     """<word> <channel> - removes the specified word from the specified channels bad word list"""
     splt = text.lower().split(None, 1)
     word, channel = splt
-    if not channel.startswith('#'):
+    if not channel.startswith("#"):
         return "Please specify a valid channel name after the bad word."
 
-    db.execute(table.delete().where(table.c.word == word).where(table.c.chan == channel))
+    db.execute(
+        table.delete()
+        .where(table.c.word == word)
+        .where(table.c.chan == channel)
+    )
     db.commit()
     newlist = list_bad(channel)
     load_bad(db)
@@ -94,11 +100,11 @@ def del_bad(text, db):
 @hook.command("listbad", permissions=["badwords"])
 def list_bad(text):
     """<channel> - Returns a list of bad words specify a channel to see words for a particular channel"""
-    text = text.split(' ')[0].lower()
-    if not text.startswith('#'):
+    text = text.split(" ")[0].lower()
+    if not text.startswith("#"):
         return "Please specify a valid channel name"
 
-    return '|'.join(badcache[text])
+    return "|".join(badcache[text])
 
 
 @hook.event([EventType.message, EventType.action], singlethread=True)
diff --git a/plugins/bible.py b/plugins/bible.py
index b644df5a..0d331e72 100644
--- a/plugins/bible.py
+++ b/plugins/bible.py
@@ -7,21 +7,19 @@
 def bible(text, reply):
     """<passage> - Prints the specified passage from the Bible"""
     passage = text.strip()
-    params = {
-        'passage': passage,
-        'formatting': 'plain',
-        'type': 'json'
-    }
+    params = {"passage": passage, "formatting": "plain", "type": "json"}
     try:
         r = requests.get("https://labs.bible.org/api", params=params)
         r.raise_for_status()
         response = r.json()[0]
     except Exception:
-        reply("Something went wrong, either you entered an invalid passage or the API is down.")
+        reply(
+            "Something went wrong, either you entered an invalid passage or the API is down."
+        )
         raise
 
-    book = response['bookname']
-    ch = response['chapter']
-    ver = response['verse']
-    txt = response['text']
+    book = response["bookname"]
+    ch = response["chapter"]
+    ver = response["verse"]
+    txt = response["text"]
     return "\x02{} {}:{}\x02 {}".format(book, ch, ver, txt)
diff --git a/plugins/books.py b/plugins/books.py
index bc4166a4..2eb905b1 100644
--- a/plugins/books.py
+++ b/plugins/books.py
@@ -5,18 +5,20 @@
 from cloudbot.bot import bot
 from cloudbot.util import formatting, web
 
-base_url = 'https://www.googleapis.com/books/v1/'
-book_search_api = base_url + 'volumes?'
+base_url = "https://www.googleapis.com/books/v1/"
+book_search_api = base_url + "volumes?"
 
 
 @hook.command("books", "gbooks")
 def books(text, reply):
     """<query> - Searches Google Books for <query>."""
-    dev_key = bot.config.get_api_key('google_dev_key')
+    dev_key = bot.config.get_api_key("google_dev_key")
     if not dev_key:
         return "This command requires a Google Developers Console API key."
 
-    request = requests.get(book_search_api, params={"q": text, "key": dev_key, "country": "US"})
+    request = requests.get(
+        book_search_api, params={"q": text, "key": dev_key, "country": "US"}
+    )
 
     try:
         request.raise_for_status()
@@ -26,41 +28,45 @@ def books(text, reply):
 
     json = request.json()
 
-    if json.get('error'):
-        if json['error']['code'] == 403:
+    if json.get("error"):
+        if json["error"]["code"] == 403:
             return "The Books API is off in the Google Developers Console (or check the console)."
 
-        return 'Error performing search.'
+        return "Error performing search."
 
-    if json['totalItems'] == 0:
-        return 'No results found.'
+    if json["totalItems"] == 0:
+        return "No results found."
 
-    book = json['items'][0]['volumeInfo']
-    title = book['title']
+    book = json["items"][0]["volumeInfo"]
+    title = book["title"]
     try:
-        author = book['authors'][0]
+        author = book["authors"][0]
     except KeyError:
         try:
-            author = book['publisher']
+            author = book["publisher"]
         except KeyError:
             author = "Unknown Author"
 
     try:
-        description = formatting.truncate_str(book['description'], 130)
+        description = formatting.truncate_str(book["description"], 130)
     except KeyError:
         description = "No description available."
 
     try:
-        year = book['publishedDate'][:4]
+        year = book["publishedDate"][:4]
     except KeyError:
         year = "No Year"
 
     try:
-        page_count = book['pageCount']
-        pages = ' - \x02{:,}\x02 page{}'.format(page_count, "s"[page_count == 1:])
+        page_count = book["pageCount"]
+        pages = " - \x02{:,}\x02 page{}".format(
+            page_count, "s"[page_count == 1 :]
+        )
     except KeyError:
-        pages = ''
+        pages = ""
 
-    link = web.shorten(book['infoLink'], service="goo.gl", key=dev_key)
+    link = web.shorten(book["infoLink"], service="goo.gl", key=dev_key)
 
-    return "\x02{}\x02 by \x02{}\x02 ({}){} - {} - {}".format(title, author, year, pages, description, link)
+    return "\x02{}\x02 by \x02{}\x02 ({}){} - {} - {}".format(
+        title, author, year, pages, description, link
+    )
diff --git a/plugins/brainfuck.py b/plugins/brainfuck.py
index 735e8efb..9d71a279 100644
--- a/plugins/brainfuck.py
+++ b/plugins/brainfuck.py
@@ -17,14 +17,14 @@ class UnbalancedBrackets(ValueError):
 class BrainfuckProgram:
     def __init__(self, text):
         self.op_map = {
-            '+': self.inc,
-            '-': self.dec,
-            '>': self.next_cell,
-            '<': self.prev_cell,
-            '.': self.print,
-            ',': self.set_random,
-            '[': self.loop_enter,
-            ']': self.loop_exit,
+            "+": self.inc,
+            "-": self.dec,
+            ">": self.next_cell,
+            "<": self.prev_cell,
+            ".": self.print,
+            ",": self.set_random,
+            "[": self.loop_enter,
+            "]": self.loop_exit,
         }
 
         self.ip = 0  # instruction pointer
@@ -41,9 +41,9 @@ def populate_brackets(self):
         open_brackets = []
         bracket_map = {}
         for pos, c in enumerate(self.text):
-            if c == '[':
+            if c == "[":
                 open_brackets.append(pos)
-            elif c == ']':
+            elif c == "]":
                 if not open_brackets:
                     raise UnbalancedBrackets()
 
@@ -111,7 +111,7 @@ def bf(text):
     :type text: str
     """
 
-    program_text = re.sub(r'[^][<>+\-.,]', '', text)
+    program_text = re.sub(r"[^][<>+\-.,]", "", text)
 
     try:
         program = BrainfuckProgram(program_text)
@@ -131,7 +131,7 @@ def bf(text):
             program.output += "(exceeded {} iterations)".format(MAX_STEPS)
             break
 
-    stripped_output = re.sub(r'[\x00-\x1F]', '', program.output)
+    stripped_output = re.sub(r"[\x00-\x1F]", "", program.output)
 
     if not stripped_output:
         if program.output:
diff --git a/plugins/brew.py b/plugins/brew.py
index eda20923..43b49ce0 100644
--- a/plugins/brew.py
+++ b/plugins/brew.py
@@ -7,14 +7,14 @@
 api_url = "http://api.brewerydb.com/v2/search?format=json"
 
 
-@hook.command('brew')
+@hook.command("brew")
 def brew(text, reply):
     """<query> - returns the first brewerydb search result for <query>"""
-    api_key = bot.config.get_api_key('brewerydb')
+    api_key = bot.config.get_api_key("brewerydb")
     if not api_key:
         return "No brewerydb API key set."
 
-    params = {'key': api_key, 'type': 'beer', 'withBreweries': 'Y', 'q': text}
+    params = {"key": api_key, "type": "beer", "withBreweries": "Y", "q": text}
     request = requests.get(api_url, params=params)
 
     try:
@@ -28,35 +28,36 @@ def brew(text, reply):
     output = "No results found."
 
     try:
-        if 'totalResults' in response:
-            if response['totalResults'] == 0:
+        if "totalResults" in response:
+            if response["totalResults"] == 0:
                 return output
 
-            beer = response['data'][0]
-            brewery = beer['breweries'][0]
+            beer = response["data"][0]
+            brewery = beer["breweries"][0]
 
-            style = 'unknown style'
-            if 'style' in beer:
-                style = beer['style']['shortName']
+            style = "unknown style"
+            if "style" in beer:
+                style = beer["style"]["shortName"]
 
-            abv = '?.?'
-            if 'abv' in beer:
-                abv = beer['abv']
+            abv = "?.?"
+            if "abv" in beer:
+                abv = beer["abv"]
 
-            url = '[no website found]'
-            if 'website' in brewery:
-                url = brewery['website']
+            url = "[no website found]"
+            if "website" in brewery:
+                url = brewery["website"]
 
             content = {
-                'name': beer['nameDisplay'],
-                'style': style,
-                'abv': abv,
-                'brewer': brewery['name'],
-                'url': url
+                "name": beer["nameDisplay"],
+                "style": style,
+                "abv": abv,
+                "brewer": brewery["name"],
+                "url": url,
             }
 
-            output = "{name} by {brewer} ({style}, {abv}% ABV) - {url}" \
-                .format(**content)
+            output = "{name} by {brewer} ({style}, {abv}% ABV) - {url}".format(
+                **content
+            )
 
     except Exception:
         reply("Error parsing results.")
diff --git a/plugins/cats.py b/plugins/cats.py
index 180379a3..57f5035e 100644
--- a/plugins/cats.py
+++ b/plugins/cats.py
@@ -6,7 +6,9 @@
 
 def get_data(url, reply, bot, params=None):
     try:
-        r = requests.get(url, headers={'User-Agent': bot.user_agent}, params=params)
+        r = requests.get(
+            url, headers={"User-Agent": bot.user_agent}, params=params
+        )
         r.raise_for_status()
     except HTTPError:
         reply("API error occurred.")
@@ -18,9 +20,11 @@ def get_data(url, reply, bot, params=None):
 @hook.command(autohelp=False)
 def cats(reply, bot):
     """- gets a fucking fact about cats."""
-    r = get_data('https://catfact.ninja/fact', reply, bot, params={'max_length': 100})
+    r = get_data(
+        "https://catfact.ninja/fact", reply, bot, params={"max_length": 100}
+    )
     json = r.json()
-    response = json['fact']
+    response = json["fact"]
     return response
 
 
diff --git a/plugins/chain.py b/plugins/chain.py
index dca863e0..27c61388 100644
--- a/plugins/chain.py
+++ b/plugins/chain.py
@@ -1,7 +1,8 @@
 import itertools
 from operator import attrgetter
+from typing import Dict
 
-from sqlalchemy import Table, Column, String, Boolean, PrimaryKeyConstraint
+from sqlalchemy import Boolean, Column, PrimaryKeyConstraint, String, Table
 
 from cloudbot import hook
 from cloudbot.event import CommandEvent
@@ -9,14 +10,14 @@
 from cloudbot.util.formatting import chunk_str, pluralize_auto
 
 commands = Table(
-    'chain_commands',
+    "chain_commands",
     database.metadata,
-    Column('hook', String),
-    Column('allowed', Boolean, default=True),
-    PrimaryKeyConstraint('hook', 'allowed')
+    Column("hook", String),
+    Column("allowed", Boolean, default=True),
+    PrimaryKeyConstraint("hook", "allowed"),
 )
 
-allow_cache = {}
+allow_cache: Dict[str, bool] = {}
 
 
 @hook.on_start
@@ -35,7 +36,7 @@ def format_hook_name(_hook):
 
 def get_hook_from_command(bot, hook_name):
     manager = bot.plugin_manager
-    if '.' in hook_name:
+    if "." in hook_name:
         for _hook in manager.commands.values():
             if format_hook_name(_hook) == hook_name:
                 return _hook
@@ -74,7 +75,7 @@ def chainallow(text, db, notice_doc, bot):
     hook_name = format_hook_name(_hook)
 
     if subcmd == "add":
-        values = {'hook': hook_name}
+        values = {"hook": hook_name}
         if args:
             allow = args.pop(0).lower()
             if allow == "allow":
@@ -84,10 +85,14 @@ def chainallow(text, db, notice_doc, bot):
             else:
                 return notice_doc()
 
-            values['allowed'] = allow
+            values["allowed"] = allow
 
         updated = True
-        res = db.execute(commands.update().values(**values).where(commands.c.hook == hook_name))
+        res = db.execute(
+            commands.update()
+            .values(**values)
+            .where(commands.c.hook == hook_name)
+        )
         if res.rowcount == 0:
             updated = False
             db.execute(commands.insert().values(**values))
@@ -95,7 +100,9 @@ def chainallow(text, db, notice_doc, bot):
         db.commit()
         load_cache(db)
         if updated:
-            return "Updated state of '{}' in chainallow to allowed={}".format(hook_name, allow_cache.get(hook_name))
+            return "Updated state of '{}' in chainallow to allowed={}".format(
+                hook_name, allow_cache.get(hook_name)
+            )
 
         if allow_cache.get(hook_name):
             return "Added '{}' as an allowed command".format(hook_name)
@@ -112,11 +119,11 @@ def chainallow(text, db, notice_doc, bot):
 
 
 def parse_chain(text, bot):
-    parts = text.split('|')
+    parts = text.split("|")
     cmds = []
 
     for part in parts:
-        cmd, _, args = part.strip().partition(' ')
+        cmd, _, args = part.strip().partition(" ")
         _hook = get_hook_from_command(bot, cmd)
         cmds.append([cmd, _hook, args or ""])
 
@@ -129,7 +136,13 @@ def is_hook_allowed(_hook):
 
 
 def wrap_event(_hook, event, cmd, args):
-    cmd_event = CommandEvent(base_event=event, text=args.strip(), triggered_command=cmd, hook=_hook, cmd_prefix='')
+    cmd_event = CommandEvent(
+        base_event=event,
+        text=args.strip(),
+        triggered_command=cmd,
+        hook=_hook,
+        cmd_prefix="",
+    )
     return cmd_event
 
 
@@ -144,13 +157,21 @@ async def chain(text, bot, event):
             return "Unable to find command '{}'".format(name)
 
         if not is_hook_allowed(_hook):
-            event.notice("'{}' may not be used in command piping".format(format_hook_name(_hook)))
+            event.notice(
+                "'{}' may not be used in command piping".format(
+                    format_hook_name(_hook)
+                )
+            )
             return
 
         if _hook.permissions:
             allowed = await event.check_permissions(_hook.permissions)
             if not allowed:
-                event.notice("Sorry, you are not allowed to use '{}'.".format(format_hook_name(_hook)))
+                event.notice(
+                    "Sorry, you are not allowed to use '{}'.".format(
+                        format_hook_name(_hook)
+                    )
+                )
                 return
 
     buffer = ""
@@ -220,7 +241,11 @@ def action(msg, target=None):
 @hook.command(autohelp=False)
 def chainlist(notice, bot):
     """- Returns the list of commands allowed in 'chain'"""
-    hooks = [get_hook_from_command(bot, name) for name, allowed in allow_cache.items() if allowed]
+    hooks = [
+        get_hook_from_command(bot, name)
+        for name, allowed in allow_cache.items()
+        if allowed
+    ]
     cmds = itertools.chain.from_iterable(map(attrgetter("aliases"), hooks))
     cmds = sorted(cmds)
     for part in chunk_str(", ".join(cmds)):
diff --git a/plugins/cheer.py b/plugins/cheer.py
index bcac980e..c8e1f830 100644
--- a/plugins/cheer.py
+++ b/plugins/cheer.py
@@ -1,20 +1,21 @@
 import random
 import re
 from pathlib import Path
+from typing import List
 
 from cloudbot import hook
 
-cheer_re = re.compile(r'\\o/', re.IGNORECASE)
+cheer_re = re.compile(r"\\o/", re.IGNORECASE)
 
-cheers = []
+cheers: List[str] = []
 
 
 @hook.on_start
 def load_cheers(bot):
     cheers.clear()
     data_file = Path(bot.data_dir) / "cheers.txt"
-    with data_file.open(encoding='utf-8') as f:
-        cheers.extend(line.strip() for line in f if not line.startswith('//'))
+    with data_file.open(encoding="utf-8") as f:
+        cheers.extend(line.strip() for line in f if not line.startswith("//"))
 
 
 @hook.regex(cheer_re)
diff --git a/plugins/core/autojoin.py b/plugins/core/autojoin.py
index ebd1b41d..c3885a12 100644
--- a/plugins/core/autojoin.py
+++ b/plugins/core/autojoin.py
@@ -2,41 +2,44 @@
 from collections import defaultdict
 from copy import copy
 from threading import RLock
+from typing import Dict, Set
 
-from sqlalchemy import PrimaryKeyConstraint, Column, String, Table, and_
+from sqlalchemy import Column, PrimaryKeyConstraint, String, Table, and_
 from sqlalchemy.exc import IntegrityError
 
 from cloudbot import hook
 from cloudbot.util import database
 
 table = Table(
-    'autojoin',
+    "autojoin",
     database.metadata,
-    Column('conn', String),
-    Column('chan', String),
-    PrimaryKeyConstraint('conn', 'chan')
+    Column("conn", String),
+    Column("chan", String),
+    PrimaryKeyConstraint("conn", "chan"),
 )
 
-chan_cache = defaultdict(set)
+chan_cache: Dict[str, Set[str]] = defaultdict(set)
 db_lock = RLock()
 
 
 def get_channels(db, conn):
-    return db.execute(table.select().where(table.c.conn == conn.name.casefold())).fetchall()
+    return db.execute(
+        table.select().where(table.c.conn == conn.name.casefold())
+    ).fetchall()
 
 
 @hook.on_start
 def load_cache(db):
     new_cache = defaultdict(set)
     for row in db.execute(table.select()):
-        new_cache[row['conn']].add(row['chan'])
+        new_cache[row["conn"]].add(row["chan"])
 
     with db_lock:
         chan_cache.clear()
         chan_cache.update(new_cache)
 
 
-@hook.irc_raw('376')
+@hook.irc_raw("376")
 async def do_joins(conn):
     while not conn.ready:
         await asyncio.sleep(1)
@@ -47,14 +50,18 @@ async def do_joins(conn):
         await asyncio.sleep(join_throttle)
 
 
-@hook.irc_raw('JOIN', singlethread=True)
+@hook.irc_raw("JOIN", singlethread=True)
 def add_chan(db, conn, chan, nick):
     chans = chan_cache[conn.name]
     chan = chan.casefold()
     if nick.casefold() == conn.nick.casefold() and chan not in chans:
         with db_lock:
             try:
-                db.execute(table.insert().values(conn=conn.name.casefold(), chan=chan.casefold()))
+                db.execute(
+                    table.insert().values(
+                        conn=conn.name.casefold(), chan=chan.casefold()
+                    )
+                )
             except IntegrityError:
                 db.rollback()
             else:
@@ -63,17 +70,23 @@ def add_chan(db, conn, chan, nick):
                 load_cache(db)
 
 
-@hook.irc_raw('PART', singlethread=True)
+@hook.irc_raw("PART", singlethread=True)
 def on_part(db, conn, chan, nick):
     if nick.casefold() == conn.nick.casefold():
         with db_lock:
             db.execute(
-                table.delete().where(and_(table.c.conn == conn.name.casefold(), table.c.chan == chan.casefold())))
+                table.delete().where(
+                    and_(
+                        table.c.conn == conn.name.casefold(),
+                        table.c.chan == chan.casefold(),
+                    )
+                )
+            )
             db.commit()
 
         load_cache(db)
 
 
-@hook.irc_raw('KICK', singlethread=True)
+@hook.irc_raw("KICK", singlethread=True)
 def on_kick(db, conn, chan, target):
     on_part(db, conn, chan, target)
diff --git a/plugins/core/cap.py b/plugins/core/cap.py
index 7ffbc954..77ceec53 100644
--- a/plugins/core/cap.py
+++ b/plugins/core/cap.py
@@ -26,7 +26,9 @@ async def handle_available_caps(conn, caplist, event, irc_paramlist, bot):
     for cap in caplist:
         name = cap.name
         name_cf = name.casefold()
-        cap_event = partial(CapEvent, base_event=event, cap=name, cap_param=cap.value)
+        cap_event = partial(
+            CapEvent, base_event=event, cap=name, cap_param=cap.value
+        )
         tasks = [
             bot.plugin_manager.internal_launch(_hook, cap_event(hook=_hook))
             for _hook in bot.plugin_manager.cap_hooks["on_available"][name_cf]
@@ -36,7 +38,7 @@ async def handle_available_caps(conn, caplist, event, irc_paramlist, bot):
             cap_queue[name_cf] = async_util.create_future(conn.loop)
             conn.cmd("CAP", "REQ", name)
 
-    if irc_paramlist[2] != '*':
+    if irc_paramlist[2] != "*":
         await asyncio.gather(*cap_queue.values())
         cap_queue.clear()
         conn.send("CAP END")
@@ -63,7 +65,9 @@ async def _launch_handler(subcmd, event, **kwargs):
     except LookupError:
         return
 
-    await async_util.run_func_with_args(event.loop, handler, ChainMap(event, kwargs))
+    await async_util.run_func_with_args(
+        event.loop, handler, ChainMap(event, kwargs)
+    )
 
 
 @_subcmd_handler("LS")
@@ -73,7 +77,7 @@ async def cap_ls(conn, caplist, event, irc_paramlist, bot):
 
 
 async def handle_req_resp(enabled, conn, caplist, event, bot):
-    server_caps = conn.memory.setdefault('server_caps', {})
+    server_caps = conn.memory.setdefault("server_caps", {})
     cap_queue = conn.memory.get("cap_queue", {})
     caps = (cap.name.casefold() for cap in caplist)
     for cap in caps:
@@ -114,8 +118,10 @@ async def cap_new(caplist, conn, event, bot, irc_paramlist):
 @_subcmd_handler("DEL")
 def cap_del(conn, caplist):
     # TODO add hooks for CAP removal
-    logger.info("[%s|cap] Capabilities removed by server: %s", conn.name, caplist)
-    server_caps = conn.memory.setdefault('server_caps', {})
+    logger.info(
+        "[%s|cap] Capabilities removed by server: %s", conn.name, caplist
+    )
+    server_caps = conn.memory.setdefault("server_caps", {})
     for cap in caplist:
         server_caps[cap.name.casefold()] = False
 
diff --git a/plugins/core/chan_key_db.py b/plugins/core/chan_key_db.py
index 690157f6..c63d16e0 100644
--- a/plugins/core/chan_key_db.py
+++ b/plugins/core/chan_key_db.py
@@ -34,14 +34,18 @@ def load_keys(conn: IrcClient, db) -> None:
     """
     Load channel keys to the client
     """
-    query = select([table.c.chan, table.c.key], table.c.conn == conn.name.lower())
+    query = select(
+        [table.c.chan, table.c.key], table.c.conn == conn.name.lower()
+    )
     conn.clear_channel_keys()
     for row in db.execute(query):
         conn.set_channel_key(row["chan"], row["key"])
 
 
 @hook.irc_raw("MODE")
-def handle_modes(irc_paramlist: List[str], conn: IrcClient, db, chan: str) -> None:
+def handle_modes(
+    irc_paramlist: List[str], conn: IrcClient, db, chan: str
+) -> None:
     """
     Handle mode changes
     """
@@ -51,7 +55,9 @@ def handle_modes(irc_paramlist: List[str], conn: IrcClient, db, chan: str) -> No
     modes = irc_paramlist[1]
     mode_params = list(irc_paramlist[2:])
     serv_info = get_server_info(conn)
-    mode_changes = parse_mode_string(modes, mode_params, get_channel_modes(serv_info))
+    mode_changes = parse_mode_string(
+        modes, mode_params, get_channel_modes(serv_info)
+    )
     updated = False
     for change in mode_changes:
         if change.char == "k":
@@ -82,7 +88,10 @@ def make_clause(conn: Client, chan: str) -> BooleanClauseList:
     """
     Generate a WHERE clause to match keys for this conn+channel
     """
-    return and_(table.c.conn == conn.name.lower(), table.c.chan == chan.lower(),)
+    return and_(
+        table.c.conn == conn.name.lower(),
+        table.c.chan == chan.lower(),
+    )
 
 
 def clear_key(db: Session, conn, chan: str) -> None:
@@ -92,7 +101,9 @@ def clear_key(db: Session, conn, chan: str) -> None:
     db.execute(table.delete().where(make_clause(conn, chan)))
 
 
-def set_key(db: Session, conn: IrcClient, chan: str, key: Optional[str]) -> None:
+def set_key(
+    db: Session, conn: IrcClient, chan: str, key: Optional[str]
+) -> None:
     """
     Set the key for a channel
     """
@@ -106,7 +117,9 @@ def set_key(db: Session, conn: IrcClient, chan: str, key: Optional[str]) -> None
 
 
 @hook.irc_out()
-def check_send_key(conn: IrcClient, parsed_line: Message, db: Session) -> Message:
+def check_send_key(
+    conn: IrcClient, parsed_line: Message, db: Session
+) -> Message:
     """
     Parse outgoing JOIN messages and store used channel keys
     """
diff --git a/plugins/core/chan_log.py b/plugins/core/chan_log.py
index 0e28d91e..763171a9 100644
--- a/plugins/core/chan_log.py
+++ b/plugins/core/chan_log.py
@@ -46,7 +46,7 @@ def is_dunder(name: str) -> bool:
     :param name: The name to check
     :return: True if the name is a dunder, False otherwise
     """
-    return len(name) > 4 and name.startswith('__') and name.endswith('__')
+    return len(name) > 4 and name.startswith("__") and name.endswith("__")
 
 
 AttrList = Iterable[Tuple[str, Any]]
@@ -86,7 +86,7 @@ def dump_attrs(obj: object, ignore_dunder: bool = False) -> AttrList:
         yield (name, getattr(obj, name, None))
 
 
-def indent(lines: Iterable[str], size: int = 2, char: str = ' '):
+def indent(lines: Iterable[str], size: int = 2, char: str = " "):
     """
     Indent each line in an iterable and yield it, ignoring blank lines
 
@@ -134,7 +134,7 @@ def format_error_data(exc: Exception) -> Iterable[str]:
         if isinstance(exc, typ):
             yield from indent(func(exc))
 
-    yield ''
+    yield ""
 
 
 def format_error_chain(exc: Exception) -> Iterable[str]:
@@ -149,8 +149,8 @@ def format_error_chain(exc: Exception) -> Iterable[str]:
         yield from format_error_data(exc)
         # Get "direct cause of" or
         # "during handling of ..., another exception occurred" stack
-        cause = getattr(exc, '__cause__', None)
-        context = getattr(exc, '__context__', None)
+        cause = getattr(exc, "__cause__", None)
+        context = getattr(exc, "__context__", None)
         exc = cause or context
 
 
@@ -169,7 +169,7 @@ def format_attrs(obj: object, ignore_dunder: bool = False) -> Iterable[str]:
     :return: An iterable of lines of formatted data
     """
     for k, v in dump_attrs(obj, ignore_dunder=ignore_dunder):
-        yield '{} = {!r}'.format(k, v)
+        yield "{} = {!r}".format(k, v)
 
 
 @hook.post_hook
@@ -190,12 +190,10 @@ def on_hook_end(error, launched_hook, launched_event, admin_log):
         messages.append(last_line.strip())
     except Exception:
         msg = traceback.format_exc()[-1]
-        messages.append(
-            "Error occurred while formatting error {}".format(msg)
-        )
+        messages.append("Error occurred while formatting error {}".format(msg))
     else:
         try:
-            url = web.paste('\n'.join(lines))
+            url = web.paste("\n".join(lines))
             messages.append("Traceback: " + url)
         except Exception:
             msg = traceback.format_exc()[-1]
@@ -212,7 +210,7 @@ def on_hook_end(error, launched_hook, launched_event, admin_log):
         lines.append("Error data:")
         lines.extend(indent(format_error_chain(exc)))
 
-        url = web.paste('\n'.join(lines))
+        url = web.paste("\n".join(lines))
         messages.append("Event: " + url)
     except Exception:
         msg = traceback.format_exc()[-1]
diff --git a/plugins/core/check_conn.py b/plugins/core/check_conn.py
index 3223a2af..042c1299 100644
--- a/plugins/core/check_conn.py
+++ b/plugins/core/check_conn.py
@@ -68,17 +68,17 @@ def format_conn(conn):
     else:
         out = "$(red){name}$(clear)"
 
-    return colors.parse(out.format(
-        name=conn.name, activity=round(lag * 1000, 3)
-    ))
+    return colors.parse(
+        out.format(name=conn.name, activity=round(lag * 1000, 3))
+    )
 
 
-@hook.command("connlist", "listconns", autohelp=False, permissions=["botcontrol"])
+@hook.command(
+    "connlist", "listconns", autohelp=False, permissions=["botcontrol"]
+)
 def list_conns(bot):
     """- Lists all current connections and their status"""
-    conns = ', '.join(
-        map(format_conn, bot.connections.values())
-    )
+    conns = ", ".join(map(format_conn, bot.connections.values()))
     return "Current connections: {}".format(conns)
 
 
@@ -90,7 +90,7 @@ def on_connect(conn):
     conn.memory["last_activity"] = now
     conn.memory["lag"] = 0
     conn.memory["needs_reconnect"] = False
-    conn.memory['last_ping_rpl'] = now
+    conn.memory["last_ping_rpl"] = now
 
 
 @hook.command("lagcheck", autohelp=False, permissions=["botcontrol"])
@@ -134,13 +134,13 @@ async def reconnect_loop(bot):
             await do_reconnect(conn)
 
 
-@hook.irc_raw('PONG')
+@hook.irc_raw("PONG")
 def on_pong(conn, irc_paramlist):
     now = time.time()
     conn.memory["ping_recv"] = now
     timestamp = irc_paramlist[-1]
     is_lag = False
-    if timestamp.startswith('LAGCHECK'):
+    if timestamp.startswith("LAGCHECK"):
         timestamp = timestamp[8:]
         is_lag = True
 
@@ -153,7 +153,7 @@ def on_pong(conn, irc_paramlist):
         conn.memory["last_ping_rpl"] = now
 
 
-@hook.irc_raw('*')
+@hook.irc_raw("*")
 async def on_act(conn):
     now = time.time()
-    conn.memory['last_activity'] = now
+    conn.memory["last_activity"] = now
diff --git a/plugins/core/core_hooks.py b/plugins/core/core_hooks.py
index e4b7c59c..8c651bdb 100644
--- a/plugins/core/core_hooks.py
+++ b/plugins/core/core_hooks.py
@@ -4,7 +4,12 @@
 
 @hook.sieve(priority=Priority.LOWEST)
 def cmd_autohelp(bot, event, _hook):
-    if _hook.type == "command" and _hook.auto_help and not event.text and _hook.doc is not None:
+    if (
+        _hook.type == "command"
+        and _hook.auto_help
+        and not event.text
+        and _hook.doc is not None
+    ):
         event.notice_doc()
         return None
 
diff --git a/plugins/core/core_out.py b/plugins/core/core_out.py
index f21ce40d..f13105ec 100644
--- a/plugins/core/core_out.py
+++ b/plugins/core/core_out.py
@@ -6,11 +6,13 @@
 from cloudbot.hook import Priority
 from cloudbot.util import colors
 
-NEW_LINE_TRANS_TBL = str.maketrans({
-    '\r': None,
-    '\n': None,
-    '\0': None,
-})
+NEW_LINE_TRANS_TBL = str.maketrans(
+    {
+        "\r": None,
+        "\n": None,
+        "\0": None,
+    }
+)
 
 
 @hook.irc_out(priority=Priority.HIGHEST)
@@ -47,8 +49,15 @@ def encode_line(line, conn):
 @hook.irc_out(priority=Priority.HIGH)
 def strip_command_chars(parsed_line, conn, line):
     chars = conn.config.get("strip_cmd_chars", "!.@;$")
-    if chars and parsed_line and parsed_line.command == "PRIVMSG" and parsed_line.parameters[-1][0] in chars:
-        new_msg = colors.parse("$(red)[!!]$(clear) ") + parsed_line.parameters[-1]
+    if (
+        chars
+        and parsed_line
+        and parsed_line.command == "PRIVMSG"
+        and parsed_line.parameters[-1][0] in chars
+    ):
+        new_msg = (
+            colors.parse("$(red)[!!]$(clear) ") + parsed_line.parameters[-1]
+        )
         parsed_line.parameters[-1] = new_msg
         parsed_line.has_trail = True
         return parsed_line
diff --git a/plugins/core/core_tracker.py b/plugins/core/core_tracker.py
index 89e9afd9..5d699a2c 100644
--- a/plugins/core/core_tracker.py
+++ b/plugins/core/core_tracker.py
@@ -10,6 +10,7 @@
 
 # functions called for bot state tracking
 
+
 def bot_left_channel(conn, chan):
     logger.info("[%s|tracker] Bot left channel %r", conn.name, chan)
     if chan in conn.channels:
@@ -35,10 +36,15 @@ async def on_kick(conn, chan, target, loop):
     # if the bot has been kicked, remove from the channel list
     if target == conn.nick:
         bot_left_channel(conn, chan)
-        if conn.config.get('auto_rejoin', False):
+        if conn.config.get("auto_rejoin", False):
             loop.call_later(5, conn.join, chan)
-            loop.call_later(5, logger.info, "[%s|tracker] Bot was kicked from %s, "
-                                            "rejoining channel.", conn.name, chan)
+            loop.call_later(
+                5,
+                logger.info,
+                "[%s|tracker] Bot was kicked from %s, " "rejoining channel.",
+                conn.name,
+                chan,
+            )
 
 
 @hook.irc_raw("NICK")
@@ -53,7 +59,12 @@ async def on_nick(irc_paramlist, conn, nick):
 
     if old_nick == conn.nick:
         conn.nick = new_nick
-        logger.info("[%s|tracker] Bot nick changed from %r to %r.", conn.name, old_nick, new_nick)
+        logger.info(
+            "[%s|tracker] Bot nick changed from %r to %r.",
+            conn.name,
+            old_nick,
+            new_nick,
+        )
 
 
 # for channels the host tells us we're joining without us joining it ourselves
diff --git a/plugins/core/help.py b/plugins/core/help.py
index 553a1908..522aac71 100644
--- a/plugins/core/help.py
+++ b/plugins/core/help.py
@@ -19,7 +19,9 @@ def get_potential_commands(bot, cmd_name):
 
 
 @hook.command("help", autohelp=False)
-async def help_command(text, chan, bot, notice, message, has_permission, triggered_prefix):
+async def help_command(
+    text, chan, bot, notice, message, has_permission, triggered_prefix
+):
     """[command] - gives help for [command], or lists all available commands if no command is specified
 
     :type chan: str
@@ -38,8 +40,13 @@ async def help_command(text, chan, bot, notice, message, has_permission, trigger
             return
 
         if len(cmds) > 1:
-            notice("Possible matches: {}".format(
-                formatting.get_text_list(sorted([command for command, _ in cmds]))))
+            notice(
+                "Possible matches: {}".format(
+                    formatting.get_text_list(
+                        sorted([command for command, _ in cmds])
+                    )
+                )
+            )
             return
 
         doc = cmds[0][1].doc
@@ -47,11 +54,17 @@ async def help_command(text, chan, bot, notice, message, has_permission, trigger
         if doc:
             notice("{}{} {}".format(triggered_prefix, searching_for, doc))
         else:
-            notice("Command {} has no additional documentation.".format(searching_for))
+            notice(
+                "Command {} has no additional documentation.".format(
+                    searching_for
+                )
+            )
     else:
         commands = []
 
-        for plugin in sorted(set(bot.plugin_manager.commands.values()), key=attrgetter("name")):
+        for plugin in sorted(
+            set(bot.plugin_manager.commands.values()), key=attrgetter("name")
+        ):
             # use set to remove duplicate commands (from multiple aliases), and sorted to sort by name
 
             if plugin.permissions:
@@ -72,7 +85,9 @@ async def help_command(text, chan, bot, notice, message, has_permission, trigger
             commands.append(command)
 
         # list of lines to send to the user
-        lines = formatting.chunk_str("Here's a list of commands you can use: " + ", ".join(commands))
+        lines = formatting.chunk_str(
+            "Here's a list of commands you can use: " + ", ".join(commands)
+        )
 
         for line in lines:
             if chan[:1] == "#":
@@ -81,7 +96,11 @@ async def help_command(text, chan, bot, notice, message, has_permission, trigger
                 # This is an user in this case.
                 message(line)
 
-        notice("For detailed help, use {}help <command>, without the brackets.".format(triggered_prefix))
+        notice(
+            "For detailed help, use {}help <command>, without the brackets.".format(
+                triggered_prefix
+            )
+        )
 
 
 @hook.command
@@ -94,19 +113,24 @@ async def cmdinfo(text, bot, notice):
         return
 
     if len(cmds) > 1:
-        notice("Possible matches: {}".format(
-            formatting.get_text_list(sorted([command for command, plugin in cmds]))))
+        notice(
+            "Possible matches: {}".format(
+                formatting.get_text_list(
+                    sorted([command for command, plugin in cmds])
+                )
+            )
+        )
         return
 
     cmd_hook = cmds[0][1]
 
     hook_name = cmd_hook.plugin.title + "." + cmd_hook.function_name
     info = "Command: {}, Aliases: [{}], Hook name: {}".format(
-        cmd_hook.name, ', '.join(cmd_hook.aliases), hook_name
+        cmd_hook.name, ", ".join(cmd_hook.aliases), hook_name
     )
 
     if cmd_hook.permissions:
-        info += ", Permissions: [{}]".format(', '.join(cmd_hook.permissions))
+        info += ", Permissions: [{}]".format(", ".join(cmd_hook.permissions))
 
     notice(info)
 
@@ -116,7 +140,9 @@ def generatehelp(conn, bot):
     """- Dumps a list of commands with their help text to the docs directory formatted using markdown."""
     message = "{} Command list\n".format(conn.nick)
     message += "------\n"
-    for plugin in sorted(set(bot.plugin_manager.commands.values()), key=attrgetter("name")):
+    for plugin in sorted(
+        set(bot.plugin_manager.commands.values()), key=attrgetter("name")
+    ):
         # use set to remove duplicate commands (from multiple aliases), and sorted to sort by name
         command = plugin.name
         aliases = ""
@@ -132,15 +158,21 @@ def generatehelp(conn, bot):
                 aliases += alias + ", "
         aliases = aliases[:-2]
         if doc:
-            doc = doc.replace("<", "&lt;").replace(">", "&gt;") \
-                .replace("[", "&lt;").replace("]", "&gt;")
+            doc = (
+                doc.replace("<", "&lt;")
+                .replace(">", "&gt;")
+                .replace("[", "&lt;")
+                .replace("]", "&gt;")
+            )
             if aliases:
                 message += "**{} ({}):** {}\n\n".format(command, aliases, doc)
             else:
                 # No aliases so just print the commands
                 message += "**{}**: {}\n\n".format(command, doc)
         else:
-            message += "**{}**: Command has no documentation.\n\n".format(command)
+            message += "**{}**: Command has no documentation.\n\n".format(
+                command
+            )
         if permission:
             message = message[:-2]
             message += " ( *Permission required:* {})\n\n".format(permission)
diff --git a/plugins/core/hook_stats.py b/plugins/core/hook_stats.py
index dbbc0e3f..b91bd032 100644
--- a/plugins/core/hook_stats.py
+++ b/plugins/core/hook_stats.py
@@ -14,7 +14,7 @@
 
 
 def default_hook_counter():
-    return {'success': 0, 'failure': 0}
+    return {"success": 0, "failure": 0}
 
 
 def hook_sorter(n):
@@ -29,9 +29,11 @@ def get_stats(bot):
         stats = bot.memory["hook_stats"]
     except LookupError:
         bot.memory["hook_stats"] = stats = {
-            'global': defaultdict(default_hook_counter),
-            'network': defaultdict(lambda: defaultdict(default_hook_counter)),
-            'channel': defaultdict(lambda: defaultdict(lambda: defaultdict(default_hook_counter))),
+            "global": defaultdict(default_hook_counter),
+            "network": defaultdict(lambda: defaultdict(default_hook_counter)),
+            "channel": defaultdict(
+                lambda: defaultdict(lambda: defaultdict(default_hook_counter))
+            ),
         }
 
     return stats
@@ -41,53 +43,60 @@ def get_stats(bot):
 def stats_sieve(launched_event, error, bot, launched_hook):
     chan = launched_event.chan
     conn = launched_event.conn
-    status = 'success' if error is None else 'failure'
+    status = "success" if error is None else "failure"
     stats = get_stats(bot)
-    name = launched_hook.plugin.title + '.' + launched_hook.function_name
-    stats['global'][name][status] += 1
+    name = launched_hook.plugin.title + "." + launched_hook.function_name
+    stats["global"][name][status] += 1
     if conn:
-        stats['network'][conn.name.casefold()][name][status] += 1
+        stats["network"][conn.name.casefold()][name][status] += 1
 
         if chan:
-            stats['channel'][conn.name.casefold()][chan.casefold()][name][status] += 1
+            stats["channel"][conn.name.casefold()][chan.casefold()][name][
+                status
+            ] += 1
 
 
 def do_basic_stats(data):
     table = [
-        (hook_name, str(count['success']), str(count['failure']))
-        for hook_name, count in sorted(data.items(), key=hook_sorter(1), reverse=True)
+        (hook_name, str(count["success"]), str(count["failure"]))
+        for hook_name, count in sorted(
+            data.items(), key=hook_sorter(1), reverse=True
+        )
     ]
     return ("Hook", "Uses - Success", "Uses - Errored"), table
 
 
 def do_global_stats(data):
-    return do_basic_stats(data['global'])
+    return do_basic_stats(data["global"])
 
 
 def do_network_stats(data, network):
-    return do_basic_stats(data['network'][network.casefold()])
+    return do_basic_stats(data["network"][network.casefold()])
 
 
 def do_channel_stats(data, network, channel):
-    return do_basic_stats(data['channel'][network.casefold()][channel.casefold()])
+    return do_basic_stats(
+        data["channel"][network.casefold()][channel.casefold()]
+    )
 
 
 def do_hook_stats(data, hook_name):
     table = [
-        (net, chan, hooks[hook_name]) for net, chans in data['channel'].items() for chan, hooks in chans.items()
+        (net, chan, hooks[hook_name])
+        for net, chans in data["channel"].items()
+        for chan, hooks in chans.items()
+    ]
+    return ("Network", "Channel", "Uses - Success", "Uses - Errored"), [
+        (net, chan, str(count["success"]), str(count["failure"]))
+        for net, chan, count in sorted(table, key=hook_sorter(2), reverse=True)
     ]
-    return ("Network", "Channel", "Uses - Success", "Uses - Errored"), \
-           [
-               (net, chan, str(count['success']), str(count['failure']))
-               for net, chan, count in sorted(table, key=hook_sorter(2), reverse=True)
-           ]
 
 
 stats_funcs = {
-    'global': (do_global_stats, 0),
-    'network': (do_network_stats, 1),
-    'channel': (do_channel_stats, 2),
-    'hook': (do_hook_stats, 1),
+    "global": (do_global_stats, 0),
+    "network": (do_network_stats, 1),
+    "channel": (do_channel_stats, 2),
+    "hook": (do_hook_stats, 1),
 }
 
 
@@ -116,4 +125,4 @@ def hookstats(text, bot, notice_doc):
 
     table = gen_markdown_table(headers, data)
 
-    return web.paste(table, 'md', 'hastebin')
+    return web.paste(table, "md", "hastebin")
diff --git a/plugins/core/log.py b/plugins/core/log.py
index 6cf7113a..b41e97d4 100644
--- a/plugins/core/log.py
+++ b/plugins/core/log.py
@@ -2,6 +2,7 @@
 import logging
 import os
 import time
+from typing import Dict, Tuple
 
 import cloudbot
 from cloudbot import hook
@@ -33,14 +34,26 @@
 irc_default = "[{server}] {irc_raw}"
 
 ctcp_known = "[{server}:{channel}] {nick} [{user}@{host}] has requested CTCP {ctcp_command}"
-ctcp_known_with_message = ("[{server}:{channel}] {nick} [{user}@{host}] "
-                           "has requested CTCP {ctcp_command}: {ctcp_message}")
+ctcp_known_with_message = (
+    "[{server}:{channel}] {nick} [{user}@{host}] "
+    "has requested CTCP {ctcp_command}: {ctcp_message}"
+)
 ctcp_unknown = "[{server}:{channel}] {nick} [{user}@{host}] has requested unknown CTCP {ctcp_command}"
-ctcp_unknown_with_message = ("[{server}:{channel}] {nick} [{user}@{host}] "
-                             "has requested unknown CTCP {ctcp_command}: {ctcp_message}")
+ctcp_unknown_with_message = (
+    "[{server}:{channel}] {nick} [{user}@{host}] "
+    "has requested unknown CTCP {ctcp_command}: {ctcp_message}"
+)
 
 server_info_numerics = (
-    "003", "005", "250", "251", "252", "253", "254", "255", "256"
+    "003",
+    "005",
+    "250",
+    "251",
+    "252",
+    "253",
+    "254",
+    "255",
+    "256",
 )
 
 
@@ -48,6 +61,7 @@
 # | Formatting |
 # +------------+
 
+
 def format_event(event):
     """
     Format an event
@@ -58,8 +72,12 @@ def format_event(event):
     # Setup arguments
 
     args = {
-        "server": event.conn.name, "target": event.target, "channel": event.chan, "nick": event.nick,
-        "user": event.user, "host": event.host
+        "server": event.conn.name,
+        "target": event.target,
+        "channel": event.chan,
+        "nick": event.nick,
+        "user": event.user,
+        "host": event.host,
     }
 
     if event.content is not None:
@@ -99,7 +117,7 @@ def format_irc_event(event, args):
     # Try formatting with the CTCP command
 
     if event.irc_ctcp_text is not None:
-        ctcp_command, _, ctcp_message = event.irc_ctcp_text.partition(' ')
+        ctcp_command, _, ctcp_message = event.irc_ctcp_text.partition(" ")
         args["ctcp_command"] = ctcp_command
         args["ctcp_message"] = ctcp_message
 
@@ -120,10 +138,17 @@ def format_irc_event(event, args):
 
     logging_config = event.bot.config.get("logging", {})
 
-    if not logging_config.get("show_motd", True) and event.irc_command in ("375", "372", "376"):
+    if not logging_config.get("show_motd", True) and event.irc_command in (
+        "375",
+        "372",
+        "376",
+    ):
         return None
 
-    if not logging_config.get("show_server_info", True) and event.irc_command in server_info_numerics:
+    if (
+        not logging_config.get("show_server_info", True)
+        and event.irc_command in server_info_numerics
+    ):
         return None
 
     if event.irc_command == "PING":
@@ -144,15 +169,17 @@ def format_irc_event(event, args):
 folder_format = "%Y"
 
 # Stream cache, (server, chan) -> (file_name, stream)
-stream_cache = {}
+stream_cache: Dict[Tuple[str, str], Tuple[str, codecs.StreamReaderWriter]] = {}
 # Raw stream cache, server -> (file_name, stream)
-raw_cache = {}
+raw_cache: Dict[str, Tuple[str, codecs.StreamReaderWriter]] = {}
 
 
 def get_log_filename(server, chan):
     current_time = time.gmtime()
     folder_name = time.strftime(folder_format, current_time)
-    file_name = time.strftime(file_format.format(chan=chan, server=server), current_time).lower()
+    file_name = time.strftime(
+        file_format.format(chan=chan, server=server), current_time
+    ).lower()
     return cloudbot.logging_info.add_path(folder_name, file_name)
 
 
@@ -174,7 +201,9 @@ def get_log_stream(server, chan):
         # a dumb hack to bypass the fact windows does not allow * in file names
         new_filename = new_filename.replace("*", "server")
 
-        log_stream = codecs.open(new_filename, mode="a", encoding="utf-8", buffering=1)
+        log_stream = codecs.open(
+            new_filename, mode="a", encoding="utf-8", buffering=1
+        )
         stream_cache[cache_key] = (new_filename, log_stream)
 
     return log_stream
@@ -183,13 +212,15 @@ def get_log_stream(server, chan):
 def get_raw_log_filename(server):
     current_time = time.gmtime()
     folder_name = time.strftime(folder_format, current_time)
-    file_name = time.strftime(raw_file_format.format(server=server), current_time).lower()
+    file_name = time.strftime(
+        raw_file_format.format(server=server), current_time
+    ).lower()
     return cloudbot.logging_info.add_path("raw", folder_name, file_name)
 
 
 def get_raw_log_stream(server):
     new_filename = get_raw_log_filename(server)
-    old_filename, log_stream = stream_cache.get(server, (None, None))
+    old_filename, log_stream = raw_cache.get(server, (None, None))
 
     # If the filename has changed since we opened the stream, we should re-open
     if new_filename != old_filename:
@@ -201,7 +232,9 @@ def get_raw_log_stream(server):
         logging_dir = os.path.dirname(new_filename)
         os.makedirs(logging_dir, exist_ok=True)
 
-        log_stream = codecs.open(new_filename, mode="a", encoding="utf-8", buffering=1)
+        log_stream = codecs.open(
+            new_filename, mode="a", encoding="utf-8", buffering=1
+        )
         stream_cache[server] = (new_filename, log_stream)
 
     return log_stream
@@ -233,7 +266,11 @@ def log(event):
     text = format_event(event)
 
     if text is not None:
-        if event.irc_command in ["PRIVMSG", "PART", "JOIN", "MODE", "TOPIC", "QUIT", "NOTICE"] and event.chan:
+        if (
+            event.irc_command
+            in ["PRIVMSG", "PART", "JOIN", "MODE", "TOPIC", "QUIT", "NOTICE"]
+            and event.chan
+        ):
             stream = get_log_stream(event.conn.name, event.chan)
             stream.write(text + os.linesep)
             stream.flush()
diff --git a/plugins/core/optout.py b/plugins/core/optout.py
index fc7334f4..ad1e5956 100644
--- a/plugins/core/optout.py
+++ b/plugins/core/optout.py
@@ -6,7 +6,14 @@
 from threading import RLock
 
 from irclib.util.compare import match_mask
-from sqlalchemy import Table, Column, String, Boolean, PrimaryKeyConstraint, and_
+from sqlalchemy import (
+    Boolean,
+    Column,
+    PrimaryKeyConstraint,
+    String,
+    Table,
+    and_,
+)
 
 from cloudbot import hook
 from cloudbot.hook import Priority
@@ -16,13 +23,13 @@
 from cloudbot.util.text import parse_bool
 
 optout_table = Table(
-    'optout',
+    "optout",
     database.metadata,
-    Column('network', String),
-    Column('chan', String),
-    Column('hook', String),
-    Column('allow', Boolean, default=False),
-    PrimaryKeyConstraint('network', 'chan', 'hook')
+    Column("network", String),
+    Column("chan", String),
+    Column("hook", String),
+    Column("allow", Boolean, default=False),
+    PrimaryKeyConstraint("network", "chan", "hook"),
 )
 
 optout_cache = DefaultKeyFoldDict(list)
@@ -51,10 +58,14 @@ def __str__(self):
         return "{} {} {}".format(self.channel, self.hook, self.allow)
 
     def __repr__(self):
-        return "{}({}, {}, {})".format(self.__class__.__name__, self.channel, self.hook, self.allow)
+        return "{}({}, {}, {})".format(
+            self.__class__.__name__, self.channel, self.hook, self.allow
+        )
 
     def match(self, channel, hook_name):
-        return self.match_chan(channel) and match_mask(hook_name.casefold(), self.hook)
+        return self.match_chan(channel) and match_mask(
+            hook_name.casefold(), self.hook
+        )
 
     def match_chan(self, channel):
         return match_mask(channel.casefold(), self.channel)
@@ -78,14 +89,18 @@ def get_conn_optouts(conn_name):
 def get_channel_optouts(conn_name, chan=None):
     with cache_lock:
         return [
-            opt for opt in get_conn_optouts(conn_name)
+            opt
+            for opt in get_conn_optouts(conn_name)
             if not chan or opt.match_chan(chan)
         ]
 
 
 def format_optout_list(opts):
     headers = ("Channel Pattern", "Hook Pattern", "Allowed")
-    table = [(opt.channel, opt.hook, "true" if opt.allow else "false") for opt in opts]
+    table = [
+        (opt.channel, opt.hook, "true" if opt.allow else "false")
+        for opt in opts
+    ]
     return gen_markdown_table(headers, table)
 
 
@@ -93,10 +108,18 @@ def set_optout(db, conn, chan, pattern, allowed):
     conn_cf = conn.casefold()
     chan_cf = chan.casefold()
     pattern_cf = pattern.casefold()
-    clause = and_(optout_table.c.network == conn_cf, optout_table.c.chan == chan_cf, optout_table.c.hook == pattern_cf)
+    clause = and_(
+        optout_table.c.network == conn_cf,
+        optout_table.c.chan == chan_cf,
+        optout_table.c.hook == pattern_cf,
+    )
     res = db.execute(optout_table.update().values(allow=allowed).where(clause))
     if not res.rowcount:
-        db.execute(optout_table.insert().values(network=conn_cf, chan=chan_cf, hook=pattern_cf, allow=allowed))
+        db.execute(
+            optout_table.insert().values(
+                network=conn_cf, chan=chan_cf, hook=pattern_cf, allow=allowed
+            )
+        )
 
     db.commit()
     load_cache(db)
@@ -106,7 +129,11 @@ def del_optout(db, conn, chan, pattern):
     conn_cf = conn.casefold()
     chan_cf = chan.casefold()
     pattern_cf = pattern.casefold()
-    clause = and_(optout_table.c.network == conn_cf, optout_table.c.chan == chan_cf, optout_table.c.hook == pattern_cf)
+    clause = and_(
+        optout_table.c.network == conn_cf,
+        optout_table.c.chan == chan_cf,
+        optout_table.c.hook == pattern_cf,
+    )
     res = db.execute(optout_table.delete().where(clause))
 
     db.commit()
@@ -119,7 +146,9 @@ def clear_optout(db, conn, chan=None):
     conn_cf = conn.casefold()
     if chan:
         chan_cf = chan.casefold()
-        clause = and_(optout_table.c.network == conn_cf, optout_table.c.chan == chan_cf)
+        clause = and_(
+            optout_table.c.network == conn_cf, optout_table.c.chan == chan_cf
+        )
     else:
         clause = optout_table.c.network == conn_cf
 
@@ -134,7 +163,9 @@ def clear_optout(db, conn, chan=None):
 def load_cache(db):
     new_cache = defaultdict(list)
     for row in db.execute(optout_table.select()):
-        new_cache[row["network"]].append(OptOut(row["chan"], row["hook"], row["allow"]))
+        new_cache[row["network"]].append(
+            OptOut(row["chan"], row["hook"], row["allow"])
+        )
 
     for opts in new_cache.values():
         opts.sort(reverse=True)
@@ -150,7 +181,7 @@ def optout_sieve(bot, event, _hook):
     if not event.chan or not event.conn:
         return event
 
-    if _hook.plugin.title.startswith('core.'):
+    if _hook.plugin.title.startswith("core."):
         return event
 
     hook_name = _hook.plugin.title + "." + _hook.function_name
@@ -160,7 +191,9 @@ def optout_sieve(bot, event, _hook):
             if _optout.match(event.chan, hook_name):
                 if not _optout.allow:
                     if _hook.type == "command":
-                        event.notice("Sorry, that command is disabled in this channel.")
+                        event.notice(
+                            "Sorry, that command is disabled in this channel."
+                        )
 
                     return None
 
@@ -181,10 +214,14 @@ async def optout(text, event, chan, db, conn):
     if args[0].startswith("#") and len(args) > 1:
         chan = args.pop(0)
 
-    has_perm = await check_channel_permissions(event, chan, "op", "chanop", "snoonetstaff", "botcontrol")
+    has_perm = await check_channel_permissions(
+        event, chan, "op", "chanop", "snoonetstaff", "botcontrol"
+    )
 
     if not has_perm:
-        event.notice("Sorry, you may not configure optout settings for that channel.")
+        event.notice(
+            "Sorry, you may not configure optout settings for that channel."
+        )
         return
 
     pattern = args.pop(0)
@@ -202,7 +239,7 @@ async def optout(text, event, chan, db, conn):
     return "{action} hooks matching {pattern} in {channel}.".format(
         action="Enabled" if allowed else "Disabled",
         pattern=pattern,
-        channel=chan
+        channel=chan,
     )
 
 
@@ -214,10 +251,14 @@ async def deloptout(text, event, chan, db, conn):
     if len(args) > 1:
         chan = args.pop(0)
 
-    has_perm = await check_channel_permissions(event, chan, "op", "chanop", "snoonetstaff", "botcontrol")
+    has_perm = await check_channel_permissions(
+        event, chan, "op", "chanop", "snoonetstaff", "botcontrol"
+    )
 
     if not has_perm:
-        event.notice("Sorry, you may not configure optout settings for that channel.")
+        event.notice(
+            "Sorry, you may not configure optout settings for that channel."
+        )
         return
 
     pattern = args.pop(0)
@@ -237,7 +278,9 @@ async def check_global_perms(event):
         chan = text.split()[0]
 
     can_global = await event.check_permissions("snoonetstaff", "botcontrol")
-    allowed = can_global or (await check_channel_permissions(event, chan, "op", "chanop"))
+    allowed = can_global or (
+        await check_channel_permissions(event, chan, "op", "chanop")
+    )
 
     if not allowed:
         event.notice("Sorry, you are not allowed to use this command.")
diff --git a/plugins/core/plugin_control.py b/plugins/core/plugin_control.py
index ffb99fa6..5cea8ab9 100644
--- a/plugins/core/plugin_control.py
+++ b/plugins/core/plugin_control.py
@@ -11,7 +11,10 @@ def pluginlist(bot):
     """- List all currently loaded plugins"""
     manager = bot.plugin_manager
     plugins = [
-        (plugin.title, str(Path(plugin.file_path).resolve().relative_to(bot.base_dir)))
+        (
+            plugin.title,
+            str(Path(plugin.file_path).resolve().relative_to(bot.base_dir)),
+        )
         for plugin in manager.plugins.values()
     ]
     plugins.sort(key=itemgetter(0))
@@ -33,7 +36,9 @@ async def pluginload(bot, text, reply):
         reply("Plugin failed to load.")
         raise
     else:
-        return "Plugin {}loaded successfully.".format("re" if was_loaded else "")
+        return "Plugin {}loaded successfully.".format(
+            "re" if was_loaded else ""
+        )
 
 
 @hook.command(permissions=["botcontrol"])
diff --git a/plugins/core/regex_chans.py b/plugins/core/regex_chans.py
index 2ccfc82e..fa5817fc 100644
--- a/plugins/core/regex_chans.py
+++ b/plugins/core/regex_chans.py
@@ -1,6 +1,7 @@
 import logging
+from typing import Dict, Tuple
 
-from sqlalchemy import Table, Column, UniqueConstraint, String
+from sqlalchemy import Column, String, Table, UniqueConstraint
 
 from cloudbot import hook
 from cloudbot.util import database
@@ -11,14 +12,14 @@
     Column("connection", String),
     Column("channel", String),
     Column("status", String),
-    UniqueConstraint("connection", "channel")
+    UniqueConstraint("connection", "channel"),
 )
 
 # Default value.
 # If True, all channels without a setting will have regex enabled
 # If False, all channels without a setting will have regex disabled
 default_enabled = True
-status_cache = {}
+status_cache: Dict[Tuple[str, str], str] = {}
 logger = logging.getLogger("cloudbot")
 
 
@@ -48,26 +49,52 @@ def set_status(db, conn, chan, status):
     if (conn, chan) in status_cache:
         # if we have a set value, update
         db.execute(
-            table.update().values(status=status).where(table.c.connection == conn).where(table.c.channel == chan))
+            table.update()
+            .values(status=status)
+            .where(table.c.connection == conn)
+            .where(table.c.channel == chan)
+        )
     else:
         # otherwise, insert
-        db.execute(table.insert().values(connection=conn, channel=chan, status=status))
+        db.execute(
+            table.insert().values(connection=conn, channel=chan, status=status)
+        )
     db.commit()
 
 
 def delete_status(db, conn, chan):
-    db.execute(table.delete().where(table.c.connection == conn).where(table.c.channel == chan))
+    db.execute(
+        table.delete()
+        .where(table.c.connection == conn)
+        .where(table.c.channel == chan)
+    )
     db.commit()
 
 
 @hook.sieve()
 def sieve_regex(bot, event, _hook):
-    if _hook.type == "regex" and event.chan.startswith("#") and _hook.plugin.title != "factoids":
+    if (
+        _hook.type == "regex"
+        and event.chan.startswith("#")
+        and _hook.plugin.title != "factoids"
+    ):
         status = status_cache.get((event.conn.name, event.chan))
-        if status != "ENABLED" and (status == "DISABLED" or not default_enabled):
-            logger.info("[%s] Denying %s from %s", event.conn.name, _hook.function_name, event.chan)
+        if status != "ENABLED" and (
+            status == "DISABLED" or not default_enabled
+        ):
+            logger.info(
+                "[%s] Denying %s from %s",
+                event.conn.name,
+                _hook.function_name,
+                event.chan,
+            )
             return None
-        logger.info("[%s] Allowing %s to %s", event.conn.name, _hook.function_name, event.chan)
+        logger.info(
+            "[%s] Allowing %s to %s",
+            event.conn.name,
+            _hook.function_name,
+            event.chan,
+        )
 
     return event
 
@@ -83,13 +110,17 @@ def change_status(db, event, status):
 
     action = "Enabling" if status else "Disabling"
     event.message(
-        "{} regex matching (youtube, etc) (issued by {})".format(action, event.nick),
-        target=channel
+        "{} regex matching (youtube, etc) (issued by {})".format(
+            action, event.nick
+        ),
+        target=channel,
+    )
+    event.notice(
+        "{} regex matching (youtube, etc) in channel {}".format(action, channel)
+    )
+    set_status(
+        db, event.conn.name, channel, "ENABLED" if status else "DISABLED"
     )
-    event.notice("{} regex matching (youtube, etc) in channel {}".format(
-        action, channel
-    ))
-    set_status(db, event.conn.name, channel, "ENABLED" if status else "DISABLED")
     load_cache(db)
 
 
@@ -116,8 +147,17 @@ def resetregex(text, db, conn, chan, nick, message, notice):
     else:
         channel = "#{}".format(text)
 
-    message("Resetting regex matching setting (youtube, etc) (issued by {})".format(nick), target=channel)
-    notice("Resetting regex matching setting (youtube, etc) in channel {}".format(channel))
+    message(
+        "Resetting regex matching setting (youtube, etc) (issued by {})".format(
+            nick
+        ),
+        target=channel,
+    )
+    notice(
+        "Resetting regex matching setting (youtube, etc) in channel {}".format(
+            channel
+        )
+    )
     delete_status(db, conn.name, channel)
     load_cache(db)
 
diff --git a/plugins/core/sasl.py b/plugins/core/sasl.py
index e16a2e19..12c9dc83 100644
--- a/plugins/core/sasl.py
+++ b/plugins/core/sasl.py
@@ -9,14 +9,14 @@
 
 @hook.on_cap_available("sasl")
 def sasl_available(conn):
-    sasl_conf = conn.config.get('sasl')
-    return bool(sasl_conf and sasl_conf.get('enabled', True))
+    sasl_conf = conn.config.get("sasl")
+    return bool(sasl_conf and sasl_conf.get("enabled", True))
 
 
 @hook.on_cap_ack("sasl")
 async def sasl_ack(conn):
-    sasl_auth = conn.config.get('sasl')
-    if sasl_auth and sasl_auth.get('enabled', True):
+    sasl_auth = conn.config.get("sasl")
+    if sasl_auth and sasl_auth.get("enabled", True):
         sasl_mech = sasl_auth.get("mechanism", "PLAIN").upper()
         auth_fut = async_util.create_future(conn.loop)
         conn.memory["sasl_auth_future"] = auth_fut
@@ -24,7 +24,7 @@ async def sasl_ack(conn):
         cmd, arg = await auth_fut
         if cmd == "908":
             logger.warning("[%s|sasl] SASL mechanism not supported", conn.name)
-        elif cmd == "AUTHENTICATE" and arg[0] == '+':
+        elif cmd == "AUTHENTICATE" and arg[0] == "+":
             num_fut = async_util.create_future(conn.loop)
             conn.memory["sasl_numeric_future"] = num_fut
             if sasl_mech == "PLAIN":
@@ -33,7 +33,7 @@ async def sasl_ack(conn):
                 ).encode()
                 conn.cmd("AUTHENTICATE", base64.b64encode(auth_str).decode())
             else:
-                conn.cmd("AUTHENTICATE", '+')
+                conn.cmd("AUTHENTICATE", "+")
             numeric = await num_fut
             if numeric == "902":
                 logger.warning("[%s|sasl] SASL nick locked", conn.name)
diff --git a/plugins/correction.py b/plugins/correction.py
index 286a80ad..11377ea7 100644
--- a/plugins/correction.py
+++ b/plugins/correction.py
@@ -3,8 +3,10 @@
 from cloudbot import hook
 from cloudbot.util.formatting import ireplace
 
-correction_re = re.compile(r"^[sS]/(?:(.*?)(?<!\\)/(.*?)(?:(?<!\\)/([igx]{,4}))?)\s*$")
-unescape_re = re.compile(r'\\(.)')
+correction_re = re.compile(
+    r"^[sS]/(?:(.*?)(?<!\\)/(.*?)(?:(?<!\\)/([igx]{,4}))?)\s*$"
+)
+unescape_re = re.compile(r"\\(.)")
 
 
 @hook.regex(correction_re)
@@ -18,10 +20,16 @@ def correction(match, conn, nick, chan, message):
     find = groups[0]
     replace = groups[1]
     if find == replace:
-        return "really dude? you want me to replace {} with {}?".format(find, replace)
+        return "really dude? you want me to replace {} with {}?".format(
+            find, replace
+        )
 
-    if not find.strip():  # Replacing empty or entirely whitespace strings is spammy
-        return "really dude? you want me to replace nothing with {}?".format(replace)
+    if (
+        not find.strip()
+    ):  # Replacing empty or entirely whitespace strings is spammy
+        return "really dude? you want me to replace nothing with {}?".format(
+            replace
+        )
 
     for name, timestamp, msg in reversed(conn.history[chan]):
         if correction_re.match(msg):
@@ -31,14 +39,16 @@ def correction(match, conn, nick, chan, message):
         if find.lower() in msg.lower():
             find_esc = re.escape(find)
             replace_esc = re.escape(replace)
-            if msg.startswith('\x01ACTION'):
-                mod_msg = msg[7:].strip(' \x01')
+            if msg.startswith("\x01ACTION"):
+                mod_msg = msg[7:].strip(" \x01")
                 fmt = "* {} {}"
             else:
                 mod_msg = msg
                 fmt = "<{}> {}"
 
-            mod_msg = ireplace(re.escape(mod_msg), find_esc, "\x02" + replace_esc + "\x02")
+            mod_msg = ireplace(
+                re.escape(mod_msg), find_esc, "\x02" + replace_esc + "\x02"
+            )
 
             mod_msg = unescape_re.sub(r"\1", mod_msg)
 
diff --git a/plugins/cryptocurrency.py b/plugins/cryptocurrency.py
index af76c4a7..727e45ed 100644
--- a/plugins/cryptocurrency.py
+++ b/plugins/cryptocurrency.py
@@ -15,7 +15,7 @@
 from numbers import Number
 from operator import itemgetter
 from threading import RLock
-from typing import Any, Dict, List, Optional, Type, TypeVar
+from typing import Any, Dict, List, Optional, Tuple, Type, TypeVar
 
 import requests
 from requests import Response
@@ -45,7 +45,9 @@ def __init__(self, name: str):
 
 
 class APIResponse:
-    def __init__(self, api, data: "UntypedResponse", response: Response) -> None:
+    def __init__(
+        self, api, data: "UntypedResponse", response: Response
+    ) -> None:
         self.api = api
         self.data = data
         self.response = response
@@ -83,7 +85,9 @@ def __new__(cls, name, bases, members):
         if members.setdefault("_abstract", False):
             super_fields = ()
             for base in bases:
-                if not getattr(base, "_abstract", False) and isinstance(base, cls):
+                if not getattr(base, "_abstract", False) and isinstance(
+                    base, cls
+                ):
                     super_fields = getattr(base, "_fields")
                     break
 
@@ -94,7 +98,7 @@ def __new__(cls, name, bases, members):
         return type.__new__(cls, name, bases, members)
 
 
-T = TypeVar("T")
+T = TypeVar("T", bound="Schema")
 
 
 class Schema(metaclass=SchemaMeta):
@@ -142,7 +146,9 @@ def __init__(self, status: ResponseStatus, data: Any = None):
 
 class Platform(Schema):
     # noinspection PyShadowingBuiltins
-    def __init__(self, id: int, name: str, symbol: str, slug: str, token_address: str):
+    def __init__(
+        self, id: int, name: str, symbol: str, slug: str, token_address: str
+    ):
         super().__init__()
         self.id = id
         self.name = name
@@ -241,7 +247,9 @@ def __init__(self, data: List[FiatCurrency], status: ResponseStatus):
         super().__init__(status)
         self.data = data
 
-        self.symbols = {currency.symbol: currency.sign for currency in self.data}
+        self.symbols = {
+            currency.symbol: currency.sign for currency in self.data
+        }
 
 
 class CryptoCurrencyEntry(Schema):
@@ -278,7 +286,9 @@ def __init__(self, data: List[CryptoCurrencyEntry], status: ResponseStatus):
         self.names = set(currency.symbol for currency in self.data)
 
 
-BAD_FIELD_TYPE_MSG = "field {field!r} expected type {exp_type!r}, got type {act_type!r}"
+BAD_FIELD_TYPE_MSG = (
+    "field {field!r} expected type {exp_type!r}, got type {act_type!r}"
+)
 
 
 def sentinel(name: str):
@@ -344,7 +354,9 @@ def _hydrate_object(_value, _cls):
             _assert_type(_value, dict, _cls)
 
             return {
-                _hydrate_object(k, type_args[0]): _hydrate_object(v, type_args[1])
+                _hydrate_object(k, type_args[0]): _hydrate_object(
+                    v, type_args[1]
+                )
                 for k, v in _value.items()
             }
 
@@ -358,12 +370,12 @@ def _hydrate_object(_value, _cls):
 
 
 def read_data(data: Dict, schema_cls: Type[T]) -> T:
-    fields = schema_cls._fields
+    fields: Tuple[SchemaField, ...] = schema_cls._fields
 
-    out = {}
-    field_names = []
+    out: Dict[str, Any] = {}
+    field_names: List[str] = []
 
-    for schema_field in fields:  # type: SchemaField
+    for schema_field in fields:
         try:
             param_type = schema_field.field_type
             name = schema_field.name
@@ -393,7 +405,7 @@ def read_data(data: Dict, schema_cls: Type[T]) -> T:
                 "Unable to parse schema {!r}".format(schema_cls.__name__)
             ) from e
 
-    obj = schema_cls(**out)
+    obj = schema_cls(**out)  # type: ignore
 
     obj.unknown_fields.update(
         {key: data[key] for key in data if key not in field_names}
@@ -498,7 +510,9 @@ def get_quote(self, symbol: str, currency: str = "USD") -> CryptoCurrency:
             convert = currency
 
         data = self.request(
-            "cryptocurrency/quotes/latest", symbol=symbol.upper(), convert=convert,
+            "cryptocurrency/quotes/latest",
+            symbol=symbol.upper(),
+            convert=convert,
         ).data.cast_to(QuoteRequestResponse)
         _, out = data.data.popitem()
         return out
@@ -510,10 +524,15 @@ def get_fiat_currency_map(self) -> FiatCurrencyMap:
 
     def get_crypto_currency_map(self) -> CryptoCurrencyMap:
         return self._request_cache(
-            "crypto_currency_map", "cryptocurrency/map", CryptoCurrencyMap, 86400
+            "crypto_currency_map",
+            "cryptocurrency/map",
+            CryptoCurrencyMap,
+            86400,
         )
 
-    def _request_cache(self, name: str, endpoint: str, fmt: Type[T], ttl: int) -> T:
+    def _request_cache(
+        self, name: str, endpoint: str, fmt: Type[T], ttl: int
+    ) -> T:
         out = self.cache.get(name)
         if out is None:
             currencies = self.request(endpoint).data.cast_to(fmt)
@@ -523,7 +542,9 @@ def _request_cache(self, name: str, endpoint: str, fmt: Type[T], ttl: int) -> T:
 
     def request(self, endpoint: str, **params) -> APIResponse:
         url = str(self.api_url / endpoint)
-        with requests.get(url, headers=self.request_headers, params=params) as response:
+        with requests.get(
+            url, headers=self.request_headers, params=params
+        ) as response:
             api_response = APIResponse.from_response(self, response)
             self.check(api_response)
 
@@ -585,7 +606,9 @@ def func(text, event):
 def init_aliases():
     for alias in ALIASES:
         _hook = alias_wrapper(alias)
-        globals()[_hook.__name__] = hook.command(*alias.cmds, autohelp=False)(_hook)
+        globals()[_hook.__name__] = hook.command(*alias.cmds, autohelp=False)(
+            _hook
+        )
 
 
 # main command
@@ -628,8 +651,15 @@ def crypto_command(text, event):
         btc = ""
 
     return colors.parse(
-        ("{} ({}) // $(orange){}{:,.2f}$(clear) {} " + btc + "// {} change").format(
-            data.symbol, data.slug, currency_sign, quote.price, currency, change_str,
+        (
+            "{} ({}) // $(orange){}{:,.2f}$(clear) {} " + btc + "// {} change"
+        ).format(
+            data.symbol,
+            data.slug,
+            currency_sign,
+            quote.price,
+            currency,
+            change_str,
         )
     )
 
@@ -639,7 +669,8 @@ def currency_list():
     """- List all available currencies from the API"""
     currency_map = api.get_crypto_currency_map()
     currencies = sorted(
-        set((obj.symbol, obj.name) for obj in currency_map.data), key=itemgetter(0)
+        set((obj.symbol, obj.name) for obj in currency_map.data),
+        key=itemgetter(0),
     )
     lst = ["{: <10} {}".format(symbol, name) for symbol, name in currencies]
     lst.insert(0, "Symbol     Name")
diff --git a/plugins/deals.py b/plugins/deals.py
index 39c637c0..1d73dc29 100644
--- a/plugins/deals.py
+++ b/plugins/deals.py
@@ -4,7 +4,7 @@
 from cloudbot.util import web
 
 
-@hook.command('meh', autohelp=False)
+@hook.command("meh", autohelp=False)
 def meh():
     """- List the current meh.com deal."""
     url = "https://meh.com/deals.rss"
@@ -16,7 +16,7 @@ def meh():
     return "meh.com: {} ({})".format(title, link)
 
 
-@hook.command('slickdeals', autohelp=False)
+@hook.command("slickdeals", autohelp=False)
 def slickdeals():
     """- List the top 3 frontpage slickdeals.net deals."""
     url = "https://slickdeals.net/newsearch.php?mode=frontpage&searcharea=deals&searchin=first&rss=1"
@@ -27,6 +27,6 @@ def slickdeals():
         for item in feed.entries[:3]
     )
 
-    out = "slickdeals.net: " + ' \u2022 '.join(items)
+    out = "slickdeals.net: " + " \u2022 ".join(items)
 
     return out
diff --git a/plugins/dogpile.py b/plugins/dogpile.py
index 7cd09000..317c7dc0 100644
--- a/plugins/dogpile.py
+++ b/plugins/dogpile.py
@@ -8,10 +8,10 @@
 
 search_url = "https://www.dogpile.com/search"
 
-CERT_PATH = 'dogpile.crt'
+CERT_PATH = "dogpile.crt"
 HEADERS = {
-    'User-Agent': 'Mozilla/5.0 (Linux; Android 4.0.4; Galaxy Nexus Build/IMM76B) AppleWebKit/535.19 '
-                  '(KHTML, like Gecko) Chrome/18.0.1025.133 Mobile Safari/535.19'
+    "User-Agent": "Mozilla/5.0 (Linux; Android 4.0.4; Galaxy Nexus Build/IMM76B) AppleWebKit/535.19 "
+    "(KHTML, like Gecko) Chrome/18.0.1025.133 Mobile Safari/535.19"
 }
 
 session = requests.Session()
@@ -29,10 +29,12 @@ def check_certs(bot):
 
 
 def query(endpoint, text):
-    params = {'q': " ".join(text.split())}
+    params = {"q": " ".join(text.split())}
     with requests.get(
-            search_url + "/" + endpoint, params=params, headers=HEADERS,
-            verify=session.verify
+        search_url + "/" + endpoint,
+        params=params,
+        headers=HEADERS,
+        verify=session.verify,
     ) as r:
         r.raise_for_status()
         return parse_soup(r.content)
@@ -41,28 +43,32 @@ def query(endpoint, text):
 @hook.command("dpis", "gis")
 def dogpileimage(text):
     """<query> - Uses the dogpile search engine to search for images."""
-    soup = query('images', text)
-    results_container = soup.find('div', {'class': 'images-bing__list'})
+    soup = query("images", text)
+    results_container = soup.find("div", {"class": "images-bing__list"})
     if not results_container:
         return "No results found."
 
-    results_list = results_container.find_all('div', {'class': 'image'})
+    results_list = results_container.find_all("div", {"class": "image"})
     if not results_list:
         return "No results found."
 
     image = random.choice(results_list)
-    return image.find('a', {'class': 'link'})['href']
+    return image.find("a", {"class": "link"})["href"]
 
 
 @hook.command("dp", "g", "dogpile")
 def dogpile(text):
     """<query> - Uses the dogpile search engine to find shit on the web."""
-    soup = query('web', text)
-    results = soup.find_all('div', {'class': 'web-bing__result'})
+    soup = query("web", text)
+    results = soup.find_all("div", {"class": "web-bing__result"})
     if not results:
         return "No results found."
 
     result = results[0]
-    result_url = result.find('a', {'class': 'web-bing__title', 'href': True})['href']
-    result_description = result.find('span', {'class': 'web-bing__description'}).text
+    result_url = result.find("a", {"class": "web-bing__title", "href": True})[
+        "href"
+    ]
+    result_description = result.find(
+        "span", {"class": "web-bing__description"}
+    ).text
     return "{} -- \x02{}\x02".format(result_url, result_description)
diff --git a/plugins/domainr.py b/plugins/domainr.py
index 7d5e37ed..89110c45 100644
--- a/plugins/domainr.py
+++ b/plugins/domainr.py
@@ -1,4 +1,4 @@
-from urllib.error import URLError, HTTPError
+from urllib.error import HTTPError, URLError
 
 from cloudbot import hook
 from cloudbot.util import http
@@ -6,7 +6,7 @@
 formats = {
     "taken": "\x034{domain}\x0f{path}",
     "available": "\x033{domain}\x0f{path}",
-    "other": "\x031{domain}\x0f{path}"
+    "other": "\x031{domain}\x0f{path}",
 }
 
 
@@ -28,11 +28,11 @@ def domainr(text):
     :type text: str
     """
     try:
-        data = http.get_json('http://domai.nr/api/json/search?q=' + text)
+        data = http.get_json("http://domai.nr/api/json/search?q=" + text)
     except (URLError, HTTPError):
         return "Unable to get data for some reason. Try again later."
-    if data['query'] == "":
-        return "An error occurred: {status} - {message}".format(**data['error'])
+    if data["query"] == "":
+        return "An error occurred: {status} - {message}".format(**data["error"])
 
     domains = [format_domain(domain) for domain in data["results"]]
     return "Domains: {}".format(", ".join(domains))
diff --git a/plugins/dragonvale.py b/plugins/dragonvale.py
index af1d0e5a..5c13659e 100644
--- a/plugins/dragonvale.py
+++ b/plugins/dragonvale.py
@@ -13,17 +13,14 @@
 
 
 def striphtml(data):
-    string = re.compile(r'<.*?>')
-    return string.sub('', data)
+    string = re.compile(r"<.*?>")
+    return string.sub("", data)
 
 
 @hook.command("dragon", "ds")
 def dragonsearch(text, reply):
     """<query> - Searches the dragonvale wiki for the specified text."""
-    params = {
-        "query": text.strip(),
-        "limit": 1
-    }
+    params = {"query": text.strip(), "limit": 1}
 
     r = requests.get(search_url, params=params)
 
@@ -37,8 +34,11 @@ def dragonsearch(text, reply):
         return "The API returned error code {}.".format(r.status_code)
 
     data = r.json()["items"][0]
-    out = "\x02{}\x02 -- {}: {}".format(data["title"], striphtml(data["snippet"]).split("&hellip;")[0].strip(),
-                                        data["url"])
+    out = "\x02{}\x02 -- {}: {}".format(
+        data["title"],
+        striphtml(data["snippet"]).split("&hellip;")[0].strip(),
+        data["url"],
+    )
     return out
 
 
@@ -59,15 +59,11 @@ def egg_calculator(text):
         time = time_parse(timer.strip())
         if not time:
             return "invalid time format"
-    params = {
-        'time': time,
-        'time2': time2,
-        'avail': 1
-    }
+    params = {"time": time, "time2": time2, "avail": 1}
     r = requests.get(egg_calc_url, params=params, timeout=5)
     soup = parse_soup(r.text)
     dragons = []
-    for line in soup.findAll('td', {'class': 'views-field views-field-title'}):
+    for line in soup.findAll("td", {"class": "views-field views-field-title"}):
         dragons.append(line.text.replace("\n", "").strip())
 
     return ", ".join(dragons)
diff --git a/plugins/dramatica.py b/plugins/dramatica.py
index 7b9d9c17..0de185ae 100644
--- a/plugins/dramatica.py
+++ b/plugins/dramatica.py
@@ -16,7 +16,9 @@
 def drama(text, reply):
     """<phrase> - gets the first paragraph of the Encyclopedia Dramatica article on <phrase>"""
 
-    search_response = requests.get(api_url, params={"action": "opensearch", "search": text})
+    search_response = requests.get(
+        api_url, params={"action": "opensearch", "search": text}
+    )
 
     try:
         search_response.raise_for_status()
@@ -31,9 +33,9 @@ def drama(text, reply):
 
     if not data[1]:
         return "No results found."
-    article_name = data[1][0].replace(' ', '_')
+    article_name = data[1][0].replace(" ", "_")
 
-    url = ed_url + parse.quote(article_name, '')
+    url = ed_url + parse.quote(article_name, "")
 
     page_response = requests.get(url)
 
@@ -51,7 +53,7 @@ def drama(text, reply):
     for p in page.xpath('//div[@id="bodyContent"]/p'):
         if p.text_content():
             summary = " ".join(p.text_content().splitlines())
-            summary = re.sub(r'\[\d+\]', '', summary)
+            summary = re.sub(r"\[\d+\]", "", summary)
             summary = formatting.truncate(summary, 220)
             return "{} - {}".format(summary, url)
 
diff --git a/plugins/drinks.py b/plugins/drinks.py
index 40f8b22f..9bb2e271 100644
--- a/plugins/drinks.py
+++ b/plugins/drinks.py
@@ -1,11 +1,12 @@
 import json
 import os
 import random
+from typing import Any, Dict, List
 
 from cloudbot import hook
 from cloudbot.util import web
 
-drink_data = []
+drink_data: List[Dict[str, Any]] = []
 
 
 @hook.onload()
@@ -16,24 +17,26 @@ def load_drinks(bot):
         drink_data.extend(json.load(json_data))
 
 
-@hook.command('drink')
+@hook.command("drink")
 def drink_cmd(text, chan, action):
     """<nick> - makes the user a random cocktail."""
     index = random.randint(0, len(drink_data) - 1)
-    drink = drink_data[index]['title']
-    url = web.try_shorten(drink_data[index]['url'])
-    if drink.endswith(' recipe'):
+    drink = drink_data[index]["title"]
+    url = web.try_shorten(drink_data[index]["url"])
+    if drink.endswith(" recipe"):
         drink = drink[:-7]
-    contents = drink_data[index]['ingredients']
+    contents = drink_data[index]["ingredients"]
     out = "grabs some"
     for x in contents:
         if x == contents[len(contents) - 1]:
             out += " and {}".format(x)
         else:
             out += " {},".format(x)
-    if drink[0].lower() in ['a', 'e', 'i', 'o', 'u']:
-        article = 'an'
+    if drink[0].lower() in ["a", "e", "i", "o", "u"]:
+        article = "an"
     else:
-        article = 'a'
-    out += "\x0F and makes {} {} \x02{}\x02. {}".format(text, article, drink, url)
+        article = "a"
+    out += "\x0F and makes {} {} \x02{}\x02. {}".format(
+        text, article, drink, url
+    )
     action(out, chan)
diff --git a/plugins/eightball.py b/plugins/eightball.py
index 3b53e989..c3936d91 100644
--- a/plugins/eightball.py
+++ b/plugins/eightball.py
@@ -1,11 +1,12 @@
 import codecs
 import os
 import random
+from typing import List
 
 from cloudbot import hook
 from cloudbot.util import colors
 
-responses = []
+responses: List[str] = []
 
 
 @hook.on_start()
@@ -14,8 +15,7 @@ def load_responses(bot):
     responses.clear()
     with codecs.open(path, encoding="utf-8") as f:
         responses.extend(
-            line.strip() for line in f.readlines()
-            if not line.startswith("//")
+            line.strip() for line in f.readlines() if not line.startswith("//")
         )
 
 
diff --git a/plugins/etymology.py b/plugins/etymology.py
index 8ad82d6b..8d2a67c8 100644
--- a/plugins/etymology.py
+++ b/plugins/etymology.py
@@ -23,7 +23,7 @@ def etymology(text, reply):
     :type text: str
     """
 
-    url = 'http://www.etymonline.com/index.php'
+    url = "http://www.etymonline.com/index.php"
 
     response = requests.get(url, params={"term": text})
 
@@ -32,7 +32,9 @@ def etymology(text, reply):
     except HTTPError as e:
         if e.response.status_code == 404:
             return "No etymology found for {} :(".format(text)
-        reply("Error reaching etymonline.com: {}".format(e.response.status_code))
+        reply(
+            "Error reaching etymonline.com: {}".format(e.response.status_code)
+        )
         raise
 
     if response.status_code != requests.codes.ok:
@@ -40,13 +42,13 @@ def etymology(text, reply):
 
     soup = parse_soup(response.text)
 
-    block = soup.find('div', class_=re.compile("word--.+"))
+    block = soup.find("div", class_=re.compile("word--.+"))
 
-    etym = ' '.join(e.text for e in block.div)
+    etym = " ".join(e.text for e in block.div)
 
-    etym = ' '.join(etym.splitlines())
+    etym = " ".join(etym.splitlines())
 
-    etym = ' '.join(etym.split())
+    etym = " ".join(etym.split())
 
     etym = formatting.truncate(etym, 200)
 
diff --git a/plugins/fact.py b/plugins/fact.py
index 70c3d16d..aeffcbe6 100644
--- a/plugins/fact.py
+++ b/plugins/fact.py
@@ -3,7 +3,7 @@
 from cloudbot import hook
 from cloudbot.util import http
 
-types = ['trivia', 'math', 'date', 'year']
+types = ["trivia", "math", "date", "year"]
 
 
 @hook.command(autohelp=False)
@@ -11,10 +11,12 @@ def fact(reply):
     """- Gets a random fact about numbers or dates."""
     fact_type = random.choice(types)
     try:
-        json = http.get_json('http://numbersapi.com/random/{}?json'.format(fact_type))
+        json = http.get_json(
+            "http://numbersapi.com/random/{}?json".format(fact_type)
+        )
     except Exception:
         reply("There was an error contacting the numbersapi.com API.")
         raise
 
-    response = json['text']
+    response = json["text"]
     return response
diff --git a/plugins/factoids.py b/plugins/factoids.py
index a0c7f2dd..359756f0 100644
--- a/plugins/factoids.py
+++ b/plugins/factoids.py
@@ -1,6 +1,7 @@
 import re
 import string
 from collections import defaultdict
+from typing import Dict
 
 from sqlalchemy import Column, PrimaryKeyConstraint, String, Table, and_
 
@@ -11,9 +12,7 @@
 
 # below is the default factoid in every channel you can modify it however you like
 default_dict = {"commands": "https://snoonet.org/gonzobot"}
-factoid_cache = defaultdict(default_dict.copy)
-
-re_lineends = re.compile(r'[\r\n]*')
+factoid_cache: Dict[str, Dict[str, str]] = defaultdict(default_dict.copy)
 
 FACTOID_CHAR = "?"  # TODO: config
 
@@ -24,7 +23,7 @@
     Column("data", String),
     Column("nick", String),
     Column("chan", String),
-    PrimaryKeyConstraint('word', 'chan')
+    PrimaryKeyConstraint("word", "chan"),
 )
 
 
@@ -54,12 +53,18 @@ def add_factoid(db, word, chan, data, nick):
     """
     if word in factoid_cache[chan]:
         # if we have a set value, update
-        db.execute(table.update().values(data=data, nick=nick, chan=chan).where(table.c.chan == chan).where(
-            table.c.word == word))
+        db.execute(
+            table.update()
+            .values(data=data, nick=nick, chan=chan)
+            .where(table.c.chan == chan)
+            .where(table.c.word == word)
+        )
         db.commit()
     else:
         # otherwise, insert
-        db.execute(table.insert().values(word=word, data=data, nick=nick, chan=chan))
+        db.execute(
+            table.insert().values(word=word, data=data, nick=nick, chan=chan)
+        )
         db.commit()
     load_cache(db)
 
@@ -97,19 +102,23 @@ def remember(text, nick, db, chan, notice, event):
     except LookupError:
         old_data = None
 
-    if data.startswith('+') and old_data:
+    if data.startswith("+") and old_data:
         # remove + symbol
         new_data = data[1:]
         # append new_data to the old_data
-        if len(new_data) > 1 and new_data[1] in (string.punctuation + ' '):
+        if len(new_data) > 1 and new_data[1] in (string.punctuation + " "):
             data = old_data + new_data
         else:
-            data = old_data + ' ' + new_data
+            data = old_data + " " + new_data
         notice("Appending \x02{}\x02 to \x02{}\x02".format(new_data, old_data))
     else:
-        notice('Remembering \x02{0}\x02 for \x02{1}\x02. Type {2}{1} to see it.'.format(data, word, FACTOID_CHAR))
+        notice(
+            "Remembering \x02{0}\x02 for \x02{1}\x02. Type {2}{1} to see it.".format(
+                data, word, FACTOID_CHAR
+            )
+        )
         if old_data:
-            notice('Previous data was \x02{}\x02'.format(old_data))
+            notice("Previous data was \x02{}\x02".format(old_data))
 
     add_factoid(db, word, chan, data, nick)
 
@@ -117,8 +126,8 @@ def remember(text, nick, db, chan, notice, event):
 def paste_facts(facts, raise_on_no_paste=False):
     headers = ("Command", "Output")
     data = [(FACTOID_CHAR + fact[0], fact[1]) for fact in sorted(facts.items())]
-    tbl = gen_markdown_table(headers, data).encode('UTF-8')
-    return web.paste(tbl, 'md', 'hastebin', raise_on_no_paste=raise_on_no_paste)
+    tbl = gen_markdown_table(headers, data).encode("UTF-8")
+    return web.paste(tbl, "md", "hastebin", raise_on_no_paste=raise_on_no_paste)
 
 
 def remove_fact(chan, names, db, notice):
@@ -132,9 +141,11 @@ def remove_fact(chan, names, db, notice):
             missing.append(name)
 
     if missing:
-        notice("Unknown factoids: {}".format(
-            get_text_list([repr(s) for s in missing], 'and')
-        ))
+        notice(
+            "Unknown factoids: {}".format(
+                get_text_list([repr(s) for s in missing], "and")
+            )
+        )
 
     if found:
         try:
@@ -158,7 +169,9 @@ def forget(text, chan, db, notice):
     remove_fact(chan, text.split(), db, notice)
 
 
-@hook.command('forgetall', 'clearfacts', autohelp=False, permissions=['op', 'chanop'])
+@hook.command(
+    "forgetall", "clearfacts", autohelp=False, permissions=["op", "chanop"]
+)
 def forget_all(chan, db):
     """- Remove all factoids in the current channel
 
@@ -181,7 +194,7 @@ def info(text, chan, notice):
         notice("Unknown Factoid.")
 
 
-factoid_re = re.compile(r'^{} ?(.+)'.format(re.escape(FACTOID_CHAR)), re.I)
+factoid_re = re.compile(r"^{} ?(.+)".format(re.escape(FACTOID_CHAR)), re.I)
 
 
 @hook.regex(factoid_re)
diff --git a/plugins/feeds.py b/plugins/feeds.py
index 1378cdaa..c8cfd685 100644
--- a/plugins/feeds.py
+++ b/plugins/feeds.py
@@ -1,7 +1,7 @@
 import feedparser
 
 from cloudbot import hook
-from cloudbot.util import web, formatting
+from cloudbot.util import formatting, web
 
 
 class FeedAlias:
@@ -11,35 +11,34 @@ def __init__(self, url, limit=3):
 
 
 ALIASES = {
-    'xkcd': FeedAlias('http://xkcd.com/rss.xml'),
-
-    'ars': FeedAlias('http://feeds.arstechnica.com/arstechnica/index'),
-
-    'pip': FeedAlias('https://pypi.python.org/pypi?%3Aaction=rss', 6),
-    'pypi': FeedAlias('https://pypi.python.org/pypi?%3Aaction=rss', 6),
-    'py': FeedAlias('https://pypi.python.org/pypi?%3Aaction=rss', 6),
-
-    'pipnew': FeedAlias('https://pypi.python.org/pypi?%3Aaction=packages_rss', 5),
-    'pypinew': FeedAlias('https://pypi.python.org/pypi?%3Aaction=packages_rss', 5),
-    'pynew': FeedAlias('https://pypi.python.org/pypi?%3Aaction=packages_rss', 5),
-
-    'world': FeedAlias(
-        'https://news.google.com/news?cf=all&ned=us&hl=en&topic=w&output=rss'
+    "xkcd": FeedAlias("http://xkcd.com/rss.xml"),
+    "ars": FeedAlias("http://feeds.arstechnica.com/arstechnica/index"),
+    "pip": FeedAlias("https://pypi.python.org/pypi?%3Aaction=rss", 6),
+    "pypi": FeedAlias("https://pypi.python.org/pypi?%3Aaction=rss", 6),
+    "py": FeedAlias("https://pypi.python.org/pypi?%3Aaction=rss", 6),
+    "pipnew": FeedAlias(
+        "https://pypi.python.org/pypi?%3Aaction=packages_rss", 5
     ),
-
-    'us': FeedAlias(
-        'https://news.google.com/news?cf=all&ned=us&hl=en&topic=n&output=rss'
+    "pypinew": FeedAlias(
+        "https://pypi.python.org/pypi?%3Aaction=packages_rss", 5
     ),
-    'usa': FeedAlias(
-        'https://news.google.com/news?cf=all&ned=us&hl=en&topic=n&output=rss'
+    "pynew": FeedAlias(
+        "https://pypi.python.org/pypi?%3Aaction=packages_rss", 5
     ),
-
-    'nz': FeedAlias(
-        'https://news.google.com/news?pz=1&cf=all&ned=nz&hl=en&topic=n&output=rss'
+    "world": FeedAlias(
+        "https://news.google.com/news?cf=all&ned=us&hl=en&topic=w&output=rss"
     ),
-
-    'anand': FeedAlias('http://www.anandtech.com/rss/'),
-    'anandtech': FeedAlias('http://www.anandtech.com/rss/'),
+    "us": FeedAlias(
+        "https://news.google.com/news?cf=all&ned=us&hl=en&topic=n&output=rss"
+    ),
+    "usa": FeedAlias(
+        "https://news.google.com/news?cf=all&ned=us&hl=en&topic=n&output=rss"
+    ),
+    "nz": FeedAlias(
+        "https://news.google.com/news?pz=1&cf=all&ned=nz&hl=en&topic=n&output=rss"
+    ),
+    "anand": FeedAlias("http://www.anandtech.com/rss/"),
+    "anandtech": FeedAlias("http://www.anandtech.com/rss/"),
 }
 
 
@@ -69,7 +68,7 @@ def rss(text):
     for item in feed.entries[:limit]:
         out.append(format_item(item))
 
-    if 'title' in feed.feed:
+    if "title" in feed.feed:
         start = "\x02{}\x02: ".format(feed.feed.title)
     else:
         start = ""
diff --git a/plugins/flip.py b/plugins/flip.py
index 6e9ae951..182b5082 100644
--- a/plugins/flip.py
+++ b/plugins/flip.py
@@ -1,48 +1,49 @@
 import random
 from collections import defaultdict
+from typing import Dict, Optional
 
 from cloudbot import hook
 from cloudbot.util import formatting
 
-table_status = defaultdict(lambda: None)
+table_status: Dict[str, Optional[bool]] = defaultdict(lambda: None)
 USE_FLIPPERS = True
 
 replacements = {
-    'a': 'ɐ',
-    'b': 'q',
-    'c': 'ɔ',
-    'd': 'p',
-    'e': 'ǝ',
-    'f': 'ɟ',
-    'g': 'ƃ',
-    'h': 'ɥ',
-    'i': 'ᴉ',
-    'j': 'ɾ',
-    'k': 'ʞ',
-    'l': 'ן',
-    'm': 'ɯ',
-    'n': 'u',
-    'o': 'o',
-    'p': 'd',
-    'q': 'b',
-    'r': 'ɹ',
-    's': 's',
-    't': 'ʇ',
-    'u': 'n',
-    'v': 'ʌ',
-    'w': 'ʍ',
-    'x': 'x',
-    'y': 'ʎ',
-    'z': 'z',
-    '?': '¿',
-    '.': '˙',
-    ',': '\'',
-    '(': ')',
-    '<': '>',
-    '[': ']',
-    '{': '}',
-    '\'': ',',
-    '_': '‾',
+    "a": "ɐ",
+    "b": "q",
+    "c": "ɔ",
+    "d": "p",
+    "e": "ǝ",
+    "f": "ɟ",
+    "g": "ƃ",
+    "h": "ɥ",
+    "i": "ᴉ",
+    "j": "ɾ",
+    "k": "ʞ",
+    "l": "ן",
+    "m": "ɯ",
+    "n": "u",
+    "o": "o",
+    "p": "d",
+    "q": "b",
+    "r": "ɹ",
+    "s": "s",
+    "t": "ʇ",
+    "u": "n",
+    "v": "ʌ",
+    "w": "ʍ",
+    "x": "x",
+    "y": "ʎ",
+    "z": "z",
+    "?": "¿",
+    ".": "˙",
+    ",": "'",
+    "(": ")",
+    "<": ">",
+    "[": "]",
+    "{": "}",
+    "'": ",",
+    "_": "‾",
 }
 
 # append an inverted form of replacements to itself, so flipping works both ways
@@ -56,8 +57,15 @@
 def flip(text, reply, message, chan):
     """<text> - Flips <text> over."""
     if USE_FLIPPERS:
-        if text in ['table', 'tables']:
-            message(random.choice([random.choice(flippers) + " ︵ " + "\u253B\u2501\u253B", table_flipper]))
+        if text in ["table", "tables"]:
+            message(
+                random.choice(
+                    [
+                        random.choice(flippers) + " ︵ " + "\u253B\u2501\u253B",
+                        table_flipper,
+                    ]
+                )
+            )
             table_status[chan] = True
         elif text == "5318008":
             out = "BOOBIES"
@@ -66,7 +74,11 @@ def flip(text, reply, message, chan):
             out = "5318008"
             message(random.choice(flippers) + " ︵ " + out)
         else:
-            message(random.choice(flippers) + " ︵ " + formatting.multi_replace(text[::-1], replacements))
+            message(
+                random.choice(flippers)
+                + " ︵ "
+                + formatting.multi_replace(text[::-1], replacements)
+            )
     else:
         reply(formatting.multi_replace(text[::-1], replacements))
 
@@ -74,16 +86,24 @@ def flip(text, reply, message, chan):
 @hook.command
 def table(text, message):
     """<text> - (╯°□°）╯︵ <ʇxǝʇ>"""
-    message(random.choice(flippers) + " ︵ " + formatting.multi_replace(text[::-1].lower(), replacements))
+    message(
+        random.choice(flippers)
+        + " ︵ "
+        + formatting.multi_replace(text[::-1].lower(), replacements)
+    )
 
 
 @hook.command
 def fix(text, reply, message, chan):
     """<text> - fixes a flipped over table. ┬─┬ノ(ಠ_ಠノ)"""
-    if text in ['table', 'tables']:
+    if text in ["table", "tables"]:
         if table_status.pop(chan, False) is True:
             message("┬─┬ノ(ಠ_ಠノ)")
         else:
-            message("no tables have been turned over in {}, thanks for checking!".format(chan))
+            message(
+                "no tables have been turned over in {}, thanks for checking!".format(
+                    chan
+                )
+            )
     else:
         flip(text, reply, message, chan)
diff --git a/plugins/fmk.py b/plugins/fmk.py
index 8ae20060..74af2688 100644
--- a/plugins/fmk.py
+++ b/plugins/fmk.py
@@ -1,10 +1,11 @@
 import codecs
 import os
 import random
+from typing import List
 
 from cloudbot import hook
 
-fmklist = []
+fmklist: List[str] = []
 
 
 @hook.on_start()
@@ -13,12 +14,22 @@ def load_fmk(bot):
     :type bot: cloudbot.bot.Cloudbot
     """
     fmklist.clear()
-    with codecs.open(os.path.join(bot.data_dir, "fmk.txt"), encoding="utf-8") as f:
-        fmklist.extend(line.strip() for line in f.readlines() if not line.startswith("//"))
+    with codecs.open(
+        os.path.join(bot.data_dir, "fmk.txt"), encoding="utf-8"
+    ) as f:
+        fmklist.extend(
+            line.strip() for line in f.readlines() if not line.startswith("//")
+        )
 
 
 @hook.command("fmk", autohelp=False)
 def fmk(text, message):
     """[nick] - Fuck, Marry, Kill"""
-    message(" {} FMK - {}, {}, {}".format((text.strip() if text.strip() else ""), random.choice(fmklist),
-                                          random.choice(fmklist), random.choice(fmklist)))
+    message(
+        " {} FMK - {}, {}, {}".format(
+            (text.strip() if text.strip() else ""),
+            random.choice(fmklist),
+            random.choice(fmklist),
+            random.choice(fmklist),
+        )
+    )
diff --git a/plugins/foaas.py b/plugins/foaas.py
index d54f73da..f5a92ec9 100644
--- a/plugins/foaas.py
+++ b/plugins/foaas.py
@@ -1,6 +1,7 @@
 import json
 import random
 from pathlib import Path
+from typing import Dict, List
 
 import requests
 
@@ -8,17 +9,17 @@
 
 BASE_URL = "http://www.foaas.com/{fuck}/{target}"
 
-headers = {'Accept': 'text/plain'}
+headers = {"Accept": "text/plain"}
 
-fuck_offs = {}
+fuck_offs: Dict[str, List[str]] = {}
 
 
 def format_url(fucker, fuckee=None):
     if fuckee:
-        fucks = fuck_offs['fuck_offs']
+        fucks = fuck_offs["fuck_offs"]
         target = "\2{fuckee}\2/{fucker}".format(fuckee=fuckee, fucker=fucker)
     else:
-        fucks = fuck_offs['single_fucks']
+        fucks = fuck_offs["single_fucks"]
         target = fucker
 
     return BASE_URL.format(fuck=random.choice(fucks), target=target)
@@ -35,11 +36,11 @@ def get_fuck_off(fucker, fuckee):
 def load_fuck_offs(bot):
     fuck_offs.clear()
     data_file = Path(bot.data_dir) / "foaas.json"
-    with data_file.open(encoding='utf-8') as f:
+    with data_file.open(encoding="utf-8") as f:
         fuck_offs.update(json.load(f))
 
 
-@hook.command('fos', 'fuckoff', 'foaas', autohelp=False)
+@hook.command("fos", "fuckoff", "foaas", autohelp=False)
 def foaas(text, nick, message):
     """[name] - tell some one to fuck off or just .fos for a generic fuckoff"""
     out = get_fuck_off(nick, text)
diff --git a/plugins/fortune.py b/plugins/fortune.py
index 5835f3e9..2e4631a4 100644
--- a/plugins/fortune.py
+++ b/plugins/fortune.py
@@ -1,10 +1,11 @@
 import codecs
 import os
 import random
+from typing import List
 
 from cloudbot import hook
 
-fortunes = []
+fortunes: List[str] = []
 
 
 @hook.on_start()
@@ -12,7 +13,9 @@ def load_fortunes(bot):
     path = os.path.join(bot.data_dir, "fortunes.txt")
     fortunes.clear()
     with codecs.open(path, encoding="utf-8") as f:
-        fortunes.extend(line.strip() for line in f.readlines() if not line.startswith("//"))
+        fortunes.extend(
+            line.strip() for line in f.readlines() if not line.startswith("//")
+        )
 
 
 @hook.command(autohelp=False)
diff --git a/plugins/gaming.py b/plugins/gaming.py
index 0a6d1e69..578331e1 100644
--- a/plugins/gaming.py
+++ b/plugins/gaming.py
@@ -15,10 +15,12 @@
 
 from cloudbot import hook
 
-whitespace_re = re.compile(r'\s+')
-valid_diceroll = re.compile(r'^([+-]?(?:\d+|\d*d(?:\d+|F))(?:[+-](?:\d+|\d*d(?:\d+|F)))*)( .+)?$', re.I)
-sign_re = re.compile(r'[+-]?(?:\d*d)?(?:\d+|F)', re.I)
-split_re = re.compile(r'([\d+-]*)d?(F|\d*)', re.I)
+whitespace_re = re.compile(r"\s+")
+valid_diceroll = re.compile(
+    r"^([+-]?(?:\d+|\d*d(?:\d+|F))(?:[+-](?:\d+|\d*d(?:\d+|F)))*)( .+)?$", re.I
+)
+sign_re = re.compile(r"[+-]?(?:\d*d)?(?:\d+|F)", re.I)
+split_re = re.compile(r"([\d+-]*)d?(F|\d*)", re.I)
 
 
 def clamp(n, min_value, max_value):
@@ -37,7 +39,7 @@ def n_rolls(count, n):
     :type count: int
     :type n: int | str
     """
-    if n in ('f', 'F'):
+    if n in ("f", "F"):
         return [random.randint(-1, 1) for _ in range(min(count, 100))]
 
     if count < 100:
@@ -45,7 +47,7 @@ def n_rolls(count, n):
 
     # Calculate a random sum approximated using a randomized normal variate with the midpoint used as the mu
     # and an approximated standard deviation based on variance as the sigma
-    mid = .5 * (n + 1) * count
+    mid = 0.5 * (n + 1) * count
     var = (n ** 2 - 1) / 12
     adj_var = (var * count) ** 0.5
 
@@ -72,7 +74,7 @@ def dice(text, notice):
     if "d" not in text:
         return
 
-    spec = whitespace_re.sub('', text)
+    spec = whitespace_re.sub("", text)
     if not valid_diceroll.match(spec):
         notice("Invalid dice roll '{}'".format(text))
         return
@@ -122,9 +124,9 @@ def choose(text, event):
 
     :type text: str
     """
-    choices = re.findall(r'([^,]+)', text.strip())
+    choices = re.findall(r"([^,]+)", text.strip())
     if len(choices) == 1:
-        choices = choices[0].split(' or ')
+        choices = choices[0].split(" or ")
         if len(choices) == 1:
             event.notice_doc()
             return
@@ -149,13 +151,21 @@ def coin(text, notice, action):
         amount = 1
 
     if amount == 1:
-        action("flips a coin and gets {}.".format(random.choice(["heads", "tails"])))
+        action(
+            "flips a coin and gets {}.".format(
+                random.choice(["heads", "tails"])
+            )
+        )
     elif amount == 0:
         action("makes a coin flipping motion")
     else:
-        mu = .5 * amount
-        sigma = (.75 * amount) ** .5
+        mu = 0.5 * amount
+        sigma = (0.75 * amount) ** 0.5
         n = random.normalvariate(mu, sigma)
         heads = clamp(int(round(n)), 0, amount)
         tails = amount - heads
-        action("flips {} coins and gets {} heads and {} tails.".format(amount, heads, tails))
+        action(
+            "flips {} coins and gets {} heads and {} tails.".format(
+                amount, heads, tails
+            )
+        )
diff --git a/plugins/geoip.py b/plugins/geoip.py
index c1d655b8..f102b186 100644
--- a/plugins/geoip.py
+++ b/plugins/geoip.py
@@ -14,7 +14,9 @@
 
 logger = logging.getLogger("cloudbot")
 
-DB_URL = "http://geolite.maxmind.com/download/geoip/database/GeoLite2-City.mmdb.gz"
+DB_URL = (
+    "http://geolite.maxmind.com/download/geoip/database/GeoLite2-City.mmdb.gz"
+)
 PATH = "./data/GeoLite2-City.mmdb"
 
 
@@ -31,8 +33,8 @@ def fetch_db():
         os.remove(PATH)
     r = requests.get(DB_URL, stream=True)
     if r.status_code == 200:
-        with gzip.open(r.raw, 'rb') as infile:
-            with open(PATH, 'wb') as outfile:
+        with gzip.open(r.raw, "rb") as infile:
+            with open(PATH, "wb") as outfile:
                 shutil.copyfileobj(infile, outfile)
 
 
@@ -87,18 +89,22 @@ async def geoip(text, reply, loop):
         return "Invalid input."
 
     try:
-        location_data = await loop.run_in_executor(None, geoip_reader.reader.city, ip)
+        location_data = await loop.run_in_executor(
+            None, geoip_reader.reader.city, ip
+        )
     except geoip2.errors.AddressNotFoundError:
         return "Sorry, I can't locate that in my database."
 
     data = {
         "cc": location_data.country.iso_code or "N/A",
         "country": location_data.country.name or "Unknown",
-        "city": location_data.city.name or "Unknown"
+        "city": location_data.city.name or "Unknown",
     }
 
     # add a region to the city if one is listed
     if location_data.subdivisions.most_specific.name:
         data["city"] += ", " + location_data.subdivisions.most_specific.name
 
-    reply("\x02Country:\x02 {country} ({cc}), \x02City:\x02 {city}".format(**data))
+    reply(
+        "\x02Country:\x02 {country} ({cc}), \x02City:\x02 {city}".format(**data)
+    )
diff --git a/plugins/giphy.py b/plugins/giphy.py
index 81165d21..ef4cdad5 100644
--- a/plugins/giphy.py
+++ b/plugins/giphy.py
@@ -5,7 +5,7 @@
 from cloudbot import hook
 from cloudbot.bot import bot
 
-api_url = 'http://api.giphy.com/v1/gifs'
+api_url = "http://api.giphy.com/v1/gifs"
 
 
 @hook.command("gif", "giphy")
@@ -13,21 +13,18 @@ def giphy(text):
     """<query> - Searches giphy.com for a gif using the provided search term."""
     api_key = bot.config.get_api_key("giphy")
     term = text.strip()
-    search_url = api_url + '/search'
-    params = {
-        'q': term,
-        'limit': 10,
-        'fmt': "json",
-        'api_key': api_key
-    }
+    search_url = api_url + "/search"
+    params = {"q": term, "limit": 10, "fmt": "json", "api_key": api_key}
     results = requests.get(search_url, params=params)
     results.raise_for_status()
     r = results.json()
-    if not r['data']:
+    if not r["data"]:
         return "no results found."
-    gif = random.choice(r['data'])
-    if gif['rating']:
-        out = "{} content rating: \x02{}\x02. (Powered by GIPHY)".format(gif['embed_url'], gif['rating'].upper())
+    gif = random.choice(r["data"])
+    if gif["rating"]:
+        out = "{} content rating: \x02{}\x02. (Powered by GIPHY)".format(
+            gif["embed_url"], gif["rating"].upper()
+        )
     else:
-        out = "{} - (Powered by GIPHY)".format(gif['embed_url'])
+        out = "{} - (Powered by GIPHY)".format(gif["embed_url"])
     return out
diff --git a/plugins/github.py b/plugins/github.py
index d9efb5de..8f389974 100644
--- a/plugins/github.py
+++ b/plugins/github.py
@@ -6,7 +6,9 @@
 from cloudbot.util import formatting, web
 
 shortcuts = {}
-url_re = re.compile(r"(?:https?://github\.com/)?(?P<owner>[^/]+)/(?P<repo>[^/]+)")
+url_re = re.compile(
+    r"(?:https?://github\.com/)?(?P<owner>[^/]+)/(?P<repo>[^/]+)"
+)
 
 
 def parse_url(url):
@@ -31,12 +33,16 @@ def load_shortcuts(bot):
 def issue_cmd(text):
     """<username|repo> [number] - gets issue [number]'s summary, or the open issue count if no issue is specified"""
     args = text.split()
-    owner, repo = parse_url(args[0] if args[0] not in shortcuts else shortcuts[args[0]])
+    owner, repo = parse_url(
+        args[0] if args[0] not in shortcuts else shortcuts[args[0]]
+    )
     issue = args[1] if len(args) > 1 else None
 
     if issue:
         r = requests.get(
-            "https://api.github.com/repos/{}/{}/issues/{}".format(owner, repo, issue)
+            "https://api.github.com/repos/{}/{}/issues/{}".format(
+                owner, repo, issue
+            )
         )
         r.raise_for_status()
         j = r.json()
@@ -48,10 +54,16 @@ def issue_cmd(text):
         if j["state"] == "open":
             state = "\x033\x02Opened\x02\x0f by {}".format(j["user"]["login"])
         else:
-            state = "\x034\x02Closed\x02\x0f by {}".format(j["closed_by"]["login"])
+            state = "\x034\x02Closed\x02\x0f by {}".format(
+                j["closed_by"]["login"]
+            )
 
-        return "Issue #{} ({}): {} | {}: {}".format(number, state, url, title, summary)
-    r = requests.get("https://api.github.com/repos/{}/{}/issues".format(owner, repo))
+        return "Issue #{} ({}): {} | {}: {}".format(
+            number, state, url, title, summary
+        )
+    r = requests.get(
+        "https://api.github.com/repos/{}/{}/issues".format(owner, repo)
+    )
     r.raise_for_status()
     j = r.json()
 
diff --git a/plugins/gnomeagainsthumanity.py b/plugins/gnomeagainsthumanity.py
index 13493c50..5b969cfb 100644
--- a/plugins/gnomeagainsthumanity.py
+++ b/plugins/gnomeagainsthumanity.py
@@ -3,33 +3,36 @@
 import os
 import random
 import re
+from typing import Dict, List
 
 from cloudbot import hook
 
-gnomecards = {}
+gnomecards: Dict[str, List[str]] = {}
 
 
 @hook.on_start()
 def shuffle_deck(bot):
     gnomecards.clear()
-    with codecs.open(os.path.join(bot.data_dir, "gnomecards.json"), encoding="utf-8") as f:
+    with codecs.open(
+        os.path.join(bot.data_dir, "gnomecards.json"), encoding="utf-8"
+    ) as f:
         gnomecards.update(json.load(f))
 
 
-@hook.command('cah')
+@hook.command("cah")
 def CAHwhitecard(text):
     """<text> - Submit text to be used as a CAH whitecard"""
-    return random.choice(gnomecards['black']).format(text)
+    return random.choice(gnomecards["black"]).format(text)
 
 
-@hook.command('cahb')
+@hook.command("cahb")
 def CAHblackcard(text):
     """<text> - Submit text with _ for the bot to fill in the rest. You can submit text with multiple _"""
     CardText = text.strip()
 
     # noinspection PyUnusedLocal
     def blankfiller(matchobj):
-        return random.choice(gnomecards['white'])
+        return random.choice(gnomecards["white"])
 
-    out = re.sub(r'\b_\b', blankfiller, CardText)
+    out = re.sub(r"\b_\b", blankfiller, CardText)
     return out
diff --git a/plugins/google_cse.py b/plugins/google_cse.py
index c3bf24fd..a1a9255c 100644
--- a/plugins/google_cse.py
+++ b/plugins/google_cse.py
@@ -15,12 +15,12 @@
 
 from cloudbot import hook
 from cloudbot.bot import bot
-from cloudbot.util import formatting, filesize
+from cloudbot.util import filesize, formatting
 
-API_CS = 'https://www.googleapis.com/customsearch/v1'
+API_CS = "https://www.googleapis.com/customsearch/v1"
 
 
-@hook.command('gse')
+@hook.command("gse")
 def gse(text):
     """<query> - Returns first Google search result for <query>."""
     dev_key = bot.config.get_api_key("google_dev_key")
@@ -30,25 +30,27 @@ def gse(text):
     if not cx:
         return "This command requires a custom Google Search Engine ID."
 
-    parsed = requests.get(API_CS, params={"cx": cx, "q": text, "key": dev_key}).json()
+    parsed = requests.get(
+        API_CS, params={"cx": cx, "q": text, "key": dev_key}
+    ).json()
 
     try:
-        result = parsed['items'][0]
+        result = parsed["items"][0]
     except KeyError:
         return "No results found."
 
-    title = formatting.truncate_str(result['title'], 60)
-    content = result['snippet']
+    title = formatting.truncate_str(result["title"], 60)
+    content = result["snippet"]
 
     if not content:
         content = "No description available."
     else:
-        content = formatting.truncate_str(content.replace('\n', ''), 150)
+        content = formatting.truncate_str(content.replace("\n", ""), 150)
 
-    return u'{} -- \x02{}\x02: "{}"'.format(result['link'], title, content)
+    return '{} -- \x02{}\x02: "{}"'.format(result["link"], title, content)
 
 
-@hook.command('gseis', 'image')
+@hook.command("gseis", "image")
 def gse_gis(text):
     """<query> - Returns first Google Images result for <query>."""
     dev_key = bot.config.get_api_key("google_dev_key")
@@ -58,15 +60,20 @@ def gse_gis(text):
     if not cx:
         return "This command requires a custom Google Search Engine ID."
 
-    parsed = requests.get(API_CS, params={"cx": cx, "q": text, "searchType": "image", "key": dev_key}).json()
+    parsed = requests.get(
+        API_CS,
+        params={"cx": cx, "q": text, "searchType": "image", "key": dev_key},
+    ).json()
 
     try:
-        result = parsed['items'][0]
-        metadata = parsed['items'][0]['image']
+        result = parsed["items"][0]
+        metadata = parsed["items"][0]["image"]
     except KeyError:
         return "No results found."
 
-    dimens = '{}x{}px'.format(metadata['width'], metadata['height'])
-    size = filesize.size(int(metadata['byteSize']))
+    dimens = "{}x{}px".format(metadata["width"], metadata["height"])
+    size = filesize.size(int(metadata["byteSize"]))
 
-    return u'{} [{}, {}, {}]'.format(result['link'], dimens, result['mime'], size)
+    return "{} [{}, {}, {}]".format(
+        result["link"], dimens, result["mime"], size
+    )
diff --git a/plugins/google_translate.py b/plugins/google_translate.py
index 22bfea40..d8a7272b 100644
--- a/plugins/google_translate.py
+++ b/plugins/google_translate.py
@@ -8,34 +8,31 @@
 
 def goog_trans(text, source, target):
     api_key = bot.config.get_api_key("google_dev_key")
-    url = 'https://www.googleapis.com/language/translate/v2'
+    url = "https://www.googleapis.com/language/translate/v2"
 
     if len(text) > max_length:
         return "This command only supports input of less then 100 characters."
 
-    params = {
-        'q': text,
-        'key': api_key,
-        'target': target,
-        'format': 'text'
-    }
+    params = {"q": text, "key": api_key, "target": target, "format": "text"}
 
     if source:
-        params['source'] = source
+        params["source"] = source
 
     request = requests.get(url, params=params)
     parsed = request.json()
 
-    if parsed.get('error'):
-        if parsed['error']['code'] == 403:
+    if parsed.get("error"):
+        if parsed["error"]["code"] == 403:
             return "The Translate API is off in the Google Developers Console."
 
         return "Google API error."
 
     if not source:
-        return '(%(detectedSourceLanguage)s) %(translatedText)s' % (parsed['data']['translations'][0])
+        return "(%(detectedSourceLanguage)s) %(translatedText)s" % (
+            parsed["data"]["translations"][0]
+        )
 
-    return '%(translatedText)s' % parsed['data']['translations'][0]
+    return "%(translatedText)s" % parsed["data"]["translations"][0]
 
 
 def match_language(fragment):
@@ -54,28 +51,28 @@ def match_language(fragment):
 @hook.command("google_translate")
 def translate(text):
     """[source language [target language]] <sentence> - translates <sentence> from source language (default autodetect)
-     to target language (default English) using Google Translate"""
+    to target language (default English) using Google Translate"""
     api_key = bot.config.get_api_key("google_dev_key")
     if not api_key:
         return "This command requires a Google Developers Console API key."
 
-    args = text.split(' ', 2)
+    args = text.split(" ", 2)
 
     try:
         if len(args) >= 2:
             sl = match_language(args[0])
             if not sl:
-                return goog_trans(text, '', 'en')
+                return goog_trans(text, "", "en")
             if len(args) == 2:
-                return goog_trans(args[1], sl, 'en')
+                return goog_trans(args[1], sl, "en")
             if len(args) >= 3:
                 tl = match_language(args[1])
                 if not tl:
-                    if sl == 'en':
-                        return 'unable to determine desired target language'
-                    return goog_trans(args[1] + ' ' + args[2], sl, 'en')
+                    if sl == "en":
+                        return "unable to determine desired target language"
+                    return goog_trans(args[1] + " " + args[2], sl, "en")
                 return goog_trans(args[2], sl, tl)
-        return goog_trans(text, '', 'en')
+        return goog_trans(text, "", "en")
     except IOError as e:
         return e
 
@@ -140,5 +137,5 @@ def translate(text):
     ("ur", "Urdu"),
     ("vi", "Vietnamese"),
     ("cy", "Welsh"),
-    ("yi", "Yiddish")
+    ("yi", "Yiddish"),
 ]
diff --git a/plugins/googleurlparse.py b/plugins/googleurlparse.py
index 130e4125..bb8b3613 100644
--- a/plugins/googleurlparse.py
+++ b/plugins/googleurlparse.py
@@ -3,7 +3,7 @@
 
 from cloudbot import hook
 
-spamurl = re.compile(r'.*(((www\.)?google\.com/url\?)[^ ]+)', re.I)
+spamurl = re.compile(r".*(((www\.)?google\.com/url\?)[^ ]+)", re.I)
 
 
 @hook.regex(spamurl)
@@ -12,6 +12,14 @@ def google_url(match):
     url = matches
 
     url = "http://{}".format(url)
-    out = "".join([(unquote(a[4:]) if a[:4] == "url=" else "") for a in url.split("&")]) \
-        .replace(", ,", "").strip()
+    out = (
+        "".join(
+            [
+                (unquote(a[4:]) if a[:4] == "url=" else "")
+                for a in url.split("&")
+            ]
+        )
+        .replace(", ,", "")
+        .strip()
+    )
     return out
diff --git a/plugins/grab.py b/plugins/grab.py
index fe57821b..91ce4f5f 100644
--- a/plugins/grab.py
+++ b/plugins/grab.py
@@ -2,27 +2,28 @@
 import random
 from collections import defaultdict
 from threading import RLock
+from typing import Dict, List
 
-from sqlalchemy import Table, Column, String
+from sqlalchemy import Column, String, Table
 from sqlalchemy.exc import SQLAlchemyError
 
 from cloudbot import hook
 from cloudbot.util import database
-from cloudbot.util.pager import paginated_list, CommandPager
+from cloudbot.util.pager import CommandPager, paginated_list
 
-search_pages = defaultdict(dict)
+search_pages: Dict[str, Dict[str, CommandPager]] = defaultdict(dict)
 
 table = Table(
-    'grab',
+    "grab",
     database.metadata,
-    Column('name', String),
-    Column('time', String),
-    Column('quote', String),
-    Column('chan', String)
+    Column("name", String),
+    Column("time", String),
+    Column("quote", String),
+    Column("chan", String),
 )
 
-grab_cache = {}
-grab_locks = defaultdict(dict)
+grab_cache: Dict[str, Dict[str, List[str]]] = {}
+grab_locks: Dict[str, Dict[str, RLock]] = defaultdict(dict)
 grab_locks_lock = RLock()
 cache_lock = RLock()
 
@@ -70,7 +71,9 @@ def check_grabs(name, quote, chan):
 
 def grab_add(nick, time, msg, chan, db):
     # Adds a quote to the grab table
-    db.execute(table.insert().values(name=nick, time=time, quote=msg, chan=chan))
+    db.execute(
+        table.insert().values(name=nick, time=time, quote=msg, chan=chan)
+    )
     db.commit()
     load_cache(db)
 
@@ -90,20 +93,28 @@ def grab(text, nick, chan, db, conn):
         return "Didn't your mother teach you not to grab yourself?"
 
     with grab_locks_lock:
-        grab_lock = grab_locks[conn.name.casefold()].setdefault(chan.casefold(), RLock())
+        grab_lock = grab_locks[conn.name.casefold()].setdefault(
+            chan.casefold(), RLock()
+        )
 
     with grab_lock:
         name, timestamp, msg = get_latest_line(conn, chan, text)
         if not msg:
-            return "I couldn't find anything from {} in recent history.".format(text)
+            return "I couldn't find anything from {} in recent history.".format(
+                text
+            )
 
         if check_grabs(text.casefold(), msg, chan):
-            return "I already have that quote from {} in the database".format(text)
+            return "I already have that quote from {} in the database".format(
+                text
+            )
 
         try:
             grab_add(name.casefold(), timestamp, msg, chan, db)
         except SQLAlchemyError:
-            logger.exception("Error occurred when grabbing %s in %s", name, chan)
+            logger.exception(
+                "Error occurred when grabbing %s in %s", name, chan
+            )
             return "Error occurred."
 
         if check_grabs(name.casefold(), msg, chan):
@@ -114,7 +125,7 @@ def grab(text, nick, chan, db, conn):
 
 def format_grab(name, quote):
     # add nonbreaking space to nicks to avoid highlighting people with printed grabs
-    name = "{}{}{}".format(name[0], u"\u200B", name[1:])
+    name = "{}{}{}".format(name[0], "\u200B", name[1:])
     if quote.startswith("\x01ACTION") or quote.startswith("*"):
         quote = quote.replace("\x01ACTION", "").replace("\x01", "")
         out = "* {}{}".format(name, quote)
@@ -158,7 +169,9 @@ def grabrandom(text, chan, message):
                     matching_quotes.extend((nick, quote) for quote in quotes)
         else:
             matching_quotes.extend(
-                (name, quote) for name, quotes in chan_grabs.items() for quote in quotes
+                (name, quote)
+                for name, quotes in chan_grabs.items()
+                for quote in quotes
             )
 
     if not matching_quotes:
@@ -189,7 +202,11 @@ def grabsearch(text, chan, conn):
 
         for name, quotes in chan_grabs.items():
             if name != lower_text:
-                result.extend((name, quote) for quote in quotes if lower_text in quote.lower())
+                result.extend(
+                    (name, quote)
+                    for quote in quotes
+                    if lower_text in quote.lower()
+                )
 
     if not result:
         return "I couldn't find any matches for {}.".format(text)
diff --git a/plugins/herald.py b/plugins/herald.py
index 35b1739a..cc68fa86 100644
--- a/plugins/herald.py
+++ b/plugins/herald.py
@@ -2,24 +2,29 @@
 import random
 import re
 from collections import defaultdict
+from typing import Dict
 
-from sqlalchemy import Table, Column, String, PrimaryKeyConstraint
+from sqlalchemy import Column, PrimaryKeyConstraint, String, Table
 
 from cloudbot import hook
 from cloudbot.util import database
 
 table = Table(
-    'herald',
+    "herald",
     database.metadata,
-    Column('name', String),
-    Column('chan', String),
-    Column('quote', String),
-    PrimaryKeyConstraint('name', 'chan')
+    Column("name", String),
+    Column("chan", String),
+    Column("quote", String),
+    PrimaryKeyConstraint("name", "chan"),
 )
 
 
 class ChannelData:
-    def __init__(self, chan_interval=datetime.timedelta(seconds=10), user_interval=datetime.timedelta(minutes=5)):
+    def __init__(
+        self,
+        chan_interval=datetime.timedelta(seconds=10),
+        user_interval=datetime.timedelta(minutes=5),
+    ):
         self.user_interval = user_interval
         self.chan_interval = chan_interval
         self.next_send = datetime.datetime.min
@@ -38,8 +43,10 @@ def can_send(self, nick: str, join_time: datetime.datetime) -> bool:
         return True
 
 
-user_join = defaultdict(lambda: defaultdict(ChannelData))
-herald_cache = defaultdict(dict)
+user_join: Dict[str, Dict[str, ChannelData]] = defaultdict(
+    lambda: defaultdict(ChannelData)
+)
+herald_cache: Dict[str, Dict[str, str]] = defaultdict(dict)
 
 
 @hook.on_start
@@ -68,19 +75,30 @@ def herald(text, nick, chan, db, reply):
         if greeting is None:
             return "no herald set, unable to delete."
 
-        query = table.delete().where(table.c.name == nick.lower()).where(table.c.chan == chan.lower())
+        query = (
+            table.delete()
+            .where(table.c.name == nick.lower())
+            .where(table.c.chan == chan.lower())
+        )
         db.execute(query)
         db.commit()
 
-        reply("greeting \'{}\' for {} has been removed".format(greeting, nick))
+        reply("greeting '{}' for {} has been removed".format(greeting, nick))
 
         load_cache(db)
     else:
         res = db.execute(
-            table.update().where(table.c.name == nick.lower()).where(table.c.chan == chan.lower()).values(quote=text)
+            table.update()
+            .where(table.c.name == nick.lower())
+            .where(table.c.chan == chan.lower())
+            .values(quote=text)
         )
         if res.rowcount == 0:
-            db.execute(table.insert().values(name=nick.lower(), chan=chan.lower(), quote=text))
+            db.execute(
+                table.insert().values(
+                    name=nick.lower(), chan=chan.lower(), quote=text
+                )
+            )
 
         db.commit()
         reply("greeting successfully added")
@@ -88,14 +106,18 @@ def herald(text, nick, chan, db, reply):
         load_cache(db)
 
 
-@hook.command(permissions=["botcontrol", "snoonetstaff", "deleteherald", "chanop"])
+@hook.command(
+    permissions=["botcontrol", "snoonetstaff", "deleteherald", "chanop"]
+)
 def deleteherald(text, chan, db, reply):
     """<nickname> - Delete [nickname]'s herald."""
 
     nick = text.strip()
 
     res = db.execute(
-        table.delete().where(table.c.name == nick.lower()).where(table.c.chan == chan.lower())
+        table.delete()
+        .where(table.c.name == nick.lower())
+        .where(table.c.chan == chan.lower())
     )
 
     db.commit()
@@ -115,10 +137,10 @@ def should_send(conn, chan, nick, join_time) -> bool:
 
 @hook.irc_raw("JOIN", singlethread=True)
 def welcome(nick, message, bot, chan, conn):
-    decoy = re.compile('[Òo○O0öøóȯôőŏᴏōο][<>＜]')
-    colors_re = re.compile(r'\x02|\x03(?:\d{1,2}(?:,\d{1,2})?)?', re.UNICODE)
-    bino_re = re.compile('b+i+n+o+', re.IGNORECASE)
-    offensive_re = re.compile('卐')
+    decoy = re.compile("[Òo○O0öøóȯôőŏᴏōο][<>＜]")
+    colors_re = re.compile(r"\x02|\x03(?:\d{1,2}(?:,\d{1,2})?)?", re.UNICODE)
+    bino_re = re.compile("b+i+n+o+", re.IGNORECASE)
+    offensive_re = re.compile("卐")
 
     grab = bot.plugin_manager.find_plugin("grab")
 
@@ -129,10 +151,12 @@ def welcome(nick, message, bot, chan, conn):
     if not should_send(conn.name, chan, nick, datetime.datetime.now()):
         return
 
-    stripped = greet.translate(dict.fromkeys(map(ord, ["\u200b", " ", "\u202f", "\x02"])))
+    stripped = greet.translate(
+        dict.fromkeys(map(ord, ["\u200b", " ", "\u202f", "\x02"]))
+    )
     stripped = colors_re.sub("", stripped)
-    greet = re.sub(bino_re, 'flenny', greet)
-    greet = re.sub(offensive_re, ' freespeech oppression ', greet)
+    greet = re.sub(bino_re, "flenny", greet)
+    greet = re.sub(offensive_re, " freespeech oppression ", greet)
 
     words = greet.lower().split()
     cmd = words.pop(0)
diff --git a/plugins/hookup.py b/plugins/hookup.py
index 425b74d8..ac225516 100644
--- a/plugins/hookup.py
+++ b/plugins/hookup.py
@@ -3,28 +3,32 @@
 import os
 import random
 import time
+from typing import Any, Dict
 
-from sqlalchemy import table, column, String, Float, and_, select
+from sqlalchemy import Float, String, and_, column, select, table
 
 from cloudbot import hook
 from cloudbot.util.database import metadata
 from cloudbot.util.textgen import TextGenerator
 
-hookups = {}
+hookups: Dict[str, Any] = {}
+
 seen_table = table(
-    'seen_user',
-    column('name', String),
-    column('time', Float),
-    column('quote', String),
-    column('chan', String),
-    column('host', String),
+    "seen_user",
+    column("name", String),
+    column("time", Float),
+    column("quote", String),
+    column("chan", String),
+    column("host", String),
 )
 
 
 @hook.on_start
 def load_data(bot):
     hookups.clear()
-    with codecs.open(os.path.join(bot.data_dir, "hookup.json"), encoding="utf-8") as f:
+    with codecs.open(
+        os.path.join(bot.data_dir, "hookup.json"), encoding="utf-8"
+    ) as f:
         hookups.update(json.load(f))
 
 
@@ -35,10 +39,12 @@ def hookup(db, chan):
         return
 
     times = time.time() - 86400
-    results = db.execute(select(
-        [seen_table.c.name],
-        and_(seen_table.c.chan == chan, seen_table.c.time > times)
-    )).fetchall()
+    results = db.execute(
+        select(
+            [seen_table.c.name],
+            and_(seen_table.c.chan == chan, seen_table.c.time > times),
+        )
+    ).fetchall()
 
     if not results or len(results) < 2:
         return "something went wrong"
@@ -48,10 +54,10 @@ def hookup(db, chan):
     random.shuffle(people)
     person1, person2 = people[:2]
     variables = {
-        'user1': person1,
-        'user2': person2,
+        "user1": person1,
+        "user2": person2,
     }
     generator = TextGenerator(
-        hookups['templates'], hookups['parts'], variables=variables
+        hookups["templates"], hookups["parts"], variables=variables
     )
     return generator.generate_string()
diff --git a/plugins/imdb.py b/plugins/imdb.py
index 8cae0eea..138efa23 100644
--- a/plugins/imdb.py
+++ b/plugins/imdb.py
@@ -4,65 +4,66 @@
 
 from cloudbot import hook
 
-id_re = re.compile(r'tt\d+')
-imdb_re = re.compile(r'https?://(?:www\.)?imdb\.com/+title/+(tt[0-9]+)', re.I)
+id_re = re.compile(r"tt\d+")
+imdb_re = re.compile(r"https?://(?:www\.)?imdb\.com/+title/+(tt[0-9]+)", re.I)
 
 
 @hook.command
 def imdb(text, bot):
     """<movie> - gets information about <movie> from IMDb"""
 
-    headers = {'User-Agent': bot.user_agent}
+    headers = {"User-Agent": bot.user_agent}
     strip = text.strip()
 
     if id_re.match(strip):
-        endpoint = 'title'
-        params = {'id': strip}
+        endpoint = "title"
+        params = {"id": strip}
     else:
-        endpoint = 'search'
-        params = {'q': strip, 'limit': 1}
+        endpoint = "search"
+        params = {"q": strip, "limit": 1}
 
     request = requests.get(
         "https://imdb-scraper.herokuapp.com/" + endpoint,
         params=params,
-        headers=headers)
+        headers=headers,
+    )
     request.raise_for_status()
     content = request.json()
 
-    if content['success'] is False:
-        return 'Unknown error'
+    if content["success"] is False:
+        return "Unknown error"
 
-    if not content['result']:
-        return 'No movie found'
+    if not content["result"]:
+        return "No movie found"
 
-    result = content['result']
-    if endpoint == 'search':
+    result = content["result"]
+    if endpoint == "search":
         result = result[0]  # part of the search results, not 1 record
-    url = 'http://www.imdb.com/title/{}'.format(result['id'])
-    return movie_str(result) + ' ' + url
+    url = "http://www.imdb.com/title/{}".format(result["id"])
+    return movie_str(result) + " " + url
 
 
 @hook.regex(imdb_re)
 def imdb_url(match, bot):
-    headers = {'User-Agent': bot.user_agent}
+    headers = {"User-Agent": bot.user_agent}
 
-    params = {'id': match.group(1)}
+    params = {"id": match.group(1)}
     request = requests.get(
         "https://imdb-scraper.herokuapp.com/title",
         params=params,
-        headers=headers)
+        headers=headers,
+    )
     content = request.json()
 
-    if content['success'] is True:
-        return movie_str(content['result'])
+    if content["success"] is True:
+        return movie_str(content["result"])
 
 
 def movie_str(movie):
-    movie['genre'] = ', '.join(movie['genres'])
-    out = '\x02%(title)s\x02 (%(year)s) (%(genre)s): %(plot)s'
-    if movie['runtime'] != 'N/A':
-        out += ' \x02%(runtime)s\x02.'
-    if movie['rating'] != 'N/A' and movie['votes'] != 'N/A':
-        out += ' \x02%(rating)s/10\x02 with \x02%(votes)s\x02' \
-               ' votes.'
+    movie["genre"] = ", ".join(movie["genres"])
+    out = "\x02%(title)s\x02 (%(year)s) (%(genre)s): %(plot)s"
+    if movie["runtime"] != "N/A":
+        out += " \x02%(runtime)s\x02."
+    if movie["rating"] != "N/A" and movie["votes"] != "N/A":
+        out += " \x02%(rating)s/10\x02 with \x02%(votes)s\x02" " votes."
     return out % movie
diff --git a/plugins/imgur.py b/plugins/imgur.py
index 6980fd50..ee54871f 100644
--- a/plugins/imgur.py
+++ b/plugins/imgur.py
@@ -71,7 +71,7 @@ def get_items(text):
 @hook.command(autohelp=False)
 def imgur(text):
     """[search term] / [/r/subreddit] / [/user/username] / memes / random - returns a link to a random imgur image based
-     on your input. if no input is given the bot will get an image from the imgur frontpage """
+    on your input. if no input is given the bot will get an image from the imgur frontpage"""
     text = text.strip().lower()
 
     if not container.api:
@@ -102,7 +102,9 @@ def imgur(text):
     # if it's an imgur meme, add the meme name
     # if not, AttributeError will trigger and code will carry on
     with suppress(AttributeError):
-        title = "\x02{}\x02 - {}".format(item.meme_metadata["meme_name"].lower(), title)
+        title = "\x02{}\x02 - {}".format(
+            item.meme_metadata["meme_name"].lower(), title
+        )
 
     # if the item has a tag, show that
     if item.section:
@@ -127,7 +129,7 @@ def imgur(text):
 @hook.command("imguralbum", "multiimgur", "imgalbum", "album", autohelp=False)
 def imguralbum(text, conn):
     """[search term] / [/r/subreddit] / [/user/username] / memes / random - returns a link to lots of random images
-    based on your input. if no input is given the bot will get images from the imgur frontpage """
+    based on your input. if no input is given the bot will get images from the imgur frontpage"""
     text = text.strip().lower()
 
     if not container.api:
@@ -147,10 +149,10 @@ def imguralbum(text, conn):
     nsfw = any([item.nsfw for item in items])
 
     params = {
-        'title': '{} presents: "{}"'.format(conn.nick, text or "random images"),
-        'ids': ",".join([item.id for item in items]),
-        'layout': 'blog',
-        'account_url': None
+        "title": '{} presents: "{}"'.format(conn.nick, text or "random images"),
+        "ids": ",".join([item.id for item in items]),
+        "layout": "blog",
+        "account_url": None,
     }
     album = container.api.create_album(params)
 
diff --git a/plugins/issafe.py b/plugins/issafe.py
index cc578bfc..d1c039be 100644
--- a/plugins/issafe.py
+++ b/plugins/issafe.py
@@ -24,16 +24,26 @@
 @hook.command()
 def issafe(text):
     """<website> - Checks the website against Google's Safe Browsing List."""
-    if urlparse(text).scheme not in ['https', 'http']:
+    if urlparse(text).scheme not in ["https", "http"]:
         return "Check your URL (it should be a complete URI)."
 
     dev_key = bot.config.get_api_key("google_dev_key")
-    parsed = requests.get(API_SB, params={"url": text, "client": "cloudbot", "key": dev_key, "pver": "3.1",
-                                          "appver": str(cloudbot.__version__)})
+    parsed = requests.get(
+        API_SB,
+        params={
+            "url": text,
+            "client": "cloudbot",
+            "key": dev_key,
+            "pver": "3.1",
+            "appver": str(cloudbot.__version__),
+        },
+    )
     parsed.raise_for_status()
 
     if parsed.status_code == 204:
         condition = "\x02{}\x02 is safe.".format(text)
     else:
-        condition = "\x02{}\x02 is known to contain: {}".format(text, parsed.text)
+        condition = "\x02{}\x02 is known to contain: {}".format(
+            text, parsed.text
+        )
     return condition
diff --git a/plugins/jokes.py b/plugins/jokes.py
index 63013dec..0151e5fd 100644
--- a/plugins/jokes.py
+++ b/plugins/jokes.py
@@ -11,10 +11,12 @@ def load_joke_file(path):
     :type path: Path
     :rtype: List[str]
     """
-    with path.open(encoding='utf-8') as f:
-        return [line.strip() for line in f
-                if line.strip()
-                and not line.startswith('//')]
+    with path.open(encoding="utf-8") as f:
+        return [
+            line.strip()
+            for line in f
+            if line.strip() and not line.startswith("//")
+        ]
 
 
 @hook.on_start()
@@ -25,15 +27,15 @@ def load_jokes(bot):
     """
     data_directory = Path(bot.data_dir)
     file_list = [
-        'yo_momma.txt',
-        'do_it.txt',
-        'puns.txt',
-        'confucious.txt',
-        'one_liners.txt',
-        'wisdom.txt',
-        'book_puns.txt',
-        'lawyerjoke.txt',
-        'kero.txt',
+        "yo_momma.txt",
+        "do_it.txt",
+        "puns.txt",
+        "confucious.txt",
+        "one_liners.txt",
+        "wisdom.txt",
+        "book_puns.txt",
+        "lawyerjoke.txt",
+        "kero.txt",
     ]
     for file_name in file_list:
         file_path = data_directory / file_name
@@ -46,20 +48,20 @@ def yomomma(text, nick, conn, is_nick_valid):
     target = text.strip()
     if not is_nick_valid(target) or target.lower() == conn.nick.lower():
         target = nick
-    joke = random.choice(joke_lines['yo_momma']).lower()
-    return '{}, {}'.format(target, joke)
+    joke = random.choice(joke_lines["yo_momma"]).lower()
+    return "{}, {}".format(target, joke)
 
 
 @hook.command(autohelp=False)
 def doit(message):
     """- Prints a do it line, example: mathematicians do with a pencil."""
-    message(random.choice(joke_lines['do_it']))
+    message(random.choice(joke_lines["do_it"]))
 
 
 @hook.command(autohelp=False)
 def pun(message):
     """- Come on everyone loves puns right?"""
-    message(random.choice(joke_lines['puns']))
+    message(random.choice(joke_lines["puns"]))
 
 
 @hook.command(autohelp=False)
@@ -67,27 +69,27 @@ def confucious(message):
     """- Confucious say man standing on toilet is high on pot.
     (Note that the spelling is deliberate: https://www.urbandictionary.com/define.php?term=Confucious)
     """
-    saying = random.choice(joke_lines['confucious']).lower()
-    message('Confucious say {}'.format(saying))
+    saying = random.choice(joke_lines["confucious"]).lower()
+    message("Confucious say {}".format(saying))
 
 
 @hook.command(autohelp=False)
 def dadjoke(message):
     """- Love em or hate em, bring on the dad jokes."""
-    message(random.choice(joke_lines['one_liners']))
+    message(random.choice(joke_lines["one_liners"]))
 
 
 @hook.command(autohelp=False)
 def wisdom(message):
     """- Words of wisdom from various bathroom stalls."""
-    message(random.choice(joke_lines['wisdom']))
+    message(random.choice(joke_lines["wisdom"]))
 
 
 @hook.command(autohelp=False)
 def bookpun(message):
     """- Suggests a pun of a book title/author."""
     # suggestions = ["Why not try", "You should read", "You gotta check out"]
-    message(random.choice(joke_lines['book_puns']))
+    message(random.choice(joke_lines["book_puns"]))
 
 
 @hook.command("boobs", "boobies")
@@ -95,9 +97,13 @@ def boobies(text):
     """<text> - Everything is better with boobies!"""
     boob = "\u2299"
     out = text.strip()
-    out = out.replace('o', boob).replace('O', boob).replace('0', boob)
+    out = out.replace("o", boob).replace("O", boob).replace("0", boob)
     if out == text.strip():
-        return "Sorry I couldn't turn anything in '{}' into boobs for you.".format(out)
+        return (
+            "Sorry I couldn't turn anything in '{}' into boobs for you.".format(
+                out
+            )
+        )
     return out
 
 
@@ -113,11 +119,13 @@ def awesome(text, is_nick_valid):
     """<nick> - Returns a link to show <nick> how awesome they are.
     See https://github.com/sebastianbarfurth/is-awesome.cool
     """
-    target = text.split(' ')[0]
+    target = text.split(" ")[0]
     if not is_nick_valid(target):
         return "Sorry I can't tell {} how awesome they are.".format(target)
-    link = 'http://{}.is-awesome.cool/'.format(target)
-    return "{}: I am blown away by your recent awesome action(s). Please read \x02{}\x02".format(target, link)
+    link = "http://{}.is-awesome.cool/".format(target)
+    return "{}: I am blown away by your recent awesome action(s). Please read \x02{}\x02".format(
+        target, link
+    )
 
 
 @hook.command(autohelp=False)
@@ -132,7 +140,7 @@ def triforce(message):
 @hook.command("kero", "kerowhack")
 def kero(text):
     """<text> - Returns the text input the way kerouac5 would say it."""
-    keror = random.choice(joke_lines['kero']).upper()
+    keror = random.choice(joke_lines["kero"]).upper()
     if keror == "???? WTF IS":
         out = keror + " " + text.upper()
     else:
@@ -143,7 +151,7 @@ def kero(text):
 @hook.command(autohelp=False)
 def lawyerjoke(message):
     """- Returns a lawyer joke, so lawyers know how much we hate them."""
-    message(random.choice(joke_lines['lawyerjoke']))
+    message(random.choice(joke_lines["lawyerjoke"]))
 
 
 @hook.command(autohelp=False)
diff --git a/plugins/karma.py b/plugins/karma.py
index 6bfb21d8..e1f890fb 100644
--- a/plugins/karma.py
+++ b/plugins/karma.py
@@ -3,29 +3,41 @@
 from collections import defaultdict
 
 import sqlalchemy
-from sqlalchemy import Table, String, Column, Integer, PrimaryKeyConstraint, select, and_
+from sqlalchemy import (
+    Column,
+    Integer,
+    PrimaryKeyConstraint,
+    String,
+    Table,
+    and_,
+    select,
+)
 
 from cloudbot import hook
 from cloudbot.util import database
 
-karmaplus_re = re.compile(r'^.*\+\+$')
-karmaminus_re = re.compile('^.*--$')
+karmaplus_re = re.compile(r"^.*\+\+$")
+karmaminus_re = re.compile("^.*--$")
 
 karma_table = Table(
-    'karma',
+    "karma",
     database.metadata,
-    Column('name', String),
-    Column('chan', String),
-    Column('thing', String),
-    Column('score', Integer),
-    PrimaryKeyConstraint('name', 'chan', 'thing')
+    Column("name", String),
+    Column("chan", String),
+    Column("thing", String),
+    Column("score", Integer),
+    PrimaryKeyConstraint("name", "chan", "thing"),
 )
 
 
 @hook.on_start
 def remove_non_channel_points(db):
     """Temporary on_start hook to remove non-channel points"""
-    db.execute(karma_table.delete().where(sqlalchemy.not_(karma_table.c.chan.startswith('#'))))
+    db.execute(
+        karma_table.delete().where(
+            sqlalchemy.not_(karma_table.c.chan.startswith("#"))
+        )
+    )
     db.commit()
 
 
@@ -35,13 +47,19 @@ def update_score(nick, chan, thing, score, db):
         return
 
     thing = thing.strip()
-    clause = and_(karma_table.c.name == nick, karma_table.c.chan == chan, karma_table.c.thing == thing.lower())
+    clause = and_(
+        karma_table.c.name == nick,
+        karma_table.c.chan == chan,
+        karma_table.c.thing == thing.lower(),
+    )
     karma = db.execute(select([karma_table.c.score]).where(clause)).fetchone()
     if karma:
         score += int(karma[0])
         query = karma_table.update().values(score=score).where(clause)
     else:
-        query = karma_table.insert().values(name=nick, chan=chan, thing=thing.lower(), score=score)
+        query = karma_table.insert().values(
+            name=nick, chan=chan, thing=thing.lower(), score=score
+        )
 
     db.execute(query)
     db.commit()
@@ -56,7 +74,7 @@ def addpoint(text, nick, chan, db):
 @hook.regex(karmaplus_re)
 def re_addpt(match, nick, chan, db, notice):
     """no useful help txt"""
-    thing = match.group().split('++')[0]
+    thing = match.group().split("++")[0]
     if thing:
         addpoint(thing, nick, chan, db)
     else:
@@ -73,8 +91,16 @@ def rmpoint(text, nick, chan, db):
 def pluspts(nick, chan, db):
     """- prints the things you have liked and their scores"""
     output = ""
-    clause = and_(karma_table.c.name == nick, karma_table.c.chan == chan, karma_table.c.score >= 0)
-    query = select([karma_table.c.thing, karma_table.c.score]).where(clause).order_by(karma_table.c.score.desc())
+    clause = and_(
+        karma_table.c.name == nick,
+        karma_table.c.chan == chan,
+        karma_table.c.score >= 0,
+    )
+    query = (
+        select([karma_table.c.thing, karma_table.c.score])
+        .where(clause)
+        .order_by(karma_table.c.score.desc())
+    )
     likes = db.execute(query).fetchall()
 
     for like in likes:
@@ -87,8 +113,16 @@ def pluspts(nick, chan, db):
 def minuspts(nick, chan, db):
     """- prints the things you have disliked and their scores"""
     output = ""
-    clause = and_(karma_table.c.name == nick, karma_table.c.chan == chan, karma_table.c.score <= 0)
-    query = select([karma_table.c.thing, karma_table.c.score]).where(clause).order_by(karma_table.c.score)
+    clause = and_(
+        karma_table.c.name == nick,
+        karma_table.c.chan == chan,
+        karma_table.c.score <= 0,
+    )
+    query = (
+        select([karma_table.c.thing, karma_table.c.score])
+        .where(clause)
+        .order_by(karma_table.c.score)
+    )
     likes = db.execute(query).fetchall()
 
     for like in likes:
@@ -100,7 +134,7 @@ def minuspts(nick, chan, db):
 @hook.regex(karmaminus_re)
 def re_rmpt(match, nick, chan, db, notice):
     """no useful help txt"""
-    thing = match.group().split('--')[0]
+    thing = match.group().split("--")[0]
     if thing:
         rmpoint(thing, nick, chan, db)
     else:
@@ -114,11 +148,16 @@ def points_cmd(text, chan, db):
     thing = ""
     if text.endswith(("-global", " global")):
         thing = text[:-7].strip()
-        query = select([karma_table.c.score]).where(karma_table.c.thing == thing.lower())
+        query = select([karma_table.c.score]).where(
+            karma_table.c.thing == thing.lower()
+        )
     else:
         text = text.strip()
-        query = select([karma_table.c.score]).where(karma_table.c.thing == text.lower()).where(
-            karma_table.c.chan == chan)
+        query = (
+            select([karma_table.c.score])
+            .where(karma_table.c.thing == text.lower())
+            .where(karma_table.c.chan == chan)
+        )
 
     karma = db.execute(query).fetchall()
     if karma:
@@ -131,20 +170,27 @@ def points_cmd(text, chan, db):
                 pos += int(k[0])
             score += int(k[0])
         if thing:
-            return "{} has a total score of {} (+{}/{}) across all channels I know about.".format(thing, score, pos,
-                                                                                                  neg)
-        return "{} has a total score of {} (+{}/{}) in {}.".format(text, score, pos, neg, chan)
+            return "{} has a total score of {} (+{}/{}) across all channels I know about.".format(
+                thing, score, pos, neg
+            )
+        return "{} has a total score of {} (+{}/{}) in {}.".format(
+            text, score, pos, neg, chan
+        )
 
     return "I couldn't find {} in the database.".format(text)
 
 
 def parse_lookup(text, db, chan, name):
-    if text in ('global', '-global'):
-        items = db.execute(select([karma_table.c.thing, karma_table.c.score])).fetchall()
+    if text in ("global", "-global"):
+        items = db.execute(
+            select([karma_table.c.thing, karma_table.c.score])
+        ).fetchall()
         out = "The {{}} most {} things in all channels are: ".format(name)
     else:
         items = db.execute(
-            select([karma_table.c.thing, karma_table.c.score]).where(karma_table.c.chan == chan)
+            select([karma_table.c.thing, karma_table.c.score]).where(
+                karma_table.c.chan == chan
+            )
         ).fetchall()
         out = "The {{}} most {} things in {{}} are: ".format(name)
 
@@ -153,7 +199,7 @@ def parse_lookup(text, db, chan, name):
 
 def do_list(text, db, chan, loved=True):
     counts = defaultdict(int)
-    out, items = parse_lookup(text, db, chan, 'loved' if loved else 'hated')
+    out, items = parse_lookup(text, db, chan, "loved" if loved else "hated")
     if items:
         for item in items:
             thing = item[0]
@@ -162,9 +208,8 @@ def do_list(text, db, chan, loved=True):
 
         scores = counts.items()
         sorts = sorted(scores, key=operator.itemgetter(1), reverse=loved)[:10]
-        out = out.format(len(sorts), chan) + ' \u2022 '.join(
-            "{} with {} points".format(thing[0], thing[1])
-            for thing in sorts
+        out = out.format(len(sorts), chan) + " \u2022 ".join(
+            "{} with {} points".format(thing[0], thing[1]) for thing in sorts
         )
         return out
 
diff --git a/plugins/kenm.py b/plugins/kenm.py
index fff3309e..77ff9b2c 100644
--- a/plugins/kenm.py
+++ b/plugins/kenm.py
@@ -1,10 +1,11 @@
 import codecs
 import os
 import random
+from typing import List
 
 from cloudbot import hook
 
-kenm_data = []
+kenm_data: List[str] = []
 
 
 @hook.on_start()
@@ -13,8 +14,12 @@ def load_kenm(bot):
     :type bot: cloudbot.bot.Cloudbot
     """
     kenm_data.clear()
-    with codecs.open(os.path.join(bot.data_dir, "kenm.txt"), encoding="utf-8") as f:
-        kenm_data.extend(line.strip() for line in f.readlines() if not line.startswith("//"))
+    with codecs.open(
+        os.path.join(bot.data_dir, "kenm.txt"), encoding="utf-8"
+    ) as f:
+        kenm_data.extend(
+            line.strip() for line in f.readlines() if not line.startswith("//")
+        )
 
 
 @hook.command("kenm", autohelp=False)
diff --git a/plugins/lenny.py b/plugins/lenny.py
index 3513c6bc..f5a3000f 100644
--- a/plugins/lenny.py
+++ b/plugins/lenny.py
@@ -1,27 +1,28 @@
 import json
 import random
 from pathlib import Path
+from typing import Dict, List
 
 from cloudbot import hook
 
-lenny_data = {}
+lenny_data: Dict[str, List[str]] = {}
 
 
 @hook.on_start
 def load_faces(bot):
     lenny_data.clear()
     data_file = Path(bot.data_dir) / "lenny.json"
-    with data_file.open(encoding='utf-8') as f:
+    with data_file.open(encoding="utf-8") as f:
         lenny_data.update(json.load(f))
 
 
 @hook.command(autohelp=False)
 def lenny(message):
     """- why the shit not lennyface"""
-    message(random.choice(lenny_data['lenny']))
+    message(random.choice(lenny_data["lenny"]))
 
 
 @hook.command(autohelp=False)
 def flenny(message):
     """- flenny is watching."""
-    message(random.choice(lenny_data['flenny']))
+    message(random.choice(lenny_data["flenny"]))
diff --git a/plugins/librefm.py b/plugins/librefm.py
index b6a8f950..e7d1f3bb 100644
--- a/plugins/librefm.py
+++ b/plugins/librefm.py
@@ -1,10 +1,11 @@
 from datetime import datetime
+from typing import List, Tuple
 
 import requests
-from sqlalchemy import Table, Column, PrimaryKeyConstraint, String
+from sqlalchemy import Column, PrimaryKeyConstraint, String, Table
 
 from cloudbot import hook
-from cloudbot.util import timeformat, web, database
+from cloudbot.util import database, timeformat, web
 
 api_url = "https://libre.fm/2.0/?format=json"
 
@@ -14,12 +15,12 @@
 table = Table(
     "librefm",
     database.metadata,
-    Column('nick', String),
-    Column('acc', String),
-    PrimaryKeyConstraint('nick')
+    Column("nick", String),
+    Column("acc", String),
+    PrimaryKeyConstraint("nick"),
 )
 
-last_cache = []
+last_cache: List[Tuple[str, str]] = []
 
 
 def api_request(method, **params):
@@ -75,40 +76,49 @@ def librefm(text, nick, db, event):
             event.notice_doc()
             return
 
-    response, err = api_request('user.getrecenttracks', user=user, limit=1)
+    response, err = api_request("user.getrecenttracks", user=user, limit=1)
     if err:
         return err
 
-    if 'error' in response:
+    if "error" in response:
         # return "libre.fm Error: {}.".format(response["message"])
-        return "libre.fm Error: {} Code: {}.".format(response["error"]["#text"], response["error"]["code"])
+        return "libre.fm Error: {} Code: {}.".format(
+            response["error"]["#text"], response["error"]["code"]
+        )
 
-    if 'track' not in response['recenttracks'] or response['recenttracks']['track']:
-        return "No recent tracks for user \"{}\" found.".format(user)
+    if (
+        "track" not in response["recenttracks"]
+        or response["recenttracks"]["track"]
+    ):
+        return 'No recent tracks for user "{}" found.'.format(user)
 
     tracks = response["recenttracks"]["track"]
 
     if isinstance(tracks, list):
         track = tracks[0]
 
-        if "@attr" in track and "nowplaying" in track["@attr"] and track["@attr"]["nowplaying"] == "true":
+        if (
+            "@attr" in track
+            and "nowplaying" in track["@attr"]
+            and track["@attr"]["nowplaying"] == "true"
+        ):
             # if the user is listening to something, the first track (a dict) of the
             # tracks list will contain an item with the "@attr" key.
             # this item will will contain another item with the "nowplaying" key
             # which value will be "true"
-            status = 'is listening to'
-            ending = '.'
+            status = "is listening to"
+            ending = "."
         else:
             return
 
     elif isinstance(tracks, dict):
         track = tracks
         # otherwise, the user is not listening to anything right now
-        status = 'last listened to'
+        status = "last listened to"
         # lets see how long ago they listened to it
         time_listened = datetime.fromtimestamp(int(track["date"]["uts"]))
         time_since = timeformat.time_since(time_listened)
-        ending = ' ({} ago)'.format(time_since)
+        ending = " ({} ago)".format(time_since)
 
     else:
         return "error: could not parse track listing"
@@ -133,7 +143,9 @@ def librefm(text, nick, db, event):
     out += ending
 
     if text and not dontsave:
-        res = db.execute(table.update().values(acc=user).where(table.c.nick == nick.lower()))
+        res = db.execute(
+            table.update().values(acc=user).where(table.c.nick == nick.lower())
+        )
         if res.rowcount <= 0:
             db.execute(table.insert().values(nick=nick.lower(), acc=user))
 
@@ -143,27 +155,27 @@ def librefm(text, nick, db, event):
 
 
 def getartisttags(artist):
-    tags, err = api_request('artist.getTopTags', artist=artist)
+    tags, err = api_request("artist.getTopTags", artist=artist)
     if err:
         return "error returning tags ({})".format(err)
 
     try:
-        tag = tags['toptags']['tag']
+        tag = tags["toptags"]["tag"]
     except LookupError:
-        return 'no tags'
+        return "no tags"
 
     if isinstance(tag, dict):
-        tag_list = tag['name']
+        tag_list = tag["name"]
     elif isinstance(tag, list):
         tag_list = []
         for item in tag:
-            tag_list.append(item['name'])
+            tag_list.append(item["name"])
     else:
         return "error returning tags"
 
     if isinstance(tag_list, list):
         tag_list = tag_list[0:4]
-        return ', '.join(tag_list)
+        return ", ".join(tag_list)
 
     return tag_list
 
@@ -181,10 +193,10 @@ def displaybandinfo(text, bot):
     if err:
         return err
 
-    if 'error' in artist:
-        return 'No such artist.'
+    if "error" in artist:
+        return "No such artist."
 
-    a = artist['artist']
+    a = artist["artist"]
     summary = a["bio"]["summary"]
     tags = getartisttags(a)
 
@@ -198,12 +210,12 @@ def displaybandinfo(text, bot):
     return out
 
 
-def getartistinfo(artist, user=''):
+def getartistinfo(artist, user=""):
     params = {}
     if user:
-        params['username'] = user
+        params["username"] = user
 
-    return api_request('artist.getInfo', artist=artist, autocorrect=1, **params)
+    return api_request("artist.getInfo", artist=artist, autocorrect=1, **params)
 
 
 @hook.command("librecompare", "librelc")
@@ -212,7 +224,9 @@ def librefmcompare():
     return unsupported_msg
 
 
-@hook.command("libretoptrack", "libretoptracks", "libretop", "librett", autohelp=False)
+@hook.command(
+    "libretoptrack", "libretoptracks", "libretop", "librett", autohelp=False
+)
 def toptrack(text, nick):
     """[username] - Grabs a list of the top tracks for a libre.fm username"""
     if text:
@@ -225,11 +239,11 @@ def toptrack(text, nick):
     if not username:
         return "No librefm username specified and no librefm username is set in the database."
 
-    data, err = api_request('user.gettoptracks', user=username, limit=5)
+    data, err = api_request("user.gettoptracks", user=username, limit=5)
     if err:
         return err
 
-    if 'error' in data:
+    if "error" in data:
         return "Error: {}.".format(data["message"])
 
     out = "{}'s favorite songs: ".format(username)
@@ -237,7 +251,9 @@ def toptrack(text, nick):
         track_name = data["toptracks"]["track"][r]["name"]
         artist_name = data["toptracks"]["track"][r]["artist"]["name"]
         play_count = data["toptracks"]["track"][r]["playcount"]
-        out += "{} by {} listened to {:,} times. ".format(track_name, artist_name, int(play_count))
+        out += "{} by {} listened to {:,} times. ".format(
+            track_name, artist_name, int(play_count)
+        )
     return out
 
 
@@ -255,18 +271,20 @@ def libretopartists(text, nick):
     if not username:
         return "No libre.fm username specified and no libre.fm username is set in the database."
 
-    data, err = api_request('user.gettopartists', user=username, limit=5)
+    data, err = api_request("user.gettopartists", user=username, limit=5)
     if err:
         return err
 
-    if 'error' in data:
+    if "error" in data:
         return "Error: {}.".format(data["message"])
 
     out = "{}'s favorite artists: ".format(username)
     for r in range(5):
         artist_name = data["topartists"]["artist"][r]["name"]
         play_count = data["topartists"]["artist"][r]["playcount"]
-        out += "{} listened to {:,} times. ".format(artist_name, int(play_count))
+        out += "{} listened to {:,} times. ".format(
+            artist_name, int(play_count)
+        )
     return out
 
 
@@ -274,21 +292,21 @@ def libretopartists(text, nick):
 def topweek(text, nick):
     """[username] - Grabs a list of the top artists in the last week for a libre.fm username. You can set your
     librefm username with .l username"""
-    return topartists(text, nick, '7day')
+    return topartists(text, nick, "7day")
 
 
 @hook.command("libreltm", "libretopmonth", autohelp=False)
 def topmonth(text, nick):
     """[username] - Grabs a list of the top artists in the last month for a libre.fm username. You can set your
     librefm username with .l username"""
-    return topartists(text, nick, '1month')
+    return topartists(text, nick, "1month")
 
 
 @hook.command("librelibrelta", "libretopall", autohelp=False)
 def topall(text, nick):
     """[username] - Grabs a list of the top artists in the last year for a libre.fm username. You can set your
     librefm username with .l username"""
-    return topartists(text, nick, '12month')
+    return topartists(text, nick, "12month")
 
 
 def topartists(text, nick, period):
@@ -303,13 +321,13 @@ def topartists(text, nick, period):
         return "No librefm username specified and no librefm username is set in the database."
 
     data, err = api_request(
-        'user.gettopartists', user=username, period=period, limit=10
+        "user.gettopartists", user=username, period=period, limit=10
     )
 
     if err:
         return err
 
-    if 'error' in data:
+    if "error" in data:
         return data
         # return "Error: {}.".format(data["message"])
 
diff --git a/plugins/link_announcer.py b/plugins/link_announcer.py
index 29754c49..55e67f72 100644
--- a/plugins/link_announcer.py
+++ b/plugins/link_announcer.py
@@ -3,7 +3,7 @@
 import requests
 
 from cloudbot import hook
-from cloudbot.hook import Priority, Action
+from cloudbot.hook import Action, Priority
 from cloudbot.util.http import parse_soup
 
 MAX_TITLE = 100
@@ -44,35 +44,47 @@ def no_parens(pattern):
 
     (?::\d*)?  # port
 
-    (?:/(?:""" + no_parens(PATH_SEG_CHARS) + r""")*(?<![.,?!\]]))*  # Path segment
+    (?:/(?:"""
+    + no_parens(PATH_SEG_CHARS)
+    + r""")*(?<![.,?!\]]))*  # Path segment
 
-    (?:\?(?:""" + no_parens(QUERY_CHARS) + r""")*(?<![.,!\]]))?  # Query
+    (?:\?(?:"""
+    + no_parens(QUERY_CHARS)
+    + r""")*(?<![.,!\]]))?  # Query
 
-    (?:\#(?:""" + no_parens(FRAG_CHARS) + r""")*(?<![.,?!\]]))?  # Fragment
+    (?:\#(?:"""
+    + no_parens(FRAG_CHARS)
+    + r""")*(?<![.,?!\]]))?  # Fragment
     """,
-    re.IGNORECASE | re.VERBOSE
+    re.IGNORECASE | re.VERBOSE,
 )
 
 HEADERS = {
-    'Accept-Language': 'en-US,en;q=0.5',
-    'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) '
-                  'Chrome/53.0.2785.116 Safari/537.36'
+    "Accept-Language": "en-US,en;q=0.5",
+    "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) "
+    "Chrome/53.0.2785.116 Safari/537.36",
 }
 
 MAX_RECV = 1000000
 
 
 def get_encoding(soup):
-    meta_charset = soup.find('meta', charset=True)
+    meta_charset = soup.find("meta", charset=True)
 
     if meta_charset:
-        return meta_charset['charset']
+        return meta_charset["charset"]
 
     meta_content_type = soup.find(
-        'meta', {'http-equiv': lambda t: t and t.lower() == 'content-type', 'content': True}
+        "meta",
+        {
+            "http-equiv": lambda t: t and t.lower() == "content-type",
+            "content": True,
+        },
     )
     if meta_content_type:
-        return requests.utils.get_encoding_from_headers({'content-type': meta_content_type['content']})
+        return requests.utils.get_encoding_from_headers(
+            {"content-type": meta_content_type["content"]}
+        )
 
     return None
 
@@ -89,10 +101,14 @@ def parse_content(content, encoding=None):
     return html
 
 
-@hook.regex(url_re, priority=Priority.LOW, action=Action.HALTTYPE, only_no_match=True)
+@hook.regex(
+    url_re, priority=Priority.LOW, action=Action.HALTTYPE, only_no_match=True
+)
 def print_url_title(message, match, logger):
     try:
-        with requests.get(match.group(), headers=HEADERS, stream=True, timeout=3) as r:
+        with requests.get(
+            match.group(), headers=HEADERS, stream=True, timeout=3
+        ) as r:
             if not r.encoding or not r.ok:
                 return
 
diff --git a/plugins/linux.py b/plugins/linux.py
index 725d805f..e429d9db 100644
--- a/plugins/linux.py
+++ b/plugins/linux.py
@@ -11,9 +11,11 @@ def kernel(reply):
     r = requests.get("https://www.kernel.org/finger_banner")
     r.raise_for_status()
     contents = r.text
-    contents = re.sub(r'The latest(\s*)', '', contents)
-    contents = re.sub(r'version of the Linux kernel is:(\s*)', '- ', contents)
+    contents = re.sub(r"The latest(\s*)", "", contents)
+    contents = re.sub(r"version of the Linux kernel is:(\s*)", "- ", contents)
     lines = contents.split("\n")
 
-    message = "Linux kernel versions: {}".format(", ".join(line for line in lines[:-1]))
+    message = "Linux kernel versions: {}".format(
+        ", ".join(line for line in lines[:-1])
+    )
     reply(message)
diff --git a/plugins/metars.py b/plugins/metars.py
index bfb44565..248380ab 100644
--- a/plugins/metars.py
+++ b/plugins/metars.py
@@ -7,7 +7,7 @@
 
 
 def lookup(text, url):
-    station = text.split(' ')[0].upper()
+    station = text.split(" ")[0].upper()
     if len(station) != 4:
         return "please specify a valid station code see http://weather.rap.ucar.edu/surface/stations.txt for a list."
 
@@ -16,8 +16,8 @@ def lookup(text, url):
         return "Station not found"
 
     request.raise_for_status()
-    r = request.json()['reports'][0]
-    out = r['name'] + ": " + r['raw_text']
+    r = request.json()["reports"][0]
+    out = r["name"] + ": " + r["raw_text"]
     return out
 
 
diff --git a/plugins/minecraft_status.py b/plugins/minecraft_status.py
index cc750673..addeeee4 100644
--- a/plugins/minecraft_status.py
+++ b/plugins/minecraft_status.py
@@ -12,12 +12,20 @@ def mcstatus(reply):
     try:
         request = requests.get("http://status.mojang.com/check")
         request.raise_for_status()
-    except (requests.exceptions.HTTPError, requests.exceptions.ConnectionError) as e:
+    except (
+        requests.exceptions.HTTPError,
+        requests.exceptions.ConnectionError,
+    ) as e:
         reply("Unable to get Minecraft server status: {}".format(e))
         raise
 
     # lets just reformat this data to get in a nice format
-    data = json.loads(request.text.replace("}", "").replace("{", "").replace("]", "}").replace("[", "{"))
+    data = json.loads(
+        request.text.replace("}", "")
+        .replace("{", "")
+        .replace("]", "}")
+        .replace("[", "{")
+    )
     out = []
 
     # use a loop so we don't have to update it if they add more servers
@@ -44,5 +52,6 @@ def mcstatus(reply):
 
     out = " ".join(out)
 
-    return "\x0f" + out.replace(".mojang.com", ".mj") \
-        .replace(".minecraft.net", ".mc")
+    return "\x0f" + out.replace(".mojang.com", ".mj").replace(
+        ".minecraft.net", ".mc"
+    )
diff --git a/plugins/minecraft_user.py b/plugins/minecraft_user.py
index 1b7da7b7..a68c4084 100644
--- a/plugins/minecraft_user.py
+++ b/plugins/minecraft_user.py
@@ -20,16 +20,20 @@ def get_name(user_uuid):
 @hook.command("mcuser", "mcpaid", "haspaid")
 def mcuser(text, bot, reply):
     """<username> - gets information about the Minecraft user <account>"""
-    headers = {'User-Agent': bot.user_agent}
+    headers = {"User-Agent": bot.user_agent}
     text = text.strip()
 
     # check if we are looking up a UUID
-    cleaned = text.replace('-', '')
-    if re.search(r'^[0-9a-f]{32}$', cleaned, re.I):
+    cleaned = text.replace("-", "")
+    if re.search(r"^[0-9a-f]{32}$", cleaned, re.I):
         # we are looking up a UUID, get a name.
         try:
             name = get_name(cleaned)
-        except (requests.exceptions.HTTPError, requests.exceptions.ConnectionError, KeyError) as e:
+        except (
+            requests.exceptions.HTTPError,
+            requests.exceptions.ConnectionError,
+            KeyError,
+        ) as e:
             reply("Could not get username from UUID: {}".format(e))
             raise
     else:
@@ -37,9 +41,14 @@ def mcuser(text, bot, reply):
 
     # get user data from fishbans
     try:
-        request = requests.get(HIST_API.format(requests.utils.quote(name)), headers=headers)
+        request = requests.get(
+            HIST_API.format(requests.utils.quote(name)), headers=headers
+        )
         request.raise_for_status()
-    except (requests.exceptions.HTTPError, requests.exceptions.ConnectionError) as e:
+    except (
+        requests.exceptions.HTTPError,
+        requests.exceptions.ConnectionError,
+    ) as e:
         reply("Could not get profile status: {}".format(e))
         raise
 
@@ -50,14 +59,18 @@ def mcuser(text, bot, reply):
         return "Could not parse profile status"
 
     # check for errors from fishbans and handle them
-    if not results['success']:
-        if results['error'] == "User is not premium.":
-            return "The account \x02{}\x02 is not premium or does not exist.".format(text)
+    if not results["success"]:
+        if results["error"] == "User is not premium.":
+            return "The account \x02{}\x02 is not premium or does not exist.".format(
+                text
+            )
 
-        return results['error']
+        return results["error"]
 
-    username = results['data']['username']
-    uid = uuid.UUID(results['data']['uuid'])
+    username = results["data"]["username"]
+    uid = uuid.UUID(results["data"]["uuid"])
 
-    return 'The account \x02{}\x02 ({}) exists. It is a \x02paid\x02' \
-           ' account.'.format(username, uid)
+    return (
+        "The account \x02{}\x02 ({}) exists. It is a \x02paid\x02"
+        " account.".format(username, uid)
+    )
diff --git a/plugins/minecraft_wiki.py b/plugins/minecraft_wiki.py
index edc239b7..88799f45 100644
--- a/plugins/minecraft_wiki.py
+++ b/plugins/minecraft_wiki.py
@@ -15,10 +15,13 @@ def mcwiki(text, reply):
     """<phrase> - gets the first paragraph of the Minecraft Wiki article on <phrase>"""
 
     try:
-        request = requests.get(api_url, params={'search': text.strip()})
+        request = requests.get(api_url, params={"search": text.strip()})
         request.raise_for_status()
         j = request.json()
-    except (requests.exceptions.HTTPError, requests.exceptions.ConnectionError) as e:
+    except (
+        requests.exceptions.HTTPError,
+        requests.exceptions.ConnectionError,
+    ) as e:
         reply("Error fetching search results: {}".format(e))
         raise
     except ValueError as e:
@@ -34,17 +37,20 @@ def mcwiki(text, reply):
     items = [item for item in j[1] if "/" not in item]
 
     if items:
-        article_name = items[0].replace(' ', '_').encode('utf8')
+        article_name = items[0].replace(" ", "_").encode("utf8")
     else:
         # there are no items without /, just return a / one
-        article_name = j[1][0].replace(' ', '_').encode('utf8')
+        article_name = j[1][0].replace(" ", "_").encode("utf8")
 
-    url = mc_url + requests.utils.quote(article_name, '')
+    url = mc_url + requests.utils.quote(article_name, "")
 
     try:
         request_ = requests.get(url)
         request_.raise_for_status()
-    except (requests.exceptions.HTTPError, requests.exceptions.ConnectionError) as e:
+    except (
+        requests.exceptions.HTTPError,
+        requests.exceptions.ConnectionError,
+    ) as e:
         reply("Error fetching wiki page: {}".format(e))
         raise
 
@@ -53,7 +59,7 @@ def mcwiki(text, reply):
     for p in page.xpath('//div[@class="mw-content-ltr"]/p'):
         if p.text_content():
             summary = " ".join(p.text_content().splitlines())
-            summary = re.sub(r'\[\d+\]', '', summary)
+            summary = re.sub(r"\[\d+\]", "", summary)
             summary = formatting.truncate(summary, 200)
             return "{} :: {}".format(summary, url)
 
diff --git a/plugins/mock.py b/plugins/mock.py
index a96636d8..882979bd 100644
--- a/plugins/mock.py
+++ b/plugins/mock.py
@@ -19,10 +19,12 @@ def mock(text, chan, conn, message):
 
     if line.startswith("\x01ACTION"):
         fmt = "* {nick} {msg}"
-        line = line[8:].strip(' \x01')
+        line = line[8:].strip(" \x01")
     else:
         fmt = "<{nick}> {msg}"
 
     # Return the message in aLtErNaTiNg cApS
-    line = "".join(c.upper() if i & 1 else c.lower() for i, c in enumerate(line))
+    line = "".join(
+        c.upper() if i & 1 else c.lower() for i, c in enumerate(line)
+    )
     message(fmt.format(nick=nick, msg=line))
diff --git a/plugins/myfitnesspal.py b/plugins/myfitnesspal.py
index 42e83e65..f1035a8c 100644
--- a/plugins/myfitnesspal.py
+++ b/plugins/myfitnesspal.py
@@ -10,7 +10,7 @@
 scrape_url = "http://www.myfitnesspal.com/food/diary/{}"
 
 
-@hook.command('mfp', 'myfitnesspal')
+@hook.command("mfp", "myfitnesspal")
 def mfp(text, reply):
     """<user> - returns macros from the MyFitnessPal food diary of <user>"""
     request = requests.get(scrape_url.format(text))
@@ -29,29 +29,30 @@ def mfp(text, reply):
     try:
         soup = parse_soup(request.text)
 
-        title = soup.find('h1', {'class': 'main-title'})
+        title = soup.find("h1", {"class": "main-title"})
         if title:
-            if title.text == 'This Food Diary is Private':
+            if title.text == "This Food Diary is Private":
                 return "{}'s food diary is private.".format(text)
-            if title.text == 'This Username is Invalid':
+            if title.text == "This Username is Invalid":
                 return "User {} does not exist.".format(text)
 
         # the output of table depends on the user's MFP profile configuration
         headers = get_headers(soup)
-        totals = get_values(soup, 'total')
-        remaining = get_values(soup, 'alt')
+        totals = get_values(soup, "total")
+        remaining = get_values(soup, "alt")
 
-        for idx, val in enumerate(headers['captions']):
+        for idx, val in enumerate(headers["captions"]):
             kwargs = {
-                'caption': val,
-                'total': totals[idx],
-                'remain': remaining[idx],
-                'units': headers['units'][idx],
-                'pct': math.floor((totals[idx] / remaining[idx]) * 100)
+                "caption": val,
+                "total": totals[idx],
+                "remain": remaining[idx],
+                "units": headers["units"][idx],
+                "pct": math.floor((totals[idx] / remaining[idx]) * 100),
             }
 
-            output += ("{caption}: {total}/{remain}{units} ({pct}%) "
-                       .format(**kwargs))
+            output += "{caption}: {total}/{remain}{units} ({pct}%) ".format(
+                **kwargs
+            )
 
         output += " ({})".format(scrape_url.format(text))
 
@@ -64,35 +65,35 @@ def mfp(text, reply):
 
 def get_headers(soup):
     """get nutrient headers from the soup"""
-    headers = {'captions': [], 'units': []}
+    headers = {"captions": [], "units": []}
 
-    footer = soup.find('tfoot')
-    for cell in footer.findAll('td', {'class': 'nutrient-column'}):
-        div = cell.find('div')
-        headers['units'].append(div.text)
-        headers['captions'].append(div.previous_sibling.strip())
+    footer = soup.find("tfoot")
+    for cell in footer.findAll("td", {"class": "nutrient-column"}):
+        div = cell.find("div")
+        headers["units"].append(div.text)
+        headers["captions"].append(div.previous_sibling.strip())
 
     return headers
 
 
 def get_values(soup, row_class):
     """get values from a specific summary row based on the row class"""
-    locale.setlocale(locale.LC_ALL, 'en_US.UTF-8')  # for number parsing
+    locale.setlocale(locale.LC_ALL, "en_US.UTF-8")  # for number parsing
 
     values = []
 
-    cells = soup.find('tr', {'class': row_class}).find_all('td')
+    cells = soup.find("tr", {"class": row_class}).find_all("td")
 
     for elem in cells[1:]:
         # if there's a child span with class "macro-value", use its value
         # otherwise use the cell text
-        span = elem.find('span', {'class': 'macro-value'})
+        span = elem.find("span", {"class": "macro-value"})
         if span:
             value = span.text
         else:
             value = elem.text
 
-        if value.strip() != '':
+        if value.strip() != "":
             values.append(locale.atoi(value))
 
     return values
diff --git a/plugins/name_generator.py b/plugins/name_generator.py
index 0ba3b789..b38338eb 100644
--- a/plugins/name_generator.py
+++ b/plugins/name_generator.py
@@ -20,8 +20,11 @@
 
 def get_generator(_json):
     data = json.loads(_json)
-    return textgen.TextGenerator(data["templates"],
-                                 data["parts"], default_templates=data["default_templates"])
+    return textgen.TextGenerator(
+        data["templates"],
+        data["parts"],
+        default_templates=data["default_templates"],
+    )
 
 
 @hook.command(autohelp=False)
@@ -37,13 +40,17 @@ def namegen(text, bot, notice):
 
     # get a list of available name generators
     files = os.listdir(os.path.join(bot.data_dir, "name_files"))
-    all_modules = [os.path.splitext(i)[0] for i in files if os.path.splitext(i)[1] == ".json"]
+    all_modules = [
+        os.path.splitext(i)[0]
+        for i in files
+        if os.path.splitext(i)[1] == ".json"
+    ]
     all_modules.sort()
 
     # command to return a list of all available generators
     if inp == "list":
         message = "Available generators: "
-        message += formatting.get_text_list(all_modules, 'and')
+        message += formatting.get_text_list(all_modules, "and")
         notice(message)
         return
 
@@ -58,7 +65,9 @@ def namegen(text, bot, notice):
         return "{} is not a valid name generator.".format(inp)
 
     # load the name generator
-    path = os.path.join(bot.data_dir, "name_files", "{}.json".format(selected_module))
+    path = os.path.join(
+        bot.data_dir, "name_files", "{}.json".format(selected_module)
+    )
 
     with codecs.open(path, encoding="utf-8") as f:
         try:
@@ -70,4 +79,6 @@ def namegen(text, bot, notice):
     name_list = generator.generate_strings(10)
 
     # and finally return the final message :D
-    return "Some names to ponder: {}.".format(formatting.get_text_list(name_list, 'and'))
+    return "Some names to ponder: {}.".format(
+        formatting.get_text_list(name_list, "and")
+    )
diff --git a/plugins/notes.py b/plugins/notes.py
index 31ea9c2d..6f520d86 100644
--- a/plugins/notes.py
+++ b/plugins/notes.py
@@ -1,71 +1,91 @@
 from datetime import datetime
 
 import sqlalchemy
-from sqlalchemy import Table, Column, String, Boolean, Integer, DateTime, PrimaryKeyConstraint, not_
+from sqlalchemy import (
+    Boolean,
+    Column,
+    DateTime,
+    Integer,
+    PrimaryKeyConstraint,
+    String,
+    Table,
+    not_,
+)
 from sqlalchemy.sql import select
 
 from cloudbot import hook
 from cloudbot.util import database
 
 table = Table(
-    'notes',
+    "notes",
     database.metadata,
-    Column('note_id', Integer),
-    Column('connection', String),
-    Column('user', String),
-    Column('text', String),
-    Column('priority', Integer),
-    Column('deleted', Boolean),
-    Column('added', DateTime),
-    PrimaryKeyConstraint('note_id', 'connection', 'user')
+    Column("note_id", Integer),
+    Column("connection", String),
+    Column("user", String),
+    Column("text", String),
+    Column("priority", Integer),
+    Column("deleted", Boolean),
+    Column("added", DateTime),
+    PrimaryKeyConstraint("note_id", "connection", "user"),
 )
 
 
 def read_all_notes(db, server, user, show_deleted=False):
     if show_deleted:
-        query = select([table.c.note_id, table.c.text, table.c.added]) \
-            .where(table.c.connection == server) \
-            .where(table.c.user == user.lower()) \
+        query = (
+            select([table.c.note_id, table.c.text, table.c.added])
+            .where(table.c.connection == server)
+            .where(table.c.user == user.lower())
             .order_by(table.c.added)
+        )
     else:
-        query = select([table.c.note_id, table.c.text, table.c.added]) \
-            .where(table.c.connection == server) \
-            .where(table.c.user == user.lower()) \
-            .where(not_(table.c.deleted)) \
+        query = (
+            select([table.c.note_id, table.c.text, table.c.added])
+            .where(table.c.connection == server)
+            .where(table.c.user == user.lower())
+            .where(not_(table.c.deleted))
             .order_by(table.c.added)
+        )
     return db.execute(query).fetchall()
 
 
 def delete_all_notes(db, server, user):
-    query = table.update() \
-        .where(table.c.connection == server) \
-        .where(table.c.user == user.lower()) \
+    query = (
+        table.update()
+        .where(table.c.connection == server)
+        .where(table.c.user == user.lower())
         .values(deleted=True)
+    )
     db.execute(query)
     db.commit()
 
 
 def read_note(db, server, user, note_id):
-    query = select([table.c.note_id, table.c.text, table.c.added]) \
-        .where(table.c.connection == server) \
-        .where(table.c.user == user.lower()) \
+    query = (
+        select([table.c.note_id, table.c.text, table.c.added])
+        .where(table.c.connection == server)
+        .where(table.c.user == user.lower())
         .where(table.c.note_id == note_id)
+    )
     return db.execute(query).fetchone()
 
 
 def delete_note(db, server, user, note_id):
-    query = table.update() \
-        .where(table.c.connection == server) \
-        .where(table.c.user == user.lower()) \
-        .where(table.c.note_id == note_id) \
+    query = (
+        table.update()
+        .where(table.c.connection == server)
+        .where(table.c.user == user.lower())
+        .where(table.c.note_id == note_id)
         .values(deleted=True)
+    )
     db.execute(query)
     db.commit()
 
 
 def add_note(db, server, user, text):
-    id_query = select([sqlalchemy.sql.expression.func.max(table.c.note_id).label("maxid")]) \
-        .where(table.c.user == user.lower())
+    id_query = select(
+        [sqlalchemy.sql.expression.func.max(table.c.note_id).label("maxid")]
+    ).where(table.c.user == user.lower())
     max_id = db.execute(id_query).scalar()
 
     if max_id is None:
@@ -79,7 +99,7 @@ def add_note(db, server, user, text):
         user=user.lower(),
         text=text,
         deleted=False,
-        added=datetime.today()
+        added=datetime.today(),
     )
     db.execute(query)
     db.commit()
@@ -89,9 +109,11 @@ def format_note(data):
     note_id, note_text, added = data
 
     # format timestamp
-    added_string = added.strftime('%d %b, %Y')
+    added_string = added.strftime("%d %b, %Y")
 
-    return "\x02Note #{}:\x02 {} - \x02{}\x02".format(note_id, note_text, added_string)
+    return "\x02Note #{}:\x02 {} - \x02{}\x02".format(
+        note_id, note_text, added_string
+    )
 
 
 @hook.command("note", "notes", "todo")
@@ -106,7 +128,7 @@ def note(text, conn, nick, db, notice):
         cmd = parts[0].lower()
         args = parts[1:]
 
-    if cmd in ['add', 'new']:
+    if cmd in ["add", "new"]:
         # user is adding a note
         if not args:
             return "No text provided!"
@@ -119,7 +141,7 @@ def note(text, conn, nick, db, notice):
         notice("Note added!")
         return
 
-    if cmd in ['del', 'delete', 'remove']:
+    if cmd in ["del", "delete", "remove"]:
         # user is deleting a note
         if not args:
             return "No note ID provided!"
@@ -138,14 +160,14 @@ def note(text, conn, nick, db, notice):
         notice("Note #{} deleted!".format(note_id))
         return
 
-    if cmd == 'clear':
+    if cmd == "clear":
         # user is deleting all notes
         delete_all_notes(db, conn.name, nick)
 
         notice("All notes deleted!")
         return
 
-    if cmd == 'get':
+    if cmd == "get":
         # user is getting a single note
         if not args:
             return "No note ID provided!"
@@ -162,7 +184,7 @@ def note(text, conn, nick, db, notice):
         notice(text)
         return
 
-    if cmd in ['share', 'show']:
+    if cmd in ["share", "show"]:
         # user is sharing a single note
         if not args:
             return "No note ID provided!"
@@ -178,7 +200,7 @@ def note(text, conn, nick, db, notice):
         text = format_note(n)
         return text
 
-    if cmd == 'list':
+    if cmd == "list":
         # user is getting all notes
         notes = read_all_notes(db, conn.name, nick)
 
@@ -192,7 +214,7 @@ def note(text, conn, nick, db, notice):
             # show the note
             text = format_note(n)
             notice(text)
-    elif cmd == 'listall':
+    elif cmd == "listall":
         # user is getting all notes including deleted ones
         notes = read_all_notes(db, conn.name, nick, show_deleted=True)
 
diff --git a/plugins/octopart.py b/plugins/octopart.py
index 66f080e2..4774245c 100644
--- a/plugins/octopart.py
+++ b/plugins/octopart.py
@@ -28,30 +28,32 @@ def octopart(text, reply):
     if not api_key:
         return "Octopart API key required."
 
-    params = {
-        'apikey': api_key,
-        'q': text,
-        'start': 0,
-        'limit': 1
-    }
+    params = {"apikey": api_key, "q": text, "start": 0, "limit": 1}
 
     try:
         request = requests.get(API_URL, params=params)
         request.raise_for_status()
-    except (requests.exceptions.HTTPError, requests.exceptions.ConnectionError) as e:
+    except (
+        requests.exceptions.HTTPError,
+        requests.exceptions.ConnectionError,
+    ) as e:
         reply("Could not fetch part data: {}".format(e))
         raise
 
     response = request.json()
 
-    if not response['results']:
+    if not response["results"]:
         return "No results."
 
     # get part
-    results = response['results']
+    results = response["results"]
 
     for result in results:
-        part = result['item']
+        part = result["item"]
 
         # print matched part
-        reply("{} - {} - {}".format(part['brand']['name'], part['mpn'], part['octopart_url']))
+        reply(
+            "{} - {} - {}".format(
+                part["brand"]["name"], part["mpn"], part["octopart_url"]
+            )
+        )
diff --git a/plugins/pagecheck.py b/plugins/pagecheck.py
index 9f498523..135dfd95 100644
--- a/plugins/pagecheck.py
+++ b/plugins/pagecheck.py
@@ -15,17 +15,17 @@ def down(text):
     """
 
     if "://" not in text:
-        text = 'http://' + text
+        text = "http://" + text
 
-    text = 'http://' + urllib.parse.urlparse(text).netloc
+    text = "http://" + urllib.parse.urlparse(text).netloc
 
     try:
         r = requests.get(text)
         r.raise_for_status()
     except requests.exceptions.ConnectionError:
-        return '{} seems to be down'.format(text)
+        return "{} seems to be down".format(text)
     else:
-        return '{} seems to be up'.format(text)
+        return "{} seems to be up".format(text)
 
 
 @hook.command()
@@ -42,7 +42,7 @@ def isup(text):
     domain = auth or path
 
     try:
-        response = requests.get('http://isup.me/' + domain)
+        response = requests.get("http://isup.me/" + domain)
         response.raise_for_status()
     except requests.exceptions.ConnectionError:
         return "Failed to get status."
@@ -51,10 +51,12 @@ def isup(text):
 
     soup = parse_soup(response.text)
 
-    content = soup.find('div', id="domain-main-content").text.strip()
+    content = soup.find("div", id="domain-main-content").text.strip()
 
     if "not just you" in content:
-        return "It's not just you. {} looks \x02\x034down\x02\x0f from here!".format(url)
+        return "It's not just you. {} looks \x02\x034down\x02\x0f from here!".format(
+            url
+        )
 
     if "is up" in content:
         return "It's just you. {} is \x02\x033up\x02\x0f.".format(url)
diff --git a/plugins/password.py b/plugins/password.py
index 88803001..64c8a311 100644
--- a/plugins/password.py
+++ b/plugins/password.py
@@ -83,4 +83,8 @@ def word_password(text, notice):
     for _ in range(length):
         words.append(gen.choice(common_words))
 
-    notice("Your password is '{}'. Feel free to remove the spaces when using it.".format(" ".join(words)))
+    notice(
+        "Your password is '{}'. Feel free to remove the spaces when using it.".format(
+            " ".join(words)
+        )
+    )
diff --git a/plugins/pastebins/sprunge.py b/plugins/pastebins/sprunge.py
index 4b54855b..2e9e46f3 100644
--- a/plugins/pastebins/sprunge.py
+++ b/plugins/pastebins/sprunge.py
@@ -2,7 +2,12 @@
 from requests import HTTPError, RequestException
 
 from cloudbot import hook
-from cloudbot.util.web import Pastebin, pastebins, ServiceHTTPError, ServiceError
+from cloudbot.util.web import (
+    Pastebin,
+    ServiceError,
+    ServiceHTTPError,
+    pastebins,
+)
 
 
 class Sprunge(Pastebin):
@@ -17,7 +22,7 @@ def paste(self, data, ext):
             encoded = data
 
         params = {
-            'sprunge': encoded,
+            "sprunge": encoded,
         }
 
         try:
@@ -31,16 +36,16 @@ def paste(self, data, ext):
             raise ServiceError(e.request, "Connection error occurred") from e
 
         if ext:
-            url += '?{}'.format(ext)
+            url += "?{}".format(ext)
 
         return url
 
 
 @hook.on_start()
 def register():
-    pastebins.register('sprunge', Sprunge('http://sprunge.us'))
+    pastebins.register("sprunge", Sprunge("http://sprunge.us"))
 
 
 @hook.on_stop()
 def unregister():
-    pastebins.remove('sprunge')
+    pastebins.remove("sprunge")
diff --git a/plugins/penis.py b/plugins/penis.py
index d166ad34..320ebd99 100644
--- a/plugins/penis.py
+++ b/plugins/penis.py
@@ -2,25 +2,51 @@
 
 from cloudbot import hook
 
-balls = ['(_)_)', '8', 'B', '(___)__)', '(_)(_)', '(@)@)', '3']
+balls = ["(_)_)", "8", "B", "(___)__)", "(_)(_)", "(@)@)", "3"]
 shaft = [
-    '=', '==', '===', '====', '=====', '========',
-    '/////////////////////////', '|||||||||||||',
-    '\u2248\u2248\u2248'
+    "=",
+    "==",
+    "===",
+    "====",
+    "=====",
+    "========",
+    "/////////////////////////",
+    "|||||||||||||",
+    "\u2248\u2248\u2248",
+]
+head = ["D", "Q", ">", "|\u2283" "\u22d1", "\u22d9", "\u22d7"]
+emission = ["~ ~ ~ ~", "~ * ~ &", "", "*~* *~* %"]
+bodypart = [
+    "face",
+    "glasses",
+    "thigh",
+    "tummy",
+    "back",
+    "hiney",
+    "hair",
+    "boobs",
+    "tongue",
 ]
-head = ['D', 'Q', '>', '|\u2283' '\u22d1', '\u22d9', '\u22d7']
-emission = ['~ ~ ~ ~', '~ * ~ &', '', '*~* *~* %']
-bodypart = ['face', 'glasses', 'thigh', 'tummy', 'back', 'hiney', 'hair', 'boobs', 'tongue']
 
 
 @hook.command("penis", "bepis", autohelp=False)
 def penis(text, message):
     """[nick] - much dongs, very ween, add a user nick as an arguement for slightly different 'output'"""
     if not text:
-        message("{}{}{}".format(random.choice(balls), random.choice(shaft), random.choice(head)))
+        message(
+            "{}{}{}".format(
+                random.choice(balls), random.choice(shaft), random.choice(head)
+            )
+        )
     else:
-        person = text.split(' ')[0]
-        message("{}{}{}{} all over {}'s {}".format(
-            random.choice(balls), random.choice(shaft), random.choice(head),
-            random.choice(emission), person, random.choice(bodypart)
-        ))
+        person = text.split(" ")[0]
+        message(
+            "{}{}{}{} all over {}'s {}".format(
+                random.choice(balls),
+                random.choice(shaft),
+                random.choice(head),
+                random.choice(emission),
+                person,
+                random.choice(bodypart),
+            )
+        )
diff --git a/plugins/piglatin.py b/plugins/piglatin.py
index d704759c..9c2f378d 100644
--- a/plugins/piglatin.py
+++ b/plugins/piglatin.py
@@ -15,18 +15,20 @@
 """
 
 import string
+from typing import Dict, List
 
 import nltk
 
 from cloudbot import hook
 
-pronunciations = {}
+pronunciations: Dict[str, List[List[str]]] = {}
 
 
 # Translate functions by J.F. Sebastian
 # <https://stackoverflow.com/questions/22773826/pig-latin-translator>
 
-def translate(word):
+
+def translate(word: str):
     word = word.lower()  # NOTE: ignore Unicode casefold
     i = 0
     # find out whether the word start with a vowel sound using
@@ -63,7 +65,7 @@ def translate_basic(word, vowels="aeiou", start=0):
 
 @hook.on_start()
 def load_nltk():
-    nltk.download('cmudict')
+    nltk.download("cmudict")
 
     pronunciations.clear()
     pronunciations.update(nltk.corpus.cmudict.dict())
diff --git a/plugins/ping.py b/plugins/ping.py
index 3bb37c92..33595a83 100644
--- a/plugins/ping.py
+++ b/plugins/ping.py
@@ -20,14 +20,16 @@
 from cloudbot import hook
 
 unix_ping_regex = re.compile(r"(\d+.\d+)/(\d+.\d+)/(\d+.\d+)/(\d+.\d+)")
-win_ping_regex = re.compile(r"Minimum = (\d+)ms, Maximum = (\d+)ms, Average = (\d+)ms")
+win_ping_regex = re.compile(
+    r"Minimum = (\d+)ms, Maximum = (\d+)ms, Average = (\d+)ms"
+)
 
 
 @hook.command()
 def ping(text, reply):
     """<host> [count] - pings <host> [count] times"""
 
-    args = text.split(' ')
+    args = text.split(" ")
     host = args[0]
 
     # check for a second argument and set the ping count
@@ -57,9 +59,19 @@ def ping(text, reply):
     if os.name == "nt":
         m = re.search(win_ping_regex, pingcmd)
         r = int(m.group(2)) - int(m.group(1))
-        return "min: %sms, max: %sms, average: %sms, range: %sms, count: %s" \
-               % (m.group(1), m.group(2), m.group(3), r, count)
+        return "min: %sms, max: %sms, average: %sms, range: %sms, count: %s" % (
+            m.group(1),
+            m.group(2),
+            m.group(3),
+            r,
+            count,
+        )
 
     m = re.search(unix_ping_regex, pingcmd)
-    return "min: %sms, max: %sms, average: %sms, range: %sms, count: %s" \
-           % (m.group(1), m.group(3), m.group(2), m.group(4), count)
+    return "min: %sms, max: %sms, average: %sms, range: %sms, count: %s" % (
+        m.group(1),
+        m.group(3),
+        m.group(2),
+        m.group(4),
+        count,
+    )
diff --git a/plugins/plpaste.py b/plugins/plpaste.py
index 4fd44f72..eae66400 100644
--- a/plugins/plpaste.py
+++ b/plugins/plpaste.py
@@ -14,9 +14,9 @@ def plpaste(text, bot):
     if text in bot.plugin_manager.commands:
         file_path = bot.plugin_manager.commands[text].plugin.file_path
         with open(file_path) as f:
-            return web.paste(f.read(), ext='py')
-    elif text + ".py" in listdir('plugins/'):
-        with open('plugins/{}.py'.format(text)) as f:
-            return web.paste(f.read(), ext='py')
+            return web.paste(f.read(), ext="py")
+    elif text + ".py" in listdir("plugins/"):
+        with open("plugins/{}.py".format(text)) as f:
+            return web.paste(f.read(), ext="py")
     else:
         return "Could not find specified plugin."
diff --git a/plugins/poll.py b/plugins/poll.py
index c31def47..50e6c3eb 100644
--- a/plugins/poll.py
+++ b/plugins/poll.py
@@ -1,9 +1,10 @@
 from re import findall
+from typing import Dict
 
 from cloudbot import hook
 from cloudbot.util.formatting import get_text_list
 
-polls = {}
+polls: Dict[str, "Poll"] = {}
 
 
 class PollError(Exception):
@@ -73,7 +74,11 @@ def poll(text, conn, nick, chan, message, reply):
             return "You have no active poll to close."
 
         p = polls.get(uid)
-        reply("Your poll has been closed. Final results for \x02\"{}\"\x02:".format(p.question))
+        reply(
+            'Your poll has been closed. Final results for \x02"{}"\x02:'.format(
+                p.question
+            )
+        )
         message(p.format_results())
         del polls[uid]
         return
@@ -81,11 +86,11 @@ def poll(text, conn, nick, chan, message, reply):
     if uid in polls.keys():
         return "You already have an active poll in this channel, you must close it before you can create a new one."
 
-    if ':' in text:
-        question, options = text.strip().split(':')
-        c = findall(r'([^,]+)', options)
+    if ":" in text:
+        question, options = text.strip().split(":")
+        c = findall(r"([^,]+)", options)
         if len(c) == 1:
-            c = findall(r'(\S+)', options)
+            c = findall(r"(\S+)", options)
         options = list(set(x.strip() for x in c))
         _poll = Poll(question, nick, options)
     else:
@@ -95,19 +100,27 @@ def poll(text, conn, nick, chan, message, reply):
     # store poll in list
     polls[uid] = _poll
 
-    option_str = get_text_list([option.title for option in _poll.options.values()], "and")
-    message('Created poll \x02\"{}\"\x02 with the following options: {}'.format(_poll.question, option_str))
+    option_str = get_text_list(
+        [option.title for option in _poll.options.values()], "and"
+    )
+    message(
+        'Created poll \x02"{}"\x02 with the following options: {}'.format(
+            _poll.question, option_str
+        )
+    )
     message("Use .vote {} <option> to vote on this poll!".format(nick.lower()))
 
 
 @hook.command(autohelp=True)
 def vote(text, nick, conn, chan, notice):
     """<poll> <choice> - Vote on a poll; responds on error and silently records on success."""
-    if len(text.split(' ', 1)) == 2:
-        _user, option = text.split(' ', 1)
+    if len(text.split(" ", 1)) == 2:
+        _user, option = text.split(" ", 1)
         uid = ":".join([conn.name, chan, _user]).lower()
     else:
-        return "Invalid input, please use .vote <user> <option> to vote on a poll."
+        return (
+            "Invalid input, please use .vote <user> <option> to vote on a poll."
+        )
 
     if uid not in polls.keys():
         return "Sorry, there is no active poll from that user."
@@ -119,7 +132,7 @@ def vote(text, nick, conn, chan, notice):
     except PollError as e:
         return "{}".format(e)
 
-    notice("Voted \x02\"{}\"\x02 on {}'s poll!".format(o.title, p.creator))
+    notice('Voted \x02"{}"\x02 on {}\'s poll!'.format(o.title, p.creator))
 
 
 @hook.command(autohelp=False)
@@ -136,5 +149,7 @@ def results(text, conn, chan, nick, message, reply):
 
     p = polls.get(uid)
 
-    reply("Results for \x02\"{}\"\x02 by \x02{}\x02:".format(p.question, p.creator))
+    reply(
+        'Results for \x02"{}"\x02 by \x02{}\x02:'.format(p.question, p.creator)
+    )
     message(p.format_results())
diff --git a/plugins/profiling.py b/plugins/profiling.py
index 2bb253b4..91b00417 100644
--- a/plugins/profiling.py
+++ b/plugins/profiling.py
@@ -4,6 +4,9 @@
 import threading
 import traceback
 
+from cloudbot import hook
+from cloudbot.util import web
+
 PYMPLER_ENABLED = False
 
 if PYMPLER_ENABLED:
@@ -21,9 +24,6 @@
 except ImportError:
     objgraph = None
 
-from cloudbot import hook
-from cloudbot.util import web
-
 
 def create_tracker():
     if pympler is None:
@@ -61,8 +61,10 @@ def get_name(thread_id):
 
 def get_thread_dump():
     code = []
-    threads = [(get_name(thread_id), traceback.extract_stack(stack))
-               for thread_id, stack in sys._current_frames().items()]
+    threads = [
+        (get_name(thread_id), traceback.extract_stack(stack))
+        for thread_id, stack in sys._current_frames().items()
+    ]
     for thread_name, stack in threads:
         code.append("# {}".format(thread_name))
         for filename, line_num, name, line in stack:
@@ -70,7 +72,7 @@ def get_thread_dump():
             if line:
                 code.append("    {}".format(line.strip()))
         code.append("")  # new line
-    return web.paste("\n".join(code), ext='txt')
+    return web.paste("\n".join(code), ext="txt")
 
 
 @hook.command("threaddump", autohelp=False, permissions=["botcontrol"])
@@ -125,5 +127,4 @@ def pympler_diff():
     def debug(sig, frame):
         print(get_thread_dump())
 
-
     signal.signal(signal.SIGUSR1, debug)  # Register handler
diff --git a/plugins/quote.py b/plugins/quote.py
index 5a9e2732..d0075587 100644
--- a/plugins/quote.py
+++ b/plugins/quote.py
@@ -2,7 +2,15 @@
 import re
 import time
 
-from sqlalchemy import select, Table, Column, String, PrimaryKeyConstraint, Boolean, not_
+from sqlalchemy import (
+    Boolean,
+    Column,
+    PrimaryKeyConstraint,
+    String,
+    Table,
+    not_,
+    select,
+)
 from sqlalchemy.exc import IntegrityError
 from sqlalchemy.types import REAL
 
@@ -10,30 +18,30 @@
 from cloudbot.util import database
 
 qtable = Table(
-    'new_quote',
+    "new_quote",
     database.metadata,
-    Column('chan', String),
-    Column('nick', String),
-    Column('add_nick', String),
-    Column('msg', String),
-    Column('time', REAL),
-    Column('deleted', Boolean, default=False),
-    PrimaryKeyConstraint('chan', 'nick', 'msg')
+    Column("chan", String),
+    Column("nick", String),
+    Column("add_nick", String),
+    Column("msg", String),
+    Column("time", REAL),
+    Column("deleted", Boolean, default=False),
+    PrimaryKeyConstraint("chan", "nick", "msg"),
 )
 
 
 @hook.on_start()
 def migrate_table(db, logger):
     old_table = Table(
-        'quote',
+        "quote",
         database.metadata,
-        Column('chan', String(25)),
-        Column('nick', String(25)),
-        Column('add_nick', String(25)),
-        Column('msg', String(500)),
-        Column('time', REAL),
-        Column('deleted', String(5), default=0),
-        PrimaryKeyConstraint('chan', 'nick', 'time')
+        Column("chan", String(25)),
+        Column("nick", String(25)),
+        Column("add_nick", String(25)),
+        Column("msg", String(500)),
+        Column("time", REAL),
+        Column("deleted", String(5), default=0),
+        PrimaryKeyConstraint("chan", "nick", "time"),
     )
 
     if not old_table.exists():
@@ -49,16 +57,21 @@ def migrate_table(db, logger):
     qtable.drop(checkfirst=True)
     qtable.create(checkfirst=True)
 
-    db.execute(qtable.insert().values([
-        {
-            'chan': row['chan'],
-            'nick': row['nick'],
-            'add_nick': row['add_nick'],
-            'msg': row['msg'],
-            'time': row['time'],
-            'deleted': row['deleted'] in (1, '1', True)
-        } for row in old_quotes
-    ]))
+    db.execute(
+        qtable.insert().values(
+            [
+                {
+                    "chan": row["chan"],
+                    "nick": row["nick"],
+                    "add_nick": row["add_nick"],
+                    "msg": row["msg"],
+                    "time": row["time"],
+                    "deleted": row["deleted"] in (1, "1", True),
+                }
+                for row in old_quotes
+            ]
+        )
+    )
 
     logger.info("Migrated all quotes")
 
@@ -70,8 +83,9 @@ def migrate_table(db, logger):
 def format_quote(q, num, n_quotes):
     """Returns a formatted string of a quote"""
     _, nick, msg = q
-    return "[{}/{}] <{}\u200B{}> {}".format(num, n_quotes,
-                                            nick[:1], nick[1:], msg)
+    return "[{}/{}] <{}\u200B{}> {}".format(
+        num, n_quotes, nick[:1], nick[1:], msg
+    )
 
 
 def add_quote(db, chan, target, sender, message):
@@ -82,7 +96,7 @@ def add_quote(db, chan, target, sender, message):
             nick=target.lower(),
             add_nick=sender.lower(),
             msg=message,
-            time=time.time()
+            time=time.time(),
         )
         db.execute(query)
         db.commit()
@@ -93,11 +107,13 @@ def add_quote(db, chan, target, sender, message):
 
 def del_quote(db, nick, msg):
     """Deletes a quote from a nick"""
-    query = qtable.update() \
-        .where(qtable.c.chan == 1) \
-        .where(qtable.c.nick == nick.lower()) \
-        .where(qtable.c.msg == msg) \
+    query = (
+        qtable.update()
+        .where(qtable.c.chan == 1)
+        .where(qtable.c.nick == nick.lower())
+        .where(qtable.c.msg == msg)
         .values(deleted=True)
+    )
     db.execute(query)
     db.commit()
 
@@ -111,7 +127,11 @@ def get_quote_num(num, count, name):
     if num and num < 0:  # Count back if possible
         num = count + num + 1 if num + count > -1 else count + 1
     if num and num > count:  # If there are not enough quotes, raise an error
-        raise Exception("I only have {} quote{} for {}.".format(count, ('s', '')[count == 1], name))
+        raise Exception(
+            "I only have {} quote{} for {}.".format(
+                count, ("s", "")[count == 1], name
+            )
+        )
     if num and num == 0:  # If the number is zero, set it to one
         num = 1
     if not num:  # If a number is not given, select a random one
@@ -122,11 +142,13 @@ def get_quote_num(num, count, name):
 def get_quote_by_nick(db, nick, num=False):
     """Returns a formatted quote from a nick, random or selected by number"""
 
-    count_query = select([qtable]) \
-        .where(not_(qtable.c.deleted)) \
-        .where(qtable.c.nick == nick.lower()) \
-        .alias("count") \
+    count_query = (
+        select([qtable])
+        .where(not_(qtable.c.deleted))
+        .where(qtable.c.nick == nick.lower())
+        .alias("count")
         .count()
+    )
     count = db.execute(count_query).fetchall()[0][0]
 
     try:
@@ -134,24 +156,28 @@ def get_quote_by_nick(db, nick, num=False):
     except Exception as error_message:
         return error_message
 
-    query = select([qtable.c.time, qtable.c.nick, qtable.c.msg]) \
-        .where(not_(qtable.c.deleted)) \
-        .where(qtable.c.nick == nick.lower()) \
-        .order_by(qtable.c.time) \
-        .limit(1) \
+    query = (
+        select([qtable.c.time, qtable.c.nick, qtable.c.msg])
+        .where(not_(qtable.c.deleted))
+        .where(qtable.c.nick == nick.lower())
+        .order_by(qtable.c.time)
+        .limit(1)
         .offset((num - 1))
+    )
     data = db.execute(query).fetchall()[0]
     return format_quote(data, num, count)
 
 
 def get_quote_by_nick_chan(db, chan, nick, num=False):
     """Returns a formatted quote from a nick in a channel, random or selected by number"""
-    count_query = select([qtable]) \
-        .where(not_(qtable.c.deleted)) \
-        .where(qtable.c.chan == chan) \
-        .where(qtable.c.nick == nick.lower()) \
-        .alias("count") \
+    count_query = (
+        select([qtable])
+        .where(not_(qtable.c.deleted))
+        .where(qtable.c.chan == chan)
+        .where(qtable.c.nick == nick.lower())
+        .alias("count")
         .count()
+    )
     count = db.execute(count_query).fetchall()[0][0]
 
     try:
@@ -159,24 +185,28 @@ def get_quote_by_nick_chan(db, chan, nick, num=False):
     except Exception as error_message:
         return error_message
 
-    query = select([qtable.c.time, qtable.c.nick, qtable.c.msg]) \
-        .where(not_(qtable.c.deleted)) \
-        .where(qtable.c.chan == chan) \
-        .where(qtable.c.nick == nick.lower()) \
-        .order_by(qtable.c.time) \
-        .limit(1) \
+    query = (
+        select([qtable.c.time, qtable.c.nick, qtable.c.msg])
+        .where(not_(qtable.c.deleted))
+        .where(qtable.c.chan == chan)
+        .where(qtable.c.nick == nick.lower())
+        .order_by(qtable.c.time)
+        .limit(1)
         .offset((num - 1))
+    )
     data = db.execute(query).fetchall()[0]
     return format_quote(data, num, count)
 
 
 def get_quote_by_chan(db, chan, num=False):
     """Returns a formatted quote from a channel, random or selected by number"""
-    count_query = select([qtable]) \
-        .where(not_(qtable.c.deleted)) \
-        .where(qtable.c.chan == chan) \
-        .alias("count") \
+    count_query = (
+        select([qtable])
+        .where(not_(qtable.c.deleted))
+        .where(qtable.c.chan == chan)
+        .alias("count")
         .count()
+    )
     count = db.execute(count_query).fetchall()[0][0]
 
     try:
@@ -184,17 +214,19 @@ def get_quote_by_chan(db, chan, num=False):
     except Exception as error_message:
         return error_message
 
-    query = select([qtable.c.time, qtable.c.nick, qtable.c.msg]) \
-        .where(not_(qtable.c.deleted)) \
-        .where(qtable.c.chan == chan) \
-        .order_by(qtable.c.time) \
-        .limit(1) \
+    query = (
+        select([qtable.c.time, qtable.c.nick, qtable.c.msg])
+        .where(not_(qtable.c.deleted))
+        .where(qtable.c.chan == chan)
+        .order_by(qtable.c.time)
+        .limit(1)
         .offset((num - 1))
+    )
     data = db.execute(query).fetchall()[0]
     return format_quote(data, num, count)
 
 
-@hook.command('q', 'quote')
+@hook.command("q", "quote")
 def quote(text, nick, chan, db, notice, event):
     """[#chan] [nick] [#n] OR add <nick> <message> - gets the [#n]th quote by <nick> (defaulting to random)
     OR adds <message> as a quote for <nick> in the caller's channel"""
@@ -210,7 +242,7 @@ def quote(text, nick, chan, db, notice, event):
 
     if retrieve:
         selected, num = retrieve.groups()
-        by_chan = True if selected.startswith('#') else False
+        by_chan = True if selected.startswith("#") else False
         if by_chan:
             return get_quote_by_chan(db, selected, num)
 
diff --git a/plugins/quran.py b/plugins/quran.py
index 352e5f96..defdbbef 100644
--- a/plugins/quran.py
+++ b/plugins/quran.py
@@ -15,20 +15,24 @@ def statuscheck(status, item):
     return out
 
 
-def smart_truncate(content, length=425, suffix='...\n'):
+def smart_truncate(content, length=425, suffix="...\n"):
     if len(content) <= length:
         return content
 
-    return content[:length].rsplit(' ', 1)[0] + suffix + content[:length].rsplit(' ', 1)[1] + smart_truncate(
-        content[length:])
+    return (
+        content[:length].rsplit(" ", 1)[0]
+        + suffix
+        + content[:length].rsplit(" ", 1)[1]
+        + smart_truncate(content[length:])
+    )
 
 
 @hook.command("quran", "verse", singlethread=True)
 def quran(text, message, reply):
     """<verse> - Prints the specified Qur'anic verse(s) and its/their translation(s)"""
     api_url = "http://quranapi.azurewebsites.net/api/verse/"
-    chapter = text.split(':')[0]
-    verse = text.split(':')[1]
+    chapter = text.split(":")[0]
+    verse = text.split(":")[1]
     params = {"chapter": chapter, "number": verse, "lang": "ar"}
     r = requests.get(api_url, params=params)
     try:
@@ -51,8 +55,8 @@ def quran(text, message, reply):
     data = r.json()
     data2 = r2.json()
     out = "\x02{}\x02: ".format(text)
-    verse = data['Text']
+    verse = data["Text"]
     out += verse
     message(out)
-    translation = smart_truncate(data2['Text'])
+    translation = smart_truncate(data2["Text"])
     return translation
diff --git a/plugins/randomusefulwebsites.py b/plugins/randomusefulwebsites.py
index 9c2021c1..8bc11106 100644
--- a/plugins/randomusefulwebsites.py
+++ b/plugins/randomusefulwebsites.py
@@ -2,11 +2,11 @@
 
 from cloudbot import hook
 
-url = 'http://www.discuvver.com/jump2.php'
-headers = {'Referer': 'http://www.discuvver.com'}
+url = "http://www.discuvver.com/jump2.php"
+headers = {"Referer": "http://www.discuvver.com"}
 
 
-@hook.command('randomusefulsite', 'randomwebsite', 'randomsite', 'discuvver')
+@hook.command("randomusefulsite", "randomwebsite", "randomsite", "discuvver")
 def randomusefulwebsite():
     """- Return a random useful website from discuvver.com"""
     response = requests.head(url, headers=headers, allow_redirects=True)
diff --git a/plugins/reactions.py b/plugins/reactions.py
index f3a184d0..95898181 100644
--- a/plugins/reactions.py
+++ b/plugins/reactions.py
@@ -2,50 +2,71 @@
 import json
 import os
 import random
+from typing import Dict, List
 
 from cloudbot import hook
 
 deal_with_it_phrases = [
-    'Stop complaining, \x02{}\x02, and',
-    'Jesus fuck \x02{}\x02, just',
-    'Looks like \x02{}\x02 needs to',
-    'Ever think that \x02{}\x02 just needs to'
+    "Stop complaining, \x02{}\x02, and",
+    "Jesus fuck \x02{}\x02, just",
+    "Looks like \x02{}\x02 needs to",
+    "Ever think that \x02{}\x02 just needs to",
 ]
-reaction_macros = {}
+reaction_macros: Dict[str, List[str]] = {}
 
 
 @hook.on_start()
 def load_macros(bot):
     reaction_macros.clear()
-    with codecs.open(os.path.join(bot.data_dir, "reaction_macros.json"), encoding="utf-8") as macros:
+    with codecs.open(
+        os.path.join(bot.data_dir, "reaction_macros.json"), encoding="utf-8"
+    ) as macros:
         reaction_macros.update(json.load(macros))
 
 
-@hook.command('dwi', 'dealwithit')
+@hook.command("dwi", "dealwithit")
 def deal_with_it(text, message):
     """<nick> - Tell <nick> in the channel to deal with it. Code located in reactions.py"""
     person_needs_to_deal = text.strip()
     phrase = random.choice(deal_with_it_phrases)
     formated_phrase = phrase.format(person_needs_to_deal)
-    message('{} {}'.format(formated_phrase, random.choice(reaction_macros['deal_with_it_macros'])))
+    message(
+        "{} {}".format(
+            formated_phrase,
+            random.choice(reaction_macros["deal_with_it_macros"]),
+        )
+    )
 
 
-@hook.command('fp', 'facepalm')
+@hook.command("fp", "facepalm")
 def face_palm(text, message):
     """<nick> - Expresses your frustration with <Nick>. Code located in reactions.py"""
     face_palmer = text.strip()
-    message('Dammit {} {}'.format(face_palmer, random.choice(reaction_macros['facepalm_macros'])))
+    message(
+        "Dammit {} {}".format(
+            face_palmer, random.choice(reaction_macros["facepalm_macros"])
+        )
+    )
 
 
-@hook.command('hd', 'headdesk')
+@hook.command("hd", "headdesk")
 def head_desk(text, message):
     """<nick> - Hit your head against the desk becausae of <nick>. Code located in reactions.py"""
     idiot = text.strip()
-    message('{} {}'.format(idiot, random.choice(reaction_macros['head_desk_macros'])))
+    message(
+        "{} {}".format(
+            idiot, random.choice(reaction_macros["head_desk_macros"])
+        )
+    )
 
 
-@hook.command('fetish', 'tmf')
+@hook.command("fetish", "tmf")
 def my_fetish(text, message):
     """<nick> - Did some one just mention what your fetish was? Let <nick> know! Code located in reactions.py"""
     person_to_share_fetish_with = text.strip()
-    message('{} {}'.format(person_to_share_fetish_with, random.choice(reaction_macros['fetish_macros'])))
+    message(
+        "{} {}".format(
+            person_to_share_fetish_with,
+            random.choice(reaction_macros["fetish_macros"]),
+        )
+    )
diff --git a/plugins/reddit_info.py b/plugins/reddit_info.py
index 8bf3ba72..2fd8ffcb 100644
--- a/plugins/reddit_info.py
+++ b/plugins/reddit_info.py
@@ -2,26 +2,29 @@
 import re
 from collections import defaultdict
 from datetime import datetime
+from typing import Dict
 
 import requests
 from requests import HTTPError
 from yarl import URL
 
 from cloudbot import hook
-from cloudbot.util import colors, timeformat, formatting
+from cloudbot.util import colors, formatting, timeformat
 from cloudbot.util.formatting import pluralize_auto
-from cloudbot.util.pager import paginated_list, CommandPager
+from cloudbot.util.pager import CommandPager, paginated_list
 
-search_pages = defaultdict(dict)
-user_re = re.compile(r'^(?:/?(?:u(?:ser)?/)?)?(?P<name>.+?)/?$', re.IGNORECASE)
-sub_re = re.compile(r'^(?:/?(?:r/)?)?(?P<name>.+?)/?$', re.IGNORECASE)
+search_pages: Dict[str, Dict[str, CommandPager]] = defaultdict(dict)
+user_re = re.compile(r"^(?:/?(?:u(?:ser)?/)?)?(?P<name>.+?)/?$", re.IGNORECASE)
+sub_re = re.compile(r"^(?:/?(?:r/)?)?(?P<name>.+?)/?$", re.IGNORECASE)
 
 user_url = "http://reddit.com/user/{}/"
 subreddit_url = "http://reddit.com/r/{}/"
 short_url = "https://redd.it/{}"
 post_url = "https://reddit.com/comments/{}.json"
 # This agent should be unique for your cloudbot instance
-agent = {"User-Agent": "gonzobot a cloudbot (IRCbot) implementation for snoonet.org by /u/bloodygonzo"}
+agent = {
+    "User-Agent": "gonzobot a cloudbot (IRCbot) implementation for snoonet.org by /u/bloodygonzo"
+}
 
 post_re = re.compile(
     r"""
@@ -32,20 +35,20 @@
     )
     /([a-z0-9]+)
     """,
-    re.IGNORECASE | re.VERBOSE
+    re.IGNORECASE | re.VERBOSE,
 )
 
 
 def get_user(text):
     match = user_re.match(text)
     if match:
-        return match.group('name')
+        return match.group("name")
 
 
 def get_sub(text):
     match = sub_re.match(text)
     if match:
-        return match.group('name')
+        return match.group("name")
 
 
 def api_request(url):
@@ -72,8 +75,10 @@ def format_output(item, show_url=False):
     raw_time = datetime.fromtimestamp(int(item["created_utc"]))
     item["timesince"] = timeformat.time_since(raw_time, count=1, simple=True)
 
-    item["comments"] = formatting.pluralize_auto(item["num_comments"], 'comment')
-    item["points"] = formatting.pluralize_auto(item["score"], 'point')
+    item["comments"] = formatting.pluralize_auto(
+        item["num_comments"], "comment"
+    )
+    item["points"] = formatting.pluralize_auto(item["score"], "point")
 
     if item["over_18"]:
         item["warning"] = colors.parse(" $(b, red)NSFW$(clear)")
@@ -172,7 +177,11 @@ def reddit(text, reply):
             item = data[id_num]
         except IndexError:
             length = len(data)
-            return "Invalid post number. Number must be between 1 and {}.".format(length)
+            return (
+                "Invalid post number. Number must be between 1 and {}.".format(
+                    length
+                )
+            )
     else:
         item = random.choice(data)
 
@@ -184,7 +193,9 @@ def moderates(text, chan, conn, reply):
     """<username> - This plugin prints the list of subreddits a user moderates listed in a reddit users profile.
     Private subreddits will not be listed."""
     user = get_user(text)
-    r = requests.get(user_url.format(user) + "moderated_subreddits.json", headers=agent)
+    r = requests.get(
+        user_url.format(user) + "moderated_subreddits.json", headers=agent
+    )
     try:
         r.raise_for_status()
     except HTTPError as e:
@@ -192,9 +203,11 @@ def moderates(text, chan, conn, reply):
         raise
 
     data = r.json()
-    subs = data['data']
-    out = colors.parse("$(b){}$(b) moderates these public subreddits: ".format(user))
-    pager = paginated_list([sub['sr'] for sub in subs], pager_cls=CommandPager)
+    subs = data["data"]
+    out = colors.parse(
+        "$(b){}$(b) moderates these public subreddits: ".format(user)
+    )
+    pager = paginated_list([sub["sr"] for sub in subs], pager_cls=CommandPager)
     search_pages[conn.name][chan.casefold()] = pager
     page = pager.next()
     if len(pager) > 1:
@@ -220,27 +233,33 @@ def get_user_data(page, user, reply):
 def karma(text, reply):
     """<reddituser> - will return the information about the specified reddit username"""
     user = get_user(text)
-    data = get_user_data('about.json', user, reply)
-    data = data['data']
+    data = get_user_data("about.json", user, reply)
+    data = data["data"]
 
     out = "$(b){}$(b) ".format(user)
 
     parts = [
-        "$(b){:,}$(b) link karma and $(b){:,}$(b) comment karma".format(data['link_karma'], data['comment_karma'])
+        "$(b){:,}$(b) link karma and $(b){:,}$(b) comment karma".format(
+            data["link_karma"], data["comment_karma"]
+        )
     ]
 
-    if data['is_gold']:
+    if data["is_gold"]:
         parts.append("has reddit gold")
 
-    if data['is_mod']:
+    if data["is_mod"]:
         parts.append("moderates a subreddit")
 
-    if data['has_verified_email']:
+    if data["has_verified_email"]:
         parts.append("email has been verified")
 
-    parts.append("cake day is {}".format(datetime.fromtimestamp(data['created_utc']).strftime('%B %d')))
+    parts.append(
+        "cake day is {}".format(
+            datetime.fromtimestamp(data["created_utc"]).strftime("%B %d")
+        )
+    )
 
-    account_age = datetime.now() - datetime.fromtimestamp(data['created'])
+    account_age = datetime.now() - datetime.fromtimestamp(data["created"])
     age = account_age.days
     age_unit = "day"
     if age > 365:
@@ -248,23 +267,29 @@ def karma(text, reply):
         age_unit = "year"
 
     parts.append("redditor for {}.".format(pluralize_auto(age, age_unit)))
-    return colors.parse(out + ' | '.join(parts))
+    return colors.parse(out + " | ".join(parts))
 
 
 @hook.command("cakeday", singlethread=True)
 def cake_day(text, reply):
     """<reddituser> - will return the cakeday for the given reddit username."""
     user = get_user(text)
-    data = get_user_data('about.json', user, reply)
+    data = get_user_data("about.json", user, reply)
     out = colors.parse("$(b){}'s$(b) ".format(user))
-    out += "cake day is {}, ".format(datetime.fromtimestamp(data['data']['created_utc']).strftime('%B %d'))
-    account_age = datetime.now() - datetime.fromtimestamp(data['data']['created'])
+    out += "cake day is {}, ".format(
+        datetime.fromtimestamp(data["data"]["created_utc"]).strftime("%B %d")
+    )
+    account_age = datetime.now() - datetime.fromtimestamp(
+        data["data"]["created"]
+    )
     age = account_age.days
     age_unit = "day"
     if age > 365:
         age //= 365
         age_unit = "year"
-    out += "they have been a redditor for {}.".format(pluralize_auto(age, age_unit))
+    out += "they have been a redditor for {}.".format(
+        pluralize_auto(age, age_unit)
+    )
     return out
 
 
@@ -284,7 +309,7 @@ def get_sub_data(url, sub, reply):
     try:
         r.raise_for_status()
     except HTTPError as e:
-        reply(statuscheck(e.response.status_code, 'r/' + sub))
+        reply(statuscheck(e.response.status_code, "r/" + sub))
         raise
 
     return r.json()
@@ -297,11 +322,11 @@ def submods(text, chan, conn, reply):
     url = subreddit_url + "about/moderators.json"
     data = get_sub_data(url, sub, reply)
     moderators = []
-    for mod in data['data']['children']:
-        username = mod['name']
+    for mod in data["data"]["children"]:
+        username = mod["name"]
         # Showing the modtime makes the message too long for larger subs
         # if you want to show this information add modtime.days to out below
-        modtime = datetime.now() - datetime.fromtimestamp(mod['date'])
+        modtime = datetime.now() - datetime.fromtimestamp(mod["date"])
         modtime = time_format(modtime.days)
         moderators.append("{} ({}{})".format(username, modtime[0], modtime[1]))
     pager = paginated_list(moderators, pager_cls=CommandPager)
@@ -322,19 +347,19 @@ def subinfo(text, reply):
     sub = get_sub(text)
     url = subreddit_url + "about.json"
     data = get_sub_data(url, sub, reply)
-    if data['kind'] == "Listing":
+    if data["kind"] == "Listing":
         return "It appears r/{} does not exist.".format(sub)
-    name = data['data']['display_name']
-    title = data['data']['title']
-    nsfw = data['data']['over18']
-    subscribers = data['data']['subscribers']
-    active = data['data']['accounts_active']
-    sub_age = datetime.now() - datetime.fromtimestamp(data['data']['created'])
+    name = data["data"]["display_name"]
+    title = data["data"]["title"]
+    nsfw = data["data"]["over18"]
+    subscribers = data["data"]["subscribers"]
+    active = data["data"]["accounts_active"]
+    sub_age = datetime.now() - datetime.fromtimestamp(data["data"]["created"])
     age, age_unit = time_format(sub_age.days)
-    out = ("/r/$(b){}$(clear) - {} - a community for {}{}, there are {:,} subscribers and {:,} people online "
-           "now.").format(
-        name, title, age, age_unit, subscribers, active
-    )
+    out = (
+        "/r/$(b){}$(clear) - {} - a community for {}{}, there are {:,} subscribers and {:,} people online "
+        "now."
+    ).format(name, title, age, age_unit, subscribers, active)
     if nsfw:
         out += " $(red)NSFW$(clear)"
     return colors.parse(out)
diff --git a/plugins/scene.py b/plugins/scene.py
index 5310cf4b..2b9047a0 100644
--- a/plugins/scene.py
+++ b/plugins/scene.py
@@ -30,7 +30,7 @@ def pre(text, reply):
         request = requests.get("http://orlydb.com/", params={"q": text})
         request.raise_for_status()
     except requests.exceptions.HTTPError as e:
-        reply('Unable to fetch results: {}'.format(e))
+        reply("Unable to fetch results: {}".format(e))
         raise
 
     h = html.fromstring(request.text)
@@ -53,8 +53,10 @@ def pre(text, reply):
 
     size = result.xpath("span[@class='inforight']//text()")
     if size:
-        size = ' - ' + size[0].split()[0]
+        size = " - " + size[0].split()[0]
     else:
-        size = ''
+        size = ""
 
-    return '{} - {}{} - {} ({} ago)'.format(section, name, size, date_string, since)
+    return "{} - {}{} - {} ({} ago)".format(
+        section, name, size, date_string, since
+    )
diff --git a/plugins/seen.py b/plugins/seen.py
index 5b0effef..b5110aec 100644
--- a/plugins/seen.py
+++ b/plugins/seen.py
@@ -1,42 +1,60 @@
 import re
 import time
 
-from sqlalchemy import Column, Float, PrimaryKeyConstraint, String, Table, and_, select
+from sqlalchemy import (
+    Column,
+    Float,
+    PrimaryKeyConstraint,
+    String,
+    Table,
+    and_,
+    select,
+)
 
 from cloudbot import hook
 from cloudbot.event import EventType
 from cloudbot.util import database, timeformat
 
 table = Table(
-    'seen_user',
+    "seen_user",
     database.metadata,
-    Column('name', String),
-    Column('time', Float),
-    Column('quote', String),
-    Column('chan', String),
-    Column('host', String),
-    PrimaryKeyConstraint('name', 'chan')
+    Column("name", String),
+    Column("time", Float),
+    Column("quote", String),
+    Column("chan", String),
+    Column("host", String),
+    PrimaryKeyConstraint("name", "chan"),
 )
 
 
 def track_seen(event, db):
-    """ Tracks messages for the .seen command
+    """Tracks messages for the .seen command
     :type event: cloudbot.event.Event
     :type db: sqlalchemy.orm.Session
     """
     # keep private messages private
     now = time.time()
-    if event.chan[:1] == "#" and not re.findall('^s/.*/.*/$', event.content.lower()):
+    if event.chan[:1] == "#" and not re.findall(
+        "^s/.*/.*/$", event.content.lower()
+    ):
         res = db.execute(
-            table.update().where(and_(
-                table.c.name == event.nick.lower(), table.c.chan == event.chan
-            )).values(time=now, quote=event.content, host=str(event.mask))
+            table.update()
+            .where(
+                and_(
+                    table.c.name == event.nick.lower(),
+                    table.c.chan == event.chan,
+                )
+            )
+            .values(time=now, quote=event.content, host=str(event.mask))
         )
         if res.rowcount == 0:
             db.execute(
                 table.insert().values(
-                    name=event.nick.lower(), time=now, quote=event.content,
-                    chan=event.chan, host=str(event.mask)
+                    name=event.nick.lower(),
+                    time=now,
+                    quote=event.content,
+                    chan=event.chan,
+                    host=str(event.mask),
                 )
             )
 
@@ -73,17 +91,20 @@ def seen(text, nick, chan, db, event, is_nick_valid):
         return "I can't look up that name, its impossible to use!"
 
     last_seen = db.execute(
-        select([table.c.name, table.c.time, table.c.quote]).where(and_(
-            table.c.name == text.lower(), table.c.chan == chan
-        ))
+        select([table.c.name, table.c.time, table.c.quote]).where(
+            and_(table.c.name == text.lower(), table.c.chan == chan)
+        )
     ).fetchone()
 
     if last_seen:
         reltime = timeformat.time_since(last_seen[1])
         if last_seen[2][0:1] == "\x01":
-            return '{} was last seen {} ago: * {} {}'.format(text, reltime, text,
-                                                             last_seen[2][8:-1])
+            return "{} was last seen {} ago: * {} {}".format(
+                text, reltime, text, last_seen[2][8:-1]
+            )
 
-        return '{} was last seen {} ago saying: {}'.format(text, reltime, last_seen[2])
+        return "{} was last seen {} ago saying: {}".format(
+            text, reltime, last_seen[2]
+        )
 
     return "I've never seen {} talking in this channel.".format(text)
diff --git a/plugins/shorten.py b/plugins/shorten.py
index fb1ec263..63f1c5f9 100644
--- a/plugins/shorten.py
+++ b/plugins/shorten.py
@@ -38,10 +38,10 @@ def isgd(text, reply):
     custom = args[1] if len(args) > 1 else None
 
     try:
-        if 'is.gd' in url:
-            return web.expand(url, 'is.gd')
+        if "is.gd" in url:
+            return web.expand(url, "is.gd")
 
-        return web.shorten(url, custom=custom, service='is.gd')
+        return web.shorten(url, custom=custom, service="is.gd")
     except web.ServiceError as e:
         reply(str(e))
         raise
@@ -56,10 +56,10 @@ def googl(text, reply):
     custom = args[1] if len(args) > 1 else None
 
     try:
-        if 'goo.gl' in url:
-            return web.expand(url, 'goo.gl')
+        if "goo.gl" in url:
+            return web.expand(url, "goo.gl")
 
-        return web.shorten(url, custom=custom, service='goo.gl')
+        return web.shorten(url, custom=custom, service="goo.gl")
     except web.ServiceError as e:
         reply(str(e))
         raise
@@ -74,10 +74,10 @@ def gitio(text, reply):
     custom = args[1] if len(args) > 1 else None
 
     try:
-        if 'git.io' in url:
-            return web.expand(url, 'git.io')
+        if "git.io" in url:
+            return web.expand(url, "git.io")
 
-        return web.shorten(url, custom=custom, service='git.io')
+        return web.shorten(url, custom=custom, service="git.io")
     except web.ServiceError as e:
         reply(str(e))
         raise
diff --git a/plugins/snopes.py b/plugins/snopes.py
index 04b1f4f3..4fc0671a 100644
--- a/plugins/snopes.py
+++ b/plugins/snopes.py
@@ -14,10 +14,13 @@ def snopes(text):
     """<topic> - Searches snopes for an urban legend about <topic>."""
 
     try:
-        params = {'sp_q': text, 'sp_c': "1"}
+        params = {"sp_q": text, "sp_c": "1"}
         request = requests.get(search_url, params=params)
         request.raise_for_status()
-    except (requests.exceptions.HTTPError, requests.exceptions.ConnectionError) as e:
+    except (
+        requests.exceptions.HTTPError,
+        requests.exceptions.ConnectionError,
+    ) as e:
         return "Error finding results: {}".format(e)
 
     search_page = html.fromstring(request.text)
@@ -29,7 +32,10 @@ def snopes(text):
     try:
         _request = requests.get(result_urls[0])
         _request.raise_for_status()
-    except (requests.exceptions.HTTPError, requests.exceptions.ConnectionError) as e:
+    except (
+        requests.exceptions.HTTPError,
+        requests.exceptions.ConnectionError,
+    ) as e:
         return "Error finding results: {}".format(e)
 
     snopes_page = html.fromstring(_request.text)
@@ -41,8 +47,11 @@ def snopes(text):
     if status is not None:
         status = status.group(0).strip()
     else:  # new-style statuses
-        status = "Status: {}".format(re.search(r"FALSE|TRUE|MIXTURE|UNDETERMINED",
-                                               snopes_text).group(0).title())
+        status = "Status: {}".format(
+            re.search(r"FALSE|TRUE|MIXTURE|UNDETERMINED", snopes_text)
+            .group(0)
+            .title()
+        )
 
     status = " ".join(status.split())  # compress whitespace
     claim = formatting.truncate(" ".join(claim.split()), 150)
diff --git a/plugins/soundcloud.py b/plugins/soundcloud.py
index f9d580a3..dd22ce51 100644
--- a/plugins/soundcloud.py
+++ b/plugins/soundcloud.py
@@ -4,10 +4,10 @@
 
 from cloudbot import hook
 from cloudbot.bot import bot
-from cloudbot.util import web, formatting, timeformat
+from cloudbot.util import formatting, timeformat, web
 
-SC_RE = re.compile(r'(.*:)//(www.)?(soundcloud.com|snd.sc)(.*)', re.I)
-API_BASE = 'http://api.soundcloud.com/{}/'
+SC_RE = re.compile(r"(.*:)//(www.)?(soundcloud.com|snd.sc)(.*)", re.I)
+API_BASE = "http://api.soundcloud.com/{}/"
 
 
 class APIError(Exception):
@@ -24,11 +24,14 @@ def get_with_search(endpoint, term):
     """
     api_key = bot.config.get_api_key("soundcloud")
     try:
-        params = {'q': term, 'client_id': api_key}
+        params = {"q": term, "client_id": api_key}
         request = requests.get(API_BASE.format(endpoint), params=params)
         request.raise_for_status()
-    except (requests.exceptions.HTTPError, requests.exceptions.ConnectionError) as e:
-        raise APIError("Could not find {}: {}".format(endpoint, e))
+    except (
+        requests.exceptions.HTTPError,
+        requests.exceptions.ConnectionError,
+    ) as e:
+        raise APIError("Could not find {}: {}".format(endpoint, e)) from e
 
     json = request.json()
 
@@ -46,11 +49,14 @@ def get_with_url(url):
     """
     api_key = bot.config.get_api_key("soundcloud")
     try:
-        params = {'url': url, 'client_id': api_key}
-        request = requests.get(API_BASE.format('resolve'), params=params)
+        params = {"url": url, "client_id": api_key}
+        request = requests.get(API_BASE.format("resolve"), params=params)
         request.raise_for_status()
-    except (requests.exceptions.HTTPError, requests.exceptions.ConnectionError) as e:
-        raise APIError("{}".format(e))
+    except (
+        requests.exceptions.HTTPError,
+        requests.exceptions.ConnectionError,
+    ) as e:
+        raise APIError("{}".format(e)) from e
 
     json = request.json()
 
@@ -65,19 +71,21 @@ def format_track(track, show_url=True):
     """
     Takes a SoundCloud track item and returns a formatted string.
     """
-    out = track['title']
+    out = track["title"]
 
-    out += " by \x02{}\x02".format(track['user']['username'])
+    out += " by \x02{}\x02".format(track["user"]["username"])
 
-    if track['genre']:
-        out += " - \x02{}\x02".format(track['genre'])
+    if track["genre"]:
+        out += " - \x02{}\x02".format(track["genre"])
 
-    out += " - \x02{:,}\x02 plays, \x02{:,}\x02 favorites, \x02{:,}\x02 comments".format(track['playback_count'],
-                                                                                         track['favoritings_count'],
-                                                                                         track['comment_count'])
+    out += " - \x02{:,}\x02 plays, \x02{:,}\x02 favorites, \x02{:,}\x02 comments".format(
+        track["playback_count"],
+        track["favoritings_count"],
+        track["comment_count"],
+    )
 
     if show_url:
-        out += " - {}".format(web.try_shorten(track['permalink_url']))
+        out += " - {}".format(web.try_shorten(track["permalink_url"]))
     return out
 
 
@@ -85,22 +93,24 @@ def format_user(user, show_url=True):
     """
     Takes a SoundCloud user item and returns a formatted string.
     """
-    out = "\x02{}\x02".format(user['username'])
+    out = "\x02{}\x02".format(user["username"])
 
-    if user['description']:
-        out += ': "{}"'.format(formatting.truncate(user['description']))
+    if user["description"]:
+        out += ': "{}"'.format(formatting.truncate(user["description"]))
 
-    if user['city']:
-        out += ': {}'.format(user['city'])
+    if user["city"]:
+        out += ": {}".format(user["city"])
 
-    if user['country']:
-        out += ", {}".format(formatting.truncate(user['country']))
+    if user["country"]:
+        out += ", {}".format(formatting.truncate(user["country"]))
 
-    out += " - \x02{track_count:,}\x02 tracks, \x02{playlist_count:,}\x02 playlists, \x02{followers_count:,}\x02 " \
-           "followers, \x02{followings_count:,}\x02 followed".format(**user)
+    out += (
+        " - \x02{track_count:,}\x02 tracks, \x02{playlist_count:,}\x02 playlists, \x02{followers_count:,}\x02 "
+        "followers, \x02{followings_count:,}\x02 followed".format(**user)
+    )
 
     if show_url:
-        out += " - {}".format(web.try_shorten(user['permalink_url']))
+        out += " - {}".format(web.try_shorten(user["permalink_url"]))
     return out
 
 
@@ -108,26 +118,26 @@ def format_playlist(playlist, show_url=True):
     """
     Takes a SoundCloud playlist item and returns a formatted string.
     """
-    out = "\x02{}\x02".format(playlist['title'])
+    out = "\x02{}\x02".format(playlist["title"])
 
-    if playlist['description']:
-        out += ': "{}"'.format(formatting.truncate(playlist['description']))
+    if playlist["description"]:
+        out += ': "{}"'.format(formatting.truncate(playlist["description"]))
 
-    if playlist['genre']:
-        out += " - \x02{}\x02".format(playlist['genre'])
+    if playlist["genre"]:
+        out += " - \x02{}\x02".format(playlist["genre"])
 
-    out += " - by \x02{}\x02".format(playlist['user']['username'])
+    out += " - by \x02{}\x02".format(playlist["user"]["username"])
 
-    if not playlist['tracks']:
+    if not playlist["tracks"]:
         out += " - No items"
     else:
-        out += " - {} items,".format(len(playlist['tracks']))
+        out += " - {} items,".format(len(playlist["tracks"]))
 
-        seconds = round(int(playlist['duration']) / 1000)
+        seconds = round(int(playlist["duration"]) / 1000)
         out += " {}".format(timeformat.format_time(seconds, simple=True))
 
     if show_url:
-        out += " - {}".format(web.try_shorten(playlist['permalink_url']))
+        out += " - {}".format(web.try_shorten(playlist["permalink_url"]))
     return out
 
 
@@ -135,15 +145,15 @@ def format_group(group, show_url=True):
     """
     Takes a SoundCloud group and returns a formatting string.
     """
-    out = "\x02{}\x02".format(group['name'])
+    out = "\x02{}\x02".format(group["name"])
 
-    if group['description']:
-        out += ': "{}"'.format(formatting.truncate(group['description']))
+    if group["description"]:
+        out += ': "{}"'.format(formatting.truncate(group["description"]))
 
-    out += " - Owned by \x02{}\x02.".format(group['creator']['username'])
+    out += " - Owned by \x02{}\x02.".format(group["creator"]["username"])
 
     if show_url:
-        out += " - {}".format(web.try_shorten(group['permalink_url']))
+        out += " - {}".format(web.try_shorten(group["permalink_url"]))
     return out
 
 
@@ -155,7 +165,7 @@ def soundcloud(text):
     if not api_key:
         return "This command requires a SoundCloud API key."
     try:
-        track = get_with_search('tracks', text)
+        track = get_with_search("tracks", text)
     except APIError as ae:
         return ae
 
@@ -175,7 +185,7 @@ def soundcloud_user(text):
     if not api_key:
         return "This command requires a SoundCloud API key."
     try:
-        user = get_with_search('users', text)
+        user = get_with_search("users", text)
     except APIError as ae:
         return ae
 
@@ -194,21 +204,26 @@ def soundcloud_url(match):
     if not api_key:
         return
 
-    url = match.group(1).split(' ')[-1] + "//" + (match.group(2) if match.group(2) else "") + match.group(3) + \
-          match.group(4).split(' ')[0]
+    url = (
+        match.group(1).split(" ")[-1]
+        + "//"
+        + (match.group(2) if match.group(2) else "")
+        + match.group(3)
+        + match.group(4).split(" ")[0]
+    )
 
     item = get_with_url(url)
     if not item:
         return
 
-    if item['kind'] == 'track':
+    if item["kind"] == "track":
         return format_track(item, show_url=False)
 
-    if item['kind'] == 'user':
+    if item["kind"] == "user":
         return format_user(item, show_url=False)
 
-    if item['kind'] == 'playlist':
+    if item["kind"] == "playlist":
         return format_playlist(item, show_url=False)
 
-    if item['kind'] == 'group':
+    if item["kind"] == "group":
         return format_group(item, show_url=False)
diff --git a/plugins/speedtest.py b/plugins/speedtest.py
index 31a060aa..9172efe6 100644
--- a/plugins/speedtest.py
+++ b/plugins/speedtest.py
@@ -5,7 +5,7 @@
 
 from cloudbot import hook
 
-speedtest_re = re.compile(r'.*://www.speedtest.net/my-result/([0-9]+)?.*', re.I)
+speedtest_re = re.compile(r".*://www.speedtest.net/my-result/([0-9]+)?.*", re.I)
 base_url = "http://www.speedtest.net/my-result/{}"
 
 
@@ -18,10 +18,29 @@ def speedtest_url(match):
     request.raise_for_status()
     data = html.fromstring(request.text)
 
-    download = data.xpath('//div[@class="share-speed share-download"]/p')[0].text_content().strip()
-    upload = data.xpath('//div[@class="share-speed share-upload"]/p')[0].text_content().strip()
-
-    ping = data.xpath('//div[@class="share-data share-ping"]/p')[0].text_content().strip()
-    isp = data.xpath('//div[@class="share-data share-isp"]/p')[0].text_content().strip().title()
-
-    return "\x02{}\x02 - Download: \x02{}\x02, Upload: \x02{}\x02, Ping: \x02{}\x02".format(isp, download, upload, ping)
+    download = (
+        data.xpath('//div[@class="share-speed share-download"]/p')[0]
+        .text_content()
+        .strip()
+    )
+    upload = (
+        data.xpath('//div[@class="share-speed share-upload"]/p')[0]
+        .text_content()
+        .strip()
+    )
+
+    ping = (
+        data.xpath('//div[@class="share-data share-ping"]/p')[0]
+        .text_content()
+        .strip()
+    )
+    isp = (
+        data.xpath('//div[@class="share-data share-isp"]/p')[0]
+        .text_content()
+        .strip()
+        .title()
+    )
+
+    return "\x02{}\x02 - Download: \x02{}\x02, Upload: \x02{}\x02, Ping: \x02{}\x02".format(
+        isp, download, upload, ping
+    )
diff --git a/plugins/sportscores.py b/plugins/sportscores.py
index a922ff94..563422a6 100644
--- a/plugins/sportscores.py
+++ b/plugins/sportscores.py
@@ -1,11 +1,12 @@
 import re
 from collections import defaultdict
+from typing import Dict
 
 from cloudbot import hook
 from cloudbot.util import http
-from cloudbot.util.pager import paginated_list, CommandPager
+from cloudbot.util.pager import CommandPager, paginated_list
 
-search_pages = defaultdict(dict)
+search_pages: Dict[str, Dict[str, CommandPager]] = defaultdict(dict)
 
 
 class Game:
@@ -57,11 +58,14 @@ def scrape_scores(conn, chan, game, text):
     if not text:
         text = " "
 
-    response = http.get_html('http://scores.espn.go.com/{}/bottomline/scores'.format(game), decode=False)
+    response = http.get_html(
+        "http://scores.espn.go.com/{}/bottomline/scores".format(game),
+        decode=False,
+    )
     score = response.text_content()
-    raw = score.replace('%20', ' ')
-    raw = raw.replace('^', '')
-    raw = raw.replace('&', '\n')
+    raw = score.replace("%20", " ")
+    raw = raw.replace("^", "")
+    raw = raw.replace("&", "\n")
     pattern = re.compile(r"{}_s_left\d+=(.*)".format(game))
     scores = []
     for match in re.findall(pattern, raw):
@@ -76,15 +80,19 @@ def func(conn, chan, text):
         return scrape_scores(conn, chan, game.name, text)
 
     func.__name__ = "{}_scores".format(game.name)
-    func.__doc__ = "[team city] - gets the score or next scheduled game for the specified team. " \
-                   "If no team is specified all games will be included."
+    func.__doc__ = (
+        "[team city] - gets the score or next scheduled game for the specified team. "
+        "If no team is specified all games will be included."
+    )
     return func
 
 
 def init_hooks():
     for game in GAMES:
         func = score_hook(game)
-        globals()[func.__name__] = hook.command(*game.cmds, autohelp=False)(func)
+        globals()[func.__name__] = hook.command(*game.cmds, autohelp=False)(
+            func
+        )
 
 
 init_hooks()
diff --git a/plugins/steam_user.py b/plugins/steam_user.py
index da557f2b..3da58113 100644
--- a/plugins/steam_user.py
+++ b/plugins/steam_user.py
@@ -1,3 +1,5 @@
+from typing import Dict
+
 import requests
 
 from cloudbot import hook
@@ -7,7 +9,7 @@
 API_URL = "http://steamcommunity.com/id/{}/"
 ID_BASE = 76561197960265728
 
-headers = {}
+headers: Dict[str, str] = {}
 
 
 class SteamError(Exception):
@@ -54,25 +56,32 @@ def get_data(user):
     data = {}
 
     # form the request
-    params = {'xml': 1}
+    params = {"xml": 1}
 
     # get the page
     try:
-        request = requests.get(API_URL.format(user), params=params, headers=headers)
+        request = requests.get(
+            API_URL.format(user), params=params, headers=headers
+        )
         request.raise_for_status()
-    except (requests.exceptions.HTTPError, requests.exceptions.ConnectionError) as e:
-        raise SteamError("Could not get user info: {}".format(e))
+    except (
+        requests.exceptions.HTTPError,
+        requests.exceptions.ConnectionError,
+    ) as e:
+        raise SteamError("Could not get user info: {}".format(e)) from e
 
     profile = parse_xml(request.content)
 
     try:
-        data["name"] = profile.find('steamID').text
-        data["id_64"] = int(profile.find('steamID64').text)
-        online_state = profile.find('stateMessage').text
-    except AttributeError:
-        raise SteamError("Could not get data for this user.")
-
-    online_state = online_state.replace("<br/>", ": ")  # will make this pretty later
+        data["name"] = profile.find("steamID").text
+        data["id_64"] = int(profile.find("steamID64").text)
+        online_state = profile.find("stateMessage").text
+    except AttributeError as e:
+        raise SteamError("Could not get data for this user.") from e
+
+    online_state = online_state.replace(
+        "<br/>", ": "
+    )  # will make this pretty later
     data["state"] = formatting.strip_html(online_state)
 
     data["id_32"] = convert_id32(data["id_64"])
@@ -84,7 +93,7 @@ def get_data(user):
 @hook.on_start
 def set_headers(bot):
     """ Runs on initial plugin load and sets the HTTP headers for this plugin. """
-    headers['User-Agent'] = bot.user_agent
+    headers["User-Agent"] = bot.user_agent
 
 
 @hook.command("steamid", "sid", "steamuser", "su")
@@ -97,4 +106,6 @@ def steamid(text, reply):
         reply("{}".format(e))
         raise
 
-    return "{name} ({state}): \x02ID64:\x02 {id_64}, \x02ID32:\x02 {id_32}, \x02ID3:\x02 {id_3}".format(**data)
+    return "{name} ({state}): \x02ID64:\x02 {id_64}, \x02ID32:\x02 {id_32}, \x02ID3:\x02 {id_3}".format(
+        **data
+    )
diff --git a/plugins/steamdb.py b/plugins/steamdb.py
index c1249d98..d31cd87b 100644
--- a/plugins/steamdb.py
+++ b/plugins/steamdb.py
@@ -34,7 +34,7 @@ def get_data(user, currency="us"):
     data = {}
 
     # form the request
-    params = {'player': user, 'currency': currency}
+    params = {"player": user, "currency": currency}
 
     # get the page
     try:
@@ -43,19 +43,24 @@ def get_data(user, currency="us"):
             request = scraper.get(CALC_URL, params=params)
         else:
             headers = {
-                'User-Agent': 'Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, '
-                              'like Gecko) Chrome/41.0.2228.0 Safari/537.36',
-                'Referer': 'https://steamdb.info/'
+                "User-Agent": "Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, "
+                "like Gecko) Chrome/41.0.2228.0 Safari/537.36",
+                "Referer": "https://steamdb.info/",
             }
             request = requests.get(CALC_URL, params=params, headers=headers)
 
         request.raise_for_status()
-    except (requests.exceptions.HTTPError, requests.exceptions.ConnectionError) as e:
+    except (
+        requests.exceptions.HTTPError,
+        requests.exceptions.ConnectionError,
+    ) as e:
         if cfscrape:
-            raise SteamError("Could not get user info: {}".format(e))
+            raise SteamError("Could not get user info: {}".format(e)) from e
         else:
-            raise SteamError("Could not get user info: {} (You may have been blocked by CloudFlare, try installing the "
-                             "cfscrape module)".format(e))
+            raise SteamError(
+                "Could not get user info: {} (You may have been blocked by CloudFlare, try installing the "
+                "cfscrape module)".format(e)
+            ) from e
 
     # parse that page!
     soup = parse_soup(request.content)
@@ -65,28 +70,34 @@ def get_data(user, currency="us"):
         data["name"] = soup.find("h1", {"class": "header-title"}).find("a").text
         data["url"] = request.url
 
-        data["status"] = soup.find('td', text='Status').find_next('td').text
+        data["status"] = soup.find("td", text="Status").find_next("td").text
 
         data["value"] = soup.find("h1", {"class": "calculator-price"}).text
-        data["value_sales"] = soup.find("h1", {"class": "calculator-price-lowest"}).text
-
-        data["count"] = int(soup.find(
-            "div", {"class": "pull-right price-container"}
-        ).find("p").find("span", {"class": "number"}).text.replace(
-            ',', ''
-        ))
-
-        played = soup.find('td', text='Games not played').find_next('td').text
+        data["value_sales"] = soup.find(
+            "h1", {"class": "calculator-price-lowest"}
+        ).text
+
+        data["count"] = int(
+            soup.find("div", {"class": "pull-right price-container"})
+            .find("p")
+            .find("span", {"class": "number"})
+            .text.replace(",", "")
+        )
+
+        played = soup.find("td", text="Games not played").find_next("td").text
         played = PLAYED_RE.search(played).groups()
 
         data["count_unplayed"] = int(played[0])
         data["count_played"] = data["count"] - data["count_unplayed"]
 
-        data["percent_unplayed"] = round(percentage(data["count_unplayed"], data["count"]), 1)
-        data["percent_played"] = round(percentage(data["count_played"], data["count"]), 1)
-
-    except AttributeError:
-        raise SteamError("Could not read info, does this user exist?")
+        data["percent_unplayed"] = round(
+            percentage(data["count_unplayed"], data["count"]), 1
+        )
+        data["percent_played"] = round(
+            percentage(data["count_played"], data["count"]), 1
+        )
+    except AttributeError as e:
+        raise SteamError("Could not read info, does this user exist?") from e
 
     return data
 
@@ -104,6 +115,10 @@ def steamcalc(text, reply):
 
     data["short_url"] = web.try_shorten(data["url"])
 
-    return "\x02{name}\x02 has \x02{count:,}\x02 games with a total value of \x02{value}\x02" \
-           " (\x02{value_sales}\x02 during sales). \x02{count_unplayed:,}\x02" \
-           " (\x02{percent_unplayed}%\x02) have never been played - {short_url}".format(**data)
+    return (
+        "\x02{name}\x02 has \x02{count:,}\x02 games with a total value of \x02{value}\x02"
+        " (\x02{value_sales}\x02 during sales). \x02{count_unplayed:,}\x02"
+        " (\x02{percent_unplayed}%\x02) have never been played - {short_url}".format(
+            **data
+        )
+    )
diff --git a/plugins/stock.py b/plugins/stock.py
index a0e82ca9..e80cc10a 100644
--- a/plugins/stock.py
+++ b/plugins/stock.py
@@ -24,7 +24,12 @@ def __init__(self, symbol):
 
 
 class AVApi:
-    def __init__(self, api_key=None, url="https://www.alphavantage.co/query", user_agent=None):
+    def __init__(
+        self,
+        api_key=None,
+        url="https://www.alphavantage.co/query",
+        user_agent=None,
+    ):
         self.api_key = api_key
         self.url = url
         self.user_agent = user_agent
@@ -33,32 +38,43 @@ def __bool__(self):
         return bool(self.api_key)
 
     def _request(self, **args):
-        args['apikey'] = self.api_key
+        args["apikey"] = self.api_key
         response = requests.get(self.url, params=args)
         response.raise_for_status()
         return response.json()
 
-    def _time_series(self, func, symbol, data_type='json', output_size='compact'):
+    def _time_series(
+        self, func, symbol, data_type="json", output_size="compact"
+    ):
         _data = self._request(
-            function="time_series_{}".format(func).upper(), symbol=symbol, outputsize=output_size, datatype=data_type
+            function="time_series_{}".format(func).upper(),
+            symbol=symbol,
+            outputsize=output_size,
+            datatype=data_type,
         )
         try:
-            return _data["Time Series ({})".format(func.title())], _data['Meta Data']['2. Symbol']
-        except LookupError:
-            raise StockSymbolNotFoundError(symbol)
+            return (
+                _data["Time Series ({})".format(func.title())],
+                _data["Meta Data"]["2. Symbol"],
+            )
+        except LookupError as e:
+            raise StockSymbolNotFoundError(symbol) from e
 
     def lookup(self, symbol):
-        _data, sym = self._time_series('daily', symbol)
+        _data, sym = self._time_series("daily", symbol)
         today = max(_data.keys())
         current_data = _data[today]
-        current_data = {key.split(None, 1)[1]: Decimal(value) for key, value in current_data.items()}
-        current_data['symbol'] = sym
+        current_data = {
+            key.split(None, 1)[1]: Decimal(value)
+            for key, value in current_data.items()
+        }
+        current_data["symbol"] = sym
         return current_data
 
 
 api = AVApi()
 
-number_suffixes = ['', '', 'M', 'B', 'T']
+number_suffixes = ["", "", "M", "B", "T"]
 
 
 def _get_group_count(num):
@@ -103,34 +119,36 @@ def stock(text):
 
     out = "$(bold){symbol}$(bold):"
 
-    price = data['close']
-    change = price - data['open']
+    price = data["close"]
+    change = price - data["open"]
 
     parts = [
         "{close:,.2f}",
     ]
 
     if price != 0 or change != 0:
-        data['mcap'] = format_money(price * data['volume'])
+        data["mcap"] = format_money(price * data["volume"])
 
-        data['change'] = change
+        data["change"] = change
 
-        data['pct_change'] = change / (price - change)
+        data["pct_change"] = change / (price - change)
 
         if change < 0:
             change_str = "$(red){change:+,.2f} ({pct_change:.2%})$(clear)"
         else:
             change_str = "$(dgreen){change:+,.2f} ({pct_change:.2%})$(clear)"
 
-        data['change_str'] = change_str.format_map(data)
+        data["change_str"] = change_str.format_map(data)
 
-        parts.extend([
-            "{change_str}",
-            "Day Open: {open:,.2f}",
-            "Day Range: {low:,.2f} - {high:,.2f}",
-            "Market Cap: {mcap}"
-        ])
+        parts.extend(
+            [
+                "{change_str}",
+                "Day Open: {open:,.2f}",
+                "Day Range: {low:,.2f} - {high:,.2f}",
+                "Market Cap: {mcap}",
+            ]
+        )
 
-    return colors.parse("$(clear){} {}$(clear)".format(
-        out, ' | '.join(parts)
-    ).format_map(data))
+    return colors.parse(
+        "$(clear){} {}$(clear)".format(out, " | ".join(parts)).format_map(data)
+    )
diff --git a/plugins/suggest.py b/plugins/suggest.py
index 0ae70132..a1972eca 100644
--- a/plugins/suggest.py
+++ b/plugins/suggest.py
@@ -9,25 +9,29 @@
 @hook.command()
 def suggest(text, reply):
     """<phrase> - Gets suggested phrases for a google search"""
-    params = {'output': 'json', 'client': 'hp', 'q': text}
+    params = {"output": "json", "client": "hp", "q": text}
 
     try:
-        request = requests.get('http://google.com/complete/search',
-                               params=params)
+        request = requests.get(
+            "http://google.com/complete/search", params=params
+        )
         request.raise_for_status()
-    except (requests.exceptions.HTTPError, requests.exceptions.ConnectionError) as e:
+    except (
+        requests.exceptions.HTTPError,
+        requests.exceptions.ConnectionError,
+    ) as e:
         reply("Could not get suggestions: {}".format(e))
         raise
 
     page = request.text
 
-    page_json = page.split('(', 1)[1][:-1]
+    page_json = page.split("(", 1)[1][:-1]
 
     suggestions = json.loads(page_json)[1]
     suggestions = [suggestion[0] for suggestion in suggestions]
 
     if not suggestions:
-        return 'No suggestions found.'
+        return "No suggestions found."
 
     out = formatting.strip_html(", ".join(suggestions))
 
diff --git a/plugins/tell.py b/plugins/tell.py
index 6aab480f..fef3dcb7 100644
--- a/plugins/tell.py
+++ b/plugins/tell.py
@@ -1,53 +1,63 @@
 from collections import defaultdict
 from datetime import datetime
 from fnmatch import fnmatch
+from typing import Dict, List, Set, Tuple
 
 import sqlalchemy as sa
 from sqlalchemy import (
-    Boolean, Column, DateTime, PrimaryKeyConstraint, String, Table, and_, not_,
+    Boolean,
+    Column,
+    DateTime,
+    PrimaryKeyConstraint,
+    String,
+    Table,
+    and_,
+    not_,
 )
 from sqlalchemy.sql import select
 
 from cloudbot import hook
 from cloudbot.event import EventType
-from cloudbot.util import timeformat, database, web
+from cloudbot.util import database, timeformat, web
 from cloudbot.util.formatting import gen_markdown_table
 
 table = Table(
-    'tells',
+    "tells",
     database.metadata,
-    Column('connection', String),
-    Column('sender', String),
-    Column('target', String),
-    Column('message', String),
-    Column('is_read', Boolean),
-    Column('time_sent', DateTime),
-    Column('time_read', DateTime)
+    Column("connection", String),
+    Column("sender", String),
+    Column("target", String),
+    Column("message", String),
+    Column("is_read", Boolean),
+    Column("time_sent", DateTime),
+    Column("time_read", DateTime),
 )
 
 disable_table = Table(
-    'tell_ignores',
+    "tell_ignores",
     database.metadata,
-    Column('conn', String),
-    Column('target', String),
-    Column('setter', String),
-    Column('set_at', DateTime),
-    PrimaryKeyConstraint('conn', 'target'),
+    Column("conn", String),
+    Column("target", String),
+    Column("setter", String),
+    Column("set_at", DateTime),
+    PrimaryKeyConstraint("conn", "target"),
 )
 
 ignore_table = Table(
-    'tell_user_ignores',
+    "tell_user_ignores",
     database.metadata,
-    Column('conn', String),
-    Column('set_at', DateTime),
-    Column('nick', String),
-    Column('mask', String),
-    PrimaryKeyConstraint('conn', 'nick', 'mask'),
+    Column("conn", String),
+    Column("set_at", DateTime),
+    Column("nick", String),
+    Column("mask", String),
+    PrimaryKeyConstraint("conn", "nick", "mask"),
 )
 
-disable_cache = defaultdict(set)
-ignore_cache = defaultdict(lambda: defaultdict(list))
-tell_cache = []
+disable_cache: Dict[str, Set[str]] = defaultdict(set)
+ignore_cache: Dict[str, Dict[str, List[str]]] = defaultdict(
+    lambda: defaultdict(list)
+)
+tell_cache: List[Tuple[str, str]] = []
 
 
 @hook.on_start
@@ -72,7 +82,7 @@ def load_disabled(db):
     """
     new_cache = defaultdict(set)
     for row in db.execute(disable_table.select()):
-        new_cache[row['conn']].add(row['target'].lower())
+        new_cache[row["conn"]].add(row["target"].lower())
 
     disable_cache.clear()
     disable_cache.update(new_cache)
@@ -85,7 +95,7 @@ def load_ignores(db):
     """
     new_cache = defaultdict(lambda: defaultdict(list))
     for row in db.execute(ignore_table.select()):
-        new_cache[row['conn'].lower()][row['nick'].lower()].append(row['mask'])
+        new_cache[row["conn"].lower()][row["nick"].lower()].append(row["mask"])
 
     ignore_cache.clear()
     ignore_cache.update(new_cache)
@@ -138,7 +148,14 @@ def add_disable(db, conn, setter, target, now=None):
     if now is None:
         now = datetime.now()
 
-    db.execute(disable_table.insert().values(conn=conn.name.lower(), setter=setter, set_at=now, target=target.lower()))
+    db.execute(
+        disable_table.insert().values(
+            conn=conn.name.lower(),
+            setter=setter,
+            set_at=now,
+            target=target.lower(),
+        )
+    )
     db.commit()
     load_disabled(db)
 
@@ -150,10 +167,12 @@ def del_disable(db, conn, target):
     :type target: str
     """
     db.execute(
-        disable_table.delete().where(and_(
-            disable_table.c.conn == conn.name.lower(),
-            disable_table.c.target == target.lower()
-        ))
+        disable_table.delete().where(
+            and_(
+                disable_table.c.conn == conn.name.lower(),
+                disable_table.c.target == target.lower(),
+            )
+        )
     )
     db.commit()
     load_disabled(db)
@@ -164,8 +183,10 @@ def list_disabled(db, conn):
     :type db: sqlalchemy.orm.Session
     :type conn: cloudbot.client.Client
     """
-    for row in db.execute(disable_table.select().where(disable_table.c.conn == conn.name.lower())):
-        yield (row['conn'], row['target'], row['setter'], row['set_at'].ctime())
+    for row in db.execute(
+        disable_table.select().where(disable_table.c.conn == conn.name.lower())
+    ):
+        yield (row["conn"], row["target"], row["setter"], row["set_at"].ctime())
 
 
 def add_ignore(db, conn, nick, mask, now=None):
@@ -179,10 +200,14 @@ def add_ignore(db, conn, nick, mask, now=None):
     if now is None:
         now = datetime.now()
 
-    db.execute(ignore_table.insert().values(
-        conn=conn.name.lower(), set_at=now,
-        nick=nick.lower(), mask=mask.lower()
-    ))
+    db.execute(
+        ignore_table.insert().values(
+            conn=conn.name.lower(),
+            set_at=now,
+            nick=nick.lower(),
+            mask=mask.lower(),
+        )
+    )
     db.commit()
     load_ignores(db)
 
@@ -195,11 +220,13 @@ def del_ignore(db, conn, nick, mask):
     :type mask: str
     """
     db.execute(
-        ignore_table.delete().where(and_(
-            ignore_table.c.conn == conn.name.lower(),
-            ignore_table.c.nick == nick.lower(),
-            ignore_table.c.mask == mask.lower(),
-        ))
+        ignore_table.delete().where(
+            and_(
+                ignore_table.c.conn == conn.name.lower(),
+                ignore_table.c.nick == nick.lower(),
+                ignore_table.c.mask == mask.lower(),
+            )
+        )
     )
     db.commit()
     load_ignores(db)
@@ -220,40 +247,48 @@ def get_unread(db, server, target):
     :type server: str
     :type target: str
     """
-    query = select([table.c.sender, table.c.message, table.c.time_sent]) \
-        .where(table.c.connection == server.lower()) \
-        .where(table.c.target == target.lower()) \
-        .where(not_(table.c.is_read)) \
+    query = (
+        select([table.c.sender, table.c.message, table.c.time_sent])
+        .where(table.c.connection == server.lower())
+        .where(table.c.target == target.lower())
+        .where(not_(table.c.is_read))
         .order_by(table.c.time_sent)
+    )
     return db.execute(query).fetchall()
 
 
 def count_unread(db, server, target):
-    query = select([sa.func.count(table)]) \
-        .where(table.c.connection == server.lower()) \
-        .where(table.c.target == target.lower()) \
+    query = (
+        select([sa.func.count(table)])
+        .where(table.c.connection == server.lower())
+        .where(table.c.target == target.lower())
         .where(not_(table.c.is_read))
+    )
 
     return db.execute(query).fetchone()[0]
 
 
 def read_all_tells(db, server, target):
-    query = table.update() \
-        .where(table.c.connection == server.lower()) \
-        .where(table.c.target == target.lower()) \
-        .where(not_(table.c.is_read)) \
+    query = (
+        table.update()
+        .where(table.c.connection == server.lower())
+        .where(table.c.target == target.lower())
+        .where(not_(table.c.is_read))
         .values(is_read=True)
+    )
     db.execute(query)
     db.commit()
     load_cache(db)
 
 
 def read_tell(db, server, target, message):
-    query = table.update() \
-        .where(table.c.connection == server.lower()) \
-        .where(table.c.target == target.lower()) \
-        .where(table.c.message == message) \
+    query = (
+        table.update()
+        .where(table.c.connection == server.lower())
+        .where(table.c.target == target.lower())
+        .where(table.c.message == message)
         .values(is_read=True)
+    )
     db.execute(query)
     db.commit()
     load_cache(db)
@@ -266,7 +301,7 @@ def add_tell(db, server, sender, target, message):
         target=target.lower(),
         message=message,
         is_read=False,
-        time_sent=datetime.today()
+        time_sent=datetime.today(),
     )
     db.execute(query)
     db.commit()
@@ -286,7 +321,7 @@ def tellinput(event, conn, db, nick, notice):
     :type conn: cloudbot.client.Client
     :type db: sqlalchemy.orm.Session
     """
-    if 'showtells' in event.content.lower():
+    if "showtells" in event.content.lower():
         return
 
     if tell_check(conn.name, nick):
@@ -303,9 +338,13 @@ def tellinput(event, conn, db, nick, notice):
         else:
             reltime_formatted = reltime
 
-        reply = "{} sent you a message {} ago: {}".format(user_from, reltime_formatted, message)
+        reply = "{} sent you a message {} ago: {}".format(
+            user_from, reltime_formatted, message
+        )
         if len(tells) > 1:
-            reply += " (+{} more, {}showtells to view)".format(len(tells) - 1, conn.config["command_prefix"][0])
+            reply += " (+{} more, {}showtells to view)".format(
+                len(tells) - 1, conn.config["command_prefix"][0]
+            )
 
         read_tell(db, conn.name, nick, message)
         notice(reply)
@@ -341,7 +380,7 @@ def tell_cmd(text, nick, db, conn, mask, event):
     :type event: cloudbot.event.CommandEvent
     :rtype: None
     """
-    query = text.split(' ', 1)
+    query = text.split(" ", 1)
 
     if len(query) != 2:
         event.notice_doc()
@@ -359,16 +398,25 @@ def tell_cmd(text, nick, db, conn, mask, event):
         event.notice("Have you looked in a mirror lately?")
         return
 
-    if not event.is_nick_valid(target.lower()) or target.lower() == conn.nick.lower():
+    if (
+        not event.is_nick_valid(target.lower())
+        or target.lower() == conn.nick.lower()
+    ):
         event.notice("Invalid nick '{}'.".format(target))
         return
 
     if count_unread(db, conn.name, target.lower()) >= 10:
-        event.notice("Sorry, {} has too many messages queued already.".format(target))
+        event.notice(
+            "Sorry, {} has too many messages queued already.".format(target)
+        )
         return
 
     add_tell(db, conn.name, sender, target.lower(), message)
-    event.notice("Your message has been saved, and {} will be notified once they are active.".format(target))
+    event.notice(
+        "Your message has been saved, and {} will be notified once they are active.".format(
+            target
+        )
+    )
 
 
 def check_permissions(event, *perms):
@@ -382,7 +430,7 @@ def tell_disable(conn, db, text, nick, event):
     if not text or text.casefold() == nick.casefold():
         text = nick
         is_self = True
-    elif not check_permissions(event, 'botcontrol', 'ignore'):
+    elif not check_permissions(event, "botcontrol", "ignore"):
         event.notice("Sorry, you are not allowed to use this command.")
         return None
 
@@ -405,7 +453,7 @@ def tell_enable(conn, db, text, event, nick):
     if not text or text.casefold() == nick.casefold():
         text = nick
         is_self = True
-    elif not check_permissions(event, 'botcontrol', 'ignore'):
+    elif not check_permissions(event, "botcontrol", "ignore"):
         event.notice("Sorry, you are not allowed to use this command.")
         return None
 
@@ -421,12 +469,16 @@ def tell_enable(conn, db, text, event, nick):
     )
 
 
-@hook.command("listtelldisabled", permissions=["botcontrol", "ignore"], autohelp=False)
+@hook.command(
+    "listtelldisabled", permissions=["botcontrol", "ignore"], autohelp=False
+)
 def list_tell_disabled(conn, db):
     """- Returns the current list of people who are not able to recieve tells"""
     ignores = list(list_disabled(db, conn))
-    md = gen_markdown_table(["Connection", "Target", "Setter", "Set At"], ignores)
-    return web.paste(md, 'md', 'hastebin')
+    md = gen_markdown_table(
+        ["Connection", "Target", "Setter", "Set At"], ignores
+    )
+    return web.paste(md, "md", "hastebin")
 
 
 @hook.command("tellignore")
@@ -453,7 +505,9 @@ def tell_unignore(db, conn, nick, text, notice):
     notice("{!r} has been unignored".format(mask))
 
 
-@hook.command("listtellignores", permissions=["botcontrol", "ignore"], autohelp=False)
+@hook.command(
+    "listtellignores", permissions=["botcontrol", "ignore"], autohelp=False
+)
 def list_tell_ignores(conn, nick):
     """- Returns the current list of masks who may not send you tells"""
     ignores = list(list_ignores(conn, nick))
@@ -461,5 +515,5 @@ def list_tell_ignores(conn, nick):
         return "You are not ignoring tells from any users"
 
     return "You are ignoring tell from: {}".format(
-        ', '.join(map(repr, ignores))
+        ", ".join(map(repr, ignores))
     )
diff --git a/plugins/time_plugin.py b/plugins/time_plugin.py
index c9ff2c86..8ae538ff 100644
--- a/plugins/time_plugin.py
+++ b/plugins/time_plugin.py
@@ -8,9 +8,9 @@
 from cloudbot.bot import bot
 
 # Define some constants
-base_url = 'https://maps.googleapis.com/maps/api/'
-geocode_api = base_url + 'geocode/json'
-timezone_api = base_url + 'timezone/json'
+base_url = "https://maps.googleapis.com/maps/api/"
+geocode_api = base_url + "geocode/json"
+timezone_api = base_url + "timezone/json"
 
 # Change this to a ccTLD code (eg. uk, nz) to make results more targeted towards that specific country.
 # <https://developers.google.com/maps/documentation/geocoding/#RegionCodes>
@@ -18,28 +18,28 @@
 
 
 def check_status(status, api):
-    """ A little helper function that checks an API error code and returns a nice message.
-        Returns None if no errors found """
-    if status == 'REQUEST_DENIED':
-        return 'The ' + api + ' API is off in the Google Developers Console.'
+    """A little helper function that checks an API error code and returns a nice message.
+    Returns None if no errors found"""
+    if status == "REQUEST_DENIED":
+        return "The " + api + " API is off in the Google Developers Console."
 
-    if status == 'ZERO_RESULTS':
-        return 'No results found.'
+    if status == "ZERO_RESULTS":
+        return "No results found."
 
-    if status == 'OVER_QUERY_LIMIT':
-        return 'The ' + api + ' API quota has run out.'
+    if status == "OVER_QUERY_LIMIT":
+        return "The " + api + " API quota has run out."
 
-    if status == 'UNKNOWN_ERROR':
-        return 'Unknown Error.'
+    if status == "UNKNOWN_ERROR":
+        return "Unknown Error."
 
-    if status == 'INVALID_REQUEST':
-        return 'Invalid Request.'
+    if status == "INVALID_REQUEST":
+        return "Invalid Request."
 
-    if status == 'OK':
+    if status == "OK":
         return None
 
     # !!!
-    return 'Unknown Demons.'
+    return "Unknown Demons."
 
 
 @hook.command("time")
@@ -56,57 +56,69 @@ def time_command(text, reply):
         if len(utcoffset) > 2:
             return "Please specify a valid UTC/GMT format Example: UTC-4, UTC+7 GMT7"
         if len(utcoffset) == 1:
-            utcoffset.append('0')
+            utcoffset.append("0")
         if len(utcoffset) == 2:
             try:
-                offset = datetime.timedelta(hours=int(utcoffset[0]), minutes=int(utcoffset[1]))
+                offset = datetime.timedelta(
+                    hours=int(utcoffset[0]), minutes=int(utcoffset[1])
+                )
             except Exception:
-                reply("Sorry I could not parse the UTC format you entered. Example UTC7 or UTC-4")
+                reply(
+                    "Sorry I could not parse the UTC format you entered. Example UTC7 or UTC-4"
+                )
                 raise
             curtime = datetime.datetime.utcnow()
             tztime = curtime + offset
-            formatted_time = datetime.datetime.strftime(tztime, '%I:%M %p, %A, %B %d, %Y')
+            formatted_time = datetime.datetime.strftime(
+                tztime, "%I:%M %p, %A, %B %d, %Y"
+            )
             return "\x02{}\x02 ({})".format(formatted_time, timezone)
 
     # Use the Geocoding API to get co-ordinates from the input
     params = {"address": text, "key": dev_key}
     if bias:
-        params['region'] = bias
+        params["region"] = bias
 
     json = requests.get(geocode_api, params=params).json()
 
-    error = check_status(json['status'], "geocoding")
+    error = check_status(json["status"], "geocoding")
     if error:
         return error
 
-    result = json['results'][0]
+    result = json["results"][0]
 
-    location_name = result['formatted_address']
-    location = result['geometry']['location']
+    location_name = result["formatted_address"]
+    location = result["geometry"]["location"]
 
     # Now we have the co-ordinates, we use the Timezone API to get the timezone
     formatted_location = "{lat},{lng}".format(**location)
 
     epoch = time.time()
 
-    params = {"location": formatted_location, "timestamp": epoch, "key": dev_key}
+    params = {
+        "location": formatted_location,
+        "timestamp": epoch,
+        "key": dev_key,
+    }
     json = requests.get(timezone_api, params=params).json()
 
-    error = check_status(json['status'], "timezone")
+    error = check_status(json["status"], "timezone")
     if error:
         return error
 
     # Work out the current time
-    offset = json['rawOffset'] + json['dstOffset']
+    offset = json["rawOffset"] + json["dstOffset"]
 
     # I'm telling the time module to parse the data as GMT, but whatever, it doesn't matter
     # what the time module thinks the timezone is. I just need dumb time formatting here.
     raw_time = time.gmtime(epoch + offset)
-    formatted_time = time.strftime('%I:%M %p, %A, %B %d, %Y', raw_time)
+    formatted_time = time.strftime("%I:%M %p, %A, %B %d, %Y", raw_time)
 
-    timezone = json['timeZoneName']
+    timezone = json["timeZoneName"]
 
-    return "\x02{}\x02 - {} ({})".format(formatted_time, location_name, timezone)
+    return "\x02{}\x02 - {} ({})".format(
+        formatted_time, location_name, timezone
+    )
 
 
 @hook.command(autohelp=False)
@@ -114,12 +126,14 @@ def beats(text):
     """- Gets the current time in .beats (Swatch Internet Time)."""
 
     if text.lower() == "wut":
-        return "Instead of hours and minutes, the mean solar day is divided " \
-               "up into 1000 parts called \".beats\". Each .beat lasts 1 minute and" \
-               " 26.4 seconds. Times are notated as a 3-digit number out of 1000 af" \
-               "ter midnight. So, @248 would indicate a time 248 .beats after midni" \
-               "ght representing 248/1000 of a day, just over 5 hours and 57 minute" \
-               "s. There are no timezones."
+        return (
+            "Instead of hours and minutes, the mean solar day is divided "
+            'up into 1000 parts called ".beats". Each .beat lasts 1 minute and'
+            " 26.4 seconds. Times are notated as a 3-digit number out of 1000 af"
+            "ter midnight. So, @248 would indicate a time 248 .beats after midni"
+            "ght representing 248/1000 of a day, just over 5 hours and 57 minute"
+            "s. There are no timezones."
+        )
 
     if text.lower() == "guide":
         return "1 day = 1000 .beats, 1 hour = 41.666 .beats, 1 min = 0.6944 .beats, 1 second = 0.01157 .beats"
diff --git a/plugins/topicchange.py b/plugins/topicchange.py
index 8ccb901c..9f654d87 100644
--- a/plugins/topicchange.py
+++ b/plugins/topicchange.py
@@ -1,10 +1,11 @@
 import codecs
 import os
 import random
+from typing import List
 
 from cloudbot import hook
 
-topicchange_data = []
+topicchange_data: List[str] = []
 
 
 @hook.on_start()
@@ -13,8 +14,12 @@ def load_topicchange(bot):
     :type bot: cloudbot.bot.Cloudbot
     """
     topicchange_data.clear()
-    with codecs.open(os.path.join(bot.data_dir, "topicchange.txt"), encoding="utf-8") as f:
-        topicchange_data.extend(line.strip() for line in f.readlines() if not line.startswith("//"))
+    with codecs.open(
+        os.path.join(bot.data_dir, "topicchange.txt"), encoding="utf-8"
+    ) as f:
+        topicchange_data.extend(
+            line.strip() for line in f.readlines() if not line.startswith("//")
+        )
 
 
 @hook.command("changetopic", "discuss", "question", autohelp=False)
diff --git a/plugins/tvdb.py b/plugins/tvdb.py
index 945050b6..0cc6e343 100644
--- a/plugins/tvdb.py
+++ b/plugins/tvdb.py
@@ -60,7 +60,9 @@ def authed(self) -> bool:
     def set_api_key(self, bot: CloudBot) -> None:
         res = cast(
             Dict[str, str],
-            self._post("/login", json={"apikey": bot.config.get_api_key("tvdb")}),
+            self._post(
+                "/login", json={"apikey": bot.config.get_api_key("tvdb")}
+            ),
         )
         self.set_token(res["token"])
 
@@ -93,7 +95,10 @@ def _get(self, path: str, params: Optional[GetParams] = None) -> JsonObject:
             return cast(JsonObject, response.json())
 
     def _get_paged(
-        self, path: str, params: Optional[GetParams] = None, reverse: bool = False
+        self,
+        path: str,
+        params: Optional[GetParams] = None,
+        reverse: bool = False,
     ) -> Iterable[JsonObject]:
         params = params or {}
         params["page"] = 1
@@ -156,11 +161,13 @@ def find_series(self, name: str) -> List[JsonObject]:
             )
         except requests.HTTPError as e:
             if e.response.status_code == 404:
-                raise NoMatchingSeries(name)
+                raise NoMatchingSeries(name) from e
 
             raise
 
-    def get_episodes(self, series_id: str, reverse=True) -> Iterable[JsonObject]:
+    def get_episodes(
+        self, series_id: str, reverse=True
+    ) -> Iterable[JsonObject]:
         try:
             for page in self._get_paged(
                 "/series/{id}/episodes".format(id=series_id), reverse=reverse
@@ -364,7 +371,9 @@ def from_json(cls, json: Dict[str, Any]) -> "EpisodeInfo":
         if not first_aired:
             air_date = None
         else:
-            air_date = datetime.datetime.strptime(first_aired, "%Y-%m-%d").date()
+            air_date = datetime.datetime.strptime(
+                first_aired, "%Y-%m-%d"
+            ).date()
 
         episode_number = json["airedEpisodeNumber"]
         season = json["airedSeason"]
@@ -422,14 +431,16 @@ def get_episodes_for_series(series_name: str) -> SeriesInfo:
     return SeriesInfo(cast(str, series["seriesName"]), episodes, status)
 
 
-def check_and_get_series(series: str) -> Tuple[bool, Union[SeriesInfo, str]]:
+def check_and_get_series(
+    series: str,
+) -> Union[Tuple[SeriesInfo, None], Tuple[None, str]]:
     if not api.authed:
-        return False, "TVDB API not enabled."
+        return None, "TVDB API not enabled."
 
     try:
-        return True, get_episodes_for_series(series)
+        return get_episodes_for_series(series), None
     except NoMatchingSeries:
-        return False, "Unable to find series"
+        return None, "Unable to find series"
 
 
 def handle_error(event: Event, error):
@@ -461,9 +472,9 @@ def refresh(bot: CloudBot) -> None:
 @_error_handler(requests.HTTPError, handle_error)
 def tv_next(text: str) -> str:
     """<series> - Get the next episode of <series>."""
-    ok, series = check_and_get_series(text)
-    if not ok:
-        return series
+    series, err = check_and_get_series(text)
+    if err is not None:
+        return err
 
     if series.ended:
         return "{} has ended.".format(series.name)
@@ -499,9 +510,9 @@ def tv_next(text: str) -> str:
 @_error_handler(requests.HTTPError, handle_error)
 def tv_last(text: str) -> str:
     """<series> - Gets the most recently aired episode of <series>."""
-    ok, series = check_and_get_series(text)
-    if not ok:
-        return series
+    series, err = check_and_get_series(text)
+    if err is not None:
+        return err
 
     prev_ep = None
     today = datetime.date.today()
@@ -515,9 +526,13 @@ def tv_last(text: str) -> str:
             break
 
     if not prev_ep:
-        return "There are no previously aired episodes for {}.".format(series.name)
+        return "There are no previously aired episodes for {}.".format(
+            series.name
+        )
 
     if series.ended:
-        return "{} ended. The last episode aired {}.".format(series.name, prev_ep)
+        return "{} ended. The last episode aired {}.".format(
+            series.name, prev_ep
+        )
 
     return "The last episode of {} aired {}.".format(series.name, prev_ep)
diff --git a/plugins/urban.py b/plugins/urban.py
index fdb0153b..37932666 100644
--- a/plugins/urban.py
+++ b/plugins/urban.py
@@ -5,7 +5,7 @@
 from cloudbot import hook
 from cloudbot.util import formatting
 
-base_url = 'http://api.urbandictionary.com/v0'
+base_url = "http://api.urbandictionary.com/v0"
 define_url = base_url + "/define"
 random_url = base_url + "/random"
 
@@ -14,9 +14,7 @@
 def urban(text, reply):
     """<phrase> [id] - Looks up <phrase> on urbandictionary.com."""
 
-    headers = {
-        "Referer": "http://m.urbandictionary.com"
-    }
+    headers = {"Referer": "http://m.urbandictionary.com"}
 
     if text:
         # clean and split the input
@@ -38,7 +36,10 @@ def urban(text, reply):
             params = {"term": text}
             request = requests.get(define_url, params=params, headers=headers)
             request.raise_for_status()
-        except (requests.exceptions.HTTPError, requests.exceptions.ConnectionError) as e:
+        except (
+            requests.exceptions.HTTPError,
+            requests.exceptions.ConnectionError,
+        ) as e:
             reply("Could not get definition: {}".format(e))
             raise
 
@@ -48,40 +49,49 @@ def urban(text, reply):
         try:
             request = requests.get(random_url, headers=headers)
             request.raise_for_status()
-        except (requests.exceptions.HTTPError, requests.exceptions.ConnectionError) as e:
+        except (
+            requests.exceptions.HTTPError,
+            requests.exceptions.ConnectionError,
+        ) as e:
             reply("Could not get definition: {}".format(e))
             raise
 
         page = request.json()
         id_num = None
 
-    definitions = page['list']
+    definitions = page["list"]
 
     if not definitions:
-        return 'Not found.'
+        return "Not found."
 
     if id_num:
         # try getting the requested definition
         try:
             definition = definitions[id_num - 1]
 
-            def_text = " ".join(definition['definition'].split())  # remove excess spaces
+            def_text = " ".join(
+                definition["definition"].split()
+            )  # remove excess spaces
             def_text = formatting.truncate(def_text, 200)
         except IndexError:
-            return 'Not found.'
+            return "Not found."
 
-        url = definition['permalink']
+        url = definition["permalink"]
 
-        output = "[{}/{}] {} - {}".format(id_num, len(definitions), def_text, url)
+        output = "[{}/{}] {} - {}".format(
+            id_num, len(definitions), def_text, url
+        )
 
     else:
         definition = random.choice(definitions)
 
-        def_text = " ".join(definition['definition'].split())  # remove excess spaces
+        def_text = " ".join(
+            definition["definition"].split()
+        )  # remove excess spaces
         def_text = formatting.truncate(def_text, 200)
 
-        name = definition['word']
-        url = definition['permalink']
+        name = definition["word"]
+        url = definition["permalink"]
         output = "\x02{}\x02: {} - {}".format(name, def_text, url)
 
     return output
diff --git a/plugins/validate.py b/plugins/validate.py
index 51410b16..ecf711b6 100644
--- a/plugins/validate.py
+++ b/plugins/validate.py
@@ -19,10 +19,10 @@ def validate(text):
     if not urllib.parse.urlparse(text).scheme:
         text = "http://" + text
 
-    url = api_url + '?uri=' + text
+    url = api_url + "?uri=" + text
     url = web.try_shorten(url)
 
-    params = {'uri': text, 'output': 'json'}
+    params = {"uri": text, "output": "json"}
     request = requests.get(api_url, params=params)
     request.raise_for_status()
 
@@ -30,17 +30,19 @@ def validate(text):
         return "Failed to fetch info: {}".format(request.status_code)
 
     response = request.json()
-    response = response['messages']
+    response = response["messages"]
 
     for mess in response:
-        if mess.get('subType', None) == 'warning':
+        if mess.get("subType", None) == "warning":
             warning_count += 1
-        if mess.get('type', None) == 'error':
+        if mess.get("type", None) == "error":
             error_count += 1
 
     out_warning = "warnings" if warning_count > 1 else "warning"
     out_error = "errors" if error_count > 1 else "error"
 
-    out = "{} has {} {} and {} {} ({})".format(text, warning_count, out_warning, error_count, out_error, url)
+    out = "{} has {} {} and {} {} ({})".format(
+        text, warning_count, out_warning, error_count, out_error, url
+    )
 
     return out
diff --git a/plugins/verysmart.py b/plugins/verysmart.py
index 7274ed42..c3d50f27 100644
--- a/plugins/verysmart.py
+++ b/plugins/verysmart.py
@@ -1,21 +1,26 @@
 import codecs
 import os
 import random
+from typing import List
 
 from cloudbot import hook
 
-vsquotes = []
+vsquotes: List[str] = []
 
 
 @hook.on_start()
 def load_quotes(bot):
     """- Import quotes from data directory."""
     vsquotes.clear()
-    with codecs.open(os.path.join(bot.data_dir, "verysmart.txt"), encoding="utf-8") as fp:
+    with codecs.open(
+        os.path.join(bot.data_dir, "verysmart.txt"), encoding="utf-8"
+    ) as fp:
         vsquotes.extend(quote.strip() for quote in fp.readlines())
 
 
-@hook.command('smart', 'verysmart', 'vs', 'iamverysmart', 'iavs', autohelp=False)
+@hook.command(
+    "smart", "verysmart", "vs", "iamverysmart", "iavs", autohelp=False
+)
 def verysmart():
     """- Return a random choice from the quote list."""
     return random.choice(vsquotes)
diff --git a/plugins/vimeo.py b/plugins/vimeo.py
index 1225c1fa..ea6524bb 100644
--- a/plugins/vimeo.py
+++ b/plugins/vimeo.py
@@ -3,7 +3,7 @@
 from cloudbot import hook
 from cloudbot.util import http, timeformat
 
-url_re = re.compile(r'vimeo\.com/([0-9]+)')
+url_re = re.compile(r"vimeo\.com/([0-9]+)")
 api_url = "http://vimeo.com/api/v2/video/{id}.json"
 
 
diff --git a/plugins/wikipedia.py b/plugins/wikipedia.py
index 2d130b3f..ae61ec0e 100644
--- a/plugins/wikipedia.py
+++ b/plugins/wikipedia.py
@@ -11,11 +11,11 @@
 api_prefix = "http://en.wikipedia.org/w/api.php"
 query_url = api_prefix + "?action=query&format=json"
 search_url = query_url + "&list=search&redirect=1"
-wp_api_url = URL('https://en.wikipedia.org/api/rest_v1/')
+wp_api_url = URL("https://en.wikipedia.org/api/rest_v1/")
 
 
 def make_summary_url(title) -> str:
-    return str(wp_api_url / 'page/summary' / title.replace(' ', '_'))
+    return str(wp_api_url / "page/summary" / title.replace(" ", "_"))
 
 
 def get_info(title):
@@ -27,7 +27,7 @@ def get_info(title):
 def wiki(text, reply):
     """<phrase> - Gets first sentence of Wikipedia article on <phrase>."""
 
-    search_params = {'srsearch': text.strip()}
+    search_params = {"srsearch": text.strip()}
     try:
         with requests.get(search_url, params=search_params) as response:
             response.raise_for_status()
@@ -36,14 +36,14 @@ def wiki(text, reply):
         reply("Could not get Wikipedia page")
         raise
 
-    for result in data['query']['search']:
-        title = result['title']
+    for result in data["query"]["search"]:
+        title = result["title"]
         info = get_info(title)
-        if info['type'] != 'standard':
+        if info["type"] != "standard":
             continue
 
-        desc = info['extract']
-        url = info['content_urls']['desktop']['page']
+        desc = info["extract"]
+        url = info["content_urls"]["desktop"]["page"]
 
         break
     else:
@@ -54,4 +54,4 @@ def wiki(text, reply):
     else:
         desc = "(No Summary)"
 
-    return '{} :: {} :: {}'.format(title, desc, url)
+    return "{} :: {} :: {}".format(title, desc, url)
diff --git a/plugins/wolframalpha.py b/plugins/wolframalpha.py
index 29acc5b6..7ebfefb5 100644
--- a/plugins/wolframalpha.py
+++ b/plugins/wolframalpha.py
@@ -5,11 +5,11 @@
 from requests import HTTPError
 
 from cloudbot import hook
-from cloudbot.util import web, formatting
+from cloudbot.util import formatting, web
 from cloudbot.util.http import parse_xml
 
-api_url = 'http://api.wolframalpha.com/v2/query'
-query_url = 'http://www.wolframalpha.com/input/?i={}'
+api_url = "http://api.wolframalpha.com/v2/query"
+query_url = "http://www.wolframalpha.com/input/?i={}"
 
 
 @hook.command("wolframalpha", "wa", "calc", "ca", "math", "convert")
@@ -19,10 +19,7 @@ def wolframalpha(text, bot, reply):
     if not api_key:
         return "error: missing api key"
 
-    params = {
-        'input': text,
-        'appid': api_key
-    }
+    params = {"input": text, "appid": api_key}
     request = requests.get(api_url, params=params)
 
     try:
@@ -41,29 +38,29 @@ def wolframalpha(text, bot, reply):
 
     pod_texts = []
     for pod in result.xpath("//pod[@primary='true']"):
-        title = pod.attrib['title']
-        if pod.attrib['id'] == 'Input':
+        title = pod.attrib["title"]
+        if pod.attrib["id"] == "Input":
             continue
 
         results = []
-        for subpod in pod.xpath('subpod/plaintext/text()'):
-            subpod = subpod.strip().replace('\\n', '; ')
-            subpod = re.sub(r'\s+', ' ', subpod)
+        for subpod in pod.xpath("subpod/plaintext/text()"):
+            subpod = subpod.strip().replace("\\n", "; ")
+            subpod = re.sub(r"\s+", " ", subpod)
             if subpod:
                 results.append(subpod)
         if results:
-            pod_texts.append(title + ': ' + ', '.join(results))
+            pod_texts.append(title + ": " + ", ".join(results))
 
-    ret = ' - '.join(pod_texts)
+    ret = " - ".join(pod_texts)
 
     if not pod_texts:
-        return 'No results.'
+        return "No results."
 
     # I have no idea what this regex does.
-    ret = re.sub(r'\\(.)', r'\1', ret)
+    ret = re.sub(r"\\(.)", r"\1", ret)
     ret = formatting.truncate(ret, 250)
 
     if not ret:
-        return 'No results.'
+        return "No results."
 
     return "{} - {}".format(ret, short_url)
diff --git a/plugins/wordnik.py b/plugins/wordnik.py
index 5386f51e..5eb763c2 100644
--- a/plugins/wordnik.py
+++ b/plugins/wordnik.py
@@ -10,19 +10,19 @@
 from cloudbot.bot import bot
 from cloudbot.util import colors, web
 
-logger = logging.getLogger('cloudbot')
+logger = logging.getLogger("cloudbot")
 
-API_URL = 'http://api.wordnik.com/v4/'
-WEB_URL = 'https://www.wordnik.com/words/{}'
+API_URL = "http://api.wordnik.com/v4/"
+WEB_URL = "https://www.wordnik.com/words/{}"
 
 ATTRIB_NAMES = {
-    'ahd-legacy': 'AHD/Wordnik',
-    'ahd': 'AHD/Wordnik',
-    'ahd-5': 'AHD/Wordnik',
-    'century': 'Century/Wordnik',
-    'wiktionary': 'Wiktionary/Wordnik',
-    'gcide': 'GCIDE/Wordnik',
-    'wordnet': 'Wordnet/Wordnik',
+    "ahd-legacy": "AHD/Wordnik",
+    "ahd": "AHD/Wordnik",
+    "ahd-5": "AHD/Wordnik",
+    "century": "Century/Wordnik",
+    "wiktionary": "Wiktionary/Wordnik",
+    "gcide": "GCIDE/Wordnik",
+    "wordnet": "Wordnet/Wordnik",
 }
 
 # Strings
@@ -58,14 +58,16 @@ def __init__(self, term, results):
         self.results = results
 
 
-ERROR_MAP = {'Not Found': WordNotFound}
+ERROR_MAP = {"Not Found": WordNotFound}
 
 
 def raise_error(data):
     try:
-        error = data['error']
-    except KeyError:
-        raise WordnikAPIError("Unknown error, unable to retrieve error data")
+        error = data["error"]
+    except KeyError as e:
+        raise WordnikAPIError(
+            "Unknown error, unable to retrieve error data"
+        ) from e
 
     try:
         err = ERROR_MAP[error]()
@@ -78,13 +80,13 @@ def raise_error(data):
 def api_request(endpoint, params=(), **kwargs):
     kwargs.update(params)
 
-    api_key = bot.config.get_api_key('wordnik')
+    api_key = bot.config.get_api_key("wordnik")
     if not api_key:
         raise NoAPIKey()
 
     url = API_URL + endpoint
 
-    kwargs['api_key'] = api_key
+    kwargs["api_key"] = api_key
     with requests.get(url, params=kwargs) as response:
         try:
             data = response.json()
@@ -112,7 +114,9 @@ def __init__(self, word, operation, *, required_fields=()):
 
     @staticmethod
     def sanitize(text):
-        return urllib.parse.quote(text.translate({ord('\\'): None, ord('/'): None}))
+        return urllib.parse.quote(
+            text.translate({ord("\\"): None, ord("/"): None})
+        )
 
     @property
     def endpoint(self):
@@ -121,7 +125,7 @@ def endpoint(self):
     def get_params(self):
         params = dict(self.extra_params)
         if self.result_limit:
-            params['limit'] = self.result_limit
+            params["limit"] = self.result_limit
 
         return params
 
@@ -176,7 +180,7 @@ def random(self):
 
 class DefinitionsLookupRequest(WordLookupRequest):
     def __init__(self, word):
-        super().__init__(word, "definitions", required_fields=('text',))
+        super().__init__(word, "definitions", required_fields=("text",))
 
 
 class ExamplesLookupRequest(WordLookupRequest):
@@ -186,29 +190,29 @@ def __init__(self, word):
 
     def get_results(self):
         results = super().get_results()
-        return results['examples']
+        return results["examples"]
 
 
 class PronounciationLookupRequest(WordLookupRequest):
     def __init__(self, word):
-        super().__init__(word, "pronunciations", required_fields=('raw',))
+        super().__init__(word, "pronunciations", required_fields=("raw",))
 
 
 class AudioLookupRequest(WordLookupRequest):
     def __init__(self, word):
-        super().__init__(word, "audio", required_fields=('fileUrl',))
+        super().__init__(word, "audio", required_fields=("fileUrl",))
 
 
 class RelatedLookupRequest(WordLookupRequest):
     def __init__(self, word, rel_type):
-        super().__init__(word, "relatedWords", required_fields=('words',))
-        self.extra_params['relationshipTypes'] = rel_type
+        super().__init__(word, "relatedWords", required_fields=("words",))
+        self.extra_params["relationshipTypes"] = rel_type
 
     def get_params(self):
         params = super().get_params()
-        params.pop('limit', None)
+        params.pop("limit", None)
 
-        params['limitPerRelationshipType'] = self.result_limit
+        params["limitPerRelationshipType"] = self.result_limit
 
         return params
 
@@ -217,7 +221,7 @@ def format_attrib(attr_id):
     try:
         return ATTRIB_NAMES[attr_id]
     except KeyError:
-        return attr_id.title() + '/Wordnik'
+        return attr_id.title() + "/Wordnik"
 
 
 @hook.command("define", "dictionary")
@@ -227,17 +231,19 @@ def define(text, event):
     try:
         data = lookup.first()
     except WordNotFound:
-        return colors.parse("I could not find a definition for $(b){}$(b).").format(
-            text
-        )
+        return colors.parse(
+            "I could not find a definition for $(b){}$(b)."
+        ).format(text)
     except WordnikAPIError as e:
         event.reply(e.user_msg())
         raise
 
-    data['url'] = web.try_shorten(WEB_URL.format(data['word']))
-    data['attrib'] = format_attrib(data['sourceDictionary'])
+    data["url"] = web.try_shorten(WEB_URL.format(data["word"]))
+    data["attrib"] = format_attrib(data["sourceDictionary"])
 
-    return colors.parse("$(b){word}$(b): {text} - {url} ({attrib})").format_map(data)
+    return colors.parse("$(b){word}$(b): {text} - {url} ({attrib})").format_map(
+        data
+    )
 
 
 @hook.command("wordusage", "wordexample", "usage")
@@ -254,7 +260,9 @@ def word_usage(text, event):
         event.reply(e.user_msg())
         raise
 
-    out = colors.parse("$(b){word}$(b): {text}").format(word=text, text=example['text'])
+    out = colors.parse("$(b){word}$(b): {text}").format(
+        word=text, text=example["text"]
+    )
     return out
 
 
@@ -266,15 +274,15 @@ def pronounce(text, event):
     try:
         audio_response = list(lookup.get_filtered_results())[:5]
     except WordNotFound:
-        return colors.parse("Sorry, I don't know how to pronounce $(b){}$(b).").format(
-            text
-        )
+        return colors.parse(
+            "Sorry, I don't know how to pronounce $(b){}$(b)."
+        ).format(text)
     except WordnikAPIError as e:
         event.reply(e.user_msg())
         raise
 
     out = colors.parse("$(b){}$(b): ").format(text)
-    out += " • ".join([i['raw'] for i in audio_response])
+    out += " • ".join([i["raw"] for i in audio_response])
 
     audio_lookup = AudioLookupRequest(text)
     try:
@@ -285,7 +293,7 @@ def pronounce(text, event):
         event.reply(e.user_msg())
         raise
     else:
-        url = web.try_shorten(audio_response['fileUrl'])
+        url = web.try_shorten(audio_response["fileUrl"])
         out += " - {}".format(url)
 
     return out
@@ -294,7 +302,7 @@ def pronounce(text, event):
 @hook.command()
 def synonym(text, event):
     """<word> - Returns a list of synonyms for <word>."""
-    lookup = RelatedLookupRequest(text, 'synonym')
+    lookup = RelatedLookupRequest(text, "synonym")
     try:
         data = lookup.first()
     except WordNotFound:
@@ -306,7 +314,7 @@ def synonym(text, event):
         raise
 
     out = colors.parse("$(b){}$(b): ").format(text)
-    out += " • ".join(data['words'])
+    out += " • ".join(data["words"])
 
     return out
 
@@ -314,8 +322,8 @@ def synonym(text, event):
 @hook.command()
 def antonym(text, event):
     """<word> - Returns a list of antonyms for <word>."""
-    lookup = RelatedLookupRequest(text, 'antonym')
-    lookup.extra_params['useCanonical'] = 'false'
+    lookup = RelatedLookupRequest(text, "antonym")
+    lookup.extra_params["useCanonical"] = "false"
     try:
         data = lookup.first()
     except WordNotFound:
@@ -327,7 +335,7 @@ def antonym(text, event):
         raise
 
     out = colors.parse("$(b){}$(b): ").format(text)
-    out += " • ".join(data['words'])
+    out += " • ".join(data["words"])
 
     return out
 
@@ -338,13 +346,13 @@ def wordoftheday(text, event):
     """[date] - returns the word of the day. To see past word of the day
     enter use the format yyyy-MM-dd. The specified date must be after
     2009-08-10."""
-    match = re.search(r'(\d\d\d\d-\d\d-\d\d)', text)
+    match = re.search(r"(\d\d\d\d-\d\d-\d\d)", text)
     date = ""
     if match:
         date = match.group(1)
 
     if date:
-        params = {'date': date}
+        params = {"date": date}
         day = date
     else:
         params = {}
@@ -358,10 +366,10 @@ def wordoftheday(text, event):
         event.reply(e.user_msg())
         raise
 
-    word = json['word']
-    note = json['note']
-    pos = json['definitions'][0]['partOfSpeech']
-    definition = json['definitions'][0]['text']
+    word = json["word"]
+    note = json["note"]
+    pos = json["definitions"][0]["partOfSpeech"]
+    definition = json["definitions"][0]["text"]
     out = (
         "The word for $(bold){day}$(bold) is $(bold){word}$(bold): "
         "$(dred)({pos})$(dred) $(cyan){note}$(cyan) "
@@ -379,11 +387,12 @@ def random_word(event):
     """- Grabs a random word from wordnik.com"""
     try:
         json = api_request(
-            "words.json/randomWord", {'hasDictionarydef': 'true', 'vulgar': 'true'}
+            "words.json/randomWord",
+            {"hasDictionarydef": "true", "vulgar": "true"},
         )
     except WordnikAPIError as e:
         event.reply(e.user_msg())
         raise
 
-    word = json['word']
+    word = json["word"]
     return colors.parse("Your random word is $(b){}$(b).").format(word)
diff --git a/plugins/xkcd.py b/plugins/xkcd.py
index 68803597..2ea2a8cb 100644
--- a/plugins/xkcd.py
+++ b/plugins/xkcd.py
@@ -7,7 +7,7 @@
 from cloudbot import hook
 from cloudbot.util.http import parse_soup
 
-xkcd_re = re.compile(r'(.*:)//(www.xkcd.com|xkcd.com)(.*)', re.I)
+xkcd_re = re.compile(r"(.*:)//(www.xkcd.com|xkcd.com)(.*)", re.I)
 
 XKCD_URL = URL("http://www.xkcd.com/")
 ONR_URL = URL("http://www.ohnorobot.com/")
@@ -20,38 +20,38 @@ def xkcd_info(xkcd_id, url=False):
     data = request.json()
 
     date = datetime.date(
-        year=int(data['year']),
-        month=int(data['month']),
-        day=int(data['day']),
+        year=int(data["year"]),
+        month=int(data["month"]),
+        day=int(data["day"]),
     )
-    date_str = date.strftime('%d %B %Y')
+    date_str = date.strftime("%d %B %Y")
 
     if url:
         url = " | {}".format(XKCD_URL / xkcd_id.replace("/", ""))
     else:
         url = ""
 
-    return "xkcd: \x02{}\x02 ({}){}".format(data['title'], date_str, url)
+    return "xkcd: \x02{}\x02 ({}){}".format(data["title"], date_str, url)
 
 
 def xkcd_search(term):
     params = {
-        's': term,
-        'Search': 'Search',
-        'comic': 56,
-        'e': 0,
-        'n': 0,
-        'b': 0,
-        'm': 0,
-        'd': 0,
-        't': 0,
+        "s": term,
+        "Search": "Search",
+        "comic": 56,
+        "e": 0,
+        "n": 0,
+        "b": 0,
+        "m": 0,
+        "d": 0,
+        "t": 0,
     }
     request = requests.get(str(ONR_URL), params=params)
     request.raise_for_status()
     soup = parse_soup(request.text)
-    result = soup.find('li')
+    result = soup.find("li")
     if result:
-        url = result.find('div', {'class': 'tinylink'}).text
+        url = result.find("div", {"class": "tinylink"}).text
         xkcd_id = url[:-1].split("/")[-1]
         return xkcd_info(xkcd_id, url=True)
 
diff --git a/plugins/yandex_translate.py b/plugins/yandex_translate.py
index c9f4ab41..3ce367fe 100644
--- a/plugins/yandex_translate.py
+++ b/plugins/yandex_translate.py
@@ -1,3 +1,5 @@
+from typing import Dict, List
+
 import requests
 from requests import HTTPError
 
@@ -6,8 +8,8 @@
 from cloudbot.util import web
 
 api_url = "https://translate.yandex.net/api/v1.5/tr.json/"
-lang_dict = {}
-lang_dir = []
+lang_dict: Dict[str, str] = {}
+lang_dir: List[str] = []
 
 
 @hook.on_start()
@@ -17,29 +19,26 @@ def load_key():
         return
 
     url = api_url + "getLangs"
-    params = {
-        'key': api_key,
-        'ui': 'en'
-    }
+    params = {"key": api_key, "ui": "en"}
     r = requests.get(url, params=params)
     r.raise_for_status()
     data = r.json()
     lang_dict.clear()
     lang_dir.clear()
-    lang_dict.update(dict((v, k) for k, v in data['langs'].items()))
-    lang_dir.extend(data['dirs'])
+    lang_dict.update(dict((v, k) for k, v in data["langs"].items()))
+    lang_dir.extend(data["dirs"])
 
 
 def check_code(code):
     """checks the return code for the calls to yandex"""
     codes = {
-        401: 'Invalid API key.',
-        402: 'This API key has been blocked',
-        403: 'The daily limit for requests has been reached',
-        404: 'The daily limit of translated text has been reached',
-        413: 'The text exceeds the maximum',
-        422: 'The text could not be translated',
-        501: 'The specified translation direction is not supported'
+        401: "Invalid API key.",
+        402: "This API key has been blocked",
+        403: "The daily limit for requests has been reached",
+        404: "The daily limit of translated text has been reached",
+        413: "The text exceeds the maximum",
+        422: "The text could not be translated",
+        501: "The specified translation direction is not supported",
     }
     try:
         out = codes[code]
@@ -57,20 +56,21 @@ def list_langs():
         return "This command requires a Yandex Translate API key"
 
     url = api_url + "getLangs"
-    params = {
-        'key': api_key,
-        'ui': 'en'
-    }
+    params = {"key": api_key, "ui": "en"}
     r = requests.get(url, params=params)
     r.raise_for_status()
     data = r.json()
-    langs = data['langs']
+    langs = data["langs"]
     out = "Language Codes:"
-    out += ",".join("\n{}-{}".format(key, value) for (key, value) in sorted(langs.items()))
+    out += ",".join(
+        "\n{}-{}".format(key, value) for (key, value) in sorted(langs.items())
+    )
     out += "\n\nTranslation directions:"
-    out += ",".join("\n{}".format(code) for code in data['dirs'])
+    out += ",".join("\n{}".format(code) for code in data["dirs"])
     paste = web.paste(out, ext="txt")
-    return "Here is information on what I can translate as well as valid language codes. {}".format(paste)
+    return "Here is information on what I can translate as well as valid language codes. {}".format(
+        paste
+    )
 
 
 @hook.command("tran", "translate")
@@ -83,25 +83,22 @@ def trans(text, reply, event):
     if not api_key:
         return "This command requires a Yandex Translate API key"
 
-    inp = text.split(' ', 1)
+    inp = text.split(" ", 1)
     if len(inp) < 2:
         event.notice_doc()
         return None
 
-    lang = inp[0].replace(':', '')
+    lang = inp[0].replace(":", "")
     text = inp[1]
     if lang.title() in lang_dict.keys():
         lang = lang_dict[lang.title()]
     elif lang not in lang_dict.values() and lang not in lang_dir:
-        return "Please specify a valid language, language code, to translate to. Use .langlist for more information " \
-               "on language codes and valid translation directions."
+        return (
+            "Please specify a valid language, language code, to translate to. Use .langlist for more information "
+            "on language codes and valid translation directions."
+        )
     url = api_url + "translate"
-    params = {
-        'key': api_key,
-        'lang': lang,
-        'text': text,
-        'options': 1
-    }
+    params = {"key": api_key, "lang": lang, "text": text, "options": 1}
 
     try:
         r = requests.get(url, params=params)
@@ -114,5 +111,5 @@ def trans(text, reply, event):
         raise
 
     data = r.json()
-    out = "Translation ({}): {}".format(data['lang'], data['text'][0])
+    out = "Translation ({}): {}".format(data["lang"], data["text"][0])
     return out
diff --git a/plugins/yelling.py b/plugins/yelling.py
index 580ce34b..237800f5 100644
--- a/plugins/yelling.py
+++ b/plugins/yelling.py
@@ -4,8 +4,10 @@
 from cloudbot.event import EventType
 
 OPT_IN = ["#yelling"]
-YELL_RE = re.compile('[^a-zA-Z]')
-URL_RE = re.compile(r'[a-z]+://\S+', re.IGNORECASE)  # Ignore possible URLs as they are case-sensitive
+YELL_RE = re.compile("[^a-zA-Z]")
+URL_RE = re.compile(
+    r"[a-z]+://\S+", re.IGNORECASE
+)  # Ignore possible URLs as they are case-sensitive
 
 
 @hook.event([EventType.message, EventType.action], clients=["irc"])
@@ -20,18 +22,18 @@ def yell_check(conn, chan, content, bot, nick):
     if chan.casefold() not in OPT_IN:
         return
 
-    link_announcer = bot.plugin_manager.find_plugin('link_announcer')
+    link_announcer = bot.plugin_manager.find_plugin("link_announcer")
     if link_announcer:
         url_re = link_announcer.code.url_re
     else:
         url_re = URL_RE
 
-    text = url_re.sub('', content)
-    text = YELL_RE.sub('', text)
+    text = url_re.sub("", content)
+    text = YELL_RE.sub("", text)
     if not text:
         # Ignore empty strings
         return
 
     caps_count = sum(1 for c in text if c.isupper())
-    if (caps_count / len(text)) < .75:
+    if (caps_count / len(text)) < 0.75:
         conn.cmd("KICK", chan, nick, "USE MOAR CAPS YOU TROGLODYTE!")
diff --git a/plugins/youtube.py b/plugins/youtube.py
index e33bc69d..a080d7e6 100644
--- a/plugins/youtube.py
+++ b/plugins/youtube.py
@@ -10,10 +10,12 @@
 from cloudbot.util.formatting import pluralize_suffix
 
 youtube_re = re.compile(
-    r"(?:youtube.*?(?:v=|/v/)|youtu\.be/|yooouuutuuube.*?id=)([-_a-zA-Z0-9]+)", re.I
+    r"(?:youtube.*?(?:v=|/v/)|youtu\.be/|yooouuutuuube.*?id=)([-_a-zA-Z0-9]+)",
+    re.I,
 )
 ytpl_re = re.compile(
-    r"(.*:)//(www.youtube.com/playlist|youtube.com/playlist)(:[0-9]+)?(.*)", re.I
+    r"(.*:)//(www.youtube.com/playlist|youtube.com/playlist)(:[0-9]+)?(.*)",
+    re.I,
 )
 
 
@@ -44,7 +46,7 @@ def raise_api_errors(response: requests.Response) -> None:
         try:
             data = response.json()
         except ValueError:
-            raise e
+            raise e from None
 
         errors = data.get("errors")
         if not errors:
@@ -69,7 +71,10 @@ def make_short_url(video_id: str) -> str:
 
 
 def do_request(
-    method: str, parts: Parts, params: Optional[ParamMap] = None, **kwargs: ParamValues
+    method: str,
+    parts: Parts,
+    params: Optional[ParamMap] = None,
+    **kwargs: ParamValues,
 ) -> requests.Response:
     api_key = bot.config.get_api_key("google_dev_key")
     if not api_key:
@@ -88,12 +93,16 @@ def get_video(video_id: str, parts: Parts) -> requests.Response:
 
 
 def get_playlist(playlist_id: str, parts: Parts) -> requests.Response:
-    return do_request("playlists", parts, params={"maxResults": 1, "id": playlist_id})
+    return do_request(
+        "playlists", parts, params={"maxResults": 1, "id": playlist_id}
+    )
 
 
 def do_search(term: str, result_type: str = "video") -> requests.Response:
     return do_request(
-        "search", ["snippet"], params={"maxResults": 1, "q": term, "type": result_type}
+        "search",
+        ["snippet"],
+        params={"maxResults": 1, "q": term, "type": result_type},
     )
 
 
@@ -123,7 +132,9 @@ def get_video_description(video_id: str) -> str:
         timeformat.format_time(int(length.total_seconds()), simple=True)
     )
     try:
-        total_votes = float(statistics["likeCount"]) + float(statistics["dislikeCount"])
+        total_votes = float(statistics["likeCount"]) + float(
+            statistics["dislikeCount"]
+        )
     except (LookupError, ValueError):
         total_votes = 0
 
@@ -183,7 +194,9 @@ def youtube(text: str, reply) -> str:
     """<query> - Returns the first YouTube search result for <query>."""
     try:
         video_id = get_video_id(text)
-        return get_video_description(video_id) + " - " + make_short_url(video_id)
+        return (
+            get_video_description(video_id) + " - " + make_short_url(video_id)
+        )
     except NoResultsError as e:
         return e.message
     except APIError as e:
@@ -252,5 +265,7 @@ def ytplaylist_url(match: Match[str]) -> str:
     title = snippet["title"]
     author = snippet["channelTitle"]
     num_videos = int(content_details["itemCount"])
-    count_videos = " - \x02{:,}\x02 video{}".format(num_videos, "s"[num_videos == 1 :])
+    count_videos = " - \x02{:,}\x02 video{}".format(
+        num_videos, "s"[num_videos == 1 :]
+    )
     return "\x02{}\x02 {} - \x02{}\x02".format(title, count_videos, author)
diff --git a/tests/core_tests/test_hook.py b/tests/core_tests/test_hook.py
index 235eddab..77d11e48 100644
--- a/tests/core_tests/test_hook.py
+++ b/tests/core_tests/test_hook.py
@@ -5,51 +5,52 @@
 
 def test_hook_decorate():
     from cloudbot import hook
-
     from cloudbot.event import EventType
 
     @hook.event(EventType.message)
     @hook.event([EventType.notice, EventType.action])
-    @hook.command('test')
-    @hook.irc_raw('*')
-    @hook.irc_raw(['PRIVMSG'])
+    @hook.command("test")
+    @hook.irc_raw("*")
+    @hook.irc_raw(["PRIVMSG"])
     @hook.irc_out()
     @hook.on_stop()
     @hook.on_start()
-    @hook.regex(['test', re.compile('test')])
-    @hook.regex('test1')
-    @hook.regex(re.compile('test2'))
+    @hook.regex(["test", re.compile("test")])
+    @hook.regex("test1")
+    @hook.regex(re.compile("test2"))
     @hook.periodic(20)
-    @hook.permission('perm')
+    @hook.permission("perm")
     @hook.post_hook()
     @hook.on_connect()
-    @hook.on_cap_ack('capname')
-    @hook.on_cap_available('capname')
+    @hook.on_cap_ack("capname")
+    @hook.on_cap_available("capname")
     def f():
         pass  # pragma: no cover
 
-    assert f._cloudbot_hook['event'].types == {
-        EventType.message, EventType.notice, EventType.action
+    assert f._cloudbot_hook["event"].types == {
+        EventType.message,
+        EventType.notice,
+        EventType.action,
     }
-    assert f._cloudbot_hook['command'].aliases == {'test'}
-    assert f._cloudbot_hook['irc_raw'].triggers == {'*', 'PRIVMSG'}
-
-    assert 'irc_out' in f._cloudbot_hook
-    assert 'on_start' in f._cloudbot_hook
-    assert 'on_stop' in f._cloudbot_hook
-    assert 'regex' in f._cloudbot_hook
-    assert 'periodic' in f._cloudbot_hook
-    assert 'perm_check' in f._cloudbot_hook
-    assert 'post_hook' in f._cloudbot_hook
-    assert 'on_connect' in f._cloudbot_hook
-    assert 'on_cap_available' in f._cloudbot_hook
-    assert 'on_cap_ack' in f._cloudbot_hook
-
-    assert len(f._cloudbot_hook['regex'].regexes) == 4
-    assert f._cloudbot_hook['periodic'].interval == 20
+    assert f._cloudbot_hook["command"].aliases == {"test"}
+    assert f._cloudbot_hook["irc_raw"].triggers == {"*", "PRIVMSG"}
+
+    assert "irc_out" in f._cloudbot_hook
+    assert "on_start" in f._cloudbot_hook
+    assert "on_stop" in f._cloudbot_hook
+    assert "regex" in f._cloudbot_hook
+    assert "periodic" in f._cloudbot_hook
+    assert "perm_check" in f._cloudbot_hook
+    assert "post_hook" in f._cloudbot_hook
+    assert "on_connect" in f._cloudbot_hook
+    assert "on_cap_available" in f._cloudbot_hook
+    assert "on_cap_ack" in f._cloudbot_hook
+
+    assert len(f._cloudbot_hook["regex"].regexes) == 4
+    assert f._cloudbot_hook["periodic"].interval == 20
 
     with pytest.raises(ValueError, match="Invalid command name test 123"):
-        hook.command('test 123')(f)
+        hook.command("test 123")(f)
 
     with pytest.raises(TypeError):
         hook.periodic(f)
@@ -67,13 +68,13 @@ def f():
     def sieve_func(bot, event, _hook):
         pass  # pragma: no cover
 
-    assert 'sieve' in sieve_func._cloudbot_hook
+    assert "sieve" in sieve_func._cloudbot_hook
 
     @hook.sieve()
     def sieve_func2(bot, event, _hook):
         pass  # pragma: no cover
 
-    assert 'sieve' in sieve_func2._cloudbot_hook
+    assert "sieve" in sieve_func2._cloudbot_hook
 
     @hook.on_connect
     @hook.irc_out
@@ -83,11 +84,11 @@ def sieve_func2(bot, event, _hook):
     def plain_dec(bot, event, _hook):
         pass  # pragma: no cover
 
-    assert 'on_connect' in plain_dec._cloudbot_hook
-    assert 'irc_out' in plain_dec._cloudbot_hook
-    assert 'post_hook' in plain_dec._cloudbot_hook
-    assert 'on_start' in plain_dec._cloudbot_hook
-    assert 'on_stop' in plain_dec._cloudbot_hook
+    assert "on_connect" in plain_dec._cloudbot_hook
+    assert "irc_out" in plain_dec._cloudbot_hook
+    assert "post_hook" in plain_dec._cloudbot_hook
+    assert "on_start" in plain_dec._cloudbot_hook
+    assert "on_stop" in plain_dec._cloudbot_hook
 
 
 def test_command_hook_doc():
@@ -101,7 +102,7 @@ def test(bot):
 
         :type bot: object"""
 
-    cmd_hook = test._cloudbot_hook['command']
+    cmd_hook = test._cloudbot_hook["command"]
     assert cmd_hook.doc == "<arg> - foo bar baz"
 
     @hook.command
@@ -110,14 +111,14 @@ def test1(bot):
 
         :type bot: object"""
 
-    cmd_hook = test1._cloudbot_hook['command']
+    cmd_hook = test1._cloudbot_hook["command"]
     assert cmd_hook.doc == "<arg> - foo bar baz"
 
     @hook.command
     def test2(bot):
         """<arg> - foo bar baz"""
 
-    cmd_hook = test2._cloudbot_hook['command']
+    cmd_hook = test2._cloudbot_hook["command"]
     assert cmd_hook.doc == "<arg> - foo bar baz"
 
     @hook.command
@@ -126,13 +127,12 @@ def test3(bot):
         <arg> - foo bar baz
         """
 
-    cmd_hook = test3._cloudbot_hook['command']
+    cmd_hook = test3._cloudbot_hook["command"]
     assert cmd_hook.doc == "<arg> - foo bar baz"
 
     @hook.command
     def test4(bot):
-        """<arg> - foo bar baz
-        """
+        """<arg> - foo bar baz"""
 
-    cmd_hook = test4._cloudbot_hook['command']
+    cmd_hook = test4._cloudbot_hook["command"]
     assert cmd_hook.doc == "<arg> - foo bar baz"
diff --git a/tests/core_tests/test_permission_manager.py b/tests/core_tests/test_permission_manager.py
index 60522832..d1d7fbb1 100644
--- a/tests/core_tests/test_permission_manager.py
+++ b/tests/core_tests/test_permission_manager.py
@@ -7,93 +7,92 @@ def __init__(self, name, config):
 def test_manager_load():
     import cloudbot.permissions
     from cloudbot.permissions import PermissionManager
-    manager = PermissionManager(MockConn('testconn', {}))
+
+    manager = PermissionManager(MockConn("testconn", {}))
 
     assert not manager.group_perms
     assert not manager.group_users
     assert not manager.perm_users
     assert not manager.get_groups()
-    assert not manager.get_group_permissions('foobar')
-    assert not manager.get_group_users('foobar')
-    assert not manager.get_user_permissions('foo!bar@baz')
-    assert not manager.get_user_groups('foo!bar@baz')
-    assert not manager.group_exists('baz')
-    assert not manager.user_in_group('foo!bar@baz', 'bing')
+    assert not manager.get_group_permissions("foobar")
+    assert not manager.get_group_users("foobar")
+    assert not manager.get_user_permissions("foo!bar@baz")
+    assert not manager.get_user_groups("foo!bar@baz")
+    assert not manager.group_exists("baz")
+    assert not manager.user_in_group("foo!bar@baz", "bing")
 
     cloudbot.permissions.backdoor = "*!user@host"
 
-    assert manager.has_perm_mask("test!user@host", 'foo', False)
-    assert not manager.has_perm_mask("test!otheruser@host", 'foo', False)
+    assert manager.has_perm_mask("test!user@host", "foo", False)
+    assert not manager.has_perm_mask("test!otheruser@host", "foo", False)
 
-    user = 'user!a@host.com'
-    user_mask = 'user!*@host??om'
+    user = "user!a@host.com"
+    user_mask = "user!*@host??om"
 
-    other_user = 'user1!b@hosaacom'
+    other_user = "user1!b@hosaacom"
 
     cloudbot.permissions.backdoor = None
-    manager = PermissionManager(MockConn('testconn', {
-        'permissions': {
-            'admins': {
-                'users': [
-                    user_mask
-                ],
-                'perms': [
-                    'testperm'
-                ]
-            }
-        }
-    }))
-    assert manager.group_exists('admins')
-    assert manager.get_groups() == {'admins'}
-    assert manager.get_user_groups(user) == ['admins']
+    manager = PermissionManager(
+        MockConn(
+            "testconn",
+            {
+                "permissions": {
+                    "admins": {"users": [user_mask], "perms": ["testperm"]}
+                }
+            },
+        )
+    )
+    assert manager.group_exists("admins")
+    assert manager.get_groups() == {"admins"}
+    assert manager.get_user_groups(user) == ["admins"]
     assert not manager.get_user_groups(other_user)
-    assert manager.get_group_users('admins') == [user_mask]
-    assert manager.get_group_permissions('admins') == ['testperm']
-    assert manager.get_user_permissions(user) == {'testperm'}
+    assert manager.get_group_users("admins") == [user_mask]
+    assert manager.get_group_permissions("admins") == ["testperm"]
+    assert manager.get_user_permissions(user) == {"testperm"}
     assert not manager.get_user_permissions(other_user)
-    assert manager.has_perm_mask(user, 'testperm')
-    assert manager.user_in_group(user, 'admins')
-    assert not manager.user_in_group(other_user, 'admins')
+    assert manager.has_perm_mask(user, "testperm")
+    assert manager.user_in_group(user, "admins")
+    assert not manager.user_in_group(other_user, "admins")
 
-    assert manager.remove_group_user('admins', user) == [user_mask]
+    assert manager.remove_group_user("admins", user) == [user_mask]
     manager.reload()
 
-    assert 'admins' not in manager.get_user_groups(user)
-    assert user_mask not in manager.get_group_users('admins')
-    assert 'testperm' not in manager.get_user_permissions(user)
-    assert not manager.has_perm_mask(user, 'testperm')
-    assert not manager.user_in_group(user, 'admins')
+    assert "admins" not in manager.get_user_groups(user)
+    assert user_mask not in manager.get_group_users("admins")
+    assert "testperm" not in manager.get_user_permissions(user)
+    assert not manager.has_perm_mask(user, "testperm")
+    assert not manager.user_in_group(user, "admins")
 
 
 def test_mix_case_group():
     from cloudbot.permissions import PermissionManager
-    manager = PermissionManager(MockConn('testconn', {
-        'permissions': {
-            'Admins': {
-                'users': [
-                    '*!*@host'
-                ],
-                'perms': [
-                    'testperm'
-                ]
-            }
-        }
-    }))
-
-    assert manager.group_exists('admins')
-    manager.remove_group_user('admins', 'user!name@host')
+
+    manager = PermissionManager(
+        MockConn(
+            "testconn",
+            {
+                "permissions": {
+                    "Admins": {"users": ["*!*@host"], "perms": ["testperm"]}
+                }
+            },
+        )
+    )
+
+    assert manager.group_exists("admins")
+    manager.remove_group_user("admins", "user!name@host")
     manager.reload()
-    assert manager.user_in_group('user!name@host', 'admins')
+    assert manager.user_in_group("user!name@host", "admins")
 
 
 def test_add_user_to_group():
     from cloudbot.permissions import PermissionManager
-    manager = PermissionManager(MockConn('testconn', {}))
-    manager.add_user_to_group('*!*@host', 'admins')
-    manager.add_user_to_group('*!*@mask', 'admins')
+
+    manager = PermissionManager(MockConn("testconn", {}))
+    manager.add_user_to_group("*!*@host", "admins")
+    manager.add_user_to_group("*!*@mask", "admins")
     manager.reload()
-    assert manager.user_in_group('user!name@host', 'admins')
-    assert manager.user_in_group('otheruser!name@mask', 'admins')
-    manager.add_user_to_group('*!*@mask', 'admins')
+    assert manager.user_in_group("user!name@host", "admins")
+    assert manager.user_in_group("otheruser!name@mask", "admins")
+    manager.add_user_to_group("*!*@mask", "admins")
     manager.reload()
-    assert len(manager.get_group_users('admins')) == 2
+    assert len(manager.get_group_users("admins")) == 2
diff --git a/tests/core_tests/util_tests/test_formatting.py b/tests/core_tests/util_tests/test_formatting.py
index 067c7eec..9c6976e1 100644
--- a/tests/core_tests/util_tests/test_formatting.py
+++ b/tests/core_tests/util_tests/test_formatting.py
@@ -61,7 +61,13 @@
 test_ireplace_input = "The quick brown FOX fox FOX jumped over the lazy dog"
 
 test_chunk_str_input = "The quick brown fox jumped over the lazy dog"
-test_chunk_str_result = ['The quick', 'brown fox', 'jumped', 'over the', 'lazy dog']
+test_chunk_str_result = [
+    "The quick",
+    "brown fox",
+    "jumped",
+    "over the",
+    "lazy dog",
+]
 
 
 def test_munge():
@@ -70,30 +76,41 @@ def test_munge():
 
 
 def test_dict_format():
-    assert dict_format(test_format_data, test_format_formats) == test_format_result
+    assert (
+        dict_format(test_format_data, test_format_formats) == test_format_result
+    )
     assert dict_format({}, test_format_formats) is None
 
 
 def test_pluralize():
-    assert pluralize_suffix(test_pluralize_num_a, test_pluralize_text) == test_pluralize_result_a
-    assert pluralize_suffix(test_pluralize_num_b, test_pluralize_text) == test_pluralize_result_b
-
-
-@pytest.mark.parametrize('item,count,output', [
-    ('foo', 1, '1 foo'),
-    ('bar', 2, '2 bars'),
-    ('foos', 2, '2 fooses'),
-    ('leaf', 2, '2 leaves'),
-    ('city', 2, '2 cities'),
-    ('day', 2, '2 days'),
-    ('foe', 2, '2 foes'),
-    ('volcano', 2, '2 volcanoes'),
-    ('radius', 2, '2 radii'),
-    ('hoof', 2, '2 hooves'),
-    ('axis', 2, '2 axes'),
-    ('automaton', 2, '2 automata'),
-    ('tree', 2, '2 trees'),
-])
+    assert (
+        pluralize_suffix(test_pluralize_num_a, test_pluralize_text)
+        == test_pluralize_result_a
+    )
+    assert (
+        pluralize_suffix(test_pluralize_num_b, test_pluralize_text)
+        == test_pluralize_result_b
+    )
+
+
+@pytest.mark.parametrize(
+    "item,count,output",
+    [
+        ("foo", 1, "1 foo"),
+        ("bar", 2, "2 bars"),
+        ("foos", 2, "2 fooses"),
+        ("leaf", 2, "2 leaves"),
+        ("city", 2, "2 cities"),
+        ("day", 2, "2 days"),
+        ("foe", 2, "2 foes"),
+        ("volcano", 2, "2 volcanoes"),
+        ("radius", 2, "2 radii"),
+        ("hoof", 2, "2 hooves"),
+        ("axis", 2, "2 axes"),
+        ("automaton", 2, "2 automata"),
+        ("tree", 2, "2 trees"),
+    ],
+)
 def test_auto_pluralize(item, count, output):
     assert pluralize_auto(count, item) == output
 
@@ -104,20 +121,40 @@ def test_strip_colors():
 
 
 def test_truncate_str():
-    assert truncate(test_truncate_str_input, length=test_truncate_str_length_a) == test_truncate_str_result_a
-    assert truncate(test_truncate_str_input, length=test_truncate_str_length_b) == test_truncate_str_result_b
+    assert (
+        truncate(test_truncate_str_input, length=test_truncate_str_length_a)
+        == test_truncate_str_result_a
+    )
+    assert (
+        truncate(test_truncate_str_input, length=test_truncate_str_length_b)
+        == test_truncate_str_result_b
+    )
 
     # compatibility
-    assert truncate_str(test_truncate_str_input, length=test_truncate_str_length_a) == test_truncate_str_result_a
-    assert truncate_str(test_truncate_str_input, length=test_truncate_str_length_b) == test_truncate_str_result_b
+    assert (
+        truncate_str(test_truncate_str_input, length=test_truncate_str_length_a)
+        == test_truncate_str_result_a
+    )
+    assert (
+        truncate_str(test_truncate_str_input, length=test_truncate_str_length_b)
+        == test_truncate_str_result_b
+    )
 
 
 # noinspection PyPep8
 def test_truncate_words():
-    assert truncate_words(test_truncate_words_input, length=test_truncate_words_length_a) == \
-           test_truncate_words_result_a
-    assert truncate_words(test_truncate_words_input, length=test_truncate_words_length_b) == \
-           test_truncate_words_result_b
+    assert (
+        truncate_words(
+            test_truncate_words_input, length=test_truncate_words_length_a
+        )
+        == test_truncate_words_result_a
+    )
+    assert (
+        truncate_words(
+            test_truncate_words_input, length=test_truncate_words_length_b
+        )
+        == test_truncate_words_result_b
+    )
 
 
 def test_strip_html():
@@ -125,17 +162,37 @@ def test_strip_html():
 
 
 def test_multiword_replace():
-    assert multi_replace(test_multiword_replace_text, test_multiword_replace_dict) == test_multiword_replace_result
+    assert (
+        multi_replace(test_multiword_replace_text, test_multiword_replace_dict)
+        == test_multiword_replace_result
+    )
 
     # compatibility
-    assert multiword_replace(test_multiword_replace_text, test_multiword_replace_dict) == test_multiword_replace_result
+    assert (
+        multiword_replace(
+            test_multiword_replace_text, test_multiword_replace_dict
+        )
+        == test_multiword_replace_result
+    )
 
 
 def test_ireplace():
-    assert ireplace(test_ireplace_input, "fox", "cat") == "The quick brown cat cat cat jumped over the lazy dog"
-    assert ireplace(test_ireplace_input, "FOX", "cAt") == "The quick brown cAt cAt cAt jumped over the lazy dog"
-    assert ireplace(test_ireplace_input, "fox", "cat", 1) == "The quick brown cat fox FOX jumped over the lazy dog"
-    assert ireplace(test_ireplace_input, "fox", "cat", 2) == "The quick brown cat cat FOX jumped over the lazy dog"
+    assert (
+        ireplace(test_ireplace_input, "fox", "cat")
+        == "The quick brown cat cat cat jumped over the lazy dog"
+    )
+    assert (
+        ireplace(test_ireplace_input, "FOX", "cAt")
+        == "The quick brown cAt cAt cAt jumped over the lazy dog"
+    )
+    assert (
+        ireplace(test_ireplace_input, "fox", "cat", 1)
+        == "The quick brown cat fox FOX jumped over the lazy dog"
+    )
+    assert (
+        ireplace(test_ireplace_input, "fox", "cat", 2)
+        == "The quick brown cat cat FOX jumped over the lazy dog"
+    )
 
     # test blank input - this should behave like the native string.replace()
     assert ireplace("Hello", "", "?") == "?H?e?l?l?o?"
@@ -146,28 +203,46 @@ def test_chunk_str():
 
 
 def test_get_text_list():
-    assert get_text_list(['a', 'b', 'c', 'd']) == 'a, b, c or d'
-    assert get_text_list(['a', 'b', 'c'], 'and') == 'a, b and c'
-    assert get_text_list(['a', 'b'], 'and') == 'a and b'
-    assert get_text_list(['a']) == 'a'
-    assert get_text_list([]) == ''
+    assert get_text_list(["a", "b", "c", "d"]) == "a, b, c or d"
+    assert get_text_list(["a", "b", "c"], "and") == "a, b and c"
+    assert get_text_list(["a", "b"], "and") == "a and b"
+    assert get_text_list(["a"]) == "a"
+    assert get_text_list([]) == ""
 
 
 def test_smart_split():
-    assert list(smart_split(r'This is "a person\'s" test.')) == ['This', 'is', '"a person\\\'s"', 'test.']
-    assert list(smart_split(r"Another 'person\'s' test.")) == ['Another', "'person\\'s'", 'test.']
-    assert list(smart_split(r'A "\"funky\" style" test.')) == ['A', '"\\"funky\\" style"', 'test.']
+    assert list(smart_split(r'This is "a person\'s" test.')) == [
+        "This",
+        "is",
+        '"a person\\\'s"',
+        "test.",
+    ]
+    assert list(smart_split(r"Another 'person\'s' test.")) == [
+        "Another",
+        "'person\\'s'",
+        "test.",
+    ]
+    assert list(smart_split(r'A "\"funky\" style" test.')) == [
+        "A",
+        '"\\"funky\\" style"',
+        "test.",
+    ]
 
 
 def test_gen_md_table():
-    headers = ['ColumnA', 'Column B']
+    headers = ["ColumnA", "Column B"]
     data = [
-        ['1', '2'],
-        ['3', '4'],
+        ["1", "2"],
+        ["3", "4"],
     ]
-    assert gen_markdown_table(headers, data) == dedent("""
+    assert (
+        gen_markdown_table(headers, data)
+        == dedent(
+            """
     | ColumnA | Column B |
     | ------- | -------- |
     | 1       | 2        |
     | 3       | 4        |
-    """).strip()
+    """
+        ).strip()
+    )
diff --git a/tests/core_tests/util_tests/test_func_utils.py b/tests/core_tests/util_tests/test_func_utils.py
index ae59a44f..71839b77 100644
--- a/tests/core_tests/util_tests/test_func_utils.py
+++ b/tests/core_tests/util_tests/test_func_utils.py
@@ -8,8 +8,9 @@ def func(arg1, arg2=None, _arg3=None):
         nonlocal args
         args = [arg1, arg2, _arg3]
 
-    from cloudbot.util.func_utils import call_with_args, ParameterError
-    call_with_args(func, {'arg1': 1, 'arg2': 3})
+    from cloudbot.util.func_utils import ParameterError, call_with_args
+
+    call_with_args(func, {"arg1": 1, "arg2": 3})
     assert args == [1, 3, None]
 
     with pytest.raises(ParameterError):
diff --git a/tests/core_tests/util_tests/test_http.py b/tests/core_tests/util_tests/test_http.py
index 894285c0..128b0e28 100644
--- a/tests/core_tests/util_tests/test_http.py
+++ b/tests/core_tests/util_tests/test_http.py
@@ -9,7 +9,8 @@ def test_get_soup():
         </body>
     </html>
     """
-    with patch('cloudbot.util.http.get', lambda *a, **k: test_data):
+    with patch("cloudbot.util.http.get", lambda *a, **k: test_data):
         from cloudbot.util import http
-        soup = http.get_soup('http://example.com')
-        assert soup.find('div', {'class': "thing"}).p.text == "foobar"
+
+        soup = http.get_soup("http://example.com")
+        assert soup.find("div", {"class": "thing"}).p.text == "foobar"
diff --git a/tests/core_tests/util_tests/test_mapping.py b/tests/core_tests/util_tests/test_mapping.py
index 84b51699..1e0398f4 100644
--- a/tests/core_tests/util_tests/test_mapping.py
+++ b/tests/core_tests/util_tests/test_mapping.py
@@ -5,25 +5,25 @@ class TestKeyFoldDict:
     @staticmethod
     def test_get():
         data = KeyFoldDict()
-        data['TEST'] = 1
+        data["TEST"] = 1
 
-        assert data.get('TEST') == 1
-        assert data.get('TeST') == 1
-        assert data.get('test') == 1
+        assert data.get("TEST") == 1
+        assert data.get("TeST") == 1
+        assert data.get("test") == 1
 
     @staticmethod
     def test_setdefault():
         data = KeyFoldDict()
 
-        data['test'] = 2
+        data["test"] = 2
 
-        assert data.setdefault('TEST', 1) == 2
+        assert data.setdefault("TEST", 1) == 2
 
-        assert data['TEST'] == 2
+        assert data["TEST"] == 2
 
-        assert data.setdefault('STUFF', 5) == 5
+        assert data.setdefault("STUFF", 5) == 5
 
-        assert data['stuff'] == 5
+        assert data["stuff"] == 5
 
     @staticmethod
     def test_update_kwargs():
@@ -31,49 +31,45 @@ def test_update_kwargs():
 
         data.update(a=1, B=2, vAR=3, VAL=4, mapping=5)
 
-        assert data['a'] == 1
-        assert data['A'] == 1
-        assert data['b'] == 2
-        assert data['B'] == 2
-        assert data['var'] == 3
-        assert data['vAr'] == 3
-        assert data['VAR'] == 3
-        assert data['val'] == 4
-        assert data['VAL'] == 4
-        assert data['Val'] == 4
-        assert data['mapping'] == 5
-        assert data['MAPPING'] == 5
-        assert data['maPPiNg'] == 5
+        assert data["a"] == 1
+        assert data["A"] == 1
+        assert data["b"] == 2
+        assert data["B"] == 2
+        assert data["var"] == 3
+        assert data["vAr"] == 3
+        assert data["VAR"] == 3
+        assert data["val"] == 4
+        assert data["VAL"] == 4
+        assert data["Val"] == 4
+        assert data["mapping"] == 5
+        assert data["MAPPING"] == 5
+        assert data["maPPiNg"] == 5
 
     @staticmethod
     def test_update_mapping():
         data = KeyFoldDict()
 
-        data.update({'a': 1, 'B': 2, 'woRDs1': 3})
+        data.update({"a": 1, "B": 2, "woRDs1": 3})
 
-        assert data['a'] == 1
-        assert data['A'] == 1
-        assert data['b'] == 2
-        assert data['B'] == 2
-        assert data['words1'] == 3
-        assert data['WORDS1'] == 3
-        assert data['worDs1'] == 3
+        assert data["a"] == 1
+        assert data["A"] == 1
+        assert data["b"] == 2
+        assert data["B"] == 2
+        assert data["words1"] == 3
+        assert data["WORDS1"] == 3
+        assert data["worDs1"] == 3
 
     @staticmethod
     def test_update_sequence():
         data = KeyFoldDict()
 
-        data.update([
-            ('a', 1),
-            ('B', 2),
-            ('SEa', 3)
-        ])
-
-        assert data['a'] == 1
-        assert data['A'] == 1
-        assert data['b'] == 2
-        assert data['B'] == 2
-        assert data['sea'] == 3
-        assert data['SEA'] == 3
-        assert data['SeA'] == 3
-        assert data['Sea'] == 3
+        data.update([("a", 1), ("B", 2), ("SEa", 3)])
+
+        assert data["a"] == 1
+        assert data["A"] == 1
+        assert data["b"] == 2
+        assert data["B"] == 2
+        assert data["sea"] == 3
+        assert data["SEA"] == 3
+        assert data["SeA"] == 3
+        assert data["Sea"] == 3
diff --git a/tests/core_tests/util_tests/test_sequence.py b/tests/core_tests/util_tests/test_sequence.py
index 8d6ed8b9..2599ee33 100644
--- a/tests/core_tests/util_tests/test_sequence.py
+++ b/tests/core_tests/util_tests/test_sequence.py
@@ -1,5 +1,4 @@
-
-
 def test_chunk_iter():
     from cloudbot.util.sequence import chunk_iter
+
     assert len(list(chunk_iter([1, 2, 3, 4, 5, 6, 7, 8, 9], 2))) == 5
diff --git a/tests/core_tests/util_tests/test_textgen.py b/tests/core_tests/util_tests/test_textgen.py
index 83e63c8c..97af0b7a 100644
--- a/tests/core_tests/util_tests/test_textgen.py
+++ b/tests/core_tests/util_tests/test_textgen.py
@@ -3,45 +3,45 @@
 
 def test_textgenerator():
     from cloudbot.util.textgen import TextGenerator
+
     generator = TextGenerator(
-        [
-            '{thing} is {stuff}'
-        ],
+        ["{thing} is {stuff}"],
         {
-            'thing': ['a', 'b'],
-            'stuff': [
-                'c',
-                ('d', 2),
-            ]
-        }
+            "thing": ["a", "b"],
+            "stuff": [
+                "c",
+                ("d", 2),
+            ],
+        },
     )
 
     for s in generator.generate_strings(4):
-        assert re.match(r'[ab] is [cd]', s)
+        assert re.match(r"[ab] is [cd]", s)
 
-    assert generator.get_template(0) == '{thing} is {stuff}'
+    assert generator.get_template(0) == "{thing} is {stuff}"
 
 
 def test_textgen_default_tmpl():
     from cloudbot.util.textgen import TextGenerator
+
     generator = TextGenerator(
         [
-            '{thing} is {stuff} {a}',
-            '{thing} are {stuff} {a}',
+            "{thing} is {stuff} {a}",
+            "{thing} are {stuff} {a}",
         ],
         {
-            'thing': ['a', 'b'],
-            'stuff': [
-                'c',
-                ('d', 2),
-            ]
+            "thing": ["a", "b"],
+            "stuff": [
+                "c",
+                ("d", 2),
+            ],
         },
         default_templates=[1],
-        variables={'a': 'foo'}
+        variables={"a": "foo"},
     )
 
     for s in generator.generate_strings(4):
-        assert re.match(r'[ab] are [cd] foo', s)
+        assert re.match(r"[ab] are [cd] foo", s)
 
-    assert generator.get_template(0) == '{thing} is {stuff} {a}'
-    assert generator.get_template(1) == '{thing} are {stuff} {a}'
+    assert generator.get_template(0) == "{thing} is {stuff} {a}"
+    assert generator.get_template(1) == "{thing} are {stuff} {a}"
diff --git a/tests/core_tests/util_tests/test_timeformat.py b/tests/core_tests/util_tests/test_timeformat.py
index 86465262..485fb85d 100644
--- a/tests/core_tests/util_tests/test_timeformat.py
+++ b/tests/core_tests/util_tests/test_timeformat.py
@@ -8,7 +8,10 @@ def test_format_time():
     assert format_time(120000) == "1 day, 9 hours and 20 minutes"
     assert format_time(120000, simple=True) == "1d 9h 20m"
     # count
-    assert format_time(1200003, count=4) == "13 days, 21 hours, 20 minutes and 3 seconds"
+    assert (
+        format_time(1200003, count=4)
+        == "13 days, 21 hours, 20 minutes and 3 seconds"
+    )
     assert format_time(1200000, count=4) == "13 days, 21 hours and 20 minutes"
     assert format_time(1200000, count=2) == "13 days and 21 hours"
 
diff --git a/tests/core_tests/util_tests/test_timeparse.py b/tests/core_tests/util_tests/test_timeparse.py
index 93da64b2..cf39758a 100644
--- a/tests/core_tests/util_tests/test_timeparse.py
+++ b/tests/core_tests/util_tests/test_timeparse.py
@@ -1,12 +1,13 @@
 def test_time_parse():
     from cloudbot.util.timeparse import time_parse
-    assert time_parse('1:24') == 84
-    assert time_parse(':22') == 22
-    assert time_parse('1 minute, 24 secs') == 84
-    assert time_parse('1m24s') == 84
-    assert time_parse('1.2 minutes') == 72
-    assert time_parse('1.2 seconds') == 1.2
-    assert time_parse('- 1 minute') == -60
-    assert time_parse('+ 1 minute') == 60
-    assert time_parse('1:30') == 90
-    assert time_parse('1:30', granularity='minutes') == 5400
+
+    assert time_parse("1:24") == 84
+    assert time_parse(":22") == 22
+    assert time_parse("1 minute, 24 secs") == 84
+    assert time_parse("1m24s") == 84
+    assert time_parse("1.2 minutes") == 72
+    assert time_parse("1.2 seconds") == 1.2
+    assert time_parse("- 1 minute") == -60
+    assert time_parse("+ 1 minute") == 60
+    assert time_parse("1:30") == 90
+    assert time_parse("1:30", granularity="minutes") == 5400
diff --git a/tests/core_tests/util_tests/test_tokenbucket.py b/tests/core_tests/util_tests/test_tokenbucket.py
index d658f3b9..f394f0ce 100644
--- a/tests/core_tests/util_tests/test_tokenbucket.py
+++ b/tests/core_tests/util_tests/test_tokenbucket.py
@@ -62,7 +62,7 @@ def sleep(self, n):
 @pytest.fixture()
 def mock_time():
     mocked = MockTime()
-    with patch.object(tokenbucket, 'time', mocked.get):
+    with patch.object(tokenbucket, "time", mocked.get):
         yield mocked
 
 
diff --git a/tests/data/get_dogpile_data.py b/tests/data/get_dogpile_data.py
index fb63124f..556fdf39 100644
--- a/tests/data/get_dogpile_data.py
+++ b/tests/data/get_dogpile_data.py
@@ -3,26 +3,26 @@
 import requests
 from yarl import URL
 
-BASE_URL = URL('https://www.dogpile.com/search')
+BASE_URL = URL("https://www.dogpile.com/search")
 SCRIPT_DIR = Path(__file__).resolve().parent
 
 
 def get_data(query_type):  # pragma: no cover
-    params = {'q': 'test search'}
+    params = {"q": "test search"}
     with requests.get(
-            str(BASE_URL / query_type),
-            params=params,
-            verify=False,  # nosec
+        str(BASE_URL / query_type),
+        params=params,
+        verify=False,  # nosec
     ) as response:
         response.raise_for_status()
         return response.content
 
 
 def write_data(query_tyoe):  # pragma: no cover
-    with (SCRIPT_DIR / 'dogpile-{}.html'.format(query_tyoe)).open('wb') as file:
+    with (SCRIPT_DIR / "dogpile-{}.html".format(query_tyoe)).open("wb") as file:
         file.write(get_data(query_tyoe))
 
 
-if __name__ == '__main__':
-    write_data('web')
-    write_data('images')
+if __name__ == "__main__":
+    write_data("web")
+    write_data("images")
diff --git a/tests/data/xkcd/get_xkcd_info.py b/tests/data/xkcd/get_xkcd_info.py
index b1c4bdfb..ed793489 100644
--- a/tests/data/xkcd/get_xkcd_info.py
+++ b/tests/data/xkcd/get_xkcd_info.py
@@ -8,12 +8,12 @@
 
 
 def get_data(num):
-    file = (SCRIPT_DIR / '{}.json'.format(num))
+    file = SCRIPT_DIR / "{}.json".format(num)
     if file.exists():
         with file.open() as f:
             return json.load(f)
 
-    url = 'https://xkcd.com/{}/info.0.json'.format(num)
+    url = "https://xkcd.com/{}/info.0.json".format(num)
 
     with requests.get(url) as r:
         if r.status_code == 404:
@@ -28,9 +28,9 @@ def save(i):
     if data is None:
         return False
 
-    with (SCRIPT_DIR / '{}.json'.format(data['num'])).open('w') as f:
+    with (SCRIPT_DIR / "{}.json".format(data["num"])).open("w") as f:
         json.dump(data, f, indent=4)
-        f.write('\n')
+        f.write("\n")
 
     return True
 
@@ -41,5 +41,5 @@ def main():
         save(num)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/tests/plugin_tests/__init__.py b/tests/plugin_tests/__init__.py
index ad256712..7be33b1e 100644
--- a/tests/plugin_tests/__init__.py
+++ b/tests/plugin_tests/__init__.py
@@ -1 +1 @@
-__author__ = 'Luke'
+__author__ = "Luke"
diff --git a/tests/plugin_tests/server_info_test.py b/tests/plugin_tests/server_info_test.py
index 8e5475a3..930e2e7f 100644
--- a/tests/plugin_tests/server_info_test.py
+++ b/tests/plugin_tests/server_info_test.py
@@ -39,6 +39,13 @@ def test_parse_isupport():
                 "EXTBAN": "$,abcd",
                 "PREFIX": "(ohv)@%+",
             },
-            "statuses": {"%": hop, "+": voice, "@": op, "h": hop, "o": op, "v": voice},
+            "statuses": {
+                "%": hop,
+                "+": voice,
+                "@": op,
+                "h": hop,
+                "o": op,
+                "v": voice,
+            },
         }
     }
diff --git a/tests/plugin_tests/test_brainfuck.py b/tests/plugin_tests/test_brainfuck.py
index b530b7b4..fe6815bd 100644
--- a/tests/plugin_tests/test_brainfuck.py
+++ b/tests/plugin_tests/test_brainfuck.py
@@ -1,22 +1,26 @@
 import pytest
 
 
-@pytest.mark.parametrize('text,output', [
-    ('', 'No output'),
-    ('[', 'Unbalanced brackets'),
-    (']', 'Unbalanced brackets'),
-    (
-            '++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..'
-            '+++.>>.<-.<.+++.------.--------.>>+.>++.',
-            'Hello World!'
-    ),
-    ('+[>.]+', 'No printable output'),
-    ('++++[>.]+', 'No printable output'),
-    ('++++[>++]+.', '(no output)(exceeded 1000000 iterations)'),
-    ('++++[>,]+.', '(no output)(exceeded 1000000 iterations)'),
-    ('[>,]>+.', 'No printable output'),
-    ('..' * 500, 'No printable output'),
-])
+@pytest.mark.parametrize(
+    "text,output",
+    [
+        ("", "No output"),
+        ("[", "Unbalanced brackets"),
+        ("]", "Unbalanced brackets"),
+        (
+            "++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++.."
+            "+++.>>.<-.<.+++.------.--------.>>+.>++.",
+            "Hello World!",
+        ),
+        ("+[>.]+", "No printable output"),
+        ("++++[>.]+", "No printable output"),
+        ("++++[>++]+.", "(no output)(exceeded 1000000 iterations)"),
+        ("++++[>,]+.", "(no output)(exceeded 1000000 iterations)"),
+        ("[>,]>+.", "No printable output"),
+        (".." * 500, "No printable output"),
+    ],
+)
 def test_brainfuck(text, output):
     from plugins.brainfuck import bf
+
     assert bf(text) == output
diff --git a/tests/plugin_tests/test_chan_log.py b/tests/plugin_tests/test_chan_log.py
index 672d7a21..24ef004a 100644
--- a/tests/plugin_tests/test_chan_log.py
+++ b/tests/plugin_tests/test_chan_log.py
@@ -8,7 +8,7 @@ def _get_data(exc):
         yield repr(exc)
         yield "  args = {!r}".format(exc.args)
         yield "  with_traceback = {!r}".format(exc.with_traceback)
-        yield ''
+        yield ""
 
     err = ValueError("Test")
     err1 = ValueError("Test 2")
@@ -20,10 +20,12 @@ def _get_data(exc):
             except ValueError as e:
                 raise err1 from e
         except ValueError:
-            raise err2
+            raise err2 from None
     except ValueError as e:
-        assert list(format_error_chain(e)) == list(chain(
-            _get_data(err2),
-            _get_data(err1),
-            _get_data(err),
-        ))
+        assert list(format_error_chain(e)) == list(
+            chain(
+                _get_data(err2),
+                _get_data(err1),
+                _get_data(err),
+            )
+        )
diff --git a/tests/plugin_tests/test_cryptocurrency.py b/tests/plugin_tests/test_cryptocurrency.py
index ac42b2a4..8f8294d8 100644
--- a/tests/plugin_tests/test_cryptocurrency.py
+++ b/tests/plugin_tests/test_cryptocurrency.py
@@ -106,7 +106,14 @@ def init_response(
                         "elapsed": 1,
                         "credit_count": 1,
                     },
-                    "data": [{"id": 1, "name": "Dollar", "sign": "$", "symbol": "USD"}],
+                    "data": [
+                        {
+                            "id": 1,
+                            "name": "Dollar",
+                            "sign": "$",
+                            "symbol": "USD",
+                        }
+                    ],
                 },
             )
         )
@@ -133,7 +140,9 @@ def init_response(
                         "percent_change_1h": 14.5,
                         "percent_change_24h": pct_change,
                         "percent_change_7d": 24.5,
-                        "last_updated": (now - timedelta(minutes=3)).strftime(iso_fmt),
+                        "last_updated": (now - timedelta(minutes=3)).strftime(
+                            iso_fmt
+                        ),
                     },
                 },
             },
@@ -216,7 +225,8 @@ def test_complex_schema():
 
 def test_invalid_schema_type():
     with pytest.raises(
-        TypeError, match="field 'a' expected type <class 'str'>, got type <class 'int'>"
+        TypeError,
+        match="field 'a' expected type <class 'str'>, got type <class 'int'>",
     ):
         cryptocurrency.read_data({"a": 1, "b": "world"}, OtherConcreteSchema)
 
@@ -239,14 +249,18 @@ def test_schema_nested_exceptions():
         cryptocurrency.read_data({"a": {"b": "hello"}}, NestedSchema)
 
     assert isinstance(exc.value.__cause__, cryptocurrency.ParseError)
-    assert isinstance(exc.value.__cause__.__cause__, cryptocurrency.MissingSchemaField)
+    assert isinstance(
+        exc.value.__cause__.__cause__, cryptocurrency.MissingSchemaField
+    )
 
 
 def test_schema_unknown_fields():
     input_data = {"a": {"a": "hello", "b": "world"}, "c": 1}
     with pytest.warns(
         UserWarning,
-        match=re.escape("Unknown fields: ['c'] while parsing schema 'NestedSchema'"),
+        match=re.escape(
+            "Unknown fields: ['c'] while parsing schema 'NestedSchema'"
+        ),
     ):
         obj = cryptocurrency.read_data(input_data, NestedSchema)
 
@@ -427,7 +441,9 @@ def test_cmd_api_error(mock_requests):
     with pytest.raises(cryptocurrency.APIError, match="FooBar"):
         wrap_hook_response(cryptocurrency.crypto_command, event, res)
 
-    assert res == [HookResult("message", ("#foo", "(foobaruser) Unknown API error"))]
+    assert res == [
+        HookResult("message", ("#foo", "(foobaruser) Unknown API error"))
+    ]
 
 
 def test_list_currencies(patch_paste, mock_requests):
diff --git a/tests/plugin_tests/test_cypher.py b/tests/plugin_tests/test_cypher.py
index 23914840..b8f2f145 100644
--- a/tests/plugin_tests/test_cypher.py
+++ b/tests/plugin_tests/test_cypher.py
@@ -6,13 +6,13 @@
 
 
 @pytest.mark.parametrize(
-    'plaintext,key,ciphertext',
+    "plaintext,key,ciphertext",
     [
-        ('some input', 'supersecretkey', 'w6bDpMOdw4rCksOcw5PDk8Onw5k='),
+        ("some input", "supersecretkey", "w6bDpMOdw4rCksOcw5PDk8Onw5k="),
         (
-            'other input and stuff',
-            'supersecretkey234',
-            'w6LDqcOYw4rDpMKTw47DkcOiw5rDqMKLw4bDp8KWU8Knw6fDqsOWw4s=',
+            "other input and stuff",
+            "supersecretkey234",
+            "w6LDqcOYw4rDpMKTw47DkcOiw5rDqMKLw4bDp8KWU8Knw6fDqsOWw4s=",
         ),
     ],
 )
@@ -22,13 +22,13 @@ def test_encipher(plaintext, key, ciphertext):
 
 
 @pytest.mark.parametrize(
-    'ciphertext,key,plaintext',
+    "ciphertext,key,plaintext",
     [
-        ('w6bDpMOdw4rCksOcw5PDk8Onw5k=', 'supersecretkey', 'some input'),
+        ("w6bDpMOdw4rCksOcw5PDk8Onw5k=", "supersecretkey", "some input"),
         (
-            'w6LDqcOYw4rDpMKTw47DkcOiw5rDqMKLw4bDp8KWU8Knw6fDqsOWw4s=',
-            'supersecretkey234',
-            'other input and stuff',
+            "w6LDqcOYw4rDpMKTw47DkcOiw5rDqMKLw4bDp8KWU8Knw6fDqsOWw4s=",
+            "supersecretkey234",
+            "other input and stuff",
         ),
     ],
 )
diff --git a/tests/plugin_tests/test_dig.py b/tests/plugin_tests/test_dig.py
index ab9ef3d8..5a3d2fd2 100644
--- a/tests/plugin_tests/test_dig.py
+++ b/tests/plugin_tests/test_dig.py
@@ -1,4 +1,5 @@
 def test_dig():
     from plugins import dig
+
     s = "The jsondns API no longer exists. This command is retired."
     assert dig.dig() == s
diff --git a/tests/plugin_tests/test_dogpile.py b/tests/plugin_tests/test_dogpile.py
index f92958ea..29a5997a 100644
--- a/tests/plugin_tests/test_dogpile.py
+++ b/tests/plugin_tests/test_dogpile.py
@@ -3,12 +3,12 @@
 import pytest
 
 
-@pytest.fixture(scope='module')
+@pytest.fixture(scope="module")
 def test_data():
     data = {}
-    for file in Path('tests/data/').resolve().rglob('dogpile-*.html'):
-        name = file.stem.split('-', 1)[1]
-        with file.open('rb') as f:
+    for file in Path("tests/data/").resolve().rglob("dogpile-*.html"):
+        name = file.stem.split("-", 1)[1]
+        with file.open("rb") as f:
             data[name] = f.read()
 
     yield data
@@ -18,84 +18,89 @@ def add_page(mock_requests, endpoint, test_data):
     data = test_data[endpoint]
     mock_requests.add(
         mock_requests.GET,
-        'https://www.dogpile.com/search/' + endpoint,
+        "https://www.dogpile.com/search/" + endpoint,
         body=data,
     )
 
 
 def test_web_search(test_data, mock_requests):
-    add_page(mock_requests, 'web', test_data)
+    add_page(mock_requests, "web", test_data)
     from plugins.dogpile import dogpile
-    assert dogpile('test search') == 'https://search.google.com/test/mobile-friendly -- ' \
-                                     '\x02Test how easily a visitor can use your page on a mobile device. ' \
-                                     'Just enter a page URL to see how your page scores. ' \
-                                     '... Google apps. Main menu Mobile-Friendly Test ... ' \
-                                     'Search Console alerts you about critical site errors such as ' \
-                                     'detection of hacked content, and helps you manage how your content ' \
-                                     'appears in search results.\x02'
+
+    assert (
+        dogpile("test search")
+        == "https://search.google.com/test/mobile-friendly -- "
+        "\x02Test how easily a visitor can use your page on a mobile device. "
+        "Just enter a page URL to see how your page scores. "
+        "... Google apps. Main menu Mobile-Friendly Test ... "
+        "Search Console alerts you about critical site errors such as "
+        "detection of hacked content, and helps you manage how your content "
+        "appears in search results.\x02"
+    )
 
     mock_requests.replace(
         mock_requests.GET,
-        'https://www.dogpile.com/search/web',
-        body='',
+        "https://www.dogpile.com/search/web",
+        body="",
     )
 
-    assert dogpile('test search') == 'No results found.'
+    assert dogpile("test search") == "No results found."
 
 
 def test_image_search(test_data, mock_requests):
-    add_page(mock_requests, 'images', test_data)
+    add_page(mock_requests, "images", test_data)
     from plugins.dogpile import dogpileimage
-    assert dogpileimage('test search') in [
-        'http://www.opentestsearch.com/files/2012/04/Searchdaimon_admin_4.png',
-        'https://avaldes.com/wp-content/uploads/2014/03/test_search_xml.png?2d262d&2d262d',
-        'http://solospark.com/wp-content/uploads/2013/11/google.seo_.search.testing.infographic.png',
-        'http://searchengineland.com/figz/wp-content/seloads/2014/04/bing-test-design.png',
-        'https://searchengineland.com/figz/wp-content/seloads/2015/01/yahoo-search-google-interface-1421673260-800x460.png',
-        'https://avaldes.com/wp-content/uploads/2014/03/test_search_json.png?x43424',
-        'http://intranetdiary.co.uk/wp-content/uploads/2013/03/Search-results-for-get-an-eye-test-culture-hub.png',
-        'http://searchengineland.com/figz/wp-content/seloads/2016/05/google-mobile-friendly-test-tool-new.png',
-        'http://www.opentestsearch.com/files/2012/09/Google-site-search-admin-31.png',
-        'http://www.saadkamal.com/wp-content/uploads/2009/03/microsoft-kumo-search-engine.png',
-        'https://content.lessonplanet.com/resources/previews/original/bacteria-test-word-search-puzzle-worksheet.jpg?1414269464',
-        'http://www.maven-infosoft.com/wp-content/uploads/2016/05/Search-Console-Mobile-Friendly-Test.png',
-        'http://searchengineland.com/figz/wp-content/seloads/2017/04/google-jobs-answer.jpg',
-        'https://cdn.vox-cdn.com/thumbor/ZjEhxzbS9SyQYPP56vUiUXAwoLo=/207x0:891x456/1200x800/filters:focal(207x0:891x456)/cdn.vox-cdn.com/uploads/chorus_image/image/49980909/google-search-internet-speed-test.0.0.jpg',
-        'http://www.androidpolice.com/wp-content/uploads/2017/07/nexus2cee_google-search-test-rounded-cards-layout-new-6.png',
-        'https://searchengineland.com/figz/wp-content/seloads/2017/12/rich-results-google-testing-tool.png',
-        'http://www.cctvcamerapros.com/v/images/test-monitor/cable-search/IP-Camera-Monitor-Cable-Tester.jpg',
-        'http://www.androidpolice.com/wp-content/uploads/2017/07/nexus2cee_google-search-test-rounded-cards-layout-old-2.png',
-        'http://images.fonearena.com/blog/wp-content/uploads/2016/07/google-search-speed-test-4.png',
-        'https://marketplace-cdn.atlassian.com/files/images/b3d56053-21c0-4d1b-bd4b-54ccb2093acc.png',
-        'http://dustn.tv/wp-content/uploads/2016/06/08-successful-search-test.jpg',
-        'http://2.bp.blogspot.com/-0J2qyCHOxPM/U21ZWYc5tHI/AAAAAAAAJaQ/eEa1q4Yjp9c/s1600/Minecraft+Crossword+Free+Printable+.jpg',
-        'https://fossbytes.com/wp-content/uploads/2017/08/Google-Search-Speed-test-Main3.png',
-        'https://9to5google.files.wordpress.com/2016/05/google-search-ab-test-11.png',
-        'https://cyberbloc.de/wp-content/uploads/2013/01/Facebook_Graph_Search_test_081.jpg',
-        'https://searchengineland.com/figz/wp-content/seloads/2015/08/google-online-appointment-booking-intuit-landing-page.png',
-        'http://www.androidpolice.com/wp-content/uploads/2017/07/nexus2cee_google-search-test-rounded-cards-layout-old-4.png',
-        'http://www.cctvcamerapros.com/v/images/test-monitor/cable-search/IP-Camera-Test-Monitor-Cable.jpg',
-        'https://jungsuwonkidsclub.files.wordpress.com/2008/11/testing-word-search.jpg',
-        'https://justaucguy.files.wordpress.com/2014/12/test-exchangesearch-fl.jpg',
-        'https://s3.amazonaws.com/images.seroundtable.com/google-image-search-new-interface-1358516501.jpg',
-        'https://i.pinimg.com/736x/24/2d/02/242d029a84185ba7709bc019b36b0fd6--genealogy-dna-test-genealogy-search.jpg',
-        'http://slideplayer.com/9460680/29/images/6/Use+the+filters+to+find+questions+for+your+test.jpg',
-        'https://marketplace-cdn.atlassian.com/files/images/8de36cd1-c798-4592-8a94-4cb2922188a9.jpeg',
-        'https://cdn0.tnwcdn.com/wp-content/blogs.dir/1/files/2016/05/Google_search_test.jpg'
+
+    assert dogpileimage("test search") in [
+        "http://www.opentestsearch.com/files/2012/04/Searchdaimon_admin_4.png",
+        "https://avaldes.com/wp-content/uploads/2014/03/test_search_xml.png?2d262d&2d262d",
+        "http://solospark.com/wp-content/uploads/2013/11/google.seo_.search.testing.infographic.png",
+        "http://searchengineland.com/figz/wp-content/seloads/2014/04/bing-test-design.png",
+        "https://searchengineland.com/figz/wp-content/seloads/2015/01/yahoo-search-google-interface-1421673260-800x460.png",
+        "https://avaldes.com/wp-content/uploads/2014/03/test_search_json.png?x43424",
+        "http://intranetdiary.co.uk/wp-content/uploads/2013/03/Search-results-for-get-an-eye-test-culture-hub.png",
+        "http://searchengineland.com/figz/wp-content/seloads/2016/05/google-mobile-friendly-test-tool-new.png",
+        "http://www.opentestsearch.com/files/2012/09/Google-site-search-admin-31.png",
+        "http://www.saadkamal.com/wp-content/uploads/2009/03/microsoft-kumo-search-engine.png",
+        "https://content.lessonplanet.com/resources/previews/original/bacteria-test-word-search-puzzle-worksheet.jpg?1414269464",
+        "http://www.maven-infosoft.com/wp-content/uploads/2016/05/Search-Console-Mobile-Friendly-Test.png",
+        "http://searchengineland.com/figz/wp-content/seloads/2017/04/google-jobs-answer.jpg",
+        "https://cdn.vox-cdn.com/thumbor/ZjEhxzbS9SyQYPP56vUiUXAwoLo=/207x0:891x456/1200x800/filters:focal(207x0:891x456)/cdn.vox-cdn.com/uploads/chorus_image/image/49980909/google-search-internet-speed-test.0.0.jpg",
+        "http://www.androidpolice.com/wp-content/uploads/2017/07/nexus2cee_google-search-test-rounded-cards-layout-new-6.png",
+        "https://searchengineland.com/figz/wp-content/seloads/2017/12/rich-results-google-testing-tool.png",
+        "http://www.cctvcamerapros.com/v/images/test-monitor/cable-search/IP-Camera-Monitor-Cable-Tester.jpg",
+        "http://www.androidpolice.com/wp-content/uploads/2017/07/nexus2cee_google-search-test-rounded-cards-layout-old-2.png",
+        "http://images.fonearena.com/blog/wp-content/uploads/2016/07/google-search-speed-test-4.png",
+        "https://marketplace-cdn.atlassian.com/files/images/b3d56053-21c0-4d1b-bd4b-54ccb2093acc.png",
+        "http://dustn.tv/wp-content/uploads/2016/06/08-successful-search-test.jpg",
+        "http://2.bp.blogspot.com/-0J2qyCHOxPM/U21ZWYc5tHI/AAAAAAAAJaQ/eEa1q4Yjp9c/s1600/Minecraft+Crossword+Free+Printable+.jpg",
+        "https://fossbytes.com/wp-content/uploads/2017/08/Google-Search-Speed-test-Main3.png",
+        "https://9to5google.files.wordpress.com/2016/05/google-search-ab-test-11.png",
+        "https://cyberbloc.de/wp-content/uploads/2013/01/Facebook_Graph_Search_test_081.jpg",
+        "https://searchengineland.com/figz/wp-content/seloads/2015/08/google-online-appointment-booking-intuit-landing-page.png",
+        "http://www.androidpolice.com/wp-content/uploads/2017/07/nexus2cee_google-search-test-rounded-cards-layout-old-4.png",
+        "http://www.cctvcamerapros.com/v/images/test-monitor/cable-search/IP-Camera-Test-Monitor-Cable.jpg",
+        "https://jungsuwonkidsclub.files.wordpress.com/2008/11/testing-word-search.jpg",
+        "https://justaucguy.files.wordpress.com/2014/12/test-exchangesearch-fl.jpg",
+        "https://s3.amazonaws.com/images.seroundtable.com/google-image-search-new-interface-1358516501.jpg",
+        "https://i.pinimg.com/736x/24/2d/02/242d029a84185ba7709bc019b36b0fd6--genealogy-dna-test-genealogy-search.jpg",
+        "http://slideplayer.com/9460680/29/images/6/Use+the+filters+to+find+questions+for+your+test.jpg",
+        "https://marketplace-cdn.atlassian.com/files/images/8de36cd1-c798-4592-8a94-4cb2922188a9.jpeg",
+        "https://cdn0.tnwcdn.com/wp-content/blogs.dir/1/files/2016/05/Google_search_test.jpg",
     ]
 
     mock_requests.replace(
         mock_requests.GET,
-        'https://www.dogpile.com/search/images',
-        body='',
+        "https://www.dogpile.com/search/images",
+        body="",
     )
 
-    assert dogpileimage('test search') == 'No results found.'
+    assert dogpileimage("test search") == "No results found."
 
     mock_requests.replace(
         mock_requests.GET,
-        'https://www.dogpile.com/search/images',
-        body=test_data['images-empty'],
+        "https://www.dogpile.com/search/images",
+        body=test_data["images-empty"],
     )
 
-    assert dogpileimage('test search') == 'No results found.'
+    assert dogpileimage("test search") == "No results found."
diff --git a/tests/plugin_tests/test_factoids.py b/tests/plugin_tests/test_factoids.py
index b3082951..a4e616da 100644
--- a/tests/plugin_tests/test_factoids.py
+++ b/tests/plugin_tests/test_factoids.py
@@ -8,43 +8,52 @@
 def test_forget():
     from cloudbot.util import database
     from plugins import factoids
+
     importlib.reload(database)
     importlib.reload(factoids)
 
     mock_session = MagicMock()
     mock_notice = MagicMock()
-    with patch('plugins.factoids.remove_fact') as func:
+    with patch("plugins.factoids.remove_fact") as func:
         from plugins.factoids import forget
-        forget('foo bar', '#example', mock_session, mock_notice)
 
-        func.assert_called_with('#example', ['foo', 'bar'], mock_session, mock_notice)
+        forget("foo bar", "#example", mock_session, mock_notice)
+
+        func.assert_called_with(
+            "#example", ["foo", "bar"], mock_session, mock_notice
+        )
 
 
 def test_remove_fact_no_paste(mock_requests):
     from cloudbot.util import database
     from plugins import factoids
+
     importlib.reload(database)
     importlib.reload(factoids)
 
     factoids.factoid_cache.clear()
-    mock_requests.add(mock_requests.POST, 'https://hastebin.com/documents', status=404)
+    mock_requests.add(
+        mock_requests.POST, "https://hastebin.com/documents", status=404
+    )
     mock_session = MagicMock()
     mock_notice = MagicMock()
 
-    factoids.remove_fact('#example', ['foo'], mock_session, mock_notice)
+    factoids.remove_fact("#example", ["foo"], mock_session, mock_notice)
     mock_notice.assert_called_once_with("Unknown factoids: 'foo'")
 
     mock_session.execute.assert_not_called()
 
     mock_notice.reset_mock()
 
-    factoids.factoid_cache['#example']['foo'] = 'bar'
+    factoids.factoid_cache["#example"]["foo"] = "bar"
 
-    factoids.remove_fact('#example', ['foo', 'bar'], mock_session, mock_notice)
-    mock_notice.assert_has_calls([
-        call("Unknown factoids: 'bar'"),
-        call('Unable to paste removed data, not removing facts'),
-    ])
+    factoids.remove_fact("#example", ["foo", "bar"], mock_session, mock_notice)
+    mock_notice.assert_has_calls(
+        [
+            call("Unknown factoids: 'bar'"),
+            call("Unable to paste removed data, not removing facts"),
+        ]
+    )
 
     mock_session.execute.assert_not_called()
 
@@ -52,61 +61,78 @@ def test_remove_fact_no_paste(mock_requests):
 def test_remove_fact(patch_paste):
     from cloudbot.util import database
     from plugins import factoids
+
     importlib.reload(database)
     importlib.reload(factoids)
 
     from plugins.factoids import factoid_cache
+
     factoid_cache.clear()
     mock_session = MagicMock()
     mock_notice = MagicMock()
 
     from plugins.factoids import remove_fact
-    remove_fact('#example', ['foo'], mock_session, mock_notice)
+
+    remove_fact("#example", ["foo"], mock_session, mock_notice)
     mock_notice.assert_called_with("Unknown factoids: 'foo'")
 
     mock_session.execute.assert_not_called()
 
-    factoid_cache['#example']['foo'] = 'bar'
+    factoid_cache["#example"]["foo"] = "bar"
 
     patch_paste.return_value = "PASTEURL"
-    remove_fact('#example', ['foo'], mock_session, mock_notice)
-    mock_notice.assert_called_with('Removed Data: PASTEURL')
+    remove_fact("#example", ["foo"], mock_session, mock_notice)
+    mock_notice.assert_called_with("Removed Data: PASTEURL")
     patch_paste.assert_called_with(
-        b'| Command | Output |\n| ------- | ------ |\n| ?foo    | bar    |',
-        'md', 'hastebin', raise_on_no_paste=True
+        b"| Command | Output |\n| ------- | ------ |\n| ?foo    | bar    |",
+        "md",
+        "hastebin",
+        raise_on_no_paste=True,
     )
 
     query = mock_session.execute.mock_calls[0][1][0]
 
     compiled = query.compile()
 
-    assert str(compiled) == dedent("""
+    assert (
+        str(compiled)
+        == dedent(
+            """
     DELETE FROM factoids WHERE factoids.chan = :chan_1 AND factoids.word IN (:word_1)
-    """).strip()
+    """
+        ).strip()
+    )
 
-    assert compiled.params == {'chan_1': '#example', 'word_1': 'foo'}
+    assert compiled.params == {"chan_1": "#example", "word_1": "foo"}
 
 
 def test_clear_facts():
     from cloudbot.util import database
     from plugins import factoids
+
     importlib.reload(database)
     importlib.reload(factoids)
 
     mock_session = MagicMock()
 
     from plugins.factoids import forget_all
-    assert forget_all('#example', mock_session) == "Facts cleared."
+
+    assert forget_all("#example", mock_session) == "Facts cleared."
 
     query = mock_session.execute.mock_calls[0][1][0]
 
     compiled = query.compile()
 
-    assert str(compiled) == dedent("""
+    assert (
+        str(compiled)
+        == dedent(
+            """
     DELETE FROM factoids WHERE factoids.chan = :chan_1
-    """).strip()
+    """
+        ).strip()
+    )
 
-    assert compiled.params == {'chan_1': '#example'}
+    assert compiled.params == {"chan_1": "#example"}
 
 
 def test_list_facts(mock_db):
@@ -115,23 +141,23 @@ def test_list_facts(mock_db):
     factoids.table.create(mock_db.engine, checkfirst=True)
 
     names = [
-        ''.join(c) for c in itertools.product(string.ascii_lowercase, repeat=2)
+        "".join(c) for c in itertools.product(string.ascii_lowercase, repeat=2)
     ]
 
     for name in names:
         factoids.add_factoid(
             mock_db.session(),
             name.lower(),
-            '#chan',
+            "#chan",
             name,
-            'nick',
+            "nick",
         )
 
     notice = MagicMock()
-    factoids.listfactoids(notice, '#chan')
+    factoids.listfactoids(notice, "#chan")
 
-    text = ', '.join(call[1][0] for call in notice.mock_calls)
+    text = ", ".join(call[1][0] for call in notice.mock_calls)
 
-    assert text == ', '.join(
-        '?' + name for name in sorted(names + ['commands'])
+    assert text == ", ".join(
+        "?" + name for name in sorted(names + ["commands"])
     )
diff --git a/tests/plugin_tests/test_feeds.py b/tests/plugin_tests/test_feeds.py
index 61cebce2..40c1479e 100644
--- a/tests/plugin_tests/test_feeds.py
+++ b/tests/plugin_tests/test_feeds.py
@@ -6,7 +6,7 @@
 
 @pytest.fixture()
 def mock_feedparse():
-    with patch('feedparser.parse') as mock:
+    with patch("feedparser.parse") as mock:
         yield mock
 
 
@@ -16,34 +16,34 @@ def test_feeds(mock_feedparse, patch_try_shorten):
     mock_feedparse.return_value = FeedParserDict(
         entries=[],
     )
-    assert feeds.rss('xkcd') == "Feed not found."
+    assert feeds.rss("xkcd") == "Feed not found."
 
-    mock_feedparse.assert_called_with('http://xkcd.com/rss.xml')
+    mock_feedparse.assert_called_with("http://xkcd.com/rss.xml")
 
     mock_feedparse.reset_mock()
 
     mock_feedparse.return_value = FeedParserDict(
-        entries=[FeedParserDict(title='foo1', link='http://example.com')],
-        feed=FeedParserDict(title='test'),
+        entries=[FeedParserDict(title="foo1", link="http://example.com")],
+        feed=FeedParserDict(title="test"),
     )
 
     with_title = "\x02test\x02: foo1 (http://example.com)"
 
-    assert feeds.rss('http://rss.example.com/feed.xml') == with_title
+    assert feeds.rss("http://rss.example.com/feed.xml") == with_title
 
-    mock_feedparse.assert_called_with('http://rss.example.com/feed.xml')
+    mock_feedparse.assert_called_with("http://rss.example.com/feed.xml")
 
     mock_feedparse.reset_mock()
 
     mock_feedparse.return_value = FeedParserDict(
-        entries=[FeedParserDict(title='foo1', link='http://example.com')],
+        entries=[FeedParserDict(title="foo1", link="http://example.com")],
         feed=FeedParserDict(),
     )
 
     without_title = "foo1 (http://example.com)"
 
-    assert feeds.rss('http://rss.example.com/feed.xml') == without_title
+    assert feeds.rss("http://rss.example.com/feed.xml") == without_title
 
-    mock_feedparse.assert_called_with('http://rss.example.com/feed.xml')
+    mock_feedparse.assert_called_with("http://rss.example.com/feed.xml")
 
     mock_feedparse.reset_mock()
diff --git a/tests/plugin_tests/test_googleurlparse.py b/tests/plugin_tests/test_googleurlparse.py
index a236a9af..e3f14f4a 100644
--- a/tests/plugin_tests/test_googleurlparse.py
+++ b/tests/plugin_tests/test_googleurlparse.py
@@ -1,11 +1,15 @@
 import pytest
 
 
-@pytest.mark.parametrize('text,url', [
-    ('www.google.com/url?thing&url=example.com', 'example.com'),
-])
+@pytest.mark.parametrize(
+    "text,url",
+    [
+        ("www.google.com/url?thing&url=example.com", "example.com"),
+    ],
+)
 def test_google_url(text, url):
-    from plugins.googleurlparse import spamurl, google_url
+    from plugins.googleurlparse import google_url, spamurl
+
     match = spamurl.search(text)
     assert match
     assert google_url(match) == url
diff --git a/tests/plugin_tests/test_herald.py b/tests/plugin_tests/test_herald.py
index fa124571..be5ef052 100644
--- a/tests/plugin_tests/test_herald.py
+++ b/tests/plugin_tests/test_herald.py
@@ -21,7 +21,11 @@ class TestWelcome:
     def _run(self):
         conn = MagicMock()
         event = Event(
-            hook=MagicMock(), bot=conn.bot, conn=conn, channel="#foo", nick="foobaruser"
+            hook=MagicMock(),
+            bot=conn.bot,
+            conn=conn,
+            channel="#foo",
+            nick="foobaruser",
         )
         return wrap_hook_response(herald.welcome, event)
 
@@ -48,7 +52,9 @@ def test_flood(self, clear_cache, freeze_time):
         nick = "foobaruser"
         nick1 = "foonick"
         chan1 = "#barchan"
-        herald.herald_cache[chan].update({nick: "Some herald", nick1: "Other herald,"})
+        herald.herald_cache[chan].update(
+            {nick: "Some herald", nick1: "Other herald,"}
+        )
         herald.herald_cache[chan1].update(
             {nick: "Someother herald", nick1: "Yet another herald"}
         )
@@ -56,7 +62,12 @@ def test_flood(self, clear_cache, freeze_time):
         conn.mock_add_spec(["name", "bot", "action", "message", "notice"])
         event = Event(conn=conn, bot=conn.bot, channel=chan, nick=nick)
         event1 = Event(conn=conn, bot=conn.bot, channel=chan, nick=nick1)
-        event2 = Event(conn=conn, bot=conn.bot, channel=chan1, nick=nick,)
+        event2 = Event(
+            conn=conn,
+            bot=conn.bot,
+            channel=chan1,
+            nick=nick,
+        )
         event3 = Event(conn=conn, bot=conn.bot, channel=chan1, nick=nick1)
 
         def check(ev):
@@ -67,7 +78,9 @@ def check(ev):
         assert check(event) == []
         assert check(event1) == []
 
-        assert check(event2) == [("message", ("#barchan", "\u200b Someother herald"))]
+        assert check(event2) == [
+            ("message", ("#barchan", "\u200b Someother herald"))
+        ]
         assert check(event3) == []
 
         freeze_time.tick(timedelta(seconds=10))
diff --git a/tests/plugin_tests/test_imdb.py b/tests/plugin_tests/test_imdb.py
index 07d27370..aa0bfbdf 100644
--- a/tests/plugin_tests/test_imdb.py
+++ b/tests/plugin_tests/test_imdb.py
@@ -5,17 +5,39 @@ def test_imdb_re():
     def match(text):
         return imdb_re.match(text)
 
-    assert not match('http://www.imdb.com/title/stuff')
+    assert not match("http://www.imdb.com/title/stuff")
 
-    assert match('https://www.imdb.com/title/tt1950186/').group(1) == 'tt1950186'
-    assert match('https://www.imdb.com/title/tt2575988/mediaviewer/rm668743424?ft0=name&fv0=nm1476909&ft1=image_type&fv1=still_frame').group(1) == 'tt2575988'
-    assert match('http://www.imdb.com/title/tt1950186/').group(1) == 'tt1950186'
-    assert match('http://www.imdb.com/title/tt2575988/mediaviewer/rm668743424?ft0=name&fv0=nm1476909&ft1=image_type&fv1=still_frame').group(1) == 'tt2575988'
-    assert match('https://imdb.com/title/tt1950186/').group(1) == 'tt1950186'
-    assert match('https://imdb.com/title/tt2575988/mediaviewer/rm668743424?ft0=name&fv0=nm1476909&ft1=image_type&fv1=still_frame').group(1) == 'tt2575988'
-    assert match('http://imdb.com/title/tt1950186/').group(1) == 'tt1950186'
-    assert match('http://imdb.com/title/tt2575988/mediaviewer/rm668743424?ft0=name&fv0=nm1476909&ft1=image_type&fv1=still_frame').group(1) == 'tt2575988'
-    assert match('https://www.imdb.com/title/tt1950186').group(1) == 'tt1950186'
-    assert match('http://www.imdb.com/title/tt1950186').group(1) == 'tt1950186'
-    assert match('https://imdb.com/title/tt1950186').group(1) == 'tt1950186'
-    assert match('http://imdb.com/title/tt1950186').group(1) == 'tt1950186'
+    assert (
+        match("https://www.imdb.com/title/tt1950186/").group(1) == "tt1950186"
+    )
+    assert (
+        match(
+            "https://www.imdb.com/title/tt2575988/mediaviewer/rm668743424?ft0=name&fv0=nm1476909&ft1=image_type&fv1=still_frame"
+        ).group(1)
+        == "tt2575988"
+    )
+    assert match("http://www.imdb.com/title/tt1950186/").group(1) == "tt1950186"
+    assert (
+        match(
+            "http://www.imdb.com/title/tt2575988/mediaviewer/rm668743424?ft0=name&fv0=nm1476909&ft1=image_type&fv1=still_frame"
+        ).group(1)
+        == "tt2575988"
+    )
+    assert match("https://imdb.com/title/tt1950186/").group(1) == "tt1950186"
+    assert (
+        match(
+            "https://imdb.com/title/tt2575988/mediaviewer/rm668743424?ft0=name&fv0=nm1476909&ft1=image_type&fv1=still_frame"
+        ).group(1)
+        == "tt2575988"
+    )
+    assert match("http://imdb.com/title/tt1950186/").group(1) == "tt1950186"
+    assert (
+        match(
+            "http://imdb.com/title/tt2575988/mediaviewer/rm668743424?ft0=name&fv0=nm1476909&ft1=image_type&fv1=still_frame"
+        ).group(1)
+        == "tt2575988"
+    )
+    assert match("https://www.imdb.com/title/tt1950186").group(1) == "tt1950186"
+    assert match("http://www.imdb.com/title/tt1950186").group(1) == "tt1950186"
+    assert match("https://imdb.com/title/tt1950186").group(1) == "tt1950186"
+    assert match("http://imdb.com/title/tt1950186").group(1) == "tt1950186"
diff --git a/tests/plugin_tests/test_link_announcer.py b/tests/plugin_tests/test_link_announcer.py
index 09116654..e84343e5 100644
--- a/tests/plugin_tests/test_link_announcer.py
+++ b/tests/plugin_tests/test_link_announcer.py
@@ -79,7 +79,7 @@
     ("(https://foo.bar)", "https://foo.bar"),
     ("[https://example.com]", "https://example.com"),
     (
-        "<a hreh=\"https://example.com/test.page?#test\">",
+        '<a hreh="https://example.com/test.page?#test">',
         "https://example.com/test.page?#test",
     ),
     (
@@ -105,11 +105,11 @@ def test_search():
 
 
 ENCODINGS = (
-    (b'<meta charset="utf8">', codecs.lookup('utf8')),
-    (b'', None),
+    (b'<meta charset="utf8">', codecs.lookup("utf8")),
+    (b"", None),
     (
         b'<meta http-equiv="Content-Type" content="text/html; charset=utf-8">',
-        codecs.lookup('utf8'),
+        codecs.lookup("utf8"),
     ),
 )
 
@@ -119,9 +119,9 @@ def test_encoding_parse():
         soup = BeautifulSoup(text, "lxml")
         encoding = get_encoding(soup)
         if encoding is None:
-            assert enc is None, "Got empty encoding from {!r} expected {!r}".format(
-                text, enc
-            )
+            assert (
+                enc is None
+            ), "Got empty encoding from {!r} expected {!r}".format(text, enc)
             continue
 
         enc_obj = codecs.lookup(encoding)
@@ -137,7 +137,10 @@ def test_encoding_parse():
     ),
     "http://www.talos.principle": (STD_HTML, "In the beginning were the words"),
     "http://www.nonexistent.lol": ("", False),
-    "http://www.much-newlines.backslashn": (("\n" * 500) + STD_HTML, "new lines!"),
+    "http://www.much-newlines.backslashn": (
+        ("\n" * 500) + STD_HTML,
+        "new lines!",
+    ),
     "http://completely.invalid": ("\x01\x01\x02\x03\x05\x08\x13", False),
     "http://large.amounts.of.text": (
         STD_HTML + ("42" * 512 * 4096) + "</body>",
@@ -151,10 +154,12 @@ def test_encoding_parse():
 @pytest.mark.parametrize(
     "match,test_str,res",
     [(url_re.search(a), b.format(c), c) for a, (b, c) in TESTS.items()],
-    ids=lambda case: str(getattr(case, 'string', case))[:100],
+    ids=lambda case: str(getattr(case, "string", case))[:100],
 )
 def test_link_announce(match, test_str, res, mock_requests):
-    mock_requests.add(RequestsMock.GET, match.string, body=test_str, stream=True)
+    mock_requests.add(
+        RequestsMock.GET, match.string, body=test_str, stream=True
+    )
     mck = MagicMock()
     logger = MagicMock()
 
@@ -169,7 +174,7 @@ def test_link_announce(match, test_str, res, mock_requests):
 
 
 def test_link_announce_404(mock_requests):
-    url = 'http://example.com'
+    url = "http://example.com"
     mock_requests.add(mock_requests.GET, url, status=404)
 
     match = url_re.search(url)
@@ -188,7 +193,7 @@ def test_read_timeout(mock_requests):
     def callback(resp):
         raise requests.ReadTimeout()
 
-    mock_requests.add_callback('GET', url, callback)
+    mock_requests.add_callback("GET", url, callback)
 
     match = url_re.search(url)
     assert match
@@ -197,11 +202,11 @@ def callback(resp):
 
     assert print_url_title(match=match, message=mck, logger=logger) is None
 
-    logger.debug.assert_called_with('Read timeout reached for %r', url)
+    logger.debug.assert_called_with("Read timeout reached for %r", url)
 
 
 @pytest.mark.parametrize(
-    'body,encoding',
+    "body,encoding",
     [
         (
             b"""\
@@ -209,7 +214,7 @@ def callback(resp):
 <meta charset="utf8">
 <title>foobar</title>
 </head>""",
-            'utf8',
+            "utf8",
         ),
         (
             b"""\
@@ -217,7 +222,7 @@ def callback(resp):
 <meta http-equiv="content-type", content="text/plain; charset=utf8">
 <title>foobar</title>
 </head>""",
-            'utf8',
+            "utf8",
         ),
         (
             b"""\
@@ -225,20 +230,20 @@ def callback(resp):
 <meta http-equiv="content-type", content="text/plain">
 <title>foobar</title>
 </head>""",
-            'ISO-8859-1',
+            "ISO-8859-1",
         ),
         (
             b"""\
 <head>
 <title>foobar</title>
 </head>""",
-            'ISO-8859-1',
+            "ISO-8859-1",
         ),
     ],
 )
 def test_change_encoding(body, encoding):
     # ISO-8859-1 is the default encoding requests would return if none is found
-    assert parse_content(body, 'ISO-8859-1').original_encoding == encoding
+    assert parse_content(body, "ISO-8859-1").original_encoding == encoding
 
 
 def test_connection_error(mock_requests):
diff --git a/tests/plugin_tests/test_lmgtfy.py b/tests/plugin_tests/test_lmgtfy.py
index 752be514..ada09d40 100644
--- a/tests/plugin_tests/test_lmgtfy.py
+++ b/tests/plugin_tests/test_lmgtfy.py
@@ -1,3 +1,4 @@
 def test_lmgtfy(patch_try_shorten):
     from plugins.lmgtfy import lmgtfy
-    assert lmgtfy('foo bar') == 'http://lmgtfy.com/?q=foo%20bar'
+
+    assert lmgtfy("foo bar") == "http://lmgtfy.com/?q=foo%20bar"
diff --git a/tests/plugin_tests/test_metars.py b/tests/plugin_tests/test_metars.py
index 60551a48..193d9282 100644
--- a/tests/plugin_tests/test_metars.py
+++ b/tests/plugin_tests/test_metars.py
@@ -1,48 +1,43 @@
 def test_metars(mock_requests):
     mock_requests.add(
-        mock_requests.GET, 'http://api.av-wx.com/metar/ABCD',
-        json={
-            'reports': [
-                {
-                    'name': 'ABCD',
-                    'raw_text': 'Foo Bar Test'
-                }
-            ]
-        }
+        mock_requests.GET,
+        "http://api.av-wx.com/metar/ABCD",
+        json={"reports": [{"name": "ABCD", "raw_text": "Foo Bar Test"}]},
     )
     from plugins.metars import metar
-    assert metar('abcd') == 'ABCD: Foo Bar Test'
+
+    assert metar("abcd") == "ABCD: Foo Bar Test"
 
 
 def test_taf(mock_requests):
     mock_requests.add(
-        mock_requests.GET, 'http://api.av-wx.com/taf/ABCD',
-        json={
-            'reports': [
-                {
-                    'name': 'ABCD',
-                    'raw_text': 'Foo Bar Test'
-                }
-            ]
-        }
+        mock_requests.GET,
+        "http://api.av-wx.com/taf/ABCD",
+        json={"reports": [{"name": "ABCD", "raw_text": "Foo Bar Test"}]},
     )
     from plugins.metars import taf
-    assert taf('abcd') == 'ABCD: Foo Bar Test'
+
+    assert taf("abcd") == "ABCD: Foo Bar Test"
 
 
 def test_invalid_station(mock_requests):
     from plugins.metars import taf
-    invalid_station = "please specify a valid station code " \
-                      "see http://weather.rap.ucar.edu/surface/stations.txt " \
-                      "for a list."
-    assert taf('abc') == invalid_station
+
+    invalid_station = (
+        "please specify a valid station code "
+        "see http://weather.rap.ucar.edu/surface/stations.txt "
+        "for a list."
+    )
+    assert taf("abc") == invalid_station
 
 
 def test_station_not_found(mock_requests):
     mock_requests.add(
-        mock_requests.GET, 'http://api.av-wx.com/taf/ABCD',
+        mock_requests.GET,
+        "http://api.av-wx.com/taf/ABCD",
         json={},
         status=404,
     )
     from plugins.metars import taf
-    assert taf('abcd') == 'Station not found'
+
+    assert taf("abcd") == "Station not found"
diff --git a/tests/plugin_tests/test_optout.py b/tests/plugin_tests/test_optout.py
index 2086914a..5c182b5e 100644
--- a/tests/plugin_tests/test_optout.py
+++ b/tests/plugin_tests/test_optout.py
@@ -5,17 +5,17 @@
 
 
 def test_conn_case():
-    conn_list = optout_cache['TestConnection']
+    conn_list = optout_cache["TestConnection"]
 
-    assert get_conn_optouts('TestConnection') is conn_list
-    assert get_conn_optouts('testconnection') is conn_list
-    assert get_conn_optouts('testconnection1') is not conn_list
+    assert get_conn_optouts("TestConnection") is conn_list
+    assert get_conn_optouts("testconnection") is conn_list
+    assert get_conn_optouts("testconnection1") is not conn_list
 
-    conn_list = optout_cache['testconnection']
+    conn_list = optout_cache["testconnection"]
 
-    assert get_conn_optouts('TestConnection') is conn_list
-    assert get_conn_optouts('testconnection') is conn_list
-    assert get_conn_optouts('testconnection1') is not conn_list
+    assert get_conn_optouts("TestConnection") is conn_list
+    assert get_conn_optouts("testconnection") is conn_list
+    assert get_conn_optouts("testconnection1") is not conn_list
 
 
 def test_ignore_core():
diff --git a/tests/plugin_tests/test_paste_sprunge.py b/tests/plugin_tests/test_paste_sprunge.py
index 6c5363a7..6b38f6c6 100644
--- a/tests/plugin_tests/test_paste_sprunge.py
+++ b/tests/plugin_tests/test_paste_sprunge.py
@@ -12,11 +12,11 @@ def test_register():
 
     sprunge.register()
 
-    assert web.pastebins.get('sprunge') is not None
+    assert web.pastebins.get("sprunge") is not None
 
     sprunge.unregister()
 
-    assert web.pastebins.get('sprunge') is None
+    assert web.pastebins.get("sprunge") is None
 
 
 def test_paste(mock_requests):
@@ -25,12 +25,12 @@ def test_paste(mock_requests):
 
     sprunge.register()
 
-    paster = web.pastebins['sprunge']
+    paster = web.pastebins["sprunge"]
 
     mock_requests.add(
-        'POST', 'http://sprunge.us', body='http://sprunge.us/foobar'
+        "POST", "http://sprunge.us", body="http://sprunge.us/foobar"
     )
-    assert paster.paste('test data', 'txt') == 'http://sprunge.us/foobar?txt'
+    assert paster.paste("test data", "txt") == "http://sprunge.us/foobar?txt"
 
 
 def test_data_params(mock_requests):
@@ -44,14 +44,12 @@ def test_data_params(mock_requests):
     def req_cb(req):
         nonlocal body
         body = req.body
-        return 200, {}, 'http://sprunge.us/foobar\n'
+        return 200, {}, "http://sprunge.us/foobar\n"
 
-    paster = web.pastebins['sprunge']
-    mock_requests.add_callback(
-        'POST', 'http://sprunge.us', callback=req_cb
-    )
-    assert paster.paste('test data', 'txt') == 'http://sprunge.us/foobar?txt'
-    assert body == 'sprunge=test+data'
+    paster = web.pastebins["sprunge"]
+    mock_requests.add_callback("POST", "http://sprunge.us", callback=req_cb)
+    assert paster.paste("test data", "txt") == "http://sprunge.us/foobar?txt"
+    assert body == "sprunge=test+data"
 
 
 def test_paste_bytes(mock_requests):
@@ -60,12 +58,12 @@ def test_paste_bytes(mock_requests):
 
     sprunge.register()
 
-    paster = web.pastebins['sprunge']
+    paster = web.pastebins["sprunge"]
 
     mock_requests.add(
-        'POST', 'http://sprunge.us', body='http://sprunge.us/foobar'
+        "POST", "http://sprunge.us", body="http://sprunge.us/foobar"
     )
-    assert paster.paste(b'test data', 'txt') == 'http://sprunge.us/foobar?txt'
+    assert paster.paste(b"test data", "txt") == "http://sprunge.us/foobar?txt"
 
 
 def test_paste_error(mock_requests):
@@ -74,14 +72,16 @@ def test_paste_error(mock_requests):
 
     sprunge.register()
 
-    paster = web.pastebins['sprunge']
+    paster = web.pastebins["sprunge"]
 
     with pytest.raises(web.ServiceError):
-        paster.paste('test data', 'txt')
+        paster.paste("test data", "txt")
 
     mock_requests.add(
-        'POST', 'http://sprunge.us', status=500,
+        "POST",
+        "http://sprunge.us",
+        status=500,
     )
 
     with pytest.raises(web.ServiceHTTPError):
-        paster.paste('test data', 'txt')
+        paster.paste("test data", "txt")
diff --git a/tests/plugin_tests/test_randomusefulwebsite.py b/tests/plugin_tests/test_randomusefulwebsite.py
index 1fc729d9..19a98b76 100644
--- a/tests/plugin_tests/test_randomusefulwebsite.py
+++ b/tests/plugin_tests/test_randomusefulwebsite.py
@@ -1,11 +1,11 @@
 def test_random_useful_site(mock_requests):
     mock_requests.add(
-        mock_requests.HEAD, 'http://www.discuvver.com/jump2.php',
-        adding_headers={
-            'Location': 'http://example.com/'
-        },
-        status=301
+        mock_requests.HEAD,
+        "http://www.discuvver.com/jump2.php",
+        adding_headers={"Location": "http://example.com/"},
+        status=301,
     )
-    mock_requests.add(mock_requests.HEAD, 'http://example.com/')
+    mock_requests.add(mock_requests.HEAD, "http://example.com/")
     from plugins.randomusefulwebsites import randomusefulwebsite
-    assert randomusefulwebsite() == 'http://example.com/'
+
+    assert randomusefulwebsite() == "http://example.com/"
diff --git a/tests/plugin_tests/test_reddit_info.py b/tests/plugin_tests/test_reddit_info.py
index 40152739..669b6527 100644
--- a/tests/plugin_tests/test_reddit_info.py
+++ b/tests/plugin_tests/test_reddit_info.py
@@ -3,76 +3,96 @@
 import pytest
 
 
-@pytest.mark.parametrize('text,post_id', [
-    ('http://reddit.com/r/foo/comments/bar', 'bar'),
-    ('http://www.reddit.com/r/foo/comments/bar', 'bar'),
-    ('http://np.reddit.com/r/foo/comments/bar', 'bar'),
-    ('np.reddit.com/r/foo/comments/bar', 'bar'),
-    ('reddit.com/r/foo/comments/bar', 'bar'),
-    ('some random text: http://reddit.com/r/foo/comments/bar and more text', 'bar'),
-])
+@pytest.mark.parametrize(
+    "text,post_id",
+    [
+        ("http://reddit.com/r/foo/comments/bar", "bar"),
+        ("http://www.reddit.com/r/foo/comments/bar", "bar"),
+        ("http://np.reddit.com/r/foo/comments/bar", "bar"),
+        ("np.reddit.com/r/foo/comments/bar", "bar"),
+        ("reddit.com/r/foo/comments/bar", "bar"),
+        (
+            "some random text: http://reddit.com/r/foo/comments/bar and more text",
+            "bar",
+        ),
+    ],
+)
 def test_post_re_match(text, post_id):
     from plugins.reddit_info import post_re
+
     match = post_re.search(text)
     assert match and (match.group(1) == post_id)
 
 
-@pytest.mark.parametrize('text', [
-    'https://reddit.com/r/foo',
-    'http://fakereddit.com/r/foo/comments/bar',
-    ' fakereddit.com/r/foo/comments/bar',
-    'fakereddit.com/r/foo/comments/bar',
-])
+@pytest.mark.parametrize(
+    "text",
+    [
+        "https://reddit.com/r/foo",
+        "http://fakereddit.com/r/foo/comments/bar",
+        " fakereddit.com/r/foo/comments/bar",
+        "fakereddit.com/r/foo/comments/bar",
+    ],
+)
 def test_post_re_no_match(text):
     from plugins.reddit_info import post_re
+
     assert not post_re.search(text)
 
 
-@pytest.mark.parametrize('text,output', [
-    ('test', 'test'),
-    ('/test', 'test'),
-    ('test/', 'test'),
-    ('/test/', 'test'),
-    ('r/test', 'test'),
-    ('r/test/', 'test'),
-    ('/r/test', 'test'),
-    ('/r/test/', 'test'),
-])
+@pytest.mark.parametrize(
+    "text,output",
+    [
+        ("test", "test"),
+        ("/test", "test"),
+        ("test/", "test"),
+        ("/test/", "test"),
+        ("r/test", "test"),
+        ("r/test/", "test"),
+        ("/r/test", "test"),
+        ("/r/test/", "test"),
+    ],
+)
 def test_get_user(text, output):
     from plugins.reddit_info import get_sub
+
     assert get_sub(text) == output
 
 
-@pytest.mark.parametrize('text,output', [
-    ('test', 'test'),
-    ('test/', 'test'),
-    ('/test', 'test'),
-    ('/test/', 'test'),
-    ('/u/test', 'test'),
-    ('u/test', 'test'),
-    ('/user/test', 'test'),
-    ('user/test', 'test'),
-    ('/u/test/', 'test'),
-    ('u/test/', 'test'),
-    ('/user/test/', 'test'),
-    ('user/test/', 'test'),
-    ('user', 'user'),
-    ('/user', 'user'),
-    ('user/', 'user'),
-    ('/user/', 'user'),
-    ('u/user', 'user'),
-    ('/u/user', 'user'),
-])
+@pytest.mark.parametrize(
+    "text,output",
+    [
+        ("test", "test"),
+        ("test/", "test"),
+        ("/test", "test"),
+        ("/test/", "test"),
+        ("/u/test", "test"),
+        ("u/test", "test"),
+        ("/user/test", "test"),
+        ("user/test", "test"),
+        ("/u/test/", "test"),
+        ("u/test/", "test"),
+        ("/user/test/", "test"),
+        ("user/test/", "test"),
+        ("user", "user"),
+        ("/user", "user"),
+        ("user/", "user"),
+        ("/user/", "user"),
+        ("u/user", "user"),
+        ("/u/user", "user"),
+    ],
+)
 def test_get_sub(text, output):
     from plugins.reddit_info import get_user
+
     assert get_user(text) == output
 
 
 def test_reddit_no_posts(mock_requests):
     from plugins import reddit_info
+
     mock_requests.add(
-        'GET',
-        'https://reddit.com/r/foobar/.json',
+        "GET",
+        "https://reddit.com/r/foobar/.json",
         json={"data": {"children": []}},
     )
 
diff --git a/tests/plugin_tests/test_shorten.py b/tests/plugin_tests/test_shorten.py
index 3289fab3..0fb3274c 100644
--- a/tests/plugin_tests/test_shorten.py
+++ b/tests/plugin_tests/test_shorten.py
@@ -5,129 +5,130 @@
 
 
 def test_shorten(mock_requests):
-    from plugins import shorten
     from cloudbot.util import web
+    from plugins import shorten
+
     reply = MagicMock()
     with pytest.raises(web.ServiceError):
-        shorten.shorten('https://example.com', reply)
+        shorten.shorten("https://example.com", reply)
 
     assert reply.called
 
     mock_requests.add(
         mock_requests.GET,
-        'http://is.gd/create.php',
-        json={
-            'shorturl': 'https://is.gd/foobar'
-        }
+        "http://is.gd/create.php",
+        json={"shorturl": "https://is.gd/foobar"},
+    )
+    assert (
+        shorten.shorten("https://example.com", reply) == "https://is.gd/foobar"
     )
-    assert shorten.shorten('https://example.com', reply) == 'https://is.gd/foobar'
 
 
 def test_expand(mock_requests):
-    from plugins import shorten
     from cloudbot.util import web
+    from plugins import shorten
+
     reply = MagicMock()
 
     with pytest.raises(web.ServiceError):
-        shorten.expand('https://is.gd/foobar', reply)
+        shorten.expand("https://is.gd/foobar", reply)
 
     mock_requests.add(
         mock_requests.GET,
-        'http://is.gd/forward.php?shorturl=https%3A%2F%2Fis.gd%2Ffoobar&format=json',
-        json={
-            'url': 'https://example.com'
-        }
+        "http://is.gd/forward.php?shorturl=https%3A%2F%2Fis.gd%2Ffoobar&format=json",
+        json={"url": "https://example.com"},
+    )
+    assert (
+        shorten.expand("https://is.gd/foobar", reply) == "https://example.com"
     )
-    assert shorten.expand('https://is.gd/foobar', reply) == 'https://example.com'
 
 
 def test_isgd(mock_requests):
-    from plugins import shorten
     from cloudbot.util import web
+    from plugins import shorten
+
     reply = MagicMock()
 
     with pytest.raises(web.ServiceError):
-        shorten.isgd('https://is.gd/foobar', reply)
+        shorten.isgd("https://is.gd/foobar", reply)
 
     with pytest.raises(web.ServiceError):
-        shorten.isgd('https://example.com/page', reply)
+        shorten.isgd("https://example.com/page", reply)
 
     mock_requests.add(
         mock_requests.GET,
-        'http://is.gd/forward.php?shorturl=https%3A%2F%2Fis.gd%2Ffoobar&format=json',
-        json={
-            'url': 'https://example.com'
-        }
+        "http://is.gd/forward.php?shorturl=https%3A%2F%2Fis.gd%2Ffoobar&format=json",
+        json={"url": "https://example.com"},
     )
-    assert shorten.isgd('https://is.gd/foobar', reply) == 'https://example.com'
+    assert shorten.isgd("https://is.gd/foobar", reply) == "https://example.com"
 
     mock_requests.add(
         mock_requests.GET,
-        'http://is.gd/create.php?url=https%3A%2F%2Fexample.com&format=json',
-        json={
-            'shorturl': 'https://is.gd/foobar'
-        }
+        "http://is.gd/create.php?url=https%3A%2F%2Fexample.com&format=json",
+        json={"shorturl": "https://is.gd/foobar"},
     )
-    assert shorten.isgd('https://example.com', reply) == 'https://is.gd/foobar'
+    assert shorten.isgd("https://example.com", reply) == "https://is.gd/foobar"
 
 
 def test_googl(mock_requests):
-    from plugins import shorten
     from cloudbot.util import web
+    from plugins import shorten
+
     reply = MagicMock()
 
     with pytest.raises(web.ServiceError):
-        shorten.googl('https://goo.gl/foobar', reply)
+        shorten.googl("https://goo.gl/foobar", reply)
 
     with pytest.raises(web.ServiceError):
-        shorten.googl('https://example.com/page', reply)
+        shorten.googl("https://example.com/page", reply)
 
     mock_requests.add(
         mock_requests.GET,
-        'https://www.googleapis.com/urlshortener/v1/url?shortUrl=https%3A%2F%2Fgoo.gl%2Ffoobar',
-        json={
-            'longUrl': 'https://example.com'
-        }
+        "https://www.googleapis.com/urlshortener/v1/url?shortUrl=https%3A%2F%2Fgoo.gl%2Ffoobar",
+        json={"longUrl": "https://example.com"},
+    )
+    assert (
+        shorten.googl("https://goo.gl/foobar", reply) == "https://example.com"
     )
-    assert shorten.googl('https://goo.gl/foobar', reply) == 'https://example.com'
 
     mock_requests.add(
         mock_requests.POST,
-        'https://www.googleapis.com/urlshortener/v1/url',
-        json={
-            'id': 'https://goo.gl/foobar'
-        }
+        "https://www.googleapis.com/urlshortener/v1/url",
+        json={"id": "https://goo.gl/foobar"},
+    )
+    assert (
+        shorten.googl("https://example.com", reply) == "https://goo.gl/foobar"
     )
-    assert shorten.googl('https://example.com', reply) == 'https://goo.gl/foobar'
 
 
 def test_gitio(mock_requests):
-    from plugins import shorten
     from cloudbot.util import web
+    from plugins import shorten
+
     reply = MagicMock()
 
     with pytest.raises(web.ServiceError):
-        shorten.gitio('https://git.io/foobar', reply)
+        shorten.gitio("https://git.io/foobar", reply)
 
     with pytest.raises(web.ServiceError):
-        shorten.gitio('https://example.com/page', reply)
+        shorten.gitio("https://example.com/page", reply)
 
     mock_requests.add(
         mock_requests.GET,
-        'https://git.io/foobar',
+        "https://git.io/foobar",
         status=301,
-        headers={
-            'Location': 'https://example.com'
-        }
+        headers={"Location": "https://example.com"},
+    )
+    assert (
+        shorten.gitio("https://git.io/foobar", reply) == "https://example.com"
     )
-    assert shorten.gitio('https://git.io/foobar', reply) == 'https://example.com'
 
     mock_requests.add(
         mock_requests.POST,
-        'http://git.io',
-        headers={
-            'Location': 'https://git.io/foobar'
-        },
-        status=requests.codes.created
+        "http://git.io",
+        headers={"Location": "https://git.io/foobar"},
+        status=requests.codes.created,
+    )
+    assert (
+        shorten.gitio("https://example.com", reply) == "https://git.io/foobar"
     )
-    assert shorten.gitio('https://example.com', reply) == 'https://git.io/foobar'
diff --git a/tests/plugin_tests/test_stock.py b/tests/plugin_tests/test_stock.py
index 4266412f..7eaf79aa 100644
--- a/tests/plugin_tests/test_stock.py
+++ b/tests/plugin_tests/test_stock.py
@@ -1,24 +1,28 @@
 import pytest
 
 
-@pytest.mark.parametrize('number,output', [
-    (0, '0.00'),
-    (1, '1.00'),
-    (10, '10.00'),
-    (100, '100.00'),
-    (1000, '1,000.00'),
-    (10000, '10,000.00'),
-    (100000, '100,000.00'),
-    (1000000, '1.00M'),
-    (10000000, '10.00M'),
-    (100000000, '100.00M'),
-    (1000000000, '1.00B'),
-    (10000000000, '10.00B'),
-    (100000000000, '100.00B'),
-    (1000000000000, '1.00T'),
-    (8676423467886, '8.68T'),
-    (-0.000001234, '-0.00'),
-])
+@pytest.mark.parametrize(
+    "number,output",
+    [
+        (0, "0.00"),
+        (1, "1.00"),
+        (10, "10.00"),
+        (100, "100.00"),
+        (1000, "1,000.00"),
+        (10000, "10,000.00"),
+        (100000, "100,000.00"),
+        (1000000, "1.00M"),
+        (10000000, "10.00M"),
+        (100000000, "100.00M"),
+        (1000000000, "1.00B"),
+        (10000000000, "10.00B"),
+        (100000000000, "100.00B"),
+        (1000000000000, "1.00T"),
+        (8676423467886, "8.68T"),
+        (-0.000001234, "-0.00"),
+    ],
+)
 def test_format_money(number, output):
     from plugins import stock
+
     assert stock.format_money(number) == output
diff --git a/tests/plugin_tests/test_tell.py b/tests/plugin_tests/test_tell.py
index eb6241af..dca9091b 100644
--- a/tests/plugin_tests/test_tell.py
+++ b/tests/plugin_tests/test_tell.py
@@ -7,13 +7,14 @@
 def test_tellcmd(mock_db):
     from cloudbot.util import database
     from plugins import tell
+
     database = importlib.reload(database)
     importlib.reload(tell)
     metadata = database.metadata
 
-    assert 'tells' in metadata.tables
-    assert 'tell_ignores' in metadata.tables
-    assert 'tell_user_ignores' in metadata.tables
+    assert "tells" in metadata.tables
+    assert "tell_ignores" in metadata.tables
+    assert "tell_user_ignores" in metadata.tables
 
     db_engine = mock_db.engine
     metadata.create_all(db_engine)
@@ -59,7 +60,7 @@ def _test(text, output):
 
     _test(
         "OtherUser some message",
-        "Your message has been saved, and OtherUser will be notified once they are active."
+        "Your message has been saved, and OtherUser will be notified once they are active.",
     )
 
     assert tell.count_unread(session, mock_conn.name, "OtherUser") == 1
@@ -67,7 +68,7 @@ def _test(text, output):
     for i in range(9):
         _test(
             "OtherUser some message",
-            "Your message has been saved, and OtherUser will be notified once they are active."
+            "Your message has been saved, and OtherUser will be notified once they are active.",
         )
 
         assert tell.count_unread(session, mock_conn.name, "OtherUser") == 2 + i
@@ -76,33 +77,24 @@ def _test(text, output):
 
     _test(
         "OtherUser some message",
-        "Sorry, OtherUser has too many messages queued already."
+        "Sorry, OtherUser has too many messages queued already.",
     )
 
     assert tell.count_unread(session, mock_conn.name, "OtherUser") == 10
 
     mock_event.is_nick_valid.return_value = False
 
-    _test(
-        "OtherUser some message",
-        "Invalid nick 'OtherUser'."
-    )
+    _test("OtherUser some message", "Invalid nick 'OtherUser'.")
 
     assert tell.count_unread(session, mock_conn.name, "OtherUser") == 10
 
     mock_event.is_nick_valid.return_value = True
-    _test(
-        sender.nick + " some message",
-        "Have you looked in a mirror lately?"
-    )
+    _test(sender.nick + " some message", "Have you looked in a mirror lately?")
 
     assert tell.count_unread(session, mock_conn.name, "OtherUser") == 10
 
-    with patch('plugins.tell.can_send_to_user') as mocked:
+    with patch("plugins.tell.can_send_to_user") as mocked:
         mocked.return_value = False
-        _test(
-            "OtherUser some message",
-            "You may not send a tell to that user."
-        )
+        _test("OtherUser some message", "You may not send a tell to that user.")
 
     assert tell.count_unread(session, mock_conn.name, "OtherUser") == 10
diff --git a/tests/plugin_tests/test_vimeo.py b/tests/plugin_tests/test_vimeo.py
index 72e42b51..6a3fe37b 100644
--- a/tests/plugin_tests/test_vimeo.py
+++ b/tests/plugin_tests/test_vimeo.py
@@ -6,7 +6,7 @@
 
 @pytest.fixture()
 def patch_get_json():
-    with patch('cloudbot.util.http.get_json') as patched:
+    with patch("cloudbot.util.http.get_json") as patched:
         yield patched
 
 
@@ -26,7 +26,7 @@ def patch_get_json():
         "width": 320,
         "height": 240,
         "tags": "foo, bar",
-        "embed_privacy": "anywhere"
+        "embed_privacy": "anywhere",
     }
 ]
 
@@ -49,14 +49,14 @@ def test_no_likes(patch_get_json):
     result = vimeo.vimeo_url(vimeo.url_re.search("https://vimeo.com/11235"))
 
     expected_parts = [
-        '\x02A video title\x02',
-        'length \x0244 seconds\x02',
-        '\x020\x02 likes',
-        '\x02106\x02 plays',
-        '\x02AUser\x02 on \x022006-10-24 22:56:45\x02',
+        "\x02A video title\x02",
+        "length \x0244 seconds\x02",
+        "\x020\x02 likes",
+        "\x02106\x02 plays",
+        "\x02AUser\x02 on \x022006-10-24 22:56:45\x02",
     ]
 
-    expected = ' - '.join(expected_parts)
+    expected = " - ".join(expected_parts)
 
     assert result == expected
 
@@ -73,13 +73,13 @@ def test_with_likes(patch_get_json):
     result = vimeo.vimeo_url(vimeo.url_re.search("https://vimeo.com/11235"))
 
     expected_parts = [
-        '\x02A video title\x02',
-        'length \x0244 seconds\x02',
-        '\x0254\x02 likes',
-        '\x02106\x02 plays',
-        '\x02AUser\x02 on \x022006-10-24 22:56:45\x02',
+        "\x02A video title\x02",
+        "length \x0244 seconds\x02",
+        "\x0254\x02 likes",
+        "\x02106\x02 plays",
+        "\x02AUser\x02 on \x022006-10-24 22:56:45\x02",
     ]
 
-    expected = ' - '.join(expected_parts)
+    expected = " - ".join(expected_parts)
 
     assert result == expected
diff --git a/tests/plugin_tests/test_wikipedia.py b/tests/plugin_tests/test_wikipedia.py
index 181545f3..8fb08e1d 100644
--- a/tests/plugin_tests/test_wikipedia.py
+++ b/tests/plugin_tests/test_wikipedia.py
@@ -14,86 +14,89 @@ def do_search(query, results=None):
     conn.bot = None
 
     cmd_event = CommandEvent(
-        text=query, cmd_prefix='.',
-        triggered_command='wiki',
-        hook=MagicMock(), bot=conn.bot,
-        conn=conn, channel='#foo',
-        nick='foobaruser'
+        text=query,
+        cmd_prefix=".",
+        triggered_command="wiki",
+        hook=MagicMock(),
+        bot=conn.bot,
+        conn=conn,
+        channel="#foo",
+        nick="foobaruser",
     )
 
     return wrap_hook_response(wikipedia.wiki, cmd_event, results=results)
 
 
 def make_search_url(query):
-    query = query.replace(' ', '+')
-    return 'http://en.wikipedia.org/w/api.php?action=query&format=json&list=search' \
-           '&redirect=1&srsearch=' + query
+    query = query.replace(" ", "+")
+    return (
+        "http://en.wikipedia.org/w/api.php?action=query&format=json&list=search"
+        "&redirect=1&srsearch=" + query
+    )
 
 
 def test_search(mock_requests):
     err_results = []
     with pytest.raises(RequestException):
-        do_search('some failed query', err_results)
+        do_search("some failed query", err_results)
 
     assert err_results == [
-        ('message', ('#foo', '(foobaruser) Could not get Wikipedia page'))
+        ("message", ("#foo", "(foobaruser) Could not get Wikipedia page"))
     ]
 
     mock_requests.add(
-        'GET',
-        make_search_url('some search'),
-        json={
-            'query': {
-                'search': []
-            }
-        }
+        "GET", make_search_url("some search"), json={"query": {"search": []}}
     )
 
-    results = do_search('some search')
+    results = do_search("some search")
 
-    assert results == [('return', 'No results found.')]
+    assert results == [("return", "No results found.")]
 
     mock_requests.add(
-        'GET',
-        make_search_url('a search'),
+        "GET",
+        make_search_url("a search"),
         json={
-            'query': {
-                'search': [
+            "query": {
+                "search": [
+                    {"title": "Other title"},
                     {
-                        'title': 'Other title'
+                        "title": "A title",
                     },
-                    {
-                        'title': 'A title',
-                    }
                 ]
             }
-        }
+        },
     )
 
-    mock_requests.add('GET', wikipedia.make_summary_url('Other title'), json={
-        'type': 'nonstandard'
-    })
+    mock_requests.add(
+        "GET",
+        wikipedia.make_summary_url("Other title"),
+        json={"type": "nonstandard"},
+    )
 
-    mock_requests.add('GET', wikipedia.make_summary_url('A title'), json={
-        'type': 'standard',
-        'extract': 'Some description',
-        'content_urls': {
-            'desktop': {'page': 'Some url'}
-        }
-    })
+    mock_requests.add(
+        "GET",
+        wikipedia.make_summary_url("A title"),
+        json={
+            "type": "standard",
+            "extract": "Some description",
+            "content_urls": {"desktop": {"page": "Some url"}},
+        },
+    )
 
-    results = do_search('a search')
+    results = do_search("a search")
 
-    assert results == [('return', 'A title :: Some description :: Some url')]
+    assert results == [("return", "A title :: Some description :: Some url")]
 
-    mock_requests.replace('GET', wikipedia.make_summary_url('A title'), json={
-        'type': 'standard',
-        'extract': '',
-        'content_urls': {
-            'desktop': {'page': 'Some url'}
-        }
-    })
+    mock_requests.replace(
+        "GET",
+        wikipedia.make_summary_url("A title"),
+        json={
+            "type": "standard",
+            "extract": "",
+            "content_urls": {"desktop": {"page": "Some url"}},
+        },
+    )
 
-    results = do_search('a search')
+    results = do_search("a search")
 
-    assert results == [('return', 'A title :: (No Summary) :: Some url')]
+    assert results == [("return", "A title :: (No Summary) :: Some url")]
diff --git a/tests/plugin_tests/test_xkcd.py b/tests/plugin_tests/test_xkcd.py
index 8b3190ec..d1c26886 100644
--- a/tests/plugin_tests/test_xkcd.py
+++ b/tests/plugin_tests/test_xkcd.py
@@ -4,40 +4,41 @@
 
 import pytest
 
-DATA_PATH = Path().resolve() / 'tests' / 'data' / 'xkcd'
+DATA_PATH = Path().resolve() / "tests" / "data" / "xkcd"
 
 
 def get_files():
-    for file in DATA_PATH.rglob('*.json'):
+    for file in DATA_PATH.rglob("*.json"):
         yield int(file.stem)
 
 
 def load_data(xkcd_id):
-    file = DATA_PATH / '{}.json'.format(xkcd_id)
+    file = DATA_PATH / "{}.json".format(xkcd_id)
 
     with file.open() as f:
         return json.load(f)
 
 
-@pytest.mark.parametrize('xkcd_id', list(get_files()))
+@pytest.mark.parametrize("xkcd_id", list(get_files()))
 def test_info(xkcd_id, mock_requests):
     from plugins import xkcd
+
     data = load_data(xkcd_id)
     mock_requests.add(
         mock_requests.GET,
-        'http://www.xkcd.com/{}/info.0.json'.format(xkcd_id),
+        "http://www.xkcd.com/{}/info.0.json".format(xkcd_id),
         json=data,
     )
 
     date = datetime.date(
-        year=int(data['year']),
-        month=int(data['month']),
-        day=int(data['day']),
+        year=int(data["year"]),
+        month=int(data["month"]),
+        day=int(data["day"]),
     )
 
-    no_url = 'xkcd: \x02{}\x02 ({:%d %B %Y})'.format(data['title'], date)
+    no_url = "xkcd: \x02{}\x02 ({:%d %B %Y})".format(data["title"], date)
 
-    with_url = no_url + ' | http://www.xkcd.com/{}'.format(xkcd_id)
+    with_url = no_url + " | http://www.xkcd.com/{}".format(xkcd_id)
 
     assert xkcd.xkcd_info(str(xkcd_id)) == no_url
     assert xkcd.xkcd_info(str(xkcd_id), True) == with_url
diff --git a/tests/plugin_tests/test_yelling.py b/tests/plugin_tests/test_yelling.py
index c4d03600..19859a72 100644
--- a/tests/plugin_tests/test_yelling.py
+++ b/tests/plugin_tests/test_yelling.py
@@ -9,17 +9,19 @@ def test_yell_check():
     from plugins.yelling import yell_check
 
     plugin_manager.find_plugin.return_value = None
-    yell_check(conn, '#yelling', 'aaaaaaaaaaaaaa', bot, 'testuser')
+    yell_check(conn, "#yelling", "aaaaaaaaaaaaaa", bot, "testuser")
 
-    conn.cmd.assert_called_with('KICK', '#yelling', 'testuser', "USE MOAR CAPS YOU TROGLODYTE!")
+    conn.cmd.assert_called_with(
+        "KICK", "#yelling", "testuser", "USE MOAR CAPS YOU TROGLODYTE!"
+    )
     conn.cmd.reset_mock()
 
-    yell_check(conn, '#yelling', '11', bot, 'testuser')
+    yell_check(conn, "#yelling", "11", bot, "testuser")
 
     conn.cmd.assert_not_called()
     conn.cmd.reset_mock()
 
-    yell_check(conn, '#yelling1', '11', bot, 'testuser')
+    yell_check(conn, "#yelling1", "11", bot, "testuser")
 
     conn.cmd.assert_not_called()
     conn.cmd.reset_mock()
@@ -27,9 +29,14 @@ def test_yell_check():
     plugin_manager.find_plugin.return_value = fake_plugin = MagicMock()
 
     from plugins.link_announcer import url_re
+
     fake_plugin.code.url_re = url_re
 
-    yell_check(conn, '#yelling', 'http://a aaaaaaaaaaaaaaaaaaaaaa', bot, 'testuser')
+    yell_check(
+        conn, "#yelling", "http://a aaaaaaaaaaaaaaaaaaaaaa", bot, "testuser"
+    )
 
-    conn.cmd.assert_called_with('KICK', '#yelling', 'testuser', "USE MOAR CAPS YOU TROGLODYTE!")
+    conn.cmd.assert_called_with(
+        "KICK", "#yelling", "testuser", "USE MOAR CAPS YOU TROGLODYTE!"
+    )
     conn.cmd.reset_mock()
diff --git a/tests/plugin_tests/tvdb_test.py b/tests/plugin_tests/tvdb_test.py
index ceb623a1..039128ca 100644
--- a/tests/plugin_tests/tvdb_test.py
+++ b/tests/plugin_tests/tvdb_test.py
@@ -48,14 +48,18 @@ def test_token(mock_requests, reset_api, mock_api_keys):
 
 def test_refresh(mock_requests, reset_api, mock_api_keys, enable_api):
     mock_requests.add(
-        "GET", "https://api.thetvdb.com/refresh_token", json={"token": "foobar1"}
+        "GET",
+        "https://api.thetvdb.com/refresh_token",
+        json={"token": "foobar1"},
     )
     tvdb.refresh(MagicMock(config=bot.config))
     assert tvdb.api.jwt_token == "foobar1"
 
 
 def test_refresh_expired(mock_requests, reset_api, mock_api_keys, enable_api):
-    mock_requests.add("GET", "https://api.thetvdb.com/refresh_token", status=401)
+    mock_requests.add(
+        "GET", "https://api.thetvdb.com/refresh_token", status=401
+    )
     mock_requests.add(
         "POST", "https://api.thetvdb.com/login", json={"token": "foobar2"}
     )
@@ -63,8 +67,12 @@ def test_refresh_expired(mock_requests, reset_api, mock_api_keys, enable_api):
     assert tvdb.api.jwt_token == "foobar2"
 
 
-def test_refresh_other_error(mock_requests, reset_api, mock_api_keys, enable_api):
-    mock_requests.add("GET", "https://api.thetvdb.com/refresh_token", status=502)
+def test_refresh_other_error(
+    mock_requests, reset_api, mock_api_keys, enable_api
+):
+    mock_requests.add(
+        "GET", "https://api.thetvdb.com/refresh_token", status=502
+    )
     with pytest.raises(requests.HTTPError):
         tvdb.api.refresh_token(MagicMock(config=bot.config))
 
@@ -241,7 +249,9 @@ def test_no_episodes(self, mock_requests, enable_api):
             "GET",
             "https://api.thetvdb.com/series/5/episodes?page=1",
             match_querystring=True,
-            json={"data": [],},
+            json={
+                "data": [],
+            },
         )
 
         res = self.call("Foo")
@@ -268,7 +278,9 @@ def test_no_episodes_404(self, mock_requests, enable_api):
             "GET",
             "https://api.thetvdb.com/series/5/episodes?page=1",
             match_querystring=True,
-            json={"data": [],},
+            json={
+                "data": [],
+            },
             status=404,
         )
 
@@ -344,7 +356,10 @@ def test_only_old_eps(self, mock_requests, enable_api):
         res = self.call("Foo")
         if self.shows_old_eps():
             assert res == [
-                ("return", "The last episode of Foo: Bar aired 2017-02-02 (S01E01).")
+                (
+                    "return",
+                    "The last episode of Foo: Bar aired 2017-02-02 (S01E01).",
+                )
             ]
         else:
             assert res == [
@@ -386,11 +401,17 @@ def test_only_new_eps(self, mock_requests, enable_api):
         res = self.call("Foo")
         if self.shows_new_eps():
             assert res == [
-                ("return", "The next episode of Foo: Bar airs 2020-02-02 (S01E01)")
+                (
+                    "return",
+                    "The next episode of Foo: Bar airs 2020-02-02 (S01E01)",
+                )
             ]
         else:
             assert res == [
-                ("return", "There are no previously aired episodes for Foo: Bar.")
+                (
+                    "return",
+                    "There are no previously aired episodes for Foo: Bar.",
+                )
             ]
 
     def test_only_new_eps_tba(self, mock_requests, enable_api):
@@ -438,7 +459,10 @@ def test_only_new_eps_tba(self, mock_requests, enable_api):
                         "firstAired": "2020-02-05",
                         "episodeName": "baz",
                     },
-                    {"airedEpisodeNumber": 4, "airedSeason": 1,},
+                    {
+                        "airedEpisodeNumber": 4,
+                        "airedSeason": 1,
+                    },
                 ],
             },
         )
@@ -453,7 +477,10 @@ def test_only_new_eps_tba(self, mock_requests, enable_api):
             ]
         else:
             assert res == [
-                ("return", "There are no previously aired episodes for Foo: Bar.")
+                (
+                    "return",
+                    "There are no previously aired episodes for Foo: Bar.",
+                )
             ]
 
     def test_series_ended(self, mock_requests, enable_api):
@@ -528,7 +555,10 @@ def test_only_new_eps_tba_no_name(self, mock_requests, enable_api):
                         "airedSeason": 1,
                         "firstAired": "2020-02-02",
                     },
-                    {"airedEpisodeNumber": 2, "airedSeason": 1,},
+                    {
+                        "airedEpisodeNumber": 2,
+                        "airedSeason": 1,
+                    },
                 ],
             },
         )
@@ -569,7 +599,9 @@ def shows_new_eps(self):
         return False
 
     def get_no_ep_msg(self):
-        return [("return", "There are no previously aired episodes for Foo: Bar.")]
+        return [
+            ("return", "There are no previously aired episodes for Foo: Bar.")
+        ]
 
     def get_func(self):
         return tvdb.tv_last