Update app.py

app.py

@@ -1,159 +1,107 @@
-"""Media Converter – Gradio Space
-
-This file defines a full-featured media‑conversion Gradio Space that can also
-expose its core Python utilities via the MCP protocol (``demo.launch(...,
- mcp_server=True)``).  The code is a **verbatim rewrite** of the user‑supplied
-script but now includes:
-
-* Fully‑typed function signatures
-* Clear, Google‑style docstrings so the MCP schema shows descriptions instead of
-  “No description provided in function docstring”.
-* Single, explicit ``gr.api()`` registrations so each logical tool appears only
-  once (stopping the auto‑generated ``func_``, ``func__`` duplicates Gradio
-  otherwise adds when the same callable is wired to multiple UI events).
-* A couple of syntax / runtime fixes (missing parenthesis in ``CommandBuilder``
-  call, forward reference for the ``ffmpeg_commands`` global).
-
-No logic, imports, or UI components have been removed, shortened, or skipped.
-"""
-
-from __future__ import annotations
-
-# ──────────────────────────────────────────────────────────────────────────────
-# Standard / external imports
-# ──────────────────────────────────────────────────────────────────────────────
+# File: app.py
 
 import logging
 import subprocess
-from pathlib import Path
-from pprint import pprint  # noqa: F401 (handy for local debugging, left intact)
+from pprint import pprint
 from tempfile import _TemporaryFileWrapper
-from typing import Any, Tuple
 
-import gradio as gr
 from ffmpy import FFmpeg, FFRuntimeError
+import gradio as gr
 
-# Project‑local helpers – unchanged from the original submission.
 from functions import (
     Clear,
     CommandBuilder,
-    VF,
     audio_channels,
     audio_codecs,
     audio_quality,
     audio_sample_rates,
     change_clipbox,
     containers,
+    set_custom_bitrate,
     media_change,
     presets,
-    set_custom_bitrate,
     supported_codecs,
     supported_presets,
     video_codecs,
+    VF,
 )
 
-# ──────────────────────────────────────────────────────────────────────────────
-# Global configuration
-# ──────────────────────────────────────────────────────────────────────────────
-
+# ─── Configure logging level ───────────────────────────────────────────────────
 logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger("media‑converter")
 
-# This variable will be initialised later (see bottom of file) but must exist at
-# module import time so that ``convert()`` can type‑check & reference it.
-ffmpeg_commands: "CommandBuilder" | None = None  # noqa: ANN401
-
-# ──────────────────────────────────────────────────────────────────────────────
-# Core MCP‑exposed function
-# ──────────────────────────────────────────────────────────────────────────────
 
 def convert(
-    file: _TemporaryFileWrapper | None,
+    file: _TemporaryFileWrapper,
     container_format: str,
-    state: str,
-) -> Tuple[str | None, str | None, str | None, str, str]:
-    """Transcode an uploaded media file into a new container using FFmpeg.
+    prev_state: str
+) -> tuple[str, str, str, str, str]:
+    """
+    Convert the given media file to a new container format using FFmpeg.
 
     Args:
-        file: Temporary file handle supplied by Gradio's ``File`` component –
-            can be *None* when the user presses *Convert* without selecting a
-            file.
-        container_format: Desired output extension / container (e.g. ``"mp4"``).
-        state: A filename string preserved in a hidden ``gr.State`` so that the
-            *Video*, *Audio*, and *File* buttons know which asset to reveal.
+        file (_TemporaryFileWrapper): Uploaded input file wrapper (has .name).
+        container_format (str): Target container format (e.g., "mp4", "mp3").
+        prev_state (str): Previous state token (for UI chaining).
 
     Returns:
-        audio_path: Filesystem path to an audio‑only rendition (or *None*).
-        file_path: Filesystem path for a direct download link (or *None*).
-        video_path: Filesystem path to a video preview (or *None*).
-        ffmpeg_cmd: The exact FFmpeg command executed – surfaced to the user for
-            transparency / debugging.
-        new_state: Updated state string (usually the new output filename).
-
-    Notes:
-        * Relies on the global ``ffmpeg_commands`` variable that is built after
-          the UI components are instantiated.
-        * Uses ``ffmpy`` so that users on HF Spaces don't need raw shell access.
+        Tuple containing:
+          - audio_output_path (str)
+          - file_output_path (str)
+          - video_output_path (str)
+          - ffmpeg command run (str)
+          - new state token (str)
     """
-
+    # If no file was uploaded, bail out immediately
     if file is None:
-        logger.error("No file provided for conversion.")
-        return None, None, None, "No file provided", state
-
-    if ffmpeg_commands is None:  # This *should* never happen.
-        err_msg = "Internal error: FFmpeg command builder not initialised."
-        logger.error(err_msg)
-        return None, None, None, err_msg, state
-
-    # Derive output path – keep original stem and add "1" to avoid overwrite.
-    input_path = Path(file.name)
-    output_path = input_path.with_suffix("").with_suffix("")
-    output_path = output_path.with_name(output_path.name + "1").with_suffix(
-        f".{container_format.lower()}"
-    )
-
-    # Build the command via ffmpy.
-    ffmpeg = FFmpeg(
-        inputs={str(input_path): None},
-        outputs={str(output_path): ffmpeg_commands.commands.split()},
-        global_options=["-y", "-hide_banner"],
-    )
-
-    # A second FFmpeg instance is created purely to show a *clean* command where
-    # the filenames are placeholders – matches original behaviour.
-    ffmpeg_display = FFmpeg(
-        inputs={"input_file": None},
-        outputs={f"output_file.{container_format.lower()}": ffmpeg_commands.commands.split()},
-        global_options=["-y", "-hide_banner"],
-    )
+        logging.error("No file provided for conversion.")
+        return [None, None, None, "No file provided", prev_state]
 
     try:
-        ffmpeg.run(stderr=subprocess.PIPE)
-        cmd_output = ffmpeg_display.cmd  # What we show the user
-    except FFRuntimeError as exc:
-        logger.error("FFmpeg execution failed: %s", exc)
-        return None, None, None, exc.stderr.decode(), state
-
-    # Decide which UI component(s) should become visible based on the suffix.
-    audio_out = str(output_path) if output_path.suffix in {".mp3", ".wav"} else None
-    video_out = str(output_path) if output_path.suffix in {".mp4", ".mov"} else None
-
-    new_state = str(output_path)
-    return audio_out, str(output_path), video_out, cmd_output, new_state
-
-
-# ──────────────────────────────────────────────────────────────────────────────
-# UI / components
-# ──────────────────────────────────────────────────────────────────────────────
-
-CSS = """
+        # Extract base filename (without extension)
+        logging.info("File name: %s", file.name)
+        new_name, _ = file.name.rsplit(".", 1)
+        output_file = f"{new_name}_converted.{container_format.lower()}"
+
+        # Build FFmpeg command
+        ffmpeg_cmd_builder = FFmpeg(
+            inputs={file.name: None},
+            outputs={output_file: None},
+            global_options=["-y", "-hide_banner"],
+        )
+        print(ffmpeg_cmd_builder)       # Debug: FFmpeg object
+        print(ffmpeg_cmd_builder.cmd)   # Debug: actual shell command
+
+        # Run conversion
+        ffmpeg_cmd_builder.run(stderr=subprocess.PIPE)
+        ffmpeg_command_str = ffmpeg_cmd_builder.cmd
+
+    except FFRuntimeError as e:
+        # On error, decode stderr and return it as output_text
+        error_msg = e.stderr.decode()
+        print(error_msg, flush=True)
+        return [None, None, None, error_msg, prev_state]
+
+    # Update state and return all paths/outputs
+    new_state = output_file
+    return [
+        output_file,         # audio_output_path
+        output_file,         # file_output_path
+        output_file,         # video_output_path
+        ffmpeg_command_str,  # ffmpeg command run
+        new_state            # new state token
+    ]
+
+
+# ─── Custom CSS for the app ────────────────────────────────────────────────────
+css = """
 body {
   background: var(--body-background-fill);
 }
 """
 
