xync-client 0.0.16.dev4__tar.gz → 0.0.16.dev9__tar.gz

{xync_client-0.0.16.dev4/xync_client.egg-info → xync_client-0.0.16.dev9}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: xync-client
-Version: 0.0.16.dev4
+Version: 0.0.16.dev9
 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.16.dev9/tests/TestAgent.py

@@ -0,0 +1,141 @@
+import logging
+
+import pytest
+from xync_schema.enums import ExStatus, ExAction
+from xync_schema.models import Ex, TestEx, Fiat, Ad, Coin, Cur
+from xync_schema.pydantic import FiatNew
+
+from xync_client.Abc.BaseTest import BaseTest
+from xync_client.Abc.Agent import BaseAgentClient
+from xync_client.Abc.Base import BaseClient, DictOfDicts, ListOfDicts
+from xync_client.TgWallet.ex import ExClient
+
+
+@pytest.mark.asyncio(loop_scope="session")
+class TestAgent(BaseTest):
+    @pytest.fixture(scope="class", autouse=True)
+    async def clients(self) -> tuple[BaseClient, BaseClient]:
+        exs = await Ex.filter(status__gt=ExStatus.plan).prefetch_related("agents__ex")
+        agents = [[ag for ag in ex.agents if ag.auth][:2] for ex in exs]
+        clients: list[tuple[BaseClient, BaseClient]] = [(t.client(), m.client()) for t, m in agents]
+        yield clients
+        [(await taker.close(), await maker.close()) for taker, maker in clients]
+
+    # 0
+    async def test_get_orders(self, clients: list[BaseAgentClient]):
+        for taker, maker in clients:
+            get_orders: ListOfDicts = await taker.get_orders()
+            ok = self.is_list_of_dicts(get_orders, False)
+            t, _ = await TestEx.update_or_create({"ok": ok}, ex_id=taker.agent.ex_id, action=ExAction.get_orders)
+            assert t.ok, "No get orders"
+            logging.info(f"{taker.agent.ex_id}:{ExAction.get_orders.name} - ok")
+
+    # 1
+    async def test_order_request(self, clients: list[BaseAgentClient]):
+        for taker, maker in clients:
+            await taker.agent.fetch_related("ex", "ex__agents")
+            ex_client: ExClient = taker.agent.ex.client()
+            ads = await ex_client.ads("NOT", "RUB", False)
+            for ad in ads:
+                order_request: dict | bool = await taker.order_request(ad["id"], ad["orderAmountLimits"]["min"])
+                if order_request:
+                    break
+            ok = order_request["status"] == "SUCCESS"
+            t, _ = await TestEx.update_or_create({"ok": ok}, ex_id=taker.agent.ex_id, action=ExAction.order_request)
+            assert t.ok, "No get orders"
+            logging.info(f"{taker.agent.ex_id}:{ExAction.order_request.name} - ok")
+
+    # 25
+    async def test_my_fiats(self, clients: list[BaseAgentClient]):
+        for taker, maker in clients:
+            my_fiats: DictOfDicts = await taker.my_fiats()
+            ok = self.is_dict_of_dicts(my_fiats)
+            t, _ = await TestEx.update_or_create({"ok": ok}, ex_id=taker.agent.ex_id, action=ExAction.my_fiats)
+            assert t.ok, "No my fiats"
+            logging.info(f"{taker.agent.ex_id}:{ExAction.my_fiats.name} - ok")
+
+    # 26
+    async def test_fiat_new(self, clients: list[BaseAgentClient]):
+        for taker, maker in clients:
+            fn = FiatNew(cur_id=11, pm_id=22, detail="123456789")
+            fiat_new: Fiat = await taker.fiat_new(fn)
+            ok = isinstance(fiat_new, Fiat)
+            t, _ = await TestEx.update_or_create({"ok": ok}, ex_id=taker.agent.ex_id, action=ExAction.fiat_new)
+            assert t.ok, "No add fiat"
+            logging.info(f"{taker.agent.ex_id}:{ExAction.fiat_new.name} - ok")
+
+    # 27
+    async def test_fiat_upd(self, clients: list[BaseAgentClient]):
+        for taker, maker in clients:
+            my_fiats = await taker.my_fiats()
+            fiats = [fiat for fiat in my_fiats.values()]
+            fiat_upd: Fiat = await taker.fiat_upd(fiat_id=fiats[0]["id"], detail="347890789")
+            ok = isinstance(fiat_upd, Fiat)
+            t, _ = await TestEx.update_or_create({"ok": ok}, ex_id=taker.agent.ex_id, action=ExAction.fiat_upd)
+            assert t.ok, "No upd fiat"
+            logging.info(f"{taker.agent.ex_id}:{ExAction.fiat_upd.name} - ok")
+
+    # 28
+    async def test_fiat_del(self, clients: list[BaseAgentClient]):
+        for taker, maker in clients:
+            my_fiats = await taker.my_fiats()
+            fiats = [fiat for fiat in my_fiats.values()]
+            fiat_del: bool = await taker.fiat_del(fiat_id=fiats[0]["id"])
+            ok = fiat_del["status"] == "SUCCESS"
+            t, _ = await TestEx.update_or_create({"ok": ok}, ex_id=taker.agent.ex_id, action=ExAction.fiat_del)
+            assert t.ok, "No del fiat"
+            logging.info(f"{taker.agent.ex_id}:{ExAction.fiat_del.name} - ok")
+
+    # 29
+    async def test_my_ads(self, clients: list[BaseAgentClient]):
+        for taker, maker in clients:
+            my_ads: ListOfDicts = await taker.my_ads()
+            ok = self.is_list_of_dicts(my_ads, False)
+            t, _ = await TestEx.update_or_create({"ok": ok}, ex_id=taker.agent.ex_id, action=ExAction.my_ads)
+            assert t.ok, "No del fiat"
+            logging.info(f"{taker.agent.ex_id}:{ExAction.my_ads.name} - ok")
+
+    # 30
+    async def test_ad_new(self, clients: list[BaseAgentClient]):
+        for taker, maker in clients:
+            my_fiats = await taker.my_fiats()
+            my_fiat = list(my_fiats.values())[0]
+            coin = await Coin.get(ticker="USDT")
+            cur = await Cur.get(ticker=my_fiat["currency"])
+            # pm = await Fiatex.get()
+            ad_new: Ad.pyd() = await taker.ad_new(
+                coin=coin, cur=cur, is_sell=True, fiats=[my_fiat["id"]], amount="10", price="120", min_fiat="500"
+            )
+            ok = ad_new["status"] == "SUCCESS"
+            t, _ = await TestEx.update_or_create({"ok": ok}, ex_id=taker.agent.ex_id, action=ExAction.ad_new)
+            assert t.ok, "No add new ad"
+            logging.info(f"{taker.agent.ex_id}:{ExAction.ad_new.name} - ok")
+
+    # 31
+    async def test_ad_upd(self, clients: list[BaseAgentClient]):
+        for taker, maker in clients:
+            my_ads: ListOfDicts = await taker.my_ads()
+            ad_upd: Ad.pyd() = await taker.ad_upd(offer_id=my_ads[0]["id"], amount="11")
+            ok = ad_upd["status"] == "SUCCESS"
+            t, _ = await TestEx.update_or_create({"ok": ok}, ex_id=taker.agent.ex_id, action=ExAction.ad_upd)
+            assert t.ok, "No add new ad"
+            logging.info(f"{taker.agent.ex_id}:{ExAction.ad_upd.name} - ok")
+
+    # 32
+    async def test_ad_del(self, clients: list[BaseAgentClient]):
+        for taker, maker in clients:
+            my_ads: ListOfDicts = await taker.my_ads()
+            ad_del: bool = await taker.ad_del(offer_id=my_ads[0]["id"])
+            t, _ = await TestEx.update_or_create({"ok": ad_del}, ex_id=taker.agent.ex_id, action=ExAction.ad_del)
+            assert t.ok, "No add new ad"
+            logging.info(f"{taker.agent.ex_id}:{ExAction.ad_del.name} - ok")
+
+    # 33
+    async def test_ad_switch(self, clients: list[BaseAgentClient]):
+        for taker, maker in clients:
+            my_ads: ListOfDicts = await taker.my_ads()
+            new_status = not (my_ads[0]["status"] == "ACTIVE")
+            ad_switch: bool = await taker.ad_switch(offer_id=my_ads[0]["id"], active=new_status)
+            t, _ = await TestEx.update_or_create({"ok": ad_switch}, ex_id=taker.agent.ex_id, action=ExAction.ad_switch)
+            assert t.ok, "No ad active/off"
+            logging.info(f"{taker.agent.ex_id}:{ExAction.ad_switch.name} - ok")

