Update app.py

app.py

@@ -1,253 +1,82 @@
 import spaces
 import gradio as gr
 import tempfile
+import numpy as np
 import os
 import subprocess
 import shutil
-import asyncio
-from pathlib import Path
-import uuid
-import logging
+import ffmpeg
 
-# Настройка логирования
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-# Конфигурация
-MAX_PROCESS_TIMEOUT = 120
-TEMP_BASE_DIR = Path("/tmp/video_processing")
-TEMP_BASE_DIR.mkdir(exist_ok=True, parents=True)
-
-async def run_ffmpeg_async(cmd, timeout=120):
-    """Асинхронный запуск ffmpeg с таймаутом"""
-    try:
-        process = await asyncio.create_subprocess_exec(
-            *cmd,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE
-        )
-        
+def finalise_video(start_video):
+    if check_ffmpeg():
         try:
-            stdout, stderr = await asyncio.wait_for(
-                process.communicate(),
-                timeout=timeout
-            )
-            
-            if process.returncode != 0:
-                error_msg = stderr.decode() if stderr else "Unknown error"
-                logger.error(f"FFmpeg error: {error_msg}")
-                raise Exception(f"FFmpeg failed: {error_msg}")
-                
-            return stdout, stderr
-            
-        except asyncio.TimeoutError:
-            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
-
-async def process_video_with_resources(start_video, job_id):
-    """Обработка видео с изоляцией ресурсов"""
-    # Создаем уникальную рабочую директорию для каждого задания
-    work_dir = TEMP_BASE_DIR / job_id
-    work_dir.mkdir(exist_ok=True)
-    
-    # Пути к файлам
-    input_path = work_dir / "input.mp4"
-    audio_path = work_dir / "with_audio.mp4"
-    blurred_path = work_dir / "blurred.mp4"
-    
-    try:
-        # Шаг 1: Сохраняем входное видео
-        if isinstance(start_video, str):
-            shutil.copy(start_video, str(input_path))
-        else:
-            # Для объектов Gradio Video
-            with open(input_path, "wb") as f:
-                # Gradio Video возвращает временный файл
-                if hasattr(start_video, "name"):
-                    with open(start_video.name, "rb") as src:
-                        f.write(src.read())
+            with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as video_tmpfile:
+                if isinstance(start_video, str):
+                    shutil.copy(start_video, video_tmpfile.name)
                 else:
-                    # Fallback
-                    import io
-                    if isinstance(start_video, io.IOBase):
-                        f.write(start_video.read())
-        
-        # Шаг 2: Добавляем аудио
-        cmd_add_audio = [
-            'ffmpeg',
-            '-f', 'lavfi', 
-            '-i', 'anullsrc=channel_layout=stereo:sample_rate=44100',
-            '-i', str(input_path),
-            '-c:v', 'copy',
-            '-c:a', 'aac',
-            '-shortest',
-            '-threads', '2',  # Используем 2 потока для баланса производительности
-            '-loglevel', 'error',
-            '-y',
-            str(audio_path)
-        ]
-        
-        await run_ffmpeg_async(cmd_add_audio, timeout=MAX_PROCESS_TIMEOUT)
+                    start_video.save(video_tmpfile.name, format="MP4")
+                video_path = video_tmpfile.name
+            
+            with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as audio_tmpfile:
+                video_with_audio_path = audio_tmpfile.name
+            cmd = [
+                'ffmpeg',
+                '-f', 'lavfi', 
+                '-i', 'anullsrc=channel_layout=stereo:sample_rate=44100',
+                '-i', video_path,
+                '-c:v', 'copy',
+                '-c:a', 'aac',
+                '-shortest',
+                '-y',
+                video_with_audio_path
+            ]
         
-        # Шаг 3: Применяем размытие
-        cmd_blur = [
-            'ffmpeg',
-            '-i', str(audio_path),
-            '-vf', 'gblur=sigma=25',
-            '-c:a', 'copy',
-            '-threads', '2',
-            '-loglevel', 'error',
-            '-y',
-            str(blurred_path)
-        ]
+            subprocess.run(cmd, capture_output=True, check=True)
         
