bafser-tgapi 1.0.0__tar.gz

bafser_tgapi-1.0.0/.github/workflows/main.yml

@@ -0,0 +1,34 @@
+name: Publish Python 🐍 distribution 📦 to PyPI
+
+on: [push]
+
+jobs:
+  build:
+    name: >-
+      Publish Python 🐍 distribution 📦 to PyPI
+    if: startsWith(github.ref, 'refs/tags/v')  # only publish to PyPI on tag pushes
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/bafser_tgapi
+    permissions:
+      id-token: write  # IMPORTANT: mandatory for trusted publishing
+
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        persist-credentials: false
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: "3.x"
+    - name: Install pypa/build
+      run: >-
+        python3 -m
+        pip install
+        build
+        --user
+    - name: Build a binary wheel and a source tarball
+      run: python3 -m build
+    - name: Publish distribution 📦 to PyPI
+      uses: pypa/gh-action-pypi-publish@release/v1

bafser_tgapi-1.0.0/.gitignore

@@ -0,0 +1,7 @@
+.venv/
+__pycache__/
+build/
+dist/
+test/db
+test/logs
+test/secret_key_jwt.txt

bafser_tgapi-1.0.0/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.

bafser_tgapi-1.0.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,99 @@
+# 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/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["hatchling >= 1.26"]
+build-backend = "hatchling.build"
+
+[project]
+name = "bafser_tgapi"
+version = "1.0.0"
+authors = [
+	{ name = "Mixel Te" },
+]
+description = "bafser tg api"
+readme = "README.md"
+requires-python = "== 3.12.*"
+classifiers = [
+    "Programming Language :: Python :: 3.12",
+    "Operating System :: OS Independent",
+]
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+dependencies = [
+	"bafser==2.2.11",
+	"requests",
+]
+
+[project.urls]
+Homepage = "https://github.com/MixelTe/bafser_tgapi"
+Issues = "https://github.com/MixelTe/bafser_tgapi/issues"

bafser_tgapi-1.0.0/src/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-1.0.0/src/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-1.0.0/src/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