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

tests/test_shell.py

@@ -0,0 +1,305 @@
+"""Tests for rosabeats_shell module."""
+
+import pytest
+from io import StringIO
+import sys
+
+from rosabeats.rosabeats_shell import (
+    parse_range,
+    parse_int,
+    parse_float,
+    rosabeats_shell,
+)
+
+
+class TestParseRange:
+    """Tests for parse_range function."""
+
+    def test_single_number(self):
+        """Should parse single number as single-element list."""
+        result = parse_range("5")
+        assert result == [5]
+
+    def test_ascending_range(self):
+        """Should parse ascending range correctly."""
+        result = parse_range("3-7")
+        assert result == [3, 4, 5, 6, 7]
+
+    def test_descending_range(self):
+        """Should parse descending range correctly."""
+        result = parse_range("7-3")
+        assert result == [7, 6, 5, 4, 3]
+
+    def test_same_number_range(self):
+        """Should handle range where start equals end."""
+        result = parse_range("5-5")
+        assert result == [5]
+
+    def test_whitespace_handling(self):
+        """Should handle leading/trailing whitespace."""
+        result = parse_range("  3-5  ")
+        assert result == [3, 4, 5]
+
+    def test_empty_string(self):
+        """Should return None for empty string."""
+        result = parse_range("")
+        assert result is None
+
+    def test_invalid_format(self, capsys):
+        """Should return None and print error for invalid format."""
+        result = parse_range("abc")
+        assert result is None
+        captured = capsys.readouterr()
+        assert "invalid range" in captured.out
+
+    def test_negative_numbers(self):
+        """Should handle negative numbers."""
+        result = parse_range("-3-2")
+        assert result == [-3, -2, -1, 0, 1, 2]
+
+
+class TestParseInt:
+    """Tests for parse_int function."""
+
+    def test_valid_integer(self):
+        """Should parse valid integer string."""
+        assert parse_int("42") == 42
+
+    def test_negative_integer(self):
+        """Should parse negative integer."""
+        assert parse_int("-5") == -5
+
+    def test_whitespace(self):
+        """Should handle whitespace."""
+        assert parse_int("  10  ") == 10
+
+    def test_invalid_integer(self, capsys):
+        """Should return None for invalid integer."""
+        result = parse_int("abc")
+        assert result is None
+        captured = capsys.readouterr()
+        assert "must be an integer" in captured.out
+
+    def test_float_string(self, capsys):
+        """Should return None for float string."""
+        result = parse_int("3.14")
+        assert result is None
+
+    def test_custom_name(self, capsys):
+        """Should use custom name in error message."""
+        parse_int("abc", "beat_count")
+        captured = capsys.readouterr()
+        assert "beat_count must be an integer" in captured.out
+
+
+class TestParseFloat:
+    """Tests for parse_float function."""
+
+    def test_valid_float(self):
+        """Should parse valid float string."""
+        assert parse_float("3.14") == pytest.approx(3.14)
+
+    def test_integer_as_float(self):
+        """Should parse integer string as float."""
+        assert parse_float("42") == 42.0
+
+    def test_negative_float(self):
+        """Should parse negative float."""
+        assert parse_float("-2.5") == -2.5
+
+    def test_whitespace(self):
+        """Should handle whitespace."""
+        assert parse_float("  1.5  ") == 1.5
+
+    def test_invalid_float(self, capsys):
+        """Should return None for invalid float."""
+        result = parse_float("abc")
+        assert result is None
+        captured = capsys.readouterr()
+        assert "must be a number" in captured.out
+
+
+class TestRosabeatsShell:
+    """Tests for rosabeats_shell class."""
+
+    @pytest.fixture
+    def shell(self):
+        """Create a shell instance for testing."""
+        s = rosabeats_shell()
+        # Don't enable audio output for tests
+        s.output_play = False
+        s.output_save = False
+        s.output_beats = False
+        return s
+
+    def test_init(self, shell):
+        """Shell should initialize with empty macros."""
+        assert shell.macros == {}
+
+    def test_define_macro(self, shell):
+        """Should define a macro."""
+        shell.define_macro("test", "beats 0-7")
+        assert "test" in shell.macros
+        assert shell.macros["test"] == "beats 0-7"
+
+    def test_redefine_macro(self, shell, capsys):
+        """Should allow redefining a macro."""
+        shell.define_macro("test", "beats 0-7")
+        shell.define_macro("test", "bars 0-3")
+        assert shell.macros["test"] == "bars 0-3"
+        captured = capsys.readouterr()
+        assert "redefining" in captured.out
+
+    def test_do_def_basic(self, shell, capsys):
+        """do_def should define a macro from command."""
+        shell.do_def("intro beats 0-15")
+        assert "intro" in shell.macros
+        assert shell.macros["intro"] == "beats 0-15"
+
+    def test_do_def_strips_comments(self, shell):
+        """do_def should strip inline comments."""
+        shell.do_def("intro beats 0-15  # this is the intro")
+        assert shell.macros["intro"] == "beats 0-15"
+
+    def test_do_def_missing_args(self, shell, capsys):
+        """do_def should show usage if missing arguments."""
+        shell.do_def("onlyname")
+        captured = capsys.readouterr()
+        assert "usage:" in captured.out
+
+    def test_do_ls_empty(self, shell, capsys):
+        """do_ls should show message when no macros defined."""
+        shell.do_ls("")
+        captured = capsys.readouterr()
+        assert "no macros defined" in captured.out
+
+    def test_do_ls_with_macros(self, shell, capsys):
+        """do_ls should list macro names."""
+        shell.define_macro("intro", "beats 0-7")
+        shell.define_macro("verse", "bars 0-3")
+        shell.do_ls("")
+        captured = capsys.readouterr()
+        assert "intro" in captured.out
+        assert "verse" in captured.out
+
+    def test_do_lsdef_shows_definitions(self, shell, capsys):
+        """do_lsdef should show macro names and definitions."""
+        shell.define_macro("intro", "beats 0-7")
+        shell.do_lsdef("")
+        captured = capsys.readouterr()
+        assert "intro" in captured.out
+        assert "beats 0-7" in captured.out
+
+    def test_do_file_sets_sourcefile(self, shell, temp_audio_file):
+        """do_file should set the source file."""
+        shell.do_file(temp_audio_file)
+        assert shell.sourcefile is not None
+        assert temp_audio_file in shell.sourcefile
+
+    def test_do_file_missing_arg(self, shell, capsys):
+        """do_file should show usage if no argument."""
+        shell.do_file("")
+        captured = capsys.readouterr()
+        assert "usage:" in captured.out
+
+    def test_do_beats_bar_missing_file(self, shell, capsys):
+        """do_beats_bar should error if no file loaded."""
+        shell.do_beats_bar("4 0")
+        captured = capsys.readouterr()
+        assert "load a file first" in captured.out
+
+    def test_do_quit_returns_true(self, shell):
+        """do_quit should return True to exit cmdloop."""
+        # Mock shutdown to avoid errors
+        shell.shutdown = lambda: None
+        result = shell.do_quit("")
+        assert result is True
+
+    def test_default_unknown_command(self, shell, capsys):
+        """default should print error for unknown command."""
+        shell.default("unknowncommand")
+        captured = capsys.readouterr()
+        assert "unknown command or macro" in captured.out
+
+    def test_default_plays_macro(self, shell, capsys):
+        """default should play a macro if name matches."""
+        shell.define_macro("test", "ls")  # ls is a safe command
+        shell.default("test")
+        captured = capsys.readouterr()
+        # Should attempt to play the macro
+        assert "test" in captured.out
+
+    def test_emptyline_does_nothing(self, shell, capsys):
+        """emptyline should not produce output or execute anything."""
+        shell.emptyline()
+        captured = capsys.readouterr()
+        assert captured.out == ""
+
+
+class TestShellLoadRecipeFile:
+    """Tests for load_recipe_file functionality."""
+
+    @pytest.fixture
+    def shell(self):
+        """Create a shell instance for testing."""
+        s = rosabeats_shell()
+        s.output_play = False
+        s.output_save = False
+        s.output_beats = False
+        return s
+
+    def test_load_recipe_file_defines_macros(self, shell, tmp_path, sample_bri_content):
+        """load_recipe_file should define macros from file."""
+        filepath = tmp_path / "test.bri"
+        filepath.write_text(sample_bri_content)
+
+        # Mock setfile to avoid actual file loading
+        shell.setfile = lambda x: setattr(shell, 'sourcefile', x)
+        # Mock track_beats
+        shell.track_beats = lambda **kwargs: None
+        shell.total_beats = 100
+        shell.total_bars = 24
+        shell.beatsperbar = 4
+        shell.downbeat = 0
+        shell.init_outputs = lambda: None
+
+        shell.load_recipe_file(str(filepath))
+
+        # Check that macros were defined
+        assert "A" in shell.macros
+        assert "B" in shell.macros
+        assert "A2" in shell.macros
+        assert "A_beats" in shell.macros
+
+    def test_load_recipe_file_strips_comments(self, shell, tmp_path):
+        """load_recipe_file should handle inline comments in defs."""
+        content = """def test beats 0-7	# inline comment
+"""
+        filepath = tmp_path / "test.br"
+        filepath.write_text(content)
+
+        shell.load_recipe_file(str(filepath))
+
+        assert "test" in shell.macros
+        assert shell.macros["test"] == "beats 0-7"
+
+    def test_load_recipe_file_not_found(self, shell, capsys):
+        """load_recipe_file should handle missing file gracefully."""
+        result = shell.load_recipe_file("/nonexistent/path.bri")
+        assert result is False
+        captured = capsys.readouterr()
+        assert "not found" in captured.out
+
+    def test_load_recipe_file_skips_comments(self, shell, tmp_path):
+        """load_recipe_file should skip comment lines."""
+        content = """# This is a comment
+def test beats 0-7
+# Another comment
+"""
+        filepath = tmp_path / "test.br"
+        filepath.write_text(content)
+
+        shell.load_recipe_file(str(filepath))
+
+        assert "test" in shell.macros
+        assert len(shell.macros) == 1  # Only one macro defined

