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

smart_bot_factory/core/__init__.py

@@ -1,7 +0,0 @@
-"""
-Ядро Smart Bot Factory
-"""
-
-from .bot_builder import BotBuilder
-
-__all__ = ['BotBuilder']

smart_bot_factory/core/bot_builder.py

@@ -1,337 +0,0 @@
-"""
-Строитель ботов для Smart Bot Factory
-"""
-
-import os
-import sys
-import asyncio
-import logging
-from pathlib import Path
-from typing import Optional, Dict, Any, List
-
-from ..integrations import (
-    Config, OpenAIClient, SupabaseClient, 
-    ConversationManager, AdminManager, PromptLoader
-)
-from ..events.decorators import get_handlers_for_prompt
-
-logger = logging.getLogger(__name__)
-
-class BotBuilder:
-    """
-    Строитель ботов, который использует существующие файлы проекта
-    и добавляет новые возможности через декораторы
-    """
-    
-    def __init__(self, bot_id: str, config_dir: Optional[Path] = None):
-        """
-        Инициализация строителя бота
-        
-        Args:
-            bot_id: Идентификатор бота
-            config_dir: Путь к директории конфигурации (по умолчанию configs/bot_id)
-        """
-        self.bot_id = bot_id
-        self.config_dir = config_dir or Path("bots") / bot_id
-        
-        # Компоненты бота
-        self.config: Optional[Config] = None
-        self.openai_client: Optional[OpenAIClient] = None
-        self.supabase_client: Optional[SupabaseClient] = None
-        self.conversation_manager: Optional[ConversationManager] = None
-        self.admin_manager: Optional[AdminManager] = None
-        self.prompt_loader: Optional[PromptLoader] = None
-        
-        # Флаги инициализации
-        self._initialized = False
-        
-        logger.info(f"🏗️ Создан BotBuilder для бота: {bot_id}")
-    
-    async def build(self) -> 'BotBuilder':
-        """
-        Строит и инициализирует все компоненты бота
-        
-        Returns:
-            BotBuilder: Возвращает self для цепочки вызовов
-        """
-        if self._initialized:
-            logger.warning(f"⚠️ Бот {self.bot_id} уже инициализирован")
-            return self
-        
-        try:
-            logger.info(f"🚀 Начинаем сборку бота {self.bot_id}")
-            
-            # 1. Инициализируем конфигурацию
-            await self._init_config()
-            
-            # 2. Инициализируем клиенты
-            await self._init_clients()
-            
-            # 3. Инициализируем менеджеры
-            await self._init_managers()
-            
-            # 4. Обновляем промпты с информацией о доступных инструментах
-            await self._update_prompts_with_tools()
-            
-            self._initialized = True
-            logger.info(f"✅ Бот {self.bot_id} успешно собран и готов к работе")
-            
-            return self
-            
-        except Exception as e:
-            logger.error(f"❌ Ошибка при сборке бота {self.bot_id}: {e}")
-            raise
-    
-    async def _init_config(self):
-        """Инициализация конфигурации"""
-        logger.info(f"⚙️ Инициализация конфигурации для {self.bot_id}")
-        
-        # Устанавливаем BOT_ID в переменные окружения
-        os.environ['BOT_ID'] = self.bot_id
-        
-        # Загружаем .env файл если существует
-        env_file = self.config_dir / ".env"
-        if env_file.exists():
-            from dotenv import load_dotenv
-            load_dotenv(env_file)
-            logger.info(f"📄 Загружен .env файл: {env_file}")
-        
-        # Проверяем, установлен ли уже путь к промптам в файле запускалки
-        if "PROMT_FILES_DIR" in os.environ:
-            logger.info(f"📁 Путь к промптам уже установлен: {os.environ['PROMT_FILES_DIR']}")
-        else:
-            # Устанавливаем правильный путь к промптам ПОСЛЕ загрузки .env
-            # Берем значение из .env и добавляем к пути bots/bot-id/
-            prompts_subdir = os.environ.get("PROMT_FILES_DIR", "prompts")
-            logger.info(f"🔍 PROMT_FILES_DIR из .env: {prompts_subdir}")
-            logger.info(f"🔍 config_dir: {self.config_dir}")
-            
-            prompts_dir = self.config_dir / prompts_subdir
-            logger.info(f"🔍 Полный путь к промптам: {prompts_dir}")
-            logger.info(f"🔍 Существует ли папка: {prompts_dir.exists()}")
-            
-            # ВАЖНО: Устанавливаем правильный путь ДО создания Config
-            if prompts_dir.exists():
-                os.environ["PROMT_FILES_DIR"] = str(prompts_dir)
-                logger.info(f"📁 Установлен путь к промптам: {prompts_dir}")
-            else:
-                logger.error(f"❌ Папка с промптами не найдена: {prompts_dir}")
-                # Устанавливаем путь даже если папки нет, чтобы Config не упал
-                os.environ["PROMT_FILES_DIR"] = str(prompts_dir)
-        
-        # Создаем конфигурацию
-        logger.info(f"🔍 PROMT_FILES_DIR перед созданием Config: {os.environ.get('PROMT_FILES_DIR')}")
-        self.config = Config()
-        logger.info(f"✅ Конфигурация инициализирована")
-    
-    async def _init_clients(self):
-        """Инициализация клиентов"""
-        logger.info(f"🔌 Инициализация клиентов для {self.bot_id}")
-        
-        # OpenAI клиент
-        self.openai_client = OpenAIClient(
-            api_key=self.config.OPENAI_API_KEY,
-            model=self.config.OPENAI_MODEL,
-            max_tokens=self.config.OPENAI_MAX_TOKENS,
-            temperature=self.config.OPENAI_TEMPERATURE
-        )
-        logger.info(f"✅ OpenAI клиент инициализирован")
-        
-        # Supabase клиент
-        self.supabase_client = SupabaseClient(
-            url=self.config.SUPABASE_URL,
-            key=self.config.SUPABASE_KEY,
-            bot_id=self.bot_id
-        )
-        await self.supabase_client.initialize()
-        logger.info(f"✅ Supabase клиент инициализирован")
-    
-    async def _init_managers(self):
-        """Инициализация менеджеров"""
-        logger.info(f"👥 Инициализация менеджеров для {self.bot_id}")
-        
-        # Admin Manager
-        self.admin_manager = AdminManager(self.config, self.supabase_client)
-        await self.admin_manager.sync_admins_from_config()
-        logger.info(f"✅ Admin Manager инициализирован")
-        
-        # Conversation Manager
-        self.conversation_manager = ConversationManager(self.supabase_client, self.admin_manager)
-        logger.info(f"✅ Conversation Manager инициализирован")
-        
-        # Prompt Loader
-        self.prompt_loader = PromptLoader(
-            prompts_dir=self.config.PROMT_FILES_DIR,
-            prompt_files=self.config.PROMPT_FILES
-        )
-        await self.prompt_loader.validate_prompts()
-        logger.info(f"✅ Prompt Loader инициализирован")
-    
-    async def _update_prompts_with_tools(self):
-        """
-        Обновляет промпты информацией о доступных обработчиках событий
-        """
-        logger.info(f"🔧 Обновление промптов с информацией об обработчиках")
-        
-        # Получаем информацию о доступных обработчиках
-        event_handlers_info = get_handlers_for_prompt()
-        
-        # Если есть обработчики, добавляем их в системный промпт
-        if event_handlers_info:
-            # Сохраняем информацию о обработчиках для использования в handlers.py
-            self._tools_prompt = event_handlers_info
-            
-            logger.info(f"✅ Промпты обновлены с информацией об обработчиках")
-        else:
-            self._tools_prompt = ""
-            logger.info(f"ℹ️ Нет зарегистрированных обработчиков")
-    
-    def get_tools_prompt(self) -> str:
-        """Возвращает промпт с информацией об инструментах"""
-        return getattr(self, '_tools_prompt', '')
-    
-    def get_status(self) -> Dict[str, Any]:
-        """Возвращает статус бота"""
-        return {
-            "bot_id": self.bot_id,
-            "initialized": self._initialized,
-            "config_dir": str(self.config_dir),
-            "components": {
-                "config": self.config is not None,
-                "openai_client": self.openai_client is not None,
-                "supabase_client": self.supabase_client is not None,
-                "conversation_manager": self.conversation_manager is not None,
-                "admin_manager": self.admin_manager is not None,
-                "prompt_loader": self.prompt_loader is not None
-            },
-            "tools": {
-                "event_handlers": len(get_handlers_for_prompt().split('\n')) if get_handlers_for_prompt() else 0
-            }
-        }
-    
-    async def start(self):
-        """
-        Запускает бота (аналог main.py)
-        """
-        if not self._initialized:
-            raise RuntimeError(f"Бот {self.bot_id} не инициализирован. Вызовите build() сначала")
-        
-        logger.info(f"🚀 Запускаем бота {self.bot_id}")
-        
-        try:
-            # Импортируем необходимые компоненты
-            from aiogram import Bot, Dispatcher
-            from aiogram.fsm.storage.memory import MemoryStorage
-            
-            # Создаем бота и диспетчер
-            bot = Bot(token=self.config.TELEGRAM_BOT_TOKEN)
-            storage = MemoryStorage()
-            dp = Dispatcher(storage=storage)
-            
-            # Инициализируем базу данных
-            await self.supabase_client.initialize()
-            
-            # Синхронизируем админов из конфигурации
-            await self.admin_manager.sync_admins_from_config()
-            
-            # Проверяем доступность промптов
-            prompts_status = await self.prompt_loader.validate_prompts()
-            logger.info(f"Статус промптов: {prompts_status}")
-            
-            # Устанавливаем глобальные переменные ДО импорта обработчиков
-            import sys
-            import importlib
-            
-            # Устанавливаем глобальные переменные в модулях handlers и admin_logic
-            try:
-                handlers_module = importlib.import_module('handlers')
-                handlers_module.config = self.config
-                handlers_module.bot = bot
-                handlers_module.dp = dp
-                handlers_module.supabase_client = self.supabase_client
-                handlers_module.openai_client = self.openai_client
-                handlers_module.prompt_loader = self.prompt_loader
-                handlers_module.admin_manager = self.admin_manager
-                handlers_module.conversation_manager = self.conversation_manager
-                logger.info("✅ Глобальные переменные установлены в handlers")
-            except Exception as e:
-                logger.warning(f"⚠️ Не удалось установить глобальные переменные в handlers: {e}")
-            
-            try:
-                admin_logic_module = importlib.import_module('admin_logic')
-                admin_logic_module.config = self.config
-                admin_logic_module.bot = bot
-                admin_logic_module.dp = dp
-                admin_logic_module.supabase_client = self.supabase_client
-                admin_logic_module.openai_client = self.openai_client
-                admin_logic_module.prompt_loader = self.prompt_loader
-                admin_logic_module.admin_manager = self.admin_manager
-                admin_logic_module.conversation_manager = self.conversation_manager
-                logger.info("✅ Глобальные переменные установлены в admin_logic")
-            except Exception as e:
-                logger.warning(f"⚠️ Не удалось установить глобальные переменные в admin_logic: {e}")
-            
-            # Также устанавливаем в bot_utils
-            try:
-                bot_utils_module = importlib.import_module('bot_utils')
-                bot_utils_module.config = self.config
-                bot_utils_module.bot = bot
-                bot_utils_module.dp = dp
-                bot_utils_module.supabase_client = self.supabase_client
-                bot_utils_module.openai_client = self.openai_client
-                bot_utils_module.prompt_loader = self.prompt_loader
-                bot_utils_module.admin_manager = self.admin_manager
-                bot_utils_module.conversation_manager = self.conversation_manager
-                logger.info("✅ Глобальные переменные установлены в bot_utils")
-            except Exception as e:
-                logger.warning(f"⚠️ Не удалось установить глобальные переменные в bot_utils: {e}")
-            
-            # Также устанавливаем в debug_routing
-            try:
-                debug_routing_module = importlib.import_module('debug_routing')
-                debug_routing_module.config = self.config
-                debug_routing_module.bot = bot
-                debug_routing_module.dp = dp
-                debug_routing_module.supabase_client = self.supabase_client
-                debug_routing_module.openai_client = self.openai_client
-                debug_routing_module.prompt_loader = self.prompt_loader
-                debug_routing_module.admin_manager = self.admin_manager
-                debug_routing_module.conversation_manager = self.conversation_manager
-                logger.info("✅ Глобальные переменные установлены в debug_routing")
-            except Exception as e:
-                logger.warning(f"⚠️ Не удалось установить глобальные переменные в debug_routing: {e}")
-            
-            # Теперь импортируем и настраиваем обработчики
-            from ..integrations import setup_handlers, setup_admin_handlers, setup_utils_handlers
-            
-            # Настраиваем обработчики запросов
-            setup_utils_handlers(dp)    # Утилитарные команды (/status, /help)
-            setup_admin_handlers(dp)    # Админские команды (/админ, /стат, /чат)
-            setup_handlers(dp)          # Основные пользовательские обработчики
-            
-            # Логируем информацию о запуске
-            logger.info(f"✅ Бот {self.bot_id} запущен и готов к работе!")
-            logger.info(f"   📊 Изоляция данных: bot_id = {self.config.BOT_ID}")
-            logger.info(f"   👑 Админов настроено: {len(self.config.ADMIN_TELEGRAM_IDS)}")
-            logger.info(f"   📝 Загружено промптов: {len(self.config.PROMPT_FILES)}")
-            
-            # Четкое сообщение о запуске
-            print(f"\n🚀 БОТ {self.bot_id.upper()} УСПЕШНО ЗАПУЩЕН!")
-            print(f"📱 Telegram Bot ID: {self.config.BOT_ID}")
-            print(f"👑 Админов: {len(self.config.ADMIN_TELEGRAM_IDS)}")
-            print(f"📝 Промптов: {len(self.config.PROMPT_FILES)}")
-            print(f"🔄 Ожидание сообщений...")
-            print(f"⏹️  Для остановки нажмите Ctrl+C\n")
-            
-            # Запуск polling (бесконечная обработка сообщений)
-            await dp.start_polling(bot)
-            
-        except Exception as e:
-            logger.error(f"❌ Ошибка при запуске бота {self.bot_id}: {e}")
-            import traceback
-            logger.error(f"Стек ошибки: {traceback.format_exc()}")
-            raise
-        finally:
-            # Очистка ресурсов при завершении
-            if 'bot' in locals():
-                await bot.session.close()

smart_bot_factory/events/__init__.py

@@ -1,27 +0,0 @@
-"""
-Система событий для Smart Bot Factory
-"""
-
-from .decorators import (
-    event_handler,
-    schedule_task,
-    get_event_handlers,
-    get_scheduled_tasks,
-    get_handlers_for_prompt,
-    execute_event_handler,
-    execute_scheduled_task,
-    schedule_task_for_later,
-    execute_scheduled_task_from_event
-)
-
-__all__ = [
-    'event_handler',
-    'schedule_task',
-    'get_event_handlers',
-    'get_scheduled_tasks', 
-    'get_handlers_for_prompt',
-    'execute_event_handler',
-    'execute_scheduled_task',
-    'schedule_task_for_later',
-    'execute_scheduled_task_from_event'
-]

smart_bot_factory/events/decorators.py

@@ -1,229 +0,0 @@
-"""
-Декораторы для обработчиков событий и временных задач
-"""
-
-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)