bafser-tgapi 1.0.0__py3-none-any.whl

bafser_tgapi/__init__.py

@@ -0,0 +1,7 @@
+from .bot import Bot, BotCmdArgs
+from .bot_with_db import BotWithDB
+from .db.msg import MsgBase
+from .db.user import TgUserBase
+from .methods import *
+from .types import *
+from .utils import check_webhook_token, configure_webhook, get_bot_name, get_url, process_update, run_long_polling, set_webhook, setup

bafser_tgapi/bot.py

@@ -0,0 +1,312 @@
+import re
+from typing import Callable, Iterable, Self, Type, TypeVar, cast
+
+from bafser import ParametrizedLogger, add_file_logger
+from typing_extensions import Protocol
+
+from .methods import *
+from .types import *
+from .utils import get_bot_name
+
+T = TypeVar("T", bound="Bot")
+type tcmd_dsc_text = str
+type tcmd_dsc_usage = str
+re_param = re.compile("<[a-z]+>", re.IGNORECASE)
+
+
+class Bot:
+    class tcmd_fn[T: "Bot"](Protocol):
+        def __call__(self, bot: T, args: "BotCmdArgs", **kwargs: str) -> str | None:
+            ...
+    type tcmd_dsc = tcmd_dsc_text | tuple[tcmd_dsc_text, tcmd_dsc_usage | list[tcmd_dsc_usage]]
+    type tcallback[T: "Bot"] = Callable[[T], None]
+    _tcommand = tuple[tcmd_fn[Self], tuple[tcmd_dsc | None, tcmd_dsc | None]]
+
+    update: Update
+    message: Message | None = None
+    callback_query: CallbackQuery | None = None
+    inline_query: InlineQuery | None = None
+    chosen_inline_result: ChosenInlineResult | None = None
+
+    _commands: dict[str, _tcommand] = {}
+    _callback: dict[Callable[..., Any], tcallback[Self]] = {}
+    _sender: User | None = None
+    chat: Chat | None = None
+    TextWrongCommand = "Wrong command"
+    TextCmdForAdmin = "Эта команда только для админов"
+    logger: "BotLogger"
+
+    @property
+    def sender(self):
+        return self._sender
+
+    @sender.setter
+    def sender(self, value: User | None):
+        self._sender = value
+        self.logger.user = value
+
+    def init(self):
+        fmt = "%(asctime)s;%(levelname)s;%(module)s;%(uid)-10s;%(uname)-15s;%(cmd)-15s;%(message)s"
+        self.logger = BotLogger(add_file_logger("logs/bot.csv", "bot", fmt, ["uid", "uname", "cmd"]))
+
+        def get_desc(v: Bot.tcmd_dsc):
+            return v if isinstance(v, str) else v[0]
+
+        for_all: list[BotCommand] = []
+        for_adm: list[BotCommand] = []
+        for cmd in self._commands.keys():
+            pub = self._commands[cmd][1][0]
+            adm = self._commands[cmd][1][1]
+            if not adm:
+                adm = pub
+            cmd = re_param.sub("", cmd)
+            if pub:
+                for_all.append(BotCommand(command=cmd, description=get_desc(pub)))
+            if adm:
+                for_adm.append(BotCommand(command=cmd, description=get_desc(adm)))
+
+        setMyCommands(for_all)
+        setMyCommands(for_adm, BotCommandScope.all_chat_administrators())
+
+    def get_my_commands(self, for_admin: bool = False):
+        i = 1 if for_admin else 0
+        r: list[tuple[str, Bot.tcmd_dsc]] = []
+        for key in self._commands.keys():
+            v = self._commands[key][1][i]
+            if v:
+                r.append((key, v))
+        return r
+
+    @classmethod
+    def add_command(cls: Type[T], command: str, *, desc: tcmd_dsc | None = None, desc_adm: tcmd_dsc | None = None):
+        def wrapper(fn: Bot.tcmd_fn[T]):
+            if "<" in command:
+                parts: list[tuple[str, bool]] = []
+                param = None
+                for ch in command:
+                    if ch == "<":
+                        param = ""
+                    elif ch == ">":
+                        if param:
+                            parts.append((param, True))
+                        param = None
+                    elif param is not None:
+                        param += ch
+                    else:
+                        if not parts or parts[-1][1]:
+                            parts.append(("", False))
+                        parts[-1] = (parts[-1][0] + ch, False)
+                res = ""
+                varnames: list[str] = []
+                for part, isvar in parts:
+                    if isvar:
+                        res += "(.*)"
+                        varnames.append(part)
+                    else:
+                        res += part
+                reg = re.compile(res, re.IGNORECASE)
+                fn.regex = reg  # type: ignore
+
+                def comparer(cmd: str):
+                    regex = cast(re.Pattern[str], fn.regex)  # type: ignore
+                    m = regex.match(cmd)
+                    if not m or len(m.groups()) != len(varnames):
+                        return None
+                    return dict(zip(varnames, m.groups()))
+                fn.comparer = comparer  # type: ignore
+
+            cls._commands[command] = (fn, (desc, desc_adm))
+            return fn
+        return wrapper
+
+    @classmethod
+    def cmd_for_admin(cls: Type[T], fn: tcmd_fn[T]):
+        def wrapped(bot: T, args: BotCmdArgs, **kwargs: str):
+            if bot.chat is None or bot.sender is None:
+                return "403(500!)"
+            ok, r = getChatMember(bot.chat.id, bot.sender.id)
+            if not ok:
+                return "403(500)"
+            if r.status != "creator" and r.status != "administrator":
+                return cls.TextCmdForAdmin
+            return fn(bot, args, **kwargs)
+        return wrapped
+
+    def _process_update(self, update: Update):
+        self.update = update
+        self.message = Undefined.default(update.message)
+        self.callback_query = Undefined.default(update.callback_query)
+        self.inline_query = Undefined.default(update.inline_query)
+        self.chosen_inline_result = Undefined.default(update.chosen_inline_result)
+        self.sender = None
+        self.chat = None
+        self.logger._reset()
+        if self.message and self.message.text != "":
+            self.sender = Undefined.default(self.message.sender)
+            self.chat = self.message.chat
+            self._on_message()
+        if self.callback_query:
+            self.sender = self.callback_query.sender
+            self.chat = self.callback_query.message.chat if Undefined.defined(self.callback_query.message) else None
+            self._on_callback_query()
+        if self.inline_query:
+            self.sender = self.inline_query.sender
+            self._call_callback(self.on_inline_query)
+        if self.chosen_inline_result:
+            self.sender = self.chosen_inline_result.sender
+            self._call_callback(self.on_chosen_inline_result)
+
+    def _call_callback(self, key: Callable[..., Any]):
+        fn = self._callback.get(key)
+        if fn:
+            fn(self)
+
+    @classmethod
+    def on_message(cls: Type[T], fn: tcallback[T]):
+        cls._callback[cls.on_message] = fn
+        return fn
+
+    @classmethod
+    def on_inline_query(cls: Type[T], fn: tcallback[T]):
+        cls._callback[cls.on_inline_query] = fn
+        return fn
+
+    @classmethod
+    def on_chosen_inline_result(cls: Type[T], fn: tcallback[T]):
+        cls._callback[cls.on_chosen_inline_result] = fn
+        return fn
+
+    def _on_message(self):
+        assert self.message
+        if self.message.text.startswith("/"):
+            r = self._on_command(self.message.text[1:])
+            if r:
+                if isinstance(r, str):
+                    self.sendMessage(r)
+            elif r is False and self.message.chat.type == "private":
+                self.sendMessage(self.TextWrongCommand)
+        else:
+            self._call_callback(self.on_message)
+
+    def _on_command(self, input: str):
+        args = BotCmdArgs(input)
+        if args.command == "":
+            return False
+        cmd, kwargs = self._find_command(args.command)
+        if not cmd:
+            return False
+        fn, _ = cmd
+        self.logger.cmd = args.command
+        r = fn(self, args, **kwargs)
+        if r:
+            return r
+        return True
+
+    def _find_command(self, cmd: str) -> tuple[_tcommand | None, dict[str, str]]:
+        c = self._commands.get(cmd, None)
+        if c:
+            return c, {}
+        for c in self._commands.values():
+            if hasattr(c[0], "comparer"):
+                kwargs = cast(dict[str, str] | None, c[0].comparer(cmd))  # type: ignore
+                if kwargs:
+                    return c, kwargs
+        return None, {}
+
+    def _on_callback_query(self):
+        assert self.callback_query
+        r = self._on_command(Undefined.default(self.callback_query.data, ""))
+        if r:
+            self.answerCallbackQuery(r if isinstance(r, str) else None)
+        else:
+            self.answerCallbackQuery(self.TextWrongCommand)
+
+    def sendMessage(self, text: str, message_thread_id: int | None = None, use_markdown: bool = False,
+                    reply_markup: InlineKeyboardMarkup | None = None, reply_parameters: ReplyParameters | None = None,
+                    entities: List[MessageEntity] | None = None, chat_id: str | int | None = None):
+        if chat_id is None:
+            if self.message:
+                chat_id = self.message.chat.id
+                if message_thread_id is None and self.message.is_topic_message and Undefined.defined(self.message.message_thread_id):
+                    message_thread_id = self.message.message_thread_id
+            elif self.callback_query and Undefined.defined(self.callback_query.message):
+                chat_id = self.callback_query.message.chat.id
+                if message_thread_id is None and Undefined.defined(self.callback_query.message.message_thread_id):
+                    message_thread_id = self.callback_query.message.message_thread_id
+            else:
+                raise Exception("tgapi: cant send message without chat id")
+        return sendMessage(chat_id, text, message_thread_id, use_markdown, reply_markup, reply_parameters, entities)
+
+    def answerCallbackQuery(self, text: str | None = None, show_alert: bool = False, url: str | None = None, cache_time: int = 0):
+        if self.callback_query is None:
+            raise Exception("tgapi: Bot.answerCallbackQuery is avaible only inside on_callback_query")
+        return answerCallbackQuery(self.callback_query.id, text, show_alert, url, cache_time)
+
+    def answerInlineQuery(self, results: list[InlineQueryResult], cache_time: int = 300, is_personal: bool = False, next_offset: str | None = None):
+        if self.inline_query is None:
+            raise Exception("tgapi: Bot.answerInlineQuery is avaible only inside on_inline_query")
+        return answerInlineQuery(self.inline_query.id, results, cache_time, is_personal, next_offset)
+
+
+@Bot.on_inline_query
+def _(bot: Bot):
+    bot.answerInlineQuery([])
+
+
+class BotLogger(ParametrizedLogger):
+    user: User | None = None
+    cmd = ""
+
+    def _reset(self):
+        self.user = None
+        self.cmd = ""
+
+    def _get_args(self) -> dict[str, str | int]:
+        return {
+            "uid": self.user.id if self.user else -1,
+            "uname": self.user.username if self.user else "",
+            "cmd": self.cmd
+        }
+
+
+class BotCmdArgs(Iterable[str]):
+    input: str
+    args: list[str]
+    raw_args = ""
+    raw_argsI = -1
+    command = ""
+
+    def __init__(self, input: str):
+        self.input = input
+        self.args = [str.strip(v) for v in input.split()]
+
+        if len(self.args) == 0:
+            return
+
+        command = self.args[0]
+        mention = command.find("@")
+        if mention > 0:
+            bot_name = command[mention:]
+            if bot_name != get_bot_name():
+                return
+            command = command[:mention]
+        self.command = command
+
+        self.args = self.args[1:]
+
+        i = input.find(" ")
+        if i > 0:
+            while i < len(input) and input[i] == " ":
+                i += 1
+            self.raw_argsI = MessageEntity.len(input[:i])
+            self.raw_args = input[i:]
+
+    def __getitem__(self, i: int):
+        return self.args[i]
+
+    def __len__(self):
+        return len(self.args)
+
+    def __iter__(self):
+        for arg in self.args:
+            yield arg

