RubigramClient 1.7.1__py3-none-any.whl → 1.7.3__py3-none-any.whl

rubigram/method/utilities/dispatch.py

@@ -0,0 +1,25 @@
+from typing import Union
+import rubigram
+
+
+class Dispatch:
+    async def dispatch(
+        self: "rubigram.Client",
+        update: Union[
+            "rubigram.types.Update",
+            "rubigram.types.InlineMessage"
+        ]
+    ):
+        if isinstance(update, rubigram.types.InlineMessage):
+            event_type = "inline"
+        else:
+            match update.type:
+                case "NewMessage": event_type = "message"
+                case "UpdatedMessage": event_type = "edit"
+                case "RemovedMessage": event_type = "delete"
+                case other:
+                    return
+
+        for handler in self.handlers[event_type]:
+            if handler.filters is None or await handler.filters(update):
+                await handler.func(self, update)

rubigram/method/utilities/setup_endpoint.py

@@ -0,0 +1,16 @@
+import rubigram
+from ...logger import logger
+
+
+class SetupEndpoints:
+    async def setup_endpoints(self: "rubigram.Client"):
+        endpoint_types = [
+            "ReceiveUpdate",
+            "ReceiveInlineMessage"
+        ]
+        for endpoint_type in endpoint_types:
+            setup = await self.update_bot_endpoints(
+                "{}/{}".format(self.endpoint, endpoint_type),
+                endpoint_type
+            )
+            logger.info("[<] set endpoint for {} : {}".format(endpoint_type, setup["status"]))

rubigram/method/utilities/updater.py

@@ -0,0 +1,17 @@
+import rubigram
+
+
+class Updater:
+    async def updater(
+        self: "rubigram.Client",
+        data: dict
+    ):
+        if "inline_message" in data:
+            event = rubigram.types.InlineMessage.parse(data["inline_message"])
+        elif "update" in data:
+            event = rubigram.types.Update.parse(data["update"])
+        else:
+            return
+
+        event.client = self
+        await self.dispatch(event)

rubigram/rubino/client.py

@@ -1,130 +1,16 @@
-from typing import Literal, Optional, Union, Any
-from aiohttp import ClientSession, FormData
-from urllib.parse import urlparse
+from typing import Optional, Literal, Union
+from .network import Network
 from random import randint
-from pathlib import Path
-from json import loads
-import os
-
-
-class Http:
-    def __init__(self, auth: str):
-        self.auth = auth
-        self.session: Optional[ClientSession] = None
-        self.api = f"https://rubino{randint(1, 30)}.iranlms.ir"
-        self.client = {
-            "app_name": "Main",
-            "app_version": "3.0.2",
-            "lang_code": "fa",
-            "package": "app.rbmain.a",
-            "platform": "Android"
-        }
-
-    async def connect(self):
-        if self.session is None:
-            self.session = ClientSession()
-
-    async def disconnect(self):
-        if self.session:
-            await self.session.close()
-            self.session = None
-
-    async def __aenter__(self):
-        await self.connect()
-        return self
-
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
-        await self.disconnect()
-
-    async def request(self, method: str, data: dict[str, Any]):
-        await self.connect()
-        json = {
-            "api_version": "0",
-            "auth": self.auth,
-            "client": self.client,
-            "data": data,
-            "method": method
-        }
-        async with self.session.post(self.api, json=json) as response:
-            response.raise_for_status()
-            return await response.json()
-
-    async def getBytes(self, url: str) -> bytes:
-        await self.connect()
-        async with self.session.get(url) as response:
-            response.raise_for_status()
-            return await response.read()
-
-    async def getName(self, url: str) -> str:
-        parser = urlparse(url)
-        return os.path.basename(parser.path)
-
-    async def request_upload_file(
-        self,
-        file_name: str,
-        file_size: str,
-        file_type: str,
-        profile_id: str,
-    ):
-        data = {
-            "file_name": file_name,
-            "file_size": file_size,
-            "file_type": file_type,
-            "profile_id": profile_id,
-        }
-        return await self.request("requestUploadFile", data)
 
