Rubka 7.2.8__py3-none-any.whl

rubka/adaptorrubka/sessions/sessions.py

@@ -0,0 +1,72 @@
+from os.path import exists
+from json import loads, dumps
+
+class Sessions:
+
+    def __init__(self, client:object) -> None:
+        self.client = client
+
+    def cheackSessionExists(self):
+        return exists(f"{self.client.session}.rubka")
+    
+    def loadSessionData(self):
+        return loads(open(f"{self.client.session}.rubka", encoding="UTF-8").read())
+        
+    def createSession(self):
+        from ..methods import Methods
+        methods:object = Methods(
+            sessionData={},
+            platform=self.client.platform,
+            apiVersion=6,
+            proxy=self.client.proxy,
+            timeOut=self.client.timeOut,
+            showProgressBar=True
+        )
+
+        while True:
+            phoneNumber:str = input("\nphone number :\t")
+            try:
+                sendCodeData:dict = methods.sendCode(phoneNumber=phoneNumber)
+            except:
+                print("The phone number is invalid! Please try again.")
+                continue
+
+            if sendCodeData['status'] == 'SendPassKey':
+                while True:
+                    passKey:str = input(f'\npass key [{sendCodeData["hint_pass_key"]}]  : ')
+                    sendCodeData:dict = methods.sendCode(phoneNumber=phoneNumber, passKey=passKey)
+                    
+                    if sendCodeData['status'] == 'InvalidPassKey':
+                        print(f'\nThe pass key({sendCodeData["hint_pass_key"]})try again.')
+                        continue
+                    break
+            
+            while True:
+                phoneCode:str = input("\ncode : ").strip()
+                signInData:dict = methods.signIn(phoneNumber=phoneNumber, phoneCodeHash=sendCodeData['phone_code_hash'], phoneCode=phoneCode)
+                if signInData['status'] != 'OK':
+                    print("The code is invalid! Please try again.")
+                    continue
+                break
+            
+            from ..crypto import Cryption
+
+            sessionData = {
+                'auth': Cryption.decryptRsaOaep(signInData["private_key"], signInData['auth']),
+                'private_key': signInData["private_key"],
+                'user': signInData['user'],
+            }
+
+            open(f"{self.client.session}.rubka", "w", encoding="UTF-8").write(dumps(sessionData, indent=4))
+
+            Methods(
+                sessionData=sessionData,
+                platform=self.client.platform,
+                apiVersion=6,
+                proxy=self.client.proxy,
+                timeOut=self.client.timeOut,
+                showProgressBar=True
+            ).registerDevice(deviceModel=f"rubka-Api-{self.client.session}")
+            print(f"\nSign successful")
+
+            return sessionData

rubka/adaptorrubka/types/__init__.py

@@ -0,0 +1 @@
+from .socket import Message

rubka/adaptorrubka/types/socket/__init__.py

@@ -0,0 +1 @@
+from .message import Message

rubka/adaptorrubka/types/socket/message.py

