pyrogram-client 0.0.2__py3-none-any.whl

pyro_client/client/base.py

@@ -0,0 +1,82 @@
+import asyncio
+from collections import OrderedDict
+from io import BytesIO
+from typing import Literal
+
+from pyrogram import Client
+from pyrogram.filters import chat, contact, AndFilter
+from pyrogram.handlers import MessageHandler
+from pyrogram.types import Message, InlineKeyboardMarkup, InlineKeyboardButton, ReplyKeyboardMarkup, KeyboardButton
+
+from pyro_client.client.single import SingleMeta
+from pyro_client.storage import PgStorage
+
+AuthTopic = Literal["phone", "code", "pass"]
+
+
+def sync_call_async(async_func, *args):
+    loop = asyncio.get_event_loop()  # Получаем текущий запущенный цикл
+    if loop.is_running():
+        future = asyncio.run_coroutine_threadsafe(async_func(*args), loop)
+        return future.result(5)  # Блокируемся, пока корутина не выполнится
+
+
+class BaseClient(Client, metaclass=SingleMeta):
+    storage: PgStorage
+
+    def __init__(self, name: str, api_id, api_hash, *args, **kwargs):
+        super().__init__(name, api_id=api_id, api_hash=api_hash, *args, storage_engine=PgStorage(name), **kwargs)
+
+    async def send(
+        self,
+        txt: str,
+        uid: int | str = "me",
+        btns: list[InlineKeyboardButton | KeyboardButton] = None,
+        photo: bytes = None,
+        video: bytes = None,
+    ) -> Message:
+        ikm = (
+            (
+                InlineKeyboardMarkup([btns])
+                if isinstance(btns[0], InlineKeyboardButton)
+                else ReplyKeyboardMarkup([btns], one_time_keyboard=True)
+            )
+            if btns
+            else None
+        )
+        if photo:
+            return await self.send_photo(uid, BytesIO(photo), txt, reply_markup=ikm)
+        elif video:
+            return await self.send_video(uid, BytesIO(video), txt, reply_markup=ikm)
+        else:
+            return await self.send_message(uid, txt, reply_markup=ikm)
+
+    async def wait_from(self, uid: int, topic: str, past: int = 0, timeout: int = 10) -> str | None:
+        fltr = chat(uid)
+        if topic == "phone":
+            fltr &= contact
+        handler = MessageHandler(self.got_msg, fltr)
+        # handler, g = self.add_handler(handler, 1)
+        g = 0
+        if g not in self.dispatcher.groups:
+            self.dispatcher.groups[g] = []
+            self.dispatcher.groups = OrderedDict(sorted(self.dispatcher.groups.items()))
+        self.dispatcher.groups[g].append(handler)
+        #
+        while past < timeout:
+            if txt := self.storage.session.state.get(uid, {}).pop(topic, None):
+                # self.remove_handler(handler)
+                self.dispatcher.groups[g].remove(handler)
+                #
+                return txt
+            await asyncio.sleep(1)
+            past += 1
+        return self.remove_handler(handler, g)
+
+    async def got_msg(self, _, msg: Message):
+        if tpc := self.storage.session.state.get(msg.from_user.id, {}).pop("waiting_for", None):
+            self.storage.session.state[msg.from_user.id][tpc] = msg.contact.phone_number if tpc == "phone" else msg.text
+
+    def rm_handler(self, uid: int):
+        for gi, grp in self.dispatcher.groups.items():
+            [self.remove_handler(h, gi) for h in grp if isinstance(h.filters, AndFilter) and uid in h.filters.base]

pyro_client/client/bot.py

@@ -0,0 +1,11 @@
+from x_auth.models import Session
+
+from pyro_client.client.base import BaseClient, AuthTopic
+
+
+class BotClient(BaseClient):
+    def __init__(self, sess: Session, _=None):
+        super().__init__(sess.id, sess.api.id, sess.api.hsh, bot_token=f"{sess.id}:{sess.is_bot}")
+
+    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/dc.json

