Upload folder using huggingface_hub

improvisation_lab/application/interval_practice/web_interval_app.py

@@ -1,6 +1,7 @@
 """Web application for interval practice."""
 
-from typing import Tuple
+import time
+from typing import Any, List, Tuple
 
 import numpy as np
 
@@ -39,6 +40,10 @@ class WebIntervalPracticeApp(BasePracticeApp):
             config=config,
         )
         self.base_note = "-"
+        self.results_table: List[List[Any]] = []
+        self.progress_timer: float = 0.0
+        self.is_auto_advance = False
+        self.note_duration = 1.5
 
     def _process_audio_callback(self, audio_data: np.ndarray):
         """Process incoming audio data and update the application state.
@@ -56,10 +61,15 @@ class WebIntervalPracticeApp(BasePracticeApp):
         result = self.service.process_audio(audio_data, current_note)
 
         # Update status display
-        self.text_manager.update_pitch_result(result)
+        self.text_manager.update_pitch_result(result, self.is_auto_advance)
 
         # Progress to next note if current note is complete
-        if result.remaining_time <= 0:
+        if self.is_auto_advance:
+            current_time = time.time()
+            if current_time - self.progress_timer >= self.note_duration:
+                self._advance_to_next_note()
+                self.progress_timer = current_time
+        elif result.remaining_time <= 0:
             self._advance_to_next_note()
 
         self.text_manager.update_phrase_text(self.current_phrase_idx, self.phrases)
@@ -68,6 +78,8 @@ class WebIntervalPracticeApp(BasePracticeApp):
         """Advance to the next note or phrase."""
         if self.phrases is None:
             return
+
+        self.update_results_table()
         self.current_note_idx += 1
         if self.current_note_idx >= len(self.phrases[self.current_phrase_idx]):
             self.current_note_idx = 0
@@ -78,41 +90,50 @@ class WebIntervalPracticeApp(BasePracticeApp):
                 self.current_note_idx
             ].value
 
-    def handle_audio(self, audio: Tuple[int, np.ndarray]) -> Tuple[str, str, str]:
+    def handle_audio(self, audio: Tuple[int, np.ndarray]) -> Tuple[str, str, str, List]:
         """Handle audio input from Gradio interface.
 
         Args:
             audio: Audio data to process.
 
         Returns:
-            Tuple[str, str, str]:
+            Tuple[str, str, str, List]:
                 The current base note including the next base note,
-                target note, and result text.
+                target note, result text, and results table.
         """
         if not self.is_running:
-            return "-", "Not running", "Start the session first"
+            return "-", "Not running", "Start the session first", []
 
         self.audio_processor.process_audio(audio)
+
         return (
             self.base_note,
             self.text_manager.phrase_text,
             self.text_manager.result_text,
+            self.results_table,
         )
 
     def start(
-        self, interval: str, direction: str, number_problems: int
-    ) -> Tuple[str, str, str]:
+        self,
+        interval: str,
+        direction: str,
+        number_problems: int,
+        is_auto_advance: bool,
+        note_duration: float,
+    ) -> Tuple[str, str, str, List]:
         """Start a new practice session.
 
         Args:
             interval: Interval to move to and back.
             direction: Direction to move to and back.
             number_problems: Number of problems to generate.
+            is_auto_advance: Whether to automatically advance to the next note.
+            note_duration: Duration of each note in seconds.
 
         Returns:
-            Tuple[str, str, str]:
+            Tuple[str, str, str, List]:
                 The current base note including the next base note,
-                target note, and result text.
+                target note, result text, and results table.
         """
         semitone_interval = Intervals.INTERVALS_MAP.get(interval, 0)
 
@@ -133,11 +154,17 @@ class WebIntervalPracticeApp(BasePracticeApp):
             self.audio_processor.start_recording()
 
         self.text_manager.update_phrase_text(self.current_phrase_idx, self.phrases)
+        self.results_table = []
+
+        self.is_auto_advance = is_auto_advance
+        self.note_duration = note_duration
+        self.progress_timer = time.time()
 
         return (
             self.base_note,
             self.text_manager.phrase_text,
             self.text_manager.result_text,
+            self.results_table,
         )
 
     def stop(self) -> Tuple[str, str, str]:
@@ -162,3 +189,25 @@ class WebIntervalPracticeApp(BasePracticeApp):
     def launch(self, **kwargs):
         """Launch the application."""
         self.ui.launch(**kwargs)
+
+    def update_results_table(self):
+        """Update the results table with the latest result."""
+        if not self.is_auto_advance:
+            return
+
+        target_note = self.phrases[self.current_phrase_idx][self.current_note_idx].value
+        if self.base_note == target_note:
+            return
+        detected_note = self.text_manager.result_text.split("|")[1].strip()
+        detected_note = detected_note.replace("Your note: ", "").replace(" ", "")
+        # Result determination
+        result = "⭕️" if detected_note == target_note else "X"
+        new_result = [
+            self.current_phrase_idx + 1,
+            self.base_note,
+            target_note,
+            detected_note,
+            result,
+        ]
+
+        self.results_table.append(new_result)

improvisation_lab/presentation/interval_practice/web_interval_view.py

@@ -4,7 +4,7 @@ This module provides a web interface using Gradio for visualizing
 and interacting with interval practice sessions.
 """
 
