rosabeats 0.1.3__py3-none-any.whl → 0.2.0__py3-none-any.whl

tests/test_downbeat.py

@@ -0,0 +1,149 @@
+"""Tests for downbeat detection module."""
+
+import pytest
+import numpy as np
+
+from rosabeats.downbeat import (
+    compute_beat_features,
+    score_offset,
+    detect_downbeat,
+    detect_downbeat_dbn,
+)
+
+
+class TestComputeBeatFeatures:
+    """Tests for compute_beat_features function."""
+
+    def test_empty_beat_times(self, mono_audio, sample_rate):
+        """Should return empty dict for empty beat times."""
+        features = compute_beat_features(mono_audio, sample_rate, np.array([]))
+        assert features == {}
+
+    def test_returns_expected_features(self, synthetic_audio_with_beats):
+        """Should return dict with expected feature keys."""
+        audio, sr = synthetic_audio_with_beats
+        beat_times = np.arange(0, 10, 0.5)  # 120 BPM
+
+        features = compute_beat_features(audio, sr, beat_times)
+
+        assert 'onset_strength' in features
+        assert 'low_freq_energy' in features
+        assert 'mid_freq_energy' in features
+        assert 'spectral_flux' in features
+        assert 'low_mid_ratio' in features
+
+    def test_feature_array_lengths(self, synthetic_audio_with_beats):
+        """Feature arrays should have same length as beat_times."""
+        audio, sr = synthetic_audio_with_beats
+        beat_times = np.arange(0, 10, 0.5)
+        n_beats = len(beat_times)
+
+        features = compute_beat_features(audio, sr, beat_times)
+
+        for key, values in features.items():
+            assert len(values) == n_beats, f"{key} has wrong length"
+
+    def test_features_are_normalized(self, synthetic_audio_with_beats):
+        """Features should be normalized to 0-1 range."""
+        audio, sr = synthetic_audio_with_beats
+        beat_times = np.arange(0, 10, 0.5)
+
+        features = compute_beat_features(audio, sr, beat_times)
+
+        for key in ['onset_strength', 'low_freq_energy', 'mid_freq_energy', 'spectral_flux']:
+            assert features[key].min() >= 0, f"{key} min should be >= 0"
+            assert features[key].max() <= 1, f"{key} max should be <= 1"
+
+
+class TestScoreOffset:
+    """Tests for score_offset function."""
+
+    def test_returns_float(self):
+        """Should return a float score."""
+        features = {
+            'onset_strength': np.array([1.0, 0.5, 0.5, 0.5, 1.0, 0.5, 0.5, 0.5]),
+            'low_freq_energy': np.array([1.0, 0.2, 0.2, 0.2, 1.0, 0.2, 0.2, 0.2]),
+            'low_mid_ratio': np.array([1.0, 0.3, 0.3, 0.3, 1.0, 0.3, 0.3, 0.3]),
+            'spectral_flux': np.array([0.8, 0.4, 0.4, 0.4, 0.8, 0.4, 0.4, 0.4]),
+        }
+
+        score = score_offset(features, offset=0, beats_per_bar=4)
+        assert isinstance(score, float)
+
+    def test_correct_offset_scores_higher(self):
+        """Offset 0 should score higher when downbeats have stronger features."""
+        # Simulate features where beat 0, 4, 8 have strong low freq (downbeats)
+        features = {
+            'onset_strength': np.array([1.0, 0.3, 0.3, 0.3, 1.0, 0.3, 0.3, 0.3, 1.0, 0.3, 0.3, 0.3]),
+            'low_freq_energy': np.array([1.0, 0.1, 0.1, 0.1, 1.0, 0.1, 0.1, 0.1, 1.0, 0.1, 0.1, 0.1]),
+            'low_mid_ratio': np.array([1.0, 0.2, 0.2, 0.2, 1.0, 0.2, 0.2, 0.2, 1.0, 0.2, 0.2, 0.2]),
+            'spectral_flux': np.array([0.8, 0.3, 0.3, 0.3, 0.8, 0.3, 0.3, 0.3, 0.8, 0.3, 0.3, 0.3]),
+        }
+
+        score_0 = score_offset(features, offset=0, beats_per_bar=4)
+        score_1 = score_offset(features, offset=1, beats_per_bar=4)
+        score_2 = score_offset(features, offset=2, beats_per_bar=4)
+        score_3 = score_offset(features, offset=3, beats_per_bar=4)
+
+        assert score_0 > score_1, "Offset 0 should score higher than offset 1"
+        assert score_0 > score_2, "Offset 0 should score higher than offset 2"
+        assert score_0 > score_3, "Offset 0 should score higher than offset 3"
+
+    def test_too_few_beats(self):
+        """Should return 0 if fewer beats than beats_per_bar."""
+        features = {
+            'onset_strength': np.array([1.0, 0.5]),
+            'low_freq_energy': np.array([1.0, 0.5]),
+            'low_mid_ratio': np.array([1.0, 0.5]),
+            'spectral_flux': np.array([1.0, 0.5]),
+        }
+
+        score = score_offset(features, offset=0, beats_per_bar=4)
+        assert score == 0.0
+
+
+class TestDetectDownbeat:
+    """Tests for detect_downbeat function."""
+
+    def test_returns_valid_offset(self, synthetic_audio_with_beats):
+        """Should return an integer offset within valid range."""
+        audio, sr = synthetic_audio_with_beats
+        beat_times = np.arange(0, 10, 0.5)
+        beats_per_bar = 4
+
+        result = detect_downbeat(audio, sr, beat_times, beats_per_bar)
+
+        assert isinstance(result, (int, np.integer))
+        assert 0 <= result < beats_per_bar
+
+    def test_few_beats_returns_zero(self, mono_audio, sample_rate):
+        """Should return 0 when there are very few beats."""
+        beat_times = np.array([0.0, 0.5])  # Only 2 beats
+
+        result = detect_downbeat(mono_audio, sample_rate, beat_times, beats_per_bar=4)
+
+        assert result == 0
+
+    def test_detects_correct_downbeat_synthetic(self, synthetic_audio_with_beats):
+        """Should detect offset 0 for synthetic audio with kicks on downbeats."""
+        audio, sr = synthetic_audio_with_beats
+        beat_times = np.arange(0, 10, 0.5)
+
+        result = detect_downbeat(audio, sr, beat_times, beats_per_bar=4)
+
+        # The synthetic audio has kicks on beat 0, 4, 8, etc. so offset should be 0
+        assert result == 0, f"Expected offset 0 but got {result}"
+
+
+class TestDetectDownbeatDbn:
+    """Tests for detect_downbeat_dbn (alias function)."""
+
+    def test_is_alias_for_detect_downbeat(self, synthetic_audio_with_beats):
+        """detect_downbeat_dbn should produce same results as detect_downbeat."""
+        audio, sr = synthetic_audio_with_beats
+        beat_times = np.arange(0, 10, 0.5)
+
+        result1 = detect_downbeat(audio, sr, beat_times, beats_per_bar=4)
+        result2 = detect_downbeat_dbn(audio, sr, beat_times, beats_per_bar=4)
+
+        assert result1 == result2

