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

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

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

@@ -12,6 +12,7 @@ from asyncpg import ConnectionDoesNotExistError
 from bybit_p2p import P2P
 from bybit_p2p._exceptions import FailedRequestError
 from pyro_client.client.file import FileClient
+from tortoise.exceptions import IntegrityError, MultipleObjectsReturned
 from tortoise.expressions import F, Q
 from urllib3.exceptions import ReadTimeoutError
 from x_model import init_db
@@ -121,41 +122,42 @@ class AgentClient(BaseAgentClient):  # Bybit client
             return data
         return [CredEpyd.model_validate(credex) for credex in data["result"]]
 
-    async def cred_epyd2db(self, cred: CredEpyd) -> models.CredEx:
-        if cred.paymentType not in (416,):
-            if not (
-                pmex := await models.Pmex.get_or_none(exid=cred.paymentType, ex=self.ex_client.ex).prefetch_related(
-                    "pm__curs"
-                )
-            ):
-                raise HTTPException(f"No Pmex {cred.paymentType} on ex#{self.ex_client.ex.name}", 404)
-            if cred_old := await models.Cred.get_or_none(
-                credexs__exid=cred.id, credexs__ex=self.actor.ex
-            ).prefetch_related("pmcur"):
-                cur_id = cred_old.pmcur.cur_id
-            else:  # is new Cred
-                cur_id = (
-                    pmex.pm.df_cur_id
-                    or (pmex.pm.country_id and await pmex.pm.country.cur_id)
-                    or (cred.currencyBalance and await models.Cur.get_or_none(ticker=cred.currencyBalance[0]))
-                    or (0 < len(pmex.pm.curs) < 20 and pmex.pm.curs[-1].id)
-                )
-            if not cur_id:
-                raise Exception(f"Set default cur for {pmex.name}")
-            if not (pmcur := await models.Pmcur.get_or_none(cur_id=cur_id, pm_id=pmex.pm_id)):
-                raise HTTPException(f"No Pmcur with cur#{cred.currencyBalance} and pm#{cred.paymentType}", 404)
-            dct = {
-                "pmcur_id": pmcur.id,
-                "name": cred.paymentConfigVo.paymentName,
-                "person_id": self.actor.person_id,
-                "detail": cred.accountNo,
-                "extra": cred.branchName or cred.bankName,
-            }  # todo: WTD with multicur pms?
-            cred_in = models.Cred.validate(dct, False)
-            cred_db, _ = await models.Cred.update_or_create(**cred_in.df_unq())
-            credex_in = models.CredEx.validate({"exid": cred.id, "cred_id": cred_db.id, "ex_id": self.actor.ex.id})
-            credex_db, _ = await models.CredEx.update_or_create(**credex_in.df_unq())
-            return credex_db
+    async def cred_epyd2db(self, ecdx: CredEpyd, pers_id: int = None, cur_id: int = None) -> models.CredEx | None:
+        if ecdx.paymentType in (416,):
+            return None
+        if not (
+            pmex := await models.Pmex.get_or_none(exid=ecdx.paymentType, ex=self.ex_client.ex).prefetch_related(
+                "pm__curs"
+            )
+        ):
+            raise HTTPException(f"No Pmex {ecdx.paymentType} on ex#{self.ex_client.ex.name}", 404)
+        if cred_old := await models.Cred.get_or_none(credexs__exid=ecdx.id, credexs__ex=self.actor.ex).prefetch_related(
+            "pmcur"
+        ):
+            cur_id = cred_old.pmcur.cur_id
+        elif not cur_id:  # is new Cred
+            cur_id = (
+                pmex.pm.df_cur_id
+                or (pmex.pm.country_id and await pmex.pm.country.cur_id)
+                or (ecdx.currencyBalance and await models.Cur.get_or_none(ticker=ecdx.currencyBalance[0]))
+                or (0 < len(pmex.pm.curs) < 20 and pmex.pm.curs[-1].id)
+            )
+        if not cur_id:
+            raise Exception(f"Set default cur for {pmex.name}")
+        if not (pmcur := await models.Pmcur.get_or_none(cur_id=cur_id, pm_id=pmex.pm_id)):
+            raise HTTPException(f"No Pmcur with cur#{ecdx.currencyBalance} and pm#{ecdx.paymentType}", 404)
+        dct = {
+            "pmcur_id": pmcur.id,
+            "name": ecdx.paymentConfigVo.paymentName,
+            "person_id": pers_id or self.actor.person_id,
+            "detail": ecdx.accountNo,
+            "extra": ecdx.branchName or ecdx.bankName or ecdx.qrcode or ecdx.payMessage or ecdx.paymentExt1,
+        }  # todo: WTD with multicur pms?
+        cred_in = models.Cred.validate(dct, False)
+        cred_db, _ = await models.Cred.update_or_create(**cred_in.df_unq())
+        credex_in = models.CredEx.validate({"exid": ecdx.id, "cred_id": cred_db.id, "ex_id": self.actor.ex.id})
+        credex_db, _ = await models.CredEx.update_or_create(**credex_in.df_unq())
+        return credex_db
 
     # 25: Список реквизитов моих платежных методов
     async def set_creds(self) -> list[models.CredEx]:
