xync-client 0.0.57.dev20__tar.gz → 0.0.57.dev22__tar.gz

{xync_client-0.0.57.dev20/xync_client.egg-info → xync_client-0.0.57.dev22}/PKG-INFO

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

@@ -261,13 +261,13 @@ class BaseExClient(HttpClient):
         }
         prs: tuple[dict, dict] = await self.pairs()
         for is_sell in (0, 1):
-            dirs: list[models.Direction] = []
+            pss: list[models.PairSide] = []
             for cur, coinz in prs[is_sell].items():
                 for coin in coinz:
                     pair, _ = await models.Pair.get_or_create(coin=coins[coin], cur=curs[cur])
-                    pairex, _ = await models.PairEx.get_or_create(pair=pair, ex=self.ex)
-                    dirs += [models.Direction(sell=is_sell, pairex=pairex)]
-            await models.Direction.bulk_create(dirs, ignore_conflicts=True)
+                    # pairex, _ = await models.PairEx.get_or_create(pair=pair, ex=self.ex)  # todo: разные ли комишки на покупку и продажу?
+                    pss += [models.PairSide(is_sell=is_sell, pair=pair)]
+            await models.PairSide.bulk_create(pss, ignore_conflicts=True)
 
     # Сохранение чужого объявления (с Pm-ами) в бд
     async def ad_pydin2db(self, ad_pydin: BaseAdIn) -> models.Ad:

{xync_client-0.0.57.dev20 → xync_client-0.0.57.dev22}/xync_client/Bybit/agent.py

@@ -19,7 +19,7 @@ from x_model import init_db
 from xync_schema import models
 from xync_schema.enums import OrderStatus
 
-from xync_schema.models import Actor, Cond, Direction, CondSim, Pmcur
+from xync_schema.models import Actor, Cond, CondSim, Pmcur, PairSide
 
 from xync_client.Abc.Agent import BaseAgentClient
 from xync_client.Abc.xtype import BaseOrderReq, FlatDict
@@ -395,8 +395,8 @@ class AgentClient(BaseAgentClient):  # Bybit client
                 size=30,
                 # status=status,  # 50 - завершено
                 # tokenId=token_id,
-                # beginTime=begin_time,
-                # endTime=end_time,
+                beginTime=begin_time,
+                endTime=end_time,
                 # side=side,  # 1 - продажа, 0 - покупка
             )
         except FailedRequestError as e:
@@ -443,12 +443,14 @@ class AgentClient(BaseAgentClient):  # Bybit client
                             pmcur=pmcur, person=seller_person, detail=ecredex.accountNo
                         )
                     ):
-                        extr = (
-                            ecredex.bankName
-                            or ecredex.branchName
-                            or ecredex.qrcode
-                            or ecredex.payMessage
-                            or ecredex.paymentExt1
+                        extr = ", ".join(
+                            [
+                                ecredex.bankName,
+                                ecredex.branchName,
+                                ecredex.qrcode,
+                                ecredex.payMessage,
+                                ecredex.paymentExt1,
+                            ]
                         )
                         crd = await models.Cred.create(
                             detail=ecredex.accountNo,
@@ -542,17 +544,17 @@ class AgentClient(BaseAgentClient):  # Bybit client
         self,
         coinex: models.Coinex,
         curex: models.Curex,
-        is_sell: bool,
+        taker_side: bool,
         pms: list[str],
         ceil: float,
         volume: float = None,
         place: int = 0,
     ):
-        k = (-1) ** int(is_sell)  # on_buy=1, on_sell=-1
+        k = (-1) ** int(taker_side)  # on_buy=1, on_sell=-1
 
         creds: dict[models.Pmex, models.CredEx] = await self.get_credexs_by_norms(pms, curex.cur_id)
         if not volume:
-            if is_sell:  # гонка в стакане продажи - мы покупаем монету за ФИАТ
+            if taker_side:  # гонка в стакане продажи - мы покупаем монету за ФИАТ
                 # todo: we using the only one fiat exactly from THE FIRST cred
                 fiat = await models.Fiat.get(cred_id=list(creds.values())[0].cred_id)
                 volume = fiat.amount / ceil
@@ -565,14 +567,14 @@ class AgentClient(BaseAgentClient):  # Bybit client
         credex_ids = [str(p.exid) for p in creds.values()]
 
         while self.actor.person.user.status > 0:
-            ads: list[Ad] = await self.ads(coinex, curex, is_sell, list(creds.keys()))
+            ads: list[Ad] = await self.ads(coinex, curex, taker_side, list(creds.keys()))
             self.overprice_filter(ads, ceil, k)
             if not ads:
-                print(coinex.exid, curex.exid, is_sell, "no ads!")
+                print(coinex.exid, curex.exid, taker_side, "no ads!")
                 await sleep(15)
                 continue
             if not (cur_plc := [i for i, ad in enumerate(ads) if int(ad.userId) == self.actor.exid]):
-                logging.warning(f"No racing in {'-' if is_sell else '+'}{coinex.exid}/{curex.exid}")
+                logging.warning(f"No racing in {'-' if taker_side else '+'}{coinex.exid}/{curex.exid}")
                 await sleep(15)
                 continue
             (cur_plc,) = cur_plc
@@ -583,13 +585,13 @@ class AgentClient(BaseAgentClient):  # Bybit client
             cad = self.get_cad(ads, ceil, k, place, cur_plc)
             new_price = f"%.{curex.cur.scale}f" % round(float(cad.price) - k * step(mad, cad), curex.cur.scale)
             if mad.price == new_price:  # Если нужная цена и так уже стоит
-                print(end="v" if is_sell else "^", flush=True)
+                print(end="v" if taker_side else "^", flush=True)
                 await sleep(3)
                 continue
             if cad.priceType:  # Если цена конкурента плавающая, то повышаем себе не цену, а %
                 new_premium = str(round(float(cad.premium) - k * step(mad, cad), 2))
                 if mad.premium == new_premium:  # Если нужный % и так уже стоит
-                    print(end="v" if is_sell else "^", flush=True)
+                    print(end="v" if taker_side else "^", flush=True)
                     await sleep(3)
                     continue
                 mad.premium = new_premium
@@ -599,14 +601,14 @@ class AgentClient(BaseAgentClient):  # Bybit client
             req = AdUpdateRequest.model_validate({**mad.model_dump(), "price": new_price, "paymentIds": credex_ids})
             try:
                 _res = self.ad_upd(req)
-                print("-" if is_sell else "+", end=req.price, flush=True)
+                print("-" if taker_side else "+", end=req.price, flush=True)
             except FailedRequestError as e:
                 if ExcCode(e.status_code) == ExcCode.FixPriceLimit:
                     if limits := re.search(
                         r"The fixed price set is lower than ([0-9]+\.?[0-9]{0,2}) or higher than ([0-9]+\.?[0-9]{0,2})",
                         e.message,
                     ):
-                        req.price = limits.group(1 if is_sell else 2)
+                        req.price = limits.group(1 if taker_side else 2)
                         if req.price != mad.price:
                             _res = self.ad_upd(req)
                     else:
@@ -629,20 +631,20 @@ class AgentClient(BaseAgentClient):  # Bybit client
         self,
         coinex: models.Coinex,
         curex: models.Curex,
-        is_sell: bool,
+        taker_side: bool,
         pms: list[str] = None,
         ceil: float = None,
         volume: float = 9000,
         min_fiat: int = None,
         max_fiat: int = None,
     ):
