RubigramClient 1.6.6__py3-none-any.whl → 1.6.7__py3-none-any.whl

rubigram/client.py

@@ -1,15 +1,22 @@
-from typing import Optional, Callable, Literal, Union
+from typing import Optional, Callable, Union
 from rubigram.types import Update, InlineMessage
 from rubigram.method import Method
 from rubigram.filters import Filter
 from rubigram.state import StateManager
 from datetime import datetime
-from aiohttp import web
+from aiohttp.web import Application, Request, json_response, run_app
 import asyncio
 import logging
 
 
-logging.basicConfig(format=("%(levelname)s | %(message)s"))
+logging.basicConfig(
+    format="%(asctime)s | %(levelname)s : %(message)s",
+    datefmt="%Y-%m-%d %H:%M:%S",
+    level=logging.DEBUG
+)
+
+logging.getLogger("asyncio").setLevel(logging.WARNING)
+logging.getLogger("aiohttp").setLevel(logging.WARNING)
 
 
 class Client(Method):
@@ -25,106 +32,129 @@ class Client(Method):
         self.host = host
         self.port = port
         self.offset_id = None
+        self.set_endpoint = True
         self.ROUTES = []
         self.MESSAGE_HANDLER = []
         self.INLINE_HANDLER = []
         self.state = StateManager()
-        super().__init__(token)     
-            
-
-    def create_handler(self, type: Literal["message", "inline"], filters: Optional[Filter] = None):
+        super().__init__(token)
+        
+    
+    def on_message(self, filters: Optional[Filter] = None):
         def decorator(func: Callable) -> Callable:
             async def wrapper(client: Client, update: Update):
                 if filters is None or await filters(update):
                     await func(client, update)
                     return True
                 return False
-            self.MESSAGE_HANDLER.append(wrapper) if type == "message" else self.INLINE_HANDLER.append(wrapper)
+            self.MESSAGE_HANDLER.append(wrapper)
             return func
         return decorator
-    
-    def on_message(self, filters: Optional[Filter] = None):
-        return self.create_handler("message", filters)
 
     def on_inline_message(self, filters: Optional[Filter] = None):
-        return self.create_handler("inline", filters)
-        
-    async def dispatch(self, update: Union[Update, InlineMessage], type: Literal["message", "inline"]):
-        handlers = self.MESSAGE_HANDLER if type == "message" else self.INLINE_HANDLER
+        def decorator(func: Callable) -> Callable:
+            async def wrapper(client: Client, update: Update):
+                if filters is None or await filters(update):
+                    await func(client, update)
+                    return True
+                return False
+            self.INLINE_HANDLER.append(wrapper)
+            return func
+        return decorator
+
+    def on_create_app(self, path: str, method: str = "GET"):
+        def decorator(func):
+            self.ROUTES.append((path, func, method.upper()))
+            return func
+        return decorator
+    
+    async def dispatch(self, update: Union[Update, InlineMessage]):
+        handlers = self.MESSAGE_HANDLER if isinstance(update, Update) else self.INLINE_HANDLER
         for handler in handlers:
             matched = await handler(self, update)
             if matched:
                 return
-
+            
     async def updater(self, data: dict):
         if "inline_message" in data:
             event = InlineMessage.from_dict(data["inline_message"])
-            type = "inline"
         elif "update" in data:
             event = Update.from_dict(data["update"])
-            type = "message"
         else: return
         event.client = self
-        await self.dispatch(event, type)
-    
+        await self.dispatch(event)
+        
     async def set_endpoints(self):
         endpoint_type = ["ReceiveUpdate", "ReceiveInlineMessage"]
-        for i in endpoint_type: await self.update_bot_endpoint(f"{self.endpoint}/{i}", i)
-    
+        for i in endpoint_type:
+            set_endpoint = await self.update_bot_endpoint(f"{self.endpoint}/{i}", i)
+            logging.info(f"status set endpoint for {i} : {set_endpoint["status"]}")
+        
     async def on_startup(self, app):
-        await self.set_endpoints()
+        if self.set_endpoint:
+            await self.set_endpoints()
         await self.start()
 
     async def on_cleanup(self, app):
         await self.stop()
         
     def create_request_handler(self):
-        async def wrapper(request: web.Request):
+        async def wrapper(request: Request):
             data = await request.json()
             await self.updater(data)
-            return web.json_response({"status": "OK"})
+            return json_response({"status": "OK"})
         return wrapper
-    
-    async def runner(self):
+
+
+    async def update_runner(self):
         try:
             while True:
-                get_updates = await self.get_update(100, self.offset_id)
-                if get_updates.updates:
-                    updates = get_updates.updates
+                get_update = await self.get_update(100, self.offset_id)
+                updates = get_update.updates
+                if updates:
                     for update in updates:
-                        time = int(update.new_message.time) if update.type == "NewMessage" else int(update.updated_message.time) if update.type == "UpdatedMessage" else None
+                        time = update.new_message.time if update.type == "NewMessage" else update.updated_message.time if update.type == "UpdatedMessage" else None
+                        time = int(time)
                         now = int(datetime.now().timestamp())
