RubigramClient 1.1.1__tar.gz → 1.2.0__tar.gz

rubigramclient-1.2.0/PKG-INFO

@@ -0,0 +1,33 @@
+Metadata-Version: 2.4
+Name: RubigramClient
+Version: 1.2.0
+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
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Rubigram
+
+A lightweight Python library to build Rubika bots easily.
+
+## Installation
+```bash
+pip install RubigramClient
+
+```python
+from rubigram import Client, filters
+from rubigram.types import Update
+
+bot = Client("your_bot_token")
+
+@bot.on_message(filters.command("start"))
+async def start_handler(client, message: Update):    
+    await message.reply("Hi, WELCOME TO RUBIGRAM")
+
+bot.run()
+```

rubigramclient-1.2.0/README.md

@@ -0,0 +1,20 @@
+# Rubigram
+
+A lightweight Python library to build Rubika bots easily.
+
+## Installation
+```bash
+pip install RubigramClient
+
+```python
+from rubigram import Client, filters
+from rubigram.types import Update
+
+bot = Client("your_bot_token")
+
+@bot.on_message(filters.command("start"))
+async def start_handler(client, message: Update):    
+    await message.reply("Hi, WELCOME TO RUBIGRAM")
+
+bot.run()
+```

rubigramclient-1.2.0/RubigramClient.egg-info/PKG-INFO

