xync-client 0.0.144__tar.gz → 0.0.147__tar.gz

{xync_client-0.0.144/xync_client.egg-info → xync_client-0.0.147}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xync-client
-Version: 0.0.144
+Version: 0.0.147
 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.144 → xync_client-0.0.147}/xync_client/Abc/Agent.py

@@ -3,19 +3,35 @@ 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_bot import XyncBot
 from xync_schema import models
-from xync_schema.models import OrderStatus, Coin, Cur, Ad, AdStatus, Actor
+from xync_schema.models import OrderStatus, Coin, Cur, Ad, AdStatus, Actor, Agent
 from xync_schema.xtype import BaseAd
 
 from xync_client.Abc.Ex import BaseExClient
 from xync_client.Abc.xtype import CredExOut, BaseOrderReq, BaseAdUpdate
+from xync_client.Gmail import GmClient
 
 
 class BaseAgentClient(HttpClient):
-    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(bot)
+    bbot: XyncBot
+    fbot: FileClient
+
+    def __init__(
+        self,
+        agent: Agent,
+        fbot: FileClient,
+        bbot: XyncBot,
+        headers: dict[str, str] = None,
+        cookies: dict[str, str] = None,
+    ):
+        self.bbot = bbot
+        self.fbot = fbot
+        self.agent: Agent = agent
+        self.actor: Actor = agent.actor
+        self.gmail = GmClient(agent.actor.person.user)
+        super().__init__(self.actor.ex.host_p2p, headers, cookies)
+        self.ex_client: BaseExClient = self.actor.ex.client(fbot)
 
     # 0: Получшение ордеров в статусе status, по монете coin, в валюте coin, в направлении is_sell: bool
     @abstractmethod

xync_client-0.0.147/xync_client/Abc/HasAbotUid.py

@@ -0,0 +1,10 @@
+from PGram import Bot
+from aiogram.types import Message
+
+
+class HasAbotUid:
+    abot: Bot
+    uid: int
+
+    async def receive(self, text: str, photo: bytes = None, video: bytes = None) -> Message:
+        return await self.abot.send(self.uid, txt=text, photo=photo, video=video)

{xync_client-0.0.144 → xync_client-0.0.147}/xync_client/Abc/InAgent.py

@@ -1,8 +1,10 @@
 from abc import abstractmethod
 
 from pyro_client.client.file import FileClient
+from xync_bot import XyncBot
+
 from xync_client.Abc.PmAgent import PmAgentClient
-from xync_schema.models import Actor
+from xync_schema.models import Agent
 
 from xync_client.Abc.Agent import BaseAgentClient
 
@@ -10,8 +12,8 @@ from xync_client.Abc.Agent import BaseAgentClient
 class BaseInAgentClient:
     pmacs: dict[int, PmAgentClient] = {}
 
-    def __init__(self, actor: Actor, bot: FileClient):
-        self.agent_client: BaseAgentClient = actor.client(bot)
+    def __init__(self, agent: Agent, fbot: FileClient, bbot: XyncBot):
+        self.agent_client: BaseAgentClient = agent.client(fbot, bbot)
 
     @abstractmethod
     async def start_listen(self) -> bool: ...

{xync_client-0.0.144 → xync_client-0.0.147}/xync_client/Abc/PmAgent.py

@@ -4,52 +4,57 @@ from datetime import datetime, timedelta
 from decimal import Decimal
 from enum import StrEnum
 
-from playwright.async_api import Page, Playwright
+from PGram import Bot
+from playwright.async_api import Page, Playwright, Browser
 from pyro_client.client.file import FileClient
 from pyro_client.client.user import UserClient
+from tortoise.timezone import now
 
-from xync_client.loader import NET_TOKEN
 from xync_schema.enums import UserStatus
-from xync_schema.models import PmAgent, User
+from xync_schema.models import PmAgent, User, Transfer
+
+from xync_client.Abc.HasAbotUid import HasAbotUid
 
 
 class LoginFailedException(Exception): ...
 
 
-class PmAgentClient(metaclass=ABCMeta):
+class PmAgentClient(HasAbotUid, metaclass=ABCMeta):
     class Pages(StrEnum):
         base = "https://host"
         LOGIN = base + "login"
         SEND = base + "send"
         OTP_LOGIN = base + "login/otp"
 
+    browser: Browser
     norm: str
     agent: PmAgent
-    bot: FileClient | UserClient
+    ubot: FileClient | UserClient = None
     page: Page
     pages: type(StrEnum) = Pages
-    last_page: int = 0
-    last_active: datetime = datetime.now()
+    last_active: datetime = now()
+    with_userbot: bool = False
     _is_started: bool = False
 
