RubigramClient 1.4.0__tar.gz → 1.4.1__tar.gz

{rubigramclient-1.4.0 → rubigramclient-1.4.1}/PKG-INFO

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

{rubigramclient-1.4.0 → rubigramclient-1.4.1}/RubigramClient.egg-info/PKG-INFO

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

{rubigramclient-1.4.0 → rubigramclient-1.4.1}/RubigramClient.egg-info/SOURCES.txt

@@ -11,4 +11,5 @@ rubigram/client.py
 rubigram/filters.py
 rubigram/method.py
 rubigram/network.py
+rubigram/state.py
 rubigram/types.py

{rubigramclient-1.4.0 → rubigramclient-1.4.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "RubigramClient"
-version = "1.4.0"
+version = "1.4.1"
 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"
@@ -15,5 +15,6 @@ classifiers = [
 ]
 dependencies = [
     "aiohttp",
-    "aiofiles"
+    "aiofiles",
+    
 ]

rubigramclient-1.4.1/rubigram/__init__.py

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

{rubigramclient-1.4.0 → rubigramclient-1.4.1}/rubigram/client.py

@@ -55,11 +55,13 @@ class Client(Method):
 
     async def handle_update(self, data: dict):
         if "inline_message" in data:
-            event = InlineMessage.read(data["inline_message"])
+            event = InlineMessage.from_dict(data["inline_message"])
             await asyncio.gather(*(h(self, event) for h in self.inlines_handler))
         elif "update" in data:
-            event = Update.read(data["update"], self)
+            event = Update.from_dict(data["update"])
+            event.client = self
             await asyncio.gather(*(h(self, event) for h in self.messages_handler))
+            
 
     async def set_endpoints(self):
         if not self.endpoint:

{rubigramclient-1.4.0 → rubigramclient-1.4.1}/rubigram/filters.py

@@ -1,14 +1,21 @@
 from rubigram.types import Update, InlineMessage
-# from rubigram.state import state_manager
+from rubigram.state import state_manager
 from typing import Union
 import re
 
 
-# def state(states: Union[str, list[str]]):
-#     def filter(message: Union[Update, InlineMessage]):
-#         user_state = state_manager.get_state(message.chat_id)
-#         return user_state in states if isinstance(states, list) else user_state == states
-#     return filter
+def state(states: Union[str, list[str]]):
+    def filter(message: Union[Update, InlineMessage]):
+        user_state = state_manager.get_state(message.chat_id)
+        return user_state in states if isinstance(states, list) else user_state == states
+    return filter
+
+def edited():
+    def filter(message: Update):
+        if isinstance(message, Update) and message.updated_message:
+            return message.updated_message.is_edited
+        return False
+    return filter
 
 def command(commands: Union[str, list[str]], prefix: str = "/"):
     def filter(message: Update):
@@ -70,6 +77,7 @@ def private():
         return False
     return filter
 
+
 def forward():
     def filter(message: Update):
         if isinstance(message, Update) and message.type == "NewMessage":
@@ -77,6 +85,30 @@ def forward():
         return False
     return filter
 
+def forward_channel():
+    def filter(message: Update):
+        if isinstance(message, Update) and message.type == "NewMessage" and message.new_message.forwarded_from:
+            return message.new_message.forwarded_from.from_sender_id == "Channel"
+        return False
+    return filter
+
+
+def forward_user():
+    def filter(message: Update):
+        if isinstance(message, Update) and message.type == "NewMessage" and message.new_message.forwarded_from:
+            return message.new_message.forwarded_from.from_sender_id == "User"
+        return False
+    return filter
+
+
+def forward_bot():
+    def filter(message: Update):
+        if isinstance(message, Update) and message.type == "NewMessage" and message.new_message.forwarded_from:
+            return message.new_message.forwarded_from.from_sender_id == "Bot"
+        return False
+    return filter
+
+
 def location():
     def filter(message: Update):
         if isinstance(message, Update) and message.type == "NewMessage":

rubigramclient-1.4.1/rubigram/method.py

@@ -0,0 +1,355 @@
+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.from_dict(response["bot"])
+    
+    async def get_chat(self, chat_id: str) -> "Chat":
+        response = await self.request("getChat", {"chat_id": chat_id})
+        return Chat.from_dict(response["chat"])
+    
+    async def get_update(self, limit: int = 1, offset_id: Optional[int] = None) -> list[Update]:
+        response = await self.request("getUpdates", {"limit": limit, "offset_id": offset_id})
+        return [Update.from_dict(update) for update in response["updates"]]
+    
+    async def get_file(self, file_id: str) -> str:
+        response = await self.request("getFile", {"file_id": file_id})
+        return response["download_url"]
+    
+    async def set_command(self, command: list):
+        response = await self.request("setCommands", {"bot_commands": command})
+        return response
+    
+    async def update_bot_endpoint(self, url: str, type: Literal["ReceiveUpdate", "ReceiveInlineMessage", "ReceiveQuery", "GetSelectionItem", "SearchSelectionItems"]):
+        response = await self.request("updateBotEndpoints", {"url": url, "type": type})
+        return response
+    
+    async def forward_message(self, from_chat_id: str, message_id: str, to_chat_id: str, disable_notification: bool = False) -> "MessageId":
+        data = {"from_chat_id": from_chat_id, "message_id": message_id, "to_chat_id": to_chat_id, "disable_notification": disable_notification}
+        response = await self.request("forwardMessage", data)
+        return MessageId.from_dict(response)
+    
+    async def delete_message(self, chat_id: str, message_id: str):
+        await self.request("deleteMessage", {"chat_id": chat_id, "message_id": message_id})
+    
+    async def remove_chat_keypad(self, chat_id: str):
+        await self.request("editChatKeypad", {"chat_id": chat_id, "chat_keypad_type": "Remove"})
+        
+    async def edit_chat_keypad(self, chat_id: str, chat_keypad):
+        await self.request("editChatKeypad", {"chat_id": chat_id, "chat_keypad_type": "New", "chat_keypad": chat_keypad})
+
+    async def edit_message_keypad(self, chat_id: str, message_id: str, inline_keypad):
+        await self.request("editMessageKeypad", {"chat_id": chat_id, "message_id": message_id, "inline_keypad": inline_keypad})
+    
+    async def edit_message_text(self, chat_id: str, message_id: str, text: str):
+        await self.request("editMessageText", {"chat_id": chat_id, "message_id": message_id, "text": text})
+    
+    async def 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.to_dict() if chat_keypad else None,
+            "inline_keypad": inline_keypad.to_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.from_dict(response)
+    
+    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.to_dict() if chat_keypad else None,
+            "inline_keypad": inline_keypad.to_dict() if inline_keypad else None,
+            "disable_notification": disable_notification,
+            "reply_to_message_id": reply_to_message_id,
+            "chat_keypad_type": chat_keypad_type
+        }
+        response = await self.request("sendPoll", data)
+        return MessageId.from_dict(response)
+    
+    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.to_dict() if chat_keypad else None,
+            "inline_keypad": inline_keypad.to_dict() if inline_keypad else None,
+            "disable_notification": disable_notification,
+            "reply_to_message_id": reply_to_message_id,
+            "chat_keypad_type": chat_keypad_type
+        }
+        response = await self.request("sendLocation", data)
+        return MessageId.from_dict(response)
+    
+    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.to_dict() if chat_keypad else None,
+            "inline_keypad": inline_keypad.to_dict() if inline_keypad else None,
+            "disable_notification": disable_notification,
+            "reply_to_message_id": reply_to_message_id,
+            "chat_keypad_type": chat_keypad_type
+        }
+        response = await self.request("sendContact", data)
+        return MessageId.from_dict(response)
+    
+    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.to_dict() if chat_keypad else None,
+            "inline_keypad": inline_keypad.to_dict() if inline_keypad else None,
+            "disable_notification": disable_notification,
+            "reply_to_message_id": reply_to_message_id,
+            "chat_keypad_type": chat_keypad_type
+        }
+        response = await self.request("sendSticker", data)
+        return MessageId.from_dict(response)
+    
+    async def request_send_file(self, type: str):
+        response = await self.request("requestSendFile", {"type": type})
+        return response["upload_url"]
+    
+    async def upload_file(self, file: str, name: str, type: str):
+        upload_url = await self.request_send_file(type)
+        response = await self.request_upload_file(upload_url, file, name)
+        return response
+    
+    
+    async def download_file(self, file_id: str, file_name: str):
+        download_url = await self.get_file(file_id)
+        response = await self.request_download_file(download_url, file_name)
+        return response
+    
+    async def send_file(
+        self,
+        chat_id: str,
+        file: str,
+        file_name: str,
+        type: Literal["File", "Image", "Voice", "Music", "Gif", "Video"] = "File",
+        chat_keypad: Keypad = None,
+        inline_keypad: Keypad = None,
+        chat_keypad_type: Literal["New", "Remove"] = None,
+        disable_notification: bool = False,
+        reply_to_message_id: str = None,
+    ) -> "MessageId":
+        file_id = await self.upload_file(file, file_name, type)
+        data = {
+            "chat_id": chat_id,
+            "file_id": file_id,
+            "chat_keypad": chat_keypad.to_dict() if chat_keypad else None,
+            "inline_keypad": inline_keypad.to_dict() if inline_keypad else None,
+            "disable_notification": disable_notification,
+            "reply_to_message_id": reply_to_message_id,
+            "chat_keypad_type": chat_keypad_type,
+        }
+        response = await self.request("sendFile", data)
+        return MessageId.from_dict(response)
+        
+        
+    async def send_document(
+        self,
+        chat_id: str,
+        document: str,
+        name: str,
+        chat_keypad: Keypad = None,
+        inline_keypad: Keypad = None,
+        chat_keypad_type: Literal["New", "Remove"] = None,
+        disable_notification: bool = False,
+        reply_to_message_id: str = None,
+    ) -> "MessageId":
+        file_id = await self.upload_file(document, name, "File")
+        data = {
+            "chat_id": chat_id,
+            "file_id": file_id,
+            "chat_keypad": chat_keypad.to_dict() if chat_keypad else None,
+            "inline_keypad": inline_keypad.to_dict() if inline_keypad else None,
+            "disable_notification": disable_notification,
+            "reply_to_message_id": reply_to_message_id,
+            "chat_keypad_type": chat_keypad_type,
+        }
+        response = await self.request("sendFile", data)
+        return MessageId.from_dict(response)
+    
+    async def send_photo(
+        self,
+        chat_id: str,
+        photo: str,
+        name: str,
+        chat_keypad: Keypad = None,
+        inline_keypad: Keypad = None,
+        chat_keypad_type: Literal["New", "Remove"] = None,
+        disable_notification: bool = False,
+        reply_to_message_id: str = None,
+    ) -> "MessageId":
+        file_id = await self.upload_file(photo, name, "Image")
+        data = {
+            "chat_id": chat_id,
+            "file_id": file_id,
+            "chat_keypad": chat_keypad.to_dict() if chat_keypad else None,
+            "inline_keypad": inline_keypad.to_dict() if inline_keypad else None,
+            "disable_notification": disable_notification,
+            "reply_to_message_id": reply_to_message_id,
+            "chat_keypad_type": chat_keypad_type,
+        }
+        response = await self.request("sendFile", data)
+        return MessageId.from_dict(response)
+    
+    async def send_video(
+        self,
+        chat_id: str,
+        video: str,
+        name: str,
+        chat_keypad: Keypad = None,
+        inline_keypad: Keypad = None,
+        chat_keypad_type: Literal["New", "Remove"] = None,
+        disable_notification: bool = False,
+        reply_to_message_id: str = None,
+    ) -> "MessageId":
+        file_id = await self.upload_file(video, name, "Video")
+        data = {
+            "chat_id": chat_id,
+            "file_id": file_id,
+            "chat_keypad": chat_keypad.to_dict() if chat_keypad else None,
+            "inline_keypad": inline_keypad.to_dict() if inline_keypad else None,
+            "disable_notification": disable_notification,
+            "reply_to_message_id": reply_to_message_id,
+            "chat_keypad_type": chat_keypad_type,
+        }
+        response = await self.request("sendFile", data)
+        return MessageId.from_dict(response)
+    
+    async def send_gif(
+        self,
+        chat_id: str,
+        gif: str,
+        name: str,
+        chat_keypad: Keypad = None,
+        inline_keypad: Keypad = None,
+        chat_keypad_type: Literal["New", "Remove"] = None,
+        disable_notification: bool = False,
+        reply_to_message_id: str = None,
+    ) -> "MessageId":
+        file_id = await self.upload_file(gif, name, "Gif")
+        data = {
+            "chat_id": chat_id,
+            "file_id": file_id,
+            "chat_keypad": chat_keypad.to_dict() if chat_keypad else None,
+            "inline_keypad": inline_keypad.to_dict() if inline_keypad else None,
+            "disable_notification": disable_notification,
+            "reply_to_message_id": reply_to_message_id,
+            "chat_keypad_type": chat_keypad_type,
+        }
+        response = await self.request("sendFile", data)
+        return MessageId.from_dict(response)
+    
+    async def send_music(
+        self,
+        chat_id: str,
+        music: str,
+        name: str,
+        chat_keypad: Keypad = None,
+        inline_keypad: Keypad = None,
+        chat_keypad_type: Literal["New", "Remove"] = None,
+        disable_notification: bool = False,
+        reply_to_message_id: str = None,
+    ) -> "MessageId":
+        file_id = await self.upload_file(music, name, "Music")
+        data = {
+            "chat_id": chat_id,
+            "file_id": file_id,
+            "chat_keypad": chat_keypad.to_dict() if chat_keypad else None,
+            "inline_keypad": inline_keypad.to_dict() if inline_keypad else None,
+            "disable_notification": disable_notification,
+            "reply_to_message_id": reply_to_message_id,
+            "chat_keypad_type": chat_keypad_type,
+        }
+        response = await self.request("sendFile", data)
+        return MessageId.from_dict(response)
+    
+    async def send_voice(
+        self,
+        chat_id: str,
+        voice: str,
+        name: str,
+        chat_keypad: Keypad = None,
+        inline_keypad: Keypad = None,
+        chat_keypad_type: Literal["New", "Remove"] = None,
+        disable_notification: bool = False,
+        reply_to_message_id: str = None,
+    ) -> "MessageId":
+        file_id = await self.upload_file(voice, name, "Voice")
+        data = {
+            "chat_id": chat_id,
+            "file_id": file_id,
+            "chat_keypad": chat_keypad.to_dict() if chat_keypad else None,
+            "inline_keypad": inline_keypad.to_dict() if inline_keypad else None,
+            "disable_notification": disable_notification,
+            "reply_to_message_id": reply_to_message_id,
+            "chat_keypad_type": chat_keypad_type,
+        }
+        response = await self.request("sendFile", data)
+        return MessageId.from_dict(response)

