xync-client 0.0.25.dev0__tar.gz → 0.0.25.dev4__tar.gz

{xync_client-0.0.25.dev0/xync_client.egg-info → xync_client-0.0.25.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: xync-client
-Version: 0.0.25.dev0
+Version: 0.0.25.dev4
 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.25.dev0 → xync_client-0.0.25.dev4}/README.md

@@ -136,6 +136,8 @@ classDef red stroke:#f00
 - 22: Список торгуемых монет (с ограничениям по валютам, если есть) `coins() => [Coin]`
 - 23: Список пар валюта/монет `pairs() => [Pair]`
 - 24: Список объяв по (buy/sell, cur, coin, pm) `ads(coin: Coin, cur: Cur, is_sell: bool, pms:list[Pm]=None)`
+- 42: Минимальные объемы валют в объявлении `cur_mins() => FlatDict`
+- 43: Минимальные объемы монет в объявлении `coin_mins() => FlatDict`
 
 ### Fiat
 - 25: Список реквизитов моих платежных методов `my_fiats(cur:Cur=None) => [Fiat]`
@@ -162,4 +164,8 @@ classDef red stroke:#f00
 - 38N: Получение уведомления о полученном отзыве `got_rated => (user_id:int, order_id:int)`
 
 ### Assets
-- 39: Получить балансы моих монет: `my_assets() => list[Asset]`
+- 41: Получить балансы моих монет: `my_assets() => list[Asset]`
+- 40: Получить реквизиты для депозита монеты `deposit(amount: int) => bool` 
+- 40N: Получена монета `deposited => amount`
+- 41: Вывести монету `withdraw(amount: int) => bool`
+- 41N: Монета выведена `withdrew => amount`

{xync_client-0.0.25.dev0 → xync_client-0.0.25.dev4}/tests/TestEx.py

@@ -1,16 +1,20 @@
 import logging
 
 import pytest
+from xync_schema.pydantic import PmPyd, BaseAd
+
 from xync_client.Abc.BaseTest import BaseTest
 from xync_schema.enums import ExStatus, ExType, ExAction
 from xync_schema.models import Ex, TestEx as ExTest
 
-from xync_client.Abc.Base import BaseClient, DictOfDicts, FlatDict, MapOfIdsList
+from xync_client.Abc.Base import BaseClient, FlatDict, MapOfIdsList
 from xync_client.Abc.Ex import BaseExClient
 
 
 @pytest.mark.asyncio(loop_scope="session")
 class TestEx(BaseTest):
+    ad: dict[str, BaseAd] = {}
+
     @pytest.fixture
     async def clients(self) -> list[BaseClient]:
         exs = await Ex.filter(status__gt=ExStatus.plan)
@@ -26,15 +30,16 @@ class TestEx(BaseTest):
             ok = self.is_flat_dict(curs)
             t, _ = await ExTest.update_or_create({"ok": ok}, ex=client.ex, action=ExAction.curs)
             assert t.ok, "No curs"
-            logging.info(f"{client.ex.name}:{ExAction.curs.name} - ok")
+            logging.info(f"{client.ex.name}: {ExAction.curs.name} - ok")
 
     # 20
     async def test_pms(self, clients: list[BaseExClient]):
         for client in clients:
-            pms: DictOfDicts = await client.pms()
-            t, _ = await ExTest.update_or_create({"ok": self.is_dict_of_dicts(pms)}, ex=client.ex, action=ExAction.pms)
+            pms: dict[int | str, PmPyd] = await client.pms()
+            ok = self.is_dict_of_objects(pms, PmPyd)
+            t, _ = await ExTest.update_or_create({"ok": ok}, ex=client.ex, action=ExAction.pms)
             assert t.ok, "No pms"
-            logging.info(f"{client.ex.name}:{ExAction.pms.name} - ok")
+            logging.info(f"{client.ex.name}: {ExAction.pms.name} - ok")
 
     # 21
     async def test_cur_pms_map(self, clients: list[BaseExClient]):
@@ -43,7 +48,7 @@ class TestEx(BaseTest):
             ok = self.is_map_of_ids(cur_pms)
             t, _ = await ExTest.update_or_create({"ok": ok}, ex=client.ex, action=ExAction.cur_pms_map)
             assert t.ok, "No pms for cur"