@@ -0,0 +1,187 @@
+class ReplyInfo:
+    def __init__(self, text, author_guid) -> None:
+        self.text = text
+        self.author_guid = author_guid
+        pass
+
+    @classmethod
+    def from_json(cls, json: dict):
+        return cls(json["text"], json["author_object_guid"])
+
+class Message:
+    def __init__(self, data:dict, methods:object) -> None:
+        self.data = data
+        self.methods = methods
+
+    @property
+    def object_guid(self) -> str:
+        return self.data["chat_updates"][0].get("object_guid")
+    
+    @property
+    def chat_type(self) -> str:
+        return self.data["chat_updates"][0].get("type")
+    
+    @property
+    def count_unseen(self) -> int:
+        return int(self.data["chat_updates"][0]["chat"].get("count_unseen", 0))
+    
+    @property
+    def last_seen_peer_mid(self) -> str:
+        return self.data["chat_updates"][0]["chat"].get("last_seen_peer_mid")
+    
+    @property
+    def time_string(self) -> str:
+        return self.data["chat_updates"][0]["chat"].get("time_string")
+    
+    @property
+    def is_mine(self) -> bool:
+        return self.data["chat_updates"][0]["chat"]["last_message"].get("is_mine")
+    
+    @property
+    def time(self) -> str:
+        return self.data["chat_updates"][0]["chat"]["last_message"].get("time")
+    
+    @property
+    def status(self) -> str:
+        return self.data["chat_updates"][0]["chat"].get("status")
+    
+    @property
+    def last_message_id(self) -> str:
+        return self.data["chat_updates"][0]["chat"].get("last_message_id")
+    
+    @property
+    def action(self) -> str:
+        return self.data["message_updates"][0].get("action")
+    
+    @property
+    def message_id(self) -> str:
+        return self.data["message_updates"][0].get("message_id")
+    
+    @property
+    def reply_message_id(self) -> str:
+        return self.data["message_updates"][0]["message"].get("reply_to_message_id")
+    
+    @property
+    def text(self) -> str:
+        return str(self.data["message_updates"][0]["message"].get("text"))
+    
+    @property
+    def is_edited(self) -> bool:
+        return self.data["message_updates"][0]["message"].get("is_edited")
+    
+    @property
+    def message_type(self) -> str:
+        if self.file_inline:
+            return self.file_inline["type"]
+        
+        return self.data["message_updates"][0]["message"].get("type")
+    
+    @property
+    def author_type(self) -> str:
+        return self.data["message_updates"][0]["message"].get("author_type")
+    
+    @property
+    def author_guid(self) -> str:
+        return self.data["message_updates"][0]["message"].get("author_object_guid")
+    
+    @property
+    def prev_message_id(self) -> str:
+        return self.data["message_updates"][0].get("prev_message_id")
+    
+    @property
+    def state(self) -> str:
+        return self.data["message_updates"][0].get("state")
+    
+    @property
+    def title(self) -> str:
+        if self.data['show_notifications']:
+            return self.data['show_notifications'][0].get('title')
+    
+    @property
+    def author_title(self) -> str:
+        return self.data['chat_updates'][0]['chat']['last_message'].get('author_title', self.title)
+    
+    @property
+    def is_user(self) -> bool:
+        return self.chat_type == "User"
+    
+    @property
+    def is_group(self) -> bool:
+        return self.chat_type == "Group"
+    
+    @property
+    def is_forward(self) -> bool:
+        return "forwarded_from" in self.data["message_updates"][0]["message"].keys()
+    
+    @property
+    def forward_from(self) -> str:
+        return self.data["message_updates"][0]["message"]["forwarded_from"].get("type_from") if self.is_forward else None
+    
+    @property
+    def forward_object_guid(self) -> str:
+        return self.data["message_updates"][0]["message"]["forwarded_from"].get("object_guid") if self.is_forward else None
+    
+    @property
+    def forward_message_id(self) -> str:
+        return self.data["message_updates"][0]["message"]["forwarded_from"].get("message_id") if self.is_forward else None
+
+    @property
+    def is_event(self) -> bool:
+        return 'event_data' in self.data['message_updates'][0]['message'].keys()
+    
+    @property
+    def event_type(self) -> str:
+        return self.data['message_updates'][0]['message']['event_data'].get('type') if self.is_event else None
+    
+    @property
+    def event_object_guid(self) -> str:
+        return self.data['message_updates'][0]['message']['event_data']['performer_object'].get('object_guid') if self.is_event else None
+    
+    @property
+    def pinned_message_id(self) -> str:
+        return self.data['message_updates'][0]['message']['event_data'].get('pinned_message_id') if self.is_event else None
+    
+    @property
+    def file_inline(self) -> dict:
+        return self.data["message_updates"][0]["message"].get("file_inline")
+
+    @property
+    def has_link(self) -> bool:
+        for link in ["http:/", "https:/", "www.", ".ir", ".com", ".net" "@"]:
+            if link in self.text.lower():
+                return True
+        return False
+    
+    @property
+    def reply_info(self) -> ReplyInfo:
+        if not self.reply_message_id:
+            return
+        
+        return ReplyInfo.from_json(self.methods.getMessagesById(self.object_guid, [self.reply_message_id])["messages"][0])
+    
+    def reply(self, text:str) -> dict:
+        return self.methods.sendText(objectGuid=self.object_guid, text=text, messageId=self.message_id)
+    
+    def seen(self) -> dict:
+        return self.methods.seenChats(seenList={self.object_guid: self.message_id})
+    
+    def reaction(self, reaction:int) -> dict:
+        return self.methods.actionOnMessageReaction(objectGuid=self.object_guid, messageId=self.message_id, reactionId=reaction, action="Add")
+    
+    def delete(self, delete_for_all:bool=True) -> dict:
+        return self.methods.deleteMessages(objectGuid=self.object_guid, messageIds=[self.message_id], deleteForAll=delete_for_all)
+    
+    def pin(self) -> dict:
+        return self.methods.pinMessage(objectGuid=self.object_guid, messageId=self.message_id)
+    
+    def forward(self, to_object_guid:str) -> dict:
+        return self.methods.forwardMessages(objectGuid=self.object_guid, message_ids=[self.message_id], toObjectGuid=to_object_guid)
+    
+    def ban(self) -> dict:
+        return self.methods.banMember(objectGuid=self.object_guid, memberGuid=self.author_guid)
+    
+    def check_join(self, object_guid:str) -> bool:
+        return self.methods.checkJoin(objectGuid=object_guid, userGuid=self.author_guid)
+    
+    def download(self, save:bool=False, save_as:str=None) -> dict:
+        return self.methods.download(save=save, saveAs=save_as, fileInline=self.file_inline)

