xync-client 0.0.100__tar.gz → 0.0.155.dev2__tar.gz

{xync_client-0.0.100/xync_client.egg-info → xync_client-0.0.155.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xync-client
-Version: 0.0.100
+Version: 0.0.155.dev2
 Author-email: Mike Artemiev <mixartemev@gmail.com>
 Project-URL: Homepage, https://gitlab.com/XyncNet/client
 Project-URL: Repository, https://gitlab.com/XyncNet/client
@@ -8,12 +8,18 @@ Requires-Python: >=3.11
 Requires-Dist: asynchuobi
 Requires-Dist: bs4
 Requires-Dist: bybit-p2p
+Requires-Dist: google-api-python-client
+Requires-Dist: google-auth-httplib2
+Requires-Dist: google-auth-oauthlib
 Requires-Dist: requests-toolbelt
 Requires-Dist: msgspec
 Requires-Dist: python-binance
 Requires-Dist: pybit
 Requires-Dist: pyotp
+Requires-Dist: pypng
 Requires-Dist: kurigram
+Requires-Dist: payeer-api
+Requires-Dist: playwright
 Requires-Dist: python-dotenv
 Requires-Dist: python-okx
 Requires-Dist: pyrogram-client

{xync_client-0.0.100 → xync_client-0.0.155.dev2}/pyproject.toml

@@ -10,13 +10,19 @@ dependencies = [
     "asynchuobi",
     "bs4",
     "bybit-p2p",
+    "google-api-python-client",
+    "google-auth-httplib2",
+    "google-auth-oauthlib",
     "requests-toolbelt",
     "msgspec",
     "python-binance",
     "pybit",
     "pyotp",
+    "pypng",
 #    "kurigram @ git+https://github.com/mixartemev/pyrogram.git",
     "kurigram",
+    "payeer-api",
+    "playwright",
     "python-dotenv",
     "python-okx",
     "pyrogram-client",

{xync_client-0.0.100 → xync_client-0.0.155.dev2}/tests/TestEx.py

@@ -84,13 +84,13 @@ class TestEx(BaseTest):
     #         logging.info(f"{client.ex.name}: {ExAction.cur_pms_map.name} - ok")
 
     # 22
-    # async def test_coins(self, clients: list[BaseExClient]):
-    #     for client in clients:
-    #         coins: dict[str, CoinEx] = await client.coins()
-    #         ok = self.is_dict_of_objects(coins, CoinEx)
-    #         t, _ = await ExStat.update_or_create({"ok": ok}, ex=client.ex, action=ExAction.coins)
-    #         assert t.ok, "No coins"
-    #         logging.info(f"{client.ex.name}: {ExAction.coins.name} - ok")
+    async def test_coins(self, clients: list[BaseExClient]):
+        for client in clients:
+            coins: dict[str, models.CoinEx] = await client.coins()
+            ok = self.is_dict_of_objects(coins, models.CoinEx)
+            t, _ = await models.ExStat.update_or_create({"ok": ok}, ex=client.ex, action=ExAction.coins)
+            assert t.ok, "No coins"
+            logging.info(f"{client.ex.name}: {ExAction.coins.name} - ok")
 
     # # 23
     # async def test_pairs(self, clients: list[BaseExClient]):

xync_client-0.0.155.dev2/xync_client/Abc/AdLoader.py

@@ -0,0 +1,299 @@
+import logging
+import re
+from asyncio import sleep
+from collections import defaultdict
+from difflib import SequenceMatcher
+
+from tortoise.exceptions import OperationalError, IntegrityError
+from xync_schema import models
+from xync_schema.xtype import BaseAd
+
+
+class AdLoader:
+    ex: models.Ex
+    all_conds: dict[int, tuple[str, set[int]]] = {}
+    cond_sims: dict[int, int] = defaultdict(set)
+    rcond_sims: dict[int, set[int]] = defaultdict(set)  # backward
+    tree: dict = {}
+
+    async def old_conds_load(self):
+        # пока не порешали рейс-кондишн, очищаем сиротские условия при каждом запуске
+        # [await c.delete() for c in await Cond.filter(ads__isnull=True)]
+        self.all_conds = {
+            c.id: (c.raw_txt, {a.maker.exid for a in c.ads})
+            for c in await models.Cond.all().prefetch_related("ads__maker")
+        }
+        for curr, old in await models.CondSim.filter().values_list("cond_id", "cond_rel_id"):
+            self.cond_sims[curr] = old
+            self.rcond_sims[old] |= {curr}
+
+        self.build_tree()
+        a = set()
+
+        def check_tree(tre):
+            for p, c in tre.items():
+                a.add(p)
+                check_tree(c)
+
+        for pr, ch in self.tree.items():
+            check_tree(ch)
+        if ct := set(self.tree.keys()) & a:
+            logging.exception(f"cycle cids: {ct}")
+
+    async def person_name_update(self, name: str, exid: int) -> models.Person:
+        if actor := await models.Actor.get_or_none(exid=exid, ex=self.ex).prefetch_related("person"):
+            actor.person.name = name
+            await actor.person.save()
+            return actor.person
+        # tmp dirty fix
+        note = f"{self.ex.id}:{exid}"
+        if person := await models.Person.get_or_none(note__startswith=note):
+            person.name = name
+            await person.save()
+            return person
+        try:
+            return await models.Person.create(name=name, note=note)
+        except OperationalError as e:
+            raise e
+        await models.Actor.create(person=person, exid=exid, ex=self.ex)
+        return person
+        # person = await models.Person.create(note=f'{actor.ex_id}:{actor.exid}:{name}') # no person for just ads with no orders
+        # raise ValueError(f"Agent #{exid} not found")
+
+    async def ad_load(
+        self,
+        pad: BaseAd,
+        cid: int = None,
+        ps: models.PairSide = None,
+        maker: models.Actor = None,
+        coinex: models.CoinEx = None,
+        curex: models.CurEx = None,
+        rname: str = None,
+    ) -> models.Ad:
+        if not maker:
+            if not (maker := await models.Actor.get_or_none(exid=pad.userId, ex=self.ex)):
+                person = await models.Person.create(name=rname, note=f"{self.ex.id}:{pad.userId}:{pad.nickName}")
+                maker = await models.Actor.create(name=pad.nickName, person=person, exid=pad.userId, ex=self.ex)
+        if rname:
+            await self.person_name_update(rname, int(pad.userId))
+        ps = ps or await models.PairSide.get_or_none(
+            is_sell=pad.side,
+            pair__coin__ticker=pad.tokenId,
+            pair__cur__ticker=pad.currencyId,
+        ).prefetch_related("pair")
+        # if not ps or not ps.pair:
+        #     ...  # THB/USDC: just for initial filling
+        ad_upd = models.Ad.validate(pad.model_dump(by_alias=True))
+        cur_scale = 10 ** (curex or await models.CurEx.get(cur_id=ps.pair.cur_id, ex=self.ex)).scale
+        coin_scale = 10 ** (coinex or await models.CoinEx.get(coin_id=ps.pair.coin_id, ex=self.ex)).scale
+        amt = int(float(pad.quantity) * float(pad.price) * cur_scale)
+        mxf = pad.maxAmount and int(float(pad.maxAmount) * cur_scale)
+        df_unq = ad_upd.df_unq(
+            maker_id=maker.id,
+            pair_side_id=ps.id,
+            amount=amt if amt < 4_294_967_295 else 4_294_967_295,
+            quantity=int(float(pad.quantity) * coin_scale),
+            min_fiat=int(float(pad.minAmount) * cur_scale),
+            max_fiat=mxf if mxf < 4_294_967_295 else 4_294_967_295,
+            price=int(float(pad.price) * cur_scale),
+            premium=int(float(pad.premium) * 100),
+            cond_id=cid,
+            status=self.ad_status(ad_upd.status),
+        )
+        try:
+            ad_db, _ = await models.Ad.update_or_create(**df_unq)
+        except OperationalError as e:
+            raise e
+        await ad_db.pms.add(*(await models.Pm.filter(pmexs__ex=self.ex, pmexs__exid__in=pad.payments)))
+        return ad_db
+
+    async def cond_load(  # todo: refact from Bybit Ad format to universal
+        self,
+        ad: BaseAd,
+        ps: models.PairSide = None,
+        force: bool = False,
+        rname: str = None,
+        coinex: models.CoinEx = None,
+        curex: models.CurEx = None,
+        pms_from_cond: bool = False,
+    ) -> tuple[models.Ad, bool]:
+        _sim, cid = None, None
+        ad_db = await models.Ad.get_or_none(exid=ad.id, maker__ex=self.ex).prefetch_related("cond")
+        # если точно такое условие уже есть в бд
+        if not (cleaned := clean(ad.remark)) or (cid := {oc[0]: ci for ci, oc in self.all_conds.items()}.get(cleaned)):
+            # и объява с таким ид уже есть, но у нее другое условие
+            if ad_db and ad_db.cond_id != cid:
+                # то обновляем ид ее условия
+                ad_db.cond_id = cid
+                await ad_db.save()
+                logging.info(f"{ad.nickName} upd cond#{ad_db.cond_id}->{cid}")
+                # old_cid = ad_db.cond_id # todo: solve race-condition, а пока что очищаем при каждом запуске
+                # if not len((old_cond := await Cond.get(id=old_cid).prefetch_related('ads')).ads):
+                #     await old_cond.delete()
+                #     logging.warning(f"Cond#{old_cid} deleted!")
+            return (ad_db or force and await self.ad_load(ad, cid, ps, coinex=coinex, curex=curex, rname=rname)), False
+        # если эта объява в таким ид уже есть в бд, но с другим условием (или без), а текущего условия еще нет в бд
+        if ad_db:
+            await ad_db.fetch_related("cond__ads", "maker")
+            if not ad_db.cond_id or (
+                # у измененного условия этой объявы есть другие объявы?
+                (rest_ads := set(ad_db.cond.ads) - {ad_db})
+                and
+                # другие объявы этого условия принадлежат другим юзерам
+                {ra.maker_id for ra in rest_ads} - {ad_db.maker_id}
+            ):
+                # создадим новое условие и присвоим его только текущей объяве
+                cond = await self.cond_new(cleaned, {int(ad.userId)})
+                ad_db.cond_id = cond.id
+                await ad_db.save()
+                ad_db.cond = cond
+                return ad_db, True
+            # а если других объяв со старым условием этой обявы нет, либо они все этого же юзера
+            # обновляем условие (в тч во всех ЕГО объявах)
+            ad_db.cond.last_ver = ad_db.cond.raw_txt
+            ad_db.cond.raw_txt = cleaned
+            try:
+                await ad_db.cond.save()
+            except IntegrityError as e:
+                raise e
+            await self.cond_upd(ad_db.cond, {ad_db.maker.exid})
+            # и подправим коэфициенты похожести нового текста
+            await self.fix_rel_sims(ad_db.cond_id, cleaned)
+            return ad_db, False
+
+        cond = await self.cond_new(cleaned, {int(ad.userId)})
+        ad_db = await self.ad_load(ad, cond.id, ps, coinex=coinex, curex=curex, rname=rname)
+        ad_db.cond = cond
+        return ad_db, True
+
+    async def cond_new(self, txt: str, uids: set[int]) -> models.Cond:
+        new_cond, _ = await models.Cond.update_or_create(raw_txt=txt)
+        # и максимально похожую связь для нового условия (если есть >= 60%)
+        await self.cond_upd(new_cond, uids)
+        return new_cond
+
+    async def cond_upd(self, cond: models.Cond, uids: set[int]):
+        self.all_conds[cond.id] = cond.raw_txt, uids
+        # и максимально похожую связь для нового условия (если есть >= 60%)
+        old_cid, sim = await self.cond_get_max_sim(cond.id, cond.raw_txt, uids)
+        await self.actual_sim(cond.id, old_cid, sim)
+
+    def find_in_tree(self, cid: int, old_cid: int) -> bool:
+        if p := self.cond_sims.get(old_cid):
+            if p == cid:
+                return True
+            return self.find_in_tree(cid, p)
+        return False
+
+    async def cond_get_max_sim(self, cid: int, txt: str, uids: set[int]) -> tuple[int | None, int | None]:
+        # находим все старые тексты похожие на 90% и более
+        if len(txt) < 15:
+            return None, None
+        sims: dict[int, int] = {}
+        for old_cid, (old_txt, old_uids) in self.all_conds.items():
+            if len(old_txt) < 15 or uids == old_uids:
+                continue
+            elif not self.can_add_sim(cid, old_cid):
+                continue
+            if sim := get_sim(txt, old_txt):
+                sims[old_cid] = sim
+        # если есть, берем самый похожий из них
+        if sims:
+            old_cid, sim = max(sims.items(), key=lambda x: x[1])
+            await sleep(0.3)
+            return old_cid, sim
+        return None, None
+
+    def can_add_sim(self, cid: int, old_cid: int) -> bool:
+        if cid == old_cid:
+            return False
+        elif self.cond_sims.get(cid) == old_cid:
+            return False
+        elif self.find_in_tree(cid, old_cid):
+            return False
+        elif self.cond_sims.get(old_cid) == cid:
+            return False
+        elif cid in self.rcond_sims.get(old_cid, {}):
+            return False
+        elif old_cid in self.rcond_sims.get(cid, {}):
+            return False
+        return True
+
+    async def fix_rel_sims(self, cid: int, new_txt: str):
+        for rel_sim in await models.CondSim.filter(cond_rel_id=cid).prefetch_related("cond"):
+            if sim := get_sim(new_txt, rel_sim.cond.raw_txt):
+                rel_sim.similarity = sim
+                await rel_sim.save()
+            else:
+                await rel_sim.delete()
+
+    async def actual_cond(self):
+        for curr, old in await models.CondSim.all().values_list("cond_id", "cond_rel_id"):
+            self.cond_sims[curr] = old
+            self.rcond_sims[old] |= {curr}
+        for cid, (txt, uids) in self.all_conds.items():
+            old_cid, sim = await self.cond_get_max_sim(cid, txt, uids)
+            await self.actual_sim(cid, old_cid, sim)
+            # хз бля чо это ваще
+            # for ad_db in await models.Ad.filter(direction__pairex__ex=self.ex).prefetch_related("cond", "maker"):
+            #     ad = Ad(id=str(ad_db.exid), userId=str(ad_db.maker.exid), remark=ad_db.cond.raw_txt)
+            #     await self.cond_upsert(ad, force=True)
+
+    async def actual_sim(self, cid: int, old_cid: int, sim: int):
+        if not sim:
+            return
+        if old_sim := await models.CondSim.get_or_none(cond_id=cid):
+            if old_sim.cond_rel_id != old_cid:
+                if sim > old_sim.similarity:
+                    logging.warning(f"R {cid}: {old_sim.similarity}->{sim} ({old_sim.cond_rel_id}->{old_cid})")
+                    await old_sim.update_from_dict({"similarity": sim, "old_rel_id": old_cid}).save()
+                    self._cond_sim_upd(cid, old_cid)
+            elif sim != old_sim.similarity:
+                logging.info(f"{cid}: {old_sim.similarity}->{sim}")
+                await old_sim.update_from_dict({"similarity": sim}).save()
+        else:
+            await models.CondSim.create(cond_id=cid, cond_rel_id=old_cid, similarity=sim)
+            self._cond_sim_upd(cid, old_cid)
+
+    def _cond_sim_upd(self, cid: int, old_cid: int):
+        if old_old_cid := self.cond_sims.get(cid):  # если старый cid уже был в дереве:
+            self.rcond_sims[old_old_cid].remove(cid)  # удаляем из обратного
+        self.cond_sims[cid] = old_cid  # а в прямом он автоматом переопределится, даже если и был
+        self.rcond_sims[old_cid] |= {cid}  # ну и в обратное добавим новый
+
+    def build_tree(self):
+        set(self.cond_sims.keys()) | set(self.cond_sims.values())
+        tree = defaultdict(dict)
+        # Группируем родителей по детям
+        for child, par in self.cond_sims.items():
+            tree[par] |= {child: {}}  # todo: make from self.rcond_sim
+
+        # Строим дерево снизу вверх
+        def subtree(node):
+            if not node:
+                return node
+            for key in node:
+                subnode = tree.pop(key, {})
+                d = subtree(subnode)
+                node[key] |= d  # actual tree rebuilding here!
+            return node  # todo: refact?
+
+        # Находим корни / без родителей
+        roots = set(self.cond_sims.values()) - set(self.cond_sims.keys())
+        for root in roots:
+            _ = subtree(tree[root])
+
+        self.tree = tree
+
+
+def get_sim(s1, s2) -> int:
+    sim = int((SequenceMatcher(None, s1, s2).ratio() - 0.6) * 10_000)
+    return sim if sim > 0 else 0
+
+
+def clean(s) -> str:
+    clear = r"[^\w\s.,!?;:()\-]"
+    repeat = r"(.)\1{2,}"
+    s = re.sub(clear, "", s).lower()
+    s = re.sub(repeat, r"\1", s)
+    return s.replace("\n\n", "\n").replace("  ", " ").strip(" \n/.,!?-")

{xync_client-0.0.100 → xync_client-0.0.155.dev2}/xync_client/Abc/Agent.py

@@ -1,21 +1,80 @@
 from abc import abstractmethod
+from asyncio.tasks import gather
+from collections import defaultdict
 
+from playwright.async_api import async_playwright
 from pydantic import BaseModel
 from pyro_client.client.file import FileClient
+from x_client import df_hdrs
 from x_client.aiohttp import Client as HttpClient
+from xync_bot import XyncBot
+from xync_client.Abc.PmAgent import PmAgentClient
+from xync_schema.enums import UserStatus
+
+from xync_client.Abc.InAgent import BaseInAgentClient
+
+from xync_client.Bybit.etype.order import TakeAdReq
 from xync_schema import models
-from xync_schema.models import OrderStatus, Coin, Cur, Ad, AdStatus, Actor
+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
-
-
-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)
+from xync_client.Abc.xtype import CredExOut, BaseOrderReq, BaseAdUpdate, AdUpd
+from xync_client.Gmail import GmClient
+
+
+class BaseAgentClient(HttpClient, BaseInAgentClient):
+    actor: Actor
+    agent: Agent
+    bbot: XyncBot
+    fbot: FileClient
+    ex_client: BaseExClient
+    pm_clients: dict[int, PmAgentClient]  # {pm_id: PmAgentClient}
+
+    def __init__(
+        self,
+        agent: Agent,
+        ex_client: BaseExClient,
+        fbot: FileClient,
+        bbot: XyncBot,
+        headers: dict[str, str] = df_hdrs,
+        cookies: dict[str, str] = None,
+    ):
+        self.bbot = bbot
+        self.fbot = fbot
+        self.agent: Agent = agent
+        self.actor: Actor = agent.actor
+        self.gmail = agent.actor.person.user.gmail and GmClient(agent.actor.person.user)
+        self.ex_client: BaseExClient = ex_client
+        self.pm_clients: dict[int, PmAgentClient] = defaultdict()
+        super().__init__(self.actor.ex.host_p2p, headers, cookies)
+
+    async def start(self, debug: bool = False):
+        tasks = []
+        if not self.is_started:
+            if self.agent.status & 1:  # race
+                tasks.append(self.start_race())
+
+            if self.agent.status & 2:  # in agent
+                if not self.pm_clients:
+                    pm_agents = await models.PmAgent.filter(
+                        active=True,
+                        auth__isnull=False,
+                        user__status=UserStatus.ACTIVE,
+                    ).prefetch_related("pm", "user__gmail")
+                    # payeer_cl = Client(actor.person.user.username_id)
+                    pw = await async_playwright().start()
+                    browser = await pw.chromium.launch(
+                        channel="chrome-beta" if debug else "chromium-headless-shell", headless=not debug
+                    )
+                    self.pm_clients = {pma.pm_id: pma.client(browser, self.bbot) for pma in pm_agents}
+                    [tasks.append(pmcl.start()) for pmcl in self.pm_clients.values()]
+                # tasks.append(self.start_listen())
+
+            if self.agent.status & 4:  # for further
+                ...
+            self.is_started = True
+        return await gather(*tasks)
 
     # 0: Получшение ордеров в статусе status, по монете coin, в валюте coin, в направлении is_sell: bool
     @abstractmethod
@@ -78,9 +137,31 @@ class BaseAgentClient(HttpClient):
     @abstractmethod
     async def ad_new(self, ad: BaseAd) -> Ad: ...
 
+    async def ad_upd(self, ad_upd_req: AdUpd) -> Ad:
+        pmex_exids = await models.PmEx.filter(ex_id=self.actor.ex_id, pm_id__in=ad_upd_req.pm_ids).values_list(
+            "exid", flat=True
+        )
+        credexs = await models.CredEx.filter(
+            ex_id=self.actor.ex_id,
+            cred__pmcur__pm_id__in=ad_upd_req.pm_ids,
+            cred__pmcur__cur_id=ad_upd_req.cur_id,
+            cred__person_id=self.actor.person_id,
+        ).prefetch_related("cred__pmcur")
+        coinex = await models.CoinEx.get(coin_id=ad_upd_req.coin_id, ex=self.ex_client.ex)
+        curex = await models.CurEx.get(cur_id=ad_upd_req.cur_id, ex=self.ex_client.ex)
+        # override
+        ad_upd_req.coin_id = coinex.exid
+        ad_upd_req.cur_id = curex.exid
+        ad_upd_req.pm_ids = pmex_exids
+        ad_upd_req.credexs = credexs
+        ad_upd_req.price = round(ad_upd_req.price, curex.scale)
+        ad_upd_req.amount = round(ad_upd_req.amount, curex.scale)
+        ad_upd_req.quantity = round(ad_upd_req.amount / ad_upd_req.price, coinex.scale)
+        return await self._ad_upd(ad_upd_req)
+
     # 31: Редактирование объявления
     @abstractmethod
-    async def ad_upd(self, ad: BaseAdUpdate) -> Ad: ...
+    async def _ad_upd(self, ad: BaseAdUpdate) -> Ad: ...
 
     # 32: Удаление
     @abstractmethod
@@ -115,6 +196,9 @@ class BaseAgentClient(HttpClient):
     @abstractmethod
     async def my_assets(self) -> dict: ...
 
+    @abstractmethod
+    async def take_ad(self, req: TakeAdReq): ...
+
     # Сохранение объявления (с Pm/Cred-ами) в бд
     # async def ad_pydin2db(self, ad_pydin: AdSaleIn | AdBuyIn) -> Ad:
     #     ad_db = await self.ex_client.ad_pydin2db(ad_pydin)

{xync_client-0.0.100 → xync_client-0.0.155.dev2}/xync_client/Abc/Ex.py

@@ -11,11 +11,13 @@ from xync_schema import models
 from xync_schema.enums import FileType
 from xync_schema.xtype import CurEx, CoinEx, BaseAd, BaseAdIn
 
-from xync_client.Abc.xtype import PmEx, MapOfIdsList
+from xync_client.Abc.AdLoader import AdLoader
+from xync_client.Abc.xtype import PmEx, MapOfIdsList, GetAds
 from xync_client.pm_unifier import PmUnifier, PmUni
 
 
-class BaseExClient(HttpClient):
+class BaseExClient(HttpClient, AdLoader):
+    host: str = None
     cur_map: dict[int, str] = {}
     unifier_class: type = PmUnifier
     logo_pre_url: str
@@ -33,7 +35,7 @@ class BaseExClient(HttpClient):
     ):
         self.ex = ex
         self.bot = bot
