maxkit 2.13.0__py3-none-any.whl

aiomax/buttons.py

@@ -0,0 +1,303 @@
+import logging
+from typing import Literal
+
+button_logger = logging.getLogger("aiomax.buttons")
+
+
+class Button:
+    def __init__(
+        self,
+        type: Literal[
+            "callback",
+            "link",
+            "request_geo_location",
+            "request_contact",
+            "chat",
+        ],
+        text: str,
+    ):
+        """
+        Base button class
+        """
+        self.type: Literal[
+            "callback",
+            "link",
+            "request_geo_location",
+            "request_contact",
+            "chat",
+        ] = type
+        self.text: str = text
+
+    @staticmethod
+    def from_json(data: dict) -> "Button":
+        if data["type"] == "callback":
+            return CallbackButton.from_json(data)
+        elif data["type"] == "link":
+            return LinkButton.from_json(data)
+        elif data["type"] == "request_geo_location":
+            return GeolocationButton.from_json(data)
+        elif data["type"] == "request_contact":
+            return ContactButton.from_json(data)
+        elif data["type"] == "chat":
+            return ChatButton.from_json(data)
+        elif data["type"] == "message":
+            return MessageButton.from_json(data)
+        elif data["type"] == "open_app":
+            return WebAppButton.from_json(data)
+        else:
+            # Unknown/newly-added button type: keep parsing the keyboard
+            # instead of crashing the whole update.
+            button_logger.warning("Unknown button type: %s", data.get("type"))
+            return Button(data["type"], data.get("text", ""))
+
+    def to_json(self) -> dict:
+        return {"type": self.type, "text": self.text}
+
+
+class CallbackButton(Button):
+    def __init__(
+        self,
+        text: str,
+        payload: str,
+        intent: Literal["default", "positive", "negative"] = "default",
+    ):
+        """
+        Callback button
+
+        :param text: Button text
+        :param payload: Payload that will be sent to the bot when the button is
+            pressed
+        :param intent: Intent of the button (changes appearance on client)
+        """
+        super().__init__("callback", text)
+        self.payload: str = payload
+        self.intent: Literal["default", "positive", "negative"] = intent
+
+    @staticmethod
+    def from_json(data: dict) -> "CallbackButton":
+        return CallbackButton(
+            data.get("text", ""),
+            data.get("payload", ""),
+            data.get("intent", "default"),
+        )
+
+    def to_json(self) -> dict:
+        return {
+            "type": "callback",
+            "text": self.text,
+            "payload": self.payload,
+            "intent": self.intent,
+        }
+
+
+class LinkButton(Button):
+    def __init__(
+        self,
+        text: str,
+        url: str,
+    ):
+        """
+        URL button on a message
+
+        :param text: Button text
+        :param url: Link that the button redirects to
+        """
+        super().__init__("link", text)
+        self.url: str = url
+
+    @staticmethod
+    def from_json(data: dict) -> "LinkButton":
+        return LinkButton(data.get("text", ""), data.get("url", ""))
+
+    def to_json(self) -> dict:
+        return {"type": "link", "text": self.text, "url": self.url}
+
+
+class GeolocationButton(Button):
+    def __init__(
+        self,
+        text: str,
+        quick: bool = False,
+    ):
+        """
+        Request geolocation button on a message
+
+        :param text: Button text
+        :param quick: Whether to show a confirmational message to a user when
+            pressing the button
+        """
+        super().__init__("request_geo_location", text)
+        self.quick: bool = quick
+
+    @staticmethod
+    def from_json(data: dict) -> "GeolocationButton":
+        return GeolocationButton(
+            data.get("text", ""), data.get("quick", False)
+        )
+
+    def to_json(self) -> dict:
+        return {
+            "type": "request_geo_location",
+            "text": self.text,
+            "quick": self.quick,
+        }
+
+
+class ContactButton(Button):
+    def __init__(self, text: str):
+        """
+        Request contact button on a message
+
+        :param text: Button text
+        """
+        super().__init__("request_contact", text)
+
+    @staticmethod
+    def from_json(data: dict) -> "ContactButton":
+        return ContactButton(data.get("text", ""))
+
+    def to_json(self) -> dict:
+        return {"type": "request_contact", "text": self.text}
+
+
+class ChatButton(Button):
+    def __init__(
+        self,
+        text: str,
+        title: str,
+        description: "str | None" = None,
+        payload: "str | None" = None,
+        uuid: "int | None" = None,
+    ):
+        """
+        Chat creation button on a message
+
+        :param text: Button text
+        :param title: Name of the new chat
+        :param description: Description of the new chat
+        :param payload: Payload that will be sent to the bot when the chat is
+            created
+        :param uuid: Chat UUID, assigned when new message is sent.
+            Provide when editing message
+        """
+        super().__init__("chat", text)
+        self.title: str = title
+        self.description: str | None = description
+        self.payload: str | None = payload
+        self.uuid: int | None = uuid
+
+    @staticmethod
+    def from_json(data: dict) -> "ChatButton":
+        return ChatButton(
+            data.get("text", ""),
+            data.get("chat_title"),
+            data.get("chat_description"),
+            data.get("start_payload"),
+            data.get("uuid"),
+        )
+
+    def to_json(self) -> dict:
+        return {
+            "type": "chat",
+            "text": self.text,
+            "chat_title": self.title,
+            "chat_description": self.description,
+            "start_payload": self.payload,
+            "uuid": self.uuid,
+        }
+
+
+class WebAppButton(Button):
+    def __init__(self, text: str, bot: "str | int"):
+        """
+        Open web app button
+
+        :param text: Button text
+        :param bot: Bot ID, username or link of which to open
+            the web app
+        """
+        super().__init__("open_app", text)
+        self.bot: "str | int" = bot
+
+    @staticmethod
+    def from_json(data: dict) -> "WebAppButton":
+        bot = data.get("contact_id", data.get("web_app"))
+        return WebAppButton(data.get("text", ""), bot)
+
+    def to_json(self) -> dict:
+        data = {"type": "open_app", "text": self.text}
+        if isinstance(self.bot, int):
+            data["contact_id"] = self.bot
+        else:
+            data["web_app"] = self.bot
+        return data
+
+
+class MessageButton(Button):
+    def __init__(self, text: str):
+        """
+        Send text to chat button
+
+        :param text: Button text. Will be sent to the chat when a user
+            presses the button
+        """
+        super().__init__("message", text)
+
+    @staticmethod
+    def from_json(data: dict) -> "MessageButton":
+        return MessageButton(data.get("text", ""))
+
+    def to_json(self) -> dict:
+        return {"type": "message", "text": self.text}
+
+
+# builder
+
+
+class KeyboardBuilder:
+    def __init__(self):
+        """
+        Keyboard builder
+        """
+        self.buttons: list[list[Button]] = []
+
+    def to_list(self) -> list[list[dict]]:
+        """
+        Returns a serialised interpretation of the keyboard to put in a message
+        """
+        return [[button.to_json() for button in row] for row in self.buttons]
+
+    def add(self, *buttons: Button):
+        """
+        Add buttons to the last row of the keyboard
+        """
+        if len(self.buttons) == 0:
+            self.buttons.append([])
+
+        self.buttons[-1].extend(buttons)
+        return self
+
+    def row(self, *buttons: Button):
+        """
+        Add a row of buttons
+        """
+        self.buttons.append(list(buttons))
+        return self
+
+    def table(self, in_row: int, *buttons: Button):
+        """
+        Adds multiple rows of buttons so that there are `in_row` buttons
+            in each row
+
+        :param in_row: How many buttons to put in each row
+        """
+        counter = 0
+
+        for button in buttons:
+            if counter == 0:
+                self.row()
+                counter = in_row
+
+            self.add(button)
+            counter -= 1
+        return self

