Update app.py

app.py

@@ -5,11 +5,8 @@ import os
 import subprocess
 import shutil
 import asyncio
-import aiofiles
 from pathlib import Path
 import uuid
-import json
-from datetime import datetime
 import logging
 
 # Настройка логирования
@@ -17,18 +14,13 @@ logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 # Конфигурация
-MAX_PROCESS_TIMEOUT = 120 
+MAX_PROCESS_TIMEOUT = 120
 TEMP_BASE_DIR = Path("/tmp/video_processing")
 TEMP_BASE_DIR.mkdir(exist_ok=True, parents=True)
 
-# Глобальный кэш для отслеживания активных процессов
-active_processes = {}
-process_lock = asyncio.Lock()
-
-async def run_ffmpeg_async(cmd, timeout=300):
+async def run_ffmpeg_async(cmd, timeout=120):
     """Асинхронный запуск ffmpeg с таймаутом"""
     try:
-        # Используем asyncio для неблокирующего выполнения
         process = await asyncio.create_subprocess_exec(
             *cmd,
             stdout=asyncio.subprocess.PIPE,
@@ -49,35 +41,16 @@ async def run_ffmpeg_async(cmd, timeout=300):
             return stdout, stderr
             
         except asyncio.TimeoutError:
-            process.kill()
-            await process.wait()
+            try:
+                process.kill()
+            except:
+                pass
             raise Exception(f"FFmpeg timeout after {timeout} seconds")
             
     except Exception as e:
         logger.error(f"FFmpeg execution error: {e}")
         raise
 
-def cleanup_directory(directory, max_age_hours=1):
-    """Очистка старых временных файлов"""
-    try:
-        now = datetime.now()
-        for item in directory.iterdir():
-            try:
-                # Получаем время создания файла
-                stat = item.stat()
-                file_age = now - datetime.fromtimestamp(stat.st_ctime)
-                
-                if file_age.total_seconds() > max_age_hours * 3600:
-                    if item.is_file():
-                        item.unlink()
-                    else:
-                        shutil.rmtree(item)
-                        logger.info(f"Cleaned up old directory: {item}")
-            except Exception as e:
-                logger.warning(f"Failed to clean up {item}: {e}")
-    except Exception as e:
-        logger.error(f"Cleanup error: {e}")
-
 async def process_video_with_resources(start_video, job_id):
     """Обработка видео с изоляцией ресурсов"""
     # Создаем уникальную рабочую директорию для каждого задания
@@ -88,22 +61,25 @@ async def process_video_with_resources(start_video, job_id):
     input_path = work_dir / "input.mp4"
     audio_path = work_dir / "with_audio.mp4"
     blurred_path = work_dir / "blurred.mp4"
-    final_path1 = work_dir / "final1.mp4"
-    final_path2 = work_dir / "final2.mp4"
     
     try:
         # Шаг 1: Сохраняем входное видео
         if isinstance(start_video, str):
             shutil.copy(start_video, str(input_path))
         else:
-            # Для объектов Gradio
+            # Для объектов Gradio Video
             with open(input_path, "wb") as f:
-                if hasattr(start_video, "read"):
-                    f.write(start_video.read())
+                # Gradio Video возвращает временный файл
+                if hasattr(start_video, "name"):
+                    with open(start_video.name, "rb") as src:
+                        f.write(src.read())
                 else:
-                    start_video.save(f)
+                    # Fallback
+                    import io
+                    if isinstance(start_video, io.IOBase):
+                        f.write(start_video.read())
         
-        # Шаг 2: Добавляем аудио (параллельно с ограниченными ресурсами)
+        # Шаг 2: Добавляем аудио
         cmd_add_audio = [
             'ffmpeg',
             '-f', 'lavfi', 
@@ -112,13 +88,13 @@ async def process_video_with_resources(start_video, job_id):
             '-c:v', 'copy',
             '-c:a', 'aac',
             '-shortest',
-            '-threads', '1',  # Ограничиваем до 1 потока для лучшей масштабируемости
-            '-loglevel', 'quiet',  # Минимальное логирование
+            '-threads', '2',  # Используем 2 потока для баланса производительности
+            '-loglevel', 'error',
             '-y',
             str(audio_path)
         ]
         
-        await run_ffmpeg_async(cmd_add_audio, timeout=120)
+        await run_ffmpeg_async(cmd_add_audio, timeout=MAX_PROCESS_TIMEOUT)
         
         # Шаг 3: Применяем размытие
         cmd_blur = [
@@ -126,62 +102,53 @@ async def process_video_with_resources(start_video, job_id):
             '-i', str(audio_path),
             '-vf', 'gblur=sigma=25',
             '-c:a', 'copy',
-            '-threads', '1',
-            '-loglevel', 'quiet',
+            '-threads', '2',
+            '-loglevel', 'error',
             '-y',
             str(blurred_path)
         ]
         
-        await run_ffmpeg_async(cmd_blur, timeout=120)
-        
-        # Шаг 4: Копируем результаты в финальные файлы
-        shutil.copy(audio_path, final_path1)
-        shutil.copy(blurred_path, final_path2)
+        await run_ffmpeg_async(cmd_blur, timeout=MAX_PROCESS_TIMEOUT)
         
-        return str(final_path1), str(final_path2)
+        # Возвращаем пути к результатам
+        return str(audio_path), str(blurred_path)
         
     except Exception as e:
         logger.error(f"Processing error for job {job_id}: {e}")
+        
+        # Удаляем рабочую директорию в случае ошибки
+        try:
+            shutil.rmtree(work_dir)
+        except:
+            pass
+        
         raise
     finally:
-        # Очищаем промежуточные файлы, оставляя только финальные
+        # Удаляем только входной файл, результаты остаются
         try:
-            for file in [input_path, audio_path, blurred_path]:
-                if file.exists():
-                    file.unlink()
-        except Exception as e:
-            logger.warning(f"Failed to clean intermediate files: {e}")
+            if input_path.exists():
+                input_path.unlink()
+        except:
+            pass
 
+# Убрал декоратор @spaces.GPU - у Space нет GPU
 async def finalise_video(start_video):
     """Основная функция обработки видео"""
-    # Генерируем уникальный ID задания
     job_id = str(uuid.uuid4())
-    
-    async with process_lock:
-        active_processes[job_id] = datetime.now()
+    logger.info(f"Starting video processing job: {job_id}")
     
     try:
-        # Периодическая очистка старых файлов
-        cleanup_directory(TEMP_BASE_DIR, max_age_hours=1)
-        
         # Обрабатываем видео
         output_path1, output_path2 = await process_video_with_resources(
             start_video, job_id
         )
         
+        logger.info(f"Completed video processing job: {job_id}")
         return output_path1, output_path2
         
     except Exception as e:
         logger.error(f"Finalise video error: {e}")
         raise gr.Error(f"Ошибка обработки видео: {str(e)}")
-    finally:
-        # Удаляем задание из активных
-        async with process_lock:
-            if job_id in active_processes:
-                del active_processes[job_id]
-        
-        # Логируем статистику
-        logger.info(f"Active processes: {len(active_processes)}")
 
 def check_ffmpeg():
     """Проверка доступности ffmpeg"""
@@ -196,21 +163,43 @@ def check_ffmpeg():
     except Exception:
         return False
 
+def cleanup_old_files():
+    """Фоновая очистка старых файлов"""
+    try:
+        now = asyncio.get_event_loop().time()
+        for item in TEMP_BASE_DIR.iterdir():
+            try:
+                if item.is_dir():
+                    # Удаляем директории старше 1 часа
+                    stat = item.stat()
+                    dir_age = now - stat.st_ctime
+                    if dir_age > 3600:  # 1 час
+                        shutil.rmtree(item, ignore_errors=True)
+                        logger.info(f"Cleaned up old directory: {item}")
+            except Exception as e:
+                logger.warning(f"Failed to clean up {item}: {e}")
+    except Exception as e:
+        logger.error(f"Cleanup error: {e}")
+
+async def periodic_cleanup():
+    """Периодическая очистка старых файлов"""
+    while True:
+        await asyncio.sleep(3600)  # Каждый час
+        cleanup_old_files()
+
 # Создаем интерфейс Gradio
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("""
-    # Финализатор
-    """)
+    gr.Markdown("# Видео Финализатор")
     
     with gr.Row():
         with gr.Column(scale=1):
             input_video = gr.Video(
-                label="📹 Входное видео",
+                label="Входное видео",
                 interactive=True
             )
             
             process_btn = gr.Button(
-                "Финализировать",
+                "Обработать видео",
                 variant="primary",
                 size="lg"
             )
@@ -218,61 +207,47 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
         with gr.Column(scale=2):
             with gr.Row():
                 output1 = gr.Video(
-                    label="Video",
+                    label="Видео с аудио",
                     autoplay=True,
                     interactive=False
                 )
                 output2 = gr.Video(
-                    label="Video",
+                    label="Размытое видео",
                     autoplay=True,
                     interactive=False
                 )
     
-    # Обработчик с прогрессом
-    process_event = process_btn.click(
-        fn=finalise_video,
-        inputs=[input_video],
-        outputs=[output1, output2],
-        # Не устанавливаем concurrency_limit - не ограничиваем параллелизм
-    )
-    
-    # Добавляем обработку Enter
-    input_video.submit(
+    # Обработчик без ограничений параллелизма
+    process_btn.click(
         fn=finalise_video,
         inputs=[input_video],
         outputs=[output1, output2]
     )
-    
-    # Примеры
-    gr.Examples(
-        examples=[
-            ["https://example.com/sample1.mp4"],
-            ["https://example.com/sample2.mp4"],
-        ],
-        inputs=[input_video],
-        outputs=[output1, output2],
-        fn=finalise_video,
-        cache_examples=False  # Не кэшируем, чтобы обрабатывать каждый раз
-    )
 
 if __name__ == "__main__":
     # Проверяем ffmpeg
     if not check_ffmpeg():
         logger.error("FFmpeg не найден! Установите ffmpeg.")
-        raise RuntimeError("FFmpeg не установлен")
+        print("Ошибка: FFmpeg не установлен.")
+        print("Для установки в Hugging Face Spaces добавьте в README.md:")
+        print("```")
+        print("app_port: 7860")
+        print("sdk: gradio")
+        print("sdk_version: 4.0.0")
+        print("```")
+        print("И убедитесь, что ffmpeg установлен в системе.")
     
     # Запускаем с максимальной производительностью
+    # Нет ограничений на параллелизм - будьте осторожны!
     demo.queue(
         max_size=100,  # Большая очередь
-        default_concurrency_limit=None
+        default_concurrency_limit=None  # Без ограничений
     ).launch(
         server_name="0.0.0.0",
         server_port=7860,
         share=False,
-        # Настройки для высокой производительности
-        max_threads=40,
+        max_threads=100,  # Много потоков для обработки
         enable_queue=True,
         show_error=True,
-        debug=False,
-        ssl_verify=False
+        debug=False
     )