rh[%SrSSKJr SSKJr SSKrSSKrSSKrSSKr SSKJ r SSK r SSK J r SSK Jr SSKJr SS KJr SS K Jr SS K Jr SS K Jr SS K Jr SSK Jr SSK Jr \ R2(aSSK Jr \ R6"SSS9r\R:"S5r\ R>Sr SSSSSSSS.r!S\"S'Sr#S S!S"S#S$S%S&S.r$S'\"S('1S)kr%S*\"S+'SS,SS-SSS.S.r&S\"S/'S0r'S.r(S1r)S2r*S3S4S5S6S7S8S9S:S;SS?S@. r+\+RY5VVs0sHupX_M snnr-\"S7\."SA5\."SA5-4S6SB\."SA5-4S5\."SA54S=SB\."SC5-4SDS<\."SC54S;\."SE5\."SE5-4SFS9\."SE54S?SG\."SC5-4SHS>\."SC54SI/ 5r/0SJSK_SLSM_SNSO_SPSQ_SRSS_STSU_SVSU_SWSX_SYSZ_S[S\_S]S^_S_S^_S`S^_SaSb_ScSb_SdSb_SeSb_SfSfSfSgSgSgSgSh.Er0Sir1\1"5r2SSjjr3SSkjr4SSljr5SSmjr6SSnjr7SSojr8SSpjr9SSqjr:SSSrjjr;\;4SSsjjr<\;4SStjjr=\;S4Sujr>"SvSw\R~5r@"SxSy\R~5rA"SzS{\R~5rB"S|S}\R\5rD"S~S\R\R5rF"SS\R5rG"SS\ R5rI\G\F\D/rJ\KS:XaSSK r \ R"\I5 ggs snnf)a+ Classes for representing and manipulating pitches, pitch-space, and accidentals. Each :class:`~music21.note.Note` object has a `Pitch` object embedded in it. Some methods below, such as `Pitch.name`, `Pitch.step`, etc. are made available directly in the `Note` object, so they will seem familiar. ) annotations) OrderedDictN)overload)base)common)SlottedObjectMixin)StepName)defaults) environment) exceptions21)interval)prebase)stylenote PitchTypePitch)boundpitch)aAtTbBeE CDrFGrrzdict[StepName, int]STEPREF)rrrr r!r"r#r%r&rr'r(rrzdict[int, StepName]STEPREF_REVERSED>rrr%r&rr'r(z set[StepName] STEPNAMESSTEP_TO_DNN_OFFSETgcyْ?()#z##z###z####-z-----z----~z#~`z-`) naturalsharp double-sharp triple-sharpquadruple-sharpflat double-flat triple-flatquadruple-flat half-sharpone-and-a-half-sharp half-flatone-and-a-half-flati*♯i2)r3rEi+)r5♭rF)r4rF)r2u♮nr8isr9isisr:isisisr;isisisisr<esr=resesr>esesesr?esesesesr@ quarter-sharprAih semisharpthree-quarter-sharprBthree-quarters-sharpisih sesquisharprCrD) quarter-flatehsemiflatthree-quarter-flatthree-quarters-flateseh sesquiflatcSHDn/n[R5H%n[U5U:XdMURU5 M' Us $ g)N)rr-rr,)accidentalNameToModifiervalueslenappend)iamssyms G/home/james-whalen/.local/lib/python3.13/site-packages/music21/pitch.py_sortModifiersrgsA +224C3x1} 35 cbU[;agU[R5;agU[;agg)a Check if name is a valid accidental name string that can be used to initialize an Accidental. Standard accidental names are valid: >>> pitch.isValidAccidentalName('double-flat') True Accidental modifiers are valid: >>> pitch.isValidAccidentalName('--') True Alternate accidental names are valid: >>> pitch.isValidAccidentalName('eses') True Anything else is not valid: >>> pitch.isValidAccidentalName('two flats') False TF)r_r`alternateNameToAccidentalNamenames rfisValidAccidentalNamerms84 '' '..00 ,, rhcU[;aU$U[;a [U$U[;a [U$[SUS35e)a Convert a valid accidental name to the standard accidental name. Raises AccidentalException if name is not a valid accidental name. >>> pitch.standardizeAccidentalName('double-flat') 'double-flat' >>> pitch.standardizeAccidentalName('--') 'double-flat' >>> pitch.standardizeAccidentalName('eses') 'double-flat' >>> pitch.standardizeAccidentalName('two flats') Traceback (most recent call last): music21.pitch.AccidentalException: 'two flats' is not a supported accidental type 'z$' is not a supported accidental type)r_modifierToAccidentalNamerjAccidentalExceptionrks rfstandardizeAccidentalNamerrsO$ ''  '''-- ,,,T22 $'KL MMrhcn[U[[45(aU$US;agUS;ag[U5$)aJ Given a pitch class string return the pitch class representation. Ints and floats are returned unchanged; >>> pitch._convertPitchClassToNumber(3) 3 >>> pitch._convertPitchClassToNumber('a') 10 >>> pitch._convertPitchClassToNumber('B') 11 >>> pitch._convertPitchClassToNumber('3') 3 >>> pitch._convertPitchClassToNumber(3.5) 3.5 )rrrr )rrrrr#) isinstanceintfloatpss rf_convertPitchClassToNumberrzs;&"sEl## % % % %2wrhcUS-nUS$)z Given a pitch class number, return a string. >>> pitch.convertPitchClassToStr(3) '3' >>> pitch.convertPitchClassToStr(10) 'A' X)pcs rfconvertPitchClassToStrrs bBVrhcl[U[5n[[R"US- 55S- $)aU Utility conversion; does not process internals. Converts a midiNote number to an octave number. Assume C4 middle C, so 60 returns 4 >>> [pitch._convertPsToOct(59), pitch._convertPsToOct(60), pitch._convertPsToOct(61)] [3, 4, 4] >>> [pitch._convertPsToOct(12), pitch._convertPsToOct(0), pitch._convertPsToOct(-12)] [0, -1, -2] >>> pitch._convertPsToOct(135) 10 Note that while this is basically a floor operation, we only treat 6 digits as significant (PITCH_SPACE_SIGNIFICANT_DIGITS) >>> pitch._convertPsToOct(71.999) 4 >>> pitch._convertPsToOct(71.99999999) 5 >>> pitch._convertPsToOct(72) 5 r|r,)roundPITCH_SPACE_SIG_DIGITSrvmathfloorrxs rf_convertPsToOctrs.0 r) *B tzz"r'" #a ''rhc[U[5(a US-nSnSnOU[U5:Xa[U5S-nSnSnO[U[5nUS-n[ US5upS[U5n[US5S:XaSnX2- nO;SUs=:aS:a O OSnX2- nO$SUs=::aS:a O OSnX2- nO US:aSnOSnSnSnUS:Xa"US ;a[ S5nUS-S-nUS :XaSnOU[ ;a[ SU-5nUnOUS- S ;aUS:a[ US- 5nUS-nOkUS- S ;a[ SU-5nUS- nONUS-S ;aUS ::a[ SU-5nUS- nO+US-S ;a[ S U-5nUS-nO[SU35e[Un US:wa[US-5n O [S5n XX4$)a_ Utility conversion; does not process internal representations. Takes in a pitch space floating-point value or a MIDI note number (Assume C4 middle C, so 60 returns 4). Returns a tuple of Step, an Accidental object, a Microtone object or None, and an int representing octave shift (which is nearly always zero, but can be 1 for a B with very high microtones). >>> pitch._convertPsToStep(60) ('C', , , 0) >>> pitch._convertPsToStep(66) ('F', , , 0) >>> pitch._convertPsToStep(67) ('G', , , 0) >>> pitch._convertPsToStep(68) ('G', , , 0) >>> pitch._convertPsToStep(-2) ('B', , , 0) >>> pitch._convertPsToStep(60.5) ('C', , , 0) >>> pitch._convertPsToStep(62) ('D', , , 0) >>> pitch._convertPsToStep(62.5) ('D', , , 0) >>> pitch._convertPsToStep(135) ('E', , , 0) >>> pitch._convertPsToStep(70) ('B', , , 0) >>> pitch._convertPsToStep(70.2) ('B', , , 0) >>> pitch._convertPsToStep(70.5) ('B', , , 0) Here is a case where perhaps D half-flat would be better: >>> pitch._convertPsToStep(61.5) ('C', , , 0) Note that Microtones can have negative and positive zeros. >>> pitch._convertPsToStep(43.00001) ('G', , , 0) >>> pitch._convertPsToStep(42.999739) ('G', , , 0) A case where octave shift is not zero. Here the ps of 59.8 would normally imply octave 3, but because it is being represented by a C, it must appear in the octave above what is implied by the ps. >>> pitch._convertPsToStep(59.8) ('C', , , 1) A number very close to 60, however, is rounded, and gets no octave shift. >>> pitch._convertPsToStep(59.9999999) ('C', , , 0) r|r,?g?g??r)rr#r#)rr r!)r#rzcannot match condition for pc: d) rurvrrdivmod Accidental NATURAL_PCSPitchExceptionr* Microtone) ryraltermicropcRealpc_floatoctShiftaccpcNamerlmicroObjs rf_convertPsToStepr:sF"c "W s2w Wr\2- .b + ] ?c !EME E D EME U Q EME QYEEE H zbGmmq&B 8H { U# q&Y 5A:#a q&Y U#a q&W "U#a q&W e$a>rdCDD F #D zUS[)Q< h ((rhc[U5nSnUS:a[US5up1X#- nOUS:aUS:aUS- nUS-nUS:aMUS:aSnUS-nOaSUs=::aS :a O OS nUS -nOIS Us=::aS ::aO OSnUnO4S Us=:aS ::a O OSnUS- nOUS :aSnUS- nO[SU35eXB-[U54$)aq Given any floating point value, split into accidental and microtone components. >>> pitch._convertCentsToAlterAndCents(125) (1.0, 25.0) >>> pitch._convertCentsToAlterAndCents(-75) (-0.5, -25.0) >>> pitch._convertCentsToAlterAndCents(-125) (-1.0, -25.0) >>> pitch._convertCentsToAlterAndCents(-200) (-2.0, 0.0) >>> pitch._convertCentsToAlterAndCents(235) (2.5, -15.0) rrijriY@igI@Kr2zvalue exceeded range: )rwr ValueError)shiftvaluealterAdd increment alterShiftcentss rf_convertCentsToAlterAndCentsrs %LEH s{!%-  ck SLE OHck s{            e r      1%9::  %, ..rhcnUS:aS[U5- n[S[R"U5-5$)ap Given a harmonic number, return the total number shift in cents assuming 12 tone equal temperament. >>> pitch._convertHarmonicToCents(8) 3600 >>> [pitch._convertHarmonicToCents(x) for x in [5, 6, 7, 8]] [2786, 3102, 3369, 3600] >>> [pitch._convertHarmonicToCents(x) for x in [16, 17, 18, 19]] [4800, 4905, 5004, 5098] >>> [pitch._convertHarmonicToCents(x) for x in range(1, 33)] [0, 1200, 1902, 2400, 2786, 3102, 3369, 3600, 3804, 3986, 4151, 4302, 4441, 4569, 4688, 4800, 4905, 5004, 5098, 5186, 5271, 5351, 5428, 5502, 5573, 5641, 5706, 5769, 5830, 5888, 5945, 6000] Works with subHarmonics as well by specifying them as either 1/x or negative numbers. note that -2 is the first subharmonic, since -1 == 1: >>> [pitch._convertHarmonicToCents(1 / x) for x in [1, 2, 3, 4]] [0, -1200, -1902, -2400] >>> [pitch._convertHarmonicToCents(x) for x in [-1, -2, -3, -4]] [0, -1200, -1902, -2400] So the fifth subharmonic of the 7th harmonic, which is C2->C3->G3->C4->E4->G4->B\`4 --> B\`3->E\`3->B\`2->G-\`2 >>> pitch._convertHarmonicToCents(7 / 5) 583 >>> pitch._convertHarmonicToCents(7.0) - pitch._convertHarmonicToCents(5.0) 583 rr,i)absrrlog2)rs rf_convertHarmonicToCentsrs3D qySZ   %(( ))rhcSnSnSn/nU(dgU(aCUVs/sHn[UR5PM n n[SU 55[U5- nU(dU(ae/n[R "US5HGup[ R"U 5n SU l[R"XS9n URU 5 MI U(aTUH@n [R"U 5n [R "U R"5S-nX^- nMB U[U5-nU(anUHZn U R$R&nU R(R*S-nUS:Xa US ;aUS -nMEUS :XdMMUS ;dMUUS -nM\ U[U5-nXE-U-[-UU-U-5- $s snf![Ra [Rs$f=f) aj Calculates the 'dissonance' of a list of pitches based on three criteria: it is considered more consonant if 1. the numerator and denominator of the Pythagorean ratios of its containing intervals are small (`smallPythagoreanRatio`); 2. it shows few double- or triple-accidentals (`accidentalPenalty`); 3. it shows thirds that can form some triad (`triadAward`) rc34# UHoS:aUOSv M g7f)r,rNr~.0rs rf #_dissonanceScore..CsG;aU 1;srN) noteStartnoteEndg!a"k?r|r-)r-rrr.)r")rrsumra itertools combinationscopydeepcopyoctaver IntervalrbIntervalExceptionrinfintervalToPythagoreanRatiolog denominatorgenericsimpleDirected chromatic semitonesrv)pitchessmallPythagoreanRatioaccidentalPenalty triadAwardscore_accidentals score_ratio score_triad intervalsp accidentalsp1p2 this_intervalratiopenaltysimple_directedinterval_semitoness rf_dissonanceScorer,sKK)+I -45Ws177|W 5G;GG#g,V  I#00!<]]2&  ( 1 1B K   / =&M77 FEhhu001MAG  "K ' s7|# &M+33BBO!.!8!8!B!BR!G !#(:f(Ds"  A%*<*Fs" ' s7|#  +k 9SAVCTBUWaBb>c ccE6)) 88O sF7*A$F<<$G#"G#c^^TSSVs/sHo"/UR5-PM nn[R"U6n[UUU4SjS9nTSS[ U5-$s snf)zN A brute-force way of simplifying -- useful if there are fewer than 5 pitches r,Nc2>T"TSS[U5-5$)Nr,)list)x oldPitches scoreFuncs rf._bruteForceEnharmonicsSearch..ns9ZPRQR^VZ[\V]E];^rhkey)getAllCommonEnharmonicsrproductminr)rrrall_possible_pitchesall_pitch_combinations newPitchess`` rf_bruteForceEnharmonicsSearchrhsnHRRSRT~V~!C!";";"==~V&..0DE+1^_J bq>D, ,,WsAc^^USSmUSSH7nU/UR5-n[UUU4SjS9nTRU5 M9 T$)Nr,c>T"TU/-5$Nr~)rrrs rfr*_greedyEnharmonicsSearch..vs:;K1Lrhr)rrrb)rroldPitch candidatesnewPitchrs ` @rf_greedyEnharmonicsSearchrrsVBQJqrNZ("B"B"DD z'LM(## rhcxUVs/sH%n[U[5(aUO [U5PM' nnU(a"URS5R/U-nSnOSn[ U5S:a [ XA5nO [ XA5n[XF5HupxURUlM U(aUSSnU$s snf)aZ Tries to simplify the enharmonic spelling of a list of pitches, pitch- or pitch-class numbers according to a given criterion. A function can be passed as an argument to `criterion`, that is tried to be minimized in a greedy left-to-right fashion. >>> pitch.simplifyMultipleEnharmonics([11, 3, 6]) [, , ] >>> pitch.simplifyMultipleEnharmonics([3, 8, 0]) [, , ] >>> pitch.simplifyMultipleEnharmonics([pitch.Pitch('G3'), ... pitch.Pitch('C-4'), ... pitch.Pitch('D4')]) [, , ] >>> pitch.simplifyMultipleEnharmonics([pitch.Pitch('A3'), ... pitch.Pitch('B#3'), ... pitch.Pitch('E4')]) [, , ] The attribute `keyContext` is for supplying a KeySignature or a Key which is used in the simplification: >>> pitch.simplifyMultipleEnharmonics([6, 10, 1], keyContext=key.Key('B')) [, , ] >>> pitch.simplifyMultipleEnharmonics([6, 10, 1], keyContext=key.Key('C-')) [, , ] Note that if there's no key context, then we won't simplify everything (at least for now; this behavior may change, ). >>> pitch.simplifyMultipleEnharmonics([pitch.Pitch('D--3'), ... pitch.Pitch('F-3'), ... pitch.Pitch('A--3')]) [, , ] >>> pitch.simplifyMultipleEnharmonics([pitch.Pitch('D--3'), ... pitch.Pitch('F-3'), ... pitch.Pitch('A--3')], ... keyContext=key.Key('C')) [, , ] * Changed in v7.3: fixed a bug with compound intervals (such as formed against the tonic of a KeySignature defaulting to octave 4): >>> pitch.simplifyMultipleEnharmonics([pitch.Pitch('B5')], keyContext=key.Key('D')) [] majorTFr r,N) rurasKeytonicrarrzipspellingIsInferred) r criterion keyContextrr remove_firstsimplifiedPitchesoldPnewPs rfsimplifyMultipleEnharmonicsr{srDKK7az!U++!q97JK &&w/556C    :8O4ZK*8 "&"9"99-ab1 )Ls,B7c\rSrSrSrg)rqir~N__name__ __module__ __qualname____firstlineno____static_attributes__r~rhrfrqrqrhrqc\rSrSrSrg)rir~Nrr~rhrfrrrrhrc\rSrSrSrg)MicrotoneExceptionir~Nrr~rhrfr r rrhr c\rSrSrSrSrSSSjjrSrSrSr Sr S r S r \ S 5r\ S 5r\ S 5r\R"S5rSrg)ria The Microtone object defines a pitch transformation above or below a standard Pitch and its Accidental. >>> m = pitch.Microtone(20) >>> m.cents 20 >>> m.alter 0.2... >>> print(m) (+20c) >>> m Microtones can be shifted according to the harmonic. Here we take the 3rd harmonic of the previous microtone >>> m.harmonicShift = 3 >>> m.harmonicShift 3 >>> m >>> m.cents 1922 >>> m.alter 19.2... Microtonal changes can be positive or negative. Both Positive and negative numbers can optionally be placed in parentheses Negative numbers in parentheses still need the minus sign. >>> m = pitch.Microtone('(-33.333333)') >>> m >>> m = pitch.Microtone('33.333333') >>> m Note that we round the display of microtones to the nearest cent, but we keep the exact alteration in both .cents and .alter: >>> m.cents 33.333... >>> m.alter 0.3333... ) _centShift_harmonicShiftcSUlX l[U[[45(aXlgUR U5 gNr)r r rurvrw _parseString)self centsOrString harmonicShifts rf__init__Microtone.__init__s5&'#0 mc5\ 2 2+O   m ,rhc[U5[La [URUR5$[R "X5$r)typerr r rdefaultDeepcopy)rmemos rf __deepcopy__Microtone.__deepcopy__,s6 : "T__d.A.AB B))$5 5rhc\URUR:Xagg![a gf=f)a! Compare cents (including harmonicShift) >>> m1 = pitch.Microtone(20) >>> m2 = pitch.Microtone(20) >>> m3 = pitch.Microtone(21) >>> m1 == m2 True >>> m1 == m3 False >>> m2.harmonicShift = 3 >>> m1 == m2 False Cannot compare True to a non-Microtone: >>> m1 == pitch.Accidental(1) False TF)rAttributeErrorrothers rf__eq__Microtone.__eq__2s/* {{djj(  s  ++c\URUR[U54n[U5$r)r r rhashr hashValuess rf__hash__Microtone.__hash__Ns- OO    J Jrhc[U5$rstrrs rf _reprInternalMicrotone._reprInternalW 4yrhcBSn[UR5nURS:aSUS3nOURS:a US3nUS:XaSnURS:wa5[R"UR5nUSURUS3- n[ U[ 3$) z Return a string representation. >>> m1 = pitch.Microtone(20) >>> print(m1) (+20c) Differs from the representation: >>> m1 r2r+c0cz-0cr,H)rr r rordinalAbbreviationMICROTONE_OPENMICROTONE_CLOSE)rsub roundShiftordAbbreviations rf__str__Microtone.__str__Zs4??+ ??a j\#C __q L"Cd{   ! #$889L9LMO Qt**+O+ >C !#&788rhc~UR[S5nUR[S5nSnUSS:XdUSR5(a7[R "USS9up4US:Xa[ SU35e[U5nO1USS:Xa([R "USS SS9up4[U5S -nX lg ) z Parse a string representation. r2rr0z 0123456789.)numbersz"no numbers found in string value: r4r,Nr) replacer5r6isdigitr getNumFromStrr rwr )rr centValuenum unused_nonNums rfrMicrotone._parseStringys  nb1 or2  8s?eAh..00!'!5!5e]!S Cby(+MeW)UVVc I 1X_!'!5!5eABi!W Cc RI#rhc URS-$)z[ Return the microtone value in accidental alter values. >>> pitch.Microtone(20).alter 0.2 {Gz?)rr+s rfrMicrotone.alterszzD  rhcF[UR5UR-$)z Return the microtone value in cents. This is not a settable property. To set the value in cents, simply use that value as a creation argument. >>> pitch.Microtone(20).cents 20 )rr r r+s rfrMicrotone.centss't':':;dooMMrhcUR$)z7 Set or get the harmonic shift, altering the microtone r r+s rfrMicrotone.harmonicShifts """rhcXlgrrKrrs rfrrLs#rhN)rr,)rzstr | int | float)rrrr__doc__ __slots__rrr r&r,r:rpropertyrrrsetterrr~rhrfrrs5rI12  - - -6 8 9>$.!! N N## $$rhrc^\rSrSr%Sr\R rSr/SQr SSSS.r S \ S 'S*S+U4S jjjr S r S rSrSrSrSrSrSrSrSr\S5rSS.SjrSrSrSr\S,Sj5r\R>S5r\S-Sj5r \ R>S 5r \S,S!j5r!\!R>S"5r!\S,S#j5r"\"R>S.S$j5r"\S%5r#\#R>S&5r#\S'5r$\S(5r%S)r&U=r'$)/ria Accidental class, representing the symbolic and numerical representation of pitch deviation from a pitch name (e.g., G, B). Two accidentals are considered equal if their names are equal. Accidentals have three defining attributes: a name, a modifier, and an alter. For microtonal specifications, the name and modifier are the same except in the case of half-sharp, half-flat, one-and-a-half-flat, and one-and-a-half-sharp. Accidentals up to quadruple-sharp and quadruple-flat are allowed. Natural-sharp etc. (for canceling a previous flat) are not yet supported officially. >>> a = pitch.Accidental('sharp') >>> a.name, a.alter, a.modifier ('sharp', 1.0, '#') >>> a.style.color = 'red' >>> import copy >>> b = copy.deepcopy(a) >>> b.style.color 'red' ) _alter_displayStatus _displayType _modifier_name_clientdisplayLocation displaySize displayStyle)rlmodifierrsetz1Size in display: "cue", "large", or a percentage.z3Style of display: "parentheses", "bracket", "both".z3Location of accidental: "normal", "above", "below".)r[r\rZdict[str, str] _DOC_ATTRc>[TU]5 SUlSUlSUlSUlSUlSUlSUlSUl SUl URU5 g)Nnormalfullr2r) superrrVrUr\r[rZrYrXrWrTr^)r specifier __class__s rfrAccidental.__init__sf $#%! ($(    rhcURURURURURUR UR UR4$r)rTrUrVrWrXrZr[r\r+s rf _hashValuesAccidental._hashValuessN KK       NN JJ         rhc4[UR55$r)r#rir+s rfr&Accidental.__hash__ sD$$&''rhc [U5[LaG[R[5nUR5Hn[ X#[ X55 M U$[ R"X5$r)rr__new___getSlotsRecursivesetattrgetattrrr)rrnewss rfrAccidental.__deepcopy__ sV : #$$Z0C,,. 01/J))$5 5rhcf[U[5(dgURUR:Xagg)z Equality. Needed for pitch comparisons. >>> a = pitch.Accidental('double-flat') >>> b = pitch.Accidental('double-flat') >>> c = pitch.Accidental('double-sharp') >>> a == b True >>> a == c False FT)rurrlrs rfr Accidental.__eq__s*%,, 99 "rhcTURU5=(d URU5$)z Greater than or equal. Based on the accidentals' alter function. >>> a = pitch.Accidental('sharp') >>> b = pitch.Accidental('flat') >>> a >= b True )__gt__r rs rf__ge__Accidental.__ge__*s!{{5!7T[[%77rhclUb[U[5(dgURUR:agg)z Greater than. Based on the accidentals' alter function. >>> a = pitch.Accidental('sharp') >>> b = pitch.Accidental('flat') >>> a < b False >>> a > b True >>> a > 5 False FTrurrrs rfrxAccidental.__gt__6. = 5* = = :: #rhcTURU5=(d URU5$)z Less than or equal. Based on the accidentals' alter function. >>> a = pitch.Accidental('sharp') >>> b = pitch.Accidental('flat') >>> c = pitch.Accidental('sharp') >>> a <= b False >>> a <= c True )__lt__r rs rf__le__Accidental.__le__Ls!{{5!7T[[%77rhclUb[U[5(dgURUR:agg)z Less than. based on alter. >>> a = pitch.Accidental('natural') >>> b = pitch.Accidental('flat') >>> a > b True >>> a < b False >>> a < 5 False FTr|rs rfrAccidental.__lt__[r~rhcUR$rrkr+s rfr,Accidental._reprInternalq yyrhcUR$rrkr+s rfr:Accidental.__str__trrhc.[S[55$)a Returns a list of accidental names that have any sort of semantic importance in music21. You may choose a name not from this list (1/7th-sharp) but if it's not on this list don't expect it to do anything for you. This is a class method, so you may call it directly on the class: Listed in alphabetical order. (TODO: maybe from lowest to highest or something implying importance?) >>> pitch.Accidental.listNames() ['double-flat', 'double-sharp', 'flat', 'half-flat', 'half-sharp', 'natural', 'one-and-a-half-flat', 'one-and-a-half-sharp', 'quadruple-flat', 'quadruple-sharp', 'sharp', 'triple-flat', 'triple-sharp'] Or call on an instance of an accidental: >>> f = pitch.Accidental('flat') >>> f.listNames() ['double-flat', 'double-sharp', 'flat', 'half-flat', 'half-sharp', 'natural', 'one-and-a-half-flat', 'one-and-a-half-sharp', 'quadruple-flat', 'quadruple-sharp', 'sharp', 'triple-flat', 'triple-sharp'] c3@# UHoR5v M g7fr)lowerrs rfr'Accidental.listNames..sB)AAggii)As)sortedr_)clss rf listNamesAccidental.listNamesws6B)ABBBrhFallowNonStandardValuec[U[5(aUR5nUS;aSUlSUlGOUS[ SSS4;aSUlSUlGOUS[ SS S 4;aSUlS UlGOUS [ S S SS4;aS UlSUlGOUS[ SSS4;aSUlSUlGOnUS[ SSSSS4;aSUlSUlGOKUS[ SSSSSS4;aSUlSUlGO'US [ S S!S"S#S$4;aS UlS$UlGOUS%[ S%S&S'S(S)S*4;aS%UlS*UlOUS+[ S+S,S-4;aS+UlS.UlOUS/[ S/S0S14;aS/UlS2UlOUS3[ S3S4S54;aS3UlS6UlOUS7[ S7S8S94;aS7UlS:UlOaU(d[ US;35e[U[5(aXlg<[U[[45(aXlg<[ US;35e[ URUl UR(aURR5 g>> a = pitch.Accidental() >>> a.set('sharp') >>> a.alter 1.0 >>> a = pitch.Accidental() >>> a.set(2) >>> a.modifier == '##' True >>> a = pitch.Accidental() >>> a.set(2.0) >>> a.modifier == '##' True >>> a = pitch.Accidental('--') >>> a.alter -2.0 >>> a.set('half-sharp') >>> a.alter 0.5 >>> a.name 'half-sharp' Setting an illegal name is generally an error: >>> a.set('flat-flat-up') Traceback (most recent call last): music21.pitch.AccidentalException: flat-flat-up is not a supported accidental type But if 'allowNonStandardValue' is True then other names (if strings) or alters (if numbers) are allowed: >>> a.set('quintuple-sharp', allowNonStandardValue=True) >>> a.set(5.0, allowNonStandardValue=True) >>> a.name 'quintuple-sharp' >>> a.alter 5.0 This is the argument that .name and .alter use to allow non-standard names * Changed in v5: added allowNonStandardValue )r8rGrr8rr9rHr,rr:rIr@r=rLrrrr>rMgrArPrQrRrrBrSrTrUrVg?rCrWrXrYrrDrZr[r\r]gr;rJr-@r<rKr@r?rNgr@rOgz# is not a supported accidental typeN) rur*rrXrTr_rqrvrwrWrY informClient)rrlrs rfr^Accidental.setsf dC ::~&Na!!'DJDK f6v>c2N NDJDK m%=m%Lb""&DJDK l$<\$J%t[#??%DJDK ,./EF+-CV#S**0DJDK k#;K#H$dJ>>$DJDK +./DE*,A6"D**/DJDK n&>~&N##'DJDK './@A:qRR*DJDK m%=m%L$$&DJDK &./?@*bRR)DJDK()TF2U*VWW$$$! D3,//" )TF2U*VWW1$**= << LL % % ' rhc&URS;agg)z Return a boolean if this Accidental describes a twelve-tone, non-microtonal pitch. >>> a = pitch.Accidental('half-flat') >>> a.isTwelveTone() False >>> a = pitch.Accidental('###') >>> a.isTwelveTone() True )rArBrCrDFTrkr+s rf isTwelveToneAccidental.isTwelveTones 99= =rhcUS;a[SUS35eUS:Xa [U5nSU-n[XU5 UR(aURR 5 gg)a Set an attribute of 'name', 'alter', and 'modifier', independently of the other attributes. >>> a = pitch.Accidental('natural') >>> a.setAttributeIndependently('alter', 1.0) >>> a.alter 1.0 >>> a.name 'natural' >>> a.setAttributeIndependently('name', 'sori') >>> a.setAttributeIndependently('modifier', '$') >>> a.modifier '$' >>> a.name 'sori' >>> a.alter 1.0 Only 'name', 'alter', and 'modifier' can be set independently: >>> a.setAttributeIndependently('color', 'red') Traceback (most recent call last): music21.pitch.AccidentalException: Cannot set attribute color independently of other parts. * New in v5: needed because .name, .alter, and .modifier run .set() )rlrr]zCannot set attribute z independently of other parts.r_N)rqrwrprYr)r attributerprivateAttrNames rfsetAttributeIndependently$Accidental.setAttributeIndependently%sk: 9 9%' {2PQS S  %LE /u- << LL % % ' rhcLUb!SHn[X5n[XU5 M gg)aK Given another Accidental object, inherit all the display properties of that object. This is needed when transposing Pitches: we need to retain accidental display properties. >>> a = pitch.Accidental('double-flat') >>> a.displayType = 'always' >>> b = pitch.Accidental('sharp') >>> b.inheritDisplay(a) >>> b.displayType 'always' N) displayType displayStatusr\r[rZ)rqrp)rrattrrs rfinheritDisplayAccidental.inheritDisplayOs1  K,E*K rhcUR$)a Get or set the name of the Accidental, like 'sharp' or 'double-flat' If the name is set to a standard name then it changes alter and modifier. If set to a non-standard name, then it does not change them: >>> a = pitch.Accidental() >>> a.name = 'flat' >>> a.alter -1.0 >>> a.modifier '-' >>> a.name = 'flat-flat-up' >>> a.alter -1.0 * Changed in v5: changing the name here changes other values, conditionally )rXr+s rfrlAccidental.namegs*zzrhc$URUSS9 gNTrr^rNs rfrlr~s d3rhcUR$)a= Get or set the alter of the Accidental, or the semitone shift caused by the Accidental where 1.0 is a shift up of one semitone, and -1.0 is the shift down of one semitone. >>> sharp = pitch.Accidental('sharp') >>> sharp.alter 1.0 >>> sharp.alter = -1 After changing alter to a known other value, name changes: >>> sharp.name 'flat' But changing it to an unusual value does not change the name: >>> notSoFlat = pitch.Accidental('flat') >>> notSoFlat.alter = -0.9 >>> notSoFlat.name 'flat' * Changed in v5: changing the alter here changes other values, conditionally )rTr+s rfrAccidental.alters8{{rhc$URUSS9 grrrNs rfrrs d3rhcUR$)a Get or set the alter of the modifier, or the string symbol used to modify the pitch name, such as "#" or "-" for sharp and flat, respectively. For a representation likely to be read by non-music21 users, see `.unicode`. >>> f = pitch.Accidental('flat') >>> f.modifier '-' >>> f.modifier = '#' >>> f.name 'sharp' However, an unknown modifier does not change anything but is preserved: >>> f.modifier = '&' >>> f.modifier '&' >>> f.name 'sharp' * Changed in v5: changing the modifier here changes other values, conditionally )rWr+s rfr]Accidental.modifiers4~~rhcRURUSS9 g![a Xlgf=f)NFr)r^rqrWrNs rfr]rs+ # HHU%H 8" #"N #s &&cUR$)a Returns or sets the display type of the accidental `"normal"` (default) displays it if it is the first in measure, or is needed to contradict a previous accidental, etc. other valid terms: * "always" * "never" * "unless-repeated" (show always unless the immediately preceding note is the same) * "even-tied" (stronger than always: shows even if it is tied to the previous note) * "if-absolutely-necessary" (display only if it is absolutely necessary, like an F-natural after an F-sharp in the same measure, but not an F-natural following an F-sharp directly across a barline. Nor an F-natural in a different octave immediately following an F-sharp). This is not yet implemented. >>> a = pitch.Accidental('flat') >>> a.displayType = 'unless-repeated' >>> a.displayType 'unless-repeated' >>> a.displayType = 'underwater' Traceback (most recent call last): music21.pitch.AccidentalException: Supplied display type is not supported: 'underwater' )rVr+s rfrAccidental.displayTypes<   rhc:US;a[SU<35eXlg)N)rbalwaysneverzunless-repeated even-tiedif-absolutely-necessaryz(Supplied display type is not supported: )rqrVrNs rfrrs, T T%(PQVPY&Z[ [!rhcUR$)a Determines if this Accidental is to be displayed; can be None (for not set), True, or False. In general do not set this, set .displayType instead. Music21 will change displayStatus at any time without warning. While `.displayType` gives general rules about when this accidental should be displayed or not, `displayStatus` determines whether after applying those rules this accidental will be displayed. In general, a `displayStatus` of `None` means that no high-level processing of accidentals has happened. Can be set to True or False (or None) directly for contexts where the next program down the line cannot evaluate displayType. See stream.makeAccidentals() for more information. Example: >>> n0 = note.Note('C#4') >>> n1 = note.Note('C#4') >>> print(n0.pitch.accidental.displayStatus) None >>> print(n1.pitch.accidental.displayStatus) None >>> s = stream.Stream() >>> s.append([n0, n1]) >>> s.makeAccidentals(inPlace=True) >>> n0.pitch.accidental.displayStatus True >>> n1.pitch.accidental.displayStatus False >>> n1.pitch.accidental.displayStatus = 2 Traceback (most recent call last): music21.pitch.AccidentalException: Supplied display status is not supported: 2 )rUr+s rfrAccidental.displayStatussN"""rhc8US;a[SU35eXlg)N)TFNz*Supplied display status is not supported: )rqrUrNs rfrrs& + +%(RSXRY&Z[ [#rhchUR[;a[UR$UR$)u Return a unicode representation of this accidental or the best unicode representation if that is not possible. >>> flat = pitch.Accidental('flat') >>> flat.unicode '♭' Compare: >>> sharp = pitch.Accidental('sharp') >>> sharp.modifier '#' >>> sharp.unicode '♯' Some accidentals, such as double sharps, produce code points outside the 2-byte set (so called "astral plane" unicode) and thus cannot be used in every circumnstance. >>> sharp = pitch.Accidental('quadruple-flat') >>> sharp.unicode '𝄫𝄫' )r]unicodeFromModifierr+s rfunicodeAccidental.unicodes*8 ==/ /&t}}5 5== rhcUR$)a6 Return the most complete representation of this Accidental. >>> a = pitch.Accidental('double-flat') >>> a.fullName 'double-flat' Note that non-standard microtone names are converted to standard ones: >>> a = pitch.Accidental('quarter-flat') >>> a.fullName 'half-flat' For now this is the same as `.name`. rkr+s rffullNameAccidental.fullName@s$yyrh) rTrYrUrVrWrXrZr[r\)r8)rezint | str | floatreturnr*rrwrr*)(rrrrrOr TextStyle _styleClassrP _DOC_ORDERr`__annotations__rrir&rr ryrxrrr,r: classmethodrr^rrrrQrlrRrr]rrrrr __classcell__)rfs@rfrrs2//K I6JKMP!I~0  (6( 8, 8,CC<27z(z$'(T+0, [[44: \\446__##!!>"" &#&#P$$ !!@rhrc \rSrSr%Sr/SQr\rSS0rS\ S'SoSSSSSSSSS .SpS jjjr S r S r SqS jr SrSrSrSjrSrSjrSrSjrSrSjr\SsSj5r\R,StSj5r\SuSj5r\R,SvSj5r\SwSj5r\R,SxSj5rSrSjrSySjr\SzSj5rSS.SjrSS.S jr\S!5r\R,S"5r\S#5r\R,S$5r\S{S%j5r \ R,S|S&j5r \S{S'j5r!\S{S(j5r"\"R,S}S)j5r"\S{S*j5r#\S+5r$\S~S,j5r%\%R,SS-j5r%\SyS.j5r&\&R,SS/j5r&\S{S0j5r'\'R,S15r'\SS2j5r(\(R,SS3j5r(\SyS4j5r)\S{S5j5r*\S{S6j5r+S{S7jr,S8S9S:S;SS?.r-S@\ SA'\S{SBj5r.S8S9S:SCSS?.r/S@\ SD'\S{SEj5r0\SzSFj5r1\1R,SSGj5r1\SzSHj5r2\2R,SSIj5r2SSJjr3SSKjr4SoSSLjjr5SSMjr6SSNjr7SSOjr80r9SP\ SQ'\:SSRj5r;\:SSSj5r;SSTjr;\:SSUj5r<\:SSVj5rSS.SS]jjr?S^r@SSS_jjrA\SyS`j5rB\BR,SSaj5rB\:SSbj5rC\:SS.SScjj5rCSS.SSdjjrCSSSe.SSfjjrDSSSe.SSgjjrEShrFSirGSSSSSjSSSjSSk. SSljjrHSmrISnrJg)riXa A fundamental object that represents a single pitch. `Pitch` objects are most often created by passing in a note name (C, D, E, F, G, A, B), an optional accidental (one or more "#"s or "-"s, where "-" means flat), and an optional octave number: >>> highEflat = pitch.Pitch('E-6') >>> highEflat.name 'E-' >>> highEflat.step 'E' >>> highEflat.accidental >>> highEflat.octave 6 The `.nameWithOctave` property gives back what we put in, `'E-6'`: >>> highEflat.nameWithOctave 'E-6' `Pitch` objects represent themselves as the class name followed by the `.nameWithOctave`: >>> p1 = pitch.Pitch('a#4') >>> p1 Printing a `pitch.Pitch` object or converting it to a string gives a more compact form: >>> print(p1) A#4 >>> str(p1) 'A#4' .. warning:: A `Pitch` without an accidental has a `.accidental` of None, not Natural. This can lead to problems if you assume that every `Pitch` or `Note` has a `.accidental` that you can call `.alter` or something like that on: >>> c = pitch.Pitch('C4') >>> c.accidental is None True >>> alters = [] >>> for pName in ['G#5', 'B-5', 'C6']: ... p = pitch.Pitch(pName) ... alters.append(p.accidental.alter) Traceback (most recent call last): AttributeError: 'NoneType' object has no attribute 'alter' >>> alters [1.0, -1.0] If a `Pitch` doesn't have an associated octave, then its `.octave` value is None. This means that it represents any G#, regardless of octave. Transposing this note up an octave doesn't change anything. >>> anyGSharp = pitch.Pitch('G#') >>> anyGSharp.octave is None True >>> print(anyGSharp.transpose('P8')) G# Sometimes we need an octave for a `Pitch` even if it's not specified. For instance, we can't play an octave-less `Pitch` in MIDI or display it on a staff. So there is an `.implicitOctave` tag to deal with these situations; by default it's always 4 (unless defaults.pitchOctave is changed) >>> anyGSharp.implicitOctave 4 If a `Pitch` has its `.octave` explicitly set, then `.implicitOctave` always equals `.octave`. >>> highEflat.implicitOctave 6 If an integer or float >= 12 is passed to the constructor then it is used as the `.ps` attribute, which is for most common piano notes, the same as a MIDI number: >>> pitch.Pitch(65) >>> pitch.Pitch(65.5).accidental A `pitch.Pitch` object can also be created using only a number from 0-11, that number is taken to be a `pitchClass`, where 0 = C, 1 = C#/D-, etc. and no octave is set. >>> p2 = pitch.Pitch(3) >>> p2 >>> p2.octave is None True Since in instantiating pitches from numbers, `pitch.Pitch(3)` could be either a D# or an E-flat, this `Pitch` object has an attribute called `.spellingIsInferred` that is set to `True`. That means that when it is transposed or displayed, other functions or programs should feel free to substitute an enharmonically equivalent pitch in its place: >>> p2.spellingIsInferred True >>> p1.spellingIsInferred False As MIDI numbers < 12 are almost unheard of in actual music, there is unlikely to be confusion between a pitchClass instantiation and a MIDI number instantiation, but if one must be clear, use `midi=` in the constructor: >>> lowE = pitch.Pitch(midi=3) >>> lowE.name, lowE.octave ('E-', -1) Instead of using a single string or integer for creating the object, a succession of named keywords can be used instead: >>> p3 = pitch.Pitch(name='C', accidental='#', octave=7, microtone=-30) >>> p3.fullName 'C-sharp in octave 7 (-30c)' The full list of supported keywords are: `name`, `accidental` (which can be a string or an :class:`~music21.pitch.Accidental` object), `octave`, microtone (which can be a number or a :class:`~music21.pitch.Microtone` object), `pitchClass` (0-11), `fundamental` (another `Pitch` object representing the fundamental for this harmonic; `harmonic` is not yet supported, but should be), and `midi` or `ps` (two ways of specifying nearly the same thing, see below). Using keywords to create `Pitch` objects is especially important if extreme pitches might be found. For instance, the first `Pitch` is B-double flat in octave 3, not B-flat in octave -3. The second object creates that low `Pitch` properly: >>> p4 = pitch.Pitch('B--3') >>> p4.accidental >>> p4.octave 3 >>> p5 = pitch.Pitch(step='B', accidental='-', octave=-3) >>> p5.accidental >>> p5.octave -3 Internally, pitches are represented by their scale step (`self.step`), their octave, and their accidental. `Pitch` objects use these three elements to figure out their pitch space representation (`self.ps`); altering any of the first three changes the pitch space (ps) representation. Similarly, altering the .ps representation alters the first three. >>> aSharp = pitch.Pitch('A#5') >>> aSharp.ps 82.0 >>> aSharp.octave = 4 >>> aSharp.ps 70.0 >>> aSharp.ps = 60.0 >>> aSharp.nameWithOctave 'C4' Two Pitches are equal if they represent the same pitch and are spelled the same (enharmonics do not count). A Pitch is greater than another Pitch if its `.ps` is greater than the other. Thus, C##4 > D-4. >>> pitch.Pitch('C#5') == pitch.Pitch('C#5') True >>> pitch.Pitch('C#5') == pitch.Pitch('D-5') False >>> pitch.Pitch('C##5') > pitch.Pitch('D-5') True A consequence of comparing enharmonics for equality but .ps for comparisons is that a `Pitch` can be neither less than nor greater than another `Pitch` without being equal: >>> pitch.Pitch('C#5') == pitch.Pitch('D-5') False >>> pitch.Pitch('C#5') > pitch.Pitch('D-5') False >>> pitch.Pitch('C#5') < pitch.Pitch('D-5') False To check for enharmonic equality, use the .ps attribute: >>> pitch.Pitch('C#5').ps == pitch.Pitch('D-5').ps True Advanced construction of pitch with keywords: >>> pitch.Pitch(name='D', accidental=pitch.Accidental('double-flat')) >>> f = pitch.Pitch(pitchClass=5, octave=4, ... microtone=pitch.Microtone(30), fundamental=pitch.Pitch('B-2')) >>> f >>> f.fundamental If contradictory keyword attributes (like `name='E-', accidental='#'`) are passed in, behavior is not defined, but unlikely to make you happy. Pitches are ProtoM21Objects, so they retain some attributes there such as .classes and .groups, but they don't have Duration or Sites objects and cannot be put into Streams ) rlnameWithOctavestep pitchClassrmidigermanfrenchspanishitaliandutchra Returns True or False about whether enharmonic spelling Has been inferred on pitch creation or whether it has been specified directly. MIDI 61 is C# or D- equally. >>> p = pitch.Pitch('C4') >>> p.spellingIsInferred False >>> p.ps = 61 >>> p.spellingIsInferred True >>> p.name 'C#' >>> p.name = 'C#' >>> p.spellingIsInferred False This makes a difference in transposing. For instance: >>> pInferred = pitch.Pitch(61) >>> pNotInferred = pitch.Pitch('C#4') >>> pInferred.nameWithOctave, pNotInferred.nameWithOctave ('C#4', 'C#4') >>> pInferred.spellingIsInferred, pNotInferred.spellingIsInferred (True, False) >>> inferredTransposed = pInferred.transpose('A1') >>> inferredTransposed.nameWithOctave 'D4' >>> notInferredTransposed = pNotInferred.transpose('A1') >>> notInferredTransposed.nameWithOctave 'C##4' An operation like diatonic transposition should retain the spelling is inferred for the resulting object >>> inferredTransposed.spellingIsInferred, notInferredTransposed.spellingIsInferred (True, False) But Chromatic transposition can change an object to inferred spelling: >>> p3 = notInferredTransposed.transpose(1) # C## -> E- not to C### >>> p3.nameWithOctave 'E-4' >>> p3.spellingIsInferred True r_r`N)rr accidental microtonerrry fundamentalc SUl[RUlSUlSUlSUlSUlSUlSUl SUl Ub[[U[5(aXl OH[U5SSuUlUlSUlUS:a[!US- 5S- UlO UbX lUbX0lUb,[U["5(aX@lO[#U5UlUb,[U[&5(aXPlO['U5UlUbX`lU bXl UbXplUbXlgg)NFrrTr|r,)_groupsr pitchStep_step_overridden_freq440 _accidental _microtone_octaverrrYrur*rlrrrvrrrrrrry) rrlrrrrrrryrkeywordss rfrPitch.__init__wsC*.  (11 /3 -1*."& #((,(,   $$$ /?t.DQq.I+ 4+*.'2:#&tby>A#5DL  I  !L  !*j11",",Z"8  )Y//!*!*9!5  !(O  "*   I >G rhc[U5$rr)r+s rfr,Pitch._reprInternalr.rhcURnURb2URRS:waU[UR5-$U$r)rrrr*rrls rfr: Pitch.__str__sA"" ?? &4??+@+@A+E#doo.. .Krhc [U[5(d[$URUR:XaOURUR:Xa5UR UR :XaUR UR :Xagg)a Are two pitches equal? They must both sound the same and be spelled the same. Enharmonic equivalence is not equality, nor is impliedOctave or is a pitch without an accidental equal to a pitch with a natural accidental. (See `:meth:`~music21.pitch.Pitch.isEnharmonic` for a method that does not require spelling equivalence, and for an example of how to compare notes without accidentals to notes with natural accidentals.) >>> c = pitch.Pitch('C2') >>> c.octave 2 >>> cs = pitch.Pitch('C#4') >>> cs.octave 4 >>> c == cs False >>> c != cs True >>> seven = 7 >>> c == seven False >>> c != seven True >>> df = pitch.Pitch('D-4') >>> cs == df False Implied octaves do not equal explicit octaves >>> c4 = pitch.Pitch('C4') >>> cImplied = pitch.Pitch('C') >>> c4 == cImplied False >>> c4.ps == cImplied.ps True Note: currently spellingIsInferred and fundamental are not checked -- this behavior may change in the future. TF)rurNotImplementedrrrrrs rfr  Pitch.__eq__s`\%''! ! KK5<< 'II+OOu'7'77NNeoo5rhc x[U5[La[R[5nURHhn[ XS5nUS;a[ X#U5 M#US:Xa[ X#S5 M7Uc[ X#S5 MH[ X#[ R"XA55 Mj U$[R"X5$)z highly optimized -- it knows exactly what can only have a scalar value and just sets that directly, only running deepcopy on the other bits. And _client should NOT be deepcopied. In fact, it is cleared to nothing. deepcopy of note will set it back. N)rrrrrY) rrrn__dict__rqrprrrr)rrrrkvs rfrPitch.__deepcopy__ s : --&C]]DT*::CA&)^CD)YCD)CDMM!$:;#J))$5 5rhc URURURURURUR [ U54n[U5$r)rrrrrrrr#r$s rfr&Pitch.__hash__$sK OO     # # NN KK II J Jrhcp[U[5(d[$URUR:agg)z Accepts enharmonic equivalence. Based entirely on pitch space representation. >>> a = pitch.Pitch('c4') >>> b = pitch.Pitch('c#4') >>> a < b True TFrurrryrs rfr Pitch.__lt__0s-%''! ! 77UXX rhctURU5nU[La[$U(agURU5$)a Less than or equal. Based on the accidentals' alter function. Note that to be equal enharmonics must be the same. So two pitches can be neither lt nor gt and not equal to each other! >>> a = pitch.Pitch('d4') >>> b = pitch.Pitch('d8') >>> c = pitch.Pitch('d4') >>> b <= a False >>> a <= b True >>> a <= c True >>> d = pitch.Pitch('c##4') >>> c >= d False >>> c <= d False Do not rely on this behavior -- it may be changed in a future version to create a total ordering. T)rrr )rr lt_results rfr Pitch.__le__As52KK&  &! ! {{5!!rhcp[U[5(d[$URUR:agg)z Accepts enharmonic equivalence. Based entirely on pitch space representation. >>> a = pitch.Pitch('d4') >>> b = pitch.Pitch('d8') >>> a > b False TFrrs rfrx Pitch.__gt__as-%''! ! 77UXX rhctURU5nU[La[$U(agURU5$)a Greater than or equal. Based on the accidentals' alter function. Note that to be equal enharmonics must be the same. So two pitches can be neither lt nor gt and not equal to each other! >>> a = pitch.Pitch('d4') >>> b = pitch.Pitch('d8') >>> c = pitch.Pitch('d4') >>> a >= b False >>> b >= a True >>> a >= c True >>> c >= a True >>> d = pitch.Pitch('c##4') >>> c >= d False >>> c <= d False Do not rely on this behavior -- it may be changed in a future version to create a total ordering. T)rxrr )rr gt_results rfry Pitch.__ge__ss56KK&  &! ! {{5!!rhchURc[R"5UlUR$)zG Similar to Groups on music21 object, returns or sets a Groups object. )rrGroupsr+s rfgroups Pitch.groupss% << ;;=DL||rhcXlgr)r)rrrs rfrrs rhcUR$)a Stores an optional accidental object contained within the Pitch object. This might return None, which is different from a natural accidental: >>> a = pitch.Pitch('E-') >>> a.accidental.alter -1.0 >>> a.accidental.modifier '-' >>> b = pitch.Pitch('C4') >>> b.accidental is None True >>> b.accidental = pitch.Accidental('natural') >>> b.accidental is None False >>> b.accidental )rr+s rfrPitch.accidentals,rhc[U[5(aXlOUcSUlO[U[5(a[U5UlO[U[5(a[U5UlSUlOd[U[ 5(a@[US-5up#[U5Ul[U5S:a[U5Ul O[SU<35eUR5 g)NrrFz/Accidental should be an Accidental object, not ) rurrr*rvrrwrrrrrr)rrrrs rfrr s eZ ( ($  ]#D  s # #)%0D  s # #)%0D "DO u % %7 FLE)%0D 5zD !*5!1NuiXY Y rhcZURc[S5nXlU$UR$)a& Returns or sets the microtone object contained within the Pitch object. Microtones must be supplied in cents. >>> p = pitch.Pitch('E-4') >>> p.microtone.cents == 0 True >>> p.ps 63.0 >>> p.microtone = 33 # adjustment in cents >>> str(p) 'E-4(+33c)' >>> p.microtone >>> (p.name, p.nameWithOctave) # these representations are unchanged ('E-', 'E-4') >>> p.microtone = '(-12c' # adjustment in cents >>> p >>> p.microtone = pitch.Microtone(-30) >>> p r)rr)rmts rfrPitch.microtones+4 ?? "1B OI?? "rhc[U[[[45(a[ U5UlgUc[ S5Ulg[U[5(aXlg[ SU35e)Nrz#Cannot get a microtone object from )rur*rwrvrrrrNs rfrr sW ec5#. / /'.DO ]'lDO y ) )#O #Fug!NO OrhcURb URR5(dgURbURRS:wagg)aW Return True if this Pitch is one of the twelve tones available on a piano keyboard. Returns False if it instead has a non-zero microtonal adjustment or has a quarter tone accidental. >>> p = pitch.Pitch('g4') >>> p.isTwelveTone() True >>> p.microtone = -20 >>> p.isTwelveTone() False >>> p2 = pitch.Pitch('g~4') >>> p2.isTwelveTone() False FrT)rrrrrr+s rfrPitch.isTwelveTone sE& ?? &??//11 ?? &4>>+?+?1+DrhcURUR- nUS:a US- nUS:aM US:a US-nUS:aM [US-5$)au Get cent deviation of this pitch from MIDI pitch. >>> p = pitch.Pitch('c~4') >>> p.ps 60.5 >>> p.midi # midi values automatically round up at 0.5 61 >>> p.getCentShiftFromMidi() -50 >>> p.microtone = -25 >>> p.ps 60.25 >>> p.midi 60 >>> p.getCentShiftFromMidi() 25 >>> p = pitch.Pitch('c#4') >>> p.microtone = -25 >>> p.ps 60.75 >>> p.midi 61 >>> p.getCentShiftFromMidi() -25 >>> p = pitch.Pitch('c#~4') >>> p.ps 61.5 >>> p.midi 62 >>> p.getCentShiftFromMidi() -50 >>> p.microtone = -3 >>> p.ps 61.47 >>> p.midi 61 >>> p.getCentShiftFromMidi() 47 >>> p.microtone = 3 >>> p.ps 61.53 >>> p.midi 62 >>> p.accidental >>> p.getCentShiftFromMidi() -47 >>> p = pitch.Pitch('c`4') # quarter tone flat >>> p.getCentShiftFromMidi() -50 >>> p.microtone = 3 >>> p.getCentShiftFromMidi() -47 Absurd octaves that MIDI can't handle will still give the right sounding pitch out of octave: >>> p = pitch.Pitch('c~4') >>> p.octave = 10 >>> p.ps 132.5 >>> p.midi 121 >>> p.getCentShiftFromMidi() -50 >>> p.octave = -1 >>> p.getCentShiftFromMidi() -50 >>> p.octave = -2 >>> p.getCentShiftFromMidi() -50 g&g(@g&@r)ryrr)r midiDistances rfgetCentShiftFromMidiPitch.getCentShiftFromMidi sc\ww* U" D LU"T! D LT!\C'((rhcSnURbXRR- nURbXRR- nU$)a Get the number of half-steps shifted by this pitch, such as 1.0 for a sharp, -1.0 for a flat, 0.0 for a natural, 2.0 for a double sharp, and -0.5 for a quarter tone flat. Thus, the alter value combines the pitch change suggested by the Accidental and the Microtone combined. >>> p = pitch.Pitch('g#4') >>> p.alter 1.0 >>> p.microtone = -25 # in cents >>> p.alter 0.75 To change the alter value, change either the accidental or the microtone. r)rrrr)rposts rfr Pitch.alterr sF* ?? & OO)) )D ?? & NN(( (D rhFinPlacecU(aUnO[R"U5nURbURRS:Xa&SUlURR S- UlOURRS:Xa&SUlURR S-UlOURRS:Xa&SUlURR S-UlO?URRS:Xa%SUlURR S- UlU(dU$UR 5 g) a Convert any quarter tone Accidentals to Microtones. tilde is the symbol for half-sharp, so G#~ is G three-quarters sharp. >>> p = pitch.Pitch('G#~') >>> str(p), p.microtone ('G#~', ) >>> p.convertQuarterTonesToMicrotones(inPlace=True) >>> p.ps 68.5 >>> str(p), p.microtone ('G#(+50c)', ) >>> p = pitch.Pitch('A') >>> p.accidental = pitch.Accidental('half-flat') # back-tick >>> str(p), p.microtone ('A`', ) >>> x = p.convertQuarterTonesToMicrotones(inPlace=False) >>> str(x), x.microtone ('A(-50c)', ) >>> str(p), p.microtone ('A`', ) NrCrrArBrrDr)rrrrlrrr)rr returnObjs rfconvertQuarterTonesToMicrotones%Pitch.convertQuarterTonesToMicrotones s2 I d+I    +##((K7'+ $&/&9&9&?&?"&D #%%**l:'+ $&/&9&9&?&?"&D #%%**.DD'* $&/&9&9&?&?"&D #%%**.CC'+ $&/&9&9&?&?"&D #     rhcRU(aUnO[R"U5nURRn[ U5upEUR b([ UR RU-5UlO[ U5UlXRlU(dU$UR5 g)a Convert any Microtones available to quarter tones, if possible. >>> p = pitch.Pitch('g3') >>> p.microtone = 78 >>> str(p) 'G3(+78c)' >>> p.convertMicrotonesToQuarterTones(inPlace=True) >>> str(p) 'G#3(-22c)' >>> p = pitch.Pitch('d#3') >>> p.microtone = 46 >>> p >>> p.convertMicrotonesToQuarterTones(inPlace=True) >>> p >>> p = pitch.Pitch('f#2') >>> p.microtone = -38 >>> p.convertMicrotonesToQuarterTones(inPlace=True) >>> str(p) 'F~2(+12c)' N) rrrrrrrrr)rrrrrrs rfconvertMicrotonesToQuarterTones%Pitch.convertMicrotonesToQuarterTones s6 I d+I##))8?    +#-$$**Z7$9I $.j#9I #     rhcURn[URS-S-[U-5nURbX RR -nUR bX RR -nU$)a The ps property permits getting and setting a pitch space value, a floating point number representing pitch space, where 60.0 is C4, middle C, 61.0 is C#4 or D-4, and floating point values are microtonal tunings (0.01 is equal to one cent), so a quarter-tone sharp above C5 is 72.5. Note that the choice of 60.0 for C4 makes it identical to the integer value of 60 for .midi, but .midi does not allow for microtones and is limited to 0-127 while .ps allows for notes before midi 0 or above midi 127. >>> a = pitch.Pitch('C4') >>> a.ps 60.0 Changing the ps value for `a` will change the step and octave: >>> a.ps = 45 >>> a >>> a.ps 45.0 Notice that ps 61 represents both C# and D-flat. Thus, "spellingIsInferred" will be true after setting our pitch to 61: >>> a.ps = 61 >>> a >>> a.ps 61.0 >>> a.spellingIsInferred True Microtonal accidentals and pure Microtones are allowed, as are extreme ranges: >>> b = pitch.Pitch('B9') >>> b.accidental = pitch.Accidental('half-flat') >>> b >>> b.ps 130.5 >>> p = pitch.Pitch('c4') >>> p.microtone = 20 >>> print('%.1f' % p.ps) 60.2 Octaveless pitches use their .implicitOctave attributes: >>> d = pitch.Pitch('D#') >>> d.octave is None True >>> d.implicitOctave 4 >>> d.ps 63.0 >>> d.octave = 5 >>> d.ps 75.0 Setting with microtones >>> p = pitch.Pitch() >>> p.ps = 61 >>> p.ps 61.0 >>> p.spellingIsInferred True >>> p.ps = 61.5 # get a quarter tone >>> p >>> p.ps = 61.7 # set a microtone >>> print(p) C#~4(+20c) >>> p.ps = 61.4 # set a microtone >>> print(p) C#~4(-10c) The property is called when self.step, self.octave or self.accidental are changed. r,r|)rrwimplicitOctaver)rrrr)rrrys rfryPitch.ps snrzz T((1,2gdmC D ?? &oo+++B ?? &nn***B rhc[U5uUlo lnURS:XaSUlOX l[ U5U-UlSUlg)Nr8T)rrrrlrrrr)rrrrs rfryr#T sO5EU4K1 3 88y "DO!O%e,x7 #'rhcSnU"UR5nUS:aSUS--nUS:aUS- nU$US:a SUS--nU$UnU$)a6 Get or set a pitch value in MIDI. MIDI pitch values are like ps values (pitchSpace) rounded to the nearest integer; while the ps attribute will accommodate floats. >>> c = pitch.Pitch('C4') >>> c.midi 60 >>> c.midi = 23.5 >>> c.midi 24 Note that like ps (pitchSpace), MIDI notes do not distinguish between sharps and flats, etc. >>> dSharp = pitch.Pitch('D#4') >>> dSharp.midi 63 >>> eFlat = pitch.Pitch('E-4') >>> eFlat.midi 63 Midi values are constrained to the space 0-127. Higher or lower values will be transposed octaves to fit in this space. >>> veryHighFHalfFlat = pitch.Pitch('F') >>> veryHighFHalfFlat.octave = 12 >>> veryHighFHalfFlat.accidental = pitch.Accidental('half-flat') >>> veryHighFHalfFlat >>> veryHighFHalfFlat.ps 160.5 >>> veryHighFHalfFlat.midi 125 >>> veryHighFHalfFlat.octave = 9 >>> veryHighFHalfFlat.midi 125 >>> notAsHighNote = pitch.Pitch() >>> notAsHighNote.ps = veryHighFHalfFlat.midi >>> notAsHighNote Note that the conversion of improper midi values to proper midi values is done before assigning .ps: >>> a = pitch.Pitch() >>> a.midi = -10 >>> a.midi 2 >>> a.ps 2.0 >>> a.spellingIsInferred True More absurd octaves: >>> p = pitch.Pitch('c~4') >>> p.octave = -1 >>> p.ps 0.5 >>> p.midi 1 >>> p.octave = -2 >>> p.ps -11.5 >>> p.midi 1 c4[R"US-5$)a5 This is round "up" at 0.5 (regardless of negative or positive) Python 3 now uses rounding mechanisms so that odd numbers round one way, even another. But we needed a consistent direction for all half-sharps/flats to go, and now long after Python 2 is no longer supported, this behavior is grandfathered in. r)rr)rs rfschoolYardRounding&Pitch.midi..schoolYardRounding s::a#g& &rhlr|srrx)rr' roundedPSrs rfr Pitch.midid soN ''tww/ s? B/E!   ]R(E E rhc[U5nUS:aSUS--nUS:aUS- nOUS:aSUS--nXlSUlg)zQ midi values are constrained within the range of 0 to 127 floating point values, r)r*r|r+rTN)rryrrNs rfrr- sX e  3; +E!  QY$E#'rhczURb#URURR-$UR$)a Gets or sets the name (pitch name with accidental but without octave) of the Pitch. >>> p = pitch.Pitch('D#5') >>> p.name 'D#' >>> p.name = 'C#' >>> p.name 'C#' >>> a = pitch.Pitch('G#') >>> a.name 'G#' Does not simplify enharmonics >>> a = pitch.Pitch('B---') >>> a.name 'B---' )rrr]r+s rfrl Pitch.name s10 ?? &99t777 799 rhc FUR5n/n/nSnUHFnUS;a*U(d[SU<S35eUR U5 M3SnUR U5 MH SR U5nSR U5n[ U5S :XaXlS UlO<[ U5S :aUS Ul[US S 5UlO[S U<35eU(a[U5nXpl g g ![a [SU<S[U5S35ef=f) z] Set name, which may be provided with or without octave values. C4 or D-3 are both accepted. zArgument to name, z, must be a string, not .F 0123456789z.Cannot have octave given before pitch name in Tr2r,NrzCannot make a name out of ) striprrrrbjoinrarrrrrvr)rusrStroctFoundoctNotfoundNonOctavechar octFoundStrrs rfrlr0 s-  e\\^F !D|#%$'UV\U__`%abb%!% d#ggh' v;! I"DO [1_q DI(4DO #=fZ!HI I %F K ; e1&;STXY_T`Saabcd d es C99'D czURb#URURR-$UR$)uv Name presently returns pitch name and accidental without octave. >>> a = pitch.Pitch('G#') >>> a.unicodeName 'G♯' )rrrr+s rf unicodeNamePitch.unicodeName s1 ?? &99t666 699 rhcxURc UR$UR[UR5-$)a Return or set the pitch name with an octave designation. If no octave as been set, no octave value is returned. >>> gSharp = pitch.Pitch('G#4') >>> gSharp.nameWithOctave 'G#4' >>> dFlatFive = pitch.Pitch() >>> dFlatFive.step = 'D' >>> dFlatFive.accidental = pitch.Accidental('flat') >>> dFlatFive.octave = 5 >>> dFlatFive.nameWithOctave 'D-5' >>> dFlatFive.nameWithOctave = 'C#6' >>> dFlatFive.name 'C#' >>> dFlatFive.octave 6 N.B. -- it's generally better to set the name and octave separately, especially since you may at some point encounter very low pitches such as "A octave -1", which will be interpreted as "A-flat, octave 1". Our crude setting algorithm also does not support octaves above 9. >>> lowA = pitch.Pitch() >>> lowA.name = 'A' >>> lowA.octave = -1 >>> lowA.nameWithOctave 'A-1' >>> lowA.nameWithOctave = lowA.nameWithOctave >>> lowA.name 'A-' >>> lowA.octave 1 Octave must be included in nameWithOctave or an exception is raised: >>> a = pitch.Pitch() >>> a.nameWithOctave = 'C#9' >>> a.nameWithOctave = 'C#' Traceback (most recent call last): music21.pitch.PitchException: Cannot set a nameWithOctave with 'C#' Set octave to None explicitly instead. )rrlr*r+s rfrPitch.nameWithOctave' s1d ;; 99 99s4;;// /rhc[U5nUSUS- n[US5nX0lX@lg! [ SU<35e=f)Nrr,rz!Cannot set a nameWithOctave with )rarvrlrr)rrlenValrlrs rfrr@^ sS PZF6A:&Dr^FI K P #DUI!NO Os -0AcxURc UR$UR[UR5-$)u Return the pitch name with octave with unicode accidental symbols, if available. Read-only property. >>> p = pitch.Pitch('C#4') >>> p.unicodeNameWithOctave 'C♯4' )rr=r*r+s rfunicodeNameWithOctavePitch.unicodeNameWithOctavei s4 ;; ## ###c$++&66 6rhc URnURbUSURR3- nURbUSUR3- nURb,UR R S:waUSUR3- nU$)a  Return the most complete representation of this Pitch, providing name, octave, accidental, and any microtonal adjustments. >>> p = pitch.Pitch('A-3') >>> p.microtone = 33.33 >>> p.fullName 'A-flat in octave 3 (+33c)' >>> p = pitch.Pitch('A`7') >>> p.fullName 'A-half-flat in octave 7' r4z in octave r )rrrrrrrrs rfrPitch.fullNamez s yy ?? & a0012 2D ;; " k$++/ /D ?? &4>>+?+?1+D a() )D rhcUR$)aB The diatonic name of the note; i.e. does not give the accidental or octave. >>> a = pitch.Pitch('B-3') >>> a.step 'B' Upper-case or lower-case names can be given to `.step` -- they will be converted to upper-case >>> b = pitch.Pitch() >>> b.step = 'c' >>> b.step 'C' Changing the `.step` does not change the `.accidental` or `.octave`: >>> a = pitch.Pitch('F#5') >>> a.step = 'D' >>> a.nameWithOctave 'D#5' Giving a value that includes an accidental raises a PitchException. Use .name instead to change that. >>> b = pitch.Pitch('E4') >>> b.step = 'B-' Traceback (most recent call last): music21.pitch.PitchException: Cannot make a step out of 'B-' This is okay though: >>> b.name = 'B-' Note that if spelling is inferred, setting the step does NOT give that enharmonic. Perhaps it should, but best to make people use .getLowerEnharmonic or .getHigherEnharmonic instead. >>> b.ps = 60 >>> b.nameWithOctave 'C4' >>> b.spellingIsInferred True >>> b.step = 'B' >>> b.accidental is None # maybe this should set to B#? But that could be screwy. True >>> b.spellingIsInferred False )rr+s rfr Pitch.step sjzzrhcUR5R5n[U5S:XaU[;aXlSUlO[ SU<35eUR5 g)z6 This does not change octave or accidental, only step r,FzCannot make a step out of N)r4upperrar+rrrr)rr6s rfrrJ sW %%' v;! ) 3J&+D # #=fZ!HI I rhc2[UR5S-$)a> Returns or sets the integer value for the pitch, 0-11, where C=0, C#=1, D=2, etc. to B=11. Can be set using integers (0-11) or 'A' or 'B' for 10 or 11. >>> a = pitch.Pitch('a3') >>> a.pitchClass 9 >>> dis = pitch.Pitch('d3') >>> dis.pitchClass 2 >>> dis.accidental = pitch.Accidental('#') >>> dis.pitchClass 3 If a string "A" or "B" is given to pitchClass, it is still returned as an int. >>> dis.pitchClass = 'A' >>> dis.pitchClass 10 >>> dis.name 'B-' Extreme octaves will not affect pitchClass >>> dis.octave = -10 >>> dis.pitchClass 10 In the past, certain microtones and/or octaves were returning pc 12! This is now fixed. >>> flattedC = pitch.Pitch('C4') >>> flattedC.microtone = -4 >>> print(flattedC) C4(-4c) >>> flattedC.pitchClass 0 >>> print(flattedC.ps) 59.96 >>> flattedC.octave = -3 >>> print(flattedC.ps) -24.04 >>> flattedC.pitchClass 0 Note that the pitchClass of a microtonally altered pitch is the pitch class of the nearest pitch. Python 3 uses the "round-to-even" method so C~4 (C half sharp 4) is pitchClass 0, since 60.5 rounds to 60.0 >>> p = pitch.Pitch('C~4') >>> p.ps 60.5 >>> p.pitchClass 0 However, for backwards compatability, the MIDI number of a microtone is created by using "schoolyard" rounding which always rounds 0.5 upwards, which can cause some unusual behavior: >>> p.midi 61 >>> pitch.Pitch(midi=p.midi).pitchClass 1 This means that pitchClass + microtone is NOT a good way to estimate the frequency of a pitch. For instance, if we take a pitch that is 90% of the way between pitchClass 0 (C) and pitchClass 1 (C#/D-flat), this formula gives an inaccurate answer of 1.9, not 0.9: >>> p = pitch.Pitch('C4') >>> p.microtone = 90 >>> p >>> p.pitchClass + (p.microtone.cents / 100.0) 1.9 More examples of setting the pitchClass. >>> a = pitch.Pitch('a3') >>> a.pitchClass = 3 >>> a >>> a.spellingIsInferred True >>> a.pitchClass = 'A' >>> a Changing pitchClass does not remove microtones. >>> a.microtone = 20 >>> a.pitchClass = 1 >>> a r|)rryr+s rfrPitch.pitchClass sHTWW~""rhc^[U5n[U5SSuUlUlSUlg)NrrT)rzrrrr)rrvalueOuts rfrrNB s39?&6x&@1&E# 4##'rhc,[UR5$)a Returns or sets a string representation of the pitch class, where integers greater than 10 are replaced by A and B, respectively. Can be used to set pitch class by a string representation as well (though this is also possible with :attr:`~music21.pitch.Pitch.pitchClass`). >>> a = pitch.Pitch('a#3') >>> a.pitchClass 10 >>> a.pitchClassString 'A' We can set the pitchClassString as well: >>> a.pitchClassString = 'B' >>> a.pitchClass 11 )rrr+s rfpitchClassStringPitch.pitchClassStringM s*&doo66rhcXlgr)r)rrs rfrRrSd srhcUR$)a; Returns or sets the octave of the note. Setting the octave updates the pitchSpace attribute. >>> a = pitch.Pitch('g') >>> a.octave is None True >>> a.implicitOctave 4 >>> a.ps ## will use implicitOctave 67.0 >>> a.name 'G' >>> a.octave = 14 >>> a.octave 14 >>> a.implicitOctave 14 >>> a.name 'G' >>> a.ps 187.0 )rr+s rfr Pitch.octavei s4||rhcZUb[U5UlOSUlUR5 gr)rvrrrNs rfrrV s&  u:DLDL rhcTURc[R$UR$)a Returns the octave of the Pitch, or defaultOctave if octave was never set. To set an octave, use .octave. Default octave is usually 4. >>> p = pitch.Pitch('C#') >>> p.octave is None True >>> p.implicitOctave 4 Cannot be set. Instead, just change the `.octave` of the pitch )rr pitchOctaver+s rfr"Pitch.implicitOctave s$ ;; '' ';; rhcPURbURRnOSnURnU[U5:wa [ S5e[U5nUS:XaUS:waSnOUS- nUS:XaU$US:a X!S--nU$US;aS nOS n[ U5S- nX$-US --nU$) u Read-only property. Returns a unicode string of the name of a Pitch in the German system (where B-flat = B, B = H, etc.) (Microtones and Quarter tones raise an error). Note that Ases is used instead of the also acceptable Asas. >>> print(pitch.Pitch('B-').german) B >>> print(pitch.Pitch('B').german) H >>> print(pitch.Pitch('E-').german) Es >>> print(pitch.Pitch('C#').german) Cis >>> print(pitch.Pitch('A--').german) Ases >>> p1 = pitch.Pitch('C') >>> p1.accidental = pitch.Accidental('half-sharp') >>> p1.german Traceback (most recent call last): music21.pitch.PitchException: Es geht nicht "german" zu benutzen mit Microtönen. Schade! Note these rarely used pitches: >>> print(pitch.Pitch('B--').german) Heses >>> print(pitch.Pitch('B#').german) His ru<Es geht nicht "german" zu benutzen mit Microtönen. Schade!rrr3r,rH)r%r&r'r(r3rLrs)rrrrvrr)r tempAltertempSteptempName firstFlatName multipleFlatss rfr Pitch.german sB ?? &--II  I & !_` ` N s?BQ >O ]t#34HO44 $ #  NQ.M/=43GHHOrhcpURbURRnOSnURnU[U5:wa [ S5e[U5nSSSSS.nSS S S S S SS.nUS:XaXB$US:aUS:a [ S5eXBX1-S-$US-nUS:a [ S5eXBX1-S-$)a Read-only attribute. Returns the name of a Pitch in the Italian system (F-sharp is fa diesis, C-flat is do bemolle, etc.) (Microtones and Quarter tones raise an error). >>> print(pitch.Pitch('B-').italian) si bemolle >>> print(pitch.Pitch('B').italian) si >>> print(pitch.Pitch('E-9').italian) mi bemolle >>> print(pitch.Pitch('C#').italian) do diesis >>> print(pitch.Pitch('A--4').italian) la doppio bemolle >>> p1 = pitch.Pitch('C') >>> p1.accidental = pitch.Accidental('half-sharp') >>> p1.italian Traceback (most recent call last): music21.pitch.PitchException: Non si puo usare `italian` con microtoni Note these rarely used pitches: >>> print(pitch.Pitch('E####').italian) mi quadruplo diesis >>> print(pitch.Pitch('D---').italian) re triplo bemolle rz(Non si puo usare `italian` con microtonirGz doppio z triplo z quadruplo )r,rr-rdoremifasollasir$rzEntirely too many sharpsdiesisrzEntirely too many flatsbemolle)rrrrvr)rr\r]cardinalityMap solfeggeMaps rfr Pitch.italian sB ?? &--II  I & !KL L N  ZJ=Q t$T!49  >( ( ]1}$%?@@(>+DDxO O!BI1}$%>??(>+DDyP PrhcURcg[URR5nUS:XagUS:XagUS:XagUS:Xagg) Nr2r,rz dobler- tripleru cuádruple)rrr)rrcs rf_getSpanishCardinalPitch._getSpanishCardinal sN ?? "DOO))*AAvaa a$rhrhrircrdrerfrg)rrr%r&rr'r(zdict[StepName, str] _SPANISH_DICTcFURbURRnOSnURURnU[ U5:wa [ S5eUS:XaU$US;aX R 5-S-$US;aX R 5-S-$[ S5e)as Read-only attribute. Returns the name of a Pitch in Spanish (Microtones and Quarter tones raise an error). >>> print(pitch.Pitch('B-').spanish) si bemol >>> print(pitch.Pitch('E-').spanish) mi bemol >>> print(pitch.Pitch('C#').spanish) do sostenido >>> print(pitch.Pitch('A--').spanish) la doble bemol >>> p1 = pitch.Pitch('C') >>> p1.accidental = pitch.Accidental('half-sharp') >>> p1.spanish Traceback (most recent call last): music21.pitch.PitchException: Unsupported accidental type. Note these rarely used pitches: >>> print(pitch.Pitch('B--').spanish) si doble bemol >>> print(pitch.Pitch('B#').spanish) si sostenido rzUnsupported accidental type.>rrrrz bemol>r,rr-rz sostenido)rrrsrrvrrq)rr\solfeges rfr Pitch.spanish6 s8 ?? &--II$$TYY/ I & !?@ @ >N * *5577(B B , &5577,F F !?@ @rhuré _FRENCH_DICTc URbURRnOSnURURnU[ U5:wa [ S5e[ U5S:a [ S5e[ U5nUS:XaU$[ U5S:XaUnOM[ U5S:XaUS-nO8[ U5S:XaUS -nO#[ U5S:XaUS -nO[ S U35eU[ U5- S:XaUS -nU$US -nU$)u Read-only attribute. Returns the name of a Pitch in the French system (where A = la, B = si, B-flat = si bémol, C-sharp = do dièse, etc.) (Microtones and Quarter tones raise an error). Note that do is used instead of the also acceptable ut. >>> print(pitch.Pitch('B-').french) si bémol >>> print(pitch.Pitch('B').french) si >>> print(pitch.Pitch('E-').french) mi bémol >>> print(pitch.Pitch('C#').french) do dièse >>> print(pitch.Pitch('A--').french) la double bémol >>> p1 = pitch.Pitch('C') >>> p1.accidental = pitch.Accidental('half-sharp') >>> p1.french Traceback (most recent call last): music21.pitch.PitchException: On ne peut pas utiliser les microtones avec "french." Quelle Dommage! rzEOn ne peut pas utiliser les microtones avec "french." Quelle Dommage!ruxOn ne peut pas utiliser les altération avec puissance supérieure à quatre avec "french." Ça me fait une belle jambe!rrz doublerrpz quadruplezCannot deal with tempStep: u dièseu bémol)rrrwrrvrr)rr\r]tempNumberedStepr^s rfr Pitch.frenchn s&@ ?? &--II))$))4 I & WY Y y>C  @  N >O ^s "'  ^s "')3  ^s "')3  ^s "',6  #>xj!IJ J s9~ % ,')3HO')3HOrhcUR$)a The frequency property gets or sets the frequency of the pitch in hertz. If the frequency has not been overridden, then it is computed based on A440Hz and equal temperament >>> a = pitch.Pitch() >>> a.frequency = 440.0 >>> a.frequency 440.0 >>> a.name 'A' >>> a.octave 4 Microtones are captured if the frequency doesn't correspond to any standard note. >>> a.frequency = 450.0 >>> a freq440r+s rf frequencyPitch.frequency s0||rhcXlgrr|rNs rfr~r s rhc~UR(a UR$URS- nSURU--$)aE Gets the frequency of the note as if it's in an equal temperament context where A4 = 440hz. The same as .frequency so long as no other temperaments are currently being used. Since we don't have any other temperament objects at present, this is the same as .frequency always. >>> a = pitch.Pitch('A4') >>> a.freq440 440.0 E{@)rry_twelfth_root_of_two)rA4offsets rfr} Pitch.freq440 s>  # #++ +ww|HD55AB BrhcS[R"US- 5[R"S5- -S-n[U[5nX0lg)Nr|rrr)rrrrry)rrrrs rfr}r s?TXXeem,txx{:;b@4/ 0rhcN[U5n[R"U5nUS:XaU$URb([ UR R U-5UlO[ U5Ul[5nURUl[R"U5Ul U$)a. Return a Pitch object representing the harmonic found above this Pitch. >>> p = pitch.Pitch('a4') >>> print(p.getHarmonic(2)) A5 >>> print(p.getHarmonic(3)) E6(+2c) >>> print(p.getHarmonic(4)) A6 >>> print(p.getHarmonic(5)) C#7(-14c) >>> print(p.getHarmonic(6)) E7(+2c) >>> print(p.getHarmonic(7)) F#~7(+19c) >>> print(p.getHarmonic(8)) A7 >>> p2 = p.getHarmonic(2) >>> p2 >>> p2.fundamental >>> p2.transpose('p5', inPlace=True) >>> p2 >>> p2.fundamental Or we can iterate over a list of the next 8 odd harmonics: >>> allHarmonics = '' >>> for i in [9, 11, 13, 15, 17, 19, 21, 23]: ... allHarmonics += ' ' + str(p.getHarmonic(i)) >>> print(allHarmonics) B7(+4c) D~8(+1c) F~8(-9c) G#8(-12c) B-8(+5c) C9(-2c) C#~9(+21c) E`9(-22c) Microtonally adjusted notes also generate harmonics: >>> q = pitch.Pitch('C4') >>> q.microtone = 10 >>> q.getHarmonic(2) >>> q.getHarmonic(3) The fundamental is stored with the harmonic. >>> h7 = pitch.Pitch('A4').getHarmonic(7) >>> print(h7) F#~7(+19c) >>> h7.fundamental >>> h7.harmonicString() '7thH/A4' >>> h7.harmonicString('A3') '14thH/A3' >>> h2 = h7.getHarmonic(2) >>> h2 >>> h2.fundamental >>> h2.fundamental.fundamental >>> h2.transpose(-24, inPlace=True) >>> h2 >>> h2.fundamental.fundamental r) rrrrrrrrr~r)rnumber centShifttempfinals rf getHarmonicPitch.getHarmonic sR,F3 mmD) >K ?? &&t~~';';i'GHDN&y1DN.. MM$/ rhcD[U[5(a [U5nUnURUR::a[ SSUSUS3-5e/n[ SS5HBnUR U5nURXE45 URUR:dMB O [U5S:arUSupgURUR:aURUR- nOURUR:aURUR- nOhSnOeUS upUS upURU R- n U RUR- nX::aU n[U 5*nU nOU n[U5nU n[U[5S -nXh4$) a Given another Pitch as a fundamental, find the harmonic of that pitch that is equal to this Pitch. Returns a tuple of harmonic number and the number of cents that the first Pitch object would have to be shifted to be the exact harmonic of this fundamental. Microtones applied to the fundamental are irrelevant, as the fundamental may be microtonally shifted to find a match to this Pitch. Example: G4 is the third harmonic of C3, albeit 2 cents flatter than the true 3rd harmonic. >>> p = pitch.Pitch('g4') >>> f = pitch.Pitch('c3') >>> p.harmonicFromFundamental(f) (3, 2.0) >>> p.microtone = p.harmonicFromFundamental(f)[1] # adjust microtone >>> int(f.getHarmonic(3).frequency) == int(p.frequency) True The shift from B-5 to the 7th harmonic of C3 is more substantial and likely to be noticed by the audience. To make p the 7th harmonic it'd have to be lowered by 31 cents. Note that the second argument is a float, but because the default rounding of music21 is to the nearest cent, the 0.0 is not a significant digit. I.e. it might be more like 31.3 cents. >>> p = pitch.Pitch('B-5') >>> f = pitch.Pitch('C3') >>> p.harmonicFromFundamental(f) (7, -31.0) z5cannot find an equivalent harmonic for a fundamental r0z ) that is not above this Pitch (r1r, rrrrr) rur*rryrrangerrbrarrr)rrtargetfoundrcr harmonicMatchmatchgap harmonicLowercandidateLowerharmonicHighercandidateHigher distanceLowerdistanceHighers rfharmonicFromFundamentalPitch.harmonicFromFundamentalVsP k3 ' ' ,K 99  & Gk]"B4&JK  q"A''*A LL! ttfii  u:>#(8 Mxx&))#hh*FII%ii%((*,1"I )M.3Bi +N"II(9(99M,//&));N .&=)) - (.) . C/036!!rhc0Uc$URc [S5eURn[U[5(a [ U5nUR U5up#[ U*5n[R"U5nUS:Xa UUSU3$UUSUSU3$)a9 Return a string representation of a harmonic equivalence. N.B. this has nothing to do with what string a string player would use to play the harmonic on. (Perhaps should be renamed). >>> pitch.Pitch('g4').harmonicString('c3') '3rdH(-2c)/C3' >>> pitch.Pitch('c4').harmonicString('c3') '2ndH/C3' >>> p = pitch.Pitch('c4') >>> p.microtone = 20 # raise 20 >>> p.harmonicString('c3') '2ndH(+20c)/C3' >>> p.microtone = -20 # lower 20 >>> p.harmonicString('c3') '2ndH(-20c)/C3' >>> p = pitch.Pitch('c4') >>> f = pitch.Pitch('c3') >>> f.microtone = -20 >>> p.harmonicString(f) '2ndH(+20c)/C3(-20c)' >>> f.microtone = +20 >>> p.harmonicString(f) '2ndH(-20c)/C3(+20c)' >>> p = pitch.Pitch('A4') >>> p.microtone = 69 >>> p.harmonicString('c2') '7thH/C2' >>> p = pitch.Pitch('A4') >>> p.harmonicString('c2') '7thH(-69c)/C2' zDno fundamental is defined for this Pitch: provide one as an argumentrH/r3/) rrrur*rrrrr4)rrharmonicrrabbrs rfharmonicStringPitch.harmonicStringsX  '$&DEE**K k3 ' ' ,K66{Cuf% ))(3 A:ZvR }5 5ZvQyk;-@ @rhc[U[5(a [U5nO[R"U5nUR U5up#U*nUR b!UR RU-UlX!4$US:waX1lX!4$)a Given a Pitch that is a plausible target for a fundamental, return the harmonic number and a potentially shifted fundamental that describes this Pitch. >>> g4 = pitch.Pitch('g4') >>> g4.harmonicAndFundamentalFromPitch('c3') (3, ) r)rur*rrrrrr)rrrrs rfharmonicAndFundamentalFromPitch%Pitch.harmonicAndFundamentalFromPitchs fc " "6]F]]6*F66v>    ' &//55=F z#( rhcfURU5up![R"U5nUUSU3$)a Given a Pitch that is a plausible target for a fundamental, find the harmonic number and a potentially shifted fundamental that describes this Pitch. Return a string representation. >>> pitch.Pitch('g4').harmonicAndFundamentalStringFromPitch('c3') '3rdH/C3(-2c)' >>> pitch.Pitch('c4').harmonicAndFundamentalStringFromPitch('c3') '2ndH/C3' >>> p = pitch.Pitch('c4') >>> p.microtone = 20 # raise 20 >>> p.harmonicAndFundamentalStringFromPitch('c3') '2ndH/C3(+20c)' >>> p.microtone = -20 # lower 20 >>> p.harmonicAndFundamentalStringFromPitch('c3') '2ndH/C3(-20c)' >>> p = pitch.Pitch('c4') >>> f = pitch.Pitch('c3') >>> f.microtone = -20 >>> p.harmonicAndFundamentalStringFromPitch(f) '2ndH/C3' >>> f.microtone = +20 >>> p.harmonicAndFundamentalStringFromPitch(f) '2ndH/C3' >>> p = pitch.Pitch('A4') >>> p.microtone = 69 >>> p.harmonicAndFundamentalStringFromPitch('c2') '7thH/C2' >>> p = pitch.Pitch('A4') >>> p.harmonicAndFundamentalStringFromPitch('c2') '7thH/C2(-69c)' r)rrr4)rrrrs rf%harmonicAndFundamentalStringFromPitch+Pitch.harmonicAndFundamentalStringFromPitch&s=T!% D D[ Q))(3D6K=11rhcURb URcURUR- S-S:H$URUR:H$)aq Return True if another Pitch is an enharmonic equivalent of this Pitch. >>> p1 = pitch.Pitch('C#3') >>> p2 = pitch.Pitch('D-3') >>> p3 = pitch.Pitch('D#3') >>> p1.isEnharmonic(p2) True >>> p2.isEnharmonic(p1) True >>> p3.isEnharmonic(p1) False Pitches are enharmonics of themselves: >>> pC = pitch.Pitch('C4') >>> pC.isEnharmonic(pC) True Notes that sound in different octaves are not enharmonics: >>> pitch.Pitch('C#4').isEnharmonic( pitch.Pitch('D-5') ) False However, different octave numbers can be the same enharmonic, because octave number is relative to the `step` (natural form) of the pitch. >>> pitch.Pitch('C4').isEnharmonic( pitch.Pitch('B#3') ) True >>> pitch.Pitch('C4').isEnharmonic( pitch.Pitch('B#4') ) False If either pitch is octaveless, then a pitch in any octave will match: >>> pitch.Pitch('C#').isEnharmonic( pitch.Pitch('D-9') ) True >>> pitch.Pitch('C#4').isEnharmonic( pitch.Pitch('D-') ) True Quarter tone enharmonics work as well: >>> pC.accidental = pitch.Accidental('one-and-a-half-sharp') >>> pC >>> pD = pitch.Pitch('D4') >>> pD.accidental = pitch.Accidental('half-flat') >>> pD >>> pC.isEnharmonic(pD) True Microtonally altered pitches do not return True unless the microtones are the same: >>> pSharp = pitch.Pitch('C#4') >>> pSharp.microtone = 20 >>> pFlat = pitch.Pitch('D-4') >>> pSharp.isEnharmonic(pFlat) False >>> pFlat.microtone = 20 >>> pSharp.isEnharmonic(pFlat) True Extreme enharmonics also work: >>> p4 = pitch.Pitch('B##3') >>> p5 = pitch.Pitch('E---4') >>> p4.isEnharmonic(p5) True If either pitch has no octave then the comparison is done without regard to octave: >>> pSharp4 = pitch.Pitch('C#4') >>> pFlatNoOctave = pitch.Pitch('D-') >>> pSharp4.isEnharmonic(pFlatNoOctave) True >>> pFlatNoOctave.isEnharmonic(pSharp4) True `isEnharmonic` can be combined with a test to see if two pitches have the same step to ensure that they both sound the same and are written the same, without regard to the presence or absence of an accidental (this is used in `:meth:~music21.stream.base.Stream.stripTies`): >>> pD4 = pitch.Pitch('D4') >>> pDNatural4 = pitch.Pitch('D4', accidental=pitch.Accidental('natural')) >>> pD4 == pDNatural4 False >>> pD4.isEnharmonic(pDNatural4) and pD4.step == pDNatural4.step True >>> pEbb4 = pitch.Pitch('E--4') >>> pD4.isEnharmonic(pEbb4) and pD4.step == pEbb4.step False r|r)rryrs rf isEnharmonicPitch.isEnharmonicVsJ@ << 4;;#6HHtww&",1 188tww& &rhz/dict[t.Literal['d2', '-d2'], interval.Interval]_transpositionIntervalscgrr~rrups rf_getEnharmonicHelperPitch._getEnharmonicHelper rhcgrr~rs rfrrrrhcSnU(dSnX0R;a#[R"U5URU'URUnURnUR USS9nU(d UcSUlU$UR UlUR UlURbURUlUcSUlgURUlg)zH abstracts the code from `getHigherEnharmonic` and `getLowerEnharmonic` d2z-d2N) maxAccidental)rr rrtransposePitchrrr)rrrintervalString intervalObj octaveStoredrs rfrrs 26"N !=!= =;C;L;L^;\D ( ( 822>B {{  & &t4 & @#HDIllDO{{&!"#"  hh rhcU$rr~rrs rfgetHigherEnharmonicPitch.getHigherEnharmonic rhcgrr~rs rfrrrhcRU(aURSSS9 gURSSS9$)a= Returns an enharmonic `Pitch` object that is a higher enharmonic. That is, the `Pitch` a diminished-second above the current `Pitch`. >>> p1 = pitch.Pitch('C#3') >>> p2 = p1.getHigherEnharmonic() >>> print(p2) D-3 We can also set it in place (in which case it returns None): >>> p1 = pitch.Pitch('C#3') >>> p1.getHigherEnharmonic(inPlace=True) >>> print(p1) D-3 The method even works for certain CRAZY enharmonics >>> p3 = pitch.Pitch('D--3') >>> p4 = p3.getHigherEnharmonic() >>> print(p4) E----3 But not for things that are just utterly insane: >>> p4.getHigherEnharmonic() Traceback (most recent call last): music21.pitch.AccidentalException: -5 is not a supported accidental type Note that half accidentals (~ = half-sharp, ` = half-flat) get converted to microtones: >>> pHalfSharp = pitch.Pitch('D~4') >>> p3QuartersFlat = pHalfSharp.getHigherEnharmonic() >>> print(p3QuartersFlat) E-4(-50c) OMIT_FROM_DOCS (Same thing if done in place; prior bug) >>> pHalfSharp = pitch.Pitch('D~4') >>> pHalfSharp.getHigherEnharmonic(inPlace=True) >>> print(pHalfSharp) E-4(-50c) TrrNFrrs rfrrs4b   % %dt % <,,Ut,D DrhcU$rr~rs rfgetLowerEnharmonicPitch.getLowerEnharmonic)rrhcgrr~rs rfrr-rrhcRU(aURSSS9 gURSSS9$)a returns a Pitch enharmonic that is a diminished second below the current note If `inPlace` is set to true, changes the current Pitch and returns None. >>> p1 = pitch.Pitch('E-') >>> p2 = p1.getLowerEnharmonic() >>> print(p2) D# The lower enharmonic can have a different octave than the original. >>> p1 = pitch.Pitch('C-3') >>> p2 = p1.getLowerEnharmonic() >>> print(p2) B2 >>> p1 = pitch.Pitch('C#3') >>> p1.getLowerEnharmonic(inPlace=True) >>> print(p1) B##2 TFrNrrs rfrr1s36   % %du % =,,Uu,E Erhr mostCommoncrU(aUnO[R"U5nURb[[URR5S:aUR S;aO'UR nURUlUcSUlU(aUR S:XaSUl[S5UlOwUR S:XaSUl[S5UlOOUR S :XaS Ul[S 5UlO'UR S :XaS Ul[S 5UlU(agU$)a Returns a new Pitch (or sets the current one if inPlace is True) that is either the same as the current pitch or has fewer sharps or flats if possible. For instance, E# returns F, while A# remains A# (i.e., does not take into account that B- is more common than A#). Useful to call if you ever have an algorithm that might take your piece far into the realm of double or triple flats or sharps. If mostCommon is set to True, then the most commonly used enharmonic spelling is chosen (that is, the one that appears first in key signatures as you move away from C on the circle of fifths). Thus, G-flat becomes F#, A# becomes B-flat, D# becomes E-flat, D-flat becomes C#, G# and A-flat are left alone. >>> p1 = pitch.Pitch('B#5') >>> p1.simplifyEnharmonic().nameWithOctave 'C6' >>> p2 = pitch.Pitch('A#2') >>> p2.simplifyEnharmonic(inPlace=True) >>> p2 >>> p3 = pitch.Pitch('E--3') >>> p4 = p3.transpose(interval.Interval('-A5')) >>> p4.simplifyEnharmonic() Setting `mostCommon` = `True` simplifies enharmonics even further. >>> pList = [pitch.Pitch('A#4'), pitch.Pitch('B-4'), ... pitch.Pitch('G-4'), pitch.Pitch('F#4')] >>> [str(p.simplifyEnharmonic(mostCommon=True)) for p in pList] ['B-4', 'B-4', 'F#4', 'F#4'] Note that pitches with implicit octaves retain their implicit octaves. This might change the pitch space for B#s and C-s. >>> pList = [pitch.Pitch('B'), pitch.Pitch('C#'), pitch.Pitch('G'), pitch.Pitch('A--')] >>> [str(p.simplifyEnharmonic()) for p in pList] ['B', 'C#', 'G', 'G'] >>> pList = [pitch.Pitch('C-'), pitch.Pitch('B#')] >>> [p.ps for p in pList] [59.0, 72.0] >>> [p.simplifyEnharmonic().ps for p in pList] [71.0, 60.0] Nr)zE#zB#zC-zF-zD#rr=zA#rzG-r'r9zD-r%) rrrrrrlrryrr)rrrr saveOctaves rfsimplifyEnharmonicPitch.simplifyEnharmonicRst I d+I    +I((../#5!.FF"[[ #ww %'+I$ ~~%!$ '1&'9 $4'!$ '1&'9 $4'!$ '1'': $4'!$ '1'': $  rhcU(aUnO[R"U5nURbURRS:aUR SS9 OURRS:aUR SS9 O_UR S;aUR SS9 O?UR SS9 O/UR S;aUR SS9 OUR SS9 U(aUR5 gU$)a Returns a new Pitch that is the(/an) enharmonic equivalent of this Pitch. Can be thought of as flipEnharmonic or something like that. N.B.: n1.name == getEnharmonic(getEnharmonic(n1)).name is not necessarily true. For instance: getEnharmonic(E##) => F# getEnharmonic(F#) => G- getEnharmonic(A--) => G getEnharmonic(G) => F## However, for all cases not involving double sharps or flats (and even many that do), getEnharmonic(getEnharmonic(n)) = n For the most ambiguous cases, it's good to know that these are the enharmonics: C <-> B#, D <-> C##, E <-> F-; F <-> E#, G <-> F##, A <-> B--, B <-> C- However, isEnharmonic() for A## and B certainly returns True. >>> p = pitch.Pitch('d#') >>> print(p.getEnharmonic()) E- >>> p = pitch.Pitch('e-8') >>> print(p.getEnharmonic()) D#8 Other tests: >>> print(pitch.Pitch('c-3').getEnharmonic()) B2 >>> print(pitch.Pitch('e#2').getEnharmonic()) F2 >>> print(pitch.Pitch('f#2').getEnharmonic()) G-2 >>> print(pitch.Pitch('c##5').getEnharmonic()) D5 >>> print(pitch.Pitch('g3').getEnharmonic()) F##3 >>> print(pitch.Pitch('B7').getEnharmonic()) C-8 Octaveless Pitches remain octaveless: >>> p = pitch.Pitch('a-') >>> p.getEnharmonic() >>> p = pitch.Pitch('B#') >>> p.getEnharmonic() Works with half-sharps, but converts them to microtones: >>> dHalfSharp = pitch.Pitch('D~') >>> print(dHalfSharp.getEnharmonic()) E-(-50c) NrTr)r%r&r()rrrrrrrr)rrrs rf getEnharmonicPitch.getEnharmonicsz D==&D ?? &$$q((((6&&*'''599/++D+9,,T,:yyO+'''5(((6     KrhcTURbURR5 gg)zL if this pitch is attached to a note, then let it know that it has changed. N)rY pitchChangedr+s rfrPitch.informClient s# << # LL % % ' $rhc\/nURSS9nUcU$URUR:waURU5 UnURSS9nUcOKUR b$[ UR R5U:aOX2;aURU5 OOM_UnURSS9nUcU$UR b&[ UR R5U:aU$X2;aURU5 OU$Me![a Muf=f![a U$f=f)a Return all common unique enharmonics for a pitch, or those that do not involve more than two accidentals. >>> p = pitch.Pitch('c#3') >>> p.getAllCommonEnharmonics() [, ] "Higher" enharmonics are listed before "Lower": >>> p = pitch.Pitch('G4') >>> p.getAllCommonEnharmonics() [, ] By setting `alterLimit` to a higher or lower number we can limit the maximum number of notes to return: >>> p = pitch.Pitch('G-6') >>> p.getAllCommonEnharmonics(alterLimit=1) [] If you set `alterLimit` to 3 or 4, you're stretching the name of the method; some of these are certainly not *common* enharmonics: >>> p = pitch.Pitch('G-6') >>> enharmonics = p.getAllCommonEnharmonics(alterLimit=3) >>> [str(enh) for enh in enharmonics] ['A---6', 'F#6', 'E##6'] Music21 does not support accidentals beyond quadruple sharp/flat, so `alterLimit` = 4 is the most you can use. (Thank goodness!) Fr) rrlrbrrqrrrr)r alterLimitrr1s rfrPitch.getAllCommonEnharmonicssUB!#  # #E # 2 9K 66TYY  KKN  ))%)8y||'q||))*Z7} A  (((7y ||'q||))*Z7  } A '   '   s$D (D DD D+*D+cN[URS-SUR--$)u Returns (or takes) an integer that uniquely identifies the diatonic version of a note, that is ignoring accidentals. The number returned is the diatonic interval above C0 (the lowest C on a Bösendorfer Imperial Grand), so G0 = 5, C1 = 8, etc. Numbers can be negative for very low notes. C4 (middleC) = 29, C#4 = 29, C##4 = 29, D-4 = 30, D4 = 30, etc. >>> c = pitch.Pitch('c4') >>> c.diatonicNoteNum 29 Unlike MIDI numbers (or `.ps`), C and C# has the same `diatonicNoteNum`: >>> c = pitch.Pitch('c#4') >>> c.diatonicNoteNum 29 But D-double-flat has a different `diatonicNoteNum` than C. >>> d = pitch.Pitch('d--4') >>> d.accidental.name 'double-flat' >>> d.diatonicNoteNum 30 >>> lowC = pitch.Pitch('c1') >>> lowC.diatonicNoteNum 8 >>> b = pitch.Pitch() >>> b.step = 'B' >>> b.octave = -1 >>> b.diatonicNoteNum 0 An `implicitOctave` of 4 is used if octave is not set: >>> c = pitch.Pitch('C') >>> c.diatonicNoteNum 29 `diatonicNoteNum` can also be set. Changing it does not change the Accidental associated with the `Pitch`. >>> lowDSharp = pitch.Pitch('C#7') # start high !!! >>> lowDSharp.diatonicNoteNum = 9 # move low >>> lowDSharp.octave 1 >>> lowDSharp.name 'D#' Negative diatonicNoteNums are possible, in case, like John Luther Adams, you want to notate the sounds of sub-sonic Earth rumblings. >>> lowLowA = pitch.Pitch('A') >>> lowLowA.octave = -1 >>> lowLowA.diatonicNoteNum -1 >>> lowLowLowD = pitch.Pitch('D') >>> lowLowLowD.octave = -3 >>> lowLowLowD.diatonicNoteNum -19 r,r!)r/rr"r+s rfdiatonicNoteNumPitch.diatonicNoteNum]s)P"$)),q0A8K8K4KLLrhc`[US- S- 5nUS- SU-- nSnXCnX lXPlg)Nr,r!r$)rvrr)rnewNumr noteNameNum pitchListnoteNames rfrrs>fqjA%&qjAJ/ *M &3  rhcgrr~rrrs rf transposePitch.transpose rhcgrr~rs rfrrrrhcZ[U[R5(aUnO[R"U5nUR U5n[U[ 5(dUR UlUR SLaURSSS9 U(dU$URUlURbURUl URUl URUl UR UlURb%[R"UR5Ul g)a Transpose the pitch 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. >>> aPitch = pitch.Pitch('g4') >>> bPitch = aPitch.transpose('m3') >>> bPitch >>> cPitch = bPitch.transpose(interval.GenericInterval(2)) >>> cPitch An interval object can also be a certain number of semitones, in which case, the spelling of the resulting note (sharp or flat, etc.) is up to the system to choose. >>> aInterval = interval.Interval(-6) >>> bPitch = aPitch.transpose(aInterval) >>> bPitch Transpose fFlat down 5 semitones -- sort of like a Perfect 4th, but should be respelled: >>> fFlat = pitch.Pitch('F-4') >>> newPitch = fFlat.transpose(-5) >>> newPitch >>> aPitch >>> aPitch.transpose(aInterval, inPlace=True) >>> aPitch Implicit octaves remain implicit: >>> anyGSharp = pitch.Pitch('G#') >>> print(anyGSharp.transpose('P8')) G# >>> print(anyGSharp.transpose('P5')) D# If the accidental of a pitch is chosen by music21, not given by the user, then after transposing, music21 will simplify the spelling again: >>> pc6 = pitch.Pitch(6) >>> pc6 >>> pc6.spellingIsInferred True >>> pc6.transpose('-m2') OMIT_FROM_DOCS Test to make sure that extreme ranges work >>> dPitch = pitch.Pitch('D2') >>> lowC = dPitch.transpose('m-23') >>> lowC >>> otherPitch = pitch.Pitch('D2') >>> otherPitch.transpose('m-23', inPlace=True) >>> print(otherPitch) C#-1 Test an issue with inPlace not setting spellingIsInferred >>> pc6.transpose(10, inPlace=True) >>> pc6.spellingIsInferred True Test an issue with inPlace not setting microtone. >>> flatAndAHalf = pitch.Accidental('one-and-a-half-flat') >>> dFlatAndAHalf = pitch.Pitch('D2') >>> dFlatAndAHalf.accidental = flatAndAHalf >>> dPitch = pitch.Pitch('D2') >>> intv = interval.Interval(dFlatAndAHalf, dPitch) >>> dPitch.transpose(intv, inPlace=True) >>> dPitch TrN)rur IntervalBaserrrvrrrlrrrrrr)rrrrrs rfrrsH eX22 3 3K"++E2K  & &t ,%%%#'#:#:A  4 ' $ ?H DI{{&hh llDO }}D &'&:&:D #||'"&-- "=rh)minimizercURc [S5eU(aUnO[R"U5nURceURUR- S::aOU=RS-slM5U(a6URUR- S:aOU=RS- slM5U(dU$g)aK Given a source Pitch, shift it down some number of octaves until it is below the target. If `minimize` is True, a pitch below the target will move up to the nearest octave. >>> higherG = pitch.Pitch('G5') >>> lowerG = higherG.transposeBelowTarget(pitch.Pitch('C#4')) >>> lowerG >>> higherG To change the pitch itself, set inPlace to True: >>> p = pitch.Pitch('G5') >>> p.transposeBelowTarget(pitch.Pitch('C#4'), inPlace=True) >>> p If already below the target, make no change: >>> pitch.Pitch('G#3').transposeBelowTarget(pitch.Pitch('C#6')) Below target includes being the same as the target >>> pitch.Pitch('g#8').transposeBelowTarget(pitch.Pitch('g#1')) This does nothing because it is already low enough: >>> pitch.Pitch('g#2').transposeBelowTarget(pitch.Pitch('f#8')) But with minimize=True, it will actually RAISE the pitch so that it is the closest pitch to the target >>> target = pitch.Pitch('f#8') >>> pitch.Pitch('g#2').transposeBelowTarget(target, minimize=True) >>> pitch.Pitch('f#2').transposeBelowTarget(target, minimize=True) If the original pitch is octaveless, raises a PitchException: >>> pitch.Pitch('d').transposeBelowTarget(pitch.Pitch('e2'), minimize=True) Traceback (most recent call last): music21.pitch.PitchException: Cannot call transposeBelowTarget with an octaveless Pitch. If the target pitch is octaveless, assumes it has the default of octave 4. (The reason for this asymmetry is that the target pitch is never altered while the original pitch (or its copy) is). >>> pitch.Pitch('f4').transposeBelowTarget(pitch.Pitch('e'), minimize=True) * Changed in v3: default for inPlace=False. Nz:Cannot call transposeBelowTarget with an octaveless Pitch.rr,r|rrrrryrrrrsrcs rftransposeBelowTargetPitch.transposeBelowTargetHsP ;;  !]^ ^ C--%Czz%%%vv !Q& JJ!OJ  99svv%*JJ!OJ  JrhcURc [S5eU(aUnO[R"U5nURceURUR- S:aOU=RS- slM5U(a6URUR- S:aOU=RS-slM5U(dU$g)a\ Given a source Pitch, shift it up octaves until it is above the target. If `minimize` is True, a pitch above the target will move down to the nearest octave. >>> pitch.Pitch('d2').transposeAboveTarget(pitch.Pitch('e4')) To change the pitch itself, set inPlace to True: >>> p = pitch.Pitch('d2') >>> p.transposeAboveTarget(pitch.Pitch('e4'), inPlace=True) >>> p If already above the target, make no change: >>> pitch.Pitch('d7').transposeAboveTarget(pitch.Pitch('e2')) Accept the same pitch: >>> pitch.Pitch('d2').transposeAboveTarget(pitch.Pitch('d8')) If minimize is True, we go the closest position: >>> pitch.Pitch('d#8').transposeAboveTarget(pitch.Pitch('d2'), minimize=True) >>> pitch.Pitch('d7').transposeAboveTarget(pitch.Pitch('e2'), minimize=True) >>> pitch.Pitch('d0').transposeAboveTarget(pitch.Pitch('e2'), minimize=True) If the original pitch is octaveless, raises a PitchException: >>> pitch.Pitch('d').transposeAboveTarget(pitch.Pitch('e2'), minimize=True) Traceback (most recent call last): music21.pitch.PitchException: Cannot call transposeAboveTarget with an octaveless Pitch. If the target pitch is octaveless, assumes it has the default of octave 4. (The reason for this asymmetry is that the target pitch is never altered while the original pitch (or its copy) is). >>> pitch.Pitch('d4').transposeAboveTarget(pitch.Pitch('e'), minimize=True) * Changed in v3: default for inPlace=False. Nz:Cannot call transposeAboveTarget with an octaveless Pitch.rr,r|rrs rftransposeAboveTargetPitch.transposeAboveTargetst ;;  !]^ ^ C--%Czz%%%vv !Q& JJ!OJ  66FII%*JJ!OJ  JrhcURcgUHOnURUR:XdMURRURR:XdMO g g)a{ Determine if this pitch is in the collection of supplied altered pitches, derived from a KeySignature object >>> ks = key.KeySignature(2) >>> altered = ks.alteredPitches >>> altered [, ] >>> cs = pitch.Pitch('c#') >>> gs = pitch.Pitch('g#') >>> cs._nameInKeySignature(altered) True >>> gs._nameInKeySignature(altered) False Note that False is returned regardless of the name if the key signature has no entry for the pitch: >>> pitch.Pitch('G')._nameInKeySignature(altered) False Other accidentals for pitches whose `.step` is in the key signature also do not match: >>> f = pitch.Pitch('F') >>> f._nameInKeySignature(altered) False >>> f.accidental = pitch.Accidental('natural') >>> f._nameInKeySignature(altered) False >>> pitch.Pitch('F##')._nameInKeySignature(altered) False >>> pitch.Pitch('C-')._nameInKeySignature(altered) False FT)rrrlralteredPitchesrs rf_nameInKeySignaturePitch._nameInKeySignaturesPJ ?? "Avv"<<$$(<(<< rhcNUHnURUR:XdM g g)a% Determine if this pitch is in the collection of supplied altered pitches, derived from a KeySignature object >>> a = pitch.Pitch('c') >>> b = pitch.Pitch('g') >>> ks = key.KeySignature(2) >>> a._stepInKeySignature(ks.alteredPitches) True >>> b._stepInKeySignature(ks.alteredPitches) False TF)rrs rf_stepInKeySignaturePitch._stepInKeySignature3s& Avv" rhT) pitchPastpitchPastMeasureotherSimultaneousPitchesrcautionaryPitchClass cautionaryAlloverrideStatuscautionaryNotImmediateRepeatlastNoteWasTiedc ^^^TRmUU4SjmSUU4Sjjn Uc/nUc/nUc/nSn X!-n USLa#TcOTRcOTRS;agTbTRS:XaSTlgU SLa$Tb TRS:waSTlgSTlggU(a*U(a#[U4S jU55(a U "S5 gU (dTb[U(dTRS ;aDTRS :XaTR U5TlgTR U5(+TlgTb-TRSLaTR U5(aSTlgTbTRS :XaTR U5(aU "S5 g[U5H_n U RTR:XdMU RTR:XdM;U RTR:wa U "S5 g O USLdTbTRS ;a U "S5 gSnUSLa0TbTRS :wa[TR5nTUlOTn[U5n[[U 5S- SS5GHHnUU:aSnSnTbTRS :Xa GO)OASn[U[U 55H$nU URTR:wdM"Sn O SnUSLa"TbTR U5(d STl gUSLa@TbTRS :wa-[U UR5nU URUlOU UnURUR:waMTRU UR:XaSnOSnUSLa2URb%URRSLa TbSTl gUSLaURbURbtTbqURRURR:XaCTR U5SLa#USLdURRSLaSn GMSTlSn GOnURbURRS :XaURbURRS :XaUSLa-TR U5SLaUSLa U "S5 O^TbSTlOSTR U5SLaUSLa U "S5 O1TR U5SLaUSLaUSLa U "S5 O TbSTlSn GOURbURUR:wauURRS :wa[URbURRSLa5USLaUSLaGM+USLaTbTRS :XaGMFU "S5 Sn GOURbURRS :Xa6Tb3URb&URRS :wa STlSn GOURbkURb^URRURR:wa0Tb-U(dURRS :wa STlSn GO%URcLURb?Tb<URRS :XaTR U5TlOSTlSn OUSLaURbURbURRURR:XazTbwUSLarUSLa&URRSLa STlSn Sn OLURRSLaSn GMTR U5(dSTlOSTlSn gGMK U SLa)TR U5SLa U "S5 gTbSTlggU(dFTbCTRS :XaTR U5TlgTR U5(+TlgU(d$Tc TR U5(a U "S5 gggg)a Given an ordered list of Pitch objects in `pitchPast`, determine if this pitch's Accidental object needs to be created or updated with a natural or other cautionary accidental. Changes to this Pitch object's Accidental object are made in-place. `pitchPast` is a list of pitches preceding this pitch in the same measure. If None, a new list will be made. `pitchPastMeasure` is a list of pitches preceding this pitch but in a previous measure. If None, a new list will be made. `otherSimultaneousPitches` is a list of other pitches in this simultaneity, for use when `cautionaryPitchClass` is True. The `alteredPitches` list supplies pitches from a :class:`~music21.key.KeySignature` object using the :attr:`~music21.key.KeySignature.alteredPitches` property. If None, a new list will be made. If `cautionaryPitchClass` is True, comparisons to past accidentals are made regardless of register. That is, if a past sharp is found two octaves above a present natural, a natural sign is still displayed. Note that this has nothing to do with whether a sharp (not in the key signature) is found in a different octave from the same note in a different octave. The sharp must always be displayed. Notes with displayType = 'if-absolutely-necessary' will ignore the True setting. If `overrideStatus` is True, this method will ignore any current `displayStatus` setting found on the Accidental. By default, this does not happen. If `displayStatus` is set to None, the Accidental's `displayStatus` is set. If `cautionaryNotImmediateRepeat` is True, cautionary accidentals will be displayed for an altered pitch even if that pitch had already been displayed as altered (unless it's an immediate repetition). Notes with displayType = 'if-absolutely-necessary' will ignore the True setting. If `lastNoteWasTied` is True then this note will be treated as immediately following a tie. >>> a = pitch.Pitch('a') >>> past = [pitch.Pitch('a#'), pitch.Pitch('c#'), pitch.Pitch('c')] >>> a.updateAccidentalDisplay(pitchPast=past, cautionaryAll=True) >>> a.accidental, a.accidental.displayStatus (, True) >>> b = pitch.Pitch('a') >>> past = [pitch.Pitch('a#'), pitch.Pitch('c#'), pitch.Pitch('c')] >>> b.updateAccidentalDisplay(pitchPast=past) # should add a natural >>> b.accidental, b.accidental.displayStatus (, True) In this example, the method will not add a natural because the match is pitchSpace and our octave is different. >>> a4 = pitch.Pitch('a4') >>> past = [pitch.Pitch('a#3'), pitch.Pitch('c#'), pitch.Pitch('c')] >>> a4.updateAccidentalDisplay(pitchPast=past, cautionaryPitchClass=False) >>> a4.accidental is None True v8 -- made keyword-only and added `otherSimultaneousPitches`. c2>Tc[S5mTTlgg)Nr8)rr)rrsrfnone_to_natural6Pitch.updateAccidentalDisplay..none_to_naturals{ +"%rhc,>T"5 TceUTlgr)r)newDisplayStatusrrs rfset_displayStatus8Pitch.updateAccidentalDisplay..set_displayStatuss  ? "? 0C rhNF)TFrTrc3># UH>nURTR:H=(a URTR:gv M@ g7fr)rr)rpSimultrs rfr0Pitch.updateAccidentalDisplay..s<97GLLDII-W'2D2D2WW7sAA )FNr8)rrrr,r)r bool)rrranyrlrrreversedrrrrarr)rrrrrrrrrrr (displayAccidentalIfNoPreviousAccidentals pitchPastAll thisPPastsetFromPitchPastpSelfoutOfMeasureLengthrcpPastInMeasurecontinuousRepeatsInMeasurejpPast octaveMatchrrs` @@rfupdateAccidentalDisplayPitch.updateAccidentalDisplayGsboo &  1 1  I  #!   !N490'3 U "{""*""m3 ?s'9 %C   d "??k1(-C%)-C% %$97999 d # '3+<+< +M88y((,(@(@(PC% -1,D,D^,T(TC% /''4/..~>>$)! ;#((i"7..~>>!$'  "),I~~*y/?/?4;;/N>>TYY.%d+- T !OO'>> d # ! D ([+DD$))$E"E E!!12s<(1,b"5A%%!&-2*?s:S'S"&q#l"34A $A559L9LL5:2526.%' 44^DD$(!%,;T(Tl1o223$0?#=#= $QzzUZZ'{{l1o444" # +d2((4((66$>?(-C%-4&&2&&2o&&++u/?/?/D/DD ,,^<E$-!,,::eC?C<(-C%'+$"".&&++y8''/**//9<-500@DH +u 4)$/?05C-..~>$F6$>%d+ ..~>$F6%?(E1%d+ ,1)#' "".jjEJJ.&&++y8''/**88EA%',@E,I5(OOO/HH!$'#' ##+&&++y8''3'',, 9$(!#' "".&&2&&++u/?/?/D/DDo"e&6&6&B&BF_&_$(!#'  ""*&&2o##((I5(,(@(@(PC%(,C%#'  -5&&2&&2&&++u/?/?/D/DDo!T)0E9!,,::%G).C%?D<'+$%%33u>> n1 = note.Note('d3') >>> n2 = note.Note('g3') >>> n2.notehead = 'diamond' >>> n2.noteheadFill = False >>> p1 = pitch.Pitch('d3') >>> harmChord = chord.Chord([n1, n2]) >>> harmChord.quarterLength = 1 >>> newChord = p1.getStringHarmonic(harmChord) >>> newChord.quarterLength = 1 >>> pitchList = newChord.pitches >>> pitchList (, , ) otherwise returns False rr)chordFr,diamondTr|rr!r-r rr.rnoStem)music21rr"r getNoteheadr notesToChromatic intervalClassrNoternoteheadParenthesis noteheadFill stemDirectionnoteheadChord) rchordInrr"risStringHarmonicchordInt soundingPitchnoteOutnote1note2chordOuts rfgetStringHarmonicPitch.getStringHarmonics0 !!OO     y| , 9# ,,Yq\9Q<H  ! !R '%aL44Q7M  # #q (%aL44Q7M  # #q (%aL44Q7M  # #q (%aL44Q7M  # #q (%aL44Q7M  # #q (%aL44Q7M  # #q (%aL44Q7M&aLM))M889&*## ( )A,556 )A,556 ,,Yq\:;;g67rh)rrYrrrrrrr}rrrrlrrryrrr)rlzstr | int | float | NonerzStepName | Noner int | Nonerz%Accidental | str | int | float | NonerzMicrotone | int | float | Nonerzint | PitchClassString | Nonerr9ryz float | Nonerz Pitch | None)robject)rr)r base.Groups)rrr;)rzAccidental | None)rz%str | Accidental | None | int | float)rr)rz$float | int | str | None | Microtone)rrvrr)r6r*r)rr )r6r rNone)rzint | PitchClassString)rr9)rzint | float | None)r int | float)rrvrr)r str | Pitchrztuple[int, float])rzstr | Pitch | Nonerr*)rr>rztuple[int, Pitch])rr>rr*)rrrr)rrrt.Literal[True]rrrr<)rrrt.Literal[False]rrrr)rrrrrrrPitchType | None)rrrr@rr)rrrr?rr<)rrrrrrA)rrrrA)r)rrrrvrzlist[PitchType])rrv)rrr!interval.IntervalBase | str | intrr?rr<)rrrrBrr@rr)rrrrBrrrrA)rlist[Pitch] | NonerrCrrCrrCrrrrrrrrrr)KrrrrrOrTWELFTH_ROOT_OF_TWOrr`rrr,r:r rr&rrrxryrQrrRrrrrrrrryrrlr=rrDrrrrRrr"rrrqrsrrwrr~r}rrrrrrrrrrrrrrrrrrrrrrr7rr~rhrfrrXs_B;J/ 0 2!I~2j-1P(,$(=A7;9="&"&+/P)P%P" P ; P 5 P7P P P)Pd5p62  ""@$!"H ]]  .,##@PP4V)p6:?2 h:?- b^^@YY ' 'YYv [[''$8 [[&!&!P  4040lPP77 844l [[  c#c#J''77,6 ]](::z8Q8Qt"      *M&*A*AZ      )L%BBH2 CC( ^^aFa"-6a"%6a"f6:;A$2;A;Az    B,2",2 ,2`d'NPRLQ  &5 !% *.   &6 !% *3  &*!%*8<AF5Ep@EFH \\  \|38Wt(HVGMGMR  , !      %*   , "      AA,A A  AT bb  bN',%* U0> Ur,\.'+-159+/%)#$-1 %E($E(+ E( #3 E( ) E(#E(E(E('+E(E(NErhc\rSrSrSrSrg)TestiYc2SSKJn U"U[55 g)Nr) testCopyAll)music21.test.commonTestrHglobals)rrHs rftestCopyAndDeepcopyTest.testCopyAndDeepcopyZs7D')$rhr~N)rrrrrKrr~rhrfrFrFYs%rhrF__main__)rlr*rr)rlr*rr*)ryzint | float | PitchClassStringrr=)rrvrr*)ryr=rrv)ryr=rz+tuple[StepName, Accidental, Microtone, int])rztuple[float, float])rr=rrv)TTT)r list[Pitch]rrrrrr)rrN)MrO __future__r collectionsrrrrtypingrrunittestr%rrmusic21.common.objectsrmusic21.common.typesr r r r r rr TYPE_CHECKINGrTypeVarr Environment environLocalLiteralPitchClassStringr)rrr*r+r/rDrr5r6r_itemsrpchrrrjrgaccidentalModifiersSortedrmrrrzrrrrrrrrrMusic21Exceptionrqrr ProtoM21Objectr StyleMixinrrTestCaserFrrmainTest)rrs00rfrcs##  5) ?? IIk 1 &&w/ 99CD   %        )%? => +'&     .F-K-K-MN-MTQAD-MN! S\CL () Hs7| #$ 3w< 8c'l "##g, S\CL () 3w< 8c'l "##g,# !!'! N! n ! ! !  & !! M! m! !\! ,!!1!2!  "!!")#!$ /0 !'1!:+,%NNJ"< (8X)X)X)v+/\$*T48/3(,9c,09c(,9c"&9cxEU-AQ4DPTMd ,77  \22  66 S$&&(:S$l` '')9)9` L{;G " "{;Bx%8  %Z +  z TogOsK=