-    async def requestUpload(
+
+class Rubino(Network):
+    def __init__(
         self,
-        file: str,
-        file_type: str,
-        file_name: Optional[str] = None,
-        profile_id: Optional[str] = None,
+        auth: str,
+        timeout: float = 30
     ):
-        path = Path(file)
-        if path.is_file():
-            data = path.read_bytes()
-            file_name = file_name if file_name else path.name
-            file_size = path.stat().st_size
-
-        elif file.startswith("http"):
-            data = await self.getBytes(file)
-            file_name = file_name if file_name else await self.getName(file)
-            file_size = len(data)
-
-        else:
-            raise Exception(f"Can't find this file : {file}")
-
-        request = await self.request_upload_file(file_name, file_size, file_type, profile_id)
-        request: dict[str, str] = request["data"]
-
-        file_id: str = request["file_id"]
-        hash_file_request: str = request["hash_file_request"]
-        server_url: str = request["server_url"]
-
-        headers = {
-            "auth": self.auth,
-            "chunk-size": str(file_size),
-            "file-id": file_id,
-            "hash-file-request": hash_file_request,
-            "content-length": str(file_size),
-            "part-number": "1",
-            "total-part": "1"
-        }
-        form = FormData()
-        form.add_field(
-            "file", data, filename=file_name, content_type="application/octet-stream"
-        )
-        async with self.session.post(server_url, data=form, headers=headers) as response:
-            text = await response.text()
-            hash_file_receive = loads(text)["data"]["hash_file_receive"]
-            return {"file_id": file_id, "hash_file_receive": hash_file_receive}
-
-
-class Rubino(Http):
-    def __init__(self, auth: str):
-        super().__init__(auth)
-    
+        super().__init__(auth, timeout)
+
     def rnd(self):
         return randint(100000, 999999999)
 
@@ -193,7 +79,7 @@ class Rubino(Http):
             "profile_id": profile_id
         }
         return self.request("requestFollow", data)
-    
+
     async def follow(self, followee_id: str, profile_id: Optional[str] = None):
         return await self.request_follow(followee_id, "Follow", profile_id)
 
@@ -210,7 +96,7 @@ class Rubino(Http):
 
     async def block_profile(self, block_id: str, profile_id: Optional[str] = None):
         return await self.set_block_profile(block_id, "Block", profile_id)
-    
+
     async def unblock_profile(self, block_id: str, profile_id: Optional[str] = None):
         return await self.set_block_profile(block_id, "Unblock", profile_id)
 
@@ -364,7 +250,7 @@ class Rubino(Http):
             "profile_id": profile_id
         }
         return await self.request("getProfileFollowers", data)
-    
+
     async def get_profile_followers(self, target_profile_id: str, limit: int = 50, profile_id: Optional[str] = None):
         data = {
             "equal": False,
@@ -448,7 +334,7 @@ class Rubino(Http):
             "profile_id": profile_id
         }
         return await self.request("getPostsByHashTag", data)
-    
+
     async def remove_page(self, profile_id: str, record_id: str):
         data = {
             "model": "Profile",
@@ -456,7 +342,7 @@ class Rubino(Http):
             "profile_id": profile_id
         }
         return await self.request("removeRecord", data)
-    
+
     async def get_new_follow_requests(self, profile_id: Optional[str] = None, limit: Optional[int] = 20):
         data = {
             "profile_id": profile_id,
@@ -464,7 +350,7 @@ class Rubino(Http):
             "sort": "FromMax"
         }
         return await self.request("getNewFollowRequests", data)
-        
+
     async def action_on_request(self, request_id: str, profile_id: Optional[str] = None, action: Literal["Accept", "Decline"] = "Accept"):
         data = {
             "action": action,
@@ -472,7 +358,7 @@ class Rubino(Http):
             "profile_id": profile_id
         }
         return await self.request("actionOnRequest", data)
-    
+
     async def accept_request(self, request_id: str, profile_id: Optional[str] = None):
         return await self.action_on_request(request_id, profile_id)
 

rubigram/rubino/network.py

