xync-client 0.0.160__tar.gz → 0.0.173__tar.gz

{xync_client-0.0.160/xync_client.egg-info → xync_client-0.0.173}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xync-client
-Version: 0.0.160
+Version: 0.0.173
 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.160 → xync_client-0.0.173}/README.md

@@ -1,3 +1,23 @@
+## Структура http-клиентов
+#### Абстрактные классы клиентов:
+**BaseClient** *[host: str]* - базовый http-клиент, с низкоуровнеными методами get, post, put и delete, сессией, и общими 
+для всех клиентов свойствами. *[В конструкторе принимает хост строкой]*
+
+**BaseExClient**(BaseClient) *[ex: Ex]* - клиент с публичными/анонимными методами конкретной биржи.
+*[В конструкторе принимает зависимость: экземпляр биржи]*
+
+**_BaseAuthClient**(BaseClient) *[agent: Agent]* - клиент реализующий логин (получение необходимых заголовков) конкретного
+юзера биржи. *[В конструкторе принимает зависимость: экземпляр агента]*
+
+**BaseInAgentTrait** - класс реализующий прием входящих событий от биржи. Если у биржи есть вебсокет канал, то по нему,
+если нет - то через поллинг каждые х секунд.
+
+**BaseAgentClient**(BaseAuthClient, BaseInAgentTrait) *[agent: Agent, ex_client: BaseExClient]* - клиент с приватными
+методами биржи от лица конкретного юзера биржи. *[В конструкторе принимает зависимости: экземпляр агента, и клиента биржи]*
+
+**BaseOrderClient** *[order: Order, agent_client: BaseExClient]* - методы для обработки конкретного ордера на бирже.
+*[В конструкторе принимает зависимости: экземпляр ордера, и клиента агента]*
+
 ## Order Flow:
 - 0: Получшение заявок за заданное время, в статусе, по валюте, монете, направлению: `get_orders(stauts=OrderStatus.active, coin='USDT', cur='RUB', is_sell=False) => [order]`
 

{xync_client-0.0.160 → xync_client-0.0.173}/tests/TestAgent.py

@@ -9,7 +9,7 @@ from xync_schema.xtype import BaseAd
 from xync_client.Abc.BaseTest import BaseTest
 from xync_client.Abc.Ex import BaseExClient
 from xync_client.Abc.Agent import BaseAgentClient
-from xync_client.Abc.xtype import CredExOut, BaseOrderReq, ListOfDicts
+from xync_client.Abc.xtype import BaseCredEx, BaseOrderReq, ListOfDicts
 
 
 @pytest.mark.asyncio(loop_scope="session")
@@ -44,8 +44,8 @@ class TestAgent(BaseTest):
     # 25
     async def test_my_creds(self, clients: list[tuple[BaseAgentClient, BaseAgentClient]]):
         for maker, taker in clients:
-            my_creds: list[CredExOut] = await taker.creds()
-            ok = self.is_list_of_objects(my_creds, CredExOut)
+            my_creds: list[BaseCredEx] = await taker.get_creds()
+            ok = self.is_list_of_objects(my_creds, BaseCredEx)
             t, _ = await ExStat.update_or_create({"ok": ok}, ex=taker.actor.ex, action=ExAction.my_creds)
             assert t.ok, "No my creds"
             logging.info(f"{taker.actor.ex.name}:{ExAction.my_creds.name} - ok")
@@ -53,7 +53,7 @@ class TestAgent(BaseTest):
     # 27
     async def test_cred_upd(self, clients: list[tuple[BaseAgentClient, BaseAgentClient]]):
         for maker, taker in clients:
-            credex = (await taker.creds())[0]
+            credex = (await taker.get_creds())[0]
             credex_db = await CredEx.get(exid=credex.id, ex=taker.actor.ex).prefetch_related("cred")
             credex_db.cred.name += "+Test!"
             cred_upd: CredEx = await taker.cred_upd(credex_db.cred, credex.id)
@@ -65,7 +65,7 @@ class TestAgent(BaseTest):
     # 28
     async def test_cred_del(self, clients: list[tuple[BaseAgentClient, BaseAgentClient]]):
         for maker, taker in clients:
-            credex = (await taker.creds())[0]
+            credex = (await taker.get_creds())[0]
             cred_del: int = await taker.cred_del(credex.id)
             ok = cred_del == credex.id
             t, _ = await ExStat.update_or_create({"ok": ok}, ex=taker.actor.ex, action=ExAction.cred_del)
