xync-client 0.0.143__py3-none-any.whl → 0.0.145__py3-none-any.whl

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/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/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/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/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/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/Gmail/__init__.py

@@ -1,113 +1,121 @@
-from playwright.async_api import Page, Playwright
-from pyro_client.client.file import FileClient
-from pyro_client.client.user import UserClient
+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.loader import NET_TOKEN
+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)
 
-class GmClient:
-    uid: int
-    user: User
-    page: Page
-    bot: UserClient = None
-    HOME = "https://mail.google.com/mail/u/0/"
+            # Сохраняем credentials для следующего запуска
+            user.gmail.token = pickle.dumps(creds)
 
-    def __init__(self, uid: int):
-        self.uid = uid
+        self.service = build("gmail", "v1", credentials=creds)
+        self.uid = user.username_id
 
-    async def start(self, pw: Playwright, headed: bool = False):
-        self.user = await User.get(username_id=self.uid).prefetch_related("gmail")
-        if not self.user.gmail:
-            self.user.gmail = await Gmail.create(
-                login=input(f"{self.user.last_name} gmail login:"), password=input("password:")
+    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,  # Только последнее письмо
             )
-        browser = await pw.chromium.launch(
-            channel="chrome" if headed else "chromium-headless-shell",
-            headless=not headed,
-            args=[
-                "--disable-blink-features=AutomationControlled",
-                "--no-sandbox",
-                "--disable-web-security",
-                "--disable-infobars",
-                "--disable-extensions",
-                "--start-maximized",
-            ],
+            .execute()
         )
-        context = await browser.new_context(storage_state=self.user.gmail.auth, locale="en")
-        self.page = await context.new_page()
-        # go home
-        await self.page.goto(self.HOME, timeout=62000)
-        if not self.page.url.startswith(self.HOME):
-            if await (  # ваще с 0 заходим
-                sgn_btn := self.page.locator(
-                    'header a[href^="https://accounts.google.com/AccountChooser/signinchooser"]:visible',
-                    has_text="sign",
-                )
-            ).count():
-                await sgn_btn.click()
-            if self.page.url.startswith("https://accounts.google.com/v3/signin/accountchooser"):  # надо выбрать акк
-                await self.page.locator("li").first.click()
-            # если предлагает залогиниться
-            elif await self.page.locator("h1#headingText", has_text="Sign In").count():
-                await self.page.fill("input[type=email]", self.user.gmail.login)
-                await self.page.locator("button", has_text="Next").click()
-            # осталось ввести пороль:
-            await self.page.fill("input[type=password]", self.user.gmail.password)
-            await self.page.locator("#passwordNext").click()
-            await self.page.wait_for_timeout(3000)
-            if self.page.url.startswith("https://accounts.google.com/v3/signin/challenge/dp"):
-                await self.load_bot()
-                await self.bot.receive("Аппрувни гмейл, у тебя 1.5 минуты", photo=await self.page.screenshot())
-        await self.page.wait_for_url(lambda u: u.startswith(self.HOME), timeout=90 * 1000)  # убеждаемся что мы в почте
-        self.user.gmail.auth = await self.page.context.storage_state()
-        await self.user.gmail.save()
-
-    async def mail_confirm(self):
-        lang = await self.page.get_attribute("html", "lang")
-        labs = {
-            "ru": "Оповещения",
-            "en-US": "Updates",
-        }
-        tab = self.page.get_by_role("heading").get_by_label(labs[lang]).last
-        await tab.click()
-        rows = self.page.locator("tbody>>nth=4 >> tr")
-        row = rows.get_by_text("Volet.com").and_(rows.get_by_text("Please Confirm Withdrawal"))
-        if not await row.count():
-            await self.bot.receive("А нет запросов от волета", photo=await self.page.screenshot())
-
-        await row.click()
-        await self.page.wait_for_load_state()
-        btn = self.page.locator('a[href^="https://account.volet.com/verify/"]', has_text="confirm").first
-        await btn.click()
-
-    async def load_bot(self):
-        if not self.bot:
-            bot = FileClient(NET_TOKEN)
-            self.bot = UserClient(self.uid, bot)
-        if not self.bot.is_connected:
-            await self.bot.start()
-
-    async def stop(self):
-        if self.bot and self.bot.is_connected:  # todo: do not stop if
-            await self.bot.stop(False)
-        await self.page.context.close()
-        await self.page.context.browser.close()
+
+        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
-    from xync_schema import TORM
-
-    _ = await init_db(TORM, True)
-    uid = 193017646
-    gmc = GmClient(uid)
-    try:
-        await gmc.start(True)
-    except TimeoutError as te:
-        raise te
-    finally:
-        await gmc.stop()
+
+    _ = 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__":

xync_client/Pms/Payeer/__init__.py

@@ -11,6 +11,7 @@ from os import urandom
 from time import sleep
 from urllib.parse import urlencode
 
