xync-client 0.0.151__tar.gz → 0.0.152__tar.gz

{xync_client-0.0.151/xync_client.egg-info → xync_client-0.0.152}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xync-client
-Version: 0.0.151
+Version: 0.0.152
 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.151 → xync_client-0.0.152}/xync_client/Abc/AdLoader.py

@@ -57,7 +57,6 @@ class AdLoader:
         coinex: models.CoinEx = None,
         curex: models.CurEx = None,
         rname: str = None,
-        pms_from_cond: bool = False,
     ) -> models.Ad:
         if not maker:
             if not (maker := await models.Actor.get_or_none(exid=pad.userId, ex=self.ex)):
@@ -87,13 +86,13 @@ class AdLoader:
             price=int(float(pad.price) * cur_scale),
             premium=int(float(pad.premium) * 100),
             cond_id=cid,
+            status=self.ad_status(ad_upd.status),
         )
         try:
             ad_db, _ = await models.Ad.update_or_create(**df_unq)
         except OperationalError as e:
             raise e
-        if not pms_from_cond:
-            await ad_db.pms.add(*(await models.Pm.filter(pmexs__ex=self.ex, pmexs__exid__in=pad.payments)))
+        await ad_db.pms.add(*(await models.Pm.filter(pmexs__ex=self.ex, pmexs__exid__in=pad.payments)))
         return ad_db
 
     async def cond_load(  # todo: refact from Bybit Ad format to universal
@@ -120,13 +119,7 @@ class AdLoader:
                 # if not len((old_cond := await Cond.get(id=old_cid).prefetch_related('ads')).ads):
                 #     await old_cond.delete()
                 #     logging.warning(f"Cond#{old_cid} deleted!")
-            return (
-                ad_db
-                or force
-                and await self.ad_load(
-                    ad, cid, ps, coinex=coinex, curex=curex, rname=rname, pms_from_cond=pms_from_cond
-                )
-            ), False
+            return (ad_db or force and await self.ad_load(ad, cid, ps, coinex=coinex, curex=curex, rname=rname)), False
         # если эта объява в таким ид уже есть в бд, но с другим условием (или без), а текущего условия еще нет в бд
         if ad_db:
             await ad_db.fetch_related("cond__ads", "maker")
@@ -154,9 +147,7 @@ class AdLoader:
             return ad_db, False
 
         cond = await self.cond_new(cleaned, {int(ad.userId)})
-        ad_db = await self.ad_load(
-            ad, cond.id, ps, coinex=coinex, curex=curex, rname=rname, pms_from_cond=pms_from_cond
-        )
+        ad_db = await self.ad_load(ad, cond.id, ps, coinex=coinex, curex=curex, rname=rname)
         ad_db.cond = cond
         return ad_db, True
 

{xync_client-0.0.151 → xync_client-0.0.152}/xync_client/Abc/Agent.py

@@ -1,10 +1,13 @@
 from abc import abstractmethod
+from asyncio.tasks import gather
 
 from pydantic import BaseModel
 from pyro_client.client.file import FileClient
 from x_client import df_hdrs
 from x_client.aiohttp import Client as HttpClient
 from xync_bot import XyncBot
+from xync_client.Abc.InAgent import BaseInAgentClient
+
 from xync_client.Bybit.etype.order import TakeAdReq
 from xync_schema import models
 from xync_schema.models import OrderStatus, Coin, Cur, Ad, AdStatus, Actor, Agent
@@ -15,13 +18,14 @@ from xync_client.Abc.xtype import CredExOut, BaseOrderReq, BaseAdUpdate
 from xync_client.Gmail import GmClient
 
 
-class BaseAgentClient(HttpClient):
+class BaseAgentClient(HttpClient, BaseInAgentClient):
     bbot: XyncBot
     fbot: FileClient
 
     def __init__(
         self,
         agent: Agent,
+        ex_client: BaseExClient,
         fbot: FileClient,
         bbot: XyncBot,
         headers: dict[str, str] = df_hdrs,
@@ -32,8 +36,20 @@ class BaseAgentClient(HttpClient):
         self.agent: Agent = agent
         self.actor: Actor = agent.actor
         self.gmail = GmClient(agent.actor.person.user)
+        self.ex_client: BaseExClient = ex_client
         super().__init__(self.actor.ex.host_p2p, headers, cookies)
-        self.ex_client: BaseExClient = self.actor.ex.client(fbot)
+
+    async def start(self):
+        tasks = []
+        if not self.is_started:
+            if self.agent.status & 1:  # race
+                tasks.append(self.start_race())
+            if self.agent.status & 2:  # in agent
+                tasks.append(self.start_listen())
+            if self.agent.status & 4:  # for further
+                ...
+            self.is_started = True
+        return await gather(*tasks)
 
     # 0: Получшение ордеров в статусе status, по монете coin, в валюте coin, в направлении is_sell: bool
     @abstractmethod

{xync_client-0.0.151 → xync_client-0.0.152}/xync_client/Abc/Ex.py

@@ -17,6 +17,7 @@ from xync_client.pm_unifier import PmUnifier, PmUni
 
 
 class BaseExClient(HttpClient, AdLoader):
+    host: str = None
     cur_map: dict[int, str] = {}
     unifier_class: type = PmUnifier
     logo_pre_url: str
@@ -34,7 +35,7 @@ class BaseExClient(HttpClient, AdLoader):
     ):
         self.ex = ex
         self.bot = bot
-        super().__init__(getattr(ex, attr), headers, cookies, proxy and proxy.str())
+        super().__init__(self.host or getattr(ex, attr), headers, cookies, proxy and proxy.str())
 
     @abstractmethod
     def pm_type_map(self, typ: models.PmEx) -> str: ...

xync_client-0.0.152/xync_client/Abc/InAgent.py

@@ -0,0 +1,10 @@
+from abc import abstractmethod
+
+
+class BaseInAgentClient:
+    @abstractmethod
+    async def start_listen(self) -> bool: ...
+
+    # 3N: [T] - Уведомление об одобрении запроса на сделку
+    @abstractmethod
+    async def request_accepted_notify(self) -> int: ...  # id

{xync_client-0.0.151 → xync_client-0.0.152}/xync_client/Bybit/InAgent.py

@@ -9,6 +9,7 @@ import websockets
 from asyncio import run, sleep
 from decimal import Decimal
 
+from bybit_p2p import P2P
 from playwright.async_api import async_playwright
 from pydantic import ValidationError
 from pyro_client.client.file import FileClient
@@ -16,6 +17,7 @@ from tortoise.exceptions import IntegrityError
 from tortoise.timezone import now
 from tortoise.transactions import in_transaction
 from xync_bot import XyncBot
+from xync_client.Bybit.ex import ExClient
 
 from xync_client.Abc.PmAgent import PmAgentClient
 from xync_schema import models
@@ -32,16 +34,17 @@ from xync_client.Bybit.etype.order import (
 )
 from xync_client.loader import NET_TOKEN, PAY_TOKEN
 from xync_client.Abc.InAgent import BaseInAgentClient
-from xync_client.Bybit.agent import AgentClient
 
 
 class InAgentClient(BaseInAgentClient):
-    agent_client: AgentClient
+    actor: models.Actor
+    api: P2P
+    ex_client: ExClient
 
     async def start_listen(self):
-        t = await self.agent_client.ott()
+        t = await self.ott()
         ts = int(float(t["time_now"]) * 1000)
-        await self.ws_prv(self.agent_client.agent.auth["deviceId"], t["result"], ts)
+        await self.ws_prv(self.actor.agent.auth["deviceId"], t["result"], ts)
 
     # 3N: [T] - Уведомление об одобрении запроса на сделку
     async def request_accepted_notify(self) -> int: ...  # id
@@ -87,11 +90,11 @@ class InAgentClient(BaseInAgentClient):
                                     except ValidationError as e:
                                         logging.error(e)
                                         logging.error(data["data"])
-                                    order = self.agent_client.api.get_order_details(orderId=upd.id)
+                                    order = self.api.get_order_details(orderId=upd.id)
                                     order = OrderFull.model_validate(order["result"])
                                     order_db = await models.Order.get_or_none(
                                         exid=order.id, ad__exid=order.itemId
-                                    ) or await self.agent_client.create_order(order)
+                                    ) or await self.create_order(order)
                                     match upd.status:
                                         case StatusApi.created:
                                             logging.info(f"Order {order.id} created at {order.createDate}")
