kurimod 3.2.0__py3-none-any.whl

kurimod/__init__.py

@@ -0,0 +1,46 @@
+"""
+kurimod - A monkeypatched add-on for Kurigram/Pyrogram
+Copyright (C) 2020 Cezar H. <https://github.com/usernein>
+
+This file is part of kurimod.
+
+kurimod is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+kurimod is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with kurimod.  If not, see <https://www.gnu.org/licenses/>.
+"""
+
+from .config import config
+from .helpers import ikb, bki, ntb, btn, kb, kbtn, array_chunk, force_reply
+from .listen import Client, MessageHandler, CallbackQueryHandler, Message, Chat, User
+from .nav import Pagination
+from .utils import patch_into, should_patch
+
+__all__ = [
+    "config",
+    "Client",
+    "MessageHandler",
+    "Message",
+    "Chat",
+    "User",
+    "CallbackQueryHandler",
+    "patch_into",
+    "should_patch",
+    "ikb",
+    "bki",
+    "ntb",
+    "btn",
+    "kb",
+    "kbtn",
+    "array_chunk",
+    "force_reply",
+    "Pagination",
+]

kurimod/config/__init__.py

@@ -0,0 +1,12 @@
+from types import SimpleNamespace
+
+config = SimpleNamespace(
+    timeout_handler=None,
+    stopped_handler=None,
+    throw_exceptions=True,
+    unallowed_click_alert=True,
+    unallowed_click_alert_text=("[kurimod] You're not expected to click this button."),
+    disable_startup_logs=False,
+)
+
+__all__ = ["config"]

kurimod/config.py

@@ -0,0 +1,9 @@
+from types import SimpleNamespace
+
+config = SimpleNamespace(
+    timeout_handler=None,
+    stopped_handler=None,
+    throw_exceptions=True,
+    unallowed_click_alert=True,
+    unallowed_click_alert_text=("[kurimod] You're not expected to click this button."),
+)

kurimod/exceptions/__init__.py

@@ -0,0 +1,4 @@
+from .listener_stopped import ListenerStopped
+from .listener_timeout import ListenerTimeout
+
+__all__ = ["ListenerStopped", "ListenerTimeout"]

kurimod/exceptions/listener_stopped.py

@@ -0,0 +1,2 @@
+class ListenerStopped(Exception):
+    pass

kurimod/exceptions/listener_timeout.py

@@ -0,0 +1,2 @@
+class ListenerTimeout(Exception):
+    pass

kurimod/helpers/__init__.py

@@ -0,0 +1,22 @@
+"""
+kurimod - A monkeypatcher add-on for Pyrogram
+Copyright (C) 2020 Cezar H. <https://github.com/usernein>
+
+This file is part of kurimod.
+
+kurimod is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+kurimod is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with kurimod.  If not, see <https://www.gnu.org/licenses/>.
+"""
+from .helpers import ikb, bki, ntb, btn, kb, kbtn, array_chunk, force_reply
+
+__all__ = ["ikb", "bki", "ntb", "btn", "kb", "kbtn", "array_chunk", "force_reply"]

kurimod/helpers/helpers.py

