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

smart_bot_factory/integrations/__init__.py

@@ -1,83 +0,0 @@
-"""
-Интеграции с существующими файлами проекта
-"""
-
-# Импортируем существующие классы из корня проекта
-import sys
-from pathlib import Path
-
-# Добавляем корень проекта в путь для импорта существующих файлов
-project_root = Path(__file__).parent.parent.parent.parent
-if str(project_root) not in sys.path:
-    sys.path.insert(0, str(project_root))
-
-try:
-    from openai_client import OpenAIClient
-    from supabase_client import SupabaseClient
-    from config import Config
-    from conversation_manager import ConversationManager
-    from admin_manager import AdminManager
-    from prompt_loader import PromptLoader
-    from bot_utils import send_message, parse_ai_response, process_events
-    from handlers import router, setup_handlers
-    from admin_logic import setup_admin_handlers
-    from bot_utils import setup_utils_handlers
-except ImportError as e:
-    # Если файлы не найдены, создаем заглушки
-    print(f"⚠️ Предупреждение: не удалось импортировать существующие файлы: {e}")
-    
-    class OpenAIClient:
-        def __init__(self, *args, **kwargs):
-            raise NotImplementedError("OpenAIClient не найден. Убедитесь, что openai_client.py существует в корне проекта")
-    
-    class SupabaseClient:
-        def __init__(self, *args, **kwargs):
-            raise NotImplementedError("SupabaseClient не найден. Убедитесь, что supabase_client.py существует в корне проекта")
-    
-    class Config:
-        def __init__(self, *args, **kwargs):
-            raise NotImplementedError("Config не найден. Убедитесь, что config.py существует в корне проекта")
-    
-    class ConversationManager:
-        def __init__(self, *args, **kwargs):
-            raise NotImplementedError("ConversationManager не найден. Убедитесь, что conversation_manager.py существует в корне проекта")
-    
-    class AdminManager:
-        def __init__(self, *args, **kwargs):
-            raise NotImplementedError("AdminManager не найден. Убедитесь, что admin_manager.py существует в корне проекта")
-    
-    class PromptLoader:
-        def __init__(self, *args, **kwargs):
-            raise NotImplementedError("PromptLoader не найден. Убедитесь, что prompt_loader.py существует в корне проекта")
-    
-    # Заглушки для функций
-    def send_message(*args, **kwargs):
-        raise NotImplementedError("send_message не найден. Убедитесь, что bot_utils.py существует в корне проекта")
-    
-    def parse_ai_response(*args, **kwargs):
-        raise NotImplementedError("parse_ai_response не найден. Убедитесь, что bot_utils.py существует в корне проекта")
-    
-    def process_events(*args, **kwargs):
-        raise NotImplementedError("process_events не найден. Убедитесь, что bot_utils.py существует в корне проекта")
-    
-    # Заглушки для роутера
-    router = None
-    setup_handlers = None
-    setup_admin_handlers = None
-    setup_utils_handlers = None
-
-__all__ = [
-    'OpenAIClient',
-    'SupabaseClient', 
-    'Config',
-    'ConversationManager',
-    'AdminManager',
-    'PromptLoader',
-    'send_message',
-    'parse_ai_response', 
-    'process_events',
-    'router',
-    'setup_handlers',
-    'setup_admin_handlers',
-    'setup_utils_handlers'
-]

smart_bot_factory/integrations/bot_utils_integration.py