-from typing import Callable, Tuple
+from typing import Callable, List, Tuple
 
 import gradio as gr
 import numpy as np
@@ -19,9 +19,11 @@ class WebIntervalPracticeView(WebPracticeView):
 
     def __init__(
         self,
-        on_generate_melody: Callable[[str, str, int], Tuple[str, str, str]],
+        on_generate_melody: Callable[
+            [str, str, int, bool, float], Tuple[str, str, str, List]
+        ],
         on_end_practice: Callable[[], Tuple[str, str, str]],
-        on_audio_input: Callable[[Tuple[int, np.ndarray]], Tuple[str, str, str]],
+        on_audio_input: Callable[[Tuple[int, np.ndarray]], Tuple[str, str, str, List]],
         config: Config,
     ):
         """Initialize the UI with callback functions.
@@ -78,6 +80,15 @@ class WebIntervalPracticeView(WebPracticeView):
                 self.number_problems_box = gr.Number(
                     label="Number of Problems", value=self.init_num_problems
                 )
+            with gr.Row():
+                self.auto_advance_checkbox = gr.Checkbox(
+                    label="Auto Advance Mode",
+                    value=True,
+                )
+                self.note_duration_box = gr.Number(
+                    label="Note Duration (seconds)",
+                    value=1.5,
+                )
 
             self.generate_melody_button = gr.Button("Generate Melody")
             self.base_note_box = gr.Textbox(
@@ -86,6 +97,19 @@ class WebIntervalPracticeView(WebPracticeView):
             with gr.Row():
                 self.phrase_info_box = gr.Textbox(label="Problem Information", value="")
                 self.pitch_result_box = gr.Textbox(label="Pitch Result", value="")
+            self.results_table = gr.DataFrame(
+                headers=[
+                    "Problem Number",
+                    "Base Note",
+                    "Target Note",
+                    "Detected Note",
+                    "Result",
+                ],
+                datatype=["number", "str", "str", "str", "str"],
+                value=[],
+                label="Result History",
+            )
+
             self._add_audio_input()
             self.end_practice_button = gr.Button("End Practice")
 
@@ -142,8 +166,19 @@ class WebIntervalPracticeView(WebPracticeView):
         # Connect button callbacks
         self.generate_melody_button.click(
             fn=self.on_generate_melody,
-            inputs=[self.interval_box, self.direction_box, self.number_problems_box],
-            outputs=[self.base_note_box, self.phrase_info_box, self.pitch_result_box],
+            inputs=[
+                self.interval_box,
+                self.direction_box,
+                self.number_problems_box,
+                self.auto_advance_checkbox,
+                self.note_duration_box,
+            ],
+            outputs=[
+                self.base_note_box,
+                self.phrase_info_box,
+                self.pitch_result_box,
+                self.results_table,
+            ],
         )
 
         self.end_practice_button.click(
@@ -166,7 +201,12 @@ class WebIntervalPracticeView(WebPracticeView):
         audio_input.stream(
             fn=self.on_audio_input,
             inputs=audio_input,
-            outputs=[self.base_note_box, self.phrase_info_box, self.pitch_result_box],
+            outputs=[
+                self.base_note_box,
+                self.phrase_info_box,
+                self.pitch_result_box,
+                self.results_table,
+            ],
             show_progress=False,
             stream_every=0.1,
         )

improvisation_lab/presentation/view_text_manager.py

@@ -31,17 +31,22 @@ class ViewTextManager(ABC):
         """Set the text to waiting for audio."""
         self.result_text = "Waiting for audio..."
 
-    def update_pitch_result(self, pitch_result: PitchResult):
+    def update_pitch_result(
+        self, pitch_result: PitchResult, is_auto_advance: bool = False
+    ):
         """Update the pitch result text.
 
         Args:
             pitch_result: The result of the pitch detection.
