diff --git a/protocols/clientbot.py b/protocols/clientbot.py
index 0d4551a..56d9033 100644
--- a/protocols/clientbot.py
+++ b/protocols/clientbot.py
@@ -113,7 +113,7 @@ class ClientbotWrapperProtocol(IRCCommonProtocol):
                                           manipulatable=manipulatable, realhost=realhost, ip=ip)
         self.servers[server].users.add(uid)
 
-        self.applyModes(uid, modes)
+        self.apply_modes(uid, modes)
 
         return u
 
@@ -128,22 +128,22 @@ class ClientbotWrapperProtocol(IRCCommonProtocol):
 
     def away(self, source, text):
         """STUB: sets away messages for clients internally."""
-        log.debug('(%s) away: target is %s, internal client? %s', self.name, source, self.isInternalClient(source))
+        log.debug('(%s) away: target is %s, internal client? %s', self.name, source, self.is_internal_client(source))
 
         if self.users[source].away != text:
-            if not self.isInternalClient(source):
+            if not self.is_internal_client(source):
                 log.debug('(%s) away: sending AWAY hook from %s with text %r', self.name, source, text)
-                self.callHooks([source, 'AWAY', {'text': text}])
+                self.call_hooks([source, 'AWAY', {'text': text}])
 
             self.users[source].away = text
 
     def invite(self, client, target, channel):
         """Invites a user to a channel."""
-        self.send('INVITE %s %s' % (self.getFriendlyName(target), channel))
+        self.send('INVITE %s %s' % (self.get_friendly_name(target), channel))
 
     def join(self, client, channel):
         """STUB: Joins a user to a channel."""
-        channel = self.toLower(channel)
+        channel = self.to_lower(channel)
 
         # Only joins for the main PyLink client are actually forwarded. Others are ignored.
         # Note: we do not automatically add our main client to the channel state, as we
@@ -159,25 +159,25 @@ class ClientbotWrapperProtocol(IRCCommonProtocol):
             self.users[client].channels.add(channel)
 
             log.debug('(%s) join: faking JOIN of client %s/%s to %s', self.name, client,
-                      self.getFriendlyName(client), channel)
-            self.callHooks([client, 'CLIENTBOT_JOIN', {'channel': channel}])
+                      self.get_friendly_name(client), channel)
+            self.call_hooks([client, 'CLIENTBOT_JOIN', {'channel': channel}])
 
     def kick(self, source, channel, target, reason=''):
         """Sends channel kicks."""
 
         log.debug('(%s) kick: checking if target %s (nick: %s) is an internal client? %s',
-                  self.name, target, self.getFriendlyName(target),
-                  self.isInternalClient(target))
-        if self.isInternalClient(target):
+                  self.name, target, self.get_friendly_name(target),
+                  self.is_internal_client(target))
+        if self.is_internal_client(target):
             # Target was one of our virtual clients. Just remove them from the state.
             self.handle_part(target, 'KICK', [channel, reason])
 
             # Send a KICK hook for message formatting.
-            self.callHooks([source, 'CLIENTBOT_KICK', {'channel': channel, 'target': target, 'text': reason}])
+            self.call_hooks([source, 'CLIENTBOT_KICK', {'channel': channel, 'target': target, 'text': reason}])
             return
 
         self.send('KICK %s %s :<%s> %s' % (channel, self._expandPUID(target),
-                      self.getFriendlyName(source), reason))
+                      self.get_friendly_name(source), reason))
 
         # Don't update our state here: wait for the IRCd to send an acknowledgement instead.
         # There is essentially a 3 second wait to do this, as we send NAMES with a delay
@@ -201,7 +201,7 @@ class ClientbotWrapperProtocol(IRCCommonProtocol):
         if self.pseudoclient and self.pseudoclient.uid == source:
             self.send('%s %s :%s' % (command, self._expandPUID(target), text))
         else:
-            self.callHooks([source, 'CLIENTBOT_MESSAGE', {'target': target, 'is_notice': notice, 'text': text}])
+            self.call_hooks([source, 'CLIENTBOT_MESSAGE', {'target': target, 'is_notice': notice, 'text': text}])
 
     def mode(self, source, channel, modes, ts=None):
         """Sends channel MODE changes."""
@@ -212,24 +212,24 @@ class ClientbotWrapperProtocol(IRCCommonProtocol):
             # with IRCd MODE acknowledgements.
             # FIXME: More related safety checks should be added for this.
             log.debug('(%s) mode: re-parsing modes %s', self.name, modes)
-            joined_modes = self.joinModes(modes)
-            for modepair in self.parseModes(channel, joined_modes):
+            joined_modes = self.join_modes(modes)
+            for modepair in self.parse_modes(channel, joined_modes):
                 log.debug('(%s) mode: checking if %s a prefix mode: %s', self.name, modepair, self.prefixmodes)
                 if modepair[0][-1] in self.prefixmodes:
-                    if self.isInternalClient(modepair[1]):
+                    if self.is_internal_client(modepair[1]):
                         # Ignore prefix modes for virtual internal clients.
                         log.debug('(%s) mode: skipping virtual client prefixmode change %s', self.name, modepair)
                         continue
                     else:
                         # For other clients, change the mode argument to nick instead of PUID.
-                        nick = self.getFriendlyName(modepair[1])
+                        nick = self.get_friendly_name(modepair[1])
                         log.debug('(%s) mode: coersing mode %s argument to %s', self.name, modepair, nick)
                         modepair = (modepair[0], nick)
                 extmodes.append(modepair)
 
             log.debug('(%s) mode: filtered modes for %s: %s', self.name, channel, extmodes)
             if extmodes:
-                self.send('MODE %s %s' % (channel, self.joinModes(extmodes)))
+                self.send('MODE %s %s' % (channel, self.join_modes(extmodes)))
                 # Don't update the state here: the IRCd sill respond with a MODE reply if successful.
 
     def nick(self, source, newnick):
@@ -238,7 +238,7 @@ class ClientbotWrapperProtocol(IRCCommonProtocol):
             self.send('NICK :%s' % newnick)
             # No state update here: the IRCd will respond with a NICK acknowledgement if the change succeeds.
         else:
-            self.callHooks([source, 'CLIENTBOT_NICK', {'newnick': newnick}])
+            self.call_hooks([source, 'CLIENTBOT_NICK', {'newnick': newnick}])
             self.users[source].nick = newnick
 
     def notice(self, source, target, text):
@@ -251,7 +251,7 @@ class ClientbotWrapperProtocol(IRCCommonProtocol):
         Sends PING to the uplink.
         """
         if self.uplink:
-            self.send('PING %s' % self.getFriendlyName(self.uplink))
+            self.send('PING %s' % self.get_friendly_name(self.uplink))
 
             # Poll WHO periodically to figure out any ident/host/away status changes.
             for channel in self.pseudoclient.channels:
@@ -266,13 +266,13 @@ class ClientbotWrapperProtocol(IRCCommonProtocol):
         if self.pseudoclient and source == self.pseudoclient.uid:
             self.send('PART %s :%s' % (channel, reason))
         else:
-            self.callHooks([source, 'CLIENTBOT_PART', {'channel': channel, 'text': reason}])
+            self.call_hooks([source, 'CLIENTBOT_PART', {'channel': channel, 'text': reason}])
 
     def quit(self, source, reason):
         """STUB: Quits a client."""
         userdata = self.users[source]
         self._remove_client(source)
-        self.callHooks([source, 'CLIENTBOT_QUIT', {'text': reason, 'userdata': userdata}])
+        self.call_hooks([source, 'CLIENTBOT_QUIT', {'text': reason, 'userdata': userdata}])
 
     def sjoin(self, server, channel, users, ts=None, modes=set()):
         """STUB: bursts joins from a server."""
@@ -288,8 +288,8 @@ class ClientbotWrapperProtocol(IRCCommonProtocol):
                 self.users[user].channels.add(channel)
 
         self.channels[channel].users |= puids
-        nicks = {self.getFriendlyName(u) for u in puids}
-        self.callHooks([server, 'CLIENTBOT_SJOIN', {'channel': channel, 'nicks': nicks}])
+        nicks = {self.get_friendly_name(u) for u in puids}
+        self.call_hooks([server, 'CLIENTBOT_SJOIN', {'channel': channel, 'nicks': nicks}])
 
     def squit(self, source, target, text):
         """STUB: SQUITs a server."""
@@ -298,7 +298,7 @@ class ClientbotWrapperProtocol(IRCCommonProtocol):
         squit_data = self._squit(source, 'CLIENTBOT_VIRTUAL_SQUIT', [target, text])
 
         if squit_data.get('nicks'):
-            self.callHooks([source, 'CLIENTBOT_SQUIT', squit_data])
+            self.call_hooks([source, 'CLIENTBOT_SQUIT', squit_data])
 
     def _stub(self, *args):
         """Stub outgoing command function (does nothing)."""
@@ -315,20 +315,20 @@ class ClientbotWrapperProtocol(IRCCommonProtocol):
 
         if field == 'IDENT' and u.ident != text:
             u.ident = text
-            if not self.isInternalClient(target):
+            if not self.is_internal_client(target):
                 # We're updating the host of an external client in our state, so send the appropriate
                 # hook payloads.
-                self.callHooks([self.sid, 'CHGIDENT',
+                self.call_hooks([self.sid, 'CHGIDENT',
                                    {'target': target, 'newident': text}])
         elif field == 'HOST' and u.host != text:
             u.host = text
-            if not self.isInternalClient(target):
-                self.callHooks([self.sid, 'CHGHOST',
+            if not self.is_internal_client(target):
+                self.call_hooks([self.sid, 'CHGHOST',
                                    {'target': target, 'newhost': text}])
         elif field in ('REALNAME', 'GECOS') and u.realname != text:
             u.realname = text
-            if not self.isInternalClient(target):
-                self.callHooks([self.sid, 'CHGNAME',
+            if not self.is_internal_client(target):
+                self.call_hooks([self.sid, 'CHGNAME',
                                    {'target': target, 'newgecos': text}])
         else:
             return  # Nothing changed
@@ -340,8 +340,8 @@ class ClientbotWrapperProtocol(IRCCommonProtocol):
         Limited (internal) nick collision checking is done here to prevent Clientbot users from
         being confused with virtual clients, and vice versa."""
         self._validateNick(nick)
-        idsource = self.nickToUid(nick)
-        is_internal = self.isInternalClient(idsource)
+        idsource = self.nick_to_uid(nick)
+        is_internal = self.is_internal_client(idsource)
 
         # If this sender isn't known or it is one of our virtual clients, spawn a new one.
         # This also takes care of any nick collisions caused by new, Clientbot users
@@ -349,7 +349,7 @@ class ClientbotWrapperProtocol(IRCCommonProtocol):
         if (not idsource) or (is_internal and self.pseudoclient and idsource != self.pseudoclient.uid):
             if idsource:
                 log.debug('(%s) Nick-colliding virtual client %s/%s', self.name, idsource, nick)
-                self.callHooks([self.sid, 'CLIENTBOT_NICKCOLLIDE', {'target': idsource, 'parse_as': 'SAVE'}])
+                self.call_hooks([self.sid, 'CLIENTBOT_NICKCOLLIDE', {'target': idsource, 'parse_as': 'SAVE'}])
 
             idsource = self.spawnClient(nick, ident or 'unknown', host or 'unknown',
                                         server=self.uplink, realname=FALLBACK_REALNAME).uid
@@ -634,9 +634,9 @@ class ClientbotWrapperProtocol(IRCCommonProtocol):
         # <- :charybdis.midnight.vpn 353 ice = #test :ice @GL
 
         # Mark "@"-type channels as secret automatically, per RFC2812.
-        channel = self.toLower(args[2])
+        channel = self.to_lower(args[2])
         if args[1] == '@':
-            self.applyModes(channel, [('+s', None)])
+            self.apply_modes(channel, [('+s', None)])
 
         names = set()
         modes = set()
@@ -667,7 +667,7 @@ class ClientbotWrapperProtocol(IRCCommonProtocol):
 
         # Statekeeping: make sure the channel's user list is updated!
         self.channels[channel].users |= names
-        self.applyModes(channel, modes)
+        self.apply_modes(channel, modes)
 
         log.debug('(%s) handle_353: adding users %s to %s', self.name, names, channel)
         log.debug('(%s) handle_353: adding modes %s to %s', self.name, modes, channel)
