Remove conn.readable_name

Author: dmptrluke

cloudbot/bot.py

@@ -117,21 +117,20 @@ def run(self):
 
     def create_connections(self):
         """ Create a BotConnection for all the networks defined in the config """
-        for conf in self.config['connections']:
+        for config in self.config['connections']:
             # strip all spaces and capitalization from the connection name
-            readable_name = conf['name']
-            name = clean_name(readable_name)
-            nick = conf['nick']
-            server = conf['connection']['server']
-            port = conf['connection'].get('port', 6667)
-            local_bind = (conf['connection'].get('bind_addr', False), conf['connection'].get('bind_port', 0))
+            name = clean_name(config['name'])
+            nick = config['nick']
+            server = config['connection']['server']
+            port = config['connection'].get('port', 6667)
+            local_bind = (config['connection'].get('bind_addr', False), config['connection'].get('bind_port', 0))
             if local_bind[0] is False:
                 local_bind = False
 
-            self.connections.append(IrcClient(self, name, nick, config=conf, channels=conf['channels'],
-                                              readable_name=readable_name, server=server, port=port,
-                                              use_ssl=conf['connection'].get('ssl', False), local_bind=local_bind))
-            logger.debug("[{}] Created connection.".format(readable_name))
+            self.connections.append(IrcClient(self, name, nick, config=config, channels=config['channels'],
+                                              server=server, port=port, use_ssl=config['connection'].get('ssl', False),
+                                              local_bind=local_bind))
+            logger.debug("[{}] Created connection.".format(name))
 
     @asyncio.coroutine
     def stop(self, reason=None, *, restart=False):
@@ -150,7 +149,7 @@ def stop(self, reason=None, *, restart=False):
             if not connection.connected:
                 # Don't quit a connection that hasn't connected
                 continue
-            logger.debug("[{}] Closing connection.".format(connection.readable_name))
+            logger.debug("[{}] Closing connection.".format(connection.name))
 
             connection.quit(reason)
 

cloudbot/client.py

@@ -12,7 +12,6 @@ class Client:
     :type bot: cloudbot.bot.CloudBot
     :type loop: asyncio.events.AbstractEventLoop
     :type name: str
-    :type readable_name: str
     :type channels: list[str]
     :type config: dict[str, unknown]
     :type nick: str
@@ -21,11 +20,10 @@ class Client:
     :type permissions: PermissionManager
     """
 
-    def __init__(self, bot, name, nick, *, readable_name, channels=None, config=None):
+    def __init__(self, bot, name, nick, *, channels=None, config=None):
         """
         :type bot: cloudbot.bot.CloudBot
         :type name: str
-        :type readable_name: str
         :type nick: str
         :type channels: list[str]
         :type config: dict[str, unknown]
@@ -34,7 +32,6 @@ def __init__(self, bot, name, nick, *, readable_name, channels=None, config=None
         self.loop = bot.loop
         self.name = name
         self.nick = nick
-        self.readable_name = readable_name
 
         if channels is None:
             self.channels = []

cloudbot/clients/irc.py

@@ -46,12 +46,11 @@ class IrcClient(Client):
     :type _ignore_cert_errors: bool
     """
 
-    def __init__(self, bot, name, nick, *, readable_name, channels=None, config=None,
+    def __init__(self, bot, name, nick, *, channels=None, config=None,
                  server, port=6667, use_ssl=False, ignore_cert_errors=True, timeout=300, local_bind=False):
         """
         :type bot: cloudbot.bot.CloudBot
         :type name: str
-        :type readable_name: str
         :type nick: str
         :type channels: list[str]
         :type config: dict[str, unknown]
@@ -61,7 +60,7 @@ def __init__(self, bot, name, nick, *, readable_name, channels=None, config=None
         :type ignore_cert_errors: bool
         :type timeout: int
         """
-        super().__init__(bot, name, nick, readable_name=readable_name, channels=channels, config=config)
+        super().__init__(bot, name, nick, channels=channels, config=config)
 
         self.use_ssl = use_ssl
         self._ignore_cert_errors = ignore_cert_errors
@@ -106,11 +105,11 @@ def connect(self):
             return
 
         if self._connected:
-            logger.info("[{}] Reconnecting".format(self.readable_name))
+            logger.info("[{}] Reconnecting".format(self.name))
             self._transport.close()
         else:
             self._connected = True
-            logger.info("[{}] Connecting".format(self.readable_name))
+            logger.info("[{}] Connecting".format(self.name))
         optional_params = {}
         if self.local_bind:
             optional_params["local_addr"] = self.local_bind
@@ -208,7 +207,7 @@ def _send(self, line):
         Sends a raw IRC line unchecked. Doesn't do connected check, and is *not* threadsafe
         :type line: str
         """
-        logger.info("[{}] >> {}".format(self.readable_name, line))
+        logger.info("[{}] >> {}".format(self.name, line))
         asyncio.async(self._protocol.send(line), loop=self.loop)
 
 
@@ -262,14 +261,14 @@ def connection_lost(self, exc):
         if exc is None:
             # we've been closed intentionally, so don't reconnect
             return
-        logger.error("[{}] Connection lost: {}".format(self.conn.readable_name, exc))
+        logger.error("[{}] Connection lost: {}".format(self.conn.name, exc))
         asyncio.async(self.conn.connect(), loop=self.loop)
 
     def eof_received(self):
         self._connected = False
         # create a new connected_future for when we are connected.
         self._connected_future = asyncio.Future(loop=self.loop)
-        logger.info("[{}] EOF received.".format(self.conn.readable_name))
+        logger.info("[{}] EOF received.".format(self.conn.name))
         asyncio.async(self.conn.connect(), loop=self.loop)
         return True
 
@@ -294,7 +293,7 @@ def data_received(self, data):
                 prefix_line_match = irc_prefix_re.match(line)
                 if prefix_line_match is None:
                     logger.critical("[{}] Received invalid IRC line '{}' from {}".format(
-                        self.conn.readable_name, line, self.conn.describe_server()))
+                        self.conn.name, line, self.conn.describe_server()))
                     continue
 
                 netmask_prefix, command, params = prefix_line_match.groups()
