spluspy 2.0.8__tar.gz → 2.1.0__tar.gz

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

@@ -5,6 +5,21 @@ 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.0] - 2026-07-12
+
+### Changed
+- Version bump to 2.1.0
+
+## [2.0.9] - 2026-07-12
+
+### Added
+- `leave_all()` method to leave all groups and channels at once
+- `delete_all_private()` method to delete all private chat dialogs
+- `/delete_all_private` bot command with confirmation flow
+
+### Changed
+- `/leave_all_groups` bot command now uses `leave_all()` to include channels
+
 ## [2.0.8] - 2026-07-12
 
 ### Changed

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spluspy
-Version: 2.0.8
+Version: 2.1.0
 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
@@ -25,6 +25,8 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Requires-Dist: aiohttp>=3.9.0
 Requires-Dist: aiosqlite>=0.19.0
+Requires-Dist: pyaes>=1.6
+Requires-Dist: rsa>=4.7
 Provides-Extra: all
 Requires-Dist: asyncpg>=0.27.0; extra == 'all'
 Requires-Dist: black>=23.0; extra == 'all'

{spluspy-2.0.8 → spluspy-2.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "spluspy"
-version = "2.0.8"
+version = "2.1.0"
 description = "A modern async Python library for interacting with Soroush Plus"
 readme = "README.md"
 license = "MIT"
@@ -37,6 +37,8 @@ classifiers = [
 dependencies = [
     "aiosqlite>=0.19.0",
     "aiohttp>=3.9.0",
+    "pyaes>=1.6",
+    "rsa>=4.7",
 ]
 
 [project.optional-dependencies]

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

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

{spluspy-2.0.8 → spluspy-2.1.0}/spluspy/_engine/client/dialogs.py

@@ -477,6 +477,103 @@ class DialogMethods:
 
         return result
 
+    async def delete_all_private(
+            self: 'SoroushClient',
+            *,
+            revoke: bool = False,
+            exclude_ids: typing.Optional[typing.List[int]] = None,
+            delay: float = 1.0,
+            on_progress: typing.Optional[typing.Callable] = None
+    ) -> dict:
+        """
+        Delete all private chat dialogs (user conversations).
+
+        Iterates through all dialogs, identifies private chats (users),
+        and deletes them. Useful for cleaning up bot spam or old conversations.
+
+        Arguments
+            revoke (`bool`, optional):
+                If ``True``, revoke (delete) messages for the other peer too.
+                Default is ``False``.
+
+            exclude_ids (list of `int`, optional):
+                List of user IDs to skip (e.g. your own account, important contacts).
+
+            delay (`float`, optional):
+                Delay in seconds between each delete to avoid flood waits.
+                Default is ``1.0``.
+
+            on_progress (callable, optional):
+                Callback called with ``(current, total, title)`` for progress updates.
+
+        Returns
+            Dict with 'success', 'failed', 'skipped' counts and details.
+
+        Example
+            .. code-block:: python
+
+                # Delete all private chats
+                result = await client.delete_all_private()
+                print(f"Deleted {result['success']} chats")
+
+                # Delete but keep certain users
+                result = await client.delete_all_private(exclude_ids=[12345, 67890])
+        """
+        exclude_ids = set(exclude_ids or [])
+        result = {"success": 0, "failed": 0, "skipped": 0, "details": []}
+
+        try:
+            dialogs = await self.get_dialogs(limit=None)
+        except Exception as exc:
+            _log.error("delete_all_private: failed to get dialogs: %s", exc)
+            return result
+
+        private_dialogs = []
+        for dialog in dialogs:
+            entity = dialog.entity
+            if entity is None:
+                continue
+            # Only user dialogs (private chats)
+            if not isinstance(entity, types.User):
+                continue
+            # Skip self
+            if entity.self:
+                continue
+            user_id = entity.id
+            if user_id in exclude_ids:
+                result["skipped"] += 1
+                result["details"].append({
+                    "id": user_id,
+                    "title": getattr(entity, 'first_name', None) or getattr(entity, 'username', str(user_id)),
+                    "status": "skipped"
+                })
+                continue
+            private_dialogs.append((user_id, entity))
+
+        total = len(private_dialogs)
+        _log.info("delete_all_private: found %d private chats to delete", total)
+
+        for idx, (user_id, entity) in enumerate(private_dialogs):
+            title = getattr(entity, 'first_name', None) or getattr(entity, 'username', str(user_id))
+            if on_progress:
+                try:
+                    on_progress(idx + 1, total, title)
+                except Exception:
+                    pass
+            try:
+                await self.delete_dialog(entity, revoke=revoke)
+                result["success"] += 1
+                result["details"].append({"id": user_id, "title": title, "status": "deleted"})
+                _log.debug("delete_all_private: deleted %s (%d)", title, user_id)
+            except Exception as exc:
+                result["failed"] += 1
+                result["details"].append({"id": user_id, "title": title, "status": "failed"})
+                _log.warning("delete_all_private: failed to delete %s (%d): %s", title, user_id, exc)
+            if delay > 0 and idx < total - 1:
+                await asyncio.sleep(delay)
+
+        return result
+
     def conversation(
             self: 'SoroushClient',
             entity: 'hints.EntityLike',

spluspy-2.1.0/spluspy/client/chat_mixin.py

@@ -0,0 +1,507 @@
+"""Advanced Chat Management Mixin for SplusPy Client.
+
+Provides raw MTProto implementations for managing channels/megagroups
+including member retrieval, restriction, and promotion.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from datetime import datetime, timezone
+from typing import Any, Optional, Union
+
+logger = logging.getLogger("client.chat")
+
+
+class ChatManagementMixin:
+    """Mixin class providing raw MTProto chat management methods.
+
+    This mixin must be used with a Client class that provides:
+    - ``_get_client()`` → returns the underlying adapter/MTProto client
+    - ``resolve_peer(peer)`` → resolves a peer to InputPeer
+    - ``invoke(request)`` or ``client(request)`` → sends raw TL requests
+    - ``_build_user(entity)`` → builds a User model from raw entity
+    """
+
+    async def get_chat_members(
+        self,
+        chat_id: Union[int, str],
+        limit: int = 200,
+    ) -> list[Any]:
+        """Get a list of members in a channel/megagroup using raw MTProto.
+
+        Uses channels.GetParticipantsRequest with ChannelParticipantsRecent
+        filter to fetch the members list.
+
+        Args:
+            chat_id: Channel/supergroup identifier (int ID, username, etc.).
+            limit: Maximum number of members to return (default 200).
+                Note: Telegram limits this to 200 per request. Use multiple
+                calls with offset for larger lists.
+
+        Returns:
+            A list of User objects for each member.
+
+        Raises:
+            RuntimeError: If the client is not connected.
+            ValueError: If the peer cannot be resolved to an InputChannel.
+
+        Example:
+            >>> members = await client.get_chat_members(-1001234567890)
+            >>> for member in members:
+            ...     print(member.first_name, member.id)
+        """
+        client = self._get_client()
+        if not client:
+            raise RuntimeError("Client not connected")
+
+        try:
+            from spluspy._engine import functions, types
+        except ImportError:
+            from telethon import functions, types
+
+        # Resolve to InputChannel
+        input_channel = await self._resolve_to_input_channel(client, chat_id)
+        if input_channel is None:
+            raise ValueError(f"Cannot resolve {chat_id!r} to an InputChannel")
+
+        all_users: list[Any] = []
+        offset = 0
+        batch_size = min(limit, 200)
+
+        while len(all_users) < limit:
+            request = functions.channels.GetParticipantsRequest(
+                channel=input_channel,
+                filter=types.ChannelParticipantsRecent(),
+                offset=offset,
+                limit=batch_size,
+                hash=0,
+            )
+
+            result = await client(request)
+
+            # Extract users from the result
+            users = getattr(result, "users", []) or []
+            participants = getattr(result, "participants", []) or []
+
+            if not participants:
+                break
+
+            # Build User objects from the users list
+            user_map = {u.id: u for u in users}
+
+            for participant in participants:
+                user_id = getattr(participant, "user_id", None)
+                if user_id and user_id in user_map:
+                    raw_user = user_map[user_id]
+                    user = self._build_user(raw_user)
+                    all_users.append(user)
+
+            offset += len(participants)
+
+            # If we got fewer than requested, there are no more
+            if len(participants) < batch_size:
+                break
+
+            # Yield to event loop
+            await asyncio.sleep(0)
+
+        logger.debug(
+            "get_chat_members: fetched %d members from %s",
+            len(all_users), chat_id,
+        )
+        return all_users[:limit]
+
+    async def restrict_user(
+        self,
+        chat_id: Union[int, str],
+        user_id: Union[int, str],
+        send_messages: bool = False,
+        until_date: int = 0,
+        *,
+        send_media: bool = False,
+        send_stickers: bool = False,
+        send_gifs: bool = False,
+        send_inline: bool = False,
+        embed_links: bool = False,
+        send_polls: bool = False,
+        change_info: bool = False,
+        invite_users: bool = False,
+        pin_messages: bool = False,
+        manage_topics: bool = False,
+    ) -> bool:
+        """Restrict a user in a megagroup/channel using raw MTProto.
+
+        Uses channels.EditBannedRequest to apply restrictions to a user.
+
+        Args:
+            chat_id: Channel/supergroup identifier.
+            user_id: User to restrict (int ID or @username).
+            send_messages: If True, user cannot send messages.
+            until_date: Unix timestamp when restriction expires.
+                0 = permanent restriction.
+            send_media: If True, user cannot send media.
+            send_stickers: If True, user cannot send stickers.
+            send_gifs: If True, user cannot send GIFs.
+            send_inline: If True, user cannot use inline bots.
+            embed_links: If True, user cannot embed links.
+            send_polls: If True, user cannot send polls.
+            change_info: If True, user cannot change chat info.
+            invite_users: If True, user cannot invite users.
+            pin_messages: If True, user cannot pin messages.
+            manage_topics: If True, user cannot manage topics.
+
+        Returns:
+            True on success, False on failure.
+
+        Example:
+            >>> # Mute a user (no messages, no media)
+            >>> await client.restrict_user(chat_id, user_id,
+            ...     send_messages=True, send_media=True)
+            >>>
+            >>> # Temporary mute for 1 hour
+            >>> import time
+            >>> await client.restrict_user(chat_id, user_id,
+            ...     send_messages=True, until_date=int(time.time()) + 3600)
+        """
+        client = self._get_client()
+        if not client:
+            logger.warning("restrict_user skipped: client not connected")
+            return False
+
+        try:
+            from spluspy._engine import functions, types
+        except ImportError:
+            from telethon import functions, types
+
+        try:
+            # Resolve the channel
+            input_channel = await self._resolve_to_input_channel(client, chat_id)
+            if input_channel is None:
+                logger.error("restrict_user: cannot resolve %s to InputChannel", chat_id)
+                return False
+
+            # Resolve the user to InputPeer
+            input_peer = await self._resolve_to_input_peer(client, user_id)
+            if input_peer is None:
+                logger.error("restrict_user: cannot resolve %s to InputPeer", user_id)
+                return False
+
+            # Convert until_date to datetime if needed
+            until_datetime = None
+            if until_date > 0:
+                until_datetime = datetime.fromtimestamp(until_date, tz=timezone.utc)
+
+            # Construct ChatBannedRights
+            # Setting a right to True means the user is BANNED from that action
+            banned_rights = types.ChatBannedRights(
+                until_date=until_datetime,
+                view_messages=False,  # Never ban from viewing
+                send_messages=send_messages,
+                send_media=send_media,
+                send_stickers=send_stickers,
+                send_gifs=send_gifs,
+                send_games=False,
+                send_inline=send_inline,
+                embed_links=embed_links,
+                send_polls=send_polls,
+                change_info=change_info,
+                invite_users=invite_users,
+                pin_messages=pin_messages,
+                manage_topics=manage_topics,
+                send_photos=send_media,
+                send_videos=send_media,
+                send_roundvideos=send_media,
+                send_audios=send_media,
+                send_voices=send_media,
+                send_docs=send_media,
+                send_plain=send_messages,
+            )
+
+            request = functions.channels.EditBannedRequest(
+                channel=input_channel,
+                participant=input_peer,
+                banned_rights=banned_rights,
+            )
+
+            await client(request)
+            logger.debug(
+                "restrict_user: restricted user %s in %s",
+                user_id, chat_id,
+            )
+            return True
+
+        except Exception as exc:
+            logger.error(
+                "restrict_user(chat=%s, user=%s) failed: %s",
+                chat_id, user_id, exc,
+            )
+            return False
+
+    async def promote_member(
+        self,
+        chat_id: Union[int, str],
+        user_id: Union[int, str],
+        is_admin: bool = True,
+        privileges: Optional[dict[str, bool]] = None,
+        *,
+        rank: str = "",
+    ) -> bool:
+        """Promote or demote a user in a megagroup/channel using raw MTProto.
+
+        Uses channels.EditAdminRequest to modify a user's admin status.
+
+        Args:
+            chat_id: Channel/supergroup identifier.
+            user_id: User to promote/demote (int ID or @username).
+            is_admin: If True, promote to admin. If False, demote to regular user.
+            privileges: Optional dict of admin privileges to grant. Keys are:
+                - change_info: Can change channel/group info
+                - post_messages: Can post messages in channel
+                - edit_messages: Can edit all messages
+                - delete_messages: Can delete any messages
+                - ban_users: Can ban users
+                - invite_users: Can invite users
+                - pin_messages: Can pin messages
+                - add_admins: Can add other admins
+                - anonymous: Can be anonymous admin
+                - manage_call: Can manage group calls
+                - other: Other admin rights
+                - manage_topics: Can manage topics
+                - post_stories: Can post stories
+                - edit_stories: Can edit stories
+                - delete_stories: Can delete stories
+
+                If None and is_admin=True, applies default admin rights.
+            rank: Optional rank/title string for the admin (e.g., "Admin", "Moderator").
+
+        Returns:
+            True on success, False on failure.
+
+        Example:
+            >>> # Promote with default admin rights
+            >>> await client.promote_member(chat_id, user_id)
+            >>>
+            >>> # Promote with specific privileges
+            >>> await client.promote_member(chat_id, user_id, privileges={
+            ...     "delete_messages": True,
+            ...     "ban_users": True,
+            ...     "invite_users": True,
+            ... })
+            >>>
+            >>> # Demote a user
+            >>> await client.promote_member(chat_id, user_id, is_admin=False)
+        """
+        client = self._get_client()
+        if not client:
+            logger.warning("promote_member skipped: client not connected")
+            return False
+
+        try:
+            from spluspy._engine import functions, types
+        except ImportError:
+            from telethon import functions, types
+
+        try:
+            # Resolve the channel
+            input_channel = await self._resolve_to_input_channel(client, chat_id)
+            if input_channel is None:
+                logger.error("promote_member: cannot resolve %s to InputChannel", chat_id)
+                return False
+
+            # Resolve the user to InputUser
+            input_user = await self._resolve_to_input_user(client, user_id)
+            if input_user is None:
+                logger.error("promote_member: cannot resolve %s to InputUser", user_id)
+                return False
+
+            # Construct ChatAdminRights
+            if is_admin:
+                if privileges:
+                    # Use provided privileges
+                    admin_rights = types.ChatAdminRights(
+                        change_info=privileges.get("change_info", False),
+                        post_messages=privileges.get("post_messages", False),
+                        edit_messages=privileges.get("edit_messages", False),
+                        delete_messages=privileges.get("delete_messages", False),
+                        ban_users=privileges.get("ban_users", False),
+                        invite_users=privileges.get("invite_users", False),
+                        pin_messages=privileges.get("pin_messages", False),
+                        add_admins=privileges.get("add_admins", False),
+                        anonymous=privileges.get("anonymous", False),
+                        manage_call=privileges.get("manage_call", False),
+                        other=privileges.get("other", False),
+                        manage_topics=privileges.get("manage_topics", False),
+                        post_stories=privileges.get("post_stories", False),
+                        edit_stories=privileges.get("edit_stories", False),
+                        delete_stories=privileges.get("delete_stories", False),
+                    )
+                else:
+                    # Default admin rights: delete messages, ban users, invite users
+                    admin_rights = types.ChatAdminRights(
+                        change_info=True,
+                        post_messages=False,
+                        edit_messages=False,
+                        delete_messages=True,
+                        ban_users=True,
+                        invite_users=True,
+                        pin_messages=True,
+                        add_admins=False,
+                        anonymous=False,
+                        manage_call=False,
+                        other=False,
+                        manage_topics=False,
+                        post_stories=False,
+                        edit_stories=False,
+                        delete_stories=False,
+                    )
+            else:
+                # Demote: all rights False
+                admin_rights = types.ChatAdminRights(
+                    change_info=False,
+                    post_messages=False,
+                    edit_messages=False,
+                    delete_messages=False,
+                    ban_users=False,
+                    invite_users=False,
+                    pin_messages=False,
+                    add_admins=False,
+                    anonymous=False,
+                    manage_call=False,
+                    other=False,
+                    manage_topics=False,
+                    post_stories=False,
+                    edit_stories=False,
+                    delete_stories=False,
+                )
+
+            request = functions.channels.EditAdminRequest(
+                channel=input_channel,
+                user_id=input_user,
+                admin_rights=admin_rights,
+                rank=rank if is_admin else "",
+            )
+
+            await client(request)
+            logger.debug(
+                "promote_member: %s user %s in %s",
+                "promoted" if is_admin else "demoted",
+                user_id, chat_id,
+            )
+            return True
+
+        except Exception as exc:
+            logger.error(
+                "promote_member(chat=%s, user=%s) failed: %s",
+                chat_id, user_id, exc,
+            )
+            return False
+
+    # ── Helper Methods ────────────────────────────────────────────
+
+    async def _resolve_to_input_channel(
+        self, client: Any, chat_id: Union[int, str]
+    ) -> Optional[Any]:
+        """Resolve a chat_id to an InputChannel object."""
+        try:
+            from spluspy._engine import types
+        except ImportError:
+            from telethon import types
+
+        try:
+            # Try get_input_entity first (returns InputPeer*)
+            input_peer = await client.get_input_entity(chat_id)
+
+            # Convert InputPeerChannel to InputChannel
+            if isinstance(input_peer, types.InputPeerChannel):
+                return types.InputChannel(
+                    channel_id=input_peer.channel_id,
+                    access_hash=input_peer.access_hash,
+                )
+
+            # If it's a Chat (basic group), we can't use channels.* methods
+            if isinstance(input_peer, types.InputPeerChat):
+                logger.warning(
+                    "_resolve_to_input_channel: %s is a basic group, "
+                    "not a channel/supergroup. channels.* methods require "
+                    "a supergroup or channel.",
+                    chat_id,
+                )
+                return None
+
+        except Exception:
+            pass
+
+        # Fallback: try get_entity
+        try:
+            entity = await client.get_entity(chat_id)
+            if isinstance(entity, types.Channel):
+                return types.InputChannel(
+                    channel_id=entity.id,
+                    access_hash=entity.access_hash,
+                )
+        except Exception:
+            pass
+
+        return None
+
+    async def _resolve_to_input_peer(
+        self, client: Any, user_id: Union[int, str]
+    ) -> Optional[Any]:
+        """Resolve a user_id to an InputPeer object."""
+        try:
+            input_peer = await client.get_input_entity(user_id)
+            return input_peer
+        except Exception:
+            pass
+
+        # Fallback: try get_entity
+        try:
+            from spluspy._engine import types
+        except ImportError:
+            from telethon import types
+
+        try:
+            entity = await client.get_entity(user_id)
+            if isinstance(entity, types.User):
+                return types.InputPeerUser(
+                    user_id=entity.id,
+                    access_hash=entity.access_hash,
+                )
+        except Exception:
+            pass
+
+        return None
+
+    async def _resolve_to_input_user(
+        self, client: Any, user_id: Union[int, str]
+    ) -> Optional[Any]:
+        """Resolve a user_id to an InputUser object."""
+        try:
+            from spluspy._engine import types
+        except ImportError:
+            from telethon import types
+
+        try:
+            input_peer = await client.get_input_entity(user_id)
+            if isinstance(input_peer, types.InputPeerUser):
+                return types.InputUser(
+                    user_id=input_peer.user_id,
+                    access_hash=input_peer.access_hash,
+                )
+        except Exception:
+            pass
+
+        # Fallback: try get_entity
+        try:
+            entity = await client.get_entity(user_id)
+            if isinstance(entity, types.User):
+                return types.InputUser(
+                    user_id=entity.id,
+                    access_hash=entity.access_hash,
+                )
+        except Exception:
+            pass
+
+        return None