fixed global state issue

.gitignore

@@ -1,4 +1,5 @@
 __pycache__/
 *.pyc
 flagged/
-.venv
+.venv
+requirements.txt

app.py

@@ -1,6 +1,4 @@
-import json
 import logging
-import os
 import subprocess
 from pprint import pprint
 from tempfile import _TemporaryFileWrapper
@@ -9,12 +7,9 @@ from ffmpy import FFmpeg
 
 import gradio as gr
 from functions import (Clear, CommandBuilder, audio_channels, audio_codecs,
-                       audio_containers, audio_quality, audio_sample_rates,
-                       change_clipbox, containers, customBitrate, filters,
-                       mediaChange, presets, profiles, speeds,
-                       supported_codecs, supported_presets, updateOutput,
-                       video_aspect_ratio, video_codecs, video_containers,
-                       video_scaling, videoChange,vf)
+                       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)
 
@@ -43,24 +38,16 @@ def convert(file: _TemporaryFileWrapper, options: str):
         stdout, stderr=ffmpeg.run(stderr=subprocess.PIPE)
         logging.info(f"{stdout} {stderr}")
         output=f"{ffmpeg.cmd}"
-        video=gr.update(label=output_file,value=output_file)
+        # video=gr.update(label=output_file,value=output_file)
 
     except Exception as e:
         stderr=e
         output=f"{ffmpeg.cmd} {stderr}"
+        return [None,None,None,output]
 
-    return [output_file,output_file,video,output]
+    return [output_file,output_file,output_file,output]
 
 
-
-"""Helper Functions for Processing """
-
-
-
-def get_component_instance(inputs: gr.Blocks) -> list:
-    return [gr.components.get_component_instance(i, render=True) for i in inputs.children if not hasattr(i,"children")]
-
-# names=[{x:i} for x in ["audioChannels","audioQualities"] for i in [[i.get("name")  for i in data[x]]]]
 with gr.Blocks(css="./styles.css") as dm:
     with gr.Tabs():
         with gr.TabItem("Format"):
@@ -70,14 +57,14 @@ with gr.Blocks(css="./styles.css") as dm:
                     file_input = gr.File()
                     options = gr.Radio(
                         label="options", choices=containers,value=containers[0])
-
-                    with gr.Row() as inputs_clip:
+                    with gr.Row():
                         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() as inputs_clip:
+                            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().style(mobile_collapse=False):
                         clearBtn = gr.Button("Clear")
                         convertBtn = gr.Button("Convert", variant="primary")
@@ -92,7 +79,8 @@ with gr.Blocks(css="./styles.css") as dm:
                     media_output_audio = gr.Audio(label="Output",visible=True,interactive=False,source="filepath")
                     media_output_video = gr.Video(label="Output",visible=False,format="mp4")
                     media_output_file = gr.File(label="Output",visible=False)
-                    output_textbox = gr.Textbox(elem_id="outputtext")
+                    with gr.Row() as command_output:
+                        output_textbox = gr.JSON(elem_id="outputtext")
                 
                 resetFormat=Clear(inputs,inputs_clip)
                 clearBtn.click(resetFormat.clear, inputs=resetFormat(), outputs=resetFormat())
@@ -132,7 +120,7 @@ with gr.Blocks(css="./styles.css") as dm:
 
         with gr.TabItem("Filters") as filter_inputs:
             gr.Markdown("## Video")
-            with gr.Row().style(equal_height=True,mobile_collapse=False) as filter_inputs:
+            with gr.Row().style(equal_height=True) as filter_inputs:
                 for i in vf:
                     # print(i.values())
                     # values = list(i.values())
@@ -152,8 +140,10 @@ with gr.Blocks(css="./styles.css") as dm:
     
     """ Format Tab change functions"""
     ffmpeg_commands=CommandBuilder(inputs_clip,video_inputs,audio_inputs,filter_inputs,filter_inputs_1)
