xync-client 0.0.164__py3-none-any.whl → 0.0.179.dev4__py3-none-any.whl

xync_client/Abc/Agent.py

@@ -5,49 +5,53 @@ from collections import defaultdict
 from typing import Literal
 
 from pydantic import BaseModel
-from pyro_client.client.file import FileClient
+from tortoise.exceptions import IntegrityError
 from x_client import df_hdrs
 from x_client.aiohttp import Client as HttpClient
-from xync_bot import XyncBot
 from xync_client.Abc.PmAgent import PmAgentClient
 
 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
-from xync_schema.xtype import BaseAd
+from xync_schema.models import OrderStatus, Coin, Cur, Ad, Actor, Agent
+from xync_schema import xtype
 
 from xync_client.Abc.Ex import BaseExClient
-from xync_client.Abc.xtype import CredExOut, BaseOrderReq, BaseAdUpdate, AdUpd, GetAds
+from xync_client.Abc.xtype import (
+    BaseCredEx,
+    BaseOrderReq,
+    BaseAd,
+    AdUpdReq,
+    GetAdsReq,
+    BaseCredexsExidsTrait,
+    BaseOrderFull,
+)
 from xync_client.Gmail import GmClient
 
 
-class BaseAgentClient(HttpClient, BaseInAgentClient):
+class BaseAgentClient(HttpClient, BaseInAgentClient):  # , metaclass=ABCMeta
     actor: Actor
     agent: Agent
-    bbot: XyncBot
-    fbot: FileClient
     ex_client: BaseExClient
-    orders: dict[int, tuple[models.Order, BaseModel]] = {}  # pending
+    orders: dict[int, tuple[models.Order, xtype.BaseOrder]] = {}  # pending
     pm_clients: dict[int, PmAgentClient]  # {pm_id: PmAgentClient}
     api: HttpClient
     cred_x2e: dict[int, int] = {}
-    cred_e2x: dict[int, int] = {}
+    cred_e2x: dict[int, models.CredEx] = {}
+    order_x2e: dict[int, int] = {}
+    order_e2x: dict[int, int] = {}
+    cdx_cls: type[BaseCredEx]
 
     def __init__(
         self,
         agent: Agent,  # agent.actor.person.user
         ex_client: BaseExClient,
-        fbot: FileClient,
-        bbot: XyncBot,
         pm_clients: dict[int, PmAgentClient] = None,
         headers: dict[str, str] = df_hdrs,
         cookies: dict[str, str] = None,
         proxy: models.Proxy = None,
     ):
-        self.bbot = bbot
-        self.fbot = fbot
         self.agent: Agent = agent
         self.actor: Actor = agent.actor
         self.gmail = agent.actor.person.user.gmail and GmClient(agent.actor.person.user)
@@ -59,15 +63,30 @@ class BaseAgentClient(HttpClient, BaseInAgentClient):
 
     async def x2e_cred(self, cred_id: int) -> int:  # cred.exid
         if not self.cred_x2e.get(cred_id):
-            self.cred_x2e[cred_id] = (await models.CredEx.get(cred_id=cred_id)).exid
-            self.cred_e2x[self.cred_x2e[cred_id]] = cred_id
+            credex = await models.CredEx.get(cred_id=cred_id)
+            self.cred_x2e[cred_id] = credex.exid
+            self.cred_e2x[credex.exid] = credex
         return self.cred_x2e[cred_id]
 
-    async def e2x_cred(self, exid: int) -> int:  # cred.id
-        if not self.cred_e2x.get(exid):
-            self.cred_e2x[exid] = (await models.CredEx.get(exid=exid, ex=self.ex_client.ex)).cred_id
-            self.cred_x2e[self.cred_e2x[exid]] = exid
-        return self.cred_e2x[exid]
+    async def e2x_cred(self, base_credex: BaseCredEx) -> models.CredEx:  # cred.id
+        if not self.cred_e2x.get(base_credex.exid):
+            if not (credex := await models.CredEx.get_or_none(exid=base_credex.exid, ex=self.ex_client.ex)):
+                credex = await self.credex_save(base_credex)
+            self.cred_e2x[base_credex.exid] = credex
+            self.cred_x2e[credex.cred_id] = base_credex.exid
+        return self.cred_e2x[base_credex.exid]
+
+    async def x2e_order(self, order_id: int) -> int:  # order.exid
+        if not self.order_x2e.get(order_id):
+            self.order_x2e[order_id] = (await models.Order[order_id]).exid
+            self.order_e2x[self.order_x2e[order_id]] = order_id
+        return self.order_x2e[order_id]
+
+    async def e2x_order(self, exid: int) -> int:  # order.id
+        if not self.order_e2x.get(exid):
+            self.order_e2x[exid] = (await models.Order.get(exid=exid, taker__ex=self.ex_client.ex)).id
+            self.order_x2e[self.order_e2x[exid]] = exid
+        return self.order_e2x[exid]
 
     async def start(self):
         if self.agent.status & 1:  # race
