PySPlusthon 0.5.3__py3-none-any.whl

PySPlusthon/client/stickers/create_new_sticker_set.py

@@ -0,0 +1,16 @@
+from typing import Union
+
+import PySPlusthon
+
+
+class CreateNewStickerSet:
+
+    async def create_new_sticker_set(
+            self: "PySPlusthon.Client",
+            user_id: Union[int, str],
+            name: str,
+            title: str,
+            sticker=None
+    ) -> bool:
+        user_id = await self.resolve_peer_id(user_id)
+        return await self.auto_execute("createNewStickerSet", locals())

PySPlusthon/client/stickers/delete_sticker_from_set.py

@@ -0,0 +1,10 @@
+import PySPlusthon
+
+
+class DeleteStickerFromSet:
+
+    async def delete_sticker_from_set(
+            self: "PySPlusthon.Client",
+            sticker: str
+    ) -> bool:
+        return await self.auto_execute("deleteStickerToSet", locals())

PySPlusthon/client/stickers/get_sticker_set.py

@@ -0,0 +1,11 @@
+import PySPlusthon
+from ...objects import StickerSet
+
+
+class GetStickerSet:
+
+    async def get_sticker_set(
+            self: "PySPlusthon.Client",
+            name: str
+    ) -> StickerSet:
+        return await self.auto_execute("getStickerSet", locals())

PySPlusthon/client/stickers/upload_sticker_file.py

@@ -0,0 +1,16 @@
+from typing import Union, BinaryIO
+
+import PySPlusthon
+from ...objects import InputMedia, resolve_media
+
+
+class UploadStickerFile:
+
+    async def upload_sticker_file(
+            self: "PySPlusthon.Client",
+            user_id: Union[int, str],
+            sticker: Union[str, bytes, BinaryIO, InputMedia]
+    ) -> str:
+        user_id = await self.resolve_peer_id(user_id)
+        sticker = resolve_media(sticker)
+        return await self.auto_execute("uploadStickerFile", locals())

PySPlusthon/client/updates/__init__.py

@@ -0,0 +1,8 @@
+from .delete_webhook import DeleteWebhook
+from .get_updates import GetUpdates
+from .get_webhook_info import GetWebhookInfo
+from .set_webhook import SetWebhook
+
+
+class Updates(DeleteWebhook, GetUpdates, GetWebhookInfo, SetWebhook):
+    pass

PySPlusthon/client/updates/delete_webhook.py

@@ -0,0 +1,9 @@
+import PySPlusthon
+
+
+class DeleteWebhook:
+
+    async def delete_webhook(
+            self: "PySPlusthon.Client"
+    ) -> bool:
+        return await self.auto_execute("deleteWebhook", locals())

PySPlusthon/client/updates/get_updates.py

@@ -0,0 +1,14 @@
+from typing import List
+
+import PySPlusthon
+from ...objects import Update
+
+
+class GetUpdates:
+
+    async def get_updates(
+            self: "PySPlusthon.Client",
+            offset: int = None,
+            limit: int = None
+    ) -> List[Update]:
+        return await self.auto_execute("getUpdates", locals())

PySPlusthon/client/updates/get_webhook_info.py

@@ -0,0 +1,10 @@
+import PySPlusthon
+from ...objects import WebhookInfo
+
+
+class GetWebhookInfo:
+
+    async def get_webhook_info(
+            self: "PySPlusthon.Client"
+    ) -> WebhookInfo:
+        return await self.auto_execute("getWebhookInfo", locals())

PySPlusthon/client/updates/set_webhook.py

@@ -0,0 +1,10 @@
+import PySPlusthon
+
+
+class SetWebhook:
+
+    async def set_webhook(
+            self: "PySPlusthon.Client",
+            url: str
+    ) -> bool:
+        return await self.auto_execute("setWebhook", locals())

PySPlusthon/client/users/__init__.py

@@ -0,0 +1,6 @@
+from .ask_review import AskReview
+from .get_me import GetMe
+
+
+class Users(AskReview, GetMe):
+    pass

PySPlusthon/client/users/ask_review.py

