spluspy 2.1.13__tar.gz → 2.2.1__tar.gz

{spluspy-2.1.13 → spluspy-2.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spluspy
-Version: 2.1.13
+Version: 2.2.1
 Summary: A modern async Python library for interacting with Soroush Plus
 Project-URL: Homepage, https://github.com/Itskillmaster/spluspy
 Project-URL: Documentation, https://github.com/Itskillmaster/spluspy#readme

{spluspy-2.1.13 → spluspy-2.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "spluspy"
-version = "2.1.13"
+version = "2.2.1"
 description = "A modern async Python library for interacting with Soroush Plus"
 readme = "README.md"
 license = "MIT"

{spluspy-2.1.13 → spluspy-2.2.1}/spluspy/__init__.py

@@ -71,6 +71,7 @@ from spluspy.network.protocols import IAdapter, ITransport, IStorage, IEventDisp
 from spluspy.network.spluspy_adapter import BaseAdapter, SpluspyAdapter, TelethonAdapter, create_adapter
 from spluspy.utils.logger import (
     setup_logging,
+    setup_errors_only_logging,
     get_logger,
     set_level,
     log,
@@ -157,6 +158,7 @@ __all__ = [
     "MessageMirror",
     "MessageScheduler",
     "setup_logging",
+    "setup_errors_only_logging",
     "get_logger",
     "set_level",
     "log",

{spluspy-2.1.13 → spluspy-2.2.1}/spluspy/__version__.py

@@ -1,6 +1,6 @@
 """SplusPy version information."""
 
-__version__ = "2.1.13"
+__version__ = "2.2.1"
 __author__ = "Ali Mirshekari"
 __license__ = "MIT"
 __url__ = "https://github.com/Itskillmaster/spluspy"

{spluspy-2.1.13 → spluspy-2.2.1}/spluspy/_engine/client/__init__.py

@@ -1,25 +1,25 @@
-"""
-This package defines clients as subclasses of others, and then a single
-`spluspy.client.soroushclient.SoroushClient` which is subclass of them
-all to provide the final unified interface while the methods can live in
-different subclasses to be more maintainable.
-
-The ABC is `spluspy.client.telegrambaseclient.SoroushPlusBaseClient` and the
-first implementor is `spluspy.client.users.UserMethods`, since calling
-requests require them to be resolved first, and that requires accessing
-entities (users).
-"""
-from .telegrambaseclient import SoroushPlusBaseClient
-from .users import UserMethods  # Required for everything
-from .messageparse import MessageParseMethods  # Required for messages
-from .uploads import UploadMethods  # Required for messages to send files
-from .updates import UpdateMethods  # Required for buttons (register callbacks)
-from .buttons import ButtonMethods  # Required for messages to use buttons
-from .messages import MessageMethods
-from .chats import ChatMethods
-from .dialogs import DialogMethods
-from .downloads import DownloadMethods
-from .account import AccountMethods
-from .auth import AuthMethods
-from .bots import BotMethods
-from .soroushclient import SoroushClient
+"""
+This package defines clients as subclasses of others, and then a single
+`spluspy.client.soroushclient.SoroushClient` which is subclass of them
+all to provide the final unified interface while the methods can live in
+different subclasses to be more maintainable.
+
+The ABC is `spluspy.client.telegrambaseclient.SoroushPlusBaseClient` and the
+first implementor is `spluspy.client.users.UserMethods`, since calling
+requests require them to be resolved first, and that requires accessing
+entities (users).
+"""
+from .telegrambaseclient import SoroushPlusBaseClient
+from .users import UserMethods  # Required for everything
+from .messageparse import MessageParseMethods  # Required for messages
+from .uploads import UploadMethods  # Required for messages to send files
+from .updates import UpdateMethods  # Required for buttons (register callbacks)
+from .buttons import ButtonMethods  # Required for messages to use buttons
+from .messages import MessageMethods
+from .chats import ChatMethods
+from .dialogs import DialogMethods
+from .downloads import DownloadMethods
+from .account import AccountMethods
+from .auth import AuthMethods
+from .bots import BotMethods
+from .soroushclient import SoroushClient

{spluspy-2.1.13 → spluspy-2.2.1}/spluspy/_engine/client/account.py

@@ -1,247 +1,247 @@
-import functools
-import inspect
-import logging
-import typing
-
-from .users import _NOT_A_REQUEST
-from .. import helpers, utils
-from ..tl import functions, TLRequest
-
-_log = logging.getLogger(__name__)
-
-if typing.TYPE_CHECKING:
-    from .soroushclient import SoroushClient
-
-
-# TODO Make use of :tl:`InvokeWithMessagesRange` somehow
-#      For that, we need to use :tl:`GetSplitRanges` first.
-class _TakeoutClient:
-    """
-    Proxy object over the client.
-    """
-    __PROXY_INTERFACE = ('__enter__', '__exit__', '__aenter__', '__aexit__')
-
-    def __init__(self, finalize, client, request):
-        # We use the name mangling for attributes to make them inaccessible
-        # from within the shadowed client object and to distinguish them from
-        # its own attributes where needed.
-        self.__finalize = finalize
-        self.__client = client
-        self.__request = request
-        self.__success = None
-
-    @property
-    def success(self):
-        return self.__success
-
-    @success.setter
-    def success(self, value):
-        self.__success = value
-
-    async def __aenter__(self):
-        # Enter/Exit behaviour is "overrode", we don't want to call start.
-        client = self.__client
-        if client.session.takeout_id is None:
-            client.session.takeout_id = (await client(self.__request)).id
-        elif self.__request is not None:
-            raise ValueError("Can't send a takeout request while another "
-                "takeout for the current session still not been finished yet.")
-        return self
-
-    async def __aexit__(self, exc_type, exc_value, traceback):
-        if self.__success is None and self.__finalize:
-            self.__success = exc_type is None
-
-        if self.__success is not None:
-            result = await self(functions.account.FinishTakeoutSessionRequest(
-                self.__success))
-            if not result:
-                raise ValueError("Failed to finish the takeout.")
-            self.session.takeout_id = None
-
-    __enter__ = helpers._sync_enter
-    __exit__ = helpers._sync_exit
-
-    async def __call__(self, request, ordered=False):
-        takeout_id = self.__client.session.takeout_id
-        if takeout_id is None:
-            raise ValueError('Takeout mode has not been initialized '
-                '(are you calling outside of "with"?)')
-
-        single = not utils.is_list_like(request)
-        requests = ((request,) if single else request)
-        wrapped = []
-        for r in requests:
-            if not isinstance(r, TLRequest):
-                raise _NOT_A_REQUEST()
-            await r.resolve(self, utils)
-            wrapped.append(functions.InvokeWithTakeoutRequest(takeout_id, r))
-
-        return await self.__client(
-            wrapped[0] if single else wrapped, ordered=ordered)
-
-    def __getattribute__(self, name):
-        # We access class via type() because __class__ will recurse infinitely.
-        # Also note that since we've name-mangled our own class attributes,
-        # they'll be passed to __getattribute__() as already decorated. For
-        # example, 'self.__client' will be passed as '_TakeoutClient__client'.
-        # https://docs.python.org/3/tutorial/classes.html#private-variables
-        if name.startswith('__') and name not in type(self).__PROXY_INTERFACE:
-            raise AttributeError  # force call of __getattr__
-
-        # Try to access attribute in the proxy object and check for the same
-        # attribute in the shadowed object (through our __getattr__) if failed.
-        return super().__getattribute__(name)
-
-    def __getattr__(self, name):
-        value = getattr(self.__client, name)
-        if inspect.ismethod(value):
-            # Emulate bound methods behavior by partially applying our proxy
-            # class as the self parameter instead of the client.
-            return functools.partial(
-                getattr(self.__client.__class__, name), self)
-
-        return value
-
-    def __setattr__(self, name, value):
-        if name.startswith('_{}__'.format(type(self).__name__.lstrip('_'))):
-            # This is our own name-mangled attribute, keep calm.
-            return super().__setattr__(name, value)
-        return setattr(self.__client, name, value)
-
-
-class AccountMethods:
-    def takeout(
-            self: 'SoroushClient',
-            finalize: bool = True,
-            *,
-            contacts: bool = None,
-            users: bool = None,
-            chats: bool = None,
-            megagroups: bool = None,
-            channels: bool = None,
-            files: bool = None,
-            max_file_size: bool = None) -> 'SoroushClient':
-        """
-        Returns a :ref:`spluspy-client` which calls methods behind a takeout session.
-
-        It does so by creating a proxy object over the current client through
-        which making requests will use :tl:`InvokeWithTakeoutRequest` to wrap
-        them. In other words, returns the current client modified so that
-        requests are done as a takeout:
-
-        Some of the calls made through the takeout session will have lower
-        flood limits. This is useful if you want to export the data from
-        conversations or mass-download media, since the rate limits will
-        be lower. Only some requests will be affected, and you will need
-        to adjust the `wait_time` of methods like `client.iter_messages
-        <spluspy.client.messages.MessageMethods.iter_messages>`.
-
-        By default, all parameters are `None`, and you need to enable those
-        you plan to use by setting them to either `True` or `False`.
-
-        You should ``except errors.TakeoutInitDelayError as e``, since this
-        exception will raise depending on the condition of the session. You
-        can then access ``e.seconds`` to know how long you should wait for
-        before calling the method again.
-
-        There's also a `success` property available in the takeout proxy
-        object, so from the `with` body you can set the boolean result that
-        will be sent back to SoroushPlus. But if it's left `None` as by
-        default, then the action is based on the `finalize` parameter. If
-        it's `True` then the takeout will be finished, and if no exception
-        occurred during it, then `True` will be considered as a result.
-        Otherwise, the takeout will not be finished and its ID will be
-        preserved for future usage as `client.session.takeout_id
-        <spluspy.sessions.abstract.Session.takeout_id>`.
-
-        Arguments
-            finalize (`bool`):
-                Whether the takeout session should be finalized upon
-                exit or not.
-
-            contacts (`bool`):
-                Set to `True` if you plan on downloading contacts.
-
-            users (`bool`):
-                Set to `True` if you plan on downloading information
-                from users and their private conversations with you.
-
-            chats (`bool`):
-                Set to `True` if you plan on downloading information
-                from small group chats, such as messages and media.
-
-            megagroups (`bool`):
-                Set to `True` if you plan on downloading information
-                from megagroups (channels), such as messages and media.
-
-            channels (`bool`):
-                Set to `True` if you plan on downloading information
-                from broadcast channels, such as messages and media.
-
-            files (`bool`):
-                Set to `True` if you plan on downloading media and
-                you don't only wish to export messages.
-
-            max_file_size (`int`):
-                The maximum file size, in bytes, that you plan
-                to download for each message with media.
-
-        Example
-            .. code-block:: python
-
-                from spluspy._engine import errors
-
-                try:
-                    async with client.takeout() as takeout:
-                        await client.get_messages('me')  # normal call
-                        await takeout.get_messages('me')  # wrapped through takeout (less limits)
-
-                        async for message in takeout.iter_messages(chat, wait_time=0):
-                            ...  # Do something with the message
-
-                except errors.TakeoutInitDelayError as e:
-                    print('Must wait', e.seconds, 'before takeout')
-        """
-        request_kwargs = dict(
-            contacts=contacts,
-            message_users=users,
-            message_chats=chats,
-            message_megagroups=megagroups,
-            message_channels=channels,
-            files=files,
-            file_max_size=max_file_size
-        )
-        arg_specified = (arg is not None for arg in request_kwargs.values())
-
-        if self.session.takeout_id is None or any(arg_specified):
-            request = functions.account.InitTakeoutSessionRequest(
-                **request_kwargs)
-        else:
-            request = None
-
-        return _TakeoutClient(finalize, self, request)
-
-    async def end_takeout(self: 'SoroushClient', success: bool) -> bool:
-        """
-        Finishes the current takeout session.
-
-        Arguments
-            success (`bool`):
-                Whether the takeout completed successfully or not.
-
-        Returns
-            `True` if the operation was successful, `False` otherwise.
-
-        Example
-            .. code-block:: python
-
-                await client.end_takeout(success=False)
-        """
-        try:
-            async with _TakeoutClient(True, self, None) as takeout:
-                takeout.success = success
-        except ValueError as e:
-            _log.debug('Failed to end takeout: %s', e)
-            return False
-        return True
+import functools
+import inspect
+import logging
+import typing
+
+from .users import _NOT_A_REQUEST
+from .. import helpers, utils
+from ..tl import functions, TLRequest
+
+_log = logging.getLogger(__name__)
+
+if typing.TYPE_CHECKING:
+    from .soroushclient import SoroushClient
+
+
+# TODO Make use of :tl:`InvokeWithMessagesRange` somehow
+#      For that, we need to use :tl:`GetSplitRanges` first.
+class _TakeoutClient:
+    """
+    Proxy object over the client.
+    """
+    __PROXY_INTERFACE = ('__enter__', '__exit__', '__aenter__', '__aexit__')
+
+    def __init__(self, finalize, client, request):
+        # We use the name mangling for attributes to make them inaccessible
+        # from within the shadowed client object and to distinguish them from
+        # its own attributes where needed.
+        self.__finalize = finalize
+        self.__client = client
+        self.__request = request
+        self.__success = None
+
+    @property
+    def success(self):
+        return self.__success
+
+    @success.setter
+    def success(self, value):
+        self.__success = value
+
+    async def __aenter__(self):
+        # Enter/Exit behaviour is "overrode", we don't want to call start.
+        client = self.__client
+        if client.session.takeout_id is None:
+            client.session.takeout_id = (await client(self.__request)).id
+        elif self.__request is not None:
+            raise ValueError("Can't send a takeout request while another "
+                "takeout for the current session still not been finished yet.")
+        return self
+
+    async def __aexit__(self, exc_type, exc_value, traceback):
+        if self.__success is None and self.__finalize:
+            self.__success = exc_type is None
+
+        if self.__success is not None:
+            result = await self(functions.account.FinishTakeoutSessionRequest(
+                self.__success))
+            if not result:
+                raise ValueError("Failed to finish the takeout.")
+            self.session.takeout_id = None
+
+    __enter__ = helpers._sync_enter
+    __exit__ = helpers._sync_exit
+
+    async def __call__(self, request, ordered=False):
+        takeout_id = self.__client.session.takeout_id
+        if takeout_id is None:
+            raise ValueError('Takeout mode has not been initialized '
+                '(are you calling outside of "with"?)')
+
+        single = not utils.is_list_like(request)
+        requests = ((request,) if single else request)
+        wrapped = []
+        for r in requests:
+            if not isinstance(r, TLRequest):
+                raise _NOT_A_REQUEST()
+            await r.resolve(self, utils)
+            wrapped.append(functions.InvokeWithTakeoutRequest(takeout_id, r))
+
+        return await self.__client(
+            wrapped[0] if single else wrapped, ordered=ordered)
+
+    def __getattribute__(self, name):
+        # We access class via type() because __class__ will recurse infinitely.
+        # Also note that since we've name-mangled our own class attributes,
+        # they'll be passed to __getattribute__() as already decorated. For
+        # example, 'self.__client' will be passed as '_TakeoutClient__client'.
+        # https://docs.python.org/3/tutorial/classes.html#private-variables
+        if name.startswith('__') and name not in type(self).__PROXY_INTERFACE:
+            raise AttributeError  # force call of __getattr__
+
+        # Try to access attribute in the proxy object and check for the same
+        # attribute in the shadowed object (through our __getattr__) if failed.
+        return super().__getattribute__(name)
+
+    def __getattr__(self, name):
+        value = getattr(self.__client, name)
+        if inspect.ismethod(value):
+            # Emulate bound methods behavior by partially applying our proxy
+            # class as the self parameter instead of the client.
+            return functools.partial(
+                getattr(self.__client.__class__, name), self)
+
+        return value
+
+    def __setattr__(self, name, value):
+        if name.startswith('_{}__'.format(type(self).__name__.lstrip('_'))):
+            # This is our own name-mangled attribute, keep calm.
+            return super().__setattr__(name, value)
+        return setattr(self.__client, name, value)
+
+
+class AccountMethods:
+    def takeout(
+            self: 'SoroushClient',
+            finalize: bool = True,
+            *,
+            contacts: bool = None,
+            users: bool = None,
+            chats: bool = None,
+            megagroups: bool = None,
+            channels: bool = None,
+            files: bool = None,
+            max_file_size: bool = None) -> 'SoroushClient':
+        """
+        Returns a :ref:`spluspy-client` which calls methods behind a takeout session.
+
+        It does so by creating a proxy object over the current client through
+        which making requests will use :tl:`InvokeWithTakeoutRequest` to wrap
+        them. In other words, returns the current client modified so that
+        requests are done as a takeout:
+
+        Some of the calls made through the takeout session will have lower
+        flood limits. This is useful if you want to export the data from
+        conversations or mass-download media, since the rate limits will
+        be lower. Only some requests will be affected, and you will need
+        to adjust the `wait_time` of methods like `client.iter_messages
+        <spluspy.client.messages.MessageMethods.iter_messages>`.
+
+        By default, all parameters are `None`, and you need to enable those
+        you plan to use by setting them to either `True` or `False`.
+
+        You should ``except errors.TakeoutInitDelayError as e``, since this
+        exception will raise depending on the condition of the session. You
+        can then access ``e.seconds`` to know how long you should wait for
+        before calling the method again.
+
+        There's also a `success` property available in the takeout proxy
+        object, so from the `with` body you can set the boolean result that
+        will be sent back to SoroushPlus. But if it's left `None` as by
+        default, then the action is based on the `finalize` parameter. If
+        it's `True` then the takeout will be finished, and if no exception
+        occurred during it, then `True` will be considered as a result.
+        Otherwise, the takeout will not be finished and its ID will be
+        preserved for future usage as `client.session.takeout_id
+        <spluspy.sessions.abstract.Session.takeout_id>`.
+
+        Arguments
+            finalize (`bool`):
+                Whether the takeout session should be finalized upon
+                exit or not.
+
+            contacts (`bool`):
+                Set to `True` if you plan on downloading contacts.
+
+            users (`bool`):
+                Set to `True` if you plan on downloading information
+                from users and their private conversations with you.
+
+            chats (`bool`):
+                Set to `True` if you plan on downloading information
+                from small group chats, such as messages and media.
+
+            megagroups (`bool`):
+                Set to `True` if you plan on downloading information
+                from megagroups (channels), such as messages and media.
+
+            channels (`bool`):
+                Set to `True` if you plan on downloading information
+                from broadcast channels, such as messages and media.
+
+            files (`bool`):
+                Set to `True` if you plan on downloading media and
+                you don't only wish to export messages.
+
+            max_file_size (`int`):
+                The maximum file size, in bytes, that you plan
+                to download for each message with media.
+
+        Example
+            .. code-block:: python
+
+                from spluspy import errors
+
+                try:
+                    async with client.takeout() as takeout:
+                        await client.get_messages('me')  # normal call
+                        await takeout.get_messages('me')  # wrapped through takeout (less limits)
+
+                        async for message in takeout.iter_messages(chat, wait_time=0):
+                            ...  # Do something with the message
+
+                except errors.TakeoutInitDelayError as e:
+                    print('Must wait', e.seconds, 'before takeout')
+        """
+        request_kwargs = dict(
+            contacts=contacts,
+            message_users=users,
+            message_chats=chats,
+            message_megagroups=megagroups,
+            message_channels=channels,
+            files=files,
+            file_max_size=max_file_size
+        )
+        arg_specified = (arg is not None for arg in request_kwargs.values())
+
+        if self.session.takeout_id is None or any(arg_specified):
+            request = functions.account.InitTakeoutSessionRequest(
+                **request_kwargs)
+        else:
+            request = None
+
+        return _TakeoutClient(finalize, self, request)
+
+    async def end_takeout(self: 'SoroushClient', success: bool) -> bool:
+        """
+        Finishes the current takeout session.
+
+        Arguments
+            success (`bool`):
+                Whether the takeout completed successfully or not.
+
+        Returns
+            `True` if the operation was successful, `False` otherwise.
+
+        Example
+            .. code-block:: python
+
+                await client.end_takeout(success=False)
+        """
+        try:
+            async with _TakeoutClient(True, self, None) as takeout:
+                takeout.success = success
+        except ValueError as e:
+            _log.debug('Failed to end takeout: %s', e)
+            return False
+        return True