fix pep 8

Author: BobDotCom

.gitignore

@@ -139,4 +139,5 @@ cython_debug/
 
 # Custom
 storage/
-.vscode/
+.vscode/
+.history/

bot.py

@@ -3,13 +3,16 @@
 ~~~~~~~~~~~~~~~~~~
 This file contains elements that are under the following licenses:
 Copyright (c) 2015 Rapptz
-license MIT, see https://github.com/Rapptz/RoboDanny/blob/e1c3c28fe20eb192463f7fc224a399141f0d915d/LICENSE.txt for more details.
+license MIT, see
+https://github.com/Rapptz/RoboDanny/blob/e1c3c28fe20eb192463f7fc224a399141f0d915d/LICENSE.txt
+for more details.
 """
 
 import discord
 import time
 import asyncio
 import re
+import asyncpg
 import os
 import url_parser
 import inspect
@@ -22,45 +25,50 @@ async def filter_links(bot, message):
         return
     if message.author.permissions_in(message.channel).manage_messages:
         return
-    regex = r'http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*(),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+'
+    regex = (r'http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*(),]|'
+             r'(?:%[0-9a-fA-F][0-9a-fA-F]))+')
 
     matches = re.findall(regex, message.content, re.MULTILINE)
     urls = []
     for link in matches:
         try:
-            urls = [] #[url_parser.get_url(link)] #[''.join(url_parser.get_base_url(str(link)).split('//')[1:])]
+            urls = []
             async with bot.http._HTTPClient__session.get(link) as resp:
                 urls.append(url_parser.get_url(link)._asdict())
                 for redirect in resp.history:
-                    urls.append(url_parser.get_url(redirect.real_url)._asdict())
-                #str(''.join(url_parser.get_base_url(str(resp.real_url)).split('//')[1:])))
+                    urls.append(
+                        url_parser.get_url(redirect.real_url)._asdict())
             for url in urls:
-                for blocked in [ # "*" means any
-                    # [http[s]://][sub.]<name>.<domain>[/path]                      # Reason
-                    ########################################################################
-                    
-                    '*.grabify.link/*',                                             # Ip Grabber
-                    '*.pornhub.com/*',                                              # Porn
+                for blocked in [  # "*" means any
+                    # [http[s]://][sub.]<name>.<domain>[/path]         # Reason
+                    ###########################################################
+
+                    '*.grabify.link/*',                            # Ip Grabber
+                    '*.pornhub.com/*',                                   # Porn
                 ]:
-                    parsed_blocked = url_parser.get_url(blocked.replace('*','-'))._asdict()
+                    parsed_blocked = url_parser.get_url(
+                        blocked.replace('*', '-'))._asdict()
                     for k, v in parsed_blocked.items():
-                        if k in ['protocol', 'www', 'dir', 'file', 'fragment', 'query']:
+                        if k in ['protocol', 'www', 'dir', 'file', 'fragment',
+                                 'query']:
                             continue
                         if v == url[k]:
                             continue
                         if isinstance(v, str):
-                            if v.replace('.','') == '-':
+                            if v.replace('.', '') == '-':
                                 continue
                             if k == 'path':
                                 if v[1:] == '-':
                                     continue
-                        return 
+                        return
                     await message.delete()
-                    await message.channel.send(f':warning: {message.author.mention} That link is not allowed :warning:', delete_after=15)
+                    await message.channel.send((
+                        f':warning: {message.author.mention} That link is not '
+                        'allowed :warning:'), delete_after=15)
                     return
         except Exception as e:
             print(e)
-            
+
 
 async def filter_invite(bot, message, content=None):
     if message.author.permissions_in(message.channel).manage_messages:
@@ -70,34 +78,40 @@ async def filter_invite(bot, message, content=None):
         801641781028454420
     ]:
         return
-    pattern = r"discord(?:(?:(?:app)?\.com)\/invite|\.gg)/([a-zA-z0-9\-]{2,})(?!\S)"
-    matches = re.findall(pattern,message.content, re.MULTILINE)
+    pattern = (
+        r'discord(?:(?:(?:app)?\.com)\/invite|\.gg)/([a-zA-z0-9\-]{2,})(?!\S)')
+    matches = re.findall(pattern, message.content, re.MULTILINE)
     if len(matches) > 5:
         await message.delete()
-        await message.channel.send(f':warning: {message.author.mention} Invite links are not allowed :warning:', delete_after=15)
+        await message.channel.send((
+            f':warning: {message.author.mention} Invite links are not allowed '
+            ':warning:'), delete_after=15)
         return True
     for code in matches:
         try:
             invite = await bot.fetch_invite(code)
         except discord.errors.NotFound:
-            invite = None # invite is fine
+            invite = None  # invite is fine
         if invite:
-            if not invite.guild.id in [message.guild.id, 681882711945641997, 782903894468198450]:
+            if invite.guild.id not in [message.guild.id, 681882711945641997,
+                                       782903894468198450]:
                 await message.delete()
-                await message.channel.send(f':warning: {message.author.mention} Invite links are not allowed :warning:', delete_after=15)
+                await message.channel.send((
+                    f':warning: {message.author.mention} Invite links are not '
+                    'allowed :warning:'), delete_after=15)
                 return True
-        
+
 
 class General(commands.Cog):
 
     def __init__(self, bot):
         self.bot = bot
 
-
     @commands.Cog.listener()
     async def on_message_edit(self, before, after):
-        if before.content != after.content: # invoke the command again if it is edited
-            ctx = await self.bot.get_context(after, cls=self.bot.helpers.Context)
+        if before.content != after.content:  # invoke the command again on edit
+            ctx = await self.bot.get_context(after,
+                                             cls=self.bot.helpers.Context)
             await self.bot.invoke(ctx)
         if after.guild:
             if after.guild.id == 681882711945641997:
@@ -112,7 +126,7 @@ async def on_message(self, message):
                 invite = await filter_invite(self.bot, message)
                 if not invite:
                     await filter_links(self.bot, message)
-                    
+
     @commands.command(name="source", aliases=["github", "code"])
     @commands.cooldown(1, 1, commands.BucketType.channel)
     async def _source(self, ctx, *, command: str = None):
@@ -135,8 +149,6 @@ async def _source(self, ctx, *, command: str = None):
             if obj is None:
                 return await ctx.send('Could not find command.')
 
-            # since we found the command we're looking for, presumably anyway, let's
-            # try to access the code itself
             src = obj.callback.__code__
             module = obj.callback.__module__
             filename = src.co_filename
@@ -150,67 +162,96 @@ async def _source(self, ctx, *, command: str = None):
             source_url = 'https://github.com/Rapptz/discord.py'
             branch = 'master'
 
-        final_url = f'<{source_url}/blob/{branch}/{location}#L{firstlineno}-L{firstlineno + len(lines) - 1}>'
-        embed = ctx.embed(title='<:githubwhite:804344724621230091> GitHub <:githubwhite:804344724621230091>', description=f'[Click Here]({final_url})')
+        final_url = (f'<{source_url}/blob/{branch}/{location}#L{firstlineno}-L'
+                     f'{firstlineno + len(lines) - 1}>')
+        github = '<:githubwhite:804344724621230091>'
+        embed = ctx.embed(title=f'{github} GitHub {github}',
+                          description=f'[Click Here]({final_url})')
         await ctx.send(embed=embed)
 
-    @commands.command(name="mystbin",aliases=["mb"])
+    @commands.command(name="mystbin", aliases=["mb"])
     @commands.cooldown(1, 1, commands.BucketType.channel)
     async def _mystbin(self, ctx, *, code: codeblock_converter = None):
-        """Send your code to Mystb.in. You may use codeblocks, no codeblocks, or inside a file."""
+        """Send your code to Mystb.in. You may use codeblocks if you want,
+        or use code from inside a file."""
         code = code.content if code else None
         attachments = None
 
         if len(ctx.message.attachments) != 0:
             attachments = ctx.message.attachments
         elif ctx.message.reference:
-            message = await ctx.channel.fetch_message(ctx.message.reference.message_id)
+            message = await ctx.channel.fetch_message(
+                ctx.message.reference.message_id)
             attachments = message.attachments
         if attachments:
             for attachment in attachments:
                 code = await attachment.read()
 
         if not code:
-            return await ctx.send(embed=ctx.error('Please either provide code in the command, attach a file, or react to a message that contains a file.'))
-        async with self.bot.http._HTTPClient__session.post('https://mystb.in/documents', data=code) as r:
+            return await ctx.send(embed=ctx.error((
+                'Please either provide code in the command, attach a file, or '
+                'react to a message that contains a file.')))
+        async with self.bot.http._HTTPClient__session.post(
+                'https://mystb.in/documents', data=code) as r:
             res = await r.json()
             key = res["key"]
-        embed = ctx.embed(title="Mystb.in Link", description='I pasted your code into a bin, click on the title access it!', url=f'https://mystb.in/{key}').set_thumbnail(url='https://cdn.discordapp.com/avatars/569566608817782824/14f120e096fb515d770eea38f9cddd88.png')
+        embed = ctx.embed(title="Mystb.in Link", description=(
+            'I pasted your code into a bin, click on the title access it!'),
+                          url=f'https://mystb.in/{key}')
+        embed.set_thumbnail(url=(
+            'https://cdn.discordapp.com/avatars/569566608817782824/'
+            '14f120e096fb515d770eea38f9cddd88.png'))
         await ctx.send(embed=embed)
 
     @commands.command(name='ping')
     async def _ping(self, ctx):
-        embed = ctx.embed(title='PONG!  :ping_pong:',description=f'**<a:DiscordSpin:795546311319355393> Websocket:** {(self.bot.latency * 1000):.2f}ms\n**:repeat: Round-Trip:** Calculating...\n**:elephant: Database:** Calculating...')
+        loading = '<a:DiscordSpin:795546311319355393>'
+        embed = ctx.embed(title='PONG!  :ping_pong:', description=(
+            f'**<{loading} Websocket:** {(self.bot.latency * 1000):.2f}ms\n**'
+            ':repeat: Round-Trip:** Calculating...\n**:elephant: Database:** '
+            'Calculating...'))
         start = time.perf_counter()
         message = await ctx.send(embed=embed)
         await asyncio.sleep(0.5)
         end = time.perf_counter()
         trip = end - start
-        embed.description = f'**<a:DiscordSpin:795546311319355393> Websocket:** {(self.bot.latency * 1000):.2f}ms\n**:repeat: Round-Trip:** {(trip * 1000):.2f}ms\n**:elephant: Database:** Calcuating...'
+        embed.description = (
+            f'**{loading} Websocket:** {(self.bot.latency * 1000):.2f}ms\n**'
+            f':repeat: Round-Trip:** {(trip * 1000):.2f}ms\n**:elephant: '
+            'Database:** Calculating...')
         await message.edit(embed=embed)
         await asyncio.sleep(0.5)
         start = time.perf_counter()
         try:
             async with self.bot.pools.config.acquire() as connection:
-                await connection.fetchval('SELECT prefixes FROM serverconf WHERE id = 0')
+                await connection.fetchval(
+                    'SELECT prefixes FROM serverconf WHERE id = 0')
             end = time.perf_counter()
             database = end - start
-            embed.description = f'**<a:DiscordSpin:795546311319355393> Websocket:** {(self.bot.latency * 1000):.2f}ms\n**:repeat: Round-Trip:** {(trip * 1000):.2f}ms\n**:elephant: Database:** {(database * 1000):.2f}ms'
-        except:
-            embed.description = f'**<a:DiscordSpin:795546311319355393> Websocket:** {(self.bot.latency * 1000):.2f}ms\n**:repeat: Round-Trip:** {(trip * 1000):.2f}ms\n**:elephant: Database:** *Did not respond!*'
+            embed.description = (
+                f'**{loading} Websocket:** {(self.bot.latency * 1000):.2f}ms\n'
+                f'**:repeat: Round-Trip:** {(trip * 1000):.2f}ms\n**:elephant:'
+                f' Database:** {(database * 1000):.2f}ms')
+        except asyncpg.exceptions._base.InterfaceError:
+            embed.description = (
+                f'**<{loading} Websocket:** {(self.bot.latency * 1000):.2f}ms'
+                f'\n**:repeat: Round-Trip:** {(trip * 1000):.2f}ms\n**'
+                ':elephant: Database:** *Did not respond!*')
         await message.edit(embed=embed)
-        
-    @commands.command(name='revive', aliases=['revivechat', 'chatrevive', 'revchat', 'chatrev'])
+
+    @commands.command(name='revive', aliases=['revivechat', 'chatrevive',
+                                              'revchat', 'chatrev'])
     @commands.guild_only()
     @commands.cooldown(1, 1800, commands.BucketType.guild)
-    @commands.has_any_role(729530191109554237, 795136568805294097, 725899526350831616)
+    @commands.has_any_role(729530191109554237, 795136568805294097,
+                           725899526350831616)  # Senior Mod +
     async def _revive(self, ctx):
-        try:
-            mention = ctx.guild.get_role(759219083639783448).mention
-        except:
-            mention = f'<@&759219083639783448>'
-        embed = ctx.embed(title='Revive Chat Ping!', description='Come back to chat and make it alive again!')
+        mention = ctx.guild.get_role(759219083639783448).mention
+        embed = ctx.embed(
+            title='Revive Chat Ping!',
+            description='Come back to chat and make it alive again!')
         await ctx.send(content=mention, embed=embed)
 
+
 def setup(bot):
     bot.add_cog(General(bot))

cogs/config.py

@@ -7,6 +7,7 @@
 from discord.ext import commands
 from jishaku.codeblocks import codeblock_converter
 
+
 class Owner(commands.Cog):
 
     def __init__(self, bot):
@@ -17,42 +18,59 @@ async def _eval(self, ctx, *, code: codeblock_converter):
         """Eval some code"""
         cog = self.bot.get_cog("Jishaku")
         await cog.jsk_python(ctx, argument=code)
-        
+
     @commands.command(name='refresh')
     async def _refresh(self, ctx):
         """Refresh the bot by invoking `jsk git pull` and `restart`"""
         cog = self.bot.get_cog("Jishaku")
         await cog.jsk_git(ctx, argument=codeblock_converter('pull'))
-        await asyncio.sleep(2) # allow jsk git pull to finish before restarting
+        await asyncio.sleep(2)  # allow jsk git pull to finish
         restart = self.bot.get_command('restart')
         await ctx.invoke(restart)
 
     @commands.command(name='restart')
     async def _restart(self, ctx, flag=None):
         """
-        Restart the bot. Will wait for any running commands to stop. Use --force to ignore any running commands and proceed with the restart
+        Restart the bot. Will wait for any running commands to stop (if
+         --force is not used).
         """
         if not (flag == '--force' or flag == '-f'):
             if self.bot.processing_commands > 1:
-                embed = discord.Embed(title='Commands in progress...', description=f'Retrying in 30 seconds. Use `{ctx.prefix}restart --force` to force restart.', timestamp=ctx.message.created_at)
-                embed.set_footer(text=f'{self.bot.processing_commands - 1} commands currently in progess')
+                embed = discord.Embed(
+                    title='Commands in progress...',
+                    description=(f'Retrying in 30 seconds. Use `{ctx.prefix}'
+                                 'restart --force` to force restart.'),
+                    timestamp=ctx.message.created_at)
+                embed.set_footer(text=(f'{self.bot.processing_commands - 1} '
+                                       'commands currently in progess'))
                 await ctx.send(embed=embed)
                 for i in range(10):
                     await asyncio.sleep(30)
                     if self.bot.processing_commands > 1:
-                        embed = discord.Embed(title='Commands in progress...', description=f'Retrying in 30 seconds. Use `{ctx.prefix}restart --force` to force restart.', timestamp=ctx.message.created_at)
-                        embed.set_footer(text=f'{self.bot.processing_commands - 1} commands currently in progess')
+                        embed = discord.Embed(
+                            title='Commands in progress...',
+                            description=('Retrying in 30 seconds. Use `'
+                                         f'{ctx.prefix}restart --force` to '
+                                         'force restart.'),
+                            timestamp=ctx.message.created_at)
+                        embed.set_footer(
+                            text=(f'{self.bot.processing_commands - 1} '
+                                  'commands currently in progess')
+                        )
                         await ctx.send(embed=embed)
                     else:
                         break
                 if self.bot.processing_commands > 1:
-                    embed = discord.Embed(title='Restart Failed', description=f'{self.bot.processing_commands - 1} commands currently in progess. Use `{ctx.prefix}restart --force` to force restart.', timestamp=ctx.message.created_at)
+                    embed = discord.Embed(title='Restart Failed', description=(
+                        f'{self.bot.processing_commands - 1} commands '
+                        f'currently in progess. Use `{ctx.prefix}restart '
+                        '--force` to force restart.'),
+                                          timestamp=ctx.message.created_at)
                     return await ctx.send(embed=embed)
         embed = discord.Embed(title="Be right back!")
         await ctx.send(embed=embed)
         self.bot.helpers.storage(self.bot, 'restart_channel', ctx.channel.id)
-        if sys.stdin.isatty(): # if the bot was run from the command line instead of from systemctl
-            # os.execv('sudo python', sys.argv) os.path.abspath(__file__)
+        if sys.stdin.isatty():  # if the bot was run from the command line
             try:
                 p = psutil.Process(os.getpid())
                 for handler in p.open_files() + p.connections():
@@ -65,18 +83,28 @@ async def _restart(self, ctx, flag=None):
         embed = ctx.error('Failed to restart')
         await ctx.send(embed=embed)
 
-    @commands.command(name='shutdown',aliases=['off','die','shut','kill'])
+    @commands.command(name='shutdown', aliases=['off', 'die', 'shut', 'kill'])
     async def _shutdown(self, ctx, flag=None):
         if flag == '--wait' or flag == '-w':
             if self.bot.processing_commands > 1:
-                embed = discord.Embed(title='Commands in progress...', description=f'Retrying in 30 seconds.', timestamp=ctx.message.created_at)
-                embed.set_footer(text=f'{self.bot.processing_commands - 1} commands currently in progess')
+                embed = discord.Embed(title='Commands in progress...',
+                                      description='Retrying in 30 seconds.',
+                                      timestamp=ctx.message.created_at)
+                embed.set_footer(text=(
+                    f'{self.bot.processing_commands - 1} commands currently '
+                    'in progess'))
                 await ctx.send(embed=embed)
                 for i in range(10):
                     await asyncio.sleep(30)
                     if self.bot.processing_commands > 1:
-                        embed = discord.Embed(title='Commands in progress...', description=f'Retrying in 30 seconds.', timestamp=ctx.message.created_at)
-                        embed.set_footer(text=f'{self.bot.processing_commands - 1} commands currently in progess')
+                        embed = discord.Embed(
+                            title='Commands in progress...',
+                            description='Retrying in 30 seconds.',
+                            timestamp=ctx.message.created_at
+                        )
+                        embed.set_footer(
+                            text=(f'{self.bot.processing_commands - 1} '
+                                  'commands currently in progess'))
                         await ctx.send(embed=embed)
                     else:
                         break
@@ -85,27 +113,40 @@ async def _shutdown(self, ctx, flag=None):
             await self.bot.logout()
         else:
             if len(sys.argv) > 1:
-                os.system(f"sudo {'stoprewrite' if sys.argv[1] == 'rewrite' else 'stopmain'}")
+                if sys.argv[1] == 'rewrite':
+                    query = 'stoprewrite'
+                else:
+                    query = 'stopmain'
+                os.system(f"sudo {query}")
             await asyncio.sleep(1)
-            await ctx.send(embed=ctx.error('Failed to stop systemd service, attempting to shut down both services'))
-            os.system(f'sudo stopall')
+            await ctx.send(embed=ctx.error((
+                'Failed to stop systemd service, attempting to shut down both '
+                'services'
+            )))
+            os.system('sudo stopall')
             await asyncio.sleep(1)
-            await ctx.send(embed=ctx.error('Failed to stop systemd service, attempting to logout normally'))
+            await ctx.send(embed=ctx.error((
+                'Failed to stop systemd service, attempting to logout normally'
+            )))
             await self.bot.logout()
 
     @commands.command(name='disable')
     async def _disable(self, ctx, toggle: bool = None):
         """
