Pending changes exported from your codespace

README.md

@@ -4,7 +4,7 @@ emoji: 🔥
 colorFrom: blue
 colorTo: green
 sdk: gradio
-sdk_version: 3.3.1
+sdk_version: 4.41.0
 app_file: app.py
 tags : ["ffmpeg","converter","media","processing"]
 pinned: true

app.py

@@ -6,10 +6,24 @@ from tempfile import _TemporaryFileWrapper
 from ffmpy import FFmpeg
 
 import gradio as gr
-from functions import (Clear, CommandBuilder, audio_channels, audio_codecs,
-                       audio_quality, audio_sample_rates,
-                       change_clipbox, containers, customBitrate, mediaChange, presets, supported_codecs, supported_presets, video_codecs, video_containers,
-                       vf)
+from functions import (
+    Clear,
+    CommandBuilder,
+    audio_channels,
+    audio_codecs,
+    audio_quality,
+    audio_sample_rates,
+    change_clipbox,
+    containers,
+    customBitrate,
+    mediaChange,
+    presets,
+    supported_codecs,
+    supported_presets,
+    video_codecs,
+    video_containers,
+    vf,
+)
 
 logging.basicConfig(level=logging.INFO)
 
@@ -17,152 +31,200 @@ logging.basicConfig(level=logging.INFO)
 logging.info(msg=f"{video_containers}")
 
 
-def convert(file: _TemporaryFileWrapper, options: str,state):
-    stderr=""
-    stdout=""
-    output_file=""
-    video=""
-    ffmpeg=FFmpeg()
+def convert(file: _TemporaryFileWrapper, options: str, state):
+    stderr = ""
+    # stdout=""
+    output_file = ""
+    # video = ""
+    ffmpeg = FFmpeg()
     try:
         logging.info(f"File name: {file.name}")
         new_name, _ = file.name.split(".")
         logging.info(f"New filename:{new_name}")
         output_file = f"{new_name}1.{options.lower()}"
-        ffmpeg = FFmpeg(inputs={file.name: None}, outputs={
-                        output_file: ffmpeg_commands.commands.split()}, global_options=["-y", "-hide_banner"])
+        ffmpeg = FFmpeg(
+            inputs={file.name: None},
+            outputs={output_file: ffmpeg_commands.commands.split()},
+            global_options=["-y", "-hide_banner"],
+        )
         print(ffmpeg)
         print(ffmpeg.cmd)
 
         ffmpeg.run(stderr=subprocess.PIPE)
         # pprint(f"{stdout} {stderr}")
-        output=f"{ffmpeg.cmd}"
+        output = f"{ffmpeg.cmd}"
         # video=gr.update(label=output_file,value=output_file)
 
     except Exception as e:
-        stderr=e
-        output=f"{stderr}"
-        return [None,None,None,output]
-
-    state=output_file    
-
-    return [output_file,output_file,output_file,output,state]
-
-
-with gr.Blocks(css="./styles.css") as dm:
-    with gr.Tabs():
-        with gr.TabItem("Format"):
-            # Input Buttons
-            with gr.Row():
-                with gr.Column() as inputs:
-                    file_input = gr.File()
-                    options = gr.Radio(
-                        label="options", choices=containers,value=containers[0])
-                    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)
-                    with gr.Row():
-                        clearBtn = gr.Button("Clear")
-                        convertBtn = gr.Button("Convert", variant="primary")
-
-                # Output Buttons
-                with gr.Column():
-                    # 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="Output",visible=True,interactive=False,source="filepath")
-                    media_output_video = gr.Video(label="Output",visible=False)
-                    media_output_file = gr.File(label="Output",visible=False)
-                    with gr.Row() as command_output:
-                        output_textbox = gr.Textbox(label="command",elem_id="outputtext")
-                
-                resetFormat=Clear(inputs,inputs_clip)
-                print(inputs_clip.children)
-                print(resetFormat)
-                state=gr.Variable()
-                clearBtn.click(resetFormat.clear, inputs=resetFormat(), outputs=resetFormat())
-                convertBtn.click(convert, inputs=[file_input, options,state], outputs=[
-                    media_output_audio,media_output_file,media_output_video, output_textbox,state])
-
-        with gr.TabItem("Video"):
-            with gr.Row() as video_inputs:
-                video_options = gr.Dropdown(
-                    label="video", choices=video_codecs,value=video_codecs[-1])
-                preset_options = gr.Dropdown(choices=presets, label="presets",value=presets[-1])
-
-
-            with gr.Row(elem_id="button"):
-                with gr.Column():
+        stderr = e
+        output = f"{stderr}"
+        return [None, None, None, output]
+
+    state = output_file
+
+    return [output_file, output_file, output_file, output, state]
+
+
+with gr.Blocks(css="./styles.css") as demo:
+    # with gr.Tabs():
+    with gr.Tab("Format"):
+        # Input Buttons
+        with gr.Row():
+            with gr.Column() as inputs:
+                file_input = gr.File()
+                options = gr.Radio(
+                    label="options", choices=containers, value=containers[0]
+                )
+                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
+                        )
+                with gr.Row():
                     clearBtn = gr.Button("Clear")
