xync-client 0.0.155__py3-none-any.whl → 0.0.156.dev18__py3-none-any.whl

xync_client/Abc/Agent.py

@@ -1,15 +1,15 @@
+import logging
 from abc import abstractmethod
-from asyncio.tasks import gather
+from asyncio import create_task, sleep
 from collections import defaultdict
+from typing import Literal
 
-from playwright.async_api import async_playwright
 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.PmAgent import PmAgentClient
-from xync_schema.enums import UserStatus
 
 from xync_client.Abc.InAgent import BaseInAgentClient
 
@@ -19,7 +19,7 @@ from xync_schema.models import OrderStatus, Coin, Cur, Ad, AdStatus, Actor, Agen
 from xync_schema.xtype import BaseAd
 
 from xync_client.Abc.Ex import BaseExClient
-from xync_client.Abc.xtype import CredExOut, BaseOrderReq, BaseAdUpdate, AdUpd
+from xync_client.Abc.xtype import CredExOut, BaseOrderReq, BaseAdUpdate, AdUpd, GetAds
 from xync_client.Gmail import GmClient
 
 
@@ -30,15 +30,20 @@ class BaseAgentClient(HttpClient, BaseInAgentClient):
     fbot: FileClient
     ex_client: BaseExClient
     pm_clients: dict[int, PmAgentClient]  # {pm_id: PmAgentClient}
