smart-bot-factory 0.1.2__py3-none-any.whl → 0.1.3__py3-none-any.whl

smart_bot_factory/core/decorators.py

@@ -0,0 +1,229 @@
+"""
+Декораторы для обработчиков событий и временных задач
+"""
+
+import asyncio
+import logging
+from typing import Callable, Any, Dict, Optional
+from datetime import datetime, timedelta
+from functools import wraps
+
+logger = logging.getLogger(__name__)
+
+# Глобальный реестр обработчиков событий
+_event_handlers: Dict[str, Callable] = {}
+_scheduled_tasks: Dict[str, Dict[str, Any]] = {}
+
+def event_handler(event_type: str, description: str = ""):
+    """
+    Декоратор для регистрации обработчика события
+    
+    Args:
+        event_type: Тип события (например, 'appointment_booking', 'phone_collection')
+        description: Описание что делает обработчик (для добавления в промпт)
+    
+    Example:
+        @event_handler("appointment_booking", "Записывает пользователя на прием")
+        async def book_appointment(user_id: int, appointment_data: dict):
+            # Логика записи на прием
+            return {"status": "success", "appointment_id": "123"}
+    """
+    def decorator(func: Callable) -> Callable:
+        _event_handlers[event_type] = {
+            'handler': func,
+            'description': description,
+            'name': func.__name__
+        }
+        
+        logger.info(f"📝 Зарегистрирован обработчик события '{event_type}': {func.__name__}")
+        
+        @wraps(func)
+        async def wrapper(*args, **kwargs):
+            try:
+                logger.info(f"🔧 Выполняем обработчик события '{event_type}'")
+                result = await func(*args, **kwargs)
+                logger.info(f"✅ Обработчик '{event_type}' выполнен успешно")
+                return result
+            except Exception as e:
+                logger.error(f"❌ Ошибка в обработчике '{event_type}': {e}")
+                raise
+        
+        return wrapper
+    return decorator
+
+def schedule_task(task_name: str, description: str = ""):
+    """
+    Декоратор для регистрации задачи, которую можно запланировать на время
+    
+    Args:
+        task_name: Название задачи (например, 'send_reminder', 'follow_up')
+        description: Описание задачи (для добавления в промпт)
+    
+    Example:
+        @schedule_task("send_reminder", "Отправляет напоминание пользователю")
+        async def send_reminder(user_id: int, message: str):
+            # Логика отправки напоминания
+            return {"status": "sent"}
+    """
+    def decorator(func: Callable) -> Callable:
+        _scheduled_tasks[task_name] = {
+            'handler': func,
+            'description': description,
+            'name': func.__name__
+        }
+        
+        logger.info(f"⏰ Зарегистрирована задача '{task_name}': {func.__name__}")
+        
+        @wraps(func)
+        async def wrapper(*args, **kwargs):
+            try:
+                logger.info(f"⏰ Выполняем запланированную задачу '{task_name}'")
+                result = await func(*args, **kwargs)
+                logger.info(f"✅ Задача '{task_name}' выполнена успешно")
+                return result
+            except Exception as e:
+                logger.error(f"❌ Ошибка в задаче '{task_name}': {e}")
+                raise
+        
+        return wrapper
+    return decorator
+
+def get_event_handlers() -> Dict[str, Dict[str, Any]]:
+    """Возвращает все зарегистрированные обработчики событий"""
+    return _event_handlers.copy()
+
+def get_scheduled_tasks() -> Dict[str, Dict[str, Any]]:
+    """Возвращает все зарегистрированные задачи"""
+    return _scheduled_tasks.copy()
+
+def get_handlers_for_prompt() -> str:
+    """
+    Возвращает описание всех обработчиков для добавления в промпт
+    """
+    if not _event_handlers and not _scheduled_tasks:
+        return ""
+    
+    prompt_parts = []
+    
+    if _event_handlers:
+        prompt_parts.append("ДОСТУПНЫЕ ОБРАБОТЧИКИ СОБЫТИЙ:")
+        for event_type, handler_info in _event_handlers.items():
+            prompt_parts.append(f"- {event_type}: {handler_info['description']}")
+    
+    if _scheduled_tasks:
+        prompt_parts.append("\nДОСТУПНЫЕ ЗАДАЧИ ДЛЯ ПЛАНИРОВАНИЯ:")
+        for task_name, task_info in _scheduled_tasks.items():
+            prompt_parts.append(f"- {task_name}: {task_info['description']}")
+    
+    return "\n".join(prompt_parts)
+
+async def execute_event_handler(event_type: str, *args, **kwargs) -> Any:
+    """Выполняет обработчик события по типу"""
+    if event_type not in _event_handlers:
+        raise ValueError(f"Обработчик события '{event_type}' не найден")
+    
+    handler_info = _event_handlers[event_type]
+    return await handler_info['handler'](*args, **kwargs)
+
+async def execute_scheduled_task(task_name: str, *args, **kwargs) -> Any:
+    """Выполняет запланированную задачу по имени"""
+    if task_name not in _scheduled_tasks:
+        raise ValueError(f"Задача '{task_name}' не найдена")
+    
+    task_info = _scheduled_tasks[task_name]
+    return await task_info['handler'](*args, **kwargs)
+
+async def schedule_task_for_later(task_name: str, delay_seconds: int, *args, **kwargs):
+    """
+    Планирует выполнение задачи через указанное время
+    
+    Args:
+        task_name: Название задачи
+        delay_seconds: Задержка в секундах
+        *args, **kwargs: Аргументы для задачи
+    """
+    if task_name not in _scheduled_tasks:
+        raise ValueError(f"Задача '{task_name}' не найдена")
+    
+    logger.info(f"⏰ Планируем задачу '{task_name}' через {delay_seconds} секунд")
+    
+    async def delayed_task():
+        await asyncio.sleep(delay_seconds)
+        await execute_scheduled_task(task_name, *args, **kwargs)
+    
+    # Запускаем задачу в фоне
+    asyncio.create_task(delayed_task())
+    
+    return {
+        "status": "scheduled",
+        "task_name": task_name,
+        "delay_seconds": delay_seconds,
+        "scheduled_at": datetime.now().isoformat()
+    }
+
+async def execute_scheduled_task_from_event(user_id: int, task_name: str, event_info: str):
+    """
+    Выполняет запланированную задачу на основе события от ИИ
+    
+    Args:
+        user_id: ID пользователя
+        task_name: Название задачи
+        event_info: Информация от ИИ (содержит время и сообщение)
+    """
+    if task_name not in _scheduled_tasks:
+        raise ValueError(f"Задача '{task_name}' не найдена")
+    
+    # Парсим event_info для извлечения времени и сообщения
+    # Формат: "через 2 часа: напомнить о приеме"
+    try:
+        if ":" in event_info:
+            time_part, message = event_info.split(":", 1)
+            time_part = time_part.strip()
+            message = message.strip()
+        else:
+            time_part = event_info
+            message = "Напоминание"
+        
+        # Парсим время
+        delay_seconds = _parse_time_to_seconds(time_part)
+        
+        # Планируем задачу
+        result = await schedule_task_for_later(task_name, delay_seconds, user_id, message)
+        
+        return result
+        
+    except Exception as e:
+        logger.error(f"Ошибка парсинга времени из event_info '{event_info}': {e}")
+        # Fallback - планируем через 1 час
+        return await schedule_task_for_later(task_name, 3600, user_id, event_info)
+
+def _parse_time_to_seconds(time_str: str) -> int:
+    """
+    Парсит строку времени в секунды
+    Поддерживает форматы:
+    - "через 2 часа"
+    - "через 30 минут" 
+    - "через 1 день"
+    - "через 2 часа 30 минут"
+    """
+    import re
+    
+    time_str = time_str.lower().strip()
+    
+    # Ищем часы
+    hours_match = re.search(r'(\d+)\s*час', time_str)
+    hours = int(hours_match.group(1)) if hours_match else 0
+    
+    # Ищем минуты
+    minutes_match = re.search(r'(\d+)\s*минут', time_str)
+    minutes = int(minutes_match.group(1)) if minutes_match else 0
+    
+    # Ищем дни
+    days_match = re.search(r'(\d+)\s*дн', time_str)
+    days = int(days_match.group(1)) if days_match else 0
+    
+    # Конвертируем в секунды
+    total_seconds = (days * 24 * 3600) + (hours * 3600) + (minutes * 60)
+    
+    # Минимум 1 минута
+    return max(total_seconds, 60)

