smart-bot-factory 0.2.11__py3-none-any.whl → 0.3.2__py3-none-any.whl

smart_bot_factory/core/router.py

@@ -57,7 +57,7 @@ class EventRouter:
             return wrapper
         return decorator
     
-    def schedule_task(self, task_name: str, notify: bool = False, smart_check: bool = True, once_only: bool = True, delay: Union[str, int] = None, event_type: str = None):
+    def schedule_task(self, task_name: str, notify: bool = False, smart_check: bool = True, once_only: bool = True, delay: Union[str, int] = None, event_type: Union[str, Callable] = None):
         """
         Декоратор для регистрации запланированной задачи в роутере
         
@@ -67,7 +67,9 @@ class EventRouter:
             smart_check: Использовать ли умную проверку
             once_only: Выполнять ли только один раз
             delay: Время задержки в удобном формате (например, "1h 30m", "45m", 3600) - ОБЯЗАТЕЛЬНО
-            event_type: Тип события для напоминания (например, 'appointment_booking') - ОПЦИОНАЛЬНО
+            event_type: Источник времени события - ОПЦИОНАЛЬНО:
+                - str: Тип события для поиска в БД (например, 'appointment_booking')
+                - Callable: Функция async def(user_id, user_data) -> datetime
         """
         def decorator(func: Callable) -> Callable:
             # Время ОБЯЗАТЕЛЬНО должно быть указано
@@ -115,7 +117,7 @@ class EventRouter:
             return wrapper
         return decorator
     
-    def global_handler(self, handler_type: str, notify: bool = False, once_only: bool = True, delay: Union[str, int] = None):
+    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):
         """
         Декоратор для регистрации глобального обработчика в роутере
         
@@ -147,7 +149,8 @@ class EventRouter:
                 'notify': notify,
                 'once_only': once_only,
                 'router': self.name,
-                'default_delay': default_delay_seconds
+                'default_delay': default_delay_seconds,
+                'event_type': event_type  # Добавляем event_type для глобальных обработчиков
             }
             
             logger.info(f"🌍 Роутер {self.name}: зарегистрирован глобальный обработчик '{handler_type}': {func.__name__}")

smart_bot_factory/creation/bot_builder.py

@@ -317,25 +317,45 @@ class BotBuilder:
         Регистрирует Telegram роутер для обработки команд и сообщений
         
         Args:
-            telegram_router: TelegramRouter для регистрации
+            telegram_router: aiogram.Router для регистрации
+            
+        Example:
+            from aiogram import Router
+            from aiogram.filters import Command
+            
+            # Создаем обычный aiogram Router
+            my_router = Router(name="my_commands")
+            
+            @my_router.message(Command("price"))
+            async def price_handler(message: Message):
+                await message.answer("Наши цены...")
+            
+            # Регистрируем в боте
+            bot_builder.register_telegram_router(my_router)
         """
-        from ..core.telegram_router import TelegramRouter
+        from aiogram import Router as AiogramRouter
         
-        if not isinstance(telegram_router, TelegramRouter):
-            raise TypeError(f"Ожидается TelegramRouter, получен {type(telegram_router)}")
+        if not isinstance(telegram_router, AiogramRouter):
+            raise TypeError(f"Ожидается aiogram.Router, получен {type(telegram_router)}")
         
         self._telegram_routers.append(telegram_router)
-        logger.info(f"✅ Telegram роутер '{telegram_router.name}' зарегистрирован в боте {self.bot_id}")
+        router_name = getattr(telegram_router, 'name', 'unnamed')
+        logger.info(f"✅ Telegram роутер '{router_name}' зарегистрирован в боте {self.bot_id}")
     
     def register_telegram_routers(self, *telegram_routers):
         """
         Регистрирует несколько Telegram роутеров одновременно
         
         Args:
-            *telegram_routers: Произвольное количество TelegramRouter
+            *telegram_routers: Произвольное количество aiogram.Router
             
         Example:
-            bot_builder.register_telegram_routers(telegram_router1, telegram_router2)
+            from aiogram import Router
+            
+            router1 = Router(name="commands")
+            router2 = Router(name="callbacks")
+            
+            bot_builder.register_telegram_routers(router1, router2)
         """
         if not telegram_routers:
             logger.warning("⚠️ register_telegram_routers вызван без аргументов")