-        await run_ffmpeg_async(cmd_blur, timeout=MAX_PROCESS_TIMEOUT)
+            with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as blur_tmpfile:
+                blurred_video_path = blur_tmpfile.name
         
-        # Возвращаем пути к результатам
-        return str(audio_path), str(blurred_path)
+            cmd_blur = [
+                'ffmpeg',
+                '-i', video_with_audio_path,  # Используем видео с аудио как источник
+                '-vf', 'gblur=sigma=25',       # Гауссово размытие с sigma=5
+                '-c:a', 'copy',               # Копируем аудио без изменений
+                '-y',
+                blurred_video_path
+            ]
         
-    except Exception as e:
-        logger.error(f"Processing error for job {job_id}: {e}")
+            subprocess.run(cmd_blur, capture_output=True, check=True)
         
-        # Удаляем рабочую директорию в случае ошибки
-        try:
-            shutil.rmtree(work_dir)
-        except:
-            pass
+            os.unlink(video_path)
         
-        raise
-    finally:
-        # Удаляем только входной файл, результаты остаются
-        try:
-            if input_path.exists():
-                input_path.unlink()
-        except:
-            pass
-
-# Убрал декоратор @spaces.GPU - у Space нет GPU
-async def finalise_video(start_video):
-    """Основная функция обработки видео"""
-    job_id = str(uuid.uuid4())
-    logger.info(f"Starting video processing job: {job_id}")
+            return video_with_audio_path, blurred_video_path
+        except Exception as e:
+            print(f"Error finaliser: {e}")
+            return
+    else:
+        print("FFmpeg not available, returning video without audio")
+        return video_path, video_path, current_seed
     
-    try:
-        # Обрабатываем видео
-        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)}")
+with gr.Blocks() as demo:
+    gr.Markdown("Finaliser")
+    with gr.Row():
+        with gr.Column():
+            input_video_component = gr.Video(label="Input Video")
+            generate_button = gr.Button("Finalise", variant="primary")
+        with gr.Column():
+            video_output_1 = gr.Video(label="Generated Video", autoplay=True, interactive=False)
+            video_output_2 = gr.Video(label="Generated Video", autoplay=True, interactive=False)
+    
+    ui_inputs = [input_video_component]
+    generate_button.click(fn=finalise_video, inputs=ui_inputs, outputs=[video_output_1, video_output_2])
 
 def check_ffmpeg():
-    """Проверка доступности ffmpeg"""
     try:
-        result = subprocess.run(
-            ['ffmpeg', '-version'],
-            capture_output=True,
-            text=True,
-            timeout=5
-        )
-        return result.returncode == 0
-    except Exception:
+        subprocess.run(['ffmpeg', '-version'], capture_output=True, check=True)
+        return True
+    except (subprocess.CalledProcessError, FileNotFoundError):
         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("# Видео Финализатор")
-    
-    with gr.Row():
-        with gr.Column(scale=1):
-            input_video = gr.Video(
-                label="Входное видео",
-                interactive=True
-            )
-            
-            process_btn = gr.Button(
-                "Обработать видео",
-                variant="primary",
-                size="lg"
-            )
-            
-        with gr.Column(scale=2):
-            with gr.Row():
-                output1 = gr.Video(
-                    label="Видео с аудио",
-                    autoplay=True,
-                    interactive=False
-                )
-                output2 = gr.Video(
-                    label="Размытое видео",
-                    autoplay=True,
-                    interactive=False
-                )
-    
-    # Обработчик без ограничений параллелизма
-    process_btn.click(
-        fn=finalise_video,
-        inputs=[input_video],
-        outputs=[output1, output2]
-    )
 
 if __name__ == "__main__":
-    # Проверяем ffmpeg
-    if not check_ffmpeg():
-        logger.error("FFmpeg не найден! Установите 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  # Без ограничений
-    ).launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False,
-        max_threads=100,  # Много потоков для обработки
-        enable_queue=True,
-        show_error=True,
-        debug=False
-    )
+    demo.queue().launch(mcp_server=True)