RubigramClient 1.7.0__py3-none-any.whl → 1.7.2__py3-none-any.whl

rubigram/method/utilities/dispatch.py

@@ -0,0 +1,25 @@
+from typing import Union
+import rubigram
+
+
+class Dispatch:
+    async def dispatch(
+        self: "rubigram.Client",
+        update: Union[
+            "rubigram.types.Update",
+            "rubigram.types.InlineMessage"
+        ]
+    ):
+        if isinstance(update, rubigram.types.InlineMessage):
+            event_type = "inline"
+        else:
+            match update.type:
+                case "NewMessage": event_type = "message"
+                case "UpdatedMessage": event_type = "edit"
+                case "RemovedMessage": event_type = "delete"
+                case other:
+                    return
+
+        for handler in self.handlers[event_type]:
+            if handler.filters is None or await handler.filters(update):
+                await handler.func(self, update)

rubigram/method/utilities/setup_endpoint.py

@@ -0,0 +1,16 @@
+import rubigram
+from ...logger import logger
+
+
+class SetupEndpoints:
+    async def setup_endpoints(self: "rubigram.Client"):
+        endpoint_types = [
+            "ReceiveUpdate",
+            "ReceiveInlineMessage"
+        ]
+        for endpoint_type in endpoint_types:
+            setup = await self.update_bot_endpoints(
+                "{}/{}".format(self.endpoint, endpoint_type),
+                endpoint_type
+            )
+            logger.info("[<] set endpoint for {} : {}".format(endpoint_type, setup["status"]))

rubigram/method/utilities/updater.py

@@ -0,0 +1,17 @@
+import rubigram
+
+
+class Updater:
+    async def updater(
+        self: "rubigram.Client",
+        data: dict
+    ):
+        if "inline_message" in data:
+            event = rubigram.types.InlineMessage.parse(data["inline_message"])
+        elif "update" in data:
+            event = rubigram.types.Update.parse(data["update"])
+        else:
+            return
+
+        event.client = self
+        await self.dispatch(event)

rubigram/state.py

@@ -1,35 +1,30 @@
 from typing import Any
 
-class StateManager:
+
+class state:
     def __init__(self):
-        self.DATA: dict[str, dict[str, Any]] = {}
-        self.STATE: dict[str, str] = {}
+        self.data: dict[str, dict[str, Any]] = {}
+        self.state: dict[str, str] = {}
 
-        
     async def set_state(self, user_id: str, state: str):
-        self.STATE[user_id] = state
-    
-    
+        self.state[user_id] = state
+
     async def get_state(self, user_id: str):
-        return self.STATE.get(user_id)
+        return self.state.get(user_id)
 
-    
     async def remove_state(self, user_id: str):
-        self.STATE.pop(user_id, None)
+        self.state.pop(user_id, None)
 
-        
     async def set_data(self, user_id: str, **data):
-        if user_id not in self.DATA:
-            self.DATA[user_id] = {}
-        self.DATA[user_id].update(data)
+        if user_id not in self.data:
+            self.data[user_id] = {}
+        self.data[user_id].update(data)
 
-    
     async def get_data(self, user_id: str, key: str = None):
-        data = self.DATA.get(user_id, {})
+        data = self.data.get(user_id, {})
         return data.get(key) if key else data
 
-
     async def remove_data(self, user_id: str, key: str = None):
         if key:
-            return self.DATA.get(user_id, {}).pop(key, None)
-        return self.DATA.pop(user_id, None)
+            return self.data.get(user_id, {}).pop(key, None)
+        return self.data.pop(user_id, None)

rubigram/types/__init__.py

@@ -0,0 +1,3 @@
+from .types import *
+from .messages import *
+from .updates import *

rubigram/types/messages.py

