partitura 1.3.0__py3-none-any.whl → 1.4.0__py3-none-any.whl

partitura/musicanalysis/voice_separation.py

@@ -124,16 +124,14 @@ def estimate_voices(note_info, monophonic_voices=True):
     #     grace_by_key[i].append(
 
     if monophonic_voices:
-
         # identity mapping
         idx_equivs = dict((n, n) for n in notearray["id"])
         input_array = notearray
 
     else:
-
         note_by_key = defaultdict(list)
 
-        for (pitch, onset, dur, i) in notearray:
+        for pitch, onset, dur, i in notearray:
             note_by_key[(onset, dur)].append(i)
 
         # dict that maps first chord note index to the list of all note indices
@@ -270,7 +268,6 @@ def est_best_connections(cost, mode="prev"):
 
     # while there are fewer than n_assignments
     while len(best_assignment) < n_assignments:
-
         # Get the remaining minimal cost
         next_best = mcost.min(1).argmin()
         next_assig = mcost.argmin(1)[next_best]
@@ -367,7 +364,6 @@ class VSNote(object):
     """
 
     def __init__(self, pitch, onset, duration, note_id, velocity=None, voice=None):
-
         # ID of the note
         self.id = note_id
         self.pitch = pitch
@@ -423,7 +419,6 @@ class VSChord(object):
     """
 
     def __init__(self, notes, rep_note="highest"):
-
         if any([n.onset != notes[0].onset for n in notes]):
             raise ValueError("All notes in the chord must have the same onset")
         if any([n.offset != notes[0].offset for n in notes]):
@@ -470,7 +465,6 @@ class Voice(object):
     """
 
     def __init__(self, stream_or_streams, voice=None):
-
         if isinstance(stream_or_streams, list):
             self.streams = stream_or_streams
         elif isinstance(stream_or_streams, NoteStream):
@@ -485,7 +479,6 @@ class Voice(object):
             self.notes = []
 
     def _setup_voice(self):
-
         # sort stream by onset
         self.streams.sort(key=lambda x: x.onset)
 
@@ -549,7 +542,6 @@ class VoiceManager(object):
     """
 
     def __init__(self, num_voices):
-
         self.num_voices = num_voices
 
         self.voices = [Voice([], voice) for voice in range(self.num_voices)]
@@ -578,7 +570,6 @@ class VSBaseScore(object):
     """
 
     def __init__(self, notes):
-
         # Set list of notes
         self.notes = notes
 
@@ -679,7 +670,6 @@ class VSBaseScore(object):
 
 class NoteStream(VSBaseScore):
     def __init__(self, notes=[], voice="auto", prev_stream=None, next_stream=None):
-
         super(NoteStream, self).__init__(notes)
         self._voice = voice
         self.prev_stream = prev_stream
@@ -738,7 +728,6 @@ class NoteStream(VSBaseScore):
 
 class Contig(VSBaseScore):
     def __init__(self, notes, is_maxcontig=False):
-
         super(Contig, self).__init__(notes)
         self._is_maxcontig = is_maxcontig
         # Onset time of the contig
@@ -758,7 +747,6 @@ class Contig(VSBaseScore):
 
         for on in self.unique_onsets[np.where(self.unique_onsets >= self.onset)[0]]:
             for i, note in enumerate(self.sounding_notes(on)):
-
                 if note not in streams[i]:
                     streams[i].append(note)
 
@@ -808,7 +796,6 @@ class VoSA(VSBaseScore):
     """
 
     def __init__(self, score, delete_gracenotes=False):
-
         # Score
         self.score = score
 
@@ -847,7 +834,6 @@ class VoSA(VSBaseScore):
         self.notes = []
 
         for n in self.score:
-
             note = VSNote(
                 pitch=n["pitch"],
                 onset=n["onset"],
@@ -910,7 +896,6 @@ class VoSA(VSBaseScore):
         )
 
     def make_contigs(self):
-
         # number of voices at each time point in the score
         n_voices = np.array([len(sn) for sn in self])
 
@@ -935,7 +920,6 @@ class VoSA(VSBaseScore):
 
         # Look for voice status changes
         for i, sn in enumerate(self):
-
             # an array of booleans that indicate whether each currently sounding note
             # was sounding in the previous time point (segment)
             note_sounding_in_prev_segment = np.array([n in self[i - 1] for n in sn])
@@ -944,13 +928,11 @@ class VoSA(VSBaseScore):
             # * there are sounding notes in the previous segment; and
             # * there is a change in number of voices in the current segment
             if any(note_sounding_in_prev_segment) and n_voice_changes[i] != 0:
