PySPlusthon 0.5.3__py3-none-any.whl

PySPlusthon/objects/message.py

@@ -0,0 +1,478 @@
+from typing import BinaryIO, List, Union
+
+from PySPlusthon import objects
+from . import Object
+from .audio import Audio
+from .animation import Animation
+from .chat import Chat
+from .date import Date
+from .document import Document
+from .photo import Photo
+from .sticker import Sticker
+from .user import User
+from .video import Video
+from .voice import Voice
+from .message_id import MessageId
+from ..enums import MessageMediaType
+from ..sync_support import add_sync_support_to_object
+from ..proto import structs
+
+
+@add_sync_support_to_object
+class Message(Object):
+    attribute_names = [
+        ("id", "message_id"),
+        ("author", "from")
+    ]
+
+    @classmethod
+    def wrap(cls, raw_object):
+        try:
+            if not raw_object.get("voice") and raw_object["document"]["mime_type"].startswith("audio"):
+                raw_object["audio"] = raw_object["document"]
+        except (TypeError, KeyError):
+            pass
+        try:
+            if not raw_object.get("video") and raw_object["document"]["mime_type"].startswith("video"):
+                raw_object["animation"] = raw_object["document"]
+        except (TypeError, KeyError):
+            pass
+        return super().wrap(raw_object)
+
+    @classmethod
+    def from_protobuf(cls, protobuf_data):
+        is_forward_message = (
+            not isinstance(protobuf_data, structs.QuotedMessage) and
+            not protobuf_data.message.ListFields() and
+            protobuf_data.quoted_message.ListFields()
+        )
+        if isinstance(protobuf_data, structs.QuotedMessage):
+            id = str(MessageId(rid=protobuf_data.message_id.value, date=protobuf_data.message_date))
+            author = User.from_protobuf(protobuf_data.sender_user_id)
+            chat = Chat.from_protobuf(protobuf_data.quoted_peer)
+            date = Date.from_protobuf(protobuf_data.message_date)
+            message = protobuf_data.quoted_message_content
+        else:
+            id = str(MessageId(rid=protobuf_data.rid, date=protobuf_data.date))
+            author = User.from_protobuf(protobuf_data.sender_uid)
+            chat = Chat.from_protobuf(protobuf_data.peer)
+            date = Date.from_protobuf(protobuf_data.date)
+            message = protobuf_data.message if protobuf_data.message.ListFields() \
+                else protobuf_data.quoted_message.quoted_message_content
+
+        return cls(
+            id=id,
+            author=author,
+            chat=chat,
+            date=date,
+            forward_from=(
+                User.from_protobuf(protobuf_data.quoted_message.sender_user_id)
+                if is_forward_message else None
+            ),
+            forward_from_chat=(
+                Chat(id=f"{protobuf_data.quoted_message.public_group_id.value}|2")
+                if is_forward_message
+                   and protobuf_data.quoted_message.HasField("public_group_id")
+                else None
+            ),
+            forward_from_message_id=(
+                str(MessageId(
+                    rid=protobuf_data.quoted_message.message_id.value,
+                    date=protobuf_data.quoted_message.message_date
+                ))
+                if is_forward_message else None
+            ),
+            forward_date=(
+                Date.from_protobuf(protobuf_data.quoted_message.message_date)
+                if is_forward_message else None
+            ),
+            reply_to_message=(
+                cls.from_protobuf(protobuf_data.quoted_message)
+                if not isinstance(protobuf_data, structs.QuotedMessage)
+                   and protobuf_data.message.ListFields()
+                   and protobuf_data.quoted_message.ListFields()
+                else None
+            ),
+            text=(
+                message.text_message.text
+                if message.HasField("text_message") else None
+            ),
+            document=(
+                Document.from_protobuf(message.document_message)
+                if message.HasField("document_message") else None
+            ),
+            photo=(
+                Photo.from_protobuf(message.document_message)
+                if message.HasField("document_message")
+                   and message.document_message.ext.HasField("document_ex_photo")
+                else None
+            ),
+            video=(
+                Video.from_protobuf(message.document_message)
+                if message.HasField("document_message")
+                   and message.document_message.ext.HasField("document_ex_video")
+                else None
+            ),
+            animation=(
+                Animation.from_protobuf(message.document_message)
+                if message.HasField("document_message")
+                   and message.document_message.ext.HasField("document_ex_gif")
+                else None
+            ),
+            voice=(
+                Voice.from_protobuf(message.document_message)
+                if message.HasField("document_message")
+                   and message.document_message.ext.HasField("document_ex_voice")
+                else None
+            ),
+            audio=(
+                Audio.from_protobuf(message.document_message)
+                if message.HasField("document_message")
+                   and message.document_message.ext.HasField("document_ex_audio")
+                else None
+            ),
+            sticker=(
+                Sticker.from_protobuf(message.sticker_message)
+                if message.HasField("sticker_message")
+                else None
+            ),
+            caption=(
+                message.document_message.caption.text
+                if message.HasField("document_message")
+                   and message.document_message.HasField("caption")
+                else None
+            )
+        )
+
+    def __init__(
+            self,
+            id: int = None,
+            author: "objects.User" = None,
+            date: "objects.Date" = None,
+            chat: "objects.Chat" = None,
+            sender_chat: "objects.Chat" = None,
+            forward_origin: "objects.ForwardOrigin" = None,
+            forward_from: "objects.User" = None,
+            forward_from_chat: "objects.Chat" = None,
+            forward_from_message_id: int = None,
+            forward_date: "objects.Date" = None,
+            reply_to_message: "objects.Message" = None,
+            edit_date: "objects.Date" = None,
+            text: str = None,
+            animation: "objects.Animation" = None,
+            entities: List["objects.Entity"] = None,
+            caption_entities: List["objects.Entity"] = None,
+            voice: "objects.Voice" = None,
+            audio: "objects.Audio" = None,
+            document: "objects.Document" = None,
+            photo: List["objects.Photo"] = None,
+            video: "objects.Video" = None,
+            sticker: "objects.Sticker" = None,
+            caption: str = None,
+            contact: "objects.Contact" = None,
+            location: "objects.Location" = None,
+            new_chat_members: List["objects.User"] = None,
+            left_chat_member: "objects.User" = None,
+            new_chat_title: str = None,
+            new_chat_photo: List["objects.Photo"] = None,
+            delete_chat_photo: bool = None,
+            group_chat_created: bool = None,
+            supergroup_chat_created: bool = None,
+            channel_chat_created: bool = None,
+            pinned_message: None = None,
+            media_group_id: int = None,
+            poll: "objects.Poll" = None,
+            reply_markup: "objects.ReplyMarkup" = None,
+            **kwargs
+    ):
+        super().__init__(**kwargs)
+        self.id: int = id
+        self.author: "objects.User" = author
+        self.date: "objects.Date" = date
+        self.chat: "objects.Chat" = chat
+        self.sender_chat: "objects.Chat" = sender_chat
+        self.forward_origin: "objects.ForwardOrigin" = forward_origin
+        self.forward_from: "objects.User" = forward_from
+        self.forward_from_chat: "objects.Chat" = forward_from_chat
+        self.forward_from_message_id: int = forward_from_message_id
+        self.forward_date: "objects.Date" = forward_date
+        self.reply_to_message: "objects.Message" = reply_to_message
+        self.edit_date: "objects.Date" = edit_date
+        self.text: str = text
+        self.animation: "objects.Animation" = animation
+        self.entities: List["objects.Entity"] = entities
+        self.caption_entities: List["objects.Entity"] = caption_entities
+        self.voice: "objects.Voice" = voice
+        self.audio: "objects.Audio" = audio
+        self.document: "objects.Document" = document
+        self.photo: List["objects.Photo"] = photo
+        self.video: "objects.Video" = video
+        self.sticker: "objects.Sticker" = sticker
+        self.caption: str = caption
+        self.contact: "objects.Contact" = contact
+        self.location: "objects.Location" = location
+        self.new_chat_members: List["objects.User"] = new_chat_members
+        self.left_chat_member: "objects.User" = left_chat_member
+        self.new_chat_title: str = new_chat_title
+        self.new_chat_photo: List["objects.Photo"] = new_chat_photo
+        self.delete_chat_photo: bool = delete_chat_photo
+        self.group_chat_created: bool = group_chat_created
+        self.supergroup_chat_created: bool = supergroup_chat_created
+        self.channel_chat_created: bool = channel_chat_created
+        self.pinned_message: None = pinned_message
+        self.media_group_id: int = media_group_id
+        self.poll: "objects.Poll" = poll
+        self.reply_markup: "objects.ReplyMarkup" = reply_markup
+
+    @property
+    def media_type(self):
+        for media_type in MessageMediaType:
+            if getattr(self, media_type.value):
+                return media_type
+
+    @property
+    def content(self) -> str:
+        return self.text or self.caption or ""
+
+    @content.setter
+    def content(self, value):
+        if self.caption or self.document or self.contact or self.location or self.photo:
+            self.caption = value
+        else:
+            self.text = value
+
+    async def reply_animation(
+            self,
+            animation: Union[str, bytes, BinaryIO, "objects.InputMedia"],
+            duration: int = None,
+            width: int = None,
+            height: int = None,
+            caption: str = None,
+            reply_markup: "objects.ReplyMarkup" = None
+    ):
+        return await self.client.send_animation(
+            self.chat.id,
+            animation,
+            duration,
+            width,
+            height,
+            caption,
+            reply_markup,
+            self.id
+        )
+
+    async def reply_audio(
+            self,
+            audio: Union[str, bytes, BinaryIO, "objects.InputMedia"],
+            caption: str = None,
+            duration: int = None,
+            title: str = None,
+            reply_markup: "objects.ReplyMarkup" = None
+    ):
+        return await self.client.send_audio(self.chat.id, audio, caption, duration, title, reply_markup, self.id)
+
+    async def reply_contact(
+            self,
+            phone_number: str,
+            first_name: str,
+            last_name: str = None,
+            reply_markup: "objects.ReplyMarkup" = None
+    ):
+        return await self.client.send_contact(self.chat.id, phone_number, first_name, last_name, reply_markup, self.id)
+
+    async def reply_document(
+            self,
+            document: Union[str, bytes, BinaryIO, "objects.InputMedia"],
+            caption: str = None,
+            reply_markup: "objects.ReplyMarkup" = None
+    ):
+        return await self.client.send_document(self.chat.id, document, caption, reply_markup, self.id)
+
+    async def reply_location(
+            self,
+            latitude: int,
+            longitude: int,
+            reply_markup: "objects.ReplyMarkup" = None
+    ):
+        return await self.client.send_location(self.chat.id, longitude, latitude, reply_markup, self.id)
+
+    async def reply_media_group(
+            self,
+            media: List["objects.InputMedia"]
+    ):
+        return await self.client.send_media_group(self.chat.id, media)
+
+    async def reply_photo(
+            self,
+            photo: Union[str, bytes, BinaryIO, "objects.InputMedia"],
+            caption: str = None,
+            reply_markup: "objects.ReplyMarkup" = None
+    ):
+        return await self.client.send_photo(self.chat.id, photo, caption, reply_markup, self.id)
+
+    async def reply_sticker(
+            self,
+            sticker: Union[str, bytes, BinaryIO, "objects.InputMedia"],
+            reply_markup: "objects.ReplyMarkup" = None
+    ):
+        return await self.client.send_sticker(self.chat.id, sticker, reply_markup, self.id)
+
+    async def reply_video(
+            self,
+            video: Union[str, bytes, BinaryIO, "objects.InputMedia"],
+            duration: int = None,
+            width: int = None,
+            height: int = None,
+            caption: str = None,
+            reply_markup: "objects.ReplyMarkup" = None
+    ):
+        return await self.client.send_video(self.chat.id, video, duration, width, height, caption, reply_markup)
+
+    async def reply_voice(
+            self,
+            voice: Union[str, bytes, BinaryIO, "objects.InputMedia"],
+            caption: str = None,
+            duration: int = None,
+            reply_markup: "objects.ReplyMarkup" = None
+    ):
+        return await self.client.send_voice(self.chat.id, voice, caption, duration, reply_markup, self.id)
+
+    async def reply(
+            self,
+            text: str,
+            reply_markup: "objects.ReplyMarkup" = None
+    ):
+        return await self.client.send_message(self.chat.id, text, reply_markup, self.id)
+
+    async def edit_text(
+            self,
+            text: str,
+            reply_markup: "objects.ReplyMarkup" = None
+    ):
+        return await self.client.edit_message_text(self.chat.id, self.id, text, reply_markup)
+
+    async def edit_caption(
+            self,
+            caption: str,
+            reply_markup: "objects.ReplyMarkup" = None
+    ):
+        return await self.client.edit_message_caption(self.chat.id, self.id, caption, reply_markup)
+
+    async def edit(
+            self,
+            text: str,
+            reply_markup: "objects.ReplyMarkup" = None
+    ):
+        if self.text:
+            return await self.edit_text(text, reply_markup)
+        return await self.edit_caption(text, reply_markup)
+
+    async def edit_reply_markup(
+            self,
+            reply_markup: "objects.ReplyMarkup"
+    ):
+        return await self.client.edit_message_reply_markup(self.chat.id, self.id, reply_markup)
+
+    async def delete(
+            self
+    ):
+        return await self.client.delete_message(self.chat.id, self.id)
+
+    async def forward(
+            self,
+            chat_id: Union[int, str]
+    ):
+        return await self.client.forward_message(chat_id, self.chat.id, self.id)
+
+    async def copy(
+            self,
+            chat_id: Union[int, str]
+    ):
+        return await self.client.copy_message(chat_id, self.chat.id, self.id)
+
+    async def send(
+            self,
+            chat_id: Union[int, str],
+            reply_markup: "objects.ReplyMarkup" = None,
+            reply_to_message_id: int = None
+    ):
+        if self.text:
+            return await self.client.send_message(
+                chat_id,
+                self.text,
+                reply_markup,
+                reply_to_message_id
+            )
+        elif self.photo:
+            return await self.client.send_photo(
+                chat_id,
+                self.photo[0].id,
+                self.caption,
+                reply_markup,
+                reply_to_message_id
+            )
+        elif self.voice:
+            return await self.client.send_voice(
+                chat_id,
+                self.voice.id,
+                caption=self.caption,
+                reply_markup=reply_markup,
+                reply_to_message_id=reply_to_message_id
+            )
+        elif self.audio:
+            return await self.client.send_audio(
+                chat_id,
+                self.audio.id,
+                caption=self.caption,
+                reply_markup=reply_markup,
+                reply_to_message_id=reply_to_message_id
+            )
+        elif self.video:
+            return await self.client.send_video(
+                chat_id,
+                self.video.id,
+                caption=self.caption,
+                reply_markup=reply_markup,
+                reply_to_message_id=reply_to_message_id
+            )
+        elif self.animation:
+            return await self.client.send_animation(
+                chat_id,
+                self.animation.id,
+                caption=self.caption,
+                reply_markup=reply_markup,
+                reply_to_message_id=reply_to_message_id
+            )
+        elif self.contact:
+            return await self.client.send_contact(
+                chat_id,
+                self.contact.phone_number,
+                self.contact.first_name,
+                self.contact.last_name,
+                reply_markup=reply_markup,
+                reply_to_message_id=reply_to_message_id
+            )
+        elif self.location:
+            return await self.client.send_location(
+                chat_id,
+                self.location.longitude,
+                self.location.latitude,
+                reply_markup=reply_markup,
+                reply_to_message_id=reply_to_message_id
+            )
+        elif self.sticker:
+            return await self.client.send_sticker(
+                chat_id,
+                self.sticker.id,
+                reply_markup=reply_markup,
+                reply_to_message_id=reply_to_message_id
+            )
+        elif self.document:
+            return await self.client.send_document(
+                chat_id,
+                self.document.id,
+                self.caption,
+                reply_markup,
+                reply_to_message_id
+            )
+        raise TypeError("Message is not copyable")