-            logging.info(f"{client.ex.name}:{ExAction.cur_pms_map.name} - ok")
+            logging.info(f"{client.ex.name}: {ExAction.cur_pms_map.name} - ok")
 
     # 22
     async def test_coins(self, clients: list[BaseExClient]):
@@ -52,7 +57,7 @@ class TestEx(BaseTest):
             ok = self.is_flat_dict(coins)
             t, _ = await ExTest.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")
+            logging.info(f"{client.ex.name}: {ExAction.coins.name} - ok")
 
     # 23
     async def test_pairs(self, clients: list[BaseExClient]):
@@ -61,13 +66,23 @@ class TestEx(BaseTest):
             ok = self.is_map_of_ids(pairs)
             t, _ = await ExTest.update_or_create({"ok": ok}, ex=client.ex, action=ExAction.pairs)
             assert t.ok, "No coins"
-            logging.info(f"{client.ex.name}:{ExAction.pairs.name} - ok")
+            logging.info(f"{client.ex.name}: {ExAction.pairs.name} - ok")
 
     # 24
     async def test_ads(self, clients: list[BaseExClient]):
         for client in clients:
-            ads: FlatDict = await client.ads("USDT", "RUB", False)
-            ok = self.is_list_of_dicts(ads)
+            ads: list[BaseAd] = await client.ads("USDT", "RUB", False)
+            ok = self.is_list_of_objects(ads, BaseAd)
             t, _ = await ExTest.update_or_create({"ok": ok}, ex=client.ex, action=ExAction.ads)
             assert t.ok, "No ads"
-            logging.info(f"{client.ex.name}:{ExAction.ads.name} - ok")
+            self.ad[client.ex.name] = ads[0]  # for further use in test_ad
+            logging.info(f"{client.ex.name}: {ExAction.ads.name} - ok")
+
+    # 42
+    async def test_ad(self, clients: list[BaseExClient]):
+        for client in clients:
+            ad: BaseAd = await client.ad(self.ad[client.ex.name].id)
+            ok = isinstance(ad, BaseAd)
+            t, _ = await ExTest.update_or_create({"ok": ok}, ex=client.ex, action=ExAction.ad)
+            assert t.ok, "No ad"
+            logging.info(f"{client.ex.name}: {ExAction.ad.name} - ok")

{xync_client-0.0.25.dev0 → xync_client-0.0.25.dev4}/xync_client/Abc/Agent.py

@@ -83,7 +83,7 @@ class BaseAgentClient(BaseClient, BaseAuthTrait):  # todo: inherit form Base or
 
     # 25: Список реквизитов моих платежных методов
     @abstractmethod
-    async def fiats(self, cur: Cur = None) -> ListOfDicts: ...  # {fiat.exid: {fiat}}
+    async def fiats(self) -> ListOfDicts: ...  # {fiat.exid: {fiat}}
 
     @staticmethod
     async def fiat_pyd2db(fiat_pyd: FiatNew | FiatUpd, uid: int, fid: int = None) -> tuple[Fiat, bool]:

{xync_client-0.0.25.dev0 → xync_client-0.0.25.dev4}/xync_client/Abc/BaseTest.py

@@ -1,11 +1,8 @@
-from abc import abstractmethod
-
-# from asyncio import AbstractEventLoop
-from typing import TypeGuard
-
 import pytest
 
 # import uvloop
+from abc import abstractmethod
+from typing import TypeGuard
 from tortoise.backends.asyncpg import AsyncpgDBClient
 from x_model import init_db
 from xync_client.Abc.Base import BaseClient, DictOfDicts, ListOfDicts, FlatDict, MapOfIdsList
@@ -16,11 +13,9 @@ from xync_client.loader import PG_DSN
 
 class BaseTest:
     # loop: AbstractEventLoop
-
     # @pytest.fixture(scope="session", autouse=True)
     # def event_loop_policy(self):
     #     return uvloop.EventLoopPolicy()
-
     @pytest.fixture(scope="session", autouse=True)
     async def cn(self) -> AsyncpgDBClient:
         cn: AsyncpgDBClient = await init_db(PG_DSN, models, True)
@@ -37,12 +32,24 @@ class BaseTest:
             return False
         return all(isinstance(k, int | str) and isinstance(v, dict) for k, v in dct.items())
 