-            videoReset=Clear(video_inputs)
-            clearBtn.click(videoReset.clear, videoReset(), videoReset())
-
-        with gr.TabItem("Audio"):
-            with gr.Row() as audio_inputs:
-                # print(names[0])
-                audio_options = gr.Dropdown(
-                    label="audio", choices=audio_codecs, value=audio_codecs[-1])
-                audio_bitrate=gr.Dropdown(choices=audio_quality, label="Audio Qualities",
-                            value=audio_quality[0])
-                custom_bitrate=gr.Number(label="Audio Qualities",visible=False)
-                gr.Dropdown(choices=audio_channels,
-                            label="Audio Channels", value=audio_channels[0])
-                gr.Dropdown(choices=audio_sample_rates,
-                            label="Sample Rates", value=audio_sample_rates[0])
-
-
-            with gr.Column(elem_id="button"):
-                clearBtn = gr.Button("Clear")
-            audioReset=Clear(audio_inputs)
-            clearBtn.click(audioReset.clear, audioReset(), audioReset())
-
-        with gr.TabItem("Filters") as filter_inputs:
-            gr.Markdown("## Video")
-            with gr.Row().style(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=list(i.keys()),
-                                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"):
+                    convertBtn = gr.Button("Convert", variant="primary")
+
+            # Output Buttons
+            with gr.Column():
+                # 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="Output", visible=True, interactive=False
+                )
+                media_output_video = gr.Video(label="Output", visible=False)
+                media_output_file = gr.File(label="Output", visible=False)
+                with gr.Row() as command_output:
+                    output_textbox = gr.Textbox(label="command", elem_id="outputtext")
+
+            resetFormat = Clear(inputs, inputs_clip)
+            print(inputs_clip.children)
+            print(resetFormat)
+            state = gr.State()
+            clearBtn.click(
+                resetFormat.clear, inputs=resetFormat(), outputs=resetFormat()
+            )
+            convertBtn.click(
+                convert,
+                inputs=[file_input, options, state],
+                outputs=[
+                    media_output_audio,
+                    media_output_file,
+                    media_output_video,
+                    output_textbox,
+                    state,
+                ],
+            )
+
+    with gr.Tab("Video"):
+        with gr.Row() as video_inputs:
+            video_options = gr.Dropdown(
+                label="video", choices=video_codecs, value=video_codecs[-1]
+            )
+            preset_options = gr.Dropdown(
+                choices=presets, label="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())
+
+    with gr.Tab("Audio"):
+        with gr.Row() as audio_inputs:
+            # print(names[0])
+            audio_options = gr.Dropdown(
+                label="audio", choices=audio_codecs, value=audio_codecs[-1]
+            )
+            audio_bitrate = gr.Dropdown(
+                choices=audio_quality,
+                label="Audio Qualities",
+                value=audio_quality[0],
+            )
+            custom_bitrate = gr.Number(label="Audio Qualities", visible=False)
+            gr.Dropdown(
+                choices=audio_channels,
+                label="Audio Channels",
+                value=audio_channels[0],
+            )
+            gr.Dropdown(
+                choices=audio_sample_rates,
+                label="Sample Rates",
+                value=audio_sample_rates[0],
+            )
+
+        with gr.Column(elem_id="button"):
+            clearBtn = gr.Button("Clear")
+        audioReset = Clear(audio_inputs)
+        clearBtn.click(audioReset.clear, audioReset(), audioReset())
+
+    with gr.Tab("Filters") as filter_inputs:
+        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=list(i.keys()), 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())
 
