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

partitura/score.py

@@ -9,14 +9,14 @@ object). This object serves as a timeline at which musical elements
 are registered in terms of their start and end times.
 """
 
-from copy import copy
+from copy import copy, deepcopy
 from collections import defaultdict
 from collections.abc import Iterable
 from numbers import Number
 
 # import copy
 from partitura.utils.music import MUSICAL_BEATS, INTERVALCLASSES
-import warnings
+import warnings, sys
 import numpy as np
 from scipy.interpolate import PPoly
 from typing import Union, List, Optional, Iterator, Iterable as Itertype
@@ -282,7 +282,7 @@ class Part(object):
         """
         # operations to avoid None values and filter them efficiently.
         m_it = self.measures
-        
+
         measures = np.array(
             [
                 [
@@ -387,7 +387,6 @@ class Part(object):
             return int_interp1d
 
     def _time_interpolator(self, quarter=False, inv=False, musical_beat=False):
-
         if len(self._points) < 2:
             return lambda x: np.zeros(len(x))
 
@@ -434,13 +433,11 @@ class Part(object):
         m1 = next(self.first_point.iter_starting(Measure), None)
 
         if m1 and m1.start is not None and m1.end is not None:
-
             f = interp1d(x, y)
             actual_dur = np.diff(f((m1.start.t, m1.end.t)))[0]
             ts = next(m1.start.iter_starting(TimeSignature), None)
 
             if ts:
-
                 normal_dur = ts.beats
                 if quarter:
                     normal_dur *= 4 / ts.beat_type
@@ -618,6 +615,18 @@ class Part(object):
         """
         return [e for e in self.iter_all(LoudnessDirection, include_subclasses=True)]
 
+    @property
+    def tempo_directions(self):
+        """Return a list of all tempo direction in the part
+
+        Returns
+        -------
+        list
+            List of TempoDirection objects
+
+        """
+        return [e for e in self.iter_all(TempoDirection, include_subclasses=True)]
+
     @property
     def articulations(self):
         """Return a list of all Articulation markings in the part
@@ -643,9 +652,7 @@ class Part(object):
 
         """
         add_segments(self)
-        return [
-            e for e in self.iter_all(Segment, include_subclasses=False)
-        ]
+        return [e for e in self.iter_all(Segment, include_subclasses=False)]
 
     def quarter_durations(self, start=None, end=None):
         """Return an Nx2 array with quarter duration (second column)
@@ -1459,7 +1466,6 @@ class TimePoint(ComparableMixin):
         ]
 
         if ending_items:
-
             result.append("{}".format(tree).rstrip())
 
             if starting_items:
@@ -1472,7 +1478,6 @@ class TimePoint(ComparableMixin):
             result.append("{}".format(tree).rstrip())
 
             for i, item in enumerate(ending_items):
-
                 if i == (len(ending_items) - 1):
                     tree.last_item()
                 else:
@@ -1483,7 +1488,6 @@ class TimePoint(ComparableMixin):
             tree.pop()
 
         if starting_items:
-
             result.append("{}".format(tree).rstrip())
             tree.last_item()
             result.append("{}starting objects".format(tree))
@@ -1491,7 +1495,6 @@ class TimePoint(ComparableMixin):
             result.append("{}".format(tree).rstrip())
 
             for i, item in enumerate(starting_items):
-
                 if i == (len(starting_items) - 1):
                     tree.last_item()
                 else:
@@ -2160,7 +2163,6 @@ class Clef(TimedObject):
     """
 
     def __init__(self, staff, sign, line, octave_change):
-
         super().__init__()
         self.staff = staff
         self.sign = sign
@@ -2572,7 +2574,6 @@ class Staff(TimedObject):
         return f"{super().__str__()} number={self.number} lines={self.lines}"
 
 
-
 class KeySignature(TimedObject):
     """Key signature.
 
@@ -2677,7 +2678,6 @@ class Words(TimedObject):
         return f'{super().__str__()} "{self.text}"'
 
 
-
 class OctaveShiftDirection(TimedObject):
     """An octave shift direction.
 
@@ -2685,6 +2685,7 @@ class OctaveShiftDirection(TimedObject):
     ----------
 
     """
+
     def __init__(self, shift_type, shift_size=8, staff=None):
         super().__init__()
         self.shift_type = shift_type
@@ -2699,16 +2700,16 @@ class OctaveShiftDirection(TimedObject):
 class Harmony(TimedObject):
     """A harmony element in the score not currently used.
 
-        Parameters
-        ----------
-        text : str
-            The harmony text
+    Parameters
+    ----------
+    text : str
+        The harmony text
 
-        Attributes
-        ----------
-        text : str
-            See parameters
-        """
+    Attributes
+    ----------
+    text : str
+        See parameters
+    """
 
     def __init__(self, text):
         super().__init__()
@@ -2744,6 +2745,7 @@ class RomanNumeral(TimedObject):
 
 class ChordSymbol(TimedObject):
     """A harmony element in the score usually for Chord Symbols."""
+
     def __init__(self, root, kind, bass=None):
         super().__init__()
         self.kind = kind
@@ -2767,6 +2769,7 @@ class Interval(object):
     direction : str
         The interval direction (e.g. up, down)
     """
+
     def __init__(self, number, quality, direction="up"):
         self.number = number
         self.quality = quality
@@ -2776,8 +2779,13 @@ class Interval(object):
     def validate(self):
         number = self.number % 7
         number = 7 if number == 0 else number
-        assert self.quality+str(number) in INTERVALCLASSES, f"Interval {number}{self.quality} not found"
-        assert self.direction in ["up", "down"], f"Interval direction {self.direction} not found"
+        assert (
+            self.quality + str(number) in INTERVALCLASSES
+        ), f"Interval {number}{self.quality} not found"
+        assert self.direction in [
+            "up",
+            "down",
+        ], f"Interval direction {self.direction} not found"
 
     def __str__(self):
         return f'{super().__str__()} "{self.number}{self.quality}"'
@@ -2994,8 +3002,16 @@ class Score(object):
         the identifier should not start with a number.
     partlist : `Part`, `PartGroup` or list of `Part` or `PartGroup` instances.
         List of  `Part` or `PartGroup` objects.
-    title: str, optional
-        Title of the score.
+    work_title: str, optional
+        Work title of the score, if applicable.
+    work_number: str, optional
+        Work number of the score, if applicable.
+    movement_title: str, optional
+        Movement title of the score, if applicable.
+    movement_number: str, optional
+        Movement number of the score, if applicable.
+    title : str, optional
+        Title of the score, from <credit-words> tag
     subtitle: str, optional
         Subtitle of the score.
     composer: str, optional
@@ -3014,7 +3030,13 @@ class Score(object):
     part_structure: list of `Part` or `PartGrop`
         List of all `Part` or `PartGroup` objects that specify the structure of
         the score.
-     title: str
+    work_title: str
+        See parameters.
+    work_number: str
+        See parameters.
+    movement_title: str
+        See parameters.
+    movement_number: str
         See parameters.
     subtitle: str
         See parameters.
@@ -3028,6 +3050,10 @@ class Score(object):
     """
 
     id: Optional[str]
+    work_title: Optional[str]
+    work_number: Optional[str]
+    movement_title: Optional[str]
+    movement_number: Optional[str]
     title: Optional[str]
     subtitle: Optional[str]
     composer: Optional[str]
@@ -3040,6 +3066,10 @@ class Score(object):
         self,
         partlist: Union[Part, PartGroup, Itertype[Union[Part, PartGroup]]],
         id: Optional[str] = None,
+        work_title: Optional[str] = None,
+        work_number: Optional[str] = None,
+        movement_title: Optional[str] = None,
+        movement_number: Optional[str] = None,
         title: Optional[str] = None,
         subtitle: Optional[str] = None,
         composer: Optional[str] = None,
@@ -3049,6 +3079,10 @@ class Score(object):
         self.id = id
 
         # Score Information (default from MuseScore/MusicXML)
+        self.work_title = work_title
+        self.work_number = work_number
+        self.movement_title = movement_title
+        self.movement_number = movement_number
         self.title = title
         self.subtitle = subtitle
         self.composer = composer
@@ -3181,7 +3215,6 @@ class ScoreVariant(object):
                 tp_new = part.get_or_add_point(tp.t + delta)
                 o_gen = (o for oo in tp.starting_objects.values() for o in oo)
                 for o in o_gen:
-
                     # special cases:
 
                     # don't include some TimedObjects in the unfolded part
@@ -3326,7 +3359,6 @@ def add_measures(part):
         pos = ts_start
 
         while pos < ts_end:
-
             measure_start = pos
             measure_end_beats = min(beat_map(pos) + measure_dur, beat_map(end))
             measure_end = min(ts_end, inv_beat_map(measure_end_beats))
@@ -3348,7 +3380,11 @@ def add_measures(part):
                 else:
                     measure_end = existing_measure.start.t
 
-            part.add(Measure(number=mcounter, name=str(mcounter)), int(measure_start), int(measure_end))
+            part.add(
+                Measure(number=mcounter, name=str(mcounter)),
+                int(measure_start),
+                int(measure_end),
+            )
 
             # if measure exists but was not at measure_start,
             # a filler measure is added with number mcounter
@@ -3586,7 +3622,6 @@ def tie_notes(part):
     succeeded = 0
     for i, note in enumerate(list(part.iter_all(Note))):
         if note.symbolic_duration is None:
-
             splits = find_tie_split(
                 note.start.t, note.end.t, int(divs_map(note.start.t)), max_splits
             )
@@ -3626,29 +3661,22 @@ def _set_end_times(part, cls):
     t = None
 
     for obj in part.iter_all(cls, include_subclasses=True):
-
         if obj.start == t:
-
             if obj.end is None:
-
                 acc.append(obj)
 
         else:
-
             for o in acc:
-
                 part.add(o, end=obj.start.t)
 
             acc = []
 
             if obj.end is None:
-
                 acc.append(obj)
 
             t = obj.start
 
     for o in acc:
-
         part.add(o, end=part.last_point.t)
 
 
@@ -3728,7 +3756,6 @@ def find_tuplets(part):
 
     # 1. group consecutive notes without symbolic_duration
     for note in part.iter_all(GenericNote, include_subclasses=True):
-
         if note.symbolic_duration is None:
             if note.start.t == prev_end:
                 candidates[-1].append(note)
@@ -3738,10 +3765,8 @@ def find_tuplets(part):
 
     # 2. within each group
     for group in candidates:
-
         # 3. search for the predefined list of tuplets
         for actual_notes in search_for_tuplets:
-
             if actual_notes > len(group):
                 # tuplet requires more notes than we have
                 continue
@@ -3759,7 +3784,6 @@ def find_tuplets(part):
                     # continue
                     tup_start += 1
                 else:
-
                     start = note_tuplet[0].start.t
                     end = note_tuplet[-1].end.t
                     total_dur = end - start
@@ -3813,7 +3837,6 @@ def sanitize_part(part, tie_tolerance=0):
             for no in part.iter_all(
                 Note, include_subclasses=False, start=gn.start.t, end=gn.start.t + 1
             ):
-
                 if no.voice == gn.voice:
                     gn.last_grace_note_in_seq.grace_next = no
 
@@ -4004,7 +4027,6 @@ def add_segments(part):
 
             # loop through the boundaries at the end of current segment
             for boundary_type in boundaries[se].keys():
-
                 # REPEATS
                 if boundary_type == "repeat_start":
                     segment_info[ss]["to"].append(segment_info[se]["ID"])
@@ -4073,7 +4095,7 @@ def add_segments(part):
                         )
 
                 # NAVIGATION SYMBOLS
-                
+
                 # Navigation1_ = destinations that should only be used after all others
                 # Navigation2_ = destinations that are used *after* a jump
                 if boundary_type == "coda":
@@ -4103,10 +4125,10 @@ def add_segments(part):
                     # find the segno and jump there
                     segno_time = destinations["segno"][0]
                     segment_info[ss]["to"].append(
-                        "Navigation1_" + segment_info[segno_time]["ID"] 
+                        "Navigation1_" + segment_info[segno_time]["ID"]
                     )
                     segment_info[ss]["to"].append(
-                        "Navigation2_" + segment_info[se]["ID"] 
+                        "Navigation2_" + segment_info[se]["ID"]
                     )
                     segment_info[ss]["type"] = "leap_start"
                     segment_info[ss]["info"].append("dal segno")
@@ -4118,7 +4140,7 @@ def add_segments(part):
                         "Navigation1_" + segment_info[part.first_point.t]["ID"]
                     )
                     segment_info[ss]["to"].append(
-                        "Navigation2_" + segment_info[se]["ID"] 
+                        "Navigation2_" + segment_info[se]["ID"]
                     )
                     segment_info[ss]["type"] = "leap_start"
                     segment_info[ss]["info"].append("da capo")
@@ -4240,8 +4262,9 @@ def pretty_segments(part):
             + str(part.beat_map(segments[p].end.t))
         )
         + "\t duration: "
-        + "{:<6}".format(str(part.beat_map(segments[p].end.t) - \
-                             part.beat_map(segments[p].start.t)))
+        + "{:<6}".format(
+            str(part.beat_map(segments[p].end.t) - part.beat_map(segments[p].start.t))
+        )
         + "\t info: "
         + str(segments[p].info)
         for p in segments.keys()
@@ -4279,7 +4302,6 @@ class Path:
         all_repeats=False,
         jumped=False,
     ):
-
         self.path = path_list
         self.segments = segments
         if used_segment_jumps is None:
@@ -4353,7 +4375,7 @@ class Path:
         for key in self.used_segment_jumps:
             for used_dest in self.used_segment_jumps[key]:
                 new_path.used_segment_jumps[key].append(used_dest)
-        
+
         return new_path
 
     def make_copy_with_jump_to(self, destination, ignore_leap_info=True):
@@ -4366,7 +4388,7 @@ class Path:
         new_path = self.copy()
         new_path.used_segment_jumps[new_path.path[-1]].append(destination)
         new_path.path.append(destination)
-        
+
         if (
             new_path.segments[destination].type == "leap_end"
             and new_path.segments[new_path.path[-2]].type == "leap_start"
@@ -4386,25 +4408,25 @@ class Path:
                     # delete used destinations
                     new_path.used_segment_jumps[segid] = list()
                 # add the jump destination to the used ones
-                new_path.used_segment_jumps[new_path.path[-2]].append(destination)      
-                        
+                new_path.used_segment_jumps[new_path.path[-2]].append(destination)
+
             if not ignore_leap_info:
                 new_path.no_repeats = True
         return new_path
 
     @property
-    def list_of_destinations_from_last_segment(self):    
+    def list_of_destinations_from_last_segment(self):
         destinations = list(self.segments[self.path[-1]].to)
         previously_used_destinations = self.used_segment_jumps[self.path[-1]]
         # only continue in order of the sequence, after full consumption, start at zero
         # if the full or minimal sequence is forced,
         # return only the single possible jump destination, else return possibly many.
-        
-        if len(previously_used_destinations) != 0:       
+
+        if len(previously_used_destinations) != 0:
             last_destination = previously_used_destinations[-1]
             last_destination_count = previously_used_destinations.count(
                 last_destination
-            )               
+            )
             last_destination_index = [
                 i for i, n in enumerate(destinations * 100) if n == last_destination
             ][last_destination_count - 1]
@@ -4604,15 +4626,15 @@ def iter_unfolded_parts(part, update_ids=True):
 
 
 # UPDATED VERSION
-def unfold_part_maximal(part, update_ids=True, ignore_leaps=True):
-    """Return the "maximally" unfolded part, that is, a copy of the
+def unfold_part_maximal(score: ScoreLike, update_ids=True, ignore_leaps=True):
+    """Return the "maximally" unfolded part/score, that is, a copy of the
     part where all segments marked with repeat signs are included
     twice.
 
     Parameters
     ----------
-    part : :class:`Part`
-        The Part to unfold.
+    score : ScoreLike
+        The Part/Score to unfold.
     update_ids : bool (optional)
         Update note ids to reflect the repetitions. Note IDs will have
         a '-<repetition number>', e.g., 'n132-1' and 'n132-2'
@@ -4625,19 +4647,75 @@ def unfold_part_maximal(part, update_ids=True, ignore_leaps=True):
 
     Returns
     -------
-    unfolded_part : :class:`Part`
-        The unfolded Part
+    unfolded_part : ScoreLike
+        The unfolded Part/Score
 
     """
+    if isinstance(score, Score):
+        # 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 = deepcopy(score)
+        # Reset recursion limit to previous value to avoid side effects
+        sys.setrecursionlimit(old_recursion_depth)
+        new_partlist = list()
+        for score in new_score.parts:
+            unfolded_part = unfold_part_maximal(
+                score, update_ids=update_ids, ignore_leaps=ignore_leaps
+            )
+            new_partlist.append(unfolded_part)
+        new_score.parts = new_partlist
+        return new_score
 
     paths = get_paths(
-        part, no_repeats=False, all_repeats=True, ignore_leap_info=ignore_leaps
+        score, no_repeats=False, all_repeats=True, ignore_leap_info=ignore_leaps
     )
 
-    unfolded_part = new_part_from_path(paths[0], part, update_ids=update_ids)
+    unfolded_part = new_part_from_path(paths[0], score, update_ids=update_ids)
     return unfolded_part
 
 
+def unfold_part_minimal(score: ScoreLike):
+    """Return the "minimally" unfolded score/part, that is, a copy of the
+    part where all segments marked with repeat are included only once.
+    For voltas only the last volta segment is included.
+    Note this might not be musically valid, e.g. a passing a "fine" even a first time will stop this unfolding.
+    Warning: The unfolding of repeats is computed part-wise, inconsistent repeat markings of parts of a single result
+    in inconsistent unfoldings.
+
+    Parameters
+    ----------
+    score: ScoreLike
+        The score/part to unfold.
+
+    Returns
+    -------
+    unfolded_score : ScoreLike
+        The unfolded Part
+
+    """
+    if isinstance(score, Score):
+        # Copy needs to be deep, otherwise the recursion limit will be exceeded
+        old_recursion_depth = sys.getrecursionlimit()
+        sys.setrecursionlimit(10000)
+        # Deep copy of score
+        unfolded_score = deepcopy(score)
+        # Reset recursion limit to previous value to avoid side effects
+        sys.setrecursionlimit(old_recursion_depth)
+        new_partlist = list()
+        for part in unfolded_score.parts:
+            unfolded_part = unfold_part_minimal(part)
+            new_partlist.append(unfolded_part)
+        unfolded_score.parts = new_partlist
+        return unfolded_score
+
+    paths = get_paths(score, no_repeats=True, all_repeats=False, ignore_leap_info=True)
+
+    unfolded_score = new_part_from_path(paths[0], score, update_ids=False)
+    return unfolded_score
+
+
 # UPDATED / UNCHANGED VERSION
 def unfold_part_alignment(part, alignment):
     """Return the unfolded part given an alignment, that is, a copy
@@ -4858,13 +4936,15 @@ def merge_parts(parts, reassign="voice"):
                         e.voice = e.voice + sum(maximum_voices[:p_ind])
                 elif reassign == "staff":
                     if isinstance(e, (GenericNote, Words, Direction)):
-
-                        e.staff = (e.staff if e.staff is not None else 1) + sum(maximum_staves[:p_ind])
+                        e.staff = (e.staff if e.staff is not None else 1) + sum(
+                            maximum_staves[:p_ind]
+                        )
                     elif isinstance(
                         e, Clef
                     ):  # TODO: to update if "number" get changed in "staff"
-
-                        e.staff = (e.staff if e.staff is not None else 1) + sum(maximum_staves[:p_ind])
+                        e.staff = (e.staff if e.staff is not None else 1) + sum(
+                            maximum_staves[:p_ind]
+                        )
                 new_part.add(e, start=new_start, end=new_end)
 
                 # new_part.add(copy.deepcopy(e), start=new_start, end=new_end)

partitura/utils/__init__.py

@@ -79,5 +79,5 @@ __all__ = [
     "show_diff",
     "PrettyPrintTree",
     "synthesize",
-    "normalize"
+    "normalize",
 ]

partitura/utils/generic.py

@@ -114,18 +114,15 @@ def iter_current_next(iterable, start=_sentinel, end=_sentinel):
 
     cur = start
     try:
-
         if cur is _sentinel:
             cur = next(iterable)
 
         while True:
-
             nxt = next(iterable)
             yield (cur, nxt)
             cur = nxt
 
     except StopIteration:
-
         if cur is not _sentinel and end is not _sentinel:
             yield (cur, end)
 
@@ -570,14 +567,12 @@ def interp1d(
         )
 
     else:
-
         # If there is only one value for x and y, assume that the method
         # will always return the same value for any input.
 
         def interp_fun(
             input_var: Union[float, int, np.ndarray]
         ) -> Callable[[Union[float, int, np.ndarray]], np.ndarray]:
-
             if y.ndim > 1:
                 result = np.broadcast_to(y, (len(np.atleast_1d(input_var)), y.shape[1]))
             else:
@@ -635,7 +630,7 @@ def monotonize_times(
     s_mono: np.ndarray
        a monotonic sequence that has been linearly interpolated using a subset of s
     x_mono: np.ndarray
-        The input of the monotonic sequence. 
+        The input of the monotonic sequence.
     """
     eps = np.finfo(float).eps
 
@@ -649,9 +644,10 @@ def monotonize_times(
     mask = np.r_[False, True, (np.diff(s_mono) != 0), False]
     x_mono = _x[1:-1]
     s_mono = interp1d(_x[mask], _s[mask], fill_value="extrapolate")(x_mono)
-    
+
     return s_mono, x_mono
 
+
 if __name__ == "__main__":
     import doctest
 

partitura/utils/misc.py

@@ -239,7 +239,6 @@ def concatenate_images(
     anchor_x = 0
     anchor_y = 0
     for img, size in zip(images, image_sizes):
-
         new_image.paste(img, (anchor_x, anchor_y))
 
         # update coordinates according to the concatenation mode