bafser_tgapi/bot_with_db.py

@@ -0,0 +1,27 @@
+from typing import Any, Type, TypeVar
+
+from bafser import db_session
+from sqlalchemy.orm import Session
+
+from .bot import Bot, BotCmdArgs
+from .types import User
+
+T = TypeVar("T", bound="BotWithDB[Any]", covariant=True)
+
+
+class BotWithDB[TUser](Bot):
+    db_sess: Session | None = None
+    user: TUser | None = None
+
+    def get_user(self, db_sess: Session, sender: User) -> TUser:
+        raise Exception("tgapi: Method BotWithDB.get_user must be implemented in subclass")
+
+    @classmethod
+    def cmd_connect_db(cls: Type[T], fn: Bot.tcmd_fn[T]):
+        def wrapped(bot: T, args: BotCmdArgs, **kwargs: str):
+            assert bot.sender
+            with db_session.create_session() as db_sess:
+                bot.db_sess = db_sess
+                bot.user = bot.get_user(db_sess, bot.sender)
+                return fn(bot, args, **kwargs)
+        return wrapped

bafser_tgapi/db/msg.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from bafser import IdMixin, Log, SqlAlchemyBase, Undefined, UserBase
+from sqlalchemy import BigInteger, String
+from sqlalchemy.orm import Mapped, Session, mapped_column
+
+import bafser_tgapi
+
+
+class MsgBase(SqlAlchemyBase, IdMixin):
+    __abstract__ = True
+
+    message_id: Mapped[int] = mapped_column()
+    message_thread_id: Mapped[Optional[int]] = mapped_column()
+    chat_id: Mapped[int] = mapped_column(BigInteger)
+    text: Mapped[Optional[str]] = mapped_column(String(512))
+
+    @classmethod
+    def new(cls, creator: UserBase, message_id: int, chat_id: int, text: str | None = None, message_thread_id: int | None = None,
+            *_: Any, **kwargs: Any):
+        db_sess = Session.object_session(creator)
+        assert db_sess
+        msg, add_changes = cls._new(db_sess, message_id, chat_id, text, message_thread_id, **kwargs)
+
+        db_sess.add(msg)
+        Log.added(msg, creator, add_changes)
+
+        return msg
+
+    @classmethod
+    def _new(cls, db_sess: Session, message_id: int, chat_id: int, text: str | None, message_thread_id: int | None, **kwargs: Any):
+        user = cls(message_id=message_id, chat_id=chat_id, text=text, message_thread_id=message_thread_id)
+        changes = [
+            ("message_id", user.message_id),
+            ("chat_id", user.chat_id),
+            ("text", user.text),
+            ("message_thread_id", user.message_thread_id),
+        ]
+        return user, changes
+
+    @classmethod
+    def new_from_data(cls, creator: UserBase, data: bafser_tgapi.Message):
+        return cls.new(creator, data.message_id, data.chat.id, data.text, Undefined.default(data.message_thread_id))
+
+    def delete(self, actor: UserBase, commit=True):
+        db_sess = Session.object_session(self)
+        assert db_sess
+        db_sess.delete(self)
+        Log.deleted(self, actor, commit=commit)

