xync-client 0.0.16.dev3__tar.gz → 0.0.16.dev7__tar.gz

{xync_client-0.0.16.dev3/xync_client.egg-info → xync_client-0.0.16.dev7}/PKG-INFO

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

@@ -0,0 +1,76 @@
+import logging
+
+import pytest
+from xync_schema.enums import ExStatus, ExAction
+from xync_schema.models import Ex, TestEx, Fiat
+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.pyd() = await taker.fiat_new(fn)
+            ok = fiat_new["status"] == "SUCCESS"
+            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.pyd() = await taker.fiat_upd(fiat_id=fiats[-1]["id"], detail="347890789")
+            ok = fiat_upd["status"] == "SUCCESS"
+            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")

{xync_client-0.0.16.dev3 → xync_client-0.0.16.dev7}/xync_client/Abc/Agent.py

@@ -26,24 +26,24 @@ 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(): ...
 
-    # 27: Редактирование
+    # 27: Редактирование реквизита моего платежного метода
     @abstractmethod
     async def fiat_upd(self, fiat_id: int, detail: str, name: str = None) -> Fiat.pyd(): ...
 
-    # 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,
@@ -60,7 +60,7 @@ class BaseAgentClient(BaseAuthClient):
         status: AdStatus = AdStatus.active,
     ) -> Ad.pyd(): ...
 
-    # 31: Редактирование
+    # 31: Редактирование объявления
     @abstractmethod
     async def ad_upd(
         self,

{xync_client-0.0.16.dev3 → xync_client-0.0.16.dev7}/xync_client/Htx/ex.py

@@ -67,7 +67,7 @@ async def main():
     _ = await init_db(PG_DSN, models, True)
     ex = await Ex.get(name="Htx")
     cl = ExClient(ex)
-    await cl.cur_pms_map()
+    # await cl.cur_pms_map()
     await cl.set_pmcurexs()
     await cl.set_coinexs()
     await cl.close()

{xync_client-0.0.16.dev3 → xync_client-0.0.16.dev7}/xync_client/TgWallet/agent.py

@@ -1,11 +1,10 @@
 from enum import StrEnum
-from typing import Literal
 
 from xync_schema.enums import AdStatus
 
-from xync_client.Abc.Base import ListOfDicts, MapOfIdsList, DictOfDicts
+from xync_client.Abc.Base import ListOfDicts, DictOfDicts
 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
 from xync_schema.pydantic import FiatNew
 
 from xync_client.Abc.Agent import BaseAgentClient
@@ -22,37 +21,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",
+        )
+        confirm = await self._post(
+            "/p2p/public-api/v2/offer/order/confirm", {"orderId": request["id"], "type": ad["type"]}
         )
-        return request
+        return confirm
 
     # 25: Список реквизитов моих платежных методов
     async def my_fiats(self, cur: Cur = None) -> DictOfDicts:
@@ -60,9 +65,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,39 +78,46 @@ class AgentClient(BaseAgentClient, AuthClient):
                 "attributes": {"version": "V1", "values": [{"name": "PAYMENT_DETAILS_NUMBER", "value": fiat.detail}]},
             },
         )
-        return add_fiat
+        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: Редактирование
+    # 27: Редактирование реквизита моего платежного метода
     async def fiat_upd(self, fiat_id: int, detail: str, name: str = None) -> Fiat.pyd():
+        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)
         edit_fiat = await self._post(
             "/p2p/public-api/v3/payment-details/edit",
             {
                 "id": fiat_id,
-                # "paymentMethodCode": code_pms,
-                # "currencyCode": cur,
+                "paymentMethodCode": pmex.exid,
+                "currencyCode": fiat.pmcur.cur_id,
                 "name": name,
                 "attributes": {"version": "V1", "values": [{"name": "PAYMENT_DETAILS_NUMBER", "value": detail}]},
             },
         )
         return edit_fiat
 
-    # 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
 
-    # 30: Создание ad
+    # 30: Создание объявления
     async def ad_new(
         self,
         coin: Coin,
@@ -118,7 +130,7 @@ class AgentClient(BaseAgentClient, AuthClient):
         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,7 +138,12 @@ 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": "",
@@ -136,29 +153,29 @@ class AgentClient(BaseAgentClient, AuthClient):
         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,
+        pms: [Pm] = 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},
@@ -172,17 +189,17 @@ 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})
+        ad_del = await self._post("/p2p/public-api/v2/offer/delete", {"type": ad["type"], "offerId": offer_id})
         return ad_del
 
     # 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})
+            active = await self._post("/p2p/public-api/v2/offer/activate", {"type": ad["type"], "offerId": offer_id})
             return active
         else:
-            off = await self._post("/p2p/public-api/v2/offer/deactivate", {"type": ad['type'], "offerId": offer_id})
+            off = await self._post("/p2p/public-api/v2/offer/deactivate", {"type": ad["type"], "offerId": offer_id})
             return off
 
     # 34: Вкл/выкл всех объявлений

{xync_client-0.0.16.dev3 → xync_client-0.0.16.dev7}/xync_client/TgWallet/ex.py

@@ -1,12 +1,13 @@
 from asyncio import run
 from x_model import init_db
+
 from xync_schema import models
 from xync_schema.models import Ex
 
+from xync_client.loader import PG_DSN
+from xync_client.Abc.Ex import BaseExClient
 from xync_client.Abc.Base import FlatDict, DictOfDicts, MapOfIdsList, ListOfDicts
 from xync_client.TgWallet.auth import AuthClient
-from xync_client.Abc.Ex import BaseExClient
-from xync_client.loader import PG_DSN
 
 
 class ExClient(BaseExClient, AuthClient):
@@ -67,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.dev3 → xync_client-0.0.16.dev7/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.dev3
+Version: 0.0.16.dev7
 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.dev3/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")