music21-rs

Wheel report

Rust docs Python docs

commit 94ed57a / music21 11.0.0b12 from float3/music21 5151b5189 / Python 3.13.16 / Linux-6.17.0-1022-azure-x86_64-with-glibc2.39

music21 API in the wheel 59.5% 973 of 1635 members; 662 lacking, 46 the crate has no function for

Own tests 356 passing, across 3 suites Median speedup 32.5× over music21 through the same Python API, across 24 operations Cost of the binding 3.3 µs a call, median, over the same call in Rust A whole program 1.00× median over 3927 of music21's own tests, installed over it Install size 5.6 MB what pip installs; music21 is 88.3 MB, 16× that music21's examples 79.5% 9191 of 11558 examples, across 47 modules

music21's docstrings 86.9% 1032 of 1188 docstrings, across 47 modules

music21's unit tests 100.0% 666 of 666 tests, across 47 modules

music21's own suite 0 regressions 5155 passing; the 0 failing are music21's own or listed

The suites that test the wheel

5511 passing, all green

Suite	Tests	Result	Passed	Failed	Command
Python parity and music21's doctests	cratewheel	passed	157	0	`cargo test --manifest-path python-parity/Cargo.toml -- --test-threads=1`
Python wheel`music21_rs-0.10.0-cp313-cp313-manylinux_2_34_x86_64.whl`	wheel	passed	—	—	`maturin build --release --manifest-path python/Cargo.toml`
Python wheel tests	wheel	passed	199	0	`python -m pytest python/tests`
music21's own test suiteRun twice, once on music21 and once on the crate, and diffed: music21's own suite fails a number of its own tests in any environment, so what counts is that the two sets match.`0 of these fail on music21 itself; 0 fail only under music21_rs`	cratewheel	passed	5155	0	`cargo run --release -p xtask --features python -- music21-suite`

A suite whose tooling is not installed is skipped, with the reason, rather than failed. One marked for both runs music21's code over the wheel's classes, which answer out of the crate, so a failure there may be either's.

Speed and size against music21

wheel 32.5× median, across 24 cases

Case	music21	wheel	wheel ×	binding
construction
`Pitch('C#4')`	1.5 µs	2.0 µs	0.8×	+1.8 µs
`Note('C#4')`	7.0 µs	863 ns	8.1×	+729 ns
`Interval('P5')`	15.0 µs	462 ns	32.5×	+388 ns
`Chord('C4 E4 G4')`	28.2 µs	6.5 µs	4.3×	+5.9 µs
chord analysis
`Chord.commonName`5 chords	893.1 µs	12.5 µs	71.2×	+3.5 µs
`Chord.root()`5 chords	194.8 µs	15.9 µs	12.2×	—
`Chord.inversion()`5 chords	291.0 µs	7.8 µs	37.4×	+3.9 µs
`Chord.forteClass`5 chords	418.7 µs	9.8 µs	42.7×	+3.7 µs
`Chord.primeForm`5 chords	421.3 µs	10.5 µs	40.2×	+3.7 µs
`Chord.intervalVector`5 chords	421.1 µs	10.5 µs	40.2×	+3.2 µs
`Chord.isDominantSeventh()`5 chords	412.9 µs	7.6 µs	54.0×	+3.2 µs
`Chord.orderedPitchClasses`5 chords	184.2 µs	8.2 µs	22.6×	+3.3 µs
`Chord: forteClass + primeForm + intervalVector`one chord, three questions	93.7 µs	3.8 µs	24.6×	+800 ns
pitch
`Pitch.transpose('M3')`	41.9 µs	2.6 µs	15.9×	+2.3 µs
`Pitch.frequency`	1.4 µs	2.2 µs	0.7×	+1.9 µs
`Pitch.getEnharmonic()`	33.8 µs	2.4 µs	13.9×	—
`Interval(p1, p2)`	16.6 µs	3.8 µs	4.4×	+3.5 µs
serial
`pcToToneRow(...).matrix()`	4.2 ms	5.9 µs	711.1×	+466 ns
`ToneRow.zeroCenteredTransformation`	408.6 µs	817 ns	500.2×	+321 ns
figured bass
`Segment(G2, '7').allCorrectSinglePossibilities()`	4.4 ms	83.9 µs	52.1×	+30.6 µs
`Segment(G2, '7') to Segment(C3), a dominant seventh resolving`	17.2 ms	340.6 µs	50.5×	+81.2 µs
`Segment(C3) to Segment(D3, '4,3'), every pair of voicings`	6.2 ms	154.8 µs	39.8×	+64.3 µs
warm object
`Chord.commonName (cached)`music21 memoizes	120 ns	78 ns	1.5×	—
`Chord.forteClass (cached)`music21 memoizes	2.3 µs	75 ns	29.9×	—

music21 11.0.0b12, Python 3.13.16 (Linux-6.17.0-1022-azure-x86_64-with-glibc2.39). Every side must agree on the answer before any of them is timed. wheel is what a caller installs, asked through the same Python API as music21; crate is the same operation in Rust with no Python in the way, and binding is what lies between the two. Each case builds a fresh object, except those marked cached.

3927 of music21's own tests, timed on every side102s on music21, 97s on music21-rs, 98s on music21-rs-wheel; music21-rs-wheel median 1.00×

Test	music21	music21-rs-wheel	music21-rs-wheel ×
furthest ahead
`timeSignatureToMidiEvents (music21.midi.translate)`	404 ms	3 ms	137.09×
`findTransformedHistorical (music21.serial.TwelveToneRow)`	92 ms	1 ms	78.64×
`isTranspositionallySymmetrical (music21.chord.Chord)`	108 ms	3 ms	38.56×
`testFigureFromChordAddOmit (music21.harmony.Test.testFigureFromChordAddOmit)`	100 ms	3 ms	32.67×
`fromIntervalVector (music21.chord)`	59 ms	2 ms	27.04×
`getZRelation (music21.chord.Chord)`	56 ms	2 ms	26.47×
`findHistorical (music21.serial.TwelveToneRow)`	31 ms	1 ms	25.46×
`testOctaveRepeatingScaleStepsReachingAnEnharmonicOctave (music21.scale.test_scale_main.Test.testOctaveRepeatingScaleStepsReachingAnEnharmonicOctave)`	68 ms	3 ms	24.50×
`fromForteClass (music21.chord)`	39 ms	2 ms	21.79×
`simplifyMultipleEnharmonics (music21.pitch)`	38 ms	2 ms	19.13×
`testMelodicMinorB (music21.scale.test_scale_main.Test.testMelodicMinorB)`	40 ms	2 ms	18.68×
`TranspositionChecker (music21.analysis.transposition)`	38 ms	2 ms	15.16×
furthest behind
`testARFFNumericClassValues (music21.features.outputFormats.Test.testARFFNumericClassValues)`	17 ms	2.00 s	0.01×
`testIncludeClassLabelAndId (music21.features.outputFormats.Test.testIncludeClassLabelAndId)`	30 ms	1.98 s	0.02×
`testParallelRun (music21.features.base.Test.testParallelRun)`	334 ms	2.31 s	0.14×
`testIncludeFlagsOff (music21.features.base.Test.testIncludeFlagsOff)`	445 ms	2.40 s	0.19×
`test_makeBeams__paddingRight (music21.stream.tests.Test.test_makeBeams__paddingRight)`	2 ms	10 ms	0.23×
`SaxophoneFractionFeature (music21.features.jSymbolic)`	4 ms	13 ms	0.33×
`setMinorRootParse (music21.romanText.translate.PartTranslator)`	3 ms	8 ms	0.34×
`populateFromSortedList (music21.tree.core.AVLTree)`	3 ms	7 ms	0.41×
`testCoreUnit2 (music21.mei.test_base.Test.testCoreUnit2)`	5 ms	12 ms	0.43×
`test_example04_4 (music21.braille.test.Test.test_example04_4)`	6 ms	14 ms	0.43×
`quarterConversion (music21.duration)`	17 ms	38 ms	0.44×
`testTextExpressionsD (music21.musicxml.test_xmlToM21.Test.testTextExpressionsD)`	12 ms	24 ms	0.49×

A test counts only where every side ran it, passed it, and took longer than a millisecond, and what the garbage collector took inside a test is taken off before the sides are compared — a full collection lands on whichever test is running, and each test is timed once. music21-rs is the crate linked into the binary that ran the suite — the working tree — and music21-rs-wheel is the wheel a caller installs, so what lies between those two is the packaging rather than the code. All 3927 tests, side by side →

What each costs to install

music21

88.3 MBinstalled package, corpus and all

music21_rs wheel

5.6 MBwhat pip installs

Against music21's own tests

9191 of 11558 examples and 666 of 666 unit tests, across 47 modules, 7 with no harness yet

Module	Docstrings	Examples	Unit tests
`music21.stream.base`no harness yet	0 of 144	0 of 2278	271 of 271
`music21.chord`	108 of 108	981 of 981	31 of 31
`music21.pitch`	84 of 84	934 of 934	38 of 38
`music21.interval`	107 of 107	771 of 771	14 of 14
`music21.duration`	53 of 53	588 of 588	16 of 16
`music21.roman`	34 of 34	560 of 560	34 of 34
`music21.voiceLeading`	61 of 61	515 of 515	2 of 2
`music21.meter.base`	34 of 34	387 of 387	22 of 22
`music21.meter.core`	39 of 39	386 of 386	none
`music21.harmony`	26 of 26	364 of 364	28 of 28
`music21.expressions`	40 of 40	350 of 350	12 of 12
`music21.scale`	62 of 62	344 of 344	58 of 58
`music21.note`	33 of 33	341 of 341	13 of 13
`music21.key`	18 of 18	245 of 245	7 of 7
`music21.figuredBass.possibility`	16 of 16	211 of 211	none
`music21.tempo`	27 of 27	196 of 196	17 of 17
`music21.figuredBass.resolution`	13 of 13	172 of 172	none
`music21.clef`	29 of 29	151 of 151	4 of 4
`music21.instrument`	15 of 15	150 of 150	12 of 12
`music21.serial`	22 of 22	149 of 149	6 of 6
`music21.figuredBass.notation`	12 of 12	129 of 129	3 of 3
`music21.analysis.discrete`	25 of 25	122 of 122	7 of 7
`music21.figuredBass.segment`	12 of 12	122 of 122	none
`music21.beam`	13 of 13	112 of 112	2 of 2
`music21.analysis.neoRiemannian`	13 of 13	107 of 107	6 of 6
`music21.sieve`	25 of 25	107 of 107	9 of 9
`music21.articulations`	27 of 27	105 of 105	2 of 2
`music21.figuredBass.checker`	12 of 12	102 of 102	none
`music21.figuredBass.realizer`	8 of 8	80 of 80	3 of 3
`music21.figuredBass.examples`	11 of 11	71 of 71	none
`music21.chord.tables`	10 of 10	65 of 65	5 of 5
`music21.scale.scala`	7 of 7	55 of 55	5 of 5
`music21.dynamics`	6 of 6	49 of 49	6 of 6
`music21.volume`	9 of 9	46 of 46	9 of 9
`music21.analysis.windowed`no harness yet	0 of 3	0 of 35	5 of 5
`music21.analysis.transposition`	7 of 7	28 of 28	7 of 7
`music21.figuredBass.realizerScale`	4 of 4	26 of 26	none
`music21.figuredBass.harmony`	4 of 4	24 of 24	none
`music21.analysis.harmonicFunction`	2 of 2	22 of 22	4 of 4
`music21.analysis.floatingKey`no harness yet	0 of 2	0 of 14	1 of 1
`music21.analysis.patel`no harness yet	0 of 2	0 of 14	none
`music21.analysis.metrical`no harness yet	0 of 2	0 of 13	none
`music21.tie`	2 of 2	13 of 13	1 of 1
`music21.analysis.pitchAnalysis`no harness yet	0 of 1	0 of 7	none
`music21.analysis.enharmonics`	1 of 1	6 of 6	4 of 4
`music21.analysis.segmentByRests`no harness yet	0 of 2	0 of 6	2 of 2
`music21.figuredBass.rules`	1 of 1	5 of 5	none
every module	1032 of 1188	9191 of 11558	666 of 666

music21's own docstrings and unit tests, run over the wheel's classes answering out of the crate, so a row here is a row for both. A docstring passes only when every one of its examples does. Every docstring is read as music21's own runner reads it, which rewrites an object's address to 0x... before comparing; the unit-test column is music21's own test suite, attributed per module, where a test music21 itself fails counts as not passing.

music21's API in the wheel

1635 members:973 in the wheel

▶Chordchord/__init__.py wheel 97 of 97

Chord analysis and the notation its notes carry. The per-note getters and setters music21 deprecated in v11 are the note's own methods here, reached through notes_mut.

music21	Wheel	In the crate
`formatVectorString`	in the wheel	`format_vector_string`
`add`	in the wheel	`add`
`annotateIntervals`	in the wheel	`annotate_intervals`
`areZRelations`	in the wheel	`are_z_relations`
`bass`	in the wheel	`bass`
`canBeDominantV`	in the wheel	`can_be_dominant_v`
`canBeTonic`	in the wheel	`can_be_tonic`
`closedPosition`	in the wheel	`closed_position`
`containsSeventh`	in the wheel	`contains_seventh`
`containsTriad`	in the wheel	`contains_triad`
`geometricNormalForm`	in the wheel	`geometric_normal_form`
`getChordStep`	in the wheel	`chord_step`
`getColor`	in the wheel	`color`
`getNotehead`	in the wheel	`notehead`
`getNoteheadFill`	in the wheel	`notehead_fill`
`getStemDirection`	in the wheel	`stem_direction`
`getTie`	in the wheel	`tie`
`getVolume`	in the wheel	`volume`
`getZRelation`	in the wheel	`z_relation`
`hasAnyEnharmonicSpelledPitches`	in the wheel	`has_any_enharmonic_spelled_pitches`
`hasAnyRepeatedDiatonicNote`	in the wheel	`has_any_repeated_diatonic_note`
`hasRepeatedChordStep`	in the wheel	`has_repeated_chord_step`
`intervalFromChordStep`	in the wheel	`interval_from_chord_step`
`inversion`	in the wheel	`inversion`
`setInversion`	in the wheel	`set_inversion`
`inversionName`	in the wheel	`inversion_name`
`inversionText`	in the wheel	`inversion_text`
`isAugmentedSixth`	in the wheel	`is_augmented_sixth`
`isAugmentedTriad`	in the wheel	`is_augmented_triad`
`isConsonant`	in the wheel	`is_consonant`
`isDiminishedSeventh`	in the wheel	`is_diminished_seventh`
`isSeventhOfType`	in the wheel	`is_seventh_of_type`
`isDiminishedTriad`	in the wheel	`is_diminished_triad`
`isDominantSeventh`	in the wheel	`is_dominant_seventh`
`isFalseDiminishedSeventh`	in the wheel	`is_false_diminished_seventh`
`isFrenchAugmentedSixth`	in the wheel	`is_french_augmented_sixth`
`isGermanAugmentedSixth`	in the wheel	`is_german_augmented_sixth`
`isHalfDiminishedSeventh`	in the wheel	`is_half_diminished_seventh`
`isIncompleteMajorTriad`	in the wheel	`is_incomplete_major_triad`
`isIncompleteMinorTriad`	in the wheel	`is_incomplete_minor_triad`
`isItalianAugmentedSixth`	in the wheel	`is_italian_augmented_sixth`
`isMajorTriad`	in the wheel	`is_major_triad`
`isMinorTriad`	in the wheel	`is_minor_triad`
`isTranspositionallySymmetrical`	in the wheel	`is_transpositionally_symmetrical`
`isSeventh`	in the wheel	`is_seventh`
`isNinth`	in the wheel	`is_ninth`
`isSwissAugmentedSixth`	in the wheel	`is_swiss_augmented_sixth`
`isTriad`	in the wheel	`is_triad`
`removeRedundantPitches`	in the wheel	`remove_redundant_pitches`
`removeRedundantPitchClasses`	in the wheel	`remove_redundant_pitch_classes`
`removeRedundantPitchNames`	in the wheel	`remove_redundant_pitch_names`
`root`	in the wheel	`root`
`semiClosedPosition`	in the wheel	`semi_closed_position`
`semitonesFromChordStep`	in the wheel	`semitones_from_chord_step`
`setColor`	in the wheel	`set_color`
`setNotehead`	in the wheel	`set_notehead`
`setNoteheadFill`	in the wheel	`set_notehead_fill`
`setStemDirection`	in the wheel	`set_stem_direction`
`setTie`	in the wheel	`set_tie`
`setVolume`	in the wheel	`set_volume`
`simplifyEnharmonics`	in the wheel	`simplify_enharmonics`
`isSortedDiatonicAscending`	in the wheel	`is_sorted_diatonic_ascending`
`sortAscending`	in the wheel	`sort_ascending`
`sortChromaticAscending`	in the wheel	`sort_chromatic_ascending`
`sortDiatonicAscending`	in the wheel	`sort_diatonic_ascending`
`sortFrequencyAscending`	in the wheel	`sort_frequency_ascending`
`transpose`	in the wheel	`transpose`
`chordTablesAddress`	in the wheel	`chord_tables_address_entry`
`commonName`	in the wheel	`common_name`
`duration`	in the wheel	`duration`
`fifth`	in the wheel	`fifth`
`forteClass`	in the wheel	`forte_class`
`forteClassNumber`	in the wheel	`forte_class_number`
`forteClassTn`	in the wheel	`forte_class_tn`
`forteClassTnI`	in the wheel	`forte_class_tni`
`fullName`	in the wheel	`full_name`
`hasZRelation`	in the wheel	`has_z_relation`
`intervalVector`	in the wheel	`interval_class_vector`
`intervalVectorString`	in the wheel	`interval_vector_string`
`isPrimeFormInversion`	in the wheel	`is_prime_form_inversion`
`multisetCardinality`	in the wheel	`multiset_cardinality`
`notes`	in the wheel	`notes`
`normalOrder`	in the wheel	`normal_order`
`normalOrderString`	in the wheel	`normal_order_string`
`orderedPitchClasses`	in the wheel	`pitch_classes`
`orderedPitchClassesString`	in the wheel	`ordered_pitch_classes_string`
`pitchClassCardinality`	in the wheel	`pitch_class_cardinality`
`pitchClasses`	in the wheel	`note_pitch_classes`
`pitchNames`	in the wheel	`pitch_names`
`pitchedCommonName`	in the wheel	`pitched_common_name`
`pitches`	in the wheel	`pitches`
`primeForm`	in the wheel	`prime_form`
`primeFormString`	in the wheel	`prime_form_string`
`quality`	in the wheel	`quality`
`scaleDegrees`	in the wheel	`scale_degrees`
`seventh`	in the wheel	`seventh`
`third`	in the wheel	`third`

▶Pitchpitch.py wheel 45 of 45

music21	Wheel	In the crate
`groups`	in the wheel	the group names music21 picks elements out of a stream by (`getElementsByGroup`); a stream here picks by kind and by position, and nothing in it carries group names
`accidental`	in the wheel	`accidental`
`microtone`	in the wheel	`microtone`
`isTwelveTone`	in the wheel	`is_twelve_tone`
`getCentShiftFromMidi`	in the wheel	`cent_shift_from_midi`
`alter`	in the wheel	`alter`
`convertQuarterTonesToMicrotones`	in the wheel	`convert_quarter_tones_to_microtones`
`convertMicrotonesToQuarterTones`	in the wheel	`convert_microtones_to_quarter_tones`
`ps`	in the wheel	`ps`
`midi`	in the wheel	`midi`
`name`	in the wheel	`name`
`unicodeName`	in the wheel	`unicode_name`
`nameWithOctave`	in the wheel	`name_with_octave`
`unicodeNameWithOctave`	in the wheel	`unicode_name_with_octave`
`fullName`	in the wheel	`full_name`
`step`	in the wheel	`step`
`pitchClass`	in the wheel	`pitch_class`
`pitchClassString`	in the wheel	`pitch_class_string`
`octave`	in the wheel	`octave`
`octaveIsImplicit`	in the wheel	`octave_is_implicit`
`implicitOctave`	in the wheel	`implicit_octave`
`german`	in the wheel	`german`
`italian`	in the wheel	`italian`
`spanish`	in the wheel	`spanish`
`french`	in the wheel	`french`
`frequency`	in the wheel	`frequency_hz`
`freq440`	in the wheel	`frequency_hz`
`getHarmonic`	in the wheel	`harmonic`
`harmonicFromFundamental`	in the wheel	`harmonic_from_fundamental`
`harmonicString`	in the wheel	`harmonic_string`
`harmonicAndFundamentalFromPitch`	in the wheel	`harmonic_and_fundamental_from_pitch`
`harmonicAndFundamentalStringFromPitch`	in the wheel	`harmonic_and_fundamental_string_from_pitch`
`isEnharmonic`	in the wheel	`is_enharmonic`
`getHigherEnharmonic`	in the wheel	`get_higher_enharmonic`
`getLowerEnharmonic`	in the wheel	`get_lower_enharmonic`
`simplifyEnharmonic`	in the wheel	`simplify_enharmonic`
`getEnharmonic`	in the wheel	`get_enharmonic`
`informClient`	in the wheel	observer callback for a containing note; there is none
`getAllCommonEnharmonics`	in the wheel	`all_common_enharmonics`
`diatonicNoteNum`	in the wheel	`diatonic_note_number`
`transpose`	in the wheel	`transpose`
`transposeBelowTarget`	in the wheel	`transpose_below_target`
`transposeAboveTarget`	in the wheel	`transpose_above_target`
`updateAccidentalDisplay`	in the wheel	`update_accidental_display`
`getStringHarmonic`	in the wheel	`string_harmonic`

▶Accidentalpitch.py wheel 12 of 12

music21	Wheel	In the crate
`listNames`	in the wheel	`list_names`
`set`	in the wheel	`set`
`isTwelveTone`	in the wheel	`is_twelve_tone`
`setAttributeIndependently`	in the wheel	`set_attribute_independently`
`inheritDisplay`	in the wheel	`inherit_display`
`name`	in the wheel	`name`
`alter`	in the wheel	`alter`
`modifier`	in the wheel	`modifier`
`displayType`	in the wheel	`display_type`
`displayStatus`	in the wheel	`display_status`
`unicode`	in the wheel	`unicode`
`fullName`	in the wheel	`full_name`

▶Microtonepitch.py wheel 3 of 3

music21	Wheel	In the crate
`alter`	in the wheel	`alter`
`cents`	in the wheel	`cents`
`harmonicShift`	in the wheel	`harmonic_shift`

▶Intervalinterval.py wheel 29 of 29

music21	Wheel	In the crate
`generic`	in the wheel	`generic`
`name`	in the wheel	`short_name`
`niceName`	in the wheel	`name`
`simpleName`	in the wheel	`simple_name`
`simpleNiceName`	in the wheel	`simple_nice_name`
`semiSimpleName`	in the wheel	`semi_simple_name`
`semiSimpleNiceName`	in the wheel	`semi_simple_nice_name`
`directedName`	in the wheel	`directed_name`
`directedNiceName`	in the wheel	`directed_nice_name`
`directedSimpleName`	in the wheel	`directed_simple_name`
`directedSimpleNiceName`	in the wheel	`directed_simple_nice_name`
`semitones`	in the wheel	`semitones`
`direction`	in the wheel	`direction`
`specifier`	in the wheel	`specifier`
`specificName`	in the wheel	`specific_name`
`isDiatonicStep`	in the wheel	`is_diatonic_step`
`isChromaticStep`	in the wheel	`is_chromatic_step`
`isStep`	in the wheel	`is_step`
`isSkip`	in the wheel	`is_skip`
`isConsonant`	in the wheel	`is_consonant`
`complement`	in the wheel	`complement`
`intervalClass`	in the wheel	`interval_class`
`cents`	in the wheel	`cents`
`transposePitch`	in the wheel	`transpose_pitch`
`reverse`	in the wheel	`reversed`
`pitchStart`	in the wheel	`pitch_start`
`pitchEnd`	in the wheel	`pitch_end`
`noteStart`	in the wheel	`note_start`
`noteEnd`	in the wheel	`note_end`

▶GenericIntervalinterval.py wheel 26 of 26

music21	Wheel	In the crate
`value`	in the wheel	`value`
`directed`	in the wheel	`directed`
`undirected`	in the wheel	`undirected`
`direction`	in the wheel	`direction`
`isSkip`	in the wheel	`is_skip`
`isDiatonicStep`	in the wheel	`is_diatonic_step`
`isStep`	in the wheel	`is_step`
`isUnison`	in the wheel	`is_unison`
`simpleUndirected`	in the wheel	`simple_undirected`
`semiSimpleUndirected`	in the wheel	`semi_simple_undirected`
`undirectedOctaves`	in the wheel	`undirected_octaves`
`octaves`	in the wheel	`octaves`
`simpleDirected`	in the wheel	`simple_directed`
`semiSimpleDirected`	in the wheel	`semi_simple_directed`
`perfectable`	in the wheel	`is_perfectable`
`niceName`	in the wheel	`nice_name`
`simpleNiceName`	in the wheel	`simple_nice_name`
`semiSimpleNiceName`	in the wheel	`semi_simple_nice_name`
`staffDistance`	in the wheel	`staff_distance`
`mod7inversion`	in the wheel	`mod7_inversion`
`mod7`	in the wheel	`mod7`
`complement`	in the wheel	`complement`
`reverse`	in the wheel	`reverse`
`transposePitch`	in the wheel	`transpose_pitch`
`transposePitchKeyAware`	in the wheel	`transpose_pitch_key_aware`
`getDiatonic`	in the wheel	`get_diatonic`

▶DiatonicIntervalinterval.py wheel 25 of 25

music21	Wheel	In the crate
`name`	in the wheel	`name`
`niceName`	in the wheel	`nice_name`
`specificName`	in the wheel	`specific_name`
`simpleName`	in the wheel	`simple_name`
`simpleNiceName`	in the wheel	`simple_nice_name`
`semiSimpleName`	in the wheel	`semi_simple_name`
`semiSimpleNiceName`	in the wheel	`semi_simple_nice_name`
`direction`	in the wheel	`direction`
`directedName`	in the wheel	`directed_name`
`directedNiceName`	in the wheel	`directed_nice_name`
`directedSimpleName`	in the wheel	`directed_simple_name`
`directedSimpleNiceName`	in the wheel	`directed_simple_nice_name`
`directedSemiSimpleName`	in the wheel	`directed_semi_simple_name`
`directedSemiSimpleNiceName`	in the wheel	`directed_semi_simple_nice_name`
`isStep`	in the wheel	`is_step`
`isDiatonicStep`	in the wheel	`is_diatonic_step`
`isSkip`	in the wheel	`is_skip`
`perfectable`	in the wheel	`is_perfectable`
`mod7inversion`	in the wheel	`mod7_inversion`
`mod7`	in the wheel	`mod7`
`reverse`	in the wheel	`reverse`
`getChromatic`	in the wheel	`get_chromatic`
`transposePitch`	in the wheel	`transpose_pitch`
`specifierAbbreviation`	in the wheel	`specifier_abbreviation`
`cents`	in the wheel	`cents`

▶ChromaticIntervalinterval.py wheel 13 of 13

music21	Wheel	In the crate
`cents`	in the wheel	`cents`
`directed`	in the wheel	`directed`
`undirected`	in the wheel	`undirected`
`direction`	in the wheel	`direction`
`mod12`	in the wheel	`mod12`
`simpleUndirected`	in the wheel	`simple_undirected`
`simpleDirected`	in the wheel	`simple_directed`
`intervalClass`	in the wheel	`interval_class`
`isChromaticStep`	in the wheel	`is_chromatic_step`
`isStep`	in the wheel	`is_step`
`reverse`	in the wheel	`reverse`
`getDiatonic`	in the wheel	`get_diatonic`
`transposePitch`	in the wheel	`transpose_pitch`

▶Specifierinterval.py wheel 4 of 4

music21	Wheel	In the crate
`niceName`	in the wheel	`nice_name`
`inversion`	in the wheel	`inversion`
`semitonesAbovePerfect`	in the wheel	`semitones_above_perfect`
`semitonesAboveMajor`	in the wheel	`semitones_above_major`

