RubigramClient 1.6.6__tar.gz → 1.6.8__tar.gz

{rubigramclient-1.6.6 → rubigramclient-1.6.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: RubigramClient
-Version: 1.6.6
+Version: 1.6.8
 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.6 → rubigramclient-1.6.8}/README.md

@@ -15,7 +15,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()
 ```
@@ -66,5 +67,24 @@ async def main():
         data = await bot.get_me()
         print(data.bot_id)
 
+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.6 → rubigramclient-1.6.8}/RubigramClient.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: RubigramClient
-Version: 1.6.6
+Version: 1.6.8
 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.6 → rubigramclient-1.6.8}/RubigramClient.egg-info/SOURCES.txt

@@ -13,4 +13,6 @@ rubigram/filters.py
 rubigram/method.py
 rubigram/network.py
 rubigram/state.py
-rubigram/types.py
+rubigram/types.py
+rubigram/rubino/__init__.py
+rubigram/rubino/client.py

{rubigramclient-1.6.6 → rubigramclient-1.6.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "RubigramClient"
-version = "1.6.6"
+version = "1.6.8"
 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"

{rubigramclient-1.6.6 → rubigramclient-1.6.8}/rubigram/__init__.py

@@ -1,4 +1,5 @@
 from .client import Client
+from .rubino import Rubino
 from .state import StateManager
 from . import enums
 from . import filters

rubigramclient-1.6.8/rubigram/client.py

@@ -0,0 +1,160 @@
+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.web import Application, Request, json_response, run_app
+import asyncio
+import logging
+
+
+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):
+    def __init__(
+        self,
+        token: str,
+        endpoint: Optional[str] = None,
+        host: str = "0.0.0.0",
+        port: int = 8000
+    ):
+        self.token = token
+        self.endpoint = endpoint
+        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 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)
+            return func
+        return decorator
+
+    def on_inline_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.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"])
+        elif "update" in data:
+            event = Update.from_dict(data["update"])
+        else: return
+        event.client = self
+        await self.dispatch(event)
+        
+    async def set_endpoints(self):
+        endpoint_type = ["ReceiveUpdate", "ReceiveInlineMessage"]
+        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):
+        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: Request):
+            data = await request.json()
+            await self.updater(data)
+            return json_response({"status": "OK"})
+        return wrapper
+
+
+    async def update_runner(self):
+        try:
+            while True:
+                get_update = await self.get_update(100, self.offset_id)
+                updates = get_update.updates
+                if updates:
+                    for update in updates:
+                        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):
+                            update.client = self
+                            await self.dispatch(update)
+                    self.offset_id = get_update.next_offset_id
+        except Exception as error:
+            logging.error(error)
+        finally:
+            await self.stop()
+    
+    def run(self, set_endpoint = True):
+        self.set_endpoint = set_endpoint
+        if self.endpoint:
+            app = Application()
+            app.on_startup(self.on_startup)
+            app.on_cleanup(self.on_cleanup)
+            
+            app.router.add_post("/ReceiveUpdate", self.create_request_handler())
+            app.router.add_post("/ReceiveInlineMessage", self.create_request_handler())
+            
+            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:
+                logging.info("Start Bot")
+                asyncio.run(self.update_runner())
+            except KeyboardInterrupt:
+                logging.info("Stop Bot")
+            except Exception as error:
+                logging.error(error)

{rubigramclient-1.6.6 → rubigramclient-1.6.8}/rubigram/enums.py

@@ -126,4 +126,12 @@ class FileType(str, Enum):
     Video = "Video"
     Gif = "Gif"
     Music = "Music"
-    Voice = "Voice"
+    Voice = "Voice"
+    
+
+class ChatAction(str, Enum):
+    Typing = "Typing"
+    Uploading = "Uploading"
+    Recording = "Recording"
+    
+    

{rubigramclient-1.6.6 → rubigramclient-1.6.8}/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
 
 
@@ -49,6 +49,21 @@ class Method(Network):
 
     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 edit_message(
+        self,
+        chat_id: str,
+        message_id: str,
+        text: Optional[str] = None,
+        chat_keypad: Optional[Keypad] = None,
+        inline_keypad: Optional[Keypad] = None
+    ):
+        if text:
+            await self.edit_message_text(chat_id, message_id, text)
+        if chat_keypad:
+            await self.edit_chat_keypad(chat_id, chat_keypad)
+        if inline_keypad:
+            await self.edit_message_keypad(chat_id, message_id, inline_keypad)
 
     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}
@@ -195,30 +210,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 +252,58 @@ 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_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_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_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_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: 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: 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: 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)
+    
+    # async def get_messages(self, chat_id: str, message_ids: Optional[list[str]] = None):
+    #     return await self.request("getMessages", {"chat_id": chat_id, "message_ids": message_ids})
+        
+    # async def get_bot_command(self):
+    #     return await self.request("getBotCommands", {})
+    
+    # async def send_chat_action(self, chat_id: str, action: enums.ChatAction):
+    #     return await self.request("sendChatAction", {"chat_id": chat_id, "action": action})
+    
+    # async def set_username(self, username: str):
+    #     return await self.request("setUsername", {"username": username})
+    
+    async def get_bot_name(self):
+        bot = await self.get_me()
+        return bot.bot_title
 
-    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 get_bot_id(self):
+        bot = await self.get_me()
+        return bot.bot_id
+    
+    async def get_bot_username(self):
+        bot = await self.get_me()
+        return bot.username
+    
+    async def get_bot_share_url(self):
+        bot = await self.get_me()
+        return bot.share_url
+    
+    async def get_bot_descriptionl(self):
+        bot = await self.get_me()
+        return bot.description
+    
+    async def get_bot_start_messagel(self):
+        bot = await self.get_me()
+        return bot.start_message

rubigramclient-1.6.8/rubigram/network.py

@@ -0,0 +1,81 @@
+from aiohttp import ClientSession, FormData
+from typing import Any, Optional, Union
+from pathlib import Path
+from urllib.parse import urlparse
+from random import randint
+import aiofiles
+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/{token}/"
+
+    async def start(self):
+        if not self.session:
+            self.session = ClientSession()
+
+    async def stop(self):
+        if self.session:
+            await self.session.close()
+            self.session = None
+
+    async def __aenter__(self):
+        await self.start()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.stop()
+
+    async def request(self, method: str, json: dict[str, Any]):
+        await self.start()
+        async with self.session.post(self.api + method, json=json) as response:
+            response.raise_for_status()
+            data: dict = await response.json()
+            return data.get("data")
+
+    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 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):
+            path = Path(file)
+
+            if path.is_file():
+                data, filename = path.read_bytes(), name if name else path.name
+
+            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}")
+
+        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 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

rubigramclient-1.6.8/rubigram/rubino/__init__.py

@@ -0,0 +1 @@
+from .client import Rubino

rubigramclient-1.6.8/rubigram/rubino/client.py

@@ -0,0 +1,82 @@
+from aiohttp import ClientSession
+from typing import Literal, Optional, Union, Any
+from random import randint
+
+
+class Rubino:
+    def __init__(self, auth: str):
+        self.auth = auth
+        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 reauest(self, method: str, data: dict[str, Any]):
+        json = {
+            "api_version": "0",
+            "auth": self.auth,
+            "client": self.client,
+            "data": data,
+            "method": method
+        }
+        async with ClientSession() as session:
+            async with session.post(self.api, json=json) as response:
+                response.raise_for_status()
+                return await response.json()
+
+    
+    async def get_post_by_share_link(self, post_link: str):
+        return await self.reauest("getPostByShareLink", {"share_string": post_link.split("/")[-1]})
+    
+    
+    async def add_post_view_count(self, post_id: str, post_profile_id: str):
+        data = {"post_id": post_id, "post_profile_id": post_profile_id}
+        return await self.reauest("addPostViewCount", data)
+    
+    
+    async def add_view_story(self, story_profile_id: str, story_ids: Union[str, list[str]], profile_id: Optional[str] = None):
+        story_ids = story_ids if isinstance(story_ids, list) else [story_ids]
+        data = {"story_profile_id": story_profile_id, "story_ids": story_ids, "profile_id": profile_id}
+        return await self.reauest("addViewStory", data)
+    
+    
+    async def is_exist_username(self, username: str):
+        username = username.replace("@", "")
+        return await self.reauest("isExistUsername", {"username": username})
+    
+    
+    async def create_page(self, username: str, name: str, bio: Optional[str] = None):
+        return await self.reauest("createPage", {"username": username, "name": name, "bio": bio})
+    
+    
+    async def add_comment(self, content: str, post_id: str, post_profile_id: str, profile_id: Optional[str] = None):
+        rnd = randint(100000, 999999999)
+        data = {"content": content, "post_id": post_id, "post_profile_id": post_profile_id, "profile_id": profile_id, "rnd": rnd}
+        return await self.reauest("addComment", data)
+    
+    
+    async def request_follow(self, followee_id: str, f_type: Literal["Follow", "Unfollow"] = "Follow", profile_id: Optional[str] = None):
+        data = {"f_type": f_type, "followee_id": followee_id, "profile_id": profile_id}
+        return self.reauest("requestFollow", data)
+    
+    
+    async def set_block_profile(self, block_id: str, action: Literal["Block", "Unblock"] = "Block", profile_id: Optional[str] = None):
+        data = {"block_id": block_id, "action": action, "profile_id": profile_id}
+        return self.reauest("setBlockProfile", data)
+    
+    
+    async def get_comments(self, post_id: str, post_profile_id: str, limit: Optional[int] = 100, profile_id: Optional[str] = None):
+        data = {
+            "post_id": post_id,
+            "post_profile_id": post_profile_id,
+            "limit": limit,
+            "profile_id": profile_id,
+            "equal": False,
+            "sort": "FromMax"
+        }
+        return await self.reauest("getComments", data)