3jQzdZddlmZddlmZddlZddlZddlmZddlm Z ddlm Z ddl m Z dd l mZdd l mZe j"d ZeZe ZGd d e j*ZGddej.ZGddeZGddej4ZeefZedk(rddlZej<eyy)z Tools for grouping elements, timespans, and especially pitched elements into kinds of searchable tree organized by start and stop offsets and other positions. ) annotations)infN)common) environment) exceptions21) SortTuple)core)nodez tree.treesc eZdZy)ElementTreeExceptionN)__name__ __module__ __qualname__?/DATA/.local/lib/python3.12/site-packages/music21/tree/trees.pyr r &srr c eZdZUdZded<ej ZdZdfd Z dZ dZ dZ d Z d Zd Zd Zd ZdZd dZd!dZdZdZdZdZfdZd!dZdZd!dZdZdZdZe dZ!e!jDdZ!e dZ#xZ$S)" ElementTreea A data structure for efficiently storing a score: flat or recursed or normal. This data structure has no connection to the XML ElementTree. This data structure stores ElementNodes: objects which implement both a `position` and `endTime` property. It provides fast lookups of such objects. >>> et = tree.trees.ElementTree() >>> et >>> s = stream.Stream() >>> for i in range(100): ... n = note.Note() ... n.duration.quarterLength = 2.0 ... s.insert(i * 2, n) >>> for n in s: ... et.insert(n) >>> et to 200.0)> >>> et.rootNode Indices:(l:0 *63* r:100) Payload:> >>> n2 = s[-1] These operations are very fast >>> et.index(n2, n2.sortTuple()) 99 Get a position after a certain position: >>> st = s[40].sortTuple() >>> st SortTuple(atEnd=0, offset=80.0, priority=0, classSortOrder=20, isNotGrace=1, insertIndex=...) >>> st2 = et.getPositionAfter(st) >>> st2.shortRepr() '82.0 <0.20...>' >>> st2.offset 82.0 >>> st3 = et.getPositionAfter(5.0) >>> st3.offset 6.0 >>> et.getPositionAfter(4.0).offset 6.0 znodeModule.ElementNode | NonerootNode)_source parentTreesct|tj|_d|_|r||j |||_yN)super__init__weakrefWeakSetrrinsertsource)selfelementsr __class__s rrzElementTree.__init__js? "??, , KK ! rc|j}|j|}|j|}||j|ury|D]}||usyy)a Is true when the ElementTree contains the object within it If element.sortTuple(self.source) returns the right information, it's a fast O(log n) search. If not his is an O(n log n) operation in python not C, so slow. >>> score = tree.examples.makeExampleScore() >>> scoreTree = score.asTree(flatten=True) >>> lastNote = score.flatten().notes[-1] >>> lastNote in scoreTree True >>> n = note.Note('E--') >>> n in scoreTree False >>> s = stream.Stream(id='tinyStream') >>> s.insert(0, n) >>> st = s.asTree(flatten=False) >>> n in st True TF)r sortTuplegetNodeByPositionpayload)r elementssourcePositionnodeAtPositionpls r __contains__zElementTree.__contains__tsa. KK **1-//?  %%%0BW}rc ||uS)a) Two ElementTrees are equal only if they are the same object. >>> et1 = tree.trees.ElementTree() >>> et2 = tree.trees.ElementTree() >>> et3 = et1 >>> et1 == et2 False >>> et1 == et3 True >>> et2 != et1 True rr exprs r__eq__zElementTree.__eq__st|rc |j|}||St|ts |jS|Dcgc]}|jc}S#t$rYywxYwcc}w)a_ Gets elements by integer index or slice. This is pretty fast in computational time (O(log n)), but it's O(log n) in Python while normal list slicing is O(1) in C, so don't use trees for __getitem__ searching if you don't have to. >>> score = tree.examples.makeExampleScore() >>> scoreTree = score.asTree(flatten=True) >>> scoreTree to 8.0) > >>> scoreTree[0] >>> scoreTree[-1] >>> scoreTree[2000] is None True Slices work >>> scoreTree[2:5] [, , ] >>> scoreTree[-6:-3] [, , ] >>> scoreTree[-100:-200] [] >>> for x in scoreTree[:]: ... x ... These should all be the same as the flat version: >>> scoreFlat = score.flatten() >>> for i in (0, -1, 10): ... if scoreFlat[i] is not scoreTree[i]: ... print('false!') >>> for i, j in ((2, 5), (-6, -3)): ... sfSlice = scoreFlat[i:j] ... for n in range(i, j): ... sliceOffset = n - i ... if sfSlice[sliceOffset] is not scoreFlat[n]: ... print('false!') N)getNodeByIndex IndexError isinstancelistr&)r inodeOrNodeListns r __getitem__zElementTree.__getitem__smh !003N  !! !ND1!)) )'56~!AII~6 6  7sA A AAc@tt|t|fSr)hashtypeidr s r__hash__zElementTree.__hash__sT$ZD*++rcH|jy|jjS)a Gets the length of the ElementTree, i.e., the number of elements enclosed. This is a very very fast O(1). >>> score = tree.examples.makeExampleScore() >>> scoreTree = score.asTree(flatten=True) >>> len(scoreTree) 20 Works well on OffsetTrees also, which are more complex, because they can have multiple elements per Node. >>> offTree = tree.trees.OffsetTree() >>> len(offTree) 0 >>> tsList = [(0, 2), (0, 9), (1, 1), (2, 3), (3, 4), ... (4, 9), (5, 6), (5, 8), (6, 8), (7, 7)] >>> noteList = [note.Note() for _ in tsList] >>> for i,n in enumerate(noteList): ... n.offset, n.quarterLength = tsList[i] >>> offTree.insert(noteList) >>> len(offTree) 10 >>> len(offTree) == len(noteList) True >>> offTree.removeElements(noteList) >>> len(offTree) 0 r)rsubtreeElementsStopIndexr>s r__len__zElementTree.__len__s"@ == }}555rc `|j}|j}|j}t|dr|j }t|dr|j }t |j }dtt|zdz}d|d|d|d|d }||d|z }|d z }|S) N shortRepr{}< z (z to )>) rlowestPositionendTimehasattrrDr<r strlen)r oposrL className lenEnclosedmsgs r__repr__zElementTree.__repr__s KK!!#,, 3 $--/C 7K ('')GJ'' CD N*S0 )Ak]"SEgYa@ = Qqe9 C s  rc Ft|tr4|j|}|dt|}t |||_yt|t rt|tsd|d|d}t ||j|jz |jz }|t|k7r!|d|d|dt|}t |tt|j|j|jD] \}}||||<yd |}t |) a Sets elements at index `i` to `new`, but keeping the old position of the element there. (This is different from OffsetTrees, where things can move around). >>> score = tree.examples.makeExampleScore() >>> scoreTree = score.asTree(flatten=True) >>> n = scoreTree[10] >>> n >>> scoreTree.getNodeByIndex(10) Indices:(l:10 *10* r:11) Payload:> >>> scoreTree[10] = note.Note('F#') >>> scoreTree[10] >>> scoreTree.getNodeByIndex(10) Indices:(l:10 *10* r:11) Payload:> >>> scoreTree[10:13] [, , ] >>> scoreTree[10:14:2] = [note.Note('E#'), note.Note('F-')] >>> scoreTree[10:13] [, , ] NzIndex must be less than zIf z is a slice, then z must be a listz is a slice of len z, so z cannot have len z$Indices must be ints or slices, got ) r4intr2rO TypeErrorr&slicer5stopstartstep enumeraterange)r r6newr8messagesliceLenj sliceIters r __setitem__zElementTree.__setitem__'s 8 a ##A&Ay4SYK@((AI 5 !c4(s"4SEI(((AFF2H3s8#C28*E#FWX[\_X`Wab(( )%*H I 9"%a&Y!J=QC@GG$ $rcg}|jt||D]>}t|j}|Dcgc]}d|z }}|j |@dj |}|Scc}w)a Print the whole contents of the tree. Slow: O(n log n) time, but it's just for debugging >>> score = tree.examples.makeExampleScore() >>> scoreTree = score.asTree(flatten=True) >>> print(scoreTree) to 8.0) > PartA: : PartB: :   )appendreprrN splitlinesextendjoin)r resultx subResults r__str__zElementTree.__str__Wss> d4j!AA))+I+459a9I5 MM) $6" 6s A3c#RK|jD]}|jyw)a Iterates through all the nodes in the offset tree and returns each node's payload Not an especially efficient way of using this beautiful tree object! But useful for debugging or a final iteration for conversion. >>> score = tree.examples.makeExampleScore() >>> scoreTree = score.asTree(flatten=True) >>> for x in scoreTree: ... print(x) PartA: : PartB: : ... N iterNodesr&)r r s r__iter__zElementTree.__iter__s#,NN$D,, %s%'c|j4|jj|jj|j|k7s|j|k7r|j ||yy)a runs updateIndices and updateEndTimes on the rootNode and if the offset or endTime of the tree differs from `initialPosition` or `initialEndTime` will run _updateParents() as well. Called by insert() and remove(). N)visitedParents)r updateIndicesupdateEndTimesrKrL_updateParents)r initialPositioninitialEndTimervs r _updateNodeszElementTree._updateNodessc == $ MM ' ' ) MM ( ( *    !_ 4<<>1     O2rc| t}|jD]1}|||vr |j||j||ty)zt Tells all parents that the position of this tree has changed. Not currently used. N)setradd_removeElementAtPositionNotImplementedError)r oldPositionrvparents rryzElementTree._updateParentssT  ! UN&&F~>!9   v &  + +D+ >% % 'rcV|j|}|yt|jtrH||jvr|jj ||js|j |yy|j|urd|_|j|j |yy)z removes an element or ElementTree from a position (either its current .offset or its oldPosition) without updating the indices, endTimes, etc. N)r%r4r&r5remove removeNode)r r'positionr s rrz$ElementTree._removeElementAtPositions %%h/ <  dllD )$,,& ##G,<<) ||w&# ||#)$rc8|j|jSa A quick but dirty method for getting the likely position (or offset) of an element within the elementTree from the element itself. Such as calling el.getOffsetBySite(tree.source) or something like that. Pulled out for subclassing )r$rr els rgetPositionFromElementUnsafez(ElementTree.getPositionFromElementUnsafes||DKK((rcJdfd |j|d|_y)a This method assumes that the current tree is empty (or will be wiped) and that listOfTuples is a non-empty list where the first element is a unique position to insert, and the second is the complete payload for that node, and that the positions are strictly increasing in order. This is about an order of magnitude faster (3ms vs 21ms for 1000 items; 31 vs. 30ms for 10,000 items) than running createNodeAtPosition() for each element in a list if it is already sorted. Thus, it should be used when converting a Stream where .isSorted is True into a tree. If any of the conditions is not true, expect to get a dangerously badly sorted tree that will be useless. >>> bFlat = corpus.parse('bwv66.6').flatten() >>> bFlat.isSorted True >>> listOfTuples = [(e.sortTuple(bFlat), e) for e in bFlat] >>> listOfTuples[14] (SortTuple(atEnd=0, offset=0.0, priority=0, ...), ) >>> et = tree.trees.ElementTree() >>> et.rootNode is None True >>> et.populateFromSortedList(listOfTuples) >>> et.rootNode Indices:(l:0 *99* r:199) Payload:> >>> n = et.rootNode >>> while n is not None: ... print(n) ... n = n.leftChild Indices:(l:0 *99* r:199) Payload:> Indices:(l:0 *49* r:99) Payload:> Indices:(l:0 *24* r:49) Payload:> Indices:(l:0 *12* r:24) Payload:> Indices:(l:0 *6* r:12) Payload:> Indices:(l:0 *3* r:6) Payload:> Indices:(l:0 *1* r:3) Payload:> Indices:(l:0 *0* r:1) Payload:> >>> n = et.rootNode >>> while n is not None: ... print(n) ... n = n.rightChild Indices:(l:0 *99* r:199) Payload:> Indices:(l:100 *149* r:199) Payload:> Indices:(l:150 *174* r:199) Payload:> Indices:(l:175 *187* r:199) Payload:> Indices:(l:188 *193* r:199) Payload:> Indices:(l:194 *196* r:199) Payload:> Indices:(l:197 *198* r:199) Payload:> ct|}|dk(ry|dz}||}|d|d}||z|_||_||z|_|d|||_||dzd||zdz|_|j |S)z- Divide and conquer. rN)rOpayloadElementIndexsubtreeElementsStartIndexrA leftChild rightChildupdate)subListOfTuplesglobalStartOffsetlenLmidpointmidtupler8 NodeClassrecurses rrz3ElementTree.populateFromSortedList..recurse(s'DqyqyH&x0H(1+x{3A$5$@A !*;A '):T)AA &!/)8"<"35AK"?8a<=#A#4x#?!#CEAL HHJHrrN)returnzcore.AVLNode | None) nodeClassr)r listOfTuplesrrs @@rpopulateFromSortedListz"ElementTree.populateFromSortedLists"L (NN  a0 rcfdfdt|trg|jt|dkr|jj|z}|dks|jj|krt|j|St|t rQ|jgS|j |jj}|d|d}}|j||Std|)a Get a node whose element is at a particular index (not position). Works with slices too See __getitem__ for caveats about speed. >>> score = tree.examples.makeExampleScore() >>> scoreTree = score.asTree(flatten=True) >>> scoreTree to 8.0) > >>> scoreTree.getNodeByIndex(0) Indices:(l:0 *0* r:2) Payload:> >>> scoreTree.getNodeByIndex(-1) Indices:(l:19 *19* r:20) Payload:> >>> scoreTree.getNodeByIndex(slice(2, 5)) [ Indices:(l:0 *2* r:4) Payload:>, Indices:(l:3 *3* r:4) Payload:>, Indices:(l:0 *4* r:8) Payload:>] >>> scoreTree.getNodeByIndex(slice(-6, -3)) [ Indices:(l:9 *14* r:20) Payload:>, Indices:(l:15 *15* r:17) Payload:>, Indices:(l:16 *16* r:17) Payload:>] >>> scoreTree.getNodeByIndex(slice(-100, -200)) [] c|j|k(r|S|jr"||jkr|j|S|jr#|j|kr|j|Syy)zB Return the node element at a given index N)rrrr indexrecurseByIndexs rrz2ElementTree.getNodeByIndex..recurseByIndex`sj''50 ED,D,D$D%dnne<<T%=%=%F%doou==&Grc^g}||S||jkr/|jr#|j|j||||jcxkr|krnn|j||j|kr/|jr#|j|j|||S)zo Return a slice of the nodes (plural) whose indices are between start <= index < stop. )rrrkrhr)r r[rZrmrecurseBySlices rrz2ElementTree.getNodeByIndex..recurseBySliceksF| t///DNN nT^^UDIJ00747 d#''$.4?? nT__eTJKMrrr(Indices must be integers or slices, got r4rWrr3rArYindicesrXr r6r outer_start outer_stoprrs @@rr2zElementTree.getNodeByIndex?sB >  a }}$  1uMM::Q>1u >>!C  !$--3 3 5 !}}$ ii F FGG&-aj'!*K!$--jI IFqcJK Krc#<Kt|D]}|yw)a{ Identical to the iterating on a core.AVLTree -- yields each node in order Slow: O(n log n) time so don't make this your main thing. >>> score = tree.examples.makeExampleScore() >>> scoreTree = score.asTree(flatten=True) >>> scoreTree to 8.0) > >>> for node in scoreTree.iterNodes(): ... print(node) Indices:(l:0 *0* r:2) Payload:> Indices:(l:1 *1* r:2) Payload:> Indices:(l:0 *2* r:4) Payload:> Indices:(l:3 *3* r:4) Payload:> Indices:(l:0 *4* r:8) Payload:> Indices:(l:5 *5* r:6) Payload:> Indices:(l:5 *6* r:8) Payload:> Indices:(l:7 *7* r:8) Payload:> Indices:(l:0 *8* r:20) Payload:> Indices:(l:9 *9* r:11) Payload:> ... Indices:(l:15 *17* r:20) Payload:> Indices:(l:18 *18* r:20) Payload:> Indices:(l:19 *19* r:20) Payload:> N)rrt)r r8r"s rrszElementTree.iterNodess!J!#AG$sc||j|}|j|}||j|ur,t|D] \}}||us |cSt |d|d|j S)a Gets index of `element` in tree. position could be none. If the element is in the original score, then it should be very fast (O(log n)) >>> score = tree.examples.makeExampleScore() >>> scoreFlat = score.flatten() >>> n = scoreFlat.notes[-1] >>> flatTree = scoreFlat.asTree() >>> flatTree.index(n) 17 If it's not in the original stream, then it should be slower than doing it on a stream (O (n log n)). >>> scoreTree = score.asTree(flatten=True) >>> n = score.flatten().notes[-1] >>> scoreTree.index(n) 17 And if it's nowhere at all, you get a ValueError! >>> scoreTree.index(note.Note('F-')) Traceback (most recent call last): ValueError: not in Tree at position SortTuple(atEnd=0, offset=0.0, priority=0, ...). z not in Tree at position .)rr%r&r] ValueErrorr)r r'rr r6r8s rrzElementTree.indexs<  88AH%%h/ <4<>> n = note.Note() >>> ot = tree.trees.OffsetTree() >>> ot >>> ot.insert(10.0, n) >>> ot >>> n2 = note.Note('D') >>> n2.offset = 20 >>> n3 = note.Note('E') >>> n3.offset = 5 >>> ot.insert([n2, n3]) >>> ot NrD) rKrLr isListLikerMr4r~ frozensetrr] _insertCorer|) r positionsOrElementsr!rzr{ positionsr6rrQs rrzElementTree.inserts(--/  *HI+I$$Y/79k3R&K !!(+"8c9-=> zH  66x@Ix(EArA,C   S" %) />:rcV|j||j|}||_y) Inserts a single element at an offset, creating new nodes as necessary, but does not updateIndices or updateEndTimes or updateParents N)createNodeAtPositionr%r&r rrr s rrzElementTree._insertCores) !!(+%%h/ rcVfd|j|jStS)a! Gets the latest position in this tree. Keep as a property, because a similar property exists on streams. >>> score = corpus.parse('bwv66.6') >>> tsTree = score.asTimespans(classList=(note.Note,)) >>> tsTree.highestPosition() 35.0 cX|j|jS|jSr)rrr rs rrz,ElementTree.highestPosition..recurse's&*t//}}$rrNEGATIVE_INFINITYr rs @rhighestPositionzElementTree.highestPositions) % == $4==) )$ $rcVfd|j|jStS)a7 Gets the earliest position in this tree. >>> score = tree.examples.makeExampleScore() >>> elTree = score.asTree() >>> elTree.lowestPosition().shortRepr() '0.0 <0.-20...>' >>> tsTree = score.asTimespans() >>> tsTree.lowestPosition() 0.0 cX|j|jS|jSr)rrrs rrz+ElementTree.lowestPosition..recurse?s&~~)t~~..== rrrs @rrKzElementTree.lowestPosition2s) ! == $4==) )$ $rc@tj|jS)aJ the original stream. (stored as a weakref but returned unwrapped) >>> example = tree.examples.makeExampleScore() >>> eTree = example.asTree() >>> eTree.source is example True >>> s = stream.Stream() >>> eTree.source = s >>> eTree.source is s True )r unwrapWeakrefrr>s rrzElementTree.sourceJs##DLL11rc8tj||_yr)r wrapWeakrefrr.s rrzElementTree.source[s))$/ rcR|j|jjStS)a Gets the latest stop position in this element-tree. This is cast as a property so that it can be used like a TimeSpan in a TimeSpanTree >>> score = corpus.parse('bwv66.6') >>> tsTree = score.asTree() >>> tsTree.endTime 36.0 Returns infinity if no elements exist: >>> et = tree.trees.ElementTree() >>> et.endTime inf )r endTimeHighINFINITYr>s rrLzElementTree.endTime`s#$ == $==,, ,r)NN)NNNr)%r rr__doc____annotations__ nodeModule ElementNoder __slots__rr,r0r9r?rBrUrdrprtr|ryrrrr2rsrrrrrrKpropertyrsetterrL __classcell__)r"s@rrr,s1f*)&&II %N">7@,"6H(.%`&P6P"&**. )[1zJLX&P'(R J*;X%,%022  ]]00rrceZdZUdZdZded<ejZdZ dZ dZ e dZ d Zd Ze d Zd Zd ZdZdZdZddZdZdZddZdZdZy) OffsetTreez A tree representation where positions are offsets in the score and each node has a payload which is a list of elements at that offset (unsorted by sort order). rznodeModule.OffsetNode | Nonerc |j}|j|}||vryy#t$r}td|d}~wwxYw)a Is true when the ElementTree contains the object within it; TRUE IF and ONLY if the .offset of the element matches the position in the tree -- thus it is very fast! >>> score = tree.examples.makeExampleScore() >>> scoreTree = score.asTree(flatten=True, groupOffsets=True) >>> score.flatten()[5] in scoreTree True Note that this way of finding an item won't work because the offset is different from the flat offset: >>> n = score.parts[0].measure(2).notes[1] >>> n >>> n.offset 1.0 >>> n in scoreTree False z7element must be a Music21Object, i.e., must have offsetNTF)offsetAttributeErrorr elementsStartingAt)r r'rae candidatess rr,zOffsetTree.__contains__sU0 ^^F ,,V4 j  &I  s % ? :?cfddfd t|trg|jt|dkr|jj|z}|dks|jj|krt|j|St|t rQ|jgS|j |jj}|d|d}}|j||Std|)a\ Gets elements by integer index or slice. >>> score = tree.examples.makeExampleScore() >>> scoreTree = score.asTree(flatten=True, groupOffsets=True) >>> scoreTree[0] >>> scoreTree[-1] >>> scoreTree[2:5] [, , ] >>> scoreTree[-6:-3] [, , ] >>> scoreTree[-100:-200] [] c<|j|cxkr|jkrnn|j||jz S|jr"||jkr|j|S|jr#|j|kr|j|Syy)zE Return the payload element at a given index N)payloadElementsStartIndexpayloadElementsStopIndexr&rrrs rrz.OffsetTree.__getitem__..recurseByIndexs--V9V9VV||ED,J,J$JKKED,J,J$J%dnne<<T%B%Be%K%doou==&Lrcg}||S||jkr/|jr#|j|j||||jkrW|j|krH||jz }t |d}||jz }|j|j |||j|kr/|j r#|j|j |||S)zf Return a slice of the payload elements (plural) where start <= index < stop. r)rrrkrmaxr&r)r r[rZrm indexStart indexStoprs rrz.OffsetTree.__getitem__..recurseBySlicesF| t555$.. nT^^UDIJt4449W9WZ^9^"T%C%CC  Q/  4#A#AA  dll:i@A,,4 nT__eTJKMrrrr)r znodeModule.OffsetNoderrs @@rr9zOffsetTree.__getitem__s, > $ a }}$  1uMM::Q>1u >>!C  !$--3 3 5 !}}$ ii F FGG&-aj'!*K!$--jI IFqcJK Krc#`K|jD]}|jD]}|yw)au Iterates through all the nodes in the offset tree and returns each thing in the payload. Not an especially efficient way of using this beautiful tree object. >>> score = tree.examples.makeExampleScore() >>> scoreTree = score.asTree(flatten=True, groupOffsets=True) >>> for x in scoreTree: ... print(x) PartA: : PartB: : ... Nrr)r r rs rrtzOffsetTree.__iter__$s,,NN$Dll#%s,.cH|j|jjzS)z Use so that both OffsetTrees, which have elements which do not have a .endTime, and TimespanTrees, which have element that have an .endTime but not a duration, can use most of the same code. )rduration quarterLength)rr s relementEndTimezOffsetTree.elementEndTime?s}}r{{8888rc|jSr)rrs rrz'OffsetTree.getPositionFromElementUnsafeIsyyrc|j}|j}|tk(rd}|j|||j |dy)zJ Add an element to the end, making certain speed savings. rN)r{)rKrLrrr|)r rrzrLs rrhzOffsetTree.appendTsK--/,, h G "% /$?rc(|jddS)z Payload sorting is done the old-fashioned way, because the number of elements at a single offset should be few enough that it is not a problem rN)r$)rns r_insertCorePayloadSortKeyz$OffsetTree._insertCorePayloadSortKey_s{{}QR  rc|j||j|}|jj||jj |j y)r)keyN)rr%r&rhsortrrs rrzOffsetTree._insertCorehsO !!(+%%h/ B d<<=rct|}|jt||j|_|jj |_|S)a Creates a new tree with the same payload as this tree. This is analogous to `dict.copy()`. Much, much faster than creating a new tree; creating one with 3600 items took 500ms. Creating the tree the first time was 40 seconds, so about an 80x speedup. >>> score = tree.examples.makeExampleScore() >>> scoreTree = score.asTimespans() >>> newTree = scoreTree.copy() >>> newTree > >>> scoreTree[16] > >>> newTree[16] > >>> scoreTree[16] is newTree[16] True )r<rr5rrcopy)r newTrees rrzOffsetTree.copyssH2$t*,tDz""..335rcg}|j|}|gt|jtr&|j |jt |S|j|j |jt |S)a Finds elements or timespans in this tree which start at `position`. >>> score = corpus.parse('bwv66.6') >>> scoreTree = score.asTimespans() >>> for timespan in scoreTree.elementsStartingAt(0.5): ... timespan ... > > > )r%r4r&r5rkrhtuple)r rresultsr s rrzOffsetTree.elementsStartingAtso%%h/  $,,-t||,W~)t||,W~rcPfdj}t|S)a Finds elements in this OffsetTree which stop at `offset`. Elements are ordered according to (start) offset. >>> score = corpus.parse('bwv66.6') >>> scoreTree = score.asTree(flatten=True, groupOffsets=True) >>> for el in scoreTree.elementsStoppingAt(0.5): ... el Works also on timespans for TimespanTrees: >>> scoreTree = score.asTimespans() >>> for el in scoreTree.elementsStoppingAt(0.5): ... el > > > czg}||jcxkr|jkrn|S|j!|j|j|jD])}j ||k(s|j |+|j!|j|j|Sr) endTimeLowrrrkr&rrhrr rmrrrr s rrz.OffsetTree.elementsStoppingAt..recursesF??f@0@0@@M~~1 gdnn&=>"ll..r48FB"MM"-+2 gdoo&>?Mrrrr rrrs`` @relementsStoppingAtzOffsetTree.elementsStoppingAts", $--(W~rcPfdj}t|S)a= Finds elements in this ElementTree which overlap `offset`. >>> score = corpus.parse('bwv66.6') >>> scoreTree = score.asTree(flatten=True, groupOffsets=True) >>> for el in scoreTree.elementsOverlappingOffset(0.5): ... el ... Works with Timespans in TimespanTrees as well. >>> scoreTree = score.asTimespans() >>> for el in scoreTree.elementsOverlappingOffset(0.5): ... el ... > cg}||jcxkr|jkrnn||j|j|jD])}j ||ks|j |+|j|j|S|jkr!|j|j|Sr)rrrkrr&rrhrrs rrz5OffsetTree.elementsOverlappingOffset..recursesF==6 rcDfdt|jS)at Gets all unique offsets of all timespans in this offset-tree. >>> score = corpus.parse('bwv66.6') >>> tsTree = score.asTimespans() >>> for offset in tsTree.allOffsets()[:10]: ... offset ... 0.0 0.5 1.0 2.0 3.0 4.0 5.0 5.5 6.0 6.5 cVg}||j!|j|j|j}t|tr|j |j n|j ||j!|j|j|Sr)rrkrr4rrhrr)r rmrQrs rrz&OffsetTree.allOffsets..recurse'sF>>-MM'$.."9:mmc9-MM#**-MM#&??.MM'$//":;Mr)rrrs @r allOffsetszOffsetTree.allOffsetss( WT]]+,,rcVfdtt|jS)a Gets all unique offsets (both starting and stopping) of all elements/timespans in this offset-tree. >>> score = corpus.parse('bwv66.6') >>> scoreTree = score.asTimespans() >>> for offset in scoreTree.allTimePoints()[:10]: ... offset ... 0.0 0.5 1.0 2.0 3.0 4.0 5.0 5.5 6.0 6.5 cHt}||j!|j|j|j|j|j|j |j !|j|j |Sr)r~rrrrpayloadEndTimesr)r rmrs rrz)OffsetTree.allTimePoints..recurseKsxUF>>-MM'$.."9: 4==) d2245??.MM'$//":;Mr)rsortedrrs @r allTimePointszOffsetTree.allTimePoints6s#* VGDMM2344rc|dur|jn|j}g}|D]N}|j|}|s|dur|j|-|j||j |iP|S)a Gets all time-points where some element is starting (or if includeStopPoints is True, where some element is starting or stopping) while some other element is still continuing onward. >>> score = corpus.parse('bwv66.6') >>> scoreOffsetTree = score.asTree(flatten=True, groupOffsets=True) >>> scoreOffsetTree.overlapTimePoints() [0.5, 5.5, 6.5, 10.5, 13.5, 14.5, 15.5...] if returnVerticality is True, then a mapping of time point to elements is returned. How cool is that? >>> otp = scoreOffsetTree.overlapTimePoints(returnVerticality=True) >>> otp[0] {0.5: } F)rr rrhgetVerticalityAt)r includeStopPointsreturnVerticality checkPointsoverlapscpoverlappingElementss roverlapTimePointszOffsetTree.overlapTimePointsWs&,=+Edoo'4K]K]K_ B"&"@"@"D & E)#T%:%:2%> ?@rcddlm}|j|}|j|}|j |}||||||}|S)aI Gets the verticality in this offset-tree which starts at `offset`. >>> bach = corpus.parse('bwv66.6') >>> scoreTree = bach.asTimespans() >>> scoreTree.getVerticalityAt(2.5) Verticalities outside the range still return a Verticality, but it might be empty: >>> scoreTree.getVerticalityAt(2000) Test that it still works if the tree is empty: >>> scoreTree = bach.asTimespans(classList=(instrument.Tuba,)) >>> scoreTree > >>> scoreTree.getVerticalityAt(5.0) Returns a verticality.Verticality object. r) Verticality)overlapTimespansstartTimespansr stopTimespans timespanTree)music21.tree.verticalityrrrr)r rrrrr verticalitys rrzOffsetTree.getVerticalityAtvsY0 9008//7 99&A!-)'  rci}|jD]/}|j}t|dkDs|dd||j<1|S)a Creates a dictionary of offsets that have more than one element starting at that time, where the keys are offset times and the values are lists of elements at that moment. >>> score = tree.examples.makeExampleScore() >>> scoreTree = score.asTree(flatten=True, groupOffsets=True) >>> scoreTree > >>> sd = scoreTree.simultaneityDict() >>> len(sd) 5 >>> list(sorted(sd.keys())) [0.0, 2.0, 4.0, 6.0, 8.0] >>> sd[0.0] [, , , , , , , ] >>> sd[2.0] [, ] rN)rsr&rOr)r simultaneityDictr r+s rr zOffsetTree.simultaneityDictsJ6NN$DB2w{24Q% /% r)NT)FF)r rrrrrr OffsetNoderr,r9rt staticmethodrrrhrrrrrrrrr rrr rrrrrxs I)(%%I"HBLt699  @!! >@,$L#J?>!-F5B>%N  rrceZdZdZdZy)Testc ddlm}ddlm}t}|j }t dD]8}|j }d|j_|j|dz|:|D]}|j||jt|jd|d}|j|j||jd |j!d }|j#|y ) zq test that get position after works with an offset when the tree is built on SortTuples. rnotestreamd@rz G# was coming from an incorrect activeSite. activeSite should not be used! r)corpusr(r&Ag@Br+rCg?rA#g@g?T) groupOffsets)r<r?r=r> zbwv66.6)flattenr@zC#N)r.r;r)r'r/r0rrrasTreerr3rOnamer^Restparse)r r;r)r'r(n0n1r7n3ststListr8r6score scoreTree elementLists rtestElementsStoppingAtzTest.testElementsStoppingAtsN #" MMO YYs^$' ! B YYs^$' ! B YYs^$' ! B YYt_$' ! b XX4X (&&s+ Va( &1&Q!&&&1. 0rA HHQ $rA HHR!VTYY[ ) XX4X (&&s+ Va( &1&Q!&&&1. 0 Y'LLDLA 2237  [)1- Q,,d3 Q,,c2 Q,,c2)22s K KN)r rrr9rSrrrr$r$s "j43rr$__main__)r __future__rmathrunittestrr.rrrmusic21.sortingr music21.treer r r Environment environLocalrr TreeExceptionr AVLTreerrTestCaser$ _DOC_ORDERr mainTestrrrras # %+&{&&|4 D  <55 H $,,H XE  E  Xk38  k3T  zGTr