bafser_tgapi/db/user.py

@@ -0,0 +1,76 @@
+from typing import Any, override
+
+from bafser import UserBase, UserKwargs, randstr
+from sqlalchemy import BigInteger, String, func
+from sqlalchemy.orm import Mapped, Session, mapped_column
+
+from ..types import User
+
+
+class TgUserBase(UserBase):
+    __abstract__ = True
+    _default_role = -1
+    id_tg: Mapped[int] = mapped_column(BigInteger, index=True, unique=True)
+    is_bot: Mapped[bool] = mapped_column()
+    first_name: Mapped[str] = mapped_column(String(128))
+    last_name: Mapped[str] = mapped_column(String(128))
+    username: Mapped[str] = mapped_column(String(128))
+    language_code: Mapped[str] = mapped_column(String(16))
+
+    @classmethod
+    def new(cls, db_sess: Session, id_tg: int, is_bot: bool, first_name: str, last_name: str, username: str, language_code: str,
+            *_: Any, **__: Any):
+        fake_creator = UserBase.get_fake_system()
+        return super().new(fake_creator, str(id_tg), randstr(8), username, [cls._default_role], db_sess=db_sess,
+                           id_tg=id_tg, is_bot=is_bot, first_name=first_name, last_name=last_name, username=username, language_code=language_code)
+
+    @classmethod
+    @override
+    def _new(cls, db_sess: Session, user_kwargs: UserKwargs, *,
+             id_tg: int, is_bot: bool, first_name: str, last_name: str, username: str, language_code: str, **kwargs: Any):
+        user = cls(**user_kwargs,
+                   id_tg=id_tg, is_bot=is_bot, first_name=first_name, last_name=last_name, username=username, language_code=language_code)
+        changes = [
+            ("id_tg", user.id_tg),
+            ("is_bot", user.is_bot),
+            ("first_name", user.first_name),
+            ("last_name", user.last_name),
+            ("username", user.username),
+            ("language_code", user.language_code),
+        ]
+        return user, changes
+
+    @classmethod
+    @override
+    def create_admin(cls, db_sess: Session):
+        return cls.new(db_sess, 0, False, "Админ", "", "admin", "en")
+
+    def __repr__(self):
+        return f"<User> [{self.id} {self.id_tg}] {self.username}"
+
+    def get_name(self):
+        return f"{self.first_name} {self.last_name}".strip()
+
+    def get_username(self):
+        if self.username != "":
+            return self.username
+        return self.get_name()
+
+    def get_tagname(self):
+        if self.username != "":
+            return f"@{self.username}"
+        return f"🥷 {self.get_name()}"
+
+    @classmethod
+    def new_from_data(cls, db_sess: Session, data: "User"):
+        return cls.new(db_sess, data.id, data.is_bot, data.first_name, data.last_name, data.username, data.language_code)
+
+    @classmethod
+    def get_by_id_tg(cls, db_sess: Session, id_tg: int):
+        return cls.query(db_sess).filter(cls.id_tg == id_tg).first()
+
+    @classmethod
+    def get_by_username(cls, db_sess: Session, username: str):
+        if username.startswith("@"):
+            username = username[1:]
+        return cls.query(db_sess).filter(func.lower(cls.username) == username.lower()).first()

