pretty-midi 0.2.11__tar.gz

pretty_midi-0.2.11/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Colin Raffel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

pretty_midi-0.2.11/PKG-INFO

@@ -0,0 +1,25 @@
+Metadata-Version: 2.1
+Name: pretty_midi
+Version: 0.2.11
+Summary: Functions and classes for handling MIDI data conveniently.
+Home-page: https://github.com/craffel/pretty-midi
+Author: Colin Raffel
+Author-email: craffel@gmail.com
+License: MIT
+Keywords: audio music midi mir
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Multimedia :: Sound/Audio :: MIDI
+License-File: LICENSE.txt
+Requires-Dist: numpy>=1.7.0
+Requires-Dist: mido>=1.1.16
+Requires-Dist: six
+Requires-Dist: importlib_resources
+Provides-Extra: fluidsynth
+Requires-Dist: pyfluidsynth>=1.3.1; extra == "fluidsynth"
+
+    Functions and classes which make handling MIDI data easy in Python.
+    Provides methods for parsing, modifying, and analyzing MIDI files.
+    

pretty_midi-0.2.11/README.md

@@ -0,0 +1,54 @@
+`pretty_midi` contains utility function/classes for handling MIDI data, so that it's in a format which is easy to modify and extract information from.
+
+Documentation is available [here](http://craffel.github.io/pretty-midi/).  You can also find a Jupyter notebook tutorial [here](https://nbviewer.org/github/craffel/pretty-midi/blob/main/Tutorial.ipynb) (click [here](https://colab.research.google.com/github/craffel/pretty-midi/blob/main/Tutorial.ipynb) to load in Colab).
+
+`pretty_midi` is available via [pip](https://pypi.python.org/pypi/pretty_midi) or via the [setup.py](https://github.com/craffel/pretty-midi/blob/master/setup.py) script. In order to synthesize MIDI data using fluidsynth, you need the [fluidsynth](http://www.fluidsynth.org/) program and [pyfluidsynth](https://pypi.python.org/pypi/pyfluidsynth).
+
+If you end up using `pretty_midi` in a published research project, please cite the following report:
+
+Colin Raffel and Daniel P. W. Ellis. [_Intuitive Analysis, Creation and Manipulation of MIDI Data with pretty_midi_](http://colinraffel.com/publications/ismir2014intuitive.pdf). In Proceedings of the 15th International Conference on Music Information Retrieval Late Breaking and Demo Papers, 2014.
+
+
+Example usage for analyzing, manipulating and synthesizing a MIDI file:
+
+```python
+import pretty_midi
+# Load MIDI file into PrettyMIDI object
+midi_data = pretty_midi.PrettyMIDI('example.mid')
+# Print an empirical estimate of its global tempo
+print(midi_data.estimate_tempo())
+# Compute the relative amount of each semitone across the entire song, a proxy for key
+total_velocity = sum(sum(midi_data.get_chroma()))
+print([sum(semitone)/total_velocity for semitone in midi_data.get_chroma()])
+# Shift all notes up by 5 semitones
+for instrument in midi_data.instruments:
+    # Don't want to shift drum notes
+    if not instrument.is_drum:
+        for note in instrument.notes:
+            note.pitch += 5
+# Synthesize the resulting MIDI data using sine waves
+audio_data = midi_data.synthesize()
+```
+
+Example usage for creating a simple MIDI file:
+
+```python
+import pretty_midi
+# Create a PrettyMIDI object
+cello_c_chord = pretty_midi.PrettyMIDI()
+# Create an Instrument instance for a cello instrument
+cello_program = pretty_midi.instrument_name_to_program('Cello')
+cello = pretty_midi.Instrument(program=cello_program)
+# Iterate over note names, which will be converted to note number later
+for note_name in ['C5', 'E5', 'G5']:
+    # Retrieve the MIDI note number for this note name
+    note_number = pretty_midi.note_name_to_number(note_name)
+    # Create a Note instance for this note, starting at 0s and ending at .5s
+    note = pretty_midi.Note(velocity=100, pitch=note_number, start=0, end=.5)
+    # Add it to our cello instrument
+    cello.notes.append(note)
+# Add the cello instrument to the PrettyMIDI object
+cello_c_chord.instruments.append(cello)
+# Write out the MIDI data
+cello_c_chord.write('cello-C-chord.mid')
+```

pretty_midi-0.2.11/pretty_midi/__init__.py

@@ -0,0 +1,151 @@
+"""
+``pretty_midi`` contains utility function/classes for handling MIDI data,
+so that it's in a format from which it is easy to modify and extract
+information.
+If you end up using ``pretty_midi`` in a published research project, please
+cite the following report:
+
+Colin Raffel and Daniel P. W. Ellis.
+`Intuitive Analysis, Creation and Manipulation of MIDI Data with pretty_midi
+<http://colinraffel.com/publications/ismir2014intuitive.pdf>`_.
+In 15th International Conference on Music Information Retrieval Late Breaking
+and Demo Papers, 2014.
+
+Example usage for analyzing, manipulating and synthesizing a MIDI file:
+
+.. code-block:: python
+
+    import pretty_midi
+    # Load MIDI file into PrettyMIDI object
+    midi_data = pretty_midi.PrettyMIDI('example.mid')
+    # Print an empirical estimate of its global tempo
+    print midi_data.estimate_tempo()
+    # Compute the relative amount of each semitone across the entire song,
+    # a proxy for key
+    total_velocity = sum(sum(midi_data.get_chroma()))
+    print [sum(semitone)/total_velocity for semitone in midi_data.get_chroma()]
+    # Shift all notes up by 5 semitones
+    for instrument in midi_data.instruments:
+        # Don't want to shift drum notes
+        if not instrument.is_drum:
+            for note in instrument.notes:
+                note.pitch += 5
+    # Synthesize the resulting MIDI data using sine waves
+    audio_data = midi_data.synthesize()
+
+Example usage for creating a simple MIDI file:
+
+.. code-block:: python
+
+    import pretty_midi
+    # Create a PrettyMIDI object
+    cello_c_chord = pretty_midi.PrettyMIDI()
+    # Create an Instrument instance for a cello instrument
+    cello_program = pretty_midi.instrument_name_to_program('Cello')
+    cello = pretty_midi.Instrument(program=cello_program)
+    # Iterate over note names, which will be converted to note number later
+    for note_name in ['C5', 'E5', 'G5']:
+        # Retrieve the MIDI note number for this note name
+        note_number = pretty_midi.note_name_to_number(note_name)
+        # Create a Note instance, starting at 0s and ending at .5s
+        note = pretty_midi.Note(
+            velocity=100, pitch=note_number, start=0, end=.5)
+        # Add it to our cello instrument
+        cello.notes.append(note)
+    # Add the cello instrument to the PrettyMIDI object
+    cello_c_chord.instruments.append(cello)
+    # Write out the MIDI data
+    cello_c_chord.write('cello-C-chord.mid')
+
+Further examples can be found in the source tree's `examples directory
+<https://github.com/craffel/pretty-midi/tree/master/examples>`_.
+
+``pretty_midi.PrettyMIDI``
+==========================
+
+.. autoclass:: PrettyMIDI
+   :members:
+   :undoc-members:
+
+``pretty_midi.Instrument``
+==========================
+
+.. autoclass:: Instrument
+   :members:
+   :undoc-members:
+
+``pretty_midi.Note``
+====================
+
+.. autoclass:: Note
+   :members:
+   :undoc-members:
+
+``pretty_midi.PitchBend``
+=========================
+
+.. autoclass:: PitchBend
+   :members:
+   :undoc-members:
+
+``pretty_midi.ControlChange``
+=============================
+
+.. autoclass:: ControlChange
+   :members:
+   :undoc-members:
+
+``pretty_midi.TimeSignature``
+=============================
+
+.. autoclass:: TimeSignature
+   :members:
+   :undoc-members:
+
+``pretty_midi.KeySignature``
+============================
+
+.. autoclass:: KeySignature
+   :members:
+   :undoc-members:
+
+``pretty_midi.Lyric``
+=====================
+
+.. autoclass:: Lyric
+   :members:
+   :undoc-members:
+
+``pretty_midi.Text``
+=====================
+
+.. autoclass:: Text
+   :members:
+   :undoc-members:
+
+Utility functions
+=================
+.. autofunction:: key_number_to_key_name
+.. autofunction:: key_name_to_key_number
+.. autofunction:: mode_accidentals_to_key_number
+.. autofunction:: key_number_to_mode_accidentals
+.. autofunction:: qpm_to_bpm
+.. autofunction:: note_number_to_hz
+.. autofunction:: hz_to_note_number
+.. autofunction:: note_name_to_number
+.. autofunction:: note_number_to_name
+.. autofunction:: note_number_to_drum_name
+.. autofunction:: drum_name_to_note_number
+.. autofunction:: program_to_instrument_name
+.. autofunction:: instrument_name_to_program
+.. autofunction:: program_to_instrument_class
+.. autofunction:: pitch_bend_to_semitones
+.. autofunction:: semitones_to_pitch_bend
+"""
+from .pretty_midi import *
+from .instrument import *
+from .containers import *
+from .utilities import *
+from .constants import *
+
+__version__ = '0.2.11'

pretty_midi-0.2.11/pretty_midi/constants.py

@@ -0,0 +1,72 @@
+"""This file defines MIDI standard constants, which are useful for converting
+between numeric MIDI data values and human-readable text.
+
+"""
+
+# INSTRUMENT_MAP[program_number] maps the program_number to an instrument name
+INSTRUMENT_MAP = ['Acoustic Grand Piano', 'Bright Acoustic Piano',
+                  'Electric Grand Piano', 'Honky-tonk Piano',
+                  'Electric Piano 1', 'Electric Piano 2', 'Harpsichord',
+                  'Clavinet', 'Celesta', 'Glockenspiel', 'Music Box',
+                  'Vibraphone', 'Marimba', 'Xylophone', 'Tubular Bells',
+                  'Dulcimer', 'Drawbar Organ', 'Percussive Organ',
+                  'Rock Organ', 'Church Organ', 'Reed Organ', 'Accordion',
+                  'Harmonica', 'Tango Accordion', 'Acoustic Guitar (nylon)',
+                  'Acoustic Guitar (steel)', 'Electric Guitar (jazz)',
+                  'Electric Guitar (clean)', 'Electric Guitar (muted)',
+                  'Overdriven Guitar', 'Distortion Guitar',
+                  'Guitar Harmonics', 'Acoustic Bass',
+                  'Electric Bass (finger)', 'Electric Bass (pick)',
+                  'Fretless Bass', 'Slap Bass 1', 'Slap Bass 2',
+                  'Synth Bass 1', 'Synth Bass 2', 'Violin', 'Viola', 'Cello',
+                  'Contrabass', 'Tremolo Strings', 'Pizzicato Strings',
+                  'Orchestral Harp', 'Timpani', 'String Ensemble 1',
+                  'String Ensemble 2', 'Synth Strings 1', 'Synth Strings 2',
+                  'Choir Aahs', 'Voice Oohs', 'Synth Choir', 'Orchestra Hit',
+                  'Trumpet', 'Trombone', 'Tuba', 'Muted Trumpet',
+                  'French Horn', 'Brass Section', 'Synth Brass 1',
+                  'Synth Brass 2', 'Soprano Sax', 'Alto Sax', 'Tenor Sax',
+                  'Baritone Sax', 'Oboe', 'English Horn', 'Bassoon',
+                  'Clarinet', 'Piccolo', 'Flute', 'Recorder', 'Pan Flute',
+                  'Blown bottle', 'Shakuhachi', 'Whistle', 'Ocarina',
+                  'Lead 1 (square)', 'Lead 2 (sawtooth)',
+                  'Lead 3 (calliope)', 'Lead 4 chiff', 'Lead 5 (charang)',
+                  'Lead 6 (voice)', 'Lead 7 (fifths)',
+                  'Lead 8 (bass + lead)', 'Pad 1 (new age)', 'Pad 2 (warm)',
+                  'Pad 3 (polysynth)', 'Pad 4 (choir)', 'Pad 5 (bowed)',
+                  'Pad 6 (metallic)', 'Pad 7 (halo)', 'Pad 8 (sweep)',
+                  'FX 1 (rain)', 'FX 2 (soundtrack)', 'FX 3 (crystal)',
+                  'FX 4 (atmosphere)', 'FX 5 (brightness)', 'FX 6 (goblins)',
+                  'FX 7 (echoes)', 'FX 8 (sci-fi)', 'Sitar', 'Banjo',
+                  'Shamisen', 'Koto', 'Kalimba', 'Bagpipe', 'Fiddle',
+                  'Shanai', 'Tinkle Bell', 'Agogo', 'Steel Drums',
+                  'Woodblock', 'Taiko Drum', 'Melodic Tom', 'Synth Drum',
+                  'Reverse Cymbal', 'Guitar Fret Noise', 'Breath Noise',
+                  'Seashore', 'Bird Tweet', 'Telephone Ring', 'Helicopter',
+                  'Applause', 'Gunshot']
+
+# INSTRUMENT_CLASSES contains the classes present in INSTRUMENTS
+INSTRUMENT_CLASSES = ['Piano', 'Chromatic Percussion', 'Organ', 'Guitar',
+                      'Bass', 'Strings', 'Ensemble', 'Brass', 'Reed', 'Pipe',
+                      'Synth Lead', 'Synth Pad', 'Synth Effects', 'Ethnic',
+                      'Percussive',
+                      'Sound Effects']
+
+# List which maps MIDI note number - 35 to drum name
+# from http://www.midi.org/techspecs/gm1sound.php
+DRUM_MAP = ['Acoustic Bass Drum', 'Bass Drum 1', 'Side Stick',
+            'Acoustic Snare', 'Hand Clap', 'Electric Snare',
+            'Low Floor Tom', 'Closed Hi Hat', 'High Floor Tom',
+            'Pedal Hi Hat', 'Low Tom', 'Open Hi Hat',
+            'Low-Mid Tom', 'Hi-Mid Tom', 'Crash Cymbal 1',
+            'High Tom', 'Ride Cymbal 1', 'Chinese Cymbal',
+            'Ride Bell', 'Tambourine', 'Splash Cymbal',
+            'Cowbell', 'Crash Cymbal 2', 'Vibraslap',
+            'Ride Cymbal 2', 'Hi Bongo', 'Low Bongo',
+            'Mute Hi Conga', 'Open Hi Conga', 'Low Conga',
+            'High Timbale', 'Low Timbale', 'High Agogo',
+            'Low Agogo', 'Cabasa', 'Maracas',
+            'Short Whistle', 'Long Whistle', 'Short Guiro',
+            'Long Guiro', 'Claves', 'Hi Wood Block',
+            'Low Wood Block', 'Mute Cuica', 'Open Cuica',
+            'Mute Triangle', 'Open Triangle']

pretty_midi-0.2.11/pretty_midi/containers.py

@@ -0,0 +1,226 @@
+"""These classes simply hold MIDI data in a convenient form.
+
+"""
+from __future__ import print_function
+
+from .utilities import key_number_to_key_name
+
+
+class Note(object):
+    """A note event.
+
+    Parameters
+    ----------
+    velocity : int
+        Note velocity.
+    pitch : int
+        Note pitch, as a MIDI note number.
+    start : float
+        Note on time, absolute, in seconds.
+    end : float
+        Note off time, absolute, in seconds.
+
+    """
+
+    def __init__(self, velocity, pitch, start, end):
+        if end < start:
+            raise ValueError("Note end time must be greater than start time")
+        
+        self.velocity = velocity
+        self.pitch = pitch
+        self.start = start
+        self.end = end
+
+    def get_duration(self):
+        """Get the duration of the note in seconds."""
+        return self.end - self.start
+
+    @property
+    def duration(self):
+        return self.get_duration()
+
+    def __repr__(self):
+        return 'Note(start={:f}, end={:f}, pitch={}, velocity={})'.format(
+            self.start, self.end, self.pitch, self.velocity)
+
+
+class PitchBend(object):
+    """A pitch bend event.
+
+    Parameters
+    ----------
+    pitch : int
+        MIDI pitch bend amount, in the range ``[-8192, 8191]``.
+    time : float
+        Time where the pitch bend occurs.
+
+    """
+
+    def __init__(self, pitch, time):
+        self.pitch = pitch
+        self.time = time
+
+    def __repr__(self):
+        return 'PitchBend(pitch={:d}, time={:f})'.format(self.pitch, self.time)
+
+
+class ControlChange(object):
+    """A control change event.
+
+    Parameters
+    ----------
+    number : int
+        The control change number, in ``[0, 127]``.
+    value : int
+        The value of the control change, in ``[0, 127]``.
+    time : float
+        Time where the control change occurs.
+
+    """
+
+    def __init__(self, number, value, time):
+        self.number = number
+        self.value = value
+        self.time = time
+
+    def __repr__(self):
+        return ('ControlChange(number={:d}, value={:d}, '
+                'time={:f})'.format(self.number, self.value, self.time))
+
+
+class TimeSignature(object):
+    """Container for a Time Signature event, which contains the time signature
+    numerator, denominator and the event time in seconds.
+
+    Attributes
+    ----------
+    numerator : int
+        Numerator of time signature.
+    denominator : int
+        Denominator of time signature.
+    time : float
+        Time of event in seconds.
+
+    Examples
+    --------
+    Instantiate a TimeSignature object with 6/8 time signature at 3.14 seconds:
+
+    >>> ts = TimeSignature(6, 8, 3.14)
+    >>> print(ts)
+    6/8 at 3.14 seconds
+
+    """
+
+    def __init__(self, numerator, denominator, time):
+        if not (isinstance(numerator, int) and numerator > 0):
+            raise ValueError(
+                '{} is not a valid `numerator` type or value'.format(
+                    numerator))
+        if not (isinstance(denominator, int) and denominator > 0):
+            raise ValueError(
+                '{} is not a valid `denominator` type or value'.format(
+                    denominator))
+        if not (isinstance(time, (int, float)) and time >= 0):
+            raise ValueError(
+                '{} is not a valid `time` type or value'.format(time))
+
+        self.numerator = numerator
+        self.denominator = denominator
+        self.time = time
+
+    def __repr__(self):
+        return "TimeSignature(numerator={}, denominator={}, time={})".format(
+            self.numerator, self.denominator, self.time)
+
+    def __str__(self):
+        return '{}/{} at {:.2f} seconds'.format(
+            self.numerator, self.denominator, self.time)
+
+
+class KeySignature(object):
+    """Contains the key signature and the event time in seconds.
+    Only supports major and minor keys.
+
+    Attributes
+    ----------
+    key_number : int
+        Key number according to ``[0, 11]`` Major, ``[12, 23]`` minor.
+        For example, 0 is C Major, 12 is C minor.
+    time : float
+        Time of event in seconds.
+
+    Examples
+    --------
+    Instantiate a C# minor KeySignature object at 3.14 seconds:
+
+    >>> ks = KeySignature(13, 3.14)
+    >>> print(ks)
+    C# minor at 3.14 seconds
+    """
+
+    def __init__(self, key_number, time):
+        if not all((isinstance(key_number, int),
+                    key_number >= 0,
+                    key_number < 24)):
+            raise ValueError(
+                '{} is not a valid `key_number` type or value'.format(
+                    key_number))
+        if not (isinstance(time, (int, float)) and time >= 0):
+            raise ValueError(
+                '{} is not a valid `time` type or value'.format(time))
+
+        self.key_number = key_number
+        self.time = time
+
+    def __repr__(self):
+        return "KeySignature(key_number={}, time={})".format(
+            self.key_number, self.time)
+
+    def __str__(self):
+        return '{} at {:.2f} seconds'.format(
+            key_number_to_key_name(self.key_number), self.time)
+
+
+class Lyric(object):
+    """Timestamped lyric text.
+
+    Attributes
+    ----------
+    text : str
+        The text of the lyric.
+    time : float
+        The time in seconds of the lyric.
+    """
+
+    def __init__(self, text, time):
+        self.text = text
+        self.time = time
+
+    def __repr__(self):
+        return 'Lyric(text="{}", time={})'.format(
+            self.text.replace('"', r'\"'), self.time)
+
+    def __str__(self):
+        return '"{}" at {:.2f} seconds'.format(self.text, self.time)
+
+class Text(object):
+    """Timestamped text event.
+
+    Attributes
+    ----------
+    text : str
+        The text.
+    time : float
+        The time it occurs in seconds.
+    """
+
+    def __init__(self, text, time):
+        self.text = text
+        self.time = time
+
+    def __repr__(self):
+        return 'Text(text="{}", time={})'.format(
+            self.text.replace('"', r'\"'), self.time)
+
+    def __str__(self):
+        return '"{}" at {:.2f} seconds'.format(self.text, self.time)

pretty_midi-0.2.11/pretty_midi/fluidsynth.py

@@ -0,0 +1,72 @@
+"""Utility functions for handling fluidsynth
+
+"""
+
+import os
+import importlib_resources
+
+try:
+    import fluidsynth
+    _HAS_FLUIDSYNTH = True
+except ImportError:
+    _HAS_FLUIDSYNTH = False
+
+DEFAULT_SF2 = 'TimGM6mb.sf2'
+DEFAULT_SAMPLE_RATE = 44100
+
+
+def get_fluidsynth_instance(synthesizer=None, sfid=0, fs=None):
+    """ Check if a valid fluidsynth.Synth instance is provided, and if not,
+    create one.
+
+    Parameters
+    ----------
+    synthesizer : fluidsynth.Synth or str
+        fluidsynth.Synth instance to use or a string with the path to a .sf2 file.
+        Default ``None``, which creates a new instance using the TimGM6mb.sf2 file
+        included with ``pretty_midi``.
+    sfid : int
+        Soundfont ID to use if an instance of fluidsynth.Synth is provided.
+        Default ``0``, which uses the first soundfont.
+    fs : int
+        Sampling rate to synthesize at.
+        Default ``None``, which falls back to ``pretty_midi.fluidsynth.DEFAULT_SAMPLE_RATE``
+        = 44100 if a new instance must be created.
+        If ``synthesizer`` is an existing instance and ``fs`` is specified, then
+        ValueError will be raised if the sample rates are not equal.
+
+    Returns
+    -------
+    synthesizer : fluidsynth.Synth
+        fluidsynth.Synth instance
+    sfid : int
+        Soundfont ID
+    new_instance_created : bool
+        Whether a new instance of fluidsynth.Synth was created.
+
+    """
+    if not _HAS_FLUIDSYNTH:
+        raise ImportError("fluidsynth() was called but pyfluidsynth is not installed.")
+
+    if synthesizer is None:
+        synthesizer = os.path.join(str(importlib_resources.files(__name__)), DEFAULT_SF2)
+
+    # Create a fluidsynth instance if one wasn't provided
+    if isinstance(synthesizer, str):
+        sf2_path = synthesizer
+        if not os.path.exists(synthesizer):
+            raise ValueError("No soundfont file found at the supplied path {}".format(sf2_path))
+        fs = fs or DEFAULT_SAMPLE_RATE
+        synthesizer = fluidsynth.Synth(samplerate=fs)
+        sfid = synthesizer.sfload(sf2_path)
+        new_instance_created = True
+    elif isinstance(synthesizer, fluidsynth.Synth):
+        synth_fs = synthesizer.get_setting('synth.sample-rate')
+        if fs and synth_fs != fs:
+            raise ValueError(
+                f"synthesizer sample rate of {synth_fs} doesn't match provided fs of {fs}")
+        new_instance_created = False
+    else:
+        raise ValueError("synthesizer must be a str or a fluidsynth.Synth instance")
+
+    return synthesizer, sfid, new_instance_created