{xync_client-0.0.16.dev4 → xync_client-0.0.16.dev9}/xync_client/Abc/Agent.py

@@ -26,47 +26,47 @@ class BaseAgentClient(BaseAuthClient):
     @abstractmethod
     async def my_fiats(self, cur: Cur = None) -> DictOfDicts: ...  # {fiat.exid: {fiat}}
 
-    # 26: Создание
+    # 26: Создание реквизита моего платежного метода
     @abstractmethod
-    async def fiat_new(self, fiat: FiatNew) -> Fiat.pyd(): ...
+    async def fiat_new(self, fiat: FiatNew) -> Fiat: ...
 
-    # 27: Редактирование
+    # 27: Редактирование реквизита моего платежного метода
     @abstractmethod
-    async def fiat_upd(self, fiat_id: int, detail: str, name: str = None) -> Fiat.pyd(): ...
+    async def fiat_upd(self, fiat_id: int, detail: str, name: str = None) -> Fiat: ...
 
-    # 28: Удаление
+    # 28: Удаление реквизита моего платежного метода
     @abstractmethod
     async def fiat_del(self, fiat_id: int) -> bool: ...
 
     # # # Ad
-    # 29: Список моих ad
+    # 29: Список моих объявлений
     @abstractmethod
     async def my_ads(self, status: AdStatus = None) -> ListOfDicts: ...
 
