xync-client 0.0.57.dev10__tar.gz → 0.0.57.dev12__tar.gz

{xync_client-0.0.57.dev10/xync_client.egg-info → xync_client-0.0.57.dev12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xync-client
-Version: 0.0.57.dev10
+Version: 0.0.57.dev12
 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.57.dev10 → xync_client-0.0.57.dev12}/xync_client/Abc/Agent.py

@@ -1,6 +1,7 @@
 from abc import abstractmethod
 
 from pydantic import BaseModel
+from pyro_client.client.file import FileClient
 from x_client.aiohttp import Client as HttpClient
 from xync_schema import models
 from xync_schema.models import OrderStatus, Coin, Cur, Ad, AdStatus, Actor
@@ -11,10 +12,10 @@ from xync_client.Abc.xtype import CredExOut, BaseOrderReq, BaseAdUpdate
 
 
 class BaseAgentClient(HttpClient):
-    def __init__(self, actor: Actor, headers: dict[str, str] = None, cookies: dict[str, str] = None):
+    def __init__(self, actor: Actor, bot: FileClient, headers: dict[str, str] = None, cookies: dict[str, str] = None):
         self.actor: Actor = actor
         super().__init__(actor.ex.host_p2p, headers, cookies)
-        self.ex_client: BaseExClient = self.actor.ex.client(actor)
+        self.ex_client: BaseExClient = self.actor.ex.client(bot, actor)
 
     # 0: Получшение ордеров в статусе status, по монете coin, в валюте coin, в направлении is_sell: bool
     @abstractmethod

{xync_client-0.0.57.dev10 → xync_client-0.0.57.dev12}/xync_client/Abc/Ex.py

@@ -234,15 +234,7 @@ class BaseExClient(HttpClient):
                 if not url.startswith("/"):
                     url = "/" + url
                 url = "https://" + self.logo_pre_url + url
-            if not (file := await models.File.get_or_none(name=url)):
-                resp = await ss.get(url)
-                if resp.ok:
-                    byts = await resp.read()
-                    upf, ref = await self.bot.save_doc(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 await self.file_upsert(url, ss)
         return file
 
     # Импорт монет (с Coinex-ами) с биржи в бд
@@ -287,6 +279,18 @@ class BaseExClient(HttpClient):
         await ad_db.pmexs.add(*getattr(ad_pydin, "pmexs_", []))
         return ad_db
 
+    async def file_upsert(self, url: str, ss: ClientSession = None) -> models.File:
+        if not (file := await models.File.get_or_none(name__startswith=url.split("?")[0])):
+            ss = ss or self.session
+            if (resp := await ss.get(url)).ok:
+                byts = await resp.read()
+                upf, ref = await self.bot.save_doc(byts, resp.content_type)
+                await sleep(0.3)
+                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
+
     # async def _proc(self, resp: ClientResponse, data_key: str = None, body: dict | str = None) -> dict | str:
     #     if resp.status in (401, 403):
     #         # proxy = await models.Proxy.filter(valid=True, country__short__not="US").order_by("-updated_at").first()

{xync_client-0.0.57.dev10 → xync_client-0.0.57.dev12}/xync_client/Bybit/agent.py

@@ -11,13 +11,14 @@ import pyotp
 from asyncpg import ConnectionDoesNotExistError
 from bybit_p2p import P2P
 from bybit_p2p._exceptions import FailedRequestError
+from pyro_client.client.file import FileClient
 from tortoise.expressions import F, Q
 from urllib3.exceptions import ReadTimeoutError
 from x_model import init_db
 from xync_schema import models
 from xync_schema.enums import OrderStatus
 
-from xync_schema.models import Cur, Actor, Cond, Direction, CondSim, Person
+from xync_schema.models import Cur, Actor, Cond, Direction, CondSim, Person, Pmcur
 
 from xync_client.Abc.Agent import BaseAgentClient
 from xync_client.Abc.xtype import BaseOrderReq, FlatDict
@@ -33,7 +34,7 @@ from xync_client.Bybit.etype.order import (
     Message,
     Statuses,
 )
-from xync_client.loader import TORM
+from xync_client.loader import TORM, TOKEN
 
 
 class NoMakerException(Exception):
@@ -81,8 +82,8 @@ class AgentClient(BaseAgentClient):  # Bybit client
     cond_sims: dict[int, tuple[int, int]] = {}
     sim_conds: dict[int, set[int]] = defaultdict(set)  # backward
 
-    def __init__(self, actor: Actor, **kwargs):
-        super().__init__(actor, **kwargs)
+    def __init__(self, actor: Actor, bot: FileClient, **kwargs):
+        super().__init__(actor, bot, **kwargs)
         self.api = P2P(testnet=False, api_key=actor.agent.auth["key"], api_secret=actor.agent.auth["sec"])
 
     """ Private METHs"""
@@ -381,56 +382,93 @@ class AgentClient(BaseAgentClient):  # Bybit client
             },
         )
 
