rhSrSSKJr SSKrSSKrSSKrSSKJr SSK J r SSK J r SSK J r SSKJr SS KJr SS K Jr SS K Jr SS K Jr SS K Jr SSK Jr SSK Jr \R0(aSSK Jr SiSjrSS.SjSjjr"SS\R85r"SS\ R<5r"SS\5r "SS\ RB5r""SS\ RB5r#"SS\RH5r%"S S!\ R<5r&"S"S#\&5r'"S$S%\&5r("S&S'\&5r)"S(S)\5r*"S*S+\5r+"S,S-\+5r,"S.S/\,5r-"S0S1\-5r."S2S3\-5r/"S4S5\,5r0"S6S7\05r1"S8S9\05r2"S:S;\+5r3"S<S=\35r4"S>S?\35r5"S@SA\35r6"SBSC\35r7"SDSE\+5r8"SFSG\+5r9"SHSI\95r:"SJSK\+5r;"SLSM\;5r<"SNSO\<5r="SPSQ\<5r>"SRSS\;5r?"STSU\?5r@"SVSW\?5rA"SXSY\R85rB"SZS[\+5rC"S\S]\5rD"S^S_\R85rE"S`Sa\RH5rF"SbSc\RH5rG"SdSe\5rH"SfSg\RH5rI\*/rJ\KSh:XaSSK r \ R"5 gg)ka_ This module provides object representations of expressions, that is notational symbols such as Fermatas, Mordents, Trills, Turns, etc. which are stored under a Music21Object's .expressions attribute. A sub-category of Expressions are Ornaments. Unlike articulations, expressions can be attached to the Stream itself. For instance, TextExpressions. ) annotationsN)Fraction)base)common) OrnamentDelay)opFrac)OffsetQL) exceptions21)interval)key)pitch)spanner)stylenotecX[U[R5(a/URS:H=(a URR S:H$[U[R 5(aURS:H$[U[R5(aUR S:H$g)NP1rF) isinstancer Intervalname chromatic semitonesDiatonicIntervalChromaticInterval)intvs M/home/james-whalen/.local/lib/python3.13/site-packages/music21/expressions.pyisUnisonr/s$))**yyD BT^^%=%=%BB D(33 4 4yyD  D(44 5 5~~"" keySigc6Un[R(aUce[US5(dU/$UR(dU/$/n/nSnU(a[R(aUceUS-nURSn[US5(aUR X!S9upxn UHn UR U 5 M U Hn UR U 5 M UcUnOrURSSUlUn[R(aUceUR(dO0O&URSSUlUR(dO U(aM/n UHn U R U 5 M UbU R U5 UHn U R U 5 M U $)a given a Note or Unpitched with Ornament expressions, convert them into a list of objects that represents the performed version of the object: >>> n1 = note.Note('D5') >>> n1.quarterLength = 1 >>> n1.expressions.append(expressions.WholeStepMordent()) >>> expList = expressions.realizeOrnaments(n1) >>> st1 = stream.Stream() >>> st1.append(expList) >>> #_DOCS_SHOW st1.show() .. image:: images/expressionsMordentRealize.* :width: 218 N expressionsdrrealizer)t TYPE_CHECKINGhasattrr"r%append) srcObjr srcObject preExpandListpostExpandList loopBusterthisExpression preExpand newSrcObject postExpandiretLists rrealizeOrnamentsr58s*06I$$$ 9m , ,{  " "{   ,,, !OJ&2215N~y116D6L6L7M73 #A!((+##A"))!,$' ,I+4+@+@+D (( ??$000 ,,-)2(=(=ab(A % ,,9j<A NN1   NN9 %A NN1  rc\rSrSrSrg)ExpressionExceptionN__name__ __module__ __qualname____firstlineno____static_attributes__r9rrr7r7rr7cb^\rSrSrSr\R rU4SjrSSjr \ SSj5r Sr U=r $) Expressionz; This base class is inherited by many diverse expressions. c 4>[TU]"S0UD6 SUlg)Nfirstr9)super__init__ tieAttachselfkeywords __class__s rrGExpression.__init__s $8$ rcg)Nr9rJs r _reprInternalExpression._reprInternalsrcXURRn[R"USS9$)a& returns the name of the expression, which is generally the class name lowercased and spaces where a new capital occurs. Subclasses can override this as necessary. >>> sc = expressions.Schleifer() >>> sc.name 'schleifer' >>> iTurn = expressions.InvertedTurn() >>> iTurn.name 'inverted turn'  ) replacement)rLr;rcamelCaseToHyphen)rJ classNames rrExpression.names& NN++ '' sCCr)rHreturnstr)r;r<r=r>__doc__r TextStyle _styleClassrGrQpropertyrr? __classcell__rLs@rrBrBs3//K!DDrrBcz^\rSrSrSrSr\RrS SS.U4Sjjjr Sr \ S Sj5r S r S rS rU=r$) RehearsalMarka? A rehearsal mark is a type of Expression that designates a rehearsal marking, such as A., B., etc. Takes two inputs, content ('B', 5, 'III') and an optional numbering system which is helpful for getting the next rehearsal mark. >>> rm = expressions.RehearsalMark('B') >>> rm N numberingc >[TU]"S0UD6 XlUS;a [S5eX lSUR lSUR lg)N) alphabeticalromannumberNz>> ex = expressions.RehearsalMark() >>> ex._getNumberingFromContent('C') 'alphabetical' >>> ex._getNumberingFromContent('VII') 'roman' >>> ex._getNumberingFromContent('X') 'roman' >>> ex._getNumberingFromContent('CI') 'roman' >>> ex._getNumberingFromContent('5') 'number' >>> ex._getNumberingFromContent(5) 'number' >>> print(ex._getNumberingFromContent('*')) None Nrkrj2ri) rintr[ ValueErrorr numberTools fromRomanlenstring ascii_letters)cunused romanValues r_getNumberingFromContent&RehearsalMark._getNumberingFromContents2 9 a  !S!! VF    ++55a8J1v{B%    $$ $!s' > A  A .B>B BBcURnU(dURUR5nU(dURcgURS-$US:XaU[[ URS5S-5nU[ R ;aS[UR5S--$U$US:Xa[UR5S-$US:Xa7[R"[R"UR5S-5$g) a? Return the next content based on the numbering >>> expressions.RehearsalMark('A').nextContent() 'B' >>> expressions.RehearsalMark('II').nextContent() 'III' >>> expressions.RehearsalMark('IV').nextContent() 'V' >>> expressions.RehearsalMark(7).nextContent() 8 >>> expressions.RehearsalMark('Z').nextContent() 'AA' With rehearsal mark 'I' default is to consider it as a roman numeral: >>> expressions.RehearsalMark('I').nextContent() 'II' Specify `numbering` directly to avoid problems: >>> expressions.RehearsalMark('I', numbering='alphabetical').nextContent() 'J' Nrwrir$Arkrj) rgrrnchrordr~rr}ryrtoRomanr|)rJrg nextContents rrRehearsalMark.nextContents>NN 55dllCI||#<>&"2"24<<"@1"DE E"rcF[UR5URS9$)a Return the next rehearsal mark. >>> rm = expressions.RehearsalMark('C') >>> rm.nextMark() >>> rm = expressions.RehearsalMark('IV', numbering='roman') >>> nm = rm.nextMark() >>> nm.content 'V' >>> nm.numbering 'roman' rf)rcrrgrPs rnextMarkRehearsalMark.nextMark5s T--/4>>JJr)rnrgrs)rZ str | None)r;r<r=r>r\classSortOrderrTextStylePlacementr^rGrQ staticmethodrrrr?r`ras@rrcrcsX N**K,$,,"55n2FhKKrrcc$\rSrSrSrSrSrSrSrg) PedalTypeiIsustain sostenutosoftsilentr9N) r;r<r=r>Sustain SostenutoSoftSilentr?r9rrrrIsGI D Frrc$\rSrSrSrSrSrSrSrg) PedalFormiOlinesymbol symbolalt symbolliner9N) r;r<r=r>LineSymbol SymbolAlt SymbolLiner?r9rrrrOs D FIJrrc4^\rSrSrSrSU4SjjrSrU=r$) PedalMarkiUa A pedal mark spanner contains a pedaled set of notes. The spanner starts at the moment of down-pedal, and ends at the moment of up-pedal. There can be any number of pedal "bounces" in the middle of the spanner. The visual form of the pedal mark can vary. The following examples use a pedal mark with one "bounce" in the middle:: Pedal marks can be lines: |_______^________| Pedal marks can be normal symbolic: Ped. * Ped. * Pedal marks can be altered symbolic: Ped. Ped. * Pedal marks can be symbol and line: Ped.____^________| Pedal marks, whether lines, symbols, or a combination, can represent the sustain pedal (Ped.), the sostenuto pedal (Sost.), the soft (una corda) pedal, or (more rarely) the silent (muting) pedal. Pedal marks that are symbolic can be abbreviated: e.g. P. instead of Ped., S. instead of Sost. Pedal marks that are lines can have non-printed portions (gaps) in them; these are usually started with "simile", but not necessarily. c>[TU]"U0UD6 SSKJn UR/UlSUlSUlSUlSUl g)NrrF) rFrGmusic21r GeneralNotefillElementTypes pedalType pedalForm abbreviated placement)rJspannedElementsrKrrLs rrGPedalMark.__init__psH /6X6 !%!1!1 2)-)-!&#'r)rrrrrrZNoner;r<r=r>r\rGr?r`ras@rrrUs4 (  ( (rrc:^\rSrSrSrSU4SjjrSSjrSrU=r$) PedalObjectizX Base class of individual objects that mark various transitions in a PedalMark spanner. c 4>[TU]"S0UD6 SUlgNr9)rFrGrrIs rrGPedalObject.__init__s $8$%)rc<URcgSUR3$)N uninsertedzat ) activeSiteoffsetrPs rrQPedalObject._reprInternals ?? "T[[M""r)rrrY) r;r<r=r>r\rGrQr?r`ras@rrrs*##rrc\rSrSrSrSrg) PedalBounceiz[ This object, when seen in a PedalMark spanner, represents an up/down bounce of the pedal. r9Nr;r<r=r>r\r?r9rrrrrrc\rSrSrSrSrg) PedalGapStartiz This object, when seen in a PedalMark spanner, represents a disappearance of the pedal line, usually with a TextExpression('simile'). The pedaling should continue (similarly to before), but the line is invisible during this gap. r9Nrr9rrrrsrrc\rSrSrSrSrg) PedalGapEndiz_ This object, when seen in a PedalMark spanner, represents the reappearance of the pedal line. r9Nrr9rrrrrrrc^\rSrSr%SrSr\RrSS0r S\ S'SU4Sjjr S r \ SS j5r\RSS j5r\ S 5r\RS 5rSrSrSrU=r$)TextExpressionia A TextExpression is a word, phrase, or similar bit of text that is positioned in a Stream or Measure. Conventional expressive indications are text like "agitato" or "con fuoco." >>> te = expressions.TextExpression('Con fuoco') >>> te.content 'Con fuoco' Most configuration of style is done on the `.style` :class:`~music21.style.TextStyle` object itself. >>> te.style.fontSize = 24.0 >>> te.style.fontSize 24 >>> te.style.fontStyle = 'italic' >>> te.style.fontWeight = 'bold' >>> te.style.letterSpacing = 0.5 rera Staff placement: 'above', 'below', or None. A setting of None implies that the placement will be determined by notation software and no particular placement is demanded. This is not placed in the `.style` property, since for some expressions, the placement above or below an object has semantic meaning and is not purely presentational. zdict[str, str] _DOC_ATTRc >[TU]"S0UD6 [U[5(d[U5UlOXlSUlgr)rFrGrr[_contentr)rJrnrKrLs rrGTextExpression.__init__s; $8$'3''LDM#Mrc[UR5S:aURSSS-n[U5$URb[UR5$g)N z...rO)r}rrt)rJ shortContents rrQTextExpression._reprInternalsO t}}  #=="-5L % % ]] & & &rcRUR(dgURR$)a Returns or sets the enclosure on the Style object stored on .style. Exposed directly on the expression for backwards compatibility. Does not create a .style object if one does not exist and the value is None. >>> te = expressions.TextExpression('Bridge') >>> te.enclosure is None True >>> te.enclosure = style.Enclosure.RECTANGLE >>> te.enclosure Note that this is also set on `.style`. >>> te.style.enclosure NhasStyleInformationr enclosurerPs rrTextExpression.enclosures ,''zz###rcNUR(dUcgXRlgrsrrJvalues rrrs''EM $ rcUR$)z Get or set the content. >>> te = expressions.TextExpression('dolce') >>> te.content 'dolce' >>> te.content = 'sweeter' >>> te )rrPs rrnTextExpression.contents}}rc$[U5Ulgrs)r[rrs rrnrs E  rcSSKJn URHbnURUR5(dM%[ R "U5nUR[ R "U55 Us $ g)z If this TextExpression can be a RepeatExpression, return a new :class:`~music21.repeat.RepeatExpression`. object, otherwise, return None. r)repeatN)rrrepeatExpressionReference isValidTextrcopydeepcopysetTextExpression)rJrobjres rgetRepeatExpression"TextExpression.getRepeatExpressions[ #33Ct}}--]]3'$$T]]4%89 4rcgrsr9rPs r getTempoTextTextExpression.getTempoText0s r)rrrs)rZstyle.Enclosure | None)rr)r;r<r=r>r\rrr]r^r__annotations__rGrQr_rsetterrnrrr?r`ras@rrrs.N//K   !I~  $$2%%    ^^##*  rrc ^\rSrSrSrSU4SjjrSSS.SSjjrSS.SS jjrSS .SS jjr\ SS j5r SSSSS SSS S.SSjjr Sr U=r $)Ornamenti7a) An Ornament is a type of Expression that, when attached to a Note (in the future: Notes) can transform into the main note. All ornaments have an `.autoScale` boolean which determines whether to shrink (not currently to expand) the ornament if the note it is attached to is too short to realize. c P>[TU]"S0UD6 SUlSUlSUlg)NTr9)rFrGconnectedToPrevious autoScale_ornamentalPitchesrIs rrGOrnament.__init__@s* $8$#' ;=rNFr inPlacecFU(d[R"U5n/U/4$)a| subclassable method call that takes a sourceObject and optional keySig and returns a three-element tuple of a list of notes before the "main note" or the result of the expression if it gobbles up the entire note, the "main note" itself (or None) to keep processing for ornaments, and a list of notes after the "main note". * New in v8: inPlace boolean; note that some ornaments might not return a Note in the second position at all (such as trills) so inPlace does nothing. * Changed in v9: Optional keySig can be passed in (useful in cases where there is no keySig in srcObj's context, or where a different keySig is desired). )rr)rJr*r rs rr%Ornament.realizeGs",]]6*FFBruseQLc[U5(+nU(a([US5(d[S[U535eUc URn[ R "U5nXFRl[ R "U5nXGRlU(aF[R(a![U[R5(deURUSS9 URU5 URU5 g)z< Used by trills and mordents to fill out their realization. transposezExpected note; got NTr)rr( TypeErrortype quarterLengthrrdurationr&r'rrNoterr))rJr* fillObjectstransposeIntervalr isTransposed firstNote secondNotes rfillListOfRealizedNotes Ornament.fillListOfRealizedNotesbs"**;!<<  < <1$v,@A A =&&EMM&) ,1(]]6* ,1) !*dii8888  !2D A9%:&rrcg6 Only implemented in Turn, GeneralMordent, and Trill. Nr9rJr*r s rresolveOrnamentalPitches!Ornament.resolveOrnamentalPitchess rc[5$)r)tuplerPs rornamentalPitchesOrnament.ornamentalPitchess wrT pitchPastpitchPastMeasureotherSimultaneousPitchesalteredPitchescautionaryPitchClass cautionaryAlloverrideStatuscautionaryNotImmediateRepeatcgr r9) rJrrrrrrrrs rupdateAccidentalDisplay Ornament.updateAccidentalDisplays r)rrrrr*note.Note | note.Unpitchedr key.KeySignature | NonerboolrZzltuple[list[note.Note | note.Unpitched], note.Note | note.Unpitched | None, list[note.Note | note.Unpitched]]) r*r#rz list[note.Note | note.Unpitched]rinterval.IntervalBaserzOffsetQL | NonerZrr*note.GeneralNoter r$rZztuple[pitch.Pitch, ...])rlist[pitch.Pitch] | Nonerr*rr*rr*rr%rr%rr%rr%rZr)r;r<r=r>r\rGr%r rr_rr r?r`ras@rrr7s*>)-  ( &     0  B $ !'(!'4!'1 !'  !' !'N)-   & -137;?15%)#$-1*1  #9  / #'+ rrc n^\rSrSr%SrSrS\S'SS.SU4Sjjjr\SU4S jj5r \SS j5r \ RSS j5r \SS j5r SS .SSjjr SS .SSjjr\SSj5r\S Sj5rSSSSSSSSS.S!SjjrSSS.S"SjjrSrU=r$)#GeneralMordentiz# Base class for all Mordent types. rOr[ _directionN accidentalc N>[TU]"S0UD6 XlSUlSUlg)N?abover9)rFrG _accidentalrrrJr/rKrLs rrGGeneralMordent.__init__s( $8$2<" rct>[TU]nURbUSURR-S-- nU$)a returns the name of the Mordent/InvertedMordent, which is generally the class name lowercased, with spaces where a new capital occurs. The name also will include any accidental, if it exists. Subclasses can override this as necessary. >>> mordent = expressions.Mordent() >>> mordent.name 'mordent' >>> sharp = pitch.Accidental('sharp') >>> invertedMordent = expressions.InvertedMordent(accidental=sharp) >>> invertedMordent.name 'inverted mordent (sharp)'  ()rFrr/rJtheNamerLs rrGeneralMordent.names;&w| ?? & tdoo222S8 8GrcUR$)z* This is the GeneralMordent's accidental. r3rPs rr/GeneralMordent.accidentals rcXlgrsr>rJ newAccidentals rr/r?(rcUR$)z\ The direction of the mordent's ornamental pitch from the main note. Can be 'up' or 'down'. r-rPs r directionGeneralMordent.direction rrcURS;a [S5eUR(d[R"S5$U=(d< UR [ R5=(d [ R"S5nURSn[R"U5nSUl URcURUl URS:Xa%UR[R"S5S S 9 O$UR[R"S 5S S 9 UR(aURUl O URUR 5Ul [R"X45$) a Returns the size of the mordent's interval, given a source note and an optional key signature. If the key signature is not specified, the source note's context is searched for the current key signature, and if there is no such key signature, a key signature with no sharps and no flats will be used. Any `accidental` that has been set on the mordent will also be taken into account. If no `accidental` has been set, the appropriate accidental from the key signature will be used. If keySig is specified, this can be considered to be a theoretical question: "If this particular mordent were to be attached to this note, in this key, what would the size of the mordent interval be?" updownz:Cannot compute mordent size if I do not know its directionrrrNrKrwTrr-r7pitchesr rgetContextByClassr KeySignaturerrr/octaveimplicitOctaverGenericIntervalaccidentalByStepsteprJr*r srcPitchornamentalPitchs rgetSizeGeneralMordent.getSizes'& ??. 0%&bc c~~$$T* *\633C4D4DE\IYIYZ[I\ &r 2'+}}X'>%)"  ! ! )%4%C%CO " ??d "  % %h&>&>q&A4 % P  % %h&>&>r&BD % Q ??)-O &*0)@)@AUAU)VO &  ;;rcUR(dgURSnURXS9n[R"U5nURcUR UlUR USS9 URRS:waURSS9 URbMURc[R"S5Ul URRURl U4Ulg)a  Computes and stores the ornamental pitch for a GeneralMordent, given the srcObj (can be any kind of ornamented GeneralNote) and an optional keySig. If keySig is None, srcNote's context will be searched for a key signature. If no key signature is found, a key signature with no sharps and no flats will be used. A mordent on a G in a key with no sharps or flats (ornamental pitch will be F). >>> noSharpsOrFlats = key.KeySignature(sharps=0) >>> n1 = note.Note('G4') >>> mordent = expressions.Mordent() >>> mordent.resolveOrnamentalPitches(n1, keySig=noSharpsOrFlats) >>> mordent.ornamentalPitches (,) >>> mordent.ornamentalPitch e.g. A mordent on a G in a key with one sharp (ornamental pitch will be F#). >>> oneSharp = key.KeySignature(sharps=1) >>> mordent.resolveOrnamentalPitches(n1, keySig=oneSharp) >>> mordent.ornamentalPitches (,) >>> mordent.ornamentalPitch e.g. A mordent with a natural, on a G, in a key with one sharp (ornamental pitch will be F). >>> mordent.accidental = pitch.Accidental('natural') >>> mordent.resolveOrnamentalPitches(n1, keySig=oneSharp) >>> mordent.ornamentalPitches (,) >>> mordent.ornamentalPitch NrrTrrrOrZrrrRrSr microtonecentsconvertMicrotonesToQuarterTonesr/r Accidental displayStatusrrJr*r rXrrYs rr'GeneralMordent.resolveOrnamentalPitchessZ~~  &r 237<<<3V'+}}X'>  ! ! )%4%C%CO "!!"3T!B  $ $ * *a /  ; ;D ; I ?? & ))1-2-=-=a-@*7;7T7TO & & 4#2"4rcDUR(aURS$g)zp Returns the mordent's ornamentalPitch. If resolveOrnamentalPitches has not yet been called, None is returned. rNrrPs rrYGeneralMordent.ornamentalPitchX!  " "**1- -rcUR$z Returns any ornamental pitch that has been resolved (see `resolveOrnamentalPitches`, which must be called first, or an empty tuple will be returned). rfrPs rr GeneralMordent.ornamentalPitchesb&&&rTFrc 4URn U cgURbeURRbNU Rc[R"S5U lURRU RlgU R UUUUUUUSS9 g)a? Updates accidental display for a GeneralMordent's ornamental pitch. Defined exactly like Pitch.updateAccidentalDisplay, with two changes: Instead of self being the pitch to update, self is a GeneralMordent whose ornamentalPitch is to be updated; and we pay no attention to ties, since ornamental notes cannot be tied. NrFrrrrrrrlastNoteWasTied)rYr/rbr rar  rJrrrrrrrrps rr &GeneralMordent.updateAccidentalDisplayks&   9  ?? &4??+H+H+T||#$//2 )-)F)FALL &  !!-)!5'))E! " #rrcURS;a [S5eURRS:Xa [S5eURnURRURS-::a5UR(d [S5eURRS- nUnUc8UR [ R5nUc[ R"S5nURRSU-- nURXS9n/nURXXtS 9 [U5(+n U (a[U5Hup[R(a![U [R 5(deU S -n U R"R$bMYU S:XdMaUR'U R"R(5U R"lM S n XR*;aUR*R-U5n U(d[.R0"U5OUnXnRlU S :waUR*R3U 5 X/4$) a Realize a mordent. returns a three-element tuple. The first is a list of the two notes that the beginning of the note were converted to. The second is the rest of the note. The third is an empty list (since there are no notes at the end of a mordent). >>> n1 = note.Note('C4') >>> n1.quarterLength = 0.5 >>> m1 = expressions.Mordent() >>> m1.realize(n1) ([, ], , []) Note: use one of the subclasses, not the GeneralMordent class >>> n2 = note.Note('C4') >>> n2.quarterLength = 0.125 >>> m2 = expressions.GeneralMordent() >>> m2.realize(n2) Traceback (most recent call last): music21.expressions.ExpressionException: Cannot realize a mordent if I do not know its direction rJz7Cannot realize a mordent if I do not know its directionr1Cannot steal time from an object with no durationrwz0The note is not long enough to realize a mordentrrr$r)r-r7rrrrPr rQrZr r enumerater&r'rrrr r/rUrVr"indexrrpop)rJr*r ruse_ql currentKeySig remainderQLr mordNotesrnoteIdxnnoteNum inExpressions remainderNotes rr%GeneralMordent.realizesB ??. 0%&_` ` ?? ( (A -%&YZ Z## ?? ( (D,>,>,B B>>)*\]]__22Q6F/5  "44S5E5EFM$ # 0 0 3 oo33q6zB  LLLF46  $$V8I$X!)*;!<< ( 2 ??%a3333&{77%%-'Q,)6)G)G )UAGG& 3 %% %"..44T:M5< f-& /:, B   % % ) )- 8"--r)r3rrr)r/pitch.Accidental | NonerYrZrrBrr*r(r r$rZr&r'rZzpitch.Pitch | Noner)rr*rr*rr*rr*rr%rr%rr%rr%r")r;r<r=r>r\r-rrGr_rr/rrFrZrrYrr r%r?r`ras@rr,r,sJ>B!! .  )))- /< /<& /<  />> m = expressions.Mordent() >>> m.direction 'down' >>> m.getSize(note.Note('C4')) >>> m.getSize(note.Note('B3')) e.g. Mordent with flat, in default key (no flats or sharps) >>> mFlat = expressions.Mordent(accidental=pitch.Accidental('flat')) >>> mFlat.direction 'down' >>> mFlat.getSize(note.Note('C4')) >>> mFlat.getSize(note.Note('B3')) e.g. Mordent without accidentals, in key with one flat >>> oneFlat = key.KeySignature(-1) >>> mNotFlat = expressions.Mordent() >>> mNotFlat.direction 'down' >>> mNotFlat.getSize(note.Note('C4'), keySig=oneFlat) >>> mNotFlat.getSize(note.Note('B3'), keySig=oneFlat) e.g. Mordent without accidentals, with a key from context with one flat (same results) >>> noteC4 = note.Note('C4') >>> noteB3 = note.Note('B3') >>> measure = stream.Measure([oneFlat, noteC4, noteB3]) >>> mNotFlatWithKeyFromContext = expressions.Mordent() >>> mNotFlatWithKeyFromContext.direction 'down' >>> mNotFlatWithKeyFromContext.getSize(noteC4) >>> mNotFlatWithKeyFromContext.getSize(noteB3) * Changed in v7: Mordent sizes are GenericIntervals -- as was originally intended but programmed incorrectly. * Changed in v9: Support an accidental on Mordent. This also adds the concept of an ornamental pitch that is processed by makeAccidentals. The size property has been removed and replaced with `.getSize()` (which requires a `srcObj` and optional `keySig` param). Added optional `keySig` param to `.realize()` as well. rLr[r-r9Nr;r<r=r>r\r-rr?r9rrrrsCHJrrc^\rSrSrSrS U4SjjrSS.S Sjjr\S Sj5r\RS Sj5rS r U=r $)HalfStepMordenti+z A half step normal Mordent. >>> m = expressions.HalfStepMordent() >>> m.direction 'down' >>> m.getSize(note.Note('C4')) c ~>SU;a [S5e[TU]"S0UD6 [R"S5Ulg)Nr/z1Cannot initialize HalfStepMordent with accidentalzm-2r9)r7rFrGr r_minorSecondDownrIs rrGHalfStepMordent.__init__5s: 8 #%&YZ Z $8$7?7H7H7OrNrcUR$rsrrs rrZHalfStepMordent.getSize< $$$rcgrsr9rPs rr/HalfStepMordent.accidentalDrc[S5e)Nz(Cannot set accidental of HalfStepMordentr7rAs rr/rHs!"LMMrrrrrr r;r<r=r>r\rGrZr_r/rr?r`ras@rrr+sdP)- % %& %  %NNrrc^\rSrSrSrS U4SjjrSS.S Sjjr\S Sj5r\RS Sj5rS r U=r $)WholeStepMordentiMz A whole step normal Mordent. >>> m = expressions.WholeStepMordent() >>> m.direction 'down' >>> m.getSize(note.Note('C4')) c ~>SU;a [S5e[TU]"S0UD6 [R"S5Ulg)Nr/z2Cannot initialize WholeStepMordent with accidentalzM-2r9)r7rFrGr r_majorSecondDownrIs rrGWholeStepMordent.__init__Ws: 8 #%&Z[ [ $8$7?7H7H7OrNrcUR$rsrrs rrZWholeStepMordent.getSize^rrcgrsr9rPs rr/WholeStepMordent.accidentalfrrc[S5e)Nz)Cannot set accidental of WholeStepMordentrrAs rr/rjs!"MNNrrrrrrrras@rrrMsdP)- % %& %  %OOrrc(\rSrSr%SrSrS\S'Srg)InvertedMordentipa An inverted Mordent -- goes upwards and has no line through it. Note that some computer terminology calls this one a (normal) mordent, but this is a modern term. See Apel, *Harvard Dictionary of Music*, "Inverted Mordent":: An 18th-century ornament involving alternation of the written note with the note immediately above it. An inverted mordent has the size of a second, of some form, depending on the note that will have the mordent, the current key signature in that note's context, as well as any accidental on the mordent itself. >>> m = expressions.InvertedMordent() >>> m.direction 'up' >>> m.getSize(note.Note('C4')) >>> m.getSize(note.Note('B3')) >>> mSharp = expressions.InvertedMordent(accidental=pitch.Accidental('sharp')) >>> mSharp.direction 'up' >>> mSharp.getSize(note.Note('C4')) >>> mSharp.getSize(note.Note('B3')) * Changed in v7: InvertedMordent sizes are GenericIntervals -- as was originally intended but programmed incorrectly. * Changed in v9: Support an accidental on InvertedMordent. This also adds the concept of an ornamental pitch that is processed by makeAccidentals. The size property has been removed and replaced with `.getSize()` (which requires a `srcObj` and optional `keySig` param). Added optional `keySig` param to `.realize()` as well. rKr[r-r9Nrr9rrrrps%LJrrc^\rSrSrSrS U4SjjrSS.S Sjjr\S Sj5r\RS Sj5rS r U=r $)HalfStepInvertedMordentiz A half-step inverted Mordent. >>> m = expressions.HalfStepInvertedMordent() >>> m.direction 'up' >>> m.getSize(note.Note('C4')) c ~>SU;a [S5e[TU]"S0UD6 [R"S5Ulg)Nr/z9Cannot initialize HalfStepInvertedMordent with accidentalm2r9)r7rFrGr r_minorSecondUprIs rrG HalfStepInvertedMordent.__init__s@ 8 #%KM M $8$5=5F5Ft5LrNrcUR$rsrrs rrZHalfStepInvertedMordent.getSize """rcgrsr9rPs rr/"HalfStepInvertedMordent.accidentalrrc[S5e)Nz0Cannot set accidental of HalfStepInvertedMordentrrAs rr/rs!"TUUrrrrrrrras@rrrsdM)- # #& #  #VVrrc^\rSrSrSrS U4SjjrSS.S Sjjr\S Sj5r\RS Sj5rS r U=r $)WholeStepInvertedMordentiz A whole-step inverted Mordent. >>> m = expressions.WholeStepInvertedMordent() >>> m.direction 'up' >>> m.getSize(note.Note('C4')) c ~>SU;a [S5e[TU]"S0UD6 [R"S5Ulg)Nr/z:Cannot initialize WholeStepInvertedMordent with accidentalM2r9)r7rFrGr r_majorSecondUprIs rrG!WholeStepInvertedMordent.__init__s@ 8 #%LN N $8$5=5F5Ft5LrNrcUR$rsrrs rrZ WholeStepInvertedMordent.getSizerrcgrsr9rPs rr/#WholeStepInvertedMordent.accidentalrrc[S5e)Nz1Cannot set accidental of WholeStepInvertedMordentrrAs rr/rs!"UVVrrrrrrrras@rrrsdM)- # #& #  #WWrrc t^\rSrSr%SrSrS\S'SS.SU4Sjjjr\SU4S jj5r \SS j5r \SS j5r \ RSS j5r S r SS.SSjjrSS.SSjjr\S Sj5r\S!Sj5rSSSSSSSSS.S"SjjrSSS.S#SjjrSrU=r$)$Trillia A basic trill marker without the trill extension >>> tr = expressions.Trill() >>> tr.placement 'above' >>> tr.getSize(note.Note('C4')) >>> tr.getSize(note.Note('B4')) Trills have a `.nachschlag` attribute which determines whether there should be extra gracenotes at the end of the trill. >>> tr.nachschlag False >>> tr.nachschlag = True The Trill also has a "quarterLength" attribute that sets how long each trill note should be. Defaults to 32nd note: >>> tr.quarterLength 0.125 >>> tr.quarterLength == duration.Duration('32nd').quarterLength True * Changed in v7: the size should be a generic second. * Changed in v9: Support an accidental on trills. This also adds the concept of an ornamental pitch that is processed by makeAccidentals. The size property has been removed and replaced with `.getSize()` (which requires a `srcObj` and optional `keySig` param). Added optional `keySig` param to `.realize()` as well. rKr[r-Nr.c x>[TU]"S0UD6 XlSUlSUlSUlSUlSUlg)Nr2Fallr1Tr9)rFrGr3r nachschlagrHr_setAccidentalFromKeySigr4s rrGTrill.__init__s> $8$2< "(,%rc|>[TU]nUR(aUSURR-S-- nU$)a returns the name of the Trill, which is generally the class name lowercased, with spaces where a new capital occurs. The name also will include the accidental, if it exists. Subclasses can override this as necessary. >>> trill = expressions.Trill() >>> trill.name 'trill' >>> doubleSharpedTrill = expressions.Trill(accidental=pitch.Accidental('double-sharp')) >>> doubleSharpedTrill.name 'trill (double-sharp)' r7r8r9r:s rr Trill.names8$w| ?? tdoo222S8 8GrcUR$)zZ The direction of the trill's ornamental pitch from the main note. Can be 'up' or 'down'. rErPs rrFTrill.direction&rHrcUR$)zn This is the Trill's accidental. Whether or not it is visible is dictated by the accidental's displayStatus. r>rPs rr/Trill.accidental.s rcXlgrsr>rAs rr/r6rCrc/nU(aUSRRU5 [U5S:a5USRS5(d[ U5nURU5 U$)a splitClient is called by base.splitAtQuarterLength() to support splitting trills. >>> n = note.Note(type='whole') >>> n.expressions.append(expressions.Trill()) >>> st = n.splitAtQuarterLength(3.0) >>> n1, n2 = st >>> st.spannerList [>] >>> n1.getSpannerSites() [>] rr$TrillExtension)r"r)r}getSpannerSitesr)rJnoteListreturnSpannerstes r splitClientTrill.splitClient:sc  QK # # * *4 0 x=1 Xa[%@%@AQ%R%R)B  ! !" %rrcURS;a [S5eUR(d[R"S5$U=(d< UR [ R5=(d [ R"S5nURSn[R"U5nSUl URcURUl URS:Xa%UR[R"S5S S 9 O$UR[R"S 5S S 9 UR(aURUl O URUR 5Ul [R"X45$) aD Returns the size of the trill's interval, given a source note and an optional key signature. If the key signature is not specified, the source note's context is searched for the current key signature, and if there is no such key signature, a key signature with no sharps and no flats will be used. Any `accidental` that has been set on the trill will also be taken into account. If keySig is specified, this can be considered to be a theoretical question: "If this particular trill were to be attached to this note, in this key, what would the size of the trill interval be?" rJz8Cannot compute trill size if I do not know its directionrrrNrKrwTrrMrNrWs rrZ Trill.getSizePs'$ ??. 0%&`a a~~$$T* *\633C4D4DE\IYIYZ[I\ &r 2'+}}X'>%)"  ! ! )%4%C%CO " ??d "  % %h&>&>q&A4 % P  % %h&>&>r&BD % Q ??)-O &*0)@)@AUAU)VO &  ;;rcUR(dgURSnURXS9n[R"U5nURcUR UlUR USS9 URRS:waURSS9 URbMURc[R"S5Ul URRURl U4Ulg)a Computes and stores the ornamental pitch for a Trill, given the srcObj (can be any kind of ornamented GeneralNote) and an optional keySig. If keySig is None, srcNote's context will be searched for a key signature. If no key signature is found, a key signature with no sharps and no flats will be used. e.g. A trill on a D in a key with no sharps or flats (ornamental pitch will be E). >>> noSharpsOrFlats = key.KeySignature(0) >>> n2 = note.Note('D4') >>> trill = expressions.Trill() >>> trill.resolveOrnamentalPitches(n2, keySig=noSharpsOrFlats) >>> trill.ornamentalPitches (,) >>> trill.ornamentalPitch NrrTrrr]rcs rrTrill.resolveOrnamentalPitchess2~~  &r 237<<<3V'+}}X'>  ! ! )%4%C%CO "!!"3T!B  $ $ * *a /  ; ;D ; I ?? & ))1-2-=-=a-@*7;7T7TO & & 4#2"4rcDUR(aURS$g)zn Returns the trill's ornamentalPitch. If resolveOrnamentalPitches has not yet been called, None is returned. rNrfrPs rrYTrill.ornamentalPitchrhrcUR$rjrfrPs rrTrill.ornamentalPitchesrlrTFrc URn U cgUR(aNU Rc[R"S5U lURRU RlgU R UUUUUUUSS9 g)a Updates accidental display for a Trill's ornamental pitch. Defined exactly like Pitch.updateAccidentalDisplay, with two changes: Instead of self being the pitch to update, self is an Trill whose ornamentalPitch is to be updated; and we pay no attention to ties, since ornamental notes cannot be tied. These examples show a Trill whose main note is a G in a key with no sharps or flats, so the trill's ornamental pitch is an A. We show various situations where the A might or might not end up with a natural accidental. If updateAccidentalDisplay is called with cautionaryAll, the A gets a (cautionary) natural accidental. >>> noSharpsOrFlats = key.KeySignature(0) >>> trill1 = expressions.Trill() >>> trill1.resolveOrnamentalPitches(note.Note('g4'), keySig=noSharpsOrFlats) >>> trill1.ornamentalPitch >>> trill1.ornamentalPitch.accidental is None True >>> past = [pitch.Pitch('a#4'), pitch.Pitch('c#4'), pitch.Pitch('c4')] >>> trill1.updateAccidentalDisplay(pitchPast=past, cautionaryAll=True) >>> trill1.ornamentalPitch.accidental, trill1.ornamentalPitch.accidental.displayStatus (, True) If updateAccidentalDisplay is called without cautionaryAll, the A gets a natural accidental, because a previous A had a sharp accidental. >>> trill2 = expressions.Trill() >>> trill2.resolveOrnamentalPitches(note.Note('g4'), keySig=noSharpsOrFlats) >>> trill2.ornamentalPitch >>> trill2.ornamentalPitch.accidental is None True >>> past = [pitch.Pitch('a#4'), pitch.Pitch('c#4'), pitch.Pitch('c4')] >>> trill2.updateAccidentalDisplay(pitchPast=past) # should add a natural >>> trill2.ornamentalPitch.accidental, trill2.ornamentalPitch.accidental.displayStatus (, True) If updateAccidentalDisplay is called with cautionaryPitchClass=False, the A does not get a natural accidental because the previous A# was in a different octave. >>> trill3 = expressions.Trill() >>> trill3.resolveOrnamentalPitches(note.Note('g4'), keySig=noSharpsOrFlats) >>> trill3.ornamentalPitch >>> trill3.ornamentalPitch.accidental is None True >>> past = [pitch.Pitch('a#3'), pitch.Pitch('c#'), pitch.Pitch('c')] >>> trill3.updateAccidentalDisplay(pitchPast=past, cautionaryPitchClass=False) >>> trill3.ornamentalPitch.accidental is None True If we add a natural accidental to the trill (with displayStatus True), and then updateAccidentalDisplay is called with cautionaryPitchClass=False, the A gets a visible natural accidental because of that added natural accidental. >>> trill4 = expressions.Trill() >>> natural = pitch.Accidental('natural') >>> natural.displayStatus = True >>> trill4.accidental = natural >>> trill4.resolveOrnamentalPitches(note.Note('g4'), keySig=noSharpsOrFlats) >>> trill4.ornamentalPitch >>> trill4.ornamentalPitch.accidental >>> trill4.ornamentalPitch.accidental.displayStatus True >>> past = [pitch.Pitch('a#3'), pitch.Pitch('c#'), pitch.Pitch('c')] >>> trill4.updateAccidentalDisplay(pitchPast=past, cautionaryPitchClass=False) >>> trill4.ornamentalPitch.accidental >>> trill4.ornamentalPitch.accidental.displayStatus True NrFrn)rYr/r rarbr rps rr Trill.updateAccidentalDisplaysp   9  ??||#$//2 )-)F)FALL &  !!-)!5'))E! " #rrcXURnURRS:Xa [S5eURRSU-:a5UR(d [S5eURRS- nURRSUR-:aFUR(a5UR(d [S5eURRS- nUnUc8UR [ R5nUc[ R"S5nURXS9nUR5n[U5(+n[URRU- 5n UR(aU S-n /n [[U S- 55Hn URXXdS 9 M U(aURn U (aU Hn [R (aB[#U [$R&5(de[#U[$R&5(deU R(R*UR(R*:wdMU R(R,bMUR/U R05U R(lM U(a*XR2;aUR2R5U5 UR(Ga2[6R8"U5n/UlXNRl[6R8"U5n/UlXORlU(a[R (aB[#U[$R&5(de[#U[$R&5(deUR;US S 9 W (a[U(aTUR/UR05UR(lUR/UR05UR(lX/nU SU4$U S/4$) a realize a trill. Returns a three-element tuple: * The first is a list of the notes that the note was converted to. * The second is None because the trill "eats up" the whole note. * The third is a list of the notes at the end if nachschlag is True, and empty list if False. >>> n1 = note.Note('C4') >>> n1.duration.type = 'eighth' >>> t1 = expressions.Trill() >>> n1.expressions.append(t1) >>> realization = t1.realize(n1) >>> realization ([, , , ], None, []) >>> realization[0][0].quarterLength 0.125 >>> realization[0][0].pitch.octave 4 When inside a stream, the realizations will consult the current key to see if it should be a whole-step or half-step trill: >>> m = stream.Measure() >>> k1 = key.Key('D-') >>> m.insert(0, k1) >>> m.append(n1) >>> t1.realize(n1) ([, , , ], None, []) Note that if the key contradicts the note of the trill, for instance, here having a C-natural rather than a C-sharp, we do not correct the C to C#. >>> k2 = key.Key('A') >>> m.replace(k1, k2) >>> t1.realize(n1) ([, , , ], None, []) This can lead to certain unusual circumstances such as augmented second trills which are technically correct, but probably not what a performer exprects. >>> k3 = key.Key('E') >>> m.replace(k2, k3) >>> t1.realize(n1) ([, , , ], None, []) To avoid this case, create a :class:`~music21.expressions.HalfStepTrill` or :class:`~music21.expressions.WholeStepTrill`. If there is a nachschlag, it will appear in the third element of the list. >>> n1.duration.type = 'quarter' >>> m.replace(k3, k1) # back to D-flat major >>> t1.nachschlag = True >>> t1.realize(n1) ([, , , , , ], None, [, ]) Some notes can be too short to realize if autoscale is off. >>> n2 = note.Note('D4') >>> n2.duration.type = '32nd' >>> t2 = expressions.Trill() >>> t2.autoScale = False >>> t2.realize(n2) Traceback (most recent call last): music21.expressions.ExpressionException: The note is not long enough to realize a trill A quicker trill makes it possible: >>> t2.quarterLength = duration.Duration('64th').quarterLength >>> t2.realize(n2) ([, ], None, []) inPlace is not used for Trills. rrtrwz.The note is not long enough to realize a trillruz,The note is not long enough for a nachschlagNrrTr)rrr7rrrPr rQrZreverserryranger rr&r'rrrr nameWithOctaver/rUrVr"removerrr)rJr*r rrrzrtransposeIntervalReversernumberOfTrillNotes trillNotesunused_countersetAccidentalFromKeySigr~firstNoteNachschlagsecondNoteNachschlagrs rr% Trill.realize2sRR"" ?? ( (A -%&YZ Z ?? ( (1u9 4>>)*Z[[OO11A5E ?? ( (1t/A/A+A Adoo>>)*XYYOO11A5E  "44S5E5EFM$ # 0 0 3  LLLF#4#<#<#> !)*;!<<  !>!>!FG ?? ! # 57 #C(:Q(>$?@N  ( (=N ( \A &*&C&C #&#A)!TYY7777)&$))<<<<ww--1L1LL77--5!. > >qvv FGG.$ t111    % %d + ???"&--"7 .0  +9> ( ( 6#'==#8 /1 ,:? ) ) 7??%&:DIIFFFF%&9499EEEE$../G8</>*};H;Y;Y+00<2'--8r\r-rrGr_rrFr/rrrZrrYrr r%r?r`ras@rrrs!DJ>B--,  ))4)- .< .<& .<  .r-rr?r9rrrrs Jrrc^\rSrSrSrS U4SjjrSS.S Sjjr\S Sj5r\RS Sj5rS r U=r $) HalfStepTrillia A trill confined to half steps. >>> halfTrill = expressions.HalfStepTrill() >>> halfTrill.placement 'above' >>> halfTrill.getSize(note.Note('C4')) Here the key signature of 2 sharps will not affect the trill: >>> n = note.Note('B4', type='eighth') >>> m = stream.Measure() >>> m.insert(0, key.KeySignature(2)) >>> m.append(n) >>> halfTrill.realize(n) ([, , , ], None, []) c >SU;a [S5e[TU]"S0UD6 [R"S5UlSUlg)Nr/z/Cannot initialize HalfStepTrill with accidentalrFr9)r7rFrGr rrrrIs rrGHalfStepTrill.__init__sH 8 #%AC C $8$5=5F5Ft5L(-%rNrcUR$rsrrs rrZHalfStepTrill.getSize rrcgrsr9rPs rr/HalfStepTrill.accidentalrrc[S5e)Nz&Cannot set accidental of HalfStepTrillrrAs rr/rs!"JKKr)rrrrrrrras@rrrsc*.)- # #& #  #LLrrc^\rSrSrSrS U4SjjrSS.S Sjjr\S Sj5r\RS Sj5rS r U=r $)WholeStepTrillia  A trill that yields whole steps no matter what. >>> wholeTrill = expressions.WholeStepTrill() >>> wholeTrill.placement 'above' >>> wholeTrill.getSize(note.Note('C4')) Here the key signature of one sharp will not affect the trill: >>> n = note.Note('B4', type='eighth') >>> m = stream.Measure() >>> m.insert(0, key.KeySignature(1)) >>> m.append(n) >>> wholeTrill.realize(n) ([, , , ], None, []) c >SU;a [S5e[TU]"S0UD6 [R"S5UlSUlg)Nr/z0Cannot initialize WholeStepTrill with accidentalrFr9)r7rFrGr rrrrIs rrGWholeStepTrill.__init__1sH 8 #%BD D $8$5=5F5Ft5L(-%rNrcUR$rsrrs rrZWholeStepTrill.getSize:rrcgrsr9rPs rr/WholeStepTrill.accidentalBrrc[S5e)Nz'Cannot set accidental of WholeStepTrillrrAs rr/rFs!"KLLr)rrrrrrrras@rrrsc*.)- # #& #  #MMrrc,^\rSrSrSrU4SjrSrU=r$)ShakeiKzO A slower trill. >>> shake = expressions.Shake() >>> shake.quarterLength 0.25 c 4>[TU]"S0UD6 SUlg)N?r9)rFrGrrIs rrGShake.__init__Ss $8$!r)rrras@rrrKs""rrc,^\rSrSrSrU4SjrSrU=r$) Schleiferi\zd A slide or culee * Changed in v7: size is a Generic second. removed unused nachschlag component. c j>[TU]"S0UD6 [R"S5UlSUlg)Nrwrr9)rFrGr rTsizerrIs rrGSchleifer.__init__bs- $8$,,Q/ !r)rr rras@rrr\s ""rrc  ^\rSrSr%SrSrS\S'\RSSS.SU4Sjjjr \ SS j5r \ RSS j5r \ SS j5r \ RS S j5r \ S!S j5r\RS"Sj5r\ S#Sj5r\ S$U4Sjj5rSS.S%SjjrSS.S&Sjjr\ S'Sj5r\ S'Sj5r\ S(Sj5rSSSSSSSSS.S)SjjrSSS.S*SjjrSrU=r$)+Turniia$ A turn or Gruppetto. * Changed in v7: size is a Generic second. removed unused nachschlag component. * Changed in v9: Added support for delayed vs non-delayed Turn. * Changed in v9: Support upper and lower accidentals on turns. This also adds the concept of ornamental pitches that are processed by makeAccidentals. The size property has been removed and replaced with `.getSize()` (which requires a `srcObj` and optional `keySig` param, as well as which='upper' or which='lower'). Added optional `keySig` param to `.realize()` as well. Fr% _isInvertedN)delayupperAccidentallowerAccidentalc >[TU]"S0UD6 X lX0lSUlSUlSUlSUlXlg)Nr2rrr9) rFrG_upperAccidental_lowerAccidentalrrHr_delayr)rJrrrrKrLs rrG Turn.__init__wsC $8$7F7F%#'+.1  rcUR$)zv This is the Turn's upperAccidental. Whether or not it is visible is dictated by the upperAccidental's displayStatus. rrPs rrTurn.upperAccidentalrrcXlgrsr)rJnewUpperAccidentals rrr 2rcUR$)zv This is the Turn's lowerAccidental. Whether or not it is visible is dictated by the upperAccidental's displayStatus. rrPs rrTurn.lowerAccidentalrrcXlgrsr)rJnewLowerAccidentals rrr rrcUR$)z If delay is NO_DELAY, the turn is not delayed. If delay is anything else (an OffsetQL or DEFAULT_DELAY), the turn is delayed. Note that if you set delay to OffsetQL(0), and then get the delay, you will get NO_DELAY, not 0. )rrPs rr Turn.delays{{rcr[U[[45(aUS::a[RnXlg)Nr)rfloatrrNO_DELAYr)rJnewDelays rrr$s, h 1 2 2x1}$--H rc<UR[R:g$)z} Whether the Turn is delayed (i.e. between a specific note and the following note) or not (i.e. exactly on a specific note). )rrr'rPs r isDelayedTurn.isDelayeds zz]3333rc>[TU]nUR[R:XaSU-nO8[ UR[ [45(aSURS3U-nURc URbnUS- nURb.USURR-- nURbUS- nURbUSURR-- nUS- nU$) a returns the name of the Turn/InvertedTurn, which is generally the class name lowercased, with spaces where a new capital occurs, but also with a 'delayed' prefix, if the Turn/InvertedTurn is delayed. If the delay is of a specific duration, the prefix will include that duration. The name also will include upper and lower accidentals, if they exist. Subclasses can override this as necessary. >>> nonDelayedTurn = expressions.Turn() >>> nonDelayedTurn.name 'turn' >>> from music21.common.enums import OrnamentDelay >>> delayedInvertedTurn = expressions.InvertedTurn( ... delay=OrnamentDelay.DEFAULT_DELAY, ... upperAccidental=pitch.Accidental('sharp'), ... lowerAccidental=pitch.Accidental('natural') ... ) >>> delayedInvertedTurn.name 'delayed inverted turn (upper=sharp, lower=natural)' >>> delayedBy1Turn = expressions.Turn( ... delay=1.0, lowerAccidental=pitch.Accidental('double-flat')) >>> delayedBy1Turn.name 'delayed(delayQL=1.0) turn (lower=double-flat)' zdelayed zdelayed(delayQL=z) r7zupper=z, zlower=r8) rFrrr DEFAULT_DELAYrr&rrrr:s rr Turn.names<w| ::44 4 7*G  UH$5 6 6( B7'AG    +t/C/C/O tOG##/8d&:&:&?&???''3tOG##/8d&:&:&?&??? sNGrrcUS;a [S5eUR(d[R"S5$URSnU=(d< UR [ R 5=(d [ R "S5n[R"U5nSUl URcURUl SnUS:Xa1UR[R"S5S S 9 URnO0UR[R"S 5S S 9 URnU(aXel O UR!UR"5Ul [R"XE5$) a Returns the size of one of the turn's two intervals (which='upper' or which='lower'), given a source note and an optional key signature. If the key signature is not specified, the source note's context is searched for the current key signature, and if there is no such key signature, a key signature with no sharps and no flats will be used. Any `upperAccidental` or `lowerAccidental` that has been set on the turn will also be taken into account. If either has not been set, the appropriate accidental from the key signature will be used. If keySig is specified, this can be considered to be a theoretical question: "If this particular turn were to be attached to this note, in this key, what would the ('upper' or 'lower') size of the turn interval be?" )upperlowerzDTurn.getSize requires 'which' parameter be set to 'upper' or 'lower'rrrNr0rwTrrM)r7rOr rrPr rQrrr/rRrSrrTrrrUrV)rJr*whichr rXrYr/s rrZ Turn.getSizes9, * *%VX X~~$$T* * &r 2\633C4D4DE\IYIYZ[I\'+}}X'>%)"  ! ! )%4%C%CO ",0 G   % %h&>&>q&A4 % P--J  % %h&>&>r&BD % Q--J )3 &*0)@)@AUAU)VO &  ;;rcUR(dgURSnURUSUS9nURUSUS9n[R"U5nURcUR UlUR USS9 URRS:waURSS9 [R"U5nURcUR UlUR USS9 URRS:waURSS9 URbMURc[R"S5Ul URRURlURbMURc[R"S5Ul URRURlXg4Ulg) at Computes and stores the ornamental pitches for a Turn, given the srcObj (can be any kind of ornamented GeneralNote) and an optional keySig. If keySig is None, srcNote's context will be searched for a key signature. If no key signature is found, a key signature with no sharps and no flats will be used. e.g. A turn on a D in a key with two flats (upper ornamental pitch will be E flat, lower ornamental pitch will be C). >>> twoFlats = key.KeySignature(sharps=-2) >>> n1 = note.Note('D4') >>> turn = expressions.Turn() >>> turn.resolveOrnamentalPitches(n1, keySig=twoFlats) >>> turn.ornamentalPitches (, ) >>> turn.upperOrnamentalPitch >>> turn.lowerOrnamentalPitch e.g. A turn with a sharp over it and a flat under it, on a C, in a key with no sharps or flats (upper ornamental pitch will be D#, lower ornamental pitch will be B flat). >>> noSharpsOrFlats = key.KeySignature(0) >>> n2 = note.Note('C4') >>> turn = expressions.Turn( ... upperAccidental=pitch.Accidental('sharp'), ... lowerAccidental=pitch.Accidental('flat')) >>> turn.resolveOrnamentalPitches(n2, keySig=noSharpsOrFlats) >>> turn.ornamentalPitches (, ) >>> turn.upperOrnamentalPitch >>> turn.lowerOrnamentalPitch Nrr0rr1Trr)rOrZrrrRrSrr^r_r`rr/r rarbrr)rJr*r rXtransposeIntervalUptransposeIntervalDown upperPitch lowerPitchs rrTurn.resolveOrnamentalPitches#sZ~~  &r 259\\ GF6B6,7;|| GF8D8,#'--"9    $ * 9 9J 0$?    % % *  6 6t 6 D"&--"9    $ * 9 9J 2DA    % % *  6 6t 6 D    +$$,(-(8(8(; %262F2F2T2TJ ! ! /    +$$,(-(8(8(; %262F2F2T2TJ ! ! /$.":rcT[UR5S:aURS$g)zt Returns the turn's upper ornamental pitch. If resolveOrnamentalPitches has not yet been called, None is returned. r$rNr}rrPs rupperOrnamentalPitchTurn.upperOrnamentalPitch{+ t&& '1 ,**1- -rcT[UR5S:aURS$g)zt Returns the turn's lower ornamental pitch. If resolveOrnamentalPitches has not yet been called, None is returned. rwr$Nr;rPs rlowerOrnamentalPitchTurn.lowerOrnamentalPitchr>rcUR$)z Returns any ornamental pitches that have been resolved (see `resolveOrnamentalPitches`, which must be called first, or an empty tuple will be returned). rfrPs rrTurn.ornamentalPitchesrlrTrc zUR(dgURUR4URUR44HuupU cM U bRU R bEU R c[R"S5U lU R U R lM_U RUUUUUUUSS9 Mw g)aB Updates accidental display for a Turn's ornamental pitches (upper and lower). Defined exactly like Pitch.updateAccidentalDisplay, with two changes: Instead of self being the pitch to update, self is a Turn whose ornamentalPitches are to be updated; and we pay no attention to ties, since ornamental notes cannot be tied. NrFrn) rr<rr@rrbr/r rar ) rJrrrrrrrrrqaccs rr Turn.updateAccidentalDisplays&%%  & &(<(< =  & &(<(< = FA}?s'8'8'D||+','7'7': 141B1BALL.--"+)9'5-A&3'55Q(-./ rrc URnURRS:Xa [S5eUnUc8UR[R 5nUc[R "S5nUR [R:XaSnOUR [R:Xa#[URRS- 5nO@UR n[R(a[U[[45(deUnURRU- nSn USUR-:a+UR (d [S5e[US- 5nO0USUR-:aURn[USU-- 5n UR"(d#UR%US US 9n UR%US US 9n O"UR%US US 9n UR%US US 9n ['U 5(+n /n [(R*"U5n/UlXNRlU (aF[R(a![U[.R05(deUR3U S S 9 [(R*"U5n/UlXORl[(R*"U5n/UlUURlU (aF[R(a![U[.R05(deUR3U S S 9 [(R*"U5n/UlU cUURlOU URlU R5U5 U R5U5 U R5U5 U R5U5 U (a[7U 5Hunn[R(a![U[.R05(deUS-nUR8R:bMZUS;dMbUR=UR8R>5UR8lM SnXR,;aUR,RAU5nUS:Xa/SU 4$U(d[(R*"U5nOUnUURlUS:waUR,RCU5 /UU 4$)a: realize a turn. returns a three-element tuple. The first element is an empty list because there are no notes at the start of a turn. The second element is the original note with a duration equal to the delay (but if there is no delay, the second element is None, because the turn "eats up" the entire note). The third element is a list of the four turn notes, adding up to the duration of the original note (less the delay, if there is one). The four turn notes will either be of equal duration, or the fourth note will be longer, to "eat up" the entire note. >>> from music21 import * >>> from music21.common.enums import OrnamentDelay >>> m1 = stream.Measure() >>> m1.append(key.Key('F', 'major')) >>> n1 = note.Note('C5') >>> m1.append(n1) >>> t1 = expressions.Turn() >>> t1.realize(n1) ([], None, [, , , ]) >>> m2 = stream.Measure() >>> m2.append(key.KeySignature(5)) >>> n2 = note.Note('B4', type='quarter') >>> m2.append(n2) >>> t2 = expressions.InvertedTurn(delay=OrnamentDelay.DEFAULT_DELAY) >>> n2.expressions.append(t2) >>> t2.realize(n2) ([], , [, , , ]) Realizing an expression leaves the original note and expression alone >>> n2.duration.type 'quarter' >>> n2.expressions [] If `inPlace` is True then the note is affected and the turn is removed from `.expressions`: >>> n2 = note.Note('C4') >>> n2.duration.type = '32nd' >>> t2 = expressions.Turn(delay=OrnamentDelay.DEFAULT_DELAY) >>> _empty, newOrigNote, turnNotes = t2.realize(n2, inPlace=True) >>> for turnNote in turnNotes: ... print(turnNote, turnNote.duration.type) 256th 256th 256th 256th >>> n2.duration.type '64th' >>> n2.expressions [] >>> newOrigNote is n2 True If the four turn notes (self.quarterLength each) don't add up to the original note duration, the fourth turn note should be held to the length of any remaining unused duration. Here, for example, we have a dotted eighth note total duration, a delay of a 16th note, and a turn note duration of a triplet 32nd note, leaving the fourth turn note with a duration of a 16th note. This sort of turn is seen all over the music of Weber. >>> from fractions import Fraction >>> n3 = note.Note('C4') >>> n3.quarterLength = 0.75 >>> t3 = expressions.Turn(delay=0.25) >>> t3.quarterLength = 0.125 * Fraction(2, 3) >>> _empty, newOrigNote, turnNotes = t3.realize(n3, inPlace=True) >>> print(newOrigNote, newOrigNote.quarterLength) 0.25 >>> for turnNote in turnNotes: ... print(turnNote, turnNote.quarterLength) 1/12 1/12 1/12 0.25 If `.autoScale` is off and the note is not long enough to realize 4 32nd notes, then an exception is raised. >>> n2 = note.Note('C4') >>> n2.duration.type = '32nd' >>> t2 = expressions.Turn() >>> t2.autoScale = False >>> t2.realize(n2) Traceback (most recent call last): music21.expressions.ExpressionException: The note is not long enough to realize a turn rrtNrrwruz-The note is not long enough to realize a turnr0rr1Trr$)r$rHr)"rrr7rPr rQrrr'r-rr&r'rr&rrrrZrrrr"rrrr)rvr r/rUrVrwrx)rJr*r rrrzremainderDurationtheDelay turnDuration fourthNoteQLfirstTransposeIntervalsecondTransposeIntervalr turnNotesrr  thirdNote fourthNoter}r~rrrs rr% Turn.realizesT"" ?? ( (A -%&YZ Z  "44S5E5EFM$ # 0 0 3  ::// / #  ZZ=66 6 &v'D'Dq'H I zzH!(UH,=>>>> ( 447HH &* !d000 0>>)*YZZr\rrrr'rGr_rrrrr*rrZrr<r@rr r%r?r`ras@rr r is9 K )6(>(>1515 &/  / "%%33%%33   \\ 44--h)- 6< 6<6< & 6<  6rrr?r9rrrUrU s KrrUcN^\rSrSrSrU4SjrSSS.S SjjrSrU=r$) GeneralAppoggiaturai rOc \>[TU]"S0UD6 [R"S5Ulg)Nrwr9rFrGr rr rIs rrGGeneralAppoggiatura.__init__ s% $8$%%a( rNFrcbURS;a [S5eURS:Xa [S5eURRS:Xa [S5eURRS- nURS:Xa URnOURR 5n[ R"U5nXFRl[U5(+nU(aF[R(a![U[R5(deURUS S 9 S nXR;aURR!U5nU(d[ R"U5OUn XIRlUS :waU RR#U5 U/U /4$) aF realize an appoggiatura returns a three-element tuple. The first is the list of notes that the grace note was converted to. The second is the rest of the note The third is an empty list (since there are no notes at the end of an appoggiatura) >>> n1 = note.Note('C4') >>> n1.quarterLength = 0.5 >>> a1 = expressions.Appoggiatura() >>> a1.realize(n1) ([], , []) >>> n2 = note.Note('C4') >>> n2.quarterLength = 1 >>> a2 = expressions.HalfStepInvertedAppoggiatura() >>> a2.realize(n2) ([], , []) rJz=Cannot realize an Appoggiatura if I do not know its directionrOz8Cannot realize an Appoggiatura if there is no size givenrrtrwrLTrr)rFr7r rrrrrrr&r'rrrrr"rwrx) rJr*r r newDurationrappoggiaturaNoterrrs rr%GeneralAppoggiatura.realize sl< >> /%OQ Q 99?%JL L ?? ( (A -%&YZ Zoo33a7 >>V # $  $ 1 1 3 ==02=!!/!)*;!<< !"2DII>>>>  & &'8$ & G %% %"..44T:M5< f-& /:, B   % % ) )- 8 ""M266rr r") r;r<r=r>rFrGr%r?r`ras@rrWrW sKI))- A7(A7& A7  A7  0 A7A7rrWc\rSrSrSrSrg) Appoggiaturai rLr9Nr;r<r=r>rFr?r9rrrara sIrrac(^\rSrSrU4SjrSrU=r$)HalfStepAppoggiaturai c \>[TU]"S0UD6 [R"S5UlgNrr9rYrIs rrGHalfStepAppoggiatura.__init__ % $8$%%d+ rr_r;r<r=r>rGr?r`ras@rrdrd ,,rrdc(^\rSrSrU4SjrSrU=r$)WholeStepAppoggiaturai c \>[TU]"S0UD6 [R"S5UlgNrr9rYrIs rrGWholeStepAppoggiatura.__init__ rhrr_riras@rrlrl rjrrlc\rSrSrSrSrg)InvertedAppoggiaturai rKr9Nrbr9rrrqrq sIrrqc(^\rSrSrU4SjrSrU=r$)HalfStepInvertedAppoggiaturai c \>[TU]"S0UD6 [R"S5UlgrfrYrIs rrG%HalfStepInvertedAppoggiatura.__init__ rhrr_riras@rrsrs rjrrsc(^\rSrSrU4SjrSrU=r$)WholeStepInvertedAppoggiaturai c \>[TU]"S0UD6 [R"S5UlgrnrYrIs rrG&WholeStepInvertedAppoggiatura.__init__ rhrr_riras@rrwrw rjrrwc\rSrSrSrg)TremoloExceptioni r9Nr:r9rrr{r{ r@rr{c^\rSrSrSrU4Sjr\S5r\RS5rSSS.S S jjr S r U=r $) Tremoloi a A tremolo ornament represents a single-note tremolo, whether measured or unmeasured. >>> n = note.Note(type='quarter') >>> trem = expressions.Tremolo() >>> trem.measured = True # default >>> trem.numberOfMarks = 3 # default >>> trem.numberOfMarks = 'Hi' Traceback (most recent call last): music21.expressions.TremoloException: Number of marks must be a number from 0 to 8 >>> trem.numberOfMarks = -1 Traceback (most recent call last): music21.expressions.TremoloException: Number of marks must be a number from 0 to 8 TODO: (someday) realize triplet Tremolos, etc. differently from other tremolos. TODO: deal with unmeasured tremolos. c B>[TU]"S0UD6 SUlSUlg)NTrHr9)rFrGmeasured_numberOfMarksrIs rrGTremolo.__init__" s" $8$ rcUR$)zL The number of marks on the note. Currently, completely controls playback. rrPs r numberOfMarksTremolo.numberOfMarks'  """rc[U5nUS:dUS:a[[U55eXlg![an[ S5UeSnAff=fNrz,Number of marks must be a number from 0 to 8ryrzr[rr{rJnumves rrr. sU c(CQw#' S**"%  ">  14 A A  ANFrcSSUR--n/nU(d[R"U5OUnXR;aURR U5 UbHUR U:a8UR USS9upvURU5 UbUR U:aM8UbURU5 US/4$)a Realize the ornament >>> n = note.Note(type='quarter') >>> trem = expressions.Tremolo() >>> trem.measured = True # default >>> trem.numberOfMarks = 3 # default >>> trem.realize(n) ([, , , , , , , ], None, []) >>> c2 = trem.realize(n)[0] >>> [ts.quarterLength for ts in c2] [0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125] Same thing with Streams: >>> n = note.Note(type='quarter') >>> trem = expressions.Tremolo() >>> n.expressions.append(trem) >>> s = stream.Stream() >>> s.append(n) >>> s.show('text') {0.0} >>> y = stream.makeNotation.realizeOrnaments(s) >>> y.show('text') {0.0} {0.125} {0.25} {0.375} {0.5} {0.625} {0.75} {0.875} >>> trem.numberOfMarks = 1 >>> y = stream.makeNotation.realizeOrnaments(s) >>> y.show('text') {0.0} {0.5} rwrNF) retainOrigin)rrrr"rrsplitAtQuarterLengthr))rJr*r r lengthOfEach objsConvertedeRemainaddNotes rr%Tremolo.realize: sh2 2 223  /6$--'F && &    & &t ,!g&;&;l&J&;;LW\;] G   )!g&;&;l&J     )tR((r)rrr") r;r<r=r>r\rGr_rrr%r?r`ras@rr}r} sy& ##   )- @)(@)& @)  @)  0 @)@)rr}c,^\rSrSrSrU4SjrSrU=r$)Fermatai~ a Fermatas by default get appended to the last note if a note is split because of measures. To override this (for Fermatas or for any expression) set .tieAttach to 'all' or 'first' instead of 'last'. >>> p1 = stream.Part() >>> p1.append(meter.TimeSignature('6/8')) >>> n1 = note.Note('D-2') >>> n1.quarterLength = 6 >>> n1.expressions.append(expressions.Fermata()) >>> p1.append(n1) >>> #_DOCS_SHOW p1.show() .. image:: images/expressionsFermata.* :width: 193 c P>[TU]"S0UD6 SUlSUlSUlg)Nnormalinvertedlastr9)rFrGshaperrHrIs rrGFermata.__init__ s* $8$  r)rrHrrras@rrr~ s$  rrc\rSrSrSrg)TrillExtensionExceptioni r9Nr:r9rrrr r@rrcH^\rSrSrSrU4SjrSrSr\"\\SS9r Sr U=r $) ri a A wavy line trill extension, placed between two notes. N ote that some MusicXML readers include a trill symbol with the wavy line. >>> s = stream.Stream() >>> s.repeatAppend(note.Note(), 8) Create TrillExtension between notes 2 and 3 >>> te = expressions.TrillExtension(s.notes[1], s.notes[2]) >>> s.append(te) # spanner can go anywhere in the Stream >>> print(te) > c4>[TU]"U0UD6 SUlgrs)rFrG _placementrJrrKrLs rrGTrillExtension.__init__ s /6X6 rcUR$rsrrPs r _getPlacementTrillExtension._getPlacement s rcUb"UR5S;a[SU35eUbUR5Ulgg)N)r2belowzincorrect placement value: )r1rrrs r _setPlacementTrillExtension._setPlacement sA  6H!H),Gw*OP P  #kkmDO ra Get or set the placement as either above, below, or None. >>> s = stream.Stream() >>> s.repeatAppend(note.Note(), 8) >>> te = expressions.TrillExtension(s.notes[1], s.notes[2]) >>> te.placement = 'above' >>> te.placement 'above' A setting of None implies that the placement will be determined by notation software and no particular placement is demanded. )docr) r;r<r=r>r\rGrrr_rr?r`ras@rrr s, ",  <  Irrc`^\rSrSrSrU4Sjr\S5r\RS5rSr U=r $)TremoloSpanneri a A tremolo that spans multiple notes >>> ts = expressions.TremoloSpanner() >>> n1 = note.Note('C') >>> n2 = note.Note('D') >>> ts.addSpannedElements([n1, n2]) >>> ts.numberOfMarks = 2 >>> ts > >>> ts.numberOfMarks = -1 Traceback (most recent call last): music21.expressions.TremoloException: Number of marks must be a number from 0 to 8 cP>[TU]"U0UD6 SUlSUlSUlg)NTrH)rFrGrrrrs rrGTremoloSpanner.__init__ s+ /6X6 rcUR$)zE The number of marks on the note. Will eventually control playback. rrPs rrTremoloSpanner.numberOfMarks rrc[U5nUS:dUS:a[[U55eXlg![an[ S5UeSnAff=frrrs rrr sT [c(CQw#' S**"%  ["#QRXZ Z [r)rrr) r;r<r=r>r\rGr_rrr?r`ras@rrr s=$ ## [[rrc4^\rSrSrSrSSU4SjjjrSrU=r$) ArpeggioMarki a ArpeggioMark must be applied to a Chord (not to a single Note). The parameter arpeggioType can be 'normal' (a squiggly line), 'up' (a squiggly line with an up arrow), 'down' (a squiggly line with a down arrow), or 'non-arpeggio' (a bracket instead of a squiggly line, used to indicate a non-arpeggiated chord intervening in a sequence of arpeggiated ones). >>> am = expressions.ArpeggioMark('normal') >>> am.type 'normal' >>> am = expressions.ArpeggioMark('down') >>> am.type 'down' c v>[TU]"S0UD6 U(dSnUS;a[SSU<S3-5eXlg)NrrrKrLz non-arpeggioAArpeggio type must be "normal", "up", "down", or "non-arpeggio", not .r9rFrGrzr)rJ arpeggioTyperKrLs rrGArpeggioMark.__init__ sM $8$#L G GS(*+ ! rrrs)rrrras@rrr s ! !rrcD^\rSrSrSrSS.SU4SjjjrS SjrSrU=r$) ArpeggioMarkSpanneri a_ ArpeggioMarkSpanner is a multi-staff or multi-voice (i.e. multi-chord) arpeggio. The spanner should contain all the simultaneous Chords that are to be arpeggiated together. If there is only one arpeggiated note in a particular staff or voice (i.e. the rest are in other staves/voices), then in that case only the spanner can contain a Note. Do not ever put a Note that is within a Chord into a spanner; put the Chord in instead. And do not ever put an ArpeggioMark in a note or chord's .expressions. The parameter arpeggioType can be 'normal' (a squiggly line), 'up' (a squiggly line with an up arrow), 'down' (a squiggly line with a down arrow), or 'non-arpeggio' (a bracket instead of a squiggly line, used to indicate a non-arpeggiated multi-chord intervening in a sequence of arpeggiated ones). >>> ams = expressions.ArpeggioMarkSpanner(arpeggioType='non-arpeggio') >>> c1 = chord.Chord('C3 E3 G3') >>> c2 = chord.Chord('C4 E4 G4') >>> ams.addSpannedElements([c1, c2]) >>> ams.type 'non-arpeggio' >>> ams > r)rcd>[TU]"U0UD6 US;a[SSU<S3-5eXlg)Nrrrrr)rJrrrKrLs rrGArpeggioMarkSpanner.__init__5 sI /6X6 G GS(*+ ! rc$SSKJn SSKJn /nUHgn[XBR5(aUR U5 M0[XAR 5(dMLURUR5 Mi [U5[U54$)a' Return the lowest and highest note spanned by the element, extracting them from Chords if need be. >>> ch = chord.Chord(['C4', 'E4', 'G4']) >>> n = note.Note('C#3') >>> nonArp = expressions.ArpeggioMarkSpanner([ch, n]) >>> nonArp.noteExtremes() (, ) r)chordr) rrrrrr)Chordextendnotesminmax)rJrrrn_or_chs r noteExtremes ArpeggioMarkSpanner.noteExtremesB sh " G'99-- W%G[[11 W]]+  E CJ''rr)rr[)rZz)tuple[note.Note | None, note.Note | None]) r;r<r=r>r\rGrr?r`ras@rrr s)4&. !" ! !((rr__main__)rr&rZr%)r*r#r r$)Mr\ __future__rrr~typingr& fractionsrrrrmusic21.common.enumsrmusic21.common.numberToolsrmusic21.common.typesr r r r r rrr'rrr5Music21Exceptionr7 Music21ObjectrBrcStrEnumrrSpannerrrrrrrrr,rrrrrrrrrrrrr rUrWrardrlrqrsrwr{r}rrrrrr _DOC_ORDERr;mainTestr9rrrs # .-) ??%)I $I "IZ ,77 D##DFYKJYKz  '('(T #$$$ #+K+N ZN dozoft.Xt.r EnEPNgNDOwOF'n'T Vo VF W WHC*HC*LE-LE-L`-MU-M` "E "" " "k.8k.\4 I7(I7X&,<, ,L, .,#7, ,$8, |44 l)hl)` j > l;; / W__/ d)[W__)[X!:!::('//:(F   z r