-    # 30: Создание ad:
+    # 30: Создание объявления
     @abstractmethod
     async def ad_new(
         self,
         coin: Coin,
         cur: Cur,
         is_sell: bool,
-        pms: list[Pm],
-        amount: int,
+        fiats: list[Fiat],
+        amount: str,
         price: float,
+        min_fiat: str,
         is_float: bool = True,
-        min_fiat: int = None,
         details: str = None,
         autoreply: str = None,
         status: AdStatus = AdStatus.active,
     ) -> Ad.pyd(): ...
 
-    # 31: Редактирование
+    # 31: Редактирование объявления
     @abstractmethod
     async def ad_upd(
         self,
         offer_id: int,
         amount: int,
-        pms: [Pm] = None,
+        fiats: list[Fiat] = None,
         price: float = None,
         is_float: bool = None,
         min_fiat: int = None,

{xync_client-0.0.16.dev4 → xync_client-0.0.16.dev9}/xync_client/TgWallet/agent.py

@@ -1,15 +1,18 @@
+from asyncio import run
 from enum import StrEnum
-from typing import Literal
 
-from xync_schema.enums import AdStatus
+from x_model import init_db
+from xync_schema import models
+from xync_schema.enums import AdStatus, ExStatus
 
-from xync_client.Abc.Base import ListOfDicts, MapOfIdsList, DictOfDicts
+from xync_client.Abc.Base import ListOfDicts, DictOfDicts, BaseClient
 from xync_client.TgWallet.auth import AuthClient
-from xync_schema.models import User, Cur, Order, Coin, OrderStatus, Pmex, Fiat, Ad, Pm
+from xync_schema.models import Cur, Coin, OrderStatus, Pmex, Fiat, Ad, Pm, Pmcur, Fiatex, Ex
 from xync_schema.pydantic import FiatNew
 
 from xync_client.Abc.Agent import BaseAgentClient
 from xync_client.TgWallet.ex import ExClient
+from xync_client.loader import PG_DSN
 
 
 class Exceptions(StrEnum):
@@ -22,37 +25,43 @@ class Exceptions(StrEnum):
 
 class AgentClient(BaseAgentClient, AuthClient):
     # 0: Получшение ордеров в статусе status, по монете coin, в валюте coin, в направлении is_sell: bool
-    async def get_orders(self, status: OrderStatus = OrderStatus.created, coin: Coin = None, cur: Cur = None, is_sell: bool = None) -> ListOfDicts:
+    async def get_orders(
+        self, status: OrderStatus = OrderStatus.created, coin: Coin = None, cur: Cur = None, is_sell: bool = None
+    ) -> ListOfDicts:
         orders = await self._post(
             "/p2p/public-api/v2/offer/order/history/get-by-user-id",
             {"offset": 0, "limit": 100, "filter": {"status": "ALL_ACTIVE"}},  # "limit": 20
         )
-        return orders['data']
+        return orders["data"]
 
     # 1: [T] Запрос на старт сделки
     async def order_request(self, ad_id: int, amount: float) -> dict | bool:
-        await self.agent.fetch_related('ex', 'ex__agents')
+        await self.agent.fetch_related("ex", "ex__agents")
         ex_client: ExClient = self.agent.ex.client()
         ad = await ex_client._get_ad(offer_id=ad_id)
         fiats = await self.my_fiats()
-        fiats_pms = [fiat['id'] for fiat in fiats.values()]
-        ad_pms = [pm['id'] for pm in ad['paymentDetails']]
-        result = list(set(fiats_pms) & set(ad_pms))
+        fiats_pms = {fiat["paymentMethod"]["code"]: fiat["id"] for fiat in fiats.values()}
+        if not (pms := ad.get("paymentMethods")):
+            print(ad)
+        ad_pms = [pm["code"] for pm in pms]
+        result = list(set(fiats_pms.keys()) & set(ad_pms))
         if not result:
             return False
+        pid = result[0]
         request = await self._post(
             "/p2p/public-api/v2/offer/order/create-by-amount",
             {
                 "offerId": ad_id,
-                "paymentDetailsId": result[0],
-                "amount": {
-                    "currencyCode": ad['orderAmountLimits']['currencyCode'],
-                    "amount": amount
-                },
-                "type": ad['type']
-            }, 'data'
+                "paymentDetailsId": fiats_pms[pid],
+                "amount": {"currencyCode": ad["orderAmountLimits"]["currencyCode"], "amount": amount},
+                "type": ad["type"],
+            },
+            "data",
         )