@@ -0,0 +1,175 @@
+from typing import Optional
+from dataclasses import dataclass
+from .object import Object
+from .types import *
+import rubigram
+
+
+@dataclass
+class Message(Object):
+    message_id: Optional[str] = None
+    text: Optional[str] = None
+    time: Optional[str] = None
+    is_edited: Optional[bool] = None
+    sender_type: Optional[enums.MessageSender] = None
+    sender_id: Optional[str] = None
+    aux_data: Optional[AuxData] = None
+    file: Optional[File] = None
+    reply_to_message_id: Optional[str] = None
+    forwarded_from: Optional[ForwardedFrom] = None
+    forwarded_no_link: Optional[str] = None
+    location: Optional[Location] = None
+    sticker: Optional[Sticker] = None
+    contact_message: Optional[ContactMessage] = None
+    poll: Optional[Poll] = None
+    live_location: Optional[LiveLocation] = None
+    client: Optional["rubigram.Client"] = None
+
+
+@dataclass
+class InlineMessage(Object):
+    sender_id: Optional[str] = None
+    text: Optional[str] = None
+    message_id: Optional[str] = None
+    chat_id: Optional[str] = None
+    file: Optional[File] = None
+    location: Optional[Location] = None
+    aux_data: Optional[AuxData] = None
+    client: Optional["rubigram.Client"] = None
+
+
+@dataclass
+class UMessage(Object):
+    message_id: Optional[str] = None
+    file_id: Optional[str] = None
+    chat_id: Optional[str] = None
+    client: Optional["rubigram.Client"] = None
+
+    async def delete(self):
+        """Delete this message from the chat.
+
+        Sends a request to Rubigram to remove the message identified
+        by this object's `message_id` from its chat.
+
+        Args:
+            self (UMessage): The message instance to be deleted.
+
+        Returns:
+            bool: True if the message was successfully deleted, False otherwise.
+
+        Example:
+            >>> message = await client.send_message(chat_id="b0X123", text="Hello!")
+            >>> await message.delete()
+        """
+        return await self.client.delete_message(
+            self.chat_id, self.message_id
+        )
+
+    async def edit(
+        self,
+        text: Optional[str] = None,
+        inline: Optional[Keypad] = None,
+        keypad: Optional[Keypad] = None
+    ):
+        """Edit this message's content, inline keyboard, or chat keypad.
+
+        This method allows modifying the text, inline keyboard, or chat keypad
+        of the current message. You can use any combination of parameters to
+        update different parts of the message.
+
+        Args:
+            self (UMessage): The message instance to edit.
+            text (Optional[str], optional): New text content for the message. Defaults to None.
+            inline (Optional[Keypad], optional): Inline keyboard to attach to the message. Defaults to None.
+            keypad (Optional[Keypad], optional): Chat keypad to attach to the message. Defaults to None.
+
+        Returns:
+            None
+
+        Example:
+            >>> message = await client.send_message(chat_id="b0X123", text="Hello!")
+            >>> await message.edit(text="Updated text")
+            >>> await message.edit(inline=my_inline_keypad)
+            >>> await message.edit(keypad=my_chat_keypad)
+        """
+        if text:
+            await self.edit_text(text)
+        if inline:
+            await self.edit_inline(inline)
+        if keypad:
+            await self.edit_keypad(keypad)
+
+    async def edit_text(self, text: str):
+        """Edit the text content of this message.
+
+        Args:
+            self (UMessage): The message instance to edit.
+            text (str): New text to replace the current message content.
+
+        Returns:
+            UMessage: The updated message object returned by the client.
+
+        Example:
+            >>> await message.edit_text("Updated text content")
+        """
+        return await self.client.edit_message_text(
+            self.chat_id,
+            self.message_id,
+            text
+        )
+
+    async def edit_inline(self, inline: Keypad):
+        """Edit the inline keyboard of this message.
+
+        Args:
+            self (UMessage): The message instance to edit.
+            inline (Keypad): New inline keyboard to attach to the message.
+
+        Returns:
+            UMessage: The updated message object returned by the client.
+
+        Example:
+            >>> await message.edit_inline(my_inline_keypad)
+        """
+        return await self.client.edit_message_keypad(
+            self.chat_id,
+            self.message_id,
+            inline
+        )
+
+    async def edit_keypad(self, keypad: Keypad):
+        """Edit the chat keypad for this message's chat.
+
+        Args:
+            self (UMessage): The message instance whose chat keypad will be edited.
+            keypad (Keypad): New chat keypad to attach.
+
+        Returns:
+            UMessage: The updated message object returned by the client.
+
+        Example:
+            >>> await message.edit_keypad(my_chat_keypad)
+        """
+        return await self.client.edit_chat_keypad(
+            self.chat_id,
+            keypad
+        )
+
+    async def forward(self, chat_id: str):
+        """Forward this message to another chat.
+
+        Args:
+            self (UMessage): The message instance to forward.
+            chat_id (str): ID of the chat to forward the message to.
+
+        Returns:
+            UMessage: The forwarded message object returned by the client.
+
+        Example:
+            >>> await message.forward("b0AnotherChat")
+        """
+        return await self.client.forward_message(
+            self.chat_id,
+            self.message_id,
+            chat_id
+        )

rubigram/types/object.py