-
                 # indices of the sounding notes belonging to the previous time point
                 prev_sounding_note_idxs = np.where(note_sounding_in_prev_segment)[0]
 
                 # Update segment boundaries
                 for psnix in prev_sounding_note_idxs:
-
                     # get sounding note
                     prev_sounding_note = sn[psnix]
                     # Get index of the timepoint of the onset of the prev_sounding_note
@@ -968,7 +950,6 @@ class VoSA(VSBaseScore):
 
         # iterate over timepoints, sounding notes and segment boundaries
         for tp, sn, sb, nv in zip(self.utp, self, segment_boundaries, n_voices):
-
             # If there is a segment boundary and there are sounding notes
             # (i.e. do not make empty contigs)
             if sb and len(sn) > 0:
@@ -1026,7 +1007,6 @@ class VoSA(VSBaseScore):
         while keep_loop:
             # Cristalization process around the maximal contigs
             for mci in maximal_contigs_idxs:
-
                 # Get voice manager corresponding to the current
                 # maximal contig
                 vm = voice_managers_dict[mci]
@@ -1063,7 +1043,6 @@ class VoSA(VSBaseScore):
                         # been assigned (assigne voice wrt the closest
                         # maximal contig)
                         if not next_contig.has_voice_info:
-
                             # flag voices without a connection in
                             # the previous step in the loop
                             for es in f_unassigned:

partitura/performance.py

@@ -85,7 +85,11 @@ class PerformedPart(object):
         super().__init__()
         self.id = id
         self.part_name = part_name
-        self.notes = notes
+        self.notes = list(
+            map(
+                lambda n: n if isinstance(n, PerformedNote) else PerformedNote(n), notes
+            )
+        )
         self.controls = controls or []
         self.programs = programs or []
         self.ppq = ppq
@@ -203,7 +207,11 @@ class PerformedPart(object):
         if "id" not in note_array.dtype.names:
             n_ids = ["n{0}".format(i) for i in range(len(note_array))]
         else:
-            n_ids = note_array["id"]
+            # Check if all ids are the same
+            if np.all(note_array["id"] == note_array["id"][0]):
+                n_ids = ["n{0}".format(i) for i in range(len(note_array))]
+            else:
+                n_ids = note_array["id"]
 
         if "track" not in note_array.dtype.names:
             tracks = np.zeros(len(note_array), dtype=int)