+            is_auto_advance:
+                Whether to automatically advance to the next note.
+                Default is False.
         """
         result_text = (
             f"Target: {pitch_result.target_note} | "
             f"Your note: {pitch_result.current_base_note or '---'}"
         )
-        if pitch_result.current_base_note is not None:
+        if pitch_result.current_base_note is not None and not is_auto_advance:
             result_text += f" | Remaining: {pitch_result.remaining_time:.1f}s"
         self.result_text = result_text
 

tests/application/interval_practice/test_web_interval_app.py

@@ -65,11 +65,14 @@ class TestWebIntervalPracticeApp:
         with patch.object(
             self.app.audio_processor, "process_audio", return_value=None
         ) as mock_process_audio:
-            base_note, phrase_text, result_text = self.app.handle_audio(audio_data)
+            base_note, phrase_text, result_text, results_table = self.app.handle_audio(
+                audio_data
+            )
             mock_process_audio.assert_called_once_with(audio_data)
             assert base_note == self.app.base_note
             assert phrase_text == self.app.text_manager.phrase_text
             assert result_text == self.app.text_manager.result_text
+            assert results_table == self.app.results_table
 
     @pytest.mark.usefixtures("init_module")
     def test_start(self):
@@ -78,12 +81,15 @@ class TestWebIntervalPracticeApp:
         with patch.object(
             self.app.audio_processor, "start_recording", return_value=None
         ) as mock_start_recording:
-            base_note, phrase_text, result_text = self.app.start("minor 2nd", "Up", 10)
+            base_note, phrase_text, result_text, results_table = self.app.start(
+                "minor 2nd", "Up", 10, True, 1.5
+            )
             mock_start_recording.assert_called_once()
             assert self.app.is_running
             assert base_note == self.app.base_note
             assert phrase_text == self.app.text_manager.phrase_text
             assert result_text == self.app.text_manager.result_text
+            assert results_table == self.app.results_table
 
     @pytest.mark.usefixtures("init_module")
     def test_stop(self):
@@ -98,3 +104,22 @@ class TestWebIntervalPracticeApp:
             assert base_note == "-"
             assert phrase_text == self.app.text_manager.phrase_text
             assert result_text == self.app.text_manager.result_text
+
+    @pytest.mark.usefixtures("init_module")
+    @pytest.mark.parametrize(
+        "detected_note, expected_result",
+        [("C#", "⭕️"), ("D", "X")],  # Correct case  # Incorrect case
+    )
+    def test_update_results_table(self, detected_note, expected_result):
+        """Test updating the results table with correct and incorrect results."""
+        self.app.phrases = [[Notes.C, Notes.C_SHARP, Notes.C]]
+        self.app.current_phrase_idx = 0
+        self.app.current_note_idx = 1
+        self.app.base_note = "C"
+        self.app.text_manager.result_text = f"Target: C# | Your note: {detected_note}"
+
+        self.app.is_auto_advance = True
+        self.app.update_results_table()
+
+        expected_entry = [1, "C", "C#", detected_note, expected_result]
+        assert self.app.results_table[-1] == expected_entry

tests/presentation/interval_practice/test_web_interval_view.py

@@ -57,6 +57,8 @@ class TestWebIntervalPracticeView:
         assert isinstance(self.web_view.base_note_box, gr.Textbox)
         assert isinstance(self.web_view.phrase_info_box, gr.Textbox)
         assert isinstance(self.web_view.pitch_result_box, gr.Textbox)
+        assert isinstance(self.web_view.auto_advance_checkbox, gr.Checkbox)
+        assert isinstance(self.web_view.note_duration_box, gr.Number)
 
     @pytest.mark.usefixtures("init_module")
     def test_create_control_buttons(self):

tests/presentation/test_view_text_manager.py

@@ -46,8 +46,13 @@ class TestViewTextManager:
         pitch_result = PitchResult(
             target_note="C", current_base_note="A", is_correct=False, remaining_time=2.5
         )
+        # Test without auto advance
         self.text_manager.update_pitch_result(pitch_result)
         assert (
             self.text_manager.result_text
             == "Target: C | Your note: A | Remaining: 2.5s"
         )
+
+        # Test with auto advance
+        self.text_manager.update_pitch_result(pitch_result, is_auto_advance=True)
+        assert self.text_manager.result_text == "Target: C | Your note: A"