-    async def get_api_orders(self, begin_time: int, end_time: int, status: int, side: int, token_id: str):
-        lst = self.api.get_orders(
-            page=1,
-            size=1000,
-            # status=status,  # 50 - завершено
-            # tokenId=token_id,
-            # beginTime=begin_time,
-            # endTime=end_time,
-            # side=side,  # 1 - продажа, 0 - покупка
-        )
-        ords = {o["id"]: OrderItem.model_validate(o) for o in lst}
+    async def get_api_orders(
+        self,
+        page: int = 1,
+        begin_time: int = None,
+        end_time: int = None,
+        status: int = None,
+        side: int = None,
+        token_id: str = None,
+    ):
+        try:
+            lst = self.api.get_orders(
+                page=page,
+                size=30,
+                # status=status,  # 50 - завершено
+                # tokenId=token_id,
+                # beginTime=begin_time,
+                # endTime=end_time,
+                # side=side,  # 1 - продажа, 0 - покупка
+            )
+        except FailedRequestError as e:
+            if e.status_code == 10000:
+                await sleep(1, await self.get_api_orders(page, begin_time, end_time, status, side, token_id))
+        ords = {int(o["id"]): OrderItem.model_validate(o) for o in lst["result"]["items"]}
         for oid, o in ords.items():
