Enhance app.py and utils.py with improved variant selection and logging features; update final_arrangement.json to include volume automation and curve types for sections; modify .gitignore to exclude .env files and additional log patterns.

.gitignore

@@ -1,5 +1,6 @@
 .log*
 __pycache__/
+.env
 *.log
 *.log.*
 *.log.*.*
@@ -8,4 +9,6 @@ __pycache__/
 .env
 *.log.*.*.*.*.*
 __pycache__/
-log.txt
+log.txt
+*.log.*.*.*.*.*
+__pycache__/

app.py

@@ -133,6 +133,8 @@ def generate_section_variants_handler(
         descriptions = {key: data["description"] for key, data in variants.items()}
         descriptions_json = json.dumps(descriptions, indent=2)
         
+        stem_list = {key: data["stems"] for key, data in variants.items()}
+        
         logger.info(f"S3: DESCRIPTIONS of section {section_type} : {descriptions_json}")
 
         progress(1.0, desc="Complete!")
@@ -144,108 +146,79 @@ def generate_section_variants_handler(
             variant3_audio,
             variant4_audio,
             descriptions_json,
+            stem_list
         )
 
     except Exception as e:
-        return f"Error generating variants: {str(e)}", None, None, None, None, None
+        return f"Error generating variants: {str(e)}", None, None, None, None, None, None
 
 
 def select_variant(section_type, variant_num, append):
-    """Select a variant for a specific section, with an option to append. Retry up to 5 times on error."""
+    """Select a variant for a specific section, with an option to append."""
     global ALL_VARIANTS, SELECTED_VARIANTS
 
-    max_retries = 5
-    for attempt in range(1, max_retries + 1):
-        try:
-            if section_type not in ALL_VARIANTS:
-                msg = f"No variants generated for {section_type} yet"
-                if attempt == max_retries:
-                    return msg
-                continue
+    try:
+        if section_type not in ALL_VARIANTS:
+            return f"No variants generated for {section_type} yet", "None"
 
-            variant_key = f"variant{variant_num}"
-            if variant_key not in ALL_VARIANTS[section_type]:
-                msg = f"Variant {variant_num} not found for {section_type}"
-                if attempt == max_retries:
-                    return msg
-                continue
+        variant_key = f"variant{variant_num}"
+        if variant_key not in ALL_VARIANTS[section_type]:
+            return f"Variant {variant_num} not found for {section_type}", "None"
 
-            # If appending, add to the list of selected variants
-            if append:
-                # For now, just overwrite with the latest selection (no append logic)
-                SELECTED_VARIANTS[section_type] = ALL_VARIANTS[section_type][variant_key]["config"]
-            else:
-                # Otherwise, replace the selection
-                SELECTED_VARIANTS[section_type] = ALL_VARIANTS[section_type][variant_key]["config"]
+        # Store the selection
+        SELECTED_VARIANTS[section_type] = ALL_VARIANTS[section_type][variant_key]["config"]
+        
+        # Create a display string for the selected variant
+        variant_info = ALL_VARIANTS[section_type][variant_key]
+        display_text = f"Selected: Variant {variant_num}"
+        if "description" in variant_info:
+            display_text += f" - {variant_info['description']}"
 
-            return f"Selected variant {variant_num} for {section_type} (Append: {append})"
-        except Exception as e:
-            msg = f"Error selecting variant (attempt {attempt}): {str(e)}"
-            if attempt == max_retries:
-                return msg
-            continue
+        return f"Selected variant {variant_num} for {section_type}", display_text
+
+    except Exception as e:
+        return f"Error selecting variant: {str(e)}", "None"
 
 
 def generate_full_track(
     crossfade_ms,
     output_track_name,
-    include_intro,
-    include_buildup,
-    include_breakdown,
-    include_drop,
-    include_outro,
+    *section_flags,
     progress=gr.Progress(),
 ):
     """Generate the full track from selected variants"""
-    global TEMP_DIR, SELECTED_VARIANTS, UPLOADED_STEMS
+    global TEMP_DIR, SELECTED_VARIANTS, UPLOADED_STEMS, sections
 
     if not TEMP_DIR or not os.path.exists(TEMP_DIR):
-        return "Error: No stems loaded", None, None
+        return "Error: No stems loaded", None, None, None
 
     try:
         progress(0.1, desc="Preparing to generate full track...")
 
-        # Check which sections to include based on user selections and available variants
+        # Get section names from the configuration
+        section_names = list(sections.keys())
+        
+        # Map section flags to section names
         sections_to_include = {}
-        logger.info(f"SELECTED_VARIANTS: {SELECTED_VARIANTS}")
-
-        if include_intro and "intro" in SELECTED_VARIANTS:
-            sections_to_include["intro"] = SELECTED_VARIANTS["intro"]
-
-        if include_buildup and "buildup" in SELECTED_VARIANTS:
-            sections_to_include["buildup"] = SELECTED_VARIANTS["buildup"]
-
-        # We always include the full loop if it exists
-        if "full_loop" in SELECTED_VARIANTS:
-            sections_to_include["full_loop"] = SELECTED_VARIANTS["full_loop"]
-
-        if include_breakdown and "breakdown" in SELECTED_VARIANTS:
-            sections_to_include["breakdown"] = SELECTED_VARIANTS["breakdown"]
-
-        if include_drop and "drop" in SELECTED_VARIANTS:
-            sections_to_include["drop"] = SELECTED_VARIANTS["drop"]
-
-        if include_outro and "outro" in SELECTED_VARIANTS:
-            sections_to_include["outro"] = SELECTED_VARIANTS["outro"]
+        for section_name, include_flag in zip(section_names, section_flags):
+            if include_flag and section_name in SELECTED_VARIANTS:
+                sections_to_include[section_name] = SELECTED_VARIANTS[section_name]
 
         if not sections_to_include:
-            return "Error: No sections selected or available", None, None
+            return "Error: No sections selected or available", None, None, None
 
         progress(0.3, desc="Creating track structure...")
 
         # Create the final track
         final_track = None
 
-        # Define the order of sections
-        section_order = ["intro", "buildup", "full_loop", "breakdown", "drop", "outro"]
-
-        # Process each section in order
-        for section_name in section_order:
+        # Process each section in order from the configuration
+        for section_name in section_names:
             if section_name not in sections_to_include:
                 continue
 
             progress(
-                0.4 + 0.1 * section_order.index(section_name) / len(section_order),
+                0.4 + 0.1 * section_names.index(section_name) / len(section_names),
                 desc=f"Processing {section_name}...",
             )
 
@@ -257,7 +230,6 @@ def generate_full_track(
 
             # Create audio for this section
             from utils import create_section_from_json
-
             section_audio = create_section_from_json(variant_config, stems_copy)
 
             # Add to final track
@@ -281,6 +253,15 @@ def generate_full_track(
             "Total sections": len(sections_list),
             "Duration": f"{int(track_duration // 60)}:{int(track_duration % 60):02d}",
             "Crossfade": f"{crossfade_ms} ms",
+            "Section Details": {
+                section: {
+                    "BPM": sections[section]["bpm"],
+                    "Bars": sections[section]["bars"],
+                    "Volume Automation": sections[section]["volume_automation"],
+                    "Curve": sections[section]["curve"]
+                }
+                for section in sections_list
+            }
         }
 
         progress(1.0, desc="Complete!")
@@ -302,27 +283,34 @@ def generate_full_loop_variants(bpm_value, bars_value, p_value, progress=gr.Prog
     )
 
 
-def create_section_ui(section_name, bpm_default, bars_default, p_default):
+def create_section_ui(section_name, params):
     """Helper function to create UI elements for a section."""
     with gr.Accordion(f"Generate {section_name.capitalize()} Variants", open=False):
         with gr.Row():
             with gr.Column(scale=1):
                 gr.Markdown(f"### {section_name.capitalize()} Parameters")
+                gr.Markdown(f"**Volume Automation**: {params['volume_automation']}")
+                gr.Markdown(f"**Curve Type**: {params['curve']}")
+                
                 bpm_slider = gr.Slider(
                     label="BPM (Beats Per Minute)",
                     minimum=60,
                     maximum=180,
-                    value=bpm_default,
+                    value=params['bpm'],
                     step=1,
                 )
                 bars_slider = gr.Slider(
-                    label="Number of Bars", minimum=4, maximum=64, value=bars_default, step=4
+                    label="Number of Bars", 
+                    minimum=4, 
+                    maximum=64, 
+                    value=params['bars'], 
+                    step=4
                 )
                 p_slider = gr.Slider(
                     label="Variation Parameter (p)",
                     minimum=0,
                     maximum=1,
-                    value=p_default,
+                    value=params['p'],
                     step=0.1,
                 )
 
@@ -333,20 +321,24 @@ def create_section_ui(section_name, bpm_default, bars_default, p_default):
             with gr.Column(scale=2):
                 status = gr.Textbox(label="Status", interactive=False)
                 descriptions = gr.JSON(label="Variant Descriptions")
+                stem_list = gr.JSON(label="Stem List")
+                selected_variant = gr.Text(label="Selected Variant", value="None", interactive=False)
 
-        # Create empty lists to store the audio and checkbox components
-        variant_audio_list = []
-        select_btn_list = []
-        
         with gr.Row():
+            variant_audio_list = []
+            select_btn_list = []
             for i in range(1, 5):
                 with gr.Column():
                     gr.Markdown(f"### Variant {i}")
-                    # Create and immediately append each component to its respective list
                     variant_audio = gr.Audio(label=f"Variant {i}", interactive=True)
                     variant_audio_list.append(variant_audio)
                     
-                    select_btn = gr.Checkbox(label=f"Select Variant {i}")
+                    select_btn = gr.Radio(
+                        choices=[f"Select Variant {i}"], 
+                        label="", 
+                        value=None,
+                        interactive=True
+                    )
                     select_btn_list.append(select_btn)
 
     return {
@@ -356,11 +348,13 @@ def create_section_ui(section_name, bpm_default, bars_default, p_default):
         "generate_btn": generate_btn,
         "status": status,
         "descriptions": descriptions,
-        "variant_audio": variant_audio_list,  # Return the complete list of audio components
-        "select_btn": select_btn_list,  # Return the complete list of checkbox components
+        "variant_audio": variant_audio_list,
+        "select_btn": select_btn_list,
+        "selected_variant": selected_variant,
+        "stem_list": stem_list
     }
 
-def setup_section_event_handlers(section_name, section_ui):
+def setup_section_event_handlers(section_name, section_ui, selected_variants_display):
     """Setup event handlers for a given section."""
     section_type = gr.State(section_name)
 
@@ -377,6 +371,7 @@ def setup_section_event_handlers(section_name, section_ui):
             section_ui["status"],
             *section_ui["variant_audio"],
             section_ui["descriptions"],
+            section_ui["stem_list"]
         ],
     )
 