@@ -78,6 +97,115 @@ class BaseAgentClient(HttpClient, BaseInAgentClient):
         if self.agent.status & 2:  # listen
             await self.start_listen()
 
+    @abstractmethod
+    async def _get_creds(self) -> list[BaseModel]: ...
+
+    async def get_creds(self) -> list[BaseCredEx]:
+        creds: list[BaseModel] = await self._get_creds()
+        return [self.cdx_cls.model_validate(cred, from_attributes=True) for cred in creds]
+
+    async def credex_save(self, cdx: BaseCredEx, pers_id: int = None, cur_id: int = None) -> models.CredEx | None:
+        pmex = None
+        if cred_old := await models.Cred.get_or_none(
+            credexs__exid=cdx.exid, credexs__ex=self.actor.ex
+        ).prefetch_related("pmcur"):  # is old Cred
+            cur_id = cur_id or cred_old.pmcur.cur_id
+        elif not cur_id:  # is new Cred
+            if cdx.curex_exid:
+                cur_id = (await models.CurEx.get(exid=cdx.curex_exid, ex=self.actor.ex)).cur_id
+            else:
+                pmex = await models.PmEx.get_or_none(exid=cdx.pmex_exid, ex=self.ex_client.ex).prefetch_related(
+                    "pm__curs"
+                )
+                cur_id = (
+                    pmex.pm.df_cur_id
+                    or (await cdx.guess_cur(pmex.pm.curs) if len(pmex.pm.curs) != 1 else pmex.pm.curs[0].cur_id)
+                    or (pmex.pm.country_id and (await pmex.pm.country).cur_id)
+                    # or (ecdx.currencyBalance and await models.Cur.get_or_none(ticker=ecdx.currencyBalance[0]))  # это че еще за хуйня?
+                )
+        if not cur_id:
+            raise ValueError(f"Set default cur for {pmex.name}")
+        pm_id = pmex and pmex.pm_id or await self.ex_client.e2x_pm(cdx.pmex_exid)
+        if not (pmcur := await models.PmCur.get_or_none(cur_id=cur_id, pm_id=pm_id)):
+            raise ValueError(f"No PmCur with cur#{cur_id} and pm#{cdx.pmex_exid}", 404)
+        try:
+            pers_id = pers_id or cdx.seller.exid and (await self.ex_client.e2x_actor(cdx.seller)).person_id
+            cred_db, _ = await models.Cred.update_or_create(
+                {"name": cdx.name, "extra": cdx.extra},
+                pmcur=pmcur,
+                person_id=pers_id,
+                detail=cdx.detail,
+            )
+            if not cred_db.ovr_pm_id and ("XyncPay" in cred_db.detail or "XyncPay" in cred_db.extra):
+                cred_db.ovr_pm_id = 0
+                await cred_db.save()
+            credex_db, _ = await models.CredEx.update_or_create(exid=cdx.exid, cred=cred_db, ex=self.actor.ex)
+        except IntegrityError as e:
+            raise e
+        return credex_db
+
+    # 25: Список реквизитов моих платежных методов
+    async def load_creds(self) -> list[models.CredEx]:
+        credexs_epyd: list[BaseCredEx] = await self.get_creds()
+        credexs: list[models.CredEx] = [await self.credex_save(f) for f in credexs_epyd]
+        return credexs
+
+    async def my_ad_save(
+        self,
+        bmad: BaseAd | BaseCredexsExidsTrait,
+        rname: str = None,
+    ) -> models.MyAd:
+        ad_db = await self.ex_client.ad_save(bmad)
+        mad_db, _ = await models.MyAd.update_or_create(ad=ad_db)
+        credexs = await models.CredEx.filter(ex_id=self.actor.ex_id, exid__in=bmad.credex_exids)
+        await mad_db.credexs.clear()
+        await mad_db.credexs.add(*credexs)
+        return mad_db
+
+    async def load_my_ads(self, only_active: bool = None) -> list[models.MyAd]:  # upserted)
+        ads = await self.get_my_ads(True)
+        if not only_active:
+            ads += await self.get_my_ads(False)
+        return [await self.my_ad_save(ad) for ad in ads]
+
+    @abstractmethod
+    async def _get_order_full(self, order_exid: int) -> BaseOrderFull: ...
+
+    async def get_order_full(self, order_exid: int) -> xtype.BaseOrder:
+        eorder: BaseOrderFull = await self._get_order_full(order_exid)
+        _, cur_scale, __ = await self.ex_client.x2e_cur(await self.ex_client.e2x_cur(eorder.curex_exid))
+        _, coin_scale = await self.ex_client.x2e_coin(await self.ex_client.e2x_coin(eorder.coinex_exid))
+        ad = await self.ex_client.e2x_ad(eorder.ad_id)
+        credex = await self.e2x_cred(eorder.credex)
+        taker = await self.ex_client.e2x_actor(eorder.taker)
+        border = eorder.model_dump()
+        border.update(
+            ad_id=ad.id,
+            cred_id=credex.cred_id,
+            taker_id=taker.id,
+            amount=int(eorder.amount * 10**cur_scale),
+            quantity=int(eorder.quantity * 10**coin_scale),
+        )
+        return xtype.BaseOrder.model_validate(border)
+
+    async def load_order(self, order_exid: int, force_refresh: bool = False) -> tuple[models.Order, xtype.BaseOrder]:
+        if not self.orders.get(order_exid) or force_refresh:
+            order: xtype.BaseOrder = await self.get_order_full(order_exid)
+            if not (
+                order_db := await models.Order.get_or_none(
+                    exid=order_exid, ad__maker__ex=self.actor.ex
+                ).prefetch_related("ad__pair_side__pair", "cred__pmcur__cur")
+            ):
+                order_db = await self.order_save(order)
+            self.orders[order_exid] = order_db, order
+        return self.orders[order_exid]
+
+    async def order_save(self, order: xtype.BaseOrder) -> models.Order:
+        order_in = models.Order.validate(order.model_dump())
+        odb, _ = await models.Order.update_or_create(**order_in.df_unq())
+        # await odb.fetch_related("ad")  # todo: for what?
+        return odb
+
     async def racing(self, race: models.Race):
         pair = race.road.ad.pair_side.pair
         taker_side: int = not race.road.ad.pair_side.is_sell
