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

rosabeats/rosabeats_shell.py

@@ -1,386 +1,493 @@
 #!/usr/bin/env python
 
-import re, sys, os.path, random
-import cmd, rosabeats
+import re
+import sys
+import os.path
+import random
+import cmd
+import rosabeats
 
 
-class rosabeats_shell(cmd.Cmd, rosabeats.rosabeats):
-    intro = "welcome to the rosabeats shell"
-    prompt = "R@; "
+def parse_range(arg):
+    """Parse a range argument like '8' or '8-16' or '-3-2' into a list of integers.
 
-    def define_macro(self, name, value):
-        if self.is_defined_macro(name):
-            print("redefining macro %s" % name)
-        self.macros[name] = value
-        return True
+    Returns list of ints, or None on error.
+    """
+    arg = arg.strip()
+    if not arg:
+        return None
 
-    def play_macro(self, name, times):
-        if not self.is_defined_macro(name):
-            print("macro %s not defined" % name)
-            return False
+    # Support negative numbers: match optional minus, digits, optional -stop
+    m = re.match(r"^(-?\d+)(?:-(-?\d+))?$", arg)
+    if not m:
+        print(f"invalid range: '{arg}' - use e.g. '8' or '8-16' or '-3-2'")
+        return None
+    start = int(m.group(1))
+    stop = int(m.group(2)) if m.group(2) is not None else start
 
-        macro = self.macros[name]
+    if start > stop:
+        step = -1
+    else:
+        step = 1
 
-        print("[*] %d * %s [%s]" % (times, name, macro))
+    return list(range(start, (stop + 1) if step >= 0 else (stop - 1), step))
 
-        for x in range(times):
-            print("-> %s" % macro)
-            self.onecmd(self.precmd(macro))
 
-    def is_defined_macro(self, name):
-        if self.macros.get(name, None) is not None:
-            return True
-        else:
-            return False
+def parse_int(arg, name="argument"):
+    """Parse an integer argument. Returns int or None on error."""
+    try:
+        return int(arg.strip())
+    except (ValueError, AttributeError):
+        print(f"{name} must be an integer")
+        return None
 
-    def arg1_parse_range(self):
-        start = None
-        stop = None
-        step = None
 
-        try:
-            if "-" in self.cmd_args[0]:
-                start, stop = self.cmd_args[0].split("-", maxsplit=1)
-                start = int(start)
-                stop = int(stop)
-
-            else:
-                start = int(self.cmd_args[0])
-                stop = start
-        except:
-            print("first argument must be valid range, e.g. '8' or '8-10'")
-            return None
+def parse_float(arg, name="argument"):
+    """Parse a float argument. Returns float or None on error."""
+    try:
+        return float(arg.strip())
+    except (ValueError, AttributeError):
+        print(f"{name} must be a number")
+        return None
 
-        if start > stop:
-            step = -1
-        else:
-            step = 1
 
-        return [x for x in range(start, (stop + 1) if step >= 0 else (stop - 1), step)]
+class rosabeats_shell(cmd.Cmd, rosabeats.rosabeats):
+    intro = "Welcome to the rosabeats shell. Type 'help' for commands."
+    prompt = "R> "
 
-    # constructor
     def __init__(self):
         cmd.Cmd.__init__(self)
         rosabeats.rosabeats.__init__(self)
-        #       super(cmd.Cmd, self)
-        #       super(rosabeats.rosabeats, self)
-        #       super().__init__()
-        self.macros = dict()
-        self.cmd_args = None
-
-    # pre & post hooks
-    def precmd(self, line):
-        if line.strip() != '':
-            print("precmd: saving cmd as %s" % line)
-            self.prev_cmd = line
-            self.cmd_args = line.split()[1:]
-        return line
+        self.macros = {}
 
     def preloop(self):
         self.enable_output_play()
         self.disable_output_beats()
         self.disable_output_save()
 
