xync-client 0.0.235.dev3__tar.gz → 0.0.236.dev1__tar.gz

{xync_client-0.0.235.dev3 → xync_client-0.0.236.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xync-client
-Version: 0.0.235.dev3
+Version: 0.0.236.dev1
 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.235.dev3 → xync_client-0.0.236.dev1}/xync_client/Abc/Agent.py

@@ -1,4 +1,5 @@
 import logging
+import math
 from abc import abstractmethod
 from asyncio import create_task, sleep
 from collections import defaultdict
@@ -8,7 +9,7 @@ from pydantic import BaseModel
 from tortoise.exceptions import IntegrityError
 from x_client import df_hdrs
 from x_client.aiohttp import Client as HttpClient
-from xync_client.details import hot_ad_cond
+from xync_client.details import hot_ad_cond, more1perc
 from xync_schema.enums import AdStatus, OrderStatus
 
 from xync_client.Abc.PmAgent import PmAgentClient
@@ -16,7 +17,7 @@ from xync_client.Abc.PmAgent import PmAgentClient
 from xync_client.Abc.InAgent import BaseInAgentClient
 
 from xync_client.Bybit.etype.order import TakeAdReq
-from xync_schema import models
+from xync_schema import models, xtype
 
 from xync_client.Abc.Ex import BaseExClient
 from xync_client.Abc.xtype import (
@@ -27,7 +28,6 @@ from xync_client.Abc.xtype import (
     GetAdsReq,
     BaseCredexsExidsTrait,
     BaseOrderFull,
-    BaseOrder,
     MyAdXOut,
 )
 
@@ -36,7 +36,7 @@ class BaseAgentClient(HttpClient, BaseInAgentClient):  # , metaclass=ABCMeta
     actor: models.Actor
     agent: models.Agent
     ex_client: BaseExClient
-    orders: dict[int, tuple[models.Order, BaseOrder]] = {}  # 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] = {}
@@ -61,7 +61,7 @@ class BaseAgentClient(HttpClient, BaseInAgentClient):  # , metaclass=ABCMeta
         self.pm_clients: dict[int, PmAgentClient] = defaultdict()
         super().__init__(self.actor.ex.host_p2p, headers, cookies, proxy)  #  and proxy.str()
         # start
-        create_task(self.start())
+        # create_task(self.start())
 
     async def x2e_cred(self, cred_id: int) -> int:  # cred.exid
         if not self.cred_x2e.get(cred_id):
@@ -114,7 +114,7 @@ class BaseAgentClient(HttpClient, BaseInAgentClient):  # , metaclass=ABCMeta
             await self.load_pending_orders()
             await self.ads_share()
 
-    async def load_assets(self, coin_ids: list[int] = None) -> dict:
+    async def load_assets(self, coin_ids: list[int] = None):
         assets = {cid: await self.get_asset(cid) for cid in coin_ids} if coin_ids else await self.my_assets()
         for cid, amount in assets.items():
             await self.asset_save(cid, amount)
@@ -188,7 +188,7 @@ class BaseAgentClient(HttpClient, BaseInAgentClient):  # , metaclass=ABCMeta
     @abstractmethod
     async def _get_order_full(self, order_exid: int) -> BaseOrderFull: ...
 
-    async def get_order_full(self, order_exid: int) -> BaseOrder:
+    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))
@@ -203,11 +203,11 @@ class BaseAgentClient(HttpClient, BaseInAgentClient):  # , metaclass=ABCMeta
             amount=int(eorder.amount * 10**cur_scale),
             quantity=int(eorder.quantity * 10**coin_scale),
         )
-        return BaseOrder.model_validate(border)
+        return xtype.BaseOrder.model_validate(border)
 
-    async def load_order(self, order_exid: int, force_refresh: bool = False) -> tuple[models.Order, BaseOrder]:
+    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: BaseOrder = await self.get_order_full(order_exid)
+            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
@@ -222,7 +222,7 @@ class BaseAgentClient(HttpClient, BaseInAgentClient):  # , metaclass=ABCMeta
             self.orders[order_exid] = order_db, order
         return self.orders[order_exid]
 
-    async def order_save(self, order: BaseOrder) -> models.Order:
+    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())
 
@@ -524,12 +524,62 @@ class BaseAgentClient(HttpClient, BaseInAgentClient):  # , metaclass=ABCMeta
     @abstractmethod
     async def _ad_upd_api(self, ad: MyAdXOut) -> int: ...
 
