Download src/botik/telegram_app.py from AnataBak/Botik: direct link, hf CLI and curl.
- Browser
- Download file 12 kB
-
https://huggingface.co/spaces/AnataBak/Botik/resolve/main/src/botik/telegram_app.py
- Command line
-
hf download hf://spaces/AnataBak/Botik/src/botik/telegram_app.py
-
curl -L -o telegram_app.py https://huggingface.co/spaces/AnataBak/Botik/resolve/main/src/botik/telegram_app.py
12 kB
| from __future__ import annotations | |
| import logging | |
| import re | |
| from telegram import InlineKeyboardButton, InlineKeyboardMarkup, Message, Update, User | |
| from telegram.constants import ChatType | |
| from telegram.ext import ( | |
| Application, | |
| ApplicationBuilder, | |
| CallbackQueryHandler, | |
| CommandHandler, | |
| ContextTypes, | |
| MessageHandler, | |
| filters, | |
| ) | |
| from botik.config import FALLBACK_MODELS, Settings | |
| from botik.gemini_client import GeminiError, GeminiService | |
| from botik.storage import SQLiteStorage | |
| logger = logging.getLogger(__name__) | |
| BOT_INFO_KEY = "bot_info" | |
| class TelegramBot: | |
| def __init__(self, settings: Settings, storage: SQLiteStorage, gemini: GeminiService) -> None: | |
| self.settings = settings | |
| self.storage = storage | |
| self.gemini = gemini | |
| async def start(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None: | |
| message = update.effective_message | |
| if message is None: | |
| return | |
| await message.reply_text( | |
| "Привет. Я личный помощник на Gemini.\n\n" | |
| "Пиши мне в личку или упоминай в группе. Команды: /help, /reset, " | |
| "/soul, /reset_soul, /model." | |
| ) | |
| async def help(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None: | |
| message = update.effective_message | |
| if message is None: | |
| return | |
| await message.reply_text( | |
| "Что умею:\n" | |
| "• отвечать в личке и группах;\n" | |
| "• помнить историю текущего чата;\n" | |
| "• понимать, кто пишет в группе;\n" | |
| "• учитывать сообщение, на которое ты ответил свайпом;\n" | |
| "• искать в интернете через Gemini, если это нужно.\n\n" | |
| "Команды:\n" | |
| "/reset — очистить память текущего чата;\n" | |
| "/soul новый стиль — временно поменять душу текущего чата;\n" | |
| "/reset_soul — вернуть стандартную душу;\n" | |
| "/model — выбрать модель Gemini." | |
| ) | |
| async def reset(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None: | |
| message = update.effective_message | |
| chat = update.effective_chat | |
| if message is None or chat is None: | |
| return | |
| self.storage.clear_messages(chat.id) | |
| await message.reply_text("Память этого чата очищена.") | |
| async def soul(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None: | |
| message = update.effective_message | |
| chat = update.effective_chat | |
| if message is None or chat is None: | |
| return | |
| soul_text = " ".join(context.args).strip() | |
| settings = self.storage.get_chat_settings(chat.id, self.settings.default_model) | |
| if not soul_text: | |
| current = settings.custom_soul or "сейчас используется стандартная душа" | |
| await message.reply_text( | |
| "Напиши так: /soul отвечай как спокойный философ\n\n" | |
| f"Текущая временная душа: {current}" | |
| ) | |
| return | |
| self.storage.set_custom_soul(chat.id, soul_text, self.settings.default_model) | |
| await message.reply_text("Временная душа для этого чата обновлена.") | |
| async def reset_soul(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None: | |
| message = update.effective_message | |
| chat = update.effective_chat | |
| if message is None or chat is None: | |
| return | |
| self.storage.reset_custom_soul(chat.id, self.settings.default_model) | |
| await message.reply_text("Вернул стандартную душу для этого чата.") | |
| async def model(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None: | |
| message = update.effective_message | |
| chat = update.effective_chat | |
| if message is None or chat is None: | |
| return | |
| requested_model = " ".join(context.args).strip() | |
| if requested_model: | |
| self.storage.set_model(chat.id, requested_model, self.settings.default_model) | |
| await message.reply_text(f"Модель для этого чата: {requested_model}") | |
| return | |
| settings = self.storage.get_chat_settings(chat.id, self.settings.default_model) | |
| models = await self._available_models() | |
| keyboard = [ | |
| [InlineKeyboardButton(model_name, callback_data=f"model|{model_name}")] | |
| for model_name in models | |
| if len(model_name) <= 56 | |
| ][:20] | |
| if not keyboard: | |
| keyboard = [ | |
| [InlineKeyboardButton(model_name, callback_data=f"model|{model_name}")] | |
| for model_name in FALLBACK_MODELS | |
| ] | |
| await message.reply_text( | |
| f"Текущая модель: {settings.model}\nВыбери новую:", | |
| reply_markup=InlineKeyboardMarkup(keyboard), | |
| ) | |
| async def select_model(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None: | |
| query = update.callback_query | |
| if query is None or query.message is None or query.data is None: | |
| return | |
| await query.answer() | |
| if not query.data.startswith("model|"): | |
| return | |
| model_name = query.data.removeprefix("model|") | |
| self.storage.set_model(query.message.chat_id, model_name, self.settings.default_model) | |
| await query.edit_message_text(f"Модель для этого чата: {model_name}") | |
| async def text_message(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None: | |
| message = update.effective_message | |
| chat = update.effective_chat | |
| user = update.effective_user | |
| if message is None or chat is None or user is None or message.text is None: | |
| return | |
| if not await self._message_addresses_bot(message, context): | |
| return | |
| cleaned_text = await self._clean_bot_mention(message.text, context) | |
| if not cleaned_text: | |
| await message.reply_text("Напиши вопрос после упоминания или ответь мне сообщением.") | |
| return | |
| chat_settings = self.storage.get_chat_settings(chat.id, self.settings.default_model) | |
| history = self.storage.get_recent_messages(chat.id, self.settings.max_history_messages) | |
| author = _display_name(user) | |
| reply_context = _reply_context(message) | |
| self.storage.append_message( | |
| chat_id=chat.id, | |
| telegram_message_id=message.message_id, | |
| role="user", | |
| user_id=user.id, | |
| user_name=author, | |
| text=cleaned_text, | |
| ) | |
| await context.bot.send_chat_action(chat_id=chat.id, action="typing") | |
| try: | |
| answer = await self.gemini.generate_reply( | |
| model=chat_settings.model, | |
| default_system_prompt=self.settings.default_system_prompt, | |
| custom_soul=chat_settings.custom_soul, | |
| history=history, | |
| current_author=author, | |
| current_text=cleaned_text, | |
| reply_context=reply_context, | |
| ) | |
| except GeminiError: | |
| logger.exception("Gemini request failed") | |
| await message.reply_text( | |
| "Gemini сейчас не ответил. Попробуй /model и выбери другую модель." | |
| ) | |
| return | |
| self.storage.append_message( | |
| chat_id=chat.id, | |
| telegram_message_id=None, | |
| role="assistant", | |
| user_id=None, | |
| user_name="Botik", | |
| text=answer, | |
| ) | |
| await _reply_in_chunks(message, answer) | |
| async def _available_models(self) -> list[str]: | |
| models = await self.gemini.list_text_models() | |
| return models or list(FALLBACK_MODELS) | |
| async def _message_addresses_bot( | |
| self, | |
| message: Message, | |
| context: ContextTypes.DEFAULT_TYPE, | |
| ) -> bool: | |
| if message.chat.type == ChatType.PRIVATE: | |
| return True | |
| bot_id, username = await _get_bot_info(context) | |
| if ( | |
| message.reply_to_message | |
| and message.reply_to_message.from_user | |
| and message.reply_to_message.from_user.id == bot_id | |
| ): | |
| return True | |
| return bool(username and f"@{username}" in message.text.lower()) | |
| async def _clean_bot_mention( | |
| self, | |
| text: str, | |
| context: ContextTypes.DEFAULT_TYPE, | |
| ) -> str: | |
| _, username = await _get_bot_info(context) | |
| if not username: | |
| return text.strip() | |
| cleaned = re.sub(rf"@{re.escape(username)}\b", "", text, flags=re.IGNORECASE) | |
| return cleaned.strip(" \n\t,:;—-") | |
| def build_application( | |
| settings: Settings, | |
| storage: SQLiteStorage, | |
| gemini: GeminiService, | |
| ) -> Application: | |
| bot = TelegramBot(settings=settings, storage=storage, gemini=gemini) | |
| application = ( | |
| ApplicationBuilder() | |
| .token(settings.telegram_bot_token) | |
| .connect_timeout(30) | |
| .read_timeout(30) | |
| .write_timeout(30) | |
| .pool_timeout(30) | |
| .post_init(_cache_bot_info) | |
| .build() | |
| ) | |
| application.add_handler(CommandHandler("start", bot.start)) | |
| application.add_handler(CommandHandler("help", bot.help)) | |
| application.add_handler(CommandHandler("settings", bot.help)) | |
| application.add_handler(CommandHandler("reset", bot.reset)) | |
| application.add_handler(CommandHandler("soul", bot.soul)) | |
| application.add_handler(CommandHandler("reset_soul", bot.reset_soul)) | |
| application.add_handler(CommandHandler("model", bot.model)) | |
| application.add_handler(CallbackQueryHandler(bot.select_model, pattern=r"^model\|")) | |
| application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, bot.text_message)) | |
| return application | |
| def _display_name(user: User) -> str: | |
| username = f"@{user.username}" if user.username else f"user_id={user.id}" | |
| return f"{user.full_name} ({username})" | |
| async def _cache_bot_info(application: Application) -> None: | |
| me = await application.bot.get_me() | |
| application.bot_data[BOT_INFO_KEY] = { | |
| "id": me.id, | |
| "username": (me.username or "").lower(), | |
| } | |
| async def _get_bot_info(context: ContextTypes.DEFAULT_TYPE) -> tuple[int, str]: | |
| bot_info = context.application.bot_data.get(BOT_INFO_KEY) | |
| if bot_info: | |
| return int(bot_info["id"]), str(bot_info["username"]) | |
| me = await context.bot.get_me() | |
| username = (me.username or "").lower() | |
| context.application.bot_data[BOT_INFO_KEY] = {"id": me.id, "username": username} | |
| return me.id, username | |
| def _reply_context(message: Message) -> str | None: | |
| replied = message.reply_to_message | |
| if replied is None: | |
| return None | |
| author = _display_name(replied.from_user) if replied.from_user else "неизвестный автор" | |
| text = replied.text or replied.caption | |
| if not text: | |
| return f"{author}: [сообщение без текста]" | |
| return f"{author}: {text}" | |
| async def _reply_in_chunks(message: Message, text: str) -> None: | |
| chunk_size = 3900 | |
| chunks = [text[index : index + chunk_size] for index in range(0, len(text), chunk_size)] | |
| for chunk in chunks or ["Ответ пустой."]: | |
| await message.reply_text(chunk) | |