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

rosabeats/segment_song.py

@@ -75,27 +75,72 @@ def print_warning(text):
     """Print a formatted warning message"""
     print(f"{Colors.YELLOW}{Symbols.WARNING} {text}{Colors.ENDC}")
 
+def get_segment_letter(cluster_num):
+    """Convert cluster number to letter (0->A, 1->B, ..., 25->Z, 26->AA, etc.)"""
+    if cluster_num < 26:
+        return chr(ord('A') + cluster_num)
+    else:
+        # For clusters beyond 25, use AA, AB, etc.
+        first = cluster_num // 26 - 1
+        second = cluster_num % 26
+        return chr(ord('A') + first) + chr(ord('A') + second)
+
+def generate_segment_names(segments):
+    """Generate letter-based names for segments with repeat markers.
+
+    First occurrence of cluster 0 -> "A"
+    Second occurrence of cluster 0 -> "A2"
+    Third occurrence -> "A3"
+    First occurrence of cluster 1 -> "B", etc.
+
+    Returns:
+        list: List of segment names in order
+    """
+    # Track how many times we've seen each cluster label
+    cluster_counts = {}
+    names = []
+
+    for seg in segments:
+        cluster = seg['label']
+        if cluster not in cluster_counts:
+            cluster_counts[cluster] = 0
+
+        # Get base letter for this cluster
+        letter = get_segment_letter(cluster)
+
+        # Add number suffix for repeats (A, A2, A3, ...)
+        repeat_count = cluster_counts[cluster]
+        if repeat_count > 0:
+            name = letter + str(repeat_count + 1)
+        else:
+            name = letter
+
+        names.append(name)
+        cluster_counts[cluster] += 1
+
+    return names
+
 def main(args=None):
     # Set up command line argument parsing
     parser = argparse.ArgumentParser(
-        description='Segment audio file and track beats using laplacian, segmentino, or backtrack methods',
+        description='Segment audio file and track beats using Laplacian spectral clustering',
         formatter_class=argparse.ArgumentDefaultsHelpFormatter
     )
     parser.add_argument('audiofile', help='Audio file to process')
-    parser.add_argument('--method', choices=['laplacian', 'segmentino', 'backtrack'], 
-                       default='backtrack', help='Segmentation method to use')
-    parser.add_argument('--max-clusters', type=int, default=None,
-                       help='Maximum number of clusters to use for laplacian segmentation')
+    parser.add_argument('--max-clusters', type=int, default=12,
+                       help='Maximum number of clusters for segmentation')
     parser.add_argument('--beatsper', type=int, default=8,
                        help='Number of beats per bar')
-    parser.add_argument('--firstfull', type=int, default=0,
-                       help='First full bar number')
+    parser.add_argument('--downbeat', type=int, default=None,
+                       help='Beat index of first downbeat (default: 0)')
+    parser.add_argument('--auto-downbeat', action='store_true',
+                       help='Auto-detect downbeat using DBN')
     parser.add_argument('--output', help='Output file path (default: input filename with .bri extension)')