+    @staticmethod
+    def fee(min_count):
+        return 7.5 * math.exp(-0.1 * min_count) + 1.1
+
+    async def ad_fresh(self, ads: list[models.Ad], is_sell: bool, bal: float, cur_min, rate: float, haq: dict) -> dict:
+        if not ads:
+            return haq
+
+        ad = await ads.pop(0).to_float(ex_id=self.actor.ex_id)
+        if (min_count := int(ad.min_fiat / cur_min)) in {1, 10, 60}:  # is_full
+            i = (list(haq)).index((min_count, int(ad.filtered)))
+        elif 5 <= min_count < 10:
+            i = 2
+        elif 23 <= min_count < 60:
+            i = 3
+        else:
+            logging.error(f"Wrong ad.min_fiat: {ad.exid}:{ad.min_fiat}:{ad.filtered}")  # need debug
+            return await self.ad_fresh(ads, is_sell, bal, cur_min, rate, haq)
+        k, fltrd = list(haq)[i]
+        target_min = cur_min * k
+        # ad.min_fiat = min(target_min, xbal)
+
+        fld = ("amount", "quantity")[
+            int(is_sell)
+        ]  # если покупка - отталкиваемся от имеющегося cur баланса, else - coin
+        old_bal = getattr(ad, fld)
+        setattr(ad, fld, bal)
+        setattr(ad, ("amount", "quantity")[int(not is_sell)], None)  # а связанный (другой) балланс обнуляем
+        xma = MyAdXOut.model_validate(ad, from_attributes=True)
+
+        if k > 1 and xma.amount < target_min / 2:  # хватает ли денег на размещение объявы
+            logging.warning(f"Less balance {bal} for {is_sell} ad:{ad.exid}:{ad.min_fiat}:{ad.filtered}")
+            return await self.ad_fresh(ads, is_sell, bal, cur_min, rate, haq)
+
+        xma.min_fiat = min(target_min, xma.amount)
+        min_count = xma.min_fiat / cur_min
+        pk = self.fee(min_count) if fltrd else 10
+        sk = 2 * int(is_sell) - 1
+        new_price = round(rate * 0.01 * (1 + sk * pk / 200), 2)
+        if xma.price != new_price or more1perc(
+            old_bal, bal
+        ):  # если текущий объем валюты/монеты не совпадает с текущим балансом - обновляем
+            xma.price = new_price
+            xma.cond_txt = hot_ad_cond
+            await self._ad_upd_api(xma)
+            haq[(k, fltrd)][int(is_sell)] += 1
+        else:
+            haq[(k, fltrd)][int(is_sell)] -= 1
+        return await self.ad_fresh(ads, is_sell, bal, cur_min, rate, haq)
+
     async def ads_fresh(self, cur_id: int = 1, coin_id: int = 1):
         """
         Обновляем/добавляем объявления агента, в зависимости от кол-ва объявлений которое он может размещать
         одновременно `same_dir_ad` (от 1 до 4), и его текущего coin_balance.
         """
-        curex = await models.CurEx.get(cur_id=cur_id, ex_id=self.actor.ex_id)
+        curex = await models.CurEx.get(cur_id=cur_id, ex_id=self.actor.ex_id).prefetch_related("cur")
         usdt_bal = (await self.agent.coins_balance())[coin_id]
         xbals = await self.actor.person.user.balances()
         xbal = xbals[cur_id]
@@ -537,10 +587,14 @@ class BaseAgentClient(HttpClient, BaseInAgentClient):  # , metaclass=ABCMeta
         # то постим 4 объявления:
         #    1) с минимальным нижним лимитом размера ордера, и без фильтрации контрагентов
         #    2) с минимальным лимитом, но с фильтрацией контрагентов
-        #    3) с 10x мин лимитом, и с фильтрацией (если вообще есть баланс от 10x min)
-        #    4) 50x мин лимит, либо весь баланс если он меньше, с фильтрацией (если есть баланс от 20x min)
-        if usdt_bal < curex.minimum:
-            return
+        #    3) с 10x мин лимитом, и с фильтрацией (если вообще есть баланс хотя бы от 5x min)
+        #    4) 60x мин лимит, либо весь баланс если он меньше, с фильтрацией (если есть баланс от 30x min)
+        hot_ads_q = {  # item legend: (min_multiplier, is_filtered): [buy_ad_is_posted, sell_ad_is_posted]
+            (1, 0): [0, 0],
+            (1, 1): [0, 0],
+            (10, 1): [0, 0],
+            (60, 1): [0, 0],
+        }
         fltr = dict(
             my_ad__credexs__cred__ovr_pm_id=0,
             my_ad__credexs__cred__pmcur__cur_id=cur_id,
@@ -549,110 +603,30 @@ class BaseAgentClient(HttpClient, BaseInAgentClient):  # , metaclass=ABCMeta
         )
         prftch = "my_ad__credexs", "pair_side__pair__coin", "pair_side__pair__cur"
 
