spluspy 2.1.3__tar.gz → 2.1.4__tar.gz

{spluspy-2.1.3 → spluspy-2.1.4}/PKG-INFO

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

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

{spluspy-2.1.3 → spluspy-2.1.4}/spluspy/__version__.py

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

{spluspy-2.1.3 → spluspy-2.1.4}/spluspy/_engine/version.py

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

{spluspy-2.1.3 → spluspy-2.1.4}/spluspy/admin.py

@@ -157,6 +157,50 @@ class ChatAdmin:
             logger.error("unmute_user(chat=%s, user=%s) failed: %s", chat_id, user_id, exc)
             return False
 
+    async def pin_chat_message(
+        self,
+        chat_id: int,
+        message_id: Union[int, str],
+        notify: bool = True,
+    ) -> bool:
+        """Pin a specific message in a chat.
+
+        Args:
+            chat_id: Target chat.
+            message_id: Message identifier to pin.
+            notify: If ``True``, notify all members.
+
+        Returns:
+            ``True`` on success, ``False`` on failure.
+        """
+        try:
+            return await self._client.pin_chat_message(
+                chat_id, message_id, notify=notify,
+            )
+        except Exception as exc:
+            logger.error("pin_chat_message(chat=%s, msg=%s) failed: %s", chat_id, message_id, exc)
+            return False
+
+    async def unpin_chat_message(
+        self,
+        chat_id: int,
+        message_id: Union[int, str],
+    ) -> bool:
+        """Unpin a specific message in a chat.
+
+        Args:
+            chat_id: Target chat.
+            message_id: Message identifier to unpin.
+
+        Returns:
+            ``True`` on success, ``False`` on failure.
+        """
+        try:
+            return await self._client.unpin_chat_message(chat_id, message_id)
+        except Exception as exc:
+            logger.error("unpin_chat_message(chat=%s, msg=%s) failed: %s", chat_id, message_id, exc)
+            return False
+
     async def pin_message(
         self,
         chat_id: int,

{spluspy-2.1.3 → spluspy-2.1.4}/spluspy/client/client.py

@@ -2120,12 +2120,17 @@ class Client(MediaMixin, ChatManagementMixin):
             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.
+    async def pin_chat_message(
+        self,
+        chat_id: Union[int, str],
+        message_id: Union[int, str],
+        notify: bool = True,
+    ) -> bool:
+        """Pin a specific message in a chat.
 
         Args:
-            chat_id: Target chat identifier.
-            message: :class:`Message` object or message ID to pin.
+            chat_id: Target chat identifier (int ID, ``@username``, etc.).
+            message_id: Message identifier to pin (int or str).
             notify: If ``True``, notify all members about the pin.
 
         Returns:
@@ -2133,38 +2138,89 @@ class Client(MediaMixin, ChatManagementMixin):
         """
         client = self._get_client()
         if not client:
-            logger.warning("pin_message skipped: client not connected")
+            logger.warning("pin_chat_message skipped: client not connected")
             return False
-        msg_id = message.id if isinstance(message, Message) else message
+        msg_id = int(message_id)
         try:
-            await client.pin_message(chat_id, msg_id, notify=notify)
+            try:
+                from spluspy._engine import functions
+            except ImportError:
+                from telethon import functions  # type: ignore[import-untyped]
+
+            input_peer = await client.get_input_entity(int(chat_id))
+            await client(functions.messages.UpdatePinnedMessageRequest(
+                peer=input_peer,
+                id=msg_id,
+                silent=not notify,
+            ))
             return True
         except Exception as exc:
-            logger.error("pin_message(chat=%s, msg=%s) failed: %s", chat_id, msg_id, exc)
+            logger.error("pin_chat_message(chat=%s, msg=%s) failed: %s", chat_id, msg_id, exc)
             return False
 
-    async def unpin_message(self, chat_id: int, message: Union[Message, int]) -> bool:
-        """Unpin a message in a chat.
+    async def unpin_chat_message(
+        self,
+        chat_id: Union[int, str],
+        message_id: Union[int, str],
+    ) -> bool:
+        """Unpin a specific message in a chat.
 
         Args:
-            chat_id: Target chat identifier.
-            message: :class:`Message` object or message ID to unpin.
+            chat_id: Target chat identifier (int ID, ``@username``, etc.).
+            message_id: Message identifier to unpin (int or str).
 
         Returns:
             ``True`` on success, ``False`` on failure.
         """
         client = self._get_client()
         if not client:
-            logger.warning("unpin_message skipped: client not connected")
+            logger.warning("unpin_chat_message skipped: client not connected")
             return False
-        msg_id = message.id if isinstance(message, Message) else message
+        msg_id = int(message_id)
         try:
-            await client.unpin_message(chat_id, msg_id)
+            try:
+                from spluspy._engine import functions
+            except ImportError:
+                from telethon import functions  # type: ignore[import-untyped]
+
+            input_peer = await client.get_input_entity(int(chat_id))
+            await client(functions.messages.UpdatePinnedMessageRequest(
+                peer=input_peer,
+                id=msg_id,
+                unpin=True,
+            ))
             return True
         except Exception as exc:
-            logger.error("unpin_message(chat=%s, msg=%s) failed: %s", chat_id, msg_id, exc)
+            logger.error("unpin_chat_message(chat=%s, msg=%s) failed: %s", chat_id, msg_id, exc)
             return False
 
+    async def pin_message(self, chat_id: int, message: Union[Message, int], *, notify: bool = False) -> bool:
+        """Pin a message in a chat.
+
+        Args:
+            chat_id: Target chat identifier.
+            message: :class:`Message` object or message ID to pin.
+            notify: If ``True``, notify all members about the pin.
+
+        Returns:
+            ``True`` on success, ``False`` on failure.
+        """
+        msg_id = message.id if isinstance(message, Message) else message
+        return await self.pin_chat_message(chat_id, msg_id, notify=notify)
+
+    async def unpin_message(self, chat_id: int, message: Union[Message, int]) -> bool:
+        """Unpin a message in a chat.
+
+        Args:
+            chat_id: Target chat identifier.
+            message: :class:`Message` object or message ID to unpin.
+
+        Returns:
+            ``True`` on success, ``False`` on failure.
+        """
+        msg_id = message.id if isinstance(message, Message) else message
+        return await self.unpin_chat_message(chat_id, msg_id)
+
     async def unpin_all_messages(self, chat_id: int) -> bool:
         client = self._get_client()
         if not client:

{spluspy-2.1.3 → spluspy-2.1.4}/spluspy/models/message.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import logging
 from dataclasses import dataclass, field
 from datetime import datetime
 from typing import TYPE_CHECKING, Any, Optional, Union
@@ -19,6 +20,8 @@ if TYPE_CHECKING:
     from spluspy.models.media import Media
     from spluspy.models.user import User
 
+logger = logging.getLogger("message")
+
 
 @dataclass(slots=True)
 class Message:
@@ -166,36 +169,90 @@ class Message:
     async def get_reply_message(self) -> Optional["Message"]:
         """Get the message this message is replying to.
 
+        Validates that this message is actually a reply by checking
+        :attr:`is_reply` / :attr:`reply_to`, then fetches the parent
+        message from the server via the bound client.
+
         Returns:
-            The replied-to Message, or None if not available.
+            The replied-to :class:`Message`, or ``None`` if this is
+            not a reply, the message is not bound, or the fetch fails.
         """
         if self._client is None:
-            raise RuntimeError("Message is not bound to a client")
-        if not self.reply_to:
+            logger.warning("get_reply_message: message not bound to a client")
+            return None
+        if not self.is_reply or not self.reply_to:
             return None
         if self.reply_to_message is not None:
             return self.reply_to_message
-        messages = await self._client.get_messages(
-            self.chat_id, limit=1, offset_id=self.reply_to - 1,
-        )
-        if messages and messages[0].id == self.reply_to:
-            self.reply_to_message = messages[0]
-            return messages[0]
-        return None
+        try:
+            client = self._client._get_client()
+            if client is None:
+                logger.warning("get_reply_message: underlying client not connected")
+                return None
+            raw_msg = await client.get_messages(self.chat_id, ids=self.reply_to)
+            if raw_msg is None:
+                logger.warning(
+                    "get_reply_message: could not fetch message %s from chat %s",
+                    self.reply_to, self.chat_id,
+                )
+                return None
+            from spluspy.client.client import _extract_reply_fields
+
+            sender_id = getattr(raw_msg, "sender_id", None)
+            if sender_id is None and 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)
+                )
+            reply_to, reply_to_sender_id = _extract_reply_fields(raw_msg)
+
+            self.reply_to_message = Message(
+                id=raw_msg.id,
+                text=getattr(raw_msg, "message", "") or "",
+                chat_id=self.chat_id,
+                sender_id=sender_id,
+                reply_to=reply_to,
+                reply_to_sender_id=reply_to_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),
+                media=getattr(raw_msg, "media", None),
+                forward_origin=getattr(raw_msg, "fwd_from", None),
+            )
+            self.reply_to_message._client = self._client
+            return self.reply_to_message
+        except Exception as exc:
+            logger.warning("get_reply_message failed: %s", exc)
+            return None
+
+    async def pin(self, notify: bool = True) -> bool:
+        """Pin this message in its chat.
 
-    async def pin(self, notify: bool = False) -> bool:
-        """Pin this message in its chat."""
+        Args:
+            notify: If ``True``, notify all members about the pin.
+
+        Returns:
+            ``True`` on success, ``False`` on failure.
+        """
         if self._client is None:
             raise RuntimeError("Message is not bound to a client")
-        return await self._client.pin_message(
-            self.chat_id, self, notify=notify
+        return await self._client.pin_chat_message(
+            self.chat_id, self.id, notify=notify,
         )
 
     async def unpin(self) -> bool:
-        """Unpin this message."""
+        """Unpin this message.
+
+        Returns:
+            ``True`` on success, ``False`` on failure.
+        """
         if self._client is None:
             raise RuntimeError("Message is not bound to a client")
-        return await self._client.unpin_message(self.chat_id, self)
+        return await self._client.unpin_chat_message(
+            self.chat_id, self.id,
+        )
 
     async def react(self, emoji: str) -> bool:
         """Add a reaction to this message."""