Fix bugs

.gitignore

@@ -1,14 +0,0 @@
-.log*
-__pycache__/
-.env
-*.log
-*.log.*
-*.log.*.*
-*.log.*.*.*
-*.log.*.*.*.*
-.env
-*.log.*.*.*.*.*
-__pycache__/
-log.txt
-*.log.*.*.*.*.*
-__pycache__/

app.py

@@ -16,7 +16,6 @@ from utils import (
 )
 
 from dotenv import load_dotenv
-from langsmith import traceable
 
 load_dotenv()
 
@@ -134,8 +133,6 @@ 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!")
@@ -147,86 +144,108 @@ 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, None
+        return f"Error generating variants: {str(e)}", None, None, None, None, None
 
 
-@traceable(run_type="chain", name="groq_call")
 def select_variant(section_type, variant_num, append):
-    """Select a variant for a specific section, with an option to append."""
+    """Select a variant for a specific section, with an option to append. Retry up to 5 times on error."""
     global ALL_VARIANTS, SELECTED_VARIANTS
 
-    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]:
-            return f"Variant {variant_num} not found for {section_type}", "None"
-
-        # Store the selection
-        variant_info = ALL_VARIANTS[section_type][variant_key]
-        SELECTED_VARIANTS[section_type] = variant_info["config"]
-        
-        # Create a display string for the selected variant
-        display_text = f"Selected: Variant {variant_num}"
-        if "description" in variant_info:
-            display_text += f" - {variant_info['description']}"
+    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
 
-        # Log selection details for tracing
-        logger.info(f"Selected variant for {section_type}: {variant_key}")
-        logger.info(f"Variant description: {variant_info.get('description', 'No description')}")
-        logger.info(f"Stems used: {variant_info.get('config', {}).get('stems', [])}")
+            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
 
-        return f"Selected variant {variant_num} for {section_type}", display_text
+            # 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"]
 
-    except Exception as e:
-        logger.error(f"Error selecting variant: {str(e)}")
-        return f"Error selecting variant: {str(e)}", "None"
+            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
 
 
 def generate_full_track(
     crossfade_ms,
     output_track_name,
-    *section_flags,
+    include_intro,
+    include_buildup,
+    include_breakdown,
+    include_drop,
+    include_outro,
     progress=gr.Progress(),
 ):
     """Generate the full track from selected variants"""
-    global TEMP_DIR, SELECTED_VARIANTS, UPLOADED_STEMS, sections
+    global TEMP_DIR, SELECTED_VARIANTS, UPLOADED_STEMS
 
     if not TEMP_DIR or not os.path.exists(TEMP_DIR):
-        return "Error: No stems loaded", None, None, None
+        return "Error: No stems loaded", None, None
 
     try:
         progress(0.1, desc="Preparing to generate full track...")
 
-        # Get section names from the configuration
-        section_names = list(sections.keys())
-        
-        # Map section flags to section names
+        # Check which sections to include based on user selections and available variants
         sections_to_include = {}
-        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]
+        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"]
 
         if not sections_to_include:
-            return "Error: No sections selected or available", None, None, None
+            return "Error: No sections selected or available", None, None
 
         progress(0.3, desc="Creating track structure...")
 
         # Create the final track
         final_track = None
 
-        # Process each section in order from the configuration
-        for section_name in section_names:
+        # 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:
             if section_name not in sections_to_include:
                 continue
 
             progress(
-                0.4 + 0.1 * section_names.index(section_name) / len(section_names),
+                0.4 + 0.1 * section_order.index(section_name) / len(section_order),
                 desc=f"Processing {section_name}...",
             )
 
@@ -238,6 +257,7 @@ 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
@@ -261,15 +281,6 @@ 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!")
@@ -291,34 +302,27 @@ def generate_full_loop_variants(bpm_value, bars_value, p_value, progress=gr.Prog
     )
 
 
