From 335397554f299683a4f3a0e1af27480d76ce6853 Mon Sep 17 00:00:00 2001
From: Romain J <romain.ordi@gmail.com>
Date: Thu, 4 Jun 2020 00:14:50 +0200
Subject: [PATCH] feat(botCore|launcher): add features to the core launcher

---
 .idea/tuxbot-bot-rewrite.iml                  |   2 +
 .idea/workspace.xml                           |   9 +-
 README.md                                     |   2 +-
 Tuxbot_bot.egg-info/PKG-INFO                  |  11 +
 Tuxbot_bot.egg-info/SOURCES.txt               |  25 ++
 Tuxbot_bot.egg-info/dependency_links.txt      |   1 +
 Tuxbot_bot.egg-info/entry_points.txt          |   4 +
 Tuxbot_bot.egg-info/requires.txt              |  29 ++
 Tuxbot_bot.egg-info/top_level.txt             |   1 +
 build/lib/tuxbot/__init__.py                  |  14 +
 build/lib/tuxbot/__main__.py                  | 139 ++++++++
 build/lib/tuxbot/cogs/images/__init__.py      |   5 +
 build/lib/tuxbot/cogs/images/images.py        | 175 ++++++++++
 build/lib/tuxbot/cogs/logs/__init__.py        |  14 +
 build/lib/tuxbot/cogs/logs/logs.py            | 323 ++++++++++++++++++
 build/lib/tuxbot/cogs/network/__init__.py     |   5 +
 build/lib/tuxbot/cogs/network/network.py      | 105 ++++++
 build/lib/tuxbot/core/__init__.py             |   8 +
 build/lib/tuxbot/core/bot.py                  |  65 ++++
 build/lib/tuxbot/core/config.py               |  41 +++
 build/lib/tuxbot/core/data_manager.py         |  26 ++
 build/lib/tuxbot/core/utils/functions/cli.py  |  89 +++++
 .../lib/tuxbot/core/utils/functions/extra.py  | 114 +++++++
 build/lib/tuxbot/logging.py                   |  39 +++
 build/lib/tuxbot/setup.py                     | 292 ++++++++++++++++
 dist/Tuxbot_bot-3.0.0-py3.8.egg               | Bin 0 -> 44154 bytes
 setup.cfg                                     |   2 +
 tuxbot/__init__.py                            |   6 +-
 tuxbot/__main__.py                            | 118 +++++--
 tuxbot/cogs/network/network.py                |   2 +-
 tuxbot/core/bot.py                            |  30 +-
 tuxbot/logging.py                             | 154 ++-------
 tuxbot/setup.py                               |   4 +-
 33 files changed, 1680 insertions(+), 174 deletions(-)
 create mode 100644 Tuxbot_bot.egg-info/PKG-INFO
 create mode 100644 Tuxbot_bot.egg-info/SOURCES.txt
 create mode 100644 Tuxbot_bot.egg-info/dependency_links.txt
 create mode 100644 Tuxbot_bot.egg-info/entry_points.txt
 create mode 100644 Tuxbot_bot.egg-info/requires.txt
 create mode 100644 Tuxbot_bot.egg-info/top_level.txt
 create mode 100644 build/lib/tuxbot/__init__.py
 create mode 100644 build/lib/tuxbot/__main__.py
 create mode 100644 build/lib/tuxbot/cogs/images/__init__.py
 create mode 100644 build/lib/tuxbot/cogs/images/images.py
 create mode 100644 build/lib/tuxbot/cogs/logs/__init__.py
 create mode 100644 build/lib/tuxbot/cogs/logs/logs.py
 create mode 100644 build/lib/tuxbot/cogs/network/__init__.py
 create mode 100644 build/lib/tuxbot/cogs/network/network.py
 create mode 100644 build/lib/tuxbot/core/__init__.py
 create mode 100644 build/lib/tuxbot/core/bot.py
 create mode 100644 build/lib/tuxbot/core/config.py
 create mode 100644 build/lib/tuxbot/core/data_manager.py
 create mode 100644 build/lib/tuxbot/core/utils/functions/cli.py
 create mode 100644 build/lib/tuxbot/core/utils/functions/extra.py
 create mode 100644 build/lib/tuxbot/logging.py
 create mode 100644 build/lib/tuxbot/setup.py
 create mode 100644 dist/Tuxbot_bot-3.0.0-py3.8.egg

diff --git a/.idea/tuxbot-bot-rewrite.iml b/.idea/tuxbot-bot-rewrite.iml
index 3a04e2e..d728f09 100644
--- a/.idea/tuxbot-bot-rewrite.iml
+++ b/.idea/tuxbot-bot-rewrite.iml
@@ -2,6 +2,8 @@
 <module type="PYTHON_MODULE" version="4">
   <component name="NewModuleRootManager">
     <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/build" />
+      <excludeFolder url="file://$MODULE_DIR$/dist" />
       <excludeFolder url="file://$MODULE_DIR$/venv" />
     </content>
     <orderEntry type="inheritedJdk" />
diff --git a/.idea/workspace.xml b/.idea/workspace.xml
index 6ce748b..22b2f9c 100644
--- a/.idea/workspace.xml
+++ b/.idea/workspace.xml
@@ -2,10 +2,15 @@
 <project version="4">
   <component name="ChangeListManager">
     <list default="true" id="c97c8a30-7573-4dcd-a0d4-5bf94b8ddbbd" name="5ed57ed9960f35191182a924 core" comment="">
+      <change beforePath="$PROJECT_DIR$/.idea/tuxbot-bot-rewrite.iml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/tuxbot-bot-rewrite.iml" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/.idea/workspace.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/workspace.xml" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/README.md" beforeDir="false" afterPath="$PROJECT_DIR$/README.md" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/setup.cfg" beforeDir="false" afterPath="$PROJECT_DIR$/setup.cfg" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/tuxbot/__init__.py" beforeDir="false" afterPath="$PROJECT_DIR$/tuxbot/__init__.py" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/tuxbot/__main__.py" beforeDir="false" afterPath="$PROJECT_DIR$/tuxbot/__main__.py" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/tuxbot/cogs/network/network.py" beforeDir="false" afterPath="$PROJECT_DIR$/tuxbot/cogs/network/network.py" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/tuxbot/core/bot.py" beforeDir="false" afterPath="$PROJECT_DIR$/tuxbot/core/bot.py" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/tuxbot/core/models/__init__.py" beforeDir="false" />
+      <change beforePath="$PROJECT_DIR$/tuxbot/logging.py" beforeDir="false" afterPath="$PROJECT_DIR$/tuxbot/logging.py" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/tuxbot/setup.py" beforeDir="false" afterPath="$PROJECT_DIR$/tuxbot/setup.py" afterDir="false" />
     </list>
     <list id="a3abf5c0-7587-46e4-8f09-88e34a1ab8a4" name="5ed41911b012e33f68a07e7a i18n" comment="" />
@@ -117,7 +122,7 @@
       <workItem from="1591049956280" duration="4910000" />
       <workItem from="1591054878071" duration="1039000" />
       <workItem from="1591088657371" duration="4107000" />
-      <workItem from="1591128560850" duration="29106000" />
+      <workItem from="1591128560850" duration="38137000" />
     </task>
     <option name="localTasksCounter" value="2" />
     <option name="createBranch" value="false" />
diff --git a/README.md b/README.md
index eca9d54..79e302a 100644
--- a/README.md
+++ b/README.md
@@ -52,7 +52,7 @@ source ~/tuxvenv/bin/activate
 
 Now, you can finish the installation by executing this single command:
 ```shell script
-python setup.py install
+pip install .
 ```
 
 ## Configuration
