xync-client 0.0.145__tar.gz → 0.0.147__tar.gz

{xync_client-0.0.145/xync_client.egg-info → xync_client-0.0.147}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xync-client
-Version: 0.0.145
+Version: 0.0.147
 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.145 → xync_client-0.0.147}/xync_client/Abc/Agent.py

@@ -10,6 +10,7 @@ from xync_schema.xtype import BaseAd
 
 from xync_client.Abc.Ex import BaseExClient
 from xync_client.Abc.xtype import CredExOut, BaseOrderReq, BaseAdUpdate
+from xync_client.Gmail import GmClient
 
 
 class BaseAgentClient(HttpClient):
@@ -28,6 +29,7 @@ class BaseAgentClient(HttpClient):
         self.fbot = fbot
         self.agent: Agent = agent
         self.actor: Actor = agent.actor
+        self.gmail = GmClient(agent.actor.person.user)
         super().__init__(self.actor.ex.host_p2p, headers, cookies)
         self.ex_client: BaseExClient = self.actor.ex.client(fbot)
 

{xync_client-0.0.145 → xync_client-0.0.147}/xync_client/Abc/PmAgent.py

@@ -32,7 +32,7 @@ class PmAgentClient(HasAbotUid, metaclass=ABCMeta):
     ubot: FileClient | UserClient = None
     page: Page
     pages: type(StrEnum) = Pages
-    last_active: datetime = datetime.now()
+    last_active: datetime = now()
     with_userbot: bool = False
     _is_started: bool = False
 

{xync_client-0.0.145 → xync_client-0.0.147}/xync_client/Abc/xtype.py

@@ -53,7 +53,9 @@ class BaseOrderReq(BaseModel):
     asset_amount: float | None = None
     fiat_amount: float | None = None
 
-    # todo: mv from to base to special ex class
+    pm_id: int = (None,)
+
+    # todo: mv from base to special ex class
     amount_is_fiat: bool = True
     is_sell: bool = None
     cur_exid: int | str = None

{xync_client-0.0.145 → xync_client-0.0.147}/xync_client/Bybit/InAgent.py

@@ -77,7 +77,7 @@ class InAgentClient(BaseInAgentClient):
             while resp := await websocket.recv():
                 if data := json.loads(resp):
                     upd, order_db = None, None
-                    logging.info(f" {datetime.now().strftime('%H:%M:%S')} upd: {data.get('topic')}:{data.get('type')}")
+                    logging.info(f" {now().strftime('%H:%M:%S')} upd: {data.get('topic')}:{data.get('type')}")
                     match data.get("topic"):
                         case "OTC_ORDER_STATUS":
                             match data["type"]:
@@ -108,10 +108,11 @@ class InAgentClient(BaseInAgentClient):
                                                 if not (pmacdx := await self.get_pma_by_cdex(order)):
                                                     continue
                                                 pma, cdx = pmacdx