@@ -0,0 +1,180 @@
+{
+  "7": 2,
+  "1": 1,
+  "20": 4,
+  "211": 2,
+  "212": 4,
+  "213": 4,
+  "216": 4,
+  "218": 4,
+  "220": 4,
+  "221": 4,
+  "222": 4,
+  "223": 4,
+  "224": 4,
+  "225": 4,
+  "226": 4,
+  "227": 4,
+  "228": 4,
+  "229": 4,
+  "230": 4,
+  "231": 4,
+  "232": 4,
+  "233": 4,
+  "234": 4,
+  "235": 4,
+  "236": 4,
+  "237": 4,
+  "238": 4,
+  "239": 4,
+  "240": 4,
+  "241": 4,
+  "242": 4,
+  "243": 4,
+  "244": 4,
+  "245": 4,
+  "246": 2,
+  "247": 4,
+  "248": 4,
+  "249": 4,
+  "250": 4,
+  "251": 4,
+  "252": 4,
+  "253": 4,
+  "254": 4,
+  "255": 4,
+  "256": 4,
+  "257": 4,
+  "258": 4,
+  "260": 4,
+  "261": 4,
+  "262": 4,
+  "263": 4,
+  "264": 4,
+  "265": 4,
+  "266": 4,
+  "267": 4,
+  "268": 4,
+  "269": 4,
+  "27": 4,
+  "290": 4,
+  "291": 4,
+  "297": 1,
+  "298": 4,
+  "299": 1,
+  "30": 4,
+  "31": 4,
+  "32": 4,
+  "33": 4,
+  "34": 4,
+  "36": 4,
+  "373": 2,
+  "374": 2,
+  "375": 2,
+  "380": 2,
+  "39": 4,
+  "40": 4,
+  "41": 4,
+  "43": 4,
+  "44": 4,
+  "45": 4,
+  "46": 4,
+  "47": 4,
+  "48": 4,
+  "49": 2,
+  "500": 1,
+  "501": 1,
+  "502": 1,
+  "503": 1,
+  "504": 1,
+  "505": 1,
+  "506": 1,
+  "507": 1,
+  "508": 1,
+  "509": 1,
+  "51": 1,
+  "52": 1,
+  "53": 1,
+  "54": 1,
+  "55": 1,
+  "56": 1,
+  "57": 1,
+  "58": 1,
+  "590": 1,
+  "591": 1,
+  "592": 1,
+  "593": 1,
+  "594": 1,
+  "595": 1,
+  "596": 1,
+  "597": 1,
+  "598": 1,
+  "599": 2,
+  "60": 5,
+  "61": 5,
+  "62": 5,
+  "63": 5,
+  "64": 5,
+  "65": 5,
+  "66": 5,
+  "672": 1,
+  "673": 5,
+  "674": 1,
+  "675": 5,
+  "676": 5,
+  "677": 5,
+  "678": 1,
+  "679": 1,
+  "680": 1,
+  "681": 1,
+  "682": 1,
+  "683": 1,
+  "684": 1,
+  "685": 1,
+  "686": 1,
+  "687": 1,
+  "688": 1,
+  "689": 1,
+  "690": 1,
+  "691": 1,
+  "692": 1,
+  "81": 5,
+  "82": 5,
+  "84": 5,
+  "86": 5,
+  "852": 5,
+  "853": 5,
+  "855": 5,
+  "856": 5,
+  "880": 5,
+  "886": 5,
+  "90": 4,
+  "91": 4,
+  "92": 4,
+  "93": 5,
+  "94": 5,
+  "95": 5,
+  "960": 5,
+  "961": 4,
+  "962": 4,
+  "963": 4,
+  "964": 2,
+  "965": 4,
+  "966": 4,
+  "967": 4,
+  "968": 4,
+  "970": 2,
+  "971": 4,
+  "972": 4,
+  "973": 4,
+  "974": 4,
+  "975": 5,
+  "976": 5,
+  "977": 5,
+  "992": 2,
+  "993": 2,
+  "995": 2,
+  "994": 2,
+  "996": 2,
+  "998": 2
+}

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/single.py

@@ -0,0 +1,38 @@
+from tortoise.functions import Count
+from x_auth.models import Proxy, Session, Username, App
+
+from pyro_client.loader import WSToken
+
+
+class SingleMeta(type):
+    _instances = {}
+
+    async def __call__(cls, uid: int | str, bot=None):
+        if cls not in cls._instances:
+            bt = None
+            if isinstance(uid, str):
+                if len(ub := uid.split(":")) == 2:
+                    uid, bt = ub
+                if uid.isnumeric():
+                    uid = int(uid)
+            sess = await cls._sess(uid, bt, None if bot else ...)
+            cls._instances[cls] = super().__call__(sess, bot)
+        return cls._instances[cls]
+
+    async def _sess(self, uid: int | str, bt: str = None, px: Proxy | None = ..., dc: int = 2) -> Session:
+        username, _ = await Username.get_or_create(**{"id" if isinstance(uid, int) else "username": uid})
+        if not (
+            session := await Session.get_or_none(user=username, api__dc=dc) or await Session.get_or_none(id=username.id)
+        ):
+            if px is Ellipsis:
+                await Proxy.load_list(WSToken)
+                # await Proxy.get_replaced(WSToken)
+                px = await Proxy.annotate(sc=Count("sessions")).filter(valid=True).order_by("sc", "-updated_at").first()
+            if username.phone:
+                # noinspection PyUnresolvedReferences
+                dc = dc or self.get_dc()
+            session = await Session.create(
+                id=username.id, api=await App[20373304], user=username, dc_id=dc, proxy=px, is_bot=bt
+            )
+        await session.fetch_related("proxy", "api")
+        return session

