smart-bot-factory 0.3.3__py3-none-any.whl → 0.3.4__py3-none-any.whl

smart_bot_factory/admin/admin_events.py

@@ -1,14 +1,51 @@
 # Обработчики для создания админских событий
 
 import logging
-from datetime import datetime, time, timezone
+import os
+import shutil
+from datetime import datetime
 from dateutil.relativedelta import relativedelta
 from aiogram import Router, F
 from aiogram.filters import Command
 from aiogram.fsm.context import FSMContext
 from aiogram.types import Message, CallbackQuery, InlineKeyboardMarkup, InlineKeyboardButton
+from aiogram_media_group import media_group_handler
 from ..aiogram_calendar import SimpleCalendar, SimpleCalendarCallback
 import pytz
+import uuid
+import json
+
+TEMP_DIR = "temp_event_files"
+
+def generate_file_id() -> str:
+    """Генерирует уникальный ID для файла"""
+    return f"file_{uuid.uuid4().hex}"
+
+def ensure_temp_dir():
+    """Создает временную папку если её нет"""
+    if not os.path.exists(TEMP_DIR):
+        os.makedirs(TEMP_DIR)
+        logger.info(f"📁 Создана временная папка {TEMP_DIR}")
+
+async def cleanup_temp_files(state: FSMContext = None):
+    """Очистка временных файлов события"""
+    # Удаляем все файлы из временной папки
+    if os.path.exists(TEMP_DIR):
+        try:
+            shutil.rmtree(TEMP_DIR)
+            logger.info(f"🗑️ Удалена папка {TEMP_DIR}")
+        except Exception as e:
+            logger.error(f"❌ Ошибка при удалении {TEMP_DIR}: {e}")
+    
+    # Очищаем информацию о файлах в состоянии
+    if state:
+        try:
+            data = await state.get_data()
+            if 'files' in data:
+                data['files'] = []
+                await state.set_data(data)
+        except Exception as e:
+            logger.error(f"❌ Ошибка при очистке состояния: {e}")
 
 logger = logging.getLogger(__name__)
 
@@ -37,9 +74,10 @@ async def create_event_start(message: Message, state: FSMContext):
     await state.set_state(AdminStates.create_event_name)
     
     await message.answer(
-        "📝 **Создание нового события**\n\n"
-        "Введите название события:\n"
-        "_(Название поможет вам идентифицировать событие для редактирования или удаления)_",
+        "📝 **Введите название события**\n\n"
+        "💡 _По этому названию вы сможете:\n"
+        "• Найти событие в списке\n"
+        "• Отменить его при необходимости_",
         parse_mode='Markdown'
     )
 
@@ -194,174 +232,196 @@ async def process_event_segment(callback_query: CallbackQuery, state: FSMContext
         "📄 _Если нужно добавить **PDF или другие документы**, вы сможете это сделать на следующем шаге_",
         parse_mode='Markdown'
     )
-
-@admin_events_router.message(AdminStates.create_event_message)
-async def process_event_message(message: Message, state: FSMContext):
-    """Обработка сообщения для пользователей"""
-    event_message = message.text or message.caption or ""
     
-    if not event_message.strip():
-        await message.answer("❌ Сообщение не может быть пустым. Попробуйте еще раз:")
+@admin_events_router.message(AdminStates.create_event_message, F.media_group_id, F.content_type.in_({'photo', 'video'}))
+@media_group_handler
+async def handle_album(messages: list[Message], state: FSMContext):
+    """Обработка альбома фотографий/видео"""
+    if not messages:
         return
     
-    # Сохраняем сообщение и media_group_id если есть
-    data_to_update = {'event_message': event_message}
-    
-    # Если это часть альбома (media group), сохраняем ID группы
-    if message.media_group_id:
-        data_to_update['media_group_id'] = message.media_group_id
-        data_to_update['waiting_for_album'] = True
-        logger.info(f"Обнаружен альбом с ID: {message.media_group_id}")
+    # Берем текст из первого сообщения с подписью
+    event_message = next((msg.caption for msg in messages if msg.caption), None)
+    if not event_message:
+        await messages[0].answer(
+            "❌ **Добавьте подпись к альбому**\n\n"
+            "💡 _Отправьте альбом заново с текстом сообщения в подписи к любой фотографии_",
+            parse_mode='Markdown'
+        )
+        return
     
-    await state.update_data(**data_to_update)
+    # Сохраняем сообщение
+    await state.update_data(event_message=event_message)
     
-    # Если есть фото в сообщении, сохраняем его
-    files = []
-    if message.photo:
-        import os
-        from ..handlers.handlers import get_global_var
-        bot = get_global_var('bot')
-        
-        # Создаем временную папку если её нет
-        temp_dir = "temp_event_files"
-        os.makedirs(temp_dir, exist_ok=True)
-        
-        # Скачиваем фото
-        photo = message.photo[-1]  # Берем самое большое фото
-        file = await bot.get_file(photo.file_id)
-        file_path = os.path.join(temp_dir, f"{photo.file_id}.jpg")
-        await bot.download_file(file.file_path, file_path)
-        
-        files.append({
-            'type': 'photo',
-            'file_path': file_path,
-            'name': f"{photo.file_id}.jpg",
-            'stage': 'with_message',
-            'has_caption': bool(message.caption)  # Первое фото с текстом
-        })
-        logger.info(f"Фото сохранено: {file_path} (with_message)")
-    
-    await state.update_data(files=files)
+    # Показываем сообщение о начале загрузки
+    await messages[0].answer(
+        "📸 **Загружаю файлы...**\n\n"
+        "💡 _Дождитесь загрузки всех файлов из альбома_",
+        parse_mode='Markdown'
+    )
     
-    # Если это НЕ альбом, переходим к добавлению файлов
-    if not message.media_group_id:
-        await state.set_state(AdminStates.create_event_files)
-        
-        # Кнопки для добавления файлов или пропуска
-        keyboard = InlineKeyboardMarkup(inline_keyboard=[
-            [InlineKeyboardButton(text="➡️ Продолжить без файлов", callback_data="files:skip")]
-        ])
-        
-        await message.answer(
-            "✅ **Сообщение сохранено!**\n\n"
-            "📎 **Дополнительные файлы**\n\n"
-            "Теперь вы можете отправить:\n"
-            "📄 PDF документы\n"
-            "📁 Файлы любых форматов\n"
-            "🎥 Дополнительные видео\n"
-            "🖼 Дополнительные фото\n\n"
-            "💡 _Можно отправить несколько файлов по очереди_\n\n"
-            "Или нажмите кнопку, если дополнительных файлов нет:",
-            reply_markup=keyboard,
-            parse_mode='Markdown'
-        )
-    # Если альбом - ничего не делаем, остальные фото обработаются отдельным handler
-
-@admin_events_router.message(AdminStates.create_event_message, F.photo)
-async def process_album_photos(message: Message, state: FSMContext):
-    """Обработка остальных фото из альбома"""
-    import os
+    # Сохраняем все файлы
     from ..handlers.handlers import get_global_var