+    @staticmethod
+    def is_dict_of_objects(dct: dict, typ: type, not_empty: bool = True) -> TypeGuard[dict]:  # todo: Generic
+        if not_empty and not len(dct):
+            return False
+        return all(isinstance(k, int | str) and isinstance(v, typ) for k, v in dct.items())
+
     @staticmethod
     def is_list_of_dicts(lst: ListOfDicts, not_empty: bool = True) -> TypeGuard[ListOfDicts]:
         if not_empty and not len(lst):
             return False
         return all(isinstance(el, dict) for el in lst)
 
+    @staticmethod
+    def is_list_of_objects(lst: list, typ: type, not_empty: bool = True) -> TypeGuard[list]:
+        if not_empty and not len(lst):
+            return False
+        return all(isinstance(el, typ) for el in lst)
+
     @staticmethod
     def is_flat_dict(dct: FlatDict, not_empty: bool = True) -> TypeGuard[FlatDict]:
         if not_empty and not len(dct):

{xync_client-0.0.25.dev0 → xync_client-0.0.25.dev4}/xync_client/Abc/Ex.py

@@ -2,10 +2,10 @@ import logging
 import re
 from abc import abstractmethod
 
-from xync_client.pyd import PmXpyd, AdInXpyd
+from xync_schema.pydantic import AdPydIn, PmPyd, BaseAd
 from xync_schema.models import Ex, Coin, Cur, Pm, Pmex, Curex, Pmcur, Pmcurex, Coinex, PmexBank, Ad
 
-from xync_client.Abc.Base import BaseClient, DictOfDicts, FlatDict, ListOfDicts, MapOfIdsList
+from xync_client.Abc.Base import BaseClient, DictOfDicts, FlatDict, MapOfIdsList
 
 
 class BaseExClient(BaseClient):
@@ -33,7 +33,7 @@ class BaseExClient(BaseClient):
 
     # 20: Список платежных методов
     @abstractmethod
-    async def pms(self, cur: Cur = None) -> dict[int | str, PmXpyd]:  # {pm.exid: pm}
+    async def pms(self, cur: Cur = None) -> dict[int | str, PmPyd]:  # {pm.exid: pm}
         ...
 
     # 21: Список платежных методов по каждой валюте
@@ -54,9 +54,17 @@ class BaseExClient(BaseClient):
     @abstractmethod
     async def ads(
         self, coin_exid: str, cur_exid: str, is_sell: bool, pm_exids: list[str | int] = None, amount: int = None
-    ) -> ListOfDicts:  # {ad.id: ad}
+    ) -> list[BaseAd]:  # {ad.id: ad}
         ...
 
+    # 42: Объява по id
+    @abstractmethod
+    async def ad(self, ad_id: int) -> BaseAd: ...
+
+    # Преобразрование объекта объявления из формата биржи в формат xync
+    @abstractmethod
+    async def _ad_epyd2pydin(self, ad: BaseAd) -> AdPydIn: ...
+
     def _pmnorm(self, s: str) -> str:
         def get_and_remove_acro(title: str) -> str:
             acr = "".join(word[0] for word in title.split(" ") if len(word) > 1 and word.istitle())
@@ -117,9 +125,18 @@ class BaseExClient(BaseClient):
         s = remove(rm_rgxps, s, True)
         return s.replace(" ", "")
 
+    # 42: Минимальные объемы валют в объявлении
+    @abstractmethod
+    async def cur_mins(self) -> FlatDict: ...
+
+    # 43: Минимальные объемы монет в объявлении
+    @abstractmethod
+    async def coin_mins(self) -> FlatDict: ...
+
+    # Импорт Pm-ов (с Pmcur-, Pmex- и Pmcurex-ами) и валют (с Curex-ами) с биржи в бд
     async def set_pmcurexs(self):
         # Pms