-        k = (-1) ** int(is_sell)  # on_buy=1, on_sell=-1
+        k = (-1) ** int(taker_side)  # on_buy=1, on_sell=-1
 
         if pms:
             creds: dict[models.Pmex, models.CredEx] = await self.get_credexs_by_norms(pms, curex.cur_id)
             [str(p.exid) for p in creds.values()]
 
-            if is_sell:  # гонка в стакане продажи - мы покупаем монету за ФИАТ
+            if taker_side:  # гонка в стакане продажи - мы покупаем монету за ФИАТ
                 fiats = await models.Fiat.filter(
                     cred_id__in=[cx.cred_id for cx in creds.values()], amount__not=F("target")
                 )
@@ -651,17 +653,16 @@ class AgentClient(BaseAgentClient):  # Bybit client
                 asset = await models.Asset.get(addr__actor=self.actor, addr__coin_id=coinex.coin_id)
                 volume = min(volume, asset.free - (asset.freeze or 0) - (asset.lock or 0))
         volume = str(round(volume, coinex.coin.scale))
-        dr = await Direction.get(
-            pairex__ex=self.ex_client.ex,
-            pairex__pair__coin_id=coinex.coin_id,
-            pairex__pair__cur_id=curex.cur_id,
-            sell=is_sell,
+        ps = await PairSide.get(
+            is_sell=taker_side,
+            pair__coin_id=coinex.coin_id,
+            pair__cur_id=curex.cur_id,
         )
         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()))
+            ads: list[Ad] = await self.ads(coinex, curex, taker_side, pms and list(creds.keys()))
 
             if not ads:
-                print(coinex.exid, curex.exid, is_sell, "no ads!")
+                print(coinex.exid, curex.exid, taker_side, "no ads!")
                 await sleep(300)
                 continue
 
@@ -669,11 +670,11 @@ class AgentClient(BaseAgentClient):  # Bybit client
                 if (ceil - float(ad.price)) * k < 0:
                     break
                 if int(ad.userId) == self.actor.exid:
-                    logging.info(f"My ad {'-' if is_sell else '+'}{coinex.exid}/{curex.exid} on place#{i}")
+                    logging.info(f"My ad {'-' if taker_side else '+'}{coinex.exid}/{curex.exid} on place#{i}")
                     continue
-                ad_db, isnew = await self.cond_upsert(ad, dr=dr)
+                ad_db, isnew = await self.cond_upsert(ad, ps=ps)
                 if isnew:
-                    s = f"{'-' if is_sell else '+'}{ad.price}[{ad.minAmount}-{ad.maxAmount}]{coinex.exid}/{curex.exid}"
+                    s = f"{'-' if taker_side else '+'}{ad.price}[{ad.minAmount}-{ad.maxAmount}]{coinex.exid}/{curex.exid}"
                     print(s, end=" | ", flush=True)
                 elif not isnew and ad_db and ad_db.cond.raw_txt != clean(ad.remark):
                     # ad_db.cond.parsed = False
