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

partitura/directions.py

@@ -151,6 +151,8 @@ CONSTANT_TEMPO_ADJ = [
     "adagio",
     "agitato",
     "andante",
+    "andante cantabile",
+    "andante amoroso",
     "andantino",
     "animato",
     "appassionato",
@@ -193,6 +195,7 @@ CONSTANT_TEMPO_ADJ = [
     "tranquilamente",
     "tranquilo",
     "recitativo",
+    "allegro moderato",
     r"/(vivo|vivacissimamente|vivace)/",
     r"/(allegro|allegretto)/",
     r"/(espressivo|espress\.?)/",

partitura/display.py

@@ -120,7 +120,6 @@ def render_lilypond(
     with TemporaryFile() as xml_fh, NamedTemporaryFile(
         suffix=prvw_sfx, delete=False
     ) as img_fh:
-
         # save part to musicxml in file handle xml_fh
         save_musicxml(score_data, xml_fh)
         # rewind read pointer of file handle before we pass it to musicxml2ly

partitura/io/__init__.py

@@ -4,6 +4,7 @@
 This module contains methods for importing and exporting symbolic music formats.
 """
 from typing import Union
+import os
 
 from .importmusicxml import load_musicxml
 from .importmidi import load_score_midi, load_performance_midi
@@ -35,7 +36,7 @@ def load_score(filename: PathLike, force_note_ids="keep") -> Score:
     """
     Load a score format supported by partitura. Currently the accepted formats
     are MusicXML, MIDI, Kern and MEI, plus all formats for which
-    MuseScore has support import-support (requires MuseScore 3).
+    MuseScore has support import-support (requires MuseScore 4 or 3).
 
     Parameters
     ----------
@@ -54,20 +55,16 @@ def load_score(filename: PathLike, force_note_ids="keep") -> Score:
     scr: :class:`partitura.score.Score`
         A score instance.
     """
-    part = None
 
-    # Catch exceptions
-    exception_dictionary = dict()
-    # Load MusicXML
-    try:
+    extension = os.path.splitext(filename)[-1].lower()
+    if extension in (".mxl", ".xml", ".musicxml"):
+        # Load MusicXML
         return load_musicxml(
             filename=filename,
             force_note_ids=force_note_ids,
         )
-    except Exception as e:
-        exception_dictionary["MusicXML"] = e
-    # Load MIDI
-    try:
+    elif extension in [".midi", ".mid"]:
+        # Load MIDI
         if (force_note_ids is None) or (not force_note_ids):
             assign_note_ids = False
         else:
@@ -76,44 +73,53 @@ def load_score(filename: PathLike, force_note_ids="keep") -> Score:
             filename=filename,
             assign_note_ids=assign_note_ids,
         )
-    except Exception as e:
-        exception_dictionary["MIDI"] = e
-    # Load MEI
-    try:
+    elif extension in [".mei"]:
+        # Load MEI
         return load_mei(filename=filename)
-    except Exception as e:
-        exception_dictionary["MEI"] = e
-    # Load Kern
-    try:
+    elif extension in [".kern", ".krn"]:
         return load_kern(
             filename=filename,
             force_note_ids=force_note_ids,
         )
-    except Exception as e:
-        exception_dictionary["Kern"] = e
-    # Load MuseScore
-    try:
+    elif extension in [
+        ".mscz",
+        ".mscx",
+        ".musescore",
+        ".mscore",
+        ".ms",
+        ".kar",
+        ".md",
+        ".cap",
+        ".capx",
+        ".bww",
+        ".mgu",
+        ".sgu",
+        ".ove",
+        ".scw",
+        ".ptb",
+        ".gtp",
+        ".gp3",
+        ".gp4",
+        ".gp5",
+        ".gpx",
+        ".gp",
+    ]:
+        # Load MuseScore
         return load_via_musescore(
             filename=filename,
             force_note_ids=force_note_ids,
         )
-    except Exception as e:
-        exception_dictionary["MuseScore"] = e
-    try:
+    elif extension in [".match"]:
         # Load the score information from a Matchfile
-        _, _, part = load_match(
+        _, _, score = load_match(
             filename=filename,
             create_score=True,
         )
-
-    except Exception as e:
-        exception_dictionary["matchfile"] = e
-    if part is None:
-        for score_format, exception in exception_dictionary.items():
-            print(f"Error loading score as {score_format}:")
-            print(exception)
-
-        raise NotSupportedFormatError
+        return score
+    else:
+        raise NotSupportedFormatError(
+            f"{extension} file extension is not supported. If this should be supported, consider editing partitura/io/__init__.py file"
+        )
 
 
 def load_score_as_part(filename: PathLike) -> Part:

partitura/io/exportmatch.py

@@ -37,6 +37,7 @@ from partitura.io.matchfile_utils import (
     FractionalSymbolicDuration,
     MatchKeySignature,
     MatchTimeSignature,
+    MatchTempoIndication,
     Version,
 )
 
@@ -53,9 +54,7 @@ from partitura.utils.misc import (
     deprecated_parameter,
 )
 
-from partitura.musicanalysis.performance_codec import (
-    get_time_maps_from_alignment
-)
+from partitura.musicanalysis.performance_codec import get_time_maps_from_alignment
 
 __all__ = ["save_match"]
 
@@ -73,6 +72,8 @@ def matchfile_from_alignment(
     score_filename: Optional[PathLike] = None,
     performance_filename: Optional[PathLike] = None,
     assume_part_unfolded: bool = False,
+    tempo_indication: Optional[str] = None,
+    diff_score_version_notes: Optional[list] = None,
     version: Version = LATEST_VERSION,
     debug: bool = False,
 ) -> MatchFile:
@@ -108,6 +109,10 @@ def matchfile_from_alignment(
         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`.
+    tempo_indication : str or None
+        The tempo direction indicated in the beginning of the score
+    diff_score_version_notes : list or None
+        A list of score notes that reflect a special score version (e.g., original edition/Erstdruck, Editors note etc.)
     version: Version
         Version of the match file. For now only 1.0.0 is supported.
     Returns
@@ -201,17 +206,14 @@ def matchfile_from_alignment(
 
     # Score prop header lines
     scoreprop_lines = defaultdict(list)
-
     # For score notes
     score_info = dict()
     # Info for sorting lines
     snote_sort_info = dict()
     for (mnum, msd, msb), m in zip(measure_starts, measures):
-
         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))
             dpq = int(spart.quarter_duration_map(time_divs))
@@ -280,9 +282,7 @@ def matchfile_from_alignment(
         # Get all notes in the measure
         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
             duration_divs = offset_divs - onset_divs
 
@@ -329,6 +329,15 @@ def matchfile_from_alignment(
             if fermata is not None:
                 score_attributes_list.append("fermata")
 
+            if isinstance(snote, score.GraceNote):
+                score_attributes_list.append("grace")
+
+            if (
+                diff_score_version_notes is not None
+                and snote.id in diff_score_version_notes
+            ):
+                score_attributes_list.append("diff_score_version")
+
             score_info[snote.id] = MatchSnote(
                 version=version,
                 anchor=str(snote.id),
@@ -351,6 +360,22 @@ def matchfile_from_alignment(
             )
             snote_sort_info[snote.id] = (onset_beats, snote.doc_order)
 
+    # # NOTE time position is hardcoded, not pretty...  Assumes there is only one tempo indication at the beginning of the score
+    if tempo_indication is not None:
+        score_tempo_direction_header = make_scoreprop(
+            version=version,
+            attribute="tempoIndication",
+            value=MatchTempoIndication(
+                tempo_indication,
+                is_list=False,
+            ),
+            measure=measure_starts[0][0],
+            beat=1,
+            offset=0,
+            time_in_beats=measure_starts[0][2],
+        )
+        scoreprop_lines["tempo_indication"].append(score_tempo_direction_header)
+
     perf_info = dict()
     pnote_sort_info = dict()
     for pnote in ppart.notes:
@@ -377,8 +402,22 @@ def matchfile_from_alignment(
 
     sort_stime = []
     note_lines = []
-    for al_note in alignment:
 
+    # Get ids of notes which voice overlap
+    sna = spart.note_array()
+    onset_pitch_slice = sna[["onset_div", "pitch"]]
+    uniques, counts = np.unique(onset_pitch_slice, return_counts=True)
+    duplicate_values = uniques[counts > 1]
+    duplicates = dict()
+    for v in duplicate_values:
+        idx = np.where(onset_pitch_slice == v)[0]
+        duplicates[tuple(v)] = idx
+    voice_overlap_note_ids = []
+    if len(duplicates) > 0:
+        duplicate_idx = np.concatenate(np.array(list(duplicates.values()))).flatten()
+        voice_overlap_note_ids = list(sna[duplicate_idx]["id"])
+
+    for al_note in alignment:
         label = al_note["label"]
 
         if label == "match":
@@ -390,6 +429,8 @@ def matchfile_from_alignment(
 
         elif label == "deletion":
             snote = score_info[al_note["score_id"]]
+            if al_note["score_id"] in voice_overlap_note_ids:
+                snote.ScoreAttributesList.append("voice_overlap")
             deletion_line = MatchSnoteDeletion(version=version, snote=snote)
             note_lines.append(deletion_line)
             sort_stime.append(snote_sort_info[al_note["score_id"]])
@@ -447,6 +488,7 @@ def matchfile_from_alignment(
         "clock_rate",
         "key_signatures",
         "time_signatures",
+        "tempo_indication",
     ]
     all_match_lines = []
     for h in header_order:
@@ -543,7 +585,7 @@ def save_match(
     else:
         raise ValueError(
             "`performance_data` should be a `Performance`, a `PerformedPart`, or a "
-            f"list of `PerformedPart` objects, but is {type(score_data)}"
+            f"list of `PerformedPart` objects, but is {type(performance_data)}"
         )
 
     # Get matchfile

partitura/io/exportmidi.py

@@ -8,7 +8,7 @@ import numpy as np
 from collections import defaultdict, OrderedDict
 from typing import Optional, Iterable
 
-from mido import MidiFile, MidiTrack, Message, MetaMessage
+from mido import MidiFile, MidiTrack, Message, MetaMessage, merge_tracks
 
 import partitura.score as score
 from partitura.score import Score, Part, PartGroup, ScoreLike
@@ -32,7 +32,7 @@ def map_to_track_channel(note_keys, mode):
     tr_helper = {}
     track = {}
     channel = {}
-    for (pg, p, v) in note_keys:
+    for pg, p, v in note_keys:
         if mode == 0:
             trk = tr_helper.setdefault(p, len(tr_helper))
             ch1 = ch_helper.setdefault(p, {})
@@ -87,6 +87,7 @@ def save_performance_midi(
     mpq: int = 500000,
     ppq: int = 480,
     default_velocity: int = 64,
+    merge_tracks_save: Optional[bool] = False,
 ) -> Optional[MidiFile]:
     """Save a :class:`~partitura.performance.PerformedPart` or
     a :class:`~partitura.performance.Performance` as a MIDI file
@@ -107,6 +108,8 @@ def save_performance_midi(
     default_velocity : int, optional
         A default velocity value (between 0 and 127) to be used for
         notes without a specified velocity. Defaults to 64.
+    merge_tracks_save : bool, optional
+        Determines whether midi tracks are merged when exporting to a midi file. Defaults to False.
 
     Returns
     -------
@@ -134,7 +137,6 @@ def save_performance_midi(
         )
 
     track_events = defaultdict(lambda: defaultdict(list))
-
     for performed_part in performed_parts:
         for c in performed_part.controls:
             track = c.get("track", 0)
@@ -217,6 +219,10 @@ def save_performance_midi(
                 track.append(msg.copy(time=t_delta))
                 t_delta = 0
             t = t_msg
+
+    if merge_tracks_save and len(mf.tracks) > 1:
+        mf.tracks = [merge_tracks(mf.tracks)]
+
     if out is not None:
         if hasattr(out, "write"):
             mf.save(file=out)
@@ -287,9 +293,9 @@ def save_score_midi(
         downbeats position are coherent in case of incomplete measures
         later in the score.
     minimum_ppq : int, optional
-        Minimum ppq to use for the MIDI file. If the ppq of the score is less, 
+        Minimum ppq to use for the MIDI file. If the ppq of the score is less,
         it will be doubled until it is above the threshold. This is useful
-        because some libraries like miditok require a certain minimum ppq to 
+        because some libraries like miditok require a certain minimum ppq to
         work properly.
 
     Returns
@@ -315,7 +321,7 @@ def save_score_midi(
     # double it until it is above the minimum level.
     # Doubling instead of setting it ensure that the common divisors stay the same.
     while ppq < minimum_ppq:
-        ppq = ppq*2
+        ppq = ppq * 2
 
     events = defaultdict(lambda: defaultdict(list))
     meta_events = defaultdict(lambda: defaultdict(list))
@@ -346,7 +352,6 @@ def save_score_midi(
             )
 
     for qm, part in zip(quarter_maps, score.iter_parts(parts)):
-
         pg = get_partgroup(part)
 
         notes = part.notes_tied
@@ -367,22 +372,30 @@ def save_score_midi(
             all_ts = list(part.iter_all(score.TimeSignature))
             ts_changing_time = [ts.start.t for ts in all_ts]
             for measure in part.iter_all(score.Measure):
-                m_duration_beat = part.beat_map(measure.end.t) - part.beat_map(measure.start.t)
+                m_duration_beat = part.beat_map(measure.end.t) - part.beat_map(
+                    measure.start.t
+                )
                 m_ts = part.time_signature_map(measure.start.t)
                 if m_duration_beat != m_ts[0]:
                     # add ts change
                     # TODO: add support for changing the beat type if number of beats is not integer
                     meta_events[part][to_ppq(measure.start.t)].append(
                         MetaMessage(
-                            "time_signature", numerator=int(m_duration_beat), denominator=int(m_ts[1])
+                            "time_signature",
+                            numerator=int(m_duration_beat),
+                            denominator=int(m_ts[1]),
                         )
                     )
-                    ts_changing_time.append(measure.start.t) # keep track of changing the ts
+                    ts_changing_time.append(
+                        measure.start.t
+                    )  # keep track of changing the ts
                     # now go back to original ts if there is no ts change after this measure
                     if not any([ts_t > measure.start.t for ts_t in ts_changing_time]):
                         meta_events[part][to_ppq(measure.end.t)].append(
                             MetaMessage(
-                                "time_signature", numerator=int(m_ts[0]), denominator=int(m_ts[1])
+                                "time_signature",
+                                numerator=int(m_ts[0]),
+                                denominator=int(m_ts[1]),
                             )
                         )
             # filter out the multiple ts changes at the same time
@@ -394,27 +407,33 @@ def save_score_midi(
             # now add the normal time signature change
             for ts in part.iter_all(score.TimeSignature):
                 if ts.start.t in ts_changing_time:
-                #don't add if something is already added at this time to cover the case of a ts change when the first measure is shorter/longer
+                    # don't add if something is already added at this time to cover the case of a ts change when the first measure is shorter/longer
                     pass
                 else:
                     meta_events[part][to_ppq(ts.start.t)].append(
                         MetaMessage(
-                            "time_signature", numerator=ts.beats, denominator=ts.beat_type
+                            "time_signature",
+                            numerator=ts.beats,
+                            denominator=ts.beat_type,
                         )
                     )
-        else: # just add the time signature that are explicit in partitura
+        else:  # just add the time signature that are explicit in partitura
             for i, ts in enumerate(part.iter_all(score.TimeSignature)):
                 if anacrusis_behavior == "pad_bar" and i == 0:
                     # shift the first time signature to 0 so MIDI players can pick up the correct measure position
                     meta_events[part][0].append(
                         MetaMessage(
-                        "time_signature", numerator=ts.beats, denominator=ts.beat_type
+                            "time_signature",
+                            numerator=ts.beats,
+                            denominator=ts.beat_type,
                         )
-                    )   
-                else: #follow the position in the partitura part
+                    )
+                else:  # follow the position in the partitura part
                     meta_events[part][to_ppq(ts.start.t)].append(
                         MetaMessage(
-                            "time_signature", numerator=ts.beats, denominator=ts.beat_type
+                            "time_signature",
+                            numerator=ts.beats,
+                            denominator=ts.beat_type,
                         )
                     )
 
@@ -424,7 +443,6 @@ def save_score_midi(
             )
 
         for note in notes:
-
             # key is a tuple (part_group, part, voice) that will be
             # converted into a (track, channel) pair.
             key = (pg, part, note.voice)