PySPlusthon 0.5.0__py3-none-any.whl

PySPlusthon/client/chats/unpin_all_chat_messages.py

@@ -0,0 +1,38 @@
+from typing import Union
+
+import PySPlusthon
+
+
+class UnpinAllChatMessages:
+
+    async def unpin_all_chat_messages(
+            self: "PySPlusthon.Client",
+            chat_id: Union[int, str]
+    ) -> bool:
+        if self.is_userbot():
+            from PySPlusthon.proto import requests, structs
+            peer_id, peer_type = map(int, chat_id.split("|"))
+
+            if peer_type in (1, 4):
+                response = await self.execute(requests.LoadPinnedMessages(
+                    peer=structs.ExPeer(type=peer_type, id=peer_id)
+                ))
+
+                message_ids = [
+                    structs.MessageId(date=pinned_message.date, rid=pinned_message.rid)
+                    for pinned_message in response.pinned_messages
+                ]
+
+                return await self.execute(requests.UnPinMessages(
+                    peer=structs.ExPeer(type=peer_type, id=peer_id),
+                    message_ids=message_ids,
+                    all=True
+                ))
+
+            elif peer_type in (2, 3, 5):
+                return await self.execute(requests.RemovePin(
+                    group_peer=structs.GroupOutPeer(group_id=peer_id)
+                ))
+
+        chat_id = await self.resolve_peer_id(chat_id)
+        return await self.auto_execute("unpinAllChatMessages", locals())

PySPlusthon/client/chats/unpin_chat_message.py

@@ -0,0 +1,33 @@
+from typing import Union
+
+import PySPlusthon
+from ...objects import resolve_message_id
+
+
+class UnpinChatMessage:
+
+    async def unpin_chat_message(
+            self: "PySPlusthon.Client",
+            chat_id: Union[int, str],
+            message_id: Union[int, str]
+    ) -> bool:
+        if self.is_userbot():
+            from PySPlusthon.proto import requests, structs
+            peer_id, peer_type = map(int, chat_id.split("|"))
+            message_id = resolve_message_id(message_id)
+
+            if peer_type in (1, 4):
+                return await self.execute(requests.UnPinMessages(
+                    peer=structs.ExPeer(type=peer_type, id=peer_id),
+                    message_ids=[structs.MessageId(date=message_id.date, rid=message_id.rid)]
+                ))
+
+            elif peer_type in (2, 3, 5):
+                return await self.execute(requests.RemoveSinglePin(
+                    group_peer=structs.GroupOutPeer(group_id=peer_id),
+                    rid=message_id.rid,
+                    date=message_id.date
+                ))
+
+        chat_id = await self.resolve_peer_id(chat_id)
+        return await self.auto_execute("unpinChatMessage", locals())

PySPlusthon/client/client.py

