xync-client 0.0.150__tar.gz → 0.0.152__tar.gz

{xync_client-0.0.150/xync_client.egg-info → xync_client-0.0.152}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xync-client
-Version: 0.0.150
+Version: 0.0.152
 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.150 → xync_client-0.0.152}/xync_client/Abc/AdLoader.py

@@ -57,7 +57,6 @@ class AdLoader:
         coinex: models.CoinEx = None,
         curex: models.CurEx = None,
         rname: str = None,
-        pms_from_cond: bool = False,
     ) -> models.Ad:
         if not maker:
             if not (maker := await models.Actor.get_or_none(exid=pad.userId, ex=self.ex)):
@@ -87,13 +86,13 @@ class AdLoader:
             price=int(float(pad.price) * cur_scale),
             premium=int(float(pad.premium) * 100),
             cond_id=cid,
+            status=self.ad_status(ad_upd.status),
         )
         try:
             ad_db, _ = await models.Ad.update_or_create(**df_unq)
         except OperationalError as e:
             raise e
-        if not pms_from_cond:
-            await ad_db.pms.add(*(await models.Pm.filter(pmexs__ex=self.ex, pmexs__exid__in=pad.payments)))
+        await ad_db.pms.add(*(await models.Pm.filter(pmexs__ex=self.ex, pmexs__exid__in=pad.payments)))
         return ad_db
 
     async def cond_load(  # todo: refact from Bybit Ad format to universal
@@ -120,13 +119,7 @@ class AdLoader:
                 # if not len((old_cond := await Cond.get(id=old_cid).prefetch_related('ads')).ads):
                 #     await old_cond.delete()
                 #     logging.warning(f"Cond#{old_cid} deleted!")
-            return (
-                ad_db
-                or force
-                and await self.ad_load(
-                    ad, cid, ps, coinex=coinex, curex=curex, rname=rname, pms_from_cond=pms_from_cond
-                )
-            ), False
+            return (ad_db or force and await self.ad_load(ad, cid, ps, coinex=coinex, curex=curex, rname=rname)), False
         # если эта объява в таким ид уже есть в бд, но с другим условием (или без), а текущего условия еще нет в бд
         if ad_db:
             await ad_db.fetch_related("cond__ads", "maker")
@@ -154,9 +147,7 @@ class AdLoader:
             return ad_db, False
 
         cond = await self.cond_new(cleaned, {int(ad.userId)})
-        ad_db = await self.ad_load(
-            ad, cond.id, ps, coinex=coinex, curex=curex, rname=rname, pms_from_cond=pms_from_cond
-        )
+        ad_db = await self.ad_load(ad, cond.id, ps, coinex=coinex, curex=curex, rname=rname)
         ad_db.cond = cond
         return ad_db, True
 

{xync_client-0.0.150 → xync_client-0.0.152}/xync_client/Abc/Agent.py

@@ -1,10 +1,13 @@
 from abc import abstractmethod
+from asyncio.tasks import gather
 
 from pydantic import BaseModel
 from pyro_client.client.file import FileClient
 from x_client import df_hdrs
 from x_client.aiohttp import Client as HttpClient
 from xync_bot import XyncBot
+from xync_client.Abc.InAgent import BaseInAgentClient
+
 from xync_client.Bybit.etype.order import TakeAdReq
 from xync_schema import models
 from xync_schema.models import OrderStatus, Coin, Cur, Ad, AdStatus, Actor, Agent
@@ -15,13 +18,14 @@ from xync_client.Abc.xtype import CredExOut, BaseOrderReq, BaseAdUpdate
 from xync_client.Gmail import GmClient
 
 
-class BaseAgentClient(HttpClient):
+class BaseAgentClient(HttpClient, BaseInAgentClient):
     bbot: XyncBot
     fbot: FileClient
 
     def __init__(
         self,
         agent: Agent,
+        ex_client: BaseExClient,
         fbot: FileClient,
         bbot: XyncBot,
         headers: dict[str, str] = df_hdrs,
@@ -32,8 +36,20 @@ class BaseAgentClient(HttpClient):
         self.agent: Agent = agent
         self.actor: Actor = agent.actor
         self.gmail = GmClient(agent.actor.person.user)
+        self.ex_client: BaseExClient = ex_client
         super().__init__(self.actor.ex.host_p2p, headers, cookies)
-        self.ex_client: BaseExClient = self.actor.ex.client(fbot)
+
+    async def start(self):
+        tasks = []
+        if not self.is_started:
+            if self.agent.status & 1:  # race
+                tasks.append(self.start_race())
+            if self.agent.status & 2:  # in agent
+                tasks.append(self.start_listen())
+            if self.agent.status & 4:  # for further
+                ...
+            self.is_started = True
+        return await gather(*tasks)
 
     # 0: Получшение ордеров в статусе status, по монете coin, в валюте coin, в направлении is_sell: bool
     @abstractmethod
@@ -134,21 +150,7 @@ class BaseAgentClient(HttpClient):
     async def my_assets(self) -> dict: ...
 
     @abstractmethod
-    async def _take_ad(self, req: TakeAdReq): ...
-
-    async def take_ad(self, req: TakeAdReq):
-        if req.is_sell:
-            fltr = dict(ex_id=self.actor.ex_id, cred__pmcur__pm_id=req.pm_id, cred__person_id=self.actor.person.id)
-            if req.cur_:
-                fltr |= dict(cred__pmcur__cur__ticker=req.cur_)
-            pmexs = await models.CredEx.filter(**fltr)
-        else:
-            pmexs = await models.PmEx.filter(ex_id=self.actor.ex_id, pm_id=req.pm_id)
-            if len(pmexs) > 1:
-                pmexs = [p for p in pmexs if p.name.endswith(f" ({req.cur_})")]
-        req.pm_id = pmexs[0].exid
-        req.quantity = round(req.amount / req.price, 4)  # todo: to get the scale from coinEx
-        return await self._take_ad(req)
+    async def take_ad(self, req: TakeAdReq): ...
 
     # Сохранение объявления (с Pm/Cred-ами) в бд
     # async def ad_pydin2db(self, ad_pydin: AdSaleIn | AdBuyIn) -> Ad:

{xync_client-0.0.150 → xync_client-0.0.152}/xync_client/Abc/Ex.py

@@ -17,6 +17,7 @@ from xync_client.pm_unifier import PmUnifier, PmUni
 
 
 class BaseExClient(HttpClient, AdLoader):
+    host: str = None
     cur_map: dict[int, str] = {}
     unifier_class: type = PmUnifier
     logo_pre_url: str
@@ -34,7 +35,7 @@ class BaseExClient(HttpClient, AdLoader):
     ):
         self.ex = ex
         self.bot = bot
-        super().__init__(getattr(ex, attr), headers, cookies, proxy and proxy.str())
+        super().__init__(self.host or getattr(ex, attr), headers, cookies, proxy and proxy.str())
 
     @abstractmethod
     def pm_type_map(self, typ: models.PmEx) -> str: ...

xync_client-0.0.152/xync_client/Abc/InAgent.py

@@ -0,0 +1,10 @@
+from abc import abstractmethod
+
+
+class BaseInAgentClient:
+    @abstractmethod
+    async def start_listen(self) -> bool: ...
+
+    # 3N: [T] - Уведомление об одобрении запроса на сделку
+    @abstractmethod
+    async def request_accepted_notify(self) -> int: ...  # id

{xync_client-0.0.150 → xync_client-0.0.152}/xync_client/Abc/xtype.py

@@ -53,7 +53,7 @@ class BaseOrderReq(BaseModel):
     asset_amount: float | None = None
     fiat_amount: float | None = None
 
-    pm_id: int = (None,)
+    pmex_exid: str = None  # int
 
     # todo: mv from base to special ex class
     amount_is_fiat: bool = True

{xync_client-0.0.150 → xync_client-0.0.152}/xync_client/Bybit/InAgent.py

@@ -9,6 +9,7 @@ import websockets
 from asyncio import run, sleep
 from decimal import Decimal
 
+from bybit_p2p import P2P
 from playwright.async_api import async_playwright
 from pydantic import ValidationError
 from pyro_client.client.file import FileClient
@@ -16,6 +17,7 @@ from tortoise.exceptions import IntegrityError
 from tortoise.timezone import now
 from tortoise.transactions import in_transaction
 from xync_bot import XyncBot
+from xync_client.Bybit.ex import ExClient
 
 from xync_client.Abc.PmAgent import PmAgentClient
 from xync_schema import models
@@ -32,16 +34,17 @@ from xync_client.Bybit.etype.order import (
 )
 from xync_client.loader import NET_TOKEN, PAY_TOKEN
 from xync_client.Abc.InAgent import BaseInAgentClient
-from xync_client.Bybit.agent import AgentClient
 
 
 class InAgentClient(BaseInAgentClient):
-    agent_client: AgentClient
+    actor: models.Actor
+    api: P2P
+    ex_client: ExClient
 
     async def start_listen(self):
-        t = await self.agent_client.ott()
+        t = await self.ott()
         ts = int(float(t["time_now"]) * 1000)
-        await self.ws_prv(self.agent_client.agent.auth["deviceId"], t["result"], ts)
+        await self.ws_prv(self.actor.agent.auth["deviceId"], t["result"], ts)
 
     # 3N: [T] - Уведомление об одобрении запроса на сделку
     async def request_accepted_notify(self) -> int: ...  # id
@@ -87,11 +90,11 @@ class InAgentClient(BaseInAgentClient):
                                     except ValidationError as e:
                                         logging.error(e)
                                         logging.error(data["data"])
-                                    order = self.agent_client.api.get_order_details(orderId=upd.id)
+                                    order = self.api.get_order_details(orderId=upd.id)
                                     order = OrderFull.model_validate(order["result"])
                                     order_db = await models.Order.get_or_none(
                                         exid=order.id, ad__exid=order.itemId
-                                    ) or await self.agent_client.create_order(order)
+                                    ) or await self.create_order(order)
                                     match upd.status:
                                         case StatusApi.created:
                                             logging.info(f"Order {order.id} created at {order.createDate}")
