smart-bot-factory 0.1.3__py3-none-any.whl → 0.1.4__py3-none-any.whl

smart_bot_factory/__init__.py

@@ -28,24 +28,6 @@ __all__ = [
     'schedule_task',
     'send_message_by_ai',
     'send_message_by_human',
-    'Config',
     'OpenAIClient',
-    'SupabaseClient',
-    'ConversationManager',
-    'AdminManager',
-    'PromptLoader',
-    'setup_handlers',
-    'setup_admin_handlers',
-    'setup_utils_handlers',
-    'parse_ai_response',
-    'process_events',
-    'setup_debug_handlers',
-    'UserStates',
-    'AdminStates',
-    'bot_testing_main',
-    'AnalyticsManager',
-    'check_timeouts',
-    'setup_bot_environment',
-    'check_setup',
-    'test_admin_system',
+    'SupabaseClient'
 ]

smart_bot_factory/cli.py

@@ -295,18 +295,58 @@ def rm(bot_id: str, force: bool = False):
         sys.exit(1)
         
 
+@cli.command()
+@click.argument("source_bot_id")
+@click.argument("new_bot_id")
+@click.option("--force", "-f", is_flag=True, help="Перезаписать существующего бота без подтверждения")
+def copy(source_bot_id: str, new_bot_id: str, force: bool = False):
+    """Скопировать существующего бота как шаблон"""
+    try:
+        # Проверяем существование исходного бота
+        source_bot_path = PROJECT_ROOT / "bots" / source_bot_id
+        if not source_bot_path.exists():
+            raise click.ClickException(f"Исходный бот {source_bot_id} не найден в папке bots/")
+        
+        # Проверяем наличие файла запускалки исходного бота
+        source_bot_file = PROJECT_ROOT / f"{source_bot_id}.py"
+        if not source_bot_file.exists():
+            raise click.ClickException(f"Файл запускалки {source_bot_id}.py не найден в корневой директории")
+        
+        # Проверяем, не существует ли уже новый бот
+        new_bot_path = PROJECT_ROOT / "bots" / new_bot_id
+        new_bot_file = PROJECT_ROOT / f"{new_bot_id}.py"
+        
+        if new_bot_path.exists() or new_bot_file.exists():
+            if not force:
+                if not click.confirm(f"Бот {new_bot_id} уже существует. Перезаписать?"):
+                    click.echo("Копирование отменено")
+                    return
+            else:
+                click.echo(f"⚠️ Перезаписываем существующего бота {new_bot_id}")
+        
+        # Копируем бота
+        click.echo(f"📋 Копируем бота {source_bot_id} → {new_bot_id}...")
+        copy_bot_template(source_bot_id, new_bot_id)
+        
+        click.echo(f"✅ Бот {new_bot_id} успешно скопирован из {source_bot_id}")
+        click.echo(f"📝 Не забудьте настроить .env файл для нового бота")
+        
+    except Exception as e:
+        click.echo(f"Ошибка при копировании бота: {e}", err=True)
+        sys.exit(1)
+
 @cli.command()
 def link():
     """Создать UTM-ссылку для бота"""
     try:
         # Проверяем наличие скрипта генерации ссылок
-        link_script = Path("utm_link_generator.py")
+        link_script = Path(__file__).parent / "utm_link_generator.py"
         if not link_script.exists():
             raise click.ClickException("Скрипт utm_link_generator.py не найден")
         
-        # Запускаем ваш скрипт генерации ссылок
-        click.echo("Запускаем генератор UTM-ссылок...")
-        subprocess.run([sys.executable, "utm_link_generator.py"], check=True)
+        # Запускаем скрипт генерации ссылок
+        click.echo("🔗 Запускаем генератор UTM-ссылок...")
+        subprocess.run([sys.executable, str(link_script)], check=True)
         
     except subprocess.CalledProcessError as e:
         click.echo(f"Ошибка при запуске генератора ссылок: {e}", err=True)
@@ -335,6 +375,7 @@ def create_new_bot_structure(template: str, bot_id: str) -> bool:
         (bot_dir / "tests").mkdir()
         (bot_dir / "reports").mkdir()
         (bot_dir / "welcome_files").mkdir()
+        (bot_dir / "files").mkdir()
         
         if template == "base":
             # Используем growthmed-october-24 как базовый шаблон
