smart-bot-factory 0.1.5__py3-none-any.whl → 0.1.7__py3-none-any.whl

smart_bot_factory/cli.py

@@ -35,9 +35,9 @@ def list():
         click.echo("🤖 Нет доступных ботов")
         return
         
-        click.echo("🤖 Доступные боты:")
-        for bot in sorted(bots):
-            click.echo(f"  📱 {bot}")
+    click.echo("🤖 Доступные боты:")
+    for bot in sorted(bots):
+        click.echo(f"  📱 {bot}")
 
 @cli.command()
 @click.argument("bot_id")
@@ -191,8 +191,8 @@ def prompts(bot_id: str, list_prompts: bool = False, edit_prompt: str = None, ad
         if not prompts_dir.exists():
             raise click.ClickException(f"Папка промптов не найдена для бота {bot_id}")
         
-        if list_prompts:
-            # Показываем список промптов
+        if list_prompts or (not edit_prompt and not add_prompt):
+            # Показываем список промптов (по умолчанию или с флагом --list)
             prompt_files = [f.name for f in prompts_dir.glob("*.txt")]
             
             if not prompt_files:
@@ -202,6 +202,13 @@ def prompts(bot_id: str, list_prompts: bool = False, edit_prompt: str = None, ad
             click.echo(f"📝 Промпты бота {bot_id}:")
             for prompt_file in sorted(prompt_files):
                 click.echo(f"  📄 {prompt_file[:-4]}")
+            
+            # Показываем справку только если не указан флаг --list
+            if not list_prompts:
+                click.echo()
+                click.echo("Использование:")
+                click.echo("  sbf prompts <bot_id> --edit <prompt_name>      # Редактировать промпт")
+                click.echo("  sbf prompts <bot_id> --add <prompt_name>       # Добавить новый промпт")
         
         elif edit_prompt:
             # Редактируем промпт
@@ -231,12 +238,6 @@ def prompts(bot_id: str, list_prompts: bool = False, edit_prompt: str = None, ad
             click.echo(f"📝 Создаем новый промпт {add_prompt}...")
             subprocess.run([editor, str(prompt_file)], check=True)
         
-        else:
-            # Показываем справку
-            click.echo("📖 Использование:")
-            click.echo("   📋 sbf prompts <bot_id> --list                    # Показать список промптов")
-            click.echo("   ✏️ sbf prompts <bot_id> --edit <prompt_name>      # Редактировать промпт")
-            click.echo("   ➕ sbf prompts <bot_id> --add <prompt_name>       # Добавить новый промпт")
             
     except subprocess.CalledProcessError as e:
         click.echo(f"❌ Ошибка при открытии редактора: {e}", err=True)
@@ -259,21 +260,21 @@ def rm(bot_id: str, force: bool = False):
         # Проверяем существование бота
         bot_path = PROJECT_ROOT / Path("bots") / bot_id
         if not bot_path.exists():
-            raise click.ClickException(f"Бот {bot_id} не найден в папке bots/")
+            raise click.ClickException(f"🤖 Бот {bot_id} не найден в папке bots/")
         
         # Проверяем наличие основного файла бота в корневой директории
         bot_file = Path(f"{bot_id}.py")
         if not bot_file.exists():
-            raise click.ClickException(f"Файл {bot_id}.py не найден в корневой директории")
+            raise click.ClickException(f"📄 Файл {bot_id}.py не найден в корневой директории")
         
         # Показываем что будет удалено
         click.echo("🗑️ Будет удалено:")
-        click.echo(f"   📄 Файл запускалки: {bot_file}")
-        click.echo(f"   📁 Папка бота: {bot_path}")
+        click.echo(f"  📄 Файл запускалки: {bot_file}")
+        click.echo(f"  📁 Папка бота: {bot_path}")
         
         # Запрашиваем подтверждение если не указан --force
         if not force:
-            if not click.confirm(f"❓ Вы уверены, что хотите удалить бота {bot_id}?"):
+            if not click.confirm(f"⚠️ Вы уверены, что хотите удалить бота {bot_id}?"):
                 click.echo("❌ Удаление отменено")
                 return
         
@@ -288,7 +289,7 @@ def rm(bot_id: str, force: bool = False):
             shutil.rmtree(bot_path)
             click.echo(f"✅ Папка {bot_path} удалена")
         
-        click.echo(f"🗑️ Бот {bot_id} полностью удален")
+        click.echo(f"🎉 Бот {bot_id} полностью удален")
         
     except Exception as e:
         click.echo(f"❌ Ошибка при удалении бота: {e}", err=True)
@@ -318,8 +319,8 @@ def copy(source_bot_id: str, new_bot_id: str, force: bool = False):
         
         if new_bot_path.exists() or new_bot_file.exists():
             if not force:
-                if not click.confirm(f"⚠️ Бот {new_bot_id} уже существует. Перезаписать?"):
-                    click.echo("❌ Копирование отменено")
+                if not click.confirm(f"Бот {new_bot_id} уже существует. Перезаписать?"):
+                    click.echo("Копирование отменено")
                     return
             else:
                 click.echo(f"⚠️ Перезаписываем существующего бота {new_bot_id}")
@@ -414,14 +415,16 @@ def create_bot_template(bot_id: str) -> str:
 
 import asyncio
 
-from smart_bot_factory.core import Router
-from smart_bot_factory.core import send_message_by_human
-from smart_bot_factory.clients import supabase_client
+from smart_bot_factory.router import Router
+from smart_bot_factory.message import send_message_by_human
+from smart_bot_factory.supabase import SupabaseClient
 from smart_bot_factory.creation import BotBuilder
 
 # Создаем роутер для всех обработчиков
 router = Router("{bot_id}_handlers")
 
+supabase_client = SupabaseClient("{bot_id}")
+
 # =============================================================================
 # ОБРАБОТЧИКИ СОБЫТИЙ
 # =============================================================================
@@ -677,18 +680,10 @@ def copy_bot_template(source_bot_id: str, new_bot_id: str):
             new_bot_file.write_text(content, encoding='utf-8')
             click.echo(f"   📄 Файл запускалки скопирован: {new_bot_id}.py")
         
-        # Копируем .env файл
-        source_env = source_dir / ".env"
+        # Создаем шаблон .env файла (НЕ копируем существующий)
         new_env = new_dir / ".env"
-        
-        if source_env.exists():
-            shutil.copy2(source_env, new_env)
-            
-            # Заменяем BOT_ID в .env
-            env_content = new_env.read_text(encoding='utf-8')
-            env_content = env_content.replace(f'BOT_ID={source_bot_id}', f'BOT_ID={new_bot_id}')
-            new_env.write_text(env_content, encoding='utf-8')
-            click.echo(f"   ⚙️ .env файл скопирован и обновлен")
+        new_env.write_text(create_env_template(new_bot_id), encoding='utf-8')
+        click.echo(f"   ⚙️ Создан шаблон .env файла")
         
         # Копируем промпты
         source_prompts = source_dir / "prompts"

smart_bot_factory/core/bot_utils.py

@@ -31,45 +31,6 @@ def get_global_var(var_name):
 
 logger = logging.getLogger(__name__)
 
-def parse_time_expression(time_text: str) -> int:
-    """
-    Парсит временные выражения и возвращает количество секунд
-    
-    Поддерживаемые форматы:
-    - "30" -> 30 секунд (основной формат)
-    - "Запуск через 30 секунд" -> 30 секунд
-    - "через 5 минут" -> 300 секунд
-    - "через 1 час" -> 3600 секунд
-    - "через 2 часа" -> 7200 секунд
-    """
-    # Сначала пробуем простое число (основной формат)
-    try:
-        return int(time_text)
-    except ValueError:
-        pass
-    
-    # Убираем лишние символы и приводим к нижнему регистру
-    text = re.sub(r'[^\w\s\d]', '', time_text.lower())
-    
-    # Ищем числа в тексте
-    numbers = re.findall(r'\d+', text)
-    if not numbers:
-        raise ValueError(f"Не найдено число в выражении: {time_text}")
-    
-    number = int(numbers[0])
-    
-    # Определяем единицу времени
-    if 'секунд' in text:
-        return number
-    elif 'минут' in text:
-        return number * 60
-    elif 'час' in text:
-        return number * 3600
-    elif 'день' in text or 'дней' in text:
-        return number * 86400
-    else:
-        # По умолчанию считаем секундами
-        return number
 
 # Создаем роутер для общих команд
 utils_router = Router()
@@ -244,10 +205,12 @@ async def process_events(session_id: str, events: list, user_id: int):
                     event_handlers = router_manager.get_event_handlers()
                     scheduled_tasks = router_manager.get_scheduled_tasks()
                     global_handlers = router_manager.get_global_handlers()
+                    logger.debug(f"🔍 RouterManager найден: {len(global_handlers)} глобальных обработчиков")
                 else:
                     event_handlers = _event_handlers
                     scheduled_tasks = _scheduled_tasks
                     global_handlers = _global_handlers
+                    logger.warning("⚠️ RouterManager не найден, используем старые декораторы")
                 
                 # Сначала пробуем как обычное событие
                 if event_type in event_handlers:
@@ -266,49 +229,59 @@ async def process_events(session_id: str, events: list, user_id: int):
                 # Если не user_event, пробуем как запланированную задачу
                 elif event_type in scheduled_tasks:
                     try:
-                        delay_seconds = parse_time_expression(event_info)
+                        # Извлекаем время из event_info (AI должен передавать число секунд)
+                        try:
+                            delay_seconds = int(event_info)
+                        except ValueError:
+                            # Если не число, используем значение по умолчанию
+                            delay_seconds = 3600
+                            logger.warning(f"   ⚠️ Не удалось извлечь время из '{event_info}', используем 3600с")
+                        
                         logger.info(f"   ⏰ Сохраняем как scheduled_task: '{event_type}' через {delay_seconds}с")
                         result = await schedule_task_for_later_with_db(event_type, user_id, event_info, delay_seconds, session_id)
                         event_id = result['event_id']
                         should_notify = result.get('notify', False)
                         logger.info(f"   💾 Задача сохранена в БД: {event_id}")
                         
-                    except ValueError as e:
+                    except Exception as e:
                         if "once_only=True" in str(e):
                             logger.info(f"   🔄 Задача '{event_type}' уже запланирована, пропускаем")
                             continue
                         else:
-                            logger.error(f"   ❌ Ошибка парсинга времени для scheduled_task '{event_type}': {e}")
-                            # Fallback - планируем через 1 час
-                            result = await schedule_task_for_later_with_db(event_type, user_id, event_info, 3600, session_id)
-                            event_id = result['event_id']
-                            should_notify = result.get('notify', False)
-                            logger.info(f"   ⏰ Задача сохранена с fallback временем (1 час): {event_id}")
+                            logger.error(f"   ❌ Ошибка планирования scheduled_task '{event_type}': {e}")
+                            continue
                 
                 # Если не scheduled_task, пробуем как глобальный обработчик
                 elif event_type in global_handlers:
                     try:
-                        delay_seconds = parse_time_expression(event_info)
+                        # Извлекаем время из event_info (AI должен передавать число секунд)
+                        try:
+                            delay_seconds = int(event_info)
+                        except ValueError:
+                            # Если не число, используем значение по умолчанию
+                            delay_seconds = 3600
+                            logger.warning(f"   ⚠️ Не удалось извлечь время из '{event_info}', используем 3600с")
+                        
                         logger.info(f"   🌍 Сохраняем как global_handler: '{event_type}' через {delay_seconds}с")
                         result = await schedule_global_handler_for_later_with_db(event_type, delay_seconds, event_info)
                         event_id = result['event_id']
                         should_notify = result.get('notify', False)
                         logger.info(f"   💾 Глобальное событие сохранено в БД: {event_id}")
                         
-                    except ValueError as e:
+                    except Exception as e:
                         if "once_only=True" in str(e):
                             logger.info(f"   🔄 Глобальное событие '{event_type}' уже запланировано, пропускаем")
                             continue
                         else:
-                            logger.error(f"   ❌ Ошибка парсинга времени для global_handler '{event_type}': {e}")
-                            # Fallback - планируем через 1 час
-                            result = await schedule_global_handler_for_later_with_db(event_type, 3600, event_info)
-                            event_id = result['event_id']
-                            should_notify = result.get('notify', False)
-                            logger.info(f"   🌍 Глобальное событие сохранено с fallback временем (1 час): {event_id}")
+                            logger.error(f"   ❌ Ошибка планирования global_handler '{event_type}': {e}")
+                            continue
                 
                 else:
                     logger.warning(f"   ⚠️ Обработчик '{event_type}' не найден среди зарегистрированных")
+                    logger.debug(f"   🔍 Доступные обработчики:")
+                    logger.debug(f"      - event_handlers: {list(event_handlers.keys())}")
+                    logger.debug(f"      - scheduled_tasks: {list(scheduled_tasks.keys())}")
+                    logger.debug(f"      - global_handlers: {list(global_handlers.keys())}")
                 
                 # Выполняем немедленные события
                 if should_execute_immediately and event_id:

smart_bot_factory/core/decorators.py

@@ -292,18 +292,16 @@ async def execute_scheduled_task(task_name: str, user_id: int, user_data: str) -
 
 async def execute_global_handler(handler_type: str, *args, **kwargs) -> Any:
     """Выполняет глобальный обработчик по типу"""
-    # Сначала пробуем получить из роутеров
-    if _router_manager:
-        global_handlers = _router_manager.get_global_handlers()
-        if handler_type in global_handlers:
-            handler_info = global_handlers[handler_type]
-            return await handler_info['handler'](*args, **kwargs)
+    router_manager = get_router_manager()
+    if router_manager:
+        global_handlers = router_manager.get_global_handlers()
+    else:
+        global_handlers = _global_handlers
     
-    # Fallback к старым декораторам
-    if handler_type not in _global_handlers:
+    if handler_type not in global_handlers:
         raise ValueError(f"Глобальный обработчик '{handler_type}' не найден")
     
-    handler_info = _global_handlers[handler_type]
+    handler_info = global_handlers[handler_type]
     return await handler_info['handler'](*args, **kwargs)
 
 async def schedule_task_for_later(task_name: str, delay_seconds: int, user_id: int, user_data: str):
@@ -461,12 +459,7 @@ async def save_immediate_event(
         raise RuntimeError("Supabase клиент не инициализирован")
     
     # Проверяем, нужно ли предотвращать дублирование
-    # Получаем информацию об обработчике через роутер-менеджер или fallback
-    if _router_manager:
-        event_handlers = _router_manager.get_event_handlers()
-        event_handler_info = event_handlers.get(event_type, {})
-    else:
-        event_handler_info = _event_handlers.get(event_type, {})
+    event_handler_info = _event_handlers.get(event_type, {})
     once_only = event_handler_info.get('once_only', True)
     
     if once_only:
@@ -510,12 +503,7 @@ async def save_scheduled_task(
         raise RuntimeError("Supabase клиент не инициализирован")
     
     # Проверяем, нужно ли предотвращать дублирование
-    # Получаем информацию о задаче через роутер-менеджер или fallback
-    if _router_manager:
-        scheduled_tasks = _router_manager.get_scheduled_tasks()
-        task_info = scheduled_tasks.get(task_name, {})
-    else:
-        task_info = _scheduled_tasks.get(task_name, {})
+    task_info = _scheduled_tasks.get(task_name, {})
     once_only = task_info.get('once_only', True)
     
     if once_only:
@@ -559,12 +547,13 @@ async def save_global_event(
         raise RuntimeError("Supabase клиент не инициализирован")
     
     # Проверяем, нужно ли предотвращать дублирование
-    # Получаем информацию о глобальном обработчике через роутер-менеджер или fallback
-    if _router_manager:
-        global_handlers = _router_manager.get_global_handlers()
-        handler_info = global_handlers.get(handler_type, {})
+    router_manager = get_router_manager()
+    if router_manager:
+        global_handlers = router_manager.get_global_handlers()
     else:
-        handler_info = _global_handlers.get(handler_type, {})
+        global_handlers = _global_handlers
+    
+    handler_info = global_handlers.get(handler_type, {})
     once_only = handler_info.get('once_only', True)
     
     if once_only:
@@ -714,14 +703,8 @@ async def process_scheduled_event(event: Dict):
 async def schedule_task_for_later_with_db(task_name: str, user_id: int, user_data: str, delay_seconds: int, session_id: str = None):
     """Планирует выполнение задачи через указанное время с сохранением в БД"""
     
-    # Проверяем через роутер-менеджер или fallback к старым декораторам
-    if _router_manager:
-        scheduled_tasks = _router_manager.get_scheduled_tasks()
-        if task_name not in scheduled_tasks:
-            raise ValueError(f"Задача '{task_name}' не найдена")
-    else:
-        if task_name not in _scheduled_tasks:
-            raise ValueError(f"Задача '{task_name}' не найдена")
+    if task_name not in _scheduled_tasks:
+        raise ValueError(f"Задача '{task_name}' не найдена")
     
     logger.info(f"⏰ Планируем задачу '{task_name}' через {delay_seconds} секунд")
     
@@ -782,14 +765,15 @@ async def schedule_task_for_later_with_db(task_name: str, user_id: int, user_dat
 async def schedule_global_handler_for_later_with_db(handler_type: str, delay_seconds: int, handler_data: str):
     """Планирует выполнение глобального обработчика через указанное время с сохранением в БД"""
     
-    # Проверяем через роутер-менеджер или fallback к старым декораторам
-    if _router_manager:
-        global_handlers = _router_manager.get_global_handlers()
-        if handler_type not in global_handlers:
-            raise ValueError(f"Глобальный обработчик '{handler_type}' не найден")
+    # Проверяем обработчик через RouterManager или fallback к старым декораторам
+    router_manager = get_router_manager()
+    if router_manager:
+        global_handlers = router_manager.get_global_handlers()
     else:
-        if handler_type not in _global_handlers:
-            raise ValueError(f"Глобальный обработчик '{handler_type}' не найден")
+        global_handlers = _global_handlers
+    
+    if handler_type not in global_handlers:
+        raise ValueError(f"Глобальный обработчик '{handler_type}' не найден")
     
     logger.info(f"🌍 Планируем глобальный обработчик '{handler_type}' через {delay_seconds} секунд")
     

smart_bot_factory/core/message_sender.py

@@ -29,11 +29,6 @@ async def send_message_by_ai(
     try:
         # Импортируем необходимые компоненты
         from .bot_utils import parse_ai_response, process_events
-        from ..config import Config
-        from ..integrations.openai_client import OpenAIClient
-        from ..integrations.supabase_client import SupabaseClient
-        from ..utils.prompt_loader import PromptLoader
-        from aiogram import Bot
 
         # Получаем компоненты из глобального контекста
         from ..handlers.handlers import get_global_var

smart_bot_factory/core/router.py

@@ -2,7 +2,7 @@
 Роутер для Smart Bot Factory - аналог aiogram Router
 """
 
-from typing import Dict, List, Any, Callable, Optional
+from typing import Dict, Any, Callable
 import logging
 
 logger = logging.getLogger(__name__)
@@ -170,3 +170,4 @@ class Router:
     
     def __repr__(self):
         return f"Router(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

@@ -163,3 +163,4 @@ class RouterManager:
     
     def __repr__(self):
         return f"RouterManager(routers={len(self._routers)}, handlers={len(self.get_all_handlers())})"
+

smart_bot_factory/creation/bot_builder.py

@@ -3,11 +3,9 @@
 """
 
 import os
-import sys
-import asyncio
 import logging
 from pathlib import Path
-from typing import Optional, Dict, Any, List
+from typing import Optional, Dict, Any
 
 from ..config import Config
 from ..integrations.openai_client import OpenAIClient
@@ -236,8 +234,13 @@ class BotBuilder:
             # Получаем модуль бота
             bot_module = sys.modules.get(module_name)
             if not bot_module:
-                logger.warning(f"⚠️ Модуль '{module_name}' не найден для установки глобальных переменных")
-                return
+                # Пытаемся импортировать модуль, если он не загружен
+                try:
+                    bot_module = importlib.import_module(module_name)
+                    logger.info(f"📦 Модуль '{module_name}' импортирован для установки глобальных переменных")
+                except ImportError as ie:
+                    logger.warning(f"⚠️ Не удалось импортировать модуль '{module_name}': {ie}")
+                    return
             
             # Устанавливаем глобальные переменные
             bot_module.supabase_client = self.supabase_client
@@ -302,8 +305,7 @@ class BotBuilder:
             prompts_status = await self.prompt_loader.validate_prompts()
             logger.info(f"Статус промптов: {prompts_status}")
             
-            # Устанавливаем глобальные переменные ДО импорта обработчиков
-            import sys
+           
             import importlib
             
             # Устанавливаем глобальные переменные в модулях handlers и admin_logic
@@ -381,26 +383,6 @@ class BotBuilder:
             # Устанавливаем глобальные переменные в модуле бота для удобного доступа
             self.set_global_vars_in_module(self.bot_id)
             
-            # Устанавливаем глобальные переменные в core.globals для внутреннего использования
-            from ..core.globals import set_globals
-            set_globals(
-                supabase_client=self.supabase_client,
-                openai_client=self.openai_client,
-                config=self.config,
-                admin_manager=self.admin_manager,
-                analytics_manager=self.analytics_manager,
-                conversation_manager=self.conversation_manager,
-                prompt_loader=self.prompt_loader,
-                bot=bot,
-                dp=dp
-            )
-            
-            # Устанавливаем клиенты в clients модуль для пользователей
-            from ..clients import set_clients
-            set_clients(
-                supabase=self.supabase_client,
-                openai=self.openai_client
-            )
             
             # Устанавливаем роутер-менеджер в декораторы
             if self.router_manager:

smart_bot_factory/event/__init__.py

@@ -0,0 +1,12 @@
+"""
+Event модули smart_bot_factory
+"""
+
+
+from ..core.decorators import event_handler, schedule_task, global_handler
+
+__all__ = [
+    'event_handler',
+    'schedule_task',
+    'global_handler'
+]

smart_bot_factory/message/__init__.py

@@ -0,0 +1,12 @@
+"""
+Message модули smart_bot_factory
+"""
+
+
+from ..core.message_sender import send_message_by_human, send_message_by_ai
+
+__all__ = [
+    'send_message_by_human',
+    'send_message_by_ai',
+    'send_message_to_users_by_stage'
+]

smart_bot_factory/router/__init__.py

@@ -0,0 +1,9 @@
+"""
+Router модули smart_bot_factory
+"""
+
+from ..core.router import Router
+
+__all__ = [
+    'Router'
+]

smart_bot_factory/supabase/__init__.py

@@ -0,0 +1,7 @@
+"""
+Supabase клиент с автоматической загрузкой настроек из .env
+"""
+
+from .client import SupabaseClient
+
+__all__ = ['SupabaseClient']