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

rosabeats/__init__.py

@@ -13,7 +13,7 @@ Main features:
 - Beat Recipe Files: Save and load beat patterns as reusable recipes
 """
 
-__version__ = "0.1.3"
+__version__ = "0.2.0"
 
 # Import main classes and functions from the module
 from .rosabeats import rosabeats

rosabeats/__main__.py

@@ -0,0 +1,59 @@
+#!/usr/bin/env python
+"""
+Entry point for running rosabeats as a module.
+
+Usage:
+    python -m rosabeats [command]
+
+Commands:
+    shell       Launch interactive shell (default)
+    segment     Segment audio file and track beats
+    beatswitch  Generate beat recipe with alternating patterns
+    recipe      Process beat recipe files
+
+Examples:
+    python -m rosabeats                     # Launch interactive shell
+    python -m rosabeats shell               # Same as above
+    python -m rosabeats segment song.wav    # Segment audio file
+    python -m rosabeats beatswitch song.wav # Generate beat recipe
+    python -m rosabeats recipe file.br      # Process beat recipe
+"""
+
+import sys
+
+
+def main():
+    """Main entry point for python -m rosabeats."""
+    if len(sys.argv) < 2:
+        # Default to shell
+        from rosabeats.rosabeats_shell import main as shell_main
+        sys.exit(shell_main())
+
+    command = sys.argv[1]
+
+    # Remove the command from argv so subcommands see correct args
+    sys.argv = [f"rosabeats {command}"] + sys.argv[2:]
+
+    if command in ("shell", "sh"):
+        from rosabeats.rosabeats_shell import main as shell_main
+        sys.exit(shell_main())
+    elif command in ("segment", "seg"):
+        from rosabeats.segment_song import main as segment_main
+        sys.exit(segment_main() or 0)
+    elif command in ("beatswitch", "bs"):
+        from rosabeats.beatswitch import main as beatswitch_main
+        sys.exit(beatswitch_main() or 0)
+    elif command in ("recipe", "br"):
+        from rosabeats.beatrecipe_processor import main as recipe_main
+        sys.exit(recipe_main() or 0)
+    elif command in ("-h", "--help", "help"):
+        print(__doc__)
+        sys.exit(0)
+    else:
+        print(f"Unknown command: {command}")
+        print("Use 'python -m rosabeats --help' for usage information.")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

rosabeats/beatrecipe_processor.py

@@ -4,6 +4,7 @@ import re, sys, os.path, random, logging
 
 from rosabeats import rosabeats
 
+
 class beatrecipe_processor(rosabeats):
     @staticmethod
     def ilist(indices):
@@ -65,6 +66,13 @@ class beatrecipe_processor(rosabeats):
     def parse_error(self, error_info):
         self.log.error("%s" % error_info)
 
+    def parse_command(self, cmd):
+        """Split a command line into (verb, args). args is a list of remaining tokens."""
+        parts = cmd.split()
+        if not parts:
+            return None, []
+        return parts[0], parts[1:]
+
     def read_beatrecipe(self):
         self.recipe_lines = list()
         with open(self.recipe, "r") as f:
@@ -75,11 +83,18 @@ class beatrecipe_processor(rosabeats):
 
                 for cmd in lines:
                     self.recipe_lines.append(cmd)
+                    # Load macro definitions at read time so macros are available after init
+                    if cmd.strip().startswith("def "):
+                        try:
+                            _, rest = cmd.split(maxsplit=1)
+                            name, value = rest.split(maxsplit=1)
+                            self.define_macro(name, value)
+                        except Exception:
+                            pass
 
     def define_macro(self, name, value):
         if self.macros.get(name) is not None:
-            self.parse_error("macro %s already defined" % name)
-            return False
+            self.log.debug("macro %s redefined" % name)
         self.macros[name] = value
         return True
 
@@ -114,7 +129,7 @@ class beatrecipe_processor(rosabeats):
             return None
 
         # skip lines that start with hash
-        if line.startswith('#'):
+        if line.startswith("#"):
             return None
 
         # remove same line comments but process rest of line
@@ -127,7 +142,7 @@ class beatrecipe_processor(rosabeats):
 
         # split multiple commands separated by semicolons
         lines = []
-        for l in line.split(';'):
+        for l in line.split(";"):
             lines.append(l.strip())
 
         return lines
@@ -339,9 +354,7 @@ class beatrecipe_processor(rosabeats):
                     return True
                 else:
                     raise e
-            print(
-                "[*] (def seg: %s = %s)" % (name, value)
-            )
+            print("[*] (def seg: %s = %s)" % (name, value))
 
             self.define_macro(name, value)
             print("defined %s => %s" % (name, value))
@@ -357,7 +370,6 @@ class beatrecipe_processor(rosabeats):
                 print("%15s %15s" % (name, value))
 
         elif self.interactive and verb == "ls":
-
             print(", ".join(list(self.macros.keys())))
 
         elif self.interactive and verb == "quit":
@@ -392,12 +404,11 @@ class beatrecipe_processor(rosabeats):
     def process_interactive(self):
         KeepProcessing = True
         while KeepProcessing:
-
             print("")
             print("enter beatrecipe command => ", end="", flush=True)
 
             lines = self.preprocess(input())
-            
+
             for cmd in lines:
                 print(cmd)
                 KeepProcessing = self.execute_command(cmd)
@@ -413,8 +424,8 @@ class beatrecipe_processor(rosabeats):
             except Exception:
                 verb = line
                 args = ""
-#               self.parse_error("could not split line into verb and args")
-#               sys.exit(1)
+            #               self.parse_error("could not split line into verb and args")
+            #               sys.exit(1)
 
             if verb == "file":
                 filename = str(args)
@@ -433,10 +444,12 @@ class beatrecipe_processor(rosabeats):
                 # if we know our audio source, load it, analyze it, and init outputs
                 if self.sourcefile:
                     print("One moment as we track your beats for you, madame...")
-                    self.track_beats(beatsper=per, firstfull=first)
+                    self.track_beats(beatsper=per, downbeat=first)
                     self.init_outputs()
                 else:
-                    self.parse_error("a file directive must come before a beats_bar directive")
+                    self.parse_error(
+                        "a file directive must come before a beats_bar directive"
+                    )
                     sys.exit(1)
 
             elif verb == "def":
@@ -457,46 +470,49 @@ class beatrecipe_processor(rosabeats):
 
 
 def main(args=None):
-    output_play = False
-    output_save = False
-    output_beats = False
-    loglevel = logging.INFO
-    recipes = []
-    
-    # If no args provided, use sys.argv (skipping the script name at index 0)
-    if args is None:
-        args = sys.argv[1:]
-        
-    for arg in args:
-        if arg == "-p" or arg == "--play":
-            output_play = True
-
-        elif arg == "-s" or arg == "--save":
-            output_save = True
-
-        elif arg == "-b" or arg == "--beats":
-            output_beats = True
-
-        elif arg == "-d" or arg == "--debug":
-            loglevel = logging.DEBUG
-
-        else:
-            recipes.append(arg)
-
-    if len(recipes) < 1:
-        print("no recipes to process were found on command line")
-        sys.exit(1)
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description='Process beat recipe files (.br) to create audio remixes',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog='''
+Examples:
+  beatrecipe-processor -p recipe.br           Play the recipe
+  beatrecipe-processor -s recipe.br           Save output to WAV
+  beatrecipe-processor -p -s recipe.br        Play and save
+  beatrecipe-processor -b recipe.br           Write beats output file
+'''
+    )
+    parser.add_argument('recipes', nargs='+', metavar='RECIPE',
+                        help='Beat recipe files (.br) to process')
+    parser.add_argument('-p', '--play', action='store_true',
+                        help='Enable audio playback')
+    parser.add_argument('-s', '--save', action='store_true',
+                        help='Save output to WAV file')
+    parser.add_argument('-b', '--beats', action='store_true',
+                        help='Write beats output file')
+    parser.add_argument('-d', '--debug', action='store_true',
+                        help='Enable debug mode')
+
+    parsed = parser.parse_args(args)
+
+    output_play = parsed.play
+    output_save = parsed.save
+    output_beats = parsed.beats
+    loglevel = logging.DEBUG if parsed.debug else logging.INFO
+    recipes = parsed.recipes
 
     if not (output_play or output_save or output_beats):
-        print("must specify one or more of --play, --save, or --beats for output")
-        sys.exit(1)
+        parser.error("must specify one or more of --play, --save, or --beats for output")
 
     for recipe in recipes:
         print("processing %s..." % recipe, flush=True)
 
         stub, ext = os.path.splitext(os.path.basename(recipe))
 
-        p = beatrecipe_processor(recipe, interactive=False, loglevel=loglevel, debug=True)
+        p = beatrecipe_processor(
+            recipe, interactive=False, loglevel=loglevel, debug=True
+        )
 
         if output_play:
             p.enable_output_play()
@@ -519,5 +535,6 @@ def main(args=None):
             print("error processing %s: %s" % (recipe, e), flush=True)
             raise e
 
+
 if __name__ == "__main__":
     main()

rosabeats/beatswitch.py

@@ -21,16 +21,16 @@ class BeatSwitcher(rosabeats.rosabeats):
     Attributes:
         infile (str): Path to input audio file
         outfile (str): Path to output beat recipe file (.br)
-        firstfull (int): Index of first full bar
+        downbeat (int): Beat index of first downbeat
         fmin (int): Minimum number of forward beats
         fmax (int): Maximum number of forward beats
         bmin (int): Minimum number of backward beats
         bmax (int): Maximum number of backward beats
     """