bafser_tgapi/methods.py

@@ -0,0 +1,187 @@
+from typing import List, Union
+
+from .types import *
+from .utils import call
+
+
+# https://core.telegram.org/bots/api#getupdates
+def getUpdates(offset: int = 0, timeout: int = 0):
+    ok, r = call("getUpdates", {"offset": offset, "timeout": timeout}, timeout=timeout + 5)
+    if not ok:
+        return False, r
+    return True, list(map(lambda x: Update.new(x).valid(), r["result"]))
+
+
+# https://core.telegram.org/bots/api#getwebhookinfo
+def getWebhookInfo():
+    ok, r = call("getWebhookInfo")
+    if not ok:
+        return False, r
+    return True, WebhookInfo.new(r["result"]).valid()
+
+
+# https://core.telegram.org/bots/api#setwebhook
+def setWebhook(url: str, secret_token: str | None = None, allowed_updates: list[str] | None = None):
+    return call("setWebhook", {"url": url, "secret_token": secret_token, "allowed_updates": allowed_updates})
+
+
+# https://core.telegram.org/bots/api#deletewebhook
+def deleteWebhook(drop_pending_updates: bool | None = None):
+    return call("deleteWebhook", {"drop_pending_updates": drop_pending_updates})
+
+
+# https://core.telegram.org/bots/api#sendmessage
+def sendMessage(chat_id: str | int, text: str, message_thread_id: int | None = None, use_markdown: bool = False,
+                reply_markup: InlineKeyboardMarkup | None = None, reply_parameters: ReplyParameters | None = None,
+                entities: List[MessageEntity] | None = None):
+    ok, r = call("sendMessage", {
+        "chat_id": chat_id,
+        "message_thread_id": message_thread_id,
+        "text": text,
+        "parse_mode": "MarkdownV2" if use_markdown else None,
+        "reply_markup": reply_markup,
+        "reply_parameters": reply_parameters,
+        "entities": entities,
+    })
+    if not ok:
+        return False, r
+    return True, Message.new(r["result"]).valid()
+
+
+# https://core.telegram.org/bots/api#editmessagetext
+def editMessageText(chat_id: Union[int, str], message_id: int, text: str, use_markdown: bool = False,
+                    reply_markup: InlineKeyboardMarkup | None = None, entities: List[MessageEntity] | None = None):
+    ok, r = call("editMessageText", {
+        "chat_id": chat_id,
+        "message_id": message_id,
+        "text": text,
+        "parse_mode": "MarkdownV2" if use_markdown else None,
+        "reply_markup": reply_markup,
+        "entities": entities,
+    })
+    if not ok:
+        return False, r
+    return True, Message.new(r["result"]).valid()
+
+
+# https://core.telegram.org/bots/api#editmessagetext
+def editMessageText_inline(inline_message_id: str, text: str, use_markdown: bool = False, reply_markup: InlineKeyboardMarkup | None = None):
+    ok, r = call("editMessageText", {
+        "inline_message_id": inline_message_id,
+        "text": text,
+        "parse_mode": "MarkdownV2" if use_markdown else None,
+        "reply_markup": reply_markup,
+    })
+    if not ok:
+        return False, r
+    return True, Message.new(r["result"]).valid()
+
+
+# https://core.telegram.org/bots/api#editmessagereplymarkup
+def editMessageReplyMarkup(chat_id: Union[int, str], message_id: int, reply_markup: InlineKeyboardMarkup):
+    ok, r = call("editMessageReplyMarkup", {
+        "chat_id": chat_id,
+        "message_id": message_id,
+        "reply_markup": reply_markup,
+    })
+    if not ok:
+        return False, r
+    return True, Message.new(r["result"]).valid()
+
+
+# https://core.telegram.org/bots/api#editmessagereplymarkup
+def editMessageReplyMarkup_inline(inline_message_id: str, reply_markup: InlineKeyboardMarkup):
+    ok, r = call("editMessageReplyMarkup", {
+        "inline_message_id": inline_message_id,
+        "reply_markup": reply_markup,
+    })
+    if not ok:
+        return False, r
+    return True, Message.new(r["result"]).valid()
+
+
+# https://core.telegram.org/bots/api#deletemessage
+def deleteMessage(chat_id: Union[int, str], message_id: int):
+    ok, r = call("deleteMessage", {
+        "chat_id": chat_id,
+        "message_id": message_id,
+    })
+    if not ok:
+        return False, r
+    return True, r["result"]
+
+
+# https://core.telegram.org/bots/api#answerinlinequery
+def answerInlineQuery(
+    inline_query_id: str,
+    results: list[InlineQueryResult],
+    cache_time: int = 300,
+    is_personal: bool = False,
+    next_offset: str | None = None,
+    # button: InlineQueryResultsButton = None,
+):
+    ok, r = call("answerInlineQuery", {
+        "inline_query_id": inline_query_id,
+        "results": results,
+        "cache_time": cache_time,
+        "is_personal": is_personal,
+        "next_offset": next_offset,
+    })
+    if not ok:
+        return False, r
+    return True, r["result"]
+
+
+# https://core.telegram.org/bots/api#answercallbackquery
+def answerCallbackQuery(
+    callback_query_id: str,
+    text: str | None = None,
+    show_alert: bool = False,
+    url: str | None = None,
+    cache_time: int = 0,
+):
+    ok, r = call("answerCallbackQuery", {
+        "callback_query_id": callback_query_id,
+        "text": text,
+        "show_alert": show_alert,
+        "url": url,
+        "cache_time": cache_time,
+    })
+    if not ok:
+        return False, r
+    return True, r["result"]
+
+
+# https://core.telegram.org/bots/api#setmycommands
+def setMyCommands(commands: list[BotCommand], scope: BotCommandScope | None = None, language_code: str | None = None):
+    ok, r = call("setMyCommands", {
+        "commands": commands,
+        "scope": scope,
+        "language_code": language_code,
+    })
+    if not ok:
+        return False, r
+    return True, r["result"]
+
+
+# https://core.telegram.org/bots/api#getchatmember
+def getChatMember(chat_id: Union[str, int], user_id: int):
+    ok, r = call("getChatMember", {
+        "chat_id": chat_id,
+        "user_id": user_id,
+    })
+    if not ok:
+        return False, r
+    return True, ChatMember.new(r["result"]).valid()
+
+
+# https://core.telegram.org/bots/api#pinchatmessage
+def pinChatMessage(chat_id: Union[str, int], message_id: int, disable_notification: bool = True):
+    ok, r = call("pinChatMessage", {
+        "chat_id": chat_id,
+        "message_id": message_id,
+        "disable_notification": disable_notification,
+    })
+    if not ok:
+        return False, r
+    return True, r["result"]

