3jUdZddlmZddlmZmZddlZddlmZddl Z ddl Z ddl m Z ddl mZddlmZdd lmZdd l mZdd l mZdd l mZdd l mZddl mZddl mZe j2rddl mZej6dZGddej:ZGddej:ZGdde j@Z!edGddZ"Gdde j@Z#GddejHZ%Gd d!e!Z&Gd"d#e!Z'Gd$d%e!Z(Gd&d'e!Z)Gd(d)e!Z*Gd*d+e!Z+Gd,d-e jXZ-e!gZ.d.e/d/<e0d0k(rddl Z e jbe-yy)1a A spanner is a music21 object that represents a connection usually between two or more music21 objects that might live in different streams but need some sort of connection between them. A slur is one type of spanner -- it might connect notes in different Measure objects or even between different parts. This package defines some of the most common spanners. Other spanners can be found in modules such as :ref:`moduleDynamics` (for things such as crescendos). ) annotations)SequenceIterableN) dataclass)base)common)opFrac)OffsetQL)defaults) environment) exceptions21)prebase)sites)stylestreamspannerc eZdZy)SpannerExceptionN__name__ __module__ __qualname__>> class CarterAccelerandoSign(spanner.Spanner): ... pass >>> n1 = note.Note('C4') >>> n2 = note.Note('D4') >>> n3 = note.Note('E4') >>> sp1 = CarterAccelerandoSign(n1, n2, n3) # or as a list: [n1, n2, n3] >>> sp1.getSpannedElements() [, , ] We can iterate over a spanner to get the contexts: >>> print(' '.join([repr(n) for n in sp1])) Now we put the notes and the spanner into a Stream object. Note that the convention is to put the spanner at the beginning of the innermost Stream that contains all the Spanners: >>> s = stream.Stream() >>> s.append([n1, n2, n3]) >>> s.insert(0, sp1) Now we can get at the spanner in one of three ways. (1) it is just a normal element in the stream: >>> for e in s: ... print(e) <...CarterAccelerandoSign > (2) we can get a stream of spanners (equiv. to getElementsByClass(spanner.Spanner)) by calling the .spanner property on the stream. >>> spannerCollection = s.spanners # a stream object >>> for thisSpanner in spannerCollection: ... print(thisSpanner) <...CarterAccelerandoSign > (3) we can get the spanner by looking at the list getSpannerSites() on any object that has a spanner: >>> n2.getSpannerSites() [>] In this example we will slur a few notes and then iterate over the stream to see which are slurred: >>> n1 = note.Note('C4') >>> n2 = note.Note('D4') >>> n3 = note.Note('E4') >>> n4 = note.Note('F4') >>> n5 = note.Note('G4') >>> n6 = note.Note('A4') Create a slur over the second and third notes at instantiation: >>> slur1 = spanner.Slur([n2, n3]) Slur the fifth and the sixth notes by adding them to an existing slur: >>> slur2 = spanner.Slur() >>> slur2.addSpannedElements([n5, n6]) Now add them all to a stream: >>> part1 = stream.Part() >>> part1.append([n1, n2, n3, n4, n5, n6]) >>> part1.insert(0, slur1) >>> part1.insert(0, slur2) Say we wanted to know which notes in a piece started a slur, here's how we could do it: >>> for n in part1.notes: ... ss = n.getSpannerSites() ... for thisSpanner in ss: ... if 'Slur' in thisSpanner.classes: ... if thisSpanner.isFirst(n): ... print(n.nameWithOctave) D4 G4 Alternatively, you could iterate over the spanners of part1 and get their first elements: >>> for thisSpanner in part1.spanners: ... firstNote = thisSpanner.getSpannedElements()[0] ... print(firstNote.nameWithOctave) D4 G4 The second method is shorter, but the first is likely to be useful in cases where you are doing other things to each note object along the way. Oh, and of course, slurs do print properly in musicxml: >>> #_DOCS_SHOW part1.show() .. image:: images/slur1_example.* :width: 400 (the Carter example would not print an arrow since that element has no corresponding musicxml representation). *Implementation notes:* The elements that are included in a spanner are stored in a Stream subclass called :class:`~music21.stream.SpannerStorage` found as the `.spannerStorage` attribute. That Stream has an attribute called `client` which links to the original spanner. Thus, `spannerStorage` is smart enough to know where it's stored, but it makes deleting/garbage-collecting a spanner a tricky operation: Ex. Prove that the spannedElement Stream is linked to container via `client`: >>> sp1.spannerStorage.client is sp1 True Spanners have a `.completeStatus` attribute which can be used to find out if all spanned elements have been added yet. It's up to the processing agent to set this, but it could be useful in deciding where to append a spanner. >>> sp1.completeStatus False When we're done adding elements: >>> sp1.completeStatus = True )spannerStoragecVt|di|ddlm}|j||_d|j _g}|D]6}t|tjr|j|/|2||z }8|j|d|_ d|_ g|_d|_y)NrrclientFunknownr)super__init__music21rSpannerStorager"autoSort isinstancer Music21ObjectappendaddSpannedElementsidLocalcompleteStatusfillElementTypes filledStatus)selfspannedElementskeywordsrprocspannedElement __class__s rr(zSpanner.__init__s $8$ #4f334@ (-$*,-N.$*<*<= N++& . %"& %*/18Arcg}|jD]}|}|jt| dj|S)N)getSpannedElementsr.reprjoin)r4msgcobjRefs r _reprInternalzSpanner._reprInternal s?((*AF JJtF| $+wws|rNignoreAttributescZdh}||}n||z}tjtt|||}t |j ||_|j jD]}|j j||j jd|S)z5 see __deepcopy__ for tests and docs r"rCr$F) updateIsFlat) tcastr!r'_deepcopySubclassabletyper" _elements coreAppendcoreElementsChanged)r4memorDdefaultIgnoreSetnewr@r9s rrIzSpanner._deepcopySubclassables --  #/ /2BB ffWW24JZ2[] 7T$"5"56cB$$..A    ) )! ,/ ..E.B rc$|j|S)a This produces a new, independent object containing references to the same spannedElements. SpannedElements linked in this Spanner must be manually re-set, likely using the replaceSpannedElement() method. Notice that we put the references to the same object so that later we can replace them; otherwise in a deepcopy of a stream, the notes in the stream will become independent of the notes in the spanner. >>> import copy >>> n1 = note.Note('g') >>> n2 = note.Note('f#') >>> c1 = clef.AltoClef() >>> sp1 = spanner.Spanner(n1, n2, c1) >>> sp2 = copy.deepcopy(sp1) >>> len(sp2.spannerStorage) 3 >>> sp1 is sp2 False >>> sp2[0] is sp1[0] True >>> sp2[2] is sp1[2] True >>> sp1[0] is n1 True >>> sp2[0] is n1 True )rI)r4rNs r __deepcopy__zSpanner.__deepcopy__&sB))$//rTc|jr|jj|tjj||yN)r" purgeOrphansrr-)r4excludeStorageStreamss rrUzSpanner.purgeOrphansNs7       , ,-B C ''.CDrFc|jr|jj|tjj||y)N) rescanIsDead)r"purgeLocationsrr-)r4rXs rrYzSpanner.purgeLocationsTs=       . .L . I ))$\)Jrc8|jj|S)a >>> n1 = note.Note('g') >>> n2 = note.Note('f#') >>> c1 = clef.BassClef() >>> sl = spanner.Spanner(n1, n2, c1) >>> sl[0] == n1 True >>> sl[-1] == c1 True >>> sl[clef.BassClef][0] == c1 True )r" __getitem__r4keys rr[zSpanner.__getitem__^s""..s33rc,t|jSrT)iterr"r4s r__iter__zSpanner.__iter__osD''((rc@t|jjSrT)lenr"rKr`s r__len__zSpanner.__len__rs4&&0011rc@t|jjS)a Return all the elements of `.spannerStorage` for this Spanner as a list of Music21Objects. >>> n1 = note.Note('g') >>> n2 = note.Note('f#') >>> sl = spanner.Spanner() >>> sl.addSpannedElements(n1) >>> sl.getSpannedElements() == [n1] True >>> sl.addSpannedElements(n2) >>> sl.getSpannedElements() == [n1, n2] True >>> sl.getSpannedElementIds() == [id(n1), id(n2)] True >>> c1 = clef.TrebleClef() >>> sl.addSpannedElements(c1) >>> sl.getSpannedElements() == [n1, n2, c1] # make sure that not sorting True )listr"rKr`s rr<zSpanner.getSpannedElementsws.D''1122rcN|jj|}t|S)aR >>> n1 = note.Note('g') >>> n2 = note.Note('f#') >>> c1 = clef.AltoClef() >>> sl = spanner.Spanner() >>> sl.addSpannedElements([n1, n2, c1]) >>> sl.getSpannedElementsByClass('Note') == [n1, n2] True >>> sl.getSpannedElementsByClass(clef.Clef) == [c1] True )r"getElementsByClassrf)r4classFilterList postStreams rgetSpannedElementsByClassz!Spanner.getSpannedElementsByClasss%((;;OL Jrcf|jjDcgc] }t|c}Scc}w)z Return all id() for all stored objects. Was performance critical, until most uses removed in v7. Used only as a testing tool now. Spanner.__contains__() was optimized in 839c7e5. )r"rKid)r4ns rgetSpannedElementIdszSpanner.getSpannedElementIdss. $22<<=>> n1 = note.Note('g') >>> n2 = note.Note('f#') >>> n3 = note.Note('e') >>> n4 = note.Note('d-') >>> n5 = note.Note('c') >>> sl = spanner.Spanner() >>> sl.addSpannedElements(n1) >>> sl.addSpannedElements(n2, n3) >>> sl.addSpannedElements([n4, n5]) >>> sl.getSpannedElementIds() == [id(n) for n in [n1, n2, n3, n4, n5]] True N)r isListLikehasSpannedElementr"rLrM)r4r5 otherElementsr@s rr/zSpanner.addSpannedElementss|4  1./O -a0O } ,O Ay))!,##..q1 ! //1rct|}|j||dk(ry|jjd|ur-|f|jjddz|j_yy)a  Add a single element as the first in the spanner. >>> n1 = note.Note('g') >>> n2 = note.Note('f#') >>> n3 = note.Note('e') >>> n4 = note.Note('d-') >>> n5 = note.Note('c') >>> sl = spanner.Spanner() >>> sl.addSpannedElements(n2, n3) >>> sl.addSpannedElements([n4, n5]) >>> sl.insertFirstSpannedElement(n1) >>> sl.getSpannedElementIds() == [id(n) for n in [n1, n2, n3, n4, n5]] True If the element is already in the spanner, it will not be added again, nor moved. (to move it to the front, remove it before running) >>> sl.insertFirstSpannedElement(n4) >>> sl.getSpannedElementIds() == [id(n) for n in [n1, n2, n3, n4, n5]] True rN)rcr/r"elements)r4firstElorigNumElementss rinsertFirstSpannedElementz!Spanner.insertFirstSpannedElementsq0 #4y ( a      ' ' +w 6 T0099#2>>    ( 7rc ||vS)a Return True if this Spanner has the spannedElement. >>> n1 = note.Note('g') >>> n2 = note.Note('f#') >>> span = spanner.Spanner() >>> span.addSpannedElements(n1) >>> span.hasSpannedElement(n1) True >>> span.hasSpannedElement(n2) False Note that a simple `in` does the same thing: >>> n1 in span True >>> n2 in span False rr4r8s rrrzSpanner.hasSpannedElements(%%rcF|jjD]}||usyy)NTF)r"rK)r4r8xs r __contains__zSpanner.__contains__s*$$..AN"/rc|ytj|r=|jj|}||jj ||dyy|jj ||dy)a When copying a Spanner, we need to update the spanner with new references for copied (if the Notes of a Slur have been copied, that Slur's Note references need references to the new Notes). Given the old spanned element, this method will replace the old with the new. The `old` parameter can be either an object or object id. >>> n1 = note.Note('g') >>> n2 = note.Note('f#') >>> c1 = clef.AltoClef() >>> c2 = clef.BassClef() >>> sl = spanner.Spanner(n1, n2, c1) >>> sl.replaceSpannedElement(c1, c2) >>> sl[-1] == c2 True NF) allDerived)risNumr"coreGetElementByMemoryLocationreplace)r4oldrPes rreplaceSpannedElementzSpanner.replaceSpannedElement!st& ; << ##BB3GA}##++Asu+E    ' 'SU ' CrincludeEndBoundarymustFinishInSpanmustBeginInSpanincludeElementsThatEndAtStartcD|jsy|jdury|j}|y||j}| t dt j rt|tjsJ|j}||urd}d}d} |3|j}|j} |jj| |j|} |) t%|j||j&z} nt%| |j&z} |j)j+| | ||||j-|j} | D]} | |ur| |ur |j#| |#|j#||||_ | | |_d|_y#tj $r(|#|j#||||_ | | |_YywxYw#tj $r&|j#||||_ | | |_YywxYw)a Fills in the intermediate elements of a spanner, that are found in searchStream between the first element's offset and the last element's offset+duration. If searchStream is None, the first element's activeSite is used. If the first element's activeSite is None, a SpannerException is raised. Ottava is an example of a Spanner that can be filled. The Ottava does not need to be inserted into the stream in order to be filled. >>> m = stream.Measure([note.Note('A'), note.Note('B'), note.Note('C')]) >>> ott1 = spanner.Ottava(m.notes[0], m.notes[2]) >>> ott1.fill(m) >>> ott1 <...Note B><...Note C>> If the searchStream is not passed in, fill still happens in this case, because the first note's activeSite is used instead. >>> ott2 = spanner.Ottava(m.notes[0], m.notes[2]) >>> ott2.fill() >>> ott2 <...Note B><...Note C>> If the searchStream is not passed, and the spanner's first element doesn't have an activeSite, a SpannerException is raised. >>> ott3 = spanner.Ottava(note.Note('D'), note.Note('E')) >>> ott3.fill() Traceback (most recent call last): music21.spanner.SpannerException: Spanner.fill() requires a searchStream or getFirst().activeSite NTz?Spanner.fill() requires a searchStream or getFirst().activeSiter)r2r3getFirst activeSiterrG TYPE_CHECKINGr,rStreamgetLastoffsetr"removegetOffsetInHierarchyrSitesExceptionr/r quarterLengthrecursegetElementsByOffsetInHierarchyrh)r4 searchStreamrrrr startElement endElementsavedEndElementOffsetsavedEndElementActiveSitestartOffsetInHierarchyendOffsetInHierarchy matchIterator foundElements rfillz Spanner.fillNstT$$     $ 04      '22L#&U ??lFMM: ::.2lln  %J15:>!  !%/$5$5 !(2(=(= %    & &z 2 /;/P/PQ]/^ "  ! '-j.M.Ml.[0:0H0H/I(J$$**@>> n1 = note.Note('g') >>> n2 = note.Note('f#') >>> n3 = note.Note('e') >>> n4 = note.Note('c') >>> n5 = note.Note('d-') >>> sl = spanner.Spanner() >>> sl.addSpannedElements(n1, n2, n3, n4, n5) >>> sl.isFirst(n2) False >>> sl.isFirst(n1) True >>> sl.isLast(n1) False >>> sl.isLast(n5) True )rr{s risFirstzSpanner.isFirsts*}}.00rc` |jdS#ttjf$rYywxYw)a Get the object of the first spannedElement (or None if it's an empty spanner) >>> n1 = note.Note('g') >>> n2 = note.Note('f#') >>> n3 = note.Note('e') >>> n4 = note.Note('c') >>> n5 = note.Note('d-') >>> sl = spanner.Spanner() >>> sl.addSpannedElements(n1, n2, n3, n4, n5) >>> sl.getFirst() is n1 True >>> spanner.Slur().getFirst() is None True rNr" IndexErrorr StreamExceptionr`s rrzSpanner.getFirsts5$ &&q) )L889   --c&|j|uS)zL Given a spannedElement, is it last? Returns True or False )rr{s risLastzSpanner.isLast s||~//rc` |jdS#ttjf$rYywxYw)a Get the object of the last spannedElement (or None if it's an empty spanner) >>> n1 = note.Note('g') >>> n2 = note.Note('f#') >>> n3 = note.Note('e') >>> n4 = note.Note('c') >>> n5 = note.Note('d-') >>> sl = spanner.Spanner() >>> sl.addSpannedElements(n1, n2, n3, n4, n5) >>> sl.getLast() is n5 True >>> spanner.Slur().getLast() is None True ruNrr`s rrzSpanner.getLasts5$ &&r* *L889  r)r5z1base.Music21Object | Sequence[base.Music21Object]rT)TF)r5z1Sequence[base.Music21Object] | base.Music21Objectrsbase.Music21Object)rwrreturnNone)r8rrbool)rr)rrrrrrrr)rrr__doc__equalityAttributesr(rBrIrRrUrYr[rardr<rkror/ryrrr~rrrrrr __classcell__r9s@rr!r!6sWr-2A#R2Ah4,!0PE K4")2 32 $>/2H/2+/2b$L&,$D^N!$)!& $.3N!! N!  N!  N!(,N!`1..0 rr!T)frozenc4eZdZUdZded<ded<dZded<y) PendingAssignmentRefz A dataclass containing information about a pending first spanned element assignment. See :meth:`SpannerBundle.setPendingSpannedElementAssignment` for documentation and tests. r!rstr classNameNOffsetQL | None offsetInScore)rrrr__annotations__rrrrrr+s N#'M='rrc*eZdZdZfdZddZxZS) SpannerAnchoraq A simple Music21Object that can be used to define the beginning or end of a Spanner, in the place of a GeneralNote. This is useful for (e.g.) a Crescendo that ends partway through a note (e.g. in a violin part). Exporters (like MusicXML) are configured to remove the SpannerAnchor itself on output, exporting only the Spanner start and stop locations. Here's an example of a whole note that has a Crescendo for the first half of the note, and a Diminuendo for the second half of the note. >>> n = note.Note('C4', quarterLength=4) >>> measure = stream.Measure([n], number=1) >>> part = stream.Part([measure], id='violin') >>> score = stream.Score([part]) Add a crescendo from the note's start to the first anchor, place in the middle of the note, and then a diminuendo from that first anchor to the second, placed at the end of the note. >>> anchor1 = spanner.SpannerAnchor() >>> anchor2 = spanner.SpannerAnchor() >>> measure.insert(2.0, anchor1) >>> measure.insert(4.0, anchor2) >>> cresc = dynamics.Crescendo(n, anchor1) >>> dim = dynamics.Diminuendo(anchor1, anchor2) >>> score.append((cresc, dim)) >>> score.show('text') {0.0} {0.0} {0.0} {2.0} {4.0} {4.0} <...SpannerAnchor at 2.0>> {4.0} <...SpannerAnchor at 4.0>> c $t|di|y)Nr)r'r()r4r6r9s rr(zSpannerAnchor.__init__\s $8$rc&|j}|jO|jjd}|s|jjd}|sy|j |d}|j j }|dk(rd|Sd|d||zS)NMeasureVoice unanchoredrzat -)rrrgetSitesByClassrdurationr)r4rsiteListqls rrBzSpannerAnchor._reprInternal_s;; ?? "!ZZ77 BH::55g>#..x{;F}}22 7> !VHAfrk]++rrr)rrrrr(rBrrs@rrr6s$J%,rrceZdZdZdddZddZdZdZddZddZ d Z dd Z ddd Z dd Z dd Z ddZd dZd!dZdZdZ d d"dZ d d#dZd$dZy)% SpannerBundleal An advanced utility object for collecting and processing collections of Spanner objects. This is necessary because often processing routines that happen at many levels still need access to the same collection of spanners. Because SpannerBundles are so commonly used with :class:`~music21.stream.Stream` objects, the Stream has a :attr:`~music21.stream.Stream.spannerBundle` property that stores and caches a SpannerBundle of the Stream. If a Stream or Stream subclass is provided as an argument, all Spanners on this Stream will be accumulated herein. Not to be confused with SpannerStorage (which is a Stream class inside a spanner that stores Elements that are spanned) * Changed in v7: only argument must be a List of spanners. Creators of SpannerBundles are required to check that this constraint is True NcFi|_g|_|r |dd|_g|_yrT)_cache_storage _pendingSpannedElementAssignment)r4spannerss rr(zSpannerBundle.__init__s*(* ') $QKDM MO-rcn|jj||jjy)zu adds a Spanner to the bundle. Will be done automatically when adding a Spanner to a Stream. N)rr.rclear)r4others rr.zSpannerBundle.appends& U# rc,t|jSrT)rcrr`s rrdzSpannerBundle.__len__s4==!!rc6|jjSrT)rrar`s rrazSpannerBundle.__iter__s}}%%''rc |j|SrT)rr\s rr[zSpannerBundle.__getitem__s}}S!!rc||jvr|jj|ntd||jj y)a Remove a stored Spanner from the bundle with an instance. Each reference must have a matching id() value. >>> su1 = spanner.Slur() >>> su1.idLocal = 1 >>> su2 = spanner.Slur() >>> su2.idLocal = 2 >>> sb = spanner.SpannerBundle() >>> sb.append(su1) >>> sb.append(su2) >>> len(sb) 2 >>> sb >>> sb.remove(su2) >>> len(sb) 1 z!cannot match object for removal: N)rrrrr)r4items rrzSpannerBundle.removesE* 4== MM  &(+LTF)ST T rcdt|S)Nzof size )rcr`s rrBzSpannerBundle._reprInternals#d)%%rctg}|jD]&}|jt|j(|S)zK Return all SpannerStorage ids from all contained Spanners )rr.rmr")r4postr}s rgetSpannerStorageIdsz"SpannerBundle.getSpannerStorageIdss3A KK1++, - rcd|}||jvs|j|Rg}|jD]#}|j|k(s|j|%|j ||j|<|j|S)aq Get spanners by `idLocal`. Returns a new SpannerBundle object >>> su = spanner.Slur() >>> su.idLocal = 1 >>> rb = spanner.RepeatBracket() >>> rb.idLocal = 2 >>> sb = spanner.SpannerBundle() >>> sb.append(su) >>> sb.append(rb) >>> len(sb) 2 >>> sb.getByIdLocal(2) >>> sb.getByIdLocal(2)[0] >>> len(sb.getByIdLocal(1)) 1 >>> sb.getByIdLocal(3) zidLocal-)rrr0r.r9)r4r0cacheKeyoutsps r getByIdLocalzSpannerBundle.getByIdLocals|6gY' 4;; &$++h*?*G!#Cmm::(JJrN$%)NN3$7DKK !{{8$$rcg}|jD]#}|j|k(s|j|%|j|S)a Get spanners by matching status of `completeStatus` to the same attribute >>> su1 = spanner.Slur() >>> su1.idLocal = 1 >>> su1.completeStatus = True >>> su2 = spanner.Slur() >>> su2.idLocal = 2 >>> sb = spanner.SpannerBundle() >>> sb.append(su1) >>> sb.append(su2) >>> sb2 = sb.getByCompleteStatus(True) >>> len(sb2) 1 >>> sb2 = sb.getByIdLocal(1).getByCompleteStatus(True) >>> sb2[0] == su1 True )rr1r.r9)r4r1rrs rgetByCompleteStatusz!SpannerBundle.getByCompleteStatussA(!--B  N2 B ~~d##rct|}d|}||jvs|j|Gg}|jD]}||vs|j||j ||j|<|j|S)a} Given a spanner spannedElement (an object), return a new SpannerBundle of all Spanner objects that have this object as a spannedElement. >>> n1 = note.Note() >>> n2 = note.Note() >>> n3 = note.Note() >>> su1 = spanner.Slur(n1, n2) >>> su2 = spanner.Slur(n2, n3) >>> sb = spanner.SpannerBundle() >>> sb.append(su1) >>> sb.append(su2) >>> list(sb.getBySpannedElement(n1)) == [su1] True >>> list(sb.getBySpannedElement(n2)) == [su1, su2] True >>> list(sb.getBySpannedElement(n3)) == [su2] True zgetBySpannedElement-)rmrrr.r9)r4r8idTargetrrrs rgetBySpannedElementz!SpannerBundle.getBySpannedElement s<n%)(4 4;; &$++h*?*G!#Cmm"R'JJrN $ %)NN3$7DKK !{{8$$rc(t|tr tdg}|jj |j D]1}i|_||vs|j |||j|3|jj |S)aY Given a spanner spannedElement (an object), replace all old spannedElements with new spannedElements for all Spanner objects contained in this bundle. The `old` parameter must be an object, not an object id. If no replacements are found, no errors are raised. Returns a list of spanners that had elements replaced. >>> n1 = note.Note('C') >>> n2 = note.Note('D') >>> su1 = spanner.Line(n1, n2) >>> su2 = spanner.Glissando(n2, n1) >>> sb = spanner.SpannerBundle() >>> sb.append(su1) >>> sb.append(su2) >>> su1 > >>> su2 > >>> n3 = note.Note('E') >>> replacedSpanners = sb.replaceSpannedElement(n2, n3) >>> replacedSpanners == [su1, su2] True >>> su1 > >>> su2 > * Changed in v7: id() is no longer allowed for `old`. >>> sb.replaceSpannedElement(id(n1), n2) Traceback (most recent call last): TypeError: send elements to replaceSpannedElement(), not ids. z2send elements to replaceSpannedElement(), not ids.)r,int TypeErrorrrrrr.)r4rrPreplacedSpannersrs rrz#SpannerBundle.replaceSpannedElement4s\ c3 PQ Q*, --BBIby((c2 ''+  rcd|}t|tr|nd}t|trdn|}||jvs|j|qg}|jD]B}|r ||jvr|j |%t||s2|j |D|j ||j|<|j|S)a Given a spanner class, return a new SpannerBundle of all Spanners of the desired class. >>> su1 = spanner.Slur() >>> su2 = layout.StaffGroup() >>> su3 = layout.StaffGroup() >>> sb = spanner.SpannerBundle() >>> sb.append(su1) >>> sb.append(su2) >>> sb.append(su3) `searchClass` should be a Class. >>> slurs = sb.getByClass(spanner.Slur) >>> slurs >>> list(slurs) == [su1] True >>> list(sb.getByClass(spanner.Slur)) == [su1] True >>> list(sb.getByClass(layout.StaffGroup)) == [su2, su3] True A tuple of classes can also be given: >>> len(sb.getByClass((spanner.Slur, layout.StaffGroup))) 3 Note that the ability to search via a string will be removed in version 10. z getByClass-r;r)r,rrrclassesr.r9)r4 searchClassr searchStr searchClassesrrs r getByClasszSpannerBundle.getByClassysD! .#-k3#?KR (c: 4;; &$++h*?*G!#Cmmbjj!8JJrN!"m4 2$%)NN3$7DKK !{{8$$rcbt|j|D]\}}||zdz|_y)a (See :meth:`setIdLocals` for an explanation of what an idLocal is.) Automatically set idLocal values for all members of the provided class. This is necessary in cases where spanners are newly created in potentially overlapping boundaries and need to be tagged for MusicXML or other output. Note that, if some Spanners already have idLocals, they will be overwritten. The `maxId` parameter sets the largest number that is available for this class. In MusicXML it is 6. Currently, this method just iterates over the spanners of this class and counts the number from 1-6 and then recycles numbers. It does not check whether more than 6 overlapping spanners of the same type exist, nor does it reset the count to 1 after all spanners of that class have been closed. The example below demonstrates that the position of the contents of the spanner have no bearing on its idLocal (since we don't even put anything into the spanners). >>> su1 = spanner.Slur() >>> su2 = layout.StaffGroup() >>> su3 = spanner.Slur() >>> sb = spanner.SpannerBundle() >>> sb.append(su1) >>> sb.append(su2) >>> sb.append(su3) >>> [sp.idLocal for sp in sb.getByClass(spanner.Slur)] [None, None] >>> sb.setIdLocalByClass('Slur') >>> [sp.idLocal for sp in sb.getByClass(spanner.Slur)] [1, 2] N) enumeraterr0)r4rmaxIdirs rsetIdLocalByClasszSpannerBundle.setIdLocalByClasss0Hty9:EAre)qBJ;rcd}t}|jD]*}|jD]}||vs|j|*,|D]}|j |y)a Utility method for outputting MusicXML (and potentially other formats) for spanners. Each Spanner type (slur, line, glissando, etc.) in MusicXML has a number assigned to it. We call this number, `idLocal`. idLocal is a number from 1 to 6. This does not mean that your piece can only have six slurs total! But it does mean that within a single part, only up to 6 slurs can happen simultaneously. But as soon as a slur stops, its idLocal can be reused. This method sets all idLocals for all classes in this SpannerBundle. This will assure that each class has a unique idLocal number. Calling this method is destructive: existing idLocal values will be lost. >>> su1 = spanner.Slur() >>> su2 = layout.StaffGroup() >>> su3 = spanner.Slur() >>> sb = spanner.SpannerBundle() >>> sb.append(su1) >>> sb.append(su2) >>> sb.append(su3) >>> [sp.idLocal for sp in sb.getByClass('Slur')] [None, None] >>> sb.setIdLocals() >>> [(sp, sp.idLocal) for sp in sb] [(, 1), (, 1), (, 2)] :class:`~music21.dynamics.DynamicWedge` objects are commingled. That is, :class:`~music21.dynamics.Crescendo` and :class:`~music21.dynamics.Diminuendo` are not numbered separately: >>> sb2 = spanner.SpannerBundle() >>> c = dynamics.Crescendo() >>> d = dynamics.Diminuendo() >>> sb2.append(c) >>> sb2.append(d) >>> sb2.setIdLocals() >>> [(sp, sp.idLocal) for sp in sb2] [(, 1), (, 2)] ) Crescendo DiminuendoN)setrraddr)r4 skip_classesrrklassrs r setIdLocalszSpannerBundle.setIdLocalss^f3 %--B ,KK&$ !I  " "9 -!rc`|j|j|j|S)a Get all spanners of a specified class `className`, an id `idLocal`, and a `completeStatus`. This is a convenience routine for multiple filtering when searching for relevant Spanners to pair with. >>> su1 = spanner.Slur() >>> su2 = layout.StaffGroup() >>> su2.idLocal = 3 >>> sb = spanner.SpannerBundle() >>> sb.append(su1) >>> sb.append(su2) >>> list(sb.getByClassIdLocalComplete(layout.StaffGroup, 3, False)) == [su2] True >>> su2.completeStatus = True >>> list(sb.getByClassIdLocalComplete(layout.StaffGroup, 3, False)) == [] True )rrr)r4rr0r1s rgetByClassIdLocalCompletez'SpannerBundle.getByClassIdLocalCompletes.(y)66 ((8 9rcXt|||}|jj||S)u< A SpannerBundle can be set up so that a particular spanner (sp) is looking for an element of class (className) to be set as first element. Any future element that matches the className (and offsetInScore, if specified) which is passed to the SpannerBundle via freePendingSpannedElementAssignment() will get it. Call `popPendingSpannedElementAssignments` after parsing to recover pending spanners that never matched their expected elements — e.g., a MusicXML `` whose `` lands between notes, needing a `SpannerAnchor` instead. First, let's see the usage without an explicit offset: Create some notes and a rest. >>> n1 = note.Note('C') >>> r1 = note.Rest() >>> n2 = note.Note('D') Notes start without any associated spanners. >>> n1.getSpannerSites() [] Create an empty Slur and a SpannerBundle to hold it. >>> su1 = spanner.Slur() >>> sb1 = spanner.SpannerBundle() >>> sb1.append(su1) >>> su1.getSpannedElements() [] Now call this method to register `su1` as awaiting the next note element. The method returns a `PendingAssignmentRef` (frozen dataclass) with information about what is registered as pending assignment. >>> sb1.setPendingSpannedElementAssignment(su1, 'Note') PendingAssignmentRef(spanner=, className='Note', offsetInScore=None) Elements are then potentially added to spanners by calling `freePendingSpannedElementAssignment` on the SpannerBundle. That method will not attach a rest like `r1` because it is not a `'Note'`: >>> sb1.freePendingSpannedElementAssignment(r1) >>> r1 in su1 False But the next Note will be attached: >>> sb1.freePendingSpannedElementAssignment(n1) >>> su1 > >>> n1 in su1 True >>> n1.getSpannerSites() [>] Once the pending assignment has been satisfied, the registration is cleared from the SpannerBundle, so no future notes that would have satisfied the assignment get assigned: >>> sb1.freePendingSpannedElementAssignment(n2) >>> n2 in su1 False >>> n2.getSpannerSites() [] And we can see that the SpannerBundle `sb1` has no spanners still awaiting (pending) elements to assign: >>> sb1.popPendingSpannedElementAssignments() [] Now a similar example using `offsetInScore`. When `offsetInScore` is specified at registration, only candidates passed with a matching offset to `freePendingSpannedElementAssignment` will be attached. Create two notes and a rest. >>> n3 = note.Note('C#') >>> wrongOffsetNote = note.Note('B') >>> r2 = note.Rest() Create a slur with `n3` already in it. >>> sb2 = spanner.SpannerBundle() >>> su2 = spanner.Slur([n3]) >>> sb2.append(su2) >>> su2.getSpannedElements() [] Register `su2` as pending and looking for the next Note at offset 4.0: >>> ref = sb2.setPendingSpannedElementAssignment(su2, 'Note', 4.0) >>> ref PendingAssignmentRef(spanner=>, className='Note', offsetInScore=4.0) Call `freePendingSpannedElementAssignment` to attach an element of the right class and offset. Note that the offset must be passed to the method; it is not necessarily the offset of the object itself (most often it is the `offsetInHierarchy` of the Part object). A note offered at the wrong offset is not attached: >>> sb2.freePendingSpannedElementAssignment(wrongOffsetNote, 5.0) >>> wrongOffsetNote in su2 False (Passing an offset here is important since, when parsing MusicXML, if a `` has `` specified, the next note might not be the one at the start of the spanner) The freePending method will not get a rest even at the correct offsetInScore because it is not the class being searched for. >>> sb2.freePendingSpannedElementAssignment(r2, 4.0) >>> r2 in su2 False We are all out of possible notes, we can see which PendingAssignmentRef elements are still awaiting elements to attach to. In this case, there is one, our Slur: >>> unmatched_pendingAssignmentRefs = sb2.popPendingSpannedElementAssignments() >>> len(unmatched_pendingAssignmentRefs) 1 >>> unmatched_pendingAssignmentRefs[0] PendingAssignmentRef(spanner=>, className='Note', offsetInScore=4.0) >>> unmatched_pendingAssignmentRefs[0].spanner is su2 True Parsers can use the information from the unmatched PendingAssignmentRef to add additional elements to the score at places where a match was expected. Given this ref, the most logical choice would be to create a `SpannerAnchor` object and put it at score offset 4.0 and insert it as the spanner's first element with `insertFirstSpannedElement`. (If a parser needs more information about where the Spanner and SpannerAnchor should go, such as a staff number, etc. it can keep a dictionary mapping `id(PendingAssignmentRef)` to a staffKey, etc.) And now the happy path: a pending assignment that finds a matching note with the right offset. (We'll demonstrate also that you need to pass in your own fractions.) >>> frac = common.numberTools.opFrac >>> n4 = note.Note('G') >>> n5 = note.Note('A') >>> su3 = spanner.Slur([n4]) >>> sb3 = spanner.SpannerBundle() >>> sb3.append(su3) >>> _ = sb3.setPendingSpannedElementAssignment(su3, 'Note', frac(77.33333)) >>> sb3.freePendingSpannedElementAssignment(n5, frac(77.33333)) >>> su3 > >>> n5 in su3 True An important detail demonstrated above is that a freed element is always inserted as the first element of the spanner, even when the spanner already has other elements. (Note A is before note G in the slur). The insert-at-front behavior is important for MusicXML parsing, since a `` specified is often encountered before the note that should *start* the spanner (because of voices, other classes, etc.), so when the starting note arrives it needs to go to the start. )rrr)rrr.)r4rrrrefs r"setPendingSpannedElementAssignmentz0SpannerBundle.setPendingSpannedElementAssignment(s3b#'  --44S9 rc*|jsyd}t|jD]N\}}|j|jvs|||jk(s1|j j ||}n||jj|yy)a7 Assigns and frees up a pendingSpannedElementAssignment if one is active and the candidate matches the class (and offsetInScore, if specified). See setPendingSpannedElementAssignment for documentation and tests. It is set up via a first-in, first-out priority. N)rrrclassSetrrrypop)r4spannedElementCandidaterrrrs r#freePendingSpannedElementAssignmentz1SpannerBundle.freePendingSpannedElementAssignments44  E EFFAs}} 7 @ @@!)(C,=,==KK99:QRF G    1 1 5 5f = rc,|j}g|_|S)a Removes and returns all pendingSpannedElementAssignments. This can be called when there will be no more calls to freePendingSpannedElementAssignment, and SpannerAnchors need to be created for each remaining pending assignment. The SpannerAnchors should be created at the appropriate offset, dictated by the assignment's offsetInScore. >>> sb = spanner.SpannerBundle() >>> sl = spanner.Slur() >>> sb.append(sl) >>> sb.setPendingSpannedElementAssignment(sl, 'Note', 0.0) PendingAssignmentRef(spanner=, className='Note', offsetInScore=0.0) `popPendingSpannedElementAssignments` returns the full list and leaves an empty list behind: >>> expectedPending = list(sb._pendingSpannedElementAssignment) >>> pending = sb.popPendingSpannedElementAssignments() >>> pending == expectedPending True >>> sb._pendingSpannedElementAssignment [] )r)r4outputs r#popPendingSpannedElementAssignmentsz1SpannerBundle.popPendingSpannedElementAssignmentss4.2-R-R02- rrT)rzlist[Spanner] | None)rr!)rr!)rr!)rz list[int])r0z int | Nonerr)r1rrr)r8r!rr)rrrPrrz list[Spanner])rzstr | type | tuple[type, ...]rz'SpannerBundle'))rr!rrrrrr)rr)rzlist[PendingAssignmentRef])rrrrr(r.rdrar[rrBrrrrrrrrrrr r rrrrrqs* O"("6&"%H$4(%TC C  C   C J1%f&)P;.z96(, w ww% w  wx(,>%>6rrc"eZdZdZfdZxZS)Slurz A slur represented as a spanner between two Notes. Slurs have `.placement` options ('above' or 'below') and `.lineType` ('dashed' or None) c@t||i|d|_d|_yrT)r'r( placementlineTyper4r5r6r9s rr(z Slur.__init__#s# /6X6 r)rrrrr(rrs@rrrs rrceZdZUdZej ZdddZded<fdZ dZ e d Z e jd Z xZS) MultiMeasureRestzb A grouping symbol that indicates that a collection of rests lasts multiple measures. a> Boolean to indicate whether rest symbols (breve, longa, etc.) should be used when displaying the rest. Your music21 inventor is a medievalist, so this defaults to True. Change defaults.multiMeasureRestUseSymbols to change globally. a" An int, specifying the maximum number of rests to display as symbols. Default is 11. If useSymbols is False then this setting does nothing. Change defaults.multiMeasureRestMaxSymbols to change globally. ) useSymbols maxSymbolszdict[str, str] _DOC_ATTRct||i|d|_|jdtj |_|jdtj|_y)Nrr) r'r(_overriddenNumbergetr multiMeasureRestUseSymbolsrmultiMeasureRestMaxSymbolsrrs rr(zMultiMeasureRest.__init__KsO /6X6"&",,|X5X5XY",,|X5X5XYrcJ|jdk7rdnd}|jd|S)Nrsr;z measure)numRests)r4plurals rrBzMultiMeasureRest._reprInternalTs) *--11rcH|j |jSt|S)a Returns the number of measures involved in the multi-measure rest. Calculated automatically from the number of rests in the spanner. Or can be set manually to override the number. >>> mmr = spanner.MultiMeasureRest() >>> for i in range(6): ... mmr.addSpannedElements([note.Rest(type='whole')]) >>> mmr.numRests 6 >>> mmr.numRests = 10 >>> mmr.numRests 10 )rrcr`s rr zMultiMeasureRest.numRestsXs&$  ! ! -)) )t9 rc||_yrT)r)r4 overriddens rr zMultiMeasureRest.numRestsos !+r)rrrrr TextStyle _styleClassrrr(rBpropertyr setterrrs@rrr/sb//K!I~*Z2,__,,rrceZdZdZdddZddd dfdZedd Zedd Zdd Z dd Z ee e d Z fdZ xZ S) RepeatBracketa A grouping of one or more measures, presumably in sequence, that mark an alternate repeat. These gather what are sometimes called first-time bars and second-time bars. It is assumed that numbering starts from 1. Numberings above 2 are permitted. The `number` keyword argument can be used to pass in the desired number. `overrideDisplay` if set will display something other than the number. For instance `ouvert` and `clos` for medieval music. However, if you use it for something like '1-3' be sure to set number properly too. >>> m = stream.Measure() >>> sp = spanner.RepeatBracket(m, number=1) >>> sp # can be one or more measures > >>> sp.number = 3 >>> sp > >>> sp.numberRange # the list of repeat numbers [3] >>> sp.number '3' Range of repeats as string: >>> sp.number = '1-3' >>> sp.numberRange [1, 2, 3] >>> sp.number '1-3' Range of repeats as list: >>> sp.number = [2, 3] >>> sp.numberRange [2, 3] >>> sp.number '2, 3' Comma separated numbers: >>> sp.number = '1, 2, 3' >>> sp.numberRange [1, 2, 3] >>> sp.number '1-3' Disjunct numbers: >>> sp.number = '1, 2, 3, 7' >>> sp.numberRange [1, 2, 3, 7] >>> sp.number '1, 2, 3, 7' Override the display. >>> sp.overrideDisplay = '1-3, 7' >>> sp > number is not affected by display overrides: >>> sp.number '1, 2, 3, 7' ab Get a contiguous list of repeat numbers that are applicable for this instance. Will always have at least one element, but [0] means undefined >>> rb = spanner.RepeatBracket() >>> rb.numberRange [0] >>> rb.number = '1,2' >>> rb.numberRange [1, 2] zr Override the string representation of this bracket, or use None to not override. ) numberRangeoverrideDisplayrN)numberr,cNt||i|g|_||_||_yrT)r'r(r+r,r-)r4r-r,r5r6r9s rr(zRepeatBracket.__init__s0 /6X6 '). rczt|jdk(xr"|jd|jddz k(S)zW are there exactly two numbers that should be written as 3, 4 not 3-4. rr)rcr+r`s r_numberSpanIsAdjacentz#RepeatBracket._numberSpanIsAdjacentsA 4##$)\d.>.>q.ATEUEUVWEX[\E\.\\rc@tj|jS)zK can we write as '3, 4' or '5-10' and not as '1, 5, 6, 11' )rcontiguousListr+r`s r_numberSpanIsContiguousz%RepeatBracket._numberSpanIsContiguouss $$T%5%566rct|jdk(r+|jddk(ryt|jdS|js2dj |jDcgc] }t|c}S|j r!|jdd|jdS|jdd|jdScc}w)z This must return a string, as we may have single numbers or lists. For a raw numerical list, look at `.numberRange`. rrr;z, rur)rcr+rr4r>r1)r4r}s r _getNumberzRepeatBracket._getNumbers t A %"a't''*+ +//yy$2B2B!C2BQ#a&2B!CDD++**1-.b1A1A"1E0FGG**1-.a0@0@0D/EFF "Ds)Cc |dk(r dg|_ytj|tr*g|_|D]}|jj |yt |t rd|vrD|jd\}}ttt|t|dz|_yd|vrRg|_|jdD]6}t|j}|jj |8y|jrt|g|_ytd|tj|r2g|_||jvr|jj |yytd|)zO Set the bracket number. There may be range of values provided r;rrr,z/number for RepeatBracket must be a number, not N)r+r holdsTyperr.r,rsplitrfrangestripisdigitrisInt)r4valuer}startendone_letter_value one_numbers r _setNumberzRepeatBracket._setNumbersY B; !sD    eS )!D   ''* s #e|"[[- s#'c%j#c(Q,(G#H #% (- C(8$!$%5%;%;%=!>J$$++J7)9$'J< &)XY^Xa'bcc \\% !D D,,,  ''.-#%TUZT]#^_ _raA Get or set the number -- returning a string always. >>> rb = spanner.RepeatBracket() >>> rb.number '' >>> rb.number = '5-7' >>> rb.number '5-7' >>> rb.numberRange [5, 6, 7] >>> rb.number = 1 docc||j|jdz}n|jdz}|t| zS)N )r,r-r'rB)r4r?r9s rrBzRepeatBracket._reprInternal0s@    +&&,C++#CUW*,,,r)r-int | str | Iterable[int]r, str | None)rrr)r?rI)rrrrrr(r'r1r4r6rDr-rBrrs@rr*r*wsDN   I,23-1 . #+ ]] 77G"`Bj* 3  F--rr*ceZdZdZdZdddd dfdZdZd Zeeed Z fd Z d Z ddZ ddZ dZdZxZS)Ottavaa An octave shift line: >>> ottava = spanner.Ottava(type='8va') >>> ottava.type '8va' >>> ottava.type = 15 >>> ottava.type '15ma' >>> ottava.type = (8, 'down') >>> ottava.type '8vb' >>> print(ottava) An Ottava spanner can either be transposing or non-transposing. In a transposing Ottava spanner, the notes in the stream should be in their written octave (as if the spanner were not there) and all the notes in the spanner will be transposed on Stream.toSoundingPitch(). A non-transposing spanner has notes that are at the pitch that they would sound (therefore the Ottava spanner is a decorative line). >>> ottava.transposing True >>> n1 = note.Note('D4') >>> n2 = note.Note('E4') >>> n2.offset = 2.0 >>> ottava.addSpannedElements([n1, n2]) >>> s = stream.Stream([ottava, n1, n2]) >>> s.atSoundingPitch = False >>> s2 = s.toSoundingPitch() >>> s2.show('text') {0.0} > {0.0} {2.0} >>> for n in s2.notes: ... print(n.nameWithOctave) D3 E3 All valid types are given below: >>> ottava.validOttavaTypes ('8va', '8vb', '15ma', '15mb', '22da', '22db') OMIT_FROM_DOCS Test the round-trip back: >>> s3 = s2.toWrittenPitch() >>> s3.show('text') {0.0} > {0.0} {2.0} >>> for n in s3.notes: ... print(n.nameWithOctave) D4 E4 )8va8vb15ma15mb22da22dbrMTabove)rJ transposingrcddlm}t| |i||jg|_d|_||_||_||_ y)Nrnote) r)rWr'r(NotRestr2_typerJrrT)r4rJrTrr5r6rWr9s rr(zOttava.__init__~sE ! /6X6!%  "&rc|jSrT)rYr`s r_getTypezOttava._getTypes zzrctj|r|dvr|dk(rd|_yd|_ytj|rt |dk\rg}|ddvr/|j t |d|j dn5|dd vr.|j t |d|j d t |d k\r|dd k(r|j d n|j ddj||_yt|t r|j|jvrtd||j|_y)N)r]rMrOrr)r]8v)r^15mr0downbar;zcannot create Ottava of type: ) rrrYrqrcr.rr>r,lowervalidOttavaTypesr)r4newTypestubs r_setTypezOttava._setTypes" << W%7!|" #   w 'CLA,=DqzX% C O, C z) C O, C 7|q WQZ6%9 C  C DJw,}}d.C.CC&4WI>@@ DJra@ Get or set Ottava type. This can be set by as complete string (such as 8va or 15mb) or with a pair specifying size and direction. >>> os = spanner.Ottava() >>> os.type = '8vb' >>> os.type '8vb' >>> os.type = 15, 'down' >>> os.type '15mb' rEcdd}|jsd}|jd|t| zS)NrTznon-transposingrH)rTrJr'rB)r4rTr9s rrBzOttava._reprInternals8# +K))Ak]+eg.C.EEErc|jjdry|jjdry|jjdrytd|j)zv Get basic parameters of shift. Returns either 8, 15, or 22 depending on the amount of shift r_r]rar^22z Cannot get shift magnitude from )rY startswithrr`s rshiftMagnitudezOttava.shiftMagnitudesZ ::  % ZZ " "4 ( ZZ " "4 ("%Edjj^#TU Urc|jjdr|ryy|jjdr|ryyy)zD Returns up or down depending on the type of shift: rercuprdN)rYendswith)r4reverses rshiftDirectionzOttava.shiftDirections? ::  s # ::  s # $rcddlm}|j|dk(rd}nd}|t|j z }||S)z return an interval.Interval() object representing this ottava >>> ottava = spanner.Ottava(type='15mb') >>> i = ottava.interval() >>> i r)IntervalrtrczP-P)music21.intervalrwrurrp)r4rtrwheaders rintervalzOttava.intervalsJ .   w  /6 9FF#d))+,,rc|jsyd|_|j}|jD]3}t|ds|jD]}|j |d5y)a On a transposing spanner, switch to non-transposing, and transpose all notes and chords in the spanner. The note/chords will all be transposed to their sounding pitch (at least as far as the ottava is concerned; transposing instruments are handled separately). >>> ottava = spanner.Ottava(type='8va') >>> n1 = note.Note('D#4') >>> n2 = note.Note('E#4') >>> ottava.addSpannedElements([n1, n2]) >>> ottava.transposing True >>> ottava.performTransposition() >>> ottava.transposing False >>> n1.nameWithOctave 'D#5' NFpitchesTinPlacerTr|r<hasattrr~ transposer4 myIntervalrnps rperformTranspositionzOttava.performTranspositionsa,  ]]_ ((*A1i(YY J 5+rc|jryd|_|jd}|jD]3}t|ds|jD]}|j |d5y)a Change a non-transposing spanner to a transposing spanner, and transpose back all the notes and chords in the spanner. The notes/chords will all be transposed to their written pitch (at least as far as the ottava is concerned; transposing instruments are handled separately). >>> ottava = spanner.Ottava(type='8va') >>> n1 = note.Note('D#4') >>> n2 = note.Note('E#4') >>> ottava.addSpannedElements([n1, n2]) >>> ottava.transposing = False >>> ottava.undoTransposition() >>> ottava.transposing True >>> n1.nameWithOctave 'D#3' NTrxr~rrrs rundoTranspositionzOttava.undoTranspositionsf*    ]]4]0 ((*A1i(YY J 5+r)rJrrTrrzt.Literal['above', 'below']r)rrrrrgr(r[rjr'rJrBrprur|rrrrs@rrLrL;s~?@F#%):A ' '# '8 ')6 Hh - DF V" $6B6rrLceZdZdZdZdZddddddd dfdZd Zd Ze eed Z d Z dZ e e e d Z dZdZe eed ZdZdZe eed ZdZdZe eed ZdZdZe eed ZxZS)Linea  A line or bracket represented as a spanner above two Notes. Brackets can take many line types. >>> b = spanner.Line() >>> b.lineType = 'dotted' >>> b.lineType 'dotted' >>> b = spanner.Line(endHeight=20) >>> b.endHeight 20 soliddasheddottedwavy)rrrcarrowbothnonerrcN)rtick startTickendTick startHeight endHeightc t ||i|d} | |_| |_d|_d|_d} | |_d} | |_|| k7r||_|| k7r||_ || k7r||_ || k7r||_ |||_ |||_ yy)NrcrrS)r'r(_endTick _startTick _endHeight _startHeight _lineTyperrrrrrr) r4rrrrrrr5r6 DEFAULT_TICKDEFAULT_LINE_TYPEDEFAULT_PLACEMENTr9s rr(z Line.__init__Ds /6X6 $ & #*#* ( ($DM  $&DN l ""DL < DI  &DN  "*D  #rc|jSrT)rr`s r _getEndTickzLine._getEndTickos }}rc|j|jvrtd||j|_yNnot a valid value: )rfvalidTickTypesrrr4r?s r _setEndTickzLine._setEndTickrs6 ;;= 3 3 3"%8#@A A  rz2 Get or set the endTick property. rEc|jSrTrr`s r _getStartTickzLine._getStartTick{ rc|j|jvrtd||j|_yr)rfrrrrs r _setStartTickzLine._setStartTick~s6 ;;= 3 3 3"%8#@A A++-rz4 Get or set the startTick property. c|jSrTrr`s r_getTickz Line._getTickrrc|j|jvrtd||j|_|j|_yr)rfrrrrrs r_setTickz Line._setTicksC ;;= 3 3 3"%8#@A A++-  rz Set the start and end tick to the same value >>> b = spanner.Line() >>> b.tick = 'arrow' >>> b.startTick 'arrow' >>> b.endTick 'arrow' c|jSrTrr`s r _getLineTypezLine._getLineType ~~rc|*|j|jvrtd|||j|_yyrrfvalidLineTypesrrrs r _setLineTypezLine._setLineTypesF  d6I6I!I"%8#@A A  "[[]DN ra Get or set the lineType property. Valid line types are listed in .validLineTypes. >>> b = spanner.Line() >>> b.lineType = 'dotted' >>> b.lineType = 'navyblue' Traceback (most recent call last): music21.spanner.SpannerException: not a valid value: navyblue >>> b.validLineTypes ('solid', 'dashed', 'dotted', 'wavy') c|jSrT)rr`s r _getEndHeightzLine._getEndHeightrrcbtj|r|dk\std|||_yNrr)rrrrrs r _setEndHeightzLine._setEndHeights. U# "%8#@A Arz Get or set the endHeight property. >>> b = spanner.Line() >>> b.endHeight = -20 Traceback (most recent call last): music21.spanner.SpannerException: not a valid value: -20 c|jSrT)rr`s r_getStartHeightzLine._getStartHeights   rcbtj|r|dk\std|||_yr)rrrrrs r_setStartHeightzLine._setStartHeights/ U# "%8#@A A!rz Get or set the startHeight property. >>> b = spanner.Line() >>> b.startHeight = None Traceback (most recent call last): music21.spanner.SpannerException: not a valid value: None ) rrrrrrrrrint | float | Nonerr)rrrrrrr(rrr'rrrrrrrrrrrrrrrrrrs@rrr3s% ;N>> gl = spanner.Glissando() >>> gl.lineType 'wavy' >>> print(gl.label) None >>> gl.label = 'gliss.' Note -- not a Line subclass for now, but that might change. r) chromatic continuousdiatonicwhiteblackrN)rlabelc~t||i|d}||_d|_d|_||k7r||_|||_yy)Nrr)r'r(r _slideTyperr)r4rrr5r6GLISSANDO_DEFAULT_LINE_TYPEr9s rr(zGlissando.__init__sV /6X6'-#4% 2 2$DM  DJ rc|jSrTrr`s rrzGlissando._getLineTyperrc|j|jvrtd||j|_yrrrs rrzGlissando._setLineType s6 ;;= 3 3 3"%8#@A ArzR Get or set the lineType property. See Line for valid line types. rEc|jS)a Get or set the slideType which determines how the glissando or slide is to be played. Values are 'chromatic' (default), 'continuous' (like a slide or smear), 'diatonic' (like a harp gliss), 'white' (meaning a white-key gliss as on a marimba), or 'black' (black-key gliss). 'continuous' slides export to MusicXML as a object. All others export as . )rr`s r slideTypezGlissando.slideType src|j|jvrtd||j|_yr)rfvalidSlideTypesrrrs rrzGlissando.slideType s6 ;;= 4 4 4"%8#@A A++-r)rrrrJ)rrrrrrr(rrr'rrr(rrs@rrrs";NOO"(#'!('  l9  H  ((rrceZdZdZdZdZdZdZdZdZ dZ d Z d Z d Z d Zd ZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZ dZ!d Z"y!)"Testc(ddlm}||_y)Nr)GeneralObjectExporter)music21.musicxml.m21ToXmlrGEX)r4rs rsetUpz Test.setUp$ sC(*rcZ|jj|}|jdS)Nzutf-8)rparsedecode)r4objxmlBytess rxmlStrz Test.xmlStr( s#88>>#&w''rc2ddlm}||ty)Nr) testCopyAll)music21.test.commonTestrglobals)r4rs rtestCopyAndDeepcopyzTest.testCopyAndDeepcopy, s7D')$rcddlm}ddlm}ddlm}|j}|j }|j }|j ||}|jd||jd||jd||jt|d|j|j||g|j}|j} |j} |j||j| |j| t} | j|| g|j| |jt|d|j| j|| g|j|j| gt} t} t}t!| | |g}|jt|jd|j|j| | |g|j| j|gy)NrrrV)layout)r)rrWrScorePart StaffGroupinsert assertEqualrcr<Noter.rr/getSpannerSitesr!)r4rrWrrp1p2sg1n1n2n3slur1sl1sl2sl3rs r testBasiczTest.testBasic0 s # " FLLN V[[] V[[]B' B B C Q# //1B8< YY[ YY[ YY[ "  "  "    "b* % Q# 113b"X> ++-w7fff c3_ % R2245q9 ..03S/B ,,.5rc2ddlm}ddlm}|j}|j t |d|j }|jd||j t |dd|_|j t |dy) Nrrrz*g?z&g@z*) r)rrrrr=rrr)r4rrsa1rbs rtestSpannerAnchorReprzTest.testSpannerAnchorReprc s"###% c$PQ FNN  c c$LM  c$PQrcfddlm}|j}|jt |dy)Nrrz)r)rrrr=)r4rsu1s rtestSpannerReprzTest.testSpannerReprt s%#lln c$<=rc~ddlm}ddlm}ddlm}|j d|j d|j d|j dg}|j |}|j |d|d }|j||d|d g}|jt|d t|jD]\}} |j| |||j|} d | _| j||jt|d t|jD]\}} |j| ||d | _| j||j| jd |jt| d t| jD]\}} |j| |||j} | j||jt| d|j dg} |j| } | j||jt| d|j| j| d|j d|j dg} |j| }|j||jt|d t|jD]\}} |j| | ||j d|j dg} |j| }|j||jt|d t|jD]\}} |j| | |y)NrrrVrABCDrr0TFErFG)r)rrWrrrr!rrrcrr<assertIsrLr3rnotes)r4rrWrtheNotesrbrnoFillElementsrelott1ott2expectedElementsott3ott4ott5s rtestSpannerFillzTest.testSpannerFilly s" #IIcNDIIcNDIIcNDIIcNS FNN8 $__Xa[(1+ 6  "1+x{3 R!$r4467EAr MM"nQ/ 08~~n-  !  R!$r4467EAr MM"nQ/ 08" !  d''. TA&t6689EAr MM"hqk *:~~ !  TA&!IIcN+~~./ !  TA& dmmo'7':;!IIcNAGGAJ7~~./ !  TA&t6689EAr MM".q1 2:GGAJ #7~~./ !  TA&t6689EAr MM".q1 2:rcddlm}ddlm}|j}d|_|j}d|_|j }|j ||j ||jt|d|j|d||j|d||j}|j}|j}|j ||j ||j t|} |jt| d|j| d||j| d|y)Nrrrrr0) r)rrrr0rr.rrcrrf) r4rrrsu2sbsu3su4rsb2s rtestSpannerBundlezTest.testSpannerBundle s#"lln lln  " " $ # # R!$ A$ A$llnlln FMMO    ##DG, S1% Q% Q%rcddlm}ddlm}|j}|j}t }|j ||g|j |j|g|j |j|gtj|}|j |j||g|j |j||g|j |j||g|j |j||g|j||g}tj|}|j |dj||g|j |dj||g|jt|dt|dy)NrrrV)r)rrWrrr/rrcopydeepcopyr<rassertNotEqualrm) r4rrWrrrrsb1rs rtestDeepcopySpannerzTest.testDeepcopySpanner su# YY[ YY[f Bx( ++-u5 ++-u5mmC  //1B8< //1B8< ++-Sz: ++-Sz:##S#J/mmC  Q224r2h? Q224r2h? Bs1vJ3q6 3rcddlm}ddlm}|j}|j}|j}|j}|j}|j }|j ||g|j |j||g|j |j|g|j|||j |j||g|j |jg|j |j|g|j|||j |j||g|j |jg|j |j|g|j } | j ||g|j } | j ||g|j} |j} |j|| | g} |j t| d|j t| || | g| j|| |j t| d|j t| || | g|j | dj|| g|j | dj| |g| j|| |j | dj| | g|j | dj| |gy)NrrVrrrr0) r)rWrrrr/rr<rrrrcrf)r4rWrrrrn4n5rrrn3an4ar%s rtestReplaceSpannedElementzTest.testReplaceSpannedElement s # YY[ YY[ YY[ YY[ YY[lln Bx( //1B8< ++-u5 !!"b) //1B8< ++-r2 ++-u5 !!"b) //1B8< ++-r2 ++-u5lln Bx(lln Bx(iikiik##S#sO4 S1% cS#sO4 !!"c* S1% cS#sO4 Q224r3i@ Q224sBi@ !!"c* Q224sCjA Q224sBi@rcddlm}ddlm}|j}|j |}|j ||j t|dy)Nrrrr)r)rrrr*r/rrc)r4rrm1rb1s rtestRepeatBracketAzTest.testRepeatBracketA+ sH#" V^^ ##B' r" S1%rcddlm}ddlm}ddlm}ddlm}|j }|j }|j|jdd|j||j }|j|jdd|j||j }|j|jd d|jd |_ |j||j|j|d |j } | j|jdd|jd | _ |j| |j|j| d |j } | j|jdd|jd | _ |j| |j|j| d |j } | j|jdd|j| |jt|jdy)NrrVrrbarc4r d#4g#4rA directionrr-a4r0b4rc#5)r)rWrrr3rr repeatAppendrr.Repeat rightBarliner*rrcr) r4rWrrr3rr.m2m3m4m5m6s rtestRepeatBracketBzTest.testRepeatBracketB5 s #" FKKM V^^   $+  V^^   %(!,  V^^   %(!,**u*5   &&r!&45 V^^   $+**u*5   &&r!&45 V^^   $+**u*5   &&r!&45 V^^   %(!,   QZZ!,rchddlm}ddlm}ddlm}ddlm}|j }|j }|j|jdd|j||j }|j|jdd|j||j }|j|jd d|jd |_ |j||jd } | j|||jt| d|j!d| |j } | j|jdd|jd | _ |j| |j|j| d |j } | j|jdd|j| |jt|j"d|j%|} |j'| j)dd |j'| j)dd |j'| j)dd y)NrrVrrr2r4r r5r6rAr7rr9r0r:r;"!")r)rWrrr3rrr=rr.r>r?r*r/rrcrrr assertGreaterfind) r4rWrrr3rr.r@rAr/rBrCraws rtestRepeatBracketCzTest.testRepeatBracketC] s #" FKKM V^^   $+  V^^   %(!,  V^^   %(!,**u*5  ##1#- r2& S1% C V^^   $+**u*5   &&r!&45 V^^   $+   QZZ!,kk!n 388$LMqQ 388$KLaP 388$LMqQrc ddlm}ddlm}ddlm}ddlm}|j }|j }|j|jdd|j||j }|j|jdd|j||j }|j|jd d|jd |_ |j||jd } | j|||jt| d|j!d| |j } | j|jdd|j| |j } | j|jdd|jd | _ |j| |jd } | j| | |jt| d|j!d| |j } | j|jdd|j| |j }|j|jdd|j||j }|j|jdd|jd |_ |j||jd }|j| ||jt|d|j!d||j }|j|jdd|j||j }|j|jdd|j||j }|j|jdd|j||j }|j|jdd|jd |_ |j||jd }|j|||||jt|d|j!d||jt|j#|j d|jt|j$d|j'|}|j)|j+dd |j)|j+dd |j)|j+dd t-j.|}|j'|}|j)|j+dd |j)|j+dd |j)|j+dd t-j.|}|j'|}|j)|j+dd |j)|j+dd |j)|j+dd y)NrrVrrr2r4r r5r6rAr7rr9r0r:r;r rGrHrI)r)rWrrr3rrr=rr.r>r?r*r/rrcrrhrrrJrKr"r#)r4rWrrr3rr.r@rAr/rBrCrb2rDm7m8rb3m9m10m11m12rb4rLrrs rtestRepeatBracketDzTest.testRepeatBracketD s# #" FKKM V^^   $+  V^^   %(!,  V^^   %(!,**u*5  ##1#- r2& S1% C V^^   $+  V^^   $+**u*5  ##1#- r2& S1% C V^^   $+  V^^   $+  V^^   $+**u*5  ##1#- r2& S1% C V^^   $+  fnn 4!,  fnn 4!,  fnn 4!,:::6  ##1#- r3S1 S1% C Q11&..ABBG QZZ!,kk!n 388$LMqQ 388$KLaP 388$LMqQ ]]1 kk"o 388$LMqQ 388$KLaP 388$LMqQ ]]2 kk"o 388$LMqQ 388$KLaP 388$LMqQrc\ddlm}ddlm}ddlm}ddlm}|j }|j d}|j|jdd|j||j d }|j|jd d|j||j d }|j|jd d|jd |_ |j||j|j|d|j d} | j|jdd|jd | _ |j| |j|j| d |j d} | j|jdd|jd | _ |j| |j|j| d |j d} | j|jdd|j| |jt|jd t!j"|} |jt| jd | j%|j d} | jd } |j'| j)| t!j"| }|jt|jd |j%|j d} |jd } |j'| j)| t!j"|}|jt|jd |j%|j d} |jd } |j'| j)| y)NrrVrrr2rr9r4r0r5rr6rAr7r r:r;r r<)r)rWrrr3rrr=rr.r>r?r*rrcrr"r#rh assertTruerr)r4rWrrr3rr.r@rArBrCrDrsp3rp3s rtestRepeatBracketEzTest.testRepeatBracketE s #" FKKM V^^1 %  $+  V^^1 %  %(!,  V^^1 %  %(!,**u*5   &&r!&45 V^^1 %  $+**u*5   &&r!&45 V^^1 %  $+**u*5   &&r!&45 V^^1 %  %(!,   QZZ!,]]1  R[[)1-  " "6>> 22 6kk!n --b12]]2  R[[)1-  " "6>> 22 6kk!n --b12 ]]2  R[[)1-  " "6>> 22 6kk!n --b12rc&ddlm}ddlm}ddlm}ddlm}|j }|j|jddgd|jd}|jd }|||}|j||j|} |j| jd d |j| jd d |j }|j|jd|jd}|jd }|||d}|j||j|} |j| jd d |j| jdd |j }|j|jd|jd}|jd }|||d}|j||j|} |j| jd d |j| jd d |j }|j|jd|jd}|jd }|||d}|j||j|} |j| jd d |j| jdd y)z} Test basic octave shift creation and output, as well as passing objects through make measure calls. rrrV)chord)rLzc-3g4rOru octave-shiftr0 type="down"rrNrJz type="up"rOrPN)r)rrWrbmusic21.spannerrLrr=Chordrr.rrcountr) r4rrWrbrLrrrsp1rLs rtestOttavaShiftAzTest.testOttavaShiftA- sb # !* FMMO u{{E4=126 WWQZ WWR[Rn  kk!n >2A6 =115 FMMO tyy{B' WWQZ WWR[R%(  kk!n >2A6 ;/3 FMMO tyy{B' WWQZ WWR[R&)  kk!n >2A6 =115 FMMO tyy{B' WWQZ WWR[R&)  kk!n >2A6 ;/3rcxddlm}ddlm}ddlm}|j}|j d}|j |}|j||j||j|}|j|jdd|j|jdd y ) z+ Test a single note octave rrrVrr4rdr0rerN) r)rrWrrrrLr.rrri)r4rrWrrrnrrLs rtestOttavaShiftBzTest.testOttavaShiftBc s # # FMMO IIdO ^^A     kk!n >2A6 =115rcjddlm}ddlm}ddlm}|j}|j |j dd|jd}d|j_ |jt|jd z}d |j_ |jd }d |j_ |j||}|j||} |j||j| |j|} |j| j!d dy)NrrrV)dynamicshalfrfr r r0r rur zgliss.<)r)rrWrrr=rrrrrrrr.rrri) r4rrWrrrrnrrrjrLs rtestGlissandoBzTest.testGlissandoB s" # FMMO tyy{B'agg&DAq KKQURZ($K 7'WWQZ WWQZB'    kk!n <0!4 #67; :.2rc0ddlm}ddlm}|j }|}|j |d|_|j|j |j|j||j|j|y)NrrVr!T) r)rWrgr!rr/r1r]rr)r4rWr!rrs rtestOneElementSpannerszTest.testOneElementSpanners sj + YY[ Y b!  ))*  2'  " &rcRddlm}ddlm}ddlm}m}|j }|j}|j}d|_d|_|jdd }|jd d } |jd||jd| |j||j|||| g} |jd| |D] } t| |s|j| "|jt|j dy) NrrrV)r!rrr0C#4wholerfD#4)r)rrWrgr!rrrr-rrr.r,rrrcr) r4rrWr!rrr.r@rrslr}s rtestRemoveSpannerszTest.testRemoveSpanners s" 1 FKKM V^^  V^^   YYu7Y + YYu7Y + !R !R    2r(^ BA!W%  QZZ!,rcddlm}ddlm}ddlm}ddlm}|j }|j}|j}d|_d|_|jdd }|jd d } |jd||jd| |j||j|||| g} |jd| |j|d } y)NrrrV converterrrr0rrrfrpickle)fmt) r)rrWrrgrrrr-rrr. freezeStr) r4rrWrrrr.r@rrr unused_datas rtestFreezeSpannerszTest.testFreezeSpanners0 s" %( FKKM V^^  V^^   YYu7Y + YYu7Y + !R !R    2r(^ B))!): rcddlm}ddlm}ddlm}|j d}|j d}|j }||||}tj|}|jt|jd|j|||j|d|d|j|d|d|j|d||j|d|y) NrrVclefrgf#rr0)r)rWrrgr!rAltoClefr"r#rrcr" assertIsNotr) r4rWrr!rrc1rjrss rtestDeepcopyJustSpannerAndNotesz$Test.testDeepcopyJustSpannerAndNotesE s  + YYs^ YYt_ ]]_b"b!mmC  S//0!4 c" c!fc!f% c!fc!f% c!fb! c!fb!rc\ddlm}ddlm}ddlm}ddlm}|j d}|j d}|j}||||}|j} | jd|tj| } | jd} |jt| jd |j!|| |j#| d|d|j#| d |d |j#|d||j#| d|y) NrrVrrrrrrr0)r)rWrrrgr!rrrrr"r#rrrcr"rr) r4rWrrr!rrrrjst1st2rss r#testDeepcopySpannerInStreamNotNotesz(Test.testDeepcopySpannerInStreamNotNotesW s  "+ YYs^ YYt_ ]]_b"b!fmmo 3mmC ll1o S//0!4 c" c!fc!f% c!fc!f% c!fb! c!fb!rcddlm}ddlm}ddlm}ddlm}|j d}|j d}|j}||||}|j} | jd|| jd |tj| } | jd} |jt| jd | jd} |j!|| |j#|| |j!| d |d |j!|d||j!| d|y) NrrVrrrrrr?rr0)r)rWrrrgr!rrrrr"r#rrrcrrr) r4rWrrr!rrrrjrrrrss r#testDeepcopyNotesInStreamNotSpannerz(Test.testDeepcopyNotesInStreamNotSpannern s  "+ YYs^ YYt_ ]]_b"b!fmmo 3 3mmC  YYq\ R//12A6  "1% c3 R  c!fc!f% c!fb! c!fb!rcddlm}ddlm}ddlm}|j d}|j d}|||}|j }|jd||jd||jd|tj|}|jd} |jt| jd | jd} |j|| |j|| |jd} |j!| | |j!|d||j!| d| y) NrrVrrG4zF#4rrr)r)rWrrgr!rrrr"r#rrrcrrrr) r4rWrr!rrrjrrrrsr^s r#testDeepcopyNotesAndSpannerInStreamz(Test.testDeepcopyNotesAndSpannerInStream s "+ YYt_ YYu b"ofmmo 3 3 3mmC  YYq\ R//12A6  "1% c" R ll1o c3 c!fb! c!fb!rcddlm}ddlm}ddlm}|j }||f}|j }|jd||jd||j|jdj||j|jdjd|tj|}|jd}|jd} |j|||j| ||j|jdj| |j|jdjd||j|jdjd||j!t#|j$d|j$j'| } |j!t#| dy)NrrVrrrr)r)rWrrgrrrrrrrrrr"r#rrrc spannerBundler) r4rWrrrrrs2rrtn2s rtestDeepcopyStreamWithSpannersz#Test.testDeepcopyStreamWithSpanners s "( YY[B5k FMMO c b ajjm,,.3 aggaj00215s; ]]1 kk!n XXa[ c" R  bkk!n--/4 bhhqk113A6< 335a8#> R--.22226 S1%rcddlm}ddlm}|j d}|j d}|j d}|j d}|j d}|}|j ||j |||j ||g|||||fD cgc] } t | } } |j} |j| | ycc} w) NrrVrrrrzd-r@) r)rWrgr!rr/rmror) r4rWr!rrrr(r)rrnidListslLists rtestGetSpannedElementIdszTest.testGetSpannedElementIds s + YYs^ YYt_ YYs^ YYt_ YYs^ Y b! b"% r2h'"$b"b"!56!5A"Q%!56((* (7s(Ccrddlm}ddlm}|j |j }t |jjd}t |jjd}|j|d|j|d|jjdd}|jd}|jd}|j|jd||j|jd||jjdd} | jd} | jd} |j| jd| |j| jd| y)Nrr) testPrimitiveHammerOnPullOffr) r)rmusic21.musicxmlrr notations32arcflattenrhrr<r) r4rrr num_hammer_on num_pull_off hammer_on hammer_n0 hammer_n1pull_offpull_n0pull_n1s rtestHammerOnPullOffzTest.testHammerOnPullOff sl%2 OOM66 7AIIK:::FG 199;99)DE  * q)IIK22:>qA 00215 00215  224Q7C 224Q7C99;11) <3|&44<:Ax&%-P*RZbRH=3~44l6""1L3(:6=43T '-.;*"$"."2"2&2)$Arrz list[type] _DOC_ORDER__main__)2r __future__rcollections.abcrrr" dataclassesrtypingrGunittestr)rrmusic21.common.numberToolsr music21.common.typesr r r r rrrrr Environment environLocalMusic21Exceptionrrr-r!rrProtoM21Objectrrrr*rLrrTestCaserrrrmainTestrrrrsu#. !-) ??&{&&y1  |44  \:: q d  q j $(((8,D&&8,vg G**g V 7 &B,wB,P~-G~-Ht6Wt6p` 7` FG(G(X~A8  ~AF" J" zGTr