smart-bot-factory 1.1.1__py3-none-any.whl

smart_bot_factory/core/router.py

@@ -0,0 +1,347 @@
+"""
+EventRouter для Smart Bot Factory - роутер для событий, задач и глобальных обработчиков
+"""
+
+import logging
+from typing import Any, Callable, Dict, Union
+
+logger = logging.getLogger(__name__)
+
+
+class EventRouter:
+    """
+    Роутер для организации обработчиков событий, задач и глобальных обработчиков
+    """
+
+    def __init__(self, name: str = None):
+        """
+        Инициализация роутера
+
+        Args:
+            name: Имя роутера для логирования
+        """
+        self.name = name or f"EventRouter_{id(self)}"
+        self._event_handlers: Dict[str, Dict[str, Any]] = {}
+        self._scheduled_tasks: Dict[str, Dict[str, Any]] = {}
+        self._global_handlers: Dict[str, Dict[str, Any]] = {}
+
+        logger.info(f"🔄 Создан роутер: {self.name}")
+
+    def event_handler(
+        self,
+        event_type: str,
+        notify: bool = False,
+        once_only: bool = True,
+        send_ai_response: bool = True,
+    ):
+        """
+        Декоратор для регистрации обработчика события в роутере
+
+        Args:
+            event_type: Тип события
+            notify: Уведомлять ли админов
+            once_only: Выполнять ли только один раз
+            send_ai_response: Отправлять ли сообщение от ИИ после обработки события (по умолчанию True)
+        """
+
+        def decorator(func: Callable) -> Callable:
+            self._event_handlers[event_type] = {
+                "handler": func,
+                "name": func.__name__,
+                "notify": notify,
+                "once_only": once_only,
+                "send_ai_response": send_ai_response,
+                "router": self.name,
+            }
+
+            logger.info(
+                f"📝 Роутер {self.name}: зарегистрирован обработчик события '{event_type}': {func.__name__}"
+            )
+
+            from functools import wraps
+
+            @wraps(func)
+            async def wrapper(*args, **kwargs):
+                try:
+                    result = await func(*args, **kwargs)
+
+                    # Автоматически добавляем флаги notify и send_ai_response к результату
+                    if isinstance(result, dict):
+                        result["notify"] = notify
+                        result["send_ai_response"] = send_ai_response
+                    else:
+                        # Если результат не словарь, создаем словарь
+                        result = {
+                            "status": "success",
+                            "result": result,
+                            "notify": notify,
+                            "send_ai_response": send_ai_response,
+                        }
+
+                    return result
+                except Exception as e:
+                    logger.error(
+                        f"Ошибка выполнения обработчика '{event_type}' в роутере {self.name}: {e}"
+                    )
+                    raise
+
+            return wrapper
+
+        return decorator
+
+    def schedule_task(
+        self,
+        task_name: str,
+        notify: bool = False,
+        notify_time: str = "after",  # 'after' или 'before'
+        smart_check: bool = True,
+        once_only: bool = True,
+        delay: Union[str, int] = None,
+        event_type: Union[str, Callable] = None,
+        send_ai_response: bool = True,
+    ):
+        """
+        Декоратор для регистрации запланированной задачи в роутере
+
+        Args:
+            task_name: Название задачи
+            notify: Уведомлять ли админов
+            notify_time: Когда отправлять уведомление админам:
+                - 'before': при создании задачи
+                - 'after': после успешного выполнения (по умолчанию)
+            smart_check: Использовать ли умную проверку
+            once_only: Выполнять ли только один раз
+            delay: Время задержки в удобном формате (например, "1h 30m", "45m", 3600) - ОБЯЗАТЕЛЬНО
+            event_type: Источник времени события - ОПЦИОНАЛЬНО:
+                - str: Тип события для поиска в БД (например, 'appointment_booking')
+                - Callable: Функция async def(user_id, user_data) -> datetime
+            send_ai_response: Отправлять ли сообщение от ИИ после выполнения задачи (по умолчанию True)
+        """
+
+        def decorator(func: Callable) -> Callable:
+            # Время ОБЯЗАТЕЛЬНО должно быть указано
+            if delay is None:
+                raise ValueError(
+                    f"Для задачи '{task_name}' в роутере {self.name} ОБЯЗАТЕЛЬНО нужно указать параметр delay"
+                )
+
+            # Импортируем функцию парсинга времени
+            from .decorators import parse_time_string
+
+            # Парсим время
+            try:
+                default_delay_seconds = parse_time_string(delay)
+                if event_type:
+                    logger.info(
+                        f"⏰ Роутер {self.name}: задача '{task_name}' настроена как напоминание о событии '{event_type}' за {delay} ({default_delay_seconds}с)"
+                    )
+                else:
+                    logger.info(
+                        f"⏰ Роутер {self.name}: задача '{task_name}' настроена с задержкой: {delay} ({default_delay_seconds}с)"
+                    )
+            except ValueError as e:
+                logger.error(
+                    f"❌ Ошибка парсинга времени для задачи '{task_name}' в роутере {self.name}: {e}"
+                )
+                raise
+
+            # Проверяем корректность notify_time
+            if notify_time not in ["before", "after"]:
+                raise ValueError(f"notify_time должен быть 'before' или 'after', получено: {notify_time}")
+
+            self._scheduled_tasks[task_name] = {
+                "handler": func,
+                "name": func.__name__,
+                "notify": notify,
+                "notify_time": notify_time,  # Когда отправлять уведомление
+                "smart_check": smart_check,
+                "once_only": once_only,
+                "router": self.name,
+                "default_delay": default_delay_seconds,
+                "event_type": event_type,  # Новое поле для типа события
+                "send_ai_response": send_ai_response,
+            }
+
+            if event_type:
+                logger.info(
+                    f"⏰ Роутер {self.name}: зарегистрирована задача-напоминание '{task_name}' для события '{event_type}': {func.__name__}"
+                )
+            else:
+                logger.info(
+                    f"⏰ Роутер {self.name}: зарегистрирована задача '{task_name}': {func.__name__}"
+                )
+
+            from functools import wraps
+
+            @wraps(func)
+            async def wrapper(*args, **kwargs):
+                try:
+                    result = await func(*args, **kwargs)
+
+                    # Автоматически добавляем флаги notify и send_ai_response к результату
+                    if isinstance(result, dict):
+                        result["notify"] = notify
+                        result["send_ai_response"] = send_ai_response
+                    else:
+                        # Если результат не словарь, создаем словарь
+                        result = {
+                            "status": "success",
+                            "result": result,
+                            "notify": notify,
+                            "send_ai_response": send_ai_response,
+                        }
+
+                    return result
+                except Exception as e:
+                    logger.error(
+                        f"Ошибка выполнения задачи '{task_name}' в роутере {self.name}: {e}"
+                    )
+                    raise
+
+            return wrapper
+
+        return decorator
+
+    def global_handler(
+        self,
+        handler_type: str,
+        notify: bool = False,
+        once_only: bool = True,
+        delay: Union[str, int] = None,
+        event_type: Union[str, Callable] = None,
+        send_ai_response: bool = True,
+    ):
+        """
+        Декоратор для регистрации глобального обработчика в роутере
+
+        Args:
+            handler_type: Тип глобального обработчика
+            notify: Уведомлять ли админов
+            once_only: Выполнять ли только один раз
+            delay: Время задержки в удобном формате (например, "1h 30m", "45m", 3600) - ОБЯЗАТЕЛЬНО
+            send_ai_response: Отправлять ли сообщение от ИИ после выполнения обработчика (по умолчанию True)
+        """
+
+        def decorator(func: Callable) -> Callable:
+            # Время ОБЯЗАТЕЛЬНО должно быть указано
+            if delay is None:
+                raise ValueError(
+                    f"Для глобального обработчика '{handler_type}' в роутере {self.name} ОБЯЗАТЕЛЬНО нужно указать параметр delay"
+                )
+
+            # Импортируем функцию парсинга времени
+            from .decorators import parse_time_string
+
+            # Парсим время
+            try:
+                default_delay_seconds = parse_time_string(delay)
+                logger.info(
+                    f"🌍 Роутер {self.name}: глобальный обработчик '{handler_type}' настроен с задержкой: {delay} ({default_delay_seconds}с)"
+                )
+            except ValueError as e:
+                logger.error(
+                    f"❌ Ошибка парсинга времени для глобального обработчика '{handler_type}' в роутере {self.name}: {e}"
+                )
+                raise
+
+            self._global_handlers[handler_type] = {
+                "handler": func,
+                "name": func.__name__,
+                "notify": notify,
+                "once_only": once_only,
+                "router": self.name,
+                "default_delay": default_delay_seconds,
+                "event_type": event_type,  # Добавляем event_type для глобальных обработчиков
+                "send_ai_response": send_ai_response,
+            }
+
+            logger.info(
+                f"🌍 Роутер {self.name}: зарегистрирован глобальный обработчик '{handler_type}': {func.__name__}"
+            )
+
+            from functools import wraps
+
+            @wraps(func)
+            async def wrapper(*args, **kwargs):
+                try:
+                    result = await func(*args, **kwargs)
+
+                    # Автоматически добавляем флаги notify и send_ai_response к результату
+                    if isinstance(result, dict):
+                        result["notify"] = notify
+                        result["send_ai_response"] = send_ai_response
+                    else:
+                        # Если результат не словарь, создаем словарь
+                        result = {
+                            "status": "success",
+                            "result": result,
+                            "notify": notify,
+                            "send_ai_response": send_ai_response,
+                        }
+
+                    return result
+                except Exception as e:
+                    logger.error(
+                        f"Ошибка выполнения глобального обработчика '{handler_type}' в роутере {self.name}: {e}"
+                    )
+                    raise
+
+            return wrapper
+
+        return decorator
+
+    def get_event_handlers(self) -> Dict[str, Dict[str, Any]]:
+        """Получает все обработчики событий роутера"""
+        return self._event_handlers.copy()
+
+    def get_scheduled_tasks(self) -> Dict[str, Dict[str, Any]]:
+        """Получает все запланированные задачи роутера"""
+        return self._scheduled_tasks.copy()
+
+    def get_global_handlers(self) -> Dict[str, Dict[str, Any]]:
+        """Получает все глобальные обработчики роутера"""
+        return self._global_handlers.copy()
+
+    def get_all_handlers(self) -> Dict[str, Dict[str, Any]]:
+        """Получает все обработчики роутера"""
+        all_handlers = {}
+        all_handlers.update(self._event_handlers)
+        all_handlers.update(self._scheduled_tasks)
+        all_handlers.update(self._global_handlers)
+        return all_handlers
+
+    def include_router(self, router: "EventRouter"):
+        """
+        Включает другой роутер в текущий
+
+        Args:
+            router: EventRouter для включения
+        """
+        # Добавляем обработчики событий
+        for event_type, handler_info in router.get_event_handlers().items():
+            if event_type in self._event_handlers:
+                logger.warning(
+                    f"⚠️ Конфликт обработчиков событий '{event_type}' между роутерами {self.name} и {router.name}"
+                )
+            self._event_handlers[event_type] = handler_info
+
+        # Добавляем запланированные задачи
+        for task_name, task_info in router.get_scheduled_tasks().items():
+            if task_name in self._scheduled_tasks:
+                logger.warning(
+                    f"⚠️ Конфликт задач '{task_name}' между роутерами {self.name} и {router.name}"
+                )
+            self._scheduled_tasks[task_name] = task_info
+
+        # Добавляем глобальные обработчики
+        for handler_type, handler_info in router.get_global_handlers().items():
+            if handler_type in self._global_handlers:
+                logger.warning(
+                    f"⚠️ Конфликт глобальных обработчиков '{handler_type}' между роутерами {self.name} и {router.name}"
+                )
+            self._global_handlers[handler_type] = handler_info
+
+        logger.info(f"🔗 Роутер {self.name}: включен роутер {router.name}")
+
+    def __repr__(self):
+        return f"EventRouter(name='{self.name}', events={len(self._event_handlers)}, tasks={len(self._scheduled_tasks)}, globals={len(self._global_handlers)})"