@@ -705,7 +705,7 @@ class ClientbotWrapperProtocol(IRCCommonProtocol):
         realname = args[-1].split(' ', 1)[-1]
 
         self._validateNick(nick)
-        uid = self.nickToUid(nick)
+        uid = self.nick_to_uid(nick)
 
         if uid is None:
             log.debug("(%s) Ignoring extraneous /WHO info for %s", self.name, nick)
@@ -732,15 +732,15 @@ class ClientbotWrapperProtocol(IRCCommonProtocol):
 
         if self.serverdata.get('track_oper_statuses'):
             if '*' in status:  # Track IRCop status
-                if not self.isOper(uid, allowAuthed=False):
+                if not self.is_oper(uid, allowAuthed=False):
                     # Don't send duplicate oper ups if the target is already oper.
-                    self.applyModes(uid, [('+o', None)])
-                    self.callHooks([uid, 'MODE', {'target': uid, 'modes': {('+o', None)}}])
-                    self.callHooks([uid, 'CLIENT_OPERED', {'text': 'IRC Operator'}])
-            elif self.isOper(uid, allowAuthed=False) and not self.isInternalClient(uid):
+                    self.apply_modes(uid, [('+o', None)])
+                    self.call_hooks([uid, 'MODE', {'target': uid, 'modes': {('+o', None)}}])
+                    self.call_hooks([uid, 'CLIENT_OPERED', {'text': 'IRC Operator'}])
+            elif self.is_oper(uid, allowAuthed=False) and not self.is_internal_client(uid):
                 # Track deopers
-                self.applyModes(uid, [('-o', None)])
-                self.callHooks([uid, 'MODE', {'target': uid, 'modes': {('-o', None)}}])
+                self.apply_modes(uid, [('-o', None)])
+                self.call_hooks([uid, 'MODE', {'target': uid, 'modes': {('-o', None)}}])
 
         self.who_received.add(uid)
 
@@ -753,7 +753,7 @@ class ClientbotWrapperProtocol(IRCCommonProtocol):
         users = self.who_received.copy()
         self.who_received.clear()
 
-        channel = self.toLower(args[1])
+        channel = self.to_lower(args[1])
         c = self.channels[channel]
         c.who_received = True
 
@@ -788,7 +788,7 @@ class ClientbotWrapperProtocol(IRCCommonProtocol):
         Handles incoming JOINs.
         """
         # <- :GL|!~GL@127.0.0.1 JOIN #whatever
-        channel = self.toLower(args[0])
+        channel = self.to_lower(args[0])
         self.join(source, channel)
 
         return {'channel': channel, 'users': [source], 'modes': self.channels[channel].modes}
@@ -798,8 +798,8 @@ class ClientbotWrapperProtocol(IRCCommonProtocol):
         Handles incoming KICKs.
         """
         # <- :GL!~gl@127.0.0.1 KICK #whatever GL| :xd
-        channel = self.toLower(args[0])
-        target = self.nickToUid(args[1])
+        channel = self.to_lower(args[0])
+        target = self.nick_to_uid(args[1])
 
         try:
             reason = args[2]
@@ -824,9 +824,9 @@ class ClientbotWrapperProtocol(IRCCommonProtocol):
         except KeyError:
             pass
 
-        if (not self.isInternalClient(source)) and not self.isInternalServer(source):
+        if (not self.is_internal_client(source)) and not self.is_internal_server(source):
             # Don't repeat hooks if we're the kicker.
-            self.callHooks([source, 'KICK', {'channel': channel, 'target': target, 'text': reason}])
+            self.call_hooks([source, 'KICK', {'channel': channel, 'target': target, 'text': reason}])
 
         # Delete channels that we were kicked from, for better state keeping.
         if self.pseudoclient and target == self.pseudoclient.uid:
@@ -838,16 +838,16 @@ class ClientbotWrapperProtocol(IRCCommonProtocol):
         # <- :ice MODE ice :+Zi
         target = args[0]
         if utils.isChannel(target):
-            target = self.toLower(target)
+            target = self.to_lower(target)
             oldobj = self.channels[target].deepcopy()
         else:
-            target = self.nickToUid(target)
+            target = self.nick_to_uid(target)
             oldobj = None
         modes = args[1:]
-        changedmodes = self.parseModes(target, modes)
-        self.applyModes(target, changedmodes)
+        changedmodes = self.parse_modes(target, modes)
+        self.apply_modes(target, changedmodes)
 
-        if self.isInternalClient(target):
+        if self.is_internal_client(target):
             log.debug('(%s) Suppressing MODE change hook for internal client %s', self.name, target)
             return
         if changedmodes:
@@ -862,15 +862,15 @@ class ClientbotWrapperProtocol(IRCCommonProtocol):
         # -> MODE #test
         # <- :midnight.vpn 324 GL #test +nt
         # <- :midnight.vpn 329 GL #test 1491773459
-        channel = self.toLower(args[1])
+        channel = self.to_lower(args[1])
         modes = args[2:]
         log.debug('(%s) Got RPL_CHANNELMODEIS (324) modes %s for %s', self.name, modes, channel)
-        changedmodes = self.parseModes(channel, modes)
-        self.applyModes(channel, changedmodes)
+        changedmodes = self.parse_modes(channel, modes)
+        self.apply_modes(channel, changedmodes)
 
     def handle_329(self, source, command, args):
         """Handles TS announcements via RPL_CREATIONTIME."""
-        channel = self.toLower(args[1])
+        channel = self.to_lower(args[1])
         ts = int(args[2])
         self.channels[channel].ts = ts
 
@@ -900,7 +900,7 @@ class ClientbotWrapperProtocol(IRCCommonProtocol):
         Handles incoming PARTs.
         """
         # <- :GL|!~GL@127.0.0.1 PART #whatever
-        channels = list(map(self.toLower, args[0].split(',')))
+        channels = list(map(self.to_lower, args[0].split(',')))
         try:
             reason = args[1]
         except IndexError:
@@ -910,7 +910,7 @@ class ClientbotWrapperProtocol(IRCCommonProtocol):
             self.channels[channel].removeuser(source)
         self.users[source].channels -= set(channels)
 
-        self.callHooks([source, 'PART', {'channels': channels, 'text': reason}])
+        self.call_hooks([source, 'PART', {'channels': channels, 'text': reason}])
 
         # Clear channels that are empty, or that we're parting.
         for channel in channels:
@@ -936,15 +936,15 @@ class ClientbotWrapperProtocol(IRCCommonProtocol):
         # <- :sender NOTICE somenick :afasfsa
         target = args[0]
 
-        if self.isInternalClient(source) or self.isInternalServer(source):
+        if self.is_internal_client(source) or self.is_internal_server(source):
             log.warning('(%s) Received %s to %s being routed the wrong way!', self.name, command, target)
             return
 
         # We use lowercase channels internally.
         if utils.isChannel(target):
-            target = self.toLower(target)
+            target = self.to_lower(target)
         else:
-            target = self.nickToUid(target)
+            target = self.nick_to_uid(target)
         if target:
             return {'target': target, 'text': args[1]}
     handle_notice = handle_privmsg
diff --git a/protocols/hybrid.py b/protocols/hybrid.py
index d868c7a..07fdb95 100644
--- a/protocols/hybrid.py
+++ b/protocols/hybrid.py
@@ -96,7 +96,7 @@ class HybridProtocol(TS6Protocol):
         """
 
         server = server or self.sid
-        if not self.isInternalServer(server):
+        if not self.is_internal_server(server):
             raise ValueError('Server %r is not a PyLink server!' % server)
 
         uid = self.uidgen[server].next_uid()
@@ -104,10 +104,10 @@ class HybridProtocol(TS6Protocol):
         ts = ts or int(time.time())
         realname = realname or conf.conf['bot']['realname']
         realhost = realhost or host
-        raw_modes = self.joinModes(modes)
+        raw_modes = self.join_modes(modes)
         u = self.users[uid] = IrcUser(nick, ts, uid, server, ident=ident, host=host, realname=realname,
             realhost=realhost, ip=ip, manipulatable=manipulatable)
-        self.applyModes(uid, modes)
+        self.apply_modes(uid, modes)
         self.servers[server].users.add(uid)
         self._send_with_prefix(server, "UID {nick} 1 {ts} {modes} {ident} {host} {ip} {uid} "
                 "* :{realname}".format(ts=ts, host=host,
@@ -138,7 +138,7 @@ class HybridProtocol(TS6Protocol):
     def topicBurst(self, numeric, target, text):
         """Sends a topic change from a PyLink server. This is usually used on burst."""
         # <- :0UY TBURST 1459308205 #testchan 1459309379 dan!~d@localhost :sdf
-        if not self.isInternalServer(numeric):
+        if not self.is_internal_server(numeric):
             raise LookupError('No such PyLink server exists.')
 
         ts = self.channels[target].ts
@@ -179,25 +179,25 @@ class HybridProtocol(TS6Protocol):
 
         self.users[uid] = IrcUser(nick, ts, uid, numeric, ident, host, realname, host, ip)
 
-        parsedmodes = self.parseModes(uid, [modes])
+        parsedmodes = self.parse_modes(uid, [modes])
         log.debug('(%s) handle_uid: Applying modes %s for %s', self.name, parsedmodes, uid)
-        self.applyModes(uid, parsedmodes)
+        self.apply_modes(uid, parsedmodes)
         self.servers[numeric].users.add(uid)
 
         # Call the OPERED UP hook if +o is being added to the mode list.
         if ('+o', None) in parsedmodes:
-            self.callHooks([uid, 'CLIENT_OPERED', {'text': 'IRC_Operator'}])
+            self.call_hooks([uid, 'CLIENT_OPERED', {'text': 'IRC_Operator'}])
 
         # Set the account name if present
         if account:
-            self.callHooks([uid, 'CLIENT_SERVICES_LOGIN', {'text': account}])
+            self.call_hooks([uid, 'CLIENT_SERVICES_LOGIN', {'text': account}])
 
         return {'uid': uid, 'ts': ts, 'nick': nick, 'realname': realname, 'host': host, 'ident': ident, 'ip': ip}
 
     def handle_tburst(self, numeric, command, args):
         """Handles incoming topic burst (TBURST) commands."""
         # <- :0UY TBURST 1459308205 #testchan 1459309379 dan!~d@localhost :sdf
-        channel = self.toLower(args[1])
+        channel = self.to_lower(args[1])
         ts = args[2]
         setter = args[3]
         topic = args[-1]
@@ -221,7 +221,7 @@ class HybridProtocol(TS6Protocol):
         target = args[0]
         ts = args[1]
         modes = args[2:]
-        parsedmodes = self.parseModes(target, modes)
+        parsedmodes = self.parse_modes(target, modes)
 
         for modepair in parsedmodes:
             if modepair[0] == '+d':
@@ -241,7 +241,7 @@ class HybridProtocol(TS6Protocol):
 
                 # Send the login hook, and remove this mode from the mode
                 # list, as it shouldn't be parsed literally.
-                self.callHooks([target, 'CLIENT_SERVICES_LOGIN', {'text': account}])
+                self.call_hooks([target, 'CLIENT_SERVICES_LOGIN', {'text': account}])
                 parsedmodes.remove(modepair)
 
             elif modepair[0] == '+x':
@@ -253,13 +253,13 @@ class HybridProtocol(TS6Protocol):
                 self.users[target].host = host
 
                 # Propagate the hostmask change as a hook.
-                self.callHooks([numeric, 'CHGHOST',
+                self.call_hooks([numeric, 'CHGHOST',
                                    {'target': target, 'newhost': host}])
 
                 parsedmodes.remove(modepair)
 
         if parsedmodes:
-            self.applyModes(target, parsedmodes)
+            self.apply_modes(target, parsedmodes)
 
         return {'target': target, 'modes': parsedmodes}
 
diff --git a/protocols/inspircd.py b/protocols/inspircd.py
index be76c2d..3d14eb4 100644
--- a/protocols/inspircd.py
+++ b/protocols/inspircd.py
@@ -44,7 +44,7 @@ class InspIRCdProtocol(TS6BaseProtocol):
         """
         server = server or self.sid
 
-        if not self.isInternalServer(server):
+        if not self.is_internal_server(server):
             raise ValueError('Server %r is not a PyLink server!' % server)
 
         uid = self.uidgen[server].next_uid()
@@ -52,11 +52,11 @@ class InspIRCdProtocol(TS6BaseProtocol):
         ts = ts or int(time.time())
         realname = realname or conf.conf['bot']['realname']
         realhost = realhost or host
-        raw_modes = self.joinModes(modes)
+        raw_modes = self.join_modes(modes)
         u = self.users[uid] = IrcUser(nick, ts, uid, server, ident=ident, host=host, realname=realname,
             realhost=realhost, ip=ip, manipulatable=manipulatable, opertype=opertype)
 
-        self.applyModes(uid, modes)
+        self.apply_modes(uid, modes)
         self.servers[server].users.add(uid)
 
         self._send_with_prefix(server, "UID {uid} {ts} {nick} {realhost} {host} {ident} {ip}"
@@ -73,10 +73,10 @@ class InspIRCdProtocol(TS6BaseProtocol):
         # InspIRCd doesn't distinguish between burst joins and regular joins,
         # so what we're actually doing here is sending FJOIN from the server,
         # on behalf of the clients that are joining.
-        channel = self.toLower(channel)
+        channel = self.to_lower(channel)
 
-        server = self.getServer(client)
-        if not self.isInternalServer(server):
+        server = self.get_server(client)
+        if not self.is_internal_server(server):
             log.error('(%s) Error trying to join %r to %r (no such client exists)', self.name, client, channel)
             raise LookupError('No such PyLink client exists.')
 
@@ -84,7 +84,7 @@ class InspIRCdProtocol(TS6BaseProtocol):
         modes = [m for m in self.channels[channel].modes if m[0] not in self.cmodes['*A']]
         self._send_with_prefix(server, "FJOIN {channel} {ts} {modes} :,{uid}".format(
                 ts=self.channels[channel].ts, uid=client, channel=channel,
-                modes=self.joinModes(modes)))
+                modes=self.join_modes(modes)))
         self.channels[channel].users.add(client)
         self.users[client].channels.add(channel)
 
@@ -99,7 +99,7 @@ class InspIRCdProtocol(TS6BaseProtocol):
             sjoin('100', '#test', [('', '100AAABBC'), ('qo', 100AAABBB'), ('h', '100AAADDD')])
             sjoin(self.sid, '#test', [('o', self.pseudoclient.uid)])
         """
-        channel = self.toLower(channel)
+        channel = self.to_lower(channel)
         server = server or self.sid
         assert users, "sjoin: No users sent?"
         log.debug('(%s) sjoin: got %r for users', self.name, users)
@@ -144,14 +144,14 @@ class InspIRCdProtocol(TS6BaseProtocol):
         namelist = ' '.join(namelist)
         self._send_with_prefix(server, "FJOIN {channel} {ts} {modes} :{users}".format(
                 ts=ts, users=namelist, channel=channel,
-                modes=self.joinModes(modes)))
+                modes=self.join_modes(modes)))
         self.channels[channel].users.update(uids)
 
         if banmodes:
             # Burst ban modes if there are any.
             # <- :1ML FMODE #test 1461201525 +bb *!*@bad.user *!*@rly.bad.user
             self._send_with_prefix(server, "FMODE {channel} {ts} {modes} ".format(
-                ts=ts, channel=channel, modes=self.joinModes(banmodes)))
+                ts=ts, channel=channel, modes=self.join_modes(banmodes)))
 
         self.updateTS(server, channel, ts, changedmodes)
 