-            order = OrderFull.model_validate(self.api.get_order_details(orderId=oid))
-            ad = Ad(**self.api.get_ad_details(itemId=o.itemId))
-            if not (
-                ad_db := await models.Ad.get_or_none(
-                    exid=o.itemId, direction__pairex__ex=self.ex_client.ex
-                ).prefetch_related("pmex")
-            ):
-                dr = await Direction.get(
-                    sell=o["side"],
-                    pairex__ex=self.ex_client.ex,
-                    pairex__pair__coin__ticker=o["tokenId"],
-                    pairex__pair__cur__ticker=o["currencyId"],
-                )
-                ad_db, cond_isnew = await self.cond_upsert(ad, order["targetUserName"], dr)  # todo: fix realname
-
-            models.CredEx.update_or_create({}, exid=order.confirmedPayTerm.paymentType, ex=self.ex_client.ex)
-            models.Order.update_or_create(
+            fo = self.api.get_order_details(orderId=oid)
+            order = OrderFull.model_validate(fo["result"])
+            ad = Ad(**self.api.get_ad_details(itemId=order.itemId)["result"])
+            maker_name = o.buyerRealName, o.sellerRealName  # ad.side
+            im_maker = order.makerUserId == o.userId
+            taker_id = (o.userId, o.targetUserId)[int(im_maker)]
+            taker_nick = (self.actor.name, o.targetNickName)[int(im_maker)]
+            ad_db, cond_isnew = await self.cond_upsert(ad, maker_name[ad.side], force=True)
+            if not ad_db:
+                ...
+            if (cred := order.confirmedPayTerm).paymentType:
+                if not (credex := await models.CredEx.get_or_none(exid=cred.id, ex=self.ex_client.ex)):
+                    pmcur = await Pmcur.get(pm__pmexs__exid=cred.paymentType, cur__ticker=ad.currencyId)
+                    if not (
+                        crd := await models.Cred.get_or_none(
+                            pmcur=pmcur, person=ad_db.maker.person, detail=cred.accountNo
+                        )
+                    ):
+                        extr = cred.bankName or cred.branchName or cred.qrcode or cred.payMessage or cred.paymentExt1
+                        crd = await models.Cred.create(
+                            detail=cred.accountNo,
+                            pmcur=pmcur,
+                            person=ad_db.maker.person,
+                            name=cred.realName,
+                            extra=extr,
+                        )
+                    credex = await models.CredEx.create(exid=cred.id, ex=self.ex_client.ex, cred=crd)
+            taker_person, _ = await Person.get_or_create(name=maker_name[::-1][ad.side])
+            taker, _ = await Actor.get_or_create(
+                {"name": taker_nick}, person=taker_person, ex=self.ex_client.ex, exid=taker_id
+            )
+            order_db, _ = await models.Order.update_or_create(
                 {
                     "amount": o.amount,
                     "status": OrderStatus[Statuses(o.status).name],
-                    "created_at": o.createDate,
-                    "payed_at": order.transferDate,
-                    "confirmed_at": order.updateDate,  # todo: check
-                    "cred": order.confirmedPayTerm,
-                    # "taker": order.updateDate,
+                    "created_at": int(o.createDate[:-3]),
+                    "payed_at": order.transferDate != "0" and int(order.transferDate[:-3]),
+                    "confirmed_at": Statuses(o.status) == Statuses.completed and int(order.updateDate[:-3]),
+                    "appealed_at": o.status == 30 and int(order.updateDate[:-3]),
+                    "cred_id": cred.paymentType and credex.cred_id or None,
+                    "taker": taker,
                 },
                 exid=o.id,
                 ad=ad_db,
             )
-            msgs = [Message.model_validate(m) for m in self.api.get_chat_messages(orderId=oid, size=200)]
-            [
+            dmsgs = self.api.get_chat_messages(orderId=oid, size=200)["result"]["result"][::-1]
+            if ad.remark != dmsgs.pop(0)["message"]:
+                logging.exception(ad.remark)
+            msgs = [Message.model_validate(m) for m in dmsgs if m["msgType"] in (1, 2, 7, 8)]
+            msgs_db = [
                 models.Msg(
+                    order=order_db,
                     read=m.isRead,
-                    txt=m.message,
+                    to_maker=m.userId != order.makerUserId,
+                    **({"txt": m.message} if m.msgType == 1 else {"file": await self.ex_client.file_upsert(m.message)}),
+                    sent_at=int(m.createDate[:-3]),
                 )
                 for m in msgs
             ]
-            models.Msg.bulk_create([models.Msg])
+            _ = await models.Msg.bulk_create(msgs_db, ignore_conflicts=True)
+        logging.info(f"orders page#{page} imported ok!")
+        if len(ords) == 30:
+            await self.get_api_orders(page + 1, begin_time, end_time, status, side, token_id)
 
     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]:
@@ -592,10 +630,6 @@ class AgentClient(BaseAgentClient):  # Bybit client
             pairex__pair__cur_id=curex.cur_id,
             sell=is_sell,
         )
-        self.all_conds = {
-            c.id: (c.raw_txt, {str(a.maker.exid) for a in c.ads})
-            for c in await Cond.all().prefetch_related("ads__maker")
-        }
         while self.actor.person.user.status > 0:  # todo: depends on rest asset/fiat
             ads: list[Ad] = await self.ads(coinex, curex, is_sell, pms and list(creds.keys()))
 
@@ -632,13 +666,17 @@ class AgentClient(BaseAgentClient):  # Bybit client
                     logging.warning("Connection failed. Restarting..")
             await sleep(6)
 