@@ -0,0 +1,14 @@
+from typing import Union
+
+import PySPlusthon
+
+
+class AskReview:
+
+    async def ask_review(
+            self: "PySPlusthon.Client",
+            user_id: Union[int, str],
+            delay_seconds: int = 0
+    ) -> bool:
+        user_id = await self.resolve_peer_id(user_id)
+        return await self.auto_execute("askReview", locals())

PySPlusthon/client/users/get_me.py

@@ -0,0 +1,16 @@
+import PySPlusthon
+from ...objects import User
+
+
+class GetMe:
+
+    async def get_me(
+            self: "PySPlusthon.Client"
+    ) -> User:
+        if self.is_userbot():
+            jwt = self.load_session()
+            data = self.decode_jwt(jwt)
+            my_id = data["payload"]["payload"]["user_id"]
+            return await self.get_chat(f"{my_id}|1")
+
+        return await self.auto_execute("getMe", locals())

PySPlusthon/conditions/__init__.py

@@ -0,0 +1,43 @@
+from .condition import Condition, AllCondition, AnyCondition, NotCondition, create
+from .all import all
+from .forward import forward
+from .reply import reply
+from .text import text
+from .entities import entities
+from .document import document
+from .photo import photo
+from .video import video
+from .voice import voice
+from .caption import caption
+from .contact import contact
+from .location import location
+from .new_chat_members import new_chat_members
+from .left_chat_member import left_chat_member
+from .new_chat_title import new_chat_title
+from .new_chat_photo import new_chat_photo
+from .delete_chat_photo import delete_chat_photo
+from .group_chat_created import group_chat_created
+from .supergroup_chat_created import supergroup_chat_created
+from .channel_chat_created import channel_chat_created
+from .pinned_message import pinned_message
+from .media import media
+from .command import Command as command
+from .private import private
+from .group import group
+from .channel import channel
+from .regex import Regex as regex
+from .at_state import AtState as at_state
+from .is_instance import IsInstance as is_instance
+from .chat import Chat as chat
+from .is_joined import IsJoined as is_joined
+from .is_admin import IsAdmin as is_admin
+from .author import Author as author
+from .equals import Equals as equals
+from .content import content
+from .media_group import media_group
+from .sticker import sticker
+from .number import number
+from .click import Click as click
+from .audio import audio
+from .animation import animation
+from .poll import poll

PySPlusthon/conditions/all.py

@@ -0,0 +1,6 @@
+from .condition import create
+
+
+@create()
+def all() -> bool:
+    return True

PySPlusthon/conditions/animation.py

@@ -0,0 +1,7 @@
+from .condition import create
+from ..objects import Message
+
+
+@create(can_process=Message)
+def animation(event) -> bool:
+    return bool(event.animation)

PySPlusthon/conditions/at_state.py

@@ -0,0 +1,18 @@
+from .condition import Condition
+from ..objects import Message, CallbackQuery
+from ..states import State
+
+
+class AtState(Condition):
+    def __init__(self, state, state_machine=None):
+        super().__init__(can_process=(Message, CallbackQuery))
+        self.state = str(state) if isinstance(state, State) else state
+        self.state_machine = state_machine
+
+    async def process(self, client, event) -> bool:
+        if not event.author:
+            return False
+        if self.state_machine is None:
+            return event.author.get_state() == self.state
+        else:
+            return self.state_machine[event.author.id] == self.state

PySPlusthon/conditions/audio.py

@@ -0,0 +1,7 @@
+from .condition import create
+from ..objects import Message
+
+
+@create(can_process=Message)
+def audio(event) -> bool:
+    return bool(event.audio)

PySPlusthon/conditions/author.py

@@ -0,0 +1,13 @@
+from .condition import Condition
+from ..objects import Message, CallbackQuery
+
+
+class Author(Condition):
+    def __init__(self, *authors):
+        super().__init__(can_process=(Message, CallbackQuery))
+        self.authors = set(authors)
+
+    async def process(self, client, event) -> bool:
+        if not event.author:
+            return False
+        return event.author.id in self.authors

PySPlusthon/conditions/caption.py

@@ -0,0 +1,7 @@
+from .condition import create
+from ..objects import Message
+
+
+@create(can_process=Message)
+def caption(event) -> bool:
+    return bool(event.caption)

PySPlusthon/conditions/channel.py

