pyrogram-client 0.0.5__tar.gz → 0.0.7.dev2__tar.gz

{pyrogram_client-0.0.5/pyrogram_client.egg-info → pyrogram_client-0.0.7.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyrogram-client
-Version: 0.0.5
+Version: 0.0.7.dev2
 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.5 → pyrogram_client-0.0.7.dev2}/pyro_client/client/base.py

@@ -4,30 +4,55 @@ from io import BytesIO
 from typing import Literal
 
 from pyrogram import Client
+from pyrogram.errors import AuthKeyUnregistered, Unauthorized
 from pyrogram.filters import chat, contact, AndFilter
 from pyrogram.handlers import MessageHandler
 from pyrogram.types import Message, InlineKeyboardMarkup, InlineKeyboardButton, ReplyKeyboardMarkup, KeyboardButton
+from x_auth.models import Session, App, Username
 
-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):
+    storage: PgStorage
+    uid: int = None
 
+    _insts: dict[int, "BaseClient"] = {}
 
-class BaseClient(Client, metaclass=SingleMeta):
-    storage: PgStorage
+    def __new__(cls, uid: int, *args, **kwargs):
+        """Single client for each uid"""
+        cls.uid = uid
+        if uid not in cls._insts:
+            cls._insts[uid] = Client.__new__(cls)
+        return cls._insts[uid]
 
-    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), workers=1, **kwargs
-        )
+    def __init__(self, *args, **kwargs):
+        if not hasattr(self, "name"):
+            name = str(self.uid)
+            super().__init__(name, storage_engine=PgStorage(name), **kwargs)  # , workers=2
+
+    async def preload(self):
+        if not (session := await Session.get_or_none(id=self.uid).prefetch_related("api")):
+            app = await App[20373304]
+            username, _ = await Username.get_or_create(id=self.uid)
+            bt = self.bot_token and self.bot_token.split(":")[1]
+            session = await Session.create(id=self.uid, api=app, user=username, is_bot=bt)
+            self.api_id = app.id
+            self.api_hash = app.hsh
+            await session.fetch_related("api")
+        self.storage.session = session
+
+    async def start(self, use_qr: bool = False, except_ids: list[int] = None):
+        if not self.is_connected:
+            await self.preload()
+            try:
+                return await super().start(use_qr=use_qr, except_ids=except_ids or [])
+            except (AuthKeyUnregistered, Unauthorized) as e:
+                await self.storage.session.delete()
+                raise e
+        return self
 
     async def send(
         self,
@@ -64,6 +89,7 @@ class BaseClient(Client, metaclass=SingleMeta):
             self.dispatcher.groups[g] = []
             self.dispatcher.groups = OrderedDict(sorted(self.dispatcher.groups.items()))
         self.dispatcher.groups[g].append(handler)
+        self.storage.session.state |= {uid: {"waiting_for": topic}}
         #
         while past < timeout:
             if txt := self.storage.session.state.get(uid, {}).pop(topic, None):

pyrogram_client-0.0.7.dev2/pyro_client/client/bot.py

@@ -0,0 +1,39 @@
+from pyro_client.client.base import BaseClient, AuthTopic
+from pyro_client.loader import TOKEN
+
+
+class BotClient(BaseClient):
+    def __new__(cls, bid: int | str) -> "BotClient":
+        """
+        :param bid: int | str - Если для такого bot_id в бд есть Session с его токеном в is_bot - можно просто id: int
+        если нет - нужно передавать весь токен, что б Сессия в бд создалась.
+        """
+        if isinstance(bid, str):
+            bid = int(bid.split(":")[0])
+        return super().__new__(cls, bid)
+
+    def __init__(self, bid: int | str):
+        bt = isinstance(bid, str) and ":" in bid and bid
+        super().__init__(bid, bot_token=bt or None)
+
+    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)
+
+
+async def main():
+    from x_model import init_db
+    from pyro_client.loader import TORM
+
+    _ = await init_db(TORM, True)
+
+    bc: BotClient = BotClient(6806432376)
+    bc1: BotClient = BotClient(TOKEN)
+    await bc.start()
+    await bc1.start()
+    await bc.stop()
+
+
+if __name__ == "__main__":
+    from asyncio import run
+
+    run(main())

{pyrogram_client-0.0.5 → pyrogram_client-0.0.7.dev2}/pyro_client/client/user.py

@@ -5,20 +5,25 @@ 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.errors import BadRequest, SessionPasswordNeeded
 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 x_auth.models import Username, Proxy
 
 from pyro_client.client.base import BaseClient, AuthTopic
 from pyro_client.client.bot import BotClient
-from pyro_client.loader import WSToken, TOKEN
+from pyro_client.loader import WSToken
 
 vers: dict[ClientPlatform, str] = {
     ClientPlatform.IOS: "18.5",
     ClientPlatform.ANDROID: "16",
 }
 
+devs: dict[ClientPlatform, str] = {
+    ClientPlatform.IOS: "iPhone 17 Air",
+    ClientPlatform.ANDROID: "Tesla Phone",
+}
+
 
 class Prx(BaseModel):
     scheme: str = "socks5"
@@ -31,31 +36,24 @@ class Prx(BaseModel):
 class UserClient(BaseClient):
     bot: BotClient
 
-    def __init__(self, sess: Session, bot):
+    def __init__(self, uid: int, bot: BotClient = None):
         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(),
-        )
+        super().__init__(uid)
+
+    async def preload(self):
+        await super().preload()
+        self.device_model = devs[self.storage.session.api.platform]
+        self.app_version = self.storage.session.api.ver
+        self.system_version = vers[self.storage.session.api.platform]
+        self.client_platform = self.storage.session.api.platform
+        # await self.storage.session.fetch_related("proxy")
+        # self.proxy: Proxy = self.storage.session.proxy and self.storage.session.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
+        await super().start(use_qr, except_ids)
+        # await self.send("/start", self.bot.uid)
 
     async def ask_for(
         self, topic: AuthTopic, question: str, btns: list[InlineKeyboardButton, KeyboardButton] = None
@@ -86,7 +84,7 @@ class UserClient(BaseClient):
                 return v
         return 2
 
-    async def authorize(self, sent_code: SentCode = None) -> User:
+    async def authorize(self, sent_code: SentCode = None) -> User | None:
         sent_code_desc = {
             enums.SentCodeType.APP: "Telegram app",
             enums.SentCodeType.SMS: "SMS",
@@ -136,19 +134,16 @@ class UserClient(BaseClient):
                         except BadRequest as e:
                             await self.send(e.MESSAGE)
                             self.password = None
-            else:
-                raise Exception("User does not sent code")
+                else:
+                    raise Exception("User does not sent code")
             if isinstance(signed_in, User):
-                await self.send("✅", self.bot.me.id)
+                await self.send("✅")
                 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)
+        return None
 
     async def session_update(self, dc: int):
         await self.session.stop()
@@ -170,21 +165,21 @@ class UserClient(BaseClient):
 
 
 async def main():
-    from x_auth import models
     from x_model import init_db
+    from pyro_client.loader import TORM
 
-    from pyro_client.loader import WSToken, PG_DSN
-
-    _ = await init_db(PG_DSN, models, True)
+    _ = await init_db(TORM, True)
 
     logging.basicConfig(level=logging.INFO)
 
-    await models.Proxy.load_list(WSToken)
+    # 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)
+    bc: BotClient = BotClient(6806432376)
+    uc: UserClient = UserClient(7314099964, bc)
     # try:
     await uc.start()
+    # b = await uc.resolve_peer('xyncnetbot')
+    await uc.send("/start", bc.me.username)
     # except Exception as e:
     #     print(e.MESSAGE)
     #     await uc.send(e.MESSAGE)

{pyrogram_client-0.0.5 → pyrogram_client-0.0.7.dev2}/pyro_client/loader.py

@@ -1,11 +1,19 @@
 from dotenv import load_dotenv
 from os import getenv as env
 
+from x_auth import models
+
 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'))}"
+TORM = {
+    "connections": {"default": PG_DSN},
+    "apps": {"models": {"models": [models]}},
+    "use_tz": False,
+    "timezone": "UTC",
+}
 TOKEN = env("TOKEN")
 WSToken = env("WST")

{pyrogram_client-0.0.5 → pyrogram_client-0.0.7.dev2}/pyro_client/storage.py

@@ -1,34 +1,32 @@
 import time
-from typing import Any, Literal
+from typing import Any
 
 from pyrogram import raw, utils
 from pyrogram.storage import Storage
+from x_auth.enums import PeerType
 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"]:
+def get_input_peer(peer_id: int, access_hash: int, peer_type: PeerType):
+    if peer_type in [PeerType.user, PeerType.bot]:
         return raw.types.InputPeerUser(user_id=peer_id, access_hash=access_hash)
-
-    if peer_type == "group":
+    if peer_type == PeerType.group:
         return raw.types.InputPeerChat(chat_id=-peer_id)
-
-    if peer_type in ["channel", "supergroup"]:
+    if peer_type in [PeerType.channel, PeerType.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}")
+    raise ValueError(f"Invalid peer type: {peer_type.name}")
 
 
 class PgStorage(Storage):
     VERSION = 1
-    USERNAME_TTL = 8 * 60 * 60
+    USERNAME_TTL = 30 * 24 * 3600
     session: Session
-
-    # me_id: int
+    sid: int
 
     async def open(self):
-        # self.me_id = int((uid_dc := self.name.split("_")).pop(0))
-        self.session = await Session[self.name]
+        self.sid = int(self.name)
+        if not self.session:
+            self.session = await Session[self.sid]
 
     async def save(self):
         await self.date(int(time.time()))
@@ -36,14 +34,14 @@ class PgStorage(Storage):
     async def close(self): ...
 
     async def delete(self):
-        await Session.filter(id=self.name).delete()
+        await Session.filter(id=self.sid).delete()
 
     async def update_peers(self, peers: list[tuple[int, int, str, str]]):
         for peer in peers:
             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": phone}, session_id=self.name, id=ac_hsh
+                {"username": un, "type": PeerType[typ], "phone_number": phone}, session_id=self.sid, id=ac_hsh
             )
 
     async def update_usernames(self, usernames: list[tuple[int, list[str]]]):
@@ -51,37 +49,45 @@ 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, 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)
-        )
+    async def get_peer_by_id(self, uid: int | str):
+        if isinstance(uid, str):
+            if uid.isnumeric():
+                uid = int(uid)
+            else:
+                return await self.get_peer_by_username(uid)
+        if not (peer := await Peer.get_or_none(session_id=self.sid, username_id=uid)):
+            raise KeyError(f"Peer#{uid} not found")
         if peer.last_update_on:
             if abs(time.time() - peer.last_update_on.timestamp()) > self.USERNAME_TTL:
-                raise KeyError(f"Username expired: {uin}")
+                raise KeyError(f"Username expired: {uid}")
         return get_input_peer(peer.username_id, peer.id, peer.type)
 
     async def get_peer_by_username(self, username: str):
-        return await Peer.get(session_id=self.name, username__username=username)
+        if not (peer := await Peer.get_or_none(session_id=self.sid, username__username=username)):
+            if not (user := await Username.get_or_none(username=username)):
+                raise KeyError(f"Username: {username} not found")
+            return await self.get_peer_by_id(user.id)
+        return get_input_peer(peer.username_id, peer.id, peer.type)
 
-    async def update_state(self, value: tuple[int, int, int, int, int] = object):
+    async def update_state(self, value: tuple[int, int, int, int, int] = ...):
         if value is None:
-            return await UpdateState.filter(session_id=self.name)
+            return await UpdateState.filter(session_id=self.sid)
         elif isinstance(value, int):
-            await UpdateState.filter(session_id=self.name, id=value).delete()
+            await UpdateState.filter(session_id=self.sid, 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
+                {"pts": pts, "qts": qts, "date": date, "seq": seq}, session_id=self.sid, id=sid
             )
 
     async def get_peer_by_phone_number(self, phone_number: str):
         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)
+        if not (peer := await Peer.get_or_none(session_id=self.sid, phone_number=phone_number).values_list(*attrs)):
+            peer = await Peer.get(session_id=self.sid, 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)
+        return await Session.get(id=self.sid).values_list(attr, flat=True)
 
     async def _set(self, attr: str, value):
         # if "__" in attr:
@@ -90,40 +96,42 @@ class PgStorage(Storage):
         #     rel.__setattr__(attr, value)
         #     await rel.save()
         # else:
-        await Session.update_or_create({attr: value}, id=self.name)
+        await Session.update_or_create({attr: value}, id=self.sid)
 
-    async def _accessor(self, attr: str, value: Any = object):
-        if value is object:
+    async def _accessor(self, attr: str, value: Any = ...):
+        if value is ...:
             return await self._get(attr)
+        # elif attr == ...:
+        #     return await self._set(attr, ...)
         else:
             await self._set(attr, value)
 
-    async def dc_id(self, value: int = object):
+    async def dc_id(self, value: int = ...):
         return await self._accessor("dc_id", value)
 
-    async def api_id(self, value: int = object):
+    async def api_id(self, value: int = ...):
         return await self._accessor("api_id", value)
 
-    async def test_mode(self, value: bool = object):
+    async def test_mode(self, value: bool = ...):
         return await self._accessor("test_mode", value)
 
-    async def auth_key(self, value: bytes = object):
+    async def auth_key(self, value: bytes = ...):
         return await self._accessor("auth_key", value)
 
-    async def date(self, value: int = object):
+    async def date(self, value: int = ...):
         return await self._accessor("date", value)
 
-    async def user_id(self, value: int = object):
+    async def user_id(self, value: int = ...):
         return await self._accessor("user_id", value)
 
-    async def is_bot(self, value: bool = object):
-        if value is not object:
+    async def is_bot(self, value: bool = ...):
+        if value is not ...:
             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 is object:
+    async def version(value: int = ...):
+        if value is ...:
             ver = await Version.first()
             return ver.number
         else:

{pyrogram_client-0.0.5 → pyrogram_client-0.0.7.dev2/pyrogram_client.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyrogram-client
-Version: 0.0.5
+Version: 0.0.7.dev2
 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.5 → pyrogram_client-0.0.7.dev2}/pyrogram_client.egg-info/SOURCES.txt

@@ -9,7 +9,6 @@ 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.5/pyro_client/client/bot.py

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

pyrogram_client-0.0.5/pyro_client/client/single.py

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