spluspy 2.0.8__tar.gz → 2.0.9__tar.gz

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

@@ -5,6 +5,16 @@ 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.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.0.9}/PKG-INFO

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

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

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

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

{spluspy-2.0.8 → spluspy-2.0.9}/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.0.8 → spluspy-2.0.9}/spluspy/client/client.py

@@ -1786,6 +1786,9 @@ class Client:
     async def leave_chat(self, chat_id: Union[int, str]) -> bool:
         """Leave a chat by ID, username, or invite link.
 
+        Auto-detects whether the target is a channel/supergroup or a basic
+        group and uses the correct TL method.
+
         Args:
             chat_id: Chat integer ID, username (str), or t.me link.
 
@@ -1794,22 +1797,9 @@ class Client:
         """
         client = self._get_client()
         if not client:
-            logger.warning("leave_chat skipped: client not connected")
             return False
         resolved = self._resolve_chat_id(chat_id)
-        try:
-            if hasattr(client, "leave_chat"):
-                await client.leave_chat(resolved)
-            else:
-                await self._leave_chat_via_invoke(client, resolved)
-            logger.debug("leave_chat(%s) succeeded", chat_id)
-            return True
-        except Exception as exc:
-            logger.error("leave_chat(%s) failed: %s", chat_id, exc)
-            return False
 
-    async def _leave_chat_via_invoke(self, client: Any, resolved: Any) -> None:
-        """Leave a chat using raw TL invoke as a fallback."""
         try:
             from spluspy._engine import functions, types  # type: ignore[import-untyped]
         except ImportError:
@@ -1818,14 +1808,317 @@ class Client:
             except ImportError:
                 raise ImportError("No compatible MTProto library available for leave_chat")
 
-        entity = await client.get_entity(resolved)
+        # 1. Try get_entity to detect type
+        try:
+            entity = await client.get_entity(resolved)
+            if isinstance(entity, types.Channel):
+                return await self.leave_channel(chat_id)
+            elif isinstance(entity, types.Chat):
+                return await self.leave_group(chat_id)
+            else:
+                return await self.leave_channel(chat_id)
+        except Exception:
+            pass
 
-        if isinstance(entity, types.Channel):
-            await client(functions.channels.LeaveChannelRequest(channel=entity))
-        elif isinstance(entity, types.Chat):
-            await client(functions.messages.DeleteChatUserRequest(chat_id=entity.id, user_id="me"))
-        else:
+        # 2. Fallback: try get_input_entity
+        try:
+            input_peer = await client.get_input_entity(resolved)
+            if isinstance(input_peer, types.InputPeerChannel):
+                return await self.leave_channel(chat_id)
+            elif isinstance(input_peer, types.InputPeerChat):
+                return await self.leave_group(chat_id)
+            else:
+                return await self.leave_channel(chat_id)
+        except Exception:
+            pass
+
+        # 3. Fallback: try client.leave_chat
+        if hasattr(client, "leave_chat"):
+            try:
+                await client.leave_chat(resolved)
+                return True
+            except Exception:
+                pass
+
+        return False
+
+    async def leave_group(self, chat_id: Union[int, str]) -> bool:
+        """Leave a basic group (supergroup or regular group).
+
+        Uses DeleteChatUserRequest — the correct method for groups.
+
+        Args:
+            chat_id: Group integer ID.
+
+        Returns:
+            True on success, False on failure.
+        """
+        client = self._get_client()
+        if not client:
+            return False
+        resolved = self._resolve_chat_id(chat_id)
+
+        try:
+            from spluspy._engine import functions  # type: ignore[import-untyped]
+        except ImportError:
+            try:
+                from telethon import functions  # type: ignore[import-untyped]
+            except ImportError:
+                raise ImportError("No compatible MTProto library available")
+
+        # Strategy 1: kick_participant('me')
+        if hasattr(client, 'kick_participant'):
+            try:
+                await client.kick_participant(resolved, 'me')
+                return True
+            except Exception:
+                pass
+
+        # Strategy 2: get_entity → DeleteChatUserRequest
+        try:
+            entity = await client.get_entity(resolved)
+            chat_id_raw = getattr(entity, 'chat_id', None) or getattr(entity, 'id', None)
+            await client(functions.messages.DeleteChatUserRequest(
+                chat_id=chat_id_raw, user_id="me"
+            ))
+            return True
+        except Exception:
+            pass
+
+        # Strategy 3: get_input_entity → DeleteChatUserRequest
+        try:
+            input_peer = await client.get_input_entity(resolved)
+            chat_id_raw = getattr(input_peer, 'chat_id', None)
+            if chat_id_raw is not None:
+                await client(functions.messages.DeleteChatUserRequest(
+                    chat_id=chat_id_raw, user_id="me"
+                ))
+                return True
+        except Exception:
+            pass
+
+        return False
+
+    async def leave_channel(self, chat_id: Union[int, str]) -> bool:
+        """Leave a channel or supergroup.
+
+        Uses LeaveChannelRequest — the correct method for channels.
+
+        Args:
+            chat_id: Channel integer ID or username.
+
+        Returns:
+            True on success, False on failure.
+        """
+        client = self._get_client()
+        if not client:
+            return False
+        resolved = self._resolve_chat_id(chat_id)
+
+        try:
+            from spluspy._engine import functions  # type: ignore[import-untyped]
+        except ImportError:
+            try:
+                from telethon import functions  # type: ignore[import-untyped]
+            except ImportError:
+                raise ImportError("No compatible MTProto library available")
+
+        # Strategy 1: get_entity → LeaveChannelRequest
+        try:
+            entity = await client.get_entity(resolved)
             await client(functions.channels.LeaveChannelRequest(channel=entity))
