rh SrSSKJr /SQrSSKJrJr SSKrSSKr SSKJ r SSK r SSK J r SSK Jr SS KJr SS K Jr SS KJr SS K Jr SS K Jr SSK Jr SSK Jr SSK Jr SSK Jr SSK Jr SSKJr SSKJr \ R<(a SSK Jr SSK J!r! \RD"S5r#\ RH"SSS9r%\ RH"SSS9r&"SS\RN5r("SS \RR5r*"S!S"\*5r+S(S#jr,S)S$jr-"S%S&\ R\5r/\+/r0\1S':XaSSK r \ Rd"\/5 gg)*z This module defines the Chord object, a subclass of :class:`~music21.note.GeneralNote` as well as other methods, functions, and objects related to chords. ) annotations)toolstablesChordChordExceptionfromIntervalVectorfromForteClass)IterableSequenceN)overload)beam)common) cacheMethod) derivation)Duration) environment) exceptions21)interval)notepitch)tie)volume)r)r)stream)Stylechord_ChordBaseTypezmusic21.chord.ChordBase)bound _ChordTypezmusic21.chord.Chordc\rSrSrSrg)r5N)__name__ __module__ __qualname____firstlineno____static_attributes__r"P/home/james-whalen/.local/lib/python3.13/site-packages/music21/chord/__init__.pyrr5sr(rc^\rSrSr%SrSrSrSSSS.rS\S '\R\ RR5 SSU4S jjjr U4S jr U4S jrSSU4SjjjrSrSrS S.S SjjrS!SjrSr\S"Sj5r\S#Sj5r\R0S$Sj5r\S%Sj5r\R0S&Sj5rS'SjrS(SjrSrU=r$)) ChordBase:a A base class for NotRest objects that have multiple underlying structures like notes or unpitched percussion. As of Version 7, ChordBase lies between Chord and NotRest in the music21 hierarchy, so that features can be shared with PercussionChord. >>> cb = chord.ChordBase('C4 E4 G4') >>> cb.notes (, , ) **Equality** Equality on ChordBase is strange, but necessary to help Chord and PercussionChord do meaningful equality checks themselves. Two ChordBase objects are equal if they pass all `super()` equality tests and the **number** of stored Notes are the same. >>> cb1 = chord.ChordBase('C4 E4 G4') >>> cb2 = chord.ChordBase('C4 E4') >>> cb1 == cb2 False This is surprising, but it's necessary to make checking equality of Chord objects and PercussionChord objects themselves easier. >>> cb3 = chord.ChordBase('A#4 A#4 A#4') >>> cb1 == cb3 True Fzj Boolean read-only value describing if this GeneralNote object is a Note. Is Falsez Boolean read-only value describing if this GeneralNote object is a Rest. Is False >>> c = chord.Chord() >>> c.isRest False z%A :class:`music21.beam.Beams` object.)isNoteisRestbeamsdict[str, str] _DOC_ATTRNc 4>^Uc/n[U[5(aSU;aUR5nOU/n0Ul/Ul[ TU]"S0TD6 [U4SjS55(dURUSS9 gURXRS9 g)N c3,># UH oT;v M g7fNr").0kkeywordss r) %ChordBase.__init__..sP*OQ=*Os)durationtype quarterLength useDurationr") isinstancestrsplit _overrides_notessuper__init__any_add_core_or_initr;selfnotesr8 __class__s `r)rFChordBase.__init__ps =E eS ! !e|  -/*,  $8$P*OPPP  " "5d " ;  " "5mm " Dr(c>[TU]U5(dg[UR5[UR5:waggNFT)rE__eq__lenrKrJotherrLs r)rPChordBase.__eq__s4w~e$$ tzz?c%++. .r(c >[TU]5$r5rE__hash__rJrLs r)rWChordBase.__hash__w!!r(c>[TU]US9nURH0nX#lUR 5(dM X#R lM2 U$)z As Chord objects have one or more Volume, objects, and Volume objects store weak refs to the client object, need to specialize deepcopy handling depending on if the chord has its own volume object. )memo)rE __deepcopy__rD_chordAttachedhasVolumeInformationrclient)rJr\newnrLs r)r]ChordBase.__deepcopy__sLg""-A" %%''"%   r(c,[UR5$r5)iterrDrJs r)__iter__ChordBase.__iter__sDKK  r(c,[UR5$)zb Return the length of components in the chord. >>> c = chord.Chord(['c', 'e', 'g']) >>> len(c) 3 )rQrDrfs r)__len__ChordBase.__len__s4;;r(r>cSnUcURnSnUGHn[U[R5(aOU(a[R "XBS9nO[R "U5nUR RU5 Mr[U[5(abUR H2nUR R[R"U55 M4 U(aURUlSnSnMM[U[R5(a=UR RU5 U(aURUlSnSnGMBGME[U[[45(aiU(a0UR R[R "XBS95 GMUR R[R "U55 GM[SU35e UR H nXlM U$)a This is the private append method called by .add and called by __init__. It differs from the public method in that a duration object can be passed in which is used for the first note of the chord or as many pitches as can use it -- it's all an optimization step to create as few duration objects as is necessary. Does not clear any caches. Also requires that notes be iterable. Changed in v9: incorrect arguments raise TypeError FNT)r;z!Could not process input argument )r;r@rPitchrNoterDappendr+copydeepcopyNotRestrAint TypeErrorr^)rJrKr? quickDurationrbnewNotes r)rHChordBase._add_core_or_inits}(  --K MA!U[[))"ii@G"iilG ""7+Ay)) xxGKK&&t}}W'=> ( $%JJDM"&K$)M!At||,, ""1% $%JJDM"&K$)M!ASz**KK&&tyy'IJKK&&tyy|4 "CA3 GHH;>A# r(c[R"U5(dU/nURUSS9 UR5 g)a1 Add a Note, Pitch, the `.notes` of another chord, or string representing a Pitch, or a list of any-of-the-above types to a Chord or PercussionChord. Does no sorting. That is on the Chord object. >>> c = chord.Chord('C4 E4 G4') >>> c.add('B3') >>> c >>> c.duration >>> c.add('A2', runSort=False) >>> c >>> c.add(['B5', 'C6']) >>> c >>> c.add(pitch.Pitch('D6')) >>> c >>> n = note.Note('E6') >>> n.duration.type = 'half' >>> c.add(n) >>> c >>> c.duration >>> c[-1] >>> c[-1].duration Fr>N)r isIterablerH clearCache)rJrKs r)add ChordBase.adds:T  ''GE u%8 r(c[U[5(axURH]n[US5(dMURR U:XdM2URR U5 UR5 g [S5e[U[R5(anURHSn[US5(dMURU:XdM(URR U5 UR5 g [S5e[U[R5(d[SUS35eURR U5 UR5 g![a [S5ef=f)a- Removes a note or pitch from the chord. Must be a pitch equal to a pitch in the chord or a string specifying the pitch name with octave or a note from a chord. If not found, raises a ValueError >>> c = chord.Chord('C4 E4 G4') >>> c.remove('E4') >>> c >>> c.remove('D5') Traceback (most recent call last): ValueError: Chord.remove(x), x not in chord >>> c = chord.Chord('C4 E4 G4') >>> c.remove(pitch.Pitch('E4')) >>> c >>> c.remove(pitch.Pitch('F#5')) Traceback (most recent call last): ValueError: Chord.remove(x), x not in chord The Note also does not need to be the exact note of the chord, just matches on equality >>> c = chord.Chord('C4 E4 G4') >>> c.remove(note.Note('E4')) >>> c >>> c.remove(c[1]) >>> c >>> c.remove(note.Note('B-2')) Traceback (most recent call last): ValueError: Chord.remove(x), x not in chord >>> c.remove(4) Traceback (most recent call last): ValueError: Cannot remove 4 from a chord; try a Pitch or Note object Like Python's list object, the remove method of chord does not take a list of strings. >>> c = chord.Chord('C4 E4 G4') >>> c.remove(['C4', 'E4']) Traceback (most recent call last): ValueError: Cannot remove ['C4', 'E4'] from a chord; try a Pitch or Note object rNzChord.remove(x), x not in chordzCannot remove z) from a chord; try a Pitch or Note object) r@rArDhasattrrnameWithOctaveremoverz ValueErrorrmrrr)rJ removeItemrbs r)rChordBase.remove0s=f j# & &[[q'**77))Z7KK&&q)OO% !>? ? j%++ . .[[1g&&177j+@KK&&q)OO% ! >? ?*dll33  ,UV  @ KK  z * OO  @>? ? @s +E66F c,[UR5$r5tuplerDrfs r)rKChordBase.notessT[[!!r(c`URHnURcMURs $ g)ak Get or set a single tie based on all the ties in this Chord. This overloads the behavior of the tie attribute found in all NotRest classes. If setting a tie, tie is applied to all pitches. >>> c1 = chord.Chord(['c4', 'g4']) >>> tie1 = tie.Tie('start') >>> c1.tie = tie1 >>> c1.tie >>> c1.getTie(c1.pitches[1]) NrDrrJds r)r ChordBase.ties*&Auu uu r(c6URH nXlM gr5r)rJvaluers r)rrsAEr(c([UR[R5(a UR$UR 5(d%[R"US9UlUR$/nUR HAnURR cMURURR 5 MC [R"US9nU(a.[[[U5[U5- 55UlX0lU$)a Get or set the :class:`~music21.volume.Volume` object for this Chord. When setting the .volume property, all pitches are treated as having the same Volume object. >>> c = chord.Chord(['g#', 'd-']) >>> c.volume >>> c.volume = volume.Volume(velocity=64) >>> c.volume.velocityIsRelative = False >>> c.volume * Changed in v8: setting volume to a list of volumes is no longer supported. See :meth:`~music21.chord.ChordBase.setVolumes` instead OMIT_FROM_DOCS Make sure that empty chords have a volume: >>> chord.Chord().volume )r`) r@_volumerVolumehasComponentVolumesrDvelocityrorsroundsumrQ)rJ velocitiesinner_n out_volumes r)rChordBase.volumes8 dllFMM 2 2<< ''))!==5DL<<  {{G~~&&2!!'.."9"9:#]]$/ "%eC Oc*o,M&N"OJ ! r(c[U[R5(a?XlURH nSUlM [ RRXSS9 g[R"U5(a8UR5nUS:a[U5Ul g[U5Ulg[!SU35e)NF setClientzunhandled setting expr: )r@rrr`rDrrrr _setVolumerisNum _getVolumefloatvelocityScalarrsrr)rJexprcvols r)rrs dFMM * *K[[  ! LL # #D% # @ \\$  //#Cax%*4[""4y  #;D6!BC Cr(cSnURHnUR5(dMUS- nM! U[UR5:Xagg)a Utility method to determine if this object has component :class:`~music21.volume.Volume` objects assigned to each note-component. >>> c1 = chord.Chord(['c4', 'd-1', 'g6']) >>> c1.setVolumes([60, 20, 120]) >>> [n.volume.velocity for n in c1] [60, 20, 120] >>> c1.hasComponentVolumes() True >>> c2 = chord.Chord(['c4', 'd-1', 'g6']) >>> c2.volume.velocity = 23 >>> c2.hasComponentVolumes() False >>> c3 = chord.Chord(['c4', 'd-1', 'g6']) >>> c3.setVolumes([0.2, 0.5, 0.8]) >>> [n.volume.velocity for n in c3] [25, 64, 102] >>> c4 = chord.Chord(['c4', 'd-1', 'g6']) >>> c4.volume = 89 >>> c4.volume.velocity 89 >>> c4.hasComponentVolumes() False rrTF)rDr_rQ)rJcountrs r)rChordBase.hasComponentVolumessK@A%%''  C $ $r(c`SUl[UR5Hup#X[U5-n[ U[ R 5(aUnOAUS:a[ R "[U5S9nO[ R "[U5S9nXl URUSS9 M g)a Set as many individual volumes as appear in volumes. If there are not enough volumes, then cycles through the list of volumes here: >>> c = chord.Chord(['g#', 'd-']) >>> c.setVolumes([volume.Volume(velocity=96), volume.Volume(velocity=96)]) >>> c.hasComponentVolumes() True Note that this means that the chord itself does not have a volume at this moment! >>> c.hasVolumeInformation() False >>> c.volume.velocity 96 But after having called the volume, now it does: >>> c.hasVolumeInformation() True >>> c.volume.velocityIsRelative = False >>> c.volume * New in v8: replaces setting .volume to a list Nr)r)rFr) r enumeraterDrQr@rrrrsr`r)rJvolumesirv_entryvs r) setVolumesChordBase.setVolumess@ dkk*DA#g,./G'6==11Q; U7^DA s7|jjjr-SS?jr.SS@jr/SSAjr0SSBjr1SSC.SDjr2\3SE5r4\3SF5r5\3SG5r6SHr7\3SSIj5r8\3SSJj5r9\3SSKj5r:SSC.SSLjjr;SSC.SSMjjr<\3SSNj5r=\3SSOj5r>\3SSPj5r?SSSQ.SSRjjr@SSSjrASTrB\3SU5rC\3SV5rDSSW.SSXjjrE\3SY5rF\3SZ5rGSSC.S[jrH\3SS\j5rISS.S]jrJSS.S^jrKSS.S_jrL\SS S`.SSajjj5rM\S S`.SSbjj5rMSS S`.SScjjjrM\SSd.SSejj5rN\S SSS'.SSfjj5rNS SSS'.SSgjjrNSShjrOSSijrPSjrQSkrRSlrSSSmjrTSSnjrUSS So.SpjrVSS.SqjrWSrrXSS.SsjrYStrZSS.Sujr[\\\3Sv55r]\\\3SSwj55r^\\SSxj5r_\_RSSyj5r_\\\3SSzj55ra\\S{5rb\\S|5rc\\S}5rd\\S~5re\\S5rf\\S5rg\\S5rh\\S5ri\\S5rj\\S5rk\\SSj5rl\lRSSj5rl\\\3S55rm\\S5rnSSjro\\SSj5rp\\SSj5rq\\SSj5rr\\SSj5rs\\SSj5rt\tRS5rt\\SSj5ru\\SSj5rv\vRSSj5rv\\SSj5rw\\SSj5rx\\\3S55ry\\S5rz\\\3S55r{\\\3SSj55r|Sr}U=r~$)riHaM Class representing Chords. A Chord functions like a Note object but has multiple pitches. Create chords by passing a list of strings of pitch names: >>> dMaj = chord.Chord(['D', 'F#', 'A']) >>> dMaj Pitch names can also include octaves: >>> dMaj = chord.Chord(['D3', 'F#4', 'A5']) >>> dMaj A single string with note names separated by spaces also works: >>> myChord = chord.Chord('A4 C#5 E5') >>> myChord Or you can combine already created Notes or Pitches: >>> cNote = note.Note('C') >>> eNote = note.Note('E') >>> gNote = note.Note('G') And then create a chord with note objects: >>> cmaj = chord.Chord([cNote, eNote, gNote]) >>> cmaj # default octave of 4 is used for these notes, since octave was not specified Or with pitches: >>> cmaj2 = chord.Chord([pitch.Pitch('C'), pitch.Pitch('E'), pitch.Pitch('G')]) >>> cmaj2 Chord has the ability to determine the root of a chord, as well as the bass note of a chord. In addition, Chord is capable of determining what type of chord a particular chord is, whether it is a triad or a seventh, major or minor, etc., as well as what inversion the chord is in. A chord can also be created from pitch class numbers: >>> c = chord.Chord([0, 2, 3, 5]) >>> c.pitches (, , , ) Or from MIDI numbers: >>> c = chord.Chord([72, 76, 79]) >>> c.pitches (, , ) (If the number is < 12, it is assumed to be an octaveless pitch-class number, if above 12, then a MIDI number. To create chords below MIDI 12, create a Pitch object with that MIDI number instead and then pass that to the Chord creator). Duration or quarterLength also works: >>> d = duration.Duration(2.0) >>> myChord = chord.Chord('A4 C#5 E5', duration=d) >>> myChord >>> myChord.duration >>> myChord.duration is d True >>> myChord = chord.Chord('A4 C#5 E5', quarterLength=3.75) >>> myChord.duration.type 'half' >>> myChord.duration.dots 3 OMIT_FROM_DOCS Test that durations are being created efficiently: >>> dMaj.duration >>> cmaj.pitches[0] is cNote.pitch True >>> cNote.duration >>> cmaj.duration >>> cmaj.duration is cNote.duration True Create a chord from two chords (or a chord + notes): >>> eFlatSixFive = chord.Chord('G3 B-3 D-4 E-4') >>> fFlat = chord.Chord('F-2 A-2 C-3 F-3') >>> riteOfSpring = chord.Chord([fFlat, eFlatSixFive]) >>> riteOfSpring Incorrect entries raise a TypeError: >>> chord.Chord([base]) Traceback (most recent call last): TypeError: Could not process input argument **Equality** Two chords are equal if the Chord passes all `super()` equality tests and all their pitches are equal (possibly in a different order) >>> c1 = chord.Chord('C4 E4 G4') >>> c2 = chord.Chord('E4 C4 G4') >>> c1 == c2 True >>> c3 = chord.Chord('E4 C#4 G4') >>> c2 == c3 False >>> n1 = note.Note('C4') >>> c1 == n1 False >>> c2.duration.quarterLength = 2.0 >>> c1 == c2 False >>> c1 != c2 True TpitchesisChordzj Boolean read-only value describing if this GeneralNote object is a Chord. Is Truer0r1Nc >Ub%[SU55(a[SU35e[TU] "SSU0UD6 U Ub([ SU55(aUR SS9 ggg)Nc3# UHKn[U[R5=(a% [U[R[45(+v MM g7fr5)r@r GeneralNoternrr6rbs r)r9!Chord.__init__..sF%5.3&043C3C%D&O-7DIIu;M-N)N&O.3sAA8Use a PercussionChord to contain Unpitched objects; got rKc3B# UHn[U[5v M g7fr5)r@rsrs r)r9rs$GAZ3%7%7sTinPlacer")rGrtrErFallsimplifyEnharmonicsrIs r)rFChord.__init__s  %5.3%5"5"5VW\V]^_ _ 1u11  $G$G!G!G  $ $T $ 2"H r(c>[TU]U5(dg[UR5[UR5:waggrO)rErPsetrrRs r)rP Chord.__eq__s5w~e$$ t|| EMM 2 2r(c >[TU]5$r5rVrXs r)rWChord.__hash__rZr(cSU<3n[U[5(aNSU;a9URSS5upSU;a[URS55nOU4nOSn[ U5nOSn[U[5(aUR UnGOZ[U[5(aMUR5nUR H"nURRU:XdMUn GO [U5e[U[R5(aWUR H nXaLdM Un O UR H!nURUR:XdMUn O [U5e[U[R5(aXUR HnURULdMUn O? UR HnURU:XdMUn O [U5e[U5eU(dU$UnUH%nUS:XaURUS9nM[!Xx5nM' U$![ a GNf=f![[4a [U5ef=f)a Get item makes accessing pitch components for the Chord easier >>> c = chord.Chord('C#4 D-4') >>> cSharp = c[0] >>> cSharp >>> c['0.step'] 'C' >>> c['3.accidental'] Traceback (most recent call last): KeyError: "Cannot access component with: '3.accidental'" >>> c[5] Traceback (most recent call last): KeyError: 'Cannot access component with: 5' >>> c['D-4'] >>> c['D-4.style.color'] is None True Getting by note does not do very much: >>> c[cSharp] But we can get from another note >>> cSharp2 = note.Note('C#4') >>> cSharp2.duration.quarterLength = 3.0 >>> c[cSharp2] is cSharp True >>> c[cSharp2] is cSharp2 False KeyError is raised if not in chord. >>> notInChord = note.Note('G') >>> c[notInChord] Traceback (most recent call last): KeyError: 'Cannot access component with: ' >>> c[None] Traceback (most recent call last): KeyError: 'Cannot access component with: None' zCannot access component with: .rr"r forceClient)r@rArBrrsrrDKeyError IndexErrorupperrrrrnrmrgetattr) rJkey keyErrorStrattrStr attributes foundNoterb currentValueattrs r) __getitem__Chord.__getitem__s)j7sg> c3  cz"yya0 '>!&w}}S'9!:J")J  #h J c3   , KK, S ! !))+C[[77))S0 !I! {++ TYY ' '[[8 !I! Aww#))+$% % #;// U[[ ) )[[77c> !I! Aww#~$% % #;//;' ' ' Dx+6646H &|: w  j) ,{++ ,s H%H6% H32H36Ic[U[5(aASU;a;URS5nSRUSS5nUSnXn[ XeU5 gXnUR R U5n[U[5(a[R"U5nO^[U[R5(a[R"US9nO*[U[R5(d [S5eX R U'g)a Change either a note in the chord components, or set an attribute on a component >>> c = chord.Chord('C4 E4 G4') >>> c[0] = note.Note('C#4') >>> c >>> c['0.octave'] = 3 >>> c >>> c['E4'] = 'F4' >>> c >>> c['G4.style.color'] = 'red' >>> c['G4.style.color'] 'red' >>> c[-1].style.color 'red' >>> c[0] = None Traceback (most recent call last): ValueError: Chord index must be set to a valid note object rrNrz.Chord index must be set to a valid note object) r@rArBjoinsetattrrDindexrrnrrmr)rJrrkeySplitkeyFindrkeyObjkeyIndexs r) __setitem__Chord.__setitem__s2 c3  C3Jyy~Hhhx"~.GBUR(d[TU] 5$/nURHnURUR5 M SR U5$)Nr3)rrE _reprInternalrorr)rJ allPitches thisPitchrLs r)rChord._reprInternalsP||7(* * I   i66 7&xx ##r(cS/nUH*n[R"U5nURU5 M, URS5 SRU5$)ao Return a string representation of a vector or set Static method. Works on the class: >>> chord.Chord.formatVectorString([0, 11]) '<0B>' or an existing chord: >>> c1 = chord.Chord(['D4', 'A4', 'F#5', 'D6']) >>> c1.formatVectorString(c1.normalOrder) '<269>' or on a list that has nothing to do with the chord >>> c1.formatVectorString([10, 11, 3, 5]) '' <>)rconvertPitchClassToStrror) vectorListmsgeeStrs r)formatVectorStringChord.formatVectorStringsL,eA//2D JJt  3wws|r(cjSnURH nUcUnM [R"X5nM" U$)a Returns the lowest Pitch in the chord. The only time findBass should be called is by bass() when it is figuring out what the bass note of the chord is. Generally call bass() instead: >>> cmaj = chord.Chord(['C4', 'E3', 'G4']) >>> cmaj._findBass() N)rrgetWrittenLowerNote)rJlowestrs r) _findBassChord._findBasss8I~"!55fH &  r(FrcU(d[R"U5nOUn/n/nURHUn[URU5U;a'UR [URU55 MDUR U5 MW URnUVs/sHn[ U5PM n nUH?nU R[ U55n URU 5 U RU 5 MA XslU(aUR5 U(dU$UVs/sHoRPM sn$s snfs snf)zz Common method for stripping pitches based on redundancy of one pitch attribute. The `attribute` is provided by a string. ) rprqrDrrroidrpoprz) rJ attributer returnObj uniquePitchesdeleteComponentscompalteredrb alteredIdnIndexs r) _removePitchByRedundantAttribute&Chord._removePitchByRedundantAttributes  d+II $$Dtzz9-]B$$WTZZ%CD ''- %""$+,GqRUG ,!A__RU+F KK  MM& !" #   " %56%5GG%56 6-7s D8 D=runSortc>[R"U5(dU/n[SU55(a[SU35e[TU]U5 U(aUR SS9 gg)a Add a Note, Pitch, the `.notes` of another chord, or string representing a pitch, or a list of any-of-the-above types to a Chord. If `runSort` is True (default=True) then after appending, the chord will be sorted. >>> c = chord.Chord('C4 E4 G4') >>> c.add('B3') >>> c >>> c.duration >>> c.add('A2', runSort=False) >>> c >>> c.add(['B5', 'C6']) >>> c >>> c.add(pitch.Pitch('D6')) >>> c >>> n = note.Note('E6') >>> n.duration.type = 'half' >>> c.add(n) >>> c >>> c.duration >>> c[-1] >>> c[-1].duration Overrides `ChordBase.add()` to permit sorting with `runSort`. c3V# UHn[U[R5v M! g7fr5)r@r Unpitchedrs r)r9Chord.add..Ms>> c1 = chord.Chord(['C2', 'E2', 'G2', 'C3']) >>> c2 = c1.annotateIntervals(inPlace=False) >>> c2.lyrics [, , ] >>> [ly.text for ly in c2.lyrics] ['8', '5', '3'] The `stripSpecifiers` parameter can be used to show only the intervals size (3, 5, etc.) or the complete interval specification (m3, P5, etc.) >>> c3 = c1.annotateIntervals(inPlace=False, stripSpecifiers=False) >>> c3.lyrics [, , ] >>> [ly.text for ly in c3.lyrics] ['P8', 'P5', 'M3'] This chord was giving us problems: >>> c4 = chord.Chord(['G4', 'E4', 'B3', 'E3']) >>> c4.annotateIntervals(inPlace=True, stripSpecifiers=False) >>> [ly.text for ly in c4.lyrics] ['m3', 'P8', 'P5'] >>> c4.annotateIntervals(inPlace=True, stripSpecifiers=False, returnList=True) ['m3', 'P8', 'P5'] If sortPitches is false it still gives problems: >>> c4 = chord.Chord(['G4', 'E4', 'B3', 'E3']) >>> c4.annotateIntervals(inPlace=True, stripSpecifiers=False, sortPitches=False) >>> [ly.text for ly in c4.lyrics] ['m3', 'm6', 'm3'] >>> c = chord.Chord(['c4', 'd-4', 'g4']) >>> c.annotateIntervals(inPlace=True) >>> [ly.text for ly in c.lyrics] ['5', '2'] >>> c = chord.Chord(['c4', 'd-4', 'g4']) >>> c.annotateIntervals(inPlace=True, stripSpecifiers=False) >>> [ly.text for ly in c.lyrics] ['P5', 'm2'] >>> c = chord.Chord(['c4', 'd---4', 'g4']) >>> c.annotateIntervals(inPlace=True, stripSpecifiers=False) >>> [ly.text for ly in c.lyrics] ['P5', 'dd2'] >>> c = chord.Chord(['c4', 'g5', 'e6']) >>> c.annotateIntervals(inPlace=True) >>> [ly.text for ly in c.lyrics] ['5', '3'] TrrrrF)reverseN)rprqremoveRedundantPitchesrrangerQrrIntervalsemiSimpleNamerAdiatonicgenericsemiSimpleUndirectedrosortaddLyric) rJrrrrr lyricsListjprnotations r)rrts T MM$     . !A s199~)1b1A ! A!!!))A,2A%'++qzz11FFG   h '2 { OODO )  "H h' 8$ # Hr(cz[R"UR5nUcgURSSUSS:Xagg)a Check if another Chord is a z-relation to this Chord. >>> c1 = chord.Chord(['C', 'c#', 'e', 'f#']) >>> c2 = chord.Chord(['C', 'c#', 'e-', 'g']) >>> c3 = chord.Chord(['C', 'c#', 'f#', 'g']) >>> c1.areZRelations(c2) True >>> c1.areZRelations(c3) False If there is no z-relation for the first chord, obviously return False: >>> c4 = chord.Chord('C E G') >>> c4.areZRelations(c3) False FrT)raddressToZAddresschordTablesAddress)rJrSzRelationAddresss r) areZRelationsChord.areZRelationssG&"33D4K4KL  #  # #Aa (,r?r@r(cU(Ga[U[5(a-[R"U5n[R "U5nOe[U[R 5(aUnOC[U[ R5(a URnO[S[U535eSnURH nXFLdM Sn O U(d3URH#nURUR:XdMUnSn O U(d3URH#nURUR:XdMSnUn O U(d2U(d[SUS35eU/SUR5Q7Ul X@RS'X@RS'SUR;a URS g SUR;aUSLaURS$USLag SUR;a URS USLaSUR;aURS$UR5URS'URS$) a Generally used to find and return the bass Pitch: >>> cmaj1stInv = chord.Chord(['C4', 'E3', 'G5']) >>> cmaj1stInv.bass() Subclasses of Chord often have basses that are harder to determine. >>> cmaj = harmony.ChordSymbol('CM') >>> cmaj.bass() >>> cmin_inv = harmony.ChordSymbol('Cm/E-') >>> cmin_inv.bass() Can also be used in rare occasions to set the bass note to a new Pitch, so long as that note is found in the chord: >>> strange_chord = chord.Chord('E##4 F-4 C5') >>> strange_chord.bass() >>> strange_chord.bass('F-4') >>> strange_chord.bass() If the note assigned to the bass is not found, it will default to raising a ChordException: >>> strange_chord.bass('G--4') Traceback (most recent call last): music21.chord.ChordException: Pitch G--4 not found in chord For the purposes of initializing from a ChordSymbol and in other cases, a new bass can be added to the chord by setting `allow_add = True`: >>> strange_chord.bass('G--4', allow_add=True) >>> strange_chord.bass() By default, if nothing has been overridden, this method uses a quick algorithm to find the bass among the chord's pitches, if no bass has been previously specified. If this is not intended, set find to False when calling this method, and 'None' will be returned if no bass is specified >>> em = chord.Chord(['E3', 'G3', 'B4']) >>> print(em.bass(find=False)) None * Changed in v8: raise an exception if setting a new bass to a pitch not in the chord, unless new keyword `allow_add` is `True`. OMIT_FROM_DOCS Test to make sure that cached basses still work by calling twice: >>> a = chord.Chord(['C4']) >>> a.bass() >>> a.bass() # After changing behavior uncomment these lines. # Setting a new bass note might be helpful to move it to a different # octave. Otherwise, it is likely just to lead to confusion and # hard to diagnose errors. # # >>> cmin_inv.bass('E-2') # >>> cmin_inv.bass() # # # To find the bass again from the pitches in the chord, set find=True # # >>> cmin_inv.bass(find=True) # # # Subsequent calls after an overridden bass has been cleared by find=True # will continue to return the algorithmically determined bass. # # >>> cmin_inv.bass() # znewbass should be a Pitch, not FTzPitch z not found in chordc3$# UHov M g7fr5r"r6r0s r)r9Chord.bass..s/H inversionN)r@rArcleanedFlatNotationrrmrrnrr<rrnamerC_cacher)rJr=r9r: newbassPitchfoundBassInChordr0s r)r>r? s| '3'' 44W=${{73 GU[[11& GTYY//&}} $'FtG}o%VWW&+ \\$'+$" $A''<+F+FF'( +/( & $Avv!2!22+/('(  & $ (6':M)NOO ,I/H4<>> gSeven = chord.Chord(['g', 'b', 'd', 'f']) >>> gSeven.canBeDominantV() True >>> gDim = chord.Chord(['g', 'b-', 'd-']) >>> gDim.canBeDominantV() False TF) isMajorTriadisDominantSeventhrfs r)canBeDominantVChord.canBeDominantVs'     $"8"8":":r(cZUR5(dUR5(agg)z Returns True if the chord is a major or minor triad: >>> a = chord.Chord(['g', 'b', 'd', 'f']) >>> a.canBeTonic() False >>> a = chord.Chord(['g', 'b', 'd']) >>> a.canBeTonic() True TF)rM isMinorTriadrfs r) canBeTonicChord.canBeTonics'     $"3"3"5"5r() forceOctaveleaveRedundantPitchescgr5r"rJrUrrVs r)closedPositionChord.closedPositionr@r(rUrrVcgr5r"rXs r)rYrZr@r(cU(aUnOR[R"U5n[R"U5UlXRlSURlUR 5nUbURnUc URnXa:aSnO Xa:aSnOSnUbhURU:waXURH6nURcURUlU=RU- slM8 URU:waMXURHnURcURUlURURS-:a4U=RS-slURURS-:aM4URUR:dMU=RS- slM USLaURSS9 URSS9 U(dU$g)a\ Returns a new Chord object with the same pitch classes, but now in closed position. If `forcedOctave` is provided, the bass of the chord will be shifted to that provided octave. If inPlace is True then the original chord is returned with new pitches. >>> chord1 = chord.Chord(['C#4', 'G5', 'E6']) >>> chord2 = chord1.closedPosition() >>> chord2 Force octave changes the octave of the bass note (and all notes above it) >>> c2 = chord.Chord(['C#4', 'G5', 'E6']) >>> c2.closedPosition(forceOctave=2) >>> c3 = chord.Chord(['C#4', 'G5', 'E6']) >>> c3.closedPosition(forceOctave=6) Redundant pitches are removed by default, but can be retained: >>> c4 = chord.Chord(['C#4', 'C5', 'F7', 'F8']) >>> c5 = c4.closedPosition(forceOctave=4, inPlace=False) >>> c5 >>> c6 = c4.closedPosition(forceOctave=4, inPlace=False, leaveRedundantPitches=True) >>> c6 Implicit octaves work fine: >>> c7 = chord.Chord(['A4', 'B4', 'A']) >>> c7.closedPosition(forceOctave=4, inPlace=True) >>> c7 OMIT_FROM_DOCS Very specialized fears: Duplicate octaves were not working >>> c7b = chord.Chord(['A4', 'B4', 'A5']) >>> c7b.closedPosition(inPlace=True) >>> c7b but the bass must remain A4: >>> c7c = chord.Chord(['A4', 'B4', 'A5', 'G##6']) >>> c7c.closedPosition(inPlace=True) >>> c7c >>> str(c7c.bass()) 'A4' Complex chord for semiclosed-position testing: >>> c8 = chord.Chord(['C3', 'E5', 'C#6', 'E-7', 'G8', 'C9', 'E#9']) >>> c8.closedPosition(inPlace=True) >>> c8 Implicit octave + forceOctave >>> c9 = chord.Chord('C G E') >>> c9.closedPosition(forceOctave=6) rYNrr Tr)rprqr Derivationoriginmethodr>octaveimplicitOctaverpsdiatonicNoteNumr%r) rJrUrrVrpBass pBassOctavedifr0s r)rYrZsh I d+I#-#8#8#CI *. '*:I '   ",,K"#22 (*llk1&..88+'('7'7AHC/llk1""Axx++$$%((R-'A $$%((R-'  5#8#88A # ! ,  , ,T , : - r(cLUR5(dgURcgg)a Returns True if the chord contains at least one of each of Third, Fifth, and Seventh. raises an exception if the Root can't be determined A ninth chord contains a seventh: >>> c9 = chord.Chord(['C4', 'E4', 'G4', 'B4', 'D5']) >>> c9.containsSeventh() True As does a cluster: >>> cluster = chord.Chord('C D E F G A B') >>> cluster.containsSeventh() True But a major triad does not: >>> dMaj = chord.Chord([pitch.Pitch('D4'), pitch.Pitch('F#4'), pitch.Pitch('A5')]) >>> dMaj.containsSeventh() False Note that a seventh chord itself contains a seventh. >>> cChord = chord.Chord(['C', 'E', 'G', 'B']) >>> cChord.containsSeventh() True Empty chord returns False >>> chord.Chord().containsSeventh() False FT) containsTriadseventhrfs r)containsSeventhChord.containsSeventhes'F!!## << r(c<URcgURcgg)a Returns True or False if there is no triad above the root. "Contains vs. Is": A dominant-seventh chord contains a triad. >>> cChord = chord.Chord(['C', 'E', 'G']) >>> other = chord.Chord(['C', 'D', 'E', 'F', 'G']) >>> cChord.containsTriad() True >>> other.containsTriad() True >>> scale = chord.Chord(['C', 'D-', 'E', 'F#', 'G', 'A#', 'B']) >>> scale.containsTriad() True >>> c = chord.Chord('C4 D4') >>> c.containsTriad() False >>> chord.Chord().containsTriad() False FT)thirdfifthrfs r)rjChord.containsTriads!2 ::  :: r(cfSn[RRSUR5SS9n[ U5nU(d[ SU<35eUS:XaUR S$US:XaUR5$UVs0sH!n[RURU_M# nn[U5n[U5HFnS nXgn U n [US-Xs-5Hn X-n Xln X- S ;aS n OU n M U(dMBXYs $ /nS nUHwn/n[RURn UH6nU U-S- S-U;aURS 5 M%URS 5 M8 U"U5nURU5 My UR[U55nUU$s snf) z Looks for the root usually by finding the note with the most 3rds above it. Generally use root() instead, since if a chord doesn't know its root, root() will run ._findRoot() automatically. cVSn[U5Hup#USLdM USUS-- - nM U$)a Returns a value for how likely this pitch is to be a root given the number of thirds and fifths above it. Takes a list of True's and False's where each value represents whether a note has a 3rd, 5th, 7th, 9th, 11th, and 13th above it and calculates a value based on that. The highest score on rootnessFunction is the root. This formula might be tweaked if wrong notes are found. Rootness function might be divided by the inversion number in case that's a problem. rTr)r) rootThirdListscore root_indexvals r)rootnessFunction)Chord._findRoot..rootnessFunctions;E#,]#; $;Q*q.11E$<Lr(c38# UHoRv M g7fr5rrs r)r9"Chord._findRoot..s3Q[GG[cUR$r5step)pps r)!Chord._findRoot..s"''r(rzno pitches in chord rrT)F)r3rrrt)rmiscuniquerDrQrrr>rSTEP_TO_DNN_OFFSETrsortedr&rormax)rJrynonDuplicatingPitches lenPitchesr0stepNumsToPitchesstepNums startIndexall_are_thirds this_step_num last_step_numendIndex endIndexMod endStepNumrootnessFunctionScoresorderedChordStepscurrentListOfThirds chordStepTest rootnessScoremostRootyIndexs r) _findRootChord._findRoots 4!' 2 23QT[[3Q7I!3!K./  #7x!@A A ?<<? " 1_99; ?T5U>S6;5M5Maff5UWX5X>S 5U+, +J!N$0M)M!*q.*2IJ&3 %2 -W<%*N * K~(77,&"$.&A"$ !44QVVOO'..t4'..u5 "3 --@AM " ) )- 8'055c:P6QR$^44W5Us(F.c@/n[[UR55H+nURURUR5 M- [ U5nUS/n[S[U55H%nX2X2S- :wdMURX25 M' /n[S[U55H#nXBXBS- - S-nURU5 M% URUSUS- S-5 /n[S[U55HAnUR S5nURU5 [U5n URU 5 MC [ U5n U Sn /n Sn [S[U 55HnU RU 5 XU- n M U $)ab Geometric Normal Form, as first defined by Dmitri Tymoczko, orders pitch classes such that the spacing is prioritized with the smallest spacing between the first and second pitch class first, then the smallest spacing between second and third pitch class, and so on. This form has unique properties that make it useful. It also transposes to PC0 `geometricNormalForm` returns a list of pitch class integers in geometric normal form. Example 1: A major triad has geometricNormalForm of 038 not 047. >>> c1 = chord.Chord('E4 C5 G6 C7') >>> pcList = c1.geometricNormalForm() >>> pcList [0, 3, 8] >>> c2 = chord.Chord(pcList) >>> c2.orderedPitchClassesString '<038>' Compare this to the usual normalOrder transposed to PC0: >>> normalOrder = c1.normalOrder >>> normalOrderFirst = normalOrder[0] >>> [(pc - normalOrderFirst) % 12 for pc in normalOrder] [0, 4, 7] rrr^r)r&rQrro pitchClassrrr)rJpitchClassListrsortedPitchClassListuniquePitchClassList intervalListlPC rotationListb intervalTuplenewRotationList geomNormChordgeomNormChordPitches intervalSums r)geometricNormalFormChord.geometricNormalForm s>s4<<()A  ! !$,,q/"<"< =*%n5 4Q 78q#234A#&*>1u*EE$++,@,CD5 q#234A'*-Aa%-HHBNC    $5 1!47KB7OOSUUV q#l+,A  #A    "!,/M    . -!.'*  " q#m,-A ' ' 4 + +K.$#r(testRootcUS:aUS-nUcUR5nUc [S5eOe[U[R5(a UR nO9[U[ R 5(aUnO[S[U535eURnURH!nURU- S-S-nXa:XdMUs $ g)a Returns the (first) pitch at the provided scaleDegree (Thus, it's exactly like semitonesFromChordStep, except it instead of the number of semitones.) Returns None if none can be found. >>> cmaj = chord.Chord(['C', 'E', 'G']) >>> cmaj.getChordStep(3) # will return the third of the chord >>> g = cmaj.getChordStep(5) # will return the fifth of the chord >>> g.name 'G' >>> cmaj.getChordStep(6) is None True Ninths can be specified with either 9 or 2. Similarly for elevenths and thirteenths. >>> c9 = chord.Chord('C4 E4 G4 B4 D5') >>> c9.getChordStep(9) >>> c9.getChordStep(2) OMIT_FROM_DOCS If `root` has been explicitly overridden as `None`, calling this raises `ChordException`: >>> cmaj._overrides['root'] = None >>> cmaj.getChordStep(6) Traceback (most recent call last): music21.chord.ChordException: Cannot run getChordStep without a root (This is in OMIT_FROM_etc.) rNz&Cannot run getChordStep without a rootz testRoot should be a Pitch, not r) rootrr@rrnrrmr<rer)rJ chordStepr testRootPitchrootDNNrdiatonicDistances r) getChordStepChord.getChordStepMsX > NI   IIKM$$%MNN% $)) , ,$NNM %++ . .$M #CDNCS!TU U//I!*!:!:W!D IQN ,  &r(cB[U[5(a[R"U5nURHVnURULdMUR (dM'UR RcM@UR Rs $ URHWnURU:XdMUR (dM(UR RcMAUR Rs $ UR (aUR R$g)aB For a pitch in this Chord, return the color stored in self.editorial, or, if set for each component, return the color assigned to this component. First checks for "is" then "equals" >>> p = pitch.Pitch('C4') >>> n = note.Note(p) >>> n.style.color = 'red' >>> c = chord.Chord([n, 'E4']) >>> c.getColor(p) 'red' >>> c.getColor('C4') 'red' >>> c.getColor('E4') is None True The color of any pitch (even a non-existing one) is the color of the chord if the color of that pitch is not defined. >>> c.style.color = 'pink' >>> c.getColor('E4') 'pink' >>> c.getColor('D#7') 'pink' N)r@rArrmrDhasStyleInformationstylecolor)rJ pitchTargetrbs r)getColorChord.getColors@ k3 ' '++k2KAww+%(((QWW]]-F77==(Aww+%(((QWW]]-F77==(  # #::## #r(c[US5(a URnURH nURULdMURs $ URH!nURU:XdMURs $ g)a Given a pitch in this Chord, return an associated notehead attribute, or return 'normal' if not defined for that Pitch. If the pitch is not found, None will be returned. >>> n1 = note.Note('D4') >>> n2 = note.Note('G4') >>> n2.notehead = 'diamond' >>> c1 = chord.Chord([n1, n2]) >>> c1.getNotehead(c1.pitches[1]) 'diamond' >>> c1.getNotehead(c1.pitches[0]) 'normal' >>> c1.getNotehead(pitch.Pitch('A#6')) is None True Will work if the two notes are equal in pitch >>> c1.getNotehead(note.Note('G4')) 'diamond' rN)r~rrDnoteheadrJr0rs r) getNoteheadChord.getNoteheadsg2 1g  AAww!|zz!Aww!|zz!r(c[US5(a URnURH nURULdMURs $ URH!nURU:XdMURs $ g)aC Given a pitch in this Chord, return an associated noteheadFill attribute, or return None if not defined for that Pitch. If the pitch is not found, None will also be returned. >>> n1 = note.Note('D4') >>> n2 = note.Note('G4') >>> n2.noteheadFill = True >>> c1 = chord.Chord([n1, n2]) >>> c1.getNoteheadFill(c1.pitches[1]) True >>> print(c1.getNoteheadFill(c1.pitches[0])) None >>> c1.getNoteheadFill(pitch.Pitch('A#6')) is None True Will work if the two notes are equal in pitch >>> c1.getNoteheadFill(note.Note('G4')) True Returns None if the pitch is not in the Chord: rN)r~rrD noteheadFillrs r)getNoteheadFillChord.getNoteheadFillsg8 1g  AAww!|~~%Aww!|~~%r(c[US5(a URnURH nURULdMURs $ URH!nURU:XdMURs $ g)aa Given a pitch in this Chord, return an associated stem attribute, or return 'unspecified' if not defined for that Pitch or None. If the pitch is not found, None will be returned. >>> n1 = note.Note('D4') >>> n2 = note.Note('G4') >>> n2.stemDirection = 'double' >>> c1 = chord.Chord([n1, n2]) >>> c1.getStemDirection(c1.pitches[1]) 'double' >>> c1.getStemDirection(c1.pitches[0]) 'unspecified' Will work if the two pitches are equal in pitch >>> c1.getStemDirection(note.Note('G4')) 'double' Returns None if a Note or Pitch is not in the Chord >>> c1.getStemDirection(pitch.Pitch('A#4')) is None True rN)r~rrD stemDirectionrs r)getStemDirectionChord.getStemDirection sg8 1g  AAww!|&Aww!|&r(c@XR$![a gf=f)a Given a pitch in this Chord, return an associated Tie object, or return None if not defined for that Pitch. >>> c1 = chord.Chord(['d', 'e-', 'b-']) >>> t1 = tie.Tie('start') >>> c1.setTie(t1, c1.pitches[2]) # just to b- >>> c1.getTie(c1.pitches[2]) == t1 True >>> c1.getTie(c1.pitches[0]) is None True All notes not in chord return None >>> c1.getTie(pitch.Pitch('F#2')) is None True >>> c1.getTie('B-') N)rr)rJr0s r)getTie Chord.getTie1s%, 7;;   s  cbXnURUS9$![a [SU35ef=f)a For a given Pitch in this Chord, return the :class:`~music21.volume.Volume` object. Raises an exception if the pitch isn't in the chord (TODO: consider changing to be like notehead, etc.) >>> c = chord.Chord('C4 F4') >>> c[0].volume = 2 >>> c.getVolume('C4') >>> c.getVolume('F4') # default >>> c.getVolume('G4') Traceback (most recent call last): music21.chord.ChordException: the given pitch is not in the Chord: G4 r%the given pitch is not in the Chord: )rrr)rJr0rbs r) getVolumeChord.getVolumeLsD( NA<>> chord.fromIntervalVector((1, 1, 1, 1, 1, 1)) >>> chord.fromIntervalVector((1, 1, 1, 1, 1, 1)).getZRelation() Z relation will always be zero indexed: >>> c = chord.Chord('D D# F# G#') >>> c.getZRelation() >>> chord.Chord('C E G').getZRelation() is None True N) hasZRelationr5raddressToIntervalVectorintervalVectorToAddress forteClassaddressToTransposedNormalFormr)rJr5r addressesrS thisAddressprimes r) getZRelationChord.getZRelationgs&   !%!8!8 ../ABA66q9IE( ))-?-J-JJ'E )88?E< r(c[UR55[[SUR555:wagg)at Returns True if for any given pitchClass there is at most one spelling of the note (in any octave). >>> cChord = chord.Chord('C4 E4 G4 C5') >>> cChord.hasAnyEnharmonicSpelledPitches() False Notice that having a C in two different octaves is no problem. However, this is False: >>> cChord = chord.Chord('C4 E4 G4 B#4') >>> cChord.hasAnyEnharmonicSpelledPitches() True c38# UHoRv M g7fr5rHrDs r)r97Chord.hasAnyEnharmonicSpelledPitches..s8VAr}TF)rQ_unorderedPitchClassesrrrfs r)hasAnyEnharmonicSpelledPitches$Chord.hasAnyEnharmonicSpelledPitchess4 t**, -S8V8V5V1W Wr(c[[SUR555[[SUR555:wagg)a0 Returns True if for any diatonic note (e.g., C or C# = C) there are two or more different notes (such as E and E-) in the chord. If there are no repeated scale degrees, return False. >>> cChord = chord.Chord(['C', 'E', 'E-', 'G']) >>> cChord.hasAnyRepeatedDiatonicNote() True This routine is helpful for anything that works with Generic intervals and chord steps such as `.third` which makes sure that checking for root, second, third, ..., seventh will actually find all the different notes. This following example returns False because chromatically identical notes of different scale degrees do not count as a repeated diatonic note. (See :meth:`~music21.chord.Chord.hasAnyEnharmonicSpelledPitches` for that method) >>> other = chord.Chord(['C', 'E', 'F-', 'G']) >>> other.hasAnyRepeatedDiatonicNote() False c38# UHoRv M g7fr5rrDs r)r93Chord.hasAnyRepeatedDiatonicNote..s0>> cChord = chord.Chord(['G2', 'E4', 'E-5', 'C6']) >>> cChord.hasRepeatedChordStep(3) True >>> cChord.hasRepeatedChordStep(5) False z.Cannot run hasRepeatedChordStep without a rootrTF) rrintervalFromChordSteprrr'r)r*mod7 chromaticmod12)rJrrfirstr thisIntervals r)hasRepeatedChordStepChord.hasRepeatedChordSteps  yy{H$%UVV**95I#,,XAL$$,,11Y>))//%//2G2GG1L & r(cUcUR5nUc [S5eURHAn[R"X#5nUR R RU:XdM?Us $ g![a [S5ef=f)a Exactly like semitonesFromChordStep, except it returns the interval itself instead of the number of semitones: >>> cmaj = chord.Chord(['C', 'E', 'G']) >>> cmaj.intervalFromChordStep(3) # will return the interval between C and E >>> cmaj.intervalFromChordStep(5) # will return the interval between C and G >>> print(cmaj.intervalFromChordStep(6)) None Nz/Cannot run intervalFromChordStep without a root)rrrrr'r)r*r)rJrrrrs r)rChord.intervalFromChordSteps   X99;$%VWWI#,,XAL$$,,11Y>##&" X$%VWW Xs A55B )r9rtransposeOnSetcgr5r"rJ newInversionr9rrs r)rFChord.inversionr r(cgr5r"rs r)rFr r r(cUR(dgUbUnOUR5nUb[U5nURXeU5 gSUR;aU(dUb(UbUR5cgURU5$SUR;aURS$g![[4a [ S[ U535ef=f![ a [ S5ef=f)ah Find the chord's inversion or (if called with a number) set the chord to the new inversion. When called without a number argument, returns an integer (or None) representing which inversion (if any) the chord is in. The Chord does not have to be complete, in which case this function determines the inversion by looking at the relationship of the bass note to the root. Returns a maximum value of 5 for the fifth inversion of a thirteenth chord. Returns 0 if the bass to root interval is a unison or if interval is not a common inversion (1st-5th). The octave of the bass and root are irrelevant to this calculation of inversion. Returns None if the Chord has no pitches. >>> g7 = chord.Chord(['g4', 'b4', 'd5', 'f5']) >>> g7.inversion() 0 >>> g7.inversion(1) >>> g7 With implicit octaves, D becomes the bass (since octaves start on C): >>> g7_implicit = chord.Chord(['g', 'b', 'd', 'f']) >>> g7_implicit.inversion() 2 Note that in inverting a chord with implicit octaves, some pitches will gain octave designations, but not necessarily all of them (this behavior might change in the future): >>> g7_implicit.inversion(1) >>> g7_implicit Examples of each inversion: >>> cTriad1stInversion = chord.Chord(['E1', 'G1', 'C2']) >>> cTriad1stInversion.inversion() 1 >>> cTriad2ndInversion = chord.Chord(['G1', 'E2', 'C2']) >>> cTriad2ndInversion.inversion() 2 >>> dSeventh3rdInversion = chord.Chord(['C4', 'B4']) >>> dSeventh3rdInversion.bass(pitch.Pitch('B4')) >>> dSeventh3rdInversion.inversion() 3 >>> gNinth4thInversion = chord.Chord(['G4', 'B4', 'D5', 'F5', 'A4']) >>> gNinth4thInversion.bass(pitch.Pitch('A4')) >>> gNinth4thInversion.inversion() 4 >>> bbEleventh5thInversion = chord.Chord(['B-', 'D', 'F', 'A', 'C', 'E-']) >>> bbEleventh5thInversion.bass(pitch.Pitch('E-4')) >>> bbEleventh5thInversion.inversion() 5 Repeated notes do not affect the inversion: >>> gMajRepeats = chord.Chord(['G4', 'B5', 'G6', 'B6', 'D7']) >>> gMajRepeats.inversion(2) >>> gMajRepeats >>> gMajRepeats.inversion(3) Traceback (most recent call last): music21.chord.ChordException: Could not invert chord: inversion may not exist If testRoot is True then that temporary root is used instead of self.root(). Get the inversion for a seventh chord showing different roots >>> dim7 = chord.Chord('B4 D5 F5 A-5 C6 E6 G6') >>> dim7.inversion() 0 >>> dim7.inversion(testRoot=pitch.Pitch('D5')) 6 >>> dim7.inversion('six-four') Traceback (most recent call last): music21.chord.ChordException: Inversion must be an integer, got: Chords without pitches or otherwise impossible chords return -1, indicating no normal inversion. >>> chord.Chord().inversion(testRoot=pitch.Pitch('C5')) -1 For Harmony subclasses, this method does not check to see if the inversion is reasonable according to the figure provided. see :meth:`~music21.harmony.ChordSymbol.inversionIsValid` for checker method on ChordSymbolObjects. If only two pitches given, an inversion is still returned, often as if it were a triad: >>> chord.Chord('C4 G4').inversion() 0 >>> chord.Chord('G4 C5').inversion() 2 If transposeOnSet is False then setting the inversion simply sets the value to be returned later, which might be useful for cases where the chords are poorly spelled, or there is an added note. * Changed in v8: deal with chords without pitches rNz#Inversion must be an integer, got: rFzNot a normal inversion) rrrsrrtrr< _setInversionrCr>_findInversion)rJrr9rr rootPitchint_newInversions r)rFr sn||   I I  # a#&|#4    /N K0Th>R ?$ (;)< &&y1 1 DOO +??;/ / * a$'J4P\K]J^%_`` a" ?$%=>> ?s B-&C-(CC.cUSLaXRS'g[UR5S-nUnSUR;a URS SUR;a URS URSS9nXe:waUS:a[ UR5R nUR 5nUR U:aIURbU=RS - slOURS -UlUR U:aMIUR5 URSS9nUS -nXe:waUS:aMUS:Xa [S 5eURSS 9 g) z$ Helper function for inversion(int) FrFNrr>Tr9rrz/Could not invert chord: inversion may not existr) rCrQrrFrrdr>rbrcrzrr) rJrrrnumberOfRunsBeforeCrashingsoughtInversioncurrentInversioncurrentMaxMidi tempBassPitchs r)rChord._setInversion sQ U "+7OOK ( %(%6%:"& $// ) , T__ $'>>t>416PST6T .11N IIKM""^3 ''3!((A-(+8+G+G!+KM(  ""^3 OO #~~4~8  &! + &16PST6T & * !RS S 4(r(cv[R"UR55nSUl[R"U5nSUl[R "UU5R nUS:XaSnO8US:XaSnO/US:XaSnO&US:XaSnOUS:XaSnOUS:XaSnO US:XaSnOS nXPRS 'U$) z" Helper function for .inversion() rrrrtrr3rrrrF)rprqr>rbrnotesToGenericsimpleDirectedrI)rJrr  tempRootPitch bassToRootinvs r)rChord._findInversion s  diik2   i0  ,,]-:<>> a = chord.Chord(['G3', 'B3', 'F3', 'D3']) >>> a.inversionName() 43 Nr)rA+*)r!rt@rr3z&Not a normal inversion for a seventh: rz$Not a normal inversion for a triad: z3Not a triad or Seventh, cannot determine inversion.)rFr isSeventhrkisTriad)rJrseventhMapping triadMappings r) inversionNameChord.inversionName s .."C "9(" >>  t||7C}1}%**%'McW%UVV \\^^C}1}#((%'KC7%STT !VW W)  sB'' B43B4cSnUR5nUS:XaU$US:Xag[RRUS-$![a Us$f=f)aL A helper method to return a readable inversion text (with capitalization) for a chord: >>> chord.Chord('C4 E4 G4').inversionText() 'Root Position' >>> chord.Chord('E4 G4 C5').inversionText() 'First Inversion' >>> chord.Chord('B-3 C4 E4 G4').inversionText() 'Third Inversion' >>> chord.Chord().inversionText() 'Unknown Position' zUnknown Positionrrz Root Positionz Inversion)rFrr numberToolsordinals)rJUNKNOWNrs r) inversionTextChord.inversionText sd% .."C "9N !8"!!**3/,>> N sA AApermitAnyInversioncURnUS:XaURUS9(agUS:Xa?URUS9(agURUS9(agUR US9(agg)a  returns True if the chord is an Augmented 6th chord in normal inversion. (that is, in first inversion for Italian and German and second for French and Swiss) >>> c = chord.Chord(['A-3', 'C4', 'E-4', 'F#4']) >>> c.isAugmentedSixth() True Spelling matters >>> c.pitches[3].getEnharmonic(inPlace=True) >>> c >>> c.isAugmentedSixth() False Italian: >>> c = chord.Chord(['A-3', 'C4', 'F#4']) >>> c.isAugmentedSixth() True If `permitAnyInversion` is True then any inversion is allowed. r3r&TrF)pitchClassCardinalityisItalianAugmentedSixthisFrenchAugmentedSixthisGermanAugmentedSixthisSwissAugmentedSixth)rJr' cardinalitys r)isAugmentedSixthChord.isAugmentedSixth1 su:00 !  < P*Q,,@R,S++?Q+Rr(c(URSSS5$)ax Returns True if chord is an Augmented Triad, that is, if it contains only notes that are either in unison with the root, a major third above the root, or an augmented fifth above the root. Additionally, the Chord must contain at least one of each third and fifth above the root. The chord might not seem to need to be spelled correctly since incorrectly spelled Augmented Triads are usually augmented triads in some other inversion (e.g. C-E-Ab is a second-inversion augmented triad; C-Fb-Ab is in first inversion). However, B#-Fb-Ab does return False as it is not a stack of two major thirds in any inversion. Returns False if is not an augmented triad. >>> c = chord.Chord(['C4', 'E4', 'G#4']) >>> c.isAugmentedTriad() True >>> c = chord.Chord(['C4', 'E4', 'G4']) >>> c.isAugmentedTriad() False Other spellings will give other roots! >>> c = chord.Chord(['C4', 'E4', 'A-4']) >>> c.isAugmentedTriad() True >>> c.root() >>> c = chord.Chord(['C4', 'F-4', 'A-4']) >>> c.isAugmentedTriad() True >>> c = chord.Chord(['B#4', 'F-4', 'A-4']) >>> c.isAugmentedTriad() False >>> chord.Chord().isAugmentedTriad() False )r3r^rrr_checkTriadTyperfs r)isAugmentedTriadChord.isAugmentedTriad[ sX##J155r(cURSS9n[UR5S:Xag[UR5S:Xa`UR5nUR SS9n[ R "URSURS5nUR5$[UR5S:Xa<UR5SLdUR5SLaUR5S:waggg)a Returns True if the chord is: * one pitch (always consonant) * two pitches: uses :meth:`~music21.interval.Interval.isConsonant()` , which checks if the interval is a major or minor third or sixth or perfect fifth. * three pitches: if chord is a major or minor triad not in second inversion. These rules define all common-practice consonances (and earlier back to about 1300 all imperfect consonances) >>> c1 = chord.Chord(['C3', 'E4', 'G5']) >>> c1.isConsonant() True >>> c2 = chord.Chord(['G3', 'E-4', 'C5']) >>> c2.isConsonant() False >>> c3 = chord.Chord(['F2', 'A2', 'C3', 'E-3']) >>> c3.isConsonant() False >>> c4 = chord.Chord(['C1', 'G1', 'C2', 'G2', 'C3', 'G3']) >>> c4.isConsonant() True >>> c5 = chord.Chord(['G1', 'C2', 'G2', 'C3', 'G3']) >>> c5.isConsonant() False >>> c6 = chord.Chord(['F#']) >>> c6.isConsonant() True >>> c7 = chord.Chord(['C1', 'C#1', 'D-1']) >>> c7.isConsonant() False Spelling does matter: >>> c8 = chord.Chord(['D-4', 'G#4']) >>> c8.isConsonant() False >>> c9 = chord.Chord(['D3', 'A2', 'D2', 'D2', 'A4']) >>> c9.isConsonant() True >>> c10 = chord.Chord(['D3', 'A2', 'D2', 'D2', 'A1']) >>> c10.isConsonant() False >>> c11 = chord.Chord(['F3', 'D4', 'A4']) >>> c11.isConsonant() True >>> c12 = chord.Chord(['F3', 'D4', 'A4', 'E#4']) >>> c12.isConsonant() False OMIT_FROM_DOCS Weird things used to happen when some notes have octaves and some don't: >>> c13 = chord.Chord(['A4', 'B4', 'A']) >>> c14 = c13.removeRedundantPitchNames(inPlace=False) >>> c14 >>> i14 = interval.Interval(c14.pitches[0], c14.pitches[1]) >>> i14 >>> i14.isConsonant() False >>> c13.isConsonant() False FrrTrrr3) removeRedundantPitchNamesrQrrYr%rr' isConsonantrMrRrF)rJc2c3c4rs r)r8Chord.isConsonant sl + +E + : rzz?a  _ !$$&B**5*9B!!"**Q-A?A==? " _ !""$,0A0A0Ct0K)Q.r(c$URS5$)a Returns True if chord is a Diminished Seventh, that is, if it contains only notes that are either in unison with the root, a minor third above the root, a diminished fifth, or a minor seventh above the root. Additionally, must contain at least one of each third and fifth above the root. Chord must be spelled correctly. Otherwise returns false. >>> a = chord.Chord(['c', 'e-', 'g-', 'b--']) >>> a.isDiminishedSeventh() True >>> chord.Chord().isDiminishedSeventh() False )rr3rt isSeventhOfTyperfs r)isDiminishedSeventhChord.isDiminishedSeventh s$##L11r(cUR5(dgUR5nURH5n[R"X#5nUR R U;dM5 g g)aP Returns True if chord is a seventh chord of a particular type as specified by intervalArray. For instance `.isDiminishedSeventh()` is just a thin wrapper around `.isSeventhOfType([0, 3, 6, 9])` and `isDominantSeventh()` has intervalArray([0, 4, 7, 10]) intervalArray can be any iterable. Though it checks on intervalArray, it does make sure that it is a seventh chord, not D--, D##, G, B- >>> chord.Chord('C E G B-').isSeventhOfType((0, 4, 7, 10)) True >>> chord.Chord('C E G B-').isSeventhOfType((0, 3, 7, 10)) False >>> chord.Chord('D-- D## G B-').isSeventhOfType((0, 4, 7, 10)) False FT)rrrrr'rr)rJ intervalArrayrrrs r)r@Chord.isSeventhOfType sY&~~yy{I#,,T=L%%++=@&r(c(URSSS5$)a Returns True if chord is a Diminished Triad, that is, if it contains only notes that are either in unison with the root, a minor third above the root, or a diminished fifth above the root. Additionally, must contain at least one of each third and fifth above the root. Chord must be spelled correctly. Otherwise returns false. >>> cChord = chord.Chord(['C', 'E-', 'G-']) >>> cChord.isDiminishedTriad() True >>> other = chord.Chord(['C', 'E-', 'F#']) >>> other.isDiminishedTriad() False OMIT_FROM_DOCS >>> chord.Chord().isDiminishedTriad() False >>> other = chord.Chord(['C', 'E-', 'F#', 'G-']) >>> other.isDiminishedTriad() False This is in an OMIT section )r3 rr3rtr2rfs r)isDiminishedTriadChord.isDiminishedTriad# s8##J155r(c$URS5$)a Returns True if chord is a Dominant Seventh, that is, if it contains only notes that are either in unison with the root, a major third above the root, a perfect fifth, or a major seventh above the root. Additionally, must contain at least one of each third and fifth above the root. Chord must be spelled correctly. Otherwise returns false. >>> a = chord.Chord(['b', 'g', 'd', 'f']) >>> a.isDominantSeventh() True >>> chord.Chord().isDominantSeventh() False >>> c2 = chord.Chord('C4 E4 G4 A#4') >>> c2.isDominantSeventh() False )rrrrGr?rfs r)rNChord.isDominantSeventhA s,##M22r(c&URSSS:H$)a Returns True if chord is a Diminished Seventh, that is, if it contains only notes that are either in unison with the root, a minor third above the root, a diminished fifth, or a diminished seventh above the root. Additionally, must contain at least one of each third and fifth above the root. Chord MAY BE SPELLED INCORRECTLY. Otherwise returns False. >>> c = chord.Chord('C D# G- A') >>> c.isFalseDiminishedSeventh() True >>> chord.Chord().isFalseDiminishedSeventh() False >>> chord.Chord('C4 E4 G4').isFalseDiminishedSeventh() False Correctly spelled diminished seventh chords are also false diminished sevenths. >>> chord.Chord('C4 E-4 G-4 B--4').isFalseDiminishedSeventh() True Nr3)rr)r5rfs r)isFalseDiminishedSeventhChord.isFalseDiminishedSeventhY s6&&r*j88r(c.URSSU/SQ5$)a3 Returns True if the chord is a French augmented sixth chord (flat 6th scale degree in bass, tonic, second scale degree, and raised 4th). N.B. The root() method of music21.chord.Chord determines the root based on the note with the most thirds above it. However, under this definition, a 1st-inversion french augmented sixth chord resembles a second inversion chord, not the first inversion subdominant chord it is based upon. We fix this by adjusting the root. First, however, we check to see if the chord is in second inversion to begin with, otherwise it is not a Fr+6 chord. This is to avoid ChordException errors. >>> fr6a = chord.Chord(['A-3', 'C4', 'D4', 'F#4']) >>> fr6a.isFrenchAugmentedSixth() True Spelling matters: >>> fr6b = chord.Chord(['A-3', 'C4', 'D4', 'G-4']) >>> fr6b.isFrenchAugmentedSixth() False >>> fr6b = chord.Chord(['A-3', 'C4', 'E--4', 'F#4']) >>> fr6b.isFrenchAugmentedSixth() False Inversion matters: >>> fr6c = chord.Chord(['C4', 'D4', 'F#4', 'A-4']) >>> fr6c.isFrenchAugmentedSixth() False Unless `permitAnyInversion` is True >>> fr6c.isFrenchAugmentedSixth(permitAnyInversion=True) True * Changed in v7: `permitAnyInversion` added OMIT_FROM_DOCS >>> chord.Chord().isFrenchAugmentedSixth() False >>> fr6d = chord.Chord(['A-3', 'C-4', 'D4', 'F#4']) >>> fr6d.isFrenchAugmentedSixth() False )rrr))M3zm-6d5zA-4)m7zM-2_isAugmentedSixthHelperrJr's r)r+Chord.isFrenchAugmentedSixthv s$h++   9   r(c.URSSU/SQ5$)a Returns True if the chord is a German augmented sixth chord (flat 6th scale degree in bass, tonic, flat third scale degree, and raised 4th). >>> gr6a = chord.Chord(['A-3', 'C4', 'E-4', 'F#4']) >>> gr6a.isGermanAugmentedSixth() True Spelling matters (see isSwissAugmentedSixth) >>> gr6b = chord.Chord(['A-3', 'C4', 'D#4', 'F#4']) >>> gr6b.isGermanAugmentedSixth() False Inversion matters: >>> gr6c = chord.Chord(['C4', 'E-4', 'F#4', 'A-4']) >>> gr6c.isGermanAugmentedSixth() False unless `permitAnyInversion` is True: >>> gr6c.isGermanAugmentedSixth(permitAnyInversion=True) True * Changed in v7: `permitAnyInversion` added OMIT_FROM_DOCS >>> chord.Chord().isGermanAugmentedSixth() False >>> gr6d = chord.Chord(['A-3', 'C-4', 'E-4', 'F#4']) >>> gr6d.isGermanAugmentedSixth() False rrr)d3zA-6rSd7zA-2rVrXs r)r,Chord.isGermanAugmentedSixth s$N++   9   r(c$URS5$)a Returns True if chord is a Half Diminished Seventh, that is, if it contains only notes that are either in unison with the root, a minor third above the root, a diminished fifth, or a major seventh above the root. Additionally, must contain at least one of each third, fifth, and seventh above the root. Chord must be spelled correctly. Otherwise returns false. >>> c1 = chord.Chord(['C4', 'E-4', 'G-4', 'B-4']) >>> c1.isHalfDiminishedSeventh() True Incorrectly spelled chords are not considered half-diminished sevenths >>> c2 = chord.Chord(['C4', 'E-4', 'G-4', 'A#4']) >>> c2.isHalfDiminishedSeventh() False Nor are incomplete chords >>> c3 = chord.Chord(['C4', 'G-4', 'B-4']) >>> c3.isHalfDiminishedSeventh() False >>> chord.Chord().isHalfDiminishedSeventh() False )rr3rtrGr?rfs r)isHalfDiminishedSeventhChord.isHalfDiminishedSeventh s:##M22r(cURSSS:wagURnUcgURHDn[R"UR 5U5nUR RS;dMD g g)a Returns True if the chord is an incomplete Major triad, or, essentially, a dyad of root and major third >>> c1 = chord.Chord(['C4', 'E3']) >>> c1.isMajorTriad() False >>> c1.isIncompleteMajorTriad() True Note that complete major triads return False: >>> c2 = chord.Chord(['C4', 'E3', 'G5']) >>> c2.isIncompleteMajorTriad() False Remember, MAJOR Triad: >>> c3 = chord.Chord(['C4', 'E-3']) >>> c3.isIncompleteMajorTriad() False Must be spelled properly >>> c1 = chord.Chord(['C4', 'F-4']) >>> c1.isIncompleteMajorTriad() False Empty Chords return False >>> chord.Chord().isIncompleteMajorTriad() False OMIT_FROM_DOCS Swap the two notes: >>> c1 = chord.Chord(['C####4', 'E----4']) >>> c1.isIncompleteMajorTriad() False Nr)rrF)rrTr5rorrr'rrrrJrorrs r)isIncompleteMajorTriadChord.isIncompleteMajorTriad spX  " "2A && 0  =I#,,TYY[)DL%%++69& r(cURSSS:wagURnUcgURHDn[R"UR 5U5nUR RS;dMD g g)aF returns True if the chord is an incomplete Minor triad, or, essentially, a dyad of root and minor third >>> c1 = chord.Chord(['C4', 'E-3']) >>> c1.isMinorTriad() False >>> c1.isIncompleteMinorTriad() True >>> c2 = chord.Chord(['C4', 'E-3', 'G5']) >>> c2.isIncompleteMinorTriad() False OMIT_FROM_DOCS >>> c3 = chord.Chord(['C4', 'E4']) >>> c3.isIncompleteMinorTriad() False >>> c3 = chord.Chord(['C4', 'D#4']) >>> c3.isIncompleteMinorTriad() False >>> c3 = chord.Chord(['C###4', 'E---4']) >>> c3.isIncompleteMinorTriad() False >>> chord.Chord().isIncompleteMinorTriad() False Nr)rr3F)rr3Trfrgs r)isIncompleteMinorTriadChord.isIncompleteMinorTriad8 sp@  " "2A && 0  =I#,,TYY[)DL%%++69& r()restrictDoublingsr'c$URSSUSS/5nU(dgU(akUR5nURnURnU(dgURH+nUR UR :XaMXuLdM%XtLdM+ g g)a Returns True if the chord is a properly spelled Italian augmented sixth chord in first inversion. Otherwise returns False. If restrictDoublings is set to True then only the tonic may be doubled. >>> c1 = chord.Chord(['A-4', 'C5', 'F#6']) >>> c1.isItalianAugmentedSixth() True Spelling matters: >>> c2 = chord.Chord(['A-4', 'C5', 'G-6']) >>> c2.isItalianAugmentedSixth() False So does inversion: >>> c3 = chord.Chord(['F#4', 'C5', 'A-6']) >>> c3.isItalianAugmentedSixth() False >>> c4 = chord.Chord(['C5', 'A-5', 'F#6']) >>> c4.isItalianAugmentedSixth() False If inversions don't matter to you, add `permitAnyInversion=True`: >>> c3.isItalianAugmentedSixth(permitAnyInversion=True) True >>> c4.isItalianAugmentedSixth(permitAnyInversion=True) True If doubling rules are turned on then only the tonic can be doubled: >>> c4 = chord.Chord(['A-4', 'C5', 'F#6', 'C6', 'C7']) >>> c4.isItalianAugmentedSixth(restrictDoublings=True) True >>> c5 = chord.Chord(['A-4', 'C5', 'F#6', 'C5', 'F#7']) >>> c5.isItalianAugmentedSixth(restrictDoublings=True) False >>> c5.isItalianAugmentedSixth(restrictDoublings=False) True * Changed in v7: `restrictDoublings` is keyword only. Added `permitAnyInversion`. )r3rrrr]rSFT)rWrrorprrH)rJrmr' aug6checkrrorpr0s r)r*Chord.isItalianAugmentedSixthf s\00   M *   99;DJJEJJE\\66UZZ'>am " r(cNURSSU:wagUR5(agU(dUR5U:wagUR 5nUR nUcg[ R"XV5nURUS;agURnUcg[ R"XX5n U RUS;ag[U5S:agURn U cg[ R"XZ5n U RUS;agg![a gf=f)zU Helper method for simplifying checking Italian, German, etc. Augmented Sixth chords Nr3FrrTr) r5rrFrrrorr'directedSimpleNamerprQrk) rJchordTableAddressrequiredInversionr'intervalsCheckrro thirdIntervalrp fifthIntervalrkseventhIntervals r)rWChord._isAugmentedSixthHelper s"  " "2A &*; ;  . . 0 0 %$..*:>O*Oyy{  = ))$6  + +>!3D D  = ))$6  + +>!3D D ~  ",, ?"++D:  - -^A5F F9  sD D$#D$cLURSSU:wagUR5(dgUR5(agURnURnUR 5nUR nUR U- S-nX:wagUR U- S-n X:wagg)a$ Helper method for `isMajorTriad`, `isMinorTriad`, `isDiminishedTriad`, and `isAugmentedTriad` that checks the chordAddress first, then the number of semitones the third should be and fifth. Deals with strange corner cases like C, E###, G--- not being a major triad, as quickly as possible. Nr3Fr^T)r5rrrorprr) rJ chordAddressthirdSemitonesfifthSemitonesrorprrootPitchClassrvrws r)r3Chord._checkTriadType s  " "2A &, 6||~~  . . 0 0  yy{))N:b@  *))N:b@  *r(c(URSSS5$)a Returns True if chord is a Major Triad, that is, if it contains only notes that are either in unison with the root, a major third above the root, or a perfect fifth above the root. Additionally, must contain at least one of each third and fifth above the root. Chord must be spelled correctly. Otherwise returns false. Example: >>> cChord = chord.Chord(['C', 'E', 'G']) >>> other = chord.Chord(['C', 'G']) >>> cChord.isMajorTriad() True >>> other.isMajorTriad() False Notice that the proper spelling of notes is crucial >>> chord.Chord(['B-', 'D', 'F']).isMajorTriad() True >>> chord.Chord(['A#', 'D', 'F']).isMajorTriad() False (See: :meth:`~music21.chord.Chord.forteClassTn` to catch this case; major triads in the forte system are 3-11B no matter how they are spelled.) >>> chord.Chord(['A#', 'D', 'F']).forteClassTn == '3-11B' True OMIT_FROM_DOCS Strange chords like [C,E###,G---] used to return True. E### = G and G--- = E, so the chord is found to be a major triad, even though it should not be. This bug is now fixed. >>> chord.Chord(['C', 'E###', 'G---']).isMajorTriad() False >>> chord.Chord(['C', 'E', 'G', 'E###', 'G---']).isMajorTriad() False >>> chord.Chord().isMajorTriad() False )r3 rrrr2rfs r)rMChord.isMajorTriad s\##KA66r(c(URSSS5$)a Returns True if chord is a Minor Triad, that is, if it contains only notes that are either in unison with the root, a minor third above the root, or a perfect fifth above the root. Additionally, must contain at least one of each third and fifth above the root. Chord must be spelled correctly. Otherwise returns false. Example: >>> cChord = chord.Chord(['C', 'E-', 'G']) >>> cChord.isMinorTriad() True >>> other = chord.Chord(['C', 'E', 'G']) >>> other.isMinorTriad() False OMIT_FROM_DOCS >>> chord.Chord().isMinorTriad() False )r3rrr3rr2rfs r)rRChord.isMinorTriad0 s,##J155r()requireIntervallicEvennesscUR(dgURnURS:XaU$URUR4nUS;agU(dUS;agg)a3 Returns True if the Chord is symmetrical under transposition and False otherwise. A pitch-class-based way of looking at this, is can all the pitch classes be transposed up some number of semitones 1-11 and end up with the same pitch-classes. Like the dyad F-B can have each note transposed up 6 semitones and get another B-F = F-B dyad. A tonally-focused way of looking at this would be to ask, "Are we unable to distinguish root position vs. some inversion of the basic chord by ear alone?" For instance, we can see (visually) that C-Eb-Gb-Bbb is a diminished-seventh chord in root position, while Eb-Gb-Bbb-C is a diminished-seventh in first inversion. But if the chord were heard in isolation it would not be possible to tell the inversion at all, since diminished-sevenths are transpositionally symmetrical. With either way of looking at it, there are fourteen set classes of 2-10 pitch classes have this property, including the augmented triad: >>> chord.Chord('C E G#').isTranspositionallySymmetrical() True But the major triad is not transpositionally symmetrical: >>> chord.Chord('C E G').isTranspositionallySymmetrical() False The whole-tone scale and the Petrushka chord are both transpositionally symmetrical: >>> wholeToneAsChord = chord.Chord('C D E F# G# B- C') >>> wholeToneAsChord.isTranspositionallySymmetrical() True >>> petrushka = chord.Chord([0, 1, 3, 6, 7, 9]) >>> petrushka.isTranspositionallySymmetrical() True If `requireIntervallicEvenness` is True then only chords that also have even spacing / evenly divide the octave are considered transpositionally symmetrical. The normal cases are the F-B (06) dyad, the augmented triad, the diminished-seventh chord, and the whole-tone scale collection: >>> wholeToneAsChord.isTranspositionallySymmetrical(requireIntervallicEvenness=True) True >>> petrushka.isTranspositionallySymmetrical(requireIntervallicEvenness=True) False Note that complements of these chords (except the whole-tone collection) are not transpositionally symmetrical if `requireIntervallicEvenness` is required: >>> chord.Chord([0, 4, 8]).isTranspositionallySymmetrical(requireIntervallicEvenness=True) True >>> chord.Chord([1, 2, 3, 5, 6, 7, 9, 10, 11]).isTranspositionallySymmetrical( ... requireIntervallicEvenness=True) False Empty chords and the total aggregate cannot have their inversion determined by ear alone. So they are `True` with or without `requireIntervallicEvenness`. >>> chord.Chord().isTranspositionallySymmetrical() True >>> chord.Chord(list(range(12))).isTranspositionallySymmetrical() True Monads (single-note "chords") cannot be transposed 1-11 semitones to recreate themselves, so they return `False` by default: >>> chord.Chord('C').isTranspositionallySymmetrical() False But they are the only case where `requireIntervallicEvenness` actually switches from `False` to `True`, because they do evenly divide the octave. >>> chord.Chord('C').isTranspositionallySymmetrical(requireIntervallicEvenness=True) True 11-note chords return `False` in either case: >>> chord.Chord(list(range(11))).isTranspositionallySymmetrical() False Tr))rrt)r3r^)rrM)rt#)r^r) )rr>)rrQ)rtr)rt)rt)rr>)rrQ)rrM)r>r^)rGrtF)rDr5r.r)rJraddresslookups r)isTranspositionallySymmetrical$Chord.isTranspositionallySymmetricalH sml{{))   ! #- -%%w'9'9:   )f 9 / r(c[UR5n[U5S:wagURcgURcgUR cgg)a Returns True if chord contains at least one of each of Third, Fifth, and Seventh, and every note in the chord is a Third, Fifth, or Seventh, such that there are no repeated scale degrees (ex: E and E-). Else return false. Example: >>> cChord = chord.Chord(['C', 'E', 'G', 'B']) >>> cChord.isSeventh() True >>> other = chord.Chord(['C', 'D', 'E', 'F', 'G', 'B']) >>> other.isSeventh() False OMIT_FROM_DOCS >>> chord.Chord().isSeventh() False rFT)r pitchNamesrQrorprkrJuniquePitchNamess r)rChord.isSeventh sN*t/  A % ::  ::  << r(c[UR5n[U5S:wagURcgURcgUR cg[ URS55$![a gf=f)aZ Returns True if chord contains at least one of each of Third, Fifth, Seventh, and Ninth and every note in the chord is a Third, Fifth, Seventh, or Ninth, such that there are no repeated scale degrees (ex: E and E-). Else return false. Example: >>> cChord = chord.Chord(['C', 'E', 'G', 'B', 'D']) >>> cChord.isNinth() True >>> other = chord.Chord(['C', 'E', 'F', 'G', 'B']) >>> other.isNinth() False OMIT_FROM_DOCS >>> chord.Chord().isNinth() False >>> chord.Chord('C C# C## C### C###').isNinth() False >>> chord.Chord('C C# E B D').isNinth() False >>> chord.Chord('C E G C- D').isNinth() False rFr) rrrQrorprkrrrrs r)isNinth Chord.isNinth sz<t/  A % ::  ::  <<  ))!,- -  sA++ A87A8c.URSSU/SQ5$)a Returns true if it is a respelled German augmented 6th chord with sharp 2 instead of flat 3. This chord has many names, Swiss Augmented Sixth, Alsatian Chord, English A6, Norwegian, etc. as well as doubly-augmented sixth, which is a bit of a misnomer since it is the 4th that is doubly augmented, not the sixth. >>> chord.Chord('A-4 C5 D#5 F#6').isSwissAugmentedSixth() True Respelled as a German Augmented Sixth does not count: >>> chord.Chord('A-4 C5 E-5 F#6').isSwissAugmentedSixth() False Inversions matter: >>> ch3 = chord.Chord('F#4 D#5 C6 A-6') >>> ch3.isSwissAugmentedSixth() False unless `permitAnyInversion` is given: >>> ch3.isSwissAugmentedSixth(permitAnyInversion=True) True * Changed in v7: `permitAnyInversion` added r[r))m3zM-6)dd5zAA-4r_rVrXs r)r-Chord.isSwissAugmentedSixths#:++   ;   r(c[UR5n[U5S:Xa#UR(aUR(agg)a} Returns True if this Chord is a triad of some sort. It could even be a rather exotic triad so long as the chord contains at least one Third and one Fifth and all notes have the same name as one of the three notes. Note: only returns True if triad is spelled correctly. Note the difference of "containsTriad" vs. "isTriad": A dominant-seventh chord is NOT a triad, but it contains two triads. >>> cChord = chord.Chord(['C4', 'E4', 'A4']) >>> cChord.isTriad() True >>> other = chord.Chord(['C', 'D', 'E', 'F', 'G']) >>> other.isTriad() False >>> incorrectlySpelled = chord.Chord(['C', 'D#', 'G']) >>> incorrectlySpelled.isTriad() False >>> incorrectlySpelled.pitches[1].getEnharmonic(inPlace=True) >>> incorrectlySpelled >>> incorrectlySpelled.isTriad() True OMIT_FROM_DOCS >>> chord.Chord().isTriad() False >>> chord.Chord('C4 E4 G4 B#4').isTriad() False r3TF)rrrQrorprs r)r Chord.isTriad:s4Jt/  A %$**r(c"URSUS9$)a Remove all but one instance of a pitch that appears twice. It removes based on the name of the note and the octave, so the same note name in two different octaves is retained. If `inPlace` is True, a copy is not made and a list of deleted pitches is returned; otherwise make and return a copy. >>> c1 = chord.Chord(['c2', 'e3', 'g4', 'e3']) >>> c1 >>> removedList = c1.removeRedundantPitches(inPlace=True) >>> c1 >>> removedList [] >>> c1.forteClass '3-11B' >>> c2 = chord.Chord(['c2', 'e3', 'g4', 'c5']) >>> c2c = c2.removeRedundantPitches(inPlace=False) >>> c2c It is a known bug that because pitch.nameWithOctave gives the same value for B-flat in octave 1 as B-natural in octave negative 1, negative octaves can screw up this method. With all the things left to do for music21, it doesn't seem a bug worth squashing at this moment, but FYI: >>> p1 = pitch.Pitch('B-') >>> p1.octave = 1 >>> p2 = pitch.Pitch('B') >>> p2.octave = -1 >>> c3 = chord.Chord([p1, p2]) >>> removedPitches = c3.removeRedundantPitches(inPlace=True) >>> c3.pitches (,) >>> c3.pitches[0].name 'B-' >>> c3.pitches[0].octave 1 >>> removedPitches [] >>> removedPitches[0].name 'B' >>> removedPitches[0].octave -1 The first pitch survives: >>> c3.pitches[0] is p1 True >>> c3.pitches[0] is p2 False * Changed in v6: inPlace defaults to False. rrrrJrs r)r%Chord.removeRedundantPitchesds%@445E=D5F Fr(c"URSUS9$)a Remove all but the FIRST instance of a pitch class with more than one instance of that pitch class. If `inPlace` is True, a copy is not made and a list of deleted pitches is returned; otherwise a copy is made and that copy is returned. >>> c1 = chord.Chord(['c2', 'e3', 'g4', 'e3']) >>> removed = c1.removeRedundantPitchClasses(inPlace=True) >>> c1.pitches (, , ) >>> c2 = chord.Chord(['c5', 'e3', 'g4', 'c2', 'e3', 'f-4']) >>> removed = c2.removeRedundantPitchClasses(inPlace=True) >>> c2.pitches (, , ) * Changed in v6: inPlace defaults to False. rrrrs r)removeRedundantPitchClasses!Chord.removeRedundantPitchClassess#(44\=D5F Fr(c"URSUS9$)a Remove all but the FIRST instance of a pitch class with more than one instance of that pitch name regardless of octave (but note that spelling matters, so that in the example, the F-flat stays even though there is already an E.) If `inPlace` is True, a copy is not made and a list of deleted pitches is returned; otherwise a copy is made and that copy is returned. >>> c2 = chord.Chord(['c5', 'e3', 'g4', 'c2', 'e3', 'f-4']) >>> c2 >>> rem = c2.removeRedundantPitchNames(inPlace=True) >>> c2 >>> rem [, ] * Changed in v6: inPlace defaults to False. rHrrrs r)r7Chord.removeRedundantPitchNamess#,44V=D5F Fr(rcgr5r"rJnewrootr9s r)r Chord.root r(cgr5r"rs r)rrrr(cU(Gah[U[5(a-[R"U5n[R "U5nO][U[ R5(a URnO1[U[R 5(aUnO[SU<35eSnURH nX5LdM Sn O U(d3URH#nURUR:XdMUnSn O U(d1URH!nURUR:XdMUn O X0RS'X0RS'SUR;a URS gUSLafSUR;a URS SUR;a URS UR5URS'URS$SUR;aPUSLaKSUR;aURS$UR5URS'URS$SUR;aURS$g)al Returns the root of the chord. Or if given a Pitch as the newroot will override the algorithm and always return that Pitch. >>> cmaj = chord.Chord(['E3', 'C4', 'G5']) >>> cmaj.root() Examples: >>> cmaj = chord.Chord(['E', 'G', 'C']) >>> cmaj.root() For some chords we make an exception. For instance, take this chord in B-flat minor: >>> aDim7no3rd = chord.Chord(['A3', 'E-4', 'G4']) It could be considered a type of E-flat 11 chord with a 3rd, but no 5th, 7th, or 9th, in 5th inversion. That doesn't make sense, so we should call it an A dim 7th chord with no 3rd. >>> aDim7no3rd.root() >>> aDim7no3rdInv = chord.Chord(['E-3', 'A4', 'G4']) >>> aDim7no3rdInv.root() The root of a 13th chord (which could be any chord in any inversion) is designed to be the bass: >>> chord.Chord('F3 A3 C4 E-4 G-4 B4 D5').root() Multiple pitches in different octaves do not interfere with root. >>> lotsOfNotes = chord.Chord(['E3', 'C4', 'G4', 'B-4', 'E5', 'G5']) >>> r = lotsOfNotes.root() >>> r >>> r is lotsOfNotes.pitches[1] True Setting of a root may happen for a number of reasons, such as in the case where music21's idea of a root differs from the interpreter's. To specify the root directly, pass the pitch to the root function: >>> cSus4 = chord.Chord('C4 F4 G4') >>> cSus4.root() # considered by music21 to be an F9 chord in 2nd inversion Change it to be a Csus4: >>> cSus4.root('C4') >>> cSus4.root() Note that if passing in a string as the root, the root is set to a pitch in the chord if possible. >>> cSus4.root() is cSus4.pitches[0] True You might also want to supply an "implied root." For instance, some people call a diminished seventh chord (generally viio7) a dominant chord with an omitted root (Vo9) -- here we will specify the root to be a note not in the chord: >>> vo9 = chord.Chord(['B3', 'D4', 'F4', 'A-4']) >>> vo9.root() >>> vo9.root(pitch.Pitch('G3')) >>> vo9.root() When setting a root, the pitches of the chord are left untouched: >>> [p.nameWithOctave for p in vo9.pitches] ['B3', 'D4', 'F4', 'A-4'] By default, this method uses an algorithm to find the root among the chord's pitches, if no root has been previously specified. If a root has been explicitly specified, as in the Csus4 chord above, it can be returned to the original root() by setting find explicitly to True: >>> cSus4.root(find=True) Subsequent calls without find=True have also removed the overridden root: >>> cSus4.root() If for some reason you do not want the root-finding algorithm to be run (for instance, checking to see if an overridden root has been specified) set find=False. "None" will be returned if no root has been specified. >>> c = chord.Chord(['E3', 'G3', 'B4']) >>> print(c.root(find=False)) None Chord symbols, for instance, have their root already specified on construction: >>> d = harmony.ChordSymbol('CM/E') >>> d.root(find=False) There is no need to set find=False in this case, however, the algorithm will skip the slow part of finding the root if it has been specified (or already found and no pitches have changed). A chord with no pitches has no root and raises a ChordException. >>> chord.Chord().root() Traceback (most recent call last): music21.chord.ChordException: no pitches in chord * Changed in v5.2: `find` is a keyword-only parameter, `newroot` finds `Pitch` in `Chord` zCannot find a Pitch in FTrrFN)r@rArrGrrmrrnrrrrHrCrIr)rJrr9 newroot_pitchfoundRootInChordr0s r)rrsP '3'' 44W= % G 4 GTYY// ' GU[[11 '  #:7+!FGG % \\ %'+$" $A''=+G+GG() +/( & $Avv!3!33() & '4OOF #"/KK dkk)KK , T\(OOF+dkk)KK ,"&.."2DKK ;;v& &DOO+U1B${{6**&*nn&6 F#{{6** t &??6* *r()rVcgr5r"rXs r)semiClosedPositionChord.semiClosedPositionsr(cU$r5r"rXs r)rrs  r(cURUUUS9nUSLaUn[R(aSSKJn [ XE5(de[ R "UR5nU(av/n/n[U5HXupU RU;aURU R5 M2U =RS- sl URU 5 MZ UnU(aMvUR5 URSS9 USLaU$g) ac Similar to :meth:`~music21.chord.Chord.ClosedPosition` in that it moves everything within an octave EXCEPT if there's already a pitch at that step, then it puts it up an octave. It's a very useful display standard for dense post-tonal chords. >>> c1 = chord.Chord(['C3', 'E5', 'C#6', 'E-7', 'G8', 'C9', 'E#9']) >>> c2 = c1.semiClosedPosition(inPlace=False) >>> c2 `leaveRedundantPitches` still works, and gives them a new octave! >>> c3 = c1.semiClosedPosition( ... inPlace=False, ... leaveRedundantPitches=True, ... ) >>> c3 of course `forceOctave` still works, as does `inPlace=True`. >>> c1.semiClosedPosition( ... forceOctave=2, ... inPlace=True, ... leaveRedundantPitches=True, ... ) >>> c1 r[Tr)StreamrrFN)rYt TYPE_CHECKINGmusic21.streamrr@rprrrrorbrzr) rJrUrrVr9rremainingPitches usedStepsnewRemainingPitchesrr0s r)rrsN [)07L!N d?B ?? -b)) ))99RZZ0I"$ !"2366*$$QVV,HHMH'..q1 4 3   & e I r(cTURXS9nUcgURR$)aO Returns the number of semitones (mod12) above the root that the chordStep lies (i.e., 3 = third of the chord; 5 = fifth, etc.) if one exists. Or None if it does not exist. You can optionally specify a note.Note object to try as the root. It does not change the Chord.root object. We use these methods to figure out what the root of the triad is. Currently, there is a bug that in the case of a triply diminished third (e.g., "c" => "e----"), this function will incorrectly claim no third exists. Perhaps this should be construed as a feature. In the case of chords such as C, E-, E, semitonesFromChordStep(3) will return the number for the first third, in this case 3. It will not return 4, nor a list object (3, 4). You probably do not want to be using tonal chord manipulation functions on chords such as these anyway. Check for such cases with chord.hasAnyRepeatedDiatonicNote first. Tools with the expression "chordStep" in them refer to the diatonic third, fifth, etc., of the chord. They have little to do with the scale degree of the scale or key that the chord is embedded within. See "chord.scaleDegrees" for this functionality. >>> cChord = chord.Chord(['E3', 'C4', 'G5']) >>> cChord.semitonesFromChordStep(3) # distance from C to E 4 >>> cChord.semitonesFromChordStep(5) # C to G 7 Omitted chordSteps return None >>> print(cChord.semitonesFromChordStep(6)) None Note that the routine returns the semitones to the FIRST third. This chord has two thirds, C and C# >>> aChord = chord.Chord(['a2', 'c4', 'c#5', 'e#7']) >>> aChord.semitonesFromChordStep(3) 3 >>> aChord.semitonesFromChordStep(5) 8 >>> print(aChord.semitonesFromChordStep(2)) None Test whether this strange chord gets the B# as 0 semitones: >>> c = chord.Chord(['C4', 'E4', 'G4', 'B#4']) >>> c.semitonesFromChordStep(7) 0 If testRoot is set to a Pitch object then that note is used as the root of the chord regardless of anything else that might be considered. A-minor: 1st inversion. >>> aMin = chord.Chord(['C4', 'E4', 'A4']) >>> aMin.semitonesFromChordStep(3) 3 >>> aMin.semitonesFromChordStep(5) 7 C6 chord, jazz like, root position: >>> cPitch = pitch.Pitch('C4') >>> c6 = aMin # renaming for clarity >>> c6.semitonesFromChordStep(3, testRoot = cPitch) 4 >>> c6.semitonesFromChordStep(5, testRoot = cPitch) is None True >>> c6.semitonesFromChordStep(6, testRoot = cPitch) 9 rN)rrr)rJrrtempInts r)semitonesFromChordStepChord.semitonesFromChordSteps2^,,Y,J ?$$** *r(cUcEUR(a4XRlURHnXRlM g[U[5(a[ R "U5nSnURH&nUR ULdMXRlSn O U(d7URH'nUR U:XdMXRlSn O U(d[SU35eg)ae Set color for specific pitch. >>> c = chord.Chord('C4 E4 G4') >>> c.setColor('red', 'C4') >>> c['0.style.color'] 'red' >>> c.setColor('blue') # set for whole chord >>> c.style.color 'blue' >>> c['E4.style.color'] 'blue' >>> c.setColor('red', 'C9') Traceback (most recent call last): music21.chord.ChordException: the given pitch is not in the Chord: C9 NFTr)rDrrr@rArrmr)rJrrrbmatchrs r)setColorChord.setColorVs&  4;;$JJ [[ % !   S ) )++k2KAww+% %   [[77k)$)GGM E !  7 }EG Gr(cUc+UR(aURSRnO+[U[5(a[R"U5nSnURHnURULdMXlSn O U(d-URHnURU:XdMXlSn O U(d[ SU35eg)a Given a notehead attribute as a string and a pitch object in this Chord, set the notehead attribute of that pitch to the value of that notehead. Valid notehead type names are found in note.noteheadTypeNames (see below): >>> for noteheadType in note.noteheadTypeNames: ... noteheadType ... 'arrow down' 'arrow up' 'back slashed' 'circle dot' 'circle-x' 'circled' 'cluster' 'cross' 'diamond' 'do' 'fa' 'fa up' 'inverted triangle' 'la' 'left triangle' 'mi' 'none' 'normal' 'other' 're' 'rectangle' 'slash' 'slashed' 'so' 'square' 'ti' 'triangle' 'x' >>> n1 = note.Note('D4') >>> n2 = note.Note('G4') >>> c1 = chord.Chord([n1, n2]) >>> c1.setNotehead('diamond', c1.pitches[1]) # just to g >>> c1.getNotehead(c1.pitches[1]) 'diamond' >>> c1.getNotehead(c1.pitches[0]) 'normal' If a chord has two of the same pitch, but each associated with a different notehead, then object equality must be used to distinguish between the two. >>> c2 = chord.Chord(['D4', 'D4']) >>> secondD4 = c2.pitches[1] >>> c2.setNotehead('diamond', secondD4) >>> for i in [0, 1]: ... c2.getNotehead(c2.pitches[i]) ... 'normal' 'diamond' By default, assigns to first pitch: >>> c3 = chord.Chord('C3 F4') >>> c3.setNotehead('slash', None) >>> c3['0.notehead'] 'slash' Less safe to match by string, but possible: >>> c3.setNotehead('so', 'F4') >>> c3['1.notehead'] 'so' Error: >>> c3.setNotehead('so', 'G4') Traceback (most recent call last): music21.chord.ChordException: the given pitch is not in the Chord: G4 NrFTr)rDrr@rArmrrrJnhrrrs r) setNoteheadChord.setNoteheadsd  4;;++a...K  S ) )++k2KAww+%   [[77k)!#J E !  #H !VW Wr(cUc+UR(aURSRnO+[U[5(a[R"U5nSnURHnURULdMXlSn O U(d-URHnURU:XdMXlSn O U(d[ SU35eg)a Given a noteheadFill attribute as a string (or False) and a pitch object in this Chord, set the noteheadFill attribute of that pitch to the value of that notehead. Valid noteheadFill names are True, False, None (default) >>> n1 = note.Note('D4') >>> n2 = note.Note('G4') >>> c1 = chord.Chord([n1, n2]) >>> c1.setNoteheadFill(False, c1.pitches[1]) # just to g >>> c1.getNoteheadFill(c1.pitches[1]) False >>> c1.getNoteheadFill(c1.pitches[0]) is None True If a chord has two of the same pitch, but each associated with a different notehead, then object equality must be used to distinguish between the two. >>> c2 = chord.Chord(['D4', 'D4']) >>> secondD4 = c2.pitches[1] >>> c2.setNoteheadFill(False, secondD4) >>> for i in [0, 1]: ... print(c2.getNoteheadFill(c2.pitches[i])) ... None False By default, assigns to first pitch: >>> c3 = chord.Chord('C3 F4') >>> c3.setNoteheadFill(False, None) >>> c3['0.noteheadFill'] False Less safe to match by string, but possible: >>> c3.setNoteheadFill(True, 'F4') >>> c3['1.noteheadFill'] True Error: >>> c3.setNoteheadFill(True, 'G4') Traceback (most recent call last): music21.chord.ChordException: the given pitch is not in the Chord: G4 NrFTr)rDrr@rArmrrrs r)setNoteheadFillChord.setNoteheadFills`  4;;++a...K  S ) )++k2KAww+%!#  [[77k)%'N E !  #H !VW Wr(cUc+UR(aURSRnO+[U[5(a[R"U5nSnURHnURULdMXlSn O U(d-URHnURU:XdMXlSn O U(d[ SU35eg)a# Given a stem attribute as a string and a pitch object in this Chord, set the stem attribute of that pitch to the value of that stem. Valid stem directions are found note.stemDirectionNames (see below). >>> for name in note.stemDirectionNames: ... name ... 'double' 'down' 'noStem' 'none' 'unspecified' 'up' >>> n1 = note.Note('D4') >>> n2 = note.Note('G4') >>> c1 = chord.Chord([n1, n2]) >>> c1.setStemDirection('double', c1.pitches[1]) # just to g >>> c1.getStemDirection(c1.pitches[1]) 'double' >>> c1.getStemDirection(c1.pitches[0]) 'unspecified' If a chord has two of the same pitch, but each associated with a different stem, then object equality must be used to distinguish between the two. >>> c2 = chord.Chord(['D4', 'D4']) >>> secondD4 = c2.pitches[1] >>> c2.setStemDirection('double', secondD4) >>> for i in [0, 1]: ... print(c2.getStemDirection(c2.pitches[i])) ... unspecified double By default, assigns to first pitch: >>> c3 = chord.Chord('C3 F4') >>> c3.setStemDirection('down', None) >>> c3['0.stemDirection'] 'down' Less safe to match by string, but possible: >>> c3.setStemDirection('down', 'F4') >>> c3['1.stemDirection'] 'down' Error: >>> c3.setStemDirection('up', 'G4') Traceback (most recent call last): music21.chord.ChordException: the given pitch is not in the Chord: G4 NrFTr)rDrr@rArmrr)rJstemrrrs r)setStemDirectionChord.setStemDirection*st  4;;++a...K  S ) )++k2KAww+%"&  [[77k)&*O E !  7 }EG Gr(c Uc+UR(aURSRnO+[U[5(a[R"U5n[U[5(a[ R "U5nOUnSnURH nURULdXRLdMX5lSn O U(d.URHnX%UR4;dMX5lSn O U(d[SU35eg)a Given a tie object (or a tie type string) and a pitch or Note in this Chord, set the pitch's tie attribute in this chord to that tie type. >>> c1 = chord.Chord(['d3', 'e-4', 'b-4']) >>> t1 = tie.Tie('start') >>> c1.setTie(t1, 'b-4') # or it can be done with a pitch.Pitch object >>> c1.getTie(c1.pitches[2]) is t1 True Setting a tie with a chord with the same pitch twice requires getting the exact pitch object out to be sure which one: >>> c2 = chord.Chord(['D4', 'D4']) >>> secondD4 = c2.pitches[1] >>> c2.setTie('start', secondD4) >>> for i in [0, 1]: ... print(c2.getTie(c2.pitches[i])) ... None >>> c3 = chord.Chord('C3 F4') >>> c3.setTie('start', None) >>> c3.getTie(c3.pitches[0]) Less safe to match by string, because there might be multiple pitches with the same name in the chord, but possible: >>> c4 = chord.Chord('D4 F#4') >>> c4.setTie('start', 'F#4') >>> c4.getTie('F#4') Setting a tie on a note not in the chord is an error: >>> c3.setTie('stop', 'G4') Traceback (most recent call last): music21.chord.ChordException: the given pitch is not in the Chord: G4 NrFTr)rDrr@rArmrTier)rJ tieObjOrStrrtieObjrrs r)setTie Chord.setTiexsT  4;;++a...K  S ) )++k2K k3 ' 'WW[)F FAww+%)9  [[agg,."E E !  7 }EG Gr(c[U[5(a[R"U5nO][U[R 5(a URnO1[U[R5(aUnO[ SU<35eSnURH<nURULdURU:XdM$XlURUSS9 Sn O U(d[SU35eg)aB Set the :class:`~music21.volume.Volume` object of a specific Pitch. * Changed in v8: after appearing in ChordBase in v7, it has been properly moved back to Chord itself. The ability to change just the first note's volume has been removed. Use `Chord().volume = vol` to change the volume for a whole chord. zCannot setVolume on target FrTrN) r@rArrmrrnrrDr`rr)rJrtargetrrrs r) setVolumeChord.setVolumes fc " "++f-K  * * ,,K  , , K:6*EF FAww+%K)?!  SE 2  #H !VW Wr()r keyContextcU(aUnO[R"U5n[R"URUS9n[ [ U55HnXEURUlM USLaU$g)a Calls `pitch.simplifyMultipleEnharmonics` on the pitches of the chord. Simplifies the enharmonics in the sense of making a more logical chord. Note below that E# is added there because C# major is simpler than C# F G#. >>> c = chord.Chord('C# F G#') >>> c.pitches (, , ) >>> c.simplifyEnharmonics(inPlace=True) >>> c.pitches (, , ) If `keyContext` is provided the enharmonics are simplified based on the supplied Key or KeySignature. >>> c.simplifyEnharmonics(inPlace=True, keyContext=key.Key('A-')) >>> c.pitches (, , ) )rFN)rprqrsimplifyMultipleEnharmonicsrr&rQrD)rJrrrrrs r)rChord.simplifyEnharmonicssm, I d+I33DLLZXs7|$A(/ I  Q  %% e   r(c URUS9$)Nr)sortDiatonicAscendingrs r)rChord.sortAscendings))')::r(cf[R"U5nURRSS9 U$)zS Same as sortAscending but notes are sorted by midi number, so F## sorts above G-. c.URR$r5)rrdxs r)r.Chord.sortChromaticAscending..s 177::r(rrprqrDr,rJnewChords r)sortChromaticAscendingChord.sortChromaticAscendings-==&!56r(c U(a5URRSS5(agUnUR5 O[R"U5nUR R SS9 SURS'U(dU$g)a# The notes are sorted by :attr:`~music21.pitch.Pitch.diatonicNoteNum` or vertical position on a grand staff (so F## sorts below G-). Notes that are the identical diatonicNoteNum are further sorted by :attr:`~music21.pitch.Pitch.ps` (midi numbers that accommodate floats). We return a new Chord object with the notes arranged from lowest to highest (unless inPlace=True) >>> cMajUnsorted = chord.Chord(['E4', 'C4', 'G4']) >>> cMajSorted = cMajUnsorted.sortDiatonicAscending() >>> cMajSorted.pitches[0].name 'C' >>> c2 = chord.Chord(['E4', 'C4', 'G4']) >>> c2.sortDiatonicAscending(inPlace=True) >>> c2 >>> sameDNN = chord.Chord(['F#4', 'F4']) >>> sameDNN.sortDiatonicAscending() * Changed in v6: if inPlace is True do not return anything. isSortedAscendingDiatonicFNcZURRURR4$r5)rrerdrs r)r-Chord.sortDiatonicAscending..-sQWW-D-Daggjj,Qr(rT)rIgetrzrprqrDr,)rJrrs r)rChord.sortDiatonicAscending sv4 {{:EBBI OO  d+I"QR8< 45 r(cf[R"U5nURRSS9 U$)z Same as above, but uses a note's frequency to determine height; so that C# would be below D- in 1/4-comma meantone, equal in equal temperament, but below it in (most) just intonation types. c.URR$r5)r frequencyrs r)r.Chord.sortFrequencyAscending..:s177+<+>> a = chord.Chord(['g4', 'a3', 'c#6']) >>> b = a.transpose('m3') >>> b Here we create the interval object first (rather than giving a string) and specify transposing down six semitones, instead of saying A-4. >>> aInterval = interval.Interval(-6) >>> b = a.transpose(aInterval) >>> b If `inPlace` is True then rather than returning a new chord, the chord itself is changed. >>> a.transpose(aInterval, inPlace=True) >>> a r)TrN)r~rr'rprqrD transpose)rJrr intervalObjpostrbs r)rChord.transpose=shF 5* % %K"++E2K==&DDA KK TK 2 Kr(c[R"U5$![Ra [R"SSSS5s$f=f)a Return a four-element ChordTableAddress that represents that raw data location for information on the set class interpretation of this Chord as well as the original pitchClass The data format is a Forte set class cardinality, index number, and inversion status (where 0 is invariant, and -1 and 1 represent inverted or not, respectively). >>> c = chord.Chord(['D4', 'F#4', 'B-4']) >>> c.chordTablesAddress ChordTableAddress(cardinality=3, forteClass=12, inversion=0, pcOriginal=2) >>> c = chord.Chord('G#2 A2 D3 G3') >>> c.chordTablesAddress ChordTableAddress(cardinality=4, forteClass=6, inversion=0, pcOriginal=2) This method caches the result so that it does not need to be looked up again. One change from chord.tables.seekChordTablesAddress: the empty chord returns a special address instead of raising an exception: >>> chord.Chord().chordTablesAddress ChordTableAddress(cardinality=0, forteClass=0, inversion=0, pcOriginal=0) r)rseekChordTablesAddressChordTablesExceptionChordTableAddressrfs r)r5Chord.chordTablesAddresswsD8 8006 6** 8++Aq!Q7 7 8s-AAc  [SUR55(agURnURS:XagURS:Xa[ UR5S:XagURVs1sHo"R iM nnURVs1sHo"R iM nn[ U5S:Xa[[ U5S:Xag[ U5S:Xa;[R"URSURS5R$g [ U5S:Xag g [R"U5nURS:XGa?URVs1sHo"R iM nnURVs1sHo"R iM nnURSnURnURSS HnURU:wdMUn O [S 5e[R"Xh5n [ U5S:a'U RRn U S:waSOSn U SU 3$[ U5S:aU R S-$[R"URSURS5R$UR"n SSjn UR$UR&UR(UR*UR,UR.UR0UR0UR0S. nU S:XaUR35(aUS$UR55(aUS$UR5SS9(a'USS-UR75R95-$UR;5(aUS$UR;SS9(a'USS-UR75R95-$SUS-$U S:XaZUR=5(aUS$UR=SS9(a'USS-UR75R95-$US$U S:XaZUR?5(aUS$UR?SS9(a'USS-UR75R95-$US$U S;aU "U5(aUS$SUS-$X;aUSnXnU"5(dSU-nU$U(dSU -$US$s snfs snfs snfs snf) a Return the most common name associated with this Chord as a string. Checks some common enharmonic equivalents. >>> c1 = chord.Chord(['c', 'e-', 'g']) >>> c1.commonName 'minor triad' >>> c2 = chord.Chord(['c', 'e', 'g']) >>> c2.commonName 'major triad' >>> c2b = chord.Chord(['c', 'f-', 'g']) >>> c2b.commonName 'enharmonic equivalent to major triad' >>> c3 = chord.Chord(['c', 'd-', 'e', 'f#']) >>> c3.commonName 'all-interval tetrachord' Chords with no common names just return the Forte Class >>> c3 = chord.Chord([0, 1, 2, 3, 4, 9]) >>> c3.commonName 'forte class 6-36B' Dominant seventh and German/Swiss sixths are distinguished >>> c4a = chord.Chord(['c', 'e', 'g', 'b-']) >>> c4a.commonName 'dominant seventh chord' >>> c4b = chord.Chord(['c', 'e', 'g', 'a#']) >>> c4b.commonName 'German augmented sixth chord' >>> c4c = chord.Chord(['c', 'e', 'f##', 'a#']) >>> c4c.commonName # some call it Alsacian or English 'Swiss augmented sixth chord' When in an unusual inversion, augmented sixth chords have their inversion added: >>> c4b = chord.Chord('A#3 C4 E4 G4') >>> c4b.commonName 'German augmented sixth chord in root position' Dyads are called by actual name: >>> dyad1 = chord.Chord('C E') >>> dyad1.commonName 'Major Third' >>> dyad2 = chord.Chord('C F-') >>> dyad2.commonName 'Diminished Fourth' Compound intervals are given in full if there are only two distinct pitches: >>> dyad1 = chord.Chord('C4 E5') >>> dyad1.commonName 'Major Tenth' But if there are more pitches, then the interval is given in a simpler form: >>> dyad1 = chord.Chord('C4 C5 E5 C6') >>> dyad1.commonName 'Major Third with octave doublings' If there are multiple enharmonics present just the simple number of semitones is returned. >>> dyad1 = chord.Chord('C4 E5 F-5 B#7') >>> dyad1.commonName '4 semitones' Special handling of one- and two-pitchClass chords: >>> gAlone = chord.Chord(['G4']) >>> gAlone.commonName 'note' >>> gAlone = chord.Chord('G4 G4') >>> gAlone.commonName 'unison' >>> gAlone = chord.Chord('G4 G5') >>> gAlone.commonName 'Perfect Octave' >>> gAlone = chord.Chord('G4 G6') >>> gAlone.commonName 'Perfect Double-octave' >>> gAlone = chord.Chord('G4 G5 G6') >>> gAlone.commonName 'multiple octaves' >>> gAlone = chord.Chord('F#4 G-4') >>> gAlone.commonName 'enharmonic unison' >>> chord.Chord().commonName 'empty chord' Microtonal chords all have the same commonName: >>> chord.Chord('C`4 D~4').commonName 'microtonal chord' Enharmonic equivalents to common sevenths and ninths are clarified: >>> chord.Chord('C4 E4 G4 A##4').commonName 'enharmonic equivalent to major seventh chord' >>> chord.Chord('C4 E-4 G4 A#4 D4').commonName 'enharmonic equivalent to minor-ninth chord' * Changed in v5.5: special cases for checking enharmonics in some cases * Changed in v6.5: better handling of 0-, 1-, and 2-pitchClass and microtonal chords. * Changed in v7: Inversions of augmented sixth-chords are specified. * Changed in v7.3: Enharmonic equivalents to common seventh and ninth chords are specified. OMIT_FROM_DOCS >>> chord.Chord('C E G C-').commonName 'enharmonic equivalent to major seventh chord' >>> chord.Chord('C E G B--').commonName 'enharmonic equivalent to minor seventh chord' >>> chord.Chord('C E G A').commonName 'minor seventh chord' c3J# UHoR5(+v M g7fr5) isTwelveTonerDs r)r9#Chord.commonName..s:\>>###\s!#zmicrotonal chordr empty chordrrunisonrzmultiple octaveszenharmonic unisonzenharmonic octavesNz#Will never happen, just for typing.sr semitonez with octave doublingsc$UR5(dgUR5RS5nURUR;agUR nU(dgURS5nURUR;agg)z; For testing minor-minor sevenths and major-major sevenths FP5T)rrrrHrro)rhypothetical_fifthrohypothetical_sevenths r),_isSeventhWithPerfectFifthsAboveRootAndThirdFChord.commonName.._isSeventhWithPerfectFifthsAboveRootAndThirdWst;;==!"!3!3D!9 !&&all:GGE#(??4#8 #(( <r() z3-11Az3-11Bz3-10z3-12z4-27Az4-28z5-27Az5-27Bz5-34z4-27BTr&z in r3zenharmonic to z4-25z3-8A)z4-20z4-26zenharmonic equivalent to z forte class )rrrr) rGrr5r.rQrHrdrr'niceNameraddressToCommonNamesrrrsimpleUndirectedsemiSimpleNiceNamerrRrMrHr4rcrArrNr,r$lowerr-r+r*)rJctar0r pitchPSesctnp0 p0pitchClassp1relevantIntervalsimpleUnpluralrr enharmonicTestsouttests r) commonNameChord.commonNamesL :T\\: : :%%% ??a  ??a 4<< A%*.,,7,Q&&,J7'+||4|!|I4:!#y>Q&#y>Q&#,,T\\!_dll1oNWWW-9~"*+))#. ??a *.,,7,Q&&,J7'+||4|!|I4aB==L\\!"%<<</B& %%JKK'008 :"+55FF (A 2"9VH559~!'::=UUU$$T\\!_dll1oFOO O__  $&&&&**))11,,\\\\LL    %%''1v ,,..1v ,,,E1v););)=)C)C)EEE++--1v ++t+D1v););)=)C)C)EEE'#a&00 6 !**,,1v ,,,E1v););)=)C)C)EEE1v 6 !++--1v ---F1v););)=)C)C)EEE1v + +>> c = chord.Chord(['a', 'c', 'e']) >>> c.duration Durations can be overridden after the fact: >>> d = duration.Duration() >>> d.quarterLength = 2 >>> c.duration = d >>> c.duration >>> c.duration == d True >>> c.duration is d True Nr)rcastr _durationrDr;rr@)rJrpitchZeroDurationd_outs r)r;Chord.durationsh0 FF8D=$.. 1 9 $ A 7 7 .N ??eX.. .. r(cV[U[5(aXlg[SU35e)z Set a Duration object. z$this must be a Duration object, not N)r@rr"r)rJ durationObjs r)r;r%s+ k8 , ,(N!#G }!UV Vr(cFURS5$![a gf=f)a Shortcut for getChordStep(5), but caches it and does not raise exceptions >>> cMaj1stInv = chord.Chord(['E3', 'C4', 'G5']) >>> cMaj1stInv.fifth >>> cMaj1stInv.fifth.midi 79 >>> chord.Chord('C4 D4').fifth is None True OMIT_FROM_DOCS >>> chord.Chord().fifth rNrrrfs r)rp Chord.fifth*( $$Q' '     cz[R"URS5$![Ra gf=f)a Return the Forte set class name as a string. This assumes a Tn formation, where inversion distinctions are represented. (synonym: forteClassTn) >>> c1 = chord.Chord(['c', 'e-', 'g']) >>> c1.forteClass '3-11A' >>> c2 = chord.Chord(['c', 'e', 'g']) >>> c2.forteClass '3-11B' Empty chords return 'N/A' >>> chord.Chord().forteClass 'N/A' Non-twelve-tone chords return as if all microtones and non-twelve-tone accidentals are removed: >>> chord.Chord('c~4 d`4').forteClass '2-2' tnN/AraddressToForteNamer5rrfs r)rChord.forteClasss86 ,,T-D-DdK K**   #::c.URR$)a Return the number of the Forte set class within the defined set group. That is, if the set is 3-11, this method returns 11. >>> c1 = chord.Chord(['c', 'e-', 'g']) >>> c1.forteClassNumber 11 >>> c2 = chord.Chord(['c', 'e', 'g']) >>> c2.forteClassNumber 11 )r5rrfs r)forteClassNumberChord.forteClassNumbers&&111r(cUR$)z A synonym for "forteClass" Return the Forte Tn set class name, where inversion distinctions are represented: >>> c1 = chord.Chord(['c', 'e-', 'g']) >>> c1.forteClass '3-11A' >>> c2 = chord.Chord(['c', 'e', 'g']) >>> c2.forteClassTn '3-11B' )rrfs r) forteClassTnChord.forteClassTns r(cz[R"URS5$![Ra gf=f)a Return the Forte TnI class name, where inversion distinctions are not represented. >>> c1 = chord.Chord(['c', 'e-', 'g']) >>> c1.forteClassTnI '3-11' >>> c2 = chord.Chord(['c', 'e', 'g']) >>> c2.forteClassTnI '3-11' Empty chords return 'N/A' >>> chord.Chord().forteClassTnI 'N/A' Non-twelve-tone chords return as if all microtones and non-twelve-tone accidentals are removed: >>> chord.Chord('c~4 d`4').forteClassTnI '2-2' tnir/r0rfs r) forteClassTnIChord.forteClassTnI0s82 ,,T-D-DeL L**  r3cB/n/nURHnURUR5 M! URS5 URSSRU5-S-5 URURR5 SRU5$)aX Return the most complete representation of this Note, providing duration and pitch information. >>> c = chord.Chord(['D', 'F#', 'A']) >>> c.fullName 'Chord {D | F-sharp | A} Quarter' >>> chord.Chord(['d1', 'e4-', 'b3-'], quarterLength=2/3).fullName 'Chord {D in octave 1 | E-flat in octave 4 | B-flat in octave 3} Quarter Triplet (2/3 QL)' rz {z | z} r)rrofullNamerr;)rJrsubr0s r)r?Chord.fullNameNs|A JJ!** ' 7 45::c?+d23 4==))*wws|r(c[R"UR5nUbgg![Ra gf=f)a  Return True or False if the Chord has a Z-relation. >>> c1 = chord.Chord(['c', 'e-', 'g']) >>> c1.hasZRelation False >>> c2 = chord.Chord(['c', 'c#', 'e', 'f#']) >>> c2.hasZRelation # it is c, c#, e-, g True OMIT_FROM_DOCS >>> chord.Chord().hasZRelation False FT)rr4r5r)rJrs r)rChord.hasZRelationesE$ ++D,C,CDD   **  s '>>c[[R"UR55$![Ra /SQs$f=f)a Return the interval vector for this Chord as a list of integers. >>> c1 = chord.Chord(['c', 'e-', 'g']) >>> c1.intervalVector [0, 0, 1, 1, 1, 0] >>> c2 = chord.Chord(['c', 'c#', 'e', 'f#']) >>> c2.intervalVector [1, 1, 1, 1, 1, 1] >>> c3 = chord.Chord(['c', 'c#', 'e-', 'g']) >>> c3.intervalVector [1, 1, 1, 1, 1, 1] OMIT_FROM_DOCS >>> chord.Chord().intervalVector [0, 0, 0, 0, 0, 0] )rrrrrr)listrrr5rrfs r)intervalVectorChord.intervalVectors>, &66t7N7NOP P** &% % &s(+AAc@[RUR5$)z Return the interval vector as a string representation. >>> c1 = chord.Chord(['c', 'e-', 'g']) >>> c1.intervalVectorString '<001110>' )rrrFrfs r)intervalVectorStringChord.intervalVectorStrings''(;(;<>> c1 = chord.Chord(['c', 'e-', 'g']) >>> c1.isPrimeFormInversion False >>> c2 = chord.Chord(['c', 'e', 'g']) >>> c2.isPrimeFormInversion True rTF)r5rFrfs r)isPrimeFormInversionChord.isPrimeFormInversions  " " , , 2r(c,[UR5$)z Return an integer representing the cardinality of the multiset, or the number of pitch values. >>> c1 = chord.Chord(['D4', 'A4', 'F#5', 'D6']) >>> c1.multisetCardinality 4 )rQ pitchClassesrfs r)multisetCardinalityChord.multisetCardinalitys4$$%%r(c,[UR5$)a/ Return a tuple (immutable) of the notes contained in the chord. Generally using .pitches or iterating over the chord is the best way to work with the components of a chord, but in unusual cases, a chord may, for instance, consist of notes with independent durations, volumes, or colors, or, more often, different tie statuses. `Chord` includes methods such as `.setTie()` for most of these features, but from time to time accessing all the `Note` objects as a tuple can be valuable. >>> c1 = chord.Chord(['c', 'e-', 'g']) >>> c1.duration.type = 'quarter' >>> c1Notes = c1.notes >>> c1Notes (, , ) Note that to set duration independently, a new Duration object needs to be created. Internal notes for Chords created from strings or pitches all share a Duration object. >>> c1.duration is c1Notes[0].duration True >>> c1Notes[1].duration is c1Notes[2].duration True >>> c1Notes[2].duration = duration.Duration('half') >>> c1.duration.type 'quarter' >>> c1[2].duration.type 'half' The property can also set the notes for a chord, but it must be set to an iterable of literal Note objects. >>> c1.notes = [note.Note('D#4'), note.Note('C#4')] >>> c1 Notice that the notes set this way are not sorted -- this is a property for power users who want complete control. Any incorrect assignment raises a TypeError: >>> c1.notes = 'C E G' Traceback (most recent call last): TypeError: notes must be set with an iterable >>> c1.notes = [pitch.Pitch('C'), pitch.Pitch('E')] Traceback (most recent call last): TypeError: every element of notes must be a note.Note object In case of an error, the previous notes are not changed (for this reason, `.notes` cannot take a generator expression). >>> c1 * New in v5.7 rrfs r)rK Chord.notessxT[[!!r(c[R"U5(d [S5e[SU55(d [S5eURR 5 UR USS9 g)z+ sets notes to an iterable of Note objects z"notes must be set with an iterablec3V# UHn[U[R5v M! g7fr5)r@rrnrs r)r9Chord.notes.. s>X:a++Xrz1every element of notes must be a note.Note objectFrN)rryrtrrDclearr{)rJnewNotess r)rKrSs^   **@A A>X>>>OP P  5)r(c`URn[R"U5nURn[ U5nUH-nUVs/sH ofU-S-PM nn[ U5U:XdM+Us $ [ S[UR5-5e![Ra /s$f=fs snf)a Return the normal order/normal form of the Chord represented as a list of integers: >>> c1 = chord.Chord(['c', 'e-', 'g']) >>> c1.normalOrder [0, 3, 7] >>> c2 = chord.Chord(['c', 'e', 'g']) >>> c2.normalOrder [0, 4, 7] >>> c3 = chord.Chord(['d', 'f#', 'a']) >>> c3.normalOrder [2, 6, 9] >>> c3 = chord.Chord(['B-4', 'D5', 'F5']) >>> c3.normalOrder [10, 2, 5] To get normalOrder transposed to PC 0, do this: >>> c3 = chord.Chord(['B-4', 'D5', 'F5']) >>> normalOrder = c3.normalOrder >>> firstPitch = normalOrder[0] >>> [(pc - firstPitch) % 12 for pc in normalOrder] [0, 4, 7] To get normalOrder formatted as a vectorString run .formatVectorString on it: >>> c3.normalOrder [10, 2, 5] >>> chord.Chord.formatVectorString(c3.normalOrder) '' (this is equivalent:) >>> c3.formatVectorString(c3.normalOrder) '' OMIT_FROM_DOCS These were giving problems before: >>> chord.Chord('G#2 A2 D3 G3').normalOrder [7, 8, 9, 2] >>> chord.Chord('G3 D4 A-4 A4 C5 E5').normalOrder [7, 8, 9, 0, 2, 4] >>> chord.Chord('E#3 A3 C#4').normalOrder [1, 5, 9] >>> chord.Chord('B5 G4 D5 E-5 D6').normalOrder [11, 2, 3, 7] >>> chord.Chord().normalOrder [] r^z(Could not find a normalOrder for chord: ) r5rrrorderedPitchClassesrrrAorderedPitchClassesString)rJrtransposedNormalForm orderedPCsmustBePresentPCstransposeAmountpcpossibleNormalOrders r) normalOrderChord.normalOrders|%% #)#G#G#L -- z?)OI]"^I]2$8B#>I] "^&'+;;** *G"4#A#ABCD D** I  #_sBB+B('B(c@[RUR5$)z Return the normal order/normal form of the Chord as a string representation. >>> c1 = chord.Chord(['c', 'e-', 'g']) >>> c1.normalOrder [0, 3, 7] >>> c1.normalOrderString '<037>' )rrrbrfs r)normalOrderStringChord.normalOrderString\s''(8(899r(cv[5nURHnURUR5 M U$)z helper function for orderedPitchClasses but also routines like pitchClassCardinality which do not need sorting. Returns a set of ints )rrr{rrJpcGroupr0s r)rChord._unorderedPitchClassesjs.%A KK %r(cF[[UR555$)z Return a list of pitch class integers, ordered form lowest to highest. >>> c1 = chord.Chord(['D4', 'A4', 'F#5', 'D6']) >>> c1.orderedPitchClasses [2, 6, 9] )rErrrfs r)rZChord.orderedPitchClassesvsF46689::r(c@[RUR5$)z Return a string representation of the pitch class values. >>> c1 = chord.Chord(['f#', 'e-', 'g']) >>> c1.orderedPitchClassesString '<367>' Redundancies are removed >>> c1 = chord.Chord(['f#', 'e-', 'e-', 'g']) >>> c1.orderedPitchClassesString '<367>' )rrrZrfs r)r[Chord.orderedPitchClassesStrings''(@(@AAr(c4[UR55$)z Return the cardinality of pitch classes, or the number of unique pitch classes, in the Chord: >>> c1 = chord.Chord(['D4', 'A4', 'F#5', 'D6']) >>> c1.pitchClassCardinality 3 )rQrrfs r)r)Chord.pitchClassCardinalitys4..011r(cf/nURHnURUR5 M U$)z Return a list of all pitch classes in the chord as integers. Not sorted >>> c1 = chord.Chord(['D4', 'A4', 'F#5', 'D6']) >>> c1.pitchClasses [2, 9, 6, 2] )rrorrhs r)rOChord.pitchClassess,A NN1<< (r(clURVs/sHoRRPM sn$s snf)aD Return a list of Pitch names from each :class:`~music21.pitch.Pitch` object's :attr:`~music21.pitch.Pitch.name` attribute. >>> c = chord.Chord(['g#', 'd-']) >>> c.pitchNames ['G#', 'D-'] >>> c = chord.Chord('C4 E4 G4 C4') >>> c.pitchNames ['C', 'E', 'G', 'C'] >>> c.pitchNames = ['c2', 'g2'] >>> c.pitchNames ['C', 'G'] )rDrrHrs r)rChord.pitchNamess&&'+kk2k k222s1cB[R"U5(af[US[5(a@/UlUH2nURR [ R"U55 M4 O[SU35e[SU35eUR5 g)Nrz-must provide a list containing a Pitch, not: z,cannot set pitch name with provided object: ) r isListLiker@rArDrorrnrrz)rJrrHs r)rrts   U # #%(C((  !DKK&&tyy7"%CE7KMM!#OPUw!WX X r(cURnUS:XaU$US;aURSR$URS::dSU;d SU;dSU;a3UR 5nURR SS 5nUS U3$UR 5nURR SS 5nUSU3$![a URSnN>f=f) a" Return a common name of this Chord including a pitch identifier, if possible: Most common chords will use the root as the pitch name and have it at the beginning: >>> c1 = chord.Chord(['c', 'e-', 'g']) >>> c1.pitchedCommonName 'C-minor triad' >>> c2 = chord.Chord(['c', 'e', 'g']) >>> c2.pitchedCommonName 'C-major triad' Because the hyphen is confusing w/ music21 flat notation, flats are displayed as "b": >>> c2a = chord.Chord('C-2 E-2 G-2') >>> c2a.pitchedCommonName 'Cb-major triad' Other forms might have the pitch elsewhere. Thus, this is a method for display, not for extracting information: >>> c3 = chord.Chord('A#2 D3 F3') >>> c3.pitchedCommonName 'enharmonic equivalent to major triad above A#' Note that in this case, the bass, not the root is used to determine the pitch name: >>> c4 = chord.Chord('D3 F3 A#3') >>> c4.pitchedCommonName 'enharmonic equivalent to major triad above D' >>> c5 = chord.Chord([1, 2, 3, 4, 5, 10]) >>> c5.pitchedCommonName 'forte class 6-36B above C#' >>> c4 = chord.Chord('D3 F3 A#3') >>> c4.pitchedCommonName 'enharmonic equivalent to major triad above D' A single pitch just returns that pitch name: >>> chord.Chord(['D3']).pitchedCommonName 'D' Unless there is more than one octave: >>> chord.Chord('D3 D4').pitchedCommonName 'Perfect Octave above D' >>> chord.Chord('D3 D4 D5').pitchedCommonName 'multiple octaves above D' Two different pitches give interval names: >>> chord.Chord('F3 C4').pitchedCommonName 'Perfect Fifth above F' Compound intervals are used unless there are multiple octaves: >>> chord.Chord('E-3 C5').pitchedCommonName 'Major Thirteenth above Eb' >>> chord.Chord('E-3 C5 C6').pitchedCommonName 'Major Sixth with octave doublings above Eb' These one-pitch-class and two-pitch-class chords with multiple enharmonics are unusual: >>> chord.Chord('D#3 E-3').pitchedCommonName 'enharmonic unison above D#' >>> chord.Chord('D#3 E-3 D#4').pitchedCommonName 'enharmonic octaves above D#' >>> chord.Chord('D#3 E-3 E3').pitchedCommonName '1 semitone above D#' >>> chord.Chord('D#3 E-3 F3 G--4').pitchedCommonName '2 semitones above D#' >>> chord.Chord().pitchedCommonName 'empty chord' * Changed in v5.5: octaves never included, flats are converted, special tools for enharmonics. * Changed in v6.5: special names for 0-, 1-, and 2-pitchClass chords. r)rrrr enharmonicz forte classr-rz above )rrrHr)r>replacerr)rJnameStrr>bassNamerrootNames r)pitchedCommonNameChord.pitchedCommonNamesp// m #N ( (<<?'' '  % % *' G+')99;Dyy((c2HYghZ0 0 'yy{yy((c2HZq * *" '||A 's B==CCc>[SUR55nU$)a6 Get or set a list or tuple of all Pitch objects in this Chord. >>> c = chord.Chord(['C4', 'E4', 'G#4']) >>> c.pitches (, , ) >>> [p.midi for p in c.pitches] [60, 64, 68] >>> d = chord.Chord() >>> d.pitches = c.pitches >>> d.pitches (, , ) >>> c = chord.Chord(['C4', 'A4', 'E5']) >>> c.bass() >>> c.root() Note here that the list will be converted to a tuple: >>> c.pitches = ['C#4', 'A#4', 'E#5'] >>> c.pitches (, , ) Bass and root information is also changed. >>> c.bass() >>> c.root() c38# UHoRv M g7fr5r)r6 components r)r9 Chord.pitches..gs0^R]YR]r}r)rJrs r)r Chord.pitches?s!P,10^RVR]R]0^+^r(c/UlUR5 UH2nURR[R"U55 M4 gr5)rDrzrorrn)rJrr0s r)rrjs7  A KK  tyy| ,r(c[[R"UR55$![Ra /s$f=f)a  Return a representation of the Chord as a prime-form list of pitch class integers: >>> c1 = chord.Chord(['c', 'e-', 'g']) >>> c1.primeForm [0, 3, 7] >>> c2 = chord.Chord(['c', 'e', 'g']) >>> c2.primeForm [0, 3, 7] OMIT_FROM_DOCS >>> chord.Chord().primeForm [] )rEraddressToPrimeFormr5rrfs r) primeFormChord.primeFormss=& 11$2I2IJK K** I s(+AAc@[RUR5$)z Return a representation of the Chord as a prime-form set class string. >>> c1 = chord.Chord(['c', 'e-', 'g']) >>> c1.primeFormString '<037>' >>> c1 = chord.Chord(['c', 'e', 'g']) >>> c1.primeFormString '<037>' )rrrrfs r)primeFormStringChord.primeFormStrings''77r(cURS5nURS5nUcgURS5(agURS5(agUcUS:XagUS:XaggURS5(agUS:XaUS:XagUS:XaUS:XagUS :XaUS:Xag US :XaUS:Xag g![a gf=f) a Returns the quality of the underlying triad of a triad or seventh, either major, minor, diminished, augmented, or other: >>> a = chord.Chord(['a', 'c', 'e']) >>> a.quality 'minor' Inversions don't matter, nor do added tones so long as a root can be found: >>> a = chord.Chord(['f', 'b', 'd', 'g']) >>> a.quality 'major' >>> a = chord.Chord(['c', 'a-', 'e']) >>> a.quality 'augmented' >>> a = chord.Chord(['c', 'c#', 'd']) >>> a.quality 'other' Incomplete triads are returned as major or minor: >>> a = chord.Chord(['c', 'e-']) >>> a.quality 'minor' >>> a = chord.Chord(['e-', 'g']) >>> a.quality 'major' Chords that contain more than one triad return 'other' >>> chord.Chord('C C# E G').quality 'other' >>> chord.Chord('C E- E G').quality 'other' >>> chord.Chord('C E G- G').quality 'other' Note these two edge cases: >>> chord.Chord('C D E').quality # NB! Major 9th. 'major' >>> chord.Chord('C E--').quality 'other' Empty chords are definitely 'other': >>> chord.Chord().quality 'other' r3rrSrrmajorminorrr augmentedrt diminished)rrr)rJrorps r)quality Chord.qualitysr //2E//2E =  & &q ) )  & &q ) ) ]z!  & &q ) ) aZEQJ aZEQJ aZEQJ aZEQJ9  s"B44 CCcSSKJn [US5(aURb URnOUR UR SS9nUcg/nUR HnURUSURRS9nUcURS 5 M>URUURRS 9nURUR:XaURUS45 MURUl U[R"[!UR"UR"- 554nURU5 M U$) a Returns a list of two-element tuples for each pitch in the chord where the first element of the tuple is the scale degree as an int and the second is an Accidental object that specifies the alteration from the scale degree (could be None if the note is not part of the scale). It is easiest to see the utility of this method using a chord subclass, :class:`music21.roman.RomanNumeral`, but it is also callable from this Chord object if the Chord has a Key or Scale context set for it. >>> k = key.Key('f#') # 3-sharps minor >>> rn = roman.RomanNumeral('V', k) >>> rn.key >>> rn.pitches (, , ) >>> rn.scaleDegrees [(5, None), (7, ), (2, None)] >>> rn2 = roman.RomanNumeral('N6', k) >>> rn2.pitches (, , ) >>> rn2.scaleDegrees # N.B. -- natural form used for minor! [(4, None), (6, None), (2, )] As mentioned above, the property can also get its scale from context if the chord is embedded in a Stream. Let's create the same V in f#-minor again, but give it a context of c-sharp minor, and then c-minor instead: >>> chord1 = chord.Chord(['C#5', 'E#5', 'G#5']) >>> st1 = stream.Stream() >>> st1.append(key.Key('c#')) # c-sharp minor >>> st1.append(chord1) >>> chord1.scaleDegrees [(1, None), (3, ), (5, None)] >>> st2 = stream.Stream() >>> chord2 = chord.Chord(['C#5', 'E#5', 'G#5']) >>> st2.append(key.Key('c')) # c minor >>> st2.append(chord2) # same pitches as before gives different scaleDegrees >>> chord2.scaleDegrees [(1, ), (3, ), (5, )] >>> st3 = stream.Stream() >>> st3.append(key.Key('C')) # C major >>> chord2 = chord.Chord(['C4', 'C#4', 'D4', 'E-4', 'E4', 'F4']) # 1st 1/2 of chromatic >>> st3.append(chord2) >>> chord2.scaleDegrees [(1, None), (1, ), (2, None), (3, ), (3, None), (4, None)] If no context can be found, return `None`: >>> chord.Chord('C4 E4 G4').scaleDegrees is None True * Changed in v6.5: will return `None` if no context can be found: r)scalerNT)sortByCreationTimer)comparisonAttribute direction)NN)r)music21rr~rgetContextByClassScalergetScaleDegreeFromPitch Direction DESCENDINGropitchFromDegreerHrbr Accidentalrsrd)rJrscdegreesrdegree actualPitchtupleKeys r) scaleDegreesChord.scaleDegreess+B " 4  DHH$8B'' 'MBzI//$*//440F ~|, 00#oo881 ##y~~5NNFD>2)2)9)9K& & % 0 0Y\\KNN5R1S T VHNN8,'&(r(cFURS5$![a gf=f)a Shortcut for getChordStep(7), but caches the value >>> bDim7_2ndInv = chord.Chord(['F2', 'A-3', 'B4', 'D5']) >>> bDim7_2ndInv.seventh Test whether this strange chord gets the B# not the C or something else: >>> c = chord.Chord(['C4', 'E4', 'G4', 'B#4']) >>> c.seventh * Changed in v6.5: return None on empty chords/errors OMIT_FROM_DOCS >>> chord.Chord().seventh rNr)rfs r)rk Chord.seventhWs*, $$Q' '  r,cFURS5$![a gf=f)a2 Shortcut for getChordStep(3), but caches the value, and returns None on errors. >>> cMaj1stInv = chord.Chord(['E3', 'C4', 'G5']) >>> cMaj1stInv.third >>> cMaj1stInv.third.octave 3 * Changed in v6.5: return `None` on empty chords/errors OMIT_FROM_DOCS >>> chord.Chord().third r3Nr)rfs r)ro Chord.thirdrr+r,)r"rDrr5)rKzmt.Union[None, Sequence[pitch.Pitch], Sequence[note.Note], Sequence[Chord], Sequence[str], str, Sequence[int]])rz#int | str | note.Note | pitch.Pitch)rrA)rpitch.Pitch | None)rJrrrArz_ChordType | list[pitch.Pitch]r) rJrrrrrrrrt.Literal[True]r list[str]) rJrrrrrrrrt.Literal[False]rr) rJrrrrrrrrrrr) rJrrrrrrrrrrz_ChordType | None | list[str])rJrrSrrr)r=rr9 bool | Noner:rr pitch.Pitch)r=str | pitch.Pitch | note.Noter9rr:rrr)r=$None | str | pitch.Pitch | note.Noter9rr:rrrr) rJrrU int | NonerrrVrrr) rJrrUrrrrVrrr) rJrrUrrrrVrrz_ChordType | None)rr)rz list[int])rrsrznote.Note | pitch.Pitch | Nonerr)rz Chord | None) rrsr9rrrrrrr) rrr9rrrrrrrs) rrr9rrrrrrr)rrsrrrrrr)rrrrs)rr) rsztuple[int, int, int]rtrsr'rruzlist[tuple[str, str]]rr)rrr9rrr)rrr9rrr)rrr9rrr)rJrrrrr)rJrrrrr) rJrrUrrz"t.Literal[True] | t.Literal[False]rVrrzNone | _ChordType)rz tie.Tie | str)rz volume.Volumerzstr | note.Note | pitch.Pitch)rr)r'r)rztuple[note.Note, ...])rXzIterable[note.Note]rr)rzset[int])rrs)rr)rztuple[pitch.Pitch, ...])rzIterable[pitch.Pitch]rr)r#r$r%r&rr _DOC_ORDERr1rrr+rFrPrWrrr staticmethodrrrr{r rr7r>rOrSrYrlrjrrrrrrrrrrrrrrrFrrrr$r/rr4r8rAr@rHrNrNr+r,rcrhrkr*rWr3rMrRrrrr-rr%rr7rrrrrrrrrrrrrrrrr5rr;rrprr5r8r<r?rrFrIrLrPrKrbrerrZr[r)rOrr~rrrrrrkror'rrs@r)rrHs JXGJ 6!I~ Y(()263/330"}~+&Z$:2 &7&7&7 & &7^ 5-  5-5-n $        $      !% ',   !     %     %* $ ',   "     %      $  iii i  i  i #iV4              *        37Y' Y'/Y' Y'  Y'  Y'v"$!%&+    !  $     !%$)&+    "  $     !%&+ DDD D $ D  DL)VBX5t@$L04 @@- @  @D-^"H%N&P6N6!L(6;?8<@: %)#     #       " %)#     #       "&Q%)# QQ Q # Q  Q Qf')')') ')  ')R!F$XL?B6;(T+6+6ZeeN22&<66:33.998 2 2":,6&&4==" & &;";"z \\ * *IDIDV : : ;;BB  2 2  33(  m+m+^((T ^^--. 8 8VVr^^@2r(rcSnSnSn[U[5(aSU;asURS5n[US5n[R "US5upV[U5nSUR 5;aSnOSUR 5;aSnO[SU35e[R"U5(aR[U5S ::a5U(aUSn[U5S:aUSn[U5S :aUS nO[S U35e[S U35e[R"XU/5n[U5$) a Return a Chord given a Forte-class notation. The Forte class can be specified as string (e.g., 3-11) or as a list of cardinality and number (e.g., [8, 1]). If no match is available, None is returned. >>> chord.fromForteClass('3-11') >>> chord.fromForteClass('3-11b') >>> chord.fromForteClass('3-11a') >>> chord.fromForteClass((11, 1)) Nrryrarrz5cannot extract set-class representation from string: r3r"cannot handle specified notation: ) r@rArBrsr getNumFromStrrrrvrQrrr)r1cardnumr notationPartsstr_numcharsrs r)r r s=* D C C(C  (?$NN3/M}Q'(D#11-2BCNGg,Cekkm# % GzRT T   8 $ $ x=A {8}q qk8}q qk #EhZ!PQ QA(LMM  0 0$S1A BE <r(cSn[R"U5(a%[U5S:Xa[R"U5nUc[ SU35e/nUH1nUR [[R"U555 M3 [U5S:XaUS$[U5S:Xa U(dUS$[U5S:Xa U(aUS$g)a Return one or more Chords given an interval vector. >>> chord.fromIntervalVector([0, 0, 0, 0, 0, 1]) >>> chord.fromIntervalVector((5, 5, 5, 5, 5, 5)) is None True >>> chord.fromIntervalVector((1, 1, 1, 1, 1, 1)) >>> chord.fromIntervalVector((1, 1, 1, 1, 1, 1), getZRelation=True) >>> chord.fromIntervalVector((1, 1, 1, 1, 1, 1)).getZRelation() Nrtrrrr) rrvrQrrrrorr)r1r addressListrrs r)rrs(K "" x=A  88BKA(LMM D E&>>wGHI 4yA~Aw Ta Aw TaLAwr(c\rSrSrSrSrSrg)Testiz# Most tests now in test/test_chord c2SSKJn U"U[55 g)Nr) testCopyAll)music21.test.commonTestrglobals)rJrs r)testCopyAndDeepcopyTest.testCopyAndDeepcopys7D')$r(r"N)r#r$r%r&rrr'r"r(r)rrs %r(r__main__)r1zstr | Sequence[int]rr)F)3r __future__r__all__collections.abcr r rptypingrr unittestrr rmusic21.common.decoratorsrrmusic21.durationrrrrrrrr music21.chordrrrr music21.styler Environment environLocalTypeVarrrMusic21Exceptionrrrr+rr rTestCaserrr#mainTestr"r(r)rs # `. 1%  ??#&&w/ +3LM YY|+@ A  \22 J- J-\AUIAUJj4n'X%8  %W  z Tr(