pyro_client/client/user.py

@@ -0,0 +1,199 @@
+import logging
+from json import load
+from os.path import dirname
+
+from pydantic import BaseModel, Field
+from pyrogram import enums
+from pyrogram.enums import ClientPlatform
+from pyrogram.errors import BadRequest, SessionPasswordNeeded, AuthKeyUnregistered, Unauthorized
+from pyrogram.session import Auth, Session as PyroSession
+from pyrogram.types import Message, User, SentCode, InlineKeyboardButton, KeyboardButton
+from x_auth.models import Session, Username, Proxy
+
+from pyro_client.client.base import BaseClient, AuthTopic
+from pyro_client.client.bot import BotClient
+from pyro_client.loader import WSToken
+
+vers: dict[ClientPlatform, str] = {
+    ClientPlatform.IOS: "18.5",
+    ClientPlatform.ANDROID: "16",
+}
+
+
+class Prx(BaseModel):
+    scheme: str = "socks5"
+    hostname: str = Field(validation_alias="host")
+    port: int
+    username: str
+    password: str
+
+
+class UserClient(BaseClient):
+    bot: BotClient
+
+    def __init__(self, sess: Session, bot):
+        self.bot = bot
+        super().__init__(
+            sess.id,
+            sess.api.id,
+            sess.api.hsh,
+            device_model="iPhone 16e",
+            app_version=sess.api.ver,
+            system_version=vers.get(sess.api.platform),
+            client_platform=sess.api.platform,
+            proxy=sess.proxy and sess.proxy.dict(),
+        )
+
+    async def start(self, use_qr: bool = False, except_ids: list[int] = None):
+        if not self.bot.is_connected:
+            await self.bot.start()
+        # dcs = await self.bot.invoke(GetConfig())
+        try:
+            await super().start(use_qr=use_qr, except_ids=except_ids or [])
+            await self.send("im ok")
+        except AuthKeyUnregistered as e:
+            await self.storage.session.delete()
+            raise e
+        except (AuthKeyUnregistered, Unauthorized) as e:
+            raise e
+
+    async def ask_for(
+        self, topic: AuthTopic, question: str, btns: list[InlineKeyboardButton, KeyboardButton] = None
+    ) -> str:
+        if topic == "phone":
+            btns = btns or [] + [KeyboardButton("Phone", True)]
+        await self.receive(question, btns)
+        uid = int(self.storage.name)
+        self.bot.storage.session.state[uid] = {"waiting_for": topic}
+        return await self.bot.wait_auth_from(uid, topic)
+
+    async def receive(
+        self,
+        txt: str,
+        btns: list[InlineKeyboardButton | KeyboardButton] = None,
+        photo: bytes = None,
+        video: bytes = None,
+    ) -> Message:
+        return await self.bot.send(txt, int(self.storage.name), btns, photo, video)
+
+    def get_dc(self):
+        if not self.phone_number:
+            return 2
+        with open(f"{dirname(__file__)}/dc.json", "r") as file:
+            jsn = load(file)
+        for k, v in jsn.items():
+            if self.phone_number.startswith(k):
+                return v
+        return 2
+
+    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:
+            user = await Username[self.storage.session.id]
+            if not (user.phone and (phone := str(user.phone))):
+                phone = await self.ask_for("phone", "Phone plz")
+                user.phone = phone
+                await user.save()
+            self.phone_number = phone
+            if (dc := self.get_dc()) != 2:
+                await self.session_update(dc)
+            if not self.phone_number:
+                await self.authorize()
+            try:
+                # user.phone = int(self.phone_number.strip("+ ").replace(" ", ""))
+                sent_code = await self.send_code(self.phone_number, True, False, True, False, True)
+            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:
+            if code := await self.ask_for("code", f"Code from {sent_code_desc[sent_code.type]}"):
+                self.phone_code = 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.receive(e.MESSAGE)
+                    self.phone_code = None
+                    return await self.authorize(sent_code)
+                except SessionPasswordNeeded:
+                    # Step 2.1?: Cloud password
+                    while True:
+                        self.password = await self.ask_for(
+                            "pass", f"Enter pass: (hint: {await self.get_password_hint()})"
+                        )
+                        try:
+                            signed_in = await self.check_password(self.password)
+                            break
+                        except BadRequest as e:
+                            await self.send(e.MESSAGE)
+                            self.password = None
+            else:
+                raise Exception("User does not sent code")
+            if isinstance(signed_in, User):
+                await self.send("✅", self.bot.me.id)
+                await self.storage.save()
+                return signed_in
+
+            if not signed_in:
+                await self.receive("No registered such phone number")
+
+    async def stop(self, block: bool = True):
+        await super().stop(block)
+        await self.bot.stop(block)
+
+    async def session_update(self, dc: int):
+        await self.session.stop()
+
+        await self.storage.dc_id(dc)
+        await self.storage.auth_key(
+            await Auth(self, await self.storage.dc_id(), await self.storage.test_mode()).create()
+        )
+        self.session = PyroSession(
+            self, await self.storage.dc_id(), await self.storage.auth_key(), await self.storage.test_mode()
+        )
+        if not self.proxy and not self.storage.session.proxy:
+            await Proxy.load_list(WSToken)
+            prx: Proxy = await Proxy.filter(valid=True).order_by("-updated_at").first()
+            self.storage.session.proxy = prx
+            await self.storage.session.save()
+            self.proxy = prx.dict()
+        await self.session.start()
+
+
+async def main():
+    from x_auth import models
+    from x_model import init_db
+
+    from pyro_client.loader import WSToken, PG_DSN
+
+    _ = await init_db(PG_DSN, models, True)
+
+    logging.basicConfig(level=logging.INFO)
+
+    await models.Proxy.load_list(WSToken)
+    # session = await models.Session.filter(is_bot__isnull=True).order_by("-date").prefetch_related("proxy").first()
+    bc: BotClient = await BotClient("xyncnetbot")
+    uc: UserClient = await UserClient(5547330178, bc)
+    # try:
+    await uc.start()
+    # 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,130 @@
+import time
+from typing import Any, Literal
+
+from pyrogram import raw, utils
+from pyrogram.storage import Storage
+from x_auth.models import Username, Version, Session, Peer, UpdateState
+
+
+def get_input_peer(peer_id: int, access_hash: int, peer_type: Literal["user", "bot", "group", "channel", "supergroup"]):
+    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))
+        self.session = await Session[self.name]
+
+    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(phn and {"phone": phn}, 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):
+        # if "__" in attr:
+        #     table, attr = attr.split("__")
+        #     rel = await self.session.__getattribute__(table)
+        #     rel.__setattr__(attr, value)
+        #     await rel.save()
+        # else:
+        await Session.update_or_create({attr: value}, id=self.name)
+
+    async def _accessor(self, attr: str, value: Any = object):
+        if value is 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 is object:
+            ver = await Version.first()
+            return ver.number
+        else:
+            await Version.update_or_create(id=value)