-                                                am, tid = pma.check_in(
+                                                am, tid = await pma.check_in(
                                                     Decimal(order.amount),
                                                     cdx.cred.pmcur.cur.ticker,
-                                                    datetime.fromtimestamp(float(order.createDate) / 1000),
+                                                    # todo: почему в московском час.поясе?
+                                                    datetime.fromtimestamp(float(order.transferDate) / 1000),
                                                 )
                                                 if not tid:
                                                     logging.info(
@@ -142,9 +143,13 @@ class InAgentClient(BaseInAgentClient):
                                                     if (
                                                         o["amount"] == order.amount
                                                         and o["id"] != upd.id
-                                                        and int(order.createDate) < int(o["createDate"]) + 900 * 000
-                                                        # todo: get full_order from o, and cred or pm from full_order:
-                                                        # and o['paymentTermList'][0].accountNo == order.paymentTermList[0].accountNo
+                                                        and int(order.createDate)
+                                                        < int(o["createDate"]) + 15 * 60 * 1000
+                                                        # get full_order from o, and cred or pm from full_order:
+                                                        and self.agent_client.api.get_order_details(orderId=o["id"])[
+                                                            "result"
+                                                        ]["paymentTermList"][0]["accountNo"]
+                                                        == order.paymentTermList[0].accountNo
                                                     )
                                                 ]
                                                 curex = await models.CurEx.get(
@@ -155,7 +160,7 @@ class InAgentClient(BaseInAgentClient):
                                                     cred_id=order_db.cred_id,
                                                     amount=int(float(order.amount) * 10**curex.scale),
                                                     status__not_in=[OrderStatus.completed, OrderStatus.canceled],
-                                                    created_at__gt=now() - timedelta(hours=1),
+                                                    created_at__gt=now() - timedelta(minutes=15),
                                                 )
                                                 if pos or pos_db:
                                                     await self.agent_client.ex_client.bot.send(
@@ -169,10 +174,10 @@ class InAgentClient(BaseInAgentClient):
                                                 # !!! ОТПРАВЛЯЕМ ДЕНЬГИ !!!
                                                 self.agent_client.api.release_assets(orderId=upd.id)
                                                 logging.info(
-                                                    f"Order {order.id} created, paid before #{tid}:{am} at {order.createDate}, and RELEASED at {datetime.now()}"
+                                                    f"Order {order.id} created, paid before #{tid}:{am} at {order.createDate}, and RELEASED at {now()}"
                                                 )
                                             elif upd.side == 1:  # я покупатель - ждем мою оплату
-                                                continue  # logging.warning(f"Order {order.id} PAID at {datetime.now()}: {int_am}")
+                                                continue  # logging.warning(f"Order {order.id} PAID at {now()}: {int_am}")
                                             else:
                                                 ...
                                             # todo: check is always canceling
@@ -416,7 +421,7 @@ async def main():
             actor__person__user__status=UserStatus.ACTIVE,
             actor__person__user__pm_agents__isnull=False,
         )
-        .prefetch_related("actor__ex", "actor__person__user")
+        .prefetch_related("actor__ex", "actor__person__user__gmail")
         .first()
     )
     pm_agents = await models.PmAgent.filter(
@@ -434,7 +439,7 @@ async def main():
         # payeer_cl = Client(actor.person.user.username_id)
         for pma in pm_agents:
             pcl: PmAgentClient = pma.client(bbot)
-            cl.pmacs[pma.pm_id] = await pcl.start(await async_playwright().start(), True)
+            cl.pmacs[pma.pm_id] = await pcl.start(await async_playwright().start(), False)
         try:
             _ = await cl.start_listen()
         except Exception as e:

{xync_client-0.0.145 → xync_client-0.0.147}/xync_client/Bybit/agent.py

@@ -31,7 +31,7 @@ from xync_schema.enums import OrderStatus
 from xync_schema.models import Actor, Cond, CondSim, PmCur, PairSide, Agent
 
 from xync_client.Abc.Agent import BaseAgentClient
-from xync_client.Abc.xtype import BaseOrderReq, FlatDict
+from xync_client.Abc.xtype import FlatDict, BaseOrderReq
 from xync_client.Bybit.etype.ad import AdPostRequest, AdUpdateRequest, Ad, AdStatus
 from xync_client.Bybit.etype.cred import CredEpyd
 from xync_client.Bybit.etype.order import (
@@ -43,6 +43,8 @@ from xync_client.Bybit.etype.order import (
     OrderFull,
     Message,
     Status,
+    OrderSellRequest,
+    TakeAdReq,
 )
 from xync_client.loader import TORM, NET_TOKEN, PAY_TOKEN
 
@@ -273,20 +275,39 @@ class AgentClient(BaseAgentClient):  # Bybit client
         security_risk_token = data["result"]["securityRiskToken"]
         return security_risk_token
 
-    def _check_2fa(self, risk_token):
-        # 2fa code
-        bybit_secret = self.agent.auth["2fa"]
-        totp = pyotp.TOTP(bybit_secret)
-        totp_code = totp.now()
-
-        res = self._post(
-            "/user/public/risk/verify", {"risk_token": risk_token, "component_list": {"google2fa": totp_code}}
+    async def _check_2fa(self, risk_token) -> int:
+        cres = await self._post("/user/public/risk/components", {"risk_token": risk_token})
+        if cres["ret_msg"] != "success":
+            raise HTTPException("get")
+        cres = cres["result"]["component_list"]
+        res = await self._post(
+            "/user/public/risk/verify",
+            {
+                "risk_token": risk_token,
+                "component_list": {c["component_id"]: self.__get_2fa(c["component_id"]) for c in cres},
+            },
         )
         if res["ret_msg"] != "success":
-            print("Wrong 2fa, wait 5 secs and retry..")
-            sleep(5)
-            self._check_2fa(risk_token)
-        return res
+            logging.error("Wrong 2fa, wait 5 secs and retry..")
+            await sleep(5)
+            await self._check_2fa(risk_token)
+        return res["ret_code"]
+
+    async def __get_2fa(self, typ: Literal["google2fa", "email_verify", "payment_password_verify"], rt: str = None):
+        if typ == "google2fa":
+            bybit_secret = self.agent.auth["2fa"]
+            totp = pyotp.TOTP(bybit_secret)
+            return totp.now()
+        elif typ == "email_verify":
+            res = await self._post("/user/public/risk/send/code", {"risk_token": rt, "component_id": "email_verify"})
+            if res["ret_msg"] != "success":
+                return self.gmail.bybit_code()
+            elif cool_down := int(res["result"]["cool_down"]):
+                await sleep(cool_down)
+                return self.gmail.bybit_code()
+        elif typ == "payment_password_verify":
+            return self.agent.auth["pass"]
+        raise Exception("2fa fail")
 
     def _post_ad(self, risk_token: str):
         self.create_ad_body.update({"securityRiskToken": risk_token})
@@ -340,27 +361,56 @@ class AgentClient(BaseAgentClient):  # Bybit client
         data = self.api.remove_ad(itemId=ad_id)
         return data
 
-    async def order_request(self, br: BaseOrderReq) -> OrderResp:
-        res0 = await self._post("/fiat/otc/item/simple", data={"item_id": str(br.ad_id)})
-        if res0["ret_code"] == 0:
-            res0 = res0["result"]
-        res0 = PreOrderResp.model_validate(res0)
+    async def __preorder_request(self, ad_id: int) -> PreOrderResp:
+        res = await self._post("/fiat/otc/item/simple", data={"item_id": str(ad_id)})
+        if res["ret_code"] == 0:
+            res = res["result"]
+        return PreOrderResp.model_validate(res)
+
+    async def __order_request_build(self, por: PreOrderResp, br: BaseOrderReq) -> OrderRequest:
         req = OrderRequest(
-            itemId=br.ad_id,
+            itemId=por.id,
             tokenId=br.coin_exid,
             currencyId=br.cur_exid,
-            side=str(OrderRequest.Side(int(br.is_sell))),
-            amount=str(br.fiat_amount or br.asset_amount * float(res0.price)),
-            curPrice=res0.curPrice,
-            quantity=str(br.asset_amount or round(br.fiat_amount / float(res0.price), br.coin_scale)),
-            flag="amount" if br.amount_is_fiat else "quantity",
+            side="1" if br.is_sell else "0",
+            amount=str(br.fiat_amount),
+            curPrice=por.curPrice,
+            quantity=str(round(br.fiat_amount / float(por.price), br.coin_scale)),
+            flag="amount",
+            # paymentType="51",
+            # paymentId="20399134",
+            # online="0"
         )
+        if br.is_sell:
+            credex = await models.CredEx.get(
+                cred__person_id=self.actor.person_id,
+                pmcur__pm__pmexs__exid=por.payments[0],
+                pmcur__pm__pmexs__ex_id=self.ex_client.ex.id,
+                pmcur__cur_id=br.cur_exid,
+            )
+            req = OrderSellRequest(**req.model_dump(), paymentType=por.payments[0], paymentId=str(credex.exid))
+        return req
+
+    async def _order_request(self, bor: BaseOrderReq) -> OrderResp:
+        por: PreOrderResp = await self.__preorder_request(bor.ad_id)
+        req: OrderRequest | OrderSellRequest = await self.__order_request_build(por, bor)
         # вот непосредственно сам запрос на ордер
-        res = await self._post("/fiat/otc/order/create", data=req.model_dump())
+        return await self.__order_create(req, bor)
+
+    async def __order_create(self, req: OrderRequest | OrderSellRequest, bor: BaseOrderReq) -> OrderResp:
+        res: dict = await self._post("/fiat/otc/order/create", data=req.model_dump())
         if res["ret_code"] == 0:
-            return OrderResp.model_validate(res["result"])
+            resp = OrderResp.model_validate(res["result"])
         elif res["ret_code"] == 912120030 or res["ret_msg"] == "The price has changed, please try again later.":
-            return await self.order_request(br)
+            resp = await self._order_request(bor)
+        if not resp.orderId and resp.needSecurityRisk:
+            if rc := await self._check_2fa(resp.securityRiskToken):
+                await self.bbot.send(self.actor.person.user.username_id, f"Bybit 2fa: {rc}")
+                raise Exception(f"Bybit 2fa: {rc}")
+            # еще раз уже с токеном
+            req.securityRiskToken = resp.securityRiskToken
+            resp = await self.__order_create(req, bor)
+        return resp
 
     async def cancel_order(self, order_id: str) -> bool:
         cr = CancelOrderReq(orderId=order_id)
@@ -546,7 +596,7 @@ class AgentClient(BaseAgentClient):  # Bybit client
             to = ((odb.payed_at or odb.created_at) + timedelta(minutes=180 + 30)).isoformat(sep=" ").split("+")[0]
             tsa = [
                 t
-                for tid, t in self.hist.items()
+                for tid, t in (self.hist.items() if self.hist else [])
                 if (ecredex.accountNo == t["to"] and t["from"] != "@merchant" and frm < t["date"] < to)
             ]
             buyer_person = (
@@ -1185,6 +1235,20 @@ class AgentClient(BaseAgentClient):  # Bybit client
 
         self.tree = tree
 
+    async def take_ad(self, req: TakeAdReq):
+        ad: Ad = Ad.model_validate(self.api.get_ad_details(itemId=req.ad_id))
+        bor = BaseOrderReq(
+            ad_id=str(ad.id),
+            fiat_amount=req.amount,
+            is_sell=bool(ad.side),
+            cur_exid=ad.currencyId,
+            coin_exid=ad.tokenId,
+            coin_scale=ad.token.scale,
+            pm_id=req.pm_id,
+        )
+        resp: OrderResp = await self._order_request(bor)
+        return resp
+
 
 def ms2utc(msk_ts_str: str):
     return datetime.fromtimestamp(int(msk_ts_str) / 1000, timezone(timedelta(hours=3), name="MSK"))
@@ -1262,20 +1326,20 @@ async def main():
         else:  # параметры гонки изменены
             ...
 
-    actor = (
+    agent = (
         await models.Agent.filter(actor__ex_id=4, auth__isnull=False, active=True)
-        .prefetch_related("actor__ex", "actor__person__user")
+        .prefetch_related("actor__ex", "actor__person__user__gmail")
         .first()
     )
     filebot = FileClient(NET_TOKEN)
     await filebot.start()
     # b.add_handler(MessageHandler(cond_start_handler, command("cond")))
-    cl: AgentClient = actor.client(filebot, XyncBot(PAY_TOKEN, cn))
+    cl: AgentClient = agent.client(filebot, XyncBot(PAY_TOKEN, cn))
 
     # await cl.ex_client.set_pairs()
     # await cl.ex_client.set_pms()
-    # await cl.set_creds()
-    # await cl.export_my_ads()
+    await cl.set_creds()
+    await cl.export_my_ads()
 
     # создание гонок по мои активным объявам:
     # for ma in cl.my_ads():
@@ -1323,7 +1387,7 @@ async def main():
     # )
     # await cl.get_api_orders()  # 43, 1741294800000, 1749157199999)
 
-    races = await models.Race.filter(started=True).prefetch_related(
+    races = await models.Race.filter(started=True, road__ad__maker_id=agent.actor_id).prefetch_related(
         "road__ad__pair_side__pair__cur",
         "road__ad__pms",
     )
@@ -1335,20 +1399,10 @@ async def main():
             # cl.get_api_orders(),  # 10, 1738357200000, 1742504399999
         )
     except Exception as e:
-        await filebot.send("🤬Bybit agent CRASHED!!!🤬", actor.person.user.username_id)
-        await filebot.send(e.__repr__(), actor.person.user.username_id)
+        await filebot.send("🤬Bybit agent CRASHED!!!🤬", agent.actor.person.user.username_id)
+        await filebot.send(e.__repr__(), agent.actor.person.user.username_id)
         raise e
-    # bor = BaseOrderReq(
-    #     ad_id="1861440060199632896",
-    #     # asset_amount=40,
-    #     fiat_amount=3000,
-    #     amount_is_fiat=True,
-    #     is_sell=False,
-    #     cur_exid=rub.exid,
-    #     coin_exid=usdt.exid,
-    #     coin_scale=usdt.coin.scale,
-    # )
-    # res: OrderResp = await cl.order_request(bor)
+
     # await cl.cancel_order(res.orderId)
     await filebot.stop()
     await cl.close()

{xync_client-0.0.145 → xync_client-0.0.147}/xync_client/Bybit/etype/order.py

@@ -1,4 +1,3 @@
-from datetime import datetime
 from enum import IntEnum
 from typing import Literal
 
@@ -45,6 +44,12 @@ class StatusApi(IntEnum):
     waiting_for_objection = 110
 
 
+class TakeAdReq(BaseModel):
+    ad_id: int | str
+    amount: float
+    pm_id: int = None
+
+
 class OrderRequest(BaseModel):
     class Side(IntEnum):
         BUY = 0
@@ -60,33 +65,46 @@ class OrderRequest(BaseModel):
     flag: Literal["amount", "quantity"]
     version: str = "1.0"
     securityRiskToken: str = ""
+    isFromAi: bool = False
+
+
+class OrderSellRequest(OrderRequest):
+    paymentId: str
+    paymentType: str
 
 
 class PreOrderResp(BaseModel):
-    price: str  # float
-    curPrice: str
-    totalAmount: float
-    minAmount: float
-    maxAmount: float
-    minQuantity: float
-    maxQuantity: float
+    id: str  # bigint
+    price: str  # float .cur.scale
+    lastQuantity: str  # float .coin.scale
+    curPrice: str  # hex 32
+    lastPrice: str  # float .cur.scale # future
+    isOnline: bool
+    lastLogoutTime: str  # timestamp(0)+0
     payments: list[str]  # list[int]
     status: Literal[10, 20]
-    paymentTerms: list
-    paymentPeriod: Literal[15]
-    lastQuantity: float
-    lastPrice: float
-    isOnline: bool
-    lastLogoutTime: datetime
-    itemPriceAvailableTime: datetime
-    itemPriceValidTime: int  # 45000
+    paymentTerms: list  # empty
+    paymentPeriod: Literal[15, 30, 60]
+    totalAmount: str  # float .cur.scale
+    minAmount: str  # float .cur.scale
+    maxAmount: str  # float .cur.scale
+    minQuantity: str  # float .coin.scale
+    maxQuantity: str  # float .coin.scale
+    itemPriceAvailableTime: str  # timestamp(0)+0
+    itemPriceValidTime: Literal["45000"]
     itemType: Literal["ORIGIN"]
+    shareItem: bool  # False
 
 
 class OrderResp(BaseModel):
     orderId: str
     isNeedConfirm: bool
+    confirmId: str = ""
     success: bool
+    securityRiskToken: str = ""
+    riskTokenType: Literal["challenge"] = None
+    riskVersion: Literal["1", "2"] = None
+    needSecurityRisk: bool
     isBulkOrder: bool
     confirmed: str = None
     delayTime: str

{xync_client-0.0.145 → xync_client-0.0.147}/xync_client/Gmail/__init__.py

@@ -92,8 +92,8 @@ class GmClient(HasAbotUid):
 
         return {"id": message_id, "subject": subject, "from": from_email, "date": date, "body": body}
 
-    async def mail_confirm(self, amount: float, dt: datetime):
-        if email := self._get_last_email("Volet.com", "Please Confirm Withdrawal"):
+    async def volet_confirm(self, amount: float, dt: datetime):
+        if email := self._get_last_email("noreply@volet.com", "Please Confirm Withdrawal"):  # "Volet.com"
             date = datetime.strptime(email["date"].split(",")[1].split(" +")[0], "%d %b %Y %H:%M:%S")
             if match := re.search(r"Amount: <b>([\d.]+) [A-Z]{3}</b>", email["body"]):
                 amt = float(match.group(1))
@@ -107,6 +107,19 @@ class GmClient(HasAbotUid):
         await self.receive("А нет запросов от волета")
         return False
 
+    async def bybit_code(self, dt: datetime) -> str | None:
+        if email := self._get_last_email("Bybit", "[Bybit]Security Code for Your Bybit Account"):
+            date = datetime.strptime(email["date"].split(",")[1].split(" +")[0], "%d %b %Y %H:%M:%S")
+            if match := re.search(r'<span style="font-size:28pt;color:#ff9c2e">(\d{6})</span>', email["body"]):
+                code = match.group(1)
+
+        if email and date > dt and code:
+            get(f"https://account.volet.com/verify/{code}")
+            return code
+
+        await self.receive("А нет запросов от волета")
+        return None
+
 
 async def _test():
     from x_model import init_db
@@ -115,7 +128,7 @@ async def _test():
 
     gm = await Gmail.get(id=1).prefetch_related("user__username")
     gmc = GmClient(gm)
-    await gmc.mail_confirm(amount=90, dt=datetime.now())
+    await gmc.volet_confirm(amount=90, dt=datetime.now())
 
 
 if __name__ == "__main__":

{xync_client-0.0.145 → xync_client-0.0.147}/xync_client/Pms/Payeer/__init__.py

@@ -22,6 +22,7 @@ from playwright.async_api import async_playwright, Playwright, Error
 
 # noinspection PyProtectedMember
 from playwright._impl._errors import TimeoutError
+from tortoise.timezone import now
 from xync_bot import XyncBot
 from xync_schema.models import TopUp, TopUpAble, PmAgent, Transfer
 
@@ -139,7 +140,7 @@ class Client(PmAgentClient):
     async def send(self, t: Transfer) -> tuple[str, bytes] | float:
         dest, cur = t.order.cred.detail, t.order.cred.pmcur.cur.ticker
         amount = round(t.order.amount * 10**-t.order.cred.pmcur.cur.scale, t.order.cred.pmcur.cur.scale)
-        self.last_active = datetime.now()
+        self.last_active = now()
         page = self.page
         if not page.url.startswith(self.pages.SEND):
             try:
@@ -181,7 +182,7 @@ class Client(PmAgentClient):
                 await page.click(f".history-id-{trans_num} a.link")
                 sleep(1)
                 receipt = await page.query_selector(".ui-dialog.ui-corner-all")
-                return trans_num, await receipt.screenshot(path=f"tmp/{trans_num}.png")
+                return trans_num, receipt and await receipt.screenshot(path=f"tmp/{trans_num}.png")
             else:
                 await self.receive("Payeer хз", photo=await self.page.screenshot())
                 return -1
@@ -192,10 +193,10 @@ class Client(PmAgentClient):
             )
             return has_amount
 
-    def check_in(
+    async def check_in(
         self, amount: Decimal | int | float, cur: str, dt: datetime = None, tid: str | int = None
     ) -> tuple[Decimal | None, int | None]:
-        history = self.api.history(type="incoming", append=tid, count=3)
+        history = self.api.history(type="incoming", count=10)
         if tid:
             return (t := history.get(tid)) and Decimal(t["creditedAmount"])
         ts: list[dict] = [
@@ -204,7 +205,8 @@ class Client(PmAgentClient):
             if (
                 amount <= Decimal(h["creditedAmount"]) <= ceil(amount)
                 and h["creditedCurrency"] == cur
-                and datetime.fromisoformat(h["date"]) > dt - timedelta(minutes=1)
+                # todo: wrong tz
+                and datetime.fromisoformat(h["date"]) > dt - timedelta(minutes=3)  # +180(tz)-5
             )
         ]
         if not (t := ts and ts[0]):

{xync_client-0.0.145 → xync_client-0.0.147}/xync_client/Pms/Volet/__init__.py

@@ -174,7 +174,7 @@ class Client(PmAgentClient):
         elif self.agent.user.username.session:
             if not (code := await self.wait_for_code(volet_bot_id, topic, hg)):
                 if 1:  # todo: Is mail_confirm required?
-                    if _mcr := await self.gmail.mail_confirm(amount, t.updated_at):
+                    if _mcr := await self.gmail.volet_confirm(amount, t.updated_at):
                         ...
                         # todo: click Continue
                     if not (code := await self.wait_for_code(volet_bot_id, topic, hg)):

{xync_client-0.0.145 → xync_client-0.0.147/xync_client.egg-info}/PKG-INFO

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