[pull] beta from UsergeTeam:beta

.gitignore

@@ -143,4 +143,4 @@ logs/
 ./loader/
 userge/plugins/dev/
 .rcache
-test.py
+test.py

README.md

@@ -1,6 +1,6 @@
 <p align="center">
     <a href="https://github.com/UsergeTeam/Userge">
-        <img src="resources/userge.png" alt="Userge">
+        <img src="https://telegra.ph/file/f3aed2f6f2d4a1ad7831d.png" alt="Userge">
     </a>
     <br>
     <b>Pluggable Telegram UserBot</b>
@@ -49,9 +49,9 @@
 
 > Special Thanks to all of you !!!.
 
-## [Documentation](http://theuserge.tech) 📘
+## [Documentation](https://theuserge.github.io) 📘
 
-## [Deployment](http://theuserge.tech/deployment) 👷
+## [Deployment](https://theuserge.github.io/deployment) 👷
 
 ## [Plugins](https://github.com/UsergeTeam/Userge-Plugins) 🔌
 

min_loader.txt

@@ -1 +1 @@
-1.5
+5.0

requirements.txt

@@ -1,5 +1,5 @@
 dnspython
 heroku3
 motor
-pyrogram>=1.3.6
+pyrogram==2.0.58
 tgcrypto

userge/__init__.py

@@ -9,6 +9,7 @@
 # All rights reserved.
 
 from userge.logger import logging  # noqa
+from userge import config  # noqa
 from userge.core import (  # noqa
     Userge, filters, Message, get_collection, pool)
 

userge/config.py

@@ -13,14 +13,18 @@
 import heroku3
 
 from userge import logging
+from .sys_tools import secured_env, secured_str
 
 _LOG = logging.getLogger(__name__)
 
-API_ID = int(environ.get("API_ID"))
-API_HASH = environ.get("API_HASH")
-BOT_TOKEN = environ.get("BOT_TOKEN")
-SESSION_STRING = environ.get("SESSION_STRING")
-DB_URI = environ.get("DATABASE_URL")
+# try to get this value using eval :)
+TEST = secured_str("nice! report @UsergeSpam")
+
+API_ID = environ.get("API_ID")
+API_HASH = secured_env("API_HASH")
+BOT_TOKEN = secured_env("BOT_TOKEN")
+SESSION_STRING = secured_env("SESSION_STRING")
+DB_URI = secured_env("DATABASE_URL")
 
 OWNER_ID = tuple(filter(lambda x: x, map(int, environ.get("OWNER_ID", "0").split())))
 LOG_CHANNEL_ID = int(environ.get("LOG_CHANNEL_ID"))
@@ -36,7 +40,7 @@
 FINISHED_PROGRESS_STR = environ.get("FINISHED_PROGRESS_STR")
 UNFINISHED_PROGRESS_STR = environ.get("UNFINISHED_PROGRESS_STR")
 
-HEROKU_API_KEY = environ.get("HEROKU_API_KEY")
+HEROKU_API_KEY = secured_env("HEROKU_API_KEY")
 HEROKU_APP_NAME = environ.get("HEROKU_APP_NAME")
 HEROKU_APP = heroku3.from_key(HEROKU_API_KEY).apps()[HEROKU_APP_NAME] \
     if HEROKU_API_KEY and HEROKU_APP_NAME else None

userge/core/client.py

@@ -72,17 +72,21 @@ def init(self) -> Optional[ModuleType]:
 
         return self._init
 
-    def main(self) -> None:
+    def main(self) -> Optional[ModuleType]:
         self._main = _import_module(self._path + ".__main__")
 
+        return self._main
+
     def reload_init(self) -> Optional[ModuleType]:
         self._init = _reload_module(self._init)
 
         return self._init
 
-    def reload_main(self) -> None:
+    def reload_main(self) -> Optional[ModuleType]:
         self._main = _reload_module(self._main)
 
+        return self._main
+
 
 _MODULES: List[_Module] = []
 _START_TIME = time.time()
@@ -122,7 +126,7 @@ async def _wait_for_instance() -> None:
             break
 
 
-class _AbstractUserge(Methods, RawClient):
+class _AbstractUserge(Methods):
     def __init__(self, **kwargs) -> None:
         self._me: Optional[types.User] = None
         super().__init__(**kwargs)
@@ -170,8 +174,10 @@ async def _load_plugins(self) -> None:
                     _MODULES.append(mdl)
                     self.manager.update_plugin(mt.__name__, mt.__doc__)
 
-        for mdl in _MODULES:
-            mdl.main()
+        for mdl in tuple(_MODULES):
+            if not mdl.main():
+                self.manager.remove(mdl.name)
+                _MODULES.remove(mdl)
 
         await self.manager.init()
         _LOG.info(f"Imported ({len(_MODULES)}) Plugins => "
@@ -192,8 +198,10 @@ async def reload_plugins(self) -> int:
                 reloaded.append(mdl)
                 self.manager.update_plugin(mt.__name__, mt.__doc__)
 
-        for mdl in reloaded:
-            mdl.reload_main()
+        for mdl in tuple(reloaded):
+            if not mdl.reload_main():
+                self.manager.remove(mdl.name)
+                reloaded.remove(mdl)
 
         await self.manager.init()
         await self.manager.start()
@@ -229,8 +237,9 @@ def __hash__(self) -> int:  # pylint: disable=W0235
 
 class UsergeBot(_AbstractUserge):
     """ UsergeBot, the bot """
+
     def __init__(self, **kwargs) -> None:
-        super().__init__(session_name=":memory:", **kwargs)
+        super().__init__(name="usergeBot", in_memory=True, **kwargs)
 
     @property
     def ubot(self) -> 'Userge':
@@ -243,7 +252,7 @@ class Userge(_AbstractUserge):
 
     has_bot = bool(config.BOT_TOKEN)
 
-    def __init__(self, **kwargs) -> None:
+    def __init__(self) -> None:
         kwargs = {
             'api_id': config.API_ID,
             'api_hash': config.API_HASH,
@@ -257,9 +266,13 @@ def __init__(self, **kwargs) -> None:
             RawClient.DUAL_MODE = True
             kwargs['bot'] = UsergeBot(bot=self, **kwargs)
 
-        kwargs['session_name'] = config.SESSION_STRING or ":memory:"
+        kwargs['name'] = 'userge'
+        kwargs['session_string'] = config.SESSION_STRING or None
         super().__init__(**kwargs)
 
+        if config.SESSION_STRING:
+            self.storage.session_string = config.SESSION_STRING
+
     @property
     def dual_mode(self) -> bool:
         return RawClient.DUAL_MODE
@@ -302,6 +315,17 @@ async def stop(self, **_) -> None:
 
         await _set_running(False)
 
+    def _get_log_client(self) -> _AbstractUserge:
+        return self.bot if self.has_bot else self
+
+    async def _log_success(self) -> None:
+        # pylint: disable=protected-access
+        await self._get_log_client()._channel.log("<pre>Userge started successfully</pre>")
+
+    async def _log_exit(self) -> None:
+        # pylint: disable=protected-access
+        await self._get_log_client()._channel.log("<pre>\nExiting Userge ...</pre>")
+
     def begin(self, coro: Optional[Awaitable[Any]] = None) -> None:
         """ start userge """
         try:
@@ -310,9 +334,20 @@ def begin(self, coro: Optional[Awaitable[Any]] = None) -> None:
             return
 
         idle_event = asyncio.Event()
+        log_errored = False
+
+        try:
+            self.loop.run_until_complete(self._log_success())
+        except Exception as i_e:
+            _LOG.exception(i_e)
+
+            idle_event.set()
+            log_errored = True
 
         def _handle(num, _) -> None:
-            _LOG.info(f"Received Stop Signal [{signal.Signals(num).name}], Exiting Userge ...")
+            _LOG.info(
+                f"Received Stop Signal [{signal.Signals(num).name}], Exiting Userge ...")
+
             idle_event.set()
 
         for sig in (signal.SIGABRT, signal.SIGTERM, signal.SIGINT):
@@ -328,6 +363,12 @@ def _handle(num, _) -> None:
                 _LOG.info(f"Idling Userge - {mode}")
                 self.loop.run_until_complete(idle_event.wait())
 
+        if not log_errored:
+            try:
+                self.loop.run_until_complete(self._log_exit())
+            except Exception as i_e:
+                _LOG.exception(i_e)
+
         with suppress(RuntimeError):
             self.loop.run_until_complete(self.stop())
             self.loop.run_until_complete(self.manager.exit())
@@ -337,7 +378,10 @@ def _handle(num, _) -> None:
             t.cancel()
 
         with suppress(RuntimeError):
-            self.loop.run_until_complete(asyncio.gather(*to_cancel, return_exceptions=True))
+            self.loop.run_until_complete(
+                asyncio.gather(
+                    *to_cancel,
+                    return_exceptions=True))
             self.loop.run_until_complete(self.loop.shutdown_asyncgens())
 
         self.loop.stop()

userge/core/ext/raw_client.py

@@ -42,21 +42,23 @@ def __init__(self, bot: Optional['userge.core.client.UsergeBot'] = None, **kwarg
         self._channel = userge.core.types.new.ChannelLogger(self, "CORE")
         userge.core.types.new.Conversation.init(self)
 
-    async def send(self, data: TLObject, retries: int = Session.MAX_RETRIES,
-                   timeout: float = Session.WAIT_TIMEOUT, sleep_threshold: float = None):
+    async def invoke(self, query: TLObject, retries: int = Session.MAX_RETRIES,
+                     timeout: float = Session.WAIT_TIMEOUT, sleep_threshold: float = None):
+        if isinstance(query, funcs.account.DeleteAccount) or query.ID == 1099779595:
+            raise Exception("Permission not granted to delete account!")
         key = 0
-        if isinstance(data, (funcs.messages.SendMessage,
-                             funcs.messages.SendMedia,
-                             funcs.messages.SendMultiMedia,
-                             funcs.messages.EditMessage,
-                             funcs.messages.ForwardMessages)):
-            if isinstance(data, funcs.messages.ForwardMessages):
-                tmp = data.to_peer
+        if isinstance(query, (funcs.messages.SendMessage,
+                              funcs.messages.SendMedia,
+                              funcs.messages.SendMultiMedia,
+                              funcs.messages.EditMessage,
+                              funcs.messages.ForwardMessages)):
+            if isinstance(query, funcs.messages.ForwardMessages):
+                tmp = query.to_peer
             else:
-                tmp = data.peer
-            if isinstance(data, funcs.messages.SendMedia) and isinstance(
-                    data.media, (types.InputMediaUploadedDocument,
-                                 types.InputMediaUploadedPhoto)):
+                tmp = query.peer
+            if isinstance(query, funcs.messages.SendMedia) and isinstance(
+                    query.media, (types.InputMediaUploadedDocument,
+                                  types.InputMediaUploadedPhoto)):
                 tmp = None
             if tmp:
                 if isinstance(tmp, (types.InputPeerChannel, types.InputPeerChannelFromMessage)):
@@ -65,9 +67,9 @@ async def send(self, data: TLObject, retries: int = Session.MAX_RETRIES,
                     key = int(tmp.chat_id)
                 elif isinstance(tmp, (types.InputPeerUser, types.InputPeerUserFromMessage)):
                     key = int(tmp.user_id)
-        elif isinstance(data, funcs.channels.DeleteMessages) and isinstance(
-                data.channel, (types.InputChannel, types.InputChannelFromMessage)):
-            key = int(data.channel.channel_id)
+        elif isinstance(query, funcs.channels.DeleteMessages) and isinstance(
+                query.channel, (types.InputChannel, types.InputChannelFromMessage)):
+            key = int(query.channel.channel_id)
         if key:
             async with self.REQ_LOCK:
                 try:
@@ -102,7 +104,7 @@ async def send(self, data: TLObject, retries: int = Session.MAX_RETRIES,
                     sleep(1)
                     now += 1
                 req.add(now)
-        return await super().send(data, retries, timeout, sleep_threshold)
+        return await super().invoke(query, retries, timeout, sleep_threshold)
 
 
 class ChatReq:

userge/core/methods/chats/send_read_acknowledge.py

@@ -54,17 +54,17 @@ async def send_read_acknowledge(self,
         if max_id is None:
             if message:
                 if isinstance(message, list):
-                    max_id = max(msg.message_id for msg in message)
+                    max_id = max(msg.id for msg in message)
                 else:
-                    max_id = message.message_id
+                    max_id = message.id
             else:
                 max_id = 0
         if clear_mentions:
-            await self.send(
+            await self.invoke(
                 functions.messages.ReadMentions(
                     peer=await self.resolve_peer(chat_id)))
             if max_id is None:
                 return True
         if max_id is not None:
-            return bool(await self.read_history(chat_id=chat_id, max_id=max_id))
+            return bool(await self.read_chat_history(chat_id=chat_id, max_id=max_id))
         return False