Update app.py

app.py

@@ -302,16 +302,33 @@ def midi_to_mp3(midi_obj: MidiFile, instrument: str = "Trumpet") -> Tuple[str, f
 def get_fallback_exercise(instrument: str, level: str, key: str,
                           time_sig: str, measures: int) -> str:
     key_notes = {
-        "C Major": ["C4", "D4", "E4", "G4"],
-        "G Major": ["G4", "A4", "B4", "D5"],
-        "D Major": ["D4", "E4", "F#4", "A4"],
-        "F Major": ["F4", "G4", "A4", "C5"],
-        "Bb Major": ["Bb3", "C4", "D4", "F4"],
-        "A Minor": ["A3", "B3", "C4", "D4", "E4", "G4"],
-        "E Minor": ["E3", "F#3", "G3", "A3", "B3", "D4"],
+        "C Major": ["C4", "D4", "E4", "F4", "G4", "A4", "B4"],
+        "G Major": ["G3", "A3", "B3", "C4", "D4", "E4", "F#4"],
+        "D Major": ["D4", "E4", "F#4", "G4", "A4", "B4", "C#5"],
+        "F Major": ["F3", "G3", "A3", "Bb3", "C4", "D4", "E4"],
+        "Bb Major": ["Bb3", "C4", "D4", "Eb4", "F4", "G4", "A4"],
+        "A Minor": ["A3", "B3", "C4", "D4", "E4", "F4", "G4"],
+        "E Minor": ["E3", "F#3", "G3", "A3", "B3", "C4", "D4"],
     }
     
+    # Get fundamental note from key signature
+    fundamental_note = key.split()[0]  # Gets 'C' from 'C Major' or 'A' from 'A Minor'
+    is_major = "Major" in key
+    
+    # Get notes for the key
     notes = key_notes.get(key, key_notes["C Major"])
+    
+    # Find fundamental note with octave for ending
+    fundamental_with_octave = None
+    for note in notes:
+        if note.startswith(fundamental_note):
+            fundamental_with_octave = note
+            break
+    
+    # If not found, use the first note (should not happen with our key definitions)
+    if not fundamental_with_octave:
+        fundamental_with_octave = notes[0]
+    
     numerator, denominator = map(int, time_sig.split('/'))
     
     # Calculate units based on 8th notes
@@ -329,14 +346,30 @@ def get_fallback_exercise(instrument: str, level: str, key: str,
     cumulative = 0
     current_units = 0
     
-    while current_units < target_units:
-        note = random.choice(notes)
+    # Reserve at least 2 units for the final note
+    final_note_duration = min(4, max(2, rhythm[0]))  # Between 2 and 4 units
+    available_units = target_units - final_note_duration
+    
+    # Generate notes until we reach the available units
+    while current_units < available_units:
+        # Avoid minor 7th in major keys
+        if is_major:
+            # Filter out minor 7th notes (e.g., Bb in C major)
+            available_notes = [n for n in notes if not (n.startswith("Bb") and key == "C Major") and
+                              not (n.startswith("F") and key == "G Major") and
+                              not (n.startswith("C") and key == "D Major") and
+                              not (n.startswith("Eb") and key == "F Major") and
+                              not (n.startswith("Ab") and key == "Bb Major")]
+        else:
+            available_notes = notes
+            
+        note = random.choice(available_notes)
         dur = random.choice(rhythm)
         
-        # Don't exceed target
-        if current_units + dur > target_units:
-            dur = target_units - current_units
-            if dur == 0:
+        # Don't exceed available units
+        if current_units + dur > available_units:
+            dur = available_units - current_units
+            if dur <= 0:
                 break
         
         cumulative += dur
@@ -347,6 +380,16 @@ def get_fallback_exercise(instrument: str, level: str, key: str,
             "cumulative_duration": cumulative
         })
     
+    # Add the final note (fundamental of the key)
+    final_duration = target_units - current_units
+    if final_duration > 0:
+        cumulative += final_duration
+        result.append({
+            "note": fundamental_with_octave,
+            "duration": final_duration,
+            "cumulative_duration": cumulative
+        })
+    
     return json.dumps(result)
 
 def get_style_based_on_level(level: str) -> str:
@@ -399,9 +442,19 @@ def query_mistral(prompt: str, instrument: str, level: str, key: str,
     else:
         style = get_style_based_on_level(level)
         technique = get_technique_based_on_level(level)
+        # Extract fundamental note from key signature
+        fundamental_note = key.split()[0]  # Gets 'C' from 'C Major' or 'A' from 'A Minor'
+        is_major = "Major" in key
+        
+        # Create additional musical constraints
+        key_constraints = (
+            f"The exercise MUST end on the fundamental note of the key ({fundamental_note}). "
+            f"{'' if not is_major else 'For this major key, avoid using the minor 7th degree.'}"
+        )
+        
         user_prompt = (
             f"Create a {style} {instrument.lower()} exercise in {key} with {time_sig} time signature "
-            f"{technique} for a {level.lower()} player. {duration_constraint} "
+            f"{technique} for a {level.lower()} player. {duration_constraint} {key_constraints} "
             "Output ONLY a JSON array of objects with the following structure: "
             "[{{'note': string, 'duration': integer, 'cumulative_duration': integer}}] "
             "Use standard note names (e.g., \"Bb4\", \"F#5\"). Monophonic only. "