rh %SrSSKJr SSKrSSKrSSKJr SSKrSSKJ r SSKJ r SSKJ r SSK J r SS KJr SS KJr SS KJr SS KJr SS KJr SSKJr SSKJr SSKJr SSKJr \R0(a?SSKJrJr SSKJrJr SSKJr SSKJ r SSKJ!r! SSKJ"r" SSK#J$r$ \RJ"SSS9r&\RN"S5r(Sr)Sr*Sr+"S S!\RX5r-"S"S#\RX5r."S$S%\RX5r/\R`S&r1/S&Qr2S'\3S('"S)S*\Rh\Rj5r6"S+S,\ Rn5r8"S-S\85r9"S.S/\95r:"S0S1\95r;"S2S3\85r<"S4S5\Rz5r>"S6S7\Rz5r?\:\<\;\9\8\6/r@\AS8:XaSSKr\R"\?5 gg)9z Classes and functions for creating Notes, Rests, and Lyrics. The :class:`~music21.pitch.Pitch` object is stored within, and used to configure, :class:`~music21.note.Note` objects. ) annotationsN)overload)base)beam)common)Duration) environment) exceptions21) expressions)interval)Pitch)prebase)styletie)volume)IterableSequence)StepName OffsetQLIn) articulations)chord instrument) percussion)Style _NotRestTypeNotRest)boundnote)z arrow downzarrow upz back slashedz circle dotzcircle-xcircledclustercrossdiamonddofazfa upzinverted trianglelaz left triangleminonenormalotherre rectangleslashslashedsosquaretitrianglex)doubledownnoStemr) unspecifiedupcl[5Vs/sH4oRS5(aMURS5(aM2UPM6 nnURS5 URS5 URS5 URS5 URS5 URS5 URS 5 URS 5 URS 5 URS 5 URS 5 URS5 URS5 URS5 URS5 URS5 URS5 URS5 URS5 URS5 URS5 U$s snf)N__Testtrunittestr environLocalcopy _DOC_ORDERrr rrrr r r r rrrrSyllabicChoices)globals startswithremove)nouts F/home/james-whalen/.local/lib/python3.13/site-packages/music21/note.py__dir__rI\s5i Wi||D'91!,,vBV1iC WJJsOJJ}JJzJJzJJ~JJvJJ|JJzJJwJJvJJvJJxJJ}JJ~JJ}JJzJJyJJwJJuJJxJJ ! J3 XsF1F1F1c\rSrSrSrg)LyricExceptionyN__name__ __module__ __qualname____firstlineno____static_attributes__rMrHrKrKyrTrKc\rSrSrSrg) NoteException}rMNrNrMrTrHrWrW}rUrTrWc\rSrSrSrg)NotRestExceptionrMNrNrMrTrHrZrZrUrTrZ)Nbeginsingleendmiddle compositezlist[SyllabicChoices]SYLLABIC_CHOICESc^\rSrSrSr\R rSrSSSSS.SU4Sjjjjr Sr \ SS j5r \ SS j5r \ RSS j5r \ SS j5r\RSS j5r\ SSj5r\RSSj5r\ SSj5r\RSSj5r\ S Sj5r\RS!Sj5rS"S#SjjrSrU=r$)$Lyrica An object representing a single Lyric as part of a note's .lyrics property. The note.lyric property is a simple way of specifying a single lyric, but Lyric objects are needed for working with multiple lyrics. >>> l = note.Lyric(text='hello') >>> l Music21 processes leading and following hyphens intelligently by default. >>> l2 = note.Lyric(text='hel-') >>> l2 If `applyRaw` is set to True then hyphens will be treated as actual text, and the `syllabic` will be set to "single". >>> l3 = note.Lyric(number=3, text='hel-', applyRaw=True) >>> l3 Lyrics have four properties: text, number, identifier, syllabic (single, begin, middle, end, or (not in musicxml) composite) >>> l3.text 'hel-' >>> l3.number 3 >>> l3.syllabic 'single' Note musicXML only supports one 'identifier' attribute which is called 'number' but which can be a number or a descriptive identifier like 'part2verse1.' To preserve lyric ordering, music21 stores a number and a descriptive identifier separately. The descriptive identifier is by default the same as the number, but in cases where a string identifier is present, it will be different. Both music21 and musicxml support multiple `Lyric` objects in the same stanza, for instance, if there is an elision on a note then multiple lyrics with different syllabics can appear on a single note. In music21 these are supported by setting .components into a list of `Lyric` object. For instance in the madrigal "Il bianco e dolce cigno", the "co" and "e" of "bianco e" are elided into a single lyric: >>> bianco = note.Lyric() >>> co = note.Lyric('co', syllabic='end') >>> e = note.Lyric('e', syllabic='single') >>> bianco.components = [co, e] >>> bianco.isComposite True >>> bianco.text 'co e' >>> bianco.syllabic 'composite' >>> e.elisionBefore = '_' >>> bianco.text 'co_e' >>> [component.syllabic for component in bianco.components] ['end', 'single'] Custom elision elements for composite components will be supported later. * New in v6.7: composite components, elisionBefore * Changed in v8: lyric text can be an empty string, but not None. ) _identifier_number _syllabic_text components elisionBeforeFN)applyRawsyllabic identifierc >[TU]5 SUlSUlSUlSUlSUlSUlU(aURX5 UbX@l X l XPl g)N ) super__init__rerfrhrgrirjsetTextAndSyllabicrlnumberrm)selftextrurkrlrmkeywords __class__s rHrsLyric.__init__sh %)  *.,0    # #D 3  $M %rTcSnURbUSURS3- nURbUSUR<S3- nURbUSURS3- nUR(aUSUR<S3- nU$)Nrpznumber=rqz identifier=z syllabic=ztext=)rurermrlrw)rvrGs rH _reprInternalLyric._reprInternals ;; " WT[[M+ +C    ' [ 315 5C == $ Yt}}oQ/ /C 99 U499-q) )C rTc,[UR5$)zf Returns True if this Lyric has composite elements, for instance, is multiple lyrics placed together. )boolrirvs rH isCompositeLyric.isComposites DOO$$rTcvUR(d UR$[R(a&[ UR [ 5(dS5eUR SRnUcSnUR SSH/nURb UROSnXRU-- nM1 U$)a Gets or sets the text of the lyric. For composite lyrics, set the text of individual components instead of setting the text here. >>> l = note.Lyric() >>> l.text '' >>> l.text = 'hi' >>> l.text 'hi' Setting the text of a composite lyric wipes out the components: >>> bianco = note.Lyric() >>> co = note.Lyric('co', syllabic='end') >>> e = note.Lyric('e', syllabic='single') >>> bianco.components = [co, e] >>> bianco.isComposite True >>> bianco.text 'co e' >>> bianco.text = 'co_e' >>> bianco.isComposite False z=Programming error: isComposite implies that components existsrNrpro) rrhr= TYPE_CHECKING isinstancerirrwrj)rvtext_out component componentTexts rHrw Lyric.texts6:: !$//8<<TST<q)..H!__QR0 2;..2L RT 33mCC1OrTc@UR(aSUlXlgN)rrirh)rvnewTexts rHrwr?s   "DO rTc>UR(agUR$)a Returns or sets the syllabic property of a lyric. >>> fragment = note.Lyric('frag', syllabic='begin') >>> fragment.syllabic 'begin' >>> fragment.rawText 'frag-' >>> fragment.syllabic = 'end' >>> fragment.rawText '-frag' Illegal values raise a LyricException >>> fragment.syllabic = 'slide' Traceback (most recent call last): music21.note.LyricException: Syllabic value 'slide' is not in note.SYLLABIC_CHOICES, namely: [None, 'begin', 'single', 'end', 'middle', 'composite'] r`)rrgrs rHrlLyric.syllabicEs,   >> !rTcXU[;a[SU<S3S[3-5eXlg)NzSyllabic value z is not in znote.SYLLABIC_CHOICES, namely: )rarKrg)rv newSyllabics rHrlras= . . !+ <34D3EFG %rTcLURc UR$UR$)a By default, this is the same as self.number. However, if there is a descriptive identifier like 'part2verse1', it is stored here and will be different from self.number. When converting to musicXML, this property will be stored in the lyric 'number' attribute which can store a number or a descriptive identifier but not both. >>> l = note.Lyric() >>> l.number = 12 >>> l.identifier 12 >>> l.identifier = 'Rainbow' >>> l.identifier 'Rainbow' Default value is the same as default for number, that is, 1: >>> note.Lyric().identifier 1 )rerfrs rHrmLyric.identifierjs&.    #<< ## #rTcXlgr)rervvalues rHrmrs rTcURnUR(d2URnUS:XaUS-$US:XaSU-S-$US:XaSU-$U$[R(a&[ UR [5(dS5eUR SRnUR SRnUS;aSU-nUS ;aUS- nU$) a` returns the text of the syllable with '-' etc. >>> l = note.Lyric('hel-') >>> l.text 'hel' >>> l.rawText 'hel-' >>> l = note.Lyric('lo', syllabic='end') >>> l.rawText '-lo' >>> l = note.Lyric('-ti-') >>> l.rawText '-ti-' >>> l = note.Lyric('bye') >>> l.rawText 'bye' Composite lyrics take their endings from the first and last components: >>> composite = note.Lyric() >>> co = note.Lyric('co', syllabic='end') >>> e = note.Lyric('e', syllabic='single') >>> e.elisionBefore = '_' >>> composite.components = [co, e] >>> composite.rawText '-co_e' >>> e.syllabic = 'middle' >>> composite.rawText '-co_e-' r\-r_r^z>Programming error: isComposite should assert components existsr)r_r^)r\r_)rwrrlr=rrrir)rvrwrl firstSyllabic lastSyllabics rHrawText Lyric.rawTextsHyy}}H7"cz!X%TzC''U"Tz! !$//8<<UTU< OOA.77M??2.77L 11Tz22 KrTc$URUSS9 g)NT)rk)rt)rv rawTextIns rHrrs  D9rTcUR$)aB This stores the number of the lyric (which determines the order lyrics appear in the score if there are multiple lyrics). Unlike the musicXML lyric number attribute, this value must always be a number; lyric order is always stored in this form. Descriptive identifiers like 'part2verse1' which can be found in the musicXML lyric number attribute should be stored in self.identifier. Default is 1 >>> l = note.Lyric('Hi') >>> l.number 1 >>> l.number = 5 >>> l.number 5 >>> l.number = None Traceback (most recent call last): music21.note.LyricException: Number best be number )rfrs rHru Lyric.numbers.||rTc\[R"U5(d [S5eXlg)NzNumber best be number)risIntrKrfrs rHrurs"||E"" !89 9 rTc[U[5(d [U5nUSLa>URS5(a(URS5(dUSSUlSUlgUSLa>URS5(d(URS5(aUSSUlSUlgUSLa>URS5(a(URS5(aUSSUlSUlgXlUR bU(dS Ulgg) a| Given a setting for rawText and applyRaw, sets the syllabic type for a lyric based on the rawText. Useful for parsing raw text from, say, an OMR score. Or just to quickly set text and syllabic. >>> l = note.Lyric() >>> l.setTextAndSyllabic('hel-') >>> l.text 'hel' >>> l.syllabic 'begin' >>> l.setTextAndSyllabic('-lo') >>> l.text 'lo' >>> l.syllabic 'end' >>> l.setTextAndSyllabic('the') >>> l.text 'the' >>> l.syllabic 'single' If applyRaw is True then this will assume you actually want hyphens in the text, and if syllabic is None, sets it to 'single' >>> l = note.Lyric() >>> l.setTextAndSyllabic('hel-', applyRaw=True) >>> l.text 'hel-' >>> l.syllabic 'single' If applyRaw is True, other syllabic settings except None are retained >>> l.syllabic = 'begin' >>> l.setTextAndSyllabic('-lo', applyRaw=True) >>> l.text '-lo' >>> l.syllabic 'begin' This method wipes out components. FrroNr^rr\r_r])rstrrDendswithrwrl)rvrrks rHrtLyric.setTextAndSyllabics^'3'''lG u !3!3C!8!8AQAQRUAVAV DI!DM  w'9'9#'>'>7CSCSTWCXCX DI#DM  7#5#5c#:#:w?O?OPS?T?T" DI$DMI}}$H ( -5rT) rerfrgrhrirjrmrurlrw)rpro) rwrruintrkrrlrBrm str | Nonereturnrrr)rr)rrB)rrB)rz str | int)rr)rr)rr)rrrNone)F)rrrkrrr)rOrPrQrR__doc__rTextStylePlacement _styleClass __slots__rsr|propertyrrwsetterrlrmrrurtrS __classcell__rys@rHrcrcsqFN**KI  %#(-1(, %%% % + % & %%< %%&&P [[ ""6__%%$$6!!88v ^^::0 ]] ?)?)rTrcc^\rSrSr%SrSrSrSr\Rr S\ S'Sr S\ S'S S /r S S S SS.rS\ S'SSS.S'U4SjjjrU4SjrU4Sjr\S(Sj5r\R(S)Sj5r\S*Sj5r\R(S+Sj5rS,SSS.S-SjjjrS.SSS.Sjjr\S/Sj5r\S0S j5r\R(S1S!j5rSS".S#jrSSS$.S%jrS&rU=r$)2 GeneralNotei/a7 A GeneralNote object is the base class object for the :class:`~music21.note.Note`, :class:`~music21.note.Rest`, :class:`~music21.chord.Chord`, and related objects. Keywords can be passed to a GeneralNote which are then passed to the underlying :class:`~music21.duration.Duration`. These keywords might be listed like type='16th', dots=2 etc. to create a double-dotted sixteenth note. In almost every circumstance, you should create note.Note() or note.Rest() or chord.Chord() objects directly, and not use this underlying structure. >>> gn = note.GeneralNote(type='16th', dots=2) >>> gn.quarterLength 0.4375 **Equality** GeneralNote objects are equal if they pass superclass tests (e.g., their durations are equal), and they have the same articulation and expression classes (in any order), and their ties are equal. Fztype[style.Style]rrtuple[str, ...]equalityAttributesduration quarterLengthz=Boolean read-only value describing if this object is a Chord.z/A list of :class:`~music21.note.Lyric` objects.za list of expressions (such as :class:`~music21.expressions.Fermata`, etc.) that are stored on this Note.zya list of articulations such as :class:`~music21.articulations.Staccato`, etc.) that are stored on this Note.)isChordlyricsr rdict[str, str] _DOC_ATTRN)rlyricc f>UciU(a SU;aSU;a [S5nOL[S0UD6nSU;aUS SU;aUS URS:XaUR5(dSUlOUn[TU]"SSU0UD6 /Ul/Ul/UlUbURU5 SUl g)Ntyperg?rrrM) rrcurrentComponentsrrrsrr raddLyric_tie)rvrrrx tempDurationrys rHrsGeneralNote.__init___s  h 6?RZ;Z'} '3(3 "h. 1X% (!..!3 , > > @ @14L.#L ;,;(;#% 9;?A   MM% #' rTcN>[TU]U5(dgSHn[X5Vs/sHn[U5PM nn[X5Vs/sHn[U5PM nn[ U5[ U5:wa g[ U5[ U5:wdM g gs snfs snf)NF)rr T)rr__eq__getattrrlenset)rvr+searchr4my_art_express_classesother_art_express_classesrys rHrGeneralNote.__eq__sw~e$$5F7>t7L%M7L!d1g7L "%M:A%:P(Q:PQa:P %(Q)*c2K.LL)*c2K.LL 5&N(Qs B B"c >[TU]5$r)rr__hash__)rvrys rHrGeneralNote.__hash__sw!!rTcUR$)z Return and set a :class:`~music21.note.Tie` object, or None. >>> n = note.Note() >>> n.tie is None True >>> n.tie = tie.Tie('start') rrs rHrGeneralNote.tiesyyrTcXlgrrrs rHrrs rTcUR(dgURVs/sHoRPM nnSRUVs/sH o3cMUPM sn5$s snfs snf)a The lyric property can be used to get and set a lyric for this Note, Chord, or Rest. This is a simplified version of the more general :meth:`~music21.note.GeneralNote.addLyric` method. >>> a = note.Note('A4') >>> a.lyrics [] >>> a.lyric = 'hel-' >>> a.lyric 'hel' >>> a.lyrics [] Eliminate Lyrics by setting a.lyric to None >>> a.lyric = None >>> a.lyric >>> a.lyrics [] Set multiple lyrics with \n separated text: >>> a.lyric = '1. Hi\n2. Bye' >>> a.lyric '1. Hi\n2. Bye' >>> a.lyrics [, ] You can also set a lyric with a lyric object directly: >>> b = note.Note('B5') >>> ly = note.Lyric('bon-') >>> b.lyric = ly >>> b.lyrics [] >>> b.lyric 'bon' * Changed in v6.7: added setting to a Lyric object. Removed undocumented setting to False instead of setting to None N )rrwjoin)rvlyallTexttextStrs rHrGeneralNote.lyricsO^{{%)[[1[r77[1yyPg'PQQ2PsAA#A#cP/UlUcg[U[5(aURRU5 g[U[5(d [ U5nUR S5n[ U5H*up4URR[XCS-S95 M, g)Nrro)ru)rrrcappendrsplit enumerate)rvrvaluesivs rHrrs =  eU # # KK  u % %%%JET"f%DA KK  uQ1u5 6&rT)rklyricIdentifierc r[U[5(d [U5nUc<[UR5S-nURR [ XX4S95 gSnURHnUR U:XdMXlSn O USLa$URR [ XX4S95 gg)a Adds a lyric, or an additional lyric, to a Note, Chord, or Rest's lyric list. If `lyricNumber` is not None, a specific line of lyric text can be set. The lyricIdentifier can also be set. >>> n1 = note.Note() >>> n1.addLyric('hello') >>> n1.lyrics[0].text 'hello' >>> n1.lyrics[0].number 1 An added option gives the lyric number, not the list position >>> n1.addLyric('bye', 3) >>> n1.lyrics[1].text 'bye' >>> n1.lyrics[1].number 3 >>> for lyr in n1.lyrics: ... print(lyr.text) hello bye Replace an existing lyric by specifying the same number: >>> n1.addLyric('ciao', 3) >>> n1.lyrics[1].text 'ciao' >>> n1.lyrics[1].number 3 Giving a lyric with a hyphen at either end will set whether it is part of a multisyllable word: >>> n1.addLyric('good-') >>> n1.lyrics[2].text 'good' >>> n1.lyrics[2].syllabic 'begin' This feature can be overridden by specifying the keyword only argument "applyRaw=True": >>> n1.addLyric('-5', applyRaw=True) >>> n1.lyrics[3].text '-5' >>> n1.lyrics[3].syllabic 'single' NrorkrmFT)rrrrrrcrurw)rvrw lyricNumberrkr maxLyrics foundLyric thisLyrics rHrGeneralNote.addLyricsn$$$t9D  DKK(1,I KK  uT.6 T UJ![[ ##{2%)N!%J ) U" ""52:$XY#rTrc [U[5(d [U5nURUSHnU=RS- slM URR U[ XS-X4S95 g)aJ Inserts a lyric into the Note, Chord, or Rest's lyric list in front of the index specified (0 by default), using index + 1 as the inserted lyric's line number. shifts line numbers of all following lyrics in list >>> n1 = note.Note() >>> n1.addLyric('second') >>> n1.lyrics [] >>> n1.insertLyric('first', 0) >>> n1.lyrics [, ] OMIT_FROM_DOCS test inserting in the middle. >>> n1.insertLyric('newSecond', 1) >>> n1.lyrics [, , ] Test number as lyric: >>> n1.insertLyric(0, 3) >>> n1.lyrics [, , , ] Nror)rrrruinsertrc)rvrwindexrkrmrs rH insertLyricGeneralNote.insertLyric;sdD$$$t9D[[(E LLA L) 5%qy19#R SrTc URS$)Nr)classesrs rHfullNameGeneralNote.fullNamegs||ArTcg)zh Returns an empty tuple. (Useful for iterating over GeneralNotes since they include Notes and Chords.) rMrMrs rHpitchesGeneralNote.pitchesks rTcgrrM)rv_values rHrrss rTinPlacecUS:d [S5eU(aUnO[R"U5nURR U5UlU(dU$g)a Given a scalar greater than zero, return a Note with a scaled Duration. If `inPlace` is True, this is done in-place and the method returns None. If `inPlace` is False [default], this returns a modified deepcopy. * Changed in v5: inPlace is now False. >>> n = note.Note('g#') >>> n.quarterLength = 3 >>> n.augmentOrDiminish(2, inPlace=True) >>> n.quarterLength 6.0 >>> c = chord.Chord(['g#', 'a#', 'd']) >>> c.quarterLength = 2 >>> c.augmentOrDiminish(0.25, inPlace=True) >>> c.quarterLength 0.5 >>> n = note.Note('g#') >>> n.augmentOrDiminish(-1) Traceback (most recent call last): music21.note.NoteException: scalar must be greater than zero >>> n = note.Note() >>> n.quarterLength = 3 >>> n2 = n.augmentOrDiminish(1/3, inPlace=False) >>> n2.quarterLength 1.0 >>> n.quarterLength 3.0 rz scalar must be greater than zeroN)rWr@deepcopyraugmentOrDiminish)rvscalarrposts rHrGeneralNote.augmentOrDiminishysQBz BC C D==&D 77? KrT) appoggiaturarcUSLa[R"U5nOUnURRUS9UlUSLaU$g)az Return a grace version of this GeneralNote >>> n = note.Note('G4', quarterLength=2) >>> n.duration.quarterLength 2.0 >>> n.duration.isGrace False >>> n.duration >>> n.duration.type 'half' >>> n.duration.components (DurationTuple(type='half', dots=0, quarterLength=2.0),) >>> ng = n.getGrace() >>> ng.duration.quarterLength 0.0 >>> ng.duration.isGrace True >>> ng.duration >>> ng.duration.type 'half' >>> ng.duration.components (DurationTuple(type='half', dots=0, quarterLength=0.0),) Appoggiaturas are still a work in progress. * Changed in v6: corrected spelling of `appoggiatura` keyword. >>> ng2 = n.getGrace(appoggiatura=True) >>> ng2.duration >>> ng2.duration.slash False Set inPlace to True to change the duration element on the Note. This can have negative consequences if the Note is in a stream. >>> r = note.Rest(quarterLength=0.5) >>> r.getGrace(inPlace=True) >>> r.duration F)rN)r@rrgetGraceDuration)rvrres rHgetGraceGeneralNote.getGracesK\ e  d#AAZZ00l0K e H rT)rrr r)rzDuration | NonerzNone | str | Lyric)rtie.Tie | None)rr )rr)rzstr | Lyric | Nonerrr)rr)rrrztuple[Pitch, ...])rIterable[Pitch]rr)rOrPrQrRrisNoteisRestrr NoteStyler__annotations__rrArrsrrrrrrrrrrrrrSrrs@rHrr/s8F FG%*__K"4*22o.JSC-` !I~,0)-#'(#''#'#'J("   ZZ2R2Rh \\77&"FY !% FY +/ FYP'SUt'SX ^^  49/d(-e66rTrc|^\rSrSr%SrSS0rS\S'SrS\S 'S S S .S%U4S jjjrS&S S .S'U4Sjjjjr S&Sjr \ S(Sj5r \ RS)Sj5r \ S(Sj5r\RS5r\ S*Sj5r\RS+Sj5r\ S,Sj5r\RS-Sj5rS,SjrS&S.SjjrS/S0Sjjr\ S1Sj5r\RS0Sj5r\ S2Sj5r\RS3Sj5r\SS .S4S!jj5r\S5S"j5rSS .S6S#jjrS$rU=r$)7riah Parent class for Note-like objects that are not rests; that is to say they have a stem, can be tied, and volume is important. Basically, that's a :class:`Note` or :class:`~music21.chord.Chord` (or their subclasses such as :class:`~music21.harmony.ChordSymbol`), or :class:`Unpitched` object. NotRest elements are generally not created on their own. It is a class that exists to store common functionality used by Note, Unpitched, and Chord objects. >>> nr = note.NotRest(storedInstrument=instrument.Ocarina()) >>> nr.stemDirection = 'up' * Changed in v9: beams is keyword only. Added storedInstrument keyword. beamszx A :class:`~music21.beam.Beams` object that contains information about the beaming of this note.rr)notehead noteheadFillnoteheadParenthesisrrrN)rstoredInstrumentc >[TU]"S0UD6 SUlSUlSUlSUlSUlUbXlO[R"5UlX l SUl g)Nr*Fr8rM) rrrs _notehead _noteheadFill_noteheadParenthesis_stemDirection_volumerrBeams_storedInstrument_chordAttached)rvrrrxrys rHrsNotRest.__init__sa $8$&(,*/!#0+/  JDJ=M48rTignoreAttributesc>[TU]US1S9n[R(a[R"[ U5nUR 5(aX3RlU$)Nrr ) rr_deepcopySubclassabler=rcastrhasVolumeInformationrclient)rvmemor!newrys rHr#NotRest._deepcopySubclassablesTg+DDTCU+V ??&&s+C  $ $ & & #JJ  rTc URUS9$)a, As NotRest objects have a Volume, objects, and Volume objects store refs to the client object, need to specialize deepcopy handling >>> import copy >>> n = note.NotRest() >>> n.volume = volume.Volume(velocity=50) >>> m = copy.deepcopy(n) >>> m.volume.client is m True >>> n.volume.client is n True )r')r#)rvr's rH __deepcopy__NotRest.__deepcopy__(s))t)44rTcUR$)aA Get or set the stem direction of this NotRest object. Valid stem direction names are found in note.stemDirectionNames (see below). >>> note.stemDirectionNames ('double', 'down', 'noStem', 'none', 'unspecified', 'up') >>> n = note.Note() By default, a Note's stemDirection is 'unspecified' meaning that it is unknown: >>> n.stemDirection 'unspecified' >>> n.stemDirection = 'noStem' >>> n.stemDirection 'noStem' The alias 'none' (the string) is the same as 'noStem' >>> n.stemDirection = 'none' >>> n.stemDirection 'noStem' >>> n.stemDirection = 'junk' Traceback (most recent call last): music21.note.NotRestException: not a valid stem direction name: junk Stem direction can be set explicitly to None to remove any prior stem information, same as 'unspecified': >>> n.stemDirection = None >>> n.stemDirection 'unspecified' )rrs rH stemDirectionNotRest.stemDirection:sJ"""rTc^UcSnO!US:XaSnOU[;a[SU35eXlg)Nr8r)r7z!not a valid stem direction name: )stemDirectionNamesrZr)rv directions rHr.r/as<  %I &  I 0 0"%Fyk#RS S'rTcUR$)a Get or set the notehead type of this NotRest object. Valid notehead type names are found in note.noteheadTypeNames (see below): >>> note.noteheadTypeNames ('arrow down', 'arrow up', 'back slashed', 'circle dot', 'circle-x', 'circled', 'cluster', 'cross', 'diamond', 'do', 'fa', 'fa up', 'inverted triangle', 'la', 'left triangle', 'mi', 'none', 'normal', 'other', 're', 'rectangle', 'slash', 'slashed', 'so', 'square', 'ti', 'triangle', 'x') >>> n = note.Note() >>> n.notehead = 'diamond' >>> n.notehead 'diamond' >>> n.notehead = 'junk' Traceback (most recent call last): music21.note.NotRestException: not a valid notehead type name: 'junk' )rrs rHrNotRest.noteheadks*~~rTcTUS;aSnOU[;a[SU<35eXlg)N)r)Nrpz not a valid notehead type name: )noteheadTypeNamesrZrrs rHrr4s1 & &E + +"%EeY#OP PrTcUR$)a Get or set the note head fill status of this NotRest. Valid note head fill values are True, False, or None (meaning default). "yes" and "no" are converted to True and False. >>> n = note.Note() >>> n.noteheadFill = 'no' >>> n.noteheadFill False >>> n.noteheadFill = 'filled' >>> n.noteheadFill True >>> n.noteheadFill = 'jelly' Traceback (most recent call last): music21.note.NotRestException: not a valid notehead fill value: 'jelly' )rrs rHrNotRest.noteheadFills&!!!rTcdUS;aSnO!US;aSnOUS;aSnO[SU<35eX lg)N)r)Ndefault)TfilledyesT)F notfillednoFz!not a valid notehead fill value: )rZrrvr boolValues rHrr8sG - -I - -I 0 0I"%Fui#PQ Q&rTcUR$)a Get or set the note head parentheses for this Note/Unpitched/Chord object. >>> n = note.Note() >>> n.noteheadParenthesis False >>> n.noteheadParenthesis = True >>> n.noteheadParenthesis True 'yes' or 1 equate to True; 'no' or 0 to False >>> n.noteheadParenthesis = 'no' >>> n.noteheadParenthesis False Anything else raises an exception: >>> n.noteheadParenthesis = 'blah' Traceback (most recent call last): music21.note.NotRestException: notehead parentheses must be True or False, not 'blah' )rrs rHrNotRest.noteheadParenthesiss0(((rTcRUS;aSnOUS;aSnO[SU<35eX lg)N)Tr<roT)Fr>rFz0notehead parentheses must be True or False, not )rZrr?s rHrrBs; $ $I & &I"%UV[U^#_` `$-!rTc URcgg)a4 Returns bool whether volume was set -- saving some time for advanced users (such as MusicXML exporters) that only want to look at the volume if it is already there. >>> n = note.Note() >>> n.hasVolumeInformation() False >>> n.volume >>> n.hasVolumeInformation() True FT)rrs rHr%NotRest.hasVolumeInformations << rTcURc6Uc[R"US9UlO[R"US9UlURn[R(aUceU$)N)r&)rrVolumer=r)rv forceClient volume_outs rH _getVolumeNotRest._getVolumesV << "%}}D9 %}}K@ \\ ??) ))rTTcUcSUlg[U[R5(a7U(a)URb[ R "U5nXlXlg[R"U5(a?U(a8UR5nUS:a[U5Ul g[U5Ul g[SU35e)Nroz"this must be a Volume object, not )rrrrGr&r@rrisNumrJfloatvelocityScalarrvelocity TypeError)rvr setClientvols rH _setVolumeNotRest._setVolumes =DL v}} - -<<+ MM%0E#  L \\% Y//#Cqy%*5\""5z @HI IrTc"UR5$)aP Get and set the :class:`~music21.volume.Volume` object of this object. Volume objects are created on demand. >>> n1 = note.Note() >>> n1.volume.velocity = 120 >>> n2 = note.Note() >>> n2.volume = 80 # can directly set a velocity value >>> s = stream.Stream() >>> s.append([n1, n2]) >>> [n.volume.velocity for n in s.notes] [120, 80] )rJrs rHrNotRest.volumes  rTc&URU5 gr)rTrs rHrrWs rTcUR$)a Get or set the :class:`~music21.instrument.Instrument` that should be used to play this note, overriding whatever Instrument object may be active in the Stream. (See :meth:`getInstrument` for a means of retrieving `storedInstrument` if available before falling back to a context search to find the active instrument.) >>> snare = note.Unpitched() >>> snare.storedInstrument = instrument.SnareDrum() >>> snare.storedInstrument >>> snare )rrs rHrNotRest.storedInstrument#s"%%%rTcUb8[US5(aSUR;a[S[U535eXlg)NclassSetzmusic21.instrument.InstrumentzExpected Instrument; got )hasattrr\rQrr)rvnewValues rHrrZ6sA   :667x?P?PP7X7GHI I!)rT) returnDefaultcgrrMrvr_s rH getInstrumentNotRest.getInstrument> rTcgrrMras rHrbrcErdrTcSSKJn URb UR$URURSS9nU(aUcUR"5$Ucg[ R "URU5$)a Retrieves the `.storedInstrument` on this `NotRest` instance, if any. If one is not found, executes a context search (without following derivations) to find the closest (i.e., active) instrument in the stream hierarchy. Returns a default instrument if no instrument is found in the context and `returnDefault` is True (default). >>> n = note.Note() >>> m = stream.Measure([n]) >>> n.getInstrument(returnDefault=False) is None True >>> dulcimer = instrument.Dulcimer() >>> m.insert(0, dulcimer) >>> n.getInstrument() is dulcimer True Overridden `.storedInstrument` is privileged: >>> picc = instrument.Piccolo() >>> n.storedInstrument = picc >>> n.getInstrument() is picc True Instruments in containing streams ARE found: >>> n.storedInstrument = None >>> m.remove(dulcimer) >>> p = stream.Part([m]) >>> p.insert(0, dulcimer) >>> n.getInstrument() is dulcimer True But not if the instrument is only found in a derived stream: >>> derived = p.stripTies() >>> p.remove(dulcimer) >>> derived.getInstruments().first() >>> n.getInstrument(returnDefault=False) is None True Electing to return a default generic `Instrument`: >>> n.getInstrument(returnDefault=True) rrNF)followDerivation)music21rrgetContextByClass Instrumentr=r$)rvr_rinstrument_or_nones rHrbrcLszh '  ,(( (!33  ! !E4; /7((* *  'vvj++-?@@rT)rrrrrrrr)rzbeam.Beams | Nonerinstrument.Instrument | Noner)rvrr'zdict[int, t.Any] | Noner!zset[str] | Nonerrr)r2z None | str)rz bool | None)rzbool | None | strr)rzbool | str | int)rHzNotRest | Noner volume.Volume)T)rz"None | volume.Volume | int | float)rrm)rrl)r^rl)r_zt.Literal[True]rzinstrument.Instrument)r_zt.Literal[False]rrl)r_rrrl)rOrPrQrRrrrrrsr#r+rr.rrrrr%rJrTrrrrbrSrrs@rHrrs>& ;!I~+ +/@D9'9$>99.=A AE $9 1> JV  5$$#$#L((,__""( ' '))2. .(04 ,%$J.!!  ]]&&$**8< %4 1   %5 6  -1=A%)=A6=A=ArTc^\rSrSr%SrSrSrS\S'/SQrSS S S .r S \S 'S'SSS.S(U4Sjjjjr Sr Sr Sr SrSrS'S)Sjjr\S*Sj5r\R&S+Sj5r\S*Sj5r\R&S+Sj5r\S,Sj5r\R&S-Sj5r\S.Sj5r\R&S/Sj5r\S0Sj5r\R&S1S j5rS!S".S#jr\S*S$j5rS%rS&rU=r$)2Noteia One of the most important music21 classes, a Note stores a single note (that is, not a rest or an unpitched element) that can be represented by one or more notational units -- so for instance a C quarter-note and a D# eighth-tied-to-32nd are both a single Note object. A Note knows both its total duration and how to express itself as a set of tied notes of different lengths. For instance, a note of 2.5 quarters in length could be half tied to eighth or dotted quarter tied to quarter. The first argument to the Note is the pitch name (with or without octave, see the introduction to :class:`music21.pitch.Pitch`). Further arguments can be specified as keywords (such as type, dots, etc.) and are passed to the underlying :class:`music21.duration.Duration` element. >>> n = note.Note() >>> n >>> n.pitch >>> n = note.Note('B-') >>> n.name 'B-' >>> n.octave is None True >>> n.pitch.implicitOctave 4 >>> n = note.Note(name='D#') >>> n.name 'D#' >>> n = note.Note(nameWithOctave='D#5') >>> n.nameWithOctave 'D#5' Other ways of instantiating a Pitch object, such as by MIDI number or pitch class are also possible: >>> note.Note(64).nameWithOctave 'E4' All keyword args that are valid for Duration or Pitch objects are valid (as well as those for superclasses, NotRest, GeneralNote, Music21Object): >>> n = note.Note(step='C', accidental='sharp', octave=2, id='csharp', type='eighth', dots=2) >>> n.nameWithOctave 'C#2' >>> n.duration **Equality and ordering** Two notes are equal if they pass all the equality tests for NotRest and their pitches are equal. Attributes that might change based on the wider context of a note (such as offset) are not compared. This test does not look at lyrics in establishing equality. (It may in the future.) >>> note.Note('C4') == note.Note('C4') True Enharmonics are not equal: >>> note.Note('D#4') == note.Note('E-4') False >>> note.Note('C4', type='half') == note.Note('C4', type='quarter') False Notes, like pitches, also have an ordering based on their pitches. >>> highE = note.Note('E5') >>> lowF = note.Note('F2') >>> otherHighE = note.Note('E5') >>> highE > lowF True >>> highE < lowF False >>> highE >= otherHighE True >>> highE <= otherHighE True Notice you cannot compare Notes w/ ints or anything that does not have a `.pitch` attribute. >>> highE < 50 Traceback (most recent call last): TypeError: '<' not supported between instances of 'Note' and 'int' Note also that two objects can be >= and <= without being equal, because only pitch-height is being compared in <, <=, >, >= but duration and other elements are compared in equality. >>> otherHighE.duration.type = 'whole' Now otherHighE is != highE >>> highE == otherHighE False But it is both >= and <= it: >>> highE >= otherHighE True >>> highE <= otherHighE True (The pigeonhole principle police have a bounty out on my head for this.) Tpitchrr)rrnameWithOctavezABoolean read-only value describing if this Note is a Note (True).zBBoolean read-only value describing if this Note is a Rest (False).zA :class:`~music21.pitch.Pitch` object containing all the information about the note's pitch. Many `.pitch` properties and methods are also made `Note` properties also)r r rqrrN)namerrc >[TU]"S0UD6 U Ub.[U[5(aXlO2[U40UD6UlO UbUnO U(dSn[U40UD6UlXRlg)NC4rM)rrrsrr rq_client)rvrqrsrrrxrys rHrs Note.__init__sq $8$  %''" "55H5 )%t0x0DJ" rTcUR$r)rsrs rHr|Note._reprInternal+s yyrTcbURUR:$![a [s$f=frrqAttributeErrorNotImplementedrvr+s rH__lt__ Note.__lt__// ":: + + "! ! " ..cbURUR:$![a [s$f=frr{r~s rH__gt__ Note.__gt__7rrcbURUR:*$![a [s$f=frr{r~s rH__le__ Note.__le__=/ "::, , "! ! "rcbURUR:$![a [s$f=frr{r~s rH__ge__ Note.__ge__CrrcHURU5nX"RlU$)z@ After doing a deepcopy of the pitch, be sure to set the client )r#rqrv)rvr'r(s rHr+Note.__deepcopy__Is#((.  rTc.URR$)z Return or set the pitch name from the :class:`~music21.pitch.Pitch` object. See `Pitch`'s attribute :attr:`~music21.pitch.Pitch.name`. rqrsrs rHrs Note.nameU zzrTc$XRlgrrrs rHrsr]  rTc.URR$)z Return or set the pitch name with octave from the :class:`~music21.pitch.Pitch` object. See `Pitch`'s attribute :attr:`~music21.pitch.Pitch.nameWithOctave`. rqrrrs rHrrNote.nameWithOctaveas zz(((rTc$XRlgrrrs rHrrris $) !rTc.URR$)zt Return or set the pitch step from the :class:`~music21.pitch.Pitch` object. See :attr:`~music21.pitch.Pitch.step`. rqsteprs rHr Note.stepmrrTc$XRlgrrrs rHrrurrTc.URR$)zx Return or set the octave value from the :class:`~music21.pitch.Pitch` object. See :attr:`~music21.pitch.Pitch.octave`. rqoctavers rHr Note.octaveys zz   rTc$XRlgrrrs rHrrs ! rTcUR4$)a Return the single :class:`~music21.pitch.Pitch` object in a tuple. This property is designed to provide an interface analogous to that found on :class:`~music21.chord.Chord` so that `[c.pitches for c in s.notes]` provides a consistent interface for all objects. >>> n = note.Note('g#') >>> n.nameWithOctave 'G#' >>> n.pitches (,) Since this is a Note, not a chord, from the list or tuple, only the first one will be used: >>> n.pitches = [pitch.Pitch('c2'), pitch.Pitch('g2')] >>> n.nameWithOctave 'C2' >>> n.pitches (,) The value for setting must be a list or tuple: >>> n.pitches = pitch.Pitch('C4') Traceback (most recent call last): music21.note.NoteException: cannot set pitches with provided object: C4 For setting a single one, use `n.pitch` instead. Don't use strings, or you will get a string back! >>> n.pitches = ('C4', 'D4') >>> n.pitch 'C4' >>> n.pitch.diatonicNoteNum Traceback (most recent call last): AttributeError: 'str' object has no attribute 'diatonicNoteNum' rprs rHr Note.pitchessP }rTcx[R"U5(aU(a USUlg[SU35e)Nrz)cannot set pitches with provided object: )r isListLikerqrWrs rHrrs3   U # #qDJ"KE7 ST TrTFrcSSKJn [U[R5(aUnO[R "U5nU(d[ R"U5nOUnURRUSS9 URRb[U[[R45(aURUR5nUbURH|nURR UR :XdM)URRR"URR":wdMcURR%SS9 M~ U(dSUR&lU$g)aa Transpose the Note 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. >>> a = note.Note('g4') >>> b = a.transpose('m3') >>> b >>> aInterval = interval.Interval(-6) >>> b = a.transpose(aInterval) >>> b >>> c = b.transpose(interval.GenericInterval(2)) >>> c >>> a.transpose(aInterval, inPlace=True) >>> a If the transposition value is an integer, take the KeySignature or Key context into account >>> s = stream.Stream() >>> s.append(key.Key('D')) >>> s.append(note.Note('F')) >>> s.append(key.Key('b-', 'minor')) >>> s.append(note.Note('F')) >>> s.show('text') {0.0} {0.0} {1.0} {1.0} >>> for n in s.notes: ... n.transpose(1, inPlace=True) >>> s.show('text') {0.0} {0.0} {1.0} {1.0} r)keyTrN transpose)rhrrr IntervalBaseIntervalr@rrqr accidentalrChromaticIntervalri KeySignaturealteredPitches pitchClassalter getEnharmonic derivationmethod)rvrrr intervalObjr ksContext alteredPitchs rHrNote.transposes^ eX22 3 3K"++E2K==&DD [$7 JJ ! ! -usH,F,F&GHH..s/?/?@I$$-$<$%= %0DOO "KrTc/nURURRS-5 URURR5 URS5 SR U5$)a Return the most complete representation of this Note, providing duration and pitch information. >>> n = note.Note('A-', quarterLength=1.5) >>> n.fullName 'A-flat Dotted Quarter Note' >>> n = note.Note('E~3', quarterLength=2) >>> n.fullName 'E-half-sharp in octave 3 Half Note' >>> n = note.Note('D', quarterLength=0.25) >>> n.pitch.microtone = 25 >>> n.fullName 'D (+25c) 16th Note' rqz Noterp)rrqrrr)rvmsgs rHr Note.fullNamesT( 4::&&,- 4==))* 7wws|rTcb0UlURbURR5 gg)z< Called by the underlying pitch if something changed there. N)_cacher clearCachers rH pitchChangedNote.pitchChangeds.    *    * * , +rT)rrqr)rqzstr | int | Pitch | Nonersrrrr)rvrorror)rr)rr)rr)r int | None)rrr )rr rr)rOrPrQrRrr rrrArrsr|rrrrr+rrsrrrrrrrrrrSrrs@rHrorosrfF*44AJVV@!I~.2"#',0 "*" ""* ""6"" " "  [[  ))** [[  !! ]]""''R ^^UU +0JX2--rTroc`^\rSrSrSrSrS S U4SjjjrSrS Sjr\ S Sj5r Sr U=r $) Unpitchedi)aM A General class of unpitched objects which appear at different places on the staff. Examples: percussion notation. >>> unp = note.Unpitched() Unpitched elements have :attr:`displayStep` and :attr:`displayOctave`, which shows where they should be displayed as if the staff were a 5-line staff in treble clef, but they do not have pitch objects: >>> unp.displayStep 'B' >>> unp.displayOctave 4 >>> unp.displayStep = 'G' >>> unp.pitch Traceback (most recent call last): AttributeError: 'Unpitched' object has no attribute 'pitch... Unpitched elements generally have an instrument object associated with them: >>> unp.storedInstrument = instrument.Woodblock() >>> unp Two unpitched objects compare the same if their instrument and displayStep and displayOctave are equal (and satisfy all the equality requirements of their base classes): >>> unp2 = note.Unpitched() >>> unp == unp2 False >>> unp2.displayStep = 'G' >>> unp2.storedInstrument = instrument.Woodblock() >>> unp == unp2 True >>> unp2.storedInstrument = instrument.Triangle() >>> unp == unp2 False ) displayStep displayOctaverc >[TU]"S0UD6 SUlSUlSUlU(a.[ U5nUR UlURUlgg)NBrM)rrrsrrrr rimplicitOctave)rv displayNamerx display_pitchrys rHrsUnpitched.__init__Xs[ $8$?C%("# !+.M,11D !.!=!=D  rTcdUR(dg[URR5$)Nrp)rreprinstrumentNamers rHr|Unpitched._reprInternalgs%$$--<<= =rTc>[URURS9$)z returns a pitch object that is the same as the displayStep and displayOctave. it will never have an accidental. >>> unp = note.Unpitched() >>> unp.displayStep = 'E' >>> unp.displayOctave = 4 >>> unp.displayPitch() )rr)r rrrs rH displayPitchUnpitched.displayPitchms$**43E3EFFrTc:UR5nUR$)zt Returns the `nameWithOctave` of the :meth:`displayPitch`. >>> unp = note.Unpitched('B2') >>> unp.displayName 'B2' )rrr)rvrs rHrUnpitched.displayNamezs))+ +++rT)rrrr)rr)rr r) rOrPrQrRrrrsr|rrrrSrrs@rHrr)sH(XN!% > > >> G , ,rTrc^\rSrSr%SrSrSrSSSSS S .rS \S 'SS SS.SU4Sjjjjr Sr \ SSj5r Sr U=r$)Restia Rests are represented in music21 as GeneralNote objects that do not have a pitch object attached to them. By default, they have length 1.0 (Quarter Rest) Calling :attr:`~music21.stream.Stream.notes` on a Stream does not get rests. However, the property :attr:`~music21.stream.Stream.notesAndRests` of Streams gets rests as well. >>> r = note.Rest() >>> r.isRest True >>> r.isNote False >>> r.duration.quarterLength = 2.0 >>> r.duration.type 'half' All Rests have the name property 'rest': >>> r.name 'rest' And their .pitches is an empty tuple >>> r.pitches () All arguments to Duration are valid in constructing: >>> r2 = note.Rest(type='whole') >>> r2.duration.quarterLength 4.0 Or they can just be specified in without a type, and they'll be evaluated automatically >>> r3, r4 = note.Rest('half'), note.Rest(2.0) >>> r3 == r4 True >>> r3.duration.quarterLength 2.0 Two rests are considered equal if their durations are equal. >>> r1 = note.Rest('quarter') >>> r2 = note.Rest('quarter') >>> r1 == r2 True >>> r1 != r2 False >>> r2.duration.quarterLength = 4/3 >>> r1 == r2 False A rest is never equal to a note. >>> r1 == note.Note() False TrestzBBoolean read-only value describing if this Rest is a Note (False).zLBoolean read-only value describing if this Rest is a Rest (True, obviously).znreturns "rest" always. It is here so that you can get `x.name` on all `.notesAndRests` objectszJnumber of lines/spaces to shift the note upwards or downwards for display.a;does this rest last a full measure or if it does, should it display itself as whole rest (or breve rest) and centered. Options are "auto" (default), False, True, and "always" "auto" is the default, where if the rest value happens to match the current time signature context (and there is no pickup or other padding), then display it as a whole rest, centered, etc. otherwise will display normally. False means do not display the rest as full measure whole rest, no matter what. This setting is often used by composers in very small time signatures such as 1/8, where a whole rest can look incongruous. True keeps the set duration, but will always display as a full measure rest even if it's not the length of the measure (generally a whole note unless the time signature is very long). "always" means that on export, the duration will (EVENTUALLY, not yet!) update automatically to match the time signature context and always display as a whole rest. "always" does not work yet -- functions as True. See examples in :meth:`music21.musicxml.m21ToXml.MeasureExporter.restToXml` )r r rs stepShift fullMeasurerrrauto)rrc >Ub*[U[5(a SU;aXS'O SU;aXS'[TU] "S0UD6 X lX0lg)NrrrM)rrrrrsrr)rvlengthrrrxrys rHrs Rest.__init__sR  &#&&6+A#)  0,2) $8$"&rTc URRR5n[U5S:aUR SS5$URR nU[ U5:Xa [ U5n[U5nUS3$)Nrqrql)rrlowerrreplacerrr)rv duration_namer ql_strings rHr|Rest._reprInternalss ..446 }  " ((c2 2,,BSW}WBI[# #rTc4URRS-$)z Return the most complete representation of this Rest, providing duration information. >>> r = note.Rest(quarterLength=1.5) >>> r.fullName 'Dotted Quarter Rest' >>> note.Rest(type='whole').fullName 'Whole Rest' z Rest)rrrs rHr Rest.fullNames}}%%//rT)rrr)rzstr | OffsetQLIn | Nonerrrz(t.Literal[True, False, 'auto', 'always']r)rOrPrQrRrr rsrrrsr|rrrSrrs@rHrrs;xF DW`;a !I~@04'#$IO ',' 'G '' $ 0 0rTrc(\rSrSrSrSrSrSrSrg) TestExternalizA These are tests that open windows and rely on external software TcSSKJn URS5nSUlUR(aUR 5 gg)z. Need to test direct note creation w/o stream rr zD-3g@N)rhr rorshow)rvr as rH testSingleTestExternal.testSingles1 ! IIe  99 FFH rTcSSKJn SSKJn UR5nSHCupEUR 5nXVlXFlSURlURU5 ME UR(aUR5 gg)Nrr)stream) zd-3g@zc#6g @za--5g?)f?)g3g?)zd##4g?rrr)zf#2r)zg-3gUUUUUU?)zd#6gUUUUUU?z#FF00FF) rhr rStreamrorrsrcolorrr)rvr rr pitchNameqLenbs rH testBasicTestExternal.testBasic%se " MMO "OI  A"OF%AGGM HHQK " 99 FFH rTrMN) rOrPrQrRrrrrrSrMrTrHrrs DrTrc\rSrSrSrSrg)r<i;c2SSKJn U"U[55 g)Nr) testCopyAll)music21.test.commonTestrrC)rvrs rHtestCopyAndDeepcopyTest.testCopyAndDeepcopy<s7D')$rTrMN)rOrPrQrRrrSrMrTrHr<r<;s%rTr<__main__)Cr __future__rr@typingr=rr>rhrrrmusic21.durationrr r r r music21.pitchr rrrrrcollections.abcrrmusic21.common.typesrrrrrr music21.stylerTypeVarr Environmentr?r6r1rIMusic21ExceptionrKrWrZLiteralrBrarProtoM21Object StyleMixinrc Music21ObjectrrrorrTestCaserr<rArOmainTestrMrTrHrs # % ??29%""#99^9=L&&v. >: \22  L11  |44 ))QR+' \)G " "E$4$4\)D r$$$rl dAkdAP U-7U-x [,[,~G0;G0Z"8$$"L%8  %D)Wk5 A  z TrT