docs/beatrecipe_docs.txt

@@ -1,80 +0,0 @@
-every beat recipe must contain these two lines, at the top:
-            file <filename.wav>
-            beats_bar # #
-
-the two arguments to beats_bar specify the number of beats pe bar, and the absolute beat
-number in the file that starts the first bar (this is often 0, first beat = first bar,
-but is also often not, depending on track and file characteristics; using control_beats.py
-to experiment is best way to discover if this should be non-zero for a given track)
-
-These two lines are necessary to specify source and in order to calculate where bars are
-in the file. After them, everything else is optional and can occur as many or few times as
-you like, in any order
-
-            beats #
-            bars #
-            beats #-#
-            bars #-#
-
-These are the simplest. You can play one or more beats, or one or more bars, by specifying
-the beats or bars you wish to play. All of these are valid syntax:
-
-            beats 3
-            beats 3-3
-            beats 3-8
-            beats 8-3
-            bars 4
-            bars 4-4
-            bars 4-12
-            bars 12-4
-
-If the first and last  # specified are the same, it will be like specifying a single
-beat/bar. If the first # specified is greater than the last, the beats/bars will be
-played in reverse order, i.e. bars 4-1 will play bar 4, bar 3, bar 2, then bar 1.
-
-            rest #
-
-Will insert silence. The argument specifies number of beats of silence. "rest 1" will
-insert 1 beat of silence. Argument is floating point, so you can add fractional beats
-of silence, e.g. "rest 0.5" will add half a beat of silence.
-
-            beats_shuf #
-            beats_shuf #-#
-            bars_shuf #
-            bars_shuf #-#
-
-These two act much like beats and bars covered previously, except instead of playing
-the specified beats or bars in the sequence specified, they will be randomly shuffled
-before being played. If only a single beat or bar is given after these specifiers,
-it will be the same as using "beats" or "bars" as shuffling a single item will always
-result in the output of that one item (i.e. "bars_shuf 8" is same as "bars 8").
-
-
-            bars_rev #
-            bars_rev #-#
-
-This is like bars, except it will play the beats in the bar in reverse order. That is,
-if "bars 0" played beats 0, 1, 2, 3, 4, 5, 6, and 7, "bars_rev 0" would play beats
-7, 6, 5, 4, 3, 2, 1, and 0.
-
-            beat_div # # #
-This will divide a beat into equal segments and play a certain number of them. The
-first argument is the beat #. The second argument is how many pieces to divide the beat
-into. THe third argument is how many times to play that subdivided beat. For example,
-"beat_div 540 2 2" will play the first half of beat 540 twice; "beat_div 300 3 12"
-will play the first third of beat 300 12 times (this will sound like 4 beats of triplets).
-
-            def name bars #
-            def name bars #-#
-            def name beats #
-            def name beats #-#
-
-This defines a segment that can later be played with the play command (below). Right now
-it can only handle beats and bars specifications (per above) but the plan is to expand it
-to represent any valid command.
-
-            play name
-
-This will play any defined segment defined with "def" (above). If previously you had said
-"def seg1 bars 0-7" later when you say "play seg1" it will actually play bars 0-7.
-1

