xync-client 0.0.25.dev40__tar.gz → 0.0.25.dev41__tar.gz

{xync_client-0.0.25.dev40/xync_client.egg-info → xync_client-0.0.25.dev41}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: xync-client
-Version: 0.0.25.dev40
+Version: 0.0.25.dev41
 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.dev40 → xync_client-0.0.25.dev41}/tests/TestAgent.py

@@ -3,7 +3,7 @@ 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_schema.types import FiatNew, BaseAd
 
 from xync_client.Abc.Base import DictOfDicts, ListOfDicts
 from xync_client.Abc.BaseTest import BaseTest
@@ -25,6 +25,17 @@ class TestAgent(BaseTest):
         yield clients
         [(await taker.close(), await maker.close()) for taker, maker in clients]
 
+    # 42
+    async def test_ad(self, clients: list[BaseExClient]):
+        for client in clients:
+            if not self.ad.get(client.ex.id):
+                await self.test_ads(clients)
+            ad: BaseAd = await client.ad(self.ad[client.ex.id].id)
+            ok = isinstance(ad, BaseAd)
+            t, _ = await TestEx.update_or_create({"ok": ok}, ex=client.ex, action=ExAction.ad)
+            assert t.ok, "No ad"
+            logging.info(f"{client.ex.name}: {ExAction.ad.name} - ok")
+
     # 0
     async def test_get_orders(self, clients: list[BaseAgentClient]):
         for taker, maker in clients:

{xync_client-0.0.25.dev40 → xync_client-0.0.25.dev41}/tests/TestEx.py

@@ -1,19 +1,21 @@
 import logging
 
 import pytest
-from xync_schema.pydantic import PmPyd, BaseAd, CurEpyd, CoinEpyd
+from xync_schema.types import Pm, BaseAd, CurE, CoinE
 
 from xync_client.Abc.BaseTest import BaseTest
 from xync_schema.enums import ExStatus, ExType, ExAction
 from xync_schema.models import Ex, TestEx as ExTest
 
-from xync_client.Abc.Base import BaseClient, FlatDict, MapOfIdsList
+from xync_client.Abc.Base import BaseClient, MapOfIdsList
 from xync_client.Abc.Ex import BaseExClient
 
 
 @pytest.mark.asyncio(loop_scope="session")
 class TestEx(BaseTest):
-    ad: dict[str, BaseAd] = {}
+    coins: dict[int, dict[str, CoinE]] = {}
+    curs: dict[int, dict[str, CurE]] = {}
+    ad: dict[int, BaseAd] = {}
 
     @pytest.fixture
     async def clients(self) -> list[BaseClient]:
@@ -26,17 +28,18 @@ class TestEx(BaseTest):
     # 19
     async def test_curs(self, clients: list[BaseExClient]):
         for client in clients:
-            curs: list[CurEpyd] = await client.curs()
-            ok = self.is_list_of_objects(curs, CurEpyd)
+            curs: dict[str, CurE] = await client.curs()
+            ok = self.is_dict_of_objects(curs, CurE)
             t, _ = await ExTest.update_or_create({"ok": ok}, ex=client.ex, action=ExAction.curs)
             assert t.ok, "No curs"
+            self.curs[client.ex.id] = curs
             logging.info(f"{client.ex.name}: {ExAction.curs.name} - ok")
 
     # 20
     async def test_pms(self, clients: list[BaseExClient]):
         for client in clients:
-            pms: dict[int | str, PmPyd] = await client.pms()
-            ok = self.is_dict_of_objects(pms, PmPyd)
+            pms: dict[int | str, Pm] = await client.pms()
+            ok = self.is_dict_of_objects(pms, Pm)
             t, _ = await ExTest.update_or_create({"ok": ok}, ex=client.ex, action=ExAction.pms)
             assert t.ok, "No pms"
             logging.info(f"{client.ex.name}: {ExAction.pms.name} - ok")
@@ -53,17 +56,18 @@ class TestEx(BaseTest):
     # 22
     async def test_coins(self, clients: list[BaseExClient]):
         for client in clients:
-            coins: FlatDict = await client.coins()
-            ok = self.is_list_of_objects(coins, CoinEpyd)
+            coins: dict[str, CoinE] = await client.coins()
+            ok = self.is_dict_of_objects(coins, CoinE)
             t, _ = await ExTest.update_or_create({"ok": ok}, ex=client.ex, action=ExAction.coins)
             assert t.ok, "No coins"
+            self.coins[client.ex.id] = coins
             logging.info(f"{client.ex.name}: {ExAction.coins.name} - ok")
 
     # 23
     async def test_pairs(self, clients: list[BaseExClient]):
         for client in clients:
-            pairs: MapOfIdsList = await client.pairs()
-            ok = self.is_map_of_ids(pairs)
+            pairs_buy, pairs_sell = await client.pairs()
+            ok = self.is_map_of_ids(pairs_buy) and self.is_map_of_ids(pairs_sell)
             t, _ = await ExTest.update_or_create({"ok": ok}, ex=client.ex, action=ExAction.pairs)
             assert t.ok, "No coins"
             logging.info(f"{client.ex.name}: {ExAction.pairs.name} - ok")
@@ -71,18 +75,13 @@ class TestEx(BaseTest):
     # 24
     async def test_ads(self, clients: list[BaseExClient]):
         for client in clients:
-            ads: list[BaseAd] = await client.ads("USDT", "USD", False)
+            self.coins[client.ex.id] = self.coins.get(client.ex.id) or await client.coins()
+            self.curs[client.ex.id] = self.curs.get(client.ex.id) or await client.curs()
+            coin: int | str = self.coins[client.ex.id]["USDT"].exid
+            cur: int | str = self.curs[client.ex.id]["EUR"].exid
+            ads: list[BaseAd] = await client.ads(coin, cur, False)
             ok = self.is_list_of_objects(ads, BaseAd)
             t, _ = await ExTest.update_or_create({"ok": ok}, ex=client.ex, action=ExAction.ads)
             assert t.ok, "No ads"
-            self.ad[client.ex.name] = ads[0]  # for further use in test_ad
+            self.ad[client.ex.id] = ads[0]  # for further use in test_ad
             logging.info(f"{client.ex.name}: {ExAction.ads.name} - ok")
-
-    # 42
-    async def test_ad(self, clients: list[BaseExClient]):
-        for client in clients:
-            ad: BaseAd = await client.ad(self.ad.get(client.ex.name, (await client.ads("USDT", "RUB", False))[0]).id)
-            ok = isinstance(ad, BaseAd)
-            t, _ = await ExTest.update_or_create({"ok": ok}, ex=client.ex, action=ExAction.ad)
-            assert t.ok, "No ad"
-            logging.info(f"{client.ex.name}: {ExAction.ad.name} - ok")

{xync_client-0.0.25.dev40 → xync_client-0.0.25.dev41}/xync_client/Abc/Ex.py

@@ -38,7 +38,7 @@ class PmUnifier:
         # "GTB Bank (Guarantee Trust Bank)": "GTBank",
     }
     re_bank = [
-        r"^bank (?!of )| bank$",
+        r"^bank (?!of )|bank$",
         r" banka$",
         r" bankas$",
         r" bankası$",
@@ -81,14 +81,11 @@ class PmUnifier:
         self.cts = countries
 
     def countries(self, name: str):
-        cmap = {
-            "kazakstan": "kazakhstan",
-        }
         for ct in self.cts:
             # Если имя кончается на "Название_страны" в скобках
             if (
                 ct
-                and self.pms[name].norm.endswith((ct + ")", cmap.get(ct, ct)))
+                and self.pms[name].norm.endswith((ct + ")", ct))
                 and not self.pms[name].norm.endswith((" of " + ct, " of the " + ct, " and " + ct, " de " + ct))
             ):
                 self.pms[name].norm = self.pms[name].norm.replace(ct, "")
@@ -130,7 +127,7 @@ class PmUnifier:
         ).upper()
         if len(acr) >= 2 and (
             f"({acr})" in self.pms[name].norm
-            or self.pms[name].norm.startswith(acr + " ")
+            or self.pms[name].norm.startswith((acr + " ", acr + ":"))
             or self.pms[name].norm.endswith(" " + acr)
         ):
             self.pms[name].norm = self.pms[name].norm.replace(acr, "", 1).replace("()", "", 1).strip()
@@ -146,7 +143,7 @@ class PmUnifier:
             self.pms[name].norm = self.pms[name].norm.replace(src, trgt)
 
     def clear(self, name: str):
-        self.pms[name].norm = self.pms[name].norm.replace("()", "").replace("  ", " ").strip(" -")
+        self.pms[name].norm = self.pms[name].norm.replace("()", "").replace("  ", " ").strip(" -:")
 
     def __call__(self, s: str) -> PmUni:
         # если в словаре замен есть текущее назвние - меняем, иначе берем строку до запятой
@@ -179,7 +176,7 @@ class BaseExClient(BaseClient):
 
     # 19: Список поддерживаемых валют тейкера
     @abstractmethod
-    async def curs(self) -> list[types.CurE]:  # {cur.exid: cur.ticker}
+    async def curs(self) -> dict[str, types.CurE]:  # {cur.ticker: cur}
         ...
 
     # 20: Список платежных методов
@@ -194,12 +191,12 @@ class BaseExClient(BaseClient):
 
     # 22: Список торгуемых монет (с ограничениям по валютам, если есть)
     @abstractmethod
-    async def coins(self) -> list[types.CoinE]:  # {coin.exid: coin.ticker}
+    async def coins(self) -> dict[str, types.CoinE]:  # {coin.ticker: coin}
         ...
 
     # 23: Список пар валюта/монет
     @abstractmethod
-    async def pairs(self) -> MapOfIdsList: ...
+    async def pairs(self) -> tuple[MapOfIdsList, MapOfIdsList]: ...
 
     # 24: Список объяв по (buy/sell, cur, coin, pm)
     @abstractmethod
@@ -217,20 +214,18 @@ class BaseExClient(BaseClient):
     async def ad_epyd2pydin(self, ad: types.BaseAd) -> types.BaseAdIn: ...  # my_uid: for MyAd
 
     # 99: Страны
-    @abstractmethod
-    async def countries(self) -> list[Struct]: ...
+    async def countries(self) -> list[Struct]:
+        return []
 
     # Импорт Pm-ов (с Pmcur-, Pmex- и Pmcurex-ами) и валют (с Curex-ами) с биржи в бд
     async def set_pmcurexs(self):
         # Curs
-        cur_pyds: list[types.CurE] = await self.curs()
+        cur_pyds: dict[str, types.CurE] = await self.curs()
         curs: dict[int | str, models.Cur] = {
-            cur_pyd.exid: (
-                await models.Cur.update_or_create({"rate": cur_pyd.rate}, ticker=cur_pyd.ticker, id=cur_pyd.exid)
-            )[0]
-            for cur_pyd in cur_pyds
+            cur_pyd.exid: (await models.Cur.update_or_create({"rate": cur_pyd.rate}, ticker=tkr))[0]
+            for tkr, cur_pyd in cur_pyds.items()
         }
-        curexs: list[models.Curex] = [models.Curex(**c.model_dump(), cur=curs[c.exid], ex=self.ex) for c in cur_pyds]
+        curexs = [models.Curex(**c.model_dump(), cur=curs[c.exid], ex=self.ex) for c in cur_pyds.values()]
         # Curex
         await models.Curex.bulk_create(
             curexs, update_fields=["minimum", "rounding_scale"], on_conflict=["cur_id", "ex_id"]
@@ -288,10 +283,11 @@ class BaseExClient(BaseClient):
         uni = PmUnifier(cntrs)
         for k, pm in pms_epyds.items():
             pmu: PmUni = uni(pm.name)
+            country = await models.Country.get(name__iexact=cnt) if (cnt := pmu.country) else None
             if prev[2] == pm.name and pmu.country == prev[3]:  # оригинальное имя не уникально на этой бирже
                 logging.warning(f"Pm: '{pm.name}' duplicated with ids {prev[0]}: {k} on {self.ex.name}")
                 # новый Pm не добавляем, а берем старый с этим названием
-                pm_ = pms.get(prev[0], await models.Pm.get_or_none(norm=prev[1]))
+                pm_ = pms.get(prev[0], await models.Pm.get_or_none(norm=prev[1], country=country))
                 # и добавляем Pmex для него
                 await models.Pmex.update_or_create({"name": pm.name}, ex=self.ex, exid=k, pm=pm_)
             elif (
@@ -302,19 +298,16 @@ class BaseExClient(BaseClient):
                 )
                 # новый Pm не добавляем, только Pmex для него
                 # новый Pm не добавляем, а берем старый с этим названием
-                pm_ = pms.get(prev[0], await models.Pm.get_or_none(norm=prev[1]))
+                pm_ = pms.get(prev[0], await models.Pm.get_or_none(norm=prev[1], country=country))
                 # и добавляем.обновляем Pmex для него
                 await models.Pmex.update_or_create({"pm": pm_}, ex=self.ex, exid=k, name=pm.name)
             else:
                 # todo: add logo and all other
-                d = pmu.df_unq()
-                d.update(
-                    {
-                        "country": await models.Country.get(name__iexact=cnt) if (cnt := d.get("country")) else None,
-                        "logo": pm.logo,
-                        "type_": pm.type_,
-                    }
-                )
+                d = {**pmu.df_unq(), "country": country}
+                if pm.logo:
+                    d["defaults"]["logo"] = pm.logo
+                if pm.type_:
+                    d["defaults"]["type_"] = pm.type_
                 try:
                     pms[k], _ = await models.Pm.update_or_create(**d)
                 except (MultipleObjectsReturned, IntegrityError) as e:
@@ -350,12 +343,12 @@ class BaseExClient(BaseClient):
 
     # Импорт монет (с Coinex-ами) с биржи в бд
     async def set_coinexs(self):
-        coins: list[types.CoinE] = await self.coins()
+        coins: dict[str, types.CoinE] = await self.coins()
         coins_db: dict[int, models.Coin] = {
-            c.exid: (await models.Coin.update_or_create(ticker=c.ticker))[0] for c in coins
+            c.exid: (await models.Coin.update_or_create(ticker=c.ticker))[0] for c in coins.values()
         }
         coinexs: list[models.Coinex] = [
-            models.Coinex(coin=coins_db[c.exid], ex=self.ex, exid=c.exid, minimum=c.minimum) for c in coins
+            models.Coinex(coin=coins_db[c.exid], ex=self.ex, exid=c.exid, minimum=c.minimum) for c in coins.values()
         ]
         await models.Coinex.bulk_create(coinexs, update_fields=["minimum"], on_conflict=["coin_id", "ex_id"])
 

{xync_client-0.0.25.dev40 → xync_client-0.0.25.dev41}/xync_client/Htx/agent.py

@@ -83,8 +83,9 @@ class Private(BaseAgentClient):
     async def ads_switch(self) -> bool:
         pass
 
-    async def get_user(self, user_id) -> dict:
-        pass
+    async def get_user(self, user_id: int) -> dict:
+        user = (await self._get(f"/-/x/otc/v1/user/{user_id}/info"))["data"]
+        return user
 
     async def send_user_msg(self, msg: str, file=None) -> bool:
         pass

{xync_client-0.0.25.dev40 → xync_client-0.0.25.dev41}/xync_client/Htx/etype/ad.py

@@ -1,6 +1,7 @@
 from typing import Literal
 
 from pydantic import BaseModel
+from xync_schema.types import BaseAd
 
 
 class TradeRule(BaseModel):
@@ -56,7 +57,7 @@ class PayName(BaseModel):
     id: int
 
 
-class Resp(BaseModel):
+class Resp(BaseAd):
     blockType: int
     chargeType: bool
     coinId: int
@@ -71,12 +72,12 @@ class Resp(BaseModel):
     labelName: str | None = None
     maxTradeLimit: str
     merchantLevel: int
-    merchantTags: str | None = None
+    merchantTags: list[str] | None
     minTradeLimit: str
     orderCompleteRate: str
     payMethod: str
     payMethods: list[PayMethod]
-    payName: list[PayName]  # приходит массив объектов внутри строки
+    payName: str  # list[PayName]  # приходит массив объектов внутри строки
     payTerm: int
     price: str
     seaViewRoom: str | None = None

xync_client-0.0.25.dev41/xync_client/Htx/ex.py

@@ -0,0 +1,157 @@
+from asyncio import run
+
+from msgspec import convert
+from x_model import init_db
+from xync_schema import models, types
+from xync_schema.models import Ex, Cur
+from xync_schema.enums import PmType
+
+from xync_client.Abc.Base import MapOfIdsList
+from xync_client.Abc.Ex import BaseExClient
+from xync_client.Htx.etype import pm, Country, ad
+from xync_client.loader import PG_DSN
+
+
+class ExClient(BaseExClient):
+    def pm_type_map(self, type_: models.Pmex) -> str:
+        pass
+
+    async def pairs(self) -> tuple[MapOfIdsList, MapOfIdsList]:
+        self.session.headers["client-type"] = "web"
+        reb = (await self._get("/-/x/otc/v1/trade/fast/config/list?side=buy&tradeMode=c2c_simple"))["data"]
+        res = (await self._get("/-/x/otc/v1/trade/fast/config/list?side=sell&tradeMode=c2c_simple"))["data"]
+        coins = await self.coins()
+        curs = await self.curs()
+        b = {
+            cur.exid: cns
+            for tkr, cur in curs.items()
+            if (
+                cns := set(
+                    coins[c["cryptoAsset"]["name"]].exid for c in reb if tkr in [q["name"] for q in c["quoteAsset"]]
+                )
+            )
+        }
+        s = {
+            cur.exid: cns
+            for tkr, cur in curs.items()
+            if (
+                cns := set(
+                    coins[c["cryptoAsset"]["name"]].exid for c in res if tkr in [q["name"] for q in c["quoteAsset"]]
+                )
+            )
+        }
+        return b, s
+
+    async def ads(
+        self, coin_exid: int, cur_exid: int, is_sell: bool, pm_exids: list[str] = None, amount: int = None
+    ) -> list[types.BaseAd]:
+        params = {
+            "coinId": coin_exid,
+            "currency": cur_exid,
+            "tradeType": "sell" if is_sell else "buy",
+            "currPage": 1,
+            "payMethod": ",".join(pm_exids) if pm_exids else 0,
+            "acceptOrder": 0,
+            "blockType": "general",
+            "online": 1,
+            "range": 0,
+            "amount": amount or "",
+            "onlyTradable": "false",
+            "isFollowed": "false",
+        }
+        res = (await self._get("/-/x/otc/v1/data/trade-market", params))["data"]
+        ads = [ad.Resp(**a) for a in res]
+        return ads
+
+    async def ad(self, ad_id: int) -> types.BaseAd:
+        pass
+
+    # 20: Get all pms
+    async def pms(self, _cur: Cur = None) -> dict[int, types.Pm]:
+        dist = {
+            0: PmType.card,
+            1: PmType.bank,
+            2: PmType.cash,
+            3: PmType.emoney,
+            4: PmType.emoney,
+            5: PmType.IFSC,
+        }
+
+        pms: list[pm.Resp] = [convert(p, pm.Resp) for p in (await self._coin_curs_pms())["payMethod"]]
+
+        pmsd = {
+            p.payMethodId: types.Pm(
+                name=p.name,
+                type_=dist.get(p.template),
+                logo=p.bankImage or p.bankImageWeb,
+            )
+            for p in pms
+        }
+
+        return pmsd
+
+    # 21: Get all: currency,pay,allCountry,coin
+    async def curs(self) -> dict[str, types.CurE]:
+        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}
+        res = (await self._get("/-/x/otc/v1/trade/fast/config/list?side=sell&tradeMode=c2c_simple"))["data"]
+        cursd: dict[str, float] = {}
+        for c in res:
+            for q in c["quoteAsset"]:
+                cursd[q["name"]] = max(cursd.get(q["name"], 0), float(q["minAmount"]))
+        return {tkr: types.CurE(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]]:
+        res = await self._coin_curs_pms()
+        wrong_pms = {4, 34, 498, 548, 20009, 20010}  # , 212, 239, 363  # these ids not exist in pms
+        return {c["currencyId"]: set(c["supportPayments"]) - wrong_pms for c in res["currency"] if c["supportPayments"]}
+
+    # 23: Список торгуемых монет
+    async def coins(self) -> dict[str, types.CoinE]:
+        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.CoinE(exid=cid, ticker=tkr, p2p=tkr in coinsl) for tkr, cid in cmap.items()}
+
+    # 99: Страны
+    async def countries(self) -> list[Country]:
+        cmap = {
+            "Kazakstan": "Kazakhstan",
+        }
+        res = await self._coin_curs_pms()
+        cts = [
+            Country(
+                id=c["countryId"],
+                code=c["code"],
+                name=cmap.get(ct := name[:-1] if (name := c["name"].split(",")[0]).endswith(".") else name, ct),
+                short=c["appShort"],
+                cur_id=c["currencyId"],
+            )
+            for c in res["country"]
+        ]
+        return cts
+
+    # Get all: currency,pay,allCountry,coin
+    async def _coin_curs_pms(self) -> (dict, dict, dict, dict):
+        res = (await self._get("/-/x/otc/v1/data/config-list?type=currency,pay,coin,allCountry"))["data"]
+        res["currency"][0]["currencyId"] = 1
+        [c.update({"currencyId": 1, "name": ""}) for c in res["country"] if c["currencyId"] == 172]
+        return res
+
+
+async def main():
+    _ = await init_db(PG_DSN, models, True)
+    ex = await Ex.get(name="Htx")
+    cl = ExClient(ex)
+    await cl.pairs()
+    await cl.set_pmcurexs()
+    await cl.set_coinexs()
+    await cl.close()
+
+
+if __name__ == "__main__":
+    run(main())

