feat: add reverb send slider and update parameter handling in demo

app.py

@@ -331,7 +331,10 @@ def update_param(m, attr_name, value):
         case torch.nn.Parameter:
             getattr(m, attr_name).data.copy_(value)
         case _:
-            setattr(m, attr_name, torch.tensor(value))
+            if getattr(m, attr_name).ndim == 0:
+                setattr(m, attr_name, torch.tensor(value))
+            else:
+                setattr(m, attr_name, torch.tensor([value]))
 
 
 @torch.no_grad()
@@ -604,6 +607,13 @@ with gr.Blocks() as demo:
                 interactive=True,
                 label="Low Pass Frequency (Hz)",
             )
+            reverb_send = gr.Slider(
+                minimum=-80,
+                maximum=0,
+                value=fx[7].params.sends_0.log10().item() * 20,
+                interactive=True,
+                label="Reverb Send (dB)",
+            )
         with gr.Column():
             delay_plot = gr.Plot(
                 plot_delay(fx), label="Delay Frequency Response", elem_id="delay-plot"
@@ -688,15 +698,16 @@ with gr.Blocks() as demo:
     ]
     delay_update_plot_flag = [True] * 4 + [False] * 2
 
-    all_effect_sliders = peq_sliders + cmp_sliders + delay_sliders
-    split_sizes = [len(peq_sliders), len(cmp_sliders), len(delay_sliders)]
+    all_effect_sliders = peq_sliders + cmp_sliders + delay_sliders + [reverb_send]
+    split_sizes = [len(peq_sliders), len(cmp_sliders), len(delay_sliders), 1]
 
     def assign_fx_params(fx, *args):
         peq_sliders, cmp_sliders, delay_sliders = (
             args[: split_sizes[0]],
             args[split_sizes[0] : sum(split_sizes[:2])],
-            args[sum(split_sizes[:2]) :],
+            args[sum(split_sizes[:2]) : -1],
         )
+        reverb_send_slider = args[-1]
         for idx, s, attr_name in zip(peq_indices, peq_sliders, peq_attr_names):
             update_param(fx[idx].params, attr_name, s)
 
@@ -707,76 +718,47 @@ with gr.Blocks() as demo:
             m, name = get_last_attribute(fx[7].effects[0], attr_name)
             f(m, name, s)
 
+        update_param(fx[7].params, "sends_0", 10 ** (reverb_send_slider / 20))
+
         return fx
 
-    for idx, s, attr_name in zip(peq_indices, peq_sliders, peq_attr_names):
+    common_steps = chain_functions(
+        lambda x, *all_s: assign_fx_params(vec2fx(x), *all_s),
+        lambda fx: (fx2x(fx), fx),
+        lambda x, fx: (x2z(x), x, fx),
+    )
+
+    for s in peq_sliders:
         s.input(
             chain_functions(
-                lambda x, s, extra_pc_idx, *all_s: (
-                    assign_fx_params(vec2fx(x), *all_s),
-                    s,
-                    extra_pc_idx,
-                ),
-                lambda fx, s, extra_pc_idx, idx=idx, attr_name=attr_name: (
-                    update_param(fx[idx].params, attr_name, s),
-                    fx,
-                    extra_pc_idx,
-                ),
-                lambda _, fx, extra_pc_idx: (fx2x(fx), fx, extra_pc_idx),
-                lambda x, fx, extra_pc_idx: (x2z(x), x, fx, extra_pc_idx),
+                lambda x, i, *args: common_steps(x, *args) + (i,),
                 lambda z, x, fx, extra_pc_idx: [z, x]
                 + [model2json(fx), plot_eq(fx)]
                 + update_pc(z, extra_pc_idx),
             ),
-            inputs=[fx_params, s, extra_pc_dropdown] + all_effect_sliders,
+            inputs=[fx_params, extra_pc_dropdown] + all_effect_sliders,
             outputs=[z, fx_params, json_output, peq_plot] + update_pc_outputs,
         )
 
-    for f, s, attr_name, update_plot in zip(
-        cmp_update_funcs, cmp_sliders, cmp_attr_names, cmp_update_plot_flag
-    ):
+    for s, update_plot in zip(cmp_sliders, cmp_update_plot_flag):
         s.input(
             chain_functions(
-                lambda x, s, e_pc_i, *all_s: (
-                    assign_fx_params(vec2fx(x), *all_s),
-                    s,
-                    e_pc_i,
-                ),
-                lambda fx, s, e_pc_i, attr_name=attr_name, f=f: (
-                    f(fx[6].params, attr_name, s),
-                    fx,
-                    e_pc_i,
-                ),
-                lambda _, fx, e_pc_i: (fx2x(fx), fx, e_pc_i),
-                lambda x, fx, e_pc_i: (x2z(x), x, fx, e_pc_i),
+                lambda x, i, *args: common_steps(x, *args) + (i,),
                 lambda z, x, fx, e_pc_i, update_plot=update_plot: [z, x]
                 + [model2json(fx)]
                 + ([plot_comp(fx)] if update_plot else [])
                 + update_pc(z, e_pc_i),
             ),
-            inputs=[fx_params, s, extra_pc_dropdown] + all_effect_sliders,
+            inputs=[fx_params, extra_pc_dropdown] + all_effect_sliders,
             outputs=[z, fx_params, json_output]
             + ([comp_plot] if update_plot else [])
             + update_pc_outputs,
         )
 
-    for f, s, attr_name, update_plot in zip(
-        delay_update_funcs, delay_sliders, delay_attr_names, delay_update_plot_flag
-    ):
+    for s, update_plot in zip(delay_sliders, delay_update_plot_flag):
         s.input(
             chain_functions(
-                lambda x, s, e_pc_i, *all_s: (
-                    assign_fx_params(vec2fx(x), *all_s),
-                    s,
-                    e_pc_i,
-                ),
-                lambda fx, s, e_pc_i, f=f, attr_name=attr_name: (
-                    f(*get_last_attribute(fx[7].effects[0], attr_name), s),
-                    fx,
-                    e_pc_i,
-                ),
-                lambda _, fx, e_pc_i: (fx2x(fx), fx, e_pc_i),
-                lambda x, fx, e_pc_i: (x2z(x), x, fx, e_pc_i),
+                lambda x, i, *args: common_steps(x, *args) + (i,),
                 lambda z, x, fx, e_pc_i, update_plot=update_plot: (
                     [z, x]
                     + [model2json(fx)]
@@ -784,13 +766,22 @@ with gr.Blocks() as demo:
                     + update_pc(z, e_pc_i)
                 ),
             ),
-            inputs=[fx_params, s, extra_pc_dropdown] + all_effect_sliders,
+            inputs=[fx_params, extra_pc_dropdown] + all_effect_sliders,
             outputs=[z, fx_params]
             + [json_output]
             + ([delay_plot] if update_plot else [])
             + update_pc_outputs,
         )
 
+    reverb_send.input(
+        chain_functions(
+            lambda x, i, *args: common_steps(x, *args) + (i,),
+            lambda z, x, fx, e_pc_i: [z, x] + [model2json(fx)] + update_pc(z, e_pc_i),
+        ),
+        inputs=[fx_params, extra_pc_dropdown] + all_effect_sliders,
+        outputs=[z, fx_params, json_output] + update_pc_outputs,
+    )
+
     render_button.click(
         chain_functions(
             lambda audio, ratio, x, *all_s: (
@@ -841,6 +832,7 @@ with gr.Blocks() as demo:
         fx[7].effects[0].eq.params.freq.item(),
         fx[7].effects[0].odd_pan.params.pan.item() * 200 - 100,
         fx[7].effects[0].even_pan.params.pan.item() * 200 - 100,
+        fx[7].params.sends_0.log10().item() * 20,
     ]
     update_fx_outputs = [
         pk1_freq,
@@ -870,6 +862,7 @@ with gr.Blocks() as demo:
         delay_lp_freq,
         odd_pan,
         even_pan,
+        reverb_send,
     ]
     update_plots = lambda fx: [
         plot_eq(fx),