RubigramClient 1.7.17__py3-none-any.whl

rubigram/methods/utilities/dispatcher.py

@@ -0,0 +1,66 @@
+#  RubigramClient - Rubika API library for python
+#  Copyright (C) 2025-present Javad <https://github.com/DevJavad>
+#  Github - https://github.com/DevJavad/rubigram
+
+
+from typing import Union
+import rubigram
+
+
+class Dispatcher:
+    async def dispatcher(
+        self: "rubigram.Client",
+        update: Union["rubigram.types.Update", "rubigram.types.InlineMessage"]
+    ):
+        """
+        **Dispatch incoming updates to appropriate handlers.**
+            `await client.dispatcher(update)`
+
+        This method routes incoming updates to the correct handler functions
+        based on the update type. It supports both regular updates and
+        inline messages, and ensures that only one handler processes each update.
+
+        Args:
+            update (`Union[rubigram.types.Update, rubigram.types.InlineMessage]`):
+                The incoming update to dispatch to handlers.
+
+        Example:
+        .. code-block:: python
+
+            # This method is automatically called by the client
+            # when receiving updates from Rubigram
+
+            # Example update flow:
+            # 1. New message → message_handlers
+            # 2. Edited message → edit_message_handlers  
+            # 3. Deleted message → delete_message_handlers
+            # 4. Bot start → start_bot_handlers
+            # 5. Bot stop → stop_bot_handlers
+            # 6. Inline message → inline_message_handlers
+
+        Note:
+            - Stops after the first handler that returns True (indicating a match)
+            - Each update type has its own dedicated handler list
+            - Inline messages are processed separately from regular updates
+            - The order of handler registration matters (first match wins)
+        """
+        if isinstance(update, rubigram.types.InlineMessage):
+            handlers = self.inline_message_handlers
+
+        else:
+            type = update.type
+            if type == "NewMessage":
+                handlers = self.new_message_handlers
+            elif type == "UpdatedMessage":
+                handlers = self.update_message_handlers
+            elif type == "RemovedMessage":
+                handlers = self.remove_message_handlers
+            elif type == "StartedBot":
+                handlers = self.started_bot_handlers
+            elif type == "StoppedBot":
+                handlers = self.stopped_bot_handlers
+
+        for handler in handlers:
+            matched = await handler(self, update)
+            if matched:
+                return

rubigram/methods/utilities/run.py

@@ -0,0 +1,118 @@
+#  RubigramClient - Rubika API library for python
+#  Copyright (C) 2025-present Javad <https://github.com/DevJavad>
+#  Github - https://github.com/DevJavad/rubigram
+
+
+from datetime import datetime
+import asyncio
+import logging
+import rubigram
+
+
+logger = logging.getLogger(__name__)
+
+
+class Run:
+    """
+    Long-polling update receiver for Rubika Bot API.
+
+    This class provides methods for running the bot in long-polling mode,
+    continuously fetching updates from the API and dispatching them to
+    registered handlers. It includes timestamp validation to ensure only
+    recent updates are processed.
+
+    Note:
+        This class is typically used as a mixin or extension to the
+        Client class via monkey-patching or inheritance.
+
+    Example:
+    .. code-block:: python
+        # Monkey-patch the client with run methods
+        client = Client(token="YOUR_BOT_TOKEN")
+        client.receiver = Run.receiver.__get__(client, Client)
+        client.run = Run.run.__get__(client, Client)
+
+        # Run the bot in polling mode
+        client.run()
+    """
+
+    async def receiver(self: "rubigram.Client"):
+        """
+        Continuously receive and process updates via long-polling.
+
+        This method:
+        1. Starts the client
+        2. Enters an infinite loop to fetch updates
+        3. Validates update timestamps to prevent replay attacks
+        4. Dispatches valid updates to handlers
+        5. Manages the update offset for incremental fetching
+        6. Stops the client on error or exit
+
+        Workflow:
+            - Fetches up to 100 updates at a time
+            - Validates that message timestamps are recent (within 2 seconds)
+            - Sets the client on each update for handler access
+            - Updates the offset to avoid processing the same update twice
+            - Continues polling until an error occurs
+
+        Note:
+            Timestamp validation ensures updates are not older than 2 seconds
+            from current time to prevent processing delayed or replayed messages.
+
+        Raises:
+            Exception: Any error during update fetching or processing.
+
+        Example:
+        .. code-block:: python
+            # Manual receiver usage
+            await client.receiver()
+        """
+        await self.start()
+        try:
+            while True:
+                updates = await self.get_updates(100, self.offset_id)
+                if updates.updates:
+                    for update in updates.updates:
+                        time = update.update_time
+                        now = int(datetime.now().timestamp())
+                        if time and (time >= now or time + 2 >= now):
+                            logger.debug("New Event, type: %s", update.type)
+                            update.client = self
+                            await self.dispatcher(update)
+
+                        self.offset_id = updates.next_offset_id
+        finally:
+            await self.stop()
+
+    def run(self: "rubigram.Client"):
+        """
+        Run the bot in long-polling mode (blocking call).
+
+        This method:
+        1. Creates and runs an asyncio event loop
+        2. Executes the receiver method
+        3. Handles KeyboardInterrupt for graceful shutdown
+        4. Closes the event loop on exit
+
+        Note:
+            This is a blocking method that runs indefinitely until
+            interrupted by Ctrl+C or a fatal error.
+
+        Example:
+        .. code-block:: python
+            # Simple bot runner
+            client = Client(token="YOUR_BOT_TOKEN")
+            client.run = Run.run.__get__(client, Client)
+            client.run()  # Blocks here
+        """
+        try:
+            logger.info(
+                "Run rubigram client, token: %s",
+                self.token[:20] + "*" * max(0, len(self.token) - 20)
+            )
+            asyncio.run(self.receiver())
+        except KeyboardInterrupt:
+            logger.info(
+                "Stop Runing rubigram client, token: %s",
+                self.token[:20] + "*" * max(0, len(self.token) - 20)
+            )

