Rubka 2.11.13__tar.gz → 3.2.5__tar.gz

{rubka-2.11.13 → rubka-3.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Rubka
-Version: 2.11.13
+Version: 3.2.5
 Summary: A Python library for interacting with Rubika Bot API.
 Home-page: https://github.com/Mahdy-Ahmadi/Rubka
 Download-URL: https://github.com/Mahdy-Ahmadi/Rubka/archive/refs/tags/v0.1.0.tar.gz

{rubka-2.11.13 → rubka-3.2.5}/Rubka.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Rubka
-Version: 2.11.13
+Version: 3.2.5
 Summary: A Python library for interacting with Rubika Bot API.
 Home-page: https://github.com/Mahdy-Ahmadi/Rubka
 Download-URL: https://github.com/Mahdy-Ahmadi/Rubka/archive/refs/tags/v0.1.0.tar.gz

rubka-3.2.5/Rubka.egg-info/SOURCES.txt

@@ -0,0 +1,39 @@
+README.md
+setup.py
+Rubka.egg-info/PKG-INFO
+Rubka.egg-info/SOURCES.txt
+Rubka.egg-info/dependency_links.txt
+Rubka.egg-info/requires.txt
+Rubka.egg-info/top_level.txt
+rubka/__init__.py
+rubka/api.py
+rubka/config.py
+rubka/context.py
+rubka/decorators.py
+rubka/exceptions.py
+rubka/jobs.py
+rubka/keyboards.py
+rubka/keypad.py
+rubka/logger.py
+rubka/utils.py
+rubka/adaptorrubka/__init__.py
+rubka/adaptorrubka/enums.py
+rubka/adaptorrubka/exceptions.py
+rubka/adaptorrubka/client/__init__.py
+rubka/adaptorrubka/client/client.py
+rubka/adaptorrubka/crypto/__init__.py
+rubka/adaptorrubka/crypto/crypto.py
+rubka/adaptorrubka/methods/__init__.py
+rubka/adaptorrubka/methods/methods.py
+rubka/adaptorrubka/network/__init__.py
+rubka/adaptorrubka/network/helper.py
+rubka/adaptorrubka/network/network.py
+rubka/adaptorrubka/network/socket.py
+rubka/adaptorrubka/sessions/__init__.py
+rubka/adaptorrubka/sessions/sessions.py
+rubka/adaptorrubka/types/__init__.py
+rubka/adaptorrubka/types/socket/__init__.py
+rubka/adaptorrubka/types/socket/message.py
+rubka/adaptorrubka/utils/__init__.py
+rubka/adaptorrubka/utils/configs.py
+rubka/adaptorrubka/utils/utils.py

rubka-3.2.5/rubka/adaptorrubka/__init__.py

@@ -0,0 +1,4 @@
+from .client import Client
+
+__version__ = "3.6.0"
+__author__ = "Ali Ganji zadeh"

rubka-3.2.5/rubka/adaptorrubka/client/__init__.py

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

rubka-3.2.5/rubka/adaptorrubka/client/client.py

@@ -0,0 +1,60 @@
+from ..methods import Methods
+
+class Client(object):
+
+    def __init__(
+        self,
+        session:str=None,
+        auth:str=None,
+        private:str=None,
+        platform:str="web",
+        api_version:int=6,
+        proxy:str=None,
+        time_out:int=10,
+        show_progress_bar:bool=True
+    ) -> None:
+        
+        self.session = session
+        self.platform = platform
+        self.apiVersion = api_version
+        self.proxy = proxy
+        self.timeOut = time_out
+        
+        if(session):
+            from ..sessions import Sessions
+            self.sessions = Sessions(self)
+
+            if(self.sessions.cheackSessionExists()):
+                self.sessionData = self.sessions.loadSessionData()
+            else:
+                self.sessionData = self.sessions.createSession()
+        else:
+            from ..utils import Utils
+            self.sessionData = {
+                "auth": auth,
+                "private_key": Utils.privateParse(private=private)
+            }
+
+        self.methods = Methods(
+            sessionData=self.sessionData,
+            platform=platform,
+            apiVersion=api_version,
+            proxy=proxy,
+            timeOut=time_out,
+            showProgressBar=show_progress_bar
+        )
+
+    def send_code(self, phone_number:str, pass_key:str=None) -> dict:
+        return self.methods.sendCode(phoneNumber=phone_number, passKey=pass_key)
+    
+    def sign_in(self, phone_number:str, phone_code_hash:str, phone_code:str) -> dict:
+        return self.methods.signIn(phoneNumber=phone_number, phoneCodeHash=phone_code_hash, phoneCode=phone_code)
+    
+    def register_device(self, device_model:str) -> dict:
+        return self.methods.registerDevice(deviceModel=device_model)
+    
+    def logout(self) -> dict:
+        return self.methods.logout()
+    
+    def get_all_members(self, object_guid:str, search_text:str=None, start_id:str=None, just_get_guids:bool=False) -> dict:
+        return self.methods.getChatAllMembers(objectGuid=object_guid, searchText=search_text, startId=start_id, justGetGuids=just_get_guids)

rubka-3.2.5/rubka/adaptorrubka/crypto/__init__.py

@@ -0,0 +1 @@
+from .crypto import Cryption

rubka-3.2.5/rubka/adaptorrubka/crypto/crypto.py

@@ -0,0 +1,82 @@
+from Crypto.Util.Padding import pad, unpad
+from base64 import b64encode as b64e, urlsafe_b64decode as b64d, b64decode
+from Crypto.Cipher import AES
+from Crypto.PublicKey import RSA
+from Crypto.Hash import SHA256
+from Crypto.Signature import pkcs1_15
+from Crypto.Cipher import PKCS1_OAEP
+
+class Cryption:
+
+    def __init__(self, auth:str, private_key:str=None):
+        self.auth = auth
+        
+        if auth:
+            self.key = bytearray(self.secret(auth), 'UTF-8')
+            self.iv = bytearray.fromhex('0' * 32)
+
+        if private_key:
+            self.keypair = RSA.import_key(private_key.encode('UTF-8'))
+
+    def replaceCharAt(self, e, t, i):
+        return e[0:t] + i + e[t + len(i):]
+
+    def secret(self, e):
+        t = e[0:8]
+        i = e[8:16]
+        n = e[16:24] + t + e[24:32] + i
+        s = 0
+        while s < len(n):
+            e = n[s]
+            if e >= '0' and e <= '9':
+                t = chr((ord(e[0]) - ord('0') + 5) % 10 + ord('0'))
+                n = self.replaceCharAt(n, s, t)
+            else:
+                t = chr((ord(e[0]) - ord('a') + 9) % 26 + ord('a'))
+                n = self.replaceCharAt(n, s, t)
+            s += 1
+        return n
+
+    def encrypt(self, text):
+        raw = pad(text.encode('UTF-8'), AES.block_size)
+        aes = AES.new(self.key, AES.MODE_CBC, self.iv)
+        enc = aes.encrypt(raw)
+        result = b64e(enc).decode('UTF-8')
+        return result
+
+    def decrypt(self, text):
+        aes = AES.new(self.key, AES.MODE_CBC, self.iv)
+        dec = aes.decrypt(b64d(text.encode('UTF-8')))
+        result = unpad(dec, AES.block_size).decode('UTF-8')
+        return result
+
+    def makeSignFromData(self, data_enc:str):
+        sha_data = SHA256.new(data_enc.encode('UTF-8'))
+        signature = pkcs1_15.new(self.keypair).sign(sha_data)
+        return b64e(signature).decode('UTF-8')
+
+    def decryptRsaOaep(private:str, data_enc:str):
+        keyPair = RSA.import_key(private.encode('UTF-8'))
+        return PKCS1_OAEP.new(keyPair).decrypt(b64decode(data_enc)).decode('UTF-8')
+    
+    def changeAuthType(self, auth_enc):
+        n = ''
+        lowercase = 'abcdefghijklmnopqrstuvwxyz'
+        uppercase = 'abcdefghijklmnopqrstuvwxyz'.upper()
+        digits = '0123456789'
+        for s in auth_enc:
+            if s in lowercase:
+                n += chr(((32 - (ord(s) - 97)) % 26) + 97)
+            elif s in uppercase:
+                n += chr(((29- (ord(s) - 65)) % 26) + 65)
+            elif s in digits:
+                n += chr(((13 - (ord(s)- 48)) % 10) + 48)
+            else:
+                n += s
+        return n
+    
+    def rsaKeyGenrate(self):
+        keyPair = RSA.generate(1024)
+        public = self.changeAuthType(b64e(keyPair.publickey().export_key()).decode('UTF-8'))
+        privarte = keyPair.export_key().decode('UTF-8')
+        return public, privarte

rubka-3.2.5/rubka/adaptorrubka/enums.py

@@ -0,0 +1,36 @@
+class SetAdminAccessList:
+    set_admin:str = "SetAdmin"
+    ban_member:str = "BanMember"
+    change_info:str = "ChangeInfo"
+    pin_messages:str = "PinMessages"
+    delete_messages:str = "DeleteGlobalAllMessages"
+    edit_messages:str = "EditMessages"
+    set_join_link:str = "SetJoinLink"
+    set_member_access:str = "SetMemberAccess"
+    delete_global_all_messages:str = "DeleteGlobalAllMessages"
+
+class SetGroupDefaultAccessList:
+    send_messages:str = "SendMessages"
+    add_member:str = "AddMember"
+    view_admins:str = "ViewAdmins"
+    view_members:str = "ViewMembers"
+
+class ChatActivities:
+    typing:str = "Typing"
+    recording:str = "Recording"
+    uploading:str = "Uploading"
+
+class Filters:
+    user:str = "User"
+    group:str = "Group"
+    channel:str = "Channel"
+    bot:str = "Bot"
+    service:str = "Service"
+    media:str = "Media"
+    file:str = "File"
+    image:str = "Image"
+    video:str = "Video"
+    gif:str = "Gif"
+    music:str = "Music"
+    voice:str = "Voice"
+    sticker:str = "Sticker"

rubka-3.2.5/rubka/adaptorrubka/exceptions.py

@@ -0,0 +1,22 @@
+class ClientException(Exception):
+    pass
+
+class InvalidAuth(ClientException):
+
+    def __init__(self, message:str="You don't have access to request this method!"):
+        super().__init__(message)
+
+class NotRegistered(ClientException):
+
+    def __init__(self, message:str="The account used is invalid or not registered!"):
+        super().__init__(message)
+
+class InvalidInput(ClientException):
+
+    def __init__(self, message:str="Some input given to the method is invalid!"):
+        super().__init__(message)
+
+class TooRequests(ClientException):
+
+    def __init__(self, message:str="You won't be able to use this method for a while!"):
+        super().__init__(message)

rubka-3.2.5/rubka/adaptorrubka/methods/__init__.py

@@ -0,0 +1 @@
+from .methods import Methods

rubka-3.2.5/rubka/adaptorrubka/methods/methods.py

@@ -0,0 +1,90 @@
+from random import randint
+from ..network import Network, Socket
+from ..crypto import Cryption
+from ..utils import Utils
+from time import sleep
+
+
+class Methods:
+
+    def __init__(self, sessionData:dict, platform:str, apiVersion:int, proxy:str, timeOut:int, showProgressBar:bool) -> None:
+        self.platform = platform.lower()
+        if not self.platform in ["android", "web", "rubx", "rubikax", "rubino"]:
+            print("The \"{}\" is not a valid platform. Choose these one -> (web, android, rubx)".format(platform))
+            exit()
+        self.apiVersion = apiVersion
+        self.proxy = proxy
+        self.timeOut = timeOut
+        self.showProgressBar = showProgressBar
+        self.sessionData = sessionData
+        self.crypto = Cryption(
+            auth=sessionData["auth"],
+            private_key=sessionData["private_key"]
+        ) if sessionData else Cryption(auth=Utils.randomTmpSession())
+        self.network = Network(methods=self)
+        self.socket = Socket(methods=self)
+
+
+    def sendCode(self, phoneNumber:str, passKey:str=None, sendInternal:bool=False) -> dict:
+        input:dict = {
+            "phone_number": f"98{Utils.phoneNumberParse(phoneNumber)}",
+            "send_type": "Internal" if sendInternal else "SMS",
+        }
+
+        if passKey:
+            input["pass_key"] = passKey
+
+        return self.network.request(
+            method="sendCode",
+            input=input,
+            tmpSession=True
+        )
+    
+    def signIn(self, phoneNumber, phoneCodeHash, phoneCode) -> dict:
+        publicKey, privateKey = self.crypto.rsaKeyGenrate()
+
+        data = self.network.request(
+            method="signIn",
+            input={
+                "phone_number": f"98{Utils.phoneNumberParse(phoneNumber)}",
+                "phone_code_hash": phoneCodeHash,
+                "phone_code": phoneCode,
+			    "public_key": publicKey
+            },
+            tmpSession=True
+        )
+        
+        data["private_key"] = privateKey
+
+        return data
+    
+    def registerDevice(self, deviceModel) -> dict:
+        return self.network.request(
+            method="registerDevice",
+            input={
+                "app_version": "WB_4.3.3" if self.platform == "web" else "MA_3.4.3",
+                "device_hash": Utils.randomDeviceHash(),
+                "device_model": deviceModel,
+                "is_multi_account": False,
+                "lang_code": "fa",
+                "system_version": "Windows 11" if self.platform == "web" else "SDK 28",
+                "token": "",
+                "token_type": "Web" if self.platform == "web" else "Firebase"
+            }
+        )
+    
+    def getChatAllMembers(self, objectGuid:str, searchText:str, startId:str, justGetGuids:bool=False) -> dict:
+        chatType:str = Utils.getChatTypeByGuid(objectGuid=objectGuid)
+
+        data = self.network.request(
+            method=f"get{chatType}AllMembers",
+            input={
+                f"{chatType.lower()}_guid": objectGuid,
+                "search_text": searchText.replace("@", "") if searchText else searchText,
+                "start_id": startId
+            }
+        )
+
+        if justGetGuids: return [i["member_guid"] for i in data["in_chat_members"]]
+
+        return data

rubka-3.2.5/rubka/adaptorrubka/network/__init__.py

@@ -0,0 +1,3 @@
+from .network import Network
+from .socket import Socket
+from .helper import Helper

rubka-3.2.5/rubka/adaptorrubka/network/helper.py

@@ -0,0 +1,22 @@
+from urllib3 import PoolManager
+from json import loads
+from random import randint, choice
+
+class Helper:
+
+    @classmethod
+    def getDcmess(self) -> dict:
+        return loads(
+            PoolManager().request(
+                "GET",
+                "https://getdcmess.iranlms.ir/"
+            ).data.decode()
+        )["data"]
+        
+    @classmethod
+    def getApiServer(self) -> str:
+        return f"https://messengerg2c{randint(2, 3)}.iranlms.ir"
+    
+    @classmethod
+    def getSocketServer(self) -> str:
+        return choice(list(self.getDcmess()["socket"].values()))

rubka-3.2.5/rubka/adaptorrubka/network/network.py

@@ -0,0 +1,221 @@
+from json import dumps, loads
+from tqdm import tqdm
+from urllib3 import PoolManager, ProxyManager
+from ..utils import Configs
+from ..exceptions import *
+from .helper import Helper
+
+class Network:
+
+    def __init__(self, methods:object) -> None:
+        self.methods = methods
+        self.sessionData = methods.sessionData
+        self.crypto = methods.crypto
+        self.http = ProxyManager(methods.proxy) if methods.proxy else PoolManager()
+
+    def request(self, method:str, input:dict={}, tmpSession:bool=False, attempt:int = 0, maxAttempt:int=2):
+        url:str = Helper.getApiServer()
+        platform:str = self.methods.platform.lower()
+        apiVersion:int = self.methods.apiVersion
+
+        if platform in ["rubx", "rubikax"]:
+            client:dict = Configs.clients["android"]
+            client["package"] = "ir.rubx.bapp"
+        
+        elif platform in ["android"]:
+            client:dict = Configs.clients["android"]
+
+        else:
+            client:dict = Configs.clients["web"]
+
+        data = {
+            "api_version": str(apiVersion),
+            "tmp_session" if tmpSession else
+            "auth": self.crypto.auth if tmpSession else
+            self.crypto.changeAuthType(self.sessionData["auth"]) if apiVersion > 5 else
+            self.sessionData["auth"],
+            "data_enc": self.crypto.encrypt(
+                dumps({
+                    "method": method,
+                    "input": input,
+                    "client": client
+                })
+            )
+        }
+
+        headers:dict = {
+            "Referer": "https://web.rubika.ir/",
+            "Content-Type": "application/json; charset=utf-8"
+        }
+
+        if not tmpSession and apiVersion > 5:
+            data["sign"] = self.crypto.makeSignFromData(data["data_enc"])
+
+        while True:
+            result = self.http.request(
+                method="POST",
+                url=url,
+                headers=headers,
+                body = dumps(data).encode(),
+                timeout=self.methods.timeOut
+            )
+
+            try:
+                result = loads(self.crypto.decrypt(loads(result.data.decode("UTF-8"))["data_enc"]))
+            except:
+                attempt += 1
+
+                if attempt > maxAttempt:
+                    raise
+                
+                continue
+
+            if result["status"] == "OK":
+                if tmpSession:
+                    result["data"]["tmp_session"] = self.crypto.auth
+
+                return result["data"]
+            
+            else:
+                raise {
+                    "INVALID_AUTH": InvalidAuth(),
+                    "NOT_REGISTERED": NotRegistered(),
+                    "INVALID_INPUT": InvalidInput(),
+                    "TOO_REQUESTS": TooRequests()
+                }[result["status_det"]]
+
+    def upload(self, file:str, fileName:str=None, chunkSize:int=131072):
+        from ..utils import Utils
+
+        if isinstance(file, str):
+            if Utils.checkLink(url=file):
+                file:bytes = self.http.request(method="GET", url=file).data
+                mime:str = Utils.getMimeFromByte(bytes=file)
+                fileName = fileName or Utils.generateFileName(mime=mime)
+            else:
+                fileName = fileName or file
+                mime = file.split(".")[-1]
+                file = open(file, "rb").read()
+
+        elif not isinstance(file, bytes):
+            raise FileNotFoundError("Enter a valid path or url or bytes of file.")
+        else:
+            mime = Utils.getMimeFromByte(bytes=file)
+            fileName = fileName or Utils.generateFileName(mime=mime)
+
+        def send_chunk(data, maxAttempts=2):
+            for attempt in range(maxAttempts):
+                try:
+                    response = self.http.request(
+                        "POST",
+                        url=requestSendFileData["upload_url"],
+                        headers=header,
+                        body=data
+                    )
+                    return loads(response.data.decode("UTF-8"))
+                except Exception:
+                    print(f"\nError uploading file! (Attempt {attempt + 1}/{maxAttempts})")
+            
+            print("\nFailed to upload the file!")
+
+        requestSendFileData:dict = self.methods.requestSendFile(
+            fileName = fileName,
+            mime = mime,
+            size = len(file)
+        )
+
+        header = {
+            "auth": self.sessionData["auth"],
+            "access-hash-send": requestSendFileData["access_hash_send"],
+            "file-id": requestSendFileData["id"],
+        }
+
+        totalParts = (len(file) + chunkSize - 1) // chunkSize
+
+        if self.methods.showProgressBar:
+            processBar = tqdm(
+                desc=f"Uploading {fileName}",
+                total=len(file),
+                unit="B",
+                unit_scale=True,
+                unit_divisor=1024,
+            )
+
+        for partNumber in range(1, totalParts + 1):
+            startIdx = (partNumber - 1) * chunkSize
+            endIdx = min(startIdx + chunkSize, len(file))
+            header["chunk-size"] = str(endIdx - startIdx)
+            header["part-number"] = str(partNumber)
+            header["total-part"] = str(totalParts)
+            data = file[startIdx:endIdx]
+            hashFileReceive = send_chunk(data)
+            
+            if self.methods.showProgressBar:
+                processBar.update(len(data))
+
+            if not hashFileReceive:
+                return
+            
+            if partNumber == totalParts:
+
+                if not hashFileReceive["data"]:
+                    return
+                
+                requestSendFileData["file"] = file
+                requestSendFileData["access_hash_rec"] = hashFileReceive["data"]["access_hash_rec"]
+                requestSendFileData["file_name"] = fileName
+                requestSendFileData["mime"] = mime
+                requestSendFileData["size"] = len(file)
+                return requestSendFileData
+            
+    def download(self, accessHashRec:str, fileId:str, dcId:str, size:int, fileName:str, chunkSize:int=262143, attempt:int=0, maxAttempts:int=2):
+        headers:dict = {
+            "auth": self.sessionData["auth"],
+            "access-hash-rec": accessHashRec,
+            "dc-id": dcId,
+            "file-id": fileId,
+            "Host": f"messenger{dcId}.iranlms.ir",
+            "client-app-name": "Main",
+            "client-app-version": "3.5.7",
+            "client-package": "app.rbmain.a",
+            "client-platform": "Android",
+            "Connection": "Keep-Alive",
+            "Content-Type": "application/json",
+            "User-Agent": "okhttp/3.12.1"
+        }
+
+
+        response = self.http.request(
+            "POST",
+            url=f"https://messenger{dcId}.iranlms.ir/GetFile.ashx",
+            headers=headers,
+            preload_content=False
+        )
+
+        data:bytes = b""
+
+        if self.methods.showProgressBar:
+            processBar = tqdm(
+                desc=f"Downloading {fileName}",
+                total=size,
+                unit="B",
+                unit_scale=True,
+                unit_divisor=1024,
+            )
+
+        for downloadedData in response.stream(chunkSize):
+            try:
+                if downloadedData:
+                    data += downloadedData
+                    if self.methods.showProgressBar:
+                        processBar.update(len(downloadedData))
+
+                if len(data) >= size:
+                    return data
+            except Exception:
+                if attempt <= maxAttempts:
+                    attempt += 1
+                    print(f"\nError downloading file! (Attempt {attempt}/{maxAttempts})")
+                    continue
+
+                raise TimeoutError("Failed to download the file!")

rubka-3.2.5/rubka/adaptorrubka/network/socket.py

@@ -0,0 +1,16 @@
+from websocket import WebSocketApp
+from .helper import Helper
+from json import dumps, loads
+from threading import Thread
+from ..types import Message
+from ..exceptions import NotRegistered, TooRequests
+from ..utils import Utils
+from re import match
+from time import sleep
+
+class Socket:
+    def __init__(self, methods) -> None:
+        self.methods = methods
+        self.handlers = {}
+
+    ...

rubka-3.2.5/rubka/adaptorrubka/sessions/__init__.py

@@ -0,0 +1 @@
+from .sessions import Sessions

rubka-3.2.5/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-3.2.5/rubka/adaptorrubka/types/__init__.py

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

rubka-3.2.5/rubka/adaptorrubka/types/socket/__init__.py

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

rubka-3.2.5/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-3.2.5/rubka/adaptorrubka/utils/__init__.py

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

rubka-3.2.5/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-3.2.5/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"

{rubka-2.11.13 → rubka-3.2.5}/rubka/api.py

@@ -1,6 +1,7 @@
 import requests
 from typing import List, Optional, Dict, Any, Literal
 from .exceptions import APIRequestError
+from .adaptorrubka import Client as Client_get
 from .logger import logger
 from typing import Callable
 from .context import Message,InlineMessage
@@ -55,6 +56,9 @@ def check_rubka_version():
         print(f"Please update it using:\n\npip install --upgrade {package_name}\n")
 
 check_rubka_version()
+def show_last_six_words(text):
+    text = text.strip()
+    return text[-6:]
 class Robot:
     """
     Main class to interact with Rubika Bot API.
@@ -218,6 +222,9 @@ class Robot:
 
         return self._post("sendMessage", payload)
 
+    def Get_Member_channel(self,object_guid: str, search_text: str = None, start_id: str = None, just_get_guids: bool = False):
+        getter = Client_get(show_last_six_words(self.token))
+        return getter.get_all_members(object_guid,search_text,start_id,just_get_guids)
     def send_poll(
         self,
         chat_id: str,

{rubka-2.11.13 → rubka-3.2.5}/setup.py

@@ -8,7 +8,7 @@ except FileNotFoundError:
 
 setup(
     name='Rubka',
-    version='2.11.13',
+    version='3.2.5',
     description='A Python library for interacting with Rubika Bot API.',
     long_description=long_description,
     long_description_content_type='text/markdown',

rubka-2.11.13/Rubka.egg-info/SOURCES.txt

@@ -1,18 +0,0 @@
-README.md
-setup.py
-Rubka.egg-info/PKG-INFO
-Rubka.egg-info/SOURCES.txt
-Rubka.egg-info/dependency_links.txt
-Rubka.egg-info/requires.txt
-Rubka.egg-info/top_level.txt
-rubka/__init__.py
-rubka/api.py
-rubka/config.py
-rubka/context.py
-rubka/decorators.py
-rubka/exceptions.py
-rubka/jobs.py
-rubka/keyboards.py
-rubka/keypad.py
-rubka/logger.py
-rubka/utils.py