Botik / src /botik /telegram_app.py
AnataBak's picture
Upload folder using huggingface_hub
3cdcea4 verified
Raw History Blame Contribute Delete
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)