-        return request
+        confirm = await self._post(
+            "/p2p/public-api/v2/offer/order/confirm", {"orderId": request["id"], "type": ad["type"]}
+        )
+        return confirm
 
     # 25: Список реквизитов моих платежных методов
     async def my_fiats(self, cur: Cur = None) -> DictOfDicts:
@@ -60,9 +69,9 @@ class AgentClient(BaseAgentClient, AuthClient):
         fiats = {fiat["id"]: fiat for fiat in fiats["data"]}
         return fiats
 
-    # 26: Создание
-    async def fiat_new(self, fiat: FiatNew) -> Fiat.pyd():
-        pmex = await Pmex.get_or_create(pm_id=fiat.pm_id, ex=self.agent.ex)  # .prefetch_related('pm')
+    # 26: Создание реквизита моего платежного метода
+    async def fiat_new(self, fiat: FiatNew) -> Fiat:
+        pmex, _ = await Pmex.get_or_create(pm_id=fiat.pm_id, ex=self.agent.ex)  # .prefetch_related('pm')
         cur = await Cur[fiat.cur_id]
         add_fiat = await self._post(
             "/p2p/public-api/v3/payment-details/create",
@@ -73,52 +82,68 @@ class AgentClient(BaseAgentClient, AuthClient):
                 "attributes": {"version": "V1", "values": [{"name": "PAYMENT_DETAILS_NUMBER", "value": fiat.detail}]},
             },
         )
