What is music21?
Music21 is a set of tools for helping scholars and other active listeners answer questions about music quickly and simply. If you’ve ever asked yourself a question like, “I wonder how often Bach does that” or “I wish I knew which band was the first to use these chords in this order,” or “I’ll bet we’d know more about Renaissance counterpoint (or Indian ragas or post-tonal pitch structures or the form of minuets) if I could write a program to automatically write more of them,” then music21 can help you with your work.
How simple is music21 to use?
Extremely. After starting Python and typing "from music21 import *"
you can do all of these things with only a single line of music21 code:
Display a short melody in musical notation:
3/4 c4 d8 f g16 a g f#").show()
Print the twelve-tone matrix for a
tone row (in this case the opening of Schoenberg's Fourth String Quartet):
print (serial.rowToMatrix([2,1,9,10,5,3,4,0,8,7,6,11]) )
or since all the 2nd-Viennese school rows are already available as objects, you can type:
print (serial.getHistoricalRowByName('RowSchoenbergOp37').matrix() )
Convert a file from Humdrum's **kern data format to MusicXML for editing in Finale or Sibelius:
With five lines of music21 code or less, you can:
Prepare a thematic (incipit) catalog of every Bach chorale that is in 3/4:
catalog = stream.Opus()
for work in corpus.chorales.Iterator():
firstTS = work.recurse().getElementsByClass('TimeSignature')
if firstTS.ratioString == '3/4':
Google every motet in your
database that includes the word ‘exultavit’ in the superius
(soprano) part (even if broken up as multiple syllables in the source
file) to see how common the motet's text is (assuming you have a bunch
of motets in "listOfMotets"):
for motet in listOfMotets:
superius = motet
lyrics = text.assembleLyrics(part)
if 'exultavit' in lyrics:
webbrowser.open('http://www.google.com/search?&q=' + lyrics)
Add the German name (i.e., B♭ = B, B = H, A♯ = Ais) under each note of a Bach chorale and show the new score:
bwv295 = corpus.parse('bach/bwv295')
for thisNote in bwv295.recurse().notes:
Of course, you are never limited to just using five lines to do tasks with
music21. In the demos folder of the
music21 package and in the sample problems page
(and throughout the documentation) you’ll find examples of more complicated problems
that music21 is well-suited to solving, such as
cataloging the rhythms of a piece from most to
Music21 builds on preexisting frameworks and
as Humdrum, MusicXML,
and MIDI but music21 uses an object-oriented
framework that makes it easier to handle complex data. At the same time music21 tries to keep its code clear and make reusing existing code simple. With music21 once you (or anyone else) has written a program to solve a problem, that program can easily become a module to be adapted or built upon to solve dozens of similar (but not identical) problems.
Interested in learning more?
music21 v6.7 is released. This will likely be the last release on the v6 line (more later), which has seen remarkable speed and stability improvements. Here’s what’s new in the past month since 6.5 came out:
- Important bug fix: if you’ve had trouble loading
music21 with an “importlib” error, this is fixed.
- Composite lyrics changes to the implementation in 6.5: multiple syllables on one note in a single verse (like in Italian, “Il bianco edolce cigno”) now are imported to MusicXML property, stored in a Lyric.components object, and export to MusicXML properly.
- Lyrics searching finds all lyrics in all verses (and composite lyrics too)
- More major improvements to piano staff imports (thanks to Jacob Tyler Walls = JTW)
- RomanNumeral.isMixture() shows whether a chord is borrowed from the other mode (Mark Gotham)
- Several improvements in chord symbols (JTW + Alexandre Papadopoulos)
- More improvements to finding instrument names from MIDI (JTW)
- Duration marks in chords in ABC import properly (Marian Schultz)
- Documentation improvements.
- MusicXML parse failures now more often give the part and measure context (JTW)
- Substantial bug fixes in Stream.setElementOffset. Adds a new Stream.coreSetElementOffset for the dangerous but super fast version, and makes the original version safer. (JTW)
- Bug fixes in MEI articulations (heinzer) and accidentals (JTW)
- Bug fixes in external tools in windows including spaces (JTW)
- Channels handle better in MIDI (bearpelican)
- Humdrum files with positioned rests no longer crash (Phil Kirlin)
- OctaveRepeatingScale and CyclicalScale now usable as abstract classes (JTW)
- Articulations and expressions musicxml does not support are exported as (JTW)
- Better support for .musicxml as a file name within compressed .mxl files.
- Beaming in pickup measures is fixed.
- Stem directions can now be set automatically to coincide with beam groups. This is very useful if you are creating your own notation from scratch (as in VexFlow output; m21j gets the same routines)
- Spanner endHeight and startHeight are processed correctly (JTW)
- NoChord objects (in Chord Symbols) now retain their text (like “N.C.”) in more situations (JTW)
- All NotRest objects get a .pitches function – a small thing, but will be helpful in the future.
6.7 is likely the last release in version 6. We begin work on version 7 today! This means that most deprecated functions will be removed, to speed up the system and help build new things.
- Version 7 will require Python 3.7 as a minimum version. Python 3.6 will be end-of-life by November, and v.7 will last for at least into 2022. music21 will continue to support all Python versions that are actively maintained during the expected life of the version. v3.7-3.9 will be supported, and when 3.10 comes out, the next minor version of
music21 will support it.
But dropping Py3.6 means some great changes:
- Many things that are NamedTuples will become dataclasses. (all but sortTuple). This will make working with a lot of data much better.
- Many many string options (such as notehead and beam types) will become Enums. This will help with avoiding making coding mistakes that are hard to detect. Where this has already happened (like in VoiceLeadingQuartet.MotionType) life has already become better. They will be StringEnums, and have a transition period, so code that checks for Beam.type == “start” or Lyric.syllabic == “begin” will still work (but I can never remember which is start and which is begin. Hence the point!)
- Substantial changes to Unpitched to make percussion support work.
- Some OrderedDicts (yuk!) will become normal dictionaries, now that insertion order is guaranteed to be preserved.
- Whatever else has been annoying me but I haven't been able to fix by committing to keep major versions backwards compatible.
- For simplifying the life of beginner users,
__dir__ will be defined for certain key modules (like Note) so that all the typing and internal information isn't exposed.
- I'm hoping that getElementsByClass will be able to specify its return type, at least when called with a class. For people using Typing in Python, this will be a major improvement.
Deprecated functions gone ASAP:
- Chord.findRoot() -- just use chord.root() instead
- interval.convertSpecifier – use parseSpecifier instead
- formats.findFormat (and many others in the formats module etc.)
- humdrum.parseData, humdrum.parseFile (just use converter.parse)
- Editorial.misc (just stick it on editorial)
- Duration.updateQuarterLength (not needed)
- SpacerRest will become deprecated – just use a normal Rest with hideObjectOnPrint = True
- Setting a pitch.accidental to a number or string will be deprecated – create an Accidental object first
- setElementOffset deprecates two keywords: addElement and setActiveSite
- isClassOrSubclass to be deprecated, use Class in .classSet – WAY faster
- getClefs to be deprecated – use recurse().getElementsByClass(‘Clef’)
- getKeySignatures to be deprecated -- use recurse().getElementsByClass(‘KeySignature’)
- Stream.makeChords() to be deprecated – Chordify is the way to go.
- Stream.extendDurationsAndGetBoundaries – was meant to be deprecated in 6 and gone in 7. It gets a one version reprieve.
- stripTies.retainContainers to be deprecated – will always be True. Just call .flat afterwards to not get this.
- Stream.iter.variants to be deprecated. Just use .getElementsByClass(‘Variant’)
- tree.toStream.chordified() to be deprecated. It’s the internal guts of Chordify now
- VoiceLeading.color to be deprecated – set .style.color on notes like any other object
Weird changes of properties to methods:
Stream.iter() will be the encouraged new form instead of
Stream.sorted() will be encouraged new form instead of
- (This might not happen, but...)
Stream.flat() encouraged for
Stream.flat -- similarly for
- Other properties where it is possible to encourage method calling will also get this change.
These methods were disguised as properties early on in
music21 and it was a bad mistake, leading to lots of problems with introspection. Migration will go like this: v7 -- new forms are allowed and documentation is updated to encourage it. v8 -- all mention of old forms will be removed from the system and where possible using the old form will send a DeprecationWarning. v9 -- old forms are removed.
Version 7 might take until the summer or beyond. (Hence there may be bug-fix versions of v6.7 along the way). So for now, enjoy what’s out there and look forward to the future. The main branch will move to v7 but will remain as stable as possible.
Thanks to the community for great support and as always to the Seaver Institute, National Endowment for the Humanities, and MIT for support of
Happy New Year! I am pleased to announce that the newest Version of
music21, version 6.5 has been released. It is nearly completely backwards compatible with other v6 releases and runs on Python 3.6–3.8.
Music21 is an open-source toolkit for computational music theory and musicology, and also used in composition and music production. Download it via
pip install --upgrade music21
Version 6.5 adds several important new features since the bug-fix version 6.3 (from mid-November 2020) while squashing many bugs and speeding up a number of parts of the system. Many of the contributions were made by members of the open source community, including major contributions by Jacob Tyler Walls (JTW), Mark Gotham (MG), Néstor Nápoles López (NNL), and Paula Muñoz Lago.
PartStaff objects such as a staff of a piano part now export properly back to MusicXML as one part with
<staff> tags. Huge work by JTW!
- RomanText is now a valid output format in addition to input! Save your analyses for later! Thanks Mark Gotham!
- search/lyrics now finds second and subsequent lyrics (thanks to Paula ML and DIDONE project)
- Improvements to VI and VII roman numerals in minor (JTW)
- MIDI tries to import part names from instruments (JTW)
- MIDI properly reads and writes conductor tracks (JTW)
- Doc improvements for many places including RomanNumerals, insertIntoNoteOrChord, chordify with GraceNote (MSC)
- Major speedups for many chord actions including getLeadingTone, isTriad, isMajorTriad, etc. (NNL + MSC w/ JTW)
music21 loads or starts up in 1/3 the time as before. (MSC)
- Opus.write() improvements -- now all filenames of an Opus write call have similar names and only the last filename is returned (JTW)
- All properties in music21 are readable without raising an exception. This will help inspection/debugging software. (MSC)
- Staff-type is imported and exported properly to/from musicxml as the
.staffType attribute on
.staffLines is now settable on all Stream types (not just Parts) as a shortcut to manipulating
layout.StaffLayout().staffLines at the start of the Stream. (MSC)
- roman.RomanNumeral.isNeapolitan() (MG)
Smaller features and bug fixes:
- midi.realtime.StreamPlayer now allows for non-blocking playing and for stopping at various points. (antran22)
- If scratch/temp directory is not writable or does not exist, use backup directories (JTW + Tanchihpin0517 )
- Use subprocess.run() for launching external tools (JTW)
- Deprecated method Environment.launch() is removed. (JTW)
- MusicXML reader selection improved, especially on Windows (MSC)
- Refactor of the musicxml subpackage for smaller files and more expandability (MSC)
- Default readers set for Unix (Thomas Wilson).
- RomanNumeral parsing improvements, esp. for chords like V7b5. (MSC)
- testing is moved to Github Actions for faster responses. Thanks to Travis-CI for years of support (MSC)
- works on Python 3.9 -- v6 is likely the last version to support py 3.6. (MSC)
- Instruments outside of voices are retained when making measures (JTW)
- all tests pass on Windows for windows developers. (JTW)
- better installation on conda-forge w/ a webcolors change (JTW)
- unmeasured scores export to MusicXML better (JTW)
- MIDI instruments no longer get incorrect durations (JTW)
- MIDI pitch bends are easier to understand (JTW)
- Improved tuplet brackets when number is not shown (JTW)
- Coverage improved (MSC + JTW)
- Better commonName for 0, 1, 2 note chords, and microtonal chords (MSC)
.show('scala') works on more scales. (JTW)
- More XML Chord symbols import (JTW)
- Fixes for aadd6 and other chord symbols where the name of the note ("A") is also present in the modifier ("Add") (JTW)
- Chord.quality returns "other" for C C# E G (MG)
- An empty degree-alter now matches MusicXML spec (JTW)
- ABC and MIDI parsing cleanups to make it easier for developers to extend (MSC)
- Very old musicxml files with empty "tie" elements parse better. (JTW)
- Improved handling of omitted pitches in RomanNumerals (JTW)
instrument.deduplicate() removes duplicate instruments at the same offset in a stream (JTW)
- Repeat endings with no number displayed now export to musicxml properly (JTW)
- Several routines such as findGaps were leaving Streams in corrupt states -- fixed (MSC)
partitionByInstrument() no longer leaves instruments with non-zero durations (MSC)
- MuseData reading works properly on zip files created on an OS with different line breaks (MSC)
Thanks always to the Seaver Institute, the NEH, and MIT for support on creating
I'm not sure if the next release will be v7 (with some backwards incompatible changes) or another v6 release (6.7). I do know that better piano support and percussion support are high on my lists. However, I'll be taking a bit of a break from music21 over January at least in order to get other publications out and work with my other projects. Happily, the community engagement with music21 has never been stronger and I'll still be here reviewing Pull Requests and thinking about the next steps!
-- Myke Cuthbert
Music21 version 6.3 has been released. Biggest new feature is compatibility with macOS 11.0 Big Sur, whose numbering system change broke music21. Major bug of
corpus.search() on Windows not working should be fixed also. Chordify users get a nice upgrade also.
pip install --upgrade music21
This is primarily a bug fix release, so let's list the major bugs squashed first:
- Music21 gets the proper mac version and runs in Big Sur (thanks Daniel Fürst)
- corpus.search() should work on PC now. Sharing music21 scores that have been frozen and thawed should also work across Mac and PC.
- ChordSymbols preserve root and bass (thanks to Jacob Tayler Walls = JTW for this and so much else in this release!)
- Instrument names that cannot be decoded from MIDI do not crash MIDI parsing (JTW)
- Audio searches and other searches on empty streams are improved. (JTW)
- Non existent user scratch directory does not raise major bugs any more (David Garfinkle and JTW)
- New location for System/Preview on macOS since Catalina and musescore on Windows (MSC + JTW)
- remove() now searches endElements as well.
- Corrected octaves on pitches derived in IntervalNetwork.nextPitch() (JTW) -- should fix some weird scale pitch octaves.
- TextExpressions now have correct offsets when derived from a tempo indication or coda (JTW)
- MIDI files parsed multiple times with different quantization settings work properly (JTW)
- MIDI files with zero-length notes now create zero-length GraceNotes and not 1.0 length notes in music21 (JTW)
- All tests pass in Python 3.8 (now on to 3.9!)
- Beethoven Opus 59 no 3 mvmt 4 contained all 4 movements in it. Now it only contains movement 4.
- MIDI's matchedNoteOff was not working properly. Works now (Thanks SunWoong KIM)
- If two keys had the same likelihood in probe-tone analysis then only one appeared in .alterateInterpretations. Now there will always be a 23-element list. (ZM-J + JTW)
- C-version of Python Levenshtein was sometimes not being called even if installed. This will greatly speed up similarity searching.
- Harmony.addChordStepModification gets an
updatePitches=True attribute that will immediately apply the chordStepModification to the computed pitches. The default of False remains for now, but will become True in music21 v.7.
- Chordify and Verticality.makeChords gets a new keyword attribute "copyPitches=False" which makes it so that the original pitches (and not deepcopies) from the score appear in the chordified score. This can make it MUCH easier to see which pitches in a chordified score relate to the pitches in the original. However, they are identical objects, so changing one later will change the other. Default behavior is unchanged.
- Repeats play back properly in MIDI (JTW)
- Improved Docs (configuration instructions, typos, examples) (many people but especially JTW)
- Much better typing all around for developers
- math.log2 used instead of math.log(x, 2) for no more floating point confusion in many quarterLengths (JTW)
- Braille keeps its debugging information in Note.editorial instead of custom attributes (backwards incompatible change, but okay)
- Braille/runAllBrailleTests improved for non-sighted developers.
- Incomplete 7th/9th/11th chords find roots better (JTW)
- Legacy code for Python 3.5 removed (JTW)
- Augmented sixth RomanNumerals work w/o needing a key. Also work with secondary numerals (JTW)
- Bach chorales sort by BWV as a number rather than a string (JTW)
- Beethoven quartets from Project Gutenberg had hidden voices w/ incorrect durations to show playback of trills, etc. Those voices have been removed. Speeds up the parsing of those pieces greatly, and gives better feature extractions. Affected pieces are opus 59.1.3, 59.1.4, 59.2.1, 59.2.2, 59.3.2, 59.3.3, 59.3.4, and opus 133.
- Improvements to instrument name lookups (Thanks Mark Gotham)
- Unnecessary list comprehensions are removed.
- For running tests, missing optional modules and Lilypond. will cause import errors.
- ABC module has been partially cleaned up, and made easier for developers to hack new ABC extensions to.
as this is a 6.X release, we have tried to keep backwards incompatible changes to a bare minimum, but a few obscure cases are changed:
.beatStrength on notes without a TimeSignature or MetronomeMark context now return
nan instead of raising an exception.
.beatStr returns the string
"nan". Python 3.8's mock methods iterate through all properties before setting up the mocked object and properties that might raise exceptions cause problems. This seems like a good direction to go in, so please expect that all property getters will switch to never raising an exception but giving
nan or another failure indicator in the future.
- KrumhanslSchmucker and KrumhanslKessler probe tone analysis are now identical. The difference before was probably a typo. They are now synonyms for each other.
Thanks always to the Seaver Institute, the National Endowment for the Humanities, and the School of Humanities, Arts, and Social Sciences and the Music and Theater Arts Section of MIT for their support in making music21 possible. And can we all give applause to Jacob Tayler Walls for all the great work done on this release!
Music21 v6 is OUT as v6.1.0! This represents over 500 commits over the past 14 months since v5.7 was released.
Many thanks to Jacob Tyler Walls (JTW below) who made so many contributions to the v6 branch, both big and small. Mad props and round of applause!
v6 fully supports Python 3.8 and removes support for Python 3.5. v6 will be the last major release to support Python 3.6 and we will work on Python 3.9 support immediately.
As with all new
v.X releases of
music21 there are improvements and some backwards incompatible changes (not too many)
In no particular order, here are the things to look for in the new music21 v6:
Type hints throughout music21 -- when you program with a sophisticated IDE you will be able to see what is returned and required as attributes in much of music21.
music21 is no longer packaged with external modules; these will be installed when installing music21 via pip (otherwise run
pip install -r requirements.txt). Speed and security improvements come with this.
converter.parse('file.mid', quantizePost=False) will let you load in a MIDI file without any quantizing. (Thanks JTW)
Lots more values cached = faster music21; RomanNumerals in particular are over an order of magnitude faster, and Chords are faster too. If you ever have a problem, all Music21Objects have a .clearCache() function. Just add @cacheMethod as a decorator to a method and it will use the caching routine.
Intervals have been rewritten to use properties entirely. So whatever happens to an Interval, its
semiSimpleNiceName (to take one of dozens of examples) will always be up to date. Intervals use
Specifiers that are enums like
interval. Specifier.PERFECTinstead of inscrutable numbers. (those inscrutable numbers still work though) Specifiers are more than just standard enums -- they can invert themselves, do
semitonesAboveMajor() etc. Interval geeks rejoice.
Intervals given a noteStart and a name will generate noteEnd automagically. They also get transposePitch() improvements along the way.
transposePitchFromC() which takes a pitch in C major and returns the pitch in the same scale degree in this key..
Voices with gaps in them work way better in MusicXML. Repeat endings with multiple numbers like 1,2 r/t with musicxml (JTW)
TSV files which encode harmonic analysis can now be parsed (Thanks Mark Gotham)
harm spines parse now, giving another way of encoding harmonic analysis. (Thanks Néstor Nápoles López)
MIDI refactor: easier to subclass and extend and with many docs -- keeps a clear distinction between strings and bytes. MIDI values are all Enum classes (but IntEnums so they compare well with pure numbers)
StripTies works much better thanks to JTW -- and does not filter out non-Notes anymore (technically an incompatibility, but really a bug fix). Voices, etc. don't faze
.stripTies() any more. Stream.voicesToParts() also preserves more elements. Chords with some notes tied and some don't no longer get merged. Note that stripTies
retainContainers defaults to True now, because getting the opposite behavior is as easy as a
Internal but important: lots of parts of music21 code that used abbreviations now spell out the whole word. This is important for our friends using screen readers. While music21 will (for historical/compatibility reasons) still use
camelCase for all method names, attribute names, etc., internal variables may now use
underscore_case which helps with screen readers.
Stream().write('mxl') will write compressed musicxml (JTW). Or
write('...', format='musicxml', compress=True)
Improvements to VoiceLeadingQuartets (thanks Ryaan Ahmed), including finding parallel intervals with octave displacement. voiceCrossing and voiceOverlap detection.
Substantial improvements to RomanText: see https://dmitri.mycpanel.princeton.edu/romantext.pdf
RomanNumerals can specify how they represent ^6 and ^7 in minor with
OMR fixers can recognize Turns and other ornaments. More merging here to come. Thanks Janelle Sands!
Substantial improvements to beaming routines and tests (thanks Almog Cohen!)
Keys now have
.deriveByDegree() like Scales, so "What minor key has scale degree 3 as B-flat?" can easily be answered.
Improvements to dotted tuplets (Almog Cohen)
Chord.name/fullName now gives better names for common chords like Major/Minor triads -- no longer relies entirely on chord.tables. But even there many improvements and spelling corrections.
.notes to get at the notes that make up a chord, in a different way than
for n in Chord -- I'm still an old Perl guy, sometimes There's More Than One Way to Do It, and this way makes some things conceptually much easier and faster.
More Bach Chorale fixes from Doctor Schmidt (thanks!)
Stream.replace(recurse=True) finally works!
StringIndication, FretIndication work in musicxml (thanks Peter Mitrano)
For those who are adventurous -- intervalNetworks are now exposed on scales.
prebase.ProtoM21Object -- an idea ported back from
music21j: nearly every object in
music21, including all Music21Objects, inherits from this super-lightweight base class which allows for querying classes and giving consistent representations. It makes working in music21 a lot more fun.
- Stream filters now return a new StreamIterator. So old code like:
s = stream.Stream()
sIter = s.iter
should now be written as:
s = stream.Stream()
sIter = s.iter
sIter2 = sIter.getElementsByClass('Chord')
For most people using filters within a for-loop, nothing will appear to have changed.
if element in stream now only returns True if the element is actually in the Stream, not if element is equal to something in the Stream. This is not normal Python behavior for
__contains__ but it is something music21 users have counted on for a decade, and now it is assured.
MIDI has been completely refactored, so if you are mucking with MIDI internals, it's going to be completely different. If you're just using
.write('midi') it won't have changed much.
- Setting a pitch's accidental to a number is deprecated and to be removed soon. use
b = pitch.Pitch('B4'); b.accidental = pitch.Accidental(-1).
- some long deprecated functions removed, such as Stream.restoreActiveSites, Stream. _yieldReverseUpwardsSearch, common.standardDeviation (use statistics.stdev instead).
- Chord sort methods no longer return the chord itself if
- interval.convertSemitoneToSpecifierGenericMicrotone, convertSemitoneToSpecifierGeneric now return a Specifier Enum as their first value
- Spelling corrections that are technically incompatible: Interval.perfectable replaces typo Interval.prefectable. Appoggiatura is spelled correctly with two-gs everywhere it's used (JTW)
stripTies(retainContainers=True) is now the default.
- Half-diminished chords have ø7 etc. as their default representation.
- MIDI.intsToHexString has become MIDI.intsToHexBytes which does what is says it does.
Small Changes/Bugs squashed:
- A malformed spanner in musicxml will no longer crash parsing.
- Tuplets are equal if their durations are equal. Better docs for duration equality.
getContextByClass have a
activeSiteOnly keyword for searching activeSite only. Speed!
music21.X import * works much more reliably.
- Bugs fixed in feature extraction of keys.
serial allows "P" or "T" to be used for transpositions
- Tone-Rows give their row in the repr.
- Historical tone-rows no longer have Row in their name. For instance:
serial.getHistoricalRowByName('SchoenbergOp37').matrix() -- the old form still works though.
- Feature extraction on empty streams (or ones that don't have instruments or something else) works properly (JTW)
- Feature output formats can set
.ext directly, in case you need a different extension.
- viio7 can be specified as vii07
- Interval: reverse=True works properly
- subprocess.run is used instead of os.system for PNG generation. Thanks Uğur Güney. Fixes using musescore with music21 in Jupyter when spaces appear in filenames. (also thanks to Frank Zalkow)
- Better representation for many objects
- Error handling for incorrect chord abbreviation is improved. Thanks Vikram Natarajan
- Librettists and lyricists can be searched in metadata.
.age() works properly for living composers.
- MIDI plays back properly in Jupyter again BUT also does not add a delay when writing out a file.
- Voice numbers in generated musicxml are now low numbers
- pitch.Accidental gets
. setAttributeIndependently() in case you want something to look like a flat but only alter 0.8 semitones. (This appeared in v.5 at some point but was never announced)
- Note gets a
pitchChanged() method which is called by its attached pitch anytime it changes so that caches can be used. Pitch gets an
informClient() method which is called anytime the pitch itself changes. There is something similar in Chords too. This squashes a lot of bugs where pitches were changing but notes/chords/scales/etc. did not act like they had changed.
- makeAccidentals works properly in Voices (JTW)
- MIDI parsing gets more instrument objects from more places (JTW)
- zero-length objects at the end of streams were being ignored by makeNotation (JTW)
- Show formats: MuseScore 3.5 compatibility. (JTW). Preview is found by default on macOS Catalina/Big Sur -- still works for older OSes. No more 'is your doc > 999 pages?' bugs!
- Some Neo-Riemannian docs weren't showing (thanks Adam Spiers)
- Tone profiles for key analysis have been corrected. (thanks Micah Walter)
scaleDegreeWithAlteration on Augmented 6th chords works.
.musicxml is fully recognized as a suffix.
- Improvements to analysis.windowed (thanks Sandro Luck)
- RepeatExpander now does nothing on a score with no repeats. Before, it crashed.
- Sousa example couldn't show before (thanks David H. Gutteridge)
- Verticality.removeVerticalDissonances now works (also thanks to Gutteridge)
- Z-relation for 5Z37 (5Z17) was incorrect (thanks Rodrigo Balthar Furman for spotting this)
- Power-users who subclass Stream to be standard storage variants:
Stream().coreSelfActiveSite(el) allows for subclassing what happens when an element should normally have its
activeSite set to the stream.
- Lilypond output with UTF-8 works. Grace notes no longer crash Lilypond. Now that there is a 64-bit binary Mac version of Lilypond, it will not be removed from music21.
- RomanNumerals compare with each other.
__eq__ logically defined.
- Modest performance improvements in sorting (Thanks Alexander Morgan)
- Documentation and test improvements and a few bugs squashed in ABC parsing.
- f-strings used throughout music21 allowing for more detailed error messages and many bugs to be detected and removed.
- interval.Interval.convertSpecifier() deprecated. use
- Humdrum parseData() and parseFile() are deprecated. use the general converter.parse() instead.
.editorial.misc is deprecated, just stick whatever you want on the
.editorial object itself.
As always, I want to thank MIT, the NEH, and the Seaver Institute for supporting
music21 over the years along with the community of developers who use and give back to
Music21 v5.7.2 has been released.
This release adds basic support for running music21 v5 on Python 3.8 — the full test suite does not pass on py 3.8 but the differences there appear to be cosmetic.
If you are using Python 3.8 run:
pip install --upgrade music21
Music21 v5.7 is the fourth and final release in the v5 series. It brings under the hood fixes -- lots of bug fixes and speed ups and some new features -- from 126 commits since last October.
Download by running from command line:
pip install --upgrade music21
This is the last release of the v5 series so that work on v6 which may bring some backwards incompatible changes -- all deprecated features will be removed, as will support for Python 3.5 (by the time v6 is released, Py3.8 will be out and this keeps w/ music21 policy of supporting the last three Python releases). The release of v5.7 also marks the End-of-Life for music21 v4 (the last release to support Python 2.7); if someone wants to continue supporting v4/Python 2.7 in music21, please let me know, but I'm so happy with how quickly almost all of us have moved to Python 3. Looking forward to major tablature improvements, SMuFL support, and much faster development thanks to "f-strings" in v6.
The music21 user community continues to be active and robust as attested by the number of contributed features below. Thanks for keeping me sustained during my non-music Admin time! Among the most notable improvements are (in reverse chronological order):
Type hints on major objects and functions in the library and the promise of more (once Py3.5 is dropped) soon. Those who use fancy IDEs like PyCharm will reap major bug checks!
The most extensive typo-checking / spell-checking / linting ever done to music21 -- the code now has that new car smell.
Stream.measures(4, "5a") -- measure suffixes work in many more places in the code.
Pizzicato notes export properly in MusicXML
Improvements to MEI accidental handling (kudos @raffazizzi
KeySignatures work better in multi-voice contexts (thanks @pconerly
Bugs that made
.getContextByClass() sometimes inconsistent (especially with forward searches) fixed.
Harmony objects (ChordSymbols, etc.) sort before Notes so that the harmony of a note at the offset can be found easier. And proper musicxml offset support (thanks @a-papadopoulos
Chord.notes gives direct access to the underlying Note objects that make up a Chord. Chords also get a good
Added Neo-Riemannian analysis features (thanks @MarkGotham
) and triads can now know which hexatonic system they belong to.
Fixes to MusicXML chord input.
Barlines now use "type=double" instead of "style=double", since in v6 they will get full
User's Guide gets the long awaited Chapter 58 on Sites and Contexts for advanced users.
Clefs get a
.name property so that the class does not need to be parsed.
Grace notes no longer cause obscure bugs in
A bug in Interval.direction for some perfect intervals is fixed (thanks @ryaanahmed
team for identifying the bug)
As always, I want to acknowledge MIT Music and Theater Arts and the School of Humanities, Arts, and Social Sciences for encouraging the development of music21. Founding contributions to music21 were made by the Seaver Institute and the National Endowment for the Humanities.
How can I contribute?
Music21 is a rapidly-progressing project,
but it is always looking for researchers interested
in contributing code, questions, freely-distributable pieces, bug
fixes, or documentation. Please
contact Michael Scott
Cuthbert (cuthbert at mit.edu), music21 creator, or on the music21list.
The development of music21 has been
supported by the School of
Humanities, Arts, and Social Sciences
and Theater Arts section, and
generous grants from the Seaver Institute and the
NEH/Digging-Into-Data Challenge. Further donations to the project are always welcome.