xync-client 0.0.25.dev42__tar.gz → 0.0.25.dev43__tar.gz

{xync_client-0.0.25.dev42/xync_client.egg-info → xync_client-0.0.25.dev43}/PKG-INFO

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

@@ -1,7 +1,7 @@
 import logging
 
 import pytest
-from xync_schema.types import Pm, BaseAd, CurE, CoinE
+from xync_schema.types import BaseAd, CurEx, CoinEx, PmOut
 
 from xync_client.Abc.BaseTest import BaseTest
 from xync_schema.enums import ExStatus, ExType, ExAction
@@ -13,8 +13,8 @@ from xync_client.Abc.Ex import BaseExClient
 
 @pytest.mark.asyncio(loop_scope="session")
 class TestEx(BaseTest):
-    coins: dict[int, dict[str, CoinE]] = {}
-    curs: dict[int, dict[str, CurE]] = {}
+    coins: dict[int, dict[str, CoinEx]] = {}
+    curs: dict[int, dict[str, CurEx]] = {}
 
     @pytest.fixture
     async def clients(self) -> list[BaseClient]:
@@ -27,8 +27,8 @@ class TestEx(BaseTest):
     # 19
     async def test_curs(self, clients: list[BaseExClient]):
         for client in clients:
-            curs: dict[str, CurE] = await client.curs()
-            ok = self.is_dict_of_objects(curs, CurE)
+            curs: dict[str, CurEx] = await client.curs()
+            ok = self.is_dict_of_objects(curs, CurEx)
             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
@@ -37,8 +37,8 @@ class TestEx(BaseTest):
     # 20
     async def test_pms(self, clients: list[BaseExClient]):
         for client in clients:
-            pms: dict[int | str, Pm] = await client.pms()
-            ok = self.is_dict_of_objects(pms, Pm)
+            pms: dict[int | str, PmOut] = await client.pms()
+            ok = self.is_dict_of_objects(pms, PmOut)
             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")
@@ -55,8 +55,8 @@ class TestEx(BaseTest):
     # 22
     async def test_coins(self, clients: list[BaseExClient]):
         for client in clients:
-            coins: dict[str, CoinE] = await client.coins()
-            ok = self.is_dict_of_objects(coins, CoinE)
+            coins: dict[str, CoinEx] = await client.coins()
+            ok = self.is_dict_of_objects(coins, CoinEx)
             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

{xync_client-0.0.25.dev42 → xync_client-0.0.25.dev43}/xync_client/Abc/Ex.py

@@ -1,173 +1,14 @@
 import logging
-import re
 from abc import abstractmethod
 
 import msgspec
 from msgspec import Struct
 from tortoise.exceptions import MultipleObjectsReturned, IntegrityError
-from x_model.types import Upd
-from xync_schema import types
 from xync_schema import models
+from xync_schema.types import CurEx, PmOut, CoinEx, BaseAd, BaseAdIn
 
 from xync_client.Abc.Base import BaseClient, MapOfIdsList
-
-
-class PmUni(Upd):
-    _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]
+from xync_client.pm_unifier import PmUnifier, PmUni
 
 
 class BaseExClient(BaseClient):
@@ -176,12 +17,12 @@ class BaseExClient(BaseClient):
 
     # 19: Список поддерживаемых валют тейкера
     @abstractmethod
-    async def curs(self) -> dict[str, types.CurE]:  # {cur.ticker: cur}
+    async def curs(self) -> dict[str, CurEx]:  # {cur.ticker: cur}
         ...
 
     # 20: Список платежных методов
     @abstractmethod
-    async def pms(self, cur: models.Cur = None) -> dict[int | str, types.Pm]:  # {pm.exid: pm}
+    async def pms(self, cur: models.Cur = None) -> dict[int | str, PmOut]:  # {pm.exid: pm}
         ...
 
     # 21: Список платежных методов по каждой валюте
@@ -191,7 +32,7 @@ class BaseExClient(BaseClient):
 
     # 22: Список торгуемых монет (с ограничениям по валютам, если есть)
     @abstractmethod
-    async def coins(self) -> dict[str, types.CoinE]:  # {coin.ticker: coin}
+    async def coins(self) -> dict[str, CoinEx]:  # {coin.ticker: coin}
         ...
 
     # 23: Список пар валюта/монет
@@ -202,16 +43,16 @@ class BaseExClient(BaseClient):
     @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}
+    ) -> list[BaseAd]:  # {ad.id: ad}
         ...
 
     # 42: Чужая объява по id
     @abstractmethod
-    async def ad(self, ad_id: int) -> types.BaseAd: ...
+    async def ad(self, ad_id: int) -> BaseAd: ...
 
     # Преобразрование объекта объявления из формата биржи в формат xync
     @abstractmethod
-    async def ad_epyd2pydin(self, ad: types.BaseAd) -> types.BaseAdIn: ...  # my_uid: for MyAd
+    async def ad_epyd2pydin(self, ad: BaseAd) -> BaseAdIn: ...  # my_uid: for MyAd
 
     # 99: Страны
     async def countries(self) -> list[Struct]:
@@ -220,7 +61,7 @@ class BaseExClient(BaseClient):
     # Импорт Pm-ов (с Pmcur-, Pmex- и Pmcurex-ами) и валют (с Curex-ами) с биржи в бд
     async def set_pmcurexs(self):
         # Curs