+    bot = get_global_var('bot')
+    ensure_temp_dir()
     
     data = await state.get_data()
+    files = data.get('files', [])
     
-    # Проверяем что это альбом и мы ждем остальные фото
-    if not data.get('waiting_for_album'):
-        return
+    for i, message in enumerate(messages, 1):
+        try:
+            if message.photo:
+                photo = message.photo[-1]
+                file = await bot.get_file(photo.file_id)
+                file_name = f"photo_{datetime.now().strftime('%Y%m%d_%H%M%S')}_{i}.jpg"
+                file_path = os.path.join(TEMP_DIR, file_name)
+                await bot.download_file(file.file_path, file_path)
+                
+                files.append({
+                    'type': 'photo',
+                    'file_path': file_path,
+                    'name': file_name,
+                    'stage': 'with_message',
+                    'has_caption': bool(message.caption),
+                    'order': i  # Сохраняем порядок в альбоме
+                })
+                
+            elif message.video:
+                file = await bot.get_file(message.video.file_id)
+                file_name = message.video.file_name or f"{message.video.file_id}.mp4"
+                file_path = os.path.join(TEMP_DIR, file_name)
+                await bot.download_file(file.file_path, file_path)
+                
+                files.append({
+                    'type': 'video',
+                    'file_path': file_path,
+                    'name': file_name,
+                    'stage': 'with_message',
+                    'has_caption': bool(message.caption),
+                    'order': i  # Сохраняем порядок в альбоме
+                })
+            
+            # Показываем прогресс каждые 5 файлов
+            if i % 5 == 0:
+                await messages[0].answer(
+                    f"📸 Загружено файлов: {i}/{len(messages)}",
+                    parse_mode='Markdown'
+                )
+                
+        except Exception as e:
+            logger.error(f"❌ Ошибка загрузки файла {i}: {e}")
+            continue
     
-    # Проверяем что это тот же альбом
-    if message.media_group_id != data.get('media_group_id'):
-        return
+    # Сохраняем файлы
+    await state.update_data(files=files)
     
-    bot = get_global_var('bot')
-    files = data.get('files', [])
+    # Переходим к следующему этапу
+    await state.set_state(AdminStates.create_event_files)
     
-    # Создаем временную папку если её нет
-    temp_dir = "temp_event_files"
-    os.makedirs(temp_dir, exist_ok=True)
+    keyboard = InlineKeyboardMarkup(inline_keyboard=[
+        [InlineKeyboardButton(text="➡️ Продолжить без файлов", callback_data="files:skip")]
+    ])
     
-    # Скачиваем фото
-    photo = message.photo[-1]
-    file = await bot.get_file(photo.file_id)
-    file_path = os.path.join(temp_dir, f"{photo.file_id}.jpg")
-    await bot.download_file(file.file_path, file_path)
+    await messages[0].answer(
+        f"✅ **Сообщение и {len(files)} файлов сохранены!**\n\n"
+        "📎 **Дополнительные файлы**\n\n"
+        "Теперь вы можете отправить:\n"
+        "📄 PDF документы\n"
+        "📁 Файлы любых форматов\n"
+        "🎥 Дополнительные видео\n"
+        "🖼 Дополнительные фото\n\n"
+        "💡 _Можно отправить несколько файлов по очереди_\n\n"
+        "Или нажмите кнопку, если дополнительных файлов нет:",
+        reply_markup=keyboard,
+        parse_mode='Markdown'
+    )
+
+@admin_events_router.message(AdminStates.create_event_message, F.text | F.photo | F.video)
+async def process_event_message(message: Message, state: FSMContext):
+    """Обработка одиночного сообщения с текстом/фото/видео"""
+    # Если это часть альбома - пропускаем, его обработает другой handler
+    if message.media_group_id:
+        return
     
-    files.append({
-        'type': 'photo',
-        'file_path': file_path,
-        'name': f"{photo.file_id}.jpg",
-        'stage': 'with_message',
-        'has_caption': False  # Остальные фото без текста
-    })
+    event_message = message.text or message.caption or ""
     
-    await state.update_data(files=files)
-    logger.info(f"Фото из альбома сохранено: {file_path} (with_message, всего: {len(files)})")
+    # Проверяем текст
+    if not event_message.strip():
+        await message.answer("❌ Сообщение не может быть пустым. Попробуйте еще раз:")
+        return
     
-    # Автоматически переходим к следующему этапу через 2 секунды после последнего фото
-    import asyncio
-    await asyncio.sleep(2)
+    # Сохраняем сообщение
+    await state.update_data(event_message=event_message)
     
-    # Проверяем что все еще ждем альбом (не было новых фото)
+    # Если есть медиа, сохраняем его
     data = await state.get_data()
-    if data.get('waiting_for_album') and data.get('media_group_id') == message.media_group_id:
-        # Все фото получены, переходим к добавлению доп файлов
-        await state.update_data(waiting_for_album=False)
-        await state.set_state(AdminStates.create_event_files)
+    files = data.get('files', [])
+    
+    if message.photo or message.video:
+        import os
+        from ..handlers.handlers import get_global_var
+        bot = get_global_var('bot')
         
-        files_count = len(data.get('files', []))
-        keyboard = InlineKeyboardMarkup(inline_keyboard=[
-            [InlineKeyboardButton(text="➡️ Продолжить", callback_data="files:skip")]
-        ])
+        # Создаем временную папку
+        ensure_temp_dir()
         