@@ -386,7 +381,26 @@ def setup_section_event_handlers(section_name, section_ui):
         select_btn.change(
             fn=select_variant,
             inputs=[section_type, variant_num, gr.State(False)],
-            outputs=[section_ui["status"]],
+            outputs=[section_ui["status"], section_ui["selected_variant"]],
+        )
+
+        # Update selected variants display whenever a variant is selected
+        def update_selected_variants_display():
+            selected = {}
+            for s in SELECTED_VARIANTS:
+                if s in ALL_VARIANTS:
+                    for v in range(1, 5):
+                        variant_key = f"variant{v}"
+                        if variant_key in ALL_VARIANTS[s]:
+                            if s not in selected:
+                                selected[s] = {}
+                            selected[s]["Selected Variant"] = ALL_VARIANTS[s][variant_key].get("description", f"Variant {v}")
+            return json.dumps(selected, indent=2)
+
+        select_btn.change(
+            fn=update_selected_variants_display,
+            inputs=[],
+            outputs=[selected_variants_display],
         )
 
 
@@ -430,16 +444,25 @@ with gr.Blocks(title="Interactive Music Track Generator") as demo:
         # Editable diagram with progress indicator
         with gr.Row():
             gr.Markdown("⏳ In Progress: Adjusting sections...")
+        
         edm_arrangement_tab()
 
     with gr.Tab("2. Generate Section Variants"):
-        # Example of creating UI for sections dynamically
+        gr.Markdown("### Generate and Select Variants for Each Section")
+        gr.Markdown("Generate variants for each section and select which one to use in the final track")
+        
+        # Create UI for sections dynamically based on final_arrangement.json
         section_uis = {}
+        
+        # Create selected variants display first
+        selected_variants_display = gr.JSON(
+            label="Selected Variants", 
+            value={"No variants selected yet": "Generate and select variants in sections below"}
+        )
+        
         for section_name, params in sections.items():
-            section_uis[section_name] = create_section_ui(
-                section_name, params["bpm"], params["bars"], params["p"]
-            )
-            setup_section_event_handlers(section_name, section_uis[section_name])
+            section_uis[section_name] = create_section_ui(section_name, params)
+            setup_section_event_handlers(section_name, section_uis[section_name], selected_variants_display)
 
     with gr.Tab("3. Create Full Track"):
         with gr.Row():
@@ -459,11 +482,18 @@ with gr.Blocks(title="Interactive Music Track Generator") as demo:
                 )
 
                 gr.Markdown("### Sections to Include")
-                include_intro = gr.Checkbox(label="Include Intro", value=True)
-                include_buildup = gr.Checkbox(label="Include buildup", value=True)
-                include_breakdown = gr.Checkbox(label="Include breakdown", value=True)
-                include_drop = gr.Checkbox(label="Include drop", value=True)
-                include_outro = gr.Checkbox(label="Include Outro", value=True)
+                section_checkboxes = {}
+                for section_name in sections.keys():
+                    section_checkboxes[section_name] = gr.Checkbox(
+                        label=f"Include {section_name.capitalize()}", 
+                        value=True
+                    )
+                
+                gr.Markdown("### Selected Variants Summary")
+                selected_variants_display = gr.JSON(
+                    label="Selected Variants", 
+                    value={"No variants selected yet": "Generate and select variants in Section 2"}
+                )
 
                 generate_track_btn = gr.Button(
                     "Generate Full Track", variant="primary", scale=2
@@ -487,11 +517,7 @@ with gr.Blocks(title="Interactive Music Track Generator") as demo:
         inputs=[
             crossfade_ms,
             output_track_name,
-            include_intro,
-            include_breakdown,
-            include_buildup,
-            include_drop,
-            include_outro,
+            *[section_checkboxes[section] for section in sections.keys()]
         ],
         outputs=[track_status, full_track_audio, track_summary],
     )

final_arrangement.json

@@ -2,46 +2,81 @@
   "intro": {
     "bpm": 120,
     "bars": 8,
-    "p": 0.3
+    "p": 0.3,
+    "volume_automation": [
+      9.6,
+      16
+    ],
+    "curve": "Linear"
   },
   "verse1": {
-    "bpm": 40,
+    "bpm": 48,
     "bars": 32,
-    "p": 0.5
+    "p": 0.5,
+    "volume_automation": [
+      48,
+      48
+    ],
+    "curve": "Flat"
   },
-  "pre_chorus": {
-    "bpm": 60,
+  "buildup": {
+    "bpm": 120,
     "bars": 16,
-    "p": 0.5
+    "p": 0.4,
+    "volume_automation": [
+      38.4,
+      64
+    ],
+    "curve": "Linear"
   },
   "drop": {
     "bpm": 120,
     "bars": 16,
-    "p": 0.7
+    "p": 0.7,
+    "volume_automation": [
+      100,
+      100
+    ],
+    "curve": "Flat"
   },
   "breakdown": {
     "bpm": 120,
     "bars": 16,
-    "p": 0.6
+    "p": 0.6,
+    "volume_automation": [
+      40,
+      24.0
+    ],
+    "curve": "-ve Linear"
   },
   "bridge": {
     "bpm": 60,
     "bars": 32,
-    "p": 0.5
-  },
-  "buildup": {
-    "bpm": 120,
-    "bars": 16,
-    "p": 0.4
+    "p": 0.5,
+    "volume_automation": [
+      60,
+      60
+    ],
+    "curve": "Flat"
   },
   "drop2": {
     "bpm": 100,
     "bars": 64,
-    "p": 0.5
+    "p": 0.5,
+    "volume_automation": [
+      100,
+      100
+    ],
+    "curve": "Flat"
   },
   "outro": {
     "bpm": 120,
     "bars": 8,
-    "p": 0.3
+    "p": 0.3,
+    "volume_automation": [
+      40,
+      24.0
+    ],
+    "curve": "-ve Linear"
   }
 }

temp_choose.py

@@ -1,8 +1,16 @@
 import gradio as gr
 import plotly.graph_objects as go
 import numpy as np
