xync-client 0.0.25.dev47__tar.gz → 0.0.25.dev50__tar.gz

{xync_client-0.0.25.dev47/xync_client.egg-info → xync_client-0.0.25.dev50}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: xync-client
-Version: 0.0.25.dev47
+Version: 0.0.25.dev50
 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.dev47 → xync_client-0.0.25.dev50}/xync_client/Abc/Ex.py

@@ -13,6 +13,8 @@ from xync_client.pm_unifier import PmUnifier, PmUni
 
 
 class BaseExClient(BaseClient):
+    unifier_class: type = PmUnifier
+
     @abstractmethod
     def pm_type_map(self, typ: models.Pmex) -> str: ...
 
@@ -86,6 +88,7 @@ class BaseExClient(BaseClient):
             if c.cur_id not in curs:
                 cur, _ = await models.Cur.get_or_create(ticker=cur_map[c.cur_id])
                 c.cur_id = cur.id
+            c.cur_id = curs[c.cur_id].id
         # Country preparing
         # countries = sorted(
         #     (c for c in countries if c.code not in (999, 9999, 441624, 999999)), key=lambda x: x.name
@@ -124,7 +127,7 @@ class BaseExClient(BaseClient):
         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)
+        uni = self.unifier_class(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

xync_client-0.0.25.dev47/xync_client/BingX/pyd.py → xync_client-0.0.25.dev50/xync_client/BingX/etype/ad.py

@@ -3,37 +3,6 @@ from typing import List
 from xync_schema.types import BaseAd
 
 
-class User(BaseModel):
-    nickname: str
-    avatar: str
-    phone: bool
-    email: bool
-    # payMethods: dict
-
-
-class AvailableVolume(BaseModel):
-    tradeUSDTNum30: float
-
-
-class Price(BaseModel):
-    asset: str
-    fiat: str
-    value: str
-
-
-class OrderLimitsIn(BaseModel):
-    minAmount: str
-    maxAmount: str
-
-
-class PmEpyd(BaseModel):
-    id: int
-    name: str
-    mainColor: str
-    icon: str
-    number: int
-
-
 class UserPaymentMethod(BaseModel):
     id: int
     paymentMethodId: int
@@ -91,4 +60,4 @@ class Ad(BaseAd):
     merchantKycType: int
     merchantVerificationType: int
     isUserMatchCondition: bool
-    notMatchConditionReason: str
+    notMatchConditionReason: str

xync_client-0.0.25.dev50/xync_client/BingX/etype/pm.py

@@ -0,0 +1,8 @@
+from pydantic import BaseModel
+
+class PmE(BaseModel):
+    id: int
+    name: str
+    mainColor: str
+    icon: str
+    number: int

{xync_client-0.0.25.dev47 → xync_client-0.0.25.dev50}/xync_client/BingX/ex.py

@@ -3,23 +3,30 @@ from asyncio import run
 from x_model import init_db
 from xync_schema import models
 from xync_schema.models import Ex
-from xync_schema.types import CurEx, CoinEx
+from xync_schema import types
 
 from xync_client.Abc.Ex import BaseExClient
-from xync_client.Abc.types import PmEx
 from xync_client.BingX.base import BaseBingXClient
 from xync_client.loader import PG_DSN
 from xync_client.Abc.Base import MapOfIdsList
-from xync_client.BingX.pyd import PmEpyd, Ad
+from xync_client.BingX.etype import ad, pm
+from xync_client.Abc.types import PmEx
+from xync_client.pm_unifier import PmUnifier
 
 
 class ExClient(BaseExClient, BaseBingXClient):
+    class BingUnifier(PmUnifier):
+        pm_map = {
+            "СБП": "SBP",
+        }
+
+    unifier_class = BingUnifier
     headers: dict[str, str] = {
         "accept": "application/json, text/plain, */*",
         "accept-language": "ru-RU,ru;q=0.9,en-US;q=0.8,en;q=0.7",
         "app_version": "9.0.5",
         "device_id": "ccfb6d50-b63b-11ef-b31f-ef1f76f67c4e",
-        "lang": "ru-RU",
+        "lang": "en",
         "platformid": "30",
         "device_brand": "Linux_Chrome_131.0.0.0",
         "sec-ch-ua": '"Google Chrome";v="131", "Chromium";v="131", "Not_A Brand";v="24"',
@@ -27,47 +34,48 @@ class ExClient(BaseExClient, BaseBingXClient):
         "x-requested-with": "XMLHttpRequest",
     }
 
-    async def _pms(self, cur) -> list[PmEpyd]:
+    async def _pms(self, cur) -> list[pm.PmE]:
         pms = await self._get("/api/c2c/v1/advert/payment/list", params={"fiat": cur})
-        return [PmEpyd(**pm) for pm in pms["data"]["paymentMethodList"]]
+        return [pm.PmE(**_pm) for _pm in pms["data"]["paymentMethodList"]]
 
     # 19: Список всех платежных методов на бирже
-    async def pms(self, cur: str = None) -> dict[int, PmEx]:
+    async def pms(self, cur: str = None) -> dict[int | str, PmEx]:
         all_pms = {}
-        for cur in await self.curs():
+        for cur in (await self.curs()).values():
             pms = await self._pms(cur.ticker)
-            for pm in pms:
-                all_pms[pm.id] = PmEx(id=pm.id, name=pm.name, logo=pm.icon)
+            for p in pms:
+                all_pms[p.id] = PmEx(exid=p.id, name=p.name, logo=p.icon)
         return all_pms
 
     # 20: Список поддерживаемых валют на BingX
-    async def curs(self) -> list[CurEx]:  # {cur.exid: cur.ticker}
+    async def curs(self) -> list[types.CurEx]:  # {cur.exid: cur.ticker}
         params = {
             "type": "1",
             "asset": "USDT",
             "coinType": "2",
         }
         curs = await self._get("/api/c2c/v1/common/supportCoins", params=params)
-        return [CurEx(exid=cur["id"], ticker=cur["name"]) for cur in curs["data"]["coins"]]
+        return {cur["name"]: types.CurEx(exid=cur["id"], ticker=cur["name"]) for cur in curs["data"]["coins"]}
 
     # 21: cur_pms_map на BingX
     async def cur_pms_map(self) -> MapOfIdsList:
-        return {cur.ticker: [pm.id for pm in await self._pms(cur.ticker)] for cur in await self.curs()}
+        return {cur.exid: [pm.id for pm in await self._pms(cur.ticker)] for cur in (await self.curs()).values()}
 
     # 22: Монеты на BingX
-    async def coins(self) -> list[CoinEx]:
-        return [CoinEx(exid="1", ticker="USDT")]
+    async def coins(self) -> list[types.CoinEx]:
+        return {"USDT": types.CoinEx(exid="1", ticker="USDT")}
 
     # 23: Список пар валюта/монет
     async def pairs(self) -> MapOfIdsList:
-        coins = await self.coins()
-        curs = await self.curs()
-        return {cur.ticker: set(c.ticker for c in coins) for cur in curs}
+        coins = (await self.coins()).keys()
+        curs = (await self.curs()).keys()
+        p = {cur: {c for c in coins} for cur in curs}
+        return p, p
 
     # 24: ads
     async def ads(
         self, coin_exid: str, cur_exid: str, is_sell: bool, pm_exids: list[str | int] = None, amount: int = None
-    ) -> list[Ad]:
+    ) -> list[ad.Ad]:
         params = {
             "type": 1,
             "fiat": cur_exid,
@@ -79,14 +87,21 @@ class ExClient(BaseExClient, BaseBingXClient):
         }
 
         ads = await self._get("/api/c2c/v1/advert/list", params=params)