aiomax/cache.py

@@ -0,0 +1,31 @@
+from .types import Message
+
+
+class MessageCache:
+    def __init__(self, max_size: int = 10000):
+        """
+        New message cache.
+
+        :param max_size: Maximum number of messages to store
+        """
+        self.max_size: int = max_size
+        self.messages: dict[str, Message] = {}
+
+    def get_message(self, id: str) -> "Message | None":
+        """
+        Returns a message by ID. None if message wasnt cached
+
+        :param id: Message ID
+        """
+        return self.messages.get(id, None)
+
+    def add_message(self, message: Message):
+        """
+        Caches a message.
+
+        :param message: Message
+        """
+        self.messages[message.id] = message
+
+        while len(self.messages) > self.max_size:
+            (k := next(iter(self.messages)), self.messages.pop(k))

aiomax/exceptions.py

@@ -0,0 +1,85 @@
+class AiomaxException(Exception):
+    """
+    Default class for aiomax Exceptions
+    """
+
+
+class InvalidToken(AiomaxException):
+    """
+    Invalid token Exception
+    """
+
+
+class AttachmentNotReady(AiomaxException):
+    """
+    Attachment not ready Exception
+    """
+
+
+class ChatNotFound(AiomaxException):
+    """
+    Chat not found Exception
+    """
+
+
+class IncorrectTextLength(AiomaxException):
+    """
+    Incorrect text length Exception
+    """
+
+
+class InternalError(AiomaxException):
+    """
+    Internal error Exception
+    """
+
+    def __init__(self, id: "str | None" = None):
+        self.id: str = id
+
+
+class UnknownErrorException(AiomaxException):
+    """
+    Unknown error Exception
+    """
+
+    def __init__(self, text: str, description: "str | None" = None):
+        self.text: str = text
+        self.description: "str | None" = description
+
+
+class AccessDeniedException(AiomaxException):
+    """
+    Access Denied Exception
+    """
+
+    def __init__(self, description: "str | None" = None):
+        self.description: "str | None" = description
+
+
+class NotFoundException(AiomaxException):
+    """
+    Something not found Exception
+    """
+
+    def __init__(self, description: "str | None" = None):
+        self.description: "str | None" = description
+
+
+class MessageNotFoundException(NotFoundException):
+    """
+    Child `NotFoundException` exception class that is raised
+    in `Bot.get_message` function
+    """
+
+
+class FilenameNotProvided(AiomaxException):
+    """
+    Filename not provided exception
+    """
+
+
+class InvalidSSLException(AiomaxException):
+    """
+    Invalid SSL certificate. Might mean that
+    Mintsifra certificate is not installed
+    """

