xync-client 0.0.164__py3-none-any.whl → 0.0.172__py3-none-any.whl

xync_client/Bybit/{InAgent.py → inAgent.py}

@@ -1,7 +1,7 @@
 from asyncio import create_task
-from bybit_p2p import P2P
 from pyro_client.client.file import FileClient
 from xync_bot import XyncBot
+from xync_client.Abc.InAgent import BaseInAgentClient
 from xync_schema.models import Agent
 
 from xync_client.Bybit.agent import AgentClient
@@ -9,16 +9,11 @@ from xync_client.Bybit.ex import ExClient
 
 from xync_schema import models
 
-from xync_client.Bybit.etype.order import (
-    OrderItem,
-)
+from xync_client.Bybit.etype.order import OrderItem
 
 
-class InAgentClient(AgentClient):
-    actor: models.Actor
-    agent: models.Agent
-    api: P2P
-    ex_client: ExClient
+class InAgentClient(BaseInAgentClient):
+    agent_client: AgentClient
 
     orders: dict[int, models.Order] = {}
 
@@ -33,4 +28,4 @@ class InAgentClient(AgentClient):
         self.orders = {o.exid: o for o in await models.Order.filter(exid__in=po.keys())}
         for oid in po.keys() - self.orders.keys():
             fo = self.api.get_order_details(orderId=oid)
-            self.orders[oid] = await self.create_order_db(fo)
+            self.orders[oid] = await self.order_save(fo)

xync_client/Bybit/order.py

@@ -1,28 +1,45 @@
-from xync_client.Bybit.etype.cred import PaymentTerm
-from xync_schema.models import CredEx, PmEx
+from asyncio import sleep
+
+from bybit_p2p._exceptions import FailedRequestError
+from xync_client.Bybit.agent import AgentClient
 
 from xync_client.Abc.Order import BaseOrderClient
 
 
 class OrderClient(BaseOrderClient):
-    # 5: Перевод сделки в состояние "оплачено", c отправкой чека
-    async def mark_payed(self, payterm: PaymentTerm = None, receipt: bytes = None):
-        if payterm:
-            pt = str(payterm.paymentType)
-            pid = payterm.id
-        else:
-            pmx = await PmEx.get(pm__pmcurs__id=self.order.cred.pmcur_id, ex=self.agent_client.ex_client.ex)
-            pt = pmx.exid
-            cdx = await CredEx.get(cred_id=self.order.cred_id, ex=self.agent_client.ex_client.ex)
-            pid = str(cdx.exid)
-        self.agent_client.api.mark_as_paid(orderId=str(self.order.exid), paymentType=pt, paymentId=pid)
+    agent_client: AgentClient
 
-    # 6: Отмена одобренной сделки
-    async def cancel_order(self) -> bool: ...
+    # 5: Перевод сделки в состояние "оплачено", c отправкой чека
+    async def _mark_payed(self, credex_exid: int = None, pmex_exid: int | str = None, receipt: bytes = None):
+        params = dict(orderId=str(self.order.exid), paymentType=str(pmex_exid), paymentId=str(credex_exid))
+        try:
+            self.agent_client.api.mark_as_paid(**params)
+        except FailedRequestError as e:
+            if e.status_code == 912100202:  # Server error, please try again later
+                await sleep(5, self.agent_client.api.mark_as_paid(**params))
+            else:
+                raise e
 
     # 7: Подтвердить получение оплаты
     async def confirm(self):
-        self.agent_client.api.release_assets(orderId=str(self.order.exid))
+        try:
+            self.agent_client.api.release_assets(orderId=str(self.order.exid))
+        except FailedRequestError as e:
+            if e.status_code == 912100202:  # Server error, please try again later
+                await sleep(5, self.agent_client.api.release_assets(orderId=str(self.order.exid)))
+            else:
+                raise e
+
+    # 6: Отмена одобренной сделки
+    async def cancel(self) -> bool: ...
+
+    # 6: Запрос отмены (оплаченная контрагентом продажа)
+    async def cancel_request(self) -> bool: ...
+
+    # 6: Одобрение запроса на отмену (оплаченная мной покупка)
+    async def cancel_accept(self):
+        data = {"orderId": self.order.exid, "examineResult": "PASS"}
+        await self.agent_client._post("/x-api/fiat/otc/order/buyer/examine/sellerCancelOrderApply", data)
 
     # 9, 10: Подать аппеляцию cо скриншотом/видео/файлом
     async def start_appeal(self, file) -> bool: ...

xync_client/Htx/agent.py

@@ -9,7 +9,7 @@ from x_client import df_hdrs
 from x_client.aiohttp import Client
 from xync_bot import XyncBot
 
-from xync_client.Abc.xtype import AdUpd, GetAds
+from xync_client.Abc.xtype import AdUpdReq, GetAdsReq
 from xync_client.Htx.etype.order import OrderItem, OrderFull
 from xync_client.loader import NET_TOKEN, PAY_TOKEN, TORM
 
@@ -47,9 +47,9 @@ class AgentClient(BaseAgentClient):
                 await self.agent.save(update_fields=["auth"])
                 self.session.headers["Token"] = resp["data"]
 
-    async def creds(self) -> list[test.CredEpyd]:
+    async def get_creds(self) -> list[test.BaseCredEpyd]:
         resp = await self._get("/-/x/otc/v1/user/receipt-account")
-        return [test.CredEpyd(**cred) for cred in resp["data"]]
+        return [test.BaseCredEpyd(**cred) for cred in resp["data"]]
 
     async def cred_del(self, cred_id: int) -> int:
         data = {"id": str(cred_id), "password": self.actor.agent.auth["password"]}
@@ -161,7 +161,7 @@ class AgentClient(BaseAgentClient):
     async def fiat_del(self, fiat_id: int) -> bool:
         pass
 
-    async def my_ads(self) -> list[dict]:
+    async def get_my_ads(self) -> list[dict]:
         res = await self._get(url_my_ads)
         ads: [] = res["data"]
         if (pages := res["totalPage"]) > 1:
@@ -184,7 +184,7 @@ class AgentClient(BaseAgentClient):
     ) -> models.Ad:
         pass
 
-    async def x2e_req_ad_upd(self, xreq: AdUpd) -> ad.AdsUpd:
+    async def x2e_req_ad_upd(self, xreq: AdUpdReq) -> ad.AdsUpd:
         creds = [
             ad.TradeRule(
                 content="Payment method-%s",
@@ -331,10 +331,10 @@ async def _test():
     # _ = await cl.cred_del(16984748)
 
     while True:
-        breq = GetAds(coin_id=1, cur_id=1, is_sell=False, pm_ids=[366])
-        sreq = GetAds(coin_id=1, cur_id=1, is_sell=True, pm_ids=[366])
-        breq_upd = AdUpd(id=1185713, price=87.01, **{**breq.model_dump(), "amount": 100000.01})
-        sreq_upd = AdUpd(id=1188929, price=98.99, **{**sreq.model_dump(), "amount": 200000.01})
+        breq = GetAdsReq(coin_id=1, cur_id=1, is_sell=False, pm_ids=[366])
+        sreq = GetAdsReq(coin_id=1, cur_id=1, is_sell=True, pm_ids=[366])
+        breq_upd = AdUpdReq(id=1185713, price=87.01, **{**breq.model_dump(), "amount": 100000.01})
+        sreq_upd = AdUpdReq(id=1188929, price=98.99, **{**sreq.model_dump(), "amount": 200000.01})
 
         bads: list[ad.Resp] = await cl.ex_client.ads(breq)
         sads: list[ad.Resp] = await cl.ex_client.ads(sreq)

xync_client/Htx/etype/ad.py

@@ -1,9 +1,7 @@
 from typing import Literal
-
 from pydantic import BaseModel, RootModel
-from xync_schema.xtype import BaseAd
 
-from xync_client.Abc.xtype import BaseAdUpdate
+from xync_client.Abc.xtype import BaseAd
 
 
 class TradeRule(BaseModel):
@@ -21,7 +19,7 @@ class TradeRule(BaseModel):
 TradeRulesV2 = RootModel[list[TradeRule]]
 
 
-class AdsUpd(BaseAdUpdate):
+class AdsUpd(BaseAd):
     tradeType: int
     coinId: int
     currency: int

xync_client/Htx/etype/test.py

@@ -1,5 +1,5 @@
 from pydantic import BaseModel, Field
-from xync_client.Abc.xtype import CredExOut
+from xync_client.Abc.xtype import BaseCredEx
 
 
 class ModelField(BaseModel):
@@ -15,7 +15,7 @@ class ModelField(BaseModel):
     value: str | None
 
 
-class CredEpyd(CredExOut):
+class BaseCredEpyd(BaseCredEx):
     id: int
     uid: int
     userName: str
@@ -34,13 +34,13 @@ class CredEpyd(CredExOut):
     payMethodName: str
 
 
-class CredExId(CredExOut):
+class BaseCredExId(BaseCredEx):
     id: int = Field(validation_alias="bankId")
 
 
 class Result(BaseModel):
     code: int
-    data: CredExId
+    data: BaseCredExId
     extend: str | None = None
     message: str
     success: bool

xync_client/Htx/ex.py

@@ -9,7 +9,7 @@ from xync_schema.models import Ex, Cur
 from xync_schema.enums import PmType
 
 from xync_client.Abc.Ex import BaseExClient
-from xync_client.Abc.xtype import PmEx, MapOfIdsList, GetAds
+from xync_client.Abc.xtype import PmEx, MapOfIdsList, GetAdsReq
 from xync_client.Htx.etype import pm, Country, ad
 from xync_client.loader import NET_TOKEN
 from xync_client.loader import TORM
@@ -42,7 +42,7 @@ class ExClient(BaseExClient):
                         pair[rcurs[cur["name"]]] += [coen]
         return tuple(pairs.values())
 
-    async def x2e_req_ads(self, xreq: GetAds) -> ad.AdsReq:
+    async def x2e_req_ads(self, xreq: GetAdsReq) -> ad.AdsReq:
         coin_id, _ = await self.x2e_coin(xreq.coin_id)
         cur_id, _, __ = await self.x2e_cur(xreq.cur_id)
         ereq = ad.AdsReq(
@@ -106,7 +106,39 @@ class ExClient(BaseExClient):
     # 22: Список платежных методов по каждой валюте
     async def cur_pms_map(self) -> dict[int, set[int]]:
         res = await self.data
-        wrong_pms = {4, 34, 498, 548, 20009, 20010}  # , 212, 239, 363  # these ids not exist in pms
+        wrong_pms = {
+            4,
+            34,
+            498,
+            548,
+            20009,
+            20010,
+            10015,
+            20005,
+            20008,
+            10000,
+            10001,
+            10002,
+            10004,
+            20001,
+            20002,
+            20003,
+            20004,
+            20005,
+            20006,
+            20007,
+            10003,
+            10005,
+            10006,
+            10007,
+            10008,
+            10009,
+            10010,
+            10011,
+            10012,
+            10013,
+            10014,
+        }  # , 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: Список торгуемых монет

xync_client/Mexc/agent.py

@@ -13,7 +13,7 @@ from xync_bot import XyncBot
 from xync_client.Mexc.api import MEXCP2PApiClient
 from xync_client.Mexc.etype import ad
 
-from xync_client.Abc.xtype import GetAds, AdUpd
+from xync_client.Abc.xtype import GetAdsReq, AdUpdReq
 from xync_client.Bybit.etype.order import TakeAdReq
 from xync_client.Mexc.etype.order import OrderDetail
 
@@ -114,7 +114,7 @@ class AgentClient(BaseAgentClient):
         res = await self._post("/api/platform/p2p/api/order/deal?mhash=" + auth["mhash"], data=auth | data, hdrs=hdrs)
         return res["data"]
 
-    async def x2e_req_ad_upd(self, xreq: AdUpd) -> ad.AdUpd:
+    async def x2e_req_ad_upd(self, xreq: AdUpdReq) -> ad.AdUpd:
         coin_id, coin_scale = await self.ex_client.x2e_coin(xreq.coin_id)
         cur_id, cur_scale, minimum = await self.ex_client.x2e_cur(xreq.cur_id)
         ereq = ad.AdUpd(
@@ -170,12 +170,12 @@ async def main():
     while True:
         bceil = 106
         sceil = 124.98
-        breq = GetAds(coin_id=1, cur_id=1, is_sell=False, pm_ids=[366])
-        sreq = GetAds(coin_id=1, cur_id=1, is_sell=True, pm_ids=[366])
-        breq_upd = AdUpd(
+        breq = GetAdsReq(coin_id=1, cur_id=1, is_sell=False, pm_ids=[366])
+        sreq = GetAdsReq(coin_id=1, cur_id=1, is_sell=True, pm_ids=[366])
+        breq_upd = AdUpdReq(
             id="a1574183931501582340", price=87, **{**breq.model_dump(), "amount": 11000.01}, max_amount=4370
         )  # + 1 cent
-        sreq_upd = AdUpd(id="a1594624084590445568", price=150, **{**sreq.model_dump(), "amount": 30000.01})
+        sreq_upd = AdUpdReq(id="a1594624084590445568", price=150, **{**sreq.model_dump(), "amount": 30000.01})
 
         await sleep(5)
         bads: list[ad.Ad] = await cl.ex_client.ads(breq)

xync_client/Mexc/ex.py

@@ -6,7 +6,7 @@ import requests
 from xync_client.loader import TORM, NET_TOKEN
 
 from xync_client.Abc.Ex import BaseExClient
-from xync_client.Abc.xtype import PmEx, MapOfIdsList, GetAds
+from xync_client.Abc.xtype import PmEx, MapOfIdsList, GetAdsReq
 from xync_client.Mexc.etype import pm, ad
 
 from xync_schema import xtype
@@ -77,7 +77,7 @@ class ExClient(BaseExClient):
                 self.pm_x2e[xid] = (await models.PmEx.get(**fltr)).exid
         return self.pm_x2e[xid]
 
-    async def x2e_req_ads(self, xreq: GetAds) -> ad.AdsReq:
+    async def x2e_req_ads(self, xreq: GetAdsReq) -> ad.AdsReq:
         coin_id, _ = await self.x2e_coin(xreq.coin_id)
         cur_id, _, __ = await self.x2e_cur(xreq.cur_id)
         ereq = ad.AdsReq(

xync_client/TgWallet/agent.py

@@ -10,7 +10,7 @@ from xync_client.TgWallet.ex import ExClient
 from xync_schema import models
 
 from xync_client.TgWallet.pyd import (
-    CredEpyd,
+    BaseCredEpyd,
     Attrs,
     AttrsV2,
     OneAdTakerMakerSale,
@@ -36,7 +36,7 @@ from xync_schema.enums import AdStatus, UserStatus, OrderStatus
 
 from xync_client.Abc.Base import ListOfDicts
 from xync_client.TgWallet.auth import AuthClient
-from xync_schema.xtype import BaseAdIn, AdBuyIn, AdSaleIn, OrderIn
+from xync_schema.xtype import BaseAd, AdBuy, AdSale, OrderIn
 
 from xync_client.Abc.Agent import BaseAgentClient
 
@@ -110,21 +110,21 @@ class AgentClient(BaseAgentClient, AuthClient):
             offerId=base_req.ad_id, type="SALE" if base_req.is_sell else "BUY", paymentDetailsId=credex.exid
         )
         ad = await models.Ad.get(exid=base_req.ad_id).prefetch_related(
-            "direction__pairex__pair__cur" if base_req.fiat_amount else "direction__pairex__pair__coin"
+            "direction__pairex__pair__cur" if base_req.amount else "direction__pairex__pair__coin"
         )
         amount = AvailableAmountVolume(
             currencyCode=ad.direction.pairex.pair.cur.ticker
-            if base_req.fiat_amount
+            if base_req.amount
             else ad.direction.pairex.pair.coin.ticker,
-            amount=str(base_req.fiat_amount if base_req.fiat_amount else base_req.asset_amount),
+            amount=str(base_req.amount if base_req.amount else base_req.quantity),
         )
         req = (
             OrderAmountReq(**common.model_dump(), amount=amount)
-            if base_req.fiat_amount
+            if base_req.amount
             else OrderVolumeReq(**common.model_dump(), volume=amount)
         )
         request = await self._post(
-            f"/p2p/public-api/v2/offer/order/create-by-{'amount' if base_req.fiat_amount else 'volume'}",
+            f"/p2p/public-api/v2/offer/order/create-by-{'amount' if base_req.amount else 'volume'}",
             req.model_dump(exclude_none=True),
         )
         if r := request.get("data"):
@@ -170,8 +170,8 @@ class AgentClient(BaseAgentClient, AuthClient):
 
     # # # CREDS # # #
     @staticmethod
-    def fiat_args2ex_pyd(exid: int | str, cur: str, detail: str, name: str, typ: str, extra=None) -> CredEpyd:
-        cred = CredEpyd(
+    def fiat_args2ex_pyd(exid: int | str, cur: str, detail: str, name: str, typ: str, extra=None) -> BaseCredEpyd:
+        cred = BaseCredEpyd(
             paymentMethodCode=exid,
             currencyCode=cur,
             name=name,
@@ -201,11 +201,11 @@ class AgentClient(BaseAgentClient, AuthClient):
         }
 
     # 25: Список реквизитов моих платежных методов
-    async def creds(self) -> list[CredEpyd]:
+    async def get_creds(self) -> list[BaseCredEpyd]:
         resp = await self._post("/p2p/public-api/v3/payment-details/get/by-user-id")
-        return [CredEpyd(**cred) for cred in resp["data"]]
+        return [BaseCredEpyd(**cred) for cred in resp["data"]]
 
-    async def cred_epyd2db(self, cred: CredEpyd) -> models.CredEx:
+    async def cred_epyd2db(self, cred: BaseCredEpyd) -> 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)):
@@ -229,8 +229,8 @@ class AgentClient(BaseAgentClient, AuthClient):
         return credex_db
 
     # 25: Список реквизитов моих платежных методов
-    async def set_creds(self) -> list[models.CredEx]:
-        creds_epyd: list[CredEpyd] = await self.creds()
+    async def load_creds(self) -> list[models.CredEx]:
+        creds_epyd: list[BaseCredEpyd] = await self.creds()
         credexs: list[models.CredEx] = [await self.cred_epyd2db(f) for f in creds_epyd]
         return credexs
 
@@ -272,7 +272,7 @@ class AgentClient(BaseAgentClient, AuthClient):
         else:
             hdrs = {}
         add_cred = await self._post("/p2p/public-api/v3/payment-details/create", cred_new, headers=hdrs)
-        cred_epyd = CredEpyd(**add_cred["data"])
+        cred_epyd = BaseCredEpyd(**add_cred["data"])
         return await self.cred_epyd2db(cred_epyd)
 
     # 27: Редактирование реквизита моего платежного метода
@@ -298,7 +298,7 @@ class AgentClient(BaseAgentClient, AuthClient):
             "x-wallet-device-serial": self.actor.agent.auth["ds"],
         }
         edit_cred = await self._post("/p2p/public-api/v3/payment-details/edit", cred_upd, headers=hdrs)
-        cred_epyd = CredEpyd(**edit_cred["data"])
+        cred_epyd = BaseCredEpyd(**edit_cred["data"])
         return await self.cred_epyd2db(cred_epyd)
 
     # 28: Удаление реквизита моего платежного метода
@@ -310,19 +310,19 @@ class AgentClient(BaseAgentClient, AuthClient):
         else:
             logging.error(res)
 
-    async def ad_epyd2pydin(self, ad_: OneAdTakerMakerSale | OneAdMakerBuy | OneAdTakerBuy) -> AdBuyIn | AdSaleIn:
-        ad_in: BaseAdIn = await self.ex_client.ad_common_epyd2pydin(ad_)
+    async def ad_epyd2pydin(self, ad_: OneAdTakerMakerSale | OneAdMakerBuy | OneAdTakerBuy) -> AdBuy | AdSale:
+        ad_in: BaseAd = await self.ex_client.ad_common_epyd2pydin(ad_)
         ad_in.maker_id = self.actor.id
         if isinstance(ad_, _PmsTrait):
-            return AdBuyIn(
+            return AdBuy(
                 **ad_in.model_dump(),
                 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)
+        return AdSale(**ad_in.model_dump(), credexs_=credsexs)
 
     # 29: Список моих объявлений
-    async def my_ads(self, status: AdStatus = None) -> list[AdMakerBuy | AdMakerSale]:
+    async def get_my_ads(self, status: AdStatus = None) -> list[AdMakerBuy | AdMakerSale]:
         def model(ad: dict) -> (AdMakerBuy | AdMakerSale).__class__:
             return AdMakerSale if ad["type"] == "SALE" else AdMakerBuy
 

xync_client/TgWallet/ex.py

@@ -4,7 +4,7 @@ from pyro_client.client.file import FileClient
 from x_model import init_db
 from xync_schema import xtype
 from xync_schema import models
-from xync_schema.xtype import AdBuyIn
+from xync_schema.xtype import AdBuy
 
 from xync_client.Abc.xtype import PmEx
 from xync_client.TgWallet.pyd import (
@@ -124,30 +124,30 @@ class ExClient(BaseExClient, AuthClient):
         ads = await self._post("/p2p/public-api/v2/offer/depth-of-market/", params, "data")
         return [AdTakerSaleBuy(**ad) for ad in ads]
 
-    async def ad_common_epyd2pydin(self, ad: _BaseAd) -> xtype.BaseAdIn:
+    async def ad_common_epyd2pydin(self, ad: _BaseAd) -> xtype.BaseAd:
         coin = await models.Coin.get_or_create_by_name(ad.price.baseCurrencyCode)
         cur = await models.Cur.get_or_create_by_name(ad.price.quoteCurrencyCode)
         pair, _ = await models.Pair.get_or_create(coin=coin, cur=cur)
         pairex, _ = await models.PairEx.get_or_create(pair=pair, ex=self.ex)
         dr, _ = await models.Direction.get_or_create(pairex=pairex, sell=ad.is_sell)
-        return xtype.BaseAdIn(
+        return xtype.BaseAd(
             id=ad.id,
             price=ad.price.value,
             min_fiat=ad.orderAmountLimits.min,
             amount=float(ad.availableVolume.amount) * float(ad.price.estimated),
             max_fiat=ad.orderAmountLimits.max,
-            direction_id=dr.id,
+            pair_side_id=dr.id,
             detail=getattr(ad, "comment", None),
         )
 
-    async def ad_taker_epyd2pydin(self, ad: _TakerOne) -> xtype.AdBuyIn:
-        adx: xtype.BaseAdIn = await self.ad_common_epyd2pydin(ad)
+    async def ad_taker_epyd2pydin(self, ad: _TakerOne) -> xtype.AdBuy:
+        adx: xtype.BaseAd = await self.ad_common_epyd2pydin(ad)
         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 xtype.AdBuyIn(
+        return xtype.AdBuy(
             **adx.model_dump(by_alias=True),
             pms_=await models.Pm.filter(pmexs__ex=self.ex, pmexs__exid__in=[p.code for p in pms]),
         )
@@ -167,14 +167,14 @@ async def _test():
         # get ads list
         ads: list[AdTakerSaleBuy] = await cl.ads("TON", "RUB", True)
         # prepare ad list items for saving
-        ads_pydin: list[xtype.BaseAdIn] = [await cl.ad_taker_epyd2pydin(adp) for adp in ads]
+        ads_pydin: list[xtype.BaseAd] = [await cl.ad_taker_epyd2pydin(adp) for adp in ads]
         # list items save
         _ads_db = [await cl.ad_pydin2db(adi) for adi in ads_pydin]
 
         # get ad fulls
         ads_pyd: list[_TakerOne] = [await cl.ad(ad.exid) for ad in ads]
         # prepare ad fulls for saving
-        ads_pydin: list[AdBuyIn] = [await cl.ad_taker_epyd2pydin(adp) for adp in ads_pyd]
+        ads_pydin: list[AdBuy] = [await cl.ad_taker_epyd2pydin(adp) for adp in ads_pyd]
         # full ones save
         _ads_db = [await sleep(0.1, await cl.ad_pydin2db(adi)) for adi in ads_pydin]
 
@@ -182,14 +182,14 @@ async def _test():
         # get ads list
         ads: list[AdTakerSaleBuy] = await cl.ads("TON", "RUB", False)
         # prepare ad list items for saving
-        ads_pydin: list[xtype.BaseAdIn] = [await cl.ad_taker_epyd2pydin(adp) for adp in ads]
+        ads_pydin: list[xtype.BaseAd] = [await cl.ad_taker_epyd2pydin(adp) for adp in ads]
         # list items save
         _ads_db = [await cl.ad_pydin2db(adi) for adi in ads_pydin]
 
         # get ad fulls
         ads_pyd = [await cl.ad(ad.exid) for ad in ads]
         # prepare ad fulls for saving
-        ads_pydin: list[AdBuyIn] = [await cl.ad_taker_epyd2pydin(adp) for adp in ads_pyd]
+        ads_pydin: list[AdBuy] = [await cl.ad_taker_epyd2pydin(adp) for adp in ads_pyd]
         # full ones save
         _ads_db = [await cl.ad_pydin2db(adi) for adi in ads_pydin]
 

xync_client/TgWallet/pyd.py

@@ -2,7 +2,7 @@ from typing import Literal
 from pydantic import BaseModel, computed_field
 from xync_schema.xtype import BaseAd
 
-from xync_client.Abc.xtype import CredExOut
+from xync_client.Abc.xtype import BaseCredEx
 
 
 # Модели для вложенных структур
@@ -126,7 +126,7 @@ class CredEpydUpd(CredEpydNew):
     id: int
 
 
-class CredEpyd(CredExOut):
+class BaseCredEpyd(BaseCredEx):
     id: int
     userId: int
     paymentMethod: PmEpydRoot
@@ -194,7 +194,7 @@ class AdTakerSaleBuy(_BaseAd, _PmsTrait, _UserTrait):
 
 
 class OneAdTakerMakerSale(_TakerOne):
-    paymentDetails: list[CredEpyd]
+    paymentDetails: list[BaseCredEpyd]
     fee: Fee
 
 
@@ -208,7 +208,7 @@ class OneAdMakerBuy(_BaseAd, _OneTrait, _PmsTrait): ...
 
 
 class AdMakerSale(_BaseAd, _StatusTrait):
-    paymentDetails: list[CredEpyd]
+    paymentDetails: list[BaseCredEpyd]
 
 
 # # #
@@ -278,7 +278,7 @@ class OrderEpyd(BaseModel):
     offerType: AdType
     isExpress: bool
     price: Price
-    paymentDetails: CredEpyd
+    paymentDetails: BaseCredEpyd
     volume: AvailableAmountVolume
     amount: AvailableAmountVolume
     feeVolume: AvailableAmountVolume

xync_client/pm_unifier.py

@@ -17,7 +17,7 @@ class PmUnifier:
     pms: dict[str, PmUni] = {}  # {origin: normalized}
 
     re_bank = [
-        r"^bank (?!(of |transfer))|(?<!(to|the)\s) bank$",
+        r"^bank (?!(of |transfer))|(?<!( to|the)\s) bank$",
         r" banka$",
         r" bankas$",
         r" bankasi$",
@@ -124,7 +124,8 @@ class PmUnifier:
 
     def bank(self, name: str):
         for r in self.re_bank:
-            if (match := re.search(r, self.pms[name].norm)) and match.group() != self.pms[name].norm:
+            match = re.search(r, self.pms[name].norm)
+            if match and match.group() != self.pms[name].norm:
                 self.pms[name].norm = self.pms[name].norm.replace(match.group(), "")
                 self.pms[name].bank = True
                 self.clear(name)

{xync_client-0.0.164.dist-info → xync_client-0.0.172.dist-info}/METADATA

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