rosabeats-0.1.3.dist-info/RECORD

@@ -1,16 +0,0 @@
-docs/beatrecipe_docs.txt,sha256=2WOPDt_8Av27vKV5Sq2yYK0PhByJH4nU6JS6rnlD4PM,3355
-rosabeats/__init__.py,sha256=egpPGyTlEcFz8g4Fxlmzx3R2ntFXoVUc0ttzFOyPOFs,841
-rosabeats/beatrecipe_processor.py,sha256=fAMJugNVfYvEza2U3C4s488d9KT4LejvglAlBBTBjJk,16230
-rosabeats/beatswitch.py,sha256=VOO00lHM8TYrPHBL-a0SkJ5jvFtSUq6LpyID3WhZfZ8,8483
-rosabeats/rosabeats.py,sha256=BHYD01biiw3z-vtoGGs9gK-ZURk9velt6Or0_-Qom1c,36264
-rosabeats/rosabeats_shell.py,sha256=Giq1sdHw96TOK86ze5QUfnOuyKsFzddfWP5fTztJt4w,10718
-rosabeats/segment_song.py,sha256=VJ4poSXVfXZGFLkn8HP92M3bCjk-wMxeumBwAh2svec,6703
-rosabeats-0.1.3.dist-info/licenses/LICENSE.md,sha256=aPJeloE50MoONg47hPe8CtvglnNcGO3tsS-S5os4WiA,771
-scripts/reverse_beats_in_bars_rosa.py,sha256=g1fRRTTko7BrDnmGQOhIq_rMsVYQznUwgTolRSXFDpI,1167
-scripts/shuffle_bars_rosa.py,sha256=m3zLkQ8A0tgApeVUni6calh6xwHLwzJlkG_qdbyJ3bU,799
-scripts/shuffle_beats_rosa.py,sha256=USaHpWgv7B8rQKVAOXqoia91FLBYyn1N03dIQOcpyBM,683
-rosabeats-0.1.3.dist-info/METADATA,sha256=L8ztM95XsgvMYKD5Ae-Zevize47RmoHpmkzQzDMIe5U,6987
-rosabeats-0.1.3.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-rosabeats-0.1.3.dist-info/entry_points.txt,sha256=4psFMIAY5kogJyT8RMdFeTpAnRHmZpaFPnlwI3tntuk,208
-rosabeats-0.1.3.dist-info/top_level.txt,sha256=XbOrAF6RZpVfzXdkX9tFRtJFB3RUGXodl7RzoYIfz7A,23
-rosabeats-0.1.3.dist-info/RECORD,,

