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

partitura/utils/music.py

@@ -20,13 +20,15 @@ import os
 try:
     import miditok
     from miditok.midi_tokenizer import MIDITokenizer
-    import miditoolkit 
+    import miditoolkit
 except ImportError:
     miditok = None
     miditoolkit = None
+
     class MIDITokenizer(object):
         pass
 
+
 from partitura.utils.misc import deprecated_alias
 
 if TYPE_CHECKING:
@@ -277,13 +279,39 @@ INTERVALCLASSES = [
     for specific in ["dd", "d", "P", "A", "AA"]
 ]
 
-INTERVAL_TO_SEMITONES = dict(zip(INTERVALCLASSES, [
-    generic+specific for generic in [1, 3, 8, 10] for specific in [-2, -1, 0, 1, 2, 3]
-] + [generic+specific for generic in [0, 5, 7] for specific in [-2, -1, 0, 1, 2]]))
-
+INTERVAL_TO_SEMITONES = dict(
+    zip(
+        INTERVALCLASSES,
+        [
+            generic + specific
+            for generic in [1, 3, 8, 10]
+            for specific in [-2, -1, 0, 1, 2, 3]
+        ]
+        + [
+            generic + specific
+            for generic in [0, 5, 7]
+            for specific in [-2, -1, 0, 1, 2]
+        ],
+    )
+)
 
-STEPS = {"C": 0, "D": 1, "E": 2, "F": 3, "G": 4, "A": 5, "B": 6, 0: "C", 1: "D", 2: "E", 3: "F", 4: "G", 5: "A", 6: "B"}
 
+STEPS = {
+    "C": 0,
+    "D": 1,
+    "E": 2,
+    "F": 3,
+    "G": 4,
+    "A": 5,
+    "B": 6,
+    0: "C",
+    1: "D",
+    2: "E",
+    3: "F",
+    4: "G",
+    5: "A",
+    6: "B",
+}
 
 
 MUSICAL_BEATS = {6: 2, 9: 3, 12: 4}
@@ -406,7 +434,7 @@ def transpose_step(step, interval, direction):
     if interval == "P1":
         pass
     else:
-        step = STEPS[op(STEPS[step.capitalize()], interval-1)]
+        step = STEPS[op(STEPS[step.capitalize()], interval - 1)]
     return step
 
 
@@ -419,7 +447,7 @@ def _transpose_note(note, interval):
     inverval
 
     """
-    if interval.quality+str(interval.number) == "P1":
+    if interval.quality + str(interval.number) == "P1":
         pass
     else:
         # TODO work for arbitrary octave.
@@ -438,7 +466,9 @@ def _transpose_note(note, interval):
             diff_sm = tmp_pc - prev_pc if tmp_pc >= prev_pc else tmp_pc + 12 - prev_pc
         else:
             diff_sm = prev_pc - tmp_pc if prev_pc >= tmp_pc else prev_pc + 12 - tmp_pc
-        note.alter = INTERVAL_TO_SEMITONES[interval.quality+str(interval.number)] - diff_sm
+        note.alter = (
+            INTERVAL_TO_SEMITONES[interval.quality + str(interval.number)] - diff_sm
+        )
 
 
 def transpose(score: ScoreLike, interval: Interval) -> ScoreLike:
@@ -458,7 +488,15 @@ def transpose(score: ScoreLike, interval: Interval) -> ScoreLike:
         Transposed score.
     """
     import partitura.score as s
+    import sys
+
+    # Copy needs to be deep, otherwise the recursion limit will be exceeded
+    old_recursion_depth = sys.getrecursionlimit()
+    sys.setrecursionlimit(10000)
+    # Deep copy of score
     new_score = copy.deepcopy(score)
+    # Reset recursion limit to previous value to avoid side effects
+    sys.setrecursionlimit(old_recursion_depth)
     if isinstance(score, s.Score):
         for part in new_score.parts:
             transpose(part, interval)