@@ -688,8 +708,9 @@ class BotBuilder:
             if self._telegram_routers:
                 logger.info(f"🔗 Подключаем {len(self._telegram_routers)} пользовательских Telegram роутеров")
                 for telegram_router in self._telegram_routers:
-                    dp.include_router(telegram_router.get_aiogram_router())
-                    logger.info(f"✅ Подключен Telegram роутер: {telegram_router.name}")
+                    dp.include_router(telegram_router)
+                    router_name = getattr(telegram_router, 'name', 'unnamed')
+                    logger.info(f"✅ Подключен Telegram роутер: {router_name}")
             
             # Настраиваем стандартные обработчики (меньший приоритет)
             setup_utils_handlers(dp)    # Утилитарные команды (/status, /help)
@@ -718,6 +739,12 @@ class BotBuilder:
             logger.info(f"   👑 Админов настроено: {len(self.config.ADMIN_TELEGRAM_IDS)}")
             logger.info(f"   📝 Загружено промптов: {len(self.config.PROMPT_FILES)}")
             
+            # Запускаем фоновый процессор событий
+            from ..core.decorators import background_event_processor
+            import asyncio
+            asyncio.create_task(background_event_processor())
+            logger.info("✅ Фоновый процессор событий запущен (проверка БД каждую минуту)")
+            
             # Четкое сообщение о запуске
             print(f"\n🤖 БОТ {self.bot_id.upper()} УСПЕШНО ЗАПУЩЕН!")
             print(f"📱 Telegram Bot ID: {self.config.BOT_ID}")

smart_bot_factory/handlers/handlers.py

@@ -5,7 +5,7 @@ import time
 from aiogram import Router, F
 from aiogram.filters import Command, StateFilter
 from aiogram.fsm.context import FSMContext
-from aiogram.types import Message
+from aiogram.types import Message, CallbackQuery
 
 from ..core.bot_utils import send_message, parse_ai_response, process_events, send_welcome_file
 from ..core.states import UserStates, AdminStates
@@ -64,9 +64,9 @@ async def start_handler(message: Message, state: FSMContext):
         logger.error(f"Ошибка при обработке /start: {e}")
         await send_message(message, "Произошла ошибка при инициализации. Попробуйте позже.")
 
-@router.message(Command(commands=["timeup"]))
+@router.message(Command(commands=["timeup", "вперед"]))
 async def timeup_handler(message: Message, state: FSMContext):
-    """Обработчик команды /timeup - тестирование запланированных событий"""
+    """Обработчик команды /timeup (или /вперед) - тестирование запланированных событий"""
     from ..core.decorators import process_scheduled_event, update_event_result
     from datetime import datetime
     
@@ -172,7 +172,153 @@ async def timeup_handler(message: Message, state: FSMContext):
     except Exception as e:
         logger.error(f"❌ Критическая ошибка в timeup_handler: {e}")
         await message.answer(f"❌ Ошибка тестирования: {str(e)}")
-
+        
+@router.message(F.voice | F.audio)
+async def voice_handler(message: Message, state: FSMContext):
+    """Обработчик голосовых и аудио сообщений"""
+    openai_client = get_global_var('openai_client')
+    bot = get_global_var('bot')
+    admin_manager = get_global_var('admin_manager')
+    
+    import os
+    from pathlib import Path
+    from datetime import datetime
+    
+    processing_msg = None
+    
+    try:
+        # Проверяем что это не админ в режиме администратора
+        if admin_manager.is_admin(message.from_user.id):
+            if admin_manager.is_in_admin_mode(message.from_user.id):
+                return  # Админы работают с текстом
+        
+        logger.info(f"🎤 Получено голосовое сообщение от {message.from_user.id}")
+        
+        # Получаем файл
+        if message.voice:
+            file_id = message.voice.file_id
+            duration = message.voice.duration
+        else:
+            file_id = message.audio.file_id
+            duration = message.audio.duration
+        
+        # Показываем что обрабатываем
+        processing_msg = await message.answer("🎤 Распознаю голос...")
+        
+        try:
+            # Скачиваем файл
+            file = await bot.get_file(file_id)
+            
+            # Путь для сохранения
+            temp_dir = Path("temp_audio")
+            temp_dir.mkdir(exist_ok=True)
+            
+            file_path = temp_dir / f"{message.from_user.id}_{int(datetime.now().timestamp())}.ogg"
+            
+            # Скачиваем
+            await bot.download_file(file.file_path, file_path)
+            logger.info(f"📥 Файл скачан: {file_path} ({duration} сек)")
+            
+            # Распознаем через Whisper
+            recognized_text = await openai_client.transcribe_audio(str(file_path))
+            
+            # Удаляем временный файл
+            try:
+                os.remove(file_path)
+                logger.info(f"🗑️ Временный файл удален: {file_path}")
+            except Exception as e:
+                logger.warning(f"⚠️ Не удалось удалить временный файл: {e}")
+            
+            if not recognized_text:
+                await processing_msg.edit_text("❌ Не удалось распознать голос. Попробуйте еще раз.")
+                return
+            
+            logger.info(f"✅ Текст распознан успешно: '{recognized_text[:100]}...'")
+            
+            # Получаем данные сессии
+            current_state = await state.get_state()
+            data = await state.get_data()
+            
+            logger.info(f"🔍 Текущее состояние: {current_state}")
+            logger.info(f"🔍 Данные в state: {data}")
+            
+            session_id = data.get('session_id')
+            system_prompt = data.get('system_prompt')
+            
+            logger.info(f"📝 session_id из state: {session_id}")
+            
+            # Если session_id нет в state, пытаемся получить из БД
+            if not session_id:
+                logger.warning(f"⚠️ session_id не найден в state, ищем активную сессию в БД...")
+                supabase_client = get_global_var('supabase_client')
+                
+                session_info = await supabase_client.get_active_session(message.from_user.id)
+                if session_info:
+                    session_id = session_info['id']
+                    system_prompt = session_info['system_prompt']
+                    
+                    # Сохраняем в state для следующих сообщений
+                    await state.update_data(session_id=session_id, system_prompt=system_prompt)
+                    await state.set_state(UserStates.waiting_for_message)
+                    
+                    logger.info(f"✅ Сессия восстановлена из БД: {session_id}")
+                else:
+                    logger.error(f"❌ Активная сессия не найдена в БД")
+            
+            if session_id:
+                # Сохраняем распознанный текст в state
+                await state.update_data(voice_recognized_text=recognized_text)
+                await state.set_state(UserStates.voice_confirmation)
+                
+                # Показываем распознанный текст с кнопками выбора
+                from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
+                
+                keyboard = InlineKeyboardMarkup(inline_keyboard=[
+                    [InlineKeyboardButton(text="✅ Отправить", callback_data="voice_send")],
+                    [InlineKeyboardButton(text="✏️ Изменить текст", callback_data="voice_edit")],
+                    [InlineKeyboardButton(text="🎤 Надиктовать заново", callback_data="voice_retry")]
+                ])
+                
+                # Удаляем сообщение "Обрабатываю"
+                try:
+                    await processing_msg.delete()
+                except:
+                    pass
+                
+                # Показываем результат с кнопками
+                await message.answer(
+                    f"✅ Распознано:\n\n<i>{recognized_text}</i>\n\n"
+                    f"Выберите действие:",
+                    reply_markup=keyboard,
+                    parse_mode='HTML'
+                )
+                
+                logger.info(f"✅ Показаны кнопки подтверждения голосового сообщения")
+            else:
+                logger.warning(f"❌ Нет session_id в состоянии")
+                await processing_msg.edit_text(
+                    f"✅ Распознано:\n\n{recognized_text}\n\n"
+                    f"Сессия не найдена. Напишите /start"
+                )
+                
+        except Exception as e:
+            logger.error(f"❌ Ошибка в процессе обработки голоса: {e}")
+            logger.exception("Полный стек ошибки:")
+            if processing_msg:
+                await processing_msg.edit_text("❌ Ошибка обработки. Попробуйте написать текстом.")
+            else:
+                await message.answer("❌ Ошибка обработки. Попробуйте написать текстом.")
+        
+    except Exception as e:
+        logger.error(f"❌ КРИТИЧЕСКАЯ ошибка обработки голоса: {e}")
+        logger.exception("Полный стек критической ошибки:")
+        try:
+            if processing_msg:
+                await processing_msg.edit_text("❌ Ошибка распознавания. Попробуйте написать текстом.")
+            else:
+                await message.answer("❌ Ошибка распознавания. Попробуйте написать текстом.")
+        except:
+            pass
 
 async def user_start_handler(message: Message, state: FSMContext):
     """Обработчик /start для обычных пользователей"""