@@ -0,0 +1,112 @@
+import sys
+from typing import Union, TypeVar, Type, get_origin, get_args, get_type_hints
+from dataclasses import dataclass, fields
+from json import dumps
+
+T = TypeVar("T", bound="Object")
+
+
+@dataclass
+class Object:
+
+    def asdict(self):
+        data = {}
+        for f in fields(self):
+            value = getattr(self, f.name)
+            if isinstance(value, Object):
+                inner = value.asdict()
+                data[f.name] = {"_": value.__class__.__name__, **inner}
+            elif isinstance(value, list):
+                data[f.name] = [
+                    {"_": v.__class__.__name__, **v.asdict()} if isinstance(v, Object) else v for v in value
+                ]
+            else:
+                data[f.name] = value
+        return data
+
+    def jsonify(self, exclude_none: bool = False) -> str:
+        def clear(obj):
+            if isinstance(obj, dict):
+                return {k: clear(v) for k, v in obj.items() if v is not None}
+            elif isinstance(obj, list):
+                return [clear(i) for i in obj if i is not None]
+            else:
+                return obj
+
+        data = self.asdict()
+        data.pop("client", None)
+        if exclude_none:
+            data = clear(data)
+        return dumps(
+            {"_": self.__class__.__name__, **data},
+            ensure_ascii=False,
+            indent=4
+        )
+
+    @classmethod
+    def parse(cls: Type[T], data: dict) -> T:
+        data = data or {}
+        init_data = {}
+
+        try:
+            module = sys.modules[cls.__module__]
+            type_hints = get_type_hints(
+                cls, globalns=module.__dict__, localns=None)
+        except Exception:
+            type_hints = {}
+
+        for field in fields(cls):
+            raw_value = data.get(field.name)
+            if isinstance(raw_value, dict) and "_" in raw_value:
+                raw_value = {k: v for k, v in raw_value.items() if k != "_"}
+
+            field_type = type_hints.get(field.name, field.type)
+            origin = get_origin(field_type)
+
+            if origin is Union:
+                args = get_args(field_type)
+                non_none_args = [arg for arg in args if arg is not type(None)]
+                if len(non_none_args) == 1:
+                    field_type = non_none_args[0]
+                    origin = get_origin(field_type)
+                else:
+                    pass
+
+            if isinstance(raw_value, dict) and isinstance(field_type, type) and issubclass(field_type, Object):
+                init_data[field.name] = field_type.parse(raw_value)
+
+            elif origin == list:
+                inner_type = get_args(field_type)[0]
+                inner_origin = get_origin(inner_type)
+                if inner_origin is Union:
+                    inner_args = [a for a in get_args(
+                        inner_type) if a is not type(None)]
+                    inner_type = inner_args[0] if inner_args else inner_type
+
+                if isinstance(raw_value, list):
+                    if isinstance(inner_type, type) and issubclass(inner_type, Object):
+                        init_data[field.name] = [
+                            inner_type.parse(v) if isinstance(v, dict) else v for v in raw_value
+                        ]
+                    else:
+                        init_data[field.name] = raw_value
+                else:
+                    init_data[field.name] = [
+                    ] if raw_value is None else raw_value
+
+            elif origin is Union:
+                args = get_args(field_type)
+                obj_arg = next((arg for arg in args if isinstance(
+                    arg, type) and issubclass(arg, Object)), None)
+                if obj_arg and isinstance(raw_value, dict):
+                    init_data[field.name] = obj_arg.parse(raw_value)
+                else:
+                    init_data[field.name] = raw_value
+
+            else:
+                init_data[field.name] = raw_value
+
+        return cls(**init_data)
+
+    def __str__(self):
+        return self.jsonify(True)

rubigram/types/types.py