aiomax/filters.py

@@ -0,0 +1,179 @@
+import re
+from typing import Any
+
+
+def normalize_filter(filter_):
+    if isinstance(filter_, str):
+        return equals(filter_)
+
+    elif isinstance(filter_, bool):
+        return lambda _: filter_
+
+    elif callable(filter_):
+        return filter_
+
+    raise ValueError(f"Unsupported filter type: {type(filter_)}")
+
+
+class _filter:
+    """
+    Superclass of other filters for support of bit-wise or and bit-wise and
+    """
+
+    def __or__(self, other):
+        return _OrFilter(self, other)
+
+    def __and__(self, other):
+        return _AndFilter(self, other)
+
+
+class _OrFilter(_filter):
+    """
+    Class for using bit-wise or on filters
+    """
+
+    def __init__(self, filter1, filter2):
+        self.filter1 = normalize_filter(filter1)
+        self.filter2 = normalize_filter(filter2)
+
+    def __call__(self, obj: any):
+        return self.filter1(obj) or self.filter2(obj)
+
+
+class _AndFilter(_filter):
+    """
+    Class for using bit-wise and on filters
+    """
+
+    def __init__(self, filter1, filter2):
+        self.filter1 = normalize_filter(filter1)
+        self.filter2 = normalize_filter(filter2)
+
+    def __call__(self, obj: any):
+        return self.filter1(obj) and self.filter2(obj)
+
+
+class equals(_filter):
+    def __init__(self, content: str):
+        """
+        :param content: Content to check
+
+        Checks if the content equals to the given string
+        """
+        self.content = content
+
+    def __call__(self, obj: any):
+        if hasattr(obj, "content"):
+            return obj.content == self.content
+        else:
+            raise Exception(f"Class {type(obj).__name__} has no content")
+
+
+class has(_filter):
+    def __init__(self, content: str):
+        """
+        :param content: Content to check
+
+        Checks if the content has the given string
+        """
+        self.content = content
+
+    def __call__(self, obj: any):
+        if not hasattr(obj, "content"):
+            raise Exception(f"Class {type(obj).__name__} has no content")
+        if obj.content is None:
+            return False
+        return self.content in obj.content
+
+
+class startswith(_filter):
+    def __init__(self, prefix: str):
+        """
+        :param prefix: Prefix to check
+
+        Checks if the content starts with the given prefix
+        """
+        self.prefix = prefix
+
+    def __call__(self, obj: any):
+        if not hasattr(obj, "content"):
+            raise Exception(f"Class {type(obj).__name__} has no content")
+        if obj.content is None:
+            return False
+        return obj.content.startswith(self.prefix)
+
+
+class endswith(_filter):
+    def __init__(self, suffix: str):
+        """
+        :param suffix: Suffix to check
+
+        Checks if the content ends with the given suffix
+        """
+        self.suffix = suffix
+
+    def __call__(self, obj: any):
+        if not hasattr(obj, "content"):
+            raise Exception(f"Class {type(obj).__name__} has no content")
+        if obj.content is None:
+            return False
+        return obj.content.endswith(self.suffix)
+
+
+class regex(_filter):
+    def __init__(self, pattern: str):
+        """
+        :param pattern: Regex pattern to check
+
+        Checks if the content matches the given pattern
+        """
+        self.pattern = pattern
+
+    def __call__(self, obj: any):
+        if not hasattr(obj, "content"):
+            raise Exception(f"Class {type(obj).__name__} has no content")
+        if obj.content is None:
+            return None
+        return re.fullmatch(self.pattern, obj.content)
+
+
+def papaya(obj: any):
+    """
+    Checks if the content's second-to-last word of the content is "папайя".
+
+    You do not need to call this.
+    """
+    if not hasattr(obj, "content"):
+        raise Exception(f"Class {type(obj).__name__} has no content")
+    if obj.content is None:
+        return False
+    words = obj.content.split()
+    if len(words) < 2:
+        return False
+    return words[-2].lower() == "папайя"
+
+
+class state(_filter):
+    def __init__(self, state: Any):
+        """
+        :param state: State to check
+
+        Checks if the content matches the given pattern
+        """
+        self.state = state
+
+    def __call__(self, obj: Any):
+        if not hasattr(obj, "user_id"):
+            raise Exception(f"Class {type(obj).__name__} has no user id")
+
+        user_id = obj.user_id
+
+        if not user_id:
+            return False
+
+        if not hasattr(obj, "bot") or not obj.bot:
+            return False
+
+        storage = obj.bot.storage
+
+        return storage.get_state(user_id) == self.state