bafser_tgapi/types.py

@@ -0,0 +1,316 @@
+from datetime import datetime
+from typing import Any, Literal, Union, override
+
+from bafser import JsonObj, JsonOpt, Undefined
+
+
+class WebhookInfo(JsonObj):
+    # https://core.telegram.org/bots/api#webhookinfo
+    url: str
+
+
+class User(JsonObj):
+    # https://core.telegram.org/bots/api#user
+    id: int
+    is_bot: bool
+    first_name: str
+    last_name: str = ""
+    username: str = ""
+    language_code: str = ""
+
+
+class Chat(JsonObj):
+    # https://core.telegram.org/bots/api#chat
+    id: int
+    type: Literal["private", "group", "supergroup", "channel"]
+    title: str = ""
+    is_forum: bool = False
+
+
+class MessageEntity(JsonObj):
+    class _User(JsonObj):
+        id: int
+
+    Type = Literal["mention", "hashtag", "cashtag", "bot_command", "url", "email", "phone_number", "bold", "italic", "underline",
+                   "strikethrough", "spoiler", "blockquote", "expandable_blockquote", "code", "pre", "text_link", "text_mention", "custom_emoji"]
+    # https://core.telegram.org/bots/api#messageentity
+    type: Type
+    offset: int
+    length: int
+    url: JsonOpt[str] = Undefined
+    user: JsonOpt[_User] = Undefined
+    language: JsonOpt[str] = Undefined
+    custom_emoji_id: JsonOpt[str] = Undefined
+
+    @staticmethod
+    def text_mention(offset: int, length: int, user_id: int):
+        return MessageEntity(type="text_mention", offset=offset, length=length, user=MessageEntity._User(id=user_id))
+
+    @staticmethod
+    def blockquote(offset: int, length: int):
+        return MessageEntity(type="blockquote", offset=offset, length=length)
+
+    @staticmethod
+    def spoiler(offset: int, length: int):
+        return MessageEntity(type="spoiler", offset=offset, length=length)
+
+    @staticmethod
+    def bold(offset: int, length: int):
+        return MessageEntity(type="bold", offset=offset, length=length)
+
+    @staticmethod
+    def italic(offset: int, length: int):
+        return MessageEntity(type="italic", offset=offset, length=length)
+
+    @staticmethod
+    def underline(offset: int, length: int):
+        return MessageEntity(type="underline", offset=offset, length=length)
+
+    @staticmethod
+    def len(text: str):
+        return len(MessageEntity.encode_text(text)) // 2
+
+    @staticmethod
+    def encode_text(text: str):
+        return text.encode("utf-16-le")
+
+    @staticmethod
+    def decode_text(text: bytes):
+        return text.decode("utf-16-le")
+
+    def get_msg_text(self, msg: str):
+        text = MessageEntity.encode_text(msg)
+        s = self.offset * 2 - 2
+        e = s + self.length * 2
+        return MessageEntity.decode_text(text[s:e])
+
+
+class Message(JsonObj):
+    # https://core.telegram.org/bots/api#message
+    __datetime_parser__ = datetime.fromtimestamp
+    message_id: int
+    message_thread_id: JsonOpt[int]
+    sender: JsonOpt[User]
+    chat: Chat
+    reply_to_message: JsonOpt["Message"]
+    is_topic_message: bool = False
+    text: str = ""
+    date: datetime
+    entities: list[MessageEntity] = []
+
+    @override
+    def _parse(self, key: str, v: Any, json: dict[str, Any]):
+        if key == "from":
+            return "sender", v
+
+
+class InaccessibleMessage(JsonObj):
+    # https://core.telegram.org/bots/api#inaccessiblemessage
+    __datetime_parser__ = datetime.fromtimestamp
+    message_id: int
+    chat: Chat
+    date: datetime
+    message_thread_id = Undefined
+
+
+class InlineQuery(JsonObj):
+    # https://core.telegram.org/bots/api#inlinequery
+    id: str
+    sender: User
+    query: str
+    offset: str
+    chat_type: JsonOpt[Literal["sender", "private", "group", "supergroup", "channel"]]
+
+    @override
+    def _parse(self, key: str, v: Any, json: dict[str, Any]):
+        if key == "from":
+            return "sender", v
+
+
+type MaybeInaccessibleMessage = Message | InaccessibleMessage
+
+
+class CallbackQuery(JsonObj):
+    # https://core.telegram.org/bots/api#callbackquery
+    id: str
+    sender: User
+    message: JsonOpt[MaybeInaccessibleMessage]
+    inline_message_id: JsonOpt[str]
+    chat_instance: str
+    data: JsonOpt[str]
+    game_short_name: JsonOpt[str]
+
+    @override
+    def _parse(self, key: str, v: Any, json: dict[str, Any]):
+        if key == "from":
+            return "sender", v
+
+
+class ChosenInlineResult(JsonObj):
+    # https://core.telegram.org/bots/api#choseninlineresult
+    result_id: str
+    sender: User
+    # location: Location
+    inline_message_id: JsonOpt[str]
+    query: str
+
+    @override
+    def _parse(self, key: str, v: Any, json: dict[str, Any]):
+        if key == "from":
+            return "sender", v
+
+
+class Update(JsonObj):
+    # https://core.telegram.org/bots/api#update
+    update_id: int
+    message: JsonOpt[Message]
+    inline_query: JsonOpt[InlineQuery]
+    callback_query: JsonOpt[CallbackQuery]
+    chosen_inline_result: JsonOpt[ChosenInlineResult]
+
+
+class InputTextMessageContent(JsonObj):
+    # https://core.telegram.org/bots/api#inputtextmessagecontent
+    message_text: str
+    parse_mode: JsonOpt[Literal["MarkdownV2", "HTML", "Markdown"]] = Undefined
+    entities: JsonOpt[list[MessageEntity]] = Undefined
+    # link_preview_options: LinkPreviewOptions
+
+    @staticmethod
+    def nw(message_text: str, use_markdown: bool = False):
+        return InputTextMessageContent(
+            message_text=message_text,
+            parse_mode="MarkdownV2" if use_markdown else Undefined
+        )
+
+
+type InputMessageContent = InputTextMessageContent
+
+
+class CallbackGame(JsonObj):
+    # https://core.telegram.org/bots/api#callbackgame
+    pass
+
+
+class CopyTextButton(JsonObj):
+    # https://core.telegram.org/bots/api#copytextbutton
+    text: str
+
+
+class InlineKeyboardButton(JsonObj):
+    # https://core.telegram.org/bots/api#inlinekeyboardbutton
+    text: str
+    url: JsonOpt[str] = Undefined
+    callback_data: JsonOpt[str] = Undefined
+    # web_app: WebAppInfo
+    # login_url: LoginUrl
+    switch_inline_query: JsonOpt[str] = Undefined
+    switch_inline_query_current_chat: JsonOpt[str] = Undefined
+    # switch_inline_query_chosen_chat: SwitchInlineQueryChosenChat
+    copy_text: JsonOpt[CopyTextButton] = Undefined
+    callback_game: JsonOpt[CallbackGame] = Undefined
+    # pay: bool
+
+    @staticmethod
+    def callback(text: str, callback_data: str):
+        return InlineKeyboardButton(text=text, callback_data=callback_data)
+
+    @staticmethod
+    def inline_query_current_chat(text: str, query: str):
+        return InlineKeyboardButton(text=text, switch_inline_query_current_chat=query)
+
+    @staticmethod
+    def run_game(text: str):
+        return InlineKeyboardButton(text=text, callback_game=CallbackGame())
+
+    @staticmethod
+    def open_url(text: str, url: str):
+        return InlineKeyboardButton(text=text, url=url)
+
+
+class InlineKeyboardMarkup(JsonObj):
+    # https://core.telegram.org/bots/api#inlinekeyboardmarkup
+    inline_keyboard: list[list[InlineKeyboardButton]]
+
+
+class InlineQueryResult:
+    # https://core.telegram.org/bots/api#inlinequeryresult
+    pass
+
+
+class InlineQueryResultArticle(JsonObj, InlineQueryResult):
+    # https://core.telegram.org/bots/api#inlinequeryresultarticle
+    type: Literal["article"] = JsonObj.field(default="article", init=False)
+    id: str
+    title: str
+    input_message_content: InputMessageContent
+    reply_markup: JsonOpt[InlineKeyboardMarkup] = Undefined
+    url: JsonOpt[str] = Undefined
+    description: JsonOpt[str] = Undefined
+    thumbnail_url: JsonOpt[str] = Undefined
+    thumbnail_width: JsonOpt[int] = Undefined
+    thumbnail_height: JsonOpt[int] = Undefined
+
+
+class InlineQueryResultGame(JsonObj, InlineQueryResult):
+    # https://core.telegram.org/bots/api#inlinequeryresultgame
+    type: Literal["game"] = JsonObj.field(default="game", init=False)
+    id: str
+    game_short_name: str
+    reply_markup: JsonOpt[InlineKeyboardMarkup] = Undefined
+
+
+class BotCommand(JsonObj):
+    # https://core.telegram.org/bots/api#botcommand
+    command: str  # 1-32 characters. Can contain only lowercase English letters, digits and underscores.
+    description: str  # 1-256 characters.
+
+
+class ChatMember(JsonObj):
+    # https://core.telegram.org/bots/api#chatmember
+    status: Literal["creator", "administrator", "member", "restricted", "left", "kicked"]
+    user: User
+
+
+BotCommandScopeType = Literal["default", "all_private_chats", "all_group_chats",
+                              "all_chat_administrators", "chat", "chat_administrators", "chat_member"]
+
+
+class BotCommandScope(JsonObj):
+    # https://core.telegram.org/bots/api#botcommandscope
+    type: BotCommandScopeType
+    chat_id: JsonOpt[Union[str, int]] = Undefined
+    user_id: JsonOpt[int] = Undefined
+
+    @staticmethod
+    def default():
+        return BotCommandScope(type="default")
+
+    @staticmethod
+    def all_private_chats():
+        return BotCommandScope(type="all_private_chats")
+
+    @staticmethod
+    def all_group_chats():
+        return BotCommandScope(type="all_group_chats")
+
+    @staticmethod
+    def all_chat_administrators():
+        return BotCommandScope(type="all_chat_administrators")
+
+    @staticmethod
+    def chat(chat_id: Union[str, int]):
+        return BotCommandScope(type="chat", chat_id=chat_id)
+
+    @staticmethod
+    def chat_administrators(chat_id: Union[str, int]):
+        return BotCommandScope(type="chat_administrators", chat_id=chat_id)
+
+    @staticmethod
+    def chat_member(chat_id: Union[str, int], user_id: int):
+        return BotCommandScope(type="chat_member", chat_id=chat_id, user_id=user_id)
+
+
+class ReplyParameters(JsonObj):
+    # https://core.telegram.org/bots/api#replyparameters
+    message_id: int