-        return [Ad(**ad) for ad in ads["data"]["dataList"]]
+        return [ad.Ad(**ad) for ad in ads["data"]["dataList"]]
 
 
 async def main():
     _ = await init_db(PG_DSN, models, True)
     bg = await Ex.get(name="BingX")
     cl = ExClient(bg)
-    _ads = await cl.ads("USDT", "RUB", False)
+    await cl.set_coinexs()
+    await cl.set_pmcurexs()
+    # _curs = await cl.curs()
+    # _coins = await cl.coins()
+    # _pairs = await cl.pairs()
+    # _pms = await cl.pms("EUR")
+    # _pms_map = await cl.cur_pms_map()
+    # _ads = await cl.ads("USDT", "RUB", False)
     await cl.close()
 
 

{xync_client-0.0.25.dev47 → xync_client-0.0.25.dev50}/xync_client/Bybit/ex.py

@@ -4,6 +4,7 @@ from xync_schema.models import Cur
 
 from xync_client.Abc.Base import ListOfDicts, MapOfIdsList, DictOfDicts, FlatDict
 from xync_client.Abc.Ex import BaseExClient
+from xync_client.pm_unifier import PmUnifier
 
 
 class AdsStatus(IntEnum):
@@ -12,8 +13,20 @@ class AdsStatus(IntEnum):
 
 
 class ExClient(BaseExClient):  # Bybit client
