spluspy 2.1.1__tar.gz → 2.1.2__tar.gz

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

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

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

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

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

{spluspy-2.1.1 → 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__ = '2.1.1'
+__version__ = '2.1.2'

{spluspy-2.1.1 → 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(