rubigram/rubino/__init__.py

@@ -0,0 +1,6 @@
+#  RubigramClient - Rubika API library for python
+#  Copyright (C) 2025-present Javad <https://github.com/DevJavad>
+#  Github - https://github.com/DevJavad/rubigram
+
+
+from .client import Rubino

rubigram/rubino/client.py

@@ -0,0 +1,374 @@
+#  RubigramClient - Rubika API library for python
+#  Copyright (C) 2025-present Javad <https://github.com/DevJavad>
+#  Github - https://github.com/DevJavad/rubigram
+
+
+from typing import Optional, Literal, Union
+from .network import Network
+from random import randint
+
+
+class Rubino(Network):
+    def __init__(
+        self,
+        auth: str,
+        timeout: float = 30.0,
+        connect_timeout: float = 10.0,
+        read_timeout: float = 20.0,
+        max_connections: int = 100
+    ):
+        super().__init__(auth, timeout, connect_timeout, read_timeout, max_connections)
+
+    def rnd(self):
+        return randint(100000, 999999999)
+
+    async def app_post(
+        self,
+        file: str,
+        caption: Optional[str] = None,
+        post_type: Literal["Picture", "Video"] = "Picture",
+        profile_id: Optional[str] = None,
+        file_name: Optional[str] = None,
+        is_multi_file: Optional[str] = None,
+    ):
+        request = await self.request_upload(file, post_type, file_name, profile_id)
+        file_id, hash_file_receive = request["file_id"], request["hash_file_receive"]
+        data = {
+            "caption": caption,
+            "file_id": file_id,
+            "hash_file_receive": hash_file_receive,
+            "height": 800,
+            "width": 800,
+            "is_multi_file": is_multi_file,
+            "post_type": post_type,
+            "rnd": self.rnd(),
+            "thumbnail_file_id": file_id,
+            "thumbnail_hash_file_receive": hash_file_receive,
+            "profile_id": profile_id
+        }
+        return await self.request("addPost", data)
+
+    async def get_post_by_share_link(self, post_link: str):
+        return await self.request("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.request("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.request("addViewStory", data)
+
+    async def is_exist_username(self, username: str):
+        return await self.request("isExistUsername", {"username": username.replace("@", "")})
+
+    async def create_page(self, username: str, name: str, bio: Optional[str] = None):
+        return await self.request("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):
+        data = {
+            "content": content,
+            "post_id": post_id,
+            "post_profile_id": post_profile_id,
+            "profile_id": profile_id,
+            "rnd": self.rnd()
+        }
+        return await self.request("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.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)
+
+    async def unfollow(self, followee_id: str, profile_id: Optional[str] = None):
+        return await self.request_follow(followee_id, "Unfollow", profile_id)
+
+    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.request("setBlockProfile", data)
+
+    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)
+
+    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.request("getComments", data)
+
+    async def get_my_profile_info(self, profile_id: Optional[str] = None):
+        return await self.request("getMyProfileInfo", {"profile_id": profile_id})
+
+    async def get_profile_list(self, limit: Optional[int] = 10):
+        data = {
+            "limit": limit,
+            "equal": False,
+            "sort": "FromMax"
+        }
+        return await self.request("getProfileList", data)
+
+    async def get_profile_stories(self, profile_id: Optional[str] = None, limit: Optional[int] = 10):
+        return self.request("getProfileStories", {"limit": limit, "profile_id": profile_id})
+
+    async def get_recent_following_posts(self, profile_id: Optional[str] = None, limit: Optional[int] = 10):
+        data = {
+            "limit": limit,
+            "equal": False,
+            "sort": "FromMax",
+            "profile_id": profile_id
+        }
+        return await self.request("getRecentFollowingPosts", data)
+
+    async def get_share_link(self, post_id: str, target_profile_id: str, profile_id: Optional[str] = None):
+        return await self.request("getShareLink", {"post_id": post_id, "target_profile_id": target_profile_id, "profile_id": profile_id})
+
+    async def get_story_id(self, post_profile_id: str, profile_id: Optional[str] = None):
+        return await self.request("getStoryIds", {"post_profile_id": post_profile_id, "profile_id": profile_id})
+
+    async def save_post(self, post_id: str, target_profile_id: str, profile_id: Optional[str] = None):
+        data = {
+            "action_type": "Bookmark",
+            "post_id": post_id,
+            "target_profile_id": target_profile_id,
+            "profile_id": profile_id
+        }
+        return await self.request("postBookmarkAction", data)
+
+    async def unsave_post(self, post_id: str, post_profile_id: str, profile_id: Optional[str] = None):
+        data = {
+            "action_type": "Unbookmark",
+            "post_id": post_id,
+            "post_profile_id": post_profile_id,
+            "profile_id": profile_id
+        }
+        return await self.request("postBookmarkAction", data)
+
+    async def update_profile(self, profile_id: Optional[str] = None):
+        data = {
+            "profile_id": profile_id,
+            "profile_status": "Public"
+        }
+        return await self.request("updateProfile", data)
+
+    async def like_post(self, post_id: str, target_profile_id: str, profile_id: Optional[str] = None):
+        data = {
+            "action_type": "Like",
+            "post_id": post_id,
+            "target_profile_id": target_profile_id,
+            "profile_id": profile_id
+        }
+        return await self.request("likePostAction", data)
+
+    async def unlike_post(self, post_id: str, target_profile_id: str, profile_id: Optional[str] = None):
+        data = {
+            "action_type": "Unlike",
+            "post_id": post_id,
+            "target_profile_id": target_profile_id,
+            "profile_id": profile_id
+        }
+        return await self.request("likePostAction", data)
+
+    async def like_comment(self, comment_id: str, post_id: str, profile_id: Optional[str] = None):
+        data = {
+            "action_type": "Like",
+            "comment_id": comment_id,
+            "post_id": post_id,
+            "profile_id": profile_id
+        }
+        return await self.request("likeCommentAction", data)
+
+    async def unlike_comment(self, comment_id: str, post_id: str, profile_id: Optional[str] = None):
+        data = {
+            "action_type": "Unlike",
+            "comment_id": comment_id,
+            "post_id": post_id,
+            "profile_id": profile_id
+        }
+        return await self.request("likeCommentAction", data)
+
+    async def get_saved_posts(self, limit: int = 10, profile_id: Optional[str] = None):
+        data = {
+            "equal": False,
+            "limit": limit,
+            "sort": "FromMax",
+            "profile_id": profile_id
+        }
+        return await self.request("getBookmarkedPosts", data)
+
+    async def get_archive_stories(self, limit: int = 10, start_id: Optional[str] = None, profile_id: Optional[str] = None):
+        data = {
+            "equal": False,
+            "limit": limit,
+            "start_id": start_id,
+            "sort": "FromMax",
+            "profile_id": profile_id
+        }
+        return await self.request("getMyArchiveStories", data)
+
+    async def get_profile_highlights(self, target_profile_id: str, limit: int = 10, profile_id: Optional[str] = None):
+        data = {
+            "equal": False,
+            "limit": limit,
+            "sort": "FromMax",
+            "target_profile_id": target_profile_id,
+            "profile_id": profile_id
+        }
+        return await self.request("getProfileHighlights", data)
+
+    async def get_blocked_profiles(self, limit: int = 50, max_id: Optional[str] = None, profile_id: Optional[str] = None):
+        data = {
+            "equal": False,
+            "limit": limit,
+            "max_id": max_id,
+            "sort": "FromMax",
+            "profile_id": profile_id
+        }
+        return await self.request("getBlockedProfiles", data)
+
+    async def get_profile_following(self, target_profile_id: str, limit: int = 50, profile_id: Optional[str] = None):
+        data = {
+            "equal": False,
+            "f_type": "Following",
+            "limit": limit,
+            "sort": "FromMax",
+            "target_profile_id": target_profile_id,
+            "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,
+            "f_type": "Follower",
+            "limit": limit,
+            "sort": "FromMax",
+            "target_profile_id": target_profile_id,
+            "profile_id": profile_id
+        }
+        return await self.request("getProfileFollowers", data)
+
+    async def get_my_stories_list(self, limit: Optional[int] = None, profile_id: Optional[str] = None):
+        data = {
+            "limit": limit,
+            "profile_id": profile_id
+        }
+        return await self.request("getMyStoriesList", data)
+
+    async def delete_story(self, story_id: str, profile_id: Optional[str] = None):
+        data = {
+            "profile_id": profile_id,
+            "story_id": story_id
+        }
+        return await self.request("deleteStory", data)
+
+    async def get_explore_posts(self, topic_id: str, limit: int = 50, max_id: Optional[str] = None, profile_id: Optional[str] = None):
+        data = {
+            "equal": False,
+            "limit": limit,
+            "max_id": max_id,
+            "sort": "FromMax",
+            "topic_id": topic_id,
+            "profile_id": profile_id
+        }
+        return await self.request("getExplorePosts", data)
+
+    async def search_profile(self, username: str, limit: int = 50, profile_id: Optional[str] = None):
+        data = {
+            "equal": False,
+            "limit": limit,
+            "sort": "FromMax",
+            "username": username.replace("@", ""),
+            "profile_id": profile_id
+        }
+        return await self.request("searchProfile", data)
+
+    async def search_in_rubino(self, username: str, limit: int = 50, profile_id: Optional[str] = None):
+        data = {
+            "equal": False,
+            "limit": limit,
+            "sort": "FromMax",
+            "username": username.startswith("@"),
+            "profile_id": profile_id
+        }
+        return await self.request("searchProfile", data)
+
+    async def get_hashtag_trend(self, limit: int = 50, profile_id: Optional[str] = None):
+        data = {
+            "equal": False,
+            "limit": limit,
+            "sort": "FromMax",
+            "profile_id": profile_id
+        }
+        return await self.request("getHashTagTrend", data)
+
+    async def search_hashtag(self, content: str, limit: int = 50, profile_id: Optional[str] = None):
+        data = {
+            "content": content,
+            "equal": False,
+            "limit": limit,
+            "sort": "FromMax",
+            "profile_id": profile_id
+        }
+        return await self.request("searchHashTag", data)
+
+    async def get_posts_by_hashtag(self, hashtag: str, limit: int = 50, profile_id: Optional[str] = None):
+        data = {
+            "equal": False,
+            "hashtag": hashtag,
+            "limit": limit,
+            "profile_id": profile_id
+        }
+        return await self.request("getPostsByHashTag", data)
+
+    async def remove_page(self, profile_id: str, record_id: str):
+        data = {
+            "model": "Profile",
+            "record_id": record_id,
+            "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,
+            "limit": limit,
+            "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,
+            "request_id": request_id,
+            "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)
+
+    async def reject_request(self, request_id: str, profile_id: Optional[str] = None):
+        return await self.action_on_request(request_id, profile_id, "Decline")

rubigram/rubino/network.py

@@ -0,0 +1,129 @@
+#  RubigramClient - Rubika API library for python
+#  Copyright (C) 2025-present Javad <https://github.com/DevJavad>
+#  Github - https://github.com/DevJavad/rubigram
+
+
+from typing import Optional, Any
+from aiohttp import FormData
+from ..http_session import HttpSession
+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: float = 30.0,
+        connect_timeout: float = 10.0,
+        read_timeout: float = 20.0,
+        max_connections: int = 100
+    ):
+        self.auth = auth
+        self.http = HttpSession(timeout, connect_timeout, read_timeout, max_connections)
+        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 get_bytes(self, url: str) -> bytes:
+        async with self.http.session.get(url) as response:
+            response.raise_for_status()
+            return await response.read()
+
+    async def get_name(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 request_upload(
+        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.get_bytes(file)
+            file_name = file_name if file_name else await self.get_name(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}