Rubka 6.6.2__py3-none-any.whl → 7.1.17__py3-none-any.whl

rubka/metadata.py

@@ -0,0 +1,117 @@
+import re
+from typing import Any, Dict, List
+import markdownify
+def _normalize_multiline_quote(text: str) -> str:
+    lines = text.splitlines()
+    normalized_lines = []
+    quote_block = []
+
+    for line in lines + [""]:
+        if line.startswith(">"):quote_block.append(line[1:].strip())
+        else:
+            if quote_block:
+                normalized_lines.append("$" + "\n".join(quote_block) + "$")
+                quote_block = []
+            normalized_lines.append(line)
+    return "\n".join(normalized_lines).strip()
+
+class Track_parsed:
+    _PATT = re.compile(
+    r"(?P<pre>```(?P<pre_c>[\s\S]*?)```)"
+    r"|(?P<bold>\*\*(?P<bold_c>.*?)\*\*)"
+    r"|(?P<mono>`(?P<mono_c>.*?)`)"
+    r"|(?P<italic>__(?P<italic_c>.*?)__)"
+    r"|(?P<underline>--(?P<underline_c>.*?)--)"
+    r"|(?P<link>\[(?P<link_text>.*?)\]\((?P<link_url>\S+?)\))"
+    r"|(?P<quote>\$(?P<quote_c>[\s\S]*?)\$)"
+    r"|(?P<quote_md>^>(?P<quote_md_c>.*?)(?:\n|$))"
+    r"|(?P<strike>~~(?P<strike_c>.*?)~~)"
+    r"|(?P<spoiler>\|\|(?P<spoiler_c>.*?)\|\|)",
+    flags=re.DOTALL,
+)
+    _TYPE_MAP = {
+        "pre": "Pre",
+        "bold": "Bold",
+        "mono": "Mono",
+        "italic": "Italic",
+        "underline": "Underline",
+        "strike": "Strike",
+        "spoiler": "Spoiler",
+        "quote": "Quote",
+        "quote_md": "Quote",
+        "link": "Link",
+    }
+
+    @staticmethod
+    def _utf16_len_java_style(s: str) -> int:
+        return len(s.encode("utf-16-be")) // 2
+
+    @staticmethod
+    def _html2md(src: str) -> str:
+        src = re.sub(r'<i>(.*?)</i>', r'||\1||', src, flags=re.DOTALL)
+        src = re.sub(r'<span class="spoiler">(.*?)</span>', r'||\1||', src, flags=re.DOTALL)
+        src = markdownify.markdownify(html=src).strip()
+        src = src.replace("@@SPOILER@@", "||")
+        return src
+
+    def transcribe(self, src: str, mode: str = "MARKDOWN") -> Dict[str, Any]:
+        if mode and mode.upper() == "HTML":
+            src = self._html2md(src)
+        src = _normalize_multiline_quote(src)
+
+        payload_parts: List[Dict[str, Any]] = []
+
+        normalized_text = src
+        byte_offset = 0
+        char_offset = 0
+
+        matches = list(self._PATT.finditer(src))
+        for m in matches:
+            whole = m.group(0)
+            start, end = m.span()
+            adj_from = self._utf16_len_java_style(src[:start]) - byte_offset
+            adj_char_from = start - char_offset
+
+            gname = m.lastgroup
+            if not gname:
+                continue
+            
+            if gname == "link":
+                inner = m.group("link_text") or ""
+                link_href = m.group("link_url")
+            else:
+                inner = m.group(f"{gname}_c") or ""
+                link_href = None
+            if gname in ["quote", "quote_md", "bold", "italic", "underline", "spoiler", "strike"]:
+                inner_metadata = self.transcribe(inner, mode="MARKDOWN")
+                inner = inner_metadata["text"]
+                if "metadata" in inner_metadata:
+                    for part in inner_metadata["metadata"]["meta_data_parts"]:
+                        part["from_index"] += adj_from
+                        payload_parts.append(part)
+            if inner == "":
+                continue
+            content_utf16_len = self._utf16_len_java_style(inner)
+            part: Dict[str, Any] = {
+                "type": self._TYPE_MAP.get(gname, "Unknown"),
+                "from_index": adj_from,
+                "length": content_utf16_len,
+            }
+            if link_href:
+                part["link_url"] = link_href
+            payload_parts.append(part)
+            normalized_text = (
+                normalized_text[:adj_char_from] + inner + normalized_text[end - char_offset :]
+            )
+            byte_offset += self._utf16_len_java_style(whole) - content_utf16_len
+            char_offset += (end - start) - len(inner)
+
+        result: Dict[str, Any] = {"text": normalized_text.strip()}
+        if payload_parts:
+            result["metadata"] = {"meta_data_parts": payload_parts}
+
+        return result
+
+
+    def parse(self, text: str, parse_mode: str = "MARKDOWN") -> Dict[str, Any]:
+        return self.transcribe(text, mode=parse_mode)

