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

partitura/io/musescore.py

@@ -36,38 +36,70 @@ class FileImportException(Exception):
     pass
 
 
-def find_musescore3():
-    # # possible way to detect MuseScore... executable
-    # for p in os.environ['PATH'].split(':'):
-    #     c = glob.glob(os.path.join(p, 'MuseScore*'))
-    #     if c:
-    #         print(c)
-    #         break
-
-    result = shutil.which("musescore")
-
-    if result is None:
-        result = shutil.which("musescore3")
-
-    if result is None:
-        result = shutil.which("mscore")
-
+def find_musescore_version(version=4):
+    """Find the path to the MuseScore executable for a specific version.
+    If version is a empty string it tries to find an unspecified version of
+    MuseScore which is used in some systems.
+    """
+    result = shutil.which(f"musescore{version}")
     if result is None:
-        result = shutil.which("mscore3")
-
+        result = shutil.which(f"mscore{version}")
     if result is None:
         if platform.system() == "Linux":
             pass
-
         elif platform.system() == "Darwin":
-            result = shutil.which("/Applications/MuseScore 3.app/Contents/MacOS/mscore")
-
+            result = shutil.which(
+                f"/Applications/MuseScore {version}.app/Contents/MacOS/mscore"
+            )
         elif platform.system() == "Windows":
-            result = shutil.which(r"C:\Program Files\MuseScore 3\bin\MuseScore3.exe")
+            result = shutil.which(
+                rf"C:\Program Files\MuseScore {version}\bin\MuseScore{version}.exe"
+            )
 
     return result
 
 
+def find_musescore():
+    """Find the path to the MuseScore executable.
+
+    This function first tries to find the executable for MuseScore 4,
+    then for MuseScore 3, and finally for any version of MuseScore.
+
+    Returns
+    -------
+    str
+        Path to the MuseScore executable
+
+    Raises
+    ------
+    MuseScoreNotFoundException
+        When no MuseScore executable was found
+    """
+
+    mscore_exec = find_musescore_version(version=4)
+    if not mscore_exec:
+        mscore_exec = find_musescore_version(version=3)
+        if mscore_exec:
+            warnings.warn(
+                "Only Musescore 3 is installed. Consider upgrading to musescore 4."
+            )
+        else:
+            mscore_exec = find_musescore_version(version="")
+            if mscore_exec:
+                warnings.warn(
+                    "A unspecified version of MuseScore was found. Consider upgrading to musescore 4."
+                )
+            else:
+                raise MuseScoreNotFoundException()
+    # check if a screen is available (only on Linux)
+    if "DISPLAY" not in os.environ and platform.system() == "Linux":
+        raise MuseScoreNotFoundException(
+            "Musescore Executable was found, but a screen is missing. Musescore needs a screen to load scores"
+        )
+
+    return mscore_exec
+
+
 @deprecated_alias(fn="filename")
 @deprecated_parameter("ensure_list")
 def load_via_musescore(
@@ -103,15 +135,22 @@ or a list of these
         One or more part or partgroup objects
 
     """
+    if filename.endswith(".mscz"):
+        pass
+    else:
+        # open the file as text and check if the first symbol is "<" to avoid
+        # further processing in case of non-XML files
+        with open(filename, "r") as f:
+            if f.read(1) != "<":
+                raise FileImportException(
+                    "File {} is not a valid XML file.".format(filename)
+                )
 
-    mscore_exec = find_musescore3()
-
-    if not mscore_exec:
-        raise MuseScoreNotFoundException()
+    mscore_exec = find_musescore()
 
     xml_fh = os.path.splitext(os.path.basename(filename))[0] + ".musicxml"
 
-    cmd = [mscore_exec, "-o", xml_fh, filename]
+    cmd = [mscore_exec, "-o", xml_fh, filename, "-f"]
 
     try:
         ps = subprocess.run(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.PIPE)
@@ -167,10 +206,7 @@ def render_musescore(
     out : Optional[PathLike]
        Path to the output generated image (or None if no image was generated)
     """
-    mscore_exec = find_musescore3()
-
-    if not mscore_exec:
-        return None
+    mscore_exec = find_musescore()
 
     if fmt not in ("png", "pdf"):
         warnings.warn("warning: unsupported output format")
@@ -193,6 +229,7 @@ def render_musescore(
             "-o",
             os.fspath(img_fh),
             os.fspath(xml_fh),
+            "-f",
         ]
         try:
             ps = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)

partitura/performance.py

@@ -85,7 +85,11 @@ class PerformedPart(object):
         super().__init__()
         self.id = id
         self.part_name = part_name
-        self.notes = notes
+        self.notes = list(
+            map(
+                lambda n: n if isinstance(n, PerformedNote) else PerformedNote(n), notes
+            )
+        )
         self.controls = controls or []
         self.programs = programs or []
         self.ppq = ppq