rubigramclient-1.4.1/rubigram/network.py

@@ -0,0 +1,58 @@
+from aiohttp import ClientSession, FormData
+from typing import Any, Optional, Dict, Union
+import aiofiles
+import re
+import os
+
+
+class Network:
+    def __init__(self, token: str) -> None:
+        self.token: str = token
+        self.session: Optional[ClientSession] = None
+        self.api: str = f"https://botapi.rubika.ir/v3/{self.token}/"
+
+    async def get_session(self) -> ClientSession:
+        if self.session is None or self.session.closed:
+            self.session = ClientSession()
+        return self.session
+
+    async def close(self) -> None:
+        if self.session and not self.session.closed:
+            await self.session.close()
+
+    async def request(self, method: str, json: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        session = await self.get_session()
+        async with session.post(self.api + method, json=json) as response:
+            response.raise_for_status()
+            data: dict = await response.json()
+            return data.get("data")
+
+    async def request_bytes_file(self, url: str) -> bytes:
+        session = await self.get_session()
+        async with session.get(url) as response:
+            response.raise_for_status()
+            return await response.read()
+
+    async def request_upload_file(self, upload_url: str, file: Union[str], name: str) -> str:
+        session = await self.get_session()
+
+        if isinstance(file, str) and re.match(r"^https?://", file):
+            file = await self.request_bytes_file(file)
+            
+        elif isinstance(file, str) and os.path.isfile(file):
+            async with aiofiles.open(file, "rb") as f:
+                file = await f.read()
+
+        form = FormData()
+        form.add_field("file", file, filename=name, content_type="application/octet-stream")
+
+        async with session.post(upload_url, data=form) as response:
+            response.raise_for_status()
+            data = await response.json()
+            return data["data"]["file_id"]
+        
+    async def request_download_file(self, url: str, name: str) -> dict[str, Union[str, bool]]:
+        file = await self.request_bytes_file(url)
+        async with aiofiles.open(name, "wb") as f:
+            await f.write(file)
+            return {"status": True, "file": name}

rubigramclient-1.4.1/rubigram/state.py

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