xync-client 0.0.57.dev22__tar.gz → 0.0.57.dev24__tar.gz

{xync_client-0.0.57.dev22/xync_client.egg-info → xync_client-0.0.57.dev24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xync-client
-Version: 0.0.57.dev22
+Version: 0.0.57.dev24
 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.57.dev22 → xync_client-0.0.57.dev24}/xync_client/Bybit/agent.py

@@ -79,9 +79,10 @@ class AgentClient(BaseAgentClient):  # Bybit client
         "actionType": "MODIFY",
         "securityRiskToken": "",
     }
-    all_conds: dict[int, tuple[str, set[str]]] = {}
-    cond_sims: dict[int, tuple[int, int]] = {}
-    sim_conds: dict[int, set[int]] = defaultdict(set)  # backward
+    all_conds: dict[int, tuple[str, set[int]]] = {}
+    cond_sims: dict[int, int] = defaultdict(set)
+    rcond_sims: dict[int, set[int]] = defaultdict(set)  # backward
+    tree: dict = {}
 
     def __init__(self, actor: Actor, bot: FileClient, **kwargs):
         super().__init__(actor, bot, **kwargs)
@@ -444,13 +445,15 @@ class AgentClient(BaseAgentClient):  # Bybit client
                         )
                     ):
                         extr = ", ".join(
-                            [
+                            x
+                            for xtr in [
                                 ecredex.bankName,
                                 ecredex.branchName,
                                 ecredex.qrcode,
                                 ecredex.payMessage,
                                 ecredex.paymentExt1,
                             ]
+                            if (x := xtr.strip())
                         )
                         crd = await models.Cred.create(
                             detail=ecredex.accountNo,
@@ -476,9 +479,9 @@ class AgentClient(BaseAgentClient):  # Bybit client
                     "appealed_at": o.status == 30 and int(order.updateDate[:-3]) or None,
                     "cred_id": ecredex.paymentType and credex.cred_id or None,
                     "taker": taker,
+                    "ad": ad_db,
                 },
                 exid=o.id,
-                ad=ad_db,
             )
             dmsgs = self.api.get_chat_messages(orderId=oid, size=200)["result"]["result"][::-1]
             msgs = [Message.model_validate(m) for m in dmsgs if m["msgType"] in (1, 2, 7, 8)]
@@ -727,36 +730,62 @@ class AgentClient(BaseAgentClient):  # Bybit client
             ad_db.cond.raw_txt = cleaned
             self.all_conds[ad_db.cond_id] = cleaned, {ad_db.maker.exid}
             await ad_db.cond.save()
-            await self.sim_upd(ad_db.cond_id, cleaned)
+            await self.sim_check_rels(ad_db.cond_id, cleaned)
             return ad_db, False
 
-        # находим все старые тексты похожие на 90% и более
-        if _sims := {
-            old_cid: (txt, sim)
-            for old_cid, (txt, uids) in self.all_conds.items()
-            if len(cleaned) > 15 and ad.userId not in uids and (sim := get_sim(cleaned, txt))
-        }:
-            # если есть, берем самый похожий из них
-            old_cid, (txt, sim) = max(_sims.items(), key=lambda x: x[1][1])
-            old_ads = await models.Ad.filter(cond_id=old_cid, maker__exid=int(ad.userId)).prefetch_related("cond")
-            for old_ad in old_ads:
-                # и у этого чела есть объява с почти таким же текстом
-                if old_ad.exid == int(ad.id):  # и он изменил текст как раз в ней
-                    # заменяем текст без создания нового cond
-                    await old_ad.cond.update_or_create(raw_txt=cleaned)
-                    await old_ad.fetch_related("cond")
-                    return old_ad, False
-                # но это не она, значит у него есть другая объява с похожим, но чуть отличающимся текстом
-                logging.warning(f"ad#{ad.id}-cond#{old_cid} txt updated:\n{txt}\n|\nV\n{cleaned}")
-
         new_cond = await Cond.create(raw_txt=cleaned)