@@ -0,0 +1,232 @@
+from json import dumps, loads
+from asyncio import get_event_loop, sleep
+from inspect import iscoroutine, iscoroutinefunction, stack
+from io import BufferedReader, BytesIO
+from typing import get_type_hints
+import re
+from pathlib import Path
+import sys
+from typing import Union
+import base64
+
+from httpx import ConnectError
+
+from .messages import Messages
+from .updates import Updates
+from .users import Users
+from .attachments import Attachments
+from .chats import Chats
+from .invite_links import InviteLinks
+from .stickers import Stickers
+from ..objects import Object, wrap, unwrap, Chat, User, Message
+from ..errors import TooManyRequestsError, RPCError
+from ..network import HTTPConnection
+from ..dispatcher import Dispatcher, Chain, PrintingChain
+from ..smart_call import remove_unwanted_keyword_parameters, run_asynchronously
+from ..sync_support import add_sync_support_to_object
+from ..event_handlers import ConnectHandler, DisconnectHandler, InitializeHandler, ShutdownHandler
+
+
+@add_sync_support_to_object
+class Client(Chain, Messages, Updates, Users, Attachments, Chats, InviteLinks, Stickers):
+    WORKDIR = Path(sys.argv[0]).parent
+
+    def __init__(
+            self,
+            token: str,
+            async_workers: int = None,
+            sync_workers: int = None,
+            use_concurrency: bool = True,
+            time_out: int = None,
+            workdir: Union[Path, str] = None,
+            sleep_threshold: int = 60,
+            proxy=None,
+            base_url: str = None,
+            short_url: str = None
+    ):
+        super().__init__("default", None, PrintingChain())
+        self.token = token
+        self.time_out = time_out
+        if workdir is None:
+            self.workdir = self.WORKDIR
+        else:
+            self.workdir = workdir if isinstance(workdir, Path) else Path(workdir)
+        self.dispatcher = Dispatcher(
+            self,
+            async_workers=async_workers,
+            sync_workers=sync_workers,
+            use_concurrency=use_concurrency
+        )
+        self.http_connection = HTTPConnection(token, time_out, proxy, base_url, short_url)
+        self.sleep_threshold = sleep_threshold
+        self.user = None
+        self.is_disconnected = False
+        self.last_update_id = None
+
+    def __repr__(self):
+        client_name = type(self).__name__
+        try:
+            name = self.user.full_name
+        except AttributeError:
+            name = "Not initialized yet"
+        return f"{client_name}({name})"
+
+    def is_userbot(self):
+        return False
+
+    async def initialize(self):
+        await self.dispatcher.start()
+        await self.dispatcher.dispatch_event(self, InitializeHandler)
+
+    async def shutdown(self):
+        await self.dispatcher.dispatch_event(self, ShutdownHandler)
+        await self.dispatcher.stop()
+
+    async def resolve_peer_id(self, chat_id):
+        if isinstance(chat_id, str) and not chat_id.isnumeric():
+            peer = await self.get_chat(chat_id)
+            return peer.id
+        if isinstance(chat_id, (Chat, User)):
+            return chat_id.id
+        return chat_id
+
+    async def connect(self):
+        if self.is_started:
+            raise ConnectionError("Connection is already started")
+        self.is_started = True
+        await self.http_connection.start()
+        if get_event_loop().is_running():
+            self.user = await self.get_me()
+
+    async def disconnect(self):
+        if not self.is_started:
+            raise ConnectionError("Connection is already stopped")
+        self.is_started = False
+        await self.http_connection.stop()
+
+    async def __aenter__(self):
+        await self.connect()
+        return self
+
+    async def __aexit__(self, *args):
+        try:
+            await self.disconnect()
+        except ConnectionError:
+            return
+
+    def __enter__(self):
+        self.connect()
+        return self
+
+    def __exit__(self, *args):
+        try:
+            self.disconnect()
+        except ConnectionError:
+            return
+
+    async def execute_http(self, service: str, json: bool = None, **data):
+        data = {k: v for k, v in data.items() if v is not None}
+        files = {}
+        if json is None:
+            for value in data.values():
+                if isinstance(value, (bytes, BufferedReader, BytesIO)):
+                    json = False
+                    break
+            else:
+                json = True
+        for key, value in data.items():
+            data[key] = unwrap(value)
+        if not json:
+            for key, value in data.copy().items():
+                if isinstance(value, (bytes, BufferedReader, BytesIO)):
+                    files[key] = value
+                    del data[key]
+                elif isinstance(value, dict):
+                    data[key] = dumps(value)
+        while True:
+            try:
+                if json:
+                    return await self.http_connection.request(service, json=data)
+                return await self.http_connection.request(service, data=data, files=files)
+            except RPCError as error:
+                if error.seconds <= self.sleep_threshold:
+                    print(f"[Too many requests] retry after: {error.seconds} (caused by {service})")
+                    await sleep(error.seconds)
+                else:
+                    raise error
+
+    async def execute(self, service: str, json: bool = None, **data):
+        return await self.execute_http(service, json=json, **data)
+
+    async def auto_execute(self, service: str, data: dict, json: bool = None):
+        bound_method_name = stack()[1].function
+        bound_method = getattr(self, bound_method_name)
+        type_hints = get_type_hints(bound_method)
+        del data["self"]
+        del type_hints["self"]
+        return_type_hint = type_hints.pop("return")
+        result = await self.execute(service, json, **data)
+        result = wrap(return_type_hint, result)
+        if isinstance(result, Object):
+            result.bind(self)
+        return result
+
+    async def start_polling(self, clear_pending_updates: bool = True):
+        await self.delete_webhook()
+        await self.initialize()
+        while True:
+            try:
+                if self.last_update_id is None:
+                    try:
+                        if not clear_pending_updates:
+                            raise Exception()
+                        updates = await self.get_updates(offset=-1)
+                    except Exception:
+                        updates = await self.get_updates()
+                else:
+                    updates = await self.get_updates(offset=self.last_update_id + 1)
+            except ConnectError:
+                if not self.is_disconnected:
+                    self.is_disconnected = True
+                    await self.dispatcher.dispatch_event(self, DisconnectHandler)
+            except Exception as error:
+                await self.dispatcher.dispatch_event(self, error)
+            else:
+                if self.is_disconnected:
+                    self.is_disconnected = False
+                    await self.dispatcher.dispatch_event(self, ConnectHandler)
+                for update in updates:
+                    if self.last_update_id is not None and self.last_update_id >= update.id:
+                        continue
+                    self.last_update_id = update.id
+                    await self.dispatcher.dispatch_event(self, update.get_effective_update())
+
+    def run(self, function=None, **kwargs):
+        try:
+            self.connect()
+            if function is None:
+                self.start_polling(**kwargs)
+            elif iscoroutine(function):
+                loop = get_event_loop()
+                loop.run_until_complete(function)
+            elif iscoroutinefunction(function):
+                kwargs = remove_unwanted_keyword_parameters(function, client=self, **kwargs)
+                loop = get_event_loop()
+                loop.run_until_complete(function(**kwargs))
+            else:
+                kwargs = remove_unwanted_keyword_parameters(function, client=self, **kwargs)
+                function(**kwargs)
+        except KeyboardInterrupt:
+            return
+        finally:
+            if self.dispatcher.is_started:
+                self.shutdown()
+            self.disconnect()
+
+    async def download(self, file_id: str):
+        return await self.http_connection.download_file(file_id)
+
+    def create_referral_link(self, name, value) -> str:
+        if self.user is None:
+            raise RuntimeError("Client not initialized. Connect first.")
+        return f"{self.http_connection.short_url}/{self.user.username}?{name}={value}"

