xync-client 0.0.25.dev22__tar.gz → 0.0.25.dev38__tar.gz

{xync_client-0.0.25.dev22/xync_client.egg-info → xync_client-0.0.25.dev38}/PKG-INFO

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

@@ -71,7 +71,7 @@ class TestEx(BaseTest):
     # 24
     async def test_ads(self, clients: list[BaseExClient]):
         for client in clients:
-            ads: list[BaseAd] = await client.ads("USDT", "RUB", False)
+            ads: list[BaseAd] = await client.ads("USDT", "USD", False)
             ok = self.is_list_of_objects(ads, BaseAd)
             t, _ = await ExTest.update_or_create({"ok": ok}, ex=client.ex, action=ExAction.ads)
             assert t.ok, "No ads"
@@ -81,7 +81,7 @@ class TestEx(BaseTest):
     # 42
     async def test_ad(self, clients: list[BaseExClient]):
         for client in clients:
-            ad: BaseAd = await client.ad(self.ad[client.ex.name].id)
+            ad: BaseAd = await client.ad(self.ad.get(client.ex.name, (await client.ads("USDT", "RUB", False))[0]).id)
             ok = isinstance(ad, BaseAd)
             t, _ = await ExTest.update_or_create({"ok": ok}, ex=client.ex, action=ExAction.ad)
             assert t.ok, "No ad"

{xync_client-0.0.25.dev22 → xync_client-0.0.25.dev38}/tests/_todo_refact/Bybit/test_bybit_p2p.py

@@ -135,10 +135,10 @@ async def test_on_off_ads(dbc):
     old_status = AdsStatus[bybit_p2p.online_ads()]
     new_status = AdsStatus(int(not bool(old_status.name)))
     ok = await _switch_ad(new_status)
-    assert ok, "Ads no " + new_status.name
+    assert ok, "Ad no " + new_status.name
     # возвращаем как было:
     ok = await _switch_ad(old_status)
-    assert ok, "Ads no " + old_status.name
+    assert ok, "Ad no " + old_status.name
 
 
 # старт заявки (тейкером 17)

{xync_client-0.0.25.dev22 → xync_client-0.0.25.dev38}/xync_client/Abc/Ex.py

@@ -50,7 +50,7 @@ class BaseExClient(BaseClient):
 
     # 23: Список пар валюта/монет
     @abstractmethod
-    async def pairs(self) -> DictOfDicts: ...
+    async def pairs(self) -> MapOfIdsList: ...
 
     # 24: Список объяв по (buy/sell, cur, coin, pm)
     @abstractmethod

{xync_client-0.0.25.dev22 → xync_client-0.0.25.dev38}/xync_client/Binance/sapi.py

@@ -138,7 +138,7 @@ class Sapi(Client):
         }
         return await self._post(Ep.POST_AD, body)
 