-        self.all_conds[new_cond.id] = new_cond.raw_txt, {ad.userId}
+        # находим все старые тексты похожие на 90% и более
+        old_cid, sim = await self.cond_get_max_sim(new_cond.id, new_cond.raw_txt, {int(ad.userId)})
+        # old_ads = await models.Ad.filter(cond_id=old_cid, maker__exid=int(ad.userId)).prefetch_related("cond")
+        # for old_ad in old_ads:
+        #     # и у этого чела есть объява с почти таким же текстом
+        #     if old_ad.exid == int(ad.id):  # и он изменил текст как раз в ней
+        #         # заменяем текст без создания нового cond
+        #         await old_ad.cond.update_or_create(raw_txt=cleaned)
+        #         await old_ad.fetch_related("cond")
+        #         return old_ad, False
+        #     # но это не она, значит у него есть другая объява с похожим, но чуть отличающимся текстом
+        #     logging.warning(f"ad#{ad.id}-cond#{old_cid} txt updated:\n{txt}\n|\nV\n{cleaned}")
+
+        self.all_conds[new_cond.id] = new_cond.raw_txt, {int(ad.userId)}
         # если нашелся похожий текст у другого юзера, добавим связь с % похожести
         if sim:
-            await self.sim_new(new_cond.id, sim, old_cid)
+            await CondSim.create(cond_id=new_cond.id, similarity=sim, cond_rel_id=old_cid)
 
         return await self.ad_create(ad, new_cond.id), True
 
+    def find_in_tree(self, cid: int, old_cid: int) -> bool:
+        if p := self.cond_sims.get(old_cid):
+            if p == cid:
+                return True
+            return self.find_in_tree(cid, p)
+        return False
+
+    async def cond_get_max_sim(self, cid: int, txt: str, uids: set[int]) -> tuple[int | None, int | None]:
+        # находим все старые тексты похожие на 90% и более
+        sims: dict[int, int] = {}
+        for old_cid, (old_txt, old_uids) in self.all_conds.items():
+            if len(old_txt) < 15 or cid == old_cid or uids == old_uids:
+                continue
+            elif self.cond_sims.get(cid) == old_cid:
+                continue
+            elif self.cond_sims.get(old_cid) == cid:
+                continue
+            elif cid in self.rcond_sims.get(old_cid, {}):
+                continue
+            elif old_cid in self.rcond_sims.get(cid, {}):
+                continue
+            elif self.find_in_tree(cid, old_cid):
+                continue
+            if sim := get_sim(txt, old_txt):
+                sims[old_cid] = sim
+        # если есть, берем самый похожий из них
+        if sims:
+            old_cid, sim = max(sims.items(), key=lambda x: x[1])
+            await sleep(0.3)
+            return old_cid, sim
+        return None, None
+
     async def person_upsert(self, name: str, exid: int) -> models.Person:
         if actor := await models.Actor.get_or_none(exid=exid, ex=self.ex_client.ex).prefetch_related("person"):
             if not actor.person:
@@ -796,24 +825,75 @@ class AgentClient(BaseAgentClient):  # Bybit client
             return None
         return await CondSim.create(cond_id=new_cid, similarity=sim, cond_rel_id=old_cid)
 
-    async def sim_upd(self, cid: int, new_txt: int):
-        for sim_db in (_sims := await CondSim.filter(Q(join_type="OR", cond_id=cid, cond_rel_id=cid))):
-            (op,) = {sim_db.cond_id, sim_db.cond_rel_id} - {cid}
-            op_cond = await Cond[op]
-            sim_db.similarity = get_sim(new_txt, op_cond.raw_txt)
-            await sim_db.save()
+    async def sim_check_rels(self, cid: int, new_txt: int):
+        if _old_sims := await CondSim.filter(Q(join_type="OR", cond_id=cid, cond_rel_id=cid)):
+            for sim_db in _old_sims:
+                (op,) = {sim_db.cond_id, sim_db.cond_rel_id} - {cid}
+                op_cond = await Cond[op]
+                sim_db.similarity = get_sim(new_txt, op_cond.raw_txt)
+                await sim_db.save()
+
+    def build_tree(self):
+        set(self.cond_sims.keys()) | set(self.cond_sims.values())
+        tree = defaultdict(dict)
+        # Группируем родителей по детям
+        for child, par in self.cond_sims.items():
+            tree[par] |= {child: {}}  # todo: make from self.rcond_sim
+
+        # Строим дерево снизу вверх
+        def subtree(node):
+            if not node:
+                return node
+            for key in node:
+                subnode = tree.pop(key, {})
+                d = subtree(subnode)
+                node[key] |= d  # actual tree rebuilding here!
+            return node  # todo: refact?
+
+        # Находим корни / без родителей
+        roots = set(self.cond_sims.values()) - set(self.cond_sims.keys())
+        for root in roots:
+            _ = subtree(tree[root])
+
+        self.tree = tree
 
     async def actual_cond(self):