-    async def start(self, pw: Playwright, headed: bool = False, userbot: bool = False) -> "PmAgentClient":
-        bot = FileClient(NET_TOKEN)
-        self.bot = UserClient(self.uid, bot) if userbot else bot
-        await self.bot.start()
+    async def start(self, pw: Playwright, headed: bool = False) -> "PmAgentClient":
+        if self.with_userbot:
+            self.ubot = UserClient(self.uid)
+            await self.ubot.start()
 
         self.browser = await pw.chromium.launch(
-            channel="chromium" if headed else "chromium-headless-shell", headless=not headed
+            channel="chrome-beta" if headed else "chromium-headless-shell", headless=not headed
         )
+        # noinspection PyTypeChecker
         context = await self.browser.new_context(storage_state=self.agent.state)
         self.page = await context.new_page()
-        await self.page.goto(self.pages.SEND)  # Оптимистично переходим сразу на страницу отправки
+        await self.page.goto(self.pages.SEND, wait_until="commit")  # Оптимистично переходим сразу на страницу отправки
         if self.page.url.startswith(self.pages.LOGIN):  # Если перебросило на страницу логина
             await self._login()  # Логинимся
         if not self.page.url.startswith(self.pages.SEND):  # Если в итоге не удалось попасть на отправку
-            await self.bot.send(self.norm + " not logged in!", self.uid, photo=await self.page.screenshot())
+            await self.receive(self.norm + " not logged in!", photo=await self.page.screenshot())
             raise LoginFailedException(f"User {self.agent.user_id} has not logged in")
         loop = get_running_loop()
-        self.last_active = datetime.now()
+        self.last_active = now()
         loop.create_task(self._idle())  # Бесконечно пасёмся в фоне на странице отправки, что бы куки не протухли
         self._is_started = True
         return self
@@ -59,18 +64,21 @@ class PmAgentClient(metaclass=ABCMeta):
     async def _idle(self):  # todo: не мешать другим процессам, обновлять на другой вкладке?
         while (await User.get(username_id=self.uid)).status >= UserStatus.ACTIVE:
             await self.page.wait_for_timeout(30 * 1000)
-            if self.last_active < datetime.now() - timedelta(minutes=1):
-                await self.page.reload()
-                self.last_active = datetime.now()
-        await self.bot.send(self.norm + " stoped", self.uid)
+            if self.last_active < now() - timedelta(minutes=1):
+                await self.page.reload(wait_until="commit")
+                self.last_active = now()
+        await self.receive(self.norm + " stoped")
         await self.stop()
 
     async def stop(self):
         # save state
+        # noinspection PyTypeChecker
         self.agent.state = await self.page.context.storage_state()
         await self.agent.save()
         # closing
-        await self.bot.stop()
+        await self.abot.stop()
+        if self.ubot:
+            await self.ubot.stop()
         await self.page.context.close()
         await self.page.context.browser.close()
         self._is_started = False
@@ -79,15 +87,18 @@ class PmAgentClient(metaclass=ABCMeta):
     async def _login(self): ...
 
     @abstractmethod
-    async def send(self, dest, amount: int, cur: str) -> tuple[int, bytes, float]: ...
+    async def send(self, t: Transfer) -> tuple[int, bytes] | float: ...
 
     @abstractmethod  # проверка поступления определенной суммы за последние пол часа (минимум), return точную сумму
-    async def check_in(self, amount: int | Decimal | float, cur: str, tid: str | int = None) -> float | None: ...
+    async def check_in(
+        self, amount: int | Decimal | float, cur: str, dt: datetime, tid: str | int = None
+    ) -> float | None: ...
 
     @abstractmethod  # видео входа в аккаунт, и переход в историю поступлений за последние сутки (минимум)
     async def proof(self) -> bytes: ...
 
-    def __init__(self, agent: PmAgent):
+    def __init__(self, agent: PmAgent, abot: Bot):
         self.agent = agent
+        self.abot = abot
         self.uid = agent.user.username_id
         self.norm = agent.pm.norm

{xync_client-0.0.144 → xync_client-0.0.147}/xync_client/Abc/xtype.py

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

{xync_client-0.0.144 → xync_client-0.0.147}/xync_client/Bybit/InAgent.py

@@ -1,6 +1,7 @@
 import json
 import logging
 import re
+import traceback
 from datetime import datetime, timezone, timedelta
 from uuid import uuid4
 
@@ -14,6 +15,7 @@ from pyro_client.client.file import FileClient
 from tortoise.exceptions import IntegrityError
 from tortoise.timezone import now
 from tortoise.transactions import in_transaction
+from xync_bot import XyncBot
 
 from xync_client.Abc.PmAgent import PmAgentClient
 from xync_schema import models