@@ -372,31 +413,6 @@ def create_bot_template(bot_id: str) -> str:
 """
 
 import asyncio
-import sys
-import os
-from pathlib import Path
-
-# Добавляем корень проекта в путь
-project_root = Path(__file__).parent
-sys.path.insert(0, str(project_root))
-
-# Устанавливаем переменные окружения ДО импорта библиотеки
-bot_id = "{bot_id}"
-config_dir = Path("bots") / bot_id
-prompts_dir = config_dir / "prompts"
-
-if prompts_dir.exists():
-    os.environ["PROMT_FILES_DIR"] = str(prompts_dir)
-    print(f"📁 Установлен путь к промптам: {{prompts_dir}}")
-
-# Загружаем .env файл ДО импорта библиотеки
-env_file = config_dir / ".env"
-if env_file.exists():
-    from dotenv import load_dotenv
-    load_dotenv(env_file)
-    print(f"📄 Загружен .env файл: {{env_file}}")
-else:
-    print(f"⚠️ .env файл не найден: {{env_file}}")
 
 from smart_bot_factory import (
     BotBuilder,
@@ -516,12 +532,12 @@ def copy_from_growthmed_template(bot_dir: Path, bot_id: str):
         bot_file = PROJECT_ROOT / Path(f"{bot_id}.py")
         bot_file.write_text(create_bot_template(bot_id), encoding='utf-8')
         
-        # Копируем .env файл в папку бота
+        # Создаем .env файл в папке бота (НЕ копируем из шаблона)
         env_file = bot_dir / ".env"
         env_file.write_text(create_env_template(bot_id), encoding='utf-8')
         
         # Копируем промпты из growthmed-october-24
-        source_prompts = Path("configs/growthmed-october-24/prompts")
+        source_prompts = Path(__file__).parent / "configs" / "growthmed-october-24" / "prompts"
         target_prompts = bot_dir / "prompts"
         
         if source_prompts.exists():
@@ -529,17 +545,134 @@ def copy_from_growthmed_template(bot_dir: Path, bot_id: str):
                 shutil.copy2(prompt_file, target_prompts / prompt_file.name)
             click.echo("Промпты скопированы из growthmed-october-24")
         else:
+            click.echo(f"⚠️ Папка промптов не найдена: {source_prompts}")
             # Fallback к базовым промптам
             create_basic_prompts(target_prompts)
             click.echo("Созданы базовые промпты")
+        
+        # Копируем тесты из growthmed-october-24
+        source_tests = Path(__file__).parent / "configs" / "growthmed-october-24" / "tests"
+        target_tests = bot_dir / "tests"
+        
+        if source_tests.exists():
+            for test_file in source_tests.glob("*"):
+                if test_file.is_file():
+                    shutil.copy2(test_file, target_tests / test_file.name)
+            click.echo("Тесты скопированы из growthmed-october-24")
+        
+        # Копируем welcome_files из growthmed-october-24
+        source_welcome = Path(__file__).parent / "configs" / "growthmed-october-24" / "welcome_file"
+        target_welcome = bot_dir / "welcome_files"
+        
+        if source_welcome.exists():
+            for welcome_file in source_welcome.glob("*"):
+                if welcome_file.is_file():
+                    shutil.copy2(welcome_file, target_welcome / welcome_file.name)
+            click.echo("Welcome файлы скопированы из growthmed-october-24")
+        
+        # Копируем files из growthmed-october-24
+        source_files = Path(__file__).parent / "configs" / "growthmed-october-24" / "files"
+        target_files = bot_dir / "files"
+        
+        if source_files.exists():
+            for file_item in source_files.glob("*"):
+                if file_item.is_file():
+                    shutil.copy2(file_item, target_files / file_item.name)
+            click.echo("Файлы скопированы из growthmed-october-24")
             
     except Exception as e:
         click.echo(f"Ошибка при копировании шаблона: {e}")
         # Fallback к базовым промптам
         create_basic_prompts(bot_dir / "prompts")
 
+def copy_bot_template(source_bot_id: str, new_bot_id: str):
+    """Копирует существующего бота как шаблон для нового бота"""
+    try:
+        source_dir = PROJECT_ROOT / "bots" / source_bot_id
+        new_dir = PROJECT_ROOT / "bots" / new_bot_id
+        
+        # Создаем папку для нового бота
+        new_dir.mkdir(exist_ok=True)
+        
+        # Создаем структуру папок
+        (new_dir / "prompts").mkdir(exist_ok=True)
+        (new_dir / "tests").mkdir(exist_ok=True)
+        (new_dir / "reports").mkdir(exist_ok=True)
+        (new_dir / "welcome_files").mkdir(exist_ok=True)
+        (new_dir / "files").mkdir(exist_ok=True)
+        
+        # Копируем основной файл бота в корневую директорию
+        source_bot_file = PROJECT_ROOT / f"{source_bot_id}.py"
+        new_bot_file = PROJECT_ROOT / f"{new_bot_id}.py"
+        
+        if source_bot_file.exists():
+            shutil.copy2(source_bot_file, new_bot_file)
+            
+            # Заменяем название бота в файле
+            content = new_bot_file.read_text(encoding='utf-8')
+            content = content.replace(f'BotBuilder("{source_bot_id}")', f'BotBuilder("{new_bot_id}")')
+            content = content.replace(f'bot_id="{source_bot_id}"', f'bot_id="{new_bot_id}"')
+            new_bot_file.write_text(content, encoding='utf-8')
+            click.echo(f"   📄 Файл запускалки скопирован: {new_bot_id}.py")
+        
+        # Копируем .env файл
+        source_env = source_dir / ".env"
+        new_env = new_dir / ".env"
+        
+        if source_env.exists():
+            shutil.copy2(source_env, new_env)
+            
+            # Заменяем BOT_ID в .env
+            env_content = new_env.read_text(encoding='utf-8')
+            env_content = env_content.replace(f'BOT_ID={source_bot_id}', f'BOT_ID={new_bot_id}')
+            new_env.write_text(env_content, encoding='utf-8')
+            click.echo(f"   ⚙️ .env файл скопирован и обновлен")
+        
+        # Копируем промпты
+        source_prompts = source_dir / "prompts"
+        new_prompts = new_dir / "prompts"
+        
+        if source_prompts.exists():
+            for prompt_file in source_prompts.glob("*.txt"):
+                shutil.copy2(prompt_file, new_prompts / prompt_file.name)
+            click.echo(f"   📝 Промпты скопированы")
+        
+        # Копируем тесты
+        source_tests = source_dir / "tests"
+        new_tests = new_dir / "tests"
+        
+        if source_tests.exists():
+            for test_file in source_tests.glob("*"):
+                if test_file.is_file():
+                    shutil.copy2(test_file, new_tests / test_file.name)
+            click.echo(f"   🧪 Тесты скопированы")
+        
+        # Копируем welcome_files
+        source_welcome = source_dir / "welcome_files"
+        new_welcome = new_dir / "welcome_files"
+        
+        if source_welcome.exists():
+            for welcome_file in source_welcome.glob("*"):
+                if welcome_file.is_file():
+                    shutil.copy2(welcome_file, new_welcome / welcome_file.name)
+            click.echo(f"   📁 Welcome файлы скопированы")
+        
+        # Копируем files
+        source_files = source_dir / "files"
+        new_files = new_dir / "files"
+        
+        if source_files.exists():
+            for file_item in source_files.glob("*"):
+                if file_item.is_file():
+                    shutil.copy2(file_item, new_files / file_item.name)
+            click.echo(f"   📎 Файлы скопированы")
+        
+    except Exception as e:
+        click.echo(f"Ошибка при копировании бота: {e}")
+        raise
+
 def copy_from_bot_template(template: str, bot_dir: Path, bot_id: str):
-    """Копирует шаблон из существующего бота"""
+    """Копирует шаблон из существующего бота (для команды create)"""
     try:
         template_dir = PROJECT_ROOT / Path("bots") / template
         if not template_dir.exists():
@@ -557,16 +690,9 @@ def copy_from_bot_template(template: str, bot_dir: Path, bot_id: str):
             content = content.replace(f'bot_id="{template}"', f'bot_id="{bot_id}"')
             bot_file.write_text(content, encoding='utf-8')
         
-        # Копируем .env файл
-        template_env = template_dir / ".env"
-        if template_env.exists():
-            env_file = bot_dir / ".env"
-            shutil.copy2(template_env, env_file)
-            
-            # Заменяем BOT_ID в .env
-            env_content = env_file.read_text(encoding='utf-8')
-            env_content = env_content.replace(f'BOT_ID={template}', f'BOT_ID={bot_id}')
-            env_file.write_text(env_content, encoding='utf-8')
+        # Создаем .env файл в папке бота (НЕ копируем из шаблона)
+        env_file = bot_dir / ".env"
+        env_file.write_text(create_env_template(bot_id), encoding='utf-8')
         
         # Копируем промпты
         template_prompts = template_dir / "prompts"

smart_bot_factory/core/bot_utils.py

@@ -186,28 +186,38 @@ async def process_events(session_id: str, events: list, user_id: int):
             await supabase_client.add_session_event(session_id, event_type, event_info)
             logger.info(f"   ✅ Событие сохранено в БД")
             
-            # Уведомляем админов
-            await notify_admins_about_event(user_id, event)
-            logger.info(f"   ✅ Админы уведомлены")
-            
             # Вызываем зарегистрированный обработчик события или задачи
+            should_notify = False
             try:
                 # Сначала пробуем как обычное событие
                 try:
                     logger.info(f"   🎯 Вызываем обработчик события '{event_type}'")
                     result = await execute_event_handler(event_type, user_id, event_info)
                     logger.info(f"   ✅ Обработчик события вернул: {result}")
+                    
+                    should_notify = result.get('notify', False)
+                        
                 except ValueError:
                     # Если обработчик события не найден, пробуем как запланированную задачу
                     logger.info(f"   ⏰ Пробуем как запланированную задачу '{event_type}'")
                     result = await execute_scheduled_task(event_type, user_id, event_info)
                     logger.info(f"   ✅ Задача выполнена: {result}")
+                    
+                    should_notify = result.get('notify', False)
+                        
             except ValueError as e:
                 logger.warning(f"   ⚠️ Обработчик/задача не найдены: {e}")
             except Exception as e:
                 logger.error(f"   ❌ Ошибка в обработчике/задаче: {e}")
                 logger.exception("   Стек ошибки:")
             
+            # Уведомляем админов только если result.notify = True
+            if should_notify:
+                await notify_admins_about_event(user_id, event)
+                logger.info(f"   ✅ Админы уведомлены")
+            else:
+                logger.info(f"   🔕 Уведомления админам отключены для '{event_type}'")
+            
         except Exception as e:
             logger.error(f"❌ Ошибка обработки события {event}: {e}")
             logger.exception("Стек ошибки:")
@@ -647,19 +657,19 @@ OpenAI API: {'✅' if openai_status else '❌'}
         
         
 def parse_utm_from_start_param(start_param: str) -> dict:
-    """Парсит UTM-метки из start параметра в формате utmSource-vk_utmCampaign-summer2025
+    """Парсит UTM-метки из start параметра в формате source-vk_campaign-summer2025
     
     Args:
-        start_param: строка вида 'utmSource-vk_utmCampaign-summer2025' или полная ссылка
+        start_param: строка вида 'source-vk_campaign-summer2025' или полная ссылка
         
     Returns:
         dict: {'utm_source': 'vk', 'utm_campaign': 'summer2025'}
         
     Examples:
-        >>> parse_utm_from_start_param('utmSource-vk_utmCampaign-summer2025')
+        >>> parse_utm_from_start_param('source-vk_campaign-summer2025')
         {'utm_source': 'vk', 'utm_campaign': 'summer2025'}
         
-        >>> parse_utm_from_start_param('https://t.me/bot?start=utmSource-vk_utmCampaign-summer2025')
+        >>> parse_utm_from_start_param('https://t.me/bot?start=source-vk_campaign-summer2025')
         {'utm_source': 'vk', 'utm_campaign': 'summer2025'}
     """
     import re