+    api: HttpClient
+    cred_x2e: dict[int, int] = {}
+    cred_e2x: dict[int, int] = {}
 
     def __init__(
         self,
-        agent: Agent,
+        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
@@ -47,34 +52,282 @@ class BaseAgentClient(HttpClient, BaseInAgentClient):
         self.gmail = agent.actor.person.user.gmail and GmClient(agent.actor.person.user)
         self.ex_client: BaseExClient = ex_client
         self.pm_clients: dict[int, PmAgentClient] = defaultdict()
-        super().__init__(self.actor.ex.host_p2p, headers, cookies)
-
-    async def start(self, debug: bool = False):
-        tasks = []
-        if not self.is_started:
-            if self.agent.status & 1:  # race
-                tasks.append(self.start_race())
-
-            if self.agent.status & 2:  # in agent
-                if not self.pm_clients:
-                    pm_agents = await models.PmAgent.filter(
-                        active=True,
-                        auth__isnull=False,
-                        user__status=UserStatus.ACTIVE,
-                    ).prefetch_related("pm", "user__gmail")
-                    # payeer_cl = Client(actor.person.user.username_id)
-                    pw = await async_playwright().start()
-                    browser = await pw.chromium.launch(
-                        channel="chrome-beta" if debug else "chromium-headless-shell", headless=not debug
-                    )
-                    self.pm_clients = {pma.pm_id: pma.client(browser, self.bbot) for pma in pm_agents}
-                    [tasks.append(pmcl.start()) for pmcl in self.pm_clients.values()]
-                # tasks.append(self.start_listen())
-
-            if self.agent.status & 4:  # for further
-                ...
-            self.is_started = True
-        return await gather(*tasks)
+        super().__init__(self.actor.ex.host_p2p, headers, cookies, proxy)  #  and proxy.str()
+        # start
+        create_task(self.start())
+
+    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
+        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 start(self):
+        if self.agent.status & 1:  # щас пока юзаем статус чисто как бул актив
+            for race in await models.Race.filter(started=True, road__ad__maker_id=self.agent.actor_id).prefetch_related(
+                "road__ad__pair_side__pair__cur", "road__credexs__cred"
+            ):
+                create_task(self.racing(race))
+
+    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
+        # конвертим наши параметры гонки в ex-овые для конкретной биржи текущего агента
+        coinex: models.CoinEx = await models.CoinEx.get(coin_id=pair.coin_id, ex=self.actor.ex).prefetch_related("coin")
+        curex: models.CurEx = await models.CurEx.get(cur_id=pair.cur_id, ex=self.actor.ex).prefetch_related("cur")
+        creds = [c.cred for c in race.road.credexs]
+        pm_ids = [pm.id for pm in race.road.ad.pms]
+        pmexs: list[models.PmEx] = [pmex for pm in race.road.ad.pms for pmex in pm.pmexs if pmex.ex_id == 4]
+        post_pm_ids = {c.cred.ovr_pm_id for c in race.road.credexs if c.cred.ovr_pm_id}
+        post_pmexs = set(await models.PmEx.filter(pm_id__in=post_pm_ids, ex=self.actor.ex).prefetch_related("pm"))
+
+        k = (-1) ** taker_side  # on_buy=1, on_sell=-1
+        sleep_sec = 3  # 1 if set(pms) & {"volet"} and coinex.coin_id == 1 else 5
+        _lstat, volume = None, 0
+
+        # погнали цикл гонки
+        while self.actor.person.user.status > 0:  # todo: separate agents, not whole user.activity
+            # подгружаем из бд обновления по текущей гонке
+            await race.refresh_from_db()
+            if not race.started:  # пока выключена
+                await sleep(5)
+                continue
+
+            # конверт бд int фильтровочной суммы в float конкретной биржи
+            amt = race.filter_amount * 10**-curex.cur.scale if race.filter_amount else None
+            ceils = await self.get_ceils(coinex, curex, pmexs, 0.003, 0, amt, post_pmexs)
+            race.ceil = int(ceils[taker_side] * 10**curex.scale)
+            await race.save()
+
+            last_vol = volume
+            if taker_side:  # гонка в стакане продажи - мы покупаем монету за ФИАТ
+                fiat = max(await models.Fiat.filter(cred_id__in=[c.id for c in creds]), key=lambda x: x.amount)
+                volume = (fiat.amount * 10**-curex.cur.scale) / (race.road.ad.price * 10**-curex.scale)
+            else:  # гонка в стакане покупки - мы продаем МОНЕТУ за фиат
+                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(
+                coin_id=pair.coin_id, cur_id=pair.cur_id, is_sell=bool(taker_side), pm_ids=pm_ids, amount=amt, limit=50
+            )
+            try:
+                ads: list[Ad] = await self.ex_client.ads(get_ads_req)
+            except Exception:
+                await sleep(1)
+                ads: list[Ad] = await self.ads(coinex, curex, taker_side, pmexs, amt, 50, race.vm_filter, post_pmexs)
+
+            self.overprice_filter(ads, race.ceil * 10**-curex.scale, k)  # обрезаем сверху все ads дороже нашего потолка
+
+            if not ads:
+                print(coinex.exid, curex.exid, taker_side, "no ads!")
+                await sleep(15)
+                continue
+            # определяем наше текущее место в уже обрезанном списке ads
+            if not (cur_plc := [i for i, ad in enumerate(ads) if int(ad.userId) == self.actor.exid]):
+                logging.warning(f"No racing in {pmexs[0].name} {'-' if taker_side else '+'}{coinex.exid}/{curex.exid}")
+                await sleep(15)
+                continue
+            (cur_plc,) = cur_plc  # может упасть если в списке > 1 наш ad
+            [(await self.ex_client.cond_load(ad, race.road.ad.pair_side, True))[0] for ad in ads[:cur_plc]]
+            # rivals = [
+            #     (await models.RaceStat.update_or_create({"place": plc, "price": ad.price, "premium": ad.premium}, ad=ad))[
+            #         0
+            #     ]
+            #     for plc, ad in enumerate(rads)
+            # ]
+            mad: Ad = ads.pop(cur_plc)
+            # if (
+            #     not (lstat := lstat or await race.stats.order_by("-created_at").first())
+            #     or lstat.place != cur_plc
+            #     or lstat.price != float(mad.price)
+            #     or set(rivals) != set(await lstat.rivals)
+            # ):
+            #     lstat = await models.RaceStat.create(race=race, place=cur_plc, price=mad.price, premium=mad.premium)
+            #     await lstat.rivals.add(*rivals)
+            if not ads:
+                await sleep(60)
+                continue
+            if not (cad := self.get_cad(ads, race.ceil * 10**-curex.scale, k, race.target_place, cur_plc)):
+                continue
+            new_price = round(float(cad.price) - k * step(mad, cad, curex.scale), curex.scale)
+            if (
+                float(mad.price) == new_price and volume == last_vol
+            ):  # Если место уже нужное или нужная цена и так уже стоит
+                print(
+                    f"{'v' if taker_side else '^'}{mad.price}",
+                    end=f"[{race.ceil * 10**-curex.scale}+{cur_plc}] ",
+                    flush=True,
+                )
+                await sleep(sleep_sec)
+                continue
+            if cad.priceType:  # Если цена конкурента плавающая, то повышаем себе не цену, а %
+                new_premium = (float(mad.premium) or float(cad.premium)) - k * step(mad, cad, 2)
+                # if float(mad.premium) == new_premium:  # Если нужный % и так уже стоит
+                #     if mad.priceType and cur_plc != race.target_place:
+                #         new_premium -= k * step(mad, cad, 2)
+                #     elif volume == last_vol:
+                #         print(end="v" if taker_side else "^", flush=True)
+                #         await sleep(sleep_sec)
+                #         continue
+                mad.premium = str(round(new_premium, 2))
+            mad.priceType = cad.priceType
+            mad.quantity = volume
+            mad.maxAmount = str(2_000_000 if curex.cur_id == 1 else 40_000)
+            # req = AdUpdateRequest.model_validate(
+            #     {
+            #         **mad.model_dump(),
+            #         "price": str(round(new_price, curex.scale)),
+            #         "paymentIds": [str(cx.exid) for cx in race.road.credexs],
+            #     }
+            # )
+            # try:
+            #     print(
+            #         f"c{race.ceil * 10**-curex.scale}+{cur_plc} {coinex.coin.ticker}{'-' if taker_side else '+'}{req.price}{curex.cur.ticker}"
+            #         f"{[pm.norm for pm in race.road.ad.pms]}{f'({req.premium}%)' if req.premium != '0' else ''} "
+            #         f"t{race.target_place} ;",
+            #         flush=True,
+            #     )
+            #     _res = self.ad_upd(req)
+            # except FailedRequestError as e:
+            #     if ExcCode(e.status_code) == ExcCode.FixPriceLimit:
+            #         if limits := re.search(
+            #             r"The fixed price set is lower than ([0-9]+\.?[0-9]{0,2}) or higher than ([0-9]+\.?[0-9]{0,2})",
+            #             e.message,
+            #         ):
+            #             req.price = limits.group(1 if taker_side else 2)
+            #             if req.price != mad.price:
+            #                 _res = self.ad_upd(req)
+            #         else:
+            #             raise e
+            #     elif ExcCode(e.status_code) == ExcCode.InsufficientBalance:
+            #         asset = await models.Asset.get(addr__actor=self.actor, addr__coin_id=coinex.coin_id)
+            #         req.quantity = str(round(asset.free * 10**-coinex.scale, coinex.scale))
+            #         _res = self.ad_upd(req)
+            #     elif ExcCode(e.status_code) == ExcCode.RareLimit:
+            #         if not (
+            #             sads := [
+            #                 ma
+            #                 for ma in self.my_ads(False)
+            #                 if (
+            #                     ma.currencyId == curex.exid
+            #                     and ma.tokenId == coinex.exid
+            #                     and taker_side != ma.side
+            #                     and set(ma.payments) == set([pe.exid for pe in pmexs])
+            #                 )
+            #             ]
+            #         ):
+            #             logging.error(f"Need reserve Ad {'sell' if taker_side else 'buy'} {coinex.exid}/{curex.exid}")
+            #             await sleep(90)
+            #             continue
+            #         self.ad_del(ad_id=int(mad.id))
+            #         req.id = sads[0].id
+            #         req.actionType = "ACTIVE"
+            #         self.api.update_ad(**req.model_dump())
+            #         logging.warning(f"Ad#{mad.id} recreated")
+            #     # elif ExcCode(e.status_code) == ExcCode.Timestamp:
+            #     #     await sleep(3)
+            #     else:
+            #         raise e
+            # except (ReadTimeoutError, ConnectionDoesNotExistError):
+            #     logging.warning("Connection failed. Restarting..")
+            await sleep(6)
+
+    async def get_books(
+        self,
+        coinex: models.CoinEx,
+        curex: models.CurEx,
+        pmexs: list[models.PmEx],
+        amount: int,
+        post_pmexs: list[models.PmEx] = None,
+    ) -> tuple[list[Ad], list[Ad]]:
+        buy: list[Ad] = await self.ads(coinex, curex, False, pmexs, amount, 40, False, post_pmexs)
+        sell: list[Ad] = await self.ads(coinex, curex, True, pmexs, amount, 30, False, post_pmexs)
+        return buy, sell
+
+    async def get_spread(
+        self, bb: list[Ad], sb: list[Ad], perc: float, place: int = 0
+    ) -> tuple[tuple[float, float], float, int] | None:
+        if len(bb) and len(sb):
+            buy_price, sell_price = float(bb[place].price), float(sb[place].price)
+            half_spread = (buy_price - sell_price) / (buy_price + sell_price)
+            if half_spread * 2 < perc:
+                return await self.get_spread(bb, sb, perc, place)
+            return (buy_price, sell_price), half_spread, place
+        return None
+
+    async def get_ceils(
+        self,
+        coinex: models.CoinEx,
+        curex: models.CurEx,
+        pmexs: list[models.PmEx],
+        min_prof=0.02,
+        place: int = 0,
+        amount: int = None,
+        post_pmexs: set[models.PmEx] = None,
+    ) -> tuple[float, float]:  # todo: refact to Pairex
+        for pmc_id in {pmx.pm_id for pmx in pmexs} | set(self.pm_clients.keys()):
+            if ceils := self.pm_clients[pmc_id].get_ceils():
+                return ceils
+        bb, sb = await self.get_books(coinex, curex, pmexs, amount, post_pmexs)
+        perc = list(post_pmexs or pmexs)[0].pm.fee * 0.0001 + min_prof
+        (bf, sf), _hp, _zplace = await self.get_spread(bb, sb, perc, place)
+        mdl = (bf + sf) / 2  # middle price
+        bc, sc = mdl + mdl * (perc / 2), mdl - mdl * (perc / 2)
+        return bc, sc
+
+    async def mad_upd(self, mad: Ad, attrs: dict, cxids: list[str]):
+        if not [setattr(mad, k, v) for k, v in attrs.items() if getattr(mad, k) != v]:
+            print(end="v" if mad.side else "^", flush=True)
+            return await sleep(5)
+        # req = AdUpdateRequest.model_validate({**mad.model_dump(), "paymentIds": cxids})
+        # try:
+        #     return self.ad_upd(req)
+        # except FailedRequestError as e:
+        #     if ExcCode(e.status_code) == ExcCode.FixPriceLimit:
+        #         if limits := re.search(
+        #             r"The fixed price set is lower than ([0-9]+\.?[0-9]{0,2}) or higher than ([0-9]+\.?[0-9]{0,2})",
+        #             e.message,
+        #         ):
+        #             return await self.mad_upd(mad, {"price": limits.group(1 if mad.side else 2)}, cxids)
+        #     elif ExcCode(e.status_code) == ExcCode.RareLimit:
+        #         await sleep(180)
+        #     else:
+        #         raise e
+        # except (ReadTimeoutError, ConnectionDoesNotExistError):
+        #     logging.warning("Connection failed. Restarting..")
+        # print("-" if mad.side else "+", end=req.price, flush=True)
+        await sleep(60)
+
+    def overprice_filter(self, ads: list[Ad], ceil: float, k: Literal[-1, 1]):
+        # вырезаем ads с ценами выше потолка
+        if ads and (ceil - float(ads[0].price)) * k > 0:
+            if int(ads[0].userId) != self.actor.exid:
+                ads.pop(0)
+                self.overprice_filter(ads, ceil, k)
+
+    def get_cad(self, ads: list[Ad], ceil: float, k: Literal[-1, 1], target_place: int, cur_plc: int) -> Ad:
+        if not ads:
+            return None
+        # чью цену будем обгонять, предыдущей или слещующей объявы?
+        # cad: Ad = ads[place] if cur_plc > place else ads[cur_plc]
+        # переделал пока на жесткую установку целевого места, даже если текущее выше:
+        if len(ads) <= target_place:
+            logging.error(f"target place {target_place} not found in ads {len(ads)}-lenght list")
+            target_place = len(ads) - 1
+        cad: Ad = ads[target_place]
+        # а цена обгоняемой объявы не выше нашего потолка?
+        if (float(cad.price) - ceil) * k <= 0:
+            # тогда берем следующую
+            ads.pop(target_place)
+            cad = self.get_cad(ads, ceil, k, target_place, cur_plc)
+        # todo: добавить фильтр по лимитам min-max
+        return cad
 
     # 0: Получшение ордеров в статусе status, по монете coin, в валюте coin, в направлении is_sell: bool
     @abstractmethod
@@ -133,31 +386,23 @@ class BaseAgentClient(HttpClient, BaseInAgentClient):
     @abstractmethod
     async def my_ads(self, status: AdStatus = None) -> list[BaseAd]: ...
 
+    @abstractmethod
+    async def x2e_req_ad_upd(self, xreq: AdUpd) -> BaseAdUpdate: ...
+
     # 30: Создание объявления
     @abstractmethod
     async def ad_new(self, ad: BaseAd) -> Ad: ...
 
-    async def ad_upd(self, ad_upd_req: AdUpd) -> Ad:
-        pmex_exids = await models.PmEx.filter(ex_id=self.actor.ex_id, pm_id__in=ad_upd_req.pm_ids).values_list(
-            "exid", flat=True
-        )
-        credexs = await models.CredEx.filter(
+    async def ad_upd(self, xreq: AdUpd) -> Ad:
+        xreq.credexs = await models.CredEx.filter(
             ex_id=self.actor.ex_id,
-            cred__pmcur__pm_id__in=ad_upd_req.pm_ids,
-            cred__pmcur__cur_id=ad_upd_req.cur_id,
+            cred__pmcur__pm_id__in=xreq.pm_ids,
+            cred__pmcur__cur_id=xreq.cur_id,
             cred__person_id=self.actor.person_id,
         ).prefetch_related("cred__pmcur")
-        coinex = await models.CoinEx.get(coin_id=ad_upd_req.coin_id, ex=self.ex_client.ex)
-        curex = await models.CurEx.get(cur_id=ad_upd_req.cur_id, ex=self.ex_client.ex)
-        # override
-        ad_upd_req.coin_id = coinex.exid
-        ad_upd_req.cur_id = curex.exid
-        ad_upd_req.pm_ids = pmex_exids
-        ad_upd_req.credexs = credexs
-        ad_upd_req.price = round(ad_upd_req.price, curex.scale)
-        ad_upd_req.amount = round(ad_upd_req.amount, curex.scale)
-        ad_upd_req.quantity = round(ad_upd_req.amount / ad_upd_req.price, coinex.scale)
-        return await self._ad_upd(ad_upd_req)
+        # xreq.credexs = credexs
+        ereq = await self.x2e_req_ad_upd(xreq)
+        return await self._ad_upd(ereq)
 
     # 31: Редактирование объявления
     @abstractmethod
@@ -214,3 +459,20 @@ class BaseAgentClient(HttpClient, BaseInAgentClient):
     #     if banks:  # only for SBP
     #         await cred_db.banks.add(*[await PmExBank.get(exid=b) for b in banks])
     #     return True
+
+
+def step_is_need(mad, cad) -> bool:
+    # todo: пока не решен непонятный кейс, почему то конкурент по всем параметрам слабже, но в списке ранжируется выше.
+    #  текущая версия: recentExecuteRate округляется до целого, но на бэке байбита его дробная часть больше
+    return (
+        bool(set(cad.authTag) & {"VA2", "BA"})
+        or cad.recentExecuteRate > mad.recentExecuteRate
+        or (
+            cad.recentExecuteRate
+            == mad.recentExecuteRate  # and cad.finishNum > mad.finishNum # пока прибавляем для равных
+        )
+    )
+
+
+def step(mad, cad, scale: int = 2) -> float:
+    return float(int(step_is_need(mad, cad)) * 10**-scale).__round__(scale)