rubka/rubino.py

@@ -1,10 +1,14 @@
 import urllib3
-import json
-from typing import Any, Dict
+import json,random
+from typing import Any, Dict,List
 from tempfile import NamedTemporaryFile
 from os import system, chmod, remove
 from base64 import b64encode
 from io import BytesIO
+class InvalidInputError(Exception):
+    def __init__(self, message="Invalid input provided"):
+        self.message = message
+        super().__init__(self.message)
 class confing():
     headers= {
         "User-Agent": "okhttp/3.12.1",
@@ -192,9 +196,15 @@ class req:
             except:
                 continue
             else:
-                if 'data_enc' in  response.json():
-                    return loads(self.enc.decrypt(response.json()['data_enc']))
-                return response.json()
+                
+                response_data = response.json()
+
+                if 'data_enc' in response_data:
+                    return loads(self.enc.decrypt(response_data['data_enc']))
+                if response_data.get('status') != "OK":
+                    raise InvalidInputError(f"Error : {response_data.get('status_det', 'Unknown error')}")
+                return response_data
+
         
     def requestUploadFile(self,file_name:str,size:str,file_type:str,profile_id:str=None):
         return self.send_request({
@@ -203,6 +213,7 @@ class req:
             "file_type": file_type,
             "profile_id": profile_id
         },"requestUploadFile")
+    
 
     def upload(self, post_file, post_type: str, profile_id: str = None):
         file_byte_code = post_file if isinstance(post_file, bytes) else open(post_file, "rb").read()
@@ -406,28 +417,14 @@ class api:
             response_data = json.loads(response.data.decode('utf-8'))
             if 'result' in response_data:
                     return response_data['result']
-def _req(term, results, lang, start, proxies, timeout):
-    resp = get(
-        url="https://www.google.com/search",
-        headers={
-            "User-Agent": get_useragent()
-        },
-        params={
-            "q": term,
-            "num": results + 2,  # Prevents multiple requests
-            "hl": lang,
-            "start": start,
-        },
-        proxies=proxies,
-        timeout=timeout,
-    )
-    resp.raise_for_status()
-    return resp
-import random
+
 
 class Bot():
-    """rubino class"""
+    """rubino class Regester m.rubika.ir"""
     def __init__(self,auth,platform="m.rubika.ir",lang_code="fa") -> None:
+        """
+        regester m.rubika.ir
+        """
         self.auth=auth
         self.platform=platform
         self.lang_code=lang_code
@@ -446,7 +443,7 @@ class Bot():
                 "api_version":"0",
                 "client":{
                     "app_name":"Main",
-                    "app_version":"2.2.4",
+                    "app_version":"2.4.7",
                     "package":"m.rubika.ir",
                     "platform":"PWA"
                 },
@@ -473,11 +470,12 @@ class Bot():
         if response.status == 200:
             response_data = json.loads(response.data.decode('utf-8'))
             if 'data' in response_data:
-                    return response_data['data']
+                return response_data['data']
             else:
-                return response_data['status_det']
-        else :
-            raise Exception("Request Error Server")
+                raise Exception(f"Error: {response_data.get('status_det', 'Unknown error')}")
+        else:
+            raise Exception(f"Request Error Server - Status Code: {response.status}")
+
     def edit_info_page(
         self,
         username_me:str,
@@ -660,6 +658,49 @@ class Bot():
             return [668,789]
         except Exception as e:
             return [668,789]
+    def add_Story(self,post_file:str,duration:int=27,size:list=[668,798],thumbnail_file:str=None,profile_id:str=None):
+        
+        if post_file.split(".")[-1] == "mp4" or post_file.split(".")[-1] == "mov" or post_file.split(".")[-1] == "mkv" or "https://":
+            try:
+                if "https://" in post_file:
+                    tumb_res , post_res = req(self.auth).upload(image_to_bytes(thumbnail_file) if type(thumbnail_file) is str else confing.th,"Picture",profile_id) , req(self.auth).upload(requests.get(post_file).content,"Video",profile_id)
+                else :
+                    tumb_res , post_res = req(self.auth).upload(image_to_bytes(thumbnail_file) if type(thumbnail_file) is str else confing.th,"Picture",profile_id) , req(self.auth).upload(post_file,"Video",profile_id)
+            except ModuleNotFoundError:
+                print("pip install moviepy")
+                tumb_res , post_res = req(self.auth).upload(confing.th,"Picture",profile_id) , req(self.auth).upload(post_file,"Video",profile_id)
+            data = {
+                "duration": str(duration),
+                "file_id": post_res[0]["file_id"],
+                "hash_file_receive": post_res[1],
+                "height": 1280 if size[1] > 1280 else size[1],
+                "story_type": "Video",
+                "rnd": random.randint(100000, 999999999),
+                "snapshot_file_id": tumb_res[0]["file_id"],
+                "snapshot_hash_file_receive": tumb_res[1],
+                "thumbnail_file_id": tumb_res[0]["file_id"],
+                "thumbnail_hash_file_receive": tumb_res[1],
+                "width": 720 if size[0] > 720 else size[0],
+                "profile_id": profile_id
+            }
+                
+        elif post_file.split(".")[-1] == "jpg" or post_file.split(".")[-1] == "png":
+            post_res = req(self.auth).upload(post_file,"Picture",profile_id)
+
+            data = {
+                "file_id": post_res[0]["file_id"],
+                "hash_file_receive": post_res[1],
+                "height": 1280 if size[1] > 1280 else size[1],
+                "story_type": "Picture",
+                "rnd": random.randint(100000, 999999999),
+                "thumbnail_file_id": post_res[0]["file_id"],
+                "thumbnail_hash_file_receive": post_res[1],
+                "width": 720 if size[0] > 720 else size[0],
+                "profile_id": profile_id
+            }
+        else:
+            return "file address eror"
+        return req(self.auth).send_request(data,"addStory")['data']
     def add_Post(self,post_file: str, caption: str = None, time: int = 1, size: Any = [668, 798], thumbnail_file: str = None, profile_id: str = None):
         from concurrent.futures import ThreadPoolExecutor
         if size == "Auto" or size =="auto":
@@ -891,6 +932,22 @@ class Bot():
             "target_profile_id": target_profile_id,
             "profile_id": profile_id
         },methode="getProfileFollowers")