PySPlusthon/client/invite_links/__init__.py

@@ -0,0 +1,7 @@
+from .create_chat_invite_link import CreateChatInviteLink
+from .export_chat_invite_link import ExportChatInviteLink
+from .revoke_chat_invite_link import RevokeChatInviteLink
+
+
+class InviteLinks(CreateChatInviteLink, ExportChatInviteLink, RevokeChatInviteLink):
+    pass

PySPlusthon/client/invite_links/create_chat_invite_link.py

@@ -0,0 +1,14 @@
+from typing import Union
+
+import PySPlusthon
+from ...objects import InviteLink
+
+
+class CreateChatInviteLink:
+
+    async def create_chat_invite_link(
+            self: "PySPlusthon.Client",
+            chat_id: Union[int, str]
+    ) -> InviteLink:
+        chat_id = await self.resolve_peer_id(chat_id)
+        return await self.auto_execute("createChatInviteLink", locals())

PySPlusthon/client/invite_links/export_chat_invite_link.py

@@ -0,0 +1,21 @@
+from typing import Union
+
+import PySPlusthon
+
+
+class ExportChatInviteLink:
+
+    async def export_chat_invite_link(
+            self: "PySPlusthon.Client",
+            chat_id: Union[int, str]
+    ) -> str:
+        if self.is_userbot():
+            from PySPlusthon.proto import requests, structs
+            peer_id, peer_type = map(int, chat_id.split("|"))
+            response = await self.execute(requests.GetGroupInviteUrl(
+                group_peer=structs.GroupOutPeer(group_id=peer_id, access_hash=1)
+            ))
+            return response.url
+
+        chat_id = await self.resolve_peer_id(chat_id)
+        return await self.auto_execute("exportChatInviteLink", locals())