@@ -0,0 +1,11 @@
+from .condition import create
+from ..objects import Message, CallbackQuery
+from ..enums import ChatType
+
+
+@create(can_process=(Message, CallbackQuery))
+def channel(event) -> bool:
+    if isinstance(event, Message):
+        return event.chat.type == ChatType.CHANNEL
+    elif isinstance(event, CallbackQuery):
+        return event.message.chat.type == ChatType.CHANNEL

PySPlusthon/conditions/channel_chat_created.py

@@ -0,0 +1,7 @@
+from .condition import create
+from ..objects import Message
+
+
+@create(can_process=Message)
+def channel_chat_created(event) -> bool:
+    return bool(event.channel_chat_created)

PySPlusthon/conditions/chat.py

@@ -0,0 +1,14 @@
+from .condition import Condition
+from ..objects import Message, CallbackQuery
+
+
+class Chat(Condition):
+    def __init__(self, *chats):
+        super().__init__(can_process=(Message, CallbackQuery))
+        self.chats = set(chats)
+
+    async def process(self, client, event) -> bool:
+        if isinstance(event, Message):
+            return event.chat.id in self.chats
+        elif isinstance(event, CallbackQuery):
+            return event.message.chat.id in self.chats

PySPlusthon/conditions/click.py

@@ -0,0 +1,24 @@
+import re
+
+from .condition import Condition
+from ..objects import Message, CallbackQuery, ReplyKeyboard, InlineKeyboard
+
+
+class Click(Condition):
+    def __init__(self, keyboard, row_index: int, button_index: int):
+        super().__init__(can_process=(Message, CallbackQuery))
+        self.keyboard = keyboard
+        self.row_index = row_index
+        self.button_index = button_index
+
+    @staticmethod
+    def create_regex(text):
+        return "^" + re.sub(r"{.*?}", ".*", text) + "$"
+
+    async def process(self, client, event) -> bool:
+        if isinstance(self.keyboard, ReplyKeyboard) and isinstance(event, Message):
+            button = self.keyboard.keyboard[self.row_index][self.button_index]
+            return bool(re.match(self.create_regex(button.text), event.text))
+        elif isinstance(self.keyboard, InlineKeyboard) and isinstance(event, CallbackQuery):
+            button = self.keyboard.inline_keyboard[self.row_index][self.button_index]
+            return bool(re.match(self.create_regex(button.callback_data), event.data))

PySPlusthon/conditions/command.py

@@ -0,0 +1,23 @@
+from .condition import Condition
+from ..objects import Message
+
+
+class Command(Condition):
+    def __init__(self, name, prefix="/", min_arguments=None, max_arguments=None):
+        super().__init__(can_process=Message)
+        self.name = name
+        self.prefix = prefix
+        self.min_arguments = min_arguments
+        self.max_arguments = max_arguments
+
+    async def process(self, client, event) -> bool:
+        if not event.text:
+            return False
+        name, *arguments = event.text.split()
+        if name.lower() != f"{self.prefix}{self.name.lower()}":
+            return False
+        if self.min_arguments is not None and len(arguments) < self.min_arguments:
+            return False
+        if self.max_arguments is not None and len(arguments) > self.max_arguments:
+            return False
+        return True

PySPlusthon/conditions/condition.py

