xync-bot 0.3.7.dev1__py3-none-any.whl → 0.3.24__py3-none-any.whl

xync_bot/__main__.py

@@ -0,0 +1,36 @@
+import logging
+from asyncio import run
+
+from PGram import Bot
+from aiogram.client.default import DefaultBotProperties
+from aiogram.enums import UpdateType
+from x_model import init_db
+
+from xync_bot.routers.main.handler import mr
+from xync_bot.routers.cond import cr
+from xync_bot.routers.pay.handler import pr
+from xync_bot.routers import last
+from xync_bot.routers.pay.dep import Store
+
+au = [
+    UpdateType.MESSAGE,
+    UpdateType.CALLBACK_QUERY,
+    UpdateType.CHAT_MEMBER,
+    UpdateType.MY_CHAT_MEMBER,
+]  # , UpdateType.CHAT_JOIN_REQUEST
+bot = Bot([cr, pr, mr, last], Store(), au, default=DefaultBotProperties(parse_mode="HTML"))
+
+if __name__ == "__main__":
+    from xync_bot.loader import TOKEN, TORM
+
+    logging.basicConfig(level=logging.INFO)
+
+    async def main() -> None:
+        cn = await init_db(TORM)
+        bot.dp.workflow_data["store"].glob = await Store.Global()  # todo: refact store loading
+        await bot.start(
+            TOKEN,
+            cn,
+        )
+
+    run(main())

xync_bot/loader.py

@@ -19,3 +19,5 @@ TORM = {
     "use_tz": False,
     "timezone": "UTC",
 }
+
+glob = object

xync_bot/routers/__init__.py

@@ -1,8 +1,41 @@
-from aiogram.types import User
-from aiogram.utils.web_app import WebAppUser
-from xync_schema import models
+import logging
 
+from aiogram import Router, F
+from aiogram.enums import ContentType
+from aiogram.exceptions import TelegramBadRequest
+from aiogram.types import Message
 
-async def user_upsert(u: User | WebAppUser, blocked: bool = None) -> tuple[User, bool]:
-    user_in: models.User.Upd = await models.User.tg2in(u, blocked)
-    return await models.User.update_or_create(user_in.model_dump(exclude_none=True, exclude={"id"}), id=u.id)
+last = Router(name="last")
+
+
+@last.message(
+    F.content_type.not_in(
+        {
+            ContentType.NEW_CHAT_MEMBERS,
+            # ContentType.LEFT_CHAT_MEMBER,
+            # ContentType.SUPERGROUP_CHAT_CREATED,
+            # ContentType.NEW_CHAT_PHOTO,
+            # ContentType.FORUM_TOPIC_CREATED,
+            # ContentType.FORUM_TOPIC_EDITED,
+            ContentType.FORUM_TOPIC_CLOSED,
+            # ContentType.GENERAL_FORUM_TOPIC_HIDDEN, # deletable
+        }
+    )
+)
+async def del_cbq(msg: Message):
+    try:
+        await msg.delete()
+        logging.info({"DELETED": msg.model_dump(exclude_none=True)})
+    except TelegramBadRequest:
+        logging.error({"NOT_DELETED": msg.model_dump(exclude_none=True)})
+
+
+@last.message()
+async def all_rest(msg: Message):
+    logging.warning(
+        {
+            "NO_HANDLED": msg.model_dump(
+                exclude_none=True,
+            )
+        }
+    )

xync_bot/routers/cond/__init__.py

@@ -1,114 +1,33 @@
-import re
-from enum import IntEnum
-from inspect import isclass
-from typing import Coroutine
-
 from aiogram import Router, F
-from aiogram.filters import CommandStart
+from aiogram.exceptions import TelegramBadRequest
+from aiogram.filters import Command
 from aiogram.fsm.context import FSMContext
-from aiogram.types import (
-    Message,
-    ReplyKeyboardMarkup,
-    KeyboardButton,
-    InlineKeyboardMarkup,
-    InlineKeyboardButton,
-    CallbackQuery,
-    # ReplyKeyboardRemove,
-)
-from cyrtranslit import to_latin
+from aiogram.types import Message, InlineKeyboardMarkup, InlineKeyboardButton, CallbackQuery
 from xync_schema import models