-        self.all_conds = {
-            c.id: (c.raw_txt, {str(a.maker.exid) for a in c.ads})
-            for c in await Cond.all().prefetch_related("ads__maker")
-        }
-        self.cond_sims = {cs.cond_id: (cs.cond_rel_id, cs.similarity) for cs in await CondSim.all()}
-        for c, (o, s) in self.cond_sims.items():
-            self.sim_conds[o].add(c)
-        for ad_db in await models.Ad.filter(direction__pairex__ex=self.ex_client.ex).prefetch_related("cond", "maker"):
-            ad = Ad(id=str(ad_db.exid), userId=str(ad_db.maker.exid), remark=ad_db.cond.raw_txt)
-            await self.cond_upsert(ad, force=True)
+        for curr, old in await CondSim.all().values_list("cond_id", "cond_rel_id"):
+            self.cond_sims[curr] = old
+            self.rcond_sims[old] |= {curr}
+        self.build_tree()
+        for cid, (txt, uids) in self.all_conds.items():
+            old_cid, sim = await self.cond_get_max_sim(cid, txt, uids)
+            if sim:
+                if old_sim := await CondSim.get_or_none(cond_id=cid):
+                    if old_sim.cond_rel_id != old_cid:
+                        if sim <= old_sim.similarity:
+                            # old_rsim = await CondSim.get_or_none(cond_id=old_cid)
+                            # if not old_rsim:
+                            #     await CondSim.create(cond_id=old_cid, cond_rel_id=cid, similarity=sim)
+                            #     self.cond_sims[old_cid] = cid
+                            #     self.rcond_sims[cid] |= {old_cid}
+                            #     # self.add_to_tree(old_cid, cid, self.tree)
+                            # elif old_rsim.similarity < sim:
+                            #     await CondSim.update_or_create({"cond_rel_id": cid, "similarity": sim}, cond_id=old_cid)
+                            #     self.cond_sims[old_cid] = cid
+                            #     self.rcond_sims[cid] |= {old_cid}
+                            #     self.rcond_sims[old_rsim.cond_rel_id].remove(old_rsim.cond_id)
+                            #     logging.warning(f'{old_cid}: {old_sim.similarity}->{sim} ({old_sim.cond_rel_id}->{cid})')
+                            continue
+                        logging.warning(f"R {cid}: {old_sim.similarity}->{sim} ({old_sim.cond_rel_id}->{old_cid})")
+                        await old_sim.update_from_dict({"similarity": sim, "old_rel_id": old_cid}).save()
+                    elif sim != old_sim.similarity:
+                        logging.info(f"{cid}: {old_sim.similarity}->{sim}")
+                        await old_sim.update_from_dict({"similarity": sim}).save()
+                else:
+                    await CondSim.create(cond_id=cid, cond_rel_id=old_cid, similarity=sim)
+                    self.cond_sims[cid] = old_cid
+                    self.rcond_sims[old_cid] |= {cid}
+                    # self.add_to_tree(cid, old_cid, self.tree)
+            # for ad_db in await models.Ad.filter(direction__pairex__ex=self.ex_client.ex).prefetch_related("cond", "maker"):
+            #     ad = Ad(id=str(ad_db.exid), userId=str(ad_db.maker.exid), remark=ad_db.cond.raw_txt)
+            #     await self.cond_upsert(ad, force=True)
 
     async def get_credexs_by_norms(self, norms: list[str], cur_id: int) -> dict[models.Pmex, models.CredEx] | None:
         try:
@@ -831,7 +911,7 @@ class AgentClient(BaseAgentClient):  # Bybit client
 
 
 def get_sim(s1, s2) -> int:
-    sim = int((SequenceMatcher(None, s1, s2).ratio() - 0.9) * 10_000)
+    sim = int((SequenceMatcher(None, s1, s2).ratio() - 0.6) * 10_000)
     return sim if sim > 0 else 0
 
 
@@ -888,49 +968,64 @@ async def main():
     actor = (
         await models.Actor.filter(ex_id=9, agent__isnull=False).prefetch_related("ex", "agent", "person__user").first()
     )