@@ -694,20 +695,16 @@ class AgentClient(BaseAgentClient):  # Bybit client
             await sleep(6)
 
     async def cond_upsert(
-        self, ad: Ad, rname: str = None, dr: Direction = None, force: bool = False
+        self, ad: Ad, rname: str = None, ps: PairSide = None, force: bool = False
     ) -> tuple[models.Ad, bool]:
         sim, cid = None, None
+        ad_db = await models.Ad.get_or_none(exid=ad.id, ex=self.ex_client.ex).prefetch_related("cond")
         # если точно такое условие уже есть в бд, ниче делать не надо
         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).prefetch_related("maker__person")
-                    or await self.ad_create(ad, cid, rname, dr),
-                    False,
-                )
-            return None, False
+            return (ad_db or force and await self.ad_create(ad, cid, rname, ps)), False
         # если эта объява уже есть в бд
-        if ad_db := await models.Ad.get_or_none(exid=ad.id).prefetch_related("cond__ads__maker", "maker__person"):
+        if ad_db:
+            await ad_db.fetch_related("cond__ads", "maker")
             # у измененного условия этой объявы есть другие объявы?
             if rest_ads := set(ad_db.cond.ads) - {ad_db}:
                 # другие объявы этого условия принадлежат другим юзерам
@@ -768,7 +765,7 @@ class AgentClient(BaseAgentClient):  # Bybit client
             return actor.person
         return await models.Person.create(name=name)
 
-    async def ad_create(self, ad: Ad, cid: int, rname: str = None, dr: Direction = None) -> models.Ad:
+    async def ad_create(self, ad: Ad, cid: int, rname: str = None, ps: PairSide = None) -> models.Ad:
         act_df = {}
         if int(ad.userId) != self.actor.exid:
             act_df |= {"name": ad.nickName}
@@ -782,16 +779,16 @@ class AgentClient(BaseAgentClient):  # Bybit client
             max_fiat=ad.maxAmount,
             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.currencyId,
+            pair_side=ps
+            or await PairSide.get(
+                is_sell=ad.side,
+                pair__coin__ticker=ad.tokenId,
+                pair__cur__ticker=ad.currencyId,
             ),
+            ex=self.ex_client.ex,
             maker=actor,
         )
-        await ad_db.fetch_related("cond", "maker__person")
+        await ad_db.pms.add(*(await models.Pm.filter(pmexs__ex=self.ex_client.ex, pmexs__exid__in=ad.payments)))
         return ad_db
 
     async def sim_new(self, new_cid: int, sim: int, old_cid: int):
@@ -814,15 +811,9 @@ class AgentClient(BaseAgentClient):  # Bybit client
         self.cond_sims = {cs.cond_id: (cs.cond_rel_id, cs.similarity) for cs in await CondSim.all()}
         for c, (o, s) in self.cond_sims.items():
             self.sim_conds[o].add(c)
-        dr = await Direction.get(
-            sell=1,
-            pairex__ex=self.ex_client.ex,
-            pairex__pair__coin__ticker="USDT",
-            pairex__pair__cur__ticker="RUB",
-        )
         for ad_db in await models.Ad.filter(direction__pairex__ex=self.ex_client.ex).prefetch_related("cond", "maker"):
             ad = Ad(id=str(ad_db.exid), userId=str(ad_db.maker.exid), remark=ad_db.cond.raw_txt)
-            await self.cond_upsert(ad, dr=dr, cid=ad_db.cond_id)
+            await self.cond_upsert(ad, force=True)
 
     async def get_credexs_by_norms(self, norms: list[str], cur_id: int) -> dict[models.Pmex, models.CredEx] | None:
         try:
@@ -901,32 +892,29 @@ async def main():
         cl: AgentClient = actor.client(b)
         # await cl.ex_client.set_pmcurexs(cookies=actor.agent.auth["cookies"])  # 617 -> 639
         # await cl.set_creds()
+        # await cl.ex_client.set_pairs()
         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.actual_cond()
         await gather(
-            cl.battle(usdt, rub, False, ["volet"], 79.97),  # гонка в стакане покупки - мы продаем
-            cl.battle(usdt, rub, True, ["volet"], 79.9),  # гонка в стакане продажи - мы покупаем
+            cl.battle(usdt, rub, False, ["volet"], 79.8),  # гонка в стакане покупки - мы продаем
+            cl.battle(usdt, rub, True, ["volet"], 79.8),  # гонка в стакане продажи - мы покупаем
             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),
-            cl.get_api_orders(67),
+            cl.take(usdt, rub, False, ceil=80, volume=360),
+            cl.take(usdt, rub, True, ceil=80, volume=360),
+            # cl.get_api_orders(), # 10, 1738357200000, 1742504399999
         )
 
         bor = BaseOrderReq(

{xync_client-0.0.57.dev20 → xync_client-0.0.57.dev22/xync_client.egg-info}/PKG-INFO

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