+from PGram import Bot
 from asyncpg.pgproto.pgproto import timedelta
 from cryptography.hazmat.primitives import padding
 from cryptography.hazmat.primitives.ciphers import Cipher
@@ -18,10 +19,13 @@ from cryptography.hazmat.primitives.ciphers.algorithms import AES
 from cryptography.hazmat.primitives.ciphers.modes import CBC
 from payeer_api import PayeerAPI
 from playwright.async_api import async_playwright, Playwright, Error
+
+# noinspection PyProtectedMember
 from playwright._impl._errors import TimeoutError
-from xync_schema.models import TopUp, TopUpAble, PmAgent
+from xync_bot import XyncBot
+from xync_schema.models import TopUp, TopUpAble, PmAgent, Transfer
 
-from xync_client.loader import TORM
+from xync_client.loader import TORM, PAY_TOKEN
 
 from xync_client.Abc.PmAgent import PmAgentClient
 from xync_client.Pms.Payeer.login import login
@@ -64,9 +68,10 @@ class Client(PmAgentClient):
     norm: str = "payeer"
     pages: type(StrEnum) = Pages
     api: PayeerAPI
+    with_userbot: bool = False
 
-    def __init__(self, agent: PmAgent):
-        super().__init__(agent)
+    def __init__(self, agent: PmAgent, abot: XyncBot):
+        super().__init__(agent, abot)
         if api_id := self.agent.auth.get("api_id"):
             self.api = PayeerAPI(self.agent.auth["email"], api_id, self.agent.auth["api_sec"])
 
@@ -74,7 +79,7 @@ class Client(PmAgentClient):
         await login(self.agent)
         for cookie in self.agent.state["cookies"]:
             await self.page.context.add_cookies([cookie])
-        await self.page.goto(self.pages.SEND)
+        await self.page.goto(self.pages.SEND, wait_until="commit")
 
     @staticmethod
     def form_redirect(topup: TopUp) -> tuple[str, dict | None]:
@@ -131,20 +136,22 @@ class Client(PmAgentClient):
             "ts": datetime.strptime(ti["dateCreate"], "%d.%m.%Y %H:%M:%S") - timedelta(hours=3),
         }
 
-    async def send(self, dest: str, amount: int, cur: str) -> tuple[int, bytes, int] | int:
+    async def send(self, t: Transfer) -> tuple[str, bytes] | float:
+        dest, cur = t.order.cred.detail, t.order.cred.pmcur.cur.ticker
+        amount = round(t.order.amount * 10**-t.order.cred.pmcur.cur.scale, t.order.cred.pmcur.cur.scale)
         self.last_active = datetime.now()
         page = self.page
         if not page.url.startswith(self.pages.SEND):
             try:
-                await page.goto(self.pages.SEND)
+                await page.goto(self.pages.SEND, wait_until="commit")
             except (TimeoutError, Error):
                 await login(self.agent)
                 for cookie in self.agent.state["cookies"]:
                     await page.context.add_cookies([cookie])
                 sleep(0.5)
-                await page.goto("https://payeer.com/en/account/send/")
+                await page.goto("https://payeer.com/en/account/send/", wait_until="commit")
         has_amount = float(self.api.get_balance()[cur]["DOSTUPNO"])
-        if float(amount) <= has_amount:
+        if amount <= has_amount:
             sleep(0.1)
             await page.locator('input[name="param_ACCOUNT_NUMBER"]').fill(dest)
             await page.locator("select[name=curr_receive]").select_option(value=cur)
@@ -166,42 +173,41 @@ class Client(PmAgentClient):
             except TimeoutError as _:
                 logging.error("Repeat!")
                 sleep(0.5)
-                return await self.send(dest, amount, cur)
+                return await self.send(t)
             if await page.locator('.note_txt:has-text("successfully completed")').count():
                 transaction = await page.locator(".note_txt").all_text_contents()
-                trans_num = int(transaction[0].replace("Transaction #", "").split()[0])
-                await page.goto("https://payeer.com/ru/account/history/")
+                trans_num = transaction[0].replace("Transaction #", "").split()[0]
+                await page.goto("https://payeer.com/ru/account/history/", wait_until="commit")
                 await page.click(f".history-id-{trans_num} a.link")
                 sleep(1)
                 receipt = await page.query_selector(".ui-dialog.ui-corner-all")
-                return trans_num, await receipt.screenshot(path=f"tmp/{trans_num}.png"), int(has_amount - amount)
+                return trans_num, await receipt.screenshot(path=f"tmp/{trans_num}.png")
             else:
-                await self.bot.send("Payeer хз", self.uid, photo=await self.page.screenshot())
+                await self.receive("Payeer хз", photo=await self.page.screenshot())
                 return -1
         else:
