""" util functions and classes """ import json from tempfile import _TemporaryFileWrapper from typing import List import gradio as gr from gradio.components import Component def parse(param: str) -> dict: with open(param, encoding="utf-8") as file: return json.load(file) data = parse("./data.json") codecs = parse("./codecs.json") """Video""" 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"]] 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("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"]] """ Video & Audio Filters """ # deband=[i.get("name") for i in data["deband"]] # deflicker=[i.get("name") for i in data["deflicker"]] # deshake=[i.get("name") for i in data["deshake"]] # 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"]] video_filters = ["deband", "deflicker", "deshake", "dejudder", "denoise", "deinterlace"] VF = [{vFilter: names} for vFilter in video_filters for names in [list(data[vFilter])]] presets = [i.get("name") for i in data["presets"]] profiles = [i.get("name") for i in data["profiles"]] 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.changefunc(comp, comp.value) # print( # comp.label, # comp, # ) comp.change( fn=self.changefunc, inputs=[gr.State(comp.label), comp], outputs=[] ) def reset(self): self.output_dict = {"vf": {}, "af": {}} self.commands = "" self.vf, self.af, self.extra = ([] for _ in range(3)) def __init__(self, *inputs: gr.Row | gr.Column) -> None: """ Parameters: *inputs: A tuple of layout blocks containing components(Textbox,Button...). """ self.output_dict = {"vf": {}, "af": {}} self.formatoutputdict = {"vf": {}, "af": {}} # state=gr.Variable() # state2=gr.Variable() self._component: List[Component] = [] self.vf, self.af, self.extra = ([] for _ in range(3)) self.commands = "" if inputs is None: return None for i in inputs: self._component += self._get_component_instance(i) # print(self._component, "component") # print(len(self._component), "length") # for comp in self._component: # state = gr.State() # if comp.label is not None: # state.value = comp.label # comp.change(fn=self.changefunc, inputs=[state, comp], outputs=[]) # self.changefunc(state.value, comp.value) # comp.change(fn=self.changefunc, inputs=[state, comp], outputs=[]) def changefunc(self, component_label: str | None, new_value=""): print(component_label, "typaaaaaaaa", new_value) label, *_ = ( component_label.strip(": \n").lower().split() if component_label else "" if not isinstance(component_label, list) else "".join(component_label).strip(": ").lower().split() ) label += "".join(_).title() key = newoutputMap.get(label) lst_extra, vf, af = ([] for _ in range(3)) if new_value not in [None, "Source", "Auto", "", "None", "none", 0]: self.set_vf(label, new_value) self.set_af(label, new_value) self.set_f(label, new_value) for val in self.output_dict: if val == "vf": vf = self.output_dict.get(val, {}).values() vf = ",".join(list(vf)) elif val == "af": af = self.output_dict.get(val, {}).values() af = ",".join(list(af)) else: lst_extra.extend([val, self.output_dict.get(val)]) else: self.output_dict.pop(key, "No Key Exists") self.output_dict["vf"].pop(label, "No Key Exists") self.output_dict["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(label, self.vf, self.af, self.extra) print(self.output_dict, "out") def set_vf(self, label: str, new_value: "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(str(new_value).lower().split()) arg = key.get(value, None) self.output_dict["vf"].update({label: arg}) else: self.output_dict["vf"].update({key: key}) def set_f(self, label, new_value): """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"]: codec_label = codecs.get(label) value = ( codec_label.get(new_value, new_value) if codec_label else new_value ) print(value) self.output_dict.update({key: value}) elif label in ["startTime", "stopTime"]: self.output_dict.update({key: new_value}) else: value = "".join( [ i.get("value", "None") for i in data.get(label) if i.get("name", None) == new_value ] ) self.output_dict.update({key: value}) def set_af(self, label: str, new_value: "str|int"): """Sets Audio filters Args: label : label of components newValue : value of component """ if newoutputMap["af"].get(label): value = int(new_value) / 100 arg = f"{label}={value}" self.output_dict["af"].update({label: arg}) def update(self, component: Component): for comp in self._component: # print(comp, "comp") comp.change( lambda: gr.Textbox(value=self.output_dict), [], [component], trigger_mode="once", ) def _get_component_instance(self, inputs: gr.Row | gr.Column) -> List[Component]: """ returns components present in a layout block Parameters: inputs: layout block """ res = [] for i in inputs.children: # print(i,hasattr(i,"children")) # print( # type(i), # "type", # # isinstance(i, gr.components.Component), # # isinstance(i, gr.Blocks), # hasattr(i, "children"), # ) if not hasattr(i, "children"): # res.append(gr.components.get_component_instance(i,render=True)) # if isinstance(i, gr.components.Component): # print(gr.components.get_component_instance(i, render=True)) res += [gr.components.get_component_instance(i, render=True)] # print(res) elif hasattr(i, "children"): # if isinstance(i, gr.Blocks): 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")] def set_video_filters(self, options): value = self.output_dict.get(options, "-") 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.output_dict["vf"].update({options: arg}) return True if options in ["deband", "deflicker", "deshake", "dejudder"]: arg = filters self.output_dict["vf"].update({options: arg}) return True return False def set_audio_filters(self, options): value = self.output_dict.get(options, "-") if options in ["acontrast"]: value = int(value) / 100 arg = f"{options}={value}" self.output_dict["af"].update({options: arg}) return True return def set_format(self, options): value = self.output_dict.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 ] ) arg = f"{filters} {value}" self.output_dict.update({options: arg}) return True elif data.get(options) is None: arg = f"{filters} {value}" self.output_dict.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.output_dict.update({options: arg}) def build(self): for i in self.output_dict: if self.set_video_filters(i): continue elif self.set_audio_filters(i): continue else: self.set_format(i) lst_extra, vf, af = ([] for _ in range(3)) for val in self.output_dict: if val == "vf": vf = self.output_dict.get(val).values() vf = ",".join(list(vf)) elif val == "af": af = self.output_dict.get(val).values() af = ",".join(list(af)) else: lst_extra.append(self.output_dict.get(val)) # print(lst_extra, "temp x") # if vf:self.vf=f"-vf '{vf}'" # if af:self.af=f"-af '{af}'" 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}" def startfunc(self, component: gr.components.Component, new_value=""): label, *_ = ( component.label.strip(": ").lower().split() if not isinstance(component.label, list) else "".join(component.label).strip(": ").lower().split() ) label += "".join(_).title() if new_value not in [None, "Source", "Auto", "", "None", 0]: self.output_dict["vf"].update({label: new_value}) self.output_dict["af"].update({label: new_value}) self.output_dict.update({label: new_value}) else: self.output_dict.pop(label, "No Key Exists") self.output_dict["vf"].pop(label, "No Key Exists") self.output_dict["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.output_dict) 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(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) # 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_] def media_change(option: str, state) -> 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 """ print(state, "state") ops = {"Audio": gr.Audio(visible=True, value=state)} ops2 = {"Video": gr.Video(visible=True, value=state)} ops3 = {"File": gr.File(visible=True, value=state, interactive=False)} def chosen(x: dict) -> Component: 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_] """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 set_custom_bitrate(choice: int) -> Component: """ Toggle a component for custom Audio Quality visible/none Args: choice : Custom audio quality Returns: Component: component toggle state """ if choice == "Custom": return gr.Number(visible=True) return gr.Number(visible=False, value=0) def supported_codecs(codec: str) -> List[Component]: """ Changes video and audio components with appropriate options according to passed format Args: format: passed media codec (x264,x265) Returns: List[Component]: list of components with updated choices """ if codec: codec = codec.lower() video_lst = [ val.get("value") for val in data["codecs"]["video"] if val.get("supported") is None or codec in val["supported"] ] audio_lst = [ val.get("value") for val in data["codecs"]["audio"] if val.get("supported") is None or codec in val["supported"] ] return [gr.Dropdown(choices=video_lst), gr.Dropdown(choices=audio_lst)] def supported_presets(preset: str) -> Component: """ Changes presets component with appropriate options according to passed format Args: format: passed media codec (slow,fast,ultrafast) Returns: Component: component with updated choice list (video codecs) """ if preset: preset = preset.lower() print(preset, "preset") video_lst = [ val.get("name") for val in data["presets"] if val.get("supported") is None or preset in val["supported"] ] return gr.Dropdown(choices=video_lst) def change_clipbox(choice: str) -> List[Component]: """ 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"), 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.Textbox(visible=False, value=""), gr.Textbox(visible=False, value=""), ] 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 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 def __str__(self): return f"{self._component} __clear__ class" def __repr__(self): return self._component def __init__(self, *input_component: gr.Row | gr.Column) -> None: """ Parameters: *input_component: A tuple of layout blocks containing components """ super().__init__(*input_component) self._component = [] if input_component is not None: for i in input_component: # self._component += super()._get_component_instance(i) self._component += self.__get_component_instance(i) def __get_component_instance(self, inputs: gr.Row | gr.Column) -> list: # print(inputs, " class instance") res = [] # print(*inputs.children) for i in inputs.children: # print(i,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)] # print(i) elif hasattr(i, "children"): # print(*i.children) 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) 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) 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)