@@ -0,0 +1,33 @@
+Metadata-Version: 2.4
+Name: RubigramClient
+Version: 1.2.0
+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
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Rubigram
+
+A lightweight Python library to build Rubika bots easily.
+
+## Installation
+```bash
+pip install RubigramClient
+
+```python
+from rubigram import Client, filters
+from rubigram.types import Update
+
+bot = Client("your_bot_token")
+
+@bot.on_message(filters.command("start"))
+async def start_handler(client, message: Update):    
+    await message.reply("Hi, WELCOME TO RUBIGRAM")
+
+bot.run()
+```

{rubigramclient-1.1.1 → rubigramclient-1.2.0}/RubigramClient.egg-info/top_level.txt

@@ -1,2 +1 @@
-dist
 rubigram

rubigramclient-1.2.0/pyproject.toml

@@ -0,0 +1,15 @@
+[project]
+name = "RubigramClient"
+version = "1.2.0"
+description = "A simple and flexible Python library for building advanced Rubika bots with powerful message handling, inline buttons, and custom filters."
+readme = "README.md"
+requires-python = ">=3.7"
+license = {file = "LICENSE"}
+authors = [
+  { name="Javad RZ", email="Javad.Py1385@gmail.com" }
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]

rubigramclient-1.2.0/rubigram/__init__.py

@@ -0,0 +1,2 @@
+from .client import Client
+from .filters import filter

{rubigramclient-1.1.1 → rubigramclient-1.2.0}/rubigram/client.py

@@ -1,6 +1,6 @@
-from rubigram.types import Message, InlineMessage, MessageId, Chat, Bot
+from rubigram.types import Update, MessageId, Keypad, Chat, Bot
 from aiohttp import ClientSession, FormData, web
-from typing import Literal
+from typing import Literal, Optional
 import aiofiles
 
 
@@ -27,24 +27,25 @@ class Client:
         return decorator
     
     async def update(self, data: dict):
-        update_object = Message(self, data["update"]) if data.get("update") else InlineMessage(data["inline_message"])
+        event = Update.read(data["update"], self)
         for handler in self.messages_handler:
-            await handler(self, update_object)
-            
+            await handler(self, event)
+           
     
     async def get_me(self) -> "Bot":
         response = await self.request("getMe", {})
-        return Bot(response["data"]["bot"])
+        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(response["data"])
+        return Chat.read(response["data"]["chat"])
 
     
-    async def get_updates(self, limit: int = 1, offset_id: str = None):
+    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})
-        return response
+        updates = [update for update in response["data"]["updates"]]
+        return [Update.read(update) for update in updates]
     
     
     async def set_command(self, commands: list):
@@ -65,8 +66,8 @@ class Client:
         self,
         chat_id: str,
         text: str,
-        chat_keypad = None, # مشخص کردن تایپ
-        inline_keypad = None, # مشخص کردن تایپ
+        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
@@ -74,14 +75,14 @@ class Client:
         data = {
             "chat_id": chat_id,
             "text": text,
-            "chat_keypad": chat_keypad,
-            "inline_keypad": inline_keypad,
+            "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(response["data"])
+        return MessageId.read(response["data"])
 
     
     async def send_poll(
@@ -89,8 +90,8 @@ class Client:
         chat_id: str,
         question: str,
         options: list[str],
-        chat_keypad = None, # مشخص کردن تایپ
-        inline_keypad = None, # مشخص کردن تایپ
+        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
@@ -106,7 +107,7 @@ class Client:
             "chat_keypad_type": chat_keypad_type
         }
         response = await self.request("sendPoll", data)
-        return MessageId(response["data"])
+        return MessageId.read(response["data"])
     
     
     async def send_location(
@@ -114,8 +115,8 @@ class Client:
         chat_id: str,
         latitude: str,
         longitude: str,
-        chat_keypad = None, # مشخص کردن تایپ
-        inline_keypad = None, # مشخص کردن تایپ
+        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
@@ -131,7 +132,7 @@ class Client:
             "chat_keypad_type": chat_keypad_type
         }
         response = await self.request("sendLocation", data)
-        return MessageId(response["data"])
+        return MessageId.read(response["data"])
     
     
     async def send_contact(
@@ -140,8 +141,8 @@ class Client:
         first_name: str,
         last_name: str,
         phone_number: str,
-        chat_keypad = None, # مشخص کردن تایپ
-        inline_keypad  = None, # مشخص کردن تایپ
+        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
@@ -158,15 +159,15 @@ class Client:
             "chat_keypad_type": chat_keypad_type
         }
         response = await self.request("sendContact", data)
-        return MessageId(response["data"])
+        return MessageId.read(response["data"])
     
     
     async def send_sticker(
         self,
         chat_id: str,
         sticker_id: str,
-        chat_keypad = None, # مشخص کردن تایپ
-        inline_keypad = None, # مشخص کردن تایپ
+        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,
@@ -181,7 +182,7 @@ class Client:
             "chat_keypad_type": chat_keypad_type
         }
         response = await self.request("sendSticker", data)
-        return MessageId(response["data"])
+        return MessageId.read(response["data"])
     
     
     async def forward_message(
@@ -198,7 +199,7 @@ class Client:
             "disable_notification": disable_notification
         }
         response = await self.request("forwardMessage", data)
-        return MessageId(response["data"])
+        return MessageId.read(response["data"])
     
     
     async def edit_message_text(
@@ -215,7 +216,7 @@ class Client:
         self,
         chat_id: str,
         message_id: str,
-        inline_keypad # مشخص کردن تایپ
+        inline_keypad: Keypad
         ) -> None:
         data = {"chat_id": chat_id, "message_id": message_id, "inline_keypad": inline_keypad}
         await self.request("editMessageKeypad", data)
@@ -224,7 +225,7 @@ class Client:
     async def edit_chat_keypad(
         self,
         chat_id: str,
-        chat_keypad # مشخص کردن تایپ
+        chat_keypad: Keypad
     ) -> None:
         data = {"chat_id": chat_id, "chat_keypad_type": "New", "chat_keypad": chat_keypad}
         await self.request("editChatKeypad", data)
@@ -290,7 +291,7 @@ class Client:
             "chat_keypad_type": chat_keypad_type,
         }
         response = await self.request("sendFile", data)
-        return MessageId(response["data"])
+        return MessageId.read(response["data"])
 
     
     async def download_file(self, file_id: str, file_name: str):

{rubigramclient-1.1.1 → rubigramclient-1.2.0}/rubigram/filters.py

@@ -1,23 +1,23 @@
-from rubigram.types import Message
+from rubigram.types import Update
 from typing import Union
 
 
 class filter:
     @staticmethod
     def text():
-        def inner(update: Message):
+        def inner(update: Update):
             return update.new_message.text
         return inner
 
     @staticmethod
     def private():
-        def inner(update: Message):
+        def inner(update: Update):
             return update.new_message.sender_type == "User"
         return inner
     
     @staticmethod
     def command(cmd: Union[str, list[str]]):
-        def inner(update: Message):
+        def inner(update: Update):
             if not update.new_message.text:
                 return False
             if not update.new_message.text.startswith("/"):
@@ -27,24 +27,24 @@ class filter:
     
     @staticmethod
     def text_filter(text: str):
-        def inner(update: Message):
+        def inner(update: Update):
             return update.new_message.text == text if update.new_message.text else False
         return inner
     
     @staticmethod
     def chat(chat_id: str):
-        def inner(update: Message):
+        def inner(update: Update):
             return update.chat_id == chat_id
         return inner
     
     @staticmethod
     def file():
-        def inner(update: Message):
+        def inner(update: Update):
             return update.new_message.file
         return inner
     
     @staticmethod
     def button(id: str):
-        def inner(update: Message):
+        def inner(update: Update):
             return update.new_message.aux_data.button_id == id if update.new_message.aux_data else False
         return inner

rubigramclient-1.2.0/rubigram/types.py

@@ -0,0 +1,470 @@
+from dataclasses import dataclass
+from typing import Any, Dict, List, Literal, Optional
+import rubigram
+
+
+
+@dataclass
+class Location:
+    longitude: Optional[str] = None
+    latitude: Optional[str] = None
+    
+    def _dict(self) -> Dict:
+        return {
+            "longitude": self.longitude,
+            "latitude": self.latitude
+        }
+    
+    @classmethod
+    def read(cls, data: dict[str, Any]) -> "Location":
+        return cls(
+            longitude = data.get("longitude"),
+            latitude = data.get("latitude"),
+        )
+
+@dataclass
+class ButtonSelectionItem:
+    text: Optional[str] = None
+    image_url: Optional[str] = None
+    type: Optional[Literal["TextOnly", "TextImgThu", "TextImgBig"]] = None
+    
+    def _dict(self) -> Dict:
+        return {
+            "text": self.text,
+            "image_url": self.image_url,
+            "type": self.type
+        }
+
+@dataclass
+class ButtonTextbox:
+    type_line: Optional[Literal["SingleLine", "MultiLine"]] = None
+    type_keypad: Optional[Literal["String", "Number"]] = None
+    place_holder: Optional[str] = None
+    title: Optional[str] = None
+    default_value: Optional[str] = None
+    
+    def _dict(self) -> Dict:
+        return {
+            "type_line": self.type_line,
+            "type_keypad": self.type_keypad,
+            "place_holder": self.place_holder,
+            "title": self.title,
+            "default_value": self.default_value
+        }
+
+@dataclass
+class ButtonLocation:
+    default_pointer_location: Optional[Location] = None
+    default_map_location: Optional[Location] = None
+    type: Optional[Literal["Picker", "View"]] = None
+    title: Optional[str] = None
+    location_image_url: Optional[str] = None
+    
+    def _dict(self) -> Dict:
+        return {
+            "default_pointer_location": self.default_pointer_location._dict(),
+            "default_map_location": self.default_map_location._dict(),
+            "type": self.type,
+            "title": self.title,
+            "location_image_url": self.location_image_url
+        }
+    
+@dataclass
+class ButtonStringPicker:
+    items: Optional[List[str]] = None
+    default_value: Optional[str] = None
+    title: Optional[str] = None
+    
+    def _dict(self) -> Dict:
+        return {
+            "items": self.items,
+            "default_value": self.default_value,
+            "title": self.title,
+        }
+
+@dataclass
+class ButtonNumberPicker:
+    min_value: Optional[str] = None
+    max_value: Optional[str] = None
+    default_value: Optional[str] = None
+    title: Optional[str] = None
+    
+    def _dict(self) -> Dict:
+        return {
+            "min_value": self.min_value,
+            "max_value": self.max_value,
+            "default_value": self.default_value,
+            "title": self.title
+        }
+    
+@dataclass
+class ButtonCalendar:
+    default_value: Optional[str] = None
+    type: Optional[Literal["DatePersian", "DateGregorian"]] = None
+    min_year: Optional[str] = None
+    max_year: Optional[str] = None
+    title: Optional[str] = None
+    
+    def _dict(self) -> Dict:
+        return {
+            "default_value": self.default_value,
+            "type": self.type,
+            "min_year": self.min_year,
+            "max_year": self.max_year,
+            "title": self.title
+        }
+
+@dataclass
+class ButtonSelection:
+    selection_id: Optional[str] = None
+    search_type: Optional[str] = None
+    get_type: Optional[str] = None
+    items: Optional[ButtonSelectionItem] = None
+    is_multi_selection: Optional[bool] = None
+    columns_count: Optional[str] = None
+    title: Optional[str] = None
+    
+    def _dict(self) -> Dict:
+        return {
+            "selection_id": self.selection_id,
+            "search_type": self.search_type,
+            "get_type": self.get_type,
+            "items": self.items._dict() if self.items else None,
+            "is_multi_selection": self.is_multi_selection,
+            "columns_count": self.columns_count,
+            "title": self.title
+        }
+    
+    
+    
+@dataclass
+class Button:
+    id: Optional[str] = None
+    type: Literal[
+        "Simple", "Selection", "Calendar", "NumberPicker", "StringPicker", "Location", "Payment",
+        "CameraImage", "CameraVideo", "GalleryImage", "GalleryVideo", "File", "Audio", "RecordAudio",
+        "MyPhoneNumber", "MyLocation", "Textbox", "Link", "AskMyPhoneNumber", "AskLocation", "Barcode"
+    ] = "Simple"
+    button_text: Optional[str] = None
+    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
+    
+    def _dict(self) -> Dict:
+        return {
+            "id": self.id,
+            "type": self.type,
+            "button_text": self.button_text,
+            "button_selection": self.button_selection._dict() if self.button_selection else None,
+            "button_calendar": self.button_calendar._dict() if self.button_calendar else None,
+            "button_number_picker": self.button_number_picker._dict() if self.button_number_picker else None,
+            "button_string_picker": self.button_string_picker._dict() if self.button_string_picker else None,
+            "button_location": self.button_location._dict() if self.button_location else None,
+            "button_textbox": self.button_textbox._dict() if self.button_textbox else None
+        }
+
+@dataclass
+class KeypadRow:
+    buttons: List[Button]
+    
+    def _dict(self) -> Dict:
+        return {
+            "buttons": [button._dict() for button in self.buttons]
+        }
+
+@dataclass
+class Keypad:
+    rows: List[KeypadRow]
+    resize_keyboard: bool = True
+    on_time_keyboard: bool = False
+    
+    def _dict(self) -> Dict:
+        return {
+            "rows": [row._dict() for row in self.rows],
+            "resize_keyboard": self.resize_keyboard,
+            "one_time_keyboard": self.on_time_keyboard
+        }
+
+@dataclass
+class MessageId:
+    client: Optional["rubigram.Client"] = None
+    message_id: Optional[str] = None
+    file_id: Optional[str] = None
+    
+    @classmethod
+    def read(cls, data: Dict[str, Any]) -> "MessageId":
+        return cls(
+            message_id = data.get("message_id"),
+            file_id = data.get("file_id")
+        )
+
+@dataclass
+class PollStatus:
+    state: Optional[Literal["Open", "Closed"]] = None
+    selection_index: Optional[int] = None
+    percent_vote_options: Optional[List[int]] = None
+    total_vote: Optional[int] = None
+    show_total_votes: Optional[bool] = None
+    
+    @classmethod
+    def read(cls, data: Dict[str, Any]) -> "PollStatus":
+        return cls(
+            state = data.get("state"),
+            selection_index = data.get("selection_index"),
+            percent_vote_options = data.get("percent_vote_options"),
+            total_vote = data.get("total_vote"),
+            show_total_votes = data.get("show_total_votes"),
+        )
+
+@dataclass
+class File:
+    file_id: Optional[str] = None
+    file_name: Optional[str] = None
+    size: Optional[str] = None
+    
+    @classmethod
+    def read(cls, data: dict[str, Any]) -> "File":
+        return cls(
+            file_id = data.get("file_id"),
+            file_name = data.get("file_name"),
+            size = data.get("size"),
+        )
+    
+@dataclass
+class LiveLocation:
+    start_time: Optional[str] = None
+    live_period: Optional[int] = None
+    current_location: Optional[Location] = None
+    user_id: Optional[str] = None
+    status: Optional[Literal["Stopped", "Live"]] = None
+    last_update_time: Optional[str] = None
+    
+    @classmethod
+    def read(cls, data: dict[str, Any]) -> "LiveLocation":
+        return cls(
+            start_time = data.get("start_time"),
+            live_period = data.get("live_period"),
+            current_location = Location.read(data.get("current_location")) if "current_location" in data else None,
+            user_id = data.get("user_id"),
+            status = data.get("status"),
+            last_update_time = data.get("last_update_time")
+        )
+    
+@dataclass
+class Poll:
+    question: Optional[str] = None
+    options: Optional[List[str]] = None
+    poll_status: Optional[PollStatus] = None
+    
+    @classmethod
+    def read(cls, data: dict[str, Any]) -> "Poll":
+        return cls(
+            question = data.get("question"),
+            options = data.get("options"),
+            poll_status = PollStatus.read(data.get("poll_status")) if "poll_status" in data else None
+        )
+    
+@dataclass
+class ContactMessage:
+    phone_number: Optional[str] = None
+    first_name: Optional[File] = 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,
+            last_name = data.get("last_name")
+        )
+    
+@dataclass
+class Sticker:
+    sticker_id: Optional[str] = None
+    file: Optional[File] = None
+    emoji_character: Optional[str] = None
+    
+    @classmethod
+    def read(cls, data: dict[str, Any]) -> "Sticker":
+        return cls(
+            sticker_id = data.get("sticker_id"),
+            file = File.read(data.get("file")) if "file" in data else None,
+            emoji_character = data.get("emoji_character")
+        )
+
+@dataclass
+class ForwardedFrom:
+    type_from: Optional[Literal["User", "Channel", "Bot"]] = None
+    message_id: Optional[str] = None
+    from_chat_id: Optional[str] = None
+    from_sender_id: Optional[str] = None
+    
+    @classmethod
+    def read(cls, data: dict[str, Any]) -> "ForwardedFrom":
+        return cls(
+            type_from = data.get("type_from"),
+            message_id = data.get("message_id"),
+            from_chat_id = data.get("from_chat_id"),
+            from_sender_id = data.get("from_sender_id")
+        )
+
+@dataclass
+class AuxData:
+    start_id: Optional[str] = None
+    button_id: Optional[str] = None
+    
+    @classmethod
+    def read(cls, data: Dict[str, Any]) -> "AuxData":
+        return cls(
+            start_id = data.get("start_id"),
+            button_id = data.get("button_id")
+        )
+    
+@dataclass
+class PaymentStatus:
+    payment_id: Optional[str] = None
+    status: Optional[Literal["Paid", "NotPaid"]] = None
+    
+    @classmethod
+    def read(cls, data: Dict[str, Any]) -> "PaymentStatus":
+        return cls(
+            payment_id = data.get("payment_id"),
+            status = data.get("status")
+        )
+
+@dataclass
+class Chat:
+    chat_id: Optional[str] = None
+    chat_type: Optional[Literal["User", "Bot", "Group", "Channel"]] = None
+    user_id: Optional[str] = None
+    first_name: Optional[str] = None
+    last_name: Optional[str] = None
+    title: Optional[str] = None
+    username: Optional[str] = None
+    
+    @classmethod
+    def read(cls, data: Dict[str, Any]) -> "Chat":
+        return cls(
+            chat_id = data.get("chat_id"),
+            chat_type = data.get("chat_type"),
+            user_id = data.get("user_id"),
+            first_name = data.get("first_name"),
+            last_name = data.get("last_name"),
+            title = data.get("title"),
+            username = data.get("username")
+        )
+
+@dataclass
+class Bot:
+    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
+    
+    @classmethod
+    def read(cls, data: Dict[str, Any]) -> "Bot":
+        return cls(
+            bot_id = data.get("bot_id"),
+            bot_title = data.get("bot_title"),
+            avatar = File.read(data.get("avatar")) if data.get("avatar") else None,
+            description = data.get("description"),
+            username = data.get("username"),
+            start_message = data.get("start_message"),
+            share_url = data.get("share_url")
+        )
+
+@dataclass
+class InlineMessage:
+    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
+    
+    @classmethod
+    def read(cls, data: Dict[str, Any]) -> "InlineMessage":
+        return cls(
+            sender_id = data.get("sender_id"),
+            text = data.get("text"),
+            message_id = data.get("message_id"),
+            chat_id = data.get("chat_id"),
+            file = File.read(data.get("file")) if data.get("file") else None,
+            location = Location.read(data.get("location")) if data.get("location") else None,
+            aux_data = AuxData.read(data.get("aux_data")) if data.get("aux_data") else None
+        )
+
+@dataclass
+class Message:
+    message_id: Optional[str] = None
+    text: Optional[str] = None
+    time: Optional[str] = None
+    is_edited: Optional[bool] = None
+    sender_type: Optional[Literal["User", "Bot"]] = 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
+    
+    @classmethod
+    def read(cls, data: Dict[str, Any]) -> "Message":
+        return cls(
+            message_id = data["message_id"],
+            text = data.get("text"),
+            time = data["time"],
+            is_edited = data["is_edited"],
+            sender_type = data["sender_type"],
+            sender_id = data["sender_id"],
+            aux_data = AuxData.read(data["aux_data"]) if "aux_data" in data else None,
+            file = File.read(data["file"]) if "file" in data else None,
+            reply_to_message_id = data.get("reply_to_message_id"),
+            forwarded_from = ForwardedFrom.read(data["forwarded_from"]) if "forwarded_from" in data else None,
+            forwarded_no_link = data.get("forwarded_no_link"),
+            location = Location.read(data["location"]) if "location" in data else None,
+            sticker = Sticker.read(data["sticker"]) if "sticker" in data else None,
+            contact_message = ContactMessage.read(data["contact_message"]) if "contact_message" in data else None,
+            poll = Poll.read(data["poll"]) if "poll" in data else None,
+            live_location = LiveLocation.read(data["live_location"]) if "live_location" in data else None
+        )
+
+@dataclass
+class Update:
+    client: Optional["rubigram.Client"] = 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
+    
+    @classmethod
+    def read(cls, data: Dict[str, Any], client: Optional["rubigram.Client"] = None) -> "Update":
+        return cls(
+            client = client,
+            type = data["type"],
+            chat_id = data["chat_id"],
+            removed_message_id = data.get("removed_message_id"),
+            new_message = Message.read(data["new_message"]),
+            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
+        )
+        
+    async def reply_text(self, text: str) -> "MessageId":
+        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)

rubigramclient-1.1.1/PKG-INFO

@@ -1,24 +0,0 @@
-Metadata-Version: 2.4
-Name: RubigramClient
-Version: 1.1.1
-Summary: A Python library for connect to Rubika API
-Author-email: Javad RJ <Javad.Py1385@gmail.com>
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Dynamic: license-file
-
-Rubigram
-
-```python
-from rubigram import Client, filter
-from rubigram.types import Message
-
-client = Client("Your_Bot_Token")
-
-@bot.on_message(filter.command("start"))
-async def start(client: Client, message: Message):
-    chat_id = message.chat_id
-    await message.reply("Hi, {}".format(chat_id))
-
-client.run()

