xync-client 0.0.43.dev32__tar.gz → 0.0.43.dev35__tar.gz

{xync_client-0.0.43.dev32/xync_client.egg-info → xync_client-0.0.43.dev35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xync-client
-Version: 0.0.43.dev32
+Version: 0.0.43.dev35
 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.43.dev32 → xync_client-0.0.43.dev35}/xync_client/Abc/InAgent.py

@@ -1,13 +1,13 @@
 from abc import abstractmethod
 
-from xync_schema.models import Agent
+from xync_schema.models import Actor
 
 from xync_client.Abc.Agent import BaseAgentClient
 
 
 class BaseInAgentClient:
-    def __init__(self, agent: Agent):
-        self.agent_client: BaseAgentClient = agent.client()
+    def __init__(self, actor: Actor):
+        self.agent_client: BaseAgentClient = actor.client()
 
     @abstractmethod
     async def start_listen(self) -> bool: ...

{xync_client-0.0.43.dev32 → xync_client-0.0.43.dev35}/xync_client/Bybit/InAgent.py

@@ -6,8 +6,7 @@ from xync_schema import models
 from xync_client.Abc.InAgent import BaseInAgentClient
 from xync_client.Bybit.agent import AgentClient
 from xync_client.Bybit.ws import prv
-from xync_client.TgWallet.pyro import PyroClient
-from xync_client.loader import PG_DSN, bot
+from xync_client.loader import PG_DSN
 
 
 class InAgentClient(BaseInAgentClient):
@@ -16,7 +15,7 @@ class InAgentClient(BaseInAgentClient):
     async def start_listen(self):
         t = await self.agent_client.ott()
         ts = int(float(t["time_now"]) * 1000)
-        await prv(self.agent_client.agent.auth["deviceId"], t["result"], ts, listen)
+        await prv(self.agent_client.actor.agent.auth["deviceId"], t["result"], ts, listen)
 
     # 3N: [T] - Уведомление об одобрении запроса на сделку
     async def request_accepted_notify(self) -> int: ...  # id
@@ -28,13 +27,14 @@ def listen(data: dict):
 
 async def main():
     _ = await init_db(PG_DSN, models, True)
-    pbot = PyroClient(bot)
-    await pbot.app.start()
-    await pbot.app.create_channel("tc")
-    await pbot.app.stop()
-
-    agent = await models.Agent.filter(actor__ex_id=9, auth__isnull=False).prefetch_related("actor__ex").first()
-    cl: InAgentClient = agent.in_client()
+    # pbot = PyroClient(bot)
+    # await pbot.app.start()
+    # await pbot.app.create_channel("tc")
+    # await pbot.app.stop()
+
+    actor = await models.Actor.filter(ex_id=9, agent__auth__isnull=False).prefetch_related("ex", "agent").first()
+    cl: InAgentClient = actor.in_client()
+    _ = await cl.start_listen()
     await cl.agent_client.close()
 
 

{xync_client-0.0.43.dev32 → xync_client-0.0.43.dev35}/xync_client/Bybit/agent.py

@@ -381,6 +381,24 @@ class AgentClient(BaseAgentClient):  # Bybit client
         print("-" if mad.side else "+", end=req.price, flush=True)
         await sleep(60)
 
