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)