-        Disable the bot in case of an exploit, major bug, or other emergency. The bot will remain online, but only bot owners will be able to run commands on it
+        Disable the bot in case of an exploit, major bug, or other emergency.
+        The bot will remain online, but only bot owners will be able to run
+        commands on it.
         """
         self.bot.disabled = not self.bot.disabled if toggle is None else toggle
         embed = ctx.embed(title='Bot Status', timestamp=ctx.message.created_at)
-        embed.add_field(name='Disabled',value=self.bot.disabled)
-        self.bot.helpers.storage(self.bot, key='disabled', value=self.bot.disabled)
+        embed.add_field(name='Disabled', value=self.bot.disabled)
+        self.bot.helpers.storage(self.bot, key='disabled',
+                                 value=self.bot.disabled)
         await ctx.send(embed=embed)
 
     async def cog_check(self, ctx):
         return ctx.author.id in self.bot.owner_ids
 
+
 def setup(bot):
     bot.add_cog(Owner(bot))

cogs/general.py

@@ -5,16 +5,13 @@
 import datetime
 import asyncpg
 import asyncio
-import discord
-import inspect
 from discord.ext import commands
-from discord_slash import SlashContext as SlashCtx
 
 
 class Bot(commands.Bot):
 
     async def logout(self, *args, **kwargs):
-        if hasattr(self.pools,'config'):
+        if hasattr(self.pools, 'config'):
             try:
                 await asyncio.wait_for(self.pools.config.close(), timeout=5)
             except Exception as e:
@@ -24,40 +21,47 @@ async def logout(self, *args, **kwargs):
                 await asyncio.wait_for(self.sr_api.close(), timeout=5)
             except Exception as e:
                 print(e)
-        if hasattr(self,'wavelink'):
+        if hasattr(self, 'wavelink'):
             if not self.wavelink.session.closed:
-                await asyncio.wait_for(self.wavelink.session.close(), timeout=5)
+                await asyncio.wait_for(self.wavelink.session.close(),
+                                       timeout=5)
         await super().logout(*args, **kwargs)
 
+
 class Embed(discord.Embed):
     def __repr__(self):
         return self.description or ''
 
+
 class Context(commands.Context):
 
     Embed = Embed
 
-    def embed(self, description=None, *args,**kwargs):
+    def embed(self, description=None, *args, **kwargs):
         default = {
             'timestamp': self.message.created_at,
             'description': description
         }
         default.update(kwargs)
-        return_embed = self.Embed(*args,**default)
-        return_embed.set_footer(icon_url=self.author.avatar_url,text=f'Requested by {self.author}')
+        return_embed = self.Embed(*args, **default)
+        return_embed.set_footer(icon_url=self.author.avatar_url,
+                                text=f'Requested by {self.author}')
         return return_embed
 
-    def error(self, description=None, *args,**kwargs):
+    def error(self, description=None, *args, **kwargs):
         default = {
             'title': 'Error',
             'color': discord.Color.red(),
             'timestamp': self.message.created_at,
             'description': description
         }
         default.update(kwargs)
-        return_embed = self.Embed(*args,**default)
-        return_embed.set_author(name=self.author,icon_url=self.author.avatar_url)
-        return_embed.set_footer(icon_url=self.bot.user.avatar_url,text=f'If you think this is a mistake please contact {self.bot.get_user(self.bot.owner_ids[0])}')
+        return_embed = self.Embed(*args, **default)
+        return_embed.set_author(name=self.author,
+                                icon_url=self.author.avatar_url)
+        return_embed.set_footer(icon_url=self.bot.user.avatar_url, text=(
+            'If you think this is a mistake please contact '
+            f'{self.bot.get_user(self.bot.owner_ids[0])}'))
         return return_embed
 
 
@@ -69,44 +73,51 @@ async def init_connection(connection):
         schema='pg_catalog'
     )
 
+
 def storage(bot, key=None, value=None, method=None, override=False):
     try:
-        with open('./storage/config.json','r') as f:
+        with open('./storage/config.json', 'r') as f:
             data = json.load(f)
-    except:
-        with open('./storage/config.json','w+') as f:
+    except OSError:
+        with open('./storage/config.json', 'w+') as f:
             f.write('{}')
-        with open('./storage/config.json','r') as f:
+        with open('./storage/config.json', 'r') as f:
             data = json.load(f)
     data['cogs'] = data.get('cogs', [])
     data['blacklisted'] = data.get('blacklisted', [])
     data['disabled'] = data.get('disabled', False)
-    data['owners'] = data.get('owners', [int(bot.default_owner) if bot.default_owner else 690420846774321221])
+    if bot.default_owner:
+        temp_owner = int(bot.default_owner)
+    else:
+        temp_owner = 690420846774321221
+    data['owners'] = data.get('owners', [temp_owner])
     bot.restart_channel = data.get('restart_channel', None)
     data['restart_channel'] = None
     if key and value:
         if method == 'append':
-            if not value in data[key] or override:
+            if value not in data[key] or override:
                 data[key].append(value)
         elif method == 'remove':
             if value in data[key] or override:
                 data[key].remove(value)
         else:
             data[key] = value
-    with open('./storage/config.json','w') as f:
-        json.dump(data,f,indent=4)
+    with open('./storage/config.json', 'w') as f:
+        json.dump(data, f, indent=4)
     return data
 
+
 async def prepare(bot, guild=None):
     try:
         connection = await bot.pools.config.acquire()
         await bot.pools.config.release(connection)
-    except:
+    except asyncpg.exceptions._base.InterfaceError:
         try:
-            bot.pools.config = await asyncio.wait_for(asyncpg.create_pool(database='codingbot_db', init=init_connection), timeout=5)
+            bot.pools.config = await asyncio.wait_for(asyncpg.create_pool(
+                database='codingbot_db', init=init_connection), timeout=5)
             connection = await bot.pools.config.acquire()
             await bot.pools.config.release(connection)
-        except:
+        except (OSError, asyncpg.exceptions._base.InterfaceError):
             if guild:
                 bot.server_cache[guild.id] = bot.server_cache.get(guild.id, {
                     'prefixes': bot.default_prefixes.copy(),
@@ -122,7 +133,8 @@ async def prepare(bot, guild=None):
                     prefixes text[]
                 );
             ''')
-            data = await connection.fetchrow('SELECT * FROM serverconf WHERE id = $1', guild.id)
+            data = await connection.fetchrow(
+                'SELECT * FROM serverconf WHERE id = $1', guild.id)
             bot.server_cache[guild.id] = bot.server_cache.get(guild.id, {
                 'prefixes': bot.default_prefixes.copy(),
                 'commands': {}
@@ -133,72 +145,87 @@ async def prepare(bot, guild=None):
                 if isinstance(data['commands'], dict):
                     bot.server_cache[guild.id]['commands'] = data['commands']
 
+
 async def is_disabled(ctx):
     if not ctx.guild:
         return False
     try:
         data = ctx.bot.server_cache[ctx.guild.id].copy()
-    except:
+    except KeyError:
         await prepare(ctx.bot, ctx.guild)
         try:
             data = ctx.bot.server_cache[ctx.guild.id].copy()
-        except:
+        except KeyError:
             data = {}
-    ids_to_check = [ctx.guild.id, ctx.channel.id, ctx.author.id] + [r.id for r in ctx.author.roles]
+    ids_to_check = [ctx.guild.id, ctx.channel.id, ctx.author.id]
+    ids_to_check += [r.id for r in ctx.author.roles]
     for id_ in ids_to_check:
         data[int(id_)] = data.get(int(id_), [])
-        if True in data[int(id_)] or ctx.command.qualified_name in data[int(id_)]:
+        if (True in data[int(id_)]
+                or ctx.command.qualified_name in data[int(id_)]):
             return True
     return False
 
+
 async def prefix(bot, message):
     return_prefixes = bot.default_prefixes.copy()
     if not message.guild:
         return_prefixes.append('')
     else:
         try:
             data = bot.server_cache[message.guild.id]['prefixes']
-        except:
+        except KeyError:
             try:
-                bot.server_cache[message.guild.id] = bot.server_cache.get(message.guild.id, {
-                    'prefixes': return_prefixes,
-                    'commands': {}
-                })
+                bot.server_cache[message.guild.id] = bot.server_cache.get(
+                    message.guild.id, {
+                        'prefixes': return_prefixes,
+                        'commands': {}
+                    })
                 bot.loop.create_task(prepare(bot, message.guild))
                 data = bot.server_cache[message.guild.id]['prefixes']
-            except:
+            except KeyError:
                 data = bot.default_prefixes
         return_prefixes = data or return_prefixes
     return return_prefixes
 
 
-async def log_command_error(ctx,error,handled):
+async def log_command_error(ctx, error, handled):
     if not handled:
         channel = ctx.bot.get_channel(787461422896513104)
     else:
         channel = ctx.bot.get_channel(787476834689744926)
     title = 'Ignoring exception in command {}:'.format(ctx.command)
-    err = ''.join(traceback.format_exception(type(error), error, error.__traceback__))
+    err = ''.join(traceback.format_exception(
+        type(error), error, error.__traceback__))
     try:
-        embed = discord.Embed(title=title,description=f'```py\n{err}```',timestamp=ctx.message.created_at,color=discord.Color.red()).set_author(name=ctx.author,icon_url=ctx.author.avatar_url)
+        embed = discord.Embed(title=title, description=f'```py\n{err}```',
+                              timestamp=ctx.message.created_at,
+                              color=discord.Color.red())
+        embed.set_author(name=ctx.author, icon_url=ctx.author.avatar_url)
         await channel.send(embed=embed)
-    except:
+    except discord.errors.Forbidden:
         try:
-            await channel.send(f"**<@{ctx.bot.owner_ids[0]}> An error occurred but I couldn't log it here**")
-        except:
+            await channel.send((f"**<@{ctx.bot.owner_ids[0]}> An error "
+                                "occurred but I couldn't log it here**"))
+        except discord.errors.Forbidden:
             pass
-        print('Ignoring exception in command {}:'.format(ctx.command), file=sys.stderr)
-        traceback.print_exception(type(error), error, error.__traceback__, file=sys.stderr)
+        print('Ignoring exception in command {}:'.format(ctx.command),
+              file=sys.stderr)
+        traceback.print_exception(type(error), error, error.__traceback__,
+                                  file=sys.stderr)
     finally:
         return
 
+
 async def log_error(bot, event_method, *args, **kwargs):
     channel = bot.get_channel(812359854890156073)
     try:
         title = 'Ignoring exception in {}'.format(event_method)
         err = ''.join(traceback.format_exc())
-        embed = discord.Embed(title=title,description=f'```py\n{err}```',timestamp=datetime.datetime.utcnow(),color=discord.Color.red())
+        embed = discord.Embed(title=title, description=f'```py\n{err}```',
+                              timestamp=datetime.datetime.utcnow(),
+                              color=discord.Color.red())
         await channel.send(embed=embed)
-    except:
+    except discord.errors.Forbidden:
         print('Ignoring exception in {}'.format(event_method), file=sys.stderr)
         traceback.print_exc()

cogs/help.py

@@ -9,4 +9,5 @@ DiscordUtils
 pytest
 aiosqlite_pool.zip
 time-str
-discord-flags
+discord-flags
+url-parser

cogs/owner.py

@@ -1,5 +1,5 @@
-import pytest
 import bot
 
+
 def test(token):
     bot.bot.run(token)