Update app.py

app.py

@@ -1,13 +1,11 @@
-# File: app.py
-
 import logging
 import subprocess
 from pprint import pprint
 from tempfile import _TemporaryFileWrapper
 
 from ffmpy import FFmpeg, FFRuntimeError
-import gradio as gr
 
+import gradio as gr
 from functions import (
     Clear,
     CommandBuilder,
@@ -26,80 +24,56 @@ from functions import (
     VF,
 )
 
-# ─── Configure logging level ───────────────────────────────────────────────────
 logging.basicConfig(level=logging.INFO)
 
 
-def convert(
-    file: _TemporaryFileWrapper,
-    container_format: str,
-    prev_state: str
-) -> tuple[str, str, str, str, str]:
-    """
-    Convert the given media file to a new container format using FFmpeg.
-
-    Args:
-        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:
-        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
+def convert(file: _TemporaryFileWrapper, container_format: str, new_state: str):
     if file is None:
         logging.error("No file provided for conversion.")
-        return [None, None, None, "No file provided", prev_state]
+        return [None, None, None, "No file provided", new_state]
 
+    output_file = ""
+    ffmpeg = FFmpeg()
     try:
-        # 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(
+        new_name, _ = file.name.split(".")
+        logging.info("New filename:%s", new_name)
+        output_file = f"{new_name}1.{container_format.lower()}"
+        ffmpeg = FFmpeg(
             inputs={file.name: None},
-            outputs={output_file: None},
+            outputs={output_file: ffmpeg_commands.commands.split()},
+            global_options=["-y", "-hide_banner"],
+        )
+        ffmpeg_wo = FFmpeg(
+            inputs={"input_file": None},
+            outputs={
+                f"output_file.{container_format.lower()}": ffmpeg_commands.commands.split()
+            },
             global_options=["-y", "-hide_banner"],
         )
-        print(ffmpeg_cmd_builder)       # Debug: FFmpeg object
-        print(ffmpeg_cmd_builder.cmd)   # Debug: actual shell command
+        print(ffmpeg)
+        print(ffmpeg.cmd)
 
-        # Run conversion
-        ffmpeg_cmd_builder.run(stderr=subprocess.PIPE)
-        ffmpeg_command_str = ffmpeg_cmd_builder.cmd
+        ffmpeg.run(stderr=subprocess.PIPE)
+        # pprint(f"{stdout} {stderr}")
+        output = f"{ffmpeg.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]
+        output = e.stderr.decode()
+        print(str(e.stderr), flush=True)
+        return [None, None, None, output, new_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
-    ]
+
+    return [output_file, output_file, output_file, ffmpeg_wo.cmd, new_state]
 
 
-# ─── Custom CSS for the app ────────────────────────────────────────────────────
 css = """
 body {
   background: var(--body-background-fill);
 }
 """
 
-# ─── Build the Gradio interface ────────────────────────────────────────────────
 with gr.Blocks(
     css=css,
     theme=gr.themes.Soft(
@@ -107,72 +81,71 @@ with gr.Blocks(
         secondary_hue=gr.themes.colors.amber,
         neutral_hue=gr.themes.colors.slate,
         font=["sans-serif"],
+        # font=["ui-sans-serif", "system-ui", "sans-serif"],
     ),
 ) as demo:
-
     with gr.Tabs(selected="format", elem_classes="tabs"):
-
-        # ── Format Tab ────────────────────────────────────────────────────────
         with gr.Tab("Format", id="format"):
-
+            # Input Buttons
             with gr.Row():
                 with gr.Column() as inputs:
-                    file_input = gr.File(label="Upload File")  # upload control
+                    file_input = gr.File()
                     options = gr.Radio(
-                        label="Container Format",
-                        choices=containers,
-                        value=containers[0],
+                        label="options", choices=containers, value=containers[0]
                     )
-
-                    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")               # reset inputs
-                        convertBtn = gr.Button("Convert", variant="primary")  # run conversion
+                        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():
+                        clearBtn = gr.Button("Clear")
+                        convertBtn = gr.Button("Convert", variant="primary")
 
+                # Output Buttons
                 with gr.Column():
-                    # Output modality buttons
-                    video_button = gr.Button("Video")
-                    audio_button = gr.Button("Audio")
-                    file_button  = gr.Button("File")
-
-                    # 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)
-
-                    output_textbox = gr.Code(
-                        value="$ echo 'Hello, World!'",
-                        label="FFmpeg Command",
-                        language="shell",
-                        elem_id="outputtext",
+                    # media_output = gr.Audio(label="Output")
+                    with gr.Row():
+                        video_button = gr.Button("Video")
+                        audio_button = gr.Button("Audio")
+                        file_button = gr.Button("File")
+                    media_output_audio = gr.Audio(
+                        type="filepath",
+                        label="Audio",
+                        visible=False,
+                        interactive=False,
+                    )
+                    media_output_video = gr.Video(
+                        label="Video", visible=True, height=300
                     )
+                    media_output_file = gr.File(label="File", visible=False)
+                    with gr.Row() as command_output:
+                        output_textbox = gr.Code(
+                            value="$ echo 'Hello, World!'",
+                            label="command",
+                            language="shell",
+                            elem_id="outputtext",
+                        )
 
-                # 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
+                # print(inputs_clip.children)
+                # print(resetFormat)
                 state = gr.State()
-
-                # Convert button → convert_media tool
+                clearBtn.click(resetFormat.clear, resetFormat(), resetFormat())
                 convertBtn.click(
-                    fn=convert,
+                    convert,
                     inputs=[file_input, options, state],
                     outputs=[
                         media_output_audio,
@@ -181,137 +154,108 @@ with gr.Blocks(
                         output_textbox,
                         state,
                     ],
-                    api_name="convert_media",
-                    description="Convert an uploaded file to the selected format via FFmpeg"
                 )
 
-        # ── Video Tab ─────────────────────────────────────────────────────────
         with gr.Tab("Video", id="video"):
             with gr.Row() as video_inputs:
                 video_options = gr.Dropdown(
-                    label="Video Codec", choices=video_codecs, value=video_codecs[-1]
+                    label="video", choices=video_codecs, value=video_codecs[-1]
                 )
                 preset_options = gr.Dropdown(
-                    label="Preset", choices=presets, value=presets[-1]
+                    choices=presets, label="presets", value=presets[-1]
                 )
 
-            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"
-            )
+            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 ─────────────────────────────────────────────────────────
         with gr.Tab("Audio", id="audio"):
             with gr.Row() as audio_inputs:
+                # print(names[0])
                 audio_options = gr.Dropdown(
-                    label="Audio Codec", choices=audio_codecs, value=audio_codecs[-1]
+                    label="audio", choices=audio_codecs, value=audio_codecs[-1]
                 )
                 audio_bitrate = gr.Dropdown(
-                    label="Audio Quality", choices=audio_quality, value=audio_quality[0]
-                )
-                custom_bitrate = gr.Number(
-                    label="Custom Bitrate", visible=False
+                    choices=audio_quality,
+                    label="Audio Qualities",
+                    value=audio_quality[0],
                 )
+                custom_bitrate = gr.Number(label="Audio Qualities", visible=False)
                 gr.Dropdown(
-                    label="Audio Channels", choices=audio_channels, value=audio_channels[0]
+                    choices=audio_channels,
+                    label="Audio Channels",
+                    value=audio_channels[0],
                 )
                 gr.Dropdown(
-                    label="Sample Rate", choices=audio_sample_rates, value=audio_sample_rates[0]
+                    choices=audio_sample_rates,
+                    label="Sample Rates",
+                    value=audio_sample_rates[0],
                 )
 
-            clearAudBtn = gr.Button("Clear")
+            with gr.Column(elem_id="button"):
+                clearBtn = gr.Button("Clear")
             audioReset = Clear(audio_inputs)
-            clearAudBtn.click(
-                fn=audioReset.clear,
-                inputs=audioReset(),
-                outputs=audioReset(),
-                api_name="reset_audio_tab",
-                description="Clear all inputs in the Audio tab"
-            )
+            clearBtn.click(audioReset.clear, audioReset(), audioReset())
 
-        # ── Filters Tab ────────────────────────────────────────────────────────
         with gr.Tab("Filters", id="filters") as filter_inputs:
-            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"
+            gr.Markdown("## Video")
+            # equal_height=True
+            with gr.Row(equal_height=True) as filter_inputs:
+                for i in VF:
+                    # print(i.values())
+                    # values = list(i.values())
+                    values = list(i.values())[0]
+                    choices = [j for lst in values for j in [lst.get("name")]]
+                    a = gr.Dropdown(
+                        label=str(list(i.keys())[0]), choices=choices, value=choices[0]
+                    )
+            gr.Markdown("## Audio")
+            with gr.Row(elem_id="acontrast") as filter_inputs_1:
+                acontrastSlider = 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())
+
+    # demo.load(fn=ffmpeg_commands.reset, inputs=[], outputs=[])
+    clip.change(fn=change_clipbox, inputs=clip, outputs=[start_time, stop_time])
+    # file_input.change(fn=updateOutput,inputs=file_input,outputs=output_textbox)
+
+    options.change(supported_codecs, [options], [video_options, audio_options])
+    # options.change(mediaChange,[options],[media_output_audio,media_output_video])
+    # video_button.click(fn=videoChange,inputs=media_output_file,outputs=media_output_video)
+    audio_button.click(
+        media_change,
+        [audio_button, state],
+        [media_output_audio, media_output_video, media_output_file],
     )
-
-    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"
+    video_button.click(
+        media_change,
+        [video_button, state],
+        [media_output_audio, media_output_video, media_output_file],
     )
-
-    video_options.change(
-        fn=supported_presets,
-        inputs=[video_options],
-        outputs=[preset_options],
-        api_name="update_presets",
-        description="Refresh preset list when video codec changes"
+    # media_output_audio.change(lambda x:gr.update(value=x),[media_output_audio],[media_output_video])
+    file_button.click(
+        media_change,
+        [file_button, state],
+        [media_output_audio, media_output_video, media_output_file],
     )
+    """Video Tab change functions"""
+    video_options.change(supported_presets, [video_options], [preset_options])
+    """Audio Tab change functions"""
+    audio_bitrate.change(set_custom_bitrate, [audio_bitrate], [custom_bitrate])
 
-    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 ────────────────────────────────────────
+    """ Format Tab change functions"""
     ffmpeg_commands = CommandBuilder(
-        inputs_clip, video_inputs, audio_inputs, filter_inputs, acontrastSlider
+        inputs_clip, video_inputs, audio_inputs, filter_inputs, filter_inputs_1
     )
-    ffmpeg_commands.setup_listener()            # start listening to UI changes
-    # pprint(ffmpeg_commands.commands)          # debug: show commands
-    ffmpeg_commands.update(output_textbox)      # populate initial command
+    ffmpeg_commands.setup_listener()
+    # pprint(ffmpeg_commands.commands)
+    ffmpeg_commands.update(output_textbox)
 
-# ─── Launch the app with MCP enabled ───────────────────────────────────────────
 if __name__ == "__main__":
-    demo.launch(show_error=True, max_threads=300, mcp_server=True)
+    demo.launch(show_error=True, max_threads=300)