Как создать ChatGPT бота в Telegram на Python

python -m venv chatgpt_bot_env
source chatgpt_bot_env/bin/activate  # для Linux/MacOS
# или
chatgpt_bot_env\Scripts\activate  # для Windows

pip install python-telegram-bot==13.15
pip install openai
pip install python-dotenv

# .env
TELEGRAM_BOT_TOKEN=your_telegram_bot_token
OPENAI_API_KEY=your_openai_api_key

chatgpt_bot/
    ├── .env                # Файл с переменными окружения
    ├── config.py          # Конфигурационные параметры
    ├── bot.py            # Основной файл с логикой бота
    ├── requirements.txt   # Список зависимостей
    └── README.md         # Документация проекта

from dotenv import load_dotenv
import os
 
load_dotenv()
 
# Загрузка конфигурационных параметров из переменных окружения
TELEGRAM_BOT_TOKEN = os.getenv('TELEGRAM_BOT_TOKEN')
OPENAI_API_KEY = os.getenv('OPENAI_API_KEY')
 
# Дополнительные параметры конфигурации
MODEL_NAME = "gpt-3.5-turbo"  # Модель ChatGPT
MAX_TOKENS = 1000  # Максимальное количество токенов в ответе
TEMPERATURE = 0.7  # Параметр, влияющий на креативность ответов

import telegram
import openai
from config import TELEGRAM_BOT_TOKEN, OPENAI_API_KEY
 
def test_telegram_connection():
    try:
        bot = telegram.Bot(token=TELEGRAM_BOT_TOKEN)
        bot_info = bot.get_me()
        print(f"Успешное подключение к Telegram API. Имя бота: {bot_info.first_name}")
        return True
    except Exception as e:
        print(f"Ошибка подключения к Telegram API: {str(e)}")
        return False
 
def test_openai_connection():
    try:
        openai.api_key = OPENAI_API_KEY
        response = openai.ChatCompletion.create(
            model="gpt-3.5-turbo",
            messages=[{"role": "user", "content": "Test connection"}],
            max_tokens=10
        )
        print("Успешное подключение к OpenAI API")
        return True
    except Exception as e:
        print(f"Ошибка подключения к OpenAI API: {str(e)}")
        return False

python-telegram-bot==13.15
openai==0.28.0
python-dotenv==0.19.0
requests==2.26.0

import logging
import os
from datetime import datetime
 
def setup_logger():
    # Создаем директорию для логов, если она не существует
    if not os.path.exists('logs'):
        os.makedirs('logs')
    
    # Настраиваем формат логирования
    log_format = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
    logging.basicConfig(
        level=logging.INFO,
        format=log_format,
        handlers=[
            logging.FileHandler(
                f'logs/bot_{datetime.now().strftime("%Y%m%d")}.log'
            ),
            logging.StreamHandler()
        ]
    )
    
    return logging.getLogger(__name__)

if __name__ == "__main__":
    test_telegram_connection()
    test_openai_connection()

from telegram.ext import Updater, CommandHandler, MessageHandler, Filters
from telegram import Update, ParseMode
from telegram.ext import CallbackContext
import logging
from config import TELEGRAM_BOT_TOKEN
 
class ChatGPTBot:
    def __init__(self):
        self.updater = Updater(TELEGRAM_BOT_TOKEN, use_context=True)
        self.dispatcher = self.updater.dispatcher
        self.setup_handlers()
        self.logger = logging.getLogger(__name__)
        
    def setup_handlers(self):
        self.dispatcher.add_handler(CommandHandler("start", self.start_command))
        self.dispatcher.add_handler(CommandHandler("help", self.help_command))
        self.dispatcher.add_handler(MessageHandler(Filters.text & ~Filters.command, self.handle_message))
        self.dispatcher.add_error_handler(self.error_handler)

def start_command(self, update: Update, context: CallbackContext):
    user = update.effective_user
    welcome_message = f"""
    Здравствуйте, {user.first_name}!
 
    Я бот, работающий на базе ChatGPT. Я готов помочь вам с различными задачами:
    • Ответить на ваши вопросы
    • Помочь с написанием текстов
    • Объяснить сложные концепции
    • Предложить идеи и решения
 
    Просто напишите мне сообщение, и я постараюсь помочь!
    
    Используйте /help для получения дополнительной информации.
    """
    update.message.reply_text(welcome_message, parse_mode=ParseMode.MARKDOWN)

def help_command(self, update: Update, context: CallbackContext):
    help_message = """
    *Доступные команды:*
    
    /start - Начать диалог с ботом
    /help - Показать это сообщение помощи
    /clear - Очистить историю диалога
    /settings - Настройки бота
    
    *Как использовать бота:*
    • Просто отправьте текстовое сообщение
    • Бот поддерживает контекст беседы
    • Для начала новой темы используйте /clear
    
    *Совет:* Чем точнее ваш запрос, тем полезнее будет ответ.
    """
    update.message.reply_text(help_message, parse_mode=ParseMode.MARKDOWN)