-        super().__init__(getattr(ex, attr), headers, cookies, proxy and proxy.str())
+        super().__init__(self.host or getattr(ex, attr), headers, cookies, proxy and proxy.str())
 
     @abstractmethod
     def pm_type_map(self, typ: models.PmEx) -> str: ...
@@ -62,16 +64,19 @@ class BaseExClient(HttpClient):
     @abstractmethod
     async def pairs(self) -> tuple[MapOfIdsList, MapOfIdsList]: ...
 
+    async def _x2e_ads(self, req: GetAds) -> GetAds:  # {ad.id: ad}
+        req.coin_id = await models.CoinEx.get(coin_id=req.coin_id, ex=self.ex).values_list("exid", flat=True)
+        req.cur_id = await models.CurEx.get(cur_id=req.cur_id, ex=self.ex).values_list("exid", flat=True)
+        req.pm_ids = await models.PmEx.filter(ex=self.ex, pm_id__in=req.pm_ids).values_list("exid", flat=True)
+        return req
+
     # 24: Список объяв по (buy/sell, cur, coin, pm)
+    async def ads(self, req: GetAds, lim: int = None, vm_filter: bool = False, **kwargs) -> list[BaseAd]:
+        return await self._ads(await self._x2e_ads(req), lim, vm_filter, **kwargs)
+
     @abstractmethod
