feat: simplify slider initialization by using partial functions for common parameters

app.py

@@ -184,11 +184,6 @@ def model2json(fx):
         },
         "Cross Send (dB)": fx[7].params.sends_0.log10().mul(20).item(),
     }
-    replace_neg_inf = lambda d: (
-        {k: (replace_neg_inf(v) if v != -np.inf else -1e500) for k, v in d.items()}
-        if isinstance(d, dict)
-        else d
-    )
     return {
         "Direct": results,
         "Sends": spatial_fx,
@@ -350,6 +345,14 @@ with gr.Blocks() as demo:
     fx_params = gr.State(mean)
     fx = vec2fx(fx_params.value)
 
+    default_pc_slider = partial(
+        gr.Slider, minimum=SLIDER_MIN, maximum=SLIDER_MAX, interactive=True, value=0
+    )
+    default_audio_block = partial(gr.Audio, type="numpy", loop=True)
+    default_freq_slider = partial(gr.Slider, label="Frequency (Hz)", interactive=True)
+    default_gain_slider = partial(gr.Slider, label="Gain (dB)", interactive=True)
+    default_q_slider = partial(gr.Slider, label="Q", interactive=True)
+
     gr.Markdown(
         title_md,
         elem_id="title",
@@ -363,9 +366,7 @@ with gr.Blocks() as demo:
 
     with gr.Row():
         with gr.Column():
-            audio_input = gr.Audio(
-                type="numpy", sources="upload", label="Input Audio", loop=True
-            )
+            audio_input = default_audio_block(sources="upload", label="Input Audio")
             with gr.Row():
                 random_button = gr.Button(
                     f"Randomise PCs",
@@ -379,36 +380,12 @@ with gr.Blocks() as demo:
                     "Run", elem_id="render-button", variant="primary"
                 )
             with gr.Row():
-                s1 = gr.Slider(
-                    minimum=SLIDER_MIN,
-                    maximum=SLIDER_MAX,
-                    label="PC 1",
-                    value=0,
-                    interactive=True,
-                )
-                s2 = gr.Slider(
-                    minimum=SLIDER_MIN,
-                    maximum=SLIDER_MAX,
-                    label="PC 2",
-                    value=0,
-                    interactive=True,
-                )
+                s1 = default_pc_slider(label="PC 1")
+                s2 = default_pc_slider(label="PC 2")
 
             with gr.Row():
-                s3 = gr.Slider(
-                    minimum=SLIDER_MIN,
-                    maximum=SLIDER_MAX,
-                    label="PC 3",
-                    value=0,
-                    interactive=True,
-                )
-                s4 = gr.Slider(
-                    minimum=SLIDER_MIN,
-                    maximum=SLIDER_MAX,
-                    label="PC 4",
-                    value=0,
-                    interactive=True,
-                )
+                s3 = default_pc_slider(label="PC 3")
+                s4 = default_pc_slider(label="PC 4")
 
             sliders = [s1, s2, s3, s4]
 
@@ -418,23 +395,12 @@ with gr.Blocks() as demo:
                 info="Select which extra PC to adjust",
                 interactive=True,
             )
-            extra_slider = gr.Slider(
-                minimum=SLIDER_MIN,
-                maximum=SLIDER_MAX,
-                label="Extra PC",
-                value=0,
-            )
+            extra_slider = default_pc_slider(label="Extra PC")
 
         with gr.Column():
-            audio_output = gr.Audio(
-                type="numpy", label="Output Audio", interactive=False, loop=True
-            )
-            direct_output = gr.Audio(
-                type="numpy", label="Direct Audio", interactive=False, loop=True
-            )
-            wet_output = gr.Audio(
-                type="numpy", label="Wet Audio", interactive=False, loop=True
-            )
+            audio_output = default_audio_block(label="Output Audio", interactive=False)
+            direct_output = default_audio_block(label="Direct Audio", interactive=False)
+            wet_output = default_audio_block(label="Wet Audio", interactive=False)
 
     _ = gr.Markdown("## Parametric EQ")
     peq_plot = gr.Plot(plot_eq(fx), label="PEQ Frequency Response", elem_id="peq-plot")
@@ -442,122 +408,58 @@ with gr.Blocks() as demo:
         with gr.Column(min_width=160):
             _ = gr.Markdown("High Pass")
             hp = fx[5]
-            hp_freq = gr.Slider(
-                minimum=16,
-                maximum=5300,
-                value=fx[5].params.freq.item(),
-                interactive=True,
-                label="Frequency (Hz)",
-            )
-            hp_q = gr.Slider(
-                minimum=0.5,
-                maximum=10,
-                value=fx[5].params.Q.item(),
-                interactive=True,
-                label="Q",
+            hp_freq = default_freq_slider(
+                minimum=16, maximum=5300, value=hp.params.freq.item()
             )
+            hp_q = default_q_slider(minimum=0.5, maximum=10, value=hp.params.Q.item())
 
         with gr.Column(min_width=160):
             _ = gr.Markdown("Low Shelf")
             ls = fx[2]
-            ls_freq = gr.Slider(
-                minimum=30,
-                maximum=200,
-                value=fx[2].params.freq.item(),
-                interactive=True,
-                label="Frequency (Hz)",
+            ls_freq = default_freq_slider(
+                minimum=30, maximum=200, value=ls.params.freq.item()
             )
-            ls_gain = gr.Slider(
-                minimum=-12,
-                maximum=12,
-                value=fx[2].params.gain.item(),
-                interactive=True,
-                label="Gain (dB)",
+            ls_gain = default_gain_slider(
+                minimum=-12, maximum=12, value=ls.params.gain.item()
             )
 
         with gr.Column(min_width=160):
             _ = gr.Markdown("Peak filter 1")
             pk1 = fx[0]
-            pk1_freq = gr.Slider(
-                minimum=33,
-                maximum=5400,
-                value=fx[0].params.freq.item(),
-                interactive=True,
-                label="Frequency (Hz)",
-            )
-            pk1_gain = gr.Slider(
-                minimum=-12,
-                maximum=12,
-                value=fx[0].params.gain.item(),
-                interactive=True,
-                label="Gain (dB)",
+            pk1_freq = default_freq_slider(
+                minimum=33, maximum=5400, value=pk1.params.freq.item()
             )
-            pk1_q = gr.Slider(
-                minimum=0.2,
-                maximum=20,
-                value=fx[0].params.Q.item(),
-                interactive=True,
-                label="Q",
+            pk1_gain = default_gain_slider(
+                minimum=-12, maximum=12, value=pk1.params.gain.item()
             )
+            pk1_q = default_q_slider(minimum=0.2, maximum=20, value=pk1.params.Q.item())
         with gr.Column(min_width=160):
             _ = gr.Markdown("Peak filter 2")
             pk2 = fx[1]
-            pk2_freq = gr.Slider(
-                minimum=200,
-                maximum=17500,
-                value=fx[1].params.freq.item(),
-                interactive=True,
-                label="Frequency (Hz)",
+            pk2_freq = default_freq_slider(
+                minimum=200, maximum=17500, value=pk2.params.freq.item()
             )
-            pk2_gain = gr.Slider(
-                minimum=-12,
-                maximum=12,
-                value=fx[1].params.gain.item(),
-                interactive=True,
-                label="Gain (dB)",
-            )
-            pk2_q = gr.Slider(
-                minimum=0.2,
-                maximum=20,
-                value=fx[1].params.Q.item(),
-                interactive=True,
-                label="Q",
+            pk2_gain = default_gain_slider(
+                minimum=-12, maximum=12, value=pk2.params.gain.item()
             )
+            pk2_q = default_q_slider(minimum=0.2, maximum=20, value=pk2.params.Q.item())
 
         with gr.Column(min_width=160):
             _ = gr.Markdown("High Shelf")
             hs = fx[3]
-            hs_freq = gr.Slider(
-                minimum=750,
-                maximum=8300,
-                value=fx[3].params.freq.item(),
-                interactive=True,
-                label="Frequency (Hz)",
+            hs_freq = default_freq_slider(
+                minimum=750, maximum=8300, value=hs.params.freq.item()
             )
-            hs_gain = gr.Slider(
-                minimum=-12,
-                maximum=12,
-                value=fx[3].params.gain.item(),
-                interactive=True,
-                label="Gain (dB)",
+            hs_gain = default_gain_slider(
+                minimum=-12, maximum=12, value=hs.params.gain.item()
             )
         with gr.Column(min_width=160):
             _ = gr.Markdown("Low Pass")
             lp = fx[4]
-            lp_freq = gr.Slider(
-                minimum=200,
-                maximum=18000,
-                value=fx[4].params.freq.item(),
-                interactive=True,
-                label="Frequency (Hz)",
-            )
-            lp_q = gr.Slider(
-                minimum=0.5,
-                maximum=10,
-                value=fx[4].params.Q.item(),
-                interactive=True,
-                label="Q",
+            lp_freq = default_freq_slider(
+                minimum=200, maximum=18000, value=lp.params.freq.item()
             )
+            lp_q = default_q_slider(minimum=0.5, maximum=10, value=lp.params.Q.item())
 
     _ = gr.Markdown("## Compressor and Expander")
     with gr.Row():
@@ -566,49 +468,49 @@ with gr.Blocks() as demo:
             cmp_th = gr.Slider(
                 minimum=-60,
                 maximum=0,
-                value=fx[6].params.cmp_th.item(),
+                value=comp.params.cmp_th.item(),
                 interactive=True,
-                label="fx[6]. Threshold (dB)",
+                label="Threshold (dB)",
             )
             cmp_ratio = gr.Slider(
                 minimum=1,
                 maximum=20,
-                value=fx[6].params.cmp_ratio.item(),
+                value=comp.params.cmp_ratio.item(),
                 interactive=True,
-                label="fx[6]. Ratio",
+                label="Comp. Ratio",
             )
             make_up = gr.Slider(
                 minimum=-12,
                 maximum=12,
-                value=fx[6].params.make_up.item(),
+                value=comp.params.make_up.item(),
                 interactive=True,
                 label="Make Up (dB)",
             )
             attack_time = gr.Slider(
                 minimum=0.1,
                 maximum=100,
-                value=coef2ms(fx[6].params.at, 44100).item(),
+                value=coef2ms(comp.params.at, 44100).item(),
                 interactive=True,
                 label="Attack Time (ms)",
             )
             release_time = gr.Slider(
                 minimum=50,
                 maximum=1000,
-                value=coef2ms(fx[6].params.rt, 44100).item(),
+                value=coef2ms(comp.params.rt, 44100).item(),
                 interactive=True,
                 label="Release Time (ms)",
             )
             exp_ratio = gr.Slider(
                 minimum=0,
                 maximum=1,
-                value=fx[6].params.exp_ratio.item(),
+                value=comp.params.exp_ratio.item(),
                 interactive=True,
                 label="Exp. Ratio",
             )
             exp_th = gr.Slider(
                 minimum=-80,
                 maximum=0,
-                value=fx[6].params.exp_th.item(),
+                value=comp.params.exp_th.item(),
                 interactive=True,
                 label="Exp. Threshold (dB)",
             )
@@ -624,42 +526,42 @@ with gr.Blocks() as demo:
             delay_time = gr.Slider(
                 minimum=100,
                 maximum=1000,
-                value=fx[7].effects[0].params.delay.item(),
+                value=delay.params.delay.item(),
                 interactive=True,
                 label="Delay Time (ms)",
             )
             feedback = gr.Slider(
                 minimum=0,
                 maximum=1,
-                value=fx[7].effects[0].params.feedback.item(),
+                value=delay.params.feedback.item(),
                 interactive=True,
                 label="Feedback",
             )
             delay_gain = gr.Slider(
                 minimum=-80,
                 maximum=0,
-                value=fx[7].effects[0].params.gain.log10().item() * 20,
+                value=delay.params.gain.log10().item() * 20,
                 interactive=True,
                 label="Gain (dB)",
             )
             odd_pan = gr.Slider(
                 minimum=-100,
                 maximum=100,
-                value=fx[7].effects[0].odd_pan.params.pan.item() * 200 - 100,
+                value=delay.odd_pan.params.pan.item() * 200 - 100,
                 interactive=True,
                 label="Odd Delay Pan",
             )
             even_pan = gr.Slider(
                 minimum=-100,
                 maximum=100,
-                value=fx[7].effects[0].even_pan.params.pan.item() * 200 - 100,
+                value=delay.even_pan.params.pan.item() * 200 - 100,
                 interactive=True,
                 label="Even Delay Pan",
             )
             delay_lp_freq = gr.Slider(
                 minimum=200,
                 maximum=16000,
-                value=fx[7].effects[0].eq.params.freq.item(),
+                value=delay.eq.params.freq.item(),
                 interactive=True,
                 label="Low Pass Frequency (Hz)",
             )