-            await self.bot.send(
+            await self.receive(
                 f"Payeer no have {amount}, only {has_amount}{cur} to {dest}",
-                self.uid,
                 photo=await self.page.screenshot(),
             )
             return has_amount
 
     def check_in(
-        self, amount: Decimal | int | float, cur: str, tme: datetime = None, tid: str | int = None
+        self, amount: Decimal | int | float, cur: str, dt: datetime = None, tid: str | int = None
     ) -> tuple[Decimal | None, int | None]:
         history = self.api.history(type="incoming", append=tid, count=3)
         if tid:
             return (t := history.get(tid)) and Decimal(t["creditedAmount"])
-        t = [
+        ts: list[dict] = [
             h
             for h in history.values()
             if (
                 amount <= Decimal(h["creditedAmount"]) <= ceil(amount)
                 and h["creditedCurrency"] == cur
-                and datetime.fromisoformat(h["date"]) > tme - timedelta(minutes=1)
+                and datetime.fromisoformat(h["date"]) > dt - timedelta(minutes=1)
             )
         ]
-        if not (t := t and t[0]):
+        if not (t := ts and ts[0]):
             return None, None
         return (
             amount <= (am := Decimal(t["creditedAmount"])) <= ceil(amount) and t["creditedCurrency"] == cur
@@ -219,7 +225,8 @@ async def main(uid: int):
     )
     if not agent:
         raise Exception(f"No active user #{uid} with agent for volet!")
-    pyr = agent.client()
+    abot = Bot(PAY_TOKEN)
+    pyr = agent.client(abot)
     playwright: Playwright = await async_playwright().start()
     try:
         dest, amount, cur = "P79619335", 4, "RUB"
@@ -236,14 +243,14 @@ async def main(uid: int):
         res = pyr.check_in(3, cur, datetime.now())
 
         if len(res) > 1 and isinstance(res[1], bytes):
-            await pyr.bot.send(f"Transaction #{res[0]}", uid, photo=res[1])
+            await pyr.receive(f"Transaction #{res[0]}", photo=res[1])
         elif res[0] > 0:
-            await pyr.bot.send(f"Sreen of transaction #{res[0]} failed", uid, photo=await pyr.page.screenshot())
+            await pyr.receive(f"Sreen of transaction #{res[0]} failed", photo=await pyr.page.screenshot())
         else:
-            await pyr.bot.send(f"Sending {amount} {cur} to {dest} FAILED", uid, photo=await pyr.page.screenshot())
+            await pyr.receive(f"Sending {amount} {cur} to {dest} FAILED", photo=await pyr.page.screenshot())
 
     except TimeoutError as te:
-        await pyr.bot.send(repr(te), uid, photo=await pyr.page.screenshot())
+        await pyr.receive(repr(te), photo=await pyr.page.screenshot())
         raise te
     # finally:
     #     await pyr.stop()

xync_client/Pms/Payeer/login.py

@@ -12,7 +12,7 @@ async def login(agent: PmAgent):
     options.add_argument("--disable-blink-features=AutomationControlled")
     options.add_argument("--no-sandbox")
     options.add_argument("--disable-dev-shm-usage")
-    options.add_argument("--headless=new")  # for Chrome >= 109
+    # options.add_argument("--headless=new")  # for Chrome >= 109
     options.add_argument("--disable-renderer-backgrounding")
     options.add_argument("--disable-background-timer-throttling")
     options.add_argument("--disable-backgrounding-occluded-windows")
@@ -28,7 +28,11 @@ async def login(agent: PmAgent):
     options.add_argument("--window-size=1920,1080")
     options.add_argument("--user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36")
 
-    driver = uc.Chrome(options=options, headless=True)
+    driver = uc.Chrome(
+        options=options,
+        headless=False,
+        browser_executable_path="/Applications/Google Chrome Beta.app/Contents/MacOS/Google Chrome Beta",
+    )
     wait = WebDriverWait(driver, timeout=10)
     try:
         driver.get("https://payeer.com/en/auth")

xync_client/Pms/Volet/__init__.py

@@ -1,10 +1,12 @@
 import logging
 import re
-from asyncio import run, ensure_future
+from asyncio import run
+from datetime import datetime
 from decimal import Decimal
 from enum import StrEnum
 from hashlib import sha256
 
+from PGram import Bot
 from playwright.async_api import async_playwright, Page, Locator, Position, Playwright  # , FloatRect
 from pyotp import TOTP
 
@@ -12,12 +14,15 @@ from pyotp import TOTP
 from playwright._impl._errors import TimeoutError
 from pyro_client.client.user import UserClient
 from pyrogram.handlers import MessageHandler
+from tortoise.timezone import now
+from xync_schema import models
 from xync_schema.enums import UserStatus
-from xync_schema.models import Cur, User, PmAgent, Cred, PmCur, Fiat, TopUp
+from xync_schema.models import Cur, User, PmAgent, Cred, PmCur, Fiat, TopUp, Transfer
 
 from xync_client.Abc.PmAgent import PmAgentClient
 from xync_client.Gmail import GmClient
 from xync_client.Pms.Volet.api import APIClient
+from xync_client.loader import PAY_TOKEN
 
 
 class CaptchaException(Exception): ...
@@ -58,24 +63,28 @@ class Client(PmAgentClient):
         # HOME = base + "pages/transaction"
         SEND = base + "pages/transfer/wallet"
 
-    async def check_in(self, amount: int | Decimal | float, cur: str, tid: str | int = None) -> float | None:
-        pass
+    async def check_in(
+        self, amount: int | Decimal | float, cur: str, dt: datetime, tid: str | int = None
+    ) -> float | None:
+        return await (self.api.check_by_id(tid) if tid else self.api.check_by_amount(amount, cur))
 
     async def proof(self) -> bytes:
         pass
 
     uid: int
     agent: PmAgent
-    bot: UserClient
+    abot: Bot
+    ubot: UserClient
     api: APIClient
     page: Page
     gmail: GmClient
     norm: str = "payeer"
     pages: type(StrEnum) = Pages
+    with_userbot: bool = True
 
-    def __init__(self, agent: PmAgent):
-        super().__init__(agent)
-        self.gmail = GmClient(self.uid)
+    def __init__(self, agent: PmAgent, abot: Bot):
+        super().__init__(agent, abot)
+        self.gmail = GmClient(agent.user)
         self.api = APIClient(self.agent.auth["api"], self.agent.auth["password"], self.agent.auth["login"])
 
     @staticmethod
@@ -113,77 +122,92 @@ class Client(PmAgentClient):
             "ts": t["updatedTime"],
         }
 
-    async def start(self, pw: Playwright, headed: bool = False):
-        ensure_future(self.gmail.start(pw, False))
-        return await super().start(pw, False, True)
-
     async def wait_for_code(self, uid: int, topic: str, hg: tuple[MessageHandler, int]) -> str:
-        code = await self.bot.wait_from(uid, topic, hg)
+        code = await self.ubot.wait_from(uid, topic, hg)
         return code and code[-6:]
 
     async def _login(self):
         ll = self.page.locator("input#j_username")
-        await ll.fill("mixartemev@gmail.com")
-        await self.page.locator("input#j_password").fill("mixfixX98")
-        await self.page.wait_for_timeout(200)
+        await ll.fill(self.agent.auth["login"])
+        await self.page.locator("input#j_password").fill(self.agent.auth["password"])
+        await self.page.wait_for_timeout(300)
         await ll.click()
+        await ll.press(key="ArrowLeft")
+        await ll.blur()
         volet_bot_id, topic = 243630567, "otp_login"
         await self.page.locator("input#loginToAdvcashButton", has_text="log in").hover()
-        hg = self.bot.subscribe_for(volet_bot_id, topic)  # 243630567 - is volet bot
+        hg = self.ubot.subscribe_for(volet_bot_id, topic)
         await self.page.locator("input#loginToAdvcashButton:not([disabled])", has_text="log in").click()
         await self.page.wait_for_url(self.pages.OTP_LOGIN)
         if not (code := await self.wait_for_code(volet_bot_id, topic, hg)):
-            await self.bot.receive("no login code", photo=await self.page.screenshot())
+            await self.ubot.receive("no login code", photo=await self.page.screenshot())
             raise NoCodeException(self.agent.user_id)
         await self.page.locator("input#otpId").fill(code)
         await self.page.click("input#checkOtpButton")
-        await self.page.wait_for_url(self.pages.SEND)
+        await self.page.wait_for_url(self.pages.SEND, wait_until="domcontentloaded")
+        # save state
+        # noinspection PyTypeChecker
+        self.agent.state = await self.page.context.storage_state()
+        await self.agent.save()
 
-    async def send(self, dest: str, amount: float, cur: str) -> tuple[int, bytes, float]:
+    async def send(self, t: Transfer) -> tuple[str, bytes] | float:
+        dest, cur = t.order.cred.detail, t.order.cred.pmcur.cur.ticker
+        amount = round(t.order.amount * 10**-t.order.cred.pmcur.cur.scale, t.order.cred.pmcur.cur.scale)
+        self.last_active = now()
         curs_map = {"RUB": "Ruble"}
-
-        await self.go(self.pages.SEND)
+        await self.go(self.pages.SEND, False)
         await self.page.click("[class=combobox-account]")
-        await self.page.click(f'[class=rf-ulst-itm] b:has-text("{curs_map[cur]}") ")')
-        await self.page.wait_for_timeout(200)
+        await self.page.click(f'[class=rf-ulst-itm] b:has-text("{curs_map[cur]}")')
+        await self.page.wait_for_selector(f"#srcCurrency:has-text('{cur}')")
         await self.page.fill("#srcAmount", str(amount))
-        await self.page.fill("#destWalletId", dest)
-        await self.page.wait_for_timeout(300)
+        dw = self.page.locator("#destWalletId")
+        await dw.fill(dest)
+        await dw.blur()
+        await self.page.wait_for_selector(f"#destCurrency:has-text('{cur}')")
+        volet_bot_id, topic = 243630567, "otp_send"
+        hg = self.ubot.subscribe_for(volet_bot_id, topic)
         await self.page.locator("form#mainForm input[type=submit]", has_text="continue").click()
         # todo: check success confirming
         if otp := self.agent.auth.get("otp"):
             totp = TOTP(otp)
             code = totp.now()
         elif self.agent.user.username.session:
-            if not (code := await self.wait_for_code("send")):
-                if 1:  # todo: need main confirm
-                    await self.gmail.mail_confirm()
-                await self.bot.receive("no send trans code", photo=await self.page.screenshot())
+            if not (code := await self.wait_for_code(volet_bot_id, topic, hg)):
+                if 1:  # todo: Is mail_confirm required?
+                    if _mcr := await self.gmail.mail_confirm(amount, t.updated_at):
+                        ...
+                        # todo: click Continue
+                    if not (code := await self.wait_for_code(volet_bot_id, topic, hg)):
+                        code = await self.wait_for_code(volet_bot_id, topic, hg)
+            if not code:
+                await self.receive("no send trans code", photo=await self.page.screenshot())
                 raise NoCodeException(self.agent.user_id)
         else:
             raise OtpNotSetException(self.agent.user_id)
         await self.page.fill("#securityValue", code)
         await self.page.locator("input[type=submit]", has_text="confirm").click()
         await self.page.wait_for_url(self.pages.SEND)
+        tid = await self.page.text_content("ul.p-confirmation-info dl.success>dd")
         await self.page.get_by_role("heading").click()
-        slip = await self.page.screenshot(clip={"x": 440, "y": 205, "width": 420, "height": 360})
-        await self.bot.receive(f"{amount} to {dest} sent", photo=slip)
+        slip = await self.page.screenshot(clip={"x": 440, "y": 205, "width": 440, "height": 415})
+        await self.receive(f"{amount} to {dest} sent", photo=slip)
+        return tid, slip
 
-    async def go(self, url: Pages):
+    async def go(self, url: Pages, commit: bool = True):
         try:
-            await self.page.goto(url)
+            await self.page.goto(url, wait_until="commit" if commit else "domcontentloaded")
             if len(await self.page.content()) < 1000:  # todo: fix captcha symptom
                 await self.captcha_click()
         except Exception as e:
-            await self.bot.receive(repr(e), photo=await self.page.screenshot())
+            await self.receive(repr(e), photo=await self.page.screenshot())
             raise e
 
     async def send_cap_help(self, xcap: Locator):
         if await xcap.count():
             bb = await xcap.bounding_box(timeout=2000)
             byts = await self.page.screenshot(clip=bb)
-            await self.bot.receive("put x, y", photo=byts)
-            txt = await self.bot.bot.wait_from(self.bot.me.id, "xy", timeout=59)
+            await self.receive("put x, y", photo=byts)
+            txt = await self.ubot.wait_from(self.uid, "xy", timeout=59)  # todo: fix
             for xy in txt.split(";"):
                 px, py = xy
                 x, y = bb["x"] + bb["width"] * int(px) / 100, bb["y"] + bb["height"] * int(py) / 100
@@ -202,7 +226,7 @@ class Client(PmAgentClient):
         if await xcap.count():
             await self.send_cap_help(xcap)
         try:
-            await self.page.wait_for_url(lambda url: url != captcha_url)
+            await self.page.wait_for_url(lambda url: url != captcha_url, wait_until="commit")
         except TimeoutError:  # if page no changed -> captcha is undone
             await self.page.screenshot()
             raise CaptchaException(self.page.url)
@@ -233,41 +257,36 @@ class Client(PmAgentClient):
         ]
         [await Fiat.update_or_create({"amount": amount}, cred=cred) for cred, amount in creds]
 