@@ -116,7 +244,7 @@ class BaseAgentClient(HttpClient, BaseInAgentClient):
                 asset = await models.Asset.get(addr__actor=self.actor, addr__coin_id=coinex.coin_id)
                 volume = asset.free * 10**-coinex.scale
             volume = str(round(volume, coinex.scale))
-            get_ads_req = GetAds(
+            get_ads_req = GetAdsReq(
                 coin_id=pair.coin_id, cur_id=pair.cur_id, is_sell=bool(taker_side), pm_ids=pm_ids, amount=amt, limit=50
             )
             try:
@@ -363,10 +491,6 @@ class BaseAgentClient(HttpClient, BaseInAgentClient):
         self, exid: int | str, cur: str, detail: str, name: str, fid: int, typ: str, extra=None
     ) -> fiat_pyd: ...
 
-    # 25: Список реквизитов моих платежных методов
-    @abstractmethod
-    async def creds(self) -> list[CredExOut]: ...  # {credex.exid: {cred}}
-
     # Создание реквизита на бирже
     async def cred_new(self, cred: models.Cred) -> models.CredEx: ...
 
@@ -387,16 +511,16 @@ class BaseAgentClient(HttpClient, BaseInAgentClient):
     # # # Ad
     # 29: Список моих объявлений
     @abstractmethod
-    async def my_ads(self, status: AdStatus = None) -> list[BaseAd]: ...
+    async def get_my_ads(self, status: bool = None) -> list[BaseAd | BaseCredexsExidsTrait]: ...
 
     @abstractmethod
-    async def x2e_req_ad_upd(self, xreq: AdUpd) -> BaseAdUpdate: ...
+    async def x2e_req_ad_upd(self, xreq: AdUpdReq) -> BaseAd: ...
 
     # 30: Создание объявления
     @abstractmethod
     async def ad_new(self, ad: BaseAd) -> Ad: ...
 
-    async def ad_upd(self, xreq: AdUpd) -> Ad:
+    async def ad_upd(self, xreq: AdUpdReq) -> Ad:
         xreq.credexs = await models.CredEx.filter(
             ex_id=self.actor.ex_id,
             cred__pmcur__pm_id__in=xreq.pm_ids,
@@ -409,7 +533,7 @@ class BaseAgentClient(HttpClient, BaseInAgentClient):
 
     # 31: Редактирование объявления
     @abstractmethod
-    async def _ad_upd(self, ad: BaseAdUpdate) -> Ad: ...
+    async def _ad_upd(self, ad: BaseAd) -> Ad: ...
 
     # 32: Удаление
     @abstractmethod