-        return add_fiat
-
-    # 27: Редактирование
-    async def fiat_upd(self, fiat_id: int, detail: str, name: str = None) -> Fiat.pyd():
+        pmex = await Pmex.get(exid=add_fiat["data"]["paymentMethod"]["code"], ex=self.agent.ex)
+        cur = await Cur.get(ticker=add_fiat["data"]["currency"])
+        pmcur, _ = await Pmcur.get_or_create(cur=cur, pm_id=pmex.pm_id)
+        attrs = {a["name"]: a["value"] for a in add_fiat["data"]["attributes"]["values"]}
+        f, _ = await Fiat.update_or_create(
+            {"detail": attrs["PAYMENT_DETAILS_NUMBER"]}, pmcur=pmcur, user_id=self.agent.user_id
+        )
+        await Fiatex.update_or_create({"exid": add_fiat["data"]["id"]}, ex=self.agent.ex, fiat=f)
+        return f
+
+    # 27: Редактирование реквизита моего платежного метода
+    async def fiat_upd(self, fiat_id: int, detail: str, name: str = None) -> Fiat:
+        fiat = await Fiat.get(fiatexs__exid=fiat_id, fiatexs__ex=self.agent.ex).prefetch_related("pmcur")
+        pmex = await Pmex.get(pm_id=fiat.pmcur.pm_id, ex=self.agent.ex)
+        cur = await Cur[fiat.pmcur.cur_id]
         edit_fiat = await self._post(
             "/p2p/public-api/v3/payment-details/edit",
             {
                 "id": fiat_id,
-                # "paymentMethodCode": code_pms,
-                # "currencyCode": cur,
+                "paymentMethodCode": pmex.exid,
+                "currencyCode": cur.ticker,
                 "name": name,
                 "attributes": {"version": "V1", "values": [{"name": "PAYMENT_DETAILS_NUMBER", "value": detail}]},
             },
         )
-        return edit_fiat
+        pmex = await Pmex.get(exid=edit_fiat["data"]["paymentMethod"]["code"], ex=self.agent.ex)
+        cur = await Cur.get(ticker=edit_fiat["data"]["currency"])
+        pmcur, _ = await Pmcur.get_or_create(cur=cur, pm_id=pmex.pm_id)
+        attrs = {a["name"]: a["value"] for a in edit_fiat["data"]["attributes"]["values"]}
+        f, _ = await Fiat.update_or_create(
+            {"detail": attrs["PAYMENT_DETAILS_NUMBER"]}, pmcur=pmcur, user_id=self.agent.user_id
+        )
+        await Fiatex.update_or_create({"exid": edit_fiat["data"]["id"]}, ex=self.agent.ex, fiat=f)
+        return f
 
-    # 28: Удаление
+    # 28: Удаление реквизита моего платежного метода
     async def fiat_del(self, fiat_id: int) -> bool:
         del_fiat = await self._post("/p2p/public-api/v3/payment-details/delete", {"id": fiat_id})
         return del_fiat
 
-    # 29: Список моих ad
+    # 29: Список моих объявлений
     async def my_ads(self, status: AdStatus = None) -> ListOfDicts:
-        mapping = {
-            AdStatus.defActive: "INACTIVE",
-            AdStatus.active: "ACTIVE"
-        }
+        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"}
         )
-        return [ad for ad in ads["data"] if ad["status"] == mapping[status]] if status else ads
+        return [ad for ad in ads["data"] if ad["status"] == mapping[status]] if status else ads['data']
 
-    # 30: Создание ad
+    # 30: Создание объявления
     async def ad_new(
         self,
         coin: Coin,
         cur: Cur,
         is_sell: bool,
-        pms: list[Pm],
-        amount: int,
+        fiats: list[Fiat],
+        amount: str,
         price: float,
+        min_fiat: str,
         is_float: bool = True,
-        min_fiat: int = None,
         details: str = None,
         autoreply: str = None,
-        status: AdStatus = AdStatus.active
+        status: AdStatus = AdStatus.active,
     ) -> Ad.pyd():
         create = await self._post(
             "/p2p/public-api/v2/offer/create",
@@ -126,45 +151,50 @@ class AgentClient(BaseAgentClient, AuthClient):
                 "type": "SALE" if is_sell else "BUY",
                 "initVolume": {"currencyCode": coin.ticker, "amount": f"{amount}"},
                 "orderRoundingRequired": False,
-                "price": {"type": "FIXED", "baseCurrencyCode": coin.ticker, "quoteCurrencyCode": cur.ticker, "value": price},
+                "price": {
+                    "type": "FIXED",
+                    "baseCurrencyCode": coin.ticker,
+                    "quoteCurrencyCode": cur.ticker,
+                    "value": price,
+                },
                 "orderAmountLimits": {"min": min_fiat},
                 "paymentConfirmTimeout": "PT15M" if is_sell else "PT3H",
                 "comment": "",
-                "paymentDetailsIds": pms,
+                "paymentDetailsIds": fiats,
             },
         )
         return create
 
     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})