-def create_section_ui(section_name, params):
+def create_section_ui(section_name, bpm_default, bars_default, p_default):
     """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=params['bpm'],
+                    value=bpm_default,
                     step=1,
                 )
                 bars_slider = gr.Slider(
-                    label="Number of Bars", 
-                    minimum=4, 
-                    maximum=64, 
-                    value=params['bars'], 
-                    step=4
+                    label="Number of Bars", minimum=4, maximum=64, value=bars_default, step=4
                 )
                 p_slider = gr.Slider(
                     label="Variation Parameter (p)",
                     minimum=0,
                     maximum=1,
-                    value=params['p'],
+                    value=p_default,
                     step=0.1,
                 )
 
@@ -329,24 +333,20 @@ def create_section_ui(section_name, params):
             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.Radio(
-                        choices=[f"Select Variant {i}"], 
-                        label="", 
-                        value=None,
-                        interactive=True
-                    )
+                    select_btn = gr.Checkbox(label=f"Select Variant {i}")
                     select_btn_list.append(select_btn)
 
     return {
@@ -356,13 +356,11 @@ def create_section_ui(section_name, params):
         "generate_btn": generate_btn,
         "status": status,
         "descriptions": descriptions,
-        "variant_audio": variant_audio_list,
-        "select_btn": select_btn_list,
-        "selected_variant": selected_variant,
-        "stem_list": stem_list
+        "variant_audio": variant_audio_list,  # Return the complete list of audio components
+        "select_btn": select_btn_list,  # Return the complete list of checkbox components
     }
 
-def setup_section_event_handlers(section_name, section_ui, selected_variants_display):
+def setup_section_event_handlers(section_name, section_ui):
     """Setup event handlers for a given section."""
     section_type = gr.State(section_name)
 
@@ -379,7 +377,6 @@ def setup_section_event_handlers(section_name, section_ui, selected_variants_dis
             section_ui["status"],
             *section_ui["variant_audio"],
             section_ui["descriptions"],
-            section_ui["stem_list"]
         ],
     )
 
@@ -389,26 +386,7 @@ def setup_section_event_handlers(section_name, section_ui, selected_variants_dis
         select_btn.change(
             fn=select_variant,
             inputs=[section_type, variant_num, gr.State(False)],
-            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],
+            outputs=[section_ui["status"]],
         )
 
 
@@ -452,26 +430,16 @@ 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"):
-        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
+        # Example of creating UI for sections dynamically
         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)
-            setup_section_event_handlers(section_name, section_uis[section_name], selected_variants_display)
+            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])
 
     with gr.Tab("3. Create Full Track"):
         with gr.Row():
@@ -491,18 +459,11 @@ with gr.Blocks(title="Interactive Music Track Generator") as demo:
                 )
 
                 gr.Markdown("### Sections to Include")
-                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"}
-                )
+                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)
 
                 generate_track_btn = gr.Button(
                     "Generate Full Track", variant="primary", scale=2
@@ -526,7 +487,11 @@ with gr.Blocks(title="Interactive Music Track Generator") as demo:
         inputs=[
             crossfade_ms,
             output_track_name,
-            *[section_checkboxes[section] for section in sections.keys()]
+            include_intro,
+            include_breakdown,
+            include_buildup,
+            include_drop,
+            include_outro,
         ],
         outputs=[track_status, full_track_audio, track_summary],
     )

final_arrangement.json

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

requirements.txt

@@ -8,5 +8,3 @@ python-dotenv
 plotly-express
 pandas
 pydub
-langsmith
-langchain

temp_choose.py

@@ -1,16 +1,8 @@
 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": [
@@ -70,8 +62,7 @@ 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",
-                text=[name] * len(x), textposition="top center"
+                x=x, y=y, fill="tozeroy", name=name, mode="lines", line_shape="hv"
             )
         )
         total_bars = max(total_bars, bar + length)
@@ -80,12 +71,7 @@ def editable_diagram(section_data):
         title="EDM Arrangement Energy Curve",
         xaxis_title="Bar",
         yaxis_title="Volume (Energy)",
-        xaxis=dict(
-            range=[0, total_bars + 4],
-            tickmode='linear',
-            tick0=0,
-            dtick=4
-        ),
+        xaxis=dict(range=[0, total_bars + 4]),
         yaxis=dict(range=[0, 100]),
         height=400,
     )
@@ -126,7 +112,6 @@ 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)
@@ -139,35 +124,16 @@ def finalise():
         # Add more as needed
     }
     result = {}
-    
-    logger.info(f"Arrangement: {arrangement}")
-    print(f"Arrangement: {arrangement}")
-    for starting_bar, tempo, name, length, curve in arrangement:
+    for 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")
 
@@ -178,9 +144,9 @@ def finalise():
 #             label="Choose Arrangement Variation",
 #         )
 
-#     out_plot = gr.Plot(label="Arrangement Diagram", value=load_variation("High Energy Flow"))
+#     out_plot = gr.Plot(label="Arrangement Diagram")
 #     variation.change(fn=load_variation, inputs=variation, outputs=out_plot)
-#     iface.load(fn=load_variation, inputs=[variation], outputs=[out_plot])
+#     out_plot.value = editable_diagram(arrangement)
 
 #     with gr.Accordion("🎻 Edit Section Parameters", open=False):
 #         for i, (bar, tempo, name, length, curve) in enumerate(arrangement):

utils.py

@@ -8,22 +8,25 @@ from pydub.effects import low_pass_filter, high_pass_filter
 from tqdm import tqdm
 from groq import Groq
 import logging
-from langsmith import traceable
-from langchain.callbacks import LangChainTracer
 
 from dotenv import load_dotenv
 import random
-from temp_choose import *
+from temp_choose import (
+    arrangements,
+    arrangement,
+    shift_arrangement,
+    editable_diagram,
+    update_section,
+    insert_section,
+    finalise,
+    load_variation,
+)
 
 load_dotenv()
 
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.INFO)
-logger.addHandler(logging.StreamHandler())
-logger.addHandler(logging.FileHandler("log.txt"))
 
-
-@traceable(run_type="llm", name="groq_call")
 def make_groq_call(stems, song_name, p, section_type=None, bpm=120, bars=16):
     """
     Make a call to the Groq API to get music production instructions.