tests/test_rosabeats.py

@@ -0,0 +1,234 @@
+"""Tests for core rosabeats module."""
+
+import pytest
+import numpy as np
+import os
+
+from rosabeats.rosabeats import rosabeats
+
+
+class TestRosabeatsInit:
+    """Tests for rosabeats initialization."""
+
+    def test_init_without_file(self):
+        """Should initialize without a file."""
+        r = rosabeats()
+        assert r.sourcefile is None
+        assert r.data is None
+        assert r.sr is None
+
+    def test_init_with_file(self, temp_audio_file):
+        """Should initialize with a file path."""
+        r = rosabeats(temp_audio_file)
+        assert r.sourcefile is not None
+        assert temp_audio_file in r.sourcefile
+
+    def test_debug_mode(self):
+        """Should set debug mode."""
+        r = rosabeats(debug=True)
+        assert rosabeats.debug is True
+
+        # Reset
+        rosabeats.debug = False
+
+
+class TestRosabeatsSetfile:
+    """Tests for setfile method."""
+
+    def test_setfile_sets_sourcefile(self, temp_audio_file):
+        """setfile should set sourcefile to absolute path."""
+        r = rosabeats()
+        r.setfile(temp_audio_file)
+
+        assert r.sourcefile is not None
+        assert os.path.isabs(r.sourcefile)
+
+    def test_setfile_sets_saved_features_path(self, temp_audio_file):
+        """setfile should set saved_features path."""
+        r = rosabeats()
+        r.setfile(temp_audio_file)
+
+        assert r.saved_features is not None
+        assert r.saved_features.endswith(".pkl")
+
+
+class TestRosabeatsLoad:
+    """Tests for audio loading."""
+
+    def test_load_wav_file(self, temp_audio_file):
+        """Should load a WAV file."""
+        r = rosabeats(temp_audio_file)
+        r.load()
+
+        assert r.data is not None
+        assert r.sr is not None
+        assert r.channels is not None
+
+    def test_load_creates_stereo_data(self, temp_audio_file):
+        """Loaded data should have channel dimension."""
+        r = rosabeats(temp_audio_file)
+        r.load()
+
+        # Data should be (channels, samples)
+        assert r.data.ndim >= 1
+
+
+class TestRosabeatsMixToMono:
+    """Tests for mix_to_mono method."""
+
+    def test_mix_to_mono(self, temp_audio_file):
+        """Should create mono mix of audio."""
+        r = rosabeats(temp_audio_file)
+        r.load()
+        r.mix_to_mono()
+
+        assert r.mono is not None
+        assert r.mono.ndim == 1
+
+
+class TestRosabeatsTrackBeats:
+    """Tests for beat tracking."""
+
+    def test_track_beats_basic(self, temp_audio_file):
+        """Should track beats and set related attributes."""
+        r = rosabeats(temp_audio_file)
+        r.track_beats(beatsper=4, downbeat=0)
+
+        assert r.beat_timings is not None
+        assert r.beat_samples is not None
+        assert r.beat_slices is not None
+        assert r.total_beats is not None
+        assert r.total_beats > 0
+        assert r.beatsperbar == 4
+        assert r.downbeat == 0
+
+    def test_track_beats_sets_total_bars(self, temp_audio_file):
+        """Should calculate total bars."""
+        r = rosabeats(temp_audio_file)
+        r.track_beats(beatsper=4, downbeat=0)
+
+        assert r.total_bars is not None
+        expected_bars = (r.total_beats - r.downbeat) // r.beatsperbar
+        assert r.total_bars == expected_bars
+
+    def test_track_beats_with_downbeat(self, temp_audio_file):
+        """Should handle non-zero downbeat."""
+        r = rosabeats(temp_audio_file)
+        r.track_beats(beatsper=4, downbeat=2)
+
+        assert r.downbeat == 2
+
+
+class TestRosabeatsBeatStartsBar:
+    """Tests for beat_starts_bar method."""
+
+    @pytest.fixture
+    def tracked_rosabeats(self, temp_audio_file):
+        """Create rosabeats instance with beats tracked."""
+        r = rosabeats(temp_audio_file)
+        r.track_beats(beatsper=4, downbeat=0)
+        return r
+
+    def test_downbeat_starts_bar(self, tracked_rosabeats):
+        """Beat 0 should start bar 0 when downbeat is 0."""
+        result = tracked_rosabeats.beat_starts_bar(0)
+        assert result == 0
+
+    def test_non_downbeat_returns_none(self, tracked_rosabeats):
+        """Non-downbeat beats should return None."""
+        result = tracked_rosabeats.beat_starts_bar(1)
+        assert result is None
+
+        result = tracked_rosabeats.beat_starts_bar(2)
+        assert result is None
+
+    def test_subsequent_downbeats(self, tracked_rosabeats):
+        """Beats at bar boundaries should return bar numbers."""
+        result = tracked_rosabeats.beat_starts_bar(4)
+        assert result == 1
+
+        result = tracked_rosabeats.beat_starts_bar(8)
+        assert result == 2
+
+
+class TestRosabeatsOutputControl:
+    """Tests for output enable/disable methods."""
+
+    def test_enable_disable_play(self):
+        """Should enable and disable playback output."""
+        r = rosabeats()
+
+        r.enable_output_play()
+        assert r.output_play is True
+
+        r.disable_output_play()
+        assert r.output_play is False
+
+    def test_enable_disable_save(self, tmp_path):
+        """Should enable and disable save output."""
+        r = rosabeats()
+        outfile = str(tmp_path / "out.wav")
+
+        r.enable_output_save(outfile)
+        assert r.output_save is True
+        assert r.remix_output_file == outfile
+
+        r.disable_output_save()
+        assert r.output_save is False
+
+    def test_enable_disable_beats(self, tmp_path):
+        """Should enable and disable beats output."""
+        r = rosabeats()
+        outfile = str(tmp_path / "out.br")
+
+        r.enable_output_beats(outfile)
+        assert r.output_beats is True
+        assert r.beats_output_file == outfile
+
+        r.disable_output_beats()
+        assert r.output_beats is False
+
+
+class TestRosabeatsDetectDownbeat:
+    """Tests for detect_downbeat method."""
+
+    def test_detect_downbeat_returns_int(self, temp_audio_file):
+        """detect_downbeat should return an integer."""
+        r = rosabeats(temp_audio_file)
+        r.track_beats(beatsper=4, downbeat=0)
+
+        result = r.detect_downbeat(4)
+
+        assert isinstance(result, (int, np.integer))
+        assert 0 <= result < 4
+
+    def test_detect_downbeat_dbn(self, temp_audio_file):
+        """detect_downbeat_dbn should work."""
+        r = rosabeats(temp_audio_file)
+        r.track_beats(beatsper=4, downbeat=0)
+
+        result = r.detect_downbeat_dbn(4)
+
+        assert isinstance(result, (int, np.integer))
+        assert 0 <= result < 4
+
+
+class TestRosabeatsRest:
+    """Tests for rest method."""
+
+    @pytest.fixture
+    def output_rosabeats(self, temp_audio_file, tmp_path):
+        """Create rosabeats with save output enabled."""
+        r = rosabeats(temp_audio_file)
+        r.track_beats(beatsper=4, downbeat=0)
+        r.enable_output_save(str(tmp_path / "out.wav"))
+        r.reset_remix()
+        return r
+
+    def test_rest_adds_silence(self, output_rosabeats):
+        """rest should add silence to remix buffer."""
+        initial_index = output_rosabeats.remix_index
+
+        output_rosabeats.rest(1.0)  # 1 beat of silence
+
+        assert output_rosabeats.remix_index > initial_index