def handle_message(self, update: Update, context: CallbackContext):
    try:
        user_message = update.message.text
        chat_id = update.effective_chat.id
        
        # Отправляем уведомление о печати
        context.bot.send_chat_action(chat_id=chat_id, action='typing')
        
        # Здесь позже добавим обработку сообщения через ChatGPT
        
        # Временный ответ для проверки работоспособности
        response = f"Получено сообщение: {user_message}"
        update.message.reply_text(response)
        
    except Exception as e:
        self.logger.error(f"Ошибка при обработке сообщения: {str(e)}")
        update.message.reply_text("Произошла ошибка при обработке вашего сообщения. Пожалуйста, попробуйте позже.")

def error_handler(self, update: Update, context: CallbackContext):
    self.logger.error(f"Update {update} caused error {context.error}")
    
    error_message = "Произошла ошибка при обработке запроса. Пожалуйста, попробуйте позже."
    if update and update.effective_message:
        update.effective_message.reply_text(error_message)

def run(self):
    self.logger.info("Бот запущен и готов к работе")
    self.updater.start_polling()
    self.updater.idle()
 
if __name__ == '__main__':
    # Настройка логирования
    logging.basicConfig(
        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
        level=logging.INFO
    )
    
    # Создание и запуск бота
    bot = ChatGPTBot()
    bot.run()

class UserSession:
    def __init__(self):
        self.conversation_history = []
        self.last_interaction = None
        self.settings = {
            'max_tokens': 1000,
            'temperature': 0.7,
            'language': 'ru'
        }
    
    def add_message(self, role: str, content: str):
        self.conversation_history.append({
            'role': role,
            'content': content,
            'timestamp': datetime.now()
        })
    
    def clear_history(self):
        self.conversation_history = []

class ChatGPTBot:
    def __init__(self):
        # ... предыдущий код ...
        self.user_sessions = {}
    
    def get_user_session(self, user_id: int) -> UserSession:
        if user_id not in self.user_sessions:
            self.user_sessions[user_id] = UserSession()
        return self.user_sessions[user_id]

def clear_command(self, update: Update, context: CallbackContext):
    user_id = update.effective_user.id
    session = self.get_user_session(user_id)
    session.clear_history()
    update.message.reply_text("История диалога очищена. Можете начать новую беседу.")

def settings_command(self, update: Update, context: CallbackContext):
    user_id = update.effective_user.id
    session = self.get_user_session(user_id)
    
    settings_message = f"""
    *Текущие настройки:*
    • Максимальное количество токенов: {session.settings['max_tokens']}
    • Температура генерации: {session.settings['temperature']}
    • Язык ответов: {session.settings['language']}
    
    Для изменения настроек используйте команды:
    /set_tokens <число> - установить максимальное количество токенов
    /set_temp <число> - установить температуру (0.1-1.0)
    /set_lang <код языка> - установить язык ответов
    """
    update.message.reply_text(settings_message, parse_mode=ParseMode.MARKDOWN)

class BotMonitor:
    def __init__(self):
        self.start_time = datetime.now()
        self.request_count = 0
        self.error_count = 0
        self.active_users = set()
    
    def log_request(self, user_id: int):
        self.request_count += 1
        self.active_users.add(user_id)
    
    def log_error(self):
        self.error_count += 1
    
    def get_stats(self):
        uptime = datetime.now() - self.start_time
        return {
            'uptime': str(uptime),
            'requests': self.request_count,
            'errors': self.error_count,
            'active_users': len(self.active_users)
        }

def cleanup_sessions(self):
    current_time = datetime.now()
    inactive_timeout = timedelta(hours=24)
    
    inactive_users = []
    for user_id, session in self.user_sessions.items():
        if current_time - session.last_interaction > inactive_timeout:
            inactive_users.append(user_id)
    
    for user_id in inactive_users:
        del self.user_sessions[user_id]

import json
import pickle
 
class StateManager:
    def __init__(self, filename='bot_state.pickle'):
        self.filename = filename
    
    def save_state(self, bot_instance):
        state = {
            'user_sessions': bot_instance.user_sessions,
            'monitor_data': bot_instance.monitor.get_stats()
        }
        with open(self.filename, 'wb') as f:
            pickle.dump(state, f)
    
    def load_state(self, bot_instance):
        try:
            with open(self.filename, 'rb') as f:
                state = pickle.load(f)
                bot_instance.user_sessions = state['user_sessions']
                return True
        except FileNotFoundError:
            return False

