xync-client 0.0.94.dev0__tar.gz → 0.0.95.dev0__tar.gz

{xync_client-0.0.94.dev0/xync_client.egg-info → xync_client-0.0.95.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xync-client
-Version: 0.0.94.dev0
+Version: 0.0.95.dev0
 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.94.dev0 → xync_client-0.0.95.dev0}/tests/TestAgent.py

@@ -3,7 +3,7 @@ import logging
 import pytest
 from tortoise.functions import Count
 from xync_schema.enums import ExStatus, ExAction, UserStatus
-from xync_schema.models import Ex, ExStat, Ad, Coin, Cur, Pmcur, Cred, CredEx, Actor, Person
+from xync_schema.models import Ex, ExStat, Ad, Coin, Cur, PmCur, Cred, CredEx, Actor, Person
 from xync_schema.xtype import BaseAd
 
 from xync_client.Abc.BaseTest import BaseTest
@@ -32,9 +32,9 @@ class TestAgent(BaseTest):
     # 26
     async def test_cred_new(self, clients: list[tuple[BaseAgentClient, BaseAgentClient]]):
         for maker, taker in clients:
-            pmcur = await Pmcur.filter(pm__pmexs__ex=taker.actor.ex, cur__ticker="RUB", pm__norm="payeer").first()
+            pmcur = await PmCur.filter(pm__pmexs__ex=taker.actor.ex, cur__ticker="RUB", pm__norm="payeer").first()
             cred = await Cred.create(person_id=taker.actor.person_id, name="Tst", detail="79990001234", pmcur=pmcur)
-            # await cred.banks.add(await PmexBank.get(exid="mts"), await PmexBank.get(exid="sberbankru"))
+            # await cred.banks.add(await PmExBank.get(exid="mts"), await PmExBank.get(exid="sberbankru"))
             cred_new: CredEx = await taker.cred_new(cred)
             ok = isinstance(cred_new, CredEx)
             t, _ = await ExStat.update_or_create({"ok": ok}, ex=taker.actor.ex, action=ExAction.cred_new)

{xync_client-0.0.94.dev0 → xync_client-0.0.95.dev0}/tests/TestEx.py

@@ -104,8 +104,8 @@ class TestEx(BaseTest):
     # 24
     async def test_ads(self, clients: list[BaseExClient]):
         for client in clients:
-            cur = await models.Curex.filter(cur__ticker="EUR", ex=client.ex).first().values_list("exid", flat=True)
-            coin = await models.Coinex.filter(coin__ticker="USDT", ex=client.ex).first().values_list("exid", flat=True)
+            cur = await models.CurEx.filter(cur__ticker="EUR", ex=client.ex).first().values_list("exid", flat=True)
+            coin = await models.CoinEx.filter(coin__ticker="USDT", ex=client.ex).first().values_list("exid", flat=True)
             ads: list[BaseAd] = await client.ads(coin, cur, False)
             ok = self.is_list_of_objects(ads, BaseAd)
             t, _ = await models.ExStat.update_or_create({"ok": ok}, ex=client.ex, action=ExAction.ads)
@@ -123,10 +123,10 @@ class TestEx(BaseTest):
                 continue
             for race in races:
                 # получаем данные направления текущей гонки
-                coinex = await models.Coinex.get(ex=client.ex, coin_id=race.road.ad.pair_side.pair.coin_id)
-                curex = await models.Curex.get(ex=client.ex, cur_id=race.road.ad.pair_side.pair.cur_id)
+                coinex = await models.CoinEx.get(ex=client.ex, coin_id=race.road.ad.pair_side.pair.coin_id)
+                curex = await models.CurEx.get(ex=client.ex, cur_id=race.road.ad.pair_side.pair.cur_id)
                 pm_ids = [pm.id for pm in race.road.ad.pms]
-                pmex_exids = await models.Pmex.filter(ex=client.ex, pm_id__in=pm_ids).values_list("exid", flat=True)
+                pmex_exids = await models.PmEx.filter(ex=client.ex, pm_id__in=pm_ids).values_list("exid", flat=True)
                 # получаем объявления по этому направлению
                 ads = await client.ads(coinex.exid, curex.exid, race.road.ad.pair_side.is_sell, pmex_exids)
                 # if race.vm_filter:

{xync_client-0.0.94.dev0 → xync_client-0.0.95.dev0}/xync_client/Abc/Agent.py

@@ -128,5 +128,5 @@ class BaseAgentClient(HttpClient):
     #     credex_in = models.CredEx.validate({"exid": cred_in.id, "cred_id": cred_db.id})
     #     credex_db, _ = await models.CredEx.update_or_create(**credex_in.df_unq())
     #     if banks:  # only for SBP