+            return True
+        except Exception:
+            pass
+
+        # Strategy 2: get_input_entity → LeaveChannelRequest
+        try:
+            input_peer = await client.get_input_entity(resolved)
+            await client(functions.channels.LeaveChannelRequest(channel=input_peer))
+            return True
+        except Exception:
+            pass
+
+        # Strategy 3: client.leave_chat fallback
+        if hasattr(client, "leave_chat"):
+            try:
+                await client.leave_chat(resolved)
+                return True
+            except Exception:
+                pass
+
+        return False
+
+    async def get_all_groups(self) -> list[dict]:
+        """Get all groups and channels the bot is a member of.
+
+        Returns:
+            List of dicts with keys: id, title, type ('channel' or 'chat')
+        """
+        client = self._get_client()
+        if not client:
+            logger.warning("get_all_groups skipped: client not connected")
+            return []
+
+        try:
+            dialogs = await client.get_dialogs(limit=None)
+        except Exception as exc:
+            logger.error("get_all_groups: failed to get dialogs: %s", exc)
+            return []
+
+        groups = []
+        for dialog in dialogs:
+            entity = dialog.entity
+            if entity is None:
+                continue
+            entity_type = type(entity).__name__
+            # Skip users (not groups/channels)
+            if "User" in entity_type:
+                continue
+            # Skip self
+            if getattr(entity, 'id', None) == self._user_id:
+                continue
+            groups.append({
+                "id": getattr(entity, 'id', 0),
+                "title": getattr(entity, 'title', 'Unknown'),
+                "type": "channel" if "Channel" in entity_type else "chat",
+                "entity": entity,
+            })
+
+        logger.debug("get_all_groups: found %d groups/channels", len(groups))
+        return groups
+
+    async def leave_all_groups(self, exclude_ids: list[int] = None) -> dict:
+        """Leave all basic groups and supergroups (not channels).
+
+        Args:
+            exclude_ids: List of chat IDs to skip.
+
+        Returns:
+            Dict with 'success', 'failed', 'skipped' counts and details.
+        """
+        exclude_ids = set(exclude_ids or [])
+        all_groups = await self.get_all_groups()
+        result = {"success": 0, "failed": 0, "skipped": 0, "details": []}
+
+        for g in all_groups:
+            if g["type"] == "channel":
+                continue  # only groups
+            chat_id = g["id"]
+            if chat_id in exclude_ids:
+                result["skipped"] += 1
+                result["details"].append({"id": chat_id, "title": g["title"], "status": "skipped"})
+                continue
+
+            ok = await self.leave_group(chat_id)
+            if ok:
+                result["success"] += 1
+                result["details"].append({"id": chat_id, "title": g["title"], "status": "left"})
+            else:
+                result["failed"] += 1
+                result["details"].append({"id": chat_id, "title": g["title"], "status": "failed"})
+            await asyncio.sleep(1)
+
+        return result
+
+    async def leave_all_channels(self, exclude_ids: list[int] = None) -> dict:
+        """Leave all channels (not groups).
+
+        Args:
+            exclude_ids: List of chat IDs to skip.
+
+        Returns:
+            Dict with 'success', 'failed', 'skipped' counts and details.
+        """
+        exclude_ids = set(exclude_ids or [])
+        all_groups = await self.get_all_groups()
+        result = {"success": 0, "failed": 0, "skipped": 0, "details": []}
+
+        for g in all_groups:
+            if g["type"] == "chat":
+                continue  # only channels
+            chat_id = g["id"]
+            if chat_id in exclude_ids:
+                result["skipped"] += 1
+                result["details"].append({"id": chat_id, "title": g["title"], "status": "skipped"})
+                continue
+
+            ok = await self.leave_channel(chat_id)
+            if ok:
+                result["success"] += 1
+                result["details"].append({"id": chat_id, "title": g["title"], "status": "left"})
+            else:
+                result["failed"] += 1
+                result["details"].append({"id": chat_id, "title": g["title"], "status": "failed"})
+            await asyncio.sleep(1)
+
+        return result
+
+    async def leave_all(self, exclude_ids: list[int] = None) -> dict:
+        """Leave all groups and channels.
+
+        Args:
+            exclude_ids: List of chat IDs to skip.
+
+        Returns:
+            Dict with 'success', 'failed', 'skipped' counts and details.
+        """
+        exclude_ids = set(exclude_ids or [])
+        all_groups = await self.get_all_groups()
+        result = {"success": 0, "failed": 0, "skipped": 0, "details": []}
+
+        for g in all_groups:
+            chat_id = g["id"]
+            if chat_id in exclude_ids:
+                result["skipped"] += 1
+                result["details"].append({"id": chat_id, "title": g["title"], "status": "skipped"})
+                continue
+
+            if g["type"] == "channel":
+                ok = await self.leave_channel(chat_id)
+            else:
+                ok = await self.leave_group(chat_id)
+
+            if ok:
+                result["success"] += 1
+                result["details"].append({"id": chat_id, "title": g["title"], "status": "left"})
+            else:
+                result["failed"] += 1
+                result["details"].append({"id": chat_id, "title": g["title"], "status": "failed"})
+            await asyncio.sleep(1)
+
+        return result
+
+    async def delete_all_private(
+        self,
+        *,
+        revoke: bool = False,
+        exclude_ids: list[int] = None,
+        delay: float = 1.0,
+        on_progress=None,
+    ) -> dict:
+        """Delete all private chat dialogs (user conversations).
+
+        Args:
+            revoke: If True, revoke messages for the other peer too.
+            exclude_ids: List of user IDs to skip.
+            delay: Delay in seconds between each delete.
+            on_progress: Callback ``(current, total, title)`` for progress.
+
+        Returns:
+            Dict with 'success', 'failed', 'skipped' counts and details.
+        """
+        client = self._get_client()
+        if not client:
+            logger.warning("delete_all_private skipped: client not connected")
+            return {"success": 0, "failed": 0, "skipped": 0, "details": []}
+
+        return await client.delete_all_private(
+            revoke=revoke,
+            exclude_ids=exclude_ids,
+            delay=delay,
+            on_progress=on_progress,
+        )
 
     async def pin_message(self, chat_id: int, message: Union[Message, int], *, notify: bool = False) -> bool:
         """Pin a message in a chat.

{spluspy-2.0.8 → spluspy-2.0.9}/spluspy/utils/version_check.py

@@ -70,7 +70,8 @@ def print_update_notice(new_version: str) -> None:
     print(
         f"\n\033[33m⚠ SplusPy {new_version} is available "
         f"(installed: {__version__}).\033[0m\n"
-        f"\033[33m  Run: pip install --upgrade spluspy\033[0m\n",
+        f"\033[33m  Run: pip install --upgrade spluspy\033[0m\n"
+        f"\033[33m  Channel » @SplusPy\033[0m\n",
         file=sys.stderr,
     )