@@ -28,7 +30,7 @@ from xync_client.Bybit.etype.order import (
     OrderFull,
     StatusApi,
 )
-from xync_client.loader import NET_TOKEN
+from xync_client.loader import NET_TOKEN, PAY_TOKEN
 from xync_client.Abc.InAgent import BaseInAgentClient
 from xync_client.Bybit.agent import AgentClient
 
@@ -39,7 +41,7 @@ class InAgentClient(BaseInAgentClient):
     async def start_listen(self):
         t = await self.agent_client.ott()
         ts = int(float(t["time_now"]) * 1000)
-        await self.ws_prv(self.agent_client.actor.agent.auth["deviceId"], t["result"], ts)
+        await self.ws_prv(self.agent_client.agent.auth["deviceId"], t["result"], ts)
 
     # 3N: [T] - Уведомление об одобрении запроса на сделку
     async def request_accepted_notify(self) -> int: ...  # id
@@ -75,7 +77,7 @@ class InAgentClient(BaseInAgentClient):
             while resp := await websocket.recv():
                 if data := json.loads(resp):
                     upd, order_db = None, None
-                    logging.info(f" {datetime.now().strftime('%H:%M:%S')} upd: {data.get('topic')}:{data.get('type')}")
+                    logging.info(f" {now().strftime('%H:%M:%S')} upd: {data.get('topic')}:{data.get('type')}")
                     match data.get("topic"):
                         case "OTC_ORDER_STATUS":
                             match data["type"]:
@@ -96,20 +98,21 @@ class InAgentClient(BaseInAgentClient):
                                             # сразу уменьшаем доступный остаток монеты/валюты
                                             await self.money_upd(order_db)
                                             if upd.side:  # я покупатель - ждем мою оплату
-                                                dest = order.paymentTermList[0].accountNo
-                                                if not re.match(r"^([PpРр])\d{7,10}\b", dest):
+                                                _dest = order.paymentTermList[0].accountNo
+                                                if not re.match(r"^([PpРр])\d{7,10}\b", _dest):
                                                     continue
                                                 await order_db.fetch_related("ad__pair_side__pair", "cred__pmcur__cur")
-                                                await self.send_payment(order_db, dest)
+                                                await self.send_payment(order_db)
                                         case StatusApi.wait_for_buyer:
                                             if upd.side == 0:  # ждем когда покупатель оплатит
                                                 if not (pmacdx := await self.get_pma_by_cdex(order)):
                                                     continue
                                                 pma, cdx = pmacdx
