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

partitura/io/importmei.py

@@ -3,7 +3,9 @@
 """
 This module contains methods for importing MEI files.
 """
+from collections import OrderedDict
 from lxml import etree
+from fractions import Fraction
 from xmlschema.names import XML_NAMESPACE
 import partitura.score as score
 from partitura.utils.music import (
@@ -68,6 +70,11 @@ class MeiParser(object):
         self.parts = (
             None  # parts get initialized in create_parts() and filled in fill_parts()
         )
+        # find the music tag inside the document
+        music_el = self.document.findall(self._ns_name("music", all=True))
+        if len(music_el) != 1:
+            raise Exception("Only MEI with a single <music> element are supported")
+        self.music_el = music_el[0]
         self.repetitions = (
             []
         )  # to be filled when we encounter repetitions and process in the end
@@ -78,20 +85,21 @@ class MeiParser(object):
 
     def create_parts(self):
         # handle main scoreDef info: create the part list
-        main_partgroup_el = self.document.find(self._ns_name("staffGrp", all=True))
+        main_partgroup_el = self.music_el.find(self._ns_name("staffGrp", all=True))
         self.parts = self._handle_main_staff_group(main_partgroup_el)
 
     def fill_parts(self):
         # fill parts with the content of the score
-        scores_el = self.document.findall(self._ns_name("score", all=True))
+        scores_el = self.music_el.findall(self._ns_name("score", all=True))
         if len(scores_el) != 1:
             raise Exception("Only MEI with a single score element are supported")
         sections_el = scores_el[0].findall(self._ns_name("section"))
         position = 0
+        measure_number = 1
         for section_el in sections_el:
             # insert in parts all elements except ties
-            position = self._handle_section(
-                section_el, list(score.iter_parts(self.parts)), position
+            position, measure_number = self._handle_section(
+                section_el, list(score.iter_parts(self.parts)), position, measure_number
             )
 
         # handles ties
@@ -351,27 +359,39 @@ class MeiParser(object):
         self._handle_clef(staffdef_el, position, part)
 
     def _intsymdur_from_symbolic(self, symbolic_dur):
-        """Produce a int symbolic dur (e.g. 12 is a eight note triplet) and a dot number by looking at the symbolic dur dictionary:
-        i.e., symbol, eventual tuplet ancestors."""
+        """Produce a int symbolic dur (e.g. 8 is a eight note), a dot number, and a tuplet modifier,
+        e.g., (2,3) means there are 3 notes in the space of 2 notes."""
         intsymdur = SYMBOLIC_TO_INT_DURS[symbolic_dur["type"]]
         # deals with tuplets
         if symbolic_dur.get("actual_notes") is not None:
             assert symbolic_dur.get("normal_notes") is not None
-            intsymdur = (
-                intsymdur * symbolic_dur["actual_notes"] / symbolic_dur["normal_notes"]
+            # intsymdur = (
+            #     intsymdur * symbolic_dur["actual_notes"] / symbolic_dur["normal_notes"]
+            # )
+            tuplet_modifier = (
+                symbolic_dur["normal_notes"],
+                symbolic_dur["actual_notes"],
             )
+        else:
+            tuplet_modifier = None
         # deals with dots
         dots = symbolic_dur.get("dots") if symbolic_dur.get("dots") is not None else 0
-        return intsymdur, dots
+        return intsymdur, dots, tuplet_modifier
 
     def _find_ppq(self):
         """Finds the ppq for MEI filed that do not explicitely encode this information"""
-        els_with_dur = self.document.xpath(".//*[@dur]")
+        els_with_dur = self.music_el.xpath(".//*[@dur]")
         durs = []
         durs_ppq = []
         for el in els_with_dur:
             symbolic_duration = self._get_symbolic_duration(el)
-            intsymdur, dots = self._intsymdur_from_symbolic(symbolic_duration)
+            intsymdur, dots, tuplet_mod = self._intsymdur_from_symbolic(
+                symbolic_duration
+            )
+            if tuplet_mod is not None:
+                # consider time modifications keeping the numerator of the minimized fraction
+                minimized_fraction = Fraction(intsymdur * tuplet_mod[1], tuplet_mod[0])
+                intsymdur = minimized_fraction.numerator
             # double the value if we have dots, to be sure be able to encode that with integers in partitura
             durs.append(intsymdur * (2**dots))
             durs_ppq.append(
@@ -574,9 +594,16 @@ class MeiParser(object):
             duration = 0 if el.get("grace") is not None else int(el.get("dur.ppq"))
         else:
             # compute the duration from the symbolic duration
-            intsymdur, dots = self._intsymdur_from_symbolic(symbolic_duration)
+            intsymdur, dots, tuplet_mod = self._intsymdur_from_symbolic(
+                symbolic_duration
+            )
             divs = part._quarter_durations[0]  # divs is the same as ppq
-            duration = divs * 4 / intsymdur
+            if tuplet_mod is None:
+                tuplet_mod = (
+                    1,
+                    1,
+                )  # if no tuplet modifier, set one that does not change the duration
+            duration = (divs * 4 * tuplet_mod[0]) / (intsymdur * tuplet_mod[1])
             for d in range(dots):
                 duration = duration + 0.5 * duration
             # sanity check to verify the divs are correctly set
@@ -728,6 +755,55 @@ class MeiParser(object):
         )
         # add mrest to the part
         part.add(rest, position, position + parts_per_measure)
+        # return duration to update the position in the layer
+        return position + parts_per_measure
+
+    def _handle_multirest(self, multirest_el, position, voice, staff, part):
+        """
+        Handles a rest that spawn multiple measures
+
+        Parameters
+        ----------
+        multirest_el : lxml tree
+            A mrest element in the lxml tree.
+        position : int
+            The current position on the timeline.
+        voice : int
+            The voice of the section.
+        staff : int
+            The current staff also refers to a Part.
+        part : Partitura.Part
+            The created part to add elements to.
+
+        Returns
+        -------
+        position + duration : int
+            Next position on the timeline.
+        """
+        # find id
+        multirest_id = multirest_el.attrib[self._ns_name("id", XML_NAMESPACE)]
+        # find how many measures
+        n_measures = int(multirest_el.attrib["num"])
+        if n_measures > 1:
+            raise Exception(
+                f"Multi-rests with more than 1 measure are not supported yet. Found one with {n_measures}."
+            )
+        # find closest time signature
+        last_ts = list(part.iter_all(cls=score.TimeSignature))[-1]
+        # find divs per measure
+        ppq = part.quarter_duration_map(position)
+        parts_per_measure = int(ppq * 4 * last_ts.beats / last_ts.beat_type)
+
+        # create dummy rest to insert in the timeline
+        rest = score.Rest(
+            id=multirest_id,
+            voice=voice,
+            staff=1,
+            symbolic_duration=estimate_symbolic_duration(parts_per_measure, ppq),
+            articulations=None,
+        )
+        # add mrest to the part
+        part.add(rest, position, position + parts_per_measure)
         # now iterate
         # return duration to update the position in the layer
         return position + parts_per_measure
@@ -780,7 +856,20 @@ class MeiParser(object):
 
     def _handle_space(self, e, position, part):
         """Moves current position."""
-        space_id, duration, symbolic_duration = self._duration_info(e, part)
+        try:
+            space_id, duration, symbolic_duration = self._duration_info(e, part)
+        except (
+            KeyError
+        ):  # if the space don't have a duration, move to the end of the measure
+            # find closest time signature
+            last_ts = list(part.iter_all(cls=score.TimeSignature))[-1]
+            # find divs per measure
+            ppq = part.quarter_duration_map(position)
+            parts_per_measure = int(ppq * 4 * last_ts.beats / last_ts.beat_type)
+            # find divs elapsed since last barline
+            last_barline = list(part.iter_all(cls=pt.score.Measure))[-1]
+            duration = position - last_barline.start.t
+
         return position + duration
 
     def _handle_barline_symbols(self, measure_el, position: int, left_or_right: str):
@@ -823,6 +912,12 @@ class MeiParser(object):
                 new_position = self._handle_mrest(
                     e, position, ind_layer, ind_staff, part
                 )
+            elif e.tag == self._ns_name(
+                "multiRest"
+            ):  # rest that spawn more than one measure
+                new_position = self._handle_multirest(
+                    e, position, ind_layer, ind_staff, part
+                )
             elif e.tag == self._ns_name("beam"):
                 # TODO : add Beam element
                 # recursive call to the elements inside beam
@@ -846,7 +941,14 @@ class MeiParser(object):
             position = new_position
         return position
 
-    def _handle_staff_in_measure(self, staff_el, staff_ind, position: int, part):
+    def _handle_staff_in_measure(
+        self,
+        staff_el,
+        staff_ind,
+        position: int,
+        part: pt.score.Part,
+        measure_number: int,
+    ):
         """
         Handles staffs inside a measure element.
 
@@ -860,6 +962,9 @@ class MeiParser(object):
             The current position on the timeline.
         part : Partitura.Part
             The created partitura part object.
+        measure_number : int
+            The number of the measure. This number is independent of the measure name specified in the score.
+            It starts from 1 and always increases by 1 at each measure
 
         Returns
         -------
@@ -867,7 +972,9 @@ class MeiParser(object):
             The final position on the timeline.
         """
         # add measure
-        measure = score.Measure(number=staff_el.getparent().get("n"))
+        measure = score.Measure(
+            number=measure_number, name=staff_el.getparent().get("n")
+        )
         part.add(measure, position)
 
         layers_el = staff_el.findall(self._ns_name("layer"))
@@ -921,7 +1028,7 @@ class MeiParser(object):
         for dir_el in dir_els:
             self._handle_dir_element(dir_el, position)
 
-    def _handle_section(self, section_el, parts, position: int):
+    def _handle_section(self, section_el, parts, position: int, measure_number: int):
         """
         Returns position and fills parts with elements.
 
@@ -933,11 +1040,15 @@ class MeiParser(object):
             A list of partitura Parts.
         position : int
             The current position on the timeline.
+        measure_number : int
+            The current measure_number
 
         Returns
         -------
         position : int
             The end position of the section.
+        measure_number : int
+            The number of the last measure.
         """
         for i_el, element in enumerate(section_el):
             # handle measures
@@ -951,7 +1062,9 @@ class MeiParser(object):
                 end_positions = []
                 for i_s, (part, staff_el) in enumerate(zip(parts, staves_el)):
                     end_positions.append(
-                        self._handle_staff_in_measure(staff_el, i_s + 1, position, part)
+                        self._handle_staff_in_measure(
+                            staff_el, i_s + 1, position, part, measure_number
+                        )
                     )
                 # handle directives (dir elements)
                 self._handle_directives(element, position)
@@ -961,19 +1074,19 @@ class MeiParser(object):
                     warnings.warn(
                         f"Warning : parts have measures of different duration in measure {element.attrib[self._ns_name('id',XML_NAMESPACE)]}"
                     )
-                    # enlarge measures to the max
-                    for part in parts:
-                        last_measure = list(part.iter_all(pt.score.Measure))[-1]
-                        if last_measure.end.t != max_position:
-                            part.add(
-                                pt.score.Measure(number=last_measure.number),
-                                position,
-                                max_position,
-                            )
-                            part.remove(last_measure)
+                    # # enlarge measures to the max
+                    # for part in parts:
+                    #     last_measure = list(part.iter_all(pt.score.Measure))[-1]
+                    #     if last_measure.end.t != max_position:
+                    #         part.add(
+                    #             pt.score.Measure(number=last_measure.number),
+                    #             max_position
+                    #         )
+                    #         part.remove(last_measure)
                 position = max_position
                 # handle right barline symbol
                 self._handle_barline_symbols(element, position, "right")
+                measure_number += 1
             # handle staffDef elements
             elif element.tag == self._ns_name("scoreDef"):
                 # meter modifications
@@ -990,10 +1103,14 @@ class MeiParser(object):
                         self._handle_keysig(element, position, part)
             # handle nested section
             elif element.tag == self._ns_name("section"):
-                position = self._handle_section(element, parts, position)
+                position, measure_number = self._handle_section(
+                    element, parts, position, measure_number
+                )
             elif element.tag == self._ns_name("ending"):
                 ending_start = position
-                position = self._handle_section(element, parts, position)
+                position, measure_number = self._handle_section(
+                    element, parts, position, measure_number
+                )
                 # insert the ending element
                 ending_number = int(re.sub("[^0-9]", "", element.attrib["n"]))
                 self._add_ending(ending_start, position, ending_number, parts)
@@ -1009,7 +1126,7 @@ class MeiParser(object):
             else:
                 raise Exception(f"element {element.tag} is not yet supported")
 
-        return position
+        return position, measure_number
 
     def _add_ending(self, start_ending, end_ending, ending_string, parts):
         for part in score.iter_parts(parts):
@@ -1024,7 +1141,7 @@ class MeiParser(object):
         all_notes = [
             note
             for part in score.iter_parts(part_list)
-            for note in part.iter_all(cls=score.Note)
+            for note in part.iter_all(cls=score.Note, include_subclasses=True)
         ]
         all_notes_dict = {note.id: note for note in all_notes}
         for tie_el in ties_el:
@@ -1052,6 +1169,7 @@ class MeiParser(object):
                 "WARNING : unmatched repetitions. adding a repetition start at position 0"
             )
             self.repetitions.insert(0, {"type": "start", "pos": 0})
+
         status = "stop"
         sanitized_repetition_list = []
         # check if start-stop are alternate
@@ -1082,11 +1200,19 @@ class MeiParser(object):
         # check if ending with a start
         if sanitized_repetition_list[-1] == "start":
             print("WARNING : unmatched repetitions. Ignoring last start")
+        ## sanitize the found repetitions to remove duplicates
+        sanitized_repetition_list = list(
+            OrderedDict(
+                (tuple(d.items()), d) for d in sanitized_repetition_list
+            ).values()
+        )
         self.repetitions = sanitized_repetition_list
 
         ## insert the repetitions to all parts
         for rep_start, rep_stop in zip(self.repetitions[:-1:2], self.repetitions[1::2]):
-            assert rep_start["type"] == "start" and rep_stop["type"] == "stop"
+            assert (
+                rep_start["type"] == "start" and rep_stop["type"] == "stop"
+            ), "Something wrong with repetitions"
             for part in score.iter_parts(self.parts):
                 part.add(score.Repeat(), rep_start["pos"], rep_stop["pos"])
 

partitura/io/importmidi.py

@@ -183,11 +183,10 @@ def load_performance_midi(
                 # end note if it's a 'note off' event or 'note on' with velocity 0
                 elif note_off or (note_on and msg.velocity == 0):
                     if note not in sounding_notes:
-                        warnings.warn("ignoring MIDI message %s" % msg)
+                        warnings.warn(f"ignoring MIDI message {msg}")
                         continue
 
                     # append the note to the list associated with the channel
-
                     notes.append(
                         dict(
                             # id=f"n{len(notes)}",
@@ -473,6 +472,28 @@ or a list of these
     else:
         note_ids = [None for i in range(len(note_array))]
 
+    ## sanitize time signature, when they are only present in one track, and no global is set
+    # find the number of ts per each track
+    number_of_time_sig_per_track = [
+        len(time_sigs_by_track[t]) for t in key_sigs_by_track.keys()
+    ]
+    # if one track has 0 ts, and another has !=0 ts, and no global_time_sigs is present, sanitize
+    # all key signatures are copied to global, and the track ts are removed
+    if (
+        len(global_time_sigs) == 0
+        and min(number_of_time_sig_per_track) == 0
+        and max(number_of_time_sig_per_track) != 0
+    ):
+        warnings.warn(
+            "Sanitizing time signatures. They will be shared across all tracks."
+        )
+        for ts in [
+            ts for ts_track in time_sigs_by_track.values() for ts in ts_track
+        ]:  # flattening all track time signatures to a list of ts
+            global_time_sigs.append(ts)
+        # now clear all track_ts
+        time_sigs_by_track.clear()
+
     time_sigs_by_part = defaultdict(set)
     for tr, ts_list in time_sigs_by_track.items():
         for ts in ts_list:

partitura/io/importmusicxml.py

@@ -60,6 +60,22 @@ PEDAL_DIRECTIONS = {
     "sustain_pedal": score.SustainPedalDirection,
 }
 
+TEMPO_DIRECTIONS = {
+    "Adagio": score.ConstantTempoDirection,
+    "Andante": score.ConstantTempoDirection,
+    "Andante amoroso": score.ConstantTempoDirection,
+    "Andante cantabile": score.ConstantTempoDirection,
+    "Andante grazioso": score.ConstantTempoDirection,
+    "Menuetto": score.ConstantTempoDirection,
+    "Allegretto grazioso": score.ConstantTempoDirection,
+    "Allegro moderato": score.ConstantTempoDirection,
+    "Allegro assai": score.ConstantTempoDirection,
+    "Allegro": score.ConstantTempoDirection,
+    "Allegretto": score.ConstantTempoDirection,
+    "Molto allegro": score.ConstantTempoDirection,
+    "Presto": score.ConstantTempoDirection,
+}
+
 OCTAVE_SHIFTS = {8: 1, 15: 2, 22: 3}
 
 
@@ -114,7 +130,6 @@ def _parse_partlist(partlist):
     structure = []
     current_group = None
     part_dict = {}
-
     for e in partlist:
         if e.tag == "part-group":
             if e.get("type") == "start":
@@ -146,7 +161,6 @@ def _parse_partlist(partlist):
             part.part_abbreviation = next(
                 iter(e.xpath("part-abbreviation/text()")), None
             )
-
             part_dict[part_id] = part
 
             if current_group is None:
@@ -239,6 +253,10 @@ def load_musicxml(
 
     composer = None
     scid = None
+    work_title = None
+    work_number = None
+    movement_title = None
+    movement_number = None
     title = None
     subtitle = None
     lyricist = None
@@ -254,8 +272,20 @@ def load_musicxml(
             tag="work-title",
             as_type=str,
         )
+        scidn = get_value_from_tag(
+            e=work_info_el,
+            tag="work-number",
+            as_type=str,
+        )
+        work_title = scid
+        work_number = scidn
 
-        title = scid
+    movement_title_el = document.find(".//movement-title")
+    movement_number_el = document.find(".//movement-number")
+    if movement_title_el is not None:
+        movement_title = movement_title_el.text
+    if movement_number_el is not None:
+        movement_number = movement_number_el.text
 
     score_identification_el = document.find("identification")
 
@@ -289,6 +319,10 @@ def load_musicxml(
     scr = score.Score(
         id=scid,
         partlist=partlist,
+        work_number=work_number,
+        work_title=work_title,
+        movement_number=movement_number,
+        movement_title=movement_title,
         title=title,
         subtitle=subtitle,
         composer=composer,
@@ -841,8 +875,9 @@ def _handle_direction(e, position, part, ongoing):
             # first child of direction-type is dynamics, there may be subsequent
             # dynamics items, so we loop:
             for child in direction_type:
+                # check if child has no children, in which case continue
                 # interpret as score.Direction, fall back to score.Words
-                dyn_el = next(iter(child))
+                dyn_el = next(iter(child), None)
                 if dyn_el is not None:
                     direction = DYN_DIRECTIONS.get(dyn_el.tag, score.Words)(
                         dyn_el.tag, staff=staff
@@ -1137,7 +1172,7 @@ def _handle_sound(e, position, part):
     if "tempo" in e.attrib:
         tempo = score.Tempo(int(e.attrib["tempo"]), "q")
         # part.add_starting_object(position, tempo)
-        _add_tempo_if_unique(position, part, tempo)
+        (position, part, tempo)
 
 
 def _handle_note(e, position, part, ongoing, prev_note, doc_order):

partitura/io/matchfile_utils.py

@@ -871,6 +871,35 @@ def format_time_signature_list(value: MatchTimeSignature) -> str:
     return str(value)
 
 
+class MatchTempoIndication(MatchParameter):
+    def __init__(
+        self,
+        value: str,
+        is_list: bool = False,
+    ):
+        super().__init__()
+        self.value = self.from_string(value)[0]
+        self.is_list = is_list
+
+    def __str__(self):
+        return self.value
+
+    @classmethod
+    def from_string(cls, string: str) -> MatchTempoIndication:
+        content = interpret_as_list(string)
+        return content
+
+
+def interpret_as_tempo_indication(value: str) -> MatchTempoIndication:
+    tempo_indication = MatchTempoIndication.from_string(value)
+    return tempo_indication
+
+
+def format_tempo_indication(value: MatchTempoIndication) -> str:
+    value.is_list = False
+    return str(value)
+
+
 ## Miscellaneous utils
 
 

partitura/io/matchlines_v1.py

@@ -58,6 +58,9 @@ from partitura.io.matchfile_utils import (
     format_key_signature_v1_0_0,
     to_snake_case,
     get_kwargs_from_matchline,
+    MatchTempoIndication,
+    interpret_as_tempo_indication,
+    format_tempo_indication,
 )
 
 # Define current version of the match file format
@@ -237,6 +240,11 @@ SCOREPROP_LINE = {
             format_key_signature_v1_0_0,
             MatchKeySignature,
         ),
+        "tempoIndication": (
+            interpret_as_tempo_indication,
+            format_tempo_indication,
+            MatchTempoIndication,
+        ),
         "beatSubDivision": (interpret_as_list_int, format_list, list),
         "directions": (interpret_as_list, format_list, list),
     }