@@ -194,8 +194,8 @@ class InspIRCdProtocol(TS6BaseProtocol):
         # -> :9PYAAAAAA FMODE #pylink 1433653951 +os 9PYAAAAAA
         # -> :9PYAAAAAA MODE 9PYAAAAAA -i+w
 
-        if (not self.isInternalClient(numeric)) and \
-                (not self.isInternalServer(numeric)):
+        if (not self.is_internal_client(numeric)) and \
+                (not self.is_internal_server(numeric)):
             raise LookupError('No such PyLink client/server exists.')
 
         log.debug('(%s) inspircd._send_with_prefixModes: received %r for mode list', self.name, modes)
@@ -203,18 +203,18 @@ class InspIRCdProtocol(TS6BaseProtocol):
             # https://github.com/inspircd/inspircd/blob/master/src/modules/m_spanningtree/opertype.cpp#L26-L28
             # Servers need a special command to set umode +o on people.
             self._operUp(target)
-        self.applyModes(target, modes)
-        joinedmodes = self.joinModes(modes)
+        self.apply_modes(target, modes)
+        joinedmodes = self.join_modes(modes)
         if utils.isChannel(target):
-            ts = ts or self.channels[self.toLower(target)].ts
+            ts = ts or self.channels[self.to_lower(target)].ts
             self._send_with_prefix(numeric, 'FMODE %s %s %s' % (target, ts, joinedmodes))
         else:
             self._send_with_prefix(numeric, 'MODE %s %s' % (target, joinedmodes))
 
     def kill(self, numeric, target, reason):
         """Sends a kill from a PyLink client/server."""
-        if (not self.isInternalClient(numeric)) and \
-                (not self.isInternalServer(numeric)):
+        if (not self.is_internal_client(numeric)) and \
+                (not self.is_internal_server(numeric)):
             raise LookupError('No such PyLink client/server exists.')
 
         # InspIRCd will show the raw kill message sent from our server as the quit message.
@@ -230,12 +230,12 @@ class InspIRCdProtocol(TS6BaseProtocol):
         # We only need to call _remove_client here if the target is one of our
         # clients, since any remote servers will send a QUIT from
         # their target if the command succeeds.
-        if self.isInternalClient(target):
+        if self.is_internal_client(target):
             self._remove_client(target)
 
     def topicBurst(self, numeric, target, text):
         """Sends a topic change from a PyLink server. This is usually used on burst."""
-        if not self.isInternalServer(numeric):
+        if not self.is_internal_server(numeric):
             raise LookupError('No such PyLink server exists.')
         ts = int(time.time())
         servername = self.servers[numeric].name
@@ -245,13 +245,13 @@ class InspIRCdProtocol(TS6BaseProtocol):
 
     def invite(self, numeric, target, channel):
         """Sends an INVITE from a PyLink client.."""
-        if not self.isInternalClient(numeric):
+        if not self.is_internal_client(numeric):
             raise LookupError('No such PyLink client exists.')
         self._send_with_prefix(numeric, 'INVITE %s %s' % (target, channel))
 
     def knock(self, numeric, target, text):
         """Sends a KNOCK from a PyLink client."""
-        if not self.isInternalClient(numeric):
+        if not self.is_internal_client(numeric):
             raise LookupError('No such PyLink client exists.')
         self._send_with_prefix(numeric, 'ENCAP * KNOCK %s :%s' % (target, text))
 
@@ -263,7 +263,7 @@ class InspIRCdProtocol(TS6BaseProtocol):
             raise NotImplementedError("Changing field %r of a client is "
                                       "unsupported by this protocol." % field)
 
-        if self.isInternalClient(target):
+        if self.is_internal_client(target):
             # It is one of our clients, use FIDENT/HOST/NAME.
             if field == 'IDENT':
                 self.users[target].ident = text
@@ -285,7 +285,7 @@ class InspIRCdProtocol(TS6BaseProtocol):
                 self._send_with_prefix(self.sid, 'CHGIDENT %s %s' % (target, text))
 
                 # Send hook payloads for other plugins to listen to.
