xync-client 0.0.25.dev59__tar.gz → 0.0.25.dev62__tar.gz

{xync_client-0.0.25.dev59/xync_client.egg-info → xync_client-0.0.25.dev62}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: xync-client
-Version: 0.0.25.dev59
+Version: 0.0.25.dev62
 Author-email: Mike Artemiev <mixartemev@gmail.com>
 Project-URL: Homepage, https://gitlab.com/XyncNet/client
 Project-URL: Repository, https://gitlab.com/XyncNet/client

{xync_client-0.0.25.dev59 → xync_client-0.0.25.dev62}/tests/TestEx.py

@@ -100,3 +100,11 @@ class TestEx(BaseTest):
             t, _ = await ExTest.update_or_create({"ok": True}, ex=client.ex, action=ExAction.set_pmcurs)
             assert t.ok, "PmCurs not set"
             logging.info(f"{client.ex.name}: {ExAction.ads.name} - ok")
+
+    # 0
+    async def test_set_pairs(self, clients: list[BaseExClient]):
+        for client in clients:
+            await client.set_pairs()
+            t, _ = await ExTest.update_or_create({"ok": True}, ex=client.ex, action=ExAction.set_pairs)
+            assert t.ok, "Pairs not set"
+            logging.info(f"{client.ex.name}: {ExAction.ads.name} - ok")

{xync_client-0.0.25.dev59 → xync_client-0.0.25.dev62}/xync_client/Abc/Ex.py

@@ -193,6 +193,24 @@ class BaseExClient(BaseClient):
         ]
         await models.Coinex.bulk_create(coinexs, update_fields=["minimum"], on_conflict=["coin_id", "ex_id"])
 
+    # Импорт пар биржи в бд
+    async def set_pairs(self):
+        curs: dict[str, CurEx] = {
+            k: (await models.Cur.get_or_create(ticker=c.ticker))[0] for k, c in (await self.curs()).items()
+        }
+        coins: dict[str, CoinEx] = {
+            k: (await models.Coin.get_or_create(ticker=c.ticker))[0] for k, c in (await self.coins()).items()
+        }
+        prs: tuple[dict, dict] = await self.pairs()
+        for is_sell in (0, 1):
+            dirs: list[models.Direction] = []
+            for cur, coinz in prs[is_sell].items():
+                for coin in coinz:
+                    pair, _ = await models.Pair.get_or_create(coin=coins[coin], cur=curs[cur])
+                    pairex, _ = await models.PairEx.get_or_create(pair=pair, ex=self.ex)
+                    dirs += [models.Direction(sell=is_sell, pairex=pairex)]
+            await models.Direction.bulk_create(dirs, ignore_conflicts=True)
+
     # Сохранение чужого объявления (с Pm-ами) в бд
     async def ad_pydin2db(self, ad_pydin: BaseAdIn) -> models.Ad:
         ad_db, _ = await models.Ad.update_or_create(**ad_pydin.df_unq())

{xync_client-0.0.25.dev59 → xync_client-0.0.25.dev62}/xync_client/BingX/ex.py

@@ -74,13 +74,13 @@ class ExClient(BaseExClient, BaseBingXClient):
 
     # 24: ads
     async def ads(
-            self, coin_exid: str, cur_exid: str, is_sell: bool, pm_exids: list[str | int] = None, amount: int = None
+        self, coin_exid: str, cur_exid: str, is_sell: bool, pm_exids: list[str | int] = None, amount: int = None
     ) -> list[ad.Ad]:
         params = {
             "type": 1,
             "fiat": cur_exid,
             "asset": coin_exid,
-            "amount": "",
+            "amount": amount,
             "hidePaymentInfo": "",
             "payMethodId": pm_exids if pm_exids else "",
             "isUserMatchCondition": "true" if is_sell else "false",
@@ -94,6 +94,8 @@ async def main():
     _ = await init_db(PG_DSN, models, True)
     bg = await Ex.get(name="BingX")
     cl = ExClient(bg)
+    _ads = await cl.ads("USDT", "RUB", False)
+    await cl.set_pairs()
     await cl.set_coinexs()
     await cl.set_pmcurexs()
     # _curs = await cl.curs()
@@ -101,7 +103,6 @@ async def main():
     # _pairs = await cl.pairs()
     # _pms = await cl.pms("EUR")
     # _pms_map = await cl.cur_pms_map()
-    # _ads = await cl.ads("USDT", "RUB", False)
     await cl.close()
 
 

{xync_client-0.0.25.dev59 → xync_client-0.0.25.dev62}/xync_client/Htx/ex.py

@@ -101,7 +101,7 @@ class ExClient(BaseExClient):
         return pmsd
 
     # 21: Get all: currency,pay,allCountry,coin
-    async def curs(self) -> dict[str, types.CurEx]:
+    async def curs(self) -> dict[int, types.CurEx]:
         self.session.headers["client-type"] = "web"
         curs: list[dict] = (await self._coin_curs_pms())["currency"]
         cmap: dict[str, int] = {c["nameShort"]: c["currencyId"] for c in curs}
@@ -110,7 +110,7 @@ class ExClient(BaseExClient):
         for c in res:
             for q in c["quoteAsset"]:
                 cursd[q["name"]] = max(cursd.get(q["name"], 0), float(q["minAmount"]))
-        return {tkr: types.CurEx(exid=exid, ticker=tkr, minimum=cursd.get(tkr)) for tkr, exid in cmap.items()}
+        return {exid: types.CurEx(exid=exid, ticker=tkr, minimum=cursd.get(tkr)) for tkr, exid in cmap.items()}
 
     # 22: Список платежных методов по каждой валюте
     async def cur_pms_map(self) -> dict[int, set[int]]:
@@ -119,13 +119,13 @@ class ExClient(BaseExClient):
         return {c["currencyId"]: set(c["supportPayments"]) - wrong_pms for c in res["currency"] if c["supportPayments"]}
 
     # 23: Список торгуемых монет
-    async def coins(self) -> dict[str, types.CoinEx]:
+    async def coins(self) -> dict[int, types.CoinEx]:
         self.session.headers["client-type"] = "web"
         coins: list[dict] = (await self._coin_curs_pms())["coin"]
         cmap: dict[str, int] = {c["coinCode"]: c["coinId"] for c in coins}
         res = (await self._get("/-/x/otc/v1/trade/fast/config/list?side=buy&tradeMode=c2c_simple"))["data"]
         coinsl: list[str] = [c["cryptoAsset"]["name"] for c in res]
-        return {tkr: types.CoinEx(exid=cid, ticker=tkr, p2p=tkr in coinsl) for tkr, cid in cmap.items()}
+        return {cid: types.CoinEx(exid=cid, ticker=tkr, p2p=tkr in coinsl) for tkr, cid in cmap.items()}
 
     # 99: Страны
     async def countries(self) -> list[Country]:
@@ -157,6 +157,7 @@ async def main():
     _ = await init_db(PG_DSN, models, True)
     ex = await Ex.get(name="Htx")
     cl = ExClient(ex)
+    await cl.set_pairs()
     await cl.pms()
     await cl.pairs()
     await cl.set_pmcurexs()

{xync_client-0.0.25.dev59 → xync_client-0.0.25.dev62}/xync_client/KuCoin/etype/ad.py

@@ -1,5 +1,7 @@
 from pydantic import BaseModel, Field
 from typing import List, Optional
+from xync_schema.types import BaseAd
+
 
 class AdPayType(BaseModel):
     id: str
@@ -10,8 +12,9 @@ class AdPayType(BaseModel):
     subBranch: Optional[str] = None
     reservedFields: Optional[str] = None
 
-class Ad(BaseModel):
-    id: str
+
+class Ad(BaseAd):
+    exid: str | None = Field(alias="id")
     side: str
     legal: str
     currency: str
@@ -46,4 +49,4 @@ class Ad(BaseModel):
     tradeLimitTip: Optional[str] = None
     opponentBalanceLimit: str
     blackStatus: int
-    self: bool
+    self: bool

{xync_client-0.0.25.dev59 → xync_client-0.0.25.dev62}/xync_client/KuCoin/ex.py

@@ -14,58 +14,74 @@ from xync_client.Abc.types import PmEx
 class ExClient(BaseExClient):
     async def _pms(self, cur) -> list[pm.PmE]:
         params = {
-            'legal': cur,
-            'lang': 'ru_RU',
+            "legal": cur,
+            "lang": "ru_RU",
         }
         pms = await self._get("/_api/otc/legal/payTypes", params=params)
         return [pm.PmE(**_pm) for _pm in pms["data"]]
 
-    async def curs(self) -> list[types.CurEx]:
+    async def curs(self) -> dict[types.CurEx]:
         curs = (await self._get("/_api/otc/dictionary/getData", {"type": "LEGAL"}))["data"]
-        return {
-            cur["typeCode"]:types.CurEx(exid=cur["typeCode"], ticker=cur["typeCode"]) for cur in curs
-        }
+        return {cur["typeCode"]: types.CurEx(exid=cur["typeCode"], ticker=cur["typeCode"]) for cur in curs}
 
     async def pms(self, cur: models.Cur = None) -> dict[int | str, PmEx]:
         all_pms = {}
         for cur_obj in (await self.curs()).values():
             pms = await self._pms(cur_obj.ticker)
-            for pm in pms:
-                all_pms[pm.payTypeCode] = PmEx(exid=pm.payTypeCode, name=pm.payTypeName)
+            for p in pms:
+                all_pms[p.payTypeCode] = PmEx(exid=p.payTypeCode, name=p.payTypeName)
         return all_pms
 
     async def cur_pms_map(self) -> MapOfIdsList:
-        return {cur.exid: [pm.payTypeCode for pm in await self._pms(cur.ticker)] for cur in (await self.curs()).values()}
+        return {
+            cur.exid: [pm.payTypeCode for pm in await self._pms(cur.ticker)] for cur in (await self.curs()).values()
+        }
 
-    async def coins(self) -> list[types.CoinEx]:
+    async def coins(self) -> dict[types.CoinEx]:
         all_coins = {}
         for cur in (await self.curs()).keys():
             params = {
-                'legal': cur,
-                'lang': 'ru_RU',
+                "legal": cur,
+                "lang": "ru_RU",
             }
             coins = await self._get("/_api/otc/symbol/support", params=params)
             for coin in coins["data"]:
-                all_coins[coin["currency"]] = types.CoinEx(exid=coin["currency"] ,ticker=coin["currency"], scale=coin["currencyPrecision"])
+                all_coins[coin["currency"]] = types.CoinEx(
+                    exid=coin["currency"], ticker=coin["currency"], scale=coin["currencyPrecision"]
+                )
         return all_coins
 
-    async def pairs(self) -> MapOfIdsList:
+    async def pairs(self) -> tuple[MapOfIdsList, MapOfIdsList]:
         coins = (await self.coins()).keys()
         curs = (await self.curs()).keys()
         s = {cur: {c for c in coins} for cur in curs}
         return s, s
 
     async def ads(
-            self, coin_exid: str, cur_exid: str, is_sell: bool, pm_exids: list[str | int] = None, amount: int = None
+        self, coin_exid: str, cur_exid: str, is_sell: bool, pm_exids: list[str | int] = None, amount: int = None
     ) -> list[ad.Ad]:
-        pass
+        params = {
+            "status": "PUTUP",
+            "currency": coin_exid,
+            "legal": cur_exid,
+            "page": "1",
+            "pageSize": "10",
+            "side": "SELL",
+            "amount": amount or "",
+            "payTypeCodes": pm_exids or "",
+            "sortCode": "PRICE",
+            "highQualityMerchant": "0",
+            "lang": "ru_RU",
+        }
+        ads = await self._get("/_api/otc/ad/list", params=params)
+        return [ad.Ad(price=a["floatPrice"], **a) for a in ads["items"]]
 
 
 async def main():
     _ = await init_db(PG_DSN, models, True)
-    bg = await Ex.get(name="KuCoin")
+    bg = await models.Ex.get(name="KuCoin")
     cl = ExClient(bg)
-    # await cl.curs()
+    _ads = await cl.ads("USDT", "RUB", False)
     # await cl.coins()
     await cl.pms()
 

{xync_client-0.0.25.dev59 → xync_client-0.0.25.dev62/xync_client.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: xync-client
-Version: 0.0.25.dev59
+Version: 0.0.25.dev62
 Author-email: Mike Artemiev <mixartemev@gmail.com>
 Project-URL: Homepage, https://gitlab.com/XyncNet/client
 Project-URL: Repository, https://gitlab.com/XyncNet/client