pyrogram-client 0.0.2.dev1__py3-none-any.whl

pyro_client/client/base.py

@@ -0,0 +1,42 @@
+from asyncio import sleep
+from io import BytesIO
+from typing import Literal
+
+from pyrogram import Client
+from pyrogram.filters import chat
+from pyrogram.handlers import MessageHandler
+from pyrogram.types import Message
+
+from pyro_client.storage import PgStorage
+
+AuthTopic = Literal["phone", "code", "pass"]
+
+
+class BaseClient(Client):
+    storage: PgStorage
+
+    def __init__(self, name: str, *args, **kwargs):
+        super().__init__(name, *args, storage_engine=PgStorage(name), **kwargs)
+
+    async def send(self, txt: str, uid: int | str = "me", photo: bytes = None, video: bytes = None) -> Message:
+        if photo:
+            return await self.send_photo(uid, BytesIO(photo), txt)
+        elif video:
+            return await self.send_video(uid, BytesIO(video), txt)
+        else:
+            return await self.send_message(uid, txt)
+
+    async def wait_from(self, uid: int, topic: str, past: int = 0, timeout: int = 10) -> str:
+        handler = MessageHandler(self.got_msg, chat(uid))
+        self.add_handler(handler)
+        while past < timeout:
+            if txt := self.storage.session.state.get(uid, {}).pop(topic, None):
+                self.remove_handler(handler)
+                return txt
+            await sleep(1)
+            past += 1
+            return await self.wait_from(uid, topic, past, timeout)
+
+    async def got_msg(self, _, msg: Message):
+        if topic := self.storage.session.state.get(msg.from_user.id, {}).pop("waiting_for", None):
+            self.storage.session.state[msg.from_user.id][topic] = msg.text

pyro_client/client/bot.py

@@ -0,0 +1,9 @@
+from pyro_client.client.base import BaseClient, AuthTopic
+
+
+class BotClient(BaseClient):
+    def __init__(self, api_id: str, api_hash: str, token: str):
+        super().__init__(token.split(":")[0], api_id, api_hash, bot_token=token)
+
+    async def wait_auth_from(self, uid: int, topic: AuthTopic, past: int = 0, timeout: int = 60) -> str:
+        return await super().wait_from(uid, topic, past, timeout)

pyro_client/client/file.py

@@ -0,0 +1,58 @@
+from io import BytesIO
+
+from pyrogram.raw.functions.messages import UploadMedia
+from pyrogram.raw.functions.upload import GetFile
+from pyrogram.raw.types import (
+    MessageMediaDocument,
+    InputMediaUploadedDocument,
+    InputPeerSelf,
+    MessageMediaPhoto,
+    InputMediaUploadedPhoto,
+    InputDocumentFileLocation,
+    InputPhotoFileLocation,
+)
+from pyrogram.raw.types.upload import File
+from pyrogram.types import Message
+
+from pyro_client.client.bot import BotClient
+
+
+class FileClient(BotClient):
+    @staticmethod
+    def ref_enc(ph_id: int, access_hash: int, ref: bytes) -> bytes:
+        return ph_id.to_bytes(8, "big") + access_hash.to_bytes(8, "big", signed=True) + ref
+
+    @staticmethod
+    def ref_dec(full_ref: bytes) -> tuple[int, int, bytes]:
+        pid, ah = int.from_bytes(full_ref[:8], "big"), int.from_bytes(full_ref[8:16], "big", signed=True)
+        return pid, ah, full_ref[16:]
+
+    async def save_doc(self, byts: bytes, ctype: str) -> tuple[MessageMediaDocument, bytes]:
+        in_file = await self.save_file(BytesIO(byts))
+        imud = InputMediaUploadedDocument(file=in_file, mime_type=ctype, attributes=[])
+        upf: MessageMediaDocument = await self.invoke(UploadMedia(peer=InputPeerSelf(), media=imud))
+        return upf, (
+            upf.document.id.to_bytes(8, "big")
+            + upf.document.access_hash.to_bytes(8, "big", signed=True)
+            + upf.document.file_reference
+        )
+
+    async def save_photo(self, file: bytes) -> tuple[MessageMediaPhoto, bytes]:
+        in_file = await self.save_file(BytesIO(file))
+        upm = UploadMedia(peer=InputPeerSelf(), media=InputMediaUploadedPhoto(file=in_file))
+        upp: MessageMediaPhoto = await self.invoke(upm)
+        return upp, self.ref_enc(upp.photo.id, upp.photo.access_hash, upp.photo.file_reference)
+
+    async def get_doc(self, fid: bytes) -> File:
+        pid, ah, ref = self.ref_dec(fid)
+        loc = InputDocumentFileLocation(id=pid, access_hash=ah, file_reference=ref, thumb_size="x")
+        return await self.invoke(GetFile(location=loc, offset=0, limit=512 * 1024))
+
+    async def get_photo(self, fid: bytes, st: str) -> File:
+        pid, ah, ref = self.ref_dec(fid)
+        loc = InputPhotoFileLocation(id=pid, access_hash=ah, file_reference=ref, thumb_size=st)
+        return await self.invoke(GetFile(location=loc, offset=0, limit=512 * 1024))
+
+    async def bot_got_msg(self, _, msg: Message):
+        if state := self.storage.session.state.pop("bot", None):
+            self.storage.session.state[state] = msg.text

