Update app.py

app.py

@@ -1,487 +1,118 @@
+# main.py
 import gradio as gr
-import tempfile
+from fastapi import FastAPI, File, UploadFile, Form
+from fastapi.middleware.cors import CORSMiddleware
+import uvicorn
 import os
-import re
-from moviepy.editor import VideoFileClip, concatenate_videoclips, AudioFileClip, CompositeAudioClip, concatenate_audioclips
-import numpy as np
-import logging
-import sys
-import traceback
-import socket
+import tempfile
 import shutil
+import traceback
+import logging
+from merge_utils import merge_videos_and_audios  # move your merge logic to merge_utils.py for clean code!
 
-# Set up logging to debug issues
-logging.basicConfig(level=logging.INFO, handlers=[logging.StreamHandler(sys.stdout)])
+# Setup logging
+logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# --- Functions ---
-
-def check_port(port):
-    """
-    Check if a port is available.
-    Returns True if the port is free, False if it's in use.
-    """
-    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-        try:
-            s.bind(("0.0.0.0", port))
-            return True
-        except socket.error:
-            return False
-
-def sort_files_by_index(file_list, prefix_pattern):
-    """
-    Sort files based on their numerical index in the filename.
-    Args:
-        file_list: List of file paths (e.g., ['file2.mp4', 'file1.mp4', 'file3.mp4'])
-        prefix_pattern: Regex pattern to match the prefix and number (e.g., r'file(\d+)\.mp4')
-    Returns:
-        Sorted list of file paths
-    """
-    if not file_list:
-        return []
-    
-    def extract_index(filename):
-        match = re.match(prefix_pattern, os.path.basename(filename))
-        if match:
-            return int(match.group(1))
-        return float('inf')  # Invalid filenames go to the end
-    
-    sorted_files = sorted(file_list, key=extract_index)
-    logger.info(f"Sorted files: {sorted_files}")
-    return sorted_files
-
-def get_indices_string(file_list, prefix_pattern):
-    """
-    Extract the numerical indices from filenames and return as a string.
-    Args:
-        file_list: List of file paths
-        prefix_pattern: Regex pattern to match the prefix and number
-    Returns:
-        String of indices (e.g., '123' for ['file1.mp4', 'file2.mp4', 'file3.mp4'])
-    """
-    if not file_list:
-        return ""
-    indices = []
-    for filename in file_list:
-        match = re.match(prefix_pattern, os.path.basename(filename))
-        if match:
-            indices.append(match.group(1))
-    return "".join(indices)
-
-def split_files_by_extension(all_files):
-    """
-    Split a list of files into videos (.mp4) and audios (.mp3, .wav) based on extensions.
-    Args:
-        all_files: List of file paths (e.g., ['file1.mp4', 'audio1.mp3', 'file2.mp4', 'audio2.mp3'])
-    Returns:
-        Tuple of (video_files, audio_files)
-    """
-    video_files = []
-    audio_files = []
-    for file_path in all_files:
-        filename = os.path.basename(file_path).lower()
-        if filename.endswith('.mp4'):
-            video_files.append(file_path)
-        elif filename.endswith(('.mp3', '.wav')):
-            audio_files.append(file_path)
-        else:
-            logger.warning(f"Unsupported file extension for {file_path}; skipping")
-    return video_files, audio_files
-
-def trim_silence(audio_clip, threshold=0.005):
-    """
-    Trim silence from the start and end of an audio clip.
-    Args:
-        audio_clip: AudioFileClip object
-        threshold: Amplitude threshold below which audio is considered silent
-    Returns:
-        Trimmed AudioFileClip
-    """
-    try:
-        # Get audio data as numpy array
-        samples = audio_clip.to_soundarray(fps=44100)
-        # Compute amplitude (RMS)
-        if len(samples.shape) > 1:  # Stereo audio
-            amplitudes = np.sqrt(np.mean(samples**2, axis=1))
-        else:  # Mono audio
-            amplitudes = np.sqrt(samples**2)
-        
-        # Find non-silent regions
-        non_silent = amplitudes > threshold
-        if not np.any(non_silent):
-            logger.warning("Audio clip is completely silent; returning original clip")
-            return audio_clip
-        
-        # Find start and end indices
-        start_idx = np.argmax(non_silent)
-        end_idx = len(non_silent) - np.argmax(non_silent[::-1])
-        
-        # Convert indices to time (seconds)
-        start_time = start_idx / 44100
-        end_time = end_idx / 44100
-        
-        # Ensure the trimmed duration is reasonable
-        if end_time <= start_time:
-            logger.warning("Trimmed duration is zero or negative; returning original clip")
-            return audio_clip
-        
-        # Trim the audio
-        trimmed_audio = audio_clip.subclip(start_time, end_time)
-        logger.info(f"Trimmed audio from {start_time:.2f}s to {end_time:.2f}s (original duration: {audio_clip.duration:.2f}s)")
-        return trimmed_audio
-    except Exception as e:
-        logger.error(f"Error trimming silence: {str(e)}")
-        return audio_clip
-
-def merge_videos_and_audios(video_files=None, audio_files=None, orig_vol=1.0, music_vol=0.5, temp_dir=None):
-    """
-    Merge multiple video clips and/or audio clips based on inputs provided.
-    - If only video_files: Merge videos, retaining their original audio.
-    - If only audio_files: Merge audio files into a single audio file.
-    - If both: Merge videos and overlay the concatenated audio.
-    Files are sorted by numerical index in their filenames (e.g., file1.mp4, file2.mp4).
-    Args:
-        video_files: List of video file paths (optional)
-        audio_files: List of audio file paths (optional)
-        orig_vol: Volume for original video audio (0.0 to 1.0)
-        music_vol: Volume for background audio (0.0 to 1.0)
-        temp_dir: Temporary directory to clean up (optional)
-    Returns:
-        Path to the merged file (video or audio) or error message.
-    """
-    try:
-        # Sort files by numerical index
-        video_files = sort_files_by_index(video_files, r'file(\d+)\.mp4')
-        audio_files = sort_files_by_index(audio_files, r'audio(\d+)\.(mp3|wav)')
-        
-        # Get indices for output naming
-        video_indices = get_indices_string(video_files, r'file(\d+)\.mp4')
-        audio_indices = get_indices_string(audio_files, r'audio(\d+)\.(mp3|wav)')
-
-        # Ensure at least two files are provided (videos, audios, or combination)
-        video_count = len(video_files) if video_files else 0
-        audio_count = len(audio_files) if audio_files else 0
-        total_files = video_count + audio_count
-
-        logger.info(f"Starting merge with {video_count} video files and {audio_count} audio files")
-
-        if total_files < 2:
-            error_msg = "Error: Please upload at least 2 files total (videos, audios, or a combination)."
-            logger.error(error_msg)
-            return error_msg
-
-        # Create a temporary output path (use provided temp_dir if available)
-        if temp_dir is None:
-            temp_dir = tempfile.mkdtemp()
-        output_dir = temp_dir
-
-        # Case 1: Audio only
-        if audio_count >= 2 and video_count == 0:
-            output_filename = f"combined_audio_{audio_indices}.mp3"
-            output_path = os.path.join(output_dir, output_filename)
-            logger.info("Merging audio files only")
-            
-            # Load, normalize, and trim audio clips
-            audio_clips = []
-            for audio in audio_files:
-                clip = AudioFileClip(audio).set_fps(44100)  # Normalize sample rate
-                clip = clip.to_stereo() if clip.nchannels == 1 else clip  # Convert mono to stereo
-                logger.info(f"Original audio duration for {audio}: {clip.duration:.2f}s, channels: {clip.nchannels}")
-                trimmed_clip = trim_silence(clip)
-                if trimmed_clip.duration > 0:
-                    audio_clips.append(trimmed_clip)
-                else:
-                    logger.warning(f"Skipping audio file {audio} as it has zero duration after trimming")
-            
-            # Check if we have enough clips to concatenate
-            if len(audio_clips) < 2:
-                error_msg = "Error: Fewer than 2 audio clips available after trimming (clips may be silent or too short)."
-                logger.error(error_msg)
-                for clip in audio_clips:
-                    clip.close()
-                return error_msg
-            
-            # Log durations after trimming
-            for i, clip in enumerate(audio_clips):
-                logger.info(f"Trimmed audio {i+1} duration: {clip.duration:.2f}s, channels: {clip.nchannels}")
-            
-            # Concatenate audio clips
-            logger.info(f"Attempting to concatenate {len(audio_clips)} audio clips")
-            final_audio_clip = concatenate_audioclips(audio_clips)
-            logger.info(f"Concatenated audio duration: {final_audio_clip.duration:.2f}s, channels: {final_audio_clip.nchannels}")
-            
-            # Verify concatenated duration
-            expected_duration = sum(clip.duration for clip in audio_clips)
-            if abs(final_audio_clip.duration - expected_duration) > 0.1:
-                logger.warning(f"Concatenated duration ({final_audio_clip.duration:.2f}s) does not match expected duration ({expected_duration:.2f}s)")
-            
-            # Write the final audio
-            logger.info(f"Writing output audio to {output_path}")
-            final_audio_clip.write_audiofile(output_path, codec="mp3")
-            
-            # Close resources
-            final_audio_clip.close()
-            for clip in audio_clips:
-                clip.close()
-            
-            logger.info("Audio merge completed successfully")
-            return output_path
-
-        # Case 2: Video only or Video with Audio
-        if audio_indices:
-            output_filename = f"combined_video_{video_indices}_with_audio_{audio_indices}.mp4"
-        else:
-            output_filename = f"combined_video_{video_indices}.mp4"
-        output_path = os.path.join(output_dir, output_filename)
-        
-        # Load and concatenate video clips
-        video_clips = [VideoFileClip(video) for video in video_files]
-        final_video_clip = concatenate_videoclips(video_clips, method='compose')
-        
-        # Determine final video duration
-        video_duration = final_video_clip.duration or sum(clip.duration for clip in video_clips)
-        logger.info(f"Total video duration: {video_duration:.2f}s")
-        
-        # Handle audio (if provided)
-        if audio_files:
-            logger.info("Processing audio files")
-            # Load, normalize, and trim audio clips
-            audio_clips = []
-            for audio in audio_files:
-                clip = AudioFileClip(audio).set_fps(44100)  # Normalize sample rate
-                clip = clip.to_stereo() if clip.nchannels == 1 else clip  # Convert mono to stereo
-                logger.info(f"Original audio duration for {audio}: {clip.duration:.2f}s, channels: {clip.nchannels}")
-                trimmed_clip = trim_silence(clip)
-                if trimmed_clip.duration > 0:
-                    audio_clips.append(trimmed_clip)
-                else:
-                    logger.warning(f"Skipping audio file {audio} as it has zero duration after trimming")
-            
-            # Log durations after trimming
-            for i, clip in enumerate(audio_clips):
-                logger.info(f"Trimmed audio {i+1} duration: {clip.duration:.2f}s, channels: {clip.nchannels}")
-            
-            if not audio_clips:
-                logger.warning("No valid audio clips after trimming; using original video audio only")
-                final_audio = final_video_clip.audio.volumex(orig_vol) if final_video_clip.audio else None
-            else:
-                # Concatenate audio clips
-                logger.info(f"Attempting to concatenate {len(audio_clips)} audio clips")
-                concatenated_audio = concatenate_audioclips(audio_clips)
-                logger.info(f"Concatenated audio duration: {concatenated_audio.duration:.2f}s, channels: {concatenated_audio.nchannels}")
-                
-                # Verify concatenated duration
-                expected_duration = sum(clip.duration for clip in audio_clips)
-                if abs(concatenated_audio.duration - expected_duration) > 0.1:
-                    logger.warning(f"Concatenated duration ({concatenated_audio.duration:.2f}s) does not match expected duration ({expected_duration:.2f}s)")
-                
-                # Adjust concatenated audio duration to match video duration (trim or loop)
-                if concatenated_audio.duration > video_duration:
-                    concatenated_audio = concatenated_audio.subclip(0, video_duration)
-                    logger.info(f"Trimmed concatenated audio to match video duration: {concatenated_audio.duration:.2f}s")
-                elif concatenated_audio.duration < video_duration:
-                    # Loop the audio to match video duration
-                    concatenated_audio = concatenated_audio.fx(lambda clip: clip.loop(duration=video_duration))
-                    logger.info(f"Looped concatenated audio to match video duration: {concatenated_audio.duration:.2f}s")
-                
-                # Apply volume to concatenated audio
-                concatenated_audio = concatenated_audio.volumex(music_vol)
-                
-                # Get original video audio (if any) and apply volume
-                original_audio = final_video_clip.audio.volumex(orig_vol) if final_video_clip.audio else None
-                
-                # Composite the audio tracks
-                if original_audio:
-                    final_audio = CompositeAudioClip([original_audio, concatenated_audio])
-                else:
-                    final_audio = concatenated_audio
-        else:
-            logger.info("No audio files provided; using original video audio if available")
-            # If no audio files provided, retain original video audio (if any)
-            final_audio = final_video_clip.audio.volumex(orig_vol) if final_video_clip.audio else None
-        
-        # Set the audio to the final video
-        final_video_clip = final_video_clip.set_audio(final_audio)
-        
-        # Write the final video
-        logger.info(f"Writing output video to {output_path}")
-        final_video_clip.write_videofile(output_path, codec="libx264", fps=30, audio_codec="aac", ffmpeg_params=["-preset", "fast"])
-        
-        # Close resources
-        final_video_clip.close()
-        for clip in video_clips:
-            clip.close()
-        if audio_files and audio_clips:
-            for clip in audio_clips:
-                clip.close()
-            if 'concatenated_audio' in locals():
-                concatenated_audio.close()
-        
-        logger.info("Video merge completed successfully")
-        return output_path
-    except Exception as e:
-        error_msg = f"Error during merging: {str(e)}\n{traceback.format_exc()}"
-        logger.error(error_msg)
-        return error_msg
-    finally:
-        # Clean up temporary directory if it was created in this function
-        if temp_dir and os.path.exists(temp_dir):
-            try:
-                shutil.rmtree(temp_dir)
-                logger.info(f"Cleaned up temporary directory: {temp_dir}")
-            except Exception as e:
-                logger.warning(f"Failed to clean up temporary directory {temp_dir}: {str(e)}")
-
-# --- Gradio App Using Blocks ---
-
-def gradio_merge_files(file_binaries, orig_vol, music_vol, file_names=None):
-    """
-    Gradio endpoint to merge videos and/or audio from binary file uploads.
-    Args:
-        file_binaries: List of binary data (bytes objects)
-        orig_vol: Volume for original video audio (0.0 to 1.0)
-        music_vol: Volume for background audio (0.0 to 1.0)
-        file_names: List of original filenames (passed separately for API calls)
-    Returns:
-        Path to the merged file (video or audio) or error message
-    """
+# --- FASTAPI SETUP ---
+fastapi_app = FastAPI(title="Video & Audio Merger API")
+
+# CORS for n8n to call the API
+fastapi_app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # You can restrict to your domain if needed
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# FastAPI endpoint to accept binary files from n8n
+@fastapi_app.post("/merge")
+async def merge_endpoint(
+    files: list[UploadFile] = File(...),
+    orig_vol: float = Form(1.0),
+    music_vol: float = Form(0.5),
+):
     try:
-        logger.info(f"Received {len(file_binaries) if file_binaries else 0} binary files")
-        
-        if not file_binaries or len(file_binaries) < 2:
-            error_msg = "Error: Please upload at least 2 files."
-            logger.error(error_msg)
-            return error_msg, None
+        logger.info(f"Received {len(files)} files from n8n")
 
-        # Create a temporary directory to store uploaded files
+        # Save files to temp dir
         temp_dir = tempfile.mkdtemp()
-        all_files = []
-
-        # When called via the UI, Gradio provides binary data but not filenames directly.
-        # When called via API (e.g., n8n), we need to get filenames from the request.
-        # For UI testing, infer filenames based on index; for API, use provided file_names.
-        if file_names is None:
-            # Fallback for UI: assign temporary filenames (not ideal for production)
-            file_names = []
-            for idx, binary in enumerate(file_binaries):
-                ext = ".mp4" if idx % 2 == 0 else ".mp3"  # Dummy assignment for UI testing
-                file_names.append(f"temp_file_{idx}{ext}")
-            logger.warning("No file names provided; using temporary names for UI testing. For API calls, pass file_names.")
-
-        if len(file_names) != len(file_binaries):
-            error_msg = f"Error: Mismatch between file binaries ({len(file_binaries)}) and file names ({len(file_names)})."
-            logger.error(error_msg)
-            return error_msg, None
-
-        # Save each binary file to the temporary directory
-        for binary, filename in zip(file_binaries, file_names):
-            if binary is None:
-                logger.warning(f"Skipping None binary data for file {filename}")
-                continue
-            # Validate filename
-            original_filename = os.path.basename(filename)
-            if not re.match(r'file\d+\.mp4', original_filename, re.IGNORECASE) and \
-               not re.match(r'audio\d+\.(mp3|wav)', original_filename, re.IGNORECASE):
-                logger.warning(f"Filename {original_filename} does not match expected pattern; skipping")
-                continue
-            # Create a temporary file path
-            temp_file_path = os.path.join(temp_dir, original_filename)
-            # Write the binary data to the temporary file
-            with open(temp_file_path, 'wb') as temp_file:
-                temp_file.write(binary)
-            all_files.append(temp_file_path)
-            logger.info(f"Saved uploaded file to {temp_file_path}")
-
-        if len(all_files) < 2:
-            error_msg = "Error: Fewer than 2 valid files after filtering."
-            logger.error(error_msg)
-            return error_msg, None
-
-        # Split files into videos and audios based on extensions
-        video_files, audio_files = split_files_by_extension(all_files)
-        logger.info(f"Identified {len(video_files)} video files: {video_files}")
-        logger.info(f"Identified {len(audio_files)} audio files: {audio_files}")
-        
-        result = merge_videos_and_audios(
+        saved_files = []
+
+        for upload_file in files:
+            filename = os.path.basename(upload_file.filename)
+            file_path = os.path.join(temp_dir, filename)
+            with open(file_path, "wb") as f:
+                content = await upload_file.read()
+                f.write(content)
+            saved_files.append(file_path)
+            logger.info(f"Saved file: {file_path}")
+
+        # Split files into video and audio
+        video_files = [f for f in saved_files if f.lower().endswith(".mp4")]
+        audio_files = [f for f in saved_files if f.lower().endswith((".mp3", ".wav"))]
+
+        # Run merge
+        output_path = merge_videos_and_audios(
             video_files=video_files,
             audio_files=audio_files,
             orig_vol=orig_vol,
             music_vol=music_vol,
-            temp_dir=temp_dir
+            temp_dir=temp_dir,
         )
-        
-        if isinstance(result, str) and result.startswith("Error"):
-            logger.error(result)
-            return result, None
-        else:
-            logger.info(f"Merge successful. Output saved at: {result}")
-            # Return appropriate output based on file type
-            if result.endswith(".mp3"):
-                return None, result  # Audio output
-            else:
-                return result, None  # Video output
-    except Exception as e:
-        error_msg = f"Error processing files: {str(e)}\n{traceback.format_exc()}"
-        logger.error(error_msg)
-        return error_msg, None
-    finally:
-        # Cleanup is handled in merge_videos_and_audios
-        pass
 
-# --- Main Execution ---
+        # Return result as path or error
+        if isinstance(output_path, str) and output_path.startswith("Error"):
+            return {"success": False, "error": output_path}
 
-if __name__ == "__main__":
-    logger.info(f"Environment: {os.environ.get('HUGGINGFACE_SPACES', 'Not in HF Spaces')}")
-    logger.info(f"Arguments: {sys.argv}")
-    
-    # Check ports in a wider range
-    default_port = 7860
-    ports_to_try = list(range(default_port, default_port + 11))  # 7860 to 7870
-    
-    selected_port = None
-    for port in ports_to_try:
-        logger.info(f"Checking if port {port} is available")
-        if check_port(port):
-            logger.info(f"Port {port} is available")
-            selected_port = port
-            break
-        else:
-            logger.warning(f"Port {port} is already in use")
-    
-    if selected_port is None:
-        logger.error("No available ports found in range 7860-7870")
-        sys.exit(1)
+        # Move output to persistent location (optional)
+        public_output_dir = "./outputs"
+        os.makedirs(public_output_dir, exist_ok=True)
+        final_output_path = os.path.join(public_output_dir, os.path.basename(output_path))
+        shutil.move(output_path, final_output_path)
+        logger.info(f"Final output moved to {final_output_path}")
 
-    logger.info("Launching Gradio Blocks interface")
-
-    with gr.Blocks(title="Video and Audio Merger API") as app:
-        gr.Markdown("## Video and Audio Merger API")
-        gr.Markdown("Upload at least 2 files total (videos, audios, or a combination) to merge them.")
-        gr.Markdown("For API usage, send binary files via multipart/form-data. Name videos as file1.mp4, file2.mp4, etc., and audios as audio1.mp3, audio2.mp3, etc.")
-        
-        with gr.Row():
-            file_input = gr.File(label="Upload Files (Videos: .mp4, Audios: .mp3/.wav)", type="binary", file_count="multiple")
-        
-        with gr.Row():
-            orig_vol_input = gr.Slider(minimum=0.0, maximum=1.0, value=1.0, step=0.05, label="Original Video Audio Volume")
-            music_vol_input = gr.Slider(minimum=0.0, maximum=1.0, value=0.5, step=0.05, label="Background Audio Volume")
-        
-        output_video = gr.Video(label="Merged Video (if videos provided)")
-        output_audio = gr.Audio(label="Merged Audio (if only audios provided)")
-        merge_button = gr.Button("Merge Files")
-        
-        merge_button.click(
-            fn=gradio_merge_files,
-            inputs=[file_input, orig_vol_input, music_vol_input],
-            outputs=[output_video, output_audio]
-        )
+        return {
+            "success": True,
+            "output_url": f"/outputs/{os.path.basename(final_output_path)}"
+        }
 
-    try:
-        logger.info(f"Attempting to launch Gradio app on port {selected_port}")
-        app.queue(api_open=True)
-        app.launch(server_port=selected_port, share=True)
-        logger.info(f"Gradio app launched successfully on port {app.server_port}")
     except Exception as e:
-        error_msg = f"Failed to launch Gradio interface: {str(e)}\n{traceback.format_exc()}"
+        error_msg = f"Exception: {str(e)}\n{traceback.format_exc()}"
         logger.error(error_msg)
-        raise
+        return {"success": False, "error": error_msg}
+
+# --- GRADIO SETUP ---
+with gr.Blocks(title="Video and Audio Merger UI") as gradio_app:
+    gr.Markdown("## Video and Audio Merger")
+    file_input = gr.File(label="Upload Files", type="binary", file_count="multiple")
+    orig_vol_input = gr.Slider(minimum=0.0, maximum=1.0, value=1.0, step=0.05, label="Original Video Audio Volume")
+    music_vol_input = gr.Slider(minimum=0.0, maximum=1.0, value=0.5, step=0.05, label="Background Audio Volume")
+    output_video = gr.Video(label="Merged Video")
+    output_audio = gr.Audio(label="Merged Audio")
+    merge_button = gr.Button("Merge Files")
+
+    def gradio_merge_files(file_binaries, orig_vol, music_vol):
+        # You can call your existing function here (same as before)
+        pass  # Keep your old gradio_merge_files() here!
+
+    merge_button.click(
+        fn=gradio_merge_files,
+        inputs=[file_input, orig_vol_input, music_vol_input],
+        outputs=[output_video, output_audio],
+    )
+
+# --- COMBINE BOTH ---
+if __name__ == "__main__":
+    import threading
+
+    # Run FastAPI server in background
+    def run_fastapi():
+        uvicorn.run(fastapi_app, host="0.0.0.0", port=8000)
+
+    threading.Thread(target=run_fastapi).start()
+
+    # Run Gradio app on another port (HuggingFace will pick this)
+    gradio_app.queue(api_open=True)
+    gradio_app.launch(server_port=7860, share=True)