▶interval.py functionsinterval.py wheel 20 of 20

Module-level helpers.

music21	Wheel	In the crate
`convertStaffDistanceToInterval`	in the wheel	`staff_distance_to_generic_number`
`convertDiatonicNumberToStep`	in the wheel	`convert_diatonic_number_to_step`
`parseSpecifier`	in the wheel	`parse_specifier`
`convertGeneric`	in the wheel	`convert_generic`
`convertSemitoneToSpecifierGenericMicrotone`	in the wheel	`convert_semitone_to_specifier_generic_microtone`
`convertSemitoneToSpecifierGeneric`	in the wheel	`convert_semitone_to_specifier_generic`
`intervalToPythagoreanRatio`	in the wheel	`pythagorean_ratio`
`notesToGeneric`	in the wheel	`notes_to_generic`
`notesToChromatic`	in the wheel	`notes_to_chromatic`
`intervalsToDiatonic`	in the wheel	`intervals_to_diatonic`
`intervalFromGenericAndChromatic`	in the wheel	`from_generic_and_chromatic`
`getWrittenHigherNote`	in the wheel	`written_higher_pitch`
`getAbsoluteHigherNote`	in the wheel	`absolute_higher_pitch`
`getWrittenLowerNote`	in the wheel	`written_lower_pitch`
`getAbsoluteLowerNote`	in the wheel	`absolute_lower_pitch`
`transposePitch`	in the wheel	`transpose_pitch`
`transposeNote`	in the wheel	`transpose_note`
`notesToInterval`	in the wheel	`between_pitches`
`add`	in the wheel	`sum`
`subtract`	in the wheel	`difference`

▶KeySignaturekey.py wheel 7 of 7

music21	Wheel	In the crate
`asKey`	in the wheel	`as_key`
`alteredPitches`	in the wheel	`altered_pitches`
`accidentalByStep`	in the wheel	`accidental_by_step`
`transpose`	in the wheel	`transpose`
`transposePitchFromC`	in the wheel	`transpose_pitch_from_c`
`getScale`	in the wheel	`scale`
`sharps`	in the wheel	`sharps`

▶Keykey.py wheel 6 of 6

tonalCertainty belongs to a key that came out of analysis, so it lives on the ranked estimates in analysis.

music21	Wheel	In the crate
`relative`	in the wheel	`relative`
`parallel`	in the wheel	`parallel`
`tonicPitchNameWithCase`	in the wheel	`tonic_pitch_name_with_case`
`deriveByDegree`	in the wheel	`derive_by_degree`
`tonalCertainty`	in the wheel	`tonal_certainty`
`transpose`	in the wheel	`transpose`

▶ConcreteScalescale/__init__.py wheel 25 of 27

2 not in wheel

music21	Wheel	In the crate
`write`	not in the wheel	writes a file, and this library does no file IO: a caller saves the Scala text `scala_data` and `file_string` give, or a score `musicxml::to_musicxml` writes
`show`	not in the wheel	opens the scale in another program, which is the caller's to do
`isConcrete`	in the wheel	every Scale here has a tonic, so the question has one answer; the wheel answers it for a scale built without one
`name`	in the wheel	`music21_name`
`getTonic`	in the wheel	`tonic`
`abstract`	in the wheel	a scale's pattern is its ScaleType or the steps it was given, read with scale_type and custom_steps; there is no abstract scale object beside it, and the wheel hands music21 one built from those
`getDegreeMaxUnique`	in the wheel	`degree_count`
`transpose`	in the wheel	`transpose`
`tune`	in the wheel	`tune`
`romanNumeral`	in the wheel	`roman_numeral`
`getPitches`	in the wheel	`pitches`
`getChord`	in the wheel	`chord`
`pitchFromDegree`	in the wheel	`pitch_at_degree`
`pitchesFromScaleDegrees`	in the wheel	`pitches_from_scale_degrees`
`intervalBetweenDegrees`	in the wheel	`interval_between_degrees`
`getScaleDegreeFromPitch`	in the wheel	`degree_of`
`getScaleDegreeAndAccidentalFromPitch`	in the wheel	`degree_and_accidental_of`
`solfeg`	in the wheel	`solfeg`
`nextPitch`	in the wheel	`next_pitch_above`
`isNext`	in the wheel	`is_next`
`match`	in the wheel	`match_pitches`
`findMissing`	in the wheel	`find_missing`
`deriveRanked`	in the wheel	`derive_ranked`
`derive`	in the wheel	`derive`
`deriveAll`	in the wheel	`derive_all`
`deriveByDegree`	in the wheel	`derive_by_degree`
`getScalaData`	in the wheel	`scala_data`

▶scale/__init__.py classesscale/__init__.py wheel 26 of 32

6 not in wheel

The ConcreteScale subclasses, as ScaleType variants or runtime constructors.

music21	Wheel	In the crate
`AbstractDiatonicScale`	not in the wheel	the IntervalNetwork layer
`AbstractOctatonicScale`	not in the wheel	the IntervalNetwork layer
`AbstractHarmonicMinorScale`	not in the wheel	the IntervalNetwork layer
`AbstractMelodicMinorScale`	not in the wheel	the IntervalNetwork layer
`AbstractCyclicalScale`	not in the wheel	the IntervalNetwork layer
`AbstractOctaveRepeatingScale`	not in the wheel	the IntervalNetwork layer
`Scale`	in the wheel	the abstract base
`AbstractScale`	in the wheel	a pattern with no tonic is a ScaleType or a list of steps; the wheel's AbstractScale stands on those and builds music21's IntervalNetwork from them
`ConcreteScale`	in the wheel	realized by Scale, StepScale and ScalaScale
`DiatonicScale`	in the wheel	the diatonic modes are ScaleType variants
`MajorScale`	in the wheel	`MajorScale`
`MinorScale`	in the wheel	`MinorScale`
`DorianScale`	in the wheel	`DorianScale`
`PhrygianScale`	in the wheel	`PhrygianScale`
`LydianScale`	in the wheel	`LydianScale`
`MixolydianScale`	in the wheel	`MixolydianScale`
`HypodorianScale`	in the wheel	`HypodorianScale`
`HypophrygianScale`	in the wheel	`HypophrygianScale`
`HypolydianScale`	in the wheel	`HypolydianScale`
`HypomixolydianScale`	in the wheel	`HypomixolydianScale`
`LocrianScale`	in the wheel	`LocrianScale`
`HypolocrianScale`	in the wheel	`HypolocrianScale`
`HypoaeolianScale`	in the wheel	`HypoaeolianScale`
`HarmonicMinorScale`	in the wheel	`HarmonicMinorScale`
`MelodicMinorScale`	in the wheel	`MelodicMinorScale`
`OctatonicScale`	in the wheel	`OctatonicScale`
`OctaveRepeatingScale`	in the wheel	`octave_repeating`
`CyclicalScale`	in the wheel	`cyclical`
`ChromaticScale`	in the wheel	`ChromaticScale`
`WholeToneScale`	in the wheel	`WholeToneScale`
`SieveScale`	in the wheel	`sieve`
`ScalaScale`	in the wheel	`ScalaScale`

▶RomanNumeralroman.py wheel 11 of 11

music21	Wheel	In the crate
`adjustMinorVIandVIIByQuality`	in the wheel	`adjust_minor_vi_and_vii_by_quality`
`transpose`	in the wheel	`transpose`
`romanNumeral`	in the wheel	`roman_numeral`
`figure`	in the wheel	`figure`
`figureAndKey`	in the wheel	`figure_and_key`
`key`	in the wheel	`key`
`scaleDegreeWithAlteration`	in the wheel	`scale_degree_with_alteration`
`bassScaleDegreeFromNotation`	in the wheel	`bass_scale_degree_from_notation`
`functionalityScore`	in the wheel	`functionality_score`
`isNeapolitan`	in the wheel	`is_neapolitan`
`isMixture`	in the wheel	`is_mixture`

▶TimeSignaturemeter/base.py wheel 33 of 33

The bar, the beats, the beams and the accent partitions, as the four MeterSequences music21 hangs off a meter; the tree is modelled here rather than the numbers being derived from the ratio alone.

music21	Wheel	In the crate
`resetValues`	in the wheel	rebuilding a meter in place; a new one is built instead
`load`	in the wheel	rebuilding a meter in place; a new one is built instead
`ratioString`	in the wheel	`ratio_string`
`ratioEqual`	in the wheel	`ratio_equal`
`numerator`	in the wheel	`numerator`
`denominator`	in the wheel	`denominator`
`barDuration`	in the wheel	`bar_duration`
`beatLengthToQuarterLengthRatio`	in the wheel	`beat_length_to_quarter_length_ratio`
`quarterLengthToBeatLengthRatio`	in the wheel	`quarter_length_to_beat_length_ratio`
`beatCount`	in the wheel	`beat_count`
`beatCountName`	in the wheel	`beat_count_name`
`beatDuration`	in the wheel	`beat_duration`
`beatDivisionCount`	in the wheel	`beat_division_count`
`beatDivisionCountName`	in the wheel	`beat_division_count_name`
`beatDivisionDurations`	in the wheel	`beat_division_durations`
`beatSubDivisionDurations`	in the wheel	`beat_sub_division_durations`
`classification`	in the wheel	`classification`
`summedNumerator`	in the wheel	`summed_numerator`
`getBeams`	in the wheel	`beams_for`
`setDisplay`	in the wheel	`set_display`
`getAccent`	in the wheel	`accent`
`setAccentWeight`	in the wheel	`set_accent_weight`
`averageBeatStrength`	in the wheel	`average_beat_strength`
`getMeasureOffsetOrMeterModulusOffset`	in the wheel	`offset_in_bar`
`getAccentWeight`	in the wheel	`accent_weight`
`getBeat`	in the wheel	`beat_at_offset`
`getBeatOffsets`	in the wheel	`beat_offsets`
`getBeatDuration`	in the wheel	`beat_duration`
`getOffsetFromBeat`	in the wheel	`offset_from_beat`
`getBeatProgress`	in the wheel	`beat_progress`
`getBeatProportion`	in the wheel	`beat_proportion`
`getBeatProportionStr`	in the wheel	`beat_proportion_string`
`getBeatDepth`	in the wheel	`beat_depth`

▶MetronomeMarktempo.py wheel 10 of 10

music21	Wheel	In the crate
`referent`	in the wheel	`referent`
`numberSounding`	in the wheel	`number_sounding`
`getQuarterBPM`	in the wheel	`quarter_bpm`
`setQuarterBPM`	in the wheel	`quarter_bpm`
`getTextExpression`	in the wheel	`text_expression`
`getEquivalentByReferent`	in the wheel	`equivalent_by_referent`
`getMaintainedNumberWithReferent`	in the wheel	`maintained_number_with_referent`
`secondsPerQuarter`	in the wheel	`seconds_per_quarter`
`durationToSeconds`	in the wheel	`duration_to_seconds`
`secondsToDuration`	in the wheel	`seconds_to_duration`

▶MetricModulationtempo.py wheel 8 of 8

A change of tempo written as an equation between two metronome marks.

music21	Wheel	In the crate
`oldMetronome`	in the wheel	`old_metronome`
`oldReferent`	in the wheel	`old_referent`
`newMetronome`	in the wheel	`new_metronome`
`newReferent`	in the wheel	`new_referent`
`number`	in the wheel	`number`
`updateByContext`	in the wheel	`update_from`
`setEqualityByReferent`	in the wheel	`set_equality_by_referent`
`setOtherByReferent`	in the wheel	`set_other_by_referent`

▶Instrumentinstrument.py wheel 4 of 4

One of music21's instrument classes, with what an instrument of it starts out as.

music21	Wheel	In the crate
`bestName`	in the wheel	`best_name`
`partIdRandomize`	in the wheel	makes an id up out of the clock and a random number; the crate keeps the id a score gives (`part_id`) and makes none up, reading no clock -- the wheel gives a random one as music21 does
`instrumentIdRandomize`	in the wheel	makes an id up out of the clock and a random number; the crate keeps the id a score gives (`instrument_id`) and makes none up, reading no clock -- the wheel gives a random one as music21 does
`autoAssignMidiChannel`	in the wheel	`auto_assign_midi_channel`

▶StringInstrumentinstrument.py wheel 1 of 1

A string instrument's open strings, the only member music21 gives its string family.

music21	Wheel	In the crate
`stringPitches`	in the wheel	`string_pitches`

▶UnpitchedPercussioninstrument.py wheel 1 of 1

How an unpitched percussion instrument is played, and the drum that plays.

music21	Wheel	In the crate
`modifier`	in the wheel	`modifier`

▶instrument.py functionsinstrument.py wheel 8 of 8

Module-level helpers: finding an instrument by name or program, and what instruments do to a stream they stand in.

music21	Wheel	In the crate
`unbundleInstruments`	in the wheel	`unbundle_instruments`
`bundleInstruments`	in the wheel	`bundle_instruments`
`ensembleNameBySize`	in the wheel	`ensemble_name_by_size`
`deduplicate`	in the wheel	`deduplicate`
`instrumentFromMidiProgram`	in the wheel	`from_midi_program`
`partitionByInstrument`	in the wheel	`partition_by_instrument`
`fromString`	in the wheel	`from_name`
`getAllNamesForInstrument`	in the wheel	`all_names`

▶PercussionMappermidi/percussion.py wheel 0 of 2

2 not in wheel

The General MIDI percussion map, both ways: the instrument a key plays, played the way that key says, and the key an instrument is played by. music21's reverseInstrumentMapping is tables::PERCUSSION_KEYS.

music21	Wheel	In the crate
`midiPitchToInstrument`	not in the wheel	`for_percussion_key`
`midiInstrumentToPitch`	not in the wheel	`percussion_pitch`

▶Durationduration.py wheel 24 of 24

A quarter length, the note values it is written as, and the tuplets it is written inside.

music21	Wheel	In the crate
`linked`	in the wheel	`linked`
`addDurationTuple`	in the wheel	`add_duration_tuple`
`appendTuplet`	in the wheel	`append_tuplet`
`augmentOrDiminish`	in the wheel	`augment_or_diminish`
`clear`	in the wheel	`clear`
`componentIndexAtQtrPosition`	in the wheel	`component_index_at_qtr_position`
`componentStartTime`	in the wheel	`component_start_time`
`consolidate`	in the wheel	`consolidate`
`getGraceDuration`	in the wheel	`grace_duration`
`informClient`	in the wheel	observer callback for a containing note; there is none
`sliceComponentAtPosition`	in the wheel	`slice_component_at_position`
`currentComponents`	in the wheel	the working-out is not deferred here, so there is no half-worked-out state to read
`splitDotGroups`	in the wheel	`split_dot_groups`
`components`	in the wheel	`components`
`dotGroups`	in the wheel	`dot_groups`
`dots`	in the wheel	`dots`
`fullName`	in the wheel	`full_name`
`isComplex`	in the wheel	`is_complex`
`ordinal`	in the wheel	`ordinal`
`quarterLengthNoTuplets`	in the wheel	`quarter_length_no_tuplets`
`quarterLength`	in the wheel	`quarter_length`
`tuplets`	in the wheel	`tuplets`
`aggregateTupletMultiplier`	in the wheel	`aggregate_tuplet_multiplier`
`type`	in the wheel	`duration_type`

▶ToneRowserial.py wheel 10 of 10

music21	Wheel	In the crate
`pitchClasses`	in the wheel	`pitch_classes`
`noteNames`	in the wheel	`note_names`
`isTwelveToneRow`	in the wheel	`is_twelve_tone_row`
`makeTwelveToneRow`	in the wheel	`make_twelve_tone_row`
`isSameRow`	in the wheel	`is_same_row`
`getIntervalsAsString`	in the wheel	`intervals_as_string`
`zeroCenteredTransformation`	in the wheel	`zero_centered_transformation`
`originalCenteredTransformation`	in the wheel	`original_centered_transformation`
`findZeroCenteredTransformations`	in the wheel	`find_zero_centered_transformations`
`findOriginalCenteredTransformations`	in the wheel	`find_original_centered_transformations`

▶TwelveToneRowserial.py wheel 7 of 7

music21	Wheel	In the crate
`matrix`	in the wheel	`matrix`
`findHistorical`	in the wheel	`find_historical`
`findTransformedHistorical`	in the wheel	`find_transformed_historical`
`isAllInterval`	in the wheel	`is_all_interval`
`getLinkClassification`	in the wheel	`link_classification`
`isLinkChord`	in the wheel	`is_link_chord`
`areCombinatorial`	in the wheel	`are_combinatorial`

▶serial.py functionsserial.py wheel 3 of 3

Module-level helpers.

music21	Wheel	In the crate
`getHistoricalRowByName`	in the wheel	`historical_row_by_name`
`pcToToneRow`	in the wheel	`new`
`rowToMatrix`	in the wheel	`row_to_matrix`

▶VoiceLeadingQuartetvoiceLeading.py wheel 30 of 30

music21	Wheel	In the crate
`key`	in the wheel	`key`
`v1n1`	in the wheel	`v1n1`
`v1n2`	in the wheel	`v1n2`
`v2n1`	in the wheel	`v2n1`
`v2n2`	in the wheel	`v2n2`
`motionType`	in the wheel	`motion_type`
`noMotion`	in the wheel	`no_motion`
`obliqueMotion`	in the wheel	`oblique_motion`
`similarMotion`	in the wheel	`similar_motion`
`parallelMotion`	in the wheel	`parallel_motion`
`contraryMotion`	in the wheel	`contrary_motion`
`outwardContraryMotion`	in the wheel	`outward_contrary_motion`
`inwardContraryMotion`	in the wheel	`inward_contrary_motion`
`antiParallelMotion`	in the wheel	`anti_parallel_motion`
`parallelInterval`	in the wheel	`parallel_interval`
`parallelFifth`	in the wheel	`parallel_fifth`
`parallelOctave`	in the wheel	`parallel_octave`
`parallelUnison`	in the wheel	`parallel_unison`
`parallelUnisonOrOctave`	in the wheel	`parallel_unison_or_octave`
`hiddenInterval`	in the wheel	`hidden_interval`
`hiddenFifth`	in the wheel	`hidden_fifth`
`hiddenOctave`	in the wheel	`hidden_octave`
`voiceOverlap`	in the wheel	`voice_overlap`
`voiceCrossing`	in the wheel	`voice_crossing`
`isProperResolution`	in the wheel	`is_proper_resolution`
`leapNotSetWithStep`	in the wheel	`leap_not_set_with_step`
`modalOpening`	in the wheel	`modal_opening`
`opensIncorrectly`	in the wheel	`opens_incorrectly`
`clausulaVera`	in the wheel	`clausula_vera`
`closesIncorrectly`	in the wheel	`closes_incorrectly`

▶Sievesieve.py wheel 9 of 9

The sieve as written and its compressed reading: parse, membership, the segment formats and the interval widths of one period.

music21	Wheel	In the crate
`expand`	in the wheel	which reading answers is not state on the sieve here; `compressed` hands back the other one and the sieve as written stays as it was
`compress`	in the wheel	`compressed`
`setZ`	in the wheel	the range is an argument of each question here, not state on the sieve
`setZRange`	in the wheel	the range is an argument of each question here, not state on the sieve
`setSegmentFormat`	in the wheel	the segment format is an argument of each question here, not state on the sieve
`segment`	in the wheel	`segment`
`period`	in the wheel	`period`
`collect`	in the wheel	`collect`
`represent`	in the wheel	the sieve is written by `Display`, which is not a function the map can name

▶Beamsbeam.py wheel 12 of 12

All the beams over one note, and the rules for a run of them.

music21	Wheel	In the crate
`naiveBeams`	in the wheel	`naive_beams`
`removeSandwichedUnbeamables`	in the wheel	`remove_sandwiched_unbeamables`
`mergeConnectingPartialBeams`	in the wheel	`merge_connecting_partial_beams`
`sanitizePartialBeams`	in the wheel	`sanitize_partial_beams`
`append`	in the wheel	`append`
`fill`	in the wheel	`fill`
`getByNumber`	in the wheel	`by_number`
`getNumbers`	in the wheel	`numbers`
`getTypeByNumber`	in the wheel	`by_number`
`getTypes`	in the wheel	`types`
`setAll`	in the wheel	`set_all`
`setByNumber`	in the wheel	`set_by_number`

▶Volumevolume.py wheel 9 of 9

How loud a note sounds, as a velocity and as a scalar.

music21	Wheel	In the crate
`getDynamicContext`	in the wheel	`dynamic_context`
`mergeAttributes`	in the wheel	`merge_attributes`
`getRealizedStr`	in the wheel	`realized_str`
`getRealized`	in the wheel	`realized`
`cachedRealized`	in the wheel	the crate caches nothing -- a value that answers the same question twice is doing arithmetic. The wheel caches as music21 does
`cachedRealizedStr`	in the wheel	the crate caches nothing -- a value that answers the same question twice is doing arithmetic. The wheel caches as music21 does
`realized`	in the wheel	`realized`
`velocity`	in the wheel	`velocity`
`velocityScalar`	in the wheel	`velocity_scalar`

▶volume.py functionsvolume.py wheel 1 of 1

music21	Wheel	In the crate
`realizeVolume`	in the wheel	`realize_volume`

▶FigurefiguredBass/notation.py wheel 1 of 1

One number of that column, with the accidental written against it.

music21	Wheel	In the crate
`isPureExtender`	in the wheel	`is_pure_extender`

▶ModifierfiguredBass/notation.py wheel 2 of 2

The mark as written beside the accidental it means: figured bass has marks no accidental name covers, a + that raises and a / that lowers.

music21	Wheel	In the crate
`modifyPitchName`	in the wheel	`modify_pitch_name`
`modifyPitch`	in the wheel	`modify`

▶figuredBass/notation.py functionsfiguredBass/notation.py wheel 1 of 1

music21	Wheel	In the crate
`convertToPitch`	in the wheel	`convert_to_pitch`

▶sieve.py functionssieve.py wheel 6 of 6

The number helpers music21 keeps beside the sieve: primes, and spacings across the unit interval.

music21	Wheel	In the crate
`eratosthenes`	in the wheel	`eratosthenes`
`rabinMiller`	in the wheel	`rabin_miller`
`discreteBinaryPad`	in the wheel	`discrete_binary_pad`
`unitNormRange`	in the wheel	`unit_norm_range`
`unitNormEqual`	in the wheel	`unit_norm_equal`
`unitNormStep`	in the wheel	`unit_norm_step`

▶GeneralNotenote.py wheel 8 of 8

What every written note and chord has: a length, what is sung to it, and the marks over it. The crate has no type of its own for it -- the GeneralNote to NotRest to Note chain was mirrored here once as wrapper structs and taken out again -- so its members are matched against the types that carry them.

music21	Wheel	In the crate
`tie`	in the wheel	`tie`
`lyric`	in the wheel	`lyric`
`addLyric`	in the wheel	`add_lyric`
`insertLyric`	in the wheel	`insert_lyric`
`fullName`	in the wheel	`full_name`
`pitches`	in the wheel	`pitches`
`augmentOrDiminish`	in the wheel	`augment_or_diminish`
`getGrace`	in the wheel	`grace_note`

▶NotRestnote.py wheel 8 of 8

A note or chord as distinct from a rest: what it is written as, which way its stem goes, and how loud it sounds.

music21	Wheel	In the crate
`stemDirection`	in the wheel	`stem_direction`
`notehead`	in the wheel	`notehead`
`noteheadFill`	in the wheel	`notehead_fill`
`noteheadParenthesis`	in the wheel	`notehead_parenthesis`
`hasVolumeInformation`	in the wheel	`has_volume_information`
`volume`	in the wheel	`volume`
`storedInstrument`	in the wheel	`stored_instrument`
`getInstrument`	in the wheel	`instrument`

▶Lyricnote.py wheel 7 of 7

A syllable sung to a note.

music21	Wheel	In the crate
`isComposite`	in the wheel	`is_composite`
`text`	in the wheel	`text`
`syllabic`	in the wheel	`syllabic`
`identifier`	in the wheel	`identifier`
`rawText`	in the wheel	`raw_text`
`number`	in the wheel	`number`
`setTextAndSyllabic`	in the wheel	`set_text_and_syllabic`

▶Restnote.py wheel 1 of 1

A silence of a written length.

music21	Wheel	In the crate
`fullName`	in the wheel	`full_name`

▶ChordBasechord/__init__.py wheel 7 of 7

What a chord is before it is asked anything: the notes it holds, and adding to and taking from them.

music21	Wheel	In the crate
`add`	in the wheel	`add`
`remove`	in the wheel	`remove`
`notes`	in the wheel	`notes`
`tie`	in the wheel	`tie`
`volume`	in the wheel	`volume`
`hasComponentVolumes`	in the wheel	`has_component_volumes`
`setVolumes`	in the wheel	`set_volumes`

▶Tupletduration.py wheel 10 of 10

The bracket that says a length is written as one thing and sounds as another.

music21	Wheel	In the crate
`augmentOrDiminish`	in the wheel	`augment_or_diminish`
`setDurationType`	in the wheel	`set_duration_type`
`setRatio`	in the wheel	`set_ratio`
`totalTupletLength`	in the wheel	`total_tuplet_length`
`tupletMultiplier`	in the wheel	`multiplier`
`durationActual`	in the wheel	`duration_actual`
`durationNormal`	in the wheel	`duration_normal`
`fullName`	in the wheel	`full_name`
`tupletActual`	in the wheel	`tuplet_actual`
`tupletNormal`	in the wheel	`tuplet_normal`

▶Notenote.py wheel 8 of 8

A pitch and an optional duration.

music21	Wheel	In the crate
`name`	in the wheel	`pitch_name`
`nameWithOctave`	in the wheel	`pitch_name_with_octave`
`step`	in the wheel	`step`
`octave`	in the wheel	`octave`
`pitches`	in the wheel	`pitches`
`transpose`	in the wheel	`transpose`
`fullName`	in the wheel	`full_name`
`pitchChanged`	in the wheel	observer callback; there is none

▶ChordSymbolharmony.py wheel 3 of 3

music21	Wheel	In the crate
`findFigure`	in the wheel	`find_figure`
`inversionIsValid`	in the wheel	`inversion_is_valid`
`transpose`	in the wheel	`transpose`

▶pitch.py functionspitch.py wheel 4 of 4

Module-level helpers.

music21	Wheel	In the crate
`isValidAccidentalName`	in the wheel	`is_valid_name`
`standardizeAccidentalName`	in the wheel	`standardize_name`
`convertPitchClassToStr`	in the wheel	`convert_pitch_class_to_str`
`simplifyMultipleEnharmonics`	in the wheel	`simplify_multiple_enharmonics`

▶key.py functionskey.py wheel 3 of 3

Module-level helpers.

music21	Wheel	In the crate
`convertKeyStringToMusic21KeyString`	in the wheel	`convert_key_string_to_music21_key_string`
`sharpsToPitch`	in the wheel	`sharps_to_pitch`
`pitchToSharps`	in the wheel	`pitch_to_sharps`

▶duration.py functionsduration.py wheel 12 of 12

Module-level helpers.

music21	Wheel	In the crate
`nextLargerType`	in the wheel	`next_larger`
`nextSmallerType`	in the wheel	`next_smaller`
`quarterLengthToClosestType`	in the wheel	`quarter_length_to_closest_type`
`convertQuarterLengthToType`	in the wheel	`from_quarter_length`
`dottedMatch`	in the wheel	`type_and_dots`
`quarterLengthToNonPowerOf2Tuplet`	in the wheel	`quarter_length_to_non_power_of_2_tuplet`
`quarterLengthToTuplet`	in the wheel	`quarter_length_to_tuplet`
`quarterConversion`	in the wheel	`quarter_conversion`
`convertTypeToQuarterLength`	in the wheel	`quarter_length`
`convertTypeToNumber`	in the wheel	`type_number`
`durationTupleFromQuarterLength`	in the wheel	`type_and_dots`
`durationTupleFromTypeDots`	in the wheel	`from_type_with_dots`

