RubigramClient 1.3.3__py3-none-any.whl → 1.3.5__py3-none-any.whl

rubigram/__init__.py

@@ -1,2 +1,4 @@
 from .client import Client
-from .filters import filter
+from .method import Method
+from .network import NetWork
+from . import filters

rubigram/client.py

@@ -1,317 +1,72 @@
-from rubigram.types import Update, MessageId, InlineMessage, Keypad, Chat, Bot
-from aiohttp import ClientSession, FormData, web
-from typing import Literal, Optional
-import aiofiles
+from rubigram.types import Update, InlineMessage
+from rubigram.method import Method
+from aiohttp import web
 
 
-class Client:
-    def __init__(self, token: str):
+class Client(Method):
+    def __init__(self, token: str, endpoint: str = None, host: str = "0.0.0.0", port: int = 5000):
         self.token = token
+        self.port = port
+        self.host = host
+        self.endpoint = endpoint
         self.messages_handler = []
-        self.api = f"https://botapi.rubika.ir/v3/{self.token}"
-    
-    async def request(self, method: str, data: dict):
-        async with ClientSession() as session:
-            async with session.post(f"{self.api}/{method}", json=data) as response:
-                response.raise_for_status()
-                return await response.json()
+        self.inlines_handler = []
+        self.routes = web.RouteTableDef()
+        self.api = f"https://botapi.rubika.ir/v3/{self.token}/"
+        super().__init__(token)
+
     
     def on_message(self, *filters):
         def decorator(func):
-            async def wrapped(client, update):
+            async def wrapper(client, update):
                 if all(f(update) for f in filters):
                     await func(client, update)
-            self.messages_handler.append(wrapped)
+            self.messages_handler.append(wrapper)
             return func
         return decorator
     