-    async def cond_upsert(self, ad: Ad, rname: str = None, dr: Direction = None) -> tuple[models.Ad, bool]:
-        sim = None
+    async def cond_upsert(
+        self, ad: Ad, rname: str = None, dr: Direction = None, force: bool = False
+    ) -> tuple[models.Ad, bool]:
+        sim, cid = None, None
         # если точно такое условие уже есть в бд, ниче делать не надо
-        if not (cleaned := clean(ad.remark)) or cleaned in {oc[0] for oc in self.all_conds.values()}:
+        if not (cleaned := clean(ad.remark)) or (cid := {oc[0]: ci for ci, oc in self.all_conds.items()}.get(cleaned)):
+            if force:
+                return await models.Ad.get_or_none(exid=ad.id) or await self.ad_create(ad, cid, rname, dr), False
             return None, False
         # если эта объява уже есть в бд
-        if ad_db := await models.Ad.get_or_none(exid=ad.id).prefetch_related("cond__ads__maker", "maker"):
+        if ad_db := await models.Ad.get_or_none(exid=ad.id).prefetch_related("cond__ads__maker", "maker__person"):
             # у измененного условия этой объявы есть другие объявы?
             if rest_ads := set(ad_db.cond.ads) - {ad_db}:
                 # другие объявы этого условия принадлежат другим юзерам
@@ -652,17 +690,15 @@ class AgentClient(BaseAgentClient):  # Bybit client
                     return ad_db, True
             # проверка на всякий что точно нет такого условия
             if new_cond := await Cond.get_or_none(raw_txt=cleaned):
-                logging.exception("!!!!!!!!!", rest_uids)
+                logging.warning(f"Условие {new_cond.id} появилось в бд из других потоков")
+                if rest_ads and rest_uids:
+                    logging.exception("И оно есть объявах других юезров", rest_ads, rest_uids)
             # если других объяв со старым условием этой обявы нет, либо они все этого же юзера
             # обновляем условие (в тч во всех ЕГО объявах)
             ad_db.cond.last_ver = ad_db.cond.raw_txt
             ad_db.cond.raw_txt = cleaned
-            if sim_db := await CondSim.get_or_none(Q(join_type="OR", cond=ad_db.cond, cond_rel=ad_db.cond)):
-                sim_db.similarity = get_sim(cleaned, ad_db.cond.last_ver)
-                await sim_db.save()
             self.all_conds[ad_db.cond_id] = cleaned, {ad_db.maker.exid}
             await ad_db.cond.save()
-
             await self.sim_upd(ad_db.cond_id, cleaned)
             return ad_db, False
 
@@ -687,34 +723,39 @@ class AgentClient(BaseAgentClient):  # Bybit client
 
         new_cond = await Cond.create(raw_txt=cleaned)
         self.all_conds[new_cond.id] = new_cond.raw_txt, {ad.userId}
-        act_df = {"name": ad.nickName}
+        ad_db = await self.ad_create(ad, new_cond.id)
+
+        # если нашелся похожий текст у другого юзера, добавим связь с % похожести
+        if sim:
+            await self.sim_new(new_cond.id, sim, old_cid)
+
+        await ad_db.fetch_related("cond", "maker__person")
+        return ad_db, True
+
+    async def ad_create(self, ad: Ad, cid: int, rname: str = None, dr: Direction = None) -> models.Ad:
+        act_df = {}
+        if int(ad.userId) != self.actor.exid:
+            act_df |= {"name": ad.nickName}
         if rname:
-            act_df |= {"person": await Person.get_or_create(name=rname)}
+            act_df |= {"person": (await Person.get_or_create(name=rname))[0]}
         actor, _ = await Actor.update_or_create(act_df, exid=ad.userId, ex=self.ex_client.ex)