@@ -676,15 +686,15 @@ def parse_utm_from_start_param(start_param: str) -> dict:
             else:
                 return {}
         
-        # Парсим формат: utmSource-vk_utmCampaign-summer2025
+        # Парсим новый формат: source-vk_campaign-summer2025
         if '_' in start_param and '-' in start_param:
             parts = start_param.split('_')
             for part in parts:
                 if '-' in part:
                     key, value = part.split('-', 1)
-                    # Преобразуем utmSource в utm_source
-                    if key.startswith('utm'):
-                        key = 'utm_' + key[3:].lower()
+                    # Преобразуем source в utm_source
+                    if key in ['source', 'medium', 'campaign', 'content', 'term']:
+                        key = 'utm_' + key
                         utm_data[key] = value
             
     except Exception as e:

smart_bot_factory/core/decorators.py

@@ -14,16 +14,17 @@ logger = logging.getLogger(__name__)
 _event_handlers: Dict[str, Callable] = {}
 _scheduled_tasks: Dict[str, Dict[str, Any]] = {}
 
-def event_handler(event_type: str, description: str = ""):
+def event_handler(event_type: str, description: str = "", notify: bool = False):
     """
     Декоратор для регистрации обработчика события
     
     Args:
         event_type: Тип события (например, 'appointment_booking', 'phone_collection')
         description: Описание что делает обработчик (для добавления в промпт)
+        notify: Уведомлять ли админов о выполнении события (по умолчанию False)
     
     Example:
-        @event_handler("appointment_booking", "Записывает пользователя на прием")
+        @event_handler("appointment_booking", "Записывает пользователя на прием", notify=True)
         async def book_appointment(user_id: int, appointment_data: dict):
             # Логика записи на прием
             return {"status": "success", "appointment_id": "123"}
@@ -32,7 +33,8 @@ def event_handler(event_type: str, description: str = ""):
         _event_handlers[event_type] = {
             'handler': func,
             'description': description,
-            'name': func.__name__
+            'name': func.__name__,
+            'notify': notify
         }
         
         logger.info(f"📝 Зарегистрирован обработчик события '{event_type}': {func.__name__}")
@@ -43,6 +45,18 @@ def event_handler(event_type: str, description: str = ""):
                 logger.info(f"🔧 Выполняем обработчик события '{event_type}'")
                 result = await func(*args, **kwargs)
                 logger.info(f"✅ Обработчик '{event_type}' выполнен успешно")
+                
+                # Автоматически добавляем флаг notify к результату
+                if isinstance(result, dict):
+                    result['notify'] = notify
+                else:
+                    # Если результат не словарь, создаем словарь
+                    result = {
+                        'status': 'success',
+                        'result': result,
+                        'notify': notify
+                    }
+                
                 return result
             except Exception as e:
                 logger.error(f"❌ Ошибка в обработчике '{event_type}': {e}")
@@ -51,25 +65,29 @@ def event_handler(event_type: str, description: str = ""):
         return wrapper
     return decorator
 
-def schedule_task(task_name: str, description: str = ""):
+def schedule_task(task_name: str, description: str = "", notify: bool = False):
     """
     Декоратор для регистрации задачи, которую можно запланировать на время
     
     Args:
         task_name: Название задачи (например, 'send_reminder', 'follow_up')
         description: Описание задачи (для добавления в промпт)
+        notify: Уведомлять ли админов о выполнении задачи (по умолчанию False)
     
     Example:
-        @schedule_task("send_reminder", "Отправляет напоминание пользователю")
-        async def send_reminder(user_id: int, message: str):
-            # Логика отправки напоминания
-            return {"status": "sent"}
+        @schedule_task("send_reminder", "Отправляет напоминание пользователю", notify=False)
+        async def send_reminder(user_id: int, user_data: dict):
+            # user_data содержит: {"delay_seconds": 3600, "scheduled_at": "..."}
+            delay_seconds = user_data.get("delay_seconds", 0)
+            # Логика отправки напоминания (выполняется на фоне)
+            return {"status": "sent", "delay_seconds": delay_seconds}
     """
     def decorator(func: Callable) -> Callable:
         _scheduled_tasks[task_name] = {
             'handler': func,
             'description': description,
-            'name': func.__name__
+            'name': func.__name__,
+            'notify': notify
         }
         
         logger.info(f"⏰ Зарегистрирована задача '{task_name}': {func.__name__}")
@@ -80,6 +98,18 @@ def schedule_task(task_name: str, description: str = ""):
                 logger.info(f"⏰ Выполняем запланированную задачу '{task_name}'")
                 result = await func(*args, **kwargs)
                 logger.info(f"✅ Задача '{task_name}' выполнена успешно")
+                
+                # Автоматически добавляем флаг notify к результату
+                if isinstance(result, dict):
+                    result['notify'] = notify
+                else:
+                    # Если результат не словарь, создаем словарь
+                    result = {
+                        'status': 'success',
+                        'result': result,
+                        'notify': notify
+                    }
+                
                 return result
             except Exception as e:
                 logger.error(f"❌ Ошибка в задаче '{task_name}': {e}")
@@ -125,22 +155,23 @@ async def execute_event_handler(event_type: str, *args, **kwargs) -> Any:
     handler_info = _event_handlers[event_type]
     return await handler_info['handler'](*args, **kwargs)
 
-async def execute_scheduled_task(task_name: str, *args, **kwargs) -> Any:
+async def execute_scheduled_task(task_name: str, user_id: int, user_data: dict) -> Any:
     """Выполняет запланированную задачу по имени"""
     if task_name not in _scheduled_tasks:
         raise ValueError(f"Задача '{task_name}' не найдена")
     
     task_info = _scheduled_tasks[task_name]
-    return await task_info['handler'](*args, **kwargs)
+    return await task_info['handler'](user_id, user_data)
 
-async def schedule_task_for_later(task_name: str, delay_seconds: int, *args, **kwargs):
+async def schedule_task_for_later(task_name: str, delay_seconds: int, user_id: int, user_data: dict):
     """
     Планирует выполнение задачи через указанное время
     
     Args:
         task_name: Название задачи
         delay_seconds: Задержка в секундах
-        *args, **kwargs: Аргументы для задачи
+        user_id: ID пользователя
+        user_data: Данные для задачи
     """
     if task_name not in _scheduled_tasks:
         raise ValueError(f"Задача '{task_name}' не найдена")
@@ -149,7 +180,7 @@ async def schedule_task_for_later(task_name: str, delay_seconds: int, *args, **k
     
     async def delayed_task():
         await asyncio.sleep(delay_seconds)
-        await execute_scheduled_task(task_name, *args, **kwargs)
+        await execute_scheduled_task(task_name, user_id, user_data)
     
     # Запускаем задачу в фоне
     asyncio.create_task(delayed_task())
@@ -168,62 +199,32 @@ async def execute_scheduled_task_from_event(user_id: int, task_name: str, event_
     Args:
         user_id: ID пользователя
         task_name: Название задачи
-        event_info: Информация от ИИ (содержит время и сообщение)
+        event_info: Информация от ИИ (содержит время в секундах и сообщение)
     """
     if task_name not in _scheduled_tasks:
         raise ValueError(f"Задача '{task_name}' не найдена")
     
-    # Парсим event_info для извлечения времени и сообщения
-    # Формат: "через 2 часа: напомнить о приеме"
     try:
-        if ":" in event_info:
-            time_part, message = event_info.split(":", 1)
-            time_part = time_part.strip()
-            message = message.strip()
-        else:
-            time_part = event_info
-            message = "Напоминание"
+        # ИИ присылает время в секундах, парсим его
+        delay_seconds = int(event_info)
         
-        # Парсим время
-        delay_seconds = _parse_time_to_seconds(time_part)
+        # Создаем user_data с временем в секундах
+        user_data = {
+            "delay_seconds": delay_seconds,
+            "scheduled_at": datetime.now().isoformat()
+        }
         
-        # Планируем задачу
-        result = await schedule_task_for_later(task_name, delay_seconds, user_id, message)
+        # Планируем задачу на фоне
+        result = await schedule_task_for_later(task_name, delay_seconds, user_id, user_data)
         
         return result
         
-    except Exception as e:
+    except ValueError as e:
         logger.error(f"Ошибка парсинга времени из event_info '{event_info}': {e}")
         # Fallback - планируем через 1 час
-        return await schedule_task_for_later(task_name, 3600, user_id, event_info)
+        user_data = {
+            "delay_seconds": 3600,
+            "scheduled_at": datetime.now().isoformat()
+        }
+        return await schedule_task_for_later(task_name, 3600, user_id, user_data)
 
-def _parse_time_to_seconds(time_str: str) -> int:
-    """
-    Парсит строку времени в секунды
-    Поддерживает форматы:
-    - "через 2 часа"
-    - "через 30 минут" 
-    - "через 1 день"
-    - "через 2 часа 30 минут"
-    """
-    import re
-    
-    time_str = time_str.lower().strip()
-    
-    # Ищем часы
-    hours_match = re.search(r'(\d+)\s*час', time_str)
-    hours = int(hours_match.group(1)) if hours_match else 0
-    
-    # Ищем минуты
-    minutes_match = re.search(r'(\d+)\s*минут', time_str)
-    minutes = int(minutes_match.group(1)) if minutes_match else 0
-    
-    # Ищем дни
-    days_match = re.search(r'(\d+)\s*дн', time_str)
-    days = int(days_match.group(1)) if days_match else 0
-    
-    # Конвертируем в секунды
-    total_seconds = (days * 24 * 3600) + (hours * 3600) + (minutes * 60)
-    
-    # Минимум 1 минута
-    return max(total_seconds, 60)