@@ -1,224 +0,0 @@
-"""
-Интеграция с bot_utils.py для обработки событий
-"""
-
-import logging
-from typing import List, Dict, Any
-
-logger = logging.getLogger(__name__)
-
-async def enhanced_process_events(session_id: str, events: List[Dict[str, Any]], user_id: int):
-    """
-    Улучшенная версия process_events из bot_utils.py
-    с поддержкой декораторов обработчиков событий
-    """
-    from ..events.decorators import (
-        execute_event_handler, 
-        get_event_handlers, 
-        get_scheduled_tasks,
-        execute_scheduled_task_from_event
-    )
-    
-    logger.info(f"🔔 Обрабатываем {len(events)} событий для пользователя {user_id}")
-    
-    for event in events:
-        try:
-            event_type = event.get('тип', '')
-            event_info = event.get('инфо', '')
-            
-            if not event_type:
-                continue
-            
-            logger.info(f"📝 Обрабатываем событие: {event_type}")
-            
-            # Проверяем, есть ли зарегистрированный обработчик событий
-            event_handlers = get_event_handlers()
-            scheduled_tasks = get_scheduled_tasks()
-            
-            if event_type in event_handlers:
-                # Используем зарегистрированный обработчик событий
-                logger.info(f"🔧 Используем зарегистрированный обработчик для '{event_type}'")
-                
-                try:
-                    # Парсим event_info если это строка
-                    if isinstance(event_info, str):
-                        event_data = _parse_event_info(event_info, user_id)
-                    else:
-                        event_data = event_info
-                    
-                    # Вызываем обработчик
-                    result = await execute_event_handler(event_type, user_id, event_data)
-                    logger.info(f"✅ Обработчик '{event_type}' выполнен: {result}")
-                    
-                except Exception as e:
-                    logger.error(f"❌ Ошибка в обработчике '{event_type}': {e}")
-                    # Fallback к стандартной обработке
-                    await _fallback_event_processing(session_id, event_type, event_info, user_id)
-                    
-            elif event_type in scheduled_tasks:
-                # Это запланированная задача - парсим время из event_info
-                logger.info(f"⏰ Планируем задачу '{event_type}' на основе event_info: {event_info}")
-                
-                try:
-                    result = await execute_scheduled_task_from_event(user_id, event_type, event_info)
-                    logger.info(f"✅ Задача '{event_type}' запланирована: {result}")
-                    
-                except Exception as e:
-                    logger.error(f"❌ Ошибка в планировании задачи '{event_type}': {e}")
-                    # Fallback к стандартной обработке
-                    await _fallback_event_processing(session_id, event_type, event_info, user_id)
-            else:
-                # Используем стандартную обработку из bot_utils.py
-                logger.info(f"📋 Используем стандартную обработку для '{event_type}'")
-                await _fallback_event_processing(session_id, event_type, event_info, user_id)
-            
-        except Exception as e:
-            logger.error(f"❌ Ошибка при обработке события {event}: {e}")
-
-def _parse_event_info(event_info: str, user_id: int) -> Dict[str, Any]:
-    """
-    Парсит строку event_info и извлекает структурированные данные
-    """
-    # Простой парсинг для типичных случаев
-    # Например: "Иван Петров, +7-999-123-45-67, интересуется имплантацией"
-    
-    data = {
-        "user_id": user_id,
-        "raw_info": event_info
-    }
-    
-    # Пытаемся извлечь телефон
-    import re
-    phone_match = re.search(r'\+?[7-8]?[\s\-]?\(?\d{3}\)?[\s\-]?\d{3}[\s\-]?\d{2}[\s\-]?\d{2}', event_info)
-    if phone_match:
-        data["phone"] = phone_match.group(0)
-    
-    # Пытаемся извлечь имя (первое слово)
-    words = event_info.split(',')
-    if words:
-        data["name"] = words[0].strip()
-    
-    # Пытаемся извлечь услугу/интерес
-    if len(words) > 2:
-        data["interest"] = words[2].strip()
-    
-    return data
-
-async def _fallback_event_processing(session_id: str, event_type: str, event_info: str, user_id: int):
-    """
-    Стандартная обработка событий (из оригинального bot_utils.py)
-    """
-    # Импортируем оригинальную функцию
-    import sys
-    from pathlib import Path
-    
-    # Добавляем корень проекта в путь
-    project_root = Path(__file__).parent.parent.parent.parent
-    if str(project_root) not in sys.path:
-        sys.path.insert(0, str(project_root))
-    
-    try:
-        from supabase_client import SupabaseClient
-        from main import supabase_client
-        
-        # Сохраняем в БД
-        await supabase_client.add_session_event(session_id, event_type, event_info)
-        
-        # Уведомляем админов
-        await _notify_admins_about_event(user_id, {
-            'тип': event_type,
-            'инфо': event_info
-        })
-        
-    except ImportError:
-        logger.warning("Не удалось импортировать оригинальные модули для fallback обработки")
-
-async def _notify_admins_about_event(user_id: int, event: Dict[str, Any]):
-    """
-    Уведомление админов о событии (из оригинального bot_utils.py)
-    """
-    try:
-        import sys
-        from pathlib import Path
-        
-        # Добавляем корень проекта в путь
-        project_root = Path(__file__).parent.parent.parent.parent
-        if str(project_root) not in sys.path:
-            sys.path.insert(0, str(project_root))
-        
-        from main import supabase_client, admin_manager, bot
-        from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
-        from datetime import datetime
-        
-        event_type = event.get('тип', '')
-        event_info = event.get('инфо', '')
-        
-        if not event_type:
-            return
-        
-        # Получаем информацию о пользователе
-        try:
-            user_response = supabase_client.client.table('sales_users').select(
-                'first_name', 'last_name', 'username'
-            ).eq('telegram_id', user_id).execute()
-            
-            user_info = user_response.data[0] if user_response.data else {}
-            
-            # Формируем имя пользователя
-            name_parts = []
-            if user_info.get('first_name'):
-                name_parts.append(user_info['first_name'])
-            if user_info.get('last_name'):
-                name_parts.append(user_info['last_name'])
-            
-            user_name = " ".join(name_parts) if name_parts else "Без имени"
-            
-            # Формируем отображение пользователя
-            if user_info.get('username'):
-                user_display = f"{user_name} (@{user_info['username']})"
-            else:
-                user_display = user_name
-                
-        except Exception as e:
-            logger.error(f"Ошибка получения информации о пользователе {user_id}: {e}")
-            user_display = "Пользователь"
-        
-        # Маппинг эмодзи
-        emoji_map = {
-            'телефон': '📱',
-            'консультация': '💬',
-            'покупка': '💰',
-            'отказ': '❌',
-            'appointment_booking': '📅',
-            'phone_collection': '📱'
-        }
-        
-        emoji = emoji_map.get(event_type, '🔔')
-        
-        # Формируем уведомление
-        notification = f"""
-{emoji} {event_type.upper()}!
-👤 {user_display}
-🆔 ID: {user_id}
-📝 {event_info}
-🕐 {datetime.now().strftime('%H:%M')}
-"""
-        
-        # Создаем клавиатуру
-        keyboard = InlineKeyboardMarkup(inline_keyboard=[
-            [
-                InlineKeyboardButton(text="💬 Чат", callback_data=f"admin_chat_{user_id}"),
-                InlineKeyboardButton(text="📋 История", callback_data=f"admin_history_{user_id}")
-            ]
-        ])
-        
-        # Отправляем всем активным админам
-        active_admins = await admin_manager.get_active_admins()
-        for admin_id in active_admins:
-            try:
-                await bot.send_message(admin_id, notification.strip(), reply_markup=keyboard)
-            except Exception as e:
-                logger.error(f"Ошибка отправки уведомления админу {admin_id}: {e}")
-                
-    except Exception as e:
-        logger.error(f"Ошибка отправки уведомления админам: {e}")

