3j8 UdZddlmZddlZddlZddlZddlmZddlZddl Z ddl m Z ddl m Z ddlmZddl mZdd l mZdd l mZdd l mZdd l mZdd l mZddl mZej.dZeezej6zej8zZiZded<dZ dZ!dZ"dddddddddd Z# d* d+dZ$GddejJZ&Gdd ejJZ'Gd!d"e(Z)Gd#d$e jTZ+Gd%d&e+ejXZ-Gd'd(ej\Z/e+e-gZ0e1d)k(rddl Z e jde/yy),aQ This module defines objects for representing key signatures as well as key areas. The :class:`~music21.key.KeySignature` is used in :class:`~music21.stream.Measure` objects for defining notated key signatures. The :class:`~music21.key.Key` object is a fuller representation not just of a key signature but also of the key of a region. ) annotationsN)overload)base) cacheMethod)StepName) environment) exceptions21)interval)note)pitch)scale)stylekeyzdict[int, pitch.Pitch]_sharpsToPitchCachec|jdr|dk(r |S|dk(rd}|S|dk(rd}|St|dk(r|ddk(r |dd z}|St|d d dhk(r|dd t|d z zz}|S) a+ Utility function to change strings in the form of "Eb" to "E-" (for E-flat major) and leaves alone proper music21 strings (like "E-" or "f#"). A little bit complex because of parsing bb as B-flat minor and Bb as B-flat major. >>> key.convertKeyStringToMusic21KeyString('Eb') 'E-' >>> key.convertKeyStringToMusic21KeyString('f#') 'f#' >>> key.convertKeyStringToMusic21KeyString('bb') 'b-' >>> key.convertKeyStringToMusic21KeyString('Bb') 'B-' >>> key.convertKeyStringToMusic21KeyString('b#') 'b#' >>> key.convertKeyStringToMusic21KeyString('c') 'c' >>> key.convertKeyStringToMusic21KeyString('Bbb') 'B--' >>> key.convertKeyStringToMusic21KeyString('bbb') 'b--' >>> key.convertKeyStringToMusic21KeyString('Ebb') 'E--' bbbzb-BbB-r-N)endswithlenset) textStrings 8/DATA/.local/lib/python3.12/site-packages/music21/key.py"convertKeyStringToMusic21KeyStringr1s4    $s):   t    t   ZA *R.C"7]S(   Z^  %]SC Oa,?%@@ cP|d}|tvrtjt|Stjd}d|_|dkDrd}n |dkrd}n|St j|}tt|D]}|j|}d|_|t|<|S)a Given a positive/negative number of sharps, return a Pitch object set to the appropriate major key value. >>> key.sharpsToPitch(1) >>> key.sharpsToPitch(2) >>> key.sharpsToPitch(-2) >>> key.sharpsToPitch(-6) Note that these are :class:`music21.pitch.Pitch` objects not just names: >>> k1 = key.sharpsToPitch(6) >>> k1 >>> k1.step 'F' >>> k1.accidental OMIT_FROM_DOCS The second time we do something it should be in the cache, so let's make sure it still works: >>> key.sharpsToPitch(1) >>> key.sharpsToPitch(1) >>> 1 in key._sharpsToPitchCache True >>> key._sharpsToPitchCache[1] NrCP5zP-5) rcopydeepcopyr Pitchoctaver IntervalrangeabstransposePitch) sharpCount pitchInit intervalStr intervalObjis r sharpsToPitchr1XsJ ((}}0<== C IIA~ a ##K0K 3z? #..y9 $I&/ # r )Fr"GDAEBrr) majorionianminoraeoliandorianphrygianlydian mixolydianlocrianct|trtj|}nRt|tjr|}n5t|tj r |j}nt d|tj|jdz }|jN|jjdur t dt|jj}|d|zz}||tvr |t|z }|S)a Given a pitch string or :class:`music21.pitch.Pitch` or :class:`music21.note.Note` object, return the number of sharps found in that mode. The `mode` parameter can be 'major', 'minor', or most of the common church/jazz modes ('dorian', 'mixolydian', etc.) including Locrian. If `mode` is omitted or not found, the default mode is major. (extra points to anyone who can find the earliest reference to the Locrian mode in print. David Cohen and I (MSAC) have been looking for this for years). >>> key.pitchToSharps('c') 0 >>> key.pitchToSharps('c', 'minor') -3 >>> key.pitchToSharps('a', 'minor') 0 >>> key.pitchToSharps('d') 2 >>> key.pitchToSharps('e-') -3 >>> key.pitchToSharps('a') 3 >>> key.pitchToSharps('e', 'minor') 1 >>> key.pitchToSharps('f#', 'major') 6 >>> key.pitchToSharps('g-', 'major') -6 >>> key.pitchToSharps('c#') 7 >>> key.pitchToSharps('g#') 8 >>> key.pitchToSharps('e', 'dorian') 2 >>> key.pitchToSharps('d', 'dorian') 0 >>> key.pitchToSharps('g', 'mixolydian') 0 >>> key.pitchToSharps('e-', 'lydian') -2 >>> key.pitchToSharps('e-', 'lydian') -2 >>> key.pitchToSharps('a', 'phrygian') -1 >>> key.pitchToSharps('e', 'phrygian') 0 >>> key.pitchToSharps('f#') 6 >>> key.pitchToSharps(note.Note('f-')) -8 >>> key.pitchToSharps(pitch.Pitch('f--')) -15 >>> key.pitchToSharps('f--', 'locrian') -20 >>> key.pitchToSharps('a', 'ionian') 3 >>> key.pitchToSharps('a', 'aeolian') 0 But quarter tones don't work: >>> key.pitchToSharps('C~') Traceback (most recent call last): music21.key.KeyException: Cannot determine sharps for quarter-tone keys! silly! z&Cannot get a sharp number from value: rFz5Cannot determine sharps for quarter-tone keys! silly!) isinstancestrr r&r Note KeyException fifthsOrderindexstep accidental isTwelveToneintaltermodeSharpsAlter)valuemode pitchValuesharpsvaas r pitchToSharpsrXsR%[[' E5;; ' E499 %[[ CE7KLL  z /! 3F(  - - /5 8VW W*''--.!c'! DO3/$'' Mr c eZdZy)KeySignatureExceptionN__name__ __module__ __qualname__r rrZrZr rZc eZdZy)rJNr[r_r rrJrJ r`r rJc eZdZy) KeyWarningNr[r_r rrcrcr`r rccPeZdZdZej ZdZdZddfd Z dZ dZ dddZ e eddZej dd Ze dd Zdd Zed d  ddZe d dZd d  d!dZd d d"dZd#dZd$dZd%dZe eedZxZS)& KeySignaturea& A KeySignature object specifies the signature to be used for a piece; it normally takes one argument: an `int` giving the number of sharps, or, if negative, the number of flats. If you are starting with the name of a key, see the :class:`~music21.key.Key` object. >>> A = key.KeySignature(3) >>> A >>> Eflat = key.KeySignature(-3) >>> Eflat If you want to get a real Key, then use the :class:`~music21.key.Key` object instead: >>> illegal = key.KeySignature('c#') Traceback (most recent call last): music21.key.KeySignatureException: Cannot get a KeySignature from this "number" of sharps: 'c#'; did you mean to use a key.Key() object instead? >>> legal = key.Key('c#') >>> legal.sharps 4 >>> legal To set a non-traditional Key Signature, create a KeySignature object with `sharps=None`, and then set the `alteredPitches` list: >>> unusual = key.KeySignature(sharps=None) >>> unusual.alteredPitches = ['E-', 'G#'] >>> unusual >>> unusual.isNonTraditional True To set a pitch as displayed in a particular octave, create a non-traditional KeySignature and then set pitches with octaves: >>> unusual = key.KeySignature(sharps=None) >>> unusual.alteredPitches = ['F#4'] >>> unusual If the accidental applies to all octaves but is being displayed differently then you are done, but if you want them to apply only to the octave displayed in then set `.accidentalsApplyOnlyToOctave` to `True`: >>> unusual.accidentalsApplyOnlyToOctave False >>> unusual.accidentalsApplyOnlyToOctave = True **Equality** Two KeySignatures are equal if they pass all `super().__eq__` checks and their sharps are equal. Currently, non-standard key signatures are not checked (this may change). >>> sharp2 = key.KeySignature(2) >>> flat4 = key.KeySignature(-4) >>> sharp2 == flat4 False >>> sharp2 == key.KeySignature(2) True * Changed in v7: `sharps` defaults to 0 (key of no flats/sharps) rather than `None` for nontraditional keys. )rVrc t|di| | |t|k7rtd|ddz||_d|_d|_y#t$r}td|ddz|d}~wwxYw)Nz8Cannot get a KeySignature from this "number" of sharps: z; z/did you mean to use a key.Key() object instead?Fr_)super__init__rPrZ ValueError_sharps_alteredPitchesaccidentalsApplyOnlyToOctave)selfrVkeywordsve __class__s rrhzKeySignature.__init__ds $8$ !vV'<+NvjXZ[GHII 8<,1) 'J6*TVWCD  s"A A+A&&A+c d}|j}|:ddj|jDcgc] }t|c}zdz}|S|dkDr|d}|S|dk(rd}|S|dk(rd }|S|d k(rd }|St |d }|Scc}w) Nz pitches: [z, ]rz sharpsz1 sharprzno sharps or flatsrz1 flatz flats)rVjoinalteredPitchesrHr*)rmoutputnsps r_strDescriptionzKeySignature._strDescription{s [[ :!DIIt?R?R.S?R!s1v?R.S$TTWZZF !Vt7^F 1WF 1W)F  2XF By'F /TsB c(d|jzSNzof )ryrms r _reprInternalzKeySignature._reprInternalst++---r c4|jxsd}|!|tjd|td||d}|=|;tj Dcic]\}}|| }}}t |} |||z }tjt|}|j}|tvrtd |d t|} t|| z } t| j|Scc}}w#t$r!}td|jd||d}~wwxYw) a Return a `key.Key` object representing this KeySignature object as a key in the given mode or in the given tonic. If `mode` is None, and `tonic` is not provided, major is assumed. If both mode and tonic are provided, the tonic is ignored. >>> ks = key.KeySignature(2) >>> ks.asKey() >>> ks.asKey(mode='minor') If `mode` is None, an attempt is made to solve for the mode: >>> ks.asKey(tonic='A') But will raise `KeyException` if an impossible solution is requested: >>> ks.asKey(tonic='D#') Traceback (most recent call last): music21.key.KeyException: Could not solve for mode from sharps=2, tonic=D# Ionian and Aeolian are supplied instead of major or minor when deriving mode in this way: >>> ks2 = key.KeySignature() >>> ks2.asKey() >>> ks2.asKey(tonic='C') * New in v7: `tonic` argument to solve for mode. rNzignoring provided tonic: r) stacklevelr<z%Could not solve for mode from sharps=z, tonic=zMode z is unknown)rVwarningswarnrcrRitemsrXKeyErrorrJtcastrHlowerr1Keyname) rmrTtonic our_sharpskvmajorSharpsToMode majorSharpskesharpAlterationFromMajorpitchObjs rasKeyzKeySignature.asKeys=B[[%A   1 MM5eW=zVW X >> a = key.KeySignature(3) >>> a.alteredPitches [, , ] >>> b = key.KeySignature(1) >>> b.alteredPitches [] >>> c = key.KeySignature(9) >>> [str(p) for p in c.alteredPitches] ['F#', 'C#', 'G#', 'D#', 'A#', 'E#', 'B#', 'F##', 'C##'] >>> d = key.KeySignature(-3) >>> d.alteredPitches [, , ] >>> e = key.KeySignature(-1) >>> e.alteredPitches [] >>> f = key.KeySignature(-6) >>> [str(p) for p in f.alteredPitches] ['B-', 'E-', 'A-', 'D-', 'G-', 'C-'] >>> g = key.KeySignature(-8) >>> [str(p) for p in g.alteredPitches] ['B-', 'E-', 'A-', 'D-', 'G-', 'C-', 'F-', 'B--'] Non-standard, non-traditional key signatures can set their own altered pitches cache. >>> nonTrad = key.KeySignature(sharps=None) >>> nonTrad.alteredPitches = ['B-', 'F#', 'E-', 'G#'] >>> nonTrad.alteredPitches [, , , ] OMIT_FROM_DOCS Ensure at least something is provided when the user hasn't provided enough info: >>> nonTrad2 = key.KeySignature(sharps=None) >>> nonTrad2.alteredPitches [] Nrr7r#TinPlacer2P4) rkrVr r&r) transposer$r%r'appendr*)rmpostpKeepr0rxs rruzKeySignature.alteredPitchess p    +'' '"$ ;; K ;;?KK$E{{Q4;;'d3MM%( A ( [[1_KK$E3t{{+,d3MM%( A -  r c|jg}|D]}t|tr%|jt j |8t|tj r|j|dt|t js|jtj|j||_ yN) clearCacherGrHrr r&r rIr$r%rk)rmnewAlteredPitchesnewListrxs rruzKeySignature.alteredPitchess %'"A!S!u{{1~.Au{{+q!Atyy)t}}QWW56 # 'r c6|j |jryy)a Returns bool if this is a non-traditional KeySignature: >>> g = key.KeySignature(3) >>> g.isNonTraditional False >>> g = key.KeySignature(sharps=None) >>> g.alteredPitches = [pitch.Pitch('E`')] >>> g.isNonTraditional True >>> g >>> g.accidentalByStep('E') TF)rVrur|s risNonTraditionalzKeySignature.isNonTraditional(s( ;; 4#6#6r ct|jD]N}|jj|jk(s/t j |j cSy)aN Given a step (C, D, E, F, etc.) return the accidental for that note in this key (using the natural minor for minor) or None if there is none. >>> g = key.KeySignature(1) >>> g.accidentalByStep('F') >>> g.accidentalByStep('G') is None True >>> f = key.KeySignature(-1) >>> bbNote = note.Note('B-5') >>> f.accidentalByStep(bbNote.step) Fix a wrong note in F-major: >>> wrongBNote = note.Note('B#4') >>> if f.accidentalByStep(wrongBNote.step) != wrongBNote.pitch.accidental: ... wrongBNote.pitch.accidental = f.accidentalByStep(wrongBNote.step) >>> wrongBNote Set all notes to the correct notes for a key using the note's Key Context. Before: >>> s1 = stream.Stream() >>> s1.append(key.KeySignature(4)) # E-major or C-sharp-minor >>> s1.append(note.Note('C', type='half')) >>> s1.append(note.Note('E-', type='half')) >>> s1.append(key.KeySignature(-4)) # A-flat-major or F-minor >>> s1.append(note.Note('A', type='whole')) >>> s1.append(note.Note('F#', type='whole')) >>> #_DOCS_SHOW s1.show() .. image:: images/keyAccidentalByStep_Before.* :width: 400 After: >>> for n in s1.notes: ... n.pitch.accidental = n.getContextByClass(key.KeySignature).accidentalByStep(n.step) >>> #_DOCS_SHOW s1.show() .. image:: images/keyAccidentalByStep.* :width: 400 OMIT_FROM_DOCS >>> s1.show('text') {0.0} {0.0} {2.0} {4.0} {4.0} {8.0} Test to make sure there are not linked accidentals (fixed bug 22 Nov. 2010) >>> nB1 = note.Note('B', type='whole') >>> nB2 = note.Note('B', type='whole') >>> s1.append(nB1) >>> s1.append(nB2) >>> for n in s1.notes: ... n.pitch.accidental = n.getContextByClass(key.KeySignature).accidentalByStep(n.step) >>> (nB1.pitch.accidental, nB2.pitch.accidental) (, ) >>> nB1.pitch.accidental.name = 'sharp' >>> (nB1.pitch.accidental, nB2.pitch.accidental) (, ) N)reversedrurMrr$r%rN)rmrMthisAlterations raccidentalByStepzKeySignature.accidentalByStepAsQR't':':;N""((*djjl:}}^%>%>??< r Frcyrr_rmrSrs rrzKeySignature.transpose r cyrr_rs rrzKeySignature.transposerr ct|tjr|}n2t|tjr|}ntj|}|st j |}n|}|j d}|j}|j|}t|tr'tt|dkDr|j}t||_ |j|s|Sy)aG Transpose the KeySignature by the user-provided value. If the value is an integer, the transposition is treated in half steps. If the value is a string, any Interval string specification can be provided. Alternatively, a :class:`music21.interval.Interval` object can be supplied. >>> a = key.KeySignature(2) >>> a >>> a.asKey('major') >>> b = a.transpose('p5') >>> b >>> b.asKey('major') >>> b.sharps 3 >>> c = b.transpose('-m2') >>> c.asKey('major') >>> c.sharps 8 >>> d = c.transpose('-a3') >>> d.asKey('major') >>> d.sharps -3 Transposition by semitone (or other chromatic interval) >>> c = key.KeySignature(0) >>> dFlat = c.transpose(1) >>> dFlat >>> d = dFlat.transpose(1) >>> d >>> eFlat = d.transpose(1) >>> eFlat r<N)rGr r(GenericIntervalr$r%rrr+rPr*rX getEnharmonicrVr)rmrSrr/rk1p1p2s rrzKeySignature.transposesf eX.. /K x77 8K"++E2K==&DD ZZ  XX  ' ' + eS !c-*;&>> ks = key.KeySignature(-3) >>> p1 = pitch.Pitch('B') >>> p2 = ks.transposePitchFromC(p1) >>> p2.name 'D' Original pitch is unchanged: >>> p1.name 'B' >>> ks2 = key.KeySignature(2) >>> p2 = ks2.transposePitchFromC(p1) >>> p2.name 'C#' For out of scale pitches the relationship still works; note also that original octave is preserved. >>> p3 = pitch.Pitch('G-4') >>> p4 = ks.transposePitchFromC(p3) >>> p4.nameWithOctave 'B--4' If inPlace is True then the original pitch is modified and nothing is returned. >>> p5 = pitch.Pitch('C5') >>> ks.transposePitchFromC(p5, inPlace=True) >>> p5.nameWithOctave 'E-5' Nrrr#Tr) r'r$r%rVr*r r(r)r+)rmrxr transInterval transTimesoriginalOctaver0s rtransposePitchFromCz KeySignature.transposePitchFromCsP   a A ;;! H [[1_T[[)J$--d3MJ$--d3Mz"A  ( (D ( 9#  %%AHHr c|j|j}|dvrtj|S|dk(rtj|St d|)a@ Return a :class:`music21.scale.Scale` object (or, actually, a subclass such as :class:`~music21.scale.MajorScale` or :class:`~music21.scale.MinorScale`) that is representative of this key signature and mode. Raises KeySignatureException if mode is not in [None, 'major', 'minor']. >>> ks = key.KeySignature(3) >>> ks >>> ks.getScale('major') >>> ks.getScale('minor') )Nr<r>z0No mapping to a scale exists for this mode yet: )rrr MajorScale MinorScalerZ)rmrTrs rgetScalezKeySignature.getScale4s^ ::d#)) ? "##H- - W_##H- -'*Z[_Z`(ab br c|jSr)rjr|s r _getSharpszKeySignature._getSharpsOs ||r cR||jk7r||_|jyyr)rjr)rmrSs r _setSharpszKeySignature._setSharpsRs$ DLL  DL OO  !r a Get or set the number of sharps. If the number is negative then it sets the number of flats. Equivalent to musicxml's 'fifths' attribute. >>> ks1 = key.KeySignature(2) >>> ks1.sharps 2 >>> ks1.sharps = -4 >>> ks1 Can be set to None for a non-traditional key signature )doc)r)rV int | None)NN)rT str | Nonerr)returnzlist[pitch.Pitch])rz#list[str | pitch.Pitch | note.Note]rNone)rbool)rMrrzpitch.Accidental | NonerSTransposeTypesrzt.Literal[False]rzt.SelfrSrrzt.Literal[True]rrrSrrrrz t.Self | None)rx pitch.Pitchrzpitch.Pitch | None)r<)rr)rSr)r\r]r^__doc__r TextStyle _styleClassequalityAttributesclassSortOrderrhryr}rpropertyrrusetterrrrrrrrrrV __classcell__rps@rreresUEL//K$ N2.".6(pOOb '  ' '0Nd/4 ' , 9?   ' + 04  #(L'L L-8L\>CCJc6 j*   Fr rec eZdZUdZdZdZded<ded< d ddZd Zd Z d Z d Z e dd Z e ddZe ddZfdZdZdddZedd ddZe ddZdd d fdZxZS)!ra Note that a key is a sort of hypothetical/conceptual object. It probably has a scale (or scales) associated with it and a :class:`~music21.key.KeySignature`, but not necessarily. A Key object has all the attributes of a KeySignature and all the attributes of a :class:`~music21.scale.DiatonicScale`. >>> cm = key.Key('c') # lowercase = c minor. >>> cm >>> cm.mode 'minor' >>> cm.tonic >>> cm.sharps -3 >>> cm.pitchFromDegree(3) >>> cm.pitchFromDegree(7) >>> cSharpMaj = key.Key('C#') # uppercase = C# major >>> cSharpMaj >>> cSharpMaj.sharps 7 >>> fFlatMaj = key.Key('F-') >>> fFlatMaj >>> fFlatMaj.sharps -8 >>> fFlatMaj.accidentalByStep('B') >>> eDor = key.Key('E', 'dorian') >>> eDor >>> eDor.sharps 2 >>> eDor.pitches [, , , , , , , ] If you prefer not to use uppercase and lowercase to distinguish major and minor, the shorthand of CM or Cm can also be used: >>> key.Key('EM') >>> key.Key('F#m') **Equality** Two Keys are equal if their tonics' names are equal, their sharps are equal, and their modes are equal (and they pass all superclass tests) >>> k = key.Key(pitch.Pitch('C4')) >>> k2 = key.Key(pitch.Pitch('C5')) >>> k == k2 True >>> k.mode = 'minor' >>> k == k2 False * Changed in v8: keys now compare equal regardless of the octave of their tonics. rNr_moderrc (t|tjtjfr |j }n|}|Ud|vrd}t jdd|}nGd|vrd}t jdd|}n)|j|k(rd}nd}n|j}t||}t|tjr|}nrrMr<r)rGr rIr r&rresubrrXrerhr DiatonicScalertyperT _abstract buildNetworkcorrelationCoefficientalternateInterpretations)rmrrTrntonicStrrV tonicPitchs rrhz Key.__init__sR edii5 6zzHH <h66#r8466#r84!X-::> % NN ' ' 2 '+#46%r cdt|zSr{)rHr|s rr}zKey._reprInternalss4y  r c<|j}|d|jS)N )tonicPitchNameWithCaserT)rmrs r__str__z Key.__str__s$++$))%%r ctj||sy|jj|jjk(xr|j|jk(S)NF)re__eq__rrrT)rmothers rrz Key.__eq__sD""4/zz%++"2"22NtyyEJJ7NNr ct|dz S)N)idr|s r__hash__z Key.__hash__s$x1}r c|jdvr|S|jdk(r$t|jjdSt|jjdS)an if the Key is major or minor, return the relative minor or major. Otherwise, just returns self -- this is the best way to not have random crashes in the middle of large datasets. Note that this uses .sharps as a speedup, so if that has been changed, there will be a problem: >>> k = key.Key('E-') >>> k >>> k.relative >>> k.relative.relative >>> key.Key('D', 'dorian').relative r>r<r<r>)rTrerVrr|s rrelativez Key.relativesV, 99. .K 99  ,227; ; ,227; ;r c|jdvr|S|jdk(rt|jdSt|jdS)a if the Key is major or minor, return the parallel minor or major. Otherwise, just returns self -- this is the best way to not have random crashes in the middle of large datasets. >>> k = key.Key('D') >>> k >>> k.parallel >>> k.parallel.parallel >>> key.Key('D', 'dorian').parallel rr<r>)rTrrr|s rparallelz Key.parallelsD& 99. .K 99 tzz7+ +tzz7+ +r c|jj}|jdk(r|j}|S|jdk(r|j }|S)a Return the pitch name as a string with the proper case (upper = major; lower = minor) Useful, but simple: >>> k = key.Key('c#') >>> k.tonicPitchNameWithCase 'c#' >>> k = key.Key('B') >>> k.tonicPitchNameWithCase 'B' >>> k.mode = 'minor' >>> k.tonicPitchNameWithCase 'b' Anything else will return the default (capital) >>> k.mode = 'dorian' >>> k.tonicPitchNameWithCase 'B' r<r>)rrrTupperr)rmrs rrzKey.tonicPitchNameWithCase7sO.::?? 99 ~~'HYY' !~~'Hr cft|||}|j|_d|_g|_|S)ai Given a degree and pitchReference derive a new Key object that has the same mode but a different tonic Example: What minor key has scale degree 3 as B-flat? >>> minorKey = key.Key(mode='minor') >>> newMinor = minorKey.deriveByDegree(3, 'B-') >>> newMinor Note that in minor, the natural form is used: >>> minorKey.deriveByDegree(7, 'E') >>> minorKey.deriveByDegree(6, 'G') To use the harmonic form, change `.abstract` on the key to another abstract scale: >>> minorKey.abstract = scale.AbstractHarmonicMinorScale() >>> minorKey.deriveByDegree(7, 'E') >>> minorKey.deriveByDegree(6, 'G') Currently because of a limitation in bidirectional scale searching, melodic minor scales cannot be used as abstracts for deriving by degree. * New in v6: preserve mode in key.Key.deriveByDegree. N)rgderiveByDegreerTrr)rmdegreepitchRefretrps rrzKey.deriveByDegreeUs9Dg$VX699&*"')$ r c\|js tdg}|j|j|jD]%}|j}|dkDs|j|'t |dkr|jdkry|jS|d}|d|dz }|dz|dzzS)NzDcannot process ambiguity without a list of .alternateInterpretationsrrgr)rrZrrr)rmfocussubKeycc absMagnitude leaderSpans r%_tonalCertaintyCorrelationCoefficientz)Key._tonalCertaintyCorrelationCoefficients,,'VX X T00133F..BAv R 4 u:>**a/222Qx 1Xa( q Z!^44r cH|dk(r|jStd|)al Provide a measure of tonal ambiguity for Key determined with one of many methods. The `correlationCoefficient` assumes that the alternateInterpretations list has been filled from the use of a KeyWeightKeyAnalysis subclass. >>> littlePiece = converter.parse("tinyNotation: 4/4 c4 d e f g a b c' e' g' e' c'") >>> k = littlePiece.analyze('key') >>> k >>> k.tonalCertainty() 1.1648... Three most likely alternateInterpretations: >>> k.alternateInterpretations[0:3] [, , ] >>> k.correlationCoefficient 0.9068... >>> k.alternateInterpretations[0].correlationCoefficient 0.7778... least likely interpretation: >>> k.alternateInterpretations[-1] Note that this method only exists if the key has come from an analysis method. Otherwise it raises a KeySignatureException >>> k2 = key.Key('b-') >>> k2.tonalCertainty() Traceback (most recent call last): music21.key.KeySignatureException: cannot process ambiguity without a list of .alternateInterpretations >>> k2.alternateInterpretations [] rzUnknown method: )rri)rmmethods rtonalCertaintyzKey.tonalCertaintys0T - -==? ?/x89 9r Frcyrr_rs rrz Key.transpose r cyrr_rs rrz Key.transposerr c|durt||||}nt|||}|j|j}|j|_|j |s|Sy)a Transpose the Key by the user-provided value. If the value is an integer, the transposition is treated in half steps. If the value is a string, any Interval string specification can be provided. Alternatively, a :class:`music21.interval.Interval` object can be supplied. >>> dMajor = key.Key('D') >>> dMajor >>> aMaj = dMajor.transpose('p5') >>> aMaj >>> aMaj.sharps 3 >>> aMaj.tonic >>> aMaj.mode 'major' `inPlace=True` works here and returns None while changing the Key itself. >>> changingKey = key.Key('g') >>> changingKey >>> changingKey.sharps -2 >>> changingKey.transpose('m-3', inPlace=True) >>> changingKey >>> changingKey.sharps 1 >>> changingKey.transpose(1, inPlace=True) >>> changingKey >>> changingKey.sharps -4 >>> changingKey.transpose(1, inPlace=True) >>> changingKey >>> changingKey.transpose(1, inPlace=True) >>> changingKey >>> changingKey.transpose(1, inPlace=True) >>> changingKey TrN)rgrrrTrr)rmrSrrpostKeyrps rrz Key.transposesll d? G eW  5D7$UG$ B  % LL,a 0 II+ ,   %=  > B  %s#s#s#t$ MMOA HHTYYq\ " II+ ,   %=  > B  % MMOs{{*S[[83;;FA HHTYYq\ "G II+ ,   %=  > B  % MMOs{{*A HHTYYq\ "+ II+ ,   %=  > B  % MMO*A HHTYYq\ "+ II+ ,   %=  > B  % %r ctd}|jdd}|j|jd|j|jd|jd}|j|jd|j|jdd}|j t |5}|jd d}ddd|j|jd |j|jd d }|jt|5}|jdd }ddd|jjjty#1swYxYw#1swY@xYw) Nr)rTrr<r4r6rr@zignoring provided tonic: Er>rz0Could not solve for mode from sharps=2, tonic=A-zA-) rerrrTrassertWarnsRegexrcassertRaisesRegexrJassertIsInstance exception __cause__r)rmksrexpectedcms r testAsKeyzTest.testAsKeyss7 !_ HH$dH + ) 1137 HH3H  * 1137/  " ":x 8BgS1A9 ) 1137E  # #L( ;rd$/A< bll44h?9 8< ;s9E,%E8,E58FN)r\r]r^rrrr3r=r_r rr r #s%& -0&n@r r __main__r)rSr rTrrrP)3r __future__rr$rtypingrrunittestrrrmusic21.common.decoratorsrmusic21.common.typesrrr r r r r r Environment environLocalrPrHr(rrrr rr1rKrRrXMusic21ExceptionrZrJWarningrc Music21ObjectrerrTestCaser  _DOC_ORDERr\mainTestr_r rrLsr# 1) &{&&u- S***8+C+CC /1+0$N<D2  !!#  $(] ],/]@ L99  <00   Q  4%%Q  hw,++wv f@8  f@VC  zGTr