rework startup

ubot/__init__.py

@@ -1,3 +1,4 @@
+import asyncio
 import sys
 from logging import INFO, basicConfig, getLogger
 from time import time
@@ -18,60 +19,64 @@ if sys.version_info.major < 3 or (sys.version_info.major == 3 and sys.version_in
     sys.exit(1)
 
 startup_time = time()
+loop = asyncio.get_event_loop()
+logger = getLogger(__name__)
 
 
 class MicroBot():
-    client = None
     settings = Settings()
+    client = None
     logger = None
     loader = None
 
     def __init__(self):
         basicConfig(format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", level=INFO)
-        self.logger = getLogger(__name__)
+        loop.run_until_complete(self._initialize_bot())
-        self.start_client()
-        self.loader = Loader(self.client, self.logger, self.settings)
 
-    async def run_until_done(self):
+    async def _initialize_bot(self):
-        self.loader.load_all_modules()
+        global ldr
-        self.logger.info("Bot successfully started.")
+        global micro_bot
-        await self.client.run_until_disconnected()
-        await self.stop_client(reason="Bot disconnected.")
 
-    def start_client(self):
         try:
-            self.client = telethon.TelegramClient(
+            self.client = await telethon.TelegramClient(
                 self.settings.get_config("session_name", "bot0") or "bot0",
                 self.settings.get_config("api_id"),
                 self.settings.get_config("api_hash"),
                 connection=CTA
-                ).start(
+            ).start(
-                    bot_token=self.settings.get_config("bot_token")
+                bot_token=self.settings.get_config("bot_token")
-                )
+            )
+
+            self.me = await self.client.get_me()
         except (TokenInvalidError, AccessTokenExpiredError, AccessTokenInvalidError):
-            self.logger.error("The bot token provided is invalid, exiting.")
+            logger.error("The bot token provided is invalid, exiting.")
             sys.exit(1)
 
+        self.me = await self.client.get_me()
+        self.loader = Loader(self)
+        ldr = self.loader
+        micro_bot = self
+        self.loader.load_all_modules()
+        logger.info("Bot successfully started.")
+
+    async def run_until_done(self):
+        await self.client.run_until_disconnected()
+        await self.stop_client(reason="Bot disconnected.")
+
     async def stop_client(self, reason=None, exit_code=None):
         if reason:
-            self.logger.info("Stopping bot for reason: %s", reason)
+            logger.info("Stopping bot for reason: %s", reason)
         else:
-            self.logger.info("Stopping bot.")
+            logger.info("Stopping bot.")
 
         await self.loader.aioclient.close()
 
         if exit_code is not None:
-            self.logger.info("Exiting with exit code: %i", exit_code)
+            logger.info("Exiting with exit code: %i", exit_code)
             sys.exit(exit_code)
         else:
             sys.exit(0)
 
 
 telethon.events.NewMessage.Event = ExtendedEvent
-
+loop.run_until_complete(MicroBot().run_until_done())
-micro_bot = MicroBot()
-ldr = micro_bot.loader
-client = micro_bot.client
-logger = micro_bot.logger
-
-client.loop.run_until_complete(micro_bot.run_until_done())

ubot/command_handler.py

@@ -21,16 +21,16 @@ class CommandHandler():
     inline_article_commands = []
     callback_queries = []
 
-    def __init__(self, client, settings, loader, logger):
+    def __init__(self, loader):
-        self.username = client.loop.run_until_complete(client.get_me()).username
-        self.settings = settings
         self.loader = loader
+        self.micro_bot = loader.micro_bot
+        self.settings = self.micro_bot.settings
+        self.logger = loader.logger
         self.db = loader.db
-        self.logger = logger
         self.hard_prefix = self.settings.get_list("hard_cmd_prefix") or ["/"]
-        client.add_event_handler(self.report_incoming_excepts, events.NewMessage(incoming=True, forwards=False, func=lambda e: e.raw_text))
+        self.micro_bot.client.add_event_handler(self.report_incoming_excepts, events.NewMessage(incoming=True, forwards=False, func=lambda e: e.raw_text))
-        client.add_event_handler(self.handle_inline, events.InlineQuery())
+        self.micro_bot.client.add_event_handler(self.handle_inline, events.InlineQuery())
-        client.add_event_handler(self.handle_callback_query, events.CallbackQuery())
+        self.micro_bot.client.add_event_handler(self.handle_callback_query, events.CallbackQuery())
 
     async def report_incoming_excepts(self, event):
         try:
@@ -54,7 +54,7 @@ class CommandHandler():
                 else:
                     prefix_list = self.hard_prefix + [chat_prefix]
 
-                pattern_match = search(self.pattern_template.format(f"({'|'.join([escape(i) for i in prefix_list])})", command.pattern + command.pattern_extra, self.username), event.raw_text, IGNORECASE|DOTALL)
+                pattern_match = search(self.pattern_template.format(f"({'|'.join([escape(i) for i in prefix_list])})", command.pattern + command.pattern_extra, self.micro_bot.me.username), event.raw_text, IGNORECASE|DOTALL)
 
             if pattern_match:
                 if not (priv_resp := await self.check_privs(event, command, chat_db))[0]:

ubot/loader.py

@@ -23,11 +23,11 @@ class Loader():
     loaded_modules = []
     all_modules = []
 
-    def __init__(self, client, logger, settings):
+    def __init__(self, micro_bot):
-        self.client = client
+        self.micro_bot = micro_bot
-        self.logger = logger
+        self.settings = micro_bot.settings
-        self.settings = settings
+        self.logger = micro_bot.logger
-        self.command_handler = CommandHandler(client, settings, self, logger)
+        self.command_handler = CommandHandler(self)
 
     def load_all_modules(self):
         self._find_all_modules()
@@ -135,10 +135,10 @@ class Loader():
         return [i for i in self.command_handler.callback_queries if i.function == func]
 
     async def run_async(self, function, *args):
-        return await self.client.loop.run_in_executor(self.thread_pool, partial(function, *args))
+        return await self.micro_bot.client.loop.run_in_executor(self.thread_pool, partial(function, *args))
 
     def prefix(self):
-        return ", ".join(self.settings.get_list("hard_cmd_prefix") or ["/"])
+        return ", ".join(self.micro_bot.settings.get_list("hard_cmd_prefix") or ["/"])
 
     def _find_all_modules(self):
         module_paths = glob.glob(dirname(__file__) + "/modules/*.py")

ubot/modules/_sudo.py

@@ -13,7 +13,7 @@ import psutil
 from telethon import version
 from telethon.tl.types import Channel, Chat
 
-from ubot import ldr, micro_bot, startup_time
+from ubot import ldr, startup_time
 
 
 @ldr.add("eval", owner=True, hide_help=True)
@@ -165,9 +165,9 @@ async def shutdown(event):
     await event.reply("Goodbye…")
 
     if event.other_args[0]:
-        await micro_bot.stop_client(reason="Shutdown command issued.", exit_code=1)
+        await ldr.micro_bot.stop_client(reason="Shutdown command issued.", exit_code=1)
     else:
-        await micro_bot.stop_client(reason="Shutdown command issued.")
+        await ldr.micro_bot.stop_client(reason="Shutdown command issued.")
 
 
 @ldr.add("blacklist", sudo=True, hide_help=True)

ubot/modules/booru.py

@@ -1,5 +1,6 @@
-from re import compile
 from random import choice
+from re import compile
+
 from asyncbooru import Danbooru, Gelbooru, Konachan, Sankaku, Yandere
 from telethon import Button
 

ubot/modules/scrapers.py

@@ -2,6 +2,7 @@ import io
 import re
 
 from PIL import Image
+
 from ubot import ldr
 
 

ubot/modules/system.py

@@ -1,6 +1,7 @@
 from time import time_ns
 
 from telethon import Button
+
 from ubot import ldr