+    def search_Follower(self,username,profile_id,target_profile_id,limit=10,search_type="Follower"):
+        return self._reuests_post(data={
+            "limit": limit,
+            "profile_id": profile_id,
+            "search_type": limit,
+            "target_profile_id": target_profile_id,
+            "username": username
+        },methode="searchFollower")
+    def search_Following(self,username,profile_id,target_profile_id,limit=10,search_type="Following"):
+        return self._reuests_post(data={
+            "limit": limit,
+            "profile_id": profile_id,
+            "search_type": limit,
+            "target_profile_id": target_profile_id,
+            "username": username
+        },methode="searchFollower")
     
     def get_Page_Following(self,target_profile_id:str,sort:str="FromMax",limit:int=50,equal:bool=False,profile_id:str=None):
         return self._reuests_post(data={
@@ -925,28 +982,30 @@ class Bot():
             "username": username,
             "profile_id": profile_id
         },methode="getProfileFollowers")
-    
-    def get_NewFollow_Requests(self,sort:str="FromMax",limit:int=50,equal:bool=False,profile_id:str=None):
+    def get_Related_Explore_Post(self,post_id:str,track_id,post_profile_id:str,limit:int=50,start_id:bool=False,profile_id:str=None,target_profile_id=None,):
         return self._reuests_post(data={
-            "equal": equal,
             "limit": limit,
-            "sort": sort,
+            "post_id": post_id,
+            "post_profile_id": post_profile_id,
+            "start_id": start_id,
+            "target_profile_id": target_profile_id,
+            "track_id": track_id,
             "profile_id": profile_id
-        },methode="getNewFollowRequests")
+        },methode="getRelatedExplorePost")
     
