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

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

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

@@ -18,7 +18,7 @@ class TestEx(BaseTest):
     @pytest.fixture
     async def clients(self) -> list[BaseClient]:
         exs = await Ex.filter(status__gt=ExStatus.plan)
-        [await ex.fetch_related("contragents__agent") for ex in exs if ex.type_ == ExType.tg]
+        [await ex.fetch_related("actors__agent") for ex in exs if ex.type_ == ExType.tg]
         clients: list[BaseExClient] = [ex.client() for ex in exs]
         yield clients
         [await cl.close() for cl in clients]

{xync_client-0.0.25.dev19 → xync_client-0.0.25.dev22}/xync_client/Abc/Agent.py

@@ -13,7 +13,7 @@ from xync_client.Abc.Base import BaseClient
 class BaseAgentClient(BaseClient):
     def __init__(self, agent: Agent):
         self.agent: Agent = agent
-        super().__init__(self.agent.contragent.ex)  # , "host_p2p"
+        super().__init__(self.agent.actor.ex)  # , "host_p2p"
         self.ex_client: BaseExClient = self.ex.client()
 
     @abstractmethod
@@ -97,12 +97,12 @@ class BaseAgentClient(BaseClient):
     async def fiat_f2in(self, fiat_new: FiatNew) -> FiatPydIn:
         if not (_pmcur := await Pmcur.get_or_none(cur_id=fiat_new.cur_id, pm_id=fiat_new.pm_id)):
             raise HTTPException(FailReason.body, f"No Pmcur with cur#{fiat_new.cur_id} and pm#{fiat_new.pm_id}", 404)
-        # cred = await Cred.create({"exid": }, pmcur=pmcur, contragent=self.agent.contragent)
+        # cred = await Cred.create({"exid": }, pmcur=pmcur, actor=self.agent.actor)
         # df = {"detail": fiat_pyd.detail, "name": fiat_pyd.name, "amount": fiat_pyd.amount, "target": fiat_pyd.target}
         # unq = {"pmcur": pmcur, "user_id": uid}
 
     # async def fiat_new(self, fiat: FiatNew) -> Fiat:
-    #     contragent = await Contragent.get_or_create({"name": }, ex=self.ex_client.ex, exid=self.agent.contragent.exid)
+    #     actor = await Actor.get_or_create({"name": }, ex=self.ex_client.ex, exid=self.agent.actor.exid)
     #     FiatPydIn()
     #     fiat_db: Fiat = (await self.fiat_pyd2db(fiat, self.agent.user_id))[0]
     #     if not (fiatex := Fiatex.get_or_none(fiat=fiat_db, ex=self.agent.ex)):

{xync_client-0.0.25.dev19 → xync_client-0.0.25.dev22}/xync_client/BingX/base.py

@@ -1,7 +1,7 @@
-import os
 import subprocess
 from datetime import datetime
 from json import dumps
+from os.path import dirname
 from uuid import uuid4
 
 from xync_client.Abc.Base import BaseClient
@@ -12,12 +12,7 @@ class BaseBingXClient(BaseClient):
         traceid = str(uuid4()).replace("-", "")
         now = str(int(datetime.now().timestamp() * 1000))
         payload = dumps(_payload, separators=(",", ":"), sort_keys=True) if _payload else "{}"
-        prefs = {
-            "tests": "../xync_client/BingX/",
-            "xync_client": "BingX/",
-        }
-        pref = prefs.get(os.getcwd().split("/")[-1], "xync_client/BingX/")
-        p = subprocess.Popen(["node", pref + "req.mjs", now, traceid, payload], stdout=subprocess.PIPE)
+        p = subprocess.Popen(["node", dirname(__file__) + "/req.mjs", now, traceid, payload], stdout=subprocess.PIPE)
         sign = p.stdout.read().decode().strip()
         return {
             "sign": sign,

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

@@ -1,13 +1,16 @@
 from asyncio import run
 
 from x_model import init_db
-from xync_client.Abc.Base import DictOfDicts, FlatDict
 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
 
 
 class ExClient(BaseExClient, BaseBingXClient):
@@ -24,47 +27,42 @@ class ExClient(BaseExClient, BaseBingXClient):
         "x-requested-with": "XMLHttpRequest",
     }
 
-    async def _pms(self, cur):
+    async def _pms(self, cur) -> list[PmEpyd]:
         pms = await self._get("/api/c2c/v1/advert/payment/list", params={"fiat": cur})
-        return pms["data"]
+        return [PmEpyd(**pm) for pm in pms["data"]["paymentMethodList"]]
 
     # 19: Список всех платежных методов на бирже