@@ -136,7 +139,7 @@ class InAgentClient(BaseInAgentClient):
                                                     continue
 
                                                 # если висят незавершенные продажи с такой же суммой
-                                                pos = (await self.agent_client.get_orders_active(1))["result"]
+                                                pos = (await self.get_orders_active(1))["result"]
                                                 pos = [
                                                     o
                                                     for o in pos.get("items", [])
@@ -146,14 +149,14 @@ class InAgentClient(BaseInAgentClient):
                                                         and int(order.createDate)
                                                         < int(o["createDate"]) + 15 * 60 * 1000
                                                         # get full_order from o, and cred or pm from full_order:
-                                                        and self.agent_client.api.get_order_details(orderId=o["id"])[
-                                                            "result"
-                                                        ]["paymentTermList"][0]["accountNo"]
+                                                        and self.api.get_order_details(orderId=o["id"])["result"][
+                                                            "paymentTermList"
+                                                        ][0]["accountNo"]
                                                         == order.paymentTermList[0].accountNo
                                                     )
                                                 ]
                                                 curex = await models.CurEx.get(
-                                                    cur__ticker=order.currencyId, ex=self.agent_client.ex_client.ex
+                                                    cur__ticker=order.currencyId, ex=self.ex_client.ex
                                                 )
                                                 pos_db = await models.Order.filter(
                                                     exid__not=order.id,
@@ -163,16 +166,16 @@ class InAgentClient(BaseInAgentClient):
                                                     created_at__gt=now() - timedelta(minutes=15),
                                                 )
                                                 if pos or pos_db:
-                                                    await self.agent_client.ex_client.bot.send(
+                                                    await self.ex_client.bot.send(
                                                         f"[Duplicate amount!]"
                                                         f"(https://www.bybit.com/ru-RU/p2p/orderList/{order.id})",
-                                                        self.agent_client.actor.person.user.username_id,
+                                                        self.actor.person.user.username_id,
                                                     )
                                                     logging.warning("Duplicate amount!")
                                                     continue
 
                                                 # !!! ОТПРАВЛЯЕМ ДЕНЬГИ !!!
-                                                self.agent_client.api.release_assets(orderId=upd.id)
+                                                self.api.release_assets(orderId=upd.id)
                                                 logging.info(
                                                     f"Order {order.id} created, paid before #{tid}:{am} at {order.createDate}, and RELEASED at {now()}"
                                                 )
@@ -236,14 +239,14 @@ class InAgentClient(BaseInAgentClient):
                                 case "RECEIVE":
                                     upd = Receive.model_validate(data["data"])
                                     if order_db := await models.Order.get_or_none(
-                                        exid=upd.orderId, ad__maker__ex=self.agent_client.actor.ex
+                                        exid=upd.orderId, ad__maker__ex=self.actor.ex
                                     ).prefetch_related("ad__pair_side__pair", "cred__pmcur__cur"):
-                                        im_taker = order_db.taker_id == self.agent_client.actor.id
+                                        im_taker = order_db.taker_id == self.actor.id
                                         im_buyer = order_db.ad.pair_side.is_sell == im_taker
                                         if order_db.ad.auto_msg != upd.message and upd.roleType == "user":
                                             msg, _ = await models.Msg.update_or_create(
                                                 {
-                                                    "to_maker": upd.userId == self.agent_client.actor.exid and im_taker,
+                                                    "to_maker": upd.userId == self.actor.exid and im_taker,
                                                     "sent_at": datetime.fromtimestamp(float(upd.createDate) / 1000),
                                                 },
                                                 txt=upd.message,
@@ -262,7 +265,7 @@ class InAgentClient(BaseInAgentClient):
                                     if upd.orderStatus in (
                                         StatusApi.wait_for_buyer,
                                     ):  # todo: тут приходит ордер.статус=10, хотя покупатель еще не нажал оплачено
-                                        order = self.agent_client.api.get_order_details(orderId=upd.orderId)["result"]
+                                        order = self.api.get_order_details(orderId=upd.orderId)["result"]
                                         order = OrderFull.model_validate(order)
 
                                 case "CLEAR":
@@ -295,15 +298,13 @@ class InAgentClient(BaseInAgentClient):
     async def money_upd(self, order_db: models.Order):
         # обновляем остаток монеты
         await order_db.fetch_related("ad__pair_side__pair", "cred", "transfer")
-        ass = await models.Asset.get(
-            addr__coin_id=order_db.ad.pair_side.pair.coin_id, addr__actor=self.agent_client.actor
-        )
+        ass = await models.Asset.get(addr__coin_id=order_db.ad.pair_side.pair.coin_id, addr__actor=self.actor)
         # обновляем остаток валюты
         fiat = await models.Fiat.get(
-            cred__person_id=self.agent_client.actor.person_id, cred__pmcur_id=order_db.cred.pmcur_id
+            cred__person_id=self.actor.person_id, cred__pmcur_id=order_db.cred.pmcur_id
         ).prefetch_related("cred__pmcur__pm")
         fee = round(order_db.amount * (fiat.cred.pmcur.pm.fee or 0) * 0.0001)
-        im_seller = order_db.ad.pair_side.is_sell == (_im_maker := order_db.ad.maker_id == self.agent_client.actor.id)
+        im_seller = order_db.ad.pair_side.is_sell == (_im_maker := order_db.ad.maker_id == self.actor.id)
         # k = int(im_seller) * 2 - 1  # im_seller: 1, im_buyer: -1
         if order_db.status == OrderStatus.created:
             if im_seller:
@@ -335,9 +336,9 @@ class InAgentClient(BaseInAgentClient):
         pma, cur = await self.get_pma_by_pmex(order_db)
         async with in_transaction():
             # отмечаем ордер на бирже "оплачен"
-            pmex = await models.PmEx.get(pm_id=order_db.cred.pmcur.pm_id, ex=self.agent_client.actor.ex)
-            credex = await models.CredEx.get(cred=order_db.cred, ex=self.agent_client.actor.ex)
-            self.agent_client.api.mark_as_paid(
+            pmex = await models.PmEx.get(pm_id=order_db.cred.pmcur.pmex_exid, ex=self.actor.ex)
+            credex = await models.CredEx.get(cred=order_db.cred, ex=self.actor.ex)
+            self.api.mark_as_paid(
                 orderId=str(order_db.exid),
                 paymentType=pmex.exid,  # pmex.exid
                 paymentId=str(credex.exid),  # credex.exid
@@ -346,7 +347,7 @@ class InAgentClient(BaseInAgentClient):
             if t := await models.Transfer.get_or_none(order=order_db, amount=order_db.amount):
                 await pma.bot.send(
                     f"Order# {order_db.exid}: Double send {fmt_am}{cur} to {order_db.cred.detail} #{t.pmid}!",
-                    self.agent_client.actor.person.user.username_id,
+                    self.actor.person.user.username_id,
                 )
                 raise Exception(
                     f"Order# {order_db.exid}: Double send {fmt_am}{cur} to {order_db.cred.detail} #{t.pmid}!"
@@ -367,38 +368,34 @@ class InAgentClient(BaseInAgentClient):
 
     async def send_receipt(self, oexid: str, tid: int) -> tuple[PmAgentClient | None, models.CredEx] | None:
         try:
-            if res := self.agent_client.api.upload_chat_file(upload_file=f"tmp/{tid}.png").get("result"):
+            if res := self.api.upload_chat_file(upload_file=f"tmp/{tid}.png").get("result"):
                 await sleep(0.5)
-                self.agent_client.api.send_chat_message(
-                    orderId=oexid, contentType="pic", message=res["url"], msgUuid=uuid4().hex
-                )
+                self.api.send_chat_message(orderId=oexid, contentType="pic", message=res["url"], msgUuid=uuid4().hex)
         except Exception as e:
             logging.error(e)
         await sleep(0.5)
-        self.agent_client.api.send_chat_message(
-            orderId=oexid, contentType="str", message=f"#{tid}", msgUuid=uuid4().hex
-        )
+        self.api.send_chat_message(orderId=oexid, contentType="str", message=f"#{tid}", msgUuid=uuid4().hex)
 
     async def get_pma_by_cdex(self, order: OrderFull) -> tuple[PmAgentClient | None, models.CredEx] | None:
         cdxs = await models.CredEx.filter(
-            ex=self.agent_client.ex_client.ex,
+            ex=self.ex_client.ex,
             exid__in=[ptl.id for ptl in order.paymentTermList],
-            cred__person=self.agent_client.actor.person,
+            cred__person=self.actor.person,
         ).prefetch_related("cred__pmcur__cur")
-        pmas = [pma for cdx in cdxs if (pma := self.pmacs.get(cdx.cred.pmcur.pm_id))]
+        pmas = [pma for cdx in cdxs if (pma := self.pmacs.get(cdx.cred.pmcur.pmex_exid))]
         if not len(pmas):
             # raise ValueError(order.paymentTermList, f"No pm_agents for {order.paymentTermList[0].paymentType}")
             return None
         elif len(pmas) > 1:
-            logging.error(order.paymentTermList, f">1 pm_agents for {cdxs[0].cred.pmcur.pm_id}")
+            logging.error(order.paymentTermList, f">1 pm_agents for {cdxs[0].cred.pmcur.pmex_exid}")
         else:
             return pmas[0], cdxs[0]
 
     async def get_pma_by_pmex(self, order_db: models.Order) -> tuple[PmAgentClient, str]:
-        pma = self.pmacs.get(order_db.cred.pmcur.pm_id)
+        pma = self.pmacs.get(order_db.cred.pmcur.pmex_exid)
         if pma:
             return pma, order_db.cred.pmcur.cur.ticker
-        logging.error(f"No pm_agents for {order_db.cred.pmcur.pm_id}")
+        logging.error(f"No pm_agents for {order_db.cred.pmcur.pmex_exid}")
 
     @staticmethod
     def listen(data: dict | None):
@@ -445,7 +442,7 @@ async def main():
         except Exception as e:
             await b.send("😱Bybit InAgent CRASHED!!!😱", agent.actor.person.user.username_id)
             await b.send(f"```\n{''.join(traceback.format_exception(e))}\n```", agent.actor.person.user.username_id)
-        await cl.agent_client.close()
+        await cl.close()
 
 
 if __name__ == "__main__":