partitura 1.4.0__tar.gz → 1.5.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: partitura
-Version: 1.4.0
+Version: 1.5.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, Patricia Hu

{partitura-1.4.0 → partitura-1.5.0}/partitura/__init__.py

@@ -15,6 +15,7 @@ from .io.exportmusicxml import save_musicxml
 from .io.importmei import load_mei
 from .io.importkern import load_kern
 from .io.importmusic21 import load_music21
+from .io.importdcml import load_dcml
 from .io.importmidi import load_score_midi, load_performance_midi, midi_to_notearray
 from .io.exportmidi import save_score_midi, save_performance_midi
 from .io.importmatch import load_match
@@ -22,7 +23,8 @@ from .io.exportmatch import save_match
 from .io.importnakamura import load_nakamuramatch, load_nakamuracorresp
 from .io.importparangonada import load_parangonada_csv
 from .io.exportparangonada import save_parangonada_csv, save_csv_for_parangonada
-from .io.exportaudio import save_wav
+from .io.exportaudio import save_wav, save_wav_fluidsynth
+from .io.exportmei import save_mei
 from .display import render
 from . import musicanalysis
 from .musicanalysis import make_note_features, compute_note_array, full_note_array
@@ -56,9 +58,12 @@ __all__ = [
     "save_performance_midi",
     "load_match",
     "save_match",
+    "load_dcml",
     "load_nakamuramatch",
     "load_nakamuracorresp",
     "load_parangonada_csv",
     "save_parangonada_csv",
+    "save_wav",
+    "save_wav_fluidsynth",
     "render",
 ]

{partitura-1.4.0 → partitura-1.5.0}/partitura/directions.py

@@ -13,6 +13,7 @@ The functionality is provided by the function `parse_words`
 
 import re
 import warnings
+from partitura.utils.globals import UNABBREVS
 
 try:
     from lark import Lark
@@ -51,29 +52,6 @@ def join_items(items):
     )
 
 
-UNABBREVS = [
-    (re.compile(r"(crescendo|cresc\.?)"), "crescendo"),
-    (re.compile(r"(smorzando|smorz\.?)"), "smorzando"),
-    (re.compile(r"(decrescendo|(decresc|decr|dimin|dim)\.?)"), "diminuendo"),
-    (re.compile(r"((acceler|accel|acc)\.?)"), "accelerando"),
-    (re.compile(r"(ritenente|riten\.?)"), "ritenuto"),
-    (re.compile(r"((ritard|rit)\.?)"), "ritardando"),
-    (re.compile(r"((rallent|rall)\.?)"), "rallentando"),
-    (re.compile(r"(dolciss\.?)"), "dolcissimo"),
-    (re.compile(r"((sosten|sost)\.?)"), "sostenuto"),
-    (re.compile(r"(delicatiss\.?)"), "delicatissimo"),
-    (re.compile(r"(leggieramente|leggiermente|leggiero|legg\.?)"), "leggiero"),
-    (re.compile(r"(leggierissimo|(leggieriss\.?))"), "leggierissimo"),
-    (re.compile(r"(scherz\.?)"), "scherzando"),
-    (re.compile(r"(tenute|ten\.?)"), "tenuto"),
-    (re.compile(r"(allegretto)"), "allegro"),
-    (re.compile(r"(espress\.?)"), "espressivo"),
-    (re.compile(r"(ligato)"), "legato"),
-    (re.compile(r"(ligatissimo)"), "legatissimo"),
-    (re.compile(r"((rinforz|rinf|rfz|rf)\.?)"), "rinforzando"),
-]
-
-
 def unabbreviate(s):
     for p, v in UNABBREVS:
         if p.match(s):

{partitura-1.4.0 → partitura-1.5.0}/partitura/io/__init__.py

@@ -12,10 +12,12 @@ from .musescore import load_via_musescore
 from .importmatch import load_match
 from .importmei import load_mei
 from .importkern import load_kern
+from .exportkern import save_kern
 from .importparangonada import load_parangonada_csv
 from .exportparangonada import save_parangonada_csv
 from .importmusic21 import load_music21
