xync-client 0.0.57.dev9__tar.gz → 0.0.57.dev11__tar.gz

{xync_client-0.0.57.dev9/xync_client.egg-info → xync_client-0.0.57.dev11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xync-client
-Version: 0.0.57.dev9
+Version: 0.0.57.dev11
 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.dev9 → xync_client-0.0.57.dev11}/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.dev9 → xync_client-0.0.57.dev11}/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.dev9 → xync_client-0.0.57.dev11}/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 tortoise.expressions import F
+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,79 @@ 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, 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=1,
+                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(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])
+            if not ad_db:
+                ...
+            cred = order.confirmedPayTerm
+            if not (credex := await models.CredEx.get_or_none(exid=cred.id, ex=self.ex_client.ex)):
+                if not (crd := await models.Cred.get_or_none(pmcur__pm__pmex__exid=cred.paymentType)):
+                    extr = cred.bankName or cred.branchName or cred.qrcode or cred.payMessage or cred.paymentExt1
+                    crd = await models.Cred.create(
+                        detail=cred.accountNo,
+                        pmcur=await Pmcur.get(pm__pmex__exid=cred.paymentType, cur__ticker=ad.currencyId),
+                        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": int(order.transferDate[:-3]),
+                    "confirmed_at": int(order.updateDate[:-3]),  # todo: check
+                    "cred_id": credex.cred_id,
+                    "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)
+            ...
 
     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]:
@@ -634,43 +658,42 @@ class AgentClient(BaseAgentClient):  # Bybit client
 
     async def cond_upsert(self, ad: Ad, rname: str = None, dr: Direction = None) -> tuple[models.Ad, bool]:
         sim = None
-        # если точно такого условия еще нет в бд
+        # если точно такое условие уже есть в бд, ниче делать не надо
         if not (cleaned := clean(ad.remark)) or cleaned in {oc[0] for oc in self.all_conds.values()}:
             return None, False