-        pms_epyds: dict[int | str, PmXpyd] = {
+        pms_epyds: dict[int | str, PmPyd] = {
             k: v for k, v in sorted((await self.pms()).items(), key=lambda x: x[1].name)
         }  # sort by name
         pms: dict[int | str, Pm] = dict({})
@@ -129,11 +146,9 @@ class BaseExClient(BaseClient):
             if prev[1:] == (norm, pm.name):
                 logging.warning(f"Pm: '{pm.name}' duplicated with ids {prev[0]}: {k} on {self.ex.name}")
                 pm_ = pms.get(prev[0], (await Pm.get_or_none(name=prev[2])) or await Pm.get_or_none(identifier=prev[1]))
-                await Pmex.update_or_create({"pm": pm_}, ex=self.ex, exid=k, name=pm.name)
+                await Pmex.update_or_create({"pm": pm_, "name": pm.name}, ex=self.ex, exid=k)
             elif prev[1] == norm:
-                logging.error(
-                    f"Pm: '{pm.name}' & '{prev[2]}' overnormd as '{norm}' with ids {prev[0]}: {k} on {self.ex.name}"
-                )
+                logging.error(f"Pm: {pm.name}&{prev[2]} overnormd as {norm} with ids {prev[0]}: {k} on {self.ex.name}")
                 await Pmex.update_or_create(
                     {"pm": pms.get(prev[0], await Pm.get(name=prev[2]))}, ex=self.ex, exid=k, name=pm.name
                 )
@@ -146,16 +161,17 @@ class BaseExClient(BaseClient):
         # Pmex banks
         for k, pm in pms_epyds.items():
             if banks := pm.banks:
-                pmex = await Pmex.get(pm=pms[k], ex=self.ex, exid=k)
+                pmex = await Pmex.get(ex=self.ex, exid=k)  # pm=pms[k],
                 for b in banks:
-                    await PmexBank.update_or_create({"name": b.name}, exid=b.code, pmex=pmex)
+                    await PmexBank.update_or_create({"name": b.name}, exid=b.exid, pmex=pmex)
 
         # Curs
         cursd = await self.curs()
         curs: {int: Cur} = {k: (await Cur.update_or_create(ticker=c))[0] for k, c in cursd.items()}
         # Curex
-        curexs = [Curex(cur=c, ex=self.ex, exid=k) for k, c in curs.items()]  # , p2p=True
-        await Curex.bulk_create(curexs, ignore_conflicts=True)
+        cur_mins = await self.cur_mins()
+        curexs = [Curex(cur=c, ex=self.ex, exid=k, minimum=cur_mins[k]) for k, c in curs.items()]  # , p2p=True
+        await Curex.bulk_create(curexs, update_fields=["minimum"], on_conflict=["cur_id", "ex_id"])
 
         cur2pms = await self.cur_pms_map()
         # # Link PayMethods with currencies
@@ -173,12 +189,17 @@ class BaseExClient(BaseClient):
         pmcurexs = [Pmcurex(pmcur=pmcur, ex=self.ex) for pmcur in pmcurs]
         await Pmcurex.bulk_create(pmcurexs)
 
+    # Импорт монет (с Coinex-ами) с биржи в бд
     async def set_coinexs(self):
         res = await self.coins()
         coins: dict[int, Coin] = {k: (await Coin.update_or_create(ticker=c))[0] for k, c in res.items()}
-        coinexs: list[Coinex] = [Coinex(coin=c, ex=self.ex, exid=k) for k, c in coins.items()]
-        await Coinex.bulk_create(coinexs, ignore_conflicts=True)
-
-    async def set_ad(self, ad: AdInXpyd) -> Ad:
-        ad_db, _ = await Ad.update_or_create(ad.model_dump(), id=ad.id)
+        coin_mins = await self.coin_mins()
+        coinexs: list[Coinex] = [Coinex(coin=c, ex=self.ex, exid=k, minimum=coin_mins[k]) for k, c in coins.items()]
+        await Coinex.bulk_create(coinexs, update_fields=["minimum"], on_conflict=["coin_id", "ex_id"])
+
+    # Сохранение чужого объявления (с Pm-ами) в бд
+    async def set_ad(self, ad: BaseAd) -> Ad:
+        adx = await self._ad_epyd2pydin(ad)
+        ad_db, _ = await Ad.update_or_create(adx.model_dump(exclude_none=True), id=adx.id)
+        await ad_db.pms.add(*adx.payMeths)
         return ad_db

{xync_client-0.0.25.dev0 → xync_client-0.0.25.dev4}/xync_client/BitGet/ex.py

@@ -72,8 +72,8 @@ class ExClient(BaseExClient):
             result.append(
                 {
                     "price": float(slot["priceValue"]),
-                    "minFiat": float(slot["minAmount"]),
-                    "maxFiat": float(min(slot["maxAmount"], slot["amount"])),
+                    "min_fiat": float(slot["minAmount"]),
+                    "max_fiat": float(min(slot["maxAmount"], slot["amount"])),
                     "user": int(slot["userId"]) if slot["userId"] else None,
                     "pms": [int(pay_method["paymethodId"]) for pay_method in slot["paymethodInfo"]],
                 }

{xync_client-0.0.25.dev0 → xync_client-0.0.25.dev4}/xync_client/TgWallet/agent.py

@@ -2,19 +2,10 @@ from asyncio import run
 from enum import StrEnum
 
 from x_model import init_db, HTTPException, FailReason
+from xync_client.pyd import FiatXpyd
 from xync_schema import models
 
-from xync_client.TgWallet.pyd import (
-    Banks,
-    FiatEpyd,
-    Attrs,
-    AttrsV2,
-    MyAdEPydSale,
-    MyAdEPydPurchase,
-    AdEpydInPurchase,
-    AdEpydInSale,
-    AdEPyd,
-)
+from xync_client.TgWallet.pyd import Banks, FiatEpyd, Attrs, AttrsV2, MyAdInPurchaseEpyd, MyAdInSaleEpyd, AdFullEpyd
 from xync_client.loader import PG_DSN
 from xync_schema.enums import AdStatus
 
@@ -25,7 +16,6 @@ from xync_schema.pydantic import FiatNew
 
 from xync_client.Abc.Agent import BaseAgentClient
 from xync_client.TgWallet.ex import ExClient
-from xync_client.pyd import FiatXn
 
 
 class Exceptions(StrEnum):
@@ -50,11 +40,6 @@ class AgentClient(BaseAgentClient, AuthClient):
         )
         return order["data"]
 
-    # 0: Получение ордера по ид
-    async def settings(self) -> ListOfDicts:
-        settings = await self._post("/p2p/public-api/v2/offer/settings/get")
-        return settings["data"]
-
     # 0: Получение ордера по ид
     async def order(self, oid) -> ListOfDicts:
         orders = await self._post("/p2p/public-api/v2/offer/order/get", {"orderId": oid})
@@ -64,8 +49,8 @@ class AgentClient(BaseAgentClient, AuthClient):
     async def order_request(self, ad_id: int, amount: float) -> dict | bool:
         await self.agent.fetch_related("ex", "ex__agents")
         ex_client: ExClient = self.agent.ex.client()
-        ad: AdEPyd = await ex_client._get_ad(offer_id=ad_id)
-        fiats = await self.my_fiats()
+        ad: AdFullEpyd = await ex_client.ad(ad_id=ad_id)
+        fiats = await self.fiats()
         fiats_pms = {fiat["paymentMethod"]["code"]: fiat["id"] for fiat in fiats.values()}
         if not (pms := ad.get("paymentMethods")):
             print(ad)
@@ -128,18 +113,18 @@ class AgentClient(BaseAgentClient, AuthClient):
         }
 
     # 25: Список реквизитов моих платежных методов