@@ -316,7 +315,7 @@ def data_received(self, data):
                 noprefix_line_match = irc_noprefix_re.match(line)
                 if noprefix_line_match is None:
                     logger.critical("[{}] Received invalid IRC line '{}' from {}".format(
-                        self.conn.readable_name, line, self.conn.describe_server()))
+                        self.conn.name, line, self.conn.describe_server()))
                     continue
                 command = noprefix_line_match.group(1)
                 params = noprefix_line_match.group(2)

cloudbot/permissions.py

@@ -11,7 +11,6 @@
 class PermissionManager(object):
     """
     :type name: str
-    :type readable_name: str
     :type config: dict[str, ?]
     :type group_perms: dict[str, list[str]]
     :type group_users: dict[str, list[str]]
@@ -22,11 +21,10 @@ def __init__(self, conn):
         """
         :type conn: cloudbot.client.Client
         """
-        logger.info("[{}|permissions] Created permission manager for {}.".format(conn.readable_name, conn.name))
+        logger.info("[{}|permissions] Created permission manager for {}.".format(conn.name, conn.name))
 
         # stuff
         self.name = conn.name
-        self.readable_name = conn.readable_name
         self.config = conn.config
 
         self.group_perms = {}
@@ -39,14 +37,14 @@ def reload(self):
         self.group_perms = {}
         self.group_users = {}
         self.perm_users = {}
-        logger.info("[{}|permissions] Reloading permissions for {}.".format(self.readable_name, self.name))
+        logger.info("[{}|permissions] Reloading permissions for {}.".format(self.name, self.name))
         groups = self.config.get("permissions", {})
         # work out the permissions and users each group has
         for key, value in groups.items():
             if not key.islower():
-                logger.warning("[{}|permissions] Warning! Non-lower-case group '{}' in config. This will cause problems when"
-                               "setting permissions using the bot's permissions commands"
-                               .format(self.readable_name, key))
+                logger.warning("[{}|permissions] Warning! Non-lower-case group '{}' in config. This will cause problems"
+                               " when setting permissions using the bot's permissions commands"
+                               .format(self.name, key))
             key = key.lower()
             self.group_perms[key] = []
             self.group_users[key] = []
@@ -62,9 +60,9 @@ def reload(self):
                     self.perm_users[perm] = []
                 self.perm_users[perm].extend(users)
 
-        logger.debug("[{}|permissions] Group permissions: {}".format(self.readable_name, self.group_perms))
-        logger.debug("[{}|permissions] Group users: {}".format(self.readable_name, self.group_users))
-        logger.debug("[{}|permissions] Permission users: {}".format(self.readable_name, self.perm_users))
+        logger.debug("[{}|permissions] Group permissions: {}".format(self.name, self.group_perms))
+        logger.debug("[{}|permissions] Group users: {}".format(self.name, self.group_users))
+        logger.debug("[{}|permissions] Permission users: {}".format(self.name, self.perm_users))
 
     def has_perm_mask(self, user_mask, perm, notice=True):
         """