▶tempo.py functionstempo.py wheel 2 of 2

Module-level helpers.

music21	Wheel	In the crate
`convertTempoByReferent`	in the wheel	`convert_tempo_by_referent`
`interpolateElements`	in the wheel	`interpolate_elements`

▶roman.py functionsroman.py wheel 8 of 8

Module-level helpers.

music21	Wheel	In the crate
`expandShortHand`	in the wheel	`expand_shorthand`
`correctSuffixForChordQuality`	in the wheel	`correct_suffix_for_chord_quality`
`figureTuples`	in the wheel	`figure_tuples`
`figureTupleSolo`	in the wheel	`from_pitch_and_reference`
`identifyAsTonicOrDominant`	in the wheel	`identify_as_tonic_or_dominant`
`romanInversionName`	in the wheel	`roman_inversion_name`
`correctRNAlterationForMinor`	in the wheel	`correct_rn_alteration_for_minor`
`romanNumeralFromChord`	in the wheel	`roman_numeral_from_chord`

▶chord/__init__.py functionschord/__init__.py wheel 2 of 2

Module-level helpers.

music21	Wheel	In the crate
`fromForteClass`	in the wheel	`from_forte_class`
`fromIntervalVector`	in the wheel	`from_interval_vector`

▶chord/tables.py functionschord/tables.py wheel 9 of 9

The Forte tables of set classes, read without a chord in hand. The data is generated from music21's own and checked by xtask verify-tables.

music21	Wheel	In the crate
`forteIndexToInversionsAvailable`	in the wheel	`inversions_available`
`addressToTransposedNormalForm`	in the wheel	`normal_form`
`addressToPrimeForm`	in the wheel	`prime_form`
`addressToIntervalVector`	in the wheel	`interval_class_vector`
`intervalVectorToAddress`	in the wheel	`set_classes_with_interval_vector`
`addressToZAddress`	in the wheel	`z_related_class`
`addressToCommonNames`	in the wheel	`common_names`
`addressToForteName`	in the wheel	`forte_name`
`seekChordTablesAddress`	in the wheel	`address_of_pitch_classes`

▶TabChordBaseromanText/tsvConverter.py wheel 0 of 3

3 not in wheel

One row of the lab's tabular analysis, read: the columns both of its standards share, the label music21 builds a numeral from, and the chord that numeral stands for. The one row type here reads a row of either standard, as music21's two subclasses do between them.

music21	Wheel	In the crate
`combinedChord`	not in the wheel	`chord`
`tabToM21`	not in the wheel	`element`
`populateFromRow`	not in the wheel	`from_row`

▶TabChordV2romanText/tsvConverter.py wheel 0 of 4

4 not in wheel

What the lab's second standard renamed: the measure and the onset it writes as mn and mn_onset, and the keys it writes without the underscore.

music21	Wheel	In the crate
`beat`	not in the wheel	`beat`
`measure`	not in the wheel	`measure`
`local_key`	not in the wheel	`local_key`
`global_key`	not in the wheel	`global_key`

▶TsvHandlerromanText/tsvConverter.py wheel 0 of 3

3 not in wheel

A table read: the rows, and the score of numerals they make.

music21	Wheel	In the crate
`tsvToChords`	not in the wheel	`tsv_to_chords`
`toM21Stream`	not in the wheel	`from_tsv`
`prepStream`	not in the wheel	a step inside the reader: `from_tsv` prepares the measures from the table's own numbers and meters itself and hands back the whole score

▶M21toTSVromanText/tsvConverter.py wheel 0 of 2

2 not in wheel

A score written back as a table, column for column.

music21	Wheel	In the crate
`m21ToTsv`	not in the wheel	`to_tsv`
`write`	not in the wheel	writes a file, which the library does not do: `to_tsv` hands back the text

▶romanText/tsvConverter.py functionsromanText/tsvConverter.py wheel 0 of 7

7 not in wheel

Module-level helpers: the swaps between the two notations, a local key read as a degree or as a key of its own, and the form, the figured bass and the added tones a label writes.

music21	Wheel	In the crate
`getForm`	not in the wheel	`form_of`
`handleAddedTones`	not in the wheel	`handle_added_tones`
`localKeyAsRn`	not in the wheel	`local_key_as_roman`
`isMinor`	not in the wheel	`is_minor`
`characterSwaps`	not in the wheel	`character_swaps`
`getLocalKey`	not in the wheel	`local_key`
`getSecondaryKey`	not in the wheel	`secondary_key`

▶CTSongromanText/clercqTemperley.py wheel 0 of 8

8 not in wheel

A de Clercq-Temperley analysis of the rock corpus as its text says it: the title, the comments, the rules, and the key and the meter the song opens in.

music21	Wheel	In the crate
`parse`	not in the wheel	`parse`
`title`	not in the wheel	`title`
`comments`	not in the wheel	`comments`
`rules`	not in the wheel	`rules`
`homeTimeSig`	not in the wheel	`home_time_signature`
`homeKey`	not in the wheel	`home_key`
`toPart`	not in the wheel	`to_part`
`toScore`	not in the wheel	music21's own deprecated name for `toPart`, which it will take out

▶CTRuleromanText/clercqTemperley.py wheel 0 of 12

12 not in wheel

One rule of a song, a line of its text: its name, the section it stands for, its chords, its comment, and the measures it expands to.

music21	Wheel	In the crate
`parent`	not in the wheel	music21 keeps a weak reference from a rule back to the song holding it, and reads the rule's key, meter and other rules through it; a song here expands its own rules (`CtSong::to_part`), so nothing needs the way back
`expand`	not in the wheel	`expand`
`expandExpansionContent`	not in the wheel	a step inside the expansion, which the crate drives from the song rather than from the rule keeping the state
`expandSimpleContent`	not in the wheel	a step inside the expansion, as `expandExpansionContent`
`isSame`	not in the wheel	`is_same`
`addOptionalTieAndLyrics`	not in the wheel	a step inside the expansion, which ties the chord before as it writes the one after
`insertKsTs`	not in the wheel	a step inside the expansion: the crate writes the key and the meter into a measure as it builds it
`fixupChordAtom`	not in the wheel	`fixup_chord_atom`
`musicText`	not in the wheel	`music_text`
`comment`	not in the wheel	`comment`
`LHS`	not in the wheel	`left_hand_side`
`sectionName`	not in the wheel	`section_name`

▶harmony.py functionsharmony.py wheel 7 of 10

3 not in wheel

Module-level helpers.

music21	Wheel	In the crate
`addNewChordSymbol`	not in the wheel	mutates music21's global chord-type table; the crate's is a constant, and the wheel's chord symbols read music21's live table wherever music21 is there to edit it
`changeAbbreviationFor`	not in the wheel	mutates music21's global chord-type table; the crate's is a constant, and the wheel's chord symbols read music21's live table wherever music21 is there to edit it
`removeChordSymbols`	not in the wheel	mutates music21's global chord-type table; the crate's is a constant, and the wheel's chord symbols read music21's live table wherever music21 is there to edit it
`chordSymbolFigureFromChord`	in the wheel	`chord_symbol_figure_from_chord`
`alterToChordSymbolString`	in the wheel	`alter_to_chord_symbol_string`
`chordSymbolFromChord`	in the wheel	`chord_symbol_from_chord`
`getAbbreviationListGivenChordType`	in the wheel	`abbreviations_for_kind`
`getCurrentAbbreviationFor`	in the wheel	`current_abbreviation_for_kind`
`getNotationStringGivenChordType`	in the wheel	`notation_for_kind`
`realizeChordSymbolDurations`	in the wheel	`realize_chord_symbol_durations`

▶meter/base.py functionsmeter/base.py wheel 1 of 1

Module-level helpers.

music21	Wheel	In the crate
`bestTimeSignature`	in the wheel	`best_time_signature`

▶ScalaDatascale/scala/__init__.py wheel 7 of 7

A Scala scale as its file writes it: a description, a degree a line and the interval it repeats at. ScalaFile is left out because it is file IO, which this library leaves to its caller.

music21	Wheel	In the crate
`parse`	in the wheel	`parse`
`getCentsAboveTonic`	in the wheel	`written_cents`
`getAdjacentCents`	in the wheel	`adjacent_cents`
`setAdjacentCents`	in the wheel	`from_adjacent_cents`
`getIntervalSequence`	in the wheel	`interval_sequence`
`setIntervalSequence`	in the wheel	`from_interval_sequence`
`getFileString`	in the wheel	`file_string`

▶scale/scala/__init__.py functionsscale/scala/__init__.py wheel 2 of 3

1 not in wheel

Module-level helpers.

music21	Wheel	In the crate
`getPaths`	not in the wheel	where the archive's files sit on disk; the archive here is one bundled table and has no paths
`parse`	in the wheel	`find`
`search`	in the wheel	`search`

▶Tietie.py wheel 4 of 4

Two written notes sounding as one, and how the tie between them is drawn.

music21	Wheel	In the crate
`id`	in the wheel	the address of the Python object, which is how music21 tells one tie from another; a tie here is a value its note holds, and has no identity apart from it
`placement`	in the wheel	`placement`
`style`	in the wheel	`style`
`type`	in the wheel	`tie_type`

▶MeterTerminalmeter/core.py wheel 10 of 10

A span of a bar written as a ratio, which is what a meter's partitions are made of.

music21	Wheel	In the crate
`ratioEqual`	in the wheel	`ratio_equal`
`subdivideByCount`	in the wheel	`subdivide_by_count`
`subdivideByList`	in the wheel	`subdivide_by_list`
`subdivideByOther`	in the wheel	`subdivide_by_other`
`subdivide`	in the wheel	`subdivide`
`weight`	in the wheel	`weight`
`numerator`	in the wheel	`numerator`
`denominator`	in the wheel	`denominator`
`duration`	in the wheel	`quarter_length`
`depth`	in the wheel	`depth`

▶MeterSequencemeter/core.py wheel 25 of 25

A span divided into parts, each of them a span in turn, which is the tree every meter question is read off.

music21	Wheel	In the crate
`partitionDisplay`	in the wheel	`partition_display`
`getPartitionOptions`	in the wheel	`partition_options`
`partitionByCount`	in the wheel	`partition_by_count`
`partitionByList`	in the wheel	`partition_by_list`
`partitionByOtherMeterSequence`	in the wheel	`partition_by_other`
`partition`	in the wheel	one setter dispatching on the type of what it is handed; the three partitions it dispatches to are each ported
`subdividePartitionsEqual`	in the wheel	`subdivide_partitions_equal`
`subdivideNestedHierarchy`	in the wheel	`subdivide_nested_hierarchy`
`partitionStr`	in the wheel	`partition_string`
`load`	in the wheel	rebuilding a sequence in place; a new one is built instead
`weight`	in the wheel	`weight`
`flatten`	in the wheel	`flatten`
`flatWeight`	in the wheel	`flat_weights`
`depth`	in the wheel	`depth`
`isUniformPartition`	in the wheel	`is_uniform_partition`
`getLevelList`	in the wheel	`level_list`
`getLevel`	in the wheel	`level`
`getLevelSpan`	in the wheel	`level_span`
`getLevelWeight`	in the wheel	`level_weight`
`setLevelWeight`	in the wheel	`set_level_weight`
`offsetToIndex`	in the wheel	`offset_to_index`
`offsetToAddress`	in the wheel	`offset_to_address`
`offsetToSpan`	in the wheel	`offset_to_span`
`offsetToWeight`	in the wheel	`offset_to_weight`
`offsetToDepth`	in the wheel	`offset_to_depth`

▶voiceLeading.py functionsvoiceLeading.py wheel 2 of 2

Module-level helpers.

music21	Wheel	In the crate
`getVerticalityFromObject`	in the wheel	`verticality_at`
`iterateAllVoiceLeadingQuartets`	in the wheel	`iterate_all_voice_leading_quartets`

▶Dynamicdynamics.py wheel 2 of 2

A dynamic mark and the loudness it stands for. In a stream it is in force until the next, which is what realize_volume reads.

music21	Wheel	In the crate
`value`	in the wheel	`value`
`volumeScalar`	in the wheel	`volume_scalar`

▶dynamics.py functionsdynamics.py wheel 1 of 1

Module-level helpers.

music21	Wheel	In the crate
`dynamicStrFromDecimal`	in the wheel	`dynamic_str_from_decimal`

▶Clefclef.py wheel 3 of 3

A clef: its sign, the line it sits on, the octaves it transposes and the note on its lowest line.

music21	Wheel	In the crate
`octaveChange`	in the wheel	`octave_change`
`name`	in the wheel	`name`
`getStemDirectionForPitches`	in the wheel	`stem_direction_for_pitches`

▶PitchClefclef.py wheel 1 of 1

A clef that places pitches, whose lowest line moves with its octave change.

music21	Wheel	In the crate
`octaveChange`	in the wheel	`octave_change`

▶clef.py functionsclef.py wheel 2 of 2

Module-level helpers.

music21	Wheel	In the crate
`clefFromString`	in the wheel	`from_string`
`bestClef`	in the wheel	`best_for`

▶Articulationarticulations.py wheel 2 of 2

A mark on a note saying how it is played: how much louder, how much shorter, and which part of a tied note keeps it.

music21	Wheel	In the crate
`name`	in the wheel	`name`
`volumeShift`	in the wheel	`volume_shift`

▶Ornamentexpressions.py wheel 5 of 5

An ornament and the notes it is played as: its ornamental pitches and its realization over a note in a key.

music21	Wheel	In the crate
`realize`	in the wheel	`realize`
`fillListOfRealizedNotes`	in the wheel	a helper realize fills its lists with; realize is ported
`resolveOrnamentalPitches`	in the wheel	`ornamental_pitches`
`ornamentalPitches`	in the wheel	`ornamental_pitches`
`updateAccidentalDisplay`	in the wheel	`update_accidental_display`

▶GeneralMordentexpressions.py wheel 9 of 9

music21	Wheel	In the crate
`name`	in the wheel	`name`
`accidental`	in the wheel	`accidental`
`direction`	in the wheel	`direction`
`getSize`	in the wheel	`size`
`resolveOrnamentalPitches`	in the wheel	`ornamental_pitches`
`ornamentalPitch`	in the wheel	`ornamental_pitches`
`ornamentalPitches`	in the wheel	`ornamental_pitches`
`updateAccidentalDisplay`	in the wheel	`update_accidental_display`
`realize`	in the wheel	`realize`

▶Trillexpressions.py wheel 10 of 10

music21	Wheel	In the crate
`name`	in the wheel	`name`
`direction`	in the wheel	`direction`
`accidental`	in the wheel	`accidental`
`splitClient`	in the wheel	`split_client`
`getSize`	in the wheel	`size`
`resolveOrnamentalPitches`	in the wheel	`ornamental_pitches`
`ornamentalPitch`	in the wheel	`ornamental_pitches`
`ornamentalPitches`	in the wheel	`ornamental_pitches`
`updateAccidentalDisplay`	in the wheel	`update_accidental_display`
`realize`	in the wheel	`realize`

▶Turnexpressions.py wheel 12 of 12

music21	Wheel	In the crate
`upperAccidental`	in the wheel	`upper_accidental`
`lowerAccidental`	in the wheel	`lower_accidental`
`delay`	in the wheel	`delay`
`isDelayed`	in the wheel	`is_delayed`
`name`	in the wheel	`name`
`getSize`	in the wheel	`turn_size`
`resolveOrnamentalPitches`	in the wheel	`ornamental_pitches`
`upperOrnamentalPitch`	in the wheel	`ornamental_pitches`
`lowerOrnamentalPitch`	in the wheel	`ornamental_pitches`
`ornamentalPitches`	in the wheel	`ornamental_pitches`
`updateAccidentalDisplay`	in the wheel	`update_accidental_display`
`realize`	in the wheel	`realize`

▶GeneralAppoggiaturaexpressions.py wheel 1 of 1

music21	Wheel	In the crate
`realize`	in the wheel	`realize`

▶Tremoloexpressions.py wheel 2 of 2

music21	Wheel	In the crate
`numberOfMarks`	in the wheel	`number_of_marks`
`realize`	in the wheel	`realize`

▶figuredBass/possibility.py functionsfiguredBass/possibility.py wheel 15 of 15

The rules a voicing of a figured bass is held to, alone and moving to the next.

music21	Wheel	In the crate
`voiceCrossing`	in the wheel	`voice_crossing`
`isIncomplete`	in the wheel	`is_incomplete`
`upperPartsWithinLimit`	in the wheel	`upper_parts_within_limit`
`pitchesWithinLimit`	in the wheel	`pitches_within_limit`
`limitPartToPitch`	in the wheel	`limit_part_to_pitch`
`parallelFifths`	in the wheel	`parallel_fifths`
`parallelOctaves`	in the wheel	`parallel_octaves`
`hiddenFifths`	in the wheel	`hidden_fifths`
`hiddenOctaves`	in the wheel	`hidden_octaves`
`voiceOverlap`	in the wheel	`voice_overlap`
`partMovementsWithinLimits`	in the wheel	`part_movements_within_limits`
`upperPartsSame`	in the wheel	`upper_parts_same`
`partsSame`	in the wheel	`parts_same`
`couldBeItalianA6Resolution`	in the wheel	`could_be_italian_a6_resolution`
`partPairs`	in the wheel	`part_pairs`

▶figuredBass/resolution.py functionsfiguredBass/resolution.py wheel 13 of 14

1 not in wheel

How a dominant seventh, a diminished seventh or an augmented sixth resolves, voiced part for part.

music21	Wheel	In the crate
`showResolutions`	not in the wheel	puts the voicings in a score and opens it in another program; `Realization::generate_realization_from_possibility_progression` writes voicings as a score, and opening a program is the caller's to do
`augmentedSixthToDominant`	in the wheel	`augmented_sixth_to_dominant`
`augmentedSixthToMajorTonic`	in the wheel	`augmented_sixth_to_major_tonic`
`augmentedSixthToMinorTonic`	in the wheel	`augmented_sixth_to_minor_tonic`
`dominantSeventhToMajorTonic`	in the wheel	`dominant_seventh_to_major_tonic`
`dominantSeventhToMinorTonic`	in the wheel	`dominant_seventh_to_minor_tonic`
`dominantSeventhToMajorSubmediant`	in the wheel	`dominant_seventh_to_major_submediant`
`dominantSeventhToMinorSubmediant`	in the wheel	`dominant_seventh_to_minor_submediant`
`dominantSeventhToMajorSubdominant`	in the wheel	`dominant_seventh_to_major_subdominant`
`dominantSeventhToMinorSubdominant`	in the wheel	`dominant_seventh_to_minor_subdominant`
`diminishedSeventhToMajorTonic`	in the wheel	`diminished_seventh_to_major_tonic`
`diminishedSeventhToMinorTonic`	in the wheel	`diminished_seventh_to_minor_tonic`
`diminishedSeventhToMajorSubdominant`	in the wheel	`diminished_seventh_to_major_subdominant`
`diminishedSeventhToMinorSubdominant`	in the wheel	`diminished_seventh_to_minor_subdominant`

▶FiguredBassScalefiguredBass/realizerScale.py wheel 3 of 3

The key a figured bass is counted in, and the notes a bass and its figures stand for.

music21	Wheel	In the crate
`getPitchNames`	in the wheel	`pitch_names`
`getSamplePitches`	in the wheel	`sample_pitches`
`getPitches`	in the wheel	`pitches`

▶SegmentfiguredBass/segment.py wheel 9 of 9

A bass note and its figures, every voicing of them, and the moves to the next.

music21	Wheel	In the crate
`singlePossibilityRules`	in the wheel	music21's table of its own Python functions for printing; the rules are Rules and the segment runs them
`consecutivePossibilityRules`	in the wheel	music21's table of its own Python functions for printing; the rules are Rules and the segment runs them
`specialResolutionRules`	in the wheel	music21's table of its own Python functions for printing; the rules are Rules and the segment runs them
`resolveDominantSeventhSegment`	in the wheel	`resolve_dominant_seventh_segment`
`resolveDiminishedSeventhSegment`	in the wheel	`resolve_diminished_seventh_segment`
`resolveAugmentedSixthSegment`	in the wheel	`resolve_augmented_sixth_segment`
`allSinglePossibilities`	in the wheel	`all_single_possibilities`
`allCorrectSinglePossibilities`	in the wheel	`all_correct_single_possibilities`
`allCorrectConsecutivePossibilities`	in the wheel	`all_correct_consecutive_possibilities`

▶figuredBass/segment.py functionsfiguredBass/segment.py wheel 1 of 2

1 not in wheel

Module-level helpers.

music21	Wheel	In the crate
`printRules`	not in the wheel	prints music21's rule tables, which hold its Python functions
`getPitches`	in the wheel	`pitches`

▶FiguredBassLinefiguredBass/realizer.py wheel 5 of 5

A bass line and its figures in a key and a meter, written out as a part, and realized into every voicing that keeps the rules -- and keeps any part laid over it.

music21	Wheel	In the crate
`addElement`	in the wheel	`add_element`
`generateBassLine`	in the wheel	`generate_bass_line`
`retrieveSegments`	in the wheel	`segments`
`overlayPart`	in the wheel	`overlay_part`
`realize`	in the wheel	`realize`

▶RealizationfiguredBass/realizer.py wheel 7 of 7

Every way of voicing a line: counted, listed, chosen from, and written out as a score in keyboard or chorale style. Where music21 chooses at random the caller chooses.

music21	Wheel	In the crate
`getNumSolutions`	in the wheel	`num_solutions`
`getAllPossibilityProgressions`	in the wheel	`all_possibility_progressions`
`getRandomPossibilityProgression`	in the wheel	`possibility_progression_by`
`generateRealizationFromPossibilityProgression`	in the wheel	`generate_realization_from_possibility_progression`
`generateAllRealizations`	in the wheel	`generate_all_realizations`
`generateRandomRealization`	in the wheel	`generate_random_realization`
`generateRandomRealizations`	in the wheel	`generate_random_realizations`

▶KeyWeightKeyAnalysisanalysis/discrete.py wheel 2 of 6

4 not in wheel

Key finding by correlating a duration-weighted pitch-class distribution with one of five key profiles.

music21	Wheel	In the crate
`solutionLegend`	not in the wheel	the colour legend of a keyscape graph; presentation
`solutionUnitString`	not in the wheel	the unit a graph's legend is labelled with; presentation
`solutionToColor`	not in the wheel	the colour a key is drawn in; presentation
`process`	not in the wheel	`estimate_key_from_distribution`
`getWeights`	in the wheel	`major_weights`
`getSolution`	in the wheel	`estimate_key_from_distribution`

▶Ambitusanalysis/discrete.py wheel 2 of 6

4 not in wheel

music21	Wheel	In the crate
`solutionLegend`	not in the wheel	the colour legend of a graph; presentation
`solutionUnitString`	not in the wheel	the unit a graph's legend is labelled with; presentation
`solutionToColor`	not in the wheel	the colour a span is drawn in; presentation
`process`	not in the wheel	`pitch_span`
`getPitchSpan`	in the wheel	`pitch_span`
`getSolution`	in the wheel	`pitch_span`

▶MelodicIntervalDiversityanalysis/discrete.py wheel 4 of 4

music21	Wheel	In the crate
`solutionToColor`	in the wheel	the colour a count is drawn in; presentation
`countMelodicIntervals`	in the wheel	`melodic_interval_counts`
`process`	in the wheel	`melodic_interval_counts`
`getSolution`	in the wheel	`melodic_interval_counts`

▶EnharmonicSimplifieranalysis/enharmonics.py wheel 6 of 6

The best spelling of a run of pitches, scored on augmented and diminished steps, accidentals and their mixture.

music21	Wheel	In the crate
`getRepresentations`	in the wheel	`spelling_options`
`getProduct`	in the wheel	lists every combination of the spellings at once; best_choice walks them one at a time
`bestPitches`	in the wheel	`best_spelling`
`getAlterationScore`	in the wheel	`alteration_score`
`getMixSharpFlatsScore`	in the wheel	`mixture_score`
`getAugDimScore`	in the wheel	`aug_dim_score`

▶analysis/neoRiemannian.py functionsanalysis/neoRiemannian.py wheel 12 of 12

L, P and R, their chains, the hexatonic cycle and systems, and the chromatic and disjunct mediants.

music21	Wheel	In the crate
`L`	in the wheel	`apply`
`P`	in the wheel	`apply`
`R`	in the wheel	`apply`
`isNeoR`	in the wheel	`is_neo_r`
`isChromaticMediant`	in the wheel	`is_chromatic_mediant`
`LRP_combinations`	in the wheel	`lrp_combination`
`completeHexatonic`	in the wheel	`complete_hexatonic`
`hexatonicSystem`	in the wheel	`hexatonic_system`
`chromaticMediants`	in the wheel	`chromatic_mediant`
`disjunctMediants`	in the wheel	`disjunct_mediant`
`S`	in the wheel	`slide`
`N`	in the wheel	`nebenverwandt`

▶analysis/harmonicFunction.py functionsanalysis/harmonicFunction.py wheel 2 of 2

The eighteen harmonic function labels and the Roman numerals they stand for, in either mode.

music21	Wheel	In the crate
`functionToRoman`	in the wheel	`to_roman`
`romanToFunction`	in the wheel	`from_roman`

▶TranspositionCheckeranalysis/transposition.py wheel 6 of 6

A set of pitches in all twelve transpositions, and how many of them differ.

music21	Wheel	In the crate
`getTranspositions`	in the wheel	`transpositions`
`listNormalOrders`	in the wheel	`normal_orders`
`listDistinctNormalOrders`	in the wheel	`distinct_normal_orders`
`numDistinctTranspositions`	in the wheel	`distinct_count`
`getChordsOfDistinctTranspositions`	in the wheel	`distinct_chords`
`getPitchesOfDistinctTranspositions`	in the wheel	`distinct_pitches`

▶analysis/patel.py functionsanalysis/patel.py wheel 2 of 2

The normalized pairwise variability of a rhythm and the melodic interval variability of a line.

music21	Wheel	In the crate
`nPVI`	in the wheel	`n_pvi`
`melodicIntervalVariability`	in the wheel	`melodic_interval_variability`

▶analysis/metrical.py functionsanalysis/metrical.py wheel 2 of 2

The depth of the metrical hierarchy at each note, and Thomassen's melodic accent.

music21	Wheel	In the crate
`labelBeatDepth`	in the wheel	`label_beat_depth`
`thomassenMelodicAccent`	in the wheel	`thomassen_melodic_accent`

▶Segmenteranalysis/segmentByRests.py wheel 2 of 2

A part cut into its runs of notes between rests and clefs, and the intervals inside them.

music21	Wheel	In the crate
`getSegmentsList`	in the wheel	`segments_list`
`getIntervalList`	in the wheel	`interval_list`

▶analysis/pitchAnalysis.py functionsanalysis/pitchAnalysis.py wheel 1 of 1

How often each value of a property of a stream's pitches comes.

music21	Wheel	In the crate
`pitchAttributeCount`	in the wheel	`pitch_attribute_count`

▶WindowedAnalysisanalysis/windowed.py wheel 3 of 3

A stream cut into quarter-note windows, and an analysis run over windows of each size.

music21	Wheel	In the crate
`getMinimumWindowStream`	in the wheel	`new`
`analyze`	in the wheel	`analyze`
`process`	in the wheel	`process`

▶KeyAnalyzeranalysis/floatingKey.py wheel 4 of 4

A key for every measure, each measure's reading smoothed by its neighbours'.

music21	Wheel	In the crate
`run`	in the wheel	`run`
`getRawKeyByMeasure`	in the wheel	`raw_key_by_measure`
`getInterpretationByMeasure`	in the wheel	`interpretation_by_measure`
`smoothInterpretationByMeasure`	in the wheel	`smooth_interpretation_by_measure`

▶analysis/floatingKey.py functionsanalysis/floatingKey.py wheel 1 of 1

music21	Wheel	In the crate
`divide`	in the wheel	`divide`

▶humdrum/harmParser.py functionshumdrum/harmParser.py wheel 0 of 1

1 not in wheel

The harmonic annotations a **harm spine carries, read as the roman numerals they stand for.

music21	Wheel	In the crate
`convertHarmToRoman`	not in the wheel	`convert_harm_to_roman`

▶HarmParserhumdrum/harmParser.py wheel 0 of 1

1 not in wheel

A **harm token read: the accidental, the degree, the quality, the intervals, the inversion, an alternative reading and a secondary function. music21 reads it with the regular expressions of its HarmDefs, which the crate has none of -- Harm::parse reads the token by hand in the same order, and ROOTS is the table of degrees.

music21	Wheel	In the crate
`parse`	not in the wheel	`parse`

▶Barlinebar.py wheel 2 of 2

How a measure is closed. A crate measure keeps one as its own left_barline or right_barline, and a barline standing inside a measure is an element of the stream.

music21	Wheel	In the crate
`type`	in the wheel	`bar_type`
`musicXMLBarStyle`	in the wheel	`musicxml_bar_style`

▶Repeatbar.py wheel 3 of 3

A barline that says which way the music goes back. A crate barline carries the direction and the times, so a repeat is a barline that has them.

music21	Wheel	In the crate
`direction`	in the wheel	`repeat_direction`
`times`	in the wheel	`repeat_times`
`getTextExpression`	in the wheel	`repeat_text_expression`

▶Streamstream/base.py wheel 99 of 131

32 not in wheel

Music on a timeline, and the subclasses music21 nests inside one another: Measure, Part, PartStaff, Score, Voice and Opus are all read here, since the crate has one Stream with a StreamKind where music21 has seven classes. What makes an object a *member* of a music21 stream is deliberately absent -- sites, contexts, derivations, activeSite -- so the members that ask an element where it sits, or ask the stream to hold somebody else's object, are excluded with their reasons. The notation methods live in makenotation, what a bar and a beat last in meter, and the variant methods in variant, which is where music21 keeps them too.

music21	Wheel	In the crate
`write`	not in the wheel	writing a file, which the format modules do
`show`	not in the wheel	rendering, which the crate leaves to its caller
`iter`	not in the wheel	`iter`
`first`	not in the wheel	as `elementOffset`: `events` answers in order
`last`	not in the wheel	as `elementOffset`: `events` answers in order
`clear`	not in the wheel	empties a stream in place; `clone_empty` answers an empty one of the same kind
`mergeAttributes`	not in the wheel	what `clone_empty` carries over
`index`	not in the wheel	as `elementOffset`
`storeAtEnd`	not in the wheel	elements music21 keeps at the right barline rather than at an offset; a measure's barlines are its own here
`isAtEnd`	not in the wheel	needs the sites a crate stream does not keep
`setDerivationMethod`	not in the wheel	derivations, which a crate stream does not keep
`replace`	not in the wheel	swaps one object for another; `events_mut` reaches each in place
`splitAtDurations`	not in the wheel	`split_at_durations`
`recurseRepr`	not in the wheel	music21's own text dump of a stream
`plot`	not in the wheel	plotting, which the crate leaves to its caller
`addGroupForElements`	not in the wheel	the group names music21 picks elements out of a stream by; nothing a crate stream holds carries them
`getElementsByGroup`	not in the wheel	as `addGroupForElements`
`getElementById`	not in the wheel	an id on every element, which only a stream and a note carry here
`transferOffsetToElements`	not in the wheel	moves a stream's own offset onto what it holds, which needs the sites a crate stream does not keep
`haveAccidentalsBeenMade`	not in the wheel	a flag music21 keeps on the stream; nothing here remembers having been asked
`sort`	not in the wheel	a crate stream is in offset order as it is built
`containerInHierarchy`	not in the wheel	needs the sites a crate stream does not keep
`makeImmutable`	not in the wheel	music21's mutability machinery, which a value has no need of
`makeMutable`	not in the wheel	as `makeImmutable`
`duration`	not in the wheel	a crate stream has no `Duration` of its own; `highest_time` answers when the last thing in it ends
`beat`	not in the wheel	where one element sits in its bar; `placed` answers it for every element at once, and `beat_and_measure_from_offset` for a point
`beatStr`	not in the wheel	as `beat`
`beatDuration`	not in the wheel	`beat_duration`
`beatStrength`	not in the wheel	as `beat`
`attachMelodicIntervals`	not in the wheel	attaches an interval to each note; `melodic_intervals` answers them instead, a crate note carrying nothing of its line
`activateVariants`	not in the wheel	`activate_variants`
`showVariantAsOssialikePart`	not in the wheel	`show_variant_as_ossialike_part`
`elements`	in the wheel	`events`
`clef`	in the wheel	the clef a stream opens with; the clef in force is read by `in_force_before`, a crate stream keeping no clef of its own
`timeSignature`	in the wheel	`time_signature_at`
`keySignature`	in the wheel	`key_signature_at`
`staffLines`	in the wheel	`staff_lines`
`cloneEmpty`	in the wheel	`clone_empty`
`hasElementOfClass`	in the wheel	`has_element_of_class`
`mergeElements`	in the wheel	`merge_elements`
`remove`	in the wheel	takes a named object out; `retain_leaves` and `remove_event` take out by place or by test
`pop`	in the wheel	`remove_event`
`removeByClass`	in the wheel	`remove_by_class`
`removeByNotOfClass`	in the wheel	`remove_by_not_of_class`
`setElementOffset`	in the wheel	as `elementOffset`: `events_mut` reaches each in place
`elementOffset`	in the wheel	asks where one object sits; a crate stream owns values rather than objects, so `events` gives each with its offset
`insert`	in the wheel	`insert`
`insertIntoNoteOrChord`	in the wheel	`insert_into_note_or_chord`
`append`	in the wheel	`push`
`insertAndShift`	in the wheel	`insert_and_shift`
`splitAtQuarterLength`	in the wheel	`split_at_quarter_length`
`analyze`	in the wheel	`analyze`
`getElementsByClass`	in the wheel	`elements_of_class`
`getElementsNotOfClass`	in the wheel	`elements_not_of_class`
`getElementsByOffset`	in the wheel	`elements_in_span`
`getElementAtOrBefore`	in the wheel	`element_at_or_before`
`getElementBeforeOffset`	in the wheel	`element_before_offset`
`getElementAfterElement`	in the wheel	`element_after`
`measures`	in the wheel	`measures`
`measure`	in the wheel	one measure by its number; `measures` answers them all, each carrying its own `number`
`template`	in the wheel	`template`
`measureOffsetMap`	in the wheel	`measure_offset_map`
`finalBarline`	in the wheel	`final_barline`
`voices`	in the wheel	`voices`
`spanners`	in the wheel	`spanners`
`atSoundingPitch`	in the wheel	`at_sounding_pitch`
`toSoundingPitch`	in the wheel	`to_sounding_pitch`
`toWrittenPitch`	in the wheel	`to_written_pitch`
`getTimeSignatures`	in the wheel	`time_signatures`
`getInstruments`	in the wheel	`instruments`
`getInstrument`	in the wheel	`instrument`
`invertDiatonic`	in the wheel	`invert_diatonic`
`shiftElements`	in the wheel	`shift_elements`
`repeatAppend`	in the wheel	`repeat_append`
`repeatInsert`	in the wheel	`repeat_insert`
`extractContext`	in the wheel	`extract_context`
`chordify`	in the wheel	`chordify`
`splitByClass`	in the wheel	`split_by`
`offsetMap`	in the wheel	`offset_map`
`makeMeasures`	in the wheel	`make_measures`
`makeRests`	in the wheel	`make_rests`
`makeTies`	in the wheel	`make_ties`
`makeBeams`	in the wheel	`make_beams`
`makeAccidentals`	in the wheel	`make_accidentals`
`makeNotation`	in the wheel	`make_notation`
`extendDuration`	in the wheel	`extend_duration`
`stripTies`	in the wheel	`strip_ties`
`extendTies`	in the wheel	`extend_ties`
`sorted`	in the wheel	as `sort`
`flatten`	in the wheel	`flatten`
`recurse`	in the wheel	`recurse`
`highestOffset`	in the wheel	`highest_offset`
`highestTime`	in the wheel	`highest_time`
`lowestOffset`	in the wheel	`lowest_offset`
`seconds`	in the wheel	`seconds`
`metronomeMarkBoundaries`	in the wheel	`metronome_mark_boundaries`
`metadata`	in the wheel	`metadata`
`beatAndMeasureFromOffset`	in the wheel	`beat_and_measure_from_offset`
`transpose`	in the wheel	`transpose`
`scaleOffsets`	in the wheel	`scale_offsets`
`scaleDurations`	in the wheel	`scale_durations`
`augmentOrDiminish`	in the wheel	`augment_or_diminish`
`quantize`	in the wheel	`quantize`
`expandRepeats`	in the wheel	`expand_repeats`
`sliceByQuarterLengths`	in the wheel	`slice_by_quarter_lengths`
`sliceByGreatestDivisor`	in the wheel	`slice_by_greatest_divisor`
`sliceAtOffsets`	in the wheel	`slice_at_offsets`
`sliceByBeat`	in the wheel	`slice_by_beat`
`hasMeasures`	in the wheel	`has_measures`
`hasVoices`	in the wheel	`has_voices`
`hasPartLikeStreams`	in the wheel	`has_part_like_streams`
`isTwelveTone`	in the wheel	`is_twelve_tone`
`isWellFormedNotation`	in the wheel	`is_well_formed_notation`
`notesAndRests`	in the wheel	`notes_and_rests`
`notes`	in the wheel	`notes`
`pitches`	in the wheel	`pitches`
`findConsecutiveNotes`	in the wheel	`find_consecutive_notes`
`melodicIntervals`	in the wheel	`melodic_intervals`
`findGaps`	in the wheel	`find_gaps`
`isGapless`	in the wheel	`is_gapless`
`getOverlaps`	in the wheel	`get_overlaps`
`isSequence`	in the wheel	`is_sequence`
`simultaneousAttacks`	in the wheel	`simultaneous_attacks`
`attachIntervalsBetweenStreams`	in the wheel	`harmonic_intervals`
`playingWhenAttacked`	in the wheel	`playing_when_attacked`
`allPlayingWhileSounding`	in the wheel	`all_playing_while_sounding`
`makeVoices`	in the wheel	`make_voices`
`voicesToParts`	in the wheel	`voices_to_parts`
`explode`	in the wheel	`explode`
`flattenUnnecessaryVoices`	in the wheel	`flatten_unnecessary_voices`
`lyrics`	in the wheel	`lyrics`

▶Measurestream/base.py wheel 8 of 9

1 not in wheel

A bar of music. A crate stream of kind Measure carries its own barlines and padding, and what a bar and a beat last is read off the metre.

music21	Wheel	In the crate
`mergeAttributes`	not in the wheel	what `clone_empty` carries over
`measureNumberWithSuffix`	in the wheel	`number_with_suffix`
`makeNotation`	in the wheel	`make_notation`
`barDurationProportion`	in the wheel	`bar_duration_proportion`
`padAsAnacrusis`	in the wheel	`pad_as_anacrusis`
`barDuration`	in the wheel	`bar_duration`
`bestTimeSignature`	in the wheel	`best_time_signature`
`leftBarline`	in the wheel	`left_barline`
`rightBarline`	in the wheel	`right_barline`

▶Partstream/base.py wheel 3 of 4

1 not in wheel

One player's line. A crate stream of kind Part or PartStaff carries the name and abbreviation music21 keeps as partName and partAbbreviation.

music21	Wheel	In the crate
`mergeAttributes`	not in the wheel	what `clone_empty` carries over
`partName`	in the wheel	`name`
`partAbbreviation`	in the wheel	`abbreviation`
`makeAccidentals`	in the wheel	`make_accidentals`

▶Scorestream/base.py wheel 9 of 9

Every part of a piece together.

music21	Wheel	In the crate
`parts`	in the wheel	`parts`
`measures`	in the wheel	`measures`
`measure`	in the wheel	one measure by its number; `measures` answers them all, each carrying its own `number`
`expandRepeats`	in the wheel	`expand_repeats`
`measureOffsetMap`	in the wheel	`measure_offset_map`
`sliceByGreatestDivisor`	in the wheel	`slice_by_greatest_divisor`
`partsToVoices`	in the wheel	`parts_to_voices`
`implode`	in the wheel	`implode`
`makeNotation`	in the wheel	`make_notation`

▶Opusstream/base.py wheel 5 of 7

2 not in wheel

The scores a multi-work file holds, which many an ABC or Essen collection is.

music21	Wheel	In the crate
`write`	not in the wheel	writing a file, which the format modules do
`show`	not in the wheel	rendering, which the crate leaves to its caller
`getNumbers`	in the wheel	`score_numbers`
`getScoreByNumber`	in the wheel	`score_by_number`
`getScoreByTitle`	in the wheel	`score_by_title`
`scores`	in the wheel	`scores`
`mergeScores`	in the wheel	`merge_scores`

▶percussion.py classespercussion.py wheel 0 of 1

1 not in wheel

Unpitched percussion: a stroke written on a staff with no pitch to it, and a chord of them.

music21	Wheel	In the crate
`PercussionChord`	not in the wheel	`PercussionChord`

▶PercussionChordpercussion.py wheel 0 of 2

2 not in wheel

A chord of strokes, each of which may be pitched or not. Its members are PercussionNotes rather than notes, since a stroke is not a note.

music21	Wheel	In the crate
`notes`	not in the wheel	`members`
`pitches`	not in the wheel	`pitches`

▶tablature.py classestablature.py wheel 0 of 8

8 not in wheel

Fretted-instrument tablature: which string is stopped at which fret, and the pitches that sounds. The four instruments music21 keeps a class each for are constructors here, a fretboard being the same thing whatever it is strung as.

music21	Wheel	In the crate
`FretNote`	not in the wheel	`FretNote`
`FretBoard`	not in the wheel	`FretBoard`
`FirstFret`	not in the wheel	`FirstFret`
`ChordWithFretBoard`	not in the wheel	`ChordWithFretBoard`
`GuitarFretBoard`	not in the wheel	`guitar`
`UkeleleFretBoard`	not in the wheel	`ukulele`
`BassGuitarFretBoard`	not in the wheel	`bass_guitar`
`MandolinFretBoard`	not in the wheel	`mandolin`

▶FretBoardtablature.py wheel 0 of 3

3 not in wheel

music21	Wheel	In the crate
`fretNotesLowestFirst`	not in the wheel	`fret_notes_lowest_first`
`getFretNoteByString`	not in the wheel	`fret_note_by_string`
`getPitches`	not in the wheel	`pitches`

▶ChordWithFretBoardtablature.py wheel 0 of 1

1 not in wheel

A chord symbol with a diagram under it.

music21	Wheel	In the crate
`getFretNotesFromFigure`	not in the wheel	music21's own is a stub that answers nothing, its docstring a `TODO`: the fret notes a figure stands for are not worked out there either

▶text.py functionstext.py wheel 0 of 4

4 not in wheel

Words in a score: the lyrics assembled off its notes, and an article moved to the front of a title or back to its end.

music21	Wheel	In the crate
`assembleLyrics`	not in the wheel	`assemble_lyrics`
`assembleAllLyrics`	not in the wheel	`assemble_all_lyrics`
`prependArticle`	not in the wheel	`prepend_article`
`postpendArticle`	not in the wheel	`postpend_article`

▶TextBoxtext.py wheel 0 of 2

2 not in wheel

Text standing anywhere on the page, which MusicXML writes as a credit.

music21	Wheel	In the crate
`content`	not in the wheel	`content`
`page`	not in the wheel	`page`

▶LanguageDetectortext.py wheel 0 of 3

3 not in wheel

Which language a text is most likely in, by the letters that follow each pair of letters.

music21	Wheel	In the crate
`readExcerpts`	not in the wheel	reads the excerpt files off the disk; the crate's excerpts are built in and the library does no file IO
`mostLikelyLanguage`	not in the wheel	`most_likely_language`
`mostLikelyLanguageNumeric`	not in the wheel	`most_likely_language_numeric`

▶Trigramtext.py wheel 0 of 6

6 not in wheel

music21	Wheel	In the crate
`length`	not in the wheel	`length`
`parseExcerpt`	not in the wheel	`from_text`
`measure`	not in the wheel	the step that counts the letter triples, which building one does
`similarity`	not in the wheel	`similarity`
`makeWords`	not in the wheel	`from_words`
`likely`	not in the wheel	which language a trigram is nearest, which `most_likely_language` answers

▶layout.py classeslayout.py wheel 0 of 10

10 not in wheel

How a score is laid out: the page and system margins a file states, a staff's size and lines, and the parts bracketed together.

music21	Wheel	In the crate
`LayoutBase`	not in the wheel	the class music21 hangs the four layouts off; `layout::Layout` is the one of them a stream holds
`ScoreLayout`	not in the wheel	`ScoreLayout`
`PageLayout`	not in the wheel	`PageLayout`
`SystemLayout`	not in the wheel	`SystemLayout`
`StaffLayout`	not in the wheel	`StaffLayout`
`StaffGroup`	not in the wheel	`StaffGroup`
`LayoutScore`	not in the wheel	a score regrouped into pages, systems and staves for a renderer, with the three streams below it; the crate keeps the layout a file states and renders nothing
`Page`	not in the wheel	a page of such a score
`System`	not in the wheel	a system of such a score
`Staff`	not in the wheel	a staff of such a score

▶layout.py functionslayout.py wheel 0 of 4

4 not in wheel

Reading a score's measures back off its pages and systems, which only a LayoutScore has.

music21	Wheel	In the crate
`divideByPages`	not in the wheel	builds a `LayoutScore`, which the crate has none of
`getPageRegionMeasureNumbers`	not in the wheel	the measures on a page of a `LayoutScore`
`getSystemRegionMeasureNumbers`	not in the wheel	the measures in a system of a `LayoutScore`
`getRegionMeasureNumbers`	not in the wheel	the measures in a region of a `LayoutScore`

▶ScoreLayoutlayout.py wheel 0 of 1

1 not in wheel

music21	Wheel	In the crate
`tenthsToMillimeters`	not in the wheel	`tenths_to_millimeters`

▶StaffGrouplayout.py wheel 0 of 2

2 not in wheel

The parts a brace or a bracket joins, and whether their barlines are drawn through.

music21	Wheel	In the crate
`barTogether`	not in the wheel	`bar_together`
`symbol`	not in the wheel	`symbol`

▶style.py classesstyle.py wheel 2 of 10

8 not in wheel

How something is drawn. The crate models what a reader must read back to write the same document again -- a text's font and where it sits, a line's ticks, a colour -- and the page itself it does not model. Inside music21 the wheel hands back music21's own style objects, whose subclasses carry more than one class here would.

music21	Wheel	In the crate
`Enclosure`	not in the wheel	the shape drawn round a text, kept as the name music21 gives it where something has one (`expressions::RehearsalMark::enclosure`) rather than as a type of its own
`TextStyle`	not in the wheel	`TextStyle`
`TextStylePlacement`	not in the wheel	a text style that also says which side of the staff it is on, which is `display::Drawn` here
`BezierStyle`	not in the wheel	the curve of a slur
`LineStyle`	not in the wheel	the dashes of a line
`StreamStyle`	not in the wheel	how a whole stream is drawn
`BeamStyle`	not in the wheel	how a beam is drawn
`StyleMixin`	not in the wheel	what music21 mixes into every class it draws; nothing here has a style of its own to mix in
`Style`	in the wheel	the base class every style hangs off; the crate keeps the few drawing values it reads and writes beside the thing drawn
`NoteStyle`	in the wheel	how a note is drawn beyond its colour and its size

▶TextStylestyle.py wheel 0 of 8

8 not in wheel

music21	Wheel	In the crate
`alignVertical`	not in the wheel	`align_vertical`
`alignHorizontal`	not in the wheel	`align_horizontal`
`justify`	not in the wheel	`justify`
`fontStyle`	not in the wheel	`font_style`
`fontWeight`	not in the wheel	`font_weight`
`fontSize`	not in the wheel	`font_size`
`letterSpacing`	not in the wheel	the space between a text's letters: nothing the crate reads states one, and the writer is held to music21's output byte for byte on every corpus score, so there is nothing to carry across
`fontFamily`	not in the wheel	`font_family`

▶spanner.py classesspanner.py wheel 2 of 10

8 not in wheel

Something drawn across several notes: a slur, a hairpin, an octave line, a pedal mark. A spanner here is one value with a kind, naming the leaves it joins by their position in the stream that holds it.

music21	Wheel	In the crate
`PendingAssignmentRef`	not in the wheel	music21's note to itself that a spanner is waiting for its first element, which the readers keep as a queue
`SpannerAnchor`	not in the wheel	an element standing in a stream for a spanner to hang off where there is no note to; a spanner here names positions and needs none
`Slur`	not in the wheel	`Slur`
`MultiMeasureRest`	not in the wheel	several measures of rest drawn as one, which is a notation this crate does not write
`RepeatBracket`	not in the wheel	`Ending`
`Ottava`	not in the wheel	`Ottava`
`Line`	not in the wheel	`Line`
`Glissando`	not in the wheel	`Glissando`
`Spanner`	in the wheel	`Spanner`
`SpannerBundle`	in the wheel	the collection music21 keeps a stream's spanners in; a crate stream holds its own

▶Spannerspanner.py wheel 6 of 14

8 not in wheel

The leaves a spanner joins are positions in Stream::leaves, so what it holds is the stream's to hand back.

music21	Wheel	In the crate
`purgeOrphans`	not in the wheel	drops the elements no stream holds any more, which only a spanner keeping objects can have
`purgeLocations`	not in the wheel	drops the sites it remembers, and it remembers none
`getSpannedElementsByClass`	not in the wheel	the elements of a class among them, which the stream holding them answers
`getSpannedElementIds`	not in the wheel	Python object ids
`insertFirstSpannedElement`	not in the wheel	puts an element first by object
`fill`	not in the wheel	fills in every element between the first and the last, which asks the stream what stands between them
`isFirst`	not in the wheel	`is_first`
`isLast`	not in the wheel	`is_last`
`getSpannedElements`	in the wheel	`spanned`
`addSpannedElements`	in the wheel	adds elements by object; `Spanner::new` takes the positions it joins
`hasSpannedElement`	in the wheel	whether an element is among them, which is `spanned().contains`
`replaceSpannedElement`	in the wheel	swaps one element for another by object
`getFirst`	in the wheel	the first element itself; `spanned` gives its position and the stream hands back what stands there
`getLast`	in the wheel	the last element itself, likewise

▶Ottavaspanner.py wheel 0 of 6

6 not in wheel

An octave line, and whether the notes under it are written where they sound.

music21	Wheel	In the crate
`type`	not in the wheel	`name`
`shiftMagnitude`	not in the wheel	`magnitude`
`shiftDirection`	not in the wheel	`up`
`interval`	not in the wheel	`interval`
`performTransposition`	not in the wheel	`to_sounding_pitch`
`undoTransposition`	not in the wheel	`to_written_pitch`

▶Linespanner.py wheel 0 of 6

6 not in wheel

A bracket with a tick at each end.

music21	Wheel	In the crate
`endTick`	not in the wheel	`end`
`startTick`	not in the wheel	`start`
`tick`	not in the wheel	sets both ends at once; `LineEnds` carries each
`lineType`	not in the wheel	`line_type`
`endHeight`	not in the wheel	`end_height`
`startHeight`	not in the wheel	`start_height`

▶Glissandospanner.py wheel 0 of 2

2 not in wheel

music21	Wheel	In the crate
`lineType`	not in the wheel	`line_type`
`slideType`	not in the wheel	`slide_type`

▶repeat.py classesrepeat.py wheel 0 of 16

16 not in wheel

The marks that send the music back -- a segno, a coda, a da capo -- which are the kinds of one RepeatExpression here, and the expansion that plays them out.

music21	Wheel	In the crate
`RepeatMark`	not in the wheel	what music21 mixes into everything that repeats; a barline here says it repeats and an expression says where to go back to
`RepeatExpression`	not in the wheel	`RepeatExpression`
`RepeatExpressionMarker`	not in the wheel	`is_marker`
`Coda`	not in the wheel	`Coda`
`Segno`	not in the wheel	`Segno`
`Fine`	not in the wheel	`Fine`
`RepeatExpressionCommand`	not in the wheel	the kinds that send the music somewhere rather than marking a place, which is every kind `is_marker` says no to
`DaCapo`	not in the wheel	`DaCapo`
`DaCapoAlFine`	not in the wheel	`DaCapoAlFine`
`DaCapoAlCoda`	not in the wheel	`DaCapoAlCoda`
`AlSegno`	not in the wheel	`AlSegno`
`DalSegno`	not in the wheel	`DalSegno`
`DalSegnoAlFine`	not in the wheel	`DalSegnoAlFine`
`DalSegnoAlCoda`	not in the wheel	`DalSegnoAlCoda`
`Expander`	not in the wheel	`expand_repeats`
`RepeatFinder`	not in the wheel	finds the repeated passages of a score so as to write it with repeat signs, which nothing here writes

▶repeat.py functionsrepeat.py wheel 0 of 3

3 not in wheel

Writing repeats into a score, which the crate does not do: it plays out the repeats a score already has.

music21	Wheel	In the crate
`insertRepeatEnding`	not in the wheel	writes an ending bracket over some measures
`insertRepeat`	not in the wheel	writes repeat barlines round some measures
`deleteMeasures`	not in the wheel	takes measures out and renumbers the rest

▶RepeatExpressionrepeat.py wheel 0 of 6

6 not in wheel

music21	Wheel	In the crate
`getText`	not in the wheel	`text`
`setText`	not in the wheel	`set_text`
`applyTextFormatting`	not in the wheel	the font and the justification a renderer draws the words with; `justify` says which way they are set
`setTextExpression`	not in the wheel	keeps the words as a `TextExpression` object
`getTextExpression`	not in the wheel	the words as a `TextExpression` for a renderer; `text` is what they say
`isValidText`	not in the wheel	`is_valid_text`

▶Expanderrepeat.py wheel 0 of 7

7 not in wheel

Playing a score's repeats out, which Stream::expand_repeats does in one.

music21	Wheel	In the crate
`process`	not in the wheel	`expand_repeats`
`measureMap`	not in the wheel	the measures of the expansion listed for a caller to read
`repeatBarsAreCoherent`	not in the wheel	a step of the expansion, which answers an error where the repeats make no sense
`findInnermostRepeatIndices`	not in the wheel	a step of the expansion
`processInnermostRepeatBars`	not in the wheel	a step of the expansion
`getRepeatExpressionIndex`	not in the wheel	a step of the expansion
`isExpandable`	not in the wheel	whether there is anything to play out, which expanding answers

▶variant.py functionsvariant.py wheel 0 of 10

10 not in wheel

Another reading of a passage kept beside the one in the score: merged in from a second source, refined, gathered into blocks, and activated in place of what it replaces.

music21	Wheel	In the crate
`mergeVariants`	not in the wheel	`merge_variants`
`mergeVariantScores`	not in the wheel	`merge_variant_scores`
`mergeVariantMeasureStreams`	not in the wheel	`merge_variant_measure_streams`
`mergeVariantsEqualDuration`	not in the wheel	`merge_variants_equal_duration`
`mergePartAsOssia`	not in the wheel	`merge_part_as_ossia`
`addVariant`	not in the wheel	`add_variant`
`refineVariant`	not in the wheel	`refine_variant`
`getMeasureHashes`	not in the wheel	`measure_hashes`
`makeAllVariantsReplacements`	not in the wheel	`make_all_variants_replacements`
`makeVariantBlocks`	not in the wheel	`make_variant_blocks`

▶Variantvariant.py wheel 0 of 15

15 not in wheel