aiomax/fsm.py

@@ -0,0 +1,107 @@
+from typing import Any
+
+
+class FSMStorage:
+    """
+    In-memory storage of FSM state and data.
+
+    State is keyed by ``user_id`` only, so a user shares the same state and
+    data across every chat they talk to the bot in. In multi-chat/group bots
+    a single user's flows in different chats will therefore collide; scope
+    your own keys by chat if you need per-chat isolation.
+    """
+
+    def __init__(self):
+        self.states: dict[int, Any] = {}
+        self.data: dict[int, Any] = {}
+
+    def get_state(self, user_id: int) -> Any:
+        """
+        Gets user's state
+        """
+        return self.states.get(user_id)
+
+    def get_data(self, user_id: int) -> Any:
+        """
+        Gets user's data
+        """
+        return self.data.get(user_id)
+
+    def change_state(self, user_id: int, new: Any):
+        """
+        Changes user's state
+        """
+        self.states[user_id] = new
+
+    def change_data(self, user_id: int, new: Any):
+        """
+        Changes user's data
+        """
+        self.data[user_id] = new
+
+    def clear_state(self, user_id: int) -> Any:
+        """
+        Clears user's state and returns it
+        """
+        return self.states.pop(user_id, None)
+
+    def clear_data(self, user_id: int) -> Any:
+        """
+        Clears user's data and returns it
+        """
+        return self.data.pop(user_id, None)
+
+    def clear(self, user_id: int):
+        """
+        Clears user's state and data
+        """
+        self.states.pop(user_id, None)
+        self.data.pop(user_id, None)
+
+
+class FSMCursor:
+    def __init__(self, storage: FSMStorage, user_id: int):
+        self.storage: FSMStorage = storage
+        self.user_id: int = user_id
+
+    def get_state(self) -> Any:
+        """
+        Gets user's state
+        """
+        return self.storage.get_state(self.user_id)
+
+    def get_data(self) -> Any:
+        """
+        Gets user's data
+        """
+        return self.storage.get_data(self.user_id)
+
+    def change_state(self, new: Any):
+        """
+        Changes user's state
+        """
+        self.storage.change_state(self.user_id, new)
+
+    def change_data(self, new: Any):
+        """
+        Changes user's data
+        """
+        self.storage.change_data(self.user_id, new)
+
+    def clear_state(self) -> Any:
+        """
+        Deletes user's state and returns it
+        """
+        return self.storage.clear_state(self.user_id)
+
+    def clear_data(self) -> Any:
+        """
+        Deletes user's data and returns it
+        """
+        return self.storage.clear_data(self.user_id)
+
+    def clear(self):
+        """
+        Clears user's state and data
+        """
+        self.storage.clear(self.user_id)