-    ffmpeg_commands.do()
+    # ffmpeg_commands.do()
+    dm.load(fn=ffmpeg_commands.reset,inputs=[],outputs=[])
     pprint(ffmpeg_commands.commands)
+    state=gr.Variable()
     ffmpeg_commands.update(output_textbox)
     # file_input.change(fn=updateOutput,inputs=file_input,outputs=output_textbox)
     clip.change(fn=change_clipbox, inputs=clip,
@@ -170,5 +160,6 @@ with gr.Blocks(css="./styles.css") as dm:
     video_options.change(supported_presets,[video_options],[preset_options])
     """Audio Tab change functions"""
     audio_bitrate.change(customBitrate,[audio_bitrate],[custom_bitrate])
-    
-dm.launch()
+
+if __name__=='__main__':
+    dm.launch()

functions.py

@@ -1,9 +1,13 @@
+"""
+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:
@@ -14,14 +18,15 @@ 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("name") for i in data["codecs"]["video"]]
+video_codecs = [i.get("value") for i in data["codecs"]["video"]]
 video_aspect_ratio = [i.get("name") for i in data["aspects"]]
 video_scaling = [i.get("name") for i in data["scalings"]]
 """ Audio """
 audio_containers = [i.get("name") for i in data["containers"]["audio"]]
-audio_codecs = [i.get("name") for i in data["codecs"]["audio"]]
+audio_codecs = [i.get("value") for i in data["codecs"]["audio"]]
 audio_channels = [i.get("name") for i in data["audioChannels"]]
 audio_quality = [i.get("name") for i in data["audioQualities"]]
 audio_sample_rates = [i.get("name") for i in data["sampleRates"]]
@@ -44,27 +49,42 @@ 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 
 """
 
 
 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"""
+
     def __call__(self, *args, **kwds):
         return [i.value for i in self._component]
 
     def do(self, *inputs, **kwds):
         for comp in self._component:
             if comp.label is not None:
-                self.startfunc(comp,"",comp.value)
+                self.changefunc(comp, "", comp.value)
+
+    def reset(self):
+        self.outputDict = {"vf": {}, "af": {}}
+        self.commands=""
+        self.vf, self.af, self.extra = ([] for _ in range(3))
 
     def __init__(self, *inputs: gr.Blocks) -> None:
-        self.outputDict = {}
+        """
+        Parameters:
+            *inputs: A tuple of layout blocks containing components(Textbox,Button...).
+        """
+
+        self.outputDict = {"vf": {}, "af": {}}
         self.formatOutputDict = {"vf": {}, "af": {}}
         # state=gr.Variable()
         # state2=gr.Variable()
 
-        self._component: list[gr.components.Changeable] = []
+        self._component: List[Component] = []
         self.vf, self.af, self.extra = ([] for _ in range(3))
         self.commands = ""
         if inputs is None:
@@ -80,29 +100,107 @@ class CommandBuilder():
                 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()
+        label += "".join(_).title()
+        key = newoutputMap.get(label)
+        lst_extra, vf, af = ([] for _ in range(3))
 
+        if newValue not in [None, "Source", "Auto", "", "None", "none", 0]:
+            self.setVf(label, newValue)
+            self.setAf(label, newValue)
+            self.setF(label, newValue)
+            for val in self.outputDict:
+                if val == "vf":
+                    vf = self.outputDict.get(val).values()
+                    vf = ",".join(list(vf))
+                elif val == "af":
+                    af = self.outputDict.get(val).values()
+                    af = ",".join(list(af))
+                    pass
+                else:
+                    lst_extra.extend([val, self.outputDict.get(val)])
 
-    def update(self, Component: gr.components.IOComponent):
+        else:
+            self.outputDict.pop(key, "No Key Exists")
+            self.outputDict["vf"].pop(label, "No Key Exists")
+            self.outputDict["af"].pop(label, "No Key Exists")
+        self.vf = f"-vf '{vf}'" if vf else ""
+        self.af = f"-af '{af}'" if af else ""
+        self.extra = " ".join(lst_extra)
+        self.commands = f"{self.vf} {self.af} {self.extra}"
+
+        print(self.vf, self.af, self.extra)
+
+    def setVf(self, label:str, newValue:"str| int"):
+        """Sets Video filters 
+
+        Args:
+            label : label of components
+            newValue : value of component
+        """
+        if newoutputMap["vf"].get(label):
+            key = newoutputMap["vf"].get(label)
+            if label in ["deinterlace", "denoise"]:
+                value = "_".join(newValue.lower().split())
+                arg = key.get(value, None)
+                self.outputDict["vf"].update({label: arg})
+            else:
+                self.outputDict["vf"].update({key: key})
+
+    def setF(self, label, newValue):
+        """ Sets Extra filters 
+        Args:
+            label : label of components
+            newValue : value of component
+        """
+        if newoutputMap.get(label):
+            key = newoutputMap.get(label)
+            if label in ["video", "audio", "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])
+                self.outputDict.update({key: value})
+
+    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
+            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.commands), [], [Component])
-
-    def _get_component_instance(self, inputs: gr.Blocks) -> "list[gr.components.Component]":
+                value=self.outputDict), [], [Component])
+
+    def _get_component_instance(self, inputs: gr.Blocks) -> List[Component]:
+        """
+        returns components present in a layout block
+        Parameters:
+            inputs: layout block
+        """
         return [gr.components.get_component_instance(i, render=True) for i in inputs.children if not hasattr(i, "children")]
 
     def setVideoFilters(self, options):
         value = self.outputDict.get(options, "-")
-        filters = outputMap.get(options, None)
+        filters = newoutputMap.get(options, None)
         arg = ""
         if options in ["deinterlace", "denoise"]:
             value = "_".join(value.lower().split())
             arg = filters.get(value, None)
             # self.vf.append(arg)
-            self.formatOutputDict["vf"].update({options: arg})
+            self.outputDict["vf"].update({options: arg})
             return True
         if options in ["deband", "deflicker", "deshake", "dejudder"]:
             arg = filters
-            self.formatOutputDict["vf"].update({options: arg})
+            self.outputDict["vf"].update({options: arg})
             return True
 
         return
@@ -113,28 +211,28 @@ class CommandBuilder():
             value = int(value)/100
             arg = f"{options}={value}"
 
-            self.formatOutputDict["af"].update({options: arg})
+            self.outputDict["af"].update({options: arg})
             return True
         return
 
     def setFormat(self, options):
         value = self.outputDict.get(options, "-")
-        filters = outputMap.get(options, None)
+        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])
             arg = f"{filters} {value}"
-            self.formatOutputDict.update({options: arg})
+            self.outputDict.update({options: arg})
             return True
         elif data.get(options) == None:
             arg = f"{filters} {value}"
-            self.formatOutputDict.update({options: arg})
+            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])
             arg = f"{filters} {value}"
-            self.formatOutputDict.update({options: arg})
+            self.outputDict.update({options: arg})
 
     def build(self):
         for i in self.outputDict:
@@ -145,15 +243,15 @@ class CommandBuilder():
             else:
                 self.setFormat(i)
         lst_extra, vf, af = ([] for _ in range(3))
-        for val in self.formatOutputDict:
+        for val in self.outputDict:
             if val == "vf":
-                vf = self.formatOutputDict.get(val).values()
+                vf = self.outputDict.get(val).values()
                 vf = ",".join(list(vf))
             elif val == "af":
-                af = self.formatOutputDict.get(val).values()
+                af = self.outputDict.get(val).values()
                 af = ",".join(list(af))
             else:
-                lst_extra.append(self.formatOutputDict.get(val))
+                lst_extra.append(self.outputDict.get(val))
         # print(lst_extra, "temp x")
         # if vf:self.vf=f"-vf '{vf}'"
         # if af:self.af=f"-af '{af}'"
@@ -162,50 +260,39 @@ class CommandBuilder():
         self.extra = " ".join(lst_extra)
         self.commands = f"{self.vf} {self.af} {self.extra}"
 
-    def changefunc(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()
-        label += "".join(_).title()
-        if newValue not in [None, "Source", "Auto", "", "None",0]:
-            self.outputDict.update({label: newValue})
-        else:
-            self.outputDict.pop(label, "No Key Exists")
-            self.formatOutputDict["vf"].pop(label, "Key is None or similar")
-            self.formatOutputDict["af"].pop(label, "Key is None or similar")
-            self.formatOutputDict.pop(label, "Key is None or similar")
-        self.build()
-        print(self.commands,"   self.commands")
-        print(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()
         label += "".join(_).title()
-        if newValue not in [None, "Source", "Auto", "", "None",0]:
+        if newValue not in [None, "Source", "Auto", "", "None", 0]:
+            self.outputDict["vf"].update({label: newValue})
+            self.outputDict["af"].update({label: newValue})
             self.outputDict.update({label: newValue})
         else:
             self.outputDict.pop(label, "No Key Exists")
-            self.formatOutputDict["vf"].pop(label, "Key is None or similar")
-            self.formatOutputDict["af"].pop(label, "Key is None or similar")
-            self.formatOutputDict.pop(label, "Key is None or similar")
+            self.outputDict["vf"].pop(label, "No Key Exists")
+            self.outputDict["af"].pop(label, "No Key Exists")
+            # self.formatOutputDict["vf"].pop(label, "Key is None or similar")
+            # self.formatOutputDict["af"].pop(label, "Key is None or similar")
+            # self.formatOutputDict.pop(label, "Key is None or similar")
+        print(self.outputDict)
         self.build()
 
 
-
-
-def somefunc(input: gr.components.IOComponent, c_label=""):
-    label = ""
-    output={}
-    print(input, c_label)
-    label, *_ = input.label.strip(": ").lower().split(
-    ) if type(input.label) != list else "".join(input.label).strip(": ").lower().split()
-    label += "".join(_).title()
-    print(outputMap.get(label), label, c_label)
-    if c_label not in [None, "Source", "Auto", ""]:
-        print(input.value)
-        output.update({label: c_label})
-    else:
-        output.pop(label, "No Key Exists")
-    pprint(output)
+# def somefunc(input: gr.components.IOComponent, c_label=""):
+#     label = ""
+#     output = {}
+#     print(input, c_label)
+#     label, *_ = input.label.strip(": ").lower().split(
+#     ) if type(input.label) != list else "".join(input.label).strip(": ").lower().split()
+#     label += "".join(_).title()
+#     print(newoutputMap.get(label), label, c_label)
+#     if c_label not in [None, "Source", "Auto", ""]:
+#         print(input.value)
+#         output.update({label: c_label})
+#     else:
+#         output.pop(label, "No Key Exists")
+#     pprint(output)
 
 # def mediaChange(option):
 #     no_=gr.update(visible=False)
@@ -218,19 +305,29 @@ def somefunc(input: gr.components.IOComponent, c_label=""):
 #     else:
 #         output=gr.update(visible=False)
 #         return [no_,no_]
-def mediaChange(option):
-    no_=gr.update(visible=False)
-    output=gr.update(visible=True)
-    ops={"Audio":gr.update(visible=True)}
-    ops2={"Video":gr.update(visible=True)}
-    ops3={"File":gr.update(visible=True,interactive=False)}
-    # if option.lower()!="mp4" and option in video_containers:
-    #     option="mp4"
-    chosen=lambda x:x.get(option,gr.update(visible=False))
-    print(chosen(ops2),ops2.get(option,no_))
-    return [chosen(ops),chosen(ops2),chosen(ops3)]
-def videoChange(value):
-    print(value.name)
+
+
+def mediaChange(option:str)-> List[Component]:
+    """
+        Allows playing the media in various options,
+        Video, Audio or File
+
+    Args:
+        option : Clicked buttons value
+
+    Returns:
+        List[Component]: list of toggled output components to display
+    """
+    ops = {"Audio": gr.update(visible=True)}
+    ops2 = {"Video": gr.update(visible=True)}
+    ops3 = {"File": gr.update(visible=True, interactive=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)
@@ -243,67 +340,112 @@ def videoChange(value):
     #     return [no_,no_]
 
 
-def customBitrate(choice):
+
+
+"""Helper Functions for Processing """
+
+
+# def clear(*input):
+#     print(input, " clear_func")
+#     # for i in [inp for i in input for inp in i]:
+#     #     print(i, hasattr(i,"cleared_value"),type(i))
+#     # a=default_clear(input_components)
+#     def clear_func(x): return [component.cleared_value if hasattr(
+#         component, "cleared_value") else None for component in x]
+#     print(clear_func(input))
+#     return clear_func(input)
+
+def customBitrate(choice:int)-> Component:
+    """
+        Toggle acomponent for custom Audio Quality 
+        visible/none
+    Args:
+        choice : Custom audio quality
+
+    Returns:
+        Component: component toggle state
+    """
     if choice == "Custom":
-        return gr.update(visible=True, value=None)
+        return gr.update(visible=True)
     else:
-        return gr.update(visible=False, value=None)
+        return gr.update(visible=False, value=0)
+
 
+def supported_codecs(format: str)-> List[Component]:
+    """
+        Changes video and audio components with appropriate 
+        options according to passed format 
 
-def supported_codecs(format: str, a=data):
-    # lst=[i for i in a["codecs"]["audio"]
-    # if i.get("supported")==None or "ogg" in i["supported"]]
+    Args:
+        format: passed media codec (x264,x265)
+
+    Returns:
+        List[Component]: list of components with updated choices
+    """
     if format:
         format = format.lower()
-    video_lst = [val.get("name") for val in a["codecs"]["video"]
+    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("name") for val in a["codecs"]["audio"]
+    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, a=data):
+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 a["presets"]
+    video_lst = [val.get("name") for val in data["presets"]
                  if val.get("supported") == None or format in val["supported"]]
-    print(format, video_lst)
     return gr.update(choices=video_lst)
 
 
-"""Helper Functions for Processing """
-
-
-def clear(*input):
-    print(input, " clear_func")
-    # for i in [inp for i in input for inp in i]:
-    #     print(i, hasattr(i,"cleared_value"),type(i))
-    # a=default_clear(input_components)
-    def clear_func(x): return [component.cleared_value if hasattr(
-        component, "cleared_value") else None for component in x]
-    print(clear_func(input))
-    return clear_func(input)
+def change_clipbox(choice:str)-> List[Component]:
+    """
+    Toggles the clipping Textbox 
+    
+    Args:
+        choice: Enabled/None
 
-
-def change_clipbox(choice):
-    print(gr.Dropdown().postprocess("clip test"))
+    Returns:
+        List[Component]: list of components with visible state of the clip components
+    """
     if choice == "Enabled":
         return [gr.update(visible=True, value="00:00"), gr.update(visible=True, value="00:10")]
     else:
         return [gr.update(visible=False, value=""), gr.update(visible=False, value="")]
 
 
-def updateOutput(file: _TemporaryFileWrapper):
+def updateOutput(file: _TemporaryFileWrapper)-> Component:
     if file:
         print(file.name)
         return gr.update(value=file.name)
 
 
-def get_component_instance(inputs: gr.Blocks) -> list:
+def get_component_instance(inputs: gr.Blocks)-> List[Component]:
+    """ returns only components
+
+    Args:
+        inputs: layout elements
+
+    Returns:
+        List[Component]: components
+    """
     return [gr.components.get_component_instance(i, render=True) for i in inputs.children]
 
 
 class Clear(CommandBuilder):
+    """ Class for clearing components in layouts
+    """
+
     def __call__(self, *args, **kwds):
         return self._component
 
@@ -314,32 +456,39 @@ class Clear(CommandBuilder):
         return self._component
 
     def __init__(self, *input_component: gr.Blocks()) -> None:
+        """
+        Parameters:
+            *input_component: A tuple of layout blocks containing components
+        """
         self._component = []
         if input_component is not None:
             for i in input_component:
                 self._component += super()._get_component_instance(i)
 
-    def __get_component_instance(self, inputs: gr.Blocks) -> list:
-        # print(inputs, " class instance")
-        # res=[]
-        # for i in inputs.children:
-        #     print(hasattr(i,"children"))
-        #     if not (hasattr(i,"children")):
-        #         res.append(gr.components.get_component_instance(i,render=True))
-        #         print(i)
-        #     elif hasattr(i,"children"):
-        #         continue
-        # return res
-        return [gr.components.get_component_instance(i, render=True) for i in inputs.children if not hasattr(i, "children")]
+    # def __get_component_instance(self, inputs: gr.Blocks) -> list:
+    #     # print(inputs, " class instance")
+    #     # res=[]
+    #     # for i in inputs.children:
+    #     #     print(hasattr(i,"children"))
+    #     #     if not (hasattr(i,"children")):
+    #     #         res.append(gr.components.get_component_instance(i,render=True))
+    #     #         print(i)
+    #     #     elif hasattr(i,"children"):
+    #     #         continue
+    #     # return res
+    #     return [gr.components.get_component_instance(i, render=True) for i in inputs.children if not hasattr(i, "children")]
 
     def add(self, *args):
         print(args, type(args))
         if args is not None:
             for i in args:
-                self._component += self.__get_component_instance(i)
+                self._component += super().__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]
         return clear_func(self._component)

new_mappings.json

@@ -0,0 +1,68 @@
+{
+    "vf": {
+        "deband": "deband",
+        "deshake": "deshake",
+        "deflicker": "deflicker",
+        "dejudder": "dejudder",
+        "denoise": {
+            "light": "removegrain=22",
+            "medium": "vaguedenoiser=threshold=3:method=soft:nsteps=5",
+            "heavy": "vaguedenoiser=threshold=6:method=soft:nsteps=5",
+            "default": "removegrain=0"
+        },
+        "deinterlace": {
+            "frame": "yadif=0:-1:0",
+            "field": "yadif=1:-1:0",
+            "frame_nospatial": "yadif=2:-1:0",
+            "field_nospatial": "yadif=3:-1:0"
+        }
+    },
+    "af": {
+        "acontrast": 0
+    },
+    "protocols": "",
+    "startTime": "-ss",
+    "stopTime": "-to",
+
+    "video": "-c:v",
+    "audio": "-c:a",
+    "bitrate": "-b:v",
+    "minrate": "-minrate",
+    "maxrate": "-maxrate",
+    "bufsize": "-bufsize",
+    "gopsize": "-g",
+    "pixelFormat": "-pix_fmt",
+
+    "containers": {
+        "video": "-c:v",
+        "audio": "-c:a"
+    },
+    "clipping": {
+        "startTime": "-ss",
+        "stopTime": "-to"
+    },
+    "codecs": "",
+    "presets": "-preset",
+    "passOptions": "-pass",
+    "pixelformats": "",
+    "frameRates": "-r",
+    "speeds": "",
+    "tunes": "-tune",
+    "profiles": "-profile:v",
+    "levels": "",
+    "fastStart": "-movflags",
+    "sizes": "",
+    "formats": "",
+    "aspects": "-aspect",
+    "scalings": "",
+
+
+    "audioStreams": "",
+    "audioChannels": "-ac",
+    "audioQualities": "-b:a",
+    "sampleRates": "-ar",
+
+
+    "extraOptions": "",
+    "logLevels": ""
+}