-    
+
     def __init__(self, infile, debug=False):
         """Initialize the BeatSwitcher.
-        
+
         Args:
             infile (str): Path to input audio file
             debug (bool, optional): Enable debug mode
@@ -43,26 +43,26 @@ class BeatSwitcher(rosabeats.rosabeats):
 
         # Initialize instance variables
         self.outfile = None
-        self.firstfull = None
+        self._downbeat_arg = None
         self.fmin = None
         self.fmax = None
         self.bmin = None
         self.bmax = None
 
-    def setup(self, outfile, firstfull):
+    def setup(self, outfile, downbeat=None):
         """Set up the beat recipe configuration.
-        
+
         Args:
             outfile (str): Path to output beat recipe file (.br)
-            firstfull (int): Index of first full bar
+            downbeat (int, optional): Beat index of first downbeat (auto-detected if None)
         """
         # Configure output file
         self.outfile = outfile
         self.enable_output_beats(self.outfile)
 
         # Configure beat tracking
-        self.firstfull = firstfull
-        self.track_beats(firstfull=firstfull)
+        self._downbeat_arg = downbeat
+        self.track_beats(downbeat=downbeat)
 
         # Disable WAV output and playback
         self.disable_output_save()
@@ -90,7 +90,7 @@ class BeatSwitcher(rosabeats.rosabeats):
             self.gen_beat_samples()
 
         # Start from first full bar
-        curr_beat = self.firstfullbar
+        curr_beat = self.downbeat
         song_over = False
         direction = "r"  # Start with reverse direction
 
@@ -215,8 +215,12 @@ def parse_args():
         help="Maximum number of backward beats"
     )
     parser.add_argument(
-        "--firstfull", type=int, default=0,
-        help="First full bar index"
+        "--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(
         "--debug", action="store_true",
@@ -247,7 +251,19 @@ def main():
     
     # Create and run beat switcher
     bs = BeatSwitcher(args.input_file, debug=args.debug)
-    bs.setup(output_file, args.firstfull)
+
+    # Determine downbeat value
+    if args.downbeat is not None:
+        downbeat = args.downbeat
+    elif args.auto_downbeat:
+        # Auto-detect using DBN approach
+        bs.track_beats(downbeat=0)
+        print("Auto-detecting downbeat using DBN...")
+        downbeat = bs.detect_downbeat_dbn(bs.beatsperbar)
+    else:
+        downbeat = 0
+
+    bs.setup(output_file, downbeat)
     bs.set_parameters(args.fmin, args.fmax, args.bmin, args.bmax)
     bs.run()
 

rosabeats/downbeat.py

@@ -0,0 +1,207 @@
+"""
+Downbeat detection for beat-tracked audio.
+
+This module finds the first downbeat (beat 1 of bar 1) given beat times from
+a beat tracker. It uses spectral features that distinguish downbeats:
+- Low-frequency energy (bass/kick drum often hits on downbeats)
+- Onset strength patterns
+- Spectral contrast
+"""
+
+import numpy as np
+
+
+def compute_beat_features(audio_data, sr, beat_times):
+    """Compute features at each beat position for downbeat detection.
+
+    Args:
+        audio_data: Mono audio time series
+        sr: Sample rate
+        beat_times: Beat times in seconds
+
+    Returns:
+        dict with feature arrays, each of shape (num_beats,)
+    """
+    import librosa
+
+    n_beats = len(beat_times)
+    if n_beats == 0:
+        return {}
+
+    # Convert beat times to samples
+    beat_samples = librosa.time_to_samples(beat_times, sr=sr)
+
+    # Compute spectrograms
+    # Standard spectrogram for onset strength
+    hop_length = 512
+    S = np.abs(librosa.stft(audio_data, hop_length=hop_length))
+
+    # Mel spectrogram for low-frequency analysis
+    mel_S = librosa.feature.melspectrogram(S=S**2, sr=sr, n_mels=128)
+
+    # Low frequency energy (roughly 20-200 Hz, first ~10 mel bands)
+    low_freq_energy = np.sum(mel_S[:10, :], axis=0)
+
+    # Mid frequency energy (roughly 200-2000 Hz)
+    mid_freq_energy = np.sum(mel_S[10:60, :], axis=0)
+
+    # Onset strength
+    onset_env = librosa.onset.onset_strength(S=librosa.amplitude_to_db(S, ref=np.max), sr=sr)
+
+    # Spectral flux (change in spectrum)
+    spectral_flux = np.sqrt(np.sum(np.diff(S, axis=1)**2, axis=0))
+    spectral_flux = np.concatenate([[0], spectral_flux])
+
+    # Convert beat samples to frames
+    beat_frames = librosa.samples_to_frames(beat_samples, hop_length=hop_length)
+    beat_frames = np.minimum(beat_frames, len(onset_env) - 1)
+
+    # Extract features at each beat
+    features = {
+        'onset_strength': onset_env[beat_frames],
+        'low_freq_energy': low_freq_energy[beat_frames],
+        'mid_freq_energy': mid_freq_energy[beat_frames],
+        'spectral_flux': spectral_flux[np.minimum(beat_frames, len(spectral_flux) - 1)],
+    }
+
+    # Normalize each feature
+    for key in features:
+        f = features[key]
+        if f.max() > f.min():
+            features[key] = (f - f.min()) / (f.max() - f.min())
+        else:
+            features[key] = np.zeros_like(f)
+
+    # Compute low-to-mid ratio (high on kick drums)
+    low = features['low_freq_energy']
+    mid = features['mid_freq_energy']
+    # Avoid division by zero
+    features['low_mid_ratio'] = low / (mid + 0.1)
+    if features['low_mid_ratio'].max() > 0:
+        features['low_mid_ratio'] /= features['low_mid_ratio'].max()
+
+    return features
+
+
+def score_offset(features, offset, beats_per_bar, weights=None):
+    """Score a particular beat offset for being the downbeat.
+
+    Args:
+        features: Dict of feature arrays from compute_beat_features
+        offset: Beat offset to test (0 to beats_per_bar-1)
+        beats_per_bar: Number of beats per bar
+        weights: Optional dict of feature weights
+
+    Returns:
+        float: Score for this offset (higher = more likely downbeat)
+    """
+    if weights is None:
+        # Default weights emphasizing low frequency (bass drum)
+        weights = {
+            'onset_strength': 1.0,
+            'low_freq_energy': 2.0,
+            'low_mid_ratio': 1.5,
+            'spectral_flux': 0.5,
+        }
+
+    n_beats = len(features['onset_strength'])
+    if n_beats < beats_per_bar:
+        return 0.0
+
+    # Get indices of would-be downbeats with this offset
+    downbeat_indices = np.arange(offset, n_beats, beats_per_bar)
+
+    if len(downbeat_indices) == 0:
+        return 0.0
+
+    # Weight earlier downbeats more (they're more reliable, less affected by
+    # song structure changes like drops/breakdowns)
+    position_weights = np.exp(-0.02 * np.arange(len(downbeat_indices)))
+
+    # Compute weighted score for each feature
+    total_score = 0.0
+    for feature_name, feature_weight in weights.items():
+        if feature_name not in features:
+            continue
+
+        feature_values = features[feature_name][downbeat_indices]
+
+        # Also compute contrast with non-downbeat positions
+        non_downbeat_mask = np.ones(n_beats, dtype=bool)
+        non_downbeat_mask[downbeat_indices] = False
+
+        if non_downbeat_mask.any():
+            non_downbeat_mean = features[feature_name][non_downbeat_mask].mean()
+        else:
+            non_downbeat_mean = 0
+
+        # Score = weighted sum of (downbeat values - non-downbeat mean)
+        contrast = feature_values - non_downbeat_mean
+        feature_score = np.sum(contrast * position_weights) / position_weights.sum()
+
+        total_score += feature_weight * feature_score
+
+    return total_score
+
+
+def detect_downbeat(audio_data, sr, beat_times, beats_per_bar=4, debug=False):
+    """Detect the first downbeat given audio and beat times.
+
+    This finds which beat offset (0 to beats_per_bar-1) best aligns with
+    musical downbeats based on spectral features.
+
+    Args:
+        audio_data: Mono audio time series
+        sr: Sample rate
+        beat_times: Beat times in seconds from beat tracker
+        beats_per_bar: Number of beats per bar
+        debug: Print debug information
+
+    Returns:
+        int: Index of the first downbeat in beat_times array
+    """
+    n_beats = len(beat_times)
+
+    if n_beats < beats_per_bar:
+        return 0
+
+    # Compute features at each beat
+    features = compute_beat_features(audio_data, sr, beat_times)
+
+    if not features:
+        return 0
+
+    # Score each possible offset
+    best_offset = 0
+    best_score = -np.inf
+
+    for offset in range(beats_per_bar):
+        score = score_offset(features, offset, beats_per_bar)
+
+        if debug:
+            print(f"  Offset {offset}: score = {score:.4f}")
+
+        if score > best_score:
+            best_score = score
+            best_offset = offset
+
+    if debug:
+        print(f"  Best offset: {best_offset} (score = {best_score:.4f})")
+
+    return best_offset
+
+
+# Alias for compatibility
+def detect_downbeat_dbn(audio_data, sr, beat_times, beats_per_bar=4):
+    """Detect the first downbeat (alias for detect_downbeat).
+
+    Args:
+        audio_data: Mono audio time series
+        sr: Sample rate
+        beat_times: Beat times in seconds
+        beats_per_bar: Number of beats per bar
+
+    Returns:
+        int: Index of the first downbeat
+    """
+    return detect_downbeat(audio_data, sr, beat_times, beats_per_bar)