+    class BybitUnifier(PmUnifier):
+        pm_map = {
+            "Local Bank (R-Green)": "Sberbank",
+            "Local Bank (S-Green)": "Sberbank",
+            "Local Card (Red)": "Alfa-Bank",
+            "Local Card (Yellow)": "T-Bank",
+            "Local Card M-redTS": "MTS-bank",
+            "Local Card-Green": "Sberbank",
+            "Local Card-Yellow": "T-Bank",
+        }
+
     host = "api2.bybit.com"
     headers = {"cookie": ";"}  # rewrite token for public methods
+    unifier_class = BybitUnifier
 
     async def _get_config(self):
         resp = await self._get("/fiat/p2p/config/initial")
@@ -57,7 +70,9 @@ class ExClient(BaseExClient):  # Bybit client
         return cc
 
     # 24: Список объяв по (buy/sell, cur, coin, pm)
-    async def ads(self, coin_exid: str, cur_exid: str, is_sell: bool, pm_exids: list[str | int] = None, amount: int = None) -> ListOfDicts:
+    async def ads(
+        self, coin_exid: str, cur_exid: str, is_sell: bool, pm_exids: list[str | int] = None, amount: int = None
+    ) -> ListOfDicts:
         data = {
             "userId": "",
             "tokenId": coin_exid,

{xync_client-0.0.25.dev47 → xync_client-0.0.25.dev50}/xync_client/Htx/ex.py

@@ -11,9 +11,17 @@ from xync_client.Abc.Ex import BaseExClient
 from xync_client.Abc.types import PmEx
 from xync_client.Htx.etype import pm, Country, ad
 from xync_client.loader import PG_DSN
+from xync_client.pm_unifier import PmUnifier
 
 
 class ExClient(BaseExClient):
+    class BingUnifier(PmUnifier):
+        pm_map = {
+            "SBP - Fast Bank Transfer": "SBP",
+        }
+
+    unifier_class = BingUnifier
+
     def pm_type_map(self, typ: models.Pmex) -> str:
         pass
 

xync_client-0.0.25.dev50/xync_client/KuCoin/etype/ad.py

@@ -0,0 +1,49 @@
+from pydantic import BaseModel, Field
+from typing import List, Optional
+
+class AdPayType(BaseModel):
+    id: str
+    bankName: Optional[str] = None
+    payTypeCode: str
+    payQrcodePic: Optional[str] = None
+    payTypeNumber: Optional[str] = None
+    subBranch: Optional[str] = None
+    reservedFields: Optional[str] = None
+
+class Ad(BaseModel):
+    id: str
+    side: str
+    legal: str
+    currency: str
+    currencyQuantity: str
+    currencyBalanceQuantity: str
+    premium: str
+    status: str
+    limitPrice: Optional[str] = None
+    floatPrice: str
+    limitMinQuote: str
+    limitMaxQuote: str
+    adPayTypes: List[AdPayType]
+    remarks: str
+    needKyc: str
+    nickName: str
+    showLetter: str
+    lastActiveTime: int
+    lastActiveDesc: str
+    lastActiveStatus: str
+    priceType: str
+    portraitURL: Optional[str] = None
+    displayStatus: str
+    kycLevel: int
+    tradeTimeLimit: int
+    updatedAt: int
+    goldMerchants: int
+    foxKingMerchants: int
+    adTarget: int
+    dealOrderNum: str
+    dealOrderRate: str
+    userId: str
+    tradeLimitTip: Optional[str] = None
+    opponentBalanceLimit: str
+    blackStatus: int
+    self: bool

xync_client-0.0.25.dev50/xync_client/KuCoin/etype/pm.py

@@ -0,0 +1,8 @@
+from pydantic import BaseModel
+
+
+class PmE(BaseModel):
+    legal: str
+    payTypeId: str
+    payTypeCode: str
+    payTypeName: str

xync_client-0.0.25.dev50/xync_client/KuCoin/ex.py

@@ -0,0 +1,75 @@
+from asyncio import run
+
+from x_model import init_db
+from xync_schema import models
+from xync_schema import types
+
+from xync_client.Abc.Base import MapOfIdsList
+from xync_client.Abc.Ex import BaseExClient
+from xync_client.loader import PG_DSN
+from xync_client.KuCoin.etype import pm, ad
+from xync_client.Abc.types import PmEx
+
+
+class ExClient(BaseExClient):
+    async def _pms(self, cur) -> list[pm.PmE]:
+        params = {
+            'legal': cur,
+            'lang': 'ru_RU',
+        }
+        pms = await self._get("/_api/otc/legal/payTypes", params=params)
+        return [pm.PmE(**_pm) for _pm in pms["data"]]
+
+    async def curs(self) -> list[types.CurEx]:
+        curs = (await self._get("/_api/otc/dictionary/getData", {"type": "LEGAL"}))["data"]
+        return {
+            cur["typeCode"]:types.CurEx(exid=cur["id"], ticker=cur["typeCode"]) for cur in curs
+        }
+
+    async def pms(self, cur: models.Cur = None) -> dict[int | str, PmEx]:
+        all_pms = {}
+        for cur_obj in (await self.curs()).values():
+            pms = await self._pms(cur_obj.ticker)
+            for pm in pms:
+                all_pms[pm.payTypeId] = PmEx(exid=pm.payTypeId, name=pm.payTypeName)
+        return all_pms
+
+    async def cur_pms_map(self) -> MapOfIdsList:
+        return {cur.exid: [pm.payTypeId for pm in await self._pms(cur.ticker)] for cur in (await self.curs()).values()}
+
+    async def coins(self) -> list[types.CoinEx]:
+        all_coins = {}
+        for cur in (await self.curs()).keys():
+            params = {
+                'legal': cur,
+                'lang': 'ru_RU',
+            }
+            coins = await self._get("/_api/otc/symbol/support", params=params)
+            for coin in coins["data"]:
+                all_coins[coin["currency"]] = types.CoinEx(exid=coin["currencyPrecision"] ,ticker=coin["currency"])
+        return all_coins
+
+    async def pairs(self) -> MapOfIdsList:
+        coins = (await self.coins()).keys()
+        curs = (await self.curs()).keys()
+        b = {cur: {c for c in coins} for cur in curs}
+        s = {cur: {c for c in coins} for cur in curs}
+        return s, b
+
+    async def ads(
+            self, coin_exid: str, cur_exid: str, is_sell: bool, pm_exids: list[str | int] = None, amount: int = None
+    ) -> list[ad.Ad]:
+        pass
+
+
+async def main():
+    _ = await init_db(PG_DSN, models, True)
+    bg = await Ex.get(name="KuCoin")
+    cl = ExClient(bg)
+    # await cl.curs()
+    # await cl.coins()
+    await cl.pms()
+
+
+if __name__ == "__main__":
+    run(main())

xync_client-0.0.25.dev47/xync_client/Okx/pyd.py → xync_client-0.0.25.dev50/xync_client/Okx/etype/ad.py

@@ -3,17 +3,6 @@ from typing import List, Optional
 from xync_schema.types import BaseAd
 
 
-class PmE(BaseModel):
-    fieldJson: list
-    instantSettlePayment: bool
-    mainColor: str
-    mostUsed: bool
-    needVerification: bool
-    paymentMethod: str
-    paymentMethodDescription: str
-    transferSpeed: int
-
-
 class PromoBadgeInfoVo(BaseModel):
     badgeList: List[str]
 

xync_client-0.0.25.dev50/xync_client/Okx/etype/pm.py

@@ -0,0 +1,12 @@
+from pydantic import BaseModel
+
+
+class PmE(BaseModel):
+    fieldJson: list
+    instantSettlePayment: bool
+    mainColor: str
+    mostUsed: bool
+    needVerification: bool
+    paymentMethod: str
+    paymentMethodDescription: str
+    transferSpeed: int

{xync_client-0.0.25.dev47 → xync_client-0.0.25.dev50}/xync_client/Okx/ex.py

@@ -7,50 +7,62 @@ from xync_schema import types
 from xync_client.Abc.Base import MapOfIdsList
 from xync_client.Abc.Ex import BaseExClient
 from xync_client.loader import PG_DSN
-from xync_client.Okx.pyd import PmE, Ads, Ad
-
+from xync_client.Okx.etype import ad, pm
+from xync_client.Abc.types import PmEx
 
 class ExClient(BaseExClient):
-    async def _pms(self, cur) -> list[PmE]:
+    async def _pms(self, cur) -> list[pm.PmE]:
         params = {
             "quoteCurrency": f"{cur}",
             "needField": "false",
         }
         pms = await self._get("/v3/c2c/configs/receipt/templates", params=params)
-        return [PmE(**pm) for pm in pms["data"]]
+        return [pm.PmE(**_pm) for _pm in pms["data"]]
 
     # 19: Список поддерживаемых валют тейкера
-    async def curs(self) -> list[types.CurE]:  # {cur.exid: cur.ticker}
+    async def curs(self) -> list[types.CurEx]:  # {cur.exid: cur.ticker}
         curs = await self._get("/v3/users/common/list/currencies")
-        return [types.CurE(exid=cur["currencyId"], ticker=cur["displayName"]) for cur in curs["data"]]
+        return {
+            cur["displayName"]: types.CurEx(exid=cur["currencyId"],ticker=cur["displayName"])
+            for cur in curs["data"]
+        }
 
     # 20: Список платежных методов
-    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, PmEx]:  # {pm.exid: pm}
         all_pms = {}
-        for cur in await self.curs():
-            pms = await self._pms(cur.ticker)
+        for cur_obj in (await self.curs()).values():
+            pms = await self._pms(cur_obj.ticker)
             for pm in pms:
-                all_pms[pm.transferSpeed] = types.Pm(name=pm.paymentMethod)
+                all_pms[pm.transferSpeed] = PmEx(exid=pm.transferSpeed, name=pm.paymentMethod)
         return all_pms
 
     # 21: Список платежных методов по каждой валюте
     async def cur_pms_map(self) -> MapOfIdsList:  # {cur.exid: [pm.exid]}
-        return {cur.ticker: [pm.paymentMethod for pm in await self._pms(cur.ticker)] for cur in await self.curs()}
+        return {cur.exid: [pm.paymentMethod for pm in await self._pms(cur.ticker)] for cur in (await self.curs()).values()}
 
     # 22: Список торгуемых монет (с ограничениям по валютам, если есть)
-    async def coins(self) -> list[types.CoinE]:  # {coin.exid: coin.ticker}
-        ...
+    async def coins(self) -> list[types.CoinEx]: # {coin.exid: coin.ticker}
+        for cur in (await self.curs()).keys():
+            params = {
+                'type': '1',
+                'quote': cur,
+                'side': 'buy'
+            }
+            coins = await self._get("/v3/c2c/currency/pairs", params=params)
+            return {coin["baseCurrency"]: types.CoinEx(exid=coin["baseCurrencyId"], ticker=coin["baseCurrency"]) for coin in coins["data"]}
 
     # 23: Список пар валюта/монет
     async def pairs(self) -> MapOfIdsList:
-        coins = await self.coins()
-        curs = await self.curs()
-        return {cur.ticker: set(c.ticker for c in coins) for cur in curs}
+        coins = (await self.coins()).keys()
+        curs = (await self.curs()).keys()
+        b = {cur: {c for c in coins} for cur in curs}
+        s = {cur: {c for c in coins} for cur in curs}
+        return s, b
 
     # 24: Список объяв по (buy/sell, cur, coin, pm)
     async def ads(
         self, coin_exid: str, cur_exid: str, is_sell: bool, pm_exids: list[str | int] = None, amount: int = None
-    ) -> list[Ads]:  # {ad.id: ad}
+    ) -> list[ad.Ads]:  # {ad.id: ad}
         params = {
             "side": "sell",
             "paymentMethod": "all",
@@ -64,16 +76,16 @@ class ExClient(BaseExClient):
             "numberPerPage": "5",
         }
         ads = await self._get("/v3/c2c/tradingOrders/getMarketplaceAdsPrelogin", params=params)
-        return [Ads(**ad) for ad in ads["data"]["sell"]]
+        return [ad.Ads(**ad) for ad in ads["data"]["sell"]]
 
     # 42: Чужая объява по id
-    async def ad(self, ad_id: int) -> Ad:
+    async def ad(self, ad_id: int) -> ad.Ad:
         params = {
             "publicUserId": "f81434eb2a",
             "t": f"{ad_id}",
         }
         ad = await self._get("/v3/c2c/merchant/liteProfile", params=params)
-        return Ad(**ad)
+        return ad.Ad(**ad)
 
 
 async def main():

{xync_client-0.0.25.dev47 → xync_client-0.0.25.dev50}/xync_client/TgWallet/ex.py

@@ -1,8 +1,9 @@
-from asyncio import run
+from asyncio import run, sleep
 
 from x_model import init_db
 from xync_schema import types
 from xync_schema import models