@@ -655,6 +693,8 @@ def midi_ticks_to_seconds(
 
 SIGN_TO_ALTER = {
     "n": 0,
+    "ns": 1,
+    "nf": -1,
     "#": 1,
     "s": 1,
     "ss": 2,
@@ -671,7 +711,6 @@ SIGN_TO_ALTER = {
 
 
 def ensure_pitch_spelling_format(step, alter, octave):
-
     if step.lower() not in MIDI_BASE_CLASS:
         if step.lower() != "r":
             raise ValueError("Invalid `step`")
@@ -961,14 +1000,12 @@ def format_symbolic_duration(symbolic_dur):
 
     """
     if symbolic_dur is None:
-
         return "unknown"
 
     else:
         result = (symbolic_dur.get("type") or "") + "." * symbolic_dur.get("dots", 0)
 
         if "actual_notes" in symbolic_dur and "normal_notes" in symbolic_dur:
-
             result += "_{}/{}".format(
                 symbolic_dur["actual_notes"], symbolic_dur["normal_notes"]
             )
@@ -1712,7 +1749,6 @@ def match_note_arrays(
     target_note_array = ensure_notearray(target_note_array)
 
     if fields is not None:
-
         if isinstance(fields, (list, tuple)):
             onset_key, duration_key = fields
         elif isinstance(fields, str):
@@ -1861,7 +1897,6 @@ def remove_silence_from_performed_part(ppart):
     for track in control_dict:
         for channel in control_dict[track]:
             for number, ct in control_dict[track][channel].items():
-
                 cta = np.array(ct)
                 cinterp = interp1d(
                     x=cta[:, 0],
@@ -2567,7 +2602,6 @@ def note_array_from_note_list(
 
     note_array = []
     for note in note_list:
-
         note_info = tuple()
         note_on_div = note.start.t
         note_off_div = note.start.t + note.duration_tied
@@ -2762,7 +2796,6 @@ def rest_array_from_rest_list(
 
     rest_array = []
     for rest in rest_list:
-
         rest_info = tuple()
         rest_on_div = rest.start.t
         rest_off_div = rest.start.t + rest.duration_tied
@@ -2875,14 +2908,12 @@ def rec_collapse_rests(rest_array):
 
 
 def update_note_ids_after_unfolding(part):
-
     note_id_dict = defaultdict(list)
 
     for n in part.notes:
         note_id_dict[n.id].append(n)
 
     for nid, notes in note_id_dict.items():
-
         if nid is None:
             continue
 
@@ -2988,9 +3019,7 @@ def performance_notearray_from_score_notearray(
     pnote_array = np.zeros(len(snote_array), dtype=ppart_fields)
 
     if isinstance(velocity, np.ndarray):
-
         if velocity.ndim == 2:
-
             velocity_fun = interp1d(
                 x=velocity[:, 0],
                 y=velocity[:, 1],
@@ -3026,7 +3055,6 @@ def performance_notearray_from_score_notearray(
     iois = np.diff(unique_onsets)
 
     if callable(bpm) or isinstance(bpm, np.ndarray):
-
         if callable(bpm):
             # bpm parameter is a callable that returns a bpm value
             # for each score onset
@@ -3036,7 +3064,6 @@ def performance_notearray_from_score_notearray(
             )
 
         elif isinstance(bpm, np.ndarray):
-
             if bpm.ndim != 2:
                 raise ValueError("`bpm` should be a 2D array")
 
@@ -3209,7 +3236,7 @@ def slice_ppart_by_time(
     ----------
     ppart : `PerformedPart` object
     start_time : float
-        Starting time in seconds 
+        Starting time in seconds
     end_time : float
         End time in seconds
     clip_note_off : bool
@@ -3234,90 +3261,98 @@ def slice_ppart_by_time(
     # create a new (empty) instance of a PerformedPart
     # single dummy note added to be able to set sustain_pedal_threshold in __init__
     # -> check `adjust_offsets_w_sustain` in partitura.performance
-    ppart_slice = PerformedPart([{'note_on': 0, 'note_off': 0}])
+    # ppart_slice = PerformedPart([{"note_on": 0, "note_off": 0, "pitch": 0}])
 
     # get ppq if PerformedPart contains it,
     # else skip time_tick info when e.g. created with 'load_performance_midi'
     try:
         ppq = ppart.ppq
-        ppart_slice.ppq = ppq
     except AttributeError:
         ppq = None
 
+    controls_slice = []
     if ppart.controls:
-        controls_slice = []
         for cc in ppart.controls:
-            if cc['time'] >= start_time and cc['time'] <= end_time:
+            if cc["time"] >= start_time and cc["time"] <= end_time:
                 new_cc = cc.copy()
-                new_cc['time'] -= start_time
+                new_cc["time"] -= start_time
                 if ppq:
-                    new_cc['time_tick'] = int(2 * ppq * cc['time'])
+                    new_cc["time_tick"] = int(2 * ppq * cc["time"])
                 controls_slice.append(new_cc)
-        ppart_slice.controls = controls_slice
-    
+
+    programs_slice = []
     if ppart.programs:
-        programs_slice = []
         for pr in ppart.programs:
-            if pr['time'] >= start_time and pr['time'] <= end_time:
+            if pr["time"] >= start_time and pr["time"] <= end_time:
                 new_pr = pr.copy()
-                new_pr['time'] -= start_time
+                new_pr["time"] -= start_time
                 if ppq:
-                    new_pr['time_tick'] = int(2 * ppq * pr['time'])
+                    new_pr["time_tick"] = int(2 * ppq * pr["time"])
                 programs_slice.append(new_pr)
-        ppart_slice.programs = programs_slice
 
     notes_slice = []
     note_id = 0
-    for note in ppart.notes: 
+    for note in ppart.notes:
         # collect previous sounding notes at start_time
         if note["note_on"] < start_time and note["note_off"] > start_time:
             new_note = note.copy()
-            new_note['note_on'] = 0.
+            new_note["note_on"] = 0.0
             if clip_note_off:
-                new_note['note_off'] = min(note['note_off'] - start_time, end_time - start_time)
-            else: 
-                new_note['note_off'] = note['note_off'] - start_time
+                new_note["note_off"] = min(
+                    note["note_off"] - start_time, end_time - start_time
+                )
+            else:
+                new_note["note_off"] = note["note_off"] - start_time
             if ppq:
-                new_note['note_on_tick'] = 0
-                new_note['note_off_tick'] = int(2 * ppq * new_note['note_off'])
+                new_note["note_on_tick"] = 0
+                new_note["note_off_tick"] = int(2 * ppq * new_note["note_off"])
             if reindex_notes:
-                new_note['id'] = f"n{note_id}"
+                new_note["id"] = f"n{note_id}"
                 note_id += 1
             notes_slice.append(new_note)
         # todo - combine both cases
-        if note['note_on'] >= start_time: 
-            if note['note_on'] < end_time:
+        if note["note_on"] >= start_time:
+            if note["note_on"] < end_time:
                 new_note = note.copy()
-                new_note['note_on'] -= start_time
+                new_note["note_on"] -= start_time
                 if clip_note_off:
-                    new_note['note_off'] = min(note['note_off'] - start_time, end_time - start_time)
-                else: 
-                    new_note['note_off'] = note['note_off'] - start_time
+                    new_note["note_off"] = min(
+                        note["note_off"] - start_time, end_time - start_time
+                    )
+                else:
+                    new_note["note_off"] = note["note_off"] - start_time
                 if ppq:
-                    new_note['note_on_tick'] = int(2 * ppq * new_note['note_on'])
-                    new_note['note_off_tick'] = int(2 * ppq * new_note['note_off'])
+                    new_note["note_on_tick"] = int(2 * ppq * new_note["note_on"])
+                    new_note["note_off_tick"] = int(2 * ppq * new_note["note_off"])
                 if reindex_notes:
-                    new_note['id'] = 'n' + str(note_id)
+                    new_note["id"] = "n" + str(note_id)
                     note_id += 1
                 notes_slice.append(new_note)
-            # assumes notes in list are sorted by onset time   
-            else: 
-                break               
-    
-    ppart_slice.notes = notes_slice
-    
-    # set threshold property after creating notes list to update 'sound_offset' values 
+            # assumes notes in list are sorted by onset time
+            else:
+                break
+
+    # Create slice PerformedPart
+    ppart_slice = PerformedPart(
+        notes=notes_slice, programs=programs_slice, controls=controls_slice, ppq=ppq
+    )
+
+    # set threshold property after creating notes list to update 'sound_offset' values
     ppart_slice.sustain_pedal_threshold = ppart.sustain_pedal_threshold
 
     if ppart.id:
-        ppart_slice.id = ppart.id + '_slice_{}s_to_{}s'.format(start_time, end_time)     
+        ppart_slice.id = ppart.id + "_slice_{}s_to_{}s".format(start_time, end_time)
     if ppart.part_name:
-        ppart_slice.part_name = ppart.part_name 
+        ppart_slice.part_name = ppart.part_name
 
     return ppart_slice
 
 
-def tokenize(score_data : ScoreLike, tokenizer : MIDITokenizer, incomplete_bar_behaviour : str = "pad_bar"):
+def tokenize(
+    score_data: ScoreLike,
+    tokenizer: MIDITokenizer,
+    incomplete_bar_behaviour: str = "pad_bar",
+):
     """
     Tokenize a score using a tokenizer from miditok.
     Parameters
@@ -3340,16 +3375,23 @@ def tokenize(score_data : ScoreLike, tokenizer : MIDITokenizer, incomplete_bar_b
     """
 
     if miditok is None or miditoolkit is None:
-        raise ImportError("Miditok and miditoolkit must be installed for this function to work")
+        raise ImportError(
+            "Miditok and miditoolkit must be installed for this function to work"
+        )
     with TemporaryDirectory() as tmpdir:
         temp_midi_path = os.path.join(tmpdir, "temp_midi.mid")
-        partitura.io.exportmidi.save_score_midi(score_data, out = temp_midi_path, anacrusis_behavior=incomplete_bar_behaviour, part_voice_assign_mode = 4, minimum_ppq = 480 )
+        partitura.io.exportmidi.save_score_midi(
+            score_data,
+            out=temp_midi_path,
+            anacrusis_behavior=incomplete_bar_behaviour,
+            part_voice_assign_mode=4,
+            minimum_ppq=480,
+        )
         midi = miditoolkit.MidiFile(temp_midi_path)
         tokens = tokenizer(midi)
     return tokens
 
 
-
 if __name__ == "__main__":
     import doctest
 

partitura/utils/normalize.py

@@ -6,20 +6,23 @@ This module contains normalization utilities
 import numpy as np
 
 
-EPSILON=0.0001
-
-
-def range_normalize(array, 
-                    min_value = None, 
-                    max_value = None,
-                    log = False,
-                    exp = False,
-                    hard_clip = True):
-    
+EPSILON = 0.0001
+
+
+def range_normalize(
+    array,
+    min_value=None,
+    max_value=None,
+    log=False,
+    log2=False,
+    exp=False,
+    exp2=False,
+    hard_clip=True,
+):
     """
     Linear mapping a vector from range [min_value, max_value] to [0, 1].
     Preprocessing possible with log and exp.
-    Values exceeding the range [0, 1] are clipped to 0 or 1 if 
+    Values exceeding the range [0, 1] are clipped to 0 or 1 if
     clip is True, otherwise they are extrapolated.
     """
     if min_value is None:
@@ -28,8 +31,12 @@ def range_normalize(array,
         max_value = array.max()
     if log:
         array = np.log(np.abs(array) + EPSILON)
+    elif log2:
+        array = np.log2(np.abs(array) + EPSILON)
     if exp:
         array = np.exp(array)
+    elif exp2:
+        array = np.exp2(array)
     # handle div by zero
     if min_value == max_value:
         array = np.clip(array, 0, 1)
@@ -41,17 +48,13 @@ def range_normalize(array,
         return array
 
 
-def zero_one_normalize(array, 
-                    min_value = -3.0, 
-                    max_value = 3.0,
-                    log = False,
-                    exp = False,
-                    clip = True):
-    
+def zero_one_normalize(
+    array, min_value=-3.0, max_value=3.0, log=False, exp=False, clip=True
+):
     """
     Compute zero mean and unit variance of a vector.
     Preprocessing possible with log and exp.
-    Values exceeding the range [-min_value, max_value] 
+    Values exceeding the range [-min_value, max_value]
     are clipped if clip is True.
     """
 
@@ -76,41 +79,75 @@ def minmaxrange_normalize(array):
 
 
 DEFAULT_NORM_FUNCS = {
-    "pitch": {"func": range_normalize, # some normalization function
-                "kwargs": {"min_value":0, "max_value":127}}, # some keyword arguments
+    "pitch": {
+        "func": range_normalize,
+        "kwargs": {"min_value": 0, "max_value": 127},
+    },
+    "velocity": {
+        "func": range_normalize,
+        "kwargs": {"min_value": 0, "max_value": 127},
+    },
+    "onset_beat": {
+        "func": minmaxrange_normalize,
+        "kwargs": {},
+    },
+    "duration_beat": {
+        "func": range_normalize,
+        "kwargs": {"min_value": -3, "max_value": 3, "log2": True},
+        # ref beat = 4th -> -3 = 32nd, 3 = breve
+    },
+    "beat_period": {
+        "func": range_normalize,
+        "kwargs": {"min_value": -3, "max_value": 2, "log2": True},
+        # ref 1 second / beat -> -3 = 0.125 sec / beat , 2 = 4 sec / beat
+    },
+    "timing": {
+        "func": range_normalize,
+        "kwargs": {"min_value": -0.2, "max_value": 0.2},
+        # deviation in seconds
+    },
+    "articulation_log": {
+        "func": range_normalize,
+        "kwargs": {"min_value": -4, "max_value": 3},
+        # thia ia the ratio in base2 log -> just min max clip
+    },
     # fill up with all note and performance features
 }
 
 
-def normalize(in_array, 
-              norm_funcs = DEFAULT_NORM_FUNCS,
-              norm_func_fallback = minmaxrange_normalize,
-              default_value = np.inf
-              ):
-    
+def normalize(
+    in_array,
+    norm_funcs=DEFAULT_NORM_FUNCS,
+    norm_func_fallback=minmaxrange_normalize,
+    default_value=np.inf,
+):
     """
     Normalize a note array.
     May include note features as well as performance features.
     All input columns must be of numeric types, everything is
     cast to single precision float.
-    
+
     Parameters
     ----------
     array : np.ndarray
         The performance array to be normalized.
     norm_funcs : dict
         A dictionary of normalization functions for each feature.
-    
+
     Returns
     -------
     array : np.ndarray
         The normalized performance array.
     """
-    dtype_new = np.dtype({'names':in_array.dtype.names, 'formats': [float for k in range(len(in_array.dtype.names))]})
+    dtype_new = np.dtype(
+        {
+            "names": in_array.dtype.names,
+            "formats": [float for k in range(len(in_array.dtype.names))],
+        }
+    )
     array = in_array.copy().astype(dtype_new)
 
     for feature in array.dtype.names:
-
         # use mask for non-default values and don't change default values
         non_default_mask = array[feature] != default_value
 
@@ -120,9 +157,12 @@ def normalize(in_array,
         else:
             # check whether a normalization function is defined for the feature
             if feature not in norm_funcs:
-                array[feature][non_default_mask] = norm_func_fallback(array[feature][non_default_mask])
+                array[feature][non_default_mask] = norm_func_fallback(
+                    array[feature][non_default_mask]
+                )
             else:
-                array[feature][non_default_mask] = norm_funcs[feature]["func"](array[feature][non_default_mask], 
-                                                                               **norm_funcs[feature]["kwargs"])     
-    
+                array[feature][non_default_mask] = norm_funcs[feature]["func"](
+                    array[feature][non_default_mask], **norm_funcs[feature]["kwargs"]
+                )
+
     return array

partitura/utils/synth.py

@@ -320,7 +320,6 @@ class DistributedHarmonics(object):
         n_harmonics: int,
         weights: Union[np.ndarray, str] = "equal",
     ) -> None:
-
         self.n_harmonics = n_harmonics
         self.weights = weights
 
@@ -330,7 +329,6 @@ class DistributedHarmonics(object):
         self._overtones = np.arange(1, self.n_harmonics + 2)
 
     def __call__(self, freq: float) -> Tuple[np.ndarray]:
-
         return self._overtones * freq, self.weights
 
 
@@ -344,7 +342,6 @@ class ShepardTones(object):
         min_freq: Union[float, int] = 77.8,
         max_freq: Union[float, int] = 2349,
     ) -> None:
-
         self.min_freq = min_freq
         self.max_freq = max_freq
 
@@ -361,7 +358,6 @@ class ShepardTones(object):
         )
 
     def __call__(self, freq) -> Tuple[np.ndarray]:
-
         min_freq = self.min_f(freq)
 
         freqs = 2 ** np.arange(5) * min_freq
@@ -485,15 +481,13 @@ def synthesize(
             return x, 1
 
     elif isinstance(harmonic_dist, int):
-
         harmonic_dist = DistributedHarmonics(harmonic_dist)
 
     elif isinstance(harmonic_dist, str):
         if harmonic_dist in ("shepard",):
             harmonic_dist = ShepardTones()
 
-    for (f, oif, dur) in zip(freq_in_hz, onsets_in_frames, duration):
-
+    for f, oif, dur in zip(freq_in_hz, onsets_in_frames, duration):
         freqs, weights = harmonic_dist(f)
 
         note = additive_synthesis(

{partitura-1.3.0.dist-info → partitura-1.4.0.dist-info}/METADATA

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: partitura
-Version: 1.3.0
+Version: 1.4.0
 Summary: A package for handling symbolic musical information
 Home-page: https://github.com/CPJKU/partitura
-Author: Maarten Grachten, Carlos Cancino-Chacón, Silvan Peter, Emmanouil Karystinaios, Francesco Foscarin, Thassilo Gadermaier
+Author: Maarten Grachten, Carlos Cancino-Chacón, Silvan Peter, Emmanouil Karystinaios, Francesco Foscarin, Thassilo Gadermaier, Patricia Hu
 Author-email: partitura-users@googlegroups.com
 License: Apache 2.0
 Keywords: music notation musicxml midi

partitura-1.4.0.dist-info/RECORD

@@ -0,0 +1,51 @@
+partitura/__init__.py,sha256=pwZEYD4DiL5_xm7rioL1UsHkeMUYE9gu-063KGvkcZM,2194
+partitura/directions.py,sha256=F5Au1u6DB0vzxscNZF5pqva73gHQzSLQ2syahyrByeY,14163
+partitura/display.py,sha256=QPfdbvKvivfsCRSjZnWztMwRryefVn_vjuQO2BCRRxM,5599
+partitura/performance.py,sha256=7tXXfuSbc7GPRbyg5VES-NtSrMiOFVcR3g3tO8c8n5U,21230
+partitura/score.py,sha256=2jzdwOZG93S6_L7kCe6MRNO9W6Xe6vNm9aZlj68SSw8,156031
+partitura/assets/musicxml.xsd,sha256=Sa6eNOBLpbcgBGh5lPcNWYMj6zNT6tti-u3Mnp3EvX8,335762
+partitura/assets/score_example.krn,sha256=-sdx5JEZrkOyP26bmXG6XdPdgNYwHedXvM-rch5C_6Y,104
+partitura/assets/score_example.mei,sha256=YMmQ07gztEAlkeXayTY53SSzoXVPLwoY-n4M3zpUgUY,2436
+partitura/assets/score_example.mid,sha256=X-c10L0ore-dQu6fH67XV5LoFuSJERI_6vC0bl6JD-0,56
+partitura/assets/score_example.musicxml,sha256=EUGM9PJzoazJLnaIqAWFFWThd7NmrZnabhkX6BSG3t8,1589
+partitura/io/__init__.py,sha256=GWDIEmgVKYLxPaaWzEWppHHvV-VmbONab8Xz6PWaoPA,6364
+partitura/io/exportaudio.py,sha256=3YzLFT0bKOdxLZnMwzMlp9_b9PFWBNKmiuLn5gNcLvs,3985
+partitura/io/exportmatch.py,sha256=Wxnw54wcnN-zwPvXH7ThP7D0MLXAiHJ_NK59fwXMrlw,20946
+partitura/io/exportmei.py,sha256=51kzU5WB41j-d2HSbNcMS6zTl4fgS-rF0bj-IOysmLQ,71850
+partitura/io/exportmidi.py,sha256=tftlWDqFfgVYZ8j9FnOblVicFOv0zdO5sMlcZGcfILw,19725
+partitura/io/exportmusicxml.py,sha256=d3atEddXecKUtPtdaINZMpGnu5RoNSbSrFG3J8RHEKg,35318
+partitura/io/exportparangonada.py,sha256=AFZeYWRPFkoMoF4eMRDyZavC7v3H4Crs9bCkow2QO9s,9056
+partitura/io/importkern.py,sha256=vwbh9Y9RlDAD5OzZywNmRQKJhtIkek8_wHfXHUB43ao,22394
+partitura/io/importmatch.py,sha256=90spvpvUEcF3M-7vt42IwHwkpkTobyXfDS8TeUg33ZM,29868
+partitura/io/importmei.py,sha256=wkfCmJYAZSUy-uSh1mxmvs3iTtOH5aeQxb0Cf5Rn7r8,47584
+partitura/io/importmidi.py,sha256=Y75pfCQ_ZNrluNajhOhtS40geiNkA9RhxLc9NvxiNuY,27235
+partitura/io/importmusic21.py,sha256=SZEnKukfHohys3vzVzRVJj88NWok9OTJ_a89gcQSmRY,8201
+partitura/io/importmusicxml.py,sha256=T_CnwnIXmtwCgOXdN6gGu4fM8Tz2u1Z33lfbqZC2NJc,57658
+partitura/io/importnakamura.py,sha256=jEBOLRhGXFcsfFVfxm7cerF0ap_jCt9PmcDp0VHNFYc,8432
+partitura/io/importparangonada.py,sha256=9VKkwvBB66rwbiv_8URItFuvQ5X9N0ybpL0eHYdAMeg,5927
+partitura/io/matchfile_base.py,sha256=mkHwL9IxJ3JhU86ob2yi1FyNKxEeXxhInLi0gTCA7sg,31670
+partitura/io/matchfile_utils.py,sha256=ug-c9J_xP-_gvDufBPSw9PAjTFEmqE56Vr89zdcT6dE,26601
+partitura/io/matchlines_v0.py,sha256=TVJN0YUevmSpANNjBdaoGtN-c3IrhTCcGk7WAuoOdTA,29228
+partitura/io/matchlines_v1.py,sha256=kHxaeOQTs87yZyNTHRth5Z9BEug0-o2YUpF9pPr9P54,40486
+partitura/io/musescore.py,sha256=kaWpRnNIxSSyfHanQa6c6CxKSDYNfWhLUbhETzLJzyU,8853
+partitura/musicanalysis/__init__.py,sha256=XQDeUrjitlzybIP1l8CU6vOLqNm7C7B7vhe0pySwuVY,1236
+partitura/musicanalysis/key_identification.py,sha256=Kl4hx_AkuRQuBGvNlpGAE3MqpznmWLGFo68Yx3rqSss,6991
+partitura/musicanalysis/meter.py,sha256=ORynu2foZmmedj1je-em1xCvzPfIj9RqnZBFWnnwe5k,11189
+partitura/musicanalysis/note_array_to_score.py,sha256=sCFxJS98t8mpL4hNHCcvArduqm6isNnQ_Zhfw7RLwVQ,21781
+partitura/musicanalysis/note_features.py,sha256=XUOC1jUgddyTyxP5yVCLcygtY44e1tJzFcafmKdsMu0,37809
+partitura/musicanalysis/performance_codec.py,sha256=wkf_lPLfGkWKKU-rEsWSqHj-AJAuSURRJDWawnthnXA,34663
+partitura/musicanalysis/performance_features.py,sha256=beRKADPJefzQ2rZxM_31s_bwmlr5MTX__cvqNbOcZsc,17909
+partitura/musicanalysis/pitch_spelling.py,sha256=u3-r_1oTOz87aEDtEkS_jVbtzrJmAo1quPqgZfmsiAk,8928
+partitura/musicanalysis/tonal_tension.py,sha256=0e_w6E4zp3Un_ctrUc5GeLti0qZHupywzh9e2w7o3Fs,17350
+partitura/musicanalysis/voice_separation.py,sha256=Uxy04j-Tar_hVFUY9gIcEG9qr7o-ya8ZSauuX6q_G5A,35740
+partitura/utils/__init__.py,sha256=WebirkSldT9htYdiUwemm5Vt9uXRsaYGSDRWUm4NeTI,1973
+partitura/utils/generic.py,sha256=T-gtDIF_qxcUgq9BUhHmsIiYLYSyyAs6Qu25DZ1EL3c,19050
+partitura/utils/misc.py,sha256=CQrIfETS-__2ZGz0eV2BDZtd9FbUHgevQT1PSRL9VvU,7064
+partitura/utils/music.py,sha256=TJkF6L7_gQbxLIjFWwvtcdCi6kPWsmdbZyhI5_C6LMM,111276
+partitura/utils/normalize.py,sha256=18OvJBiYOQoefedgxpX8TEwxEqoO7hQ31XXx3JjfYps,4667
+partitura/utils/synth.py,sha256=9xg6sVRmz7KWGlNTWFp3bo-7bT1wRwNRdi-ODr8H4PI,15568
+partitura-1.4.0.dist-info/LICENSE,sha256=mfxqxedyDV9qko2GrppTJVlVnpK7qkUE5sPUkGK_a9I,11429
+partitura-1.4.0.dist-info/METADATA,sha256=lQDI6LrW9bLmKh5Kk9r5CP6MCbdNNprGs98KHLpYaO4,9423
+partitura-1.4.0.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
+partitura-1.4.0.dist-info/top_level.txt,sha256=oUqKOhAhzAD7e9Al23ZKsGssQFCu9FpYj_DHGC15euU,10
+partitura-1.4.0.dist-info/RECORD,,

{partitura-1.3.0.dist-info → partitura-1.4.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.40.0)
+Generator: bdist_wheel (0.41.2)
 Root-Is-Purelib: true
 Tag: py3-none-any