-            filterReset=Clear(filter_inputs,filter_inputs_1)
-            clearBtn.click(filterReset.clear, filterReset(), filterReset())
-    
     """ Format Tab change functions"""
-    ffmpeg_commands=CommandBuilder(inputs_clip,video_inputs,audio_inputs,filter_inputs,filter_inputs_1)
+    ffmpeg_commands = CommandBuilder(
+        inputs_clip, video_inputs, audio_inputs, filter_inputs, filter_inputs_1
+    )
     # ffmpeg_commands.do()
-    dm.load(fn=ffmpeg_commands.reset,inputs=[],outputs=[])
+
+    # demo.load(fn=ffmpeg_commands.reset, inputs=[], outputs=[])
+    clip.change(fn=change_clipbox, inputs=clip, outputs=[start_time, stop_time])
     pprint(ffmpeg_commands.commands)
     ffmpeg_commands.update(output_textbox)
     # file_input.change(fn=updateOutput,inputs=file_input,outputs=output_textbox)
-    clip.change(fn=change_clipbox, inputs=clip,
-                outputs=[start_time, stop_time])
-    
-    options.change(supported_codecs,[options],[video_options,audio_options])
+
+    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(mediaChange,[audio_button,state],[media_output_audio,media_output_video,media_output_file])
-    video_button.click(mediaChange,[video_button,state],[media_output_audio,media_output_video,media_output_file])
+    audio_button.click(
+        mediaChange,
+        [audio_button, state],
+        [media_output_audio, media_output_video, media_output_file],
+    )
+    video_button.click(
+        mediaChange,
+        [video_button, state],
+        [media_output_audio, media_output_video, media_output_file],
+    )
     # media_output_audio.change(lambda x:gr.update(value=x),[media_output_audio],[media_output_video])
-    file_button.click(mediaChange,[file_button,state],[media_output_audio,media_output_video,media_output_file])
+    file_button.click(
+        mediaChange,
+        [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])
+    video_options.change(supported_presets, [video_options], [preset_options])
     """Audio Tab change functions"""
-    audio_bitrate.change(customBitrate,[audio_bitrate],[custom_bitrate])
+    audio_bitrate.change(customBitrate, [audio_bitrate], [custom_bitrate])
 
-if __name__=='__main__':
-    dm.launch()
+if __name__ == "__main__":
+    demo.launch(debug=True)

functions.py

@@ -1,14 +1,15 @@
 """
 util functions and classes
 """
+
 import json
-from pprint import pprint
 from tempfile import _TemporaryFileWrapper
 from typing import List
 
 import gradio as gr
 from gradio.components import Component
 
+
 def parse(param: json) -> dict:
     with open(param) as file:
         return json.load(file)
@@ -18,8 +19,7 @@ data = parse("./data.json")
 codecs = parse("./codecs.json")
 
 """Video"""
-containers = [j.get("name") for i in data["containers"]
-              for j in data["containers"][i]]
+containers = [j.get("name") for i in data["containers"] for j in data["containers"][i]]
 video_containers = [i.get("name") for i in data["containers"]["video"]]
 video_codecs = [i.get("value") for i in data["codecs"]["video"]]
 video_aspect_ratio = [i.get("name") for i in data["aspects"]]
@@ -38,10 +38,8 @@ audio_sample_rates = [i.get("name") for i in data["sampleRates"]]
 # dejudder=[i.get("name") for i in data["dejudder"]]
 # denoise=[i.get("name") for i in data["denoise"]]
 # deinterlace=[i.get("name") for i in data["deinterlace"]]