smart_bot_factory/core/message_sender.py

@@ -0,0 +1,249 @@
+"""
+Функции для отправки сообщений через ИИ и от человека
+"""
+
+import logging
+import time
+from datetime import datetime
+from typing import Dict, Any, Optional
+import pytz
+
+logger = logging.getLogger(__name__)
+
+async def send_message_by_ai(
+    user_id: int, 
+    message_text: str, 
+    session_id: str = None
+) -> Dict[str, Any]:
+    """
+    Отправляет сообщение пользователю через ИИ (копирует логику process_user_message)
+    
+    Args:
+        user_id: ID пользователя в Telegram
+        message_text: Текст сообщения для обработки ИИ
+        session_id: ID сессии чата (если не указан, будет использована активная сессия)
+        
+    Returns:
+        Результат отправки
+    """
+    try:
+        # Импортируем необходимые компоненты
+        from .bot_utils import parse_ai_response, process_events
+        from .config import Config
+        from .openai_client import OpenAIClient
+        from .supabase_client import SupabaseClient
+        from .prompt_loader import PromptLoader
+        from aiogram import Bot
+
+        # Получаем компоненты из глобального контекста
+        from .handlers import get_global_var
+        bot = get_global_var('bot')
+        supabase_client = get_global_var('supabase_client')
+        openai_client = get_global_var('openai_client')
+        config = get_global_var('config')
+        prompt_loader = get_global_var('prompt_loader')
+        
+        # Если session_id не указан, получаем активную сессию пользователя
+        if not session_id:
+            session_info = await supabase_client.get_active_session(user_id)
+            if not session_info:
+                return {
+                    "status": "error",
+                    "error": "Активная сессия не найдена",
+                    "user_id": user_id
+                }
+            session_id = session_info['id']
+        
+        # Загружаем системный промпт
+        try:
+            system_prompt = await prompt_loader.load_system_prompt()
+            logger.info(f"✅ Системный промпт загружен ({len(system_prompt)} символов)")
+        except Exception as e:
+            logger.error(f"❌ Ошибка загрузки системного промпта: {e}")
+            return {
+                "status": "error",
+                "error": "Не удалось загрузить системный промпт",
+                "user_id": user_id
+            }
+        
+        # Сохраняем сообщение пользователя в БД
+        await supabase_client.add_message(
+            session_id=session_id,
+            role='user',
+            content=message_text,
+            message_type='text'
+        )
+        logger.info(f"✅ Сообщение пользователя сохранено в БД")
+        
+        # Получаем историю сообщений
+        chat_history = await supabase_client.get_chat_history(session_id, limit=config.MAX_CONTEXT_MESSAGES)
+        logger.info(f"📚 Загружена история: {len(chat_history)} сообщений")
+        
+        # Добавляем текущее время
+        moscow_tz = pytz.timezone('Europe/Moscow')
+        current_time = datetime.now(moscow_tz)
+        time_info = current_time.strftime('%H:%M, %d.%m.%Y, %A')
+        
+        # Модифицируем системный промпт, добавляя время
+        system_prompt_with_time = f"""
+{system_prompt}
+
+ТЕКУЩЕЕ ВРЕМЯ: {time_info} (московское время)
+"""
+        
+        # Формируем контекст для OpenAI
+        messages = [{"role": "system", "content": system_prompt_with_time}]
+        
+        for msg in chat_history[-config.MAX_CONTEXT_MESSAGES:]:
+            messages.append({
+                "role": msg['role'],
+                "content": msg['content']
+            })
+        
+        # Добавляем финальные инструкции
+        final_instructions = await prompt_loader.load_final_instructions()
+        if final_instructions:
+            messages.append({"role": "system", "content": final_instructions})
+            logger.info(f"🎯 Добавлены финальные инструкции")
+        
+        logger.info(f"📝 Контекст сформирован: {len(messages)} сообщений")
+        
+        # Отправляем действие "печатает"
+        await bot.send_chat_action(user_id, "typing")
+        
+        # Получаем ответ от ИИ
+        start_time = time.time()
+        ai_response = await openai_client.get_completion(messages)
+        processing_time = int((time.time() - start_time) * 1000)
+        
+        logger.info(f"🤖 OpenAI ответил за {processing_time}мс")
+        
+        # Обрабатываем ответ
+        tokens_used = 0
+        ai_metadata = {}
+        response_text = ""
+        
+        if not ai_response or not ai_response.strip():
+            logger.warning(f"❌ OpenAI вернул пустой ответ!")
+            fallback_message = "Извините, произошла техническая ошибка. Попробуйте переформулировать вопрос."
+            ai_response = fallback_message
+            response_text = fallback_message
+        else:
+            tokens_used = openai_client.estimate_tokens(ai_response)
+            response_text, ai_metadata = parse_ai_response(ai_response)
+            
+            if not ai_metadata:
+                response_text = ai_response
+                ai_metadata = {}
+            elif not response_text.strip():
+                response_text = ai_response
+        
+        # Обновляем этап сессии и качество лида
+        if ai_metadata:
+            stage = ai_metadata.get('этап')
+            quality = ai_metadata.get('качество')
+            
+            if stage or quality is not None:
+                await supabase_client.update_session_stage(session_id, stage, quality)
+                logger.info(f"✅ Этап и качество обновлены в БД")
+            
+            # Обрабатываем события
+            events = ai_metadata.get('события', [])
+            if events:
+                logger.info(f"🔔 Обрабатываем {len(events)} событий")
+                await process_events(session_id, events, user_id)
+        
+        # Сохраняем ответ ассистента
+        await supabase_client.add_message(
+            session_id=session_id,
+            role='assistant',
+            content=response_text,
+            message_type='text',
+            tokens_used=tokens_used,
+            processing_time_ms=processing_time,
+            ai_metadata=ai_metadata
+        )
+        
+        # Определяем финальный ответ
+        if config.DEBUG_MODE:
+            final_response = ai_response
+        else:
+            final_response = response_text
+        
+        # Отправляем ответ пользователю напрямую через бота
+        await bot.send_message(
+            chat_id=user_id,
+            text=final_response
+        )
+        
+        return {
+            "status": "success",
+            "user_id": user_id,
+            "response_text": response_text,
+            "tokens_used": tokens_used,
+            "processing_time_ms": processing_time,
+            "events_processed": len(events) if events else 0
+        }
+        
+    except Exception as e:
+        logger.error(f"❌ Ошибка в send_message_by_ai: {e}")
+        return {
+            "status": "error",
+            "error": str(e),
+            "user_id": user_id
+        }
+
+async def send_message_by_human(
+    user_id: int, 
+    message_text: str,
+    session_id: Optional[str] = None
+) -> Dict[str, Any]:
+    """
+    Отправляет сообщение пользователю от имени человека (готовый текст)
+    
+    Args:
+        user_id: ID пользователя в Telegram
+        message_text: Готовый текст сообщения
+        session_id: ID сессии (опционально, для сохранения в БД)
+        
+    Returns:
+        Результат отправки
+    """
+    try:
+        # Импортируем необходимые компоненты
+        from .handlers import get_global_var
+        bot = get_global_var('bot')
+        supabase_client = get_global_var('supabase_client')
+        
+        # Отправляем сообщение пользователю
+        message = await bot.send_message(
+            chat_id=user_id,
+            text=message_text
+        )
+        
+        # Если указана сессия, сохраняем сообщение в БД
+        if session_id:
+            await supabase_client.add_message(
+                session_id=session_id,
+                role='assistant',
+                content=message_text,
+                message_type='text',
+                metadata={'sent_by_human': True}
+            )
+            logger.info(f"💾 Сообщение от человека сохранено в БД")
+        
+        return {
+            "status": "success",
+            "user_id": user_id,
+            "message_id": message.message_id,
+            "message_text": message_text,
+            "saved_to_db": bool(session_id)
+        }
+        
+    except Exception as e:
+        logger.error(f"❌ Ошибка в send_message_by_human: {e}")
+        return {
+            "status": "error",
+            "error": str(e),
+            "user_id": user_id
+        }

smart_bot_factory/core/states.py

@@ -0,0 +1,14 @@
+"""
+Состояния FSM для бота
+"""
+
+from aiogram.fsm.state import State, StatesGroup
+
+class UserStates(StatesGroup):
+    waiting_for_message = State()
+    admin_chat = State()  # пользователь в диалоге с админом
+
+class AdminStates(StatesGroup):
+    admin_mode = State()
+    in_conversation = State()
+

smart_bot_factory/creation/__init__.py

@@ -0,0 +1,8 @@
+"""
+Creation модули smart_bot_factory
+"""
+
+from ..creation.bot_builder import BotBuilder
+from ..creation.bot_testing import main as bot_testing_main
+
+__all__ = ['BotBuilder', 'bot_testing_main']