Merge branch 'release/0.4.4'

Author: roszcz

.github/workflows/ci_tests.yaml

@@ -24,8 +24,7 @@ jobs:
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
-        pip install pytest
-        if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
+        pip install -e .[dev]
     - name: Test with pytest
       run: |
         pytest tests/

README.md

@@ -1,6 +1,44 @@
 # Fortepyan :musical_keyboard:
+
 ![GitHub CI](https://github.com/Nospoko/Fortepyan/actions/workflows/ci_tests.yaml/badge.svg?branch=master) [![Python 3.9](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads) [![PyPI version](https://img.shields.io/pypi/v/fortepyan.svg)](https://pypi.org/project/fortepyan/) [![PyPI download month](https://img.shields.io/pypi/dm/fortepyan.svg)](https://pypi.org/project/fortepyan/)
 
+**fortepyan** is a glorified pandas wrapper for midi files with piano music.
+
+The main class to operate with is `MidiPiece`, which gives you access to the notes dataframe, and some useful utilities:
+
+```python
+from fortepyan import MidiPiece
+
+piece = MidiPiece.from_file("foo.mid")
+
+piece.df
+#        pitch  velocity        start          end  duration
+# 0         52        70     0.000000     0.538542  0.538542
+# 1         52        62     0.660417     0.951562  0.291146
+# 2         57        62    20.769792    21.207812  0.438021
+# 3         67        65    62.172917    62.510937  0.338021
+# 4         69        56    62.179167    62.232292  0.053125
+```
+
+Using with HuggingFace datasets:
+
+
+```python
+from datasets import load_datasets
+
+dataset = load_dataset("epr-labs/maestro-sustain-v2", split="train")
+piece = MidiPiece.from_huggingface(dataset[312])
+piece.source
+# {
+#     'composer': 'Franz Liszt',
+#     'title': 'Dante Sonata',
+#     'split': 'train',
+#     'year': 2009,
+#     'midi_filename': '2009/MIDI-Unprocessed_11_R1_2009_06-09_ORIG_MID--AUDIO_11_R1_2009_11_R1_2009_09_WAV.midi',
+#     'dataset': 'maestro'
+# }
+```
+
 ### Usage
 
 ```python
@@ -12,6 +50,8 @@ ff.view.draw_pianoroll_with_velocities(piece)
 ff.view.make_piano_roll_video(piece, "tmp.mp4")
 ```
 
+## Contributing
+
 ### Development
 
 Pre-commit hooks with forced python formatting ([black](https://github.com/psf/black), [flake8](https://flake8.pycqa.org/en/latest/), and [isort](https://pycqa.github.io/isort/)):

fortepyan/__init__.py

@@ -4,7 +4,7 @@
 from fortepyan.midi.structures import MidiFile, MidiPiece
 
 __all__ = ["view", "MidiFile", "MidiPiece"]
-__version__ = "0.4.3"
+__version__ = "0.4.4"
 
 # Pretty MIDI will throw an unwanted error for large files with high PPQ
 # This is a workaround

fortepyan/midi/structures.py

@@ -64,14 +64,22 @@ def __post_init__(self):
         if not self.source:
             self.source = {
                 "start": 0,
-                "start_time": 0,
                 "finish": self.size,
             }
 
     @property
     def size(self) -> int:
         return self.df.shape[0]
 
+    def copy(self) -> "MidiPiece":
+        notes_df = self.df.copy()
+        source = self.source.copy()
+        piece = MidiPiece(
+            df=notes_df,
+            source=source,
+        )
+        return piece
+
     def time_shift(self, shift_s: float) -> "MidiPiece":
         """
         Shift the start and end times of all notes in the MidiPiece by a specified amount.
@@ -109,93 +117,25 @@ def trim(
         self,
         start: float,
         finish: float,
-        shift_time: bool = True,
-        slice_type: str = "standard",
     ) -> "MidiPiece":
-        """
-        Trim a segment of a MIDI piece based on specified start and finish parameters,
-        with options for different slicing types.
-
-        This method modifies the MIDI piece by selecting a segment from it, based on the `start` and `finish` parameters.
-        The segment can be selected through different methods determined by `slice_type`. If `shift_time` is True,
-        the timing of notes in the trimmed segment will be shifted to start from zero.
-
-        Args:
-            start (float | int): The starting point of the segment.
-                It's treated as a float for 'standard' or 'by_end' slicing types, and as an integer
-                for 'index' slicing type.
-            finish (float | int): The ending point of the segment. Similar to `start`, it's treated
-                as a float or an integer depending on the `slice_type`.
-            shift_time (bool, optional): Whether to shift note timings in the trimmed segment
-                to start from zero. Default is True.
-            slice_type (str, optional): The method of slicing. Can be 'standard',
-                'by_end', or 'index'. Default is 'standard'. See note below.
-
-        Returns:
-            MidiPiece: A new `MidiPiece` object representing the trimmed segment of the original MIDI piece.
-
-        Raises:
-            ValueError: If `start` and `finish` are not integers when
-                `slice_type` is 'index', or if `start` is larger than `finish`.
-            IndexError: If the indices are out of bounds for 'index' slicing type,
-                or if no notes are found in the specified range for other types.
-            NotImplementedError: If the `slice_type` provided is not implemented.
-
-        Examples:
-            Trimming using standard slicing:
-            >>> midi_piece.trim(start=1.0, finish=5.0)
-
-            Trimming using index slicing:
-            >>> midi_piece.trim(start=0, finish=10, slice_type="index")
+        ids = (self.df.start >= start) & (self.df.start <= finish)
 
-            Trimming with time shift disabled:
-            >>> midi_piece.trim(start=1.0, finish=5.0, shift_time=False)
+        idx = np.where(ids)[0]
+        if len(idx) == 0:
+            raise IndexError("No notes found in the specified range.")
 
-            An example of a trimmed MIDI piece:
-            ![Trimmed MIDI piece](../assets/random_midi_piece.png)
-
-        Slice types:
-            The `slice_type` parameter determines how the start and finish parameters are interpreted.
-            It can be one of the following:
-
-                'standard': Trims notes that start outside the [start, finish] range.
-
-                'by_end': Trims notes that end after the finish parameter.
-
-                'index': Trims notes based on their index in the DataFrame.
-                    The start and finish parameters are treated as integers
-
-        """
-        if slice_type == "index":
-            if not isinstance(start, int) or not isinstance(finish, int):
-                raise ValueError("Using 'index' slice_type requires 'start' and 'finish' to be integers.")
-            if start < 0 or finish >= self.size:
-                raise IndexError("Index out of bounds.")
-            if start > finish:
-                raise ValueError("'start' must be smaller than 'finish'.")
-            start_idx = start
-            finish_idx = finish + 1
-        else:
-            if slice_type == "by_end":
-                ids = (self.df.start >= start) & (self.df.end <= finish)
-            elif slice_type == "standard":  # Standard slice type
-                ids = (self.df.start >= start) & (self.df.start <= finish)
-            else:
-                # not implemented
-                raise NotImplementedError(f"Slice type '{slice_type}' is not implemented.")
-
-            idx = np.where(ids)[0]
-            if len(idx) == 0:
-                raise IndexError("No notes found in the specified range.")
-
-            start_idx = idx[0]
-            finish_idx = idx[-1] + 1
+        start_idx = idx[0]
+        finish_idx = idx[-1] + 1
 
         slice_obj = slice(start_idx, finish_idx)
 
-        out = self.__getitem__(slice_obj, shift_time)
+        out_piece = self.__getitem__(slice_obj)
 
-        return out
+        # Let the user see the start:finish window as the new 0:duration view
+        out_piece.df.start -= start
+        out_piece.df.end -= start
+
+        return out_piece
 
     def __sanitize_get_index(self, index: slice) -> slice:
         """
@@ -237,19 +177,16 @@ def __sanitize_get_index(self, index: slice) -> slice:
 
         return index
 
-    def __getitem__(self, index: slice, shift_time: bool = True) -> "MidiPiece":
+    def __getitem__(self, index: slice) -> "MidiPiece":
         """
         Get a slice of the MIDI piece, optionally shifting the time of notes.
 
         This method returns a segment of the MIDI piece based on the provided index. It sanitizes the index using the
-        `__sanitize_get_index` method. If `shift_time` is True, it shifts the start and end times of the notes in the
-        segment so that the first note starts at time 0. The method also keeps track of the original piece's information
+        `__sanitize_get_index` method. The method also keeps track of the original piece's information
         in the sliced piece's source data.
 
         Args:
             index (slice): The slicing index to select a part of the MIDI piece. It must be a slice object.
-            shift_time (bool, optional): If True, shifts the start and end times of notes so the first note starts at 0.
-                                    Default is True.
 
         Returns:
             MidiPiece: A new `MidiPiece` object representing the sliced segment of the original MIDI piece.
@@ -261,34 +198,18 @@ def __getitem__(self, index: slice, shift_time: bool = True) -> "MidiPiece":
             Getting a slice from the MIDI file with time shift:
                 >>> midi_piece[0:10]
 
-            Getting a slice without time shift:
-                >>> midi_piece[5:15, shift_time=False]
-
         Note:
             The `__getitem__` method is a special method in Python used for indexing or slicing objects. In this class,
         it is used to get a slice of a MIDI piece.
         """
         index = self.__sanitize_get_index(index)
-        part = self.df[index].reset_index(drop=True)
-
-        if shift_time:
-            # Shift the start and end times so that the first note starts at 0
-            first_sound = part.start.min()
-            part.start -= first_sound
-            part.end -= first_sound
-
-            # Adjust the source to reflect the new start time
-            start_time_adjustment = first_sound
-        else:
-            # No adjustment to the start time
-            start_time_adjustment = 0
+        part_df = self.df[index].reset_index(drop=True)
 
         # Make sure the piece can always be tracked back to the original file exactly
         out_source = dict(self.source)
-        out_source["start"] = self.source.get("start", 0) + index.start
-        out_source["finish"] = self.source.get("start", 0) + index.stop
-        out_source["start_time"] = self.source.get("start_time", 0) + start_time_adjustment
-        out = MidiPiece(df=part, source=out_source)
+        out_source["start"] = self.source.get("start", 0) + int(index.start)
+        out_source["finish"] = self.source.get("start", 0) + int(index.stop)
+        out = MidiPiece(df=part_df, source=out_source)
 
         return out
 

fortepyan/view/pianoroll/main.py

@@ -88,8 +88,9 @@ def sanitize_midi_piece(piece: MidiPiece) -> MidiPiece:
             lineno=88,
         )
         piece = piece.trim(
-            start=0, finish=duration_threshold, slice_type="by_end", shift_time=False
-        )  # Added "by_end" to make sure a very long note doesn't cause an error
+            start=0,
+            finish=duration_threshold,
+        )
 
     return piece
 

pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "fortepyan"
-version = "0.4.3"
+version = "0.4.4"
 description = "Process MIDI piano with (almost) no pain"
 readme = "README.md"
 authors = [{ name = "Piano For AI", email = "roszcz+fortepyan@gmail.com" }]
@@ -34,9 +34,15 @@ requires-python = ">=3.9"
 [project.optional-dependencies]
 dev = [
   "pre-commit ~= 3.8.0",
+  "pytest == 7.4.3",
   "pytest-watch == 4.2.0",
   "streamlit-pianoroll == 0.7.1"
 ]
+test = [
+  "pytest ~= 8.0.0",
+  "pytest-watch == 4.2.0"
+]
+
 
 [project.urls]
 Homepage = "https://github.com/Nospoko/fortepyan"
@@ -53,7 +59,7 @@ packages = [
 ]
 
 [tool.bumpver]
-current_version = "0.4.3"
+current_version = "0.4.4"
 version_pattern = "MAJOR.MINOR.PATCH"
 commit_message = "bump version {old_version} -> {new_version}"
 commit = false

tests/midi/test_structures.py

@@ -86,54 +86,6 @@ def test_midi_piece_duration_calculation(sample_df):
     assert piece.duration == 5.5
 
 
-def test_trim_within_bounds_with_shift(sample_midi_piece):
-    # Test currently works as in the original code.
-    # We might want to change this behavior so that
-    # we do not treat the trimed piece as a new piece
-    trimmed_piece = sample_midi_piece.trim(2, 3)
-    assert len(trimmed_piece.df) == 2, "Trimmed MidiPiece should contain 2 notes."
-    assert trimmed_piece.df["start"].iloc[0] == 0, "New first note should start at 0 seconds."
-    assert trimmed_piece.df["pitch"].iloc[0] == 64, "New first note should have pitch 64."
-    assert trimmed_piece.df["end"].iloc[-1] == 2, "New last note should end at 2 seconds."
-
-
-def test_trim_index_slice_type(sample_midi_piece):
-    trimmed_piece = sample_midi_piece.trim(1, 3, slice_type="index")
-    assert len(trimmed_piece) == 3, "Trimmed MidiPiece should contain 3 notes."
-    assert trimmed_piece.df["start"].iloc[0] == 0, "New first note should start at 0 seconds."
-    assert trimmed_piece.df["pitch"].iloc[0] == 62, "New first note should have pitch 62."
-    assert trimmed_piece.df["end"].iloc[-1] == 3, "New last note should end at 3 seconds."
-
-
-def test_trim_by_end_slice_type(sample_midi_piece):
-    trimmed_piece = sample_midi_piece.trim(1, 5, slice_type="by_end")
-    assert len(trimmed_piece.df) == 3, "Trimmed MidiPiece should contain 3 notes."
-    assert trimmed_piece.df["start"].iloc[0] == 0, "New first note should start at 0 seconds."
-    assert trimmed_piece.df["pitch"].iloc[0] == 62, "New first note should have pitch 62."
-    assert trimmed_piece.df["end"].iloc[-1] == 3, "New last note should end at 2 seconds."
-    assert trimmed_piece.df["pitch"].iloc[-1] == 65, "New last note should have pitch 65."
-
-
-def test_trim_with_invalid_slice_type(sample_midi_piece):
-    with pytest.raises(NotImplementedError):
-        _ = sample_midi_piece.trim(1, 3, slice_type="invalid")  # Invalid slice type, should raise an error
-
-
-def test_trim_within_bounds_no_shift(sample_midi_piece):
-    # This test should not shift the start times
-    trimmed_piece = sample_midi_piece.trim(2, 3, shift_time=False)
-    assert len(trimmed_piece.df) == 2, "Trimmed MidiPiece should contain 2 notes."
-    # Since we're not shifting, the start should not be 0 but the actual start time
-    assert trimmed_piece.df["start"].iloc[0] == 2, "First note should retain its original start time."
-    assert trimmed_piece.df["pitch"].iloc[0] == 64, "First note should have pitch 64."
-    assert trimmed_piece.df["end"].iloc[-1] == 4, "Last note should end at 4 seconds."
-
-
-def test_trim_at_boundaries(sample_midi_piece):
-    trimmed_piece = sample_midi_piece.trim(0, 5.5)
-    assert trimmed_piece.size == sample_midi_piece.size, "Trimming at boundaries should not change the size."
-
-
 def test_trim_out_of_bounds(sample_midi_piece):
     with pytest.raises(IndexError):
         _ = sample_midi_piece.trim(5.5, 8)  # Out of bounds, should raise an error
@@ -145,11 +97,6 @@ def test_trim_with_invalid_range(sample_midi_piece):
         _ = sample_midi_piece.trim(4, 2)  # Invalid range, start is greater than finish
 
 
-def test_source_update_after_trimming(sample_midi_piece):
-    trimmed_piece = sample_midi_piece.trim(1, 3)
-    assert trimmed_piece.source["start_time"] == 1, "Source start_time should be updated to reflect trimming."
-
-
 def test_to_midi(sample_midi_piece):
     # Create the MIDI track
     midi_file = sample_midi_piece.to_midi()