-filters = ["deband", "deflicker", "deshake",
-           "dejudder", "denoise", "deinterlace"]
-vf = [{vFilter: names} for vFilter in filters for names in [
-    [i for i in data[vFilter]]]]
+filters = ["deband", "deflicker", "deshake", "dejudder", "denoise", "deinterlace"]
+vf = [{vFilter: names} for vFilter in filters for names in [[i for i in data[vFilter]]]]
 
 presets = [i.get("name") for i in data["presets"]]
 profiles = [i.get("name") for i in data["profiles"]]
@@ -51,12 +49,12 @@ speeds = [i.get("name") for i in data["speeds"]]
 outputMap = parse("./mappings.json")
 newoutputMap = parse("./new_mappings.json")
 """Output Mappings of commands to value
-   audioQuality -b:a 128k 
+   audioQuality -b:a 128k
 """
 
 
-class CommandBuilder():
-    """Takes a collection of gradio layout elements and attaches 
+class CommandBuilder:
+    """Takes a collection of gradio layout elements and attaches
     a function to each component in the context
     to build an array of ffmpeg commands"""
 
@@ -70,7 +68,7 @@ class CommandBuilder():
 
     def reset(self):
         self.outputDict = {"vf": {}, "af": {}}
-        self.commands=""
+        self.commands = ""
         self.vf, self.af, self.extra = ([] for _ in range(3))
 
     def __init__(self, *inputs: gr.Blocks) -> None:
@@ -92,17 +90,21 @@ class CommandBuilder():
         for i in inputs:
             self._component += self._get_component_instance(i)
         for comp in self._component:
-            state = gr.Variable()
-            state2 = gr.Variable()
+            state = gr.State()
+            state2 = gr.State()
             if comp.label is not None:
                 state.value = comp
                 state2.value = comp.label
-                comp.change(fn=self.changefunc, inputs=[
-                            state, state2, comp], outputs=[])
-
-    def changefunc(self, input: gr.components.IOComponent, c_label="", newValue=""):
-        label, *_ = input.label.strip(": \n").lower().split(
-        ) if type(input.label) != list else "".join(input.label).strip(": ").lower().split()
+                comp.change(
+                    fn=self.changefunc, inputs=[state, state2, comp], outputs=[]
+                )
+
+    def changefunc(self, input: gr.components.Component, c_label="", newValue=""):
+        label, *_ = (
+            input.label.strip(": \n").lower().split()
+            if not isinstance(input.label, list)
+            else "".join(input.label).strip(": ").lower().split()
+        )
         label += "".join(_).title()
         key = newoutputMap.get(label)
         lst_extra, vf, af = ([] for _ in range(3))
@@ -132,8 +134,8 @@ class CommandBuilder():
 
         print(self.vf, self.af, self.extra)
 
-    def setVf(self, label:str, newValue:"str| int"):
-        """Sets Video filters 
+    def setVf(self, label: str, newValue: "str| int"):
+        """Sets Video filters
 
         Args:
             label : label of components
@@ -149,7 +151,7 @@ class CommandBuilder():
                 self.outputDict["vf"].update({key: key})
 
     def setF(self, label, newValue):
-        """ Sets Extra filters 
+        """Sets Extra filters
         Args:
             label : label of components
             newValue : value of component
@@ -157,31 +159,36 @@ class CommandBuilder():
         if newoutputMap.get(label):
             key = newoutputMap.get(label)
             if label in ["video", "audio"]:
-                value=codecs.get(label).get(newValue,newValue)
+                value = codecs.get(label).get(newValue, newValue)
                 print(value)
-                self.outputDict.update({key:value})
+                self.outputDict.update({key: value})
             elif label in ["startTime", "stopTime"]:
                 self.outputDict.update({key: newValue})
             else:
-                value = "".join([i.get("value", "None") for i in data.get(
-                    label) if i.get("name", None) == newValue])
+                value = "".join(
+                    [
+                        i.get("value", "None")
+                        for i in data.get(label)
+                        if i.get("name", None) == newValue
+                    ]
+                )
                 self.outputDict.update({key: value})
 
-    def setAf(self, label:str, newValue:"str|int"):
-        """ Sets Extra filters 
+    def setAf(self, label: str, newValue: "str|int"):
+        """Sets Extra filters
         Args:
             label : label of components
             newValue : value of component
         """
         if newoutputMap["af"].get(label):