-    async def ads(
-        self,
-        coin_exid: str,
-        cur_exid: str,
-        is_sell: bool,
-        pm_exids: list[str | int] = None,
-        amount: int = None,
-        lim: int = None,
+    async def _ads(
+        self, req: GetAds, lim: int = None, vm_filter: bool = False, **kwargs
     ) -> list[BaseAd]:  # {ad.id: ad}
         ...
 
@@ -91,9 +96,15 @@ class BaseExClient(HttpClient):
     async def set_curs(self, cookies: dict = None) -> bool:
         # Curs
         cur_pyds: dict[str, CurEx] = await self.curs()
+        old_curs = {c.ticker: c.id for c in await models.Cur.all()}
         curs: dict[int | str, models.Cur] = {
-            exid: (await models.Cur.update_or_create({"rate": cur_pyd.rate or 0}, ticker=cur_pyd.ticker))[0]
-            for exid, cur_pyd in cur_pyds.items()
+            exid: (
+                await models.Cur.update_or_create(
+                    {"rate": cur_pyd.rate or 0, "id": old_curs.get(cur_pyd.ticker, await models.Cur.all().count() + 1)},
+                    ticker=cur_pyd.ticker,
+                )
+            )[0]
+            for i, (exid, cur_pyd) in enumerate(cur_pyds.items())
         }
         curexs = [
             models.CurEx(**c.model_dump(exclude_none=True), cur=curs[c.exid], ex=self.ex) for c in cur_pyds.values()
@@ -209,7 +220,7 @@ class BaseExClient(HttpClient):
         coinexs: dict[str, CoinEx] = await self.coins()
         coins_db: dict[int, models.Coin] = {
             c.exid: (
-                await models.Coin.update_or_create({"scale": c.scale} if c.scale is not None else {}, ticker=c.ticker)
+                await models.Coin.update_or_create({"scale": c.scale or self.coin_scales[c.ticker]}, ticker=c.ticker)
             )[0]
             for c in coinexs.values()
         }
@@ -236,24 +247,22 @@ class BaseExClient(HttpClient):
         }
         prs: tuple[dict, dict] = await self.pairs()
         for is_sell in (0, 1):
-            pss: list[models.PairSide] = []
             for cur, coinz in prs[is_sell].items():
                 for coin in coinz:
                     pair, _ = await models.Pair.get_or_create(coin=coins[coin], cur=curs[cur])
                     # pairex, _ = await models.PairEx.get_or_create(pair=pair, ex=self.ex)  # todo: разные ли комишки на покупку и продажу?
-                    pss += [models.PairSide(is_sell=is_sell, pair=pair)]
-            await models.PairSide.bulk_create(pss, ignore_conflicts=True)
+                    await models.PairSide.update_or_create(is_sell=is_sell, pair=pair)
         return True
 
     # Сохранение чужого объявления (с Pm-ами) в бд
-    async def ad_pydin2db(self, ad_pydin: BaseAdIn) -> models.Ad:
-        dct = ad_pydin.model_dump()
-        dct["exid"] = dct.pop("id")
-        ad_in = models.Ad.validate(dct)
-        ad_db, _ = await models.Ad.update_or_create(**ad_in.df_unq())
-        await ad_db.credexs.add(*getattr(ad_pydin, "credexs_", []))
-        await ad_db.pmexs.add(*getattr(ad_pydin, "pmexs_", []))
-        return ad_db
+    # async def ad_pydin2db(self, ad_pydin: BaseAdIn) -> models.Ad:
+    #     dct = ad_pydin.model_dump()
+    #     dct["exid"] = dct.pop("id")
+    #     ad_in = models.Ad.validate(dct)
+    #     ad_db, _ = await models.Ad.update_or_create(**ad_in.df_unq())
+    #     await ad_db.credexs.add(*getattr(ad_pydin, "credexs_", []))
+    #     await ad_db.pmexs.add(*getattr(ad_pydin, "pmexs_", []))
+    #     return ad_db
 
     async def file_upsert(self, url: str, ss: ClientSession = None) -> models.File:
         if not (file := await models.File.get_or_none(name__startswith=url.split("?")[0])):
@@ -267,12 +276,12 @@ class BaseExClient(HttpClient):
                 # fr = await pbot.get_file(file.ref)  # check
         return file
 
-    async def _proc(self, resp: ClientResponse, data_key: str = None, bp: dict | str = None) -> dict | str:
+    async def _proc(self, resp: ClientResponse, bp: dict | str = None) -> dict | str:
         if resp.status in (403,):
             proxy = await models.Proxy.filter(valid=True, country__short__not="US").order_by("-updated_at").first()
             cookies = self.session.cookie_jar.filter_cookies(self.session._base_url)
             self.session = ClientSession(
                 self.session._base_url, headers=self.session.headers, cookies=cookies or None, proxy=proxy.str()
             )
-            return await self.METHS[resp.method](self, resp.url.path, bp, data_key=data_key)
-        return await super()._proc(resp, data_key, bp)
+            return await self.METHS[resp.method](self, resp.url.path, bp)
+        return await super()._proc(resp, bp)

xync_client-0.0.155.dev2/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.155.dev2/xync_client/Abc/InAgent.py

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