Merge remote-tracking branch 'origin/remodulationatizationing' into development

src/__main__.py

@@ -0,0 +1,103 @@
+# !/usr/bin/python
+# -*- coding: utf8 -*-
+"""
+App entry point.
+
+Something meaningful here, eventually.
+"""
+import asyncio
+import json
+import logging
+import random
+import traceback
+
+import discord
+from discord.ext import commands
+
+from src.config.config import LoadConfig
+from src.shared_libs.loggable import Loggable
+from src.shared_libs.ioutil import in_here
+
+
+# Init logging to output on INFO level to stderr.
+logging.basicConfig(level='INFO')        
+
+
+# If uvloop is installed, change to that eventloop policy as it 
+# is more efficient
+try:
+    import uvloop
+    asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
+    del uvloop
+except BaseException as ex:
+    logging.warning(f'Could not load uvloop. {type(ex).__qualname__}: {ex};',
+                    'reverting to default impl.')
+else:
+    logging.info(f'Using uvloop for asyncio event loop policy.')
+
+
+# Bot Class
+# Might be worth moving this to it's own file? 
+class SebiMachine(commands.Bot, LoadConfig, Loggable):
+    """This discord is dedicated to http://www.discord.gg/GWdhBSp"""
+    def __init__(self):
+        # Initialize and attach config / settings
+        LoadConfig.__init__(self)
+        commands.Bot.__init__(self, command_prefix=self.defaultprefix)
+
+        # Load plugins
+        # Add your cog file name in this list
+        with open(in_here('cogs.txt')) as cog_file:
+            cogs = cog_file.readlines()
+            
+        for cog in cogs:
+            # Could this just be replaced with `strip()`?
+            cog = cog.replace('\n', '')
+            self.load_extension(f'{__name__}.cogs.{cog}')
+            self.logger.info(f'Loaded: {cog}')
+            
+    async def on_ready(self):
+        """On ready function"""
+        self.maintenance and self.logger.warning('MAINTENANCE ACTIVE')
+
+    async def on_command_error(self, ctx, error):
+        """
+        The event triggered when an error is raised while invoking a command.
+        ctx   : Context
+        error : Exception
+        """
+        jokes = ["I\'m a bit tipsy, I took to many screenshots...",
+                 "I am rushing to the 24/7 store to get myself anti-bug spray...",
+                 "Organizing turtle race...",
+                 "There is no better place then 127.0.0.1...",
+                 "Recycling Hex Decimal...",
+                 "No worry, I get fixed :^)...",
+                 "R.I.P, press F for respect...",
+                 "The bug repellent dit not work...",
+                 "You found a bug in the program. Unfortunately the joke did not fit here, better luck next time..."]
+
+        # CommandErrors triggered by other propagating errors tend to get wrapped. This means
+        # if we have a cause, we should probably consider unwrapping that so we get a useful
+        # message.
+        error = error.__cause__ or error
+        tb = traceback.format_exception(type(error), error, error.__traceback__, limit=2, chain=False)
+        tb = ''.join(tb)
+        joke = random.choice(jokes)
+        fmt = f'**`{self.defaultprefix}{ctx.command}`**\n{joke}\n\n**{type(error).__name__}:**:\n```py\n{tb}\n```'
+        simple_fmt = f'**`{self.defaultprefix}{ctx.command}`**\n{joke}\n\n**{type(error).__name__}:**:\n**`{error}`**'
+        
+        # Stops the error handler erroring.
+        try:
+            await ctx.send(fmt)
+        except:
+            traceback.print_exc()
+
+
+if __name__ == '__main__':
+    client = SebiMachine()
+    # Make sure the key stays private.
+    # I am 99% certain this is valid!
+    with open(f'{__name__}/config/PrivateConfig.json') as fp:
+        PrivateConfig = json.load(fp)
+
+    client.run(PrivateConfig["bot-key"])

src/cogs.txt

@@ -0,0 +1,5 @@
+example
+contributors
+code
+git
+fun

src/shared_libs/ioutils.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python3.6
+# -*- coding: utf-8 -*-
+"""
+IO stuff.
+"""
+import inspect
+import os
+
+
+__all__ = ('in_here',)
+
+
+def in_here(first_path_bit: str, *path_bits: str, stack_depth: int=0) -> str:
+    """
+    A somewhat voodooish and weird piece of code. This enables us to
+    directly refer to a file in the same directory as the code that 
+    calls this method, without any due regard for where in the file
+    system tree it is.
+    
+    Apart from that, this will behave just like os.path.join, meaning
+    that varaidic strings will be joined with the appropriate 
+    directory separator for the current platform.
+    
+    This works by inspecting the stack frame for the caller.
+    If you are planning on nesting this call in another utility and wish
+    for the stack to refer to that caller, you should increment 
+    the ``stack_depth`` arg for each nested call you make. By default,
+    you can ignore this and it will default to 0.
+    
+    :param first_path_bit: the initial path bit to operate with. This is 
+        required.
+    :param path_bits: additional bits of path to construct relative to here.
+        These are entirely optional.
+    :param stack_depth: optional, defaults to 0. How many nested calls
+        we expect this to be called in. Affects the relative directory
+        that is used.
+    :returns: the absolute path to the given relative path provided.
+    """    
+    try:
+        frame = inspect.stack()[1 + nested_by]
+    except IndexError:
+        raise RuntimeError('Could not find a stack record. Interpreter has '
+                           'been shot.')
+    else:
+        module = inspect.getmodule(frame[0])
+        assert hasattr(module, '__file__'), 'No `__file__\' attr, welp.'
+
+        file = module.__file__
+
+        dir_name = os.path.dirname(file)
+        abs_dir_name = os.path.abspath(dir_name)
+
+        pathish = os.path.join(abs_dir_name, first_path_bit, *path_bits)
+        return pathish

src/shared_libs/loggable.py

@@ -14,6 +14,9 @@ boast faster lookups.
 import logging
 
 
+__all__ = ('Loggable',)
+
+
 class Loggable:
     __slots__ = ('logger',)