RubigramClient 1.4.1__py3-none-any.whl → 1.4.2__py3-none-any.whl

rubigram/__init__.py

@@ -1,5 +1,4 @@
 from .network import Network
 from .method import Method
 from .client import Client
-from . import filters
-from . import state
+from . import filters

rubigram/client.py

@@ -1,92 +1,146 @@
 from __future__ import annotations
-from typing import Callable, Awaitable, Optional
+from typing import Optional, Callable, Awaitable
 from aiohttp import web
 from functools import wraps
 from rubigram.types import Update, InlineMessage
 from rubigram.method import Method
+from rubigram.filters import Filter
+from datetime import datetime
 import asyncio
 import logging
 
 logger = logging.getLogger(__name__)
 
-
 class Client(Method):
-    def __init__(
-        self,
-        token: str,
-        endpoint: Optional[str] = None,
-        host: str = "0.0.0.0",
-        port: int = 8000
-    ):
+    def __init__(self, token: str, endpoint: Optional[str] = None, host: str = "0.0.0.0", port: int = 8000):
         self.token = token
-        self.port = port
-        self.host = host
         self.endpoint = endpoint
-        self.messages_handler: list[Callable[[Client, Update], Awaitable]] = []
-        self.inlines_handler: list[Callable[[Client, InlineMessage], Awaitable]] = []
+        self.host = host
+        self.port = port
+        self.offset_id = None
         self.routes = web.RouteTableDef()
+        self.message_handlers = []
+        self.inline_handlers = []
         super().__init__(token)
 
-    def on_message(self, *filters: Callable[[Update], bool]):
+    def on_message(self, *filters: Filter):
         def decorator(func: Callable[[Client, Update], Awaitable]):
             @wraps(func)
             async def wrapper(client: Client, update: Update):
                 try:
-                    if all(f(update) for f in filters):
+                    combined_filter = filters[0] if filters else None
+                    for filter in filters[1:]:
+                        combined_filter = combined_filter & filter
+                    
+                    if combined_filter is None or await combined_filter(update):
                         await func(client, update)
+                        return True
+                    return False
                 except Exception as e:
                     logger.exception(f"Error in message handler {func.__name__}: {e}")
-            self.messages_handler.append(wrapper)
+                    return False
+            self.message_handlers.append(wrapper)
             return func
         return decorator
 
-    def on_inline_message(self, *filters: Callable[[InlineMessage], bool]):
+
+    def on_inline_message(self, *filters: Filter):
         def decorator(func: Callable[[Client, InlineMessage], Awaitable]):
             @wraps(func)
             async def wrapper(client: Client, update: InlineMessage):
                 try:
-                    if all(f(update) for f in filters):
+                    combined_filter = filters[0] if filters else None
+                    for filter in filters[1:]:
+                        combined_filter = combined_filter & filter
+                    
+                    if combined_filter is None or await combined_filter(update):
                         await func(client, update)
+                        return True
+                    return False
                 except Exception as e:
                     logger.exception(f"Error in inline handler {func.__name__}: {e}")
-            self.inlines_handler.append(wrapper)
+                    return False
+            self.inline_handlers.append(wrapper)
             return func
         return decorator
 
-    async def handle_update(self, data: dict):
+
+    async def dispatch_update(self, update: Update):
+        for handler in self.message_handlers:
+            try:
+                matched = await handler(self, update)
+                if matched:
+                    return
+            except Exception as error:
+                logger.exception(f"Error in handler dispatch: {error}")
+
+    async def dispatch_inline(self, update: InlineMessage):
+        for handler in self.inline_handlers:
+            try:
+                matched = await handler(self, update)
+                if matched:
+                    return
+            except Exception as error:
+                logger.exception(f"Error in inline handler dispatch: {error}")
+
+    async def updater(self, data: dict):
         if "inline_message" in data:
             event = InlineMessage.from_dict(data["inline_message"])
-            await asyncio.gather(*(h(self, event) for h in self.inlines_handler))
+            await self.dispatch_inline(event)
         elif "update" in data:
             event = Update.from_dict(data["update"])
             event.client = self
-            await asyncio.gather(*(h(self, event) for h in self.messages_handler))
+            await self.dispatch_update(event)
             
-
     async def set_endpoints(self):
-        if not self.endpoint:
-            return
-        await self.update_bot_endpoint(f"{self.endpoint}/ReceiveUpdate", "ReceiveUpdate")
-        await self.update_bot_endpoint(f"{self.endpoint}/ReceiveInlineMessage", "ReceiveInlineMessage")
+        if self.endpoint:
+            await self.update_bot_endpoint(f"{self.endpoint}/ReceiveUpdate", "ReceiveUpdate")
+            await self.update_bot_endpoint(f"{self.endpoint}/ReceiveInlineMessage", "ReceiveInlineMessage")
 
     def run(self):
-        @self.routes.post("/ReceiveUpdate")
-        async def receive_update(request: web.Request):
-            data = await request.json()
-            await self.handle_update(data)
-            return web.json_response({"status": "OK"})
+        if self.endpoint:
+            @self.routes.post("/ReceiveUpdate")
+            async def receive_update(request: web.Request):
+                data = await request.json()
+                await self.updater(data)
+                return web.json_response({"status": "OK"})
 