{xync_client-0.0.25.dev40 → xync_client-0.0.25.dev41}/xync_client/TgWallet/ex.py

@@ -32,17 +32,17 @@ class ExClient(BaseExClient, AuthClient):
         return settings["data"]
 
     # 19: Список поддерживаемых валют тейкера
-    async def curs(self) -> list[types.CurE]:
+    async def curs(self) -> dict[str, types.CurE]:
         coins_curs = await self._post("/p2p/public-api/v2/currency/all-supported")
         stg = await self._settings()
         roundings: dict[str, int] = stg["offerSettings"]["roundingScaleByFiatCurrency"]
         minimums: dict[str, str] = stg["offerSettings"]["minOrderAmountByCurrencyCode"]
-        return [
-            types.CurE(
+        return {
+            c["code"]: types.CurE(
                 exid=c["code"], ticker=c["code"], rounding_scale=roundings.get(c["code"]), minimum=minimums[c["code"]]
             )
             for c in coins_curs["data"]["fiat"]
-        ]
+        }
 
     async def _pms(self, cur: str) -> dict[str, PmEpydRoot]:
         pms = await self._post("/p2p/public-api/v3/payment-details/get-methods/by-currency-code", {"currencyCode": cur})
@@ -54,7 +54,7 @@ class ExClient(BaseExClient, AuthClient):
         if cur:
             pms = await self._pms(cur)
         else:
-            for cur in await self.curs():
+            for cur in (await self.curs()).values():
                 pms |= await self._pms(cur.exid)
         return {
             k: types.Pm(
@@ -67,25 +67,25 @@ class ExClient(BaseExClient, AuthClient):
 
     # 21: Список платежных методов по каждой валюте
     async def cur_pms_map(self) -> MapOfIdsList:
-        return {cur.exid: list(await self._pms(cur.exid)) for cur in await self.curs()}
+        return {cur.exid: list(await self._pms(cur.exid)) for cur in (await self.curs()).values()}
 
     # 22: Список торгуемых монет (с ограничениям по валютам, если есть)
-    async def coins(self) -> list[types.CoinE]:
+    async def coins(self) -> dict[str, types.CoinE]:
         coins_curs = await self._post("/p2p/public-api/v2/currency/all-supported")
         stg = await self._settings()
         lims = list(stg["offerSettings"]["offerVolumeLimitsPerMarket"].values())
         coins = {k: max(float(v[k]["minInclusive"]) for v in lims) for k, v in lims[0].items()}
-        return [
-            types.CoinE(exid=c["code"], ticker=c["code"], minimum=coins[c["code"]])
+        return {
+            c["code"]: types.CoinE(exid=c["code"], ticker=c["code"], minimum=coins[c["code"]])
             for c in coins_curs["data"]["crypto"]
-        ]
+        }
 
     # 23: Список пар валюта/монет
-    async def pairs(self) -> MapOfIdsList:
+    async def pairs(self) -> tuple[MapOfIdsList, MapOfIdsList]:
         coins = await self.coins()
         curs = await self.curs()
-        pairs = {cur.exid: set(c.exid for c in coins) for cur in curs}
-        return pairs
+        pairs = {cur.exid: set(c.exid for c in coins.values()) for cur in curs.values()}
+        return pairs, pairs
 
     # 42: Чужая объява по id
     async def ad(self, ad_id: int) -> _TakerOne:
@@ -126,9 +126,10 @@ class ExClient(BaseExClient, AuthClient):
 
     async def ad_taker_epyd2pydin(self, ad: _TakerOne) -> types.AdBuyIn:
         adx: types.BaseAdIn = await self.ad_common_epyd2pydin(ad)
-        adx.maker = (await models.Actor.update_or_create({"name": ad.user.nickname}, ex=self.ex, exid=ad.user.userId))[
-            0
-        ]
+        act_unq = dict(ex=self.ex, exid=ad.user.userId)
+        if not (actor := await models.Actor.get_or_none(**act_unq)):
+            actor = await models.Actor.create(**act_unq, name=ad.user.nickname, person=await models.Person.create())
+        adx.maker = actor
         pms = ad.paymentMethods if isinstance(ad, _PmsTrait) else [pd.paymentMethod for pd in ad.paymentDetails]
         return types.AdBuyIn(
             **adx.model_dump(), pms_=await models.Pm.filter(pmexs__ex=self.ex, pmexs__exid__in=[p.code for p in pms])

{xync_client-0.0.25.dev40 → xync_client-0.0.25.dev41/xync_client.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: xync-client
-Version: 0.0.25.dev40
+Version: 0.0.25.dev41
 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.dev40/xync_client/Htx/ex.py

@@ -1,90 +0,0 @@
-from asyncio import run
-
-from msgspec import convert
-from x_model import init_db
-from xync_schema import models, types
-from xync_schema.models import Ex, Cur
-from xync_schema.enums import PmType
-
-from xync_client.Abc.Ex import BaseExClient
-from xync_client.Htx.etype import pm, Country
-from xync_client.loader import PG_DSN
-
-
-class ExClient(BaseExClient):
-    # 20: Get all pms
-    async def pms(self, _cur: Cur = None) -> dict[int, types.Pm]:
-        dist = {
-            0: PmType.card,
-            1: PmType.bank,
-            2: PmType.cash,
-            3: PmType.emoney,
-            4: PmType.emoney,
-            5: PmType.IFSC,
-        }
-
-        pms: list[pm.Resp] = [convert(p, pm.Resp) for p in (await self._coin_curs_pms())["payMethod"]]
-
-        pmsd = {
-            p.payMethodId: types.Pm(
-                name=p.name,
-                type_=dist.get(p.template),
-                logo=p.bankImage or p.bankImageWeb,
-            )
-            for p in pms
-        }
-
-        return pmsd
-
-    # 21: Get all: currency,pay,allCountry,coin
-    async def curs(self) -> list[types.CurE]:
-        res = (await self._coin_curs_pms())["currency"]
-        return [
-            types.CurE(exid=c["currencyId"], ticker=c["nameShort"]) for c in res
-        ]  # if c['showPtoP'] todo: wht "showPtoP" is means
-
-    # 22: Список платежных методов по каждой валюте
-    async def cur_pms_map(self) -> dict[int, set[int]]:
-        res = await self._coin_curs_pms()
-        wrong_pms = {4, 34, 498, 548, 20009, 20010}  # , 212, 239, 363  # these ids not exist in pms
-        return {c["currencyId"]: set(c["supportPayments"]) - wrong_pms for c in res["currency"] if c["supportPayments"]}
-
-    # 23: Список торгуемых монет
-    async def coins(self) -> list[types.CoinE]:
-        coins: list[dict] = (await self._coin_curs_pms())["coin"]
-        return [types.CoinE(exid=c["coinId"], ticker=c["coinCode"]) for c in coins if c["coinType"] == 2]
-
-    # 99: Страны
-    async def countries(self) -> list[Country]:
-        res = await self._coin_curs_pms()
-        cts = [
-            Country(
-                id=c["countryId"],
-                code=c["code"],
-                name=name[:-1] if (name := c["name"].split(",")[0]).endswith(".") else name,
-                short=c["appShort"],
-                cur_id=c["currencyId"],
-            )
-            for c in res["country"]
-        ]
-        return cts
-
-    # Get all: currency,pay,allCountry,coin
-    async def _coin_curs_pms(self) -> (dict, dict, dict, dict):
-        res = (await self._get("/-/x/otc/v1/data/config-list?type=currency,pay,coin,allCountry"))["data"]
-        res["currency"][0]["currencyId"] = 1
-        [c.update({"currencyId": 1, "name": ""}) for c in res["country"] if c["currencyId"] == 172]
-        return res
-
-
-async def main():
-    _ = await init_db(PG_DSN, models, True)
-    ex = await Ex.get(name="Htx")
-    cl = ExClient(ex)
-    await cl.set_pmcurexs()
-    await cl.set_coinexs()
-    await cl.close()
-
-
-if __name__ == "__main__":
-    run(main())