+        if xbal < curex.minimum:
+            logging.error(f"Not enough xync balance: {xbal}")
+            return
+
         bads = (
             await models.Ad.filter(**fltr, status=AdStatus.active, pair_side__is_sell=False)
             .order_by("min_fiat", "filtered")
             .prefetch_related(*prftch)
             .limit(self.agent.same_dir_ad)
         )
-        if not bads:
-            return
-        bad = await bads.pop(0).to_float(ex_id=self.actor.ex_id)
-        if bad.min_fiat != curex.minimum and bad.filtered:
-            logging.error(bad.min_fiat)  # need debug
-        if bad.amount != xbal:
-            bad.amount = xbal
-            bad.quantity = None
-            xma = MyAdXOut.model_validate(bad, from_attributes=True)
-            xma.cond_txt = hot_ad_cond
-            await self._ad_upd_api(xma)
-
-        if not bads:
-            return
-        bad = await bads.pop(0).to_float(ex_id=self.actor.ex_id)
-        if bad.min_fiat != curex.minimum and not bad.filtered:
-            logging.error(bad.min_fiat)  # need debug
-        if bad.amount != xbal:
-            bad.amount = xbal
-            bad.quantity = None
-            xma = MyAdXOut.model_validate(bad, from_attributes=True)
-            xma.cond_txt = hot_ad_cond
-            await self._ad_upd_api(xma)
-
-        if not bads:
-            return
-        bad = await bads.pop(0).to_float(ex_id=self.actor.ex_id)
-        if curex.minimum * 2 <= bad.min_fiat < curex.minimum * 10 or bad.amount != xbal:
-            bad.min_fiat = min(xbal, curex.minimum * 10)
-            bad.amount = xbal
-            bad.quantity = None
-            xma = MyAdXOut.model_validate(bad, from_attributes=True)
-            xma.cond_txt = hot_ad_cond
-            await self._ad_upd_api(xma)
+        await self.ad_fresh(bads, False, xbal, curex.minimum, curex.cur.rate, hot_ads_q)
 
-        if not bads:
+        if usdt_bal * curex.cur.rate * 10**-curex.cur.scale < curex.minimum:
+            logging.error(f"Not enough {self.ex_client.ex.name} balance: {usdt_bal}")
             return
-        bad = await bads.pop(0).to_float(ex_id=self.actor.ex_id)
-        if curex.minimum * 20 <= bad.min_fiat < curex.minimum * 50 or bad.amount != xbal:
-            bad.min_fiat = min(xbal, curex.minimum * 10)
-            bad.amount = xbal
-            bad.quantity = None
-            xma = MyAdXOut.model_validate(bad, from_attributes=True)
-            xma.cond_txt = hot_ad_cond
-            await self._ad_upd_api(xma)
 
-        # sell
         sads = (
-            await models.Ad.filter(**fltr, status=AdStatus.active, pair_side__is_sell=False)
-            .order_by("min_fiat", "filtered")
+            await models.Ad.filter(**fltr, status=AdStatus.active, pair_side__is_sell=True)
+            .order_by("-min_fiat", "-filtered")
             .prefetch_related(*prftch)
             .limit(self.agent.same_dir_ad)
         )