-        @self.routes.post("/ReceiveInlineMessage")
-        async def receive_inline_message(request: web.Request):
-            data = await request.json()
-            await self.handle_update(data)
-            return web.json_response({"status": "OK"})
+            @self.routes.post("/ReceiveInlineMessage")
+            async def receive_inline_message(request: web.Request):
+                data = await request.json()
+                await self.updater(data)
+                return web.json_response({"status": "OK"})
+
+            app = web.Application()
+            app.add_routes(self.routes)
+            
+            async def on_startup(_):
+                await self.set_endpoints()
+            app.on_startup.append(on_startup)
+            web.run_app(app, host=self.host, port=self.port)
+            
+        else:
+            async def polling():
+                while True:
+                    try:
+                        get_update = await self.get_update(100, self.offset_id)
+                        if get_update.updates:
+                            updates = get_update.updates
+                            for update in updates:
+                                if update.type == "NewMessage":
+                                    message_time = int(update.new_message.time)
+                                elif update.type == "UpdatedMessage":
+                                    message_time = int(update.updated_message.time)
+                                else:
+                                    continue
 
-        app = web.Application()
-        app.add_routes(self.routes)
+                                now = int(datetime.now().timestamp())
+                                if message_time >= now or message_time + 2 >= now:
+                                    await self.dispatch_update(update)
 
-        async def on_startup(_):
-            await self.set_endpoints()
+                            self.offset_id = get_update.next_offset_id
+                    except Exception as e:
+                        logger.exception(f"Polling error: {e}")
+                        await asyncio.sleep(1)
 
-        app.on_startup.append(on_startup)
-        web.run_app(app, host=self.host, port=self.port)
+            asyncio.run(polling())

rubigram/filters.py

@@ -1,145 +1,165 @@
 from rubigram.types import Update, InlineMessage
-from rubigram.state import state_manager
-from typing import Union
+from typing import Union, Callable, Awaitable
 import re
 
 
-def state(states: Union[str, list[str]]):
-    def filter(message: Union[Update, InlineMessage]):
-        user_state = state_manager.get_state(message.chat_id)
-        return user_state in states if isinstance(states, list) else user_state == states
-    return filter
-
-def edited():
-    def filter(message: Update):
-        if isinstance(message, Update) and message.updated_message:
-            return message.updated_message.is_edited
-        return False
-    return filter
-
-def command(commands: Union[str, list[str]], prefix: str = "/"):
-    def filter(message: Update):
-        if isinstance(message, Update) and message.new_message and message.new_message.text:
-            text = message.new_message.text.strip()
-            cmds = commands if isinstance(commands, list) else [commands]
-            for cmd in cmds:
-                if text.lower().startswith(prefix + cmd.lower()):
-                    return True
-        return False
-    return filter
-
-def button(id: Union[str, list[str]]):
-    def filter(message: InlineMessage):
-        if isinstance(message, InlineMessage):
-            button_id = message.aux_data.button_id
-            ID = id if isinstance(id, list) else [id]
-            for i in ID:
-                if button_id == i:
+class Filter:
+    def __init__(self, func: Callable[[Union[Update, InlineMessage]], bool | Awaitable[bool]]):
+        self.func = func
+
+    async def __call__(self, update: Union[Update, InlineMessage]) -> bool:
+        result = self.func(update)
+        if isinstance(result, Awaitable):
+            return await result
+        return result
+
+    def __and__(self, other: "Filter"):
+        async def combined(update):
+            return await self(update) and await other(update)
+        return Filter(combined)
+
+    def __or__(self, other: "Filter"):
+        async def combined(update):
+            return await self(update) or await other(update)
+        return Filter(combined)
+
+
+class command(Filter):
+    def __init__(self, cmd: Union[str, list[str]], prefix: str = "/"):
+        self.cmd = cmd
+        self.prefix = prefix
+        super().__init__(self.filter)
+
+    def filter(self, update: Update):
+        commands = [self.cmd] if isinstance(self.cmd, str) else self.cmd
+        text = ""
+        if isinstance(update, Update):
+            if update.type == "NewMessage":
+                text = update.new_message.text
+            elif update.type == "UpdatedMessage":
+                text = update.updated_message.text
+
+            for cmd in commands:
+                if text.lower().startswith(self.prefix + cmd.lower()):
                     return True
-        return False
-    return filter
+            return False
 
-def chat(chat_id: Union[str, list[str]]):
-    def filter(message: Union[Update, InlineMessage]):
-        chat_ids = chat_id if isinstance(chat_id, list) else [chat_id]
-        if isinstance(message, Update) or isinstance(message, InlineMessage):
-            return message.chat_id in chat_ids
-        return False
-    return filter
-
-def regex(pattern: str):
-    def filter(message: Union[Update, InlineMessage]):
-        if isinstance(message, Update) and message.type == "NewMessage" and message.new_message.text:
-            return bool(re.search(pattern, message.new_message.text))
-        elif isinstance(message, InlineMessage) and message.text:
-            return bool(re.search(pattern, message.text))
-        return False
-    return filter
-            
-def text():
-    def filter(message: Update):
-        if isinstance(message, Update) and message.type == "NewMessage":
-            return message.new_message.text is None
-        return False
-    return filter
 
-def file():
-    def filter(message: Update):
-        if isinstance(message, Update) and message.type == "NewMessage":
-            return message.new_message.file is None
-        return False
-    return filter
+class regex(Filter):
+    def __init__(self, pattern: str):
+        self.pattern = pattern
+        super().__init__(self.filter)
 