-    async def stop(self):
-        # save state
-        self.agent.state = await self.page.context.storage_state()
-        await self.agent.save()
-        # closing
-        await self.bot.stop()
-        await self.gmail.stop()
-        await self.page.context.close()
-        await self.page.context.browser.close()
-
 
 async def _test():
     from x_model import init_db
     from xync_client.loader import TORM
 
     _ = await init_db(TORM, True)
-    logging.basicConfig(level=logging.DEBUG)
-    uid = 193017646
+    logging.basicConfig(level=logging.INFO)
+    abot = Bot(PAY_TOKEN)
     playwright: Playwright = await async_playwright().start()
-    agent = await PmAgent.get_or_none(pm__norm="volet", user__username_id=uid).prefetch_related(
-        "user__username__session"
-    )
-    if not agent:
-        raise Exception(f"No active user #{uid} with agent for volet!")
 
-    va = agent.client()
     try:
-        await va.start(playwright)
-        await va.send("alena.artemeva25@gmail.com", 7.98)
-        await va.wait_for_payments()
+        o = await models.Order.create(ad_id=7, exid=1, amount=900, cred_id=522, taker_id=419)
+        await o.fetch_related("cred__pmcur__cur", "ad")
+        pma = await models.PmAgent.get(
+            active=True,
+            auth__isnull=False,
+            pm_id=o.cred.pmcur.pm_id,
+            user__person__actors=o.ad.maker_id,
+            user__status=UserStatus.ACTIVE,
+        ).prefetch_related("pm", "user__gmail", "user__username__session")
+        t = models.Transfer(amount=9, created_at=now(), order=o)
+        pcl: Client = pma.client(abot)
+        pcl = await pcl.start(playwright, True, True)
+        await pcl.send(t)
+        await pcl.wait_for_payments()
     except TimeoutError as te:
-        await va.bot.receive(repr(te), photo=await va.page.screenshot())
+        await pcl.receive(repr(te), photo=await pcl.page.screenshot())
         raise te
     finally:
-        await va.stop()
+        await pcl.stop()
 
 
 if __name__ == "__main__":

xync_client/Pms/Volet/api.py

@@ -88,16 +88,17 @@ class APIClient:
     async def check_by_amount(self, amount: decimal, cur: str = "RUB", timeout: int = 5 * 60, past: int = 0):
         hist: list = self.make_request("history", {"transactionDirection": "INCOMING", "count": 3, "from": 0})
         if int(hist[0].amount) == int(amount):
-            return hist[0]
+            return hist[0]["amount"], hist[0]["id"]
         await sleep(period)
         past += period
         if past < timeout:
             return await self.check_by_amount(amount, cur, timeout, past)
-        return False
+        return None, None
 
     def check_by_id(self, tid: str):
-        t: dict = self.make_request("findTransaction", tid)
-        return t
+        if t := self.make_request("findTransaction", tid):
+            return t["amount"], t["id"]
+        return None, None
 
 
 async def main():

xync_client/loader.py

@@ -5,6 +5,7 @@ from xync_schema import models
 load_dotenv()
 
 NET_TOKEN = env("NET_TOKEN")