-
+from .exportmei import save_mei
+from .importdcml import load_dcml
 from partitura.utils.misc import (
     deprecated_alias,
     deprecated_parameter,

{partitura-1.4.0 → partitura-1.5.0}/partitura/io/exportaudio.py

@@ -1,8 +1,7 @@
 #!/usr/bin/python
 # -*- coding: utf-8 -*-
 """
-This module contains methods to synthesize Partitura object to wav using
-additive synthesis
+This module contains methods to synthesize a Partitura ScoreLike object to wav.
 """
 from typing import Union, Optional, Callable, Dict, Any
 import numpy as np
@@ -13,10 +12,18 @@ from partitura.score import ScoreLike
 from partitura.performance import PerformanceLike
 
 from partitura.utils.synth import synthesize, SAMPLE_RATE, A4
+from partitura.utils.fluidsynth import (
+    synthesize_fluidsynth,
+    DEFAULT_SOUNDFONT,
+    HAS_FLUIDSYNTH,
+)
 
 from partitura.utils.misc import PathLike
 
-__all__ = ["save_wav"]
+__all__ = [
+    "save_wav",
+    "save_wav_fluidsynth",
+]
 
 
 def save_wav(
@@ -89,8 +96,76 @@ def save_wav(
         bpm=bpm,
     )
 
+    if out is not None:
+        # convert to 16bit integers (save as PCM 16 bit)
+        # (some DAWs cannot load audio files that are float64,
+        # e.g., Logic)
+        amplitude = np.iinfo(np.int16).max
+        if abs(audio_signal).max() <= 1:
+            # convert to 16bit integers (save as PCM 16 bit)
+            amplitude = np.iinfo(np.int16).max
+            audio_signal *= amplitude
+        wavfile.write(out, samplerate, audio_signal.astype(np.int16))
+
+    else:
+        return audio_signal
+
+
+def save_wav_fluidsynth(
+    input_data: Union[ScoreLike, PerformanceLike, np.ndarray],
+    out: Optional[PathLike] = None,
+    samplerate: int = SAMPLE_RATE,
+    soundfont: PathLike = DEFAULT_SOUNDFONT,
+    bpm: Union[float, np.ndarray, Callable] = 60,
+) -> Optional[np.ndarray]:
+    """
+    Export a score (a `Score`, `Part`, `PartGroup` or list of `Part` instances),
+    a performance (`Performance`, `PerformedPart` or list of `PerformedPart` instances)
+    as a WAV file using fluidsynth
+
+    Parameters
+    ----------
+    input_data : ScoreLike, PerformanceLike or np.ndarray
+        A partitura object with note information.
+    out : PathLike or None
+        Path of the output Wave file. If None, the method outputs
+        the audio signal as an array (see `audio_signal` below).
+    samplerate: int
+        The sample rate of the audio file in Hz. The default is 44100Hz.
+    soundfont : PathLike
+        Path to the soundfont in SF2/SF3 format for fluidsynth.
+    bpm : float, np.ndarray, callable
+        The bpm to render the output (if the input is a score-like object).
+        See `partitura.utils.music.performance_notearray_from_score_notearray`
+        for more information on this parameter.
+
+    Returns
+    -------
+    audio_signal : np.ndarray
+       Audio signal as a 1D array. Only returned if `out` is None.
+    """
+
+    if not HAS_FLUIDSYNTH:
+        raise ImportError("Fluidsynth is not installed!")
+
+    audio_signal = synthesize_fluidsynth(
+        note_info=input_data,
+        samplerate=samplerate,
+        soundfont=soundfont,
+        bpm=bpm,
+    )
+
     if out is not None:
         # Write audio signal
-        wavfile.write(out, samplerate, audio_signal)
+
+        # convert to 16bit integers (save as PCM 16 bit)
+        # (some DAWs cannot load audio files that are float64,
+        # e.g., Logic)
+        amplitude = np.iinfo(np.int16).max
+        if abs(audio_signal).max() <= 1:
+            # convert to 16bit integers (save as PCM 16 bit)
+            amplitude = np.iinfo(np.int16).max
+            audio_signal *= amplitude
+        wavfile.write(out, samplerate, audio_signal.astype(np.int16))
     else:
         return audio_signal

partitura-1.5.0/partitura/io/exportkern.py

@@ -0,0 +1,344 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+This module contains methods for exporting Kern files.
+"""
+import math
+from collections import defaultdict
+
+import numpy
+
+import partitura.score as spt
+from operator import itemgetter
+from typing import Optional
+import numpy as np
+import warnings
+from partitura.utils import partition, iter_current_next, to_quarter_tempo
+from partitura.utils.misc import deprecated_alias, PathLike
+
+__all__ = ["save_kern"]
+
+
+ACC_TO_SIGN = {
+    0: "n",
+    -1: "-",
+    1: "#",
+    -2: "--",
+    2: "##",
+}
+
+# Kern notes encoding has a dedicated octave for each note.
+KERN_NOTES = {
+    ("C", 3): "C",
+    ("D", 3): "D",
+    ("E", 3): "E",
+    ("F", 3): "F",
+    ("G", 3): "G",
+    ("A", 3): "A",
+    ("B", 3): "B",
+    ("C", 4): "c",
+    ("D", 4): "d",
+    ("E", 4): "e",
+    ("F", 4): "f",
+    ("G", 4): "g",
+    ("A", 4): "a",
+    ("B", 4): "b",
+}
+
+KERN_DURS = {
+    "maxima": "000",
+    "long": "00",
+    "breve": "0",
+    "whole": "1",
+    "half": "2",
+    "quarter": "4",
+    "eighth": "8",
+    "16th": "16",
+    "32nd": "32",
+    "64th": "64",
+    "128th": "128",
+    "256th": "256",
+}
+
+KEYS = ["f", "c", "g", "d", "a", "e", "b"]
+
+
+class KernExporter(object):
+    """
+    Class for exporting a partitura score to Kern format.
+
+    Parameters
+    ----------
+    part: spt.Part
+        Part to export to Kern format.
+    """
+
+    def __init__(self, part):
+        self.part = part
+        note_array = part.note_array(include_staff=True)
+        num_measures = len(part.measures)
+        num_notes = len(part.notes)
+        num_rests = len(part.rests)
+        self.unique_voc_staff = np.unique(note_array[["voice", "staff"]], axis=0)
+        self.vocstaff_map_dict = {
+            f"{self.unique_voc_staff[i][0]}-{self.unique_voc_staff[i][1]}": i
+            for i in range(self.unique_voc_staff.shape[0])
+        }
+        # Part elements is really the maximum number of lines we could have in the kern file
+        # we add some to account for the **kern and the *- encoding at beginning and end of file and also tandem elements
+        # that might be added. We also add the number of measures to account for the measure encoding
+        total_elements_ish = num_measures + num_notes + num_rests + 2 + 10
+        self.out_data = np.empty(
+            (total_elements_ish, len(self.unique_voc_staff)), dtype=object
+        )
+        self.unique_times = np.array([p.t for p in part._points])
+        # Fill all values with the "." character to filter afterwards
+        self.out_data.fill(".")
+        self.out_data[0] = "**kern"
+        self.out_data[-1] = "*-"
+        # Add the staff element to the second line
+        for i in range(self.unique_voc_staff.shape[0]):
+            self.out_data[1, i] = f"*staff{self.unique_voc_staff[i][1]}"
+        self.prev_note_time = None
+        self.prev_note_col_idx = None
+        self.prev_note_row_idx = None
+
+    def parse(self):
+        """
+        Parse the partitura score to Kern format.
+
+        This method iterates over all elements in the partitura score and converts them to Kern format.
+        To better process the elements, the method first groups them by start time and then processes them in order.
+        It first finds notes and then processes structural elements (clefs, time signatures, etc.) and finally measures.
+
+        Returns
+        -------
+        self.out_data: np.ndarray
+            Kern file as a numpy array of strings.
+        """
+        row_idx = 2
+        for start_time in self.unique_times:
+            end_time = start_time + 1
+            # Get all elements starting at this time
+            elements_starting = np.array(
+                list(self.part.iter_all(start=start_time, end=end_time)), dtype=object
+            )
+            # Find notes
+            note_mask = np.array(
+                [isinstance(el, spt.GenericNote) for el in elements_starting]
+            )
+            if np.any(~note_mask):
+                bar_mask = np.array(
+                    [
+                        isinstance(el, spt.Measure)
+                        for el in elements_starting[~note_mask]
+                    ]
+                )
+                tandem_mask = ~bar_mask
+                structural_elements = elements_starting[~note_mask]
+                structural_elements = np.hstack(
+                    (structural_elements[tandem_mask], structural_elements[bar_mask])
+                )
+            else:
+                structural_elements = elements_starting[~note_mask]
+            # Put structural elements first (start with tandem elements, then measure elements, then notes and rests)
+            elements_starting = np.hstack(
+                (structural_elements, elements_starting[note_mask])
+            )
+            for el in elements_starting:
+                add_row = True
+                if isinstance(el, spt.GenericNote):
+                    self._handle_note(el, row_idx)
+                elif isinstance(el, spt.Clef):
+                    # Apply clef to all voices of the same staff
+                    currect_staff = el.staff
+                    for staff_idx in range(self.unique_voc_staff.shape[0]):
+                        if self.unique_voc_staff[staff_idx][1] == currect_staff:
+                            kern_el = f"*clef{el.sign.upper()}{el.line}"
+                            self.out_data[row_idx, staff_idx] = kern_el
+                elif isinstance(el, spt.Tempo):
+                    # Apply tempo to all splines
+                    kern_el = f"*MM{to_quarter_tempo(el.qpm)}"
+                    self.out_data[row_idx] = kern_el
+                elif isinstance(el, spt.Measure):
+                    # Apply measure to all splines
+                    kern_el = f"={el.number}"
+                    self.out_data[row_idx] = kern_el
+                elif isinstance(el, spt.TimeSignature):
+                    # Apply element to all splines
+                    kern_el = f"*M{el.beats}/{el.beat_type}"
+                    self.out_data[row_idx] = kern_el
+                elif isinstance(el, spt.KeySignature):
+                    # Apply element to all splines
+                    if el.fifths < 0:
+                        alters = "-".join(KEYS[: el.fifths])
+                    elif el.fifths > 0:
+                        alters = "#".join(KEYS[: el.fifths])
+                    else:
+                        alters = ""
+                    kern_el = f"*k[{alters}]"
+                    self.out_data[row_idx] = kern_el
+                else:
+                    add_row = False
+                    warnings.warn(f"Element {el} is not supported for kern export yet.")
+                if add_row:
+                    row_idx += 1
+        return self.out_data
+
+    def trim(self, data):
+        # if an entire row is filled with "." elements remove it.
+        out_data = data[~np.all(data == ".", axis=1)]
+        return out_data
+
+    def sym_dur_to_kern(self, symbolic_duration: dict) -> str:
+        kern_base = KERN_DURS[symbolic_duration["type"]]
+        dots = (
+            "." * symbolic_duration["dots"]
+            if "dots" in symbolic_duration.keys()
+            else ""
+        )
+        if "actual_notes" in symbolic_duration.keys() and "normal_notes":
+            kern_base = (
+                int(kern_base)
+                * symbolic_duration["actual_notes"]
+                / symbolic_duration["normal_notes"]
+            )
+            kern_base = str(kern_base)
+        return kern_base + dots
+
+    def duration_to_kern(self, element: spt.GenericNote) -> str:
+        if isinstance(element, spt.GraceNote):
+            if element.grace_type == "acciaccatura":
+                return "p"
+            else:
+                return "q"
+        else:
+            if "type" not in element.symbolic_duration.keys():
+                warnings.warn(f"Element {element} has no symbolic duration type")
+                return "4"
+            return self.sym_dur_to_kern(element.symbolic_duration)
+
+    def pitch_to_kern(self, element: spt.GenericNote) -> str:
+        """
+        Transform a Partitura Note object to a kern note string (only pitch).
+
+        To encode pitch correctly in kern we need to take into account that the octave
+        duplication of the step in kern can either move the note up or down an octave
+
+        """
+        if isinstance(element, spt.Rest):
+            return "r"
+        step, alter, octave = element.step, element.alter, element.octave
+        # Check if we need to have duplication of the step character
+        if octave > 4:
+            multiply_character = octave - 3
+            octave = 4
+        elif octave < 3:
+            multiply_character = 4 - octave
+            octave = 3
+        else:
+            multiply_character = 1
+        # Fetch the correct string for the step and multiply it if needed
+        kern_step = KERN_NOTES[(step, octave)] * multiply_character
+        kern_alter = ACC_TO_SIGN[alter] if alter is not None else ""
+        return kern_step + kern_alter
+
+    def markings_to_kern(self, element: spt.GenericNote) -> str:
+        symbols = ""
+        if not isinstance(element, spt.Rest):
+            if element.tie_next and element.tie_prev:
+                symbols += "-"
+            elif element.tie_next:
+                symbols += "["
+            elif element.tie_prev:
+                symbols += "]"
+            if element.slur_starts:
+                symbols += "("
+            if element.slur_stops:
+                symbols += ")"
+        if isinstance(element, spt.Note):
+            if element.beam is not None:
+                symbols += (
+                    "L"
+                    if element.beam == "begin"
+                    else "J" if element.beam == "end" else "K"
+                )
+        return symbols
+
+    def _handle_note(self, el: spt.GenericNote, row_idx) -> str:
+        voice = el.voice
+        staff = el.staff
+        duration = self.duration_to_kern(el)
+        pitch = self.pitch_to_kern(el)
+        col_idx = self.vocstaff_map_dict[f"{voice}-{staff}"]
+        markings = self.markings_to_kern(el)
+        kern_el = duration + pitch + markings
+        if self.prev_note_time == el.start.t:
+            if self.prev_note_col_idx == col_idx:
+                # Chords in Kern
+                self.out_data[self.prev_note_row_idx, self.prev_note_col_idx] = (
+                    self.out_data[self.prev_note_row_idx, self.prev_note_col_idx]
+                    + " "
+                    + kern_el
+                )
+            else:
+                # Same row (start.t) other spline
+                self.out_data[self.prev_note_row_idx, col_idx] = kern_el
+        else:
+            # New line
+            self.out_data[row_idx, col_idx] = kern_el
+            self.prev_note_row_idx = row_idx
+        self.prev_note_col_idx = col_idx
+        self.prev_note_time = el.start.t
+
+
+def save_kern(
+    score_data: spt.ScoreLike,
+    out: Optional[PathLike] = None,
+) -> Optional[np.ndarray]:
+    """
+    Save a score in Kern format.
+
+    Parameters
+    ----------
+    score_data: spt.ScoreLike
+        Score to save in Kern format
+
+    out: Optional[PathLike]
+        Path to save the Kern file. If None, the function returns the Kern file as a numpy array.
+
+    Returns
+    -------
+    Optional[np.ndarray]
+        If out is None, the Kern file is returned as a numpy array.
+    """
+    # Header extracts meta information about the score
+    header = "Here is some random piece"
+    # Kern can output only from part so first let's merge parts (we need a timewise representation)
+    if isinstance(score_data, spt.Score):
+        # TODO check that divisions are the same
+        part = spt.merge_parts(score_data.parts)
+    else:
+        part = score_data
+    if not part.measures:
+        spt.add_measures(part)
+    spt.fill_rests(part, measurewise=False)
+    exporter = KernExporter(part)
+    out_data = exporter.parse()
+    out_data = exporter.trim(out_data)
+    # Use numpy savetxt to save the file
+    footer = "Encoded using the Partitura Python package, version 1.5.0"
+    if out is not None:
+        np.savetxt(
+            fname=out,
+            X=out_data,
+            fmt="%1.26s",
+            delimiter="\t",
+            newline="\n",
+            header=header,
+            footer=footer,
+            comments="!!!",
+            encoding="utf-8",
+        )
+    else:
+        return out_data

{partitura-1.4.0 → partitura-1.5.0}/partitura/io/exportmatch.py

@@ -358,7 +358,10 @@ def matchfile_from_alignment(
                 offset_in_beats=offset_beats,
                 score_attributes_list=score_attributes_list,
             )
-            snote_sort_info[snote.id] = (onset_beats, snote.doc_order)
+            snote_sort_info[snote.id] = (
+                onset_beats,
+                snote.doc_order if snote.doc_order is not None else 0,
+            )
 
     # # 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:
@@ -392,7 +395,7 @@ def matchfile_from_alignment(
             onset=onset,
             offset=offset,
             velocity=pnote["velocity"],
-            channel=pnote.get("channel", 1),
+            channel=pnote.get("channel", 0),
             track=pnote.get("track", 0),
         )
         pnote_sort_info[pnote["id"]] = (