smart-bot-factory 0.3.9__tar.gz → 1.0.0__tar.gz

{smart_bot_factory-0.3.9 → smart_bot_factory-1.0.0}/.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.9 → smart_bot_factory-1.0.0}/PKG-INFO

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

{smart_bot_factory-0.3.9 → smart_bot_factory-1.0.0}/pyproject.toml

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

{smart_bot_factory-0.3.9 → smart_bot_factory-1.0.0}/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.9 → smart_bot_factory-1.0.0}/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.9 → smart_bot_factory-1.0.0}/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.9 → smart_bot_factory-1.0.0}/smart_bot_factory/core/decorators.py

@@ -7,7 +7,7 @@ import logging
 import re
 from datetime import datetime, timedelta, timezone
 from functools import wraps
-from typing import Any, Callable, Dict, Union
+from typing import Any, Callable, Dict, Optional, Union
 
 logger = logging.getLogger(__name__)
 
@@ -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,
@@ -1885,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":
@@ -2155,12 +2176,13 @@ async def check_event_already_processed(
         return False
 
 
-async def process_admin_event(event: Dict):
+async def process_admin_event(event: Dict, single_user_id: Optional[int] = None):
     """
     Обрабатывает одно админское событие - скачивает файлы из Storage и отправляет пользователям
 
     Args:
         event: Событие из БД с данными для отправки
+        single_user_id: ID пользователя для тестовой отправки. Если указан, сообщение будет отправлено только ему
     """
     import json
     import shutil
@@ -2244,17 +2266,20 @@ async def process_admin_event(event: Dict):
                 raise
 
         # 2. Получаем пользователей
-        users = await supabase_client.get_users_by_segment(segment)
-
-        if not users:
-            logger.warning(f"⚠️ Нет пользователей для сегмента '{segment}'")
-            return {
-                "success_count": 0,
-                "failed_count": 0,
-                "total_users": 0,
-                "segment": segment or "Все",
-                "warning": "Нет пользователей",
-            }
+        if single_user_id:
+            users = [{"telegram_id": single_user_id}]
+            logger.info(f"🔍 Тестовая отправка для пользователя {single_user_id}")
+        else:
+            users = await supabase_client.get_users_by_segment(segment)
+            if not users:
+                logger.warning(f"⚠️ Нет пользователей для сегмента '{segment}'")
+                return {
+                    "success_count": 0,
+                    "failed_count": 0,
+                    "total_users": 0,
+                    "segment": segment or "Все",
+                    "warning": "Нет пользователей",
+                }
 
         success_count = 0
         failed_count = 0

{smart_bot_factory-0.3.9 → smart_bot_factory-1.0.0}/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.9 → smart_bot_factory-1.0.0}/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,

{smart_bot_factory-0.3.9 → smart_bot_factory-1.0.0}/smart_bot_factory/event/__init__.py

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

{smart_bot_factory-0.3.9 → smart_bot_factory-1.0.0}/smart_bot_factory/handlers/handlers.py

@@ -79,7 +79,7 @@ async def timeup_handler(message: Message, state: FSMContext):
     """Обработчик команды /timeup (или /вперед) - тестирование запланированных событий"""
     from datetime import datetime
 
-    from ..core.decorators import process_scheduled_event, update_event_result
+    from ..core.decorators import process_scheduled_event, update_event_result, process_admin_event
 
     supabase_client = get_global_var("supabase_client")
 
@@ -95,9 +95,7 @@ async def timeup_handler(message: Message, state: FSMContext):
             .in_("status", ["pending", "immediate"])
         )
 
-        # 🆕 Фильтруем по bot_id если указан
-        if supabase_client.bot_id:
-            user_events_query = user_events_query.eq("bot_id", supabase_client.bot_id)
+        user_events_query = user_events_query.eq("bot_id", supabase_client.bot_id)
 
         user_events = user_events_query.execute()
 
@@ -107,14 +105,9 @@ async def timeup_handler(message: Message, state: FSMContext):
             .select("*")
             .is_("user_id", "null")
             .in_("status", ["pending", "immediate"])
+            .eq("bot_id", supabase_client.bot_id)
         )
 
-        # 🆕 Фильтруем по bot_id если указан
-        if supabase_client.bot_id:
-            global_events_query = global_events_query.eq(
-                "bot_id", supabase_client.bot_id
-            )
-
         global_events = global_events_query.execute()
 
         # Объединяем события
@@ -155,23 +148,30 @@ async def timeup_handler(message: Message, state: FSMContext):
                 )
 
                 # Выполняем событие