@@ -0,0 +1,121 @@
+from typing import Optional, Any
+from aiohttp import FormData
+from ..http import Http
+from urllib.parse import urlparse
+from random import randint
+from pathlib import Path
+from json import loads
+import os
+
+
+class Network:
+    def __init__(
+        self,
+        auth: str,
+        timeout: Optional[float] = 30
+    ):
+        self.auth = auth
+        self.http = Http(timeout)
+        self.api = f"https://rubino{randint(1, 30)}.iranlms.ir"
+        self.client = {
+            "app_name": "Main",
+            "app_version": "3.0.2",
+            "lang_code": "fa",
+            "package": "app.rbmain.a",
+            "platform": "Android"
+        }
+
+    async def start(self):
+        await self.http.connect()
+
+    async def stop(self):
+        await self.http.disconnect()
+
+    async def __aenter__(self):
+        await self.start()
+        return self
+
+    async def __aexit__(self, *args):
+        await self.stop()
+
+    async def request(self, method: str, data: dict[str, Any]):
+        json = {
+            "api_version": "0",
+            "auth": self.auth,
+            "client": self.client,
+            "data": data,
+            "method": method
+        }
+        async with self.http.session.post(self.api, json=json) as response:
+            response.raise_for_status()
+            return await response.json()
+
+    async def getBytes(self, url: str) -> bytes:
+        async with self.http.session.get(url) as response:
+            response.raise_for_status()
+            return await response.read()
+
+    async def getName(self, url: str) -> str:
+        parser = urlparse(url)
+        return os.path.basename(parser.path)
+
+    async def request_upload_file(
+        self,
+        file_name: str,
+        file_size: str,
+        file_type: str,
+        profile_id: str,
+    ):
+        data = {
+            "file_name": file_name,
+            "file_size": file_size,
+            "file_type": file_type,
+            "profile_id": profile_id,
+        }
+        return await self.request("requestUploadFile", data)
+
+    async def requestUpload(
+        self,
+        file: str,
+        file_type: str,
+        file_name: Optional[str] = None,
+        profile_id: Optional[str] = None,
+    ):
+        path = Path(file)
+        if path.is_file():
+            data = path.read_bytes()
+            file_name = file_name if file_name else path.name
+            file_size = path.stat().st_size
+
+        elif file.startswith("http"):
+            data = await self.getBytes(file)
+            file_name = file_name if file_name else await self.getName(file)
+            file_size = len(data)
+
+        else:
+            raise Exception(f"Can't find this file : {file}")
+
+        request = await self.request_upload_file(file_name, file_size, file_type, profile_id)
+        request: dict[str, str] = request["data"]
+
+        file_id: str = request["file_id"]
+        hash_file_request: str = request["hash_file_request"]
+        server_url: str = request["server_url"]
+
+        headers = {
+            "auth": self.auth,
+            "chunk-size": str(file_size),
+            "file-id": file_id,
+            "hash-file-request": hash_file_request,
+            "content-length": str(file_size),
+            "part-number": "1",
+            "total-part": "1"
+        }
+        form = FormData()
+        form.add_field(
+            "file", data, filename=file_name, content_type="application/octet-stream"
+        )
+        async with self.http.session.post(server_url, data=form, headers=headers) as response:
+            text = await response.text()
+            hash_file_receive = loads(text)["data"]["hash_file_receive"]
+            return {"file_id": file_id, "hash_file_receive": hash_file_receive}

rubigram/state.py

@@ -1,35 +1,30 @@
 from typing import Any
 
-class StateManager:
+
+class state:
     def __init__(self):
-        self.DATA: dict[str, dict[str, Any]] = {}
-        self.STATE: dict[str, str] = {}
+        self.data: dict[str, dict[str, Any]] = {}
+        self.state: dict[str, str] = {}
 
-        
     async def set_state(self, user_id: str, state: str):
-        self.STATE[user_id] = state
-    
-    
+        self.state[user_id] = state
+
     async def get_state(self, user_id: str):
-        return self.STATE.get(user_id)
+        return self.state.get(user_id)
 
-    
     async def remove_state(self, user_id: str):
-        self.STATE.pop(user_id, None)
+        self.state.pop(user_id, None)
 
-        
     async def set_data(self, user_id: str, **data):
-        if user_id not in self.DATA:
-            self.DATA[user_id] = {}
-        self.DATA[user_id].update(data)
+        if user_id not in self.data:
+            self.data[user_id] = {}
+        self.data[user_id].update(data)
 
-    
     async def get_data(self, user_id: str, key: str = None):
-        data = self.DATA.get(user_id, {})
+        data = self.data.get(user_id, {})
         return data.get(key) if key else data
 
-
     async def remove_data(self, user_id: str, key: str = None):
         if key:
-            return self.DATA.get(user_id, {}).pop(key, None)
-        return self.DATA.pop(user_id, None)
+            return self.data.get(user_id, {}).pop(key, None)
+        return self.data.pop(user_id, None)

rubigram/types/__init__.py