diff --git a/Tuxbot_bot.egg-info/PKG-INFO b/Tuxbot_bot.egg-info/PKG-INFO
new file mode 100644
index 0000000..c0cdedd
--- /dev/null
+++ b/Tuxbot_bot.egg-info/PKG-INFO
@@ -0,0 +1,11 @@
+Metadata-Version: 1.2
+Name: Tuxbot-bot
+Version: 3.0.0
+Summary: A bot made for GnousEU and OpenSource
+Home-page: https://git.gnous.eu/gnouseu/tuxbot-bot/
+Author: Romain J.
+Author-email: romain@gnous.eu
+License: UNKNOWN
+Description: UNKNOWN
+Platform: UNKNOWN
+Requires-Python: >=3.7
diff --git a/Tuxbot_bot.egg-info/SOURCES.txt b/Tuxbot_bot.egg-info/SOURCES.txt
new file mode 100644
index 0000000..7e560d4
--- /dev/null
+++ b/Tuxbot_bot.egg-info/SOURCES.txt
@@ -0,0 +1,25 @@
+README.md
+setup.cfg
+setup.py
+Tuxbot_bot.egg-info/PKG-INFO
+Tuxbot_bot.egg-info/SOURCES.txt
+Tuxbot_bot.egg-info/dependency_links.txt
+Tuxbot_bot.egg-info/entry_points.txt
+Tuxbot_bot.egg-info/requires.txt
+Tuxbot_bot.egg-info/top_level.txt
+tuxbot/__init__.py
+tuxbot/__main__.py
+tuxbot/logging.py
+tuxbot/setup.py
+tuxbot/cogs/images/__init__.py
+tuxbot/cogs/images/images.py
+tuxbot/cogs/logs/__init__.py
+tuxbot/cogs/logs/logs.py
+tuxbot/cogs/network/__init__.py
+tuxbot/cogs/network/network.py
+tuxbot/core/__init__.py
+tuxbot/core/bot.py
+tuxbot/core/config.py
+tuxbot/core/data_manager.py
+tuxbot/core/utils/functions/cli.py
+tuxbot/core/utils/functions/extra.py
\ No newline at end of file
diff --git a/Tuxbot_bot.egg-info/dependency_links.txt b/Tuxbot_bot.egg-info/dependency_links.txt
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/Tuxbot_bot.egg-info/dependency_links.txt
@@ -0,0 +1 @@
+
diff --git a/Tuxbot_bot.egg-info/entry_points.txt b/Tuxbot_bot.egg-info/entry_points.txt
new file mode 100644
index 0000000..52c933a
--- /dev/null
+++ b/Tuxbot_bot.egg-info/entry_points.txt
@@ -0,0 +1,4 @@
+[console_scripts]
+tuxbot = tuxbot.__main__:main
+tuxbot-setup = tuxbot.setup:setup
+
diff --git a/Tuxbot_bot.egg-info/requires.txt b/Tuxbot_bot.egg-info/requires.txt
new file mode 100644
index 0000000..78de599
--- /dev/null
+++ b/Tuxbot_bot.egg-info/requires.txt
@@ -0,0 +1,29 @@
+aiohttp==3.6.2
+aiosqlite==0.13.0
+async-timeout==3.0.1
+asyncpg==0.20.1
+attrs==19.3.0
+cachetools==4.1.0
+certifi==2020.4.5.1
+chardet==3.0.4
+ciso8601==2.1.3
+colorama==0.4.3
+discord-flags==2.1.1
+discord.py==1.3.3
+dnspython==1.16.0
+humanize==2.4.0
+idna==2.9
+ipinfo==3.0.0
+ipwhois==1.1.0
+iso8601==0.1.12
+multidict==4.7.6
+psutil==5.7.0
+PyPika==0.37.7
+pytz==2020.1
+requests==2.23.0
+six==1.15.0
+tortoise-orm==0.16.13
+typing-extensions==3.7.4.2
+urllib3==1.25.9
+websockets==8.1
+yarl==1.4.2
diff --git a/Tuxbot_bot.egg-info/top_level.txt b/Tuxbot_bot.egg-info/top_level.txt
new file mode 100644
index 0000000..9bd5b31
--- /dev/null
+++ b/Tuxbot_bot.egg-info/top_level.txt
@@ -0,0 +1 @@
+tuxbot
diff --git a/build/lib/tuxbot/__init__.py b/build/lib/tuxbot/__init__.py
new file mode 100644
index 0000000..2f9deab
--- /dev/null
+++ b/build/lib/tuxbot/__init__.py
@@ -0,0 +1,14 @@
+import subprocess
+from collections import namedtuple
+
+build = subprocess.check_output(['git', 'rev-parse', '--short', 'HEAD']) \
+    .decode()
+
+VersionInfo = namedtuple('VersionInfo', 'major minor micro releaselevel build')
+version_info = VersionInfo(
+    major=3, minor=0, micro=0,
+    releaselevel='alpha', build=build
+)
+
+__version__ = "v{}.{}.{}" \
+    .format(version_info.major, version_info.minor, version_info.micro)
\ No newline at end of file
diff --git a/build/lib/tuxbot/__main__.py b/build/lib/tuxbot/__main__.py
new file mode 100644
index 0000000..a989e5b
--- /dev/null
+++ b/build/lib/tuxbot/__main__.py
@@ -0,0 +1,139 @@
+import argparse
+import asyncio
+import logging
+import signal
+import sys
+
+import discord
+from colorama import Fore, init, Style
+
+import tuxbot.logging
+from tuxbot.core import data_manager
+from tuxbot.core.bot import Tux
+
+log = logging.getLogger("tuxbot.main")
+init()
+
+
+def parse_cli_flags(args):
+    parser = argparse.ArgumentParser(
+        description="Tuxbot - OpenSource bot",
+        usage="tuxbot <instance_name> [arguments]"
+    )
+    parser.add_argument("--version", "-V", help="Show tuxbot's used version")
+    parser.add_argument("--list-instances", "-L",
+                        help="List all instance names")
+    parser.add_argument(
+        "instance_name", nargs="?",
+        help="Name of the bot instance created during `redbot-setup`.")
+
+    args = parser.parse_args(args)
+
+    if args.prefix:
+        args.prefix = sorted(args.prefix, reverse=True)
+    else:
+        args.prefix = []
+
+    return args
+
+
+async def shutdown_handler(tux, signal_type, exit_code=None):
+    if signal_type:
+        log.info("%s received. Quitting...", signal_type)
+        sys.exit(0)
+    elif exit_code is None:
+        log.info("Shutting down from unhandled exception")
+        tux.shutdown_code = 1
+
+    if exit_code is not None:
+        tux.shutdown_code = exit_code
+
+    try:
+        await tux.logout()
+    finally:
+        pending = [
+            t for t in asyncio.all_tasks() if t is not asyncio.current_task()
+        ]
+
+        for task in pending:
+            task.cancel()
+
+        await asyncio.gather(*pending, return_exceptions=True)
+
+
+async def run_bot(tux: Tux, cli_flags: argparse.Namespace) -> None:
+    data_path = data_manager.get_data_path(tux.instance_name)
+
+    tuxbot.logging.init_logging(
+        level=cli_flags.logging_level,
+        location=data_path / "logs"
+    )
+
+    log.debug("====Basic Config====")
+    log.debug("Data Path: %s", data_path)
+
+    if cli_flags.token:
+        token = cli_flags.token
+    else:
+        token = await tux.config.token()
+
+    if not token:
+        log.critical("Token must be set if you want to login.")
+        sys.exit(1)
+
+    try:
+        await tux.start(token, bot=True, cli_flags=cli_flags)
+    except discord.LoginFailure:
+        log.critical("This token appears to be valid.")
+        sys.exit(1)
+
+    return None
+
+
+def main():
+    tux = None
+    cli_flags = parse_cli_flags(sys.argv[1:])
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+
+    try:
+        if cli_flags.no_instance:
+            print(Fore.RED
+                  + "No instance provided ! "
+                    "You can use 'tuxbot -L' to list all available instances"
+                  + Style.RESET_ALL)
+            sys.exit(1)
+
+        tux = Tux(
+            cli_flags=cli_flags,
+            description="Tuxbot, made from and for OpenSource",
+            dm_help=None
+        )
+
+        loop.run_until_complete(run_bot(tux, cli_flags))
+    except KeyboardInterrupt:
+        log.warning("Please use <prefix>quit instead of Ctrl+C to Shutdown!")
+        log.error("Received KeyboardInterrupt")
+        if tux is not None:
+            loop.run_until_complete(shutdown_handler(tux, signal.SIGINT))
+    except SystemExit as exc:
+        log.info("Shutting down with exit code: %s", exc.code)
+        if tux is not None:
+            loop.run_until_complete(shutdown_handler(tux, None, exc.code))
+    except Exception as exc:
+        log.exception("Unexpected exception (%s): ", type(exc), exc_info=exc)
+        if tux is not None:
+            loop.run_until_complete(shutdown_handler(tux, None, 1))
+    finally:
+        loop.run_until_complete(loop.shutdown_asyncgens())
+        log.info("Please wait, cleaning up a bit more")
+        loop.run_until_complete(asyncio.sleep(1))
+        asyncio.set_event_loop(None)
+        loop.stop()
+        loop.close()
+        exit_code = 1 if tux is None else tux.shutdown_code
+        sys.exit(exit_code)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/build/lib/tuxbot/cogs/images/__init__.py b/build/lib/tuxbot/cogs/images/__init__.py
new file mode 100644
index 0000000..516710a
--- /dev/null
+++ b/build/lib/tuxbot/cogs/images/__init__.py
@@ -0,0 +1,5 @@
+from .images import Images
+
+
+def setup(bot):
+    bot.add_cog(Images(bot))
diff --git a/build/lib/tuxbot/cogs/images/images.py b/build/lib/tuxbot/cogs/images/images.py
new file mode 100644
index 0000000..d1bf8d4
--- /dev/null
+++ b/build/lib/tuxbot/cogs/images/images.py
@@ -0,0 +1,175 @@
+import logging
+from io import BytesIO
+
+import discord
+from discord.ext import commands, flags
+
+from app import TuxBot
+from utils.functions.extra import ContextPlus, command_extra
+
+log = logging.getLogger(__name__)
+
+
+class Images(commands.Cog, name="Images"):
+    def __init__(self, bot):
+        self.bot = bot
+        self.image_api = "http://0.0.0.0:8080"
+
+    async def _send_meme(self, ctx: ContextPlus, endpoint: str, **passed_flags):
+        async with ctx.typing():
+            url = f"{self.image_api}/{endpoint}?"
+            for key, val in passed_flags.items():
+                if val:
+                    url += f"{key}={val}&"
+
+            async with self.bot.session.get(url) as r:
+                if r.status != 200:
+                    return await ctx.send("Failed...")
+
+                data = BytesIO(await r.read())
+
+        await ctx.send(
+            file=discord.File(data, "output.png")
+        )
+
+    @command_extra(name="phcomment")
+    @commands.cooldown(1, 5, commands.BucketType.user)
+    async def _phcomment(self, ctx: ContextPlus, user: discord.User = None, *, message: commands.clean_content(fix_channel_mentions=True, escape_markdown=True)):
+        async with ctx.typing():
+            message = message.replace("&", "%26")
+            if user is None:
+                avatar = ctx.author.avatar_url_as(format='png')
+                username = ctx.author.name
+            else:
+                avatar = user.avatar_url_as(format='png')
+                username = user.name
+
+            url = f"{self.image_api}/ph/comment" \
+                  f"?image={avatar}" \
+                  f"&username={username}" \
+                  f"&message={message}"
+
+            async with self.bot.session.get(url) as r:
+                if r.status != 200:
+                    return await ctx.send("Failed...")
+
+                data = BytesIO(await r.read())
+
+        await ctx.send(
+            file=discord.File(data, "output.png")
+        )
+
+    @command_extra(name="phvideo")
+    @commands.cooldown(1, 5, commands.BucketType.user)
+    async def _phvideo(self, ctx: ContextPlus, image: str, author: discord.User, *, title: commands.clean_content(fix_channel_mentions=True, escape_markdown=True)):
+        async with ctx.typing():
+            url = f"{self.image_api}/ph/video" \
+                  f"?image={image}" \
+                  f"&username={author.name}" \
+                  f"&title={title}"
+
+            async with self.bot.session.get(url) as r:
+                if r.status != 200:
+                    return await ctx.send("Failed...")
+
+                data = BytesIO(await r.read())
+
+        await ctx.send(
+            file=discord.File(data, "output.png")
+        )
+
+    @flags.add_flag("--text1", type=str)
+    @flags.add_flag("--text2", type=str)
+    @flags.add_flag("--text3", type=str)
+    @command_extra(name="balloon")
+    @commands.cooldown(1, 5, commands.BucketType.user)
+    async def _balloon(self, ctx: ContextPlus, **passed_flags):
+        passed_flags["text3"] = passed_flags.get("text3")
+        passed_flags["text4"] = passed_flags.get("text1")
+        passed_flags["text5"] = passed_flags.get("text2")
+
+        await self._send_meme(ctx, 'balloon', **passed_flags)
+
+    @flags.add_flag("--text1", type=str)
+    @flags.add_flag("--text2", type=str)
+    @flags.add_flag("--text3", type=str)
+    @command_extra(name="butterfly")
+    @commands.cooldown(1, 5, commands.BucketType.user)
+    async def _butterfly(self, ctx: ContextPlus, **passed_flags):
+        await self._send_meme(ctx, 'butterfly', **passed_flags)
+
+    @flags.add_flag("--text1", type=str)
+    @flags.add_flag("--text2", type=str)
+    @command_extra(name="buttons")
+    @commands.cooldown(1, 5, commands.BucketType.user)
+    async def _buttons(self, ctx: ContextPlus, **passed_flags):
+        await self._send_meme(ctx, 'buttons', **passed_flags)
+
+    @flags.add_flag("--text1", type=str)
+    @command_extra(name="cmm")
+    @commands.cooldown(1, 5, commands.BucketType.user)
+    async def _cmm(self, ctx: ContextPlus, **passed_flags):
+        await self._send_meme(ctx, 'change_my_mind', **passed_flags)
+
+    @flags.add_flag("--text1", type=str)
+    @flags.add_flag("--text2", type=str)
+    @command_extra(name="drake")
+    @commands.cooldown(1, 5, commands.BucketType.user)
+    async def _drake(self, ctx: ContextPlus, **passed_flags):
+        await self._send_meme(ctx, 'drake', **passed_flags)
+
+    @flags.add_flag("--text1", type=str)
+    @flags.add_flag("--text2", type=str, default=False)
+    @command_extra(name="fry")
+    @commands.cooldown(1, 5, commands.BucketType.user)
+    async def _fry(self, ctx: ContextPlus, **passed_flags):
+        await self._send_meme(ctx, 'fry', **passed_flags)
+
+    @flags.add_flag("--text1", type=str)
+    @flags.add_flag("--text2", type=str, default=False)
+    @command_extra(name="imagination")
+    @commands.cooldown(1, 5, commands.BucketType.user)
+    async def _imagination(self, ctx: ContextPlus, **passed_flags):
+        await self._send_meme(ctx, 'imagination', **passed_flags)
+
+    @flags.add_flag("--text1", type=str)
+    @flags.add_flag("--text2", type=str, default=False)
+    @command_extra(name="everywhere")
+    @commands.cooldown(1, 5, commands.BucketType.user)
+    async def _everywhere(self, ctx: ContextPlus, **passed_flags):
+        await self._send_meme(ctx, 'everywhere', **passed_flags)
+
+    @flags.add_flag("--text1", type=str)
+    @flags.add_flag("--text2", type=str)
+    @flags.add_flag("--text3", type=str)
+    @command_extra(name="choice")
+    @commands.cooldown(1, 5, commands.BucketType.user)
+    async def _choice(self, ctx: ContextPlus, **passed_flags):
+        await self._send_meme(ctx, 'choice', **passed_flags)
+
+    @flags.add_flag("--text1", type=str)
+    @command_extra(name="pika")
+    @commands.cooldown(1, 5, commands.BucketType.user)
+    async def _pika(self, ctx: ContextPlus, **passed_flags):
+        await self._send_meme(ctx, 'pika', **passed_flags)
+
+    @flags.add_flag("--text1", type=str)
+    @flags.add_flag("--text2", type=str)
+    @flags.add_flag("--text3", type=str)
+    @command_extra(name="pkp")
+    @commands.cooldown(1, 5, commands.BucketType.user)
+    async def _pkp(self, ctx: ContextPlus, **passed_flags):
+        await self._send_meme(ctx, 'pkp', **passed_flags)
+
+    @flags.add_flag("--text1", type=str)
+    @flags.add_flag("--text2", type=str)
+    @command_extra(name="puppet")
+    @commands.cooldown(1, 5, commands.BucketType.user)
+    async def _puppet(self, ctx: ContextPlus, **passed_flags):
+        await self._send_meme(ctx, 'puppet', **passed_flags)
+
+    @flags.add_flag("--text1", type=str)
+    @command_extra(name="scroll_of_truth", alias=['sot'])
+    @commands.cooldown(1, 5, commands.BucketType.user)
+    async def _sot(self, ctx: ContextPlus, **passed_flags):
+        await self._send_meme(ctx, 'scroll_of_truth', **passed_flags)
diff --git a/build/lib/tuxbot/cogs/logs/__init__.py b/build/lib/tuxbot/cogs/logs/__init__.py
new file mode 100644
index 0000000..733b020
--- /dev/null
+++ b/build/lib/tuxbot/cogs/logs/__init__.py
@@ -0,0 +1,14 @@
+import logging
+
+from discord.ext import commands
+
+from .logs import Logs, GatewayHandler, on_error
+
+
+def setup(bot):
+    cog = Logs(bot)
+    bot.add_cog(cog)
+
+    handler = GatewayHandler(cog)
+    logging.getLogger().addHandler(handler)
+    commands.AutoShardedBot.on_error = on_error
diff --git a/build/lib/tuxbot/cogs/logs/logs.py b/build/lib/tuxbot/cogs/logs/logs.py
new file mode 100644
index 0000000..7981168
--- /dev/null
+++ b/build/lib/tuxbot/cogs/logs/logs.py
@@ -0,0 +1,323 @@
+"""
+
+Based on https://github.com/Rapptz/RoboDanny/blob/3d94e89ef27f702a5f57f432a9131bdfb60bb3ec/cogs/stats.py
+Adapted by Romain J.
+
+"""
+
+import asyncio
+import datetime
+import json
+import logging
+import textwrap
+import traceback
+from collections import defaultdict
+
+import discord
+import humanize
+import psutil
+from discord.ext import commands, tasks
+
+from app import TuxBot
+from utils.functions.extra import command_extra
+
+log = logging.getLogger(__name__)
+
+
+class GatewayHandler(logging.Handler):
+    def __init__(self, cog):
+        self.cog = cog
+        super().__init__(logging.INFO)
+
+    def filter(self, record):
+        return record.name == 'discord.gateway' \
+               or 'Shard ID' in record.msg \
+               or 'Websocket closed ' in record.msg
+
+    def emit(self, record):
+        self.cog.add_record(record)
+
+
+class Logs(commands.Cog):
+
+    def __init__(self, bot: TuxBot):
+        self.bot = bot
+        self.process = psutil.Process()
+        self._batch_lock = asyncio.Lock(loop=bot.loop)
+        self._data_batch = []
+        self._gateway_queue = asyncio.Queue(loop=bot.loop)
+        self.gateway_worker.start()
+
+        self._resumes = []
+        self._identifies = defaultdict(list)
+
+    def _clear_gateway_data(self):
+        one_week_ago = datetime.datetime.utcnow() - datetime.timedelta(days=7)
+        to_remove = [
+            index for index, dt in enumerate(self._resumes)
+            if dt < one_week_ago
+        ]
+        for index in reversed(to_remove):
+            del self._resumes[index]
+
+        for shard_id, dates in self._identifies.items():
+            to_remove = [index for index, dt in enumerate(dates) if
+                         dt < one_week_ago]
+            for index in reversed(to_remove):
+                del dates[index]
+
+    @tasks.loop(seconds=0.0)
+    async def gateway_worker(self):
+        record = await self._gateway_queue.get()
+        await self.notify_gateway_status(record)
+
+    async def register_command(self, ctx):
+        if ctx.command is None:
+            return
+
+        command = ctx.command.qualified_name
+        self.bot.command_stats[command] += 1
+        message = ctx.message
+        if ctx.guild is None:
+            destination = 'Private Message'
+            guild_id = None
+        else:
+            destination = f'#{message.channel} ({message.guild})'
+            guild_id = ctx.guild.id
+
+        log.info(
+            f'{message.created_at}: {message.author} '
+            f'in {destination}: {message.content}')
+        async with self._batch_lock:
+            self._data_batch.append({
+                'guild': guild_id,
+                'channel': ctx.channel.id,
+                'author': ctx.author.id,
+                'used': message.created_at.isoformat(),
+                'prefix': ctx.prefix,
+                'command': command,
+                'failed': ctx.command_failed,
+            })
+
+    @commands.Cog.listener()
+    async def on_command_completion(self, ctx):
+        await self.register_command(ctx)
+
+    @commands.Cog.listener()
+    async def on_socket_response(self, msg):
+        self.bot.socket_stats[msg.get('t')] += 1
+
+    @property
+    def logs(self):
+        webhooks = {}
+
+        for key, value in self.bot.logs_channels.items():
+            webhooks[key] = discord.Webhook.partial(
+                id=value.get('webhook')['id'],
+                token=value.get('webhook')['token'],
+                adapter=discord.AsyncWebhookAdapter(
+                    self.bot.session
+                )
+            )
+
+        return webhooks
+
+    async def log_error(self, *, ctx=None, extra=None):
+        e = discord.Embed(title='Error', colour=0xdd5f53)
+        e.description = f'```py\n{traceback.format_exc()}\n```'
+        e.add_field(name='Extra', value=extra, inline=False)
+        e.timestamp = datetime.datetime.utcnow()
+
+        if ctx is not None:
+            fmt = '{0} (ID: {0.id})'
+            author = fmt.format(ctx.author)
+            channel = fmt.format(ctx.channel)
+            guild = 'None' if ctx.guild is None else fmt.format(ctx.guild)
+
+            e.add_field(name='Author', value=author)
+            e.add_field(name='Channel', value=channel)
+            e.add_field(name='Guild', value=guild)
+
+        await self.logs.get('errors').send(embed=e)
+
+    async def send_guild_stats(self, e, guild):
+        e.add_field(name='Name', value=guild.name)
+        e.add_field(name='ID', value=guild.id)
+        e.add_field(name='Shard ID', value=guild.shard_id or 'N/A')
+        e.add_field(name='Owner',
+                    value=f'{guild.owner} (ID: {guild.owner.id})')
+
+        bots = sum(member.bot for member in guild.members)
+        total = guild.member_count
+        online = sum(member.status is discord.Status.online
+                     for member in guild.members)
+
+        e.add_field(name='Members', value=str(total))
+        e.add_field(name='Bots', value=f'{bots} ({bots / total:.2%})')
+        e.add_field(name='Online', value=f'{online} ({online / total:.2%})')
+
+        if guild.icon:
+            e.set_thumbnail(url=guild.icon_url)
+
+        if guild.me:
+            e.timestamp = guild.me.joined_at
+
+        await self.logs.get('guilds').send(embed=e)
+
+    @commands.Cog.listener()
+    async def on_guild_join(self, guild: discord.guild):
+        e = discord.Embed(colour=0x53dda4, title='New Guild')  # green colour
+        await self.send_guild_stats(e, guild)
+
+    @commands.Cog.listener()
+    async def on_guild_remove(self, guild: discord.guild):
+        e = discord.Embed(colour=0xdd5f53, title='Left Guild')  # red colour
+        await self.send_guild_stats(e, guild)
+
+    @commands.Cog.listener()
+    async def on_message(self, message: discord.message):
+        ctx = await self.bot.get_context(message)
+        if ctx.valid:
+            return
+
+        if isinstance(message.channel, discord.DMChannel):
+            if message.author is self.bot.user:
+                e = discord.Embed(
+                    title=f"DM to: {message.channel.recipient}",
+                    description=message.content,
+                    color=0x39e326
+                )
+            else:
+                e = discord.Embed(
+                    title="New DM:",
+                    description=message.content,
+                    color=0x0A97F5
+                )
+            e.set_author(
+                name=message.channel.recipient,
+                icon_url=message.channel.recipient.avatar_url_as(format="png")
+            )
+
+            if message.attachments:
+                attachment_url = message.attachments[0].url
+                e.set_image(url=attachment_url)
+
+            e.set_footer(
+                text=f"User ID: {message.channel.recipient.id}"
+            )
+
+            await self.logs["dm"].send(embed=e)
+
+    @commands.Cog.listener()
+    async def on_command_error(self, ctx, error):
+        await self.register_command(ctx)
+        if not isinstance(error, (
+                commands.CommandInvokeError, commands.ConversionError)):
+            return
+
+        error = error.original
+        if isinstance(error, (discord.Forbidden, discord.NotFound)):
+            return
+
+        e = discord.Embed(title='Command Error', colour=0xcc3366)
+        e.add_field(name='Name', value=ctx.command.qualified_name)
+        e.add_field(name='Author', value=f'{ctx.author} (ID: {ctx.author.id})')
+
+        fmt = f'Channel: {ctx.channel} (ID: {ctx.channel.id})'
+        if ctx.guild:
+            fmt = f'{fmt}\nGuild: {ctx.guild} (ID: {ctx.guild.id})'
+
+        e.add_field(name='Location', value=fmt, inline=False)
+        e.add_field(name='Content', value=textwrap.shorten(
+            ctx.message.content,
+            width=512
+        ))
+
+        exc = ''.join(traceback.format_exception(
+            type(error), error, error.__traceback__,
+            chain=False)
+        )
+        e.description = f'```py\n{exc}\n```'
+        e.timestamp = datetime.datetime.utcnow()
+        await self.logs.get('errors').send(embed=e)
+
+    @commands.Cog.listener()
+    async def on_socket_raw_send(self, data):
+        if '"op":2' not in data and '"op":6' not in data:
+            return
+
+        back_to_json = json.loads(data)
+        if back_to_json['op'] == 2:
+            payload = back_to_json['d']
+            inner_shard = payload.get('shard', [0])
+            self._identifies[inner_shard[0]].append(datetime.datetime.utcnow())
+        else:
+            self._resumes.append(datetime.datetime.utcnow())
+
+        self._clear_gateway_data()
+
+    def add_record(self, record):
+        self._gateway_queue.put_nowait(record)
+
+    async def notify_gateway_status(self, record):
+        types = {
+            'INFO': ':information_source:',
+            'WARNING': ':warning:'
+        }
+
+        emoji = types.get(record.levelname, ':heavy_multiplication_x:')
+        dt = datetime.datetime.utcfromtimestamp(record.created)
+        msg = f'{emoji} `[{dt:%Y-%m-%d %H:%M:%S}] {record.message}`'
+        await self.logs.get('gateway').send(msg)
+
+    @command_extra(name='commandstats')
+    @commands.is_owner()
+    async def _commandstats(self, ctx, limit=20):
+        counter = self.bot.command_stats
+        width = len(max(counter, key=len))
+
+        if limit > 0:
+            common = counter.most_common(limit)
+        else:
+            common = counter.most_common()[limit:]
+
+        output = '\n'.join(f'{k:<{width}}: {c}' for k, c in common)
+
+        await ctx.send(f'```\n{output}\n```')
+
+    @commands.command('socketstats')
+    @commands.is_owner()
+    async def _socketstats(self, ctx):
+        delta = datetime.datetime.utcnow() - self.bot.uptime
+        minutes = delta.total_seconds() / 60
+        total = sum(self.bot.socket_stats.values())
+        cpm = total / minutes
+        await ctx.send(
+            f'{total} socket events observed ({cpm:.2f}/minute):\n'
+            f'{self.bot.socket_stats}')
+
+    @commands.command('uptime')
+    async def _uptime(self, ctx):
+        uptime = humanize.naturaltime(
+            datetime.datetime.utcnow() - self.bot.uptime)
+        await ctx.send(f'Uptime: **{uptime}**')
+
+
+async def on_error(self, event, *args):
+    e = discord.Embed(title='Event Error', colour=0xa32952)
+    e.add_field(name='Event', value=event)
+    e.description = f'```py\n{traceback.format_exc()}\n```'
+    e.timestamp = datetime.datetime.utcnow()
+
+    args_str = ['```py']
+    for index, arg in enumerate(args):
+        args_str.append(f'[{index}]: {arg!r}')
+    args_str.append('```')
+    e.add_field(name='Args', value='\n'.join(args_str), inline=False)
+
+    hook = self.get_cog('Logs').logs.get('errors')
+    try:
+        await hook.send(embed=e)
+    except (discord.HTTPException, discord.NotFound,
+            discord.Forbidden, discord.InvalidArgument):
+        pass
diff --git a/build/lib/tuxbot/cogs/network/__init__.py b/build/lib/tuxbot/cogs/network/__init__.py
new file mode 100644
index 0000000..b6623f9
--- /dev/null
+++ b/build/lib/tuxbot/cogs/network/__init__.py
@@ -0,0 +1,5 @@
+from .network import Network
+
+
+def setup(bot):
+    bot.add_cog(Network(bot))
diff --git a/build/lib/tuxbot/cogs/network/network.py b/build/lib/tuxbot/cogs/network/network.py
new file mode 100644
index 0000000..42c2a93
--- /dev/null
+++ b/build/lib/tuxbot/cogs/network/network.py
@@ -0,0 +1,105 @@
+import logging
+import socket
+import ipinfo
+import discord
+
+from discord.ext import commands, flags
+from ipwhois import Net
+from ipwhois.asn import IPASN
+from ipinfo.exceptions import RequestQuotaExceededError
+from requests.exceptions import HTTPError
+
+from app import TuxBot
+from utils.functions.extra import ContextPlus, command_extra
+
+log = logging.getLogger(__name__)
+
+
+class Network(commands.Cog, name="Useless"):
+    def __init__(self, bot: TuxBot):
+        self.bot = bot
+
+    @flags.add_flag("-i", "--ip", type=str, default='v4',
+                    choices=['v4', '4', 'v6', '6'])
+    @command_extra(name="iplocalise", aliases=['localiseip'])
+    @commands.cooldown(1, 5, commands.BucketType.user)
+    async def _iplocalise(self, ctx: ContextPlus, target: str, **passed_flags):
+        loading = await ctx.send(
+            "_Récupération des informations..._", deletable=False
+        )
+
+        def get_hostname(dtl, tgt):
+            try:
+                return dtl.hostname
+            except AttributeError:
+                try:
+                    return socket.gethostbyaddr(tgt)[0]
+                except (ValueError, socket.herror):
+                    return 'N/A'
+
+        ip_type = passed_flags.get('ip')
+        target_copy = target
+
+        # clean https://, last /, ...
+        spltTgt = target.split("://")
+        target = spltTgt[
+            (0, 1)[len(spltTgt) > 1]
+        ].split("?")[0].split('/')[0].split(':')[0].lower()
+
+        try:
+            target = socket.getaddrinfo(
+                target, None,
+                socket.AF_INET if ip_type in ['v4', '4'] else socket.AF_INET6
+            )[1][4][0]
+        except socket.gaierror:
+            return \
+                await ctx.send("Erreur, cette adresse n'est pas disponible.")
+
+        net = Net(target)
+        obj = IPASN(net)
+        ip_info = obj.lookup()
+
+        try:
+            handler = ipinfo.getHandler(self.bot.config.ipinfo)
+            details = handler.getDetails(target)
+            api_result = True
+        except (RequestQuotaExceededError, HTTPError):
+            details = None
+            api_result = False
+
+        if api_result:
+            belongs = f"{details.org}"
+
+            osm = f"https://www.openstreetmap.org/" \
+                  f"?mlat={details.latitude}" \
+                  f"&mlon={details.longitude}" \
+                  f"#map=5/{details.latitude}/{details.longitude}" \
+                  f"&layers=H"
+
+            region = f"[{details.city} - {details.region} " \
+                     f"({details.country})]({osm})"
+            flag = f"https://www.countryflags.io/" \
+                   f"{details.country}/shiny/64.png"
+        else:
+            belongs = f"{ip_info['asn_description']} (AS{ip_info['asn']})"
+            region = f"{ip_info['asn_country_code']}"
+            flag = f"https://www.countryflags.io/" \
+                   f"{ip_info['asn_country_code']}/shiny/64.png"
+
+        e = discord.Embed(
+            title=f"**Information sur __{target_copy}__ :**"
+                  f" `{target}`",
+            color=0x5858d7
+        )
+
+        e.add_field(name="Appartient à :", value=belongs)
+        e.add_field(name="RIR :", value=f"{ip_info['asn_registry']}")
+        e.add_field(name="Region :", value=region)
+
+        e.add_field(name="Nom de l'hôte :",
+                    value=get_hostname(details, target), inline=False)
+
+        e.set_thumbnail(url=flag)
+
+        await loading.delete()
+        await ctx.send(embed=e)
diff --git a/build/lib/tuxbot/core/__init__.py b/build/lib/tuxbot/core/__init__.py
new file mode 100644
index 0000000..d38178b
--- /dev/null
+++ b/build/lib/tuxbot/core/__init__.py
@@ -0,0 +1,8 @@
+from colorama import init
+
+from .. import __version__, version_info, VersionInfo
+from .config import Config
+
+__all__ = ["Config", "__version__", "version_info", "VersionInfo"]
+
+init()
diff --git a/build/lib/tuxbot/core/bot.py b/build/lib/tuxbot/core/bot.py
new file mode 100644
index 0000000..a7764a2
--- /dev/null
+++ b/build/lib/tuxbot/core/bot.py
@@ -0,0 +1,65 @@
+from pathlib import Path
+
+from discord.ext import commands
+from . import Config
+from . import data_manager
+
+
+__all__ = ["Tux"]
+
+
+class Tux(commands.AutoShardedBot):
+    def __init__(self, *args, cli_flags=None, bot_dir: Path = Path.cwd(), **kwargs):
+        # by default, if the bot shutdown without any intervention,
+        # it's a crash
+        self.shutdown_code = 1
+        self.cli_flags = cli_flags
+        self.instance_name = self.cli_flags.instance_name
+        self.last_exception = None
+
+        self.config = Config(
+            data_manager.get_data_path(self.instance_name)
+        )
+        self.config.register_global(
+            token=None,
+            prefix=[],
+            owner=None,
+            whitelist=[],
+            blacklist=[],
+            locale="en-US",
+            embeds=True,
+            color=0x6E83D1,
+            disabled_commands=[]
+        )
+        self.config.register_guild(
+            prefix=[],
+            whitelist=[],
+            blacklist=[],
+            locale="en-US",
+            admin_role=[],
+            mod_role=[],
+            embeds=None,
+            ignored=False,
+            disabled_commands=[]
+        )
+        self.config.register_channel(
+            ignored=False
+        )
+
+        if "owner_ids" in kwargs:
+            kwargs["owner_ids"] = set(kwargs["owner_ids"])
+        else:
+            kwargs["owner_ids"] = self.config.owner_ids()
+
+        message_cache_size = 100_000
+        kwargs["max_messages"] = message_cache_size
+        self.max_messages = message_cache_size
+
+        self.uptime = None
+        self.main_dir = bot_dir
+
+        print(str(self.cli_flags), self.instance_name, self.config, self.owner_ids, self.main_dir)
+
+        exit()
+
+        super().__init__(*args, help_command=None, **kwargs)
diff --git a/build/lib/tuxbot/core/config.py b/build/lib/tuxbot/core/config.py
new file mode 100644
index 0000000..56bb294
--- /dev/null
+++ b/build/lib/tuxbot/core/config.py
@@ -0,0 +1,41 @@
+from pathlib import Path
+from typing import Any, NoReturn
+
+
+class Config:
+    GLOBAL = "GLOBAL"
+    GUILD = "GUILD"
+    CHANNEL = "TEXT_CHANNEL"
+    ROLE = "ROLE"
+    MEMBER = "MEMBER"
+    USER = "USER"
+
+    def __init__(self, config_dir: Path):
+        self._defaults = {}
+
+    def __getattr__(self, item: str) -> dict:
+        return getattr(self._defaults, item)
+
+    def _register_default(self, key: str, **kwargs: Any):
+        ...
+
+    def register_core(self, **kwargs) -> NoReturn:
+        self._register_default(self.GUILD, **kwargs)
+
+    def register_global(self, **kwargs) -> NoReturn:
+        self._register_default(self.GLOBAL, **kwargs)
+
+    def register_guild(self, **kwargs) -> NoReturn:
+        self._register_default(self.GUILD, **kwargs)
+
+    def register_channel(self, **kwargs) -> NoReturn:
+        self._register_default(self.CHANNEL, **kwargs)
+
+    def register_role(self, **kwargs) -> NoReturn:
+        self._register_default(self.ROLE, **kwargs)
+
+    def register_member(self, **kwargs) -> NoReturn:
+        self._register_default(self.MEMBER, **kwargs)
+
+    def register_user(self, **kwargs) -> NoReturn:
+        self._register_default(self.USER, **kwargs)
diff --git a/build/lib/tuxbot/core/data_manager.py b/build/lib/tuxbot/core/data_manager.py
new file mode 100644
index 0000000..473ea42
--- /dev/null
+++ b/build/lib/tuxbot/core/data_manager.py
@@ -0,0 +1,26 @@
+from pathlib import Path
+
+import appdirs
+
+app_dir = appdirs.AppDirs("Tuxbot-bot")
+config_dir = Path(app_dir.user_config_dir)
+config_file = config_dir / "config.json"
+
+
+def get_data_path(instance_name: str) -> Path:
+    return Path(app_dir.user_data_dir) / "data" / instance_name
+
+
+def get_core_path(instance_name: str) -> Path:
+    data_path = get_data_path(instance_name)
+    return data_path / "data" / instance_name / "core"
+
+
+def get_cogs_path(instance_name: str) -> Path:
+    data_path = get_data_path(instance_name)
+    return data_path / "data" / instance_name / "cogs"
+
+
+def get_cog_path(instance_name: str, cog_name: str) -> Path:
+    data_path = get_data_path(instance_name)
+    return data_path / "data" / instance_name / "cogs" / cog_name
diff --git a/build/lib/tuxbot/core/utils/functions/cli.py b/build/lib/tuxbot/core/utils/functions/cli.py
new file mode 100644
index 0000000..3763a21
--- /dev/null
+++ b/build/lib/tuxbot/core/utils/functions/cli.py
@@ -0,0 +1,89 @@
+import codecs
+import itertools
+import sys
+
+
+def bordered(*columns: dict) -> str:
+    """
+    credits to https://github.com/Cog-Creators/Red-DiscordBot/blob/V3/develop/redbot/core/utils/chat_formatting.py
+
+    Get two blocks of text in a borders.
+
+    Note
+    ----
+    This will only work with a monospaced font.
+
+    Parameters
+    ----------
+    *columns : `sequence` of `str`
+        The columns of text, each being a list of lines in that column.
+
+    Returns
+    -------
+    str
+        The bordered text.
+
+    """
+    encoder = codecs.getencoder(sys.stdout.encoding)
+    try:
+        encoder("┌┐└┘─│")  # border symbols
+    except UnicodeEncodeError:
+        ascii_border = True
+    else:
+        ascii_border = False
+
+    borders = {
+        "TL": "+" if ascii_border else "┌",  # Top-left
+        "TR": "+" if ascii_border else "┐",  # Top-right
+        "BL": "+" if ascii_border else "└",  # Bottom-left
+        "BR": "+" if ascii_border else "┘",  # Bottom-right
+        "HZ": "-" if ascii_border else "─",  # Horizontal
+        "VT": "|" if ascii_border else "│",  # Vertical
+    }
+
+    sep = " " * 4  # Separator between boxes
+    widths = tuple(
+        max(
+            len(row) for row in column.get('rows')
+        ) + 9
+        for column in columns
+    )  # width of each col
+    cols_done = [False] * len(columns)  # whether or not each column is done
+    lines = [""]
+
+    for i, column in enumerate(columns):
+        lines[0] += "{TL}" + "{HZ}" + column.get('title') \
+                    + "{HZ}" * (widths[i] - len(column.get('title')) - 1) \
+                    + "{TR}" + sep
+
+    for line in itertools.zip_longest(
+            *[column.get('rows') for column in columns]
+    ):
+        row = []
+        for colidx, column in enumerate(line):
+            width = widths[colidx]
+            done = cols_done[colidx]
+            if column is None:
+                if not done:
+                    # bottom border of column
+                    column = "{HZ}" * width
+                    row.append("{BL}" + column + "{BR}")
+                    cols_done[colidx] = True  # mark column as done
+                else:
+                    # leave empty
+                    row.append(" " * (width + 2))
+            else:
+                column += " " * (width - len(column))  # append padded spaces
+                row.append("{VT}" + column + "{VT}")
+
+        lines.append(sep.join(row))
+
+    final_row = []
+    for width, done in zip(widths, cols_done):
+        if not done:
+            final_row.append("{BL}" + "{HZ}" * width + "{BR}")
+        else:
+            final_row.append(" " * (width + 2))
+    lines.append(sep.join(final_row))
+
+    return "\n".join(lines).format(**borders)
diff --git a/build/lib/tuxbot/core/utils/functions/extra.py b/build/lib/tuxbot/core/utils/functions/extra.py
new file mode 100644
index 0000000..6783211
--- /dev/null
+++ b/build/lib/tuxbot/core/utils/functions/extra.py
@@ -0,0 +1,114 @@
+import ast
+import asyncio
+import json
+import os
+
+import discord
+from discord.ext import commands, flags
+
+from configs.bot.protected import protected
+from configs.bot.settings import prefixes
+
+
+class ContextPlus(commands.Context):
+    async def send(self, content=None, *args, **kwargs):
+        if content is not None:
+            for value in protected:
+                content = content.replace(
+                    str(value),
+                    '[Deleted]'
+                )
+
+        if kwargs.get('content') is not None:
+            for value in protected:
+                kwargs['content'] = kwargs['content'].replace(
+                    str(value),
+                    '[Deleted]'
+                )
+
+        if kwargs.get('embeds') is not None and len(kwargs.get('embeds')) > 0:
+            for i, embed in enumerate(kwargs.get('embeds')):
+                embed = str(kwargs.get('embed').to_dict())
+                for value in protected:
+                    embed = embed.replace(str(value), '[Deleted]')
+                kwargs['embeds'][i] = discord.Embed.from_dict(
+                    ast.literal_eval(embed)
+                )
+
+        if kwargs.get('embed') is not None:
+            embed = str(kwargs.get('embed').to_dict())
+            for value in protected:
+                embed = embed.replace(str(value), '[Deleted]')
+            kwargs['embed'] = discord.Embed.from_dict(
+                ast.literal_eval(embed)
+            )
+
+        if (hasattr(self.command, 'deletable') and self.command.deletable) \
+                and kwargs.pop('deletable', True):
+            message = await super().send(content, *args, **kwargs)
+            await message.add_reaction('🗑')
+
+            def check(reaction: discord.Reaction, user: discord.User):
+                return user == self.author \
+                       and str(reaction.emoji) == '🗑' \
+                       and reaction.message.id == message.id
+
+            try:
+                await self.bot.wait_for(
+                    'reaction_add',
+                    timeout=60.0,
+                    check=check
+                )
+            except asyncio.TimeoutError:
+                await message.remove_reaction('🗑', self.bot.user)
+            else:
+                await message.delete()
+            return message
+        else:
+            return await super().send(content, *args, **kwargs)
+
+
+class CommandPLus(flags.FlagCommand):
+    def __init__(self, function, **kwargs):
+        super().__init__(function, **kwargs)
+        self.deletable = kwargs.pop("deletable", True)
+
+
+def command_extra(*args, **kwargs):
+    return commands.command(*args, **kwargs, cls=CommandPLus)
+
+
+class GroupPlus(flags.FlagGroup):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.deletable = kwargs.pop("deletable", True)
+
+
+def group_extra(*args, **kwargs):
+    return commands.group(*args, **kwargs, cls=GroupPlus)
+
+
+async def get_prefix(bot, message):
+    custom_prefix = prefixes
+    if message.guild:
+        path = f"configs/guilds/{str(message.guild.id)}.json"
+
+        if os.path.exists(path):
+            with open(path) as f:
+                datas = json.load(f)
+
+                custom_prefix = datas["Prefix"]
+
+        return commands.when_mentioned_or(*custom_prefix)(bot, message)
+
+
+def get_owners() -> list:
+    with open("configs/bot/whitelist.json") as f:
+        datas = json.load(f)
+
+        return datas['owners']
+
+
+def get_blacklist() -> dict:
+    with open("configs/bot/blacklist.json") as f:
+        return json.load(f)
diff --git a/build/lib/tuxbot/logging.py b/build/lib/tuxbot/logging.py
new file mode 100644
index 0000000..4880004
--- /dev/null
+++ b/build/lib/tuxbot/logging.py
@@ -0,0 +1,39 @@
+import logging.handlers
+import logging
+import pathlib
+import sys
+
+MAX_OLD_LOGS = 8
+MAX_BYTES = 5_000_000
+
+
+def init_logging(level: int, location: pathlib.Path) -> None:
+    dpy_logger = logging.getLogger("discord")
+    dpy_logger.setLevel(logging.WARN)
+    dpy_logger_file = location / 'discord.log'
+
+    base_logger = logging.getLogger("tuxbot")
+    base_logger.setLevel(level)
+    base_logger_file = location / 'tuxbot.log'
+
+    formatter = logging.Formatter(
+        "[{asctime}] [{levelname}] {name}: {message}",
+        datefmt="%Y-%m-%d %H:%M:%S", style="{"
+    )
+
+    dpy_handler = logging.handlers.RotatingFileHandler(
+        str(dpy_logger_file.resolve()),
+        maxBytes=MAX_BYTES, backupCount=MAX_OLD_LOGS
+    )
+    base_handler = logging.handlers.RotatingFileHandler(
+        str(base_logger_file.resolve()),
+        maxBytes=MAX_BYTES, backupCount=MAX_OLD_LOGS
+    )
+
+    dpy_logger.addHandler(dpy_handler)
+    base_logger.addHandler(base_handler)
+
+    stdout_handler = logging.StreamHandler(sys.stdout)
+    stdout_handler.setFormatter(formatter)
+    base_logger.addHandler(stdout_handler)
+    dpy_logger.addHandler(stdout_handler)
diff --git a/build/lib/tuxbot/setup.py b/build/lib/tuxbot/setup.py
new file mode 100644
index 0000000..9e2e7d7
--- /dev/null
+++ b/build/lib/tuxbot/setup.py
@@ -0,0 +1,292 @@
+import json
+import logging
+import re
+import sys
+from pathlib import Path
+from typing import NoReturn, Union, List, Set
+
+import click
+from colorama import Fore, Style, init
+
+from tuxbot.core.data_manager import config_dir, app_dir
+
+init()
+
+try:
+    config_dir.mkdir(parents=True, exist_ok=True)
+except PermissionError:
+    print(f"mkdir: cannot create directory '{config_dir}': Permission denied")
+    sys.exit(1)
+
+config_file = config_dir / "config.json"
+
+
+def load_existing_config() -> dict:
+    if not config_file.exists():
+        return {}
+
+    with config_file.open() as fs:
+        return json.load(fs)
+
+
+instances_data = load_existing_config()
+if not instances_data:
+    instances_list = []
+else:
+    instances_list = list(instances_data.keys())
+
+
+def save_config(name, data, delete=False):
+    _config = load_existing_config()
+
+    if delete and name in _config:
+        _config.pop(name)
+    else:
+        _config[name] = data
+
+    with config_file.open("w") as fs:
+        json.dump(_config, fs, indent=4)
+
+
+def get_name() -> str:
+    name = ""
+    while not name:
+        print(
+            "What name do you want to give this instance?\n"
+            "(valid characters: A-Z, a-z, 0-9, _, -)"
+        )
+        name = input("> ")
+        if re.fullmatch(r"[a-zA-Z0-9_\-]*", name) is None:
+            print()
+            print(
+                Fore.RED
+                + "ERROR: Invalid characters provided"
+                + Style.RESET_ALL
+            )
+            name = ""
+    return name
+
+
+def get_data_dir(instance_name: str) -> Path:
+    data_path = Path(app_dir.user_data_dir) / "data" / instance_name
+    data_path_input = ""
+    print()
+
+    def make_data_dir(path: Path) -> Union[Path, str]:
+        try:
+            path.mkdir(parents=True, exist_ok=True)
+        except OSError:
+            print()
+            print(
+                Fore.RED
+                + f"mkdir: cannot create directory '{path}':"
+                  f" Permission denied"
+                + Style.RESET_ALL
+            )
+            path = ""
+
+        return path
+
+    while not data_path_input:
+        print(
+            "where do you want to save the configurations?\n"
+            "Press [enter] to keep the default path"
+        )
+        print()
+        print(f"Default: {data_path}")
+
+        data_path_input = input("> ")
+
+        if data_path_input != '':
+            data_path_input = Path(data_path_input)
+
+            try:
+                exists = data_path_input.exists()
+            except OSError:
+                print()
+                print(
+                    Fore.RED
+                    + "Impossible to verify the validity of the path, "
+                      "make sure it does not contain any invalid characters."
+                    + Style.RESET_ALL
+                )
+                data_path_input = ""
+                exists = False
+
+            if data_path_input and not exists:
+                data_path_input = make_data_dir(data_path_input)
+        else:
+            data_path_input = make_data_dir(data_path)
+
+    print()
+    print(
+        f"You have chosen {data_path_input} to be your config directory for "
+        f"`{instance_name}` instance"
+    )
+
+    if not click.confirm("Please confirm", default=True):
+        print("Rerun the process to redo this configuration.")
+        sys.exit(0)
+
+    (data_path_input / 'core').mkdir(parents=True, exist_ok=True)
+    (data_path_input / 'cogs').mkdir(parents=True, exist_ok=True)
+    (data_path_input / 'logs').mkdir(parents=True, exist_ok=True)
+
+    return data_path_input
+
+
+def get_token() -> str:
+    token = ""
+
+    while not token:
+        print(
+            "Please enter the bot token\n"
+            "(you can find it at https://discord.com/developers/applications)"
+        )
+        token = input("> ")
+        if re.fullmatch(r"([a-zA-Z0-9]{24}\.[a-zA-Z0-9_]{6}\.[a-zA-Z0-9_\-]{27}|mfa\.[a-zA-Z0-9_\-]{84})", token) is None:
+            print(
+                Fore.RED
+                + "ERROR: Invalid token provided"
+                + Style.RESET_ALL
+            )
+            token = ""
+    return token
+
+
+def get_multiple(question: str, confirmation: str, value_type: type)\
+        -> Set[Union[str, int]]:
+    print(question)
+    values = [value_type(input('> '))]
+
+    while click.confirm(confirmation, default=False):
+        values.append(value_type(input('> ')))
+
+    return set(values)
+
+
+def additional_config() -> dict:
+    p = Path(r'tuxbot/cogs').glob('**/additional_config.json')
+    datas = {}
+
+    for file in p:
+        print()
+        cog_name = str(file.parent).split('/')[-1]
+        datas[cog_name] = {}
+
+        with file.open('r') as f:
+            data = json.load(f)
+
+        print(f"\n==Configuration for `{cog_name}` module==")
+
+        for key, value in data.items():
+            print()
+            print(value['description'])
+            datas[cog_name][key] = input('> ')
+
+    return datas
+
+
+def finish_setup(data_dir: Path) -> NoReturn:
+    print("Now, it's time to finish this setup by giving bot informations\n")
+
+    token = get_token()
+    print()
+    prefixes = get_multiple(
+        "Choice a (or multiple) prefix for the bot",
+        "Add another prefix ?",
+        str
+    )
+    mentionable = click.confirm(
+        "Does the bot answer if it's mentioned?",
+        default=True
+    )
+
+    owners_id = get_multiple(
+        "Give the owner id of this bot",
+        "Add another owner ?",
+        int
+    )
+
+    cogs_config = additional_config()
+
+    core_file = data_dir / 'core' / 'settings.json'
+    core = {
+        'token': token,
+        'prefixes': prefixes,
+        'mentionable': mentionable,
+        'owners_id': owners_id,
+    }
+
+    with core_file.open("w") as fs:
+        json.dump(core, fs, indent=4)
+
+    for cog, data in cogs_config.items():
+        data_cog_dir = data_dir / 'cogs' / cog
+        data_cog_dir.mkdir(parents=True, exist_ok=True)
+
+        data_cog_file = data_cog_dir / 'settings.json'
+
+        with data_cog_file.open("w") as fs:
+            json.dump(data, fs, indent=4)
+
+
+def basic_setup() -> NoReturn:
+    print("Hi ! it's time for you to give me informations about you instance")
+    name = get_name()
+
+    data_dir = get_data_dir(name)
+
+    configs = load_existing_config()
+    instance_config = configs[name] if name in instances_list else {}
+
+    instance_config["DATA_PATH"] = str(data_dir.resolve())
+    instance_config["IS_RUNNING"] = False
+
+    if name in instances_list:
+        print()
+        print(
+            Fore.RED
+            + f"WARNING: An instance named `{name}` already exists "
+              f"Continuing will overwrite this instance configs."
+            + Style.RESET_ALL
+        )
+        if not click.confirm("Are you sure you want to continue?",
+                             default=False):
+            print("Abandon...")
+            sys.exit(0)
+
+    save_config(name, instance_config)
+
+    print("\n"*4)
+
+    finish_setup(data_dir)
+
+    print()
+    print(
+        f"Instance successfully created! "
+        f"You can now run `tuxbot {name}` to launch this instance"
+    )
+
+
+def setup():
+    try:
+        """Create a new instance."""
+        level = logging.DEBUG
+        base_logger = logging.getLogger("tuxbot")
+        base_logger.setLevel(level)
+        formatter = logging.Formatter(
+            "[{asctime}] [{levelname}] {name}: {message}",
+            datefmt="%Y-%m-%d %H:%M:%S", style="{"
+        )
+        stdout_handler = logging.StreamHandler(sys.stdout)
+        stdout_handler.setFormatter(formatter)
+        base_logger.addHandler(stdout_handler)
+
+        basic_setup()
+    except KeyboardInterrupt:
+        print("Exiting...")
+
+
+if __name__ == "__main__":
+    setup()
diff --git a/dist/Tuxbot_bot-3.0.0-py3.8.egg b/dist/Tuxbot_bot-3.0.0-py3.8.egg
new file mode 100644
index 0000000000000000000000000000000000000000..aef0a65902eda3b03977d8dda1c2276d84804d7f
GIT binary patch
literal 44154
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
RB!UWx1vo^^kbM5_e*hQ-3f2Gs