-def private():
-    def filter(message: Update):
-        if isinstance(message, Update) and message.type == "NewMessage":
-            return message.new_message.sender_type in ["User", "Bot"]
+    def filter(self, update: Union[Update, InlineMessage]):
+        text = ""
+        if isinstance(update, Update):
+            if update.type == "NewMessage":
+                text = getattr(update.new_message, "text", "")
+            elif update.type == "UpdatedMessage":
+                text = getattr(update.updated_message, "text", "")
+        elif isinstance(update, InlineMessage):
+            text = getattr(update, "text", "")
+
+        if text:
+            return bool(re.search(self.pattern, text))
         return False
-    return filter
 
 
-def forward():
-    def filter(message: Update):
-        if isinstance(message, Update) and message.type == "NewMessage":
-            return message.new_message.forwarded_from is None
-        return False
-    return filter
+class chat(Filter):
+    def __init__(self, chat_id: Union[str, list[str]]):
+        self.chat_id = chat_id
+        super().__init__(self.filter)
 
-def forward_channel():
-    def filter(message: Update):
-        if isinstance(message, Update) and message.type == "NewMessage" and message.new_message.forwarded_from:
-            return message.new_message.forwarded_from.from_sender_id == "Channel"
-        return False
-    return filter
+    def filter(self, update: Union[Update, InlineMessage]):
+        chat_ids = [self.chat_id] if isinstance(
+            self.chat_id, str) else self.chat_id
+        return update.chat_id in chat_ids
 
 
-def forward_user():
-    def filter(message: Update):
-        if isinstance(message, Update) and message.type == "NewMessage" and message.new_message.forwarded_from:
-            return message.new_message.forwarded_from.from_sender_id == "User"
-        return False
-    return filter
+class button(Filter):
+    def __init__(self, button_id: Union[str, list[str]]):
+        self.button_id = button_id
+        super().__init__(self.filter)
 
+    def filter(self, update: InlineMessage):
+        if isinstance(update, InlineMessage):
+            button_ids = [self.button_id] if isinstance(
+                self.button_id, str) else self.button_id
+            return update.aux_data.button_id in button_ids
 
-def forward_bot():
-    def filter(message: Update):
-        if isinstance(message, Update) and message.type == "NewMessage" and message.new_message.forwarded_from:
-            return message.new_message.forwarded_from.from_sender_id == "Bot"
-        return False
-    return filter
 
 
-def location():
-    def filter(message: Update):
-        if isinstance(message, Update) and message.type == "NewMessage":
-            return message.new_message.location is None
-        return False
-    return filter
+def TEXT(update: Update):
+    return bool(update.new_message and getattr(update.new_message, "text", None))
 
-def sticker():
-    def filter(message: Update):
-        if isinstance(message, Update) and message.type == "NewMessage":
-            return message.new_message.sticker is None
-        return False
-    return filter
 
-def contact():
-    def filter(message: Update):
-        if isinstance(message, Update) and message.type == "NewMessage":
-            return message.new_message.contact_message is None
-        return False
-    return filter
+def FILE(update: Update):
+    return bool(update.new_message and getattr(update.new_message, "file", None))
 
-def poll():
-    def filter(message: Update):
-        if isinstance(message, Update) and message.type == "NewMessage":
-            return message.new_message.poll is None
-        return False
-    return filter
 
-def live():
-    def filter(message: Update):
-        if isinstance(message, Update) and message.type == "NewMessage":
-            return message.new_message.live_location is None
-        return False
-    return filter
+def LIVE(update: Update):
+    return bool(update.new_message and getattr(update.new_message, "live_location", None))
+
+
+def POLL(update: Update):
+    return bool(update.new_message and getattr(update.new_message, "poll", None))
+
+
+def CONTACT(update: Update):
+    return bool(update.new_message and getattr(update.new_message, "contact_message", None))
+
+
+def STICKER(update: Update):
+    return bool(update.new_message and getattr(update.new_message, "sticker", None))
+
+
+def LOCATION(update: Update):
+    return bool(update.new_message and getattr(update.new_message, "location", None))
+
+
+def FORWARD(update: Update):
+    return bool(update.new_message and getattr(update.new_message, "forwarded_from", None))
+
+
+def EDITED(update: Update):
+    if isinstance(update, Update) and update.type == "UpdatedMessage":
+        return update.updated_message.is_edited
+
+
+def PRIVATE(update: Update):
+    if isinstance(update, Update) and update.type == "NewMessage":
+        return update.new_message.sender_type in ["User", "Bot"]
+    return False
+
+
+def FORWARD_BOT(update: Update):
+    if isinstance(update, Update) and update.type == "NewMessage" and update.new_message.forwarded_from:
+        return update.new_message.forwarded_from.type_from == "Bot"
+    return False
+
+
+def FORWARD_USER(update: Update):
+    if isinstance(update, Update) and update.type == "NewMessage" and update.new_message.forwarded_from:
+        return update.new_message.forwarded_from.type_from == "User"
+    return False
+
+
+def FORWARD_CHANNEL(update: Update):
+    if isinstance(update, Update) and update.type == "NewMessage" and update.new_message.forwarded_from:
+        return update.new_message.forwarded_from.type_from == "Channel"
+    return False
+
+
+text = Filter(TEXT)
+file = Filter(FILE)
+live = Filter(LIVE)
+poll = Filter(POLL)
+edited = Filter(EDITED)
+contact = Filter(CONTACT)
+sticker = Filter(STICKER)
+location = Filter(LOCATION)
+forward = Filter(FORWARD)
+private = Filter(PRIVATE)
+forward_bot = Filter(FORWARD_BOT)
+forward_user = Filter(FORWARD_USER)
+forward_channel = Filter(FORWARD_CHANNEL)

