Spaces:
Running
Running
| """ | |
| UI Tester: a reference app exercising every PyHARP feature. | |
| Unlike the other examples, this app does no real processing. It exists to | |
| verify that HARP renders each supported input control, each track type, and | |
| each output label type correctly. Use it as a lookup for how a given | |
| component is declared, and as a smoke test after changing HARP's UI. | |
| Covered here: | |
| - Track inputs and outputs: audio and MIDI | |
| - Generic file input and output (a file picker rather than a track) | |
| - Every control type: slider, number box, dropdown (single and | |
| multiple selection), checkbox, text box | |
| - Optional inputs, via harp_required(False) | |
| - Control and output descriptions, via set_info() | |
| - Output labels over both audio and MIDI, with every label field | |
| """ | |
| from pyharp import * | |
| from typing import Optional, Tuple | |
| import gradio as gr | |
| import time | |
| import os | |
| # Reference media, used only when the corresponding input track is left empty. | |
| # Bundled alongside this app so it also works offline and once deployed. | |
| RESOURCE_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "resources") | |
| REFERENCE_AUDIO_PATH = os.path.join(RESOURCE_DIR, "test.wav") | |
| REFERENCE_MIDI_PATH = os.path.join(RESOURCE_DIR, "test.mid") | |
| # Metadata shown in HARP's model info panel | |
| model_card = ModelCard( | |
| name="UI Tester", | |
| description=( | |
| "Exercises every input control, track type, and output label type " | |
| "supported by HARP. No real processing is performed: input tracks are " | |
| "passed through unchanged, and bundled reference media is substituted for any " | |
| "track left empty, so the app can be run without loading anything. " | |
| "The control values are echoed into the output label descriptions." | |
| ), | |
| author="TEAMuP", | |
| tags=["example", "ui", "test", "v3"], | |
| ) | |
| def build_audio_labels(duration: float, descriptions: dict) -> list: | |
| """ | |
| Build one audio label of each supported variety. | |
| A label with an amplitude is drawn as an overlay on the waveform, and one | |
| without is drawn in the overhead strip above it. | |
| Args: | |
| duration (float): Duration of the output audio, in seconds. | |
| descriptions (dict): Control values to echo into the labels. | |
| Returns: | |
| labels (list): The constructed AudioLabel objects. | |
| """ | |
| return [ | |
| # Overhead, at the start, with a clickable link | |
| AudioLabel( | |
| t=0.0, | |
| label="start", | |
| duration=1.0, | |
| description=descriptions["sliders"], | |
| color=OutputLabel.rgb_color_to_int(0, 255, 0), | |
| link="https://github.com/TEAMuP-dev/pyharp" | |
| ), | |
| # Overlay, pinned to the bottom of the waveform | |
| AudioLabel( | |
| t=0.0, | |
| label="amplitude 0.0", | |
| duration=1.0, | |
| description=descriptions["dropdowns"], | |
| color=OutputLabel.rgb_color_to_int(28, 102, 48), | |
| amplitude=0.0 | |
| ), | |
| # Overlay, pinned to the middle of the waveform | |
| AudioLabel( | |
| t=0.5 * duration, | |
| label="amplitude 0.5", | |
| duration=1.0, | |
| description=descriptions["checkboxes"], | |
| color=OutputLabel.rgb_color_to_int(102, 28, 48), | |
| amplitude=0.5 | |
| ), | |
| # Overhead, at the end, with no duration (a marker rather than a span) | |
| AudioLabel( | |
| t=duration, | |
| label="end", | |
| duration=0.0, | |
| description=descriptions["text"], | |
| color=OutputLabel.rgb_color_to_int(0, 0, 255) | |
| ), | |
| ] | |
| def build_midi_labels(descriptions: dict) -> list: | |
| """ | |
| Build one MIDI label of each supported variety. | |
| A label with a pitch is drawn as an overlay on the corresponding piano | |
| roll row, and one without is drawn in the overhead strip above it. | |
| Args: | |
| descriptions (dict): Control values to echo into the labels. | |
| Returns: | |
| labels (list): The constructed MidiLabel objects. | |
| """ | |
| return [ | |
| # Overhead, spanning the first second | |
| MidiLabel( | |
| t=0.0, | |
| label="start", | |
| duration=1.0, | |
| description=descriptions["number"], | |
| color=OutputLabel.rgb_color_to_int(255, 255, 0) | |
| ), | |
| # Overlay, on the piano roll row for the given pitch | |
| MidiLabel( | |
| t=0.0, | |
| label="pitch 76", | |
| duration=1.0, | |
| description=descriptions["text"], | |
| color=OutputLabel.rgb_color_to_int(255, 128, 78), | |
| pitch=76 | |
| ), | |
| # Overlay, as a marker with a clickable link | |
| MidiLabel( | |
| t=1.0, | |
| label="pitch 86", | |
| duration=0.0, | |
| color=OutputLabel.rgb_color_to_int(78, 128, 255), | |
| link="https://github.com/TEAMuP-dev/pyharp", | |
| pitch=86 | |
| ), | |
| ] | |
| def process_fn( | |
| input_audio_path: Optional[str], | |
| input_midi_path: Optional[str], | |
| input_file_path: Optional[str], | |
| processing_delay: float, | |
| gain: float, | |
| repetitions: float, | |
| mode: str, | |
| effects: list, | |
| enable_audio_labels: bool, | |
| enable_midi_labels: bool, | |
| text_prompt: str | |
| ) -> Tuple[str, str, LabelList, str]: | |
| """ | |
| Pass the input tracks through and annotate them with output labels. | |
| Args: | |
| input_audio_path (Optional[str]): Audio track, or None if left empty. | |
| input_midi_path (Optional[str]): MIDI track, or None if left empty. | |
| input_file_path (Optional[str]): Generic file, or None if left empty. | |
| processing_delay (float): Seconds to sleep, to test HARP's cancel button. | |
| gain (float): Unused; demonstrates a fractional slider. | |
| repetitions (float): Unused; demonstrates a number box. | |
| mode (str): Unused; demonstrates a dropdown. | |
| effects (list): Unused; demonstrates a multiple-selection dropdown. | |
| enable_audio_labels (bool): Whether to emit labels over the audio. | |
| enable_midi_labels (bool): Whether to emit labels over the MIDI. | |
| text_prompt (str): Written to the output file when no input file is given. | |
| Returns: | |
| output_audio_path (str): Path to the output audio. | |
| output_midi_path (str): Path to the output MIDI. | |
| output_labels (LabelList): Labels drawn over the output tracks. | |
| output_file_path (str): Path to the generic output file. | |
| """ | |
| if input_audio_path is None: | |
| input_audio_path = REFERENCE_AUDIO_PATH | |
| if input_midi_path is None: | |
| input_midi_path = REFERENCE_MIDI_PATH | |
| audio = load_audio(input_audio_path) | |
| midi = load_midi(input_midi_path) | |
| output_audio_path = str(save_audio(audio)) | |
| output_midi_path = str(save_midi(midi)) | |
| # A generic file input arrives as a path, and is echoed back unchanged. | |
| # When none is provided, write one so the output component is populated. | |
| if input_file_path is None: | |
| output_file_path = get_default_path(".txt") | |
| with open(output_file_path, "w") as f: | |
| f.write(f"text_prompt: {text_prompt}\n") | |
| else: | |
| output_file_path = input_file_path | |
| # Echo the control values so they can be read back in HARP | |
| descriptions = { | |
| "sliders": f"processing_delay: {processing_delay}, gain: {gain}", | |
| "number": f"repetitions: {repetitions}", | |
| "dropdowns": f"mode: {mode}, effects: {effects}", | |
| "checkboxes": ( | |
| f"audio_labels: {enable_audio_labels}, " | |
| f"midi_labels: {enable_midi_labels}" | |
| ), | |
| "text": f"text_prompt: {text_prompt}", | |
| } | |
| output_labels = LabelList() | |
| if enable_audio_labels: | |
| # Total duration of the audio, in seconds | |
| duration = audio.audio_data.shape[-1] / audio.sample_rate | |
| output_labels.labels.extend(build_audio_labels(duration, descriptions)) | |
| if enable_midi_labels: | |
| output_labels.labels.extend(build_midi_labels(descriptions)) | |
| # Stall so that HARP's cancel button and status area can be exercised | |
| time.sleep(float(processing_delay)) | |
| return output_audio_path, output_midi_path, output_labels, output_file_path | |
| # Build the Gradio endpoint | |
| with gr.Blocks() as demo: | |
| # Audio and MIDI components become tracks in HARP. A gr.File with any | |
| # other extension becomes a GUI file picker instead. Every input here is | |
| # optional, so the app can be run without loading anything. | |
| # Order must match the process_fn signature. | |
| input_components = [ | |
| gr.Audio( | |
| type="filepath", | |
| label="Input Audio" | |
| ) | |
| .harp_required(False) | |
| .set_info("Passed through unchanged. Bundled reference audio is used if empty."), | |
| gr.File( | |
| type="filepath", | |
| label="Input MIDI", | |
| file_types=[".mid", ".midi"] | |
| ) | |
| .harp_required(False) | |
| .set_info("Passed through unchanged. Bundled reference MIDI is used if empty."), | |
| gr.File( | |
| type="filepath", | |
| label="Input File", | |
| file_types=[".txt", ".csv", ".json", ".nam"] | |
| ) | |
| .harp_required(False) | |
| .set_info("A generic file. HARP shows this as a file picker, not a track."), | |
| gr.Slider( | |
| minimum=0, | |
| maximum=60, | |
| step=1, | |
| value=0, | |
| label="Processing Delay (s)", | |
| info="Stalls processing, so the cancel button can be tested." | |
| ), | |
| gr.Slider( | |
| minimum=0.0, | |
| maximum=1.0, | |
| step=0.01, | |
| value=0.5, | |
| label="Gain", | |
| info="A fractional slider (unused)." | |
| ), | |
| gr.Number( | |
| minimum=1, | |
| maximum=16, | |
| step=1, | |
| value=4, | |
| label="Repetitions", | |
| info="A number box (unused)." | |
| ), | |
| gr.Dropdown( | |
| choices=["first", "second", "third"], | |
| value="second", | |
| label="Mode", | |
| info="A dropdown (unused)." | |
| ), | |
| gr.Dropdown( | |
| choices=["reverb", "delay", "chorus"], | |
| value=["reverb", "chorus"], | |
| multiselect=True, | |
| label="Effects", | |
| info="A dropdown allowing more than one selection (unused)." | |
| ), | |
| gr.Checkbox( | |
| value=True, | |
| label="Audio Labels", | |
| info="Emit output labels over the audio track." | |
| ), | |
| gr.Checkbox( | |
| value=True, | |
| label="MIDI Labels", | |
| info="Emit output labels over the MIDI track." | |
| ), | |
| gr.Textbox( | |
| value="Hello World", | |
| label="Text Prompt", | |
| info="A text box. Written to the output file when no input file is given." | |
| ), | |
| ] | |
| # A gr.JSON output receives the LabelList and is drawn over the tracks. | |
| # Order must match the values returned by process_fn. | |
| output_components = [ | |
| gr.Audio( | |
| type="filepath", | |
| label="Output Audio" | |
| ).set_info("The input audio, unchanged."), | |
| gr.File( | |
| type="filepath", | |
| label="Output MIDI", | |
| file_types=[".mid", ".midi"] | |
| ).set_info("The input MIDI, unchanged."), | |
| gr.JSON( | |
| label="Output Labels" | |
| ).set_info("Labels drawn over the output tracks."), | |
| gr.File( | |
| type="filepath", | |
| label="Output File" | |
| ).set_info("A generic file output."), | |
| ] | |
| app = build_endpoint( | |
| model_card=model_card, | |
| input_components=input_components, | |
| output_components=output_components, | |
| process_fn=process_fn, | |
| ) | |
| demo.queue().launch(share=True, show_error=True, pwa=True) | |