-        return get_own['data']
+        get_own = await self._post("/p2p/public-api/v2/offer/get-user-own/", {"offerId": offer_id})
+        return get_own["data"]
 
-    # 31: Редактирование
+    # 31: Редактирование объявления
     async def ad_upd(
-            self,
-            offer_id: int,
-            amount: int,
-            pms: [Pm] = None,
-            price: float = None,
-            is_float: bool = None,
-            min_fiat: int = None,
-            details: str = None,
-            autoreply: str = None,
-            status: AdStatus = None,
+        self,
+        offer_id: int,
+        amount: int,
+        fiats: list[Fiat] = None,
+        price: float = None,
+        is_float: bool = None,
+        min_fiat: int = None,
+        details: str = None,
+        autoreply: str = None,
+        status: AdStatus = None,
     ) -> Ad.pyd():
         ad = await self._get_my_ad(offer_id)
         upd = await self._post(
             "/p2p/public-api/v2/offer/edit",
             {
                 "offerId": offer_id,
-                "paymentConfirmTimeout": ad['paymentConfirmTimeout'],
-                "type": ad['type'],
+                "paymentConfirmTimeout": ad["paymentConfirmTimeout"],
+                "type": ad["type"],
                 "orderRoundingRequired": False,
-                "price": {"type": "FIXED", "value": price},
-                "orderAmountLimits": {"min": min_fiat},
+                "price": {"type": "FIXED", "value": ad['price']['value']},
+                "orderAmountLimits": {"min": ad["orderAmountLimits"]["min"]},
                 "comment": "",  # TODO: comment
                 "volume": f"{amount}",
-                "paymentDetailsIds": pms,
+                "paymentDetailsIds": [a['id'] for a in ad["paymentDetails"]],
             },
         )
         return upd
@@ -172,18 +202,18 @@ class AgentClient(BaseAgentClient, AuthClient):
     # 32: Удаление
     async def ad_del(self, offer_id: int) -> bool:
         ad = await self._get_my_ad(offer_id)
-        ad_del = await self._post("/p2p/public-api/v2/offer/delete", {"type": ad['type'], "offerId": offer_id})
-        return ad_del
+        ad_del = await self._post("/p2p/public-api/v2/offer/delete", {"type": ad["type"], "offerId": offer_id})
+        return ad_del['status'] == "SUCCESS"
 
     # 33: Вкл/выкл объявления
     async def ad_switch(self, offer_id: int, active: bool) -> bool:
         ad = await self._get_my_ad(offer_id)
         if active:
-            active = await self._post("/p2p/public-api/v2/offer/activate", {"type": ad['type'], "offerId": offer_id})
-            return active
+            active = await self._post("/p2p/public-api/v2/offer/activate", {"type": ad["type"], "offerId": offer_id})
+            return active['status'] == "SUCCESS"
         else:
-            off = await self._post("/p2p/public-api/v2/offer/deactivate", {"type": ad['type'], "offerId": offer_id})
-            return off
+            off = await self._post("/p2p/public-api/v2/offer/deactivate", {"type": ad["type"], "offerId": offer_id})
+            return off['status'] == "SUCCESS"
 
     # 34: Вкл/выкл всех объявлений
     async def ads_switch(self, active: bool) -> bool:
@@ -208,6 +238,13 @@ class AgentClient(BaseAgentClient, AuthClient):
     # 39: Балансы моих монет
     async def my_assets(self) -> dict: ...
 
+
+
+
+
+
+
+
     # base_url = 'https://p2p.walletbot.me'
     # middle_url = '/p2p/'
 
@@ -244,3 +281,21 @@ class AgentClient(BaseAgentClient, AuthClient):
     async def order_payment_confirm(self, order_id: str):
         payment_confirm = await self._post("/p2p/public-api/v2/payment-details/confirm", {"orderId": order_id})
         return payment_confirm
