3jk ddlmZddlmZmZddlZddlZddlZddl Z ddl m Z ddl m Z ddl m Z ddl mZddl mZdd l mZdd l mZdd l mZdd l mZdd l mZddl mZddl mZddlmZddlmZmZddlmZej<rddlm Z ddl m!Z!ddl"m#Z#ejHe%Z&dddd d7dZ'dddddddd d8dZ(dddddd d8dZ)dddejTfd d8d Z+dd!d8d"Z,d9d#Z- d: d;d$Z.dd(Z1ddddddddd) d?d*Z2 d@ dAd+Z3ddd, dBd-Z4ddd, dCd.Z5ddd/ dDd0Z6ddd1 dEd2Z7ejpdFd3Z9Gd4d5e jtZ;e| _/W~|r tA|d |jB_|s|Sycc}w) a Return a new Measure, or Stream of Measures, with beams applied to all notes. Measures with Voices will process voices independently. Note that `makeBeams()` is automatically called in show('musicxml') and other formats if there is no beaming information in the piece (see `haveBeamsBeenMade`). If `inPlace` is True, this is done in-place; if `inPlace` is False, this returns a modified deep copy. .. note:: Before Version 1.6, `inPlace` default was `True`; now `False` like most `inPlace` options in music21. Also, in 1.8, no tuplets are made automatically. Use makeTupletBrackets() See :meth:`~music21.meter.TimeSignature.getBeams` for the algorithm used. >>> aMeasure = stream.Measure() >>> aMeasure.timeSignature = meter.TimeSignature('4/4') >>> aNote = note.Note() >>> aNote.quarterLength = 0.25 >>> aMeasure.repeatAppend(aNote, 16) >>> bMeasure = aMeasure.makeBeams(inPlace=False) >>> for i in range(4): ... print(f'{i} {bMeasure.notes[i].beams!r}') 0 /> 1 /> 2 /> 3 /> This was formerly a bug -- we could not have a partial-left beam at the start of a beam group. Now merges across the archetypeSpan >>> aMeasure = stream.Measure() >>> aMeasure.timeSignature = meter.TimeSignature('4/4') >>> for i in range(4): ... aMeasure.append(note.Rest(quarterLength=0.25)) ... aMeasure.repeatAppend(note.Note('C4', quarterLength=0.25), 3) >>> bMeasure = aMeasure.makeBeams(inPlace=False).notes >>> for i in range(6): ... print(f'{i} {bMeasure[i].beams!r}') 0 /> 1 /> 2 /> 3 /> 4 /> 5 /> Grace notes no longer interfere with beaming: >>> m = stream.Measure() >>> m.timeSignature = meter.TimeSignature('3/4') >>> m.repeatAppend(note.Note(quarterLength=0.25), 4) >>> m.repeatAppend(note.Rest(), 2) >>> gn = note.Note(duration=duration.GraceDuration()) >>> m.insert(0.25, gn) >>> m.makeBeams(inPlace=True) >>> [n.beams for n in m.notes] [/>, , />, />, />] OMIT_FROM_DOCS TODO: inPlace=False does not work in many cases ?? still an issue? 2017 rr makeBeamszEcannot process a stream that is neither a Measure nor has no MeasuresN:cannot process beams in a Measure without a time signature)measureStartOffsetT)"music21rcoreCopyAsDerivation isinstanceMeasurelistgetElementsByClassr timeSignaturegetContextByClassr TimeSignature hasVoicesvoicesappend notesAndRestslenr isGraceremovesum quarterLengthr barDuration paddingLeft paddingRight highestTimegetBeams enumeratebeamsrBeamssetStemDirectionForBeamGroups streamStatus)srrrr returnObjmColllastTimeSignaturem noteGroupsv noteStreamdurListndsummeddurSumbarQLoffset beamsListi thisBeamss H/DATA/.local/lib/python3.12/site-packages/music21/stream/makeNotation.pyrr3sX **;7  )V^^, Y11&..AB(&((WY YOOWq/B/B5CVCV/W  $$,f,,PRR  ;;=XX!!!//"8"8":;   aoo446 7 %J:!#G::%%%%a(qzz*  7;7a!//7;}n t;|}t;||}|jA}||jB_"d |jB_#d }d}d} | jH}|dz|_%|jM|}||| j(d||ur||}t j ||_'|dk(rG||_|dkDr;|jP/|j'dt j |jPtS|D],}| jT}||_+|jYd|.|r|j[|j\j^dk(r| j(d|d|jY||||j\j^z }||k\rn|dz }c|j[t|}g}t!j"d}tS|D]^} || }|jN |jN}|ja|} | |j\j^z}!|jc|| |!d`|D]}"|"\}#}$}%}t|#|jdr|jc|#3d}&tS|D](} || }'|'d} |'d}!|'d}| |$cxkr|!ks#n&d}&n|&s<|$|%cxk(r|k(rnn|jg|#| j(d|#d|$d|%d|$| z }(|j,|#ur|(dk(rt|#t j"r||j'|(|#|j|j'|(|#|D]})|jc|)~ t|j | jHdz }*ti|j | jHD]@\} }| |*k7r |dvr||_5n |dvr||_5|s%t-j6|d |_B|s|jmd d |Sg|_7g|_8|j[|jr|}+n|j}+|+D]#}#|j'|ja|#|#%ycc}w)a Takes a stream and places all of its elements into measures (:class:`~music21.stream.Measure` objects) based on the :class:`~music21.meter.TimeSignature` objects placed within the stream. If no TimeSignatures are found in the stream, a default of 4/4 is used. If `inPlace` is True, the original Stream is modified and lost if `inPlace` is False, this returns a modified deep copy. Many advanced features are available: (1) If a `meterStream` is given, the TimeSignatures in this stream are used instead of any found in the Stream. Alternatively, a single TimeSignature object can be provided in lieu of the stream. This feature lets you test out how a group of notes might be interpreted as measures in a number of different metrical schemes. (2) If `refStreamOrTimeRange` is provided, this Stream or List is used to give the span that you want to make measures as necessary to fill empty rests at the ends or beginnings of Streams, etc. Say for instance you'd like to make a complete score from a short ossia section, then you might use another Part from the Score as a `refStreamOrTimeRange` to make sure that the appropriate measures of rests are added at either side. (3) If `innerBarline` is not None, the specified Barline object or string-specification of Barline style will be used to create Barline objects between every created Measure. The default is None. (4) If `finalBarline` is not None, the specified Barline object or string-specification of Barline style will be used to create a Barline objects at the end of the last Measure. The default is 'final'. The `searchContext` parameter determines whether context searches are used to find Clef and other notation objects. Here is a simple example of makeMeasures: A single measure of 4/4 is created from a Stream containing only three quarter notes: >>> sSrc = stream.Stream() >>> sSrc.append(note.Note('C4', type='quarter')) >>> sSrc.append(note.Note('D4', type='quarter')) >>> sSrc.append(note.Note('E4', type='quarter')) >>> sMeasures = sSrc.makeMeasures() >>> sMeasures.show('text') {0.0} {0.0} {0.0} {0.0} {1.0} {2.0} {3.0} Notice that the last measure is incomplete -- makeMeasures does not fill up incomplete measures. We can also check that the measure created has the correct TimeSignature: >>> sMeasures[0].timeSignature Now let's redo this work in 2/4 by putting a TimeSignature of 2/4 at the beginning of the stream and rerunning makeMeasures. Now we will have two measures, each with correct measure numbers: >>> sSrc.insert(0.0, meter.TimeSignature('2/4')) >>> sMeasuresTwoFour = sSrc.makeMeasures() >>> sMeasuresTwoFour.show('text') {0.0} {0.0} {0.0} {0.0} {1.0} {2.0} {0.0} {1.0} Let us put 10 quarter notes in a Part. >>> sSrc = stream.Part() >>> n = note.Note('E-4') >>> n.quarterLength = 1 >>> sSrc.repeatAppend(n, 10) After we run makeMeasures, we will have 3 measures of 4/4 in a new Part object. This experiment demonstrates that running makeMeasures does not change the type of Stream you are using: >>> sMeasures = sSrc.makeMeasures() >>> len(sMeasures.getElementsByClass(stream.Measure)) 3 >>> sMeasures.__class__.__name__ 'Part' Demonstrate what `makeMeasures` will do with `inPlace` = True: >>> sScr = stream.Score() >>> sPart = stream.Part() >>> sPart.insert(0, clef.TrebleClef()) >>> sPart.insert(0, meter.TimeSignature('3/4')) >>> sPart.append(note.Note('C4', quarterLength = 3.0)) >>> sPart.append(note.Note('D4', quarterLength = 3.0)) >>> sScr.insert(0, sPart) >>> sScr.makeMeasures(inPlace=True) >>> sScr.show('text') {0.0} {0.0} {0.0} {0.0} {0.0} {3.0} {0.0} {3.0} If after running makeMeasures you run makeTies, it will also split long notes into smaller notes with ties. Lyrics and articulations are attached to the first note. Expressions (fermatas, etc.) will soon be attached to the last note but this is not yet done: >>> p1 = stream.Part() >>> p1.append(meter.TimeSignature('3/4')) >>> longNote = note.Note('D#4') >>> longNote.quarterLength = 7.5 >>> longNote.articulations = [articulations.Staccato()] >>> longNote.lyric = 'hi' >>> p1.append(longNote) >>> partWithMeasures = p1.makeMeasures() >>> partWithMeasures is not p1 True >>> dummy = partWithMeasures.makeTies(inPlace=True) >>> partWithMeasures.show('text') {0.0} {0.0} {0.0} {0.0} {3.0} {0.0} {6.0} {0.0} {1.5} >>> allNotes = partWithMeasures.flatten().notes >>> allNotes[0].articulations [] >>> allNotes[1].articulations [] >>> allNotes[2].articulations [] >>> [allNotes[0].lyric, allNotes[1].lyric, allNotes[2].lyric] ['hi', None, None] * Changed in v6: all but first attribute are keyword only. * Changed in v7: now safe to call `makeMeasures` directly on a score containing parts. r)spannerrNStreamTrTF) returnDefaultrWsortByCreationTime4meterStream is neither a Stream nor a TimeSignature!)recurse makeMeasuresr"r!zDfailed to find TimeSignature in meterStream; cannot process Measuresztime signature z has no duration4/4)measuremStartmEndrerfrdzcannot place element z with start/end /z within any measures)regularN)9r$r\rhasPartLikeStreamscopydeepcopyr)rbr-flattenisSortedsortedr1r.getTimeSignaturesr&rr,r]insertr SpannerBundlerr+ClefgetElementsByOffsetfirstrZ offsetMapmaxendTimer9 __class__ derivationoriginmethodr'numbergetElementAtOrBeforer* keySignaturerangeVoiceid coreInsertcoreElementsChangedr6r5 elementOffsetr/Spanner storeAtEndr; rightBarlinesetDerivationMethod _elements _endElements),r@rUrVrWrXrYrZrr\rrerA substreamsrcObj voiceCounttsspannerBundleAccumclefObj offsetMapListxoMaxrefStreamHighestTimeposto measureCountrCrDthisTimeSignature voiceIndexrFpostLenpostMeasureListrPrf oneOffsetMapestartendmatchpostMeasureInfooNewsp lastIndex postSorteds, rRrbrbs`  F  I a(I"55h?I  " "{8L1>0<0<,4+/ # %@   ;;=FYY[F]]_F]]6*F' ..$/  K!4!4 5 #fmmo 1b!+v}}5(&((FH H!..0kk@V55dii@G++DII6JJ1MSSUmmFD9G$$&M}5}!AII}56' *FMM :#7#C#C #&';#< 4-. ;;=DDOO+DOO AL  FNN !# (<AO 1 AFA~!.."<DMM!..9:  +J AAD LLA ,  ! ! #  ( ( 6 6! ;(&((!"3!66FGI I 1  * * 8 88 9  A Lm p $iGO++E2 7^ G ?? & ! ##A&)55CCC 1*0(, . /& $0!5#z a )  % %a ( wA-a0O$X.F"6*D *A%% #t#",f,,+A3.>ugQseK_`bb v~ 66Q;  19Au':':;    HHT1  HHZ ' 'a 0u&z! B! D++FNN;#44!-#44!- ]]1d3AFC     >    ==JJA HHT''*A .G6s[)rVfillGapstimeRangeFromBarDurationr hideRestsc B ddlm}|s|jd}n|}d|j_|j j r:|j j D]}|jd|||||ry|S d dd} d} d} |rt||jr | | } nt||jrst||jr | | } nt|tjr}d} t|j|jr |j} | | | } nD|jr4tt!d |j#|jD} | dk(ri| |j$} nZt||j&r|j(} |j$} n+t+j,|rt/|} t1|} |j3rt5|j6} n.|jrt5|j#d } n|g} d}| D]}|j(}|j$}|j8xs|}t||jrp|xs|}|r | ||} |j6D]}|jd|||||j(}|j$}t/|j:j<| } || z }|dkDrHt?j@}||jB_||jD_#|jI| || |z }|dkDrHt?j@}||jB_||jD_#|jI|||sZ|jK}|n|D]h}t?j@}|jBj<|jB_||jD_#|jI|jL|j|jre|jOt>j@fd d}|j#|jD]#}|jQ||||j$z }%|dur|Sy)a) Given a Stream with an offset not equal to zero, fill with one Rest preceding this offset. This can be called on any Stream, a Measure alone, or a Measure that contains Voices. This method recurses into Parts, Measures, and Voices, since users are unlikely to want "loose" rests outside sub-containers. If `refStreamOrTimeRange` is provided as a Stream, this Stream is used to get min and max offsets. If a list is provided, the list assumed to provide minimum and maximum offsets. Rests will be added to fill all time defined within refStream. If `fillGaps` is True, this will create rests in any time regions that have no active elements. If `timeRangeFromBarDuration` is True, and the calling Stream is a Measure with a TimeSignature (or a Part containing them), the time range will be determined by taking the :meth:`~music21.stream.Measure.barDuration` and subtracting :attr:`~music21.stream.Measure.paddingLeft` and :attr:`~music21.stream.Measure.paddingRight`. This keyword takes priority over `refStreamOrTimeRange`. If both are provided, `timeRangeFromBarDuration` prevails, unless no TimeSignature can be found, in which case, the function falls back to `refStreamOrTimeRange`. If `inPlace` is True, this is done in-place; if `inPlace` is False, this returns a modified deepcopy. >>> a = stream.Stream() >>> a.insert(20, note.Note()) >>> len(a) 1 >>> a.lowestOffset 20.0 >>> a.show('text') {20.0} Now make some rests: >>> b = a.makeRests(inPlace=False) >>> len(b) 2 >>> b.lowestOffset 0.0 >>> b.show('text') {0.0} {20.0} >>> b[0].duration.quarterLength 20.0 Same thing, but this time, with gaps, and hidden rests: >>> a = stream.Stream() >>> a.insert(20, note.Note('C4')) >>> a.insert(30, note.Note('D4')) >>> len(a) 2 >>> a.lowestOffset 20.0 >>> a.show('text') {20.0} {30.0} >>> b = a.makeRests(fillGaps=True, inPlace=False, hideRests=True) >>> len(b) 4 >>> b.lowestOffset 0.0 >>> b.show('text') {0.0} {20.0} {21.0} {30.0} >>> b[0].style.hideObjectOnPrint True Now with measures: >>> a = stream.Part() >>> a.insert(4, note.Note('C4')) >>> a.insert(8, note.Note('D4')) >>> len(a) 2 >>> a.lowestOffset 4.0 >>> a.insert(0, meter.TimeSignature('4/4')) >>> a.makeMeasures(inPlace=True) >>> a.show('text', addEndTimes=True) {0.0 - 0.0} {0.0 - 0.0} {0.0 - 0.0} {4.0 - 5.0} {0.0 - 1.0} {8.0 - 9.0} {0.0 - 1.0} {1.0 - 1.0} >>> a.makeRests(fillGaps=True, inPlace=True) >>> a.show('text', addEndTimes=True) {0.0 - 4.0} {0.0 - 0.0} {0.0 - 0.0} {0.0 - 4.0} {4.0 - 8.0} {0.0 - 1.0} {1.0 - 4.0} {8.0 - 12.0} {0.0 - 1.0} {1.0 - 4.0} {4.0 - 4.0} * Changed in v6: all but first attribute are keyword only. * Changed in v7: - `inPlace` defaults False. - Recurses into parts, measures, voices. - Gave priority to `timeRangeFromBarDuration` over `refStreamOrTimeRange`. * Changed in v8: scores (or other streams having parts) edited `inPlace` return `None`. rr makeRestsNT)rrrrVrcd}||jj}n||jj}|)||jz}||jz}t |}t |dS)zd Needed for timeRangeFromBarDuration. Returns 0.0 if no meter can be found. r")r6r5r7r8rrv)rDrrs rRoHighTargetForMeasurez(makeRests..oHighTargetForMeasure^sg >>>//D ]==..D = AMM !D ANN "D$zmakeRests..s%5a ++5as "r')classFilterListr)NN)rDzstream.Measure | Nonerzmeter.TimeSignature | Nonereturnr))r$rr%r?tupletsiterpartsrr&r'rrr, activeSite hasMeasuresrr4r)r9r] lowestOffsetr isIterableminrvr-r(r.r*r6r5rRestr stylehideObjectOnPrintrpfindGapsrNmakeTiessetElementOffset)r@rVrrrrrrA inner_partr oLowTarget oHighTarget maybe_measurebundlerC componentoLowoHigh ts_or_measure inner_voiceqLenr gapStreamraccumulatedTimerDs rRrrsU~ **;7  &*I"~~#..*00J  !#%9)A ! 1  "&'+  $ (JK i 0/)5Q5QRXR`R`5a%"K c  '#//K ,fmm <-::J.::K   3 412J23Ki&&'    i229=>26 %%%%%33H7H i 0-:M'3I?PQ (// %%d/709;H?W &( 0))D))Em77EE{SKj  !8 A'+AJJ $(1AGG %   Z +U" !8 A'+AJJ $(1AGG %   UA & !**,I$"A A/0zz/G/GAJJ,09AGG-$$QXXq1 #YdDII<F--fnn=A  & &q/ : q}} ,O>drrUrdisplayTiedAccidentalsrc"ddlm}|s|jd}n|}|s|jdt j |s|g}t ||jrC|jD]}|j|d|||stjt|Sy|jr:|j|jD]}|j|d|||s|Sy|j!s|jd||j#dd }nJ|sHt%j&t(j*d t(j,} |j/d| d} t1|j|j2} | t5| kr7| | } |j7| j8} | d zt5| kr | | d z}d }nQ|j2}| j8}|| j:j<z|_| j>d z|_d}|jArd}nd }| j:j<}| jAr| jB}d}n| g}d }|D]@}|D]7}|jDjG|r |jH}|jK|}tM||jNj<z}||z }|dkrj||k\rp||z }|jQ|d| \}}|rD|r2t |tRs|jB|}nA|jU|}n/|jBd}n|rtW||jBd}nd}||}|j/d||s |j/|j8|| jY|:C| d z } | t5| kr7|j|j2D]}|j[d|s|Sy)a Given a stream containing measures, examine each element in the Stream. If the element's duration extends beyond the measure's boundary, create a tied entity, placing the split Note in the next Measure. Note that this method assumes that there is appropriate space in the next Measure: this will not shift Note objects, but instead allocate them evenly over barlines. If `inPlace` is True, this is done in-place; if `inPlace` is False, this returns a modified deep copy. Put a 12-quarter-note-long note into a Stream w/ 4/4 as the duration. >>> d = stream.Stream() >>> d.insert(0, meter.TimeSignature('4/4')) >>> n = note.Note('C4') >>> n.quarterLength = 12 >>> d.insert(0, n) >>> d.show('text') {0.0} {0.0} After running makeMeasures, we get nice measures, a clef, but only one way-too-long note in Measure 1: >>> x = d.makeMeasures() >>> x.show('text') {0.0} {0.0} {0.0} {0.0} {4.0} {8.0} {0.0} >>> n2 = x.measure(1).notes[0] >>> n2.duration.quarterLength 12.0 >>> n2 is n False But after running makeTies, all is good: >>> x.makeTies(inPlace=True) >>> x.show('text') {0.0} {0.0} {0.0} {0.0} {4.0} {0.0} {8.0} {0.0} {4.0} >>> m = x.measure(1).notes[0] >>> m.duration.quarterLength 4.0 >>> m is n False >>> m.tie >>> x.measure(2).notes[0].tie >>> x.measure(3).notes[0].tie Same experiment, but with rests: >>> d = stream.Stream() >>> d.insert(0, meter.TimeSignature('4/4')) >>> r = note.Rest() >>> r.quarterLength = 12 >>> d.insert(0, r) >>> x = d.makeMeasures() >>> x.makeTies(inPlace=True) >>> x.show('text') {0.0} {0.0} {0.0} {0.0} {4.0} {0.0} {8.0} {0.0} {4.0} Notes: uses base.Music21Object.splitAtQuarterLength() once it has figured out what to split. * Changed in v4: inPlace = False by default. * Changed in v6: all but first attribute are keyword only. * New in v7: `classFilterList` acts as a filter on what elements will be operated on (i.e. have durations split and/or ties made). The default `(note.GeneralNote,)` includes Notes, Chords, and Rests. Here will we split and make ties only on Notes, leaving the too-long rest in measure 1 alone. >>> p = stream.Part() >>> p.append(meter.TimeSignature('2/4')) >>> p.insert(0.0, note.Rest(quarterLength=3.0)) >>> p.insert(3.0, note.Note(quarterLength=3.0)) >>> p.makeMeasures(inPlace=True) >>> p.makeTies(classFilterList=[note.Note], inPlace=True) >>> p.show('text', addEndTimes=True) {0.0 - 3.0} {0.0 - 0.0} {0.0 - 0.0} {0.0 - 3.0} {2.0 - 4.0} {1.0 - 2.0} {4.0 - 6.0} {0.0 - 2.0} {2.0 - 2.0} >>> p.measure(3).notes[0].tie OMIT_FROM_DOCS configure ".previous" and ".next" attributes Previously a note tied from one voice could not make ties into a note in the next measure outside of voices. Fixed May 2017 >>> p = stream.Part() >>> m1 = stream.Measure(number=1) >>> m2 = stream.Measure(number=2) >>> m1.append(meter.TimeSignature('1/4')) >>> v1 = stream.Voice(id='v1') >>> v2 = stream.Voice(id=2) # also test problems with int voice ids >>> n1 = note.Note('C4') >>> n1.tie = tie.Tie('start') >>> n2 = note.Note('D--4') >>> n2.tie = tie.Tie('start') >>> v1.append(n1) >>> v2.append(n2) >>> n3 = note.Note('C4') >>> n3.tie = tie.Tie('stop') >>> m2.append(n3) >>> m1.insert(0, v1) >>> m1.insert(0, v2) >>> p.append([m1, m2]) >>> p2 = p.makeTies() test same thing with needed makeTies: >>> p = stream.Part() >>> m1 = stream.Measure(number=1) >>> m2 = stream.Measure(number=2) >>> m1.append(meter.TimeSignature('1/4')) >>> v1 = stream.Voice(id='v1') >>> v2 = stream.Voice(id=2) # also test problems with int voice ids >>> n1 = note.Note('C4', quarterLength=2) >>> n2 = note.Note('B4') >>> v1.append(n1) >>> v2.append(n2) >>> m1.insert(0, v1) >>> m1.insert(0, v2) >>> p.append(m1) >>> p.insert(1.0, m2) >>> p2 = p.makeTies() >>> p2.show('text') {0.0} {0.0} {0.0} {0.0} {0.0} {0.0} {1.0} {0.0} >>> for n in p2.recurse().notes: ... print(n, n.tie) None Be helpful and wrap `classFilterList` in a list if need be. >>> m = stream.Measure([note.Note(quarterLength=8.0)]) >>> m.insert(0, meter.TimeSignature('4/4')) >>> p = stream.Part([m]) >>> p.makeTies(inPlace=True, classFilterList='Note') >>> len(p.getElementsByClass(stream.Measure)) 2 >>> p.recurse().last().tie rrrzcannot process an empty streamTrNz(cannot process a stream without measuresF)r_rWrgr!) retainOriginrr).r$rr%rrrr&Opusscoresrtcastrrir)r]rrorr,r meterNumeratormeterDenominatorBeatTyperpr(r'r1r}rNr6r5r|r-r.classSet isdisjointrrrr splitAtQuarterLengthintgetElementByIdmoveNotesToVoicesr/flattenUnnecessaryVoices)r@rUrrrrrAsubScoreprmCount measureListrDactiveTSmNextmNextAddmOffsetmNextHasVoicesrfr mHasVoicesrFrvIdeOffseteEndovershotqLenWithinMeasureeRemaindstrds rRrrsL **:6  $f$$%EFF   _ -*+)V[[)!((H   +&*5K.=  ) 66*i0 0##%--fmm>> n = note.Note() >>> n.duration.quarterLength = 1/3 >>> s = stream.Stream() >>> s.insert(0, meter.TimeSignature('2/4')) >>> s.repeatAppend(n, 6) >>> tupletTypes = [x.duration.tuplets[0].type for x in s.notes] >>> tupletTypes [None, None, None, None, None, None] >>> stream.makeNotation.makeTupletBrackets(s, inPlace=True) >>> tupletTypes = [x.duration.tuplets[0].type for x in s.notes] >>> tupletTypes ['start', None, 'stop', 'start', None, 'stop'] The tuplets must already be coherent. See :class:`~music21.duration.TupletFixer` for how to get that set up. TODO: does not handle nested tuplets * Changed in v1.8: `inPlace` is False by default. * Changed in v7: Legacy behavior of taking in a list of durations removed. makeTupletBracketsNr!z3got multi-tuplet duration; cannot yet handle this. rr" startStopFrstopT)r%r0r r2r/rr1 environLocalwarnr;rr5typebrackettotalTupletLengthr?)r@r durationListrArI tupletMapdur tupletListcompletionCountcompletionTargettupletPreviousrP tupletObj tupletNexts rRrrYs6-/L **+?@   $ $ ::   AJJ'% GII[[    dC[ ) _q    Ej^T    dC[ )   jmS1 2!$O&*+/N(3 Is s9~! !"1q5)!,J J  $_s7H7H%HIO%)9)A%%0IN(-I%&)O%,IN'0'B'B'D$#:J'J!' #' "% + 0F!% "i 4l&*I"  rc|jd|j_fd}|D]O}|jrjt |*t |dr ||?j|QS)a- Realize all ornaments on a stream Creates a new stream that contains all realized ornaments in addition to other elements in the original stream. >>> s1 = stream.Stream() >>> m1 = stream.Measure() >>> m1.number = 1 >>> m1.append(meter.TimeSignature('4/4')) >>> n1 = note.Note('C4', type='whole') >>> n1.expressions.append(expressions.Mordent()) >>> m1.append(n1) >>> m2 = stream.Measure() >>> m2.number = 2 >>> n2 = note.Note('D4', type='whole') >>> m2.append(n2) >>> s1.append(m1) >>> s1.append(m2) >>> for x in s1.recurse(includeSelf=True): ... x >>> s2 = stream.makeNotation.realizeOrnaments(s1) >>> for x in s2.recurse(includeSelf=True): ... x TODO: does not work for Gapful streams because it uses append rather than the offset of the original realizeOrnaments)derivationMethodc&d}|jD]i}t|ds|j|\}}}d}|D]}j||j||D]}j|k|durj|yy)NFrealizeT)r hasattrr r/) innerElementelementHasBeenRealizedexpbeforeduringafterrI newStreams rRrealizeElementExpressionsz3realizeOrnaments..realizeElementExpressionss!&++C3 *$'KK $= !FFE%) "  #!  (  #, "U *   \ * +rr ) cloneEmptyrNisStreamr/rr )r@relementrs @rRrrsyX .@ AIxxI+&      -g6 7w .)'2  ) rcddlm}|}t|j|}|D]4}|j |j |||j |6|j d|y)zH Move notes into voices. Happens inplace always. Returns None r)rN)music21.streamrr(r)rprr3)sourcerrraffectedElementsrs rRrr"se % 'CF55oFG  6''*A. a MM!Srczt|tjsyt}t|tj r t |}n|g}|D]g}|j3|jjdk(st|tjrC|j|jji|S)a helper method for makeAccidentals to get the tie pitch set (or None) from the prior >>> n1 = note.Note('C4') >>> n2 = note.Note('D4') >>> n2.tie = tie.Tie('start') >>> n3 = note.Note('E4') >>> n3.tie = tie.Tie('stop') >>> n4 = note.Note('F4') >>> n4.tie = tie.Tie('continue') >>> c = chord.Chord([n1, n2, n3, n4]) >>> tps = stream.makeNotation.getTiePitchSet(c) >>> isinstance(tps, set) True >>> sorted(tps) ['D4', 'F4'] Non tie possessing objects return None >>> r = bar.Repeat() >>> stream.makeNotation.getTiePitchSet(r) is None True Note or Chord without ties, returns an empty set: >>> n = note.Note('F#5') >>> stream.makeNotation.getTiePitchSet(n) set() >>> pChord = percussion.PercussionChord([note.Unpitched('D4'), note.Note('E5')]) >>> stream.makeNotation.getTiePitchSet(pChord) set() Rest returns None >>> r = note.Rest() >>> stream.makeNotation.getTiePitchSet(r) is None True Nr) r&rNotRestsetr ChordBaser(tier UnpitchedaddrnameWithOctave)prior tiePitchSet previousNotesrIs rRgetTiePitchSetr%3sT eT\\ *%K%)U   55=AEEJJ&0Jq$..4Q ../ r) pitchPastpitchPastMeasureuseKeySignaturealteredPitchescautionaryPitchClass cautionaryAlloverrideStatuscautionaryNotImmediateRepeatr#c nddlm} m} d} g} t|tj r3|} | j jDcgc]}|j} }t|j| }t|D]g\}}|dkDr|j%||dz jt||dz z}nA| r?||dz jt||dz zDcgc]}|j| vr|}} ||dz tjd}t!|} | [|jO|jj jDcgc]}|j}}| Dchc] }||vs| } }|j=|j} | j jDcgc]}|j} }|j'||| |d||d|||  jt|| rd|j(_yycc}wcc}wcc}wcc}w#t"t$f$rYwxYwcc}w) a: Makes accidentals in place on a stream that contains Measures. Helper for Stream.makeNotation and Part.makeAccidentals. The function walks measures in order to update the values for the following keyword arguments of :meth:`~music21.stream.base.makeAccidentals` and calls that method on each Measure. (For this reason, the values supplied for these arguments in the method signature will be used on the first measure only, or in the case of `useKeySignature`, not at all if the first measure contains a `KeySignature`.):: pitchPastMeasure useKeySignature tiePitchSet Operates on the measures in place; make a copy first if this is not desired. * Changed in v8: the Stream may have other elements besides measures and the method will still work. r)r'r]FNr!T) r&r'r(r)searchKeySignatureByContextr*r+rr,r-r#)rr'r]r&r KeySignaturegetScalepitchesnamer(r)r;r~ornamentalPitchesrrr% IndexErrorrmakeAccidentalsr? accidentals)r@r&r'r(r)r*r+r,r-r#r'r]ksLastksLastDiatonicr measuresOnlyrPrDpreviousNoteOrChord ksNewDiatonictps rRmakeAccidentalsInMeasureStreamr?ls[B/ %*F "N/3#3#34 *0//*;*C*CD*CQ!&&*CD"&q';';G'D"EL,'1 q5~~% Q'//2CLQRUVQVDW2XX! !Q'//2CLQRUVQVDW2XX$5X+,vv^3%&X!$5 &21q5&9$,,&G&K#,-@A *q~~/I67^^5L5L5N5V5V$W5VQVV5VM$W0;"S "r]?R2 K"S >> %^^F.4oo.?.G.GH.Gaff.GNH -")(-!5'))E#  E(^!V%)"eE"$5%X"S0   IsIH $H>AHH,H2 H<HH6H2 HH/.H/c.ddlm}g}|jD]}}t||r|j t |*t |ds7|jD]8}t|tjs|j |j :|S)aP Returns all ornamental :class:`~music21.pitch.Pitch` objects found in any ornaments in notes/chords in the stream (and substreams) as a Python list. Very much like the pitches property, except that instead of returning all the pitches found in notes and chords, it returns the ornamental pitches found in the ornaments on the notes and chords. If you want a list of _all_ the pitches in a stream, including the ornamental pitches, you can call s.pitches and makeNotation.ornamentalPitches(s), and then combine the two resulting lists into one big list. r)r]r ) rr]elementsr&extendr5r r Ornament)r@r]rrorns rRr5r5sw& D ZZ a KK)!, - Q &}}c;#7#78KK 5 56%  Kr)r&r'otherSimultaneousPitchesr)r*r+r,r-c |jD]e} t| tjs| j|| js<| j ||||||||W|| jz }gy)a Makes accidentals for the ornamental pitches for any Ornaments on noteOrChord. This is very similar to the processing in pitch.updateAccidentalDisplay, except that there is no tie processing, since ornamental pitches cannot be tied. )r&r'r)r*r+r,r-N)r r&rCresolveOrnamentalPitchesr5updateAccidentalDisplay) noteOrChordr&r'rEr)r*r+r,r-rDs rRmakeOrnamentalAccidentalsrJs"&&#{334  $$[1$$  ##-)!5'))E $ G  .. .I%'rc#vK|r|jn|j}g}d}|jD]y}d}|jr6|jj dr|jj d}|dk(rd}|r|j ||dk(r |g}d}o|rr|ru|g{|r|yyw)a Generator that yields a List of NotRest objects that fall within a beam group. If `skipNoBeams` is True, then NotRest objects that have no beams are skipped. Recurse is True by default. Unclosed beam groups (like start followed by a Rest before a stop), currently will continue to yield until the first stop, but this behavior may change at any time in the future as beaming-over-barlines with multiple voices or beaming across Parts or PartStaffs is supported. >>> from music21.stream.makeNotation import iterateBeamGroups >>> sc = converter.parse('tinyNotation: 3/4 c8 d e f g4 a4 b8 a16 g16 f4') >>> sc.makeBeams(inPlace=True) >>> for beamGroup in iterateBeamGroups(sc): ... print(beamGroup) [, ] [, ] [, , ] >>> for beamGroup in iterateBeamGroups(sc, skipNoBeams=False): ... print(beamGroup) [, ] [, ] [] [] [, , ] [] If recurse is False, assumes a flat Score: >>> for beamGroup in iterateBeamGroups(sc, recurse=False): ... print(beamGroup) >>> for beamGroup in iterateBeamGroups(sc.flatten(), recurse=False): ... print(beamGroup) [, ] [, ] [, , ] * New in v6.7. FNr!rTr)rarnotesr< getByNumbergetTypeByNumberr/)r@ skipNoBeamsraiteratorcurrent_beam_group in_beam_groupel first_el_types rRiterateBeamGroupsrU s`IPUVU[U[U]H-/Mnn"& 88,,Q/HH44Q7M G # M   % %b ) F "$ $!# !M]$J   sB$B9'B9*B9 setNewStems overrideConsistentStemDirectionscFt|ddD]}t|||y)a Find all beam groups and set all the `stemDirection` tags for notes/chords in a beam group to point either up or down. If any other stem direction is encountered ('double', 'noStem', etc.) that note is skipped. If all notes have the same (non-unspecified) direction, then they are left alone unless `overrideConsistentStemDirections` is True (default: False). For instance, :meth:`~music21.clef.Clef.getStemDirectionForPitches` might say "down" but if everything in the beamGroup is either if `setANewStems` is True (as by default), then even notes with stemDirection of 'unspecified' get a stemDirection. The method currently assumes that the clef does not change within a beam group. This assumption may change in the future without notice. Operates in place. Run `copy.deepcopy(s)` beforehand for a non-inPlace version. * New in v6.7. T)rOrarVN)rUsetStemDirectionOneGroup)r@rWrX beamGroups rRr>r>Qs)6'qdDI  #-M Jrc|sy|Dchc]}|jdvr |j}}d|vrd}nt|dkrd}nd}|djtj}|y|}g}|D]}|j |j |sy|j|} |D]+}|j} | dk(r|s| dvr|s|r | dvs%| |_-ycc}w) z Helper function to set stem directions for one beam group (or perhaps a beat, etc.) See setStemDirectionForBeamGroups for detailed information. * New in v6.7. N)updown unspecifiedr_FTr)r]r^) stemDirectionr1r+rrrrBr3getStemDirectionForPitches) grouprWrXrIstem_directionshas_consistent_stem_directionsoptional_clef_context clef_context pitchListgroupStemDirection noteDirections rRrZrZts 05L1//-JJOL').& _  !)-&).&-2!H,F,Ftyy,Q$3L#%I # %@@K  M )+ ~-60  ; ;0AO/Ls!C)raaddTiesc|r|jdd}n|g}|D]}t|j}d}d}|D]}|jjrf|jj rP|||jjdk(r2|jjd}t |j|z}nd}d}t |jjdj|z } | dk(rd}d}|jtjd} | r1| jt |j|jzk7r| s| jj s2d| cxkr| jksInM| j| |\} } |j| j| z| y)a Split notes or rests if doing so will complete any incomplete tuplets. The element being split must have a duration that exceeds the remainder of the incomplete tuplet. The first note is edited; the additional notes are inserted in place. (Destructive edit, so make a copy first if desired.) Relies on :meth:`~music21.stream.base.splitAtQuarterLength`. * New in v8. >>> from music21.stream.makeNotation import splitElementsToCompleteTuplets >>> s = stream.Stream( ... [note.Note(quarterLength=1/3), note.Note(quarterLength=1), note.Note(quarterLength=2/3)] ... ) >>> splitElementsToCompleteTuplets(s) >>> [el.quarterLength for el in s.notes] [Fraction(1, 3), Fraction(2, 3), Fraction(1, 3), Fraction(2, 3)] >>> [el.tie for el in s.notes] [None, , , None] With `recurse`: >>> m = stream.Measure([note.Note(quarterLength=1/6)]) >>> m.insert(5/6, note.Note(quarterLength=1/6)) >>> m.makeRests(inPlace=True, fillGaps=True) >>> p = stream.Part([m]) >>> splitElementsToCompleteTuplets(p, recurse=True) >>> [el.quarterLength for el in p.recurse().notesAndRests] [Fraction(1, 6), Fraction(1, 3), Fraction(1, 3), Fraction(1, 6)] T streamsOnly includeSelfNr"r)activeSiteOnly)rk)rar(r0r rexpressionIsInferredrr5rnextr GeneralNoterNrrp) r@rarkrP container general_notes last_tupletpartial_tuplet_sumgnql_to_completenext_gnunused_left_edited_in_placerights rRsplitElementsToCompleteTupletsr}sN9949@3 Y445 ,0 '*B ##KK44 (K2;;;N;Nq;Q,Q kk11!4 %+B,<,>VBII@P@P4P-QQ7++@@~=(=(===9@9U9U&:V:96/$$W^^n%DeL3 rra onlyIfTiedctj|}|r|jdd}n|g}|D]}|j|jD]}|j ||j |r |j|n|jr|j|j|jk(sn|jx}rmd|j_|d}|ddD]} |j!| |jj#d|j_|j|_|j!y#t$rYwxYw) a Locate consecutive notes or rests in `s` (or its substreams if `recurse` is True) that are unnecessarily expressed as tuplets and replace them with a single element. These groups must: - be consecutive (with respect to :class:`~music21.note.GeneralNote` objects) - be all rests, or all :class:`~music21.note.NotRest`s with equal `.pitches` - all have :attr:`~music21.duration.Duration.expressionIsInferred` = `True`. - not begin during a tuplet - sum to the tuplet's total length - if `NotRest`, all must be tied (if `onlyIfTied` is True) The groups are consolidated by prolonging the first note or rest in the group and removing the subsequent elements from the stream. (Destructive edit, so make a copy first if desired.) * New in v8. >>> s = stream.Stream() >>> r = note.Rest(quarterLength=1/6) >>> s.repeatAppend(r, 5) >>> s.insert(5/6, note.Note(duration=r.duration)) >>> from music21.stream.makeNotation import consolidateCompletedTuplets >>> consolidateCompletedTuplets(s) >>> [el.quarterLength for el in s.notesAndRests] [0.5, Fraction(1, 6), Fraction(1, 6), Fraction(1, 6)] `onlyIfTied` is `True` by default: >>> s2 = stream.Stream() >>> n = note.Note(quarterLength=1/3) >>> s2.repeatAppend(n, 3) >>> consolidateCompletedTuplets(s) >>> [el.quarterLength for el in s2.notesAndRests] [Fraction(1, 3), Fraction(1, 3), Fraction(1, 3)] >>> consolidateCompletedTuplets(s2, onlyIfTied=False) >>> [el.quarterLength for el in s2.notesAndRests] [1.0] Does nothing if tuplet definitions are not the same. (In which case, see :class:`~music21.duration.TupletFixer` instead). >>> s3 = stream.Stream([note.Rest(quarterLength=1/3), note.Rest(quarterLength=1/6)]) >>> for my_rest in s3.notesAndRests: ... print(my_rest.duration.tuplets) (,) (,) >>> consolidateCompletedTuplets(s) >>> [el.quarterLength for el in s3.notesAndRests] [Fraction(1, 3), Fraction(1, 6)] Does nothing if there are multiple (nested) tuplets. )rTrmFrr!N)r TupletSearchStateraresetr0advance_tuplet_sumshould_be_testedr/ ValueErrorto_consolidatemark_no_consolidationrwcompletion_targetget_consolidatable_notesr?rr3clearr5) r@rar search_staterPrtrxconsolidatableNotesfirst_note_in_group other_notes rRconsolidateCompletedTupletsrsNz--DL9949@3 ))B  + +B /,,R0 ''+,,224..,2P2PP*6*O*O*QQ&Q5:I**2*=a*@'&9!"&= !((4'>'00668;='0088D8V8V'5""$-*"s8E E! E!c#Ki}|jD]?}|j#|jj|t|<2d|t|<A d|jD]}|j+|j t|d|j_:|j t|ddusXt j d|_d|j_y#|jD]}|j+|j t|d|j_:|j t|ddusXt j d|_d|j_wxYww)a. Restore accidental displayStatus on a Stream after an (inPlace) operation that sets accidental displayStatus (e.g. a transposition). Note that you should not do this unless you know that the displayStatus values will still be valid after the operation. >>> sc = corpus.parse('bwv66.6') >>> intv = interval.Interval('P8') >>> classList = (key.KeySignature, note.Note) >>> with stream.makeNotation.saveAccidentalDisplayStatus(sc): ... sc.transpose(intv, inPlace=True, classFilterList=classList) * New in v9. NFTr)r3 accidental displayStatusrgetr Accidental)r@displayStatusesrs rRsaveAccidentalDisplayStatusrQs4 -/O YY << #%&\\%?%?OBqE " !&1  2 A||'-<-@-@A-M *""2a5%0D8$//2 -1 * A||'-<-@-@A-M *""2a5%0D8$//2 -1 * s,AFC*A#F<.F*A$E=.E==Fc\eZdZdZdZdZdZdZdZdZ dZ d Z d Z d Z d Zd ZdZy)Testz> Note: most Stream tests are found in stream/tests.py zGtinyNotation: 2/2 c8 d e f trip{a b c' a b c'} f' e' d' G a b c' d'cddlm}|j}tj}|j |d|j t|dt||j t|d|j |djdd|j t|dd|j tt|jdjdy)Nrrr!rz\[, , , ])r$rr]rNote repeatAppend assertEqualr1rclassesstrr(r.r0)selfrr@n1s rRtestNotesToVoiceszTest.testNotesToVoices|s" FMMO YY[ r1 Q#! Q# 1a'2 QqTA& T!((1+";";<=K Lrcdddlm}|jj}|j ddt |\}}}}fd}||dgdzt |d ||dgdzt |||d gdz|D] }d |_ t |||d gdzt |d ||d gdzt |||d gd zt |||d gdzgd} t|D]\} }| | |_t |||gdy)Nr converterTFrrcjt|t|t||D]!\}}j|j|#yr)rr1zipra)rcexpected groupNoteexpectedStemDirectionrs rRtestDirectionsz9Test.testSetStemDirectionOneGroup..testDirectionssJ   SZX 747x4H0 0  !8!8:OP5Irr_r)rWr]r^)rXr^noStemdoubler]r^rrr^) r$rparseallaBreveBeamTestrrUrZrar;) rrrabcrJrrIdStemsrPs ` rRtestSetStemDirectionOneGroupz!Test.testSetStemDirectionOneGroups2% OOD22 3 DE :&q) 1a Q q=/A-. 6q=/A-. #q4&1*%A$AO #q6(Q,' TJq4&1*% #q6(Q,' !#q4&1*%3aLDAq$QiAO! #q>?rcddlm}|j|j}|j ddt t |d}gd}t|D]\}}|||_t||j|jjDcgc]}|jc}dgd zd gd zzdgd zzgd zycc}w) NrrTFrr/rr]rr^rr) r$rrrrr(rUr;rar>rrlrL)rrrrJrrPrIs rR!testSetStemDirectionForBeamGroupsz&Test.testSetStemDirectionForBeamGroupss% OOD22 3 DE : "1% &r *3aLDAq$QiAO! &a( 199;3D3DE3Da!//3DE!vhl2dVaZ??@ EsCcddlm}|jd}|jd|j |j j Dcgc]}|jc}gdgd}t|j j |D] \}}||_t|dd |j |j j Dcgc]}|jc}gd y cc}wcc}w) z Stems that would all be up, starting from scratch, but because of overrideConsistentStemDirections=False, we only change the first group with an "unspecified" direction rrztinyNotation: 2/4 b8 f8 a8 b8Tr)r]r]r]r])r^r_r^r^FrV)r]r]r^r^N) r$rrrrrlrLrarr>)rrrrIrstemDirs rRtestSetStemDirectionConsistencyz$Test.testSetStemDirectionConsistencys & OO; < D ! &'iik&7&7 8&7Q__&7 8 $ 9aiik//8JAw%AO9 &aT\ab &'iik&7&7 8&7Q__&7 8 (  9 9s C8C=cddlm}|j|j}gd}t |j j ddD]\}}|||_|jd|j|j j Dcgc]}|jc}dgdzd gd zzdgdzzgd zycc}w) NrrrTrr]rr^rr) r$rrrr;rlrLrarr)rrrrrPrIs rRtestMakeBeamsWithStemDirectionz#Test.testMakeBeamsWithStemDirections% OOD22 33aiik//45DAq$QiAO6 D ! 199;3D3DE3Da!//3DE!"8a<( 6A:&@@ EsC cdddlm}|jd}tjd}d|_tjd}d|_|j djd||j djd|g|jjd_ g|jjd_ |jd|j|jjDcgc]}|jc}d d gycc}w) NrrztinyNotation: 4/4zd fg?r!Trr_) r$rrr Chordr5rdrprlrL makeNotationrra)rrrc1c2rIs rRtestMakeBeamsOnEmptyChordzTest.testMakeBeamsOnEmptyChords% OO/ 0 [[  [[  ! Ar" ! C$%' !"%' !" t$ &'iik&7&7 8&7Q__&7 8 M * 8sD-cddlm}ddlm}|jd}||jj }|j |j|jj}|jt|jjd|j}|jj}|jt|jjd||jj}d|_d} |j|j | 5|jddddy#1swYyxYw) Nrrrz tinyNotation: 2/4 r2 d8 d8 d8 d8r!r T)r)r$rrrr'last assertIsNoner*rLrtrr1r<rOrassertRaisesRegexr) rrrrrDm_n0m2m2_n0m1msgs rR'testMakeBeamsFromTimeSignatureInContextz,Test.testMakeBeamsFromTimeSignatureInContexts%" OO> ? fnn  " " $ !//*ww}} TZZ112A6 [[]  U[[223Q7v~~  $ $ &J  # #F$:$:C @ LLtL 4A @ @s :EEcDddlm}ddlm}|j|j}|j |j 5}|jtjddd|jtjdy#1swY/xYw)Nrrr)rUr`) r$rrrr assertRaisesrrbr Durationrr exception)rrrrcms rRtestStreamExceptionszTest.testStreamExceptions st%" OOD22 3   v55 6" NNx'8'8':N ;7 R\\* B D7 6s %BBcddlm}|j}|jd}|j dt j d|j dtjdd|jd }|j dt j d |j dtjd d |jd }|j dtjdd |j|||g|j}|jt||jd |j||jjjjjj d|j||jdjjjj d |jt||jd jd|j||jd jjjj d y)z From a real-world failure. Should not be making ties in an example that starts with a short TS but moves to a longer one and all is valid. rrr!r|z3/4C4g@)r5r`z6/1D4g8@E4N)r$rPartr'rprr,rrr/rrr1rtrLr r5)rrrrrm3pps rR"testMakeTiesChangingTimeSignaturesz'Test.testMakeTiesChangingTimeSignatures s # FKKM V^^1 % !U((/0 !TYYt378 V^^1 % !U((/0 !TYYt489 V^^1 % !TYYt489 "b" ZZ\ R/0!4 FNN+11399??AJJXXZ]^ FNN+A.44::<EESSUYZ R/28891= FNN+A.44::<EESSUYZrcBddlm}ddlm}|j d}|t j D]}d|j_t|dd|j|t j Dcgc]}|jc}|dd gd zycc}w) Nrrrz/tinyNotation: 2/4 trip{c8 d8 e8} trip{e8 e8 r8}TFr~r!rr) fractionsrr$rrrrsr rqrrr5)rrrr@rSrxs rR.testConsolidateCompletedTupletsNoFalsePositivez3Test.testConsolidateCompletedTupletsNoFalsePositive, s&% OOM ND$$%B/3BKK ,&#AtF ()$*:*:(; <(;"R  (; < a^ q  ( + KK))$/yK Y   QWWQZ66 >   aggaj..99GG H   QWWQZ66 >   aggaj..99GG H , 22E: aggaj&&11??F 22E: aggaj&&11??G, +s !C.K$$K-c ddlmm  fd}|}|jd|j }|j |j jdj jd|j |j jdj jd |j|j jdj|j d|j |j jdj jd|j |j jdj jd j}|}d |_ |}d |_ |jd||j||jd|j }|j |jjt j"dj jd|j|jjt j"dj|j d|j |jdt j"dj jd y) Nr)rrcjd}jd}jd}|jt j dt jddd }t jd d } jd |_ |j||gjd}t jd d } jd|_ t jdd }|j||g|j||g|jd||S)N mainScore)rpart0r!rrcDhalf)rdotsrquarter)rrr`rr) Scorerr'r/rr,rrTierrp) scp0m01d1rm02rc3rrs rRgetScorez0Test.testMakeNotationRecursive..getScoreT s-B(B &..*C JJu**51 23V!4B3Y/BWWW%BF JJBx  &..*C3Y/BWWV_BF3V,B JJBx IIsCj ! IIa IrTrr!rr`rscore1score2)r$rr stripTiesrrrlrLrrrrrpr/rrtrr) rrr@ssops1s2opprrs @@rRtestMakeNotationRecursivezTest.testMakeNotationRecursiveQ s"' ( J D ! ZZ\ ++A.22CGGG4DE ++A.22CGGFOD !))+++A.223 4   **1-1137773CD **1-113776?C V[[] Z Z !R "  T "kkm ))+DII6q9==swww?OP "))//+DII6q9==> D ! 1dii0377IrN)__name__ __module__ __qualname____doc__rrrrrrrrrrrrr rrrRrrvsSbL "@H  2  "5(D[0  H,.Jrr__main__) r@rrboolrrrrrStreamType | None)r@rrr)r@rrr))rs)rrrNone)r"z'music21.note.NotRest'rset[str] | None)r@zStreamType | StreamIteratorr&list[pitch.Pitch] | Noner'rr(zbool | key.KeySignaturer)rr*rr+rr,rr-rr#rrr)r@rrzlist[pitch.Pitch])rIznote.Note | chord.Chordr&rr'rrErr)rr*rr+rr,rr-r)TT)r@rrz)Generator[list[note.NotRest], None, None])r@rrr)rczlist[note.NotRest]rr)r@ stream.Streamrarrkrrr)r@rrarrrrr)rzt.Generator[None, None, None])> __future__rcollections.abcrr contextlibrjtypingrunittestr$rrrr r r r r rrrrmusic21.common.numberToolsrmusic21.common.typesrrmusic21.exceptions21r TYPE_CHECKINGrrrmusic21.stream.iteratorr Environment__file__rrrbrrsrrrrr%r?r5rJrUr>rZr}rcontextmanagerrTestCaserr mainTestrrrRr$s#/ -50??"6'{&&x0 ""' rrr r  r  rp  ]]]D " RRRn  %%' {{{| 27xvK^'7;?"7x)-/3-1-1!% )-!%^* ^*&^*- ^* + ^* + ^*^*^*^*#'^*^* ^*@8)-/37;-1!% )-#/&#/&#/- #/ 5 #/ + #/#/#/#/#'#/N D!D!/ D!T%*      L%* 01 01  01l IMIMIM IM  IM^ [%[%[% [%  [%| 22HIJ8  IJZ zGTr