PySPlusthon/objects/message_id.py

@@ -0,0 +1,31 @@
+from typing import Union
+
+from . import Object
+
+
+class MessageId(Object):
+    def __init__(
+            self,
+            message_id: Union[str, tuple] = None,
+            *,
+            rid: int = None,
+            date: int = None,
+            **kwargs
+    ):
+        super().__init__(**kwargs)
+        if message_id is not None and isinstance(message_id, str):
+            rid, date = map(int, message_id.split(":"))
+        elif message_id is not None:
+            rid, date = message_id
+        self.rid = rid
+        self.date = date
+
+    def __str__(self):
+        return f"{self.rid}:{self.date}"
+
+
+def resolve_message_id(message_id: Union[str, tuple, MessageId]) -> MessageId:
+    if not isinstance(message_id, MessageId):
+        message_id = MessageId(message_id)
+
+    return message_id

PySPlusthon/objects/object.py

@@ -0,0 +1,154 @@
+from typing import get_type_hints, get_args, get_origin, Union, List, Optional
+from copy import copy
+from json import dumps
+
+from ..enums import NameEnum
+import PySPlusthon
+
+
+class Object:
+    attribute_names = []
+
+    @classmethod
+    def expected_types(cls):
+        return get_type_hints(cls.__init__)
+
+    @classmethod
+    def validate_types(cls, raw_object):
+        expected_types = cls.expected_types()
+        for key, value in raw_object.items():
+            if not expected_types.get(key):
+                continue
+            if value is None:
+                continue
+            expected_type = expected_types[key]
+            union_type = Union if type(Union) is type else (type(Union), type(Union[str, int]))
+            if isinstance(expected_type, union_type) and get_origin(expected_type) in (Union, None):
+                expected_type = get_args(expected_type)[0]
+            if isinstance(expected_type, (type(List), type(List[str]))) and get_origin(expected_type) == list:
+                if isinstance(value, list):
+                    raw_object[key] = wrap(expected_type, value)
+                continue
+            if issubclass(expected_type, NameEnum):
+                try:
+                    raw_object[key] = expected_type(value)
+                except ValueError:
+                    pass
+                else:
+                    continue
+            if not issubclass(expected_type, Object):
+                continue
+            if isinstance(value, expected_type):
+                continue
+            raw_object[key] = expected_type.wrap(value)
+        return raw_object
+
+    @classmethod
+    def wrap(cls, raw_object):
+        for attribute_name, key_name in cls.attribute_names:
+            if raw_object.get(key_name):
+                raw_object[attribute_name] = raw_object.pop(key_name)
+        raw_object = cls.validate_types(raw_object)
+        return cls(**raw_object)
+
+    @classmethod
+    def from_protobuf(cls, protobuf_data):
+        raise NotImplementedError()
+
+    def __setitem__(self, key, value):
+        setattr(self, key, value)
+
+    def __getitem__(self, item):
+        return getattr(self, item)
+
+    def bind(self, client):
+        self.client = client
+        for value in self.__dict__.values():
+            if isinstance(value, Object):
+                value.bind(client)
+
+    def __init__(
+            self,
+            **kwargs
+    ):
+        self.client: Optional["PySPlusthon.Client"] = None
+        for key, value in kwargs.items():
+            self[key] = value
+
+    def unwrap(self):
+        result = copy(self)
+        del result.client
+        for key, value in result.__dict__.copy().items():
+            if isinstance(value, NameEnum):
+                result[key] = value.value
+            if isinstance(value, list):
+                result[key] = unwrap(value)
+            if isinstance(value, Object):
+                result[key] = value.unwrap()
+            if value is None:
+                delattr(result, key)
+        for attribute_name, key_name in result.attribute_names:
+            if result.__dict__.get(attribute_name):
+                result[key_name] = result.__dict__.pop(attribute_name)
+        return result.__dict__
+
+    def to_json(self):
+        return dumps(self.unwrap(), ensure_ascii=False, indent=4)
+
+    def __repr__(self):
+        attributes = []
+        for key, value in self.__dict__.items():
+            if key == "client":
+                continue
+            if value is None:
+                continue
+            attributes.append(f"{key}={repr(value)}")
+
+        if not attributes:
+            return f"{type(self).__name__}()"
+
+        attributes = ",\n".join(attributes)
+        attributes = "\n".join(" "*4 + line for line in attributes.splitlines())
+        return f"{type(self).__name__}(\n{attributes}\n)"
+
+
+def wrap(expected_type, raw_object):
+    if isinstance(expected_type, (type(List), type(List[str]))) and get_origin(expected_type) == list:
+        if isinstance(raw_object, list):
+            expected_type = get_args(expected_type)[0]
+            raw_object = copy(raw_object)
+            for i, element in enumerate(raw_object):
+                if element is None:
+                    continue
+                if isinstance(expected_type, (type(List), type(List[str]))) and get_origin(expected_type) == list:
+                    if isinstance(element, list):
+                        raw_object[i] = wrap(expected_type, element)
+                    continue
+                if not issubclass(expected_type, Object):
+                    continue
+                if isinstance(element, expected_type):
+                    continue
+                raw_object[i] = expected_type.wrap(element)
+            from .list import List as PySplusthonList
+            return PySplusthonList(raw_object)
+
+    if issubclass(expected_type, Object):
+        return expected_type.wrap(raw_object)
+
+    return raw_object
+
+
+def unwrap(wrapped_object):
+    if isinstance(wrapped_object, list):
+        wrapped_object = copy(wrapped_object)
+        for i, element in enumerate(wrapped_object):
+            wrapped_object[i] = unwrap(element)
+        return list(wrapped_object)
+
+    if isinstance(wrapped_object, Object):
+        return wrapped_object.unwrap()
+    
+    if isinstance(wrapped_object, NameEnum):
+        return wrapped_object.value
+
+    return wrapped_object

PySPlusthon/objects/order_info.py

@@ -0,0 +1,19 @@
+from . import Object
+from PySPlusthon import objects
+
+
+class OrderInfo(Object):
+
+    def __init__(
+            self,
+            name: str = None,
+            phone_number: str = None,
+            email: str = None,
+            shipping_address: "objects.ShippingAddress" = None,
+            **kwargs
+    ):
+        super().__init__(**kwargs)
+        self.name: str = name
+        self.phone_number: str = phone_number
+        self.email: str = email
+        self.shipping_address: "objects.ShippingAddress" = shipping_address