-    async with FileClient(TOKEN) as b:
-        cl: AgentClient = actor.client(b)
-        # await cl.ex_client.set_pmcurexs(cookies=actor.agent.auth["cookies"])  # 617 -> 639
-        # await cl.set_creds()
-        # await cl.ex_client.set_pairs()
-        usdt = await models.Coinex.get(coin__ticker="USDT", ex=cl.actor.ex).prefetch_related("coin")
-        btc = await models.Coinex.get(coin__ticker="BTC", ex=cl.actor.ex).prefetch_related("coin")
-        eth = await models.Coinex.get(coin__ticker="ETH", ex=cl.actor.ex).prefetch_related("coin")
-        usdc = await models.Coinex.get(coin__ticker="USDC", ex=cl.actor.ex).prefetch_related("coin")
-        rub = await models.Curex.get(cur__ticker="RUB", ex=cl.actor.ex).prefetch_related("cur")
-        cl.all_conds = {
-            c.id: (c.raw_txt, {str(a.maker.exid) for a in c.ads})
-            for c in await Cond.all().prefetch_related("ads__maker")
-        }
-        # await cl.actual_cond()
-        await gather(
-            cl.battle(usdt, rub, False, ["volet"], 79.8),  # гонка в стакане покупки - мы продаем
-            cl.battle(usdt, rub, True, ["volet"], 79.8),  # гонка в стакане продажи - мы покупаем
-            cl.battle(eth, rub, False, ["volet"], 206_000),
-            cl.battle(eth, rub, True, ["volet"], 200_000),
-            cl.battle(btc, rub, False, ["volet"], 8_500_000),
-            cl.battle(btc, rub, True, ["volet"], 8_400_000),
-            cl.battle(usdc, rub, False, ["volet"], 80.5),
-            cl.battle(usdc, rub, True, ["volet"], 79),
-            cl.take(usdt, rub, False, ceil=80, volume=360),
-            cl.take(usdt, rub, True, ceil=80, volume=360),
-            # cl.get_api_orders(), # 10, 1738357200000, 1742504399999
-        )
+    # async with FileClient(TOKEN) as b:
+    cl: AgentClient = actor.client(FileClient(TOKEN))
+    # await cl.ex_client.set_pmcurexs(cookies=actor.agent.auth["cookies"])  # 617 -> 639
+    # await cl.set_creds()
+    # await cl.ex_client.set_pairs()
+    usdt = await models.Coinex.get(coin__ticker="USDT", ex=cl.actor.ex).prefetch_related("coin")
+    btc = await models.Coinex.get(coin__ticker="BTC", ex=cl.actor.ex).prefetch_related("coin")
+    eth = await models.Coinex.get(coin__ticker="ETH", ex=cl.actor.ex).prefetch_related("coin")
+    usdc = await models.Coinex.get(coin__ticker="USDC", ex=cl.actor.ex).prefetch_related("coin")
+    rub = await models.Curex.get(cur__ticker="RUB", ex=cl.actor.ex).prefetch_related("cur")
+    cl.all_conds = {
+        c.id: (c.raw_txt, {a.maker.exid for a in c.ads}) for c in await Cond.all().prefetch_related("ads__maker")
+    }
+    for curr, old in await CondSim.filter().values_list("cond_id", "cond_rel_id"):
+        cl.cond_sims[curr] = old
+        cl.rcond_sims[old] |= {curr}
+    cl.build_tree()
+    a = set()
+
+    def check_tree(tre):
+        for p, c in tre.items():
+            a.add(p)
+            check_tree(c)
+
+    for pr, ch in cl.tree.items():
+        check_tree(ch)
+    await cl.actual_cond()
+    await gather(
+        cl.get_api_orders(10, 1737493200000, 1742590800000),  # 10, 1738357200000, 1742504399999
+        cl.battle(usdt, rub, False, ["volet"], 79.8),  # гонка в стакане покупки - мы продаем
+        cl.battle(usdt, rub, True, ["volet"], 79.8),  # гонка в стакане продажи - мы покупаем
+        cl.battle(eth, rub, False, ["volet"], 206_000),
+        cl.battle(eth, rub, True, ["volet"], 200_000),
+        cl.battle(btc, rub, False, ["volet"], 8_500_000),
+        cl.battle(btc, rub, True, ["volet"], 8_400_000),
+        cl.battle(usdc, rub, False, ["volet"], 80.5),
+        cl.battle(usdc, rub, True, ["volet"], 79),
+        cl.take(usdt, rub, False, ceil=80, volume=360),
+        cl.take(usdt, rub, True, ceil=80, volume=360),
+    )
 
-        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 cl.close()
+    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 cl.close()
 
 
 if __name__ == "__main__":
-    run(main())
+    try:
+        run(main())
+    except KeyboardInterrupt:
+        logging.info("Shutting down")

{xync_client-0.0.57.dev22 → xync_client-0.0.57.dev24/xync_client.egg-info}/PKG-INFO

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