-    parser.add_argument('--debug', action='store_true', 
+    parser.add_argument('--debug', action='store_true',
                        help='Enable debug mode for detailed processing information')
-    
+
     args = parser.parse_args()
-    
+
     # Set output file if not specified
     if args.output is None:
         basename = os.path.basename(args.audiofile)
@@ -104,20 +149,19 @@ def main(args=None):
     else:
         output = args.output
 
-    if args.method == "laplacian" and args.max_clusters is None:
-        print_warning("max-clusters is not specified for laplacian segmentation, using default of 48")
-        args.max_clusters = 48
-
-    if args.max_clusters is not None and args.method != "laplacian":
-        print_warning("max-clusters is specified for non-laplacian segmentation, this will be ignored")
-
     # Print processing information
     print_header("Audio Segmentation and Beat Tracking")
     print(f"{Colors.BOLD}Input:{Colors.ENDC}")
     print(f"  Audio file: {args.audiofile}")
-    print(f"  Method: {args.method}")
+    print(f"  Max clusters: {args.max_clusters}")
     print(f"  Beats per bar: {args.beatsper}")
-    print(f"  First full bar: {args.firstfull}")
+    if args.downbeat is not None:
+        downbeat_str = str(args.downbeat)
+    elif args.auto_downbeat:
+        downbeat_str = "auto-detect"
+    else:
+        downbeat_str = "0 (default)"
+    print(f"  Downbeat: {downbeat_str}")
     print(f"  Output file: {output}")
     if args.debug:
         print_warning("Debug mode enabled - detailed processing information will be shown")
@@ -128,11 +172,25 @@ def main(args=None):
     print_success(f"Loaded {os.path.basename(args.audiofile)}")
 
     print_step("Tracking beats")
-    s.track_beats(args.beatsper, args.firstfull)
+    # Determine downbeat value
+    if args.downbeat is not None:
+        downbeat = args.downbeat
+    elif args.auto_downbeat:
+        # Auto-detect using DBN approach
+        s.track_beats(args.beatsper, downbeat=0)  # Track first to get beat timings
+        print_step("Auto-detecting downbeat using DBN")
+        downbeat = s.detect_downbeat_dbn(args.beatsper)
+        s.downbeat = downbeat
+        s.total_bars = int((s.total_beats - s.downbeat) / s.beatsperbar)
+    else:
+        downbeat = 0
+
+    if not args.auto_downbeat:
+        s.track_beats(args.beatsper, downbeat)
     print_success(f"Found {s.total_beats} beats in {s.total_bars} bars")
 
-    print_step(f"Segmenting with {args.method} method")
-    s.segment(method=args.method, max_clusters=args.max_clusters)
+    print_step("Segmenting audio")
+    s.segment(max_clusters=args.max_clusters)
     print_success(f"Identified {s.total_segments} segments")
 
     print_step("Assigning beats and bars to segments")
@@ -145,26 +203,37 @@ def main(args=None):
         # Write header information
         f.write("##BEATS## This was segmented and tracked using librosa's beat tracker\n\n")
         f.write(f"file {s.sourcefile}\n")
-        f.write(f"beats_bar {s.beatsperbar} {s.firstfullbar}\n")
+        f.write(f"beats_bar {s.beatsperbar} {s.downbeat}\n")
         f.write(f"# total beats = {s.total_beats}\n")
-        f.write(f"# total bars = {s.total_bars} (beats {s.firstfullbar}-{s.firstfullbar + (s.beatsperbar * s.total_bars)})\n")
+        f.write(f"# total bars = {s.total_bars} (beats {s.downbeat}-{s.downbeat + (s.beatsperbar * s.total_bars)})\n")
+
+        # Generate letter-based segment names
+        segment_names = generate_segment_names(s.segments)
 
         # Process and write segment information
         bars_defs = []
         beats_defs = []
         for idx, seg in enumerate(s.segments):
+            seg_name = segment_names[idx]
+
             # Print segment information to console
-            print(f"\n{Colors.BOLD}Segment {idx}:{Colors.ENDC}")
-            print(f"  Label: {seg['label']}")
+            print(f"\n{Colors.BOLD}Segment {seg_name}:{Colors.ENDC}")
+            print(f"  Cluster: {seg['label']}")
             print(f"  Duration: {seg['duration']:.2f} seconds")
-            
+
             if len(seg["bars"]) >= 1:
-                print(f"  Bars: {seg['bars'][0]}-{seg['bars'][-1]}")
-                bars_defs.append(f"def {seg['label']}_{idx} bars {seg['bars'][0]}-{seg['bars'][-1]}")
-            
+                # Filter out negative bars (pickup beats before downbeat)
+                valid_bars = [b for b in seg["bars"] if b >= 0]
+                if len(valid_bars) >= 1:
+                    print(f"  Bars: {valid_bars[0]}-{valid_bars[-1]}")
+                    bars_defs.append(f"def {seg_name} bars {valid_bars[0]}-{valid_bars[-1]}")
+                elif len(seg["bars"]) >= 1:
+                    # All bars are negative (pickup section)
+                    print(f"  Bars: (pickup) {seg['bars'][0]}-{seg['bars'][-1]}")
+
             if len(seg["beats"]) >= 1:
                 print(f"  Beats: {seg['beats'][0]}-{seg['beats'][-1]}")
-                beats_defs.append(f"def {seg['label']}_{idx}_beats beats {seg['beats'][0]}-{seg['beats'][-1]}\t# dur = {seg['duration']:.2f}s, beats {seg['beats'][0]}-{seg['beats'][-1]}")
+                beats_defs.append(f"def {seg_name}_beats beats {seg['beats'][0]}-{seg['beats'][-1]}\t# dur = {seg['duration']:.2f}s")
 
         # Write segment definitions to file
         for d in bars_defs:

{rosabeats-0.1.3.dist-info → rosabeats-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rosabeats
-Version: 0.1.3
+Version: 0.2.0
 Summary: Audio beat detection, segmentation, and remixing library using librosa
 Author: John Fleming
 License-Expression: ISC
@@ -8,15 +8,13 @@ Project-URL: Homepage, https://github.com/jbff/rosabeats
 Project-URL: Repository, https://github.com/jbff/rosabeats
 Keywords: audio,beat,detection,segmentation,remixing,librosa,music
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: Multimedia :: Sound/Audio :: Analysis
 Classifier: Topic :: Multimedia :: Sound/Audio :: Conversion
-Requires-Python: >=3.9
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE.md
 Requires-Dist: librosa<1.0,>=0.11.0
@@ -27,11 +25,9 @@ Requires-Dist: scipy<2.0,>=1.15
 Requires-Dist: scikit-learn<2.0,>=1.5
 Provides-Extra: ffms2
 Requires-Dist: ffms2; extra == "ffms2"
-Provides-Extra: vamp
-Requires-Dist: vamp; extra == "vamp"
-Provides-Extra: all
-Requires-Dist: ffms2; extra == "all"
-Requires-Dist: vamp; extra == "all"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
 Dynamic: license-file
 
 # rosabeats
@@ -48,9 +44,7 @@ I wrote most of this code in 2018-2019 and made some additions through 2021. I c
 
 - **Beat Detection**: Automatically detect beats and tempo in audio files
 - **Bar Analysis**: Group beats into bars with configurable beats-per-bar
-- **Audio Segmentation**: Segment songs into structural parts using:
-  - Laplacian segmentation (powered by librosa)
-  - Segmentino (using Vamp plugins) 
+- **Audio Segmentation**: Segment songs into structural parts using Laplacian spectral clustering 
 - **Audio Remixing**: Create remixes by manipulating beats and bars:
   - Play individual beats or ranges of beats
   - Play entire bars or ranges of bars
@@ -66,7 +60,7 @@ I wrote most of this code in 2018-2019 and made some additions through 2021. I c
 
 ### Prerequisites
 
-- Python 3.9+ (Tested most recently with Python 3.11.12 and 3.13.2)
+- Python 3.11+ (Tested most recently with Python 3.11.12 and 3.13.2)
 - ffms2 libraries (On Fedora: `dnf install ffms2`; tested most recently with ffms-5.0)
 
 ### Installing from PyPI
@@ -105,32 +99,17 @@ pip install -e .
 
 3. Installing optional dependencies:
 
-rosabeats has optional dependencies that can be installed based on your needs:
-
 ```bash
-# Install with Vamp plugin support
-pip install .[vamp]
-
 # Install with ffms2 support for additional audio formats
 pip install .[ffms2]
-
-# Install with all optional dependencies
-pip install .[all]
 ```
 
 This will install the package and its dependencies, and make the following command-line tools available:
 - `beatrecipe-processor`: Process beat recipes
-- `segment-song`: Segment songs using librosa's Laplacian segmentation
+- `segment-song`: Segment songs and track beats
 - `beatswitch`: Generate beat recipes with alternating patterns
 - `rosabeats-shell`: Interactive shell for beat manipulation
 
-### Optional: Vamp Plugins for Segmentino
-
-If you want to use the Segmentino-based segmentation:
-
-1. Download and install the Vamp plugin SDK
-2. Install the Segmentino plugin
-
 ### Using rosabeats
 
 The package can be imported in Python as:
@@ -153,6 +132,5 @@ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH RE
 ## Acknowledgments
 
 - [librosa](https://librosa.org/) for audio analysis
-- [Vamp plugins](https://www.vamp-plugins.org/) for audio segmentation
 - [Amen](https://github.com/algorithmic-music-exploration/amen) was the original inspiration
 

rosabeats-0.2.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+rosabeats/__init__.py,sha256=NK8E9j28o-RhODkxyz8_eAh1vrZCsIWCgMjH4k1ihmE,841
+rosabeats/__main__.py,sha256=mD7v9AKzfGGuNtoeiJHk86viSYSdLnZ68UQEeVMqKaY,1899
+rosabeats/beatrecipe_processor.py,sha256=Qqib_TxTMnf9rxJikGrQKF-gELuMvLXJ5cxMV2yKBLM,17466
+rosabeats/beatswitch.py,sha256=IxnoIJLZ3MnCehZiHdwh4CBUepIAD7aAbPZpGMkgOtA,9000
+rosabeats/downbeat.py,sha256=pr--PY8EoG2kFQ1ZNzaLlIjvWsYXFdq3WkCITwbUQ2I,6500
+rosabeats/rosabeats.py,sha256=pi2ZF1Ee5bP-d0gIuEdx5woIjOJ51cUoVLKynrYuOmQ,36660
+rosabeats/rosabeats_shell.py,sha256=IpFIj_gJlnTpSNBH7tz9Hz6WMiEpE8pLUOneU5QbSso,14083
+rosabeats/segment_song.py,sha256=bNEvVmeNTb2Qqh6yQRoUGbJyOGH4ICwl-TFR8vLJtvo,8725
+rosabeats-0.2.0.dist-info/licenses/LICENSE.md,sha256=aPJeloE50MoONg47hPe8CtvglnNcGO3tsS-S5os4WiA,771
+tests/__init__.py,sha256=K1oWjE0XeOozGuGmu-XE1MmHzSjPMPe8fCIXApdkupQ,23
+tests/conftest.py,sha256=cazq6W3j3jBKo2Swby3NtxZy_SfjAFIhnFEkzG6SXJE,3616
+tests/test_beatrecipe_processor.py,sha256=5XYsyeD_gEk5BzSC5aMuiE6FEQrT8p838wdT7JqUZF4,7014
+tests/test_downbeat.py,sha256=ZbEst4u-ZPBv1nUBXe46GV6spAXkvPfrjh65Hw1GdlY,6028
+tests/test_rosabeats.py,sha256=O4x6grGFV9_zcU9bIqbjLoKkzuMR-Gsou3bv6r1tDWk,6998
+tests/test_segment_song.py,sha256=hJYtdpe9tmBygv_MdDRlmz9dfylQl7v8Quidrm9GOdA,3414
+tests/test_shell.py,sha256=c_IgwQlej-tBPMHCSWvqQ1mxnEora3KoZBL0JAE6grk,10258
+rosabeats-0.2.0.dist-info/METADATA,sha256=nMSRJ8LMQ0AYDzeQNKUV3h333KbdEAXSlrw98cTPp9Q,6325
+rosabeats-0.2.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+rosabeats-0.2.0.dist-info/entry_points.txt,sha256=4psFMIAY5kogJyT8RMdFeTpAnRHmZpaFPnlwI3tntuk,208
+rosabeats-0.2.0.dist-info/top_level.txt,sha256=3mKBok5LDShHMDBok1_PSp9Y4tGYJn76G61HF-iaBFc,16
+rosabeats-0.2.0.dist-info/RECORD,,

rosabeats-0.2.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+rosabeats
+tests

tests/__init__.py

@@ -0,0 +1 @@
+# rosabeats test suite

tests/conftest.py

@@ -0,0 +1,131 @@
+"""Shared pytest fixtures for rosabeats tests."""
+
+import pytest
+import numpy as np
+
+
+@pytest.fixture
+def sample_rate():
+    """Standard sample rate for tests."""
+    return 22050
+
+
+@pytest.fixture
+def mono_audio(sample_rate):
+    """Generate a simple mono audio signal (1 second of sine wave)."""
+    duration = 1.0
+    t = np.linspace(0, duration, int(sample_rate * duration), dtype=np.float32)
+    # 440 Hz sine wave
+    audio = 0.5 * np.sin(2 * np.pi * 440 * t)
+    return audio
+
+
+@pytest.fixture
+def beat_times():
+    """Sample beat times at 120 BPM (0.5s intervals)."""
+    return np.array([0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0, 5.5, 6.0, 6.5, 7.0, 7.5])
+
+
+@pytest.fixture
+def synthetic_audio_with_beats(sample_rate):
+    """Generate synthetic audio with clear beats for testing.
+
+    Creates a 10-second audio clip at 120 BPM with kicks on downbeats
+    (every 4 beats) and lighter hits on other beats.
+    """
+    duration = 10.0
+    n_samples = int(sample_rate * duration)
+    audio = np.zeros(n_samples, dtype=np.float32)
+
+    bpm = 120
+    beat_interval = 60.0 / bpm  # 0.5 seconds
+    beats_per_bar = 4
+
+    # Create a simple kick drum sound (low frequency pulse)
+    kick_duration = 0.05
+    kick_samples = int(sample_rate * kick_duration)
+    t_kick = np.linspace(0, kick_duration, kick_samples)
+    kick = np.sin(2 * np.pi * 60 * t_kick) * np.exp(-t_kick * 40)
+
+    # Create a lighter hi-hat sound (high frequency noise burst)
+    hat_duration = 0.02
+    hat_samples = int(sample_rate * hat_duration)
+    t_hat = np.linspace(0, hat_duration, hat_samples)
+    hat = np.random.randn(hat_samples).astype(np.float32) * 0.1 * np.exp(-t_hat * 100)
+
+    # Place beats
+    beat_num = 0
+    current_time = 0.0
+    while current_time < duration:
+        sample_idx = int(current_time * sample_rate)
+
+        if beat_num % beats_per_bar == 0:
+            # Downbeat - kick drum
+            end_idx = min(sample_idx + len(kick), n_samples)
+            audio[sample_idx:end_idx] += kick[:end_idx - sample_idx]
+        else:
+            # Other beat - hi-hat
+            end_idx = min(sample_idx + len(hat), n_samples)
+            audio[sample_idx:end_idx] += hat[:end_idx - sample_idx]
+
+        beat_num += 1
+        current_time += beat_interval
+
+    # Normalize
+    if np.max(np.abs(audio)) > 0:
+        audio = audio / np.max(np.abs(audio)) * 0.8
+
+    return audio, sample_rate
+
+
+@pytest.fixture
+def temp_audio_file(tmp_path, synthetic_audio_with_beats):
+    """Create a temporary WAV file for testing.
+
+    This creates a stereo file for better compatibility with rosabeats.
+    """
+    import soundfile as sf
+
+    audio, sr = synthetic_audio_with_beats
+    # Convert to stereo
+    stereo_audio = np.column_stack([audio, audio])
+    filepath = tmp_path / "test_audio.wav"
+    sf.write(filepath, stereo_audio, sr)
+    return str(filepath)
+
+
+@pytest.fixture
+def sample_br_content():
+    """Sample beat recipe file content."""
+    return """file test.wav
+beats_bar 4 0
+# This is a comment
+def intro beats 0-15
+def verse bars 0-3
+def chorus bars 4-7
+
+# Play commands
+play intro
+play verse 2
+"""
+
+
+@pytest.fixture
+def sample_bri_content():
+    """Sample .bri file content (from segment-song output)."""
+    return """##BEATS## This was segmented and tracked using librosa's beat tracker
+
+file /path/to/audio.wav
+beats_bar 4 0
+# total beats = 100
+# total bars = 24 (beats 0-96)
+def A bars 0-3
+def B bars 4-7
+def A2 bars 8-11
+def C bars 12-15
+
+def A_beats beats 0-15	# dur = 8.00s
+def B_beats beats 16-31	# dur = 8.00s
+def A2_beats beats 32-47	# dur = 8.00s
+def C_beats beats 48-63	# dur = 8.00s
+"""

tests/test_beatrecipe_processor.py

@@ -0,0 +1,193 @@
+"""Tests for beatrecipe_processor module."""
+
+import pytest
+
+from rosabeats.beatrecipe_processor import beatrecipe_processor
+
+
+class TestBeatrecipeProcessorIlist:
+    """Tests for ilist static method."""
+
+    def test_ascending_range(self):
+        """Should create list from ascending range tuple."""
+        result = beatrecipe_processor.ilist((3, 7, 1))
+        assert result == [3, 4, 5, 6, 7]
+
+    def test_descending_range(self):
+        """Should create list from descending range tuple."""
+        result = beatrecipe_processor.ilist((7, 3, -1))
+        assert result == [7, 6, 5, 4, 3]
+
+    def test_single_element(self):
+        """Should handle single element range."""
+        result = beatrecipe_processor.ilist((5, 5, 1))
+        assert result == [5]
+
+
+class TestBeatrecipeProcessorParseFirstLast:
+    """Tests for parse_first_last static method."""
+
+    def test_single_number(self):
+        """Should parse single number."""
+        result = beatrecipe_processor.parse_first_last("5")
+        assert result == (5, 5, 1)
+
+    def test_ascending_range(self):
+        """Should parse ascending range."""
+        result = beatrecipe_processor.parse_first_last("3-7")
+        assert result == (3, 7, 1)
+
+    def test_descending_range(self):
+        """Should parse descending range with negative step."""
+        result = beatrecipe_processor.parse_first_last("7-3")
+        assert result == (7, 3, -1)
+
+
+class TestBeatrecipeProcessorPreprocess:
+    """Tests for preprocess method."""
+
+    @pytest.fixture
+    def processor(self, tmp_path, sample_br_content):
+        """Create a processor instance with a recipe file."""
+        recipe_file = tmp_path / "test.br"
+        recipe_file.write_text(sample_br_content)
+        return beatrecipe_processor(str(recipe_file))
+
+    def test_empty_line(self, processor):
+        """Should return None for empty line."""
+        result = processor.preprocess("")
+        assert result is None
+
+    def test_whitespace_only(self, processor):
+        """Should return None for whitespace only."""
+        result = processor.preprocess("   ")
+        assert result is None
+
+    def test_comment_line(self, processor):
+        """Should return None for comment line."""
+        result = processor.preprocess("# this is a comment")
+        assert result is None
+
+    def test_simple_command(self, processor):
+        """Should return list with single command."""
+        result = processor.preprocess("beats 0-7")
+        assert result == ["beats 0-7"]
+
+    def test_inline_comment_stripped(self, processor):
+        """Should strip inline comments."""
+        result = processor.preprocess("beats 0-7 # play intro")
+        assert result == ["beats 0-7"]
+
+    def test_semicolon_splits_commands(self, processor):
+        """Should split commands on semicolons."""
+        result = processor.preprocess("beats 0-3; beats 4-7")
+        assert result == ["beats 0-3", "beats 4-7"]
+
+    def test_multiple_semicolons(self, processor):
+        """Should handle multiple semicolons."""
+        result = processor.preprocess("a; b; c")
+        assert result == ["a", "b", "c"]
+
+
+class TestBeatrecipeProcessorMacros:
+    """Tests for macro functionality."""
+
+    @pytest.fixture
+    def processor(self, tmp_path, sample_br_content):
+        """Create a processor instance with a recipe file."""
+        recipe_file = tmp_path / "test.br"
+        recipe_file.write_text(sample_br_content)
+        return beatrecipe_processor(str(recipe_file))
+
+    def test_define_macro(self, processor):
+        """Should define a macro."""
+        processor.define_macro("test", "beats 0-7")
+        assert processor.is_defined_macro("test")
+        assert processor.macros["test"] == "beats 0-7"
+
+    def test_is_defined_macro_false(self, processor):
+        """Should return False for undefined macro."""
+        assert not processor.is_defined_macro("undefined")
+
+    def test_redefine_macro(self, processor):
+        """Should allow redefining a macro."""
+        processor.define_macro("test", "beats 0-7")
+        processor.define_macro("test", "bars 0-3")
+        assert processor.macros["test"] == "bars 0-3"
+
+
+class TestBeatrecipeProcessorParseCommand:
+    """Tests for parse_command method."""
+
+    @pytest.fixture
+    def processor(self, tmp_path, sample_br_content):
+        """Create a processor instance with a recipe file."""
+        recipe_file = tmp_path / "test.br"
+        recipe_file.write_text(sample_br_content)
+        p = beatrecipe_processor(str(recipe_file))
+        p.interactive = False
+        return p
+
+    def test_parse_beats_command(self, processor):
+        """Should parse beats command."""
+        verb, args = processor.parse_command("beats 0-7")
+        assert verb == "beats"
+        assert args == ["0-7"]
+
+    def test_parse_bars_command(self, processor):
+        """Should parse bars command."""
+        verb, args = processor.parse_command("bars 0-3")
+        assert verb == "bars"
+        assert args == ["0-3"]
+
+    def test_parse_def_command(self, processor):
+        """Should parse def command."""
+        verb, args = processor.parse_command("def intro beats 0-7")
+        assert verb == "def"
+        assert args == ["intro", "beats", "0-7"]
+
+    def test_parse_play_command(self, processor):
+        """Should parse play command."""
+        verb, args = processor.parse_command("play intro 2")
+        assert verb == "play"
+        assert args == ["intro", "2"]
+
+    def test_parse_rest_command(self, processor):
+        """Should parse rest command."""
+        verb, args = processor.parse_command("rest 1.5")
+        assert verb == "rest"
+        assert args == ["1.5"]
+
+    def test_parse_file_command(self, processor):
+        """Should parse file command."""
+        verb, args = processor.parse_command("file /path/to/audio.wav")
+        assert verb == "file"
+        assert args == ["/path/to/audio.wav"]
+
+    def test_parse_beats_bar_command(self, processor):
+        """Should parse beats_bar command."""
+        verb, args = processor.parse_command("beats_bar 4 0")
+        assert verb == "beats_bar"
+        assert args == ["4", "0"]
+
+
+class TestBeatrecipeProcessorInit:
+    """Tests for processor initialization."""
+
+    def test_init_with_recipe(self, tmp_path, sample_br_content):
+        """Should initialize with recipe file."""
+        recipe_file = tmp_path / "test.br"
+        recipe_file.write_text(sample_br_content)
+        p = beatrecipe_processor(str(recipe_file))
+        assert p.macros is not None
+        assert p.interactive is False
+
+    def test_loads_macros_from_recipe(self, tmp_path, sample_br_content):
+        """Should load macro definitions from recipe file."""
+        recipe_file = tmp_path / "test.br"
+        recipe_file.write_text(sample_br_content)
+        p = beatrecipe_processor(str(recipe_file))
+        # The sample_br_content defines 'intro', 'verse', 'chorus'
+        assert p.is_defined_macro("intro")
+        assert p.is_defined_macro("verse")
+        assert p.is_defined_macro("chorus")