@@ -86,7 +84,7 @@ def has_perm_mask(self, user_mask, perm, notice=True):
         for allowed_mask in allowed_users:
             if fnmatch(user_mask.lower(), allowed_mask):
                 if notice:
-                    logger.info("[{}|permissions] Allowed user {} access to {}".format(self.readable_name, user_mask, perm))
+                    logger.info("[{}|permissions] Allowed user {} access to {}".format(self.name, user_mask, perm))
                 return True
 
         return False
@@ -177,7 +175,8 @@ def remove_group_user(self, group, user_mask):
                 # Okay, maybe a warning, but no support.
                 if group not in config_groups:
                     logger.warning(
-                        "[{}|permissions] Can't remove user from group due to upper-case group names!".format(self.readable_name))
+                        "[{}|permissions] Can't remove user from group due to"
+                        " upper-case group names!".format(self.name))
                     continue
                 config_group = config_groups.get(group)
                 config_users = config_group.get("users")

plugins/core_misc.py

@@ -27,10 +27,10 @@ def onjoin(conn, bot):
     :type conn: cloudbot.clients.clients.IrcClient
     :type bot: cloudbot.bot.CloudBot
     """
-    bot.logger.info("[{}|misc] Bot is sending join commands for network.".format(conn.readable_name))
+    bot.logger.info("[{}|misc] Bot is sending join commands for network.".format(conn.name))
     nickserv = conn.config.get('nickserv')
     if nickserv and nickserv.get("enabled", True):
-        bot.logger.info("[{}|misc] Bot is authenticating with NickServ.".format(conn.readable_name))
+        bot.logger.info("[{}|misc] Bot is authenticating with NickServ.".format(conn.name))
         nickserv_password = nickserv.get('nickserv_password', '')
         nickserv_name = nickserv.get('nickserv_name', 'nickserv')
         nickserv_account_name = nickserv.get('nickserv_user', '')
@@ -50,16 +50,16 @@ def onjoin(conn, bot):
     # Set bot modes
     mode = conn.config.get('mode')
     if mode:
-        bot.logger.info("[{}|misc] Bot is setting mode on itself: {}".format(conn.readable_name, mode))
+        bot.logger.info("[{}|misc] Bot is setting mode on itself: {}".format(conn.name, mode))
         conn.cmd('MODE', conn.nick, mode)
 
     # Join config-defined channels
-    bot.logger.info("[{}|misc] Bot is joining channels for network.".format(conn.readable_name))
+    bot.logger.info("[{}|misc] Bot is joining channels for network.".format(conn.name))
     for channel in conn.channels:
         conn.join(channel)
         yield from asyncio.sleep(0.4)
 
-    bot.logger.info("[{}|misc] Bot has finished sending join commands for network.".format(conn.readable_name))
+    bot.logger.info("[{}|misc] Bot has finished sending join commands for network.".format(conn.name))
 
 
 @asyncio.coroutine

plugins/core_sieve.py

@@ -31,7 +31,7 @@ def init_tasks(loop, conn):
         # tasks already started
         return
 
-    logger.info("[{}|sieve] Bot is starting ratelimiter cleanup task.".format(conn.readable_name))
+    logger.info("[{}|sieve] Bot is starting ratelimiter cleanup task.".format(conn.name))
     loop.call_later(600, task_clear, loop)
     inited.append(conn.name)
 
@@ -102,7 +102,7 @@ def sieve_suite(bot, event, _hook):
             pass
         else:
             bot.logger.info("[{}|sieve] Refused command from {}. "
-                            "Entity had {} tokens, needed {}.".format(conn.readable_name, uid, bucket.tokens,
+                            "Entity had {} tokens, needed {}.".format(conn.name, uid, bucket.tokens,
                                                                       message_cost))
             if strict:
                 # bad person loses all tokens

plugins/core_tracker.py

@@ -16,15 +16,15 @@
 # functions called for bot state tracking
 
 def bot_left_channel(conn, chan):
-    logger.info("[{}|tracker] Bot left channel '{}'".format(conn.readable_name, chan))
+    logger.info("[{}|tracker] Bot left channel '{}'".format(conn.name, chan))
     if chan in conn.channels:
         conn.channels.remove(chan)
     if chan in conn.history:
         del conn.history[chan]
 
 
 def bot_joined_channel(conn, chan):
-    logger.info("[{}|tracker] Bot joined channel '{}'".format(conn.readable_name, chan))
+    logger.info("[{}|tracker] Bot joined channel '{}'".format(conn.name, chan))
     conn.channels.append(chan)
     conn.history[chan] = deque(maxlen=100)
 
@@ -44,7 +44,7 @@ def on_kick(conn, chan, target, loop):
         if conn.config.get('auto_rejoin', False):
             loop.call_later(5, conn.join, chan)
             loop.call_later(5, logger.info, "[{}|tracker] Bot was kicked from {}, "
-                                            "rejoining channel.".format(conn.readable_name, chan))
+                                            "rejoining channel.".format(conn.name, chan))
 
 
 @asyncio.coroutine
@@ -64,7 +64,7 @@ def on_nick(irc_paramlist, conn, irc_raw):
 
     if old_nick == conn.nick:
         conn.nick = new_nick
-        logger.info("[{}|tracker] Bot nick changed from '{}' to '{}'.".format(conn.readable_name, old_nick, new_nick))
+        logger.info("[{}|tracker] Bot nick changed from '{}' to '{}'.".format(conn.name, old_nick, new_nick))
 
 
 # for channels the host tells us we're joining without us joining it ourselves

plugins/log.py

@@ -54,7 +54,7 @@ def format_event(event):
     # Setup arguments
 
     args = {
-        "server": event.conn.readable_name, "target": event.target, "channel": event.chan, "nick": event.nick,
+        "server": event.conn.name, "target": event.target, "channel": event.chan, "nick": event.nick,
         "user": event.user, "host": event.host
     }
 
@@ -126,7 +126,7 @@ def format_irc_event(event, args):
 
     # Format using the default raw format
 
-    return irc_default.format(server=event.conn.readable_name, irc_raw=event.irc_raw)
+    return irc_default.format(server=event.conn.name, irc_raw=event.irc_raw)
 
 # +--------------+
 # | File logging |
@@ -147,7 +147,7 @@ def get_log_filename(server, chan):
     current_time = time.gmtime()
     folder_name = time.strftime(folder_format, current_time)
     file_name = time.strftime(file_format.format(chan=chan, server=server), current_time).lower()
-    return os.path.join(cloudbot.log_dir, folder_name, file_name)
+    return os.path.join(cloudbot.logging_dir, folder_name, file_name)
 
 
 def get_log_stream(server, chan):
@@ -162,8 +162,8 @@ def get_log_stream(server, chan):
             log_stream.flush()
             log_stream.close()
 
-        log_dir = os.path.dirname(new_filename)
-        os.makedirs(log_dir, exist_ok=True)
+        logging_dir = os.path.dirname(new_filename)
+        os.makedirs(logging_dir, exist_ok=True)
 
         # a dumb hack to bypass the fact windows does not allow * in file names
         new_filename = new_filename.replace("*", "server")
@@ -178,7 +178,7 @@ def get_raw_log_filename(server):
     current_time = time.gmtime()
     folder_name = time.strftime(folder_format, current_time)
     file_name = time.strftime(raw_file_format.format(server=server), current_time).lower()
-    return os.path.join(cloudbot.log_dir, "raw", folder_name, file_name)
+    return os.path.join(cloudbot.logging_dir, "raw", folder_name, file_name)
 
 
 def get_raw_log_stream(server):
@@ -192,8 +192,8 @@ def get_raw_log_stream(server):
             log_stream.flush()
             log_stream.close()
 
-        log_dir = os.path.dirname(new_filename)
-        os.makedirs(log_dir, exist_ok=True)
+        logging_dir = os.path.dirname(new_filename)
+        os.makedirs(logging_dir, exist_ok=True)
 
         log_stream = codecs.open(new_filename, mode="a", encoding="utf-8", buffering=1)
         stream_cache[server] = (new_filename, log_stream)

plugins/regex_chans.py

@@ -59,9 +59,9 @@ def sieve_regex(bot, event, _hook):
     if _hook.type == "regex" and event.chan.startswith("#") and _hook.plugin.title != "factoids":
         status = status_cache.get((event.conn.name, event.chan))
         if status != "ENABLED" and (status == "DISABLED" or not default_enabled):
-            bot.logger.info("[{}] Denying {} from {}".format(event.conn.readable_name, _hook.function_name, event.chan))
+            bot.logger.info("[{}] Denying {} from {}".format(event.conn.name, _hook.function_name, event.chan))
             return None
-        bot.logger.info("[{}] Allowing {} to {}".format(event.conn.readable_name, _hook.function_name, event.chan))
+        bot.logger.info("[{}] Allowing {} to {}".format(event.conn.name, _hook.function_name, event.chan))
 
     return event