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

rubigram/client.py

@@ -36,6 +36,8 @@ class Client(Method):
         self.ROUTES = []
         self.MESSAGE_HANDLER = []
         self.INLINE_HANDLER = []
+        self.EDIT_HANDLER = []
+        self.DELETE_HANDLER = []
         self.state = StateManager()
         super().__init__(token)
         
@@ -61,6 +63,28 @@ class Client(Method):
             self.INLINE_HANDLER.append(wrapper)
             return func
         return decorator
+    
+    def on_edit_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.EDIT_HANDLER.append(wrapper)
+            return func
+        return decorator
+    
+    def on_delete_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.DELETE_HANDLER.append(wrapper)
+            return func
+        return decorator
 
     def on_create_app(self, path: str, method: str = "GET"):
         def decorator(func):
@@ -69,7 +93,19 @@ class Client(Method):
         return decorator
     
     async def dispatch(self, update: Union[Update, InlineMessage]):
-        handlers = self.MESSAGE_HANDLER if isinstance(update, Update) else self.INLINE_HANDLER
+        if isinstance(update, InlineMessage):
+            handlers = self.INLINE_HANDLER
+        else:
+            type = update.type
+            if type == "NewMessage":
+                handlers = self.MESSAGE_HANDLER
+            elif type == "UpdatedMessage":
+                handlers = self.EDIT_HANDLER
+            elif type == "RemovedMessage":
+                handlers = self.DELETE_HANDLER
+            else:
+                logging.warning("Update type invalid : {}".format(type))
+
         for handler in handlers:
             matched = await handler(self, update)
             if matched:

rubigram/filters.py

@@ -25,7 +25,7 @@ class Filter:
 
 async def TEXT(message: Update):
     if isinstance(message, Update):
-        return True if message.new_message and message.new_message.text else False
+        return True if message.new_message and message.new_message.text or message.updated_message.text else False
     return False
 
 async def FILE(message: Update):
@@ -126,8 +126,12 @@ class command(Filter):
         super().__init__(self.filter)
 
     async def filter(self, update: Update):
-        if isinstance(update, Update) and update.type == "NewMessage":
-            text = update.new_message.text or ""
+        if isinstance(update, Update):
+            if update.new_message:
+                text = update.new_message.text
+            elif update.updated_message:
+                text = update.updated_message.text
+            else: return False
             text = text if self.case_sensitive else text.lower()
             return any(text.startswith(cmd) for cmd in self.cmds)
         return False
@@ -163,9 +167,7 @@ class regex(Filter):
         elif isinstance(update, InlineMessage):
             text = getattr(update, "text", "")
 
-        if text:
-            return bool(re.search(self.pattern, text))
-        return False
+        return bool(re.search(self.pattern, text)) if text else False
 
 
 class chat(Filter):

rubigram/method.py

@@ -36,19 +36,19 @@ class Method(Network):
         return response
 
     async def delete_message(self, chat_id: str, message_id: str):
-        await self.request("deleteMessage", {"chat_id": chat_id, "message_id": message_id})
+        return 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"})
+        return await self.request("editChatKeypad", {"chat_id": chat_id, "chat_keypad_type": "Remove"})
 
     async def edit_chat_keypad(self, chat_id: str, chat_keypad: Keypad):
-        await self.request("editChatKeypad", {"chat_id": chat_id, "chat_keypad_type": "New", "chat_keypad": chat_keypad.asdict()})
+        return await self.request("editChatKeypad", {"chat_id": chat_id, "chat_keypad_type": "New", "chat_keypad": chat_keypad.asdict()})
 
     async def edit_message_keypad(self, chat_id: str, message_id: str, inline_keypad: Keypad):
-        await self.request("editMessageKeypad", {"chat_id": chat_id, "message_id": message_id, "inline_keypad": inline_keypad.asdict()})
+        return await self.request("editMessageKeypad", {"chat_id": chat_id, "message_id": message_id, "inline_keypad": inline_keypad.asdict()})
 
     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})
+        return await self.request("editMessageText", {"chat_id": chat_id, "message_id": message_id, "text": text})
         
     async def edit_message(
         self,

rubigram/network.py

@@ -33,7 +33,7 @@ class Network:
         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")
+            return data.get("data", {})
 
     async def getBytes(self, url: str) -> bytes:
         await self.start()

rubigram/rubino/client.py

@@ -1,11 +1,16 @@
-from aiohttp import ClientSession
 from typing import Literal, Optional, Union, Any
+from aiohttp import ClientSession, FormData
+from urllib.parse import urlparse
 from random import randint
+from pathlib import Path
+from json import loads
+import os
 
 
-class Rubino:
+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",
@@ -15,8 +20,24 @@ class Rubino:
             "platform": "Android"
         }
 
-    
-    async def reauest(self, method: str, data: dict[str, Any]):
+    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,
@@ -24,52 +45,175 @@ class Rubino:
             "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 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(
+        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.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)
     
+    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.requestUpload(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.reauest("getPostByShareLink", {"share_string": post_link.split("/")[-1]})
-    
-    
+        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.reauest("addPostViewCount", data)
-    
-    
+        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.reauest("addViewStory", data)
-    
-    
+        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):
-        username = username.replace("@", "")
-        return await self.reauest("isExistUsername", {"username": username})
-    
-    
+        return await self.request("isExistUsername", {"username": username.replace("@", "")})
+
     async def create_page(self, username: str, name: str, bio: Optional[str] = None):
-        return await self.reauest("createPage", {"username": username, "name": name, "bio": bio})
-    
-    
+        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):
-        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)
-    
-    
+        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.reauest("requestFollow", data)
-    
+        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.reauest("setBlockProfile", data)
-    
+        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,
@@ -79,4 +223,258 @@ class Rubino:
             "equal": False,
             "sort": "FromMax"
         }
-        return await self.reauest("getComments", data)
+        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")