smart_bot_factory/core/router_manager.py

@@ -0,0 +1,218 @@
+"""
+Менеджер роутеров для Smart Bot Factory
+"""
+
+import logging
+from typing import Any, Dict, List, Optional
+
+from .router import EventRouter
+
+logger = logging.getLogger(__name__)
+
+
+class RouterManager:
+    """
+    Менеджер для управления роутерами событий и их обработчиками
+    """
+
+    def __init__(self):
+        self._routers: List[EventRouter] = []
+        self._combined_handlers: Dict[str, Dict[str, Any]] = {
+            "event_handlers": {},
+            "scheduled_tasks": {},
+            "global_handlers": {},
+        }
+
+        logger.info("🔄 Создан менеджер роутеров")
+
+    def register_router(self, router: EventRouter):
+        """
+        Регистрирует роутер событий в менеджере
+
+        Args:
+            router: EventRouter для регистрации
+        """
+        if router not in self._routers:
+            self._routers.append(router)
+            self._update_combined_handlers()
+            logger.info(f"✅ Зарегистрирован роутер: {router.name}")
+        else:
+            logger.warning(f"⚠️ Роутер {router.name} уже зарегистрирован")
+
+    def unregister_router(self, router: EventRouter):
+        """
+        Отменяет регистрацию роутера событий
+
+        Args:
+            router: EventRouter для отмены регистрации
+        """
+        if router in self._routers:
+            self._routers.remove(router)
+            self._update_combined_handlers()
+            logger.info(f"❌ Отменена регистрация роутера: {router.name}")
+        else:
+            logger.warning(f"⚠️ Роутер {router.name} не найден в зарегистрированных")
+
+    def _update_combined_handlers(self):
+        """Обновляет объединенные обработчики всех роутеров"""
+        # Очищаем текущие обработчики
+        self._combined_handlers = {
+            "event_handlers": {},
+            "scheduled_tasks": {},
+            "global_handlers": {},
+        }
+
+        logger.debug(
+            f"🔍 RouterManager._update_combined_handlers(): обновляем обработчики для {len(self._routers)} роутеров"
+        )
+
+        # Собираем обработчики из всех роутеров
+        for router in self._routers:
+            logger.debug(f"🔍 Обрабатываем роутер: {router.name}")
+
+            # Обработчики событий
+            event_handlers = router.get_event_handlers()
+            logger.debug(
+                f"🔍 Роутер {router.name}: {len(event_handlers)} обработчиков событий"
+            )
+            for event_type, handler_info in event_handlers.items():
+                if event_type in self._combined_handlers["event_handlers"]:
+                    existing_router = self._combined_handlers["event_handlers"][
+                        event_type
+                    ]["router"]
+                    logger.warning(
+                        f"⚠️ Конфликт обработчиков событий '{event_type}' между роутерами {existing_router} и {router.name}"
+                    )
+                self._combined_handlers["event_handlers"][event_type] = handler_info
+
+            # Запланированные задачи
+            scheduled_tasks = router.get_scheduled_tasks()
+            logger.debug(
+                f"🔍 Роутер {router.name}: {len(scheduled_tasks)} запланированных задач: {list(scheduled_tasks.keys())}"
+            )
+            for task_name, task_info in scheduled_tasks.items():
+                if task_name in self._combined_handlers["scheduled_tasks"]:
+                    existing_router = self._combined_handlers["scheduled_tasks"][
+                        task_name
+                    ]["router"]
+                    logger.warning(
+                        f"⚠️ Конфликт задач '{task_name}' между роутерами {existing_router} и {router.name}"
+                    )
+                self._combined_handlers["scheduled_tasks"][task_name] = task_info
+
+            # Глобальные обработчики
+            global_handlers = router.get_global_handlers()
+            logger.debug(
+                f"🔍 Роутер {router.name}: {len(global_handlers)} глобальных обработчиков"
+            )
+            for handler_type, handler_info in global_handlers.items():
+                if handler_type in self._combined_handlers["global_handlers"]:
+                    existing_router = self._combined_handlers["global_handlers"][
+                        handler_type
+                    ]["router"]
+                    logger.warning(
+                        f"⚠️ Конфликт глобальных обработчиков '{handler_type}' между роутерами {existing_router} и {router.name}"
+                    )
+                self._combined_handlers["global_handlers"][handler_type] = handler_info
+
+        logger.debug(
+            f"🔍 RouterManager._update_combined_handlers(): итого - {len(self._combined_handlers['scheduled_tasks'])} задач: {list(self._combined_handlers['scheduled_tasks'].keys())}"
+        )
+
+        total_handlers = (
+            len(self._combined_handlers["event_handlers"])
+            + len(self._combined_handlers["scheduled_tasks"])
+            + len(self._combined_handlers["global_handlers"])
+        )
+
+        logger.info(
+            f"📊 Обновлены объединенные обработчики: {total_handlers} обработчиков из {len(self._routers)} роутеров"
+        )
+
+    def get_event_handlers(self) -> Dict[str, Dict[str, Any]]:
+        """Получает все обработчики событий"""
+        return self._combined_handlers["event_handlers"].copy()
+
+    def get_scheduled_tasks(self) -> Dict[str, Dict[str, Any]]:
+        """Получает все запланированные задачи"""
+        tasks = self._combined_handlers["scheduled_tasks"].copy()
+        logger.debug(
+            f"🔍 RouterManager.get_scheduled_tasks(): возвращаем {len(tasks)} задач: {list(tasks.keys())}"
+        )
+        return tasks
+
+    def get_global_handlers(self) -> Dict[str, Dict[str, Any]]:
+        """Получает все глобальные обработчики"""
+        return self._combined_handlers["global_handlers"].copy()
+
+    def get_all_handlers(self) -> Dict[str, Dict[str, Any]]:
+        """Получает все обработчики всех типов"""
+        all_handlers = {}
+        all_handlers.update(self._combined_handlers["event_handlers"])
+        all_handlers.update(self._combined_handlers["scheduled_tasks"])
+        all_handlers.update(self._combined_handlers["global_handlers"])
+        return all_handlers
+
+    def get_handlers_for_prompt(self) -> str:
+        """Возвращает описание всех обработчиков для добавления в промпт ИИ"""
+        prompt_parts: List[str] = []
+
+        if not any(self._combined_handlers.values()):
+            return ""
+
+        if self._combined_handlers["event_handlers"]:
+            prompt_parts.append("ДОСТУПНЫЕ ОБРАБОТЧИКИ СОБЫТИЙ:")
+            for event_type, handler_info in self._combined_handlers[
+                "event_handlers"
+            ].items():
+                router_name = handler_info.get("router", "unknown")
+                prompt_parts.append(
+                    f"- {event_type}: {handler_info['name']} (роутер: {router_name})"
+                )
+
+        if self._combined_handlers["scheduled_tasks"]:
+            prompt_parts.append("\nДОСТУПНЫЕ ЗАДАЧИ ДЛЯ ПЛАНИРОВАНИЯ:")
+            for task_name, task_info in self._combined_handlers[
+                "scheduled_tasks"
+            ].items():
+                router_name = task_info.get("router", "unknown")
+                prompt_parts.append(
+                    f"- {task_name}: {task_info['name']} (роутер: {router_name})"
+                )
+
+        if self._combined_handlers["global_handlers"]:
+            prompt_parts.append("\nДОСТУПНЫЕ ГЛОБАЛЬНЫЕ ОБРАБОТЧИКИ:")
+            for handler_type, handler_info in self._combined_handlers[
+                "global_handlers"
+            ].items():
+                router_name = handler_info.get("router", "unknown")
+                prompt_parts.append(
+                    f"- {handler_type}: {handler_info['name']} (роутер: {router_name})"
+                )
+
+        return "\n".join(prompt_parts)
+
+    def get_router_by_name(self, name: str) -> Optional[EventRouter]:
+        """Получает роутер событий по имени"""
+        for router in self._routers:
+            if router.name == name:
+                return router
+        return None
+
+    def get_router_stats(self) -> Dict[str, Any]:
+        """Получает статистику по роутерам"""
+        stats = {"total_routers": len(self._routers), "routers": []}
+
+        for router in self._routers:
+            router_stats = {
+                "name": router.name,
+                "event_handlers": len(router.get_event_handlers()),
+                "scheduled_tasks": len(router.get_scheduled_tasks()),
+                "global_handlers": len(router.get_global_handlers()),
+            }
+            stats["routers"].append(router_stats)
+
+        return stats
+
+    def __repr__(self):
+        return f"RouterManager(routers={len(self._routers)}, handlers={len(self.get_all_handlers())})"

smart_bot_factory/core/states.py

@@ -0,0 +1,27 @@
+"""
+Состояния FSM для бота
+"""
+
+from aiogram.fsm.state import State, StatesGroup
+
+
+class UserStates(StatesGroup):
+    waiting_for_message = State()
+    admin_chat = State()  # пользователь в диалоге с админом
+
+    voice_confirmation = State()  # ожидание подтверждения распознанного текста
+    voice_editing = State()  # редактирование распознанного текста
+
+
+class AdminStates(StatesGroup):
+    admin_mode = State()
+    in_conversation = State()
+
+    # Состояния для создания события
+    create_event_name = State()
+    create_event_date = State()
+    create_event_time = State()
+    create_event_segment = State()
+    create_event_message = State()
+    create_event_files = State()
+    create_event_confirm = State()

smart_bot_factory/creation/__init__.py

@@ -0,0 +1,7 @@
+"""
+Creation модули smart_bot_factory
+"""
+
+from ..creation.bot_builder import BotBuilder
+
+__all__ = ["BotBuilder"]