+
+
+# async def main():
+#     await init_db(PG_DSN, models, True)
+#     exs = await Ex.filter(status__gt=ExStatus.plan).prefetch_related("agents__ex")
+#     agents = [[ag for ag in ex.agents if ag.auth][:2] for ex in exs]
+#     clients: list[tuple[AgentClient, AgentClient]] = [(t.client(), m.client()) for t, m in agents]
+#     taker, maker = clients[0]
+#     my_fiats = await taker.my_fiats()
+#     my_fiat = list(my_fiats.values())[0]
+#     coin = await Coin.get(ticker="USDT")
+#     cur = await Cur.get(ticker=my_fiat["currency"])
+#     fiatex = await Fiatex.get(exid=my_fiat['id']).prefetch_related('fiat')
+#     e = await taker.ad_new(coin=coin, cur=cur, is_sell=True, fiats=[fiatex.fiat], amount='10', price='120', min_fiat='500')
+#     print(e)
+#
+# if __name__ == "__main__":
+#     run(main())

{xync_client-0.0.16.dev4 → xync_client-0.0.16.dev9}/xync_client/TgWallet/ex.py

@@ -68,7 +68,7 @@ async def main():
     await init_db(PG_DSN, models, True)
     tgex = await Ex.get(name="TgWallet").prefetch_related("agents", "agents__ex")
     cl = tgex.client()
-    e = await cl.set_pmcurexs()
+    e = await cl.pms()
     print(e)
 
 

{xync_client-0.0.16.dev4 → xync_client-0.0.16.dev9/xync_client.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: xync-client
-Version: 0.0.16.dev4
+Version: 0.0.16.dev9
 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.16.dev4/tests/TestAgent.py

@@ -1,53 +0,0 @@
-import logging
-
-import pytest
-from xync_schema.enums import ExStatus, ExAction
-from xync_schema.models import Ex, TestEx
-
-from xync_client.Abc.BaseTest import BaseTest
-from xync_client.Abc.Agent import BaseAgentClient
-from xync_client.Abc.Base import BaseClient, DictOfDicts, ListOfDicts
-from xync_client.TgWallet.ex import ExClient
-
-
-@pytest.mark.asyncio(loop_scope="session")
-class TestAgent(BaseTest):
-    @pytest.fixture(scope="class", autouse=True)
-    async def clients(self) -> list[BaseClient]:
-        exs = await Ex.filter(status__gt=ExStatus.plan).prefetch_related("agents__ex")
-        clients: list[BaseAgentClient] = [[ag for ag in ex.agents if ag.auth].pop().client() for ex in exs]
-        yield clients
-        [await cl.close() for cl in clients]
-
-    # 0
-    async def test_get_orders(self, clients: list[BaseAgentClient]):
-        for client in clients:
-            get_orders: ListOfDicts = await client.get_orders()
-            ok = self.is_list_of_dicts(get_orders, False)
-            t, _ = await TestEx.update_or_create({"ok": ok}, ex_id=client.agent.ex_id, action=ExAction.get_orders)
-            assert t.ok, "No get orders"
-            logging.info(f"{client.agent.ex_id}:{ExAction.get_orders.name} - ok")
-
-    # 1
-    async def test_order_request(self, clients: list[BaseAgentClient]):
-        for client in clients:
-            await client.agent.fetch_related('ex', 'ex__agents')
-            ex_client: ExClient = client.agent.ex.client()
-            ads = await ex_client.ads('USDT', 'RUB', True)
-            for ad in ads:
-                order_request: dict | bool = await client.order_request(ad['id'], ad['orderAmountLimits']['min'])
-                if order_request:
-                    continue
-            ok = isinstance(order_request, dict)
-            t, _ = await TestEx.update_or_create({"ok": ok}, ex_id=client.agent.ex_id, action=ExAction.order_request)
-            assert t.ok, "No get orders"
-            logging.info(f"{client.agent.ex_id}:{ExAction.order_request.name} - ok")
-
-    # 25
-    async def test_my_fiats(self, clients: list[BaseAgentClient]):
-        for client in clients:
-            my_fiats: DictOfDicts = await client.my_fiats()
-            ok = self.is_dict_of_dicts(my_fiats)
-            t, _ = await TestEx.update_or_create({"ok": ok}, ex_id=client.agent.ex_id, action=ExAction.my_fiats)
-            assert t.ok, "No my fiats"
-            logging.info(f"{client.agent.ex_id}:{ExAction.my_fiats.name} - ok")