-                await process_scheduled_event(event)
-
-                # Помечаем как выполненное
-                await update_event_result(
-                    event_id,
-                    "completed",
-                    {
-                        "executed": True,
-                        "test_mode": True,
-                        "tested_by_user": message.from_user.id,
-                        "tested_at": datetime.now().isoformat(),
-                    },
-                )
-
-                success_count += 1
-                results.append(f"✅ {event_label}")
-                logger.info(f"✅ Событие {event_id} успешно выполнено")
+                if event_category == "admin_event":
+                    # Для админских событий используем тестовую отправку только текущему пользователю
+                    await process_admin_event(event, single_user_id=message.from_user.id)
+                    # Не отмечаем админское событие как выполненное при тестовой отправке
+                    success_count += 1
+                    results.append(f"✅ {event_label} (тестовая отправка)")
+                    logger.info(f"✅ Событие {event_id} протестировано для пользователя {message.from_user.id}")
+                else:
+                    await process_scheduled_event(event)
+                    # Помечаем как выполненное только не-админские события
+                    if event_category != "global_handler":
+                        await update_event_result(
+                            event_id,
+                            "completed",
+                            {
+                                "executed": True,
+                                "test_mode": True,
+                                "tested_by_user": message.from_user.id,
+                                "tested_at": datetime.now().isoformat(),
+                            },
+                        )
+                    success_count += 1
+                    results.append(f"✅ {event_label}")
+                    logger.info(f"✅ Событие {event_id} успешно выполнено")
 
             except Exception as e:
                 failed_count += 1

{smart_bot_factory-0.3.9 → smart_bot_factory-1.0.0}/smart_bot_factory/integrations/supabase_client.py

@@ -570,22 +570,37 @@ class SupabaseClient:
     ) -> int:
         """Начинает диалог между админом и пользователем"""
         try:
+            # Проверяем существование пользователя с правильным bot_id
+            user_query = self.client.table("sales_users").select("telegram_id").eq("telegram_id", user_id)
+            if self.bot_id:
+                user_query = user_query.eq("bot_id", self.bot_id)
+            
+            user_response = user_query.execute()
+            if not user_response.data:
+                logger.error(f"❌ Пользователь {user_id} не найден в sales_users{f' для bot_id {self.bot_id}' if self.bot_id else ''}")
+                raise APIError("User not found in sales_users")
+
             # Завершаем активные диалоги этого админа
             await self.end_admin_conversations(admin_id)
 
+            # Готовим данные для записи
+            conversation_data = {
+                "admin_id": admin_id,
+                "user_id": user_id,
+                "session_id": session_id,
+                "status": "active",
+                "auto_end_at": (
+                    datetime.now(timezone.utc) + timedelta(minutes=30)
+                ).isoformat(),
+            }
+
+            # Добавляем bot_id если он указан
+            if self.bot_id:
+                conversation_data["bot_id"] = self.bot_id
+
             response = (
                 self.client.table("admin_user_conversations")
-                .insert(
-                    {
-                        "admin_id": admin_id,
-                        "user_id": user_id,
-                        "session_id": session_id,
-                        "status": "active",
-                        "auto_end_at": (
-                            datetime.now(timezone.utc) + timedelta(minutes=30)
-                        ).isoformat(),
-                    }
-                )
+                .insert(conversation_data)
                 .execute()
             )
 
@@ -608,7 +623,7 @@ class SupabaseClient:
                 self.client.table("admin_user_conversations")
                 .update(
                     {
-                        "status": "ended",
+                        "status": "completed",  # Используем 'completed' вместо 'ended'
                         "ended_at": datetime.now(timezone.utc).isoformat(),
                     }
                 )
@@ -619,6 +634,9 @@ class SupabaseClient:
                 query = query.eq("admin_id", admin_id)
             if user_id:
                 query = query.eq("user_id", user_id)
+            # Добавляем фильтр по bot_id если он указан
+            if self.bot_id:
+                query = query.eq("bot_id", self.bot_id)
 
             response = query.execute()
             ended_count = len(response.data)
@@ -1193,15 +1211,20 @@ class SupabaseClient:
         """Проверяет, изменился ли этап пользователя с момента планирования события"""
         try:
             # Получаем текущую информацию о сессии
-            current_response = (
+            query = (
                 self.client.table("sales_chat_sessions")
                 .select("id", "current_stage")
-                .eq("user_telegram_id", user_id)
+                .eq("user_id", user_id)
                 .order("created_at", desc=True)
                 .limit(1)
-                .execute()
             )
 
+            # Добавляем фильтр по bot_id если он указан
+            if self.bot_id:
+                query = query.eq("bot_id", self.bot_id)
+
+            current_response = query.execute()
+
             if not current_response.data:
                 return False
 

{smart_bot_factory-0.3.9 → smart_bot_factory-1.0.0}/uv.lock

@@ -1670,7 +1670,7 @@ wheels = [
 
 [[package]]
 name = "smart-bot-factory"
-version = "0.3.8"
+version = "0.3.11.dev2"
 source = { editable = "." }
 dependencies = [
     { name = "aiofiles" },