3j zdZddlmZddlmZddlmZmZddlZ ddl Z ddl m Z ddl m Z ddl mZdd l mZdd l mZdd l mZdd l mZdd l mZe j(rddl mZe j,dZGdde j0ZGddZGddeZGddeZeZGddeZGddeZGddeZ GddeZ!eeee e!gZ"Gd d!eZ#Gd"d#eZ$ d)d$Z%d*d%Z&Gd&d'e jNZ(e%ee#e$eeee ee!g Z)e*d(k(rddl Z e jVe(yy)+a Modular analysis procedures for use alone or applied with :class:`music21.analysis.windowed.WindowedAnalysis` class. All procedures should inherit from :class:`music21.analysis.discrete.DiscreteAnalysis`, or provide a similar interface. The :class:`music21.analysis.discrete.KrumhanslSchmuckler` (for algorithmic key detection) and :class:`music21.analysis.discrete.Ambitus` (for pitch range analysis) provide examples. ) annotations) OrderedDict)IterableSequenceN) environment) exceptions21)harmony)interval)note)key) percussion)pitchstreamzanalysis.discretec eZdZy)DiscreteAnalysisExceptionN)__name__ __module__ __qualname__F/DATA/.local/lib/python3.12/site-packages/music21/analysis/discrete.pyrr2srrcveZdZUdZdZgZded<ddZddZddZ d Z d Z d Z d Z ddd ZdZdZdZdZy)DiscreteAnalysisa' Parent class for analytical methods. Each analytical method returns a discrete numerical (or other) results as well as a color. Colors can be used in mapping output. Analytical methods may make use of a `referenceStream` to configure the processor on initialization. z list[str] identifiersNc.||_g|_g|_yN)_referenceStreamsolutionsFoundalternativeSolutions)selfreferenceStreams r__init__zDiscreteAnalysis.__init__Ds / !%'!rc~t|dt|dt|df}d|dd|dd|ddS)z Utility conversion method >>> da = analysis.discrete.DiscreteAnalysis() >>> ffffff = (255, 255, 255) >>> da._rgbToHex(ffffff) '#ffffff' r#02x)round)r"rgbs r _rgbToHexzDiscreteAnalysis._rgbToHexQsOCFmU3q6]E#a&M93q6#,s1vcl3q6#,77rc jdttfdtddzDS)a5 Utility conversion method for six-digit hex values to RGB lists. >>> da = analysis.discrete.DiscreteAnalysis() >>> da._hexToRgb('#ffffff') [255, 255, 255] >>> da._hexToRgb('#ff8000') [255, 128, 0] >>> da._hexToRgb('#000000') [0, 0, 0] r(c3HK|]}t||dzzdyw)N)int).0ilvvalues r z-DiscreteAnalysis._hexToRgb..ks*Q;PaCaB!G ,b1;Ps"rr/)lstriplenlistrange)r"r5r4s `@r _hexToRgbzDiscreteAnalysis._hexToRgb]s: S! ZQ5Ba;PQQQrc&|dkrd}|S|dkDrd}|S)a Utility conversion method -- limits all numbers to between 0 and 255. >>> da = analysis.discrete.DiscreteAnalysis() >>> da._rgbLimit(70) 70 >>> da._rgbLimit(300) 255 >>> da._rgbLimit(-30) 0 rr)r"r5s r _rgbLimitzDiscreteAnalysis._rgbLimitms* 19E S[E rcg|_y)z, Clear all stored solutions N)r r"s rclearSolutionsFoundz$DiscreteAnalysis.clearSolutionsFounds !rc^g}|jD]\}}||vs |j||S)zu Based on solutions found so far with this processor, return the colors that have been used. r append)r"postunused_solutioncolors r getColorsUsedzDiscreteAnalysis.getColorsUseds9 &*&9&9 "OUD  E"': rc^g}|jD]\}}||vs |j||S)zx Based on solutions found so far with this processor, return the solutions that have been used. rC)r"rEsolution unused_colors rgetSolutionsUsedz!DiscreteAnalysis.getSolutionsUseds9 &*&9&9 "Hlt# H%': rcgS)a/ A list of pairs showing all discrete results and the assigned color. Data should be organized to be passed to :class:`music21.graph.GraphColorGridLegend`. If `compress` is True, the legend will only show values for solutions that have been encountered. r)r"compresss rsolutionLegendzDiscreteAnalysis.solutionLegends  rcy)[ Return a string describing the solution values. Used in Legend formation. Nrr@s rsolutionUnitStringz#DiscreteAnalysis.solutionUnitStringsrcy)z Given an analysis specific result, return the appropriate color. Must be able to handle None in the case that there is no result. Nrr"rJs rsolutionToColorz DiscreteAnalysis.solutionToColor rcy)z Given a Stream, apply the analysis to all components of this Stream. Expected return is a solution (method-specific) and a color value. Nr)r"sStreams rprocesszDiscreteAnalysis.processrVrcy)zV For a given Stream, apply the analysis and return the best solution. Nr)r" subStreams r getSolutionzDiscreteAnalysis.getSolutions rr)r+zSequence[float | int]returnstr)r5r^r]z list[int]FrNboolr]z4list[list[str | list[tuple[int | str, str | None]]]])rrr__doc__namer__annotations__r$r,r;r>rArHrLrOrRrUrYr\rrrrr6sU DK ' 8R $!       rrceZdZUdZdZdZddgZdZded<d Z ded <dfd Z d Z dd Z dddZ dZddZddZd dZd!d"dZdZdZdZddZd!dZdZdZxZS)#KeyWeightKeyAnalysisz@ Base class for all key-weight key analysis subclasses. FzKeyWeightKeyAnalysis Base Classz key.baseClasszkeyscape.baseClass)CC#C-D-DE-EFF#G-GA-AB-Bztuple[str, ...]keysValidMajor)rgrhrkD#rlrmrnrorqG#rrrsA#rtrukeysValidMinorct||||j||_nd|_i|_i|_|j yN)r#)superr$_getSharpFlatCountsharpFlatCountmajorKeyColorsminorKeyColors_fillColorDictionariesr"r# __class__s rr$zKeyWeightKeyAnalysis.__init__sP 9  &"&"9"9/"JD "&D    ##%rc$dddddddd}|j|jf|j|jffD]R\}}|D]F}t j |}|j }|j||}tt|D]}|j||d z||<||jk(r3tt|D]}|j||d z ||<t|jd kDrcd }|jd d k(r ||d|zd} n!|jd dk(r d|zd|z|d} ni} | D]}|j||| |z||<!|j|||j<IUy)z >>> p = analysis.discrete.KrumhanslSchmuckler() This automatically calls _fillColorDictionaries >>> len(p.majorKeyColors) 15 >>> p.majorKeyColors['C'] '#ff816b' z#CD4F39z#DAA520z#BCEE68z#96CDCDz#6495EDz#8968CDz#FF83FA)rgrkrmrnrqrsru2dr&-)rr&r'r(N) rrvrrzrPitchstepr;r:r8r>rcr,) r"stepLibdstvalidvalidKeyrrgbStepr3 magnitudeshiftLibs rrz+KeyWeightKeyAnalysis._fillColorDictionariess" !//1D1DE //1D1DEGJC! ;;x0}}..7s7|,A!% R!@GAJ-D///"3w<0%)^^GAJ4D%E 1x}}%) "I}}Q'3.'0Y2 >#R!q)S0')I~"y.Y#W#%%%)^^GAJ!4L%M &&*^^G%<HMM"9"Grcd}d}|jD]M}|j|jjdkr|dz }/|jjdkDsI|dz }O||fS)z Determine count of sharps and flats in a Stream >>> s = corpus.parse('bach/bwv66.6') >>> p = analysis.discrete.KrumhanslSchmuckler() >>> p._getSharpFlatCount(s.flatten()) (87, 0) rrr&)pitches accidentalalter)r"r[ flatCount sharpCountps rr~z'KeyWeightKeyAnalysis._getSharpFlatCount0sk  ""A||'<<%%)OI\\''!+!OJ # 9$$rcb|j}|dk(rgdS|dk(rgdStd|a? Returns the key weights. To provide different key weights, subclass and override this method. The defaults here are KrumhanslSchmuckler. >>> a = analysis.discrete.KrumhanslSchmuckler() >>> len(a.getWeights('major')) 12 >>> len(a.getWeights('minor')) 12 major) gffffff@gףp= @gףp= @gp= ף@gQ@g\(\@g)\(@g(\@gQ@gHzG @gRQ@g ףp= @minor) gRQ@gq= ףp@g)\( @gQ@g@g= ףp= @gRQ@g@gףp= @gQ@gQ @g\(\ @$Weights must be major or minor, not lowerrr" weightTypes r getWeightszKeyWeightKeyAnalysis.getWeightsEsC %%'  [ [ 7 "[ [+.RS]R^,_` `rcdgdz}|jsy|jD]6}|j}|jD]}||jxx|z cc<8|S)a Given a flat Stream, return a pitch class distribution. The value of each pitch class is scaled by its duration in quarter lengths. >>> a = analysis.discrete.KrumhanslSchmuckler() >>> s = stream.Stream() >>> n1 = note.Note('c') >>> n1.quarterLength = 3 >>> n2 = note.Note('f#') >>> n2.quarterLength = 2 >>> s.append(n1) >>> s.append(n2) >>> a._getPitchClassDistribution(s) [3.0, 0, 0, 0, 0, 0, 2.0, 0, 0, 0, 0, 0] >>> c1 = chord.Chord(['d', 'e', 'b-']) >>> c1.quarterLength = 1.5 >>> s.append(c1) >>> a._getPitchClassDistribution(s) [3.0, 0, 1.5, 0, 1.5, 0, 2.0, 0, 0, 0, 1.5, 0] r N)notes quarterLengthr pitchClass)r" streamObjpcDistnlengthrs r_getPitchClassDistributionz/KeyWeightKeyAnalysis._getPitchClassDistributionXsY,rA__FYYq||$.$!  rc|ydgdz}|j|}tt|D]7}tt|D]}||xx|||z dz||zz cc< 9|S)z Takes in a pitch class distribution as a list and convolutes it over Sapp's given distribution for finding key, returning the result. Nrr)rr:r8)r"pcDistributionrrJ toneWeightsr3js r_convoluteDistributionz+KeyWeightKeyAnalysis._convoluteDistributionzsy  !38ooj1 s8}%A3~./ QUbL 9N1.sJ4ILRFB<4Is)sorted enumeratereverserr)r" keyResults differences likelyKeysaunused_correlationrs r_getLikelyKeysz#KeyWeightKeyAnalysis._getLikelyKeyssj  #$#( JIj4IJ J '( " #kk"o{2?JrN'(rc&|ydgdz}dgdz}dgdz}dgdz}|j|}t|t|z } t|t|z } tt|D]} tt|D]} || || | z dz| z || | z zz|| <|| || | z dz| z dzz|| <|| || | z dzz|| <|| dk(s|| dk(rd|| <gt || || || zdzz || <|S)z{ Takes in a list of numerical probable key results and returns the difference of the top two keys. Ngrr'r?)rsumr8r:float) r"rrrrJtop bottomRight bottomLeftrprofileAveragehistogramAverager3rs r_getDifferencez#KeyWeightKeyAnalysis._getDifferences~  !$ ebjebj URZ ooj1 [)C ,<<~.^1DDs8}%A3{+,QQ" ->&q),<<$>?A"-QQ" ->14E"F A *1 "1%(88Q2?!@ 1 q>Q&*Q-1*<"%HQK"'A;q>JqM3QVY2Y(Z"[HQK-&rcgd}g}|r\|j}|j}g}|D]4}|D]-}|d ||djk(s|j|46n|}g}d} dD]} | dk(r |j} n| dk(r |j } | g} g} |D cgc]} t j| c} D]k} |j|| g}d}|r||vrd }|j| vrd }|rd }d }n!|j}| dk(r|j}| j||fm| j| |j| |Scc} w#t$rd}YwxYw) z Returns a list of lists of possible results for the creation of a legend. >>> p = analysis.discrete.KrumhanslSchmuckler() >>> post = p.solutionLegend() )rirgrhrjrkrwrlrmrnrorprqrxrrrsryrtrurNr)MajorMinorrrFT#ffffffr) rHrLrcrDrvrzrrrUKeyErrorr)r"rN _keySortOrder colorsUsed solutionsUsedkeySortOrderFilteredkeyElsoldataryLabelrowpairsrkeyPitchrGmaskkeyStrs rrOz#KeyWeightKeyAnalysis.solutionLegends  ++-J 113M$& &(C1v~ A +,33E: )'$1 !#)F ++7"++=CHC46E5IJ5IU[[^5IJ! 00(F1CDEJ.#==-D%EF&]]F(!' fe_-/K0 JJu  KK E)F 5K ! E!sE?E E"!E"cy)rQKeysrr@s rrRz'KeyWeightKeyAnalysis.solutionUnitString src|d}|y|dj}|dk(r|j|jS|j|jS)a Given a two-element tuple of (tonicPitch, modality) return the proper color >>> p = analysis.discrete.KrumhanslSchmuckler() >>> solution = (pitch.Pitch('C'), 'major') >>> p.solutionToColor(solution) '#ff816b' rrr&r)rrrcr)r"rJ solutionKeymodalitys rrUz$KeyWeightKeyAnalysis.solutionToColors^qk  A;$$& w &&{'7'78 8&&{'7'78 8rc|j|}|j|d}|j||d}|j||}|j|d}|j||d}|j||}||fS)Nrr)rrrr) r"rXrkeyResultsMajordifferenceMajorlikelyKeysMajorkeyResultsMinordifferenceMinorlikelyKeysMinors r _likelyKeysz KeyWeightKeyAnalysis._likelyKeys&s88A55ngN--o.>> ks = analysis.discrete.KrumhanslSchmuckler() >>> s = converter.parse('tinynotation: 4/4 b-4 e- f g-') >>> ks._bestKeyEnharmonic(pitch.Pitch('e#'), 'minor', s) >>> ks._bestKeyEnharmonic(pitch.Pitch('f-'), 'major', s) NFrTrinPlace)rcrvrz getEnharmonic)r"pitchObjmoderXflipEnharmonics r_bestKeyEnharmonicz'KeyWeightKeyAnalysis._bestKeyEnharmonic6sk    7?}}D$7$77!% W_}}D$7$77!%   " "4 " 0rc|jjjtj}|j |\}}||Dcgc] \}}||df }}}ng}|||Dcgc] \}}||df c}}z }|s t d|j|j|d\}}}|j|||}|||f} |j| } |rFg|_ |ddD]7\}}}|j|||}|jj|||f9|jj| | f| | fScc}}wcc}}w)a Takes in a Stream or sub-Stream and performs analysis on all contents of the Stream. The :class:`~music21.analysis.windowed.WindowedAnalysis` windowing system can be used to get many results by calling this method. Returns two values, a solution data list and a color string. The data list contains a key (as a string), a mode (as a string), and a correlation value (degree of certainty) Nrrz.failed to get likely keys for Stream componentrr&)flatten notesAndRestsgetElementsNotOfClassr UnpitchedrrsortrrrUr!rDr ) r"rXstoreAlternativesrrr coefficientsortListrrJrGs rrYzKeyWeightKeyAnalysis.processgs//#11GGW,0+;+;G+D(  &,;=,;(K%a1,; =H  & -<>-<)![&q'2-<> >H+,\] ]  ({ Q  # #AtW 5t[)$$X. (*D %(0 $ Q++AtW=))00!T;1GH)5 ""He#45A= >s E 0EcTtj|d|d}|d|_|S)zg Convert a solution into an appropriate object representation, returning a Key object. rr&)tonicrr')r KeycorrelationCoefficient)r"rJks r_solutionToObjectz&KeyWeightKeyAnalysis._solutionToObjects- GG(1+HQK 8#+A; rc |j|jd\}}|j|}|jg|_|jD],}|jj |j|.|S)a Return a music21 Key object defining the results of the analysis. Do not call process before calling this method, as this method calls process. Note that all alternative solutions are returned as Key objects and stored on a list found at Key.alternateInterpretations. >>> s = corpus.parse('bach/bwv66.6') >>> p = analysis.discrete.KrumhanslSchmuckler() >>> p.getSolution(s) # this seems correct >>> s = corpus.parse('bach/bwv57.8') >>> p = analysis.discrete.KrumhanslSchmuckler(s) >>> p.getSolution(s) T)r)rYrralternateInterpretationsr!rD)r"rXrJrKrrs rr\z KeyWeightKeyAnalysis.getSolutions}&"&goo.?SW!X,  " "8 , % % -)+A &,,C & & - -d.D.DS.I J-rr)r]ztuple[int, int]r)r]z list[float])r]zlist[t.Any] | None)r]zNone | list[float]r_r`)rrrrb_DOC_ALL_INHERITEDrcrrvrdrzr$rr~rrrrrrOrRrUrrrYrr\ __classcell__rs@rrfrfs -D"$89K 'NO'NO &8=t%*a&D $!FL\ 9(0 /bDLrrfc<eZdZdZdZdZgdZdfd ZddZxZ S) KrumhanslSchmucklera Implementation of Krumhansl-Schmuckler/Kessler weightings for Krumhansl-Schmuckler key determination algorithm. Values from https://extras.humdrum.org/man/keycor/, which describes these weightings as "Strong tendency to identify the dominant key as the tonic." * Changed in v6.3: it used to be that these were different from the Kessler profiles, but that was likely a typo. Thus, KrumhanslKessler and KrumhanslSchmuckler are synonyms of each other. Fz)Krumhansl Schmuckler/Kessler Key Analysis)z key.krumhanslzkey.schmucklerzkey.krumhansl-schmucklerzkey.krumhanslschmuckler krumhansl schmucklerzkrumhansl-schmucklerkrumhanslschmucklerz key.kesslerzkey.krumhansl-kesslerzkey.krumhanslkesslerkesslerzkrumhansl-kesslerkrumhanslkesslerc&t||yr|r}r$rs rr$zKrumhanslSchmuckler.__init__ 9rcb|j}|dk(rgdS|dk(rgdStd|rrrs rrzKrumhanslSchmuckler.getWeightssG %%'  & & 7 "[ [+.RS]R^,_` `rrr rrrrbrrcrr$rrrs@rrrs'  6DK:arrc<eZdZdZdZdZgdZdfd ZddZxZ S) AardenEssena Implementation of Aarden-Essen weightings for Krumhansl-Schmuckler key determination algorithm. Values from https://extras.humdrum.org/man/keycor/, which describes these weightings as "Weak tendency to identify the subdominant key as the tonic." (N.B. -- we are not sure exactly where the minor weightings come from, and recommend only using these weights for major). FzAarden Essen Key Analysis) z key.aardenz key.essenzkey.aarden-essenzkey.aardenessenaardenessenz aarden-essen aardenessenr keyscapec&t||yr|rrs rr$zAardenEssen.__init__rrcb|j}|dk(rgdS|dk(rgdStd|)z Returns the key weights. >>> a = analysis.discrete.AardenEssen() >>> len(a.getWeights('major')) 12 >>> len(a.getWeights('minor')) 12 r) g2w-!1@IΣ?g|?5^-@gv?g( 3@g&†&@gIΣ?gZd;6@rg:KTO @gF?gY4 @r) gC2@g,=)?g $(~,@g h"0@[tz?g=U,@rgǺ2@g2C@g~5?g7T7@g䠄?rrrs rrzAardenEssen.getWeightssQ %%'  0 07 "K K,.RS]R^,_` `rrrrrs@rrrs' &DK:arrc<eZdZdZdZdZgdZdfd ZddZxZ S) SimpleWeightsa@ Implementation of simple weights by Craig Sapp for Krumhansl-Schmuckler key determination algorithm. Values from https://extras.humdrum.org/man/keycor/, which describes these weightings as "Performs most consistently with large regions of music, becomes noisier with smaller regions of music." FzSimple Weight Key Analysis)z key.simplez key.weightzkey.simple-weightzkey.simpleweightsimpleweightz simple-weight simpleweightc&t||yr|rrs rr$zSimpleWeights.__init__Brrcb|j}|dk(rgdS|dk(rgdStd|)z Returns the key weights. >>> a = analysis.discrete.SimpleWeights() >>> len(a.getWeights('major')) 12 >>> len(a.getWeights('minor')) 12 r) r'rr&rr&r&rr'rr&rr&r) r'rr&r&rr&rr'r&rrrrrrs rrzSimpleWeights.getWeightsEsC %%'  7 7 7 "; ;+.RS]R^,_` `rrrrrs@rrr3s' 'DK:arrc<eZdZdZdZdZgdZdfd ZddZxZ S) BellmanBudgea  Implementation of Bellman-Budge weightings for Krumhansl-Schmuckler key determination algorithm. Values from https://extras.humdrum.org/man/keycor/, which describes these weightings as "No particular tendencies for confusions with neighboring keys." FzBellman Budge Key Analysis)z key.bellmanz key.budgezkey.bellman-budgezkey.bellmanbudgebellmanbudgez bellman-budge bellmanbudgec&t||yr|rrs rr$zBellmanBudge.__init__frrcb|j}|dk(rgdS|dk(rgdStd|)a Returns the key weights. >>> a = analysis.discrete.BellmanBudge() >>> len(a.getWeights('major')) 12 >>> len(a.getWeights('minor')) 12 >>> a.getWeights('major') [16.8..., 0.8..., 12.9..., 1.4..., ...] r) g0@gQ?gfffff)@g(\?g{G*@g\('@g?gHzG4@g?gGz @gףp= ?gp= #%@r) g)\(2@gGz?g{G)@gGz*@gQ?gL&@gGz?gR5@g(\@g{Gz?gq= ףp?gQk$@rrrs rrzBellmanBudge.getWeightsisC %%'  a a 7 "a a+.RS]R^,_` `rrrrrs@rr%r%Ys'  'DK:arr%c<eZdZdZdZdZgdZdfd ZddZxZ S) TemperleyKostkaPayneaG Implementation of Temperley-Kostka-Payne weightings for Krumhansl-Schmuckler key determination algorithm. Values from https://extras.humdrum.org/man/keycor/, which describes these weightings as "Strong tendency to identify the relative major as the tonic in minor keys. Well-balanced for major keys." Fz#Temperley Kostka Payne Key Analysis) z key.temperleyz key.kostkaz key.paynezkey.temperley-kostka-paynezkey.temperleykostkapayne temperleykostkapayneztemperley-kostka-paynetemperleykostkapaynec&t||yr|rrs rr$zTemperleyKostkaPayne.__init__rrcb|j}|dk(rgdS|dk(rgdStd|)z Returns the key weights. >>> a = analysis.discrete.TemperleyKostkaPayne() >>> len(a.getWeights('major')) 12 >>> len(a.getWeights('minor')) 12 r) gV-?gQ?gZd;?gˡE?gq= ףp?q= ףp?g~jt?gzG?g9v?gCl?gv/?g?r) gbX9?g/$?gtV?g-?gJ +?r3gzG?gCl?gB`"?gx&?g/$?gQ?rrrs rrzTemperleyKostkaPayne.getWeightssM %%'  > > 7 "> >,.RS]R^,_` `rrrrrs@rr,r,s' 0DK :arr,cjeZdZdZdZdZddgZddfd ZddZddZ ddd Z d Z dd Z d Z d ZxZS)Ambitusz A basic analysis method for measuring register. >>> ambitusAnalysis = analysis.discrete.Ambitus() >>> ambitusAnalysis.identifiers[0] 'ambitus' FzAmbitus Analysisambitusspanct||d|_d|_t |_|j yr|)r}r$ minPitchObj maxPitchObjr_pitchSpanColors_generateColorsrs rr$zAmbitus.__init__s; 9.2-17B} rcd}|s|jd|j|j}|y|\|_|_t |jj |jj z }nd}n|}||z }|dk(rd}d}d}t ||dzD]E}td|z |z |z|z} |j| dz| dz| f|j|<|dz }Gy) a~ Provide uniformly distributed colors across the entire range. >>> ambitusAnalysis = analysis.discrete.Ambitus() >>> ambitusAnalysis._generateColors() >>> for i, j in ambitusAnalysis._pitchSpanColors.items(): ... if i > 3: break ... print(i, j) 0 #130f19 1 #14101b 2 #16111d 3 #16121e rNr&go@g?g333333?) r getPitchSpanr9r:r1psr:r*r,r;) r" numColorsminPitchpitchSpanReturnmaxPitch valueRanger antiBlackr3vals rr<zAmbitus._generateColorss  $$0"&"3"3D4I4I"J"*5D2 $"2t//22T5E5E5H5HHI H( ?J xA.A%)+z9TABYNC'+~~d cCiRU6V'WD ! !! $ AID /rcz||jur0|jr$|jr|j|jfS|jj}|syg}g}|D]r}d}t |t jr&t |tjs |j}||Dcgc]}|jc}z }|j|t|sy|jt|}|jt|} ||} || } ||jur| |_| |_| | fScc}w)a For a given subStream, return a tuple consisting of the two pitches with the minimum and maximum pitch space value. This public method may be used by other classes. It ignores ChordSymbol objects. Demonstration: >>> s = corpus.parse('bach/bwv66.6') >>> p = analysis.discrete.Ambitus() >>> pitchMin, pitchMax = p.getPitchSpan(s.parts[0].getElementsByClass(stream.Measure)[3]) >>> pitchMin.ps, pitchMax.ps (66.0, 71.0) >>> p.getPitchSpan(s.parts[0].getElementsByClass(stream.Measure)[6]) (, ) >>> s = stream.Stream() >>> c = chord.Chord(['a2', 'b4', 'c8']) >>> s.append(c) >>> p.getPitchSpan(s) (, ) Returns None if the stream contains no pitches. >>> s = stream.Stream(note.Rest()) >>> p.getPitchSpan(s) is None True OMIT_FROM_DOCS And with only ChordSymbols: >>> s.insert(4, harmony.ChordSymbol('C6')) >>> p.getPitchSpan(s) is None True Nr)rr9r:recurser isinstancer GeneralNoter ChordSymbolrrAextendindexminmax) r"r[ justNotespsFound pitchesFoundrrr minPitchIndex maxPitchIndexr9r:s rr@zAmbitus.getPitchSpans0L -- -$2B2BtGWGW##T%5%55 5%%'--  "*, A-/G!T--.z!WEXEX7Y)) g.gg. .G    (  c'l3  c'l3 "=1 "=1 -- -*D *D K''!/s,D8cg}|r|j}g}i}tt|jj D](}|r|j||vr|j|||<*t |j }|j |dt|dz}|t|dzd}||fD]H} dg} g} | D]}||} | j|| f| j| |j| J|S)a| Return legend data. >>> s = corpus.parse('bach/bwv66.6') >>> soprano = s.parts[0] >>> p = analysis.discrete.Ambitus(soprano) # provide ref stream >>> p.solutionLegend() [['', [(0, '#130f19'), (1, '#211a2c'), (2, '#2f263f'), (3, '#3e3253'), (4, '#4c3d66'), (5, '#5b4979')]], ['', [(6, '#69548c'), (7, '#775f9f'), (8, '#866bb2'), (9, '#9476c5'), (10, '#a382d9'), (11, '#b18eec'), (12, '#bf99ff')]]] >>> len(p.solutionLegend()) 2 >>> [len(x) for x in p.solutionLegend()] [2, 2] >>> [len(y) for y in [x for x in p.solutionLegend()]] [2, 2] >>> s = corpus.parse('bach/bwv66.6') >>> p = analysis.discrete.Ambitus() >>> p.solutionLegend(compress=True) # empty if nothing processed [['', []], ['', []]] >>> x = p.process(s.parts[0]) >>> [len(y) for y in [x for x in p.solutionLegend(compress=True)]] [2, 2] >>> x = p.process(s.parts[1]) >>> [len(y) for y in [x for x in p.solutionLegend(compress=True)]] [2, 2] Nr'r)rHr:r8r;keysr9rrD) r"rNrrcolorsr3rX keysTopRow keysBottomRowkeyGrouprrrGs rrOzAmbitus.solutionLegend<sN ++-J!#s40055789A((+:=--a0F1I :FKKM" +CIN, c$i1n./ $]3H=?DC46Eq  aZ( JJu  KK 4 rcy)rQz Half-Stepsrr@s rrRzAmbitus.solutionUnitStringsrcF||jdS|j|S)a' >>> p = analysis.discrete.Ambitus() >>> s = stream.Stream() >>> c = chord.Chord(['a2', 'b4', 'c8']) >>> s.append(c) >>> minPitch, maxPitch = p.getPitchSpan(s) >>> p.solutionToColor(maxPitch.ps - minPitch.ps).startswith('#') True )r=r=r=)r,r;rTs rrUzAmbitus.solutionToColors*  >>/2 2$$X..rc |j|}|Ltj|d|d}|j|dj|djz }nd}d}|j j ||f||fS)a; Given a Stream, return a solution (as an interval) and a color string. >>> p = analysis.discrete.Ambitus() >>> s = stream.Stream() >>> c = chord.Chord(['a2', 'b4', 'c8']) >>> s.append(c) >>> p.process(s) (, '#665288') Nrr&) noteStartnoteEndr)r@r IntervalrUrAr rD)r"rXrErJrGs rrYzAmbitus.processs  )  ((47DGLH((ad1gjj)@AEHE ""He#45rc.|j|\}}|S)z Procedure to only return an Interval object. >>> s = corpus.parse('bach/bwv66.6') >>> p = analysis.discrete.Ambitus() >>> p.getSolution(s) )rYr"rXrJrKs rr\zAmbitus.getSolutions"&g!6,rr)r#zstream.Stream | None)r]z&tuple[pitch.Pitch, pitch.Pitch] | Noner_r`)rJz int | Noner]r^)rrrrbrrcrr$r<r@rOrRrUrYr\rrs@rr5r5sL Df%K'VF(PEN /". rr5cPeZdZdZdZdZddgZd fd ZdZd dZ d d Z d Z xZ S)MelodicIntervalDiversityzV An analysis method to determine the diversity of intervals used in a Stream. FzInterval Diversityzinterval.diversity intervalsc&t||yr|rrs rr$z!MelodicIntervalDiversity.__init__rrcy)NrrrTs rrUz(MelodicIntervalDiversity.solutionToColorsrcddlm}|i}|jr%t|j |j }n|g}|D]}|j jdj tjj}t|D]\} } | t|dz kr || dz} nd} | %tj| | } |r| jjdk(rW|r)| jjdkr| j!} | j"|vr| dg|| j"<|| j"dxxdz cc<|S)z Find all unique melodic intervals in this Stream. If `found` is provided as a dictionary, this dictionary will be used to store Intervals, and counts of Intervals already found will be incremented. rrNFrr'r&)music21rhasPartLikeStreamsr9getElementsByClassStreamr stripTiesr Noterr8r rb chromatic semitonesr directedName) r"rXfoundignoreDirection ignoreUnisonrprocListr noteStreamr3rnNexts rcountMelodicIntervalsz.MelodicIntervalDiversity.countMelodicIntervalssF # =E  % % 'G66v}}EFHyHA..u.=PPQUQZQZ[bbdJ!*-1J!++&q1u-E E$ ))!U3A#;;00A5$&;;0014 ! A~~U212Aann-ann-a0A50). > rcp|j||}t||jt|fS)zH Find how many unique intervals are used in this Stream )rzr8rU)r"rXruuniqueIntervalss rrYz MelodicIntervalDiversity.processs644WoN?#T%9%9#o:N%OOOrcJ|j|j\}}|S)z= Solution is the number of unique intervals. )rYrrds rr\z$MelodicIntervalDiversity.getSolution s#"&goo.?!@,rr)NTT)T) rrrrbrrcrr$rUrzrYr\rrs@rrfrfs: D'5K:4lPrrfc v|dk(rd}t|}||}|j|Std|)a Public interface to discrete analysis methods to be applied to a Stream given as an argument. Methods return process-specific data format. See subclasses for details. Analysis methods can be specified as arguments or by use of a `method` keyword argument. If `method` is the class name, that class is returned. Otherwise, the :attr:`~music21.analysis.discrete.DiscreteAnalysis.identifiers` list of all :class:`~music21.analysis.discrete.DiscreteAnalysis` subclass objects will be searched for matches. The first match that is found is returned. :class:`~music21.analysis.discrete.Ambitus` :class:`~music21.analysis.discrete.KrumhanslSchmuckler` >>> s = corpus.parse('bach/bwv66.6') >>> analysis.discrete.analyzeStream(s, 'Krumhansl') >>> analysis.discrete.analyzeStream(s, 'ambitus') >>> analysis.discrete.analyzeStream(s, 'key') >>> analysis.discrete.analyzeStream(s, 'span') Note that the same results can be obtained by calling "analyze" directly on the stream object: >>> s.analyze('key') >>> s.analyze('span') r:r7zno such analysis method: )analysisClassFromMethodNamer\r)rmethodkeywordsanalysisClassNameobjs r analyzeStreamrsRH5PQW5X$!y)) $&?x$H IIrctttttt g}d}|D]L}|j |jj vs|j |jvsJ|}n|!|D]}|jD] }||k(s |}|%|D] }|jD] }||vs|}n||S|S)aF Returns an analysis class given a method name, or None if none can be found Searches first the class name, then the .identifiers array for each class, then a subset of any identifier. >>> acfmn = analysis.discrete.analysisClassFromMethodName >>> acfmn('aarden') >>> acfmn('span') This one is fundamentally important: >>> acfmn('key') >>> print(repr(acfmn('unknown-format'))) None N) r5rrrr%r,rrrcr)ranalysisClassesmatch analysisClassidStrs rrrMs,  5O*.E( LLNm44::< <<<>]%7%77!E  ) },M&22U?)E 3- },M&22U?)E 3   L- Lrc6eZdZdZdZdZdZdZdZdZ y) Testc2ddlm}||ty)Nr) testCopyAll)music21.test.commonTestrglobals)r"rs rtestCopyAndDeepcopyzTest.testCopyAndDeepcopys7D')$rc.ddlm}t}|jd}|jd}|jd}|j |j |j |j \}}|j|j||z}|j |j |j |j \} } | j| j| | z} |j |j \} } | j| jg}tt|D]+}||\}}| |\}}|j|||zdz f-y)Nr converterz1tinynotation: 4/4 c4 d e f g a b c c#4 d# e# f#z0tinynotation: 4/4 c#4 d# e# f# f g a b- c d e fzQtinynotation: 4/4 c4 d e f g a b c c#4 d# e# f# c#4 d# e# f# f g a b- c d e fg@) rkrrparserYrrrr:r8rD)r"rrs1s2s3likelyKeysMajor1likelyKeysMinor1 allResults1likelyKeysMajor2likelyKeysMinor2 allResults2likelyKeysMajor3likelyKeysMinor3avgr3count1count2s rtestKeyAnalysisKrumhanslzTest.testKeyAnalysisKrumhanslsh%  ! __P Q __O P __@A "**,-.]]2::<-H**&)99  "**,-.]]2::<-H**&)99 ./]]2::<-H**s;'(A#AIAv#AIAv JJFVOs23 4)rc ddlm}ddlm}|j}|j t j d|j t j d|j t j dt}|j|}|jt|dd|jt|d d |jt|d |j}|j t j d |j t j d |j t j d |j t j d t}|j|}|jt|d|jt|dd|j|d}|jt|d |jt|dd|jt|ddt}|jd}|j|jd}|jt|d|jt|dd|jt|dd|jt|dd|jt|dd|j|}|jt|d|jttt|d |jt|d!d"|jt|dd#|jt|dd$|jt|d%d&|jt|dd'|jt|dd(|jt|d d)y)*Nrr)corpuszg#3a3g4m7z#[, 1]m2z#[, 1]r'c3d3r&M2z#[, 3]F)ruzM-2z$[, 1]z#[, 2]zcorelli/opus3no1/1grave P5z#[, 8]P4z#[, 7]m3z#[, 1]z$[, 21] z=['M2', 'M3', 'M6', 'P15', 'P4', 'P5', 'P8', 'd5', 'm2', 'm3']P15z$[, 1]z$[, 16]z$[, 29]M3z$[, 16]z$[, 12]z$[, 79]z$[, 43])rkrrrnrDr rprfrz assertEqualr^r8rpartsrr9)r"rrsmidmidDicts rtestIntervalDiversityzTest.testIntervalDiversitys["" FMMO 5!" 4! 4!&(++A. WT]+-RS WT]+-RS Wq) FMMO 4! 4! 4! 4!&(++A. Wq) WT]+-RS++Au+E Wq) WU^,.TU WT]+-RS&( LL2 3++AGGAJ7 Wq) WT]+-RS WT]+-RS WT]+-RS WT]+-ST++A. Wr* VDM23X Z WU^,.TU WT]+-ST WT]+-ST WT]+-ST WT]+-ST WT]+-ST WT]+-STrcddlm}dD]k}|j}|jt j ||j t|jdj|my)Nrr)rsrtrr Krumhansl) rkrrnrDr rprr^analyzer)r"rrrs rtestKeyAnalysisSpellingzTest.testKeyAnalysisSpellingsT""A A HHTYYq\ "   S;!7!=!=> B#rcXddlm}ddlm}|j |j }t }|j|}|j|j|jg}|jt|dd|jt|dd|jt|dddd t}|j|}|j|j|jg}|jt|dd|jt|dd t}|j|}|j|j|jg}|jt|dd|jt|dd t}|j|}|j|j|jg}|jt|dd|jt|dd t!}|j|}|j|j|jg}|jt|dd|jt|dd y) Nrr) testFilesror&rr'z0.81063r)rkrmusic21.musicxmlrr edgefield82brr\rrrrr^rrr%r,)r"rrrrrrEs rtestKeyAnalysisDiverseWeightsz"Test.testKeyAnalysisDiverseWeightss%. OOI22 3  ! MM! !9!9: T!Wt, T!Ww/ T!Wa*I6 M MM! !9!9: T!Wt, T!Ww/ O MM! !9!9: T!Wt, T!Ww/ N MM! !9!9: T!Wt, T!Ww/ " MM! !9!9: T!Wt, T!Ww/rcddlm}|j}|jt j dd|jt j dd|jt j dd|j d }|jt|d |jd jd |jDd |j d}|jt|d|jd jd|jDd|j}|jt j dd|jt j dd|j d}|jt|jdy)Nrrcgrr'rzC major c34K|]}|jywrtonicPitchNameWithCaser2kps rr6z1Test.testKeyAnalysisLikelyKeys..&!aF`"";";F`z7c G a F g e f E- A- B- d D A b b- c# f# C# E g# F# e- BrzF majorc34K|]}|jywrrrs rr6z1Test.testKeyAnalysisLikelyKeys..+rrz7C c g f a G d A- B- E- e b- D A f# C# b E c# e- F# B g#zc#r ) rkrrn repeatAppendr rprrr^joinrr8)r"rrrrs rtestKeyAnalysisLikelyKeyszTest.testKeyAnalysisLikelyKeyssQ" FMMO tyy~q) tyy~q) tyy~q) II+ , Q+ !aaF`F`!aaR T IIm $ Q+ !aaF`F`!aaR TV]]_  #*  $+ JJu  Q778"=rc ddlm}|j}|jt j |jt jt j t jdt jdg|jd}|j|jdy)NrrzE-4zB-4r zE- major) rkrrnrDr rr PercussionChordrprrrc)r"rrrs rtestKeyAnalysisIgnoresUnpitchedz$Test.testKeyAnalysisIgnoresUnpitched9s" FMMO !" ++ NN  IIe  IIe -   IIe  ,rN) rrrrrrrrrrrrrrrs*%&5R4UlC#0J>8 -rr__main__)rz stream.Streamrr^)rr^r]ztype[DiscreteAnalysis] | None),rb __future__r collectionsrcollections.abcrrtypingtunittestrkrrr r r r r r TYPE_CHECKINGr Environment environLocalMusic21ExceptionrrrfrKrumhanslKesslerrrr%r,keyWeightKeyAnalysisClassesr5rfrrTestCaser _DOC_ORDERrmainTestrrrrs ##. ??&{&&':;  = = J J fH+HZ+a.+a\')a&)aX#a(#aL$a'$aN&a/&aT 3*M+-A!JJ\S/Sr1J1J 1Jj:~x-8  x-x-w8P"M; !#79  zGTr