bafser_tgapi/utils.py

@@ -0,0 +1,185 @@
+import importlib
+import logging
+import os
+from typing import TYPE_CHECKING, Any, Type
+
+import requests
+from bafser import JsonObj, Undefined, response_msg
+from flask import Flask, g, request
+
+from .types import Update
+
+if TYPE_CHECKING:
+    from .bot import Bot
+
+bot_token = ""
+bot_name = ""
+webhook_token = ""
+url = ""
+
+bot: "Bot | None" = None
+webhook_route = "/webhook"
+
+
+def setup(config_path: str = "config.txt", botCls: Type["Bot"] | None = None, import_folder: str | None = None, app: Flask | None = None):
+    global bot_token, bot_name, webhook_token, url, bot
+    try:
+        data = read_config(config_path)
+        bot_token = data["bot_token"]
+        bot_name = data["bot_name"]
+        webhook_token = data["webhook_token"]
+        url = data["url"].strip("/") + "/"
+    except Exception as e:
+        logging.error(f"Cant read config\n{e}")
+        raise e
+
+    if import_folder:
+        if not os.path.exists(import_folder):
+            return
+
+        def import_dir(path: str):
+            import_module = path.replace("/", ".").replace("\\", ".")
+            for file in os.listdir(path):
+                fpath = os.path.join(path, file)
+                if os.path.isdir(fpath):
+                    import_dir(fpath)
+                    continue
+                if not file.endswith(".py"):
+                    continue
+                module = import_module + "." + file[:-3]
+                importlib.import_module(module)
+
+        import_dir(import_folder)
+
+    if botCls:
+        bot = botCls()
+        bot.init()
+
+    if app:
+        app.post(webhook_route)(webhook)
+
+
+def read_config(path: str):
+    data: dict[str, str] = {}
+    with open(path) as f:
+        for line in f:
+            if "=" not in line:
+                continue
+            i = line.index("=")
+            key, value = line[:i], line[i + 1:]
+            data[key.strip().replace(" ", "_")] = value.strip()
+    return data
+
+
+def check_webhook_token(token: str):
+    return token == webhook_token
+
+
+def get_url(path: str):
+    while path.startswith("/"):
+        path = path[1:]
+    return url + path
+
+
+def get_bot_name():
+    return bot_name
+
+
+def process_update(update: Update):
+    if not bot:
+        raise Exception("tgapi: cant process update without Bot specified in setup")
+    bot._process_update(update)
+
+
+def run_long_polling():
+    from .methods import getUpdates
+    print("listening for updates...")
+    update_id = -1
+    while True:
+        ok, updates = getUpdates(update_id + 1, 60)
+        if not ok:
+            print("Error!", updates)
+            break
+        for update in updates:
+            update_id = max(update_id, update.update_id)
+            print(f"Update(update_id={update.update_id}, {", ".join(k for k, v in update.items() if Undefined.default(v) and k != "update_id")})")
+            process_update(update)
+
+
+def webhook():
+    token = request.headers.get("X-Telegram-Bot-Api-Secret-Token", "")
+    if (not check_webhook_token(token)):
+        return response_msg("wrong token", 403)
+
+    values, is_json = g.json
+    if not is_json:
+        return response_msg("body is not json", 415)
+
+    logging.info(f"webhook: {values}")
+    process_update(Update.new(values).valid())
+    return "ok"
+
+
+def call(method: str, data: JsonObj | dict[str, Any] | None = None, timeout: int | None = None):
+    if timeout is not None and timeout <= 0:
+        timeout = None
+    json = None
+    if isinstance(data, dict):
+        json = __item_to_json__(data)
+    elif data:
+        json = data.json()
+    try:
+        r = requests.post(f"https://api.telegram.org/bot{bot_token}/{method}", json=json, timeout=timeout)
+        if not r.ok:
+            logging.error(f"tgapi: {method} [{r.status_code}]\t{json}; {r.content}")
+            return False, r.json()
+        rj = r.json()
+        logging.info(f"tgapi: {method}\t{json} -> {rj}")
+        return True, rj
+    except Exception as e:
+        logging.error(f"tgapi call error\n{e}")
+        raise Exception("tgapi call error")
+
+
+def __item_to_json__(item: Any) -> Any:
+    if isinstance(item, dict):
+        r = {}
+        for field, v in item.items():
+            v = __item_to_json__(v)
+            if v is not None:
+                r[field] = v
+        return r
+    if isinstance(item, (list, tuple)):
+        return [__item_to_json__(v) for v in item if v is not None]
+    if isinstance(item, JsonObj):
+        return item.json()
+    return item
+
+
+def set_webhook(allowed_updates: list[str] | None = None):
+    from .methods import setWebhook
+    ok, r = setWebhook(get_url(webhook_route), webhook_token, allowed_updates)
+    if not ok:
+        raise Exception(f"tgapi: cant set webhook\n{r}")
+
+
+def configure_webhook(set: bool, allowed_updates: list[str] | None = None, *, config_path: str | None = None):
+    global bot_token, bot_name, webhook_token, url
+    from .methods import deleteWebhook, setWebhook
+    if config_path:
+        try:
+            config = read_config(config_path)
+            bot_token = config["bot_token"]
+            bot_name = config["bot_name"]
+            webhook_token = config["webhook_token"]
+            url = config["url"].strip("/") + "/"
+        except Exception as e:
+            print(f"Cant read config\n{e}")
+            return
+
+    if set:
+        ok, r = setWebhook(get_url(webhook_route), webhook_token, allowed_updates)
+    else:
+        ok, r = deleteWebhook(True)
+
+    print(f"{ok}\n {r}")