@@ -0,0 +1,211 @@
+from typing import Optional, Union
+from dataclasses import dataclass, field
+from .. import enums
+from .object import Object
+
+
+@dataclass
+class Chat(Object):
+    chat_id: Optional[str] = None
+    chat_type: Optional[enums.ChatType] = None
+    user_id: Optional[str] = None
+    first_name: Optional[str] = None
+    last_name: Optional[str] = None
+    title: Optional[str] = None
+    username: Optional[str] = None
+
+
+@dataclass
+class File(Object):
+    file_id: Optional[str] = None
+    file_name: Optional[str] = None
+    size: Optional[int] = None
+
+
+@dataclass
+class ForwardedFrom(Object):
+    type_from: Optional[enums.ForwardedFrom] = None
+    message_id: Optional[str] = None
+    from_chat_id: Optional[str] = None
+    from_sender_id: Optional[str] = None
+
+
+@dataclass
+class PaymentStatus(Object):
+    payment_id: Optional[str] = None
+    status: Optional[Union[str, enums.PaymentStatus]] = None
+
+
+@dataclass
+class Bot(Object):
+    bot_id: Optional[str] = None
+    bot_title: Optional[str] = None
+    avatar: Optional[File] = None
+    description: Optional[str] = None
+    username: Optional[str] = None
+    start_message: Optional[str] = None
+    share_url: Optional[str] = None
+
+
+@dataclass
+class BotCommand(Object):
+    command: Optional[str] = None
+    description: Optional[str] = None
+
+
+@dataclass
+class Sticker(Object):
+    sticker_id: Optional[str] = None
+    file: Optional[File] = None
+    emoji_character: Optional[str] = None
+
+
+@dataclass
+class ContactMessage(Object):
+    phone_number: Optional[str] = None
+    first_name: Optional[str] = None
+    last_name: Optional[str] = None
+
+
+@dataclass
+class PollStatus(Object):
+    state: Optional[Union[str, enums.PollStatus]] = None
+    selection_index: Optional[int] = None
+    percent_vote_options: Optional[list[int]] = None
+    total_vote: Optional[int] = None
+    show_total_votes: Optional[bool] = None
+
+
+@dataclass
+class Poll(Object):
+    question: Optional[str] = None
+    options: Optional[list[str]] = None
+    poll_status: Optional[PollStatus] = None
+
+
+@dataclass
+class Location(Object):
+    longitude: Optional[str] = None
+    latitude: Optional[str] = None
+
+
+@dataclass
+class LiveLocation(Object):
+    start_time: Optional[str] = None
+    live_period: Optional[int] = None
+    current_location: Optional[Location] = None
+    user_id: Optional[str] = None
+    status: Optional[Union[str, enums.LiveLocationStatus]] = None
+    last_update_time: Optional[str] = None
+
+
+@dataclass
+class ButtonSelectionItem(Object):
+    text: Optional[str] = None
+    image_url: Optional[str] = None
+    type: Optional[Union[str, enums.ButtonSelectionType]] = None
+
+
+@dataclass
+class ButtonSelection(Object):
+    selection_id: Optional[str] = None
+    search_type: Optional[str] = None
+    get_type: Optional[str] = None
+    items: Optional[list[ButtonSelectionItem]] = None
+    is_multi_selection: Optional[bool] = None
+    columns_count: Optional[str] = None
+    title: Optional[str] = None
+
+
+@dataclass
+class ButtonCalendar(Object):
+    default_value: Optional[str] = None
+    type: Optional[Union[str, enums.ButtonCalendarType]] = None
+    min_year: Optional[str] = None
+    max_year: Optional[str] = None
+    title: Optional[str] = None
+
+
+@dataclass
+class ButtonNumberPicker(Object):
+    min_value: Optional[str] = None
+    max_value: Optional[str] = None
+    default_value: Optional[str] = None
+    title: Optional[str] = None
+
+
+@dataclass
+class ButtonStringPicker(Object):
+    items: Optional[list[str]] = None
+    default_value: Optional[str] = None
+    title: Optional[str] = None
+
+
+@dataclass
+class ButtonTextbox(Object):
+    type_line: Optional[Union[str, enums.ButtonTextboxTypeLine]] = None
+    type_keypad: Optional[Union[str, enums.ButtonTextboxTypeKeypad]] = None
+    place_holder: Optional[str] = None
+    title: Optional[str] = None
+    default_value: Optional[str] = None
+
+
+@dataclass
+class ButtonLocation(Object):
+    default_pointer_location: Optional[Location] = None
+    default_map_location: Optional[Location] = None
+    type: Optional[Union[str, enums.ButtonLocationType]] = None
+    title: Optional[str] = None
+    location_image_url: Optional[str] = None
+
+
+@dataclass
+class OpenChatData(Object):
+    Object_guid: Optional[str] = None
+    Object_type: Optional[Union[str, enums.ChatType]] = None
+
+
+@dataclass
+class JoinChannelData(Object):
+    username: Optional[str] = None
+    ask_join: bool = False
+
+
+@dataclass
+class ButtonLink(Object):
+    type: Optional[Union[str, enums.ButtonLinkType]] = None
+    link_url: Optional[str] = None
+    joinchannel_data: Optional[JoinChannelData] = None
+    open_chat_data: Optional[OpenChatData] = None
+
+
+@dataclass
+class AuxData(Object):
+    start_id: Optional[str] = None
+    button_id: Optional[str] = None
+
+
+@dataclass
+class Button(Object):
+    id: Optional[str] = None
+    button_text: Optional[str] = None
+    type: Optional[Union[str, enums.ButtonType]] = enums.ButtonType.Simple
+    button_selection: Optional[ButtonSelection] = None
+    button_calendar: Optional[ButtonCalendar] = None
+    button_number_picker: Optional[ButtonNumberPicker] = None
+    button_string_picker: Optional[ButtonStringPicker] = None
+    button_location: Optional[ButtonLocation] = None
+    button_textbox: Optional[ButtonTextbox] = None
+    button_link: Optional[ButtonLink] = None
+
+
+@dataclass
+class KeypadRow(Object):
+    buttons: list[Button] = field(default_factory=list)
+
+
+@dataclass
+class Keypad(Object):
+    rows: list[KeypadRow] = field(default_factory=list)
+    resize_keyboard: bool = True
+    on_time_keyboard: bool = False