@@ -203,7 +207,11 @@ class PerformedPart(object):
         if "id" not in note_array.dtype.names:
             n_ids = ["n{0}".format(i) for i in range(len(note_array))]
         else:
-            n_ids = note_array["id"]
+            # Check if all ids are the same
+            if np.all(note_array["id"] == note_array["id"][0]):
+                n_ids = ["n{0}".format(i) for i in range(len(note_array))]
+            else:
+                n_ids = note_array["id"]
 
         if "track" not in note_array.dtype.names:
             tracks = np.zeros(len(note_array), dtype=int)
@@ -280,6 +288,174 @@ def adjust_offsets_w_sustain(
         note["sound_off"] = offset
 
 
+class PerformedNote:
+    """
+    A dictionary-like object representing a performed note.
+
+    Parameters
+    ----------
+    pnote_dict : dict
+        A dictionary containing performed note information.
+        This information can contain the following fields:
+        "id", "pitch", "note_on", "note_off", "velocity", "track", "channel", "sound_off".
+        If not provided, the default values will be used.
+        Pitch, note_on, and note_off are required.
+    """
+
+    def __init__(self, pnote_dict):
+        self.pnote_dict = pnote_dict
+        self.pnote_dict["id"] = self.pnote_dict.get("id", None)
+        self.pnote_dict["pitch"] = self.pnote_dict.get("pitch", self["midi_pitch"])
+        self.pnote_dict["note_on"] = self.pnote_dict.get("note_on", -1)
+        self.pnote_dict["note_off"] = self.pnote_dict.get("note_off", -1)
+        self.pnote_dict["sound_off"] = self.pnote_dict.get(
+            "sound_off", self["note_off"]
+        )
+        self.pnote_dict["track"] = self.pnote_dict.get("track", 0)
+        self.pnote_dict["channel"] = self.pnote_dict.get("channel", 1)
+        self.pnote_dict["velocity"] = self.pnote_dict.get("velocity", 60)
+        self._validate_values(pnote_dict)
+        self._accepted_keys = [
+            "id",
+            "pitch",
+            "note_on",
+            "note_off",
+            "velocity",
+            "track",
+            "channel",
+            "sound_off",
+            "note_on_tick",
+            "note_off_tick",
+        ]
+
+    def __str__(self):
+        return f"PerformedNote: {self['id']}"
+
+    def __eq__(self, other):
+        if not isinstance(PerformedNote):
+            return False
+        if not self.keys() == other.keys():
+            return False
+        return np.all(
+            np.array([self[k] == other[k] for k in self.keys() if k in other.keys()])
+        )
+
+    def keys(self):
+        return self.pnote_dict.keys()
+
+    def get(self, key, default=None):
+        return self.pnote_dict.get(key, default)
+
+    def __hash__(self):
+        return hash(self["id"])
+
+    def __lt__(self, other):
+        return self["note_on"] < other["note_on"]
+
+    def __le__(self, other):
+        return self["note_on"] <= other["note_on"]
+
+    def __gt__(self, other):
+        return self["note_on"] > other["note_on"]
+
+    def __ge__(self, other):
+        return self["note_on"] >= other["note_on"]
+
+    def __getitem__(self, key):
+        return self.pnote_dict.get(key, None)
+
+    def __setitem__(self, key, value):
+        if key not in self._accepted_keys:
+            raise KeyError(f"Key {key} not accepted for PerformedNote")
+        self._validate_values((key, value))
+        self.pnote_dict[key] = value
+
+    def __delitem__(self, key):
+        raise KeyError("Cannot delete items from PerformedNote")
+
+    def __iter__(self):
+        return iter(self.keys())
+
+    def __len__(self):
+        return len(self.keys())
+
+    def __contains__(self, key):
+        return key in self.keys()
+
+    def copy(self):
+        return PerformedNote(self.pnote_dict.copy())
+
+    def _validate_values(self, d):
+        if isinstance(d, dict):
+            dd = d
+        elif isinstance(d, tuple):
+            dd = {d[0]: d[1]}
+        else:
+            raise ValueError(f"Invalid value {d} provided for PerformedNote")
+
+        for key, value in dd.items():
+            if key == "pitch":
+                self._validate_pitch(value)
+            elif key == "note_on":
+                self._validate_note_on(value)
+            elif key == "note_off":
+                self._validate_note_off(value)
+            elif key == "velocity":
+                self._validate_velocity(value)
+            elif key == "sound_off":
+                self._validate_sound_off(value)
+            elif key == "note_on_tick":
+                self._validate_note_on_tick(value)
+            elif key == "note_off_tick":
+                self._validate_note_off_tick(value)
+
+    def _validate_sound_off(self, value):
+        if self.get("note_off", -1) < 0:
+            return
+        if value < 0:
+            raise ValueError(f"sound_off must be greater than or equal to 0")
+        if value < self.pnote_dict["note_off"]:
+            raise ValueError(f"sound_off must be greater or equal to note_off")
+
+    def _validate_note_on(self, value):
+        if value < 0:
+            raise ValueError(
+                f"Note on value provided is invalid, must be greater than or equal to 0"
+            )
+
+    def _validate_note_off(self, value):
+        if self.pnote_dict.get("note_on", -1) < 0:
+            return
+        if value < 0 or value < self.pnote_dict["note_on"]:
+            raise ValueError(
+                f"Note off value provided is invalid, "
+                f"must be a positive value greater than or equal to 0 and greater or equal to note_on"
+            )
+
+    def _validate_note_on_tick(self, value):
+        if value < 0:
+            raise ValueError(
+                f"Note on tick value provided is invalid, must be greater than or equal to 0"
+            )
+
+    def _validate_note_off_tick(self, value):
+        if self.pnote_dict.get("note_on_tick", -1) < 0:
+            return
+        if value < 0 or value < self.pnote_dict["note_on_tick"]:
+            raise ValueError(
+                f"Note off tick value provided is invalid, "
+                f"must be a positive value greater than or equal to 0 and greater or equal to note_on_tick"
+            )
+
+    def _validate_pitch(self, value):
+        if value > 127 or value < 0:
+            raise ValueError(f"pitch must be between 0 and 127")
+
+    def _validate_velocity(self, value):
+        if value > 127 or value < 0:
+            raise ValueError(f"velocity must be between 0 and 127")
+
+
 class Performance(object):
     """Main object for representing a performance.
 

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
@@ -615,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
@@ -2990,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
@@ -3010,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.
@@ -3024,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]
@@ -3036,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,
@@ -3045,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
@@ -4588,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'
@@ -4609,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

partitura/utils/music.py

@@ -488,8 +488,15 @@ def transpose(score: ScoreLike, interval: Interval) -> ScoreLike:
         Transposed score.
     """
     import partitura.score as s
+    import sys
 
+    # 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 = copy.deepcopy(score)
+    # Reset recursion limit to previous value to avoid side effects
+    sys.setrecursionlimit(old_recursion_depth)
     if isinstance(score, s.Score):
         for part in new_score.parts:
             transpose(part, interval)
@@ -686,6 +693,8 @@ def midi_ticks_to_seconds(
 
 SIGN_TO_ALTER = {
     "n": 0,
+    "ns": 1,
+    "nf": -1,
     "#": 1,
     "s": 1,
     "ss": 2,
@@ -3252,18 +3261,17 @@ def slice_ppart_by_time(
     # create a new (empty) instance of a PerformedPart
     # single dummy note added to be able to set sustain_pedal_threshold in __init__
     # -> check `adjust_offsets_w_sustain` in partitura.performance
-    ppart_slice = PerformedPart([{"note_on": 0, "note_off": 0}])
+    # ppart_slice = PerformedPart([{"note_on": 0, "note_off": 0, "pitch": 0}])
 
     # get ppq if PerformedPart contains it,
     # else skip time_tick info when e.g. created with 'load_performance_midi'
     try:
         ppq = ppart.ppq
-        ppart_slice.ppq = ppq
     except AttributeError:
         ppq = None
 
+    controls_slice = []
     if ppart.controls:
-        controls_slice = []
         for cc in ppart.controls:
             if cc["time"] >= start_time and cc["time"] <= end_time:
                 new_cc = cc.copy()
@@ -3271,10 +3279,9 @@ def slice_ppart_by_time(
                 if ppq:
                     new_cc["time_tick"] = int(2 * ppq * cc["time"])
                 controls_slice.append(new_cc)
-        ppart_slice.controls = controls_slice
 
+    programs_slice = []
     if ppart.programs:
-        programs_slice = []
         for pr in ppart.programs:
             if pr["time"] >= start_time and pr["time"] <= end_time:
                 new_pr = pr.copy()
@@ -3282,7 +3289,6 @@ def slice_ppart_by_time(
                 if ppq:
                     new_pr["time_tick"] = int(2 * ppq * pr["time"])
                 programs_slice.append(new_pr)
-        ppart_slice.programs = programs_slice
 
     notes_slice = []
     note_id = 0
@@ -3326,7 +3332,10 @@ def slice_ppart_by_time(
             else:
                 break
 
-    ppart_slice.notes = notes_slice
+    # Create slice PerformedPart
+    ppart_slice = PerformedPart(
+        notes=notes_slice, programs=programs_slice, controls=controls_slice, ppq=ppq
+    )
 
     # set threshold property after creating notes list to update 'sound_offset' values
     ppart_slice.sustain_pedal_threshold = ppart.sustain_pedal_threshold

{partitura-1.3.1.dist-info → partitura-1.4.0.dist-info}/METADATA

@@ -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