xync-client 0.0.25.dev3__tar.gz → 0.0.25.dev6__tar.gz

{xync_client-0.0.25.dev3/xync_client.egg-info → xync_client-0.0.25.dev6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: xync-client
-Version: 0.0.25.dev3
+Version: 0.0.25.dev6
 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.dev3 → xync_client-0.0.25.dev6}/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.dev3 → xync_client-0.0.25.dev6}/xync_client/Abc/Agent.py

@@ -3,24 +3,21 @@ from abc import abstractmethod
 from pydantic import BaseModel
 from tortoise.exceptions import IntegrityError
 from x_model import HTTPException, FailReason
+from xync_client.Abc.Ex import BaseExClient
 
 from xync_client.Abc.Base import BaseClient
-from xync_client.Abc.Ex import ListOfDicts
 
 from xync_client.Abc.AuthTrait import BaseAuthTrait
 from xync_schema.models import OrderStatus, Coin, Cur, Ad, AdStatus, Fiat, Agent, Pmex, Pmcur, Fiatex
-from xync_schema.pydantic import FiatNew, FiatUpd
+from xync_schema.pydantic import FiatNew, FiatUpd, BaseAd
 
 
 class BaseAgentClient(BaseClient, BaseAuthTrait):  # todo: inherit form Base or from Ex Client?
     def __init__(self, agent: Agent):
         self.agent: Agent = agent
-        # self.ex_client: BaseExClient = agent.ex.client()  # todo: really need?
+        self.ex_client: BaseExClient = agent.ex.client(agent)  # todo: really need?
         super().__init__(agent.ex)  # , "host_p2p"
 
-    @abstractmethod
-    def pm_type_map(self, type_: Pmex) -> str: ...
-
     @abstractmethod
     async def start_listen(self) -> bool: ...
 
@@ -28,7 +25,7 @@ class BaseAgentClient(BaseClient, BaseAuthTrait):  # todo: inherit form Base or
     @abstractmethod
     async def get_orders(
         self, status: OrderStatus = OrderStatus.created, coin: Coin = None, cur: Cur = None, is_sell: bool = None
-    ) -> ListOfDicts: ...
+    ) -> list: ...
 
     # 3N: [T] - Уведомление об одобрении запроса на сделку
     @abstractmethod
@@ -50,7 +47,7 @@ class BaseAgentClient(BaseClient, BaseAuthTrait):  # todo: inherit form Base or
     async def request_canceled_notify(self) -> int: ...  # id
 
     # # # Fiat
-    async def _fiat_pyd2args(
+    async def _fiat_epyd2pydin(
         self, fiat: FiatNew | FiatUpd
     ) -> tuple[int | str, str, str, str, str]:  # exid,cur,dtl,name,typ
         if not (pmex := await Pmex.get_or_none(ex=self.agent.ex, pm_id=fiat.pm_id).prefetch_related("pm")):
@@ -60,17 +57,17 @@ class BaseAgentClient(BaseClient, BaseAuthTrait):  # todo: inherit form Base or
             # and then get this pm again
             pmex = await Pmex.get(ex=self.agent.ex, pm_id=fiat.pm_id).prefetch_related("pm")
         cur = await Cur[fiat.cur_id]
-        return pmex.exid, cur.ticker, fiat.detail, fiat.name or pmex.name, self.pm_type_map(pmex)
+        return pmex.exid, cur.ticker, fiat.detail, fiat.name or pmex.name, self.ex_client.pm_type_map(pmex)
 
     async def fiat_new_pyd2args(
         self, fiat: FiatNew
     ) -> tuple[int | str, str, str, str, str, None]:  # exid,cur,dtl,name,typ
-        return await self._fiat_pyd2args(fiat) + (None,)
+        return await self._fiat_epyd2pydin(fiat) + (None,)
 
     async def fiat_upd_pyd2args(
         self, fiat: FiatNew, fid: int
     ) -> tuple[int | str, str, str, str, str, int]:  # *new_p2args,id
-        return await self._fiat_pyd2args(fiat) + (fid,)
+        return await self._fiat_epyd2pydin(fiat) + (fid,)
 
     @property
     @abstractmethod
@@ -83,7 +80,7 @@ class BaseAgentClient(BaseClient, BaseAuthTrait):  # todo: inherit form Base or
 
     # 25: Список реквизитов моих платежных методов
     @abstractmethod
-    async def fiats(self) -> ListOfDicts: ...  # {fiat.exid: {fiat}}
+    async def fiats(self) -> list: ...  # {fiat.exid: {fiat}}
 
     @staticmethod
     async def fiat_pyd2db(fiat_pyd: FiatNew | FiatUpd, uid: int, fid: int = None) -> tuple[Fiat, bool]:
@@ -117,24 +114,11 @@ class BaseAgentClient(BaseClient, BaseAuthTrait):  # todo: inherit form Base or
     # # # Ad
     # 29: Список моих объявлений
     @abstractmethod
-    async def my_ads(self, status: AdStatus = None) -> ListOfDicts: ...
+    async def my_ads(self, status: AdStatus = None) -> list[BaseAd]: ...
 
     # 30: Создание объявления
     @abstractmethod
-    async def ad_new(
-        self,
-        coin: Coin,
-        cur: Cur,
-        is_sell: bool,
-        fiats: list[Fiat],
-        amount: str,
-        price: float,
-        min_fiat: str,
-        is_float: bool = True,
-        details: str = None,
-        autoreply: str = None,
-        status: AdStatus = AdStatus.active,
-    ) -> Ad.pyd(): ...
+    async def ad_new(self, ad: BaseAd) -> Ad: ...
 
     # 31: Редактирование объявления
     @abstractmethod
@@ -149,11 +133,11 @@ class BaseAgentClient(BaseClient, BaseAuthTrait):  # todo: inherit form Base or
         details: str = None,
         autoreply: str = None,
         status: AdStatus = None,
-    ) -> Ad.pyd(): ...
+    ) -> Ad: ...
 
     # 32: Удаление
     @abstractmethod