@@ -0,0 +1,90 @@
+from pyrogram.types import (
+    InlineKeyboardButton,
+    InlineKeyboardMarkup,
+    KeyboardButton,
+    ReplyKeyboardMarkup,
+    ForceReply,
+)
+
+
+def ikb(rows=None):
+    if rows is None:
+        rows = []
+
+    lines = []
+    for row in rows:
+        line = []
+        for button in row:
+            button = (
+                btn(button, button) if isinstance(button, str) else btn(*button)
+            )  # InlineKeyboardButton
+            line.append(button)
+        lines.append(line)
+    return InlineKeyboardMarkup(inline_keyboard=lines)
+    # return {'inline_keyboard': lines}
+
+
+def btn(text, value, type="callback_data"):
+    return InlineKeyboardButton(text, **{type: value})
+    # return {'text': text, type: value}
+
+
+# The inverse of above
+def bki(keyboard):
+    lines = []
+    for row in keyboard.inline_keyboard:
+        line = []
+        for button in row:
+            button = ntb(button)  # btn() format
+            line.append(button)
+        lines.append(line)
+    return lines
+    # return ikb() format
+
+
+def ntb(button):
+    for btn_type in [
+        "callback_data",
+        "url",
+        "switch_inline_query",
+        "switch_inline_query_current_chat",
+        "callback_game",
+    ]:
+        value = getattr(button, btn_type)
+        if value:
+            break
+    button = [button.text, value]
+    if btn_type != "callback_data":
+        button.append(btn_type)
+    return button
+    # return {'text': text, type: value}
+
+
+def kb(rows=None, **kwargs):
+    if rows is None:
+        rows = []
+
+    lines = []
+    for row in rows:
+        line = []
+        for button in row:
+            button_type = type(button)
+            if button_type == str:
+                button = KeyboardButton(button)
+            elif button_type == dict:
+                button = KeyboardButton(**button)
+
+            line.append(button)
+        lines.append(line)
+    return ReplyKeyboardMarkup(keyboard=lines, **kwargs)
+
+
+kbtn = KeyboardButton
+
+
+def force_reply(selective=True):
+    return ForceReply(selective=selective)
+
+
+def array_chunk(input_array, size):
+    return [input_array[i : i + size] for i in range(0, len(input_array), size)]

kurimod/listen/__init__.py

@@ -0,0 +1,35 @@
+"""
+kurimod - A monkeypatcher add-on for Pyrogram
+Copyright (C) 2020 Cezar H. <https://github.com/usernein>
+
+This file is part of kurimod.
+
+kurimod is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+kurimod is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with kurimod.  If not, see <https://www.gnu.org/licenses/>.
+"""
+
+from .callback_query_handler import CallbackQueryHandler
+from .chat import Chat
+from .client import Client
+from .message import Message
+from .message_handler import MessageHandler
+from .user import User
+
+__all__ = [
+    "Client",
+    "MessageHandler",
+    "Message",
+    "Chat",
+    "User",
+    "CallbackQueryHandler",
+]

kurimod/listen/callback_query_handler.py