rubigram/method.py

@@ -1,65 +1,66 @@
-from rubigram.network import Network
+from .network import Network
 from typing import Literal, Optional
-from rubigram.types import Bot, Chat, Update, Keypad, MessageId
+from .types import Bot, Chat, Keypad, MessageId, Updates
 
 
 class Method(Network):
     def __init__(self, token: str):
         super().__init__(token)
-        
+
     async def get_me(self) -> "Bot":
         response = await self.request("getMe", {})
         return Bot.from_dict(response["bot"])
-    
+
     async def get_chat(self, chat_id: str) -> "Chat":
         response = await self.request("getChat", {"chat_id": chat_id})
         return Chat.from_dict(response["chat"])
-    
-    async def get_update(self, limit: int = 1, offset_id: Optional[int] = None) -> list[Update]:
+
+    async def get_update(self, limit: int = 1, offset_id: Optional[int] = None) -> "Updates":
         response = await self.request("getUpdates", {"limit": limit, "offset_id": offset_id})
-        return [Update.from_dict(update) for update in response["updates"]]
-    
+        return Updates.from_dict(response)
+
     async def get_file(self, file_id: str) -> str:
         response = await self.request("getFile", {"file_id": file_id})
         return response["download_url"]
-    
+
     async def set_command(self, command: list):
         response = await self.request("setCommands", {"bot_commands": command})
         return response
-    
+
     async def update_bot_endpoint(self, url: str, type: Literal["ReceiveUpdate", "ReceiveInlineMessage", "ReceiveQuery", "GetSelectionItem", "SearchSelectionItems"]):
         response = await self.request("updateBotEndpoints", {"url": url, "type": type})
         return response
-    
-    async def forward_message(self, from_chat_id: str, message_id: str, to_chat_id: str, disable_notification: bool = False) -> "MessageId":
-        data = {"from_chat_id": from_chat_id, "message_id": message_id, "to_chat_id": to_chat_id, "disable_notification": disable_notification}
-        response = await self.request("forwardMessage", data)
-        return MessageId.from_dict(response)
-    
+
     async def delete_message(self, chat_id: str, message_id: str):
         await self.request("deleteMessage", {"chat_id": chat_id, "message_id": message_id})
-    
+
     async def remove_chat_keypad(self, chat_id: str):
         await self.request("editChatKeypad", {"chat_id": chat_id, "chat_keypad_type": "Remove"})
-        
+
     async def edit_chat_keypad(self, chat_id: str, chat_keypad):
         await self.request("editChatKeypad", {"chat_id": chat_id, "chat_keypad_type": "New", "chat_keypad": chat_keypad})
 
     async def edit_message_keypad(self, chat_id: str, message_id: str, inline_keypad):
         await self.request("editMessageKeypad", {"chat_id": chat_id, "message_id": message_id, "inline_keypad": inline_keypad})
-    
+
     async def edit_message_text(self, chat_id: str, message_id: str, text: str):
         await self.request("editMessageText", {"chat_id": chat_id, "message_id": message_id, "text": text})
-    
+
+    async def forward_message(self, from_chat_id: str, message_id: str, to_chat_id: str, disable_notification: bool = False) -> "MessageId":
+        data = {"from_chat_id": from_chat_id, "message_id": message_id,
+                "to_chat_id": to_chat_id, "disable_notification": disable_notification}
+        response = await self.request("forwardMessage", data)
+        return MessageId.from_dict(response)
+
     async def send_message(
         self,
         chat_id: str,
         text: str,
         chat_keypad: Keypad = None,
-        inline_keypad: Keypad= None,
+        inline_keypad: Keypad = None,
         chat_keypad_type: Literal["New", "Remove"] = None,
         disable_notification: bool = None,
-        reply_to_message_id = None
+        reply_to_message_id=None
     ) -> "MessageId":
         data = {
             "chat_id": chat_id,
@@ -72,7 +73,7 @@ class Method(Network):
         }
         response = await self.request("sendMessage", data)
         return MessageId.from_dict(response)
-    
+
     async def send_poll(
         self,
         chat_id: str,
@@ -96,7 +97,7 @@ class Method(Network):
         }
         response = await self.request("sendPoll", data)
         return MessageId.from_dict(response)
-    
+
     async def send_location(
         self,
         chat_id: str,
@@ -120,7 +121,7 @@ class Method(Network):
         }
         response = await self.request("sendLocation", data)
         return MessageId.from_dict(response)
-    
+
     async def send_contact(
         self,
         chat_id: str,
@@ -146,7 +147,7 @@ class Method(Network):
         }
         response = await self.request("sendContact", data)
         return MessageId.from_dict(response)
-    
+
     async def send_sticker(
         self,
         chat_id: str,
@@ -166,30 +167,31 @@ class Method(Network):
             "reply_to_message_id": reply_to_message_id,
             "chat_keypad_type": chat_keypad_type
         }