rubigramclient-1.1.1/README.md

@@ -1,14 +0,0 @@
-Rubigram
-
-```python
-from rubigram import Client, filter
-from rubigram.types import Message
-
-client = Client("Your_Bot_Token")
-
-@bot.on_message(filter.command("start"))
-async def start(client: Client, message: Message):
-    chat_id = message.chat_id
-    await message.reply("Hi, {}".format(chat_id))
-
-client.run()

rubigramclient-1.1.1/RubigramClient.egg-info/PKG-INFO

@@ -1,24 +0,0 @@
-Metadata-Version: 2.4
-Name: RubigramClient
-Version: 1.1.1
-Summary: A Python library for connect to Rubika API
-Author-email: Javad RJ <Javad.Py1385@gmail.com>
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Dynamic: license-file
-
-Rubigram
-
-```python
-from rubigram import Client, filter
-from rubigram.types import Message
-
-client = Client("Your_Bot_Token")
-
-@bot.on_message(filter.command("start"))
-async def start(client: Client, message: Message):
-    chat_id = message.chat_id
-    await message.reply("Hi, {}".format(chat_id))
-
-client.run()

rubigramclient-1.1.1/pyproject.toml

@@ -1,17 +0,0 @@
-[build-system]
-requires = ["setuptools", "wheel"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "RubigramClient"
-version = "1.1.1"
-description = "A Python library for connect to Rubika API"
-readme = "README.md"
-authors = [
-    { name = "Javad RJ", email = "Javad.Py1385@gmail.com" }
-]
-license = { file = "LICENSE" }
-requires-python = ">=3.7"
-
-[tool.setuptools.packages.find]
-where = ["."]

rubigramclient-1.1.1/rubigram/__init__.py

@@ -1,3 +0,0 @@
-from .client import Client
-from .filters import filter
-from . import types

rubigramclient-1.1.1/rubigram/types.py

@@ -1,235 +0,0 @@
-import rubigram
-from typing import Literal
-from json import dumps
-
-
-
-class ForwardFrom:
-    def __init__(self, data: dict):
-        self.type_from: str = data["type_from"]
-        self.message_id: str = data["message_id"]
-        self.from_sender_id: str = data.get("from_sender_id")
-        self.from_chat_id: str = data.get("from_chat_id")
-    
-    def _dict(self):
-        return {
-            "type_from": self.type_from,
-            "message_id": self.message_id,
-            "from_sender_id": self.from_sender_id,
-            "from_chat_id": self.from_chat_id
-        }
-
-    def __str__(self):
-        return dumps(self._dict(), indent=4, ensure_ascii=False)
-        
-        
-class File:
-    def __init__(self, data: dict):
-        self.file_id: str = data["file_id"]
-        self.file_name: str = data.get("file_name")
-        self.size: int = data.get("size")
-    
-    def _dict(self):
-        return {"file_id": self.file_id, "file_name": self.file_name, "size": self.size}
-        
-    def __str__(self):
-        return dumps(self._dict(), indent=4, ensure_ascii=False)
-    
-    
-class Location:
-    def __init__(self, data: dict):
-        self.longitude: int = data["longitude"]
-        self.latitude: int = data["latitude"]
-    
-    def _dict(self):
-        return {"longitude": self.longitude, "latitude": self.latitude}
-    
-    def __str__(self):
-        return dumps(self._dict(), indent=4, ensure_ascii=False)
-
-
-class AuxData:
-    def __init__(self, data: dict):
-        self.start_id = data.get("start_id")
-        self.button_id: str = data.get("button_id")
-    
-    def _dict(self):
-        return {"start_id": self.start_id, "button_id": self.button_id}
-    
-    def __str__(self):
-        return dumps(self._dict(), indent=4, ensure_ascii=False)
-        
-        
-class MessageId:
-    def __init__(self, data: dict):
-        self.message_id = data["message_id"]
-    
-    def _dict(self):
-        return {"message_id": self.message_id}
-    
-    def __str__(self):
-        return dumps(self._dict(), indent=4, ensure_ascii=False)
-
-
-class UpdateMessage:
-    def __init__(self, data: dict):
-        self.message_id: str = data["message_id"]
-        self.text: str = data["text"]
-        self.time: str = data["time"]
-        self.is_edited: bool = data["is_edited"]
-        self.sender_type: str = data["sender_type"]
-        self.sender_id: str = data["sender_id"]
-        
-    def _dict(self):
-        return {
-            "message_id": self.message_id,
-            "text": self.text,
-            "time": self.time,
-            "is_edited": self.is_edited,
-            "sender_type": self.sender_type,
-            "sender_id": self.sender_id
-        }
-        
-    def __str__(self):
-        return dumps(self._dict(), indent=4, ensure_ascii=False)
-
-
-class NewMessage:
-    def __init__(self, data: dict):
-        self.message_id: str = data["message_id"]
-        self.time: str = data["time"]
-        self.is_edited: bool = data["is_edited"]
-        self.sender_type: str = data["sender_type"]
-        self.sender_id: str = data["sender_id"]
-        self.text: str = data.get("text")
-        self.forwarded_from: ForwardFrom = ForwardFrom(data["forwarded_from"]) if data.get("forwarded_from") else None
-        self.file: File = File(data["file"]) if data.get("file") else None
-        self.location: Location = Location(data["location"]) if data.get("location") else None
-        self.aux_data: AuxData = AuxData(data["aux_data"]) if data.get("aux_data") else None
-
-    def _dict(self):
-        return {
-            "message_id": self.message_id,
-            "time": self.time,
-            "is_edited": self.is_edited,
-            "sender_type": self.sender_type,
-            "sender_id": self.sender_id,
-            "text": self.text,
-            "forwarded_from": self.forwarded_from._dict() if self.forwarded_from else None,
-            "file": self.file._dict() if self.file else None,
-            "location": self.location._dict() if self.location else None,
-            "aux_data": self.aux_data._dict() if self.aux_data else None
-        }
-        
-    def __str__(self):
-        return dumps(self._dict(), indent=4, ensure_ascii=False)
-    
-
-class InlineMessage:
-    def __init__(self, data: dict):
-        self.message_id: str = data["message_id"]
-        self.chat_id: str = data["chat_id"]
-        self.sender_id: str = data["sender_id"]
-        self.text: str = data["text"]
-        self.aux_data: AuxData = AuxData(data["aux_data"])
-        self.location: Location = Location(data["location"]) if data.get("location") else None
-    
-    def _dict(self):
-        return {
-            "message_id": self.message_id,
-            "chat_id": self.chat_id,
-            "sender_id": self.sender_id,
-            "text": self.text,
-            "aux_data": self.aux_data._dict() if self.aux_data else None,
-            "location":self.location._dict() if self.location else None
-        }
-        
-    def __str__(self):
-        return dumps(self._dict(), indent=4, ensure_ascii=False)
-
-
-class Bot:
-    def __init__(self, data: dict):
-        self.bot_id: str = data["bot_id"]
-        self.bot_title: str = data["bot_title"]
-        self.username: str = data["username"]
-        self.start_message: str = data["start_message"]
-        self.share_url: str = data["share_url"]
-        self.description: str = data["description"]
-        self.avatar: File = File(data["avatar"]) if data.get("avatar") else None
-
-    def _dict(self):
-        return {
-            "bot_id": self.bot_id,
-            "bot_title": self.bot_title,
-            "username": self.username,
-            "start_message": self.start_message,
-            "share_url": self.share_url,
-            "description": self.description,
-            "avatar": self.avatar._dict() if self.avatar else None
-        }
-    
-    def __str__(self):
-        return dumps(self._dict(), indent=4, ensure_ascii=False)
-
-
-class Chat:
-    def __init__(self, data: dict):
-        self.chat_id: str = data["chat_id"]
-        self.chat_type: str = data["chat_type"]
-        self.user_id: str = data.get("user_id")
-        self.first_name: str = data.get("first_name")
-        self.last_name: str = data.get("last_name")
-        self.title: str = data.get("title")
-        self.username: str = data.get("username")
-    
-    def _dict(self):
-        return {
-            "chat_id": self.chat_id,
-            "chat_type": self.chat_type,
-            "user_id": self.user_id,
-            "first_name": self.first_name,
-            "last_name": self.last_name,
-            "title" : self.title,
-            "username": self.username
-        }
-        
-    def __str__(self):
-        return dumps(self._dict(), indent=4, ensure_ascii=False)
-    
-
-class Message:
-    def __init__(self, client: "rubigram.Client", data: dict):
-        # Message Update Type : ["NewMessage", "UpdatedMessage", "RemovedMessage", "StartedBot", "StoppedBot"و "UpdatedPayment"]
-        self.client = client
-        self.type: str = data["type"]
-        self.chat_id: str = data["chat_id"]
-        self.new_message: NewMessage = NewMessage(data.get("new_message")) if data.get("new_message") else None
-        self.removed_message_id: int = data.get("removed_message_id")
-        self.updated_message: UpdateMessage = UpdateMessage(data.get("updated_message")) if data.get("updated_message") else None
-    
-    def _dict(self):
-        return {
-            "type": self.type,
-            "chat_id": self.chat_id,
-            "new_message": self.new_message._dict() if self.new_message else None,
-            "removed_message_id" : self.removed_message_id,
-            "updated_message": self.updated_message._dict() if self.updated_message else None
-        }
-        
-    def __str__(self):
-        return dumps(self._dict(), indent=4, ensure_ascii=False)
-
-    async def reply_text(self, text: str):
-        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"
-    ):
-        return await self.client.send_file(self.chat_id, path, file_name, type)
-
-    async def download(self, file_name: str):
-        return await self.client.download_file(self.new_message.file.file_id, file_name)