performance fixes

requirements.txt

@@ -12,12 +12,12 @@ google-auth-oauthlib
 googletrans
 hachoir==3.1.1
 heroku3
+motor
 nest_asyncio
 oauth2client
 Pillow
 psutil
 pybase64
-pymongo
 pySmartDL
 python-dotenv
 pytz

userge/core/client.py

@@ -28,6 +28,7 @@
 class Userge(Methods):
     """Userge, the userbot"""
     def __init__(self) -> None:
+        self._tmp_tasks: List[asyncio.Task] = []
         self._imported: List[ModuleType] = []
         _LOG.info(_LOG_STR, "Setting Userge Configs")
         super().__init__(client=self,
@@ -41,24 +42,32 @@ def getLogger(name: str) -> logging.Logger:
         _LOG.debug(_LOG_STR, f"Creating Logger => {name}")
         return logging.getLogger(name)
 
-    def load_plugin(self, name: str) -> None:
+    async def load_plugin(self, name: str) -> None:
         """Load plugin to Userge"""
         _LOG.debug(_LOG_STR, f"Importing {name}")
         self._imported.append(
             importlib.import_module(f"userge.plugins.{name}"))
+        if hasattr(self._imported[-1], '_init'):
+            tmp_func = getattr(self._imported[-1], '_init')
+            if asyncio.iscoroutinefunction(tmp_func):
+                self._tmp_tasks.append(asyncio.get_event_loop().create_task(tmp_func()))
         _LOG.debug(_LOG_STR, f"Imported {self._imported[-1].__name__} Plugin Successfully")
 
-    def load_plugins(self) -> None:
-        """Load all Plugins"""
+    async def _load_plugins(self) -> None:
         self._imported.clear()
+        self._tmp_tasks.clear()
         _LOG.info(_LOG_STR, "Importing All Plugins")
         for name in get_all_plugins():
             try:
-                self.load_plugin(name)
+                await self.load_plugin(name)
             except ImportError as i_e:
                 _LOG.error(_LOG_STR, i_e)
         _LOG.info(_LOG_STR, f"Imported ({len(self._imported)}) Plugins => "
                   + str([i.__name__ for i in self._imported]))
+        await asyncio.gather(
+            asyncio.gather(*self._tmp_tasks),
+            self.manager.init())
+        self._tmp_tasks.clear()
 
     async def reload_plugins(self) -> int:
         """Reload all Plugins"""
@@ -73,6 +82,7 @@ async def reload_plugins(self) -> int:
             else:
                 reloaded.append(reloaded_.__name__)
         _LOG.info(_LOG_STR, f"Reloaded {len(reloaded)} Plugins => {reloaded}")
+        # await self.manager.init()
         return len(reloaded)
 
     async def restart(self, update_req: bool = False) -> None:
@@ -98,6 +108,7 @@ def begin(self) -> None:
         run = loop.run_until_complete
         _LOG.info(_LOG_STR, "Starting Userge")
         run(self.start())
+        run(self._load_plugins())
         running_tasks: List[asyncio.Task] = []
         for task in self._tasks:
             running_tasks.append(loop.create_task(task()))

userge/core/database.py

@@ -8,8 +8,10 @@
 
 __all__ = ['get_collection']
 
-from pymongo import MongoClient
-from pymongo.collection import Collection
+import asyncio
+
+from motor.motor_asyncio import AsyncIOMotorClient
+from motor.core import AgnosticClient, AgnosticDatabase, AgnosticCollection
 
 from userge import logging, Config
 
@@ -18,19 +20,20 @@
 
 _LOG.info(_LOG_STR, "Connecting to Database...")
 
-_MGCLIENT = MongoClient(Config.DB_URI)
+_MGCLIENT: AgnosticClient = AsyncIOMotorClient(Config.DB_URI)
+_RUN = asyncio.get_event_loop().run_until_complete
 
-if "Userge" in _MGCLIENT.list_database_names():
+if "Userge" in _RUN(_MGCLIENT.list_database_names()):
     _LOG.info(_LOG_STR, "Userge Database Found :) => Now Logging to it...")
 else:
     _LOG.info(_LOG_STR, "Userge Database Not Found :( => Creating New Database...")
 
-_DATABASE = _MGCLIENT["Userge"]
+_DATABASE: AgnosticDatabase = _MGCLIENT["Userge"]
 
 
-def get_collection(name: str) -> Collection:
+def get_collection(name: str) -> AgnosticCollection:
     """Create or Get Collection from your database"""
-    if name in _DATABASE.list_collection_names():
+    if name in _RUN(_DATABASE.list_collection_names()):
         _LOG.debug(_LOG_STR, f"{name} Collection Found :) => Now Logging to it...")
     else:
         _LOG.debug(_LOG_STR, f"{name} Collection Not Found :( => Creating New Collection...")

userge/core/ext/manager.py

@@ -8,6 +8,7 @@
 
 __all__ = ['Manager']
 
+import asyncio
 from typing import Union, List, Dict
 
 from ..types import Plugin, Filtr, Command, clear_db
@@ -91,6 +92,10 @@ def unloaded_plugins(self) -> List[Plugin]:
         """returns all unloaded plugins"""
         return [plg for _, plg in self.plugins.items() if not plg.is_loaded]
 
+    async def init(self) -> None:
+        """initialize all plugins"""
+        await asyncio.gather(*[plg.init() for _, plg in self.plugins.items()])
+
     def add_plugin(self, client: '_client.Userge',
                    name: str, about: str = '') -> Plugin:
         """add plugin to manager"""
@@ -104,115 +109,115 @@ def clear_plugins(self) -> None:
         """clear all plugins"""
         self.plugins.clear()
 
-    def enable_commands(self, commands: List[str]) -> List[str]:
+    async def enable_commands(self, commands: List[str]) -> List[str]:
         """enable list of commands"""
         enabled: List[str] = []
         for cmd_name in list(set(commands).intersection(set(self.commands))):
-            ret = self.commands[cmd_name].enable()
+            ret = await self.commands[cmd_name].enable()
             if ret:
                 enabled.append(ret)
         return enabled
 
-    def disable_commands(self, commands: List[str]) -> List[str]:
+    async def disable_commands(self, commands: List[str]) -> List[str]:
         """disable list of commands"""
         disabled: List[str] = []
         for cmd_name in list(set(commands).intersection(set(self.commands))):
-            ret = self.commands[cmd_name].disable()
+            ret = await self.commands[cmd_name].disable()
             if ret:
                 disabled.append(ret)
         return disabled
 
-    def load_commands(self, commands: List[str]) -> List[str]:
+    async def load_commands(self, commands: List[str]) -> List[str]:
         """load list of commands"""
         loaded: List[str] = []
         for cmd_name in list(set(commands).intersection(set(self.commands))):
-            ret = self.commands[cmd_name].load()
+            ret = await self.commands[cmd_name].load()
             if ret:
                 loaded.append(ret)
         return loaded
 
-    def unload_commands(self, commands: List[str]) -> List[str]:
+    async def unload_commands(self, commands: List[str]) -> List[str]:
         """unload list of commands"""
         unloaded: List[str] = []
         for cmd_name in list(set(commands).intersection(set(self.commands))):
-            ret = self.commands[cmd_name].unload()
+            ret = await self.commands[cmd_name].unload()
             if ret:
                 unloaded.append(ret)
         return unloaded
 
-    def enable_filters(self, filters: List[str]) -> List[str]:
+    async def enable_filters(self, filters: List[str]) -> List[str]:
         """enable list of filters"""
         enabled: List[str] = []
         for flt_name in list(set(filters).intersection(set(self.filters))):
-            ret = self.filters[flt_name].enable()
+            ret = await self.filters[flt_name].enable()
             if ret:
                 enabled.append(ret)
         return enabled
 
-    def disable_filters(self, filters: List[str]) -> List[str]:
+    async def disable_filters(self, filters: List[str]) -> List[str]:
         """disable list of filters"""
         disabled: List[str] = []
         for flt_name in list(set(filters).intersection(set(self.filters))):
-            ret = self.filters[flt_name].disable()
+            ret = await self.filters[flt_name].disable()
             if ret:
                 disabled.append(ret)
         return disabled
 
-    def load_filters(self, filters: List[str]) -> List[str]:
+    async def load_filters(self, filters: List[str]) -> List[str]:
         """load list of filters"""
         loaded: List[str] = []
         for flt_name in list(set(filters).intersection(set(self.filters))):
-            ret = self.filters[flt_name].load()
+            ret = await self.filters[flt_name].load()
             if ret:
                 loaded.append(ret)
         return loaded
 
-    def unload_filters(self, filters: List[str]) -> List[str]:
+    async def unload_filters(self, filters: List[str]) -> List[str]:
         """unload list of filters"""
         unloaded: List[str] = []
         for flt_name in list(set(filters).intersection(set(self.filters))):
-            ret = self.filters[flt_name].unload()
+            ret = await self.filters[flt_name].unload()
             if ret:
                 unloaded.append(ret)
         return unloaded
 
-    def enable_plugins(self, plugins: List[str]) -> Dict[str, List[str]]:
+    async def enable_plugins(self, plugins: List[str]) -> Dict[str, List[str]]:
         """enable list of plugins"""
         enabled: Dict[str, List[str]] = {}
         for plg_name in list(set(plugins).intersection(set(self.plugins))):
-            ret = self.plugins[plg_name].enable()
+            ret = await self.plugins[plg_name].enable()
             if ret:
                 enabled.update({plg_name: ret})
         return enabled
 
-    def disable_plugins(self, plugins: List[str]) -> Dict[str, List[str]]:
+    async def disable_plugins(self, plugins: List[str]) -> Dict[str, List[str]]:
         """disable list of plugins"""
         disabled: Dict[str, List[str]] = {}
         for plg_name in list(set(plugins).intersection(set(self.plugins))):
-            ret = self.plugins[plg_name].disable()
+            ret = await self.plugins[plg_name].disable()
             if ret:
                 disabled.update({plg_name: ret})
         return disabled
 
-    def load_plugins(self, plugins: List[str]) -> Dict[str, List[str]]:
+    async def load_plugins(self, plugins: List[str]) -> Dict[str, List[str]]:
         """load list of plugins"""
         loaded: Dict[str, List[str]] = {}
         for plg_name in list(set(plugins).intersection(set(self.plugins))):
-            ret = self.plugins[plg_name].load()
+            ret = await self.plugins[plg_name].load()
             if ret:
                 loaded.update({plg_name: ret})
         return loaded
 
-    def unload_plugins(self, plugins: List[str]) -> Dict[str, List[str]]:
+    async def unload_plugins(self, plugins: List[str]) -> Dict[str, List[str]]:
         """unload list of plugins"""
         unloaded: Dict[str, List[str]] = {}
         for plg_name in list(set(plugins).intersection(set(self.plugins))):
-            ret = self.plugins[plg_name].unload()
+            ret = await self.plugins[plg_name].unload()
             if ret:
                 unloaded.update({plg_name: ret})
         return unloaded
 
     @staticmethod
-    def clear() -> bool:
+    async def clear() -> bool:
         """clear all filters in database"""
-        return bool(clear_db())
+        return bool(await clear_db())

userge/core/methods/decorators.py

@@ -166,6 +166,5 @@ async def template(_: RawClient, __: RawMessage) -> None:
                 flt.update_command(handler, func.__doc__)
             else:
                 flt.update_filter(f"{module_name }.{func.__name__}", func.__doc__, handler)
-            flt.init()
             return func
         return decorator