music21	Wheel	In the crate
`purgeOrphans`	not in the wheel	drops the elements no stream holds any more, which only a variant keeping objects can have
`purgeLocations`	not in the wheel	drops the sites it remembers, and it remembers none
`getElementIds`	not in the wheel	Python object ids
`replaceElement`	not in the wheel	swaps one element for another by object
`highestTime`	not in the wheel	`highest_time`
`highestOffset`	not in the wheel	the offset of the stream it holds, which `Stream::highest_offset` answers of its contents
`show`	not in the wheel	rendering, which the crate leaves to its caller
`containedHighestTime`	not in the wheel	`contained_highest_time`
`containedHighestOffset`	not in the wheel	`contained_highest_offset`
`containedSite`	not in the wheel	the stream it was read out of, which is a site
`replacementQuarterLength`	not in the wheel	`replacement_quarter_length`
`replacementDuration`	not in the wheel	the `Duration` of what it replaces; `replacement_quarter_length` is how long that is
`lengthType`	not in the wheel	`length_type`
`replacedElements`	not in the wheel	`replaced_elements`
`removeReplacedElementsFromStream`	not in the wheel	`remove_replaced_elements_from_stream`

▶Metadatametadata/__init__.py wheel 3 of 35

32 not in wheel

What a score says about itself. Every standard name is read and written by that name through one pair of members, where music21 keeps a property for each; STANDARD_PROPERTIES is the table of the 131 names, checked against music21's live one by metadata_parity.

music21	Wheel	In the crate
`add`	not in the wheel	`add`
`getCustom`	not in the wheel	`get`
`addCustom`	not in the wheel	`add`
`setCustom`	not in the wheel	`set`
`uniqueNameToNamespaceName`	not in the wheel	`namespace_name`
`namespaceNameToUniqueName`	not in the wheel	`unique_name_of`
`isContributorUniqueName`	not in the wheel	`is_contributor_unique_name`
`isStandardName`	not in the wheel	`unique_name_of`
`software`	not in the wheel	`get`
`contributors`	not in the wheel	`contributors`
`copyright`	not in the wheel	`string_value`
`getContributorsByRole`	not in the wheel	`contributors_by_role`
`alternativeTitle`	not in the wheel	`string_value`
`composer`	not in the wheel	`string_value`
`composers`	not in the wheel	`get`
`dateCreated`	not in the wheel	`string_value`
`fileFormat`	not in the wheel	`string_value`
`filePath`	not in the wheel	`string_value`
`corpusFilePath`	not in the wheel	`string_value`
`fileNumber`	not in the wheel	`string_value`
`localeOfComposition`	not in the wheel	`string_value`
`librettist`	not in the wheel	`string_value`
`librettists`	not in the wheel	`get`
`lyricist`	not in the wheel	`string_value`
`lyricists`	not in the wheel	`get`
`movementName`	not in the wheel	`string_value`
`movementNumber`	not in the wheel	`string_value`
`number`	not in the wheel	`string_value`
`opusNumber`	not in the wheel	`string_value`
`title`	not in the wheel	`title`
`bestTitle`	not in the wheel	`best_title`
`convertValue`	not in the wheel	reads a value as one of music21's own primitives -- a `Text`, a `Contributor`, a `Date`; a `MetadataValue` here is the text and the role it was given under
`all`	in the wheel	`all`
`addContributor`	in the wheel	`add_contributor`
`search`	in the wheel	`search`

▶RichMetadatametadata/__init__.py wheel 0 of 4

4 not in wheel

The numbers music21 caches beside a score's metadata so that its corpus can be searched without parsing every file again.

music21	Wheel	In the crate
`merge`	not in the wheel	takes in another score's cached numbers
`getSourcePath`	not in the wheel	where the file sits, relative to the corpus
`update`	not in the wheel	works out the ambitus, the key signatures, the time signatures and the rest of a score and keeps them; `Stream::analyze` answers each of those of a score when asked
`all`	not in the wheel	the cached numbers beside the metadata

▶search/base.py functionssearch/base.py wheel 0 of 18

18 not in wheel

Searching a stream for a run of notes: the searches themselves, and the strings music21 turns a line into so that one line can be matched against another.

music21	Wheel	In the crate
`streamSearchBase`	not in the wheel	`run_over`
`rhythmicSearch`	not in the wheel	`rhythmic_search`
`noteNameSearch`	not in the wheel	`note_name_search`
`noteNameRhythmicSearch`	not in the wheel	`note_name_rhythmic_search`
`approximateNoteSearch`	not in the wheel	`approximate_note_search`
`approximateNoteSearchNoRhythm`	not in the wheel	`approximate_note_search_no_rhythm`
`approximateNoteSearchOnlyRhythm`	not in the wheel	`approximate_note_search_only_rhythm`
`approximateNoteSearchWeighted`	not in the wheel	`approximate_note_search_weighted`
`translateStreamToString`	not in the wheel	`translate_stream_to_string`
`translateDiatonicStreamToString`	not in the wheel	`translate_diatonic_stream_to_string`
`translateIntervalsAndSpeed`	not in the wheel	`translate_intervals_and_speed`
`translateStreamToStringNoRhythm`	not in the wheel	`translate_stream_to_string_no_rhythm`
`translateStreamToStringOnlyRhythm`	not in the wheel	`translate_stream_to_string_only_rhythm`
`translateNoteToByte`	not in the wheel	`translate_note_to_byte`
`translateNoteWithDurationToBytes`	not in the wheel	`translate_note_with_duration_to_bytes`
`translateNoteTieToByte`	not in the wheel	`translate_note_tie_to_byte`
`translateDurationToBytes`	not in the wheel	`translate_duration_to_bytes`
`mostCommonMeasureRhythms`	not in the wheel	`most_common_measure_rhythms`

▶StreamSearchersearch/base.py wheel 0 of 4

4 not in wheel

A search for a list of terms, each a note name, a length or a wildcard.

music21	Wheel	In the crate
`run`	not in the wheel	`run`
`wildcardAlgorithm`	not in the wheel	`run_over`
`rhythmAlgorithm`	not in the wheel	`rhythmic_search`
`noteNameAlgorithm`	not in the wheel	`note_name_search`

▶LyricSearchersearch/lyrics.py wheel 0 of 4

4 not in wheel

Searching the words sung in a score, which means indexing them into one text first.

music21	Wheel	In the crate
`indexText`	not in the wheel	`index_text`
`indexTuples`	not in the wheel	`indexed`
`index`	not in the wheel	`indexed`
`search`	not in the wheel	`search`

▶IndexedLyricsearch/lyrics.py wheel 0 of 1

1 not in wheel

music21	Wheel	In the crate
`modify`	not in the wheel	a named tuple's `_replace`, which is Python's own

▶search/segment.py functionssearch/segment.py wheel 0 of 8

8 not in wheel

Comparing scores by cutting each part into overlapping segments and matching the strings they make.

music21	Wheel	In the crate
`translateMonophonicPartToSegments`	not in the wheel	`translate_monophonic_part_to_segments`
`indexScoreParts`	not in the wheel	`index_score_parts`
`indexScoreFilePaths`	not in the wheel	indexes the scores at a list of paths, which means reading files
`indexOnePath`	not in the wheel	indexes the score at a path, likewise
`saveScoreDict`	not in the wheel	writes an index to a file
`loadScoreDict`	not in the wheel	reads an index back
`getDifflibOrPyLev`	not in the wheel	chooses between two Python libraries for the string comparison; `search::difflib` is the one `difflib.SequenceMatcher` ratio, ported
`scoreSimilarity`	not in the wheel	`score_similarity`

▶ReductiveNoteanalysis/reduction.py wheel 0 of 2

2 not in wheel

A note of a reduction, written in a lyric under the note it reduces.

music21	Wheel	In the crate
`isParsed`	not in the wheel	`is_parsed`
`getNoteAndTextExpression`	not in the wheel	`note_and_text_expression`

▶ScoreReductionanalysis/reduction.py wheel 0 of 3

3 not in wheel

music21	Wheel	In the crate
`score`	not in the wheel	`score`
`chordReduction`	not in the wheel	`chord_reduction`
`reduce`	not in the wheel	`reduce`

▶PartReductionanalysis/reduction.py wheel 0 of 2

2 not in wheel

How busy each part of a score is, span by span, which music21 draws as a horizontal bar graph.

music21	Wheel	In the crate
`process`	not in the wheel	`weighted_spans`
`getGraphHorizontalBarWeightedData`	not in the wheel	the spans arranged for music21's bar graph; `weighted_spans` is what they say

▶ActivityMatchanalysis/correlate.py wheel 0 of 1

1 not in wheel

What goes with what in a stream: every pitch against the dynamic sounding with it.

music21	Wheel	In the crate
`pitchToDynamic`	not in the wheel	`pitch_to_dynamic`

▶ElementTimespantree/spans.py wheel 0 of 6

6 not in wheel

One element of a stream as the stretch of time it sounds for, which is what a timespan tree holds.

music21	Wheel	In the crate
`quarterLength`	not in the wheel	`quarter_length`
`new`	not in the wheel	a copy with some of its values changed, which a value type here is made afresh
`measureNumber`	not in the wheel	`measure_number`
`getParentageByClass`	not in the wheel	`parentage`
`part`	not in the wheel	`part`
`makeElement`	not in the wheel	the element itself, which an `ElementTimespan` holds a reference to

▶Timespantree/spans.py wheel 0 of 6

6 not in wheel

music21	Wheel	In the crate
`offset`	not in the wheel	`offset`
`endTime`	not in the wheel	`end_time`
`new`	not in the wheel	a copy with some of its values changed
`canMerge`	not in the wheel	whether two timespans may be joined, which only the tree's own merging asks
`mergeWith`	not in the wheel	joins two timespans
`splitAt`	not in the wheel	cuts a timespan in two

▶TimespanTreetree/timespanTree.py wheel 0 of 17

17 not in wheel

Every element of a score as a stretch of time, which is how the voice-leading walk reads what sounds together. The crate keeps the timespans in offset order rather than in music21's tree, there being no insertion to keep balanced.

music21	Wheel	In the crate
`elementEndTime`	not in the wheel	`end_time`
`index`	not in the wheel	where a timespan sits in the tree, which is its place in the list here
`offset`	not in the wheel	`lowest_position`
`removeTimespanList`	not in the wheel	takes several out, likewise
`removeTimespan`	not in the wheel	takes a timespan out of the tree; the crate reads a stream into timespans and does not edit them
`findNextPitchedTimespanInSameStreamByClass`	not in the wheel	`next_in_same_part`
`findPreviousPitchedTimespanInSameStreamByClass`	not in the wheel	`previous_in_same_part`
`getVerticalityAtOrBefore`	not in the wheel	`verticality_at_or_before`
`iterateConsonanceBoundedVerticalities`	not in the wheel	`consonance_bounded_verticalities`
`iterateVerticalities`	not in the wheel	`verticalities`
`iterateVerticalitiesNwise`	not in the wheel	`verticalities_nwise`
`splitAt`	not in the wheel	`split_at`
`toPartwiseTimespanTrees`	not in the wheel	a tree for each part of the score; `as_timespans` reads whichever stream it is given, a part included
`unwrapVerticalities`	not in the wheel	`unwrap`
`allParts`	not in the wheel	every part the timespans came from, which the caller has in the score it read
`maximumOverlap`	not in the wheel	`maximum_overlap`
`element`	not in the wheel	the element a timespan holds, which `ElementTimespan::element` answers

▶Verticalitytree/verticality.py wheel 0 of 14

14 not in wheel

Everything sounding at one offset, which is what a chord of a chordified score is made of.

music21	Wheel	In the crate
`bassTimespan`	not in the wheel	`bass_timespan`
`beatStrength`	not in the wheel	the accent weight of the offset in the measure holding it, which music21 asks the note and the note asks its site; `TimeSignature::accent_weight` answers it given the meter
`toChord`	not in the wheel	`to_chord`
`measureNumber`	not in the wheel	`measure_number`
`nextStartOffset`	not in the wheel	`next_start_offset`
`nextVerticality`	not in the wheel	`next`
`pitchSet`	not in the wheel	`pitch_set`
`pitchClassSet`	not in the wheel	`pitch_class_set`
`previousVerticality`	not in the wheel	`previous`
`startAndOverlapTimespans`	not in the wheel	`start_and_overlap_timespans`
`timeToNextEvent`	not in the wheel	`time_to_next_event`
`makeElement`	not in the wheel	`make_element`
`getAllVoiceLeadingQuartets`	not in the wheel	`voice_leading_quartets`
`getPairedMotion`	not in the wheel	`paired_motion`

▶Horizontalitytree/analysis.py wheel 0 of 3

3 not in wheel

The timespans one voice sounds in a row, and whether the middle note of three is passed through or stepped away from and back.

music21	Wheel	In the crate
`hasPassingTone`	not in the wheel	`has_passing_tone`
`hasNeighborTone`	not in the wheel	`has_neighbor_tone`
`hasNoMotion`	not in the wheel	`has_no_motion`

▶tree/fromStream.py functionstree/fromStream.py wheel 0 of 4

4 not in wheel

Reading a score into timespans.

music21	Wheel	In the crate
`listOfTreesByClass`	not in the wheel	a tree per part per class, which the caller builds of what `as_timespans` reads
`asTree`	not in the wheel	`as_timespans`
`makeFastShallowTreeFromSortedStream`	not in the wheel	a tree of one stream's own elements with nothing nested, built without sorting; the crate sorts once and keeps a list
`asTimespans`	not in the wheel	`as_timespans`

▶tree/toStream.py functionstree/toStream.py wheel 0 of 2

2 not in wheel

Writing timespans back out as a stream.

music21	Wheel	In the crate
`chordified`	not in the wheel	`chordify`
`partwise`	not in the wheel	the timespans written back out as a part each, which is the score they were read from

▶features/base.py functionsfeatures/base.py wheel 0 of 5

5 not in wheel

The machinery round the feature extractors: finding one by its id, and the vector a stream gives for all of them. The 72 jSymbolic extractors and the 24 native ones are rows of a generated table rather than a class each, and features_parity checks that table against music21's live classes.

music21	Wheel	In the crate
`allFeaturesAsList`	not in the wheel	`all_features_as_list`
`extractorsById`	not in the wheel	`extractors_by_id`
`extractorById`	not in the wheel	`extractor_by_id`
`vectorById`	not in the wheel	`vector_by_id`
`getIndex`	not in the wheel	`index_of`

▶Featurefeatures/base.py wheel 0 of 2

2 not in wheel

What one extractor found: the numbers, and what each of them is called.

music21	Wheel	In the crate
`prepareVectors`	not in the wheel	makes room for the numbers before they are worked out, which building one does
`normalize`	not in the wheel	divides the numbers by their sum, which `Extractor::extract` does where the extractor asks for it

▶FeatureExtractorfeatures/base.py wheel 0 of 7

7 not in wheel

One extractor: its id, how many numbers it gives, and what it reads off a stream. music21 keeps the stream and the half-built feature on the object; here an extractor is a row of a table and reading is a function of the data.

music21	Wheel	In the crate
`setData`	not in the wheel	hands the extractor the stream to read, which `extract` takes as an argument
`getAttributeLabels`	not in the wheel	`attribute_labels`
`fillFeatureAttributes`	not in the wheel	copies the extractor's own id and name onto the feature it is filling in
`prepareFeature`	not in the wheel	makes the blank feature and fills its attributes in, which `blank` answers
`process`	not in the wheel	the reading itself, which is the row's own function and runs in `extract`
`extract`	not in the wheel	`extract`
`getBlankFeature`	not in the wheel	`blank`

▶StreamFormsfeatures/base.py wheel 0 of 14

14 not in wheel

The readings of a stream every extractor shares, each worked out once when it is first asked for. music21 keys them by name in a dictionary; here each is a member of the data, and the ones only one extractor reads are worked out where it reads them.

music21	Wheel	In the crate
`keys`	not in the wheel	the names music21 looks a form up by
`formPartitionByInstrument`	not in the wheel	`partition_by_instrument`
`formSetClassHistogram`	not in the wheel	how often each set class comes, which the extractors that read it work out where they read it
`formPitchClassSetHistogram`	not in the wheel	how often each pitch-class set comes, likewise
`formTypesHistogram`	not in the wheel	how often each written value comes, likewise
`formGetElementsByClassMeasure`	not in the wheel	the measures of the stream, which `Stream::measures` answers
`formChordify`	not in the wheel	`chordified_chords`
`formQuarterLengthHistogram`	not in the wheel	`quarter_length_histogram`
`formMidiPitchHistogram`	not in the wheel	`midi_pitch_histogram`
`formPitchClassHistogram`	not in the wheel	`pitch_class_histogram`
`formMidiIntervalHistogram`	not in the wheel	`midi_interval_histogram`
`formContourList`	not in the wheel	`contour_list`
`formSecondsMap`	not in the wheel	`seconds_map`
`formBeatHistogram`	not in the wheel	how often each beat strength comes, which the extractor reading it works out

▶DataInstancefeatures/base.py wheel 0 of 5

5 not in wheel

One subject prepared for extraction: the stream with its ties stripped, each part and each voice of it prepared on its own, and every reading an extractor may ask for.

music21	Wheel	In the crate
`setupPostStreamParse`	not in the wheel	the second half of reading the stream in, which building one does in one
`setClassLabel`	not in the wheel	the class a subject belongs to for the data set it is in; `DataSet::add_data` takes it beside the subject
`getClassValue`	not in the wheel	that class, likewise
`getId`	not in the wheel	the name a subject goes by, which `DataSet::add_data` takes beside it
`parseStream`	not in the wheel	`new`

▶DataSetfeatures/base.py wheel 0 of 12

12 not in wheel

Several subjects run through the same extractors, written out as a table.

music21	Wheel	In the crate
`getClassLabel`	not in the wheel	`class_label`
`addFeatureExtractors`	not in the wheel	`add_extractors`
`getAttributeLabels`	not in the wheel	`attribute_labels`
`getDiscreteLabels`	not in the wheel	`discrete_labels`
`getClassPositionLabels`	not in the wheel	where the class column sits, which the caller knows of the labels it asked for
`addMultipleData`	not in the wheel	adds several subjects at once, which is `add_data` in a loop
`addData`	not in the wheel	`add_data`
`process`	not in the wheel	`process`
`getFeaturesAsList`	not in the wheel	`features_as_list`
`getUniqueClassValues`	not in the wheel	`unique_class_values`
`getString`	not in the wheel	`to_text`
`write`	not in the wheel	writes the table to a file, which the library does not do: `to_text` is the text to write

▶braille/basic.py functionsbraille/basic.py wheel 0 of 27

27 not in wheel

One element of a score in braille: a note, a rest, a chord, a clef, a signature, a dynamic, a word.

music21	Wheel	In the crate
`barlineToBraille`	not in the wheel	`barline_to_braille`
`chordToBraille`	not in the wheel	`chord_to_braille`
`pitchToOctave`	not in the wheel	`pitch_to_octave`
`clefToBraille`	not in the wheel	`clef_to_braille`
`dynamicToBraille`	not in the wheel	`dynamic_to_braille`
`instrumentToBraille`	not in the wheel	`instrument_to_braille`
`keySigToBraille`	not in the wheel	`key_sig_to_braille`
`metronomeMarkToBraille`	not in the wheel	`metronome_mark_to_braille`
`yieldBrailleArticulations`	not in the wheel	`note_to_braille`
`noteToBraille`	not in the wheel	`note_to_braille`
`handlePitchWithAccidental`	not in the wheel	`note_to_braille`
`handleArticulations`	not in the wheel	`note_to_braille`
`handleExpressions`	not in the wheel	`note_to_braille`
`restToBraille`	not in the wheel	`rest_to_braille`
`tempoTextToBraille`	not in the wheel	`tempo_text_to_braille`
`textExpressionToBraille`	not in the wheel	`text_expression_to_braille`
`timeSigToBraille`	not in the wheel	`time_sig_to_braille`
`showOctaveWithNote`	not in the wheel	`show_octave_with_note`
`transcribeHeading`	not in the wheel	`transcribe_heading`
`transcribeNoteFingering`	not in the wheel	`transcribe_note_fingering`
`transcribeSignatures`	not in the wheel	`transcribe_signatures`
`brailleUnicodeToBrailleAscii`	not in the wheel	`braille_unicode_to_braille_ascii`
`brailleAsciiToBrailleUnicode`	not in the wheel	`braille_ascii_to_braille_unicode`
`brailleUnicodeToSymbols`	not in the wheel	`braille_unicode_to_symbols`
`yieldDots`	not in the wheel	`yield_dots`
`wordToBraille`	not in the wheel	`word_to_braille`
`numberToBraille`	not in the wheel	`number_to_braille`

▶braille/translate.py functionsbraille/translate.py wheel 0 of 8

8 not in wheel

A whole score in braille, part by part or on joined staves.

music21	Wheel	In the crate
`objectToBraille`	not in the wheel	`element_to_braille`
`streamToBraille`	not in the wheel	`stream_to_braille`
`scoreToBraille`	not in the wheel	`score_to_braille`
`metadataToString`	not in the wheel	`metadata_to_string`
`opusToBraille`	not in the wheel	every score of an opus one after another, which is `score_to_braille` of each
`measureToBraille`	not in the wheel	`measure_to_braille`
`partToBraille`	not in the wheel	`part_to_braille`
`keyboardPartsToBraille`	not in the wheel	`keyboard_parts_to_braille`

▶BrailleTextbraille/text.py wheel 0 of 11

11 not in wheel

The page the braille is written onto: its lines, and what may still fit on the one being written.

music21	Wheel	In the crate
`showHand`	not in the wheel	`set_show_hand`
`addHeading`	not in the wheel	`add_heading`
`addLongExpression`	not in the wheel	`add_long_expression`
`addToNewLine`	not in the wheel	`add_to_new_line`
`appendOrInsertCurrent`	not in the wheel	`append_or_insert_current`
`addInaccord`	not in the wheel	`add_inaccord`
`addMeasureNumber`	not in the wheel	`add_measure_number`
`optionalAddKeyboardSymbolsAndDots`	not in the wheel	`optional_add_keyboard_symbols_and_dots`
`addSignatures`	not in the wheel	`add_signatures`
`makeNewLine`	not in the wheel	`make_new_line`
`recenterHeadings`	not in the wheel	`recenter_headings`

▶BrailleTextLinebraille/text.py wheel 0 of 5

5 not in wheel

music21	Wheel	In the crate
`append`	not in the wheel	`append`
`insert`	not in the wheel	`insert`
`canAppend`	not in the wheel	`can_append`
`canInsert`	not in the wheel	`can_insert`
`lastHyphenToSpace`	not in the wheel	`last_hyphen_to_space`

▶BrailleKeyboardbraille/text.py wheel 0 of 2

2 not in wheel

music21	Wheel	In the crate
`makeNewLines`	not in the wheel	`make_new_lines`
`addNoteGroupings`	not in the wheel	`add_note_groupings`

▶braille/lookup.py functionsbraille/lookup.py wheel 0 of 3

3 not in wheel

The braille cells music21 writes each thing with, which are tables here rather than dictionaries built at import.

music21	Wheel	In the crate
`makeBrailleDictionary`	not in the wheel	builds music21's dictionary of cells at import; the tables here are written out
`dotsAdd`	not in the wheel	`dots_add`
`makePitchNameToNotes`	not in the wheel	`pitch_name_to_note`

▶braille/segment.py functionsbraille/segment.py wheel 0 of 10

10 not in wheel

A part cut into the segments braille is written in, each a run of elements that belong together.

music21	Wheel	In the crate
`setGroupingGlobals`	not in the wheel	music21's module-level defaults for a grouping, set the first time one is made; `SegmentOptions` is what a caller says instead
`findSegments`	not in the wheel	`find_segments`
`prepareSlurredNotes`	not in the wheel	`prepare_slurred_notes`
`getRawSegments`	not in the wheel	`get_raw_segments`
`extractBrailleElements`	not in the wheel	`extract_braille_elements`
`prepareBeamedNotes`	not in the wheel	`prepare_beamed_notes`
`setAffinityCode`	not in the wheel	which kind of segment an element belongs in, which `extract_braille_elements` says as it reads
`areGroupingsIdentical`	not in the wheel	whether two groupings are the same, which the segment asks of its own
`splitNoteGrouping`	not in the wheel	`split_note_grouping`
`splitMeasure`	not in the wheel	cuts a measure in two so that the braille fits, which `split_note_grouping` does of the grouping

▶BrailleSegmentbraille/segment.py wheel 0 of 17

17 not in wheel

One segment written out. music21 takes the segment apart member by member -- the heading, the measure number, each grouping -- where transcribe does the whole of it in order, so those steps are not members here.

music21	Wheel	In the crate
`brailleText`	not in the wheel	`transcribe`
`transcribe`	not in the wheel	`transcribe`
`addDummyRests`	not in the wheel	a step of the transcription: the rests that stand before a measure number
`extractMeasureNumber`	not in the wheel	a step of the transcription
`extractHeading`	not in the wheel	a step of the transcription: the key, the meter and the tempo over the first measure
`extractInaccordGrouping`	not in the wheel	a step of the transcription: the voices written one after another
`extractLongExpressionGrouping`	not in the wheel	a step of the transcription
`showLeadingOctaveFromNoteGrouping`	not in the wheel	a step of the transcription: whether the first note of a grouping shows its octave
`needsSplitToFit`	not in the wheel	a step of the transcription: whether a grouping must be split to fit the line
`splitNoteGroupingAndTranscribe`	not in the wheel	a step of the transcription, which `split_note_grouping` does the splitting half of
`extractNoteGrouping`	not in the wheel	a step of the transcription
`addRepeatSymbols`	not in the wheel	a step of the transcription: the sign for a measure repeated
`extractSignatureGrouping`	not in the wheel	a step of the transcription
`extractTempoTextGrouping`	not in the wheel	a step of the transcription
`consolidate`	not in the wheel	a step of the transcription: the groupings of one kind joined into one
`addGroupingAttributes`	not in the wheel	`add_grouping_attributes`
`fixArticulations`	not in the wheel	`fix_articulations`

▶BrailleGrandSegmentbraille/segment.py wheel 0 of 5

5 not in wheel

A keyboard part written on joined staves, the two hands' groupings paired.

music21	Wheel	In the crate
`brailleText`	not in the wheel	`transcribe`
`yieldCombinedGroupingKeys`	not in the wheel	`combined_keys`
`transcribe`	not in the wheel	`transcribe`
`extractHeading`	not in the wheel	a step of the transcription
`extractNoteGrouping`	not in the wheel	a step of the transcription

▶StreamAligneralpha/analysis/aligner.py wheel 0 of 14

14 not in wheel

Two readings of the same music lined up against each other -- a score read by an optical reader against the same music played in -- by the edit distance between their hashes.

music21	Wheel	In the crate
`getDefaultHasher`	not in the wheel	`new`
`align`	not in the wheel	`align`
`makeHashedStreams`	not in the wheel	`align`
`setupDistanceMatrix`	not in the wheel	`align_hashed`
`populateDistanceMatrix`	not in the wheel	`align_hashed`
`getPossibleMovesFromLocation`	not in the wheel	`align_hashed`
`getOpFromLocation`	not in the wheel	`align_hashed`
`insertCost`	not in the wheel	what an insertion costs, which is one everywhere
`deleteCost`	not in the wheel	what a deletion costs, likewise
`substitutionCost`	not in the wheel	what a substitution costs, which the hashes' difference says
`calculateNumSimilarities`	not in the wheel	`changes_count`
`tupleEqualityWithoutReference`	not in the wheel	whether two hashes are equal but for which note they came from, which comparing them answers
`calculateChangesList`	not in the wheel	`align_hashed`
`showChanges`	not in the wheel	prints the changes, and colours the notes of the score to show them

▶Hasheralpha/analysis/hasher.py wheel 0 of 7

7 not in wheel

A stream's notes as hashes, each as much or as little of the note as the caller asked to compare.

music21	Wheel	In the crate
`setupValidTypesAndStateVars`	not in the wheel	reads the switches into the state music21 hashes by, which are the fields of a `Hasher` here
`setupTupleList`	not in the wheel	`tuple_list`
`hashMeasures`	not in the wheel	the measures hashed one at a time, which is `hash_stream` of each
`hashStream`	not in the wheel	`hash_stream`
`addHashToFinalHash`	not in the wheel	appends one hash to the list being built
`addNoteHashWithReferenceToFinalHash`	not in the wheel	appends a note's hash with the note it came from, likewise
`addNoteHashToFinalHash`	not in the wheel	appends a note's hash, likewise