rosabeats-0.1.3.dist-info/top_level.txt

@@ -1,3 +0,0 @@
-docs
-rosabeats
-scripts

scripts/reverse_beats_in_bars_rosa.py

@@ -1,48 +0,0 @@
-#!/usr/bin/env python
-# shuffle bars in a song with rosabeats
-
-import sys
-
-from rosabeats import rosabeats
-
-if __name__ == "__main__":
-    try:
-        infile = str(sys.argv[1])
-    except:
-        print("must specify input and output file", flush=True)
-        sys.exit(1)
-    try:
-        outfile = str(sys.argv[2])
-    except:
-        print("must specify input and output file", flush=True)
-        sys.exit(1)
-    try:
-        first_bar = int(sys.argv[3])
-    except:
-        first_bar = 0
-    try:
-        beats_per = int(sys.argv[4])
-    except:
-        beats_per = 8
-
-    song = rosabeats(infile, debug=True)
-    song.divide_bars()
-    song.track_beats()
-
-    bar_count = int(song.total_beats / beats_per)
-
-    barlist = [x for x in range(bar_count + 1)]
-
-    song.enable_output_play()
-    song.setup_playback()
-
-    song.enable_output_save(outfile)
-    song.reset_remix()
-
-    song.play_beats([x for x in range(first_bar)])
-    for count, bar in enumerate(barlist):
-        first_b = (count * 8) + first_bar
-        beatlist = [x for x in range(first_b, first_b + beats_per)]
-        beatlist.reverse()
-        song.play_beats(beatlist)
-    song.save_remix()