PySPlusthon/client/invite_links/revoke_chat_invite_link.py

@@ -0,0 +1,23 @@
+from typing import Union
+
+import PySPlusthon
+from ...objects import InviteLink
+
+
+class RevokeChatInviteLink:
+
+    async def revoke_chat_invite_link(
+            self: "PySPlusthon.Client",
+            chat_id: Union[int, str],
+            invite_link: str
+    ) -> InviteLink:
+        if self.is_userbot():
+            from PySPlusthon.proto import requests, structs
+            peer_id, peer_type = map(int, chat_id.split("|"))
+            response = await self.execute(requests.RevokeInviteUrl(
+                group_peer=structs.GroupOutPeer(group_id=peer_id, access_hash=1)
+            ))
+            return InviteLink(link=response.url)
+
+        chat_id = await self.resolve_peer_id(chat_id)
+        return await self.auto_execute("revokeChatInviteLink", locals())

PySPlusthon/client/messages/__init__.py

@@ -0,0 +1,21 @@
+from .answer_callback_query import AnswerCallbackQuery
+from .send_message import SendMessage
+from .edit_message_caption import EditMessageCaption
+from .edit_message_reply_markup import EditMessageReplyMarkup
+from .edit_message_text import EditMessageText
+from .forward_message import ForwardMessage
+from .delete_message import DeleteMessage
+from .copy_message import CopyMessage
+
+
+class Messages(
+    AnswerCallbackQuery,
+    SendMessage,
+    EditMessageCaption,
+    EditMessageReplyMarkup,
+    EditMessageText,
+    ForwardMessage,
+    DeleteMessage,
+    CopyMessage
+):
+    pass

PySPlusthon/client/messages/answer_callback_query.py

@@ -0,0 +1,12 @@
+import PySPlusthon
+
+
+class AnswerCallbackQuery:
+
+    async def answer_callback_query(
+            self: "PySPlusthon.Client",
+            callback_query_id: str,
+            text: str,
+            show_alert: bool = False
+    ) -> bool:
+        return await self.auto_execute("answerCallbackQuery", locals())

PySPlusthon/client/messages/copy_message.py

@@ -0,0 +1,43 @@
+from typing import Union
+
+import PySPlusthon
+from ...objects import Message, resolve_message_id
+
+
+class CopyMessage:
+
+    async def copy_message(
+            self: "PySPlusthon.Client",
+            chat_id: Union[int, str],
+            from_chat_id: Union[int, str],
+            message_id: Union[int, str]
+    ) -> Message:
+        if self.is_userbot():
+            from PySPlusthon.proto import requests, structs
+            peer_id, peer_type = map(int, chat_id.split("|"))
+            from_peer_id, from_peer_type = map(int, from_chat_id.split("|"))
+            message_id = resolve_message_id(message_id)
+            peer = structs.Peer(type=from_peer_type, id=from_peer_id)
+            response = await self.execute(requests.LoadHistory(
+                peer=peer,
+                date=message_id.date,
+                load_mode=2,
+                limit=1
+            ))
+            result = response.history[0]
+            return await self.execute(requests.SendMessage(
+                peer=structs.Peer(
+                    type=peer_type,
+                    id=peer_id
+                ),
+                rid=self.ws_connection.create_rid(),
+                message=result.message,
+                ex_peer=structs.Peer(
+                    type=peer_type,
+                    id=peer_id
+                )
+            ))
+
+        chat_id = await self.resolve_peer_id(chat_id)
+        from_chat_id = await self.resolve_peer_id(from_chat_id)
+        return await self.auto_execute("copyMessage", locals())