▶alpha/analysis/fixer.py functionsalpha/analysis/fixer.py wheel 0 of 1

1 not in wheel

Mending one reading of a score against another: the notes within a length, and the fixes themselves.

music21	Wheel	In the crate
`getNotesWithinDuration`	not in the wheel	`notes_within_duration`

▶OrnamentFixeralpha/analysis/fixer.py wheel 0 of 3

3 not in wheel

Where the played reading trills or turns and the read one does not, the ornament is written onto the read one.

music21	Wheel	In the crate
`findOrnament`	not in the wheel	`find_ornament`
`addOrnament`	not in the wheel	writes the ornament onto the read note, which `fix` does where it finds one
`fix`	not in the wheel	`fix`

▶EnharmonicFixeralpha/analysis/fixer.py wheel 0 of 8

8 not in wheel

Where the two readings spell the same sound differently, the played spelling wins.

music21	Wheel	In the crate
`fix`	not in the wheel	`fix_enharmonics`
`isEnharmonic`	not in the wheel	whether two notes sound alike, which is `Pitch::is_enharmonic`
`hasAcc`	not in the wheel	whether a note carries an accidental, which is `Pitch::accidental_is_written`
`hasNatAcc`	not in the wheel	whether it carries a natural, likewise
`hasSharpFlatAcc`	not in the wheel	whether it carries a sharp or a flat, likewise
`stepEq`	not in the wheel	whether two notes stand on the same step
`stepNotEq`	not in the wheel	whether they do not
`intervalTooBig`	not in the wheel	whether the two are too far apart to be a misspelling, which the fix asks as it goes

▶alpha/analysis/ornamentRecognizer.py functionsalpha/analysis/ornamentRecognizer.py wheel 0 of 1

1 not in wheel

How long the notes of an ornament last, written out.

music21	Wheel	In the crate
`calculateTrillNoteDuration`	not in the wheel	`ornament_note_quarter_length`

▶TrillRecognizeralpha/analysis/ornamentRecognizer.py wheel 0 of 1

1 not in wheel

Whether a run of notes is a trill written out, and which trill it is.

music21	Wheel	In the crate
`recognize`	not in the wheel	`recognize`

▶TurnRecognizeralpha/analysis/ornamentRecognizer.py wheel 0 of 2

2 not in wheel

music21	Wheel	In the crate
`isAcceptableInterval`	not in the wheel	`is_acceptable_interval`
`recognize`	not in the wheel	`recognize`

▶OrnamentRecognizeralpha/analysis/ornamentRecognizer.py wheel 0 of 2

2 not in wheel

music21	Wheel	In the crate
`calculateOrnamentNoteQl`	not in the wheel	`ornament_note_quarter_length`
`calculateOrnamentTotalQl`	not in the wheel	`ornament_total_quarter_length`

▶alpha/analysis/search.py functionsalpha/analysis/search.py wheel 0 of 1

1 not in wheel

Runs of notes that walk a scale, found in a part.

music21	Wheel	In the crate
`findConsecutiveScale`	not in the wheel	`find_consecutive_scale`

▶ScoreCorrectoromr/correctors.py wheel 0 of 14

14 not in wheel

Mending a score read by an optical reader against itself: a measure that reads oddly is compared with the same measure of the other parts and with the rest of its own part, and the likeliest reading wins.

music21	Wheel	In the crate
`run`	not in the wheel	`run`
`runPriorModel`	not in the wheel	music21's measure of how much the correction helped, which `PriorsIntegrationScore` carries
`getAllHashes`	not in the wheel	`all_hashes`
`getSinglePart`	not in the wheel	`single_part_mut`
`runHorizontalCorrectionModel`	not in the wheel	`run_horizontal_correction_model`
`getMeasureSlice`	not in the wheel	the same measure across every part, which `vertical_probability_dist` reads as it goes
`getAllIncorrectMeasures`	not in the wheel	`all_incorrect_measures`
`verticalProbabilityDist`	not in the wheel	`vertical_probability_dist`
`getVerticalProbabilityDistributionSinglePart`	not in the wheel	a step of the vertical correction, which `vertical_probability_dist` does for every part at once
`getVerticalProbabilityDistributionSinglePartSingleMeasure`	not in the wheel	a step of the same
`runVerticalSearch`	not in the wheel	`run_vertical_search`
`substituteOneMeasureContentsForAnother`	not in the wheel	`substitute_measure`
`runVerticalCorrectionModel`	not in the wheel	`run_vertical_correction_model`
`generateCorrectedScore`	not in the wheel	`generate_corrected_score`

▶SinglePartomr/correctors.py wheel 0 of 7

7 not in wheel

music21	Wheel	In the crate
`getMeasures`	not in the wheel	the measures of the part, which the `Stream` it was read from holds
`getIncorrectMeasureIndices`	not in the wheel	`find_incorrect_measures`
`getSequenceHashesFromMeasureStream`	not in the wheel	`hashed_notes`
`horizontalProbabilityDist`	not in the wheel	`horizontal_probability_dist`
`runHorizontalSearch`	not in the wheel	`run_horizontal_search`
`runHorizontalCorrectionModel`	not in the wheel	`run_horizontal_correction_model`
`getProbabilityDistribution`	not in the wheel	`probability_distribution`

▶MeasureHashomr/correctors.py wheel 0 of 15

15 not in wheel

One measure as a string, a character a note, so that two measures may be compared as text.

music21	Wheel	In the crate
`getHashString`	not in the wheel	`measure_hash`
`hashNote`	not in the wheel	`measure_hash`
`hashGrace`	not in the wheel	`measure_hash`
`hashRest`	not in the wheel	`measure_hash`
`hashQuarterLength`	not in the wheel	`measure_hash`
`setSequenceMatcher`	not in the wheel	keeps Python's own `SequenceMatcher` on the object; `search::difflib` is the comparison, ported
`getMeasureDifference`	not in the wheel	`measure_difference`
`getOpCodes`	not in the wheel	`opcodes`
`getProbabilityBasedOnChanges`	not in the wheel	`probability_based_on_changes`
`differenceProbabilityForOneOpCode`	not in the wheel	the odds of one edit, which `probability_based_on_changes` sums
`getProbabilityOnEquality`	not in the wheel	the odds of two measures reading alike, likewise
`getProbabilityOnOmission`	not in the wheel	the odds of a note left out, likewise
`getProbabilityOnAddition`	not in the wheel	the odds of a note put in, likewise
`getProbabilityOnSubstitute`	not in the wheel	`probability_on_substitute`
`getProbabilityFromOneCharSub`	not in the wheel	`probability_from_one_char_sub`

▶MeasureSliceomr/correctors.py wheel 0 of 2

2 not in wheel

The same measure across every part, which is what a doubtful measure is compared against.

music21	Wheel	In the crate
`getSliceHashes`	not in the wheel	the hashes of the measure across every part, which `ScoreCorrector::vertical_probability_dist` reads as it goes
`runSliceSearch`	not in the wheel	the search across the parts, which `run_vertical_search` does

▶omr/evaluators.py functionsomr/evaluators.py wheel 0 of 2

2 not in wheel

How well the mending did: a score with mistakes put in on purpose, mended, and compared with the one it was made from.

music21	Wheel	In the crate
`evaluateCorrectingModel`	not in the wheel	`evaluate_correcting_model`
`autoCorrelationBestMeasure`	not in the wheel	`auto_correlation_best_measure`

▶OmrGroundTruthPairomr/evaluators.py wheel 0 of 10

10 not in wheel

music21	Wheel	In the crate
`debug`	not in the wheel	music21's switch for printing what it is doing
`parseAll`	not in the wheel	reads both scores from their files
`hashAll`	not in the wheel	hashes both scores, which building the pair does
`getOmrScore`	not in the wheel	`omr`
`getGroundScore`	not in the wheel	`ground`
`substCost`	not in the wheel	what a substitution costs, which the hashes' difference says
`insertCost`	not in the wheel	what an insertion costs, which is one everywhere
`deleteCost`	not in the wheel	what a deletion costs, likewise
`minEditDist`	not in the wheel	`min_edit_distance`
`getDifferences`	not in the wheel	`differences`

▶audioSearch/__init__.py functionsaudioSearch/__init__.py wheel 0 of 16

16 not in wheel

Hearing a monophonic line: the pitch of each stretch of sound, the lengths they make, and the notes that come of it.

music21	Wheel	In the crate
`histogram`	not in the wheel	`histogram`
`autocorrelationFunction`	not in the wheel	`autocorrelation_frequency`
`prepareThresholds`	not in the wheel	`prepare_thresholds`
`interpolation`	not in the wheel	`interpolation`
`normalizeInputFrequency`	not in the wheel	`normalize_input_frequency`
`pitchFrequenciesToObjects`	not in the wheel	`pitch_frequencies_to_objects`
`getFrequenciesFromMicrophone`	not in the wheel	listens to a microphone, which the library does not do
`getFrequenciesFromAudioFile`	not in the wheel	`frequencies_from_wav`
`getFrequenciesFromPartialAudioFile`	not in the wheel	reads part of a file as it is being recorded
`detectPitchFrequencies`	not in the wheel	`detect_pitch_frequencies`
`smoothFrequencies`	not in the wheel	`smooth_frequencies`
`joinConsecutiveIdenticalPitches`	not in the wheel	`join_consecutive_identical_pitches`
`quantizeDuration`	not in the wheel	`quantize_duration`
`quarterLengthEstimation`	not in the wheel	`quarter_length_estimation`
`notesAndDurationsToStream`	not in the wheel	`notes_and_durations_to_stream`
`decisionProcess`	not in the wheel	`decision_process`

▶search/serial.py classessearch/serial.py wheel 0 of 8

8 not in wheel

The classes music21's serial search is written as. The crate has one matcher taking Matching, since the five subclasses differ only in how a run is normalized before it is compared.

music21	Wheel	In the crate
`ContiguousSegmentOfNotes`	not in the wheel	`ContiguousSegment`
`ContiguousSegmentSearcher`	not in the wheel	`ContiguousSegmentSearcher`
`SegmentMatcher`	not in the wheel	`SegmentMatcher`
`TransposedSegmentMatcher`	not in the wheel	one of `Matching`'s six kinds rather than a class of its own: `Matching::Transposed`, which compares the intervals a run makes
`TransformedSegmentMatcher`	not in the wheel	`Matching::Transformed`, which compares the rows a transposition, inversion, retrograde or retrograde inversion takes one to the other
`MultisetSegmentMatcher`	not in the wheel	`Matching::Multiset`, which compares the pitch classes in any order
`TransposedMultisetMatcher`	not in the wheel	`Matching::TransposedMultiset`
`TransposedInvertedMultisetMatcher`	not in the wheel	`Matching::TransposedInvertedMultiset`

▶ContiguousSegmentOfNotessearch/serial.py wheel 0 of 7

7 not in wheel

A run of a stream's notes and chords a search found: where it starts, the pitch classes it was read as, and the segment it was matched to.

music21	Wheel	In the crate
`startMeasureNumber`	not in the wheel	`start_measure`
`startOffset`	not in the wheel	`start_offset`
`getActiveMatchedRows`	not in the wheel	two `ToneRow`s built from the `active` and `matched` fields, which a caller builds itself; what music21 uses them for is the transformations between them, which `zero_centered_transformations_from_matched` and its original-centred twin answer
`zeroCenteredTransformationsFromMatched`	not in the wheel	`zero_centered_transformations_from_matched`
`originalCenteredTransformationsFromMatched`	not in the wheel	`original_centered_transformations_from_matched`
`readPitchClassesFromBottom`	not in the wheel	`pitch_classes_from_bottom`
`getDistinctPitchClasses`	not in the wheel	`distinct_pitch_classes`

▶ContiguousSegmentSearchersearch/serial.py wheel 0 of 11

11 not in wheel

Every run of a given length in a stream, read in one of music21's ways of reading repetitions, chords in or out.

music21	Wheel	In the crate
`getSearchBoundMethod`	not in the wheel	music21 chooses a method by name for each way of reading repetitions; the crate's one walk takes `Repetitions` as an argument
`byLength`	not in the wheel	`by_length`
`addActiveChords`	not in the wheel	a step inside that walk: the crate reads a chord's pitch classes where it meets one
`searchIncludeAllExclude`	not in the wheel	one of the twelve methods that choice picks between, which the one walk answers for
`searchIncludeAllInclude`	not in the wheel	as `searchIncludeAllExclude`
`searchSkipConsecutiveExclude`	not in the wheel	as `searchIncludeAllExclude`
`searchSkipConsecutiveInclude`	not in the wheel	as `searchIncludeAllExclude`
`searchIgnoreAllExclude`	not in the wheel	as `searchIncludeAllExclude`
`searchIgnoreAllInclude`	not in the wheel	as `searchIncludeAllExclude`
`searchRowsOnlyExclude`	not in the wheel	as `searchIncludeAllExclude`
`searchRowsOnlyInclude`	not in the wheel	as `searchIncludeAllExclude`

▶SegmentMatchersearch/serial.py wheel 0 of 9

9 not in wheel

The runs of a stream that are segments searched for, and the stream with each marked by a lyric. Matching says how a run is told the same as a segment, which is music21's five subclasses.

music21	Wheel	In the crate
`reps`	not in the wheel	`repetitions`
`includeChords`	not in the wheel	`include_chords`
`getContiguousSegmentsByLength`	not in the wheel	the searcher's `by_length`, which `find` asks for itself
`find`	not in the wheel	`find`
`findOneIgnoreAll`	not in the wheel	one of the two branches of music21's `find`, which it picks by how repetitions are read; the crate's `find` is the one walk
`findOneOtherReps`	not in the wheel	the other branch of `find`
`checkSearchedAlready`	not in the wheel	whether a segment the same as one already searched for is to be passed over, which `find` keeps as it goes
`normalize`	not in the wheel	how a run is read before it is compared, which is what `Matching` says: the pitch classes, the intervals they make, or the row they are
`equalSubset`	not in the wheel	the comparison `Matching` decides, which the crate does inside `find`

▶search/serial.py functionssearch/serial.py wheel 0 of 6

6 not in wheel

Module-level: the six functions marking a stream's runs with the name of the segment each matched. Each is SegmentMatcher::label given the Matching that function's name says.

music21	Wheel	In the crate
`labelSegments`	not in the wheel	`label`
`labelTransposedSegments`	not in the wheel	`label`
`labelTransformedSegments`	not in the wheel	`label`
`labelMultisets`	not in the wheel	`label`
`labelTransposedMultisets`	not in the wheel	`label`
`labelTransposedAndInvertedMultisets`	not in the wheel	`label`

Every public member of the music21 classes the wheel stands in for, asked of the wheel under music21's own names. A member it lacks is one a program loses when it calls install_into_music21(), where it raises rather than quietly answering out of music21's implementation. The last column says what the crate makes of the same member.

Not in the wheel

662 members

