pyrogram-client 0.0.2.dev1__tar.gz → 0.0.4__tar.gz

{pyrogram_client-0.0.2.dev1 → pyrogram_client-0.0.4}/.pre-commit-config.yaml

@@ -14,7 +14,7 @@ repos:
   - id: build
     name: build
     ### build & upload package only for "main" branch push
-    entry: bash -c 'echo $PRE_COMMIT_LOCAL_BRANCH | grep /master && make twine || echo 0'
+    entry: bash -c 'echo $PRE_COMMIT_LOCAL_BRANCH | grep /main && make twine || echo 0'
     language: system
     pass_filenames: false
     verbose: true

{pyrogram_client-0.0.2.dev1/pyrogram_client.egg-info → pyrogram_client-0.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyrogram-client
-Version: 0.0.2.dev1
+Version: 0.0.4
 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

pyrogram_client-0.0.4/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]

{pyrogram_client-0.0.2.dev1 → pyrogram_client-0.0.4}/pyro_client/client/bot.py

@@ -1,9 +1,11 @@
+from x_auth.models import Session
+
 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)
+    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)

pyrogram_client-0.0.4/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
+}

pyrogram_client-0.0.4/pyro_client/client/single.py

@@ -0,0 +1,40 @@
+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:
+            prx = ...
+            bt = None
+            if isinstance(uid, str):
+                if len(ub := uid.split(":")) == 2:
+                    uid, bt = ub
+                    prx = None
+                if uid.isnumeric():
+                    uid = int(uid)
+            sess = await cls._sess(uid, bt, prx)
+            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

pyrogram_client-0.0.4/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, TOKEN
+
+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(TOKEN)
+    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())

{pyrogram_client-0.0.2.dev1 → pyrogram_client-0.0.4}/pyro_client/storage.py

@@ -1,15 +1,12 @@
 import time
-from typing import Any
+from typing import Any, Literal
 
 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 x_auth.models import Username, Version, Session, Peer, UpdateState
 
-from pyro_client.loader import WSToken
 
-
-def get_input_peer(peer_id: int, access_hash: int, peer_type: str):
+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)
 
@@ -26,28 +23,12 @@ class PgStorage(Storage):
     VERSION = 1
     USERNAME_TTL = 8 * 60 * 60
     session: Session
-    me_id: int
+
+    # 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
+        # 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()))
@@ -59,10 +40,10 @@ class PgStorage(Storage):
 
     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)
+            uid, ac_hsh, typ, phone = peer
+            un, _ = await Username.update_or_create(phone and {"phone": phone}, id=uid)
             await Peer.update_or_create(
-                {"username": un, "type": typ, "phone_number": phn}, session_id=self.name, id=ac_hsh
+                {"username": un, "type": typ, "phone_number": phone}, session_id=self.name, id=ac_hsh
             )
 
     async def update_usernames(self, usernames: list[tuple[int, list[str]]]):
@@ -70,17 +51,17 @@ class PgStorage(Storage):
             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}")
+    async def get_peer_by_id(self, uin: int | str):
+        peer = await (
+            Peer.get(session_id=self.name, username_id=uin) if isinstance(uin, int) else self.get_peer_by_username(uin)
+        )
         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}")
+                raise KeyError(f"Username expired: {uin}")
         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)
+        return await Peer.get(session_id=self.name, username__username=username)
 
     async def update_state(self, value: tuple[int, int, int, int, int] = object):
         if value is None:
@@ -94,22 +75,25 @@ class PgStorage(Storage):
             )
 
     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}")
+        attrs = "id", "access_hash", "type"
+        if not (peer := await Peer.get_or_none(session_id=self.name, phone_number=phone_number).values_list(*attrs)):
+            peer = await Peer.get(session_id=self.name, username__phone=phone_number).values_list(*attrs)
         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 == object:
+        if value is object:
             return await self._get(attr)
         else:
             await self._set(attr, value)
@@ -133,11 +117,13 @@ class PgStorage(Storage):
         return await self._accessor("user_id", value)
 
     async def is_bot(self, value: bool = object):
-        return await self._accessor("is_bot", value)
+        if value is not object:
+            value = self.session.is_bot if value else None  # dirty
+        return bool(await self._accessor("is_bot", value))
 
     @staticmethod
     async def version(value: int = object):
-        if value == object:
+        if value is object:
             ver = await Version.first()
             return ver.number
         else:

{pyrogram_client-0.0.2.dev1 → pyrogram_client-0.0.4/pyrogram_client.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyrogram-client
-Version: 0.0.2.dev1
+Version: 0.0.4
 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

{pyrogram_client-0.0.2.dev1 → pyrogram_client-0.0.4}/pyrogram_client.egg-info/SOURCES.txt

@@ -7,7 +7,9 @@ pyro_client/loader.py
 pyro_client/storage.py
 pyro_client/client/base.py
 pyro_client/client/bot.py
+pyro_client/client/dc.json
 pyro_client/client/file.py
+pyro_client/client/single.py
 pyro_client/client/user.py
 pyrogram_client.egg-info/PKG-INFO
 pyrogram_client.egg-info/SOURCES.txt

pyrogram_client-0.0.2.dev1/pyro_client/client/base.py

@@ -1,42 +0,0 @@
-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

pyrogram_client-0.0.2.dev1/pyro_client/client/user.py

@@ -1,106 +0,0 @@
-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())