partitura 1.3.1__tar.gz → 1.4.0__tar.gz

{partitura-1.3.1 → partitura-1.4.0}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: partitura
-Version: 1.3.1
+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
@@ -15,6 +15,12 @@ Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: lxml
+Requires-Dist: lark-parser
+Requires-Dist: xmlschema
+Requires-Dist: mido
 
 
 [//]: # (<p align="center"> )

{partitura-1.3.1 → partitura-1.4.0}/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-1.3.1 → partitura-1.4.0}/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-1.3.1 → partitura-1.4.0}/partitura/io/exportmatch.py

@@ -37,6 +37,7 @@ from partitura.io.matchfile_utils import (
     FractionalSymbolicDuration,
     MatchKeySignature,
     MatchTimeSignature,
+    MatchTempoIndication,
     Version,
 )
 
@@ -71,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:
@@ -106,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
@@ -199,7 +206,6 @@ def matchfile_from_alignment(
 
     # Score prop header lines
     scoreprop_lines = defaultdict(list)
-
     # For score notes
     score_info = dict()
     # Info for sorting lines
@@ -276,7 +282,6 @@ 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
@@ -324,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),
@@ -346,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:
@@ -372,6 +402,21 @@ def matchfile_from_alignment(
 
     sort_stime = []
     note_lines = []
+
+    # 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"]
 
@@ -384,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"]])
@@ -441,6 +488,7 @@ def matchfile_from_alignment(
         "clock_rate",
         "key_signatures",
         "time_signatures",
+        "tempo_indication",
     ]
     all_match_lines = []
     for h in header_order:
@@ -537,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-1.3.1 → partitura-1.4.0}/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
@@ -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)

{partitura-1.3.1 → partitura-1.4.0}/partitura/io/importmatch.py

@@ -6,7 +6,7 @@ This module contains methods for parsing matchfiles
 import os
 from typing import Union, Tuple, Optional, Callable, List
 import warnings
-
+from functools import partial
 import numpy as np
 
 from partitura import score
@@ -197,21 +197,23 @@ def load_matchfile(
 
     parsed_lines = list()
     # Functionality to remove duplicate lines
-    for i, line in enumerate(raw_lines):
-        if line in raw_lines[i + 1 :] and line != "":
-            warnings.warn(f"Duplicate line found in matchfile: {line}")
-            continue
-        parsed_line = parse_matchline(line, from_matchline_methods, version)
-        if parsed_line is None:
-            warnings.warn(f"Could not empty parse line: {line} ")
-            continue
-        parsed_lines.append(parsed_line)
-
+    len_raw_lines = len(raw_lines)
+    np_lines = np.array(raw_lines, dtype=str)
+    # Remove empty lines
+    np_lines = np_lines[np_lines != ""]
+    # Remove duplicate lines
+    _, idx = np.unique(np_lines, return_index=True)
+    np_lines = np_lines[np.sort(idx)]
+    # Parse lines
+    f = partial(
+        parse_matchline, version=version, from_matchline_methods=from_matchline_methods
+    )
+    f_vec = np.vectorize(f)
+    parsed_lines = f_vec(np_lines).tolist()
+    # Create MatchFile instance
     mf = MatchFile(lines=parsed_lines)
-
     # Validate match for duplicate snote_ids or pnote_ids
     validate_match_ids(mf)
-
     return mf
 
 
@@ -371,29 +373,38 @@ def performed_part_from_match(
     # PerformedNote instances for all MatchNotes
     notes = []
 
-    first_note = next(mf.iter_notes(), None)
-    if first_note and first_note_at_zero:
-        offset = midi_ticks_to_seconds(first_note.Onset, mpq=mpq, ppq=ppq)
-        offset_tick = first_note.Onset
-    else:
-        offset = 0
-        offset_tick = 0
-
-    notes = [
-        dict(
-            id=format_pnote_id(note.Id),
-            midi_pitch=note.MidiPitch,
-            note_on=midi_ticks_to_seconds(note.Onset, mpq, ppq) - offset,
-            note_off=midi_ticks_to_seconds(note.Offset, mpq, ppq) - offset,
-            note_on_tick=note.Onset - offset_tick,
-            note_off_tick=note.Offset - offset_tick,
-            sound_off=midi_ticks_to_seconds(note.Offset, mpq, ppq) - offset,
-            velocity=note.Velocity,
-            track=getattr(note, "Track", 0),
-            channel=getattr(note, "Channel", 1),
+    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)
+    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
+        notes.append(
+            dict(
+                id=format_pnote_id(note.Id),
+                midi_pitch=note.MidiPitch,
+                note_on=n_onset_sec,
+                note_off=midi_ticks_to_seconds(note.Offset, mpq, ppq),
+                note_on_tick=note.Onset,
+                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", 1),
+            )
         )
-        for note in mf.notes
-    ]
+    # Set first note_on to zero in ticks and seconds if first_note_at_zero
+    if first_note_at_zero and len(note_onsets_in_secs) > 0:
+        offset = note_onsets_in_secs.min()
+        offset_tick = note_onsets_in_tick.min()
+        if offset > 0 and offset_tick > 0:
+            for note in notes:
+                note["note_on"] -= offset
+                note["note_off"] -= offset
+                note["sound_off"] -= offset
+                note["note_on_tick"] -= offset_tick
+                note["note_off_tick"] -= offset_tick
 
     # SustainPedal instances for sustain pedal lines
     sustain_pedal = [