rh SrSSKJr SSKJrJrJr SSKJrJ r J r SSK r SSK J r SSKrSSKrSSKJr SSKrSSKrSSKrSSKrSSKJr SSKrSSKrSS KJr SS KJr SS KJr SS KJrJr SS K J!r! SSK"J#r#J$r$J%r%J&r&J'r' SSKJ(r( SSKJ)r) SSKJ*r* SSKJ+r+ SSKJ,r, SSKJ-r- SSKJ.r. SSKJ/r/ SSKJ0r0 SSKJ1r1 SSKJ2r2 SSKJ3r3 SSKJ4r4 SSKJ5r5 SSKJ6r6 SSKJ7r7 SSKJ8r8 SS KJ9r9 SS!KJ:r: SS"K;Jr> SS%K;J?r? SS&K;J@r@ SS'KAJBrBJCrCJDrD \R(aSS(KJFrF \-R"S)5rH\.RrI\.RrJ\R"S*5rL\4RS-\NS+-rO\"S,/S-Q5rP"S.S/\Q5rR\"S0/S1Q5rS"S2S3\S?\V5r\"S@SA\V5r]"SBSC\V5r^"SDSE\V5r_"SFSG\R5ra\V\X\Y\\\]\W\^\_\S/ rb\cSH:XaSSKr\R"\a5 gg)Ia The :class:`~music21.stream.Stream` and its subclasses (which are themselves subclasses of the :class:`~music21.base.Music21Object`) are the fundamental containers of offset-positioned notation and musical elements in music21. Common Stream subclasses, such as the :class:`~music21.stream.Measure`, :class:`~music21.stream.Part` and :class:`~music21.stream.Score` objects, are also in this module. ) annotations)deque namedtuple OrderedDict) CollectionIterableSequenceN)Fraction)isclose)overload)base)bar)common)GatherSpanners OffsetSpecial)opFrac) StreamType M21ObjTypeChangedM21ObjTypeOffsetQLOffsetQLSpecial)clef)chord)defaults) derivation)duration) environment) exceptions21)interval) instrumentkey)metadata)meter)note)pitch)tie)repeat)sites)style)tempo)core) makeNotation) streamStatus)iterator)filters)GivenElementsBehavior RecursionType ShowNumberspannerstreamTRecursiveLyricListBestQuantizationMatch) remainingGaperrortickmatch signedErrordivisorc\rSrSrSrg)StreamDeprecationWarning\N)__name__ __module__ __qualname____firstlineno____static_attributes__rCM/home/james-whalen/.local/lib/python3.13/site-packages/music21/stream/base.pyrArA\s rIrA OffsetMap)elementoffsetendTime voiceIndexcx^\rSrSr%SrSrSrSrS\S'\ Rr S\S '\ Rr/S QrS S S SSSS.rS\S'GS\R$S.GSU4SjjjjrSrGSSjrGSSjrGSU4SjjrGSU4SjjrGSSjrGSSjrGSSjr\GSSj5r\GSS j5r\GSS!j5r\GSS"j5r\GSS#j5r\GS S$j5rGS!S%jrGS"S&jrGS"S'jrGS#S(jr \!GS$S)j5r"\"RFGS%S*j5r"S+r$S,r%GS&S-jr&S.r'\!GS'S/j5r(\(RFGS(S0j5r(\!GS)S1j5r)\)RFGS*S2j5r)\!GS+S3j5r*\*RFGS,S4j5r*\!GSS5j5r+\+RFGS-S6j5r+GS.S7jr,GSGS/S8jjr-GS0U4S9jjr.\/R`"S:S;S<5GS1S=j5r1GS2S>jr2GSS?jr3GS3S@jr4SSSA.GS4SBjjr5GSGS5SCjjr6SDr7GS.SEjr8SFr9GSSSG.GS6U4SHjjjjr:GSGS7SIjjr;SJr<GS8SKjr=GS2SLjr>GSSSSM.SNjjr?GS2SOjr@SPrAGS2SQjrBGSSRjrCGS2GS9SSjjrDSSST.GS:SUjjrESSV.GS;SWjjrFSSSSSX.GS;SYjjrGSZSSSSS[.GSS\jjrHSSS].GSS^jjrISSS].GSS_jjrJGSSbjrLGSSSSc.GS?SdjjjrM\GS@Sej5rN\GSASfj5rN\GSBSgj5rNGSCShjrNGSDSijrOGSDSjjrPGSESkjrQGSSSSSSSl.GSDSmjjjrRGSSSn.GSFSojjjrSGSGSGSpjjrTGSSqjrUGSHSrjrVSs\WRSSt.GSISujjrYSsSSv.GSJSwjjrZSSSS\["5Sx.Syjr\GSKGSLSzjjr]S{r^S|r_\!"\^\_S}S~9r`\!S5ra\!GSMSj5rb\!GSNSj5rc\cRFGSOSj5rc\SSSS.GSPSjj5rd\SSSSS.GSQSjj5rdSSSSS.GSRSjjrdGSSSjreSSS.GSTSjjrfSSSS.GSUSjjrgSSSSS.SjrhSSSS.GSVSjjriSSSS.GSWSjjrj\kR"S54SS.SjjrmGSXSjrnSroSrpSrqGSYSjrrGSZSjrsSSSSSS.SjrtSruGSSjrvGS[SjrwGS\SjrxSSS\kR44SjrzSSSS.Sjr{SSSSSSSSSSSSS. GS]Sjjr|Sr}SSSSSSSSSSSSSS. GS^Sjjr~SS.Sjr\SS.GS_Sjj5r\SSS.GS`Sjj5rSSS.GSaSjjrGSbSjrGS2SjrSrGS2GS7Sjjr\!S5r\SSSSS.GScSjj5r\SSSS.GSdSjj5rSSSSS.GSeSjjrSS.GSfSjjrSrGSgSjr\!S5rSr\!S5r\!S5rSrSr\!GShSj5r\RFGSiSj5rSrSr\!"\\SS~9rGSSjrSrGSSjr\!"\SS~9rGSjSjrGSkSjr\!"\\SS~9rSr\!S5r\!S5r\!S5r\!S5rGSgSjrSSSS.GSlSjjrSSSS.SjrSS.SjrSS.SjrGSmGSnSjjrGSgGSoSjjrSSSS.SjrSSS.SjrGSpSjrGSpSjrSrSrSrSrGSqSjr\!GSrSj5r\!GSsSj5r\!GStSj5r\SSSSSSS.GSuSjj5r\SSSSSS.GSvSjj5r\SSSSSSSS.GSwSjj5rSSSSSSSS.GSxSjjrSrGSySjrGS2SjrGSzSjrSrSr\!GSqSj5rSrGSqSjrSrSrSrGSGSjrGSGSjrSSGS.GSjrSGS.GS{GSjjrSGS.GSjrGSrSSGS .GS jrGS|GS}GS jjrGSSSGS .GS jjrGSgGSjrGSgGSjrGSgGSjrGS~GSjrGSrSS.GSjrGSrU=r$(Streamha This is the fundamental container for Music21Objects; objects may be ordered and/or placed in time based on offsets from the start of this container. As a subclass of Music21Object, Streams have offsets, priority, id, and groups. Streams may be embedded within other Streams. As each Stream can have its own offset, when Streams are embedded the offset of an element is relatively only to its parent Stream. The :meth:`~music21.stream.Stream.flatten` and method provides access to a flat version of all embedded Streams, with offsets relative to the top-level Stream. The Stream :attr:`~music21.stream.Stream.elements` attribute returns the contents of the Stream as a list. Direct access to, and manipulation of, the elements list is not recommended. Instead, use the host of high-level methods available. The Stream, like all Music21Objects, has a :class:`music21.duration.Duration` that is usually the "release" time of the chronologically last element in the Stream (that is, the highest onset plus the duration of any element in the Stream). The duration, however, can be "unlinked" and explicitly set independent of the Stream's contents. The first element passed to the Stream is an optional single Music21Object or a list, tuple, or other Stream of Music21Objects which is used to populate the Stream by inserting each object at its :attr:`~music21.base.Music21Object.offset` property. One special case is when every such object, such as a newly created one, has no offset. Then, so long as the entire list is not composed of non-Measure Stream subclasses representing synchrony like Parts or Voices, each element is appended, creating a sequence of elements in time, rather than synchrony. Other arguments and keywords are ignored, but are allowed so that subclassing the Stream is easier. >>> s1 = stream.Stream() >>> s1.append(note.Note('C#4', type='half')) >>> s1.append(note.Note('D5', type='quarter')) >>> s1.duration.quarterLength 3.0 >>> for thisNote in s1.notes: ... print(thisNote.octave) ... 4 5 This is a demonstration of creating a Stream with other elements, including embedded Streams (in this case, :class:`music21.stream.Part`, a Stream subclass): >>> c1 = clef.TrebleClef() >>> c1.offset = 0.0 >>> c1.priority = -1 >>> n1 = note.Note('E-6', type='eighth') >>> n1.offset = 1.0 >>> p1 = stream.Part() >>> p1.offset = 0.0 >>> p1.id = 'embeddedPart' >>> p1.append(note.Rest()) # quarter rest >>> s2 = stream.Stream([c1, n1, p1]) >>> s2.duration.quarterLength 1.5 >>> s2.show('text') {0.0} {0.0} {0.0} {1.0} * New in v7: providing a single element now works: >>> s = stream.Stream(meter.TimeSignature()) >>> s.first() Providing a list of objects or Measures or Scores (but not other Stream subclasses such as Parts or Voices) positions sequentially, i.e. appends, if they all have offset 0.0 currently: >>> s2 = stream.Measure([note.Note(), note.Note(), bar.Barline()]) >>> s2.show('text') {0.0} {1.0} {2.0} A list of measures will thus each be appended: >>> m1 = stream.Measure(n1, number=1) >>> m2 = stream.Measure(note.Rest(), number=2) >>> s3 = stream.Part([m1, m2]) >>> s3.show('text') {0.0} {1.0} {1.5} {0.0} Here, every element is a Stream that's not a Measure (or Score), so it will be inserted at 0.0, rather than appending: >>> s4 = stream.Score([stream.PartStaff(n1), stream.PartStaff(note.Rest())]) >>> s4.show('text') {0.0} {1.0} {0.0} {0.0} Create nested streams in one fell swoop: >>> s5 = stream.Score(stream.Part(stream.Measure(chord.Chord('C2 A2')))) >>> s5.show('text') {0.0} {0.0} {0.0} This behavior can be modified by the `givenElementsBehavior` keyword to go against the norm of 'OFFSETS': >>> from music21.stream.enums import GivenElementsBehavior >>> s6 = stream.Stream([note.Note('C'), note.Note('D')], ... givenElementsBehavior=GivenElementsBehavior.INSERT) >>> s6.show('text') # all notes at offset 0.0 {0.0} {0.0} >>> p1 = stream.Part(stream.Measure(note.Note('C')), id='p1') >>> p2 = stream.Part(stream.Measure(note.Note('D')), id='p2') >>> s7 = stream.Score([p1, p2], ... givenElementsBehavior=GivenElementsBehavior.APPEND) >>> s7.show('text') # parts following each other (not recommended) {0.0} {0.0} {0.0} {1.0} {0.0} {0.0} For developers of subclasses, please note that because of how Streams are copied, there cannot be required parameters (i.e., without defaults) in initialization. For instance, this would not be allowed, because craziness and givenElements are required:: class CrazyStream(Stream): def __init__(self, givenElements, craziness, **keywords): ... * New in v7: smart appending * New in v8: givenElementsBehavior keyword configures the smart appending. TFiz int | floatclassSortOrderr2 recursionType) appendinsert storeAtEndinsertAndShiftrecurseflatnotespitches transposeaugmentOrDiminish scaleOffsetsscaleDurationsaw Class variable: RecursionType Enum of (ELEMENTS_FIRST (default), FLATTEN, ELEMENTS_ONLY) that decides whether the stream likely holds relevant contexts for the elements in it. Define this for a stream class, not an individual object. see :meth:`~music21.base.Music21Object.contextSites` zQ Boolean describing whether the Stream is sorted or not. z Boolean describing whether the Stream is automatically sorted by offset whenever necessary. z Boolean describing whether this Stream contains embedded sub-Streams or Stream subclasses (not flat). a Boolean that says whether all system breaks in the piece are explicitly defined. Only used on musicxml output (maps to the musicxml tag) and only if this is the outermost Stream being shown a Boolean that says whether all page breaks in the piece are explicitly defined. Only used on musicxml output (maps to the musicxml tag) and only if this is the outermost Stream being shown. )rTisSortedautoSortisFlatdefinesExplicitSystemBreaksdefinesExplicitPageBreaksdict[str, str] _DOC_ATTRN)givenElementsBehaviorc >[TU]"S0UD6 SUl[R"U5UlSUlSUlSUlSUlSUl SUl Ucg[U[R5(a-[R"[ [RU/5nSnU["R$:Xa4['SU55nU(a['SU55(aSnOU["R*:XaSnOSnUHJnUR-U5 U(aUR/U5 M.UR1UR2U5 ML UR55 g![(a Nf=f)NFTunknownc3># UHoRS:Hv M g7f)N)rM.0es rJ "Stream.__init__..is H-QS-sc3# UH=nUR=(a% URR[[45v M? g7fN)isStreamclassSet isdisjointMeasureScorerms rJrprqls7",*ZZKAJJ$9$97E:J$KK*sAArC)super__init___created_via_deprecated_flatr. StreamStatus_unlinkedDurationrbrdre_atSoundingPitch_mutable isinstancer Music21Objecttcastlistr1OFFSETSallAttributeErrorINSERTcoreGuardBeforeAddElement coreAppend coreInsertrMcoreElementsChanged)self givenElementsrhkeywords appendBoolro __class__s rJrzStream.__init__=se $8$-2)(55d;!% ,1().&E?cXL$)z? No two streams are ever equal unless they are the same Stream rC)rothers rJ__eq__ Stream.__eq__~s }rIc[U5S- $)Nidrs rJ__hash__Stream.__hash__s$x1}rIc:URbUR[U5:wa@[UR5[[U55:wa[UR5$[UR[5(a[ UR5$gg)N)rstrrinthexrs rJ _reprInternalStream._reprInternalsf 77 ww"T("s477|s2d8}'D477|#DGGS))477|#rIc >URSLa!UR(aUR5 [TU]"SXS.UD6$)NFfmtfprC)rarbsortrywrite)rrrrrs rJr Stream.writes5 ==E !dmm IIKw}88x88rIc >URSLa!UR(aUR5 [TU]"SXS.UD6$)NFrapprC)rarbrryshow)rrrrrs rJr Stream.shows5 ==E !dmm IIKw|9999rIcX[UR5[UR5-$)a Get the total number of elements in the Stream. This method does not recurse into and count elements in contained Streams. >>> import copy >>> a = stream.Stream() >>> for x in range(4): ... n = note.Note('G#') ... n.offset = x * 3 ... a.insert(n) >>> len(a) 4 >>> b = stream.Stream() >>> for x in range(4): ... b.insert(copy.deepcopy(a)) # append streams >>> len(b) 4 >>> len(b.flatten()) 16 Includes end elements: >>> b.storeAtEnd(bar.Barline('double')) >>> len(b) 5 )len _elements _endElementsrs rJ__len__Stream.__len__s#84>>"S):):%;;;rIcUR(a+[R"S[RSS9 SUl[ R "[R[[R"U55$)z The Stream iterator, used in all for loops and similar iteration routines. This method returns the specialized :class:`music21.stream.StreamIterator` class, which adds necessary Stream-specific features. z-.flat is deprecated. Call .flatten() instead) stacklevelF) r{warningswarnrMusic21DeprecationWarningrrr/StreamIteratorrrs rJ__iter__Stream.__iter__s^  , , MMI&@@%& (16D -vvh--j9--d35 5rIc"UR5$)a\ The Stream iterator, used in all for loops and similar iteration routines. This method returns the specialized :class:`music21.stream.StreamIterator` class, which adds necessary Stream-specific features. Generally you don't need this, just iterate over a stream, but it is necessary to add custom filters to an iterative search before iterating. )rrs rJiter Stream.iters}}rIcgrsrCrks rJ __getitem__Stream.__getitem__ rIcgrsrCrs rJrrrrIcgrsrCrs rJrrrrIcgrsrCrs rJrr rIcgrsrCrs rJrrrrIcgrsrCrs rJrrrrIcUR(d!UR(aUR5 [U[5(aqSnSUs=::a[ UR 5:aO OUR UnOURUnURU5 [R"[U5$[U[5(axUR nURbURS:dURb%URS:a[!UR5n[R"[X15$[U["5(a[%U[&R(5(aUR+5R-U5$[R"["[U5nUR+5R-U5$[.R0"U5(a6[3SU55(aUR+5R-U5$[U[45(a7UR+5R7U5nSU;aUR95$U$[;S[#U535e![a) [SUS3S[ UR53-5ef=f) aV Get a Music21Object from the Stream using a variety of keys or indices. If an int is given, the Music21Object at the index is returned, as if it were a list or tuple: >>> c = note.Note('C') >>> d = note.Note('D') >>> e = note.Note('E') >>> r1 = note.Rest() >>> f = note.Note('F') >>> g = note.Note('G') >>> r2 = note.Rest() >>> a = note.Note('A') >>> s = stream.Stream([c, d, e, r1, f, g, r2, a]) >>> s[0] >>> s[-1] Out of range notes raise an IndexError: >>> s[99] Traceback (most recent call last): IndexError: attempting to access index 99 while elements is of size 8 If a slice of indices is given, a list of elements is returned, as if the Stream were a list or Tuple. >>> subslice = s[2:5] >>> subslice [, , ] >>> len(subslice) 3 >>> s[1].offset 1.0 >>> subslice[1].offset 3.0 If a class is given, then a :class:`~music21.stream.iterator.RecursiveIterator` of elements matching the requested class is returned, similar to `Stream().recurse().getElementsByClass()`. >>> len(s) 8 >>> len(s[note.Rest]) 2 >>> len(s[note.Note]) 6 >>> for n in s[note.Note]: ... print(n.name, end=' ') C D E F G A Note that this iterator is recursive: it will find elements inside of streams within this stream: >>> c_sharp = note.Note('C#') >>> v = stream.Voice() >>> v.insert(0, c_sharp) >>> s.insert(0.5, v) >>> len(s[note.Note]) 7 When using a single Music21 class in this way, your type checker will be able to infer that the only objects in any loop are in fact `note.Note` objects, and catch programming errors before running. Multiple classes can be provided, separated by commas. Any element matching any of the requested classes will be matched. >>> len(s[note.Note, note.Rest]) 9 >>> for note_or_rest in s[note.Note, note.Rest]: ... if isinstance(note_or_rest, note.Note): ... print(note_or_rest.name, end=' ') ... else: ... print('Rest', end=' ') C C# D E Rest F G Rest A The actual object returned by `s[module.Class]` is a :class:`~music21.stream.iterator.RecursiveIterator` and has all the functions available on it: >>> s[note.Note] <...> If no elements of the class are found, no error is raised in version 7: >>> list(s[layout.StaffLayout]) [] If the key is a string, it is treated as a `querySelector` as defined in :meth:`~music21.stream.iterator.getElementsByQuerySelector`, namely that bare strings are treated as class names, strings beginning with `#` are id-queries, and strings beginning with `.` are group queries. We can set some ids and groups for demonstrating. >>> a.id = 'last_a' >>> c.groups.append('ghost') >>> e.groups.append('ghost') '.ghost', because it begins with `.`, is treated as a class name and returns a `RecursiveIterator`: >>> for n in s['.ghost']: ... print(n.name, end=' ') C E A query selector with a `#` returns the single element matching that element or returns None if there is no match: >>> s['#last_a'] >>> s['#nothing'] is None True Any other query raises a TypeError: >>> s[0.5] Traceback (most recent call last): TypeError: Streams can get items by int, slice, class, class iterable, or string query; got * Changed in v7: - out of range indexes now raise an IndexError, not StreamException - strings ('music21.note.Note', '#id', '.group') are now treated like a query selector. - slices with negative indices now supported - Unsupported types now raise TypeError - Class and Group searches now return a recursive `StreamIterator` rather than a `Stream` - Slice searches now return a list of elements rather than a `Stream` * Changed in v8: - for strings: only fully-qualified names such as "music21.note.Note" or partially-qualified names such as "note.Note" are supported as class names. Better to use a literal type or explicitly call .recurse().getElementsByClass to get the earlier behavior. Old behavior still works until v9. This is an attempt to unify __getitem__ behavior in StreamIterators and Streams. - allowed iterables of qualified class names, e.g. `[note.Note, note.Rest]` Nrzattempting to access index  zwhile elements is of size c3B# UHn[U[5v M g7frs)rtype)rn maybe_types rJrp%Stream.__getitem__..s)[YZ:*Z*F*FYZs#zQStreams can get items by int, slice, class, class iterable, or string query; got )rarbrrrrrelements IndexErrorcoreSelfActiveSiterrrslicestartstoprr issubclassr rrYgetElementsByClassr isIterablerrgetElementsByQuerySelectorfirst TypeError)rrr=searchElementsm21TypequerySelectorIterators rJrrs.~}} IIK a  EA+DNN++q) MM!,E  # #E *66*e, , 5 ! !8<~~N#! 9KPQPVPVYZPZ!%dmm!466*n&78 8 4 !T//00||~88;; &&j!115||~88AA   q ! !c)[YZ)[&[&[<<>44Q7 7 3  $(LLN$M$Ma$P !ax,2244,, 7)   Q"$5aS:6s4==7I6JKLs >J3Kc.US$![a gf=f)a Return the first element of a Stream. (Added for compatibility with StreamIterator) Or None if the Stream is empty. Unlike s.iter().first(), which is a significant performance gain, s.first() is the same speed as s[0], except for not raising an IndexError. >>> nC = note.Note('C4') >>> nD = note.Note('D4') >>> s = stream.Stream() >>> s.append([nC, nD]) >>> s.first() >>> empty = stream.Stream() >>> print(empty.first()) None * New in v7. rNrrs rJr Stream.firsts"* 7N    c.US$![a gf=f)a Return the last element of a Stream. (Added for compatibility with StreamIterator) Or None if the Stream is empty. s.last() is the same speed as s[-1], except for not raising an IndexError. >>> nC = note.Note('C4') >>> nD = note.Note('D4') >>> s = stream.Stream() >>> s.append([nC, nD]) >>> s.last() >>> empty = stream.Stream() >>> print(empty.last()) None * New in v7. Nrrs rJlast Stream.lasts"( 8O  rc^[T5UR;=(dE [U4SjUR55=(d [U4SjUR55$)a Returns True if `el` is in the stream (compared with Identity) and False otherwise. >>> nC = note.Note('C4') >>> nD = note.Note('D4') >>> s = stream.Stream() >>> s.append(nC) >>> nC in s True >>> nD in s False Note that we match on actual `id()` equality (`x is y`) and not on `==` equality. >>> nC2 = note.Note('C4') >>> nC == nC2 True >>> nC2 in s False To get the latter, compare on `.elements` which uses Python's default `__contains__` for tuples. >>> nC2 in s.elements True c34># UH oTLdM Sv M g7fTNrCrnsElels rJrp&Stream.__contains__..)sC~tt~ c34># UH oTLdM Sv M g7frrCrs rJrpr*sF'82Itt'8r)r _offsetDictanyrrrrs `rJ __contains__Stream.__contains__ sO<2$***GCt~~CCGFt'8'8FF HrIcbSUR;dURScxUR(d!UR(aUR5 [R "[ [URUR-5URS'[URS5$)ag .elements is a Tuple representing the elements contained in the Stream. Directly getting, setting, and manipulating this Tuple is reserved for advanced usage. Instead, use the provided high-level methods. The elements retrieved here may not have this stream as an activeSite, therefore they might not be properly ordered. In other words: Don't use unless you really know what you're doing. Treat a Stream like a list! See how these are equivalent: >>> m = stream.Measure([note.Note('F4'), note.Note('G4')]) >>> m.elements (, ) >>> tuple(m) (, ) When setting .elements, a list of Music21Objects can be provided, or a complete Stream. If a complete Stream is provided, elements are extracted from that Stream. This has the advantage of transferring offset correctly and getting elements stored at the end. >>> a = stream.Stream() >>> a.repeatInsert(note.Note('C'), list(range(10))) >>> b = stream.Stream() >>> b.repeatInsert(note.Note('D'), list(range(10))) >>> b.offset = 6 >>> c = stream.Stream() >>> c.repeatInsert(note.Note('E'), list(range(10))) >>> c.offset = 12 >>> b.insert(c) >>> b.isFlat False >>> a.isFlat True Assigning from a Stream works well, and is actually much safer than assigning from `.elements` of the other Stream, since the active sites may have changed of that stream's elements in the meantime. >>> a.elements = b >>> a.isFlat False >>> len(a.recurse().notes) == len(b.recurse().notes) == 20 True There is one good use for .elements as opposed to treating a Stream like a list, and that is that `in` for Streams compares on object identity, i.e., id(a) == id(b) [this is for historical reasons], while since `.elements` is a tuple. Recall our measure with the notes F4 and G4 above. >>> other_g = note.Note('G4') This new G can't be found in m, because it is not physically in the Measure >>> other_g in m False But it is *equal* to something in the Measure: >>> other_g in m.elements True But again, this could be done simply with: >>> other_g in tuple(m) True One reason to use `.elements` is to iterate quickly without setting activeSite: >>> n = note.Note() >>> m1 = stream.Measure([n]) >>> m2 = stream.Measure([n]) >>> n.activeSite is m2 True >>> for el in m1.elements: ... pass >>> n.activeSite is m2 True >>> for el in m1: ... pass >>> n.activeSite is m1 True r) _cacherarbrrrrrrrtuplers rJrStream.elements,syx T[[ (DKK ,C,K==T]] &'ffT*-=t~~PTPaPa?a&bDKK #T[[,--rIc 0Ul[U[5(a[UR5UlURHNnUR X!R U5SS9 URRU5 URU5 MP [UR5Ul URHNnUR UUR USS9SS9 URRU5 URU5 MP Op[U5Ul/Ul URHInUR X"RSS9 URRU5 URU5 MK UR5 g)a Sets this stream's elements to the elements in another stream (just give the stream, not the stream's .elements), or to a list of elements. Safe: newStream.elements = oldStream Unsafe: newStream.elements = oldStream.elements Why? The activeSites of some elements may have changed between retrieving and setting (esp. if a lot else has happened in the meantime). Where are we going to get the new stream's elements' offsets from? why from their active sites! So don't do this! T addElement returnSpecialN) rrrQrrcoreSetElementOffset elementOffsetr)addrrrMr)rvalueros rJrrsL*SU eV $ $7;EOO7LDN^^))!-@-@-CPT)U D!''*$;?u?Q?Q:RD &&))!&+&9&9!4&9&P15*7 D!''* '"%[DN "D ^^))!XX$)G D!''*$   "rIcURUnUR[U5 URR U5 SUlX RU'UR X"RSS9 URU5 URRU5 [U[5(aURSS9 SUl gUR5 g)a Insert an item at a currently filled index position, as represented in the elements list. >>> a = stream.Stream() >>> a.repeatInsert(note.Note('C'), list(range(10))) >>> b = stream.Stream() >>> b.repeatInsert(note.Note('C'), list(range(10))) >>> b.offset = 6 >>> c = stream.Stream() >>> c.repeatInsert(note.Note('C'), list(range(10))) >>> c.offset = 12 >>> b.insert(c) >>> a.isFlat True >>> a[3] = b >>> a.isFlat False NTrF updateIsFlat)rrrr)remove activeSiterrMrrrrQrrc)rrroldValues rJ __setitem__Stream.__setitem__s*>>!$   R\ *d#""q !!%$!G &   eV $ $  $ $% $ 8DK  $ $ &rIc>URU UR5 g)z Delete element at an index position. Index positions are based on positions in self.elements. >>> a = stream.Stream() >>> a.repeatInsert(note.Note('C'), list(range(10))) >>> del a[0] >>> len(a) 9 N)rrrs rJ __delitem__Stream.__delitem__s NN1    "rIcUb[U[5(d [S5eURSS9nURH$nUR UR U5U5 M& URH$nUR UR U5U5 M& URHnURU5 M URHnURU5 M U$)a Add, or concatenate, two Streams. Presently, this does not manipulate the offsets of the incoming elements to actually be at the end of the Stream. This may be a problem that makes this method not so useful? >>> a = stream.Part() >>> a.repeatInsert(note.Note('C'), [0, 1]) >>> b = stream.Stream() >>> b.repeatInsert(note.Note('G'), [0, 1, 2]) >>> c = a + b >>> c.pitches # autoSort is True, thus a sorted version results [, , , , ] >>> len(c.notes) 5 The autoSort of the first stream becomes the autoSort of the destination. The class of the first becomes the class of the destination. >>> a.autoSort = False >>> d = a + b >>> [str(p) for p in d.pitches] ['C', 'C', 'G', 'G', 'G'] >>> d.__class__.__name__ 'Part' Works with Streams with Store at end, which does put both at the end. >>> a.autoSort = True >>> a.storeAtEnd(bar.Barline('final')) >>> b.storeAtEnd(clef.TrebleClef()) >>> f = a + b >>> f.show('text') {0.0} {0.0} {1.0} {1.0} {2.0} {3.0} {3.0} z-cannot concatenate a Stream with a non-Stream__add__derivationMethod) rrQr cloneEmptyrrVrrrW)rrsros rJrStream.__add__s^ = 5& 9 9KL L OOYO 7A HHT''*A . A HHU((+Q /!""A LLO###A LLO$rIcLUR(agUR(agg)a As a container class, Streams return True if they are non-empty and False if they are empty: >>> def testBool(s): ... if s: ... return True ... else: ... return False >>> s = stream.Stream() >>> testBool(s) False >>> s.append(note.Note()) >>> testBool(s) True >>> s.append(note.Note()) >>> testBool(s) True >>> s = stream.Stream() >>> s.storeAtEnd(bar.Barline('final')) >>> testBool(s) True TFrrrs rJ__bool__Stream.__bool__9s4 >>   rIc~UR[R5RS5nUR 5$)a Finds or sets a :class:`~music21.clef.Clef` at offset 0.0 in the Stream (generally a Measure): >>> m = stream.Measure() >>> m.number = 10 >>> m.clef = clef.TrebleClef() >>> thisTrebleClef = m.clef >>> thisTrebleClef.sign 'G' >>> thisTrebleClef.getOffsetBySite(m) 0.0 Setting the clef for the measure a second time removes the previous clef from the measure and replaces it with the new one: >>> m.clef = clef.BassClef() >>> m.clef.sign 'F' And the TrebleClef is no longer in the measure: >>> thisTrebleClef.getOffsetBySite(m) Traceback (most recent call last): music21.sites.SitesException: an entry for this object is not stored in stream The `.clef` appears in a `.show()` or other call just like any other element >>> m.append(note.Note('D#', type='whole')) >>> m.show('text') {0.0} {0.0} r)rrClefgetElementsByOffsetr)rclefLists rJr Stream.clefZs1J**4995II!L~~rIcURnUb URURU55nUcgURSU5 g)Nrl)rpopindexrV)rclefObjoldClefjunks rJrr"sB))  88DJJw/0D ?  C!rIc~UR[R5RS5nUR 5$)a Gets or sets the timeSignature at offset 0.0 of the Stream (generally a Measure) >>> m1 = stream.Measure(number=1) >>> m1.timeSignature = meter.TimeSignature('2/4') >>> m1.timeSignature.numerator, m1.timeSignature.denominator (2, 4) >>> m1.show('text') {0.0} Setting timeSignature to None removes any TimeSignature at offset 0.0: >>> m1.timeSignature = None >>> m1.elements () Only the time signature at offset 0 is found: >>> m2 = stream.Measure(number=2) >>> m2.insert(0.0, meter.TimeSignature('5/4')) >>> m2.insert(2.0, meter.TimeSignature('7/4')) >>> ts = m2.timeSignature >>> ts.numerator, ts.denominator (5, 4) >>> m2.timeSignature = meter.TimeSignature('2/8') >>> m2.timeSignature After setting a new `.timeSignature`, the old one is no longer in the Stream: >>> ts in m2 False This property is not recursive, so a Part will not have the time signature of the measure within it: >>> p = stream.Part() >>> p.append(m2) >>> p.timeSignature is None True r)rr$ TimeSignaturer r)rtsLists rJ timeSignatureStream.timeSignatures5\(()<)<=QQRST||~rIcURnUb URURU55nUcgURSU5 gNr)r,r$r%rV)rtsObjoldTimeSignaturer(s rJr,r-sD--  '88DJJ'789D =  AurIc[UR5R[R5R S55$![ a gf=f)a Find or set a Key or KeySignature at offset 0.0 of a stream. >>> a = stream.Measure() >>> a.keySignature = key.KeySignature(-2) >>> ks = a.keySignature >>> ks.sharps -2 >>> a.show('text') {0.0} A key.Key object can be used instead of key.KeySignature, since the former derives from the latter. >>> a.keySignature = key.Key('E', 'major') >>> for k in a: ... print(k.offset, repr(k)) 0.0 Notice that setting a new key signature replaces any previous ones: >>> len(a.getElementsByClass(key.KeySignature)) 1 `.keySignature` can be set to None: >>> a.keySignature = None >>> a.keySignature is None True rN)nextrrr" KeySignaturer  StopIterationrs rJ keySignatureStream.keySignaturesH@  66s7G7GH\\]^_` `  sAA AAcURnUb URURU55nUcgURSU5 g)z_ >>> a = stream.Measure() >>> a.keySignature = key.KeySignature(6) >>> a.keySignature.sharps 6 Nr)r6r$r%rV)rkeyObjoldKeyr(s rJr6r7sD""  88DJJv./D >  AvrIcSSKJn XRnUH5nURU5S:a gURcM)URs $ g)a Returns the number of staffLines for the Stream, as defined by the first StaffLayout object found at offset 0 that defines staffLines >>> m = stream.Measure() >>> m.staffLines 5 >>> m.staffLines = 4 >>> m.staffLines 4 >>> m.show('text') {0.0} >>> staffLayout = m.getElementsByClass(layout.StaffLayout).first() >>> staffLayout.staffLines = 1 >>> m.staffLines 1 >>> p = stream.Part() >>> p.insert(0, m) >>> p.staffLines 1 >>> p2 = stream.Part() >>> m0 = stream.Measure() >>> m0.insert(0, note.Note(type='whole')) >>> p2.append(m0) >>> p2.append(m) >>> p2.staffLines 5 OMIT_FROM_DOCS Check that staffLayout is altered by staffLayout setter: >>> m.staffLines = 2 >>> staffLayout.staffLines 2 rlayout)music21r= StaffLayoutgetOffsetInHierarchy staffLines)rr= staffLayoutssls rJrBStream.staffLinessXT #../ B&&t,q0}}(}}$  rIcSSKJn UR5RS5R UR 5nUR 5nU(d"UR US9nURSU5 gXlg)Nrr<rl)rB) r?r=rYr rr@rrVrB)r newStaffLinesr=rC firstLayoutrDs rJrBrE=sj"  WY  %   2 2 3  #((* %+%7%7=%7%QB KKR %2 "rIcSUlg)z Remove all elements in a stream. >>> m = stream.Measure(number=3) >>> m.append(note.Note('C')) >>> m.storeAtEnd(bar.Barline('final')) >>> len(m) 2 >>> m.clear() >>> len(m) 0 Does not remove any other attributes >>> m.number 3 rCN)rrs rJclear Stream.clearMs $ rIcUR5nX"RlXRlUbXRlUR U5 U$)aq Create a Stream that is identical to this one except that the elements are empty and set derivation. >>> p = stream.Part() >>> p.autoSort = False >>> p.id = 'hi' >>> p.insert(0, note.Note()) >>> q = p.cloneEmpty(derivationMethod='demo') >>> q.autoSort False >>> q >>> q.derivation.origin is p True >>> q.derivation.method 'demo' >>> len(q) 0 )rrclientoriginmethodmergeAttributes)rr returnObjs rJrStream.cloneEmptyasN*!% 0 &/#&*#  '*: '!!$'rIc >[TU]U5 [U[5(dgSH*n[ X5(dM[ X[ X55 M, g)a Merge relevant attributes from the Other stream into this one. >>> s = stream.Stream() >>> s.append(note.Note()) >>> s.autoSort = False >>> s.id = 'hi' >>> s2 = stream.Stream() >>> s2.mergeAttributes(s) >>> s2.autoSort False >>> s2 >>> len(s2) 0 N)rbrardrer~r)ryrPrrQhasattrsetattrgetattrrrattrrs rJrPStream.mergeAttributes~sJ" &%(( RDu##GE$89RrIzv9.3v11z5Use `el in stream` instead of `stream.hasElement(el)`c X;$)z DEPRECATED: just use `el in stream` instead of `stream.hasElement(el)` Return True if an element, provided as an argument, is contained in this Stream. rC)robjs rJ hasElementStream.hasElements {rIcLURHnXR;dM g g)ag Given a single class name as string, return True or False if an element with the specified class is found. Only a single class name can be given. >>> s = stream.Stream() >>> s.append(meter.TimeSignature('5/8')) >>> s.append(note.Note('d-2')) >>> s.insert(dynamics.Dynamic('fff')) >>> s.hasElementOfClass(meter.TimeSignature) True >>> s.hasElementOfClass('Measure') False To be deprecated in v10 -- to be removed in v11, use: >>> bool(s.getElementsByClass(meter.TimeSignature)) True >>> bool(s.getElementsByClass(stream.Measure)) False forceFlat does nothing, while getElementsByClass can be done on recurse() TF)rru)r className forceFlatros rJhasElementOfClassStream.hasElementOfClasss$6AJJ&rIcUb [U5nOSnURHlnUbEURUR5(a#UR UR U5U5 MIMKUR UR U5U5 Mn UR HLnUb5URUR5(aURU5 M9M;URU5 MN UR5 g)aO Given another Stream, store references of each element in the other Stream in this Stream. This does not make copies of any elements, but simply stores all of them in this Stream. Optionally, provide a list of classes to include with the `classFilter` list. This method provides functionality like a shallow copy, but manages locations properly, only copies elements, and permits filtering by class type. >>> s1 = stream.Stream() >>> s2 = stream.Stream() >>> n1 = note.Note('f#') >>> n2 = note.Note('g') >>> s1.append(n1) >>> s1.append(n2) >>> s2.mergeElements(s1) >>> len(s2) 2 >>> s1[0] is s2[0] True >>> s1[1] is s2[1] True >>> viola = instrument.Viola() >>> trumpet = instrument.Trumpet() >>> s1.insert(0, viola) >>> s1.insert(0, trumpet) >>> s2.mergeElements(s1, classFilterList=('BrassInstrument',)) >>> len(s2) 3 >>> viola in s2 False N) setr intersectionrurrrcoreStoreAtEndr)rrclassFilterListclassFilterSetros rJ mergeElementsStream.mergeElementssH  & 1N!NA*!..qzz::OOE$7$7$:A>; 3 3A 6: ! ##A*!..qzz::''*;##A& $   "rIcUR(d!UR(aUR5 SUR;a,URSbURS[ U5$0URS'[ U5nSnUR H!nXALaX0RSU'Us $US- nM# URH!nXALaX0RSU'Us $US- nM# [SUS35e![ a Nf=f)a Return the first matched index for the specified object. Raises a StreamException if the object cannot be found. >>> s = stream.Stream() >>> n1 = note.Note('G') >>> n2 = note.Note('A') >>> s.insert(0.0, n1) >>> s.insert(5.0, n2) >>> len(s) 2 >>> s.index(n1) 0 >>> s.index(n2) 1 Note that this is done via Object identity, so another identical G won't be found in the stream. >>> n3 = note.Note('G') >>> s.index(n3) Traceback (most recent call last): music21.exceptions21.StreamException: cannot find object () in Stream To find the index of something equal to the object in the stream, cast the stream to a tuple or list first: >>> tuple(s).index(n3) 0 r%rzcannot find object (z ) in Stream) rarbrrrKeyErrorrrStreamException)rrobjIdcountros rJr% Stream.index sF}} IIK dkk !dkk'&:&F {{7+BrF33$&DKK 2Aw.3 G$U+ QJE  ""Aw.3 G$U+ QJE #  4RD DEE'  sC<< D D ) shiftOffsetsrYc URSLa [S5eUSLaUSLa [S5e[R"U5(d:[ R (a![U[R5(deU/nO[U[5(ac[U5S:aT[ R (a![U[R5(ae[[XRS95nOA[ R (a![U[R5(ae[U5nSn[#U5GHupgUR%U5nSn [UR.5n Sn X:aUR.R1U5nOUR2R1X- 5nSn Ub^USLaURU5n UR4[7U5 UR;SS 9 URR-U5 S UlUSLdMU SLdMUR>R@nX-nUS-[U5:aURXFS-5nOUR>R@nX_- nUS:wdGMFURCUUSSSS 9H)nURU5nUREUUU- 5 M+ GM UR;SS 9 g ![R a [U5nGNf=f![an [U[R5(d['US[)U535U eUSLaZUR+SS 9HGn U R%U5nU R-U5 O#![[R 4a MEf=f S n A GMjS n A ff=f![8a GNf=f) at Remove an object from this Stream. Additionally, this Stream is removed from the object's sites in :class:`~music21.sites.Sites`. If a list of objects is passed, they will all be removed. If shiftOffsets is True, then offsets will be corrected after object removal. It is more efficient to pass a list of objects than to call remove on each object individually if shiftOffsets is True. >>> import copy >>> s = stream.Stream() >>> n1 = note.Note('g') >>> n2 = note.Note('g#') Copies of an object are not the same as the object >>> n3 = copy.deepcopy(n2) >>> s.insert(10, n1) >>> s.insert(5, n2) >>> s.remove(n1) >>> len(s) 1 >>> s.insert(20, n3) >>> s.remove(n3) >>> [e for e in s] == [n2] True No error is raised if the target is not found. >>> s.remove(n3) >>> s2 = stream.Stream() >>> c = clef.TrebleClef() >>> n1, n2, n3, n4 = note.Note('a'), note.Note('b'), note.Note('c'), note.Note('d') >>> n5, n6, n7, n8 = note.Note('e'), note.Note('f'), note.Note('g'), note.Note('a') >>> s2.insert(0.0, c) >>> s2.append([n1, n2, n3, n4, n5, n6, n7, n8]) >>> s2.remove(n1, shiftOffsets=True) >>> s2.show('text') {0.0} {0.0} {1.0} {2.0} {3.0} {4.0} {5.0} {6.0} >>> s2.remove([n3, n6, n4], shiftOffsets=True) >>> s2.show('text') {0.0} {0.0} {1.0} {2.0} {3.0} With the recurse=True parameter, we can remove elements deeply nested. However, shiftOffsets does not work with recurse=True yet. >>> p1 = stream.Part() >>> m1 = stream.Measure(number=1) >>> c = clef.BassClef() >>> m1.insert(0, c) >>> m1.append(note.Note(type='whole')) >>> p1.append(m1) >>> m2 = stream.Measure(number=2) >>> n2 = note.Note('D', type='half') >>> m2.append(n2) >>> n3 = note.Note(type='half') >>> m2.append(n3) >>> p1.append(m2) >>> p1.show('text') {0.0} {0.0} {0.0} {4.0} {0.0} {2.0} Without recurse=True: >>> p1.remove(n2) >>> p1.show('text') {0.0} {0.0} {0.0} {4.0} {0.0} {2.0} With recurse=True: >>> p1.remove(n2, recurse=True) >>> p1.show('text') {0.0} {0.0} {0.0} {4.0} {2.0} With recurse=True and a list to remove: >>> p1.remove([c, n3], recurse=True) >>> p1.show('text') {0.0} {0.0} {4.0} Can also remove elements stored at end: >>> streamWithBarline = stream.Stream(note.Note()) >>> barline = bar.Barline('final') >>> streamWithBarline.storeAtEnd(barline) >>> barline in streamWithBarline True >>> streamWithBarline.remove(barline) >>> barline in streamWithBarline False * Changed in v5.3: firstMatchOnly removed -- impossible to have element in stream twice. recurse and shiftOffsets changed to keywordOnly arguments Fz&Cannot remove from an immutable streamTzDCannot do both shiftOffsets and recurse search at the same time, yetrmr!rlz is not a Music21Object; got  streamsOnlyN clearIsSortedincludeEndBoundarymustFinishInSpanmustBeginInSpan)#rImmutableStreamExceptionror isListLiker TYPE_CHECKINGrr rr rrsortedrr)SitesException enumerater%rrrYr rr$rrrrnrr r quarterLengthr r)r targetOrListrsrY targetListshiftDuritarget indexInStreamsermatchedEndElementbaseElementCount matchOffsetr= matchDurationshiftedRegionStartshiftedRegionEndrors rJr  Stream.removeJsJ ==E !*+ST T 4 GtO!VX X  ..!,0B0BCCCC&J  h / /C 4E4I%lD4F4FGGGG 0!&;M;M"NO %lD4F4FGGGGl+J":.IA  $ 6 2 "!& "4>>2 K/**=9))--m.NO$(! 4'"&"4"4U";K((E3((u(= ""4(#' t#(9U(B % < < %0%@"ES_,'+'9'9*U:K'L$'+}}'B'B$)s?!556H6FINGLFJ 6L )-(:(:1(= 11!]X5MNLi/|   u 5Q'' 0!,/  0# !&$*<*<==#vh.KDQWL>$Z[accd?!\\d\;%,-GGFOMHHV,! /1E1EF%$% < @ sa K&L N=&L L  N:AN5'"N  N5 N) %N5(N) )N55N:= O  O c[UR5nUcGUR(aURR5nOYURR5nO>X:aURRU5nOURRX- 5nUR SS9 UR [ U5 URRU5 SUl U$![a N0f=f)a Return and remove the object found at the user-specified index value. Index values are those found in `elements` and are not necessary offset order. >>> a = stream.Stream() >>> for i in range(12): # notes C, C#, etc. to B ... a.append(note.Note(i)) >>> a.pop(0) >>> len(a) 11 If nothing is given, then it pops the last thing from the stream. >>> a.pop() >>> len(a) 10 NFrw) rrrr$rrrrnr)r r )rr%eLenposts rJr$ Stream.pop-s*4>>" =  ((,,.~~))+ \>>%%e,D$$((6D   u 5   D* $    s.C(( C54C5c//S.nUH(nURnX$SRUS5 M* UHnn[X5nX%n[U5HMnUR U5n UR [ U 5 U RRU5 SU l MO Mp URSS9 g![a NFf=f)z6 helper method to remove different kinds of elements. r iterSection sectionIndexNFrw) activeInformationrUrVreversedr$rrrnr)r r r) rstreamIteratorpopDict unused_elaisection sectionListpopListpopIndex removeElements rJ_removeIterationStream._removeIterationYs!##%(I11B }% & - -b.@ A( G!$0K&G$W- + 9 ((M):; ##**40+/ (.   u 5 s(B88 CCcdUR5RU5nURU5 g)a Remove all elements from the Stream based on one or more classes given in a list. >>> s = stream.Stream() >>> s.append(meter.TimeSignature('4/4')) >>> s.repeatAppend(note.Note('C'), 8) >>> len(s) 9 >>> s.removeByClass('GeneralNote') >>> len(s) 1 >>> len(s.notes) 0 Test that removing from end elements works. >>> s = stream.Measure() >>> s.append(meter.TimeSignature('4/4')) >>> s.repeatAppend(note.Note('C'), 4) >>> s.rightBarline = bar.Barline('final') >>> len(s) 6 >>> s.removeByClass('Barline') >>> len(s) 5 N)rrrrrhelFilters rJ removeByClassStream.removeByClassxs(:99;11/B h'rIcbUR5RU5nURU5$)a Remove all elements not of the specified class or subclass in the Stream in place. >>> s = stream.Stream() >>> s.append(meter.TimeSignature('4/4')) >>> s.repeatAppend(note.Note('C'), 8) >>> len(s) 9 >>> s.removeByNotOfClass(meter.TimeSignature) >>> len(s) 1 >>> len(s.notes) 0 )rgetElementsNotOfClassrrs rJremoveByNotOfClassStream.removeByNotOfClasss+ 99;44_E$$X..rIignoreAttributesc>1SknUcUnOX#-n[T U]XS9n0nXTl/Ul/UlXDR lURH]nURU5nUR(d[R"Xa5nOURU5nURXxSS9 M_ URH(nUR[R"Xa55 M* UR5 U$)N>rrrrT ignoreSort)ry_deepcopySubclassablerrrr.rMrrtcopydeepcopyrrgr) rmemordefaultIgnoreSetnew newOffsetDictrorM newElementrs rJrStream._deepcopySubclassables    #/ /B  '77`PR ' #&A''*F::!]]13 44T: NN6$N ?3 8""A   t}}Q5 6 # ! rIclURU5nUR(aURU5 U$)z* Deepcopy the stream from copy.deepcopy() )rr _replaceSpannerBundleForDeepcopy)rrrs rJ __deepcopy__Stream.__deepcopy__s.((. ==  1 1# 6 rIclURnU(dgURSS9HnSUR;aMURRS:waM1URR nUcMLUR R5(dMmURXC5 URSS9 M g)NF includeSelfzmusic21.spanner.Spannerr)excludeStorageStreams) spannerBundlerYrurrOrNr)hasSpannerSitereplaceSpannedElement purgeOrphans)rrnewSpannerBundlerorNs rJr'Stream._replaceSpannerBundleForDeepcopys,, /A(AJJ6||""n4\\((F~||**,,!66vA U;)0rIcFURUU5 URSS9 g)aM Sets the Offset for an element that is already in a given stream. Set up a note in two different streams at two different offsets: >>> n = note.Note('B-4') >>> s = stream.Stream(id='Stream1') >>> s.insert(10, n) >>> n.offset 10.0 >>> n.activeSite.id 'Stream1' >>> s2 = stream.Stream(id='Stream2') >>> s2.insert(30, n) >>> n.activeSite.id 'Stream2' Now change the note's offset in Stream1: >>> s.setElementOffset(n, 20.0) This call has the effect of switching the `activeSite` of `n` to `s`. >>> n.activeSite.id 'Stream1' >>> n.offset 20.0 >>> n.getOffsetBySite(s) 20.0 If the element is not in the Stream, raises a StreamException: >>> n2 = note.Note('D') >>> s.setElementOffset(n2, 30.0) Traceback (most recent call last): music21.exceptions21.StreamException: Cannot set the offset for element , not in Stream . * Changed in v5.5: also sets .activeSite for the element * Changed in v6.7: also runs coreElementsChanged() * Changed in v7: addElement is removed; see :meth:`~music21.stream.core.StreamCoreMixin.coreSetElementOffset` Fr N)rr)rrLrMs rJsetElementOffsetStream.setElementOffsets+b !!'"( $   e 4rIcUR[U5Sn[ U[ 5(aUSLaU[;a [X5$U$![aS URHnURUup5XLdM Mf [R"S[U5SSU35ef=f![a [R"SSU3-5ef=f)a> Return the offset as an opFrac (float or Fraction) from the offsetMap. highly optimized for speed. >>> m = stream.Measure(number=1) >>> m.append(note.Note('C')) >>> d = note.Note('D') >>> m.append(d) >>> m.elementOffset(d) 1.0 If returnSpecial is True then returns like OffsetSpecial.AT_END are allowed. >>> b = bar.Barline() >>> m.storeAtEnd(b) >>> m.elementOffset(b) 2.0 >>> m.elementOffset(b, returnSpecial=True) Unlike element.getOffsetBySite(self), this method will NOT follow derivation chains and in fact will raise a sites.SitesException >>> import copy >>> p = stream.Part(id='sPart') >>> p.insert(20, m) >>> m.getOffsetBySite(p) 20.0 >>> p.elementOffset(m) 20.0 >>> mCopy = copy.deepcopy(m) >>> mCopy.number = 10 >>> mCopy.derivation from via '__deepcopy__'> >>> mCopy.getOffsetBySite(p) 20.0 >>> p.elementOffset(mCopy) Traceback (most recent call last): music21.sites.SitesException: an entry for this object 0x... is not stored in stream Performance note: because it will not follow derivation chains, and does not need to unwrap a weakref, this method should usually be about 3x faster than element.getOffsetBySite(self) -- currently 600ns instead of 1.5 microseconds. rzan entry for this object 0xxz is not stored in stream Fz3attempted to retrieve a bound offset with a string z!attribute that is not supported: ) rrrnr rrrrrVr)rrLro idElementreturnedElements rJrStream.elementOffsetRsb b  G-a0A a  -5"8Q-=O ?t'' H) b!-- %)%5%5i%@"- .))1"W+a@YZ^Y_`bb b" ?))I9!=>?? ?s#A B/,B,?B,)B,/'Cr setActiveSitecVUbUnUnO{UcX[U[5(aCSnU[U5:a1XnXS-nURXVUS9 US- nU[U5:aM1gUnURnUR U5n[U5nUn URU 5 URUU UUS 9n S n U R(aS n URU S9 US LaXlgg![ a [SU<S3S-5ef=f![[4a [S U<S 35ef=f)aJ Inserts an item(s) at the given offset(s). If `ignoreSort` is True then the inserting does not change whether the Stream is sorted or not (much faster if you're going to be inserting dozens of items that don't change the sort status) The `setActiveSite` parameter should nearly always be True; only for advanced Stream manipulation would you not change the activeSite after inserting an element. Has three forms: in the two argument form, inserts an element at the given offset: >>> st1 = stream.Stream() >>> st1.insert(32, note.Note('B-')) >>> st1.highestOffset 32.0 In the single argument form with an object, inserts the element at its stored offset: >>> n1 = note.Note('C#') >>> n1.offset = 30.0 >>> st1 = stream.Stream() >>> st1.insert(n1) >>> st2 = stream.Stream() >>> st2.insert(40.0, n1) >>> n1.getOffsetBySite(st1) 30.0 In single argument form with a list, the list should contain pairs that alternate offsets and items; the method then, obviously, inserts the items at the specified offsets. Note: This functionality will be deprecated in v9 and replaced with a list of tuples of [(offset, element), (offset, element)] and removed in v10 >>> n1 = note.Note('G') >>> n2 = note.Note('F#') >>> st3 = stream.Stream() >>> st3.insert([1.0, n1, 2.0, n2]) >>> n1.getOffsetBySite(st3) 1.0 >>> n2.getOffsetBySite(st3) 2.0 >>> len(st3) 2 Raises an error if offset is not a number: >>> stream.Stream().insert('l', note.Note('B')) Traceback (most recent call last): music21.exceptions21.StreamException: Offset 'l' must be a number. Also raises an error if the object is not a music21 object (or a list of them) >>> stream.Stream().insert(3.3, 'hello') Traceback (most recent call last): music21.exceptions21.StreamException: The object you tried to add to the Stream, 'hello', is not a Music21Object. Use an ElementWrapper object if this is what you intend. The error message is slightly different in the one-element form: >>> stream.Stream().insert('hello') Traceback (most recent call last): music21.exceptions21.StreamException: Cannot insert item 'hello' to stream -- is it a music21 object? NrrmrzCannot insert item z to stream z-- is it a music21 object?zOffset z must be a number.rFTr )rrrrVr getOffsetBySiterrofloat ValueErrorrrrrtrra) roffsetOrItemOrList itemOrNonerrrMitemrr rL storeSortedr s rJrV Stream.insertsh  !'FD  J/A4$H$HAc,--+.)a%0 FZ @Q c,-- &D F!__ --j9  J6]F &&w/oof&-1;4A&C    L   l ;  'M 1" F%(;D8;&O(D'EFF FI& J!GF:5G"HI I Js'C& D&D!D(c [URUXR-SSSS9R5nSn[ U5S:XGa/n/nUSnUn[ U[ R5(ao[ U[ R5(aUR/nU/nO?[ U[R5(a [UR5n[U5n[ U[ R5(a[ U[ R5(aURUR/nX/nOb[ U[R5(a3UR/[UR5-nU/[U5-nOUR/nU/n[ U[R5(a[ U[ R5(a3[UR5UR/-n[U5U/-nO[ U[R5(aC[UR5[UR5-n[U5[U5-nO [UR5n[U5n[ U5S:dUSLa[R"U5n O>[ U5S:Xa[ R"US5n O[ R"5n URU l URU lURU l[!US5(a@UR"H0n U R$S;dMU R'U R$5 M2 [!U S 5(a"[!US 5(aUR(U l[!U S 5(a"[!US 5(aUR*U l[ U [R5(a)[-U 5HupX{n U R*U lM O[ U5S:a [/S 5eUn UbUR1U5 UR3XSSS 9 g) aZ Insert a Note or Chord into an offset position in this Stream. If there is another Note or Chord in this position, create a new Note or Chord that combines the pitches of the inserted chord. If there is a Rest in this position, the Rest is replaced by the Note or Chord. The duration of the previously-found chord will remain the same in the new Chord. >>> n1 = note.Note('D4') >>> n1.duration.quarterLength = 2.0 >>> r1 = note.Rest() >>> r1.duration.quarterLength = 2.0 >>> c1 = chord.Chord(['C4', 'E4']) >>> s = stream.Stream() >>> s.append(n1) >>> s.append(r1) >>> s.append(c1) >>> s.show('text') {0.0} {2.0} {4.0} Save the original Streams for later >>> import copy >>> s2 = copy.deepcopy(s) >>> s3 = copy.deepcopy(s) >>> s4 = copy.deepcopy(s) Notice that the duration of the inserted element is not taken into consideration and the original element is not broken up, as it would be in chordify(). But Chords and Notes are created: >>> for i in [0.0, 2.0, 4.0]: ... s.insertIntoNoteOrChord(i, note.Note('F#4')) >>> s.show('text') {0.0} {2.0} {4.0} If chordsOnly is set to True then no notes are returned, only chords, but untouched notes are left alone: >>> s2.insert(5.0, note.Note('E##4')) >>> for i in [0.0, 2.0, 4.0]: ... s2.insertIntoNoteOrChord(i, note.Note('F#4'), chordsOnly=True) >>> s2.show('text') {0.0} {2.0} {4.0} {5.0} A chord inserted on top of a note always changes the note into a chord: >>> s2.insertIntoNoteOrChord(5.0, chord.Chord('F#4 G-4')) >>> s2.show('text') {0.0} {2.0} {4.0} {5.0} Chords can also be inserted into rests: >>> s3.getElementsByOffset(2.0).first() >>> s3.insertIntoNoteOrChord(2.0, chord.Chord('C4 E4 G#4')) >>> s3.show('text') {0.0} {2.0} {4.0} Despite the variable name, a rest could be inserted into a noteOrChord. It does nothing to existing notes or chords, and just adds a new rest afterwards. >>> s4.show('text', addEndTimes=True) {0.0 - 2.0} {2.0 - 4.0} {4.0 - 5.0} >>> for i in [0.0, 4.0, 6.0]: # skipping 2.0 for now ... r = note.Rest(type='quarter') ... s4.insertIntoNoteOrChord(i, r) >>> r2 = note.Rest(type='quarter') >>> s4.insertIntoNoteOrChord(2.0, r) >>> s4.show('text', addEndTimes=True) {0.0 - 2.0} {2.0 - 4.0} {4.0 - 5.0} {6.0 - 7.0} Notice that (1) the original duration and not the new duration is used, unless there is no element at that place, and (2) if an element is put into a place where no existing element was found, then it will be found in the new Stream, but if it is placed on top of an existing element, the original element or a new copy will remain: >>> r in s4 True >>> r2 in s4 False If a Stream has more than one note, chord, or rest at that position, currently an error is raised. This may change later: >>> s5 = stream.Stream() >>> s5.insert(0, note.Note('C##4')) >>> s5.insert(0, note.Note('E--4')) >>> s5.insertIntoNoteOrChord(0, note.Note('D4')) Traceback (most recent call last): music21.exceptions21.StreamException: more than one element found at the specified offset FTryNrmrlyrics)rN stemDirection noteheadFillz3more than one element found at the specified offsetr)rr r notesAndRestsrrr%RestNoter&rChordr\ expressions articulationsrrTrtextaddLyricrrrror rV)rrM noteOrChord chordsOnlytargets removeTargetr\ componentsr finalTargetlyrn nPreviouss rJinsertIntoNoteOrChordStream.insertIntoNoteOrChord! syd  $ $222#(!& $ %  m  w<1 GJQZF!L&$)),,k49955*001G"-J U[[99";#6#67G!%k!2J&$)),,k49955%||[->->?G"(!6J U[[99%||ntK4G4G/HHG"(D,=!=J%||nG"(J&%++..k49955"6>>2k6G6G5HHG!%f !=J U[[99"6>>2T+:M:M5NNG!%f[0A!AJ"6>>2G!%fJ7|a:#5#kk'2 W""ii 3 "iik &,&8&8K #(.(<(+> (+u{{33%k2DA * I%.%;%;AN3\A !"WX X%K  # KK % FE NrIcLURn[R"U5(dU/nSnUR(aURSnOSnSnUGHnUR U5 UR (aSnUR XbSS9 URRU5 URU5 URRU5 URRS:waX&RR- nUbQURR(d6URUR:dURUR:aSnUnGM U(aSnO URnUR!US9 XplUR#[%U55 g)a Add a Music21Object (including another Stream) to the end of the current Stream. If given a list, will append each element in order after the previous one. The "end" of the stream is determined by the `highestTime` property (that is the latest "release" of an object, or directly after the last element ends). Runs fast for multiple addition and will preserve isSorted if True >>> a = stream.Stream() >>> notes = [] >>> for x in range(3): ... n = note.Note('G#') ... n.duration.quarterLength = 3 ... notes.append(n) >>> a.append(notes[0]) >>> a.highestOffset, a.highestTime (0.0, 3.0) >>> a.append(notes[1]) >>> a.highestOffset, a.highestTime (3.0, 6.0) >>> a.append(notes[2]) >>> a.highestOffset, a.highestTime (6.0, 9.0) >>> notes2 = [] Notes' naive offsets will change when they are added to a stream. >>> for x in range(3): ... n = note.Note('A-') ... n.duration.quarterLength = 3 ... n.offset = 0 ... notes2.append(n) >>> a.append(notes2) # add em all again >>> a.highestOffset, a.highestTime (15.0, 18.0) >>> a.isSequence() True Adding a note that already has an offset set does nothing different from above! That is, it is still added to the end of the Stream: >>> n3 = note.Note('B-') >>> n3.offset = 1 >>> n3.duration.quarterLength = 3 >>> a.append(n3) >>> a.highestOffset, a.highestTime (18.0, 21.0) >>> n3.getOffsetBySite(a) 18.0 Prior to v5.7 there was a bug where appending a `Clef` after a `KeySignature` or a `Measure` after a `KeySignature`, etc. would not cause sorting to be re-run. This bug is now fixed. >>> s = stream.Stream() >>> s.append([meter.TimeSignature('4/4'), ... clef.TrebleClef()]) >>> s.elements[0] >>> s.show('text') {0.0} {0.0} >>> s.append(metadata.Metadata(composer='Cage')) >>> s.show('text') {0.0} {0.0} {0.0} FrNTrrr ) highestTimerr~rrrtrr)rrrUrrpriorityrSrar_setHighestTimer)rothersrrx lastElementr rors rJrU Stream.append s]V&&   ((XF >>..,KK A  * *1 -zz#   % %a % F GGKK   # #A & NN ! !! $zz''1,zz777 &{/C/C/Q/QJJ!5!55++k.H.HH$(MK+0 K--K   l ;#  VK01rIc[U[5(aUHnURX2S9 M gUnUnURU5 URR S:wa [ S5eURU5 URSS9 g)aq Inserts an item or items at the end of the Stream, stored in the special box (called _endElements). This method is useful for putting things such as right bar lines or courtesy clefs that should always be at the end of a Stream no matter what else is appended to it. As sorting is done only by priority and class, it cannot avoid setting isSorted to False. >>> s = stream.Stream() >>> b = bar.Repeat() >>> s.storeAtEnd(b) >>> b in s True >>> s.elementOffset(b) 0.0 >>> s.elementOffset(b, returnSpecial=True) Only elements of zero duration can be stored. Otherwise, a `StreamException` is raised. rNrzTcannot insert an object with a non-zero Duration into the highest time elements listFr ) rrrWrrrrorgr)r itemOrListrrrLs rJrWStream.storeAtEnd` s4 j$ ' '"<# D &&w/    ) )Q .!#ST T G$   e 4rIcBUb!UnURRnUnUnXT-nOUc|[U[5(agUnSnSnSn U [ U5:aOXn XS-n U RRn[ XzU-5nUbX:aU nU S- n U [ U5:aMOO3UnURRnUR U-nUR nSn Sn URH.n URU 5n X- nUS:aM U bX:dM*Un U n M0 U bURU 5nX- nOSnUS::aODURH4n URU 5n X- nUS:dM URXU-5 M6 UR5 URX5 g)a Insert an item at a specified or native offset, and shift any elements found in the Stream to start at the end of the added elements. This presently does not shift elements that have durations that extend into the lowest insert position. >>> st1 = stream.Stream() >>> st1.insertAndShift(32, note.Note('B')) >>> st1.highestOffset 32.0 >>> st1.insertAndShift(32, note.Note('C')) >>> st1.highestOffset 33.0 >>> st1.show('text', addEndTimes=True) {32.0 - 33.0} {33.0 - 34.0} Let's insert an item at the beginning, note that since the C and B are not affected, they do not shift. >>> st1.insertAndShift(0, note.Note('D')) >>> st1.show('text', addEndTimes=True) {0.0 - 1.0} {32.0 - 33.0} {33.0 - 34.0} But if we insert something again at the beginning of the stream, everything after the first shifted note begins shifting, so the C and the B shift even though there is a gap there. Normally there's no gaps in a stream, so this will not be a factor: >>> st1.insertAndShift(0, note.Note('E')) >>> st1.show('text', addEndTimes=True) {0.0 - 1.0} {1.0 - 2.0} {33.0 - 34.0} {34.0 - 35.0} In the single argument form with an object, inserts the element at its stored offset: >>> n1 = note.Note('C#') >>> n1.offset = 30.0 >>> n2 = note.Note('D#') >>> n2.offset = 30.0 >>> st1 = stream.Stream() >>> st1.insertAndShift(n1) >>> st1.insertAndShift(n2) # will shift offset of n1 >>> n1.getOffsetBySite(st1) 31.0 >>> n2.getOffsetBySite(st1) 30.0 >>> st1.show('text', addEndTimes=True) {30.0 - 31.0} {31.0 - 32.0} >>> st2 = stream.Stream() >>> st2.insertAndShift(40.0, n1) >>> st2.insertAndShift(40.0, n2) >>> n1.getOffsetBySite(st2) 41.0 In single argument form with a list, the list should contain pairs that alternate offsets and items; the method then, obviously, inserts the items at the specified offsets: >>> n1 = note.Note('G-') >>> n2 = note.Note('F-') >>> st3 = stream.Stream() >>> st3.insertAndShift([1.0, n1, 2.0, n2]) >>> n1.getOffsetBySite(st3) 1.0 >>> n2.getOffsetBySite(st3) 2.0 >>> len(st3) 2 >>> st3.show('text', addEndTimes=True) {1.0 - 2.0} {2.0 - 3.0} N.B. -- using this method on a list assumes that you'll be inserting contiguous objects; you can't shift things that are separated, as this following FAILED example shows. >>> n1 = note.Note('G', type='half') >>> st4 = stream.Stream() >>> st4.repeatAppend(n1, 3) >>> st4.insertAndShift([2.0, note.Note('e'), 4.0, note.Note('f')]) >>> st4.show('text') {0.0} {2.0} {4.0} {5.0} {7.0} As an FYI, there is no removeAndShift() function, so the opposite of insertAndShift(el) is remove(el, shiftOffsets=True). Nrlrrmr) rrrrrmaxrMrrrrrV)rrr insertObjectqLrMlowestOffsetInserthighestTimeInsert insertListrrrolowestElementToShift lowestGapgaplowestOffsetToShiftshiftPoss rJrXStream.insertAndShift sJ  !%L&&44B'F!'  &   J/A4$H$H+J # !% Ac*o%M1u%ZZ--$'(9r6$B!%-1G)*&Qc*o%.L&&44B , 3 3b 8 !-!4!4  $ A""1%A(CQw CO '($  +"&"4"45I"J (>HH q=  ^^&&q),#:--aX>$   " &3rIcU(dUR5nOUR5nUH"nURcMXRlM$ g)a Sets the .derivation.method for each element in the Stream if it has a .derivation object. >>> import copy >>> s = converter.parse('tinyNotation: 2/4 c2 d e f') >>> s2 = copy.deepcopy(s) >>> s2.recurse().notes[-1].derivation from via '__deepcopy__'> >>> s2.setDerivationMethod('exampleCopy', recurse=True) >>> s2.recurse().notes[-1].derivation from via 'exampleCopy'> Without recurse: >>> s = converter.parse('tinyNotation: 2/4 c2 d e f') >>> s2 = copy.deepcopy(s) >>> s2.setDerivationMethod('exampleCopy') >>> s2.recurse().notes[-1].derivation from via '__deepcopy__'> N)rrYrrO)rrrYsIterrs rJsetDerivationMethodStream.setDerivationMethodM s;0IIKELLNEB}}('7 $rIrY allDerivedc^^^^U4UUUU4SjjnURT5n[TSU35e![a Of=fURT5nOK![a> T(a4URTSS9nUbURTTTS9 U"5 UbU"US9 gf=f[ UR 5nXh:aZUR UmTUR U'UR TURT5SS 9 TRRU5 O\URXh- mTURXh- 'UR T[RSS 9 TRRU5 TRRU5 STl[T5UR ;aUR [T5 Sn TR"(aSn UR%U S 9 U"5 g) a Given a `target` object, replace it with the supplied `replacement` object. Does nothing if target cannot be found. Raises StreamException if replacement is already in the stream. If `allDerived` is True (as it is by default), all sites (stream) that this stream derives from and also have a reference for the replacement will be similarly changed. This is useful for altering both a flat and nested representation. >>> cSharp = note.Note('C#4') >>> s = stream.Stream() >>> s.insert(0, cSharp) >>> dFlat = note.Note('D-4') >>> s.replace(cSharp, dFlat) >>> s.show('t') {0.0} If allDerived is True then all streams that this stream comes from get changed (but not non-derived streams) >>> otherStream = stream.Stream() >>> otherStream.insert(0, dFlat) >>> f = note.Note('F4') >>> sf = s.flatten() >>> sf is not s True >>> sf.replace(dFlat, f, allDerived=True) >>> sf[0] is f True >>> s[0] is f True >>> otherStream[0] is dFlat True Note that it does not work the other way: if we made the replacement on `s` then `sf`, the flattened representation, would not be changed, since `s` does not derive from `sf` but vice-versa. With `recurse=True`, a stream can replace an element that is further down in the hierarchy. First let's set up a nested score: >>> s = stream.Score() >>> p = stream.Part(id='part1') >>> s.append(p) >>> m = stream.Measure() >>> p.append(m) >>> cSharp = note.Note('C#4') >>> m.append(cSharp) >>> s.show('text') {0.0} {0.0} {0.0} Now make a deep-nested replacement >>> dFlat = note.Note('D-4') >>> s.replace(cSharp, dFlat, recurse=True) >>> s.show('text') {0.0} {0.0} {0.0} * Changed by v5: `allTargetSites` renamed to `allDerived` -- only searches in derivation chain. * Changed in v5.3: `firstMatchOnly` removed -- impossible to have element in stream twice. `recurse` and `shiftOffsets` changed to keywordOnly arguments * Changed in v6: recurse works * Changed in v7: raises `StreamException` if replacement is already in the stream. c >T(dgURR5H>nURSSS9H'nUTR;dMUR TTTSS9 M) M@ g)NTrvrFr)rchainrYr)replace) startSite derivedSitesubsiterrY replacementrs rJreplaceDerived&Stream.replace..replaceDerived sf(3399; *22tQU2VG&,,.(30738(: W >" 8^^A&F +DNN1   % %k43E3Ef3MZ^ % _    ! !$ '&&qx0F*5D  ah '  % %k=3G3GTX % Y    ! !$ ' D!  f:)) )  F,   L   l ;s!3 AAAABBrYcSSjnU"U5 U(a URSSSS9H nU"U5 M [R"U45$)a Overrides base method :meth:`~music21.base.Music21Object.splitAtDurations` so that once each element in the stream having a complex duration is split into similar, shorter elements representing each duration component, the original element is actually replaced in the stream where it was found with those new elements. Returns a 1-tuple containing itself, for consistency with the superclass method. >>> s = stream.Stream() >>> s.insert(note.Note(quarterLength=5.0)) >>> post = s.splitAtDurations() >>> post (,) >>> [n.duration for n in s] [, ] Unless `recurse=True`, notes in substreams will not be found. >>> s2 = stream.Score() >>> p = stream.Part([note.Note(quarterLength=5)]) >>> s2.append(p) >>> s2.splitAtDurations() (,) >>> [n.duration for n in s2.recurse().notes] [] >>> s2.splitAtDurations(recurse=True) (,) >>> [n.duration for n in s2.recurse().notes] [, ] `recurse=True` should not be necessary to find elements in streams without substreams, such as a loose Voice: >>> v = stream.Voice([note.Note(quarterLength=5.5)], id=1) >>> v.splitAtDurations() (,) >>> [n.duration for n in v.notes] [, ] But a Voice in a Measure (most common) will not be found without `recurse`: >>> m = stream.Measure() >>> v2 = stream.Voice([note.Note(quarterLength=5.25)]) >>> m.insert(v2) >>> m.splitAtDurations() (,) >>> [n.duration for n in m.recurse().notes] [] For any spanner containing the element being removed, the first or last of the replacing components replaces the removed element (according to whether it was first or last in the spanner.) >>> s3 = stream.Stream() >>> n1 = note.Note(quarterLength=5) >>> n2 = note.Note(quarterLength=5) >>> s3.append([n1, n2]) >>> s3.insert(0, spanner.Slur([n1, n2])) >>> post = s3.splitAtDurations() >>> s3.spanners.first().getFirst() is n1 False >>> s3.spanners.first().getFirst().duration >>> s3.spanners.first().getLast().duration Does not act on rests where `.fullMeasure` is True or 'always', nor when `.fullMeasure` is 'auto' and the duration equals the `.barDuration`. This is because full measure rests are usually represented as a single whole rest regardless of their duration. >>> r = note.Rest(quarterLength=5.0) >>> r.fullMeasure = 'auto' >>> v = stream.Voice(r) >>> m = stream.Measure(v) >>> result = m.splitAtDurations(recurse=True) >>> list(result[0][note.Rest]) [] Here is a rest that doesn't fill the measure: >>> m.insert(0, meter.TimeSignature('6/4')) >>> result = m.splitAtDurations(recurse=True) >>> list(result[0][note.Rest]) [, ] But by calling it a full-measure rest, we won't try to split it: >>> r2 = note.Rest(quarterLength=5.0) >>> r2.fullMeasure = True >>> m2 = stream.Measure(r2) >>> m2.insert(0, meter.TimeSignature('6/4')) >>> result = m2.splitAtDurations() >>> list(result[0][note.Rest]) [] c$UR/SQ5GHnURRS:waM [U[R 5(aUR S;aMQ[U[R 5(aUR S:Xa[U[5(aURUR:XaMSUR;aSUR(aBURR(a'URURR:XaGMURnUR5nURXS5 X#SR- nUSSH"nUR!X$5 X$R- nM$ UR#5HSnUR%5ULaUR'XS5 UR)5ULdM?UR'XS5 MU S UR*lGM g) N)rQVariantSpannercomplex)TalwaysautoVoicerrmrF)rrrrr%r fullMeasurerw barDurationclassesr  isMeasurerMsplitAtDurationsrrrVgetSpannerSitesgetFirstrgetLastr.beams)r" complexObj insertPointobjList subsequentsps rJprocessContainer1Stream.splitAtDurations..processContainer\ s'==>^_ &&++y8j$))449O9OSc9cj$))449O9OSY9Y"9g66!+!4!4 8M8M!M !Y%6%66'22'22<<(11Y5I5I5U5UU (// $557!!*aj9qz777 ")!"+J$$[=#;#;;K#. %446B{{} 200QZHzz|z100R[I 7 05 &&,C`rIFTrrvrestoreActiveSites)r"rQ)rYr _SplitTuple)rrYr; innerStreams rJr1Stream.splitAtDurations sTF" 5J  #|| %4D , R  - R((rI) retainOriginaddTiesdisplayTiedAccidentals searchContextc /n[U5nU(aUnOURS5nUR5nUR(aUR USS9n U (a[ R "U S5UlU(a&UR[R5n U bU /nO([UR[R55nU(a[ R "US5UlUR[R5n U b[ R "U 5Ul XR:a[ R""Xx/5$UR%UURSSSSS9n /n /nU H<nUR'U5U:aU R)U5 M+UR)U5 M> U H=nXR'U5- nUR+USUUS9unnUR-SU5 M? UH8nUR-UR/U5U- U5 UR1U5 M: [ R""Xx/5$)z This method overrides the method on Music21Object to provide similar functionality for Streams. Most arguments are passed to Music21Object.splitAtQuarterLength. * Changed in v7: all but quarterLength are keyword only splitAtQuarterLengthFrE returnDefaultrT)rzr{includeElementsThatEndAtStartr|rBrCrD)rcoreCopyAsDerivationrr0getTimeSignaturesrrr6getContextByClassr"r4rrrrrr r?r rrUrGrVrr )rrrBrCrDrE keySignaturessLeftsRighttimeSignatures ksContextendClefr targetSplit targetMoverqlSplit unused_eLefteRights rJrGStream.splitAtQuarterLength s113 }- E--.DEE! ??"44+#5N&*mmN14E&F#!33C4D4DE (%.KM $U%=%=c>N>N%O P &*mmM!4D&E#--dii8G""mmG4 ,, ,##UO4 4++    #"*/! ,   F""6*]:""6*!!&) "F $&9&9&&AAG#)#>#>!'= $?$? L& MM!V $" !F MM&007-G P LL !00rIr prefixSpaces addBreaks addIndent addEndTimesuseMixedNumeralsc ^^^SUUU4Sjjn/nSnTH{n U(aSU-n OSn [U [5(a=URU"X55 URU RX-UUTTS95 MdURU"X55 M} U(aSR U5n U $SR U5n U $) a Used by .show('text') to display a stream's contents with offsets. >>> s1 = stream.Stream() >>> s2 = stream.Stream() >>> s3 = stream.Stream() >>> n1 = note.Note() >>> s3.append(n1) >>> s2.append(s3) >>> s1.append(s2) >>> post = s1.recurseRepr(addBreaks=False, addIndent=False) >>> post '{0.0} / {0.0} <...> / {0.0} ' Made public in v7. Always calls on self. c>URT5nT(a[R"U5nO[R"U5nTSLaUS-U-S-[ U5-$X R R -nT(a[R"U5nO[R"U5nUS-U-S-U-S-[ U5-$)NF{z} z - )rr mixedNumeral strTrimFloatreprrr) in_element in_indentoffGetoffqlqlStrr_rr`s rJ singleElement)Stream.recurseRepr..singleElement s //5F))&1))&1e# 3,t3d:6FFF11???#"//3E"//3E 3,u4u`. >>> s = corpus.parse('demos/two-parts.xml') #_DOCS_HIDE >>> thePlot = s.plot('pianoroll', doneAction=None) #_DOCS_HIDE >>> #_DOCS_SHOW s = corpus.parse('bach/bwv57.8') >>> #_DOCS_SHOW thePlot = s.plot('pianoroll') .. image:: images/HorizontalBarPitchSpaceOffset.* :width: 600 By default, a plot is returned in normal Python environments, but not in Jupyter notebook/JupyterLab/Google Colab. The keyword `returnInNotebook` if True returns a plot no matter what. Changed in v9: Changed default for return in notebook, and added `returnInNotebook` keyword based on changes to recent Jupyter and similar releases. r)graph)xValueyValuezValueN)r?r plotStreamrrunningInNotebookrun) r plotFormatrrrrrrouts rJplot Stream.plotC s\B "        6#;#;#=#=J  rIc 4SSKJn UR"X40UD6$)a< Runs a particular analytical method on the contents of the stream to find its ambitus (range) or key. * ambitus -- runs :class:`~music21.analysis.discrete.Ambitus` * key -- runs :class:`~music21.analysis.discrete.KrumhanslSchmuckler` Some of these methods can take additional arguments. For details on these arguments, see :func:`~music21.analysis.discrete.analyzeStream`. Example: >>> s = corpus.parse('bach/bwv66.6') >>> s.analyze('ambitus') >>> s.analyze('key') Example: music21 allows you to automatically run an analysis to get the key of a piece or excerpt not based on the key signature but instead on the frequency with which some notes are used as opposed to others (first described by Carol Krumhansl). For instance, a piece with mostly Cs and Gs, some Fs, and Ds, but fewer G#s, C#s, etc. is more likely to be in the key of C major than in D-flat major (or A minor, etc.). You can easily get this analysis from a stream by running: >>> myStream = corpus.parse('luca/gloria') >>> analyzedKey = myStream.analyze('key') >>> analyzedKey analyzedKey is a :class:`~music21.key.Key` object with a few extra parameters. correlationCoefficient shows how well this key fits the profile of a piece in that key: >>> analyzedKey.correlationCoefficient 0.86715... `alternateInterpretations` is a list of the other possible interpretations sorted from most likely to least: >>> analyzedKey.alternateInterpretations [, , , ...] Each of these can be examined in turn to see its correlation coefficient: >>> analyzedKey.alternateInterpretations[1].correlationCoefficient 0.788528... >>> analyzedKey.alternateInterpretations[22].correlationCoefficient -0.86728... r)discrete)music21.analysisr analyzeStream)rrOrrs rJanalyzeStream.analyzet sz .%%d?h??rI)rYrc$U(dUR5OUR5nUb%UR[R"U55nU(+UlUH/nXR ;dMUR RU5 M1 g)a Add the group to the groups attribute of all elements. if `classFilter` is set then only those elements whose objects belong to a certain class (or for Streams which are themselves of a certain class) are set. >>> a = stream.Stream() >>> a.repeatAppend(note.Note('A-'), 30) >>> a.repeatAppend(note.Rest(), 30) >>> a.addGroupForElements('flute') >>> a[0].groups ['flute'] >>> a.addGroupForElements('quietTime', note.Rest) >>> a[0].groups ['flute'] >>> a[50].groups ['flute', 'quietTime'] >>> a[1].groups.append('quietTime') # set one note to it >>> a[1].step = 'B' >>> b = a.getElementsByGroup('quietTime') >>> len(b) 31 >>> c = b.getElementsByClass(note.Note) >>> len(c) 1 >>> c[0].name 'B-' If recurse is True then all sub-elements will get the group: >>> s = converter.parse('tinyNotation: 4/4 c4 d e f g a b- b') >>> s.addGroupForElements('scaleNote', 'Note') >>> s.recurse().notes[3].groups [] >>> s.addGroupForElements('scaleNote', 'Note', recurse=True) >>> s.recurse().notes[3].groups ['scaleNote'] No group will be added more than once: >>> s.addGroupForElements('scaleNote', 'Note', recurse=True) >>> s.recurse().notes[3].groups ['scaleNote'] * New in v6.7.1: recurse N)rrY addFilterr0 ClassFilterr>groupsrU)rgroup classFilterrYr sIteratorrs rJaddGroupForElementsStream.addGroupForElements slh(/DIIKDLLN  "!++G,?,? ,LMI+8'8 $BII%   'rIcgrsrCrrhs rJrStream.getElementsByClass  rIcgrsrCrs rJrr rrIcgrsrCrs rJrrrrIc@UR5RU5$)a Return a StreamIterator that will iterate over Elements that match one or more classes in the `classFilterList`. A single class can also be used for the `classFilterList` parameter instead of a List. >>> a = stream.Score() >>> a.repeatInsert(note.Rest(), list(range(10))) >>> for x in range(4): ... n = note.Note('G#') ... n.offset = x * 3 ... a.insert(n) >>> found = a.getElementsByClass(note.Note) >>> found >>> len(found) 4 >>> found[0].pitch.accidental.name 'sharp' >>> foundStream = found.stream() >>> isinstance(foundStream, stream.Score) True Notice that we do not find elements that are in sub-streams of the main Stream. We'll add 15 more rests in a sub-stream, and they won't be found: >>> b = stream.Stream() >>> b.repeatInsert(note.Rest(), list(range(15))) >>> a.insert(b) >>> found = a.getElementsByClass(note.Rest) >>> len(found) 10 To find them either (1) use `.flatten()` to get at everything: >>> found = a.flatten().getElementsByClass(note.Rest) >>> len(found) 25 Or, (2) recurse over the main stream and call .getElementsByClass on each one. Notice that the first subStream is actually the outermost Stream: >>> totalFound = 0 >>> for subStream in a.recurse(streamsOnly=True, includeSelf=True): ... found = subStream.getElementsByClass(note.Rest) ... totalFound += len(found) >>> totalFound 25 The class name of the Stream created is usually the same as the original: >>> found = a.getElementsByClass(note.Note).stream() >>> found.__class__.__name__ 'Score' An exception is if `returnStreamSubClass` is False, which makes the method return a generic Stream: >>> found = a.getElementsByClass(note.Rest).stream(returnStreamSubClass=False) >>> found.__class__.__name__ 'Stream' Make a list from a StreamIterator: >>> foundList = list(a.recurse().getElementsByClass(note.Rest)) >>> len(foundList) 25 )rrrs rJrr sbyy{--o>>rIc>UR5RUSS9$)a Return a list of all Elements that do not match the one or more classes in the `classFilterList`. In lieu of a list, a single class can be used as the `classFilterList` parameter. >>> a = stream.Stream() >>> a.repeatInsert(note.Rest(), list(range(10))) >>> for x in range(4): ... n = note.Note('G#') ... n.offset = x * 3 ... a.insert(n) >>> found = a.getElementsNotOfClass(note.Note) >>> len(found) 10 >>> b = stream.Stream() >>> b.repeatInsert(note.Rest(), list(range(15))) >>> a.insert(b) Here, it gets elements from within a stream this probably should not do this, as it is one layer lower >>> found = a.flatten().getElementsNotOfClass(note.Rest) >>> len(found) 4 >>> found = a.flatten().getElementsNotOfClass(note.Note) >>> len(found) 25 F returnClone)rrrs rJrStream.getElementsNotOfClass]s >yy{00e0TTrIc>UR5RUSS9$)aN >>> n1 = note.Note('C') >>> n1.groups.append('trombone') >>> n2 = note.Note('D') >>> n2.groups.append('trombone') >>> n2.groups.append('tuba') >>> n3 = note.Note('E') >>> n3.groups.append('tuba') >>> s1 = stream.Stream() >>> s1.append(n1) >>> s1.append(n2) >>> s1.append(n3) >>> tboneSubStream = s1.getElementsByGroup('trombone') >>> for thisNote in tboneSubStream: ... print(thisNote.name) C D >>> tubaSubStream = s1.getElementsByGroup('tuba') >>> for thisNote in tubaSubStream: ... print(thisNote.name) D E OMIT_FROM_DOCS # TODO: group comparisons are not YET case insensitive. Fr)rgetElementsByGroup)rgroupFilterLists rJrStream.getElementsByGroup~s 6yy{--o5-QQrIcUR5R[R"U55nUHnUs $ g)a Returns the first encountered element for a given id. Return None if no match. Note: this uses the id attribute stored on elements, which may not be the same as id(e). >>> a = stream.Stream() >>> ew = note.Note() >>> a.insert(0, ew) >>> a[0].id = 'green' >>> None == a.getElementById(3) True >>> a.getElementById('green').id 'green' >>> a.getElementById('Green').id # case does not matter 'green' Getting an element by getElementById changes its activeSite >>> b = stream.Stream() >>> b.append(ew) >>> ew.activeSite is b True >>> ew2 = a.getElementById('green') >>> ew2 is ew True >>> ew2.activeSite is a True >>> ew.activeSite is a True * Changed in v7: remove classFilter. N)rrr0IdFilter)r elementIdrros rJgetElementByIdStream.getElementByIds8BIIK))'*:*:9*EF AHrI)rzr{r|rJ classListc rUR5RUUUUUUS9nUbURU5nU$)a Returns a StreamIterator containing all Music21Objects that are found at a certain offset or within a certain offset time range (given the `offsetStart` and (optional) `offsetEnd` values). There are several attributes that govern how this range is determined: If `mustFinishInSpan` is True then an event that begins between offsetStart and offsetEnd but which ends after offsetEnd will not be included. The default is False. For instance, a half note at offset 2.0 will be found in getElementsByOffset(1.5, 2.5) or getElementsByOffset(1.5, 2.5, mustFinishInSpan=False) but not by getElementsByOffset(1.5, 2.5, mustFinishInSpan=True). The `includeEndBoundary` option determines if an element begun just at the offsetEnd should be included. For instance, the half note at offset 2.0 above would be found by getElementsByOffset(0, 2.0) or by getElementsByOffset(0, 2.0, includeEndBoundary=True) but not by getElementsByOffset(0, 2.0, includeEndBoundary=False). Setting includeEndBoundary to False at the same time as mustFinishInSpan is set to True is probably NOT what you want to do unless you want to find things like clefs at the end of the region to display as courtesy clefs. The `mustBeginInSpan` option determines whether notes or other objects that do not begin in the region but are still sounding at the beginning of the region are excluded. The default is True -- that is, these notes will not be included. For instance the half note at offset 2.0 from above would not be found by getElementsByOffset(3.0, 3.5) or getElementsByOffset(3.0, 3.5, mustBeginInSpan=True) but it would be found by getElementsByOffset(3.0, 3.5, mustBeginInSpan=False) Setting includeElementsThatEndAtStart to False is useful for zeroLength searches that set mustBeginInSpan == False to not catch notes that were playing before the search but that end just before the end of the search type. This setting is *ignored* for zero-length searches. See the code for allPlayingWhileSounding for a demonstration. This chart and the examples below demonstrate the various features of getElementsByOffset. It is one of the most complex methods of music21 but also one of the most powerful, so it is worth learning at least the basics. .. image:: images/getElementsByOffset.* :width: 600 >>> st1 = stream.Stream() >>> n0 = note.Note('C') >>> n0.duration.type = 'half' >>> n0.offset = 0 >>> st1.insert(n0) >>> n2 = note.Note('D') >>> n2.duration.type = 'half' >>> n2.offset = 2 >>> st1.insert(n2) >>> out1 = st1.getElementsByOffset(2) >>> len(out1) 1 >>> out1[0].step 'D' >>> out2 = st1.getElementsByOffset(1, 3) >>> len(out2) 1 >>> out2[0].step 'D' >>> out3 = st1.getElementsByOffset(1, 3, mustFinishInSpan=True) >>> len(out3) 0 >>> out4 = st1.getElementsByOffset(1, 2) >>> len(out4) 1 >>> out4[0].step 'D' >>> out5 = st1.getElementsByOffset(1, 2, includeEndBoundary=False) >>> len(out5) 0 >>> out6 = st1.getElementsByOffset(1, 2, includeEndBoundary=False, mustBeginInSpan=False) >>> len(out6) 1 >>> out6[0].step 'C' >>> out7 = st1.getElementsByOffset(1, 3, mustBeginInSpan=False) >>> len(out7) 2 >>> [el.step for el in out7] ['C', 'D'] Note, that elements that end at the start offset are included if mustBeginInSpan is False >>> out8 = st1.getElementsByOffset(2, 4, mustBeginInSpan=False) >>> len(out8) 2 >>> [el.step for el in out8] ['C', 'D'] To change this behavior set includeElementsThatEndAtStart=False >>> out9 = st1.getElementsByOffset(2, 4, ... mustBeginInSpan=False, includeElementsThatEndAtStart=False) >>> len(out9) 1 >>> [el.step for el in out9] ['D'] Note how zeroLengthSearches implicitly set includeElementsThatEndAtStart=False. These two are the same: >>> out1 = st1.getElementsByOffset(2, mustBeginInSpan=False) >>> out2 = st1.getElementsByOffset(2, 2, mustBeginInSpan=False) >>> len(out1) == len(out2) == 1 True >>> out1[0] is out2[0] is n2 True But this is different: >>> out3 = st1.getElementsByOffset(2, 2.1, mustBeginInSpan=False) >>> len(out3) 2 >>> out3[0] is n0 True Explicitly setting includeElementsThatEndAtStart=False does not get the first note: >>> out4 = st1.getElementsByOffset(2, 2.1, mustBeginInSpan=False, ... includeElementsThatEndAtStart=False) >>> len(out4) 1 >>> out4[0] is n2 True Testing multiple zero-length elements with mustBeginInSpan: >>> tc = clef.TrebleClef() >>> ts = meter.TimeSignature('4/4') >>> ks = key.KeySignature(2) >>> s = stream.Stream() >>> s.insert(0.0, tc) >>> s.insert(0.0, ts) >>> s.insert(0.0, ks) >>> len(s.getElementsByOffset(0.0, mustBeginInSpan=True)) 3 >>> len(s.getElementsByOffset(0.0, mustBeginInSpan=False)) 3 OMIT_FROM_DOCS >>> a = stream.Stream() >>> n = note.Note('G') >>> n.quarterLength = 0.5 >>> a.repeatInsert(n, list(range(8))) >>> b = stream.Stream() >>> b.repeatInsert(a, [0, 3, 6]) >>> c = b.getElementsByOffset(2, 6.9) >>> len(c) 2 >>> c = b.flatten().getElementsByOffset(2, 6.9) >>> len(c) 10 Same test as above, but with floats >>> out1 = st1.getElementsByOffset(2.0) >>> len(out1) 1 >>> out1[0].step 'D' >>> out2 = st1.getElementsByOffset(1.0, 3.0) >>> len(out2) 1 >>> out2[0].step 'D' >>> out3 = st1.getElementsByOffset(1.0, 3.0, mustFinishInSpan=True) >>> len(out3) 0 >>> out3b = st1.getElementsByOffset(0.0, 3.001, mustFinishInSpan=True) >>> len(out3b) 1 >>> out3b[0].step 'C' >>> out3b = st1.getElementsByOffset(1.0, 3.001, ... mustFinishInSpan=True, mustBeginInSpan=False) >>> len(out3b) 1 >>> out3b[0].step 'C' >>> out4 = st1.getElementsByOffset(1.0, 2.0) >>> len(out4) 1 >>> out4[0].step 'D' >>> out5 = st1.getElementsByOffset(1.0, 2.0, includeEndBoundary=False) >>> len(out5) 0 >>> out6 = st1.getElementsByOffset(1.0, 2.0, ... includeEndBoundary=False, mustBeginInSpan=False) >>> len(out6) 1 >>> out6[0].step 'C' >>> out7 = st1.getElementsByOffset(1.0, 3.0, mustBeginInSpan=False) >>> len(out7) 2 >>> [el.step for el in out7] ['C', 'D'] * Changed in v5.5: all arguments changing behavior are keyword only. ) offsetStart offsetEndrzr{r|rJ)rr r) rrrrzr{r|rJrrs rJr Stream.getElementsByOffsetsQZIIK33#1-+*G 4I   !44Y?IrI _beforeNotAtc^/n[U5nUnTR5nU(aURU5nSUlUHnn[UTR U5- 5nUS:d US:XaU(aTR (a O,MHX:XaUR X45 MaX:dMhX4/nUnMp U(a'[UU4SjS9n TRU S5 U S$g)au Given an offset, find the element at this offset, or with the offset less than and nearest to. Return one element or None if no elements are at or preceded by this offset. If the `classList` parameter is used, it should be a list of class names or strings, and only objects that are instances of these classes or subclasses of these classes will be returned. >>> stream1 = stream.Stream() >>> x = note.Note('D4') >>> x.id = 'x' >>> y = note.Note('E4') >>> y.id = 'y' >>> z = note.Rest() >>> z.id = 'z' >>> stream1.insert(20, x) >>> stream1.insert(10, y) >>> stream1.insert( 0, z) >>> b = stream1.getElementAtOrBefore(21) >>> b.offset, b.id (20.0, 'x') >>> b = stream1.getElementAtOrBefore(19) >>> b.offset, b.id (10.0, 'y') >>> b = stream1.getElementAtOrBefore(0) >>> b.offset, b.id (0.0, 'z') >>> b = stream1.getElementAtOrBefore(0.1) >>> b.offset, b.id (0.0, 'z') You can give a list of acceptable classes to return, and non-matching elements will be ignored >>> c = stream1.getElementAtOrBefore(100, [clef.TrebleClef, note.Rest]) >>> c.offset, c.id (0.0, 'z') Getting an object via getElementAtOrBefore sets the activeSite for that object to the Stream, and thus sets its offset >>> stream2 = stream.Stream() >>> stream2.insert(100.5, x) >>> x.offset 100.5 >>> d = stream1.getElementAtOrBefore(20) >>> d is x True >>> x.activeSite is stream1 True >>> x.offset 20.0 If no element is before the offset, returns None >>> s = stream.Stream() >>> s.insert(10, note.Note('E')) >>> print(s.getElementAtOrBefore(9)) None The sort order of returned items is the reverse of the normal sort order, so that, for instance, if there's a clef and a note at offset 20, getting the object before offset 21 will give you the note, and not the clef, since clefs sort before notes: >>> clef1 = clef.BassClef() >>> stream1.insert(20, clef1) >>> e = stream1.getElementAtOrBefore(21) >>> e Frc<>SUS-USRT54$)Nrrrm sortTuplerrs rJ-Stream.getElementAtOrBefore..:sR!A$Y!t@T4UrIr!rmN) rrrr>rrarUrr) rrMrr candidatesnearestTrailSpanrrospanrLs ` rJgetElementAtOrBeforeStream.getElementAtOrBeforesL !&>!IIK !44Y?I', $A#FT-?-?-B$BCDaxDAI,==)!!4),(#i[ #'  **UVG  # #GAJ /1: rIc"URXSS9$)a Get element before (and not at) a provided offset. If the `classList` parameter is used, it should be a list of class names or strings, and only objects that are instances of these classes or subclasses of these classes will be returned. >>> stream1 = stream.Stream() >>> x = note.Note('D4') >>> x.id = 'x' >>> y = note.Note('E4') >>> y.id = 'y' >>> z = note.Rest() >>> z.id = 'z' >>> stream1.insert(20, x) >>> stream1.insert(10, y) >>> stream1.insert( 0, z) >>> b = stream1.getElementBeforeOffset(21) >>> b.offset, b.id (20.0, 'x') >>> b = stream1.getElementBeforeOffset(20) >>> b.offset, b.id (10.0, 'y') >>> b = stream1.getElementBeforeOffset(10) >>> b.offset, b.id (0.0, 'z') >>> b = stream1.getElementBeforeOffset(0) >>> b is None True >>> b = stream1.getElementBeforeOffset(0.1) >>> b.offset, b.id (0.0, 'z') >>> w = note.Note('F4') >>> w.id = 'w' >>> stream1.insert( 0, w) This should get w because it was inserted last. >>> b = stream1.getElementBeforeOffset(0.1) >>> b.offset, b.id (0.0, 'w') But if we give it a lower priority than z then z will appear first. >>> w.priority = z.priority - 1 >>> b = stream1.getElementBeforeOffset(0.1) >>> b.offset, b.id (0.0, 'z') Tr)r)rrMrs rJgetElementBeforeOffsetStream.getElementBeforeOffset?sD(((NNrIczUb [U5nOSnURU5nURnUc-U[U5S- :XagXTS-nUR U5 U$[ US-[U55HAnUb$UR XWR5(dM*XWnUR U5 Us $ g)a Given an element, get the next element. If classList is specified, check to make sure that the element is an instance of the class list >>> st1 = stream.Stream() >>> n1 = note.Note('C4') >>> n2 = note.Note('D4') >>> r3 = note.Rest() >>> st1.append([n1, n2, r3]) >>> t2 = st1.getElementAfterElement(n1) >>> t2 is n2 True >>> t3 = st1.getElementAfterElement(t2) >>> t3 is r3 True >>> t4 = st1.getElementAfterElement(t3) >>> t4 >>> t5 = st1.getElementAfterElement(n1, [note.Rest]) >>> t5 >>> t5 is r3 True >>> t6 = st1.getElementAfterElement(n1, [note.Rest, note.Note]) >>> t6 is n2 True >>> t7 = st1.getElementAfterElement(r3) >>> t7 is None True If the element is not in the stream, it will raise a StreamException: >>> st1.getElementAfterElement(note.Note('C#')) Traceback (most recent call last): music21.exceptions21.StreamException: cannot find object () in Stream Nrm)rer%rrrrangerfru)rrLrruelPosrrors rJgetElementAfterElementStream.getElementAfterElementsR  9~HH  7#==  H ))QY'''*519c(m4$(=(=hk>R>R(S(S A++A.H 5rIcSSjnUR[5nU(ar[U[5(a%[U[[R 45(d [ S5e[R"[[[XQU55$U"U5nSnSn[U[5(a,[R"U5upU (aU n[U5n[U[5(a,[R"U5up*U (aU n[U5nUbm[[XS-55n U(a$UV s/sHoRU ;dMU PM n n O[!U5VV s/sHupUS-U ;dMU PM n nn OUU(a$UV s/sHoRU:dMU PM n n O*[!U5VV s/sHupUS-U:dMU PM n nn UbwU n/n UHmn U RU:waU R#U 5 M&U R$(dU R#U 5 MJU R$U:dM\U R#U 5 Mo UbwU n/n UHmn U RU:waU R#U 5 M&U R$(dU R#U 5 MJU R$U::dM\U R#U 5 Mo U $s sn fs sn nfs sn fs sn nf)NcUH!n[UR5nUS:wdM! g g![a [SU35ef=f)zi Many people create streams where every number is zero. This will check for that as quickly as possible. z)found problematic measure for numbering: rTF)rnumberrro)measureIteratormmNumbers rJhasMeasureNumberInformationKStream._getMeasureNumberListByStartEnd..hasMeasureNumberInformationsZ %[!!((mGa<% "[),UVWUX*YZZ[s )AzFnumberStart and numberEnd must be integers with indicesNotNumbers=Truerm)rz iterator.StreamIterator[Measure]rqbool)rrwrrtypesNoneTyperrrrrr getNumFromStrrerrrrU numberSuffix)r numberStart numberEndindicesNotNumbersr mStreamIterhasUniqueMeasureNumbers startSuffix endSuffixstartSuffixTemp endSuffixTempmatchingMeasureNumbersrmatchesr oldMatchess rJ_getMeasureNumberListByStartEnd&Stream._getMeasureNumberListByStartEnds 9=8O8OPW8X  k3//z)cSXSaSaMb7c7c \66$w-ki.P)QR R"=k"J   k3 ' '+1+?+? +L (K- k*K i % %'-';';I'F $I) II  %({M)J%K "&&1XkXXAW5W1kX)2;)?D)?#$q5,B#B)?D'&1MkXX5L1kM)2;)?=)?'(1u ';)?=  " JG88{*NN1%NN1%^^{2NN1%     JG88y(NN1%NN1%^^y0NN1%  AYDN=s0KK5K"K"K(4K( K-K-rr* Instrumentr4collectgatherSpannersrc[R"[[UR SS95nUnUR UUUS9nU(dSn Sn OUSn U R U5n UHzn U b3U R5RU 5RS5(aM;U RU 5n U cMQU bU RS- U l URSU 5 M| UH(n U R U5U - nURX5 M* UR5 U(a,U[RLnUR!UUR"S9 U$) a Get a region of Measures based on a start and end Measure number where the boundary numbers are both included. That is, a request for measures 4 through 10 will return 7 Measures, numbers 4 through 10. Additionally, any number of associated classes can be gathered from the context and put into the measure. By default, we collect the Clef, TimeSignature, KeySignature, and Instrument so that there is enough context to perform. (See getContextByClass() and .previous() for definitions of the context) While all elements in the source are the original elements in the extracted region, new Measure objects are created and returned. >>> bachIn = corpus.parse('bach/bwv66.6') >>> bachExcerpt = bachIn.parts[0].measures(1, 3) >>> len(bachExcerpt.getElementsByClass(stream.Measure)) 3 Because bwv66.6 has a pickup measure, and we requested to start at measure 1, this is NOT true: >>> firstExcerptMeasure = bachExcerpt.getElementsByClass(stream.Measure).first() >>> firstBachMeasure = bachIn.parts[0].getElementsByClass(stream.Measure).first() >>> firstExcerptMeasure is firstBachMeasure False >>> firstBachMeasure.number 0 >>> firstExcerptMeasure.number 1 To get all measures from the beginning, go ahead and always request measure 0 to x, there will be no error if there is not a pickup measure. >>> bachExcerpt = bachIn.parts[0].measures(0, 3) >>> excerptNote = bachExcerpt.getElementsByClass(stream.Measure).first().notes.first() >>> originalNote = bachIn.parts[0].recurse().notes[0] >>> excerptNote is originalNote True if `indicesNotNumbers` is True, then it ignores defined measureNumbers and uses 0-indexed measure objects and half-open range. For instance, if you have a piece that goes "m1, m2, m3, m4, ..." (like a standard piece without pickups, then `.measures(1, 3, indicesNotNumbers=True)` would return measures 2 and 3, because it is interpreted as the slice from object with index 1, which is measure 2 (m1 has an index of 0) up to but NOT including the object with index 3, which is measure 4. IndicesNotNumbers is like a Python-slice. >>> bachExcerpt2 = bachIn.parts[0].measures(0, 2, indicesNotNumbers=True) >>> for m in bachExcerpt2.getElementsByClass(stream.Measure): ... print(m) ... print(m.number) 0 1 If `numberEnd=None` then it is interpreted as the last measure of the stream: >>> bachExcerpt3 = bachIn.parts[0].measures(7, None) >>> for m in bachExcerpt3.getElementsByClass(stream.Measure): ... print(m) Note that the offsets in the new stream are shifted so that the first measure in the excerpt begins at 0.0 The measure elements are the same objects as the original: >>> lastExcerptMeasure = bachExcerpt3.getElementsByClass(stream.Measure).last() >>> lastOriginalMeasure = bachIn.parts[0].getElementsByClass(stream.Measure).last() >>> lastExcerptMeasure is lastOriginalMeasure True At the beginning of the Stream returned, before the measures will be some additional objects so that the context is properly preserved: >>> for thing in bachExcerpt3: ... print(thing) P1: Soprano: Instrument 1 f# minor Collecting gets the most recent element in the context of the stream: >>> bachIn.parts[0].insert(10, key.Key('D-')) >>> bachExcerpt4 = bachIn.parts[0].measures(7, None) >>> for thing in bachExcerpt4: ... print(thing) P1: Soprano: Instrument 1 D- major ... What is collected is determined by the "collect" iterable. To collect nothing send an empty list: >>> bachExcerpt5 = bachIn.parts[0].measures(8, None, collect=[]) >>> for thing in bachExcerpt5: ... print(thing) If a stream has measure suffixes, then Streams having that suffix or no suffix are returned. >>> p = stream.Part() >>> mSuffix3 = stream.Measure(number=3) >>> mSuffix4 = stream.Measure(number=4) >>> mSuffix4a = stream.Measure(number=4) >>> mSuffix4a.numberSuffix = 'a' >>> mSuffix4b = stream.Measure(number=4) >>> mSuffix4b.numberSuffix = 'b' >>> mSuffix5 = stream.Measure(number=5) >>> mSuffix5a = stream.Measure(number=5) >>> mSuffix5a.numberSuffix = 'a' >>> mSuffix6 = stream.Measure(number=6) >>> p.append([mSuffix3, mSuffix4, mSuffix4a, mSuffix4b, mSuffix5, mSuffix5a, mSuffix6]) >>> suffixExcerpt = p.measures('4b', 6) >>> suffixExcerpt.show('text') {0.0} {0.0} {0.0} {0.0} {0.0} >>> suffixExcerpt2 = p.measures(3, '4a') >>> suffixExcerpt2.show('text') {0.0} {0.0} {0.0} GatherSpanners can change the output: >>> from music21.common.enums import GatherSpanners >>> beachIn = corpus.parse('beach') >>> beachExcerpt = beachIn.measures(3, 4, gatherSpanners=GatherSpanners.ALL) >>> len(beachExcerpt.spannerBundle) 8 >>> len(beachIn.spannerBundle) 94 * Changed in v7: does not create measures automatically. * Changed in v7: If `gatherSpanners` is True or GatherSpanners.ALL (default), then just the spanners pertaining to the requested measure region are provided, rather than the entire bundle from the source. OMIT_FROM_DOCS Ensure that layout.StaffGroup objects are present: >>> for sp in beachExcerpt.spannerBundle.getByClass('StaffGroup'): ... print(sp) <... P5-Staff2>> <...Alto II>> This is in OMIT measuresrrNrlrrm)requireAllPresentconstrainingSpannerBundle)rrrQrwrrrrYrr rNrrrr COMPLETE_ONLYcoreGatherMissingSpannersr)rrrrrrrQsrcObjr startMeasure startOffsetr`foundrmOffsetrs rJrStream.measures9sblFF6'?DOOZO,XY 66  /7 LK"1:L&66v>K I$#++-@@K__`abb!229=E +%1%:%:Q%>EN$$Q.!A''/+=G   , %%' !/>3O3O!O   / /"3*.*<*< 0  rIrrc[U[5(dUS:aSnUnUnU(a US- nUS:XaSnURUUUS9nU(aUSnURU5 U$g)ad Given a measure number, return a single :class:`~music21.stream.Measure` object if the Measure number exists, otherwise return None. This method is distinguished from :meth:`~music21.stream.Stream.measures` in that this method returns a single Measure object, not a Stream containing one or more Measure objects. >>> a = corpus.parse('bach/bwv324.xml') >>> a.parts[0].measure(3) See :meth:`~music21.stream.Stream.measures` for an explanation of collect and indicesNotNumbers To get the last measure of a piece, use -1 as a measureNumber -- this will turn on indicesNotNumbers if it is off: >>> a.parts[0].measure(-1) Getting a non-existent measure will return None: >>> print(a.parts[0].measure(99)) None OMIT_FROM_DOCS >>> sf = a.parts[0].flatten() >>> sf.measure(2) is None True rTrmrNr)rrrr)r measureNumberrrstartMeasureNumberendMeasureNumbermatchingMeasuresrs rJmeasureStream.measure!sJ----!2C $ *(   ! !R'#' ??  /@   #A  # #A &HrI fillWithRests removeClasses retainVoices removeAllexemptFromRemovec .^^^URSS9mUc1SknO8USLa [5nSnO&[R"U5(a [U5nSSS.mUUU4SjnUGHnUR USS9nUR (ajU(dS UR ;aSU"5 URTUUUUS 9n U[R:waTRX5 OTRU 5 MS n USLaSn O>> b = corpus.parse('bwv66.6') >>> sopr = b.parts[0] >>> soprEmpty = sopr.template() >>> soprEmpty.show('text') {0.0} {0.0} {0.0} {0.0} {0.0} {0.0} {0.0} {1.0} {0.0} {5.0} {0.0} {9.0} {0.0} {0.0} {13.0} ... Really make empty with `fillWithRests=False` >>> alto = b.parts[1] >>> altoEmpty = alto.template(fillWithRests=False) >>> altoEmpty.show('text') {0.0} {0.0} {0.0} {0.0} {0.0} {0.0} {1.0} {5.0} {9.0} {0.0} ... `removeClasses` can be a list or set of classes to remove. By default it is ['GeneralNote', 'Dynamic', 'Expression'] >>> tenor = b.parts[2] >>> tenorNoClefsSignatures = tenor.template(fillWithRests=False, ... removeClasses=['Clef', 'KeySignature', 'TimeSignature', 'Instrument']) >>> tenorNoClefsSignatures.show('text') {0.0} {0.0} {0.0} {0.5} {1.0} {0.0} {1.0} {2.0} {3.0} {5.0} ... Setting removeAll to True removes everything that is not a Stream: (this was removeClasses=True; in v9.9 both removeClasses=True or removeAll=True is allowed; in v10 only removeAll=True will be allowed). >>> bass = b.parts[3] >>> bassEmpty = bass.template(fillWithRests=False, removeAll=True) >>> bassEmpty.show('text') {0.0} {1.0} {5.0} {9.0} {13.0} ... `exemptFromRemove` should be a set of classes (or class strings) that are exempted from removal by removeAll or removeClasses >>> bass = b.parts[3] >>> bassEmpty = bass.template(fillWithRests=False, removeAll=True, ... exemptFromRemove={meter.TimeSignature}) >>> bassEmpty[meter.TimeSignature].first() >>> print(bassEmpty[clef.Clef].first()) None Here is an example of exerpts of what calling template() with default values on the whole score looks like. >>> b.template().show('text') {0.0} {0.0} {0.0} {0.0} {0.0} {0.0} {0.0} {0.0} {0.0} {1.0} {0.0} ... {33.0} {0.0} {3.0} {0.0} {0.0} {0.0} {0.0} {0.0} {0.0} {0.0} {0.0} {1.0} {0.0} ... {33.0} {0.0} {3.0} {0.0} If `retainVoices` is False (default True) then Voice streams are treated differently from all other Streams and are removed. All elements in the voice are removed even if they do not match the `classList`: >>> p = stream.Part(id='part0') >>> m1 = stream.Measure(number=1) >>> v1 = stream.Voice(id='voice1') >>> v1.insert(0, note.Note('E', quarterLength=4.0)) >>> v2 = stream.Voice(id='voice2') >>> v2.insert(0, note.Note('G', quarterLength=2.0)) >>> m1.insert(0, v1) >>> m1.insert(0, v2) >>> m2 = stream.Measure(number=2) >>> m2.insert(0, note.Note('D', quarterLength=4.0)) >>> p.append([m1, m2]) >>> pt = p.template(retainVoices=False) >>> pt.show('text') {0.0} {0.0} {4.0} {0.0} >>> pt[0][0].quarterLength 4.0 Developer note -- if you just want a copy of a Score with new Part and Measure objects, but you don't care that the notes, etc. inside are the same objects as the original (i.e., you do not plan to manipulate them, or you want the manipulations to return to the original objects), using .template() is several times faster than a deepcopy of the stream (about 4x faster on bwv66.6) * Changed in v7: all arguments are keyword only. * New in v9.9: added exemptFromRemove * Note: in v10 templaterN>Dynamic Expression GeneralNoteT)rMrNc>T(dgTScgTSTS- n[R"US9nTRTSU5 STS'STS'g)NrMrNr)r%rr)restQLrestObjrrrestInfos rJoptionalAddRest(Stream.template..optionalAddRests` !)i(8H+==Fiif5G NN8H-w 7!%HX "&HY rIrr,rFrMrN)strict)rrerrrrtr/rrr!rrgrurfrrrrziprrwrrr)rrrrrrrrelOffsetoutEl skip_elementrNelNewoldMnewMrrs ` @@rJrStream.template[sThoozo:  DM d "EMI   } - - .M"t4 'B))"D)AH{{  1J! -2?1=.75E $G }333NN83&&u-!LD # ))-88# !g&<# BKK$<$<=M$N$N$ !R[[%>%>&)B)BBG)1-5*.5+ 8I#66.5+7 &?= ! b)}333NN83&&u-_f  # #G ,  " "7 + JD    3 3D ?    ! rIc0n[U;dSU;aIUR[5H0nURU5nXB;a/X$'X$RU5 M2 UHwnU[S4;aMURU5HQnUR [5nUcMUnUR nXB;a/X$'X2U;dM>X$RU5 MS My [ [UR5SS95nU$)a If this Stream contains Measures, returns an OrderedDict whose keys are the offsets of the start of each measure and whose values are a list of references to the :class:`~music21.stream.Measure` objects that start at that offset. Even in normal music there may be more than one Measure starting at each offset because each :class:`~music21.stream.Part` might define its own Measure. However, you are unlikely to encounter such things unless you run Score.flatten(retainContainers=True). The offsets are always measured relative to the calling Stream (self). You can specify a `classFilterList` argument as a list of classes to find instead of Measures. But the default will of course find Measure objects. Example 1: This Bach chorale is in 4/4 without a pickup, so as expected, measures are found every 4 offsets, until the weird recitation in m. 7 which in our edition lasts 10 beats and thus causes a gap in measureOffsetMap from 24.0 to 34.0. .. image:: images/streamMeasureOffsetMapBWV324.* :width: 572 >>> chorale = corpus.parse('bach/bwv324.xml') >>> alto = chorale.parts['#alto'] >>> altoMeasures = alto.measureOffsetMap() >>> altoMeasures OrderedDict([(0.0, []), (4.0, []), (8.0, []), ... (38.0, [])]) >>> list(altoMeasures.keys()) [0.0, 4.0, 8.0, 12.0, 16.0, 20.0, 24.0, 34.0, 38.0] altoMeasures is a dictionary of the measures that are found in the alto part, so we can get the measure beginning on offset 4.0 (measure 2) and display it (though it's the only measure found at offset 4.0, there might be others as in example 2, so we need to call altoMeasures[4.0][0] to get this measure.): >>> altoMeasures[4.0] [] >>> altoMeasures[4.0][0].show('text') {0.0} {1.0} {2.0} {3.0} Example 2: How to get all the measures from all parts (not the most efficient way, but it works!): >>> mom = chorale.measureOffsetMap() >>> mom OrderedDict([(0.0, [, , , ]), (4.0, [, ...])]) >>> for measure_obj in mom[8.0]: ... print(measure_obj, measure_obj.getContextByClass(stream.Part).id) Soprano Alto Tenor Bass Changed in v9: classFilterList must be a list or tuple of strings or Music21Objects OMIT_FROM_DOCS see important examples in testMeasureOffsetMap() and testMeasureOffsetMapPostTie() rwc US$r/rCrs rJr)Stream.measureOffsetMap.. qQRtrIr!) rwrrrUrNrMrritems) rrh offsetMaprrMr`romaybe_morderedOffsetMaps rJmeasureOffsetMapStream.measureOffsetMapesr:<  o %o)E,,W5++A.*(*I%!((+ 6)IWi00,,Y7 --g6?*(*I%f--%,,Q/%8).'vioo.?^'TUrIcbUR5(a;/nURS5H"nURUR55 M$ U$UR 5(a-UR[ 5R 5R$[US5(a UR$gNrQ rightBarline) hasPartLikeStreamsrrU_getFinalBarline hasMeasuresrwrr)rT)rrps rJr+Stream._getFinalBarlines  " " $ $D,,X6 A..017K!!..w7<<>KKK~..(((rIcUR5(ac[R"U5(dU/n[UR S55H&up#X[ U5-nUR U5 M( gUR5(a(XR [5R5l g[US5(aXl ggr() r*rr~rrr_setFinalBarliner,rwrr)rT)rrrr-bls rJr0Stream._setFinalBarlines  " " $ $$$U++!$"9"9("CDs5z>*""2& E      CH # #G , 1 1 3 @ T> * * % +rIaM Get or set the final barline of this Stream's Measures, if and only if there are Measures defined as elements in this Stream. This method will not create Measures if none exist. >>> p = stream.Part() >>> m1 = stream.Measure() >>> m1.rightBarline = bar.Barline('double') >>> p.append(m1) >>> p.finalBarline >>> m2 = stream.Measure() >>> m2.rightBarline = bar.Barline('final') >>> p.append(m2) >>> p.finalBarline This property also works on Scores that contain one or more Parts. In that case a list of barlines can be used to set the final barline. >>> s = corpus.parse('bwv66.6') >>> s.finalBarline [, , , ] >>> s.finalBarline = 'none' >>> s.finalBarline [, , , ] Getting or setting a final barline on a Measure (or another Stream with a rightBarline attribute) is the same as getting or setting the rightBarline. >>> m = stream.Measure() >>> m.finalBarline is None True >>> m.finalBarline = 'final' >>> m.finalBarline >>> m.rightBarline Getting on a generic Stream, Voice, or Opus always returns a barline of None, and setting on a generic Stream, Voice, or Opus always returns None: >>> s = stream.Stream() >>> s.finalBarline is None True >>> s.finalBarline = 'final' >>> s.finalBarline is None True * Changed in v6.3: does not raise an exception if queried or set on a measure-less stream. Previously raised a StreamException docc$URS5$)z Return all :class:`~music21.stream.Voices` objects in an iterator >>> s = stream.Stream() >>> s.insert(0, stream.Voice()) >>> s.insert(0, stream.Voice()) >>> len(s.voices) 2 r,rrs rJvoices Stream.voicesDs&&w//rIcDSSKJn URUR5$)a Return all :class:`~music21.spanner.Spanner` objects (things such as Slurs, long trills, or anything that connects many objects) in an Iterator >>> s = stream.Stream() >>> s.insert(0, spanner.Slur()) >>> s.insert(0, spanner.Slur()) >>> len(s.spanners) 2 rr4)r?r5rr()rr5s rJspannersStream.spannersRs $&&w77rIcUR$)aj Get or set the atSoundingPitch status, that is whether the score is at concert pitch or may have transposing instruments that will not sound as notated. Valid values are True, False, and 'unknown'. Note that setting "atSoundingPitch" does not actually transpose the notes. See `toSoundingPitch()` for that information. >>> s = stream.Stream() >>> s.atSoundingPitch = True >>> s.atSoundingPitch = False >>> s.atSoundingPitch = 'unknown' >>> s.atSoundingPitch 'unknown' >>> s.atSoundingPitch = 'junk' Traceback (most recent call last): music21.exceptions21.StreamException: not a valid at sounding pitch value: junk )r~rs rJatSoundingPitchStream.atSoundingPitchfs,$$$rIc8US;aXlg[SU35e)N)TFrjz%not a valid at sounding pitch value: )r~rorrs rJr=r>~s$ , ,$) !!$I%"QR RrI)reversetransposeKeySignaturepreserveAccidentalDisplaycgrsrCrrArBrCinPlaces rJ_transposeByInstrumentStream._transposeByInstrument rI)rArBrCrFcgrsrCrEs rJrGrHrIrIc U(d[R"U5nOUnURSS9n0nUHnURRXx'M URUlUR SSS9nU(a0[ R[R[R4n O [ R[R4n UR5n UHnURcMURn XR-n UR5R!U U SSSS9R#5n URnU(aUR%5nU(a9U (a2[&R("U 5 U R+USU S9 SSS5 MU R+USU S9 M UR-5HupXRlM U$!,(df  GM=f) a8 Transpose the Stream according to each instrument's transposition. If reverse is False, the transposition will happen in the direction opposite of what is specified by the Instrument. for instance, for changing a concert score to a transposed score or for extracting parts. TODO: Fill out -- expose publicly? Tr$rFrFNry)rFrh)rrgetInstrumentsrrextendDurationr%rrrr"r4haveAccidentalsBeenMade transpositionrMflattenr r6rAr-saveAccidentalDisplayStatusr]r!)rrArBrCrFrQinstrument_streaminstrument_mapinstrhdisplayStatusesAreSetrendfocustrans original_qls rJrGrHs$ d+II%44T4B@B%D#'==#>#>N & &/%7%7".<<\SX<Y !#yy%++s7G7GHO#yy%++6O&*&B&B&D%D!!)KKE,,,C%--/CC#(!& $ D& '-fh  &&E (-B!==eDOOE4OYEDt_U'&,"0!5!5!7 D*5MM '"8EDs ?G G+ cURnURS:XaUUR5H@nURnUR(dM"URS:wdM4URn O gUR SSS9HanURS:XaMURSLaUSLaUR SS9 M:URSLdMKUSLdMRUR SS9 Mc U$)a `atSoundingPitch` might be True, False, or 'unknown'. Given that setting the property does not automatically synchronize the corresponding property on contained or containing streams, any time a method relying on the value of `atSoundingPitch` such as :meth:`toSoundingPitch` visits a stream, it will need to resolve 'unknown' values or even possibly conflicting values. If this stream's `.atSoundingPitch` is 'unknown', this helper method searches this stream's sites until a True or False value for `.atSoundingPitch` is found, since it is possible a user only manipulated the value on the top-level stream. Then, contained streams are searched to verify that they do not contain conflicting values (i.e. .atSoundingPitch = True when the container has .atSoundingPitch = False). Conflicting values are resolved by converting the inner streams to written or sounding pitch as necessary to match this stream's value. rjTFrrL)r= contextSitessitertrYtoSoundingPitchtoWrittenPitch)r at_sounding contextTupler] substreams rJ_treatAtSoundingPitchStream._treatAtSoundingPitchs&**   9 , $ 1 1 3 $((===T%9%9Y%F"&"6"6K !4!$EJI((I5((E1kT6I))$)7**d2{e7K(((6 KrI)rCrFcSSKJn U(dURS5nOUnUR5(dSUR;a>UR [ 5HnURSUS9 M SUlU(dU$S$UR5nUSLa/URSUSS 9 URSSS 9H nSUlM XCRHnUR5 M U(dU$g) a If not at sounding pitch, transpose all Pitch elements to sounding pitch. The atSoundingPitch property is used to determine if transposition is necessary. Affected by the presence of Instruments and by Ottava spanners >>> sc = stream.Score() >>> p = stream.Part(id='barisax') >>> p.append(instrument.BaritoneSaxophone()) >>> m = stream.Measure(number=1) >>> m.append(note.Note('A4')) >>> p.append(m) >>> sc.append(p) >>> sc.atSoundingPitch = False >>> scSounding = sc.toSoundingPitch() >>> scSounding.show('text') {0.0} {0.0} {0.0} {0.0} >>> scSounding.atSoundingPitch True >>> scSounding.parts[0].atSoundingPitch True >>> scSounding.recurse().notes[0].nameWithOctave 'C3' If 'atSoundingPitch' is unknown for this Stream and all of its parent Streams then no transposition will take place, and atSoundingPitch will remain unknown (this used to raise an exception): >>> s = stream.Score() >>> p = stream.Part(id='partEmpty') >>> s.insert(0.0, p) >>> p.toSoundingPitch() >>> s.atSoundingPitch = False >>> sp = p.toSoundingPitch() >>> sp >>> sp.atSoundingPitch 'unknown' >>> sp.derivation.origin is p True * Changed in v2.0.10: inPlace is False * Changed in v5: returns None if inPlace=True * Changed in v9: no transposition instead of exception if atSoundingPitch is 'unknown' rr4r^OpusT)rFrCNFrArCrFr)r?r5rLr*rurrQr^r=rcrGrYOttavaperformTransposition) rrCrFr5rQpartLiker`r"ottavas rJr^Stream.toSoundingPitch s v $112CDII  ' ' ) )Vy7I7I-I%88@(( .G)A )-I %$+9 5 5557 %   , ,*C -  '..4T.R ,0 )S /F  ' ' )0 rI)ottavasToSoundingrCrFcSSKJn U(dURS5nOUnUR5(dSUR;a]UR S5H@n[ R(a[U[5(deURSUUS9 MB SUl ODUR5nUSLa/URSUSS 9 URSSS 9H nSUl M U(a&XTRHn U R!5 M O%XTRHn U R#5 M U(dU$g ) a If not at written pitch, transpose all Pitch elements to written pitch. The atSoundingPitch property is used to determine if transposition is necessary. Note that if ottavasToSounding is True, any notes/chords within an Ottava will _then_ be transposed to sounding Pitch (this is useful for the MusicXML writer, since MusicXML likes all pitches to be written pitches, except for those in ottavas, which should be transposed to written (by instrument) and then transposed to sounding (by ottava). >>> sc = stream.Score() >>> p = stream.Part(id='baritoneSax') >>> p.append(instrument.BaritoneSaxophone()) >>> m = stream.Measure(number=1) >>> m.append(note.Note('C3')) >>> p.append(m) >>> sc.append(p) >>> sc.atSoundingPitch = True >>> scWritten = sc.toWrittenPitch() >>> scWritten.show('text') {0.0} {0.0} {0.0} {0.0} >>> scWritten.atSoundingPitch False >>> scWritten.parts[0].atSoundingPitch False >>> scWritten.recurse().notes[0].nameWithOctave 'A4' * Changed in v3: `inPlace` defaults to `False` * Changed in v5 returns `None` if `inPlace=True` * Changed in v9: no transposition instead of exception if atSoundingPitch is 'unknown' rr4r_rfrQT)rFrmrCFrgrN)r?r5rLr*r/rrrrrQr_r=rcrGrYrhriundoTransposition) rrmrCrFr5rQrjr`r"rks rJr_Stream.toWrittenPitchis<V $112BCII  ' ' ) )Vy7H7H-H%88B??%h7777'' &7.G( C).I %#99;Kd"00 .G 1 "+!2!2tQU!2!VI05I-"W #NN3++-4$NN3((*4 rI)rErIrYsortByCreationTimecU(a"U[RR5nO-UR[R5R5nSURlU(d+U(a$UR SUS9nUbURU5 U(aeU(aUSRS:aK[R"[R<S[R<35nURSU5 U$)aj Collect all :class:`~music21.meter.TimeSignature` objects in this stream. If no TimeSignature objects are defined, get a default (4/4 or whatever is defined in the defaults.py file). >>> s = stream.Part(id='changingMeter') >>> s.repeatInsert(note.Note('C#'), list(range(11))) >>> threeFour = meter.TimeSignature('3/4') >>> s.insert(0.0, threeFour) >>> twoTwo = meter.TimeSignature('2/2') >>> s.insert(3.0, twoTwo) >>> tsStream = s.getTimeSignatures() >>> tsStream.derivation.method 'getTimeSignatures' >>> tsStream >>> tsStream.show('text') {0.0} {3.0} The contents of the time signature stream are the original, not copies of the original: >>> tsStream[0] is threeFour True Many time signatures are found within measures, so this method will find them also and place them at the appropriate point within the overall Stream. N.B. if there are different time signatures for different parts, this method will not distinguish which parts use which time signatures. >>> sm = s.makeMeasures() >>> sm.show('text') {0.0} {0.0} {0.0} {0.0} {1.0} {2.0} {3.0} {0.0} {0.0} {1.0} {2.0} {3.0} {7.0} {0.0} {1.0} {2.0} {3.0} {4.0} >>> tsStream2 = sm.getTimeSignatures() >>> tsStream2.show('text') {0.0} {3.0} If you do not want this recursion, set recurse=False >>> len(sm.getTimeSignatures(recurse=False, returnDefault=False)) 0 We set returnDefault=False here, because otherwise a default time signature of 4/4 is returned: >>> sm.getTimeSignatures(recurse=False)[0] Note that a measure without any time signature can still find a context TimeSignature with this method so long as searchContext is True (as by default): >>> m3 = sm.measure(3) >>> m3.show('text') {0.0} {1.0} {2.0} {3.0} {4.0} >>> m3.getTimeSignatures()[0] The oldest context for the measure will be used unless sortByCreationTime is False, in which case the typical order of context searching will be used. >>> p2 = stream.Part() >>> p2.insert(0, meter.TimeSignature('1/1')) >>> p2.append(m3) >>> m3.getTimeSignatures()[0] If searchContext is False then the default will be returned (which is somewhat acceptable here, since there are 4 quarter notes in the measure) but not generally correct: >>> m3.getTimeSignatures(searchContext=False)[0] * Changed in v8: time signatures within recursed streams are found by default. Added recurse. Removed option for recurse=False and still getting the first time signature in the first measure. This was wholly inconsistent. rMr*)rqrrl/) r$r*r6rrrOrNrUrMrmeterNumeratormeterDenominatorBeatTyperV)rrErIrYrqrr\tss rJrMStream.getTimeSignaturess` ++,335D**5+>+>?FFHD!4 ((M_(`C C  47>>C/((H4K4K4<4U4U*WX Ar" rIsearchActiveSiterIrYcSnU(dUR5nOUR5n[R"[[ R UR[ R 5R55nU(aUR5nOmU(afURbYURR(a>URULa/URRUSS9nUbURSU5 U(a7Uc4SSKJn U"5n[R UlURSU5 U$)a Search this stream (and, by default, its subStreams) or activeSite streams for :class:`~music21.instrument.Instrument` objects, and return a new stream containing them. >>> m1 = stream.Measure([meter.TimeSignature('4/4'), ... instrument.Clarinet(), ... note.Note('C5', type='whole')]) >>> m2 = stream.Measure([instrument.BassClarinet(), ... note.Note('C3', type='whole')]) >>> p = stream.Part([m1, m2]) >>> instruments = p.getInstruments() >>> instruments >>> instruments.show('text') {0.0} {4.0} If there are no instruments, returns a Stream containing a single default `Instrument`, unless returnDefault is False. >>> p = stream.Part() >>> m = stream.Measure([note.Note()]) >>> p.insert(0, m) >>> instrumentStream = p.getInstruments(returnDefault=True) >>> defaultInst = instrumentStream.first() >>> defaultInst Insert an instrument into the Part (not the Measure): >>> p.insert(0, instrument.Koto()) Searching the measure will find this instrument only if the measure's activeSite is searched, as it is by default: >>> searchedActiveSite = p.measure(1).getInstruments() >>> searchedActiveSite.first() >>> searchedNaive = p.measure(1).getInstruments(searchActiveSite=False, returnDefault=False) >>> len(searchedNaive) 0 * Changed in v8: recurse is True by default. NF)ryrIrr)rrYrrrQr rrr6rr rt getInstrumentrVmusic21.instrumentrpartName)rryrIrYinstObjrrrs rJrMStream.getInstrumentsEsh/3IIKELLNEvvfZ223..z/D/DELLN jjlGOO/00 OO47#oo;;)9&+<-G* Aw/ W_ 5 lG (00G  KK7 # rIcDURUUUS9nUR5$)aG Return the first Instrument found in this Stream, or None. >>> s = stream.Score() >>> p1 = stream.Part() >>> p1.insert(instrument.Violin()) >>> m1p1 = stream.Measure() >>> m1p1.append(note.Note('g')) >>> p1.append(m1p1) >>> p2 = stream.Part() >>> p2.insert(instrument.Viola()) >>> m1p2 = stream.Measure() >>> m1p2.append(note.Note('f#')) >>> p2.append(m1p2) >>> s.insert(0, p1) >>> s.insert(0, p2) >>> p1.getInstrument(returnDefault=False).instrumentName 'Violin' >>> p2.getInstrument(returnDefault=False).instrumentName 'Viola' * Changed in v7: added `recurse` (default False) rx)rMr)rryrIrYrs rJr|Stream.getInstruments1</3.A.A-'/B/  zz|rIC4rLcTU(aUnOURS5nUR5R[R5nSnU(d[R "S5nO[ U5S:XaUSnOSnSnURRnU[RHnSU-URR- URlU(a5URURR5URl OSUR[R5n U RURR5URl URRcMSURRlM U(dU$g) a inverts a stream diatonically around the given note (by default, middle C) For pieces where the key signature does not change throughout the piece it is MUCH faster than for pieces where the key signature changes. Here in this test, we put Ciconia's Quod Jactatur (a single voice piece that should have a canon solution: see trecento.quodJactatur) into 3 flats (instead of its original 1 flat) in measure 1, but into 5 sharps in measure 2 and then invert around F4, creating a new piece. >>> qj = corpus.parse('ciconia/quod_jactatur').parts[0].measures(1, 2) >>> qj.id = 'measureExcerpt' >>> qj.show('text') {0.0} {0.0} {0.0} {0.0} {0.0} {0.0} {0.0} {0.0} {1.5} {2.0} {0.0} {0.5} {1.0} {1.5} >>> qjFlat = qj.flatten() >>> k1 = qjFlat.getElementsByClass(key.KeySignature).first() >>> k3flats = key.KeySignature(-3) >>> qjFlat.replace(k1, k3flats, allDerived=True) >>> qj.getElementsByClass(stream.Measure)[1].insert(0, key.KeySignature(5)) >>> qj2 = qj.invertDiatonic(note.Note('F4'), inPlace=False) >>> qj2.show('text') {0.0} {0.0} {0.0} {0.0} {0.0} {0.0} {0.0} {0.0} {1.5} {2.0} {0.0} {0.0} {0.5} {1.0} {1.5} * Changed in v5: inPlace is False by default. invertDiatonicTCrmrNFr)rLrYrr"r4Keyrr&diatonicNoteNumr%NotRestaccidentalByStepstep accidentalrN displayStatus) r inversionNoterF returnStream keySigSearch quickSearchourKey inversionDNNrksActives rJrStream.invertDiatonics?v L445EFL#++-@@AQAQR  WWS\F  ! #!!_FFK$**:: dll+A'(<'7177;R;R&RAGG #%+%<%%>qww||%L"ww!!-37""0, rIc VURHnUbURU5U:aMUbURU5U:aM7Ub"URRU5(aM\UR U[ URU5U-55 M UR 5 g)a Add the given offset value to every offset of the objects found in the Stream. Objects that are specifically placed at the end of the Stream via .storeAtEnd() (such as right barlines) are not affected. If startOffset is given then elements before that offset will not be shifted. If endOffset is given then all elements at or after this offset will be not be shifted. >>> a = stream.Stream() >>> a.repeatInsert(note.Note('C'), list(range(10))) >>> a.shiftElements(30) >>> a.lowestOffset 30.0 >>> a.shiftElements(-10) >>> a.lowestOffset 20.0 Use shiftElements to move elements after a change in duration: >>> st2 = stream.Stream() >>> st2.insert(0, note.Note('D4', type='whole')) >>> st2.repeatInsert(note.Note('C4'), list(range(4, 8))) >>> st2.show('text') {0.0} {4.0} {5.0} {6.0} {7.0} Now make the first note a dotted whole note and shift the rest by two quarters: >>> firstNote = st2[0] >>> firstNoteOldQL = firstNote.quarterLength >>> firstNote.duration.dots = 1 >>> firstNoteNewQL = firstNote.quarterLength >>> shiftAmount = firstNoteNewQL - firstNoteOldQL >>> shiftAmount 2.0 >>> st2.shiftElements(shiftAmount, startOffset=4.0) >>> st2.show('text') {0.0} {6.0} {7.0} {8.0} {9.0} A class filter list may be given. It must be an iterable. >>> st2.insert(7.5, key.Key('F')) >>> st2.shiftElements(2/3, startOffset=6.0, endOffset=8.0, ... classFilterList=[note.Note]) >>> st2.show('text') {0.0} {6.6667} {7.5} {7.6667} {8.0} {9.0} N)rrrurvrrr)rrMr endOffsetrhros rJ shiftElementsStream.shiftElements#sDA&4+=+=a+@;+N$););A)>))K*qzz/D/D_/U/U  % %a0B0B10E0N)O P    "rIcHURUR5 SUlg)a^ Transfer the offset of this stream to all internal elements; then set the offset of this stream to zero. >>> a = stream.Stream() >>> a.repeatInsert(note.Note('C'), list(range(10))) >>> a.offset = 30 >>> a.transferOffsetToElements() >>> a.lowestOffset 30.0 >>> a.offset 0.0 >>> a.offset = 20 >>> a.transferOffsetToElements() >>> a.lowestOffset 50.0 rlN)rrMrs rJtransferOffsetToElementsStream.transferOffsetToElementsrs& 4;;' rIcURnUn[U5H(nUR [ R "U55 M* g![a [S5ef=f)a Given an object and a number, run append that many times on a deepcopy of the object. numberOfTimes should of course be a positive integer. >>> a = stream.Stream() >>> n = note.Note('D--') >>> n.duration.type = 'whole' >>> a.repeatAppend(n, 10) >>> a.show('text') {0.0} {4.0} {8.0} {12.0} ... {36.0} >>> a.duration.quarterLength 40.0 >>> a[9].offset 36.0 Tto put a non Music21Object in a stream, create a music21.ElementWrapper for the itemN)rtrrorrUrr)rr numberOfTimesunusedrLunused_is rJ repeatAppendStream.repeatAppendsd. T]]FGm,H KK g. /- T!#ST T Ts AAc&[R"U5(d[SU35eURnUnUH*n[ R "U5nURXV5 M, UR5 g![a [S5ef=f)a Given an object, create a deep copy of each object at each position specified by the offset list: >>> a = stream.Stream() >>> n = note.Note('G-') >>> n.quarterLength = 1 >>> a.repeatInsert(n, [0, 2, 3, 4, 4.5, 5, 6, 7, 8, 9, 10, 11, 12]) >>> len(a) 13 >>> a[10].offset 10.0 z)must provide an iterable of offsets, not rN) rrrortrrrrr)rroffsetsrrLrM elementCopys rJ repeatInsertStream.repeatInserts  ))!$MgY"WX X T]]FGF--0K OOF 0   " T"#ST T Ts A::BcrURS5nSnSnSn [UR5HPupXLdU RUR:XdM%U nUR U 5nXR R -n MR Uc [S5eURH<n UR U 5n X- U s=::a X-:dM'O M+URX5 M> URH<n UR U 5n X- U s=::a X-:dM'O M+URU 5 M> UR5 U$)aB Extracts elements around the given element within (before) quarter notes and (after) quarter notes (default 4), and returns a new Stream. >>> qn = note.Note(type='quarter') >>> qtrStream = stream.Stream() >>> qtrStream.repeatInsert(qn, [0, 1, 2, 3, 4, 5]) >>> hn = note.Note(type='half') >>> hn.name = 'B-' >>> qtrStream.append(hn) >>> qtrStream.repeatInsert(qn, [8, 9, 10, 11]) >>> hnStream = qtrStream.extractContext(hn, 1.0, 1.0) >>> hnStream.show('text') {5.0} {6.0} {8.0} * Changed in v7: forceOutputClass removed. OMIT_FROM_DOCS TODO: maxBefore -- maximum number of elements to return before; etc. TODO: use .template to get new Stream NOTE: RENAME: this probably should be renamed, as we use Context in a special way. Perhaps better is extractNeighbors? extractContextNrz(Could not find the element in the stream) rrrrrrrrorrrrgr)r searchElementbeforeafter maxBeforemaxAfterdisplayr foundOffsetfoundEndrbrors rJrStream.extractContexts%<//"23 dmm,DA!QTT]-=-=%="003 &)A)AA - =!"LM MA""1%A#q;8+;;;""1( ""A""1%A#q;8+;;;&&q)# ##%rIcrURR5nU(a [5nOUVs1sHn[US5iM nnU(a [5nO8UVs1sH+n[USUSRR -5iM- nn[ URU55$s snfs snf)a Get a list of all offsets and endtimes of notes and rests in this stream. Helper method for makeChords and Chordify run on .flatten().notesAndRests >>> s = stream.Score() >>> p1 = stream.Part() >>> p1.insert(4, note.Note('C#')) >>> p1.insert(5.3, note.Rest()) >>> p2 = stream.Part() >>> p2.insert(2.12, note.Note('D-', type='half')) >>> p2.insert(5.5, note.Rest()) >>> s.insert(0, p1) >>> s.insert(0, p2) We will get a mix of float and fractions.Fraction() objects >>> [str(o) for o in s.flatten()._uniqueOffsetsAndEndTimes()] ['53/25', '4.0', '103/25', '5.0', '53/10', '5.5', '63/10', '6.5'] Limit what is returned: >>> [str(o) for o in s.flatten()._uniqueOffsetsAndEndTimes(offsetsOnly=True)] ['53/25', '4.0', '53/10', '5.5'] >>> [str(o) for o in s.flatten()._uniqueOffsetsAndEndTimes(endTimesOnly=True)] ['103/25', '5.0', '63/10', '6.5'] And this is useless :-) >>> s.flatten()._uniqueOffsetsAndEndTimes(offsetsOnly=True, endTimesOnly=True) [] rrm)rvaluesrerrrrunion)r offsetsOnly endTimesOnlyoffsetDictValuesrvendTimess rJ_uniqueOffsetsAndEndTimes Stream._uniqueOffsetsAndEndTimessJ ++224 eG-=>-=vad|-=G> uH&67%5qtadmm&A&AAB%5 7gmmH-..? 7s B/!2B4)rCaddPartIdAsGroupremoveRedundantPitchesr^ copyPitchesc(^^^^^^UUUUU4SjnU4SjmSmU(asUR5(a<URS5R5RSLaUR SS9nO$URSLaUR SS9nOUnOUnUR5(a$UR[ 5R5nOUnUR SSSS9n U R5(acU R[5n [U 5H>upURU S S S 9n U b U"X5 M#[RS USU 35 M@ OU"X5 U RH?nURcMURRS:wdM.S URlMA [#US5(aPUR$bCUR5S La0U R'S[(R*"UR$55 U $)a( Create a chordal reduction of polyphonic music, where each change to a new pitch results in a new chord. If a Score or Part of Measures is provided, a Stream of Measures will be returned. If a flat Stream of notes, or a Score of such Streams is provided, no Measures will be returned. If using chordify with chord symbols, ensure that the ChordSymbol objects have durations (by default, the duration of a ChordSymbol object is 0, unlike a Chord object). If Harmony objects are not provided a duration, they will not be included in the chordified output pitches but may appear as chord symbols in notation on the score. To realize the chord symbol durations on a score, call :meth:`music21.harmony.realizeChordSymbolDurations` and pass in the score. This functionality works by splitting all Durations in all parts, or if there are multiple parts by all unique offsets. All simultaneous durations are then gathered into single chords. If `addPartIdAsGroup` is True, all elements found in the Stream will have their source Part id added to the element's pitches' Group. These groups names are useful for partially "de-chordifying" the output. If the element chordifies to a :class:`~music21.chord.Chord` object, then the group will be found in each :class:`~music21.pitch.Pitch` element's .groups in Chord.pitches. If the element chordifies to a single :class:`~music21.note.Note` then .pitch.groups will hold the group name. The `addTies` parameter currently does not work for pitches in Chords. If `toSoundingPitch` is True, all parts that define one or more transpositions will be transposed to sounding pitch before chordification. True by default. >>> s = stream.Score() >>> p1 = stream.Part() >>> p1.id = 'part1' >>> p1.insert(4, note.Note('C#4')) >>> p1.insert(5.3, note.Rest()) >>> p2 = stream.Part() >>> p2.id = 'part2' >>> p2.insert(2.12, note.Note('D-4', type='half')) >>> p2.insert(5.5, note.Rest()) >>> s.insert(0, p1) >>> s.insert(0, p2) >>> s.show('text', addEndTimes=True) {0.0 - 6.3} {4.0 - 5.0} {5.3 - 6.3} {0.0 - 6.5} {2.12 - 4.12} {5.5 - 6.5} >>> cc = s.chordify() >>> cc[3] >>> cc[3].duration.quarterLength Fraction(22, 25) >>> cc.show('text', addEndTimes=True) {0.0 - 2.12} {2.12 - 4.0} {4.0 - 4.12} {4.12 - 5.0} {5.0 - 6.5} Here's how addPartIdAsGroup works: >>> cc2 = s.chordify(addPartIdAsGroup=True) >>> cSharpDFlatChord = cc2[2] >>> for p in cSharpDFlatChord.pitches: ... (str(p), p.groups) ('C#4', ['part1']) ('D-4', ['part2']) >>> s = stream.Stream() >>> p1 = stream.Part() >>> p1.insert(0, harmony.ChordSymbol('Cm', quarterLength=4.0)) >>> p1.insert(2, note.Note('C2')) >>> p1.insert(4, harmony.ChordSymbol('D', quarterLength=4.0)) >>> p1.insert(7, note.Note('A2')) >>> s.insert(0, p1) >>> s.chordify().show('text') {0.0} {2.0} {3.0} {4.0} {7.0} Note that :class:`~music21.harmony.ChordSymbol` objects can also be chordified: >>> s = stream.Stream() >>> p2 = stream.Part() >>> p1 = stream.Part() >>> p2.insert(0, harmony.ChordSymbol('Cm', quarterLength=4.0)) >>> p1.insert(2, note.Note('C2')) >>> p2.insert(4, harmony.ChordSymbol('D', quarterLength=4.0)) >>> p1.insert(7, note.Note('A2')) >>> s.insert(0, p1) >>> s.insert(0, p2) >>> s.chordify().show('text') {0.0} {2.0} {3.0} {4.0} {7.0} If addPartIdAsGroup is True, and there are redundant pitches, ensure that the merged pitch has both groups >>> s = stream.Score() >>> p0 = stream.Part(id='p0') >>> p0.insert(0, note.Note('C4')) >>> p1 = stream.Part(id='p1') >>> p1.insert(0, note.Note('C4')) >>> s.insert(0, p0) >>> s.insert(0, p1) >>> s1 = s.chordify(addPartIdAsGroup=True) >>> c = s1.recurse().notes[0] >>> c >>> c.pitches[0].groups ['p0', 'p1'] With copyPitches = False, then the original pitches are retained, which together with removeRedundantPitches=False can be a powerful tool for working back to the original score: >>> n00 = note.Note('C4') >>> n01 = note.Note('E4') >>> n10 = note.Note('E4', type='half') >>> p0 = stream.Part(id='p0') >>> p1 = stream.Part(id='p1') >>> p0.append([n00, n01]) >>> p1.append(n10) >>> s = stream.Score() >>> s.insert(0, p0) >>> s.insert(0, p1) >>> ss = s.chordify(removeRedundantPitches=False, copyPitches=False, addPartIdAsGroup=True) >>> ss.show('text') {0.0} {1.0} >>> c1 = ss.recurse().notes[1] >>> for p in c1.pitches: ... if 'p0' in p.groups: ... p.step = 'G' # make a complete triad >>> n01 * Changed in v5: - Runs a little faster for small scores and run a TON faster for big scores running in O(n) time not O(n^2) - no longer supported: displayTiedAccidentals=False, * Changed in v6.3: Added copyPitches OMIT_FROM_DOCS Test that chordifying works on a single stream. >>> f2 = stream.Score() >>> f2.insert(0, metadata.Metadata()) >>> f2.insert(0, note.Note('C4')) >>> f2.insert(0, note.Note('D#4')) >>> c = f2.chordify() >>> cn = c.notes >>> cn[0].pitches (, ) c >UR[R4S9nUR5nSU;aSU-n[ X3SS5HupE[ XESS9(aMUR U5nXT- nUS:a*[RSS U<S U<S 3-S US U3-5 URUT T T T S9nUR[U5U5 M UR5 T "U5 g)z> streamToChordify is either a Measure or a Score=MeasureSlice rr)rrmNgHz>)abs_tolz(Something is wrong with the verticality z in stream z: rz its endTime z is less than its offset )rCrrr) asTimespansr%r  allTimePointsrr getVerticalityAt environLocalr makeElementrrr) templateInnerstreamToChordify timespanTreerrMrNvertr chordOrRestrrCconsolidateRestsrrs rJchordifyOneMeasure+Stream.chordify..chordifyOneMeasures,774CSCSBU7VL(668M % $} 4 #&}AB6G#H6D9#44V< ' 0  1$ %%B&}&7r$CD( 1J6(ST #..}7>@PF\;F /1 ((E'$I(  - - / ] +rIc>/n[UR5H?n[U[R5(d T"X5 /nM.UR U5 MA T"X5 grs)rrrr%rrU)rconsecutiveRestsrremoveConsecutiveRestss rJr)Stream.chordify..consolidateRestssU! =667!"dii00*=K')$$++B/ 8 #= CrIc[U5S:ag[SU55nURUS5nUHnURU5 M [R "5nX%R lURX55 g)Nrc3L# UHoRRv M g7frs)rr)rnrs rJrpBStream.chordify..removeConsecutiveRests..&sSBRQ 8 8BRs"$r) rsumrr r%rrrrV)rr totalDurationrrrNews rJr/Stream.chordify..removeConsecutiveRests#su#$q(SBRSSM'556Fq6IJK%$$Q'&99;D*7MM '   3rIrQFrL)r )rrrrCTrNzMalformed Part object, z, at measure index z even-tiedr#r)r*rrr=r^rQrr,rwrrrrr\r displayTyperrTr#rVrr)rrCrrr^rrworkObjtemplateStreamrrrtemplateMeasure measurePartr-rrs ``` ` @@rJchordifyStream.chordifyFsf , ,@ D 4 ''))00:@@BRRV[[..u.=%%...u.=G  " " $ $$77?EEGN$N!**9I8=+?    ! !&99'BO&/&@"%ooatoT *&D %%(?yH[\][^&_` 'A x 1!!A||'ALL,D,D ,S-1 *" GZ ( ($$0..0D8 OOAt}}W-=-=> ?rIc URSS9nURSS9nUb URU5R5nOUnUHTnU"U5(a#URUR U5U5 M3URUR U5U5 MV UR H4nU"U5(aUR U5 M#UR U5 M6 UR5 UR5 X44$)a Given a stream, get all objects of type classObj and divide them into two new streams depending on the results of fx. Fx should be a lambda or other function on elements. All elements where fx returns "True" go in the first stream. All other elements are put in the second stream. If classObj is None then all elements are returned. ClassObj can also be a list of classes. In this example, we will create 50 notes from midi note 30 (two octaves and a tritone below middle C) to midi note 80 (an octave and a minor sixth above middle C) and add them to a Stream. We then create a lambda function to split between those notes below middle C (midi note 60) and those above (google "lambda functions in Python" for more information on what these powerful tools are). >>> stream1 = stream.Stream() >>> for x in range(30, 81): ... n = note.Note() ... n.pitch.midi = x ... stream1.append(n) >>> fx = lambda n: n.pitch.midi < 60 >>> b, c = stream1.splitByClass(note.Note, fx) Stream b now contains all the notes below middle C, that is, 30 notes, beginning with F#1 and ending with B3 while Stream c has the 21 notes from C4 to A-5: >>> len(b) 30 >>> (b[0].nameWithOctave, b[-1].nameWithOctave) ('F#1', 'B3') >>> len(c) 21 >>> (c[0].nameWithOctave, c[-1].nameWithOctave) ('C4', 'G#5') splitByClassr)rrr6rrrrgr)rclassObjfxarrros rJrStream.splitByClass]sT OO^O < OO^O <  ++H5<<>EEA!uu U003Q7 U003Q7  ##A!uu  #  # $  t rIc`UcUn/nUR5(a|/n[UR5H&upEURUR 5U45 M( UR S5nU(a"UR SUR5S45 OUS4/nUHupxURHun [U [R5(aM$U RRn URU 5n [X-5n [!XX5n URU 5 Mw M U$)a Returns a list where each element is a NamedTuple consisting of the 'offset' of each element in a stream, the 'endTime' (that is, the offset plus the duration) and the 'element' itself. Also contains a 'voiceIndex' entry which contains the voice number of the element, or None if there are no voices. >>> n1 = note.Note(type='quarter') >>> c1 = clef.AltoClef() >>> n2 = note.Note(type='half') >>> s1 = stream.Stream() >>> s1.append([n1, c1, n2]) >>> om = s1.offsetMap() >>> om[2].offset 1.0 >>> om[2].endTime 3.0 >>> om[2].element is n2 True >>> om[2].voiceIndex Needed for makeMeasures and a few other places. The Stream source of elements is self by default, unless a `srcObj` is provided. (this will be removed in v.8) >>> s = stream.Stream() >>> s.repeatAppend(note.Note(), 8) >>> for om in s.offsetMap(): ... om OffsetMap(element=, offset=0.0, endTime=1.0, voiceIndex=None) OffsetMap(element=, offset=1.0, endTime=2.0, voiceIndex=None) OffsetMap(element=, offset=2.0, endTime=3.0, voiceIndex=None) OffsetMap(element=, offset=3.0, endTime=4.0, voiceIndex=None) OffsetMap(element=, offset=4.0, endTime=5.0, voiceIndex=None) OffsetMap(element=, offset=5.0, endTime=6.0, voiceIndex=None) OffsetMap(element=, offset=6.0, endTime=7.0, voiceIndex=None) OffsetMap(element=, offset=7.0, endTime=8.0, voiceIndex=None) Nr,r) hasVoicesrr7rUrQrrVr6rrrBarlinerrrrrK)rrr"rrr elsNotOfVoicerrOrodurrMrN thisOffsetMaps rJr"Stream.offsetMapsV >F     F!&--0 qyy{A./1"88AM a-"6"6"8$!?@tn%F!' E__a--jj..,,Q/ .!*!W I   /%"(rIc 8[R"UUUUUUUUS9$)z Return a new stream (or if inPlace=True change in place) this Stream so that it has internal measures. For more details, see :py:func:`~music21.stream.makeNotation.makeMeasures`. ) meterStreamrefStreamOrTimeRangerE innerBarline finalBarlinebestClefrF)r- makeMeasures)rrrrErrrrFs rJrStream.makeMeasuress/ (( #!5'%%  rIc 4[R"UUUUUUS9$)zf Calls :py:func:`~music21.stream.makeNotation.makeRests`. * Changed in v7, inPlace=False by default. )rfillGapstimeRangeFromBarDurationrF hideRests)r- makeRests)rrrrrFrs rJrStream.makeRestss)%% !5%=   rIc2[R"UUUUUS9$)z Calls :py:func:`~music21.stream.makeNotation.makeTies`. * Changed in v4: inPlace=False by default. * New in v.7: `classFilterList`. )rrFrDrh)r-makeTies)rrrFrDrhs rJrStream.makeTiess&$$ ##9+   rIrFsetStemDirectionsfailOnNoTimeSignaturec0[R"UUUUS9$)a; Return a new Stream, or modify the Stream in place, with beams applied to all notes. See :py:func:`~music21.stream.makeNotation.makeBeams`. * New in v6.7: setStemDirections. * New in v7: failOnNoTimeSignature raises StreamException if no TimeSignature exists in the stream context from which to make measures. r)r- makeBeams)rrFrrs rJrStream.makeBeams,s#%% /"7   rI) pitchPastpitchPastMeasureotherSimultaneousPitchesuseKeySignaturealteredPitchessearchKeySignatureByContextcautionaryPitchClass cautionaryAllrFoverrideStatuscautionaryNotImmediateRepeat tiePitchSetc jU (dURS5n OUn Uc/nUc/nUc/n/n[U[R5(a URnOiUSLadSnU(a&UR [R5nUbU/nOUR [R5nU(aUSRnX^- nU R5RnU c [5n SnUGHnURb@URR(a%UbURULaUSSn/nURn[U[R5(aURRU ;aSnOSnURR!UUUUUU U US9 UR#UR5 U R%5 UR&b?UR&R(S:wa%U R+URR5 [,R."UUUUUUU U S9 GMD[U[0R25(Ga+[5n[5U5HnURnURU ;aSnOSnUR6Vs/sH nUULdM UPM nnUR!UUUUUUU U US 9 UR&b5UR&R(S:waUR+UR5 [,R."UUUUUUU U S9 M U R%5 UHnU R+U5 M UUR6- n[,R."UUUUUUU U S9 GMU R%5 GM SU R8lU (dU $gs snf) a A method to set and provide accidentals given various conditions and contexts. `pitchPast` is a list of pitches preceding this pitch in this measure. `pitchPastMeasure` is a list of pitches preceding this pitch but in a previous measure. `otherSimultaneousPitches` is a list of other pitches in this simultaneity, for use when `cautionaryPitchClass` is True. If `useKeySignature` is True, a :class:`~music21.key.KeySignature` will be searched for in this Stream or this Stream's defined contexts. An alternative KeySignature can be supplied with this object and used for temporary pitch processing. If `alteredPitches` is a list of modified pitches (Pitches with Accidentals) that can be directly supplied to Accidental processing. These are the same values obtained from a :class:`music21.key.KeySignature` object using the :attr:`~music21.key.KeySignature.alteredPitches` property. If `cautionaryPitchClass` is True, comparisons to past accidentals are made regardless of register. That is, if a past sharp is found two octaves above a present natural, a natural sign is still displayed. If `cautionaryAll` is True, all accidentals are shown. If `overrideStatus` is True, this method will ignore any current `displayStatus` setting found on the Accidental. By default this does not happen. If `displayStatus` is set to None, the Accidental's `displayStatus` is set. If `cautionaryNotImmediateRepeat` is True, cautionary accidentals will be displayed for an altered pitch even if that pitch had already been displayed as altered. If `tiePitchSet` is not None it should be a set of `.nameWithOctave` strings to determine whether following accidentals should be shown because the last note of the same pitch had a start or continue tie. If `searchKeySignatureByContext` is True then keySignatures from the context of the stream will be used if none found. The :meth:`~music21.pitch.Pitch.updateAccidentalDisplay` method is used to determine if an accidental is necessary. This will assume that the complete Stream is the context of evaluation. For smaller context ranges, call this on Measure objects. If `inPlace` is True, this is done in-place; if `inPlace` is False, this returns a modified deep copy. * Changed in v6: does not return anything if inPlace is True. * Changed in v7: default inPlace is False * Changed in v8: altered unisons/octaves in Chords now supply clarifying naturals. All arguments are keyword only. makeAccidentalsNTrF)r r rrrrrlastNoteWasTiedr)r r rrrrr) r r r rrrrrr)rLrr"r4rrNrrYrrer r0r%rr&nameWithOctaveupdateAccidentalDisplayrUrJr'rrr-makeOrnamentalAccidentalsrrrr\r. accidentals)rr r r r rrrrrFrrrrQaddAlteredPitchesksIterks noteIterator last_measurerorseenPitchNamesrr-rpNames rJrStream.makeAccidentals>sL112CDII  I  #!   !N/1 os'7'7 8 8 / > >   $   +++C,<,<=> TF001A1AB%+1I$<$<!+ !((*88  %K%) A||'ALL,B,B+ L0P(1|$ "I || !TYY''77))[8&*O&+O//'%5#1)="/#11M$305  )!!#55$v)=OOAGG$:$:;66'%5#1)="/#11MOAu{{++"%aAA'';6*.*/CD99/_9%PU]^P^9,/_--"+)91I'5-A&3'55Q(7. 9uu(QUUZZ6-A&**1+;+;<!::"+)9'5-A&3'55QS1!D!!#+EOOE*,QYY& 66'%5#1)="/#11MO!!#CF.2 * c0`s  N0)N0c.URR$)a. If Accidentals.displayStatus is None for all contained pitches, it as assumed that accidentals have not been set for display and/or makeAccidentals has not been run. If any Accidental has displayStatus other than None, this method returns True, regardless of if makeAccidentals has actually been run. )r.rrs rJrOStream.haveAccidentalsBeenMades  ,,,rI) rrrFrr r r rrrrrrc U(aUnOURS5nURU(+S9 UR5(dOURSSS9 UR UUSUS9 UR5(d[ S[ U5S35eURR(d[R"UUUUUU U U U U S9 [R"XSS 9 UR[5H/n[R"USSS 9 [R"USSS 9 M1 URR (d[R""USS 9 UR[5H5nURR.(aM [R0"USS 9 M7 U(dU$g ![$R&a)n[(R*"[-U55 S nANS nAff=f)a This method calls a sequence of Stream methods on this Stream to prepare notation, including creating voices for overlapped regions, Measures if necessary, creating ties, beams, accidentals, and tuplet brackets. If `inPlace` is True, this is done in-place. if `inPlace` is False, this returns a modified deep copy. The following additional parameters are documented on :meth:`~music21.stream.base.makeAccidentals`:: pitchPast pitchPastMeasure useKeySignature alteredPitches cautionaryPitchClass cautionaryAll overrideStatus cautionaryNotImmediateRepeat tiePitchSet >>> s = stream.Stream() >>> n = note.Note('g') >>> n.quarterLength = 1.5 >>> s.repeatAppend(n, 10) >>> sMeasures = s.makeNotation() >>> len(sMeasures.getElementsByClass(stream.Measure)) 4 >>> sMeasures.getElementsByClass(stream.Measure).last().rightBarline.type 'final' * Changed in v7: `inPlace=True` returns `None`. r-)rVTrFrrrrFrz!no measures found in stream with z elements) r r r rrrrrr)rrFrYrCrY onlyIfTiedrLN)rLrr, makeVoicesrrorr.rr-makeAccidentalsInMeasureStreamrrrwsplitElementsToCompleteTupletsconsolidateCompletedTupletsr5rr$MeterExceptionrrrtupletsmakeTupletBrackets)rrrrFrr r r rrrrrrrrmes rJr-Stream.makeNotation*sh L44^DL ..; / ''))  # #D4 # @  % %'%9! & #  ++--%7D {)LNN((44  7 7#!1 /-%9+--I' ) lTR009A  7 74QU V  4 4QQU V:((.. '&&|TB009A>>)))//4@: '' ' c"g&& 'sF22G/G**G/cU(dURS5nOUnURRn[UR U55n[ XUSS5H8upgUR U5UR U5- nXRlM: U(a)UUR US5- USRlU(dU$g)ad Given a Stream and an object class name, go through the Stream and find each instance of the desired object. The time between adjacent objects is then assigned to the duration of each object. The last duration of the last object is assigned to extend to the end of the Stream. If `inPlace` is True, this is done in-place; if `inPlace` is False, this returns a modified deep copy. >>> stream1 = stream.Stream() >>> n = note.Note(type='quarter') >>> n.duration.quarterLength 1.0 >>> stream1.repeatInsert(n, [0, 10, 20, 30, 40]) >>> dyn = dynamics.Dynamic('ff') >>> stream1.insert(15, dyn) >>> stream1[-1].offset # offset of last element 40.0 >>> stream1.duration.quarterLength # total duration 41.0 >>> len(stream1) 6 >>> stream2 = stream1.flatten().extendDuration(note.GeneralNote, inPlace=False) >>> len(stream2) 6 >>> stream2[0].duration.quarterLength 10.0 The Dynamic does not affect the second note: >>> stream2[1].offset 10.0 >>> stream2[1].duration.quarterLength 10.0 >>> stream2[-1].duration.quarterLength # or extend to end of stream 1.0 >>> stream2.duration.quarterLength 41.0 >>> stream2[-1].offset 40.0 rNrmNr)rLrrrrrr) robjClassrFrQ qLenTotalrrL nextElementrs rJrNStream.extendDurations^112BCII&&44  44X>?$'12,$? G**;7):Q:QRY:ZZD-1   *%@ 3<5>5L5LXVX\5Z4[HRL ! ! / rI) matchByPitchcgrsrCrrFr:s rJ stripTiesStream.stripTiesrIrFr:cU$rsrCr<s rJr=r>s  rIc4^^^^U(dURS5nOUnSURlUR5(a6UR [ 5HnUR STS9 M U(dU$gUR5(a-URHnUR STS9 M U(dU$gUR5nURRS5R5n/m/nSUUUU4Sjjn SSjn [[U55GHn Sn X{n U S :a U S - mUTmOSmSm[U S 5(aNU R bAU R R"S :Xa'TbTT;aU /mOTT;aTR%U 5 Sn O[U S 5(aU R bU R R"S :XaT(dTR%U 5 Sn OT(a)U "U 5nU(aTR%U 5 Sn OzU /mSn OtU "U 5(ac['T[(R*5(a0[TR,5[U R,5:waU /mOTR%U 5 Sn O/mSn U cU "U 5n U (dGMTR%U 5 [T5S:a/mGMS nTS SH%nXUR.- nUR%U5 M' US :Xa [1S5e[2R4"[(R6UTS 5nUR.nUR8R:(dSUR8l[=UU-5UlSUlUR?5 UR@H/nTS SH#nUUU;dMURCUUU5 M% M1 /mGM URE5 UHn X{nURGUSS9 M U(dU$g)a Find all notes that are tied; remove all tied notes, then make the first of the tied notes have a duration equal to that of all tied constituents. Lastly, remove the formerly-tied notes. This method can be used on Stream and Stream subclasses. When used on a stream containing Part-like substreams, as with many scores, :class:`~music21.stream.Part`, :class:`~music21.stream.Measure`, and other Stream subclasses are retained. `inPlace` controls whether the input stream is modified or whether a deep copy is made. (New in v7, to conform to the rest of music21, `inPlace=True` returns `None`.) Presently, this only works if tied notes are sequential in the same voice; ultimately this will need to look at .to and .from attributes (if they exist) >>> a = stream.Stream() >>> n = note.Note() >>> n.quarterLength = 6 >>> a.append(n) >>> m = a.makeMeasures() >>> m.makeTies(inPlace=True) >>> len(m.flatten().notes) 2 >>> m = m.stripTies() >>> len(m.flatten().notes) 1 In cases where notes are manipulated after initial tie creation, some chord members might lack ties. This will not prevent merging the tied notes if all the pitches match, and `matchByPitch=True` (default): >>> c1 = chord.Chord('C4 E4') >>> c1.tie = tie.Tie('start') >>> c2 = chord.Chord('C4 E4') >>> c2.tie = tie.Tie('stop') >>> m = stream.Measure() >>> m.append([c1, c2]) >>> c1.add(note.Note('G4')) >>> c2.add(note.Note('G4')) >>> c2.notes[-1].tie is None True >>> strippedPitchMatching = m.stripTies() >>> len(strippedPitchMatching.flatten().notes) 1 This can be prevented with `matchByPitch=False`, in which case every note, including each chord member, must have "stop" and/or "continue" tie types, which was not the case above: >>> strippedMixedTieTypes = m.stripTies(matchByPitch=False) >>> len(strippedMixedTieTypes.flatten().notes) 2 >>> c2.notes[0].tie = tie.Tie('stop') >>> c2.notes[1].tie = tie.Tie('stop') >>> c2.notes[2].tie = tie.Tie('stop') >>> strippedUniformTieTypes = m.stripTies(matchByPitch=False) >>> len(strippedUniformTieTypes.flatten().notes) 1 Notice the matching happens even after altering the pitches: >>> c3 = c2.transpose(6) >>> otherM = stream.Measure([c1, c3]) >>> strippedTransposed = otherM.stripTies(matchByPitch=False) >>> len(strippedTransposed.flatten().notes) 1 When `matchByPitch` is True (as it is by default) the following behavior defined regarding chords with a tie type "continue": >>> c1.notes[0].tie = tie.Tie('continue') >>> c1.notes[1].tie = tie.Tie('start') >>> c1.notes[2].tie = tie.Tie('start') Continue is accepted here as an ersatz-start: >>> stripped1 = m.stripTies(matchByPitch=True) >>> len(stripped1.flatten().notes) 1 But prepend an element so that it's considered as a tie continuation: >>> c0 = chord.Chord('C4 E4 G4') >>> c0.tie = tie.Tie('start') >>> m2 = stream.Measure() >>> m2.append([c0, c1, c2]) Now the mixed tie types on c1 will only be connected to c2 on the permissive option (`matchByPitch=True`): >>> stripped2 = m2.stripTies(matchByPitch=True) >>> stripped2.elements (,) >>> stripped3 = m2.stripTies(matchByPitch=False) >>> stripped3.elements (, , ) Now correct the tie types on c1 and try the strict option: >>> c1.notes[0].tie = tie.Tie('continue') >>> c1.notes[1].tie = tie.Tie('continue') >>> c1.notes[2].tie = tie.Tie('continue') >>> stripped4 = m2.stripTies(matchByPitch=False) >>> stripped4.elements (,) Now replace the first element with just a single C4 note. The following chords will be merged with each other, but not with the single note, even on `matchByPitch=False`. (`matchByPitch=False` is permissive about pitch but strict about cardinality.) >>> newC = note.Note('C4') >>> newC.tie = tie.Tie('start') >>> m2.replace(c0, newC) >>> stripped5 = m2.stripTies(matchByPitch=False) >>> stripped5.elements (, ) * Changed in v7: `matchByPitch` defaults True r=FTr@Nc URS:$r/r )r _iterators rJr"Stream.stripTies..s""2"2Q"6rIc*>[US5(aG[U[R5(d(URbURR S:XagT(d[U[R5(a[T[R5(aSUR Vs/sHoRPM sn;abUR Vs1sHoRR iM snS1:Xa-[TR5[UR5:XagT(dgTbTT;a{[TS5(aj[US5(aY[T[R5(d:[U[R5(dTRUR:XagTb[U[R5(dTT;a[TS5(a[US5(a[TR5[UR5:wag[TRUR5H7up#URUR:wdURU5(aM7 g ggs snfs snf)z: updateEndMatch based on nList, iLast, matchByPitch, etc. r'NrTFr&r\)rTrrrr'rr[rr\r&r%rrr isEnharmonic)nInnerinner_ppLastpInneriLastr:nLast posConnecteds rJupdateEndMatch(Stream.stripTies..updateEndMatchs&&&vu{{;; . 61!"65;;77"5%++66 $M W[[ $MM9?Fg))F6(REMM*c&...AA"!-w//00'uekk::&vu{{;; v||3!&vtyy99-y11 22u}}%V^^)<< %(%GMEzzV[[08J8J68R8R$ &H S%NFs .J JcURcgURRS:wag[U[R5(a>UR H.nURc gURRS:wdM. g g)NFcontinueT)r'rrrrr[)nrinnerNs rJallTiesAreContinue,Stream.stripTies..allTiesAreContinuesgvv~vv{{j("ekk** hhFzz)$zz*4$ ' rIrrmr'rrRrz(aggregated ties have a zero duration sumr$rqr)rS note.NotRestrqr)$rLr.r5r*rrQr=rr7rQrrr6rrrTr'rrUrr%rr\rrorrr rlinkedr informSitesr:rrAr )rrFr:rQr-rfnotes_and_rests posDeleterOrUrendMatchr tempEndMatchdurSumq changing_noteqLenr:r%nTargetrLrMrNs ` @@@rJr=r>sX11+>II(- $  ' ' ) )11&9 D| D:      %% D| D&      &'oo&?&? 6' &(   = = ~ s?+,AH"A1uA'.5!!) g-=E$=$%3Ll* ''* !U##) j0# ''*$H!$2!#4L#$++A.#()*s #('**"%66C >>F$$Q'*Q;)*TUU!"t'7'7VW9Y Z $22$--4448M**1.4TF].C +%) !))+**B!-ab!1*51R744 / 6 -"2% " c-h A&(G   Wd  3  rIc^U4SjnUR5RR5n[U5GHupV/n[ U[ R 5(aU/nO-[ U[R5(a [U5nOMXU"XEURU5URR-5n[R"Xx5Hup/n [ U [ R 5(aU /n O*[ U [R5(a [U 5n U Hn [U R U5[U R U5:XdM3U R"c["R$"S5U lO+U R"R&S:XaSU R"l["R$"S5U l M M GM g)aY Connect any adjacent pitch space values that are the same with a Tie. Adjacent pitches can be Chords, Notes, or Voices. If `ignoreRests` is True, rests that occur between events will not be considered in matching pitches. The `pitchAttr` determines the pitch attribute that is used for comparison. Any valid pitch attribute name can be used. c>U[U5S- :Xa/$T(aw[US-[UR55HQnURUn[U[R 5(dM3URUR U5n O URU5n/nUH5n[U[R 5(dM$URU5 M7 U$)Nrm) rrrrr%rrr rU) srcStream currentIndex targetOffsetjrr=rmatchEl ignoreRestss rJ_getNextElements+Stream.extendTies.._getNextElementsss9~11 |a/Y5H5H1IJA",,Q/B!"dll33'0':':1'='M'M%('  K11,?ED gt||44KK(!KrINrrrR)rQr[r6rrr%rrrrrrr itertoolsproductrVr&r'Tier) rrl pitchAttrrmsrcFlatrropSrc connectionsr-rmSrcras ` rJ extendTiesStream.extendTies~sY 6,,.&&--/g&DAD!TYY''sAu{{++Aw*7+,+<+>> n1 = note.Note('A') >>> n2 = note.Note('B') >>> s = stream.Stream() >>> s.autoSort = False >>> s.insert(100, n2) >>> s.insert(0, n1) # now a has a lower offset by higher index >>> [n.name for n in s] ['B', 'A'] >>> s[0].name 'B' >>> s.sort() >>> s[0].name 'A' >>> [n.name for n in s] ['A', 'B'] c&>URT5$rsrrs rJrStream.sort..sakk$.?rIr!c&>URT5$rsrrs rJrr{sT1BrIF)r rx keepIndexTN)rarrrrr)rforces` rJr Stream.sortsn< $--E NN  $?  @    " "'B " C  $ $"# %  !DM5:rIcURRS5nUbU$[R"UR5n[R"UR5n[R"U5nX$lX4lX#-HNnUR XPR U5SS9 URRU5 URU5 MP UR5 X@RS'U$)a (TL;DR: you probably do not need to call this method unless you have turned `.autoSort` to off.) Returns a new Stream where all the elements are sorted according to offset time, then priority, then classSortOrder (so that, for instance, a Clef at offset 0 appears before a Note at offset 0). If this Stream is not flat, then only the elements directly in the stream itself are sorted. To sort all, run myStream.flatten().sorted(). For instance, here is an unsorted Stream: >>> s = stream.Stream() >>> s.autoSort = False # if True, sorting is automatic >>> s.insert(1, note.Note('D')) >>> s.insert(0, note.Note('C')) >>> s.show('text') {1.0} {0.0} But a sorted version of the Stream puts the C first: >>> s.sorted().show('text') {0.0} {1.0} While the original stream remains unsorted: >>> s.show('text') {1.0} {0.0} OMIT_FROM_DOCS >>> s = stream.Stream() >>> s.autoSort = False >>> s.repeatInsert(note.Note('C#'), [0, 2, 4]) >>> s.repeatInsert(note.Note('D-'), [1, 3, 5]) >>> s.isSorted False >>> g = '' >>> for myElement in s: ... g += '%s: %s; ' % (myElement.offset, myElement.name) >>> g '0.0: C#; 2.0: C#; 4.0: C#; 1.0: D-; 3.0: D-; 5.0: D-; ' >>> y = s.sorted() >>> y.isSorted True >>> g = '' >>> for myElement in y: ... g += '%s: %s; ' % (myElement.offset, myElement.name) >>> g '0.0: C#; 1.0: D-; 2.0: C#; 3.0: D-; 4.0: C#; 5.0: D-; ' >>> farRight = note.Note('E') >>> farRight.priority = 5 >>> farRight.offset = 2.0 >>> y.insert(farRight) >>> g = '' >>> for myElement in y: ... g += '%s: %s; ' % (myElement.offset, myElement.name) >>> g '0.0: C#; 1.0: D-; 2.0: C#; 3.0: D-; 4.0: C#; 5.0: D-; 2.0: E; ' >>> z = y.sorted() >>> g = '' >>> for myElement in z: ... g += '%s: %s; ' % (myElement.offset, myElement.name) >>> g '0.0: C#; 1.0: D-; 2.0: C#; 2.0: E; 3.0: D-; 4.0: C#; 5.0: D-; ' >>> z[2].name, z[3].name ('C#', 'E') * Changed in v7: made into a method, not a property. rTr) rgetrrrrrr)rrr)r cache_sortedshallowElementsshallowEndElementsrros rJr Stream.sorteds\{{x0  # ))DNN3!YYt'8'89 IIdO& + 5A " "1&8&8&; " M GGKKN  # 6  ! HrIc\U(aSnOSnURRU5nUbU$[R"U5nUR[U5:waWURn[ U[ 5(aU[ R:a [U5n[U5S-U-nXdl[R"U5nXl X'l Xtl 0Ul0Ul/Ul/UlUR#5 [$R&"USSSS9nUH<n U R((a U(dMUR+UR-5U SS9 M> U(dSUlUR0SLaUR35 OUR#5 X@RU'U$)ar A very important method that returns a new Stream that has all sub-containers "flattened" within it, that is, it returns a new Stream where no elements nest within other elements. Here is a simple example of the usefulness of .flatten(). We will create a Score with two Parts in it, each with two Notes: >>> sc = stream.Score() >>> p1 = stream.Part() >>> p1.id = 'part1' >>> n1 = note.Note('C4') >>> n2 = note.Note('D4') >>> p1.append(n1) >>> p1.append(n2) >>> p2 = stream.Part() >>> p2.id = 'part2' >>> n3 = note.Note('E4') >>> n4 = note.Note('F4') >>> p2.append(n3) >>> p2.append(n4) >>> sc.insert(0, p1) >>> sc.insert(0, p2) When we look at sc, we will see only the two parts: >>> sc.elements (, ) We can get at the notes by using the indices of the stream to get the parts and then looking at the .elements there: >>> sc[0].elements (, ) >>> sc.getElementById('part2').elements (, ) If, however, we want to get all the notes, storing their offsets related to the beginning of the containing stream, one way is via calling .flatten() on sc and looking at the elements there: >>> sc.flatten().elements (, , , ) Flattening a stream is a great way to get at all the notes in a larger piece. For instance if we load a four-part Bach chorale into music21 from the integrated corpus, it will appear at first that there are no notes in the piece: >>> bwv66 = corpus.parse('bach/bwv66.6') >>> len(bwv66.notes) 0 This is because all the notes in the piece lie within :class:`music21.stream.Measure` objects and those measures lie within :class:`music21.stream.Part` objects. It'd be a pain to navigate all the way through all those objects just to count notes. Fortunately we can get a Stream of all the notes in the piece with .flatten().notes and then use the length of that Stream to count notes: >>> bwv66flat = bwv66.flatten() >>> len(bwv66flat.notes) 165 When, as is commonly the case, we want to find all the notes, but do not care to have offsets related to the origin of the stream, then `.recurse()` is a more efficient way of working: >>> len(bwv66.recurse().notes) 165 If `retainContainers=True` then a "semiFlat" version of the stream is returned where Streams are also included in the output stream. In general, you will not need to use this because `.recurse()` is more efficient and does not lead to problems of the same object appearing in the hierarchy more than once. >>> n1 = note.Note('C5') >>> m1 = stream.Measure([n1], number='1a') >>> p1 = stream.Part([m1]) >>> p1.id = 'part1' >>> n2 = note.Note('D5') >>> m2 = stream.Measure([n2], number='1b') >>> p2 = stream.Part([m2]) >>> p2.id = 'part2' >>> sc = stream.Score([p1, p2]) `sf` will be the "semi-flattened" version of the score. >>> sf = sc.flatten(retainContainers=True) >>> sf.elements (, , , , , ) >>> sf[0] Notice that these all return the same object: >>> sf[0][0][0] >>> sf[1][0] >>> sf[4] Unless it is important to get iterate in order from front of score to back of the score, you are generally better off using recurse instead of `.flatten(retainContainers=True)`, with `.getOffsetInHierarchy()` to figure out where in the score each element lies. For instance, this is how we can iterate using recurse(): >>> for el in sc.recurse(): ... print(el) If you look back to our simple example of four notes above, you can see that the E (the first note in part2) comes before the D (the second note of part1). This is because the flat stream is automatically sorted like all streams are by default. The next example shows how to change this behavior. >>> s = stream.Stream() >>> s.autoSort = False >>> s.repeatInsert(note.Note('C#'), [0, 2, 4]) >>> s.repeatInsert(note.Note('D-'), [1, 3, 5]) >>> s.isSorted False >>> g = '' >>> for myElement in s: ... g += '%s: %s; ' % (myElement.offset, myElement.name) ... >>> g '0.0: C#; 2.0: C#; 4.0: C#; 1.0: D-; 3.0: D-; 5.0: D-; ' >>> y = s.sorted() >>> y.isSorted True >>> g = '' >>> for myElement in y: ... g += '%s: %s; ' % (myElement.offset, myElement.name) ... >>> g '0.0: C#; 1.0: D-; 2.0: C#; 3.0: D-; 4.0: C#; 5.0: D-; ' >>> q = stream.Stream() >>> for i in range(5): ... p = stream.Stream() ... p.repeatInsert(base.Music21Object(), [0, 1, 2, 3, 4]) ... q.insert(i * 10, p) ... >>> len(q) 5 >>> qf = q.flatten() >>> len(qf) 25 >>> qf[24].offset 44.0 Note that combining `.flatten(retainContainers=True)` with pure `.flatten()` can lead to unstable Streams where the same object appears more than once, in violation of a `music21` lookup rule. >>> sc.flatten(retainContainers=True).flatten().elements (, , , , , ) OMIT_FROM_DOCS >>> r = stream.Stream() >>> for j in range(5): ... q = stream.Stream() ... for i in range(5): ... p = stream.Stream() ... p.repeatInsert(base.Music21Object(), [0, 1, 2, 3, 4]) ... q.insert(i * 10, p) ... r.insert(j * 100, q) >>> len(r) 5 >>> len(r.flatten()) 125 >>> r.flatten()[124].offset 444.0 semiFlatrZ_FT)r>r ignoreSortingr)rrrrrrr#minIdNumberToConsiderMemoryLocationrrr DerivationrNrOrrrrr/RecursiveIteratorrtrcurrentHierarchyOffsetrcrbr) rretainContainersrOcached_versionsNewsOldIdnewIdsNew_derivationriros rJrQStream.flattenXsux FF0  %! ! yy 77bh WWF&#&&6H4`4`+`VK#%.EG$//5!%!')    "5=5O5O $ 6 Azz"2 OOB557+0  2  DK ==D IIK  $ $ &" F rIc2URSS9nSUlU$)z Deprecated: use `.flatten()` instead A property that returns the same flattened representation as `.flatten()` as of music21 v7. See :meth:`~music21.stream.base.Stream.flatten()` for documentation. F)rT)rQr{)r flatStreams rJrZ Stream.flatqs"\\5\9 26 /rIrC)rvr>rrc[R"[R[[R"U55$rs)rrr/rrrrvr>rrs rJrYStream.recurses,vvh00X>XY]>^__rI)r>rrc[R"[R[[R"U5R [55$rs)rrr/rrQrrs rJrYrs=vvh008006II&QS SrIc[R"UUUUS9nU(aURU5n[R(a3U(a,[R "[R[ U5$U$)a `.recurse()` is a fundamental method of music21 for getting into elements contained in a Score, Part, or Measure, where elements such as notes are contained in sub-Stream elements. Returns an iterator that iterates over a list of Music21Objects contained in the Stream, starting with self's elements (unless includeSelf=True in which case, it starts with the element itself), and whenever finding a Stream subclass in self, that Stream subclass's elements. Here's an example. Let's create a simple score. >>> s = stream.Score(id='mainScore') >>> p0 = stream.Part(id='part0') >>> p1 = stream.Part(id='part1') >>> m01 = stream.Measure(number=1) >>> m01.append(note.Note('C', type='whole')) >>> m02 = stream.Measure(number=2) >>> m02.append(note.Note('D', type='whole')) >>> m11 = stream.Measure(number=1) >>> m11.append(note.Note('E', type='whole')) >>> m12 = stream.Measure(number=2) >>> m12.append(note.Note('F', type='whole')) >>> p0.append([m01, m02]) >>> p1.append([m11, m12]) >>> s.insert(0, p0) >>> s.insert(0, p1) >>> s.show('text') {0.0} {0.0} {0.0} {4.0} {0.0} {0.0} {0.0} {0.0} {4.0} {0.0} Now we could assign the `.recurse()` method to something, but that won't have much effect: >>> sRecurse = s.recurse() >>> sRecurse So, that's not how we use `.recurse()`. Instead, use it in a `for` loop: >>> for el in s.recurse(): ... tup = (el, el.offset, el.activeSite) ... print(tup) (, 0.0, ) (, 0.0, ) (, 0.0, ) (, 4.0, ) (, 0.0, ) (, 0.0, ) (, 0.0, ) (, 0.0, ) (, 4.0, ) (, 0.0, ) If we specify `includeSelf=True` then the original stream is also iterated: >>> for el in s.recurse(includeSelf=True): ... tup = (el, el.offset, el.activeSite) ... print(tup) (, 0.0, None) (, 0.0, ) (, 0.0, ) (, 0.0, ) ... Notice that like calling `.show('text')`, the offsets are relative to their containers. Compare the difference between putting `.recurse().notes` and `.flatten().notes`: >>> for el in s.recurse().notes: ... tup = (el, el.offset, el.activeSite) ... print(tup) (, 0.0, ) (, 0.0, ) (, 0.0, ) (, 0.0, ) >>> for el in s.flatten().notes: ... tup = (el, el.offset, el.activeSite) ... print(tup) (, 0.0, ) (, 0.0, ) (, 4.0, ) (, 4.0, ) If you don't need correct offsets or activeSites, set `restoreActiveSites` to `False`. Then the last offset/activeSite will be used. It's a bit of a speedup, but leads to some bad code, so use it only in highly optimized situations. We'll also test using multiple classes here. The Stream given is the same as the s.flatten().notes stream. >>> for el in s.recurse(classFilter=('Note', 'Rest'), restoreActiveSites=False): ... tup = (el, el.offset, el.activeSite) ... print(tup) (, 0.0, ) (, 4.0, ) (, 0.0, ) (, 4.0, ) So, this is pretty unreliable so don't use it unless the tiny speedup is worth it. The other two attributes are pretty self-explanatory: `streamsOnly` will put only Streams in, while `includeSelf` will add the initial stream from recursion. If the inclusion or exclusion of `self` is important to you, put it in explicitly. >>> for el in s.recurse(includeSelf=False, streamsOnly=True): ... tup = (el, el.offset, el.activeSite) ... print(tup) (, 0.0, ) (, 0.0, ) (, 4.0, ) (, 0.0, ) (, 0.0, ) (, 4.0, ) .. warning:: Remember that like all iterators, it is dangerous to alter the components of the Stream being iterated over during iteration. if you need to edit while recursing, list(s.recurse()) is safer. * Changed in v5.5: All attributes are keyword only. * Changed in v8: removed parameter `skipSelf`. Use `includeSelf` instead. )rvr>r)r/rrrrrrQ)rrvr>rrrs rJrYrs``6>5O5O #1# 6  &&{3B ??{66(44V>> s1 = stream.Score(id='s1') >>> p1 = stream.Part() >>> m1 = stream.Measure(id='m1') >>> n = note.Note('D') >>> m1.append(n) >>> p1.append(m1) >>> s1.insert(0, p1) >>> s2 = stream.Stream(id='s2') >>> s2.append(n) >>> n.activeSite.id 's2' >>> s1.containerInHierarchy(n).id 'm1' >>> n.activeSite.id 'm1' >>> n.activeSite = s2 >>> s1.containerInHierarchy(n, setActiveSite=False).id 'm1' >>> n.activeSite.id 's2' If the element cannot be found in the hierarchy then None is returned. >>> s3 = stream.Stream() >>> s3.containerInHierarchy(n) is None True TFr=N)r)rYr)rrrelSitesrs rJr Stream.containerInHierarchy/ sIX(($DUZ[A| ((, \ rIcURSLaUR5 URSSS9H-nUR(dMUR5 SUlM/ SUlg)z Clean this Stream: for self and all elements, purge all dead locations and remove all non-contained sites. Further, restore all active sites. FTrN)rrrYrt)rros rJ makeImmutableStream.makeImmutablec sU == % IIK$EBA zzz" C rIcSUlU(a%URSS9HnURSS9 M UR5 g)NTruFr$)rrY makeMutabler)rrYros rJrStream.makeMutablet s= \\d\3 e ,4   "rIcSUR;aURSbOUR(dSURS'OURSLa.URSnURU5URS'O]SnURH nURU5nUbXB:dMUnM" Ub[ U5URS'OSURS'URS$)al Get start time of element with the highest offset in the Stream. Note the difference between this property and highestTime which gets the end time of the highestOffset >>> stream1 = stream.Stream() >>> for offset in [0, 4, 8]: ... n = note.Note('G#', type='whole') ... stream1.insert(offset, n) >>> stream1.highestOffset 8.0 >>> stream1.highestTime 12.0 HighestOffsetNrlTr)rrrarr)reLasthighestOffsetSoFarrocandidateOffsets rJ highestOffsetStream.highestOffset s" dkk )dkk/.J.V +.DKK ( ]]d "NN2&E+/+=+=e+DDKK (!% ^^"&"4"4Q"7%-1U)8&$ "-/45G/H O,/3 O,{{?++rIc XRS'g)z For internal use only. HighestTimeN)rr@s rJrStream._setHighestTime s&+ M"rIcdSUR;aURSbOUR(dSURS'gSnURH6nURU5URR-n[ X5nM8 [ U5URS'URS$)a Returns the maximum of all Element offsets plus their Duration in quarter lengths. This value usually represents the last "release" in the Stream. Stream.duration is normally equal to the highestTime expressed as a Duration object, but it can be set separately for advanced operations. Example: Insert a dotted half note at position 0 and see where it cuts off: >>> p1 = stream.Stream() >>> p1.highestTime 0.0 >>> n = note.Note('A-') >>> n.quarterLength = 3 >>> p1.insert(0, n) >>> p1.highestTime 3.0 Now insert in the same stream, the dotted half note at positions 1, 2, 3, 4 and see when the final note cuts off: >>> p1.repeatInsert(n, [1, 2, 3, 4]) >>> p1.highestTime 7.0 Another example. >>> n = note.Note('C#') >>> n.quarterLength = 3 >>> q = stream.Stream() >>> for i in [20, 0, 10, 30, 40]: ... p = stream.Stream() ... p.repeatInsert(n, [0, 1, 2, 3, 4]) ... q.insert(i, p) # insert out of order >>> len(q.flatten()) 25 >>> q.highestTime # this works b/c the component Stream has a duration 47.0 >>> r = q.flatten() * Changed in v6.5: highestTime can return a Fraction. OMIT_FROM_DOCS Make sure that the cache really is empty >>> 'HighestTime' in r._cache False >>> r.highestTime # 44 + 3 47.0 Can highestTime be a fraction? >>> n = note.Note('D') >>> n.duration.quarterLength = 1/3 >>> n.duration.quarterLength Fraction(1, 3) >>> s = stream.Stream() >>> s.append(note.Note('C')) >>> s.append(n) >>> s.highestTime Fraction(4, 3) rrl)rrrrrrr)rhighestTimeSoFarrors rJrStream.highestTime sT DKK 'DKK ,F,R ),DKK &" ^^#'#5#5a#8%&ZZ%=%=$>#&'7#I $*00@)ADKK &{{=))rIcSUR;aURSbOUR(dSURS'O}URSLa.URSnURU5URS'O@SnURH nURU5nUbXB:dMUnM" X RS'URS$)a Get the start time of the Element with the lowest offset in the Stream. >>> stream1 = stream.Stream() >>> for x in range(3, 5): ... n = note.Note('G#') ... stream1.insert(x, n) ... >>> stream1.lowestOffset 3.0 If the Stream is empty, then the lowest offset is 0.0: >>> stream2 = stream.Stream() >>> stream2.lowestOffset 0.0 >>> p = stream.Stream() >>> p.repeatInsert(note.Note('D5'), [0, 1, 2, 3, 4]) >>> q = stream.Stream() >>> q.repeatInsert(p, list(range(0, 50, 10))) >>> len(q.flatten()) 25 >>> q.lowestOffset 0.0 >>> r = stream.Stream() >>> r.repeatInsert(q, list(range(97, 500, 100))) >>> len(r.flatten()) 125 >>> r.lowestOffset 97.0 lowestOffset LowestOffsetNrlTr)rrrar)reFirstminOffsetSoFarrors rJrStream.lowestOffset !sL T[[ (T[[-H-T *-DKK ' ]]d "^^A&F*.*<***rIcURb UR$SUR;aURSbURS$[R"URS9URS'URS$)zb Gets the duration of the whole stream (generally the highestTime, but can be set independently). Durationr )r}rrrrrs rJ _getDurationStream._getDurationD!su  ! ! -)) ) 4;; &4;;z+B+N;;z* *'/&7&7dFVFV&WDKK #;;z* *rIc[U[R5(aXlgUcSUlg[ SU35e)a Set the total duration of the Stream independently of the highestTime of the stream. Useful to define the scope of the stream as independent of its constituted elements. If set to None, then the default behavior of computing automatically from highestTime is reestablished. Nz$this must be a Duration object, not )rrrr}ro)r durationObjs rJ _setDurationStream._setDurationS!s> k8#4#4 5 5%0 "  %)D "!$H "VW WrIc"UR5$)a= Returns the total duration of the Stream, from the beginning of the stream until the end of the final element. May be set independently by supplying a Duration object. >>> a = stream.Stream() >>> q = note.Note(type='quarter') >>> a.repeatInsert(q, [0, 1, 2, 3]) >>> a.highestOffset 3.0 >>> a.highestTime 4.0 >>> a.duration >>> a.duration.quarterLength 4.0 Advanced usage: override the duration from what is set: >>> newDuration = duration.Duration('half') >>> newDuration.quarterLength 2.0 >>> a.duration = newDuration >>> a.duration.quarterLength 2.0 Restore normal behavior by setting duration to None: >>> a.duration = None >>> a.duration Note that the highestTime for the stream is the same whether duration is overridden or not: >>> a.highestTime 4.0 )rrs rJrStream.durationc!sR  ""rIc&URU5 grs)rr@s rJrr!s % rIcgrsrCr@s rJ _setSecondsStream._setSeconds!s rIcSnUR[R5n/nU(dSnO ''(9:Bz##s* <',,.B),b {5M'M $#$<=JAw+,1++D,<,<==  G3/0144%=!e%D"l'' ,,T]; ;C> rIag Get or set the duration of this Stream in seconds, assuming that this object contains a :class:`~music21.tempo.MetronomeMark` or :class:`~music21.tempo.MetricModulation`. >>> s = corpus.parse('bwv66.6') # piece without a tempo >>> sFlat = s.flatten() >>> t = tempo.MetronomeMark('adagio') >>> sFlat.insert(0, t) >>> sFlat.seconds 38.57142857... >>> tFast = tempo.MetronomeMark('allegro') >>> sFlat.replace(t, tFast) >>> sFlat.seconds 16.363... Setting seconds on streams is not supported. Ideally it would instead scale all elements to fit, but this is a long way off. If a stream does not have a tempo-indication in it then the property returns 0.0 if an empty Stream (or self.highestTime is 0.0) or 'nan' if there are non-zero duration objects in the stream: >>> s = stream.Stream() >>> s.seconds 0.0 >>> s.insert(0, clef.TrebleClef()) >>> s.seconds 0.0 >>> s.append(note.Note(type='half')) >>> s.seconds nan >>> import math >>> math.isnan(s.seconds) True * Changed in v6.3: return nan rather than raising an exception. Do not attempt to change seconds on a stream, as it did not do what you would expect. cUcUnUR5nUR[R5n/nURnUR nU(d)[R "SS9nURXeU45 U$[U5S:Xa~USRU5nUSR5n X:a<[R "SS9nURXhU45 URXU 45 U$URXeU 45 U$/n UH4n U RU5nU RXR5/5 M6 U SSU:aT[R "SS9nURXjSSU45 URU SSU SSU SS45 O&URU SSU SSU SS45 [U 5Hhun upU S:XaMU [U 5S- :Xa URXSUXS45 MBURXSXS-SXS45 Mj U$)a Return a list of offset start, offset end, MetronomeMark triples for all TempoIndication objects found in this Stream or a Stream provided by srcObj. If no MetronomeMarks are found, or an initial region does not have a MetronomeMark, a mark of quarter equal to 120 is provided as default. Note that if other TempoIndication objects are defined, they will be converted to MetronomeMarks and returned here >>> s = stream.Stream() >>> s.repeatAppend(note.Note(), 8) >>> s.insert([6, tempo.MetronomeMark(number=240)]) >>> s.metronomeMarkBoundaries() [(0.0, 6.0, ), (6.0, 8.0, )] xrrmr) rQrr+rrr MetronomeMarkrUrrrr) rrrsr mmBoundariesrr mmDefaultrr offsetPairsrrs rJmetronomeMarkBoundariesStream.metronomeMarkBoundaries!s( >F.."--e.C.CD )) ++ ++37I   I F GVS]a  ++G4A!557B!//s; ##\i$@A##QR$89DA##\$CD@;K&&w/""A'B'B'D#EF 1~a </!//s; ##\q>!3D%.%01##[^A%6 Aq8I%0^A%6%89##[^A%6 Aq8I%0^A%6%89( 4 7A6#k*Q.. ''):K)4):)<=!''):KAF3363B **      F!&--0 qyy{A./1tn%F"( Ea--jj..q007; ! /5/I/I 08 O,171K1K &,28 -.1<_1M3>?P3Q2R ,-)*I&,6L)!!+.%"((rIab Returns a list where each element is a dictionary consisting of the 'offsetSeconds' in seconds of each element in a Stream, the 'duration' in seconds, the 'endTimeSeconds' in seconds (that is, the offset plus the duration), and the 'element' itself. Also contains a 'voiceIndex' entry which contains the voice number of the element, or None if there are no voices. >>> mm1 = tempo.MetronomeMark(number=120) >>> n1 = note.Note(type='quarter') >>> c1 = clef.AltoClef() >>> n2 = note.Note(type='half') >>> s1 = stream.Stream() >>> s1.append([mm1, n1, c1, n2]) >>> om = s1.secondsMap >>> om[3]['offsetSeconds'] 0.5 >>> om[3]['endTimeSeconds'] 1.5 >>> om[3]['element'] is n2 True >>> om[3]['voiceIndex'] cUR[R5nURS5nUR 5$)> >>> a = stream.Stream() >>> a.metadata = metadata.Metadata() r)rr#Metadatar r)rmdLists rJ _getMetadataStream._getMetadata"s6 (():):;++A.||~rIcUR5nUb URURU55nUb3[U[R 5(aUR SU5 ggg)rNr)rr$r%rr#rrV)r metadataObj oldMetadatar(s rJ _setMetadataStream._setMetadata"s^ '')  "88DJJ{34D  "z+x?P?P'Q'Q KK; '(R "rIa` Get or set the :class:`~music21.metadata.Metadata` object found at the beginning (offset 0) of this Stream. >>> s = stream.Stream() >>> s.metadata = metadata.Metadata() >>> s.metadata.composer = 'frank' >>> s.metadata.composer 'frank' May also return None if nothing is there. c8URUR5$rs)rr rs rJ_getMeasureOffsetStream._getMeasureOffset"s##DOO44rIcg)z! beat returns None for a Stream. NrCrs rJbeat Stream.beat"r?rIcg)zh unlike other Music21Objects, streams always have beatStr (beat string) of None May change to '' soon. NrCrs rJbeatStrStream.beatStr"r?rIcg)zG unlike other Music21Objects, streams always have beatDuration of None NrCrs rJ beatDurationStream.beatDuration" rIcg)zG unlike other Music21Objects, streams always have beatStrength of None NrCrs rJ beatStrengthStream.beatStrength"r rIcUnUR5(dUR5(aLSnUH1nUR(dMUR5(dM-SnUn O U(d [S5eO UR5(d [S5eUR US/S9nUc [S5eUR nUcUR [R5nUc [S 5eURXR- 5nURn URn U S :XaSn U c U(aU S :XaURURS/S9n U (aU R [R5n U (d [S 5eU RU RR :Xa U R"n OU RU R5S- n X-U 4$URURR UR$R - 5S- n X-U4$X4$! [S 5e=f)a Returns a two-element tuple of the beat and the Measure object (or the first one if there are several at the same offset; unlikely but possible) for a given offset from the start of this Stream (that contains measures). Recursively searches for measures. Note that this method assumes that all parts have measures of consistent length. If that's not the case, this method can be called on the relevant part. This algorithm should work even for weird time signatures such as 2+3+2/8. >>> bach = corpus.parse('bach/bwv1.6') >>> bach.parts[0].measure(2).getContextByClass(meter.TimeSignature) >>> returnTuples = [] >>> for offset in [0.0, 1.0, 2.0, 5.0, 5.5]: ... returnTuples.append(bach.beatAndMeasureFromOffset(offset)) >>> returnTuples [(4.0, ), (1.0, ), (2.0, ), (1.0, ), (1.5, )] To get just the measureNumber and beat, use a transformation like this: >>> [(beat, measureObj.number) for beat, measureObj in returnTuples] [(4.0, 0), (1.0, 1), (2.0, 1), (1.0, 2), (1.5, 2)] Adapted from contributed code by Dmitri Tymoczko. With thanks to DT. FTz3beatAndMeasureFromOffset: could not find any parts!z6beatAndMeasureFromOffset: could not find any measures!rwrNz4beatAndMeasureFromOffset: no measure at that offset.zIbeatAndMeasureFromOffset: could not find a time signature for that place.z?beatAndMeasureFromOffset: offset is beyond the end of the piecerrznbeatAndMeasureFromOffset: partial measure found, but could not find a time signature for the preceding measurerm)r,r*rtrorr,rNr$r*getBeatProportionrMrrrrr.r beatCountr)r searchOffsetfixZerosmyStream foundPart subStreammyMeasts1myBeatfoundMeasureNumber numSuffixprevMeasts2padBeatss rJbeatAndMeasureFromOffsetStream.beatAndMeasureFromOffset"sO@##%%**,,! !)I$--  ,,..$( #, "*!)*_``! ++--)*bcc..| {.S >!"XY Y"" ;**5+>+>?C ;![] ] S**<--+GHF$]]'' ?I  X2D2I66v}}QZP[6\H001D1DE)Z[[''3??+H+HH"}}H"44X5I5IJQNH)84400OO11FOO4Q4QQSUVW)622# #S S!QS Ss 5H22 H?)rFrYrhc`U(dURS5nOUn[U[[45(a[R "U5nO[U[R 5(a[R "US9nO|[U[R5(a[R "US9nOH[R(a1[U[R[R 45(deUnUSLaUR5nOUR5nU(a%UR[R"U55nUHnUR (aM[#US5(dM)[U[R5(ax[U[$R&5(dW[#US5(aDUR)[$R&5n UR*Hn UR-XSS9 M MMMUR/USS9 M U(dU$g)aI Transpose all specified classes in the Stream 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. returns a new Stream by default, but if the optional "inPlace" key is set to True then it modifies pitches in place. TODO: for generic interval set accidental by key signature. >>> aInterval = interval.Interval('d5') >>> aStream = corpus.parse('bach/bwv324.xml') >>> part = aStream.parts[0] >>> [str(p) for p in aStream.parts[0].pitches[:10]] ['B4', 'D5', 'B4', 'B4', 'B4', 'B4', 'C5', 'B4', 'A4', 'A4'] >>> bStream = aStream.parts[0].flatten().transpose('d5') >>> [str(p) for p in bStream.pitches[:10]] ['F5', 'A-5', 'F5', 'F5', 'F5', 'F5', 'G-5', 'F5', 'E-5', 'E-5'] Test that aStream hasn't been changed: >>> [str(p) for p in aStream.parts[0].pitches[:10]] ['B4', 'D5', 'B4', 'B4', 'B4', 'B4', 'C5', 'B4', 'A4', 'A4'] >>> cStream = bStream.flatten().transpose('a4') >>> [str(p) for p in cStream.pitches[:10]] ['B5', 'D6', 'B5', 'B5', 'B5', 'B5', 'C6', 'B5', 'A5', 'A5'] >>> cStream.flatten().transpose(aInterval, inPlace=True) >>> [str(p) for p in cStream.pitches[:10]] ['F6', 'A-6', 'F6', 'F6', 'F6', 'F6', 'G-6', 'F6', 'E-6', 'E-6'] * Changed in v8: first value is position only, all other values are keyword only r]) chromatic)diatonicTr\rLN)rLrrrrIntervalChromaticIntervalDiatonicIntervalrrGenericIntervalrYrrr0rrtrTr"r4rNr\transposePitchKeyAwarer]) rrrFrYrhrintvrrorr-s rJr]Stream.transposed#sf,,[9DD ec3Z ( ($$U+D x99 : :$$u5D x88 9 9$$e4D!%(*B*BHDUDU)VWWWWD d? I I !++G,?,?,PQIAzzq+&&dH$<$<==%a)9)9::wq)?T?T//0@0@A!"A 77d7K"+@U: KKdK3KrIlowest anchorZeroanchorZeroRecurserFc US:d [S5eU(dURS5nOUnUS;a[UR5nO>US;a[UR5nO"US;a [SS5nO[SUS 35eUR HTnUR U5U- U-nX- nURXx5 UR(dMBURUUUS S 9 MV UR5 U(dU$g ) a Scale all offsets by a multiplication factor given in `amountToScale`. Durations are not altered. To augment or diminish a Stream, see the :meth:`~music21.stream.Stream.augmentOrDiminish` method. The `anchorZero` parameter determines if and/or where the zero offset is established for the set of offsets in this Stream before processing. Offsets are shifted to make either the lower or upper values the new zero; then offsets are scaled; then the shifts are removed. Accepted values are None (no offset shifting), "lowest", or "highest". The `anchorZeroRecurse` parameter determines the anchorZero for all embedded Streams, and Streams embedded within those Streams. If the lowest offset in an embedded Stream is non-zero, setting this value to None will allow the space between the start of that Stream and the first element to be scaled. If the lowest offset in an embedded Stream is non-zero, setting this value to 'lowest' will not alter the space between the start of that Stream and the first element to be scaled. To shift all the elements in a Stream, see the :meth:`~music21.stream.Stream.shiftElements` method. * Changed in v5: inPlace is default False, and anchorZero, anchorZeroRecurse and inPlace are keyword only arguments. r'amountToScale must be greater than zeror_)r))highestrsrmzan anchorZero value of z is not acceptedTr*N) rorLr rrrrrrtr_r) r amountToScaler+r,rFrQ offsetShiftrors rJr_Stream.scaleOffsets#sRq !"KL L11.AII  #"9#9#9:K ; &"9#:#:;K 6 !"1a.K!$;J>> s = stream.Stream() >>> n = note.Note() >>> s.repeatAppend(n, 10) >>> s.highestOffset, s.highestTime (9.0, 10.0) >>> s1 = s.augmentOrDiminish(2) >>> s1.highestOffset, s1.highestTime (18.0, 20.0) >>> s1 = s.augmentOrDiminish(0.5) >>> s1.highestOffset, s1.highestTime (4.5, 5.0) rr.r^r)NT)r0r+r,rF)r0rF)rorLr_r`)rr0rFrQs rJr^Stream.augmentOrDiminish8$slHq !"KL L112EFII ]x15t  E  }d KrIc^^T(d[RmSSSjjmSUU4SjjnUSLaURS5nOUnU/nUSLa[UR SSS95nUGHpn U R n /n [ U R5GH$upU(aU RU 5nSnUS:aS nS U-nT"[U5T5nURU-nU RX5 [U S 5(a.URS:waURU-U RlU(dMU R R"n[%US5n['U [(R*5(+=(d U R R,nU(aeU (a^U"XS-WS 9unnUb:Ub7[/URU R0- 5nT"[U5TUU5nO'T"[U5TU5nOT"[U5TU5nURS:Xa3['U [(R25(aU R5U 5 GMURU R l[U S 5(dGMURS:wdGM URU RlGM' U R9SS 9 U R;U 5 GMs USLaU$g )a Quantize time values in this Stream by snapping offsets and/or durations to the nearest multiple of a quarter length value given as one or more divisors of 1 quarter length. The quantized value found closest to a divisor multiple will be used. The `quarterLengthDivisors` provides a flexible way to provide quantization settings. For example, (2,) will snap all events to eighth note grid. (4, 3) will snap events to sixteenth notes and eighth note triplets, whichever is closer. (4, 6) will snap events to sixteenth notes and sixteenth note triplets. If quarterLengthDivisors is not specified then defaults.quantizationQuarterLengthDivisors is used. The default is (4, 3). `processOffsets` determines whether the Offsets are quantized. `processDurations` determines whether the Durations are quantized. Both are set to True by default. Setting both to False does nothing to the Stream. if `inPlace` is True, then the quantization is done on the Stream itself. If False (default) then a new quantized Stream of the same class is returned. If `recurse` is True, then all substreams are also quantized. If False (default), then only the highest level of the Stream is quantized. * Changed in v7: - `recurse` defaults False - look-ahead approach to choosing divisors to avoid gaps when processing durations >>> n = note.Note() >>> n.quarterLength = 0.49 >>> s = stream.Stream() >>> s.repeatInsert(n, [0.1, 0.49, 0.9]) >>> nShort = note.Note() >>> nShort.quarterLength = 0.26 >>> s.repeatInsert(nShort, [1.49, 1.76]) >>> s.quantize((4,), processOffsets=True, processDurations=True, inPlace=True) >>> [e.offset for e in s] [0.0, 0.5, 1.0, 1.5, 1.75] >>> [e.duration.quarterLength for e in s] [0.5, 0.5, 0.5, 0.25, 0.25] The error in quantization is set in the editorial attribute for the note in two places `.offsetQuantizationError` and `.quarterLengthQuantizationError`: >>> [e.editorial.offsetQuantizationError for e in s.notes] [0.1, -0.01, -0.1, -0.01, 0.01] >>> [e.editorial.quarterLengthQuantizationError for e in s.notes] [-0.01, -0.01, -0.01, 0.01, 0.01] With default quarterLengthDivisors: >>> s = stream.Stream() >>> s.repeatInsert(n, [0.1, 0.49, 0.9]) >>> nShort = note.Note() >>> nShort.quarterLength = 0.26 >>> s.repeatInsert(nShort, [1.49, 1.76]) >>> quantized = s.quantize(processOffsets=True, processDurations=True, inPlace=False) >>> [e.offset for e in quantized] [0.0, 0.5, 1.0, 1.5, 1.75] >>> [e.duration.quarterLength for e in quantized] [0.5, 0.5, 0.5, 0.25, 0.25] Set `recurse=True` to quantize elements in substreams such as parts, measures, voices: >>> myPart = converter.parse('tinynotation: c32 d32 e32 f32') >>> myPart.quantize(inPlace=True) >>> [e.offset for e in myPart.measure(1).notes] # no change! [0.0, 0.125, 0.25, 0.375] >>> myPart.quantize(inPlace=True, recurse=True) >>> [e.offset for e in myPart.measure(1).notes] [0.0, 0.0, 0.25, Fraction(1, 3)] * New in v7: if both `processDurations` and `processOffsets` are True, then the next note's quantized offset is taken into account when quantizing the duration of the current note. This is to prevent unnecessary gaps from applying different quantization units to adjacent notes: >>> s2 = stream.Stream() >>> nOddLength = note.Note(quarterLength=0.385) >>> s2.repeatInsert(nOddLength, [0, 0.5, 1, 1.5]) >>> s2.show('t', addEndTimes=True) {0.0 - 0.385} {0.5 - 0.885} {1.0 - 1.385} {1.5 - 1.885} Before v.7, this would have yielded four triplet-eighths (separated by 1/6 QL rests): >>> s2.quantize(processOffsets=True, processDurations=True, inPlace=True) >>> s2.show('text', addEndTimes=True) {0.0 - 0.5} {0.5 - 1.0} {1.0 - 1.5} {1.5 - 1.8333} OMIT_FROM_DOCS Test changing defaults, running, and changing back: >>> dd = defaults.quantizationQuarterLengthDivisors >>> defaults.quantizationQuarterLengthDivisors = (3,) >>> u = s.quantize(processOffsets=True, processDurations=True, inPlace=False) >>> [e.offset for e in u] [0.0, Fraction(1, 3), 1.0, Fraction(4, 3), Fraction(5, 3)] >>> [e.duration.quarterLength for e in u] [Fraction(1, 3), Fraction(1, 3), Fraction(1, 3), Fraction(1, 3), Fraction(1, 3)] Original unchanged because inPlace=False: >>> [e.offset for e in s] [Fraction(1, 10), Fraction(49, 100), Fraction(9, 10), Fraction(149, 100), Fraction(44, 25)] >>> defaults.quantizationQuarterLengthDivisors = dd >>> v = s.quantize(processOffsets=True, processDurations=True, inPlace=False) >>> [e.offset for e in v] [0.0, 0.5, 1.0, 1.5, 1.75] >>> [e.duration.quarterLength for e in v] [0.5, 0.5, 0.5, 0.25, 0.25] Tc (/nUH~nSU- n[R"X5upxn U(d!US:XaUn[X- S5n [U 5nX6-S:XaSn O[ X7- S5n UR [ XXgX55 M [U5n U $)Nrmrlr)rnearestMultiplerabsrrUr9min) rdivisors zeroAllowed gapToFillrdivr<r=r;signedErrorInnerr:bestMatchTuples rJ bestMatch"Stream.quantize..bestMatch$s 24E3w171G1G1U.."u| E',V^Q'?$ 01E#q(#&L#&y'8##>L )$T:JQR !ZN! !rIc>URUSH;nURU5nT"[U5T5nURU:dM8X54s $ g)NNN)rrrr=) useStream startIndexrnext_el next_offsetlook_ahead_resultrCquarterLengthDivisorss rJfindNextElementNotCoincident5Stream.quantize..findNextElementNotCoincident%s[ %..z{;'55g> $-eK.@BW$X!$**[8"55 < rIFquantizerrmrr editorial)rGrHrNr )Trl)rqr9)rGrQrHrrrrqz>tuple[base.Music21Object | None, BestQuantizationMatch | None])r!quantizationQuarterLengthDivisorsrLrrYrarrrrr=rrTr>rPoffsetQuantizationErrorrrrrr%risGracerrMrrUquarterLengthQuantizationErrorrr )rrLprocessOffsetsprocessDurationsrFrYrMr useStreamsrGoriginallySortedrests_lacking_durationsrrorsign o_matchTuplerkr> next_elementrKr? d_matchTuplerCs ` @rJrOStream.quantizek$sH%$,$N$N !  " #  "4   " H   e 44Z@LL"^ d?l22tQU2VWJ#I )11 79 #!)"5"56!!//2AD1u!F#,U1X7L#ML$**T1A2218q+..<3K3Kq3P>J>V>VY]>] ;##11BRB&0DLL&A"A"WQZZEWEWK%*:8*3ASTV8 &7(38I8U(./@/F/F/Q(RI+4 %b +@+y,ZL,5U2Y@UWb+cL'0r2E/ . #i.)Q__<%I9::**9*FD'' 2G   Q $$W3 +=+=!=>=D %%' rIrCrFcU(dURS5nOUnUR5(a.UR[5HnUR USS9 M U$[ 5nUR H0nURU;dMURUR5 M2 [R"U5nURU/SUSS9 U(dU$g)z Slice all :class:`~music21.duration.Duration` objects on all Notes and Rests of this Stream. Duration are sliced according to the approximate GCD found in all durations. sliceByGreatestDivisorTrtNrnrrCrF) rLr,rrwrvrerrrrapproximateGCDrj)rrCrFrQruniqueQuarterLengthsror?s rJrvStream.sliceByGreatestDivisor%s112JKII  " "11':(($(G; "u((A&::$((9)''(<= ''7)/3Wd ( T rIc U(dURS5nOUnUR5(aSUR[5H8nUVs/sHoUR U5- PM n nUR U USUS9 M: U$UR 5(aSUR[5H8n UVs/sHoU R U5- PM n nU R U USUS9 M: U$UR5n UVs/sHn[U5PM nnU Hn U upnnUb[U 5[U5:waM&/n[U5n[U5nUH&nXs=:aU:dMO MURU5 M( U(dMsU nUnUH1nUU- nURUSUUS9unnURUU5 UnM3 M UR5 USLaU$gs snfs snfs snf)aS Given a list of quarter lengths, slice and optionally tie all Music21Objects crossing these points. >>> s = stream.Stream() >>> n = note.Note() >>> n.duration.type = 'whole' >>> s.append(n) >>> post = s.sliceAtOffsets([1, 2, 3], inPlace=True) >>> [(e.offset, e.quarterLength) for e in s] [(0.0, 1.0), (1.0, 1.0), (2.0, 1.0), (3.0, 1.0)] sliceAtOffsetsT) offsetListrCrFrDNrKF)rLr,rrwrr|r*rQr"rrrUrGrr)rr}rrCrFrDrQrroffsetListLocalr-r"obrorrunused_voiceCount cutPointseNext oStartNextoCutunused_eCompletes rJr|Stream.sliceAtOffsets%s(*112BCII  " "11':NX"XZq'8'8'C#CZ"X  O)0)-8N!P ;   ' ' ) )11&9MW"XZq'8'8'C#CZ"X  O)0)-8N!P:  '') )34AfQi 4B13 .At.!ber&z&9IF^F$D.3.H.H%) '/E /I/+$e((E2!"J#'@ %%' e   o#Y#Y5s G#5G(G-c"U(dURS5nOUnUR5(a0UR[5HnUR UUSUS9 M U$UR 5(a0UR[ 5HnUR UUSUS9 M U$URSS9nU(d [S5e[U5S:a [S5eUSR5n URU UUSUS9 U(dU$g ) z Slice all elements in the Stream that have a Duration at the offsets determined to be the beat from the local TimeSignature. * Changed in v7: return None if inPlace is True sliceByBeatT)rrCrFrD)rIzno time signature was foundrmz6not yet implemented: slice by changing time signaturesrN) rLr,rrwrr*rlrMrorgetBeatOffsetsr|) rrrCrFrDrQrr-tsStreamr}s rJrStream.sliceByBeatX&s.11-@II  " "11': V&-&*5KM;    ' ' ) )11$7 V&-&*5KM8  ..T.B!"?@ @ x=1 !"Z[ [a[//1   (.)0)-8N ! P  rIcSUR;dURSc<SnURHn[U[5(dMSn O XRS'URS$)a Return a boolean value showing if this Stream contains Measures. >>> p = stream.Part() >>> p.repeatAppend(note.Note(), 8) >>> p.hasMeasures() False >>> p.makeMeasures(inPlace=True) >>> len(p.getElementsByClass(stream.Measure)) 2 >>> p.hasMeasures() True Only returns True if the immediate Stream has measures, not if there are nested measures: >>> sc = stream.Score() >>> sc.append(p) >>> sc.hasMeasures() False r,FT)rrrrwrrr\s rJr,Stream.hasMeasures&sc*  +t{{=/I/QD~~c7++D & *.KK &{{=))rIcSUR;dURSc7SnURHnSUR;dMSn O XRS'URS$)z? Return a boolean value showing if this Stream contains Voices rFr,T)rrr/rs rJrStream.hasVoices&sb dkk )T[[-E-MD~~ckk)D & (,KK ${{;''rIcSUR;dURScSnUR(dUR[5H~n[ U[ 5(aSn Of[ U[ [45(aSn OGURS:waSn O3UR[ 5(dUR(dM|SnM XRS'URS$)a- Return a boolean value showing if this Stream contains any Parts, or Part-like sub-Streams. Part-like sub-streams are Streams that contain Measures or Notes. And where no sub-stream begins at an offset besides zero. >>> s = stream.Score() >>> s.hasPartLikeStreams() False >>> p1 = stream.Part() >>> p1.repeatAppend(note.Note(), 8) >>> s.insert(0, p1) >>> s.hasPartLikeStreams() True A stream that has a measure in it is not a part-like stream. >>> s = stream.Score() >>> m1 = stream.Measure() >>> m1.repeatAppend(note.Note(), 4) >>> s.append(m1) >>> s.hasPartLikeStreams() False A stream with a single generic Stream substream at the beginning has part-like Streams: >>> s = stream.Score() >>> m1 = stream.Stream() >>> m1.repeatAppend(note.Note(), 4) >>> s.append(m1) >>> s.hasPartLikeStreams() True Adding another though makes it not part-like. >>> m2 = stream.Stream() >>> m2.repeatAppend(note.Note(), 4) >>> s.append(m2) >>> s.hasPartLikeStreams() False Flat objects do not have part-like Streams: >>> sf = s.flatten() >>> sf.hasPartLikeStreams() False r*FTrl) rrcrrQrrlrwr,rMr)r multiPartr\s rJr*Stream.hasPartLikeStreams&sf t{{ 2dkkBV6W6_I;;226:C!#t,,$( #C'5)9::$) s*$) 0099 ...$( %;&1:KK, -{{/00rIcXURHnUR5(aM g g)z Return true if this Stream only employs twelve-tone equal-tempered pitch values. >>> s = stream.Stream() >>> s.append(note.Note('G#4')) >>> s.isTwelveTone() True >>> s.append(note.Note('G~4')) >>> s.isTwelveTone() False FT)r\ isTwelveTone)rr-s rJrStream.isTwelveTone 's'A>>##rIcd^Sm[U[[45(agUR(ag[U[5(aUR 5(agg[U[ 5(a[U4SjUR55$UR5(aT"U5$g)a% Return True if, given the context of this Stream or Stream subclass, contains what appears to be well-formed notation. This often means the formation of Measures, or a Score that contains Part with Measures. >>> s = corpus.parse('bwv66.6') >>> s.isWellFormedNotation() True >>> s.parts[0].isWellFormedNotation() True >>> s.parts[0].getElementsByClass(stream.Measure).first().isWellFormedNotation() True >>> s2 = stream.Score() >>> m = stream.Measure() >>> s2.append(m) >>> s2.isWellFormedNotation() False >>> o = stream.Opus([s]) >>> o.isWellFormedNotation() True >>> o2 = stream.Opus([s2]) >>> o2.isWellFormedNotation() False Only Measures and Voices are allowed to contain notes and rests directly: >>> m.isWellFormedNotation() True >>> s2.append(note.Rest()) >>> s2.isWellFormedNotation() False cL[SUR[555$)Nc3@# UHoR5v M g7frs)r,)rnrs rJrpQStream.isWellFormedNotation..allSubstreamsHaveMeasures..E'sV0U1}}0Us)rrrQ) testStreams rJallSubstreamsHaveMeasures>Stream.isWellFormedNotation..allSubstreamsHaveMeasuresD'sV 0M0Mf0UVV VrITFc34># UH nT"U5v M g7frsrC)rnrrs rJrp.Stream.isWellFormedNotation..Q'sI[033[s) rrwr,rrlr,rfrscoresr*)rrs @rJisWellFormedNotationStream.isWellFormedNotation'sJ W dWe, - -    d # #!!" d # #IT[[II I  $ $ & &,T2 2rIcRUR[R5nSUlU$)a( The notesAndRests property of a Stream returns a `StreamIterator` that consists only of the :class:`~music21.note.GeneralNote` objects found in the stream. The new Stream will contain mostly notes and rests (including :class:`~music21.note.Note`, :class:`~music21.chord.Chord`, :class:`~music21.note.Rest`) but also their subclasses, such as `Harmony` objects (`ChordSymbols`, `FiguredBass`), etc. >>> s1 = stream.Stream() >>> k1 = key.KeySignature(0) # key of C >>> n1 = note.Note('B') >>> r1 = note.Rest() >>> c1 = chord.Chord(['A', 'B-']) >>> s1.append([k1, n1, r1, c1]) >>> s1.show('text') {0.0} {0.0} {1.0} {2.0} `.notesAndRests` removes the `KeySignature` object but keeps the `Rest`. >>> notes1 = s1.notesAndRests.stream() >>> notes1.show('text') {0.0} {1.0} {2.0} The same caveats about `Stream` classes and `.flatten()` in `.notes` apply here. r)rr%r overrideDerivationrrs rJrStream.notesAndRestsX's.H  # #D$4$4 5 +: 'rIcRUR[R5nSUlU$)a The `.notes` property of a Stream returns an iterator that consists only of the notes (that is, :class:`~music21.note.Note`, :class:`~music21.chord.Chord`, etc.) found in the stream. This excludes :class:`~music21.note.Rest` objects. >>> p1 = stream.Part() >>> k1 = key.KeySignature(0) # key of C >>> n1 = note.Note('B') >>> r1 = note.Rest() >>> c1 = chord.Chord(['A', 'B-']) >>> p1.append([k1, n1, r1, c1]) >>> p1.show('text') {0.0} {0.0} {1.0} {2.0} >>> noteStream = p1.notes.stream() >>> noteStream.show('text') {0.0} {2.0} Notice that `.notes` returns a :class:`~music21.stream.iterator.StreamIterator` object >>> p1.notes Let's add a measure to `p1`: >>> m1 = stream.Measure() >>> n2 = note.Note('D') >>> m1.insert(0, n2) >>> p1.append(m1) Now note that `n2` is *not* found in `p1.notes` >>> p1.notes.stream().show('text') {0.0} {2.0} We need to call `p1.flatten().notes` to find it: >>> p1.flatten().notes.stream().show('text') {0.0} {2.0} {3.0} (Technical note: All elements of class NotRest are being found right now. This will eventually change to also filter out Unpitched objects, so that all elements returned by `.notes` have a `.pitches` attribute. r[)rr%rrrs rJr[ Stream.notes's+p?C>U>UVZVbVb>c *1 'rIc/nURHon[U[R5(aM$[U[R [ 45(dMKUR[UR55 Mq U$)aM Returns all :class:`~music21.pitch.Pitch` objects found in any element in the Stream as a Python List. Elements such as Streams, and Chords will have their Pitch objects accumulated as well. For that reason, a flat representation is not required. Note that this does not include any ornamental pitches implied by any ornaments on those Notes and Chords. To get those, use the makeNotation.ornamentalPitches(s) method. Pitch objects are returned in a List, not a Stream. This usage differs from the .notes property, but makes sense since Pitch objects usually have by default a Duration of zero. This is an important difference between them and :class:`music21.note.Note` objects. key.Key objects are subclasses of Scales, which DO have a .pitches list, but they are specifically exempt from looking for pitches, since that is unlikely what someone wants here. N.B., TODO: This may turn to an Iterator soon. >>> a = corpus.parse('bach/bwv324.xml') >>> partOnePitches = a.parts[0].pitches >>> len(partOnePitches) 25 >>> partOnePitches[0] >>> [str(p) for p in partOnePitches[0:10]] ['B4', 'D5', 'B4', 'B4', 'B4', 'B4', 'C5', 'B4', 'A4', 'A4'] Note that the pitches returned above are objects, not text: >>> partOnePitches[0].octave 4 Since all elements with a `.pitches` list are returned and streams themselves have `.pitches` properties (the docs you are reading now), pitches from embedded streams are also returned. Flattening a stream is not necessary. Whether this is a feature or a bug is in the eye of the beholder. >>> len(a.pitches) 104 Chords get their pitches found as well: >>> c = chord.Chord(['C4', 'E4', 'G4']) >>> n = note.Note('F#4') >>> m = stream.Measure() >>> m.append(n) >>> m.append(c) >>> m.pitches [, , , ] ) rrr"rr%r rQextendrr\)rrros rJr\Stream.pitches'satA!SWW%%A 0 0&9:: DO,  rI) skipRests skipChords skipUnisons skipOctavesskipGaps getOverlapsc /$rsrC rrrrrrrnoNoners rJfindConsecutiveNotesStream.findConsecutiveNotes(  rI)rrrrrc /$rsrCrs rJrr(rrI)rrrrrrrc /$rsrCrs rJrr!(rrIc :URSLa!UR(aUR5 /n Sn Sn Sn Sn SnUSLaSnURSSS9GHnURU :a>UR [ R5(aUSLaU RS5 Sn SnSn Sn UR [ R5(a URn UR [ R5GHnU SLa/USLa*URU :aU(dU RS5 Sn [U[ R5(aUSLdd[U5S:wdUURRUSR:wd.USLa'URRUSR:wdMUSLaURU :aMU RU5 URU :aMURn [!U UR"R$-5n Sn UR&nGM9[U[(R*5(Ga [UR&5S:aUSLa*U SLa"U(dU RS5 Sn SnGMGMGMUSLa@[U5[UR&5:XaS UR&5S U5:Xd{USLdURU :acU RU5 URU :aGMURn [!U UR"R$-5n UR&nSn GM^GMaGMdUSLaD[U[ R,5(a%U SLa USLaU RS5 Sn SnGMGMUSLdGM[U[ R,5(dGM[!URUR"R$-5n GM GM U SLaU R/5 U $) a Returns a list of consecutive *pitched* Notes in a Stream. A single "None" is placed in the list at any point there is a discontinuity (such as if there is a rest between two pitches), unless the `noNone` parameter is True. How to determine consecutive pitches is a little tricky and there are many options: * The `skipUnisons` parameter uses the midi-note value (.ps) to determine unisons, so enharmonic transitions (F# -> Gb) are also skipped if `skipUnisons` is true. We believe that this is the most common usage. * However, because of this, you cannot completely be sure that the x.findConsecutiveNotes() - x.findConsecutiveNotes(skipUnisons=True) will give you the number of P1s in the piece, because there could be d2's in there as well. See test.TestStream.testFindConsecutiveNotes() for usage details. This example is adapted from the tutorials/Examples page. >>> s = converter.parse("tinynotation: 4/4 f8 d'8~ d'8 d'8~ d'4 b'-8 a'-8 a-8") >>> m = s.measure(1) >>> m.findConsecutiveNotes(skipUnisons=True, skipOctaves=True, ... skipRests=True, noNone=True) [, , , ] >>> m.findConsecutiveNotes(skipUnisons=False, ... skipRests=True, noNone=True) [, , , , , , ] * Changed in v7: * now finds notes in Voices without requiring `getOverlaps=True` and iterates over Parts rather than flattening. * If `noNone=False`, inserts `None` when backing up to scan a subsequent voice or part. * Changed in v8: all parameters are keyword only. OMIT_FROM_DOCS N.B. for chords, currently, only the first pitch is tested for unison. this is a bug TODO: FIX (\*\*keywords is there so that other methods that pass along dicts to findConsecutiveNotes don't have to remove their own args; this method is used in melodicIntervals.) this is omitted -- add docs above. FrlrCTrNrmrc38# UHoRv M g7frspsrnr-s rJrp.Stream.findConsecutiveNotes..(s$=9aTT9c38# UHoRv M g7frsrrs rJrpr(sA\P[1$$P[r)rarbrrYrMrr%r rUrrrrr& pitchClassrrrrr\rrrr$)rrrrrrrrr returnList lastStartlastEndlastContainerEnd lastWasNone lastPitchesr"ros rJrr0(sR ==E !dmm IIK.0 ! %( /1 $ K$DII  #33!44T5E5EFF%!!$'"  IG ++D,<,<==#,#8#8 11$2B2BC5($-HHw.!"))$/&* a++'50!+.!3gg00KN4M4MM*e3$%GGJJ+a.2C2C$C "e+70B %%a(xx') !I$Y1I1I%IJG"'K"#))K 5;;//C NQ4F!T)&%/&--d3*.K*,K9?/ +d2$' $4AII$F$=199$=A\P[A\$\*d2ahh'6I"))!,88g-$$%HH "(QZZ5M5M)M"N&'ii &+ 7J%] 5($Q 22%."))$/&* &( '$&:a+C+C$QXX 0H0H%HIGqD%JX $  NN rIc UR"S0UD6n[U5S:aURSS9$URSS9n[X"SS5GHupEUbUcMUR(aUR(dM2[ R UR;aURSnOUn[ R UR;aURSnOUn[R"Xg5n[URUR-5Ul [R"[URUR- 55UlUR!U5 GM U$)aE Returns a Stream of :class:`~music21.interval.Interval` objects between Notes (and by default, Chords) that follow each other in a stream. the offset of the Interval is the offset of the beginning of the interval (if two notes are adjacent, then this offset is equal to the offset of the second note, but if skipRests is set to True or there is a gap in the Stream, then these two numbers will be different). See :meth:`~music21.stream.Stream.findConsecutiveNotes` in this class for a discussion of what is meant by default for "consecutive notes", and which keywords such as skipChords, skipRests, skipUnisons, etc. can be used to change that behavior. The interval between a Note and a Chord (or between two chords) is the interval to the first pitch of the Chord (pitches[0]) which is usually the lowest. For more complex interval calculations, run :meth:`~music21.stream.Stream.findConsecutiveNotes` and then calculate your own intervals directly. Returns an empty Stream if there are not at least two elements found by findConsecutiveNotes. >>> s1 = converter.parse("tinynotation: 3/4 c4 d' r b b'", makeNotation=False) >>> #_DOCS_SHOW s1.show() .. image:: images/streamMelodicIntervals1.* :width: 246 >>> intervalStream1 = s1.melodicIntervals() >>> intervalStream1.show('text') {1.0} {4.0} >>> M9 = intervalStream1[0] >>> M9.noteStart.nameWithOctave, M9.noteEnd.nameWithOctave ('C4', 'D5') Using the skip attributes from :meth:`~music21.stream.Stream.findConsecutiveNotes`, we can alter which intervals are reported: >>> intervalStream2 = s1.melodicIntervals(skipRests=True, skipOctaves=True) >>> intervalStream2.show('text') {1.0} {2.0} >>> m3 = intervalStream2[1] >>> m3.directedNiceName 'Descending Minor Third' rmelodicIntervalsrrmNrrC)rrrrr\rrrur[rr"rrMrrrrV) r skipKeywordsrrthisNotenextNote noteStartnoteEndreturnIntervals rJrStream.melodicIntervals(s:f..>> z?Q ??4F?G G8JK "%jQR."A H8#3$$)9)9{{h///$NN1- $ {{h///"..+"%..yBN$*8??X=S=S+S$TN !&.&7&7."7"7799':N #    /)#B,rIc/nUHNnURRnUR[URU-54nUR U5 MP U$)a! Given a flat stream, create a list of the start and end times (as a tuple pair) of all elements in the Stream. >>> a = stream.Stream() >>> a.repeatInsert(note.Note(type='half'), [0, 1, 2, 3, 4]) >>> a._getDurSpan(a.flatten()) [(0.0, 2.0), (1.0, 3.0), (2.0, 4.0), (3.0, 5.0), (4.0, 6.0)] )rrrMrrU)rrrrordurSpans rJ _getDurSpanStream._getDurSpan%)sPA****Cxx3!78G KK   rIcX/nUR5 SnU(aUSSUSS::aSnU$USSUSS:aSnU$)a Compare two durSpans and find overlaps; optionally, include coincident boundaries. a and b are sorted to permit any ordering. If an element ends at 3.0 and another starts at 3.0, this may or may not be considered an overlap. The includeCoincidentEnds parameter determines this behaviour, where ending and starting 3.0 being a type of overlap is set by the includeEndBoundary being True. >>> sc = stream.Stream() >>> sc._durSpanOverlap((0, 5), (4, 12), False) True >>> sc._durSpanOverlap((0, 10), (11, 12), False) False >>> sc._durSpanOverlap((11, 12), (0, 10), False) False >>> sc._durSpanOverlap((0, 3), (3, 6), False) False >>> sc._durSpanOverlap((0, 3), (3, 6), True) True FrmrT)r)rrrrzdurSpansrs rJ_durSpanOverlapStream._durSpanOverlap8)sd.6  {1~!Q/ {1~ A. rIcUR5nURSLaUR5nURU5n[R "[ [[[4[ [U555nUR5 [[U55Vs/sHn/PM nn[U5Hzupg[US-[U55HYnX8n URUSU S5(a4XWSRU S5 XYSRUS5 MX Mx M| UHn U R5 M U$s snf)a Find any elements in an elementsSorted list that have durations that cause overlaps. Returns a list of lists that has elements with overlaps, all index values that match are included in that list. See testOverlaps, in unit tests, for examples. Used in getOverlaps inside makeVoices. Frmr)rQrarrrrrrrrrrrrrrU) rr durSpanSorteddurSpanSortedIndexr overlapMaprsrcrjdstlss rJ _findLayeringStream._findLayering])s@\\^   % '#**,J((4 :; sH}% & =) *:  !49]9K3L&M3Lar3L &M 23FA1q5#&8"9:(+''AA771v&--c!f51v&--c!f5 ;4B GGI'Ns( Ecd^ ^ UR5nURSLaUR5n[U5[U5:wa [ S5e0n[ X5Hunm U(dMT R nSnUH^nX'm SnUH%n [U 4SjX955(dM!SnU n O UcUnU(dMBXc;a/X6'X6RT 5 M` UH"n [U 4SjX955(dM! M UcUnXc;a/X6'X6RT 5 M U$)z Given a stream of flat elements and a map of equal length with lists of index values that meet a given condition (overlap or simultaneities), organize into a dictionary by the relevant or first offset Fz1layeringMap must be the same length as flatStreamNTc34># UH oTLdM Sv M g7frrC)rnro elementObjs rJrp.Stream._consolidateLayering..)sDAO44rc34># UH oTLdM Sv M g7frrC)rnro srcElementObjs rJrpr)sCW]0BttWr) rQrarrrorrMrrU) r layeringMaprrindices srcOffset dstOffsetrjstorerrrs @@rJ_consolidateLayeringStream._consolidateLayering)sA \\^   % '#**,J { s: .!"UV V&)+&B "G]%,,II'] ADDDD %$% $ )I5 ,*,O**:6',CTWCCC $ )I(&(DO&&}5O'CP rIc\SUR;a2URSb"URSSLagURS$URSS9nSnUHnURUSS9nU[R:Xa OxXB:aB[ R "5n[XB- 5nXeRl URX%SS9 URRn[[X$U-55nM UR5 U(dSURS'gXRS'U$) a, Returns either (1) a Stream containing empty Music21Objects whose offsets and durations are the length of gaps in the Stream or (2) None if there are no gaps. N.B. there may be gaps in the flattened representation of the stream but not in the unflattened. Hence why "isSequence" calls self.flatten().isGapless >>> s = stream.Stream() >>> s.insert(1.0, note.Note('E', type='half')) >>> s.insert(5.0, note.Note('F', type='whole')) >>> s.storeAtEnd(bar.Barline('final')) >>> gapStream = s.findGaps() >>> gapStream.show('text', addEndTimes=True) {0.0 - 1.0} {3.0 - 5.0} Returns None if not gaps: >>> s2 = stream.Stream() >>> s2.append(note.Note('G')) >>> s2.findGaps() is None True * Changed in v7: gapStream is filled with rests instead of Music21Objects findGapsNFrrlTrr) rrrrr!r%rrrrrVrr)r gapStreamhighestCurrentEndTimeroeOffset gapElementgapQuarterLengtheDurs rJrStream.findGaps)s:  $Z)@)L{{:&%/;;z* *OOZO@ #A(($(?G-....!YY[ #)'*I#J 4D##1  !6t T::++D$*3/DPTn+U$V ! &+DKK #&/KK # rIcSUR;aURSbURS$UR5cSURS'gSURS'g)a@ Returns True if there are no gaps between the lowest offset and the highest time. Otherwise returns False >>> s = stream.Stream() >>> s.append(note.Note('C')) >>> s.append(note.Note('D')) >>> s.isGapless True >>> s.insert(10.0, note.Note('E')) >>> s.isGapless False OMIT_FROM_DOCS Test cache: >>> s.isGapless False isGaplessTF)rrrs rJrStream.isGapless*s[, $++ %$++k*B*N;;{+ +}}&+/ K(+0 K(rIcDUR5nURU5$)aM Find any elements that overlap. Overlapping might include elements that have zero-length duration simultaneous. This method returns a dictionary, where keys are the start time of the first overlap and value are a list of all objects included in that overlap group. This example demonstrates that end-joining overlaps do not count. >>> a = stream.Stream() >>> for x in range(4): ... n = note.Note('G#') ... n.duration = duration.Duration('quarter') ... n.offset = x * 1 ... a.insert(n) ... >>> d = a.getOverlaps() >>> len(d) 0 Notes starting at the same time overlap: >>> a = stream.Stream() >>> for x in [0, 0, 0, 0, 13, 13, 13]: ... n = note.Note('G#') ... n.duration = duration.Duration('half') ... n.offset = x ... a.insert(n) ... >>> d = a.getOverlaps() >>> len(d[0]) 4 >>> len(d[13]) 3 >>> a = stream.Stream() >>> for x in [0, 0, 0, 0, 3, 3, 3]: ... n = note.Note('G#') ... n.duration = duration.Duration('whole') ... n.offset = x ... a.insert(n) ... Default is to not include coincident boundaries >>> d = a.getOverlaps() >>> len(d[0]) 7 )rr)rrs rJrStream.getOverlaps *s&h'') ((44rIcTUR5nSnUHnU(dM Sn U$ U$)a A stream is a sequence if it has no overlaps. >>> a = stream.Stream() >>> for x in [0, 0, 0, 0, 3, 3, 3]: ... n = note.Note('G#') ... n.duration = duration.Duration('whole') ... n.offset = x * 1 ... a.insert(n) ... >>> a.isSequence() False OMIT_FROM_DOCS TODO: check that co-incident boundaries are properly handled >>> a = stream.Stream() >>> for x in [0, 4, 8.0]: ... n = note.Note('G#') ... n.duration = duration.Duration('whole') ... a.append(n) ... >>> a.isSequence() True TF)r)rrr indexLists rJ isSequenceStream.isSequenceY*s:6'') #Iy $ rIcb[R"U5n[R"U5n0nUHnURUS5nSXF'M UH*nUSRU5nX;dMXH==S- ss'M, /n [ U5Hn XJS:dM U R U 5 M U $)a returns an ordered list of offsets where elements are started (attacked) at the same time in both self and stream2. In this example, we create one stream of Qtr, Half, Qtr, and one of Half, Qtr, Qtr. There are simultaneous attacks at offset 0.0 (the beginning) and at offset 3.0, but not at 1.0 or 2.0: >>> st1 = stream.Stream() >>> st2 = stream.Stream() >>> st1.append([note.Note(type='quarter'), ... note.Note(type='half'), ... note.Note(type='quarter')]) >>> st2.append([note.Note(type='half'), ... note.Note(type='quarter'), ... note.Note(type='quarter')]) >>> print(st1.simultaneousAttacks(st2)) [0.0, 3.0] rrmr)r/OffsetIteratorrrrrU) rstream2stream1Offsetsstream2Offsets returnKeythisList thisOffsetthatList thatOffsetrrs rJsimultaneousAttacksStream.simultaneousAttacks*s*"006!009 &H++HQK8J$%I !''H!!44W=J&%*%'  !),K%*!!+.-rIcUR[R5HnSURlUR UR U5SSS9nUR[R5H9nSn[R"X$5nSUl XRRlUcM8 M M g![Ra N%f=f)ax For each element in self, creates an interval.Interval object in the element's editorial that is the interval between it and the element in cmpStream that is sounding at the moment the element in srcStream is attacked. Remember that if you are comparing two streams with measures, etc., you'll need to flatten each stream as follows: >>> #_DOCS_SHOW stream1.flatten().attachIntervalsBetweenStreams(stream2.flatten()) Example usage: >>> s1 = converter.parse('tinynotation: 7/4 C4 d8 e f# g A2 d2', makeNotation=False) >>> s2 = converter.parse('tinynotation: 7/4 g4 e8 d c4 a2 r2', makeNotation=False) >>> s1.attachIntervalsBetweenStreams(s2) >>> for n in s1.notes: ... if n.editorial.harmonicInterval is None: ... print('None') # Wil print if other voice had a rest. ... else: ... print(n.editorial.harmonicInterval.directedName) P12 M2 M-2 A-4 P-5 P8 None NF)r|r{harmonic) rr%rrPharmonicIntervalr rrr" intervalTyperMusic21Exception)r cmpStreamr simultEls simultNote interval1s rJattachIntervalsBetweenStreams$Stream.attachIntervalsBetweenStreams*s@((3A+/AKK (!55d6H6H6KFKGL6NI(::499E   ( 1 1! @I-7I*3>> s1 = converter.parse('tinyNotation: 7/4 C4 d8 e f# g A2 d2', makeNotation=False) >>> s1.attachMelodicIntervals() >>> for n in s1.notes: ... if n.editorial.melodicInterval is None: ... print('None') ... else: ... print(n.editorial.melodicInterval.directedName) None M9 M2 M2 m2 m-7 P4 >>> s = stream.Stream() >>> s.append(note.Note('C')) >>> s.append(note.Note('D')) >>> s.append(note.Rest(quarterLength=4.0)) >>> s.append(note.Note('D')) >>> s.attachMelodicIntervals() >>> for n in s.notes: ... if n.editorial.melodicInterval is None: ... print('None') # Will print if other voice had a rest. ... else: ... print(n.editorial.melodicInterval.directedName) None M2 P1 rNmelodic) r[r6rr%rrr"rrPmelodicIntervalr3)rr[ currentObjectpreviousObjectrs rJattachMelodicIntervalsStream.attachMelodicIntervals*sN !!#a '*"=$))<<">499=="*"3"3N"R/8,:I''7*N)..0M'rIcUbURU5nO URnURUSS9nU(dg[U5S:XaUS$UH!n[ XQR 5(dMUs $ US$)a Given an element (from another Stream) returns the single element in this Stream that is sounding while the given element starts. If there are multiple elements sounding at the moment it is attacked, the method returns the first element of the same class as this element, if any. If no element is of the same class, then the first element encountered is returned. For more complex usages, use allPlayingWhileSounding. Returns None if no elements fit the bill. The optional elStream is the stream in which el is found. If provided, el's offset in that Stream is used. Otherwise, the current offset in el is used. It is just in case you are paranoid that el.offset might not be what you want, because of some fancy manipulation of el.activeSite >>> n1 = note.Note('G#') >>> n2 = note.Note('D#') >>> s1 = stream.Stream() >>> s1.insert(20.0, n1) >>> s1.insert(21.0, n2) >>> n3 = note.Note('C#') >>> s2 = stream.Stream() >>> s2.insert(20.0, n3) >>> s1.playingWhenAttacked(n3) >>> n3.setOffsetBySite(s2, 20.5) >>> s1.playingWhenAttacked(n3) >>> n3.setOffsetBySite(s2, 21.0) >>> n3.offset 21.0 >>> s1.playingWhenAttacked(n3) If there is more than one item at the same time in the other stream then the first item matching the same class is returned, even if another element has a closer offset. >>> n3.setOffsetBySite(s2, 20.5) >>> s1.insert(20.5, clef.BassClef()) >>> s1.playingWhenAttacked(n3) >>> fc = clef.FClef() # superclass of BassClef >>> s2.insert(20.5, fc) >>> s1.playingWhenAttacked(fc) But since clefs have zero duration, moving the FClef ever so slightly will find the note instead >>> fc.setOffsetBySite(s2, 20.6) >>> s1.playingWhenAttacked(fc) Optionally, specify the site to get the offset from: >>> n3.setOffsetBySite(s2, 21.0) >>> n3.setOffsetBySite(None, 100) >>> n3.activeSite = None >>> s1.playingWhenAttacked(n3) is None True >>> s1.playingWhenAttacked(n3, s2).name 'D#' NFr|rmr)rrMr rrr)rrelStreamr otherElementsthisEls rJplayingWhenAttackedStream.playingWhenAttacked+sT  ))(3HyyH0050Q   1 $ # #'fll33!M(!# #rIcVUbURU5nO URnX1R-nXC:wa"URUUSSSS9R 5nOURUSS9R 5nX5lURUlUHnURU- UlM U$)a2 Returns a new Stream of elements in this stream that sound at the same time as `el`, an element presumably in another Stream. The offset of this new Stream is set to el's offset, while the offset of elements within the Stream are adjusted relative to their position with respect to the start of el. Thus, a note that is sounding already when el begins would have a negative offset. The duration of otherStream is forced to be the length of el -- thus a note sustained after el ends may have a release time beyond that of the duration of the Stream. As above, elStream is an optional Stream to look up el's offset in. Use this to work on an element in another part. The method always returns a Stream, but it might be an empty Stream. OMIT_FROM_DOCS TODO: write: requireClass: Takes as an optional parameter "requireClass". If this parameter is boolean True then only elements of the same class as el are added to the new Stream. If requireClass is list, it is used like classList in elsewhere in stream to provide a list of classes that the el must be a part of. F)r|rzrJr!)rrMrr r6)rrr"relEndr#r$s rJallPlayingWhileSoundingStream.allPlayingWhileSoundingt+s8  ))(3HyyH+++   44 %#(.3 55 6>> s = stream.Stream() >>> s.insert(0, note.Note('C4', quarterLength=4)) >>> s.repeatInsert(note.Note('b-4', quarterLength=0.5), [x * 0.5 for x in list(range(8))]) >>> s.makeVoices(inPlace=True) >>> len(s.voices) 2 >>> [n.pitch for n in s.voices[0].notes] [] >>> [str(n.pitch) for n in s.voices[1].notes] ['B-4', 'B-4', 'B-4', 'B-4', 'B-4', 'B-4', 'B-4', 'B-4'] * Changed in v7: if `fillGaps=True` and called on an incomplete measure, makes trailing rests in voices. This scenario occurs when parsing MIDI. r,rmNrT)rrFrr)rLrarr[r6rrrrrrUr,rrrVr rr) rrFrrQolDictr maxVoiceCountr7dummyrorrs rJr,Stream.makeVoices+sj,11,?II!! NN '')557V]]_E_ESZ_EKL A   =)E MM%' "* A!!),A==A%HHQN   Q ! Aq  A&    (,9=  " ' QFs<F countByIdc Sn/nUR5(a~UR[5HdnURn[ U5nU(d [ Xb5nM.UH0nUR U;dMURUR 5 M2 Mf ORUR5(a;URnU(d [ U5nOUVs/sHowR PM nnOSn[ U[ U55nU(dU$X#4$s snf)a Returns the maximum number of voices in a part. Used by voicesToParts. Minimum returned is 1. If `countById` is True, returns a tuple of (maxVoiceCount, voiceIdList) >>> import copy >>> p0 = stream.Part() >>> p0._maxVoiceCount() 1 >>> v0 = stream.Voice(id='v0') >>> p0.insert(0, v0) >>> p0._maxVoiceCount() 1 >>> v1 = stream.Voice(id='v1') >>> p0.insert(0, v1) >>> p0._maxVoiceCount() 2 >>> p1 = stream.Part() >>> m1 = stream.Measure(number=1) >>> p1.insert(0, m1) >>> p1._maxVoiceCount() 1 >>> m1.insert(0, v0) >>> p1._maxVoiceCount() 1 >>> m1.insert(0, v1) >>> p1._maxVoiceCount() 2 >>> m2 = stream.Measure(number=2) >>> p1.append(m2) >>> p1._maxVoiceCount() 2 >>> v01 = copy.copy(v0) >>> v11 = stream.Voice(id='v11') >>> m2.insert(0, v01) >>> m2.insert(0, v11) >>> p1._maxVoiceCount() 2 >>> v2 = stream.Voice(id='v2') >>> m2.insert(0, v2) >>> p1._maxVoiceCount() 3 If `countById` is True then different voice ids create different parts. >>> mvc, vIds = p1._maxVoiceCount(countById=True) >>> mvc 4 >>> vIds ['v0', 'v1', 'v11', 'v2'] >>> v01.id = 'v01' >>> mvc, vIds = p1._maxVoiceCount(countById=True) >>> mvc 5 >>> vIds ['v0', 'v1', 'v01', 'v11', 'v2'] rm) r,rrwr7rrrrUr) rr1 voiceCountvoiceIdsrmVoicesmVCountrr7s rJ_maxVoiceCountStream._maxVoiceCount+sz      ,,W5((g, !$W!9J$44x/$OOADD1% 6^^  [[F [ *01&QDD&1JS]3  ' '2sD  separateByIdc^^^^[5nTR5(aHTR[5H-nUR TS9nUHnUR SU5 M M/ U$TR TS9nT(dUm/nOUumn0m[T5Hn[5nUR SU5 T(d0[TR5S-[U5-Ul UTU'MVXxn [TR5S-[U 5-Ul UTU 'M UUUU4Sjn URHnURTSS9 M TR5(GaTR[5Hn U R5(a U "U 5 M"[5n U R!U 5 U RU 5 URSR TR#U 5U 5 [S T5H\n[5n U R!U 5 U RU S S9 URUR TR#U 5U 5 M^ M OpTR5(a=[%TR&5H#upURURU5 M% OURSRT5 URHUnUR5(dM[(R*"US S 9UR[5R-5lMW U$) a If this Stream defines one or more voices, extract each into a Part, returning a Score. If this Stream has no voices, return the Stream as a Part within a Score. >>> c = corpus.parse('demos/two-voices') >>> c.show('t') {0.0} {0.0} {0.0} {0.0} {0.0} {0.0} {0.0} {0.0} ... {0.0} {0.0} {0.0} {0.0} {0.0} ... {3.0} {0.0} {0.0} ... {3.5} {4.0} {0.0} {0.0} ... {3.0} {0.0} {0.0} ... {3.5} {8.0} {0.0} {4.0} {0.0} >>> ce = c.voicesToParts() >>> ce.show('t') {0.0} {0.0} {0.0} {0.0} {0.0} {0.0} {0.0} ... {3.0} {4.0} {0.0} ... {3.0} {8.0} {0.0} {4.0} {0.0} {0.0} {0.0} {0.0} {0.0} ... {3.5} {4.0} {0.0} ... {3.5} {8.0} {0.0} If `separateById` is True then all voices with the same id will be connected to the same Part, regardless of order they appear in the measure. Compare the previous output: >>> p0pitches = ce.parts[0].pitches >>> p1pitches = ce.parts[1].pitches >>> ' '.join([p.nameWithOctave for p in p0pitches]) 'E4 D#4 D#4 E4 F#4 E4 B3 B3 E4 E4' >>> ' '.join([p.nameWithOctave for p in p1pitches]) 'F#2 F#3 E3 E2 D#2 D#3 B2 B3 E2 E3 D3 D2 C#2 C#3 A2 A3' Swap voice ids in first measure: >>> m0 = c.parts[0].getElementsByClass(stream.Measure).first() >>> m0.voices[0].id, m0.voices[1].id ('3', '4') >>> m0.voices[0].id = '4' >>> m0.voices[1].id = '3' Now run voicesToParts with `separateById=True` >>> ce = c.voicesToParts(separateById=True) >>> p0pitches = ce.parts[0].pitches >>> p1pitches = ce.parts[1].pitches >>> ' '.join([p.nameWithOctave for p in p0pitches]) 'E4 D#4 D#4 E4 F#4 E2 E3 D3 D2 C#2 C#3 A2 A3' >>> ' '.join([p.nameWithOctave for p in p1pitches]) 'F#2 F#3 E3 E2 D#2 D#3 B2 B3 E4 B3 B3 E4 E4' Note that the second and subsequent measure's pitches were changed not the first, because separateById aligns the voices according to order first encountered, not by sorting the Ids. r9rr0z-v-c>[5nURU5 URUSS9 Sn[5n[ UR 5H|up$[ R"U5nURU5 URnT (dT UnOURU5 T UnURT RU5U5 M~ T (dQ[US-T 5H=nT UnURT RU5[ R"U55 M? gT HDn X;aM T U nURT RU5[ R"U55 MF g)zY This is the main routine for dealing with the most common and most difficult voice set. rr*rr4rhrrmN) rwrPrjrerr7rrrrrVrr)mInnermActive vIndexInnerseenIdsThisMeasurevInner mNewInnervIdrK emptyIndex voiceIdInner partCountpartDictrr:s rJdoOneMeasureWithVoices4Stream.voicesToParts..doOneMeasureWithVoices,sI iG  # #F +  ! !! " K!$ '0'?# !MM'2 ''/ii#%k2F&**3/%c]F d008)D(@" "' a"CJ%j1FMM$"4"4V"TU#D%-L#9 %l3FMM$"4"4V"TU %-rIr{r?rm)rr*r4Tr$)rxr*rrQ voicesToPartsrVr7rrlrrpartsrjr,rwrrPrrr7rrr)rr:rr-sSubpSub mvcReturnr4rvoiceIdrKrmNewmEmptyvIndexrrIrJs`` @@rJrMStream.voicesToPartsR,s` G  " " $ $,,V4LA DHHQ%!5H'','? !IH"+ Ix y!AA HHQN477|d*SV3 "+477|c)CL8$%!"/ V/ VdA OOD/O B     ,,W5;;==*1-#9D((+&&q)GGAJ%%d&8&8&;TB"1i0!(..q1,,QAM,N ))$*<*>> s = stream.Stream(note.Note()) >>> s.insert(0, note.Note()) >>> s.insert(0, note.Note()) >>> s.makeVoices(inPlace=True) >>> len(s.voices) 3 >>> s.remove(s.voices[1].notes[0], recurse=True) >>> s.remove(s.voices[2].notes[0], recurse=True) >>> voicesFlattened = s.flattenUnnecessaryVoices() >>> len(voicesFlattened.voices) 0 * Changed in v5: inPlace is default False and a keyword only arg. Nrm) r7rrrUr rrrrr) rr~rFrQr rQr shiftOffsetros rJflattenUnnecessaryVoicesStream.flattenUnnecessaryVoicesM-s>{{ d+II!!A a q! " A   Q  w<1 // : A((7H7H7K)KQO$  #   ) ) + rIc0nSnSSjnUGHEnUSLax[U[5(acUnURHOn USLa9U RbU RRS:XaU"XU5 US- nM?MAU"XU5 US- nMQ MUSLaO[U[ 5(a:UR USUS9n U H!n X;a/XK'XKRX5 M# M[U[R5(aQUSLa;URbURRS:XaU"XtU5 US- nGM1GM4U"XtU5 US- nGMEGMH U$)a Returns a dict of lists of lyric objects (with the keys being the lyric numbers) found in self. Each list will have an element for each note in the stream (which may be a note.Lyric() or None). By default, this method automatically recurses through measures, but not other container streams. >>> s = converter.parse('tinynotation: 4/4 a4 b c d e f g a', makeNotation=False) >>> someLyrics = ['this', 'is', 'a', 'list', 'of', 'eight', 'lyric', 'words'] >>> for n, lyric in zip(s.notes, someLyrics): ... n.lyric = lyric >>> s.lyrics() {1: [, ..., ]} >>> s.notes[3].lyric = None >>> s.lyrics()[1] [, ..., None, ..., ] If ignoreBarlines is True, it will behave as if the elements in measures are all in a flattened stream (note that this is not stream.flatten() as it does not copy the elements) together without measure containers. This means that even if recurse is False, lyrics() will still essentially recurse through measures. >>> s.makeMeasures(inPlace=True) >>> s.lyrics()[1] [, ..., None, ..., ] >>> list(s.lyrics(ignoreBarlines=False).keys()) [] If recurse is True, this method will recurse through all container streams and build a nested list structure mirroring the hierarchy of the stream. Note that if ignoreBarlines is True, measure structure will not be reflected in the hierarchy, although if ignoreBarlines is False, it will. Note that streams which do not contain any instance of a lyric number will not appear anywhere in the final list (not as a [] or otherwise). >>> scr = stream.Score(s) >>> scr.lyrics(ignoreBarlines=False, recurse=True)[1] [[[, <...'is'>, <...'a'>, None], [<...'of'>, <...'eight'>, <...'lyric'>, <...'words'>]]] Notice that the measures are nested in the part which is nested in the score. >>> scr.lyrics(ignoreBarlines=True, recurse=True)[1] [[, <...'is'>, <...'a'>, None, <...'of'>, <...'eight'>, <...'lyric'>, <...'words'>]] Notice that this time, the measure structure is ignored. >>> list(scr.lyrics(ignoreBarlines=True, recurse=False).keys()) [] rcUR(dUHnXRS5 M g/nURHsnURU;a([U5Vs/sHnSPM snXR'XRRU5 URUR5 Mu UHnX4;dM XRS5 M gs snfrs)rrUrr)rinner_returnListsnumNonesToAppendr addLyricNumsrr.s rJappendLyricsFromNote+Stream.lyrics..appendLyricsFromNote-s 88*A%(//5+Lhh99$55FKL\F]3^F]UDF]3^%ii0!)),33B7##BII.  '(%(//5'4_s CTrrm)ignoreBarlinesrYskipTies)rrXr`#dict[int, list[RecursiveLyricList]]rar) rrwr[r'rrQrrUr%r) rrerYrf returnListsnumNotesrcrorrsublistsrs rJr Stream.lyrics-shL<>   6 6B 6" 6,A%*Q*@*@A4'55=AEEJJ',A0J$MH ,QXF A !DZ6%:%:88>4Zb8c!A+)+ N))(+6"At||,,t#uu} g(=,QXF A (BMHCFrI) matchBySpanrFcSSKJn U(dURS5nOUn/n/nURUR5HnnUbXR ;aMUR n U S:XaURU5 M<U S:XaURU5 MUU S:XdM]URX5 Mp /n /n /n UHJnURX5upnU RU 5 U RU5 U RU5 ML URU SSS 9 /nUHRnURUR- nURU5UR-nURUS U-U/45 MT URUS SS 9 UH8nURX5upU RU5 U RU5 M: UR!X5 UR#5 U(dU$g) a For any :class:`~music21.variant.Variant` objects defined in this Stream (or selected by matching the `group` parameter), replace elements defined in the Variant with those in the calling Stream. Elements replaced will be gathered into a new Variant given the group 'default'. If a variant is activated with .replacementDuration different from its length, the appropriate elements in the stream will have their offsets shifted, and measure numbering will be fixed. If matchBySpan is True, variants with lengthType 'replacement' will replace all the elements in the replacement region of comparable class. If matchBySpan is False, elements will be swapped in when a match is found between an element in the variant and an element in the replacement region of the string. >>> sStr = 'd4 e4 f4 g4 a2 b-4 a4 g4 a8 g8 f4 e4 d2 a2 ' >>> v1Str = ' a2. b-8 a8 ' >>> v2Str1 = ' d4 f4 a2 ' >>> v2Str2 = ' d4 f4 AA2 ' >>> sStr += "d4 e4 f4 g4 a2 b-4 a4 g4 a8 b-8 c'4 c4 f1" >>> s = converter.parse('tinynotation: 4/4 ' + sStr, makeNotation=False) >>> s.makeMeasures(inPlace=True) # maybe not necessary? >>> v1stream = converter.parse('tinynotation: 4/4 ' + v1Str, makeNotation=False) >>> v2stream1 = converter.parse('tinynotation: 4/4 ' + v2Str1, makeNotation=False) >>> v2stream2 = converter.parse('tinynotation: 4/4 ' + v2Str2, makeNotation=False) >>> v1 = variant.Variant() >>> v1measure = stream.Measure() >>> v1.insert(0.0, v1measure) >>> for e in v1stream.notesAndRests: ... v1measure.insert(e.offset, e) >>> v2 = variant.Variant() >>> v2.replacementDuration = 4.0 >>> v2measure1 = stream.Measure() >>> v2measure2 = stream.Measure() >>> v2.insert(0.0, v2measure1) >>> v2.insert(4.0, v2measure2) >>> for e in v2stream1.notesAndRests: ... v2measure1.insert(e.offset, e) >>> for e in v2stream2.notesAndRests: ... v2measure2.insert(e.offset, e) >>> v3 = variant.Variant() >>> v3.replacementDuration = 4.0 >>> v1.groups = ['docVariants'] >>> v2.groups = ['docVariants'] >>> v3.groups = ['docVariants'] >>> s.insert(4.0, v1) # replacement variant >>> s.insert(12.0, v2) # insertion variant (2 bars replace 1 bar) >>> s.insert(20.0, v3) # deletion variant (0 bars replace 1 bar) >>> s.show('text') {0.0} {0.0} {0.0} {0.0} {1.0} {2.0} {3.0} {4.0} {4.0} {0.0} {2.0} {3.0} {8.0} {0.0} {1.0} {1.5} {2.0} {3.0} {12.0} {12.0} {0.0} {2.0} {16.0} {0.0} {1.0} {2.0} {3.0} {20.0} {20.0} {0.0} {2.0} {3.0} {24.0} {0.0} {1.0} {1.5} {2.0} {3.0} {28.0} {0.0} {4.0} >>> docVariant = s.activateVariants('docVariants') >>> #_DOCS_SHOW s.show() .. image:: images/stream_activateVariants1.* :width: 600 >>> #_DOCS_SHOW docVariant.show() .. image:: images/stream_activateVariants2.* :width: 600 >>> docVariant.show('text') {0.0} {0.0} {0.0} {0.0} {1.0} {2.0} {3.0} {4.0} {4.0} {0.0} {3.0} {3.5} {8.0} {0.0} {1.0} {1.5} {2.0} {3.0} {12.0} {12.0} {0.0} {1.0} {2.0} {16.0} {0.0} {1.0} {2.0} {20.0} {0.0} {1.0} {2.0} {3.0} {24.0} {24.0} {0.0} {1.0} {1.5} {2.0} {3.0} {28.0} {0.0} {4.0} After a variant group has been activated, the regions it replaced are stored as variants with the group 'default'. It should be noted that this means .activateVariants should rarely if ever be used on a stream which is returned by activateVariants because the group information is lost. >>> defaultVariant = docVariant.activateVariants('default') >>> #_DOCS_SHOW defaultVariant.show() .. image:: images/stream_activateVariants3.* :width: 600 >>> defaultVariant.show('text') {0.0} {0.0} {0.0} {0.0} {1.0} {2.0} {3.0} {4.0} {4.0} {0.0} {2.0} {3.0} {8.0} {0.0} {1.0} {1.5} {2.0} {3.0} {12.0} {12.0} {0.0} {2.0} {16.0} {0.0} {1.0} {2.0} {3.0} {20.0} {20.0} {0.0} {2.0} {3.0} {24.0} {0.0} {1.0} {1.5} {2.0} {3.0} {28.0} {0.0} {4.0} rvariantactivateVariantsN elongationdeletionrT)isRemoverFrF)r?rorLrr'r lengthTyperU_insertReplacementVariant_insertDeletionVariantr_removeOrExpandGapsreplacementDurationcontainedHighestTimer_insertInsertionVariant_fixMeasureNumbersr)rrrlrFrorQelongationVariantsdeletionVariantsrrtdeletedMeasuresinsertedMeasuresdeletedRegionsForRemoval deletedRegionvDeletedMeasuresvInsertedMeasuresTupleinsertionRegionsForExpansionlengthDifferenceinsertionStarts rJrpStream.activateVariants.sb $112DEII --goo>A U((%:J\)"))!,z) ''*},33AC?$$& !A11!A ].D $ + +M :  " "#3 4  # #$: ;" %%&>W[%\(*$#A 44q7M7MM ..y9A>> v = variant.Variant() >>> variantDataM1 = [('b', 'eighth'), ('c', 'eighth'), ... ('a', 'quarter'), ('a', 'quarter'),('b', 'quarter')] >>> variantDataM2 = [('c', 'quarter'), ('d', 'quarter'), ('e', 'quarter'), ('e', 'quarter')] >>> variantData = [variantDataM1, variantDataM2] >>> for d in variantData: ... m = stream.Measure() ... for pitchName,durType in d: ... n = note.Note(pitchName) ... n.duration.type = durType ... m.append(n) ... v.append(m) >>> v.groups = ['paris'] >>> v.replacementDuration = 8.0 >>> s = stream.Stream() >>> streamDataM1 = [('a', 'quarter'), ('b', 'quarter'), ('a', 'quarter'), ('g', 'quarter')] >>> streamDataM2 = [('b', 'eighth'), ('c', 'quarter'), ('a', 'eighth'), ... ('a', 'quarter'), ('b', 'quarter')] >>> streamDataM3 = [('c', 'quarter'), ('b', 'quarter'), ('a', 'quarter'), ('a', 'quarter')] >>> streamDataM4 = [('c', 'quarter'), ('b', 'quarter'), ('a', 'quarter'), ('a', 'quarter')] >>> streamData = [streamDataM1, streamDataM2, streamDataM3, streamDataM4] >>> for d in streamData: ... m = stream.Measure() ... for pitchName,durType in d: ... n = note.Note(pitchName) ... n.duration.type = durType ... m.append(n) ... s.append(m) >>> s.insert(4.0, v) >>> deletedMeasures, insertedMeasuresTuple = s._insertReplacementVariant(v) >>> deletedMeasures [] >>> insertedMeasuresTuple (0, []) >>> s.show('text') {0.0} {0.0} {1.0} {2.0} {3.0} {4.0} {4.0} {0.0} {0.5} {1.0} {2.0} {3.0} {8.0} {0.0} {1.0} {2.0} {3.0} {12.0} {0.0} {1.0} {2.0} {3.0} rrndefaultrmr0FN)r?ror'rrrr containedSiter rr/rUr rVrVrrreplacedElementsrrwpopleftr)rrrlroremovedvStarttargetsMatchedro oInStreamrtargetToReplacer~r highestNumber oInVariants rJru Stream._insertReplacementVariant@/s)D $//####A&NZZ"%6%6q%GG 229=PPQRQZQZ[\Q]^7"a'N&-ajONN?3KK0KK - UCC#2#9#9' *! A F, "$gO!  M((.G!//2V; z- Aa))#**1884ZZ"%6%6q%GG  I)a))#:#:#<)* $%)//2 " KKN KK ()"57 7rIcSSKJn [5nURUR- nUR 5nS/UlURUlURU5nXqR-nURU5n U Hin [U [5(aURU R5 URU 5U- n URX5 URU 5 Mk Sn /n URHn [U [5(aAU(a"UR!5U l U Rn OSU l U RU 5 XzR#UR$5-nURX5 M URU5 URXv5 X/4['U5X44$)a Helper function for activateVariants used for inserting variants that are shorter than the region they replace. Inserts elements in the variant and deletes elements in the replaced region but does not close gaps. Returns a tuple describing the region where elements were removed, the gap is left behind to be dealt with by _removeOrExpandGaps. Tuple is of form (startOffset, lengthOfDeletedRegion, []). The empty list is expected by _removeOrExpandGaps and describes the list of elements which should be exempted from shifting for a particular gap. In the case of deletion, no elements need be exempted. >>> v = variant.Variant() >>> variantDataM1 = [('b', 'eighth'), ('c', 'eighth'), ('a', 'quarter'), ... ('a', 'quarter'),('b', 'quarter')] >>> variantDataM2 = [('c', 'quarter'), ('d', 'quarter'), ... ('e', 'quarter'), ('e', 'quarter')] >>> variantData = [variantDataM1, variantDataM2] >>> for d in variantData: ... m = stream.Measure() ... for pitchName,durType in d: ... n = note.Note(pitchName) ... n.duration.type = durType ... m.append(n) ... v.append(m) >>> v.groups = ['paris'] >>> v.replacementDuration = 12.0 >>> s = stream.Stream() >>> streamDataM1 = [('a', 'quarter'), ('b', 'quarter'), ('a', 'quarter'), ('g', 'quarter')] >>> streamDataM2 = [('b', 'eighth'), ('c', 'quarter'), ('a', 'eighth'), ... ('a', 'quarter'), ('b', 'quarter')] >>> streamDataM3 = [('c', 'quarter'), ('b', 'quarter'), ('a', 'quarter'), ('a', 'quarter')] >>> streamDataM4 = [('c', 'quarter'), ('b', 'quarter'), ('a', 'quarter'), ('a', 'quarter')] >>> streamData = [streamDataM1, streamDataM2, streamDataM3, streamDataM4] >>> for d in streamData: ... m = stream.Measure() ... for pitchName,durType in d: ... n = note.Note(pitchName) ... n.duration.type = durType ... m.append(n) ... s.append(m) >>> s.insert(4.0, v) >>> deletedRegion, deletedMeasures, insertedMeasuresTuple = s._insertDeletionVariant(v) >>> deletedRegion (12.0, 4.0, []) >>> deletedMeasures [0] >>> insertedMeasuresTuple (0, []) >>> s.show('text') {0.0} {0.0} {1.0} {2.0} {3.0} {4.0} {4.0} {0.0} {0.5} {1.0} {2.0} {3.0} {8.0} {0.0} {1.0} {2.0} {3.0} rrnrN)r?rorrxryr'rrrrrwrUrrVr rrrrr)rrrlror~rrr deletionStartrrorrrrs rJrvStream._insertDeletionVariant/sV $'0013I3II//##&'&<&<###A&!7!77 $$T*A!W%%&&qxx0++A.7J NN: ) KKN  A!W%%#.668AH%&HHM AH%++A.!2!21??!CCI KK %!& A F$ b 1  !  -  rIcSSKJn [5nUR5nS/UlUR UlURU5nURU5nUHin[U[5(aURUR5 URU5U- n URX5 URU5 Mk Sn /n URHn[U[5(aAU(a"UR!5Ul URn OSUl U RU5 XhR#UR$5-n URX5 M U caUR'SURU5SSSS9R)[5n Sn U H$nU bURU :dMURn M& URU5 URXe5 X4U4$) a Helper function for activateVariants. _removeOrExpandGaps must be called on the expanded regions before this function, or it will not work properly. >>> v = variant.Variant() >>> variantDataM1 = [('b', 'eighth'), ('c', 'eighth'), ('a', 'quarter'), ... ('a', 'quarter'),('b', 'quarter')] >>> variantDataM2 = [('c', 'quarter'), ('d', 'quarter'), ... ('e', 'quarter'), ('e', 'quarter')] >>> variantData = [variantDataM1, variantDataM2] >>> for d in variantData: ... m = stream.Measure() ... for pitchName,durType in d: ... n = note.Note(pitchName) ... n.duration.type = durType ... m.append(n) ... v.append(m) >>> v.groups = ['paris'] >>> v.replacementDuration = 4.0 >>> s = stream.Stream() >>> streamDataM1 = [('a', 'quarter'), ('b', 'quarter'), ('a', 'quarter'), ('g', 'quarter')] >>> streamDataM2 = [('b', 'eighth'), ('c', 'quarter'), ('a', 'eighth'), ... ('a', 'quarter'), ('b', 'quarter')] >>> streamDataM3 = [('c', 'quarter'), ('b', 'quarter'), ('a', 'quarter'), ('a', 'quarter')] >>> streamDataM4 = [('c', 'quarter'), ('b', 'quarter'), ('a', 'quarter'), ('a', 'quarter')] >>> streamData = [streamDataM1, streamDataM2, streamDataM3, streamDataM4] >>> for d in streamData: ... m = stream.Measure() ... for pitchName,durType in d: ... n = note.Note(pitchName) ... n.duration.type = durType ... m.append(n) ... s.append(m) >>> s.insert(4.0, v) >>> insertionRegionsForExpansion = [(8.0, 4.0, [v])] >>> s._removeOrExpandGaps(insertionRegionsForExpansion, isRemove=False, inPlace=True) >>> insertedMeasuresTuple, deletedMeasures = s._insertInsertionVariant(v) >>> measurePrior, insertedMeasures = insertedMeasuresTuple >>> measurePrior 0 >>> len(insertedMeasures) 1 >>> s.show('text') {0.0} {0.0} {1.0} {2.0} {3.0} {4.0} {4.0} {0.0} {0.5} {1.0} {2.0} {3.0} {8.0} {0.0} {1.0} {2.0} {3.0} {12.0} {0.0} {1.0} {2.0} {3.0} {16.0} {0.0} {1.0} {2.0} {3.0} rrnrNrlTFry)r?rorr'rryrxrrrrwrUrrVr rrrrr r)rrrlror~rrrrorhighestMeasurerrmeasuresToCheckrs rJrzStream._insertInsertionVariantZ0s` $'//##&'&<&<###A&$$T*A!W%%&&qxx0++A.7J NN: ) KKN A!W%%#.668AH%&XXN !AH$++A.!2!21??!CCI KK %"  !#66s7;7I7I!7LJNHMGK 79 :L9KG9T  N$!)QXX-F%&XXN% A F$1?BBrIc USLaUnO[R"U5nURRnUSLaSn[ USS9n[ U5HupU upn [ SU 55n US-[U5:a XxS-SnSnOUnSnXk-nURX-UUSSS 9H]n[U5U ;aMU(dURRU ;aM7URU5nURUUU- 5 M_ M GOSn0n[ US S9n[ U5H<upU upn US-[U5:a XxS-SnSnOUnSnUnXk-nXnUU U4UU 'M> [ US S9HnUUupnpn[ S U 55n URUUUSSS 9Hn[U5U ;d!U(dBURRU ;a(URU5nURUUU-5 M[URU5nURUUU-5 M M UR5 USLag U$)a Helper for activateVariants. Takes a list of tuples in the form (startOffset, duration, [list, of, exempt, objects]). If isRemove is True, gaps with duration will be closed at each startOffset. Exempt objects are useful for gap-expansion with variants. The gap must push all objects that occur after the insertion ahead, but the variant object itself should not be moved except by other gaps. This is poorly written and should be re-written, but it is difficult to describe. >>> s = stream.Stream() >>> s.insert(5.0, note.Note('a')) >>> s.insert(10.0, note.Note('b')) >>> s.insert(11.0, note.Note('c')) >>> s.insert(12.0, note.Note('d')) >>> s.insert(13.0, note.Note('e')) >>> s.insert(20.0, note.Note('f')) >>> n = note.Note('g') >>> s.insert(15.0, n) >>> sGapsRemoved = s._removeOrExpandGaps( ... [(0.0, 5.0, []), (6.0, 4.0, []), (14.0, 6.0, [n])], isRemove=True) >>> sGapsRemoved.show('text') {0.0} {1.0} {2.0} {3.0} {4.0} {5.0} {15.0} >>> sGapsExpanded = s._removeOrExpandGaps( ... [(0.0, 5.0, []), (11.0, 5.0, []), (14.0, 1.0, [n])], isRemove=False) >>> sGapsExpanded.show('text') {10.0} {15.0} {21.0} {22.0} {23.0} {25.0} {31.0} Trlc US$r/rCrs rJr,Stream._removeOrExpandGaps..1 6RS9rIr!c38# UHn[U5v M g7frsrrms rJrp-Stream._removeOrExpandGaps..1%C]bee]rrmrFryc US$r/rCrs rJrr81rrIc SU-$NrrC)rjs rJrrH1sR#XrIc38# UHn[U5v M g7frsrrms rJrprK1rrN)rrrrrrrerr rroriginIdrrr)rlistOffsetDurExemptionrsrFrQreturnObjDurationr listSortedrdurTuplerdurationAmount exemptObjectsexemptObjectSetr includeEndror shiftsDict exemptShiftrMs rJrwStream._removeOrExpandGaps0sV d?I d+I%..<< t H 6n UbU RU:dMU RU:dM*U RU-U l M@ UnMO Sn[USS9HMnXnUH>n UbU RU:dMU RU:dM*U RU-U l M@ UnMO g)a Corrects the measures numbers of a string of measures given a list of measure numbers that have been deleted and a list of tuples (highest measure number below insertion, number of inserted measures). >>> s = converter.parse('tinynotation: 4/4 d4 e4 f4 g4 a2 b-4 a4 g4 a8 g8 f4 e4 g1') >>> s[-1].offset = 20.0 >>> s.show('text') {0.0} {0.0} {0.0} {0.0} {1.0} {2.0} {3.0} {4.0} {0.0} {2.0} {3.0} {8.0} {0.0} {1.0} {1.5} {2.0} {3.0} {20.0} {0.0} {4.0} >>> s.remove(s.measure(2)) >>> s.show('text') {0.0} {0.0} ... {8.0} {0.0} ... {20.0} {0.0} {4.0} >>> deletedMeasures = [2] >>> m1 = stream.Measure() >>> m1.repeatAppend(note.Note('e'),4) >>> s.insert(12.0, m1) >>> m2 = stream.Measure() >>> m2.repeatAppend(note.Note('f'),4) >>> s.insert(16.0, m2) >>> s.show('text') {0.0} {0.0} ... {8.0} {0.0} ... {12.0} {0.0} {1.0} {2.0} {3.0} {16.0} {0.0} {1.0} {2.0} {3.0} {20.0} {0.0} {4.0} >>> insertedMeasures = [(3, [m1, m2])] >>> s._fixMeasureNumbers(deletedMeasures, insertedMeasures) >>> s.show('text') {0.0} {0.0} {0.0} ... {8.0} {0.0} ... {12.0} {0.0} ... {16.0} {0.0} ... {20.0} {0.0} {4.0} >>> fixedNumbers = [] >>> for m in s.getElementsByClass(stream.Measure): ... fixedNumbers.append( m.number ) >>> fixedNumbers [1, 2, 3, 4, 5] NcP>[U[5(a T"US5$UcgU$)Nri)rr) numOrNumTuplemeasureNumberSortRoutines rJr;Stream._fixMeasureNumbers..measureNumberSortRoutine1s/-/// a0@AA&$$rIr!rrmc SU-$rrCrs rJr+Stream._fixMeasureNumbers..1b1frIc SU-$rrCrs rJrr2rrI) rrrrwr6rrrr rUrr)rr~r allMeasures oldMeasures newMeasurescumulativeNumberShiftoldCorrectionsnewCorrectionsr measurePriorextendedMeasures nextMeasurerpreviousBoundaryrshiftrs @rJr{Stream._fixMeasureNumberse1s~ /0%   % 56--g6==?  !)M-//1>. '%-=)>>%*Q. )A&&q)&&q)*H1$K * 4I|a/0.C{+%*%4I}q014I}q01#), ,<=A"%E #+qxx:J/Jxx1}#$88e#3! !  > ,<=A"%E #+qxx:J/Jxx1}#$88e#3! !  >rIcSSKJn X;aURSUSU35eUSLaUnUnOWURS5nURR 5R U5nUR5RUnUGHn[R"U5n Sn U RGHpn U Rn SU ;a8U Rn X;dU RS ;aU RU 5 GOSn GOS U ;aU RR nU R#U 5nU RU 5 [$R&"5nSUR(lUURlU R-UU5 OS U ;aU RR nU R.HnU RU5 M [$R&"5nUURlSUR(lU R-S U5 SU R(lGMs U R1USSS 9 U (dGMUR-S U 5 GM U(agU$)a, Takes a part within the score and a list of variant groups within that part. Puts the variant object in a part surrounded by hidden rests to mimic the appearance of an ossia despite limited musicXML support for ossia staves. Note that this will ignore variants with .lengthType 'elongation' and 'deletion' as there is no good way to represent ossia staves like those by this method. >>> sPartStr = 'd4 e4 f4 g4 a2 b-4 a4 g4 a8 g8 f4 e4 d2 a2 ' >>> v1Str = ' a2. b-8 a8 ' >>> v2Str = ' d4 f4 a2 ' >>> sPartStr += "d4 e4 f4 g4 a2 b-4 a4 g4 a8 b-8 c'4 c4 f1" >>> sPartStream = converter.parse('tinynotation: 4/4 ' + sPartStr) >>> sPartStream.makeMeasures(inPlace=True) # maybe not necessary? >>> v1stream = converter.parse('tinynotation: 4/4 ' + v1Str) >>> v2stream = converter.parse('tinynotation: 4/4 ' + v2Str) >>> v1 = variant.Variant() >>> v1measure = stream.Measure() >>> v1.insert(0.0, v1measure) >>> for e in v1stream.notesAndRests: ... v1measure.insert(e.offset, e) >>> v2 = variant.Variant() >>> v2measure = stream.Measure() >>> v2.insert(0.0, v2measure) >>> for e in v2stream.notesAndRests: ... v2measure.insert(e.offset, e) >>> v3 = variant.Variant() >>> v2.replacementDuration = 4.0 >>> v3.replacementDuration = 4.0 >>> v1.groups = ['variant1'] >>> v2.groups = ['variant2'] >>> v3.groups = ['variant3'] >>> sPart = stream.Part() >>> for e in sPartStream: ... sPart.insert(e.offset, e) >>> sPart.insert(4.0, v1) >>> sPart.insert(12.0, v2) >>> sPart.insert(20.0, v3) # This is a deletion variant and will be skipped >>> s = stream.Score() >>> s.insert(0.0, sPart) >>> streamWithOssia = s.showVariantAsOssialikePart(sPart, ... ['variant1', 'variant2', 'variant3'], inPlace=False) >>> #_DOCS_SHOW streamWithOssia.show() rrnzCould not find z in TshowVariantAsOssialikePartFr')rqrrr rwrl)rFrlN)r?roVariantExceptionrLrNr6r%rrrrr/rrtr rrrr%rr*hideObjectOnPrintrVrrp)r containedPart variantGroupsrFrorQ returnPartcontainedPartIndex variantGroupnewPartexpressedVariantsExistroeClasses elementGroupsnQuarterLengthnOffsetrmeasureDurationrs rJr!Stream.showVariantAsOssialikePart 2sl $%**_]O4PTv+VW W d?I&J112NOI!%!2!2!4!:!:=!I ")//0BCJ*LmmJ/G%* "%%99($%HHM): ||/IIq)15."h.%&ZZ%=%=N//8GNN1% A04AGG-/=AJJ,NN7A.(*&'jj&>&>O__ - A/>AJJ,04AGG-HHS!$,0)5&8  $ $\4T $ R%%  g.C*F   rI)r~r{rrrrr}rbrerdrrcrarMr)r.rs)rz?t.Union[None, base.Music21Object, Sequence[base.Music21Object]]rhr1)rqrrprF)rq#iterator.StreamIterator[M21ObjType])rrrq&iterator.RecursiveIterator[M21ObjType])rrrqr)rrrqzlist[M21ObjType])rtype[ChangedM21ObjType]rqz-iterator.RecursiveIterator[ChangedM21ObjType])rrrqr)rzCollection[type]rqr)rzCt.Union[str, int, slice, type[ChangedM21ObjType], Collection[type]]rqz|t.Union[iterator.RecursiveIterator[M21ObjType], iterator.RecursiveIterator[ChangedM21ObjType], M21ObjType, list[M21ObjType]])rqzM21ObjType | None)rbase.Music21Objectrqr)rqztuple[M21ObjType, ...])rz%Stream | Iterable[base.Music21Object])rrrz'Stream'rqr)rqclef.Clef | None)r&r)rqmeter.TimeSignature | None)r0r)rqkey.KeySignature | None)r9r)rGr)rqNone)rrr str | Nonerqr)rr)r\rrqrF)rrrqr)rz1base.Music21Object | Sequence[base.Music21Object])r%z int | Nonerqr)rrrzdict[int, t.Any] | Nonerqr)rrrqr)rLrrMz&int | float | Fraction | OffsetSpecial)rrrqr rrrrrYrrrrqr)rqzbase._SplitTuple)NNNN) rrrrrrrrrr)rOr)rr)rhzstr | Iterable[str]rqr)rhrrqz*iterator.StreamIterator[ChangedM21ObjType])rhz!Iterable[type[ChangedM21ObjType]]rqr)rhzWt.Union[str, Iterable[str], type[ChangedM21ObjType], Iterable[type[ChangedM21ObjType]]]rqzXt.Union[iterator.StreamIterator[M21ObjType], iterator.StreamIterator[ChangedM21ObjType]])rqziterator.StreamIterator)rqbase.Music21Object | None)rMrrIt.Union[str, Iterable[str], type[M21ObjType], type, Iterable[type], None]rrrqr)rMrrrrqr)r int | strrrrrrqz list[Measure])rqzStream[Measure])rqzMeasure | None)rwrhz5list[t.Type] | list[str] | tuple[t.Type] | tuple[str]rqz,OrderedDict[float | Fraction, list[Measure]])rqz(iterator.StreamIterator[spanner.Spanner])rqbool | t.Literal['unknown'])rr) rrrArrBrrCrrFt.Literal[True]rqr) rrrArrBrrCrrFt.Literal[False]rqr) rrrArrBrrCrrFrrqStreamType | None)rqz bool | str)rCr)rmrrCrrFr)rqzStream[instrument.Instrument])rqzinstrument.Instrument | None)NNN)@rNN)FF)NNFNfinalFF)NFFFF)r list[pitch.Pitch] | Noner rr rr bool | key.KeySignaturerrrrrrrrrFrrrrrrset[str] | None)rrr rr rr rrrrrrrrrrrrr)rrrFrr:rrqr)rrrFrr:rrqr)rrrFrr:rrqr)Fr)rvrrqr)rvrrqz"iterator.RecursiveIterator[Stream])rvrr>rrrrqzSt.Union[iterator.RecursiveIterator[M21ObjType], iterator.RecursiveIterator[Stream]])rrrqz Stream | NoneT)rq'music21.duration.Duration')rr)rqmetadata.Metadata | None)rrrqr)rz+str | int | 'music21.interval.IntervalBase')rCTTFF) rLz Iterable[int]rUrrVrrFrrYr)rrrcrrqr)NTFFrW)rqz)iterator.StreamIterator[note.GeneralNote])rqz%iterator.StreamIterator[note.NotRest])rqzlist[pitch.Pitch])rrrrrrrrrrrrrrrqzlist[note.NotRest])rrrrrrrrrrrrrrrqzlist[note.Note])rrrrrrrrrrrrrrrqzlist[note.NotRest | None])rrrrrrrrrrrrrrrqzGt.Union[list[note.NotRest | None], list[note.NotRest], list[note.Note]])rqzlist[tuple[OffsetQL, OffsetQL]])rqzlist[list[int]])rqzint | tuple[int, list[str]])TFF)rerrYrrfrrqrgTF)rDrErFrG__doc__rtr0rS__annotations__r2ELEMENTS_FIRSTrTr* StreamStyle _styleClass _DOC_ORDERrgr1rrzrrrrrrrrr rrrrpropertyrsetterrrrrrr,r6rBrJrrPr deprecatedr]rbrjr%r r$rrrrrrrrrVrrUrWrXrrr1rGrrr|rrrrrrrrr rrrrrALLrr frozensetrr%r+r0rr7r:r=rGrcr^r_rMrMr|r%rrrrrrrrrrr"rrr rrrrOr-rNr=rwrrrQrZrYr rrrrrrrrrrrsecondsrrrrrrr#rrrrr rr]r_r`r^rOrfrjrvr|rr,rr*rrrr[r\rrrrrrrrrrr rrr%r)r,r7rMrXr\rrprurvrzrwr{rrH __classcell__rs@rJrQrQhsZzHI #NI##0#?#?M=?##KIJ ( &;(!I~(XIM?# AV@]@] ?#!F?# )> ?#?#B  99 ::<<5"        "  7     0     0  W 1W 3 W r42 HDa.a.F__+#+#Z('T #AFB& & P [[ " "11f  ""H"33j 3 3(:::4 vu'122@G#R<FB" a6La6F**X6>(@/*=AB04B$9B$. BBH  <@55#55155nJ\A( ! A(FDOLw2r-5dv4z%*8.18.28J!&#' I*I/I I ! I -1 IV+0O)O)h+/%)49+/ [1 5E [1@"#"" %%* A 03 AF(-uCC,15 1 1%) $ $ $ . ', .!... . $ .b?@L)-:(%**. :(#&:(@ ,= C   ,C J   ,M C  Q?-Q?!TQ?fUBR:$Rv  &*v !vD D#DD DD !D` BOBO BO !BOjARZZZ  Z  ZBH%))e eVP"' 8-9 8x $#" "++ HXLX} H}  4} ~ &&,.>;E ; Lz 0 088&%%.SS &**/     $  $(  !     &**/$)     $  $(  "     &**/ EEE $ E $( E  E EN'X+0 \$(\B#(*/ Q Q$( Q  Qj)-(,"&-1 FT)-%)# Z)F Z|(,$(# #)C #J,099T?X uX zM#^2&0P$#L?B046v0/j#Un>@HX! :"!&  ."(-"&"2"2!4  ($)DX] *-137;?1515,1%)#$-1%)^*^1 ^ #9 ^ / ^/^&*^#^^^^'+^#^@ -"&*."#9=@D>B>B26+0,1:>26z !7 z (>z '<z &<z ,0z %)z &*z 48z #0z x38@D " !   %*! "   ! BBB B  BH FT)!XbHWWr  16#' `-` &L ``$( S,S &H SS%*+/%' [![%)[# [ &Q [B 2 2  2h"#",",H+ ^*^*@6+6+p +X (#(#T__!! /b{K&6 & GPOb6.b./ J8 ( l    H"5 i$ff6fP9A'+URh8=0;@1j02#!% j ,j j  j  j  j X,,bBF&*EQf15e"N$ Wt  !+0 4r*@ (K1Z$6r&&P99vAAJ ',!!!  %             !!!  $              !!!#(         !  !  "  !!!bb b  b  bbbb bHNb&#J*X6p=~>75r!N'h0d21hX$t2n%*DJX+0Y(Y(v-2n` $16u@P $ EEE E - ERb$bbH R7lB HKC\49||b!HSXoorIrQc4\rSrSrSr\R rSrSr g)r,i}2a A Stream subclass for declaring that all the music in the stream belongs to a certain "voice" for analysis or display purposes. Note that both Finale's Layers and Voices as concepts are considered Voices here. Voices have a sort order of 1 greater than time signatures r>rCN) rDrErFrGrr2rrTrSrHrCrIrJr,r,}2s "00MNrIr,c ^\rSrSr%Sr\R rSrS/r SSSSS S S S S S. r S\ S'SS.S$U4Sjjjr Sr SrU4SjrS%SjrS&SjrS'Sjr\S5rSrSrSr\"\\SS9rS rS!r\"\\S"S9rS#rU=r$)(rwi2a A representation of a Measure organized as a Stream. All properties of a Measure that are Music21 objects are found as part of the Stream's elements. Measure number can be explicitly set with the `number` keyword: >>> m4 = stream.Measure(number=4) >>> m4 >>> m4.number 4 If passed a single integer as an argument, assumes that this int is the measure number. >>> m5 = stream.Measure(5) >>> m5 Number can also be a string if there is a suffix: >>> m4 = stream.Measure(number='4a') >>> m4 >>> m4.numberSuffix 'a' Though they have all the features of general streams, Measures have specific attributes that allow for setting their number and numberSuffix, keep track of whether they have a different clef or key or timeSignature than previous measures, allow for padding (and pickups), and can be found as a "measure slice" within a score and parts. Trzh Boolean describing if the TimeSignature is different than the previous Measure.zFBoolean describing if the Clef is different than the previous Measure.zJBoolean describing if KeySignature is different than the previous Measure.zu A number representing the displayed or shown Measure number as presented in a written Score.aP If a Measure number has a string annotation, such as "a" or similar, this string is stored here. Note that in MusicXML, such suffixes often appear as prefixes to measure numbers. In music21 (like most measure numbering systems), these numbers appear as suffixes.zG Enum describing if the measure number should be displayed.z A suggestion for layout width, though most rendering systems do not support this designation. Use :class:`~music21.layout.SystemLayout` objects instead.ao defines empty space at the front of the measure for purposes of determining beat, etc for pickup/anacrusis bars. In 4/4, a measure with a one-beat pickup note will have a `paddingLeft` of 3.0. (The name comes from the CSS graphical term for the amount of padding on the left side of a region.)a defines empty space at the end of the measure for purposes of determining whether or not a measure is filled. In 4/4, a piece beginning a one-beat pickup note will often have a final measure of three beats, instead of four. The final measure should have a `paddingRight` of 1.0. (The name comes from the CSS graphical term for the amount of padding on the right side of a region.)) timeSignatureIsNew clefIsNewkeyIsNewrr showNumber layoutWidth paddingLeft paddingRightrfrgrrc>[U5S:Xa%[US[5(a US:XaUSnSn[TU]"U0UD6 SUlSUlSUlSUlSUl SUl SUl [U[5(a6[R"U5upE[U5UlU(aXPl OXl[ R"UlSUlg)NrmrrCFrl)rrrryrzrr r filledr rrrrrrr3DEFAULTr r )rrargsrrealNumsuffixrs rJrzMeasure.__init__2s t9>ja#666Q;!WFD $+(+#(  &)&)  fc " "$226:OGg,DK$*! K$,, rIcUR(a"[UR5UR-$[UR5$)a Return the measure `.number` with the `.numberSuffix` as a string. >>> m = stream.Measure() >>> m.number = 4 >>> m.numberSuffix = 'A' >>> m.measureNumberWithSuffix() '4A' Test that it works as musicxml >>> xml = musicxml.m21ToXml.GeneralObjectExporter().parse(m) >>> print(xml.decode('utf-8')) ... ... Test round tripping: >>> s2 = converter.parseData(xml) >>> print(s2[stream.Measure].first().measureNumberWithSuffix()) 4A Note that we use print here because in parsing the data will become a unicode string. )rrrrs rJmeasureNumberWithSuffixMeasure.measureNumberWithSuffix 3s6:   t{{#d&7&77 7t{{# #rIcBUR5SUR3-$)Nz offset=)rrMrs rJrMeasure._reprInternal/3s!++-(4;;-0HHHrIc >[TU]U5 SH*n[X5(dM[X[ X55 M, g)a Given another Measure, configure all non-element attributes of this Measure with the attributes of the other Measure. No elements will be changed or copied. This method is necessary because Measures, unlike some Streams, have attributes independent of any stored elements. Overrides base.Music21Object.mergeAttributes >>> m1 = stream.Measure() >>> m1.id = 'MyMeasure' >>> m1.clefIsNew = True >>> m1.number = 2 >>> m1.numberSuffix = 'b' >>> m1.layoutWidth = 200 >>> m2 = stream.Measure() >>> m2.mergeAttributes(m1) >>> m2.layoutWidth 200 >>> m2.id 'MyMeasure' >>> m2 Try with not another Measure: >>> m3 = stream.Stream() >>> m3.id = 'hello' >>> m2.mergeAttributes(m3) >>> m2.id 'hello' >>> m2.layoutWidth 200 ) rr r rr rrrr NryrPrTrUrVrWs rJrPMeasure.mergeAttributes33s;L &]Du##GE$89]rIc |U(d[R"U5nOUnUR5nSH nXT;dM XE M UR"S SSS.UD6 URcDUR SSS9nUR SSS9nU(aUSnOUR 5nXl[R"USSS9 [R"USSS 9 URSS 9 U/URQHn [R"U SS 9 M U(dU$g![ [R4a USnNf=f) a This method calls a sequence of Stream methods on this :class:`~music21.stream.Measure` to prepare notation. If `inPlace` is True, this is done in-place; if `inPlace` is False, this returns a modified deep copy. >>> m = stream.Measure() >>> n1 = note.Note('g#') >>> n2 = note.Note('g') >>> m.append([n1, n2]) >>> m.makeNotation(inPlace=True) >>> m.notes[1].pitch.accidental )rrrT)rrFNFrHrr)r*rLrC)rrrr,rMbestTimeSignatureror$r0r-r.r/rr7r2) rrFsubroutineKeywordsrsrkCopy illegalKey contextMeters defaultMetersrvm_or_vs rJr-Measure.makeNotationa3sM4 d#AA$))+MJ$'N TdDTGT ?? "//d>C0EM//e>B0DM"1%*//1B!O33AtTR00DTR D !n188nF  + +FD A%H()=)=>*&q)B*sDD;:D;cdUc URn[URUR- 5$)au Return a floating point value greater than 0 showing the proportion of the bar duration that is filled based on the highest time of all elements. 0.0 is empty, 1.0 is filled; 1.5 specifies of an overflow of half. Bar duration refers to the duration of the Measure as suggested by the `TimeSignature`. This value cannot be determined without a `TimeSignature`. An already-obtained Duration object can be supplied with the `barDuration` optional argument. >>> import copy >>> m = stream.Measure() >>> m.timeSignature = meter.TimeSignature('3/4') >>> n = note.Note() >>> n.quarterLength = 1 >>> m.append(copy.deepcopy(n)) >>> m.barDurationProportion() Fraction(1, 3) >>> m.append(copy.deepcopy(n)) >>> m.barDurationProportion() Fraction(2, 3) >>> m.append(copy.deepcopy(n)) >>> m.barDurationProportion() 1.0 >>> m.append(copy.deepcopy(n)) >>> m.barDurationProportion() Fraction(4, 3) )r.rrr)rr.s rJbarDurationProportionMeasure.barDurationProportion3s2@  **Kd&&)B)BBCCrIcVU(a^/nURH5n[U[R5(d OUR U5 M7 U(aUR USS9 UR nURUS9nUS:a#SU- n[URU-5Ul gg)af Given an incompletely filled Measure, adjust the `paddingLeft` value to represent contained events as shifted to fill the right-most duration of the bar. Calling this method will overwrite any previously set `paddingLeft` value, based on the current TimeSignature-derived `barDuration` attribute. >>> m = stream.Measure() >>> m.timeSignature = meter.TimeSignature('3/4') >>> n = note.Note() >>> n.quarterLength = 1.0 >>> m.append(n) >>> m.padAsAnacrusis() >>> m.paddingLeft 2.0 >>> m.timeSignature = meter.TimeSignature('5/4') >>> m.padAsAnacrusis() >>> m.paddingLeft 4.0 Empty space at the beginning of the measure will not be taken in account: >>> m = stream.Measure() >>> m.timeSignature = meter.TimeSignature('3/4') >>> n = note.Note(type='quarter') >>> m.insert(2.0, n) >>> m.padAsAnacrusis() >>> m.paddingLeft 0.0 If useInitialRests is True, then rests at the beginning of the measure are removed. This is especially useful for formats that don't give a way to specify a pickup measure (such as tinynotation) or software that generates incorrect opening measures. So, to fix the problem before, put a rest at the beginning and call useInitialRests: >>> r = note.Rest(type='half') >>> m.insert(0, r) >>> m.padAsAnacrusis(useInitialRests=True) >>> m.paddingLeft 2.0 And the rest is gone! >>> m.show('text') {0.0} {0.0} Only initial rests count for useInitialRests: >>> m = stream.Measure() >>> m.timeSignature = meter.TimeSignature('3/4') >>> m.append(note.Rest(type='eighth')) >>> m.append(note.Rest(type='eighth')) >>> m.append(note.Note('C4', type='quarter')) >>> m.append(note.Rest(type='eighth')) >>> m.append(note.Note('D4', type='eighth')) >>> m.show('text') {0.0} {0.0} {0.5} {1.0} {2.0} {2.5} >>> m.padAsAnacrusis(useInitialRests=True) >>> m.paddingLeft 1.0 >>> m.show('text') {0.0} {0.0} {1.0} {1.5} T)rs)r.rmN) rrr%rrUr r.r(rrr )ruseGapsuseInitialRests removeListgnr. proportionproportionShifts rJpadAsAnacrusisMeasure.padAsAnacrusis3sZ J((!"dii00!!"%) JT : && //K/H >*nO%k&?&?/&QRD  rIcLURbURnUR$URSSSS9nU(dUR5nUR$USnUR$![Ra# [ R "UR5s$f=f)a Return the bar duration, or the Duration specified by the TimeSignature, regardless of what elements are found in this Measure or the highest time. TimeSignature is found first within the Measure, or within a context based search. To get the duration of the total length of elements, just use the `.duration` property. Here we create a 3/4 measure and "over-stuff" it with five quarter notes. `barDuration` still gives a duration of 3.0, or a dotted quarter note, while `.duration` gives a whole note tied to a quarter. >>> m = stream.Measure() >>> m.timeSignature = meter.TimeSignature('3/4') >>> m.barDuration >>> m.repeatAppend(note.Note(type='quarter'), 5) >>> m.barDuration >>> m.duration The objects returned by `barDuration` and `duration` are full :class:`~music21.duration.Duration` objects, will all the relevant properties: >>> m.barDuration.fullName 'Dotted Half' >>> m.duration.fullName 'Whole tied to Quarter (5 total QL)' TF)rErIrqr) r,rMrrrrrrr.)rrvrs rJr.Measure.barDuration94sJ    )##B~~--D>?sA,,4B#"B#c.[R"U5$)a Given a Measure with elements in it, get a TimeSignature that contains all elements. Calls meter.bestTimeSignature(self) Note: this does not yet accommodate triplets. We create a simple stream that should be in 3/4 >>> s = converter.parse('C4 D4 E8 F8', format='tinyNotation', makeNotation=False) >>> m = stream.Measure() >>> for el in s: ... m.insert(el.offset, el) But there is no TimeSignature! >>> m.show('text') {0.0} {1.0} {2.0} {2.5} So, we get the best Time Signature and put it in the Stream. >>> ts = m.bestTimeSignature() >>> ts >>> m.timeSignature = ts >>> m.show('text') {0.0} {0.0} {1.0} {2.0} {2.5} For further details about complex time signatures, etc. see `meter.bestTimeSignature()` )r$rrs rJrMeasure.bestTimeSignaturet4sT&&t,,rIc/nURHLn[U[R5(dM$UR U5S:XdM;UR U5 O U(dgUS$)Nrlr)rrrrrrUrbarListros rJ_getLeftBarlineMeasure._getLeftBarline4s\A!S[[))%%a(C/NN1%  1: rIc"Sn[U[5(a[R"U5nSUlO UcSnOSUlUR 5nUb UR URU55nU(aURSU5 gg)NTleftFr) rrrrlocationr:r$r%rV)r barlineObjrVoldLeftBarliner(s rJ_setLeftBarlineMeasure._setLeftBarline4s j# & &Z0J"(J   F"(J --/  %88DJJ~67D  KK: & rIa> Get or set the left barline, or the Barline object found at offset zero of the Measure. Can be set either with a string representing barline style or a bar.Barline() object or None. Note that not all bars have barline objects here -- regular barlines don't need them. r3c/nURH5n[U[R5(dM$UR U5 O U(dgUS$r/)rrrrrUr8s rJ_getRightBarlineMeasure._getRightBarline4sK""A!S[[))q!# 1: rIcSn[U[5(a[R"U5nSUlO UcSnOSUlUb6[U[R 5(aUR S;aSUlUR5nUb URURU55nU(aURU5 gg)NTrightF)rNrW) rrrrr>Repeat directionrDr$r%rW)rr?rVoldRightBarliner(s rJ_setRightBarlineMeasure._setRightBarline4s j# & &Z0J")J   F")J   !jSZZ&H&H##6', $//1  &88DJJ78D  OOJ ' rIa Get or set the right barline, or the Barline object found at the offset equal to the bar duration. >>> b = bar.Barline('final') >>> m = stream.Measure() >>> print(m.rightBarline) None >>> m.rightBarline = b >>> m.rightBarline.type 'final' A string can also be used instead: >>> c = converter.parse('tinynotation: 3/8 C8 D E F G A B4.') >>> c.measure(1).rightBarline = 'light-light' >>> c.measure(3).rightBarline = 'light-heavy' >>> #_DOCS_SHOW c.show() .. image:: images/stream_barline_demo.* :width: 211 OMIT_FROM_DOCS .measure currently isn't the same as the original measure. ) r rr r rrr rr r)rrrrsr)rDrErFrGrr2rrTr0rrgrrzrrrPr-r(r1rr.rr:rA leftBarlinerDrKr)rHrrs@rJrwrw2s"F"00MIJ7^`?+J HI;&!I~&P12# # Z $DI+:^#FP"DHgX44t*-X '&?*  K (6,,!  LrIrwc^\rSrSrSr\R rU4SjrSr Sr \ "\ \ SS9r Sr S r\ "\ \S S9rS S S S S S S S.SjrU4SjrSrU=r$)rli5a? A Stream subclass for designating music that is considered a single part. When put into a Score object, Part objects are all collected in the `Score.parts` call. Otherwise, they mostly work like generic Streams. Generally the hierarchy goes: Score > Part > Measure > Voice, but you are not required to stick to this. Part groupings (piano braces, etc.) are found in the :ref:`moduleLayout` module in the :class:`~music21.layout.StaffGroup` Spanner object. OMIT_FROM_DOCS Check that this is True and works for everything before suggesting that it works! May be enclosed in a staff (for instance, 2nd and 3rd trombone on a single staff), may enclose staves (piano treble and piano bass), or may not enclose or be enclosed by a staff (in which case, it assumes that this part fits on one staff and shares it with no other part cB>[TU]"U0UD6 SUlSUlgrs)ryrz _partName_partAbbreviation)rrrrs rJrz Part.__init__05s$ $+(+!%rIc URb UR$SUR;aURS$SnU[RH#nURnUc UR nUcM# O XRS'U$)NrP)rPrr rr~instrumentNamerpnros rJ _getPartNamePart._getPartName55s >> %>> ! DKK ';;{+ +B*//0ZZ:))B> 1 (*KK $IrIcXlgrs)rPrnewNames rJ _setPartNamePart._setPartNameE5s rIa Gets or sets a string representing the name of this part as a whole (not counting instrument changes, etc.). It can be set explicitly (or set on parsing) or it can take its name from the first :class:`~music21.instrument.Instrument` object encountered in the stream (or within a substream), first checking its .partName, then checking its .instrumentName Can also return None. >>> p = stream.Part() >>> p.partName is None True >>> cl = instrument.Clarinet() >>> p.insert(0, cl) >>> p.partName 'Clarinet' >>> p.remove(cl) >>> p.partName is None True >>> p.insert(0, instrument.Flute()) >>> p.partName 'Flute' >>> p.partName = 'Reed 1' >>> p.partName 'Reed 1' Note that changing an instrument's .partName or .instrumentName while it is already in the Stream will not automatically update this unless .coreElementsChanged() is called or this Stream's elements are otherwise altered. This is because the value is cached so that O(n) searches through the Stream do not need to be done every time. r3c URb UR$SUR;aURS$SnU[RH#nURnUc UR nUcM# O XRS'U$)NrQ)rQrr rpartAbbreviationinstrumentAbbreviationrUs rJ_getPartAbbreviationPart._getPartAbbreviationk5s  ! ! -)) ) DKK /;;23 3B*//0'':11B> 1 02KK+ ,IrIcXlgrs)rQrZs rJ_setPartAbbreviationPart._setPartAbbreviation{5s!(rIa Gets or sets a string representing the abbreviated name of this part as a whole (not counting instrument changes, etc.). It can be set explicitly (or set on parsing) or it can take its name from the first :class:`~music21.instrument.Instrument` object encountered in the stream (or within a substream), first checking its .partAbbreviation, then checking its .instrumentAbbreviation Can also return None. >>> p = stream.Part() >>> p.partAbbreviation is None True >>> cl = instrument.Clarinet() >>> p.insert(0, cl) >>> p.partAbbreviation 'Cl' >>> p.remove(cl) >>> p.partAbbreviation is None True >>> p.insert(0, instrument.Flute()) >>> p.partAbbreviation 'Fl' >>> p.partAbbreviation = 'Rd 1' >>> p.partAbbreviation 'Rd 1' Note that changing an instrument's .partAbbreviation or .instrumentAbbreviation while it is already in the Stream will not automatically update this unless .coreElementsChanged() is called or this Stream's elements are otherwise altered. This is because the value is cached so that O(n) searches through the Stream do not need to be done every time. NTF)rrrrFrrrc U(dURS5nOUnUR[5n [R"U UUUUUUS9 U(dU$g)a This overridden method of Stream.makeAccidentals walks measures to arrive at desired values for keyword arguments `tiePitchSet` and `pitchPastMeasure` when calling `makeAccidentals()` on each Measure. 1. Ties across barlines are detected so that accidentals are not unnecessarily reiterated. (`tiePitchSet`) 2. Pitches appearing on the same step in an immediately preceding measure, if foreign to the key signature of that previous measure, are printed with cautionary accidentals in the subsequent measure. (`pitchPastMeasure`) Most of the logic has been factored out to :meth:`~music21.stream.makeNotation.makeAccidentalsInMeasureStream`, which is called after managing the `inPlace` keyword and finding measures to iterate. * Changed in v7: `inPlace` defaults False r)rrrrrrN)rLrrwr-r-) rrrrrFrrrrQ measureStreams rJrPart.makeAccidentals5s_@112CDII!44W= 33 )!5'))E#  rIc >[TU]U5 SH*n[X5(dM[X[ X55 M, g)z Merge relevant attributes from the Other part into this one. Key attributes of difference: partName and partAbbreviation. TODO: doc test )rPrQNrrWs rJrPPart.mergeAttributes5s6 &6Du##GE$897rI)rQrP)rDrErFrGrr2FLATTENrTrzrWr\rr~rardr_rrPrHrrs@rJrlrl5s*"))M &  ! l!9! HF ) 46J!Q! L!%)2h : :rIrlc\rSrSrSrSrg) PartStaffi5z A Part subclass for designating music that is represented on a single staff but may only be one of many staves for a single part. rCNrDrErFrGrrHrCrIrJrmrm5srIrmc \rSrSrSrSrSrSrg)Systemi5aO Totally optional and used only in OMR and Capella: a designation that all the music in this Stream belongs in a single system. The system object has two attributes, systemNumber (which number is it) and systemNumbering which says at what point the numbering of systems resets. It can be either "Score" (default), "Opus", or "Page". rrxrCN)rDrErFrGr systemNumbersystemNumberingrHrCrIrJrprp5sLOrIrpc^\rSrSrSr\R r\SSj5r S\ RS4Sjr \ R\R \R$\R(4\ RS4SjrSSS jjrSSS jjr\SS .SS jj5r\SSS .SSjj5rSSS .SSjjrSSSjjrSrSU4SjjrSrU=r$)rxi 6a A Stream subclass for handling music with more than one Part. Almost totally optional (the largest containing Stream in a piece could be a generic Stream, or a Part, or a Staff). And Scores can be embedded in other Scores (in fact, our original thought was to call this class a Fragment because of this possibility of continuous embedding; though it's probably better to embed a Score in an Opus), but we figure that many people will like calling the largest container a Score and that this will become a standard. c>UR[5nSUlU$)aQ Return all :class:`~music21.stream.Part` objects in a :class:`~music21.stream.Score`. It filters out all other things that might be in a Score object, such as Metadata returning just the Parts. >>> s = corpus.parse('bach/bwv66.6') >>> s.parts >>> len(s.parts) 4 rN)rrlr)r partIterators rJrN Score.parts6s"7;6M6Md6S *1 'rIrFc vUR5nURU5 URH(nURUUUUUS9nUR SU5 M* U(a'UR n U Hn UR SU 5 M XfR lXR lSUR l U$)a This method overrides the :meth:`~music21.stream.Stream.measures` method on Stream. This creates a new Score stream that has the same measure range for all Parts. The `collect` argument is a list of classes that will be collected; see Stream.measures() >>> s = corpus.parse('bwv66.6') >>> post = s.measures(3, 5) # range is inclusive, i.e., [3, 5] >>> len(post.parts) 4 >>> len(post.parts[0].getElementsByClass(stream.Measure)) 3 >>> len(post.parts[1].getElementsByClass(stream.Measure)) 3 rrr) rrPrNrrVr:rrMrNrO) rrrrrrrr- measuredPartspStreamr:s rJrScore.measures*6s0~~ T"A::k&/.55C8I &KL KK< ( }}H Ar""&!%!+ rIc US:aSnUnUnU(a US- nUS:XaSnUR5nURU5 UR[5H(nUR UUUUUS9n UR SU 5 M* U(a'UR n U Hn UR SU 5 M XwRlXRl SURl U$)a Given a measure number (or measure index, if indicesNotNumbers is True) return another Score object which contains multiple parts but each of which has only a single :class:`~music21.stream.Measure` object if the Measure number exists, otherwise returns a score with parts that are empty. This method overrides the :meth:`~music21.stream.Stream.measure` method on Stream to allow for finding a single "measure slice" within parts: >>> bachIn = corpus.parse('bach/bwv324.xml') >>> excerpt = bachIn.measure(2) >>> excerpt >>> len(excerpt.parts) 4 >>> excerpt.parts[0].show('text') {0.0} {0.0} {0.0} {0.0} {0.0} {0.0} {1.0} {2.0} {3.0} Note that the parts created have all the meta-information outside the measure unless this information appears in the measure itself at the beginning: >>> bachIn.measure(1).parts[0].show('text') {0.0} {0.0} {0.0} {0.0} {0.0} {0.0} {0.0} {2.0} This way the original measure objects can be returned without being altered. The final measure slice of the piece can be obtained with index -1. Example: quickly get the last chord of the piece, without needing to run .chordify() on the whole piece: >>> excerpt = bachIn.measure(-1) >>> excerptChords = excerpt.chordify() >>> excerptChords.show('text') {0.0} {0.0} {0.0} {0.0} {0.0} {0.0} {4.0} >>> lastChord = excerptChords[chord.Chord].last() >>> lastChord Note that we still do a .getElementsByClass(chord.Chord) since many pieces end with nothing but a rest. rTrmrNrr) rrPrrlrrVr:rrMrNrO) rrrrrrrrr-mStreamryr:s rJr Score.measure[6sH 1  $ *(   ! !R'#' ~~ T"((.Ajj!3!1)00>3D !FG KK7 #/ }}H Ar""&!%!* rITcURSS9nURU5 UR5R[5H:n[ R "U5nURURU5U5 M< UR[5H"nURSURSS95 M$ URnURSS9HlnURR5(dM$URR nUcM?URR"S:XdM[UR%Xs5 Mn U$)a Expand all repeats, as well as all repeat indications given by text expressions such as D.C. al Segno. This method always returns a new Stream, with deepcopies of all contained elements at all level. Note that copySpanners is ignored here, as they are always copied. rfrrF)rcrr)rrPrrrlrrrVrrrfrrYr)rrrNrOr)rrcrrorer-rrNs rJrfScore.expandRepeats6s@ T"2248A==#D KK**1-t 49((.A KK1???> ?/ ** %0Aww%%'',,%!,,*=*=*O!77B 1  rIcbUR5RnU(d[RX5$0nUHNnURU5nUH4nXc;a/X6'XVH nXsU;dM X6R U5 M" M6 MP [ [ UR5SS95nU$)a This Score method overrides the :meth:`~music21.stream.Stream.measureOffsetMap` method of Stream. This creates a map based on all contained Parts in this Score. Measures found in multiple Parts with the same offset will be appended to the same list. If no parts are found in the score, then the normal :meth:`~music21.stream.Stream.measureOffsetMap` routine is called. This method is smart and does not assume that all Parts have measures with identical offsets. c US$r/rCrs rJr(Score.measureOffsetMap..7r rIr!)rrNrQr%rUrrr!) rrhrNr"r- mapPartialrrr$s rJr%Score.measureOffsetMap6s" !!**4A A9; A++O %%' rIc 4SSKJn /n/n[U[5(aUn[ UR 5HRupX-S:Xa/nUR U 5 OUR U 5 X-US- :XdM?UR U5 /nMT U(aUR U5 O[R"U5(a[R"[[[-U5nUHqn /n[U [5(dUR UR U 5 O'U H!n UR UR U 5 M# UR U5 Ms O[SU35eURSS9n URU lUGHn[U5S:XaU(dU R!SUS5 M1[#5n [ U5GHupU R%5(aSnOSn[ U R'[(55GH+unnU(d,[)5nUR+U5 UR-US S 9 OU R'[(5Un[/5nUUlUR'[2R4UR6/5H\nU(a1[U[2R85(aUS -S:XaS OS UlUR!UR=U5U5 M^ UR!SU5 U(aGM U R!UR=U 5U5 GM. U R>H$nU R!UR=U 5U5 M& GM U R!SU 5 Sn GM U $)aW Given a multi-part :class:`~music21.stream.Score`, return a new Score that combines parts into voices. The `voiceAllocation` parameter sets the maximum number of voices per Part. The `permitOneVoicePerPart` parameter, if True, will encode a single voice inside a single Part, rather than leaving it as a single Part alone, with no internal voices. >>> s = corpus.parse('bwv66.6') >>> len(s.flatten().notes) 165 >>> post = s.partsToVoices(voiceAllocation=4) >>> len(post.parts) 1 >>> len(post.parts.first().getElementsByClass(stream.Measure).first().voices) 4 >>> len(post.flatten().notes) 165 rr4rmz"incorrect voiceAllocation format: partsToVoicesrTFr>r?rupdownN) r?r5rrrrNrUrrrrrrorr#rrVrlr,rrwrPrjr,rr%r r(rrrr:)rvoiceAllocationpermitOneVoicePerPartsetStemsr5subbundle voicesPerPartpIndexr-rpartIdrpActiver,mIndexrrArror:s rJrScore.partsToVoicesZ7s: $ os + ++M&tzz2 )Q.CJJqMJJqM)]Q->>MM#&C3 c"    / /ffT$s(^_EO(!%..JJtzz%01"' 4::f#56#( c")"$FFW"XY Y OO_O =]] C3x1}%:CF#fG&s^ &&(("&K"'K!*1+?+?+H!IIFA'")) //2--aBP-Q#*"<"U(aUnOURS5nUR5 UR5(a@URS5HnUR"SUUSUS.UD6 M UR 5 O[ [U]"SUUSUS.UD6 U(agU$)a@ This method overrides the makeNotation method on Stream, such that a Score object with one or more Parts or Streams that may not contain well-formed notation may be transformed and replaced by well-formed notation. If `inPlace` is True, this is done in-place; if `inPlace` is False, this returns a modified deep copy. r-rQTr(NrC)rLrr*rr-rryrx) rrrrFrr rrrs rJr-Score.makeNotation7s$ L44^DL..0  " " $ $!44X>5;4H'+(05"4 5?  , , . % 3 J I]<@=E J7I  J  rIrC)rqziterator.StreamIterator[Part]r)rrxrcrrqrxrr)rrxrCrrFrrqr)rrxrCrrFrrqrx)rrxrCrrFrrqz Score | None)rFT)rzint | list[list | int])NNFF)rDrErFrGrr2 ELEMENTS_ONLYrTrrNrrrrrr$r*r rr"r4rrfr%r rvrrr-rHrrs@rJrxrx 6s "//M (Q . 2 2#( .fE$7$79N9NPSP`P`a-11"' dL!JLX  H   4  F   !     $)    "      ??? ?  ?D=>,1#@'9@D &! 4 4 rIrxcl\rSrSrSr\R rSrSr Sr \ S5r Sr S S jrS S jrS rg) rfi$8z A Stream subclass for handling multi-work music encodings. Many ABC files, for example, define multiple works or parts within a single file. Opus objects can contain multiple Score objects, or even other Opus objects! c/nUR[5H(nURURR5 M* U$)z Return a list of all numbers defined in this Opus. >>> o = corpus.parse('josquin/oVenusBant') >>> o.getNumbers() ['1', '2', '3'] )rrxrUr#r)rrrs rJ getNumbersOpus.getNumbers/8s9((/A KK )) *0 rIcUR[5H,nURRUS5up4U(dM*Us $ g)aX Get Score objects from this Stream by number. Performs title search using the :meth:`~music21.metadata.Metadata.search` method, and returns the first result. >>> o = corpus.parse('josquin/oVenusBant') >>> o.getNumbers() ['1', '2', '3'] >>> s = o.getScoreByNumber(2) >>> s.metadata.title 'O Venus bant' >>> s.metadata.alternativeTitle 'Tenor' rNrrxr#search)r opusMatchrr= unused_fields rJgetScoreByNumberOpus.getScoreByNumber<8s<"((/A"#**"3"3Ix"H Eu0rIcUR[5H,nURRUS5up4U(dM*Us $ g)a Get Score objects from this Stream by a title. Performs title search using the :meth:`~music21.metadata.Metadata.search` method, and returns the first result. >>> o = corpus.parse('essenFolksong/erk5') >>> s = o.getScoreByTitle('Vrienden, kommt alle gaere') >>> s.metadata.title 'Vrienden, kommt alle gaere' Regular expressions work fine >>> s = o.getScoreByTitle('(.*)kommt(.*)') >>> s.metadata.title 'Vrienden, kommt alle gaere' titleNr)r titleMatchrr=rs rJgetScoreByTitleOpus.getScoreByTitleS8s<$((/A"#**"3"3J"H Eu0rIc$URS5$)zB Return all :class:`~music21.stream.Score` objects in an iterator rxr6rs rJr Opus.scoresj8s &&w//rIc[5n[R"5nURHnURR 5R 5nURSU5 URnUcMNURbURcURUlURcMURbMURUl M URSU5 U$)aI Some Opus objects represent numerous scores that are individual parts of the same work. This method will treat each contained Score as a Part, merging and returning a single Score with merged Metadata. >>> o = corpus.parse('josquin/milleRegrets') >>> s = o.mergeScores() >>> s.metadata.title 'Mille regrets' >>> len(s.parts) 4 r) rxr#rrrNrr-rVrcomposer)rrmdNewrr-mds rJ mergeScoresOpus.mergeScoresr8sw!!#A ,,.A KK1 B~88'EKK,?"$((EK;;*u~~/E%'[[EN Au rINc JUR(dgUbSU;a[R"XU40UD6$[R"5(a[R"XU40UD6$SnUc>Uc S[ S-nO[R "U5upe[ RUSS9nSn[U[5(a[R"U5nURnURnSRUR5n /n [ R""[ R$"['UR555n [)UR5Hup[ R""[ R$"U S-55nX- nS U-nUS -U-[U S -5-U -nUU- nU R"SUUS .UD6n[ R+S U SU35 U R-U5 M U(a[.R0"U5 U (aU S$S$)a Displays an object in a format provided by the `fmt` argument or, if not provided, the format set in the user's Environment. This method overrides the behavior specified in :class:`~music21.base.Music21Object` for all formats besides explicit lily.x calls. Individual files are written for each score; returns the last file written. >>> sc1 = stream.Score() >>> sc2 = stream.Score() >>> o = stream.Opus() >>> o.append([sc1, sc2]) #_DOCS_SHOW >>> o.write() #_DOCS_SHOW PosixPath('/some/temp/path-2.xml') NlilyF. writeFormat)r returnPathlibTr0r<rmrz Component z written to rrC)rrQrrrr findFormat getTempFilerrpathlibPathparentstemrssuffixesmathceillog10rr printDebugrUosr )rrrrdeleter unused_formatfpParentfpStemfpSuffixrplacesRequiredrrplacesConsumed zeroesNeededzeroes scoreNamefpToUse fpReturneds rJr Opus.write8s&{{ ?v}<<2:: :  % % ' '<<2:: : :{|M::(.(9(9#(>% ))u)MBF b#  b!B9988BKK(4::c$++.>#?@dkk*DA!YYtzz!a%'89N):L<'F v-AE :XEI*GASWAAJ  # #j< |$L M KK #+  IIbMtBx)T)rIc UbSU;a[R"XU40UD6$[R"5(a[R"XU40UD6$URHnUR"SXS.UD6 M g)z Show an Opus file. This method overrides the behavior specified in :class:`~music21.base.Music21Object` for all formats besides explicit lily.x calls. or when running under Jupyter notebook. NrrrC)rQrrrr)rrrrrs rJr Opus.show8sl ?v};;t#:: :  % % ' ';;t#:: :[[43484!rIrCrF)rDrErFrGrr2rrTrrrrrrrrrHrCrIrJrfrf$8sH "//M ..00!H;*z5rIrfc~^\rSrSrSrS SS.SU4SjjjjrSrSrSS jrS SS .SU4S jjjr Sr U=r $)SpannerStoragei8a For advanced use. This Stream subclass is only used inside a Spanner object to provide object storage of connected elements (things the Spanner spans). This subclass name can be used to search in an object's .sites and find any and all locations that are SpannerStorage objects. A `client` keyword argument must be provided by the Spanner in creation. >>> stream.SpannerStorage(client=spanner.Slur()) * Changed in v8: spannerParent is renamed client. N)rMc h>UcSSKJn UR"5nX l[TU]"U40UD6 g)Nrr4)r?r5r(rMryrz)rrrMrr5rs rJrzSpannerStorage.__init__8s. > '__&F'-  3(3rIcd[UR5nSURSUR3$)Nzfor r)rrMrErF)rtcs rJrSpannerStorage._reprInternal9s, $++ bmm_Aboo%677rIcg)z( Never set activeSite to spannerStorage NrCrs rJr!SpannerStorage.coreSelfActiveSite 9s rITc[S5e)Nz#SpannerStorage cannot store at end.)ro)rrLrs rJrgSpannerStorage.coreStoreAtEnd9sCDDrIFrcP>X ;aURU5 g[TU] XX4S9 g)z Overrides :meth:`~music21.stream.Stream.replace` in order to check first whether `replacement` already exists in `self`. If so, delete `target` from `self` and return; otherwise call the superclass method. * New in v7. Nr)r ryr)rrrrYrrs rJrSpannerStorage.replace9s*   KK   WTrIrs)rMzspanner.Spanner | Nonerr) rDrErFrGrrzrrrgrrHrrs@rJrr8sp 4T448  E!&#' U*U/U U ! U -1 UUrIrc\rSrSrSrSrg)VariantStoragei*9a For advanced use. This Stream subclass is only used inside a Variant object to provide object storage of connected elements (things the Variant defines). This subclass name can be used to search in an object's .sites and find any and all locations that are VariantStorage objects. It also ensures that they are pickled properly as Streams on a non-Stream object. * Changed in v8: variantParent is removed. Never used. rCNrnrCrIrJrr*9s rIrc\rSrSrSrSrSrg)Testi<9z3 Note: most Stream tests are found in stream.tests c2SSKJn U"U[55 g)Nr) testCopyAll)music21.test.commonTestrglobals)rrs rJtestCopyAndDeepcopyTest.testCopyAndDeepcopy@9s7D')$rIrCN)rDrErFrGrrrHrCrIrJrr<9s %rIr__main__)er __future__r collectionsrrrcollections.abcrrr r fractionsr rorr rrrtypingrr unittestrr?r rrmusic21.common.enumsrrmusic21.common.numberToolsrmusic21.common.typesrrrrrrrrrrrrrr r"r#r$r%r&r'r(r)r*r+music21.streamr,r-r.r/r0music21.stream.enumsr1r2r3rr5 Environmentrror}TypeVarr7Lyricrr8r9 UserWarningrArK StreamCoreGenericrQr,rwrlrmrprxrfrrTestCaserrrDmainTestrCrIrJrs#66::    >- ''#"QQ??&&x0 ..'@@IIcNZZ_T*>%??"H  {  {$R S PHT__aii 3PHjP F "D  fD  NK:6K:Z6 V W FW t}56}5J>UV>UBV$%8  %gtUD%ni9  z TrI