@@ -0,0 +1,88 @@
+from inspect import iscoroutinefunction
+
+from ..smart_call import remove_unwanted_keyword_parameters
+
+
+class Condition:
+    def __init__(self, function=None, can_process=None):
+        self.function = function
+        self.can_process = can_process
+
+    def is_not_processable(self, event):
+        return self.can_process is not None and not isinstance(event, self.can_process)
+
+    async def __call__(self, client, event) -> bool:
+        if self.is_not_processable(event):
+            return False
+        return await self.process(client, event)
+
+    async def process(self, client, event) -> bool:
+        kwargs = dict(condition=self, client=client, event=event)
+        kwargs = remove_unwanted_keyword_parameters(self.function, **kwargs)
+        if iscoroutinefunction(self.function):
+            return await self.function(**kwargs)
+        return self.function(**kwargs)
+
+    def __and__(self, other):
+        return AllCondition(self, other)
+
+    def __or__(self, other):
+        return AnyCondition(self, other)
+
+    def __invert__(self):
+        return NotCondition(self)
+
+    def __repr__(self):
+        return type(self).__name__
+
+
+class AllCondition(Condition):
+    def __init__(self, *conditions):
+        super().__init__()
+        self.conditions = conditions
+
+    async def __call__(self, client, event) -> bool:
+        for condition in self.conditions:
+            if not await condition(client, event):
+                return False
+        return True
+
+    def __repr__(self):
+        conditions_string = ", ".join(map(str, self.conditions))
+        return f"All({conditions_string})"
+
+
+class AnyCondition(Condition):
+    def __init__(self, *conditions):
+        super().__init__()
+        self.conditions = conditions
+
+    async def __call__(self, client, event) -> bool:
+        for condition in self.conditions:
+            if await condition(client, event):
+                return True
+        return False
+
+    def __repr__(self):
+        conditions_string = ", ".join(map(str, self.conditions))
+        return f"Any({conditions_string})"
+
+
+class NotCondition(Condition):
+    def __init__(self, condition):
+        super().__init__()
+        self.condition = condition
+
+    async def __call__(self, client, event) -> bool:
+        return not await self.condition(client, event)
+
+    def __repr__(self):
+        return f"Not({self.condition})"
+
+
+def create(name: str = None, can_process=None):
+    def decorator(function):
+        CustomCondition = type(name or function.__name__ or "CustomCondition", (Condition,), {})
+        return CustomCondition(function, can_process)
+
+    return decorator

PySPlusthon/conditions/contact.py

@@ -0,0 +1,7 @@
+from .condition import create
+from ..objects import Message
+
+
+@create(can_process=Message)
+def contact(event) -> bool:
+    return bool(event.contact)

PySPlusthon/conditions/content.py

@@ -0,0 +1,7 @@
+from .condition import create
+from ..objects import Message
+
+
+@create(can_process=Message)
+def content(event) -> bool:
+    return bool(event.content)

PySPlusthon/conditions/delete_chat_photo.py

@@ -0,0 +1,7 @@
+from .condition import create
+from ..objects import Message
+
+
+@create(can_process=Message)
+def delete_chat_photo(event) -> bool:
+    return bool(event.delete_chat_photo)

PySPlusthon/conditions/document.py

@@ -0,0 +1,7 @@
+from .condition import create
+from ..objects import Message
+
+
+@create(can_process=Message)
+def document(event) -> bool:
+    return bool(event.document)

PySPlusthon/conditions/entities.py

@@ -0,0 +1,7 @@
+from .condition import create
+from ..objects import Message
+
+
+@create(can_process=Message)
+def entities(event) -> bool:
+    return bool(event.entities or event.caption_entities)

PySPlusthon/conditions/equals.py

@@ -0,0 +1,14 @@
+from .condition import Condition
+from ..objects import Message, CallbackQuery
+
+
+class Equals(Condition):
+    def __init__(self, *values):
+        super().__init__(can_process=(Message, CallbackQuery))
+        self.values = values
+
+    async def process(self, client, event) -> bool:
+        if isinstance(event, Message):
+            return event.content in self.values
+        elif isinstance(event, CallbackQuery):
+            return event.data in self.values

PySPlusthon/conditions/forward.py

@@ -0,0 +1,7 @@
+from .condition import create
+from ..objects import Message
+
+
+@create(can_process=Message)
+def forward(event) -> bool:
+    return bool(event.forward_from or event.forward_from_chat)

PySPlusthon/conditions/group.py

@@ -0,0 +1,11 @@
+from .condition import create
+from ..objects import Message, CallbackQuery
+from ..enums import ChatType
+
+
+@create(can_process=(Message, CallbackQuery))
+def group(event) -> bool:
+    if isinstance(event, Message):
+        return event.chat.type == ChatType.GROUP
+    elif isinstance(event, CallbackQuery):
+        return event.message.chat.type == ChatType.GROUP

PySPlusthon/conditions/group_chat_created.py

@@ -0,0 +1,7 @@
+from .condition import create
+from ..objects import Message
+
+
+@create(can_process=Message)
+def group_chat_created(event) -> bool:
+    return bool(event.group_chat_created)

PySPlusthon/conditions/is_admin.py