@@ -408,35 +410,60 @@ class AgentClient(BaseAgentClient):  # Bybit client
         for oid, o in ords.items():
             fo = self.api.get_order_details(orderId=oid)
             order = OrderFull.model_validate(fo["result"])
+            await sleep(0.5)
             ad = Ad(**self.api.get_ad_details(itemId=order.itemId)["result"])
-            maker_name = o.buyerRealName, o.sellerRealName  # ad.side
+            maker_name = o.buyerRealName, o.sellerRealName
+            seller_person, _ = await Person.get_or_create(name=o.sellerRealName)
             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)
+            ecredex: CredEpyd = order.confirmedPayTerm
+            if ecredex.paymentType:
+                if not (credex := await models.CredEx.get_or_none(exid=ecredex.id, ex=self.ex_client.ex)):
+                    # cur_id = await Cur.get(ticker=ad.currencyId).values_list('id', flat=True)
+                    # await self.cred_epyd2db(ecredex, ad_db.maker.person_id, cur_id)
+                    if (
+                        await Pmcur.filter(
+                            pm__pmexs__ex=self.ex_client.ex,
+                            pm__pmexs__exid=ecredex.paymentType,
+                            cur__ticker=ad.currencyId,
+                        ).count()
+                        != 1
+                    ):
+                        ...
+                    pmcur = await Pmcur.get(
+                        pm__pmexs__ex=self.ex_client.ex, pm__pmexs__exid=ecredex.paymentType, cur__ticker=ad.currencyId
+                    )
                     if not (
                         crd := await models.Cred.get_or_none(
-                            pmcur=pmcur, person=ad_db.maker.person, detail=cred.accountNo
+                            pmcur=pmcur, person=seller_person, detail=ecredex.accountNo
                         )
                     ):
-                        extr = cred.bankName or cred.branchName or cred.qrcode or cred.payMessage or cred.paymentExt1
+                        extr = (
+                            ecredex.bankName
+                            or ecredex.branchName
+                            or ecredex.qrcode
+                            or ecredex.payMessage
+                            or ecredex.paymentExt1
+                        )
                         crd = await models.Cred.create(
-                            detail=cred.accountNo,
+                            detail=ecredex.accountNo,
                             pmcur=pmcur,
                             person=ad_db.maker.person,
-                            name=cred.realName,
+                            name=ecredex.realName,
                             extra=extr,
                         )
-                    credex = await models.CredEx.create(exid=cred.id, ex=self.ex_client.ex, cred=crd)
+                    credex = await models.CredEx.create(exid=ecredex.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
-            )
+            try:
+                taker, _ = await Actor.get_or_create(
+                    {"name": taker_nick, "person": taker_person}, ex=self.ex_client.ex, exid=taker_id
+                )
+            except IntegrityError as e:
+                logging.error(e)
             order_db, _ = await models.Order.update_or_create(
                 {
                     "amount": o.amount,
@@ -445,7 +472,7 @@ class AgentClient(BaseAgentClient):  # Bybit client
                     "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,
+                    "cred_id": ecredex.paymentType and credex.cred_id or None,
                     "taker": taker,
                 },
                 exid=o.id,
@@ -523,7 +550,7 @@ class AgentClient(BaseAgentClient):  # Bybit client
     ):
         k = (-1) ** int(is_sell)  # on_buy=1, on_sell=-1
 
-        creds: dict[models.Pmex, models.CredEx] = await get_creds(pms, self.actor.ex)
+        creds: dict[models.Pmex, models.CredEx] = await self.get_credexs_by_norms(pms, curex.cur_id)
         if not volume:
             if is_sell:  # гонка в стакане продажи - мы покупаем монету за ФИАТ
                 # todo: we using the only one fiat exactly from THE FIRST cred
@@ -612,7 +639,7 @@ class AgentClient(BaseAgentClient):  # Bybit client
         k = (-1) ** int(is_sell)  # on_buy=1, on_sell=-1
 
         if pms:
-            creds: dict[models.Pmex, models.CredEx] = await get_creds(pms, self.actor.ex)
+            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:  # гонка в стакане продажи - мы покупаем монету за ФИАТ
@@ -673,7 +700,11 @@ class AgentClient(BaseAgentClient):  # Bybit client
         # если точно такое условие уже есть в бд, ниче делать не надо
         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 (
+                    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
         # если эта объява уже есть в бд
         if ad_db := await models.Ad.get_or_none(exid=ad.id).prefetch_related("cond__ads__maker", "maker__person"):
@@ -723,14 +754,11 @@ 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}
-        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
+        return await self.ad_create(ad, new_cond.id), True
 
     async def ad_create(self, ad: Ad, cid: int, rname: str = None, dr: Direction = None) -> models.Ad:
         act_df = {}
@@ -739,7 +767,7 @@ class AgentClient(BaseAgentClient):  # Bybit client
         if 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)
-        return await models.Ad.create(
+        ad_db = await models.Ad.create(
             price=ad.price,
             amount=float(ad.quantity) * float(ad.price),
             min_fiat=ad.minAmount,
@@ -755,6 +783,8 @@ class AgentClient(BaseAgentClient):  # Bybit client
             ),
             maker=actor,
         )
+        await ad_db.fetch_related("cond", "maker__person")
+        return ad_db
 
     async def sim_new(self, new_cid: int, sim: int, old_cid: int):
         if not sim:
@@ -786,6 +816,20 @@ class AgentClient(BaseAgentClient):  # Bybit client
             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)
 
+    async def get_credexs_by_norms(self, norms: list[str], cur_id: int) -> dict[models.Pmex, models.CredEx] | None:
+        try:
+            return {
+                await models.Pmex.get(pm__norm=n, ex=self.ex_client.ex): await models.CredEx.get(
+                    ex=self.ex_client.ex,
+                    cred__pmcur__pm__norm=n,
+                    cred__person_id=self.actor.person_id,
+                    cred__pmcur__cur_id=cur_id,
+                )
+                for n in norms
+            }
+        except MultipleObjectsReturned as e:
+            logging.exception(e)
+
 
 def get_sim(s1, s2) -> int:
     sim = int((SequenceMatcher(None, s1, s2).ratio() - 0.9) * 10_000)
@@ -830,18 +874,13 @@ def listen(data: dict):
     print(data)
 
 
-async def get_creds(norms: list[str], ex: models.Ex) -> dict[models.Pmex, models.CredEx]:
-    return {
-        await models.Pmex.get(ex=ex, pm__norm=n): await models.CredEx.get(ex=ex, cred__pmcur__pm__norm=n) for n in norms
-    }
-
-
 class ExcCode(IntEnum):
     FixPriceLimit = 912120022
     RareLimit = 912120050
     InsufficientAmount = 912120024
     Timestamp = 10002
     IP = 10010
+    Quantity = 912300019
 
 
 async def main():
@@ -867,7 +906,6 @@ async def main():
             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),  # гонка в стакане покупки - мы продаем
@@ -880,6 +918,7 @@ async def main():
             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(1),
         )
 
         bor = BaseOrderReq(

{xync_client-0.0.57.dev12 → xync_client-0.0.57.dev14}/xync_client/Bybit/etype/cred.py

@@ -45,7 +45,6 @@ class CredEpyd(CredExOut):
     businessName: str
     concept: str
     online: str
-    countNo: str
     paymentExt1: str
     paymentExt2: str
     paymentExt3: str
@@ -53,8 +52,9 @@ class CredEpyd(CredExOut):
     paymentExt5: str
     paymentExt6: str
     paymentTemplateVersion: int
-    hasPaymentTemplateChanged: bool
-    paymentConfigVo: PaymentConfigVo
-    realNameVerified: bool
-    channel: str
-    currencyBalance: list[str]
+    countNo: str = None  # only for my cred
+    hasPaymentTemplateChanged: bool = None  # only for my cred
+    paymentConfigVo: PaymentConfigVo  # only for my cred
+    realNameVerified: bool = None  # only for my cred
+    channel: str = None  # only for my cred
+    currencyBalance: list[str] = None  # only for my cred

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

@@ -4,6 +4,8 @@ from typing import Literal
 
 from pydantic import BaseModel
 
+from xync_client.Bybit.etype.cred import CredEpyd
+
 
 class Statuses(IntEnum):
     deleted = 40  # order canceled
@@ -183,7 +185,7 @@ class OrderFull(OrderItem):
     payCode: str
     paymentType: int
     transferDate: str
-    paymentTermList: list[PaymentTerm]
+    paymentTermList: list[CredEpyd]
     remark: str
     recentOrderNum: int
     recentExecuteRate: int
@@ -192,8 +194,8 @@ class OrderFull(OrderItem):
     appealNickName: str
     canAppeal: str
     totalAppealTimes: str
-    paymentTermResult: PaymentTerm
-    confirmedPayTerm: PaymentTerm
+    paymentTermResult: CredEpyd
+    confirmedPayTerm: CredEpyd
     appealedTimes: str
     orderFinishMinute: int
     makerFee: str

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

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