class SuggestionSystem:
    def __init__(self):
        self.command_patterns = {
            'вопрос': '/help',
            'очистить': '/clear',
            'настройки': '/settings',
            'начать': '/start'
        }
    
    def get_suggestions(self, message: str) -> list:
        suggestions = []
        message = message.lower()
        
        for trigger, command in self.command_patterns.items():
            if trigger in message:
                suggestions.append(command)
        
        return suggestions[:3]  # Возвращаем не более трех подсказок

class RateLimiter:
    def __init__(self):
        self.requests = {}
        self.max_requests = 50  # максимальное количество запросов в час
        self.window_size = 3600  # размер окна в секундах (1 час)
    
    def can_process(self, user_id: int) -> bool:
        current_time = time.time()
        user_requests = self.requests.get(user_id, [])
        
        # Удаляем старые запросы
        user_requests = [req for req in user_requests 
                        if current_time - req < self.window_size]
        
        if len(user_requests) >= self.max_requests:
            return False
        
        user_requests.append(current_time)
        self.requests[user_id] = user_requests
        return True

class ChatGPTBot:
    def __init__(self):
        # ... предыдущий код ...
        self.monitor = BotMonitor()
        self.state_manager = StateManager()
        self.suggestion_system = SuggestionSystem()
        self.rate_limiter = RateLimiter()
        
        # Загружаем сохраненное состояние
        self.state_manager.load_state(self)
        
        # Добавляем периодическую очистку сессий
        self.updater.job_queue.run_repeating(
            self.cleanup_job,
            interval=timedelta(hours=1)
        )
    
    def cleanup_job(self, context: CallbackContext):
        self.cleanup_sessions()
        self.state_manager.save_state(self)

import openai
from typing import List, Dict
from config import OPENAI_API_KEY, MODEL_NAME
 
class ChatGPTHandler:
    def __init__(self):
        openai.api_key = OPENAI_API_KEY
        self.model = MODEL_NAME
        self.default_params = {
            'temperature': 0.7,
            'max_tokens': 1000,
            'top_p': 1.0,
            'frequency_penalty': 0.0,
            'presence_penalty': 0.0
        }
    
    async def generate_response(self, messages: List[Dict], custom_params: Dict = None) -> str:
        try:
            params = self.default_params.copy()
            if custom_params:
                params.update(custom_params)
                
            response = await openai.ChatCompletion.acreate(
                model=self.model,
                messages=messages,
                **params
            )
            return response.choices[0].message.content
        except openai.error.OpenAIError as e:
            raise ChatGPTException(f"Ошибка при обращении к ChatGPT: {str(e)}")

from functools import lru_cache
import hashlib
import json
 
class ResponseCache:
    def __init__(self, cache_size: int = 1000):
        self.cache = lru_cache(maxsize=cache_size)(self._generate_response_cached)
        
    def _generate_cache_key(self, messages: List[Dict], params: Dict) -> str:
        cache_data = {
            'messages': messages,
            'params': params
        }
        return hashlib.md5(json.dumps(cache_data, sort_keys=True).encode()).hexdigest()
    
    async def _generate_response_cached(self, cache_key: str):
        chatgpt = ChatGPTHandler()
        return await chatgpt.generate_response(messages, params)
    
    async def get_response(self, messages: List[Dict], params: Dict = None) -> str:
        cache_key = self._generate_cache_key(messages, params)
        return await self.cache(cache_key)

class MessageFormatter:
    @staticmethod
    def format_conversation_history(history: List[Dict]) -> List[Dict]:
        formatted_messages = []
        for message in history:
            formatted_messages.append({
                'role': message['role'],
                'content': message['content']
            })
        return formatted_messages
    
    @staticmethod
    def create_system_message(instructions: str) -> Dict:
        return {
            'role': 'system',
            'content': instructions
        }
    
    @staticmethod
    def create_user_message(content: str) -> Dict:
        return {
            'role': 'user',
            'content': content
        }

class ConversationManager:
    def __init__(self, max_history: int = 10):
        self.max_history = max_history
        
    def prepare_messages(self, session: UserSession, new_message: str) -> List[Dict]:
        messages = [MessageFormatter.create_system_message(
            "Вы - полезный ассистент, который отвечает на вопросы пользователя."
        )]
        
        # Добавляем историю сообщений
        history = session.conversation_history[-self.max_history:]
        messages.extend(MessageFormatter.format_conversation_history(history))
        
        # Добавляем новое сообщение
        messages.append(MessageFormatter.create_user_message(new_message))
        return messages