@@ -0,0 +1,146 @@
+from inspect import iscoroutinefunction
+from typing import Callable, Tuple
+
+import pyrogram
+from pyrogram.filters import Filter
+from pyrogram.types import CallbackQuery
+
+from .client import Client
+from ..config import config
+from ..types import ListenerTypes, Identifier, Listener
+from ..utils import patch_into, should_patch
+
+
+@patch_into(pyrogram.handlers.callback_query_handler.CallbackQueryHandler)
+class CallbackQueryHandler(
+    pyrogram.handlers.callback_query_handler.CallbackQueryHandler
+):
+    old__init__: Callable
+
+    @should_patch()
+    def __init__(self, callback: Callable, filters: Filter = None):
+        self.original_callback = callback
+        self.old__init__(self.resolve_future_or_callback, filters)
+
+    @should_patch()
+    def compose_data_identifier(self, query: CallbackQuery):
+        from_user = query.from_user
+        from_user_id = from_user.id if from_user else None
+        from_user_username = from_user.username if from_user else None
+
+        chat_id = None
+        message_id = None
+
+        if query.message:
+            message_id = getattr(
+                query.message, "id", getattr(query.message, "message_id", None)
+            )
+
+            if query.message.chat:
+                chat_id = [query.message.chat.id, query.message.chat.username]
+
+        return Identifier(
+            message_id=message_id,
+            chat_id=chat_id,
+            from_user_id=[from_user_id, from_user_username],
+            inline_message_id=query.inline_message_id,
+        )
+
+    @should_patch()
+    async def check_if_has_matching_listener(
+        self, client: Client, query: CallbackQuery
+    ) -> Tuple[bool, Listener]:
+        data = self.compose_data_identifier(query)
+
+        listener = client.get_listener_matching_with_data(
+            data, ListenerTypes.CALLBACK_QUERY
+        )
+
+        listener_does_match = False
+
+        if listener:
+            filters = listener.filters
+            if callable(filters):
+                if iscoroutinefunction(filters.__call__):
+                    listener_does_match = await filters(client, query)
+                else:
+                    listener_does_match = await client.loop.run_in_executor(
+                        None, filters, client, query
+                    )
+            else:
+                listener_does_match = True
+
+        return listener_does_match, listener
+
+    @should_patch()
+    async def check(self, client: Client, query: CallbackQuery):
+        listener_does_match, listener = await self.check_if_has_matching_listener(
+            client, query
+        )
+
+        if callable(self.filters):
+            if iscoroutinefunction(self.filters.__call__):
+                handler_does_match = await self.filters(client, query)
+            else:
+                handler_does_match = await client.loop.run_in_executor(
+                    None, self.filters, client, query
+                )
+        else:
+            handler_does_match = True
+
+        data = self.compose_data_identifier(query)
+
+        if config.unallowed_click_alert:
+            # matches with the current query but from any user
+            permissive_identifier = Identifier(
+                chat_id=data.chat_id,
+                message_id=data.message_id,
+                inline_message_id=data.inline_message_id,
+                from_user_id=None,
+            )
+
+            matches = permissive_identifier.matches(data)
+
+            if (
+                listener
+                and (matches and not listener_does_match)
+                and listener.unallowed_click_alert
+            ):
+                alert = (
+                    listener.unallowed_click_alert
+                    if isinstance(listener.unallowed_click_alert, str)
+                    else config.unallowed_click_alert_text
+                )
+                await query.answer(alert)
+                return False
+
+        # let handler get the chance to handle if listener
+        # exists but its filters doesn't match
+        return listener_does_match or handler_does_match
+
+    @should_patch()
+    async def resolve_future_or_callback(
+        self, client: Client, query: CallbackQuery, *args
+    ):
+        listener_does_match, listener = await self.check_if_has_matching_listener(
+            client, query
+        )
+
+        if listener and listener_does_match:
+            client.remove_listener(listener)
+
+            if listener.future and not listener.future.done():
+                listener.future.set_result(query)
+
+                raise pyrogram.StopPropagation
+            elif listener.callback:
+                if iscoroutinefunction(listener.callback):
+                    await listener.callback(client, query, *args)
+                else:
+                    listener.callback(client, query, *args)
+
+                raise pyrogram.StopPropagation
+            else:
+                raise ValueError("Listener must have either a future or a callback")
+        else:
+            await self.original_callback(client, query, *args)

kurimod/listen/chat.py

@@ -0,0 +1,21 @@
+import pyrogram
+
+from .client import Client
+from ..utils import patch_into, should_patch
+
+
+@patch_into(pyrogram.types.user_and_chats.chat.Chat)
+class Chat(pyrogram.types.user_and_chats.chat.Chat):
+    _client: Client
+
+    @should_patch()
+    def listen(self, *args, **kwargs):
+        return self._client.listen(*args, chat_id=self.id, **kwargs)
+
+    @should_patch()
+    def ask(self, text, *args, **kwargs):
+        return self._client.ask(self.id, text, *args, **kwargs)
+
+    @should_patch()
+    def stop_listening(self, *args, **kwargs):
+        return self._client.stop_listening(*args, chat_id=self.id, **kwargs)

kurimod/listen/client.py