-        await message.answer(
-            f"✅ **Сообщение и {files_count} фото сохранены!**\n\n"
-            "📎 **Дополнительные файлы**\n\n"
-            "Теперь вы можете отправить:\n"
-            "📄 PDF документы\n"
-            "📁 Файлы любых форматов\n"
-            "🎥 Дополнительные видео\n\n"
-            "💡 _Можно отправить несколько файлов по очереди_\n\n"
-            "Или нажмите кнопку, если дополнительных файлов нет:",
-            reply_markup=keyboard,
-            parse_mode='Markdown'
-        )
-
-@admin_events_router.callback_query(F.data == "album:done", AdminStates.create_event_message)
-async def finish_album_collection(callback_query: CallbackQuery, state: FSMContext):
-    """Завершение сбора фото из альбома"""
-    await state.update_data(waiting_for_album=False)
-    await state.set_state(AdminStates.create_event_files)
+        if message.photo:
+            # Скачиваем фото
+            photo = message.photo[-1]  # Берем самое большое фото
+            file = await bot.get_file(photo.file_id)
+            file_name = f"photo_{datetime.now().strftime('%Y%m%d_%H%M%S')}.jpg"
+            file_path = os.path.join(TEMP_DIR, file_name)
+            await bot.download_file(file.file_path, file_path)
+            
+            files.append({
+                'type': 'photo',
+                'file_path': file_path,
+                'name': file_name,
+                'stage': 'with_message',
+                'has_caption': bool(message.caption)
+            })
+            logger.info(f"Фото сохранено: {file_path} (with_message)")
+            
+        elif message.video:
+            # Скачиваем видео
+            file = await bot.get_file(message.video.file_id)
+            file_name = message.video.file_name or f"{message.video.file_id}.mp4"
+            file_path = os.path.join(TEMP_DIR, file_name)
+            await bot.download_file(file.file_path, file_path)
+            
+            files.append({
+                'type': 'video',
+                'file_path': file_path,
+                'name': file_name,
+                'stage': 'with_message',
+                'has_caption': bool(message.caption)
+            })
+            logger.info(f"Видео сохранено: {file_path} (with_message)")
     
-    data = await state.get_data()
-    files_count = len(data.get('files', []))
+    await state.update_data(files=files)
+    
+    # Переходим к добавлению файлов
+    await state.set_state(AdminStates.create_event_files)
     
     keyboard = InlineKeyboardMarkup(inline_keyboard=[
-        [InlineKeyboardButton(text="➡️ Продолжить", callback_data="files:skip")]
+        [InlineKeyboardButton(text="➡️ Продолжить без файлов", callback_data="files:skip")]
     ])
     