tests/test_segment_song.py

@@ -0,0 +1,120 @@
+"""Tests for segment_song module."""
+
+import pytest
+
+from rosabeats.segment_song import (
+    get_segment_letter,
+    generate_segment_names,
+)
+
+
+class TestGetSegmentLetter:
+    """Tests for get_segment_letter function."""
+
+    def test_single_letters(self):
+        """Should return single letters for 0-25."""
+        assert get_segment_letter(0) == "A"
+        assert get_segment_letter(1) == "B"
+        assert get_segment_letter(25) == "Z"
+
+    def test_double_letters(self):
+        """Should return double letters for 26+."""
+        assert get_segment_letter(26) == "AA"
+        assert get_segment_letter(27) == "AB"
+        assert get_segment_letter(51) == "AZ"
+        assert get_segment_letter(52) == "BA"
+
+
+class TestGenerateSegmentNames:
+    """Tests for generate_segment_names function."""
+
+    def test_unique_clusters(self):
+        """Should assign unique letters to unique clusters."""
+        segments = [
+            {'label': 0},
+            {'label': 1},
+            {'label': 2},
+        ]
+
+        names = generate_segment_names(segments)
+
+        assert names == ["A", "B", "C"]
+
+    def test_repeated_clusters_get_numbers(self):
+        """Repeated clusters should get numeric suffixes."""
+        segments = [
+            {'label': 0},
+            {'label': 1},
+            {'label': 0},  # Second occurrence of cluster 0
+            {'label': 1},  # Second occurrence of cluster 1
+        ]
+
+        names = generate_segment_names(segments)
+
+        assert names == ["A", "B", "A2", "B2"]
+
+    def test_multiple_repeats(self):
+        """Multiple repeats should get incrementing numbers."""
+        segments = [
+            {'label': 0},
+            {'label': 0},
+            {'label': 0},
+            {'label': 0},
+        ]
+
+        names = generate_segment_names(segments)
+
+        assert names == ["A", "A2", "A3", "A4"]
+
+    def test_complex_pattern(self):
+        """Should handle complex patterns correctly."""
+        # Simulating A B A C A B pattern
+        segments = [
+            {'label': 0},  # A
+            {'label': 1},  # B
+            {'label': 0},  # A2
+            {'label': 2},  # C
+            {'label': 0},  # A3
+            {'label': 1},  # B2
+        ]
+
+        names = generate_segment_names(segments)
+
+        assert names == ["A", "B", "A2", "C", "A3", "B2"]
+
+    def test_empty_segments(self):
+        """Should return empty list for empty input."""
+        names = generate_segment_names([])
+        assert names == []
+
+    def test_single_segment(self):
+        """Should handle single segment."""
+        segments = [{'label': 0}]
+        names = generate_segment_names(segments)
+        assert names == ["A"]
+
+    def test_many_unique_clusters(self):
+        """Should handle many unique clusters."""
+        # 30 unique clusters
+        segments = [{'label': i} for i in range(30)]
+
+        names = generate_segment_names(segments)
+
+        assert len(names) == 30
+        assert names[0] == "A"
+        assert names[25] == "Z"
+        assert names[26] == "AA"
+        assert names[27] == "AB"
+
+    def test_no_apostrophes_in_names(self):
+        """Names should not contain apostrophes."""
+        segments = [
+            {'label': 0},
+            {'label': 0},
+            {'label': 0},
+        ]
+
+        names = generate_segment_names(segments)
+
+        for name in names:
+            assert "'" not in name, f"Name '{name}' contains apostrophe"