class APIRetryHandler:
    def __init__(self, max_retries: int = 3, delay: float = 1.0):
        self.max_retries = max_retries
        self.delay = delay
    
    async def execute_with_retry(self, func, *args, **kwargs):
        for attempt in range(self.max_retries):
            try:
                return await func(*args, **kwargs)
            except openai.error.RateLimitError:
                if attempt == self.max_retries - 1:
                    raise
                await asyncio.sleep(self.delay * (2 ** attempt))
            except openai.error.APIError as e:
                if attempt == self.max_retries - 1:
                    raise
                await asyncio.sleep(self.delay)

class ChatGPTBot:
    def __init__(self):
        # ... предыдущий код ...
        self.chatgpt = ChatGPTHandler()
        self.cache = ResponseCache()
        self.conversation_manager = ConversationManager()
        self.retry_handler = APIRetryHandler()
    
    async def process_message(self, update: Update, context: CallbackContext):
        user_id = update.effective_user.id
        message_text = update.message.text
        session = self.get_user_session(user_id)
        
        try:
            # Подготовка сообщений для отправки в API
            messages = self.conversation_manager.prepare_messages(
                session,
                message_text
            )
            
            # Получение ответа от ChatGPT с использованием системы повторных попыток
            response = await self.retry_handler.execute_with_retry(
                self.chatgpt.generate_response,
                messages,
                session.settings
            )
            
            # Сохранение истории диалога
            session.add_message('user', message_text)
            session.add_message('assistant', response)
            
            # Отправка ответа пользователю
            await update.message.reply_text(response)
            
        except Exception as e:
            self.logger.error(f"Ошибка при обработке сообщения: {str(e)}")
            await update.message.reply_text(
                "Произошла ошибка при обработке вашего сообщения. "
                "Пожалуйста, попробуйте позже."
            )

class TokenManager:
    def __init__(self):
        self.encoder = tiktoken.get_encoding("cl100k_base")
    
    def count_tokens(self, text: str) -> int:
        return len(self.encoder.encode(text))
    
    def truncate_text(self, text: str, max_tokens: int) -> str:
        tokens = self.encoder.encode(text)
        if len(tokens) <= max_tokens:
            return text
        return self.encoder.decode(tokens[:max_tokens])

class APIPerformanceMonitor:
    def __init__(self):
        self.response_times = []
        self.error_counts = defaultdict(int)
        self.token_usage = []
    
    def log_request(self, start_time: float, end_time: float, tokens_used: int, error: Exception = None):
        response_time = end_time - start_time
        self.response_times.append(response_time)
        self.token_usage.append(tokens_used)
        
        if error:
            error_type = type(error).__name__
            self.error_counts[error_type] += 1
    
    def get_statistics(self) -> Dict:
        return {
            'avg_response_time': statistics.mean(self.response_times),
            'max_response_time': max(self.response_times),
            'total_tokens': sum(self.token_usage),
            'error_distribution': dict(self.error_counts)
        }

class ModelContextManager:
    def __init__(self):
        self.context_templates = {
            'general': "Вы - полезный ассистент, готовый помочь с любыми вопросами.",
            'technical': "Вы - технический эксперт, специализирующийся на программировании и технологиях.",
            'creative': "Вы - креативный помощник, способный генерировать идеи и творческие решения.",
            'academic': "Вы - академический ассистент, помогающий с научными и образовательными вопросами."
        }
    
    def get_context(self, context_type: str, custom_instructions: str = None) -> str:
        base_context = self.context_templates.get(context_type, self.context_templates['general'])
        if custom_instructions:
            return f"{base_context}\n{custom_instructions}"
        return base_context

class ContentModerator:
    def __init__(self):
        self.blocked_patterns = [
            r'(?i)нецензурная_лексика',
            r'(?i)оскорбления',
            r'(?i)спам'
        ]
        self.sensitive_topics = set(['политика', 'религия', 'конфликты'])
    
    def check_content(self, text: str) -> Tuple[bool, str]:
        # Проверка на запрещенные паттерны
        for pattern in self.blocked_patterns:
            if re.search(pattern, text):
                return False, "Сообщение содержит недопустимый контент"
        
        # Проверка на чувствительные темы
        words = set(text.lower().split())
        if words.intersection(self.sensitive_topics):
            return True, "Внимание: сообщение содержит чувствительные темы"
        
        return True, ""

class ResponsePostProcessor:
    def __init__(self):
        self.markdown_formatter = markdown2.Markdown()
        
    def format_response(self, response: str) -> str:
        # Форматирование кода
        response = self.format_code_blocks(response)
        
        # Проверка и исправление пунктуации
        response = self.fix_punctuation(response)
        
        # Форматирование списков
        response = self.format_lists(response)
        
        return response
    
    def format_code_blocks(self, text: str) -> str:
        code_pattern = r'```(\w+)?\n(.*?)\n```'
        return re.sub(code_pattern, self.process_code_block, text, flags=re.DOTALL)
    
    def process_code_block(self, match) -> str:
        language = match.group(1) or ''
        code = match.group(2)
        return f"```{language}\n{textwrap.dedent(code).strip()}\n```"