-from xync_schema.enums import SynonymType, Party, Slip, AbuserType, NameType, Boundary
-
-r = Router()
-
-
-async def wrap_cond(txt: str):
-    bnks = await models.Synonym.filter(typ=SynonymType.bank)
-    bnks = "|".join("\\b" + b.txt + ("\\b" if b.boundary & Boundary.right else "") for b in bnks)
-    for syn in await models.Synonym.all():
-        lb, rb = "\\b" if syn.boundary & Boundary.left else "", "\\b" if syn.boundary & Boundary.right else ""
-        if syn.typ == SynonymType.bank_side:
-            syn.txt.replace("#banks#", f"({bnks})")
-        if syn.is_re or syn.txt in txt:
-            pattern = re.compile(lb + syn.txt + rb)
-            if match := re.search(pattern, txt):
-                g = match.group()
-                val, hval = await get_val(syn.typ, syn.val)
-                val = syn.typ.name + (f'="{hval}"' if hval else "")
-                txt = re.sub(pattern, f"<code>{g}</code><tg-spoiler>[{val}]</tg-spoiler>", txt)
-    return txt
-
-
-async def cbanks(bnid: str) -> list[tuple[int, str]]:
-    beginning = to_latin(bnid[:2], lang_code="ru")
-    return await models.Pm.filter(norm__startswith=beginning, bank=True).values_list("id", "norm")
-
-
-async def cppo(txt: str) -> list[tuple[int, str]]:
-    opts = re.findall(r"\d+", txt) or [1, 2, 3, 5, 10]
-    return [(o, str(o)) for o in opts]
-
-
-synopts: dict[SynonymType, list[str] | type(IntEnum) | None | Coroutine] = {
-    SynonymType.name: ["not_slavic", "slavic"],
-    SynonymType.ppo: cppo,
-    SynonymType.from_party: Party,
-    SynonymType.to_party: Party,
-    SynonymType.slip_req: Slip,
-    SynonymType.slip_send: Slip,
-    SynonymType.abuser: AbuserType,
-    SynonymType.scale: ["1", "10", "100", "1000"],
-    SynonymType.slavic: NameType,
-    SynonymType.mtl_like: None,
-    SynonymType.bank: cbanks,
-    SynonymType.bank_side: ["except", "only"],
-}
-rkm = ReplyKeyboardMarkup(
-    keyboard=[
-        [KeyboardButton(text="ppo"), KeyboardButton(text="abuser")],
-        [KeyboardButton(text="from_party"), KeyboardButton(text="to_party")],
-        [KeyboardButton(text="slip_send"), KeyboardButton(text="slip_req")],
-        [KeyboardButton(text="name"), KeyboardButton(text="slavic")],
-        [KeyboardButton(text="scale"), KeyboardButton(text="mtl_like")],
-        [KeyboardButton(text="bank"), KeyboardButton(text="bank_side")],
-    ],
-    one_time_keyboard=True,
-)
-
-
-async def get_val(typ: SynonymType.__class__, val: str) -> tuple[SynonymType | int | bool, str]:
-    if isinstance(val, str) and val.isnumeric():
-        val = int(val)
-    if isclass(lst := synopts[typ]) and issubclass(lst, IntEnum):
-        return (v := lst(val)), v.name
-    elif isinstance(lst, list):
-        return val, lst[val]
-    elif typ == SynonymType.bank:
-        return val, (await models.Pm[val]).norm
-    return val, val
-
-
-async def btns(typ: SynonymType.__class__, txt: str = None) -> InlineKeyboardMarkup | None:
-    if lst := synopts[typ]:
-        if isinstance(lst, list):
-            kb = [[InlineKeyboardButton(text=n, callback_data=f"st:{typ.name}:{i}")] for i, n in enumerate(lst)]
-        elif isclass(lst) and issubclass(lst, IntEnum):
-            kb = [[InlineKeyboardButton(text=i.name, callback_data=f"st:{typ.name}:{i.value}")] for i in lst]
-        else:
-            kb = [[InlineKeyboardButton(text=n, callback_data=f"st:{typ.name}:{i}")] for i, n in await lst(txt)]
-        return InlineKeyboardMarkup(inline_keyboard=kb)
-    else:
-        return lst
-
-
-@r.message(CommandStart())
+from xync_schema.enums import SynonymType
+
+from xync_bot.routers.cond.func import wrap_cond, get_val, btns, rkm, ikm, SynTypeCd, CondCd
+
+cr = Router(name="cond")
+
+
+@cr.message(Command("cond"))
 async def start(msg: Message, state: FSMContext):