+import logging
 import json
 
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+file_handler = logging.FileHandler('temp_choose.log')
+file_handler.setLevel(logging.INFO)
+file_handler.setFormatter(logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s'))
+logger.addHandler(file_handler)
+
 # Three base arrangements
 arrangements = {
     "High Energy Flow": [
@@ -62,7 +70,8 @@ def editable_diagram(section_data):
             y = np.full(len(x), tempo)
         fig.add_trace(
             go.Scatter(
-                x=x, y=y, fill="tozeroy", name=name, mode="lines", line_shape="hv"
+                x=x, y=y, fill="tozeroy", name=name, mode="lines", line_shape="hv",
+                text=[name] * len(x), textposition="top center"
             )
         )
         total_bars = max(total_bars, bar + length)
@@ -71,7 +80,12 @@ def editable_diagram(section_data):
         title="EDM Arrangement Energy Curve",
         xaxis_title="Bar",
         yaxis_title="Volume (Energy)",
-        xaxis=dict(range=[0, total_bars + 4]),
+        xaxis=dict(
+            range=[0, total_bars + 4],
+            tickmode='linear',
+            tick0=0,
+            dtick=4
+        ),
         yaxis=dict(range=[0, 100]),
         height=400,
     )
@@ -112,6 +126,7 @@ def finalise():
         "Verse 1": "verse1",
         "Pre-Chorus": "pre_chorus",
         "Bridge": "bridge",
+        "Pre-Verse": "pre_verse",
         # Add more mappings as needed
     }
     # Example default values for bpm, bars, p (customize as needed)
@@ -124,16 +139,35 @@ def finalise():
         # Add more as needed
     }
     result = {}
-    for bar, tempo, name, length, curve in arrangement:
+    
+    logger.info(f"Arrangement: {arrangement}")
+    print(f"Arrangement: {arrangement}")
+    for starting_bar, tempo, name, length, curve in arrangement:
         key = section_key_map.get(name, name.lower().replace(' ', '_'))
-        # You can customize how you set bpm, bars, p here
         params = default_section_params.get(key, {"bpm": tempo, "bars": length, "p": 0.5})
+
+        # Volume automation logic
+        if curve.lower() == "flat":
+            volume_automation = [tempo, tempo]
+        elif curve.lower() == "linear":
+            volume_automation = [round(tempo * 0.6, 2), tempo]
+        elif curve.lower() in ["-ve linear", "negative linear"]:
+            volume_automation = [tempo, round(tempo * 0.6, 2)]
+        else:
+            volume_automation = [tempo, tempo]  # default to flat
+
+        params["volume_automation"] = volume_automation
+        params["curve"] = curve  # Optionally save the curve type too
+
         result[key] = params
     with open("final_arrangement.json", "w") as f:
         json.dump(result, f, indent=2)
     return json.dumps(result, indent=2)
 
 
+# To be commented, as UI is in different file
+# Commented out for now
+
 # with gr.Blocks() as iface:
 #     gr.Markdown("# 🌚 Interactive EDM Arrangement Tool")
 
@@ -144,9 +178,9 @@ def finalise():
 #             label="Choose Arrangement Variation",
 #         )
 
-#     out_plot = gr.Plot(label="Arrangement Diagram")
+#     out_plot = gr.Plot(label="Arrangement Diagram", value=load_variation("High Energy Flow"))
 #     variation.change(fn=load_variation, inputs=variation, outputs=out_plot)
-#     out_plot.value = editable_diagram(arrangement)
+#     iface.load(fn=load_variation, inputs=[variation], outputs=[out_plot])
 
 #     with gr.Accordion("🎻 Edit Section Parameters", open=False):
 #         for i, (bar, tempo, name, length, curve) in enumerate(arrangement):

utils.py

@@ -11,21 +11,14 @@ import logging
 
 from dotenv import load_dotenv
 import random