+
         response = await self.request("sendSticker", data)
         return MessageId.from_dict(response)
-    
+
     async def request_send_file(self, type: str):
         response = await self.request("requestSendFile", {"type": type})
         return response["upload_url"]
-    
+
     async def upload_file(self, file: str, name: str, type: str):
         upload_url = await self.request_send_file(type)
         response = await self.request_upload_file(upload_url, file, name)
         return response
-    
-    
+
     async def download_file(self, file_id: str, file_name: str):
         download_url = await self.get_file(file_id)
         response = await self.request_download_file(download_url, file_name)
         return response
-    
+
     async def send_file(
         self,
         chat_id: str,
         file: str,
         file_name: str,
-        type: Literal["File", "Image", "Voice", "Music", "Gif", "Video"] = "File",
+        type: Literal["File", "Image", "Voice",
+                      "Music", "Gif", "Video"] = "File",
         chat_keypad: Keypad = None,
         inline_keypad: Keypad = None,
         chat_keypad_type: Literal["New", "Remove"] = None,
@@ -208,148 +210,21 @@ class Method(Network):
         }
         response = await self.request("sendFile", data)
         return MessageId.from_dict(response)
-        
-        
-    async def send_document(
-        self,
-        chat_id: str,
-        document: str,
-        name: str,
-        chat_keypad: Keypad = None,
-        inline_keypad: Keypad = None,
-        chat_keypad_type: Literal["New", "Remove"] = None,
-        disable_notification: bool = False,
-        reply_to_message_id: str = None,
-    ) -> "MessageId":
-        file_id = await self.upload_file(document, name, "File")
-        data = {
-            "chat_id": chat_id,
-            "file_id": file_id,
-            "chat_keypad": chat_keypad.to_dict() if chat_keypad else None,
-            "inline_keypad": inline_keypad.to_dict() if inline_keypad else None,
-            "disable_notification": disable_notification,
-            "reply_to_message_id": reply_to_message_id,
-            "chat_keypad_type": chat_keypad_type,
-        }
-        response = await self.request("sendFile", data)
-        return MessageId.from_dict(response)
-    
-    async def send_photo(
-        self,
-        chat_id: str,
-        photo: str,
-        name: str,
-        chat_keypad: Keypad = None,
-        inline_keypad: Keypad = None,
-        chat_keypad_type: Literal["New", "Remove"] = None,
-        disable_notification: bool = False,
-        reply_to_message_id: str = None,
-    ) -> "MessageId":
-        file_id = await self.upload_file(photo, name, "Image")
-        data = {
-            "chat_id": chat_id,
-            "file_id": file_id,
-            "chat_keypad": chat_keypad.to_dict() if chat_keypad else None,
-            "inline_keypad": inline_keypad.to_dict() if inline_keypad else None,
-            "disable_notification": disable_notification,
-            "reply_to_message_id": reply_to_message_id,
-            "chat_keypad_type": chat_keypad_type,
-        }
-        response = await self.request("sendFile", data)
-        return MessageId.from_dict(response)
-    
-    async def send_video(
-        self,
-        chat_id: str,
-        video: str,
-        name: str,
-        chat_keypad: Keypad = None,
-        inline_keypad: Keypad = None,
-        chat_keypad_type: Literal["New", "Remove"] = None,
-        disable_notification: bool = False,
-        reply_to_message_id: str = None,
-    ) -> "MessageId":
-        file_id = await self.upload_file(video, name, "Video")
-        data = {
-            "chat_id": chat_id,
-            "file_id": file_id,
-            "chat_keypad": chat_keypad.to_dict() if chat_keypad else None,
-            "inline_keypad": inline_keypad.to_dict() if inline_keypad else None,
-            "disable_notification": disable_notification,
-            "reply_to_message_id": reply_to_message_id,
-            "chat_keypad_type": chat_keypad_type,
-        }
-        response = await self.request("sendFile", data)
-        return MessageId.from_dict(response)
-    
-    async def send_gif(
-        self,
-        chat_id: str,
-        gif: str,
-        name: str,
-        chat_keypad: Keypad = None,
-        inline_keypad: Keypad = None,
-        chat_keypad_type: Literal["New", "Remove"] = None,
-        disable_notification: bool = False,
-        reply_to_message_id: str = None,
-    ) -> "MessageId":
-        file_id = await self.upload_file(gif, name, "Gif")
-        data = {
-            "chat_id": chat_id,
-            "file_id": file_id,
-            "chat_keypad": chat_keypad.to_dict() if chat_keypad else None,
-            "inline_keypad": inline_keypad.to_dict() if inline_keypad else None,
-            "disable_notification": disable_notification,
-            "reply_to_message_id": reply_to_message_id,
-            "chat_keypad_type": chat_keypad_type,
-        }
-        response = await self.request("sendFile", data)
-        return MessageId.from_dict(response)
-    
-    async def send_music(
-        self,
-        chat_id: str,
-        music: str,
-        name: str,
-        chat_keypad: Keypad = None,
-        inline_keypad: Keypad = None,
-        chat_keypad_type: Literal["New", "Remove"] = None,
-        disable_notification: bool = False,
-        reply_to_message_id: str = None,
-    ) -> "MessageId":
-        file_id = await self.upload_file(music, name, "Music")
-        data = {
-            "chat_id": chat_id,
-            "file_id": file_id,
-            "chat_keypad": chat_keypad.to_dict() if chat_keypad else None,
-            "inline_keypad": inline_keypad.to_dict() if inline_keypad else None,
-            "disable_notification": disable_notification,
-            "reply_to_message_id": reply_to_message_id,
-            "chat_keypad_type": chat_keypad_type,
-        }
-        response = await self.request("sendFile", data)
-        return MessageId.from_dict(response)
-    
-    async def send_voice(
-        self,
-        chat_id: str,
-        voice: str,
-        name: str,
-        chat_keypad: Keypad = None,
-        inline_keypad: Keypad = None,
-        chat_keypad_type: Literal["New", "Remove"] = None,
-        disable_notification: bool = False,
-        reply_to_message_id: str = None,
-    ) -> "MessageId":
-        file_id = await self.upload_file(voice, name, "Voice")
-        data = {
-            "chat_id": chat_id,
-            "file_id": file_id,
-            "chat_keypad": chat_keypad.to_dict() if chat_keypad else None,
-            "inline_keypad": inline_keypad.to_dict() if inline_keypad else None,
-            "disable_notification": disable_notification,
-            "reply_to_message_id": reply_to_message_id,
-            "chat_keypad_type": chat_keypad_type,
-        }
-        response = await self.request("sendFile", data)
-        return MessageId.from_dict(response)
+
+    async def send_document(self, chat_id: str, document: str, name: str, **kwargs):
+        return await self.send_file(chat_id, document, name, "File", **kwargs)
+
+    async def send_photo(self, chat_id: str, photo: str, name: str, **kwargs):
+        return await self.send_file(chat_id, photo, name, "Image", **kwargs)
+
+    async def send_video(self, chat_id: str, video: str, name: str, **kwargs):
+        return await self.send_file(chat_id, video, name, "Video", **kwargs)
+
+    async def send_gif(self, chat_id: str, gif: str, name: str, **kwargs):
+        return await self.send_file(chat_id, gif, name, "Gif", **kwargs)
+
+    async def send_music(self, chat_id: str, music: str, name: str, **kwargs):
+        return await self.send_file(chat_id, music, name, "Music", **kwargs)
+
+    async def send_voice(self, chat_id: str, voice: str, name: str, **kwargs):
+        return await self.send_file(chat_id, voice, name, "Voice", **kwargs)