-    def accept_Request_Follow(self,request_id:str,profile_id:str=None):
+    def get_Highlight_StoryIds(self,highlight_id:str,profile_id:str,target_profile_id:str):
         return self._reuests_post(data={
-            "action": "Accept",
-            "request_id": request_id,
-            "profile_id": profile_id
-        },methode="actionOnRequest")
-    
-    def decline_Request_Follow(self,request_id:str,profile_id:str=None):
+            "highlight_id": highlight_id,
+            "profile_id": profile_id,
+            "target_profile_id": target_profile_id
+        },methode="getHighlightStoryIds")
+    def get_Highlight_Stories(self,highlight_id:str,profile_id:str,target_profile_id:str,story_ids:list):
         return self._reuests_post(data={
-            "action": "Decline",
-            "request_id": request_id,
-            "profile_id": profile_id
-        },methode="actionOnRequest")
+            "highlight_id": highlight_id,
+            "profile_id": profile_id,
+            "target_profile_id": target_profile_id,
+            "story_ids":story_ids
+        },methode="getHighlightStories")
     def un_save_Post(self,post_profile_id:str,post_id:str,profile_id:str=None):
         return self._reuests_post(data={
             "action_type": "Unbookmark",
@@ -955,14 +1014,24 @@ class Bot():
             "track_id": "Related",
             "profile_id": profile_id
         },methode="postBookmarkAction")
-    
-    def get_Saved_Posts(self,sort:str="FromMax",limit:int=51,equal:bool=False,profile_id:str=None):
-        return self._reuests_post(data={
-            "equal": equal,
+    def get_saved_posts(
+    self,
+    max_id: str,
+    limit: int = 20,
+    profile_id: Optional[str] = None,
+    sort: str = "FromMax") -> Dict[str, Any]:
+        payload = {
             "limit": limit,
-            "sort": sort,
-            "profile_id": profile_id
-        },methode="getBookmarkedPosts")
+            "max_id": max_id,
+            "sort": sort
+        }
+        if profile_id is not None:
+            payload["profile_id"] = profile_id
+
+        return self._reuests_post(
+            data=payload,
+            methode="getBookmarkedPosts"
+        )
     
     def search_Page(self,username:str,sort:str="FromMax",limit:int=50,equal:bool=False,profile_id:str=None):
         return self._reuests_post(data={
@@ -994,6 +1063,14 @@ class Bot():
             "record_id": post_id,
             "profile_id": profile_id
         },methode="setReportRecord")
+    def report_Post(self,post_profile_id,post_id:str,reason:int=2,profile_id:str=None):
+        return self._reuests_post(data={
+            "model": "Post",
+            "reason": reason,
+            "post_profile_id":post_profile_id,
+            "record_id": post_id,
+            "profile_id": profile_id
+        },methode="setReportRecord")
 
     def delete_Post(self,post_id:str,profile_id:str=None):
         return self._reuests_post(data={
@@ -1013,6 +1090,12 @@ class Bot():
             "profile_status": profile_status,
             "profile_id": profile_id
         },methode="updateProfile")
+    def get_New_Events(self,limit:int=20,sort:str="FromMax",profile_id:str=None):
+        return self._reuests_post(data={
+            "limit": limit,
+            "profile_id": profile_id,
+            "sort":sort
+        },methode="updateProfile")
 
     def allow_Send_MessagePv(self,is_message_allowed:bool=False,profile_id:str=None):
         return self._reuests_post(data={
@@ -1035,49 +1118,7 @@ class Bot():
             "thumbnail_hash_file_receive": prof_res[1],
             "profile_id": profile_id
         },methode="updateProfilePhoto")