-        ad_db = await models.Ad.create(
+        return await models.Ad.create(
             price=ad.price,
             amount=float(ad.quantity) * float(ad.price),
             min_fiat=ad.minAmount,
             max_fiat=ad.maxAmount,
-            cond=new_cond,
+            cond_id=cid,
             exid=int(ad.id),
             direction=dr
             or await Direction.get(
                 sell=ad.side,
                 pairex__ex=self.ex_client.ex,
                 pairex__pair__coin__ticker=ad.tokenId,
-                pairex__pair__cur__ticker=ad.currency,
+                pairex__pair__cur__ticker=ad.currencyId,
             ),
             maker=actor,
         )
 
-        # если нашелся похожий текст у другого юзера, добавим связь с % похожести
-        if sim:
-            await self.sim_new(new_cond.id, sim, old_cid)
-
-        await ad_db.fetch_related("cond")
-        return ad_db, True
-
     async def sim_new(self, new_cid: int, sim: int, old_cid: int):
         if not sim:
             return None
@@ -727,80 +768,6 @@ class AgentClient(BaseAgentClient):  # Bybit client
             sim_db.similarity = get_sim(new_txt, op_cond.raw_txt)
             await sim_db.save()
 
-    #
-    # async def cond_upsert(
-    #     self, ad: Ad, rname: str = None, dr: Direction = None, cid: int = 0
-    # ) -> tuple[models.Ad, bool]:
-    #     sim = None
-    #     dr = dr or await Direction.get(
-    #         sell=ad.side,
-    #         pairex__ex=self.ex_client.ex,
-    #         pairex__pair__coin__ticker=ad.tokenId,
-    #         pairex__pair__cur__ticker=ad.currencyId,
-    #     )
-    #     # если точно такого условия еще нет в бд
-    #     old_conds = self.all_conds.copy() if cid else self.all_conds
-    #     if cid:  # если есть то это не текущий проверяемый cond
-    #         old_conds.pop(cid)
-    #     if (cleaned := clean(ad.remark)) and cleaned not in {oc[0] for oc in old_conds.values()}:
-    #         # находим все старые тексты похожие на 90% и более
-    #         if sim_connds := {
-    #             old_cid: (txt, sim)
-    #             for old_cid, (txt, uids) in old_conds.items()
-    #             if len(cleaned) > 15
-    #             and ad.userId not in uids
-    #             and cid not in self.sim_conds.get(old_cid, {})
-    #             and (sim := int((SequenceMatcher(None, cleaned, txt).ratio() - 0.9) * 10_000))
-    #             > self.cond_sims.get(cid, (..., 0))[1]
-    #         }:
-    #             # если есть, берем самый похожий из них
-    #             old_cid, (txt, sim) = max(sim_connds.items(), key=lambda x: x[1])
-    #             old_ads = await models.Ad.filter(cond_id=old_cid, maker__exid=int(ad.userId)).prefetch_related("cond")
-    #             for old_ad in old_ads:
-    #                 # и у этого чела есть объява с почти таким же текстом
-    #                 if old_ad.exid == int(ad.id):  # и он изменил текст как раз в ней
-    #                     # заменяем текст без создания нового cond
-    #                     await old_ad.cond.update_or_create(raw_txt=cleaned)
-    #                     await old_ad.fetch_related("cond")
-    #                     return old_ad, False
-    #                 # но это не она, значит у него есть другая объява с похожим, но чуть отличающимся текстом
-    #                 logging.warning(f"ad#{ad.id}-cond#{old_cid} txt updated:\n{txt}\n|\n|\nV\n{cleaned}")
-    #     if not cid:
-    #         cond, isnew = await Cond.get_or_create(raw_txt=cleaned)
-    #         cid = cond.id
-    #         if isnew:
-    #             self.all_conds[cid] = cond.raw_txt, {ad.userId}
-    #     if sim and sim_connds:  # если нашелся похожий текст у другого юзера, добавим связь с % похожести
-    #         await CondSim.update_or_create({"similarity": sim, "cond_rel_id": old_cid}, cond_id=cid)
-    #         self.cond_sims[cid] = old_cid, sim
-    #         self.sim_conds[old_cid].add(cid)
-    #     if not ad.price:
-    #         return
-    #     act_df = {"name": ad.nickName}
-    #     if rname:
-    #         act_df |= {"person": await Person.get_or_create(name=rname)}
-    #     actor, _ = await Actor.update_or_create(act_df, exid=ad.userId, ex=self.ex_client.ex)
-    #     ad_db, _ = await models.Ad.update_or_create(
-    #         {
-    #             "price": ad.price,
-    #             "amount": float(ad.quantity) * float(ad.price),
-    #             "min_fiat": ad.minAmount,
-    #             "max_fiat": ad.maxAmount,
-    #             "cond": cond,
-    #         },
-    #         exid=int(ad.id),
-    #         direction=dr
-    #         or await Direction.get(
-    #             sell=ad.side,
-    #             pairex__ex=self.ex_client.ex,
-    #             pairex__pair__coin__ticker=ad.tokenId,
-    #             pairex__pair__cur__ticker=ad.currency,
-    #         ),
-    #         maker=actor,
-    #     )
-    #     await ad_db.fetch_related("cond")
-    #     return ad_db, isnew
-
     async def actual_cond(self):
         self.all_conds = {
             c.id: (c.raw_txt, {str(a.maker.exid) for a in c.ads})
@@ -883,45 +850,51 @@ async def main():
     actor = (
         await models.Actor.filter(ex_id=9, agent__isnull=False).prefetch_related("ex", "agent", "person__user").first()
     )
-    cl: AgentClient = actor.client()
-    # await cl.ex_client.set_pmcurexs(cookies=actor.agent.auth["cookies"])  # 617 -> 639
-    # await cl.set_creds()
-    usdt = await models.Coinex.get(coin__ticker="USDT", ex=cl.actor.ex).prefetch_related("coin")
-    btc = await models.Coinex.get(coin__ticker="BTC", ex=cl.actor.ex).prefetch_related("coin")
-    eth = await models.Coinex.get(coin__ticker="ETH", ex=cl.actor.ex).prefetch_related("coin")
-    usdc = await models.Coinex.get(coin__ticker="USDC", ex=cl.actor.ex).prefetch_related("coin")
-    rub = await models.Curex.get(cur__ticker="RUB", ex=cl.actor.ex).prefetch_related("cur")
-    # await models.Direction.get(
-    #     pairex__ex=cl.actor.ex, pairex__pair__coin__ticker="USDT", pairex__pair__cur__ticker="RUB", sell=True
-    # )
-    # await cl.set_creds()
-    # await cl.actual_cond()
-    await gather(
-        cl.battle(usdt, rub, False, ["volet"], 79.97),  # гонка в стакане покупки - мы продаем
-        cl.battle(usdt, rub, True, ["volet"], 79.9),  # гонка в стакане продажи - мы покупаем
-        cl.battle(eth, rub, False, ["volet"], 206_000),
-        cl.battle(eth, rub, True, ["volet"], 200_000),
-        cl.battle(btc, rub, False, ["volet"], 8_500_000),
-        cl.battle(btc, rub, True, ["volet"], 8_400_000),
-        cl.battle(usdc, rub, False, ["volet"], 80.5),
-        cl.battle(usdc, rub, True, ["volet"], 79),
-        cl.take(usdt, rub, False, ceil=80.5, volume=360),
-        cl.take(usdt, rub, True, ceil=80.5, volume=360),
-    )
+    async with FileClient(TOKEN) as b:
+        cl: AgentClient = actor.client(b)
+        # await cl.ex_client.set_pmcurexs(cookies=actor.agent.auth["cookies"])  # 617 -> 639
+        # await cl.set_creds()
+        usdt = await models.Coinex.get(coin__ticker="USDT", ex=cl.actor.ex).prefetch_related("coin")
+        btc = await models.Coinex.get(coin__ticker="BTC", ex=cl.actor.ex).prefetch_related("coin")
+        eth = await models.Coinex.get(coin__ticker="ETH", ex=cl.actor.ex).prefetch_related("coin")
+        usdc = await models.Coinex.get(coin__ticker="USDC", ex=cl.actor.ex).prefetch_related("coin")
+        rub = await models.Curex.get(cur__ticker="RUB", ex=cl.actor.ex).prefetch_related("cur")
+        # await models.Direction.get(
+        #     pairex__ex=cl.actor.ex, pairex__pair__coin__ticker="USDT", pairex__pair__cur__ticker="RUB", sell=True
+        # )
+        cl.all_conds = {
+            c.id: (c.raw_txt, {str(a.maker.exid) for a in c.ads})
+            for c in await Cond.all().prefetch_related("ads__maker")
+        }
+        # await cl.set_creds()
+        await cl.get_api_orders(2)
+        # await cl.actual_cond()
+        await gather(
+            cl.battle(usdt, rub, False, ["volet"], 79.97),  # гонка в стакане покупки - мы продаем
+            cl.battle(usdt, rub, True, ["volet"], 79.9),  # гонка в стакане продажи - мы покупаем
+            cl.battle(eth, rub, False, ["volet"], 206_000),
+            cl.battle(eth, rub, True, ["volet"], 200_000),
+            cl.battle(btc, rub, False, ["volet"], 8_500_000),
+            cl.battle(btc, rub, True, ["volet"], 8_400_000),
+            cl.battle(usdc, rub, False, ["volet"], 80.5),
+            cl.battle(usdc, rub, True, ["volet"], 79),
+            cl.take(usdt, rub, False, ceil=80.5, volume=360),
+            cl.take(usdt, rub, True, ceil=80.5, volume=360),
+        )
 
-    bor = BaseOrderReq(
-        ad_id="1861440060199632896",
-        # asset_amount=40,
-        fiat_amount=3000,
-        amount_is_fiat=True,
-        is_sell=False,
-        cur_exid=rub.exid,
-        coin_exid=usdt.exid,
-        coin_scale=usdt.coin.scale,
-    )
-    res: OrderResp = await cl.order_request(bor)
-    await cl.cancel_order(res.orderId)
-    await cl.close()
+        bor = BaseOrderReq(
+            ad_id="1861440060199632896",
+            # asset_amount=40,
+            fiat_amount=3000,
+            amount_is_fiat=True,
+            is_sell=False,
+            cur_exid=rub.exid,
+            coin_exid=usdt.exid,
+            coin_scale=usdt.coin.scale,
+        )
+        res: OrderResp = await cl.order_request(bor)
+        await cl.cancel_order(res.orderId)
+        await cl.close()
 
 
 if __name__ == "__main__":

{xync_client-0.0.57.dev10 → xync_client-0.0.57.dev12}/xync_client/Bybit/etype/order.py

@@ -105,7 +105,7 @@ class PaymentConfigVo(BaseModel):
     addTips: str
     itemTips: str
     online: int
-    items: list[str]
+    items: list[dict[str, str | bool]]
 
 
 class PaymentTerm(BaseModel):
@@ -236,7 +236,7 @@ class OrderFull(OrderItem):
     needSellerExamineCancel: bool
     couponCurrencyAmount: str
     totalCurrencyAmount: str
-    usedCoupon: Literal[1, 2]  # bool: 1: used, 2: no used
+    usedCoupon: bool  # bool: 1: used, 2: no used
     couponTokenId: str
     couponQuantity: str
     completedOrderAppealCount: int
@@ -262,12 +262,12 @@ class Message(BaseModel):
     msgCode: int
     createDate: str
     isRead: Literal[0, 1]  # int: 1: read, 0: unread
-    contentType: Literal["text", "pic", "pdf", "video"]
+    contentType: Literal["str", "pic", "pdf", "video"]
     roleType: str
     userId: str
     orderId: str
     msgUuid: str
     nickName: str
-    read: str
+    read: Literal[0, 1]
     fileName: str
     onlyForCustomer: int

{xync_client-0.0.57.dev10 → xync_client-0.0.57.dev12}/xync_client/Htx/etype/ad.py

@@ -1,7 +1,7 @@
 from typing import Literal
 
 from pydantic import BaseModel
-from xync_schema.types import BaseAd
+from xync_schema.xtype import BaseAd
 
 
 class TradeRule(BaseModel):

{xync_client-0.0.57.dev10 → xync_client-0.0.57.dev12}/xync_client/Htx/ex.py

@@ -4,7 +4,7 @@ from collections import defaultdict
 from msgspec import convert
 from pyro_client.client.file import FileClient
 from x_model import init_db
-from xync_schema import models, types
+from xync_schema import models, xtype
 from xync_schema.models import Ex, Cur
 from xync_schema.enums import PmType
 
@@ -51,7 +51,7 @@ class ExClient(BaseExClient):
 
     async def ads(
         self, coin_exid: int, cur_exid: int, is_sell: bool, pm_exids: list[str] = None, amount: int = None
-    ) -> list[types.BaseAd]:
+    ) -> list[xtype.BaseAd]:
         params = {
             "coinId": coin_exid,
             "currency": cur_exid,
@@ -70,7 +70,7 @@ class ExClient(BaseExClient):
         ads = [ad.Resp(**a) for a in res]
         return ads
 
-    async def ad(self, ad_id: int) -> types.BaseAd:
+    async def ad(self, ad_id: int) -> xtype.BaseAd:
         pass
 
     # 20: Get all pms
@@ -99,7 +99,7 @@ class ExClient(BaseExClient):
         return pmsd
 
     # 21: Get all: currency,pay,allCountry,coin
-    async def curs(self) -> dict[int, types.CurEx]:
+    async def curs(self) -> dict[int, xtype.CurEx]:
         self.session.headers["client-type"] = "web"
         curs: list[dict] = (await self.data)["currency"]
         cmap: dict[str, int] = {c["nameShort"]: c["currencyId"] for c in curs}
@@ -108,7 +108,7 @@ class ExClient(BaseExClient):
         for c in res:
             for q in c["quoteAsset"]:
                 cursd[q["name"]] = max(cursd.get(q["name"], 0), float(q["minAmount"]))
-        return {exid: types.CurEx(exid=exid, ticker=tkr, minimum=cursd.get(tkr)) for tkr, exid in cmap.items()}
+        return {exid: xtype.CurEx(exid=exid, ticker=tkr, minimum=cursd.get(tkr)) for tkr, exid in cmap.items()}
 
     # 22: Список платежных методов по каждой валюте
     async def cur_pms_map(self) -> dict[int, set[int]]:
@@ -117,13 +117,13 @@ class ExClient(BaseExClient):
         return {c["currencyId"]: set(c["supportPayments"]) - wrong_pms for c in res["currency"] if c["supportPayments"]}
 
     # 23: Список торгуемых монет
-    async def coins(self) -> dict[int, types.CoinEx]:
+    async def coins(self) -> dict[int, xtype.CoinEx]:
         self.session.headers["client-type"] = "web"
         coins: list[dict] = (await self.data)["coin"]
         res = (await self._get("/-/x/otc/v1/trade/fast/config/list?side=buy&tradeMode=c2c_simple"))["data"]
         coinsl: list[str] = [c["cryptoAsset"]["name"] for c in res]
         return {
-            c["coinId"]: types.CoinEx(exid=c["coinId"], ticker=c["coinCode"], scale=c["showPrecision"])
+            c["coinId"]: xtype.CoinEx(exid=c["coinId"], ticker=c["coinCode"], scale=c["showPrecision"])
             for c in coins
             if c["coinCode"] in coinsl
         }

{xync_client-0.0.57.dev10 → xync_client-0.0.57.dev12/xync_client.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xync-client
-Version: 0.0.57.dev10
+Version: 0.0.57.dev12
 Author-email: Mike Artemiev <mixartemev@gmail.com>
 Project-URL: Homepage, https://gitlab.com/XyncNet/client
 Project-URL: Repository, https://gitlab.com/XyncNet/client