literal 0
HcmV?d00001

diff --git a/setup.cfg b/setup.cfg
index 2d8c661..d5fe968 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -12,6 +12,7 @@ python_requires = >=3.7
 install_requires =
     aiohttp==3.6.2
     aiosqlite==0.13.0
+    appdirs==1.4.4
     async-timeout==3.0.1
     asyncpg==0.20.1
     attrs==19.3.0
@@ -19,6 +20,7 @@ install_requires =
     certifi==2020.4.5.1
     chardet==3.0.4
     ciso8601==2.1.3
+    click==7.1.2
     colorama==0.4.3
     discord-flags==2.1.1
     discord.py==1.3.3
diff --git a/tuxbot/__init__.py b/tuxbot/__init__.py
index 2f9deab..e7b1e77 100644
--- a/tuxbot/__init__.py
+++ b/tuxbot/__init__.py
@@ -10,5 +10,7 @@ version_info = VersionInfo(
     releaselevel='alpha', build=build
 )
 
-__version__ = "v{}.{}.{}" \
-    .format(version_info.major, version_info.minor, version_info.micro)
\ No newline at end of file
+__version__ = "v{}.{}.{}-{}.{}".format(
+    version_info.major, version_info.minor, version_info.micro,
+    version_info.releaselevel, version_info.build
+).replace('\n', '')
diff --git a/tuxbot/__main__.py b/tuxbot/__main__.py
index 9216b63..e09cbe0 100644
--- a/tuxbot/__main__.py
+++ b/tuxbot/__main__.py
@@ -1,38 +1,104 @@
 import argparse
 import asyncio
