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

{xync_client-0.0.25.dev39/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.dev39
+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.dev39 → 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.dev39 → 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.dev41/xync_client/Abc/Ex.py

@@ -0,0 +1,361 @@
+import logging
+import re
+from abc import abstractmethod
+
+import msgspec
+from msgspec import Struct
+from tortoise.exceptions import MultipleObjectsReturned, IntegrityError
+from x_model.models import PydIn
+from xync_schema import types
+from xync_schema import models
+
+from xync_client.Abc.Base import BaseClient, MapOfIdsList
+
+
+class PmUni(PydIn):
+    _unq: list[str] = ["norm", "country"]
+
+    norm: str
+    acronym: str = None
+    country: str = None
+    alias: str = None
+    extra: str = None
+    bank: bool = None
+
+
+class PmUnifier:
+    pms: dict[str, PmUni] = {}  # {origin: normalized}
+
+    pm_map: dict[str, str] = {
+        "Юmoney": "YooMoney",
+        # "Local Bank (R-Green)": "Sberbank",
+        # "Local Bank (S-Green)": "Sberbank",
+        # "Local Card (Red)": "Alfa-Bank",
+        # "Local Card (Yellow)": "Tinkoff",
+        # "Local Card M-redTS": "MTS-bank",
+        # "Local Card-Green": "Sberbank",
+        # "Local Card-Yellow": "Tinkoff",
+        # "GTB Bank (Guarantee Trust Bank)": "GTBank",
+    }
+    re_bank = [
+        r"^bank (?!of )|bank$",
+        r" banka$",
+        r" bankas$",
+        r" bankası$",
+        r" banca$",
+        r"^banco(?! de | del )| banco$",
+    ]
+    re_extra = [
+        r"\(card\)$|\bpay$|\bmoney$|\bwallet$|\bcash$",
+        r"b\.s\.c\.|k\.s\.c|s\.a$| sv$| gt$",
+    ]
+    re_glut = [
+        r"\.io$|\.com$",
+        r"l'|d’|d'",
+    ]
+    i18n_map = {
+        # "  ": " ",
+        "nationale": "national",
+        "а": "a",
+        "á": "a",
+        "â": "a",
+        "о": "o",
+        "ó": "o",
+        "ō": "o",
+        "ú": "u",
+        "ü": "u",
+        "ų": "u",
+        "с": "c",
+        "č": "c",
+        "ç": "c",
+        "é": "e",
+        "è": "e",
+        "ş": "s",
+        "š": "s",
+        "ř": "r",
+        "í": "i",
+    }
+    rms = " -:`'’′"
+
+    def __init__(self, countries: list[str]):
+        self.cts = countries
+
+    def countries(self, name: str):
+        for ct in self.cts:
+            # Если имя кончается на "Название_страны" в скобках
+            if (
+                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, "")
+                self.pms[name].country = ct
+                self.clear(name)
+                return
+
+    def extra(self, name: str):
+        for r in self.re_extra:
+            if match := re.search(r, self.pms[name].norm):
+                self.pms[name].norm = self.pms[name].norm.replace(match.group(), "")
+                self.pms[name].extra = match.group()
+                self.clear(name)
+                return
+
+    def alias(self, name: str):
+        if match := re.search(r"\(.+\)$", self.pms[name].norm):
+            self.pms[name].norm = self.pms[name].norm.replace(match.group(), "")
+            self.pms[name].alias = match.group()[1:-1]
+            self.clear(name)
+            return
+
+    def bank(self, name: str):
+        for r in self.re_bank:
+            if match := re.search(r, self.pms[name].norm):
+                self.pms[name].norm = self.pms[name].norm.replace(match.group(), "")
+                self.pms[name].bank = True
+                self.clear(name)
+                return
+
+    def acro(self, name: str):
+        acr = "".join(
+            wrd[0]
+            for wrd in self.pms[name].norm.split(" ")
+            if not wrd.isupper()
+            and not wrd.startswith(("(", "the"))
+            and len(wrd) > 2
+            or (len(wrd) > 1 and wrd.istitle())
+        ).upper()
+        if len(acr) >= 2 and (
+            f"({acr})" in self.pms[name].norm
+            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()
+            self.pms[name].acronym = acr
+            self.clear(name)
+
+    def slim(self, name: str):
+        for rm in self.re_glut:
+            self.pms[name].norm = re.sub(rm, "", self.pms[name].norm)
+
+    def i18n(self, name: str):
+        for src, trgt in self.i18n_map.items():
+            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(" -:")
+
+    def __call__(self, s: str) -> PmUni:
+        # если в словаре замен есть текущее назвние - меняем, иначе берем строку до запятой
+        self.pms[s] = PmUni(norm=self.pm_map.get(s, s.split(",")[0]))
+        # вырезаем мусорные добавки
+        self.slim(s)
+        # заменяем локальные символы на англ:
+        self.i18n(s)
+        # находим и вырезаем аббревиатуру, если есть
+        self.acro(s)
+        # уменьшаем все буквы
+        self.pms[s].norm = self.pms[s].norm.lower()
+        # находим и вырезаем страны, если есть
+        self.countries(s)
+        self.bank(s)
+        self.extra(s)
+        self.alias(s)
+        self.bank(s)
+        self.countries(s)
+        self.extra(s)
+        # вырезаем каждый символ rms
+        [self.pms[s].norm.replace(rm, "") for rm in self.rms]
+
+        return self.pms[s]
+
+
+class BaseExClient(BaseClient):
+    @abstractmethod
+    def pm_type_map(self, type_: models.Pmex) -> str: ...
+
+    # 19: Список поддерживаемых валют тейкера
+    @abstractmethod
+    async def curs(self) -> dict[str, types.CurE]:  # {cur.ticker: cur}
+        ...
+
+    # 20: Список платежных методов
+    @abstractmethod
+    async def pms(self, cur: models.Cur = None) -> dict[int | str, types.Pm]:  # {pm.exid: pm}
+        ...
+
+    # 21: Список платежных методов по каждой валюте
+    @abstractmethod
+    async def cur_pms_map(self) -> MapOfIdsList:  # {cur.exid: [pm.exid]}
+        ...
+
+    # 22: Список торгуемых монет (с ограничениям по валютам, если есть)
+    @abstractmethod
+    async def coins(self) -> dict[str, types.CoinE]:  # {coin.ticker: coin}
+        ...
+
+    # 23: Список пар валюта/монет
+    @abstractmethod
+    async def pairs(self) -> tuple[MapOfIdsList, MapOfIdsList]: ...
+
+    # 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, amount: int = None
+    ) -> list[types.BaseAd]:  # {ad.id: ad}
+        ...
+
+    # 42: Чужая объява по id
+    @abstractmethod
+    async def ad(self, ad_id: int) -> types.BaseAd: ...
+
+    # Преобразрование объекта объявления из формата биржи в формат xync
+    @abstractmethod
+    async def ad_epyd2pydin(self, ad: types.BaseAd) -> types.BaseAdIn: ...  # my_uid: for MyAd
+
+    # 99: Страны
+    async def countries(self) -> list[Struct]:
+        return []
+
+    # Импорт Pm-ов (с Pmcur-, Pmex- и Pmcurex-ами) и валют (с Curex-ами) с биржи в бд
+    async def set_pmcurexs(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=tkr))[0]
+            for tkr, cur_pyd in cur_pyds.items()
+        }
+        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"]
+        )
+
+        countries = await self.countries()
+
+        cur_map = {
+            172: "CNY",
+            8: "KRW",
+            25: "MMK",
+        }
+        for c in countries:
+            if c.cur_id not in curs:
+                cur, _ = await models.Cur.get_or_create(id=c.cur_id, ticker=cur_map[c.cur_id])
+                c.cur_id = cur.id
+        # Country preparing
+        # countries = sorted(
+        #     (c for c in countries if c.code not in (999, 9999, 441624, 999999)), key=lambda x: x.name
+        # )  # sort and filter
+        cnts = {
+            "BosniaandHerzegovina": "BA",
+            "Brunei": "BN",
+            "Congo": "CD",
+            "Djibouti": "DJ",
+            "Guinea": "GN",
+            "Iraq": "IQ",
+            "Kyrgyzstan": "KG",
+            "ComorosIslands": "KM",
+            "Liberia": "LR",
+            "Libya": "LY",
+            "Yemen": "YE",
+            "Zimbabwe": "ZW",
+            "United States of America": "US",
+            "Lebanon": "LB",
+            "Central African Republic": "XA",
+            "Laos": "LA",
+            "Tanzania": "TZ",
+            "Bangladesh": "BD",
+        }
+        [setattr(c, "short", cnts.get(c.name, c.short)) for c in countries]  # add missed shortNames
+        # Countries create
+        cntrs: [models.Country] = [models.Country(**msgspec.to_builtins(c)) for c in countries]
+        # ids only for HTX
+        await models.Country.bulk_create(cntrs, ignore_conflicts=True)
+        # todo: curexcountry
+
+        # Pms
+        pms_epyds: dict[int | str, types.Pm] = {
+            k: v for k, v in sorted((await self.pms()).items(), key=lambda x: x[1].name)
+        }  # sort by name
+        pms: dict[int | str, models.Pm] = dict({})
+        prev = 0, "", ""  # id, normd-name, orig-name
+        cntrs = [c.lower() for c in await models.Country.all().values_list("name", flat=True)]
+        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], country=country))
+                # и добавляем Pmex для него
+                await models.Pmex.update_or_create({"name": pm.name}, ex=self.ex, exid=k, pm=pm_)
+            elif (
+                prev[1] == pmu.norm and pmu.country == prev[3]
+            ):  # 2 разных оригинальных имени на этой бирже совпали при нормализации
+                logging.error(
+                    f"Pm: {pm.name}&{prev[2]} overnormd as {pmu.norm} with ids {prev[0]}: {k} on {self.ex.name}"
+                )
+                # новый Pm не добавляем, только Pmex для него
+                # новый Pm не добавляем, а берем старый с этим названием
+                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(), "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:
+                    print(d)
+                    raise e
+            prev = k, pmu.norm, pm.name, pmu.country
+        # Pmexs
+        pmexs = [models.Pmex(exid=k, ex=self.ex, pm=pm, name=pms_epyds[k].name) for k, pm in pms.items()]
+        await models.Pmex.bulk_create(pmexs, on_conflict=["ex_id", "exid"], update_fields=["pm_id", "name", "name_"])
+        # Pmex banks
+        for k, pm in pms_epyds.items():
+            if banks := pm.banks:
+                pmex = await models.Pmex.get(ex=self.ex, exid=k)  # pm=pms[k],
+                for b in banks:
+                    await models.PmexBank.update_or_create({"name": b.name}, exid=b.exid, pmex=pmex)
+
+        cur2pms = await self.cur_pms_map()
+        # # Link PayMethods with currencies
+        pmcurs = set()
+        for cur_id, exids in cur2pms.items():
+            for exid in exids:
+                pmcurs.add(
+                    (
+                        await models.Pmcur.update_or_create(
+                            cur=curs[cur_id],
+                            pm=pms.get(exid)
+                            or (await models.Pmex.get(ex=self.ex, exid=exid).prefetch_related("pm")).pm,
+                        )
+                    )[0]
+                )
+        # pmcurexs = [Pmcurex(pmcur=pmcur, ex=self.ex) for pmcur in pmcurs]
+        # await Pmcurex.bulk_create(pmcurexs)
+
+    # Импорт монет (с Coinex-ами) с биржи в бд
+    async def set_coinexs(self):
+        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.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.values()
+        ]
+        await models.Coinex.bulk_create(coinexs, update_fields=["minimum"], on_conflict=["coin_id", "ex_id"])
+
+    # Сохранение чужого объявления (с Pm-ами) в бд
+    async def ad_pydin2db(self, ad_pydin: types.BaseAdIn) -> models.Ad:
+        df, unq = ad_pydin.args()
+        ad_db, _ = await models.Ad.update_or_create(df, **unq)
+        if getattr(ad_pydin, "pms_", None):  # if it ListItem, not Full One # todo: remove?
+            await ad_db.pms.add(*ad_pydin.pms_)
+        return ad_db

{xync_client-0.0.25.dev39 → 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.dev39 → 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