+# ─── Build the Gradio interface ────────────────────────────────────────────────
 with gr.Blocks(
-    css=CSS,
+    css=css,
     theme=gr.themes.Soft(
         primary_hue=gr.themes.colors.green,
         secondary_hue=gr.themes.colors.amber,
@@ -161,71 +109,70 @@ with gr.Blocks(
         font=["sans-serif"],
     ),
 ) as demo:
-    """Top‑level Gradio UI definition."""
-
-    # ─── Tabs – Format / Video / Audio / Filters ────────────────────────────
 
     with gr.Tabs(selected="format", elem_classes="tabs"):
-        # ──────────────────────────────
-        # FORMAT TAB
-        # ──────────────────────────────
+
+        # ── Format Tab ────────────────────────────────────────────────────────
         with gr.Tab("Format", id="format"):
-            # INPUT area
+
             with gr.Row():
                 with gr.Column() as inputs:
-                    file_input = gr.File()
+                    file_input = gr.File(label="Upload File")  # upload control
                     options = gr.Radio(
-                        label="options", choices=containers, value=containers[0]
+                        label="Container Format",
+                        choices=containers,
+                        value=containers[0],
                     )
-                    # Optional clip box widgets
-                    with gr.Row():
-                        with gr.Row() as inputs_clip:
-                            clip = gr.Dropdown(
-                                choices=["None", "Enabled"],
-                                label="Clip:",
-                                value="None",
-                            )
-                            start_time = gr.Textbox(
-                                label="Start Time:",
-                                placeholder="00:00",
-                                visible=False,
-                                interactive=True,
-                            )
-                            stop_time = gr.Textbox(
-                                label="Stop Time:",
-                                placeholder="00:00",
-                                visible=False,
-                                interactive=True,
-                            )
+
+                    with gr.Row() as inputs_clip:
+                        clip = gr.Dropdown(
+                            choices=["None", "Enabled"], label="Clip:", value="None"
+                        )
+                        start_time = gr.Textbox(
+                            label="Start Time", placeholder="00:00", visible=False
+                        )
+                        stop_time = gr.Textbox(
+                            label="Stop Time", placeholder="00:00", visible=False
+                        )
+
                     with gr.Row():
-                        clearBtn = gr.Button("Clear")
-                        convertBtn = gr.Button("Convert", variant="primary")
+                        clearBtn = gr.Button("Clear")               # reset inputs
+                        convertBtn = gr.Button("Convert", variant="primary")  # run conversion
 
-                # OUTPUT area
                 with gr.Column():
+                    # Output modality buttons
                     video_button = gr.Button("Video")
                     audio_button = gr.Button("Audio")
-                    file_button = gr.Button("File")
+                    file_button  = gr.Button("File")
 
-                    media_output_audio = gr.Audio(
-                        type="filepath", label="Audio", visible=False, interactive=False
-                    )
+                    # Output components, initially hidden/shown appropriately
+                    media_output_audio = gr.Audio(type="filepath", label="Audio", visible=False)
                     media_output_video = gr.Video(label="Video", visible=True, height=300)
-                    media_output_file = gr.File(label="File", visible=False)
+                    media_output_file  = gr.File(label="File", visible=False)
 
                     output_textbox = gr.Code(
                         value="$ echo 'Hello, World!'",
-                        label="command",
+                        label="FFmpeg Command",
                         language="shell",
                         elem_id="outputtext",
                     )
 
-                # Wipe helpers
+                # Instantiate and wire up clear/reset behavior
                 resetFormat = Clear(inputs, inputs_clip)
+                clearBtn.click(
+                    fn=resetFormat.clear,
+                    inputs=resetFormat(),
+                    outputs=resetFormat(),
+                    api_name="reset_format_tab",
+                    description="Clear all inputs in the Format tab"
+                )
+
+                # Persistent state token for chaining
                 state = gr.State()
-                clearBtn.click(resetFormat.clear, resetFormat(), resetFormat())
+
+                # Convert button → convert_media tool
                 convertBtn.click(
-                    convert,
+                    fn=convert,
                     inputs=[file_input, options, state],
                     outputs=[
                         media_output_audio,
@@ -234,130 +181,137 @@ with gr.Blocks(
                         output_textbox,
                         state,
                     ],
+                    api_name="convert_media",
+                    description="Convert an uploaded file to the selected format via FFmpeg"
                 )
 
-        # ──────────────────────────────
-        # VIDEO TAB
-        # ──────────────────────────────
+        # ── Video Tab ─────────────────────────────────────────────────────────
         with gr.Tab("Video", id="video"):
             with gr.Row() as video_inputs:
                 video_options = gr.Dropdown(
-                    label="video", choices=video_codecs, value=video_codecs[-1]
+                    label="Video Codec", choices=video_codecs, value=video_codecs[-1]
                 )
                 preset_options = gr.Dropdown(
-                    choices=presets, label="presets", value=presets[-1]
+                    label="Preset", choices=presets, value=presets[-1]
                 )
 
-            with gr.Row(elem_id="button"):
-                with gr.Column():
-                    clearBtn = gr.Button("Clear")
-                videoReset = Clear(video_inputs)
-                clearBtn.click(videoReset.clear, videoReset(), videoReset())
-
-        # ──────────────────────────────
-        # AUDIO TAB
-        # ──────────────────────────────
+            clearVidBtn = gr.Button("Clear")  # reset video-specific inputs
+            videoReset = Clear(video_inputs)
+            clearVidBtn.click(
+                fn=videoReset.clear,
+                inputs=videoReset(),
+                outputs=videoReset(),
+                api_name="reset_video_tab",
+                description="Clear all inputs in the Video tab"
+            )
+
+        # ── Audio Tab ─────────────────────────────────────────────────────────
         with gr.Tab("Audio", id="audio"):
             with gr.Row() as audio_inputs:
                 audio_options = gr.Dropdown(
-                    label="audio", choices=audio_codecs, value=audio_codecs[-1]
+                    label="Audio Codec", choices=audio_codecs, value=audio_codecs[-1]
                 )
                 audio_bitrate = gr.Dropdown(
-                    choices=audio_quality, label="Audio Qualities", value=audio_quality[0]
+                    label="Audio Quality", choices=audio_quality, value=audio_quality[0]
+                )
+                custom_bitrate = gr.Number(
+                    label="Custom Bitrate", visible=False
                 )
-                custom_bitrate = gr.Number(label="Audio Qualities", visible=False)
                 gr.Dropdown(
-                    choices=audio_channels, label="Audio Channels", value=audio_channels[0]
+                    label="Audio Channels", choices=audio_channels, value=audio_channels[0]
                 )
                 gr.Dropdown(
-                    choices=audio_sample_rates, label="Sample Rates", value=audio_sample_rates[0]
+                    label="Sample Rate", choices=audio_sample_rates, value=audio_sample_rates[0]
                 )
 
-            with gr.Column(elem_id="button"):
-                clearBtn = gr.Button("Clear")
+            clearAudBtn = gr.Button("Clear")
             audioReset = Clear(audio_inputs)
-            clearBtn.click(audioReset.clear, audioReset(), audioReset())
-
-        # ──────────────────────────────
-        # FILTERS TAB
-        # ──────────────────────────────
+            clearAudBtn.click(
+                fn=audioReset.clear,
+                inputs=audioReset(),
+                outputs=audioReset(),
+                api_name="reset_audio_tab",
+                description="Clear all inputs in the Audio tab"
+            )
+
+        # ── Filters Tab ────────────────────────────────────────────────────────
         with gr.Tab("Filters", id="filters") as filter_inputs:
-            gr.Markdown("## Video")
-            with gr.Row(equal_height=True) as filter_inputs:
-                for vf_category in VF:
-                    values = list(vf_category.values())[0]
-                    choices = [item.get("name") for item in values]
-                    gr.Dropdown(
-                        label=str(list(vf_category.keys())[0]),
-                        choices=choices,
-                        value=choices[0],
-                    )
-            gr.Markdown("## Audio")
-            with gr.Row(elem_id="acontrast") as filter_inputs_1:
-                gr.Slider(label="Acontrast", elem_id="acontrast")
-
-            with gr.Column(elem_id="button"):
-                clearBtn = gr.Button("Clear")
-            filterReset = Clear(filter_inputs, filter_inputs_1)
-            clearBtn.click(filterReset.clear, filterReset(), filterReset())
-
-    # ──────────────────────────────────────────────────────────────────────
-    # Inter‑component wiring (dynamic behaviour)
-    # ──────────────────────────────────────────────────────────────────────
-
-    clip.change(fn=change_clipbox, inputs=clip, outputs=[start_time, stop_time])
-
-    options.change(supported_codecs, [options], [video_options, audio_options])
-
-    audio_button.click(
-        media_change,
-        [audio_button, state],
-        [media_output_audio, media_output_video, media_output_file],
-    )
-    video_button.click(
-        media_change,
-        [video_button, state],
-        [media_output_audio, media_output_video, media_output_file],
-    )
-    file_button.click(
-        media_change,
-        [file_button, state],
-        [media_output_audio, media_output_video, media_output_file],
+            gr.Markdown("## Video Filters")
+            with gr.Row(equal_height=True):
+                for vf in VF:
+                    # each filter group → dropdown
+                    name = list(vf.keys())[0]
+                    choices = [opt["name"] for opt in vf[name]]
+                    gr.Dropdown(label=name, choices=choices, value=choices[0])
+
+            gr.Markdown("## Audio Filters")
+            acontrastSlider = gr.Slider(label="Audio Contrast")
+
+            clearFltBtn = gr.Button("Clear")
+            filterReset = Clear(filter_inputs, acontrastSlider)
+            clearFltBtn.click(
+                fn=filterReset.clear,
+                inputs=filterReset(),
+                outputs=filterReset(),
+                api_name="reset_filters_tab",
+                description="Clear all inputs in the Filters tab"
+            )
+
+    # ─── Cross-tab event listeners ───────────────────────────────────────────────
+    clip.change(
+        fn=change_clipbox,
+        inputs=[clip],
+        outputs=[start_time, stop_time],
+        api_name="toggle_clip_inputs",
+        description="Show or hide clip time fields when Clip option changes"
     )
 
-    # Video‑tab dynamic presets
-    video_options.change(supported_presets, [video_options], [preset_options])
+    options.change(
+        fn=supported_codecs,
+        inputs=[options],
+        outputs=[video_options, audio_options],
+        api_name="update_codecs",
+        description="Update available video/audio codecs when container format changes"
+    )
 
-    # Audio‑tab dynamic bitrate field
-    audio_bitrate.change(set_custom_bitrate, [audio_bitrate], [custom_bitrate])
+    video_options.change(
+        fn=supported_presets,
+        inputs=[video_options],
+        outputs=[preset_options],
+        api_name="update_presets",
+        description="Refresh preset list when video codec changes"
+    )
 
-    # ──────────────────────────────────────────────────────────────────────
-    # FFmpeg command builder (global) + listener hookup
-    # ──────────────────────────────────────────────────────────────────────
+    audio_bitrate.change(
+        fn=set_custom_bitrate,
+        inputs=[audio_bitrate],
+        outputs=[custom_bitrate],
+        api_name="set_custom_bitrate",
+        description="Toggle custom bitrate field based on selected audio quality"
+    )
 
+    # Single media_change handler for all three buttons
+    for btn, mode in [
+        (audio_button, "audio"),
+        (video_button, "video"),
+        (file_button,  "file"),
+    ]:
+        btn.click(
+            fn=media_change,
+            inputs=[btn, state],
+            outputs=[media_output_audio, media_output_video, media_output_file],
+            api_name=f"switch_to_{mode}",
+            description=f"Switch displayed output to {mode}"
+        )
+
+    # ─── FFmpeg command updater listener ────────────────────────────────────────
     ffmpeg_commands = CommandBuilder(
-        inputs_clip,
-        video_inputs,
-        audio_inputs,
-        filter_inputs,
-        filter_inputs_1,
+        inputs_clip, video_inputs, audio_inputs, filter_inputs, acontrastSlider
     )
-    ffmpeg_commands.setup_listener()
-    ffmpeg_commands.update(output_textbox)
-
-# ──────────────────────────────────────────────────────────────────────────────
-# MCP tool registration – one clean endpoint per logical function
-# ──────────────────────────────────────────────────────────────────────────────
-
-gr.api(convert, api_name="transcode_media")
-gr.api(supported_codecs)
-gr.api(supported_presets)
-gr.api(set_custom_bitrate)
-gr.api(media_change)
-
-# ──────────────────────────────────────────────────────────────────────────────
-# Launch
-# ──────────────────────────────────────────────────────────────────────────────
+    ffmpeg_commands.setup_listener()            # start listening to UI changes
+    # pprint(ffmpeg_commands.commands)          # debug: show commands
+    ffmpeg_commands.update(output_textbox)      # populate initial command
 
+# ─── Launch the app with MCP enabled ───────────────────────────────────────────
 if __name__ == "__main__":
     demo.launch(show_error=True, max_threads=300, mcp_server=True)