+    await msg.reply('Заполняем синонимы признаков условий объявлений: "ссылка на инструкцию"', reply_markup=rkm)
+    await show_new_cond(msg, state)
+
+
+async def show_new_cond(msg: Message, state: FSMContext):
     cond = await models.Cond.filter(parsed__isnull=True).order_by("-created_at").first().prefetch_related("parsed")
-    await state.set_data({"cid": cond.id, "cond_txt": cond.raw_txt})
-    await msg.reply(await wrap_cond(cond.raw_txt), reply_markup=rkm)
+    await state.set_data({"cond": cond})
+    await show_cond(msg, cond)
+
 
+async def show_cond(msg: Message, cond: models.Cond):
+    await msg.answer(await wrap_cond(cond), reply_markup=ikm)
 
-@r.message(F.quote)
+
+@cr.message(F.quote)
 async def got_synonym(msg: Message, state: FSMContext):
     if not (msg.text in {st.name for st in SynonymType} and SynonymType[msg.text]):
         return await msg.reply_text(
@@ -122,58 +41,51 @@ async def got_synonym(msg: Message, state: FSMContext):
         await models.Synonym.update_or_create({"typ": typ}, txt=msg.quote.text)
         if rm := await btns(typ, msg.quote.text):
             return await msg.answer("Уточните", reply_markup=rm, reply_to_message_id=msg.message_id)
-        await syn_result(msg, f"st:{typ.name}:1", state)
+        await syn_result(msg, SynTypeCd(typ=typ.name, val=1), state)
     return None
 
 
-@r.callback_query()
-async def got_synonym_val(cbq: CallbackQuery, state: FSMContext):
-    await syn_result(cbq.message, cbq.data, state)
-
-
-async def syn_result(msg: Message, data: str, state: FSMContext):
-    t, st, sv = data.split(":")
-    if t == "st":
-        typ = SynonymType[st]
-        val, hval = await get_val(typ, sv)
-        syntext = await state.get_value("syntext")
-        cid = await state.get_value("cid")
-        syn, _ = await models.Synonym.update_or_create({"val": val}, typ=typ, txt=syntext)
-        await models.CondParsed.update_or_create({typ.name: val}, cond_id=cid)
-        await msg.reply(
-            f'Текст "{syntext}" определен как синоним для `{typ.name}` со значением {hval}',
-            reply_markup=InlineKeyboardMarkup(
-                inline_keyboard=[
-                    [
-                        InlineKeyboardButton(text="Готово! Давай новый", callback_data=f"cond:complete:{cid}"),
-                        InlineKeyboardButton(text="Продолжить с этим текстом", callback_data=f"cond:process:{cid}"),
-                    ]
+@cr.callback_query(SynTypeCd.filter())
+async def got_synonym_val(cbq: CallbackQuery, callback_data: SynTypeCd, state: FSMContext):
+    await syn_result(cbq.message, callback_data, state)
+
+
+async def syn_result(msg: Message, cbd: SynTypeCd, state: FSMContext):
+    cond: models.Cond = await state.get_value("cond")
+    typ = SynonymType[cbd.typ]
+    val, hval = await get_val(typ, cbd.val)
+    syntext = await state.get_value("syntext")
+    syn, _ = await models.Synonym.update_or_create({"val": val}, typ=typ, txt=syntext)
+    await models.CondParsed.update_or_create({typ.name: val}, cond_id=cond.id)
+    await msg.answer(
+        f'Текст "{syntext}" определен как синоним для `{typ.name}` со значением {hval}',
+        reply_markup=InlineKeyboardMarkup(
+            inline_keyboard=[
+                [
+                    InlineKeyboardButton(text="Готово! Давай новый", callback_data="cond:complete"),
+                    InlineKeyboardButton(text="Продолжить с этим текстом", callback_data="cond:continue"),
                 ]
-            ),
-        )
-        # await msg.reply_to_message.delete()
-        # await msg.delete()
-        # await cmsg.edit_text(wrapped_txt)
-
-    elif t == "cond":
-        if st == "complete":
-            await models.CondParsed.update_or_create({"parsed": True}, cond_id=int(sv))
-            await start(msg, state)
-        else:
-            wrapped_txt = await wrap_cond(await state.get_value("cond_txt"))
-            # cmsg: Message = await state.get_value('cmsg')
-            await msg.reply(wrapped_txt, reply_markup=rkm)
-    else:
-        await msg.reply("Где я?")
-
-
-@r.message(F.reply_to_message)
-async def clear(msg: Message):
-    await msg.reply_to_message.delete_reply_markup()
-    await msg.delete()
-
-
-@r.message()
-async def unknown(msg: Message):
-    # user = await User.get(username_id=msg.from_user.id)
-    await msg.delete()
+            ]
+        ),
+    )
+
+
+@cr.callback_query(CondCd.filter())
+async def got_action(cbq: CallbackQuery, callback_data: CondCd, state: FSMContext):
+    cond: models.Cond = await state.get_value("cond")
+    if callback_data.act == "complete":
+        await models.CondParsed.update_or_create({"parsed": True}, cond=cond)
+        await show_new_cond(cbq.message, state)
+    elif callback_data.act == "pass":
+        await show_new_cond(cbq.message, state)
+    elif callback_data.act == "refresh":
+        try:
+            await cbq.message.edit_text(await wrap_cond(cond), reply_markup=ikm)
+        except TelegramBadRequest as e:
+            if "message is not modified:" in e.message:
+                return await cbq.answer("Текст не изменился")
+            raise e
+    elif callback_data.act == "continue":
+        await (await state.get_value("cmsg")).delete()
+        await show_cond(cbq.message, cond)
+    return await cbq.answer(callback_data.act)

xync_bot/routers/cond/func.py

@@ -0,0 +1,118 @@
+import re
+from enum import IntEnum
+from inspect import isclass
+from typing import Coroutine
+
+from aiogram.filters.callback_data import CallbackData
+from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton, ReplyKeyboardMarkup, KeyboardButton
+from cyrtranslit import to_latin
+from xync_schema import models
+from xync_schema.enums import SynonymType, Boundary, Party, Slip, AbuserType, NameType
+
+
+class SynTypeCd(CallbackData, prefix="st"):
+    typ: str
+    val: int
+
+
+class CondCd(CallbackData, prefix="cond"):
+    act: str
+
+
+async def wrap_cond(cond: models.Cond):
+    bnks = await models.Synonym.filter(typ=SynonymType.bank)
+    bnks = "|".join("\\b" + b.txt + ("\\b" if b.boundary & Boundary.right else "") for b in bnks)
+    ad = await models.Ad.filter(cond=cond).order_by("-updated_at").prefetch_related("ex", "pair_side").first()
+    hdr = ("SELL" if ad.pair_side.is_sell else "BUY") + f":{ad.price} [{ad.min_fiat}]"
+    if (mx := (ad.max_fiat or ad.amount)) > ad.min_fiat:
+        hdr += f"->[{mx}]"
+    txt = cond.raw_txt
+    for syn in await models.Synonym.all():
+        lb, rb = "\\b" if syn.boundary & Boundary.left else "", "\\b" if syn.boundary & Boundary.right else ""
+        if syn.typ == SynonymType.bank_side:
+            syn.txt.replace("#banks#", f"({bnks})")
+        if syn.is_re or syn.txt in txt:
+            pattern = re.compile(lb + syn.txt + rb)
+            if match := re.search(pattern, txt):
+                g = match.group()
+                val, hval = await get_val(syn.typ, syn.val)
+                val = syn.typ.name + (f'="{hval}"' if hval else "")
+                txt = re.sub(pattern, f"<code>{g}</code><tg-spoiler>[{val}]</tg-spoiler>", txt)
+    return f"<blockquote>{hdr} {ad.ex.name}</blockquote>{txt}"
+
+
+async def cbanks(bnid: str) -> list[tuple[int, str]]:
+    beginning = to_latin(bnid[:2], lang_code="ru")
+    return await models.Pm.filter(norm__startswith=beginning, bank=True).values_list("id", "norm")
+
+
+async def cppo(txt: str) -> list[tuple[int, str]]:
+    opts = re.findall(r"\d+", txt) or [1, 1000, 5000]
+    return [(o, str(o)) for o in opts]
+
+
+async def contact(txt: str) -> list[tuple[int, str]]: ...
+
+
+synopts: dict[SynonymType, list[str] | type(IntEnum) | None | Coroutine] = {
+    SynonymType.name: ["not_slavic", "slavic"],
+    SynonymType.ppo: cppo,
+    SynonymType.from_party: Party,
+    SynonymType.to_party: Party,
+    SynonymType.slip_req: Slip,
+    SynonymType.slip_send: Slip,
+    SynonymType.abuser: AbuserType,
+    SynonymType.scale: ["1", "100", "1000", "5000"],
+    SynonymType.slavic: NameType,
+    SynonymType.mtl_like: None,
+    SynonymType.bank: cbanks,
+    SynonymType.bank_side: ["except", "only"],
+    SynonymType.sbp_strict: ["no", "sbp", "card"],
+    SynonymType.contact: contact,
+}
+
+rkm = ReplyKeyboardMarkup(
+    keyboard=[
+        [KeyboardButton(text="ppo"), KeyboardButton(text="abuser")],
+        [KeyboardButton(text="from_party"), KeyboardButton(text="to_party")],
+        [KeyboardButton(text="slip_send"), KeyboardButton(text="slip_req")],
+        [KeyboardButton(text="name"), KeyboardButton(text="slavic")],
+        [KeyboardButton(text="scale"), KeyboardButton(text="mtl_like")],
+        [KeyboardButton(text="bank"), KeyboardButton(text="bank_side")],
+        [KeyboardButton(text="sbp_strict"), KeyboardButton(text="contact")],
+    ],
+    # one_time_keyboard=True,
+)
+ikm = InlineKeyboardMarkup(
+    inline_keyboard=[
+        [
+            InlineKeyboardButton(text="Обновить", callback_data="cond:refresh"),
+            InlineKeyboardButton(text="Пропустить", callback_data="cond:pass"),
+        ]
+    ]
+)
+
+
+async def get_val(typ: SynonymType.__class__, val: str | int) -> tuple[SynonymType | int | bool, str]:
+    if isinstance(val, str) and val.isnumeric():
+        val = int(val)
+    if isclass(lst := synopts[typ]) and issubclass(lst, IntEnum):
+        return (v := lst(val)), v.name
+    elif isinstance(lst, list):
+        return val, lst[val]
+    elif typ == SynonymType.bank:
+        return val, (await models.Pm[val]).norm
+    return val, val
+
+
+async def btns(typ: SynonymType.__class__, txt: str = None) -> InlineKeyboardMarkup | None:
+    if lst := synopts[typ]:
+        if isinstance(lst, list):
+            kb = [[InlineKeyboardButton(text=n, callback_data=f"st:{typ.name}:{i}")] for i, n in enumerate(lst)]
+        elif isclass(lst) and issubclass(lst, IntEnum):
+            kb = [[InlineKeyboardButton(text=i.name, callback_data=f"st:{typ.name}:{i.value}")] for i in lst]
+        else:
+            kb = [[InlineKeyboardButton(text=n, callback_data=f"st:{typ.name}:{i}")] for i, n in await lst(txt)]
+        return InlineKeyboardMarkup(inline_keyboard=kb)
+    else:
+        return lst