-        if not sads:
-            return
-        sad = await sads.pop(0).to_float(ex_id=self.actor.ex_id)
-        if sad.min_fiat != curex.minimum and sad.filtered:
-            logging.error(sad.min_fiat)  # need debug
-        if sad.quantity != usdt_bal:
-            sad.quantity = usdt_bal
-            sad.amount = None
-            xma = MyAdXOut.model_validate(sad, from_attributes=True)
-            xma.cond_txt = hot_ad_cond
-            await self._ad_upd_api(xma)
-
-        if not sads:
-            return
-        sad = await sads.pop(0).to_float(ex_id=self.actor.ex_id)
-        if sad.min_fiat != curex.minimum and not sad.filtered:
-            logging.error(sad.min_fiat)  # need debug
-        if sad.quantity != usdt_bal:
-            sad.quantity = usdt_bal
-            sad.amount = None
-            xma = MyAdXOut.model_validate(sad, from_attributes=True)
-            xma.cond_txt = hot_ad_cond
-            await self._ad_upd_api(xma)
-
-        if not sads:
-            return
-        sad = await sads.pop(0).to_float(ex_id=self.actor.ex_id)
-        if curex.minimum * 2 <= sad.min_fiat < curex.minimum * 10 or sad.quantity != usdt_bal:
-            sad.min_fiat = min(usdt_bal, curex.minimum * 10)
-            sad.quantity = usdt_bal
-            sad.amount = None
-            xma = MyAdXOut.model_validate(sad, from_attributes=True)
-            xma.cond_txt = hot_ad_cond
-            await self._ad_upd_api(xma)
-
-        if not sads:
-            return
-        sad = await sads.pop(0).to_float(ex_id=self.actor.ex_id)
-        if curex.minimum * 20 <= sad.min_fiat < curex.minimum * 50 or sad.quantity != usdt_bal:
-            sad.min_fiat = min(usdt_bal, curex.minimum * 10)
-            sad.quantity = usdt_bal
-            sad.amount = None
-            xma = MyAdXOut.model_validate(sad, from_attributes=True)
-            xma.cond_txt = hot_ad_cond
-            await self._ad_upd_api(xma)
+        await self.ad_fresh(sads, True, usdt_bal, curex.minimum, curex.cur.rate, hot_ads_q)
+        return hot_ads_q
 
     # 32: Удаление
     @abstractmethod

{xync_client-0.0.235.dev3 → xync_client-0.0.236.dev1}/xync_client/Abc/Ex.py

@@ -4,7 +4,6 @@ from abc import abstractmethod
 from asyncio import sleep
 from collections import defaultdict
 from difflib import SequenceMatcher
-from math import floor
 
 from aiohttp import ClientSession, ClientResponse
 from msgspec import Struct
@@ -187,7 +186,6 @@ class BaseExClient(HttpClient, AdLoader):
             update=dict(
                 coin_id=(await self.x2e_coin(xreq.coin_id))[0],
                 cur_id=(await self.x2e_cur(xreq.cur_id))[0],
-                is_sell=str(int(xreq.is_sell)),
                 pm_ids=xreq.pm_ids and [await self.x2e_pm(pid) for pid in xreq.pm_ids],
             )
         )