-    def arg1_float(self):
-        try:
-            arg1 = float(self.cmd_args[0])
-        except:
-            print("arg1 must be float")
-            return None
-        return arg1
+    # --- Macro management ---
 
-    def arg1_string(self):
-        try:
-            arg1 = str(self.cmd_args[0])
-        except:
-            print("arg1 must be string")
-            return None
-        return arg1
+    def define_macro(self, name, value):
+        if name in self.macros:
+            print(f"redefining macro '{name}'")
+        self.macros[name] = value
 
-    def arg1_int(self):
-        try:
-            arg1 = int(self.cmd_args[0])
-        except:
-            print("arg1 must be int")
-            return None
-        return arg1
+    def play_macro(self, name, times=1):
+        if name not in self.macros:
+            print(f"macro '{name}' not defined")
+            return False
 
-    def arg2_int(self):
-        try:
-            arg1 = int(self.cmd_args[1])
-        except:
-            print("arg2 must be int")
-            return None
-        return arg1
+        macro = self.macros[name]
+        print(f"[*] {times} x {name} [{macro}]")
 
-    def arg3_int(self):
-        try:
-            arg3 = int(self.cmd_args[2])
-        except:
-            print("arg3 must be int")
-            return None
-        return arg3
+        for _ in range(times):
+            print(f"-> {macro}")
+            self.onecmd(macro)
+        return True
 
-    def arg2_valid_repeat(self):
-        # no second arg so 1 by default
-        if len(self.cmd_args) < 2:
-            return 1
+    # --- Commands ---
 
-        return self.arg2_int()
+    def do_file(self, arg):
+        """Load an audio file: file <path>"""
+        if not arg.strip():
+            print("usage: file <path>")
+            return
 
-    def arg3_valid_repeat(self):
-        # no third arg so 1 by default
-        if len(self.cmd_args) < 3:
-            return 1
+        filename = arg.strip()
+        print(f"loading {filename}")
+        self.setfile(filename)
 
-        return self.arg3_int()
+    def do_beats_bar(self, arg):
+        """Set beats per bar and downbeat: beats_bar <beats_per_bar> <downbeat>"""
+        args = arg.split()
+        if len(args) < 2:
+            print("usage: beats_bar <beats_per_bar> <downbeat>")
+            return
 
-    # command handlers
-    def do_rest(self, arg):
-        rest = self.arg1_float()
-        times = self.arg2_valid_repeat()
+        beatsper = parse_int(args[0], "beats_per_bar")
+        downbeat = parse_int(args[1], "downbeat")
 
-        if rest is None or times is None:
-            return False
+        if beatsper is None or downbeat is None:
+            return
 
-        print("[*] %d * %g beat(s) of rest" % (times, rest))
+        if not self.sourcefile:
+            print("error: load a file first with 'file <path>'")
+            return
 
-        for x in range(times):
-            self.rest(rest)
+        print("Tracking beats...")
+        self.track_beats(beatsper=beatsper, downbeat=downbeat)
+        print(f"Found {self.total_beats} beats in {self.total_bars} bars")
+        self.init_outputs()
 
     def do_beats(self, arg):
-        beats = self.arg1_parse_range()
-        times = self.arg2_valid_repeat()
-
-        if beats is None or times is None:
-            return False
-
-        print("[*] %d * " % times, end="", flush=True)
+        """Play beats: beats <N> or beats <N-M> [times]"""
+        args = arg.split()
+        if not args:
+            print("usage: beats <N> or beats <N-M> [times]")
+            return
+
+        beats = parse_range(args[0])
+        if beats is None:
+            return
+
+        times = 1
+        if len(args) > 1:
+            times = parse_int(args[1], "times")
+            if times is None:
+                return
 
         if len(beats) > 1:
-            print("(beats %d-%d) " % (beats[0], beats[-1]))
+            print(f"[*] {times} x beats {beats[0]}-{beats[-1]}")
         else:
-            print("(beat %d) " % beats[0])
-
-        for x in range(times):
-            self.play_beats(beats)
-
-    def do_beat_div(self, arg):
-        beat = self.arg1_int()
-        divisor = self.arg2_int()
-        times = self.arg3_valid_repeat()
-
-        if beats is None or divisor is None or times is None:
-            return False
-
-        print("[*] %d * (1/%d beats) " % (times, divisor), flush=True)
+            print(f"[*] {times} x beat {beats[0]}")
 
-        for x in range(times):
-            print("%d/%d " % (beat, divisor), end="", flush=True)
-            self.play_beat(beat, divisor=divisor, silent=True)
-
-        print(flush=True)
-
-    def do_beats_shuf(self, arg):
-        beats = self.arg1_parse_range()
-        times = self.arg2_valid_repeat()
-
-        if beats is None or times is None:
-            return False
-
-        print("[*] %d * " % times, end="", flush=True)
-        print("(shuffled beats %d-%d] " % (beats[0], beats[-1]), flush=True)
-
-        for x in range(times):
-            random.shuffle(beats)
+        for _ in range(times):
             self.play_beats(beats)
 
     def do_bars(self, arg):
-        bars = self.arg1_parse_range()
-        times = self.arg2_valid_repeat()
-
-        if bars is None or times is None:
-            return False
+        """Play bars: bars <N> or bars <N-M> [times]"""
+        args = arg.split()
+        if not args:
+            print("usage: bars <N> or bars <N-M> [times]")
+            return
+
+        bars = parse_range(args[0])
+        if bars is None:
+            return
+
+        times = 1
+        if len(args) > 1:
+            times = parse_int(args[1], "times")
+            if times is None:
+                return
 
-        print("[*] %d * " % times, end="", flush=True)
         if len(bars) > 1:
-            print("(bars %d-%d) " % (bars[0], bars[-1]), flush=True)
+            print(f"[*] {times} x bars {bars[0]}-{bars[-1]}")
         else:
-            print("(bar %d) " % bars[0], flush=True)
+            print(f"[*] {times} x bar {bars[0]}")
 
-        for x in range(times):
+        for _ in range(times):
             self.play_bars(bars)
 
     def do_bars_rev(self, arg):
-        bars = self.arg1_parse_range()
-        times = self.arg2_valid_repeat()
+        """Play bars with beats reversed: bars_rev <N-M> [times]"""
+        args = arg.split()
+        if not args:
+            print("usage: bars_rev <N-M> [times]")
+            return
+
+        bars = parse_range(args[0])
+        if bars is None:
+            return
+
+        times = 1
+        if len(args) > 1:
+            times = parse_int(args[1], "times")
+            if times is None:
+                return
 
-        if bars is None or times is None:
-            return False
-
-        print("[*] %d * " % times, end="", flush=True)
         if len(bars) > 1:
-            print("(rev bars %d-%d) " % (bars[0], bars[-1]), flush=True)
+            print(f"[*] {times} x bars_rev {bars[0]}-{bars[-1]}")
         else:
-            print("(rev bar %d) " % bars[0], flush=True)
+            print(f"[*] {times} x bar_rev {bars[0]}")
 
-        for x in range(times):
+        for _ in range(times):
             self.play_bars(bars, reverse=True)
 
+    def do_beats_shuf(self, arg):
+        """Play beats in shuffled order: beats_shuf <N-M> [times]"""
+        args = arg.split()
+        if not args:
+            print("usage: beats_shuf <N-M> [times]")
+            return
+
+        beats = parse_range(args[0])
+        if beats is None:
+            return
+
+        times = 1
+        if len(args) > 1:
+            times = parse_int(args[1], "times")
+            if times is None:
+                return
+
+        print(f"[*] {times} x beats_shuf {beats[0]}-{beats[-1]}")
+
+        for _ in range(times):
+            random.shuffle(beats)
+            self.play_beats(beats)
+
     def do_bars_shuf(self, arg):