-    async def update(self, data: dict):
-        event = Update.read(data["update"], self) if data.get("update") else InlineMessage.read(data["inline_message"])
-        for handler in self.messages_handler:
-            await handler(self, event)
-           
-    
-    async def get_me(self) -> "Bot":
-        response = await self.request("getMe", {})
-        return Bot.read(response["data"]["bot"])
-    
-    
-    async def get_chat(self, chat_id: str) -> "Chat":
-        response = await self.request("getChat", {"chat_id": chat_id})
-        return Chat.read(response["data"]["chat"])
-
-    
-    async def get_updates(self, limit: int = 1, offset_id: str = None) -> list["Update"]:
-        response = await self.request("getUpdates", {"limit": limit, "offset_id": offset_id})
-        updates = [update for update in response["data"]["updates"]]
-        return [Update.read(update) for update in updates]
-    
-    
-    async def set_command(self, commands: list):
-        response = await self.request("setCommands", {"bot_commands": commands})
-        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 send_message(
-        self,
-        chat_id: str,
-        text: str,
-        chat_keypad : Optional[Keypad] = None,
-        inline_keypad: Optional[Keypad] = None,
-        chat_keypad_type: Literal["New", "Remove"] = None,
-        disable_notification: bool = None,
-        reply_to_message_id = None
-    ) -> "MessageId":
-        data = {
-            "chat_id": chat_id,
-            "text": text,
-            "chat_keypad": chat_keypad._dict() if chat_keypad else None,
-            "inline_keypad": inline_keypad._dict() if inline_keypad else None,
-            "chat_keypad_type": chat_keypad_type,
-            "disable_notification": disable_notification,
-            "reply_to_message_id": reply_to_message_id
-        }
-        response = await self.request("sendMessage", data)
-        return MessageId.read(response["data"])
-
-    
-    async def send_poll(
-        self,
-        chat_id: str,
-        question: str,
-        options: list[str],
-        chat_keypad: Keypad = None,
-        inline_keypad: Keypad = None,
-        disable_notification: bool = False,
-        reply_to_message_id: str = None,
-        chat_keypad_type: Literal[None, "New", "Remove"] = None
-    ) -> "MessageId":
-        data = {
-            "chat_id": chat_id,
-            "question": question,
-            "options": options,
-            "chat_keypad": chat_keypad,
-            "inline_keypad": inline_keypad,
-            "disable_notification": disable_notification,
-            "reply_to_message_id": reply_to_message_id,
-            "chat_keypad_type": chat_keypad_type
-        }
-        response = await self.request("sendPoll", data)
-        return MessageId.read(response["data"])
-    
-    
-    async def send_location(
-        self,
-        chat_id: str,
-        latitude: str,
-        longitude: str,
-        chat_keypad: Keypad = None,
-        inline_keypad: Keypad = None,
-        disable_notification: bool = False,
-        reply_to_message_id: str = None,
-        chat_keypad_type: Literal[None, "New", "Remove"] = None
-    ) -> "MessageId":
-        data = {
-            "chat_id": chat_id,
-            "latitude": latitude,
-            "longitude": longitude,
-            "chat_keypad": chat_keypad,
-            "inline_keypad": inline_keypad,
-            "disable_notification": disable_notification,
-            "reply_to_message_id": reply_to_message_id,
-            "chat_keypad_type": chat_keypad_type
-        }
-        response = await self.request("sendLocation", data)
-        return MessageId.read(response["data"])
-    
-    
-    async def send_contact(
-        self,
-        chat_id: str,
-        first_name: str,
-        last_name: str,
-        phone_number: str,
-        chat_keypad: Keypad = None,
-        inline_keypad: Keypad  = None,
-        disable_notification: bool = False,
-        reply_to_message_id: str = None,
-        chat_keypad_type: Literal[None, "New", "Remove"] = None
-    ) -> "MessageId":
-        data = {
-            "chat_id": chat_id,
-            "first_name": first_name,
-            "last_name": last_name,
-            "phone_number": phone_number,
-            "chat_keypad": chat_keypad,
-            "inline_keypad": inline_keypad,
-            "disable_notification": disable_notification,
-            "reply_to_message_id": reply_to_message_id,
-            "chat_keypad_type": chat_keypad_type
-        }
-        response = await self.request("sendContact", data)
-        return MessageId.read(response["data"])
-    
-    
-    async def send_sticker(
-        self,
-        chat_id: str,
-        sticker_id: str,
-        chat_keypad: Keypad = None,
-        inline_keypad: Keypad = None,
-        disable_notification: bool = False,
-        reply_to_message_id: str = None,
-        chat_keypad_type: Literal[None, "New", "Remove"] = None,
-    ) -> "MessageId":
-        data = {
-            "chat_id": chat_id,
-            "sticker_id": sticker_id,
-            "chat_keypad": chat_keypad,
-            "disable_notification": disable_notification,
-            "inline_keypad": inline_keypad,
-            "reply_to_message_id": reply_to_message_id,
-            "chat_keypad_type": chat_keypad_type
-        }
-        response = await self.request("sendSticker", data)
-        return MessageId.read(response["data"])
-    
-    
-    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.read(response["data"])
-    
-    
-    async def edit_message_text(
-        self,
-        chat_id: str,
-        message_id: str,
-        text: str
-    ) -> None:
-        data = {"chat_id": chat_id, "message_id": message_id, "text": text}
-        await self.request("editMessageText", data)
-    
-    
-    async def edit_message_keypad(
-        self,
-        chat_id: str,
-        message_id: str,
-        inline_keypad: Keypad
-        ) -> None:
-        data = {"chat_id": chat_id, "message_id": message_id, "inline_keypad": inline_keypad}
-        await self.request("editMessageKeypad", data)
-        
-        
-    async def edit_chat_keypad(
-        self,
-        chat_id: str,
-        chat_keypad: Keypad
-    ) -> None:
-        data = {"chat_id": chat_id, "chat_keypad_type": "New", "chat_keypad": chat_keypad}
-        await self.request("editChatKeypad", data)
-    
-    
-    async def remove_chat_keypad(
-        self,
-        chat_id: str
-    ) -> None:
-        data = {"chat_id": chat_id, "chat_keypad_type": "Remove"}
-        await self.request("editChatKeypad", data)
-        
-    
-    async def delete_message(
-        self,
-        chat_id: str,
-        message_id: str
-        ) -> None:
-        data = {"chat_id": chat_id, "message_id": message_id}
-        await self.request("deleteMessage", data)
-    
-    
-    async def get_file(self, file_id: str) -> str:
-        response = await self.request("getFile", {"file_id": file_id})
-        return response["data"]["download_url"]
-
-    
-    async def request_send_file(self, type: Literal["File", "Image", "Voice", "Music", "Gif", "Video"]) -> str:
-        response = await self.request("requestSendFile", {"type": type})
-        return response["data"]["upload_url"]
-
-    
-    async def upload_file(self, path: str, file_name: str, type: Literal["File", "Image", "Voice", "Music", "Gif", "Video"]) -> str:
-        upload_url = await self.request_send_file(type)
-        form = FormData()
-        form.add_field("file", open(path, "rb"), filename=file_name, content_type="application/octet-stream")
-        async with ClientSession() as session:
-            async with session.post(upload_url, data=form) as response:
-                result = await response.json()
-                return result["data"]["file_id"]
-    
+    def on_inline_message(self, *filters):
+        def decorator(func):
+            async def wrapper(client, update):
+                if all(f(update) for f in filters):
+                    await func(client, update)
+            self.inlines_handler.append(wrapper)
+            return func
+        return decorator
     
