spluspy 2.1.0__tar.gz → 2.1.2__tar.gz

{spluspy-2.1.0 → spluspy-2.1.2}/CHANGELOG.md

@@ -5,6 +5,11 @@ All notable changes to SplusPy will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/),
 and this project adheres to [Semantic Versioning](https://semver.org/).
 
+## [2.1.1] - 2026-07-12
+
+### Changed
+- Version bump to 2.1.1
+
 ## [2.1.0] - 2026-07-12
 
 ### Changed

{spluspy-2.1.0 → spluspy-2.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spluspy
-Version: 2.1.0
+Version: 2.1.2
 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.0 → spluspy-2.1.2}/pyproject.toml

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

{spluspy-2.1.0 → spluspy-2.1.2}/spluspy/__version__.py

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

{spluspy-2.1.0 → spluspy-2.1.2}/spluspy/_engine/version.py

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

{spluspy-2.1.0 → spluspy-2.1.2}/spluspy/client/chat_mixin.py

@@ -398,6 +398,472 @@ class ChatManagementMixin:
             )
             return False
 
+    async def set_chat_permissions(
+        self,
+        chat_id: Union[int, str],
+        send_messages: Optional[bool] = None,
+        send_media: Optional[bool] = None,
+        send_stickers: Optional[bool] = None,
+        send_gifs: Optional[bool] = None,
+        send_polls: Optional[bool] = None,
+        embed_links: Optional[bool] = None,
+        invite_users: Optional[bool] = None,
+        change_info: Optional[bool] = None,
+        pin_messages: Optional[bool] = None,
+    ) -> bool:
+        """Set the default chat permissions (default banned rights) for a group.
+
+        Controls what actions regular members are allowed to perform.
+        This applies to ALL non-admin members of the group.
+
+        Args:
+            chat_id: Channel/supergroup identifier (int ID, @username, etc.).
+            send_messages: ``True`` to ALLOW sending text messages,
+                ``False`` to RESTRICT. ``None`` keeps current state.
+            send_media: ``True`` to ALLOW sending media (photos, videos, etc.),
+                ``False`` to RESTRICT. ``None`` keeps current state.
+            send_stickers: ``True`` to ALLOW sending stickers,
+                ``False`` to RESTRICT. ``None`` keeps current state.
+            send_gifs: ``True`` to ALLOW sending GIFs,
+                ``False`` to RESTRICT. ``None`` keeps current state.
+            send_polls: ``True`` to ALLOW sending polls,
+                ``False`` to RESTRICT. ``None`` keeps current state.
+            embed_links: ``True`` to ALLOW embedding links in messages,
+                ``False`` to RESTRICT. ``None`` keeps current state.
+            invite_users: ``True`` to ALLOW inviting other users,
+                ``False`` to RESTRICT. ``None`` keeps current state.
+            change_info: ``True`` to ALLOW changing group info,
+                ``False`` to RESTRICT. ``None`` keeps current state.
+            pin_messages: ``True`` to ALLOW pinning messages,
+                ``False`` to RESTRICT. ``None`` keeps current state.
+
+        Returns:
+            ``True`` on success, ``False`` on failure.
+
+        Note:
+            In MTProto, ``ChatBannedRights`` flags are **positive-ban**:
+            setting a flag to ``True`` means the user is BANNED from that
+            action. This method inverts the semantics so that ``True``
+            means "allowed" (intuitive for the developer).
+
+        Example:
+            >>> # Lock everything: no messages, no media, no stickers
+            >>> await client.set_chat_permissions(chat_id,
+            ...     send_messages=False, send_media=False,
+            ...     send_stickers=False)
+            >>>
+            >>> # Only restrict media; keep everything else as-is
+            >>> await client.set_chat_permissions(chat_id,
+            ...     send_media=False)
+            >>>
+            >>> # Unlock everything
+            >>> await client.set_chat_permissions(chat_id,
+            ...     send_messages=True, send_media=True,
+            ...     send_stickers=True, send_gifs=True,
+            ...     send_polls=True, embed_links=True,
+            ...     invite_users=True, change_info=True,
+            ...     pin_messages=True)
+        """
+        client = self._get_client()
+        if not client:
+            logger.warning("set_chat_permissions skipped: client not connected")
+            return False
+
+        try:
+            from spluspy._engine import functions, types
+        except ImportError:
+            from telethon import functions, types
+
+        try:
+            # Resolve chat_id to InputPeer
+            input_peer = await self._resolve_to_input_peer(client, chat_id)
+            if input_peer is None:
+                # Fallback: try get_input_entity directly
+                try:
+                    input_peer = await client.get_input_entity(chat_id)
+                except Exception:
+                    logger.error(
+                        "set_chat_permissions: cannot resolve %s to InputPeer",
+                        chat_id,
+                    )
+                    return False
+
+            # Map developer-friendly booleans to MTProto banned-rights.
+            # In MTProto: True = BANNED (restricted).
+            # Here:      True = ALLOWED (not banned), False = RESTRICTED (banned).
+            # None means "don't change" (omit from ChatBannedRights).
+
+            def _to_banned(val: Optional[bool]) -> Optional[bool]:
+                """Convert developer-friendly bool to MTProto banned flag.
+
+                True (allowed) -> False (not banned)
+                False (restricted) -> True (banned)
+                None -> None (omit)
+                """
+                if val is None:
+                    return None
+                return not val  # Invert: allowed -> not banned, restricted -> banned
+
+            banned_rights = types.ChatBannedRights(
+                until_date=None,
+                view_messages=False,  # Never restrict viewing messages
+                send_messages=_to_banned(send_messages),
+                send_media=_to_banned(send_media),
+                send_stickers=_to_banned(send_stickers),
+                send_gifs=_to_banned(send_gifs),
+                send_games=_to_banned(send_media),  # Games use media permission
+                send_inline=_to_banned(send_media),  # Inline bots use media permission
+                embed_links=_to_banned(embed_links),
+                send_polls=_to_banned(send_polls),
+                change_info=_to_banned(change_info),
+                invite_users=_to_banned(invite_users),
+                pin_messages=_to_banned(pin_messages),
+                manage_topics=_to_banned(change_info),  # Topics use change_info permission
+                send_photos=_to_banned(send_media),
+                send_videos=_to_banned(send_media),
+                send_roundvideos=_to_banned(send_media),
+                send_audios=_to_banned(send_media),
+                send_voices=_to_banned(send_media),
+                send_docs=_to_banned(send_media),
+                send_plain=_to_banned(send_messages),
+            )
+
+            request = functions.messages.EditChatDefaultBannedRightsRequest(
+                peer=input_peer,
+                banned_rights=banned_rights,
+            )
+
+            await client(request)
+            logger.debug(
+                "set_chat_permissions: updated default permissions for %s",
+                chat_id,
+            )
+            return True
+
+        except Exception as exc:
+            logger.error(
+                "set_chat_permissions(chat=%s) failed: %s",
+                chat_id, exc,
+            )
+            return False
+
+    async def set_chat_title(
+        self,
+        chat_id: Union[int, str],
+        title: str,
+    ) -> bool:
+        """Change the title of a channel or supergroup.
+
+        Uses ``channels.EditTitleRequest`` to update the group/channel name.
+
+        Args:
+            chat_id: Channel/supergroup identifier (int ID, @username, etc.).
+            title: New title for the chat (1–128 characters).
+
+        Returns:
+            ``True`` on success, ``False`` on failure.
+
+        Example:
+            >>> await client.set_chat_title(-1001234567890, "New Group Name")
+        """
+        client = self._get_client()
+        if not client:
+            logger.warning("set_chat_title skipped: client not connected")
+            return False
+
+        try:
+            from spluspy._engine import functions
+        except ImportError:
+            from telethon import functions
+
+        try:
+            input_channel = await self._resolve_to_input_channel(client, chat_id)
+            if input_channel is None:
+                logger.error("set_chat_title: cannot resolve %s to InputChannel", chat_id)
+                return False
+
+            request = functions.channels.EditTitleRequest(
+                channel=input_channel,
+                title=title,
+            )
+            await client(request)
+            logger.debug("set_chat_title: updated title for %s", chat_id)
+            return True
+
+        except Exception as exc:
+            logger.error("set_chat_title(chat=%s) failed: %s", chat_id, exc)
+            return False
+
+    async def set_chat_about(
+        self,
+        chat_id: Union[int, str],
+        about: str,
+    ) -> bool:
+        """Change the about/description text of a chat.
+
+        Uses ``messages.EditChatAboutRequest`` to update the chat bio.
+        Works for both basic groups and supergroups/channels.
+
+        Args:
+            chat_id: Chat identifier (int ID, @username, etc.).
+            about: New about text (0–70 characters). Pass empty string to clear.
+
+        Returns:
+            ``True`` on success, ``False`` on failure.
+
+        Example:
+            >>> await client.set_chat_about(-1001234567890, "Welcome to our group!")
+        """
+        client = self._get_client()
+        if not client:
+            logger.warning("set_chat_about skipped: client not connected")
+            return False
+
+        try:
+            from spluspy._engine import functions
+        except ImportError:
+            from telethon import functions
+
+        try:
+            input_peer = await self._resolve_to_input_peer(client, chat_id)
+            if input_peer is None:
+                # Fallback: try get_input_entity directly
+                try:
+                    input_peer = await client.get_input_entity(chat_id)
+                except Exception:
+                    logger.error("set_chat_about: cannot resolve %s to InputPeer", chat_id)
+                    return False
+
+            request = functions.messages.EditChatAboutRequest(
+                peer=input_peer,
+                about=about,
+            )
+            await client(request)
+            logger.debug("set_chat_about: updated about for %s", chat_id)
+            return True
+
+        except Exception as exc:
+            logger.error("set_chat_about(chat=%s) failed: %s", chat_id, exc)
+            return False
+
+    async def set_chat_photo(
+        self,
+        chat_id: Union[int, str],
+        file_path: str,
+    ) -> bool:
+        """Upload and set a new photo for a channel or supergroup.
+
+        Reads the photo from *file_path*, uploads it to Telegram servers,
+        then applies it via ``channels.EditPhotoRequest``.
+
+        Args:
+            chat_id: Channel/supergroup identifier (int ID, @username, etc.).
+            file_path: Local filesystem path to the image file
+                (JPEG, PNG, or GIF recommended).
+
+        Returns:
+            ``True`` on success, ``False`` on failure.
+
+        Example:
+            >>> await client.set_chat_photo(-1001234567890, "/path/to/photo.jpg")
+        """
+        client = self._get_client()
+        if not client:
+            logger.warning("set_chat_photo skipped: client not connected")
+            return False
+
+        try:
+            from spluspy._engine import functions, types
+        except ImportError:
+            from telethon import functions, types
+
+        try:
+            input_channel = await self._resolve_to_input_channel(client, chat_id)
+            if input_channel is None:
+                logger.error("set_chat_photo: cannot resolve %s to InputChannel", chat_id)
+                return False
+
+            # Read and upload the photo file
+            import os
+            import hashlib
+
+            file_path_str = str(file_path)
+            file_size = os.path.getsize(file_path_str)
+            file_name = os.path.basename(file_path_str)
+
+            with open(file_path_str, "rb") as f:
+                file_data = f.read()
+
+            # Use client's built-in upload helper if available,
+            # otherwise do a manual upload via upload.saveFilePart
+            file_id = int.from_bytes(os.urandom(8), "big", signed=True)
+            CHUNK_SIZE = 512 * 1024  # 512 KB per part
+            total_parts = max(1, (file_size + CHUNK_SIZE - 1) // CHUNK_SIZE)
+
+            for part_idx in range(total_parts):
+                offset = part_idx * CHUNK_SIZE
+                chunk = file_data[offset:offset + CHUNK_SIZE]
+
+                if total_parts > 1:
+                    result = await client(functions.upload.SaveBigFilePartRequest(
+                        file_id=file_id,
+                        file_part=part_idx,
+                        file_total_parts=total_parts,
+                        bytes=chunk,
+                    ))
+                else:
+                    result = await client(functions.upload.SaveFilePartRequest(
+                        file_id=file_id,
+                        file_part=part_idx,
+                        bytes=chunk,
+                    ))
+
+                if not result:
+                    logger.error("set_chat_photo: upload failed at part %d", part_idx)
+                    return False
+
+            uploaded_file = types.InputFile(
+                id=file_id,
+                parts=total_parts,
+                name=file_name,
+                md5_checksum="",
+            )
+
+            photo_obj = types.InputChatUploadedPhoto(file=uploaded_file)
+
+            request = functions.channels.EditPhotoRequest(
+                channel=input_channel,
+                photo=photo_obj,
+            )
+            await client(request)
+            logger.debug("set_chat_photo: updated photo for %s", chat_id)
+            return True
+
+        except Exception as exc:
+            logger.error("set_chat_photo(chat=%s) failed: %s", chat_id, exc)
+            return False
+
+    async def start_group_call(
+        self,
+        chat_id: Union[int, str],
+        title: Optional[str] = None,
+    ) -> bool:
+        """Start a new group call (voice chat) in a supergroup.
+
+        Uses ``phone.CreateGroupCallRequest`` to initiate the call.
+        The caller must have admin rights with ``manage_call`` enabled.
+
+        Args:
+            chat_id: Supergroup/channel identifier (int ID, @username, etc.).
+            title: Optional title for the group call (e.g. "Team Meeting").
+
+        Returns:
+            ``True`` on success, ``False`` on failure.
+
+        Raises:
+            No exceptions — errors are caught and logged.
+
+        Example:
+            >>> await client.start_group_call(-1001234567890, title="Daily Standup")
+        """
+        client = self._get_client()
+        if not client:
+            logger.warning("start_group_call skipped: client not connected")
+            return False
+
+        try:
+            from spluspy._engine import functions
+        except ImportError:
+            from telethon import functions
+
+        try:
+            input_peer = await self._resolve_to_input_peer(client, chat_id)
+            if input_peer is None:
+                # Fallback: try get_input_entity directly
+                try:
+                    input_peer = await client.get_input_entity(chat_id)
+                except Exception:
+                    logger.error("start_group_call: cannot resolve %s to InputPeer", chat_id)
+                    return False
+
+            import os
+            random_id = int.from_bytes(os.urandom(4), "big", signed=True)
+
+            request = functions.phone.CreateGroupCallRequest(
+                peer=input_peer,
+                random_id=random_id,
+                title=title,
+            )
+            await client(request)
+            logger.debug("start_group_call: started call in %s", chat_id)
+            return True
+
+        except Exception as exc:
+            logger.error("start_group_call(chat=%s) failed: %s", chat_id, exc)
+            return False
+
+    async def stop_group_call(
+        self,
+        chat_id: Union[int, str],
+    ) -> bool:
+        """Stop (discard) an active group call in a supergroup.
+
+        Fetches the current group call via ``channels.GetFullChannelRequest``,
+        extracts the ``InputGroupCall`` from the ``full_chat.call`` attribute,
+        and sends ``phone.DiscardGroupCallRequest`` to end it.
+
+        Args:
+            chat_id: Supergroup/channel identifier (int ID, @username, etc.).
+
+        Returns:
+            ``True`` on success, ``False`` on failure (including when no
+            active call exists).
+
+        Example:
+            >>> await client.stop_group_call(-1001234567890)
+        """
+        client = self._get_client()
+        if not client:
+            logger.warning("stop_group_call skipped: client not connected")
+            return False
+
+        try:
+            from spluspy._engine import functions, types
+        except ImportError:
+            from telethon import functions, types
+
+        try:
+            input_channel = await self._resolve_to_input_channel(client, chat_id)
+            if input_channel is None:
+                logger.error("stop_group_call: cannot resolve %s to InputChannel", chat_id)
+                return False
+
+            # Fetch full channel info to get the active group call
+            full_chat_result = await client(functions.channels.GetFullChannelRequest(
+                channel=input_channel,
+            ))
+
+            full_chat = getattr(full_chat_result, "full_chat", None)
+            if full_chat is None:
+                logger.warning("stop_group_call: no full_chat returned for %s", chat_id)
+                return False
+
+            input_group_call = getattr(full_chat, "call", None)
+            if input_group_call is None:
+                logger.warning("stop_group_call: no active group call in %s", chat_id)
+                return False
+
+            request = functions.phone.DiscardGroupCallRequest(
+                call=input_group_call,
+            )
+            await client(request)
+            logger.debug("stop_group_call: stopped call in %s", chat_id)
+            return True
+
+        except Exception as exc:
+            logger.error("stop_group_call(chat=%s) failed: %s", chat_id, exc)
+            return False
+
     # ── Helper Methods ────────────────────────────────────────────
 
     async def _resolve_to_input_channel(

{spluspy-2.1.0 → spluspy-2.1.2}/spluspy/client/client.py

@@ -545,6 +545,46 @@ class Client(MediaMixin, ChatManagementMixin):
         """Register a handler for edited messages."""
         return self.on(MessageEditedEventBuilder(**kwargs))
 
+    def on_edited_message(self, *message_filters: Any, **kwargs: Any) -> Callable[[Handler], Handler]:
+        """Register a handler for edited messages with optional filters.
+
+        The handler receives ``(client, message)`` as arguments.
+        Multiple filter arguments are combined with ``&`` (AND).
+
+        Example:
+            >>> @bot.on_edited_message(filters.text & filters.private)
+            ... async def on_edited(client, message):
+            ...     await message.reply("Edited!")
+
+            >>> @bot.on_edited_message(filters.group, filters.photo)
+            ... async def on_group_edit(client, message):
+            ...     ...
+        """
+        from spluspy.filters.filters import Filter, AndFilter, CallableFilter
+
+        priority = kwargs.pop("priority", HandlerPriority.NORMAL)
+        builder = MessageEditedEventBuilder(**kwargs)
+        if hasattr(builder, '_priority'):
+            builder._priority = priority
+
+        composed: Any = None
+        for f in message_filters:
+            if isinstance(f, Filter):
+                composed = f if composed is None else AndFilter(composed, f)
+            elif callable(f):
+                cf = CallableFilter(f)
+                composed = cf if composed is None else AndFilter(composed, cf)
+
+        def decorator(func: Handler) -> Handler:
+            self._handlers.setdefault(MessageEdited, []).append(
+                (builder, func, composed)
+            )
+            self._handlers[MessageEdited].sort(
+                key=lambda x: x[0].priority if hasattr(x[0], 'priority') else HandlerPriority.NORMAL
+            )
+            return func
+        return decorator
+
     def on_callback_query(self, **kwargs: Any) -> Callable[[Handler], Handler]:
         """Callback queries are not supported on Soroush+ user sessions.
 
@@ -740,9 +780,111 @@ class Client(MediaMixin, ChatManagementMixin):
                     task.add_done_callback(self._handler_tasks.discard)
 
                 client.add_event_handler(_wrapped, event)
+            elif isinstance(builder, MessageEditedEventBuilder):
+                _filter = composed_filter
+
+                sig = inspect.signature(func)
+                _param_count = len(sig.parameters)
+
+                async def _wrapped_edited(evt, _f=_filter, _pc=_param_count):
+                    raw_msg = evt.message
+
+                    if _f is not None and isinstance(_f, _FilterBase):
+                        _lightweight = _PreMessage(raw_msg)
+                        if not _f(_lightweight):
+                            return
+
+                    sender_id = None
+                    if hasattr(raw_msg, 'sender_id'):
+                        sender_id = raw_msg.sender_id
+                    elif hasattr(raw_msg, 'from_id') and raw_msg.from_id:
+                        fid = raw_msg.from_id
+                        sender_id = getattr(fid, 'user_id', None) if hasattr(fid, 'user_id') else (fid if isinstance(fid, int) else None)
+
+                    chat_id = None
+                    peer = getattr(raw_msg, 'peer_id', None)
+                    if peer is not None:
+                        chat_id = (
+                            getattr(peer, 'channel_id', None)
+                            or getattr(peer, 'chat_id', None)
+                            or getattr(peer, 'user_id', None)
+                        )
+                        if not chat_id:
+                            peer_id_val = getattr(peer, 'id', None)
+                            if peer_id_val:
+                                constructor_name = type(peer).__name__
+                                if "Channel" in constructor_name:
+                                    chat_id = -1000000000000 - peer_id_val
+                                elif "Chat" in constructor_name:
+                                    chat_id = -peer_id_val
+                                else:
+                                    chat_id = peer_id_val
+                    if not chat_id:
+                        prop_val = getattr(raw_msg, 'chat_id', None)
+                        if prop_val and prop_val != raw_msg.id:
+                            chat_id = prop_val
+                    if not chat_id:
+                        chat_obj = getattr(raw_msg, 'chat', None)
+                        if chat_obj is not None:
+                            cid = getattr(chat_obj, 'id', None)
+                            if cid and cid != raw_msg.id:
+                                chat_id = cid
+                    if not chat_id:
+                        chat_id = getattr(raw_msg, 'group_guid', None)
+                    if not chat_id:
+                        chat_id = 0
+
+                    reply_to_id = None
+                    reply_to_sender_id = None
+                    _rid, _rsid = _extract_reply_fields(raw_msg)
+                    reply_to_id = _rid
+                    reply_to_sender_id = _rsid
+
+                    media_obj = getattr(raw_msg, 'media', None)
+                    fwd = getattr(raw_msg, 'fwd_from', None)
+
+                    message = Message(
+                        id=raw_msg.id,
+                        text=getattr(raw_msg, 'message', '') or '',
+                        chat_id=chat_id,
+                        sender_id=sender_id,
+                        is_private=getattr(raw_msg, 'is_private', True),
+                        is_group=getattr(raw_msg, 'is_group', False),
+                        is_channel=getattr(raw_msg, 'is_channel', False),
+                        reply_to=reply_to_id,
+                        reply_to_sender_id=reply_to_sender_id,
+                        media=media_obj,
+                        forward_origin=fwd,
+                        raw=getattr(raw_msg, '__dict__', {}),
+                    )
+                    message._client = self
+
+                    async def _run_handler() -> None:
+                        try:
+                            if _pc >= 2:
+                                await func(self, message)
+                            else:
+                                splus_event = MessageEdited(message=message)
+                                splus_event._set_client(self)
+                                await func(splus_event)
+                        except TypeError:
+                            try:
+                                await func(self, message)
+                            except Exception:
+                                splus_event = MessageEdited(message=message)
+                                splus_event._set_client(self)
+                                await func(splus_event)
+                        except Exception as exc:
+                            logger.error("Handler error: %s: %s", type(exc).__name__, exc)
+                            traceback.print_exc()
+
+                    task = asyncio.create_task(_run_handler())
+                    self._handler_tasks.add(task)
+                    task.add_done_callback(self._handler_tasks.discard)
+
+                client.add_event_handler(_wrapped_edited, se.MessageEdited())
             else:
                 event_map = {
-                    MessageEditedEventBuilder: se.MessageEdited,
                     CallbackQueryEventBuilder: se.CallbackQuery,
                     InlineQueryEventBuilder: se.InlineQuery,
                     ChatActionEventBuilder: se.ChatAction,