-    async def ad_del(self, offer_id: int) -> bool: ...
+    async def ad_del(self, ad_id: int) -> bool: ...
 
     # 33: Вкл/выкл объявления
     @abstractmethod

{xync_client-0.0.25.dev3 → xync_client-0.0.25.dev6}/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.dev3 → xync_client-0.0.25.dev6}/xync_client/Abc/Ex.py

@@ -2,11 +2,10 @@ import logging
 import re
 from abc import abstractmethod
 
-from xync_schema.pydantic import AdPydIn, PmPyd
+from xync_schema.pydantic import AdPydIn, PmPyd, BaseAd, CurEpyd
+from xync_schema.models import Ex, Coin, Cur, Pm, Pmex, Curex, Pmcur, Pmcurex, Coinex, PmexBank, Ad, Agent
 
-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):
@@ -22,11 +21,14 @@ class BaseExClient(BaseClient):
         "GTB Bank (Guarantee Trust Bank)": "GTBank",
     }
 
-    def __init__(self, ex: Ex):
+    def __init__(self, ex: Ex, _: Agent = None):
         self.ex: Ex = ex
         self.acronyms: dict[str, str] = {}  # for pm norm
         super().__init__(ex)  # , "host_p2p"
 
+    @abstractmethod
+    def pm_type_map(self, type_: Pmex) -> str: ...
+
     # 19: Список поддерживаемых валют тейкера
     @abstractmethod
     async def curs(self) -> FlatDict:  # {cur.exid: cur.ticker}
@@ -55,9 +57,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: ...  # my_uid: for MyAd
+
     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())
@@ -159,12 +169,14 @@ class BaseExClient(BaseClient):
                     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()}
+        cur_pyds: list[CurEpyd] = await self.curs()
+        curs: dict[int | str, Cur] = {
+            cur_pyd.exid: (await Cur.update_or_create({"rate": cur_pyd.rate}, ticker=cur_pyd.ticker))[0]
+            for cur_pyd in cur_pyds
+        }
+        curexs: list[Curex] = [Curex(**c.model_dump(), cur=curs[c.exid], ex=self.ex) for c in cur_pyds]
         # Curex
-        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"])
+        await Curex.bulk_create(curexs, update_fields=["minimum", "rounding_scale"], on_conflict=["cur_id", "ex_id"])
 
         cur2pms = await self.cur_pms_map()
         # # Link PayMethods with currencies
@@ -192,7 +204,7 @@ class BaseExClient(BaseClient):
 
     # Сохранение чужого объявления (с Pm-ами) в бд
     @staticmethod
-    async def set_ad(ad: AdPydIn) -> Ad:
-        ad_db, _ = await Ad.update_or_create(ad.model_dump(exclude_none=True), id=ad.id)
-        await ad_db.pms.add(*ad.payMeths)
+    async def ad_pydin2db(ad_pydin: AdPydIn) -> Ad:
+        ad_db, _ = await Ad.update_or_create(ad_pydin.model_dump(exclude_none=True), id=ad_pydin.id)
+        await ad_db.pms.add(*ad_pydin.payMeths)
         return ad_db

{xync_client-0.0.25.dev3 → xync_client-0.0.25.dev6}/xync_client/TgWallet/agent.py

@@ -2,17 +2,30 @@ 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, MyAdInPurchaseEpyd, MyAdInSaleEpyd, AdFullEpyd
+from xync_client.TgWallet.pyd import Banks, FiatEpyd, Attrs, AttrsV2, AdFullEpyd, MyAdEpyd, MyAdEpydIn, MyAdFullEpyd
 from xync_client.loader import PG_DSN
 from xync_schema.enums import AdStatus
 
 from xync_client.Abc.Base import ListOfDicts
 from xync_client.TgWallet.auth import AuthClient