-        bars = self.arg1_parse_range()
-        times = self.arg2_valid_repeat()
+        """Play bars in shuffled order: bars_shuf <N-M> [times]"""
+        args = arg.split()
+        if not args:
+            print("usage: bars_shuf <N-M> [times]")
+            return
 
-        if bars is None or times is None:
-            return False
+        bars = parse_range(args[0])
+        if bars is None:
+            return
+
+        times = 1
+        if len(args) > 1:
+            times = parse_int(args[1], "times")
+            if times is None:
+                return
 
-        print("[*] %d * " % times, end="", flush=True)
-        print("(shuffled bars %d-%d) " % (bars[0], bars[-1]), flush=True)
+        print(f"[*] {times} x bars_shuf {bars[0]}-{bars[-1]}")
 
-        for x in range(times):
+        for _ in range(times):
             random.shuffle(bars)
             self.play_bars(bars)
 
-    def do_play(self, arg):
-        name = self.arg1_string()
-        times = self.arg2_valid_repeat()
+    def do_beat_div(self, arg):
+        """Play subdivided beat: beat_div <beat> <divisor> [times]"""
+        args = arg.split()
+        if len(args) < 2:
+            print("usage: beat_div <beat> <divisor> [times]")
+            return
+
+        beat = parse_int(args[0], "beat")
+        divisor = parse_int(args[1], "divisor")
+        if beat is None or divisor is None:
+            return
+
+        times = 1
+        if len(args) > 2:
+            times = parse_int(args[2], "times")
+            if times is None:
+                return
+
+        print(f"[*] {times} x beat {beat}/{divisor}")
+
+        for _ in range(times):
+            self.play_beat(beat, divisor=divisor, silent=True)
+        print()
 
-        if name is None or times is None:
-            return False
+    def do_rest(self, arg):
+        """Insert silence: rest <beats> [times]"""
+        args = arg.split()
+        if not args:
+            print("usage: rest <beats> [times]")
+            return
 
-        self.play_macro(name, times)
+        rest_beats = parse_float(args[0], "beats")
+        if rest_beats is None:
+            return
 
-    def args_valid_value(self):
-        try:
-            args = " ".join(self.cmd_args[1:])
-        except:
-            print("this cmd requires the value to assign")
-            return None
-        return args
+        times = 1
+        if len(args) > 1:
+            times = parse_int(args[1], "times")
+            if times is None:
+                return
+
+        print(f"[*] {times} x rest({rest_beats})")
+
+        for _ in range(times):
+            self.rest(rest_beats)
 
     def do_def(self, arg):
-        name = self.arg1_string()
-        value = self.args_valid_value()
+        """Define a macro: def <name> <command>"""
+        args = arg.split(None, 1)  # Split into name and rest
+        if len(args) < 2:
+            print("usage: def <name> <command>")
+            return
 
-        if name is None or value is None:
-            return False
+        name = args[0]
+        value = args[1]
 
-        print("[*] (def seg: %s = %s)" % (name, value))
+        # Strip inline comments
+        if "#" in value:
+            value = value.split("#")[0].strip()
 
         self.define_macro(name, value)
-        print("defined %s => %s" % (name, value))
+        print(f"defined {name} => {value}")
 
-    def do_help(self, arg):
-        print("valid commands are:")
-        print("  beats, bars, beats_shuf, bars_shuf, beat_div, bars_rev, rest")
-        print("  for predefined macros: ls, lsdef, play, or just type the def name")
-        print("  and finally: save, help, quit")
+    def do_play(self, arg):
+        """Play a macro: play <name> [times]"""
+        args = arg.split()
+        if not args:
+            print("usage: play <name> [times]")
+            return
+
+        name = args[0]
+        times = 1
+        if len(args) > 1:
+            times = parse_int(args[1], "times")
+            if times is None:
+                return
+
+        self.play_macro(name, times)
+
+    def do_ls(self, arg):
+        """List defined macros"""
+        if self.macros:
+            print(", ".join(self.macros.keys()))
+        else:
+            print("(no macros defined)")
 
     def do_lsdef(self, arg):