music21 member	Crate	music21-rs
raises under `install_into_music21()` — 662
`ConcreteScale.writescale/__init__.py`	missing	writes a file, and this library does no file IO: a caller saves the Scala text `scala_data` and `file_string` give, or a score `musicxml::to_musicxml` writes
`ConcreteScale.showscale/__init__.py`	missing	opens the scale in another program, which is the caller's to do
`AbstractDiatonicScalescale/__init__.py`	missing	the IntervalNetwork layer
`AbstractOctatonicScalescale/__init__.py`	missing	the IntervalNetwork layer
`AbstractHarmonicMinorScalescale/__init__.py`	missing	the IntervalNetwork layer
`AbstractMelodicMinorScalescale/__init__.py`	missing	the IntervalNetwork layer
`AbstractCyclicalScalescale/__init__.py`	missing	the IntervalNetwork layer
`AbstractOctaveRepeatingScalescale/__init__.py`	missing	the IntervalNetwork layer
`PercussionMapper.midiPitchToInstrumentmidi/percussion.py`	ported	`for_percussion_key`
`PercussionMapper.midiInstrumentToPitchmidi/percussion.py`	ported	`percussion_pitch`
`TabChordBase.combinedChordromanText/tsvConverter.py`	ported	`chord`
`TabChordBase.tabToM21romanText/tsvConverter.py`	ported	`element`
`TabChordBase.populateFromRowromanText/tsvConverter.py`	ported	`from_row`
`TabChordV2.beatromanText/tsvConverter.py`	ported	`beat`
`TabChordV2.measureromanText/tsvConverter.py`	ported	`measure`
`TabChordV2.local_keyromanText/tsvConverter.py`	ported	`local_key`
`TabChordV2.global_keyromanText/tsvConverter.py`	ported	`global_key`
`TsvHandler.tsvToChordsromanText/tsvConverter.py`	ported	`tsv_to_chords`
`TsvHandler.toM21StreamromanText/tsvConverter.py`	ported	`from_tsv`
`TsvHandler.prepStreamromanText/tsvConverter.py`	missing	a step inside the reader: `from_tsv` prepares the measures from the table's own numbers and meters itself and hands back the whole score
`M21toTSV.m21ToTsvromanText/tsvConverter.py`	ported	`to_tsv`
`M21toTSV.writeromanText/tsvConverter.py`	missing	writes a file, which the library does not do: `to_tsv` hands back the text
`getFormromanText/tsvConverter.py`	ported	`form_of`
`handleAddedTonesromanText/tsvConverter.py`	ported	`handle_added_tones`
`localKeyAsRnromanText/tsvConverter.py`	ported	`local_key_as_roman`
`isMinorromanText/tsvConverter.py`	ported	`is_minor`
`characterSwapsromanText/tsvConverter.py`	ported	`character_swaps`
`getLocalKeyromanText/tsvConverter.py`	ported	`local_key`
`getSecondaryKeyromanText/tsvConverter.py`	ported	`secondary_key`
`CTSong.parseromanText/clercqTemperley.py`	ported	`parse`
`CTSong.titleromanText/clercqTemperley.py`	ported	`title`
`CTSong.commentsromanText/clercqTemperley.py`	ported	`comments`
`CTSong.rulesromanText/clercqTemperley.py`	ported	`rules`
`CTSong.homeTimeSigromanText/clercqTemperley.py`	ported	`home_time_signature`
`CTSong.homeKeyromanText/clercqTemperley.py`	ported	`home_key`
`CTSong.toPartromanText/clercqTemperley.py`	ported	`to_part`
`CTSong.toScoreromanText/clercqTemperley.py`	missing	music21's own deprecated name for `toPart`, which it will take out
`CTRule.parentromanText/clercqTemperley.py`	missing	music21 keeps a weak reference from a rule back to the song holding it, and reads the rule's key, meter and other rules through it; a song here expands its own rules (`CtSong::to_part`), so nothing needs the way back
`CTRule.expandromanText/clercqTemperley.py`	ported	`expand`
`CTRule.expandExpansionContentromanText/clercqTemperley.py`	missing	a step inside the expansion, which the crate drives from the song rather than from the rule keeping the state
`CTRule.expandSimpleContentromanText/clercqTemperley.py`	missing	a step inside the expansion, as `expandExpansionContent`
`CTRule.isSameromanText/clercqTemperley.py`	ported	`is_same`
`CTRule.addOptionalTieAndLyricsromanText/clercqTemperley.py`	missing	a step inside the expansion, which ties the chord before as it writes the one after
`CTRule.insertKsTsromanText/clercqTemperley.py`	missing	a step inside the expansion: the crate writes the key and the meter into a measure as it builds it
`CTRule.fixupChordAtomromanText/clercqTemperley.py`	ported	`fixup_chord_atom`
`CTRule.musicTextromanText/clercqTemperley.py`	ported	`music_text`
`CTRule.commentromanText/clercqTemperley.py`	ported	`comment`
`CTRule.LHSromanText/clercqTemperley.py`	ported	`left_hand_side`
`CTRule.sectionNameromanText/clercqTemperley.py`	ported	`section_name`
`addNewChordSymbolharmony.py`	missing	mutates music21's global chord-type table; the crate's is a constant, and the wheel's chord symbols read music21's live table wherever music21 is there to edit it
`changeAbbreviationForharmony.py`	missing	mutates music21's global chord-type table; the crate's is a constant, and the wheel's chord symbols read music21's live table wherever music21 is there to edit it
`removeChordSymbolsharmony.py`	missing	mutates music21's global chord-type table; the crate's is a constant, and the wheel's chord symbols read music21's live table wherever music21 is there to edit it
`getPathsscale/scala/__init__.py`	missing	where the archive's files sit on disk; the archive here is one bundled table and has no paths
`showResolutionsfiguredBass/resolution.py`	missing	puts the voicings in a score and opens it in another program; `Realization::generate_realization_from_possibility_progression` writes voicings as a score, and opening a program is the caller's to do
`printRulesfiguredBass/segment.py`	missing	prints music21's rule tables, which hold its Python functions
`KeyWeightKeyAnalysis.solutionLegendanalysis/discrete.py`	missing	the colour legend of a keyscape graph; presentation
`KeyWeightKeyAnalysis.solutionUnitStringanalysis/discrete.py`	missing	the unit a graph's legend is labelled with; presentation
`KeyWeightKeyAnalysis.solutionToColoranalysis/discrete.py`	missing	the colour a key is drawn in; presentation
`KeyWeightKeyAnalysis.processanalysis/discrete.py`	ported	`estimate_key_from_distribution`
`Ambitus.solutionLegendanalysis/discrete.py`	missing	the colour legend of a graph; presentation
`Ambitus.solutionUnitStringanalysis/discrete.py`	missing	the unit a graph's legend is labelled with; presentation
`Ambitus.solutionToColoranalysis/discrete.py`	missing	the colour a span is drawn in; presentation
`Ambitus.processanalysis/discrete.py`	ported	`pitch_span`
`convertHarmToRomanhumdrum/harmParser.py`	ported	`convert_harm_to_roman`
`HarmParser.parsehumdrum/harmParser.py`	ported	`parse`
`Stream.writestream/base.py`	missing	writing a file, which the format modules do
`Stream.showstream/base.py`	missing	rendering, which the crate leaves to its caller
`Stream.iterstream/base.py`	ported	`iter`
`Stream.firststream/base.py`	missing	as `elementOffset`: `events` answers in order
`Stream.laststream/base.py`	missing	as `elementOffset`: `events` answers in order
`Stream.clearstream/base.py`	missing	empties a stream in place; `clone_empty` answers an empty one of the same kind
`Stream.mergeAttributesstream/base.py`	missing	what `clone_empty` carries over
`Stream.indexstream/base.py`	missing	as `elementOffset`
`Stream.storeAtEndstream/base.py`	missing	elements music21 keeps at the right barline rather than at an offset; a measure's barlines are its own here
`Stream.isAtEndstream/base.py`	missing	needs the sites a crate stream does not keep
`Stream.setDerivationMethodstream/base.py`	missing	derivations, which a crate stream does not keep
`Stream.replacestream/base.py`	missing	swaps one object for another; `events_mut` reaches each in place
`Stream.splitAtDurationsstream/base.py`	ported	`split_at_durations`
`Stream.recurseReprstream/base.py`	missing	music21's own text dump of a stream
`Stream.plotstream/base.py`	missing	plotting, which the crate leaves to its caller
`Stream.addGroupForElementsstream/base.py`	missing	the group names music21 picks elements out of a stream by; nothing a crate stream holds carries them
`Stream.getElementsByGroupstream/base.py`	missing	as `addGroupForElements`
`Stream.getElementByIdstream/base.py`	missing	an id on every element, which only a stream and a note carry here
`Stream.transferOffsetToElementsstream/base.py`	missing	moves a stream's own offset onto what it holds, which needs the sites a crate stream does not keep
`Stream.haveAccidentalsBeenMadestream/base.py`	missing	a flag music21 keeps on the stream; nothing here remembers having been asked
`Stream.sortstream/base.py`	missing	a crate stream is in offset order as it is built
`Stream.containerInHierarchystream/base.py`	missing	needs the sites a crate stream does not keep
`Stream.makeImmutablestream/base.py`	missing	music21's mutability machinery, which a value has no need of
`Stream.makeMutablestream/base.py`	missing	as `makeImmutable`
`Stream.durationstream/base.py`	missing	a crate stream has no `Duration` of its own; `highest_time` answers when the last thing in it ends
`Stream.beatstream/base.py`	missing	where one element sits in its bar; `placed` answers it for every element at once, and `beat_and_measure_from_offset` for a point
`Stream.beatStrstream/base.py`	missing	as `beat`
`Stream.beatDurationstream/base.py`	ported	`beat_duration`
`Stream.beatStrengthstream/base.py`	missing	as `beat`
`Stream.attachMelodicIntervalsstream/base.py`	missing	attaches an interval to each note; `melodic_intervals` answers them instead, a crate note carrying nothing of its line
`Stream.activateVariantsstream/base.py`	ported	`activate_variants`
`Stream.showVariantAsOssialikePartstream/base.py`	ported	`show_variant_as_ossialike_part`
`Measure.mergeAttributesstream/base.py`	missing	what `clone_empty` carries over
`Part.mergeAttributesstream/base.py`	missing	what `clone_empty` carries over
`Opus.writestream/base.py`	missing	writing a file, which the format modules do
`Opus.showstream/base.py`	missing	rendering, which the crate leaves to its caller
`PercussionChordpercussion.py`	ported	`PercussionChord`
`PercussionChord.notespercussion.py`	ported	`members`
`PercussionChord.pitchespercussion.py`	ported	`pitches`
`FretNotetablature.py`	ported	`FretNote`
`FretBoardtablature.py`	ported	`FretBoard`
`FirstFrettablature.py`	ported	`FirstFret`
`ChordWithFretBoardtablature.py`	ported	`ChordWithFretBoard`
`GuitarFretBoardtablature.py`	ported	`guitar`
`UkeleleFretBoardtablature.py`	ported	`ukulele`
`BassGuitarFretBoardtablature.py`	ported	`bass_guitar`
`MandolinFretBoardtablature.py`	ported	`mandolin`
`FretBoard.fretNotesLowestFirsttablature.py`	ported	`fret_notes_lowest_first`
`FretBoard.getFretNoteByStringtablature.py`	ported	`fret_note_by_string`
`FretBoard.getPitchestablature.py`	ported	`pitches`
`ChordWithFretBoard.getFretNotesFromFiguretablature.py`	missing	music21's own is a stub that answers nothing, its docstring a `TODO`: the fret notes a figure stands for are not worked out there either
`assembleLyricstext.py`	ported	`assemble_lyrics`
`assembleAllLyricstext.py`	ported	`assemble_all_lyrics`
`prependArticletext.py`	ported	`prepend_article`
`postpendArticletext.py`	ported	`postpend_article`
`TextBox.contenttext.py`	ported	`content`
`TextBox.pagetext.py`	ported	`page`
`LanguageDetector.readExcerptstext.py`	missing	reads the excerpt files off the disk; the crate's excerpts are built in and the library does no file IO
`LanguageDetector.mostLikelyLanguagetext.py`	ported	`most_likely_language`
`LanguageDetector.mostLikelyLanguageNumerictext.py`	ported	`most_likely_language_numeric`
`Trigram.lengthtext.py`	ported	`length`
`Trigram.parseExcerpttext.py`	ported	`from_text`
`Trigram.measuretext.py`	missing	the step that counts the letter triples, which building one does
`Trigram.similaritytext.py`	ported	`similarity`
`Trigram.makeWordstext.py`	ported	`from_words`
`Trigram.likelytext.py`	missing	which language a trigram is nearest, which `most_likely_language` answers
`LayoutBaselayout.py`	missing	the class music21 hangs the four layouts off; `layout::Layout` is the one of them a stream holds
`ScoreLayoutlayout.py`	ported	`ScoreLayout`
`PageLayoutlayout.py`	ported	`PageLayout`
`SystemLayoutlayout.py`	ported	`SystemLayout`
`StaffLayoutlayout.py`	ported	`StaffLayout`
`StaffGrouplayout.py`	ported	`StaffGroup`
`LayoutScorelayout.py`	missing	a score regrouped into pages, systems and staves for a renderer, with the three streams below it; the crate keeps the layout a file states and renders nothing
`Pagelayout.py`	missing	a page of such a score
`Systemlayout.py`	missing	a system of such a score
`Stafflayout.py`	missing	a staff of such a score
`divideByPageslayout.py`	missing	builds a `LayoutScore`, which the crate has none of
`getPageRegionMeasureNumberslayout.py`	missing	the measures on a page of a `LayoutScore`
`getSystemRegionMeasureNumberslayout.py`	missing	the measures in a system of a `LayoutScore`
`getRegionMeasureNumberslayout.py`	missing	the measures in a region of a `LayoutScore`
`ScoreLayout.tenthsToMillimeterslayout.py`	ported	`tenths_to_millimeters`
`StaffGroup.barTogetherlayout.py`	ported	`bar_together`
`StaffGroup.symbollayout.py`	ported	`symbol`
`Enclosurestyle.py`	missing	the shape drawn round a text, kept as the name music21 gives it where something has one (`expressions::RehearsalMark::enclosure`) rather than as a type of its own
`TextStylestyle.py`	ported	`TextStyle`
`TextStylePlacementstyle.py`	missing	a text style that also says which side of the staff it is on, which is `display::Drawn` here
`BezierStylestyle.py`	missing	the curve of a slur
`LineStylestyle.py`	missing	the dashes of a line
`StreamStylestyle.py`	missing	how a whole stream is drawn
`BeamStylestyle.py`	missing	how a beam is drawn
`StyleMixinstyle.py`	missing	what music21 mixes into every class it draws; nothing here has a style of its own to mix in
`TextStyle.alignVerticalstyle.py`	ported	`align_vertical`
`TextStyle.alignHorizontalstyle.py`	ported	`align_horizontal`
`TextStyle.justifystyle.py`	ported	`justify`
`TextStyle.fontStylestyle.py`	ported	`font_style`
`TextStyle.fontWeightstyle.py`	ported	`font_weight`
`TextStyle.fontSizestyle.py`	ported	`font_size`
`TextStyle.letterSpacingstyle.py`	missing	the space between a text's letters: nothing the crate reads states one, and the writer is held to music21's output byte for byte on every corpus score, so there is nothing to carry across
`TextStyle.fontFamilystyle.py`	ported	`font_family`
`PendingAssignmentRefspanner.py`	missing	music21's note to itself that a spanner is waiting for its first element, which the readers keep as a queue
`SpannerAnchorspanner.py`	missing	an element standing in a stream for a spanner to hang off where there is no note to; a spanner here names positions and needs none
`Slurspanner.py`	ported	`Slur`
`MultiMeasureRestspanner.py`	missing	several measures of rest drawn as one, which is a notation this crate does not write
`RepeatBracketspanner.py`	ported	`Ending`
`Ottavaspanner.py`	ported	`Ottava`
`Linespanner.py`	ported	`Line`
`Glissandospanner.py`	ported	`Glissando`
`Spanner.purgeOrphansspanner.py`	missing	drops the elements no stream holds any more, which only a spanner keeping objects can have
`Spanner.purgeLocationsspanner.py`	missing	drops the sites it remembers, and it remembers none
`Spanner.getSpannedElementsByClassspanner.py`	missing	the elements of a class among them, which the stream holding them answers
`Spanner.getSpannedElementIdsspanner.py`	missing	Python object ids
`Spanner.insertFirstSpannedElementspanner.py`	missing	puts an element first by object
`Spanner.fillspanner.py`	missing	fills in every element between the first and the last, which asks the stream what stands between them
`Spanner.isFirstspanner.py`	ported	`is_first`
`Spanner.isLastspanner.py`	ported	`is_last`
`Ottava.typespanner.py`	ported	`name`
`Ottava.shiftMagnitudespanner.py`	ported	`magnitude`
`Ottava.shiftDirectionspanner.py`	ported	`up`
`Ottava.intervalspanner.py`	ported	`interval`
`Ottava.performTranspositionspanner.py`	ported	`to_sounding_pitch`
`Ottava.undoTranspositionspanner.py`	ported	`to_written_pitch`
`Line.endTickspanner.py`	ported	`end`
`Line.startTickspanner.py`	ported	`start`
`Line.tickspanner.py`	missing	sets both ends at once; `LineEnds` carries each
`Line.lineTypespanner.py`	ported	`line_type`
`Line.endHeightspanner.py`	ported	`end_height`
`Line.startHeightspanner.py`	ported	`start_height`
`Glissando.lineTypespanner.py`	ported	`line_type`
`Glissando.slideTypespanner.py`	ported	`slide_type`
`RepeatMarkrepeat.py`	missing	what music21 mixes into everything that repeats; a barline here says it repeats and an expression says where to go back to
`RepeatExpressionrepeat.py`	ported	`RepeatExpression`
`RepeatExpressionMarkerrepeat.py`	ported	`is_marker`
`Codarepeat.py`	ported	`Coda`
`Segnorepeat.py`	ported	`Segno`
`Finerepeat.py`	ported	`Fine`
`RepeatExpressionCommandrepeat.py`	missing	the kinds that send the music somewhere rather than marking a place, which is every kind `is_marker` says no to
`DaCaporepeat.py`	ported	`DaCapo`
`DaCapoAlFinerepeat.py`	ported	`DaCapoAlFine`
`DaCapoAlCodarepeat.py`	ported	`DaCapoAlCoda`
`AlSegnorepeat.py`	ported	`AlSegno`
`DalSegnorepeat.py`	ported	`DalSegno`
`DalSegnoAlFinerepeat.py`	ported	`DalSegnoAlFine`
`DalSegnoAlCodarepeat.py`	ported	`DalSegnoAlCoda`
`Expanderrepeat.py`	ported	`expand_repeats`
`RepeatFinderrepeat.py`	missing	finds the repeated passages of a score so as to write it with repeat signs, which nothing here writes
`insertRepeatEndingrepeat.py`	missing	writes an ending bracket over some measures
`insertRepeatrepeat.py`	missing	writes repeat barlines round some measures
`deleteMeasuresrepeat.py`	missing	takes measures out and renumbers the rest
`RepeatExpression.getTextrepeat.py`	ported	`text`
`RepeatExpression.setTextrepeat.py`	ported	`set_text`
`RepeatExpression.applyTextFormattingrepeat.py`	missing	the font and the justification a renderer draws the words with; `justify` says which way they are set
`RepeatExpression.setTextExpressionrepeat.py`	missing	keeps the words as a `TextExpression` object
`RepeatExpression.getTextExpressionrepeat.py`	missing	the words as a `TextExpression` for a renderer; `text` is what they say
`RepeatExpression.isValidTextrepeat.py`	ported	`is_valid_text`
`Expander.processrepeat.py`	ported	`expand_repeats`
`Expander.measureMaprepeat.py`	missing	the measures of the expansion listed for a caller to read
`Expander.repeatBarsAreCoherentrepeat.py`	missing	a step of the expansion, which answers an error where the repeats make no sense
`Expander.findInnermostRepeatIndicesrepeat.py`	missing	a step of the expansion
`Expander.processInnermostRepeatBarsrepeat.py`	missing	a step of the expansion
`Expander.getRepeatExpressionIndexrepeat.py`	missing	a step of the expansion
`Expander.isExpandablerepeat.py`	missing	whether there is anything to play out, which expanding answers
`mergeVariantsvariant.py`	ported	`merge_variants`
`mergeVariantScoresvariant.py`	ported	`merge_variant_scores`
`mergeVariantMeasureStreamsvariant.py`	ported	`merge_variant_measure_streams`
`mergeVariantsEqualDurationvariant.py`	ported	`merge_variants_equal_duration`
`mergePartAsOssiavariant.py`	ported	`merge_part_as_ossia`
`addVariantvariant.py`	ported	`add_variant`
`refineVariantvariant.py`	ported	`refine_variant`
`getMeasureHashesvariant.py`	ported	`measure_hashes`
`makeAllVariantsReplacementsvariant.py`	ported	`make_all_variants_replacements`
`makeVariantBlocksvariant.py`	ported	`make_variant_blocks`
`Variant.purgeOrphansvariant.py`	missing	drops the elements no stream holds any more, which only a variant keeping objects can have
`Variant.purgeLocationsvariant.py`	missing	drops the sites it remembers, and it remembers none
`Variant.getElementIdsvariant.py`	missing	Python object ids
`Variant.replaceElementvariant.py`	missing	swaps one element for another by object
`Variant.highestTimevariant.py`	ported	`highest_time`
`Variant.highestOffsetvariant.py`	missing	the offset of the stream it holds, which `Stream::highest_offset` answers of its contents
`Variant.showvariant.py`	missing	rendering, which the crate leaves to its caller
`Variant.containedHighestTimevariant.py`	ported	`contained_highest_time`
`Variant.containedHighestOffsetvariant.py`	ported	`contained_highest_offset`
`Variant.containedSitevariant.py`	missing	the stream it was read out of, which is a site
`Variant.replacementQuarterLengthvariant.py`	ported	`replacement_quarter_length`
`Variant.replacementDurationvariant.py`	missing	the `Duration` of what it replaces; `replacement_quarter_length` is how long that is
`Variant.lengthTypevariant.py`	ported	`length_type`
`Variant.replacedElementsvariant.py`	ported	`replaced_elements`
`Variant.removeReplacedElementsFromStreamvariant.py`	ported	`remove_replaced_elements_from_stream`
`Metadata.addmetadata/__init__.py`	ported	`add`
`Metadata.getCustommetadata/__init__.py`	ported	`get`
`Metadata.addCustommetadata/__init__.py`	ported	`add`
`Metadata.setCustommetadata/__init__.py`	ported	`set`
`Metadata.uniqueNameToNamespaceNamemetadata/__init__.py`	ported	`namespace_name`
`Metadata.namespaceNameToUniqueNamemetadata/__init__.py`	ported	`unique_name_of`
`Metadata.isContributorUniqueNamemetadata/__init__.py`	ported	`is_contributor_unique_name`
`Metadata.isStandardNamemetadata/__init__.py`	ported	`unique_name_of`
`Metadata.softwaremetadata/__init__.py`	ported	`get`
`Metadata.contributorsmetadata/__init__.py`	ported	`contributors`
`Metadata.copyrightmetadata/__init__.py`	ported	`string_value`
`Metadata.getContributorsByRolemetadata/__init__.py`	ported	`contributors_by_role`
`Metadata.alternativeTitlemetadata/__init__.py`	ported	`string_value`
`Metadata.composermetadata/__init__.py`	ported	`string_value`
`Metadata.composersmetadata/__init__.py`	ported	`get`
`Metadata.dateCreatedmetadata/__init__.py`	ported	`string_value`
`Metadata.fileFormatmetadata/__init__.py`	ported	`string_value`
`Metadata.filePathmetadata/__init__.py`	ported	`string_value`
`Metadata.corpusFilePathmetadata/__init__.py`	ported	`string_value`
`Metadata.fileNumbermetadata/__init__.py`	ported	`string_value`
`Metadata.localeOfCompositionmetadata/__init__.py`	ported	`string_value`
`Metadata.librettistmetadata/__init__.py`	ported	`string_value`
`Metadata.librettistsmetadata/__init__.py`	ported	`get`
`Metadata.lyricistmetadata/__init__.py`	ported	`string_value`
`Metadata.lyricistsmetadata/__init__.py`	ported	`get`
`Metadata.movementNamemetadata/__init__.py`	ported	`string_value`
`Metadata.movementNumbermetadata/__init__.py`	ported	`string_value`
`Metadata.numbermetadata/__init__.py`	ported	`string_value`
`Metadata.opusNumbermetadata/__init__.py`	ported	`string_value`
`Metadata.titlemetadata/__init__.py`	ported	`title`
`Metadata.bestTitlemetadata/__init__.py`	ported	`best_title`
`Metadata.convertValuemetadata/__init__.py`	missing	reads a value as one of music21's own primitives -- a `Text`, a `Contributor`, a `Date`; a `MetadataValue` here is the text and the role it was given under
`RichMetadata.mergemetadata/__init__.py`	missing	takes in another score's cached numbers
`RichMetadata.getSourcePathmetadata/__init__.py`	missing	where the file sits, relative to the corpus
`RichMetadata.updatemetadata/__init__.py`	missing	works out the ambitus, the key signatures, the time signatures and the rest of a score and keeps them; `Stream::analyze` answers each of those of a score when asked
`RichMetadata.allmetadata/__init__.py`	missing	the cached numbers beside the metadata
`streamSearchBasesearch/base.py`	ported	`run_over`
`rhythmicSearchsearch/base.py`	ported	`rhythmic_search`
`noteNameSearchsearch/base.py`	ported	`note_name_search`
`noteNameRhythmicSearchsearch/base.py`	ported	`note_name_rhythmic_search`
`approximateNoteSearchsearch/base.py`	ported	`approximate_note_search`
`approximateNoteSearchNoRhythmsearch/base.py`	ported	`approximate_note_search_no_rhythm`
`approximateNoteSearchOnlyRhythmsearch/base.py`	ported	`approximate_note_search_only_rhythm`
`approximateNoteSearchWeightedsearch/base.py`	ported	`approximate_note_search_weighted`
`translateStreamToStringsearch/base.py`	ported	`translate_stream_to_string`
`translateDiatonicStreamToStringsearch/base.py`	ported	`translate_diatonic_stream_to_string`
`translateIntervalsAndSpeedsearch/base.py`	ported	`translate_intervals_and_speed`
`translateStreamToStringNoRhythmsearch/base.py`	ported	`translate_stream_to_string_no_rhythm`
`translateStreamToStringOnlyRhythmsearch/base.py`	ported	`translate_stream_to_string_only_rhythm`
`translateNoteToBytesearch/base.py`	ported	`translate_note_to_byte`
`translateNoteWithDurationToBytessearch/base.py`	ported	`translate_note_with_duration_to_bytes`
`translateNoteTieToBytesearch/base.py`	ported	`translate_note_tie_to_byte`
`translateDurationToBytessearch/base.py`	ported	`translate_duration_to_bytes`
`mostCommonMeasureRhythmssearch/base.py`	ported	`most_common_measure_rhythms`
`StreamSearcher.runsearch/base.py`	ported	`run`
`StreamSearcher.wildcardAlgorithmsearch/base.py`	ported	`run_over`
`StreamSearcher.rhythmAlgorithmsearch/base.py`	ported	`rhythmic_search`
`StreamSearcher.noteNameAlgorithmsearch/base.py`	ported	`note_name_search`
`LyricSearcher.indexTextsearch/lyrics.py`	ported	`index_text`
`LyricSearcher.indexTuplessearch/lyrics.py`	ported	`indexed`
`LyricSearcher.indexsearch/lyrics.py`	ported	`indexed`
`LyricSearcher.searchsearch/lyrics.py`	ported	`search`
`IndexedLyric.modifysearch/lyrics.py`	missing	a named tuple's `_replace`, which is Python's own
`translateMonophonicPartToSegmentssearch/segment.py`	ported	`translate_monophonic_part_to_segments`
`indexScorePartssearch/segment.py`	ported	`index_score_parts`
`indexScoreFilePathssearch/segment.py`	missing	indexes the scores at a list of paths, which means reading files
`indexOnePathsearch/segment.py`	missing	indexes the score at a path, likewise
`saveScoreDictsearch/segment.py`	missing	writes an index to a file
`loadScoreDictsearch/segment.py`	missing	reads an index back
`getDifflibOrPyLevsearch/segment.py`	missing	chooses between two Python libraries for the string comparison; `search::difflib` is the one `difflib.SequenceMatcher` ratio, ported
`scoreSimilaritysearch/segment.py`	ported	`score_similarity`
`ReductiveNote.isParsedanalysis/reduction.py`	ported	`is_parsed`
`ReductiveNote.getNoteAndTextExpressionanalysis/reduction.py`	ported	`note_and_text_expression`
`ScoreReduction.scoreanalysis/reduction.py`	ported	`score`
`ScoreReduction.chordReductionanalysis/reduction.py`	ported	`chord_reduction`
`ScoreReduction.reduceanalysis/reduction.py`	ported	`reduce`
`PartReduction.processanalysis/reduction.py`	ported	`weighted_spans`
`PartReduction.getGraphHorizontalBarWeightedDataanalysis/reduction.py`	missing	the spans arranged for music21's bar graph; `weighted_spans` is what they say
`ActivityMatch.pitchToDynamicanalysis/correlate.py`	ported	`pitch_to_dynamic`
`ElementTimespan.quarterLengthtree/spans.py`	ported	`quarter_length`
`ElementTimespan.newtree/spans.py`	missing	a copy with some of its values changed, which a value type here is made afresh
`ElementTimespan.measureNumbertree/spans.py`	ported	`measure_number`
`ElementTimespan.getParentageByClasstree/spans.py`	ported	`parentage`
`ElementTimespan.parttree/spans.py`	ported	`part`
`ElementTimespan.makeElementtree/spans.py`	missing	the element itself, which an `ElementTimespan` holds a reference to
`Timespan.offsettree/spans.py`	ported	`offset`
`Timespan.endTimetree/spans.py`	ported	`end_time`
`Timespan.newtree/spans.py`	missing	a copy with some of its values changed
`Timespan.canMergetree/spans.py`	missing	whether two timespans may be joined, which only the tree's own merging asks
`Timespan.mergeWithtree/spans.py`	missing	joins two timespans
`Timespan.splitAttree/spans.py`	missing	cuts a timespan in two
`TimespanTree.elementEndTimetree/timespanTree.py`	ported	`end_time`
`TimespanTree.indextree/timespanTree.py`	missing	where a timespan sits in the tree, which is its place in the list here
`TimespanTree.offsettree/timespanTree.py`	ported	`lowest_position`
`TimespanTree.removeTimespanListtree/timespanTree.py`	missing	takes several out, likewise
`TimespanTree.removeTimespantree/timespanTree.py`	missing	takes a timespan out of the tree; the crate reads a stream into timespans and does not edit them
`TimespanTree.findNextPitchedTimespanInSameStreamByClasstree/timespanTree.py`	ported	`next_in_same_part`
`TimespanTree.findPreviousPitchedTimespanInSameStreamByClasstree/timespanTree.py`	ported	`previous_in_same_part`
`TimespanTree.getVerticalityAtOrBeforetree/timespanTree.py`	ported	`verticality_at_or_before`
`TimespanTree.iterateConsonanceBoundedVerticalitiestree/timespanTree.py`	ported	`consonance_bounded_verticalities`
`TimespanTree.iterateVerticalitiestree/timespanTree.py`	ported	`verticalities`
`TimespanTree.iterateVerticalitiesNwisetree/timespanTree.py`	ported	`verticalities_nwise`
`TimespanTree.splitAttree/timespanTree.py`	ported	`split_at`
`TimespanTree.toPartwiseTimespanTreestree/timespanTree.py`	missing	a tree for each part of the score; `as_timespans` reads whichever stream it is given, a part included
`TimespanTree.unwrapVerticalitiestree/timespanTree.py`	ported	`unwrap`
`TimespanTree.allPartstree/timespanTree.py`	missing	every part the timespans came from, which the caller has in the score it read
`TimespanTree.maximumOverlaptree/timespanTree.py`	ported	`maximum_overlap`
`TimespanTree.elementtree/timespanTree.py`	missing	the element a timespan holds, which `ElementTimespan::element` answers
`Verticality.bassTimespantree/verticality.py`	ported	`bass_timespan`
`Verticality.beatStrengthtree/verticality.py`	missing	the accent weight of the offset in the measure holding it, which music21 asks the note and the note asks its site; `TimeSignature::accent_weight` answers it given the meter
`Verticality.toChordtree/verticality.py`	ported	`to_chord`
`Verticality.measureNumbertree/verticality.py`	ported	`measure_number`
`Verticality.nextStartOffsettree/verticality.py`	ported	`next_start_offset`
`Verticality.nextVerticalitytree/verticality.py`	ported	`next`
`Verticality.pitchSettree/verticality.py`	ported	`pitch_set`
`Verticality.pitchClassSettree/verticality.py`	ported	`pitch_class_set`
`Verticality.previousVerticalitytree/verticality.py`	ported	`previous`
`Verticality.startAndOverlapTimespanstree/verticality.py`	ported	`start_and_overlap_timespans`
`Verticality.timeToNextEventtree/verticality.py`	ported	`time_to_next_event`
`Verticality.makeElementtree/verticality.py`	ported	`make_element`
`Verticality.getAllVoiceLeadingQuartetstree/verticality.py`	ported	`voice_leading_quartets`
`Verticality.getPairedMotiontree/verticality.py`	ported	`paired_motion`
`Horizontality.hasPassingTonetree/analysis.py`	ported	`has_passing_tone`
`Horizontality.hasNeighborTonetree/analysis.py`	ported	`has_neighbor_tone`
`Horizontality.hasNoMotiontree/analysis.py`	ported	`has_no_motion`
`listOfTreesByClasstree/fromStream.py`	missing	a tree per part per class, which the caller builds of what `as_timespans` reads
`asTreetree/fromStream.py`	ported	`as_timespans`
`makeFastShallowTreeFromSortedStreamtree/fromStream.py`	missing	a tree of one stream's own elements with nothing nested, built without sorting; the crate sorts once and keeps a list
`asTimespanstree/fromStream.py`	ported	`as_timespans`
`chordifiedtree/toStream.py`	ported	`chordify`
`partwisetree/toStream.py`	missing	the timespans written back out as a part each, which is the score they were read from
`allFeaturesAsListfeatures/base.py`	ported	`all_features_as_list`
`extractorsByIdfeatures/base.py`	ported	`extractors_by_id`
`extractorByIdfeatures/base.py`	ported	`extractor_by_id`
`vectorByIdfeatures/base.py`	ported	`vector_by_id`
`getIndexfeatures/base.py`	ported	`index_of`
`Feature.prepareVectorsfeatures/base.py`	missing	makes room for the numbers before they are worked out, which building one does
`Feature.normalizefeatures/base.py`	missing	divides the numbers by their sum, which `Extractor::extract` does where the extractor asks for it
`FeatureExtractor.setDatafeatures/base.py`	missing	hands the extractor the stream to read, which `extract` takes as an argument
`FeatureExtractor.getAttributeLabelsfeatures/base.py`	ported	`attribute_labels`
`FeatureExtractor.fillFeatureAttributesfeatures/base.py`	missing	copies the extractor's own id and name onto the feature it is filling in
`FeatureExtractor.prepareFeaturefeatures/base.py`	missing	makes the blank feature and fills its attributes in, which `blank` answers
`FeatureExtractor.processfeatures/base.py`	missing	the reading itself, which is the row's own function and runs in `extract`
`FeatureExtractor.extractfeatures/base.py`	ported	`extract`
`FeatureExtractor.getBlankFeaturefeatures/base.py`	ported	`blank`
`StreamForms.keysfeatures/base.py`	missing	the names music21 looks a form up by
`StreamForms.formPartitionByInstrumentfeatures/base.py`	ported	`partition_by_instrument`
`StreamForms.formSetClassHistogramfeatures/base.py`	missing	how often each set class comes, which the extractors that read it work out where they read it
`StreamForms.formPitchClassSetHistogramfeatures/base.py`	missing	how often each pitch-class set comes, likewise
`StreamForms.formTypesHistogramfeatures/base.py`	missing	how often each written value comes, likewise
`StreamForms.formGetElementsByClassMeasurefeatures/base.py`	missing	the measures of the stream, which `Stream::measures` answers
`StreamForms.formChordifyfeatures/base.py`	ported	`chordified_chords`
`StreamForms.formQuarterLengthHistogramfeatures/base.py`	ported	`quarter_length_histogram`
`StreamForms.formMidiPitchHistogramfeatures/base.py`	ported	`midi_pitch_histogram`
`StreamForms.formPitchClassHistogramfeatures/base.py`	ported	`pitch_class_histogram`
`StreamForms.formMidiIntervalHistogramfeatures/base.py`	ported	`midi_interval_histogram`
`StreamForms.formContourListfeatures/base.py`	ported	`contour_list`
`StreamForms.formSecondsMapfeatures/base.py`	ported	`seconds_map`
`StreamForms.formBeatHistogramfeatures/base.py`	missing	how often each beat strength comes, which the extractor reading it works out
`DataInstance.setupPostStreamParsefeatures/base.py`	missing	the second half of reading the stream in, which building one does in one
`DataInstance.setClassLabelfeatures/base.py`	missing	the class a subject belongs to for the data set it is in; `DataSet::add_data` takes it beside the subject
`DataInstance.getClassValuefeatures/base.py`	missing	that class, likewise
`DataInstance.getIdfeatures/base.py`	missing	the name a subject goes by, which `DataSet::add_data` takes beside it
`DataInstance.parseStreamfeatures/base.py`	ported	`new`
`DataSet.getClassLabelfeatures/base.py`	ported	`class_label`
`DataSet.addFeatureExtractorsfeatures/base.py`	ported	`add_extractors`
`DataSet.getAttributeLabelsfeatures/base.py`	ported	`attribute_labels`
`DataSet.getDiscreteLabelsfeatures/base.py`	ported	`discrete_labels`
`DataSet.getClassPositionLabelsfeatures/base.py`	missing	where the class column sits, which the caller knows of the labels it asked for
`DataSet.addMultipleDatafeatures/base.py`	missing	adds several subjects at once, which is `add_data` in a loop
`DataSet.addDatafeatures/base.py`	ported	`add_data`
`DataSet.processfeatures/base.py`	ported	`process`
`DataSet.getFeaturesAsListfeatures/base.py`	ported	`features_as_list`
`DataSet.getUniqueClassValuesfeatures/base.py`	ported	`unique_class_values`
`DataSet.getStringfeatures/base.py`	ported	`to_text`
`DataSet.writefeatures/base.py`	missing	writes the table to a file, which the library does not do: `to_text` is the text to write
`barlineToBraillebraille/basic.py`	ported	`barline_to_braille`
`chordToBraillebraille/basic.py`	ported	`chord_to_braille`
`pitchToOctavebraille/basic.py`	ported	`pitch_to_octave`
`clefToBraillebraille/basic.py`	ported	`clef_to_braille`
`dynamicToBraillebraille/basic.py`	ported	`dynamic_to_braille`
`instrumentToBraillebraille/basic.py`	ported	`instrument_to_braille`
`keySigToBraillebraille/basic.py`	ported	`key_sig_to_braille`
`metronomeMarkToBraillebraille/basic.py`	ported	`metronome_mark_to_braille`
`yieldBrailleArticulationsbraille/basic.py`	ported	`note_to_braille`
`noteToBraillebraille/basic.py`	ported	`note_to_braille`
`handlePitchWithAccidentalbraille/basic.py`	ported	`note_to_braille`
`handleArticulationsbraille/basic.py`	ported	`note_to_braille`
`handleExpressionsbraille/basic.py`	ported	`note_to_braille`
`restToBraillebraille/basic.py`	ported	`rest_to_braille`
`tempoTextToBraillebraille/basic.py`	ported	`tempo_text_to_braille`
`textExpressionToBraillebraille/basic.py`	ported	`text_expression_to_braille`
`timeSigToBraillebraille/basic.py`	ported	`time_sig_to_braille`
`showOctaveWithNotebraille/basic.py`	ported	`show_octave_with_note`
`transcribeHeadingbraille/basic.py`	ported	`transcribe_heading`
`transcribeNoteFingeringbraille/basic.py`	ported	`transcribe_note_fingering`
`transcribeSignaturesbraille/basic.py`	ported	`transcribe_signatures`
`brailleUnicodeToBrailleAsciibraille/basic.py`	ported	`braille_unicode_to_braille_ascii`
`brailleAsciiToBrailleUnicodebraille/basic.py`	ported	`braille_ascii_to_braille_unicode`
`brailleUnicodeToSymbolsbraille/basic.py`	ported	`braille_unicode_to_symbols`
`yieldDotsbraille/basic.py`	ported	`yield_dots`
`wordToBraillebraille/basic.py`	ported	`word_to_braille`
`numberToBraillebraille/basic.py`	ported	`number_to_braille`
`objectToBraillebraille/translate.py`	ported	`element_to_braille`
`streamToBraillebraille/translate.py`	ported	`stream_to_braille`
`scoreToBraillebraille/translate.py`	ported	`score_to_braille`
`metadataToStringbraille/translate.py`	ported	`metadata_to_string`
`opusToBraillebraille/translate.py`	missing	every score of an opus one after another, which is `score_to_braille` of each
`measureToBraillebraille/translate.py`	ported	`measure_to_braille`
`partToBraillebraille/translate.py`	ported	`part_to_braille`
`keyboardPartsToBraillebraille/translate.py`	ported	`keyboard_parts_to_braille`
`BrailleText.showHandbraille/text.py`	ported	`set_show_hand`
`BrailleText.addHeadingbraille/text.py`	ported	`add_heading`
`BrailleText.addLongExpressionbraille/text.py`	ported	`add_long_expression`
`BrailleText.addToNewLinebraille/text.py`	ported	`add_to_new_line`
`BrailleText.appendOrInsertCurrentbraille/text.py`	ported	`append_or_insert_current`
`BrailleText.addInaccordbraille/text.py`	ported	`add_inaccord`
`BrailleText.addMeasureNumberbraille/text.py`	ported	`add_measure_number`
`BrailleText.optionalAddKeyboardSymbolsAndDotsbraille/text.py`	ported	`optional_add_keyboard_symbols_and_dots`
`BrailleText.addSignaturesbraille/text.py`	ported	`add_signatures`
`BrailleText.makeNewLinebraille/text.py`	ported	`make_new_line`
`BrailleText.recenterHeadingsbraille/text.py`	ported	`recenter_headings`
`BrailleTextLine.appendbraille/text.py`	ported	`append`
`BrailleTextLine.insertbraille/text.py`	ported	`insert`
`BrailleTextLine.canAppendbraille/text.py`	ported	`can_append`
`BrailleTextLine.canInsertbraille/text.py`	ported	`can_insert`
`BrailleTextLine.lastHyphenToSpacebraille/text.py`	ported	`last_hyphen_to_space`
`BrailleKeyboard.makeNewLinesbraille/text.py`	ported	`make_new_lines`
`BrailleKeyboard.addNoteGroupingsbraille/text.py`	ported	`add_note_groupings`
`makeBrailleDictionarybraille/lookup.py`	missing	builds music21's dictionary of cells at import; the tables here are written out
`dotsAddbraille/lookup.py`	ported	`dots_add`
`makePitchNameToNotesbraille/lookup.py`	ported	`pitch_name_to_note`
`setGroupingGlobalsbraille/segment.py`	missing	music21's module-level defaults for a grouping, set the first time one is made; `SegmentOptions` is what a caller says instead
`findSegmentsbraille/segment.py`	ported	`find_segments`
`prepareSlurredNotesbraille/segment.py`	ported	`prepare_slurred_notes`
`getRawSegmentsbraille/segment.py`	ported	`get_raw_segments`
`extractBrailleElementsbraille/segment.py`	ported	`extract_braille_elements`
`prepareBeamedNotesbraille/segment.py`	ported	`prepare_beamed_notes`
`setAffinityCodebraille/segment.py`	missing	which kind of segment an element belongs in, which `extract_braille_elements` says as it reads
`areGroupingsIdenticalbraille/segment.py`	missing	whether two groupings are the same, which the segment asks of its own
`splitNoteGroupingbraille/segment.py`	ported	`split_note_grouping`
`splitMeasurebraille/segment.py`	missing	cuts a measure in two so that the braille fits, which `split_note_grouping` does of the grouping
`BrailleSegment.brailleTextbraille/segment.py`	ported	`transcribe`
`BrailleSegment.transcribebraille/segment.py`	ported	`transcribe`
`BrailleSegment.addDummyRestsbraille/segment.py`	missing	a step of the transcription: the rests that stand before a measure number
`BrailleSegment.extractMeasureNumberbraille/segment.py`	missing	a step of the transcription
`BrailleSegment.extractHeadingbraille/segment.py`	missing	a step of the transcription: the key, the meter and the tempo over the first measure
`BrailleSegment.extractInaccordGroupingbraille/segment.py`	missing	a step of the transcription: the voices written one after another
`BrailleSegment.extractLongExpressionGroupingbraille/segment.py`	missing	a step of the transcription
`BrailleSegment.showLeadingOctaveFromNoteGroupingbraille/segment.py`	missing	a step of the transcription: whether the first note of a grouping shows its octave
`BrailleSegment.needsSplitToFitbraille/segment.py`	missing	a step of the transcription: whether a grouping must be split to fit the line
`BrailleSegment.splitNoteGroupingAndTranscribebraille/segment.py`	missing	a step of the transcription, which `split_note_grouping` does the splitting half of
`BrailleSegment.extractNoteGroupingbraille/segment.py`	missing	a step of the transcription
`BrailleSegment.addRepeatSymbolsbraille/segment.py`	missing	a step of the transcription: the sign for a measure repeated
`BrailleSegment.extractSignatureGroupingbraille/segment.py`	missing	a step of the transcription
`BrailleSegment.extractTempoTextGroupingbraille/segment.py`	missing	a step of the transcription
`BrailleSegment.consolidatebraille/segment.py`	missing	a step of the transcription: the groupings of one kind joined into one
`BrailleSegment.addGroupingAttributesbraille/segment.py`	ported	`add_grouping_attributes`
`BrailleSegment.fixArticulationsbraille/segment.py`	ported	`fix_articulations`
`BrailleGrandSegment.brailleTextbraille/segment.py`	ported	`transcribe`
`BrailleGrandSegment.yieldCombinedGroupingKeysbraille/segment.py`	ported	`combined_keys`
`BrailleGrandSegment.transcribebraille/segment.py`	ported	`transcribe`
`BrailleGrandSegment.extractHeadingbraille/segment.py`	missing	a step of the transcription
`BrailleGrandSegment.extractNoteGroupingbraille/segment.py`	missing	a step of the transcription
`StreamAligner.getDefaultHasheralpha/analysis/aligner.py`	ported	`new`
`StreamAligner.alignalpha/analysis/aligner.py`	ported	`align`
`StreamAligner.makeHashedStreamsalpha/analysis/aligner.py`	ported	`align`
`StreamAligner.setupDistanceMatrixalpha/analysis/aligner.py`	ported	`align_hashed`
`StreamAligner.populateDistanceMatrixalpha/analysis/aligner.py`	ported	`align_hashed`
`StreamAligner.getPossibleMovesFromLocationalpha/analysis/aligner.py`	ported	`align_hashed`
`StreamAligner.getOpFromLocationalpha/analysis/aligner.py`	ported	`align_hashed`
`StreamAligner.insertCostalpha/analysis/aligner.py`	missing	what an insertion costs, which is one everywhere
`StreamAligner.deleteCostalpha/analysis/aligner.py`	missing	what a deletion costs, likewise
`StreamAligner.substitutionCostalpha/analysis/aligner.py`	missing	what a substitution costs, which the hashes' difference says
`StreamAligner.calculateNumSimilaritiesalpha/analysis/aligner.py`	ported	`changes_count`
`StreamAligner.tupleEqualityWithoutReferencealpha/analysis/aligner.py`	missing	whether two hashes are equal but for which note they came from, which comparing them answers
`StreamAligner.calculateChangesListalpha/analysis/aligner.py`	ported	`align_hashed`
`StreamAligner.showChangesalpha/analysis/aligner.py`	missing	prints the changes, and colours the notes of the score to show them
`Hasher.setupValidTypesAndStateVarsalpha/analysis/hasher.py`	missing	reads the switches into the state music21 hashes by, which are the fields of a `Hasher` here
`Hasher.setupTupleListalpha/analysis/hasher.py`	ported	`tuple_list`
`Hasher.hashMeasuresalpha/analysis/hasher.py`	missing	the measures hashed one at a time, which is `hash_stream` of each
`Hasher.hashStreamalpha/analysis/hasher.py`	ported	`hash_stream`
`Hasher.addHashToFinalHashalpha/analysis/hasher.py`	missing	appends one hash to the list being built
`Hasher.addNoteHashWithReferenceToFinalHashalpha/analysis/hasher.py`	missing	appends a note's hash with the note it came from, likewise
`Hasher.addNoteHashToFinalHashalpha/analysis/hasher.py`	missing	appends a note's hash, likewise
`getNotesWithinDurationalpha/analysis/fixer.py`	ported	`notes_within_duration`
`OrnamentFixer.findOrnamentalpha/analysis/fixer.py`	ported	`find_ornament`
`OrnamentFixer.addOrnamentalpha/analysis/fixer.py`	missing	writes the ornament onto the read note, which `fix` does where it finds one
`OrnamentFixer.fixalpha/analysis/fixer.py`	ported	`fix`
`EnharmonicFixer.fixalpha/analysis/fixer.py`	ported	`fix_enharmonics`
`EnharmonicFixer.isEnharmonicalpha/analysis/fixer.py`	missing	whether two notes sound alike, which is `Pitch::is_enharmonic`
`EnharmonicFixer.hasAccalpha/analysis/fixer.py`	missing	whether a note carries an accidental, which is `Pitch::accidental_is_written`
`EnharmonicFixer.hasNatAccalpha/analysis/fixer.py`	missing	whether it carries a natural, likewise
`EnharmonicFixer.hasSharpFlatAccalpha/analysis/fixer.py`	missing	whether it carries a sharp or a flat, likewise
`EnharmonicFixer.stepEqalpha/analysis/fixer.py`	missing	whether two notes stand on the same step
`EnharmonicFixer.stepNotEqalpha/analysis/fixer.py`	missing	whether they do not
`EnharmonicFixer.intervalTooBigalpha/analysis/fixer.py`	missing	whether the two are too far apart to be a misspelling, which the fix asks as it goes
`calculateTrillNoteDurationalpha/analysis/ornamentRecognizer.py`	ported	`ornament_note_quarter_length`
`TrillRecognizer.recognizealpha/analysis/ornamentRecognizer.py`	ported	`recognize`
`TurnRecognizer.isAcceptableIntervalalpha/analysis/ornamentRecognizer.py`	ported	`is_acceptable_interval`
`TurnRecognizer.recognizealpha/analysis/ornamentRecognizer.py`	ported	`recognize`
`OrnamentRecognizer.calculateOrnamentNoteQlalpha/analysis/ornamentRecognizer.py`	ported	`ornament_note_quarter_length`
`OrnamentRecognizer.calculateOrnamentTotalQlalpha/analysis/ornamentRecognizer.py`	ported	`ornament_total_quarter_length`
`findConsecutiveScalealpha/analysis/search.py`	ported	`find_consecutive_scale`
`ScoreCorrector.runomr/correctors.py`	ported	`run`
`ScoreCorrector.runPriorModelomr/correctors.py`	missing	music21's measure of how much the correction helped, which `PriorsIntegrationScore` carries
`ScoreCorrector.getAllHashesomr/correctors.py`	ported	`all_hashes`
`ScoreCorrector.getSinglePartomr/correctors.py`	ported	`single_part_mut`
`ScoreCorrector.runHorizontalCorrectionModelomr/correctors.py`	ported	`run_horizontal_correction_model`
`ScoreCorrector.getMeasureSliceomr/correctors.py`	missing	the same measure across every part, which `vertical_probability_dist` reads as it goes
`ScoreCorrector.getAllIncorrectMeasuresomr/correctors.py`	ported	`all_incorrect_measures`
`ScoreCorrector.verticalProbabilityDistomr/correctors.py`	ported	`vertical_probability_dist`
`ScoreCorrector.getVerticalProbabilityDistributionSinglePartomr/correctors.py`	missing	a step of the vertical correction, which `vertical_probability_dist` does for every part at once
`ScoreCorrector.getVerticalProbabilityDistributionSinglePartSingleMeasureomr/correctors.py`	missing	a step of the same
`ScoreCorrector.runVerticalSearchomr/correctors.py`	ported	`run_vertical_search`
`ScoreCorrector.substituteOneMeasureContentsForAnotheromr/correctors.py`	ported	`substitute_measure`
`ScoreCorrector.runVerticalCorrectionModelomr/correctors.py`	ported	`run_vertical_correction_model`
`ScoreCorrector.generateCorrectedScoreomr/correctors.py`	ported	`generate_corrected_score`
`SinglePart.getMeasuresomr/correctors.py`	missing	the measures of the part, which the `Stream` it was read from holds
`SinglePart.getIncorrectMeasureIndicesomr/correctors.py`	ported	`find_incorrect_measures`
`SinglePart.getSequenceHashesFromMeasureStreamomr/correctors.py`	ported	`hashed_notes`
`SinglePart.horizontalProbabilityDistomr/correctors.py`	ported	`horizontal_probability_dist`
`SinglePart.runHorizontalSearchomr/correctors.py`	ported	`run_horizontal_search`
`SinglePart.runHorizontalCorrectionModelomr/correctors.py`	ported	`run_horizontal_correction_model`
`SinglePart.getProbabilityDistributionomr/correctors.py`	ported	`probability_distribution`
`MeasureHash.getHashStringomr/correctors.py`	ported	`measure_hash`
`MeasureHash.hashNoteomr/correctors.py`	ported	`measure_hash`
`MeasureHash.hashGraceomr/correctors.py`	ported	`measure_hash`
`MeasureHash.hashRestomr/correctors.py`	ported	`measure_hash`
`MeasureHash.hashQuarterLengthomr/correctors.py`	ported	`measure_hash`
`MeasureHash.setSequenceMatcheromr/correctors.py`	missing	keeps Python's own `SequenceMatcher` on the object; `search::difflib` is the comparison, ported
`MeasureHash.getMeasureDifferenceomr/correctors.py`	ported	`measure_difference`
`MeasureHash.getOpCodesomr/correctors.py`	ported	`opcodes`
`MeasureHash.getProbabilityBasedOnChangesomr/correctors.py`	ported	`probability_based_on_changes`
`MeasureHash.differenceProbabilityForOneOpCodeomr/correctors.py`	missing	the odds of one edit, which `probability_based_on_changes` sums
`MeasureHash.getProbabilityOnEqualityomr/correctors.py`	missing	the odds of two measures reading alike, likewise
`MeasureHash.getProbabilityOnOmissionomr/correctors.py`	missing	the odds of a note left out, likewise
`MeasureHash.getProbabilityOnAdditionomr/correctors.py`	missing	the odds of a note put in, likewise
`MeasureHash.getProbabilityOnSubstituteomr/correctors.py`	ported	`probability_on_substitute`
`MeasureHash.getProbabilityFromOneCharSubomr/correctors.py`	ported	`probability_from_one_char_sub`
`MeasureSlice.getSliceHashesomr/correctors.py`	missing	the hashes of the measure across every part, which `ScoreCorrector::vertical_probability_dist` reads as it goes
`MeasureSlice.runSliceSearchomr/correctors.py`	missing	the search across the parts, which `run_vertical_search` does
`evaluateCorrectingModelomr/evaluators.py`	ported	`evaluate_correcting_model`
`autoCorrelationBestMeasureomr/evaluators.py`	ported	`auto_correlation_best_measure`
`OmrGroundTruthPair.debugomr/evaluators.py`	missing	music21's switch for printing what it is doing
`OmrGroundTruthPair.parseAllomr/evaluators.py`	missing	reads both scores from their files
`OmrGroundTruthPair.hashAllomr/evaluators.py`	missing	hashes both scores, which building the pair does
`OmrGroundTruthPair.getOmrScoreomr/evaluators.py`	ported	`omr`
`OmrGroundTruthPair.getGroundScoreomr/evaluators.py`	ported	`ground`
`OmrGroundTruthPair.substCostomr/evaluators.py`	missing	what a substitution costs, which the hashes' difference says
`OmrGroundTruthPair.insertCostomr/evaluators.py`	missing	what an insertion costs, which is one everywhere
`OmrGroundTruthPair.deleteCostomr/evaluators.py`	missing	what a deletion costs, likewise
`OmrGroundTruthPair.minEditDistomr/evaluators.py`	ported	`min_edit_distance`
`OmrGroundTruthPair.getDifferencesomr/evaluators.py`	ported	`differences`
`histogramaudioSearch/__init__.py`	ported	`histogram`
`autocorrelationFunctionaudioSearch/__init__.py`	ported	`autocorrelation_frequency`
`prepareThresholdsaudioSearch/__init__.py`	ported	`prepare_thresholds`
`interpolationaudioSearch/__init__.py`	ported	`interpolation`
`normalizeInputFrequencyaudioSearch/__init__.py`	ported	`normalize_input_frequency`
`pitchFrequenciesToObjectsaudioSearch/__init__.py`	ported	`pitch_frequencies_to_objects`
`getFrequenciesFromMicrophoneaudioSearch/__init__.py`	missing	listens to a microphone, which the library does not do
`getFrequenciesFromAudioFileaudioSearch/__init__.py`	ported	`frequencies_from_wav`
`getFrequenciesFromPartialAudioFileaudioSearch/__init__.py`	missing	reads part of a file as it is being recorded
`detectPitchFrequenciesaudioSearch/__init__.py`	ported	`detect_pitch_frequencies`
`smoothFrequenciesaudioSearch/__init__.py`	ported	`smooth_frequencies`
`joinConsecutiveIdenticalPitchesaudioSearch/__init__.py`	ported	`join_consecutive_identical_pitches`
`quantizeDurationaudioSearch/__init__.py`	ported	`quantize_duration`
`quarterLengthEstimationaudioSearch/__init__.py`	ported	`quarter_length_estimation`
`notesAndDurationsToStreamaudioSearch/__init__.py`	ported	`notes_and_durations_to_stream`
`decisionProcessaudioSearch/__init__.py`	ported	`decision_process`
`ContiguousSegmentOfNotessearch/serial.py`	ported	`ContiguousSegment`
`ContiguousSegmentSearchersearch/serial.py`	ported	`ContiguousSegmentSearcher`
`SegmentMatchersearch/serial.py`	ported	`SegmentMatcher`
`TransposedSegmentMatchersearch/serial.py`	missing	one of `Matching`'s six kinds rather than a class of its own: `Matching::Transposed`, which compares the intervals a run makes
`TransformedSegmentMatchersearch/serial.py`	missing	`Matching::Transformed`, which compares the rows a transposition, inversion, retrograde or retrograde inversion takes one to the other
`MultisetSegmentMatchersearch/serial.py`	missing	`Matching::Multiset`, which compares the pitch classes in any order
`TransposedMultisetMatchersearch/serial.py`	missing	`Matching::TransposedMultiset`
`TransposedInvertedMultisetMatchersearch/serial.py`	missing	`Matching::TransposedInvertedMultiset`
`ContiguousSegmentOfNotes.startMeasureNumbersearch/serial.py`	ported	`start_measure`
`ContiguousSegmentOfNotes.startOffsetsearch/serial.py`	ported	`start_offset`
`ContiguousSegmentOfNotes.getActiveMatchedRowssearch/serial.py`	missing	two `ToneRow`s built from the `active` and `matched` fields, which a caller builds itself; what music21 uses them for is the transformations between them, which `zero_centered_transformations_from_matched` and its original-centred twin answer
`ContiguousSegmentOfNotes.zeroCenteredTransformationsFromMatchedsearch/serial.py`	ported	`zero_centered_transformations_from_matched`
`ContiguousSegmentOfNotes.originalCenteredTransformationsFromMatchedsearch/serial.py`	ported	`original_centered_transformations_from_matched`
`ContiguousSegmentOfNotes.readPitchClassesFromBottomsearch/serial.py`	ported	`pitch_classes_from_bottom`
`ContiguousSegmentOfNotes.getDistinctPitchClassessearch/serial.py`	ported	`distinct_pitch_classes`
`ContiguousSegmentSearcher.getSearchBoundMethodsearch/serial.py`	missing	music21 chooses a method by name for each way of reading repetitions; the crate's one walk takes `Repetitions` as an argument
`ContiguousSegmentSearcher.byLengthsearch/serial.py`	ported	`by_length`
`ContiguousSegmentSearcher.addActiveChordssearch/serial.py`	missing	a step inside that walk: the crate reads a chord's pitch classes where it meets one
`ContiguousSegmentSearcher.searchIncludeAllExcludesearch/serial.py`	missing	one of the twelve methods that choice picks between, which the one walk answers for
`ContiguousSegmentSearcher.searchIncludeAllIncludesearch/serial.py`	missing	as `searchIncludeAllExclude`
`ContiguousSegmentSearcher.searchSkipConsecutiveExcludesearch/serial.py`	missing	as `searchIncludeAllExclude`
`ContiguousSegmentSearcher.searchSkipConsecutiveIncludesearch/serial.py`	missing	as `searchIncludeAllExclude`
`ContiguousSegmentSearcher.searchIgnoreAllExcludesearch/serial.py`	missing	as `searchIncludeAllExclude`
`ContiguousSegmentSearcher.searchIgnoreAllIncludesearch/serial.py`	missing	as `searchIncludeAllExclude`
`ContiguousSegmentSearcher.searchRowsOnlyExcludesearch/serial.py`	missing	as `searchIncludeAllExclude`
`ContiguousSegmentSearcher.searchRowsOnlyIncludesearch/serial.py`	missing	as `searchIncludeAllExclude`
`SegmentMatcher.repssearch/serial.py`	ported	`repetitions`
`SegmentMatcher.includeChordssearch/serial.py`	ported	`include_chords`
`SegmentMatcher.getContiguousSegmentsByLengthsearch/serial.py`	missing	the searcher's `by_length`, which `find` asks for itself
`SegmentMatcher.findsearch/serial.py`	ported	`find`
`SegmentMatcher.findOneIgnoreAllsearch/serial.py`	missing	one of the two branches of music21's `find`, which it picks by how repetitions are read; the crate's `find` is the one walk
`SegmentMatcher.findOneOtherRepssearch/serial.py`	missing	the other branch of `find`
`SegmentMatcher.checkSearchedAlreadysearch/serial.py`	missing	whether a segment the same as one already searched for is to be passed over, which `find` keeps as it goes
`SegmentMatcher.normalizesearch/serial.py`	missing	how a run is read before it is compared, which is what `Matching` says: the pitch classes, the intervals they make, or the row they are
`SegmentMatcher.equalSubsetsearch/serial.py`	missing	the comparison `Matching` decides, which the crate does inside `find`
`labelSegmentssearch/serial.py`	ported	`label`
`labelTransposedSegmentssearch/serial.py`	ported	`label`
`labelTransformedSegmentssearch/serial.py`	ported	`label`
`labelMultisetssearch/serial.py`	ported	`label`
`labelTransposedMultisetssearch/serial.py`	ported	`label`
`labelTransposedAndInvertedMultisetssearch/serial.py`	ported	`label`