class DialogueContextManager:
    def __init__(self, max_context_length: int = 2000):
        self.max_context_length = max_context_length
        self.token_manager = TokenManager()
    
    def prepare_context(self, history: List[Dict], new_message: str) -> List[Dict]:
        context = []
        current_length = 0
        
        # Добавляем системное сообщение
        system_message = MessageFormatter.create_system_message(
            ModelContextManager().get_context('general')
        )
        context.append(system_message)
        
        # Обрабатываем историю сообщений
        for message in reversed(history):
            message_tokens = self.token_manager.count_tokens(message['content'])
            if current_length + message_tokens > self.max_context_length:
                break
                
            context.insert(1, message)
            current_length += message_tokens
        
        # Добавляем новое сообщение
        context.append(MessageFormatter.create_user_message(new_message))
        
        return context

class HistoryCompressor:
    def __init__(self):
        self.token_manager = TokenManager()
        
    def compress_history(self, history: List[Dict], max_tokens: int) -> List[Dict]:
        if not history:
            return []
            
        # Вычисляем общее количество токенов
        total_tokens = sum(self.token_manager.count_tokens(msg['content']) 
                          for msg in history)
        
        if total_tokens <= max_tokens:
            return history
            
        # Создаем сжатое представление истории
        compressed = []
        current_tokens = 0
        
        for message in reversed(history):
            tokens = self.token_manager.count_tokens(message['content'])
            if current_tokens + tokens > max_tokens:
                break
                
            compressed.insert(0, message)
            current_tokens += tokens
        
        return compressed

class ChatGPTBot:
    def __init__(self):
        # ... предыдущий код ...
        self.performance_monitor = APIPerformanceMonitor()
        self.content_moderator = ContentModerator()
        self.post_processor = ResponsePostProcessor()
        self.dialogue_context = DialogueContextManager()
        self.history_compressor = HistoryCompressor()
    
    async def handle_message(self, update: Update, context: CallbackContext):
        user_id = update.effective_user.id
        message_text = update.message.text
        session = self.get_user_session(user_id)
        
        # Проверка содержимого
        is_safe, moderation_message = self.content_moderator.check_content(message_text)
        if not is_safe:
            await update.message.reply_text(moderation_message)
            return
        
        start_time = time.time()
        try:
            # Подготовка контекста
            messages = self.dialogue_context.prepare_context(
                session.conversation_history,
                message_text
            )
            
            # Получение ответа
            response = await self.chatgpt.generate_response(messages)
            
            # Постобработка ответа
            formatted_response = self.post_processor.format_response(response)
            
            # Сжатие и сохранение истории
            session.conversation_history = self.history_compressor.compress_history(
                session.conversation_history + [
                    {'role': 'user', 'content': message_text},
                    {'role': 'assistant', 'content': response}
                ],
                self.dialogue_context.max_context_length
            )
            
            await update.message.reply_text(formatted_response)
            
        except Exception as e:
            self.logger.error(f"Ошибка при обработке сообщения: {str(e)}")
            await update.message.reply_text(
                "Произошла ошибка при обработке вашего сообщения."
            )
        finally:
            # Логирование производительности
            end_time = time.time()
            self.performance_monitor.log_request(
                start_time,
                end_time,
                self.token_manager.count_tokens(message_text)
            )

class UserPreferences:
    def __init__(self):
        self.settings = {
            'language': 'ru',
            'response_length': 'medium',
            'creativity_level': 0.7,
            'notifications': True,
            'auto_clear': False
        }
        
    def update_settings(self, **kwargs):
        for key, value in kwargs.items():
            if key in self.settings:
                self.settings[key] = value
                
    def get_setting(self, key):
        return self.settings.get(key)

class MediaHandler:
    def __init__(self):
        self.supported_formats = {
            'image': ['jpeg', 'png', 'gif'],
            'document': ['pdf', 'txt', 'doc', 'docx'],
            'voice': ['ogg', 'mp3']
        }
        
    async def process_media(self, message: Message, media_type: str):
        if media_type == 'image':
            return await self.process_image(message)
        elif media_type == 'document':
            return await self.process_document(message)
        elif media_type == 'voice':
            return await self.process_voice(message)
            
    async def process_image(self, message: Message):
        photo = message.photo[-1]  # Берем версию с наивысшим качеством
        file = await photo.get_file()
        return f"Изображение получено и обработано: {file.file_size} байт"