-    async def pms(self) -> DictOfDicts:  # {pm.exid: pm}
-        curs = await self.curs()
-        pp = {}
-        for _id, cur in curs.items():
-            pms = await self._pms(cur)
-            [pp.update({p["id"]: {"name": p["name"], "logo": p["icon"]}}) for p in pms["paymentMethodList"]]
-        return pp
+    async def pms(self, cur: str = None) -> dict[int, PmPyd]:
+        all_pms = {}
+        for cur in await self.curs():
+            pms = await self._pms(cur.ticker)
+            for pm in pms:
+                all_pms[pm.id] = PmPyd(id=pm.id, name=pm.name, logo=pm.icon)
+        return all_pms
 
     # 20: Список поддерживаемых валют на BingX
-    async def curs(self) -> FlatDict:  # {cur.exid: cur.ticker}
+    async def curs(self) -> list[CurEpyd]:  # {cur.exid: cur.ticker}
         params = {
             "type": "1",
             "asset": "USDT",
             "coinType": "2",
         }
         curs = await self._get("/api/c2c/v1/common/supportCoins", params=params)
-        return {cur["id"]: cur["name"] for cur in curs["data"]["coins"]}
+        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):
-        curs = await self.curs()
-        pp = {}
-        for cur in curs.values():
-            pms = await self._pms(cur)
-            pp.update({cur: [p["id"] for p in pms["paymentMethodList"]]})
-        return pp
+        return {cur.exid: list(await self._pms(cur.exid)) for cur in await self.curs()}
 
     # 22: Монеты на BingX
     async def coins(self) -> FlatDict:
-        return {1: "USDT"}
+        return [CoinEpyd(exid="USDT", ticker="USDT")]
 
     # 23: Список пар валюта/монет
-    async def pairs(self):
+    async def pairs(self) -> MapOfIdsList:
         coins = await self.coins()
         curs = await self.curs()
-        return {cur: set(coins) for cur in curs.values()}
+        return {cur.exid: set(c.exid 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):
@@ -86,7 +84,6 @@ async def main():
     _ = await init_db(PG_DSN, models, True)
     bg = await Ex.get(name="BingX")
     cl = ExClient(bg)
-    # await cl.curs()
     await cl.pms()
     await cl.close()
 

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

@@ -0,0 +1,32 @@
+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.dev19 → xync_client-0.0.25.dev22}/xync_client/TgWallet/agent.py

@@ -43,7 +43,7 @@ from xync_schema.models import (
     Coinex,
     Pm,
     Order,
-    Contragent,
+    Actor,
 )
 from xync_schema.pydantic import FiatNew, BaseAdPydIn, AdBuyPydIn, AdSalePydIn, CredPydIn, OrderPydIn
 
@@ -81,8 +81,22 @@ class AgentClient(BaseAgentClient, AuthClient):
         orders = await self._post("/p2p/public-api/v2/offer/order/get", {"orderId": oid})
         return orders["data"]
 