-    # 6. Search Ads
+    # 6. Search Ad
     async def search_ads(self, asset, fiat, trade_type, pms: [str] = None, amount: int = None, page=1, rows=20):
         """
         Search advertisements based on search criteria.

{xync_client-0.0.25.dev22 → xync_client-0.0.25.dev38}/xync_client/BingX/ex.py

@@ -5,12 +5,11 @@ from xync_schema import models
 from xync_schema.models import Ex
 from xync_schema.pydantic import PmPyd, CurEpyd, CoinEpyd
 
-from xync_client.Abc.Base import FlatDict
 from xync_client.Abc.Ex import BaseExClient
 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
+from xync_client.BingX.pyd import PmEpyd, Ad
 
 
 class ExClient(BaseExClient, BaseBingXClient):
@@ -51,21 +50,23 @@ class ExClient(BaseExClient, BaseBingXClient):
         return [CurEpyd(exid=cur["id"], ticker=cur["name"]) for cur in curs["data"]["coins"]]
 
     # 21: cur_pms_map на BingX
-    async def cur_pms_map(self):
-        return {cur.exid: list(await self._pms(cur.exid)) for cur in await self.curs()}
+    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()}
 
     # 22: Монеты на BingX
-    async def coins(self) -> FlatDict:
-        return [CoinEpyd(exid="USDT", ticker="USDT")]
+    async def coins(self) -> list[CoinEpyd]:
+        return [CoinEpyd(exid="1", ticker="USDT")]
 
     # 23: Список пар валюта/монет
     async def pairs(self) -> MapOfIdsList:
         coins = await self.coins()
         curs = await self.curs()
-        return {cur.exid: set(c.exid for c in coins) for cur in curs}
+        return {cur.ticker: set(c.ticker for c in coins) for cur in curs}
 
     # 24: ads
-    async def ads(self, coin_exid: str, cur_exid: str, is_sell: bool, pm_exids: list[str | int] = None):
+    async def ads(
+        self, coin_exid: str, cur_exid: str, is_sell: bool, pm_exids: list[str | int] = None, amount: int = None
+    ) -> list[Ad]:
         params = {
             "type": 1,
             "fiat": cur_exid,
@@ -77,14 +78,14 @@ class ExClient(BaseExClient, BaseBingXClient):
         }
 
         ads = await self._get("/api/c2c/v1/advert/list", params=params)
-        return ads["data"]["dataList"]
+        return [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)
-    await cl.pms()
+    _ads = await cl.ads("USDT", "RUB", False)
     await cl.close()
 
 

xync_client-0.0.25.dev38/xync_client/BingX/pyd.py

@@ -0,0 +1,90 @@
+from pydantic import BaseModel
+from typing import List
+from xync_schema.pydantic 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
+    paymentMethodName: str
+    paymentMethodIcon: str
+    mainColor: str
+
+class PaymentMethod(BaseModel):
+    id: int
+    name: str
+    icon: str
+    mainColor: str
+    userPaymentMethodList: List[UserPaymentMethod]
+
+class Ad(BaseAd):
+    orderNo: str
+    tradeRecent: int
+    type: int
+    asset: str
+    fiat: str
+    fiatSymbol: str
+    totalNumber: float
+    availableAmount: float
+    priceType: int
+    fixPrice: float
+    floatRatio: float
+    price: float
+    minAmount: float
+    maxAmount: float
+    assetPrecision: int
+    fiatPrecision: int
+    pricePrecision: int
+    paymentMethodList: List[PaymentMethod]
+    termsDesc: str
+    hidePaymentInfo: int
+    nickName: str
+    merchantUid: str
+    restStatus: int
+    onlineStatus: bool
+    merchantOnlineHint: str
+    avatarUrl: str
+    tradeNum30: int
+    expireMinute: int
+    status: int
+    autoReplyMsg: str
+    formatPrice: str
+    formatMinAmount: str
+    formatMaxAmount: str
+    promotionAdvert: bool
+    promotionAdvertOnline: bool
+    promotionAdvertEnableChange: bool
+    isCanBeSubsidized: bool
+    merchantKycType: int
+    merchantVerificationType: int
+    isUserMatchCondition: bool
+    notMatchConditionReason: str

xync_client-0.0.25.dev38/xync_client/Htx/ex.py

@@ -0,0 +1,90 @@
+from asyncio import run
+
+from x_model import init_db
+from xync_schema import models, types
+from xync_schema.models import Ex, Cur
+from xync_schema.enums import PmType
+
+from xync_client.Abc.Ex import BaseExClient
+from xync_client.Htx.pyd.types import Country
+from xync_client.loader import PG_DSN
+
+
+class ExClient(BaseExClient):
+    # 20: Get all pms
+    async def pms(self, _cur: Cur = None) -> dict[int, types.Pm]:
+        dist = {
+            0: PmType.card,
+            1: PmType.bank,
+            2: PmType.cash,
+            3: PmType.emoney,
+            4: PmType.emoney,
+            5: PmType.IFSC,
+        }
+
+        pms = (await self._coin_curs_pms())["payMethod"]
+
+        pmsd = {
+            pm["payMethodId"]: types.Pm(
+                id=pm["payMethodId"],
+                name=pm["name"],
+                type_=dist.get(pm["template"], pm["template"]),
+                logo=pm.get("bankImage", pm["bankImageWeb"]),
+            )
+            for pm in pms
+        }
+
+        return pmsd
+
+    # 21: Get all: currency,pay,allCountry,coin
+    async def curs(self) -> list[types.CurE]:
+        res = (await self._coin_curs_pms())["currency"]
+        return [
+            types.CurE(exid=c["currencyId"], ticker=c["nameShort"]) for c in res
+        ]  # if c['showPtoP'] todo: wht "showPtoP" is means
+
+    # 22: Список платежных методов по каждой валюте
+    async def cur_pms_map(self) -> dict[int, set[int]]:
+        res = await self._coin_curs_pms()
+        wrong_pms = {4, 34, 498, 548, 20009, 20010}  # , 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: Список торгуемых монет
+    async def coins(self) -> list[types.CoinE]:
+        coins: list[dict] = (await self._coin_curs_pms())["coin"]
+        return [types.CoinE(exid=c["coinId"], ticker=c["coinCode"]) for c in coins if c["coinType"] == 2]
+
+    # 99: Страны
+    async def countries(self) -> list[Country]:
+        res = await self._coin_curs_pms()
+        cts = [
+            Country(
+                id=c["countryId"],
+                code=c["code"],
+                name=c["name"],
+                short=c["appShort"],
+                cur_id=c["currencyId"],
+            )
+            for c in res["country"]
+        ]
+        return cts
+
+    # Get all: currency,pay,allCountry,coin
+    async def _coin_curs_pms(self) -> (dict, dict, dict, dict):
+        res = (await self._get("/-/x/otc/v1/data/config-list?type=currency,pay,coin,allCountry"))["data"]
+        res["currency"][0]["currencyId"] = 1
+        [c.update({"currencyId": 1, "name": ""}) for c in res["country"] if c["currencyId"] == 172]
+        return res
+
+
+async def main():
+    _ = await init_db(PG_DSN, models, True)
+    ex = await Ex.get(name="Htx")
+    cl = ExClient(ex)
+    await cl.set_pmcurexs()
+    await cl.set_coinexs()
+    await cl.close()
+
+
+if __name__ == "__main__":
+    run(main())

xync_client-0.0.25.dev38/xync_client/Htx/pyd/actor.py

@@ -0,0 +1,4 @@
+from pydantic import BaseModel
+
+
+class Resp(BaseModel):

xync_client-0.0.25.dev38/xync_client/Htx/pyd/ad.py

@@ -0,0 +1,92 @@
+from typing import Literal
+
+from pydantic import BaseModel
+
+
+class TradeRule(BaseModel):
+    title: str
+    titleValue: str
+    content: str
+    inputType: int
+    inputValue: str
+    hint: str
+    contentCode: str
+    sort: int
+
+
+class Req(BaseModel):
+    tradeType: int
+    coinId: int
+    currency: int
+    minTradeLimit: float
+    maxTradeLimit: float
+    tradeCount: float
+    password: str
+    securityToken: str | None = ""
+    payTerm: int
+    isFixed: Literal["off", "on"]
+    premium: int
+    fixedPrice: str | None = ""
+    autoReplyContent: str | None = ""
+    isAutoReply: Literal["off", "on"]
+    tradeRule: str | None = ""
+    takerAcceptOrder: int
+    isPayCode: Literal["off", "on"]
+    isVerifyCapital: bool
+    receiveAccounts: int
+    deviation: int
+    isTakerLimit: Literal["off", "on"]
+    blockType: int
+    session: int
+    chargeType: bool
+    apiVersion: int
+    channel: str
+    tradeRulesV2: list[TradeRule]
+
+
+class PayMethod(BaseModel):
+    payMethodId: int
+    name: str
+    color: str
+    isRecommend: bool | None = None
+
+
+class PayName(BaseModel):
+    bankType: int
+    id: int
+
+
+class Resp(BaseModel):
+    blockType: int
+    chargeType: bool
+    coinId: int
+    currency: int
+    gmtSort: int
+    id: int
+    isCopyBlock: bool
+    isFollowed: bool
+    isOnline: bool
+    isTrade: bool
+    isVerifyCapital: bool
+    labelName: str | None = None
+    maxTradeLimit: str
+    merchantLevel: int
+    merchantTags: str | None = None
+    minTradeLimit: str
+    orderCompleteRate: str
+    payMethod: str
+    payMethods: list[PayMethod]
+    payName: list[PayName]  # приходит массив объектов внутри строки
+    payTerm: int
+    price: str
+    seaViewRoom: str | None = None
+    takerAcceptAmount: str
+    takerAcceptOrder: int
+    takerLimit: int
+    thumbUp: int
+    totalTradeOrderCount: int
+    tradeCount: str
+    tradeMonthTimes: int
+    tradeType: int
+    uid: int
+    userName: str

xync_client-0.0.25.dev38/xync_client/Htx/pyd/cred.py

@@ -0,0 +1,59 @@
+from typing import Literal
+
+from pydantic import BaseModel
+
+field_ids = {
+    926496571879587801: "payee",
+    926496571879587802: "bank",
+    926496571879587803: "sub_bank",
+    926496571879587804: "pay_account"
+}
+
+field_types = {
+    "payee": "cred__name",
+    "bank": "pm__name",
+    "sub_bank": None,
+    "pay_account": "cred__detail"
+}
+
+
+class Cred(BaseModel):
+    fieldId: str
+    fieldType: Literal["payee", "bank", "sub_bank", "pay_account"]
+    value: str | None = None
+
+
+class Req(BaseModel):
+    __root__: list[Cred]
+
+
+class ModelField(BaseModel):
+    fieldId: str
+    name: str
+    fieldType: str
+    index: int
+    maxLength: int
+    required: bool
+    copyable: bool
+    remindWord: str
+    valueType: str
+    value: str | None = None
+
+
+class Resp(BaseModel):
+    id: int
+    uid: int
+    userName: str
+    bankType: int
+    bankNumber: str
+    bankName: str
+    bankAddress: str | None = None
+    qrCode: str | None = None
+    isShow: int
+    buyingEnable: bool
+    sellingEnable: bool
+    disabledCurrencyList: list[int]
+    modelFields: str | None = ""
+    modelFieldsList: list[ModelField]
+    color: str
+    payMethodName: str

xync_client-0.0.25.dev38/xync_client/Htx/pyd/pm.py

@@ -0,0 +1,12 @@
+from pydantic import BaseModel, HttpUrl
+
+
+class Resp(BaseModel):
+    payMethodId: int
+    name: str
+    defaultName: str | None = None
+    template: int
+    bankImage: HttpUrl
+    bankImageWeb: HttpUrl
+    bankType: int
+    color: str

xync_client-0.0.25.dev38/xync_client/Htx/pyd/types.py

@@ -0,0 +1,9 @@
+from msgspec import Struct
+
+
+class Country(Struct):
+    id: int
+    code: int
+    short: str
+    name: str
+    cur_id: str

xync_client-0.0.25.dev38/xync_client/Okx/ex.py

@@ -0,0 +1,90 @@
+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.Okx.pyd import PmE, Ads, Ad
+
+
+class ExClient(BaseExClient):
+    async def _pms(self, cur) -> list[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"]]
+
+    # 19: Список поддерживаемых валют тейкера
+    async def curs(self) -> list[types.CurE]:  # {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"]]
+
+    # 20: Список платежных методов
+    async def pms(self, cur: models.Cur = None) -> dict[int | str, types.Pm]:  # {pm.exid: pm}
+        all_pms = {}
+        for cur in await self.curs():
+            pms = await self._pms(cur.ticker)
+            for pm in pms:
+                all_pms[pm.transferSpeed] = types.Pm(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()}
+
+    # 22: Список торгуемых монет (с ограничениям по валютам, если есть)
+    async def coins(self) -> list[types.CoinE]:  # {coin.exid: coin.ticker}
+        ...
+
+    # 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}
+
+    # 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}
+        params = {
+            "side": "sell",
+            "paymentMethod": "all",
+            "userType": "all",
+            "hideOverseasVerificationAds": "true" if is_sell else "false",
+            "sortType": "price_asc",
+            "limit": "100",
+            "cryptoCurrency": f"{coin_exid}",
+            "fiatCurrency": f"{cur_exid}",
+            "currentPage": "1",
+            "numberPerPage": "5",
+        }
+        ads = await self._get("/v3/c2c/tradingOrders/getMarketplaceAdsPrelogin", params=params)
+        return [Ads(**ad) for ad in ads["data"]["sell"]]
+
+    # 42: Чужая объява по id
+    async def ad(self, ad_id: int) -> Ad:
+        params = {
+            "publicUserId": "f81434eb2a",
+            "t": f"{ad_id}",
+        }
+        ad = await self._get("/v3/c2c/merchant/liteProfile", params=params)
+        return Ad(**ad)
+
+
+async def main():
+    _ = await init_db(PG_DSN, models, True)
+    bg = await models.Ex.get(name="Okx")
+    cl = ExClient(bg)
+    await cl.curs()
+    # await cl.coins()
+    # await cl.pms()
+    await cl.close()
+
+
+if __name__ == "__main__":
+    run(main())

xync_client-0.0.25.dev38/xync_client/Okx/pyd.py

@@ -0,0 +1,161 @@
+from pydantic import BaseModel
+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]
+
+
+class LegacyMerchantInfo(BaseModel):
+    accountAssociationDate: int
+    avgPaidTime: int
+    avgReleasedTime: int
+    cancelledOrderQuantity: int
+    completedOrderQuantity: int
+    hasLegacyMerchant: bool
+    legacyMerchantRegisteredDate: int
+    nickname: str
+    totalCompletionRate: str
+
+
+class MerchantInfo30DayOrderInfo(BaseModel):
+    completedBuyOrderQuantity30Day: int
+    completedOrderQuantity30Day: int
+    completedSellOrderQuantity30Day: int
+    completionRateBuyOrderQuantity30Day: float
+    completionRateOrderQuantity30Day: float
+    completionRateSellOrderQuantity30Day: float
+    servedUsersCompletedOrders30Day: int
+
+
+class MerchantScoreInfo(BaseModel):
+    merchantScore: int
+    scorePercentileRank: int
+    showMerchantScoreInfo: bool
+
+
+class UserActiveStatusVo(BaseModel):
+    userActiveStatus: int
+    userActiveStatusText: str
+
+
+class VideoVerificationStatus(BaseModel):
+    failedReason: str
+    status: int
+
+
+class Ads(BaseAd):
+    alreadyTraded: bool
+    availableAmount: str
+    avgCompletedTime: int
+    avgPaymentTime: int
+    baseCurrency: str
+    black: bool
+    cancelledOrderQuantity: int
+    completedOrderQuantity: int
+    completedRate: str
+    creatorType: str
+    guideUpgradeKyc: bool
+    id: str
+    intention: bool
+    isInstitution: int
+    maxCompletedOrderQuantity: int
+    maxUserCreatedDate: int
+    merchantId: str
+    minCompletedOrderQuantity: int
+    minCompletionRate: str
+    minKycLevel: int
+    minSellOrderQuantity: int
+    minSellOrders: int
+    minTradeVolume: int
+    mine: bool
+    nickName: str
+    paymentMethods: List[str]
+    paymentTimeoutMinutes: int
+    posReviewPercentage: str
+    price: str
+    promoBadgeInfoVo: PromoBadgeInfoVo
+    publicUserId: str
+    quoteCurrency: str
+    quoteMaxAmountPerOrder: str
+    quoteMinAmountPerOrder: str
+    quoteScale: int
+    quoteSymbol: str
+    receivingAds: bool
+    safetyLimit: bool
+    side: str
+    userActiveStatusVo: None
+    userType: str
+    verificationType: int
+    whitelistedCountries: List[str]
+
+
+class Ad(BaseAd):
+    allowChat: bool
+    auditState: int
+    avatarImage: str
+    avgCompletedTime: str
+    avgPaidTime: str
+    blackState: str
+    blackUserCount: Optional[str] = None
+    businessHoursInfo: Optional[str] = None
+    canCurrentUserViewOrderReview: bool
+    commonOrderTotal: Optional[str] = None
+    completedBuyOrderQuantity: int
+    completedOrderQuantity: int
+    completedSellOrderQuantity: int
+    countryIcon: str
+    countryId: str
+    countryName: str
+    createdDate: int
+    description: str
+    disabled: bool
+    emailVerified: bool
+    finishRate: str
+    follow: bool
+    followerCount: int
+    fundsInfo: Optional[str] = None
+    isInstitution: int
+    kycDate: int
+    kycLevel: str
+    kycRedirect: int
+    kycVerified: bool
+    legacyMerchantInfo: LegacyMerchantInfo
+    merchantDeposit: int
+    merchantDepositCurrency: str
+    merchantInfo30DayOrderInfo: MerchantInfo30DayOrderInfo
+    merchantRegistrationDate: int
+    merchantScoreInfo: MerchantScoreInfo
+    negativeReviewNum: int
+    nickName: str
+    orderTotalCount: str
+    phoneVerified: bool
+    positiveReviewNum: int
+    positiveReviewPercentage: int
+    promoBadgeInfoVo: PromoBadgeInfoVo
+    publicMerchantId: Optional[str] = None
+    publicUserId: str
+    realName: str
+    self: bool
+    showAddNicknameButton: bool
+    showAddNicknameTooltip: bool
+    showReview: bool
+    showingVideoVerification: bool
+    totalReviewNum: int
+    tradeUserCount: str
+    userActiveStatusVo: UserActiveStatusVo
+    userType: str
+    videoVerificationStatus: VideoVerificationStatus
+    vip: bool

{xync_client-0.0.25.dev22 → xync_client-0.0.25.dev38}/xync_client/pyro.py

@@ -3,7 +3,7 @@ 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
+from pyrogram.types import ChatPrivileges, Chat
 from src.loader import PG_DSN
 from tg_auth import UserStatus
 from x_model import init_db
@@ -29,20 +29,23 @@ 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"])
 
-    async def create_orders_forum(self, uid: int | str) -> tuple[int, bool]:
+    async def create_orders_forum(self, uid: int) -> tuple[int, bool]:
         async with self.app as app:
             app: Client
-            forum = await app.create_supergroup(f"xync{uid}", "Xync Orders")
+            forum: Chat = await app.create_supergroup(f"xync{uid}", "Xync Orders")
             if not (_ := await app.toggle_forum_topics(chat_id=forum.id, enabled=True)):
                 r = await app.delete_channel(forum.id)
                 r = await forum.leave()
                 raise Exception(f"Chat {forum.id} for {app.me.username} not converted to forum")
-            added = await forum.add_members([uid, "XyncNetBot"])  # , "xync_bot"
+            if added := await forum.add_members(["XyncNetBot"]):  # , "xync_bot"
+                await forum.promote_member("XyncNetBot", max_privs)
+                added = await forum.add_members([uid])
+            else:
+                pass
             try:
                 await forum.get_member(uid)
             except UserNotParticipant:
                 added = False
-            await forum.promote_member("XyncNetBot", max_privs)
             # await forum.leave()
             return forum.id, added
 

{xync_client-0.0.25.dev22 → xync_client-0.0.25.dev38/xync_client.egg-info}/PKG-INFO

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

@@ -61,9 +61,15 @@ xync_client/Gate/premarket.py
 xync_client/Htx/agent.py
 xync_client/Htx/earn.py
 xync_client/Htx/ex.py
+xync_client/Htx/pyd/actor.py
+xync_client/Htx/pyd/ad.py
+xync_client/Htx/pyd/cred.py
+xync_client/Htx/pyd/pm.py
+xync_client/Htx/pyd/types.py
 xync_client/KuCoin/pub.py
 xync_client/KuCoin/web.py
 xync_client/Okx/ex.py
+xync_client/Okx/pyd.py
 xync_client/TgWallet/agent.py
 xync_client/TgWallet/asset.py
 xync_client/TgWallet/auth.py

xync_client-0.0.25.dev22/xync_client/BingX/pyd.py

@@ -1,32 +0,0 @@
-from pydantic import BaseModel
-
-
-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

xync_client-0.0.25.dev22/xync_client/Htx/ex.py

@@ -1,77 +0,0 @@
-from asyncio import run
-
-from x_model import init_db
-from xync_schema import models
-from xync_schema.models import Ex, Coin, Cur, Pm, Ad
-from xync_schema.enums import PmType
-
-from xync_client.Abc.Ex import BaseExClient
-from xync_client.loader import PG_DSN
-
-
-class ExClient(BaseExClient):
-    # 20: Get all pms
-    async def pms(self) -> dict[int, dict]:
-        dist = {
-            0: PmType.credit_card,
-            1: PmType.bank,
-            2: PmType.cash,
-            3: PmType.web_wallet,
-            4: PmType.web_wallet,
-            5: PmType.IFSC,
-        }
-
-        pms = (await self._coin_curs_pms())["payMethod"]
-
-        pmsd = {
-            pm["payMethodId"]: {
-                "name": pm["name"],
-                "type_": dist.get(pm["template"], pm["template"]),
-                "logo": pm.get("bankImage", pm["bankImageWeb"]),
-            }
-            for pm in pms
-        }
-
-        return pmsd
-
-    # 21: Get all: currency,pay,allCountry,coin
-    async def curs(self) -> dict[int, str]:
-        res = await self._coin_curs_pms()
-        return {
-            c["currencyId"]: c["nameShort"] for c in res["currency"]
-        }  # if c['showPtoP'] todo: wht "showPtoP" is means
-
-    # 22: Список платежных методов по каждой валюте
-    async def cur_pms_map(self) -> dict[int, set[int]]:
-        res = await self._coin_curs_pms()
-        wrong_pms = {4, 34, 498, 548, 20009, 20010}  # , 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: Список торгуемых монет
-    async def coins(self) -> dict[int, str]:
-        coins: list[dict] = (await self._coin_curs_pms())["coin"]
-        return {c["coinId"]: c["coinCode"] for c in coins if c["coinType"] == 2}
-
-    # 24: Список объяв
-    async def ads(self, coin: Coin, cur: Cur, is_sell: bool, pms: list[Pm] = None) -> list[Ad]:
-        res = await self._coin_curs_pms()
-        return res["country"]
-
-    # Get all: currency,pay,allCountry,coin
-    async def _coin_curs_pms(self) -> (dict, dict, dict, dict):
-        res = await self._get("/-/x/otc/v1/data/config-list?type=currency,pay,coin")  # ,allCountry
-        return res["data"]
-
-
-async def main():
-    _ = await init_db(PG_DSN, models, True)
-    ex = await Ex.get(name="Htx")
-    cl = ExClient(ex)
-    # await cl.cur_pms_map()
-    await cl.set_pmcurexs()
-    await cl.set_coinexs()
-    await cl.close()
-
-
-if __name__ == "__main__":
-    run(main())

xync_client-0.0.25.dev22/xync_client/Okx/ex.py

@@ -1,45 +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
-
-from xync_client.Abc.Base import MapOfIdsList, ListOfDicts
-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("/v3/users/common/list/currencies"))["data"]
-        return curs
-
-    async def coins(self, cur: Cur = None) -> list[Coin]: ...
-
-    async def pms(self, cur: Cur = None) -> ListOfDicts:
-        pmcurs = {
-            cur.ticker: (await self._get("/v3/c2c/configs/receipt/templates", {"quoteCurrency": cur.ticker}))["data"]
-            for cur in await self.curs()
-        }
-        pp = {}
-        [[pp.update({p["paymentMethod"]: p["paymentMethodDescription"]}) for p in ps] for ps in pmcurs.values()]
-        pp = {k: v for k, v in sorted(pp.items(), key=lambda x: x[0])}
-        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="Okx")
-    cl = ExClient(bg)
-    # await cl.curs()
-    # await cl.coins()
-    await cl.pms()
-
-
-run(main())