-        # если такая объява уже есть, просто заменяем текст ее условия
-        if ad_db := await models.Ad.get_or_none(exid=ad.id).prefetch_related("cond__ads__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}:
+                # другие объявы этого условия принадлежат другим юзерам
                 if rest_uids := {ra.maker_id for ra in rest_ads} - {ad_db.maker_id}:
-                    # todo: дописать проверку на измененность этого условия в других ads
-                    logging.exception("у измененного cond этой ad есть другие ads где оно не изменилось", rest_uids)
-            if cond := await Cond.get_or_none(raw_txt=cleaned):
-                if not rest_ads:
-                    self.all_conds.pop(ad_db.cond_id)
-                    await ad_db.cond.delete()
-                ad_db.cond_id = cond.id
-                await ad_db.save()
-            else:
-                if rest_ads and rest_uids:
-                    logging.error(rest_uids)
-                # щас переписывается условие во всех объявах даже если они разных юзеров
-                ad_db.cond.last_ver = ad_db.cond.raw_txt
-                ad_db.cond.raw_txt = cleaned
-                uids = {ra.maker.exid for ra in ad_db.cond.ads}
-                self.all_conds[ad_db.cond_id] = cleaned, uids
-                await ad_db.cond.save()
+                    # создадим новое условие и присвоим его только текущей объяве
+                    new_cond = await Cond.create(raw_txt=cleaned)
+                    await self.sim_new(new_cond.id, get_sim(cleaned, ad_db.cond.raw_txt), ad_db.cond_id)
+                    ad_db.cond_id = new_cond.id
+                    self.all_conds[ad_db.cond_id] = cleaned, {ad_db.maker.exid}
+                    await ad_db.save()
+                    return ad_db, True
+            # проверка на всякий что точно нет такого условия
+            if new_cond := await Cond.get_or_none(raw_txt=cleaned):
+                logging.exception("!!!!!!!!!", rest_uids)
+            # если других объяв со старым условием этой обявы нет, либо они все этого же юзера
+            # обновляем условие (в тч во всех ЕГО объявах)
+            ad_db.cond.last_ver = ad_db.cond.raw_txt
+            ad_db.cond.raw_txt = cleaned
+            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
 
         # находим все старые тексты похожие на 90% и более
-        if sim_connds := {
+        if _sims := {
             old_cid: (txt, sim)
             for old_cid, (txt, uids) in self.all_conds.items()
-            if len(cleaned) > 15
-            and ad.userId not in uids
-            and (sim := int((SequenceMatcher(None, cleaned, txt).ratio() - 0.9) * 10_000)) > 0
+            if len(cleaned) > 15 and ad.userId not in uids and (sim := get_sim(cleaned, txt))
         }:
             # если есть, берем самый похожий из них
-            old_cid, (txt, sim) = max(sim_connds.items(), key=lambda x: x[1])
+            old_cid, (txt, sim) = max(_sims.items(), key=lambda x: x[1][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:
                 # и у этого чела есть объява с почти таким же текстом
@@ -682,37 +705,50 @@ class AgentClient(BaseAgentClient):  # Bybit client
                 # но это не она, значит у него есть другая объява с похожим, но чуть отличающимся текстом
                 logging.warning(f"ad#{ad.id}-cond#{old_cid} txt updated:\n{txt}\n|\n|\nV\n{cleaned}")
 
-        cond = await Cond.create(raw_txt=cleaned)
-        self.all_conds[cond.id] = cond.raw_txt, {ad.userId}
-        act_df = {"name": ad.nickName}
+        new_cond = await Cond.create(raw_txt=cleaned)
+        self.all_conds[new_cond.id] = new_cond.raw_txt, {ad.userId}
+        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(
             price=ad.price,
             amount=float(ad.quantity) * float(ad.price),
             min_fiat=ad.minAmount,
             max_fiat=ad.maxAmount,
-            cond=cond,
+            cond=new_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,
+                pairex__pair__cur__ticker=ad.currencyId,
             ),
             maker=actor,
         )
 
-        if sim and sim_connds:  # если нашелся похожий текст у другого юзера, добавим связь с % похожести
-            await CondSim.update_or_create({"similarity": sim, "cond_rel_id": old_cid}, cond_id=cond.id)
-            self.cond_sims[cond.id] = old_cid, sim
-            self.sim_conds[old_cid].add(cond.id)
+        # если нашелся похожий текст у другого юзера, добавим связь с % похожести
+        if sim:
+            await self.sim_new(new_cond.id, sim, old_cid)
 
-        await ad_db.fetch_related("cond")
+        await ad_db.fetch_related("cond", "maker__person")
         return ad_db, True
 
+    async def sim_new(self, new_cid: int, sim: int, old_cid: int):
+        if not sim:
+            return None
+        return await CondSim.create(cond_id=new_cid, similarity=sim, cond_rel_id=old_cid)
+
+    async def sim_upd(self, cid: int, new_txt: int):
+        for sim_db in (_sims := await CondSim.filter(Q(join_type="OR", cond_id=cid, cond_rel_id=cid))):
+            (op,) = {sim_db.cond_id, sim_db.cond_rel_id} - {cid}
+            op_cond = await Cond[op]
+            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
@@ -806,6 +842,11 @@ class AgentClient(BaseAgentClient):  # Bybit client
             await self.cond_upsert(ad, dr=dr, cid=ad_db.cond_id)
 
 
+def get_sim(s1, s2) -> int:
+    sim = int((SequenceMatcher(None, s1, s2).ratio() - 0.9) * 10_000)
+    return sim if sim > 0 else 0
+
+
 def detailed_diff(str1, str2):
     matcher = SequenceMatcher(None, str1, str2)
     result = []
@@ -864,45 +905,47 @@ 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
+        # )
+        # await cl.set_creds()
+        await cl.get_api_orders()
+        # 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.dev9 → xync_client-0.0.57.dev11}/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.dev9 → xync_client-0.0.57.dev11}/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.dev9 → xync_client-0.0.57.dev11}/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.dev9 → xync_client-0.0.57.dev11/xync_client.egg-info}/PKG-INFO

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