class UserAnalytics:
    def __init__(self):
        self.interaction_history = defaultdict(list)
        self.popular_queries = Counter()
        
    def log_interaction(self, user_id: int, query: str, response: str):
        self.interaction_history[user_id].append({
            'timestamp': datetime.now(),
            'query': query,
            'response': response
        })
        self.popular_queries[query] += 1
        
    def get_user_statistics(self, user_id: int):
        user_interactions = self.interaction_history[user_id]
        return {
            'total_queries': len(user_interactions),
            'average_length': statistics.mean(
                len(i['query']) for i in user_interactions
            ),
            'most_frequent': self.popular_queries.most_common(5)
        }

class TaskScheduler:
    def __init__(self):
        self.scheduled_tasks = {}
        self.periodic_tasks = {}
        
    async def schedule_task(self, user_id: int, task: str, execute_time: datetime):
        task_id = str(uuid.uuid4())
        self.scheduled_tasks[task_id] = {
            'user_id': user_id,
            'task': task,
            'execute_time': execute_time
        }
        return task_id
        
    async def add_periodic_task(self, user_id: int, task: str, interval: timedelta):
        task_id = str(uuid.uuid4())
        self.periodic_tasks[task_id] = {
            'user_id': user_id,
            'task': task,
            'interval': interval,
            'last_executed': None
        }
        return task_id

class FeedbackLearning:
    def __init__(self):
        self.feedback_history = []
        self.response_quality = defaultdict(float)
        
    def add_feedback(self, query: str, response: str, rating: float):
        self.feedback_history.append({
            'query': query,
            'response': response,
            'rating': rating,
            'timestamp': datetime.now()
        })
        self.update_quality_metrics(query, rating)
        
    def update_quality_metrics(self, query: str, rating: float):
        current_rating = self.response_quality[query]
        self.response_quality[query] = (current_rating + rating) / 2

class QueryCategorizer:
    def __init__(self):
        self.categories = {
            'technical': ['программирование', 'код', 'ошибка'],
            'creative': ['идея', 'дизайн', 'творчество'],
            'educational': ['учеба', 'образование', 'наука'],
            'general': ['помощь', 'совет', 'информация']
        }
        
    def categorize_query(self, query: str) -> str:
        query_words = set(query.lower().split())
        for category, keywords in self.categories.items():
            if query_words.intersection(keywords):
                return category
        return 'general'

class ChatGPTBot:
    def __init__(self):
        # ... предыдущий код ...
        self.preferences = UserPreferences()
        self.media_handler = MediaHandler()
        self.analytics = UserAnalytics()
        self.scheduler = TaskScheduler()
        self.feedback = FeedbackLearning()
        self.categorizer = QueryCategorizer()
        
    async def handle_message(self, update: Update, context: CallbackContext):
        user_id = update.effective_user.id
        message = update.message
        
        # Обработка медиаконтента
        if message.photo:
            response = await self.media_handler.process_media(message, 'image')
        elif message.document:
            response = await self.media_handler.process_media(message, 'document')
        elif message.voice:
            response = await self.media_handler.process_media(message, 'voice')
        else:
            # Категоризация и обработка текстового запроса
            category = self.categorizer.categorize_query(message.text)
            response = await self.process_text_message(message.text, category)
            
        # Логирование взаимодействия
        self.analytics.log_interaction(user_id, message.text, response)
        await update.message.reply_text(response)

class NotificationSystem:
    def __init__(self):
        self.subscribers = defaultdict(set)
        self.notification_types = {
            'updates': 'Обновления системы',
            'scheduled': 'Запланированные задачи',
            'alerts': 'Важные уведомления'
        }
    
    async def subscribe(self, user_id: int, notification_type: str):
        if notification_type in self.notification_types:
            self.subscribers[notification_type].add(user_id)
            return True
        return False
    
    async def send_notification(self, notification_type: str, message: str, bot):
        if notification_type in self.subscribers:
            for user_id in self.subscribers[notification_type]:
                await bot.send_message(user_id, message)

class ContextualSuggestions:
    def __init__(self):
        self.suggestion_patterns = {
            'question': ['Возможно, вам также будет интересно...', 'Похожие вопросы:'],
            'error': ['Попробуйте следующие решения:', 'Распространенные способы исправления:'],
            'request': ['Дополнительные возможности:', 'Вы также можете:']
        }
        
    def get_suggestions(self, message: str, context: dict) -> List[str]:
        message_type = self.determine_message_type(message)
        base_suggestions = self.suggestion_patterns.get(message_type, [])
        
        context_based = self.generate_context_suggestions(context)
        return base_suggestions + context_based[:3]

