smart-bot-factory 0.3.8__tar.gz → 0.3.10__tar.gz

{smart_bot_factory-0.3.8 → smart_bot_factory-0.3.10}/.gitignore

@@ -1,5 +1,9 @@
+bots/*
+
+valera.py
+publish.py
 # Byte-compiled / optimized / DLL files
-__pycache__/
+__pycache__/s
 *.py[codz]
 *$py.class
 

{smart_bot_factory-0.3.8 → smart_bot_factory-0.3.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: smart-bot-factory
-Version: 0.3.8
+Version: 0.3.10
 Summary: Библиотека для создания умных чат-ботов
 Author-email: Kopatych <eserov73@gmail.com>
 License: MIT

{smart_bot_factory-0.3.8 → smart_bot_factory-0.3.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "smart-bot-factory"
-version = "0.3.8"
+version = "0.3.10"
 description = "Библиотека для создания умных чат-ботов"
 authors = [
     {name = "Kopatych", email = "eserov73@gmail.com"}

{smart_bot_factory-0.3.8 → smart_bot_factory-0.3.10}/smart_bot_factory/admin/admin_manager.py

@@ -122,8 +122,8 @@ class AdminManager:
 
     async def notify_admins(self, message: str, exclude_admin: int = None):
         """Отправляет уведомление всем активным админам"""
-        from main import \
-            bot  # Импорт здесь чтобы избежать циклических импортов
+        from ..handlers.handlers import get_global_var
+        bot = get_global_var("bot")
 
         active_admins = await self.get_active_admins()
 

{smart_bot_factory-0.3.8 → smart_bot_factory-0.3.10}/smart_bot_factory/core/bot_utils.py

@@ -245,25 +245,33 @@ async def process_events(session_id: str, events: list, user_id: int) -> bool:
                         f"🔍 Старые scheduled_tasks: {list(scheduled_tasks.keys())}"
                     )
 
-                # Сначала пробуем как обычное событие
+                # Сначала пробуем как обычное событие или scheduled task
+                handler_info = None
+                handler_type = None
+                
                 if event_type in event_handlers:
+                    handler_info = event_handlers.get(event_type, {})
+                    handler_type = "event"
+                elif event_type in scheduled_tasks:
+                    handler_info = scheduled_tasks.get(event_type, {})
+                    handler_type = "task"
+                
+                if handler_info:
                     from ..core.decorators import execute_event_handler
 
-                    event_handler_info = event_handlers.get(event_type, {})
-                    once_only = event_handler_info.get("once_only", True)
-                    send_ai_response_flag = event_handler_info.get(
-                        "send_ai_response", True
-                    )
+                    once_only = handler_info.get("once_only", True)
+                    send_ai_response_flag = handler_info.get("send_ai_response", True)
+                    should_notify = handler_info.get("notify", False)  # Получаем notify из handler_info
 
                     logger.info(
-                        f"   🔍 Обработчик '{event_type}': once_only={once_only}, send_ai_response={send_ai_response_flag}"
+                        f"   🔍 {handler_type.title()} '{event_type}': once_only={once_only}, send_ai_response={send_ai_response_flag}, notify={should_notify}"
                     )
 
                     # Проверяем флаг send_ai_response ИЗ ДЕКОРАТОРА
                     if not send_ai_response_flag:
                         should_send_ai_response = False
                         logger.warning(
-                            f"   🔇🔇🔇 ОБРАБОТЧИК '{event_type}' ЗАПРЕТИЛ ОТПРАВКУ СООБЩЕНИЯ ОТ ИИ (send_ai_response=False) 🔇🔇🔇"
+                            f"   🔇🔇🔇 {handler_type.upper()} '{event_type}' ЗАПРЕТИЛ ОТПРАВКУ СООБЩЕНИЯ ОТ ИИ (send_ai_response=False) 🔇🔇🔇"
                         )
 
                     # Если once_only=True - проверяем в БД наличие выполненных событий
@@ -301,14 +309,21 @@ async def process_events(session_id: str, events: list, user_id: int) -> bool:
 
                     # Немедленно выполняем событие
                     logger.info(
-                        f"   🎯 Немедленно выполняем user_event: '{event_type}'"
+                        f"   🎯 Немедленно выполняем {handler_type}: '{event_type}'"
                     )
 
                     try:
-                        # Выполняем событие
-                        result = await execute_event_handler(
-                            event_type, user_id, event_info
-                        )
+                        # Выполняем обработчик в зависимости от типа
+                        if handler_type == "event":
+                            result = await execute_event_handler(
+                                event_type, user_id, event_info
+                            )
+                        elif handler_type == "task":
+                            result = await execute_scheduled_task_from_event(
+                                user_id, event_type, event_info, session_id
+                            )
+                        else:
+                            raise ValueError(f"Неизвестный тип обработчика: {handler_type}")
 
                         # Проверяем наличие поля 'info' для дашборда
                         import json
@@ -353,14 +368,14 @@ async def process_events(session_id: str, events: list, user_id: int) -> bool:
                         )
                         event_id = response.data[0]["id"]
 
-                        should_notify = event_handler_info.get("notify", False)
-
+                        # should_notify уже получен из handler_info выше
                         logger.info(
                             f"   ✅ Событие {event_id} выполнено и сохранено как completed"
                         )
 
                     except Exception as e:
                         logger.error(f"   ❌ Ошибка выполнения события: {e}")
+                        
                         # Сохраняем ошибку в БД
                         event_record = {
                             "event_type": event_type,
@@ -377,10 +392,15 @@ async def process_events(session_id: str, events: list, user_id: int) -> bool:
                         if supabase_client.bot_id:
                             event_record["bot_id"] = supabase_client.bot_id
 
-                        supabase_client.client.table("scheduled_events").insert(
-                            event_record
-                        ).execute()
-                        raise
+                        try:
+                            supabase_client.client.table("scheduled_events").insert(
+                                event_record
+                            ).execute()
+                            logger.info(f"   💾 Ошибка сохранена в БД")
+                        except Exception as db_error:
+                            logger.error(f"   ❌ Не удалось сохранить ошибку в БД: {db_error}")
+                        
+                        continue  # Переходим к следующему событию после сохранения ошибки
 
                 # Если не user_event, пробуем как запланированную задачу
                 elif event_type in scheduled_tasks:
@@ -469,12 +489,22 @@ async def process_events(session_id: str, events: list, user_id: int) -> bool:
                 logger.error(f"   ❌ Ошибка в обработчике/задаче: {e}")
                 logger.exception("   Стек ошибки:")
 
-            # Уведомляем админов только если result.notify = True
-            if should_notify:
-                await notify_admins_about_event(user_id, event)
-                logger.info("   ✅ Админы уведомлены")
+            # Проверяем notify_time для scheduled_task
+            if handler_type == "task":
+                notify_time = handler_info.get("notify_time", "after")
+                # Для 'before' уведомляем сразу при создании
+                if notify_time == "before" and should_notify:
+                    await notify_admins_about_event(user_id, event)
+                    logger.info("   ✅ Админы уведомлены (notify_time=before)")
+                elif notify_time == "after":
+                    logger.info("   ⏳ Уведомление будет отправлено после выполнения задачи (notify_time=after)")
             else:
-                logger.info(f"   🔕 Уведомления админам отключены для '{event_type}'")
+                # Для обычных событий уведомляем сразу
+                if should_notify:
+                    await notify_admins_about_event(user_id, event)
+                    logger.info("   ✅ Админы уведомлены")
+                else:
+                    logger.info(f"   🔕 Уведомления админам отключены для '{event_type}'")
 
         except Exception as e:
             logger.error(f"❌ Ошибка обработки события {event}: {e}")

{smart_bot_factory-0.3.8 → smart_bot_factory-0.3.10}/smart_bot_factory/core/conversation_manager.py

@@ -72,15 +72,20 @@ class ConversationManager:
 
         try:
             # Получаем последние 5 сообщений (сортируем по убыванию и берем первые 5)
-            response = (
+            query = (
                 self.supabase.client.table("sales_messages")
                 .select("role", "content", "created_at")
                 .eq("session_id", session_id)
                 .order("created_at", desc=True)
                 .limit(5)
-                .execute()
             )
 
+            # Добавляем фильтр по bot_id если он указан
+            if self.supabase.bot_id:
+                query = query.eq("bot_id", self.supabase.bot_id)
+
+            response = query.execute()
+
             recent_messages = response.data if response.data else []
 
             if not recent_messages:
@@ -122,12 +127,17 @@ class ConversationManager:
     async def get_user_display_name(self, user_id: int) -> str:
         """Получает красивое отображение пользователя с username"""
         try:
-            response = (
+            query = (
                 self.supabase.client.table("sales_users")
                 .select("first_name", "last_name", "username")
                 .eq("telegram_id", user_id)
-                .execute()
             )
+            
+            # Добавляем фильтр по bot_id если он указан
+            if self.supabase.bot_id:
+                query = query.eq("bot_id", self.supabase.bot_id)
+            
+            response = query.execute()
 
             if response.data:
                 user_info = response.data[0]
@@ -316,8 +326,7 @@ class ConversationManager:
 
         try:
             # Отправляем сообщение как от бота
-            parse_mode = self.parse_mode if self.parse_mode != "None" else None
-            await send_message_by_human(user_id, message.text, parse_mode=parse_mode)
+            await send_message_by_human(user_id, message.text)
 
             # Сохраняем в БД как сообщение ассистента
             session_info = await supabase_client.get_active_session(user_id)
@@ -406,27 +415,36 @@ class ConversationManager:
             logger.info("🔍 Ищем активные диалоги админов...")
 
             # Получаем все активные диалоги
-            response = (
+            query = (
                 self.supabase.client.table("admin_user_conversations")
                 .select("id", "admin_id", "user_id", "started_at", "auto_end_at")
                 .eq("status", "active")
-                .order("started_at", desc=True)
-                .execute()
             )
 
+            # Добавляем фильтр по bot_id если он указан
+            if self.supabase.bot_id:
+                query = query.eq("bot_id", self.supabase.bot_id)
+
+            response = query.order("started_at", desc=True).execute()
+
             logger.info(f"📊 Найдено {len(response.data)} активных диалогов в БД")
 
             conversations = []
             for conv in response.data:
                 # Получаем информацию о пользователе
                 try:
-                    user_response = (
+                    user_query = (
                         self.supabase.client.table("sales_users")
                         .select("first_name", "last_name", "username")
                         .eq("telegram_id", conv["user_id"])
-                        .execute()
                     )
 
+                    # Добавляем фильтр по bot_id если он указан
+                    if self.supabase.bot_id:
+                        user_query = user_query.eq("bot_id", self.supabase.bot_id)
+
+                    user_response = user_query.execute()
+
                     user_info = user_response.data[0] if user_response.data else {}
                 except Exception as e:
                     logger.error(
@@ -436,13 +454,18 @@ class ConversationManager:
 
                 # Получаем информацию об админе
                 try:
-                    admin_response = (
+                    admin_query = (
                         self.supabase.client.table("sales_admins")
                         .select("first_name", "last_name", "username")
                         .eq("telegram_id", conv["admin_id"])
-                        .execute()
                     )
 
+                    # Добавляем фильтр по bot_id если он указан
+                    if self.supabase.bot_id:
+                        admin_query = admin_query.eq("bot_id", self.supabase.bot_id)
+
+                    admin_response = admin_query.execute()
+
                     admin_info = admin_response.data[0] if admin_response.data else {}
                 except Exception as e:
                     logger.error(

{smart_bot_factory-0.3.8 → smart_bot_factory-0.3.10}/smart_bot_factory/core/decorators.py

@@ -476,6 +476,7 @@ def event_handler(
 def schedule_task(
     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,
@@ -1310,6 +1311,11 @@ async def save_immediate_event(
                 f"Событие '{event_type}' уже обрабатывалось (once_only=True)"
             )
 
+    # Получаем bot_id
+    bot_id = supabase_client.bot_id
+    if not bot_id:
+        logger.warning("⚠️ bot_id не указан при создании immediate_event")
+        
     event_record = {
         "event_type": event_type,
         "event_category": "user_event",
@@ -1318,12 +1324,9 @@ async def save_immediate_event(
         "scheduled_at": None,  # Немедленное выполнение
         "status": "immediate",
         "session_id": session_id,
+        "bot_id": bot_id,  # Всегда добавляем bot_id
     }
 
-    # 🆕 Добавляем bot_id если указан
-    if supabase_client.bot_id:
-        event_record["bot_id"] = supabase_client.bot_id
-
     try:
         response = (
             supabase_client.client.table("scheduled_events")
@@ -1375,6 +1378,11 @@ async def save_scheduled_task(
 
     scheduled_at = datetime.now(timezone.utc) + timedelta(seconds=delay_seconds)
 
+    # Получаем bot_id
+    bot_id = supabase_client.bot_id
+    if not bot_id:
+        logger.warning("⚠️ bot_id не указан при создании scheduled_task")
+        
     event_record = {
         "event_type": task_name,
         "event_category": "scheduled_task",
@@ -1383,12 +1391,9 @@ async def save_scheduled_task(
         "scheduled_at": scheduled_at.isoformat(),
         "status": "pending",
         "session_id": session_id,
+        "bot_id": bot_id,  # Всегда добавляем bot_id
     }
 
-    # 🆕 Добавляем bot_id если указан
-    if supabase_client.bot_id:
-        event_record["bot_id"] = supabase_client.bot_id
-
     try:
         response = (
             supabase_client.client.table("scheduled_events")
@@ -1445,6 +1450,11 @@ async def save_global_event(
         scheduled_at = datetime.now(timezone.utc) + timedelta(seconds=delay_seconds)
         status = "pending"
 
+    # Получаем bot_id
+    bot_id = supabase_client.bot_id
+    if not bot_id:
+        logger.warning("⚠️ bot_id не указан при создании global_event")
+        
     event_record = {
         "event_type": handler_type,
         "event_category": "global_handler",
@@ -1452,12 +1462,9 @@ async def save_global_event(
         "event_data": handler_data,
         "scheduled_at": scheduled_at.isoformat() if scheduled_at else None,
         "status": status,
+        "bot_id": bot_id,  # Всегда добавляем bot_id (глобальные события тоже привязаны к боту)
     }
 
-    # 🆕 Добавляем bot_id если указан (глобальные события тоже привязаны к боту)
-    if supabase_client.bot_id:
-        event_record["bot_id"] = supabase_client.bot_id
-
     try:
         response = (
             supabase_client.client.table("scheduled_events")
@@ -1503,22 +1510,32 @@ async def update_event_result(
         update_data["last_error"] = error_message
         # Получаем текущее количество попыток
         try:
-            current_retry = (
+            query = (
                 supabase_client.client.table("scheduled_events")
                 .select("retry_count")
                 .eq("id", event_id)
-                .execute()
-                .data[0]["retry_count"]
             )
+            
+            # Добавляем фильтр по bot_id если указан
+            if supabase_client.bot_id:
+                query = query.eq("bot_id", supabase_client.bot_id)
+                
+            current_retry = query.execute().data[0]["retry_count"]
             update_data["retry_count"] = current_retry + 1
         except Exception:
             logger.debug("Не удалось получить текущее количество попыток, устанавливаем 1")
             update_data["retry_count"] = 1
 
     try:
-        supabase_client.client.table("scheduled_events").update(update_data).eq(
+        query = supabase_client.client.table("scheduled_events").update(update_data).eq(
             "id", event_id
-        ).execute()
+        )
+        
+        # Добавляем фильтр по bot_id если указан
+        if supabase_client.bot_id:
+            query = query.eq("bot_id", supabase_client.bot_id)
+            
+        query.execute()
         logger.info(f"📝 Результат события {event_id} обновлен: {status}")
     except Exception as e:
         logger.error(f"❌ Ошибка обновления результата события {event_id}: {e}")
@@ -1613,7 +1630,14 @@ async def background_event_processor():
 
                         # ========== ОБРАБОТКА АДМИНСКИХ СОБЫТИЙ ==========
                         if event_category == "admin_event":
+                            # Проверяем bot_id
+                            if not event.get("bot_id"):
+                                logger.warning(f"⚠️ Админское событие {event['id']} не имеет bot_id")
+                            
                             try:
+                                logger.info(f"🔄 Начало обработки админского события {event['id']}")
+                                logger.info(f"📝 Данные события: {event}")
+                                
                                 # Обрабатываем и получаем результат
                                 result = await process_admin_event(event)
 
@@ -1621,22 +1645,37 @@ async def background_event_processor():
                                 import json
 
                                 supabase_client = get_supabase_client()
-                                supabase_client.client.table("scheduled_events").update(
-                                    {
-                                        "status": "completed",
-                                        "executed_at": datetime.now(
-                                            timezone.utc
-                                        ).isoformat(),
-                                        "result_data": (
-                                            json.dumps(result, ensure_ascii=False)
-                                            if result
-                                            else None
-                                        ),
-                                    }
-                                ).eq("id", event["id"]).execute()
+                                if not supabase_client:
+                                    raise RuntimeError("Не найден supabase_client")
+
+                                # Готовим данные для обновления
+                                update_data = {
+                                    "status": "completed",
+                                    "executed_at": datetime.now(timezone.utc).isoformat(),
+                                    "result_data": json.dumps(result, ensure_ascii=False) if result else None,
+                                }
+                                
+                                # Если у события нет bot_id, но он есть в клиенте - добавляем
+                                if not event.get("bot_id") and supabase_client.bot_id:
+                                    update_data["bot_id"] = supabase_client.bot_id
+                                    logger.info(f"📝 Добавлен bot_id: {supabase_client.bot_id}")
+
+                                # Строим запрос
+                                query = (
+                                    supabase_client.client.table("scheduled_events")
+                                    .update(update_data)
+                                    .eq("id", event["id"])
+                                )
+
+                                # Добавляем фильтр по bot_id если он был в событии
+                                if event.get("bot_id"):
+                                    query = query.eq("bot_id", event["bot_id"])
+
+                                # Выполняем обновление
+                                query.execute()
 
                                 logger.info(
-                                    f"✅ Админское событие {event['id']} выполнено"
+                                    f"✅ Админское событие {event['id']} выполнено и обновлено в БД"
                                 )
                                 continue
 
@@ -1644,18 +1683,45 @@ async def background_event_processor():
                                 logger.error(
                                     f"❌ Ошибка обработки админского события {event['id']}: {e}"
                                 )
+                                logger.exception("Стек ошибки:")
 
-                                # Обновляем статус на failed
-                                supabase_client = get_supabase_client()
-                                supabase_client.client.table("scheduled_events").update(
-                                    {
+                                try:
+                                    # Обновляем статус на failed
+                                    supabase_client = get_supabase_client()
+                                    if not supabase_client:
+                                        raise RuntimeError("Не найден supabase_client")
+
+                                    # Готовим данные для обновления
+                                    update_data = {
                                         "status": "failed",
                                         "last_error": str(e),
-                                        "executed_at": datetime.now(
-                                            timezone.utc
-                                        ).isoformat(),
+                                        "executed_at": datetime.now(timezone.utc).isoformat(),
                                     }
-                                ).eq("id", event["id"]).execute()
+                                    
+                                    # Если у события нет bot_id, но он есть в клиенте - добавляем
+                                    if not event.get("bot_id") and supabase_client.bot_id:
+                                        update_data["bot_id"] = supabase_client.bot_id
+                                        logger.info(f"📝 Добавлен bot_id: {supabase_client.bot_id}")
+
+                                    # Строим запрос
+                                    query = (
+                                        supabase_client.client.table("scheduled_events")
+                                        .update(update_data)
+                                        .eq("id", event["id"])
+                                    )
+
+                                    # Добавляем фильтр по bot_id если он был в событии
+                                    if event.get("bot_id"):
+                                        query = query.eq("bot_id", event["bot_id"])
+
+                                    # Выполняем обновление
+                                    query.execute()
+                                    logger.info(f"✅ Статус события {event['id']} обновлен на failed")
+                                    
+                                except Exception as update_error:
+                                    logger.error(f"❌ Ошибка обновления статуса события: {update_error}")
+                                    logger.exception("Стек ошибки обновления:")
+                                
                                 continue
 
                         # ========== ОБРАБОТКА USER СОБЫТИЙ ==========
@@ -1820,7 +1886,27 @@ async def process_scheduled_event(event: Dict):
 
     result = None
     if event_category == "scheduled_task":
+        # Получаем информацию о задаче
+        router_manager = get_router_manager()
+        if router_manager:
+            scheduled_tasks = router_manager.get_scheduled_tasks()
+        else:
+            scheduled_tasks = _scheduled_tasks
+
+        task_info = scheduled_tasks.get(event_type, {})
+        notify = task_info.get("notify", False)
+        notify_time = task_info.get("notify_time", "after")
+
+        # Выполняем задачу
         result = await execute_scheduled_task(event_type, user_id, event_data)
+
+        # Отправляем уведомление после выполнения если notify=True и notify_time="after"
+        if notify and notify_time == "after":
+            from ..core.bot_utils import notify_admins_about_event
+            event_for_notify = {"тип": event_type, "инфо": event_data}
+            await notify_admins_about_event(user_id, event_for_notify)
+            logger.info(f"   ✅ Админы уведомлены после выполнения задачи '{event_type}'")
+
     elif event_category == "global_handler":
         result = await execute_global_handler(event_type, event_data)
     elif event_category == "user_event":

{smart_bot_factory-0.3.8 → smart_bot_factory-0.3.10}/smart_bot_factory/core/message_sender.py

@@ -7,6 +7,7 @@ import time
 from datetime import datetime
 from typing import Any, Dict, Optional
 
+from aiogram.types import InlineKeyboardMarkup
 import pytz
 
 logger = logging.getLogger(__name__)
@@ -193,7 +194,7 @@ async def send_message_by_ai(
 
 
 async def send_message_by_human(
-    user_id: int, message_text: str, session_id: Optional[str] = None
+    user_id: int, message_text: str, session_id: Optional[str] = None, parse_mode: str = "Markdown", reply_markup: Optional[InlineKeyboardMarkup] = None
 ) -> Dict[str, Any]:
     """
     Отправляет сообщение пользователю от имени человека (готовый текст)
@@ -214,7 +215,7 @@ async def send_message_by_human(
         supabase_client = get_global_var("supabase_client")
 
         # Отправляем сообщение пользователю
-        message = await bot.send_message(chat_id=user_id, text=message_text)
+        message = await bot.send_message(chat_id=user_id, text=message_text, parse_mode=parse_mode, reply_markup=reply_markup)
 
         # Если указана сессия, сохраняем сообщение в БД
         if session_id:

{smart_bot_factory-0.3.8 → smart_bot_factory-0.3.10}/smart_bot_factory/core/router.py

@@ -93,6 +93,7 @@ class EventRouter:
         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,
@@ -105,6 +106,9 @@ class EventRouter:
         Args:
             task_name: Название задачи
             notify: Уведомлять ли админов
+            notify_time: Когда отправлять уведомление админам:
+                - 'before': при создании задачи
+                - 'after': после успешного выполнения (по умолчанию)
             smart_check: Использовать ли умную проверку
             once_only: Выполнять ли только один раз
             delay: Время задержки в удобном формате (например, "1h 30m", "45m", 3600) - ОБЯЗАТЕЛЬНО
@@ -141,10 +145,15 @@ class EventRouter:
                 )
                 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,