-from temp_choose import (
-    arrangements,
-    arrangement,
-    shift_arrangement,
-    editable_diagram,
-    update_section,
-    insert_section,
-    finalise,
-    load_variation,
-)
+from temp_choose import *
 
 load_dotenv()
 
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.INFO)
+logger.addHandler(logging.StreamHandler())
+logger.addHandler(logging.FileHandler("log.txt"))
 
 def make_groq_call(stems, song_name, p, section_type=None, bpm=120, bars=16):
     """
@@ -156,15 +149,15 @@ def get_stems(folder):
 
 def apply_audio_operation(audio, operation, value):
     """Apply various audio operations to an AudioSegment"""
-    if operation == "low_pass_filter":
+    if operation == "low_pass_filter" and isinstance(value, float):
         return low_pass_filter(audio, value)
-    elif operation == "high_pass_filter":
+    elif operation == "high_pass_filter" and isinstance(value, float):
         return high_pass_filter(audio, value)
-    elif operation == "fade_in":
+    elif operation == "fade_in" and isinstance(value, int):
         return audio.fade_in(value)
-    elif operation == "fade_out":
+    elif operation == "fade_out" and isinstance(value, int):
         return audio.fade_out(value)
-    elif operation == "reverb":
+    elif operation == "reverb" and isinstance(value, float):
         # Simple reverb simulation by adding delayed and attenuated copies
         result = audio
         for delay in [50, 100, 150, 200]:
@@ -172,20 +165,20 @@ def apply_audio_operation(audio, operation, value):
             delayed = AudioSegment.silent(duration=delay) + attenuated
             result = result.overlay(delayed)
         return result
-    elif operation == "delay":
+    elif operation == "delay" and isinstance(value, int):
         # Simulate delay by adding a delayed copy
         result = audio
         delayed = AudioSegment.silent(duration=value) + (audio - 6)  # -6dB for the echo
         return result.overlay(delayed)
-    elif operation == "distortion":
+    elif operation == "distortion" and isinstance(value, float):
         # Simulate distortion by adding some limiting/clipping
         gain = 1.0 + (value * 5)  # Boost the gain based on distortion value
         return audio + (gain)  # Add gain in dB
-    elif operation == "pitch_shift":
+    elif operation == "pitch_shift" and isinstance(value, float):
         # Note: pydub doesn't natively support pitch shifting
         print(f"Warning: Pitch shift not implemented, value: {value}")
         return audio
-    elif operation == "volume":
+    elif operation == "volume" and isinstance(value, float):
         # Adjust volume by dB
         return audio + value
     return audio
@@ -306,18 +299,35 @@ def generate_section_variants(
 
     progress(0.2, desc=f"Generating structure and effects for variants of {section_type}...")
     # Create each variant
+    # hERE IS tHE validation for the LLM RESPONSE
+    if not isinstance(llm_response, dict):
+        logger.error(f"Invalid LLM response: {llm_response}")
+
+    
+    # Check if the response is a valid JSON object
+    try:
+        if isinstance(llm_response, str):
+            llm_response = json.loads(llm_response)
+        elif isinstance(llm_response, dict):
+            llm_response = llm_response
+    except json.JSONDecodeError:
+        logger.error(f"Tried Converting the LLM response to JSON, but failed: {llm_response}")
+    
     variants = {}
     for variant_key in progress.tqdm(llm_response, desc="Getting variants as per AI arranegments..."):
         if variant_key.startswith("variant"):
             variant_config = llm_response[variant_key]
+            logger.info(f" gsv: Variant config: {variant_config}")
             audio = create_section_from_json(variant_config, audio_stems)
             description = variant_config.get(
                 "description", f"Variant {variant_key[-1]}"
             )
+            list_stems = variant_config.get("stems", [])
             variants[variant_key] = {
                 "audio": audio,
                 "description": description,
                 "config": variant_config,
+                "stems": list_stems
             }
     
     
@@ -434,19 +444,20 @@ def export_section_variants(variants, output_folder, section_name):
 
 
 def edm_arrangement_tab():
-    with gr.Tab("🎶 EDM Arranger"):
+    
+    with gr.Blocks() as iface:
         gr.Markdown("# 🌚 Interactive EDM Arrangement Tool")
 
-        out_plot = gr.Plot(label="Arrangement Diagram")
-
         with gr.Row():
             variation = gr.Radio(
                 choices=list(arrangements.keys()),
                 value="High Energy Flow",
                 label="Choose Arrangement Variation",
             )
-            variation.change(fn=load_variation, inputs=variation, outputs=out_plot)
-        out_plot.value = editable_diagram(arrangement)
+
+        out_plot = gr.Plot(label="Arrangement Diagram", value=load_variation("High Energy Flow"))
+        variation.change(fn=load_variation, inputs=variation, outputs=out_plot)
+        iface.load(fn=load_variation, inputs=[variation], outputs=[out_plot])
 
         with gr.Accordion("🎻 Edit Section Parameters", open=False):
             for i, (bar, tempo, name, length, curve) in enumerate(arrangement):
@@ -486,9 +497,7 @@ def edm_arrangement_tab():
             new_tempo = gr.Slider(minimum=20, maximum=100, value=50, label="Volume")
             new_length = gr.Slider(minimum=1, maximum=64, value=8, label="Length")
             new_curve = gr.Radio(
-                choices=["Flat", "Linear", "-ve Linear"],
-                value="Flat",
-                label="Curve Type",
+                choices=["Flat", "Linear", "-ve Linear"], value="Flat", label="Curve Type"
             )
             insert_btn = gr.Button("Insert Section")
             insert_btn.click(
@@ -501,3 +510,6 @@ def edm_arrangement_tab():
         final_btn = gr.Button("Finalise and Export JSON")
         final_output = gr.Textbox(label="Final Arrangement JSON", lines=15)
         final_btn.click(fn=finalise, outputs=final_output)
+
+
+