rubigram/types.py

@@ -5,6 +5,7 @@ import rubigram
 
 T = TypeVar("T", bound="Dict")
 
+
 @dataclass
 class Dict:
     def to_dict(self) -> dict[str, Any]:
@@ -14,7 +15,8 @@ class Dict:
             if is_dataclass(value):
                 data[field.name] = value.to_dict()
             elif isinstance(value, list):
-                data[field.name] = [i.to_dict() if is_dataclass(i) else i for i in value]
+                data[field.name] = [i.to_dict() if is_dataclass(i)
+                                    else i for i in value]
             else:
                 data[field.name] = value
         return data
@@ -22,7 +24,7 @@ class Dict:
     @classmethod
     def from_dict(cls: Type[T], data: dict[str, Any]) -> Optional[T]:
         if data is None:
-           return cls()
+            data = {}
         init_data = {}
         for field in fields(cls):
             value = data.get(field.name)
@@ -33,12 +35,14 @@ class Dict:
             elif origin == list:
                 inner_type = get_args(field_type)[0]
                 if isinstance(inner_type, type) and issubclass(inner_type, Dict):
-                    init_data[field.name] = [inner_type.from_dict(v) if isinstance(v, dict) else v for v in (value or [])]
+                    init_data[field.name] = [inner_type.from_dict(
+                        v) if isinstance(v, dict) else v for v in (value or [])]
                 else:
                     init_data[field.name] = value or []
             elif get_origin(field_type) is Union:
                 args = get_args(field_type)
-                dict_type = next((a for a in args if isinstance(a, type) and issubclass(a, Dict)), None)
+                dict_type = next((a for a in args if isinstance(
+                    a, type) and issubclass(a, Dict)), None)
                 if dict_type and isinstance(value, dict):
                     init_data[field.name] = dict_type.from_dict(value)
                 else:
@@ -65,6 +69,7 @@ class JoinChannelData(Dict):
     username: Optional[str] = None
     ask_join: Optional[bool] = False
 
+
 @dataclass
 class ButtonLink(Dict):
     type: Optional[Literal["joinchannel", "url"]] = None
@@ -292,172 +297,63 @@ class MessageId(Dict):
 @dataclass
 class Update(Dict):
     client: Optional["rubigram.Client"] = None
-    type: Optional[Literal["NewMessage", "UpdatedMessage", "RemovedMessage", "StartedBot", "StoppedBot", "UpdatedPayment"]] = None
+    type: Optional[Literal["NewMessage", "UpdatedMessage", "RemovedMessage",
+                           "StartedBot", "StoppedBot", "UpdatedPayment"]] = None
     chat_id: Optional[str] = None
     removed_message_id: Optional[str] = None
     new_message: Optional[Message] = None
     updated_message: Optional[Message] = None
     updated_payment: Optional[PaymentStatus] = None
+
+    async def send_text(self, text: str,) -> "MessageId":
+        return await self.client.send_message(self.chat_id, text)
     