+import getpass
+import json
 import logging
+import platform
 import signal
 import sys
+from typing import NoReturn
 
 import discord
+import pip
 from colorama import Fore, init, Style
+from pip._vendor import distro
 
 import tuxbot.logging
 from tuxbot.core import data_manager
+from tuxbot.core.bot import Tux
+from tuxbot.core.utils.functions.cli import bordered
+from . import __version__
 
 log = logging.getLogger("tuxbot.main")
 init()
 
 
+def list_instances() -> NoReturn:
+    with data_manager.config_file.open() as fs:
+        datas = json.load(fs)
+
+    instances = list(datas.keys())
+
+    info = {
+        'title': "Instances",
+        'rows': []
+    }
+
+    for instance in instances:
+        info['rows'].append(f"-> {instance}")
+
+    print(bordered(info))
+    sys.exit(0)
+
+
+def debug_info() -> NoReturn:
+    python_version = sys.version.replace('\n', '')
+    pip_version = pip.__version__
+    tuxbot_version = __version__
+    dpy_version = discord.__version__
+
+    os_info = distro.linux_distribution()
+    os_info = f"{os_info[0]} {os_info[1]}"
+
+    runner = getpass.getuser()
+
+    info = {
+        'title': "Debug Info",
+        'rows': [
+            f"Tuxbot version: {tuxbot_version}",
+            "",
+            f"Python version: {python_version}",
+            f"Python executable path: {sys.executable}",
+            f"Pip version: {pip_version}",
+            f"Discord.py version: {dpy_version}",
+            "",
+            f"OS info: {os_info}",
+            f"System arch: {platform.machine()}",
+            f"User: {runner}",
+        ]
+    }
+
+    print(bordered(info))
+    sys.exit(0)
+
+
 def parse_cli_flags(args):
     parser = argparse.ArgumentParser(
         description="Tuxbot - OpenSource bot",
         usage="tuxbot <instance_name> [arguments]"
     )
