xync-client 0.0.43.dev41__tar.gz → 0.0.43.dev43__tar.gz

{xync_client-0.0.43.dev41/xync_client.egg-info → xync_client-0.0.43.dev43}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xync-client
-Version: 0.0.43.dev41
+Version: 0.0.43.dev43
 Author-email: Mike Artemiev <mixartemev@gmail.com>
 Project-URL: Homepage, https://gitlab.com/XyncNet/client
 Project-URL: Repository, https://gitlab.com/XyncNet/client

{xync_client-0.0.43.dev41 → xync_client-0.0.43.dev43}/xync_client/Abc/Ex.py

@@ -6,14 +6,14 @@ import msgspec
 from aiohttp import ClientSession
 from msgspec import Struct
 from tortoise.exceptions import MultipleObjectsReturned, IntegrityError
+from xync_client.Pyrogram.file import FileClient
 from xync_schema import models
-from xync_schema.enums import FileType
+from xync_schema.enums import FileType, df_curs
 from xync_schema.types import CurEx, CoinEx, BaseAd, BaseAdIn
 
 from xync_client.Abc.Base import BaseClient, MapOfIdsList
 from xync_client.Abc.types import PmEx
-from xync_client.TgWallet.pyro import PyroClient
-from xync_client.loader import bot
+from xync_client.loader import TOKEN
 from xync_client.pm_unifier import PmUnifier, PmUni
 
 
@@ -164,19 +164,19 @@ class BaseExClient(BaseClient):
             else:
                 pmin = models.Pm.validate({**pmu.model_dump(), "country_id": country_id, "typ": pmex.typ})
                 if c := df_curs.get(pmu.norm):
-                    pmin.df_cur_id = curs[c].id
+                    pmin.df_cur_id = await models.Cur.get(ticker=c).values_list("id", flat=True)
                 try:
                     pms[k], _ = await models.Pm.update_or_create(**pmin.df_unq())
                 except (MultipleObjectsReturned, IntegrityError) as e:
                     raise e
             prev = k, pmu.norm, pmex.name, pmu.country
-            await models.Pmcur.update_or_create(
-                cur=await models.Cur.get(ticker="THB"), pm=await models.Pm.get(norm="cash in person")
-            )
+        await models.Pmcur.update_or_create(  # todo: NA HU YA???
+            cur=await models.Cur.get(ticker="THB"), pm=await models.Pm.get(norm="cash in person")
+        )
 
         # Pmexs
-        pbot = PyroClient(bot)
-        await pbot.app.start()
+        pbot = FileClient(TOKEN)
+        await pbot.start()
         async with ClientSession(headers=getattr(self, "logo_headers", None)) as ss:
             pmexs = [
                 models.Pmex(
@@ -189,7 +189,7 @@ class BaseExClient(BaseClient):
                 )
                 for k, pm in pms.items()
             ]
-        await pbot.app.stop()
+        await pbot.stop()
 
         await models.Pmex.bulk_create(pmexs, on_conflict=["ex_id", "exid"], update_fields=["pm_id", "logo_id", "name"])
         # Pmex banks
@@ -214,7 +214,7 @@ class BaseExClient(BaseClient):
         # pmcurexs = [Pmcurex(pmcur=pmcur, ex=self.ex) for pmcur in pmcurs]
         # await Pmcurex.bulk_create(pmcurexs)
 
-    async def logo_save(self, url: str | None, pbot: PyroClient, ss: ClientSession) -> models.File | None:
+    async def logo_save(self, url: str | None, pbot: FileClient, ss: ClientSession) -> models.File | None:
         if url or (file := None):
             if not url.startswith("https:"):
                 if not url.startswith("/"):
@@ -224,7 +224,7 @@ class BaseExClient(BaseClient):
                 resp = await ss.get(url)
                 if resp.ok:
                     byts = await resp.read()
-                    upf, ref = await pbot.save_file(byts, resp.content_type)
+                    upf, ref = await pbot.save_doc(byts, resp.content_type)
                     await sleep(0.34)
                     typ = FileType[resp.content_type.split("/")[-1]]
                     file, _ = await models.File.update_or_create({"ref": ref, "size": len(byts), "typ": typ}, name=url)

xync_client-0.0.43.dev43/xync_client/Pyrogram/base.py

@@ -0,0 +1,42 @@
+from asyncio import sleep
+from typing import Literal
+
+from pyrogram import Client
+from pyrogram.filters import chat
+from pyrogram.handlers import MessageHandler
+from pyrogram.types import Message
+
+from xync_client.Pyrogram.storage import PgStorage
+from xync_client.loader import TG_API_ID, TG_API_HASH
+
+AuthTopic = Literal["phone", "code", "pass"]
+
+
+class BaseClient(Client):
+    storage: PgStorage
+
+    def __init__(self, name: str, *args, **kwargs):
+        super().__init__(
+            name,
+            TG_API_ID,
+            TG_API_HASH,
+            storage_engine=PgStorage(name),
+            # device_model="iPhone 17 Air", app_version="XyncNet 1.0", system_version="iOS 19.0.1",
+            *args,
+            **kwargs,
+        )
+
+    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

xync_client-0.0.43.dev43/xync_client/Pyrogram/bot.py

@@ -0,0 +1,11 @@
+from xync_client.Pyrogram.base import AuthTopic
+
+from xync_client.Pyrogram.base import BaseClient
+
+
+class BotClient(BaseClient):
+    def __init__(self, token: str):
+        super().__init__(token.split(":")[0], 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)

xync_client-0.0.43.dev43/xync_client/Pyrogram/file.py

@@ -0,0 +1,61 @@
+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 xync_client.Pyrogram.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 send_img(self, txt: str, byts: bytes, uid="me"):
+        return await self.send_photo(uid, BytesIO(byts), txt)
+
+    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

xync_client-0.0.43.dev43/xync_client/Pyrogram/pyro.py

@@ -0,0 +1,74 @@
+from asyncio import run, sleep
+
+from pyrogram.errors import UserNotParticipant
+from pyrogram.raw.functions.photos import GetUserPhotos
+from pyrogram.raw.types.photos import Photos
+from pyrogram.types import Chat, ChatPrivileges
+from x_model import init_db
+
+from xync_client.Pyrogram.client import UserClient, BotClient
+from xync_client.Pyrogram.pg_storage import PgStorage
+from xync_client.loader import TG_API_ID, TG_API_HASH, PG_DSN, TOKEN
+from xync_schema import models
+
+
+class PyroClient:
+    max_privs = ChatPrivileges(
+        can_manage_chat=True,  # default
+        can_delete_messages=True,
+        can_delete_stories=True,  # Channels only
+        can_manage_video_chats=True,  # Groups and supergroups only
+        can_restrict_members=True,
+        can_promote_members=True,
+        can_change_info=True,
+        can_post_messages=True,  # Channels only
+        can_post_stories=True,  # Channels only
+        can_edit_messages=True,  # Channels only
+        can_edit_stories=True,  # Channels only
+        can_invite_users=True,
+        can_pin_messages=True,  # Groups and supergroups only
+        can_manage_topics=True,  # Supergroups only
+        is_anonymous=True,
+    )
+
+    def __init__(self, ss_id: str):
+        self.u: UserClient = UserClient(ss_id, TG_API_ID, TG_API_HASH, storage_engine=PgStorage(ss_id))
+        self.b: BotClient = BotClient("6806432376", TG_API_ID, TG_API_HASH, storage_engine=PgStorage("6806432376"))
+
+    async def create_orders_forum(self, uid: str | int) -> tuple[int, bool]:
+        chat: Chat = await self.app.create_supergroup("Xync Orders", "Xync Orders")
+        if not (await self.app.toggle_forum_topics(chat_id=chat.id, enabled=True)):
+            await self.app.delete_channel(chat.id)
+            await chat.leave()
+            raise Exception(f"Chat {chat.id} for {self.app.me.username} not converted to forum")
+        await chat.add_members(["XyncNetBot"])  # , "xync_bot"
+        await chat.promote_member("XyncNetBot", self.max_privs)
+        added = await chat.add_members([uid])
+        try:
+            await sleep(1, await chat.get_member(uid))
+        except UserNotParticipant:
+            added = False
+        # await chat.leave()
+        return chat.id, added
+
+    async def get_user_photos(self, uid: str | int) -> Photos:
+        try:
+            peer = await self.app.resolve_peer(uid)
+        except Exception as e:
+            raise e
+        return await self.app.invoke(GetUserPhotos(user_id=peer, offset=0, limit=1, max_id=-1))
+
+
+async def main():
+    _ = await init_db(PG_DSN, models, True)
+    user: models.User = await models.User.filter(status__gt=0).first()
+    bot = BotClient(TOKEN)
+    await bot.start()
+    uc = UserClient(str(user.username_id), bot)
+    await uc.start()
+    await uc.stop()
+    await bot.stop()
+
+
+if __name__ == "__main__":
+    run(main())

xync_client-0.0.43.dev43/xync_client/Pyrogram/user.py

@@ -0,0 +1,104 @@
+from pyrogram import enums
+from pyrogram.errors import BadRequest, SessionPasswordNeeded, AuthKeyUnregistered
+from pyrogram.types import Message, User, SentCode
+
+from xync_client.Pyrogram.base import BaseClient, AuthTopic
+from xync_client.Pyrogram.bot import BotClient
+from xync_client.loader import WSToken
+
+
+class UserClient(BaseClient):
+    bot: BotClient
+
+    def __init__(self, name: str, bot: BotClient, *args, **kwargs):
+        super().__init__(name, *args, **kwargs)
+        self.bot = bot
+
+    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 send(self, txt: str) -> Message:
+        return await self.bot.send_message(self.storage.me_id, txt)
+
+    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 main():
+    from x_model import init_db
+    from xync_schema import models
+    from xync_client.loader import PG_DSN, TOKEN
+
+    _ = await init_db(PG_DSN, models, True)
+    _ = await models.Proxy.load_list(WSToken)
+    bot = BotClient(TOKEN)
+    await bot.start()
+    uc = UserClient(
+        "7049542242",
+        bot,
+        proxy=dict(
+            scheme="socks5", hostname="207.244.217.165", port=6712, username="hmxelnzd", password="zaw8ied2qdjc"
+        ),
+    )
+    try:
+        await uc.start()
+    except AuthKeyUnregistered as e:
+        print(e.MESSAGE)
+        await uc.send(e.MESSAGE)
+        await uc.storage.session.delete()
+    else:
+        await uc.stop()
+    await bot.stop()
+
+
+if __name__ == "__main__":
+    from asyncio import run
+
+    run(main())

xync_client-0.0.43.dev43/xync_client/TgWallet/pyro.py

@@ -0,0 +1,43 @@
+from asyncio import run
+from urllib.parse import parse_qs
+
+from pyrogram.raw import functions
+from pyrogram.raw.types import InputPeerSelf
+from x_model import init_db
+from xync_client.Pyrogram.base import BaseClient
+
+from xync_client.loader import PG_DSN
+from xync_schema import models
+from xync_schema.models import Actor
+
+
+class PyroClient(BaseClient):
+    async def get_init_data(self) -> dict:
+        bot = await self.resolve_peer("wallet")
+        res = await self.invoke(functions.messages.RequestWebView(peer=InputPeerSelf(), bot=bot, platform="ios"))
+        raw = parse_qs(res.url)["tgWebAppUserId"][0].split("#tgWebAppData=")[1]
+        j = parse_qs(raw)
+        return {
+            "web_view_init_data": {
+                "query_id": j["query_id"][0],
+                "user": j["user"][0],
+                "auth_date": j["auth_date"][0],
+                "hash": j["hash"][0],
+            },
+            "web_view_init_data_raw": raw,
+            "ep": "menu",
+        }
+
+
+async def main():
+    _ = await init_db(PG_DSN, models, True)
+    actor: Actor = (
+        await Actor.filter(agent__isnull=False, ex__name="TgWallet").prefetch_related("ex", "person__user").first()
+    )
+    pcl = PyroClient(actor.person.user.username_id)
+    await pcl.get_init_data()
+    ...
+
+
+if __name__ == "__main__":
+    run(main())

{xync_client-0.0.43.dev41 → xync_client-0.0.43.dev43}/xync_client/loader.py

@@ -1,4 +1,3 @@
-from aiogram import Bot, Dispatcher
 from dotenv import load_dotenv
 from os import getenv as env
 
@@ -10,8 +9,7 @@ if not (TOKEN := env("TOKEN")):
     load_dotenv("/api/.env")
     logging.info(TOKEN := env("TOKEN"))
 
-bot: Bot = Bot(token=TOKEN)
-dp: Dispatcher = Dispatcher()
 PG_DSN = f"postgres://{env('POSTGRES_USER')}:{env('POSTGRES_PASSWORD')}@{env('POSTGRES_HOST', 'xyncdbs')}:{env('POSTGRES_PORT', 5432)}/{env('POSTGRES_DB', env('POSTGRES_USER'))}"
 TG_API_ID = env("TG_API_ID")
 TG_API_HASH = env("TG_API_HASH")
+WSToken = env("WST")

{xync_client-0.0.43.dev41 → xync_client-0.0.43.dev43/xync_client.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xync-client
-Version: 0.0.43.dev41
+Version: 0.0.43.dev43
 Author-email: Mike Artemiev <mixartemev@gmail.com>
 Project-URL: Homepage, https://gitlab.com/XyncNet/client
 Project-URL: Repository, https://gitlab.com/XyncNet/client

{xync_client-0.0.43.dev41 → xync_client-0.0.43.dev43}/xync_client.egg-info/SOURCES.txt

@@ -96,6 +96,11 @@ xync_client/Pms/Volet/__init__.py
 xync_client/Pms/Volet/api.py
 xync_client/Pms/Volet/_todo_req/req.mjs
 xync_client/Pms/Volet/_todo_req/req.py
+xync_client/Pyrogram/base.py
+xync_client/Pyrogram/bot.py
+xync_client/Pyrogram/file.py
+xync_client/Pyrogram/pyro.py
+xync_client/Pyrogram/user.py
 xync_client/TgWallet/agent.py
 xync_client/TgWallet/asset.py
 xync_client/TgWallet/auth.py

xync_client-0.0.43.dev41/xync_client/TgWallet/pyro.py

@@ -1,147 +0,0 @@
-from asyncio import run, sleep
-from io import BytesIO
-from urllib.parse import parse_qs
-
-from aiogram import Bot
-from pyrogram import Client
-from pyrogram.errors import UserNotParticipant
-from pyrogram.raw import functions
-from pyrogram.raw.functions.messages import UploadMedia
-from pyrogram.raw.functions.photos import GetUserPhotos
-from pyrogram.raw.functions.upload import GetFile
-from pyrogram.raw.types import (
-    InputPeerSelf,
-    InputMediaUploadedDocument,
-    MessageMediaDocument,
-    InputMediaUploadedPhoto,
-    MessageMediaPhoto,
-    InputDocumentFileLocation,
-    InputPhotoFileLocation,
-)
-from pyrogram.raw.types.photos import Photos
-from pyrogram.raw.types.upload import File
-from pyrogram.types import Chat, ChatPrivileges
-from x_model import init_db
-from xync_client.loader import TG_API_ID, TG_API_HASH, PG_DSN
-from xync_schema import models
-from xync_schema.models import Actor, PmAgent
-
-
-class PyroClient:
-    max_privs = ChatPrivileges(
-        can_manage_chat=True,  # default
-        can_delete_messages=True,
-        can_delete_stories=True,  # Channels only
-        can_manage_video_chats=True,  # Groups and supergroups only
-        can_restrict_members=True,
-        can_promote_members=True,
-        can_change_info=True,
-        can_post_messages=True,  # Channels only
-        can_post_stories=True,  # Channels only
-        can_edit_messages=True,  # Channels only
-        can_edit_stories=True,  # Channels only
-        can_invite_users=True,
-        can_pin_messages=True,  # Groups and supergroups only
-        can_manage_topics=True,  # Supergroups only
-        is_anonymous=True,
-    )
-
-    def __init__(self, ab: Actor | PmAgent | Bot):
-        name = str(ab.person.user.id) if isinstance(ab, Actor) else str(ab.id)
-        auth = (
-            {"bot_token": ab.token}
-            if isinstance(ab, Bot)
-            else {"session_string": ab.agent.auth["sess"] if isinstance(ab, Actor) else ab.auth["sess"]}
-        )
-        self.app: Client = Client(name, TG_API_ID, TG_API_HASH, **auth, in_memory=True)
-
-    @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 get_init_data(self) -> dict:
-        async with self.app:
-            bot = await self.app.resolve_peer("wallet")
-            res = await self.app.invoke(
-                functions.messages.RequestWebView(peer=InputPeerSelf(), bot=bot, platform="ios")
-            )
-            raw = parse_qs(res.url)["tgWebAppUserId"][0].split("#tgWebAppData=")[1]
-            j = parse_qs(raw)
-            return {
-                "web_view_init_data": {
-                    "query_id": j["query_id"][0],
-                    "user": j["user"][0],
-                    "auth_date": j["auth_date"][0],
-                    "hash": j["hash"][0],
-                },
-                "web_view_init_data_raw": raw,
-                "ep": "menu",
-            }
-
-    async def create_orders_forum(self, uid: str | int) -> tuple[int, bool]:
-        chat: Chat = await self.app.create_supergroup("Xync Orders", "Xync Orders")
-        if not (await self.app.toggle_forum_topics(chat_id=chat.id, enabled=True)):
-            await self.app.delete_channel(chat.id)
-            await chat.leave()
-            raise Exception(f"Chat {chat.id} for {self.app.me.username} not converted to forum")
-        await chat.add_members(["XyncNetBot"])  # , "xync_bot"
-        await chat.promote_member("XyncNetBot", self.max_privs)
-        added = await chat.add_members([uid])
-        try:
-            await sleep(1, await chat.get_member(uid))
-        except UserNotParticipant:
-            added = False
-        # await chat.leave()
-        return chat.id, added
-
-    async def get_user_photos(self, uid: str | int) -> Photos:
-        try:
-            peer = await self.app.resolve_peer(uid)
-        except Exception as e:
-            raise e
-        return await self.app.invoke(GetUserPhotos(user_id=peer, offset=0, limit=1, max_id=-1))
-
-    async def send_img(self, txt: str, byts: bytes, uid="me"):
-        return await self.app.send_photo(uid, BytesIO(byts), txt)
-
-    async def save_file(self, byts: bytes, ctype: str) -> tuple[MessageMediaDocument, bytes]:
-        in_file = await self.app.save_file(BytesIO(byts))
-        imud = InputMediaUploadedDocument(file=in_file, mime_type=ctype, attributes=[])
-        upf: MessageMediaDocument = await self.app.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.app.save_file(BytesIO(file))
-        upm = UploadMedia(peer=InputPeerSelf(), media=InputMediaUploadedPhoto(file=in_file))
-        upp: MessageMediaPhoto = await self.app.invoke(upm)
-        return upp, self.ref_enc(upp.photo.id, upp.photo.access_hash, upp.photo.file_reference)
-
-    async def get_file(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.app.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.app.invoke(GetFile(location=loc, offset=0, limit=512 * 1024))
-
-
-async def main():
-    _ = await init_db(PG_DSN, models, True)
-    actor: Actor = await Actor.filter(agent__isnull=False, ex__name="TgWallet").prefetch_related("ex").first()
-    pcl = PyroClient(actor)
-    await pcl.create_orders_forum(actor.person.user.id)
-
-
-if __name__ == "__main__":
-    run(main())