pyro_client/client/user.py

@@ -0,0 +1,106 @@
+from pyrogram import enums
+from pyrogram.errors import BadRequest, SessionPasswordNeeded, AuthKeyUnregistered
+from pyrogram.types import Message, User, SentCode
+
+from pyro_client.client.base import BaseClient, AuthTopic
+from pyro_client.client.bot import BotClient
+
+
+class UserClient(BaseClient):
+    bot: BotClient
+
+    def __init__(self, name: str, api_id: str, api_hash: str, bot_token: str = None, proxy: dict = None,
+                 device: str = "iPhone 17 Air", app: str = "XyncNet 1.0", ver: str = "iOS 19.0.1"):
+        super().__init__(name, api_id, api_hash, device_model=device, app_version=app, system_version=ver)
+        self.bot = bot_token and BotClient(api_id, api_hash, bot_token)
+
+    async def start(self, use_qr: bool = False, except_ids: list[int] = None):
+        await self.bot.start()
+        await super().start(use_qr=use_qr, except_ids=except_ids or [])
+
+    async def ask_for(self, topic: AuthTopic, question: str) -> str:
+        await self.bot.send_message(self.storage.me_id, question)
+        self.bot.storage.session.state[self.storage.me_id] = {"waiting_for": topic}
+        return await self.bot.wait_auth_from(self.storage.me_id, topic)
+
+    async def receive(self, txt: str, photo: bytes = None, video: bytes = None) -> Message:
+        return await self.bot.send(txt, self.me.id, photo, video)
+
+    async def authorize(self, sent_code: SentCode = None) -> User:
+        sent_code_desc = {
+            enums.SentCodeType.APP: "Telegram app",
+            enums.SentCodeType.SMS: "SMS",
+            enums.SentCodeType.CALL: "phone call",
+            enums.SentCodeType.FLASH_CALL: "phone flash call",
+            enums.SentCodeType.FRAGMENT_SMS: "Fragment SMS",
+            enums.SentCodeType.EMAIL_CODE: "email code",
+        }
+        # Step 1: Phone
+        if not self.phone_number:
+            try:
+                self.phone_number = await self.ask_for("phone", "Your phone:")
+                if not self.phone_number:
+                    await self.authorize()
+                sent_code = await self.send_code(self.phone_number)
+            except BadRequest as e:
+                await self.send(e.MESSAGE)
+                self.phone_number = None
+                return await self.authorize(sent_code)
+        # Step 2: Code
+        if not self.phone_code:
+            _ = await self.ask_for("code", f"The confirm code sent via {sent_code_desc[sent_code.type]}")
+            self.phone_code = _.replace("_", "")
+            try:
+                signed_in = await self.sign_in(self.phone_number, sent_code.phone_code_hash, self.phone_code)
+            except BadRequest as e:
+                await self.send(e.MESSAGE)
+                self.phone_code = None
+                return await self.authorize(sent_code)
+            except SessionPasswordNeeded as e:
+                # Step 2.1?: Cloud password
+                await self.send(e.MESSAGE)
+                while True:
+                    self.password = await self.ask_for("pass", f"Enter pass: (hint: {await self.get_password_hint()})")
+                    try:
+                        return await self.check_password(self.password)
+                    except BadRequest as e:
+                        await self.send(e.MESSAGE)
+                        self.password = None
+
+            if isinstance(signed_in, User):
+                await self.send("✅")
+                return signed_in
+
+            if not signed_in:
+                await self.send("No registered such phone number")
+
+    async def stop(self, block: bool = True):
+        await super().stop(block)
+        await self.bot.stop(block)
+
+
+async def main():
+    from x_auth import models
+    from x_model import init_db
+
+    from pyro_client.loader import WSToken, PG_DSN, TOKEN, API_ID, API_HASH
+
+    _ = await init_db(PG_DSN, models, True)
+    await models.Proxy.load_list(WSToken)
+    session = await models.Session.filter(is_bot=False).order_by("-date").first()
+    uc = UserClient("", API_ID, API_HASH, TOKEN)
+    # try:
+    await uc.start()
+    await uc.receive("hi")
+    # except Exception as e:
+    #     print(e.MESSAGE)
+    #     await uc.send(e.MESSAGE)
+    #     await uc.storage.session.delete()
+    # finally:
+    await uc.stop()
+
+
+if __name__ == "__main__":
+    from asyncio import run
+
+    run(main())

pyro_client/loader.py

@@ -0,0 +1,11 @@
+from dotenv import load_dotenv
+from os import getenv as env
+
+load_dotenv()
+
+API_ID = env("API_ID")
+API_HASH = env("API_HASH")
+PG_DSN = f"postgres://{env('POSTGRES_USER')}:{env('POSTGRES_PASSWORD')}@{env('POSTGRES_HOST', 'xyncdbs')}:" \
+         f"{env('POSTGRES_PORT', 5432)}/{env('POSTGRES_DB', env('POSTGRES_USER'))}"
+TOKEN = env("TOKEN")
+WSToken = env("WST")

pyro_client/storage.py

@@ -0,0 +1,144 @@
+import time
+from typing import Any
+
+from pyrogram import raw, utils
+from pyrogram.storage import Storage
+from tortoise.functions import Count
+from x_auth.models import Proxy, Username, Version, Session, Peer, UpdateState
+
+from pyro_client.loader import WSToken
+
+
+def get_input_peer(peer_id: int, access_hash: int, peer_type: str):
+    if peer_type in ["user", "bot"]:
+        return raw.types.InputPeerUser(user_id=peer_id, access_hash=access_hash)
+
+    if peer_type == "group":
+        return raw.types.InputPeerChat(chat_id=-peer_id)
+
+    if peer_type in ["channel", "supergroup"]:
+        return raw.types.InputPeerChannel(channel_id=utils.get_channel_id(peer_id), access_hash=access_hash)
+
+    raise ValueError(f"Invalid peer type: {peer_type}")
+
+
+class PgStorage(Storage):
+    VERSION = 1
+    USERNAME_TTL = 8 * 60 * 60
+    session: Session
+    me_id: int
+
+    async def open(self):
+        self.me_id = int((uid_dc := self.name.split("_")).pop(0))
+        if not (session := await Session.get_or_none(id=self.name)):
+            username, _ = await Username.get_or_create(id=self.me_id)
+            await Proxy.load_list(WSToken)
+            # await Proxy.get_replaced(WSToken)
+            proxy = (
+                await Proxy.annotate(sessions_count=Count("sessions"))
+                .filter(valid=True)
+                .order_by("sessions_count", "-updated_at")
+                .first()
+            )
+            session = await Session.create(
+                id=self.name,
+                user=username,
+                dc_id=int(uid_dc[0]) if uid_dc else None,
+                date=int(time.time()),
+                proxy=proxy,
+            )
+        self.session = session
+
+    async def save(self):
+        await self.date(int(time.time()))
+
+    async def close(self): ...
+
+    async def delete(self):
+        await Session.filter(id=self.name).delete()
+
+    async def update_peers(self, peers: list[tuple[int, int, str, str]]):
+        for peer in peers:
+            uid, ac_hsh, typ, phn = peer
+            un, _ = await Username.get_or_create(id=uid)
+            await Peer.update_or_create(
+                {"username": un, "type": typ, "phone_number": phn}, session_id=self.name, id=ac_hsh
+            )
+
+    async def update_usernames(self, usernames: list[tuple[int, list[str]]]):
+        for telegram_id, user_list in usernames:
+            for username in user_list:
+                await Username.update_or_create({"username": username}, id=telegram_id)
+
+    async def get_peer_by_id(self, peer_id_or_username: int | str):
+        attr = "id" if isinstance(peer_id_or_username, int) else "username"
+        if not (peer := await Peer.get_or_none(session_id=self.name, **{"username__" + attr: peer_id_or_username})):
+            raise KeyError(f"User not found: {peer_id_or_username}")
+        if peer.last_update_on:
+            if abs(time.time() - peer.last_update_on.timestamp()) > self.USERNAME_TTL:
+                raise KeyError(f"Username expired: {peer_id_or_username}")
+        return get_input_peer(peer.username_id, peer.id, peer.type)
+
+    async def get_peer_by_username(self, username: str):
+        return await self.get_peer_by_id(username)
+
+    async def update_state(self, value: tuple[int, int, int, int, int] = object):
+        if value is None:
+            return await UpdateState.filter(session_id=self.name)
+        elif isinstance(value, int):
+            await UpdateState.filter(session_id=self.name, id=value).delete()
+        else:
+            sid, pts, qts, date, seq = value
+            await UpdateState.get_or_create(
+                {"pts": pts, "qts": qts, "date": date, "seq": seq}, session_id=self.name, id=sid
+            )
+
+    async def get_peer_by_phone_number(self, phone_number: str):
+        if not (
+            peer := await Peer.filter(session_id=self.name, phone_number=phone_number).values_list(
+                "id", "access_hash", "type"
+            )
+        ):
+            raise KeyError(f"Phone number not found: {phone_number}")
+        return get_input_peer(*peer)
+
+    async def _get(self, attr: str):
+        return await Session.get(id=self.name).values_list(attr, flat=True)
+
+    async def _set(self, attr: str, value):
+        await Session.update_or_create({attr: value}, id=self.name)
+
+    async def _accessor(self, attr: str, value: Any = object):
+        if value == object:
+            return await self._get(attr)
+        else:
+            await self._set(attr, value)
+
+    async def dc_id(self, value: int = object):
+        return await self._accessor("dc_id", value)
+
+    async def api_id(self, value: int = object):
+        return await self._accessor("api_id", value)
+
+    async def test_mode(self, value: bool = object):
+        return await self._accessor("test_mode", value)
+
+    async def auth_key(self, value: bytes = object):
+        return await self._accessor("auth_key", value)
+
+    async def date(self, value: int = object):
+        return await self._accessor("date", value)
+
+    async def user_id(self, value: int = object):
+        return await self._accessor("user_id", value)
+
+    async def is_bot(self, value: bool = object):
+        return await self._accessor("is_bot", value)
+
+    @staticmethod
+    async def version(value: int = object):
+        if value == object:
+            ver = await Version.first()
+            return ver.number
+        else:
+            await Version.update_or_create(id=value)