-    parser.add_argument("--version", "-V", help="Show tuxbot's used version")
-    parser.add_argument("--list-instances", "-L",
-                        help="List all instance names")
+    parser.add_argument(
+        "--version", "-V",
+        action="store_true",
+        help="Show tuxbot's used version"
+    )
+    parser.add_argument(
+        "--debug",
+        action="store_true",
+        help="Show debug information."
+    )
+    parser.add_argument(
+        "--list-instances", "-L",
+        action="store_true",
+        help="List all instance names"
+    )
     parser.add_argument(
         "instance_name", nargs="?",
-        help="Name of the bot instance created during `redbot-setup`.")
+        help="Name of the bot instance created during `tuxbot-setup`."
+    )
 
     args = parser.parse_args(args)
 
-    if args.prefix:
-        args.prefix = sorted(args.prefix, reverse=True)
-    else:
-        args.prefix = []
-
     return args
 
 
@@ -42,10 +108,10 @@ async def shutdown_handler(tux, signal_type, exit_code=None):
         sys.exit(0)
     elif exit_code is None:
         log.info("Shutting down from unhandled exception")
-        tux._shutdown_mode = 1
+        tux.shutdown_code = 1
 
     if exit_code is not None:
-        tux._shutdown_mode = exit_code
+        tux.shutdown_code = exit_code
 
     try:
         await tux.logout()