@@ -465,6 +611,112 @@ async def user_message_handler(message: Message, state: FSMContext):
     except Exception as e:
         logger.error(f"❌ Ошибка при обработке сообщения пользователя: {e}")
         await send_message(message, "Произошла ошибка. Попробуйте еще раз или напишите /start для перезапуска.")
+        
+@router.callback_query(F.data == "voice_send")
+async def voice_send_handler(callback: CallbackQuery, state: FSMContext):
+    """Обработчик кнопки 'Отправить' для голосового сообщения"""
+    try:
+        data = await state.get_data()
+        recognized_text = data.get('voice_recognized_text')
+        session_id = data.get('session_id')
+        system_prompt = data.get('system_prompt')
+        
+        if not recognized_text or not session_id:
+            await callback.answer("❌ Ошибка: текст не найден", show_alert=True)
+            return
+        
+        # Удаляем сообщение с кнопками
+        await callback.message.delete()
+        
+        # Обрабатываем текст сразу без промежуточного сообщения
+        await process_voice_message(callback.message, state, session_id, system_prompt, recognized_text)
+        
+        # Возвращаем в обычное состояние
+        await state.set_state(UserStates.waiting_for_message)
+        await state.update_data(voice_recognized_text=None)
+        
+        await callback.answer()
+        
+    except Exception as e:
+        logger.error(f"❌ Ошибка отправки голосового: {e}")
+        await callback.answer("❌ Ошибка обработки", show_alert=True)
+
+@router.callback_query(F.data == "voice_edit")
+async def voice_edit_handler(callback: CallbackQuery, state: FSMContext):
+    """Обработчик кнопки 'Изменить текст' для голосового сообщения"""
+    try:
+        data = await state.get_data()
+        recognized_text = data.get('voice_recognized_text')
+        
+        if not recognized_text:
+            await callback.answer("❌ Ошибка: текст не найден", show_alert=True)
+            return
+        
+        # Переводим в режим редактирования
+        await state.set_state(UserStates.voice_editing)
+        
+        # Показываем текст для редактирования (обычный формат)
+        await callback.message.edit_text(
+            f"✏️ Отредактируйте распознанный текст:\n\n"
+            f"{recognized_text}\n\n"
+            f"Напишите исправленный текст:"
+        )
+        
+        await callback.answer()
+        
+    except Exception as e:
+        logger.error(f"❌ Ошибка редактирования: {e}")
+        await callback.answer("❌ Ошибка", show_alert=True)
+
+@router.callback_query(F.data == "voice_retry")
+async def voice_retry_handler(callback: CallbackQuery, state: FSMContext):
+    """Обработчик кнопки 'Надиктовать заново' для голосового сообщения"""
+    try:
+        # Удаляем сообщение с кнопками
+        await callback.message.delete()
+        
+        # Возвращаем в обычное состояние
+        await state.set_state(UserStates.waiting_for_message)
+        await state.update_data(voice_recognized_text=None)
+        
+        # Просим отправить заново
+        await callback.message.answer("🎤 Отправьте голосовое сообщение заново")
+        
+        await callback.answer()
+        
+    except Exception as e:
+        logger.error(f"❌ Ошибка повтора: {e}")
+        await callback.answer("❌ Ошибка", show_alert=True)
+
+@router.message(StateFilter(UserStates.voice_editing))
+async def voice_edit_text_handler(message: Message, state: FSMContext):
+    """Обработчик получения отредактированного текста"""
+    try:
+        edited_text = message.text.strip()
+        
+        if not edited_text:
+            await message.answer("⚠️ Текст не может быть пустым. Напишите текст:")
+            return
+        
+        # Получаем данные сессии
+        data = await state.get_data()
+        session_id = data.get('session_id')
+        system_prompt = data.get('system_prompt')
+        
+        if not session_id:
+            await message.answer("❌ Сессия не найдена. Напишите /start")
+            return
+        
+        # Обрабатываем отредактированный текст сразу
+        await process_voice_message(message, state, session_id, system_prompt, edited_text)
+        
+        # Возвращаем в обычное состояние
+        await state.set_state(UserStates.waiting_for_message)
+        await state.update_data(voice_recognized_text=None)
+        
+    except Exception as e:
+        logger.error(f"❌ Ошибка обработки отредактированного текста: {e}")
+        await message.answer("❌ Ошибка обработки. Попробуйте еще раз или напишите /start")
 
 @router.message()
 async def catch_all_handler(message: Message, state: FSMContext):