-    async def send_text(
-        self,
-        text: str,
-        chat_keypad: Keypad = None,
-        inline_keypad: Keypad= None,
-        chat_keypad_type: Literal["New", "Remove"] = None,
-        disable_notification: bool = None,
-        reply_to_message_id = None
-    ) -> "MessageId":
-        return await self.client.send_message(self.chat_id, text, chat_keypad, inline_keypad, chat_keypad_type, disable_notification, reply_to_message_id)
-    
+    async def download(self, name: str):
+        return await self.client.download_file(self.new_message.file.file_id, name)
+
     async def reply(
         self,
         text: str,
         chat_keypad: Keypad = None,
-        inline_keypad: Keypad= None,
+        inline_keypad: Keypad = None,
         chat_keypad_type: Literal["New", "Remove"] = None,
         disable_notification: bool = None,
     ) -> "MessageId":
         return await self.client.send_message(self.chat_id, text, chat_keypad, inline_keypad, chat_keypad_type, disable_notification, self.new_message.message_id)
-    
+
     async def reply_file(
         self,
         file: str,
         file_name: str,
-        type: Literal["File", "Image", "Voice", "Music", "Gif", "Video"] = "File",
-        chat_keypad: Keypad = None,
-        inline_keypad: Keypad = None,
-        chat_keypad_type: Literal["New", "Remove"] = None,
-        disable_notification: bool = False,
-    ) -> "MessageId":
-        return await self.client.send_file(
-            self.chat_id,
-            file,
-            file_name,
-            type,
-            chat_keypad,
-            inline_keypad,
-            chat_keypad_type,
-            disable_notification,
-            self.new_message.message_id
-        )
-        
-    async def reply_document(
-        self,
-        document: str,
-        name: str,
+        type: Literal["File", "Image", "Voice",
+                      "Music", "Gif", "Video"] = "File",
         chat_keypad: Keypad = None,
         inline_keypad: Keypad = None,
         chat_keypad_type: Literal["New", "Remove"] = None,
         disable_notification: bool = False,
     ) -> "MessageId":
-        return await self.client.send_document(
-            self.chat_id,
-            document,
-            name,
-            chat_keypad,
-            inline_keypad,
-            chat_keypad_type,
-            disable_notification,
-            self.new_message.message_id
-        )
-        
-    async def reply_photo(
-        self,
-        photo: str,
-        name: str,
-        chat_keypad: Keypad = None,
-        inline_keypad: Keypad = None,
-        chat_keypad_type: Literal["New", "Remove"] = None,
-        disable_notification: bool = False,
-    ) -> "MessageId":
-        return await self.client.send_photo(
-            self.chat_id,
-            photo,
-            name,
-            chat_keypad,
-            inline_keypad,
-            chat_keypad_type,
-            disable_notification,
-            self.new_message.message_id
-        )
-        
-    async def reply_video(
-        self,
-        video: str,
-        name: str,
-        chat_keypad: Keypad = None,
-        inline_keypad: Keypad = None,
-        chat_keypad_type: Literal["New", "Remove"] = None,
-        disable_notification: bool = False,
-    ) -> "MessageId":
-        return await self.client.send_video(
-            self.chat_id,
-            video,
-            name,
-            chat_keypad,
-            inline_keypad,
-            chat_keypad_type,
-            disable_notification,
-            self.new_message.message_id
-        )
-        
-    async def reply_gif(
-        self,
-        gif: str,
-        name: str,
-        chat_keypad: Keypad = None,
-        inline_keypad: Keypad = None,
-        chat_keypad_type: Literal["New", "Remove"] = None,
-        disable_notification: bool = False,
-    ) -> "MessageId":
-        return await self.client.send_gif(
-            self.chat_id,
-            gif,
-            name,
-            chat_keypad,
-            inline_keypad,
-            chat_keypad_type,
-            disable_notification,
-            self.new_message.message_id
-        )
-        
-    async def reply_music(
-        self,
-        music: str,
-        name: str,
-        chat_keypad: Keypad = None,
-        inline_keypad: Keypad = None,
-        chat_keypad_type: Literal["New", "Remove"] = None,
-        disable_notification: bool = False,
-    ) -> "MessageId":
-        return await self.client.send_music(
-            self.chat_id,
-            music,
-            name,
-            chat_keypad,
-            inline_keypad,
-            chat_keypad_type,
-            disable_notification,
-            self.new_message.message_id
-        )
-        
-    async def replyvoice(
-        self,
-        voice: str,
-        name: str,
-        chat_keypad: Keypad = None,
-        inline_keypad: Keypad = None,
-        chat_keypad_type: Literal["New", "Remove"] = None,
-        disable_notification: bool = False,
-    ) -> "MessageId":
-        return await self.client.send_voice(
-            self.chat_id,
-            voice,
-            name,
-            chat_keypad,
-            inline_keypad,
-            chat_keypad_type,
-            disable_notification,
-            self.new_message.message_id
-        )
+        return await self.client.send_file(self.chat_id, file, file_name, type, chat_keypad, inline_keypad, chat_keypad_type, disable_notification, self.new_message.message_id)
+
+    async def reply_document(self, document: str, name: str, **kwargs) -> "MessageId":
+        return await self.reply_file(document, name, "File", **kwargs)
+
+    async def reply_photo(self, photo: str, name: str, **kwargs) -> "MessageId":
+        return await self.reply_file(photo, name, "Image", **kwargs)
+
+    async def reply_video(self, video: str, name: str, **kwargs) -> "MessageId":
+        return await self.reply_file(video, name, "Video", **kwargs)
+
+    async def reply_gif(self, gif: str, name: str, **kwargs) -> "MessageId":
+        return await self.reply_file(gif, name, "Gif", **kwargs)
+
+    async def reply_music(self, music: str, name: str, **kwargs) -> "MessageId":
+        return await self.reply_file(music, name, "Music", **kwargs)
+
+    async def reply_voice(self, voice: str, name: str, **kwargs) -> "MessageId":
+        return await self.reply_file(voice, name, "Voice", **kwargs)
+
+
+@dataclass
+class Updates(Dict):
+    updates: list[Update] = None
+    next_offset_id: Optional[str] = None