smart_bot_factory/services/__init__.py

@@ -1,12 +0,0 @@
-"""
-Сервисы для работы с внешними API
-"""
-
-from .telegram_integration import TelegramIntegration
-from .message_sender import send_message_by_ai, send_message_by_human
-
-__all__ = [
-    'TelegramIntegration',
-    'send_message_by_ai',
-    'send_message_by_human'
-]

smart_bot_factory/services/message_sender.py

@@ -1,235 +0,0 @@
-"""
-Функции для отправки сообщений через ИИ и от человека
-"""
-
-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,
-    system_prompt: str = None
-) -> Dict[str, Any]:
-    """
-    Отправляет сообщение пользователю через ИИ (копирует логику process_user_message)
-    
-    Args:
-        user_id: ID пользователя в Telegram
-        message_text: Текст сообщения для обработки ИИ
-        session_id: ID сессии чата
-        system_prompt: Системный промпт для ИИ
-        
-    Returns:
-        Результат отправки
-    """
-    try:
-        # Импортируем необходимые компоненты
-        from ..integrations import supabase_client, openai_client, config, bot, prompt_loader, parse_ai_response, process_events
-        
-        # Если 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']
-        
-        # Если system_prompt не указан, получаем из сессии
-        if not system_prompt:
-            session_info = await supabase_client.get_session_info(session_id)
-            if not session_info:
-                return {
-                    "status": "error", 
-                    "error": "Информация о сессии не найдена",
-                    "user_id": user_id
-                }
-            system_prompt = session_info['system_prompt']
-        
-        # Сохраняем сообщение пользователя в БД
-        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 ..integrations import bot, 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
-        }