-    async def send_file(
-        self,
-        chat_id: str,
-        path: str,
-        file_name: str,
-        type: Literal["File", "Image", "Voice", "Music", "Gif", "Video"] = "File",
-        chat_keypad = None,
-        inline_keypad = None,
-        disable_notification: bool = False,
-        reply_to_message_id: str = None,
-        chat_keypad_type: Literal["New", "Remove"] = None,
-    ) -> str:
-        file_id = await self.upload_file(path, file_name, type)
-        data = {
-            "chat_id": chat_id,
-            "file_id": file_id,
-            "chat_keypad": chat_keypad,
-            "disable_notification": disable_notification,
-            "inline_keypad": inline_keypad,
-            "reply_to_message_id": reply_to_message_id,
-            "chat_keypad_type": chat_keypad_type,
-        }
-        response = await self.request("sendFile", data)
-        return MessageId.read(response["data"])
+    async def update(self, data: dict):
+        if "inline_message" in data:
+            event = InlineMessage.read(data["inline_message"])
+            for handler in self.inlines_handler:
+                await handler(self, event)
+        else:
+            event = Update.read(data["update"])
+            for handler in self.messages_handler:
+                await handler(self, event)
+    
+    async def set_endpoints(self):
+        await self.update_bot_endpoint(self.endpoint + "/ReceiveUpdate", "ReceiveUpdate")
+        await self.update_bot_endpoint(self.endpoint + "/ReceiveInlineMessage", "ReceiveInlineMessage")
 
-    
-    async def download_file(self, file_id: str, file_name: str):
-        download_url = await self.get_file(file_id)
-        async with ClientSession() as session:
-            async with session.get(download_url) as response:
-                if response.status == 200:
-                    async with aiofiles.open(file_name, "wb") as file:
-                        await file.write(await response.read())
-                    return {"status": "OK", "file": file_name}
-                raise Exception(f"Download Error | status_code : {response.status}")
-    
-    
     def run(self):
-        routes = web.RouteTableDef()
-        @routes.post("/receiveUpdate")
-        @routes.post("/receiveInlineMessage")
-        async def webhook(request):
+        @self.routes.post("/ReceiveUpdate")
+        async def receive_update(request):
+            data = await request.json()
+            await self.update(data)
+            return web.json_response({"status": "OK"})
+
+        @self.routes.post("/receiveInlineMessage")
+        async def receive_inline_message(request):
             data = await request.json()
             await self.update(data)
             return web.json_response({"status": "ok"})
+
         app = web.Application()
-        app.add_routes(routes)
-        web.run_app(app, host="0.0.0.0", port=8000)
+        app.add_routes(self.routes)
+
+        async def on_startup(app):
+            if self.endpoint:
+                await self.set_endpoints()
+
+        app.on_startup.append(on_startup)
+        web.run_app(app, host = self.host, port = self.port)

rubigram/filters.py

@@ -1,58 +1,53 @@
 from rubigram.types import Update, InlineMessage
 from typing import Union
 
+def command(commands: Union[str, list[str]], prefixe: str = "/"):
+    def filter(message: Update):
+        if isinstance(message, Update) and message.type == "NewMessage" and message.new_message.text:
+            text = message.new_message.text
+            COMMANDS = commands if isinstance(commands, list) else [commands]
+            for cmd in COMMANDS:
+                if text.lower().startswith(prefixe + cmd):
+                    return True
+        return False
+    return filter
 
-class filter:
-    @staticmethod
-    def command(command: Union[str, list[str]], prefixes: Union[str, list[str]] = "/"):
-        def inner(update: Update):
-            if isinstance(update, Update) and update.new_message and update.new_message.text:
-                message = update.new_message
-                commands = command if isinstance(command, list) else [command]
-                commands = [c.lower() for c in commands]
-                prefix_list = [] if prefixes is None else prefixes
-                prefix_list = prefix_list if isinstance(prefix_list, list) else [prefix_list]
-                for prefix in prefix_list:
-                    if message.text.startswith(prefix) and commands:
-                        return message.text[len(prefix):].split()[0].lower() in commands
-                    return False
-            return False
-        return inner
-    
-    @staticmethod
-    def text():
-        def inner(update: Update):
-            if isinstance(update, Update) and update.new_message:
-                return update.new_message.text is not None
-            return False
-        return inner
+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:
+                    return True
+        return False
+    return filter
 
-    @staticmethod
-    def private():
-        def inner(update: Update):
-            if isinstance(update, Update) and update.new_message:
-                return update.new_message.sender_type == "User"
-            return False
-        return inner
-    
-    @staticmethod
-    def chat(chat_id: str):
-        def inner(update: Update):
-            return getattr(update, "chat_id", None) == chat_id
-        return inner
-    
-    @staticmethod
-    def file():
-        def inner(update: Update):
-            if isinstance(update, Update) and update.new_message:
-                return update.new_message.file is not None
-            return False
-        return inner
-    
-    @staticmethod
-    def button(id: str):
-        def inner(update: InlineMessage):
-            if isinstance(update, InlineMessage):
-                return update.aux_data.button_id == id
-            return False
-        return inner
+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 text():
+    def filter(message: Update):
+        if isinstance(message, Update) and message.type == "NewMessage":
+            return bool(message.new_message.text)
+        return False
+    return filter
+
+def file():
+    def filter(message: Update):
+        if isinstance(message, Update) and message.type == "NewMessage":
+            return bool(message.new_message.file)
+        return False
+    return filter
+
+def private():
+    def filter(message: Update):
+        if isinstance(message, Update) and message.type == "NewMessage":
+            return message.new_message.sender_type in ["User", "Bot"]
+        return False
+    return filter

rubigram/method.py