-                        if time and time >= now or time + 2 >= now:
+                        if time and (time >= now or time + 2 >= now):
                             update.client = self
-                            await self.dispatch(update, "message")
-                    self.offset_id = get_updates.next_offset_id
+                            await self.dispatch(update)
+                    self.offset_id = get_update.next_offset_id
         except Exception as error:
             logging.error(error)
         finally:
             await self.stop()
     
-    def create_app(self, path: str, method: str = "Get"):
-        def decorator(func):
-            self.ROUTES.append((path, func, method))
-            return func
-        return decorator
-            
-    def run(self):
+    def run(self, set_endpoint = True):
+        self.set_endpoint = set_endpoint
         if self.endpoint:
-            app = web.Application()
+            app = Application()
             app.on_startup(self.on_startup)
             app.on_cleanup(self.on_cleanup)
-            for path, func, method in self.ROUTES:
-                if method.upper() == "GET":
-                    app.router.add_get(path, func)
-                elif method.upper() == "POST":
-                    app.router.add_post(path, func)
+            
             app.router.add_post("/ReceiveUpdate", self.create_request_handler())
             app.router.add_post("/ReceiveInlineMessage", self.create_request_handler())
-            web.run_app(app, host=self.host, port=self.port)
+            
+            for path, func, method in self.ROUTES:
+                match method:
+                    case "GET":
+                        app.router.add_get(path, func)
+                    case "POST":
+                        app.router.add_post(path, func)
+                    case "DELETE":
+                        app.router.add_delete(path, func)
+                    case "PUT":
+                        app.router.add_put(path, func)
+                    case "PATCH":
+                        app.router.add_patch(path, func)
+                        
+            run_app(app, host=self.host, port=self.port)
+
         else:
             try:
-                asyncio.run(self.runner())
-            except KeyboardInterrupt:pass
+                logging.info("Start Bot")
+                asyncio.run(self.update_runner())
+            except KeyboardInterrupt:
+                logging.info("Stop Bot")
             except Exception as error:
                 logging.error(error)

rubigram/method.py

@@ -1,6 +1,6 @@
 from .network import Network
 from rubigram import enums
-from typing import Optional
+from typing import Optional, Union
 from rubigram.types import Bot, Chat, Keypad, MessageId, Updates, BotCommand
 
 
@@ -195,30 +195,31 @@ class Method(Network):
         response = await self.request("requestSendFile", {"type": type})
         return response["upload_url"]
 
-    async def upload_file(self, file: str, name: str, type: str):
+    async def upload_file(self, file: Union[str, bytes], name: Optional[str] = None, type: str = "File"):
         upload_url = await self.request_send_file(type)
-        response = await self.RequestUploadFile(upload_url, file, name)
+        response = await self.requestUpload(upload_url, file, name)
         return response
 
-    async def download_file(self, file_id: str, file_name: str):
+    async def download_file(self, file_id: str, filename: Optional[str] = None):
         download_url = await self.get_file(file_id)
-        response = await self.RequestDownloadFile(download_url, file_name)
+        response = await self.requestDownload(download_url, filename)
         return response
 
     async def send_file(
         self,
         chat_id: str,
-        file: str,
-        file_name: str,
-        caption: str = None,
+        file: Union[str, bytes],
+        caption: Optional[str] = None,
+        file_name: Optional[str] = None,
         type: enums.FileType = enums.FileType.File,
         chat_keypad: Keypad = None,
         inline_keypad: Keypad = None,
         chat_keypad_type: Optional[enums.ChatKeypadType] = None,
         disable_notification: bool = False,
-        reply_to_message_id: str = None,
+        reply_to_message_id: Optional[str] = None,
     ) -> "MessageId":
         file_id = await self.upload_file(file, file_name, type)