@@ -153,15 +156,15 @@ def get_stems(folder):
 
 def apply_audio_operation(audio, operation, value):
     """Apply various audio operations to an AudioSegment"""
-    if operation == "low_pass_filter" and isinstance(value, float):
+    if operation == "low_pass_filter":
         return low_pass_filter(audio, value)
-    elif operation == "high_pass_filter" and isinstance(value, float):
+    elif operation == "high_pass_filter":
         return high_pass_filter(audio, value)
-    elif operation == "fade_in" and isinstance(value, int):
+    elif operation == "fade_in":
         return audio.fade_in(value)
-    elif operation == "fade_out" and isinstance(value, int):
+    elif operation == "fade_out":
         return audio.fade_out(value)
-    elif operation == "reverb" and isinstance(value, float):
+    elif operation == "reverb":
         # Simple reverb simulation by adding delayed and attenuated copies
         result = audio
         for delay in [50, 100, 150, 200]:
@@ -169,20 +172,20 @@ def apply_audio_operation(audio, operation, value):
             delayed = AudioSegment.silent(duration=delay) + attenuated
             result = result.overlay(delayed)
         return result
-    elif operation == "delay" and isinstance(value, int):
+    elif operation == "delay":
         # 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" and isinstance(value, float):
+    elif operation == "distortion":
         # 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" and isinstance(value, float):
+    elif operation == "pitch_shift":
         # Note: pydub doesn't natively support pitch shifting
         print(f"Warning: Pitch shift not implemented, value: {value}")
         return audio
-    elif operation == "volume" and isinstance(value, float):
+    elif operation == "volume":
         # Adjust volume by dB
         return audio + value
     return audio
@@ -303,35 +306,18 @@ 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
             }
     
     
@@ -448,20 +434,19 @@ def export_section_variants(variants, output_folder, section_name):
 
 
 def edm_arrangement_tab():
-    
-    with gr.Blocks() as iface:
+    with gr.Tab("🎶 EDM Arranger"):
         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",
             )
-
-        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])
+            variation.change(fn=load_variation, inputs=variation, outputs=out_plot)
+        out_plot.value = editable_diagram(arrangement)
 
         with gr.Accordion("🎻 Edit Section Parameters", open=False):
             for i, (bar, tempo, name, length, curve) in enumerate(arrangement):
@@ -501,7 +486,9 @@ 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(
@@ -514,6 +501,3 @@ 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)
-
-
-