@@ -60,8 +126,8 @@ async def shutdown_handler(tux, signal_type, exit_code=None):
         await asyncio.gather(*pending, return_exceptions=True)
 
 
-async def run_bot(tux: Tuxbot, cli_flags: argparse.Namespace) -> None:
-    data_path = data_manager.get_data_path(tuxbot.instance_name)
+async def run_bot(tux: Tux, cli_flags: argparse.Namespace) -> None:
+    data_path = data_manager.get_data_path(tux.instance_name)
 
     tuxbot.logging.init_logging(
         level=cli_flags.logging_level,
@@ -74,7 +140,7 @@ async def run_bot(tux: Tuxbot, cli_flags: argparse.Namespace) -> None:
     if cli_flags.token:
         token = cli_flags.token
     else:
-        token = await tux._config.token()
+        token = await tux.config.token()
 
     if not token:
         log.critical("Token must be set if you want to login.")
@@ -92,18 +158,28 @@ async def run_bot(tux: Tuxbot, cli_flags: argparse.Namespace) -> None:
 def main():
     tux = None
     cli_flags = parse_cli_flags(sys.argv[1:])
+
+    if cli_flags.list_instances:
+        list_instances()
+    elif cli_flags.debug:
+        debug_info()
+    elif cli_flags.version:
+        print("Tuxbot V3")
+        print(f"Complete Version: {__version__}")
+        sys.exit(0)
+
     loop = asyncio.new_event_loop()
     asyncio.set_event_loop(loop)
 
     try:
-        if cli_flags.no_instance:
+        if not cli_flags.instance_name:
             print(Fore.RED
                   + "No instance provided ! "
                     "You can use 'tuxbot -L' to list all available instances"
                   + Style.RESET_ALL)
             sys.exit(1)
 
-        tux = Tuxbot(
+        tux = Tux(
             cli_flags=cli_flags,
             description="Tuxbot, made from and for OpenSource",
             dm_help=None
@@ -113,24 +189,24 @@ def main():
     except KeyboardInterrupt:
         log.warning("Please use <prefix>quit instead of Ctrl+C to Shutdown!")
         log.error("Received KeyboardInterrupt")
-        if tuxbot is not None:
+        if tux is not None:
             loop.run_until_complete(shutdown_handler(tux, signal.SIGINT))
     except SystemExit as exc:
         log.info("Shutting down with exit code: %s", exc.code)
-        if tuxbot is not None:
+        if tux is not None:
             loop.run_until_complete(shutdown_handler(tux, None, exc.code))
     except Exception as exc:
         log.exception("Unexpected exception (%s): ", type(exc), exc_info=exc)
-        if tuxbot is not None:
+        if tux is not None:
             loop.run_until_complete(shutdown_handler(tux, None, 1))
     finally:
         loop.run_until_complete(loop.shutdown_asyncgens())
         log.info("Please wait, cleaning up a bit more")
-        loop.run_until_complete(asyncio.sleep(2))
+        loop.run_until_complete(asyncio.sleep(1))
         asyncio.set_event_loop(None)
         loop.stop()
         loop.close()
-        exit_code = 1 if tuxbot is None else tux._shutdown_mode
+        exit_code = 1 if tux is None else tux.shutdown_code
         sys.exit(exit_code)
 
 
diff --git a/tuxbot/cogs/network/network.py b/tuxbot/cogs/network/network.py
index f5c6b86..42c2a93 100644
--- a/tuxbot/cogs/network/network.py
+++ b/tuxbot/cogs/network/network.py
@@ -60,7 +60,7 @@ class Network(commands.Cog, name="Useless"):
         ip_info = obj.lookup()
 
         try:
-            handler = ipinfo.getHandler(self.bot._config.ipinfo)
+            handler = ipinfo.getHandler(self.bot.config.ipinfo)
             details = handler.getDetails(target)
             api_result = True
         except (RequestQuotaExceededError, HTTPError):
diff --git a/tuxbot/core/bot.py b/tuxbot/core/bot.py
index 43dcb8d..a7764a2 100644
--- a/tuxbot/core/bot.py
+++ b/tuxbot/core/bot.py
@@ -2,6 +2,7 @@ from pathlib import Path
 
 from discord.ext import commands
 from . import Config
+from . import data_manager
 
 
 __all__ = ["Tux"]
@@ -11,14 +12,15 @@ class Tux(commands.AutoShardedBot):
     def __init__(self, *args, cli_flags=None, bot_dir: Path = Path.cwd(), **kwargs):
         # by default, if the bot shutdown without any intervention,
         # it's a crash
-        self._shutdown_mode = 1
-        self._cli_flags = cli_flags
-        self._last_exception = None
+        self.shutdown_code = 1
+        self.cli_flags = cli_flags
+        self.instance_name = self.cli_flags.instance_name
+        self.last_exception = None
 
-        self._config = Config.register_core(
-            identifier=self._cli_flags.instance_name
+        self.config = Config(
+            data_manager.get_data_path(self.instance_name)
         )
-        self._config.register_global(
+        self.config.register_global(
             token=None,
             prefix=[],
             owner=None,
@@ -29,7 +31,7 @@ class Tux(commands.AutoShardedBot):
             color=0x6E83D1,
             disabled_commands=[]
         )
-        self._config.register_guild(
+        self.config.register_guild(
             prefix=[],
             whitelist=[],
             blacklist=[],
@@ -40,20 +42,24 @@ class Tux(commands.AutoShardedBot):
             ignored=False,
             disabled_commands=[]
         )
-        self._config.register_channel(
+        self.config.register_channel(
             ignored=False
         )
 
         if "owner_ids" in kwargs:
             kwargs["owner_ids"] = set(kwargs["owner_ids"])
         else:
-            kwargs["owner_ids"] = self._config.owner_ids()
+            kwargs["owner_ids"] = self.config.owner_ids()
 
         message_cache_size = 100_000
         kwargs["max_messages"] = message_cache_size
-        self._max_messages = message_cache_size
+        self.max_messages = message_cache_size
 
-        self._uptime = None
-        self._main_dir = bot_dir
+        self.uptime = None
+        self.main_dir = bot_dir
+
+        print(str(self.cli_flags), self.instance_name, self.config, self.owner_ids, self.main_dir)
+
+        exit()
 
         super().__init__(*args, help_command=None, **kwargs)
diff --git a/tuxbot/logging.py b/tuxbot/logging.py
index 676a8de..4880004 100644
--- a/tuxbot/logging.py
+++ b/tuxbot/logging.py
@@ -1,151 +1,39 @@
 import logging.handlers
+import logging
 import pathlib
-import re
 import sys
-from typing import List, Tuple, Optional
 
 MAX_OLD_LOGS = 8
-
-
-class RotatingFileHandler(logging.handlers.RotatingFileHandler):
-    """Custom rotating file handler.
-
-    This file handler rotates a bit differently to the one in stdlib.
-
-    For a start, this works off of a "stem" and a "directory". The stem
-    is the base name of the log file, without the extension. The
-    directory is where all log files (including backups) will be placed.
-
-    Secondly, this logger rotates files downwards, and new logs are
-    *started* with the backup number incremented. The stdlib handler
-    rotates files upwards, and this leaves the logs in reverse order.
-
-    Thirdly, naming conventions are not customisable with this class.
-    Logs will initially be named in the format "{stem}.log", and after
-    rotating, the first log file will be renamed "{stem}-part1.log",
-    and a new file "{stem}-part2.log" will be created for logging to
-    continue.
-
-    A few things can't be modified in this handler: it must use append
-    mode, it doesn't support use of the `delay` arg, and it will ignore
-    custom namers and rotators.
-
-    When this handler is instantiated, it will search through the
-    directory for logs from previous runtimes, and will open the file
-    with the highest backup number to append to.
-    """
-
-    def __init__(
-        self,
-        stem: str,
-        directory: pathlib.Path,
-        maxBytes: int = 0,
-        backupCount: int = 0,
-        encoding: Optional[str] = None,
-    ) -> None:
-        self.baseStem = stem
-        self.directory = directory.resolve()
-        # Scan for existing files in directory, append to last part of existing log
-        log_part_re = re.compile(rf"{stem}-part(?P<partnum>\d+).log")
-        highest_part = 0
-        for path in directory.iterdir():
-            match = log_part_re.match(path.name)
-            if match and int(match["partnum"]) > highest_part:
-                highest_part = int(match["partnum"])
-        if highest_part:
-            filename = directory / f"{stem}-part{highest_part}.log"
-        else:
-            filename = directory / f"{stem}.log"
-        super().__init__(
-            filename,
-            mode="a",
-            maxBytes=maxBytes,
-            backupCount=backupCount,
-            encoding=encoding,
-            delay=False,
-        )
-
-    def doRollover(self):
-        if self.stream:
-            self.stream.close()
-            self.stream = None
-        initial_path = self.directory / f"{self.baseStem}.log"
-        if self.backupCount > 0 and initial_path.exists():
-            initial_path.replace(self.directory / f"{self.baseStem}-part1.log")
-
-        match = re.match(
-            rf"{self.baseStem}(?:-part(?P<part>\d+)?)?.log", pathlib.Path(self.baseFilename).name
-        )
-        latest_part_num = int(match.groupdict(default="1").get("part", "1"))
-        if self.backupCount < 1:
-            # No backups, just delete the existing log and start again
-            pathlib.Path(self.baseFilename).unlink()
-        elif latest_part_num > self.backupCount:
-            # Rotate files down one
-            # red-part2.log becomes red-part1.log etc, a new log is added at the end.
-            for i in range(1, self.backupCount):
-                next_log = self.directory / f"{self.baseStem}-part{i + 1}.log"
-                if next_log.exists():
-                    prev_log = self.directory / f"{self.baseStem}-part{i}.log"
-                    next_log.replace(prev_log)
-        else:
-            # Simply start a new file
-            self.baseFilename = str(
-                self.directory / f"{self.baseStem}-part{latest_part_num + 1}.log"
-            )
-
-        self.stream = self._open()
+MAX_BYTES = 5_000_000
 
 
 def init_logging(level: int, location: pathlib.Path) -> None:
     dpy_logger = logging.getLogger("discord")
-    dpy_logger.setLevel(logging.WARNING)
-    base_logger = logging.getLogger("red")
+    dpy_logger.setLevel(logging.WARN)
+    dpy_logger_file = location / 'discord.log'
+
+    base_logger = logging.getLogger("tuxbot")
     base_logger.setLevel(level)
+    base_logger_file = location / 'tuxbot.log'
 
     formatter = logging.Formatter(
-        "[{asctime}] [{levelname}] {name}: {message}", datefmt="%Y-%m-%d %H:%M:%S", style="{"
+        "[{asctime}] [{levelname}] {name}: {message}",
+        datefmt="%Y-%m-%d %H:%M:%S", style="{"
     )
 
+    dpy_handler = logging.handlers.RotatingFileHandler(
+        str(dpy_logger_file.resolve()),
+        maxBytes=MAX_BYTES, backupCount=MAX_OLD_LOGS
+    )
+    base_handler = logging.handlers.RotatingFileHandler(
+        str(base_logger_file.resolve()),
+        maxBytes=MAX_BYTES, backupCount=MAX_OLD_LOGS
+    )
+
+    dpy_logger.addHandler(dpy_handler)
+    base_logger.addHandler(base_handler)
+
     stdout_handler = logging.StreamHandler(sys.stdout)
     stdout_handler.setFormatter(formatter)
     base_logger.addHandler(stdout_handler)
     dpy_logger.addHandler(stdout_handler)
-
-    if not location.exists():
-        location.mkdir(parents=True, exist_ok=True)
-    # Rotate latest logs to previous logs
-    previous_logs: List[pathlib.Path] = []
-    latest_logs: List[Tuple[pathlib.Path, str]] = []
-    for path in location.iterdir():
-        match = re.match(r"latest(?P<part>-part\d+)?\.log", path.name)
-        if match:
-            part = match.groupdict(default="")["part"]
-            latest_logs.append((path, part))
-        match = re.match(r"previous(?:-part\d+)?.log", path.name)
-        if match:
-            previous_logs.append(path)
-    # Delete all previous.log files
-    for path in previous_logs:
-        path.unlink()
-    # Rename latest.log files to previous.log
-    for path, part in latest_logs:
-        path.replace(location / f"previous{part}.log")
-
-    latest_fhandler = RotatingFileHandler(
-        stem="latest",
-        directory=location,
-        maxBytes=1_000_000,  # About 1MB per logfile
-        backupCount=MAX_OLD_LOGS,
-        encoding="utf-8",
-    )
-    all_fhandler = RotatingFileHandler(
-        stem="red",
-        directory=location,
-        maxBytes=1_000_000,
-        backupCount=MAX_OLD_LOGS,
-        encoding="utf-8",
-    )
-    for fhandler in (latest_fhandler, all_fhandler):
-        fhandler.setFormatter(formatter)
-        base_logger.addHandler(fhandler)
diff --git a/tuxbot/setup.py b/tuxbot/setup.py
index 9e2e7d7..6d13e0f 100644
--- a/tuxbot/setup.py
+++ b/tuxbot/setup.py
@@ -155,14 +155,14 @@ def get_token() -> str:
 
 
 def get_multiple(question: str, confirmation: str, value_type: type)\
-        -> Set[Union[str, int]]:
+        -> List[Union[str, int]]:
     print(question)
     values = [value_type(input('> '))]
 
     while click.confirm(confirmation, default=False):
         values.append(value_type(input('> ')))
 
-    return set(values)
+    return values
 
 
 def additional_config() -> dict: