spluspy 2.2.7__tar.gz → 2.2.9__tar.gz

{spluspy-2.2.7/spluspy.egg-info → spluspy-2.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spluspy
-Version: 2.2.7
+Version: 2.2.9
 Summary: High-performance Python Self-Bot Framework for Soroush Plus
 Author: Ali Mirshekari
 License: MIT
@@ -26,7 +26,8 @@ Requires-Dist: rsa
 Requires-Dist: pyaes
 Dynamic: license-file
 
-# SplusPy v2.2.7
+# SplusPy v2.2.9
+
 
 **A fast, minimal, and fully-featured self-bot framework**
 
@@ -36,7 +37,7 @@ Dynamic: license-file
 
 SplusPy is a Python library designed specifically for building **Soroush Plus self-bots** (userbots). It provides a clean, intuitive API for automating your personal Soroush Plus account with ease.
 
-> ⚠️ **Note:** This is a **self-bot framework** — it operates on your personal account, not a bot account. Please adhere to Telegram's Terms of Service.
+> ⚠️ **Note:** This is a **self-bot framework** — it operates on your personal account, not a bot account. Please adhere to Soroush's Terms of Service.
 
 ---
 

{spluspy-2.2.7 → spluspy-2.2.9}/README.md

@@ -1,4 +1,5 @@
-# SplusPy v2.2.7
+# SplusPy v2.2.9
+
 
 **A fast, minimal, and fully-featured self-bot framework**
 
@@ -8,7 +9,7 @@
 
 SplusPy is a Python library designed specifically for building **Soroush Plus self-bots** (userbots). It provides a clean, intuitive API for automating your personal Soroush Plus account with ease.
 
-> ⚠️ **Note:** This is a **self-bot framework** — it operates on your personal account, not a bot account. Please adhere to Telegram's Terms of Service.
+> ⚠️ **Note:** This is a **self-bot framework** — it operates on your personal account, not a bot account. Please adhere to Soroush's Terms of Service.
 
 ---
 

{spluspy-2.2.7 → spluspy-2.2.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "spluspy"
-version = "2.2.7"
+version = "2.2.9"
 description = "High-performance Python Self-Bot Framework for Soroush Plus"
 readme = "README.md"
 license = {text = "MIT"}

{spluspy-2.2.7 → spluspy-2.2.9}/spluspy/__init__.py

@@ -4,11 +4,12 @@ from .tl.custom import Button
 from .tl import patched as _  # import for its side-effects
 from . import version, events, utils, errors, functions, custom
 from .filters import filters
+from .enums import MessageMediaType
 
 __version__ = version.__version__
 
 __all__ = [
-    'Client', 'Button', 'filters',
+    'Client', 'Button', 'filters', 'MessageMediaType',
     'functions', 'custom', 'errors',
     'events', 'utils', 'connection'
 ]

{spluspy-2.2.7 → spluspy-2.2.9}/spluspy/client/downloads.py

@@ -118,6 +118,17 @@ class _DirectDownloadIter(RequestIter):
             self._exported = True
             return await self._request()
 
+        except errors.RPCError as e:
+            err_msg = str(e).upper()
+            if "FILE_REQUEST_RECEIVED_ON_CONNECTION_SERVER" in err_msg or "422" in err_msg:
+                self.client._log[__name__].info('File download must be on Media DC; switching to DC 5')
+                if self._exported and getattr(self, '_sender', None):
+                    await self.client._return_exported_sender(self._sender)
+                self._sender = await self.client._borrow_exported_sender(5)
+                self._exported = True
+                return await self._request()
+            raise
+
         except (errors.FilerefUpgradeNeededError, errors.FileReferenceExpiredError) as e:
             # Only implemented for documents which are the ones that may take that long to download
             if not self._msg_data \
@@ -142,7 +153,7 @@ class _DirectDownloadIter(RequestIter):
             return await self._request()
 
     async def close(self):
-        if not self._sender:
+        if getattr(self, '_sender', None) is None:
             return
 
         try:
@@ -1093,4 +1104,4 @@ class DownloadMethods:
                 return result
             i += 1
 
-    # endregion
+    # endregion

{spluspy-2.2.7 → spluspy-2.2.9}/spluspy/client/extra.py

@@ -1,6 +1,6 @@
 import typing
 from ..tl import functions, types
-from .. import helpers, utils, hints
+from .. import helpers, utils, hints, errors
 
 if typing.TYPE_CHECKING:
     from .soroushclient import SoroushClient
@@ -224,9 +224,9 @@ class ExtraMethods:
             The full chat info (FullChannel or FullChat).
         """
         entity = await self.get_input_entity(chat_id)
-        if helpers._entity_type(entity) == helpers._EntityType.CHANNEL:
+        try:
             return await self(functions.channels.GetFullChannelRequest(entity))
-        else:
+        except errors.BadRequestError:
             return await self(functions.messages.GetFullChatRequest(entity.chat_id))
 
     async def get_chat_info(self: 'SoroushClient', chat_id):
@@ -237,10 +237,23 @@ class ExtraMethods:
         """Alias for get_entity. Returns the entity for the given user."""
         return await self.get_entity(user_id)
 
+    async def get_full_user(self: 'SoroushClient', user_id):
+        """Fetches full user profile information."""
+        try:
+            entity = await self.get_input_entity(user_id)
+            return await self(functions.users.GetFullUserRequest(id=entity))
+        except Exception:
+            return None
+
     async def get_full_chat(self: 'SoroushClient', chat_id):
         """Alias for get_chat. Returns full chat/channel info."""
         return await self.get_chat(chat_id)
 
+    async def is_public_chat(self: 'SoroushClient', chat_id: 'hints.EntityLike') -> bool:
+        """Check if a chat is public (has a username) or not."""
+        entity = await self.get_entity(chat_id)
+        return bool(getattr(entity, 'username', None))
+
     async def get_dialogs(
         self: 'SoroushClient',
         limit: int = 0,

{spluspy-2.2.7 → spluspy-2.2.9}/spluspy/client/telegrambaseclient.py

@@ -855,7 +855,7 @@ class SoroushPlusBaseClient(abc.ABC):
         # Soroush: map all DCs to splus.ir servers
         if not cdn:
             domain = '.splus.ir'
-            if dc_id in (1, 2, 3, 4, 5):
+            if dc_id in (1, 2, 3, 4):
                 ip = f'im-server{domain}'
             elif dc_id == 6:
                 ip = f'im-server{domain}'

{spluspy-2.2.7 → spluspy-2.2.9}/spluspy/client/updates.py

@@ -298,6 +298,8 @@ class UpdateMethods:
         event = None
         if isinstance(update, (types.UpdateNewMessage, types.UpdateNewChannelMessage)):
             event = NewMessage.build(update, None, self._mb_entity_cache.self_id)
+            if event is None and isinstance(update.message, types.MessageService):
+                event = ChatAction.build(update, None, self._mb_entity_cache.self_id)
         elif isinstance(update, (types.UpdateEditMessage, types.UpdateEditChannelMessage)):
             event = MessageEdited.build(update, None, self._mb_entity_cache.self_id)
         elif isinstance(update, (types.UpdateDeleteMessages, types.UpdateDeleteChannelMessages)):
@@ -317,24 +319,6 @@ class UpdateMethods:
             types.UpdateChannelUserTyping,
         )):
             event = UserUpdate.build(update, None, self._mb_entity_cache.self_id)
-        elif isinstance(update, (types.UpdateNewMessage, types.UpdateNewChannelMessage)):
-            # Check for service messages that are ChatActions
-            msg = update.message
-            if isinstance(msg, types.MessageService) and isinstance(msg.action, (
-                types.MessageActionChatJoinedByLink,
-                types.MessageActionChatAddUser,
-                types.MessageActionChatDeleteUser,
-                types.MessageActionChatCreate,
-                types.MessageActionChannelCreate,
-                types.MessageActionChatEditTitle,
-                types.MessageActionChatEditPhoto,
-                types.MessageActionChatDeletePhoto,
-                types.MessageActionPinMessage,
-                types.MessageActionGameScore,
-            )):
-                event = ChatAction.build(update, None, self._mb_entity_cache.self_id)
-            else:
-                event = NewMessage.build(update, None, self._mb_entity_cache.self_id)
 
         # For Raw handlers, always dispatch with the raw update
         raw_event = update

{spluspy-2.2.7 → spluspy-2.2.9}/spluspy/client/uploads.py

@@ -9,7 +9,7 @@ from io import BytesIO
 
 from ..crypto import AES
 
-from .. import utils, helpers, hints
+from .. import utils, helpers, hints, errors
 from ..tl import types, functions, custom
 
 try:
@@ -666,96 +666,117 @@ class UploadMethods:
         if isinstance(file, (types.InputFile, types.InputFileBig)):
             return file  # Already uploaded
 
+        media_sender = None
+        media_dc = 5  # دیتاسنتر اختصاصی فایل‌های سروش پلاس
+
         pos = 0
-        async with helpers._FileStream(file, file_size=file_size) as stream:
-            # Opening the stream will determine the correct file size
-            file_size = stream.file_size
-
-            if not part_size_kb:
-                part_size_kb = utils.get_appropriated_part_size(file_size)
-
-            if part_size_kb > 512:
-                raise ValueError('The part size must be less or equal to 512KB')
-
-            part_size = int(part_size_kb * 1024)
-            if part_size % 1024 != 0:
-                raise ValueError(
-                    'The part size must be evenly divisible by 1024')
-
-            # Set a default file name if None was specified
-            file_id = helpers.generate_random_long()
-            if not file_name:
-                file_name = stream.name or str(file_id)
-
-            # If the file name lacks extension, add it if possible.
-            # Else SoroushPlus complains with `PHOTO_EXT_INVALID_ERROR`
-            # even if the uploaded image is indeed a photo.
-            if not os.path.splitext(file_name)[-1]:
-                file_name += utils._get_extension(stream)
-
-            # Determine whether the file is too big (over 10MB) or not
-            # SoroushPlus does make a distinction between smaller or larger files
-            is_big = file_size > 10 * 1024 * 1024
-            hash_md5 = hashlib.md5()
-
-            part_count = (file_size + part_size - 1) // part_size
-            self._log[__name__].info('Uploading file of %d bytes in %d chunks of %d',
-                                     file_size, part_count, part_size)
-
-            pos = 0
-            for part_index in range(part_count):
-                # Read the file by in chunks of size part_size
-                part = await helpers._maybe_await(stream.read(part_size))
-
-                if not isinstance(part, bytes):
-                    raise TypeError(
-                        'file descriptor returned {}, not bytes (you must '
-                        'open the file in bytes mode)'.format(type(part)))
-
-                # `file_size` could be wrong in which case `part` may not be
-                # `part_size` before reaching the end.
-                if len(part) != part_size and part_index < part_count - 1:
-                    raise ValueError(
-                        'read less than {} before reaching the end; either '
-                        '`file_size` or `read` are wrong'.format(part_size))
-
-                pos += len(part)
-
-                # Encryption part if needed
-                if key and iv:
-                    part = AES.encrypt_ige(part, key, iv)
-
-                if not is_big:
-                    # Bit odd that MD5 is only needed for small files and not
-                    # big ones with more chance for corruption, but that's
-                    # what SoroushPlus wants.
-                    hash_md5.update(part)
-
-                # The SavePartRequest is different depending on whether
-                # the file is too large or not (over or less than 10MB)
-                if is_big:
-                    request = functions.upload.SaveBigFilePartRequest(
-                        file_id, part_index, part_count, part)
-                else:
-                    request = functions.upload.SaveFilePartRequest(
-                        file_id, part_index, part)
-
-                result = await self(request)
-                if result:
-                    self._log[__name__].debug('Uploaded %d/%d',
-                                              part_index + 1, part_count)
-                    if progress_callback:
-                        await helpers._maybe_await(progress_callback(pos, file_size))
-                else:
-                    raise RuntimeError(
-                        'Failed to upload file part {}.'.format(part_index))
+        try:
+            async with helpers._FileStream(file, file_size=file_size) as stream:
+                # Opening the stream will determine the correct file size
+                file_size = stream.file_size
 
-        if is_big:
-            return types.InputFileBig(file_id, part_count, file_name)
-        else:
-            return custom.InputSizedFile(
-                file_id, part_count, file_name, md5=hash_md5, size=file_size
-            )
+                if not part_size_kb:
+                    part_size_kb = utils.get_appropriated_part_size(file_size)
+
+                if part_size_kb > 512:
+                    raise ValueError('The part size must be less or equal to 512KB')
+
+                part_size = int(part_size_kb * 1024)
+                if part_size % 1024 != 0:
+                    raise ValueError(
+                        'The part size must be evenly divisible by 1024')
+
+                # Set a default file name if None was specified
+                file_id = helpers.generate_random_long()
+                if not file_name:
+                    file_name = stream.name or str(file_id)
+
+                # If the file name lacks extension, add it if possible.
+                # Else SoroushPlus complains with `PHOTO_EXT_INVALID_ERROR`
+                # even if the uploaded image is indeed a photo.
+                if not os.path.splitext(file_name)[-1]:
+                    file_name += utils._get_extension(stream)
+
+                # Determine whether the file is too big (over 10MB) or not
+                # SoroushPlus does make a distinction between smaller or larger files
+                is_big = file_size > 10 * 1024 * 1024
+                hash_md5 = hashlib.md5()
+
+                part_count = (file_size + part_size - 1) // part_size
+                self._log[__name__].info('Uploading file of %d bytes in %d chunks of %d',
+                                         file_size, part_count, part_size)
+
+                pos = 0
+                for part_index in range(part_count):
+                    # Read the file by in chunks of size part_size
+                    part = await helpers._maybe_await(stream.read(part_size))
+
+                    if not isinstance(part, bytes):
+                        raise TypeError(
+                            'file descriptor returned {}, not bytes (you must '
+                            'open the file in bytes mode)'.format(type(part)))
+
+                    # `file_size` could be wrong in which case `part` may not be
+                    # `part_size` before reaching the end.
+                    if len(part) != part_size and part_index < part_count - 1:
+                        raise ValueError(
+                            'read less than {} before reaching the end; either '
+                            '`file_size` or `read` are wrong'.format(part_size))
+
+                    pos += len(part)
+
+                    # Encryption part if needed
+                    if key and iv:
+                        part = AES.encrypt_ige(part, key, iv)
+
+                    if not is_big:
+                        # Bit odd that MD5 is only needed for small files and not
+                        # big ones with more chance for corruption, but that's
+                        # what SoroushPlus wants.
+                        hash_md5.update(part)
+
+                    # The SavePartRequest is different depending on whether
+                    # the file is too large or not (over or less than 10MB)
+                    if is_big:
+                        request = functions.upload.SaveBigFilePartRequest(
+                            file_id, part_index, part_count, part)
+                    else:
+                        request = functions.upload.SaveFilePartRequest(
+                            file_id, part_index, part)
+
+                    # ارسال ریکوئست آپلود با هندل کردن اتصال سرور مدیا
+                    if media_sender:
+                        result = await self._call(media_sender, request)
+                    else:
+                        try:
+                            result = await self(request)
+                        except errors.RPCError as e:
+                            err_msg = str(e).upper()
+                            if "FILE_REQUEST_RECEIVED_ON_CONNECTION_SERVER" in err_msg or "422" in err_msg:
+                                self._log[__name__].info('Switching to Media DC (DC 5) for upload...')
+                                media_sender = await self._borrow_exported_sender(media_dc)
+                                result = await self._call(media_sender, request)
+                            else:
+                                raise
+
+                    if result:
+                        self._log[__name__].debug('Uploaded %d/%d',
+                                                  part_index + 1, part_count)
+                        if progress_callback:
+                            await helpers._maybe_await(progress_callback(pos, file_size))
+                    else:
+                        raise RuntimeError(
+                            'Failed to upload file part {}.'.format(part_index))
+
+            if is_big:
+                return types.InputFileBig(file_id, part_count, file_name)
+            else:
+                return custom.InputSizedFile(
+                    file_id, part_count, file_name, md5=hash_md5, size=file_size
+                )
+        finally:
+            if media_sender:
+                await self._return_exported_sender(media_sender)
 
     # endregion
 
@@ -864,4 +885,4 @@ class UploadMethods:
             )
         return file_handle, media, as_image
 
-    # endregion
+    # endregion

{spluspy-2.2.7 → spluspy-2.2.9}/spluspy/client/users.py

@@ -483,6 +483,18 @@ class UserMethods:
                     'GetUsersRequest with access_hash=0 failed for user %s, '
                     'trying contacts fallback', peer.user_id)
 
+            # SoroushPlus groups are channels. A bare positive ID may actually
+            # be a group, so try resolving it as a channel before giving up.
+            try:
+                channels = await self(functions.channels.GetChannelsRequest([
+                    types.InputChannel(peer.user_id, access_hash=0)]))
+                if channels.chats:
+                    return utils.get_input_peer(channels.chats[0])
+            except errors.RPCError:
+                _log.debug(
+                    'GetChannelsRequest with access_hash=0 failed for %s',
+                    peer.user_id)
+
             # Fallback: search contacts for the user by ID
             try:
                 contacts = (await self(
@@ -510,8 +522,10 @@ class UserMethods:
         )
 
     async def _get_peer(self: 'SoroushClient', peer: 'hints.EntityLike'):
-        i, cls = utils.resolve_id(await self.get_peer_id(peer))
-        return cls(i)
+        if isinstance(peer, int):
+            i, cls = utils.resolve_id(await self.get_peer_id(peer))
+            return cls(i)
+        return utils.get_peer(peer)
 
     async def get_peer_id(
             self: 'SoroushClient',

spluspy-2.2.9/spluspy/enums.py

@@ -0,0 +1,144 @@
+from enum import Enum
+
+
+class MessageMediaType(Enum):
+    PHOTO = "photo"
+    VIDEO = "video"
+    VIDEO_NOTE = "video_note"
+    DOCUMENT = "document"
+    AUDIO = "audio"
+    VOICE = "voice"
+    STICKER = "sticker"
+    ANIMATION = "animation"
+    GIF = "gif"
+    WEB_PAGE = "web_page"
+    GEO = "geo"
+    GEO_LIVE = "geo_live"
+    CONTACT = "contact"
+    GAME = "game"
+    POLL = "poll"
+    DICE = "dice"
+    VENUE = "venue"
+    STORY = "story"
+    GIVEAWAY = "giveaway"
+    INVOICE = "invoice"
+    UNSUPPORTED = "unsupported"
+    EMPTY = "empty"
+
+    @classmethod
+    def from_media(cls, media):
+        """
+        Detect MessageMediaType from a MessageMedia object.
+
+        Usage:
+            from spluspy.enums import MessageMediaType
+            media_type = MessageMediaType.from_media(message.media)
+        """
+        from .tl import types
+
+        if media is None or isinstance(media, types.MessageMediaEmpty):
+            return cls.EMPTY
+
+        if isinstance(media, types.MessageMediaPhoto):
+            return cls.PHOTO
+
+        if isinstance(media, types.MessageMediaDocument):
+            doc = media.document
+            if doc is None or isinstance(doc, types.DocumentEmpty):
+                return cls.DOCUMENT
+
+            attrs = {type(a): a for a in doc.attributes}
+
+            if types.DocumentAttributeSticker in attrs:
+                return cls.STICKER
+
+            if types.DocumentAttributeAnimated in attrs:
+                if types.DocumentAttributeVideo in attrs:
+                    return cls.ANIMATION
+                return cls.GIF
+
+            if types.DocumentAttributeVideo in attrs:
+                vid = attrs[types.DocumentAttributeVideo]
+                if vid.round_message:
+                    return cls.VIDEO_NOTE
+                return cls.VIDEO
+
+            if types.DocumentAttributeAudio in attrs:
+                aud = attrs[types.DocumentAttributeAudio]
+                if aud.voice:
+                    return cls.VOICE
+                return cls.AUDIO
+
+            return cls.DOCUMENT
+
+        if isinstance(media, types.MessageMediaWebPage):
+            return cls.WEB_PAGE
+
+        if isinstance(media, types.MessageMediaGeo):
+            return cls.GEO
+
+        if isinstance(media, types.MessageMediaGeoLive):
+            return cls.GEO_LIVE
+
+        if isinstance(media, types.MessageMediaContact):
+            return cls.CONTACT
+
+        if isinstance(media, types.MessageMediaGame):
+            return cls.GAME
+
+        if isinstance(media, types.MessageMediaPoll):
+            return cls.POLL
+
+        if isinstance(media, types.MessageMediaDice):
+            return cls.DICE
+
+        if isinstance(media, types.MessageMediaVenue):
+            return cls.VENUE
+
+        if isinstance(media, types.MessageMediaStory):
+            return cls.STORY
+
+        if isinstance(media, types.MessageMediaGiveaway):
+            return cls.GIVEAWAY
+
+        if isinstance(media, types.MessageMediaInvoice):
+            return cls.INVOICE
+
+        if isinstance(media, types.MessageMediaUnsupported):
+            return cls.UNSUPPORTED
+
+        return cls.EMPTY
+
+    @classmethod
+    def from_message(cls, message):
+        """
+        Detect MessageMediaType from a Message object.
+
+        Usage:
+            from spluspy.enums import MessageMediaType
+            media_type = MessageMediaType.from_message(event.message)
+        """
+        if hasattr(message, 'media'):
+            return cls.from_media(message.media)
+        return cls.EMPTY
+
+    def is_image(self):
+        return self == self.PHOTO
+
+    def is_video(self):
+        return self in (self.VIDEO, self.VIDEO_NOTE, self.ANIMATION)
+
+    def is_audio(self):
+        return self in (self.AUDIO, self.VOICE)
+
+    def is_document(self):
+        return self == self.DOCUMENT
+
+    def is_sticker(self):
+        return self == self.STICKER
+
+    def is_animation(self):
+        return self in (self.ANIMATION, self.GIF)
+
+    def is_media(self):
+        return self not in (self.EMPTY, self.UNSUPPORTED)

{spluspy-2.2.7 → spluspy-2.2.9}/spluspy/events/common.py

@@ -19,9 +19,15 @@ async def _into_id_set(client, chats):
     for chat in chats:
         if isinstance(chat, int):
             if chat < 0:
-                result.add(chat)  # Explicitly marked IDs are negative
+                # Explicitly marked IDs (e.g. legacy "-100...") are kept, and
+                # their unmarked form is also added so both styles match.
+                result.add(chat)
+                result.add(utils.resolve_id(chat)[0])
             else:
-                result.update({  # Support all valid types of peers
+                # A bare positive ID in SoroushPlus can be a user or a group
+                # (channels), so add every possible representation to match
+                # whichever type the chat actually is.
+                result.update({
                     utils.get_peer_id(types.PeerUser(chat)),
                     utils.get_peer_id(types.PeerChat(chat)),
                     utils.get_peer_id(types.PeerChannel(chat)),
@@ -122,7 +128,7 @@ class EventBuilder(abc.ABC):
                 return
 
         if self.filters:
-            if not await self.filters(event.client, event.message if hasattr(event, 'message') else event):
+            if not await self.filters(event.client, event):
                 return
 
         if not self.func: