xync-client 0.0.25.dev112__tar.gz → 0.0.25.dev116__tar.gz

{xync_client-0.0.25.dev112 → xync_client-0.0.25.dev116}/.gitignore

@@ -8,4 +8,5 @@ __pycache__
 /build
 .vscode
 /xync_client/Gate/res.js
-/tests/res.js
+/tests/res.js
+*.session*

{xync_client-0.0.25.dev112/xync_client.egg-info → xync_client-0.0.25.dev116}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xync-client
-Version: 0.0.25.dev112
+Version: 0.0.25.dev116
 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.25.dev112 → xync_client-0.0.25.dev116}/xync_client/Abc/Ex.py

@@ -20,6 +20,11 @@ from xync_client.pm_unifier import PmUnifier, PmUni
 class BaseExClient(BaseClient):
     cur_map: dict[int, str] = {}
     unifier_class: type = PmUnifier
+    logo_map = {
+        "Binance": "bin.bnbstatic.com",
+        "Gate": "www.gate.io",
+        "Mexc": "www.mexc.com/api/file/download",
+    }
 
     @abstractmethod
     def pm_type_map(self, typ: models.Pmex) -> str: ...
@@ -69,7 +74,6 @@ class BaseExClient(BaseClient):
 
     # Импорт Pm-ов (с Pmcur-, Pmex- и Pmcurex-ами) и валют (с Curex-ами) с биржи в бд
     async def set_pmcurexs(self):