bafser_tgapi-1.0.0.dist-info/METADATA

@@ -0,0 +1,115 @@
+Metadata-Version: 2.4
+Name: bafser_tgapi
+Version: 1.0.0
+Summary: bafser tg api
+Project-URL: Homepage, https://github.com/MixelTe/bafser_tgapi
+Project-URL: Issues, https://github.com/MixelTe/bafser_tgapi/issues
+Author: Mixel Te
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: ==3.12.*
+Requires-Dist: bafser==2.2.11
+Requires-Dist: requests
+Description-Content-Type: text/markdown
+
+# bafser tgapi
+
+
+## usage
+init project: `bafser init_project`
+set webhook: `bafser configure_webhook set`
+delete webhook: `bafser configure_webhook delete`
+
+main.py
+```py
+import sys
+
+from bafser import AppConfig, create_app
+import bafser_tgapi as tgapi
+
+from bot.bot import Bot
+from scripts.init_db import init_db
+
+app, run = create_app(__name__, AppConfig(DEV_MODE="dev" in sys.argv))
+
+tgapi.setup(
+    config_path="config_dev.txt" if __name__ == "__main__" else "config.txt",
+    botCls=Bot,
+    import_folder="bot",
+    app=app,
+)
+
+run(False, init_db)
+
+if __name__ == "__main__":
+    tgapi.run_long_polling()
+else:
+    tgapi.set_webhook()
+
+```
+
+init_db.py
+```py
+from bafser import AppConfig
+from sqlalchemy.orm import Session
+
+from data.user import Roles, User
+
+
+def init_db(db_sess: Session, config: AppConfig):
+    u = User.new(db_sess, 12345, False, "Admin", "", "username", "en")
+    u.add_role(u, Roles.admin)
+
+    db_sess.commit()
+
+```
+
+data.user.py
+```py
+from bafser_tgapi import TgUserBase
+
+from data._roles import Roles
+
+
+class User(TgUserBase):
+    _default_role = Roles.user
+
+```
+
+data.msg.py
+```py
+from bafser_tgapi import MsgBase
+
+from data._tables import Tables
+
+
+class Msg(MsgBase):
+    __tablename__ = Tables.Msg
+
+```
+
+bot.py
+```py
+from typing import override
+
+from bafser import Log
+import bafser_tgapi as tgapi
+from sqlalchemy.orm import Session
+
+from data.user import User
+
+
+class Bot(tgapi.BotWithDB[User]):
+    @override
+    def get_user(self, db_sess: Session, sender: tgapi.User) -> User:
+        user = User.get_by_id_tg(db_sess, sender.id)
+        if user is None:
+            user = User.new_from_data(db_sess, sender)
+        if user.username != sender.username:
+            old_username = user.username
+            user.username = sender.username
+            Log.updated(user, user, [("username", old_username, user.username)])
+        return user
+```