-    async def fiats(self, _cur: Cur = None) -> list[FiatEpyd]:
+    async def fiats(self) -> list[FiatEpyd]:
         resp = await self._post("/p2p/public-api/v3/payment-details/get/by-user-id")
         return [FiatEpyd(**fiat) for fiat in resp["data"]]
 
-    async def fiat_epyd2xpyd(self, fiat: FiatEpyd) -> FiatXn:
+    async def fiat_epyd2xpyd(self, fiat: FiatEpyd) -> FiatXpyd:
         if not (pmex := await Pmex.get_or_none(exid=fiat.paymentMethod.code, ex=self.agent.ex)):
             raise HTTPException(FailReason.body, f"No Pmex {fiat.paymentMethod.code} on ex#{self.agent.ex.name}", 404)
         if not (pmcur := await Pmcur.get_or_none(cur__ticker=fiat.currency, pm_id=pmex.pm_id)):
             raise HTTPException(
                 FailReason.body, f"No Pmcur with cur#{fiat.currency} and pm#{fiat.paymentMethod.code}", 404
             )
-        ftx = FiatXn(
+        ftx = FiatXpyd(
             id=fiat.id,
             detail="",
             name=fiat.name,
@@ -232,7 +217,7 @@ class AgentClient(BaseAgentClient, AuthClient):
         )
         return (
             [
-                MyAdEPydSale(**ad) if ad["type"] == "SALE" else MyAdEPydPurchase(**ad)
+                MyAdEpydSale(**ad) if ad["type"] == "SALE" else MyAdEpydPurchase(**ad)
                 for ad in ads["data"]
                 if not status or (status and ad["status"] == mapping[status])
             ]
@@ -241,7 +226,7 @@ class AgentClient(BaseAgentClient, AuthClient):
         )
 
     # 30: Создание объявления
-    async def ad_new(self, ad: AdEpydInPurchase | AdEpydInSale) -> Ad:
+    async def ad_new(self, ad: MyAdInPurchaseEpyd | MyAdInSaleEpyd) -> Ad:
         # coin: Coin,
         # cur: str,
         # is_sell: bool,
@@ -255,7 +240,7 @@ class AgentClient(BaseAgentClient, AuthClient):
         # status: AdStatus = AdStatus.active,
         # ) -> Ad.pyd():
         dct = {
-            "type": typ,
+            "type": ad.type,
             "initVolume": {"currencyCode": coin, "amount": amount},
             "orderRoundingRequired": True,
             "price": {

{xync_client-0.0.25.dev0 → xync_client-0.0.25.dev4}/xync_client/TgWallet/ex.py

@@ -1,14 +1,15 @@
 from asyncio import run
+
 from x_model import init_db
-from xync_client.pyd import PmXpyd, AdInXpyd
+from xync_schema.pydantic import AdPydIn, PmPyd, PmexBankPyd
 
 from xync_schema import models
-from xync_schema.models import Ex, Agent, Direction, Pair, Coin, Cur
+from xync_schema.models import Ex, Agent, Direction, Pair, Coin, Cur, Pm
 
-from xync_client.TgWallet.pyd import AdFullEpyd, AdEpyd
+from xync_client.TgWallet.pyd import AdFullEpyd, AdEpyd, PmEpydRoot
 from xync_client.loader import PG_DSN
 from xync_client.Abc.Ex import BaseExClient
-from xync_client.Abc.Base import FlatDict, DictOfDicts, MapOfIdsList
+from xync_client.Abc.Base import FlatDict, MapOfIdsList
 from xync_client.TgWallet.auth import AuthClient
 
 
@@ -17,23 +18,42 @@ class ExClient(BaseExClient, AuthClient):
         self.agent: Agent = [ag for ag in ex.agents if ag.auth][0]  # need for AuthTrait
         super().__init__(ex)  # , "host_p2p"
 
+    # 00: todo: min-max for cur and coin ad amount, order, fee ..
+    async def _settings(self) -> dict:
+        settings = await self._post("/p2p/public-api/v2/offer/settings/get")
+        return settings["data"]
+
+    async def cur_mins(self) -> FlatDict:
+        stg = await self._settings()
+        return stg["offerSettings"]["minOrderAmountByCurrencyCode"]
+
+    async def coin_mins(self) -> FlatDict:
+        stg = await self._settings()
+        lims = list(stg["offerSettings"]["offerVolumeLimitsPerMarket"].values())
+        coins = {k: max(float(v[k]["minInclusive"]) for v in lims) for k, v in lims[0].items()}
+        return coins
+
     # 19: Список поддерживаемых валют тейкера
     async def curs(self) -> FlatDict:
         coins_curs = await self._post("/p2p/public-api/v2/currency/all-supported")
         return {c["code"]: c["code"] for c in coins_curs["data"]["fiat"]}
 
-    async def _pms(self, cur: str) -> dict[str, PmXpyd]:
+    async def _pms(self, cur: str) -> dict[str, PmEpydRoot]:
         pms = await self._post("/p2p/public-api/v3/payment-details/get-methods/by-currency-code", {"currencyCode": cur})
-        return {pm["code"]: PmXpyd(name=pm["nameEng"], banks=pm.get("banks")) for pm in pms["data"]}
+        return {pm["code"]: PmEpydRoot(**pm) for pm in pms["data"]}
 
-    # 20: Список платежных методов
-    async def pms(self, cur: str = None) -> DictOfDicts:
+    # 20: Список платежных методов. todo: refact to pmexs?
+    async def pms(self, cur: str = None) -> dict[str, PmPyd]:
+        pms: dict[str:PmEpydRoot] = {}
         if cur:
-            return await self._pms(cur)
-        pms = {}
-        for cur in await self.curs():
-            pms |= await self._pms(cur)
-        return pms
+            pms = await self._pms(cur)
+        else:
+            for cur in await self.curs():
+                pms |= await self._pms(cur)
+        return {
+            k: PmPyd(name=pm.nameEng, banks=[PmexBankPyd(exid=b.code, name=b.name) for b in pm.banks or []])
+            for k, pm in pms.items()
+        }
 
     # 21: Список платежных методов по каждой валюте
     async def cur_pms_map(self) -> MapOfIdsList:
@@ -51,9 +71,10 @@ class ExClient(BaseExClient, AuthClient):
         pairs = {cur: set(coins.values()) for cur in curs.values()}
         return pairs
 
-    async def _get_ad(self, offer_id: int) -> AdFullEpyd:
-        get_ad = await self._post("/p2p/public-api/v2/offer/get", {"offerId": offer_id})
-        return AdFullEpyd(**get_ad["data"])
+    # 42: Объява по id
+    async def ad(self, ad_id: int) -> AdFullEpyd:
+        ad = await self._post("/p2p/public-api/v2/offer/get", {"offerId": ad_id})
+        return AdFullEpyd(**ad["data"])
 
     # 24: Список объяв по (buy/sell, cur, coin, pm)
     async def ads(
@@ -70,39 +91,42 @@ class ExClient(BaseExClient, AuthClient):
         ads = await self._post("/p2p/public-api/v2/offer/depth-of-market/", params, "data")
         return [AdEpyd(**ad) for ad in ads]
 
-    async def ad_epyd2xpyd(self, ad: AdEpyd | AdFullEpyd) -> AdInXpyd:
+    async def _ad_epyd2pydin(self, ad: AdEpyd | AdFullEpyd) -> AdPydIn:
         coin = await Coin.get_or_create_by_name(ad.price.baseCurrencyCode)
         cur = await Cur.get_or_create_by_name(ad.price.quoteCurrencyCode)
         pair, _ = await Pair.get_or_create(coin=coin, cur=cur, ex=self.ex)
         dr, _ = await Direction.get_or_create(pair=pair, sell=ad.is_sell)
         maker, _ = await Agent.get_or_create(exid=ad.user.userId, ex=self.ex)
-        adx = AdInXpyd(
+
+        adx = AdPydIn(
             id=ad.id,
             price=ad.price.value,
-            minFiat=ad.orderAmountLimits.min,
-            maxFiat=ad.orderAmountLimits.max,
-            direction_id=dr.id,
-            agent_id=maker.id,
+            min_fiat=ad.orderAmountLimits.min,
+            max_fiat=ad.orderAmountLimits.max,
+            direction=dr,
+            agent=maker,
             detail=getattr(ad, "comment", None),
+            payMeths=await Pm.filter(pmexs__ex=self.agent.ex, pmexs__exid__in=[p.code for p in ad.paymentMethods]),
+            # todo: maybe later adpm_banks
         )
         return adx
 
 
-async def test():
+async def _test():
     await init_db(PG_DSN, models, True)
     tgex = await Ex.get(name="TgWallet").prefetch_related("agents", "agents__ex")
     cl: ExClient = tgex.client()
+    await cl.pms("RUB")
     await cl.set_pmcurexs()
     await cl.set_coinexs()
     ads: list[AdEpyd] = await cl.ads("USDT", "RUB", False)
-    ad: AdFullEpyd = await cl._get_ad(ads[0].id)
-    adx: AdInXpyd = await cl.ad_epyd2xpyd(ad)
-    await cl.set_ad(adx)
+    ad: AdFullEpyd = await cl.ad(ads[0].id)
+    await cl.set_ad(ad)
+    ads: list[AdEpyd] = await cl.ads("USDT", "RUB", True)
     ad: AdEpyd = ads[1]
-    adx: AdInXpyd = await cl.ad_epyd2xpyd(ad)
-    await cl.set_ad(adx)
+    await cl.set_ad(ad)
     await cl.close()
 
 
 if __name__ == "__main__":
-    run(test())
+    run(_test())

{xync_client-0.0.25.dev0 → xync_client-0.0.25.dev4}/xync_client/TgWallet/pyd.py

@@ -1,6 +1,6 @@
 from typing import Literal
 from pydantic import BaseModel
-from xync_client.pyd import PayMeth
+from xync_schema.pydantic import BaseAd
 
 
 class UserStatistics(BaseModel):
@@ -100,6 +100,17 @@ class AttrsV2(AttrsV2In):
     values: list[KeyVal | Banks]
 
 
+class PmEpyd(BaseModel):
+    code: str
+    name: str
+    originNameLocale: str
+    nameEng: str
+
+
+class PmEpydRoot(PmEpyd):
+    banks: list[PmEpyd] | None = None
+
+
 class FiatPydIn(BaseModel):
     paymentMethodCode: str
     currencyCode: str
@@ -110,7 +121,7 @@ class FiatPydIn(BaseModel):
 class FiatEpyd(BaseModel):
     id: int
     userId: int
-    paymentMethod: PayMeth
+    paymentMethod: PmEpydRoot
     currency: str
     name: str = ""
     attributes: Attrs | AttrsV2
@@ -122,17 +133,16 @@ class InitVolume(BaseModel):
 
 
 class _PaymentMethodsTrait:
-    paymentMethods: list[PayMeth]
+    paymentMethods: list[PmEpydRoot]
 
 
-class __BaseCommonAd(BaseModel):
-    id: int | None = None
+class __BaseCommonAd(BaseAd):
     type: Literal["PURCHASE", "SALE"]
     price: Price
 
 
 class _MyAdEpydIn(__BaseCommonAd):
-    paymentConfirmTimeout: str
+    orderConfirmationTimeout: Literal["PT3M", "PT15M"]
     comment: str
     initVolume: InitVolume
     orderRoundingRequired: bool
@@ -167,7 +177,7 @@ class AdFullEpyd(AdEpyd):
     status: Literal["ACTIVE", "INACTIVE", "ACTIVATING"]
     createDateTime: str
     comment: str
-    orderConfirmationTimeout: Literal["PT3M"]
+    orderConfirmationTimeout: Literal["PT3M", "PT15M"]
     orderAcceptTimeout: Literal["PT10M"]
 
 

{xync_client-0.0.25.dev0 → xync_client-0.0.25.dev4/xync_client.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: xync-client
-Version: 0.0.25.dev0
+Version: 0.0.25.dev4
 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.25.dev0 → xync_client-0.0.25.dev4}/xync_client.egg-info/SOURCES.txt

@@ -19,7 +19,6 @@ tests/_todo_refact/Wallet/test_agent.py
 tests/_todo_refact/Wallet/test_ex.py
 xync_client/__init__.py
 xync_client/loader.py
-xync_client/pyd.py
 xync_client.egg-info/PKG-INFO
 xync_client.egg-info/SOURCES.txt
 xync_client.egg-info/dependency_links.txt

xync_client-0.0.25.dev0/xync_client/pyd.py

@@ -1,71 +0,0 @@
-from pydantic import BaseModel, model_validator
-from xync_schema.enums import AdStatus
-
-
-class PayMeth(BaseModel):
-    code: str
-    name: str
-    originNameLocale: str
-    nameEng: str
-
-
-class PmXpyd(BaseModel):
-    id: int | None = None
-    name: str
-    logo: str | None = None
-    banks: list[PayMeth] | None = None  # todo: refact excess data in banks
-
-
-class PmcurXpyd(BaseModel):
-    pm_id: int
-    cur_id: int
-
-
-class FiatXpyd(BaseModel):
-    # unq
-    id: int = None
-    user_id: int
-    pmcur_id: int | None = None
-    pmcur: PmcurXpyd | None = None
-    # df
-    detail: str
-    name: str = ""
-    amount: float
-    target: float | None = None
-
-    banks: list[str] = []
-
-    @classmethod
-    @model_validator(mode="before")
-    def check_at_least_one_field(cls, values):
-        if values.get("pmcur") or values.get("pmcur_id"):
-            return values
-        raise ValueError("pmcur_id or pmcur is required")
-
-    def args(self) -> tuple[dict, dict]:
-        unq: tuple[str, ...] = "id", "user_id", "pmcur_id", "pmcur"
-        df: tuple[str, ...] = "detail", "name", "amount", "target"
-
-        d = self.model_dump()
-        return {k: getattr(self, k) for k in df if d.get(k)}, {k: getattr(self, k) for k in unq if d.get(k)}
-
-
-class AdInXpyd(BaseModel):
-    # unq
-    id: int
-    # df
-    price: float
-    minFiat: float
-    maxFiat: float | None = None
-    detail: str | None = None
-    autoMsg: str | None = None
-    status: AdStatus = AdStatus.active
-    agent_id: int
-    direction_id: int
-
-
-class FiatexXpyd(BaseModel):
-    id: int | None = None
-    exid: str
-    ex_id: int
-    fiat_id: int