-    await callback_query.message.edit_text(
-        f"✅ **Сообщение и {files_count} фото сохранены!**\n\n"
+    await message.answer(
+        "✅ **Сообщение сохранено!**\n\n"
         "📎 **Дополнительные файлы**\n\n"
         "Теперь вы можете отправить:\n"
         "📄 PDF документы\n"
         "📁 Файлы любых форматов\n"
-        "🎥 Дополнительные видео\n\n"
-        "💡 _Эти файлы будут отправлены после сообщения_\n\n"
+        "🎥 Дополнительные видео\n"
+        "🖼 Дополнительные фото\n\n"
+        "💡 _Можно отправить несколько файлов по очереди_\n\n"
         "Или нажмите кнопку, если дополнительных файлов нет:",
         reply_markup=keyboard,
         parse_mode='Markdown'
     )
 
+
 @admin_events_router.message(AdminStates.create_event_files, F.document | F.photo | F.video)
 async def process_event_files(message: Message, state: FSMContext):
     """Обработка файлов для события"""
@@ -372,14 +432,13 @@ async def process_event_files(message: Message, state: FSMContext):
     files = data.get('files', [])
     bot = get_global_var('bot')
     
-    # Создаем временную папку если её нет
-    temp_dir = "temp_event_files"
-    os.makedirs(temp_dir, exist_ok=True)
+    # Создаем временную папку
+    ensure_temp_dir()
     
     # Скачиваем и добавляем файл в список
     if message.document:
         file = await bot.get_file(message.document.file_id)
-        file_path = os.path.join(temp_dir, f"{message.document.file_id}_{message.document.file_name}")
+        file_path = os.path.join(TEMP_DIR, message.document.file_name)
         await bot.download_file(file.file_path, file_path)
         
         files.append({
@@ -393,26 +452,28 @@ async def process_event_files(message: Message, state: FSMContext):
     elif message.photo:
         photo = message.photo[-1]
         file = await bot.get_file(photo.file_id)
-        file_path = os.path.join(temp_dir, f"{photo.file_id}.jpg")
+        file_name = f"photo_{datetime.now().strftime('%H%M%S')}.jpg"
+        file_path = os.path.join(TEMP_DIR, file_name)
         await bot.download_file(file.file_path, file_path)
         
         files.append({
             'type': 'photo',
             'file_path': file_path,
-            'name': f"{photo.file_id}.jpg",
+            'name': file_name,
             'stage': 'after_message'
         })
         logger.info(f"Фото сохранено: {file_path} (after_message)")
         
     elif message.video:
         file = await bot.get_file(message.video.file_id)
-        file_path = os.path.join(temp_dir, f"{message.video.file_id}.mp4")
+        file_name = message.video.file_name or f"{message.video.file_id}.mp4"  # Используем оригинальное имя или file_id
+        file_path = os.path.join(TEMP_DIR, file_name)
         await bot.download_file(file.file_path, file_path)
         
         files.append({
             'type': 'video',
             'file_path': file_path,
-            'name': f"{message.video.file_id}.mp4",
+            'name': file_name,
             'stage': 'after_message'
         })
         logger.info(f"Видео сохранено: {file_path} (after_message)")
@@ -438,9 +499,13 @@ async def process_files_action(callback_query: CallbackQuery, state: FSMContext)
     data = await state.get_data()
     files = data.get('files', [])
     
-    if action == "skip":
+    if action == "skip" and not files:
+        # Если файлов нет и нажали "Продолжить без файлов" - очищаем
         files = []
         await state.update_data(files=files)
+    elif action == "skip":
+        # Если файлы уже есть - оставляем их
+        logger.info(f"Продолжаем с {len(files)} существующими файлами")
     
     # Переход к подтверждению
     await state.set_state(AdminStates.create_event_confirm)
@@ -451,37 +516,109 @@ async def process_files_action(callback_query: CallbackQuery, state: FSMContext)
     naive_datetime = datetime.strptime(f"{event_date} {event_time}", '%Y-%m-%d %H:%M')
     moscow_datetime = MOSCOW_TZ.localize(naive_datetime)
     
-    # Сначала отправляем превью сообщения
+    # Отправляем сообщение с подтверждением
+    summary = (
+        f"📋 **Подтверждение создания события**\n\n"
+        f"📝 Название: **{data.get('event_name')}**\n"
+        f"📅 Дата и время: **{moscow_datetime.strftime('%d.%m.%Y %H:%M')} (МСК)**\n"
+        f"👥 Сегмент: **{data.get('segment_display')}**\n"
+        f"📎 Файлов: **{len(files)}**\n\n"
+        "Подтвердите создание события:"
+    )
+    
+    keyboard = InlineKeyboardMarkup(inline_keyboard=[
+        [
+            InlineKeyboardButton(text="✅ Создать", callback_data="confirm:yes"),
+            InlineKeyboardButton(text="❌ Отменить", callback_data="confirm:no")
+        ],
+        [
+            InlineKeyboardButton(text="👁 Предпросмотр", callback_data="preview:show")
+        ]
+    ])
+    
+    await callback_query.message.edit_text(
+        summary,
+        reply_markup=keyboard,
+        parse_mode='Markdown'
+    )
+
+@admin_events_router.callback_query(F.data == "preview:show", AdminStates.create_event_confirm)
+async def show_event_preview(callback_query: CallbackQuery, state: FSMContext):
+    """Показываем предпросмотр сообщения"""
     from aiogram.types import FSInputFile, InputMediaPhoto, InputMediaVideo
     
+    # Получаем данные
+    data = await state.get_data()
+    files = data.get('files', [])
+    logger.info(f"Предпросмотр: получено {len(files)} файлов из состояния")
+    
+    # Удаляем сообщение с кнопкой предпросмотра
+    await callback_query.message.delete()
+    
     # Анализируем файлы
     files_with_msg = [f for f in files if f.get('stage') == 'with_message']
     files_after = [f for f in files if f.get('stage') == 'after_message']
+    logger.info(f"Предпросмотр: {len(files_with_msg)} файлов с сообщением, {len(files_after)} дополнительных файлов")
     
     # 1. Отправляем сообщение с прикрепленными файлами
     if files_with_msg:
         media_group = []
         first_file = True
         
-        for file_info in files_with_msg:
-            if file_info['type'] == 'photo':
-                media = InputMediaPhoto(
-                    media=FSInputFile(file_info['file_path']),
-                    caption=data.get('event_message') if first_file else None,
-                    parse_mode='Markdown' if first_file else None
-                )
-                media_group.append(media)
-            elif file_info['type'] == 'video':
-                media = InputMediaVideo(
-                    media=FSInputFile(file_info['file_path']),
-                    caption=data.get('event_message') if first_file else None,
-                    parse_mode='Markdown' if first_file else None
-                )
-                media_group.append(media)
-            first_file = False
+        # Сортируем файлы по порядку
+        sorted_files = sorted(files_with_msg, key=lambda x: x.get('order', 0))
+        
+        # Добавляем файлы в том порядке, в котором они были загружены
+        for file_info in sorted_files:
+            logger.info(f"Добавляем в медиа-группу: {file_info['type']} файл {file_info['file_path']}")
+            try:
+                if file_info['type'] == 'photo':
+                    media = InputMediaPhoto(
+                        media=FSInputFile(file_info['file_path']),
+                        caption=data.get('event_message') if first_file else None,
+                        parse_mode='Markdown' if first_file else None
+                    )
+                    media_group.append(media)
+                    first_file = False
+                elif file_info['type'] == 'video':
+                    media = InputMediaVideo(
+                        media=FSInputFile(file_info['file_path']),
+                        caption=data.get('event_message') if first_file else None,
+                        parse_mode='Markdown' if first_file else None
+                    )
+                    media_group.append(media)
+                    first_file = False
+                logger.info("✅ Файл успешно добавлен в медиа-группу")
+            except Exception as e:
+                logger.error(f"❌ Ошибка добавления файла в медиа-группу: {e}")
         
         if media_group:
-            await callback_query.message.answer_media_group(media_group)
+            try:
+                from ..handlers.handlers import get_global_var
+                bot = get_global_var('bot')
+                await bot.send_media_group(chat_id=callback_query.message.chat.id, media=media_group)
+                logger.info(f"✅ Отправлена медиа-группа из {len(media_group)} файлов")
+            except Exception as e:
+                logger.error(f"❌ Ошибка отправки медиа-группы: {e}")
+                # Если не удалось отправить группой, отправляем по одному
+                first_file = True
+                for media in media_group:
+                    try:
+                        if isinstance(media, InputMediaPhoto):
+                            await callback_query.message.answer_photo(
+                                photo=media.media,
+                                caption=data.get('event_message') if first_file else None,
+                                parse_mode='Markdown' if first_file else None
+                            )
+                        elif isinstance(media, InputMediaVideo):
+                            await callback_query.message.answer_video(
+                                video=media.media,
+                                caption=data.get('event_message') if first_file else None,
+                                parse_mode='Markdown' if first_file else None
+                            )
+                        first_file = False
+                    except Exception as e2:
+                        logger.error(f"❌ Ошибка отправки отдельного файла: {e2}")
     else:
         # Только текст
         await callback_query.message.answer(
@@ -504,14 +641,18 @@ async def process_files_action(callback_query: CallbackQuery, state: FSMContext)
                 FSInputFile(file_info['file_path'])
             )
     
-    # 3. Отправляем сообщение с подтверждением
+    # 3. Отправляем сообщение с подтверждением (такое же как было)
+    event_date = data.get('event_date')
+    event_time = data.get('event_time')
+    naive_datetime = datetime.strptime(f"{event_date} {event_time}", '%Y-%m-%d %H:%M')
+    moscow_datetime = MOSCOW_TZ.localize(naive_datetime)
+    
     summary = (
         f"📋 **Подтверждение создания события**\n\n"
         f"📝 Название: **{data.get('event_name')}**\n"
         f"📅 Дата и время: **{moscow_datetime.strftime('%d.%m.%Y %H:%M')} (МСК)**\n"
         f"👥 Сегмент: **{data.get('segment_display')}**\n"
         f"📎 Файлов: **{len(files)}**\n\n"
-        f"⬆️ _Сообщение выше будет отправлено {data.get('segment_display', 'всем пользователям')}_\n\n"
         "Подтвердите создание события:"
     )
     
@@ -519,10 +660,13 @@ async def process_files_action(callback_query: CallbackQuery, state: FSMContext)
         [
             InlineKeyboardButton(text="✅ Создать", callback_data="confirm:yes"),
             InlineKeyboardButton(text="❌ Отменить", callback_data="confirm:no")
+        ],
+        [
+            InlineKeyboardButton(text="👁 Предпросмотр", callback_data="preview:show")
         ]
     ])
     
-    await callback_query.message.edit_text(
+    await callback_query.message.answer(
         summary,
         reply_markup=keyboard,
         parse_mode='Markdown'
@@ -534,6 +678,9 @@ async def process_event_confirmation(callback_query: CallbackQuery, state: FSMCo
     action = callback_query.data.split(":", 1)[1]
     
     if action == "no":
+        # Очищаем временные файлы
+        await cleanup_temp_files(state)
+        # Очищаем состояние
         await state.clear()
         await callback_query.message.edit_text(
             "❌ Создание события отменено",
@@ -562,88 +709,101 @@ async def process_event_confirmation(callback_query: CallbackQuery, state: FSMCo
     
     logger.info(f"⏰ Время события: Москва={moscow_datetime.strftime('%d.%m.%Y %H:%M %Z')}, UTC={utc_datetime.strftime('%d.%m.%Y %H:%M %Z')}")
     
-    # Загружаем файлы в Supabase Storage
-    import os
-    event_name = data.get('event_name')
-    files = data.get('files', [])
-    uploaded_files = []
-    
+    # Сначала сохраняем событие в БД чтобы получить ID
     try:
+        # Создаем событие без файлов
+        event = await supabase_client.save_admin_event(
+            event_name=data.get('event_name'),
+            event_data={
+                'segment': data.get('segment'),
+                'message': data.get('event_message'),
+                'files': []  # Пока пустой список
+            },
+            scheduled_datetime=utc_datetime
+        )
+        event_id = event['id']
+        logger.info(f"✅ Создано событие с ID {event_id}")
+        
+        # Теперь загружаем файлы в Storage
+        import os
+        files = data.get('files', [])
+        uploaded_files = []
+        
         for file_info in files:
-            # Читаем локальный файл
-            with open(file_info['file_path'], 'rb') as f:
-                file_bytes = f.read()
-            
-            # Загружаем в Storage
-            storage_info = await supabase_client.upload_event_file(
-                event_name=event_name,
-                file_data=file_bytes,
-                file_name=file_info['name']
-            )
-            
-            # Сохраняем только метаданные (БЕЗ file_id и локального пути)
-            uploaded_files.append({
-                'type': file_info['type'],
-                'name': file_info['name'],
-                'storage_path': storage_info['storage_path'],
-                'stage': file_info['stage'],
-                'has_caption': file_info.get('has_caption', False)
-            })
-            
-            # Удаляем временный локальный файл
             try:
-                os.remove(file_info['file_path'])
-                logger.info(f"🗑️ Удален временный файл: {file_info['file_path']}")
+                # Читаем локальный файл
+                with open(file_info['file_path'], 'rb') as f:
+                    file_bytes = f.read()
+                
+                # Генерируем уникальный ID для файла
+                file_id = generate_file_id()
+                
+                # Загружаем в Storage
+                storage_info = await supabase_client.upload_event_file(
+                    event_id=event_id,
+                    file_data=file_bytes,
+                    original_name=file_info['name'],
+                    file_id=file_id
+                )
+                
+                # Сохраняем метаданные файла
+                uploaded_files.append({
+                    'type': file_info['type'],
+                    'storage_path': storage_info['storage_path'],
+                    'original_name': file_info['name'],  # Используем оригинальное имя из file_info
+                    'stage': file_info['stage'],
+                    'has_caption': file_info.get('has_caption', False),
+                    'order': file_info.get('order', 0)
+                })
+                
+                # Удаляем временный локальный файл
+                try:
+                    os.remove(file_info['file_path'])
+                    logger.info(f"🗑️ Удален временный файл: {file_info['file_path']}")
+                except Exception as e:
+                    logger.warning(f"⚠️ Не удалось удалить временный файл: {e}")
+            
             except Exception as e:
-                logger.warning(f"⚠️ Не удалось удалить временный файл: {e}")
+                logger.error(f"❌ Ошибка загрузки файла {file_info['name']}: {e}")
+                # Если ошибка - удаляем все файлы события и само событие
+                try:
+                    await supabase_client.delete_event_files(event_id)
+                    # TODO: добавить метод удаления события
+                except:
+                    pass
+                raise
+        
+        logger.info(f"✅ Загружено {len(uploaded_files)} файлов в Storage для события {event_id}")
         
-        logger.info(f"✅ Загружено {len(uploaded_files)} файлов в Storage для события '{event_name}'")
+        # Обновляем событие с информацией о файлах
+        event_data = {
+            'segment': data.get('segment'),
+            'message': data.get('event_message'),
+            'files': uploaded_files
+        }
+        
+        # TODO: добавить метод обновления события
+        response = supabase_client.client.table('scheduled_events').update({
+            'event_data': json.dumps(event_data, ensure_ascii=False)
+        }).eq('id', event_id).execute()
         
     except Exception as e:
-        logger.error(f"❌ Ошибка загрузки файлов в Storage: {e}")
-        # Если ошибка - пытаемся удалить уже загруженные файлы
-        try:
-            await supabase_client.delete_event_files(event_name)
-        except:
-            pass
+        logger.error(f"❌ Ошибка создания события: {e}")
         raise
     
-    # Подготавливаем данные события с метаданными файлов
-    event_data = {
-        'segment': data.get('segment'),
-        'message': data.get('event_message'),
-        'files': uploaded_files  # ← Сохраняем только метаданные
-    }
+    # Показываем сообщение об успехе
+    await callback_query.message.edit_text(
+        f"✅ **Событие успешно создано!**\n\n"
+        f"📝 Название: `{data.get('event_name')}`\n"
+        f"📅 Запланировано на: **{moscow_datetime.strftime('%d.%m.%Y %H:%M')} (МСК)**\n"
+        f"👥 Сегмент: **{data.get('segment_display')}**\n\n"
+        f"💡 _Нажмите на название для копирования_",
+        parse_mode='Markdown'
+    )
     
-    try:
-        # Сохраняем в БД (в UTC)
-        event_id = await supabase_client.save_admin_event(
-            event_name=event_name,
-            event_data=event_data,
-            scheduled_datetime=utc_datetime
-        )
-        
-        await callback_query.message.edit_text(
-            f"✅ **Событие успешно создано!**\n\n"
-            f"📝 Название: `{data.get('event_name')}`\n"
-            f"📅 Запланировано на: **{moscow_datetime.strftime('%d.%m.%Y %H:%M')} (МСК)**\n"
-            f"👥 Сегмент: **{data.get('segment_display')}**\n\n"
-            f"💡 _Нажмите на название для копирования_",
-            parse_mode='Markdown'
-        )
-        
-        # Очищаем состояние
-        await state.clear()
-        await state.set_state(AdminStates.admin_mode)
-        
-    except Exception as e:
-        logger.error(f"Ошибка создания события: {e}")
-        await callback_query.message.edit_text(
-            f"❌ Ошибка создания события:\n`{str(e)}`",
-            parse_mode='Markdown'
-        )
-        await state.clear()
-        await state.set_state(AdminStates.admin_mode)
+    # Очищаем временные файлы и состояние
+    await cleanup_temp_files(state)
+    await state.set_state(AdminStates.admin_mode)
 
 @admin_events_router.message(Command(commands=["список_событий", "list_events"]))
 async def list_events_command(message: Message, state: FSMContext):
@@ -728,19 +888,34 @@ async def delete_event_command(message: Message, state: FSMContext):
     event_name = parts[1].strip()
     
     try:
-        # Удаляем по названию (только pending события)
-        response = supabase_client.client.table('scheduled_events').update({
-            'status': 'cancelled'
-        }).eq('event_type', event_name).eq(
+        # Сначала получаем событие чтобы узнать его ID
+        response = supabase_client.client.table('scheduled_events').select(
+            'id'
+        ).eq('event_type', event_name).eq(
             'event_category', 'admin_event'
         ).eq('status', 'pending').execute()
         
         if response.data:
+            event_id = response.data[0]['id']
+            
+            # Удаляем файлы из Storage
+            try:
+                await supabase_client.delete_event_files(event_id)
+                logger.info(f"🗑️ Удалены файлы события '{event_name}' (ID: {event_id}) из Storage")
+            except Exception as e:
+                logger.error(f"❌ Ошибка удаления файлов события из Storage: {e}")
+            
+            # Отмечаем событие как отмененное
+            supabase_client.client.table('scheduled_events').update({
+                'status': 'cancelled'
+            }).eq('id', event_id).execute()
+            
             await message.answer(
-                f"✅ Событие `{event_name}` успешно отменено",
+                f"✅ Событие `{event_name}` успешно отменено\n"
+                f"_(файлы удалены из Storage)_",
                 parse_mode='Markdown'
             )
-            logger.info(f"Отменено событие с названием '{event_name}'")
+            logger.info(f"Отменено событие '{event_name}' (ID: {event_id})")
         else:
             await message.answer(
                 f"❌ Активное событие с названием `{event_name}` не найдено\n\n"

smart_bot_factory/admin/admin_logic.py

@@ -29,6 +29,11 @@ async def cancel_handler(message: Message, state: FSMContext):
     # Получаем текущий state
     current_state = await state.get_state()
     
+    # Очищаем временные файлы если это создание события
+    if current_state and current_state.startswith('AdminStates:create_event'):
+        from .admin_events import cleanup_temp_files
+        await cleanup_temp_files(state)
+    
     # Очищаем state
     await state.clear()
     

smart_bot_factory/core/decorators.py

@@ -1747,15 +1747,15 @@ async def process_admin_event(event: Dict):
         for file_info in files_metadata:
             try:
                 file_bytes = await supabase_client.download_event_file(
-                    event_name=event_name,
-                    file_name=file_info['name']
+                    event_id=event_id,
+                    storage_path=file_info['storage_path']
                 )
                 
                 # Сохраняем в соответствующую папку
                 if file_info['stage'] == 'with_message':
-                    file_path = temp_with_msg / file_info['name']
+                    file_path = temp_with_msg / file_info['original_name']
                 else:
-                    file_path = temp_after_msg / file_info['name']
+                    file_path = temp_after_msg / file_info['original_name']
                 
                 with open(file_path, 'wb') as f:
                     f.write(file_bytes)
@@ -1794,8 +1794,11 @@ async def process_admin_event(event: Dict):
                     media_group = []
                     first_file = True
                     
-                    for file_info in files_with_msg:
-                        file_path = temp_with_msg / file_info['name']
+                    # Сортируем файлы по порядку
+                    sorted_files = sorted(files_with_msg, key=lambda x: x.get('order', 0))
+                    
+                    for file_info in sorted_files:
+                        file_path = temp_with_msg / file_info['original_name']
                         
                         if file_info['type'] == 'photo':
                             media = InputMediaPhoto(
@@ -1824,7 +1827,7 @@ async def process_admin_event(event: Dict):
                 files_after = [f for f in files_metadata if f['stage'] == 'after_message']
                 
                 for file_info in files_after:
-                    file_path = temp_after_msg / file_info['name']
+                    file_path = temp_after_msg / file_info['original_name']
                     
                     if file_info['type'] == 'document':
                         await bot.send_document(chat_id=telegram_id, document=FSInputFile(file_path))
@@ -1848,10 +1851,10 @@ async def process_admin_event(event: Dict):
         shutil.rmtree(temp_after_msg, ignore_errors=True)
         logger.info("🗑️ Временные папки очищены")
         
-        # 4.2. Удаляем файлы из Supabase Storage
+            # 4.2. Удаляем файлы из Supabase Storage
         try:
-            await supabase_client.delete_event_files(event_name)
-            logger.info(f"🗑️ Файлы события '{event_name}' удалены из Storage")
+            await supabase_client.delete_event_files(event_id)
+            logger.info(f"🗑️ Файлы события '{event_id}' удалены из Storage")
         except Exception as e:
             logger.error(f"❌ Ошибка удаления из Storage: {e}")
         

smart_bot_factory/handlers/handlers.py

@@ -222,12 +222,18 @@ async def voice_handler(message: Message, state: FSMContext):
             # Распознаем через Whisper
             recognized_text = await openai_client.transcribe_audio(str(file_path))
             
-            # Удаляем временный файл
+            # Удаляем временный файл и папку
             try:
                 os.remove(file_path)
                 logger.info(f"🗑️ Временный файл удален: {file_path}")
+                
+                # Проверяем, пуста ли папка
+                if not any(temp_dir.iterdir()):
+                    temp_dir.rmdir()
+                    logger.info(f"🗑️ Временная папка удалена: {temp_dir}")
+                
             except Exception as e:
-                logger.warning(f"⚠️ Не удалось удалить временный файл: {e}")
+                logger.warning(f"⚠️ Не удалось удалить временные файлы: {e}")
             
             if not recognized_text:
                 await processing_msg.edit_text("❌ Не удалось распознать голос. Попробуйте еще раз.")

smart_bot_factory/integrations/supabase_client.py

@@ -1101,27 +1101,36 @@ class SupabaseClient:
     # МЕТОДЫ ДЛЯ РАБОТЫ С ФАЙЛАМИ СОБЫТИЙ В SUPABASE STORAGE
     # =============================================================================
     
-    async def upload_event_file(self, event_name: str, file_data: bytes, file_name: str) -> Dict[str, str]:
+    async def upload_event_file(
+        self, 
+        event_id: str, 
+        file_data: bytes, 
+        original_name: str,
+        file_id: str
+    ) -> Dict[str, str]:
         """
         Загружает файл события в Supabase Storage
         
         Args:
-            event_name: Название события (используется как папка)
+            event_id: ID события из БД (используется как папка)
             file_data: Байты файла
-            file_name: Имя файла
+            original_name: Оригинальное имя файла (для метаданных)
+            file_id: Уникальный ID файла для хранения
             
         Returns:
-            Dict с storage_path
+            Dict с storage_path и original_name
         """
         try:
             bucket_name = 'admin-events'
             
-            # Формируем путь: admin-events/{event_name}/{file_name}
-            storage_path = f"{event_name}/{file_name}"
+            # Формируем путь: admin-events/event_id/file_id.ext
+            extension = original_name.split('.')[-1] if '.' in original_name else ''
+            storage_name = f"{file_id}.{extension}" if extension else file_id
+            storage_path = f"events/{event_id}/files/{storage_name}"
             
-            # Определяем MIME-type
+            # Определяем MIME-type по оригинальному имени файла
             import mimetypes
-            content_type, _ = mimetypes.guess_type(file_name)
+            content_type, _ = mimetypes.guess_type(original_name)
             if not content_type:
                 content_type = 'application/octet-stream'
             
@@ -1142,20 +1151,19 @@ class SupabaseClient:
             logger.error(f"❌ Ошибка загрузки файла в Storage: {e}")
             raise
     
-    async def download_event_file(self, event_name: str, file_name: str) -> bytes:
+    async def download_event_file(self, event_id: str, storage_path: str) -> bytes:
         """
         Скачивает файл события из Supabase Storage
         
         Args:
-            event_name: Название события
-            file_name: Имя файла
+            event_id: ID события
+            storage_path: Полный путь к файлу в Storage
             
         Returns:
             bytes: Содержимое файла
         """
         try:
             bucket_name = 'admin-events'
-            storage_path = f"{event_name}/{file_name}"
             
             # Скачиваем файл
             file_data = self.client.storage.from_(bucket_name).download(storage_path)
@@ -1167,30 +1175,31 @@ class SupabaseClient:
             logger.error(f"❌ Ошибка скачивания файла из Storage: {e}")
             raise
     
-    async def delete_event_files(self, event_name: str):
+    async def delete_event_files(self, event_id: str):
         """
         Удаляет ВСЕ файлы события из Supabase Storage
         
         Args:
-            event_name: Название события (папка с файлами)
+            event_id: ID события
         """
         try:
             bucket_name = 'admin-events'
+            event_path = f"events/{event_id}/files"
             
             # Получаем список всех файлов в папке события
-            files_list = self.client.storage.from_(bucket_name).list(event_name)
+            files_list = self.client.storage.from_(bucket_name).list(event_path)
             
             if not files_list:
-                logger.info(f"ℹ️ Нет файлов для удаления в событии '{event_name}'")
+                logger.info(f"ℹ️ Нет файлов для удаления в событии '{event_id}'")
                 return
             
             # Формируем пути для удаления
-            file_paths = [f"{event_name}/{file['name']}" for file in files_list]
+            file_paths = [f"{event_path}/{file['name']}" for file in files_list]
             
             # Удаляем файлы
             self.client.storage.from_(bucket_name).remove(file_paths)
             
-            logger.info(f"✅ Удалено {len(file_paths)} файлов события '{event_name}' из Storage")
+            logger.info(f"✅ Удалено {len(file_paths)} файлов события '{event_id}' из Storage")
             
         except Exception as e:
             logger.error(f"❌ Ошибка удаления файлов события из Storage: {e}")
@@ -1201,7 +1210,7 @@ class SupabaseClient:
         event_name: str,
         event_data: Dict[str, Any],
         scheduled_datetime: datetime
-    ) -> str:
+    ) -> Dict[str, Any]:
         """
         Сохраняет админское событие в таблицу scheduled_events
         
@@ -1211,7 +1220,7 @@ class SupabaseClient:
             scheduled_datetime: Дата и время отправки (должно быть в UTC с timezone info)
             
         Returns:
-            str: ID созданного события
+            Dict[str, Any]: {'id': str, 'event_type': str, ...} - все данные созданного события
         """
         try:
             import json
@@ -1233,10 +1242,10 @@ class SupabaseClient:
             }
             
             response = self.client.table('scheduled_events').insert(event_record).execute()
-            event_id = response.data[0]['id']
+            event = response.data[0]
             
-            logger.info(f"💾 Админское событие '{event_name}' сохранено в БД: {event_id} на {scheduled_datetime.isoformat()}")
-            return event_id
+            logger.info(f"💾 Админское событие '{event_name}' сохранено в БД: {event['id']} на {scheduled_datetime.isoformat()}")
+            return event
             
         except Exception as e:
             logger.error(f"❌ Ошибка сохранения админского события: {e}")

{smart_bot_factory-0.3.3.dist-info → smart_bot_factory-0.3.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: smart-bot-factory
-Version: 0.3.3
+Version: 0.3.4
 Summary: Библиотека для создания умных чат-ботов
 Author-email: Kopatych <eserov73@gmail.com>
 License: MIT
@@ -21,6 +21,7 @@ Classifier: Topic :: Communications :: Chat
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.9
 Requires-Dist: aiofiles>=23.0.0
+Requires-Dist: aiogram-media-group>=0.5.1
 Requires-Dist: aiogram>=3.4.1
 Requires-Dist: click>=8.0.0
 Requires-Dist: openai>=1.12.0

{smart_bot_factory-0.3.3.dist-info → smart_bot_factory-0.3.4.dist-info}/RECORD

@@ -4,8 +4,8 @@ smart_bot_factory/config.py,sha256=kB3G2hGMrrCSOAvlrddf8x43bgfgEaQqOCKOeELAzfM,1
 smart_bot_factory/setup_checker.py,sha256=fqRzyptyMzcb2I0boUaj0rWLdarqaN6ViX6suwTEeWc,20123
 smart_bot_factory/utm_link_generator.py,sha256=wYPdYYK555YfOP22eJXAcEv_D66_t50Dhg0-wkLVzVk,4502
 smart_bot_factory/admin/__init__.py,sha256=vdsMTpt_LiXkY-awFu_X9e2Zt7CV50PwmsWkFbk6whk,488
-smart_bot_factory/admin/admin_events.py,sha256=yU52QWc1GC-E-WAA_A3HAXpY3zMG96eGq97FtHC5ZB0,34804
-smart_bot_factory/admin/admin_logic.py,sha256=zyaklL-s0LihPGHVbguOB9F0NMaggHAyQGukco_kTtA,22831
+smart_bot_factory/admin/admin_events.py,sha256=QCosyTbJgrU8daWSK_bQgf8UZoJSIrV6xyO0R3XV2j0,43289
+smart_bot_factory/admin/admin_logic.py,sha256=vPkNk86bdPsjNUNlZ3qfKtbRr9UuJy2oG54cYUGGNmg,23107
 smart_bot_factory/admin/admin_manager.py,sha256=xlyG9mIjPmtUhS4E9lp36T7o5Kfp5PZpJ-r1QjnSn5g,6394
 smart_bot_factory/admin/admin_migration.sql,sha256=kleMPJBSe2Z7ZZz7rNyOX_yoh4GZivGesqAX90U5PGs,5667
 smart_bot_factory/admin/admin_tester.py,sha256=PGFpf7fmD5Wxea31xR2ZM_A_QpvrB73gsbxvUrHQBkg,6463
@@ -32,7 +32,7 @@ smart_bot_factory/configs/growthmed-october-24/welcome_file/welcome_file_msg.txt
 smart_bot_factory/configs/growthmed-october-24/welcome_file/Чек лист по 152ФЗ и 323ФЗ для медицины.pdf,sha256=BiAiQHNnQXJPMsks9AeL6s0beEjRFkRMJLMlAn4WorA,5284954
 smart_bot_factory/core/bot_utils.py,sha256=Be334BPspBgHNO9OpEiPlrCc0Gmy7_8sox5WpV8XHic,45174
 smart_bot_factory/core/conversation_manager.py,sha256=eoHL7MCEz68DRvTVwRwZgf2PWwGv4T6J9D-I-thETi8,28289
-smart_bot_factory/core/decorators.py,sha256=gJWaJVyCoBSsy4EsaJTv4OPVK-Efv1pQLm54Odgu4Lk,93678
+smart_bot_factory/core/decorators.py,sha256=oSsX1yCULoUfVf2aNynBmvap7zDEh5-cEcW4yoRv3dc,93903
 smart_bot_factory/core/message_sender.py,sha256=J4b6n8nXVjqf-qzL6URRSvc-FVnQfShwujVSM6qv26w,32232
 smart_bot_factory/core/router.py,sha256=03fbysaj0LR96p4-8iiml8dTmEHCkR-AaTposSv8q8o,11898
 smart_bot_factory/core/router_manager.py,sha256=dUwesog-oHk1U2EDdS8p0e4MTSkwtx5_qXn6nrJ9l9I,9700
@@ -41,9 +41,9 @@ smart_bot_factory/creation/__init__.py,sha256=IgDk8GDS3pg7Pw_Et41J33ZmeZIU5dRwQd
 smart_bot_factory/creation/bot_builder.py,sha256=yGRmOPD7qCMbhcBiltHWISoKxWx8eqjDSnZXpwhqnUs,43115
 smart_bot_factory/creation/bot_testing.py,sha256=JDWXyJfZmbgo-DLdAPk8Sd9FiehtHHa4sLD17lBrTOc,55669
 smart_bot_factory/event/__init__.py,sha256=hPL449RULIOB-OXv1ZbGNiHctAYaOMUqhSWGPrDHYBM,212
-smart_bot_factory/handlers/handlers.py,sha256=jMKD04v81BbCNLl_00rAM_rgPDH1mMdHZlLI8ZhXpc8,60438
+smart_bot_factory/handlers/handlers.py,sha256=ymPCQPjA0uQc9deiwiVrMhxpBsqdKsAfeajHzK74seA,60739
 smart_bot_factory/integrations/openai_client.py,sha256=fwaJpwojFdLBWChcFWpFGOHK9upG-nCIwDochkCRRlY,24291
-smart_bot_factory/integrations/supabase_client.py,sha256=XznvAXqcMBqHw2_-t91Exyomru-mLP6-BlYuEeoUJSY,63082
+smart_bot_factory/integrations/supabase_client.py,sha256=Rv0sZHXGSfm3UWodmaR1N-X5-2JbmynPWJKY0a0k_Tk,63557
 smart_bot_factory/message/__init__.py,sha256=-ehDZweUc3uKgmLLxFVsD-KWrDtnHpHms7pCrDelWo0,1950
 smart_bot_factory/router/__init__.py,sha256=5gEbpG3eylOyow5NmidzGUy0K-AZq7RhYLVu9OaUT6c,270
 smart_bot_factory/supabase/__init__.py,sha256=XmZP6yM9ffERM5ddAWyJnrNzEhCYtMu3AcjVCi1rOf8,179
@@ -52,8 +52,8 @@ smart_bot_factory/utils/__init__.py,sha256=UhsJXEHfrIK8h1AHsroHSwAriijk-LvnqLyvg
 smart_bot_factory/utils/debug_routing.py,sha256=BOoDhKBg7UXe5uHQxRk3TSfPfLPOFqt0N7lAo6kjCOo,4719
 smart_bot_factory/utils/prompt_loader.py,sha256=JSn7CsWnToSbHYtURdeuZn7ectyDqQGrPGHN2ixIGkw,19930
 smart_bot_factory/utils/user_prompt_loader.py,sha256=dk6P0X_3UcNqxjRtuIvb0LcPrp03zIIsstZwdmeCPaE,2519
-smart_bot_factory-0.3.3.dist-info/METADATA,sha256=kyf-bct-Sf1zvA6PwlUtTOGJ17kV7q8FuqtrjvNvXRM,31949
-smart_bot_factory-0.3.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-smart_bot_factory-0.3.3.dist-info/entry_points.txt,sha256=ybKEAI0WSb7WoRiey7QE-HHfn88UGV7nxLDxXq7b7SU,50
-smart_bot_factory-0.3.3.dist-info/licenses/LICENSE,sha256=OrK3cwdUTzNzIhJvSPtJaVMoYIyC_sSx5EFE_FDMvGs,1092
-smart_bot_factory-0.3.3.dist-info/RECORD,,
+smart_bot_factory-0.3.4.dist-info/METADATA,sha256=lO_csJRkPwV6c8SUmBUEN4WBl9X8LTx_lSt_FALl6J0,31991
+smart_bot_factory-0.3.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+smart_bot_factory-0.3.4.dist-info/entry_points.txt,sha256=ybKEAI0WSb7WoRiey7QE-HHfn88UGV7nxLDxXq7b7SU,50
+smart_bot_factory-0.3.4.dist-info/licenses/LICENSE,sha256=OrK3cwdUTzNzIhJvSPtJaVMoYIyC_sSx5EFE_FDMvGs,1092
+smart_bot_factory-0.3.4.dist-info/RECORD,,