@@ -0,0 +1,208 @@
+from rubigram.network import NetWork
+from typing import Literal, Optional
+from rubigram.types import Bot, Chat, Update, Keypad, MessageId
+
+class Method(NetWork):
+    def __init__(self, token: str):
+        super().__init__(token)
+        
+    async def get_me(self) -> "Bot":
+        response = await self.request("getMe", {})
+        return Bot.read(response["data"]["bot"])
+
+    async def get_chat(self, chat_id: str) -> "Chat":
+        response = await self.request("getChat", {"chat_id": chat_id})
+        return Chat.read(response["data"]["chat"])
+    
+    async def get_update(self, limit: int = 1, offset_id: Optional[int] = None) -> list[Update]:
+        response = await self.request("getUpdates", {"limit": limit, "offset_id": offset_id})
+        return [Update.read(update) for update in response["data"]["updates"]]
+    
+    async def get_file(self, file_id: str) -> str:
+        response = await self.request("getFile", {"file_id": file_id})
+        return response["data"]["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 request_send_file(self, type: str):
+        response = await self.request("requestSendFile", {"type": type})
+        return response["data"]["upload_url"]
+    
+    async def upload_file(self, path: str, name: str, type: str):
+        upload_url = await self.request_send_file(type)
+        response = await self.request_upload_file(upload_url, path, name)
+        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.read(response["data"])
+    
+    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 send_message(
+        self,
+        chat_id: str,
+        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":
+        data = {
+            "chat_id": chat_id,
+            "text": text,
+            "chat_keypad": chat_keypad._dict() if chat_keypad else None,
+            "inline_keypad": inline_keypad._dict() if inline_keypad else None,
+            "chat_keypad_type": chat_keypad_type,
+            "disable_notification": disable_notification,
+            "reply_to_message_id": reply_to_message_id
+        }
+        response = await self.request("sendMessage", data)
+        return MessageId.read(response["data"])
+    
+    async def send_poll(
+        self,
+        chat_id: str,
+        question: str,
+        options: list[str],
+        chat_keypad: Keypad = None,
+        inline_keypad: Keypad = None,
+        disable_notification: bool = False,
+        reply_to_message_id: str = None,
+        chat_keypad_type: Literal["New", "Remove"] = None
+    ) -> "MessageId":
+        data = {
+            "chat_id": chat_id,
+            "question": question,
+            "options": options,
+            "chat_keypad": chat_keypad._dict() if chat_keypad else None,
+            "inline_keypad": inline_keypad._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("sendPoll", data)
+        return MessageId.read(response["data"])
+    
+    async def send_location(
+        self,
+        chat_id: str,
+        latitude: str,
+        longitude: str,
+        chat_keypad: Keypad = None,
+        inline_keypad: Keypad = None,
+        disable_notification: bool = False,
+        reply_to_message_id: str = None,
+        chat_keypad_type: Literal["New", "Remove"] = None
+    ) -> "MessageId":
+        data = {
+            "chat_id": chat_id,
+            "latitude": latitude,
+            "longitude": longitude,
+            "chat_keypad": chat_keypad._dict() if chat_keypad else None,
+            "inline_keypad": inline_keypad._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("sendLocation", data)
+        return MessageId.read(response["data"])
+    
+    async def send_contact(
+        self,
+        chat_id: str,
+        first_name: str,
+        last_name: str,
+        phone_number: str,
+        chat_keypad: Keypad = None,
+        inline_keypad: Keypad = None,
+        disable_notification: bool = False,
+        reply_to_message_id: str = None,
+        chat_keypad_type: Literal["New", "Remove"] = None
+    ) -> "MessageId":
+        data = {
+            "chat_id": chat_id,
+            "first_name": first_name,
+            "last_name": last_name,
+            "phone_number": phone_number,
+            "chat_keypad": chat_keypad._dict() if chat_keypad else None,
+            "inline_keypad": inline_keypad._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("sendContact", data)
+        return MessageId.read(response["data"])
+    
+    async def send_sticker(
+        self,
+        chat_id: str,
+        sticker_id: str,
+        chat_keypad: Keypad = None,
+        inline_keypad: Keypad = None,
+        disable_notification: bool = False,
+        reply_to_message_id: str = None,
+        chat_keypad_type: Literal["New", "Remove"] = None,
+    ) -> "MessageId":
+        data = {
+            "chat_id": chat_id,
+            "sticker_id": sticker_id,
+            "chat_keypad": chat_keypad._dict() if chat_keypad else None,
+            "inline_keypad": inline_keypad._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("sendSticker", data)
+        return MessageId.read(response["data"])
+    
+    async def send_file(
+        self,
+        chat_id: str,
+        path: str,
+        file_name: str,
+        type: Literal["File", "Image", "Voice", "Music", "Gif", "Video"] = "File",
+        chat_keypad: Keypad = None,
+        inline_keypad: Keypad = None,
+        disable_notification: bool = False,
+        reply_to_message_id: str = None,
+        chat_keypad_type: Literal["New", "Remove"] = None,
+    ) -> "MessageId":
+        file_id = await self.upload_file(path, file_name, type)
+        data = {
+            "chat_id": chat_id,
+            "file_id": file_id,
+            "chat_keypad": chat_keypad._dict() if chat_keypad else None,
+            "inline_keypad": inline_keypad._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.read(response["data"])
+    
+    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

rubigram/network.py

@@ -0,0 +1,30 @@
+from aiohttp import ClientSession, FormData
+import aiofiles
+
+class NetWork:
+    def __init__(self, token: str):
+        self.token = token
+        self.api = f"https://botapi.rubika.ir/v3/{self.token}/"
+        
+    async def request(self, method: str, json: dict) -> dict:
+        async with ClientSession() as session:
+            async with session.post(self.api + method, json=json) as response:
+                response.raise_for_status()
+                return await response.json()
+            
+    async def request_upload_file(self, url: str, path: str, name: str) -> str:
+        form = FormData()
+        form.add_field("file", open(path, "rb"), filename=name, content_type="application/octet-stream")
+        async with ClientSession() as session:
+            async with session.post(url, data=form) as response:
+                response.raise_for_status()
+                result = await response.json()
+                return result["data"]["file_id"]
+            
+    async def request_download_file(self, url: str, name: str):
+        async with ClientSession() as session:
+            async with session.get(url) as response:
+                response.raise_for_status()
+                async with aiofiles.open(name, mode="wb") as file:
+                    await file.write(await response.read())
+                    return {"status": True, "file": name}

rubigram/types.py

@@ -3,7 +3,6 @@ from typing import Any, Dict, List, Literal, Optional
 import rubigram
 
 
-
 @dataclass
 class Location:
     longitude: Optional[str] = None
@@ -62,8 +61,8 @@ class ButtonLocation:
     
     def _dict(self) -> Dict:
         return {
-            "default_pointer_location": self.default_pointer_location._dict(),
-            "default_map_location": self.default_map_location._dict(),
+            "default_pointer_location": self.default_pointer_location._dict() if self.default_pointer_location else None,
+            "default_map_location": self.default_map_location._dict() if self.default_map_location else None,
             "type": self.type,
             "title": self.title,
             "location_image_url": self.location_image_url
@@ -200,6 +199,7 @@ class MessageId:
             message_id = data.get("message_id"),
             file_id = data.get("file_id")
         )
+        
 
 @dataclass
 class PollStatus:
@@ -270,14 +270,14 @@ class Poll:
 @dataclass
 class ContactMessage:
     phone_number: Optional[str] = None
-    first_name: Optional[File] = None
+    first_name: Optional[str] = None
     last_name: Optional[str] = None
     
     @classmethod
     def read(cls, data: dict[str, Any]) -> "ContactMessage":
         return cls(
             phone_number = data.get("phone_number"),
-            first_name = File.read(data.get("first_name")) if "first_name" in data else None,
+            first_name = data.get("first_name"),
             last_name = data.get("last_name")
         )
     
@@ -458,7 +458,7 @@ class Update:
             type = data["type"],
             chat_id = data["chat_id"],
             removed_message_id = data.get("removed_message_id"),
-            new_message = Message.read(data["new_message"]),
+            new_message = Message.read(data["new_message"]) if "new_message" in data else None,
             updated_message = Message.read(data["updated_message"]) if "updated_message" in data else None,
             updated_payment = PaymentStatus.read(data["updated_payment"]) if "updated_payment" in data else None
         )
@@ -467,4 +467,7 @@ class Update:
         return await self.client.send_message(self.chat_id, text, reply_to_message_id=self.new_message.message_id)
         
     async def reply_file(self, path: str, file_name: str, type: Literal["File", "Image", "Voice", "Music", "Gif", "Video"] = "File") -> "MessageId":
-        return await self.client.send_file(self.chat_id, path, file_name, type, reply_to_message_id=self.new_message.message_id)
+        return await self.client.send_file(self.chat_id, path, file_name, type, reply_to_message_id=self.new_message.message_id)
+    
+    async def download(self, file_name: str):
+        return await self.client.download_file(self.new_message.file.file_id, file_name)

{rubigramclient-1.3.3.dist-info → rubigramclient-1.3.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: RubigramClient
-Version: 1.3.3
+Version: 1.3.5
 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
@@ -9,7 +9,8 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: aiohttp>=3.8.0
+Requires-Dist: aiohttp
+Requires-Dist: aiofiles
 Dynamic: license-file
 
 # Rubigram
@@ -24,7 +25,7 @@ pip install RubigramClient
 from rubigram import Client, filters
 from rubigram.types import Update
 
-bot = Client("your_bot_token")
+bot = Client("your_bot_token", "you_endpoint_url")
 
 @bot.on_message(filters.command("start"))
 async def start_handler(client, message: Update):    

rubigramclient-1.3.5.dist-info/RECORD

@@ -0,0 +1,11 @@
+rubigram/__init__.py,sha256=4JZ6q8ukflz_izRmJNYcndcKZFCsyJdYoYVoAPwN5V0,107
+rubigram/client.py,sha256=F5yEanmYEh2WXMO_Jtwkl1vHa40K1rxHupwFNks7a7E,2635
+rubigram/filters.py,sha256=VU9Nd5ALWQAXafH1mXi19hm-E5H20JgTswTS4usK3ro,1955
+rubigram/method.py,sha256=nm2qfzkanpzDo3yusIXmjYgCYmLzV6nVOyaxPDDqqz4,9074
+rubigram/network.py,sha256=K7vvGikXStvUBqHX2gogy3hJ1eQjLAJ7kdwLbfFuZIg,1399
+rubigram/types.py,sha256=evelh8GGttOHFQjiwXOzwXYFwLXKJSHit60T0T-9VIE,17035
+rubigramclient-1.3.5.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rubigramclient-1.3.5.dist-info/METADATA,sha256=ZGaxld0O20t7CbavDp6AXPfPJYfib9haVLEuQnMWwBc,1022
+rubigramclient-1.3.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+rubigramclient-1.3.5.dist-info/top_level.txt,sha256=Mhg5HfkL6rLec5sI4ClGmwoqYUANAZUz8sVa1sT_cas,9
+rubigramclient-1.3.5.dist-info/RECORD,,

rubigramclient-1.3.3.dist-info/RECORD

@@ -1,9 +0,0 @@
-rubigram/__init__.py,sha256=K1WXGcBx9-1cLmImtnruqFk91nb_6XuhY_Ud0KS_IUk,55
-rubigram/client.py,sha256=bwt5209q4wcT9nUP67KLWryWF4TWmz1r1PR1lNuM1S8,11591
-rubigram/filters.py,sha256=nvROwHxBdjokWezfAZBjRgBdJdcOcjz0IuR3BShyiJw,2153
-rubigram/types.py,sha256=GIGvTGdDURuwJ3oHPvRR7B8oJ3V1f8MDaMAqjvOOO-0,16813
-rubigramclient-1.3.3.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rubigramclient-1.3.3.dist-info/METADATA,sha256=JAm-gGFFLj-ea9Br1sx8GhREUYLGx-JO7dBTSbsLxKA,984
-rubigramclient-1.3.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-rubigramclient-1.3.3.dist-info/top_level.txt,sha256=Mhg5HfkL6rLec5sI4ClGmwoqYUANAZUz8sVa1sT_cas,9
-rubigramclient-1.3.3.dist-info/RECORD,,