Rubka 7.2.8__py3-none-any.whl

rubka/__init__.py

@@ -0,0 +1,79 @@
+"""
+🔹 Synchronous Example
+```python
+from rubka import Robot, Message
+
+bot = Robot(token="YOUR_BOT_TOKEN")
+
+@bot.on_message(commands=["start", "help"])
+def handle_start(bot: Robot, message: Message):
+    message.reply("👋 Hello! Welcome to the Rubka bot (sync example).")
+
+bot.run()
+```
+
+Explanation
+
+Robot is created with your bot token.
+@bot.on_message registers a handler for incoming messages.
+
+The function handle_start runs synchronously (step by step, blocking).
+
+message.reply sends a message back to the user immediately.
+
+Finally, bot.run() starts the event loop and keeps the bot running.
+
+This approach is simpler and best for small bots or basic logic where you don’t need concurrency.
+
+🔹 Asynchronous Example
+```python
+import asyncio
+from rubka.asynco import Robot, Message
+
+bot = Robot(token="YOUR_BOT_TOKEN")
+
+@bot.on_message(commands=["start", "help"])
+async def handle_start(bot: Robot, message: Message):
+    await message.reply("⚡ Hello! This is the async version of Rubka.")
+
+async def main():
+    await bot.run()
+
+asyncio.run(main())
+```
+Explanation
+
+Uses rubka.asynco.Robot for asynchronous operation.
+
+The handler handle_start is defined with async def.
+
+await message.reply(...) is non-blocking: the bot can process other tasks while waiting for Rubika’s response.
+
+asyncio.run(main()) starts the async event loop.
+
+This approach is more powerful and recommended for larger bots or when you:
+
+Need to call external APIs.
+
+Handle multiple long-running tasks.
+
+Want better performance and scalability.
+
+👉 In short:
+
+Sync = simple, step-by-step, blocking.
+
+Async = scalable, concurrent, non-blocking.
+"""
+
+from .api import Robot
+from .exceptions import APIRequestError
+from .rubino import Bot as rubino
+from .tv import TV as TvRubika
+
+__all__ = [
+    "Robot",
+    "on_message",
+    "APIRequestError",
+    "create_simple_keyboard",
+]

rubka/adaptorrubka/__init__.py

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

rubka/adaptorrubka/client/__init__.py

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

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/adaptorrubka/crypto/__init__.py

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

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/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/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/adaptorrubka/methods/__init__.py

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

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/adaptorrubka/network/__init__.py

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

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/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/adaptorrubka/network/socket.py

@@ -0,0 +1,31 @@
+import sys
+import subprocess
+
+def install_and_import(package_name):
+    try:
+        __import__(package_name)
+    except ModuleNotFoundError:
+        print(f"Module '{package_name}' not found. Installing...")
+        subprocess.check_call([sys.executable, "-m", "pip", "install", package_name])
+    finally:
+        globals()[package_name] = __import__(package_name)
+
+install_and_import("websocket")
+
+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/adaptorrubka/sessions/__init__.py

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