PySPlusthon/client/messages/delete_message.py

@@ -0,0 +1,29 @@
+from typing import Union
+
+import PySPlusthon
+from ...objects import resolve_message_id
+
+
+class DeleteMessage:
+
+    async def delete_message(
+            self: "PySPlusthon.Client",
+            chat_id: Union[int, str],
+            message_id: Union[int, str]
+    ) -> bool:
+        if self.is_userbot():
+            from PySPlusthon.proto import requests, structs
+            peer_id, peer_type = map(int, chat_id.split("|"))
+            message_id = resolve_message_id(message_id)
+            return await self.execute(requests.DeleteMessage(
+                peer=structs.Peer(
+                    type=peer_type,
+                    id=peer_id
+                ),
+                rids=[message_id.rid],
+                dates=structs.DeleteDates(dates=[message_id.date]),
+                just_mine=False
+            ))
+
+        chat_id = await self.resolve_peer_id(chat_id)
+        return await self.auto_execute("deleteMessage", locals())

PySPlusthon/client/messages/edit_message_caption.py

@@ -0,0 +1,40 @@
+from typing import Union
+
+import PySPlusthon
+from ...objects import Message
+from PySPlusthon import objects
+from ...objects import resolve_message_id
+
+
+class EditMessageCaption:
+
+    async def edit_message_caption(
+            self: "PySPlusthon.Client",
+            chat_id: Union[int, str],
+            message_id: Union[int, str],
+            caption: str,
+            reply_markup: "objects.ReplyMarkup" = None
+    ) -> Message:
+        if self.is_userbot():
+            from PySPlusthon.proto import requests, structs
+            peer_id, peer_type = map(int, chat_id.split("|"))
+            message_id = resolve_message_id(message_id)
+            peer = structs.Peer(type=peer_type, id=peer_id)
+            response = await self.execute(requests.LoadHistory(
+                peer=peer,
+                date=message_id.date,
+                load_mode=2,
+                limit=1
+            ))
+            result = response.history[0].message
+            return await self.execute(requests.UpdateMessage(
+                peer=structs.Peer(
+                    type=peer_type,
+                    id=peer_id
+                ),
+                rid=message_id.rid,
+                updated_message=result
+            ))
+
+        chat_id = await self.resolve_peer_id(chat_id)
+        return await self.auto_execute("editMessageCaption", locals())

PySPlusthon/client/messages/edit_message_reply_markup.py

@@ -0,0 +1,17 @@
+from typing import Union
+
+import PySPlusthon
+from ...objects import Message
+from PySPlusthon import objects
+
+
+class EditMessageReplyMarkup:
+
+    async def edit_message_reply_markup(
+            self: "PySPlusthon.Client",
+            chat_id: Union[int, str],
+            message_id: int,
+            reply_markup: "objects.ReplyMarkup"
+    ) -> Message:
+        chat_id = await self.resolve_peer_id(chat_id)
+        return await self.auto_execute("editMessageReplyMarkup", locals())

PySPlusthon/client/messages/edit_message_text.py

