Upload folder using huggingface_hub

.github/workflows/deploy_to_hf.yml

@@ -0,0 +1,55 @@
+
+name: Deploy to Hugging Face Spaces
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Check out the repository
+      uses: actions/checkout@v3
+
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: '3.11'
+
+    - name: Install Poetry
+      run: |
+        curl -sSL https://install.python-poetry.org | python3 -
+        echo "${{ runner.tool_cache }}/poetry/bin" >> $GITHUB_PATH
+
+    - name: Export requirements.txt
+      run: poetry export -f requirements.txt --output requirements.txt --without-hashes
+
+    - name: Create packages.txt
+      run: |
+        echo "portaudio19-dev" > packages.txt
+
+    - name: Prepend YAML header to README
+      run: |
+        cat hf_space_metadata.yml README.md > new_readme.md
+        mv new_readme.md README.md
+
+    - name: Install Hugging Face CLI
+      run: |
+        python -m pip install --upgrade pip
+        pip install huggingface_hub
+
+    - name: Configure Hugging Face CLI
+      env:
+        HF_TOKEN: ${{ secrets.HF_TOKEN }}
+      run: |
+        huggingface-cli login --token $HF_TOKEN
+
+    - name: Deploy to Spaces
+      env:
+        HF_USERNAME: ${{ secrets.HF_USERNAME }}
+        SPACE_NAME: ${{ secrets.SPACE_NAME }}
+      run: |
+        huggingface-cli upload atsushieee/improvisation-lab . --repo-type=space

.gitignore

@@ -0,0 +1,165 @@
+# Ignore config.yml
+config.yml
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

Makefile

@@ -0,0 +1,33 @@
+.PHONY: install
+install:
+	poetry install
+
+.PHONY: run
+run:
+	poetry run python main.py
+
+.PHONY: lint
+lint:
+	poetry run pflake8 improvisation_lab scripts tests main.py
+	poetry run mypy improvisation_lab scripts tests main.py
+	poetry run pydocstyle improvisation_lab scripts tests main.py
+
+.PHONY: format
+format:
+	poetry run black improvisation_lab scripts tests main.py
+	poetry run isort improvisation_lab scripts tests main.py
+
+.PHONY: test
+test:
+	poetry run pytest -vs tests
+
+.PHONY: pitch-demo-web pitch-demo-direct
+pitch-demo-web:
+	poetry run python scripts/pitch_detection_demo.py --input web
+
+pitch-demo-direct:
+	poetry run python scripts/pitch_detection_demo.py --input direct
+
+# Target alias (Default: input voice via web)
+.PHONY: pitch-demo
+pitch-demo: pitch-demo-web

README.md

@@ -1,12 +1,148 @@
 ---
 title: Improvisation Lab
-emoji: 🌖
-colorFrom: purple
-colorTo: blue
+emoji: 🎵
+python_version: 3.11
+colorFrom: blue
+colorTo: purple
 sdk: gradio
 sdk_version: 5.7.1
-app_file: app.py
+app_file: main.py
 pinned: false
+license: mit
 ---