-            value = int(newValue)/100
+            value = int(newValue) / 100
             arg = f"{label}={value}"
             self.outputDict["af"].update({label: arg})
 
     def update(self, Component: Component):
         for comp in self._component:
-            comp.change(lambda: gr.update(
-                value=self.outputDict), [], [Component])
+            print(comp, "comp")
+            comp.change(lambda: gr.update(value=self.outputDict), [], [Component])
 
     def _get_component_instance(self, inputs: gr.Blocks) -> List[Component]:
         """
@@ -189,15 +196,15 @@ class CommandBuilder():
         Parameters:
             inputs: layout block
         """
-        res=[]
+        res = []
         for i in inputs.children:
             # print(i,hasattr(i,"children"))
-            if not (hasattr(i,"children")):
+            if not (hasattr(i, "children")):
                 # res.append(gr.components.get_component_instance(i,render=True))
-                res+=[gr.components.get_component_instance(i,render=True)]
+                res += [gr.components.get_component_instance(i, render=True)]
                 # print(res)
-            elif hasattr(i,"children"):
-                res+=self._get_component_instance(i)
+            elif hasattr(i, "children"):
+                res += self._get_component_instance(i)
         # print(res)
         return res
         # return [gr.components.get_component_instance(i, render=True) for i in inputs.children if not hasattr(i, "children")]
@@ -222,7 +229,7 @@ class CommandBuilder():
     def setAudioFilters(self, options):
         value = self.outputDict.get(options, "-")
         if options in ["acontrast"]:
-            value = int(value)/100
+            value = int(value) / 100
             arg = f"{options}={value}"
 
             self.outputDict["af"].update({options: arg})
@@ -233,18 +240,28 @@ class CommandBuilder():
         value = self.outputDict.get(options, "-")
         filters = newoutputMap.get(options, None)
         if options in ["video", "audio"]:
-            value = "".join([i.get("value", "None") for i in data.get(
-                "codecs").get(options) if i.get("name", None) == value])
+            value = "".join(
+                [
+                    i.get("value", "None")
+                    for i in data.get("codecs").get(options)
+                    if i.get("name", None) == value
+                ]
+            )
             arg = f"{filters} {value}"
             self.outputDict.update({options: arg})
             return True
-        elif data.get(options) == None:
+        elif data.get(options) is None:
             arg = f"{filters} {value}"
             self.outputDict.update({options: arg})
             return True
         elif options != "clip":
-            value = "".join([i.get("value", "None") for i in data.get(
-                options) if i.get("name", None) == value])
+            value = "".join(
+                [
+                    i.get("value", "None")
+                    for i in data.get(options)
+                    if i.get("name", None) == value
+                ]
+            )
             arg = f"{filters} {value}"
             self.outputDict.update({options: arg})
 
@@ -274,9 +291,12 @@ class CommandBuilder():
         self.extra = " ".join(lst_extra)
         self.commands = f"{self.vf} {self.af} {self.extra}"
 
-    def startfunc(self, input: gr.components.IOComponent, c_label="", newValue=""):
-        label, *_ = input.label.strip(": ").lower().split(
-        ) if type(input.label) != list else "".join(input.label).strip(": ").lower().split()
+    def startfunc(self, input: gr.components.Component, c_label="", newValue=""):
+        label, *_ = (
+            input.label.strip(": ").lower().split()
+            if not isinstance(input.label, list)
+            else "".join(input.label).strip(": ").lower().split()
+        )
         label += "".join(_).title()
         if newValue not in [None, "Source", "Auto", "", "None", 0]:
             self.outputDict["vf"].update({label: newValue})
@@ -321,7 +341,7 @@ class CommandBuilder():
 #         return [no_,no_]
 
 
-def mediaChange(option:str,state)-> List[Component]:
+def mediaChange(option: str, state) -> List[Component]:
     """
         Allows playing the media in various options,
         Video, Audio or File
@@ -332,28 +352,29 @@ def mediaChange(option:str,state)-> List[Component]:
     Returns:
         List[Component]: list of toggled output components to display
     """