-from xync_schema.models import Cur, Coin, OrderStatus, Pmex, Fiat, Ad, Pmcur, Fiatex, Pm, FiatBank, PmexBank, Agent
-from xync_schema.pydantic import FiatNew
+from xync_schema.models import (
+    Cur,
+    Coin,
+    OrderStatus,
+    Pmex,
+    Fiat,
+    Ad,
+    Pmcur,
+    Fiatex,
+    FiatBank,
+    PmexBank,
+    Agent,
+    Curex,
+    Coinex,
+)
+from xync_schema.pydantic import FiatNew, FiatPydIn
 
 from xync_client.Abc.Agent import BaseAgentClient
 from xync_client.TgWallet.ex import ExClient
@@ -27,9 +40,6 @@ class Exceptions(StrEnum):
 
 
 class AgentClient(BaseAgentClient, AuthClient):
-    def pm_type_map(self, pm: Pm) -> str:
-        return "V2" if pm.name.startswith("SBP") else "V1"
-
     # 0: Получение ордеров в статусе status, по монете coin, в валюте coin, в направлении is_sell
     async def orders(
         self, status: OrderStatus = OrderStatus.created, coin: Coin = None, cur: Cur = None, is_sell: bool = None
@@ -51,7 +61,7 @@ class AgentClient(BaseAgentClient, AuthClient):
         ex_client: ExClient = self.agent.ex.client()
         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()}
+        fiats_pms = {fiat["paymentMethod"]["code"]: fiat["id"] for fiat in fiats}
         if not (pms := ad.get("paymentMethods")):
             print(ad)
         ad_pms = [pm["code"] for pm in pms]
@@ -117,20 +127,20 @@ class AgentClient(BaseAgentClient, AuthClient):
         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) -> FiatXpyd:
+    async def _fiat_epyd2pydin(self, fiat: FiatEpyd) -> FiatPydIn:
         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 = FiatXpyd(
+        ftx = FiatPydIn(
             id=fiat.id,
             detail="",
             name=fiat.name,
             amount=0,
             user_id=self.agent.user_id,
-            pmcur_id=pmcur.id,
+            pmcur=pmcur,
         )
         for val in fiat.attributes.values:
             if val.name != "BANKS":
@@ -143,7 +153,7 @@ class AgentClient(BaseAgentClient, AuthClient):
     # 25: Список реквизитов моих платежных методов
     async def set_fiatexs(self) -> list[Fiatex]:
         fiat_epyds = await self.fiats()
-        fiat_xpyds: list[FiatXn] = [await self.fiat_epyd2xpyd(f) for f in fiat_epyds]
+        fiat_xpyds: list[FiatPydIn] = [await self._fiat_epyd2pydin(f) for f in fiat_epyds]
         fxs: list[Fiatex] = []
         for fx in fiat_xpyds:
             df, unq = fx.args()
@@ -209,77 +219,18 @@ class AgentClient(BaseAgentClient, AuthClient):
         return del_fiat
 
     # 29: Список моих объявлений
-    async def my_ads(self, status: AdStatus = None) -> ListOfDicts:
+    async def my_ads(self, status: AdStatus = None) -> list[MyAdEpyd]:
         mapping = {AdStatus.defActive: "INACTIVE", AdStatus.active: "ACTIVE"}
         ads = await self._post(
             "/p2p/public-api/v2/offer/user-own/list",
             {"offset": 0, "limit": 20},  # , "offerType": "SALE"|"PURCHASE"
         )
-        return (
-            [
-                MyAdEpydSale(**ad) if ad["type"] == "SALE" else MyAdEpydPurchase(**ad)
-                for ad in ads["data"]
-                if not status or (status and ad["status"] == mapping[status])
-            ]
-            if status
-            else ads["data"]
-        )
+        return [MyAdEpyd(**ad) for ad in ads["data"] if not status or (status and ad["status"] == mapping[status])]
 
     # 30: Создание объявления
-    async def ad_new(self, ad: MyAdInPurchaseEpyd | MyAdInSaleEpyd) -> Ad:
-        # coin: Coin,
-        # cur: str,
-        # is_sell: bool,
-        # fiats: list[Fiat],
-        # amount: str,
-        # price: str,
-        # min_fiat: str,
-        # is_float: bool = False,
-        # details: str = None,
-        # autoreply: str = None,
-        # status: AdStatus = AdStatus.active,
-        # ) -> Ad.pyd():
-        dct = {
-            "type": ad.type,
-            "initVolume": {"currencyCode": coin, "amount": amount},
-            "orderRoundingRequired": True,
-            "price": {
-                "type": "FLOATING" if is_float else "FIXED",
-                "baseCurrencyCode": coin,
-                "quoteCurrencyCode": cur,
-                "value": price,
-            },
-            "orderAmountLimits": {"min": min_fiat},
-            "paymentConfirmTimeout": "PT15M",
-            "comment": "",  # todo: real recipient name
-            "paymentMethodCodes": fiats,
-        }
-        if is_sell:
-            dct["paymentDetailsIds"] = [f.id for f in fiats]
-        else:
-            pm_ids = [f.pmcur.pm_id for f in fiats]
-            pmexs = await Pmex.filter(ex=self.agent.ex, pm_id__in=pm_ids)
-            dct["paymentMethodCodes"] = [pmex.exid for pmex in pmexs]
-
-        create = await self._post(
-            "/p2p/public-api/v2/offer/create",
-            {
-                "type": typ,
-                "initVolume": {"currencyCode": coin.ticker, "amount": f"{amount}"},
-                "orderRoundingRequired": False,
-                "price": {
-                    "type": "FLOATING" if is_float else "FIXED",
-                    "baseCurrencyCode": coin.ticker,
-                    "quoteCurrencyCode": cur,
-                    "value": price,
-                },
-                "orderAmountLimits": {"min": min_fiat},
-                "paymentConfirmTimeout": "PT15M" if is_sell else "PT3H",
-                "comment": "",
-                "paymentDetailsIds": fiats,
-            },
-        )
-        return create
+    async def ad_new(self, ad: MyAdEpydIn) -> MyAdFullEpyd:
+        create = await self._post("/p2p/public-api/v2/offer/create", ad.model_dump())
+        return MyAdFullEpyd(**create["data"])
 
     async def _get_my_ad(self, offer_id: int):
         get_own = await self._post("/p2p/public-api/v2/offer/get-user-own/", {"offerId": offer_id})
@@ -365,21 +316,43 @@ class AgentClient(BaseAgentClient, AuthClient):
 
 async def main():
     await init_db(PG_DSN, models, True)
-    agents = await Agent.filter(ex_id=34, auth__isnull=False).order_by("user_id").prefetch_related("ex")
+    agents: tuple[Agent, Agent, Agent] = (
+        await Agent.filter(ex_id=34, auth__isnull=False).order_by("user_id").limit(3).prefetch_related("ex")
+    )
     my, taker, maker = agents
-    mycl, tcl, mcl = my.client(), taker.client(), maker.client()
+    mycl: AgentClient = my.client()
+    tcl: AgentClient = taker.client()
+    mcl: AgentClient = maker.client()
 
-    await mycl.set_fiatexs()
+    # fiatexs = await tcl.set_fiatexs()
+    # fiatexs = await mcl.set_fiatexs()
     await mycl.my_ads()
+    coinex = await Coinex.get(coin__ticker="USDT")
+    taker_fiats = await Fiat.filter(user_id=taker.user_id)
+    maker_fiats = await Fiat.filter(user_id=maker.user_id)
+    mf: Fiat = max(
+        {mf for mf in maker_fiats if mf.pmcur_id in {tf.pmcur_id for tf in taker_fiats}}, key=lambda x: x.amount
+    )
+    curex = await Curex.get(ex=maker.ex, cur_id=(await mf.pmcur).cur_id)
+    mfiatex = await Fiatex.get(ex=maker.ex, fiat=mf)
+    ad_in = MyAdEpydIn(
+        type="SALE",
+        initVolume={"currencyCode": coinex.exid, "amount": f"{coinex.minimum}"},
+        orderRoundingRequired=True,
+        price={
+            "type": "FLOATING",
+            "baseCurrencyCode": coinex.exid,
+            "quoteCurrencyCode": curex.exid,
+            "value": "120",
+        },
+        orderAmountLimits={"min": str(curex.minimum)},
+        paymentConfirmTimeout="PT15M",
+        comment="test1",
+        paymentDetailsIds=[mfiatex.exid],
+    )
+    ad: MyAdFullEpyd = await mcl.ad_new(ad_in)
+    await mcl.ex_client.set_ad(ad)
 
-    await Coin.get(ticker="USDT")
-    await Fiat.filter(user_id=taker.user_id)
-    await Fiat.filter(user_id=maker.user_id)
-    # fiatex = await Fiatex.get(exid=my_fiat['id']).prefetch_related('fiat')
-    # ad = await tcl.ad_new(
-    #     coin=coin, cur=fiatex.fiat.currency, is_sell=True, fiats=[mf.pmcur for mf in maker_fiats], amount="10", price="120", min_fiat="500", is_float=True
-    # )
-    # ad: AdPyd = AdPyd(**ad["data"])
     # print(ad)
     await tcl.close(), await mcl.close()