@@ -778,4 +1030,135 @@ async def process_user_message(message: Message, state: FSMContext, session_id:
         try:
             await message.answer("Произошла критическая ошибка. Попробуйте написать /start для перезапуска.")
         except:
-            logger.error(f"❌ Не удалось отправить сообщение об критической ошибке")
+            logger.error(f"❌ Не удалось отправить сообщение об критической ошибке")
+            
+async def process_voice_message(message: Message, state: FSMContext, session_id: str, system_prompt: str, recognized_text: str):
+    """Обработка распознанного голосового сообщения"""
+    supabase_client = get_global_var('supabase_client')
+    openai_client = get_global_var('openai_client')
+    config = get_global_var('config')
+    bot = get_global_var('bot')
+    prompt_loader = get_global_var('prompt_loader')
+    
+    from datetime import datetime
+    import pytz
+    
+    try:
+        # Сохраняем распознанное сообщение как текст пользователя
+        await supabase_client.add_message(
+            session_id=session_id,
+            role='user',
+            content=recognized_text,
+            message_type='text',  # БД разрешает только 'text'
+            metadata={'original_type': 'voice', 'duration': message.voice.duration if message.voice else 0}
+        )
+        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(message.chat.id, "typing")
+        
+        import time
+        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
+            tokens_used = 0
+            ai_metadata = {}
+        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():
+                logger.warning("⚠️ JSON найден, но текст пустой! Используем исходный ответ.")
+                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)
+                
+                # Обрабатываем события
+                events = ai_metadata.get('события', [])
+                if events:
+                    await process_events(session_id, events, message.from_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
+        )
+
+        # Определяем финальный ответ
+        final_response = ai_response if config.DEBUG_MODE else response_text
+        
+        if not final_response or not final_response.strip():
+            final_response = "Извините, произошла ошибка при формировании ответа. Попробуйте еще раз."
+
+        # Обрабатываем файлы
+        files_list = ai_metadata.get('файлы', [])
+        directories_list = ai_metadata.get('каталоги', [])
+        
+        # Отправляем ответ пользователю
+        await send_message(message, final_response, files_list=files_list, directories_list=directories_list)
+        logger.info(f"✅ Ответ отправлен пользователю {message.from_user.id}")
+                
+    except Exception as e:
+        logger.error(f"❌ КРИТИЧЕСКАЯ ОШИБКА в process_voice_message: {e}")
+        logger.exception("Полный стек ошибки:")
+        try:
+            await message.answer("Произошла критическая ошибка. Попробуйте написать /start")
+        except:
+            pass

smart_bot_factory/integrations/openai_client.py

@@ -432,4 +432,32 @@ class OpenAIClient:
             return [model.id for model in models.data if 'gpt' in model.id.lower()]
         except Exception as e:
             logger.error(f"Ошибка при получении списка моделей: {e}")
-            return []
+            return []
+        
+    async def transcribe_audio(self, audio_file_path: str) -> str:
+        """
+        Распознает голосовое сообщение через Whisper API
+        
+        Args:
+            audio_file_path: Путь к аудио файлу
+            
+        Returns:
+            Распознанный текст
+        """
+        try:
+            logger.info(f"🎤 Отправка аудио на распознавание: {audio_file_path}")
+            
+            with open(audio_file_path, 'rb') as audio_file:
+                transcript = await self.client.audio.transcriptions.create(
+                    model="whisper-1",
+                    file=audio_file,
+                    language="ru"  # Русский язык
+                )
+            
+            text = transcript.text
+            logger.info(f"✅ Распознано {len(text)} символов: '{text[:100]}...'")
+            return text
+            
+        except Exception as e:
+            logger.error(f"❌ Ошибка распознавания аудио: {e}")
+            return ""

smart_bot_factory/router/__init__.py

@@ -3,9 +3,8 @@ Router модули smart_bot_factory
 """
 
 from ..core.router import EventRouter
-from ..core.telegram_router import TelegramRouter
 
 __all__ = [
-    'EventRouter',  # Роутер для событий
-    'TelegramRouter',  # Роутер для Telegram
+    'EventRouter',  # Роутер для событий (бизнес-логика)
+    # Для Telegram используйте aiogram.Router напрямую
 ]