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

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

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

@@ -3,8 +3,9 @@ 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
@@ -12,10 +13,23 @@ from xync_client.Abc.xtype import CredExOut, BaseOrderReq, BaseAdUpdate
 
 
 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
+        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.145/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.145}/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.145}/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()
+    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.145}/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
@@ -96,11 +98,11 @@ 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)):
@@ -140,9 +142,9 @@ class InAgentClient(BaseInAgentClient):
                                                     if (
                                                         o["amount"] == order.amount
                                                         and o["id"] != upd.id
-                                                        and o.paymentTermList[0].accountNo
-                                                        == order.paymentTermList[0].accountNo
-                                                        and int(order.createDate) < int(o["createDate"]) + 3600 * 000
+                                                        and int(order.createDate) < int(o["createDate"]) + 900 * 000
+                                                        # todo: get full_order from o, and cred or pm from full_order:
+                                                        # and o['paymentTermList'][0].accountNo == order.paymentTermList[0].accountNo
                                                     )
                                                 ]
                                                 curex = await models.CurEx.get(
@@ -245,7 +247,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 +323,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 +340,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 +405,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")
         .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()
-            cl.pmacs[pma.pm_id] = await pcl.start(await async_playwright().start(), False)
+        for pma in pm_agents:
+            pcl: PmAgentClient = pma.client(bbot)
+            cl.pmacs[pma.pm_id] = await pcl.start(await async_playwright().start(), True)
         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()
 
 

{xync_client-0.0.144 → xync_client-0.0.145}/xync_client/Bybit/agent.py

@@ -24,10 +24,11 @@ from tortoise.signals import post_save
 from urllib3.exceptions import ReadTimeoutError
 from x_model import init_db
 from x_model.func import ArrayAgg
+from xync_bot import XyncBot
 from xync_schema import models
 from xync_schema.enums import OrderStatus
 
-from xync_schema.models import Actor, Cond, CondSim, PmCur, PairSide
+from xync_schema.models import Actor, Cond, CondSim, PmCur, PairSide, Agent
 
 from xync_client.Abc.Agent import BaseAgentClient
 from xync_client.Abc.xtype import BaseOrderReq, FlatDict
@@ -43,7 +44,7 @@ from xync_client.Bybit.etype.order import (
     Message,
     Status,
 )
-from xync_client.loader import TORM, NET_TOKEN
+from xync_client.loader import TORM, NET_TOKEN, PAY_TOKEN
 
 
 class NoMakerException(Exception):
@@ -87,9 +88,9 @@ class AgentClient(BaseAgentClient):  # Bybit client
     rcond_sims: dict[int, set[int]] = defaultdict(set)  # backward
     tree: dict = {}
 
-    def __init__(self, actor: Actor, bot: FileClient, **kwargs):
-        super().__init__(actor, bot, **kwargs)
-        self.api = P2P(testnet=False, api_key=actor.agent.auth["key"], api_secret=actor.agent.auth["sec"])
+    def __init__(self, agent: Agent, fbot: FileClient, bbot: XyncBot, **kwargs):
+        super().__init__(agent, fbot, bbot, **kwargs)
+        self.api = P2P(testnet=False, api_key=agent.auth["key"], api_secret=agent.auth["sec"])
         self.hist: dict = None
         self.completed_orders: list[int] = None
 
@@ -1248,7 +1249,7 @@ class ExcCode(IntEnum):
 
 async def main():
     logging.basicConfig(level=logging.INFO)
-    _ = await init_db(TORM)
+    cn = await init_db(TORM)
 
     @post_save(models.Race)
     async def race_upserted(
@@ -1262,12 +1263,14 @@ async def main():
             ...
 
     actor = (
-        await models.Actor.filter(ex_id=4, agent__isnull=False).prefetch_related("ex", "agent", "person__user").first()
+        await models.Agent.filter(actor__ex_id=4, auth__isnull=False, active=True)
+        .prefetch_related("actor__ex", "actor__person__user")
+        .first()
     )
     filebot = FileClient(NET_TOKEN)
     await filebot.start()
     # b.add_handler(MessageHandler(cond_start_handler, command("cond")))
-    cl: AgentClient = actor.client(filebot)
+    cl: AgentClient = actor.client(filebot, XyncBot(PAY_TOKEN, cn))
 
     # await cl.ex_client.set_pairs()
     # await cl.ex_client.set_pms()

xync_client-0.0.145/xync_client/Gmail/__init__.py

@@ -0,0 +1,124 @@
+import logging
+import pickle
+import re
+from base64 import urlsafe_b64decode
+from datetime import datetime
+
+from google.auth.transport.requests import Request
+from google_auth_oauthlib.flow import InstalledAppFlow
+from googleapiclient.discovery import Resource, build
+from requests import get
+from xync_schema.models import User, Gmail
+
+from xync_client.Abc.HasAbotUid import HasAbotUid
+from xync_client.loader import TORM
+
+# Область доступа
+SCOPES = ["https://www.googleapis.com/auth/gmail.readonly"]
+
+
+class GmClient(HasAbotUid):
+    service: Resource
+
+    def __init__(self, user: User):
+        """Авторизация и создание сервиса Gmail API"""
+        creds = None
+        # Файл token.pickle хранит токены доступа пользователя
+        if user.gmail.token:
+            creds = pickle.loads(user.gmail.token)
+
+        # Если нет валидных credentials, запрашиваем авторизацию
+        if not creds or not creds.valid:
+            if creds and creds.expired and creds.refresh_token:
+                creds.refresh(Request())
+            else:
+                flow = InstalledAppFlow.from_client_config(user.gmail.auth, SCOPES)
+                creds = flow.run_local_server(port=0)
+
+            # Сохраняем credentials для следующего запуска
+            user.gmail.token = pickle.dumps(creds)
+
+        self.service = build("gmail", "v1", credentials=creds)
+        self.uid = user.username_id
+
+    def _get_last_email(self, sender_email, subject_keyword=None):
+        """
+        Получить последнее письмо от определенного отправителя
+
+        Args:
+            sender_email: email отправителя (например, 'example@gmail.com')
+            subject_keyword: ключевое слово в теме (опционально)
+        """
+
+        def _get_email_body(payload):
+            """Извлечь текст письма из payload"""
+            if "body" in payload and "data" in payload["body"]:
+                return urlsafe_b64decode(payload["body"]["data"]).decode("utf-8")
+            return ""
+
+        # Формируем поисковый запрос
+        query = f"from:{sender_email}"
+        if subject_keyword:
+            query += f" subject:{subject_keyword}"
+
+        # Ищем письма с этим запросом
+        results = (
+            self.service.users()
+            .messages()
+            .list(
+                userId="me",
+                q=query,
+                maxResults=1,  # Только последнее письмо
+            )
+            .execute()
+        )
+
+        if not (messages := results.get("messages", [])):
+            logging.warning("Письма не найдены")
+            return None
+
+        # Получаем полную информацию о письме
+        message_id = messages[0]["id"]
+        message = self.service.users().messages().get(userId="me", id=message_id, format="full").execute()
+
+        # Извлекаем заголовки
+        headers = message["payload"]["headers"]
+        subject = next((h["value"] for h in headers if h["name"] == "Subject"), "Нет темы")
+        from_email = next((h["value"] for h in headers if h["name"] == "From"), "Неизвестно")
+        date = next((h["value"] for h in headers if h["name"] == "Date"), "Неизвестно")
+
+        # Извлекаем текст письма
+        body = _get_email_body(message["payload"])
+
+        return {"id": message_id, "subject": subject, "from": from_email, "date": date, "body": body}
+
+    async def mail_confirm(self, amount: float, dt: datetime):
+        if email := self._get_last_email("Volet.com", "Please Confirm Withdrawal"):
+            date = datetime.strptime(email["date"].split(",")[1].split(" +")[0], "%d %b %Y %H:%M:%S")
+            if match := re.search(r"Amount: <b>([\d.]+) [A-Z]{3}</b>", email["body"]):
+                amt = float(match.group(1))
+            if match := re.search(r"https://account\.volet\.com/verify/([a-f0-9-]+)", email["body"]):
+                token = match.group(1)
+
+        if email and amount == amt and date > dt and token:
+            get(f"https://account.volet.com/verify/{token}")
+            return True
+
+        await self.receive("А нет запросов от волета")
+        return False
+
+
+async def _test():
+    from x_model import init_db
+
+    _ = await init_db(TORM)
+
+    gm = await Gmail.get(id=1).prefetch_related("user__username")
+    gmc = GmClient(gm)
+    await gmc.mail_confirm(amount=90, dt=datetime.now())
+
+
+if __name__ == "__main__":
+    from asyncio import run
+
+    run(_test())