smart-bot-factory 0.3.9__py3-none-any.whl → 1.0.0__py3-none-any.whl

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/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/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/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/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/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/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/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/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.dist-info → smart_bot_factory-1.0.0.dist-info}/METADATA

@@ -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.dist-info → smart_bot_factory-1.0.0.dist-info}/RECORD

@@ -6,7 +6,7 @@ smart_bot_factory/utm_link_generator.py,sha256=eA3Eic4Wvs0QpMdAFPJgYJyzv-_pSQWZ5
 smart_bot_factory/admin/__init__.py,sha256=xHUtMLeQDDQEXZrg4WAGpt-TWp8adjCC0-mYUBuino4,489
 smart_bot_factory/admin/admin_events.py,sha256=FkiD0FtnlgpxLCoN9KXR61VCn8OsI0JCWm9RjVVa6tk,43903
 smart_bot_factory/admin/admin_logic.py,sha256=TiXhZIXiXK1YQkrueY_zPFYL3_sJzoAvd100AP-ZCWU,23136
-smart_bot_factory/admin/admin_manager.py,sha256=hjk4XI5prdlE6KMm64DjzadujGu1DmXWkeTQLweWF54,6406
+smart_bot_factory/admin/admin_manager.py,sha256=u22j1xy2zLTw0kejgzWF5m657_IyMDKnDlM9kBzbjh4,6359
 smart_bot_factory/admin/admin_tester.py,sha256=YwovS51chPJoQ33pIiug-vS3augQzc1hHfbma48HtDk,6352
 smart_bot_factory/admin/timeout_checker.py,sha256=afWsg39X6M5SaRKMk7ptNod8Z0StIa2o8H5Lx8y1ZE0,24438
 smart_bot_factory/aiogram_calendar/__init__.py,sha256=UCoae3mXXDgYqqSQPotEpUxzAsZ_e62FuW9MWl1sG34,410
@@ -29,21 +29,21 @@ smart_bot_factory/configs/growthmed-october-24/tests/realistic_scenarios.yaml,sh
 smart_bot_factory/configs/growthmed-october-24/tests/scenario_examples.yaml,sha256=bzDulOU4a2LyWlcHzlQU8GYhOky2WTfyizGfjX4ioMY,2436
 smart_bot_factory/configs/growthmed-october-24/welcome_file/welcome_file_msg.txt,sha256=Db21Mm0r8SBWFdX9EeIF2FZtLQ2cvuwVlSRJd2KEYCg,922
 smart_bot_factory/configs/growthmed-october-24/welcome_file/Чек лист по 152ФЗ и 323ФЗ для медицины.pdf,sha256=BiAiQHNnQXJPMsks9AeL6s0beEjRFkRMJLMlAn4WorA,5284954
-smart_bot_factory/core/bot_utils.py,sha256=WlJ3QMIO96-n6-KyjQrGm2PR8Z1U-lvIGtSSXSSaLuE,49874
-smart_bot_factory/core/conversation_manager.py,sha256=zduDEaTr7iQoVvbcMdmqBsyN4x1ZaOpTnUt0JsAgQ7I,28497
-smart_bot_factory/core/decorators.py,sha256=RzYuzuYHLYQsDeW-k1sJW4IXVjOhaVwU5tD7Hxy3peg,107192
-smart_bot_factory/core/message_sender.py,sha256=VjOLZUhw0Lkz_IOh4p9J_L5DkEkaURFRRU-qrIsG2qc,32338
-smart_bot_factory/core/router.py,sha256=GdsSZxeuYICyzXNFeJnS4CnbaXGxojg-c9JK7z2OFiM,15592
+smart_bot_factory/core/bot_utils.py,sha256=vbWb4wUkG-FlQIGTQ6RLoSSVg_LRVTzpnX3tyowsbqY,52032
+smart_bot_factory/core/conversation_manager.py,sha256=ga0ThoDpvov97x5KLcHpL8aRlEZB1XRw3JPrexIb-jk,29506
+smart_bot_factory/core/decorators.py,sha256=9TjB9mTp2fvopSgFOJOsQ326K220QHK87ZPoNa5BV_g,108733
+smart_bot_factory/core/message_sender.py,sha256=gK0HbjLumAu5_Vr29DnOQkwbPGGmQrtkgW1dVt_9Bb8,32518
+smart_bot_factory/core/router.py,sha256=66sCp7Okyu1ceIQPpxFF88-NizTD1N7rR4ZAdwDYmi8,16285
 smart_bot_factory/core/router_manager.py,sha256=x-cc4zhZUVPCTUH980GdlE_-JjHRtYnPdEBiWnf3ka8,10156
 smart_bot_factory/core/states.py,sha256=mFyQ-oxIjTX03Wy5NHZUgYgh8fsJ5YmQU09_PhPAB04,889
 smart_bot_factory/creation/__init__.py,sha256=lHFgYIjOLvdsDAW8eLMp8zfFUCd-6wepvUaUMeJ7feU,128
 smart_bot_factory/creation/bot_builder.py,sha256=-gF53eCaWBRKoUbRGR-PDHpqLWlceQ9FLUdEqQRt6lw,42929
 smart_bot_factory/creation/bot_testing.py,sha256=aMPSgj2o2zl6yWiV1a6RMmSJfiwMYp-_0ZkmJ6aFZVs,54561
 smart_bot_factory/dashboard/__init__.py,sha256=Qie1pJgzprBlCPrZVQLhVs1JR5-YrpzfcBvHHD3OLJk,94