A member listed as ported is one the crate has a function for and the facade has not reached yet, which makes it the cheapest kind to close.

In the wheel only

46 members

music21 member	Why the crate has no function for it
answered by the facade alone — 46
`Pitch.groupspitch.py`	the group names music21 picks elements out of a stream by (`getElementsByGroup`); a stream here picks by kind and by position, and nothing in it carries group names
`Pitch.informClientpitch.py`	observer callback for a containing note; there is none
`ConcreteScale.isConcretescale/__init__.py`	every Scale here has a tonic, so the question has one answer; the wheel answers it for a scale built without one
`ConcreteScale.abstractscale/__init__.py`	a scale's pattern is its ScaleType or the steps it was given, read with scale_type and custom_steps; there is no abstract scale object beside it, and the wheel hands music21 one built from those
`Scalescale/__init__.py`	the abstract base
`AbstractScalescale/__init__.py`	a pattern with no tonic is a ScaleType or a list of steps; the wheel's AbstractScale stands on those and builds music21's IntervalNetwork from them
`ConcreteScalescale/__init__.py`	realized by Scale, StepScale and ScalaScale
`DiatonicScalescale/__init__.py`	the diatonic modes are ScaleType variants
`TimeSignature.resetValuesmeter/base.py`	rebuilding a meter in place; a new one is built instead
`TimeSignature.loadmeter/base.py`	rebuilding a meter in place; a new one is built instead
`Instrument.partIdRandomizeinstrument.py`	makes an id up out of the clock and a random number; the crate keeps the id a score gives (`part_id`) and makes none up, reading no clock -- the wheel gives a random one as music21 does
`Instrument.instrumentIdRandomizeinstrument.py`	makes an id up out of the clock and a random number; the crate keeps the id a score gives (`instrument_id`) and makes none up, reading no clock -- the wheel gives a random one as music21 does
`Duration.informClientduration.py`	observer callback for a containing note; there is none
`Duration.currentComponentsduration.py`	the working-out is not deferred here, so there is no half-worked-out state to read
`Sieve.expandsieve.py`	which reading answers is not state on the sieve here; `compressed` hands back the other one and the sieve as written stays as it was
`Sieve.setZsieve.py`	the range is an argument of each question here, not state on the sieve
`Sieve.setZRangesieve.py`	the range is an argument of each question here, not state on the sieve
`Sieve.setSegmentFormatsieve.py`	the segment format is an argument of each question here, not state on the sieve
`Sieve.representsieve.py`	the sieve is written by `Display`, which is not a function the map can name
`Volume.cachedRealizedvolume.py`	the crate caches nothing -- a value that answers the same question twice is doing arithmetic. The wheel caches as music21 does
`Volume.cachedRealizedStrvolume.py`	the crate caches nothing -- a value that answers the same question twice is doing arithmetic. The wheel caches as music21 does
`Note.pitchChangednote.py`	observer callback; there is none
`Tie.idtie.py`	the address of the Python object, which is how music21 tells one tie from another; a tie here is a value its note holds, and has no identity apart from it
`MeterSequence.partitionmeter/core.py`	one setter dispatching on the type of what it is handed; the three partitions it dispatches to are each ported
`MeterSequence.loadmeter/core.py`	rebuilding a sequence in place; a new one is built instead
`Ornament.fillListOfRealizedNotesexpressions.py`	a helper realize fills its lists with; realize is ported
`Segment.singlePossibilityRulesfiguredBass/segment.py`	music21's table of its own Python functions for printing; the rules are Rules and the segment runs them
`Segment.consecutivePossibilityRulesfiguredBass/segment.py`	music21's table of its own Python functions for printing; the rules are Rules and the segment runs them
`Segment.specialResolutionRulesfiguredBass/segment.py`	music21's table of its own Python functions for printing; the rules are Rules and the segment runs them
`MelodicIntervalDiversity.solutionToColoranalysis/discrete.py`	the colour a count is drawn in; presentation
`EnharmonicSimplifier.getProductanalysis/enharmonics.py`	lists every combination of the spellings at once; best_choice walks them one at a time
`Stream.clefstream/base.py`	the clef a stream opens with; the clef in force is read by `in_force_before`, a crate stream keeping no clef of its own
`Stream.removestream/base.py`	takes a named object out; `retain_leaves` and `remove_event` take out by place or by test
`Stream.setElementOffsetstream/base.py`	as `elementOffset`: `events_mut` reaches each in place
`Stream.elementOffsetstream/base.py`	asks where one object sits; a crate stream owns values rather than objects, so `events` gives each with its offset
`Stream.measurestream/base.py`	one measure by its number; `measures` answers them all, each carrying its own `number`
`Stream.sortedstream/base.py`	as `sort`
`Score.measurestream/base.py`	one measure by its number; `measures` answers them all, each carrying its own `number`
`Stylestyle.py`	the base class every style hangs off; the crate keeps the few drawing values it reads and writes beside the thing drawn
`NoteStylestyle.py`	how a note is drawn beyond its colour and its size
`SpannerBundlespanner.py`	the collection music21 keeps a stream's spanners in; a crate stream holds its own
`Spanner.addSpannedElementsspanner.py`	adds elements by object; `Spanner::new` takes the positions it joins
`Spanner.hasSpannedElementspanner.py`	whether an element is among them, which is `spanned().contains`
`Spanner.replaceSpannedElementspanner.py`	swaps one element for another by object
`Spanner.getFirstspanner.py`	the first element itself; `spanned` gives its position and the stream hands back what stands there
`Spanner.getLastspanner.py`	the last element itself, likewise

What these answer is Python's rather than music theory's: a cached value, a callback from the object that holds it, an instrument, or a walk through the stream a note sits in. They are why the crate is not a superset of the wheel.