-        cur_pyds: dict[str, types.CurE] = await self.curs()
+        cur_pyds: dict[str, CurEx] = 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()
@@ -274,7 +115,7 @@ class BaseExClient(BaseClient):
         # todo: curexcountry
 
         # Pms
-        pms_epyds: dict[int | str, types.Pm] = {
+        pms_epyds: dict[int | str, PmOut] = {
             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({})
@@ -343,7 +184,7 @@ class BaseExClient(BaseClient):
 
     # Импорт монет (с Coinex-ами) с биржи в бд
     async def set_coinexs(self):
-        coins: dict[str, types.CoinE] = await self.coins()
+        coins: dict[str, CoinEx] = 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()
         }
@@ -353,7 +194,7 @@ class BaseExClient(BaseClient):
         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:
+    async def ad_pydin2db(self, ad_pydin: 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?

xync_client-0.0.25.dev43/xync_client/Abc/types.py

@@ -0,0 +1 @@
+

{xync_client-0.0.25.dev42 → xync_client-0.0.25.dev43}/xync_client/Gate/ex.py

@@ -1,7 +1,9 @@
 import re
+import subprocess
 from asyncio import run, sleep
-from json import JSONDecoder
+from json import loads
 
+import requests
 from bs4 import BeautifulSoup, Script
 from x_model import init_db
 from xync_schema import models
@@ -13,31 +15,30 @@ from xync_client.loader import PG_DSN
 
 
 class ExClient(BaseExClient):
-    # 20: Список всех платежных методов на бирже
-    async def pms(self, cur: Cur = None) -> DictOfDicts:
+    # Данные для р2р из html Gate.io
+    async def c2c_data(self) -> dict:
         await sleep(1)
-        doc = await self._get("/p2p")
+        # doc = await self._get("/p2p")  # todo: почему не работает? хз
+        doc = requests.get("https://www.gate.io/p2p").text
         await sleep(1)
         soup = BeautifulSoup(doc, "html.parser")
-        script: Script = soup.body.find_all("script")[17]  # 17-th not stable
-        strng = (
-            script.get_text(strip=True)
-            .replace("\n", "")
-            .replace("  ", "")
-            .replace(
-                ',\'bank\': {image: "/images/payment/bank.png",index: "2",pay_name: lang_string("银行卡"),pay_type: "bank",rgb: "#FF860D",}',
-                "",
-            )
-        )
-        # pattern = r'var c2cData = (\{.*?\})\s+var transLang'
-        # pattern = r'payment_settings:\s{1}(\{.*?\}),\s?// 用户放开的支付方式'
-        pattern = r"payment_settings:\s{1}(\{.*?\}),paymentIdMap:"
+        script: Script = soup.body.find_all("script")[19]  # 17-th not stable
+        strng = script.get_text().replace("  ", "")
+        pattern = r"var c2cData = (\{.*?\})\s+var transLang"
         match = re.search(pattern, strng.replace(",}", "}").replace(",]", "]"), re.DOTALL)
         res = match.group(1)
-        pms = JSONDecoder(strict=False).decode(res)
+        p = subprocess.Popen(
+            ["node", "-e", f"const lang_string = a => a;console.log(JSON.stringify({res}))"], stdout=subprocess.PIPE
+        )
+        out = p.stdout.read().decode()
+        return loads(out)
+
+    # 20: Список всех платежных методов на бирже
+    async def pms(self, cur: Cur = None) -> DictOfDicts:
+        data = await self.c2c_data()
         return {
-            pm["index"]: {"name": pm["pay_name"], "logo": pm["image"], "identifier": idf, "type_": pm["base_type"]}
-            for idf, pm in pms.items()
+            pm["index"]: {"name": pm["pay_name"], "logo": pm["image"], "identifier": idf, "type_": pm.get("base_type")}
+            for idf, pm in data["payment_settings"].items()
         }
 
     # 21: Список поддерживаемых валют
@@ -62,7 +63,7 @@ async def main():
     _ = await init_db(PG_DSN, models, True)
     bg = await Ex.get(name="Gate")
     cl = ExClient(bg)
-    await cl.curs()
+    # curs = await cl.curs()
     # await cl.coins()
     pms = await cl.pms()
     print(pms)

xync_client-0.0.25.dev43/xync_client/pm_unifier.py

@@ -0,0 +1,161 @@
+import re
+
+from x_model.types import Upd
+
+
+class PmUni(Upd):
+    _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]

{xync_client-0.0.25.dev42 → xync_client-0.0.25.dev43/xync_client.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: xync-client
-Version: 0.0.25.dev42
+Version: 0.0.25.dev43
 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.dev42 → xync_client-0.0.25.dev43}/xync_client.egg-info/SOURCES.txt

@@ -19,6 +19,7 @@ tests/_todo_refact/Wallet/test_agent.py
 tests/_todo_refact/Wallet/test_ex.py
 xync_client/__init__.py
 xync_client/loader.py
+xync_client/pm_unifier.py
 xync_client/pyro.py
 xync_client.egg-info/PKG-INFO
 xync_client.egg-info/SOURCES.txt
@@ -33,6 +34,7 @@ xync_client/Abc/BaseTest.py
 xync_client/Abc/Ex.py
 xync_client/Abc/InAgent.py
 xync_client/Abc/Order.py
+xync_client/Abc/types.py
 xync_client/Binance/__init__.py
 xync_client/Binance/binance_async.py
 xync_client/Binance/earn_api.py