@@ -0,0 +1,232 @@
+import asyncio
+from inspect import iscoroutinefunction
+from typing import Optional, Callable, Dict, List, Union
+
+import pyrogram
+from pyrogram.filters import Filter
+
+from ..config import config
+from ..exceptions import ListenerTimeout, ListenerStopped
+from ..types import ListenerTypes, Identifier, Listener
+from ..utils import should_patch, patch_into
+
+
+
+@patch_into(pyrogram.client.Client)
+class Client(pyrogram.client.Client.on_callback_query()):
+    listeners: Dict[ListenerTypes, List[Listener]]
+    old__init__: Callable
+
+    @should_patch()
+    def __init__(self, *args, **kwargs):
+        self.listeners = {listener_type: [] for listener_type in ListenerTypes}
+        self.old__init__(*args, **kwargs)
+
+    @should_patch()
+    async def listen(
+        self,
+        filters: Optional[Filter] = None,
+        listener_type: ListenerTypes = ListenerTypes.MESSAGE,
+        timeout: Optional[int] = None,
+        unallowed_click_alert: bool = True,
+        chat_id: Union[Union[int, str], List[Union[int, str]]] = None,
+        user_id: Union[Union[int, str], List[Union[int, str]]] = None,
+        message_id: Union[int, List[int]] = None,
+        inline_message_id: Union[str, List[str]] = None,
+    ):
+        pattern = Identifier(
+            from_user_id=user_id,
+            chat_id=chat_id,
+            message_id=message_id,
+            inline_message_id=inline_message_id,
+        )
+
+        loop = asyncio.get_event_loop()
+        future = loop.create_future()
+
+        listener = Listener(
+            future=future,
+            filters=filters,
+            unallowed_click_alert=unallowed_click_alert,
+            identifier=pattern,
+            listener_type=listener_type,
+        )
+
+        future.add_done_callback(lambda _future: self.remove_listener(listener))
+
+        self.listeners[listener_type].append(listener)
+
+        try:
+            return await asyncio.wait_for(future, timeout)
+        except asyncio.exceptions.TimeoutError:
+            if callable(config.timeout_handler):
+                if iscoroutinefunction(config.timeout_handler.__call__):
+                    await config.timeout_handler(pattern, listener, timeout)
+                else:
+                    await self.loop.run_in_executor(
+                        None, config.timeout_handler, pattern, listener, timeout
+                    )
+            elif config.throw_exceptions:
+                raise ListenerTimeout(timeout)
+
+    @should_patch()
+    async def ask(
+        self,
+        chat_id: Union[Union[int, str], List[Union[int, str]]],
+        text: str,
+        filters: Optional[Filter] = None,
+        listener_type: ListenerTypes = ListenerTypes.MESSAGE,
+        timeout: Optional[int] = None,
+        unallowed_click_alert: bool = True,
+        user_id: Union[Union[int, str], List[Union[int, str]]] = None,
+        message_id: Union[int, List[int]] = None,
+        inline_message_id: Union[str, List[str]] = None,
+        *args,
+        **kwargs,
+    ):
+        sent_message = None
+        if text.strip() != "":
+            chat_to_ask = chat_id[0] if isinstance(chat_id, list) else chat_id
+            sent_message = await self.send_message(chat_to_ask, text, *args, **kwargs)
+
+        response = await self.listen(
+            filters=filters,
+            listener_type=listener_type,
+            timeout=timeout,
+            unallowed_click_alert=unallowed_click_alert,
+            chat_id=chat_id,
+            user_id=user_id,
+            message_id=message_id,
+            inline_message_id=inline_message_id,
+        )
+        if response:
+            response.sent_message = sent_message
+
+        return response
+
+    @should_patch()
+    def remove_listener(self, listener: Listener):
+        try:
+            self.listeners[listener.listener_type].remove(listener)
+        except ValueError:
+            pass
+
+    @should_patch()
+    def get_listener_matching_with_data(
+        self, data: Identifier, listener_type: ListenerTypes
+    ) -> Optional[Listener]:
+        matching = []
+        for listener in self.listeners[listener_type]:
+            if listener.identifier.matches(data):
+                matching.append(listener)
+
+        # in case of multiple matching listeners, the most specific should be returned
+        def count_populated_attributes(listener_item: Listener):
+            return listener_item.identifier.count_populated()
+
+        return max(matching, key=count_populated_attributes, default=None)
+
+    def get_listener_matching_with_identifier_pattern(
+        self, pattern: Identifier, listener_type: ListenerTypes
+    ) -> Optional[Listener]:
+        matching = []
+        for listener in self.listeners[listener_type]:
+            if pattern.matches(listener.identifier):
+                matching.append(listener)
+
+        # in case of multiple matching listeners, the most specific should be returned
+
+        def count_populated_attributes(listener_item: Listener):
+            return listener_item.identifier.count_populated()
+
+        return max(matching, key=count_populated_attributes, default=None)
+
+    @should_patch()
+    def get_many_listeners_matching_with_data(
+        self,
+        data: Identifier,
+        listener_type: ListenerTypes,
+    ) -> List[Listener]:
+        listeners = []
+        for listener in self.listeners[listener_type]:
+            if listener.identifier.matches(data):
+                listeners.append(listener)
+        return listeners
+
+    @should_patch()
+    def get_many_listeners_matching_with_identifier_pattern(
+        self,
+        pattern: Identifier,
+        listener_type: ListenerTypes,
+    ) -> List[Listener]:
+        listeners = []
+        for listener in self.listeners[listener_type]:
+            if pattern.matches(listener.identifier):
+                listeners.append(listener)
+        return listeners
+
+    @should_patch()
+    async def stop_listening(
+        self,
+        listener_type: ListenerTypes = ListenerTypes.MESSAGE,
+        chat_id: Union[Union[int, str], List[Union[int, str]]] = None,
+        user_id: Union[Union[int, str], List[Union[int, str]]] = None,
+        message_id: Union[int, List[int]] = None,
+        inline_message_id: Union[str, List[str]] = None,
+    ):
+        pattern = Identifier(
+            from_user_id=user_id,
+            chat_id=chat_id,
+            message_id=message_id,
+            inline_message_id=inline_message_id,
+        )
+        listeners = self.get_many_listeners_matching_with_identifier_pattern(pattern, listener_type)
+
+        for listener in listeners:
+            await self.stop_listener(listener)
+
+    @should_patch()
+    async def stop_listener(self, listener: Listener):
+        self.remove_listener(listener)
+
+        if listener.future.done():
+            return
+
+        if callable(config.stopped_handler):
+            if iscoroutinefunction(config.stopped_handler.__call__):
+                await config.stopped_handler(None, listener)
+            else:
+                await self.loop.run_in_executor(
+                    None, config.stopped_handler, None, listener
+                )
+        elif config.throw_exceptions:
+            listener.future.set_exception(ListenerStopped())
+
+    @should_patch()
+    def register_next_step_handler(
+        self,
+        callback: Callable,
+        filters: Optional[Filter] = None,
+        listener_type: ListenerTypes = ListenerTypes.MESSAGE,
+        unallowed_click_alert: bool = True,
+        chat_id: Union[Union[int, str], List[Union[int, str]]] = None,
+        user_id: Union[Union[int, str], List[Union[int, str]]] = None,
+        message_id: Union[int, List[int]] = None,
+        inline_message_id: Union[str, List[str]] = None,
+    ):
+        pattern = Identifier(
+            from_user_id=user_id,
+            chat_id=chat_id,
+            message_id=message_id,
+            inline_message_id=inline_message_id,
+        )
+
+        listener = Listener(
+            callback=callback,
+            filters=filters,
+            unallowed_click_alert=unallowed_click_alert,
+            identifier=pattern,
+            listener_type=listener_type,
+        )
+
+        self.listeners[listener_type].append(listener)

kurimod/listen/message.py

@@ -0,0 +1,32 @@
+from typing import Optional, Union, List
+
+import pyrogram
+
+from .client import Client
+from ..types import ListenerTypes
+from ..utils import patch_into, should_patch
+
+
+@patch_into(pyrogram.types.messages_and_media.message.Message)
+class Message(pyrogram.types.messages_and_media.message.Message):
+    _client = Client
+
+    @should_patch()
+    async def wait_for_click(
+        self,
+        from_user_id: Optional[Union[Union[int, str], List[Union[int, str]]]] = None,
+        timeout: Optional[int] = None,
+        filters=None,
+        alert: Union[str, bool] = True,
+    ):
+        message_id = getattr(self, "id", getattr(self, "message_id", None))
+
+        return await self._client.listen(
+            listener_type=ListenerTypes.CALLBACK_QUERY,
+            timeout=timeout,
+            filters=filters,
+            unallowed_click_alert=alert,
+            chat_id=self.chat.id,
+            user_id=from_user_id,
+            message_id=message_id,
+        )