bafser_tgapi-1.0.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+bafser_tgapi/__init__.py,sha256=r7sYqKWWrFfqeD7X3n3HTDSuD77o4qMTxP7JRUhu4hg,307
+bafser_tgapi/bot.py,sha256=c7Y2owbHY93OfR0jpJBUQ7P3ID7Qn9jiRS1Q833aMoc,11582
+bafser_tgapi/bot_with_db.py,sha256=MOBrHlz82MHi6oteITFKUi4bfCw_-WBJliiM13isp_M,868
+bafser_tgapi/methods.py,sha256=jYnqJlgANZYh6xpeF-AUQfVcdrnH1WdGolfdzsC9XG0,6133
+bafser_tgapi/types.py,sha256=vumTJMSc8iOFduUATZnS7fpKfhqJF1tUkdTlUeHHPco,9512
+bafser_tgapi/utils.py,sha256=xIteUekxklgLMjiVSVskzJYei9j8istgr791o4vYVJs,5409
+bafser_tgapi/db/msg.py,sha256=fTSt794LJp_UUxJqgl-cjCs0kpjZwGVvm6thSdY5C5Q,1902
+bafser_tgapi/db/user.py,sha256=YiY9H2bTSSaGRPpSsK2JK5jj2SILdrkr_v1dPXvndc0,3018
+bafser_tgapi-1.0.0.dist-info/METADATA,sha256=Mvp8I2dp1G8Fy4r42LeuZMMwuC_aJT0RAem7WmNNqPQ,2375
+bafser_tgapi-1.0.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+bafser_tgapi-1.0.0.dist-info/licenses/LICENSE,sha256=KnwobioUD95na9chjt9X3VNZRoNm373L-htaEgrQkCc,1064
+bafser_tgapi-1.0.0.dist-info/RECORD,,

bafser_tgapi-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

bafser_tgapi-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 MixelTe
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.