+        
         data = {
             "chat_id": chat_id,
             "file_id": file_id,
@@ -236,20 +237,22 @@ class Method(Network):
         message.client = self
         return message
 
-    async def send_document(self, chat_id: str, document: str, name: str, caption: str = None, **kwargs):
-        return await self.send_file(chat_id, document, name, caption, "File", **kwargs)
 
-    async def send_photo(self, chat_id: str, photo: str, name: str, caption: str = None, **kwargs):
-        return await self.send_file(chat_id, photo, name, caption, "Image", **kwargs)
 
-    async def send_video(self, chat_id: str, video: str, name: str, caption: str = None, **kwargs):
-        return await self.send_file(chat_id, video, name, caption, "Video", **kwargs)
+    async def send_document(self, chat_id: str, document: Union[str, bytes], caption: Optional[str] = None, file_name: Optional[str] = None, **kwargs):
+        return await self.send_file(chat_id, document, caption, file_name, "File", **kwargs)
+
+    async def send_photo(self, chat_id: str, photo: Union[str, bytes], caption: Optional[str] = None, file_name: Optional[str] = None, **kwargs):
+        return await self.send_file(chat_id, photo, caption, file_name, "Image", **kwargs)
+
+    async def send_video(self, chat_id: str, video: Union[str, bytes], caption: Optional[str] = None, file_name: Optional[str] = None, **kwargs):
+        return await self.send_file(chat_id, video, caption, file_name, "Video", **kwargs)
 
-    async def send_gif(self, chat_id: str, gif: str, name: str, caption: str = None, **kwargs):
-        return await self.send_file(chat_id, gif, name, caption, "Gif", **kwargs)
+    async def send_gif(self, chat_id: str, gif: Union[str, bytes], caption: Optional[str] = None, file_name: Optional[str] = None, **kwargs):
+        return await self.send_file(chat_id, gif, caption, file_name, "Gif", **kwargs)
 
-    async def send_music(self, chat_id: str, music: str, name: str, caption: str = None, **kwargs):
-        return await self.send_file(chat_id, music, name, caption, "Music", **kwargs)
+    async def send_music(self, chat_id: str, music: Union[str, bytes], caption: Optional[str] = None, file_name: Optional[str] = None, **kwargs):
+        return await self.send_file(chat_id, music, caption, file_name, "Music", **kwargs)
 
-    async def send_voice(self, chat_id: str, voice: str, name: str, caption: str = None, **kwargs):
-        return await self.send_file(chat_id, voice, name, caption, "Voice", **kwargs)
+    async def send_voice(self, chat_id: str, voice: Union[str, bytes], caption: Optional[str] = None, file_name: Optional[str] = None, **kwargs):
+        return await self.send_file(chat_id, voice, caption, file_name, "Voice", **kwargs)

rubigram/network.py

@@ -1,6 +1,9 @@
 from aiohttp import ClientSession, FormData
-from typing import Any, Optional
-import aiofiles, re, os
+from typing import Any, Optional, Union
+from pathlib import Path
+from urllib.parse import urlparse
+import aiofiles
+import os
 
 
 class Network:
@@ -32,34 +35,46 @@ class Network:
             data: dict = await response.json()
             return data.get("data")
 
-    async def ContentFile(self, url: str) -> bytes:
+    async def getBytes(self, url: str) -> bytes:
         await self.start()
         async with self.session.get(url) as response:
             response.raise_for_status()
             return await response.read()
 
-    async def RequestUploadFile(self, upload_url: str, file: str, name: str):
+    async def getName(self, url: str) -> str:
+        parser = urlparse(url)
+        return os.path.basename(parser.path)
+
+    async def requestUpload(self, upload_url: str, file: Union[str, bytes], name: Optional[str] = None):
+        data, filename = None, None
         if isinstance(file, str):
-            if re.match(r"^https://", file):
-                file = await self.ContentFile(file)
-            elif os.path.isfile(file):
-                async with aiofiles.open(file, "rb") as f:
-                    file = await f.read()
-            else:
-                raise Exception("file not found : {}".format(file))
+            path = Path(file)
+
+            if path.is_file():
+                data, filename = path.read_bytes(), name if name else path.name
 
-            form = FormData()
-            form.add_field("file", file, filename=name, content_type="application/octet-stream")
-            await self.start()
-            async with self.session.post(upload_url, data=form) as response:
-                response.raise_for_status()
-                data: dict = await response.json()
-                return data.get("data", {}).get("file_id")
+            elif file.startswith("http"):
+                data, filename = await self.getBytes(file), name if name else await self.getName(file)
+
+            else:
+                raise Exception(f"Can't find this file : {file}")
 
-        raise Exception("Format Of file is invalid")
+        elif isinstance(file, bytes):
+            if name:
+                data, filename = file, name
+            else:
+                raise Exception("choice name for bytes file")
+        
+        form = FormData()
+        form.add_field("file", data, filename=filename, content_type="application/octet-stream")
+        await self.start()
+        async with self.session.post(upload_url, data=form) as response:
+            response.raise_for_status()
+            data: dict = await response.json()
+            return data.get("data", {})["file_id"]
 
-    async def RequestDownloadFile(self, url: str, name: str):
-        file = await self.ContentFile(url)
+    async def requestDownload(self, url: str, filename: Optional[str] = None):
+        file, name = await self.getBytes(url), filename if filename else await self.getName(url)
         async with aiofiles.open(name, "wb") as f:
             await f.write(file)
-        return name
+            return name

rubigram/types.py

@@ -1,4 +1,4 @@
-from typing import Optional, Any
+from typing import Optional, Union, Any
 from pydantic import BaseModel
 from rubigram import enums
 
@@ -28,12 +28,48 @@ class Chat(DataManager):
     title: Optional[str] = None
     username: Optional[str] = None
 
+    def __init__(
+        self,
+        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,
+        **kwargs
+    ):
+        super().__init__(
+            chat_id=chat_id,
+            chat_type=chat_type,
+            user_id=user_id,
+            first_name=first_name,
+            last_name=last_name,
+            title=title,
+            username=username,
+            **kwargs
+        )
+
 
 class File(DataManager):
     file_id: Optional[str] = None
     file_name: Optional[str] = None
     size: Optional[str] = None
 
+    def __init__(
+        self,
+        file_id: Optional[str] = None,
+        file_name: Optional[str] = None,
+        size: Optional[str] = None,
+        **kwargs
+    ):
+        super().__init__(
+            file_id=file_id,
+            file_name=file_name,
+            size=size,
+            **kwargs
+        )
+
 
 class ForwardedFrom(DataManager):
     type_from: Optional[enums.ForwardedFrom] = None
@@ -41,16 +77,56 @@ class ForwardedFrom(DataManager):
     from_chat_id: Optional[str] = None
     from_sender_id: Optional[str] = None
 
+    def __init__(
+        self,
+        type_from: Optional[enums.ForwardedFrom] = None,
+        message_id: Optional[str] = None,
+        from_chat_id: Optional[str] = None,
+        from_sender_id: Optional[str] = None,
+        **kwargs
+    ):
+        super().__init__(
+            type_from=type_from,
+            message_id=message_id,
+            from_chat_id=from_chat_id,
+            from_sender_id=from_sender_id,
+            **kwargs
+        )
+
 
 class PaymentStatus(DataManager):
     payment_id: Optional[str] = None
     status: Optional[enums.PaymentStatus] = None
 
+    def __init__(
+        self,
+        payment_id: Optional[str] = None,
+        status: Optional[enums.PaymentStatus] = None,
+        **kwargs
+    ):
+        super().__init__(
+            payment_id=payment_id,
+            status=status,
+            **kwargs
+        )
+
 
 class MessageTextUpdate(DataManager):
     message_id: Optional[str] = None
     text: Optional[str] = None
 
+    def __init__(
+        self,
+        message_id: Optional[str] = None,
+        text: Optional[str] = None,
+        **kwargs
+    ):
+        super().__init__(
+            message_id=message_id,
+            text=text,
+            **kwargs
+        )
+
 
 class Bot(DataManager):
     bot_id: Optional[str] = None
@@ -61,23 +137,85 @@ class Bot(DataManager):
     start_message: Optional[str] = None
     share_url: Optional[str] = None
 
+    def __init__(
+        self,
+        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,
+        **kwargs
+    ):
+        super().__init__(
+            bot_id=bot_id,
+            bot_title=bot_title,
+            avatar=avatar,
+            description=description,
+            username=username,
+            start_message=start_message,
+            share_url=share_url,
+            **kwargs
+        )
+
 
 class BotCommand(DataManager):
     command: Optional[str] = None
     description: Optional[str] = None
 
+    def __init__(
+        self,
+        command: Optional[str] = None,
+        description: Optional[str] = None,
+        **kwargs
+    ):
+        super().__init__(
+            command=command,
+            description=description,
+            **kwargs
+        )
+
 
 class Sticker(DataManager):
     sticker_id: Optional[str] = None
     file: Optional[File] = None
     emoji_character: Optional[str] = None
 
+    def __init__(
+        self,
+        sticker_id: Optional[str] = None,
+        file: Optional[File] = None,
+        emoji_character: Optional[str] = None,
+        **kwargs
+    ):
+        super().__init__(
+            sticker_id=sticker_id,
+            file=file,
+            emoji_character=emoji_character,
+            **kwargs
+        )
+
 
 class ContactMessage(DataManager):
     phone_number: Optional[str] = None
     first_name: Optional[str] = None
     last_name: Optional[str] = None
 
+    def __init__(
+        self,
+        phone_number: Optional[str] = None,
+        first_name: Optional[str] = None,
+        last_name: Optional[str] = None,
+        **kwargs
+    ):
+        super().__init__(
+            phone_number=phone_number,
+            first_name=first_name,
+            last_name=last_name,
+            **kwargs
+        )
+
 
 class PollStatus(DataManager):
     state: Optional[enums.PollStatus] = None
@@ -86,17 +224,61 @@ class PollStatus(DataManager):
     total_vote: Optional[int] = None
     show_total_votes: Optional[bool] = None
 
+    def __init__(
+        self,
+        state: Optional[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,
+        **kwargs
+    ):
+        super().__init__(
+            state=state,
+            selection_index=selection_index,
+            percent_vote_options=percent_vote_options,
+            total_vote=total_vote,
+            show_total_votes=show_total_votes,
+            **kwargs
+        )
+
 
 class Poll(DataManager):
     question: Optional[str] = None
     options: Optional[list[str]] = None
     poll_status: Optional[PollStatus] = None
 
+    def __init__(
+        self,
+        question: Optional[str] = None,
+        options: Optional[list[str]] = None,
+        poll_status: Optional[PollStatus] = None,
+        **kwargs
+    ):
+        super().__init__(
+            question=question,
+            options=options,
+            poll_status=poll_status,
+            **kwargs
+        )
+
 
 class Location(DataManager):
     longitude: Optional[str] = None
     latitude: Optional[str] = None
 
+    def __init__(
+        self,
+        longitude: Optional[str] = None,
+        latitude: Optional[str] = None,
+        **kwargs
+    ):
+        super().__init__(
+            longitude=longitude,
+            latitude=latitude,
+            **kwargs
+        )
+
 
 class LiveLocation(DataManager):
     start_time: Optional[str] = None
@@ -106,12 +288,46 @@ class LiveLocation(DataManager):
     status: Optional[enums.LiveLocationStatus] = None
     last_update_time: Optional[str] = None
 
+    def __init__(
+        self,
+        start_time: Optional[str] = None,
+        live_period: Optional[int] = None,
+        current_location: Optional[Location] = None,
+        user_id: Optional[str] = None,
+        status: Optional[enums.LiveLocationStatus] = None,
+        last_update_time: Optional[str] = None,
+        **kwargs
+    ):
+        super().__init__(
+            start_time=start_time,
+            live_period=live_period,
+            current_location=current_location,
+            user_id=user_id,
+            status=status,
+            last_update_time=last_update_time,
+            **kwargs
+        )
+
 
 class ButtonSelectionItem(DataManager):
     text: Optional[str] = None
     image_url: Optional[str] = None
     type: Optional[enums.ButtonSelectionType] = None
 
+    def __init__(
+        self,
+        text: Optional[str] = None,
+        image_url: Optional[str] = None,
+        type: Optional[enums.ButtonSelectionType] = None,
+        **kwargs
+    ):
+        super().__init__(
+            text=text,
+            image_url=image_url,
+            type=type,
+            **kwargs
+        )
+
 
 class ButtonSelection(DataManager):
     selection_id: Optional[str] = None
@@ -122,6 +338,28 @@ class ButtonSelection(DataManager):
     columns_count: Optional[str] = None
     title: Optional[str] = None
 
+    def __init__(
+        self,
+        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,
+        **kwargs
+    ):
+        super().__init__(
+            selection_id=selection_id,
+            search_type=search_type,
+            get_type=get_type,
+            items=items,
+            is_multi_selection=is_multi_selection,
+            columns_count=columns_count,
+            title=title,
+            **kwargs
+        )
+
 
 class ButtonCalendar(DataManager):
     default_value: Optional[str] = None
@@ -130,6 +368,24 @@ class ButtonCalendar(DataManager):
     max_year: Optional[str] = None
     title: Optional[str] = None
 
+    def __init__(
+        self,
+        default_value: Optional[str] = None,
+        type: Optional[enums.ButtonCalendarType] = None,
+        min_year: Optional[str] = None,
+        max_year: Optional[str] = None,
+        title: Optional[str] = None,
+        **kwargs
+    ):
+        super().__init__(
+            default_value=default_value,
+            type=type,
+            min_year=min_year,
+            max_year=max_year,
+            title=title,
+            **kwargs
+        )
+
 
 class ButtonNumberPicker(DataManager):
     min_value: Optional[str] = None
@@ -137,12 +393,42 @@ class ButtonNumberPicker(DataManager):
     default_value: Optional[str] = None
     title: Optional[str] = None
 
+    def __init__(
+        self,
+        min_value: Optional[str] = None,
+        max_value: Optional[str] = None,
+        default_value: Optional[str] = None,
+        title: Optional[str] = None,
+        **kwargs
+    ):
+        super().__init__(
+            min_value=min_value,
+            max_value=max_value,
+            default_value=default_value,
+            title=title,
+            **kwargs
+        )
+
 
 class ButtonStringPicker(DataManager):
     items: Optional[list[str]] = None
     default_value: Optional[str] = None
     title: Optional[str] = None
 
+    def __init__(
+        self,
+        items: Optional[list[str]] = None,
+        default_value: Optional[str] = None,
+        title: Optional[str] = None,
+        **kwargs
+    ):
+        super().__init__(
+            items=items,
+            default_value=default_value,
+            title=title,
+            **kwargs
+        )
+
 
 class ButtonTextbox(DataManager):
     type_line: Optional[enums.ButtonTextboxTypeLine] = None
@@ -151,6 +437,24 @@ class ButtonTextbox(DataManager):
     title: Optional[str] = None
     default_value: Optional[str] = None
 
+    def __init__(
+        self,
+        type_line: Optional[enums.ButtonTextboxTypeLine] = None,
+        type_keypad: Optional[enums.ButtonTextboxTypeKeypad] = None,
+        place_holder: Optional[str] = None,
+        title: Optional[str] = None,
+        default_value: Optional[str] = None,
+        **kwargs
+    ):
+        super().__init__(
+            type_line=type_line,
+            type_keypad=type_keypad,
+            place_holder=place_holder,
+            title=title,
+            default_value=default_value,
+            **kwargs
+        )
+
 
 class ButtonLocation(DataManager):
     default_pointer_location: Optional[Location] = None
@@ -159,16 +463,58 @@ class ButtonLocation(DataManager):
     title: Optional[str] = None
     location_image_url: Optional[str] = None
 
+    def __init__(
+        self,
+        default_pointer_location: Optional[Location] = None,
+        default_map_location: Optional[Location] = None,
+        type: Optional[enums.ButtonLocationType] = None,
+        title: Optional[str] = None,
+        location_image_url: Optional[str] = None,
+        **kwargs
+    ):
+        super().__init__(
+            default_pointer_location=default_pointer_location,
+            default_map_location=default_map_location,
+            type=type,
+            title=title,
+            location_image_url=location_image_url,
+            **kwargs
+        )
+
 
 class OpenChatData(DataManager):
     object_guid: Optional[str] = None
     object_type: Optional[enums.ChatType] = None
 
+    def __init__(
+        self,
+        object_guid: Optional[str] = None,
+        object_type: Optional[enums.ChatType] = None,
+        **kwargs
+    ):
+        super().__init__(
+            object_guid=object_guid,
+            object_type=object_type,
+            **kwargs
+        )
+
 
 class JoinChannelData(DataManager):
     username: Optional[str] = None
     ask_join: bool = False
 
+    def __init__(
+        self,
+        username: Optional[str] = None,
+        ask_join: bool = False,
+        **kwargs
+    ):
+        super().__init__(
+            username=username,
+            ask_join=ask_join,
+            **kwargs
+        )
+
 
 class ButtonLink(DataManager):
     type: Optional[enums.ButtonLinkType] = None
@@ -176,11 +522,39 @@ class ButtonLink(DataManager):
     joinchannel_data: Optional[JoinChannelData] = None
     open_chat_data: Optional[OpenChatData] = None
 
+    def __init__(
+        self,
+        type: Optional[enums.ButtonLinkType] = None,
+        link_url: Optional[str] = None,
+        joinchannel_data: Optional[JoinChannelData] = None,
+        open_chat_data: Optional[OpenChatData] = None,
+        **kwargs
+    ):
+        super().__init__(
+            type=type,
+            link_url=link_url,
+            joinchannel_data=joinchannel_data,
+            open_chat_data=open_chat_data,
+            **kwargs
+        )
+
 
 class AuxData(DataManager):
     start_id: Optional[str] = None
     button_id: Optional[str] = None
 
+    def __init__(
+        self,
+        start_id: Optional[str] = None,
+        button_id: Optional[str] = None,
+        **kwargs
+    ):
+        super().__init__(
+            start_id=start_id,
+            button_id=button_id,
+            **kwargs
+        )
+
 
 class Button(DataManager):
     id: Optional[str] = None
@@ -194,21 +568,85 @@ class Button(DataManager):
     button_textbox: Optional[ButtonTextbox] = None
     button_link: Optional[ButtonLink] = None
 
+    def __init__(
+        self,
+        id: Optional[str] = None,
+        button_text: Optional[str] = None,
+        type: 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,
+        **kwargs
+    ):
+        super().__init__(
+            id=id,
+            button_text=button_text,
+            type=type,
+            button_selection=button_selection,
+            button_calendar=button_calendar,
+            button_number_picker=button_number_picker,
+            button_string_picker=button_string_picker,
+            button_location=button_location,
+            button_textbox=button_textbox,
+            button_link=button_link,
+            **kwargs
+        )
+
 
 class KeypadRow(DataManager):
     buttons: list[Button]
 
+    def __init__(
+        self,
+        buttons: list[Button],
+        **kwargs
+    ):
+        super().__init__(
+            buttons=buttons,
+            **kwargs
+        )
+
 
 class Keypad(DataManager):
     rows: list[KeypadRow]
     resize_keyboard: bool = True
     on_time_keyboard: bool = False
 
+    def __init__(
+        self,
+        rows: list[KeypadRow],
+        resize_keyboard: bool = True,
+        on_time_keyboard: bool = False,
+        **kwargs
+    ):
+        super().__init__(
+            rows=rows,
+            resize_keyboard=resize_keyboard,
+            on_time_keyboard=on_time_keyboard,
+            **kwargs
+        )
+
 
 class MessageKeypadUpdate(DataManager):
     message_id: Optional[str] = None
     inline_keypad: Optional[Keypad] = None
 
+    def __init__(
+        self,
+        message_id: Optional[str] = None,
+        inline_keypad: Optional[Keypad] = None,
+        **kwargs
+    ):
+        super().__init__(
+            message_id=message_id,
+            inline_keypad=inline_keypad,
+            **kwargs
+        )
+
 
 class Message(DataManager):
     message_id: Optional[str] = None
@@ -228,6 +666,46 @@ class Message(DataManager):
     poll: Optional[Poll] = None
     live_location: Optional[LiveLocation] = None
 
+    def __init__(
+        self,
+        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,
+        **kwargs
+    ):
+        super().__init__(
+            message_id=message_id,
+            text=text,
+            time=time,
+            is_edited=is_edited,
+            sender_type=sender_type,
+            sender_id=sender_id,
+            aux_data=aux_data,
+            file=file,
+            reply_to_message_id=reply_to_message_id,
+            forwarded_from=forwarded_from,
+            forwarded_no_link=forwarded_no_link,
+            location=location,
+            sticker=sticker,
+            contact_message=contact_message,
+            poll=poll,
+            live_location=live_location,
+            **kwargs
+        )
+
 
 class MessageId(DataManager):
     message_id: Optional[str] = None
@@ -235,6 +713,22 @@ class MessageId(DataManager):
     chat_id: Optional[str] = None
     client: Optional[Any] = None
 
+    def __init__(
+        self,
+        message_id: Optional[str] = None,
+        file_id: Optional[str] = None,
+        chat_id: Optional[str] = None,
+        client: Optional[Any] = None,
+        **kwargs
+    ):
+        super().__init__(
+            message_id=message_id,
+            file_id=file_id,
+            chat_id=chat_id,
+            client=client,
+            **kwargs
+        )
+
     async def delete(self):
         return await self.client.delete_message(self.chat_id, self.message_id)
 
@@ -257,6 +751,26 @@ class Update(DataManager):
     updated_message: Optional[Message] = None
     updated_payment: Optional[PaymentStatus] = None
 
+    def __init__(
+        self,
+        type: Optional[enums.UpdateType] = 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,
+        **kwargs
+    ):
+        super().__init__(
+            type=type,
+            chat_id=chat_id,
+            removed_message_id=removed_message_id,
+            new_message=new_message,
+            updated_message=updated_message,
+            updated_payment=updated_payment,
+            **kwargs
+        )
+
     async def download(self, file_name: str):
         return await self.client.download_file(self.new_message.file.file_id, file_name)
 
@@ -363,9 +877,9 @@ class Update(DataManager):
 
     async def reply_file(
         self,
-        file: str,
-        file_name: str,
-        caption: str = None,
+        file: Union[str, bytes],
+        caption: Optional[str] = None,
+        file_name: Optional[str] = None,
         type: enums.FileType = enums.FileType.File,
         chat_keypad: Keypad = None,
         inline_keypad: Keypad = None,
@@ -375,8 +889,8 @@ class Update(DataManager):
         return await self.client.send_file(
             self.chat_id,
             file,
-            file_name,
             caption,
+            file_name,
             type,
             chat_keypad,
             inline_keypad,
@@ -385,28 +899,23 @@ class Update(DataManager):
             self.new_message.message_id,
         )
 
-    async def reply_document(self, document: str, name: str, caption: Optional[str] = None, **kwargs) -> "MessageId":
-        return await self.reply_file(document, name, caption, "File", **kwargs)
+    async def reply_document(self, document: Union[str, bytes], caption: Optional[str] = None, file_name: Optional[str] = None, **kwargs) -> "MessageId":
+        return await self.reply_file(document, caption, file_name, "File", **kwargs)
 
-    async def reply_photo(self, photo: str, name: str, caption: Optional[str] = None, **kwargs) -> "MessageId":
-        return await self.reply_file(photo, name, caption, "Image", **kwargs)
+    async def reply_photo(self, photo: Union[str, bytes], caption: Optional[str] = None, file_name: Optional[str] = None, **kwargs) -> "MessageId":
+        return await self.reply_file(photo, caption, file_name, "Image", **kwargs)
 
-    async def reply_video(self, video: str, name: str, caption: Optional[str] = None, **kwargs) -> "MessageId":
-        return await self.reply_file(video, name, caption, "Video", **kwargs)
+    async def reply_video(self, video: Union[str, bytes], caption: Optional[str] = None, file_name: Optional[str] = None, **kwargs) -> "MessageId":
+        return await self.reply_file(video, caption, file_name, "Video", **kwargs)
 
-    async def reply_gif(self, gif: str, name: str, caption: Optional[str] = None, **kwargs) -> "MessageId":
-        return await self.reply_file(gif, name, caption, "Gif", **kwargs)
+    async def reply_gif(self, gif: Union[str, bytes], caption: Optional[str] = None, file_name: Optional[str] = None, **kwargs) -> "MessageId":
+        return await self.reply_file(gif, caption, file_name, "Gif", **kwargs)
 
-    async def reply_music(self, music: str, name: str, caption: Optional[str] = None, **kwargs) -> "MessageId":
-        return await self.reply_file(music, name, caption, "Music", **kwargs)
+    async def reply_music(self, music: Union[str, bytes], caption: Optional[str] = None, file_name: Optional[str] = None, **kwargs) -> "MessageId":
+        return await self.reply_file(music, caption, file_name, "Music", **kwargs)
 
-    async def reply_voice(self, voice: str, name: str, caption: Optional[str] = None, **kwargs) -> "MessageId":
-        return await self.reply_file(voice, name, caption, "Voice", **kwargs)
-
-
-class Updates(DataManager):
-    updates: Optional[list[Update]] = None
-    next_offset_id: Optional[str] = None
+    async def reply_voice(self, voice: Union[str, bytes], caption: Optional[str] = None, file_name: Optional[str] = None, **kwargs) -> "MessageId":
+        return await self.reply_file(voice, caption, file_name, "Voice", **kwargs)
 
 
 class InlineMessage(DataManager):
@@ -417,4 +926,43 @@ class InlineMessage(DataManager):
     chat_id: Optional[str] = None
     file: Optional[File] = None
     location: Optional[Location] = None
-    aux_data: Optional[AuxData] = None
+    aux_data: Optional[AuxData] = None
+
+    def __init__(
+        self,
+        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,
+        **kwargs
+    ):
+        super().__init__(
+            sender_id=sender_id,
+            text=text,
+            message_id=message_id,
+            chat_id=chat_id,
+            file=file,
+            location=location,
+            aux_data=aux_data,
+            **kwargs
+        )
+
+
+class Updates(DataManager):
+    updates: Optional[list[Update]] = None
+    next_offset_id: Optional[str] = None
+
+    def __init__(
+        self,
+        updates: Optional[list[Update]] = None,
+        next_offset_id: Optional[str] = None,
+        **kwargs
+    ):
+        super().__init__(
+            updates=updates,
+            next_offset_id=next_offset_id,
+            **kwargs
+        )

{rubigramclient-1.6.6.dist-info → rubigramclient-1.6.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: RubigramClient
-Version: 1.6.6
+Version: 1.6.7
 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 <MrJavad.Email@gmail.com>
 Classifier: Programming Language :: Python :: 3
@@ -31,7 +31,8 @@ bot = Client(token="YOUR_TOKEN_BOT")
 
 @bot.on_message(filters.private)
 async def welcome_message(client, message: Update):
-    await message.reply("Hi, WELCOME TO RUBIGRAM")
+    send = await message.reply("Hi, WELCOME TO RUBIGRAM")
+    await send.edit_text("message was edited")
 
 bot.run()
 ```
@@ -84,3 +85,22 @@ async def main():
 
 asyncio.run(main())
 ```
+
+## Implementation of multiple programs
+```python
+from rubigram import Client
+import asyncio
+
+tokens = [
+    "TOKEN_1",
+    "TOKEN_2"
+]
+
+async def main():
+    for token in tokens:
+        async with Client(token) as bot:
+            get_me = await bot.get_me()
+            print(get_me.asjson())
+
+asyncio.run(main())
+```

rubigramclient-1.6.7.dist-info/RECORD

@@ -0,0 +1,13 @@
+rubigram/__init__.py,sha256=h2O7aVl3woDBTHX0MdZLbhgvVRTyXA0NTzOz7F8Y7Xg,124
+rubigram/client.py,sha256=Pg50Za2idur97ZgphmXgQvu0n0N63oPE04sqhujgNk0,5940
+rubigram/enums.py,sha256=UZKH1wROBVMuHVEjrnQSwpi-y2MxMI7zl2uThdPTWoc,2722
+rubigram/filters.py,sha256=40znxAC7xAFYCeERlPYLSVtr0lxUcnQY2HRwt1zSfdk,6838
+rubigram/method.py,sha256=T_JpN6pF-xjRaw__If48H-63tzjFM8VZaUCTqd4vL2I,11501
+rubigram/network.py,sha256=v_JQpVMrHUwDk5oBXgjIBmLGYtyDxUPu7Qvqvk2XUy0,2862
+rubigram/state.py,sha256=_g13o87MHfuudbgvbfu9vAOrSzw4GhdEYkD6dSn7t2s,997
+rubigram/types.py,sha256=MrggHVI62icQpVhVASXI7UV5pav-HuHB6wwVzyg9P90,29326
+rubigramclient-1.6.7.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rubigramclient-1.6.7.dist-info/METADATA,sha256=RMfK7tSH7TDK1c2h5a_CocA5PVh5ogX8MPxZKtomGI4,2655
+rubigramclient-1.6.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+rubigramclient-1.6.7.dist-info/top_level.txt,sha256=Mhg5HfkL6rLec5sI4ClGmwoqYUANAZUz8sVa1sT_cas,9
+rubigramclient-1.6.7.dist-info/RECORD,,

rubigramclient-1.6.6.dist-info/RECORD

@@ -1,13 +0,0 @@
-rubigram/__init__.py,sha256=h2O7aVl3woDBTHX0MdZLbhgvVRTyXA0NTzOz7F8Y7Xg,124
-rubigram/client.py,sha256=CeSrSsPTg7cF0JSUXgzUVLU4ULD4dhvTZ28zY8zgDDE,5011
-rubigram/enums.py,sha256=UZKH1wROBVMuHVEjrnQSwpi-y2MxMI7zl2uThdPTWoc,2722
-rubigram/filters.py,sha256=40znxAC7xAFYCeERlPYLSVtr0lxUcnQY2HRwt1zSfdk,6838
-rubigram/method.py,sha256=Ltlfh1Jy26CKfCz5fez2jifWWCfB8mAWBQKmAu20I0E,11076
-rubigram/network.py,sha256=84-2Grde0GUDOpia6O-7oJNlupBw30ga5VE4sve31dY,2361
-rubigram/state.py,sha256=_g13o87MHfuudbgvbfu9vAOrSzw4GhdEYkD6dSn7t2s,997
-rubigram/types.py,sha256=9eA-mbhW8ILK0MJ4oJMhK00XRHvUe4EumgECgHNPvVM,13395
-rubigramclient-1.6.6.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rubigramclient-1.6.6.dist-info/METADATA,sha256=gJan_rPbbbecSrLfkpibqZzyIUfOxcmnqLEH_1Qdk5M,2260
-rubigramclient-1.6.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-rubigramclient-1.6.6.dist-info/top_level.txt,sha256=Mhg5HfkL6rLec5sI4ClGmwoqYUANAZUz8sVa1sT_cas,9
-rubigramclient-1.6.6.dist-info/RECORD,,