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

{xync_client-0.0.11.dev0 → xync_client-0.0.11.dev4}/.gitignore

@@ -5,4 +5,5 @@
 __pycache__
 /dist
 /*.egg-info
-/build
+/build
+.vscode

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: xync-client
-Version: 0.0.11.dev0
+Version: 0.0.11.dev4
 Author-email: Mike Artemiev <mixartemev@gmail.com>
 Project-URL: Homepage, https://gitlab.com/XyncNet/client
 Project-URL: Repository, https://gitlab.com/XyncNet/client

{xync_client-0.0.11.dev0 → xync_client-0.0.11.dev4}/tests/Binance/test_binance.py

@@ -1,14 +1,12 @@
 from x_model import init_db
-from xync_client.loader import DSN, BKEY, BSEC
+from xync_client.loader import PG_DSN
 from xync_schema import models
 from xync_schema.models import Ex
 
-from xync_client.Binance.ex import Client
-
 
 async def test_cur_filter():
-    _ = await init_db(DSN, models, True)
+    _ = await init_db(PG_DSN, models, True)
     ex = await Ex.get(name="Binance")
-    bn = Client(ex, (BKEY, BSEC))
+    bn = await ex.client()
     resp = await bn.cur_pms_map()
     assert len(resp[0]) and len(resp[1]), "No data"

{xync_client-0.0.11.dev0 → xync_client-0.0.11.dev4}/tests/test_ex.py

@@ -7,7 +7,6 @@ from x_model import init_db
 from xync_schema import models
 from xync_schema.models import Agent, ExAction, TestEx
 
-from xync_client.TgWallet.ex import PublicClient
 from xync_client.loader import PG_DSN
 
 
@@ -36,26 +35,26 @@ class TestWallet:
     # 20 - all_pms
     async def test_all_pms(self, cl):
         pms = await cl.pms()
-        ok = pms and cl.is_pms(pms)
+        pms and cl.is_pms(pms)
         test, _ = await TestEx.update_or_create({"ok": bool(pms)}, ex=cl.ex, action=ExAction.pms)
         assert test.ok, "No pms"
 
     # 21 - all_curs
     async def test_all_curs(self, cl):
         curs = await cl.curs()
-        test, _ = await TestEx.update_or_create({"ok": bool(curs)}, ex__name="TgWallet", action=ExAction.curs)
+        test, _ = await TestEx.update_or_create({"ok": bool(curs)}, ex=cl.ex, action=ExAction.curs)
         assert test.ok, "No curs"
 
     # 22 - all_pms
     async def test_cur_pms_map(self, cl):
         pms = await cl.cur_pms_map()
-        test, _ = await TestEx.update_or_create({"ok": bool(pms)}, ex__name="TgWallet", action=ExAction.pms)
+        test, _ = await TestEx.update_or_create({"ok": bool(pms)}, ex=cl.ex, action=ExAction.pms)
         assert test.ok, "No pms"
 
     # 23 - all_coins
     async def test_all_coins(self, cl):
         coins = await cl.coins()
-        test, _ = await TestEx.update_or_create({"ok": bool(coins)}, ex__name="TgWallet", action=ExAction.coins)
+        test, _ = await TestEx.update_or_create({"ok": bool(coins)}, ex=cl.ex, action=ExAction.coins)
         assert test.ok, "No coins"
 
     # 24 - all_ads
@@ -65,4 +64,4 @@ class TestWallet:
                 for tt in True, False:
                     ads = await cl.ads(coin, cur, tt)
                     assert len(ads), "No data"
-        await TestEx.update_or_create({"ok": bool(ads)}, ex__name="TgWallet", action=ExAction.ads)
+        await TestEx.update_or_create({"ok": bool(ads)}, ex=cl.ex, action=ExAction.ads)

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

@@ -1,33 +1,12 @@
-import logging
 from abc import abstractmethod
 
-from aiohttp import ClientResponse
-from aiohttp.http_exceptions import HttpProcessingError
-from x_client.aiohttp import Client as HttpClient
+from xync_client.Abc.Auth import BaseAuthClient
 from xync_schema.enums import PmType
-from xync_schema.models import Agent, Ex, OrderStatus, Coin, Cur, Order, Pm, Ad, AdStatus, Fiat
+from xync_schema.models import OrderStatus, Coin, Cur, Order, Pm, Ad, AdStatus, Fiat
 from xync_schema.pydantic import FiatNew
 
 
-class Client(HttpClient):
-    def __init__(self, agent: Agent):
-        self.agent: Agent = agent
-        assert isinstance(agent.ex, Ex), "`ex` should be fetched in `agent`"
-        assert agent.ex.host_p2p, "`ex.host_p2p` shouldn't be empty"
-        self.meth = {
-            "GET": self._get,
-            "POST": self._post,
-        }
-        super().__init__(agent.ex.host_p2p)
-
-    # Login: returns auth headers dict
-    async def _get_auth_hdrs(self) -> dict[str, str]:
-        return self.agent.auth
-
-    async def login(self) -> None:
-        auth_hdrs: dict[str, str] = await self._get_auth_hdrs()
-        self.session.headers.update(auth_hdrs)
-
+class BaseAgentClient(BaseAuthClient):
     # 0: Получшение ордеров в статусе status, по монете coin, в валюте coin, в направлении is_sell: bool
     @abstractmethod
     async def get_orders(
@@ -120,22 +99,3 @@ class Client(HttpClient):
     # 38: Поставить отзыв юзеру
     @abstractmethod
     async def rate_user(self, positive: bool) -> bool: ...
-
-    async def _proc(self, resp: ClientResponse, data: dict = None) -> dict | str:
-        try:
-            return await super()._proc(resp)
-        except HttpProcessingError as e:
-            if e.code == 401:
-                logging.warning(e)
-                await self.login()
-                res = await self.meth[resp.method](resp.url.path, data)
-                return res
-
-    @staticmethod
-    async def payment_methods(*methods_list):
-        payment_list = []
-        for method in methods_list:
-            method_cleared = method.lower().replace(" ", "").replace("-", "").replace("(", "").replace(")", "")
-            if method_cleared not in payment_list:
-                payment_list.append(method_cleared)
-        return payment_list

xync_client-0.0.11.dev4/xync_client/Abc/Auth.py

@@ -0,0 +1,9 @@
+from xync_client.Abc.Base import BaseClient
+from xync_schema.models import Agent
+
+
+class BaseAuthClient(BaseClient):
+    def __init__(self, agent: Agent):
+        self.headers.update(agent.auth)
+        self.agent = agent
+        super().__init__(agent.ex)

xync_client-0.0.11.dev4/xync_client/Abc/Base.py

@@ -0,0 +1,12 @@
+from x_client.aiohttp import Client
+from xync_schema.models import Ex
+
+DictOfDicts = dict[int | str, dict]
+ListOfDicts = list[dict]
+FlatDict = dict[int | str, str]
+MapOfIdsList = dict[int | str, list[int | str]]
+
+
+class BaseClient(Client):
+    def __init__(self, ex: Ex):
+        super().__init__(ex.host_p2p)

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

@@ -1,13 +1,12 @@
 import logging
 import re
 from abc import abstractmethod
-from typing import TypeGuard
 
-from x_client.aiohttp import Client
+from xync_client.Abc.Base import BaseClient, DictOfDicts, FlatDict, ListOfDicts, MapOfIdsList
 from xync_schema.models import Ex, Coin, Cur, Pm, Pmex, Curex, Pmcur, Pmcurex, Coinex
 
 
-class ExClient(Client):
+class BaseExClient(BaseClient):
     ex: Ex
     pm_map: dict[str, str] = {
         "Юmoney": "YooMoney",
@@ -23,51 +22,47 @@ class ExClient(Client):
 
     def __init__(self, ex: Ex):
         self.ex = ex
-        self.acrs: dict[str, str] = {}  # for pm norm
-        super().__init__(ex.host_p2p)
-
-    @staticmethod
-    def is_pms(val: dict[int | str, dict]) -> TypeGuard[dict[int | str, dict]]:
-        return all(isinstance(k, int | str) and isinstance(v, dict) for k, v in val.items())
+        self.acronyms: dict[str, str] = {}  # for pm norm
+        super().__init__(ex)
 
     # 20: Список всех платежных методов на бирже
     @abstractmethod
-    async def pms(self) -> dict[int | str, dict]:  # {pm.exid: pm}
+    async def pms(self) -> DictOfDicts:  # {pm.exid: pm}
         ...
 
     # 21: Список поддерживаемых валют
     @abstractmethod
-    async def curs(self) -> dict[int | str, str]:  # {cur.exid: cur.ticker}
+    async def curs(self) -> FlatDict:  # {cur.exid: cur.ticker}
         ...
 
     # 22: Список платежных методов по каждой валюте
     @abstractmethod
-    async def cur_pms_map(self) -> dict[int | str, list[int | str]]:  # {cur.exid: [pm.exid]}
+    async def cur_pms_map(self) -> MapOfIdsList:  # {cur.exid: [pm.exid]}
         ...
 
     # 23: Список торгуемых монет (с ограничениям по валютам, если есть)
     @abstractmethod
-    async def coins(self) -> dict[int | str, str]:  # {coin.exid: coin.ticker}
+    async def coins(self) -> FlatDict:  # {coin.exid: coin.ticker}
         ...
 
     # 24: Список объяв по (buy/sell, cur, coin, pm)
     @abstractmethod
     async def ads(
         self, coin_exid: str, cur_exid: str, is_sell: bool, pm_exids: list[str | int] = None
-    ) -> list[dict]:  # [ad]
+    ) -> ListOfDicts:  # {ad.id: ad}
         ...
 
-    def _pmnorm(self, s: str, idtf: str = None) -> str:
+    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())
             if len(acr) > 2:
                 title = title.replace(acr, "", 1)
-                self.acrs[acr] = title  # заполняем словарь аббревиатур
+                self.acronyms[acr] = title  # заполняем словарь аббревиатур
             return title
 
         def find_and_replace_only_acro(title: str) -> str:
-            if " " not in title and title.isupper() and title in self.acrs:
-                title = self.acrs[title]
+            if " " not in title and title.isupper() and title in self.acronyms:
+                title = self.acronyms[title]
             return title
 
         def remove(rms: str | list[str], st: str, regexp: bool = False) -> str:
@@ -120,17 +115,17 @@ class ExClient(Client):
     async def set_pmcurexs(self):
         # Pms
         pmsd = {k: v for k, v in sorted((await self.pms()).items(), key=lambda x: x[1]["name"])}  # sort by name
-        pms: dict[int | str, Pm] = {}
+        pms: dict[int | str, Pm] = dict({})
         prev = 0, "", ""  # id, normd-name, orig-name
         for k, pm in pmsd.items():
             norm = self._pmnorm(pm["name"])
             if prev[1:] == (norm, pm["name"]):
-                logging.warning(f"Pm: '{pm['name']}' duplicated with ids {prev[0]}:{k} on {self.ex.name}")
+                logging.warning(f"Pm: '{pm['name']}' duplicated with ids {prev[0]}: {k} on {self.ex.name}")
                 pm_ = pms.get(prev[0], (await Pm.get_or_none(name=prev[2])) or await Pm.get_or_none(identifier=prev[1]))
                 await Pmex.update_or_create({"pm": pm_}, ex=self.ex, exid=k, name=pm["name"])
             elif prev[1] == norm:
                 logging.error(
-                    f"Pm: '{pm['name']}' and '{prev[2]}' overnormed as '{norm}' with ids {prev[0]}:{k} on {self.ex.name}"
+                    f"Pm: '{pm['name']}' & '{prev[2]}' overnormd as '{norm}' with ids {prev[0]}: {k} on {self.ex.name}"
                 )
                 await Pmex.update_or_create(
                     {"pm": pms.get(prev[0], await Pm.get(name=prev[2]))}, ex=self.ex, exid=k, name=pm["name"]

{xync_client-0.0.11.dev0 → xync_client-0.0.11.dev4}/xync_client/Abc/Order.py

@@ -1,13 +1,22 @@
 from abc import abstractmethod
 
-from x_client.aiohttp import Client
-from xync_schema.models import Order
-
-
-class OrderClient:
-    def __init__(self, cl: Client, order: Order):
-        self.cl: Client = cl
-        self.order: Order = order
+from xync_client.Abc.Auth import BaseAuthClient
+from xync_schema.models import Order, Agent
+
+
+class BaseOrderClient(BaseAuthClient):
+    order: Order
+    is_sell: bool
+    im_maker: bool
+    im_seller: bool
+
+    def __init__(self, agent: Agent, order: Order):
+        self.order = order
+        self.is_sell = order.ad.direction.sell
+        # self.im_maker = order.ad.agent_id == agent.id
+        self.im_maker = order.taker_id != agent.id
+        self.im_seller = self.is_sell and self.im_maker
+        super().__init__(agent)
 
     # 2: [T] Отмена запроса на сделку
     @abstractmethod

xync_client-0.0.11.dev4/xync_client/Abc/Test.py

@@ -0,0 +1,21 @@
+from typing import TypeGuard
+
+from xync_client.Abc.Base import DictOfDicts, ListOfDicts, FlatDict, MapOfIdsList
+
+
+class BaseTest:
+    @staticmethod
+    def is_dod(dct: DictOfDicts) -> TypeGuard[DictOfDicts]:
+        return all(isinstance(k, int | str) and isinstance(v, dict) for k, v in dct.items())
+
+    @staticmethod
+    def is_lod(lst: ListOfDicts) -> TypeGuard[ListOfDicts]:
+        return all(isinstance(el, dict) for el in lst)
+
+    @staticmethod
+    def is_fd(dct: FlatDict) -> TypeGuard[FlatDict]:
+        return all(isinstance(k, int | str) and isinstance(v, str) for k, v in dct.items())
+
+    @staticmethod
+    def is_moil(dct: MapOfIdsList) -> TypeGuard[MapOfIdsList]:
+        return all(isinstance(k, int | str) and isinstance(v, str) for k, v in dct.items())

{xync_client-0.0.11.dev0 → xync_client-0.0.11.dev4}/xync_client/Binance/ex.py

@@ -1,16 +1,11 @@
-from asyncio import run
-
-from x_model import init_db
 from xync_schema.enums import PmType
 
-from xync_client.Abc.Ex import ExClient
+from xync_client.Abc.Ex import BaseClient
 from xync_client.Binance.sapi import Sapi
-from xync_client.loader import PG_DSN, BKEY, BSEC
-from xync_schema import models
 from xync_schema.models import Ex
 
 
-class Client(ExClient):
+class Client(BaseClient):
     def __init__(self, ex: Ex, bkeys):
         self.sapi = Sapi(*bkeys)
         super().__init__(ex)
@@ -74,12 +69,12 @@ class Client(ExClient):
 #         }
 
 
-async def main():
-    _ = await init_db(PG_DSN, models, True)
-    ex = await Ex.get(name="Binance")
-    cl = Client(ex, (BKEY, BSEC))
-    await cl.set_pmcurexs()
-    await cl.close()
-
-
-run(main())
+# async def main():
+#     _ = await init_db(PG_DSN, models, True)
+#     ex = await Ex.get(name="Binance")
+#     cl = Client(ex, (BKEY, BSEC))
+#     await cl.set_pmcurexs()
+#     await cl.close()
+#
+#
+# run(main())

xync_client-0.0.11.dev4/xync_client/BingX/ex.py

@@ -0,0 +1,52 @@
+from asyncio import run
+
+from x_model import init_db
+from xync_schema import models
+from xync_schema.models import Ex
+
+from xync_client.Abc.Ex import BaseExClient
+from xync_client.loader import PG_DSN
+
+
+class Client(BaseExClient):
+    # 20: order_request
+    async def pms(self):
+        # for cur in self.curs():
+        for cur in ["RUB", "THB", "PHP"]:  # todo: temp hardcode curs
+            params = {
+                "coinName": "USDT",
+                "tradeCoinName": cur,
+                "type": "1",
+                "amount": "500",
+            }
+            pms = await self._get("/api/fiat/v1/rapid-buy-integration", params=params)
+
+        return [pm.get("paymentMethod")["name"] for pm in pms["data"]["matchOptimalAdvertListVo"]["optimals"]]
+
+    # 21: order_request_ask
+    async def curs(self):
+        pass
+
+    # 22: cur_pms_map
+    async def cur_pms_map(self):
+        pass
+
+    # 23: coins
+    async def coins(self):
+        pass
+
+    # 24: ads
+    async def ads(self, coin_exid: str, cur_exid: str, is_sell: bool, pm_exids: list[str | int] = None):
+        pass
+
+
+async def main():
+    _ = await init_db(PG_DSN, models, True)
+    bg = await Ex.get(name="BingX")
+    cl = Client(bg)
+    await cl.curs()
+    await cl.pms()
+    await cl.close()
+
+
+run(main())

xync_client-0.0.11.dev4/xync_client/BingX/test/main.py

@@ -0,0 +1,22 @@
+import requests
+
+headers = {
+    "app_version": "8.10.0",
+    "device_id": "64a8c630-acc2-11ef-aa5e-9f6ee3baa1a5",
+    "lang": "ru-RU",
+    "platformid": "30",
+    "sign": "5679FBAAF1D0A199E6B0975616B44807220C5FC8824D41F0DE21D2261F2D8E18",
+    "timestamp": "1733496004073",
+    "traceid": "8557cddbfe574e07b36c3014b5773358",
+}
+
+params = {
+    "coinName": "USDT",
+    "tradeCoinName": "USD",
+    "type": "1",
+    "amount": "500",
+}
+
+response = requests.get("https://api-app.qq-os.com/api/fiat/v1/rapid-buy-integration", params=params, headers=headers)
+
+print([i.get("paymentMethod")["name"] for i in response.json()["data"]["matchOptimalAdvertListVo"]["optimals"]])

{xync_client-0.0.11.dev0 → xync_client-0.0.11.dev4}/xync_client/BitGet/agent.py

@@ -7,11 +7,11 @@ from xync_schema.enums import AdStatus, PmType, OrderStatus
 from xync_schema.models import User, Pm, Coin, Cur, Ad, Fiat, Order, Agent
 from xync_schema.pydantic import FiatNew
 
-from xync_client.Abc.Agent import Client as BaseClient
+from xync_client.Abc.Agent import BaseAgentClient
 from xync_client.loader import PG_DSN
 
 
-class Client(BaseClient):
+class Client(BaseAgentClient):
     headers = {"accept-language": "ru,en;q=0.9"}
 
     def __init__(self, agent: Agent):
@@ -106,7 +106,7 @@ async def main():
     _ = await init_db(PG_DSN, models, True)
     agent = await Agent.get(ex__name="BitGet").prefetch_related("ex")
     cl = Client(agent)
-    fts = await cl.my_fiats()
+    await cl.my_fiats()
     await cl.close()
 
 

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

@@ -1,14 +1,18 @@
+import json
+import subprocess
 from asyncio import run
 
 from x_model import init_db
 from xync_schema import models
 from xync_schema.models import Cur, Ex
 
-from xync_client.Abc.Ex import ExClient
+from xync_client.Abc.Ex import BaseClient
 from xync_client.loader import PG_DSN
 
 
-class Client(ExClient):
+class Client(BaseClient):
+    headers = {"accept-language": "ru,en;q=0.9"}
+
     async def curs(self) -> dict[str, str]:
         curs = (await self._post("/v1/p2p/pub/currency/queryAllCoinAndFiat"))["data"]["fiatInfoRespList"]
         return {cur["fiatCode"]: cur["fiatCode"] for cur in curs}
@@ -18,7 +22,13 @@ class Client(ExClient):
         return {coin["coinCode"]: coin["coinCode"] for coin in coins}
 
     async def pms(self, cur: Cur = None) -> dict[int, dict]:
-        curs = (await self._post("/v1/p2p/pub/currency/queryAllCoinAndFiat"))["data"]["fiatInfoRespList"]
+        # curs = (await self._post("pub/currency/queryAllCoinAndFiat"))["data"]["fiatInfoRespList"]
+        p = subprocess.Popen(
+            ["node", "req.mjs", "user/queryPaymethods", '{"languageType":6}', self.headers], stdout=subprocess.PIPE
+        )
+        out = p.stdout.read().decode()
+        curs: list[dict] = json.loads(out)
+
         pmcurs = {cur["fiatCode"]: cur["paymethodInfo"] for cur in curs}
         pp = {}
         [
@@ -69,7 +79,7 @@ async def main():
     # await cl.curs()
     # await cl.coins()
     # await cl.ads("BTC", "RUB", True, [1, 289, 375])
-    # await cl.pms()
+    await cl.pms()
     # await cl.cur_pms_map()
     await cl.set_pmcurexs()
     await cl.set_coinexs()

{xync_client-0.0.11.dev0 → xync_client-0.0.11.dev4}/xync_client/Gate/premarket.py

@@ -2,7 +2,7 @@ from x_client.aiohttp import Client
 
 
 class Priv(Client):
-    base_url = "www.gate.io"
+    host = "www.gate.io"
 
     def __init__(self, uid: str, pver: str):
         self.headers = {

{xync_client-0.0.11.dev0 → xync_client-0.0.11.dev4}/xync_client/Gate/pub.py

@@ -7,14 +7,18 @@ from x_model import init_db
 from xync_schema import models
 from xync_schema.models import Coin, Cur, Pm, Ad, Ex, Curex
 
-from xync_client.Abc import PublicClient as BasePublicClient
+from xync_client.Abc.Base import MapOfIdsList
+from xync_client.Abc.Ex import BaseExClient
 from xync_client.loader import PG_DSN
 
 
-class PublicClient(BasePublicClient):
+class PublicClient(BaseExClient):
+    async def cur_pms_map(self) -> MapOfIdsList:
+        pass
+
     async def curs(self) -> list[Cur]:
         curs = await self._post("/json_svr/buy_crypto_fiat_setting")
-        curs = [(await Cur.update_or_create(ticker=cur["fiat"]))[0] for cur in curs if cur["p2p"]]
+        curs = [cur["fiat"] for cur in curs if cur["p2p"]]
         curexs = [Curex(cur=c, ex=self.ex) for c in curs]
         await Curex.bulk_create(curexs, ignore_conflicts=True)
         return curs

{xync_client-0.0.11.dev0 → xync_client-0.0.11.dev4}/xync_client/KuCoin/pub.py

@@ -4,11 +4,15 @@ from x_model import init_db
 from xync_schema import models
 from xync_schema.models import Coin, Cur, Pm, Ad, Ex, Curex
 
-from xync_client.Abc import PublicClient as BasePublicClient
+from xync_client.Abc.Base import MapOfIdsList
+from xync_client.Abc.Ex import BaseExClient
 from xync_client.loader import PG_DSN
 
 
-class PublicClient(BasePublicClient):
+class ExClient(BaseExClient):
+    async def cur_pms_map(self) -> MapOfIdsList:
+        pass
+
     async def curs(self) -> list[Cur]:
         curs = (await self._get("/_api/otc/dictionary/getData", {"type": "LEGAL"}))["data"]
         curs = [(await Cur.update_or_create(ticker=cur["typeCode"]))[0] for cur in curs]
@@ -34,7 +38,7 @@ class PublicClient(BasePublicClient):
 async def main():
     _ = await init_db(PG_DSN, models, True)
     bg = await Ex.get(name="KuCoin")
-    cl = PublicClient(bg)
+    cl = ExClient(bg)
     # await cl.curs()
     # await cl.coins()
     await cl.pms()

xync_client-0.0.11.dev0/xync_client/Okx/pub.py → xync_client-0.0.11.dev4/xync_client/Okx/ex.py

@@ -2,23 +2,24 @@ from asyncio import run
 
 from x_model import init_db
 from xync_schema import models
-from xync_schema.models import Coin, Cur, Pm, Ad, Ex, Curex
+from xync_schema.models import Coin, Cur, Pm, Ad, Ex
 
-from xync_client.Abc import PublicClient as BasePublicClient
+from xync_client.Abc.Base import MapOfIdsList, ListOfDicts
+from xync_client.Abc.Ex import BaseExClient
 from xync_client.loader import PG_DSN
 
 
-class PublicClient(BasePublicClient):
+class ExClient(BaseExClient):
+    async def cur_pms_map(self) -> MapOfIdsList:
+        pass
+
     async def curs(self) -> list[Cur]:
         curs = (await self._get("/v3/users/common/list/currencies"))["data"]
-        curs = [(await Cur.update_or_create(ticker=cur["isoCode"]))[0] for cur in curs]
-        curexs = [Curex(cur=c, ex=self.ex) for c in curs]
-        await Curex.bulk_create(curexs, ignore_conflicts=True)
         return curs
 
     async def coins(self, cur: Cur = None) -> list[Coin]: ...
 
-    async def pms(self, cur: Cur = None) -> list[Pm]:
+    async def pms(self, cur: Cur = None) -> ListOfDicts:
         pmcurs = {
             cur.ticker: (await self._get("/v3/c2c/configs/receipt/templates", {"quoteCurrency": cur.ticker}))["data"]
             for cur in await self.curs()
@@ -35,7 +36,7 @@ class PublicClient(BasePublicClient):
 async def main():
     _ = await init_db(PG_DSN, models, True)
     bg = await Ex.get(name="Okx")
-    cl = PublicClient(bg)
+    cl = ExClient(bg)
     # await cl.curs()
     # await cl.coins()
     await cl.pms()

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

@@ -5,7 +5,7 @@ from x_client.http import Client as HttpClient
 from xync_schema.models import User, Cur, Order, Coin, OrderStatus, Pmex
 from xync_schema.pydantic import FiatNew
 
-from xync_client.Abc.Agent import Client as BaseClient
+from xync_client.Abc.Agent import BaseAgentClient
 from xync_client.TgWallet.pyro import PyroClient
 
 
@@ -17,16 +17,13 @@ class Status(IntEnum):
     ALL_ACTIVE = OrderStatus.active
 
 
-class Client(BaseClient):
+class AgentClient(BaseAgentClient):
     async def order_request(self, ad_id: int, amount: float) -> Order:
         pass
 
     async def _get_auth_hdrs(self) -> dict[str, str]:
         pyro = PyroClient(self.agent)
         init_data = await pyro.get_init_data()
-        # async with ClientSession(self.agent.ex.url_login) as sess:
-        #     resp = await sess.post('/api/v1/users/auth/', data=init_data, headers={'content-type': 'application/json;charset=UTF-8'})
-        #     tokens = await resp.json()
         tokens = HttpClient("walletbot.me")._post("/api/v1/users/auth/", init_data)
         return {"Wallet-Authorization": tokens["jwt"], "Authorization": "Bearer " + tokens["value"]}
 

xync_client-0.0.11.dev4/xync_client/TgWallet/auth.py

@@ -0,0 +1,39 @@
+import logging
+
+from aiohttp import ClientResponse
+from aiohttp.http_exceptions import HttpProcessingError
+from x_client.http import Client as HttpClient
+from xync_client.Abc.Auth import BaseAuthClient
+from xync_schema.models import Agent
+
+from xync_client.TgWallet.pyro import PyroClient
+
+
+class AuthClient(BaseAuthClient):
+    def __init__(self, agent: Agent):
+        self.meth = {
+            "GET": self._get,
+            "POST": self._post,
+            "DELETE": self._delete,
+        }
+        super().__init__(agent)
+
+    async def _get_auth_hdrs(self) -> dict[str, str]:
+        pyro = PyroClient(self.agent)
+        init_data = await pyro.get_init_data()
+        tokens = HttpClient("walletbot.me")._post("/api/v1/users/auth/", init_data)
+        return {"Wallet-Authorization": tokens["jwt"], "Authorization": "Bearer " + tokens["value"]}
+
+    async def login(self) -> None:
+        auth_hdrs: dict[str, str] = await self._get_auth_hdrs()
+        self.session.headers.update(auth_hdrs)
+
+    async def _proc(self, resp: ClientResponse, data: dict = None) -> dict | str:
+        try:
+            return await super()._proc(resp)
+        except HttpProcessingError as e:
+            if e.code == 401:
+                logging.warning(e)
+                await self.login()
+                res = await self.meth[resp.method](resp.url.path, data)
+                return res

xync_client-0.0.11.dev4/xync_client/TgWallet/ex.py

@@ -0,0 +1,40 @@
+from xync_client.Abc.Auth import BaseAuthClient
+from xync_schema.models import Pm
+
+from xync_client.Abc.Ex import BaseExClient
+
+
+class ExClient(BaseExClient, BaseAuthClient):
+    async def curs(self) -> dict[str, str]:
+        coins_curs = await self._post("/p2p/public-api/v2/currency/all-supported")
+        return {c["code"]: c["code"] for c in coins_curs["data"]["fiat"]}
+
+    async def coins(self) -> dict[str, str]:
+        coins_curs = await self._post("/p2p/public-api/v2/currency/all-supported")
+        return {c["code"]: c["code"] for c in coins_curs["data"]["crypto"]}
+
+    async def _pms(self, cur: str = "RUB") -> dict[str, dict]:
+        pms = await self._post("/p2p/public-api/v3/payment-details/get-methods/by-currency-code", {"currencyCode": cur})
+        return {pm["code"]: {"name": pm["nameEng"]} for pm in pms["data"]}
+
+    async def pms(self) -> dict[str, dict]:
+        pms = {}
+        for cur in await self.curs():
+            for k, pm in (await self._pms(cur)).items():
+                pms.update({k: pm})
+        return pms
+
+    async def cur_pms_map(self) -> dict[str, list[str]]:
+        return {cur: list(await self._pms(cur)) for cur in await self.curs()}
+
+    async def ads(self, coin: str, cur: str, is_sell: bool, pms: list[Pm] = None) -> list[dict]:
+        params = {
+            "baseCurrencyCode": coin,
+            "quoteCurrencyCode": cur,
+            "offerType": "SALE" if is_sell else "PURCHASE",
+            "offset": 0,
+            "limit": 10,
+            # ,"merchantVerified":"TRUSTED"
+        }
+        ads = await self._post("/p2p/public-api/v2/offer/depth-of-market/", params)
+        return ads

xync_client-0.0.11.dev4/xync_client/TgWallet/order.py

@@ -0,0 +1,77 @@
+from enum import StrEnum, IntEnum
+from xync_schema.models import Order, OrderStatus
+
+from xync_client.Abc.Order import BaseOrderClient
+
+
+class Exceptions(StrEnum):
+    PM_KYC = "OFFER_FIAT_COUNTRY_NOT_SUPPORTED_BY_USER_KYC_COUNTRY"
+
+
+class Status(IntEnum):
+    ALL_ACTIVE = OrderStatus.active
+
+
+class OrderClient(BaseOrderClient):
+    # 2
+    async def cancel_request(self) -> Order:
+        pass
+
+    # 2
+    async def accept_request(self) -> bool:
+        approve = await self._post(
+            "/p2p/public-api/v2/offer/order/accept",
+            {"orderId": self.order.id, "type": {True: "SALE", False: "BUY"}[self.im_seller]},
+        )
+        return approve
+
+    # 2
+    async def reject_request(self) -> bool:
+        reject = await self._post("/p2p/public-api/v2/offer/order/cancel/by-seller", {"orderId": self.order.id})
+        return reject
+
+    # 2
+    async def mark_payed(self, receipt):
+        pass
+
+    # 2
+    async def cancel_order(self) -> bool:
+        pass
+
+    # 7 - [S] payment received confirm
+    async def confirm(self) -> bool:
+        payment_confirm = await self._post("/p2p/public-api/v2/payment-details/confirm", {"orderId": self.order.id})
+        return payment_confirm
+
+    # 2
+    async def start_appeal(self, file) -> bool:
+        pass
+
+    # 2
+    async def dispute_appeal(self, file) -> bool:
+        pass
+
+    async def cancel_appeal(self) -> bool:
+        pass
+
+    # 2
+    async def send_order_msg(self, msg: str, file=None) -> bool:
+        pass
+
+    # 2
+    async def send_appeal_msg(self, file, msg: str = None) -> bool:
+        pass
+
+    # 2
+    async def _upload_file(self, order_id: int, path_to_file: str):
+        url = f"/public-api/v2/file-storage/file/upload?orderId={order_id}&uploadType=UPLOAD_BUYER_PAYMENT_RECEIPT"
+        data = {"file": open(path_to_file, "rb")}
+        upload_file = await self._post(url, data)
+        return upload_file
+
+    # 19 - order_paid
+    async def order_paid(self, order_id: str, file: dict):
+        paid = await self._post(
+            "/p2p/public-api/v2/offer/order/confirm-sending-payment", {"orderId": order_id, "paymentReceipt": file}
+        )
+        return paid

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: xync-client
-Version: 0.0.11.dev0
+Version: 0.0.11.dev4
 Author-email: Mike Artemiev <mixartemev@gmail.com>
 Project-URL: Homepage, https://gitlab.com/XyncNet/client
 Project-URL: Repository, https://gitlab.com/XyncNet/client

{xync_client-0.0.11.dev0 → xync_client-0.0.11.dev4}/xync_client.egg-info/SOURCES.txt

@@ -19,14 +19,20 @@ xync_client.egg-info/dependency_links.txt
 xync_client.egg-info/requires.txt
 xync_client.egg-info/top_level.txt
 xync_client/Abc/Agent.py
+xync_client/Abc/Auth.py
+xync_client/Abc/Base.py
 xync_client/Abc/Ex.py
 xync_client/Abc/Order.py
+xync_client/Abc/Test.py
+xync_client/Binance/__init__.py
 xync_client/Binance/binance_async.py
 xync_client/Binance/earn_api.py
 xync_client/Binance/ex.py
 xync_client/Binance/exceptions.py
 xync_client/Binance/sapi.py
 xync_client/Binance/web_c2c.py
+xync_client/BingX/ex.py
+xync_client/BingX/test/main.py
 xync_client/BitGet/__init__.py
 xync_client/BitGet/agent.py
 xync_client/BitGet/ex.py
@@ -41,8 +47,9 @@ xync_client/Htx/earn.py
 xync_client/Htx/ex.py
 xync_client/KuCoin/pub.py
 xync_client/KuCoin/web.py
-xync_client/Okx/pub.py
+xync_client/Okx/ex.py
 xync_client/TgWallet/agent.py
+xync_client/TgWallet/auth.py
 xync_client/TgWallet/ex.py
 xync_client/TgWallet/order.py
 xync_client/TgWallet/pyro.py

xync_client-0.0.11.dev0/xync_client/TgWallet/ex.py

@@ -1,78 +0,0 @@
-import logging
-
-from aiohttp import ClientResponse
-from aiohttp.http_exceptions import HttpProcessingError
-from x_client.http import Client
-from xync_schema.models import Pm, Agent, Ex
-
-from xync_client.Abc.Ex import ExClient
-from xync_client.TgWallet.pyro import PyroClient
-
-
-class PublicClient(ExClient):
-    def __init__(self, agent: Agent):
-        self.agent: Agent = agent
-        assert isinstance(agent.ex, Ex), "`ex` should be fetched in `agent`"
-        assert agent.ex.host_p2p, "`ex.host_p2p` shouldn't be empty"
-        self.meth = {
-            "GET": self._get,
-            "POST": self._post,
-        }
-        super().__init__(agent.ex)
-
-    async def _get_auth_hdrs(self) -> dict[str, str]:
-        pyro = PyroClient(self.agent)
-        init_data = await pyro.get_init_data()
-        # async with ClientSession(self.agent.ex.url_login) as sess:
-        #     resp = await sess.post('/api/v1/users/auth/', data=init_data, headers={'content-type': 'application/json;charset=UTF-8'})
-        #     tokens = await resp.json()
-        tokens = Client("walletbot.me")._post("/api/v1/users/auth/", init_data)
-        return {"Wallet-Authorization": tokens["jwt"], "Authorization": "Bearer " + tokens["value"]}
-
-    async def login(self) -> None:
-        auth_hdrs: dict[str, str] = await self._get_auth_hdrs()
-        self.session.headers.update(auth_hdrs)
-
-    async def _proc(self, resp: ClientResponse, data: dict = None) -> dict | str:
-        try:
-            return await super()._proc(resp)
-        except HttpProcessingError as e:
-            if e.code == 401:
-                logging.warning(e)
-                await self.login()
-                res = await self.meth[resp.method](resp.url.path, data)
-                return res
-
-    async def curs(self) -> dict[str, str]:
-        coins_curs = await self._post("/p2p/public-api/v2/currency/all-supported")
-        return {c["code"]: c["code"] for c in coins_curs["data"]["fiat"]}
-
-    async def coins(self) -> dict[str, str]:
-        coins_curs = await self._post("/p2p/public-api/v2/currency/all-supported")
-        return {c["code"]: c["code"] for c in coins_curs["data"]["crypto"]}
-
-    async def _pms(self, cur: str = "RUB") -> dict[str, dict]:
-        pms = await self._post("/p2p/public-api/v3/payment-details/get-methods/by-currency-code", {"currencyCode": cur})
-        return {pm["code"]: {"name": pm["nameEng"]} for pm in pms["data"]}
-
-    async def pms(self) -> dict[str, dict]:
-        pms = {}
-        for cur in await self.curs():
-            for k, pm in (await self._pms(cur)).items():
-                pms.update({k: pm})
-        return pms
-
-    async def cur_pms_map(self) -> dict[str, list[str]]:
-        return {cur: list(await self._pms(cur)) for cur in await self.curs()}
-
-    async def ads(self, coin: str, cur: str, is_sell: bool, pms: list[Pm] = None) -> list[dict]:
-        params = {
-            "baseCurrencyCode": coin,
-            "quoteCurrencyCode": cur,
-            "offerType": "SALE" if is_sell else "PURCHASE",
-            "offset": 0,
-            "limit": 10,
-            # ,"merchantVerified":"TRUSTED"
-        }
-        ads = await self._post("/p2p/public-api/v2/offer/depth-of-market/", params)
-        return ads

xync_client-0.0.11.dev0/xync_client/TgWallet/order.py

@@ -1,215 +0,0 @@
-from enum import StrEnum, IntEnum
-from typing import Literal
-
-from x_client.http import Client
-from xync_schema.models import User, Cur, Order, Coin, OrderStatus, Pmex
-from xync_schema.pydantic import FiatNew
-
-from xync_client.Abc.Agent import Client as BaseClient
-from xync_client.TgWallet.pyro import PyroClient
-
-
-class Exceptions(StrEnum):
-    PM_KYC = "OFFER_FIAT_COUNTRY_NOT_SUPPORTED_BY_USER_KYC_COUNTRY"
-
-
-class Status(IntEnum):
-    ALL_ACTIVE = OrderStatus.active
-
-
-class AgentClient(BaseClient):
-    async def _get_auth_hdrs(self) -> dict[str, str]:
-        pyro = PyroClient(self.agent)
-        init_data = await pyro.get_init_data()
-        # async with ClientSession(self.agent.ex.url_login) as sess:
-        #     resp = await sess.post('/api/v1/users/auth/', data=init_data, headers={'content-type': 'application/json;charset=UTF-8'})
-        #     tokens = await resp.json()
-        tokens = Client("walletbot.me")._post("/api/v1/users/auth/", init_data)
-        return {"Wallet-Authorization": tokens["jwt"], "Authorization": "Bearer " + tokens["value"]}
-
-    async def get_orders(
-        self, stauts: OrderStatus = OrderStatus.active, coin: Coin = None, cur: Cur = None, is_sell: bool = None
-    ) -> list[Order]:
-        orders = await self._post(
-            "/p2p/public-api/v2/offer/order/history/get-by-user-id",
-            {"offset": 0, "limit": 100, "filter": {"status": Status(stauts)}},  # "limit": 20
-        )
-        return orders
-
-    async def order_request(self, ad_id: int, amount: float) -> Order: ...
-
-    async def my_fiats(self, cur: Cur = None) -> dict:
-        fiats = await self._post("/p2p/public-api/v3/payment-details/get/by-user-id")
-        fiats = {fiat["id"]: fiat for fiat in fiats["data"]}
-        return fiats
-
-    async def fiat_new(self, fiat: FiatNew):
-        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",
-            {
-                "paymentMethodCode": pmex.exid,
-                "currencyCode": cur.ticker,
-                "name": fiat.name,
-                "attributes": {"version": "V1", "values": [{"name": "PAYMENT_DETAILS_NUMBER", "value": fiat.detail}]},
-            },
-        )
-        return add_fiat
-
-    # 7 - fiat_edit
-    async def fiat_upd(self, fiat_id: int, name: str, detail: str):
-        edit_fiat = await self._post(
-            "/p2p/public-api/v3/payment-details/edit",
-            {
-                "id": fiat_id,
-                # "paymentMethodCode": code_pms,
-                # "currencyCode": cur,
-                "name": name,
-                "attributes": {"version": "V1", "values": [{"name": "PAYMENT_DETAILS_NUMBER", "value": detail}]},
-            },
-        )
-        return edit_fiat
-
-    async def fiat_del(self, fiat_id: int):
-        del_fiat = await self._post("/p2p/public-api/v3/payment-details/delete", {"id": fiat_id})
-        return del_fiat
-
-    async def ad_switch(self) -> bool:
-        pass
-
-    async def ads_switch(self) -> bool:
-        pass
-
-    async def get_user(self, user_id) -> User:
-        pass
-
-    async def send_user_msg(self, msg: str, file=None) -> bool:
-        pass
-
-    async def block_user(self, is_blocked: bool = True) -> bool:
-        pass
-
-    async def rate_user(self, positive: bool) -> bool:
-        pass
-
-    # base_url = 'https://p2p.walletbot.me'
-    # middle_url = '/p2p/'
-
-    # 1: all_curs
-    async def all_curs(self):
-        coins_curs = await self._post("/p2p/public-api/v2/currency/all-supported")
-        curs = [c["code"] for c in coins_curs["data"]["fiat"]]
-        return curs
-
-    # 2: all_coins
-    async def all_coins(self):
-        coins_curs = await self._post("/p2p/public-api/v2/currency/all-supported")
-        coins = [c["code"] for c in coins_curs["data"]["crypto"]]
-        return coins
-
-    # 3: all_coins
-    async def all_pms(self):
-        pms = await self._post(
-            "/p2p/public-api/v3/payment-details/get-methods/by-currency-code", {"currencyCode": "RUB"}
-        )
-        return pms["data"]
-
-    # 4: all_ads
-    async def get_ads(
-        self, coin: str = "TON", cur: str = "RUB", tt: str = "SALE", offset: int = 0, limit: int = 100
-    ) -> dict:
-        params = {
-            "baseCurrencyCode": coin,
-            "quoteCurrencyCode": cur,
-            "offerType": tt,
-            "offset": offset,
-            "limit": limit,
-        }  # ,"merchantVerified":"TRUSTED"
-        ads = await self._post("/p2p/public-api/v2/offer/depth-of-market/", params)
-        return ads
-
-    # 9 - my_ads
-    async def my_ads(self, status: Literal["INACTIVE", "ACTIVE"] = None):
-        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"] == status] if status else ads
-
-    # 10 - ad_new
-    async def ad_new(self, fiats: list[int], amount: int, coin: str = "TON", cur: str = "RUB", tt: str = "SALE"):
-        create = await self._post(
-            "/p2p/public-api/v2/offer/create",
-            {
-                "type": tt,
-                "initVolume": {"currencyCode": coin, "amount": f"{amount}"},
-                "orderRoundingRequired": False,
-                "price": {"type": "FLOATING", "baseCurrencyCode": coin, "quoteCurrencyCode": cur, "value": "120"},
-                "orderAmountLimits": {"min": "500", "max": "2000"},
-                "paymentConfirmTimeout": "PT15M",
-                "comment": "",
-                "paymentDetailsIds": fiats,
-            },
-        )
-        return create
-
-    # 11 - ad_upd
-    async def ad_upd(self, typ: str, offer_id: int, fiats: list[int], amount: int):
-        upd = await self._post(
-            "/p2p/public-api/v2/offer/edit",
-            {
-                "offerId": offer_id,
-                "paymentConfirmTimeout": "PT15M",
-                "type": typ,
-                "orderRoundingRequired": False,
-                "price": {"type": "FLOATING", "value": "120"},
-                "orderAmountLimits": {"min": "500", "max": "2000"},
-                "comment": "",
-                "volume": f"{amount}",
-                "paymentDetailsIds": fiats,
-            },
-        )
-        return upd
-
-    # 12 - ad_del
-    async def ad_del(self, typ: str, offer_id: int):
-        ad_del = await self._post("/p2p/public-api/v2/offer/delete", {"type": typ, "offerId": offer_id})
-        return ad_del
-
-    # 13 - ad_on
-    async def ad_on(self, typ: str, offer_id: int):
-        active = await self._post("/p2p/public-api/v2/offer/activate", {"type": typ, "offerId": offer_id})
-        return active
-
-    # 14 - ad_off
-    async def ad_off(self, typ: str, offer_id: int) -> dict[str, str]:
-        off = await self._post("/p2p/public-api/v2/offer/deactivate", {"type": typ, "offerId": offer_id})
-        return off
-
-    # 15 - order_approve
-    async def order_approve(self, order_id: int, typ: str):
-        approve = await self._post("/p2p/public-api/v2/offer/order/accept", {"orderId": order_id, "type": typ})
-        return approve
-
-    # 16 - order_reject
-    async def order_reject(self, order_id: str):
-        reject = await self._post("/p2p/public-api/v2/offer/order/cancel/by-seller", {"orderId": order_id})
-        return reject
-
-    async def upload_file(self, order_id: int, path_to_file: str):
-        url = f"public-api/v2/file-storage/file/upload?orderId={order_id}&uploadType=UPLOAD_BUYER_PAYMENT_RECEIPT"
-        data = {"file": open(path_to_file, "rb")}
-        upload_file = await self._post(url, data)
-        return upload_file
-
-    # 19 - order_paid
-    async def order_paid(self, order_id: str, file: dict):
-        paid = await self._post(
-            "/p2p/public-api/v2/offer/order/confirm-sending-payment", {"orderId": order_id, "paymentReceipt": file}
-        )
-        return paid
-
-    # 20 - order_payment_confirm
-    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