@@ -111,7 +111,7 @@ class TestAgent(BaseTest):
             req = BaseOrderReq(
                 ad_id=ad.exid,
                 is_sell=ad.direction.sell,
-                fiat_amount=ad.min_fiat,
+                amount=ad.min_fiat,
                 cred_id=mutual_cred.id,
             )
             order_request: dict | bool = await taker.order_request(req)
@@ -123,7 +123,7 @@ class TestAgent(BaseTest):
     # 29
     async def test_my_ads(self, clients: list[tuple[BaseAgentClient, BaseAgentClient]]):
         for maker, taker in clients:
-            my_ads: list[BaseAd] = await maker.my_ads()
+            my_ads: list[BaseAd] = await maker.get_my_ads()
             ok = self.is_list_of_objects(my_ads, BaseAd)
             t, _ = await ExStat.update_or_create({"ok": ok}, ex=taker.actor.ex, action=ExAction.my_ads)
             assert t.ok, "Maker should has ads"
@@ -148,7 +148,7 @@ class TestAgent(BaseTest):
     # 31
     async def test_ad_upd(self, clients: list[tuple[BaseAgentClient, BaseAgentClient]]):
         for maker, taker in clients:
-            my_ads: ListOfDicts = await taker.my_ads()
+            my_ads: ListOfDicts = await taker.get_my_ads()
             ad_upd: Ad.pyd() = await taker.ad_upd(offer_id=my_ads[0]["id"], amount="11")
             ok = ad_upd["status"] == "SUCCESS"
             t, _ = await ExStat.update_or_create({"ok": ok}, ex=taker.actor.ex.name, action=ExAction.ad_upd)
@@ -158,7 +158,7 @@ class TestAgent(BaseTest):
     # 32
     async def test_ad_del(self, clients: list[tuple[BaseAgentClient, BaseAgentClient]]):
         for maker, taker in clients:
-            my_ads: ListOfDicts = await taker.my_ads()
+            my_ads: ListOfDicts = await taker.get_my_ads()
             ad_del: bool = await taker.ad_del(ad_id=my_ads[0]["id"])
             t, _ = await ExStat.update_or_create({"ok": ad_del}, ex=taker.actor.ex, action=ExAction.ad_del)
             assert t.ok, "No add new ad"
@@ -167,7 +167,7 @@ class TestAgent(BaseTest):
     # 33
     async def test_ad_switch(self, clients: list[tuple[BaseAgentClient, BaseAgentClient]]):
         for maker, taker in clients:
-            my_ads: ListOfDicts = await taker.my_ads()
+            my_ads: ListOfDicts = await taker.get_my_ads()
             new_status = not (my_ads[0]["status"] == "ACTIVE")
             ad_switch: bool = await taker.ad_switch(offer_id=my_ads[0]["id"], active=new_status)
             t, _ = await ExStat.update_or_create({"ok": ad_switch}, ex=taker.actor.ex, action=ExAction.ad_switch)

xync_client-0.0.173/tests/TestOrder.py

@@ -0,0 +1,24 @@
+import pytest
+from xync_client.Abc.Order import BaseOrderClient
+from xync_schema.models import Agent, Ex
+
+from xync_client.Abc.Agent import BaseAgentClient
+
+from xync_client.Abc.BaseTest import BaseTest
+
+
+class AgentTest(BaseTest):
+    @pytest.fixture(scope="class")
+    async def cl(self) -> BaseAgentClient:
+        agent = await Agent.filter(auth__not_isnull=True, status__gt=0).prefetch_related("actor__ex").first()
+        ex: Ex = agent.actor.ex
+        acl: BaseAgentClient = agent.client(ex.client())
+        yield acl
+        await acl.close()
+
+    @pytest.fixture(scope="class")
+    async def cl1(self) -> BaseOrderClient:
+        agent = (await self.exq).agents.filter(auth__not_isnull=True).offset(1).first()
+        acl = BaseOrderClient(agent)
+        yield acl
+        await acl.close()

{xync_client-0.0.160 → xync_client-0.0.173}/xync_client/Abc/Agent.py

@@ -6,6 +6,7 @@ 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
@@ -15,25 +16,36 @@ 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,
@@ -59,15 +71,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 +105,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 +252,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 +499,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 +519,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 +541,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