-        pbot = PyroClient(bot)
         # Curs
         cur_pyds: dict[str, CurEx] = await self.curs()
         curs: dict[int | str, models.Cur] = {
@@ -124,69 +128,66 @@ class BaseExClient(BaseClient):
         # todo: curexcountry
 
         # Pms
-        pms_epyds: dict[int | str, PmEx] = {
+        pmexs_epyds: dict[int | str, PmEx] = {
             k: v for k, v in sorted((await self.pms()).items(), key=lambda x: x[1].name)
         }  # sort by name
         pms: dict[int | str, models.Pm] = dict({})
         prev = 0, "", "", None  # id, normd-name, orig-name
         cntrs = [c.lower() for c in await models.Country.all().values_list("name", flat=True)]
         uni = self.unifier_class(cntrs)
-        for k, pm in pms_epyds.items():
-            pmu: PmUni = uni(pm.name)
+        for k, pmex in pmexs_epyds.items():
+            pmu: PmUni = uni(pmex.name)
             country_id = (
                 await models.Country.get(name__iexact=cnt).values_list("id", flat=True)
                 if (cnt := pmu.country)
                 else None
             )
-            if prev[2] == pm.name and pmu.country == prev[3]:  # оригинальное имя не уникально на этой бирже
-                logging.warning(f"Pm: '{pm.name}' duplicated with ids {prev[0]}: {k} on {self.ex.name}")
+            if prev[2] == pmex.name and pmu.country == prev[3]:  # оригинальное имя не уникально на этой бирже
+                logging.warning(f"Pm: '{pmex.name}' duplicated with ids {prev[0]}: {k} on {self.ex.name}")
                 # новый Pm не добавляем, а берем старый с этим названием
                 pm_ = pms.get(prev[0], await models.Pm.get_or_none(norm=prev[1], country_id=country_id))
                 # и добавляем Pmex для него
-                await models.Pmex.update_or_create({"name": pm.name}, ex=self.ex, exid=k, pm=pm_)
+                await models.Pmex.update_or_create({"name": pmex.name}, ex=self.ex, exid=k, pm=pm_)
             elif (
                 prev[1] == pmu.norm and pmu.country == prev[3]
             ):  # 2 разных оригинальных имени на этой бирже совпали при нормализации
                 logging.error(
-                    f"Pm: {pm.name}&{prev[2]} overnormd as {pmu.norm} with ids {prev[0]}: {k} on {self.ex.name}"
+                    f"Pm: {pmex.name}&{prev[2]} overnormd as {pmu.norm} with ids {prev[0]}: {k} on {self.ex.name}"
                 )
                 # новый Pm не добавляем, только Pmex для него
                 # новый Pm не добавляем, а берем старый с этим названием
                 pm_ = pms.get(prev[0], await models.Pm.get_or_none(norm=prev[1], country_id=country_id))
                 # и добавляем.обновляем Pmex для него
-                await models.Pmex.update_or_create({"pm": pm_}, ex=self.ex, exid=k, name=pm.name)
+                await models.Pmex.update_or_create({"pm": pm_}, ex=self.ex, exid=k, name=pmex.name)
             else:
-                pmin = models.Pm.validate({**pmu.model_dump(), "country_id": country_id, "typ": pm.typ})
-                # logo
-                if pm.logo or (file := None):
-                    if not (file := await models.File.get_or_none(name=pm.logo)):
-                        if not pm.logo.startswith("https:"):
-                            if not pm.logo.startswith("/"):
-                                pm.logo = "/" + pm.logo
-                            pm.logo = "https://" + pm.logo
-                        async with ClientSession() as ss:
-                            resp = await ss.get(pm.logo)
-                            if resp.ok:
-                                byts = await resp.read()
-                                upf, ref = await pbot.save_file(byts, resp.content_type)
-                                await sleep(1)
-                                typ = FileType[resp.content_type.split("/")[-1]]
-                                file, _ = await models.File.update_or_create(
-                                    {"ref": ref, "size": len(byts), "typ": typ}, name=pm.logo
-                                )
-                                await pbot.get_file(file.ref)  # check
-                # /logo
+                pmin = models.Pm.validate({**pmu.model_dump(), "country_id": country_id, "typ": pmex.typ})
                 try:
                     pms[k], _ = await models.Pm.update_or_create(**pmin.df_unq())
                 except (MultipleObjectsReturned, IntegrityError) as e:
                     raise e
-            prev = k, pmu.norm, pm.name, pmu.country
+            prev = k, pmu.norm, pmex.name, pmu.country
+
         # Pmexs
-        pmexs = [models.Pmex(exid=k, ex=self.ex, pm=pm, name=pms_epyds[k].name, logo=file) for k, pm in pms.items()]
+        pbot = PyroClient(bot)
+        await pbot.app.start()
+        async with ClientSession(headers=getattr(self, "logo_headers", None)) as ss:
+            pmexs = [
+                models.Pmex(
+                    # todo: refact logo
+                    exid=k,
+                    ex=self.ex,
+                    pm=pm,
+                    name=pmexs_epyds[k].name,
+                    logo=await self.logo_save(pmexs_epyds[k].logo, pbot, ss),
+                )
+                for k, pm in pms.items()
+            ]
+        await pbot.app.stop()
+
         await models.Pmex.bulk_create(pmexs, on_conflict=["ex_id", "exid"], update_fields=["pm_id", "logo_id", "name"])
         # Pmex banks
-        for k, pm in pms_epyds.items():
-            if banks := pm.banks:
+        for k, pmex in pmexs_epyds.items():
+            if banks := pmex.banks:
                 pmex = await models.Pmex.get(ex=self.ex, exid=k)  # pm=pms[k],
                 for b in banks:
                     await models.PmexBank.update_or_create({"name": b.name}, exid=b.exid, pmex=pmex)
@@ -206,6 +207,23 @@ 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:
+        if url or (file := None):
+            if not (file := await models.File.get_or_none(name=url)):
+                if not url.startswith("https:"):
+                    if not url.startswith("/"):
+                        url = "/" + url
+                    url = "https://" + self.logo_map[self.ex.name] + url
+                resp = await ss.get(url)
+                if resp.ok:
+                    byts = await resp.read()
+                    upf, ref = await pbot.save_file(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)
+                    # fr = await pbot.get_file(file.ref)  # check
+        return file
+
     # Импорт монет (с Coinex-ами) с биржи в бд
     async def set_coinexs(self):
         coins: dict[str, CoinEx] = await self.coins()

{xync_client-0.0.25.dev112 → xync_client-0.0.25.dev116}/xync_client/Abc/InAgent.py

@@ -1,8 +1,13 @@
 from abc import abstractmethod
 
+from xync_schema.models import Agent
+
+from xync_client.Abc.Agent import BaseAgentClient
+
 
 class BaseInAgentClient:
-    def __init__(self): ...
+    def __init__(self, agent: Agent):
+        self.agent_client: BaseAgentClient = agent.client()
 
     @abstractmethod
     async def start_listen(self) -> bool: ...

{xync_client-0.0.25.dev112 → xync_client-0.0.25.dev116}/xync_client/Binance/ex.py

@@ -22,7 +22,7 @@ class ExClient(BaseExClient):
     class BinanceUnifier(PmUnifier):
         pm_map = {
             "Banque de développement local (BDL)": "Banque de développement local (BDL)",
-            "Viettel Money": "ViettelPay"
+            "Viettel Money": "ViettelPay",
         }
 
     unifier_class = BinanceUnifier
@@ -41,7 +41,10 @@ class ExClient(BaseExClient):
 
     async def curs(self) -> dict[int, types.CurEx]:
         curs = await self._post("/bapi/c2c/v1/friendly/c2c/trade-rule/fiat-list")
-        return {c["currencyCode"]: types.CurEx(exid=c["currencyCode"], ticker=c["currencyCode"], scale=c["currencyScale"]) for c in curs["data"]}
+        return {
+            c["currencyCode"]: types.CurEx(exid=c["currencyCode"], ticker=c["currencyCode"], scale=c["currencyScale"])
+            for c in curs["data"]
+        }
 
     async def coins(self) -> dict[int, types.CoinEx]:
         for cur in (await self.curs()).keys():
@@ -131,10 +134,10 @@ async def main():
     _ = await init_db(PG_DSN, models)
     ex = await Ex.get(name="Binance")
     cl = ExClient(ex)
+    await cl.set_pmcurexs()
     await cl.pairs()
     await cl.pms()
     await cl.ads("ETH", "GEL", False)
-    await cl.set_pmcurexs()
     await cl.close()
 
 

xync_client-0.0.25.dev116/xync_client/Bybit/InAgent.py

@@ -0,0 +1,42 @@
+from asyncio import run
+
+from x_model import init_db
+from xync_schema import models
+
+from xync_client.Abc.InAgent import BaseInAgentClient
+from xync_client.Bybit.agent import AgentClient
+from xync_client.Bybit.ws import prv
+from xync_client.TgWallet.pyro import PyroClient
+from xync_client.loader import PG_DSN, bot
+
+
+class InAgentClient(BaseInAgentClient):
+    agent_client: AgentClient
+
+    async def start_listen(self):
+        t = await self.agent_client.ott()
+        ts = int(float(t["time_now"]) * 1000)
+        await prv(self.agent_client.agent.auth["deviceId"], t["result"], ts, listen)
+
+    # 3N: [T] - Уведомление об одобрении запроса на сделку
+    async def request_accepted_notify(self) -> int: ...  # id
+
+
+def listen(data: dict):
+    print(data)
+
+
+async def main():
+    _ = await init_db(PG_DSN, models, True)
+    pbot = PyroClient(bot)
+    await pbot.app.start()
+    await pbot.app.create_channel("tc")
+    await pbot.app.stop()
+
+    agent = await models.Agent.filter(actor__ex_id=9, auth__isnull=False).prefetch_related("actor__ex").first()
+    cl: InAgentClient = agent.in_client()
+    await cl.agent_client.close()
+
+
+if __name__ == "__main__":
+    run(main())

{xync_client-0.0.25.dev112 → xync_client-0.0.25.dev116}/xync_client/Bybit/agent.py

@@ -10,7 +10,6 @@ from xync_client.Abc.Base import FlatDict
 from xync_schema.models import Cur
 
 from xync_client.Abc.Agent import BaseAgentClient
-from xync_client.Bybit.ws import prv
 from xync_client.loader import BYT2FA, PG_DSN
 
 
@@ -315,9 +314,6 @@ async def main():
     _ = await init_db(PG_DSN, models, True)
     agent = await models.Agent.filter(actor__ex_id=9, auth__isnull=False).prefetch_related("actor__ex").first()
     cl: AgentClient = agent.client()
-    t = await cl.ott()
-    ts = int(float(t["time_now"]) * 1000)
-    await prv(agent.auth["deviceId"], t["result"], ts, listen)
     await cl.close()
 
 

{xync_client-0.0.25.dev112 → xync_client-0.0.25.dev116}/xync_client/Bybit/ws.py

@@ -1,6 +1,37 @@
+import hmac
 import json
-
 import websockets
+from time import time
+
+
+async def pub():
+    async with websockets.connect("wss://stream.bybit.com/v5/public/spot") as websocket:
+        sub_msg = json.dumps(
+            {"op": "subscribe", "req_id": "1", "args": ["tickers.BTCUSDT", "tickers.ETHUSDT", "tickers.TONUSDT"]}
+        )
+        await websocket.send(sub_msg)
+        p = {}
+        while resp := await websocket.recv():
+            if data := json.loads(resp).get("data"):
+                p[data["symbol"]] = data["lastPrice"]
+                print(f"BTC: {p.get('BTCUSDT')}\nETH: {p.get('ETHUSDT')}\nTON: {p.get('TONUSDT')}", end="\033[F\033[F")
+
+
+async def priv(key: str, sec: str):
+    async with websockets.connect("wss://stream.bybit.com/v5/private") as websocket:
+        expires = int((time() + 5) * 1000)
+        # Generate signature.
+        signature = str(
+            hmac.new(bytes(sec, "utf-8"), bytes(f"GET/realtime{expires}", "utf-8"), digestmod="sha256").hexdigest()
+        )
+        auth_msg = json.dumps({"op": "auth", "args": [key, expires, signature]})
+        await websocket.send(auth_msg)
+        await websocket.send(json.dumps({"req_id": "100001", "op": "ping"}))
+        sub_msg = json.dumps({"op": "subscribe", "args": ["wallet"]})
+        await websocket.send(sub_msg)
+        while resp := await websocket.recv():
+            if data := json.loads(resp).get("data"):
+                print(data)
 
 
 async def prv(did: str, tok: str, ts: int, cb: callable):

{xync_client-0.0.25.dev112 → xync_client-0.0.25.dev116}/xync_client/Mexc/ex.py

@@ -13,24 +13,39 @@ from xync_schema import types
 from xync_schema import models
 from xync_schema.models import Ex
 
+
 class ExClient(BaseExClient):
+    logo_headers = {
+        "accept-language": "ru,en;q=0.9",
+        "priority": "u=0, i",
+        "sec-ch-ua": '"Chromium";v="134", "Not:A-Brand";v="24", "Google Chrome";v="134"',
+        "sec-ch-ua-mobile": "?0",
+        "sec-ch-ua-platform": '"macOS"',
+        "sec-fetch-site": "none",  # work from CURL, not work from aiohttp with no this header
+        "user-agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36",
+    }
+
     class MexcUnifier(PmUnifier):
         pm_map = {
-             "Philippine National Bank (PNB)": "Philippines National Bank (PNB)",
-             "Al-Rajhi Bank": "Al Rajhi Bank",
-             "SBP - Fast Bank Transfer": "SBP",
-             "Touch 'n Go": "Touch n Go"
+            "Philippine National Bank (PNB)": "Philippines National Bank (PNB)",
+            "Al-Rajhi Bank": "Al Rajhi Bank",
+            "SBP - Fast Bank Transfer": "SBP",
+            "Touch 'n Go": "Touch n Go",
         }
+
     unifier_class = MexcUnifier
 
     async def _pms(self, cur) -> list[pm.PmE]:
-        pms = requests.get("https://p2p.mexc.com/api/payment/method", params={'currency': cur}).json()
+        pms = requests.get("https://p2p.mexc.com/api/payment/method", params={"currency": cur}).json()
         return [pm.PmE(**_pm) for _pm in pms["data"]]
 
     # 19: Список поддерживаемых валют тейкера
     async def curs(self) -> dict[str, types.CurEx]:  # {cur.ticker: cur}
-        _curs = requests.get('https://p2p.mexc.com/api/common/currency').json()
-        return {cur["currency"]: types.CurEx(exid=cur["currency"], ticker=cur["currency"], scale=cur["scale"]) for cur in _curs["data"]}
+        _curs = requests.get("https://p2p.mexc.com/api/common/currency").json()
+        return {
+            cur["currency"]: types.CurEx(exid=cur["currency"], ticker=cur["currency"], scale=cur["scale"])
+            for cur in _curs["data"]
+        }
 
     # 20: Список платежных методов
     async def pms(self, cur: models.Cur = None) -> dict[int | str, PmEx]:  # {pm.exid: pm}
@@ -47,8 +62,11 @@ class ExClient(BaseExClient):
 
     # 22: Список торгуемых монет (с ограничениям по валютам, если есть)
     async def coins(self) -> dict[str, types.CoinEx]:  # {coin.ticker: coin}
-        coins = requests.get('https://p2p.mexc.com/api/common/coins').json()
-        return {coin["coinId"]:types.CoinEx(exid=coin["coinId"], ticker=coin["coinName"],scale=coin["quantityScale"]) for coin in coins["data"]}
+        coins = requests.get("https://p2p.mexc.com/api/common/coins").json()
+        return {
+            coin["coinId"]: types.CoinEx(exid=coin["coinId"], ticker=coin["coinName"], scale=coin["quantityScale"])
+            for coin in coins["data"]
+        }
 
     # 23: Список пар валюта/монет
     async def pairs(self) -> tuple[MapOfIdsList, MapOfIdsList]:
@@ -59,27 +77,26 @@ class ExClient(BaseExClient):
 
     # 24: Список объяв по (buy/sell, cur, coin, pm)
     async def ads(
-            self, coin_exid: str, cur_exid: str, is_sell: bool, pm_exids: list[str | int] = None, amount: int = None
+        self, coin_exid: str, cur_exid: str, is_sell: bool, pm_exids: list[str | int] = None, amount: int = None
     ) -> list[ad.Ad]:  # {ad.id: ad}
         params = {
-            'allowTrade': 'false',
-            'amount': amount or "",
-            'blockTrade': 'false',
-            'coinId': coin_exid,
-            'countryCode': '',
-            'currency': cur_exid,
-            'follow': 'false',
-            'haveTrade': 'false',
-            'page': '1',
-            'payMethod': pm_exids or "",
-            'tradeType': 'SELL' if is_sell else "BUY",
+            "allowTrade": "false",
+            "amount": amount or "",
+            "blockTrade": "false",
+            "coinId": coin_exid,
+            "countryCode": "",
+            "currency": cur_exid,
+            "follow": "false",
+            "haveTrade": "false",
+            "page": "1",
+            "payMethod": pm_exids or "",
+            "tradeType": "SELL" if is_sell else "BUY",
         }
 
         ads = requests.get("https://p2p.mexc.com/api/market", params=params).json()
         return [ad.Ad(**_ad) for _ad in ads["data"]]
 
 
-
 async def main():
     _ = await init_db(PG_DSN, models, True)
     ex = await Ex.get(name="Mexc")
@@ -93,6 +110,6 @@ async def main():
     _pms = await cl.pms()
     await cl.close()
 
+
 if __name__ == "__main__":
     run(main())
-

xync_client-0.0.25.dev116/xync_client/TgWallet/pyro.py

@@ -0,0 +1,144 @@
+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 Agent
+
+
+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: Agent | Bot):
+        name = str(ab.actor.person.user.id) if isinstance(ab, Agent) else str(ab.id)
+        auth = {"session_string": ab.auth["sess"]} if isinstance(ab, Agent) else {"bot_token": ab.token}
+        self.app: Client = Client(name, TG_API_ID, TG_API_HASH, **auth)
+
+    @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:
+        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]:
+        await self.app.get_me()
+        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(self, uid, txt):
+        try:
+            return await self.app.send_message(uid, txt)
+        except Exception as e:
+            raise e
+
+    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)
+    agent: Agent = await Agent.filter(auth__isnull=False, ex__name="TgWallet").prefetch_related("ex").first()
+    pcl = PyroClient(agent)
+    await pcl.create_orders_forum(agent.actor.user_id)
+
+
+if __name__ == "__main__":
+    run(main())