-    @staticmethod
-    async def order_ad2epydin(ad: Ad, amount: float, cred_id: int) -> OrderEpydIn:
+    async def order_ad2epydin(self, ad: Ad, amount: float, cred_id: int = None) -> OrderEpydIn:
+        if not cred_id:  # i am taker
+            iam_maker = self.agent.actor_id == ad.maker_id
+            iam_seller = ad.direction.sell == iam_maker
+            cred_filter = (
+                {"actor__agent__user_id": self.agent.user_id}
+                if iam_seller
+                else {  # its a buy ad, i am taker
+                    "actor": ad.maker
+                }
+            )
+            await Cred.filter(
+                **cred_filter,
+                pmcur__pms__in=ad.pms,
+                # todo: ordering and filtering by fiat.amount-target
+            ).first() if iam_seller else 0
         await ad.fetch_related("direction__pairex__pair__cur")
         return OrderEpydIn(
             offerId=ad.exid,
@@ -103,16 +117,12 @@ class AgentClient(BaseAgentClient, AuthClient):
 
     async def order_epyd2pydin(self, order: OrderEpyd) -> OrderPydIn:
         ad = await Ad.get(exid=order.offerId, direction__pairex__ex=self.ex)
-        cred = await Cred.get(exid=order.paymentDetails.id, contragent__ex=self.ex)
-        iam_maker = self.agent.contragent == ad.maker
+        cred = await Cred.get(exid=order.paymentDetails.id, actor__ex=self.ex)
+        iam_maker = self.agent.actor == ad.maker
         taker = (
-            (
-                await Contragent.get(
-                    exid=(order.seller if order.is_sell == iam_maker else order.buyer).userId, ex=self.ex
-                )
-            )
+            (await Actor.get(exid=(order.seller if order.is_sell == iam_maker else order.buyer).userId, ex=self.ex))
             if iam_maker
-            else self.agent.contragent
+            else self.agent.actor
         )
         return OrderPydIn(
             exid=order.id,
@@ -185,7 +195,7 @@ class AgentClient(BaseAgentClient, AuthClient):
         cred_pin = CredPydIn(
             exid=fiat.id,
             pmcur=pmcur,
-            contragent=self.agent.contragent,
+            actor=self.agent.actor,
             name=fiat.name,
         )
         for val in fiat.attributes.values:
@@ -266,7 +276,7 @@ class AgentClient(BaseAgentClient, AuthClient):
 
     async def ad_epyd2pydin(self, ad_: OneAdTakerMakerSale | OneAdMakerBuy | OneAdTakerBuy) -> AdBuyPydIn | AdSalePydIn:
         ad_in: BaseAdPydIn = await self.ex_client.ad_common_epyd2pydin(ad_)
-        ad_in.maker = self.agent.contragent
+        ad_in.maker = self.agent.actor
         if isinstance(ad_, _PmsTrait):
             return AdBuyPydIn(
                 **ad_in.model_dump(),
@@ -292,7 +302,7 @@ class AgentClient(BaseAgentClient, AuthClient):
     async def my_ad(self, ad_id: int) -> OneAdMakerBuy | OneAdTakerMakerSale:
         ad = await self._post("/p2p/public-api/v2/offer/get-user-own", {"offerId": ad_id})
         ad: dict = ad["data"]
-        assert ad["user"]["userId"] == self.agent.contragent.exid, "Not your ad"
+        assert ad["user"]["userId"] == self.agent.actor.exid, "Not your ad"
         model = OneAdTakerMakerSale if ad["type"] == "SALE" else OneAdMakerBuy
         return model(**ad)
 
@@ -301,7 +311,7 @@ class AgentClient(BaseAgentClient, AuthClient):
     ) -> AdMakerNewSale | AdMakerNewBuy:
         coinex = await Coinex.get(coin=coin, ex=self.ex)
         curex = await Curex.get(ex=self.ex, cur=cur)
-        creds = await Cred.filter(contragent__agent__user_id=self.agent.user_id, pmcur__cur=cur).limit(5)
+        creds = await Cred.filter(actor__agent__user_id=self.agent.user_id, pmcur__cur=cur).limit(5)
         # todo: ordering and filtering by fiat.amount-target
         ad_ein = _AdNew(
             type="SALE" if is_sell else "PURCHASE",
@@ -320,7 +330,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 creds])
         else:
-            pmexs = await Pmex.filter(ex=self.agent.contragent.ex, pm__pmcurs__id__in=[c.pmcur_id for c in creds])
+            pmexs = await Pmex.filter(ex=self.agent.actor.ex, pm__pmcurs__id__in=[c.pmcur_id for c in creds])
             ad_ein = AdMakerNewBuy(**ad_ein.model_dump(exclude_none=True), paymentMethodCodes=[p.exid for p in pmexs])
         return ad_ein
 
@@ -414,10 +424,10 @@ async def main():
     maker: Agent
     taker: Agent
     maker, taker = (
-        await Agent.filter(contragent__ex_id=34, auth__isnull=False, user__status__gte=UserStatus.MEMBER)
+        await Agent.filter(actor__ex_id=34, auth__isnull=False, user__status__gte=UserStatus.MEMBER)
         .order_by("user_id")
         .limit(2)
-        .prefetch_related("contragent__ex")
+        .prefetch_related("actor__ex")
     )
     mcl: AgentClient = maker.client()
     tcl: AgentClient = taker.client()
@@ -436,10 +446,15 @@ async def main():
     await tcl.ad_switch(sad.id, True)
     await mcl.ad_switch(bad.id, True)
     sad_in = await tcl.ad_epyd2pydin(sad)
-    await Ad.create(**sad_in.model_dump(exclude_none=True))
+    sad_db = await Ad.create(**sad_in.model_dump(exclude_none=True))
     bad_in = await mcl.ad_epyd2pydin(bad)
     await Ad.create(**bad_in.model_dump(exclude_none=True))
 
+    order_epin: OrderEpydIn = await tcl.order_ad2epydin(sad_db, float(sad.orderAmountLimits.min))
+    new_order: OrderEpyd = await tcl.order_request(order_epin)
+    order_pin: OrderPydIn = await tcl.order_epyd2pydin(new_order)
+    _order_db = await tcl.order_pydin2db(order_pin)
+
     # order_epin: OrderEpydIn = await tcl.order_ad2epydin(ad_db, float(mad.orderAmountLimits.min), cred_ids[0])
     # new_order: OrderEpyd = await tcl.order_request(order_epin)
     # order_pin: OrderPydIn = await tcl.order_epyd2pydin(new_order)

{xync_client-0.0.25.dev19 → xync_client-0.0.25.dev22}/xync_client/TgWallet/auth.py

@@ -9,13 +9,11 @@ from xync_client.TgWallet.pyro import PyroClient
 class AuthClient(BaseAuthTrait, BaseClient):
     async def _get_auth_hdrs(self) -> dict[str, str]:
         if not self.agent:
-            self.agent = (
-                await Agent.filter(contragent__ex=self.ex, auth__isnull=False).prefetch_related("contragent").first()
-            )
+            self.agent = await Agent.filter(actor__ex=self.ex, auth__isnull=False).prefetch_related("actor").first()
         pyro = PyroClient(self.agent)
         init_data = await pyro.get_init_data()
         tokens = HttpClient("walletbot.me")._post("/api/v1/users/auth/", init_data)
-        self.agent.contragent.exid = tokens["user_id"]
-        await self.agent.contragent.save()
+        self.agent.actor.exid = tokens["user_id"]
+        await self.agent.actor.save()
         pref = "" if self.__class__.__name__ == "AssetClient" else "Bearer "
         return {"Wallet-Authorization": tokens["jwt"], "Authorization": pref + tokens["value"]}

{xync_client-0.0.25.dev19 → xync_client-0.0.25.dev22}/xync_client/TgWallet/ex.py

@@ -4,7 +4,7 @@ from x_model import init_db
 from xync_schema.pydantic import PmPyd, PmexBankPyd, CurEpyd, CoinEpyd, BaseAdPydIn, AdBuyPydIn
 
 from xync_schema import models
-from xync_schema.models import Ex, Direction, Pair, Coin, Cur, Pm, Contragent, PairEx
+from xync_schema.models import Ex, Direction, Pair, Coin, Cur, Pm, Actor, PairEx
 
 from xync_client.TgWallet.pyd import (
     PmEpydRoot,
@@ -123,7 +123,7 @@ class ExClient(BaseExClient, AuthClient):
 
     async def ad_taker_epyd2pydin(self, ad: _TakerOne) -> AdBuyPydIn:
         adx: BaseAdPydIn = await self.ad_common_epyd2pydin(ad)
-        adx.maker = (await Contragent.update_or_create({"name": ad.user.nickname}, ex=self.ex, exid=ad.user.userId))[0]
+        adx.maker = (await Actor.update_or_create({"name": ad.user.nickname}, ex=self.ex, exid=ad.user.userId))[0]
         pms = ad.paymentMethods if isinstance(ad, _PmsTrait) else [pd.paymentMethod for pd in ad.paymentDetails]
         return AdBuyPydIn(
             **adx.model_dump(), pms_=await Pm.filter(pmexs__ex=self.ex, pmexs__exid__in=[p.code for p in pms])

{xync_client-0.0.25.dev19 → xync_client-0.0.25.dev22}/xync_client/TgWallet/pyro.py

@@ -11,7 +11,6 @@ from xync_schema.models import Agent
 
 class PyroClient:
     def __init__(self, agent: Agent):
-        self.agent = agent
         self.app: Client = Client(str(agent.user_id), TG_API_ID, TG_API_HASH, session_string=agent.auth["sess"])
 
     async def get_init_data(self) -> dict:

xync_client-0.0.25.dev22/xync_client/pyro.py

@@ -0,0 +1,66 @@
+from asyncio import run
+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 src.loader import PG_DSN
+from tg_auth import UserStatus
+from x_model import init_db
+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_delete_messages=True,
+    can_manage_video_chats=True,  # Groups and supergroups only
+    can_restrict_members=True,
+    can_promote_members=True,
+    can_change_info=True,
+    can_invite_users=True,
+    can_pin_messages=True,  # Groups and supergroups only
+    can_manage_topics=True,  # Supergroups only
+    is_anonymous=True
+)
+
+
+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 with self.app as app:
+            app: Client
+            forum = 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"
+            try:
+                await forum.get_member(uid)
+            except UserNotParticipant:
+                added = False
+            await forum.promote_member("XyncNetBot", max_privs)
+            # await forum.leave()
+            return forum.id, added
+
+
+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
+    ).first()  # .order_by("-user__created_forums__count")
+    pcl = PyroClient(agent)
+    res = await pcl.create_orders_forum("cryrub")
+    print(res)
+
+
+if __name__ == "__main__":
+    from dotenv import load_dotenv
+    from os import getenv as env
+
+    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())

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

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

@@ -19,6 +19,7 @@ tests/_todo_refact/Wallet/test_agent.py
 tests/_todo_refact/Wallet/test_ex.py
 xync_client/__init__.py
 xync_client/loader.py
+xync_client/pyro.py
 xync_client.egg-info/PKG-INFO
 xync_client.egg-info/SOURCES.txt
 xync_client.egg-info/dependency_links.txt
@@ -43,6 +44,7 @@ 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