@@ -0,0 +1,3 @@
+from .types import *
+from .messages import *
+from .updates import *

rubigram/types/messages.py

@@ -0,0 +1,175 @@
+from typing import Optional
+from dataclasses import dataclass
+from .object import Object
+from .types import *
+import rubigram
+
+
+@dataclass
+class Message(Object):
+    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
+    client: Optional["rubigram.Client"] = None
+
+
+@dataclass
+class InlineMessage(Object):
+    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
+    client: Optional["rubigram.Client"] = None
+
+
+@dataclass
+class UMessage(Object):
+    message_id: Optional[str] = None
+    file_id: Optional[str] = None
+    chat_id: Optional[str] = None
+    client: Optional["rubigram.Client"] = None
+
+    async def delete(self):
+        """Delete this message from the chat.
+
+        Sends a request to Rubigram to remove the message identified
+        by this object's `message_id` from its chat.
+
+        Args:
+            self (UMessage): The message instance to be deleted.
+
+        Returns:
+            bool: True if the message was successfully deleted, False otherwise.
+
+        Example:
+            >>> message = await client.send_message(chat_id="b0X123", text="Hello!")
+            >>> await message.delete()
+        """
+        return await self.client.delete_message(
+            self.chat_id, self.message_id
+        )
+
+    async def edit(
+        self,
+        text: Optional[str] = None,
+        inline: Optional[Keypad] = None,
+        keypad: Optional[Keypad] = None
+    ):
+        """Edit this message's content, inline keyboard, or chat keypad.
+
+        This method allows modifying the text, inline keyboard, or chat keypad
+        of the current message. You can use any combination of parameters to
+        update different parts of the message.
+
+        Args:
+            self (UMessage): The message instance to edit.
+            text (Optional[str], optional): New text content for the message. Defaults to None.
+            inline (Optional[Keypad], optional): Inline keyboard to attach to the message. Defaults to None.
+            keypad (Optional[Keypad], optional): Chat keypad to attach to the message. Defaults to None.
+
+        Returns:
+            None
+
+        Example:
+            >>> message = await client.send_message(chat_id="b0X123", text="Hello!")
+            >>> await message.edit(text="Updated text")
+            >>> await message.edit(inline=my_inline_keypad)
+            >>> await message.edit(keypad=my_chat_keypad)
+        """
+        if text:
+            await self.edit_text(text)
+        if inline:
+            await self.edit_inline(inline)
+        if keypad:
+            await self.edit_keypad(keypad)
+
+    async def edit_text(self, text: str):
+        """Edit the text content of this message.
+
+        Args:
+            self (UMessage): The message instance to edit.
+            text (str): New text to replace the current message content.
+
+        Returns:
+            UMessage: The updated message object returned by the client.
+
+        Example:
+            >>> await message.edit_text("Updated text content")
+        """
+        return await self.client.edit_message_text(
+            self.chat_id,
+            self.message_id,
+            text
+        )
+
+    async def edit_inline(self, inline: Keypad):
+        """Edit the inline keyboard of this message.
+
+        Args:
+            self (UMessage): The message instance to edit.
+            inline (Keypad): New inline keyboard to attach to the message.
+
+        Returns:
+            UMessage: The updated message object returned by the client.
+
+        Example:
+            >>> await message.edit_inline(my_inline_keypad)
+        """
+        return await self.client.edit_message_keypad(
+            self.chat_id,
+            self.message_id,
+            inline
+        )
+
+    async def edit_keypad(self, keypad: Keypad):
+        """Edit the chat keypad for this message's chat.
+
+        Args:
+            self (UMessage): The message instance whose chat keypad will be edited.
+            keypad (Keypad): New chat keypad to attach.
+
+        Returns:
+            UMessage: The updated message object returned by the client.
+
+        Example:
+            >>> await message.edit_keypad(my_chat_keypad)
+        """
+        return await self.client.edit_chat_keypad(
+            self.chat_id,
+            keypad
+        )
+
+    async def forward(self, chat_id: str):
+        """Forward this message to another chat.
+
+        Args:
+            self (UMessage): The message instance to forward.
+            chat_id (str): ID of the chat to forward the message to.
+
+        Returns:
+            UMessage: The forwarded message object returned by the client.
+
+        Example:
+            >>> await message.forward("b0AnotherChat")
+        """
+        return await self.client.forward_message(
+            self.chat_id,
+            self.message_id,
+            chat_id
+        )