-                                                am, tid = pma.check_in(
+                                                am, tid = await pma.check_in(
                                                     Decimal(order.amount),
                                                     cdx.cred.pmcur.cur.ticker,
-                                                    datetime.fromtimestamp(float(order.createDate) / 1000),
+                                                    # todo: почему в московском час.поясе?
+                                                    datetime.fromtimestamp(float(order.transferDate) / 1000),
                                                 )
                                                 if not tid:
                                                     logging.info(
@@ -140,9 +143,13 @@ class InAgentClient(BaseInAgentClient):
                                                     if (
                                                         o["amount"] == order.amount
                                                         and o["id"] != upd.id
-                                                        and o.paymentTermList[0].accountNo
+                                                        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"]
                                                         == order.paymentTermList[0].accountNo
-                                                        and int(order.createDate) < int(o["createDate"]) + 3600 * 000
                                                     )
                                                 ]
                                                 curex = await models.CurEx.get(
@@ -153,7 +160,7 @@ class InAgentClient(BaseInAgentClient):
                                                     cred_id=order_db.cred_id,
                                                     amount=int(float(order.amount) * 10**curex.scale),
                                                     status__not_in=[OrderStatus.completed, OrderStatus.canceled],
-                                                    created_at__gt=now() - timedelta(hours=1),
+                                                    created_at__gt=now() - timedelta(minutes=15),
                                                 )
                                                 if pos or pos_db:
                                                     await self.agent_client.ex_client.bot.send(
@@ -167,10 +174,10 @@ class InAgentClient(BaseInAgentClient):
                                                 # !!! ОТПРАВЛЯЕМ ДЕНЬГИ !!!
                                                 self.agent_client.api.release_assets(orderId=upd.id)
                                                 logging.info(
-                                                    f"Order {order.id} created, paid before #{tid}:{am} at {order.createDate}, and RELEASED at {datetime.now()}"
+                                                    f"Order {order.id} created, paid before #{tid}:{am} at {order.createDate}, and RELEASED at {now()}"
                                                 )
                                             elif upd.side == 1:  # я покупатель - ждем мою оплату
-                                                continue  # logging.warning(f"Order {order.id} PAID at {datetime.now()}: {int_am}")
+                                                continue  # logging.warning(f"Order {order.id} PAID at {now()}: {int_am}")
                                             else:
                                                 ...
                                             # todo: check is always canceling
@@ -245,7 +252,10 @@ class InAgentClient(BaseInAgentClient):
                                             if not upd.message:
                                                 ...
                                             if im_buyer and (g := re.match(r"^[PpРр]\d{7,10}\b", upd.message)):
-                                                await self.send_payment(order_db, g.group())
+                                                if not order_db.cred.detail.startswith(dest := g.group()):
+                                                    order_db.cred.detail = dest
+                                                    await order_db.save()
+                                                await self.send_payment(order_db)
                                 case "READ":
                                     upd = Read.model_validate(data["data"])
                                     # if upd.status not in (StatusWs.created, StatusWs.canceled, 10, StatusWs.completed):
@@ -318,7 +328,7 @@ class InAgentClient(BaseInAgentClient):
         await fiat.save(update_fields=["amount"])
         logging.info(f"Order #{order_db.id} {order_db.status.name}. Fiat: {fiat.amount}, Asset: {ass.free}")
 
-    async def send_payment(self, order_db: models.Order, dest):
+    async def send_payment(self, order_db: models.Order):
         if order_db.status != OrderStatus.created:
             return
         fmt_am = round(order_db.amount * 10**-2, 2)
@@ -335,19 +345,23 @@ 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 {dest} #{t.pmid}!",
+                    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,
                 )
-                raise Exception(f"Order# {order_db.exid}: Double send {fmt_am}{cur} to {dest} #{t.pmid}!")
+                raise Exception(
+                    f"Order# {order_db.exid}: Double send {fmt_am}{cur} to {order_db.cred.detail} #{t.pmid}!"
+                )
 
             # ставим в бд статус "оплачен"
             order_db.status = OrderStatus.paid
             order_db.payed_at = datetime.now(timezone.utc)
             await order_db.save()
-            # отправляем деньги
-            tid, img, rest_amount = await pma.send(dest=dest, amount=fmt_am, cur=cur)
             # создаем перевод в бд
-            t, _ = await models.Transfer.update_or_create({"order": order_db, "amount": order_db.amount}, pmid=tid)
+            t = models.Transfer(order=order_db, amount=order_db.amount, updated_at=now())
+            # отправляем деньги
+            tid, img = await pma.send(t)
+            t.pmid = tid
+            await t.save()
             await self.send_receipt(str(order_db.exid), tid)  # отправляем продавцу чек
             logging.info(f"Order {order_db.exid} PAID at {datetime.now()}: {fmt_am}!")
 
@@ -396,33 +410,41 @@ async def main():
     from x_model import init_db
     from xync_client.loader import TORM
 
-    _ = await init_db(TORM, True)
+    cn = await init_db(TORM, True)
     logging.basicConfig(level=logging.INFO)
 
-    actor = (
-        await models.Actor.filter(
-            ex_id=4,
-            agent__auth__isnull=False,
-            person__user__status=UserStatus.ACTIVE,
-            person__user__pm_agents__isnull=False,
+    agent = (
+        await models.Agent.filter(
+            actor__ex_id=4,
+            active=True,
+            auth__isnull=False,
+            actor__person__user__status=UserStatus.ACTIVE,
+            actor__person__user__pm_agents__isnull=False,
         )
-        .prefetch_related("ex", "agent", "person__user__pm_agents__user", "person__user__pm_agents__pm")
+        .prefetch_related("actor__ex", "actor__person__user__gmail")
         .first()
     )
+    pm_agents = await models.PmAgent.filter(
+        active=True,
+        auth__isnull=False,
+        user__status=UserStatus.ACTIVE,
+    ).prefetch_related("pm", "user__gmail")
+
+    bbot = XyncBot(PAY_TOKEN, cn)
 
     async with FileClient(NET_TOKEN) as b:
         b: FileClient
-        cl: InAgentClient = actor.in_client(b)
+        cl: InAgentClient = agent.in_client(b, bbot)
         # await cl.agent_client.export_my_ads()
         # payeer_cl = Client(actor.person.user.username_id)
-        for pma in actor.person.user.pm_agents:
-            pcl = pma.client()
+        for pma in pm_agents:
+            pcl: PmAgentClient = pma.client(bbot)
             cl.pmacs[pma.pm_id] = await pcl.start(await async_playwright().start(), False)
         try:
             _ = await cl.start_listen()
         except Exception as e:
-            await b.send("😱Bybit InAgent CRASHED!!!😱", actor.person.user.username_id)
-            await b.send(e.__repr__(), actor.person.user.username_id)
+            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()