pyrogram_client-0.0.2.dev1.dist-info/METADATA

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: pyrogram-client
+Version: 0.0.2.dev1
+Author-email: Mike Artemiev <mixartemev@gmail.com>
+Project-URL: Homepage, https://gitlab.com/XyncNet/pyro-client
+Project-URL: Repository, https://gitlab.com/XyncNet/pyro-client
+Requires-Python: >=3.11
+Requires-Dist: kurigram
+Requires-Dist: tgcrypto
+Requires-Dist: xn-auth
+Provides-Extra: dev
+Requires-Dist: build; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
+Requires-Dist: python-dotenv; extra == "dev"
+Requires-Dist: setuptools-scm; extra == "dev"
+Requires-Dist: twine; extra == "dev"

pyrogram_client-0.0.2.dev1.dist-info/RECORD

@@ -0,0 +1,10 @@
+pyro_client/loader.py,sha256=CsBBsb8PfEtU4z7eDMlkc0V3x4PfwTvc2R1HbdVhAMg,362
+pyro_client/storage.py,sha256=c538LC1uof0glq2LIWlyd5yqJxqWz1FUgqF9l6znBCQ,5419
+pyro_client/client/base.py,sha256=m3NiiqnWTMvYvZO9p2HXFboBIUDN_NcERrek0aw-QiM,1550
+pyro_client/client/bot.py,sha256=GECmzAQh0MU3REJB8dsq5A0sIeDzzmnRYYfftRG5xF8,406
+pyro_client/client/file.py,sha256=JzP-BqqOdfP8LfVXI-qnO4hIS68mZaMnk8SVqrSngA0,2548
+pyro_client/client/user.py,sha256=2GndFXUCESC6H2H8M3JgZZK3x2GkZx1I2UXHjjAiTwY,4289
+pyrogram_client-0.0.2.dev1.dist-info/METADATA,sha256=m46X7Bm523iBohF3ogVn7JoqjfUAAybkdPC3gx65zSA,563
+pyrogram_client-0.0.2.dev1.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+pyrogram_client-0.0.2.dev1.dist-info/top_level.txt,sha256=pR3onX0Aots7ODOSrd8dssJg3J2kz36Crt_48QSwyi0,12
+pyrogram_client-0.0.2.dev1.dist-info/RECORD,,

pyrogram_client-0.0.2.dev1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.7.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pyrogram_client-0.0.2.dev1.dist-info/top_level.txt

@@ -0,0 +1 @@
+pyro_client