+        """List macros with their definitions"""
+        if not self.macros:
+            print("(no macros defined)")
+            return
         for name, value in self.macros.items():
-            print("%15s %15s" % (name, value))
+            print(f"  {name}: {value}")
 
-    def do_ls(self, arg):
-        print(", ".join(list(self.macros.keys())))
+    def do_save(self, arg):
+        """Save current session to a .br file: save <filename>"""
+        if not arg.strip():
+            print("usage: save <filename>")
+            return
 
-    def do_quit(self, arg):
-        self.shutdown()
-        sys.exit(0)
+        filename = arg.strip()
 
-    def do_file(self, arg):
-        filename = self.arg1_string()
+        if not self.sourcefile:
+            print("error: no audio file loaded")
+            return
 
-        if filename is None:
-            return False
+        print(f"saving to {filename}")
+        with open(filename, "w") as f:
+            f.write(f"file {self.sourcefile}\n")
+            f.write(f"beats_bar {self.beatsperbar} {self.downbeat}\n")
+            for name, value in self.macros.items():
+                f.write(f"def {name} {value}\n")
+        print("saved")
 
-        print("setting filename to %s" % filename)
-        self.setfile(filename)
+    def do_load(self, arg):
+        """Load a .br or .bri file: load <filename>"""
+        if not arg.strip():
+            print("usage: load <filename>")
+            return
 
-    def do_beats_bar(self, arg):
-        per = self.arg1_int()
-        first = self.arg2_int()
+        filename = arg.strip()
+        self.load_recipe_file(filename)
 
-        if per is None or first is None:
+    def load_recipe_file(self, filename):
+        """Load and execute commands from a .br or .bri file."""
+        try:
+            with open(filename, "r") as f:
+                lines = f.readlines()
+        except FileNotFoundError:
+            print(f"error: file not found: {filename}")
+            return False
+        except Exception as e:
+            print(f"error reading {filename}: {e}")
             return False
 
-        # if we know our audio source, load it, analyze it, and init outputs
+        print(f"loading {filename}...")
+        for line in lines:
+            line = line.strip()
+            # Skip empty lines and comments
+            if not line or line.startswith("#"):
+                continue
+            # Strip inline comments (but not inside the def command - that's handled separately)
+            # Execute the command
+            self.onecmd(line)
+
+        print(f"loaded {filename}")
         if self.sourcefile:
-            print("One moment as we track your beats for you, madame...")
-            self.track_beats(beatsper=per, firstfull=first)
-            print("%d beats, %d bars" % (self.total_beats, self.total_bars))
-            self.init_outputs()
-        else:
-            print("specify file before beats_bar")
-            return False
+            print(f"  audio: {self.sourcefile}")
+        if self.total_beats:
+            print(f"  {self.total_beats} beats, {self.total_bars} bars")
+        if self.macros:
+            print(f"  {len(self.macros)} macros defined")
+        return True
 
-    def do_save(self, arg):
-        filename = self.arg1_string()
-        print("saving %s" % filename)
-        with open(filename, "w") as f:
-            print("file %s" % self.sourcefile, file=f)
-            print("beats_bar %d %d" % (self.beatsperbar, self.firstfullbar), file=f)
-            for name, value in self.macros.items():
-                print("def %s %s" % (name, value), file=f)
+    def do_quit(self, arg):
+        """Exit the shell"""
+        print("goodbye")
+        self.shutdown()
+        return True  # Signals cmd.Cmd to exit
 
-    def default(self, line):
-        self.cmd_args = line.split()
-        self.do_play(line)
+    def do_exit(self, arg):
+        """Exit the shell"""
+        return self.do_quit(arg)
+
+    def do_EOF(self, arg):
+        """Handle Ctrl+D"""
+        print()
+        return self.do_quit(arg)
 