-    ops = {"Audio": gr.update(visible=True,value=state)}
-    ops2 = {"Video": gr.update(visible=True,value=state)}
-    ops3 = {"File": gr.update(visible=True,value=state, interactive=False)}
+    print(state, "state")
+    ops = {"Audio": gr.update(visible=True, value=state)}
+    ops2 = {"Video": gr.update(visible=True, value=state)}
+    ops3 = {"File": gr.update(visible=True, value=state, interactive=False)}
+
+    def chosen(x):
+        return x.get(option, gr.update(visible=False))
 
-    def chosen(x): return x.get(option, gr.update(visible=False))
     return [chosen(ops), chosen(ops2), chosen(ops3)]
 
 
 # def videoChange(value):
 #     print(value.name)
 
-    # if option in video_containers:
-    #     output=gr.update(visible=True)
-    #     return [no_,output]
-    # elif option in audio_containers:
-    #     output=gr.update(visible=True)
-    #     return [output,no_]
-    # else:
-    #     output=gr.update(visible=False)
-    #     return [no_,no_]
-
-
+# if option in video_containers:
+#     output=gr.update(visible=True)
+#     return [no_,output]
+# elif option in audio_containers:
+#     output=gr.update(visible=True)
+#     return [output,no_]
+# else:
+#     output=gr.update(visible=False)
+#     return [no_,no_]
 
 
 """Helper Functions for Processing """
@@ -369,9 +390,10 @@ def mediaChange(option:str,state)-> List[Component]:
 #     print(clear_func(input))
 #     return clear_func(input)
 
-def customBitrate(choice:int)-> Component:
+
+def customBitrate(choice: int) -> Component:
     """
-        Toggle a component for custom Audio Quality 
+        Toggle a component for custom Audio Quality
         visible/none
     Args:
         choice : Custom audio quality
@@ -385,10 +407,10 @@ def customBitrate(choice:int)-> Component:
         return gr.update(visible=False, value=0)
 
 
-def supported_codecs(format: str)-> List[Component]:
+def supported_codecs(format: str) -> List[Component]:
     """
-        Changes video and audio components with appropriate 
-        options according to passed format 
+        Changes video and audio components with appropriate
+        options according to passed format
 
     Args:
         format: passed media codec (x264,x265)
@@ -398,54 +420,77 @@ def supported_codecs(format: str)-> List[Component]:
     """
     if format:
         format = format.lower()
-    video_lst = [val.get("value") for val in data["codecs"]["video"]
-                 if val.get("supported") == None or format in val["supported"]]
-    audio_lst = [val.get("value") for val in data["codecs"]["audio"]
-                 if val.get("supported") == None or format in val["supported"]]
-    return [gr.update(choices=video_lst), gr.update(choices=audio_lst)]
-
-
-def supported_presets(format: str)-> Component:
-    """ 
-        Changes presets component with appropriate 
+    video_lst = [
+        val.get("value")
+        for val in data["codecs"]["video"]
+        if val.get("supported") is None or format in val["supported"]
+    ]
+    audio_lst = [
+        val.get("value")
+        for val in data["codecs"]["audio"]
+        if val.get("supported") is None or format in val["supported"]
+    ]
+    return [gr.Dropdown(choices=video_lst), gr.Dropdown(choices=audio_lst)]
+
+
+def supported_presets(format: str) -> Component:
+    """
+        Changes presets component with appropriate
         options according to passed format
     Args:
         format: passed media codec (x264,x265)
 
     Returns:
         Component: component with updated choice list (video codecs)
-    """ 
+    """
     if format:
         format = format.lower()
-    video_lst = [val.get("name") for val in data["presets"]
-                 if val.get("supported") == None or format in val["supported"]]
-    return gr.update(choices=video_lst)
+    print(format, "preset")
+    video_lst = [
+        val.get("name")
+        for val in data["presets"]
+        if val.get("supported") is None or format in val["supported"]
+    ]
+    return gr.Dropdown(choices=video_lst)
 
 
-def change_clipbox(choice:str)-> List[Component]:
+def change_clipbox(choice: str) -> List[Component]:
     """