-    def add_Story(self,post_file:str,duration:int=27,size:list=[668,798],thumbnail_file:str=None,profile_id:str=None):
-        
-        if post_file.split(".")[-1] == "mp4" or post_file.split(".")[-1] == "mov" or post_file.split(".")[-1] == "mkv" or "https://":
-            try:
-                if "https://" in post_file:
-                    tumb_res , post_res = req(self.auth).upload(image_to_bytes(thumbnail_file) if type(thumbnail_file) is str else confing.th,"Picture",profile_id) , req(self.auth).upload(requests.get(post_file).content,"Video",profile_id)
-                else :
-                    tumb_res , post_res = req(self.auth).upload(image_to_bytes(thumbnail_file) if type(thumbnail_file) is str else confing.th,"Picture",profile_id) , req(self.auth).upload(post_file,"Video",profile_id)
-            except ModuleNotFoundError:
-                print("pip install moviepy")
-                tumb_res , post_res = req(self.auth).upload(confing.th,"Picture",profile_id) , req(self.auth).upload(post_file,"Video",profile_id)
-            data = {
-                "duration": str(duration),
-                "file_id": post_res[0]["file_id"],
-                "hash_file_receive": post_res[1],
-                "height": 1280 if size[1] > 1280 else size[1],
-                "story_type": "Video",
-                "rnd": random.randint(100000, 999999999),
-                "snapshot_file_id": tumb_res[0]["file_id"],
-                "snapshot_hash_file_receive": tumb_res[1],
-                "thumbnail_file_id": tumb_res[0]["file_id"],
-                "thumbnail_hash_file_receive": tumb_res[1],
-                "width": 720 if size[0] > 720 else size[0],
-                "profile_id": profile_id
-            }
-                
-        elif post_file.split(".")[-1] == "jpg" or post_file.split(".")[-1] == "png":
-            post_res = req(self.auth).upload(post_file,"Picture",profile_id)
-
-            data = {
-                "file_id": post_res[0]["file_id"],
-                "hash_file_receive": post_res[1],
-                "height": 1280 if size[1] > 1280 else size[1],
-                "story_type": "Picture",
-                "rnd": random.randint(100000, 999999999),
-                "thumbnail_file_id": post_res[0]["file_id"],
-                "thumbnail_hash_file_receive": post_res[1],
-                "width": 720 if size[0] > 720 else size[0],
-                "profile_id": profile_id
-            }
-        else:
-            return "file address eror"
-        return req(self.auth).send_request(data,"addStory")['data']
+    
     def delete_Page(self,page_profile_id:str):
         return self._reuests_post(data={
             "model": "Profile",
@@ -1097,4 +1138,94 @@ class Bot():
             "post_id": post_id,
             "post_profile_id": post_profile_id,
             "profile_id": profile_id
-        },methode="addPostViewTime")['data']
+        },methode="addPostViewTime")['data']
+    def get_Profile_Posts(self,target_profile_id:str,max_id:str,sort:str="FromMax",limit:str=10):
+        return self._reuests_post(data={
+            "limit": limit,
+            "max_id": max_id,
+            "sort":sort,
+            "target_profile_id": target_profile_id,
+        },methode="getProfilePosts")['data']
+    def get_info_Post(self,url_post:str,profile_id:str=None):
+        return self._reuests_post(data={
+            "share_string": url_post,
+            "profile_id": profile_id,
+        },methode="getPostByShareLink")['data']
+    def search_HashTag(
+        self,
+        content: str,
+        profile_id:str,
+        limit: int = 20,
+    ) -> Dict[str, Any]:
+
+        payload = {
+            "profile_id": profile_id,
+            "content": content,
+            "limit": limit
+        }
+        return self._reuests_post("reportProfile", data=payload)
+    def accept_Follow_Request(
+        self,
+        request_id: str,
+        profile_id: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Accept a follow request from a user.
+
+        Args:
+            request_id (str): The ID of the follow request.
+            profile_id (Optional[str]): The profile ID of the current user (if available).
+
+        Returns:
+            Dict[str, Any]: The server's response, including action status.
+        """
+        payload = {
+            "action": "Accept",
+            "request_id": request_id,
+            "profile_id": profile_id
+        }
+        return self._reuests_post("actionOnRequest", data=payload)
+    def decline_Follow_Request(
+        self,
+        request_id: str,
+        profile_id: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Decline a follow request from a user.
+
+        Args:
+            request_id (str): The ID of the follow request.
+            profile_id (Optional[str]): The profile ID of the current user (if available).
+
+        Returns:
+            Dict[str, Any]: The server's response, including action status.
+        """
+        payload = {
+            "action": "Decline",
+            "request_id": request_id,
+            "profile_id": profile_id
+        }
+        return self._reuests_post("actionOnRequest", data=payload)
+    def get_New_Follow_Requests(
+        self,
+        profile_id: Optional[str] = None ,
+        limit: int = 20,
+        sort: str = "FromMax"
+    ) -> Dict[str, Any]:
+        """
+        Retrieve new follow requests for a given profile.
+
+        Args:
+            profile_id (str): The profile ID of the current user.
+            limit (int): The number of requests to fetch. Default is 20.
+            sort (str): The sorting order for the requests. Default is "FromMax".
+
+        Returns:
+            Dict[str, Any]: The server's response containing new follow requests.
+        """
+        payload = {
+            "profile_id": profile_id,
+            "limit": limit,
+            "sort": sort
+        }
+        return self._reuests_post("getNewFollowRequests", data=payload)