{rubigramclient-1.4.1.dist-info → rubigramclient-1.4.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: RubigramClient
-Version: 1.4.1
+Version: 1.4.2
 Summary: A simple and flexible Python library for building advanced Rubika bots with powerful message handling, inline buttons, and custom filters.
 Author-email: Javad RZ <Javad.Py1385@gmail.com>
 Classifier: Programming Language :: Python :: 3

rubigramclient-1.4.2.dist-info/RECORD

@@ -0,0 +1,11 @@
+rubigram/__init__.py,sha256=Z0foTm6Hpy4CDEH5am-IFWifi0bo4jLvpkfj3JQQHPc,107
+rubigram/client.py,sha256=GqTECi0_rVHV5ZPF-GSL577bT5EEG6RWJqYg8BC1chY,6083
+rubigram/filters.py,sha256=Zp9V81cHp41Qg4NcupZeZCaGfg3e8UUlHx2B8Xbdv7s,5386
+rubigram/method.py,sha256=OnV4O3jLvA453qFxv8dLjX7Vd-XL5goZFnuM-BrjWZM,9920
+rubigram/network.py,sha256=B5y_n7CC7wdMkzNqKpUG9cC7Cq86R0QJCwcScExluvM,2299
+rubigram/types.py,sha256=_D1raWerXaMhHo0M7i6oFoZOc_RsnlQUXLWlfhnoSDY,11719
+rubigramclient-1.4.2.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rubigramclient-1.4.2.dist-info/METADATA,sha256=lFRnrGhVnO43XBnHi4Za7AQWzipj71yQVR43U_4JzCg,2035
+rubigramclient-1.4.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+rubigramclient-1.4.2.dist-info/top_level.txt,sha256=Mhg5HfkL6rLec5sI4ClGmwoqYUANAZUz8sVa1sT_cas,9
+rubigramclient-1.4.2.dist-info/RECORD,,

rubigram/state.py

@@ -1,30 +0,0 @@
-from typing import Any, Union, Optional
-
-class StateManager:
-    def __init__(self):
-        self.states: dict[str, Any] = {}
-        self.datas: dict[str, dict[str, Any]] = {}
-
-    def set_state(self, user_id: str, state: Any):
-        self.states[user_id] = state
-    
-    def get_state(self, user_id: str):
-        return self.states.get(user_id)
-    
-    def clear_state(self, user_id: str):
-        self.states.pop(user_id, None)
-    
-    def set_data(self, user_id: str, **data):
-        if user_id not in self.datas:
-            self.datas[user_id] = {}
-        self.datas[user_id].update(data)
-        
-    def get_data(self, user_id: str, key: Optional[Union[str, int]] = None):
-        if key is not None:
-            return self.datas.get(user_id, {}).get(key)
-        return self.datas.get(user_id)
-    
-    def clear_data(self, user_id: str):
-        self.datas.pop(user_id, None)
-
-state_manager = StateManager()

rubigramclient-1.4.1.dist-info/RECORD

@@ -1,12 +0,0 @@
-rubigram/__init__.py,sha256=WotLkwsGnUkQC6XhJRtI_QNtUfOboG5k4VVcqwp_zFI,128
-rubigram/client.py,sha256=3bug_ezjMmhrPt3CmjOwEELbpFzNsRvXZZPQE7SJf0w,3557
-rubigram/filters.py,sha256=lB75_08wCz3iQqiV4QXm-dUomf2QqRG7q3b1PL5JDUQ,5174
-rubigram/method.py,sha256=AcvVyx1H0ADHHu6mfb4UW2auSVkeq9VWLE584RIXn1w,14748
-rubigram/network.py,sha256=B5y_n7CC7wdMkzNqKpUG9cC7Cq86R0QJCwcScExluvM,2299
-rubigram/state.py,sha256=jz9vNZyoxnMJM4juHeFZGc-AEa5npPWLSmp6_wBFfOY,954
-rubigram/types.py,sha256=KOoexWaeaElShNM4Pov6JJD9It704YJ_7-ZiSYNcIrE,14373
-rubigramclient-1.4.1.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rubigramclient-1.4.1.dist-info/METADATA,sha256=OsGqyYJg6pExZ9U9eGAntYMFmociYN25LFqF8qORD3Q,2035
-rubigramclient-1.4.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-rubigramclient-1.4.1.dist-info/top_level.txt,sha256=Mhg5HfkL6rLec5sI4ClGmwoqYUANAZUz8sVa1sT_cas,9
-rubigramclient-1.4.1.dist-info/RECORD,,