-smart_bot_factory/event/__init__.py,sha256=E5u8Pjul_T0E77Ftmj-mqrip05w7KwUXlF1WMc5_lIs,192
-smart_bot_factory/handlers/handlers.py,sha256=IELP8fH-hW8KhnTRKBvaO-2rnPmJRGmmcKN8acrvPe0,63656
+smart_bot_factory/event/__init__.py,sha256=eWKoiZ_DD-jTL9Tjv11ucQat8P8AhP3xWmQs29pd4ZA,190
+smart_bot_factory/handlers/handlers.py,sha256=F7qgSrz_8kXDvolYmJPofF06PZRucsA6lI11iQCjbzk,64372
 smart_bot_factory/integrations/openai_client.py,sha256=R04qglOWNu3yQ32QRMRMzO01T6luWTp83H3OJMvD-uM,24316
-smart_bot_factory/integrations/supabase_client.py,sha256=l9SsgQRYxv88_kOsaBZNJpYzsYw_NkGht9aHhTq6wCM,67205
+smart_bot_factory/integrations/supabase_client.py,sha256=7Yip9din4PDqFD1X2pkKB4KYAhmf04LUzxo9SnOrVg4,68415
 smart_bot_factory/message/__init__.py,sha256=neUUYAs8ITz3cV1B_T0P9_3XZvvn8cZ2VDpDqrf6lrc,1940
 smart_bot_factory/router/__init__.py,sha256=ywywG6iFBLLkBvtZ-huPVetqjXGN4UiUzoK6lw46bMg,272
 smart_bot_factory/supabase/__init__.py,sha256=xa1xmHLaQVoghjD5cqguiL4yd25VYMvGd6_e87uc0tQ,181
@@ -52,8 +52,8 @@ smart_bot_factory/utils/__init__.py,sha256=RgP2IAMFsJF7fxhhg8JLfhbGg9mO63xQM-NEa
 smart_bot_factory/utils/debug_routing.py,sha256=wV9BFwNmjBbF3rNI7UBdGsTf1bIT5XVQIGnxwIxhNYA,4707
 smart_bot_factory/utils/prompt_loader.py,sha256=YClbQjvRgTWCD42Rr92g77zzVEVMUgrqStI6YETC0c4,20022
 smart_bot_factory/utils/user_prompt_loader.py,sha256=lq1eQ4Hb2qN22osOjaFtkGdEc4OgpFPrzPNpPhsm5kA,2353
-smart_bot_factory-0.3.9.dist-info/METADATA,sha256=LJbAkV27vOo9uiTOXizOnvNANDi8EPg4JEn-jV2Mzpg,40748
-smart_bot_factory-0.3.9.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-smart_bot_factory-0.3.9.dist-info/entry_points.txt,sha256=ybKEAI0WSb7WoRiey7QE-HHfn88UGV7nxLDxXq7b7SU,50
-smart_bot_factory-0.3.9.dist-info/licenses/LICENSE,sha256=OrK3cwdUTzNzIhJvSPtJaVMoYIyC_sSx5EFE_FDMvGs,1092
-smart_bot_factory-0.3.9.dist-info/RECORD,,
+smart_bot_factory-1.0.0.dist-info/METADATA,sha256=9k7A5Gl3rfnCS-i9HJp2ZNXBMJCbLDOu8hlGobF0nM8,40748
+smart_bot_factory-1.0.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+smart_bot_factory-1.0.0.dist-info/entry_points.txt,sha256=ybKEAI0WSb7WoRiey7QE-HHfn88UGV7nxLDxXq7b7SU,50
+smart_bot_factory-1.0.0.dist-info/licenses/LICENSE,sha256=OrK3cwdUTzNzIhJvSPtJaVMoYIyC_sSx5EFE_FDMvGs,1092
+smart_bot_factory-1.0.0.dist-info/RECORD,,