+    def overprice_filter(self, ads: list[Ad], ceil: float, k: Literal[-1, 1]):
+        # вырезаем ads с ценами выше потолка
+        if ads and (ceil - float(ads[0].price)) * k > 0:
+            if int(ads[0].userId) != self.actor.exid:
+                ads.pop(0)
+                self.overprice_filter(ads, ceil, k)
+
+    def get_cad(self, ads: list[Ad], ceil: float, k: Literal[-1, 1], place: int, cur_plc: int) -> Ad:
+        # чью цену будем обгонять, предыдущей или слещующей объявы?
+        cad: Ad = ads[place] if cur_plc > place else ads[cur_plc]
+        # а цена обгоняемой объявы не выше нашего потолка?
+        if (float(cad.price) - ceil) * k <= 0:
+            # тогда берем следующую
+            ads.pop(place)
+            cad = self.get_cad(ads, ceil, k, place, cur_plc)
+        # todo: добавить фильтр по лимитам min-max
+        return cad
+
     async def battle(
         self,
         coinex: models.Coinex,
@@ -409,28 +427,27 @@ class AgentClient(BaseAgentClient):  # Bybit client
 
         while self.actor.person.user.status > 0:
             ads: list[Ad] = await self.ads(coinex, curex, is_sell, list(creds.keys()))
-            overprice_filter(ads, ceil, k)
+            self.overprice_filter(ads, ceil, k)
+            if not ads:
+                print(coinex.exid, curex.exid, is_sell, "no ads!")
+                await sleep(15)
+                continue
             cur_plc = [i for i, ad in enumerate(ads) if int(ad.userId) == self.actor.exid][0]
             mad: Ad = ads.pop(cur_plc)
             if not ads:
                 await sleep(60)
                 continue
-            # чью цену будем обгонять, предыдущей или слещующей объявы?
-            cad: Ad = ads[place] if cur_plc > place else ads[cur_plc]
-            # а цена обгоняемой объявы не выше нашего потолка?
-            if (float(cad.price) - ceil) * k <= 0:
-                # тогда берем следующую
-                cad = ads[cur_plc]
+            cad = self.get_cad(ads, ceil, k, place, cur_plc)
             new_price = f"%.{curex.cur.scale}f" % round(float(cad.price) - k * step(mad, cad), curex.cur.scale)
             if mad.price == new_price:  # Если нужная цена и так уже стоит
                 print(end="v" if is_sell else "^", flush=True)
-                await sleep(2)
+                await sleep(3)
                 continue
             if cad.priceType:  # Если цена конкурента плавающая, то повышаем себе не цену, а %
                 new_premium = str(round(float(cad.premium) - k * step(mad, cad), 2))
                 if mad.premium == new_premium:  # Если нужный % и так уже стоит
                     print(end="v" if is_sell else "^", flush=True)
-                    await sleep(2)
+                    await sleep(3)
                     continue
                 mad.premium = new_premium
             mad.priceType = cad.priceType
@@ -439,6 +456,7 @@ class AgentClient(BaseAgentClient):  # Bybit client
             req = AdUpdateRequest.model_validate({**mad.model_dump(), "price": new_price, "paymentIds": credex_ids})
             try:
                 _res = self.ad_upd(req)
+                print("-" if is_sell else "+", end=req.price, flush=True)
             except FailedRequestError as e:
                 if ExcCode(e.status_code) == ExcCode.FixPriceLimit:
                     if limits := re.search(
@@ -455,13 +473,14 @@ class AgentClient(BaseAgentClient):  # Bybit client
                     req.quantity = round(asset.free - (asset.freeze or 0) - (asset.lock or 0), coinex.coin.scale)
                     _res = self.ad_upd(req)
                 elif ExcCode(e.status_code) == ExcCode.RareLimit:
-                    await sleep(120)
+                    await sleep(192)
+                elif ExcCode(e.status_code) == ExcCode.Timestamp:
+                    await sleep(2)
                 else:
                     raise e
             except (ReadTimeoutError, ConnectionDoesNotExistError):
                 logging.warning("Connection failed. Restarting..")
-            print("-" if is_sell else "+", end=req.price, flush=True)
-            await sleep(60)
+            await sleep(42)
 
 
 def step(mad, cad) -> float:
@@ -473,13 +492,6 @@ def step(mad, cad) -> float:
     )
 
 
-def overprice_filter(ads: list[Ad], ceil: float, k: Literal[-1, 1]):
-    # вырезаем ads с ценами выше потолка
-    if ads and (ceil - float(ads[0].price)) * k > 0:
-        ads.pop(0)
-        overprice_filter(ads, ceil, k)
-
-
 def listen(data: dict):
     print(data)
 
@@ -494,11 +506,12 @@ class ExcCode(IntEnum):
     FixPriceLimit = 912120022
     RareLimit = 912120050
     InsufficientAmount = 912120024
+    Timestamp = 10002
 
 
 async def main():
     _ = await init_db(PG_DSN, models, True)
-    logging.basicConfig(level=logging.DEBUG)
+    logging.basicConfig(level=logging.INFO)
     actor = (
         await models.Actor.filter(ex_id=9, agent__isnull=False).prefetch_related("ex", "agent", "person__user").first()
     )
@@ -514,7 +527,7 @@ async def main():
     # )
     # await cl.set_creds()
     await gather(
-        cl.battle(usdt, rub, False, ["volet"], 83.79),  # гонка в стакане покупки - мы продаем
+        cl.battle(usdt, rub, False, ["volet"], 83.88),  # гонка в стакане покупки - мы продаем
         cl.battle(usdt, rub, True, ["volet"], 82),  # гонка в стакане продажи - мы покупаем
         cl.battle(eth, rub, False, ["volet"], 160_000),
         cl.battle(eth, rub, True, ["volet"], 144_000),

{xync_client-0.0.43.dev32 → xync_client-0.0.43.dev35}/xync_client/Pms/Volet/__init__.py

@@ -1,3 +1,4 @@
+import logging
 import re
 from asyncio import run, sleep
 from enum import StrEnum
@@ -5,7 +6,7 @@ from os.path import dirname
 from typing import Literal
 
 from aiogram.types import BufferedInputFile
-from playwright.async_api import async_playwright, Page
+from playwright.async_api import async_playwright, Page, FloatRect, Locator
 from pyotp import TOTP
 from pyrogram import filters
 from pyrogram.handlers import MessageHandler
@@ -14,8 +15,8 @@ from playwright._impl._errors import TimeoutError
 from xync_schema.enums import UserStatus
 from xync_schema.models import User, PmAgent
 
-from xync_client.TgWallet.pyro import PyroClient
-from xync_client.loader import bot
+from xync_client.pyro import PyroClient
+from xync_client.loader import bot, dp
 
 
 class ExtraCaptchaException(Exception): ...
@@ -57,7 +58,8 @@ async def report(uid: int, byts: bytes, msg: str, exc: bool = True):
 
 class Client:
     agent: PmAgent
-    pbot: PyroClient
+    bbot: PyroClient
+    ubot: PyroClient
     page: Page
     gpage: Page
 
@@ -70,10 +72,10 @@ class Client:
     async def start(self, headed: bool = False):
         self.agent = await PmAgent.get(user_id=self.uid, user__status__gt=0, pm__norm="volet").prefetch_related("user")
 
-        self.pbot = PyroClient(self.agent)
-        await self.pbot.app.start()
+        self.ubot, self.bbot = PyroClient(self.agent.user), PyroClient(bot)
+        await self.ubot.app.start(), await self.bbot.app.start()
         self.msg_listener = MessageHandler(self.got_msg, filters.chat(["ProtectimusBot"]))
-        self.pbot.app.add_handler(self.msg_listener)
+        self.ubot.app.add_handler(self.msg_listener)
 
         playwright = await async_playwright().start()
         browser = await playwright.chromium.launch(
@@ -113,7 +115,7 @@ class Client:
         await self.page.click("input#checkOtpButton")
         await self.page.wait_for_url(Pages.HOME)
 
-    async def wait_for_code(self, typ: Literal["login", "send"], past: int = 0, timeout: int = 5) -> str:
+    async def wait_for_code(self, typ: Literal["login", "send", "cap_xy"], past: int = 0, timeout: int = 5) -> str:
         while past < timeout:
             if code := self.msgs.pop(f"otp_{typ}", None):
                 return code
@@ -124,7 +126,7 @@ class Client:
     async def got_msg(self, _, msg: Message):
         if "Your OTP code:" in msg.text:
             self.msgs["otp_login"] = msg.text[-6:]
-        if "Confirmation code:" in msg.text:
+        elif "Confirmation code:" in msg.text:
             self.msgs["otp_send"] = msg.text[-6:]
         elif "Status: Completed. Sender:" in msg.text:
             self.msgs["got_payment"] = parse_transaction_info(msg.text)
@@ -137,7 +139,7 @@ class Client:
         await self.page.fill("#srcAmount", str(amount))
         await self.page.fill("#destWalletId", dest)
         await self.page.wait_for_timeout(300)
-        await self.page.locator("input[type=submit]", has_text="continue").click()
+        await self.page.locator("form#mainForm input[type=submit]", has_text="continue").click()
         if otp := self.agent.auth.get("otp"):
             totp = TOTP(otp)
             code = totp.now()
@@ -157,23 +159,16 @@ class Client:
 
     async def gmail_page(self):
         gp = await self.page.context.new_page()
-        await gp.goto(Pages.GMH, timeout=20000)
+        await gp.goto(Pages.GMH, timeout=30000)
         if not gp.url.startswith(Pages.GMH):
-            # ваще с 0 заходим
-            if await (
+            if await (  # ваще с 0 заходим
                 sgn_btn := gp.locator(
                     'header a[href^="https://accounts.google.com/AccountChooser/signinchooser"]:visible',
-                    has_text="sign in",
+                    has_text="sign",
                 )
             ).count():
                 await sgn_btn.click()
-            # если надо выбрать акк
-            lang = await gp.get_attribute("html", "lang")
-            sgn = {
-                "ru": "Выберите аккаунт",
-                "en": "Choose an account",
-            }
-            if await gp.locator("h1#headingText", has_text=sgn[lang]).count():
+            if gp.url.startswith("https://accounts.google.com/v3/signin/accountchooser"):  # если надо выбрать акк
                 await gp.locator("li").first.click()
             # если предлагает залогиниться
             elif await gp.locator("h1#headingText", has_text="Sign In").count():
@@ -181,8 +176,7 @@ class Client:
                 await gp.locator("button", has_text="Next").click()
             # осталось ввести пороль:
             await gp.fill("input[type=password]", self.agent.user.gmail_auth["password"])
-            nxt = {"ru": "Далее", "en": "Next"}
-            await gp.locator("button", has_text=nxt[lang]).click()
+            await gp.locator("#passwordNext").click()
             await report(self.uid, await gp.screenshot(), "Аппрувни гмейл, у тебя 1.5 минуты", False)
         await gp.wait_for_url(lambda u: u.startswith(Pages.GMH), timeout=90 * 1000)  # убеждаемся что мы в почте
         self.gpage = gp
@@ -212,13 +206,32 @@ class Client:
         except Exception as e:
             await report(self.uid, await self.page.screenshot(), repr(e))
 
+    async def send_cap_help(self, xcap: Locator):
+        bb = await xcap.bounding_box(timeout=2000)
+        byts = await self.page.screenshot(clip=bb)
+        infile = BufferedInputFile(byts, "cap_xy.png")
+        await self.bbot.send_img("put x, y", byts)
+        self.bbot.app.storage.user_id()
+        await bot.send_photo(uid, infile, caption=msg)
+        await report(self.uid, byts, "x, y", False)
+        dp.message.register(self.got_cap_xy)
+
+    async def got_cap_xy(self, _, msg):
+        self.msgs["typ_cap_xy"] = msg.text.split(",")
+
     async def captcha_click(self):
         captcha_url = self.page.url
         cbx = self.page.frame_locator("#main-iframe").frame_locator("iframe").first.locator("div#checkbox")
         await cbx.wait_for(state="visible"), await self.page.wait_for_timeout(500)
         await cbx.click(delay=94)
+        xcap = self.page.frame_locator("#main-iframe").frame_locator("iframe").last.locator("div.challenge-view")
+        if await xcap.count():
+            await self.send_cap_help(xcap)
+            x, y = await self.wait_for_code("cap_xy", timeout=59)
+
         try:
             await self.page.wait_for_url(lambda url: url != captcha_url)
+
         except TimeoutError:  # if page no changed -> captcha is undone
             await self.page.screenshot(path=dirname(__file__) + "/xtr_captcha.png")
             raise ExtraCaptchaException(self.page.url)
@@ -236,20 +249,22 @@ class Client:
         # closing
         await self.page.context.close()
         await self.page.context.browser.close()
-        self.pbot.app.remove_handler(self.msg_listener)
-        await self.pbot.app.stop()
+        self.ubot.app.remove_handler(self.msg_listener)
+        await self.ubot.app.stop(), await self.bbot.app.stop()
 
 
-async def _test(uid: int, dest: str, amount):
+async def _test():
     from x_model import init_db
     from xync_client.loader import PG_DSN
     from xync_schema import models
 
     _ = await init_db(PG_DSN, models, True)
+    logging.basicConfig(level=logging.DEBUG)
+    uid = 193017646
     va = Client(uid)
     try:
         await va.start(True)
-        await va.send(dest, amount)
+        await va.send("alena.artemeva25@gmail.com", 8.3456)
         await va.wait_for_payments()
     except TimeoutError as te:
         await report(uid, await va.page.screenshot(), repr(te))
@@ -257,4 +272,4 @@ async def _test(uid: int, dest: str, amount):
 
 
 if __name__ == "__main__":
-    run(_test(7807393311, "alena.artemeva25@gmail.com", 8.3456))
+    run(_test())

{xync_client-0.0.43.dev32 → xync_client-0.0.43.dev35}/xync_client/loader.py

@@ -1,4 +1,4 @@
-from aiogram import Bot
+from aiogram import Bot, Dispatcher
 from dotenv import load_dotenv
 from os import getenv as env
 
@@ -11,6 +11,7 @@ if not (TOKEN := env("TOKEN")):
     logging.info(TOKEN := env("TOKEN"))
 
 bot: Bot = Bot(token=TOKEN)
+dp: Dispatcher = Dispatcher()
 PG_DSN = f"postgres://{env('POSTGRES_USER')}:{env('POSTGRES_PASSWORD')}@{env('POSTGRES_HOST', 'xyncdbs')}:{env('POSTGRES_PORT', 5432)}/{env('POSTGRES_DB', env('POSTGRES_USER'))}"
 TG_API_ID = env("TG_API_ID")
 TG_API_HASH = env("TG_API_HASH")

xync_client-0.0.43.dev35/xync_client/pg_storage.py

@@ -0,0 +1,276 @@
+import time
+
+from pyrogram import Client, raw, utils
+from pyrogram.storage import Storage
+from tortoise import fields
+from tortoise.signals import pre_save
+from x_model.models import Model
+from xync_schema.models import User
+
+
+class Session(Model):
+    name = fields.CharField(255, primary_key=True)
+    dc_id = fields.IntField(null=False)
+    api_id = fields.IntField(null=False)
+    test_mode = fields.BooleanField(null=True)
+    auth_key = fields.BinaryField()
+    date = fields.IntField(null=False)
+    user: fields.OneToOneRelation[User] = fields.OneToOneField("models.User", "sessions")
+    user_id: int
+    is_bot = fields.BooleanField(null=True)
+
+
+class Peer(Model):
+    session: fields.ForeignKeyRelation[Session] = fields.OneToOneField("models.Session", "peers", primary_key=True)
+    id: int = fields.BigIntField(True)
+    access_hash: int = fields.BigIntField()
+    type = fields.CharField(255)
+    phone_number = fields.CharField(255)
+    last_update_on: int = fields.BigIntField()
+
+
+@pre_save(Peer)
+async def person(_meta, peer: Peer, _db, _updated: dict) -> None:
+    if not peer.last_update_on:
+        peer.last_update_on = int(time.time())
+
+
+class UpdateState(Model):
+    session: fields.ForeignKeyRelation[Session] = fields.OneToOneField("models.Session", "update_states", primary_key=True)
+    pts = fields.IntField()
+    qts = fields.IntField()
+    date = fields.IntField()
+    seq = fields.IntField()
+
+
+class Version(Model):
+    id: None
+    number = fields.IntField(primary_key=True)
+
+
+def get_input_peer(peer_id: int, access_hash: int, peer_type: str):
+    if peer_type in ["user", "bot"]:
+        return raw.types.InputPeerUser(
+            user_id=peer_id,
+            access_hash=access_hash
+        )
+
+    if peer_type == "group":
+        return raw.types.InputPeerChat(
+            chat_id=-peer_id
+        )
+
+    if peer_type in ["channel", "supergroup"]:
+        return raw.types.InputPeerChannel(
+            channel_id=utils.get_channel_id(peer_id),
+            access_hash=access_hash
+        )
+
+    raise ValueError(f"Invalid peer type: {peer_type}")
+
+
+class MultiPostgresStorage(Storage):
+    VERSION = 1
+    USERNAME_TTL = 8 * 60 * 60
+
+    def __init__(self, client: Client, database: dict):
+        super().__init__(client.name)
+        self.cn = f"postgresql+asyncpg://{database['db_user']}:{database['db_pass']}@{database['db_host']}:{database['db_port']}/{database['db_name']}"
+        self.name = client.name
+
+    async def open(self):
+        if not await Session.filter(session_name=self.name).exists():
+            _ = await Session.create(
+                session_name=self.name,
+                dc_id=None,
+                api_id=None,
+                test_mode=None,
+                auth_key=None,
+                date=int(time.time()),
+                user_id=None,
+                is_bot=None
+            )
+
+    async def save(self):
+        await self.date(int(time.time()))
+
+    async def close(self):
+        await self.cn.close()
+
+    async def delete(self):
+        # await UpdateState.filter(session__name=self.name).delete()
+        # delete(UsernameModel).where(UsernameModel.session_name == self.name)
+        # await Peer.filter(session__name=self.name).delete()  # no need if delete cascade
+        await Session.filter(session__name=self.name).delete()
+
+    async def update_peers(self, peers: list[tuple[int, int, str, str]]):
+        for peer in peers:
+            existing_peer = await Peer.get_or_none(session__name=self.name, id=peer[0])
+
+            if existing_peer:
+                existing_peer.access_hash = peer[1]
+                existing_peer.type = peer[2]
+                existing_peer.phone_number = peer[3]
+            else:
+                new_peer = await Peer.create(
+                    session__name=self.name,  # todo: pk ?
+                    id=peer[0],
+                    access_hash=peer[1],
+                    type=peer[2],
+                    phone_number=peer[3]
+                )
+
+    async def update_usernames(self, usernames: list[tuple[int, list[str]]]):
+        for telegram_id, _ in usernames:
+            await session.execute(
+                delete(UsernameModel).where(UsernameModel.session_name == self.name,
+                                            UsernameModel.id == telegram_id)
+            )
+
+        for telegram_id, user_list in usernames:
+            for username in user_list:
+                User
+                new_username = UsernameModel(session_name=self.name, id=telegram_id, username=username)
+                session.add(new_username)
+
+        await session.commit()
+
+    async def get_peer_by_id(self, peer_id_or_username):
+        async with self.session_maker() as session:
+            if isinstance(peer_id_or_username, int):
+                peer = await session.execute(
+                    select(PeerModel).filter_by(session_name=self.name, id=peer_id_or_username)
+                )
+                peer = peer.scalar_one_or_none()
+                if peer is None:
+                    raise KeyError(f"ID not found: {peer_id_or_username}")
+                return get_input_peer(peer.id, peer.access_hash, peer.type)
+            elif isinstance(peer_id_or_username, str):
+                r = await session.execute(
+                    select(
+                        PeerModel.id,
+                        PeerModel.access_hash,
+                        PeerModel.type,
+                        PeerModel.last_update_on
+                    )
+                    .join(UsernameModel, UsernameModel.id == PeerModel.id)
+                    .filter(UsernameModel.username == peer_id_or_username,
+                            UsernameModel.session_name == self.name,
+                            PeerModel.session_name == self.name)
+                    .order_by(PeerModel.last_update_on.desc())
+                )
+                r = r.fetchone()
+                if r is None:
+                    raise KeyError(f"Username not found: {peer_id_or_username}")
+                if len(r) == 4:
+                    peer_id, access_hash, peer_type, last_update_on = r
+                else:
+                    raise ValueError(f"The result does not contain the expected tuple of values. Received: {r}")
+                if last_update_on:
+                    if abs(time.time() - last_update_on) > self.USERNAME_TTL:
+                        raise KeyError(f"Username expired: {peer_id_or_username}")
+                return get_input_peer(peer_id, access_hash, peer_type)
+
+            else:
+                raise ValueError("peer_id_or_username must be an integer (ID) or string (Username).")
+
+    async def get_peer_by_username(self, username: str):
+        async with self.session_maker() as session:
+            peer_alias = aliased(PeerModel)
+            username_alias = aliased(UsernameModel)
+            r = await session.execute(
+                select(peer_alias.id, peer_alias.access_hash, peer_alias.type, peer_alias.last_update_on)
+                .join(username_alias, username_alias.id == peer_alias.id)
+                .filter(username_alias.username == username, username_alias.session_name == self.name)
+                .order_by(peer_alias.last_update_on.desc())
+            )
+            r = r.fetchone()
+            if r is None:
+                raise KeyError(f"Username not found: {username}")
+
+            peer_id, access_hash, peer_type, last_update_on = r
+            return get_input_peer(peer_id, access_hash, peer_type)
+
+    async def update_state(self, value: Tuple[int, int, int, int, int] = object):
+        async with self.session_maker() as session:
+            if value == object:
+                result = await session.execute(
+                    select(UpdateStateModel).filter_by(session_name=self.name)
+                )
+                return result.scalars().all()
+            else:
+                if isinstance(value, int):
+                    await session.execute(
+                        delete(UpdateStateModel)
+                        .where(UpdateStateModel.session_name == self.name, UpdateStateModel.id == value)
+                    )
+                else:
+                    state = await session.execute(
+                        select(UpdateStateModel).filter_by(session_name=self.name, id=value[0])
+                    )
+                    state_instance = state.scalar_one_or_none()
+
+                    if state_instance:
+                        state_instance.pts = value[1]
+                        state_instance.qts = value[2]
+                        state_instance.date = value[3]
+                        state_instance.seq = value[4]
+                    else:
+                        state_instance = UpdateStateModel(
+                            id=value[0],
+                            session_name=self.name,
+                            pts=value[1],
+                            qts=value[2],
+                            date=value[3],
+                            seq=value[4]
+                        )
+                        session.add(state_instance)
+
+                await session.commit()
+
+    async def get_peer_by_phone_number(self, phone_number: str):
+        if not (peer := await Peer.filter(
+                session__name=self.name, phone_number=phone_number
+        ).values_list("id", "access_hash", "type")):
+            raise KeyError(f"Phone number not found: {phone_number}")
+        return get_input_peer(*peer)
+
+    async def _get(self, attr: str):
+        return await Session.get(name=self.name).values_list(attr, flat=True)
+
+    async def _set(self, attr: str, value: Any):
+        await Session.update_or_create({attr: value}, name=self.name)
+
+    async def _accessor(self, attr: str, value: Any = object):
+        if value == object:
+            return await self._get(attr)
+        else:
+            await self._set(attr, value)
+
+    async def dc_id(self, value: int = object):
+        return await self._accessor('dc_id', value)
+
+    async def api_id(self, value: int = object):
+        return await self._accessor('api_id', value)
+
+    async def test_mode(self, value: bool = object):
+        return await self._accessor('test_mode', value)
+
+    async def auth_key(self, value: bytes = object):
+        return await self._accessor('auth_key', value)
+
+    async def date(self, value: int = object):
+        return await self._accessor('date', value)
+
+    async def user_id(self, value: int = object):
+        return await self._accessor('user_id', value)
+
+    async def is_bot(self, value: bool = object):
+        return await self._accessor('is_bot', value)
+
+    async def version(self, value: int = object):
+        if value == object:
+            ver = await Version.first()
+            return ver.number
+        else:
+            await Version.update_or_create({"number": value})

{xync_client-0.0.43.dev32 → xync_client-0.0.43.dev35/xync_client.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xync-client
-Version: 0.0.43.dev32
+Version: 0.0.43.dev35
 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.43.dev32 → xync_client-0.0.43.dev35}/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/pg_storage.py
 xync_client/pm_unifier.py
 xync_client/pyro.py
 xync_client.egg-info/PKG-INFO