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

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

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

@@ -28,11 +28,11 @@ class BaseAgentClient(BaseAuthClient):
 
     # 26: Создание реквизита моего платежного метода
     @abstractmethod
-    async def fiat_new(self, fiat: FiatNew) -> Fiat.pyd(): ...
+    async def fiat_new(self, fiat: FiatNew) -> Fiat: ...
 
     # 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: Удаление реквизита моего платежного метода
     @abstractmethod
@@ -50,11 +50,11 @@ class BaseAgentClient(BaseAuthClient):
         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,
@@ -66,7 +66,7 @@ class BaseAgentClient(BaseAuthClient):
         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.dev7 → xync_client-0.0.16.dev9}/xync_client/TgWallet/agent.py

@@ -1,14 +1,18 @@
+from asyncio import run
 from enum import StrEnum
 
-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, DictOfDicts
+from xync_client.Abc.Base import ListOfDicts, DictOfDicts, BaseClient
 from xync_client.TgWallet.auth import AuthClient
-from xync_schema.models import Cur, Coin, OrderStatus, Pmex, Fiat, Ad, Pm, Pmcur, Fiatex
+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):
@@ -89,20 +93,29 @@ class AgentClient(BaseAgentClient, AuthClient):
         return f
 
     # 27: Редактирование реквизита моего платежного метода
-    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:
         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)
+        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": pmex.exid,
-                "currencyCode": fiat.pmcur.cur_id,
+                "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: Удаление реквизита моего платежного метода
     async def fiat_del(self, fiat_id: int) -> bool:
@@ -115,7 +128,7 @@ class AgentClient(BaseAgentClient, AuthClient):
         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: Создание объявления
     async def ad_new(
@@ -123,11 +136,11 @@ class AgentClient(BaseAgentClient, AuthClient):
         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,
@@ -147,7 +160,7 @@ class AgentClient(BaseAgentClient, AuthClient):
                 "orderAmountLimits": {"min": min_fiat},
                 "paymentConfirmTimeout": "PT15M" if is_sell else "PT3H",
                 "comment": "",
-                "paymentDetailsIds": pms,
+                "paymentDetailsIds": fiats,
             },
         )
         return create
@@ -161,7 +174,7 @@ class AgentClient(BaseAgentClient, AuthClient):
         self,
         offer_id: int,
         amount: int,
-        pms: [Pm] = None,
+        fiats: list[Fiat] = None,
         price: float = None,
         is_float: bool = None,
         min_fiat: int = None,
@@ -177,11 +190,11 @@ class AgentClient(BaseAgentClient, AuthClient):
                 "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
@@ -190,17 +203,17 @@ class AgentClient(BaseAgentClient, AuthClient):
     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
+        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
+            return active['status'] == "SUCCESS"
         else:
             off = await self._post("/p2p/public-api/v2/offer/deactivate", {"type": ad["type"], "offerId": offer_id})
-            return off
+            return off['status'] == "SUCCESS"
 
     # 34: Вкл/выкл всех объявлений
     async def ads_switch(self, active: bool) -> bool:
@@ -225,6 +238,13 @@ class AgentClient(BaseAgentClient, AuthClient):
     # 39: Балансы моих монет
     async def my_assets(self) -> dict: ...
 
+
+
+
+
+
+
+
     # base_url = 'https://p2p.walletbot.me'
     # middle_url = '/p2p/'
 
@@ -261,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.dev7 → xync_client-0.0.16.dev9/xync_client.egg-info}/PKG-INFO

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

@@ -1,76 +0,0 @@
-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")