class BackupSystem:
    def __init__(self, backup_dir: str = 'backups'):
        self.backup_dir = backup_dir
        os.makedirs(backup_dir, exist_ok=True)
        
    def create_backup(self, data: dict, backup_type: str):
        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
        filename = f"{backup_type}_{timestamp}.json"
        
        with open(os.path.join(self.backup_dir, filename), 'w') as f:
            json.dump(data, f, indent=4, default=str)
        
    def restore_from_backup(self, backup_type: str, timestamp: str = None):
        if timestamp:
            filename = f"{backup_type}_{timestamp}.json"
        else:
            # Получаем последний backup
            files = glob.glob(os.path.join(self.backup_dir, f"{backup_type}_*.json"))
            if not files:
                return None
            filename = max(files, key=os.path.getctime)
            
        with open(filename, 'r') as f:
            return json.load(f)

class PerformanceMonitor:
    def __init__(self):
        self.metrics = {
            'response_times': [],
            'error_rates': defaultdict(int),
            'memory_usage': [],
            'api_calls': defaultdict(int)
        }
        
    def record_metric(self, metric_type: str, value: Any):
        if metric_type in self.metrics:
            if isinstance(self.metrics[metric_type], list):
                self.metrics[metric_type].append(value)
            else:
                self.metrics[metric_type][value] += 1
                
    def get_statistics(self) -> Dict:
        return {
            'avg_response_time': statistics.mean(self.metrics['response_times']),
            'error_distribution': dict(self.metrics['error_rates']),
            'memory_usage_trend': self.calculate_memory_trend(),
            'api_usage': dict(self.metrics['api_calls'])
        }

class CacheManager:
    def __init__(self, max_size: int = 1000):
        self.cache = TTLCache(maxsize=max_size, ttl=3600)
        self.stats = {
            'hits': 0,
            'misses': 0,
            'evictions': 0
        }
        
    def get(self, key: str) -> Any:
        try:
            value = self.cache[key]
            self.stats['hits'] += 1
            return value
        except KeyError:
            self.stats['misses'] += 1
            return None
            
    def set(self, key: str, value: Any):
        if len(self.cache) >= self.cache.maxsize:
            self.stats['evictions'] += 1
        self.cache[key] = value

class ChatGPTBot:
    def __init__(self):
        # ... предыдущий код ...
        self.notifications = NotificationSystem()
        self.suggestions = ContextualSuggestions()
        self.backup = BackupSystem()
        self.performance = PerformanceMonitor()
        self.cache = CacheManager()
        
    async def process_message(self, update: Update, context: CallbackContext):
        start_time = time.time()
        user_id = update.effective_user.id
        message_text = update.message.text
        
        try:
            # Проверяем кэш
            cached_response = self.cache.get(message_text)
            if cached_response:
                await update.message.reply_text(cached_response)
                return
                
            # Получаем контекстные подсказки
            suggestions = self.suggestions.get_suggestions(
                message_text,
                context.user_data
            )
            
            # Обрабатываем сообщение
            response = await self.generate_response(message_text)
            
            # Кэшируем ответ
            self.cache.set(message_text, response)
            
            # Отправляем ответ с подсказками
            await update.message.reply_text(
                response,
                reply_markup=self.create_suggestion_keyboard(suggestions)
            )
            
        finally:
            # Записываем метрики производительности
            self.performance.record_metric(
                'response_times',
                time.time() - start_time
            )

from telegram.ext import Updater, CommandHandler, MessageHandler, Filters
from telegram import Update, ParseMode
import logging
import os
from dotenv import load_dotenv
from pathlib import Path
 
# Загрузка переменных окружения
load_dotenv()
TELEGRAM_TOKEN = os.getenv('TELEGRAM_TOKEN')
OPENAI_API_KEY = os.getenv('OPENAI_API_KEY')
 
class TelegramGPTBot:
    def __init__(self):
        self.updater = Updater(TELEGRAM_TOKEN, use_context=True)
        self.dispatcher = self.updater.dispatcher
        self.setup_logging()
        self.setup_handlers()
        
    def setup_logging(self):
        logging.basicConfig(
            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
            level=logging.INFO,
            handlers=[
                logging.FileHandler('bot.log'),
                logging.StreamHandler()
            ]
        )
        self.logger = logging.getLogger(__name__)
        
    def setup_handlers(self):
        self.dispatcher.add_handler(CommandHandler("start", self.start_command))
        self.dispatcher.add_handler(CommandHandler("help", self.help_command))
        self.dispatcher.add_handler(MessageHandler(
            Filters.text & ~Filters.command, 
            self.handle_message
        ))
        self.dispatcher.add_error_handler(self.error_handler)

import openai
from typing import List, Dict
 
class ChatGPTHandler:
    def __init__(self, api_key: str):
        openai.api_key = api_key
        self.model = "gpt-3.5-turbo"
        
    async def generate_response(self, messages: List[Dict]) -> str:
        try:
            response = await openai.ChatCompletion.acreate(
                model=self.model,
                messages=messages,
                max_tokens=1000,
                temperature=0.7
            )
            return response.choices[0].message.content
        except Exception as e:
            logging.error(f"Ошибка при генерации ответа: {str(e)}")
            raise