{xync_client-0.0.25.dev112 → xync_client-0.0.25.dev116/xync_client.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xync-client
-Version: 0.0.25.dev112
+Version: 0.0.25.dev116
 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.25.dev112 → xync_client-0.0.25.dev116}/xync_client.egg-info/SOURCES.txt

@@ -57,6 +57,7 @@ xync_client/BitGet/ex.py
 xync_client/BitGet/req.mjs
 xync_client/BitGet/etype/ad.py
 xync_client/BitPapa/ex.py
+xync_client/Bybit/InAgent.py
 xync_client/Bybit/agent.py
 xync_client/Bybit/ex.py
 xync_client/Bybit/web_earn.py

xync_client-0.0.25.dev112/xync_client/TgWallet/pyro.py

@@ -1,156 +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.base.upload import File
-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.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 Agent
-
-
-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: Agent | Bot):
-        name = str(ab.actor.person.user.id) if isinstance(ab, Agent) else str(ab.id)
-        auth = {"session_string": ab.auth["sess"]} if isinstance(ab, Agent) else {"bot_token": ab.token}
-        self.app: Client = Client(name, TG_API_ID, TG_API_HASH, **auth)
-
-    async def get_init_data(self) -> dict:
-        async with self.app as app:
-            app: Client
-            bot = await app.resolve_peer("wallet")
-            res = await 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]:
-        async with self.app as app:
-            app: Client
-            await app.get_me()
-            chat: Chat = await app.create_supergroup("Xync Orders", "Xync Orders")
-            if not (await app.toggle_forum_topics(chat_id=chat.id, enabled=True)):
-                await app.delete_channel(chat.id)
-                await chat.leave()
-                raise Exception(f"Chat {chat.id} for {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:
-        async with self.app as app:
-            app: Client
-            try:
-                peer = await app.resolve_peer(uid)
-            except Exception as e:
-                raise e
-            return await app.invoke(GetUserPhotos(user_id=peer, offset=0, limit=1, max_id=-1))
-
-    async def send_message(self, uid, txt):
-        async with self.app as app:
-            app: Client
-            try:
-                return await app.send_message(uid, txt)
-            except Exception as e:
-                raise e
-
-    async def save_file(self, byts: bytes, ctype: str) -> tuple[MessageMediaDocument, bytes]:
-        async with self.app as app:
-            in_file = await app.save_file(BytesIO(byts))
-            imud = InputMediaUploadedDocument(file=in_file, mime_type=ctype, attributes=[])
-            upf: MessageMediaDocument = await 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
-            )
-
-    @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_photo(self, file: bytes) -> tuple[MessageMediaPhoto, bytes]:
-        async with self.app as app:
-            in_file = await app.save_file(BytesIO(file))
-            upm = UploadMedia(peer=InputPeerSelf(), media=InputMediaUploadedPhoto(file=in_file))
-            upp: MessageMediaPhoto = await 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:
-        async with self.app as app:
-            pid, ah, ref = self.ref_dec(fid)
-            loc = InputDocumentFileLocation(id=pid, access_hash=ah, file_reference=ref, thumb_size="x")
-            return await app.invoke(GetFile(location=loc, offset=0, limit=512 * 1024))
-
-    async def get_photo(self, fid: bytes, st: str) -> File:
-        async with self.app as app:
-            pid, ah, ref = self.ref_dec(fid)
-            loc = InputPhotoFileLocation(id=pid, access_hash=ah, file_reference=ref, thumb_size=st)
-            return await app.invoke(GetFile(location=loc, offset=0, limit=512 * 1024))
-
-
-async def main():
-    _ = await init_db(PG_DSN, models, True)
-    agent: Agent = await Agent.filter(auth__isnull=False, ex__name="TgWallet").prefetch_related("ex").first()
-    pcl = PyroClient(agent)
-    await pcl.create_orders_forum(agent.actor.user_id)
-
-
-if __name__ == "__main__":
-    run(main())