-    Toggles the clipping Textbox 
-    
+    Toggles the clipping Textbox
+
     Args:
         choice: Enabled/None
 
     Returns:
         List[Component]: list of components with visible state of the clip components
     """
+    print(choice, " now choice")
     if choice == "Enabled":
-        return [gr.update(visible=True, value="00:00"), gr.update(visible=True, value="00:10")]
+        return [
+            # gr.update(visible=True, value="00:00"),
+            # gr.update(visible=True, value="00:10"),
+            gr.Textbox(
+                label="Start Time:", placeholder="00:00", visible=True, value="00:00"
+            ),
+            gr.Textbox(
+                label="Stop Time:", placeholder="00:00", visible=True, value="00:10"
+            ),
+        ]
     else:
-        return [gr.update(visible=False, value=""), gr.update(visible=False, value="")]
+        return [
+            gr.Textbox(visible=False, value=""),
+            gr.Textbox(visible=False, value=""),
+        ]
 
 
-def updateOutput(file: _TemporaryFileWrapper)-> Component:
+def updateOutput(file: _TemporaryFileWrapper) -> Component:
     if file:
         print(file.name)
         return gr.update(value=file.name)
 
 
-def get_component_instance(inputs: gr.Blocks)-> List[Component]:
-    """ returns only components
+def get_component_instance(inputs: gr.Blocks) -> List[Component]:
+    """returns only components
 
     Args:
         inputs: layout elements
@@ -453,12 +498,13 @@ def get_component_instance(inputs: gr.Blocks)-> List[Component]:
     Returns:
         List[Component]: components
     """
-    return [gr.components.get_component_instance(i, render=True) for i in inputs.children]
+    return [
+        gr.components.get_component_instance(i, render=True) for i in inputs.children
+    ]
 
 
 class Clear(CommandBuilder):
-    """ Class for clearing components in layouts
-    """
+    """Class for clearing components in layouts"""
 
     def __call__(self, *args, **kwds):
         return self._component
@@ -469,7 +515,7 @@ class Clear(CommandBuilder):
     def __repr__(self):
         return self._component
 
-    def __init__(self, *input_component: gr.Blocks()) -> None:
+    def __init__(self, *input_component: gr.Blocks) -> None:
         """
         Parameters:
             *input_component: A tuple of layout blocks containing components
@@ -482,17 +528,17 @@ class Clear(CommandBuilder):
 
     def __get_component_instance(self, inputs: gr.Blocks) -> list:
         # print(inputs, " class instance")
-        res=[]
+        res = []
         # print(*inputs.children)
         for i in inputs.children:
             # print(i,hasattr(i,"children"))
-            if not (hasattr(i,"children")):
+            if not (hasattr(i, "children")):
                 # res.append(gr.components.get_component_instance(i,render=True))
-                res+=[gr.components.get_component_instance(i,render=True)]
+                res += [gr.components.get_component_instance(i, render=True)]
                 # print(i)
-            elif hasattr(i,"children"):
+            elif hasattr(i, "children"):
                 # print(*i.children)
-                res+=self.__get_component_instance(i)
+                res += self.__get_component_instance(i)
                 # res=[gr.components.get_component_instance(i, render=True) for i in inputs.children if not hasattr(i, "children")]
                 # print(res,"__ result")
         # print(res)
@@ -503,13 +549,22 @@ class Clear(CommandBuilder):
         print(args, type(args))
         if args is not None:
             for i in args:
-                self._component += super().__get_component_instance(i)
+                self._component += self.__get_component_instance(i)
         return self._component
 
     def clear(self, *args):
         """
         Function to clear components from a Block in the class instance
         """
-        def clear_func(x): return [component.cleared_value if hasattr(
-            component, "cleared_value") else component.value for component in x]
+
+        def clear_func(x):
+            return [
+                (
+                    component.cleared_value
+                    if hasattr(component, "cleared_value")
+                    else component.value
+                )
+                for component in x
+            ]
+
         return clear_func(self._component)