@@ -280,6 +288,174 @@ def adjust_offsets_w_sustain(
         note["sound_off"] = offset
 
 
+class PerformedNote:
+    """
+    A dictionary-like object representing a performed note.
+
+    Parameters
+    ----------
+    pnote_dict : dict
+        A dictionary containing performed note information.
+        This information can contain the following fields:
+        "id", "pitch", "note_on", "note_off", "velocity", "track", "channel", "sound_off".
+        If not provided, the default values will be used.
+        Pitch, note_on, and note_off are required.
+    """
+
+    def __init__(self, pnote_dict):
+        self.pnote_dict = pnote_dict
+        self.pnote_dict["id"] = self.pnote_dict.get("id", None)
+        self.pnote_dict["pitch"] = self.pnote_dict.get("pitch", self["midi_pitch"])
+        self.pnote_dict["note_on"] = self.pnote_dict.get("note_on", -1)
+        self.pnote_dict["note_off"] = self.pnote_dict.get("note_off", -1)
+        self.pnote_dict["sound_off"] = self.pnote_dict.get(
+            "sound_off", self["note_off"]
+        )
+        self.pnote_dict["track"] = self.pnote_dict.get("track", 0)
+        self.pnote_dict["channel"] = self.pnote_dict.get("channel", 1)
+        self.pnote_dict["velocity"] = self.pnote_dict.get("velocity", 60)
+        self._validate_values(pnote_dict)
+        self._accepted_keys = [
+            "id",
+            "pitch",
+            "note_on",
+            "note_off",
+            "velocity",
+            "track",
+            "channel",
+            "sound_off",
+            "note_on_tick",
+            "note_off_tick",
+        ]
+
+    def __str__(self):
+        return f"PerformedNote: {self['id']}"
+
+    def __eq__(self, other):
+        if not isinstance(PerformedNote):
+            return False
+        if not self.keys() == other.keys():
+            return False
+        return np.all(
+            np.array([self[k] == other[k] for k in self.keys() if k in other.keys()])
+        )
+
+    def keys(self):
+        return self.pnote_dict.keys()
+
+    def get(self, key, default=None):
+        return self.pnote_dict.get(key, default)
+
+    def __hash__(self):
+        return hash(self["id"])
+
+    def __lt__(self, other):
+        return self["note_on"] < other["note_on"]
+
+    def __le__(self, other):
+        return self["note_on"] <= other["note_on"]
+
+    def __gt__(self, other):
+        return self["note_on"] > other["note_on"]
+
+    def __ge__(self, other):
+        return self["note_on"] >= other["note_on"]
+
+    def __getitem__(self, key):
+        return self.pnote_dict.get(key, None)
+
+    def __setitem__(self, key, value):
+        if key not in self._accepted_keys:
+            raise KeyError(f"Key {key} not accepted for PerformedNote")
+        self._validate_values((key, value))
+        self.pnote_dict[key] = value
+
+    def __delitem__(self, key):
+        raise KeyError("Cannot delete items from PerformedNote")
+
+    def __iter__(self):
+        return iter(self.keys())
+
+    def __len__(self):
+        return len(self.keys())
+
+    def __contains__(self, key):
+        return key in self.keys()
+
+    def copy(self):
+        return PerformedNote(self.pnote_dict.copy())
+
+    def _validate_values(self, d):
+        if isinstance(d, dict):
+            dd = d
+        elif isinstance(d, tuple):
+            dd = {d[0]: d[1]}
+        else:
+            raise ValueError(f"Invalid value {d} provided for PerformedNote")
+
+        for key, value in dd.items():
+            if key == "pitch":
+                self._validate_pitch(value)
+            elif key == "note_on":
+                self._validate_note_on(value)
+            elif key == "note_off":
+                self._validate_note_off(value)
+            elif key == "velocity":
+                self._validate_velocity(value)
+            elif key == "sound_off":
+                self._validate_sound_off(value)
+            elif key == "note_on_tick":
+                self._validate_note_on_tick(value)
+            elif key == "note_off_tick":
+                self._validate_note_off_tick(value)
+
+    def _validate_sound_off(self, value):
+        if self.get("note_off", -1) < 0:
+            return
+        if value < 0:
+            raise ValueError(f"sound_off must be greater than or equal to 0")
+        if value < self.pnote_dict["note_off"]:
+            raise ValueError(f"sound_off must be greater or equal to note_off")
+
+    def _validate_note_on(self, value):
+        if value < 0:
+            raise ValueError(
+                f"Note on value provided is invalid, must be greater than or equal to 0"
+            )
+
+    def _validate_note_off(self, value):
+        if self.pnote_dict.get("note_on", -1) < 0:
+            return
+        if value < 0 or value < self.pnote_dict["note_on"]:
+            raise ValueError(
+                f"Note off value provided is invalid, "
+                f"must be a positive value greater than or equal to 0 and greater or equal to note_on"
+            )
+
+    def _validate_note_on_tick(self, value):
+        if value < 0:
+            raise ValueError(
+                f"Note on tick value provided is invalid, must be greater than or equal to 0"
+            )
+
+    def _validate_note_off_tick(self, value):
+        if self.pnote_dict.get("note_on_tick", -1) < 0:
+            return
+        if value < 0 or value < self.pnote_dict["note_on_tick"]:
+            raise ValueError(
+                f"Note off tick value provided is invalid, "
+                f"must be a positive value greater than or equal to 0 and greater or equal to note_on_tick"
+            )
+
+    def _validate_pitch(self, value):
+        if value > 127 or value < 0:
+            raise ValueError(f"pitch must be between 0 and 127")
+
+    def _validate_velocity(self, value):
+        if value > 127 or value < 0:
+            raise ValueError(f"velocity must be between 0 and 127")
+
+
 class Performance(object):
     """Main object for representing a performance.
 
@@ -345,7 +521,6 @@ class Performance(object):
         if isinstance(performedparts, PerformedPart):
             self.performedparts = [performedparts]
         elif isinstance(performedparts, Itertype):
-
             if not all([isinstance(pp, PerformedPart) for pp in performedparts]):
                 raise ValueError(
                     "`performedparts` should be a list of  `PerformedPart` objects!"
@@ -416,9 +591,7 @@ class Performance(object):
         track_map = dict([(tid, ti) for ti, tid in enumerate(unique_track_ids)])
 
         for i, ppart in enumerate(self):
-
             for note in ppart.notes:
-
                 note["track"] = track_map[(i, note.get("track", -1))]
 
             for control in ppart.controls: