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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: xync-client
-Version: 0.0.25.dev19
+Version: 0.0.25.dev20
 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.dev20}/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.dev20}/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.dev20}/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.dev20}/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.dev20}/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.dev20}/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.dev19 → xync_client-0.0.25.dev20/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.dev20
 Author-email: Mike Artemiev <mixartemev@gmail.com>
 Project-URL: Homepage, https://gitlab.com/XyncNet/client
 Project-URL: Repository, https://gitlab.com/XyncNet/client