partitura 1.6.0__tar.gz → 1.7.0__tar.gz

{partitura-1.6.0 → partitura-1.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: partitura
-Version: 1.6.0
+Version: 1.7.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, Patricia Hu
@@ -29,6 +29,7 @@ Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: keywords
 Dynamic: license
+Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary

{partitura-1.6.0 → partitura-1.7.0}/partitura/assets/score_example.musicxml

@@ -13,6 +13,9 @@
     <measure number="1">
       <attributes>
         <divisions>12</divisions>
+        <key>
+           <fifths>0</fifths>
+        </key>
         <time>
           <beats>4</beats>
           <beat-type>4</beat-type>

{partitura-1.6.0 → partitura-1.7.0}/partitura/io/exportmatch.py

@@ -70,7 +70,7 @@ def matchfile_from_alignment(
     piece: Optional[str] = None,
     score_filename: Optional[PathLike] = None,
     performance_filename: Optional[PathLike] = None,
-    assume_part_unfolded: bool = False,
+    assume_part_unfolded: bool = True,
     tempo_indication: Optional[str] = None,
     diff_score_version_notes: Optional[list] = None,
     version: Version = LATEST_VERSION,
@@ -107,7 +107,7 @@ def matchfile_from_alignment(
         Whether to assume that the part has been unfolded according to the
         repetitions in the alignment. If False, the part will be automatically
         unfolded to have maximal coverage of the notes in the alignment.
-        See `partitura.score.unfold_part_alignment`.
+        See `partitura.score.unfold_part_alignment`, defaults to True.
     tempo_indication : str or None
         The tempo direction indicated in the beginning of the score
     diff_score_version_notes : list or None
@@ -210,18 +210,28 @@ def matchfile_from_alignment(
     # Info for sorting lines
     snote_sort_info = dict()
     for (mnum, msd, msb), m in zip(measure_starts, measures):
+        if mnum == 0:
+            # handle offsets in anacrusis measure
+            ts_num, ts_den, _ = spart.time_signature_map(0)
+            dpq = int(spart.quarter_duration_map(0))
+            measure_dur_in_divs = m.end.t - m.start.t
+            expected_measure_dur = ts_num * 4 / ts_den * dpq
+            if measure_dur_in_divs < expected_measure_dur:
+                msd -= expected_measure_dur - measure_dur_in_divs
+                msb -= (expected_measure_dur - measure_dur_in_divs) / dpq * ts_den / 4
+
         time_signatures = spart.iter_all(score.TimeSignature, m.start, m.end)
 
         for tsig in time_signatures:
             time_divs = int(tsig.start.t)
             time_beats = float(beat_map(time_divs))
+            ts_num, ts_den, _ = spart.time_signature_map(tsig.start.t)
             dpq = int(spart.quarter_duration_map(time_divs))
+            divs_per_beat = 4 / ts_den * dpq
             beat = int((time_beats - msb) // 1)
 
-            ts_num, ts_den, _ = spart.time_signature_map(tsig.start.t)
-
             moffset_divs = Fraction(
-                int(time_divs - msd - beat * dpq), (int(ts_den) * dpq)
+                int(time_divs - msd - beat * divs_per_beat), int(ts_den * divs_per_beat)
             )
 
             scoreprop_lines["time_signatures"].append(
@@ -247,15 +257,15 @@ def matchfile_from_alignment(
         key_signatures = spart.iter_all(score.KeySignature, m.start, m.end)
 
         for ksig in key_signatures:
-            time_divs = int(tsig.start.t)
+            time_divs = int(ksig.start.t)
             time_beats = float(beat_map(time_divs))
+            ts_num, ts_den, _ = spart.time_signature_map(ksig.start.t)
             dpq = int(spart.quarter_duration_map(time_divs))
+            divs_per_beat = 4 / ts_den * dpq
             beat = int((time_beats - msb) // 1)
 
-            ts_num, ts_den, _ = spart.time_signature_map(tsig.start.t)
-
             moffset_divs = Fraction(
-                int(time_divs - msd - beat * dpq), (int(ts_den) * dpq)
+                int(time_divs - msd - beat * divs_per_beat), int(ts_den * divs_per_beat)
             )
 
             scoreprop_lines["key_signatures"].append(
@@ -282,27 +292,28 @@ def matchfile_from_alignment(
         snotes = spart.iter_all(score.Note, m.start, m.end, include_subclasses=True)
         # Beginning of each measure
         for snote in snotes:
-            onset_divs, offset_divs = snote.start.t, snote.start.t + snote.duration_tied
+            onset_divs = snote.start.t
+            offset_divs = snote.start.t + snote.duration_tied
             duration_divs = offset_divs - onset_divs
-
+            # beat computations
             onset_beats, offset_beats = beat_map([onset_divs, offset_divs])
-
-            dpq = int(spart.quarter_duration_map(onset_divs))
-
-            beat = int((onset_beats - msb) // 1)
-
+            duration_beats = offset_beats - onset_beats
+            beat = int((onset_beats - msb) // 1)  # beat field of the snote
+            # quarter, div, symbolic computation
             ts_num, ts_den, _ = spart.time_signature_map(snote.start.t)
-
-            duration_symb = Fraction(duration_divs, dpq * 4)
-
-            beat = int((onset_divs - msd) // dpq)
-
-            moffset_divs = Fraction(int(onset_divs - msd - beat * dpq), (dpq * 4))
+            dpq = int(spart.quarter_duration_map(onset_divs))
+            duration_symb = Fraction(
+                duration_divs, dpq * 4
+            )  # compute duration from quarters/divs
+            divs_per_beat = 4 / ts_den * dpq
+            moffset_divs = Fraction(
+                int(onset_divs - msd - beat * divs_per_beat),
+                int(ts_den * divs_per_beat),
+            )
 
             if debug:
-                duration_beats = offset_beats - onset_beats
                 moffset_beat = (onset_beats - msb - beat) / ts_den
-                assert np.isclose(float(duration_symb), duration_beats)
+                assert np.isclose(float(duration_symb), duration_beats / ts_den)
                 assert np.isclose(moffset_beat, float(moffset_divs))
 
             score_attributes_list = []
@@ -508,9 +519,7 @@ def matchfile_from_alignment(
 
     # Concatenate all lines
     all_match_lines += list(note_lines) + pedal_lines
-
     matchfile = MatchFile(lines=all_match_lines)
-
     return matchfile
 
 

{partitura-1.6.0 → partitura-1.7.0}/partitura/io/exportmidi.py

@@ -36,34 +36,34 @@ def map_to_track_channel(note_keys, mode):
         if mode == 0:
             trk = tr_helper.setdefault(p, len(tr_helper))
             ch1 = ch_helper.setdefault(p, {})
-            ch2 = ch1.setdefault(v, len(ch1) + 1)
+            ch2 = ch1.setdefault(v, len(ch1))
             track[(pg, p, v)] = trk
             channel[(pg, p, v)] = ch2
         elif mode == 1:
             trk = tr_helper.setdefault(pg, len(tr_helper))
             ch1 = ch_helper.setdefault(pg, {})
-            ch2 = ch1.setdefault(p, len(ch1) + 1)
+            ch2 = ch1.setdefault(p, len(ch1))
             track[(pg, p, v)] = trk
             channel[(pg, p, v)] = ch2
         elif mode == 2:
             track[(pg, p, v)] = 0
-            ch = ch_helper.setdefault(p, len(ch_helper) + 1)
+            ch = ch_helper.setdefault(p, len(ch_helper))
             channel[(pg, p, v)] = ch
         elif mode == 3:
             trk = tr_helper.setdefault(p, len(tr_helper))
             track[(pg, p, v)] = trk
-            channel[(pg, p, v)] = 1
+            channel[(pg, p, v)] = 0
         elif mode == 4:
             track[(pg, p, v)] = 0
-            channel[(pg, p, v)] = 1
+            channel[(pg, p, v)] = 0
         elif mode == 5:
             trk = tr_helper.setdefault((p, v), len(tr_helper))
             track[(pg, p, v)] = trk
-            channel[(pg, p, v)] = 1
+            channel[(pg, p, v)] = 0
         else:
             raise Exception("unsupported part/voice assign mode {}".format(mode))
 
-    result = dict((k, (track.get(k, 0), channel.get(k, 1))) for k in note_keys)
+    result = dict((k, (track.get(k, 0), channel.get(k, 0))) for k in note_keys)
     # for (pg, p, voice), v in result.items():
     #     pgn = pg.group_name if hasattr(pg, 'group_name') else pg.id
     #     print(pgn, p.id, voice)
@@ -177,7 +177,7 @@ def save_performance_midi(
 
         for c in performed_part.controls:
             track = c.get("track", 0)
-            ch = c.get("channel", 1)
+            ch = c.get("channel", 0)
             t = int(np.round(10**6 * ppq * c["time"] / mpq))
             track_events[track][t].append(
                 Message(
@@ -190,7 +190,7 @@ def save_performance_midi(
 
         for n in performed_part.notes:
             track = n.get("track", 0)
-            ch = n.get("channel", 1)
+            ch = n.get("channel", 0)
             t_on = int(np.round(10**6 * ppq * n["note_on"] / mpq))
             t_off = int(np.round(10**6 * ppq * n["note_off"] / mpq))
             vel = n.get("velocity", default_velocity)
@@ -203,7 +203,7 @@ def save_performance_midi(
 
         for p in performed_part.programs:
             track = p.get("track", 0)
-            ch = p.get("channel", 1)
+            ch = p.get("channel", 0)
             t = int(np.round(10**6 * ppq * p["time"] / mpq))
             track_events[track][t].append(
                 Message("program_change", program=int(p["program"]), channel=ch)
@@ -215,11 +215,11 @@ def save_performance_midi(
                 list(
                     set(
                         [
-                            (c.get("channel", 1), c.get("track", 0))
+                            (c.get("channel", 0), c.get("track", 0))
                             for c in performed_part.controls
                         ]
                         + [
-                            (n.get("channel", 1), n.get("track", 0))
+                            (n.get("channel", 0), n.get("track", 0))
                             for n in performed_part.notes
                         ]
                     )
@@ -395,7 +395,7 @@ def save_score_midi(
 
         def to_ppq(t):
             # convert div times to new ppq
-            return int(ppq * (qm(t) - ftp))
+            return round(ppq * (qm(t) - ftp))
 
         for tp in part.iter_all(score.Tempo):
             tempos[to_ppq(tp.start.t)] = MetaMessage(

{partitura-1.6.0 → partitura-1.7.0}/partitura/io/exportmusicxml.py

@@ -36,6 +36,23 @@ ARTICULATIONS = [
     "tenuto",
     "unstress",
 ]
+ORNAMENTS = [
+    "trill-mark",
+    "turn",
+    "delayed-turn",
+    "inverted-turn",
+    "delayed-inverted-turn",
+    "vertical-turn",
+    "inverted-vertical-turn",
+    "shake",
+    "wavy-line",
+    "mordent",
+    "inverted-mordent",
+    "schleifer",
+    "tremolo",
+    "haydn",
+    "other-ornament",
+]
 
 
 def range_number_from_counter(e, label, counter):
@@ -154,6 +171,16 @@ def make_note_el(note, dur, voice, counter, n_of_staves):
             articulations_e.extend(articulations)
             notations.append(articulations_e)
 
+    if note.ornaments:
+        ornaments = []
+        for ornament in note.ornaments:
+            if ornament in ORNAMENTS:
+                ornaments.append(etree.Element(ornament))
+        if ornaments:
+            ornaments_e = etree.Element("ornaments")
+            ornaments_e.extend(ornaments)
+            notations.append(ornaments_e)
+
     if note.technical:
         technical = []
         for technical_notation in note.technical:
@@ -184,6 +211,8 @@ def make_note_el(note, dur, voice, counter, n_of_staves):
         actual_e.text = str(sym_dur["actual_notes"])
         normal_e = etree.SubElement(time_mod_e, "normal-notes")
         normal_e.text = str(sym_dur["normal_notes"])
+        for _ in range(sym_dur.get("normal_dots", 0)):
+            etree.SubElement(time_mod_e, "normal-dot")
 
     if note.staff is not None:
         if note.staff != 1 or n_of_staves > 1:
@@ -240,12 +269,16 @@ def make_note_el(note, dur, voice, counter, n_of_staves):
             tuplet_actual_notes_e.text = str(tuplet.actual_notes)
             tuplet_actual_type_e = etree.SubElement(tuplet_actual_e, "tuplet-type")
             tuplet_actual_type_e.text = str(tuplet.actual_type)
+            for _ in range(tuplet.actual_dots):
+                etree.SubElement(tuplet_actual_e, "tuplet-dot")
             # tuplet-normal tag
             tuplet_normal_e = etree.SubElement(tuplet_e, "tuplet-normal")
             tuplet_normal_notes_e = etree.SubElement(tuplet_normal_e, "tuplet-number")
             tuplet_normal_notes_e.text = str(tuplet.normal_notes)
             tuplet_normal_type_e = etree.SubElement(tuplet_normal_e, "tuplet-type")
             tuplet_normal_type_e.text = str(tuplet.normal_type)
+            for _ in range(tuplet.normal_dots):
+                etree.SubElement(tuplet_normal_e, "tuplet-dot")
         notations.append(tuplet_e)
 
     if notations:

{partitura-1.6.0 → partitura-1.7.0}/partitura/io/importdcml.py

@@ -284,7 +284,7 @@ def read_harmony_tsv(beat_tsv_path, part):
         # key_alter = re.search(r"[#b]", row["globalkey"]).group(0) if re.search(r"[#b]", row["globalkey"]) else ""
         # key_alter = key_alter.replace("b", "-")
         # key_alter = ALT_TO_INT[key_alter]
-        # key_step, key_alter = transpose_note(key_step, key_alter, transposition_interval)
+        # key_step, key_alter, _ = transpose_note_attributes(transposition_interval, key_step, key_alter)
         # local_key = key_step + INT_TO_ALT[key_alter]
         part.add(
             spt.Cadence(

{partitura-1.6.0 → partitura-1.7.0}/partitura/io/importmatch.py

@@ -226,8 +226,7 @@ def load_match(
     ppart = performed_part_from_match(mf, pedal_threshold, first_note_at_zero)
 
     performance = Performance(
-        id=get_document_name(filename),
-        performedparts=ppart,
+        id=get_document_name(filename), performedparts=ppart, ensure_unique_tracks=False
     )
     # Generate Part
     if create_score:
@@ -345,10 +344,16 @@ def performed_part_from_match(
     notes = list()
     note_onsets_in_secs = np.array(np.zeros(len(mf.notes)), dtype=float)
     note_onsets_in_tick = np.array(np.zeros(len(mf.notes)), dtype=int)
+    tracks = set()
+    channels = set()
     for i, note in enumerate(mf.notes):
         n_onset_sec = midi_ticks_to_seconds(note.Onset, mpq, ppq)
         note_onsets_in_secs[i] = n_onset_sec
         note_onsets_in_tick[i] = note.Onset
+        track = getattr(note, "Track", 0)
+        tracks.add(track)
+        channel = getattr(note, "Channel", 0)
+        channels.add(channel)
         notes.append(
             dict(
                 id=format_pnote_id(note.Id),
@@ -359,8 +364,8 @@ def performed_part_from_match(
                 note_off_tick=note.Offset,
                 sound_off=midi_ticks_to_seconds(note.Offset, mpq, ppq),
                 velocity=note.Velocity,
-                track=getattr(note, "Track", 0),
-                channel=getattr(note, "Channel", 0),
+                track=track,
+                channel=channel,
             )
         )
     # Set first note_on to zero in ticks and seconds if first_note_at_zero
@@ -375,12 +380,23 @@ def performed_part_from_match(
                 note["note_on_tick"] -= offset_tick
                 note["note_off_tick"] -= offset_tick
 
+    # check if multiple tracks are in the match file
+    if len(tracks) > 1:
+        warnings.warn("Notes on multiple MIDI tracks in matchfile" "information!.")
+    used_track = min(tracks)
+    # check if multiple tracks are in the match file
+    if len(channels) > 1:
+        warnings.warn("Notes on multiple MIDI channels in matchfile" "information!.")
+    used_channel = min(channels)
+
     # SustainPedal instances for sustain pedal lines
     sustain_pedal = [
         dict(
             number=64,
             time=midi_ticks_to_seconds(ped.Time, mpq, ppq),
             value=ped.Value,
+            track=used_track,
+            channel=used_channel,
         )
         for ped in mf.sustain_pedal
     ]
@@ -391,6 +407,8 @@ def performed_part_from_match(
             number=67,
             time=midi_ticks_to_seconds(ped.Time, mpq, ppq),
             value=ped.Value,
+            track=used_track,
+            channel=used_channel,
         )
         for ped in mf.soft_pedal
     ]
@@ -402,6 +420,9 @@ def performed_part_from_match(
         notes=notes,
         controls=sustain_pedal + soft_pedal,
         sustain_pedal_threshold=pedal_threshold,
+        ppq=ppq,
+        mpq=mpq,
+        track=used_track,
     )
     return ppart
 
@@ -458,9 +479,9 @@ def part_from_matchfile(
     max_time = max(n.OffsetInBeats for n in snotes)
     (
         beats_map_from_beats,
-        beats_map,
+        beats_map_from_quarters,
         beat_type_map_from_beats,
-        beat_type_map,
+        beat_type_map_from_quarters,
         min_time_q,
         max_time_q,
     ) = make_timesig_maps(ts, max_time)
@@ -468,13 +489,13 @@ def part_from_matchfile(
     # compute necessary divs based on the types of notes in the
     # match snotes (only integers)
     divs_arg = [
-        max(int((beat_type_map(note.OnsetInBeats) / 4)), 1)
+        max(int((beat_type_map_from_beats(note.OnsetInBeats) / 4)), 1)
         * note.Offset.denominator
         * (note.Offset.tuple_div or 1)
         for note in snotes
     ]
     divs_arg += [
-        max(int((beat_type_map(note.OnsetInBeats) / 4)), 1)
+        max(int((beat_type_map_from_beats(note.OnsetInBeats) / 4)), 1)
         * note.Duration.denominator
         * (note.Duration.tuple_div or 1)
         for note in snotes
@@ -484,24 +505,24 @@ def part_from_matchfile(
     unique_onsets, inv_idxs = np.unique(onset_in_beats, return_inverse=True)
 
     iois_in_beats = np.diff(unique_onsets)
-    beat_to_quarter = 4 / beat_type_map(onset_in_beats)
+    beat_to_quarter = 4 / beat_type_map_from_beats(onset_in_beats)
 
     iois_in_quarters_offset = np.r_[
         beat_to_quarter[0] * onset_in_beats[0],
-        (4 / beat_type_map(unique_onsets[:-1])) * iois_in_beats,
+        (4 / beat_type_map_from_beats(unique_onsets[:-1])) * iois_in_beats,
     ]
     onset_in_quarters = np.cumsum(iois_in_quarters_offset)
     iois_in_quarters = np.diff(onset_in_quarters)
 
     # ___ these divs are relative to quarters;
     divs = np.lcm.reduce(np.unique(divs_arg))
-    onset_in_divs = np.r_[0, np.cumsum(divs * iois_in_quarters)][inv_idxs]
+    onset_in_divs = np.r_[0, np.cumsum(divs * iois_in_quarters, dtype=int)][inv_idxs]
     onset_in_quarters = onset_in_quarters[inv_idxs]
 
     part.set_quarter_duration(0, divs)
     bars = np.unique([n.Measure for n in snotes])
     t = min_time
-    t = t * 4 / beat_type_map(min_time)
+    t = t * 4 / beat_type_map_from_beats(min_time)
     offset = t
     bar_times = {}
 
@@ -511,9 +532,9 @@ def part_from_matchfile(
         # if starting beat is above zero, add padding
         rest = score.Rest()
         part.add(rest, start=0, end=t * divs)
-        onset_in_divs += t * divs
+        onset_in_divs += round(t * divs)
         offset = 0
-        t = t - t % beats_map(min_time)
+        t = t - t % beats_map_from_beats(min_time)
 
     for b_name in bars:
         notes_in_this_bar = [
@@ -552,14 +573,14 @@ def part_from_matchfile(
         # on_off_scale = 1 means duration and beat offset are given in
         # whole notes, else they're given in beats (as in the KAIST data)
         if not match_offset_duration_in_whole:
-            on_off_scale = beat_type_map(bar_start)
+            on_off_scale = beat_type_map_from_quarters(bar_start)
 
         # offset within bar in quarter units adjusted for different
-        # time signatures -> 4 / beat_type_map(bar_start)
-        bar_offset = (note.Beat - 1) * 4 / beat_type_map(bar_start)
+        # time signatures -> 4 / beat_type_map_from_quarters(bar_start)
+        bar_offset = (note.Beat - 1) * 4 / beat_type_map_from_quarters(bar_start)
 
         # offset within beat in quarter units adjusted for different
-        # time signatures -> 4 / beat_type_map(bar_start)
+        # time signatures -> 4 / beat_type_map_from_quarters(bar_start)
         beat_offset = (
             4
             / on_off_scale
@@ -576,6 +597,7 @@ def part_from_matchfile(
                 "Calculated `onset_divs` does not match `OnsetInBeats` " "information!."
             )
             onset_divs = onset_in_divs[ni]
+
         assert onset_divs >= 0
         assert np.isclose(onset_divs, onset_in_divs[ni], atol=divs * 0.01)
         is_tied = False
@@ -753,9 +775,9 @@ def part_from_matchfile(
     last_closing_barline = barline_in_divs + int(
         round(
             divs
-            * beats_map(barline_in_quarters)
+            * beats_map_from_quarters(barline_in_quarters)
             * 4
-            / beat_type_map(barline_in_quarters)
+            / beat_type_map_from_quarters(barline_in_quarters)
         )
     )
     part.add(prev_measure, None, last_closing_barline)

{partitura-1.6.0 → partitura-1.7.0}/partitura/io/importmidi.py

@@ -6,6 +6,7 @@ This module contains methods for importing MIDI files.
 import warnings
 
 from collections import defaultdict
+from operator import itemgetter
 from typing import Union, Optional, List, Tuple, Dict
 import numpy as np
 
@@ -259,6 +260,7 @@ def load_performance_midi(
                             velocity=sounding_notes[note][2],
                         )
                     )
+
                     # remove hash from dict
                     del sounding_notes[note]
 
@@ -274,6 +276,25 @@ def load_performance_midi(
             )
         )
 
+        # adjust timing of events based on tempo changes
+        for note in notes:
+            note["note_on"] = adjust_time(note["note_on_tick"], tempo_changes, ppq)
+            note["note_off"] = adjust_time(note["note_off_tick"], tempo_changes, ppq)
+        for control in controls:
+            control["time"] = adjust_time(control["time_tick"], tempo_changes, ppq)
+        for program in programs:
+            program["time"] = adjust_time(program["time_tick"], tempo_changes, ppq)
+        for time_signature in time_signatures:
+            time_signature["time"] = adjust_time(
+                time_signature["time_tick"], tempo_changes, ppq
+            )
+        for key_signature in key_signatures:
+            key_signature["time"] = adjust_time(
+                key_signature["time_tick"], tempo_changes, ppq
+            )
+        for meta in meta_other:
+            meta["time"] = adjust_time(meta["time_tick"], tempo_changes, ppq)
+
         # add note id to every note
         for k, note in enumerate(notes):
             note["id"] = f"n{k}"
@@ -290,33 +311,13 @@ def load_performance_midi(
                 mpq=default_mpq,
                 track=i,
             )
-
             pps.append(pp)
 
-    # adjust timing of events based on tempo changes
-    for pp in pps:
-        for note in pp.notes:
-            note["note_on"] = adjust_time(note["note_on_tick"], tempo_changes, ppq)
-            note["note_off"] = adjust_time(note["note_off_tick"], tempo_changes, ppq)
-        for control in pp.controls:
-            control["time"] = adjust_time(control["time_tick"], tempo_changes, ppq)
-        for program in pp.programs:
-            program["time"] = adjust_time(program["time_tick"], tempo_changes, ppq)
-        for time_signature in pp.time_signatures:
-            time_signature["time"] = adjust_time(
-                time_signature["time_tick"], tempo_changes, ppq
-            )
-        for key_signature in pp.key_signatures:
-            key_signature["time"] = adjust_time(
-                key_signature["time_tick"], tempo_changes, ppq
-            )
-        for meta in pp.meta_other:
-            meta["time"] = adjust_time(meta["time_tick"], tempo_changes, ppq)
-
     perf = performance.Performance(
         id=doc_name,
         performedparts=pps,
     )
+
     return perf
 
 
@@ -618,23 +619,25 @@ or a list of these
         # now clear all track_ts
         time_sigs_by_track.clear()
 
-    time_sigs_by_part = defaultdict(set)
+    # use a list to preserve all time sigs in order
+    time_sigs_by_part = defaultdict(list)
     for tr, ts_list in time_sigs_by_track.items():
         for ts in ts_list:
             for part in track_to_part_mapping[tr]:
-                time_sigs_by_part[part].add(ts)
+                time_sigs_by_part[part].append(ts)
     for ts in global_time_sigs:
         for part in set(part for _, part, _ in group_part_voice_keys):
-            time_sigs_by_part[part].add(ts)
+            time_sigs_by_part[part].append(ts)
 
-    key_sigs_by_part = defaultdict(set)
+    # use a list to preserve all key sigs in order
+    key_sigs_by_part = defaultdict(list)
     for tr, ks_list in key_sigs_by_track.items():
         for ks in ks_list:
             for part in track_to_part_mapping[tr]:
-                key_sigs_by_part[part].add(ks)
+                key_sigs_by_part[part].append(ks)
     for ks in global_key_sigs:
         for part in set(part for _, part, _ in group_part_voice_keys):
-            key_sigs_by_part[part].add(ks)
+            key_sigs_by_part[part].append(ks)
 
     # names_by_part = defaultdict(set)
     # for tr_ch, pg_p_v in zip(tr_ch_keys, group_part_voice_keys):
@@ -661,13 +664,11 @@ or a list of these
             spellings,
             voices,
             note_ids,
-            sorted(time_sigs_by_part[part_nr]),
-            sorted(key_sigs_by_part[part_nr]),
+            sorted(time_sigs_by_part[part_nr], key=itemgetter(0)),
+            sorted(key_sigs_by_part[part_nr], key=itemgetter(0)),
             part_id="P{}".format(part_nr + 1),
             part_name=part_names.get(part_nr, None),
         )
-
-        # print(part.pretty())
         # if this part has an associated part_group number we create a PartGroup
         # if necessary, and add the part to that. The newly created PartGroup is
         # then added to the partlist.