spluspy 2.2.7__tar.gz → 2.2.8__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spluspy
-Version: 2.2.7
+Version: 2.2.8
 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.8
+
 
 **A fast, minimal, and fully-featured self-bot framework**
 

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

@@ -1,4 +1,5 @@
-# SplusPy v2.2.7
+# SplusPy v2.2.8
+
 
 **A fast, minimal, and fully-featured self-bot framework**
 

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

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

{spluspy-2.2.7 → spluspy-2.2.8}/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.8}/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.8}/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.8}/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.8}/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.8/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.8}/spluspy/network/mtprotosender.py

@@ -30,7 +30,7 @@ from ..crypto import AuthKey
 from ..helpers import retry_range
 
 
-_RECV_TIMEOUT = 15  # seconds; triggers reconnection if no data received
+_RECV_TIMEOUT = 60  # seconds; triggers reconnection if no data received
 
 
 class MTProtoSender:
@@ -154,6 +154,49 @@ class MTProtoSender:
         """
         await self._disconnect()
 
+    def _intercept_request(self, request):
+        """
+        Soroush+ Interceptor Middleware:
+        Intercepts and rewrites outgoing requests to bypass Soroush+ server restrictions
+        and prevent RPCError 422 (NOT_SUPPORTED).
+        """
+        req_type = type(request).__name__
+
+        try:
+            # 1. تبدیل متد خروج از گروه (جلوگیری از ارور 422)
+            if req_type == 'DeleteChatUserRequest':
+                from ..tl.functions.channels import LeaveChannelRequest
+                from ..tl.types import InputChannel
+                self._log.debug("Soroush+ Interceptor: Converting DeleteChatUserRequest -> LeaveChannelRequest")
+                # سروش برای خروج از همه گروه‌ها فقط این متد را می‌پذیرد
+                return LeaveChannelRequest(channel=InputChannel(request.chat_id, 0))
+
+            # 2. تبدیل متد دریافت لیست گروه‌ها (جلوگیری از ارور 422)
+            elif req_type == 'GetChatsRequest':
+                from ..tl.functions.channels import GetChannelsRequest
+                from ..tl.types import InputChannel
+                self._log.debug("Soroush+ Interceptor: Converting GetChatsRequest -> GetChannelsRequest")
+                channels = []
+                for chat_id in request.id:
+                    if isinstance(chat_id, int):
+                        channels.append(InputChannel(chat_id, 0))
+                    else:
+                        channels.append(chat_id)
+                return GetChannelsRequest(id=channels)
+
+            # 3. تبدیل متد دریافت اطلاعات کامل گروه (جلوگیری از ارور 422)
+            elif req_type == 'GetFullChatRequest':
+                from ..tl.functions.channels import GetFullChannelRequest
+                from ..tl.types import InputChannel
+                self._log.debug("Soroush+ Interceptor: Converting GetFullChatRequest -> GetFullChannelRequest")
+                return GetFullChannelRequest(channel=InputChannel(request.chat_id, 0))
+                
+        except Exception as e:
+            self._log.error('Interceptor failed to convert request %s: %s', req_type, e)
+
+        # اگر درخواست نیازی به تغییر نداشت، خودش رو برمی‌گردونیم
+        return request
+
     def send(self, request, ordered=False):
         """
         This method enqueues the given request to be sent. Its send
@@ -181,6 +224,9 @@ class MTProtoSender:
             raise ConnectionError('Cannot send requests while disconnected')
 
         if not utils.is_list_like(request):
+            # --- SOROUSH+ INTERCEPTOR HOOK ---
+            request = self._intercept_request(request)
+            
             try:
                 state = RequestState(request)
             except struct.error as e:
@@ -196,6 +242,9 @@ class MTProtoSender:
             futures = []
             state = None
             for req in request:
+                # --- SOROUSH+ INTERCEPTOR HOOK ---
+                req = self._intercept_request(req)
+                
                 try:
                     state = RequestState(req, after=ordered and state)
                 except struct.error as e:
@@ -976,4 +1025,4 @@ class MTProtoSender:
         # Even if the library didn't disconnect, the server would (and then
         # the library would reconnect and learn about auth key being invalid).
         if isinstance(message.obj, DestroyAuthKeyOk):
-            await self._disconnect(error=AuthKeyNotFound())
+            await self._disconnect(error=AuthKeyNotFound())

{spluspy-2.2.7 → spluspy-2.2.8}/spluspy/tl/custom/message.py

@@ -7,6 +7,7 @@ from .forward import Forward
 from .file import File
 from .. import TLObject, types, functions
 from ... import utils, errors
+from ...enums import MessageMediaType
 
 _log = logging.getLogger(__name__)
 
@@ -150,6 +151,27 @@ class Message(ChatGetter, SenderGetter, TLObject):
                 self._file = File(media)
         return self._file
 
+    @property
+    def media_type(self):
+        """
+        Returns the MessageMediaType of this message.
+
+        Usage:
+            from spluspy.enums import MessageMediaType
+
+            @client.on_message()
+            async def handler(client, event):
+                media_type = event.message.media_type
+
+                if media_type == MessageMediaType.PHOTO:
+                    await event.reply("عکس دریافت شد!")
+                elif media_type == MessageMediaType.VIDEO:
+                    await event.reply("ویدیو دریافت شد!")
+                elif media_type == MessageMediaType.STICKER:
+                    await event.reply("استیکر دریافت شد!")
+        """
+        return MessageMediaType.from_media(self.media)
+
     @property
     def photo(self):
         if isinstance(self.media, types.MessageMediaPhoto):

{spluspy-2.2.7 → spluspy-2.2.8}/spluspy/utils.py

@@ -58,9 +58,6 @@ USERNAME_RE = re.compile(
 TG_JOIN_RE = re.compile(
     r'tg://(join)\?invite='
 )
-SOROUSH_JOIN_RE = re.compile(
-    r'https?://splus\.ir/joingroup/([a-zA-Z0-9_-]+)'
-)
 
 VALID_USERNAME_RE = re.compile(
     r'^[a-z](?:(?!__)\w){1,30}[a-z\d]$',
@@ -936,11 +933,6 @@ def parse_username(username):
     Returns ``(None, False)`` if the ``username`` or link is not valid.
     """
     username = username.strip()
-    
-    splus_match = SOROUSH_JOIN_RE.match(username)
-    if splus_match:
-        return splus_match.group(1), True
-    
     m = USERNAME_RE.match(username) or TG_JOIN_RE.match(username)
     if m:
         username = username[m.end():]
@@ -1575,4 +1567,4 @@ async def maybe_async(coro):
     if inspect.isawaitable(result):
         warnings.warn('Using async sessions support is an experimental feature')
         result = await result
-    return result
+    return result

{spluspy-2.2.7 → spluspy-2.2.8}/spluspy/version.py

@@ -1,3 +1,3 @@
 # Versions should comply with PEP440.
 # This line is parsed in setup.py:
-__version__ = '2.2.7'
+__version__ = '2.2.8'

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spluspy
-Version: 2.2.7
+Version: 2.2.8
 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.8
+
 
 **A fast, minimal, and fully-featured self-bot framework**