+    def default(self, line):
+        """Try to play a macro if command not recognized"""
+        args = line.split()
+        if not args:
+            return
+
+        name = args[0]
+        if name in self.macros:
+            times = 1
+            if len(args) > 1:
+                times = parse_int(args[1], "times")
+                if times is None:
+                    return
+            self.play_macro(name, times)
+        else:
+            print(f"unknown command or macro: '{name}'")
 
-#   def emptyline(self):
-#       print("repeating: %s" % self.prev_cmd)
-#       self.onecmd(self.precmd(self.prev_cmd))
+    def emptyline(self):
+        """Do nothing on empty line (don't repeat last command)"""
+        pass
 
 
 def main():
-    """
-    Main function for rosabeats-shell command-line tool.
-    
-    Usage: rosabeats-shell [audio_file [beats_per_bar first_full_bar]]
-    
-    Args:
-        audio_file: Optional audio file to analyze
-        beats_per_bar: Number of beats per bar (if audio_file is provided)
-        first_full_bar: First full bar number (if audio_file is provided)
-    
-    Returns:
-        Exit code (0 for success, non-zero for errors)
-    """
+    """Main entry point for rosabeats-shell."""
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description='Interactive shell for beat manipulation',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog='''
+Examples:
+  rosabeats-shell                           Start empty shell
+  rosabeats-shell song.wav                  Load audio file
+  rosabeats-shell song.wav 8 0              Load with 8 beats/bar, downbeat at 0
+  rosabeats-shell recipe.br                 Load beat recipe file
+  rosabeats-shell --debug song.wav          Enable debug mode
+'''
+    )
+    parser.add_argument('file', nargs='?', metavar='FILE',
+                        help='Audio file (.wav, .ogg) or recipe file (.br, .bri) to load')
+    parser.add_argument('beatsper', nargs='?', type=int, default=8, metavar='BEATSPER',
+                        help='Beats per bar (default: 8)')
+    parser.add_argument('downbeat', nargs='?', type=int, default=0, metavar='DOWNBEAT',
+                        help='Downbeat offset (default: 0)')
+    parser.add_argument('-d', '--debug', action='store_true',
+                        help='Enable debug mode')
+
+    args = parser.parse_args()
+
+    # Set debug mode before creating shell
+    if args.debug:
+        rosabeats.rosabeats.debug = True
+
+    shell = rosabeats_shell()
+    shell.preloop()
+
+    # Handle file argument
+    if args.file:
+        filename = args.file
+
+        # Check if it's a recipe file (.br or .bri) or an audio file
+        if filename.endswith(".br") or filename.endswith(".bri"):
+            shell.load_recipe_file(filename)
+        else:
+            # Treat as audio file
+            shell.onecmd(f"file {filename}")
+            shell.onecmd(f"beats_bar {args.beatsper} {args.downbeat}")
+
     try:
-        load_file = False
+        shell.cmdloop()
+    except KeyboardInterrupt:
+        print("\ninterrupted")
+    finally:
         try:
-            filename = sys.argv[1]
-            beats_bar = " ".join(sys.argv[2:])
-            load_file = True
-            print(f"Audio file: {filename}")
-            print(f"Beats/bar settings: {beats_bar}")
-        except IndexError:
-            # No command line arguments is valid
+            shell.shutdown()
+        except:
             pass
 
-        s = rosabeats_shell()
-        if load_file:
-            s.preloop()
-            s.onecmd(s.precmd(f"file {filename}"))
-            s.onecmd(s.precmd(f"beats_bar {beats_bar}"))
-
-        s.cmdloop()
-        return 0
-    except KeyboardInterrupt:
-        print("\nShutting down...")
-        if 's' in locals() and hasattr(s, 'shutdown'):
-            s.shutdown()
-        return 0
-    except Exception as e:
-        print(f"Error: {str(e)}")
-        return 1
-    finally:
-        # Ensure we clean up resources even if there's an error
-        if 's' in locals() and hasattr(s, 'shutdown'):
-            try:
-                s.shutdown()
-            except:
-                pass
+    return 0
 
 
 if __name__ == "__main__":