Deploying refreshed UI-Tester from pyharp v0.3.1.

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+*.mid filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1 @@
+_outputs

README.md

@@ -1,15 +1,13 @@
 ---
 title: UI Tester
-emoji: 🦀
+emoji: 🧪
 colorFrom: indigo
-colorTo: yellow
+colorTo: gray
 sdk: gradio
-sdk_version: 6.26.0
-python_version: '3.13'
+sdk_version: 6.24.0
 app_file: app.py
 pinned: false
 license: mit
-short_description: A template exercising every supported feature of pyharp.
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+A PyHARP example which exercises every input control, track type, and output label type supported by HARP. Performs no real processing.

app.py

@@ -0,0 +1,342 @@
+"""
+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)

requirements.txt

@@ -0,0 +1 @@
+-e git+https://github.com/TEAMuP-dev/pyharp.git#egg=pyharp

resources/test.mid

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a2c4efd5f95b0c0d9aa1b78c21bb4867a56c89b75058bc332e2369a63df6e7c7
+size 244

resources/test.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:38535cbebe3d054f8624a7856891848af8f834279a2c4b063afe3e391397da68
+size 451866