@@ -136,7 +139,7 @@ class InAgentClient(BaseInAgentClient):
                                                     continue
 
                                                 # если висят незавершенные продажи с такой же суммой
-                                                pos = (await self.agent_client.get_orders_active(1))["result"]
+                                                pos = (await self.get_orders_active(1))["result"]
                                                 pos = [
                                                     o
                                                     for o in pos.get("items", [])
@@ -146,14 +149,14 @@ class InAgentClient(BaseInAgentClient):
                                                         and int(order.createDate)
                                                         < int(o["createDate"]) + 15 * 60 * 1000
                                                         # get full_order from o, and cred or pm from full_order:
-                                                        and self.agent_client.api.get_order_details(orderId=o["id"])[
-                                                            "result"
-                                                        ]["paymentTermList"][0]["accountNo"]
+                                                        and self.api.get_order_details(orderId=o["id"])["result"][
+                                                            "paymentTermList"
+                                                        ][0]["accountNo"]
                                                         == order.paymentTermList[0].accountNo
                                                     )
                                                 ]
                                                 curex = await models.CurEx.get(
-                                                    cur__ticker=order.currencyId, ex=self.agent_client.ex_client.ex
+                                                    cur__ticker=order.currencyId, ex=self.ex_client.ex
                                                 )
                                                 pos_db = await models.Order.filter(
                                                     exid__not=order.id,
@@ -163,16 +166,16 @@ class InAgentClient(BaseInAgentClient):
                                                     created_at__gt=now() - timedelta(minutes=15),
                                                 )
                                                 if pos or pos_db:
-                                                    await self.agent_client.ex_client.bot.send(
+                                                    await self.ex_client.bot.send(
                                                         f"[Duplicate amount!]"
                                                         f"(https://www.bybit.com/ru-RU/p2p/orderList/{order.id})",
-                                                        self.agent_client.actor.person.user.username_id,
+                                                        self.actor.person.user.username_id,
                                                     )
                                                     logging.warning("Duplicate amount!")
                                                     continue
 
                                                 # !!! ОТПРАВЛЯЕМ ДЕНЬГИ !!!
-                                                self.agent_client.api.release_assets(orderId=upd.id)
+                                                self.api.release_assets(orderId=upd.id)
                                                 logging.info(
                                                     f"Order {order.id} created, paid before #{tid}:{am} at {order.createDate}, and RELEASED at {now()}"
                                                 )
@@ -236,14 +239,14 @@ class InAgentClient(BaseInAgentClient):
                                 case "RECEIVE":
                                     upd = Receive.model_validate(data["data"])
                                     if order_db := await models.Order.get_or_none(
-                                        exid=upd.orderId, ad__maker__ex=self.agent_client.actor.ex
+                                        exid=upd.orderId, ad__maker__ex=self.actor.ex
                                     ).prefetch_related("ad__pair_side__pair", "cred__pmcur__cur"):
-                                        im_taker = order_db.taker_id == self.agent_client.actor.id
+                                        im_taker = order_db.taker_id == self.actor.id
                                         im_buyer = order_db.ad.pair_side.is_sell == im_taker
                                         if order_db.ad.auto_msg != upd.message and upd.roleType == "user":
                                             msg, _ = await models.Msg.update_or_create(
                                                 {
-                                                    "to_maker": upd.userId == self.agent_client.actor.exid and im_taker,
+                                                    "to_maker": upd.userId == self.actor.exid and im_taker,
                                                     "sent_at": datetime.fromtimestamp(float(upd.createDate) / 1000),
                                                 },
                                                 txt=upd.message,
@@ -262,7 +265,7 @@ class InAgentClient(BaseInAgentClient):
                                     if upd.orderStatus in (
                                         StatusApi.wait_for_buyer,
                                     ):  # todo: тут приходит ордер.статус=10, хотя покупатель еще не нажал оплачено
-                                        order = self.agent_client.api.get_order_details(orderId=upd.orderId)["result"]
+                                        order = self.api.get_order_details(orderId=upd.orderId)["result"]
                                         order = OrderFull.model_validate(order)
 
                                 case "CLEAR":
@@ -295,15 +298,13 @@ class InAgentClient(BaseInAgentClient):
     async def money_upd(self, order_db: models.Order):
         # обновляем остаток монеты
         await order_db.fetch_related("ad__pair_side__pair", "cred", "transfer")
-        ass = await models.Asset.get(
-            addr__coin_id=order_db.ad.pair_side.pair.coin_id, addr__actor=self.agent_client.actor
-        )
+        ass = await models.Asset.get(addr__coin_id=order_db.ad.pair_side.pair.coin_id, addr__actor=self.actor)
         # обновляем остаток валюты
         fiat = await models.Fiat.get(
-            cred__person_id=self.agent_client.actor.person_id, cred__pmcur_id=order_db.cred.pmcur_id
+            cred__person_id=self.actor.person_id, cred__pmcur_id=order_db.cred.pmcur_id
         ).prefetch_related("cred__pmcur__pm")
         fee = round(order_db.amount * (fiat.cred.pmcur.pm.fee or 0) * 0.0001)
-        im_seller = order_db.ad.pair_side.is_sell == (_im_maker := order_db.ad.maker_id == self.agent_client.actor.id)
+        im_seller = order_db.ad.pair_side.is_sell == (_im_maker := order_db.ad.maker_id == self.actor.id)
         # k = int(im_seller) * 2 - 1  # im_seller: 1, im_buyer: -1
         if order_db.status == OrderStatus.created:
             if im_seller:
@@ -335,9 +336,9 @@ class InAgentClient(BaseInAgentClient):
         pma, cur = await self.get_pma_by_pmex(order_db)
         async with in_transaction():
             # отмечаем ордер на бирже "оплачен"
-            pmex = await models.PmEx.get(pm_id=order_db.cred.pmcur.pmex_exid, ex=self.agent_client.actor.ex)
-            credex = await models.CredEx.get(cred=order_db.cred, ex=self.agent_client.actor.ex)
-            self.agent_client.api.mark_as_paid(
+            pmex = await models.PmEx.get(pm_id=order_db.cred.pmcur.pmex_exid, ex=self.actor.ex)
+            credex = await models.CredEx.get(cred=order_db.cred, ex=self.actor.ex)
+            self.api.mark_as_paid(
                 orderId=str(order_db.exid),
                 paymentType=pmex.exid,  # pmex.exid
                 paymentId=str(credex.exid),  # credex.exid
@@ -346,7 +347,7 @@ class InAgentClient(BaseInAgentClient):
             if t := await models.Transfer.get_or_none(order=order_db, amount=order_db.amount):
                 await pma.bot.send(
                     f"Order# {order_db.exid}: Double send {fmt_am}{cur} to {order_db.cred.detail} #{t.pmid}!",
-                    self.agent_client.actor.person.user.username_id,
+                    self.actor.person.user.username_id,
                 )
                 raise Exception(
                     f"Order# {order_db.exid}: Double send {fmt_am}{cur} to {order_db.cred.detail} #{t.pmid}!"
@@ -367,23 +368,19 @@ class InAgentClient(BaseInAgentClient):
 
     async def send_receipt(self, oexid: str, tid: int) -> tuple[PmAgentClient | None, models.CredEx] | None:
         try:
-            if res := self.agent_client.api.upload_chat_file(upload_file=f"tmp/{tid}.png").get("result"):
+            if res := self.api.upload_chat_file(upload_file=f"tmp/{tid}.png").get("result"):
                 await sleep(0.5)
-                self.agent_client.api.send_chat_message(
-                    orderId=oexid, contentType="pic", message=res["url"], msgUuid=uuid4().hex
-                )
+                self.api.send_chat_message(orderId=oexid, contentType="pic", message=res["url"], msgUuid=uuid4().hex)
         except Exception as e:
             logging.error(e)
         await sleep(0.5)
-        self.agent_client.api.send_chat_message(
-            orderId=oexid, contentType="str", message=f"#{tid}", msgUuid=uuid4().hex
-        )
+        self.api.send_chat_message(orderId=oexid, contentType="str", message=f"#{tid}", msgUuid=uuid4().hex)
 
     async def get_pma_by_cdex(self, order: OrderFull) -> tuple[PmAgentClient | None, models.CredEx] | None:
         cdxs = await models.CredEx.filter(
-            ex=self.agent_client.ex_client.ex,
+            ex=self.ex_client.ex,
             exid__in=[ptl.id for ptl in order.paymentTermList],
-            cred__person=self.agent_client.actor.person,
+            cred__person=self.actor.person,
         ).prefetch_related("cred__pmcur__cur")
         pmas = [pma for cdx in cdxs if (pma := self.pmacs.get(cdx.cred.pmcur.pmex_exid))]
         if not len(pmas):
@@ -445,7 +442,7 @@ async def main():
         except Exception as e:
             await b.send("😱Bybit InAgent CRASHED!!!😱", agent.actor.person.user.username_id)
             await b.send(f"```\n{''.join(traceback.format_exception(e))}\n```", agent.actor.person.user.username_id)
-        await cl.agent_client.close()
+        await cl.close()
 
 
 if __name__ == "__main__":

{xync_client-0.0.151 → xync_client-0.0.152}/xync_client/Bybit/agent.py

@@ -26,14 +26,15 @@ from x_client import df_hdrs
 from x_model import init_db
 from x_model.func import ArrayAgg
 from xync_bot import XyncBot
+from xync_client.Bybit.ex import ExClient
 from xync_schema import models
-from xync_schema.enums import OrderStatus
+from xync_schema.enums import OrderStatus, AgentStatus
 
 from xync_schema.models import Actor, PmCur, Agent
 
 from xync_client.Abc.Agent import BaseAgentClient
 from xync_client.Abc.xtype import FlatDict, BaseOrderReq
-from xync_client.Bybit.etype.ad import AdPostRequest, AdUpdateRequest, Ad, AdStatus
+from xync_client.Bybit.etype.ad import AdPostRequest, AdUpdateRequest, Ad, AdStatus, MyAd
 from xync_client.Bybit.etype.cred import CredEpyd
 from xync_client.Bybit.etype.order import (
     OrderRequest,
@@ -88,8 +89,8 @@ class AgentClient(BaseAgentClient):  # Bybit client
         "securityRiskToken": "",
     }
 
-    def __init__(self, agent: Agent, fbot: FileClient, bbot: XyncBot, **kwargs):
-        super().__init__(agent, fbot, bbot, **kwargs)
+    def __init__(self, agent: Agent, ex_client: ExClient, fbot: FileClient, bbot: XyncBot, **kwargs):
+        super().__init__(agent, ex_client, fbot, bbot, **kwargs)
         self.sec_hdrs = {
             "accept-language": "ru-RU,ru;q=0.9,en-US;q=0.8,en;q=0.7",
             "gdfp": agent.auth["Risktoken"],
@@ -154,15 +155,24 @@ class AgentClient(BaseAgentClient):  # Bybit client
             raise Exception(f"Set default cur for {pmex.name}")
         if not (pmcur := await models.PmCur.get_or_none(cur_id=cur_id, pm_id=pmex.pm_id)):
             raise HTTPException(f"No PmCur with cur#{ecdx.currencyBalance} and pm#{ecdx.paymentType}", 404)
-        dct = {
-            "pmcur_id": pmcur.id,
-            "name": ecdx.realName,
-            "person_id": pers_id or self.actor.person_id,
-            "detail": ecdx.accountNo,
-            "extra": ecdx.branchName or ecdx.bankName or ecdx.qrcode or ecdx.payMessage or ecdx.paymentExt1,
-        }  # todo: WTD with multicur pms?
-        cred_in = models.Cred.validate(dct, False)
-        cred_db, _ = await models.Cred.update_or_create(**cred_in.df_unq())
+        xtr = ecdx.branchName
+        if ecdx.bankName:
+            xtr += (" | " if xtr else "") + ecdx.bankName
+        elif ecdx.payMessage:
+            xtr += (" | " if xtr else "") + ecdx.payMessage
+        elif ecdx.qrcode:
+            xtr += (" | " if xtr else "") + ecdx.qrcode
+        elif ecdx.paymentExt1:
+            xtr += (" | " if xtr else "") + ecdx.paymentExt1
+        cred_db, _ = await models.Cred.update_or_create(
+            {
+                "name": ecdx.realName,
+                "extra": xtr,
+            },
+            pmcur=pmcur,
+            person_id=pers_id or self.actor.person_id,
+            detail=ecdx.accountNo,
+        )
         credex_in = models.CredEx.validate({"exid": ecdx.id, "cred_id": cred_db.id, "ex_id": self.actor.ex.id})
         credex_db, _ = await models.CredEx.update_or_create(**credex_in.df_unq())
         return credex_db
@@ -249,9 +259,9 @@ class AgentClient(BaseAgentClient):  # Bybit client
         ads = [ad for ad in list_ads if set(ad["payments"]) - {"5", "51"}]
         return float(ads[0]["price"])
 
-    def my_ads(self, active: bool = True, page: int = 1) -> list[Ad]:
+    def my_ads(self, active: bool = True, page: int = 1) -> list[MyAd]:
         resp = self.api.get_ads_list(size="30", page=str(page), status=AdStatus.active if active else AdStatus.sold_out)
-        ads = [Ad.model_validate(ad) for ad in resp["result"]["items"]]
+        ads = [MyAd.model_validate(ad) for ad in resp["result"]["items"]]
         if resp["result"]["count"] > 30 * page:
             ads.extend(self.my_ads(active, page + 1))
         return ads
@@ -260,9 +270,13 @@ class AgentClient(BaseAgentClient):  # Bybit client
         ads = self.my_ads(True)
         if not active:
             ads += self.my_ads(False)
-        res = [await self.ex_client.ad_load(ad, maker=self.actor) for ad in ads]
-        res = [await models.MyAd.update_or_create(ad=ad) for ad in res]
-        return len(res)
+        for ad in ads:
+            ad_db = await self.ex_client.ad_load(ad, maker=self.actor)
+            mad_db, _ = await models.MyAd.update_or_create(ad=ad_db)
+            exids = [pt.id for pt in ad.paymentTerms]
+            credexs = await models.CredEx.filter(ex_id=self.actor.ex_id, exid__in=exids)
+            await mad_db.creds.add(*credexs)
+        return len(ads)
 
     def get_security_token_create(self):
         data = self._post("/x-api/fiat/otc/item/create", self.create_ad_body)
@@ -741,10 +755,15 @@ class AgentClient(BaseAgentClient):  # Bybit client
     #     if round(cpc * new_premium / cpm, 2) == m
     #     mad.premium = new_premium.to_eng_string()
 
-    async def racing(
-        self,
-        race: models.Race,
-    ):
+    async def start_race(self):
+        races = await models.Race.filter(started=True, road__ad__maker_id=self.actor.id).prefetch_related(
+            "road__ad__pair_side__pair__cur",
+            "road__ad__pms",
+        )
+        tasks = [asyncio.create_task(self.racing(race), name=f"Rc{race.id}") for race in races]
+        return await gather(*tasks)
+
+    async def racing(self, race: models.Race):
         coinex: models.CoinEx = await models.CoinEx.get(
             coin_id=race.road.ad.pair_side.pair.coin_id, ex=self.actor.ex
         ).prefetch_related("coin")
@@ -1099,23 +1118,26 @@ class ExcCode(IntEnum):
     Unknown = 912300014
 
 
+@post_save(models.Race)
+async def race_upserted(
+    _cls: type[models.Race], race: models.Race, created: bool, _db: BaseDBAsyncClient, _updated: list[str]
+):
+    logging.warning(f"Race {race.id} is now upserted")
+    asyncio.all_tasks()
+    if created:
+        ...
+    else:  # параметры гонки изменены
+        ...
+
+
 async def main():
     logging.basicConfig(level=logging.INFO)
     cn = await init_db(TORM)
 
-    @post_save(models.Race)
-    async def race_upserted(
-        _cls: type[models.Race], race: models.Race, created: bool, _db: BaseDBAsyncClient, _updated: list[str]
-    ):
-        logging.warning(f"Race {race.id} is now upserted")
-        asyncio.all_tasks()
-        if created:
-            ...
-        else:  # параметры гонки изменены
-            ...
-
     agent = (
-        await models.Agent.filter(actor__ex_id=4, auth__isnull=False, active=True, actor__person__user__id=2)
+        await models.Agent.filter(
+            actor__ex_id=4, auth__isnull=False, status__gt=AgentStatus.off, actor__person__user__id=1
+        )
         .prefetch_related(
             "actor__ex",
             "actor__person__user__gmail",
@@ -1128,15 +1150,24 @@ async def main():
     filebot = FileClient(NET_TOKEN)
     # await filebot.start()
     # b.add_handler(MessageHandler(cond_start_handler, command("cond")))
-    cl: AgentClient = agent.client(filebot, XyncBot(PAY_TOKEN, cn))
-    req = TakeAdReq(ad_id=1955696985964089344, amount=504, pm_id=128)
-    await cl.take_ad(req)
+    ex = await models.Ex.get(name="Bybit")
+    ecl: ExClient = ex.client(filebot)
+    cl: AgentClient = agent.client(ecl, filebot, XyncBot(PAY_TOKEN, cn))
+
+    # req = TakeAdReq(ad_id=1955696985964089344, amount=504, pm_id=128)
+    # await cl.take_ad(req)
+
+    # await cl.actual_cond()
+    # cl.get_api_orders(),  # 10, 1738357200000, 1742504399999
 
     # await cl.ex_client.set_pairs()
     # await cl.ex_client.set_pms()
-    await cl.set_creds()
+
+    # await cl.set_creds()
     await cl.export_my_ads()
 
+    await cl.start()
+
     # создание гонок по мои активным объявам:
     # for ma in cl.my_ads():
     #     my_ad = await models.MyAd.get(ad__exid=ma.id).prefetch_related('ad__pms', 'ad__pair_side__pair')
@@ -1161,22 +1192,6 @@ async def main():
     # )
     # await cl.get_api_orders()  # 43, 1741294800000, 1749157199999)
 
-    races = await models.Race.filter(started=True, road__ad__maker_id=agent.actor_id).prefetch_related(
-        "road__ad__pair_side__pair__cur",
-        "road__ad__pms",
-    )
-    tasks = [asyncio.create_task(cl.racing(race), name=f"Rc{race.id}") for race in races]
-    # await cl.actual_cond()
-    try:
-        await gather(
-            *tasks
-            # cl.get_api_orders(),  # 10, 1738357200000, 1742504399999
-        )
-    except Exception as e:
-        await filebot.send("🤬Bybit agent CRASHED!!!🤬", agent.actor.person.user.username_id)
-        await filebot.send(e.__repr__(), agent.actor.person.user.username_id)
-        raise e
-
     # await cl.cancel_order(res.orderId)
     await filebot.stop()
     await cl.close()

{xync_client-0.0.151 → xync_client-0.0.152}/xync_client/Bybit/etype/ad.py

@@ -1,7 +1,7 @@
 from enum import StrEnum
 from typing import List, Optional, Any, Literal
-from pydantic import BaseModel, Field, field_serializer
-from xync_schema import xtype
+from pydantic import BaseModel, Field
+from xync_client.Bybit.etype.cred import MyPaymentTerm
 from xync_schema.xtype import BaseAd
 
 from xync_client.Abc.xtype import BaseAdUpdate
@@ -126,59 +126,14 @@ class Ad(BaseAd):
     verificationOrderLabels: List[Any] = None  # for initial actualize
     verificationOrderSwitch: bool = None  # for initial actualize
     version: int = None  # for initial actualize
-    #
-    #
-    # class Ad(BaseAd):
-    #     accountId: str = None  # for initial actualize
-    #     authStatus: int = None  # for initial actualize
-    #     authTag: List[str] = None  # for initial actualize
-    #     ban: bool = None  # for initial actualize
-    #     baned: bool = None  # for initial actualize
-    #     blocked: str = None  # for initial actualize
-    #     createDate: str = None  # for initial actualize
-    #     currencyId: str = None  # for initial actualize
-    #     executedQuantity: str = None  # for initial actualize
-    #     fee: str = None  # for initial actualize
-    #     finishNum: int = None  # for initial actualize
-    #     frozenQuantity: str = None  # for initial actualize
-    #     exid: str = Field(serialization_alias="id")
-    #     isOnline: bool = None  # for initial actualize
-    #     itemType: str = None  # for initial actualize
-    #     lastLogoutTime: str = None  # for initial actualize
-    #     quantity: str = Field(serialization_alias="lastQuantity")
-    #     makerContact: bool = None  # for initial actualize
-    #     max_fiat: str = Field(serialization_alias="maxAmount")
-    #     min_fiat: str = Field(serialization_alias="minAmount")
-    #     nickName: str = None  # for initial actualize
-    #     orderNum: int = None  # for initial actualize
-    #     paymentPeriod: int = None  # for initial actualize
-    #     payments: List[str] = None  # for initial actualize
-    #     premium: str = None  # for initial actualize
-    #     price: str = None  # for initial actualize
-    #     priceType: Literal[0, 1] = None  # for initial actualize  # 0 - fix rate, 1 - floating
-    #     allQuantity: str = Field(serialization_alias="quantity")  # for initial actualize
-    #     recentExecuteRate: int = None  # for initial actualize
-    #     recentOrderNum: int = None  # for initial actualize
-    #     recommend: bool = None  # for initial actualize
-    #     recommendTag: str = None  # for initial actualize
-    #     auto_msg: str = Field(serialization_alias="remark")
-    #     is_sell: Literal[0, 1] = Field(serialization_alias="side")  # for initial actualize # 0 - покупка, 1 - продажа (для мейкера, т.е КАКАЯ объява)
-    #     status: Literal[10, 20, 30]  # 10: online; 20: offline; 30: completed
-    #     symbolInfo: SymbolInfo = None  # for initial actualize
-    #     tokenId: str = None  # for initial actualize
-    #     tokenName: str = None  # for initial actualize
-    #     tradingPreferenceSet: TradingPreferenceSet | None = None  # for initial actualize
-    #     userId: str = Field(serialization_alias="maker__exid")
-    #     userMaskId: str = None  # for initial actualize
-    #     userType: str = None  # for initial actualize
-    #     verificationOrderAmount: str = None  # for initial actualize
-    #     verificationOrderLabels: List[Any] = None  # for initial actualize
-    #     verificationOrderSwitch: bool = None  # for initial actualize
-    #     version: int = None  # for initial actualize
-
-    @field_serializer("status")
-    def status(self, status, _info) -> xtype.AdStatus:
-        return {10: xtype.AdStatus.active, 20: xtype.AdStatus.defActive, 30: xtype.AdStatus.soldOut}[status]
+
+    # @field_serializer("status")
+    # def status(self, status, _info) -> xtype.AdStatus:
+    #     return {10: xtype.AdStatus.active, 20: xtype.AdStatus.defActive, 30: xtype.AdStatus.soldOut}[status]
+
+
+class MyAd(Ad):
+    paymentTerms: List[MyPaymentTerm]
 
 
 class AdPostRequest(BaseModel):