class UserSession:
    def __init__(self):
        self.conversation_history = []
        self.settings = {
            'max_tokens': 1000,
            'temperature': 0.7,
            'language': 'ru'
        }
        
    def add_message(self, role: str, content: str):
        self.conversation_history.append({
            'role': role,
            'content': content
        })
        
    def get_context(self, max_messages: int = 5) -> List[Dict]:
        return self.conversation_history[-max_messages:]

from telegram.ext import CallbackContext
 
class TelegramGPTBot:
    async def start_command(self, update: Update, context: CallbackContext):
        welcome_message = """
        Привет! Я бот на базе ChatGPT.
        
        Я могу помочь вам с различными задачами:
        • Ответить на вопросы
        • Помочь с программированием
        • Объяснить сложные концепции
        • Генерировать идеи
        
        Просто напишите мне сообщение, и я постараюсь помочь!
        """
        await update.message.reply_text(welcome_message, parse_mode=ParseMode.MARKDOWN)
        
    async def help_command(self, update: Update, context: CallbackContext):
        help_message = """
        *Доступные команды:*
        /start - Начать диалог
        /help - Показать это сообщение
        /clear - Очистить историю диалога
        /settings - Настройки бота
        """
        await update.message.reply_text(help_message, parse_mode=ParseMode.MARKDOWN)
        
    async def handle_message(self, update: Update, context: CallbackContext):
        user_id = update.effective_user.id
        message_text = update.message.text
        
        # Получаем или создаем сессию пользователя
        if not hasattr(context.user_data, 'session'):
            context.user_data.session = UserSession()
            
        session = context.user_data.session
        
        try:
            # Добавляем сообщение пользователя в историю
            session.add_message('user', message_text)
            
            # Генерируем ответ
            messages = session.get_context()
            response = await self.chatgpt.generate_response(messages)
            
            # Сохраняем ответ в истории
            session.add_message('assistant', response)
            
            # Отправляем ответ пользователю
            await update.message.reply_text(response)
            
        except Exception as e:
            self.logger.error(f"Ошибка при обработке сообщения: {str(e)}")
            await update.message.reply_text(
                "Произошла ошибка при обработке вашего сообщения. "
                "Пожалуйста, попробуйте позже."
            )

class TelegramGPTBot:
    async def error_handler(self, update: Update, context: CallbackContext):
        self.logger.error(f"Update {update} caused error {context.error}")
        
        error_message = """
        Произошла ошибка при обработке запроса.
        
        Пожалуйста, попробуйте:
        1. Отправить сообщение позже
        2. Использовать команду /clear для очистки истории
        3. Перезапустить диалог командой /start
        """
        
        if update and update.effective_message:
            await update.effective_message.reply_text(
                error_message,
                parse_mode=ParseMode.MARKDOWN
            )

import signal
import sys
 
def signal_handler(signum, frame):
    print("\nПолучен сигнал завершения. Останавливаем бота...")
    bot.updater.stop()
    sys.exit(0)
 
if __name__ == '__main__':
    # Регистрируем обработчик сигналов
    signal.signal(signal.SIGINT, signal_handler)
    signal.signal(signal.SIGTERM, signal_handler)
    
    # Создаем и запускаем бота
    bot = TelegramGPTBot()
    
    print("Бот запущен и готов к работе!")
    bot.updater.start_polling()
    bot.updater.idle()

import subprocess
import sys
import os
 
def setup_environment():
    print("Настройка виртуального окружения...")
    subprocess.run([sys.executable, "-m", "venv", "venv"])
    
    if os.name == 'nt':  # Windows
        activate_script = "venv\\Scripts\\activate"
    else:  # Unix
        activate_script = "source venv/bin/activate"
    
    subprocess.run(activate_script, shell=True)
    subprocess.run(["pip", "install", "-r", "requirements.txt"])
 
def check_dependencies():
    print("Проверка зависимостей...")
    try:
        import telegram
        import openai
        print("Все необходимые зависимости установлены")
        return True
    except ImportError as e:
        print(f"Ошибка: {str(e)}")
        return False
 
if __name__ == "__main__":
    setup_environment()
    if check_dependencies():
        print("Установка завершена успешно")

import logging
from logging.handlers import RotatingFileHandler
 
def setup_logging():
    logger = logging.getLogger('telegram_gpt_bot')
    logger.setLevel(logging.INFO)
    
    formatter = logging.Formatter(
        '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
    )
    
    file_handler = RotatingFileHandler(
        'logs/bot.log',
        maxBytes=1024*1024,  # 1MB
        backupCount=5
    )
    file_handler.setFormatter(formatter)
    logger.addHandler(file_handler)
    
    return logger