+PAY_TOKEN = env("PAY_TOKEN")
 PG_DSN = f"postgres://{env('POSTGRES_USER')}:{env('POSTGRES_PASSWORD')}@{env('POSTGRES_HOST', 'xyncdbs')}:{env('POSTGRES_PORT', 5432)}/{env('POSTGRES_DB', env('POSTGRES_USER'))}"
 TORM = {
     "connections": {"default": PG_DSN},

{xync_client-0.0.143.dist-info → xync_client-0.0.145.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xync-client
-Version: 0.0.143
+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.143.dist-info → xync_client-0.0.145.dist-info}/RECORD

@@ -1,16 +1,17 @@
 xync_client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 xync_client/details.py,sha256=21itVPCgAtaYRR1H9J9oYudj95gafcFjExUN6QL17OI,1330
-xync_client/loader.py,sha256=zhslCMgtgp-xINPG4qQwhI1ee5Ap1vuoC8oK7GyhyMw,571
+xync_client/loader.py,sha256=hxf8ob50DO7r_qjr2qBoO7IyjkXeHHzVQ63YjXerjoU,600
 xync_client/pm_unifier.py,sha256=T2Xh-tvcu114P2YBI6RK_XDiaIhyq6ABMrXDuXPlx7A,6541
-xync_client/Abc/Agent.py,sha256=OJaJ1RIMDYAS4xeefeXxVIVI0EKnMczQtrO35MLzqr4,5390
+xync_client/Abc/Agent.py,sha256=S2f8VEejC3LHT7oUJhilZCYuhcQVREX-3uzfc06ZyO4,5633
 xync_client/Abc/Asset.py,sha256=hlgyFaU9byr2N2r8Heh-_ICx49SKuKxfRTUA4yQWmEw,454
 xync_client/Abc/Auth.py,sha256=OPQXN7_XYQZP9431ylFksd6JDusbKG8N_1g6CXTZ6yY,1495
 xync_client/Abc/BaseTest.py,sha256=vaAs5Z4HYV7k_C3zQz6JKO75s2hXtVbBI3-0Srkzv5Q,2388
 xync_client/Abc/Ex.py,sha256=n41-XCjoIV-KpC_lK3jO049tQKbFmE0eDU3SDlgZTws,12986
 xync_client/Abc/Exception.py,sha256=Sts7RpP370NBdjaH_cyXDdHtjge8zXNUGWCrKw49Zyk,482
-xync_client/Abc/InAgent.py,sha256=svKGATUM0c9YIDDEVLc-NxpUNWqZoVr5PjxoxK64RKs,650
+xync_client/Abc/HasAbotUid.py,sha256=LsTHHjMHBauCwJoqgDa9Lx4R6xsDOHfsN4jM539Bpqg,279
+xync_client/Abc/InAgent.py,sha256=XLf5czbxxEimsIIe653buoP7OsWZD6mc2w37q4TkNd0,703
 xync_client/Abc/Order.py,sha256=7-FGIJu5z9aYi0A_eJV4F-cp_6Mz_izNpefexDQZvHw,2428
-xync_client/Abc/PmAgent.py,sha256=wS1ZQs-hcC8ICDLcc9EfyNBKrM_ZDpJolAg-l_5ro-8,4094
+xync_client/Abc/PmAgent.py,sha256=5ihM_TY40SzHT4lZ_BDYtO1lqQoVAO3aXy_W8hRICHs,4359
 xync_client/Abc/xtype.py,sha256=o1JEzWmEXCPddtlqWZ6HRTZTKX6SAnvsztbASj21zOQ,2584
 xync_client/Binance/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 xync_client/Binance/binance_async.py,sha256=LP2DZaHwkfsp_4Tjvetb-1ntjQtJfODF0OgZpoPx4KU,2688
@@ -34,8 +35,8 @@ xync_client/BitGet/agent.py,sha256=YVs3bDY0OcEJGU7m2A8chzO6PFhWDnQQrA-E6MVkBBg,3
 xync_client/BitGet/ex.py,sha256=uEvvXuLaJv8o8BFi0bMA3XyBuTfVDWagAjLOHZl-xlE,3765
 xync_client/BitGet/etype/ad.py,sha256=fysSW47wGYjSOPUqY864z857AJz4gjN-nOkI1Jxd27U,1838
 xync_client/BitPapa/ex.py,sha256=U-RRB_RSOtErfRgxOZYWegZ_td_uZO37YKo3Jxchf_w,912
-xync_client/Bybit/InAgent.py,sha256=QQTRWcZXhNO-AZi9wfCAA-x24FIRL00_f4T5xCVgC10,25324
-xync_client/Bybit/agent.py,sha256=fz76f-6g81TnFoFqWX0AqMaKvnYzgYKfhpkckIOM0cM,61769
+xync_client/Bybit/InAgent.py,sha256=50c9LGJuxe2T3qOL_2qNWIesJHmlmaj-oSx8dDnk9sY,26002
+xync_client/Bybit/agent.py,sha256=wGYzvHGuKomNfEvFmosXQVscx9VXlzexc1Ic8sm-wA4,61894
 xync_client/Bybit/ex.py,sha256=3oARvReBoDs90FzQY31-L-q_YU-TIRbvWB7z4lwESsA,4715
 xync_client/Bybit/order.py,sha256=H4UIb8hxFGnw1hZuSbr0yZ4qeaCOIZOMc6jEst0ycBs,1713
 xync_client/Bybit/web_earn.py,sha256=qjqS10xlFc8r40IhDdPZ0LxA2dFEGbvBGXdsrUUJCMo,3019
@@ -47,7 +48,7 @@ xync_client/Bybit/etype/order.py,sha256=rPXw9eHJW3afVPQDRiooUkHfQhmqJ5fTdZ4vKdO6
 xync_client/Gate/ex.py,sha256=QbhB3u7TWnvVGD-AknB2nay6KZjEXQ-1JT9UacX4sWI,3735
 xync_client/Gate/premarket.py,sha256=IW-CgkmNJePJR2j_NRfULNKTePMX35XlhldqdiO76zY,2138
 xync_client/Gate/etype/ad.py,sha256=-EwtFcOWWvtE6UjaOdsuXWDTCVjAIRK0kSEsqPP4Yls,1296
-xync_client/Gmail/__init__.py,sha256=YYMDDstX8f_LVGLvqmNJi07I8BMqWhfAhLZuFQKcqcA,4687
+xync_client/Gmail/__init__.py,sha256=wNEUA1L9lvLtYoIv2fHEsb6msO9oB9QTF2OkzuCPMcM,4778
 xync_client/Htx/agent.py,sha256=rOURgTeY9TsA-IzT78l5-Ze91i0x1PY683mrX38MSgs,7356
 xync_client/Htx/earn.py,sha256=jL6eRwytZEMRom_3bFm1DYthi_GFg-E1Mm3ZDXENHSg,2386
 xync_client/Htx/ex.py,sha256=GuWK5lA_MvtSd-0DhKf2MAstKvZMHhc3BIiZSgdwZv4,6074
@@ -72,14 +73,14 @@ xync_client/Pms/Alfa/state.json,sha256=MKE6vl-JsJO9PNCVqoQgBgYZTgYkHCas7USwl8QFt
 xync_client/Pms/MTS/__init__.py,sha256=P_E7W46IZEk8RsEgl7H1xV3JplMT5l9vYQYTYyNbyQ8,2101
 xync_client/Pms/Ozon/__init__.py,sha256=EvQZDSPv0fOT2hNCTP44nXHOIEQvP5bQf_7HVLiZc2I,4123
 xync_client/Pms/Payeer/.gitignore,sha256=sWORdRp8ROppV2CsMEDJ3M_SokrNWCf8b1hlaNs64hg,12
-xync_client/Pms/Payeer/__init__.py,sha256=xN3L-IURWJ6oYXq85qu34u0OZEQOXkshgeEuMG29qg8,9584
+xync_client/Pms/Payeer/__init__.py,sha256=fxYbRHq1x1pCKQuo-blydZBWrYMSebuYZjRrD6k-e-E,9905
 xync_client/Pms/Payeer/api.py,sha256=bb8qrlPYyWafel1VR-2nate6xBeRZAVciFJblHygfAs,549
-xync_client/Pms/Payeer/login.py,sha256=W5FAA0reW5x2hSh8sBIWmR38VcYhwvrn1R64IAtWHVw,2921
+xync_client/Pms/Payeer/login.py,sha256=GyNwB-GKE_1nlkbZJ0KNI-EnCT0j_S9ogFdn-ufb-zU,3053
 xync_client/Pms/Sber/__init__.py,sha256=dxQfd9ZPhFTc_C4xrwaxrV6p0SijDCLNzBeUv3oQG38,4926
 xync_client/Pms/Sber/utils.py,sha256=gIeJspwvoBbOBt-fjxwW4WDHPoL2Evs8LVufsjrFOfo,1870
 xync_client/Pms/Tinkoff/__init__.py,sha256=ZyLvBEUn-vh-85oPUUDS586AHgvx3c-mkQE3yBQtbw8,5580
-xync_client/Pms/Volet/__init__.py,sha256=v-45Qu1MgUuMfRXnwvzsEDA3s6AJ0-50B_J3vHS0Hws,10728
-xync_client/Pms/Volet/api.py,sha256=okqppqT7M5E6sswu-xz3L4Y9-ngefBPbFtywRi6A7Xo,3595
+xync_client/Pms/Volet/__init__.py,sha256=Zn15NJRZH9pwwVjiR1Ao77MN6mTaA45B42fr0NJweno,12047
+xync_client/Pms/Volet/api.py,sha256=6_dH2rzmyyvha3PeoiZdSltiAzKDWn8roSUJOAErX4M,3673
 xync_client/Pms/Volet/pl.py,sha256=l7lvUrpjFoObXPHaseOIAcSbkNqJdpy6OLDutxYJH3U,2451
 xync_client/Pms/Volet/_todo_req/req.mjs,sha256=ut3Jw37rL5lY7SskjZ9f1l0VE33tuP-PZEYUTcJMc2I,817
 xync_client/Pms/Volet/_todo_req/req.py,sha256=mKvdPrb-lkQ98Ws92_oBKu5yqyU8Krxy9XwuIhdsBao,1570
@@ -95,7 +96,7 @@ xync_client/TgWallet/order.py,sha256=BOmBx5WWfJv0-_-A8DcR-Xd8utqO_VTmSqSegm0cteQ
 xync_client/TgWallet/pyd.py,sha256=Ys3E8b3RLuyQ26frWT0F0BorkNxVpxnd18tY4Gp9dik,5636
 xync_client/TgWallet/pyro.py,sha256=2K7QWdo48k4MbbgQt90gdz_HiPck69Njm4xaMjIVgoo,1440
 xync_client/TgWallet/web.py,sha256=kDcv9SKKQPe91mw1qJBpbuyKYCAmZdfdHJylHumLBVU,1608
-xync_client-0.0.143.dist-info/METADATA,sha256=ihkIz-z4Ih0vWS2ohLWk4clvAKj4IbviGfNeFVHUJaU,1037
-xync_client-0.0.143.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-xync_client-0.0.143.dist-info/top_level.txt,sha256=bmYEVIIrD3v7yFwH-X15pEfRvzhuAdfsAZ2igvNI4O8,12
-xync_client-0.0.143.dist-info/RECORD,,
+xync_client-0.0.145.dist-info/METADATA,sha256=Czpg727G7V7cQcbZ7mDkx0Egv3bf3xtoSgH5K1Y8QgU,1037
+xync_client-0.0.145.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+xync_client-0.0.145.dist-info/top_level.txt,sha256=bmYEVIIrD3v7yFwH-X15pEfRvzhuAdfsAZ2igvNI4O8,12
+xync_client-0.0.145.dist-info/RECORD,,