pyrogram_client-0.0.2.dist-info/METADATA

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: pyrogram-client
+Version: 0.0.2
+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.dist-info/RECORD

@@ -0,0 +1,12 @@
+pyro_client/loader.py,sha256=CsBBsb8PfEtU4z7eDMlkc0V3x4PfwTvc2R1HbdVhAMg,362
+pyro_client/storage.py,sha256=ch6r-YTYau2TgH59i_VWfLiQ1Sznc-pJ2mAmAReUB7A,4965
+pyro_client/client/base.py,sha256=hSlPrVwtmuO6dhobYTyaHsjyRYEJ6BUqbD1jQzrPo-w,3266
+pyro_client/client/bot.py,sha256=89KG-HSMQP1_263Y1jTR-X4Gb3XBEI1DFp1vSmZHmoo,442
+pyro_client/client/dc.json,sha256=uoRznbTmpLLVNdb0CFbNZIbKtOSSUD-TOc-c0kX207U,2091
+pyro_client/client/file.py,sha256=JzP-BqqOdfP8LfVXI-qnO4hIS68mZaMnk8SVqrSngA0,2548
+pyro_client/client/single.py,sha256=r3ZfVf2Udyo3rJdCR1NoDea6jFtS74JYKhdxurzZ3fc,1625
+pyro_client/client/user.py,sha256=IRXxzMbaO8Wcq_dle8gccEktU8Q-25MtQTQ87YA9hXg,7325
+pyrogram_client-0.0.2.dist-info/METADATA,sha256=TeFP14JXOVp7xAf38E2cJdqKYcRyerp-woTXzDe7zh0,558
+pyrogram_client-0.0.2.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+pyrogram_client-0.0.2.dist-info/top_level.txt,sha256=pR3onX0Aots7ODOSrd8dssJg3J2kz36Crt_48QSwyi0,12
+pyrogram_client-0.0.2.dist-info/RECORD,,

pyrogram_client-0.0.2.dist-info/WHEEL

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

pyrogram_client-0.0.2.dist-info/top_level.txt

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