@@ -0,0 +1,17 @@
+from typing import Union, Tuple
+
+from .is_joined import IsJoined
+from ..enums import ChatMemberStatus
+
+
+class IsAdmin(IsJoined):
+    ACCEPTED_STATUSES = ChatMemberStatus.ADMINISTRATOR, ChatMemberStatus.CREATOR
+
+    def __init__(
+            self,
+            *chat_ids: Union[int, str],
+            accepted_statuses: Tuple[str, ...] = None,
+            source_chat: bool = False
+    ):
+        super().__init__(*chat_ids, accepted_statuses=accepted_statuses)
+        self.source_chat = source_chat

PySPlusthon/conditions/is_instance.py

@@ -0,0 +1,10 @@
+from .condition import Condition
+
+
+class IsInstance(Condition):
+    def __init__(self, classes):
+        super().__init__()
+        self.classes = classes
+
+    async def process(self, client, event) -> bool:
+        return isinstance(event, self.classes)

PySPlusthon/conditions/is_joined.py

@@ -0,0 +1,61 @@
+from typing import Union, Tuple
+from copy import copy
+
+from .condition import Condition
+from ..objects import Message, CallbackQuery
+from ..enums import ChatMemberStatus
+from ..errors import RPCError, ForbiddenError
+
+
+class IsJoined(Condition):
+    ACCEPTED_STATUSES = ChatMemberStatus.MEMBER, ChatMemberStatus.ADMINISTRATOR, ChatMemberStatus.CREATOR
+
+    def __init__(self, *chat_ids: Union[int, str], accepted_statuses: Tuple[str, ...] = None):
+        super().__init__(can_process=(Message, CallbackQuery))
+        self.chat_ids = list(chat_ids)
+        self.chats = []
+        self.accepted_statuses = accepted_statuses or self.ACCEPTED_STATUSES
+        self.source_chat = False
+
+    async def update_chats(self, client):
+        self.chats = []
+        for chat_id in self.chat_ids:
+            chat = await client.get_chat(chat_id)
+            self.chats.append(chat)
+        self.chat_ids = [chat.id for chat in self.chats]
+
+    async def add_chat(self, client, chat_id):
+        chat = await client.get_chat(chat_id)
+        self.chats.append(chat)
+        self.chat_ids.append(chat.id)
+        return chat
+
+    async def remove_chat(self, client, chat_id):
+        chat = await client.get_chat(chat_id)
+        for c in self.chats:
+            if c.id == chat.id:
+                index = self.chats.index(c)
+                self.chats.pop(index)
+        self.chat_ids.remove(chat.id)
+        return chat
+
+    async def process(self, client, event) -> bool:
+        if self.chat_ids and not self.chats:
+            await self.update_chats(client)
+        if not event.author:
+            return False
+        chats = copy(self.chats)
+        if self.source_chat:
+            chats.append(event.chat if isinstance(event, Message) else event.message.chat)
+        event.not_accepted_chats = []
+        for chat in chats:
+            try:
+                chat_member = await client.get_chat_member(chat.id, event.author.id)
+            except ForbiddenError as error:
+                raise error
+            except RPCError:
+                event.not_accepted_chats.append(chat)
+            else:
+                if chat_member.status not in self.accepted_statuses:
+                    event.not_accepted_chats.append(chat)
+        return not bool(event.not_accepted_chats)

PySPlusthon/conditions/left_chat_member.py

@@ -0,0 +1,7 @@
+from .condition import create
+from ..objects import Message
+
+
+@create(can_process=Message)
+def left_chat_member(event) -> bool:
+    return bool(event.left_chat_member)

PySPlusthon/conditions/location.py

@@ -0,0 +1,7 @@
+from .condition import create
+from ..objects import Message
+
+
+@create(can_process=Message)
+def location(event) -> bool:
+    return bool(event.location)

PySPlusthon/conditions/media.py

@@ -0,0 +1,7 @@
+from .condition import create
+from ..objects import Message
+
+
+@create(can_process=Message)
+def media(event) -> bool:
+    return bool(event.animation or event.audio or event.document or event.photo or event.video or event.voice)

PySPlusthon/conditions/media_group.py

@@ -0,0 +1,7 @@
+from .condition import create
+from ..objects import Message
+
+
+@create(can_process=Message)
+def media_group(event) -> bool:
+    return bool(event.media_group_id)