@@ -471,12 +469,12 @@ class BaseExClient(HttpClient, AdLoader):
         badd = base_ad.model_dump()
         pms = await models.Pm.filter(pmexs__ex=self.ex, pmexs__exid__in=base_ad.pmex_exids)
         badd.update(
-            amount=int((base_ad.amount or base_ad.quantity * base_ad.price) * 10**cur_scale),
-            max_fiat=int(base_ad.max_fiat),
-            min_fiat=int(base_ad.min_fiat),
-            premium=int(base_ad.premium * 100_00),
-            price=int(base_ad.price * 10**cur_scale),
-            quantity=int((base_ad.quantity or base_ad.amount / base_ad.price) * 10**coin_scale),
+            amount=round((base_ad.amount or base_ad.quantity * base_ad.price) * 10**cur_scale),
+            max_fiat=base_ad.max_fiat,
+            min_fiat=base_ad.min_fiat,
+            premium=round(base_ad.premium * 100_00),
+            price=round(base_ad.price * 10**cur_scale),
+            quantity=round((base_ad.quantity or base_ad.amount / base_ad.price) * 10**coin_scale),
             maker_id=(await self.e2x_actor(base_ad.maker)).id,
             cond_id=cond and cond.id,
             pair_side_id=await self.e2x_pair(base_ad.coinex_exid, base_ad.curex_exid, bool(base_ad.side.value)),
@@ -721,9 +719,25 @@ class BaseExClient(HttpClient, AdLoader):
         bc, sc = mdl + mdl * (perc / 2), mdl - mdl * (perc / 2)
         return bc, sc
 
-    async def rate(self, cur_id: int, coin_id: int = 1) -> int:
-        bp, sp = await self.get_books(cur_id, coin_id)
-        return floor((sum(b.price for b in bp[5:]) + sum(s.price for s in sp[5:])) * 0.1)
+    async def rate(self, cur_id: int, coin_id: int = 1) -> float:
+        if coin_id == 1:
+            ofc = 4 if cur_id in (1, 2, 3) else 1
+        else:
+            ofc = 1 if cur_id in (1, 2, 3) else 0
+
+        bp, sp = await self.get_books(coin_id, cur_id)
+        if bp and sp:
+            return (sum(b.price for b in bp[ofc:]) / len(bp[ofc:]) + sum(s.price for s in sp[ofc:]) / len(bp[ofc:])) / 2
+        return 0
+
+    async def set_rate(self, cur_id: int, coin_id: int = 1):
+        cur = await models.Cur[cur_id]
+        rate = round(await self.rate(cur_id, coin_id), cur.scale)
+        if coin_id == 1:
+            cur.rate = rate * 10**cur.scale
+            await cur.save(update_fields=["rate"])
+        await models.Pair.filter(cur_id=cur_id, coin_id=coin_id).update(rate=rate * 10**cur.scale)
+        logging.warning(f"Set rate {coin_id}/{cur.ticker}: {rate}")
 
     async def init_seed(self, fbot: FileClient):
         await self.set_curs()

{xync_client-0.0.235.dev3 → xync_client-0.0.236.dev1}/xync_client/Abc/xtype.py

@@ -186,7 +186,7 @@ class AmountQuantityMixin:
 
 class MyAdXOut(AmountQuantityMixin, BaseModel):
     id: int
-    amount: float
+    amount: float | None = None
     auto_msg: str | None = None
     coin_id: int = Field(validation_alias=AliasPath("pair_side", "pair", "coin_id"))
     cond_txt: str = Field(None, validation_alias=AliasPath("cond", "raw_txt"))
@@ -216,6 +216,12 @@ class MyAdXOut(AmountQuantityMixin, BaseModel):
             self.maker = None
         return self
 
+    @model_validator(mode="after")
+    def min_amount(self):
+        if self.amount < self.min_fiat:
+            self.min_fiat = int(self.amount)
+        return self
+
 
 class BaseCredexsExidsTrait:
     credex_exids: list[int]

{xync_client-0.0.235.dev3 → xync_client-0.0.236.dev1}/xync_client/Bybit/agent.py

@@ -1,7 +1,7 @@
 import asyncio
 import json
 import logging
-from asyncio import sleep, gather
+from asyncio import sleep
 from datetime import datetime, timedelta, timezone
 from difflib import SequenceMatcher
 from hashlib import sha256
@@ -15,7 +15,6 @@ import websockets
 from aiohttp.http_exceptions import HttpProcessingError, HttpBadRequest
 from bybit_p2p import P2P
 from bybit_p2p._exceptions import FailedRequestError
-from payeer_api import PayeerAPI
 from pybit.unified_trading import HTTP
 from tortoise import Tortoise, get_connection
 from tortoise.timezone import now
@@ -341,6 +340,7 @@ class AgentClient(BaseAgentClient):  # Bybit client
         data = self.api.update_ad(**upd.model_dump(exclude_none=True))
         if data["ret_code"]:
             raise HttpBadRequest(data)
+        logging.info(f"Ad:{req.exid} upd: min:{req.min_fiat}, prc:{req.price}, qty:{req.quantity}, flt:{req.filtered}")
         return not data["ret_code"]
 
     def get_security_token_update(self) -> str:
@@ -1001,7 +1001,7 @@ async def main():
     await Tortoise.init(db_url=PG_DSN, modules={"models": ["x_auth.models", "xync_schema.models"]})
 
     agent = (
-        await models.Agent.filter(actor__ex_id=4, auth__isnull=False, status__gt=AgentStatus.off, id=3)
+        await models.Agent.filter(actor__ex_id=4, auth__isnull=False, status__gt=AgentStatus.off, id=1)
         .prefetch_related(
             "actor__ex",
             "actor__person__user",
@@ -1033,50 +1033,51 @@ async def main():
     # await bot.start()
     # await cl.ex_client.set_pms(bot)
     # await bot.stop()
-    # await cl.load_assets()
-    # mads = await cl.load_my_ads()
-    await cl.ads_fresh(1)
+    await cl.load_assets()
+    await cl.load_my_ads()
+    r = await cl.ads_fresh(1, 1)
+    print(r)
     # await cl.asset_save(1, b)
     # await cl.load_creds()
 
-    await cl.ads_share()
-
-    ms = await models.Agent.filter(
-        actor__ex_id=4, auth__isnull=False, status__gt=AgentStatus.off, actor__person__user__id__in=[3]
-    ).prefetch_related(
-        "actor__ex",
-        "actor__person__user__gmail",
-        "actor__my_ads__my_ad__race",
-        "actor__my_ads__pair_side__pair__cur",
-        "actor__my_ads__pms",
-    )
-    {m.actor.exid: m.client(ecl) for m in ms}
-
-    await gather(
-        # create_task(cl.start()),
-        # create_task(cl.watch_payeer(mcs, abot)),
-    )
-    # ensure_future(cl.start(True))
-    # await cl.boost_acc()
-
-    # создание гонок по мои активным объявам:
-    # for ma in cl.my_ads():
-    #     my_ad = await models.MyAd.get(ad__exid=ma.id).prefetch_related('ad__pms', 'ad__pair_side__pair')
-    #     race, _ = await models.Race.update_or_create(
-    #         {"started": True, "vm_filter": True, "target_place": 5},
-    #         road=my_ad
-    #     )
-
-    # for name in names:
-    #     s, _ = await models.Synonym.update_or_create(typ=SynonymType.name, txt=name)
-    #     await s.curs.add(rub.cur)
-
-    pauth = (await models.PmAgent[1]).auth
-    papi = PayeerAPI(pauth["email"], pauth["api_id"], pauth["api_sec"])
-    hist: dict = papi.history(count=1000)
-    hist |= papi.history(count=1000, append=list(hist.keys())[-1])
-    hist |= papi.history(count=1000, append=list(hist.keys())[-1])
-    cl.hist = hist
+    # await cl.ads_share()
+    #
+    # ms = await models.Agent.filter(
+    #     actor__ex_id=4, auth__isnull=False, status__gt=AgentStatus.off, actor__person__user__id__in=[3]
+    # ).prefetch_related(
+    #     "actor__ex",
+    #     "actor__person__user__gmail",
+    #     "actor__my_ads__my_ad__race",
+    #     "actor__my_ads__pair_side__pair__cur",
+    #     "actor__my_ads__pms",
+    # )
+    # {m.actor.exid: m.client(ecl) for m in ms}
+    #
+    # await gather(
+    #     # create_task(cl.start()),
+    #     # create_task(cl.watch_payeer(mcs, abot)),
+    # )
+    # # ensure_future(cl.start(True))
+    # # await cl.boost_acc()
+    #
+    # # создание гонок по мои активным объявам:
+    # # for ma in cl.my_ads():
+    # #     my_ad = await models.MyAd.get(ad__exid=ma.id).prefetch_related('ad__pms', 'ad__pair_side__pair')
+    # #     race, _ = await models.Race.update_or_create(
+    # #         {"started": True, "vm_filter": True, "target_place": 5},
+    # #         road=my_ad
+    # #     )
+    #
+    # # for name in names:
+    # #     s, _ = await models.Synonym.update_or_create(typ=SynonymType.name, txt=name)
+    # #     await s.curs.add(rub.cur)
+    #
+    # pauth = (await models.PmAgent[1]).auth
+    # papi = PayeerAPI(pauth["email"], pauth["api_id"], pauth["api_sec"])
+    # hist: dict = papi.history(count=1000)
+    # hist |= papi.history(count=1000, append=list(hist.keys())[-1])
+    # hist |= papi.history(count=1000, append=list(hist.keys())[-1])
+    # cl.hist = hist
 
     # cl.completed_orders = await models.Order.filter(status=OrderStatus.completed, transfer__isnull=False).values_list(
     #     "exid", flat=True

{xync_client-0.0.235.dev3 → xync_client-0.0.236.dev1}/xync_client/Bybit/etype/ad.py

@@ -19,13 +19,15 @@ class AdStatusReq(StrEnum):
 
 IntStr = Annotated[str, BeforeValidator(str)]
 Dec2Str = Annotated[str, BeforeValidator(lambda v: f"{round(v, 2):g}")]
+Dec4Str = Annotated[str, BeforeValidator(lambda v: f"{round(v - 0.00049, 4):g}")]
 NoneStr = Annotated[str, BeforeValidator(lambda v: f"{v or ''}")]
+BoolIntStr = Annotated[Literal["0", "1"], BeforeValidator(lambda v: str(int(v)))]
 
 
 class AdsReq(BaseModel):
     tokenId: str = Field(validation_alias="coin_id")
     currencyId: str = Field(validation_alias="cur_id")
-    side: Literal["0", "1"] = Field(validation_alias="is_sell")  # 0 покупка, # 1 продажа
+    side: BoolIntStr = Field(validation_alias="is_sell")  # 0 покупка, # 1 продажа
     payment: list[str] = Field([], validation_alias="pm_ids")  # int
     size: str = Field("20", validation_alias="limit", coerce_numbers_to_str=True)  # int
     page: IntStr = "1"  # int
@@ -120,7 +122,7 @@ class _MyAdEIn(RemapBase):
     remark: NoneStr = Field("", validation_alias=AliasChoices("cond_txt", AliasPath("cond", "raw_txt")))
     tradingPreferenceSet: TradingPreferenceSet = TradingPreferenceSet()
     paymentIds: list[IntStr]
-    quantity: Dec2Str  # float
+    quantity: Dec4Str  # float
     paymentPeriod: int = 15
 
     @model_validator(mode="before")
@@ -140,6 +142,7 @@ class _MyAdEIn(RemapBase):
                 orderFinishNumberDay30=5,
                 registerTimeThreshold=15,
             )
+        # out['quantity'] = f"{round(data.quantity-0.5*10**-data._coin_scale, data._coin_scale):g}"
         return out
 
 
@@ -228,7 +231,12 @@ class Ad(BaseAd, RemapBase):
 
     @model_validator(mode="after")
     def set_filtered_flag(self):
-        self.filtered = bool(self.tradingPreferenceSet.completeRateDay30 or self.tradingPreferenceSet.hasRegisterTime)
+        self.filtered = bool(
+            self.tradingPreferenceSet
+            and self.tradingPreferenceSet.hasCompleteRateDay30
+            and self.tradingPreferenceSet.hasRegisterTime
+            and self.tradingPreferenceSet.hasOrderFinishNumberDay30
+        )
         return self
 
 

{xync_client-0.0.235.dev3 → xync_client-0.0.236.dev1}/xync_client/Bybit/ex.py

@@ -124,6 +124,66 @@ class ExClient(BaseExClient):  # Bybit client
         return ads
 
 
+curs = (
+    1,
+    2,
+    3,
+    4,
+    6,
+    8,
+    9,
+    10,
+    11,
+    12,
+    13,
+    14,
+    15,
+    17,
+    18,
+    19,
+    20,
+    21,
+    22,
+    28,
+    29,
+    30,
+    33,
+    36,
+    37,
+    40,
+    41,
+    43,
+    44,
+    47,
+    50,
+    51,
+    52,
+    56,
+    59,
+    65,
+    66,
+    68,
+    69,
+    73,
+    74,
+    77,
+    78,
+    80,
+    81,
+    82,
+    85,
+    88,
+    91,
+    101,
+    103,
+    107,
+    111,
+    112,
+    113,
+    119,
+)
+
+
 async def main():
     _ = await init_db(TORM, True)
     ex = await Ex.get(name="Bybit")
@@ -131,8 +191,10 @@ async def main():
     # await bot.start()
     prx = PRX and "http://" + PRX
     cl: ExClient = ex.client(proxy=prx)
-    await cl.set_coins(False)
-    await cl.rate(1)
+    # await cl.set_coins(False)
+    for cur in curs:
+        for coin in (1, 2, 3, 4):
+            await cl.set_rate(cur, coin)
     # await cl.set_curs()
     await cl.set_pms(bot)
     await cl.set_pairs()

{xync_client-0.0.235.dev3 → xync_client-0.0.236.dev1}/xync_client/details.py

@@ -27,6 +27,10 @@ hot_ad_cond = "Банков НЕТ! Только XyncPay: ＠ex212 \n --- \n К
 hot_ad_auto_msg = "Банков нет. Только XyncPay. Читайте условия! Отменяйте, если у вас нет XyncPay"
 
 
+def more1perc(a: float, b: float):
+    return abs(a - b) / a > 0.01
+
+
 async def search_messages(phrases_to_find) -> List[Dict[str, str]]:
     _ = await init_db(TORM, True)
     msgs = await models.Msg.all().values("txt")

{xync_client-0.0.235.dev3 → xync_client-0.0.236.dev1}/xync_client.egg-info/PKG-INFO

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