rubka/adaptorrubka/utils/__init__.py

@@ -0,0 +1,2 @@
+from .configs import Configs
+from .utils import Utils

rubka/adaptorrubka/utils/configs.py

@@ -0,0 +1,18 @@
+class Configs:
+    clients:dict = {
+        "web": {
+            "app_name": "Main",
+            "app_version": "4.4.6",
+            "lang_code": "fa",
+            "package": "web.rubika.ir",
+            "platform": "Web",
+        },
+        "android": {
+            "app_name": "Main",
+            "app_version": "3.5.7",
+            "lang_code": "fa",
+            "package": "app.rbmain.a",
+            "temp_code": "27",
+            "platform": "Android"
+        }
+    }

rubka/adaptorrubka/utils/utils.py

@@ -0,0 +1,251 @@
+
+from random import choices, randint
+from time import time
+from re import finditer, sub
+from base64 import b64encode
+from io import BytesIO
+from tempfile import NamedTemporaryFile
+from mutagen import mp3, File
+from filetype import guess
+from os import system, chmod, remove
+from .configs import Configs
+
+class Utils:
+
+    def randomTmpSession() -> str:
+        return "".join(choices("abcdefghijklmnopqrstuvwxyz", k=32))
+    
+    def randomDeviceHash() -> str:
+        return "".join(choices("0123456789", k=26))
+    
+    def randomRnd() -> str:
+        return str(randint(-99999999, 99999999))
+    
+    def privateParse(private:str) -> str:
+        if private:
+            if not private.startswith("-----BEGIN RSA PRIVATE KEY-----"):
+                private = "-----BEGIN RSA PRIVATE KEY-----\\n" + private
+            
+            if not private.endswith("-----END RSA PRIVATE KEY-----"):
+                private += "\\n-----END RSA PRIVATE KEY-----"
+
+            return private.replace("\\n", "\n").strip()
+
+    def getState() -> int:
+        return int(time()) - 150
+    
+    def phoneNumberParse(phoneNumber:str) -> str:
+        if str(phoneNumber).startswith("0"):
+            phoneNumber = phoneNumber[1:]
+
+        elif str(phoneNumber).startswith("98"):
+            phoneNumber = phoneNumber[2:]
+
+        elif str(phoneNumber).startswith("+98"):
+            phoneNumber = phoneNumber[3:]
+
+        return phoneNumber
+    
+    def getChatTypeByGuid(objectGuid:str) -> str:
+        for chatType in [("u0", "User"), ("g0", "Group"), ("c0", "Channel"), ("s0", "Service"), ("b0", "Bot")]:
+            if objectGuid.startswith(chatType[0]):
+                return chatType[1]
+    
+    def isChatType(chatType:str) -> bool:
+        chatType = chatType.lower()
+        for type in ["user", "group", "channel", "service", "bot"]:
+            if type == chatType:
+                return True
+            
+    def isMessageType(messageType:str) -> bool:
+        messageType = messageType.lower()
+        for type in ["text", "image", "video", "gif", "video message", "voice", "music", "file"]:
+            if type == messageType:
+                return True
+
+    
+    def getChatTypeByLink(link:str) -> str:
+        if "rubika.ir/joing" in link: return "Group"
+        elif "rubika.ir/joinc" in link: return "Channel"
+    
+    def checkMetadata(text):
+        if text is None:
+            return [], ""
+
+        real_text = sub(r"``|\*\*|__|~~|--|@@|##|", "", text)
+        metadata = []
+        conflict = 0
+        mentionObjectIndex = 0
+        result = []
+
+        patterns = {
+            "Mono": r"\`\`([^``]*)\`\`",
+            "Bold": r"\*\*([^**]*)\*\*",
+            "Italic": r"\_\_([^__]*)\_\_",
+            "Strike": r"\~\~([^~~]*)\~\~",
+            "Underline": r"\-\-([^__]*)\-\-",
+            "Mention": r"\@\@([^@@]*)\@\@",
+            "Spoiler": r"\#\#([^##]*)\#\#",
+        }
+
+        for style, pattern in patterns.items():
+            for match in finditer(pattern, text):
+                metadata.append((match.start(), len(match.group(1)), style))
+
+        metadata.sort()
+
+        for start, length, style in metadata:
+            if not style == "Mention":
+                result.append({
+                    "type": style,
+                    "from_index": start - conflict,
+                    "length": length,
+                })
+                conflict += 4
+            else:
+                mentionObjects = [i.group(1) for i in finditer(r"\@\(([^(]*)\)", text)]
+                mentionType = Utils.getChatTypeByGuid(objectGuid=mentionObjects[mentionObjectIndex]) or "Link"
+
+                if mentionType == "Link":
+                    result.append(
+                        {
+                            "from_index": start - conflict,
+                            "length": length,
+                            "link": {
+                                "hyperlink_data": {
+                                    "url": mentionObjects[mentionObjectIndex]
+                                },
+                                "type": "hyperlink",
+                            },
+                            "type": mentionType,
+                        }
+                    )
+                else:
+                    result.append(
+                        {
+                            "type": "MentionText",
+                            "from_index": start - conflict,
+                            "length": length,
+                            "mention_text_object_guid": mentionObjects[mentionObjectIndex],
+                            "mention_text_object_type": mentionType
+                        }
+                    )
+                real_text = real_text.replace(f"({mentionObjects[mentionObjectIndex]})", "")
+                conflict += 6 + len(mentionObjects[mentionObjectIndex])
+                mentionObjectIndex += 1
+                
+        return result, real_text
+    
+    def checkLink(url:str) -> dict:
+        for i in ["http:/", "https://"]:
+            if url.startswith(i): return True
+
+    def getMimeFromByte(bytes:bytes) -> str:
+        mime = guess(bytes)
+        return "pyrubi" if mime is None else mime.extension
+    
+    def generateFileName(mime:str) -> str:
+        return "Pyrubi Library {}.{}".format(randint(1, 1000), mime)
+    
+    def getImageSize(bytes:bytes) -> str:
+        try:
+            from PIL import Image
+        except ImportError:
+            system("pip install pillow")
+            from PIL import Image
+
+        width, height = Image.open(BytesIO(bytes)).size
+        return width , height
+    
+    def getImageThumbnail(bytes:bytes) -> str:
+        try:
+            from PIL import Image
+        except ImportError:
+            system("pip install pillow")
+            from PIL import Image
+            
+        image = Image.open(BytesIO(bytes))
+        width, height = image.size
+        if height > width:
+            new_height = 40
+            new_width  = round(new_height * width / height)
+        else:
+            new_width = 40
+            new_height = round(new_width * height / width)
+        image = image.resize((new_width, new_height), Image.LANCZOS)
+        changed_image = BytesIO()
+        image.save(changed_image, format="PNG")
+        return b64encode(changed_image.getvalue()).decode("UTF-8")
+    
+    def getVideoData(bytes:bytes) -> list:
+        try:
+            from moviepy.editor import VideoFileClip
+
+            with NamedTemporaryFile(delete=False, dir=".") as temp_video:
+                temp_video.write(bytes)
+                temp_path = temp_video.name
+
+            chmod(temp_path, 0o777)
+
+            try:
+                from PIL import Image
+            except ImportError:
+                system("pip install pillow")
+                from PIL import Image
+
+            with VideoFileClip(temp_path) as clip:
+                duration = clip.duration
+                resolution = clip.size
+                thumbnail = clip.get_frame(0)
+                thumbnail_image = Image.fromarray(thumbnail)
+                thumbnail_buffer = BytesIO()
+                thumbnail_image.save(thumbnail_buffer, format="JPEG")
+                thumbnail_b64 = b64encode(thumbnail_buffer.getvalue()).decode("UTF-8")
+                clip.close()
+
+            remove(temp_path)
+
+            return thumbnail_b64, resolution, duration
+        except ImportError:
+            print(Colors.YELLOW + "Can't get video data! Please install the moviepy library by following command:\npip install moviepy" + Colors.RESET)
+            return Configs.defaultTumbInline, [900, 720], 1
+        except:
+            return Configs.defaultTumbInline, [900, 720], 1
+        
+    def getVoiceDuration(bytes:bytes) -> int:
+        file = BytesIO()
+        file.write(bytes)
+        file.seek(0)
+        return mp3.MP3(file).info.length
+    
+    def getMusicArtist(bytes:bytes) -> str:
+        try:
+            audio = File(BytesIO(bytes), easy=True)
+
+            if audio and "artist" in audio:
+                return audio["artist"][0]
+            
+            return "pyrubi"
+        except Exception:
+            return "pyrubi"
+        
+class Colors:
+    RESET = "\033[0m"
+    BLACK = "\033[30m"
+    RED = "\033[31m"
+    GREEN = "\033[32m"
+    YELLOW = "\033[33m"
+    BLUE = "\033[34m"
+    MAGENTA = "\033[35m"
+    CYAN = "\033[36m"
+    WHITE = "\033[37m"
+
+    BG_RESET = "\033[49m"
+    BG_BLACK = "\033[40m"
+    BG_RED = "\033[41m"
+    BG_GREEN = "\033[42m"
+    BG_YELLOW = "\033[43m"
+    BG_BLUE = "\033[44m"
+    BG_MAGENTA = "\033[45m"
+    BG_CYAN = "\033[46m"
+    BG_WHITE = "\033[47m"