+from xync_schema.types import AdBuyIn
 
 from xync_client.Abc.types import PmEx
 from xync_client.TgWallet.pyd import (
@@ -25,6 +26,7 @@ class ExClient(BaseExClient, AuthClient):
         super().__init__(ex)  # BaseExClient
 
     def pm_type_map(self, pm: models.Pm) -> str:
+        # todo: no pm.name
         return "V2" if pm.name.startswith("SBP") else "V1"
 
     # 00: todo: min-max for cur and coin ad amount, order, fee ..
@@ -91,7 +93,8 @@ class ExClient(BaseExClient, AuthClient):
     # 42: Чужая объява по id
     async def ad(self, ad_id: int) -> _TakerOne:
         ad = await self._post("/p2p/public-api/v2/offer/get", {"offerId": ad_id})
-        ad: dict = ad["data"]
+        if not (ad := ad.get("data")):
+            return ad
         model = OneAdTakerMakerSale if ad["type"] == "SALE" else OneAdTakerBuy
         return model(**ad)
 
@@ -142,10 +145,10 @@ async def _test():
     await init_db(PG_DSN, models, True)
     tgex = await models.Ex.get(name="TgWallet")
     cl: ExClient = tgex.client()
-    # await cl.pms()
-    # await cl.pairs()
-    # await cl.set_pmcurexs()
-    # await cl.set_coinexs()
+    await cl.pms()
+    await cl.pairs()
+    await cl.set_pmcurexs()
+    await cl.set_coinexs()
 
     # # # SALE # # #
     # get ads list
@@ -155,12 +158,12 @@ async def _test():
     # 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.id) for ad in ads]
-    # # prepare ad fulls for saving
-    # ads_pydin: list[AdBuyPydIn] = [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]
+    # 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]
+    # full ones save
+    _ads_db = [await sleep(0.1, await cl.ad_pydin2db(adi)) for adi in ads_pydin]
 
     # # # BUY # # #
     # get ads list
@@ -170,12 +173,12 @@ async def _test():
     # list items save
     _ads_db = [await cl.ad_pydin2db(adi) for adi in ads_pydin]
 
-    # # get ad fulls
-    # ads_pyd = [await cl.ad(ad.id) for ad in ads]
-    # # prepare ad fulls for saving
-    # ads_pydin: list[AdBuyPydIn] = [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]
+    # 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]
+    # full ones save
+    _ads_db = [await cl.ad_pydin2db(adi) for adi in ads_pydin]
 
     await cl.close()
 

{xync_client-0.0.25.dev47 → xync_client-0.0.25.dev50}/xync_client/pm_unifier.py

@@ -16,14 +16,7 @@ class PmUnifier:
 
     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",
+        "GTB Bank (Guarantee Trust Bank)": "GTBank",
     }
     re_bank = [
         r"^bank (?!of )|bank$",

{xync_client-0.0.25.dev47 → xync_client-0.0.25.dev50}/xync_client/pyro.py

@@ -1,23 +1,32 @@
+import io
 from asyncio import run
+from os.path import dirname
+
+import requests
+from PIL import Image
+from PIL.ImageEnhance import Brightness
 from pyrogram import Client
 from pyrogram.errors import UserNotParticipant
-from pyrogram.raw.functions.channels import ToggleForum
-from pyrogram.raw.types import InputChannel
 from pyrogram.types import ChatPrivileges, Chat
-from src.loader import PG_DSN
-from tg_auth import UserStatus
 from x_model import init_db
+from xync_schema.enums import UserStatus
+
 from xync_client.loader import TG_API_ID, TG_API_HASH
 from xync_schema import models
 from xync_schema.models import Agent
 
 max_privs = ChatPrivileges(
-    # can_manage_chat=True,  3 default
+    can_manage_chat=True,  # default
     can_delete_messages=True,
+    can_delete_stories=True,  # Channels only
     can_manage_video_chats=True,  # Groups and supergroups only
     can_restrict_members=True,
     can_promote_members=True,
     can_change_info=True,
+    can_post_messages=True,  # Channels only
+    can_post_stories=True,  # Channels only
+    can_edit_messages=True,  # Channels only
+    can_edit_stories=True,  # Channels only
     can_invite_users=True,
     can_pin_messages=True,  # Groups and supergroups only
     can_manage_topics=True,  # Supergroups only
@@ -27,7 +36,7 @@ max_privs = ChatPrivileges(
 
 class PyroClient:
     def __init__(self, agent: Agent):
-        self.app: Client = Client(str(agent.user_id), TG_API_ID, TG_API_HASH, session_string=agent.auth["sess"])
+        self.app: Client = Client(str(agent.actor.user_id), TG_API_ID, TG_API_HASH, session_string=agent.auth["sess"])
 
     async def create_orders_forum(self, uid: int) -> tuple[int, bool]:
         async with self.app as app:
@@ -53,7 +62,7 @@ class PyroClient:
 async def main():
     _ = await init_db(PG_DSN, models, True)
     agent = await Agent.filter(
-        actor__ex__name="TgWallet", auth__isnull=False, user__status__gt=UserStatus.RESTRICTED
+        actor__ex__name="TgWallet", auth__isnull=False, user__status__gt=UserStatus.SLEEP
     ).first()  # .order_by("-user__created_forums__count")
     pcl = PyroClient(agent)
     res = await pcl.create_orders_forum("cryrub")
@@ -67,3 +76,12 @@ if __name__ == "__main__":
     load_dotenv()
     PG_DSN = f"postgres://{env('POSTGRES_USER')}:{env('POSTGRES_PASSWORD')}@{env('POSTGRES_HOST', 'xyncdbs')}:{env('POSTGRES_PORT', 5432)}/{env('POSTGRES_DB', env('POSTGRES_USER'))}"
     run(main())
+
+
+def ava(url: str) -> bytes:
+    byts = requests.get(url).content
+    jpg = Image.open(io.BytesIO(byts)).convert('RGBA')
+    jpg = Brightness(jpg).enhance(0.5)
+    png = Image.open(dirname(__file__) + '/xico.png')
+    jpg.paste(png, (0, 0, 320, 320), mask=png)
+    return jpg.tobytes()

{xync_client-0.0.25.dev47 → xync_client-0.0.25.dev50/xync_client.egg-info}/PKG-INFO

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

@@ -46,10 +46,10 @@ xync_client/BingX/__init__.py
 xync_client/BingX/agent.py
 xync_client/BingX/base.py
 xync_client/BingX/ex.py
-xync_client/BingX/pyd.py
 xync_client/BingX/req.mjs
 xync_client/BingX/sign.js
-xync_client/BingX/test/main.py
+xync_client/BingX/etype/ad.py
+xync_client/BingX/etype/pm.py
 xync_client/BitGet/__init__.py
 xync_client/BitGet/agent.py
 xync_client/BitGet/ex.py
@@ -67,10 +67,13 @@ xync_client/Htx/etype/__init__.py
 xync_client/Htx/etype/ad.py
 xync_client/Htx/etype/cred.py
 xync_client/Htx/etype/pm.py
-xync_client/KuCoin/pub.py
+xync_client/KuCoin/ex.py
 xync_client/KuCoin/web.py
+xync_client/KuCoin/etype/ad.py
+xync_client/KuCoin/etype/pm.py
 xync_client/Okx/ex.py
-xync_client/Okx/pyd.py
+xync_client/Okx/etype/ad.py
+xync_client/Okx/etype/pm.py
 xync_client/TgWallet/agent.py
 xync_client/TgWallet/asset.py
 xync_client/TgWallet/auth.py

xync_client-0.0.25.dev47/xync_client/BingX/test/main.py

@@ -1,52 +0,0 @@
-import requests
-
-cookies = {
-    '__cf_bm': 'YkMbbTCO0X3QoR62nKzJi70V6SfgSUGKz5WZaTYYMd4-1738247827-1.0.1.1-HlJG9k3o1QEgRBTjxdFUDE4RTiW3IlnlghrNzBl2xbEKEEW7UhLW66FN_cZg5q6RAN2eH5o68h9i0GCsGxS4wA',
-}
-
-headers = {
-    'accept': 'application/json, text/plain, */*',
-    'accept-language': 'ru-RU,ru;q=0.9,en-US;q=0.8,en;q=0.7',
-    'app_version': '9.2.15',
-    'appid': '30004',
-    'appsiteid': '0',
-    'authorization': 'Bearer eyJicyI6MCwiYWlkIjoxMDAwOSwicGlkIjoiMzAiLCJzaWQiOiJhM2JmYWE4MzFiOWUxYzc5MGJjYjBkYmNjMjM3YTFmMiIsImFsZyI6IkhTNTEyIn0.eyJzdWIiOiIxMzc5MzM1NzcyNDUxNDk1OTQxIiwiZXhwIjoxNzM4Njc5ODM5LCJqdGkiOiIxZGZmYjNhOC02ZjU1LTQ0OTYtOWZhNi02NDQ5ODdjNjQ0MDMifQ.t51lrJYfjCd-N9iLjB7It47ku6imK-cchk42QPIWf5IrUjsuI1PsX6OWLvvFkoIw5uucuSlNQrlcbuFRPz5ngA',
-    'channel': 'official',
-    'content-type': 'application/json',
-    # 'cookie': '__cf_bm=YkMbbTCO0X3QoR62nKzJi70V6SfgSUGKz5WZaTYYMd4-1738247827-1.0.1.1-HlJG9k3o1QEgRBTjxdFUDE4RTiW3IlnlghrNzBl2xbEKEEW7UhLW66FN_cZg5q6RAN2eH5o68h9i0GCsGxS4wA',
-    'device_brand': 'Linux_Chrome_132.0.0.0',
-    'device_id': '6f76e02b64ba4a078a331eb5c323913b',
-    'lang': 'ru-RU',
-    'mainappid': '10009',
-    'origin': 'https://bingx.paycat.com',
-    'platformid': '30',
-    'priority': 'u=1, i',
-    'referer': 'https://bingx.paycat.com/',
-    'reg_channel': 'official',
-    'sec-ch-ua': '"Not A(Brand";v="8", "Chromium";v="132", "Google Chrome";v="132"',
-    'sec-ch-ua-mobile': '?0',
-    'sec-ch-ua-platform': '"Linux"',
-    'sec-fetch-dest': 'empty',
-    'sec-fetch-mode': 'cors',
-    'sec-fetch-site': 'cross-site',
-    'sign': '3CEFB4B1B8B7FF82080D092FB1D68F3B7DC5E91FAFB3CD885636FAB9889FD3A3',
-    'timestamp': '1738247933539',
-    'timezone': '3',
-    'traceid': 'e2f42528383e4bc095151a9f501f57fd',
-    'user-agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36',
-    'x-requested-with': 'XMLHttpRequest',
-}
-
-json_data = {
-    'advertNo': '1383430032238764040',
-    'asset': 'USDT',
-    'fiat': 'RUB',
-    'type': 1,
-    'userPrice': 103,
-    'areaType': 2,
-    'amount': '500',
-    'paymentMethodId': 110,
-}
-
-response = requests.post('https://api-app.qq-os.com/api/c2c/v1/order/create', cookies=cookies, headers=headers, json=json_data)
-print(response.text)

xync_client-0.0.25.dev47/xync_client/KuCoin/pub.py

@@ -1,47 +0,0 @@
-from asyncio import run
-
-from x_model import init_db
-from xync_schema import models
-from xync_schema.models import Coin, Cur, Pm, Ad, Ex, Curex
-
-from xync_client.Abc.Base import MapOfIdsList
-from xync_client.Abc.Ex import BaseExClient
-from xync_client.loader import PG_DSN
-
-
-class ExClient(BaseExClient):
-    async def cur_pms_map(self) -> MapOfIdsList:
-        pass
-
-    async def curs(self) -> list[Cur]:
-        curs = (await self._get("/_api/otc/dictionary/getData", {"type": "LEGAL"}))["data"]
-        curs = [(await Cur.update_or_create(ticker=cur["typeCode"]))[0] for cur in curs]
-        curexs = [Curex(cur=c, ex=self.ex) for c in curs]
-        await Curex.bulk_create(curexs, ignore_conflicts=True)
-        return curs
-
-    async def coins(self, cur: Cur = None) -> list[Coin]: ...
-
-    async def pms(self, cur: Cur = None) -> list[Pm]:
-        pmcurs = {
-            cur.ticker: (await self._get("/_api/otc/legal/payTypes", {"legal": cur.ticker}))["data"]
-            for cur in await self.curs()
-        }
-        pp = {}
-        [[pp.update({p["payTypeCode"]: p["payTypeName"]}) for p in ps] for ps in pmcurs.values()]
-        return pp
-
-    async def ads(self, coin: Coin, cur: Cur, is_sell: bool, pms: list[Pm] = None) -> list[Ad]:
-        pass
-
-
-async def main():
-    _ = await init_db(PG_DSN, models, True)
-    bg = await Ex.get(name="KuCoin")
-    cl = ExClient(bg)
-    # await cl.curs()
-    # await cl.coins()
-    await cl.pms()
-
-
-run(main())