-    #         await cred_db.banks.add(*[await PmexBank.get(exid=b) for b in banks])
+    #         await cred_db.banks.add(*[await PmExBank.get(exid=b) for b in banks])
     #     return True

{xync_client-0.0.94.dev0 → xync_client-0.0.95.dev0}/xync_client/Abc/Ex.py

@@ -36,7 +36,7 @@ class BaseExClient(HttpClient):
         super().__init__(getattr(ex, attr), headers, cookies, proxy and proxy.str())
 
     @abstractmethod
-    def pm_type_map(self, typ: models.Pmex) -> str: ...
+    def pm_type_map(self, typ: models.PmEx) -> str: ...
 
     # 19: Список поддерживаемых валют тейкера
     @abstractmethod
@@ -87,7 +87,7 @@ class BaseExClient(HttpClient):
     async def countries(self) -> list[Struct]:
         return []
 
-    # Импорт валют Cur-ов (с Curex-ами)
+    # Импорт валют Cur-ов (с CurEx-ами)
     async def set_curs(self, cookies: dict = None) -> bool:
         # Curs
         cur_pyds: dict[str, CurEx] = await self.curs()
@@ -96,14 +96,12 @@ class BaseExClient(HttpClient):
             for exid, cur_pyd in cur_pyds.items()
         }
         curexs = [
-            models.Curex(**c.model_dump(exclude_none=True), cur=curs[c.exid], ex=self.ex) for c in cur_pyds.values()
+            models.CurEx(**c.model_dump(exclude_none=True), 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"]
-        )
+        # CurEx
+        await models.CurEx.bulk_create(curexs, update_fields=["minimum", "scale"], on_conflict=["cur_id", "ex_id"])
 
-    # Импорт Pm-ов (с Pmcur-, Pmex- и Pmcurex-ами) и валют (с Curex-ами) с биржи в бд
+    # Импорт Pm-ов (с PmCur-, PmEx- и Pmcurex-ами) и валют (с CurEx-ами) с биржи в бд
     async def set_pms(self, cookies: dict = None) -> bool:
         if cookies:
             self.session.cookie_jar.update_cookies(cookies)
@@ -134,19 +132,19 @@ class BaseExClient(HttpClient):
                 logging.warning(f"Pm: '{pmex.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_id=country_id))
-                # и добавляем Pmex для него
-                await models.Pmex.update_or_create({"name": pmex.name}, ex=self.ex, exid=k, pm=pm_)
+                # и добавляем PmEx для него
+                await models.PmEx.update_or_create({"name": pmex.name}, ex=self.ex, exid=k, pm=pm_)
             elif (
                 prev[1] == pmu.norm and pmu.country == prev[3]
             ):  # 2 разных оригинальных имени на этой бирже совпали при нормализации
                 logging.error(
                     f"Pm: {pmex.name}&{prev[2]} overnormd as {pmu.norm} with ids {prev[0]}: {k} on {self.ex.name}"
                 )
-                # новый Pm не добавляем, только Pmex для него
+                # новый Pm не добавляем, только PmEx для него
                 # новый Pm не добавляем, а берем старый с этим названием
                 pm_ = pms.get(prev[0], await models.Pm.get_or_none(norm=prev[1], country_id=country_id))
-                # и добавляем.обновляем Pmex для него
-                await models.Pmex.update_or_create({"pm": pm_}, ex=self.ex, exid=k, name=pmex.name)
+                # и добавляем.обновляем PmEx для него
+                await models.PmEx.update_or_create({"pm": pm_}, ex=self.ex, exid=k, name=pmex.name)
             else:
                 pmin = models.Pm.validate({**pmu.model_dump(), "country_id": country_id, "typ": pmex.typ})
                 try:
@@ -154,14 +152,14 @@ class BaseExClient(HttpClient):
                 except (MultipleObjectsReturned, IntegrityError) as e:
                     raise e
             prev = k, pmu.norm, pmex.name, pmu.country
-        await models.Pmcur.update_or_create(  # todo: NA HU YA???
+        await models.PmCur.update_or_create(  # todo: NA HU YA???
             cur=await models.Cur.get(ticker="THB"), pm=await models.Pm.get(norm="cash in person")
         )
 
         # Pmexs
         async with ClientSession(headers=getattr(self, "logo_headers", None)) as ss:
             pmexs = [
-                models.Pmex(
+                models.PmEx(
                     # todo: refact logo
                     exid=k,
                     ex=self.ex,
@@ -172,13 +170,13 @@ class BaseExClient(HttpClient):
                 for k, pm in pms.items()
             ]
 
-        await models.Pmex.bulk_create(pmexs, on_conflict=["ex_id", "exid"], update_fields=["pm_id", "logo_id", "name"])
-        # Pmex banks
+        await models.PmEx.bulk_create(pmexs, on_conflict=["ex_id", "exid"], update_fields=["pm_id", "logo_id", "name"])
+        # PmEx banks
         for k, pmex in pmexs_epyds.items():
             if banks := pmex.banks:
-                pmex = await models.Pmex.get(ex=self.ex, exid=k)  # pm=pms[k],
+                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)
+                    await models.PmExBank.update_or_create({"name": b.name}, exid=b.exid, pmex=pmex)
 
         cur2pms = await self.cur_pms_map()
         # # Link PayMethods with currencies
@@ -186,13 +184,13 @@ class BaseExClient(HttpClient):
         for cur_id, exids in cur2pms.items():
             for exid in exids:
                 if not (pm_id := pms.get(exid) and pms[exid].id):
-                    if pmex := await models.Pmex.get_or_none(ex=self.ex, exid=exid):
+                    if pmex := await models.PmEx.get_or_none(ex=self.ex, exid=exid):
                         pm_id = pmex.pm_id
                     else:
                         logging.critical(f"For cur {cur_id} not found pm#{exid}")
                         continue
                 if cur_db := curs.get(cur_id):
-                    pmcurs.add((await models.Pmcur.update_or_create(cur=cur_db, pm_id=pm_id))[0])
+                    pmcurs.add((await models.PmCur.update_or_create(cur=cur_db, pm_id=pm_id))[0])
         # pmcurexs = [Pmcurex(pmcur=pmcur, ex=self.ex) for pmcur in pmcurs]
         # await Pmcurex.bulk_create(pmcurexs)
         return True
@@ -206,7 +204,7 @@ class BaseExClient(HttpClient):
             return await self.file_upsert(url, ss)
         return file
 
-    # Импорт монет (с Coinex-ами) с биржи в бд
+    # Импорт монет (с CoinEx-ами) с биржи в бд
     async def set_coins(self):
         coins: dict[str, CoinEx] = await self.coins()
         coins_db: dict[int, models.Coin] = {
@@ -215,10 +213,10 @@ class BaseExClient(HttpClient):
             )[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()
+        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"])
+        await models.CoinEx.bulk_create(coinexs, update_fields=["minimum"], on_conflict=["coin_id", "ex_id"])
         return True
 
     # Импорт пар биржи в бд

{xync_client-0.0.94.dev0 → xync_client-0.0.95.dev0}/xync_client/Abc/xtype.py

@@ -4,7 +4,7 @@ from pydantic import BaseModel, model_validator
 from x_model.types import BaseUpd
 from xync_schema.enums import PmType
 from xync_schema.models import Country, Pm, Ex
-from xync_schema.xtype import PmexBank
+from xync_schema.xtype import PmExBank
 
 from xync_client.pm_unifier import PmUni
 
@@ -17,7 +17,7 @@ MapOfIdsList = dict[int | str, list[int | str]]
 class PmTrait:
     typ: PmType | None = None
     logo: str | None = None
-    banks: list[PmexBank] | None = None
+    banks: list[PmExBank] | None = None
 
 
 class PmEx(BaseModel, PmTrait):

{xync_client-0.0.94.dev0 → xync_client-0.0.95.dev0}/xync_client/BingX/agent.py

@@ -2,7 +2,8 @@ from xync_client.Abc.Agent import BaseAgentClient
 from xync_schema.pydantic import FiatNew
 from xync_schema.models import Cur, Fiat
 from xync_client.Abc.Base import DictOfDicts
-from xync_schema.models import Cur, Coin, OrderStatus, Pmex, Fiat, Ad, Pmcur, Fiatex
+from xync_schema.models import Coin, OrderStatus
+
 
 class AgentClient(BaseAgentClient):
     headers = {
@@ -37,18 +38,20 @@ class AgentClient(BaseAgentClient):
     }
 
     # 0: Получшение заявок за заданное время, в статусе, по валюте, монете
-    async def get_orders(self, status: OrderStatus = OrderStatus.created, coin: Coin = None, cur: Cur = None, is_sell: bool = None):
+    async def get_orders(
+        self, status: OrderStatus = OrderStatus.created, coin: Coin = None, cur: Cur = None, is_sell: bool = None
+    ):
         params = {
-            'pageId': '0',
-            'pageSize': '10',
-            'messageStatus': '0',
-            'orderType': '1',
-            'orderStatus': '',
-            'fiat': '',
-            'searchKeyword': '',
-            'tradeType': '',
-            'beginTime': '1706475600000',
-            'endTime': '1738184399999',
+            "pageId": "0",
+            "pageSize": "10",
+            "messageStatus": "0",
+            "orderType": "1",
+            "orderStatus": "",
+            "fiat": "",
+            "searchKeyword": "",
+            "tradeType": "",
+            "beginTime": "1706475600000",
+            "endTime": "1738184399999",
         }
         order = await self._get("/api/c2c/v2/order/list", params=params)
         return order["data"]["result"]
@@ -56,14 +59,14 @@ class AgentClient(BaseAgentClient):
     # 1: [T] Запрос на старт сделки
     async def order_request(self, ad_id: int, amount: float):
         json_data = {
-            'advertNo': f'{ad_id}',
-            'asset': 'USDT',
-            'fiat': 'RUB',
-            'type': 1,
-            'userPrice': 103,
-            'areaType': 2,
-            'amount': f'{amount}',
-            'paymentMethodId': 110,
+            "advertNo": f"{ad_id}",
+            "asset": "USDT",
+            "fiat": "RUB",
+            "type": 1,
+            "userPrice": 103,
+            "areaType": 2,
+            "amount": f"{amount}",
+            "paymentMethodId": 110,
         }
         order = await self._post("/api/c2c/v1/order/create", json=json_data)
         if order["data"]:

{xync_client-0.0.94.dev0 → xync_client-0.0.95.dev0}/xync_client/Bybit/InAgent.py

@@ -251,7 +251,7 @@ class InAgentClient(BaseInAgentClient):
         pma, cur = await self.get_pma_by_pmex(order_db)
         async with in_transaction():
             # отмечаем ордер на бирже "оплачен"
-            pmex = await models.Pmex.get(pm_id=order_db.cred.pmcur.pm_id, ex=self.agent_client.actor.ex)
+            pmex = await models.PmEx.get(pm_id=order_db.cred.pmcur.pm_id, ex=self.agent_client.actor.ex)
             credex = await models.CredEx.get(cred=order_db.cred, ex=self.agent_client.actor.ex)
             self.agent_client.api.mark_as_paid(
                 orderId=str(order_db.exid),

{xync_client-0.0.94.dev0 → xync_client-0.0.95.dev0}/xync_client/Bybit/agent.py

@@ -29,7 +29,7 @@ from x_model.func import ArrayAgg
 from xync_schema import models
 from xync_schema.enums import OrderStatus
 
-from xync_schema.models import Actor, Cond, CondSim, Pmcur, PairSide
+from xync_schema.models import Actor, Cond, CondSim, PmCur, PairSide
 
 from xync_client.Abc.Agent import BaseAgentClient
 from xync_client.Abc.xtype import BaseOrderReq, FlatDict
@@ -132,11 +132,11 @@ class AgentClient(BaseAgentClient):  # Bybit client
         if ecdx.paymentType in (416,):  # what is 416??
             return None
         if not (
-            pmex := await models.Pmex.get_or_none(exid=ecdx.paymentType, ex=self.ex_client.ex).prefetch_related(
+            pmex := await models.PmEx.get_or_none(exid=ecdx.paymentType, ex=self.ex_client.ex).prefetch_related(
                 "pm__curs"
             )
         ):
-            raise HTTPException(f"No Pmex {ecdx.paymentType} on ex#{self.ex_client.ex.name}", 404)
+            raise HTTPException(f"No PmEx {ecdx.paymentType} on ex#{self.ex_client.ex.name}", 404)
         if cred_old := await models.Cred.get_or_none(credexs__exid=ecdx.id, credexs__ex=self.actor.ex).prefetch_related(
             "pmcur"
         ):
@@ -151,8 +151,8 @@ class AgentClient(BaseAgentClient):  # Bybit client
             )
         if not cur_id:
             raise Exception(f"Set default cur for {pmex.name}")
-        if not (pmcur := await models.Pmcur.get_or_none(cur_id=cur_id, pm_id=pmex.pm_id)):
-            raise HTTPException(f"No Pmcur with cur#{ecdx.currencyBalance} and pm#{ecdx.paymentType}", 404)
+        if not (pmcur := await models.PmCur.get_or_none(cur_id=cur_id, pm_id=pmex.pm_id)):
+            raise HTTPException(f"No PmCur with cur#{ecdx.currencyBalance} and pm#{ecdx.paymentType}", 404)
         dct = {
             "pmcur_id": pmcur.id,
             "name": ecdx.realName,
@@ -229,10 +229,10 @@ class AgentClient(BaseAgentClient):  # Bybit client
 
     async def ads(
         self,
-        cnx: models.Coinex,
-        crx: models.Curex,
+        cnx: models.CoinEx,
+        crx: models.CurEx,
         is_sell: bool,
-        pmxs: list[models.Pmex],
+        pmxs: list[models.PmEx],
         amount: int = None,
         lim: int = 50,
         vm_filter: bool = False,
@@ -445,7 +445,7 @@ class AgentClient(BaseAgentClient):  # Bybit client
                 # cur_id = await Cur.get(ticker=ad.currencyId).values_list('id', flat=True)
                 # await self.cred_epyd2db(ecredex, ad_db.maker.person_id, cur_id)
                 if (
-                    await Pmcur.filter(
+                    await PmCur.filter(
                         pm__pmexs__ex=self.ex_client.ex,
                         pm__pmexs__exid=ecredex.paymentType,
                         cur__ticker=ad.currencyId,
@@ -454,7 +454,7 @@ class AgentClient(BaseAgentClient):  # Bybit client
                 ):
                     ...
                 if not (
-                    pmcur := await Pmcur.get_or_none(
+                    pmcur := await PmCur.get_or_none(
                         pm__pmexs__ex=self.ex_client.ex,
                         pm__pmexs__exid=ecredex.paymentType,
                         cur__ticker=ad.currencyId,
@@ -614,15 +614,15 @@ class AgentClient(BaseAgentClient):  # Bybit client
         self,
         race: models.Race,
     ):
-        coinex: models.Coinex = await models.Coinex.get(
+        coinex: models.CoinEx = await models.CoinEx.get(
             coin_id=race.road.ad.pair_side.pair.coin_id, ex=self.actor.ex
         ).prefetch_related("coin")
-        curex: models.Curex = await models.Curex.get(
+        curex: models.CurEx = await models.CurEx.get(
             cur_id=race.road.ad.pair_side.pair.cur_id, ex=self.actor.ex
         ).prefetch_related("cur")
         taker_side: bool = not race.road.ad.pair_side.is_sell
         pm_ids = [pm.id for pm in race.road.ad.pms]
-        pmexs: list[models.Pmex] = await models.Pmex.filter(pm_id__in=pm_ids, ex=self.actor.ex).prefetch_related("pm")
+        pmexs: list[models.PmEx] = await models.PmEx.filter(pm_id__in=pm_ids, ex=self.actor.ex).prefetch_related("pm")
         k = (-1) ** int(taker_side)  # on_buy=1, on_sell=-1
         sleep_sec = 3  # 1 if set(pms) & {"volet"} and coinex.coin_id == 1 else 5
         creds: list[models.CredEx] = await self.get_credexs_by_pms(race.road.ad.pms, curex.cur_id)
@@ -773,7 +773,7 @@ class AgentClient(BaseAgentClient):  # Bybit client
             await sleep(6)
 
     async def get_books(
-        self, coinex: models.Coinex, curex: models.Curex, pmexs: list[models.Pmex]
+        self, coinex: models.CoinEx, curex: models.CurEx, pmexs: list[models.PmEx]
     ) -> tuple[list[Ad], list[Ad]]:
         buy: list[Ad] = await self.ads(coinex, curex, False, pmexs, None, 30)
         sell: list[Ad] = await self.ads(coinex, curex, True, pmexs, None, 30)
@@ -795,9 +795,9 @@ class AgentClient(BaseAgentClient):  # Bybit client
 
     async def get_ceils(
         self,
-        coinex: models.Coinex,
-        curex: models.Curex,
-        pmexs: list[models.Pmex],
+        coinex: models.CoinEx,
+        curex: models.CurEx,
+        pmexs: list[models.PmEx],
         min_prof=0.01,
         vmf: bool = False,
         place: int = 0,
@@ -815,8 +815,8 @@ class AgentClient(BaseAgentClient):  # Bybit client
 
     async def parse_ads(
         self,
-        coinex: models.Coinex,
-        curex: models.Curex,
+        coinex: models.CoinEx,
+        curex: models.CurEx,
         taker_side: bool,
         pms: list[str] = None,
         ceil: float = None,
@@ -827,7 +827,7 @@ class AgentClient(BaseAgentClient):  # Bybit client
         k = (-1) ** int(taker_side)  # on_buy=1, on_sell=-1
 
         if pms:
-            creds: dict[models.Pmex, models.CredEx] = await self.get_credexs_by_norms(pms, curex.cur_id)
+            creds: dict[models.PmEx, models.CredEx] = await self.get_credexs_by_norms(pms, curex.cur_id)
             [str(p.exid) for p in creds.values()]
 
             if taker_side:  # гонка в стакане продажи - мы покупаем монету за ФИАТ

{xync_client-0.0.94.dev0 → xync_client-0.0.95.dev0}/xync_client/Htx/agent.py

@@ -46,7 +46,7 @@ class AgentClient(BaseAgentClient):
 
     async def cred_new(self, cred: models.Cred) -> models.CredEx:
         pmcur = await cred.pmcur
-        exid = str(await models.Pmex.get(pm_id=pmcur.pm_id, ex=self.ex_client.ex).values_list("exid", flat=True))
+        exid = str(await models.PmEx.get(pm_id=pmcur.pm_id, ex=self.ex_client.ex).values_list("exid", flat=True))
         field_map = {
             "payee": "name",
             "bank": "extra",
@@ -71,7 +71,7 @@ class AgentClient(BaseAgentClient):
 
     async def cred_upd(self, cred: models.Cred, exid: int) -> models.CredEx:
         pmcur = await cred.pmcur
-        _exid = str(await models.Pmex.get(pm_id=pmcur.pm_id, ex=self.ex_client.ex).values_list("exid", flat=True))
+        _exid = str(await models.PmEx.get(pm_id=pmcur.pm_id, ex=self.ex_client.ex).values_list("exid", flat=True))
         field_map = {
             "payee": "name",
             "bank": "extra",
@@ -86,7 +86,7 @@ class AgentClient(BaseAgentClient):
             "modelFields": dumps(
                 [{"fieldId": fid, "fieldType": ft, "value": getattr(cred, field_map[ft])} for ft, fid in fields.items()]
             ),
-            'id': exid,
+            "id": exid,
         }
         await self._post("/-/x/otc/v1/user/receipt-account/modifyByDynamicModel", data=data)
         cred_ids = await models.Cred.filter(credexs__exid=exid).values_list("id", flat=True)

{xync_client-0.0.94.dev0 → xync_client-0.0.95.dev0}/xync_client/Htx/ex.py

@@ -24,7 +24,7 @@ class ExClient(BaseExClient):
 
     _data: dict = {}
 
-    def pm_type_map(self, typ: models.Pmex) -> str:
+    def pm_type_map(self, typ: models.PmEx) -> str:
         pass
 
     async def pairs(self) -> tuple[MapOfIdsList, MapOfIdsList]:

{xync_client-0.0.94.dev0 → xync_client-0.0.95.dev0}/xync_client/Pms/Volet/__init__.py

@@ -12,7 +12,7 @@ from playwright._impl._errors import TimeoutError
 from pyro_client.client.bot import BotClient
 from pyro_client.client.user import UserClient
 from xync_schema.enums import UserStatus
-from xync_schema.models import Cur, User, PmAgent, Cred, Pmcur, Fiat
+from xync_schema.models import Cur, User, PmAgent, Cred, PmCur, Fiat
 
 from xync_client.Gmail import GmClient
 from xync_client.Pms.Volet.api import APIClient
@@ -193,7 +193,7 @@ class Client:
                 (
                     await Cred.update_or_create(
                         {"detail": k},
-                        pmcur=(await Pmcur.get_or_create(pm__norm="volet", cur=await Cur.get(ticker=t)))[0],
+                        pmcur=(await PmCur.get_or_create(pm__norm="volet", cur=await Cur.get(ticker=t)))[0],
                         person_id=self.agent.user.person_id,
                     )
                 )[0],

{xync_client-0.0.94.dev0 → xync_client-0.0.95.dev0}/xync_client/TgWallet/agent.py

@@ -206,12 +206,12 @@ class AgentClient(BaseAgentClient, AuthClient):
         return [CredEpyd(**cred) for cred in resp["data"]]
 
     async def cred_epyd2db(self, cred: CredEpyd) -> models.CredEx:
-        if not (pmex := await models.Pmex.get_or_none(exid=cred.paymentMethod.code, ex=self.ex_client.ex)):
-            raise HTTPException(f"No Pmex {cred.paymentMethod.code} on ex#{self.ex_client.ex.name}", 404)
-        if not (pmcur := await models.Pmcur.get_or_none(cur__ticker=cred.currency, pm_id=pmex.pm_id)):
-            raise HTTPException(f"No Pmcur with cur#{cred.currency} and pm#{cred.paymentMethod.code}", 404)
+        if not (pmex := await models.PmEx.get_or_none(exid=cred.paymentMethod.code, ex=self.ex_client.ex)):
+            raise HTTPException(f"No PmEx {cred.paymentMethod.code} on ex#{self.ex_client.ex.name}", 404)
+        if not (pmcur := await models.PmCur.get_or_none(cur__ticker=cred.currency, pm_id=pmex.pm_id)):
+            raise HTTPException(f"No PmCur with cur#{cred.currency} and pm#{cred.paymentMethod.code}", 404)
         if not (person := await models.Person.get_or_none(actors__exid=cred.userId)):
-            raise HTTPException(f"No Pmcur with cur#{cred.currency} and pm#{cred.paymentMethod.code}", 404)
+            raise HTTPException(f"No PmCur with cur#{cred.currency} and pm#{cred.paymentMethod.code}", 404)
         dct = {"pmcur_id": pmcur.id, "name": cred.name, "person_id": person.id}
         banks: list[str] | None = None
         for val in cred.attributes.values:
@@ -224,7 +224,7 @@ class AgentClient(BaseAgentClient, AuthClient):
         cred_db, _ = await models.Cred.update_or_create(**cred_in.df_unq())
         credex_in = models.CredEx.validate({"exid": cred.id, "cred_id": cred_db.id, "ex_id": self.ex.id})
         if banks:  # only for SBP
-            await cred_db.banks.add(*[await models.PmexBank.get(exid=b) for b in banks])
+            await cred_db.banks.add(*[await models.PmExBank.get(exid=b) for b in banks])
         credex_db, _ = await models.CredEx.update_or_create(**credex_in.df_unq())
         return credex_db
 
@@ -246,8 +246,8 @@ class AgentClient(BaseAgentClient, AuthClient):
 
     # 26: Создание реквизита моего платежного метода
     async def cred_new(self, cred: models.Cred) -> models.CredEx:
-        pmcur: models.Pmcur = await cred.pmcur
-        exid = await models.Pmex.get(pm_id=pmcur.pm_id, ex=self.ex_client.ex).values_list("exid", flat=True)
+        pmcur: models.PmCur = await cred.pmcur
+        exid = await models.PmEx.get(pm_id=pmcur.pm_id, ex=self.ex_client.ex).values_list("exid", flat=True)
         cur = await models.Cur[pmcur.cur_id]
         vals = (
             [
@@ -277,8 +277,8 @@ class AgentClient(BaseAgentClient, AuthClient):
 
     # 27: Редактирование реквизита моего платежного метода
     async def cred_upd(self, cred: models.Cred, exid: int) -> models.CredEx:
-        pmcur: models.Pmcur = await cred.pmcur
-        pmex = await models.Pmex.get(pm_id=pmcur.pm_id, ex=self.ex_client.ex)
+        pmcur: models.PmCur = await cred.pmcur
+        pmex = await models.PmEx.get(pm_id=pmcur.pm_id, ex=self.ex_client.ex)
         cur = await models.Cur[pmcur.cur_id]
         vals = (
             [{"name": "PHONE", "value": cred.detail}, {"name": "BANKS", "value": [b.exid for b in banks]}]
@@ -316,7 +316,7 @@ class AgentClient(BaseAgentClient, AuthClient):
         if isinstance(ad_, _PmsTrait):
             return AdBuyIn(
                 **ad_in.model_dump(),
-                pmexs_=await models.Pmex.filter(ex=self.ex_client.ex, exid__in=[p.code for p in ad_.paymentMethods]),
+                pmexs_=await models.PmEx.filter(ex=self.ex_client.ex, exid__in=[p.code for p in ad_.paymentMethods]),
             )
         credsexs: list[models.CredEx] = [await self.cred_epyd2db(c) for c in ad_.paymentDetails]
         return AdSaleIn(**ad_in.model_dump(), credexs_=credsexs)
@@ -344,8 +344,8 @@ class AgentClient(BaseAgentClient, AuthClient):
     async def ad_f2ein(
         self, coin: models.Coin, cur: models.Cur, is_sell: bool, vol: int = None, cur_min: int = None
     ) -> AdMakerNewSale | AdMakerNewBuy:
-        coinex = await models.Coinex.get(coin=coin, ex=self.ex)
-        curex = await models.Curex.get(ex=self.ex, cur=cur)
+        coinex = await models.CoinEx.get(coin=coin, ex=self.ex)
+        curex = await models.CurEx.get(ex=self.ex, cur=cur)
         credexs = (
             await models.CredEx.filter(cred__person_id=self.actor.person_id, cred__pmcur__cur=cur)
             .limit(5)
@@ -355,7 +355,7 @@ class AgentClient(BaseAgentClient, AuthClient):
         ad_ein = _AdNew(
             type="SALE" if is_sell else "PURCHASE",
             initVolume=AvailableAmountVolume(currencyCode=coinex.exid, amount=str(vol or coinex.minimum)),
-            orderRoundingRequired=curex.rounding_scale is not None,
+            orderRoundingRequired=curex.scale is not None,
             price={
                 "type": "FLOATING",
                 "baseCurrencyCode": coinex.exid,
@@ -369,7 +369,7 @@ class AgentClient(BaseAgentClient, AuthClient):
         if ad_ein.type == "SALE":
             ad_ein = AdMakerNewSale(**ad_ein.model_dump(exclude_none=True), paymentDetailsIds=[c.exid for c in credexs])
         else:
-            pmexs = await models.Pmex.filter(ex=self.actor.ex, pm__pmcurs__id__in=[cx.cred.pmcur_id for cx in credexs])
+            pmexs = await models.PmEx.filter(ex=self.actor.ex, pm__pmcurs__id__in=[cx.cred.pmcur_id for cx in credexs])
             ad_ein = AdMakerNewBuy(**ad_ein.model_dump(exclude_none=True), paymentMethodCodes=[p.exid for p in pmexs])
         return ad_ein
 

{xync_client-0.0.94.dev0 → xync_client-0.0.95.dev0}/xync_client/TgWallet/ex.py

@@ -45,7 +45,7 @@ class ExClient(BaseExClient, AuthClient):
         minimums: dict[str, str] = stg["offerSettings"]["minOrderAmountByCurrencyCode"]
         return {
             c["code"]: xtype.CurEx(
-                exid=c["code"], ticker=c["code"], rounding_scale=roundings.get(c["code"]), minimum=minimums[c["code"]]
+                exid=c["code"], ticker=c["code"], scale=roundings.get(c["code"]), minimum=minimums[c["code"]]
             )
             for c in coins_curs["data"]["fiat"]
         }
@@ -66,7 +66,7 @@ class ExClient(BaseExClient, AuthClient):
             k: PmEx(
                 exid=pm.code,
                 name=pm.nameEng,
-                banks=[xtype.PmexBank(exid=b.code, name=b.name) for b in pm.banks or []],
+                banks=[xtype.PmExBank(exid=b.code, name=b.name) for b in pm.banks or []],
             )
             for k, pm in pms.items()
         }

{xync_client-0.0.94.dev0 → xync_client-0.0.95.dev0}/xync_client/TgWallet/inAgent.py

@@ -7,12 +7,10 @@ from tg_auth import UserStatus
 from tortoise.functions import Count
 from x_model import init_db
 
-from xync_schema import models
 from xync_schema.enums import AssetType
-from xync_schema.models import Agent, Order, Ad, Asset, Coin, Fiat, Fiatex, Pmex, Pmcur, Cur
+from xync_schema.models import Agent, Order, Ad, Asset, Coin, Fiat, Fiatex, PmEx, PmCur, Cur
 
 from xync_client.TgWallet.pyro import PyroClient
-from xync_client.loader import PG_DSN
 from xync_client.Abc.InAgent import BaseInAgentClient
 from xync_client.TgWallet.agent import AgentClient
 
@@ -118,8 +116,8 @@ async def main():
     for k, f in (await mc.my_fiats()).items():
         fiatex, is_new = Fiatex.get_or_create(ex=maker.ex, exid=k)
         if is_new:
-            pmex = await Pmex.get(ex=maker.ex, exid=f["paymentMethod"]["code"]).prefetch_related("pm")
-            pmcur = await Pmcur.get(pm=pmex.pm, cur=await Cur.get(ticker=f["currency"]))
+            pmex = await PmEx.get(ex=maker.ex, exid=f["paymentMethod"]["code"]).prefetch_related("pm")
+            pmcur = await PmCur.get(pm=pmex.pm, cur=await Cur.get(ticker=f["currency"]))
             await Fiat.create(
                 pmcur=pmcur,
                 user=maker.user,

{xync_client-0.0.94.dev0 → xync_client-0.0.95.dev0}/xync_client/pm_unifier.py

@@ -74,7 +74,7 @@ class PmUnifier:
     }
 
     def __init__(self, countries: list[tuple[str, str]], pm_reps: list[PmRep]):
-        self.pm_map = {p.src: p.trgt for p in pm_reps}
+        self.pm_map = {p.src: p.target for p in pm_reps}
         self.cts = countries
 
     def countries(self, name: str):
@@ -153,8 +153,8 @@ class PmUnifier:
             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)
+        for src, target in self.i18n_map.items():
+            self.pms[name].norm = self.pms[name].norm.replace(src, target)
 
     def clear(self, name: str):
         self.pms[name].norm = self.pms[name].norm.replace("()", "").replace("  ", " ").strip(" -:.	")

{xync_client-0.0.94.dev0 → xync_client-0.0.95.dev0/xync_client.egg-info}/PKG-INFO

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