@@ -0,0 +1,40 @@
+from typing import Union
+
+import PySPlusthon
+from ...objects import Message
+from PySPlusthon import objects
+from ...objects import resolve_message_id
+
+
+class EditMessageText:
+
+    async def edit_message_text(
+            self: "PySPlusthon.Client",
+            chat_id: Union[int, str],
+            message_id: Union[int, str],
+            text: str,
+            reply_markup: "objects.ReplyMarkup" = None
+    ) -> Message:
+        if self.is_userbot():
+            from PySPlusthon.proto import requests, structs
+            peer_id, peer_type = map(int, chat_id.split("|"))
+            message_id = resolve_message_id(message_id)
+            peer = structs.Peer(type=peer_type, id=peer_id)
+            response = await self.execute(requests.LoadHistory(
+                peer=peer,
+                date=message_id.date,
+                load_mode=2,
+                limit=1
+            ))
+            result = response.history[0].message
+            return await self.execute(requests.UpdateMessage(
+                peer=structs.Peer(
+                    type=peer_type,
+                    id=peer_id
+                ),
+                rid=message_id.rid,
+                updated_message=result
+            ))
+
+        chat_id = await self.resolve_peer_id(chat_id)
+        return await self.auto_execute("editMessageText", locals())

PySPlusthon/client/messages/forward_message.py

@@ -0,0 +1,35 @@
+from typing import Union
+
+import PySPlusthon
+from ...objects import Message, resolve_message_id
+
+
+class ForwardMessage:
+
+    async def forward_message(
+            self: "PySPlusthon.Client",
+            chat_id: Union[int, str],
+            from_chat_id: Union[int, str],
+            message_id: Union[int, str]
+    ) -> Message:
+        if self.is_userbot():
+            from PySPlusthon.proto import requests, structs
+            peer_id, peer_type = map(int, chat_id.split("|"))
+            message_peer_id, message_peer_type = map(int, from_chat_id.split("|"))
+            message_id = resolve_message_id(message_id)
+            return await self.execute(requests.ForwardMessages(
+                peer=structs.Peer(
+                    type=peer_type,
+                    id=peer_id
+                ),
+                rid=[self.ws_connection.create_rid()],
+                forwarded_messages=[structs.HistoryMessageIdentifier(
+                    peer=structs.OutPeer(type=message_peer_type, id=message_peer_id),
+                    random_id=message_id.rid,
+                    date=message_id.date
+                )]
+            ))
+
+        chat_id = await self.resolve_peer_id(chat_id)
+        from_chat_id = await self.resolve_peer_id(from_chat_id)
+        return await self.auto_execute("forwardMessage", locals())

PySPlusthon/client/messages/send_message.py

@@ -0,0 +1,38 @@
+from typing import Union
+
+import PySPlusthon
+from ...objects import Message
+from PySPlusthon import objects
+
+
+class SendMessage:
+
+    async def send_message(
+            self: "PySPlusthon.Client",
+            chat_id: Union[int, str],
+            text: str,
+            reply_markup: "objects.ReplyMarkup" = None,
+            reply_to_message_id: int = None
+    ) -> Message:
+        if self.is_userbot():
+            from PySPlusthon.proto import requests, structs
+            peer_id, peer_type = map(int, chat_id.split("|"))
+            return await self.execute(requests.SendMessage(
+                peer=structs.Peer(
+                    type=peer_type,
+                    id=peer_id
+                ),
+                rid=self.ws_connection.create_rid(),
+                message=structs.Message(
+                    text_message=structs.TextMessage(
+                        text=text
+                    )
+                ),
+                ex_peer=structs.Peer(
+                    type=peer_type,
+                    id=peer_id
+                )
+            ))
+
+        chat_id = await self.resolve_peer_id(chat_id)
+        return await self.auto_execute("sendMessage", locals())

PySPlusthon/client/stickers/__init__.py

@@ -0,0 +1,9 @@
+from .delete_sticker_from_set import DeleteStickerFromSet
+from .get_sticker_set import GetStickerSet
+from .create_new_sticker_set import CreateNewStickerSet
+from .upload_sticker_file import UploadStickerFile
+from .add_sticker_to_set import AddStickerToSet
+
+
+class Stickers(GetStickerSet, CreateNewStickerSet, DeleteStickerFromSet, UploadStickerFile, AddStickerToSet):
+    pass