+# Improvisation Lab
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+A Python package for generating musical improvisation melodies based on music theory principles. The package specializes in creating natural-sounding melodic phrases that follow chord progressions while respecting musical rules, with real-time pitch detection for practice feedback.
+
+Improvisation Lab Demo
+
+https://github.com/user-attachments/assets/a4207f7e-166c-4f50-9c19-5bf5269fd04e
+
+
+## Features
+
+- Generate melodic phrases based on scales and chord progressions
+- Support for multiple scale types:
+  - Major
+  - Natural minor
+  - Harmonic minor
+  - Diminished
+- Support for various chord types:
+  - Major 7th (maj7)
+  - Minor 7th (min7)
+  - Dominant 7th (dom7)
+  - Half-diminished (min7b5)
+  - Diminished 7th (dim7)
+- Intelligent note selection based on:
+  - Chord tones vs non-chord tones
+  - Scale degrees
+  - Previous note context
+- Real-time pitch detection with FCPE (Fast Context-aware Pitch Estimation)
+- Web-based and direct microphone input support
+
+## Prerequisites
+
+- Python 3.11 or higher
+- A working microphone
+- [Poetry](https://python-poetry.org/) for dependency management
+
+## Installation
+```bash
+make install
+```
+
+## Quick Start
+1. Create your configuration file:
+
+```bash
+cp config.yml.example config.yml
+```
+
+2.  (Optional) Edit `config.yml` to customize settings like audio parameters and song selection
+
+3. Run the script to start the melody generation and playback (default is web interface):
+
+```bash
+make run
+```
+
+- To run the console interface, use:
+
+```bash
+poetry run python main.py --app_type console
+```
+
+4. Follow the displayed melody phrases and sing along with real-time feedback
+
+### Configuration
+
+The application can be customized through `config.yml` with the following options:
+
+#### Audio Settings
+- `sample_rate`: Audio sampling rate (default: 44100 Hz)
+- `buffer_duration`: Duration of audio processing buffer (default: 0.2 seconds)
+- `note_duration`: How long to display each note during practice (default: 3 seconds)
+- `pitch_detector`: Configuration for the pitch detection algorithm
+  - `hop_length`: Hop length for the pitch detection algorithm (default: 512)
+  - `threshold`: Threshold for the pitch detection algorithm (default: 0.006)
+  - `f0_min`: Minimum frequency for the pitch detection algorithm (default: 80 Hz)
+  - `f0_max`: Maximum frequency for the pitch detection algorithm (default: 880 Hz)
+  - `device`: Device to use for the pitch detection algorithm (default: "cpu")
+
+#### Song Selection
+- `selected_song`: Name of the song to practice
+- `chord_progressions`: Dictionary of songs and their progressions
+  - Format: `[scale_root, scale_type, chord_root, chord_type, duration]`
+  - Example:
+    ```yaml
+    fly_me_to_the_moon:
+      - ["A", "natural_minor", "A", "min7", 4]
+      - ["A", "natural_minor", "D", "min7", 4]
+      - ["C", "major", "G", "dom7", 4]
+    ```
+
+
+## How It Works
+
+### Melody Generation
+The melody generation follows these principles:
+1. Notes are selected based on their relationship to the current chord and scale
+2. Chord tones have more freedom in movement
+3. Non-chord tones are restricted to moving to adjacent scale notes
+4. Phrases are connected naturally by considering the previous note
+5. All generated notes stay within the specified scale
+
+### Real-time Feedback
+Pitch Detection Demo:
+
+https://github.com/user-attachments/assets/fd9e6e3f-85f1-42be-a6c8-b757da478854
+
+The application provides real-time feedback by:
+1. Capturing audio from your microphone
+2. Detecting the pitch using FCPE (Fast Context-aware Pitch Estimation)
+3. Converting the frequency to the nearest musical note
+4. Displaying both the target note and your sung note in real-time
+
+## Development
+### Running Lint
+```bash
+make lint
+```
+
+### Running Format
+```bash
+make format
+```
+
+### Running Tests
+```bash
+make test
+```
+
+## License
+
+MIT License
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.

config.yml.example

@@ -0,0 +1,20 @@
+audio:
+  sample_rate: 44100
+  buffer_duration: 0.2
+  note_duration: 1.0
+  pitch_detector:
+    hop_length: 512
+    threshold: 0.006
+    f0_min: 80
+    f0_max: 880
+    device: "cpu"
+
+selected_song: "fly_me_to_the_moon"
+
+chord_progressions:
+  fly_me_to_the_moon:
+    - ["A", "natural_minor", "A", "min7", 4]
+    - ["A", "natural_minor", "D", "min7", 4]
+    - ["C", "major", "G", "dom7", 4]
+    - ["C", "major", "C", "maj7", 2]
+    - ["F", "major", "C", "dom7", 2]

hf_space_metadata.yml

@@ -0,0 +1,12 @@
+---
+title: Improvisation Lab
+emoji: 🎵
+python_version: 3.11
+colorFrom: blue
+colorTo: purple
+sdk: gradio
+sdk_version: 5.7.1
+app_file: main.py
+pinned: false
+license: mit
+---

improvisation_lab/__init__.py

@@ -0,0 +1 @@
+"""Improvisation Lab - A Python package for musical improvisation."""

improvisation_lab/application/__init__.py

@@ -0,0 +1 @@
+"""Application layer for the Improvisation Lab."""

improvisation_lab/application/melody_practice/__init__.py

@@ -0,0 +1,6 @@
+"""Application layer for melody practice."""
+
+from improvisation_lab.application.melody_practice.app_factory import \
+    MelodyPracticeAppFactory
+
+__all__ = ["MelodyPracticeAppFactory"]

improvisation_lab/application/melody_practice/app_factory.py

@@ -0,0 +1,28 @@
+"""Factory class for creating melody practice applications."""
+
+from improvisation_lab.application.melody_practice.console_app import \
+    ConsoleMelodyPracticeApp
+from improvisation_lab.application.melody_practice.web_app import \
+    WebMelodyPracticeApp
+from improvisation_lab.config import Config
+from improvisation_lab.service import MelodyPracticeService
+
+
+class MelodyPracticeAppFactory:
+    """Factory class for creating melody practice applications."""
+
+    @staticmethod
+    def create_app(app_type: str, service: MelodyPracticeService, config: Config):
+        """Create a melody practice application.
+
+        Args:
+            app_type: Type of application to create.
+            service: MelodyPracticeService instance.
+            config: Config instance.
+        """
+        if app_type == "web":
+            return WebMelodyPracticeApp(service, config)
+        elif app_type == "console":
+            return ConsoleMelodyPracticeApp(service, config)
+        else:
+            raise ValueError(f"Unknown app type: {app_type}")

improvisation_lab/application/melody_practice/base_app.py

@@ -0,0 +1,53 @@
+"""Base class for melody practice applications."""
+
+from abc import ABC, abstractmethod
+from typing import List, Optional
+
+import numpy as np
+
+from improvisation_lab.config import Config
+from improvisation_lab.domain.composition import PhraseData
+from improvisation_lab.presentation.melody_practice import ViewTextManager
+from improvisation_lab.service import MelodyPracticeService
+
+
+class BaseMelodyPracticeApp(ABC):
+    """Base class for melody practice applications."""
+
+    def __init__(self, service: MelodyPracticeService, config: Config):
+        """Initialize the application.
+
+        Args:
+            service: MelodyPracticeService instance.
+            config: Config instance.
+        """
+        self.service = service
+        self.config = config
+        self.phrases: Optional[List[PhraseData]] = None
+        self.current_phrase_idx: int = 0
+        self.current_note_idx: int = 0
+        self.is_running: bool = False
+        self.text_manager = ViewTextManager()
+
+    @abstractmethod
+    def _process_audio_callback(self, audio_data: np.ndarray):
+        """Process incoming audio data and update the application state.
+
+        Args:
+            audio_data: Audio data to process.
+        """
+        pass
+
+    @abstractmethod
+    def _advance_to_next_note(self):
+        """Advance to the next note or phrase."""
+        pass
+
+    @abstractmethod
+    def launch(self, **kwargs):
+        """Launch the application.
+
+        Args:
+            **kwargs: Additional keyword arguments for the launch method.
+        """
+        pass

improvisation_lab/application/melody_practice/console_app.py

@@ -0,0 +1,82 @@
+"""Console application for melody practice."""
+
+import time
+
+import numpy as np
+
+from improvisation_lab.application.melody_practice.base_app import \
+    BaseMelodyPracticeApp
+from improvisation_lab.config import Config
+from improvisation_lab.infrastructure.audio import DirectAudioProcessor
+from improvisation_lab.presentation.melody_practice import ConsoleMelodyView
+from improvisation_lab.service import MelodyPracticeService
+
+
+class ConsoleMelodyPracticeApp(BaseMelodyPracticeApp):
+    """Main application class for melody practice."""
+
+    def __init__(self, service: MelodyPracticeService, config: Config):
+        """Initialize the application using console UI.
+
+        Args:
+            service: MelodyPracticeService instance.
+            config: Config instance.
+        """
+        super().__init__(service, config)
+
+        self.audio_processor = DirectAudioProcessor(
+            sample_rate=config.audio.sample_rate,
+            callback=self._process_audio_callback,
+            buffer_duration=config.audio.buffer_duration,
+        )
+
+        self.ui = ConsoleMelodyView(self.text_manager, config.selected_song)
+
+    def _process_audio_callback(self, audio_data: np.ndarray):
+        """Process incoming audio data and update the application state.
+
+        Args:
+            audio_data: Audio data to process.
+        """
+        if self.phrases is None:
+            return
+        current_phrase = self.phrases[self.current_phrase_idx]
+        current_note = current_phrase.notes[self.current_note_idx]
+
+        result = self.service.process_audio(audio_data, current_note)
+        self.ui.display_pitch_result(result)
+
+        # Progress to next note if current note is complete
+        if result.remaining_time <= 0:
+            self._advance_to_next_note()
+
+    def _advance_to_next_note(self):
+        """Advance to the next note or phrase."""
+        if self.phrases is None:
+            return
+        self.current_note_idx += 1
+        if self.current_note_idx >= len(self.phrases[self.current_phrase_idx].notes):
+            self.current_note_idx = 0
+            self.current_phrase_idx += 1
+            self.ui.display_phrase_info(self.current_phrase_idx, self.phrases)
+            if self.current_phrase_idx >= len(self.phrases):
+                self.current_phrase_idx = 0
+
+    def launch(self):
+        """Launch the application."""
+        self.ui.launch()
+        self.phrases = self.service.generate_melody()
+        self.current_phrase_idx = 0
+        self.current_note_idx = 0
+        self.is_running = True
+
+        if not self.audio_processor.is_recording:
+            try:
+                self.audio_processor.start_recording()
+                self.ui.display_phrase_info(self.current_phrase_idx, self.phrases)
+                while True:
+                    time.sleep(0.1)
+            except KeyboardInterrupt:
+                print("\nStopping...")
+            finally:
+                self.audio_processor.stop_recording()

improvisation_lab/application/melody_practice/web_app.py

@@ -0,0 +1,120 @@
+"""Web application for melody practice."""
+
+import numpy as np
+
+from improvisation_lab.application.melody_practice.base_app import \
+    BaseMelodyPracticeApp
+from improvisation_lab.config import Config
+from improvisation_lab.infrastructure.audio import WebAudioProcessor
+from improvisation_lab.presentation.melody_practice import WebMelodyView
+from improvisation_lab.service import MelodyPracticeService
+
+
+class WebMelodyPracticeApp(BaseMelodyPracticeApp):
+    """Main application class for melody practice."""
+
+    def __init__(self, service: MelodyPracticeService, config: Config):
+        """Initialize the application using web UI.
+
+        Args:
+            service: MelodyPracticeService instance.
+            config: Config instance.
+        """
+        super().__init__(service, config)
+
+        self.audio_processor = WebAudioProcessor(
+            sample_rate=config.audio.sample_rate,
+            callback=self._process_audio_callback,
+            buffer_duration=config.audio.buffer_duration,
+        )
+
+        # UIをコールバック関数と共に初期化
+        self.ui = WebMelodyView(
+            on_generate_melody=self.start,
+            on_end_practice=self.stop,
+            on_audio_input=self.handle_audio,
+            song_name=config.selected_song,
+        )
+
+    def _process_audio_callback(self, audio_data: np.ndarray):
+        """Process incoming audio data and update the application state.
+
+        Args:
+            audio_data: Audio data to process.
+        """
+        if not self.is_running or not self.phrases:
+            return
+
+        current_phrase = self.phrases[self.current_phrase_idx]
+        current_note = current_phrase.notes[self.current_note_idx]
+
+        result = self.service.process_audio(audio_data, current_note)
+
+        # Update status display
+        self.text_manager.update_pitch_result(result)
+
+        # Progress to next note if current note is complete
+        if result.remaining_time <= 0:
+            self._advance_to_next_note()
+
+        self.text_manager.update_phrase_text(self.current_phrase_idx, self.phrases)
+
+    def _advance_to_next_note(self):
+        """Advance to the next note or phrase."""
+        if self.phrases is None:
+            return
+        self.current_note_idx += 1
+        if self.current_note_idx >= len(self.phrases[self.current_phrase_idx].notes):
+            self.current_note_idx = 0
+            self.current_phrase_idx += 1
+            if self.current_phrase_idx >= len(self.phrases):
+                self.current_phrase_idx = 0
+
+    def handle_audio(self, audio: tuple[int, np.ndarray]) -> tuple[str, str]:
+        """Handle audio input from Gradio interface.
+
+        Args:
+            audio: Audio data to process.
+
+        Returns:
+            tuple[str, str]: The current phrase text and result text.
+        """
+        if not self.is_running:
+            return "Not running", "Start the session first"
+
+        self.audio_processor.process_audio(audio)
+        return self.text_manager.phrase_text, self.text_manager.result_text
+
+    def start(self) -> tuple[str, str]:
+        """Start a new practice session.
+
+        Returns:
+            tuple[str, str]: The current phrase text and result text.
+        """
+        self.phrases = self.service.generate_melody()
+        self.current_phrase_idx = 0
+        self.current_note_idx = 0
+        self.is_running = True
+
+        if not self.audio_processor.is_recording:
+            self.text_manager.initialize_text()
+            self.audio_processor.start_recording()
+
+        self.text_manager.update_phrase_text(self.current_phrase_idx, self.phrases)
+        return self.text_manager.phrase_text, self.text_manager.result_text
+
+    def stop(self) -> tuple[str, str]:
+        """Stop the current practice session.
+
+        Returns:
+            tuple[str, str]: The current phrase text and result text.
+        """
+        self.is_running = False
+        if self.audio_processor.is_recording:
+            self.audio_processor.stop_recording()
+            self.text_manager.terminate_text()
+        return self.text_manager.phrase_text, self.text_manager.result_text
+
+    def launch(self, **kwargs):
+        """Launch the application."""
+        self.ui.launch(**kwargs)

improvisation_lab/config.py

@@ -0,0 +1,89 @@
+"""Configuration module for audio settings and chord progressions."""
+
+from dataclasses import dataclass, field
+from pathlib import Path
+
+import yaml
+
+
+@dataclass
+class PitchDetectorConfig:
+    """Configuration settings for pitch detection."""
+
+    sample_rate: int = 44100
+    hop_length: int = 512
+    decoder_mode: str = "local_argmax"
+    threshold: float = 0.006
+    f0_min: int = 80
+    f0_max: int = 880
+    interp_uv: bool = False
+    device: str = "cpu"
+
+
+@dataclass
+class AudioConfig:
+    """Configuration class for audio-related settings."""
+
+    sample_rate: int = 44100
+    buffer_duration: float = 0.2
+    note_duration: float = 1.0
+    pitch_detector: PitchDetectorConfig = field(default_factory=PitchDetectorConfig)
+
+    @classmethod
+    def from_yaml(cls, yaml_data: dict) -> "AudioConfig":
+        """Create AudioConfig instance from YAML data."""
+        config = cls(
+            sample_rate=yaml_data.get("sample_rate", cls.sample_rate),
+            buffer_duration=yaml_data.get("buffer_duration", cls.buffer_duration),
+            note_duration=yaml_data.get("note_duration", cls.note_duration),
+        )
+
+        if "pitch_detector" in yaml_data:
+            pitch_detector_data = yaml_data["pitch_detector"]
+            # The sample rate must be set explicitly
+            # Use the sample rate specified in the audio config
+            pitch_detector_data["sample_rate"] = config.sample_rate
+            config.pitch_detector = PitchDetectorConfig(**pitch_detector_data)
+
+        return config
+
+
+@dataclass
+class Config:
+    """Application configuration handler."""
+
+    audio: AudioConfig
+    selected_song: str
+    chord_progressions: dict
+
+    def __init__(self, config_path: str | Path = "config.yml"):
+        """Initialize Config instance.
+
+        Args:
+            config_path: Path to YAML configuration file (default: 'config.yml').
+        """
+        self.config_path = Path(config_path)
+        self._load_config()
+
+    def _load_config(self):
+        if self.config_path.exists():
+            with open(self.config_path, "r") as f:
+                yaml_data = yaml.safe_load(f)
+                self.audio = AudioConfig.from_yaml(yaml_data.get("audio", {}))
+                self.selected_song = yaml_data.get(
+                    "selected_song", "fly_me_to_the_moon"
+                )
+                self.chord_progressions = yaml_data.get("chord_progressions", {})
+        else:
+            self.audio = AudioConfig()
+            self.selected_song = "fly_me_to_the_moon"
+            self.chord_progressions = {
+                # opening 4 bars of Fly Me to the Moon
+                "fly_me_to_the_moon": [
+                    ("A", "natural_minor", "A", "min7", 8),
+                    ("A", "natural_minor", "D", "min7", 8),
+                    ("C", "major", "G", "dom7", 8),
+                    ("C", "major", "C", "maj7", 4),
+                    ("F", "major", "C", "dom7", 4),
+                ]
+            }

improvisation_lab/domain/__init__.py

@@ -0,0 +1 @@
+"""Package containing domain logic."""

improvisation_lab/domain/analysis/__init__.py

@@ -0,0 +1,5 @@
+"""Module for music analysis."""
+
+from improvisation_lab.domain.analysis.pitch_detector import PitchDetector
+
+__all__ = ["PitchDetector"]

improvisation_lab/domain/analysis/pitch_detector.py

@@ -0,0 +1,61 @@
+"""PitchDetector class for real-time pitch detection using FCPE."""
+
+import numpy as np
+import torch
+from torchfcpe import spawn_bundled_infer_model
+
+from improvisation_lab.config import PitchDetectorConfig
+
+
+class PitchDetector:
+    """Class for real-time pitch detection using FCPE."""
+
+    def __init__(self, config: PitchDetectorConfig):
+        """Initialize pitch detector.
+
+        Args:
+            config: Configuration settings for pitch detection.
+        """
+        self.sample_rate = config.sample_rate
+        self.hop_length = config.hop_length
+        self.decoder_mode = config.decoder_mode
+        self.threshold = config.threshold
+        self.f0_min = config.f0_min
+        self.f0_max = config.f0_max
+        self.interp_uv = config.interp_uv
+        self.model = spawn_bundled_infer_model(device=config.device)
+
+    def detect_pitch(self, audio_frame: np.ndarray) -> float:
+        """Detect pitch from audio frame.
+
+        Args:
+            audio_frame: Numpy array of audio samples
+
+        Returns:
+            Frequency in Hz
+        """
+        audio_length = len(audio_frame)
+        f0_target_length = (audio_length // self.hop_length) + 1
+
+        # Convert to torch tensor and reshape to match expected dimensions
+        # Add batch and channel dimensions
+        audio_tensor = torch.from_numpy(audio_frame).float()
+        audio_tensor = audio_tensor.unsqueeze(0).unsqueeze(-1)
+
+        pitch = self.model.infer(
+            audio_tensor,
+            sr=self.sample_rate,
+            decoder_mode=self.decoder_mode,
+            threshold=self.threshold,
+            f0_min=self.f0_min,
+            f0_max=self.f0_max,
+            interp_uv=self.interp_uv,
+            output_interp_target_length=f0_target_length,
+        )
+
+        # Extract the middle frequency value from the pitch tensor
+        # Taking the middle value helps avoid potential inaccuracies at the edges
+        # of the audio frame, providing a more stable frequency estimate.
+        middle_index = pitch.size(1) // 2
+        frequency = pitch[0, middle_index, 0].item()
+        return frequency

improvisation_lab/domain/composition/__init__.py

@@ -0,0 +1,6 @@
+"""Module for melody improvisation generation."""
+
+from improvisation_lab.domain.composition.melody_composer import (
+    MelodyComposer, PhraseData)
+
+__all__ = ["PhraseData", "MelodyComposer"]

improvisation_lab/domain/composition/melody_composer.py

@@ -0,0 +1,71 @@
+"""Module for handling melody generation and playback."""
+
+from dataclasses import dataclass
+from typing import List, Optional
+
+from improvisation_lab.domain.composition.phrase_generator import \
+    PhraseGenerator
+from improvisation_lab.domain.music_theory import ChordTone
+
+
+@dataclass
+class PhraseData:
+    """Data structure containing information about a melodic phrase."""
+
+    notes: List[str]
+    chord_name: str
+    scale_info: str
+    length: int
+
+
+class MelodyComposer:
+    """Class responsible for generating melodic phrases based on chord progressions."""
+
+    def __init__(self):
+        """Initialize MelodyPlayer with a melody generator."""
+        self.phrase_generator = PhraseGenerator()
+
+    def generate_phrases(
+        self, progression: List[tuple[str, str, str, str, int]]
+    ) -> List[PhraseData]:
+        """Generate a sequence of melodic phrases based on a chord progression.
+
+        Args:
+            progression:
+                List of tuples containing (scale_root, scale_type, chord_root,
+                chord_type, length) for each chord in the progression.
+
+        Returns:
+            List of PhraseData objects containing the generated melodic phrases.
+        """
+        phrases: List[PhraseData] = []
+        prev_note: Optional[str] = None
+        prev_note_was_chord_tone = False
+
+        for scale_root, scale_type, chord_root, chord_type, length in progression:
+            phrase = self.phrase_generator.generate_phrase(
+                scale_root=scale_root,
+                scale_type=scale_type,
+                chord_root=chord_root,
+                chord_type=chord_type,
+                prev_note=prev_note,
+                prev_note_was_chord_tone=prev_note_was_chord_tone,
+                length=length,
+            )
+
+            # Update information for the next phrase
+            prev_note = phrase[-1]
+            prev_note_was_chord_tone = self.phrase_generator.is_chord_tone(
+                prev_note, ChordTone.get_chord_tones(chord_root, chord_type)
+            )
+
+            phrases.append(
+                PhraseData(
+                    notes=phrase,
+                    chord_name=f"{chord_root}{chord_type}",
+                    scale_info=f"{scale_root} {scale_type}",
+                    length=length,
+                )
+            )
+
+        return phrases

improvisation_lab/domain/composition/phrase_generator.py

@@ -0,0 +1,188 @@
+"""Module for generating improvised melody phrases.
+
+This module provides functionality to generate natural melody phrases
+based on given scales and chord progressions, following music theory principles.
+"""
+
+import random
+
+from improvisation_lab.domain.music_theory import ChordTone, Notes, Scale
+
+
+class PhraseGenerator:
+    """Class for generating improvised melody phrases.
+
+    This class generates melody phrases based on given scales and chord progressions,
+    following music theory rules.
+    The next note selection depends on whether the current note is a chord tone or not,
+    with chord tones having more freedom in movement
+    while non-chord tones move to adjacent notes.
+    """
+
+    def is_chord_tone(self, note: str, chord_tones: list[str]) -> bool:
+        """Check if a note is a chord tone.
+
+        Args:
+            note: The note to check.
+            chord_tones: The list of chord tones.
+
+        Returns:
+            True if the note is a chord tone, False otherwise.
+        """
+        return note in chord_tones
+
+    def get_adjacent_notes(self, note: str, scale_notes: list[str]) -> list[str]:
+        """Get adjacent notes to a given note.
+
+        Args:
+            note: The note to get adjacent notes to.
+            scale_notes: The list of notes in the scale.
+
+        Returns:
+            The list of adjacent notes in order (lower note first, then higher note).
+        """
+        length_scale_notes = len(scale_notes)
+        if note in scale_notes:
+            note_index = scale_notes.index(note)
+            return [
+                scale_notes[(note_index - 1) % length_scale_notes],
+                scale_notes[(note_index + 1) % length_scale_notes],
+            ]
+
+        return [
+            self._find_closest_note_in_direction(note, scale_notes, -1),
+            self._find_closest_note_in_direction(note, scale_notes, 1),
+        ]
+
+    def _find_closest_note_in_direction(
+        self, note: str, scale_notes: list[str], direction: int
+    ) -> str:
+        """Find the closest note in a given direction within the scale.
+
+        Args:
+            start_index: Starting index in the chromatic scale.
+            all_notes: List of all notes (chromatic scale).
+            scale_notes: List of notes in the target scale.
+            direction: Direction to search (-1 for lower, 1 for higher).
+
+        Returns:
+            The closest note in the given direction that exists in the scale.
+        """
+        all_notes = [note.value for note in Notes]  # Chromatic scale
+        note_index = all_notes.index(note)
+
+        current_index = note_index
+        while True:
+            current_index = (current_index + direction) % 12
+            current_note = all_notes[current_index]
+            if current_note in scale_notes:
+                return current_note
+            if current_index == note_index:  # If we've gone full circle
+                break
+        return all_notes[current_index]
+
+    def get_next_note(
+        self, current_note: str, scale_notes: list[str], chord_tones: list[str]
+    ) -> str:
+        """Get the next note based on the current note, scale, and chord tones.
+
+        Args:
+            current_note: The current note.
+            scale_notes: The list of notes in the scale.
+            chord_tones: The list of chord tones.
+
+        Returns:
+            The next note.
+        """
+        is_current_chord_tone = self.is_chord_tone(current_note, chord_tones)
+
+        if is_current_chord_tone:
+            # For chord tones, freely move to any scale note
+            available_notes = [note for note in scale_notes if note != current_note]
+            return random.choice(available_notes)
+        # For non-chord tones, move to adjacent notes only
+        adjacent_notes = self.get_adjacent_notes(current_note, scale_notes)
+        return random.choice(adjacent_notes)
+
+    def select_first_note(
+        self,
+        scale_notes: list[str],
+        chord_tones: list[str],
+        prev_note: str | None = None,
+        prev_note_was_chord_tone: bool = False,
+    ) -> str:
+        """Select the first note of a phrase.
+
+        Args:
+            scale_notes: The list of notes in the scale.
+            chord_tones: The list of chord tones.
+            prev_note: The last note of the previous phrase (default: None).
+            prev_note_was_chord_tone:
+                Whether the previous note was a chord tone (default: False).
+
+        Returns:
+            The selected first note.
+        """
+        # For the first phrase, randomly select from scale notes
+        if prev_note is None:
+            return random.choice(scale_notes)
+
+        # Case: previous note was a chord tone, can move freely
+        if prev_note_was_chord_tone:
+            available_notes = [note for note in scale_notes if note != prev_note]
+            return random.choice(available_notes)
+
+        # Case: previous note was not a chord tone
+        if prev_note in chord_tones:
+            # If it's a chord tone in the current chord, can move freely
+            available_notes = [note for note in scale_notes if note != prev_note]
+            return random.choice(available_notes)
+
+        # If it's not a chord tone, can only move to adjacent notes
+        adjacent_notes = self.get_adjacent_notes(prev_note, scale_notes)
+        return random.choice(adjacent_notes)
+
+    def generate_phrase(
+        self,
+        scale_root: str,
+        scale_type: str,
+        chord_root: str,
+        chord_type: str,
+        prev_note: str | None = None,
+        prev_note_was_chord_tone: bool = False,
+        length=8,
+    ) -> list[str]:
+        """Generate a phrase of notes.
+
+        Args:
+            scale_root: The root note of the scale.
+            scale_type: The type of scale (e.g., "major", "natural_minor").
+            chord_root: The root note of the chord.
+            chord_type: The type of chord (e.g., "maj", "maj7").
+            prev_note: The last note of the previous phrase (default: None).
+            prev_note_was_chord_tone:
+                Whether the previous note was a chord tone (default: False).
+            length: The length of the phrase (default: 8).
+
+        Returns:
+            A list of note names in the phrase.
+        """
+        # Get scale notes and chord tones
+        scale_notes = Scale.get_scale_notes(scale_root, scale_type)
+        chord_tones = ChordTone.get_chord_tones(chord_root, chord_type)
+
+        # Generate the phrase
+        phrase = []
+
+        # Select the first note
+        current_note = self.select_first_note(
+            scale_notes, chord_tones, prev_note, prev_note_was_chord_tone
+        )
+        phrase.append(current_note)
+
+        # Generate remaining notes
+        for _ in range(length - 1):
+            current_note = self.get_next_note(current_note, scale_notes, chord_tones)
+            phrase.append(current_note)
+
+        return phrase

improvisation_lab/domain/music_theory.py

@@ -0,0 +1,172 @@
+"""Module containing basic music theory concepts and constants."""
+
+from enum import Enum
+
+import numpy as np
+
+
+class Notes(str, Enum):
+    """Enumeration of musical notes in chromatic scale.
+
+    This class represents the twelve notes of the chromatic scale
+    and provides methods for note manipulation and validation.
+    It inherits from both str and Enum to provide string-like behavior
+    while maintaining the benefits of enumeration.
+
+    The str inheritance allows direct string operations on the note values,
+    while Enum ensures type safety and provides a defined set of valid notes.
+
+    Examples:
+        >>> note = Notes.C
+        >>> isinstance(note, str)  # True
+        >>> note.lower()  # 'c'
+        >>> note + 'm'    # 'Cm'
+    """
+
+    C = "C"
+    C_SHARP = "C#"
+    D = "D"
+    D_SHARP = "D#"
+    E = "E"
+    F = "F"
+    F_SHARP = "F#"
+    G = "G"
+    G_SHARP = "G#"
+    A = "A"
+    A_SHARP = "A#"
+    B = "B"
+
+    @classmethod
+    def get_note_index(cls, note: str) -> int:
+        """Get the index of a note in the chromatic scale.
+
+        Args:
+            note (str): The note name to find the index for.
+
+        Returns:
+            int: The index of the note in the chromatic scale (0-11).
+        """
+        return list(cls).index(cls(note))
+
+    @classmethod
+    def get_chromatic_scale(cls, note: str) -> list[str]:
+        """Return all notes in chromatic order.
+
+        Args:
+            note (str): The note name to start the chromatic scale from.
+
+        Returns:
+            list[str]: A list of note names in chromatic order,
+                      starting from C (e.g., ["C", "C#", "D", ...]).
+        """
+        start_idx = cls.get_note_index(note)
+        all_notes = [note.value for note in cls]
+        return all_notes[start_idx:] + all_notes[:start_idx]
+
+    @classmethod
+    def convert_frequency_to_note(cls, frequency: float) -> str:
+        """Convert a frequency in Hz to the nearest note name on a piano keyboard.
+
+        Args:
+            frequency: The frequency in Hz.
+
+        Returns:
+            The name of the nearest note.
+        """
+        A4_frequency = 440.0
+        # Calculate the number of semitones from A4 (440Hz)
+        n = 12 * np.log2(frequency / A4_frequency)
+
+        # Round to the nearest semitone
+        n = round(n)
+
+        # Calculate octave and index of note name with respect to A4
+        octave = 4 + (n + 9) // 12
+        note_idx = (n + 9) % 12
+
+        note = cls.get_chromatic_scale(cls.C)[note_idx]
+        return f"{note}{octave}"
+
+    @classmethod
+    def convert_frequency_to_base_note(cls, frequency: float) -> str:
+        """Convert frequency to base note name without octave number.
+
+        Args:
+            frequency: Frequency in Hz
+
+        Returns:
+            Base note name (e.g., 'C', 'C#', 'D')
+        """
+        note_with_octave = cls.convert_frequency_to_note(frequency)
+        return note_with_octave[:-1]  # Remove the octave number
+
+
+class Scale:
+    """Musical scale representation and operations.
+
+    This class handles scale-related operations including scale generation
+    and scale note calculations.
+    """
+
+    SCALES = {
+        "major": [0, 2, 4, 5, 7, 9, 11],
+        "natural_minor": [0, 2, 3, 5, 7, 8, 10],
+        "harmonic_minor": [0, 2, 3, 5, 7, 8, 11],
+        "diminished": [0, 2, 3, 5, 6, 8, 9, 11],
+    }
+
+    @classmethod
+    def get_scale_notes(cls, root_note: str, scale_type: str) -> list[str]:
+        """Generate scale notes from root note and scale type.
+
+        Args:
+            root_note: The root note of the scale.
+            scale_type: The type of scale (e.g., "major", "natural_minor").
+
+        Returns:
+            A list of note names in the scale.
+
+        Raises:
+            ValueError: If root_note is invalid or scale_type is not recognized.
+        """
+        if scale_type not in cls.SCALES:
+            raise ValueError(f"Invalid scale type: {scale_type}")
+
+        scale_pattern = cls.SCALES[scale_type]
+        chromatic = Notes.get_chromatic_scale(root_note)
+        return [chromatic[interval % 12] for interval in scale_pattern]
+
+
+class ChordTone:
+    """Musical chord tone representation and operations.
+
+    This class handles chord tone-related operations
+    including chord tone generation and chord tone calculation.
+    """
+
+    CHORD_TONES = {
+        "maj": [0, 4, 7, 9],
+        "maj7": [0, 4, 7, 11],
+        "min7": [0, 3, 7, 10],
+        "min7(b5)": [0, 3, 6, 10],
+        "dom7": [0, 4, 7, 10],
+        "dim7": [0, 3, 6, 9],
+    }
+
+    @classmethod
+    def get_chord_tones(cls, root_note: str, chord_type: str) -> list[str]:
+        """Generate chord tones from root note and chord type.
+
+        Args:
+            root_note: The root note of the chord.
+            chord_type: The type of chord (e.g., "maj", "maj7").
+
+        Returns:
+            A list of note names in the chord.
+        """
+        if chord_type not in cls.CHORD_TONES:
+            raise ValueError(f"Invalid chord type: {chord_type}")
+
+        chord_pattern = cls.CHORD_TONES[chord_type]
+        chromatic = Notes.get_chromatic_scale(root_note)
+        return [chromatic[interval] for interval in chord_pattern]

improvisation_lab/infrastructure/__init__.py

@@ -0,0 +1 @@
+"""Infrastructure layer for handling external dependencies and implementations."""

improvisation_lab/infrastructure/audio/__init__.py

@@ -0,0 +1,10 @@
+"""Audio infrastructure components."""
+
+from improvisation_lab.infrastructure.audio.audio_processor import \
+    AudioProcessor
+from improvisation_lab.infrastructure.audio.direct_processor import \
+    DirectAudioProcessor
+from improvisation_lab.infrastructure.audio.web_processor import \
+    WebAudioProcessor
+
+__all__ = ["AudioProcessor", "DirectAudioProcessor", "WebAudioProcessor"]

improvisation_lab/infrastructure/audio/audio_processor.py

@@ -0,0 +1,53 @@
+"""Module providing abstract base class for audio input handling."""
+
+from abc import ABC, abstractmethod
+from typing import Callable
+
+import numpy as np
+
+
+class AudioProcessor(ABC):
+    """Abstract base class for audio input handling."""
+
+    def __init__(
+        self,
+        sample_rate: int,
+        callback: Callable[[np.ndarray], None] | None = None,
+        buffer_duration: float = 0.2,
+    ):
+        """Initialize AudioInput.
+
+        Args:
+            sample_rate: Audio sample rate in Hz
+            callback: Optional callback function to process audio data
+            buffer_duration: Duration of audio buffer in seconds
+        """
+        self.sample_rate = sample_rate
+        self.is_recording = False
+        self._callback = callback
+        self._buffer = np.array([], dtype=np.float32)
+        self._buffer_size = int(sample_rate * buffer_duration)
+
+    def _append_to_buffer(self, audio_data: np.ndarray) -> None:
+        """Append new audio data to the buffer."""
+        # Convert stereo to mono if necessary
+        if audio_data.ndim > 1:
+            audio_data = np.mean(audio_data, axis=1)
+        self._buffer = np.concatenate([self._buffer, audio_data])
+
+    def _process_buffer(self) -> None:
+        """Process buffer data if it has reached the desired size."""
+        if len(self._buffer) >= self._buffer_size:
+            if self._callback is not None:
+                self._callback(self._buffer[: self._buffer_size])
+            self._buffer = self._buffer[self._buffer_size :]
+
+    @abstractmethod
+    def start_recording(self):
+        """Start recording audio."""
+        pass
+
+    @abstractmethod
+    def stop_recording(self):
+        """Stop recording audio."""
+        pass

improvisation_lab/infrastructure/audio/direct_processor.py

@@ -0,0 +1,104 @@
+"""Module for handling microphone input and audio processing.
+
+This module provides functionality for real-time audio capture from a microphone,
+with support for buffering and callback-based processing of audio data.
+"""
+
+from typing import Callable
+
+import numpy as np
+import pyaudio
+
+from improvisation_lab.infrastructure.audio.audio_processor import \
+    AudioProcessor
+
+
+class DirectAudioProcessor(AudioProcessor):
+    """Handle real-time audio input from microphone.
+
+    This class provides functionality to:
+    1. Capture audio from the default microphone
+    2. Buffer the incoming audio data
+    3. Process the buffered data through a user-provided callback function
+
+    The audio processing is done in chunks, with the chunk size determined by
+    the buffer_duration parameter. This allows for efficient real-time
+    processing of audio data, such as pitch detection.
+    """
+
+    def __init__(
+        self,
+        sample_rate: int,
+        callback: Callable[[np.ndarray], None] | None = None,
+        buffer_duration: float = 0.2,
+    ):
+        """Initialize MicInput.
+
+        Args:
+            sample_rate: Audio sample rate in Hz
+            callback: Optional callback function to process audio data
+            buffer_duration: Duration of audio buffer in seconds before processing
+        """
+        super().__init__(sample_rate, callback, buffer_duration)
+        self.audio = None
+        self._stream = None
+
+    def _audio_callback(
+        self, in_data: bytes, frame_count: int, time_info: dict, status: int
+    ) -> tuple[bytes, int]:
+        """Process incoming audio data.
+
+        This callback is automatically called by PyAudio
+        when new audio data is available.
+        The audio data is converted to a numpy array and:
+        1. Stored in the internal buffer
+        2. Passed to the user-provided callback function if one exists
+
+        Note:
+            This method follows PyAudio's callback function specification.
+            It must accept four arguments (in_data, frame_count, time_info, status)
+            and return a tuple of (bytes, status_flag).
+            These arguments are automatically provided by PyAudio
+            when calling this callback.
+
+        Args:
+            in_data: Raw audio input data as bytes
+            frame_count: Number of frames in the input
+            time_info: Dictionary with timing information
+            status: Stream status flag
+
+        Returns:
+            Tuple of (input_data, pyaudio.paContinue)
+        """
+        # Convert bytes to numpy array (float32 format)
+        audio_data = np.frombuffer(in_data, dtype=np.float32)
+        self._append_to_buffer(audio_data)
+        self._process_buffer()
+        return (in_data, pyaudio.paContinue)
+
+    def start_recording(self):
+        """Start recording from microphone."""
+        if self.is_recording:
+            raise RuntimeError("Recording is already in progress")
+
+        self.audio = pyaudio.PyAudio()
+        self._stream = self.audio.open(
+            format=pyaudio.paFloat32,
+            channels=1,
+            rate=self.sample_rate,
+            input=True,
+            stream_callback=self._audio_callback,
+        )
+        self.is_recording = True
+
+    def stop_recording(self):
+        """Stop recording from microphone."""
+        if not self.is_recording:
+            raise RuntimeError("Recording is not in progress")
+
+        self._stream.stop_stream()
+        self._stream.close()
+        self.audio.terminate()
+        self.is_recording = False
+        self._stream = None
+        self.audio = None

improvisation_lab/infrastructure/audio/web_processor.py

@@ -0,0 +1,112 @@
+"""Module for handling audio input through Gradio interface."""
+
+from typing import Callable
+
+import numpy as np
+from scipy import signal
+
+from improvisation_lab.infrastructure.audio.audio_processor import \
+    AudioProcessor
+
+
+class WebAudioProcessor(AudioProcessor):
+    """Handle audio input from Gradio interface."""
+
+    def __init__(
+        self,
+        sample_rate: int,
+        callback: Callable[[np.ndarray], None] | None = None,
+        buffer_duration: float = 0.2,
+    ):
+        """Initialize GradioAudioInput.
+
+        Args:
+            sample_rate: Audio sample rate in Hz
+            callback: Optional callback function to process audio data
+            buffer_duration: Duration of audio buffer in seconds
+        """
+        super().__init__(sample_rate, callback, buffer_duration)
+
+    def _resample_audio(
+        self, audio_data: np.ndarray, original_sr: int, target_sr: int
+    ) -> np.ndarray:
+        """Resample audio data to target sample rate.
+
+        In the case of Gradio,
+        the sample rate of the audio data may not match the target sample rate.
+
+        Args:
+            audio_data: numpy array of audio samples
+            original_sr: Original sample rate in Hz
+            target_sr: Target sample rate in Hz
+
+        Returns:
+            Resampled audio data with target sample rate
+        """
+        number_of_samples = round(len(audio_data) * float(target_sr) / original_sr)
+        resampled_data = signal.resample(audio_data, number_of_samples)
+        return resampled_data
+
+    def _normalize_audio(self, audio_data: np.ndarray) -> np.ndarray:
+        """Normalize audio data to range [-1, 1] by dividing by maximum absolute value.
+
+        Args:
+            audio_data: numpy array of audio samples
+
+        Returns:
+            Normalized audio data with values between -1 and 1
+        """
+        if len(audio_data) == 0:
+            return audio_data
+        max_abs = np.max(np.abs(audio_data))
+        return audio_data if max_abs == 0 else audio_data / max_abs
+
+    def _remove_low_amplitude_noise(self, audio_data: np.ndarray) -> np.ndarray:
+        """Remove low amplitude noise from audio data.
+
+        Applies a threshold to remove low amplitude signals that are likely noise.
+
+        Args:
+            audio_data: Audio data as numpy array
+
+        Returns:
+            Audio data with low amplitude noise removed
+        """
+        # [TODO] Set appropriate threshold
+        threshold = 20.0
+        audio_data[np.abs(audio_data) < threshold] = 0
+        return audio_data
+
+    def process_audio(self, audio_input: tuple[int, np.ndarray]) -> None:
+        """Process incoming audio data from Gradio.
+
+        Args:
+            audio_input: Tuple of (sample_rate, audio_data)
+                        where audio_data is a (samples, channels) array
+        """
+        if not self.is_recording:
+            return
+
+        input_sample_rate, audio_data = audio_input
+        if input_sample_rate != self.sample_rate:
+            audio_data = self._resample_audio(
+                audio_data, input_sample_rate, self.sample_rate
+            )
+        audio_data = self._remove_low_amplitude_noise(audio_data)
+        audio_data = self._normalize_audio(audio_data)
+
+        self._append_to_buffer(audio_data)
+        self._process_buffer()
+
+    def start_recording(self):
+        """Start accepting audio input from Gradio."""
+        if self.is_recording:
+            raise RuntimeError("Recording is already in progress")
+        self.is_recording = True
+
+    def stop_recording(self):
+        """Stop accepting audio input from Gradio."""
+        if not self.is_recording:
+            raise RuntimeError("Recording is not in progress")
+        self.is_recording = False
+        self._buffer = np.array([], dtype=np.float32)

improvisation_lab/presentation/__init__.py

@@ -0,0 +1 @@
+"""Presentation layer for the application."""

improvisation_lab/presentation/melody_practice/__init__.py

@@ -0,0 +1,14 @@
+"""Presentation layer for melody practice.
+
+This package contains modules for handling the user interface
+and text management for melody practice applications.
+"""
+
+from improvisation_lab.presentation.melody_practice.console_melody_view import \
+    ConsoleMelodyView
+from improvisation_lab.presentation.melody_practice.view_text_manager import \
+    ViewTextManager
+from improvisation_lab.presentation.melody_practice.web_melody_view import \
+    WebMelodyView
+
+__all__ = ["WebMelodyView", "ViewTextManager", "ConsoleMelodyView"]

improvisation_lab/presentation/melody_practice/console_melody_view.py

@@ -0,0 +1,56 @@
+"""Console-based melody practice view.
+
+This module provides a console interface for visualizing
+and interacting with melody practice sessions.
+"""
+
+from typing import List
+
+from improvisation_lab.domain.composition import PhraseData
+from improvisation_lab.presentation.melody_practice.view_text_manager import \
+    ViewTextManager
+from improvisation_lab.service.melody_practice_service import PitchResult
+
+
+class ConsoleMelodyView:
+    """Console-based implementation of melody visualization."""
+
+    def __init__(self, text_manager: ViewTextManager, song_name: str):
+        """Initialize the console view with a text manager and song name.
+
+        Args:
+            text_manager: Text manager for updating and displaying text.
+            song_name: Name of the song to be practiced.
+        """
+        self.text_manager = text_manager
+        self.song_name = song_name
+
+    def launch(self):
+        """Run the console interface."""
+        print("\n" + f"Generating melody for {self.song_name}:")
+        print("Sing each note for 1 second!")
+
+    def display_phrase_info(self, phrase_number: int, phrases_data: List[PhraseData]):
+        """Display phrase information in console.
+
+        Args:
+            phrase_number: Number of the phrase.
+            phrases_data: List of phrase data.
+        """
+        self.text_manager.update_phrase_text(phrase_number, phrases_data)
+        print("\n" + "-" * 50)
+        print("\n" + self.text_manager.phrase_text + "\n")
+
+    def display_pitch_result(self, pitch_result: PitchResult):
+        """Display note status in console.
+
+        Args:
+            pitch_result: The result of the pitch detection.
+        """
+        self.text_manager.update_pitch_result(pitch_result)
+        print(f"{self.text_manager.result_text:<80}", end="\r", flush=True)
+
+    def display_practice_end(self):
+        """Display practice end message in console."""
+        self.text_manager.terminate_text()
+        print(self.text_manager.phrase_text)

improvisation_lab/presentation/melody_practice/view_text_manager.py

@@ -0,0 +1,70 @@
+"""Text management for melody practice.
+
+This class manages the text displayed
+in both the web and console versions of the melody practice.
+"""
+
+from typing import List
+
+from improvisation_lab.domain.composition import PhraseData
+from improvisation_lab.service.melody_practice_service import PitchResult
+
+
+class ViewTextManager:
+    """Displayed text management for melody practice."""
+
+    def __init__(self):
+        """Initialize the text manager."""
+        self.initialize_text()
+
+    def initialize_text(self):
+        """Initialize the text."""
+        self.phrase_text = "No phrase data"
+        self.result_text = "Ready to start... (waiting for audio)"
+
+    def terminate_text(self):
+        """Terminate the text."""
+        self.phrase_text = "Session Stopped"
+        self.result_text = "Practice ended"
+
+    def set_waiting_for_audio(self):
+        """Set the text to waiting for audio."""
+        self.result_text = "Waiting for audio..."
+
+    def update_pitch_result(self, pitch_result: PitchResult):
+        """Update the pitch result text.
+
+        Args:
+            pitch_result: The result of the pitch detection.
+        """
+        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:
+            result_text += f" | Remaining: {pitch_result.remaining_time:.1f}s"
+        self.result_text = result_text
+
+    def update_phrase_text(self, current_phrase_idx: int, phrases: List[PhraseData]):
+        """Update the phrase text.
+
+        Args:
+            current_phrase_idx: The index of the current phrase.
+            phrases: The list of phrases.
+        """
+        if not phrases:
+            self.phrase_text = "No phrase data"
+            return self.phrase_text
+
+        current_phrase = phrases[current_phrase_idx]
+        self.phrase_text = (
+            f"Phrase {current_phrase_idx + 1}: "
+            f"{current_phrase.chord_name}\n"
+            f"{' -> '.join(current_phrase.notes)}"
+        )
+
+        if current_phrase_idx < len(phrases) - 1:
+            next_phrase = phrases[current_phrase_idx + 1]
+            self.phrase_text += (
+                f"\nNext: {next_phrase.chord_name} ({next_phrase.notes[0]})"
+            )

improvisation_lab/presentation/melody_practice/web_melody_view.py

@@ -0,0 +1,99 @@
+"""Web-based melody practice view.
+
+This module provides a web interface using Gradio for visualizing
+and interacting with melody practice sessions.
+"""
+
+from typing import Any, Callable
+
+import gradio as gr
+
+
+class WebMelodyView:
+    """Handles the user interface for the melody practice application."""
+
+    def __init__(
+        self,
+        on_generate_melody: Callable[[], tuple[str, str]],
+        on_end_practice: Callable[[], tuple[str, str]],
+        on_audio_input: Callable[[Any], tuple[str, str]],
+        song_name: str,
+    ):
+        """Initialize the UI with callback functions.
+
+        Args:
+            on_generate_melody: Function to call when start button is clicked
+            on_end_practice: Function to call when stop button is clicked
+            on_audio_input: Function to process audio input
+            song_name: Name of the song to be practiced
+        """
+        self.on_generate_melody = on_generate_melody
+        self.on_end_practice = on_end_practice
+        self.on_audio_input = on_audio_input
+        self.song_name = song_name
+
+    def _build_interface(self) -> gr.Blocks:
+        """Create and configure the Gradio interface.
+
+        Returns:
+            gr.Blocks: The Gradio interface.
+        """
+        with gr.Blocks() as app:
+            self._add_header()
+            self.generate_melody_button = gr.Button("Generate Melody")
+            with gr.Row():
+                self.phrase_info_box = gr.Textbox(label="Phrase Information", value="")
+                self.pitch_result_box = gr.Textbox(label="Pitch Result", value="")
+            self._add_audio_input()
+            self.end_practice_button = gr.Button("End Practice")
+
+            self._add_buttons_callbacks()
+
+        return app
+
+    def _add_header(self):
+        """Create the header section of the UI."""
+        gr.Markdown(f"# {self.song_name} Melody Practice\nSing each note for 1 second!")
+
+    def _add_buttons_callbacks(self):
+        """Create the control buttons section."""
+        # Connect button callbacks
+        self.generate_melody_button.click(
+            fn=self.on_generate_melody,
+            outputs=[self.phrase_info_box, self.pitch_result_box],
+        )
+
+        self.end_practice_button.click(
+            fn=self.on_end_practice,
+            outputs=[self.phrase_info_box, self.pitch_result_box],
+        )
+
+    def _add_audio_input(self):
+        """Create the audio input section."""
+        audio_input = gr.Audio(
+            label="Audio Input",
+            sources=["microphone"],
+            streaming=True,
+            type="numpy",
+            show_label=True,
+        )
+
+        # Attention: have to specify inputs explicitly,
+        # otherwise the callback function is not called
+        audio_input.stream(
+            fn=self.on_audio_input,
+            inputs=audio_input,
+            outputs=[self.phrase_info_box, self.pitch_result_box],
+            show_progress=False,
+            stream_every=0.1,
+        )
+
+    def launch(self, **kwargs):
+        """Launch the Gradio application.
+
+        Args:
+            **kwargs: Additional keyword arguments for the launch method.
+        """
+        app = self._build_interface()
+        app.queue()
+        app.launch(**kwargs)

improvisation_lab/service/__init__.py

@@ -0,0 +1,6 @@
+"""Service layer for the Improvisation Lab."""
+
+from improvisation_lab.service.melody_practice_service import \
+    MelodyPracticeService
+
+__all__ = ["MelodyPracticeService"]

improvisation_lab/service/melody_practice_service.py

@@ -0,0 +1,128 @@
+"""Service for practicing melodies."""
+
+import time
+from dataclasses import dataclass
+
+import numpy as np
+
+from improvisation_lab.config import Config
+from improvisation_lab.domain.analysis import PitchDetector
+from improvisation_lab.domain.composition import MelodyComposer, PhraseData
+from improvisation_lab.domain.music_theory import Notes
+
+
+@dataclass
+class PitchResult:
+    """Result of pitch detection."""
+
+    target_note: str
+    current_base_note: str | None
+    is_correct: bool
+    remaining_time: float
+
+
+class MelodyPracticeService:
+    """Service for generating and processing melodies."""
+
+    def __init__(self, config: Config):
+        """Initialize MelodyPracticeService with configuration."""
+        self.config = config
+        self.melody_composer = MelodyComposer()
+        self.pitch_detector = PitchDetector(config.audio.pitch_detector)
+
+        self.correct_pitch_start_time: float | None = None
+
+    def generate_melody(self) -> list[PhraseData]:
+        """Generate a melody based on the configured chord progression.
+
+        Returns:
+            List of PhraseData instances representing the generated melody.
+        """
+        selected_progression = self.config.chord_progressions[self.config.selected_song]
+        return self.melody_composer.generate_phrases(selected_progression)
+
+    def process_audio(self, audio_data: np.ndarray, target_note: str) -> PitchResult:
+        """Process audio data to detect pitch and provide feedback.
+
+        Args:
+            audio_data: Audio data as a numpy array.
+            target_note: The target note to display.
+        Returns:
+            PitchResult containing the target note, detected note, correctness,
+            and remaining time.
+        """
+        frequency = self.pitch_detector.detect_pitch(audio_data)
+
+        if frequency <= 0:  # if no voice detected, reset the correct pitch start time
+            return self._create_no_voice_result(target_note)
+
+        note_name = Notes.convert_frequency_to_base_note(frequency)
+        if note_name != target_note:
+            return self._create_incorrect_pitch_result(target_note, note_name)
+
+        return self._create_correct_pitch_result(target_note, note_name)
+
+    def _create_no_voice_result(self, target_note: str) -> PitchResult:
+        """Create result for no voice detected case.
+
+        Args:
+            target_note: The target note to display.
+
+        Returns:
+            PitchResult for no voice detected case.
+        """
+        self.correct_pitch_start_time = None
+        return PitchResult(
+            target_note=target_note,
+            current_base_note=None,
+            is_correct=False,
+            remaining_time=self.config.audio.note_duration,
+        )
+
+    def _create_incorrect_pitch_result(
+        self, target_note: str, detected_note: str
+    ) -> PitchResult:
+        """Create result for incorrect pitch case, reset the correct pitch start time.
+
+        Args:
+            target_note: The target note to display.
+            detected_note: The detected note.
+
+        Returns:
+            PitchResult for incorrect pitch case.
+        """
+        self.correct_pitch_start_time = None
+        return PitchResult(
+            target_note=target_note,
+            current_base_note=detected_note,
+            is_correct=False,
+            remaining_time=self.config.audio.note_duration,
+        )
+
+    def _create_correct_pitch_result(
+        self, target_note: str, detected_note: str
+    ) -> PitchResult:
+        """Create result for correct pitch case.
+
+        Args:
+            target_note: The target note to display.
+            detected_note: The detected note.
+
+        Returns:
+            PitchResult for correct pitch case.
+        """
+        current_time = time.time()
+        # Note is completed if the correct pitch is sustained for the duration of a note
+        if self.correct_pitch_start_time is None:
+            self.correct_pitch_start_time = current_time
+            remaining_time = self.config.audio.note_duration
+        else:
+            elapsed_time = current_time - self.correct_pitch_start_time
+            remaining_time = max(0, self.config.audio.note_duration - elapsed_time)
+
+        return PitchResult(
+            target_note=target_note,
+            current_base_note=detected_note,
+            is_correct=True,
+            remaining_time=remaining_time,
+        )

main.py

@@ -0,0 +1,33 @@
+"""Main application module for melody practice.
+
+This module initializes and launches the melody practice application
+using either a web or console interface.
+"""
+
+import argparse
+
+from improvisation_lab.application.melody_practice import \
+    MelodyPracticeAppFactory
+from improvisation_lab.config import Config
+from improvisation_lab.service import MelodyPracticeService
+
+
+def main():
+    """Run the application."""
+    parser = argparse.ArgumentParser(description="Run the melody practice application")
+    parser.add_argument(
+        "--app_type",
+        choices=["web", "console"],
+        default="web",
+        help="Type of application to run (web or console)",
+    )
+    args = parser.parse_args()
+
+    config = Config()
+    service = MelodyPracticeService(config)
+    app = MelodyPracticeAppFactory.create_app(args.app_type, service, config)
+    app.launch()
+
+
+if __name__ == "__main__":
+    main()

packages.txt

@@ -0,0 +1 @@
+portaudio19-dev

pyproject.toml

@@ -0,0 +1,45 @@
+[tool.poetry]
+name = "improvisation-lab"
+version = "0.2.0"
+description = ""
+authors = ["atsushieee <atsushi.tabata1204@gmail.com>"]
+readme = "README.md"
+packages = [
+    {include = "improvisation_lab"},
+    {include = "scripts"}
+]
+
+[tool.poetry.dependencies]
+python = "^3.11"
+torch = "2.2.2"
+torchfcpe = "^0.0.4"
+numpy = "1.26.4"
+pyaudio = "^0.2.14"
+pyyaml = "^6.0.2"
+types-pyyaml = "^6.0.12.20240917"
+scipy = "^1.14.1"
+gradio = "5.7.1"
+
+
+[tool.poetry.group.dev.dependencies]
+mypy = "^1.13.0"
+black = "^24.10.0"
+isort = "^5.13.2"
+pydocstyle = "^6.3.0"
+pytest = "^8.3.3"
+pyproject-flake8 = "^7.0.0"
+pytest-mock = "^3.14.0"
+
+[tool.flake8]
+max-line-length = 88
+extend-ignore = "E203"
+
+[tool.black]
+line-length = 88
+
+[tool.mypy]
+ignore_missing_imports = "True"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

requirements.txt

@@ -0,0 +1,77 @@
+aiofiles==23.2.1 ; python_version >= "3.11" and python_version < "4.0"
+annotated-types==0.7.0 ; python_version >= "3.11" and python_version < "4.0"
+anyio==4.6.2.post1 ; python_version >= "3.11" and python_version < "4.0"
+audioop-lts==0.2.1 ; python_version >= "3.13" and python_version < "4.0"
+certifi==2024.8.30 ; python_version >= "3.11" and python_version < "4.0"
+charset-normalizer==3.4.0 ; python_version >= "3.11" and python_version < "4.0"
+click==8.1.7 ; python_version >= "3.11" and python_version < "4.0" and sys_platform != "emscripten"
+colorama==0.4.6 ; python_version >= "3.11" and python_version < "4.0" and platform_system == "Windows"
+einops==0.8.0 ; python_version >= "3.11" and python_version < "4.0"
+fastapi==0.115.6 ; python_version >= "3.11" and python_version < "4.0"
+ffmpy==0.4.0 ; python_version >= "3.11" and python_version < "4.0"
+filelock==3.16.1 ; python_version >= "3.11" and python_version < "4.0"
+fsspec==2024.10.0 ; python_version >= "3.11" and python_version < "4.0"
+gradio-client==1.5.0 ; python_version >= "3.11" and python_version < "4.0"
+gradio==5.7.1 ; python_version >= "3.11" and python_version < "4.0"
+h11==0.14.0 ; python_version >= "3.11" and python_version < "4.0"
+httpcore==1.0.7 ; python_version >= "3.11" and python_version < "4.0"
+httpx==0.28.0 ; python_version >= "3.11" and python_version < "4.0"
+huggingface-hub==0.26.3 ; python_version >= "3.11" and python_version < "4.0"
+idna==3.10 ; python_version >= "3.11" and python_version < "4.0"
+jinja2==3.1.4 ; python_version >= "3.11" and python_version < "4.0"
+local-attention==1.9.15 ; python_version >= "3.11" and python_version < "4.0"
+markdown-it-py==3.0.0 ; python_version >= "3.11" and python_version < "4.0" and sys_platform != "emscripten"
+markupsafe==2.1.5 ; python_version >= "3.11" and python_version < "4.0"
+mdurl==0.1.2 ; python_version >= "3.11" and python_version < "4.0" and sys_platform != "emscripten"
+mpmath==1.3.0 ; python_version >= "3.11" and python_version < "4.0"
+networkx==3.4.2 ; python_version >= "3.11" and python_version < "4.0"
+numpy==1.26.4 ; python_version >= "3.11" and python_version < "4.0"
+nvidia-cublas-cu12==12.1.3.1 ; platform_system == "Linux" and platform_machine == "x86_64" and python_version >= "3.11" and python_version < "4.0"
+nvidia-cuda-cupti-cu12==12.1.105 ; platform_system == "Linux" and platform_machine == "x86_64" and python_version >= "3.11" and python_version < "4.0"
+nvidia-cuda-nvrtc-cu12==12.1.105 ; platform_system == "Linux" and platform_machine == "x86_64" and python_version >= "3.11" and python_version < "4.0"
+nvidia-cuda-runtime-cu12==12.1.105 ; platform_system == "Linux" and platform_machine == "x86_64" and python_version >= "3.11" and python_version < "4.0"
+nvidia-cudnn-cu12==8.9.2.26 ; platform_system == "Linux" and platform_machine == "x86_64" and python_version >= "3.11" and python_version < "4.0"
+nvidia-cufft-cu12==11.0.2.54 ; platform_system == "Linux" and platform_machine == "x86_64" and python_version >= "3.11" and python_version < "4.0"
+nvidia-curand-cu12==10.3.2.106 ; platform_system == "Linux" and platform_machine == "x86_64" and python_version >= "3.11" and python_version < "4.0"
+nvidia-cusolver-cu12==11.4.5.107 ; platform_system == "Linux" and platform_machine == "x86_64" and python_version >= "3.11" and python_version < "4.0"
+nvidia-cusparse-cu12==12.1.0.106 ; platform_system == "Linux" and platform_machine == "x86_64" and python_version >= "3.11" and python_version < "4.0"
+nvidia-nccl-cu12==2.19.3 ; platform_system == "Linux" and platform_machine == "x86_64" and python_version >= "3.11" and python_version < "4.0"
+nvidia-nvjitlink-cu12==12.4.127 ; platform_system == "Linux" and platform_machine == "x86_64" and python_version >= "3.11" and python_version < "4.0"
+nvidia-nvtx-cu12==12.1.105 ; platform_system == "Linux" and platform_machine == "x86_64" and python_version >= "3.11" and python_version < "4.0"
+orjson==3.10.12 ; python_version >= "3.11" and python_version < "4.0"
+packaging==24.2 ; python_version >= "3.11" and python_version < "4.0"
+pandas==2.2.3 ; python_version >= "3.11" and python_version < "4.0"
+pillow==11.0.0 ; python_version >= "3.11" and python_version < "4.0"
+pyaudio==0.2.14 ; python_version >= "3.11" and python_version < "4.0"
+pydantic-core==2.27.1 ; python_version >= "3.11" and python_version < "4.0"
+pydantic==2.10.3 ; python_version >= "3.11" and python_version < "4.0"
+pydub==0.25.1 ; python_version >= "3.11" and python_version < "4.0"
+pygments==2.18.0 ; python_version >= "3.11" and python_version < "4.0" and sys_platform != "emscripten"
+python-dateutil==2.9.0.post0 ; python_version >= "3.11" and python_version < "4.0"
+python-multipart==0.0.12 ; python_version >= "3.11" and python_version < "4.0"
+pytz==2024.2 ; python_version >= "3.11" and python_version < "4.0"
+pyyaml==6.0.2 ; python_version >= "3.11" and python_version < "4.0"
+requests==2.32.3 ; python_version >= "3.11" and python_version < "4.0"
+rich==13.9.4 ; python_version >= "3.11" and python_version < "4.0" and sys_platform != "emscripten"
+ruff==0.8.1 ; python_version >= "3.11" and python_version < "4.0" and sys_platform != "emscripten"
+safehttpx==0.1.6 ; python_version >= "3.11" and python_version < "4.0"
+scipy==1.14.1 ; python_version >= "3.11" and python_version < "4.0"
+semantic-version==2.10.0 ; python_version >= "3.11" and python_version < "4.0"
+shellingham==1.5.4 ; python_version >= "3.11" and python_version < "4.0" and sys_platform != "emscripten"
+six==1.17.0 ; python_version >= "3.11" and python_version < "4.0"
+sniffio==1.3.1 ; python_version >= "3.11" and python_version < "4.0"
+starlette==0.41.3 ; python_version >= "3.11" and python_version < "4.0"
+sympy==1.13.1 ; python_version >= "3.11" and python_version < "4.0"
+tomlkit==0.12.0 ; python_version >= "3.11" and python_version < "4.0"
+torch==2.2.2 ; python_version >= "3.11" and python_version < "4.0"
+torchaudio==2.2.2 ; python_version >= "3.11" and python_version < "4.0"
+torchfcpe==0.0.4 ; python_version >= "3.11" and python_version < "4.0"
+tqdm==4.67.1 ; python_version >= "3.11" and python_version < "4.0"
+triton==2.2.0 ; platform_system == "Linux" and platform_machine == "x86_64" and python_version < "3.12" and python_version >= "3.11"
+typer==0.15.1 ; python_version >= "3.11" and python_version < "4.0" and sys_platform != "emscripten"
+types-pyyaml==6.0.12.20240917 ; python_version >= "3.11" and python_version < "4.0"
+typing-extensions==4.12.2 ; python_version >= "3.11" and python_version < "4.0"
+tzdata==2024.2 ; python_version >= "3.11" and python_version < "4.0"
+urllib3==2.2.3 ; python_version >= "3.11" and python_version < "4.0"
+uvicorn==0.32.1 ; python_version >= "3.11" and python_version < "4.0" and sys_platform != "emscripten"
+websockets==12.0 ; python_version >= "3.11" and python_version < "4.0"

scripts/__init__.py

@@ -0,0 +1 @@
+"""Scripts package for improvisation-lab."""

scripts/pitch_detection_demo.py

@@ -0,0 +1,141 @@
+"""Script for demonstrating pitch detection functionality."""
+
+import argparse
+import time
+
+import gradio as gr
+
+from improvisation_lab.config import Config
+from improvisation_lab.domain.analysis import PitchDetector
+from improvisation_lab.domain.music_theory import Notes
+from improvisation_lab.infrastructure.audio import (DirectAudioProcessor,
+                                                    WebAudioProcessor)
+
+
+def create_process_audio(pitch_detector: PitchDetector):
+    """Create audio processing callback function.
+
+    Args:
+        pitch_detector: PitchDetector instance
+
+    Returns:
+        Callback function for processing audio data
+    """
+
+    def process_audio(audio_data):
+        frequency = pitch_detector.detect_pitch(audio_data)
+        if frequency > 0:  # voice detected
+            note_name = Notes.convert_frequency_to_note(frequency)
+            print(
+                f"\rFrequency: {frequency:6.1f} Hz | Note: {note_name:<5}",
+                end="",
+                flush=True,
+            )
+        else:  # no voice detected
+            print("\rNo voice detected                        ", end="", flush=True)
+
+    return process_audio
+
+
+def run_direct_audio_demo(config: Config):
+    """Run pitch detection demo using microphone input.
+
+    Args:
+        config: Configuration object
+    """
+    pitch_detector = PitchDetector(config.audio.pitch_detector)
+    mic_input = DirectAudioProcessor(
+        sample_rate=config.audio.sample_rate,
+        buffer_duration=config.audio.buffer_duration,
+    )
+
+    print("Starting pitch detection demo (Microphone)...")
+    print("Sing or hum a note!")
+    print("-" * 50)
+
+    try:
+        mic_input._callback = create_process_audio(pitch_detector)
+        mic_input.start_recording()
+        while True:
+            time.sleep(0.1)
+    except KeyboardInterrupt:
+        print("\nStopping...")
+    finally:
+        mic_input.stop_recording()
+
+
+def run_web_audio_demo(config: Config):
+    """Run pitch detection demo using Gradio interface.
+
+    Args:
+        config: Configuration object
+    """
+    pitch_detector = PitchDetector(config.audio.pitch_detector)
+    audio_input = WebAudioProcessor(
+        sample_rate=config.audio.sample_rate,
+        buffer_duration=config.audio.buffer_duration,
+    )
+
+    print("Starting pitch detection demo (Gradio)...")
+    result = {"text": "No voice detected"}
+
+    def process_audio(audio_data):
+        frequency = pitch_detector.detect_pitch(audio_data)
+        if frequency > 0:
+            note_name = Notes.convert_frequency_to_note(frequency)
+            result["text"] = f"Frequency: {frequency:6.1f} Hz | Note: {note_name}"
+        else:
+            result["text"] = "No voice detected"
+
+    audio_input._callback = process_audio
+
+    def handle_audio(audio):
+        """Handle audio input from Gradio."""
+        if audio is None:
+            return result["text"]
+        if not audio_input.is_recording:
+            audio_input.start_recording()
+        audio_input.process_audio(audio)
+        return result["text"]
+
+    interface = gr.Interface(
+        fn=handle_audio,
+        inputs=gr.Audio(
+            sources=["microphone"],
+            streaming=True,
+            type="numpy",
+        ),
+        outputs=gr.Text(label="Detection Result"),
+        live=True,
+        title="Pitch Detection Demo",
+        allow_flagging="never",
+        stream_every=0.05,
+    )
+    interface.queue()
+    interface.launch(
+        share=False,
+        debug=True,
+    )
+
+
+def main():
+    """Run the pitch detection demo."""
+    parser = argparse.ArgumentParser(description="Run pitch detection demo")
+    parser.add_argument(
+        "--input",
+        choices=["direct", "web"],
+        default="web",
+        help="Input method (direct: microphone or web: browser)",
+    )
+    args = parser.parse_args()
+
+    config = Config()
+
+    if args.input == "web":
+        run_web_audio_demo(config)
+    else:
+        run_direct_audio_demo(config)
+
+
+if __name__ == "__main__":
+    main()

tests/__init__.py

@@ -0,0 +1 @@
+"""Test package for improvisation-lab."""

tests/application/__init__.py

@@ -0,0 +1 @@
+"""Tests for the application layer."""

tests/application/melody_practice/__init__.py

@@ -0,0 +1 @@
+"""Tests for the melody practice application layer."""

tests/application/melody_practice/test_app_factory.py

@@ -0,0 +1,34 @@
+"""Tests for the MelodyPracticeAppFactory class."""
+
+import pytest
+
+from improvisation_lab.application.melody_practice.app_factory import \
+    MelodyPracticeAppFactory
+from improvisation_lab.application.melody_practice.console_app import \
+    ConsoleMelodyPracticeApp
+from improvisation_lab.application.melody_practice.web_app import \
+    WebMelodyPracticeApp
+from improvisation_lab.config import Config
+from improvisation_lab.service import MelodyPracticeService
+
+
+class TestMelodyPracticeAppFactory:
+    @pytest.fixture
+    def init_module(self):
+        self.config = Config()
+        self.service = MelodyPracticeService(self.config)
+
+    @pytest.mark.usefixtures("init_module")
+    def test_create_web_app(self):
+        app = MelodyPracticeAppFactory.create_app("web", self.service, self.config)
+        assert isinstance(app, WebMelodyPracticeApp)
+
+    @pytest.mark.usefixtures("init_module")
+    def test_create_console_app(self):
+        app = MelodyPracticeAppFactory.create_app("console", self.service, self.config)
+        assert isinstance(app, ConsoleMelodyPracticeApp)
+
+    @pytest.mark.usefixtures("init_module")
+    def test_create_app_invalid_type(self):
+        with pytest.raises(ValueError):
+            MelodyPracticeAppFactory.create_app("invalid", self.service, self.config)

tests/application/melody_practice/test_console_app.py

@@ -0,0 +1,71 @@
+"""Tests for the ConsoleMelodyPracticeApp class."""
+
+from unittest.mock import Mock, patch
+
+import pytest
+
+from improvisation_lab.application.melody_practice.console_app import \
+    ConsoleMelodyPracticeApp
+from improvisation_lab.config import Config
+from improvisation_lab.infrastructure.audio import DirectAudioProcessor
+from improvisation_lab.presentation.melody_practice.console_melody_view import \
+    ConsoleMelodyView
+from improvisation_lab.service import MelodyPracticeService
+
+
+class TestConsoleMelodyPracticeApp:
+    @pytest.fixture
+    def init_module(self):
+        """Initialize ConsoleMelodyPracticeApp for testing."""
+        config = Config()
+        service = MelodyPracticeService(config)
+        self.app = ConsoleMelodyPracticeApp(service, config)
+        self.app.ui = Mock(spec=ConsoleMelodyView)
+        self.app.audio_processor = Mock(spec=DirectAudioProcessor)
+        self.app.audio_processor.is_recording = False
+
+    @pytest.mark.usefixtures("init_module")
+    @patch.object(DirectAudioProcessor, "start_recording", return_value=None)
+    @patch("time.sleep", side_effect=KeyboardInterrupt)
+    def test_launch(self, mock_start_recording, mock_sleep):
+        """Test launching the application.
+
+        Args:
+            mock_start_recording: Mock object for start_recording method.
+            mock_sleep: Mock object for sleep method.
+        """
+        self.app.launch()
+        assert self.app.is_running
+        assert self.app.current_phrase_idx == 0
+        assert self.app.current_note_idx == 0
+        self.app.ui.launch.assert_called_once()
+        self.app.ui.display_phrase_info.assert_called_once_with(0, self.app.phrases)
+        mock_start_recording.assert_called_once()
+
+    @pytest.mark.usefixtures("init_module")
+    def test_process_audio_callback(self):
+        """Test processing audio callback."""
+        audio_data = Mock()
+        self.app.phrases = [Mock(notes=["C", "E", "G"]), Mock(notes=["C", "E", "G"])]
+        self.app.current_phrase_idx = 0
+        self.app.current_note_idx = 2
+
+        with patch.object(
+            self.app.service, "process_audio", return_value=Mock(remaining_time=0)
+        ) as mock_process_audio:
+            self.app._process_audio_callback(audio_data)
+            mock_process_audio.assert_called_once_with(audio_data, "G")
+            self.app.ui.display_pitch_result.assert_called_once()
+            self.app.ui.display_phrase_info.assert_called_once_with(1, self.app.phrases)
+
+    @pytest.mark.usefixtures("init_module")
+    def test_advance_to_next_note(self):
+        """Test advancing to the next note."""
+        self.app.phrases = [Mock(notes=["C", "E", "G"])]
+        self.app.current_phrase_idx = 0
+        self.app.current_note_idx = 2
+
+        self.app._advance_to_next_note()
+        assert self.app.current_note_idx == 0
+        assert self.app.current_phrase_idx == 0
+        self.app.ui.display_phrase_info.assert_called_once_with(1, self.app.phrases)

tests/application/melody_practice/test_web_app.py

@@ -0,0 +1,94 @@
+"""Tests for the WebMelodyPracticeApp class."""
+
+from unittest.mock import Mock, patch
+
+import pytest
+
+from improvisation_lab.application.melody_practice.web_app import \
+    WebMelodyPracticeApp
+from improvisation_lab.config import Config
+from improvisation_lab.infrastructure.audio import WebAudioProcessor
+from improvisation_lab.presentation.melody_practice.web_melody_view import \
+    WebMelodyView
+from improvisation_lab.service import MelodyPracticeService
+
+
+class TestWebMelodyPracticeApp:
+    @pytest.fixture
+    def init_module(self):
+        """Initialize WebMelodyPracticeApp for testing."""
+        config = Config()
+        service = MelodyPracticeService(config)
+        self.app = WebMelodyPracticeApp(service, config)
+        self.app.ui = Mock(spec=WebMelodyView)
+        self.app.audio_processor = Mock(spec=WebAudioProcessor)
+
+    @pytest.mark.usefixtures("init_module")
+    def test_launch(self):
+        """Test launching the application."""
+        with patch.object(self.app.ui, "launch", return_value=None) as mock_launch:
+            self.app.launch()
+            mock_launch.assert_called_once()
+
+    @pytest.mark.usefixtures("init_module")
+    def test_process_audio_callback(self):
+        """Test processing audio callback."""
+        audio_data = Mock()
+        self.app.is_running = True
+        self.app.phrases = [Mock(notes=["C", "E", "G"]), Mock(notes=["C", "E", "G"])]
+        self.app.current_phrase_idx = 0
+        self.app.current_note_idx = 2
+
+        mock_result = Mock()
+        mock_result.target_note = "G"
+        mock_result.current_base_note = "G"
+        mock_result.remaining_time = 0.0
+
+        with patch.object(
+            self.app.service, "process_audio", return_value=mock_result
+        ) as mock_process_audio:
+            self.app._process_audio_callback(audio_data)
+            mock_process_audio.assert_called_once_with(audio_data, "G")
+            assert (
+                self.app.text_manager.result_text
+                == "Target: G | Your note: G | Remaining: 0.0s"
+            )
+
+    @pytest.mark.usefixtures("init_module")
+    def test_handle_audio(self):
+        """Test handling audio input."""
+        audio_data = (48000, Mock())
+        self.app.is_running = True
+        with patch.object(
+            self.app.audio_processor, "process_audio", return_value=None
+        ) as mock_process_audio:
+            phrase_text, result_text = self.app.handle_audio(audio_data)
+            mock_process_audio.assert_called_once_with(audio_data)
+            assert phrase_text == self.app.text_manager.phrase_text
+            assert result_text == self.app.text_manager.result_text
+
+    @pytest.mark.usefixtures("init_module")
+    def test_start(self):
+        """Test starting the application."""
+        self.app.audio_processor.is_recording = False
+        with patch.object(
+            self.app.audio_processor, "start_recording", return_value=None
+        ) as mock_start_recording:
+            phrase_text, result_text = self.app.start()
+            mock_start_recording.assert_called_once()
+            assert self.app.is_running
+            assert phrase_text == self.app.text_manager.phrase_text
+            assert result_text == self.app.text_manager.result_text
+
+    @pytest.mark.usefixtures("init_module")
+    def test_stop(self):
+        """Test stopping the application."""
+        self.app.audio_processor.is_recording = True
+        with patch.object(
+            self.app.audio_processor, "stop_recording", return_value=None
+        ) as mock_stop_recording:
+            phrase_text, result_text = self.app.stop()
+            mock_stop_recording.assert_called_once()
+            assert not self.app.is_running
+            assert phrase_text == self.app.text_manager.phrase_text
+            assert result_text == self.app.text_manager.result_text

tests/domain/__init__.py

@@ -0,0 +1 @@
+"""Test package for domain layer of improvisation-lab."""

tests/domain/analysis/__init__.py

@@ -0,0 +1 @@
+"""Test package for music analysis module."""

tests/domain/analysis/test_pitch_detector.py

@@ -0,0 +1,49 @@
+import numpy as np
+import pytest
+
+from improvisation_lab.config import PitchDetectorConfig
+from improvisation_lab.domain.analysis.pitch_detector import PitchDetector
+
+
+class TestPitchDetector:
+
+    @pytest.fixture
+    def init_module(self) -> None:
+        """Initialization."""
+        config = PitchDetectorConfig()
+        self.pitch_detector = PitchDetector(config)
+
+    @pytest.mark.usefixtures("init_module")
+    def test_detect_pitch_sine_wave(self):
+        """Test pitch detection with a simple sine wave."""
+        # Create a sine wave at 440 Hz (A4 note)
+        duration = 0.2  # seconds
+        # Array of sr * duration equally spaced values dividing the range 0 to duration.
+        t = np.linspace(0, duration, int(self.pitch_detector.sample_rate * duration))
+        frequency = 440.0
+        # Generates sine waves for a specified time
+        audio_data = np.sin(2 * np.pi * frequency * t).astype(np.float32)
+
+        # Detect pitch
+        detected_freq = self.pitch_detector.detect_pitch(audio_data)
+
+        # Check if detected frequency is close to 440 Hz
+        assert abs(detected_freq - 440.0) < 1.5  # Allow 1.5 Hz tolerance
+
+    def test_custom_parameters(self):
+        """Test pitch detection with custom parameters."""
+        custom_config = PitchDetectorConfig(
+            sample_rate=22050,
+            f0_min=100,
+            f0_max=800,
+            threshold=0.01,
+        )
+        detector = PitchDetector(custom_config)
+
+        duration = 0.2
+        t = np.linspace(0, duration, int(detector.sample_rate * duration))
+        frequency = 440.0
+        audio_data = np.sin(2 * np.pi * frequency * t).astype(np.float32)
+
+        detected_freq = detector.detect_pitch(audio_data)
+        assert abs(detected_freq - 440.0) < 1.5

tests/domain/composition/__init__.py

@@ -0,0 +1 @@
+"""Test package for melody jam module."""