-                self.callHooks([self.sid, 'CHGIDENT',
+                self.call_hooks([self.sid, 'CHGIDENT',
                                    {'target': target, 'newident': text}])
             elif field == 'HOST':
                 if 'm_chghost.so' not in self.modsupport:
@@ -295,7 +295,7 @@ class InspIRCdProtocol(TS6BaseProtocol):
                 self.users[target].host = text
                 self._send_with_prefix(self.sid, 'CHGHOST %s %s' % (target, text))
 
-                self.callHooks([self.sid, 'CHGHOST',
+                self.call_hooks([self.sid, 'CHGHOST',
                                    {'target': target, 'newhost': text}])
 
             elif field in ('REALNAME', 'GECOS'):
@@ -305,7 +305,7 @@ class InspIRCdProtocol(TS6BaseProtocol):
                 self.users[target].realname = text
                 self._send_with_prefix(self.sid, 'CHGNAME %s :%s' % (target, text))
 
-                self.callHooks([self.sid, 'CHGNAME',
+                self.call_hooks([self.sid, 'CHGNAME',
                                    {'target': target, 'newgecos': text}])
 
     def ping(self, source=None, target=None):
@@ -363,7 +363,7 @@ class InspIRCdProtocol(TS6BaseProtocol):
         for server in self.servers.values():
             if name == server.name:
                 raise ValueError('A server named %r already exists!' % name)
-        if not self.isInternalServer(uplink):
+        if not self.is_internal_server(uplink):
             raise ValueError('Server %r is not a PyLink server!' % uplink)
         if not utils.isServerName(name):
             raise ValueError('Invalid server name %r' % name)
@@ -523,19 +523,19 @@ class InspIRCdProtocol(TS6BaseProtocol):
         """Handles incoming PING commands, so we don't time out."""
         # <- :70M PING 70M 0AL
         # -> :0AL PONG 0AL 70M
-        if self.isInternalServer(args[1]):
+        if self.is_internal_server(args[1]):
             self._send_with_prefix(args[1], 'PONG %s %s' % (args[1], source), queue=False)
 
     def handle_fjoin(self, servernumeric, command, args):
         """Handles incoming FJOIN commands (InspIRCd equivalent of JOIN/SJOIN)."""
         # :70M FJOIN #chat 1423790411 +AFPfjnt 6:5 7:5 9:5 :o,1SRAABIT4 v,1IOAAF53R <...>
-        channel = self.toLower(args[0])
+        channel = self.to_lower(args[0])
         chandata = self.channels[channel].deepcopy()
         # InspIRCd sends each channel's users in the form of 'modeprefix(es),UID'
         userlist = args[-1].split()
 
         modestring = args[2:-1] or args[2]
-        parsedmodes = self.parseModes(channel, modestring)
+        parsedmodes = self.parse_modes(channel, modestring)
         namelist = []
 
         # Keep track of other modes that are added due to prefix modes being joined too.
@@ -579,13 +579,13 @@ class InspIRCdProtocol(TS6BaseProtocol):
         realname = args[-1]
         self.users[uid] = userobj = IrcUser(nick, ts, uid, numeric, ident, host, realname, realhost, ip)
 
-        parsedmodes = self.parseModes(uid, [args[8], args[9]])
-        self.applyModes(uid, parsedmodes)
+        parsedmodes = self.parse_modes(uid, [args[8], args[9]])
+        self.apply_modes(uid, parsedmodes)
 
         if (self.umodes.get('servprotect'), None) in userobj.modes:
             # Services are usually given a "Network Service" WHOIS, so
             # set that as the opertype.
-            self.callHooks([uid, 'CLIENT_OPERED', {'text': 'Network Service'}])
+            self.call_hooks([uid, 'CLIENT_OPERED', {'text': 'Network Service'}])
 
         self.servers[numeric].users.add(uid)
         return {'uid': uid, 'ts': ts, 'nick': nick, 'realhost': realhost, 'host': host, 'ident': ident, 'ip': ip}
@@ -620,11 +620,11 @@ class InspIRCdProtocol(TS6BaseProtocol):
     def handle_fmode(self, numeric, command, args):
         """Handles the FMODE command, used for channel mode changes."""
         # <- :70MAAAAAA FMODE #chat 1433653462 +hhT 70MAAAAAA 70MAAAAAD
-        channel = self.toLower(args[0])
+        channel = self.to_lower(args[0])
         oldobj = self.channels[channel].deepcopy()
         modes = args[2:]
-        changedmodes = self.parseModes(channel, modes)
-        self.applyModes(channel, changedmodes)
+        changedmodes = self.parse_modes(channel, modes)
+        self.apply_modes(channel, changedmodes)
         ts = int(args[1])
         return {'target': channel, 'modes': changedmodes, 'ts': ts,
                 'channeldata': oldobj}
@@ -636,8 +636,8 @@ class InspIRCdProtocol(TS6BaseProtocol):
         # <- :70MAAAAAA MODE 70MAAAAAA -i+xc
         target = args[0]
         modestrings = args[1:]
-        changedmodes = self.parseModes(target, modestrings)
-        self.applyModes(target, changedmodes)
+        changedmodes = self.parse_modes(target, modestrings)
+        self.apply_modes(target, changedmodes)
         return {'target': target, 'modes': changedmodes}
 
     def handle_idle(self, numeric, command, args):
@@ -662,7 +662,7 @@ class InspIRCdProtocol(TS6BaseProtocol):
     def handle_ftopic(self, numeric, command, args):
         """Handles incoming FTOPIC (sets topic on burst)."""
         # <- :70M FTOPIC #channel 1434510754 GLo|o|!GLolol@escape.the.dreamland.ca :Some channel topic
-        channel = self.toLower(args[0])
+        channel = self.to_lower(args[0])
         ts = args[1]
         setter = args[2]
         topic = args[-1]
@@ -676,7 +676,7 @@ class InspIRCdProtocol(TS6BaseProtocol):
     def handle_knock(self, numeric, command, args):
         """Handles channel KNOCKs."""
         # <- :70MAAAAAA ENCAP * KNOCK #blah :abcdefg
-        channel = self.toLower(args[0])
+        channel = self.to_lower(args[0])
         text = args[1]
         return {'channel': channel, 'text': text}
 
@@ -693,11 +693,11 @@ class InspIRCdProtocol(TS6BaseProtocol):
 
         # Set umode +o on the target.
         omode = [('+o', None)]
-        self.applyModes(target, omode)
+        self.apply_modes(target, omode)
 
         # Call the CLIENT_OPERED hook that protocols use. The MODE hook
         # payload is returned below.
-        self.callHooks([target, 'CLIENT_OPERED', {'text': opertype}])
+        self.call_hooks([target, 'CLIENT_OPERED', {'text': opertype}])
         return {'target': target, 'modes': omode}
 
     def handle_fident(self, numeric, command, args):
@@ -752,10 +752,10 @@ class InspIRCdProtocol(TS6BaseProtocol):
         # SQUIT, in order to be consistent with other IRCds which make SQUITs
         # implicit.
         target = self._get_SID(args[0])
-        if self.isInternalServer(target):
+        if self.is_internal_server(target):
             # The target has to be one of our servers in order to work...
             uplink = self.servers[target].uplink
-            reason = 'Requested by %s' % self.getHostmask(numeric)
+            reason = 'Requested by %s' % self.get_hostmask(numeric)
             self._send_with_prefix(uplink, 'SQUIT %s :%s' % (target, reason))
             return self.handle_squit(numeric, 'SQUIT', [target, reason])
         else:
@@ -774,7 +774,7 @@ class InspIRCdProtocol(TS6BaseProtocol):
             # <- :00A METADATA 1MLAAAJET accountname :tester
             # Sets the services login name of the client.
 
-            self.callHooks([uid, 'CLIENT_SERVICES_LOGIN', {'text': args[-1]}])
+            self.call_hooks([uid, 'CLIENT_SERVICES_LOGIN', {'text': args[-1]}])
 
     def handle_version(self, numeric, command, args):
         """
@@ -800,20 +800,20 @@ class InspIRCdProtocol(TS6BaseProtocol):
         # ENCAP -> SAKICK args: ['#test', '0ALAAAAAB', 'test']
 
         target = args[1]
-        channel = self.toLower(args[0])
+        channel = self.to_lower(args[0])
         try:
             reason = args[2]
         except IndexError:
             # Kick reason is optional, strange...
-            reason = self.getFriendlyName(source)
+            reason = self.get_friendly_name(source)
 
-        if not self.isInternalClient(target):
+        if not self.is_internal_client(target):
             log.warning("(%s) Got SAKICK for client that not one of ours: %s", self.name, target)
             return
         else:
             # Like RSQUIT, SAKICK requires that the receiving server acknowledge that a kick has
             # happened. This comes from the server hosting the target client.
-            server = self.getServer(target)
+            server = self.get_server(target)
 
         self.kick(server, channel, target, reason)
         return {'channel': channel, 'target': target, 'text': reason}
diff --git a/protocols/ircs2s_common.py b/protocols/ircs2s_common.py
index 8146c67..f2a1bdc 100644
--- a/protocols/ircs2s_common.py
+++ b/protocols/ircs2s_common.py
@@ -179,7 +179,7 @@ class IRCS2SProtocol(IRCCommonProtocol):
             sender = self.uplink
             args.insert(0, sender)
 
-        if self.isInternalClient(sender) or self.isInternalServer(sender):
+        if self.is_internal_client(sender) or self.is_internal_server(sender):
             log.warning("(%s) Received command %s being routed the wrong way!", self.name, command)
             return
 
@@ -213,13 +213,13 @@ class IRCS2SProtocol(IRCCommonProtocol):
         """
         Nick collision checker.
         """
-        uid = self.nickToUid(nick)
+        uid = self.nick_to_uid(nick)
         # If there is a nick collision, we simply alert plugins. Relay will purposely try to
         # lose fights and tag nicks instead, while other plugins can choose how to handle this.
         if uid:
             log.info('(%s) Nick collision on %s/%s, forwarding this to plugins', self.name,
                      uid, nick)
-            self.callHooks([self.sid, 'SAVE', {'target': uid}])
+            self.call_hooks([self.sid, 'SAVE', {'target': uid}])
 
     def handle_away(self, numeric, command, args):
         """Handles incoming AWAY messages."""
@@ -243,7 +243,7 @@ class IRCS2SProtocol(IRCCommonProtocol):
         #  Note that the target is a nickname, not a numeric.
 
         target = self._get_UID(args[0])
-        channel = self.toLower(args[1])
+        channel = self.to_lower(args[1])
 
         curtime = int(time.time())
         try:
@@ -274,7 +274,7 @@ class IRCS2SProtocol(IRCCommonProtocol):
 
         try:
             # Get the nick or server name of the caller.
-            killer = self.getFriendlyName(source)
+            killer = self.get_friendly_name(source)
         except KeyError:
             # Killer was... neither? We must have aliens or something. Fallback
             # to the given "UID".
@@ -289,7 +289,7 @@ class IRCS2SProtocol(IRCCommonProtocol):
 
     def handle_part(self, source, command, args):
         """Handles incoming PART commands."""
-        channels = self.toLower(args[0]).split(',')
+        channels = self.to_lower(args[0]).split(',')
 
         for channel in channels:
             self.channels[channel].removeuser(source)
@@ -337,7 +337,7 @@ class IRCS2SProtocol(IRCCommonProtocol):
             # Note: don't mess with the case of the channel prefix, or ~#channel
             # messages will break on RFC1459 casemapping networks (it becomes ^#channel
             # instead).
-            target = '#'.join((split_channel[0], self.toLower(split_channel[1])))
+            target = '#'.join((split_channel[0], self.to_lower(split_channel[1])))
             log.debug('(%s) Normalizing channel target %s to %s', self.name, args[0], target)
 
         return {'target': target, 'text': args[1]}
diff --git a/protocols/p10.py b/protocols/p10.py
index 22a72f7..f6aa738 100644
--- a/protocols/p10.py
+++ b/protocols/p10.py
@@ -262,7 +262,7 @@ class P10Protocol(IRCS2SProtocol):
         # -1 <fullname>
 
         server = server or self.sid
-        if not self.isInternalServer(server):
+        if not self.is_internal_server(server):
             raise ValueError('Server %r is not a PyLink server!' % server)
 
         # Create an UIDGenerator instance for every SID, so that each gets
@@ -273,7 +273,7 @@ class P10Protocol(IRCS2SProtocol):
         ts = ts or int(time.time())
         realname = realname or conf.conf['bot']['realname']
         realhost = realhost or host
-        raw_modes = self.joinModes(modes)
+        raw_modes = self.join_modes(modes)
 
         # Initialize an IrcUser instance
         u = self.users[uid] = IrcUser(nick, ts, uid, server, ident=ident, host=host, realname=realname,
@@ -281,7 +281,7 @@ class P10Protocol(IRCS2SProtocol):
                                           opertype=opertype)
 
         # Fill in modes and add it to our users index
-        self.applyModes(uid, modes)
+        self.apply_modes(uid, modes)
         self.servers[server].users.add(uid)
 
         # Encode IPs when sending
@@ -301,7 +301,7 @@ class P10Protocol(IRCS2SProtocol):
     def away(self, source, text):
         """Sends an AWAY message from a PyLink client. <text> can be an empty string
         to unset AWAY status."""
-        if not self.isInternalClient(source):
+        if not self.is_internal_client(source):
             raise LookupError('No such PyLink client exists.')
 
         if text:
@@ -315,7 +315,7 @@ class P10Protocol(IRCS2SProtocol):
         # Note: we have to send a nick as the target, not a UID.
         # <- ABAAA I PyLink-devel #services 1460948992
 
-        if not self.isInternalClient(numeric):
+        if not self.is_internal_client(numeric):
             raise LookupError('No such PyLink client exists.')
 
         nick = self.users[target].nick
@@ -325,10 +325,10 @@ class P10Protocol(IRCS2SProtocol):
     def join(self, client, channel):
         """Joins a PyLink client to a channel."""
         # <- ABAAB J #test3 1460744371
-        channel = self.toLower(channel)
+        channel = self.to_lower(channel)
         ts = self.channels[channel].ts
 
-        if not self.isInternalClient(client):
+        if not self.is_internal_client(client):
             raise LookupError('No such PyLink client exists.')
 
         if not self.channels[channel].users:
@@ -343,11 +343,11 @@ class P10Protocol(IRCS2SProtocol):
     def kick(self, numeric, channel, target, reason=None):
         """Sends kicks from a PyLink client/server."""
 
-        if (not self.isInternalClient(numeric)) and \
-                (not self.isInternalServer(numeric)):
+        if (not self.is_internal_client(numeric)) and \
+                (not self.is_internal_server(numeric)):
             raise LookupError('No such PyLink client/server exists.')
 
-        channel = self.toLower(channel)
+        channel = self.to_lower(channel)
         if not reason:
             reason = 'No reason given'
 
@@ -355,8 +355,8 @@ class P10Protocol(IRCS2SProtocol):
         # HACK: prevent kick bounces by sending our kick through the server if
         # the sender isn't op.
         if numeric not in self.servers and (not cobj.isOp(numeric)) and (not cobj.isHalfop(numeric)):
-            reason = '(%s) %s' % (self.getFriendlyName(numeric), reason)
-            numeric = self.getServer(numeric)
+            reason = '(%s) %s' % (self.get_friendly_name(numeric), reason)
+            numeric = self.get_server(numeric)
 
         self._send_with_prefix(numeric, 'K %s %s :%s' % (channel, target, reason))
 
@@ -369,8 +369,8 @@ class P10Protocol(IRCS2SProtocol):
         """Sends a kill from a PyLink client/server."""
         # <- ABAAA D AyAAA :nefarious.midnight.vpn!GL (test)
 
-        if (not self.isInternalClient(numeric)) and \
-                (not self.isInternalServer(numeric)):
+        if (not self.is_internal_client(numeric)) and \
+                (not self.is_internal_server(numeric)):
             raise LookupError('No such PyLink client/server exists.')
 
         self._send_with_prefix(numeric, 'D %s :Killed (%s)' % (target, reason))
@@ -381,7 +381,7 @@ class P10Protocol(IRCS2SProtocol):
 
     def message(self, numeric, target, text):
         """Sends a PRIVMSG from a PyLink client."""
-        if not self.isInternalClient(numeric):
+        if not self.is_internal_client(numeric):
             raise LookupError('No such PyLink client exists.')
 
         self._send_with_prefix(numeric, 'P %s :%s' % (target, text))
@@ -391,8 +391,8 @@ class P10Protocol(IRCS2SProtocol):
         # <- ABAAA M GL -w
         # <- ABAAA M #test +v ABAAB 1460747615
 
-        if (not self.isInternalClient(numeric)) and \
-                (not self.isInternalServer(numeric)):
+        if (not self.is_internal_client(numeric)) and \
+                (not self.is_internal_server(numeric)):
             raise LookupError('No such PyLink client/server exists.')
 
         modes = list(modes)
@@ -404,13 +404,13 @@ class P10Protocol(IRCS2SProtocol):
         is_cmode = utils.isChannel(target)
         if is_cmode:
             # Channel mode changes have a trailing TS. User mode changes do not.
-            cobj = self.channels[self.toLower(target)]
+            cobj = self.channels[self.to_lower(target)]
             ts = ts or cobj.ts
 
             # HACK: prevent mode bounces by sending our mode through the server if
             # the sender isn't op.
             if numeric not in self.servers and (not cobj.isOp(numeric)) and (not cobj.isHalfop(numeric)):
-                numeric = self.getServer(numeric)
+                numeric = self.get_server(numeric)
 
             # Wrap modes: start with max bufsize and subtract the lengths of the source, target,
             # mode command, and whitespace.
@@ -422,12 +422,12 @@ class P10Protocol(IRCS2SProtocol):
             # P10 uses nicks in user MODE targets, NOT UIDs. ~GL
             real_target = self.users[target].nick
 
-        self.applyModes(target, modes)
+        self.apply_modes(target, modes)
 
         while modes[:12]:
-            joinedmodes = self.joinModes([m for m in modes[:12]])
+            joinedmodes = self.join_modes([m for m in modes[:12]])
             if is_cmode:
-                for wrapped_modes in self.wrapModes(modes[:12], bufsize):
+                for wrapped_modes in self.wrap_modes(modes[:12], bufsize):
                     self._send_with_prefix(numeric, 'M %s %s %s' % (real_target, wrapped_modes, ts))
             else:
                 self._send_with_prefix(numeric, 'M %s %s' % (real_target, joinedmodes))
@@ -436,7 +436,7 @@ class P10Protocol(IRCS2SProtocol):
     def nick(self, numeric, newnick):
         """Changes the nick of a PyLink client."""
         # <- ABAAA N GL_ 1460753763
-        if not self.isInternalClient(numeric):
+        if not self.is_internal_client(numeric):
             raise LookupError('No such PyLink client exists.')
 
         self._send_with_prefix(numeric, 'N %s %s' % (newnick, int(time.time())))
@@ -453,17 +453,17 @@ class P10Protocol(IRCS2SProtocol):
 
     def notice(self, numeric, target, text):
         """Sends a NOTICE from a PyLink client or server."""
-        if (not self.isInternalClient(numeric)) and \
-                (not self.isInternalServer(numeric)):
+        if (not self.is_internal_client(numeric)) and \
+                (not self.is_internal_server(numeric)):
             raise LookupError('No such PyLink client/server exists.')
 
         self._send_with_prefix(numeric, 'O %s :%s' % (target, text))
 
     def part(self, client, channel, reason=None):
         """Sends a part from a PyLink client."""
-        channel = self.toLower(channel)
+        channel = self.to_lower(channel)
 
-        if not self.isInternalClient(client):
+        if not self.is_internal_client(client):
             raise LookupError('No such PyLink client exists.')
 
         msg = "L %s" % channel
@@ -485,7 +485,7 @@ class P10Protocol(IRCS2SProtocol):
 
     def quit(self, numeric, reason):
         """Quits a PyLink client."""
-        if self.isInternalClient(numeric):
+        if self.is_internal_client(numeric):
             self._send_with_prefix(numeric, "Q :%s" % reason)
             self._remove_client(numeric)
         else:
@@ -503,7 +503,7 @@ class P10Protocol(IRCS2SProtocol):
             sjoin(self.sid, '#test', [('o', self.pseudoclient.uid)])
         """
         # <- AB B #test 1460742014 +tnl 10 ABAAB,ABAAA:o :%*!*@other.bad.host ~ *!*@bad.host
-        channel = self.toLower(channel)
+        channel = self.to_lower(channel)
         server = server or self.sid
 
         assert users, "sjoin: No users sent?"
@@ -546,7 +546,7 @@ class P10Protocol(IRCS2SProtocol):
 
         msgprefix = '{sid} B {channel} {ts} '.format(sid=server, channel=channel, ts=ts)
         if regularmodes:
-            msgprefix += '%s ' % self.joinModes(regularmodes)
+            msgprefix += '%s ' % self.join_modes(regularmodes)
 
         last_prefixes = ''
         for userpair in users:
@@ -652,7 +652,7 @@ class P10Protocol(IRCS2SProtocol):
             if name == server.name:
                 raise ValueError('A server named %r already exists!' % name)
 
-        if not self.isInternalServer(uplink):
+        if not self.is_internal_server(uplink):
             raise ValueError('Server %r is not a PyLink server!' % uplink)
         if not utils.isServerName(name):
             raise ValueError('Invalid server name %r' % name)
@@ -677,10 +677,10 @@ class P10Protocol(IRCS2SProtocol):
         # <- ABAAA T #test GL!~gl@nefarious.midnight.vpn 1460852591 1460855795 :blah
         # First timestamp is channel creation time, second is current time,
 
-        if not self.isInternalClient(numeric):
+        if not self.is_internal_client(numeric):
             raise LookupError('No such PyLink client exists.')
 
-        sendername = self.getHostmask(numeric)
+        sendername = self.get_hostmask(numeric)
 
         creationts = self.channels[target].ts
 
@@ -693,7 +693,7 @@ class P10Protocol(IRCS2SProtocol):
         """Sends a TOPIC change from a PyLink server."""
         # <- AB T #test GL!~gl@nefarious.midnight.vpn 1460852591 1460855795 :blah
 
-        if not self.isInternalServer(numeric):
+        if not self.is_internal_server(numeric):
             raise LookupError('No such PyLink server exists.')
 
         sendername = self.servers[numeric].name
@@ -711,7 +711,7 @@ class P10Protocol(IRCS2SProtocol):
 
         ircd = self.serverdata.get('p10_ircd', 'nefarious').lower()
 
-        if self.isInternalClient(target):
+        if self.is_internal_client(target):
             # Host changing via SETHOST is only supported on nefarious and snircd.
             if ircd not in ('nefarious', 'snircd'):
                 raise NotImplementedError("Host changing for internal clients (via SETHOST) is only "
@@ -741,7 +741,7 @@ class P10Protocol(IRCS2SProtocol):
 
             # Save the host change as a user mode (this is what P10 does on bursts),
             # so further host checks work.
-            self.applyModes(target, [('+f', text)])
+            self.apply_modes(target, [('+f', text)])
             self.mode(self.sid, target, [('+x', None)])
         else:
             raise NotImplementedError("Changing field %r of a client is "
@@ -865,18 +865,18 @@ class P10Protocol(IRCS2SProtocol):
             # parameters attached.
             if args[5].startswith('+'):
                 modes = args[5:-3]
-                parsedmodes = self.parseModes(uid, modes)
-                self.applyModes(uid, parsedmodes)
+                parsedmodes = self.parse_modes(uid, modes)
+                self.apply_modes(uid, parsedmodes)
 
                 for modepair in parsedmodes:
                     if modepair[0][-1] == 'r':
                         # Parse account registrations, sent as usermode "+r accountname:TS"
                         accountname = modepair[1].split(':', 1)[0]
-                        self.callHooks([uid, 'CLIENT_SERVICES_LOGIN', {'text': accountname}])
+                        self.call_hooks([uid, 'CLIENT_SERVICES_LOGIN', {'text': accountname}])
 
                 # Call the OPERED UP hook if +o is being added to the mode list.
                 if ('+o', None) in parsedmodes:
-                    self.callHooks([uid, 'CLIENT_OPERED', {'text': 'IRC Operator'}])
+                    self.call_hooks([uid, 'CLIENT_OPERED', {'text': 'IRC Operator'}])
 
             self._check_cloak_change(uid)
 
@@ -947,9 +947,9 @@ class P10Protocol(IRCS2SProtocol):
 
         # Propagate a hostname update to plugins, but only if the changed host is different.
         if newhost != uobj.host:
-             self.callHooks([uid, 'CHGHOST', {'target': uid, 'newhost': newhost}])
+             self.call_hooks([uid, 'CHGHOST', {'target': uid, 'newhost': newhost}])
         if ident != uobj.ident:
-             self.callHooks([uid, 'CHGIDENT', {'target': uid, 'newident': ident}])
+             self.call_hooks([uid, 'CHGIDENT', {'target': uid, 'newident': ident}])
         uobj.host = newhost
         uobj.ident = ident
 
@@ -972,7 +972,7 @@ class P10Protocol(IRCS2SProtocol):
         currtime = time.time()
         timediff = int(time.time() - float(orig_pingtime))
 
-        if self.isInternalServer(sid):
+        if self.is_internal_server(sid):
             # Only respond if the target server is ours. No forwarding is needed because
             # no IRCds can ever connect behind us...
             self._send_with_prefix(self.sid, 'Z %s %s %s %s' % (target, orig_pingtime, timediff, currtime), queue=False)
@@ -1002,7 +1002,7 @@ class P10Protocol(IRCS2SProtocol):
             # No useful data was sent, ignore.
             return
 
-        channel = self.toLower(args[0])
+        channel = self.to_lower(args[0])
         chandata = self.channels[channel].deepcopy()
 
         bans = []
@@ -1030,7 +1030,7 @@ class P10Protocol(IRCS2SProtocol):
         # If no modes are given, this will simply be empty.
         modestring = args[2:-1]
         if modestring:
-            parsedmodes = self.parseModes(channel, modestring)
+            parsedmodes = self.parse_modes(channel, modestring)
         else:
             parsedmodes = []
 
@@ -1100,7 +1100,7 @@ class P10Protocol(IRCS2SProtocol):
 
             return {'channels': oldchans, 'text': 'Left all channels.', 'parse_as': 'PART'}
         else:
-            channel = self.toLower(args[0])
+            channel = self.to_lower(args[0])
             if ts:  # Only update TS if one was sent.
                 self.updateTS(source, channel, ts)
 
@@ -1126,15 +1126,15 @@ class P10Protocol(IRCS2SProtocol):
         # <- ABAAA OM #test +h ABAAA
         target = self._get_UID(args[0])
         if utils.isChannel(target):
-            target = self.toLower(target)
+            target = self.to_lower(target)
 
         modestrings = args[1:]
-        changedmodes = self.parseModes(target, modestrings)
-        self.applyModes(target, changedmodes)
+        changedmodes = self.parse_modes(target, modestrings)
+        self.apply_modes(target, changedmodes)
 
         # Call the CLIENT_OPERED hook if +o is being set.
         if ('+o', None) in changedmodes and target in self.users:
-            self.callHooks([target, 'CLIENT_OPERED', {'text': 'IRC Operator'}])
+            self.call_hooks([target, 'CLIENT_OPERED', {'text': 'IRC Operator'}])
 
         if target in self.users:
             # Target was a user. Check for any cloak changes.
@@ -1147,7 +1147,7 @@ class P10Protocol(IRCS2SProtocol):
     def handle_kick(self, source, command, args):
         """Handles incoming KICKs."""
         # <- ABAAA K #TEST AyAAA :PyLink-devel
-        channel = self.toLower(args[0])
+        channel = self.to_lower(args[0])
         kicked = args[1]
 
         self.handle_part(kicked, 'KICK', [channel, args[2]])
@@ -1161,7 +1161,7 @@ class P10Protocol(IRCS2SProtocol):
     def handle_topic(self, source, command, args):
         """Handles TOPIC changes."""
         # <- ABAAA T #test GL!~gl@nefarious.midnight.vpn 1460852591 1460855795 :blah
-        channel = self.toLower(args[0])
+        channel = self.to_lower(args[0])
         topic = args[-1]
 
         oldtopic = self.channels[channel].topic
@@ -1174,7 +1174,7 @@ class P10Protocol(IRCS2SProtocol):
     def handle_clearmode(self, numeric, command, args):
         """Handles CLEARMODE, which is used to clear a channel's modes."""
         # <- ABAAA CM #test ovpsmikbl
-        channel = self.toLower(args[0])
+        channel = self.to_lower(args[0])
         modes = args[1]
 
         # Enumerate a list of our existing modes, including prefix modes.
@@ -1202,7 +1202,7 @@ class P10Protocol(IRCS2SProtocol):
                     # Mode does not take an argument when unsetting.
                     changedmodes.append(('-%s' % modechar, None))
 
-        self.applyModes(channel, changedmodes)
+        self.apply_modes(channel, changedmodes)
         return {'target': channel, 'modes': changedmodes, 'channeldata': oldobj}
 
     def handle_account(self, numeric, command, args):
@@ -1236,7 +1236,7 @@ class P10Protocol(IRCS2SProtocol):
             accountname = args[1]
 
         # Call this manually because we need the UID to be the sender.
-        self.callHooks([target, 'CLIENT_SERVICES_LOGIN', {'text': accountname}])
+        self.call_hooks([target, 'CLIENT_SERVICES_LOGIN', {'text': accountname}])
 
         # Check for any cloak changes now.
         self._check_cloak_change(target)
@@ -1247,7 +1247,7 @@ class P10Protocol(IRCS2SProtocol):
         text = args[1]
 
         # Assume a usermode +f change, and then update the cloak checking.
-        self.applyModes(target, [('+f', text)])
+        self.apply_modes(target, [('+f', text)])
 
         self._check_cloak_change(target)
         # We don't need to send any hooks here, _check_cloak_change does that for us.
diff --git a/protocols/ratbox.py b/protocols/ratbox.py
index 112cc74..8a8b851 100644
--- a/protocols/ratbox.py
+++ b/protocols/ratbox.py
@@ -54,21 +54,21 @@ class RatboxProtocol(TS6Protocol):
         # UID, gecos
 
         server = server or self.sid
-        if not self.isInternalServer(server):
+        if not self.is_internal_server(server):
             raise ValueError('Server %r is not a PyLink server!' % server)
 
         uid = self.uidgen[server].next_uid()
 
         ts = ts or int(time.time())
         realname = realname or conf.conf['bot']['realname']
-        raw_modes = self.joinModes(modes)
+        raw_modes = self.join_modes(modes)
 
         orig_realhost = realhost
         realhost = realhost or host
 
         u = self.users[uid] = IrcUser(nick, ts, uid, server, ident=ident, host=host, realname=realname,
             realhost=realhost, ip=ip, manipulatable=manipulatable)
-        self.applyModes(uid, modes)
+        self.apply_modes(uid, modes)
         self.servers[server].users.add(uid)
 
         self._send_with_prefix(server, "UID {nick} 1 {ts} {modes} {ident} {host} {ip} {uid} "
diff --git a/protocols/ts6.py b/protocols/ts6.py
index 73466b7..6f4511d 100644
--- a/protocols/ts6.py
+++ b/protocols/ts6.py
@@ -38,7 +38,7 @@ class TS6Protocol(TS6BaseProtocol):
         """
         server = server or self.sid
 
-        if not self.isInternalServer(server):
+        if not self.is_internal_server(server):
             raise ValueError('Server %r is not a PyLink server!' % server)
 
         uid = self.uidgen[server].next_uid()
@@ -49,11 +49,11 @@ class TS6Protocol(TS6BaseProtocol):
         ts = ts or int(time.time())
         realname = realname or conf.conf['bot']['realname']
         realhost = realhost or host
-        raw_modes = self.joinModes(modes)
+        raw_modes = self.join_modes(modes)
         u = self.users[uid] = IrcUser(nick, ts, uid, server, ident=ident, host=host, realname=realname,
             realhost=realhost, ip=ip, manipulatable=manipulatable, opertype=opertype)
 
-        self.applyModes(uid, modes)
+        self.apply_modes(uid, modes)
         self.servers[server].users.add(uid)
 
         self._send_with_prefix(server, "EUID {nick} 1 {ts} {modes} {ident} {host} {ip} {uid} "
@@ -66,10 +66,10 @@ class TS6Protocol(TS6BaseProtocol):
 
     def join(self, client, channel):
         """Joins a PyLink client to a channel."""
-        channel = self.toLower(channel)
+        channel = self.to_lower(channel)
         # JOIN:
         # parameters: channelTS, channel, '+' (a plus sign)
-        if not self.isInternalClient(client):
+        if not self.is_internal_client(client):
             log.error('(%s) Error trying to join %r to %r (no such client exists)', self.name, client, channel)
             raise LookupError('No such PyLink client exists.')
         self._send_with_prefix(client, "JOIN {ts} {channel} +".format(ts=self.channels[channel].ts, channel=channel))
@@ -96,7 +96,7 @@ class TS6Protocol(TS6BaseProtocol):
         # their status ('@+', '@', '+' or ''), for example:
         # '@+1JJAAAAAB +2JJAAAA4C 1JJAAAADS'. All users must be behind the source server
         # so it is not possible to use this message to force users to join a channel.
-        channel = self.toLower(channel)
+        channel = self.to_lower(channel)
         server = server or self.sid
         assert users, "sjoin: No users sent?"
         log.debug('(%s) sjoin: got %r for users', self.name, users)
@@ -149,7 +149,7 @@ class TS6Protocol(TS6BaseProtocol):
             namelist = ' '.join(namelist)
             self._send_with_prefix(server, "SJOIN {ts} {channel} {modes} :{users}".format(
                     ts=ts, users=namelist, channel=channel,
-                    modes=self.joinModes(regularmodes)))
+                    modes=self.join_modes(regularmodes)))
             self.channels[channel].users.update(uids)
 
         # Now, burst bans.
@@ -172,15 +172,15 @@ class TS6Protocol(TS6BaseProtocol):
         # c <- :0UYAAAAAA TMODE 0 #a +o 0T4AAAAAC
         # u <- :0UYAAAAAA MODE 0UYAAAAAA :-Facdefklnou
 
-        if (not self.isInternalClient(numeric)) and \
-                (not self.isInternalServer(numeric)):
+        if (not self.is_internal_client(numeric)) and \
+                (not self.is_internal_server(numeric)):
             raise LookupError('No such PyLink client/server exists.')
 
-        self.applyModes(target, modes)
+        self.apply_modes(target, modes)
         modes = list(modes)
 
         if utils.isChannel(target):
-            ts = ts or self.channels[self.toLower(target)].ts
+            ts = ts or self.channels[self.to_lower(target)].ts
             # TMODE:
             # parameters: channelTS, channel, cmode changes, opt. cmode parameters...
 
@@ -189,15 +189,15 @@ class TS6Protocol(TS6BaseProtocol):
             msgprefix = ':%s TMODE %s %s ' % (numeric, ts, target)
             bufsize = S2S_BUFSIZE - len(msgprefix)
 
-            for modestr in self.wrapModes(modes, bufsize, max_modes_per_msg=10):
+            for modestr in self.wrap_modes(modes, bufsize, max_modes_per_msg=10):
                 self.send(msgprefix + modestr)
         else:
-            joinedmodes = self.joinModes(modes)
+            joinedmodes = self.join_modes(modes)
             self._send_with_prefix(numeric, 'MODE %s %s' % (target, joinedmodes))
 
     def topicBurst(self, numeric, target, text):
         """Sends a topic change from a PyLink server. This is usually used on burst."""
-        if not self.isInternalServer(numeric):
+        if not self.is_internal_server(numeric):
             raise LookupError('No such PyLink server exists.')
         # TB
         # capab: TB
@@ -212,7 +212,7 @@ class TS6Protocol(TS6BaseProtocol):
 
     def invite(self, numeric, target, channel):
         """Sends an INVITE from a PyLink client.."""
-        if not self.isInternalClient(numeric):
+        if not self.is_internal_client(numeric):
             raise LookupError('No such PyLink client exists.')
         self._send_with_prefix(numeric, 'INVITE %s %s %s' % (target, channel, self.channels[channel].ts))
 
@@ -222,7 +222,7 @@ class TS6Protocol(TS6BaseProtocol):
             log.debug('(%s) knock: Dropping KNOCK to %r since the IRCd '
                       'doesn\'t support it.', self.name, target)
             return
-        if not self.isInternalClient(numeric):
+        if not self.is_internal_client(numeric):
             raise LookupError('No such PyLink client exists.')
         # No text value is supported here; drop it.
         self._send_with_prefix(numeric, 'KNOCK %s' % target)
@@ -233,10 +233,10 @@ class TS6Protocol(TS6BaseProtocol):
         if field == 'HOST':
             self.users[target].host = text
             self._send_with_prefix(self.sid, 'CHGHOST %s :%s' % (target, text))
-            if not self.isInternalClient(target):
+            if not self.is_internal_client(target):
                 # If the target isn't one of our clients, send hook payload
                 # for other plugins to listen to.
-                self.callHooks([self.sid, 'CHGHOST',
+                self.call_hooks([self.sid, 'CHGHOST',
                                    {'target': target, 'newhost': text}])
         else:
             raise NotImplementedError("Changing field %r of a client is "
@@ -406,7 +406,7 @@ class TS6Protocol(TS6BaseProtocol):
             destination = args[1]
         except IndexError:
             destination = self.sid
-        if self.isInternalServer(destination):
+        if self.is_internal_server(destination):
             self._send_with_prefix(destination, 'PONG %s %s' % (destination, source), queue=False)
 
             if destination == self.sid and not self.has_eob:
@@ -421,12 +421,12 @@ class TS6Protocol(TS6BaseProtocol):
         """Handles incoming SJOIN commands."""
         # parameters: channelTS, channel, simple modes, opt. mode parameters..., nicklist
         # <- :0UY SJOIN 1451041566 #channel +nt :@0UYAAAAAB
-        channel = self.toLower(args[1])
+        channel = self.to_lower(args[1])
         chandata = self.channels[channel].deepcopy()
         userlist = args[-1].split()
 
         modestring = args[2:-1] or args[2]
-        parsedmodes = self.parseModes(channel, modestring)
+        parsedmodes = self.parse_modes(channel, modestring)
         namelist = []
 
         # Keep track of other modes that are added due to prefix modes being joined too.
@@ -484,7 +484,7 @@ class TS6Protocol(TS6BaseProtocol):
                 self.users[numeric].channels.discard(channel)
             return {'channels': oldchans, 'text': 'Left all channels.', 'parse_as': 'PART'}
         else:
-            channel = self.toLower(args[1])
+            channel = self.to_lower(args[1])
             self.updateTS(numeric, channel, ts)
 
             self.users[numeric].channels.add(channel)
@@ -514,19 +514,19 @@ class TS6Protocol(TS6BaseProtocol):
 
         self.users[uid] = IrcUser(nick, ts, uid, numeric, ident, host, realname, realhost, ip)
 
-        parsedmodes = self.parseModes(uid, [modes])
+        parsedmodes = self.parse_modes(uid, [modes])
         log.debug('Applying modes %s for %s', parsedmodes, uid)
-        self.applyModes(uid, parsedmodes)
+        self.apply_modes(uid, parsedmodes)
         self.servers[numeric].users.add(uid)
 
         # Call the OPERED UP hook if +o is being added to the mode list.
         if ('+o', None) in parsedmodes:
             otype = 'Server Administrator' if ('+a', None) in parsedmodes else 'IRC Operator'
-            self.callHooks([uid, 'CLIENT_OPERED', {'text': otype}])
+            self.call_hooks([uid, 'CLIENT_OPERED', {'text': otype}])
 
         # Set the accountname if present
         if accountname != "*":
-            self.callHooks([uid, 'CLIENT_SERVICES_LOGIN', {'text': accountname}])
+            self.call_hooks([uid, 'CLIENT_SERVICES_LOGIN', {'text': accountname}])
 
         return {'uid': uid, 'ts': ts, 'nick': nick, 'realhost': realhost, 'host': host, 'ident': ident, 'ip': ip}
 
@@ -587,11 +587,11 @@ class TS6Protocol(TS6BaseProtocol):
         """Handles incoming TMODE commands (channel mode change)."""
         # <- :42XAAAAAB TMODE 1437450768 #test -c+lkC 3 agte4
         # <- :0UYAAAAAD TMODE 0 #a +h 0UYAAAAAD
-        channel = self.toLower(args[1])
+        channel = self.to_lower(args[1])
         oldobj = self.channels[channel].deepcopy()
         modes = args[2:]
-        changedmodes = self.parseModes(channel, modes)
-        self.applyModes(channel, changedmodes)
+        changedmodes = self.parse_modes(channel, modes)
+        self.apply_modes(channel, changedmodes)
         ts = int(args[0])
         return {'target': channel, 'modes': changedmodes, 'ts': ts,
                 'channeldata': oldobj}
@@ -601,18 +601,18 @@ class TS6Protocol(TS6BaseProtocol):
         # <- :70MAAAAAA MODE 70MAAAAAA -i+xc
         target = args[0]
         modestrings = args[1:]
-        changedmodes = self.parseModes(target, modestrings)
-        self.applyModes(target, changedmodes)
+        changedmodes = self.parse_modes(target, modestrings)
+        self.apply_modes(target, changedmodes)
         # Call the OPERED UP hook if +o is being set.
         if ('+o', None) in changedmodes:
             otype = 'Server Administrator' if ('a', None) in self.users[target].modes else 'IRC Operator'
-            self.callHooks([target, 'CLIENT_OPERED', {'text': otype}])
+            self.call_hooks([target, 'CLIENT_OPERED', {'text': otype}])
         return {'target': target, 'modes': changedmodes}
 
     def handle_tb(self, numeric, command, args):
         """Handles incoming topic burst (TB) commands."""
         # <- :42X TB #chat 1467427448 GL!~gl@127.0.0.1 :test
-        channel = self.toLower(args[0])
+        channel = self.to_lower(args[0])
         ts = args[1]
         setter = args[2]
         topic = args[-1]
@@ -624,7 +624,7 @@ class TS6Protocol(TS6BaseProtocol):
         """Handles extended topic burst (ETB)."""
         # <- :00AAAAAAC ETB 0 #test 1470021157 GL :test | abcd
         # Same as TB, with extra TS and extensions arguments.
-        channel = self.toLower(args[1])
+        channel = self.to_lower(args[1])
         ts = args[2]
         setter = args[3]
         topic = args[-1]
@@ -642,13 +642,13 @@ class TS6Protocol(TS6BaseProtocol):
         """Handles incoming BMASK commands (ban propagation on burst)."""
         # <- :42X BMASK 1424222769 #dev b :*!test@*.isp.net *!badident@*
         # This is used for propagating bans, not TMODE!
-        channel = self.toLower(args[1])
+        channel = self.to_lower(args[1])
         mode = args[2]
         ts = int(args[0])
         modes = []
         for ban in args[-1].split():
             modes.append(('+%s' % mode, ban))
-        self.applyModes(channel, modes)
+        self.apply_modes(channel, modes)
         return {'target': channel, 'modes': modes, 'ts': ts}
 
     def handle_472(self, numeric, command, args):
@@ -684,7 +684,7 @@ class TS6Protocol(TS6BaseProtocol):
             account = ''  # No account name means a logout
 
         uid = args[0]
-        self.callHooks([uid, 'CLIENT_SERVICES_LOGIN', {'text': account}])
+        self.call_hooks([uid, 'CLIENT_SERVICES_LOGIN', {'text': account}])
 
     def handle_rsfnc(self, numeric, command, args):
         """
diff --git a/protocols/ts6_common.py b/protocols/ts6_common.py
index 65bf741..bc82488 100644
--- a/protocols/ts6_common.py
+++ b/protocols/ts6_common.py
@@ -134,11 +134,11 @@ class TS6BaseProtocol(IRCS2SProtocol):
     def kick(self, numeric, channel, target, reason=None):
         """Sends kicks from a PyLink client/server."""
 
-        if (not self.isInternalClient(numeric)) and \
-                (not self.isInternalServer(numeric)):
+        if (not self.is_internal_client(numeric)) and \
+                (not self.is_internal_server(numeric)):
             raise LookupError('No such PyLink client/server exists.')
 
-        channel = self.toLower(channel)
+        channel = self.to_lower(channel)
         if not reason:
             reason = 'No reason given'
 
@@ -155,8 +155,8 @@ class TS6BaseProtocol(IRCS2SProtocol):
     def kill(self, numeric, target, reason):
         """Sends a kill from a PyLink client/server."""
 
-        if (not self.isInternalClient(numeric)) and \
-                (not self.isInternalServer(numeric)):
+        if (not self.is_internal_client(numeric)) and \
+                (not self.is_internal_server(numeric)):
             raise LookupError('No such PyLink client/server exists.')
 
         # From TS6 docs:
@@ -187,7 +187,7 @@ class TS6BaseProtocol(IRCS2SProtocol):
 
     def nick(self, numeric, newnick):
         """Changes the nick of a PyLink client."""
-        if not self.isInternalClient(numeric):
+        if not self.is_internal_client(numeric):
             raise LookupError('No such PyLink client exists.')
 
         self._send_with_prefix(numeric, 'NICK %s %s' % (newnick, int(time.time())))
@@ -199,8 +199,8 @@ class TS6BaseProtocol(IRCS2SProtocol):
 
     def part(self, client, channel, reason=None):
         """Sends a part from a PyLink client."""
-        channel = self.toLower(channel)
-        if not self.isInternalClient(client):
+        channel = self.to_lower(channel)
+        if not self.is_internal_client(client):
             log.error('(%s) Error trying to part %r from %r (no such client exists)', self.name, client, channel)
             raise LookupError('No such PyLink client exists.')
         msg = "PART %s" % channel
@@ -211,7 +211,7 @@ class TS6BaseProtocol(IRCS2SProtocol):
 
     def quit(self, numeric, reason):
         """Quits a PyLink client."""
-        if self.isInternalClient(numeric):
+        if self.is_internal_client(numeric):
             self._send_with_prefix(numeric, "QUIT :%s" % reason)
             self._remove_client(numeric)
         else:
@@ -219,7 +219,7 @@ class TS6BaseProtocol(IRCS2SProtocol):
 
     def message(self, numeric, target, text):
         """Sends a PRIVMSG from a PyLink client."""
-        if not self.isInternalClient(numeric):
+        if not self.is_internal_client(numeric):
             raise LookupError('No such PyLink client exists.')
 
         # Mangle message targets for IRCds that require it.
@@ -229,8 +229,8 @@ class TS6BaseProtocol(IRCS2SProtocol):
 
     def notice(self, numeric, target, text):
         """Sends a NOTICE from a PyLink client or server."""
-        if (not self.isInternalClient(numeric)) and \
-                (not self.isInternalServer(numeric)):
+        if (not self.is_internal_client(numeric)) and \
+                (not self.is_internal_server(numeric)):
             raise LookupError('No such PyLink client/server exists.')
 
         # Mangle message targets for IRCds that require it.
@@ -240,7 +240,7 @@ class TS6BaseProtocol(IRCS2SProtocol):
 
     def topic(self, numeric, target, text):
         """Sends a TOPIC change from a PyLink client."""
-        if not self.isInternalClient(numeric):
+        if not self.is_internal_client(numeric):
             raise LookupError('No such PyLink client exists.')
         self._send_with_prefix(numeric, 'TOPIC %s :%s' % (target, text))
         self.channels[target].topic = text
@@ -268,7 +268,7 @@ class TS6BaseProtocol(IRCS2SProtocol):
         for server in self.servers.values():
             if name == server.name:
                 raise ValueError('A server named %r already exists!' % name)
-        if not self.isInternalServer(uplink):
+        if not self.is_internal_server(uplink):
             raise ValueError('Server %r is not a PyLink server!' % uplink)
         if not utils.isServerName(name):
             raise ValueError('Invalid server name %r' % name)
@@ -296,7 +296,7 @@ class TS6BaseProtocol(IRCS2SProtocol):
     def handle_kick(self, source, command, args):
         """Handles incoming KICKs."""
         # :70MAAAAAA KICK #test 70MAAAAAA :some reason
-        channel = self.toLower(args[0])
+        channel = self.to_lower(args[0])
         kicked = self._get_UID(args[1])
 
         try:
@@ -343,7 +343,7 @@ class TS6BaseProtocol(IRCS2SProtocol):
         """Handles incoming TOPIC changes from clients. For topic bursts,
         TB (TS6/charybdis) and FTOPIC (InspIRCd) are used instead."""
         # <- :70MAAAAAA TOPIC #test :test
-        channel = self.toLower(args[0])
+        channel = self.to_lower(args[0])
         topic = args[1]
 
         oldtopic = self.channels[channel].topic
diff --git a/protocols/unreal.py b/protocols/unreal.py
index 96847f7..5208821 100644
--- a/protocols/unreal.py
+++ b/protocols/unreal.py
@@ -66,7 +66,7 @@ class UnrealProtocol(TS6BaseProtocol):
         up to plugins to make sure they don't introduce anything invalid.
         """
         server = server or self.sid
-        if not self.isInternalServer(server):
+        if not self.is_internal_server(server):
             raise ValueError('Server %r is not a PyLink server!' % server)
 
         # Unreal 4.0 uses TS6-style UIDs. They don't start from AAAAAA like other IRCd's
@@ -81,10 +81,10 @@ class UnrealProtocol(TS6BaseProtocol):
         modes = set(modes)  # Ensure type safety
         modes |= {('+x', None), ('+t', None)}
 
-        raw_modes = self.joinModes(modes)
+        raw_modes = self.join_modes(modes)
         u = self.users[uid] = IrcUser(nick, ts, uid, server, ident=ident, host=host, realname=realname,
             realhost=realhost, ip=ip, manipulatable=manipulatable, opertype=opertype)
-        self.applyModes(uid, modes)
+        self.apply_modes(uid, modes)
         self.servers[server].users.add(uid)
 
         # UnrealIRCd requires encoding the IP by first packing it into a binary format,
@@ -116,8 +116,8 @@ class UnrealProtocol(TS6BaseProtocol):
 
     def join(self, client, channel):
         """Joins a PyLink client to a channel."""
-        channel = self.toLower(channel)
-        if not self.isInternalClient(client):
+        channel = self.to_lower(channel)
+        if not self.is_internal_client(client):
             raise LookupError('No such PyLink client exists.')
         self._send_with_prefix(client, "JOIN %s" % channel)
         self.channels[channel].users.add(client)
@@ -135,7 +135,7 @@ class UnrealProtocol(TS6BaseProtocol):
             sjoin(self.sid, '#test', [('o', self.pseudoclient.uid)])
         """
         # <- :001 SJOIN 1444361345 #test :*@+1JJAAAAAB %2JJAAAA4C 1JJAAAADS
-        channel = self.toLower(channel)
+        channel = self.to_lower(channel)
         server = server or self.sid
         assert users, "sjoin: No users sent?"
         if not server:
@@ -189,7 +189,7 @@ class UnrealProtocol(TS6BaseProtocol):
 
         # Modes are optional; add them if they exist
         if modes:
-            sjoin_prefix += " %s" % self.joinModes(simplemodes)
+            sjoin_prefix += " %s" % self.join_modes(simplemodes)
 
         sjoin_prefix += " :"
         # Wrap arguments to the max supported S2S line length to prevent cutoff
@@ -212,15 +212,15 @@ class UnrealProtocol(TS6BaseProtocol):
     def mode(self, numeric, target, modes, ts=None):
         """
         Sends mode changes from a PyLink client/server. The mode list should be
-        a list of (mode, arg) tuples, i.e. the format of utils.parseModes() output.
+        a list of (mode, arg) tuples, i.e. the format of utils.parse_modes() output.
         """
         # <- :unreal.midnight.vpn MODE #test +ntCo GL 1444361345
 
-        if (not self.isInternalClient(numeric)) and \
-                (not self.isInternalServer(numeric)):
+        if (not self.is_internal_client(numeric)) and \
+                (not self.is_internal_server(numeric)):
             raise LookupError('No such PyLink client/server exists.')
 
-        self.applyModes(target, modes)
+        self.apply_modes(target, modes)
 
         if utils.isChannel(target):
 
@@ -231,7 +231,7 @@ class UnrealProtocol(TS6BaseProtocol):
                     modes[idx] = (mode[0], self._expandPUID(mode[1]))
 
             # The MODE command is used for channel mode changes only
-            ts = ts or self.channels[self.toLower(target)].ts
+            ts = ts or self.channels[self.to_lower(target)].ts
 
             # 7 characters for "MODE", the space between MODE and the target, the space between the
             # target and mode list, and the space between the mode list and TS.
@@ -242,7 +242,7 @@ class UnrealProtocol(TS6BaseProtocol):
             bufsize -= len(target)
 
             # Subtract the prefix (":SID " for servers or ":SIDAAAAAA " for servers)
-            bufsize -= (5 if self.isInternalServer(numeric) else 11)
+            bufsize -= (5 if self.is_internal_server(numeric) else 11)
 
             # There is also an (undocumented) 15 args per line limit for MODE. The target, mode
             # characters, and TS take up three args, so we're left with 12 spaces for parameters.
@@ -251,24 +251,24 @@ class UnrealProtocol(TS6BaseProtocol):
             # * *** Warning! Possible desynch: MODE for channel #test ('+bbbbbbbbbbbb *!*@0.1 *!*@1.1 *!*@2.1 *!*@3.1 *!*@4.1 *!*@5.1 *!*@6.1 *!*@7.1 *!*@8.1 *!*@9.1 *!*@10.1 *!*@11.1') has fishy timestamp (12) (from pylink.local/pylink.local)
 
             # Thanks to kevin and Jobe for helping me debug this!
-            for modestring in self.wrapModes(modes, bufsize, max_modes_per_msg=12):
+            for modestring in self.wrap_modes(modes, bufsize, max_modes_per_msg=12):
                 self._send_with_prefix(numeric, 'MODE %s %s %s' % (target, modestring, ts))
         else:
             # For user modes, the only way to set modes (for non-U:Lined servers)
             # is through UMODE2, which sets the modes on the caller.
             # U:Lines can use SVSMODE/SVS2MODE, but I won't expect people to
             # U:Line a PyLink daemon...
-            if not self.isInternalClient(target):
+            if not self.is_internal_client(target):
                 raise ProtocolError('Cannot force mode change on external clients!')
 
             # XXX: I don't expect usermode changes to ever get cut off, but length
             # checks could be added just to be safe...
-            joinedmodes = self.joinModes(modes)
+            joinedmodes = self.join_modes(modes)
             self._send_with_prefix(target, 'UMODE2 %s' % joinedmodes)
 
     def topicBurst(self, numeric, target, text):
         """Sends a TOPIC change from a PyLink server."""
-        if not self.isInternalServer(numeric):
+        if not self.is_internal_server(numeric):
             raise LookupError('No such PyLink server exists.')
         self._send_with_prefix(numeric, 'TOPIC %s :%s' % (target, text))
         self.channels[target].topic = text
@@ -282,7 +282,7 @@ class UnrealProtocol(TS6BaseProtocol):
             raise NotImplementedError("Changing field %r of a client is "
                                       "unsupported by this protocol." % field)
 
-        if self.isInternalClient(target):
+        if self.is_internal_client(target):
             # It is one of our clients, use SETIDENT/HOST/NAME.
             if field == 'IDENT':
                 self.users[target].ident = text
@@ -300,26 +300,26 @@ class UnrealProtocol(TS6BaseProtocol):
                 self._send_with_prefix(self.sid, 'CHGIDENT %s %s' % (target, text))
 
                 # Send hook payloads for other plugins to listen to.
-                self.callHooks([self.sid, 'CHGIDENT',
+                self.call_hooks([self.sid, 'CHGIDENT',
                                    {'target': target, 'newident': text}])
 
             elif field == 'HOST':
                 self.users[target].host = text
                 self._send_with_prefix(self.sid, 'CHGHOST %s %s' % (target, text))
 
-                self.callHooks([self.sid, 'CHGHOST',
+                self.call_hooks([self.sid, 'CHGHOST',
                                    {'target': target, 'newhost': text}])
 
             elif field in ('REALNAME', 'GECOS'):
                 self.users[target].realname = text
                 self._send_with_prefix(self.sid, 'CHGNAME %s :%s' % (target, text))
 
-                self.callHooks([self.sid, 'CHGNAME',
+                self.call_hooks([self.sid, 'CHGNAME',
                                    {'target': target, 'newgecos': text}])
 
     def invite(self, numeric, target, channel):
         """Sends an INVITE from a PyLink client.."""
-        if not self.isInternalClient(numeric):
+        if not self.is_internal_client(numeric):
             raise LookupError('No such PyLink client exists.')
         self._send_with_prefix(numeric, 'INVITE %s %s' % (target, channel))
 
@@ -329,8 +329,8 @@ class UnrealProtocol(TS6BaseProtocol):
         # sent to all ops in a channel.
         # <- :unreal.midnight.vpn NOTICE @#test :[Knock] by GL|!gl@hidden-1C620195 (test)
         assert utils.isChannel(target), "Can only knock on channels!"
-        sender = self.getServer(numeric)
-        s = '[Knock] by %s (%s)' % (self.getHostmask(numeric), text)
+        sender = self.get_server(numeric)
+        s = '[Knock] by %s (%s)' % (self.get_hostmask(numeric), text)
         self._send_with_prefix(sender, 'NOTICE @%s :%s' % (target, s))
 
     ### HANDLERS
@@ -422,8 +422,8 @@ class UnrealProtocol(TS6BaseProtocol):
         self.servers[numeric].users.add(uid)
 
         # Handle user modes
-        parsedmodes = self.parseModes(uid, [modestring])
-        self.applyModes(uid, parsedmodes)
+        parsedmodes = self.parse_modes(uid, [modestring])
+        self.apply_modes(uid, parsedmodes)
 
         # The cloaked (+x) host is completely separate from the displayed host
         # and real host in that it is ONLY shown if the user is +x (cloak mode
@@ -432,7 +432,7 @@ class UnrealProtocol(TS6BaseProtocol):
 
         if ('+o', None) in parsedmodes:
             # If +o being set, call the CLIENT_OPERED internal hook.
-            self.callHooks([uid, 'CLIENT_OPERED', {'text': 'IRC Operator'}])
+            self.call_hooks([uid, 'CLIENT_OPERED', {'text': 'IRC Operator'}])
 
         if ('+x', None) not in parsedmodes:
             # If +x is not set, update to use the person's real host.
@@ -443,7 +443,7 @@ class UnrealProtocol(TS6BaseProtocol):
             accountname = nick
 
         if not accountname.isdigit():
-            self.callHooks([uid, 'CLIENT_SERVICES_LOGIN', {'text': accountname}])
+            self.call_hooks([uid, 'CLIENT_SERVICES_LOGIN', {'text': accountname}])
 
         return {'uid': uid, 'ts': ts, 'nick': nick, 'realhost': realhost, 'host': host, 'ident': ident, 'ip': ip}
 
@@ -564,7 +564,7 @@ class UnrealProtocol(TS6BaseProtocol):
         else:
             for channel in args[0].split(','):
                 # Normalize channel case.
-                channel = self.toLower(channel)
+                channel = self.to_lower(channel)
 
                 c = self.channels[channel]
 
@@ -572,14 +572,14 @@ class UnrealProtocol(TS6BaseProtocol):
                 self.channels[channel].users.add(numeric)
                 # Call hooks manually, because one JOIN command in UnrealIRCd can
                 # have multiple channels...
-                self.callHooks([numeric, command, {'channel': channel, 'users': [numeric], 'modes':
+                self.call_hooks([numeric, command, {'channel': channel, 'users': [numeric], 'modes':
                                                        c.modes, 'ts': c.ts}])
 
     def handle_sjoin(self, numeric, command, args):
         """Handles the UnrealIRCd SJOIN command."""
         # <- :001 SJOIN 1444361345 #test :001AAAAAA @001AAAAAB +001AAAAAC
         # <- :001 SJOIN 1483250129 #services +nt :+001OR9V02 @*~001DH6901 &*!*@test "*!*@blah.blah '*!*@yes.no
-        channel = self.toLower(args[1])
+        channel = self.to_lower(args[1])
         chandata = self.channels[channel].deepcopy()
         userlist = args[-1].split()
 
@@ -599,7 +599,7 @@ class UnrealProtocol(TS6BaseProtocol):
                 # Strip extra spaces between the mode argument and the user list, if
                 # there are any. XXX: report this as a bug in unreal's s2s protocol?
                 modestring = [m for m in modestring if m]
-                parsedmodes = self.parseModes(channel, modestring)
+                parsedmodes = self.parse_modes(channel, modestring)
                 changedmodes = set(parsedmodes)
         except IndexError:
             pass
@@ -705,11 +705,11 @@ class UnrealProtocol(TS6BaseProtocol):
 
         # Also, we need to get rid of that extra space following the +f argument. :|
         if utils.isChannel(args[0]):
-            channel = self.toLower(args[0])
+            channel = self.to_lower(args[0])
             oldobj = self.channels[channel].deepcopy()
 
             modes = [arg for arg in args[1:] if arg]  # normalize whitespace
-            parsedmodes = self.parseModes(channel, modes)
+            parsedmodes = self.parse_modes(channel, modes)
 
             if parsedmodes:
                 if parsedmodes[0][0] == '+&':
@@ -720,7 +720,7 @@ class UnrealProtocol(TS6BaseProtocol):
                               self.name, modes, channel, self.channels[channel].ts)
                     return
 
-                self.applyModes(channel, parsedmodes)
+                self.apply_modes(channel, parsedmodes)
 
             if numeric in self.servers and args[-1].isdigit():
                 # Sender is a server AND last arg is number. Perform TS updates.
@@ -763,7 +763,7 @@ class UnrealProtocol(TS6BaseProtocol):
 
         if newhost != oldhost:
             # Only send a payload if the old and new hosts are different.
-            self.callHooks([uid, 'SETHOST',
+            self.call_hooks([uid, 'SETHOST',
                                {'target': uid, 'newhost': newhost}])
 
     def handle_svsmode(self, numeric, command, args):
@@ -772,8 +772,8 @@ class UnrealProtocol(TS6BaseProtocol):
         target = self._get_UID(args[0])
         modes = args[1:]
 
-        parsedmodes = self.parseModes(target, modes)
-        self.applyModes(target, parsedmodes)
+        parsedmodes = self.parse_modes(target, modes)
+        self.apply_modes(target, parsedmodes)
 
         # If +x/-x is being set, update cloaked host info.
         self._check_cloak_change(target, parsedmodes)
@@ -818,7 +818,7 @@ class UnrealProtocol(TS6BaseProtocol):
         # <- :NickServ SVS2MODE 001SALZ01 +r
 
         target = self._get_UID(args[0])
-        parsedmodes = self.parseModes(target, args[1:])
+        parsedmodes = self.parse_modes(target, args[1:])
 
         if ('+r', None) in parsedmodes:
             # Umode +r is being set (log in)
@@ -829,13 +829,13 @@ class UnrealProtocol(TS6BaseProtocol):
                 # If one doesn't exist, make it the same as the nick, but only if the account name
                 # wasn't set already.
                 if not self.users[target].services_account:
-                    account = self.getFriendlyName(target)
+                    account = self.get_friendly_name(target)
                 else:
                     return
             else:
                 if account.isdigit():
                     # If the +d argument is a number, ignore it and set the account name to the nick.
-                    account = self.getFriendlyName(target)
+                    account = self.get_friendly_name(target)
 
         elif ('-r', None) in parsedmodes:
             # Umode -r being set.
@@ -853,17 +853,17 @@ class UnrealProtocol(TS6BaseProtocol):
         else:
             return
 
-        self.callHooks([target, 'CLIENT_SERVICES_LOGIN', {'text': account}])
+        self.call_hooks([target, 'CLIENT_SERVICES_LOGIN', {'text': account}])
 
     def handle_umode2(self, numeric, command, args):
         """Handles UMODE2, used to set user modes on oneself."""
         # <- :GL UMODE2 +W
-        parsedmodes = self.parseModes(numeric, args)
-        self.applyModes(numeric, parsedmodes)
+        parsedmodes = self.parse_modes(numeric, args)
+        self.apply_modes(numeric, parsedmodes)
 
         if ('+o', None) in parsedmodes:
             # If +o being set, call the CLIENT_OPERED internal hook.
-            self.callHooks([numeric, 'CLIENT_OPERED', {'text': 'IRC Operator'}])
+            self.call_hooks([numeric, 'CLIENT_OPERED', {'text': 'IRC Operator'}])
 
         self._check_cloak_change(numeric, parsedmodes)
 
@@ -873,7 +873,7 @@ class UnrealProtocol(TS6BaseProtocol):
         """Handles the TOPIC command."""
         # <- GL TOPIC #services GL 1444699395 :weeee
         # <- TOPIC #services devel.relay 1452399682 :test
-        channel = self.toLower(args[0])
+        channel = self.to_lower(args[0])
         topic = args[-1]
         setter = args[1]
         ts = args[2]
@@ -898,7 +898,7 @@ class UnrealProtocol(TS6BaseProtocol):
 
         # When SETHOST or CHGHOST is used, modes +xt are implicitly set on the
         # target.
-        self.applyModes(numeric, [('+x', None), ('+t', None)])
+        self.apply_modes(numeric, [('+x', None), ('+t', None)])
 
         return {'target': numeric, 'newhost': newhost}
 
@@ -923,7 +923,7 @@ class UnrealProtocol(TS6BaseProtocol):
 
         # When SETHOST or CHGHOST is used, modes +xt are implicitly set on the
         # target.
-        self.applyModes(target, [('+x', None), ('+t', None)])
+        self.apply_modes(target, [('+x', None), ('+t', None)])
 
         return {'target': target, 'newhost': newhost}