scripts/shuffle_bars_rosa.py

@@ -1,35 +0,0 @@
-#!/usr/bin/env python
-# shuffle bars in a song with rosabeats
-
-import sys, random
-from rosabeats import rosabeats
-
-if __name__ == "__main__":
-    if len(sys.argv) < 2:
-        print("require one argument that is a file containing music", flush=True)
-        sys.exit(1)
-
-    infile = sys.argv[1]
-    outfile = infile[0:-4] + "_barshuf.wav"
-
-    song = rosabeats(infile, debug=True)
-    song.divide_bars(8, 2)
-    song.track_beats()
-
-    bar_count = int(song.total_beats / 8)
-
-    barlist = [x for x in range(1, bar_count)]
-
-    random.shuffle(barlist)
-
-    song.enable_output_play()
-    song.setup_playback()
-
-    song.enable_output_save(outfile)
-    song.reset_remix()
-
-    song.play_beats([0, 1])
-    song.play_bar(0)
-    song.play_bars(barlist)
-    song.play_bar(bar_count)
-    song.save_remix()

scripts/shuffle_beats_rosa.py

@@ -1,29 +0,0 @@
-#!/usr/bin/env python
-# shuffle beats in a song with rosabeats
-
-import sys, random
-from rosabeats import rosabeats
-
-if __name__ == "__main__":
-    if len(sys.argv) < 2:
-        print("require one argument that is a file containing music", flush=True)
-        sys.exit(1)
-
-    infile = sys.argv[1]
-    outfile = infile[0:-4] + "_shuf.wav"
-
-    song = rosabeats(infile, debug=True)
-    song.divide_bars(8, 2)
-    song.track_beats()
-
-    beatlist = [x for x in range(song.total_beats)]
-    random.shuffle(beatlist)
-
-    song.enable_output_play()
-    song.setup_playback()
-
-    song.enable_output_save(outfile)
-    song.reset_remix()
-
-    song.play_beats(beatlist)
-    song.save_remix()