§
    ƒØjTi ã                  ó€  — d Z ddlmZ ddlmZ ddlZddlZddlZddlZddl	Z	ddl
ZddlZddlmZmZmZ ddlZddlmZ ddlmZ ddlmZ dd	lmZ dd
lmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlm Z  ddlm!Z! ddlm"Z" ddlm#Z# ddlm$Z$ ddlm%Z% ddlm&Z& ddlm'Z' ddlm(Z( ddlm)Z) ddlm*Z* ddlm+Z+ ddlm,Z, ddlm-Z- ddlm.Z. dd l/m0Z0 dd!lm1Z1 dd"lm2Z2 dd#lm3Z3 dd$lm4Z4 dd%l5m6Z6 dd&l7m8Z8 dd'l5m9Z9 dd(l:m;Z; dd)l:m<Z<  e j=        d*¦  «        Z>e6j?        Z@e6jA        ZBejC        rdd+lDmEZE dd,lmFZF dd-lmGZG dRd1„ZHdSd3„ZIdTd7„ZJ	 dUdd8d9œdVdF„ZK G dG„ dH¦  «        ZL G dI„ dJ¦  «        ZM G dK„ dLeMe8¦  «        ZN G dM„ dNeM¦  «        ZO G dO„ dPeM¦  «        ZPeQdQk    rddlZ ejR        ¦   «          dS dS )Wz>
Converters for music21 objects to musicxml using ElementTree
é    )Úannotations)ÚOrderedDictN)ÚElementÚ
SubElementÚComment)Úarticulations)Úbase)Úbar)Úclef)Úchord)Úcommon)ÚAppendSpanners)ÚopFrac)Údefaults©Úduration)Údynamics)Úenvironment)Úexceptions21)Úexpressions)Úharmony)Ú
instrument)Úkey)Úlayout)Úmetadata)Únote)Úmeter)Úpitch)Úprebase)Úrepeat)Úspanner)Ústream)ÚOffsetIterator)Ústyle)Útempo)Útext)Útie)Úhelpers)ÚPartStaffExporterMixin)Ú
xmlObjects©ÚMusicXMLExportException)ÚMusicXMLWarningzmusicxml.m21ToXml)ÚOffsetQL)Úroman)Ú	tablatureÚvalueÚstrÚreturnc                óè   — | dk    rdS | dk    rt          d¦  «        ‚| dk    rt          d¦  «        ‚| dk    rt          d¦  «        ‚| d	k    rt          d
¦  «        ‚| dk    rt          d¦  «        ‚| S )ac  
    Convert a music21 type to a MusicXML type or raise a MusicXMLExportException

    >>> musicxml.m21ToXml.typeToMusicXMLType('longa')
    'long'
    >>> musicxml.m21ToXml.typeToMusicXMLType('quarter')
    'quarter'
    >>> musicxml.m21ToXml.typeToMusicXMLType('duplex-maxima')
    Traceback (most recent call last):
    music21.musicxml.xmlObjects.MusicXMLExportException:
    Cannot convert "duplex-maxima" duration to MusicXML (too long).
    >>> musicxml.m21ToXml.typeToMusicXMLType('inexpressible')
    Traceback (most recent call last):
    music21.musicxml.xmlObjects.MusicXMLExportException:
    Cannot convert inexpressible durations to MusicXML.
    >>> musicxml.m21ToXml.typeToMusicXMLType('zero')
    Traceback (most recent call last):
    music21.musicxml.xmlObjects.MusicXMLExportException:
    Cannot convert durations without types to MusicXML.
    ÚlongaÚlongÚ2048thz9Cannot convert "2048th" duration to MusicXML (too short).zduplex-maximaz?Cannot convert "duplex-maxima" duration to MusicXML (too long).Úinexpressiblez3Cannot convert inexpressible durations to MusicXML.ÚcomplexzyCannot convert complex durations to MusicXML. Try exporting with makeNotation=True or manually running splitAtDurations()Úzeroz3Cannot convert durations without types to MusicXML.r+   )r1   s    úŽ/Users/tedpeters/Documents/Projects/Claude Projects/Misc Tools/notename-sheets/.venv/lib/python3.11/site-packages/music21/musicxml/m21ToXml.pyÚtypeToMusicXMLTyper<   T   s°   € ð, �ÒÐØˆvØ	�(Ò	Ð	Ý%Ð&aÑbÔbÐbØ	�/Ò	!Ð	!Ý%ØMñOô Oð 	Oà	�/Ò	!Ð	!Ý%Ð&[Ñ\Ô\Ð\Ø	�)Ò	Ð	Ý%ð\ñ]ô ]ð 	]ð 
�&ŠˆÝ%Ð&[Ñ\Ô\Ð\àˆó    Úcolorc                ó†   — | sdS d| vr&t          j        | ¦  «                             ¦   «         S |                      ¦   «         S )zî
    Normalize a css3 name to hex or leave it alone.

    >>> musicxml.m21ToXml.normalizeColor('')
    ''
    >>> musicxml.m21ToXml.normalizeColor('red')
    '#FF0000'
    >>> musicxml.m21ToXml.normalizeColor('#00ff00')
    '#00FF00'
    Ú ú#)Ú	webcolorsÚname_to_hexÚupper)r>   s    r;   ÚnormalizeColorrE   }   sG   € ð ð ØˆrØ
�%ÐÐÝÔ$ UÑ+Ô+×1Ò1Ñ3Ô3Ð3à�{Š{‰}Œ}Ðr=   Úsústream.Streamúmetadata.Metadata | Nonec                ó~   — | j         }|�|S |                      ¦   «         D ]}|j        j         �|j        j         c S ŒdS )a:  
    Get metadata from site or context, so that a Part
    can be shown and have the rich metadata of its Score

    >>> s = stream.Score()
    >>> s2 = s.transpose(4)
    >>> md = metadata.Metadata()
    >>> md.title = 'emptiness'
    >>> s.metadata = md
    >>> s2.metadata is None
    True
    >>> musicxml.m21ToXml.getMetadataFromContext(s2).title
    'emptiness'
    >>> musicxml.m21ToXml.getMetadataFromContext(s).title
    'emptiness'
    >>> p = stream.Part()
    >>> s2.insert(0, p)
    >>> musicxml.m21ToXml.getMetadataFromContext(p).title
    'emptiness'
    N)r   ÚcontextSitesÚsite)rF   ÚmdÚcontextSites      r;   ÚgetMetadataFromContextrN   �   sV   € ð. 
Œ€BØ	€~Øˆ	à—~’~Ñ'Ô'ð -ð -ˆØÔÔ$Ð0ØÔ#Ô,Ð,Ð,Ð,ð 1àˆ4r=   F)Ú	transformÚ
forceEmptyÚm21Elút.AnyÚxmlElr   ÚtagÚattributeNameú
str | NonerO   ú!t.Callable[[t.Any], t.Any] | NonerP   ÚboolúElement | Nonec               óò   — |€t          j        |¦  «        }	 t          | |¦  «        }n# t          $ r Y dS w xY w|� ||¦  «        }|dv r|durdS t	          ||¦  «        }|�t          |¦  «        |_        |S )aŒ  
    If m21El has an attribute called attributeName, create a new SubElement
    for xmlEl and set its text to the value of the m21El attribute.

    Pass a function or lambda function as transform to transform the
    value before setting it.  String transformation is assumed.

    Returns the SubElement

    Will not create an empty element unless forceEmpty is True

    >>> from xml.etree.ElementTree import Element
    >>> e = Element('accidental')

    >>> seta = musicxml.m21ToXml._setTagTextFromAttribute
    >>> acc = pitch.Accidental()
    >>> acc.alter = -2.0

    >>> subEl = seta(acc, e, 'alter')
    >>> subEl.text
    '-2.0'
    >>> subEl in e
    True

    >>> XB = musicxml.m21ToXml.XMLExporterBase()
    >>> XB.dump(e)
    <accidental>
      <alter>-2.0</alter>
    </accidental>

    add a transform

    >>> subEl = seta(acc, e, 'alter', transform=int)
    >>> subEl.text
    '-2'

    N©Nr@   T)r   ÚhyphenToCamelCaseÚgetattrÚAttributeErrorr   r2   r&   )rQ   rS   rT   rU   rO   rP   r1   Ú
subElements           r;   Ú_setTagTextFromAttributer`   ±   s¬   € ð\ ÐÝÔ0°Ñ5Ô5ˆðÝ˜˜}Ñ-Ô-ˆˆøÝð ð ð Øˆtˆtðøøøð ÐØ�	˜%Ñ Ô ˆà�
ÐÐ˜z°Ð5Ð5Øˆtå˜E 3Ñ'Ô'€JàÐÝ˜e™*œ*ˆ
ŒàÐs   ˜) ©
7¶7c                  óš   — e Zd ZdZ eg d¢¦  «        Zddd„Zddd	„Zd d„Zd!d„Z	d„ Z
d„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd"d„ZdS )#ÚGeneralObjectExporterzt
    Packs any `Music21Object` into a well-formed score and exports
    a bytes object MusicXML representation.
    ))ÚScoreÚ	fromScore)ÚPartÚfromPart)ÚMeasureÚfromMeasure)ÚVoiceÚ	fromVoice)ÚStreamÚ
fromStream)ÚGeneralNoteÚfromGeneralNote)ÚPitchÚ	fromPitch)ÚDurationÚfromDuration)ÚDynamicÚfromDynamic)ÚDiatonicScaleÚfromDiatonicScale)ÚScaleÚ	fromScale)ÚMusic21ObjectÚfromMusic21ObjectNÚobjúprebase.ProtoM21Object | Nonec                ó"   — || _         d| _        d S ©NT)Ú
generalObjÚmakeNotation)Úselfr{   s     r;   Ú__init__zGeneralObjectExporter.__init__
  s   € ØˆŒØ"&ˆÔÐÐr=   r3   Úbytesc                ó  — |€| j         }|€t          d¦  «        ‚| j        r*|                      |¦  «        }|                      |¦  «        S t          |t          j        ¦  «        st          d¦  «        ‚|                      |¦  «        S )a5
  
        Return a bytes object representation of anything from a
        Score to a single pitch.

        When :attr:`makeNotation` is True (default), wraps `obj` in a well-formed
        `Score`, makes a copy, and runs :meth:`~music21.stream.base.Stream.makeNotation`
        on each of the parts. To skip copying and making notation, set `.makeNotation`
        on this instance to False.

        >>> p = pitch.Pitch('D#4')
        >>> GEX = musicxml.m21ToXml.GeneralObjectExporter(p)
        >>> out = GEX.parse()  # out is bytes
        >>> outStr = out.decode('utf-8')  # now is string
        >>> print(outStr.strip())
        <?xml version="1.0" encoding="utf-8"?>
        <!DOCTYPE score-partwise
          PUBLIC "-//Recordare//DTD MusicXML ... Partwise//EN"
          "http://www.musicxml.org/dtds/partwise.dtd">
        <score-partwise version="...">
          <movement-title>Music21 Fragment</movement-title>
          <identification>
            <creator type="composer">Music21</creator>
            <encoding>
              <encoding-date>...</encoding-date>
              <software>music21 v...</software>
              <supports element="beam" type="yes" />
              <supports element="stem" type="yes" />
              <supports element="accidental" type="yes" />
            </encoding>
          </identification>
          <defaults>
            <scaling>
              <millimeters>7</millimeters>
              <tenths>40</tenths>
            </scaling>
          </defaults>
          <part-list>
            <score-part id="...">
              <part-name />
            </score-part>
          </part-list>
          <!--=========================== Part 1 ===========================-->
          <part id="...">
            <!--========================= Measure 1 ==========================-->
            <measure implicit="no" number="1">
              <attributes>
                <divisions>10080</divisions>
                <time>
                  <beats>1</beats>
                  <beat-type>4</beat-type>
                </time>
                <clef>
                  <sign>G</sign>
                  <line>2</line>
                </clef>
              </attributes>
              <note>
                <pitch>
                  <step>D</step>
                  <alter>1</alter>
                  <octave>4</octave>
                </pitch>
                <duration>10080</duration>
                <type>quarter</type>
                <accidental>sharp</accidental>
              </note>
            </measure>
          </part>
        </score-partwise>
        NzMust have an object to exportz.Can only export Scores with makeNotation=False)r   r,   r€   ÚfromGeneralObjectÚparseWellformedObjectÚ
isinstancer"   rc   )r�   r{   ÚoutObjs      r;   ÚparsezGeneralObjectExporter.parse  s�   € ðN ˆ;Ø”/ˆCØˆ;Ý)Ð*IÑJÔJÐJàÔð 	3Ø×+Ò+¨CÑ0Ô0ˆFØ×-Ò-¨fÑ5Ô5Ð5å˜c¥6¤<Ñ0Ô0ð `Ý-Ð.^Ñ_Ô_Ð_Ø×-Ò-¨cÑ2Ô2Ð2r=   Úscústream.Scorec                ó~   — t          || j        ¬¦  «        }|                     ¦   «          |                     ¦   «         S )a  
        Parse an object that has already gone through the
        `.fromGeneralObject` conversion, which has produced a copy with
        :meth:`~music21.stream.Score.makeNotation` run on it
        (unless :attr:`makeNotation` is False).

        Returns bytes.
        )r€   )ÚScoreExporterr€   r‰   ÚasBytes)r�   rŠ   ÚscoreExporters      r;   r†   z+GeneralObjectExporter.parseWellformedObjectb  s=   € õ & b°tÔ7HÐIÑIÔIˆØ×ÒÑÔÐØ×$Ò$Ñ&Ô&Ð&r=   úprebase.ProtoM21Objectc                óP  — |j         }d}t          |t          j        ¦  «        r(| j        r!|                     d|j        gdddd¬¦  «        }| j                             ¦   «         D ]&\  }}||v rt          | |¦  «        } ||¦  «        } nŒ'|€t          d| j        › d�¦  «        ‚|S )a  
        Converts any Music21Object (or a duration or a pitch) to something that
        can be passed to :class:`ScoreExporter`.

        >>> GEX = musicxml.m21ToXml.GeneralObjectExporter()
        >>> s = GEX.fromGeneralObject(duration.Duration(3.0))
        >>> s
        <music21.stream.Score 0x...>
        >>> s.show('t')
        {0.0} <music21.stream.Part 0x...>
            {0.0} <music21.stream.Measure 1 offset=0.0>
                {0.0} <music21.clef.TrebleClef>
                {0.0} <music21.meter.TimeSignature 6/8>
                {0.0} <music21.note.Note C>
                {3.0} <music21.bar.Barline type=final>
        >>> s[note.NotRest].first().duration
        <music21.duration.Duration 3.0>

        * Changed in v8: fills gaps with rests before calling makeNotation
          to avoid duplicating effort with :meth:`PartExporter.fixupNotationMeasured`.

        >>> v = stream.Voice(note.Note())
        >>> m = stream.Measure([meter.TimeSignature(), v])
        >>> GEX = musicxml.m21ToXml.GeneralObjectExporter(m)
        >>> out = GEX.parse()  # out is bytes
        >>> outStr = out.decode('utf-8')  # now is string
        >>> '<note print-object="no" print-spacing="yes">' in outStr
        True
        >>> len(v[note.Rest])  # original stream unchanged
        0
        Nç        TF)ÚrefStreamOrTimeRangeÚfillGapsÚinPlaceÚ	hideRestsÚtimeRangeFromBarDurationzCannot translate the object z; to a complete musicXML document; put it in a Stream first!)Úclassesr‡   r"   rk   r€   Ú	makeRestsÚhighestTimeÚclassMappingÚitemsr]   r,   r   )r�   r{   r˜   rˆ   ÚcMÚmethNameÚmeths          r;   r…   z'GeneralObjectExporter.fromGeneralObjecto  sì   € ð@ ”+ˆØˆå�c�6œ=Ñ)Ô)ð 	"¨dÔ.?ð 	"à—-’-°c¸3¼?Ð5KØ)-Ø(-Ø*.Ø9=ð	  ñ "ô "ˆCð !Ô-×3Ò3Ñ5Ô5ð 	ð 	‰LˆB�Ø�Wˆ}ˆ}Ý˜t XÑ.Ô.�Ø˜˜c™œ�Ø�ð ð ˆ>Ý)ð`Ø”?ð`ð `ð `ñô ð ð ˆr=   c                ó¦   — | j         r|                      d¬¦  «         |                     ¦   «         st          j        |› d�t          d¬¦  «         |S )zN
        Runs :meth:`~music21.stream.Score.makeNotation` on the copy.
        T©r•   z/ is not well-formed; see isWellFormedNotation()é   )ÚcategoryÚ
stacklevel)r€   ÚisWellFormedNotationÚwarningsÚwarnr-   )r�   rŠ   s     r;   rd   zGeneralObjectExporter.fromScore§  si   € ð Ôð 	*Ø�OŠO DˆOÑ)Ô)Ð)Ø×&Ò&Ñ(Ô(ð 	ÝŒMØÐFÐFÐFÝ(Øðñ ô ð ð ˆ	r=   c                ó  — |j         r|                     d¬¦  «         t          j        ¦   «         }|                     d|¦  «         t          j        t          |¦  «        ¦  «        |_        |  	                    |¦  «        S )z5
        From a part, put it in a new score.
        Tr¡   r   )
ÚisFlatÚmakeMeasuresr"   rc   ÚinsertÚcopyÚdeepcopyrN   r   rd   )r�   ÚprŠ   s      r;   rf   zGeneralObjectExporter.fromPart¶  sj   € ð Œ8ð 	)Ø�NŠN 4ˆNÑ(Ô(Ð(åŒ\‰^Œ^ˆØ
�	Š	�!�Q‰ŒˆÝ”mÕ$:¸1Ñ$=Ô$=Ñ>Ô>ˆŒØ�~Š~˜bÑ!Ô!Ð!r=   c                ór  — |                      ¦   «          |                     d¬¦  «         |j        j        €d|j        _        |                     t
          j        t          j        j	        j
        ¬¦  «        }|€t          j        |d¬¦  «        |_        n||_        t          j        ¦   «         }|                     |¦  «         t          j        t#          |¦  «        ¦  «        |_        |                     t          j        ¦  «        }|�|j        |_        |j        |_        |                      |¦  «        S )a  
        Translate a music21 Measure into a
        complete MusicXML string representation.

        Note: this method is called for complete MusicXML
        representation of a Measure, not for partial
        solutions in Part or Stream production.
        Tr¡   NÚmeasure)ÚgetElementMethod©Úrecurse)ÚcoreGatherMissingSpannersr€   r$   ÚmeasureNumberingÚgetContextByClassr   ÚClefr   ÚenumsÚElementSearchÚAT_OR_BEFORE_OFFSETÚbestClefr"   re   Úappendr¬   r­   rN   r   ÚpartNameÚpartAbbreviationrf   )r�   ÚmÚ"clef_from_measure_start_or_contextr®   Úcontext_parts        r;   rh   z!GeneralObjectExporter.fromMeasureÂ  s  € ð 	
×#Ò#Ñ%Ô%Ð%Ø	�Š˜tˆÑ$Ô$Ð$ØŒ7Ô#Ð+à'0ˆAŒGÔ$Ø-.×-@Ò-@ÝŒIÝ#œ\Ô7ÔKð .Añ .
ô .
Ð*ð .Ð5Ý”] 1¨dÐ3Ñ3Ô3ˆAŒFˆFà7ˆAŒFÝŒK‰MŒMˆØ	�Š�‰ŒˆÝ”]Õ#9¸!Ñ#<Ô#<Ñ=Ô=ˆŒ
Ø×*Ò*­6¬;Ñ7Ô7ˆØÐ#Ø%Ô.ˆAŒJØ!-Ô!>ˆAÔØ�}Š}˜QÑÔÐr=   c                ó‚   — t          j        d¬¦  «        }|                     d|¦  «         |                      |¦  «        S )Né   ©Únumberr   )r"   rg   r«   rh   )r�   Úvr¿   s      r;   rj   zGeneralObjectExporter.fromVoiceá  s9   € ÝŒN !Ð$Ñ$Ô$ˆØ	�Š��A‰ŒˆØ×Ò Ñ"Ô"Ð"r=   c                óÜ  — |j         rÝt          j        ¦   «         }|                     |¦  «         t	          j        |¦  «        |_        |                     t          j	        ¦  «         
                    d¦  «        st          j        |¦  «        |_        |                     d¬¦  «         t	          j        t          |¦  «        ¦  «        |_        |                      |¦  «        S |                     ¦   «         r’t          j        ¦   «         }|                     |¦  «         t	          j        |¦  «        |_        |                     d¬¦  «         t	          j        t          |¦  «        ¦  «        |_        |                      |¦  «        S |                     t          j        ¦  «                             ¦   «         j         rÊt          j        ¦   «         }|                     |¦  «         t	          j        |¦  «        |_        |                     t          j	        ¦  «         
                    d¦  «        sd}nd}|                     d|¬¦  «         t	          j        t          |¦  «        ¦  «        |_        |                      |¦  «        S |                     t          j	        ¦  «         
                    d¦  «        sd}nd}|                     d|¬¦  «        }|                      |¦  «        S )Nr’   Tr¡   F)r•   r»   )r©   r"   re   ÚmergeAttributesr¬   r­   ÚelementsÚgetElementsByClassr   r·   ÚgetElementsByOffsetr»   r€   rN   r   rf   ÚhasPartLikeStreamsrc   rd   rk   Úfirst)r�   ÚstÚst2r»   s       r;   rl   z GeneralObjectExporter.fromStreamæ  sf  € ØŒ9ð %	'Ý”+‘-”-ˆCØ×Ò Ñ#Ô#Ð#Ýœ=¨Ñ,Ô,ˆCŒLØ×(Ò(­¬Ñ3Ô3×GÒGÈÑLÔLð .Ýœ=¨Ñ-Ô-�”Ø×Ò TÐÑ*Ô*Ð*Ýœ=Õ)?ÀÑ)CÔ)CÑDÔDˆCŒLØ—=’= Ñ%Ô%Ð%à×"Ò"Ñ$Ô$ð 	'Ý”,‘.”.ˆCØ×Ò Ñ#Ô#Ð#Ýœ=¨Ñ,Ô,ˆCŒLØ×Ò TÐÑ*Ô*Ð*Ýœ=Õ)?ÀÑ)CÔ)CÑDÔDˆCŒLØ—>’> #Ñ&Ô&Ð&à×"Ò"¥6¤=Ñ1Ô1×7Ò7Ñ9Ô9Ô@ð 	'Ý”+‘-”-ˆCØ×Ò Ñ#Ô#Ð#Ýœ=¨Ñ,Ô,ˆCŒLØ×(Ò(­¬Ñ3Ô3×GÒGÈÑLÔLð !Ø��à �Ø×Ò T°HÐÑ=Ô=Ð=Ýœ=Õ)?ÀÑ)CÔ)CÑDÔDˆCŒLØ—=’= Ñ%Ô%Ð%ð ×(Ò(­¬Ñ3Ô3×GÒGÈÑLÔLð !Ø��à �Ø—/’/¨%¸(�/ÑCÔCˆCØ—>’> #Ñ&Ô&Ð&r=   c                óˆ   — t          j        |¦  «        }t          j        ¦   «         }||_        |                      |¦  «        S )zÇ
        Translate a music21 :class:`~music21.duration.Duration` into
        a complete MusicXML representation.

        Rarely, rarely used.  Only if you call .show() on a duration object
        )r¬   r­   r   ÚNoter   rn   )r�   ÚdÚdCopyÚns       r;   rr   z"GeneralObjectExporter.fromDuration  s9   € õ ”˜aÑ Ô ˆÝŒI‰KŒKˆØˆŒ
à×#Ò# AÑ&Ô&Ð&r=   c                ó¤   — t          j        |¦  «        }t          j        ¦   «         }|                     |¦  «         |                      |¦  «        S )zv
        Provide a complete MusicXML string from a single dynamic by
        putting it into a Stream first.

        )r¬   r­   r"   rk   r¼   rl   )r�   ÚdynamicObjectrÓ   Úouts       r;   rt   z!GeneralObjectExporter.fromDynamic  sB   € õ ”˜mÑ,Ô,ˆÝŒm‰oŒoˆØ�
Š
�5ÑÔÐà�Š˜sÑ#Ô#Ð#r=   c                ó  — t          j        d¬¦  «        }t          d|j                             ¦   «         dz   ¦  «        D ]—}|                     |¦  «        }t          j        ¦   «         }||_        |dk    r| 	                    |j
        ¦  «         |j
        |                     ¦   «         j
        k    rd|_        nd|_        |                     |¦  «         Œ˜|                     ¦   «         |_        |                      |¦  «        S )ai  
        Generate the pitches from this scale
        and put it into a stream.Measure, then call
        fromMeasure on it.

        >>> cMaj = scale.MajorScale('C')
        >>> GEX = musicxml.m21ToXml.GeneralObjectExporter()
        >>> m = GEX.fromScale(cMaj)
        >>> m
        <music21.stream.Score 0x11d4f17b8>

        >>> m.show('text')
        {0.0} <music21.stream.Part 0x116a04b38>
            {0.0} <music21.stream.Measure 1 offset=0.0>
                {0.0} <music21.clef.TrebleClef>
                {0.0} <music21.meter.TimeSignature 10/4>
                {0.0} <music21.note.Note C>
                {4.0} <music21.note.Note D>
                {5.0} <music21.note.Note E>
                {6.0} <music21.note.Note F>
                {7.0} <music21.note.Note G>
                {8.0} <music21.note.Note A>
                {9.0} <music21.note.Note B>
        rÃ   rÄ   é   )r"   rg   ÚrangeÚabstractÚgetDegreeMaxUniqueÚpitchFromDegreer   rÑ   r   ÚaddLyricÚnameÚgetTonicÚquarterLengthr¼   ÚbestTimeSignatureÚtimeSignaturerh   )r�   ÚscaleObjectr¿   Úir®   rÔ   s         r;   rx   zGeneralObjectExporter.fromScale*  sê   € õ4 ŒN !Ð$Ñ$Ô$ˆÝ�q˜+Ô.×AÒAÑCÔCÀaÑGÑHÔHð 	ð 	ˆAØ×+Ò+¨AÑ.Ô.ˆAÝ”	‘”ˆAØˆAŒGØ�AŠvˆvØ—
’
˜;Ô+Ñ,Ô,Ð,àŒv˜×-Ò-Ñ/Ô/Ô4Ò4Ð4Ø"#�”�à"#�”Ø�HŠH�Q‰KŒKˆKˆKØ×-Ò-Ñ/Ô/ˆŒØ×Ò Ñ"Ô"Ð"r=   c                ó`  — t          j        d¬¦  «        }t          d|j                             ¦   «         dz   ¦  «        D ]Á}|                     |¦  «        }t          j        ¦   «         }||_        |dk    r| 	                    |j
        ¦  «         |j
        |                     ¦   «         j
        k    rd|_        n1|j
        |                     ¦   «         j
        k    rd|_        nd|_        |                     |¦  «         ŒÂ|                     ¦   «         |_        |                      |¦  «        S )a‰  
        Return a complete musicxml of the DiatonicScale

        Overrides the general scale behavior to highlight
        the tonic and dominant.

        >>> cMaj = scale.MajorScale('C')
        >>> GEX = musicxml.m21ToXml.GeneralObjectExporter()
        >>> m = GEX.fromDiatonicScale(cMaj)
        >>> m
        <music21.stream.Score 0x11d4f17b8>

        >>> m.show('text')
        {0.0} <music21.stream.Part 0x116a04b38>
            {0.0} <music21.stream.Measure 1 offset=0.0>
                {0.0} <music21.clef.TrebleClef>
                {0.0} <music21.meter.TimeSignature 11/4>
                {0.0} <music21.note.Note C>
                {4.0} <music21.note.Note D>
                {5.0} <music21.note.Note E>
                {6.0} <music21.note.Note F>
                {7.0} <music21.note.Note G>
                {9.0} <music21.note.Note A>
                {10.0} <music21.note.Note B>
        rÃ   rÄ   rÙ   r¢   )r"   rg   rÚ   rÛ   rÜ   rÝ   r   rÑ   r   rÞ   rß   rà   rá   ÚgetDominantr¼   râ   rã   rh   )r�   ÚdiatonicScaleObjectr¿   rå   r®   rÔ   s         r;   rv   z'GeneralObjectExporter.fromDiatonicScaleT  s  € õ6 ŒN !Ð$Ñ$Ô$ˆÝ�qÐ-Ô6×IÒIÑKÔKÈaÑOÑPÔPð 	ð 	ˆAØ#×3Ò3°AÑ6Ô6ˆAÝ”	‘”ˆAØˆAŒGØ�AŠvˆvØ—
’
Ð.Ô3Ñ4Ô4Ð4àŒvÐ,×5Ò5Ñ7Ô7Ô<Ò<Ð<Ø"#�”�Ø”Ð.×:Ò:Ñ<Ô<ÔAÒAÐAØ"#�”�à"#�”Ø�HŠH�Q‰KŒKˆKˆKØ×-Ò-Ñ/Ô/ˆŒØ×Ò Ñ"Ô"Ð"r=   c                ó¨   — t          j        |¦  «        }t          j        d¬¦  «        }|                     |¦  «         |                      |¦  «        S )zF
        return a single TimeSignature as a musicxml document
        rÃ   rÄ   )r¬   r­   r"   rg   r¼   rh   )r�   r{   ÚobjCopyr×   s       r;   rz   z'GeneralObjectExporter.fromMusic21Object�  sM   € õ
 ”- Ñ$Ô$ˆõ Œn AÐ&Ñ&Ô&ˆØ�
Š
�7ÑÔÐØ×Ò Ñ$Ô$Ð$r=   c                óŠ  — t          j        |¦  «        }t          j        |¦  «        }d|j        cxk     rdk    r+n n(|                     dt          j        |¦  «        ¦  «         t          j         	                    |dd|j        g¬¦  «         t          j         
                    |d¬¦  «         |                      |¦  «        S )aA  
        Translate a music21 :class:`~music21.note.Note` into an object
        ready to be parsed.

        An attempt is made to find the best TimeSignature for quarterLengths
        <= 6:

        >>> n = note.Note('c3')
        >>> n.quarterLength = 3
        >>> GEX = musicxml.m21ToXml.GeneralObjectExporter()
        >>> sc = GEX.fromGeneralNote(n)
        >>> sc.show('t')
        {0.0} <music21.stream.Part 0x1046afa90>
            {0.0} <music21.stream.Measure 1 offset=0.0>
                {0.0} <music21.clef.BassClef>
                {0.0} <music21.meter.TimeSignature 6/8>
                {0.0} <music21.note.Note C>
                {3.0} <music21.bar.Barline type=final>

        But longer notes will be broken into tied components placed in
        4/4 measures:

        >>> long_note = note.Note('e5', quarterLength=40)
        >>> GEX = musicxml.m21ToXml.GeneralObjectExporter()
        >>> sc = GEX.fromGeneralNote(long_note)
        >>> sc[meter.TimeSignature].first()
        <music21.meter.TimeSignature 4/4>
        >>> len(sc[stream.Measure])
        10
        r   g      @T)r•   r“   r¡   )r¬   r­   r"   re   rá   r«   r   râ   r€   rª   ÚmakeTupletBracketsrf   )r�   rÔ   ÚnCopyÚnew_parts       r;   rn   z%GeneralObjectExporter.fromGeneralNoteŽ  sÇ   € õD ”˜aÑ Ô ˆÝ”;˜uÑ%Ô%ˆØˆqŒÐ%Ð%Ò%Ð% #Ò%Ð%Ð%Ð%Ð%Ø�OŠO˜A�uÔ6°xÑ@Ô@ÑAÔAÐAÝÔ×(Ò(ØØØ"# UÔ%8Ð!9ð 	)ñ 	
ô 	
ð 	
õ
 	Ô×.Ò.¨xÀÐ.ÑFÔFÐFØ�}Š}˜XÑ&Ô&Ð&r=   r®   úpitch.Pitchc                óØ   — t          j        ¦   «         }t          j        |¦  «        |_        t          j        d¬¦  «        }|                     |¦  «         |                      |¦  «        S )a  
        Translate a music21 :class:`~music21.pitch.Pitch` into an object
        ready to be parsed.

        >>> p = pitch.Pitch('c#3')
        >>> GEX = musicxml.m21ToXml.GeneralObjectExporter()
        >>> sc = GEX.fromPitch(p)
        >>> sc.show('t')
        {0.0} <music21.stream.Part 0x1046afa90>
            {0.0} <music21.stream.Measure 1 offset=0.0>
                {0.0} <music21.clef.BassClef>
                {0.0} <music21.meter.TimeSignature 1/4>
                {0.0} <music21.note.Note C#>
        rÃ   rÄ   )	r   rÑ   r¬   r­   r   r"   rg   r¼   rh   )r�   r®   rÔ   r×   s       r;   rp   zGeneralObjectExporter.fromPitch¼  sU   € õ  ŒI‰KŒKˆÝ”- Ñ"Ô"ˆŒÝŒn AÐ&Ñ&Ô&ˆØ�
Š
�1‰Œˆà×Ò Ñ$Ô$Ð$r=   ©N)r{   r|   )r{   r|   r3   rƒ   )rŠ   r‹   r3   rƒ   )r{   r�   ©r®   rï   )Ú__name__Ú
__module__Ú__qualname__Ú__doc__r   r›   r‚   r‰   r†   r…   rd   rf   rh   rj   rl   rr   rt   rx   rv   rz   rn   rp   © r=   r;   rb   rb   õ   s^  € € € € € ðð ð �;ð  ð  ð  ñ ô €Lð 'ð 'ð 'ð 'ð 'ðR3ð R3ð R3ð R3ð R3ðh'ð 'ð 'ð 'ð6ð 6ð 6ð 6ðpð ð ð
"ð 
"ð 
"ð ð  ð  ð>#ð #ð #ð
&'ð &'ð &'ðP'ð 'ð 'ð 
$ð 
$ð 
$ð(#ð (#ð (#ðT+#ð +#ð +#ðZ%ð %ð %ð,'ð ,'ð ,'ð\%ð %ð %ð %ð %ð %r=   rb   c                  óÂ   — e Zd ZdZd%d„Zd&d'd„Zd(d)d„Zed„ ¦   «         Zd'd„Z	d*d„Z
d„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd*d„Zd*d„Zd*d„Zd*d„Zd*d„Zddœd+d#„Zd,d$„ZdS )-ÚXMLExporterBasezm
    contains functions that could be called
    at multiple levels of exporting (Score, Part, Measure).
    r3   ÚNonec                ó^   — t          d¦  «        | _        t          j        ¦   «         | _        d S )Nzoverride-me-in-subclasses)r   ÚxmlRootr"   rk   ©r�   s    r;   r‚   zXMLExporterBase.__init__Ù  s#   € ÝÐ:Ñ;Ô;ˆŒÝ%+¤]¡_¤_ˆŒˆˆr=   Trƒ   c                óT  — t          j        ¦   «         }|                     |                      ¦   «         ¦  «         | j        }t          j        ||¬¦  «        }|                     |                     d¦  «        ¦  «         |                     ¦   «         }| 	                    ¦   «          |S )z®
        returns the xmlRoot as a bytes object. If noCopy is True
        (default), modifies the file for pretty-printing in place.  Otherwise,
        make a copy.
        )ÚnoCopyúutf-8)
ÚioÚBytesIOÚwriteÚ	xmlHeaderrü   r(   Ú
dumpStringÚencodeÚgetvalueÚclose)r�   rÿ   ÚsioÚrootObjÚrootObj_stringrÆ   s         r;   rŽ   zXMLExporterBase.asBytesÝ  s†   € õ Œj‰lŒlˆØ�	Š	�$—.’.Ñ"Ô"Ñ#Ô#Ð#Ø”,ˆÝ Ô+¨G¸FÐCÑCÔCˆØ�	Š	�.×'Ò'¨Ñ0Ô0Ñ1Ô1Ð1Ø�LŠL‰NŒNˆØ�	Š	‰ŒˆØˆr=   r@   Úcommentr2   c                ó"  — t          t          |¦  «        d¦  «        }t          j        d|z
  dz  ¦  «        }t          j        d|z
  dz  ¦  «        }d|z  dz   |z   dz   d|z  z   }t          |¦  «        }| j                             |¦  «         dS )aI  
        Add a divider to xmlRoot.

        >>> from xml.etree.ElementTree import Element
        >>> e1 = Element('accidental')
        >>> e2 = Element('accidental')

        >>> XB = musicxml.m21ToXml.ScoreExporter()
        >>> XB.xmlRoot.append(e1)
        >>> XB.addDividerComment('second accidental below')
        >>> XB.xmlRoot.append(e2)
        >>> XB.dump(XB.xmlRoot)
        <score-partwise version="...">
          <accidental />
          <!--================== second accidental below ===================-->
          <accidental />
          </score-partwise>
        é<   r¢   ú=ú N)ÚminÚlenÚmathÚfloorÚceilr   rü   r¼   )r�   r  ÚcommentLengthÚspacerLengthLowÚspacerLengthHighÚcommentTextÚdividers          r;   ÚaddDividerCommentz!XMLExporterBase.addDividerCommentì  s™   € õ& �C ™LœL¨"Ñ-Ô-ˆÝœ* b¨=Ñ&8¸AÑ%=Ñ>Ô>ˆÝœ9 b¨=Ñ&8¸AÑ%=Ñ>Ô>Ðà˜_Ñ,°Ñ3°gÑ=ÀÑCÀsÐM]ÑG]Ñ^ˆå˜+Ñ&Ô&ˆØŒ×Ò˜GÑ$Ô$Ð$Ð$Ð$r=   c                ó*   — t          j        | ¦  «        S rñ   )r(   Údump)r{   s    r;   r  zXMLExporterBase.dump	  s   € åŒ|˜CÑ Ô Ð r=   c                óR   — dt           j                             d¦  «        z   dz   dz   S )Nsd   <?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE score-partwise  PUBLIC "-//Recordare//DTD MusicXML r   s    Partwise//EN" s-   "http://www.musicxml.org/dtds/partwise.dtd">
)r   ÚmusicxmlVersionr  rý   s    r;   r  zXMLExporterBase.xmlHeader  s<   € ð=åÔ*×1Ò1°'Ñ:Ô:ñ;ð )ñ)ð Hñ	Hð 	Ir=   Nc                ó  — t          |t          j        ¦  «        r|}n|j        du rdS |j        }t	          j        |¦  «        s|f}|€d„ |D ¦   «         }nt	          j        |¦  «        s|f}t          ||¦  «        D ]ƒ\  }}	 t          ||¦  «        }n# t          $ r Y Œ#w xY w|t          j
        v rt          j        |¦  «        }|€ŒL	 t          |¦  «        }n# t          $ r Y Œiw xY w|                     ||¦  «         Œ„dS )z…
        Sets any attribute from .style, doing some conversions.

        m21Object can also be a style.Style object itself.
        FNc              3  ó>   K  — | ]}t          j        |¦  «        V — Œd S rñ   )r   r\   ©Ú.0Úxs     r;   ú	<genexpr>z5XMLExporterBase.setStyleAttributes.<locals>.<genexpr>'  s-   è è € ÐKÐK¸�Ô0°Ñ3Ô3ÐKÐKÐKÐKÐKÐKr=   )r‡   r$   ÚStyleÚhasStyleInformationr   Ú
isIterableÚzipr]   r^   r*   ÚSTYLE_ATTRIBUTES_YES_NO_TO_BOOLÚbooleanToYesNor2   Ú
ValueErrorÚset)	r�   ÚmxObjectÚ	m21ObjectÚmusicXMLNamesÚm21NamesÚstObjÚxmlNameÚm21NameÚm21Values	            r;   ÚsetStyleAttributesz"XMLExporterBase.setStyleAttributes  s[  € õ �i¥¤Ñ-Ô-ð 	$ØˆEˆEØÔ*¨eÐ3Ð3ØˆFà”OˆEåÔ  Ñ/Ô/ð 	-Ø*Ð,ˆMàÐØKÐK¸]ÐKÑKÔKˆHˆHÝÔ" 8Ñ,Ô,ð 	#Ø �{ˆHå # M°8Ñ <Ô <ð 	,ð 	,ÑˆG�WðÝ" 5¨'Ñ2Ô2��øÝ!ð ð ð Ø�ðøøøð �*ÔDÐDÐDÝ%Ô4°XÑ>Ô>�àÐØðÝ˜x™=œ=��øÝð ð ð Ø�ðøøøð �LŠL˜ (Ñ+Ô+Ð+Ð+ð#	,ð 	,s$   ÂBÂ
B!Â B!Ã
CÃ
C'Ã&C'c                ój   — d}d}|                       ||||¦  «         |                      ||¦  «         dS )a|  
        sets the justification, print-style-align group, and
        text-decoration, text-rotation,
        letter-spacing, line-height, lang, text-direction, and
        enclosure, on an
        m21Object, which must have style.TextStyle as its Style class,
        and then calls setPrintStyleAlign

        conforms to attr-group %text-formatting in the MusicXML DTD
        )Újustifyztext-decorationztext-rotationzletter-spacingzline-heightÚlangztext-directionÚ	enclosure)r8  ÚtextDecorationÚtextRotationÚletterSpacingÚ
lineHeightÚlanguageÚtextDirectionr:  N)r6  ÚsetPrintStyleAlign©r�   r.  r/  r0  r1  s        r;   ÚsetTextFormattingz!XMLExporterBase.setTextFormatting>  sH   € ðOˆðLˆà×Ò ¨)°]ÀHÑMÔMÐMØ×Ò ¨)Ñ4Ô4Ð4Ð4Ð4r=   c                ób   — |                       ||¦  «         |                      ||dd¦  «         dS )zé
        runs setPrintStyle and then sets horizontalAlign and verticalAlign, on an
        m21Object, which must have style.TextStyle as its Style class.

        conforms to attr-group %print-style-align in the MusicXML DTD
        )ÚvalignÚhalign)ÚalignVerticalÚalignHorizontalN)ÚsetPrintStyler6  ©r�   r.  r/  s      r;   rA  z"XMLExporterBase.setPrintStyleAlignP  sL   € ð 	×Ò˜8 YÑ/Ô/Ð/Ø×Ò Ø )Ø 4Ø Dñ	Fô 	Fð 	Fð 	Fð 	Fr=   c                óŠ   — |                       ||¦  «         |                      ||¦  «         |                      ||¦  «         dS )zÞ
        get position, font, and color information from the mxObject
        into the m21Object, which must have style.TextStyle as its Style class.

        conforms to attr-group %print-style in the MusicXML DTD
        N)ÚsetPositionÚsetFontÚsetColorrJ  s      r;   rI  zXMLExporterBase.setPrintStyle]  sH   € ð 	×Ò˜ 9Ñ-Ô-Ð-Ø�Š�X˜yÑ)Ô)Ð)Ø�Š�h 	Ñ*Ô*Ð*Ð*Ð*r=   c                ó    — t          |t          j        ¦  «        r|}n|j        r|j        }ndS |j        r|                     dd¦  «         dS dS )z©
        sets print-object to 'no' if m21Object.style.hideObjectOnPrint is True
        or if m21Object is a StyleObject and has .hideObjectOnPrint set to True.
        Núprint-objectÚno)r‡   r$   r&  r'  ÚhideObjectOnPrintr-  )r�   r.  r/  rÎ   s       r;   ÚsetPrintObjectzXMLExporterBase.setPrintObjecth  sg   € õ
 �i¥¤Ñ-Ô-ð 	ØˆBˆBØÔ*ð 	Ø”ˆBˆBàˆFàÔð 	/Ø�LŠL˜¨Ñ.Ô.Ð.Ð.Ð.ð	/ð 	/r=   c                ó�   — |                       ||dd¦  «         d|j        v r$t          |j        d         ¦  «        |j        d<   dS dS )zY
        Sets mxObject['color'] to a normalized version of m21Object.style.color
        r>   N)r6  ÚattribrE   rJ  s      r;   rN  zXMLExporterBase.setColorw  sT   € ð 	×Ò ¨)°W¸gÑFÔFÐFØ�h”oÐ%Ð%Ý'5°h´oÀgÔ6NÑ'OÔ'OˆHŒO˜GÑ$Ð$Ð$ð &Ð%r=   c                ó   — d}d}|                       ||||¦  «         t          |t          j        ¦  «        r|}n|j        r|j        }ndS t          |d¦  «        rt|j        dk    r2|                     dd¦  «         |j         	                    dd¦  «         n7|j        dk    r,|                     dd¦  «         |                     dd	¦  «         t          |d
¦  «        rm|j
        rht          j        |j
        ¦  «        r0|                     dd                     |j
        ¦  «        ¦  «         dS |                     d|j
        ¦  «         dS dS dS )a¸  
        sets font-family, font-style, font-size, and font-weight as
        fontFamily (list), fontStyle, fontSize and fontWeight from
        an object into a TextStyle object

        conforms to attr-group %font in the MusicXML DTD

        >>> from xml.etree.ElementTree import fromstring as EL
        >>> XB = musicxml.m21ToXml.XMLExporterBase()
        >>> mxObj = EL('<text>hi</text>')
        >>> te = expressions.TextExpression('hi!')
        >>> te.style.fontFamily = ['Courier', 'monospaced']
        >>> te.style.fontStyle = 'italic'
        >>> te.style.fontSize = 24.0
        >>> XB.setFont(mxObj, te)
        >>> XB.dump(mxObj)
        <text font-family="Courier,monospaced" font-size="24" font-style="italic">hi</text>

        >>> XB = musicxml.m21ToXml.XMLExporterBase()
        >>> mxObj = EL('<text>hi</text>')
        >>> te = expressions.TextExpression('hi!')
        >>> te.style.fontStyle = 'bold'
        >>> XB.setFont(mxObj, te)
        >>> XB.dump(mxObj)
        <text font-weight="bold">hi</text>

        >>> te.style.fontStyle = 'bolditalic'
        >>> XB.setFont(mxObj, te)
        >>> XB.dump(mxObj)
        <text font-style="italic" font-weight="bold">hi</text>
        )ú
font-stylez	font-sizeúfont-weight)Ú	fontStyleÚfontSizeÚ
fontWeightNrY  ÚboldrX  rW  Ú
bolditalicÚitalicÚ
fontFamilyzfont-familyú,)r6  r‡   r$   r&  r'  ÚhasattrrY  r-  rU  Úpopr_  r   r(  Újoin)r�   r.  r/  r0  r1  rÎ   s         r;   rM  zXMLExporterBase.setFont‚  si  € ð@ CˆØ:ˆØ×Ò ¨)°]ÀHÑMÔMÐMÝ�i¥¤Ñ-Ô-ð 	ØˆBˆBØÔ*ð 	Ø”ˆBˆBàˆFå�2�{Ñ#Ô#ð 	5àŒ|˜vÒ%Ð%Ø—’˜]¨FÑ3Ô3Ð3Ø”×#Ò# L°$Ñ7Ô7Ð7Ð7Ø” Ò-Ð-Ø—’˜]¨FÑ3Ô3Ð3Ø—’˜\¨8Ñ4Ô4Ð4å�2�|Ñ$Ô$ð 	;¨¬ð 	;ÝÔ  ¤Ñ/Ô/ð ;Ø—’˜]¨C¯HªH°R´]Ñ,CÔ,CÑDÔDÐDÐDÐDà—’˜]¨B¬MÑ:Ô:Ð:Ð:Ð:ð		;ð 	;ð 	;ð 	;r=   c                ó>   — d}d}|                       ||||¦  «         dS )zÂ
        set positioning information for an mxObject from
        default-x, default-y, relative-x, relative-y from
        the .style attribute's absoluteX, relativeX, etc. attributes.
        )z	default-xz	default-yz
relative-xz
relative-y)Ú	absoluteXÚ	absoluteYÚ	relativeXÚ	relativeYN©r6  rB  s        r;   rL  zXMLExporterBase.setPosition»  s/   € ð OˆØGˆØ×Ò ¨)°]ÀHÑMÔMÐMÐMÐMr=   c                óÒ  — |j         du rdS |j        }d|vrd|vrdS d}|j        r|j        d         }d}n|j        r|j        d         }ndS |r9t	          |d¦  «        }|                      ||¦  «         |j        �|j        |_        |j        �Xt	          |d¦  «        }t          |j        ¦  «        |_        | 	                    d	t          j        |j        ¦  «        ¦  «         dS dS )
a£  
        >>> from xml.etree.ElementTree import fromstring as EL
        >>> XB = musicxml.m21ToXml.XMLExporterBase()
        >>> mxObj = EL('<note />')
        >>> n = note.Note('C-5')

        Most common case: does nothing

        >>> XB.setEditorial(mxObj, n)
        >>> XB.dump(mxObj)
        <note />

        >>> fn = editorial.Comment('flat is obvious error for sharp')
        >>> fn.levelInformation = 2
        >>> fn.isFootnote = True
        >>> n.editorial.footnotes.append(fn)
        >>> XB.setEditorial(mxObj, n)
        >>> XB.dump(mxObj)
        <note>
          <footnote>flat is obvious error for sharp</footnote>
          <level reference="no">2</level>
        </note>

        Placing information in `.editorial.comments` only puts out the level:

        >>> mxObj = EL('<note />')
        >>> n = note.Note('C-5')
        >>> com = editorial.Comment('flat is obvious error for sharp')
        >>> com.levelInformation = 'hello'
        >>> com.isReference = True
        >>> n.editorial.comments.append(com)
        >>> XB.setEditorial(mxObj, n)
        >>> XB.dump(mxObj)
        <note>
          <level reference="yes">hello</level>
        </note>
        FNÚ	footnotesÚcommentsr   TÚfootnoteÚlevelÚ	reference)ÚhasEditorialInformationÚ	editorialrk  rl  r   rC  r&   ÚlevelInformationr2   r-  r*   r+  ÚisReference)r�   r.  r/  ÚeÚmakeFootnoteÚcÚmxFnÚmxLevels           r;   ÚsetEditorialzXMLExporterBase.setEditorialÅ  s  € ðL Ô,°Ð5Ð5ØˆFð ÔˆØ˜aÐÐ J°aÐ$7Ð$7ØˆFàˆØŒ;ð 	Ø”˜A”ˆAØˆLˆLØŒZð 	Ø”
˜1”ˆAˆAàˆFàð 	#Ý˜h¨
Ñ3Ô3ˆDØ×"Ò" 4¨Ñ+Ô+Ð+ØŒvÐ!ØœF�”	ØÔÐ)Ý  ¨7Ñ3Ô3ˆGÝ˜qÔ1Ñ2Ô2ˆGŒLØ�KŠK˜¥ZÔ%>¸q¼}Ñ%MÔ%MÑNÔNÐNÐNÐNð *Ð)r=   c                ó  — |€t          d¦  «        }n|}t          } |||ddt          j        ¬¦  «          |||d¦  «         |                      |¦  «        }t          |¦  «        r|                     |¦  «         |€|S dS )aô  
        Given a PageLayout object, set object data for <print>

        >>> pl = layout.PageLayout()
        >>> pl.pageHeight = 4000
        >>> pl.isNew = True
        >>> pl.rightMargin = 30.25
        >>> pl.leftMargin = 20
        >>> pl.pageNumber = 5

        >>> XPBase = musicxml.m21ToXml.XMLExporterBase()
        >>> mxPrint = XPBase.pageLayoutToXmlPrint(pl)
        >>> XPBase.dump(mxPrint)
        <print new-page="yes" page-number="5">
          <page-layout>
            <page-height>4000</page-height>
            <page-margins>
              <left-margin>20</left-margin>
              <right-margin>30.25</right-margin>
            </page-margins>
          </page-layout>
        </print>

        >>> MP = musicxml.xmlToM21.MeasureParser()
        >>> pl2 = MP.xmlPrintToPageLayout(mxPrint)
        >>> pl2.isNew
        True
        >>> pl2.rightMargin
        30.25
        >>> pl2.leftMargin
        20
        >>> pl2.pageNumber
        5
        >>> pl2.pageHeight
        4000
        NÚprintúnew-pageÚisNew©rO   zpage-number)r   ÚsetAttributeFromAttributer*   r+  ÚpageLayoutToXmlPageLayoutr  r¼   )r�   Ú
pageLayoutÚ	mxPrintInÚmxPrintÚsetbÚmxPageLayouts         r;   ÚpageLayoutToXmlPrintz$XMLExporterBase.pageLayoutToXmlPrint  sž   € ðL ÐÝ˜gÑ&Ô&ˆGˆGàˆGå(ˆØˆˆZ˜ *¨gÅÔAZÐ[Ñ[Ô[Ð[ØˆˆZ˜ -Ñ0Ô0Ð0à×5Ò5°jÑAÔAˆÝˆ|ÑÔð 	)Ø�NŠN˜<Ñ(Ô(Ð(àÐØˆNð Ðr=   c                ó  — |€t          d¦  «        }n|}t          } |||d¦  «          |||d¦  «         t          d¦  «        }dD ]} ||||dz   ¦  «         Œt          |¦  «        r|                     |¦  «         |€|S dS )z£
        get a <page-layout> element from a PageLayout

        Called out from pageLayoutToXmlPrint because it
        is also used in the <defaults> tag
        Nzpage-layoutzpage-heightz
page-widthzpage-margins)ÚleftÚrightÚtopÚbottomú-margin©r   r`   r  r¼   )r�   r�  ÚmxPageLayoutInr…  ÚsetaÚmxPageMarginsÚ	directions          r;   r€  z)XMLExporterBase.pageLayoutToXmlPageLayoutA  s¿   € ð Ð!Ý" =Ñ1Ô1ˆLˆLà)ˆLå'ˆàˆˆZ˜ }Ñ5Ô5Ð5ØˆˆZ˜ |Ñ4Ô4Ð4õ   Ñ/Ô/ˆØ;ð 	Cð 	CˆIØˆD�˜]¨I¸	Ñ,AÑBÔBÐBÐBÝˆ}ÑÔð 	/Ø×Ò Ñ.Ô.Ð.àÐ!ØÐð "Ð!r=   c                ó
  — |€t          d¦  «        }n|}t          } |||ddt          j        ¬¦  «         t          d¦  «        }|                      ||¦  «         t          |¦  «        r|                     |¦  «         |€|S dS )aÄ  
        Given a SystemLayout tag, set a <print> tag

        >>> sl = layout.SystemLayout()
        >>> sl.distance = 55
        >>> sl.isNew = True
        >>> sl.rightMargin = 30.25
        >>> sl.leftMargin = 20

        >>> XPBase = musicxml.m21ToXml.XMLExporterBase()
        >>> mxPrint = XPBase.systemLayoutToXmlPrint(sl)
        >>> XPBase.dump(mxPrint)
        <print new-system="yes">
          <system-layout>
            <system-margins>
              <left-margin>20</left-margin>
              <right-margin>30.25</right-margin>
            </system-margins>
            <system-distance>55</system-distance>
          </system-layout>
        </print>

        Test return conversion

        >>> MP = musicxml.xmlToM21.MeasureParser()
        >>> sl2 = MP.xmlPrintToSystemLayout(mxPrint)
        >>> sl2.isNew
        True
        >>> sl2.rightMargin
        30.25
        >>> sl2.leftMargin
        20
        >>> sl2.distance
        55
        Nr{  ú
new-systemr}  r~  úsystem-layout)r   r  r*   r+  ÚsystemLayoutToXmlSystemLayoutr  r¼   )r�   ÚsystemLayoutr‚  rƒ  r„  ÚmxSystemLayouts         r;   ÚsystemLayoutToXmlPrintz&XMLExporterBase.systemLayoutToXmlPrint\  sš   € ðJ ÐÝ˜gÑ&Ô&ˆGˆGàˆGå(ˆØˆˆ\˜7 L°'ÅZÔE^Ð_Ñ_Ô_Ð_å  Ñ1Ô1ˆØ×*Ò*¨<¸ÑHÔHÐHÝˆ~ÑÔð 	+Ø�NŠN˜>Ñ*Ô*Ð*àÐØˆNð Ðr=   c                ó  — |€t          d¦  «        }n|}t          }t          d¦  «        }dD ]} ||||dz   ¦  «         Œt          |¦  «        r|                     |¦  «          |||dd¦  «          |||dd	¦  «         |€|S dS )
aŒ  
        get given a SystemLayout object configure <system-layout> or <print>

        Called out from xmlPrintToSystemLayout because it
        is also used in the <defaults> tag

        >>> sl = layout.SystemLayout()
        >>> sl.distance = 40.0
        >>> sl.topDistance = 70.0
        >>> XPBase = musicxml.m21ToXml.XMLExporterBase()
        >>> mxSl = XPBase.systemLayoutToXmlSystemLayout(sl)
        >>> XPBase.dump(mxSl)
        <system-layout>
          <system-distance>40.0</system-distance>
          <top-system-distance>70.0</top-system-distance>
        </system-layout>

        >>> sl = layout.SystemLayout()
        >>> sl.leftMargin = 30.0
        >>> mxSl = XPBase.systemLayoutToXmlSystemLayout(sl)
        >>> XPBase.dump(mxSl)
        <system-layout>
          <system-margins>
            <left-margin>30.0</left-margin>
          </system-margins>
        </system-layout>
        Nr”  zsystem-margins)rŠ  r‹  rˆ  r‰  rŒ  zsystem-distanceÚdistanceztop-system-distanceÚtopDistancer�  )r�   r–  ÚmxSystemLayoutInr—  r�  ÚmxSystemMarginsr‘  s          r;   r•  z-XMLExporterBase.systemLayoutToXmlSystemLayout‘  sÈ   € ð8 Ð#Ý$ _Ñ5Ô5ˆNˆNà-ˆNå'ˆõ "Ð"2Ñ3Ô3ˆØ;ð 	Gð 	GˆIØˆD�˜°	¸IÑ0EÑFÔFÐFÐFåˆÑÔð 	3Ø×!Ò! /Ñ2Ô2Ð2àˆˆ\˜>Ð+<¸jÑIÔIÐIØˆˆ\˜>Ð+@À-ÑPÔPÐPð Ð#Ø!Ð!ð $Ð#r=   c                óŠ   — |€t          d¦  «        }n|}t          }t          } |||dd¦  «          |||dd¦  «         |€|S dS )a  
        get a <staff-layout> tag from a StaffLayout object

        In music21, the <staff-layout> and <staff-details> are
        intertwined in a StaffLayout object.

        >>> sl = layout.StaffLayout()
        >>> sl.distance = 40.0
        >>> sl.staffNumber = 1
        >>> XPBase = musicxml.m21ToXml.XMLExporterBase()
        >>> mxSl = XPBase.staffLayoutToXmlStaffLayout(sl)
        >>> XPBase.dump(mxSl)
        <staff-layout number="1">
          <staff-distance>40.0</staff-distance>
        </staff-layout>

        Nzstaff-layoutzstaff-distancerš  rÅ   ÚstaffNumber)r   r`   r  )r�   ÚstaffLayoutÚmxStaffLayoutInÚmxStaffLayoutr�  r„  s         r;   ÚstaffLayoutToXmlStaffLayoutz+XMLExporterBase.staffLayoutToXmlStaffLayoutÄ  si   € ð$ Ð"Ý# NÑ3Ô3ˆMˆMà+ˆMÝ'ˆÝ(ˆàˆˆ[˜-Ð)9¸:ÑFÔFÐFàˆˆ[˜-¨°=ÑAÔAÐAàÐ"Ø Ð ð #Ð"r=   Ú
accidental©ÚelNameÚaúpitch.Accidentalr¦  r   c               ó   — d}|j         dk    rd}nS|j         dk    rd}nE|j         dk    rd}n7|j         dk    rd	}n)|j         d
k    rd}n|j         }|t          j        vr||vrd}t          |¦  «        }||_        |j        dv r|                     dd¦  «         |j        dv r|                     dd¦  «         |                      ||¦  «         |S )aø  
        Convert a pitch.Accidental object to a Element of tag 'accidental' (or other name)

        >>> acc = pitch.Accidental()
        >>> acc.set('half-sharp')
        >>> acc.alter == 0.5
        True

        >>> XB = musicxml.m21ToXml.XMLExporterBase()
        >>> a2m = XB.accidentalToMx
        >>> XB.dump(a2m(acc))
        <accidental>quarter-sharp</accidental>

        >>> acc.set('double-flat')
        >>> XB.dump(a2m(acc))
        <accidental>flat-flat</accidental>

        >>> acc.set('one-and-a-half-sharp')
        >>> XB.dump(a2m(acc, elName='accidental-mark'))
        <accidental-mark>three-quarters-sharp</accidental-mark>

        >>> acc.set('half-flat')
        >>> XB.dump(a2m(acc))
        <accidental>quarter-flat</accidental>

        >>> acc.set('one-and-a-half-flat')
        >>> XB.dump(a2m(acc))
        <accidental>three-quarters-flat</accidental>

        >>> acc.set('sharp')
        >>> acc.displayStyle = 'parentheses'
        >>> XB.dump(a2m(acc))
        <accidental parentheses="yes">sharp</accidental>

        >>> acc.displayStyle = 'bracket'
        >>> XB.dump(a2m(acc))
        <accidental bracket="yes">sharp</accidental>

        >>> acc.displayStyle = 'both'
        >>> XB.dump(a2m(acc))
        <accidental bracket="yes" parentheses="yes">sharp</accidental>

        >>> acc = pitch.Accidental('flat')
        >>> acc.style.relativeX = -2
        >>> XB.dump(a2m(acc))
        <accidental relative-x="-2">flat</accidental>

        >>> acc = pitch.Accidental()
        >>> acc.name = 'double-sharp-down'  # musicxml 3.1
        >>> XB.dump(a2m(acc))
        <accidental>double-sharp-down</accidental>

        >>> acc.name = 'funnyAccidental'  # unknown
        >>> XB.dump(a2m(acc))
        <accidental>other</accidental>
        )zdouble-sharp-downzdouble-sharp-upzflat-flat-downzflat-flat-upz
arrow-downzarrow-upÚotherz
sharp-downzsharp-upznatural-downz
natural-upz	flat-downzflat-upzslash-quarter-sharpzslash-sharpz
slash-flatzdouble-slash-flatzsharp-1zsharp-2zsharp-3zsharp-5zflat-1zflat-2zflat-3zflat-4ÚsoriÚkoronz
half-sharpzquarter-sharpzone-and-a-half-sharpzthree-quarters-sharpz	half-flatzquarter-flatzone-and-a-half-flatzthree-quarters-flatzdouble-flatz	flat-flatrª  )ÚparenthesesÚbothr­  Úyes)Úbracketr®  r°  )rß   r   ÚaccidentalNameToModifierr   r&   ÚdisplayStyler-  rI  )r�   r§  r¦  ÚotherMusicXMLAccidentalsÚmxNameÚmxAccidentals         r;   ÚaccidentalToMxzXMLExporterBase.accidentalToMxä  s  € ðt$
Ð ð( Œ6�\Ò!Ð!Ø$ˆFˆFØŒVÐ-Ò-Ð-Ø+ˆFˆFØŒV�{Ò"Ð"Ø#ˆFˆFØŒVÐ,Ò,Ð,Ø*ˆFˆFØŒV�}Ò$Ð$Ø ˆFˆFà”VˆFØ�eÔ<Ð<Ð<ØÐ&>Ð>Ð>Ø �å˜v‘”ˆð #ˆÔØŒ>Ð4Ð4Ð4Ø×Ò˜]¨EÑ2Ô2Ð2ØŒ>Ð0Ð0Ð0Ø×Ò˜Y¨Ñ.Ô.Ð.à×Ò˜<¨Ñ+Ô+Ð+ØÐr=   c                ó0   — |                       |d¬¦  «        S )Nzaccidental-markr¥  )r¶  )r�   r§  s     r;   ÚaccidentalToMxAccidentalMarkz,XMLExporterBase.accidentalToMxAccidentalMarkP  s   € Ø×"Ò" 1Ð->Ð"Ñ?Ô?Ð?r=   ©r3   rú   )T)r3   rƒ   )r@   )r  r2   r3   rú   rñ   )r§  r¨  r¦  r2   r3   r   )r§  r¨  r3   r   )ró   rô   rõ   rö   r‚   rŽ   r  Ústaticmethodr  r  r6  rC  rA  rI  rS  rN  rM  rL  ry  r†  r€  r˜  r•  r£  r¶  r¸  r÷   r=   r;   rù   rù   Ô  sà  € € € € € ðð ð5ð 5ð 5ð 5ðð ð ð ð ð%ð %ð %ð %ð %ð: ð!ð !ñ „\ð!ðIð Ið Ið Ið&,ð &,ð &,ð &,ðP5ð 5ð 5ð$Fð Fð Fð	+ð 	+ð 	+ð/ð /ð /ð	Pð 	Pð 	Pð7;ð 7;ð 7;ðrNð Nð Nð?Oð ?Oð ?OðL4ð 4ð 4ð 4ðl ð  ð  ð  ð63ð 3ð 3ð 3ðj1"ð 1"ð 1"ð 1"ðf!ð !ð !ð !ð@ DPð ið ið ið ið ið iðX@ð @ð @ð @ð @ð @r=   rù   c                  óä   ‡ — e Zd ZdZd+d,ˆ fd„Zd-d„Zd-d„Zd.d„Zd.d„Zd.d„Z	d.d„Z
d.d„Zd.d„Zd.d„Zd.d„Zd.d„Zd.d„Zd.d„Zd/d„Zd„ Zd„ Zd„ Zd„ Zd „ Zd-d!„Z	 d0d1d%„Zd&„ Zd2d(„Zd.d)„Zd*„ Zˆ xZS )3r�   zT
    Convert a Score (or outer stream with .parts) into
    a musicxml Element.
    NTÚscoreústream.Score | Noner€   rX   c                óÈ  •— t          ¦   «                              ¦   «          |€t          j        ¦   «         | _        n|| _        t	          dt
          j        ¬¦  «        | _        d | _        d | _	        d | _
        d | _        g | _        d | _        g | _        d| _        d| j        g| _        g | _        g | _        i | _        g | _        g | _        g | _        g | _        || _        d S )Nzscore-partwise)Úversionr’   )Úsuperr‚   r"   rc   r   r   r  rü   ÚmxIdentificationÚscoreMetadataÚspannerBundleÚmeterStreamÚscoreLayoutsÚfirstScoreLayoutÚ	textBoxesrš   r“   ÚpartExporterListÚgroupsToJoinÚinstrumentsByStreamÚinstrumentListÚinstrumentIdListÚmidiChannelListÚpartsr€   )r�   r¼  r€   Ú	__class__s      €r;   r‚   zScoreExporter.__init__\  sà   ø€ Ý‰Œ×ÒÑÔÐØˆ=å œ,™.œ.ˆDŒKˆKàˆDŒKåÐ/½Ô9QÐRÑRÔRˆŒØ.2ˆÔà59ˆÔà9=ˆÔØHLˆÔØ68ˆÔØ9=ˆÔØ-/ˆŒØˆÔà%(¨$Ô*:Ð$;ˆÔ!à46ˆÔà57ˆÔà=?ˆÔ à;=ˆÔØ02ˆÔØ/1ˆÔà(*ˆŒ
à".ˆÔÐÐr=   r3   r   c                ó  — | j         }|s|                      ¦   «         S |                     dd¬¦  «         |                      ¦   «          |                     ¦   «         rj|                      ¦   «          |                      ¦   «         | _        |                      ¦   «          |  	                    ¦   «          |  
                    ¦   «          n|                      ¦   «          |                      ¦   «          | j                             ¦   «          | j        S )aG  
        the main function to call.

        If self.stream is empty, call self.emptyObject().  Otherwise,
        convert sounding to written pitch,
        set scorePreliminaries(), call parsePartlikeScore or parseFlatScore, then postPartProcess(),
        clean up circular references for garbage collection, and returns the <score-partwise>
        object.

        >>> b = corpus.parse('bwv66.6')
        >>> SX = musicxml.m21ToXml.ScoreExporter(b)
        >>> mxScore = SX.parse()
        >>> SX.dump(mxScore)
        <score-partwise version="...">...</score-partwise>
        T©r•   ÚottavasToSounding)r"   ÚemptyObjectÚtoWrittenPitchÚscorePreliminariesrÌ   Ú_populatePartExporterListÚjoinableGroupsrÉ  ÚsetPartExporterStaffGroupsÚrenumberVoicesWithinStaffGroupsÚparsePartlikeScoreÚparseFlatScoreÚpostPartProcessrÈ  Úclearrü   )r�   rF   s     r;   r‰   zScoreExporter.parse€  s
  € ð  ŒKˆØð 	&Ø×#Ò#Ñ%Ô%Ð%ð 	
×Ò ¸ÐÑ>Ô>Ð>à×ÒÑ!Ô!Ð!à×ÒÑ!Ô!ð 		"ð ×*Ò*Ñ,Ô,Ð,Ø $× 3Ò 3Ñ 5Ô 5ˆDÔØ×+Ò+Ñ-Ô-Ð-Ø×0Ò0Ñ2Ô2Ð2Ø×#Ò#Ñ%Ô%Ð%Ð%à×ÒÑ!Ô!Ð!à×ÒÑÔÐð 	Ô×#Ò#Ñ%Ô%Ð%àŒ|Ðr=   c                ó¨  — t          j        ¦   «         }t          j        ¦   «         }t          j        ¦   «         }t	          j        d¬¦  «        }|                     |¦  «         |                     |¦  «         |                     |¦  «         t          j        d¬¦  «        }| 	                    d|¦  «         || _         |  
                    ¦   «         S )ah  
        Creates a cheeky "This Page Intentionally Left Blank" for a blank score

        >>> emptySX = musicxml.m21ToXml.ScoreExporter()
        >>> mxScore = emptySX.parse()  # will call emptyObject
        >>> emptySX.dump(mxScore)
        <score-partwise version="...">
          <work>
            <work-title>This Page Intentionally Left Blank</work-title>
          </work>
          ...
              <note>
                <rest />
                <duration>40320</duration>
                <type>whole</type>
              </note>
            </measure>
          </part>
        </score-partwise>
        rÙ   )rá   z"This Page Intentionally Left Blank)Útitler   )r"   rc   re   rg   r   ÚRestr¼   r   ÚMetadatar«   r‰   )r�   r×   r®   r¿   ÚrrL   s         r;   rÓ  zScoreExporter.emptyObject«  s£   € õ* Œl‰nŒnˆÝŒK‰MŒMˆÝŒNÑÔˆÝŒI AÐ&Ñ&Ô&ˆØ	�Š�‰ŒˆØ	�Š�‰ŒˆØ�
Š
�1‰ŒˆåÔÐ%IÐJÑJÔJˆØ�
Š
�1�bÑÔÐàˆŒØ�zŠz‰|Œ|Ðr=   rú   c                ó  — |                       ¦   «          |                      ¦   «          |                      ¦   «          t          | j        t
          j                 ¦  «        | _        d| _        | j	        €| j        j	        | _	        dS dS )ax  
        Populate the exporter object with
        `meterStream`, `scoreLayouts`, `spannerBundle`, and `textBoxes`

        >>> emptySX = musicxml.m21ToXml.ScoreExporter()
        >>> emptySX.scorePreliminaries()  # will call emptyObject
        >>> len(emptySX.textBoxes)
        0
        >>> emptySX.spannerBundle
        <music21.spanner.SpannerBundle of size 0>

        r’   N)
ÚsetScoreLayoutsÚsetMeterStreamÚsetPartsAndRefStreamÚlistr"   r&   ÚTextBoxrÇ  rš   rÃ  rý   s    r;   rÕ  z ScoreExporter.scorePreliminariesÎ  s€   € ð 	×ÒÑÔÐØ×ÒÑÔÐØ×!Ò!Ñ#Ô#Ð#å˜dœk­$¬,Ô7Ñ8Ô8ˆŒð ˆÔàÔÐ%Ø!%¤Ô!:ˆDÔÐÐð &Ð%r=   c                ó"  — | j         }t          j        rt          |t           j        ¦  «        sJ ‚|                     t           j        ¦  «        }|D ]–}t          |t           j        ¦  «        r|j        |j	        z   }nPt          |t           j        t           j
        f¦  «        rt          d¦  «        ‚|                     ¦   «          |j	        }t          | j	        |¦  «        | _	        Œ—d| j	        g| _        t          |j        ¦  «        | _        dS )aó  
        Transfers the offset of the inner stream to elements and sets self.highestTime

        >>> b = corpus.parse('bwv66.6')
        >>> SX = musicxml.m21ToXml.ScoreExporter(b)
        >>> SX.highestTime
        0.0
        >>> SX.setPartsAndRefStream()
        >>> SX.highestTime
        36.0
        >>> SX.refStreamOrTimeRange
        [0.0, 36.0]
        >>> len(SX.parts)
        4
        >>> isinstance(SX.parts[0], stream.Part)
        True

        >>> b.insert(stream.Score())
        >>> SX = musicxml.m21ToXml.ScoreExporter(b)
        >>> SX.setPartsAndRefStream()
        Traceback (most recent call last):
        music21.musicxml.xmlObjects.MusicXMLExportException:
        Exporting scores nested inside scores is not supported
        z6Exporting scores nested inside scores is not supportedr’   N)r"   ÚtÚTYPE_CHECKINGr‡   rc   rÊ   rk   rg   Úoffsetrš   ÚOpusr,   ÚtransferOffsetToElementsÚmaxr“   rç  rÎ  )r�   rF   ÚstreamOfStreamsÚinnerStreamÚhts        r;   ræ  z"ScoreExporter.setPartsAndRefStreamç  s  € ð2 ŒKˆÝŒ?ð 	/Ý˜a¥¤Ñ.Ô.Ð.Ð.Ð.ð ×.Ò.­v¬}Ñ=Ô=ˆØ*ð 	9ð 	9ˆKõ
 ˜+¥v¤~Ñ6Ô6ð -Ø Ô'¨+Ô*AÑA��Ý˜K­&¬,½¼Ð)DÑEÔEð -Ý-ØLñNô Nð Nð ×4Ò4Ñ6Ô6Ð6Ø Ô,�Ý" 4Ô#3°RÑ8Ô8ˆDÔÐØ%(¨$Ô*:Ð$;ˆÔ!Ý˜!œ'‘]”]ˆŒ
ˆ
ˆ
r=   c                óR   — | j         }|                     ddd¬¦  «        }|| _        dS )a£  
        sets `self.meterStream` or uses a default.

        Used in makeNotation in Part later.

        >>> b = corpus.parse('bwv66.6')
        >>> SX = musicxml.m21ToXml.ScoreExporter(b)
        >>> SX.setMeterStream()
        >>> SX.meterStream
        <music21.stream.Score bach/bwv66.6.mxl>
        >>> len(SX.meterStream)
        4
        >>> SX.meterStream[0]
        <music21.meter.TimeSignature 4/4>
        FT)ÚsearchContextÚsortByCreationTimeÚreturnDefaultN)r"   ÚgetTimeSignaturesrÄ  )r�   rF   rÄ  s      r;   rå  zScoreExporter.setMeterStream  s=   € ð  ŒKˆØ×)Ò)¸Ø=BØ8<ð *ñ >ô >ˆð 'ˆÔÐÐr=   c                ó¬   — | j         }|                     t          j        ¦  «        }|                     ¦   «         | _        t          |¦  «        | _        dS )a„  
        sets `self.scoreLayouts` and `self.firstScoreLayout`

        >>> b = corpus.parse('schoenberg/opus19', 2)
        >>> SX = musicxml.m21ToXml.ScoreExporter(b)
        >>> SX.setScoreLayouts()
        >>> SX.scoreLayouts
        [<music21.layout.ScoreLayout>]
        >>> len(SX.scoreLayouts)
        1
        >>> SX.firstScoreLayout
        <music21.layout.ScoreLayout>
        N)r"   rÊ   r   ÚScoreLayoutrÍ   rÆ  rç  rÅ  )r�   rF   rÅ  s      r;   rä  zScoreExporter.setScoreLayouts-  sK   € ð ŒKˆØ×+Ò+­FÔ,>Ñ?Ô?ˆØ ,× 2Ò 2Ñ 4Ô 4ˆÔÝ  Ñ.Ô.ˆÔÐÐr=   c                óø   — d}t          | j        ¦  «        }|D ]`}|dz  }|t          |¦  «        k    rt          d¦  «        ‚t	          || ¬¦  «        }| j        |_        | j                             |¦  «         Œad S )Nr   rÃ   zinfinite stream encountered©Úparent)rç  rÎ  r  r,   ÚPartExporterrÃ  rÈ  r¼   )r�   ÚcountÚsprñ  Úpps        r;   rÖ  z'ScoreExporter._populatePartExporterList@  s�   € ØˆÝ�$”*ÑÔˆØð 		-ð 		-ˆKØ�Q‰JˆEð •s˜2‘w”wŠˆÝ-Ð.KÑLÔLÐLå˜k°$Ð7Ñ7Ô7ˆBØ#Ô1ˆBÔØÔ!×(Ò(¨Ñ,Ô,Ð,Ð,ð		-ð 		-r=   c                óx   — | j         s|                      ¦   «          | j         D ]}|                     ¦   «          ŒdS )a  
        Called by .parse() if the score has individual parts.
        Creates a `PartExporter` for each part, and runs .parse() on that part.
        Appends the PartExporter to `self.partExporterList`
        and runs .parse() on that part. Appends the PartExporter to self.
        N)rÈ  rÖ  r‰   )r�   Úpart_exs     r;   rÚ  z ScoreExporter.parsePartlikeScoreN  sL   € ð Ô$ð 	-Ø×*Ò*Ñ,Ô,Ð,ØÔ,ð 	ð 	ˆGØ�MŠM‰OŒOˆOˆOð	ð 	r=   c                ó   — | j         }t          j        ¦   «         }|D ]}|                     |j        |¦  «         Œ|                     ¦   «          t          || ¬¦  «        }|                     ¦   «          | j                             |¦  «         dS )a  
        creates a single PartExporter for this Stream and parses it.

        Note that the Score does not need to be totally flat, it just cannot have Parts inside it;
        measures are fine.

        >>> c = converter.parse('tinyNotation: 3/4 c2. d e')
        >>> SX = musicxml.m21ToXml.ScoreExporter(c)
        >>> SX.parseFlatScore()
        >>> len(SX.partExporterList)
        1
        >>> SX.partExporterList[0]
        <music21.musicxml.m21ToXml.PartExporter object at 0x...>
        >>> SX.dump(SX.partExporterList[0].xmlRoot)
        <part id="...">
          <!--========================= Measure 1 ==========================-->
          <measure implicit="no" number="1">...</measure>
        </part>
        >>> del SX.partExporterList[:]  # for garbage collection
        rû  N)	r"   re   Ú
coreInsertrì  ÚcoreElementsChangedrý  r‰   rÈ  r¼   )r�   rF   r®   Úelr   s        r;   rÛ  zScoreExporter.parseFlatScoreZ  sŒ   € ð* ŒKˆÝŒK‰MŒMˆØð 	(ð 	(ˆBØ�LŠL˜œ BÑ'Ô'Ð'Ð'Ø	×ÒÑÔÐÝ˜! DÐ)Ñ)Ô)ˆØ
�Š‰
Œ
ˆ
ØÔ×$Ò$ RÑ(Ô(Ð(Ð(Ð(r=   c                óZ   — | j         D ]"}d}| j        D ]}|j        |v r|} nŒ||_        Œ#dS )z†
        Figures out the containing StaffGroup for every PartExporter that has one.

        Called automatically by .parse()
        N)rÈ  rÉ  r"   Ú
staffGroup)r�   ÚpartExpÚjoinableGroupÚsgs       r;   rØ  z(ScoreExporter.setPartExporterStaffGroupsx  s`   € ð Ô,ð 	/ð 	/ˆGØ ˆMØÔ'ð ð �Ø”> RÐ'Ð'Ø$&�MØ�Eð (ð "/ˆGÔÐð	/ð 	/r=   c                óD  — g }| j         D �]}|j        €Œ|j        |v rŒt          j        |j                             ¦   «         ¦  «        }|                     ¦   «                              t          j        ¦  «                             ¦   «         }t          |¦  «        }|D ]e}d}|D ]^}|t          j	                 D ]I}	t          |	j        t          ¦  «        sŒ|	j        t          j        k     r|	j        dz   }Œ=||	_        |dz  }ŒJŒ_Œf|                     |j        ¦  «         �ŒdS )zµ
        Renumbers voices (as appropriate) in each StaffGroup, so that
        voices have unique numbers across the entire group.

        Called automatically by .parse()
        NrÃ   )rÈ  r  r"   rc   ÚgetSpannedElementsr³   rÊ   rg   r#   ri   r‡   ÚidÚintr   Ú#minIdNumberToConsiderMemoryLocationr¼   )
r�   ÚstaffGroupsProcessedr	  ÚstaffGroupScoreÚmeasuresStreamÚoffsetIteratorÚmeasureStackÚnextVoiceIdr¿   rÆ   s
             r;   rÙ  z-ScoreExporter.renumberVoicesWithinStaffGroups‡  sL  € ð &(ÐØÔ,ð  	<ñ  	<ˆGØÔ!Ð)ààÔ!Ð%9Ð9Ð9àõ %œl¨7Ô+=×+PÒ+PÑ+RÔ+RÑSÔSˆOà×'Ò'Ñ)Ô)×<Ò<½V¼^ÑLÔL×SÒSÑUÔUð õ >LÈNÑ=[Ô=[ˆNà .ð -ð -�Ø#$�Ø%ð -ð -�AØ�vœ|œ_ð 
-ð 
-˜Ý)¨!¬$µÑ4Ô4ð 	-à$ØœT¥HÔ$PÒPÐPà*+¬$°©(˜K˜Kð $/˜AœDØ'¨1Ñ,˜K˜Kð
-ð-ð !×'Ò'¨Ô(:Ñ;Ô;Ð;Ñ;ðA 	<ð  	<r=   c                ó  — |                       ¦   «          |                      ¦   «          t          | j        ¦  «        D ]L\  }}|                      dt          |dz   ¦  «        z   ¦  «         | j                             |j        ¦  «         ŒMdS )a5  
        calls .joinPartStaffs() from the
        :class:`~music21.musicxml.partStaffExporter.PartStaffExporterMixin`,
        then calls .setScoreHeader(),
        then appends each PartExporter's xmlRoot from
        self.partExporterList to self.xmlRoot.

        Called automatically by .parse().
        zPart rÃ   N)ÚjoinPartStaffsÚsetScoreHeaderÚ	enumeraterÈ  r  r2   rü   r¼   )r�   rå   Úpexs      r;   rÜ  zScoreExporter.postPartProcess²  sŽ   € ð 	×ÒÑÔÐØ×ÒÑÔÐÝ Ô 5Ñ6Ô6ð 	-ð 	-‰FˆAˆsØ×"Ò" 7­S°°Q±©Z¬ZÑ#7Ñ8Ô8Ð8ØŒL×Ò ¤Ñ,Ô,Ð,Ð,ð	-ð 	-r=   c                óJ  — | j         }t          |¦  «        | _        |                      ¦   «          |                      ¦   «          |                      ¦   «          | j        D ]/}| j                             |  	                    |¦  «        ¦  «         Œ0|  
                    ¦   «          dS )a`  
        Sets the group score-header in <score-partwise>.  Note that score-header is not
        a separate tag, but just a way of grouping things from the tag.

        runs `setTitles()`, `setIdentification()`, `setDefaults()`, changes textBoxes
        to `<credit>` and does the major task of setting up the part-list with `setPartList()`.
        N)r"   rN   rÂ  Ú	setTitlesÚsetIdentificationÚsetDefaultsrÇ  rü   r¼   ÚtextBoxToXmlCreditÚsetPartList)r�   rF   Útbs      r;   r  zScoreExporter.setScoreHeaderÂ  s£   € ð ŒKˆõ 4°AÑ6Ô6ˆÔà�ŠÑÔÐØ×ÒÑ Ô Ð Ø×ÒÑÔÐà”.ð 	=ð 	=ˆBØŒL×Ò × 7Ò 7¸Ñ ;Ô ;Ñ<Ô<Ð<Ð<ð 	×ÒÑÔÐÐÐr=   ÚtextBoxútext.TextBoxc                ó*  — t          d¦  «        }|j        �)|                     dt          |j        ¦  «        ¦  «         n|                     dd¦  «         t          d¦  «        }d|j        v r|                     dd¦  «         |j        |_        |                      ||¦  «         |j        rQ|j        }t          j
        rt          |t          j        ¦  «        sJ ‚|j        �|                     d	|j        ¦  «         |                     |¦  «         |S )
a“  
        Convert a music21 TextBox to a MusicXML Credit.

        >>> tb = text.TextBox('testing')
        >>> tb.style.absoluteY = 400
        >>> tb.style.absoluteX = 300
        >>> tb.page = 3
        >>> SX = musicxml.m21ToXml.ScoreExporter()
        >>> mxCredit = SX.textBoxToXmlCredit(tb)
        >>> SX.dump(mxCredit)
        <credit page="3">
          <credit-words default-x="300" default-y="400"
               halign="center" valign="top">testing</credit-words>
        </credit>

        Default of page 1:

        >>> tb = text.TextBox('testing')
        >>> tb.page
        1
        >>> mxCredit = SX.textBoxToXmlCredit(tb)
        >>> SX.dump(mxCredit)
        <credit page="1">...</credit>

        * Changed in v8: Multi-line text now exports as one `<credit-words>`
          element (preserving newlines).

        >>> tb = text.TextBox('Snare\nCymbals')
        >>> mxCredit = SX.textBoxToXmlCredit(tb)
        >>> SX.dump(mxCredit)
        <credit page="1">
            <credit-words default-x="500" default-y="500" halign="center" valign="top"
            xml:space="preserve">Snare
            Cymbals</credit-words>
        </credit>
        ÚcreditNÚpageÚ1zcredit-wordsú
z	xml:spaceÚpreserver8  )r   r'  r-  r2   Úcontentr&   rA  r'  r$   rê  rë  r‡   Ú	TextStyler8  r¼   )r�   r#  ÚmxCreditÚmxCreditWordsÚstys        r;   r   z ScoreExporter.textBoxToXmlCreditÙ  s  € õL ˜8Ñ$Ô$ˆð Œ<Ð#Ø�LŠL˜¥ W¤\Ñ!2Ô!2Ñ3Ô3Ð3Ð3à�LŠL˜ Ñ%Ô%Ð%å Ñ/Ô/ˆØ�7”?Ð"Ð"Ø×Ò˜k¨:Ñ6Ô6Ð6Ø$œ_ˆÔà×Ò ¨wÑ7Ô7Ð7ØÔ&ð 	:Ø”-ˆCÝŒð 8Ý! #¥u¤Ñ7Ô7Ð7Ð7Ð7ØŒ{Ð&Ø×!Ò! )¨S¬[Ñ9Ô9Ð9Ø�Š˜Ñ&Ô&Ð&Øˆr=   c                ó  — | j         €6t          j        ¦   «         }t          j        |_        t          j        |_        n| j         }t          | j        d¦  «        }|j        €|j        �bt          |d¦  «        }t          |d¦  «        }t          |j        ¦  «        |_	        t          |d¦  «        }t          |j        ¦  «        |_	        |j
        �/|                      |j
        ¦  «        }|                     |¦  «         |j        �/|                      |j        ¦  «        }|                     |¦  «         |j        D ],}|                      |¦  «        }	|                     |	¦  «         Œ-|                      |¦  «         |S )aN  
        Returns a default object from self.firstScoreLayout or a very simple one if none exists.

        Simple:

        >>> SX = musicxml.m21ToXml.ScoreExporter()
        >>> mxDefaults = SX.setDefaults()
        >>> SX.dump(mxDefaults)
        <defaults>
          <scaling>
            <millimeters>7</millimeters>
            <tenths>40</tenths>
          </scaling>
        </defaults>

        These numbers come from the `defaults` module:

        >>> defaults.scalingMillimeters
        7
        >>> defaults.scalingTenths
        40

        More complex:

        >>> s = corpus.parse('schoenberg/opus19', 2)
        >>> SX = musicxml.m21ToXml.ScoreExporter(s)
        >>> SX.setScoreLayouts()  # necessary to call before .setDefaults()
        >>> mxDefaults = SX.setDefaults()
        >>> mxDefaults.tag
        'defaults'
        >>> mxScaling = mxDefaults.find('scaling')
        >>> SX.dump(mxScaling)
        <scaling>
          <millimeters>6.1472</millimeters>
          <tenths>40</tenths>
        </scaling>

        >>> mxPageLayout = mxDefaults.find('page-layout')
        >>> SX.dump(mxPageLayout)
        <page-layout>
          <page-height>1818</page-height>
          <page-width>1405</page-width>
          <page-margins>
            <left-margin>83</left-margin>
            <right-margin>83</right-margin>
            <top-margin>103</top-margin>
            <bottom-margin>103</bottom-margin>
          </page-margins>
        </page-layout>

        >>> mxSystemLayout = mxDefaults.find('system-layout')
        >>> SX.dump(mxSystemLayout)
        <system-layout>
          <system-margins>
            <left-margin>0</left-margin>
            <right-margin>0</right-margin>
          </system-margins>
          <system-distance>121</system-distance>
          <top-system-distance>70</top-system-distance>
        </system-layout>

        >>> mxStaffLayoutList = mxDefaults.findall('staff-layout')
        >>> len(mxStaffLayoutList)
        1
        >>> SX.dump(mxStaffLayoutList[0])
        <staff-layout>
          <staff-distance>98</staff-distance>
        </staff-layout>
        Nr   ÚscalingÚmillimetersÚtenths)rÆ  r   rù  r   ÚscalingMillimetersÚscalingTenthsr   rü   r2   r&   r�  r€  r¼   r–  r•  ÚstaffLayoutListr£  ÚaddStyleToXmlDefaults)
r�   ÚscoreLayoutÚ
mxDefaultsÚ	mxScalingÚmxMillimetersÚmxTenthsr…  r—  r   r¢  s
             r;   r  zScoreExporter.setDefaults  sm  € ðR Ô Ð(Ý Ô,Ñ.Ô.ˆKÝ-5Ô-HˆKÔ*Ý(0Ô(>ˆKÔ%Ð%àÔ/ˆKå ¤¨jÑ9Ô9ˆ
ØÔ)Ð5¸Ô9RÐ9^Ý" :¨yÑ9Ô9ˆIÝ& y°-Ñ@Ô@ˆMÝ!$ [Ô%CÑ!DÔ!DˆMÔÝ! )¨XÑ6Ô6ˆHÝ Ô 9Ñ:Ô:ˆHŒMàÔ!Ð-Ø×9Ò9¸+Ô:PÑQÔQˆLØ×Ò˜lÑ+Ô+Ð+àÔ#Ð/Ø!×?Ò?ÀÔ@XÑYÔYˆNØ×Ò˜nÑ-Ô-Ð-à&Ô6ð 	-ð 	-ˆKØ ×<Ò<¸[ÑIÔIˆMØ×Ò˜mÑ,Ô,Ð,Ð,à×"Ò" :Ñ.Ô.Ð.ØÐr=   c                óŒ  — | j         j        sdS |                      ¦   «         }|�|                     |¦  «         | j         j        }|j        �+t          |d¦  «        }|                      ||j        ¦  «         |j        �+t          |d¦  «        }|                      ||j        ¦  «         |j	        D ]E\  }}t          |d¦  «        }|�|                      ||¦  «         |�| 
                    d|¦  «         ŒF|j        D ]E\  }	}
t          |d¦  «        }|	�| 
                    d|	¦  «         |
�| 
                    d|
¦  «         ŒFdS )a.  
        Optionally add an <appearance> tag (using `styleToXmlAppearance`)
        and <music-font>, <word-font>, zero or more <lyric-font> tags,
        and zero or more <lyric-language> tags to mxDefaults

        Demonstrating round tripping:

        >>> import xml.etree.ElementTree as ET
        >>> from xml.etree.ElementTree import fromstring as EL
        >>> defaults = ET.fromstring(
        ...     '<defaults>'
        ...     '<music-font font-family="Maestro, Opus" font-weight="bold" />'
        ...     '<word-font font-family="Garamond" font-style="italic" />'
        ...     '<lyric-font name="verse" font-size="12" />'
        ...     '<lyric-font name="chorus" font-size="14" />'
        ...     '<lyric-language name="verse" xml:lang="fr" />'
        ...     '<lyric-language name="chorus" xml:lang="en" />'
        ...     '</defaults>'
        ... )

        >>> MI = musicxml.xmlToM21.MusicXMLImporter()
        >>> MI.styleFromXmlDefaults(defaults)
        >>> SX = musicxml.m21ToXml.ScoreExporter(MI.stream)
        >>> mxDefaults = ET.Element('defaults')
        >>> SX.addStyleToXmlDefaults(mxDefaults)
        >>> SX.dump(mxDefaults)
        <defaults>
            <music-font font-family="Maestro,Opus" font-weight="bold" />
            <word-font font-family="Garamond" font-style="italic" />
            <lyric-font font-size="12" name="verse" />
            <lyric-font font-size="14" name="chorus" />
            <lyric-language name="verse" xml:lang="fr" />
            <lyric-language name="chorus" xml:lang="en" />
        </defaults>
        Nz
music-fontz	word-fontz
lyric-fontrß   zlyric-languagezxml:lang)r"   r'  ÚstyleToXmlAppearancer¼   r$   Ú	musicFontr   rM  ÚwordFontÚ
lyricFontsr-  ÚlyricLanguages)r�   r9  ÚmxAppearancerÎ   ÚmxMusicFontÚ
mxWordFontÚ	lyricNameÚ	lyricFontÚmxLyricFontÚ	lyricTypeÚ	lyricLangÚmxLyricLanguages               r;   r7  z#ScoreExporter.addStyleToXmlDefaults€  sj  € ðJ Œ{Ô.ð 	ØˆFà×0Ò0Ñ2Ô2ˆØÐ#Ø×Ò˜lÑ+Ô+Ð+àŒ[ÔˆØŒ<Ð#Ý$ Z°Ñ>Ô>ˆKØ�LŠL˜ b¤lÑ3Ô3Ð3àŒ;Ð"Ý# J°Ñ<Ô<ˆJØ�LŠL˜ R¤[Ñ1Ô1Ð1à$&¤Mð 	3ð 	3Ñ ˆI�yÝ$ Z°Ñ>Ô>ˆKØÐ$Ø—’˜[¨)Ñ4Ô4Ð4ØÐ$Ø—’ ¨	Ñ2Ô2Ð2øà$&Ô$5ð 	;ð 	;Ñ ˆI�yÝ(¨Ð5EÑFÔFˆOØÐ$Ø×#Ò# F¨IÑ6Ô6Ð6ØÐ$Ø×#Ò# J°	Ñ:Ô:Ð:øð	;ð 	;r=   c                ó,  — | j         j        }|j        s|j        s|j        s	|j        sdS t          d¦  «        }dD ]W\  }}t          ||¦  «        }|D ]?\  }}t          ||¦  «        }| 	                    d|¦  «         t          |¦  «        |_        Œ@ŒX|S )a  
        Populates the <appearance> tag of the <defaults> with
        information from the stream's .style information.

        >>> s = stream.Score()
        >>> s.style.lineWidths.append(('beam', 5.0))
        >>> s.style.noteSizes.append(('cue', 75))
        >>> s.style.distances.append(('hyphen', 0.1))
        >>> s.style.otherAppearances.append(('flags', 'wavy'))
        >>> SX = musicxml.m21ToXml.ScoreExporter(s)
        >>> mxAppearance = SX.styleToXmlAppearance()
        >>> SX.dump(mxAppearance)
        <appearance>
          <line-width type="beam">5.0</line-width>
          <note-size type="cue">75</note-size>
          <distance type="hyphen">0.1</distance>
          <other-appearance type="flags">wavy</other-appearance>
        </appearance>
        NÚ
appearance))Ú
lineWidthsz
line-width)Ú	noteSizesz	note-size)Ú	distancesrš  )ÚotherAppearanceszother-appearanceÚtype)r"   r$   rN  rO  rP  rQ  r   r]   r   r-  r2   r&   )	r�   rÎ   rC  ÚthisPropertyrT   ÚpropertyListÚpropertyTypeÚpropertyValueÚ
mxPropertys	            r;   r>  z"ScoreExporter.styleToXmlAppearanceÃ  sÊ   € ð* Œ[Ôˆà”ð 	Øœð	àœð	ð Ô+ð	ð �4å˜|Ñ,Ô,ˆð"Lð 	5ð 	5ÑˆL˜#õ # 2 |Ñ4Ô4ˆLØ/;ð 5ð 5Ñ+�˜mÝ'¨°cÑ:Ô:�
Ø—’˜v |Ñ4Ô4Ð4Ý"% mÑ"4Ô"4�
”�ð5ð
 Ðr=   c                ó@  — | j         }t          | j        d¦  «        }|                     t          j        ¦  «        }i }d}| j        D �]U}|j        }|D ]x}|| j        v rŒ| 	                    |¦  «        rW|  
                    |¦  «        }	|	                     dt          |¦  «        ¦  «         |||<   |dz  }|                     |	¦  «         Œy|                     ¦   «         }
|                     |
¦  «         d}|D ]¢}|| j        v rŒ|                     |¦  «        r�|                     ¦   «         D ]\  }}||u r|} nŒt#          d¦  «        }	|	                     dd¦  «         |�#|	                     dt          |¦  «        ¦  «         |                     |	¦  «         Œ£�ŒW|S )añ  
        Returns a <part-list> and appends it to self.xmlRoot.

        This is harder than it looks because MusicXML and music21's idea of where to store
        staff-groups are quite different.

        We find each stream in self.partExporterList, then look at the StaffGroup spanners in
        self.spannerBundle.  If the part is the first element in a StaffGroup then we add a
        <staff-group> object with 'start' as the starting point (and same for multiple StaffGroups)
        this is in `staffGroupToXmlPartGroup(sg)`.
        then we add the <score-part> descriptor of the part and its instruments, etc. (currently
        just one!), then we iterate again through all StaffGroups and if this part is the last
        element in a StaffGroup we add a <staff-group> descriptor with type="stop".

        This Bach example has four parts and one staff-group bracket linking them:

        >>> b = corpus.parse('bwv66.6')
        >>> SX = musicxml.m21ToXml.ScoreExporter(b)

        Needs some strange setup to make this work in a demo.  `.parse()` takes care of all this.

        >>> SX.scorePreliminaries()
        >>> SX.parsePartlikeScore()

        >>> mxPartList = SX.setPartList()
        >>> SX.dump(mxPartList)
        <part-list>
          <part-group number="1" type="start">...
          <score-part id="P1">...
          <score-part id="P2">...
          <score-part id="P3">...
          <score-part id="P4">...
          <part-group number="1" type="stop" />
        </part-list>

        Multi-staff parts (such as piano staves), should NOT receive `<part-group>` tags,
        since they are joined by `<staff>` tags:

        >>> cpe = corpus.parse('cpebach')
        >>> SX = musicxml.m21ToXml.ScoreExporter(cpe)
        >>> SX.scorePreliminaries()
        >>> SX.parsePartlikeScore()
        >>> SX.joinPartStaffs()

        >>> mxPartList = SX.setPartList()
        >>> SX.dump(mxPartList)
        <part-list>
          <score-part id="P1">...
          </score-part>
        </part-list>
        z	part-listrÃ   rÅ   Nú
part-grouprR  Ústop)rÃ  r   rü   Ú
getByClassr   Ú
StaffGrouprÈ  r"   rÉ  ÚisFirstÚstaffGroupToXmlPartGroupr-  r2   r¼   ÚgetXmlScorePartÚisLastrœ   r   )r�   rÃ  Ú
mxPartListÚstaffGroupsÚpartGroupIndexRefÚpartGroupIndexr  r®   r  ÚmxPartGroupÚmxScorePartÚactiveIndexÚkr1   s                 r;   r!  zScoreExporter.setPartListí  sá  € ðl Ô*ˆå ¤¨kÑ:Ô:ˆ
ð $×.Ò.­vÔ/@ÑAÔAˆð ÐØˆØÔ(ð  	3ñ  	3ˆCØ”
ˆAà!ð 	3ð 	3�Ø˜Ô*Ð*Ð*ØØ—:’:˜a‘=”=ð 3Ø"&×"?Ò"?ÀÑ"CÔ"C�KØ—O’O H­c°.Ñ.AÔ.AÑBÔBÐBà8:Ð% nÑ5Ø" aÑ'�NØ×%Ò% kÑ2Ô2Ð2øà×-Ò-Ñ/Ô/ˆKØ×Ò˜kÑ*Ô*Ð*àˆKØ!ð 3ð 3�Ø˜Ô*Ð*Ð*Øà—9’9˜Q‘<”<ð 
3à$5×$;Ò$;Ñ$=Ô$=ð "ð "™˜˜5Ø  B˜;˜;Ø*+˜KØ!˜Eð 'õ #*¨,Ñ"7Ô"7�KØ—O’O F¨FÑ3Ô3Ð3Ø"Ð.Ø#Ÿš¨µ#°kÑ2BÔ2BÑCÔCÐCØ×%Ò% kÑ2Ô2Ð2øñ3ð  Ðr=   c                ó&  — t          d¦  «        }|                     dd¦  «         t          } |||dd¦  «         |j        j        r&t          |d¦  «        }|                     dd¦  «          |||d	d
¦  «          |||dd¦  «        }|�,|                      ||¦  «         |                      ||¦  «         t          |d¦  «        }|j        du rd|_	        n#|j        du rd|_	        n|j        dk    rd|_	        |  
                    ||¦  «         |S )a‹  
        Create and configure an mxPartGroup object for the 'start' tag
        from a staff group spanner. Note that this object
        is not completely formed by this procedure (number isn't done).

        >>> b = corpus.parse('bwv66.6')
        >>> SX = musicxml.m21ToXml.ScoreExporter(b)
        >>> firstStaffGroup = b.spannerBundle.getByClass(layout.StaffGroup)[0]
        >>> mxPartGroup = SX.staffGroupToXmlPartGroup(firstStaffGroup)
        >>> SX.dump(mxPartGroup)
        <part-group type="start">
          <group-symbol>bracket</group-symbol>
          <group-barline>yes</group-barline>
        </part-group>

        At this point, you should set the number of the mxPartGroup, since it is required:

        >>> mxPartGroup.set('number', str(1))

        What can we do with it?

        >>> firstStaffGroup.name = 'Voices'
        >>> firstStaffGroup.abbreviation = 'Ch.'
        >>> firstStaffGroup.symbol = 'brace' # 'none', 'brace', 'line', 'bracket', 'square'
        >>> firstStaffGroup.barTogether = False  # True, False, or 'Mensurstrich'
        >>> mxPartGroup = SX.staffGroupToXmlPartGroup(firstStaffGroup)
        >>> SX.dump(mxPartGroup)
        <part-group type="start">
          <group-name>Voices</group-name>
          <group-abbreviation>Ch.</group-abbreviation>
          <group-symbol>brace</group-symbol>
          <group-barline>no</group-barline>
        </part-group>

        Now we avoid printing the name of the group:

        >>> firstStaffGroup.style.hideObjectOnPrint = True
        >>> mxPartGroup = SX.staffGroupToXmlPartGroup(firstStaffGroup)
        >>> SX.dump(mxPartGroup)
        <part-group type="start">
          <group-name>Voices</group-name>
          <group-name-display print-object="no" />
          <group-abbreviation>Ch.</group-abbreviation>
          <group-symbol>brace</group-symbol>
          <group-barline>no</group-barline>
        </part-group>
        rY  rR  Ústartz
group-namerß   zgroup-name-displayrP  rQ  zgroup-abbreviationÚabbreviationzgroup-symbolÚsymbolNzgroup-barlineTr¯  FÚMensurstrich)r   r-  r`   r$   rR  r   rN  rL  ÚbarTogetherr&   ry  )r�   r  re  r�  ÚmxGroupNameDisplayÚmxGroupSymbolÚmxGroupBarlines          r;   r^  z&ScoreExporter.staffGroupToXmlPartGroupR  sG  € õb ˜lÑ+Ô+ˆØ�Š˜ Ñ(Ô(Ð(Ý'ˆØˆˆZ˜ l°FÑ;Ô;Ð;ØÔÔ-ð 	9Ý!+¨KÐ9MÑ!NÔ!NÐØ×"Ò" >°4Ñ8Ô8Ð8ØˆˆZ˜Ð&:¸NÑKÔKÐKØ˜˜Z¨°nÀhÑOÔOˆØÐ$Ø�MŠM˜-¨Ñ4Ô4Ð4Ø×Ò˜]¨JÑ7Ô7Ð7å# K°ÑAÔAˆØÔ! TÐ)Ð)Ø"'ˆNÔÐØÔ# uÐ,Ð,Ø"&ˆNÔÐØÔ# ~Ò5Ð5Ø"0ˆNÔà×Ò˜+ zÑ2Ô2Ð2ð Ðr=   c                ó¨  — | j         �| j         }nt          | j        d¦  «        }|| _         d}| j        �O| j                             ddd¬¦  «        D ]1\  }}|                      |¦  «        }|                     |¦  «         d}Œ2|du rCt          j        r7t          |d¦  «        }| 	                    dd¦  «         t          j        |_
        | j        �X| j        d	         }|D ]H}t          |d
¦  «        }|j        �| 	                    d|j        ¦  «         t          |¦  «        |_
        ŒI|                      ¦   «          |                      ¦   «          |S )a	  
        Returns an identification object from self.scoreMetadata and appends it to the score.

        For defaults:

        >>> SX = musicxml.m21ToXml.ScoreExporter()
        >>> mxIdentification = SX.setIdentification()
        >>> SX.dump(mxIdentification)
        <identification>
          <creator type="composer">Music21</creator>
          <encoding>
            <encoding-date>20...-...-...</encoding-date>
            <software>music21 v...</software>
            <supports element="beam" type="yes" />
            <supports element="stem" type="yes" />
            <supports element="accidental" type="yes" />
          </encoding>
        </identification>

        More realistic:

        >>> md = metadata.Metadata()
        >>> md.composer = 'Francesca Caccini'
        >>> c = metadata.Contributor(role='arranger', name='Aliyah Shanti')
        >>> md.addContributor(c)

        Need a fresh ScoreExporter, or, it will otherwise append to the existing mxIdentification

        >>> SX = musicxml.m21ToXml.ScoreExporter()
        >>> SX.scoreMetadata = md
        >>> mxIdentification = SX.setIdentification()
        >>> SX.dump(mxIdentification)
        <identification>
          <creator type="composer">Francesca Caccini</creator>
          <creator type="arranger">Aliyah Shanti</creator>
          <encoding>
            <encoding-date>...</encoding-date>
            <software>music21 v...</software>
            <supports element="beam" type="yes" />
            <supports element="stem" type="yes" />
            <supports element="accidental" type="yes" />
          </encoding>
        </identification>

        Overriding the default:

        >>> defaults.author = "Batch Conversion March 2022"
        >>> SX = musicxml.m21ToXml.ScoreExporter()
        >>> mxIdentification = SX.setIdentification()
        >>> SX.dump(mxIdentification)
        <identification>
          <creator type="composer">Batch Conversion March 2022</creator>
          <encoding>
            <encoding-date>20...-...-...</encoding-date>
            <software>music21 v...</software>
            <supports element="beam" type="yes" />
            <supports element="stem" type="yes" />
            <supports element="accidental" type="yes" />
          </encoding>
        </identification>
        NÚidentificationFT)ÚskipNonContributorsÚreturnPrimitivesÚreturnSortedÚcreatorrR  ÚcomposerÚ	copyrightÚrights)rÁ  r   rü   rÂ  ÚallÚcontributorToXmlCreatorr¼   r   Úauthorr-  r&   Úroler2   ÚsetEncodingÚmetadataToMiscellaneous)r�   ÚmxIdÚfoundOneÚ_rv  Ú	mxCreatorÚ
copyrightsÚmxRightss           r;   r  zScoreExporter.setIdentification�  sr  € ð~ Ô Ð,ØÔ(ˆDˆDå˜dœlÐ,<Ñ=Ô=ˆDØ$(ˆDÔ!ð ˆØÔÐ)ð
 Ô*×.Ò.Ø(,Ø%)Ø!&ð /ñ (ô (ð  ð  ‘��1ð !×8Ò8¸Ñ;Ô;�	Ø—’˜IÑ&Ô&Ð&Ø��à�uÐÐ¥¤ÐÝ" 4¨Ñ3Ô3ˆIØ�MŠM˜& *Ñ-Ô-Ð-Ý%œ_ˆIŒNàÔÐ)Ø9=Ô9KÈKÔ9XˆJØð 'ð '�Ý% d¨HÑ5Ô5�Ø”6Ð%Ø—L’L ¨¬Ñ0Ô0Ð0Ý # A¡¤�”�ð 	×ÒÑÔÐð 	×$Ò$Ñ&Ô&Ð&àˆr=   rL   rH   rY   c                ó6  — |€	| j         €dS |€| j         }t          j        r|€J ‚t          d¦  «        }d}|                     ddd¬¦  «        }d}d}d}|D ]Ÿ\  }}	|dk    rŒ|dk    r|sd}Œ|dk    r|sd}Œ"|d	k    r|sd}Œ-|d
k    rŒ4|                     |¦  «        }
|
€|}
|
                     d¦  «        rŒct          |d¦  «        }|                     d|
¦  «         t          |	¦  «        |_
        d}Œ | j        �|r| j                             |¦  «         |S )a  
        Returns an mxMiscellaneous of information from metadata object md or
        from self.scoreMetadata if md is None.  If the mxMiscellaneous object
        has any miscellaneous-fields, then it is appended to self.mxIdentification
        if it exists.

        >>> SX = musicxml.m21ToXml.ScoreExporter()
        >>> md = metadata.Metadata()
        >>> md.date = metadata.primitives.DateRelative('1689', 'onOrBefore')
        >>> md.localeOfComposition = 'Rome'

        >>> mxMisc = SX.metadataToMiscellaneous(md)
        >>> SX.dump(mxMisc)
        <miscellaneous>
          <miscellaneous-field name="dcterms:created">1689/--/-- or earlier</miscellaneous-field>
          <miscellaneous-field name="humdrum:OPC">Rome</miscellaneous-field>
        </miscellaneous>
        NÚmiscellaneousFT)ÚskipContributorsru  rv  ÚsoftwareÚmovementNameÚmovementNumberrß  ry  zm21FileInfo:zmiscellaneous-fieldrß   )rÂ  rê  rë  r   r{  ÚuniqueNameToNamespaceNameÚ
startswithr   r-  r2   r&   rÁ  r¼   )r�   rL   ÚmxMiscellaneousr‚  ÚallItemsÚskippedOneMovementNameÚskippedOneMovementNumberÚskippedOneTitleÚ
uniqueNamer1   ÚnamespaceNameÚmxMiscFields               r;   r€  z%ScoreExporter.metadataToMiscellaneous	  s¥  € ð. ˆ:˜$Ô,Ð4Ø�4ØˆZØÔ#ˆBåŒ?ð 	"Ø�>�>�>å! /Ñ2Ô2ˆàˆà—6’6Ø!Ø!Øð ñ 
ô 
ˆð (-ÐØ).Ð Ø %ˆØ!)ð +	ð +	ÑˆJ˜Ø˜ZÒ'Ð'àà˜^Ò+Ð+ð .ð Ø-1Ð*ØàÐ-Ò-Ð-ð 0ð Ø/3Ð,Øà˜WÒ$Ð$ð 'ð Ø&*�OØà˜[Ò(Ð(àà&(×&BÒ&BÀ:Ñ&NÔ&NˆMØÐ$Ø *�à×'Ò'¨Ñ7Ô7ð ð å$ _Ð6KÑLÔLˆKØ�OŠO˜F MÑ2Ô2Ð2Ý" 5™zœzˆKÔØˆHˆHàÔ Ð,°Ð,ØÔ!×(Ò(¨Ñ9Ô9Ð9ð Ðr=   c                óî  — | j         �t          | j         d¦  «        }nt          d¦  «        }t          |d¦  «        }t          t          j                             ¦   «         ¦  «        |_        | j        �2d}| j        j	        D ]"}d|v r|rŒ	d}t          |d¦  «        }||_        Œ#n!t          |d¦  «        }t          j	        |_        |                      ¦   «         }|D ]}|                     |¦  «         Œ|S )aœ  
        Returns an encoding object that might have information about <supports> also.
        and appends to mxIdentification (if any)

        Will use the date of generation as encoding-date.

        >>> SX = musicxml.m21ToXml.ScoreExporter()
        >>> mxEncoding = SX.setEncoding()
        >>> SX.dump(mxEncoding)
        <encoding>
          <encoding-date>20...-...-...</encoding-date>
          <software>music21 v...</software>
          <supports element="beam" type="yes" />
          <supports element="stem" type="yes" />
          <supports element="accidental" type="yes" />
        </encoding>

        Encoding-date is in YYYY-MM-DD format.
        NÚencodingzencoding-dateFz
music21 v.TrŠ  )rÁ  r   r   r2   ÚdatetimeÚdateÚtodayr&   rÂ  rŠ  r   ÚgetSupportsr¼   )r�   Ú
mxEncodingÚmxEncodingDateÚfound_m21_alreadyrŠ  Ú
mxSoftwareÚmxSupportsListÚ
mxSupportss           r;   r  zScoreExporter.setEncodinge	  s  € ð* Ô Ð,Ý# DÔ$9¸:ÑFÔFˆJˆJå  Ñ,Ô,ˆJå# J°Ñ@Ô@ˆÝ!¥(¤-×"5Ò"5Ñ"7Ô"7Ñ8Ô8ˆÔð ÔÐ)Ø %ÐØ Ô.Ô7ð 	+ð 	+�Ø 8Ð+Ð+Ø(ð 1ð !à,0Ð)Ý'¨
°JÑ?Ô?�
Ø"*�
”�ð	+õ $ J°
Ñ;Ô;ˆJÝ&Ô/ˆJŒOð ×)Ò)Ñ+Ô+ˆØ(ð 	*ð 	*ˆJØ×Ò˜jÑ)Ô)Ð)Ð)àÐr=   úlist[Element]c                ó  — 	 ddd	„} |d
d¦  «         |dd¦  «         |dd¦  «        g}| j         }|j        r!|                      |dddd¦  «        ¦  «         |j        r!|                      |dddd¦  «        ¦  «         |S )a€  
        return a list of <supports> tags for what this supports.  Does not append to
        mxEncoding itself.

        Currently just supports beam, stem, accidental, and
        print's new-system if s.definesExplicitSystemBreaks is True
        and print's new-page if s.definesExplicitPageBreaks is True.

        >>> SX = musicxml.m21ToXml.ScoreExporter()
        >>> SX.getSupports()
        [<Element 'supports' at 0x...>,
         <Element 'supports' at 0x...>,
         <Element 'supports' at 0x...>]
        >>> for support in SX.getSupports():
        ...     SX.dump(support)
        <supports element="beam" type="yes" />
        <supports element="stem" type="yes" />
        <supports element="accidental" type="yes" />

        >>> SX.stream.definesExplicitSystemBreaks = True
        >>> len(SX.getSupports())
        4
        >>> SX.dump(SX.getSupports()[-1])
        <supports attribute="new-system" element="print" type="yes" value="yes" />

        >>> SX.stream.definesExplicitPageBreaks = True
        >>> SX.dump(SX.getSupports()[-1])
        <supports attribute="new-page" element="print" type="yes" value="yes" />

        NÚelementr2   Úsupports_typerX   Ú	attributerV   r1   c                ó$  — t          d¦  «        }|                     d| ¦  «         |                     dt          j        |¦  «        ¦  «         |r@|                     d|¦  «         |�(|                     dt          j        |¦  «        ¦  «         |S )NÚsupportsr¥  rR  r§  r1   )r   r-  r*   r+  )r¥  r¦  r§  r1   Úsus        r;   Ú
getSupportz-ScoreExporter.getSupports.<locals>.getSupport»	  s‰   € å˜Ñ$Ô$ˆBØ�FŠF�9˜gÑ&Ô&Ð&Ø�FŠF�6�:Ô4°]ÑCÔCÑDÔDÐDØð FØ—’�{ IÑ.Ô.Ð.ØÐ$Ø—F’F˜7¥JÔ$=¸eÑ$DÔ$DÑEÔEÐEØˆIr=   ÚbeamTÚstemr¤  r{  r“  r¯  r|  ©NN)r¥  r2   r¦  rX   r§  rV   r1   rV   )r"   ÚdefinesExplicitSystemBreaksr¼   ÚdefinesExplicitPageBreaks)r�   r«  ÚsupportsListrF   s       r;   rœ  zScoreExporter.getSupportsœ	  sÈ   € ð@ FJð		ð 		ð 		ð 		ð 		ð ˆJ�v˜tÑ$Ô$ØˆJ�v˜tÑ$Ô$ØˆJ�| TÑ*Ô*ð'
ˆð ŒKˆØÔ(ð 	PØ×Ò 
 
¨7°D¸,ÈÑ NÔ NÑOÔOÐOàÔ&ð 	NØ×Ò 
 
¨7°D¸*ÀeÑ LÔ LÑMÔMÐMàÐr=   c                ó�  — | j         }| j         €t          j        ¦   «         }t          j        r|€J ‚| j        }t          d¦  «        }d}|d         }|r4|€|d         }t          |d¦  «        }t          |d         ¦  «        |_	        t          |¦  «        r|                     |¦  «         |d         }|r*t          |d¦  «        }t          |d         ¦  «        |_	        d}	|d	         }
|
rt          |
d         ¦  «        }	n-|�t          |¦  «        }	nt          j        rt          j        }	ndS t          |d
¦  «        }|	|_	        dS )zd
        puts work (with work-title), movement-number, movement-title into the self.xmlRoot
        NÚworkrß  r   z
work-titlerŒ  zmovement-numberr@   r‹  zmovement-title)rÂ  r   rá  rê  rë  rü   r   r   r2   r&   r  r¼   r   rß  )r�   ÚmdObjÚmxScoreHeaderÚmxWorkÚfirstTitleFoundÚtitlesÚmxWorkTitleÚmovementNumbersÚmxMovementNumberÚmovement_titleÚmovementNamesÚmxMovementTitles               r;   r  zScoreExporter.setTitlesÕ	  se  € ð Ô"ˆØÔÐ%ÝÔ%Ñ'Ô'ˆEÝŒ?ð 	%ØÐ$Ð$Ð$àœˆÝ˜‘”ˆà.2ˆØ,1°'¬NˆØð 	.ØÐ&Ø"(¨¤)�Ý$ V¨\Ñ:Ô:ˆKÝ" 6¨!¤9™~œ~ˆKÔÝˆv‰;Œ;ð 	)Ø× Ò  Ñ(Ô(Ð(à5:Ð;KÔ5LˆØð 	<Ý)¨-Ð9JÑKÔKÐÝ$'¨¸Ô(:Ñ$;Ô$;ÐÔ!ð !ˆà38¸Ô3HˆØð 	Ý  ¨qÔ!1Ñ2Ô2ˆNˆNàÐ*Ý!$ _Ñ!5Ô!5��Ý”ð Ý!)¤��à�Ý$ ]Ð4DÑEÔEˆØ-ˆÔÐÐr=   c                ó¨   — t          d¦  «        }|j        �(|                     dt          |j        ¦  «        ¦  «         |j        �|j        |_        |S )a  
        Return a <creator> tag from a :class:`~music21.metadata.Contributor` object.

        >>> md = metadata.Metadata()
        >>> md.composer = 'Oliveros, Pauline'
        >>> contrib = md.contributors[0]
        >>> contrib
        <music21.metadata.primitives.Contributor composer:Oliveros, Pauline>

        >>> SX = musicxml.m21ToXml.ScoreExporter()
        >>> mxCreator = SX.contributorToXmlCreator(contrib)
        >>> SX.dump(mxCreator)
        <creator type="composer">Oliveros, Pauline</creator>
        rw  NrR  )r   r~  r-  r2   rß   r&   )r�   rv  r„  s      r;   r|  z%ScoreExporter.contributorToXmlCreator
  sL   € õ  ˜IÑ&Ô&ˆ	ØŒ6ÐØ�MŠM˜&¥# a¤f¡+¤+Ñ.Ô.Ð.ØŒ6ÐØœVˆIŒNØÐr=   r~   )r¼  r½  r€   rX   ©r3   r   r¹  )r#  r$  r3   r   rñ   )rL   rH   r3   rY   )r3   r£  )ró   rô   rõ   rö   r‚   r‰   rÓ  rÕ  ræ  rå  rä  rÖ  rÚ  rÛ  rØ  rÙ  rÜ  r  r   r  r7  r>  r!  r^  r  r€  r  rœ  r  r|  Ú__classcell__©rÏ  s   @r;   r�   r�   V  sL  ø€ € € € € ðð ð
"/ð "/ð "/ð "/ð "/ð "/ð "/ðH)ð )ð )ð )ðV!ð !ð !ð !ðF;ð ;ð ;ð ;ð2.#ð .#ð .#ð .#ð`'ð 'ð 'ð 'ð,/ð /ð /ð /ð&-ð -ð -ð -ð
ð 
ð 
ð 
ð)ð )ð )ð )ð</ð /ð /ð /ð(<ð (<ð (<ð (<ðV-ð -ð -ð -ð ð ð ð ð.>ð >ð >ð >ð@eð eð eðNA;ð A;ð A;ðF(ð (ð (ðTcð cð cðJIð Ið IðVgð gð gð gðV &*ð]ð ]ð ]ð ]ð ]ð~5ð 5ð 5ðn7ð 7ð 7ð 7ðr..ð ..ð ..ð ..ð`ð ð ð ð ð ð r=   r�   c                  ó„   ‡ — e Zd ZU dZddiZded<   ded<   ded	<   	 	 ddˆ fd„Zd„ Zd„ Zdd„Z	d„ Z
d„ Zd„ Zd„ Zd„ Zˆ xZS )rý  zG
    Object to convert one Part stream to a <part> tag on .parse()
    ÚpreviousPartStaffInGroupa=  
            If the part being exported is a :class:`~music21.stream.base.PartStaff`,
            this attribute will be used to store the immediately previous `PartStaff`
            in the :class:`~music21.layout.StaffGroup`, if any. (E.g. if this is
            the left hand, store a reference to the right hand.)zdict[str, str]Ú	_DOC_ATTRzlist[int | None]rÍ  z&stream.Stream[meter.TimeSignatureBase]rÄ  NÚpartObjú!stream.Part | stream.Score | Nonerü  úScoreExporter | Nonec                óL  •— t          ¦   «                              ¦   «          |€t          j        ¦   «         }|| _        || _        t          d¦  «        | _        |€@t          j        t          j	                 ¦   «         | _
        ddg| _        g | _        d| _        nZ|j
        �|j
        n"t          j        t          j	                 ¦   «         | _
        |j        | _        |j        | _        |j        | _        d | _        d | _        d | _        d | _        d | _        |j        | _        d S )NÚpartr’   T)rÀ  r‚   r"   re   rü  r   rü   rk   r   ÚTimeSignatureBaserÄ  r“   rÍ  r€   rÄ  ÚinstrumentStreamÚfirstInstrumentObjectÚlastDivisionsr  rÃ  )r�   rÆ  rü  rÏ  s      €r;   r‚   zPartExporter.__init__-
  s  ø€ õ 	‰Œ×ÒÑÔÐð ˆ?Ý”k‘m”mˆGØ07ˆŒØˆŒÝ˜v‘”ˆŒàˆ>Ý%œ}­UÔ-DÔEÑGÔGˆDÔØ),¨c¨
ˆDÔ%Ø#%ˆDÔ Ø $ˆDÔÐð $*Ô#5Ð#Að !'Ô 2Ð 2å%+¤]µ5Ô3JÔ%KÑ%MÔ%Mð Ôð )/Ô(CˆDÔ%Ø#)Ô#9ˆDÔ Ø &Ô 3ˆDÔà?CˆÔ%àKOˆÔØAEˆÔ"ð "ˆÔð 37ˆŒØ$Ô2ˆÔÐÐr=   c                óX  — | j                              dd¬¦  «         | j        rt| j                              d¬¦  «        d         | _         | j                              t           j        ¦  «        r|                      ¦   «          nH|                      ¦   «          n3| j                              t           j        ¦  «        st          d¦  «        ‚| j	         
                    ¦   «          |                      ¦   «          | j                             dt          | j        j        ¦  «        ¦  «         | j                              t           j        ¦  «        D ]Ö}|                      dt          |j        ¦  «        z   ¦  «         t'          || ¬¦  «        }| j	        |_	        	 |                     ¦   «         }n]# t          $ rP}t          |j        ¦  «        |_        t-          | j         t           j        ¦  «        r| j         j        |_        |‚d	}~ww xY w| j                             |¦  «         Œ×| j        S )
a  
        Set up instruments, convert sounding pitch to written pitch,
        create a partId (if no good one exists) and set it on
        <part>, fixes up the notation
        (:meth:`fixupNotationFlat` or :meth:`fixupNotationMeasured`),
        setIdLocals() on spanner bundle. Run parse() on each measure's MeasureExporter and
        append the output to the <part> object.

        In other words, one-stop shopping.

        :attr:`makeNotation` when False, will avoid running
        :meth:`~music21.stream.base.Stream.makeNotation`
        on the Part. Generally this attribute is set on `GeneralObjectExporter`
        or `ScoreExporter` and read from there. Running with `makeNotation`
        as False will raise `MusicXMLExportException` if no measures are present.
        If `makeNotation` is False, the transposition to written pitch is still
        performed and thus will be done in place.

        >>> from music21.musicxml.m21ToXml import PartExporter
        >>> noMeasures = stream.Part(note.Note())
        >>> pex = PartExporter(noMeasures)
        >>> pex.makeNotation = False
        >>> pex.parse()
        Traceback (most recent call last):
        music21.musicxml.xmlObjects.MusicXMLExportException:
        Cannot export with makeNotation=False if there are no measures
        TrÑ  r²   r   z>Cannot export with makeNotation=False if there are no measuresr  zMeasure rû  N)r"   rÔ  r€   ÚsplitAtDurationsrÊ   rg   ÚfixupNotationMeasuredÚfixupNotationFlatr,   rÃ  ÚsetIdLocalsÚinstrumentSetuprü   r-  r2   rÍ  ÚpartIdr  rÅ   ÚMeasureExporterr‰   ÚmeasureNumberr‡   re   r½   r¼   )r�   r¿   ÚmeasureExporterÚ	mxMeasurert  s        r;   r‰   zPartExporter.parseU
  s  € ð@ 	Œ×"Ò"¨4À4Ð"ÑHÔHÐHð Ôð 		RØœ+×6Ò6¸tÐ6ÑDÔDÀQÔGˆDŒKàŒ{×-Ò-­f¬nÑ=Ô=ð )Ø×*Ò*Ñ,Ô,Ð,Ð,à×&Ò&Ñ(Ô(Ð(Ð(Ø”×/Ò/µ´Ñ?Ô?ð 	RÝ)ØPñRô Rð Rð 	Ô×&Ò&Ñ(Ô(Ð(ð 	×ÒÑÔÐàŒ×Ò˜�s 4Ô#=Ô#DÑEÔEÑFÔFÐFà”×/Ò/µ´Ñ?Ô?ð 	+ð 	+ˆAØ×"Ò" :µ°A´H±´Ñ#=Ñ>Ô>Ð>Ý-¨a¸Ð=Ñ=Ô=ˆOØ,0Ô,>ˆOÔ)ðØ+×1Ò1Ñ3Ô3�	�	øÝ*ð ð ð Ý"% a¤h¡-¤-�”Ý˜dœk­6¬;Ñ7Ô7ð 6Ø!%¤Ô!5�A”Jà�øøøøðøøøð ŒL×Ò 	Ñ*Ô*Ð*Ð*àŒ|Ðs   ÆF-Æ-
HÆ7AHÈHc                óô  — | j         �Jt          | j        ¦  «        | j         j        v r*| j         j        t          | j        ¦  «                 | _        n!| j                             dd¬¦  «        | _        | j        d         }t          j        rt          |t          j
        ¦  «        sJ ‚|| _        | j         �d„ | j         j        D ¦   «         }n| j        j        g}|j        }||v s|€|                     ¦   «          |                      ¦   «         }|rdS t!          ¦   «         }| j        D �]N}t#          |¦  «        |v rŒ|                     t#          |¦  «        ¦  «         |j        �|j        | j        v r`	 |                     | j        ¬¦  «         nC# t,          j        $ r1}t0                               t5          |¦  «        ¦  «         Y d}~nd}~ww xY w| j                             |j        ¦  «         |j        �| j         r'|j        | j         j        v r|                     ¦   «          | j         �G| j         j                             |j        ¦  «         ||u r| j         j                             |¦  «         �ŒPdS )a¨  
        Sets self.instrumentStream and self.firstInstrumentObject for the stream,
        checks for a unique midiChannel and then blocks it off from future use.

        >>> p = converter.parse('tinyNotation: 4/4 c1 d1 e1')
        >>> p.getElementsByClass(stream.Measure)[0].insert(0, instrument.Clarinet())
        >>> p.getElementsByClass(stream.Measure)[1].insert(0, instrument.BassClarinet())
        >>> PEX = musicxml.m21ToXml.PartExporter(p)
        >>> PEX.instrumentStream is None
        True
        >>> PEX.firstInstrumentObject is None
        True
        >>> PEX.instrumentSetup()
        >>> PEX.instrumentStream
        <music21.stream.Part 0x10ae02780>

        The "P" signifies that it is the main instrument associated with a Part.

        >>> PEX.instrumentStream.show('text')
        {0.0} <music21.instrument.Clarinet 'P...: Clarinet'>
        {4.0} <music21.instrument.BassClarinet 'Bass clarinet'>
        NT©rö  r³   r   c                ó   — g | ]	}|j         ‘Œ
S r÷   )rÕ  r"  s     r;   ú
<listcomp>z0PartExporter.instrumentSetup.<locals>.<listcomp>À
  s   € ÐGÐGÐG q˜!œ(ÐGÐGÐGr=   )ÚusedChannels)rü  r  r"   rÊ  rÌ  ÚgetInstrumentsrê  rë  r‡   r   Ú
InstrumentrÍ  rË  rÕ  ÚpartIdRandomizeÚ#mergeInstrumentStreamPartStaffAwarer-  rR  ÚaddÚmidiChannelrÍ  ÚautoAssignMidiChannelr   ÚInstrumentExceptionÚenvironLocalr§   r2   r¼   ÚinstrumentIdrÌ  ÚinstrumentIdRandomize)r�   rÍ  Ú
instIdListÚfirstInstIdÚshould_short_circuitÚseen_instrument_classesÚthisInstrumentrt  s           r;   rÔ  zPartExporter.instrumentSetup›
  sœ  € ð0 Œ;Ð"¥r¨$¬+¡¤¸$¼+Ô:YÐ'YÐ'Yð %)¤KÔ$CÅBÀtÄ{ÁOÄOÔ$TˆDÔ!Ð!ð %)¤K×$>Ò$>ÈTÐ[_Ð$>Ñ$`Ô$`ˆDÔ!Ø $Ô 5°aÔ 8ÐÝŒ?ð 	LÝÐ3µZÔ5JÑKÔKÐKÐKÐKØ%:ˆÔ"àŒ;Ð"ØGÐG¨D¬KÔ,FÐGÑGÔGˆJˆJàœ+œ.Ð)ˆJà+Ô2ˆØ˜*Ð$Ð$¨Ð(;Ø!×1Ò1Ñ3Ô3Ð3à#×GÒGÑIÔIÐØð 	ØˆFå"%¡%¤%ÐØ"Ô3ð 	Fñ 	FˆNõ �NÑ#Ô#Ð'>Ð>Ð>Øà#×'Ò'­¨^Ñ(<Ô(<Ñ=Ô=Ð=ØÔ*Ð2Ø%Ô1°TÔ5IÐIÐIð.Ø"×8Ò8ÀdÔFZÐ8Ñ[Ô[Ð[Ð[øÝ#Ô7ð .ð .ð .Ý ×%Ò%¥c¨!¡f¤fÑ-Ô-Ð-Ð-Ð-Ð-Ð-Ð-øøøøð.øøøð Ô ×'Ò'¨Ô(BÑCÔCÐCð Ô+Ð3Ø”Kð 4à&Ô3°t´{Ô7SÐSÐSØ×4Ò4Ñ6Ô6Ð6ð Œ{Ð&Ø”Ô,×3Ò3°NÔ4OÑPÔPÐPØ!Ð%:Ð:Ð:Ø”KÔ.×5Ò5°nÑEÔEÐEùð=	Fð 	Fs   Å5FÆGÆ 'GÇGr3   rX   c                ó®  — | j         €dS | j         j        sdS | j         j        D ]°}|                     | j        ¦  «        rˆ|dd…         D ]|}|                     dd¬¦  «        }| xj        |z  c_        | j        �t          j        | j        d¬¦  «         | j         r*| j        �#t          |¦  «        }| j        | j         j	        |<   Œ}Œ¤| j        |v r dS Œ±dS )aQ  
        Merges instrument streams from subsequent parts in a PartStaff group.

        Does nothing in the normal case of single staves.

        Returns whether instrument processing should short circuit,
        which is False for the general case and True for subsequent
        PartStaff objects after the first in a group.
        NFrÃ   TrÛ  r¡   )
rü  rÉ  r]  r"   rß  rÌ  r   Údeduplicater  rÊ  )r�   Újoined_groupÚsubsequent_staffÚother_instrumentsÚnext_ids        r;   râ  z0PartExporter.mergeInstrumentStreamPartStaffAwareí
  s$  € ð Œ;ÐØ�5ð Œ{Ô'ð 	Ø�5à œKÔ4ð 	ð 	ˆLØ×#Ò# D¤KÑ0Ô0ð à(4°Q°R°RÔ(8ð 
Yð 
YÐ$Ø(8×(GÒ(GØ&*°Dð )Hñ ):ô ):Ð%àÐ)Ô)Ð->Ñ>Ð)Ô)ØÔ,Ð8Ý"Ô.¨tÔ/DÈdÐSÑSÔSÐSð ”{ð Y tÔ'<Ð'HÝ"$Ð%5Ñ"6Ô"6˜ØCGÔCX˜œÔ7¸Ñ@øð
Yð ” Ð,Ð,ð
 �t�tð -ð ˆur=   c                ó˜   — | j         }|                     ¦   «          |                     | j        | j        d¬¦  «         |j        | _        dS )zR
        Runs makeNotation on a flatStream, such as one lacking measures.
        T)rÄ  r“   r•   N)r"   ÚmakeMutabler€   rÄ  r“   rÃ  )r�   rÊ  s     r;   rÒ  zPartExporter.fixupNotationFlat  s]   € ð Œ{ˆØ×ÒÑÔÐð 	×Ò dÔ&6Ø/3Ô/HØ"&ð 	ñ 	(ô 	(ð 	(ð& "Ô/ˆÔÐÐr=   c                ó¬  — | j         }|                     t           j        ¦  «        }|                     ¦   «         }|sdS t	          |d¦  «        rU|j        €N|                     ¦   «          |                     t
          j        ¦  «        }|r|                     ¦   «         |_        t	          |d¦  «        rU|j        €N|                     ¦   «          |                     t          j
        ¦  «        }|r|                     ¦   «         |_        t	          |d¦  «        rU|j        €N|                     ¦   «          |                     t          j        ¦  «        }|r|                     ¦   «         |_        |j                             ¦   «         s|                     d¬¦  «         |j        j        sW	 |                     d¬¦  «         n?# t&          j        $ r-}t+          j        t/          |¦  «        d¬¦  «         Y d}~nd}~ww xY w|j        j        s3|D ]0}|g|j        ¢D ]#}	t           j                             |	d¬¦  «         Œ$Œ1| j        s|j        | _        dS dS )	a>  
        Checks to see if there are any attributes in the part stream and moves
        them into the first measure if necessary.

        Checks if makeAccidentals is run, and haveBeamsBeenMade is done, and
        tuplets have been made.

        * Changed in v7: no longer accepts `measureStream` argument.
        Nr   ÚkeySignaturerã   Tr¡   r¢   )r¤   )r"   rÊ   rg   rÍ   ra  r   rö  r·   rø  r   ÚKeySignaturerã   r   ÚTimeSignatureÚstreamStatusÚhaveAccidentalsBeenMadeÚmakeAccidentalsÚbeamsÚ	makeBeamsr   ÚStreamExceptionr¦   r§   r-   ÚtupletsÚvoicesr€   rì   rÃ  )
r�   rÊ  ÚmeasuresÚfirst_measureÚ
outerClefsÚouterKeySignaturesÚouterTimeSignaturesÚser¿   Úm_or_vs
             r;   rÑ  z"PartExporter.fixupNotationMeasured1  s‘  € ð Œ{ˆØ×*Ò*­6¬>Ñ:Ô:ˆØ ŸšÑ(Ô(ˆØð 	ØˆFõ �= &Ñ)Ô)ð 	8¨mÔ.@Ð.HØ×%Ò%Ñ'Ô'Ð'Ø×0Ò0µ´Ñ;Ô;ˆJØð 8Ø%/×%5Ò%5Ñ%7Ô%7�Ô"å�= .Ñ1Ô1ð 	H°mÔ6PÐ6XØ×%Ò%Ñ'Ô'Ð'Ø!%×!8Ò!8½Ô9IÑ!JÔ!JÐØ!ð HØ-?×-EÒ-EÑ-GÔ-G�Ô*å�= /Ñ2Ô2ð 	J°}Ô7RÐ7ZØ×%Ò%Ñ'Ô'Ð'Ø"&×"9Ò"9½%Ô:MÑ"NÔ"NÐØ"ð JØ.A×.GÒ.GÑ.IÔ.I�Ô+ð Ô ×8Ò8Ñ:Ô:ð 	/Ø× Ò ¨Ð Ñ.Ô.Ð.ØÔ Ô&ð 	AðAØ—’ t�Ñ,Ô,Ð,Ð,øÝÔ/ð Að Að AÝ”�o¨bÑ1Ô1¸aÐ@Ñ@Ô@Ð@Ð@Ð@Ð@Ð@Ð@øøøøðAøøøàÔ Ô(ð 	QØð Qð Q�Ø ˜n 1¤8˜nð Qð Q�FÝÔ'×:Ò:¸6È4Ð:ÑPÔPÐPÐPðQð Ô!ð 	4Ø!%Ô!3ˆDÔÐÐð	4ð 	4s   Æ*G ÇG=Ç#G8Ç8G=c                óh  — | j         }t          d¦  «        }|                     d| j                             d¦  «        ¦  «         t          |d¦  «        }t          |d¦  «        r|j        �|j        |_        nt          j        |_        |j
        r"|j        j        s|                     dd¦  «         t          | j         d¦  «        rL|j        �Et          |d	¦  «        }|j        |_        |j
        r"|j        j        s|                     dd¦  «         t          ¦   «         }| j        D ]s}t!          |¦  «        |v rŒ|j        €|j        €|j        �J|                     |                      |¦  «        ¦  «         |                     t!          |¦  «        ¦  «         Œtt          ¦   «         }| j        D ]}t!          |¦  «        |v rŒ|j        €t/          |t0          j        ¦  «        rJ|                     |                      |¦  «        ¦  «         |                     t!          |¦  «        ¦  «         Œ€|S )
zè
        make a <score-part> from a music21 Part object and a parsed mxPart (<part>) element.

        contains details about instruments, etc.

        called directly by the ScoreExporter as a late part of the processing.
        z
score-partr  z	part-namer½   NrP  rQ  r¾   zpart-abbreviation)r"   r   r-  rü   Úgetr   ra  r½   r&   r   r'  r$   ÚprintPartNamer¾   ÚprintPartAbbreviationrÌ  rR  ÚinstrumentNameÚinstrumentAbbreviationÚmidiProgramr¼   ÚinstrumentToXmlScoreInstrumentrã  r‡   r   ÚUnpitchedPercussionÚinstrumentToXmlMidiInstrument)r�   rÊ  rf  Ú
mxPartNameÚmxPartAbbreviationrí  Úinsts          r;   r_  zPartExporter.getXmlScoreParte  s)  € ð Œ{ˆÝ˜lÑ+Ô+ˆà�Š˜˜dœl×.Ò.¨tÑ4Ô4Ñ5Ô5Ð5å ¨[Ñ9Ô9ˆ
Ý�4˜Ñ$Ô$ð 	0¨¬Ð)BØ"œmˆJŒOˆOå&Ô/ˆJŒOàÔ#ð 	1¨D¬JÔ,Dð 	1Ø�NŠN˜>¨4Ñ0Ô0Ð0õ �4”;Ð 2Ñ3Ô3ð 	=¸Ô8MÐ8YÝ!+¨KÐ9LÑ!MÔ!MÐØ&*Ô&;ÐÔ#àÔ'ð =°´
Ô0Pð =Ø"×&Ò& ~°tÑ<Ô<Ð<õ
 #&¡%¤%ÐàÔ)ð 	8ð 	8ˆDå�D‰zŒzÐ4Ð4Ð4ØØÔ#Ð/ØÔ2Ð>ØÔ'Ð3Ø×"Ò" 4×#FÒ#FÀtÑ#LÔ#LÑMÔMÐMØ'×+Ò+­D°©J¬JÑ7Ô7Ð7øå"%¡%¤%Ðð Ô)ð 	8ð 	8ˆDå�D‰zŒzÐ4Ð4Ð4ØàÔÐ+­z¸$Å
Ô@^Ñ/_Ô/_Ð+Ø×"Ò" 4×#EÒ#EÀdÑ#KÔ#KÑLÔLÐLØ'×+Ò+­D°©J¬JÑ7Ô7Ð7øàÐr=   c                ó&  — t          d¦  «        }|                     dt          |j        ¦  «        ¦  «         t	          |d¦  «        }t          |j        ¦  «        |_        |j        �)t	          |d¦  «        }t          |j        ¦  «        |_        |S )aÜ  
        Convert an :class:`~music21.instrument.Instrument` object to a
        <score-instrument> element and return it.

        >>> i = instrument.Clarinet()
        >>> i.instrumentId = 'clarinet1'
        >>> i.midiChannel = 4
        >>> PEX = musicxml.m21ToXml.PartExporter()
        >>> mxScoreInstrument = PEX.instrumentToXmlScoreInstrument(i)
        >>> PEX.dump(mxScoreInstrument)
        <score-instrument id="clarinet1">
          <instrument-name>Clarinet</instrument-name>
          <instrument-abbreviation>Cl</instrument-abbreviation>
        </score-instrument>

        >>> i.instrumentName = "Klarinette 1."
        >>> i.instrumentAbbreviation = 'Kl.1'
        >>> mxScoreInstrument = PEX.instrumentToXmlScoreInstrument(i)
        >>> PEX.dump(mxScoreInstrument)
        <score-instrument id="clarinet1">
          <instrument-name>Klarinette 1.</instrument-name>
          <instrument-abbreviation>Kl.1</instrument-abbreviation>
        </score-instrument>
        zscore-instrumentr  zinstrument-nameNzinstrument-abbreviation)r   r-  r2   rè  r   r  r&   r  )r�   rå   ÚmxScoreInstrumentÚmxInstrumentNameÚmxInstrumentAbbreviations        r;   r  z+PartExporter.instrumentToXmlScoreInstrument¡  s�   € õ4 $Ð$6Ñ7Ô7ÐØ×Ò˜d¥C¨¬Ñ$7Ô$7Ñ8Ô8Ð8Ý%Ð&7Ð9JÑKÔKÐÝ # AÔ$4Ñ 5Ô 5ÐÔØÔ#Ð/Ý'1Ð2CÐE^Ñ'_Ô'_Ð$Ý,/°Ô0HÑ,IÔ,IÐ$Ô)ð
 !Ð r=   c                óJ  — t          d¦  «        }|                     dt          |j        ¦  «        ¦  «         |j        €8	 |                     | j        ¦  «         n# t          j        $ r
 d|_        Y nw xY wt          |d¦  «        }t          |j        dz   ¦  «        |_
        |j        �,t          |d¦  «        }t          |j        dz   ¦  «        |_
        t          |t          j        ¦  «        r3|j        �,t          |d¦  «        }t          |j        dz   ¦  «        |_
        |S )	aþ  
        Convert an instrument object to a <midi-instrument> tag and return the element

        >>> i = instrument.Clarinet()
        >>> i.instrumentId = 'clarinet1'
        >>> i.midiChannel = 4
        >>> PEX = musicxml.m21ToXml.PartExporter()
        >>> mxMidiInstrument = PEX.instrumentToXmlMidiInstrument(i)
        >>> PEX.dump(mxMidiInstrument)
        <midi-instrument id="clarinet1">
          <midi-channel>5</midi-channel>
          <midi-program>72</midi-program>
        </midi-instrument>

        >>> m = instrument.Maracas()
        >>> m.instrumentId = 'my maracas'
        >>> m.midiChannel  # 0-indexed
        9
        >>> m.percMapPitch
        70
        >>> PEX = musicxml.m21ToXml.PartExporter()
        >>> mxMidiInstrument = PEX.instrumentToXmlMidiInstrument(m)
        >>> PEX.dump(mxMidiInstrument)  # 1-indexed in MusicXML
        <midi-instrument id="my maracas">
          <midi-channel>10</midi-channel>
          <midi-unpitched>71</midi-unpitched>
        </midi-instrument>
        zmidi-instrumentr  Nr   zmidi-channelrÃ   zmidi-programzmidi-unpitched)r   r-  r2   rè  rä  rå  rÍ  r   ræ  r   r&   r  r‡   r   r  ÚpercMapPitch)r�   rå   ÚmxMidiInstrumentÚmxMidiChannelÚmxMidiProgramÚmxMidiUnpitcheds         r;   r  z*PartExporter.instrumentToXmlMidiInstrumentÈ  s)  € õ< #Ð#4Ñ5Ô5ÐØ×Ò˜T¥3 q¤~Ñ#6Ô#6Ñ7Ô7Ð7ØŒ=Ð ð"Ø×'Ò'¨Ô(<Ñ=Ô=Ð=Ð=øÝÔ3ð "ð "ð "à !�”��ð"øøøõ #Ð#3°^ÑDÔDˆÝ  ¤°Ñ!2Ñ3Ô3ˆÔð Œ=Ð$Ý&Ð'7¸ÑHÔHˆMÝ!$ Q¤]°QÑ%6Ñ!7Ô!7ˆMÔÝ�a�Ô7Ñ8Ô8ð 	;¸Q¼^Ð=WÝ(Ð)9Ð;KÑLÔLˆOÝ#& q¤~¸Ñ'9Ñ#:Ô#:ˆOÔ ð  Ðs   Á A ÁA4Á3A4r®  )rÆ  rÇ  rü  rÈ  ©r3   rX   )ró   rô   rõ   rö   rÅ  Ú__annotations__r‚   r‰   rÔ  râ  rÒ  rÑ  r_  r  r  rÁ  rÂ  s   @r;   rý  rý  
  s#  ø€ € € € € € ðð ð 	#ð %Dð!€Ið ð ð ñ ð $Ð#Ð#Ñ#Ø7Ð7Ð7Ñ7ð ;?Ø.2ð&3ð &3ð &3ð &3ð &3ð &3ð &3ðPDð Dð DðLPFð PFð PFðd%ð %ð %ð %ðN0ð 0ð 0ð:24ð 24ð 24ðh:ð :ð :ðx%!ð %!ð %!ðN3 ð 3 ð 3 ð 3 ð 3 ð 3 ð 3 r=   rý  c                  ó  ‡ — e Zd Z eg d¢¦  «        Z eg d¢¦  «        ZddhZ	 	 dÁdÂˆ fd
„Zd„ Zd„ Z	dÃd„Z
dÃd„ZddœdÄd„Zej        fdÅd„ZdÆd„ZdÇd!„ZedÈd'„¦   «         ZedÈd(„¦   «         ZdÉd,„Z	 	 dÊdËd3„ZdÌd4„ZdÍd8„ZdÊdÎd;„ZdÏdA„ZdÐdD„ZdÑdG„ZdÒdJ„ZdÓdM„Z	 	 dÊdÔdQ„ZdÕdR„Z dÖdT„Z!d×dW„Z"dÕdX„Z#	 dÌdØdY„Z$dÙdZ„Z%d[„ Z&dÚd^„Z'	 	 dÊdÛd_„Z(dÜdb„Z)dÜdc„Z*dÝde„Z+dÞdh„Z,dßdk„Z-dl„ Z.dàdm„Z/edádq„¦   «         Z0edâdt„¦   «         Z1dãdw„Z2däd{„Z3d|d}œdåd€„Z4	 dÌd|d�œdæd…„Z5	 dÌd|d�œdçd‡„Z6dèdŠ„Z7déd�„Z8dêd�„Z9dëd“„Z:dìd–„Z;díd™„Z<dîdœ„Z=dïdŸ„Z>dðd£„Z?	 	 dñdòd¨„Z@dód«„ZAd¬„ ZBd­„ ZCd®„ ZDd¯„ ZEd°„ ZFd±„ ZGd²„ ZHd³„ ZId´„ ZJdµ„ ZKdôd¸„ZLd¹„ ZMdº„ ZNdÌd»„ZOd¼„ ZPdÌd½„ZQd¾„ ZRd¿„ ZSdÀ„ ZTˆ xZUS )õrÖ  ))rÑ   Ú	noteToXml)ÚNoChordÚnoChordToXml)ÚChordWithFretBoardÚchordWithFretBoardToXml)ÚChordSymbolÚchordSymbolToXml)ÚRomanNumeralÚromanNumeralToXml)Ú	ChordBaseÚ
chordToXml)Ú	UnpitchedÚunpitchedToXml)rà  Ú	restToXml)rs   ÚdynamicToXml)ÚSegnoÚ
segnoToXml)ÚCodaÚ	codaToXml)Ú	TempoTextÚtempoIndicationToXml)ÚMetronomeMarkr8  )ÚMetricModulationr8  )ÚTextExpressionÚtextExpressionToXml)ÚRepeatExpressionr<  )ÚRehearsalMarkÚrehearsalMarkToXml)ÚPedalObjectÚpedalObjectToXml))r·   Ú	clefToXml)rù  ÚkeySignatureToXml)rú  ÚtimeSignatureToXmlÚ
LayoutBaseÚBarlineNÚ
measureObjústream.Measure | Nonerü  úPartExporter | Nonec                óü  •— t          ¦   «                              ¦   «          |€t          j        ¦   «         | _        n|| _        || _        t          d¦  «        | _        t          j        | _	        t          | j        | j        ¦  «         d | _        d | _        d| _        d| _        d | _        d| _        d| _        i | _        g | _        |€t)          j        ¦   «         | _        n|j        | _        | j        | _        d S )Nr°   r’   rÃ   )rÀ  r‚   r"   rg   rü  r   rü   r   ÚdivisionsPerQuarterÚcurrentDivisionsÚsynchronizeIdsÚtranspositionIntervalÚmxTransposeÚmeasureOffsetStartÚoffsetInMeasureÚcurrentVoiceIdÚnextFreeVoiceNumberÚnextArpeggioNumberÚarpeggioNumbersÚ
rbSpannersr!   ÚSpannerBundlerÃ  ÚobjectSpannerBundle)r�   rG  rü  rÏ  s      €r;   r‚   zMeasureExporter.__init__   sî   ø€ õ 	‰Œ×ÒÑÔÐØÐÝ œ.Ñ*Ô*ˆDŒKˆKà$ˆDŒKàˆŒÝ˜yÑ)Ô)ˆŒÝ (Ô <ˆÔõ 	�t”| T¤[Ñ1Ô1Ð1ð &*ˆÔ"ØˆÔØ"%ˆÔØ"ˆÔØ,0ˆÔØ()ˆÔ Ø'(ˆÔØKMˆÔà79ˆŒàˆ>Ý!(Ô!6Ñ!8Ô!8ˆDÔÐà!'Ô!5ˆDÔà#'Ô#5ˆÔ Ð Ð r=   c                óP  — |                       ¦   «          |                      ¦   «          |                      ¦   «          |                      ¦   «          |                      ¦   «          |                      ¦   «          |                      ¦   «          |                      ¦   «          | j        S )a%  
        main parse call.

        deals with transposing, repeat brackets, setting measureNumber and width,
        the first mxPrint, the first <attributes> tag, the left barline, parsing all internal
        elements, setting the right barline, then returns the root <measure> tag.
        )	ÚsetTransposeÚsetRbSpannersÚsetMxAttributesÚ
setMxPrintÚ&setMxAttributesObjectForStartOfMeasureÚsetLeftBarlineÚmainElementsParseÚsetRightBarlinerü   rý   s    r;   r‰   zMeasureExporter.parseC  sš   € ð 	×ÒÑÔÐØ×ÒÑÔÐØ×ÒÑÔÐØ�ŠÑÔÐØ×3Ò3Ñ5Ô5Ð5Ø×ÒÑÔÐà×ÒÑ Ô Ð à×ÒÑÔÐØŒ|Ðr=   c                ó´  — | j         }|                     ¦   «         s|                      |d¬¦  «         dS |                     t           j        ¦  «                              ¦   «         }|                      |d¬¦  «         t          |j        ¦  «        }t          |¦  «        D ]7\  }}|t          |¦  «        dz
  k    rd}nd}|                      ||¬¦  «         Œ8dS )z`
        deals with parsing all the elements in a stream, whether it has voices or not.
        F©ÚbackupAfterwardsNTrÃ   )	r"   Ú	hasVoicesÚparseFlatElementsÚgetElementsNotOfClassri   rç  r  r  r  )r�   r¿   ÚnonVoiceMeasureItemsÚ	allVoicesrå   rÆ   rd  s          r;   r`  z!MeasureExporter.mainElementsParseW  sñ   € ð ŒKˆð �{Š{‰}Œ}ð 	Ø×"Ò" 1°uÐ"Ñ=Ô=Ð=ØˆFà ×6Ò6µv´|ÑDÔD×KÒKÑMÔMÐØ×ÒÐ3ÀdÐÑKÔKÐKå˜œ‘N”Nˆ	Ý˜iÑ(Ô(ð 	Ið 	I‰DˆAˆqØ•C˜	‘N”N QÑ&Ò&Ð&Ø#(Ð Ð à#'Ð ð ×"Ò" 1Ð7GÐ"ÑHÔHÐHÐHð	Ið 	Ir=   ÚbyOffsetr.   c                ó  — t          t          || j        z  ¦  «        ¦  «        }|r_t          d¦  «        }t	          |d¦  «        }t          |¦  «        |_        | j                             |¦  «         | xj	        |z  c_	        dS dS )aÚ  
        Moves self.offsetInMeasure forward by an OffsetQL, appending the appropriate
        <forward> tag (expressed in divisions) to self.xmlRoot.

        >>> MEX = musicxml.m21ToXml.MeasureExporter()
        >>> len(MEX.xmlRoot)
        0
        >>> MEX.moveForward(1)
        >>> MEX.dump(MEX.xmlRoot)
        <measure>
          <forward>
            <duration>10080</duration>
          </forward>
        </measure>
        >>> len(MEX.xmlRoot)
        1

        Úforwardr   N©
r  ÚroundrL  r   r   r2   r&   rü   r¼   rQ  )r�   rj  ÚamountToMoveForwardÚ	mxForwardÚ
mxDurations        r;   ÚmoveForwardzMeasureExporter.moveForwardp  s�   € õ& $'¥u¨X¸Ô8MÑ-MÑ'NÔ'NÑ#OÔ#OÐØð 	-Ý 	Ñ*Ô*ˆIÝ# I¨zÑ:Ô:ˆJÝ!Ð"5Ñ6Ô6ˆJŒOØŒL×Ò 	Ñ*Ô*Ð*ØÐ Ô  HÑ,Ð Ô Ð Ð ð	-ð 	-r=   c                ó  — t          t          || j        z  ¦  «        ¦  «        }|r_t          d¦  «        }t	          |d¦  «        }t          |¦  «        |_        | j                             |¦  «         | xj	        |z  c_	        dS dS )aØ  
        Moves self.offsetInMeasure backward by an OffsetQL, appending the appropriate
        <backup> tag (expressed in divisions) to self.xmlRoot.

        >>> MEX = musicxml.m21ToXml.MeasureExporter()
        >>> len(MEX.xmlRoot)
        0
        >>> MEX.moveBackward(2)
        >>> MEX.dump(MEX.xmlRoot)
        <measure>
          <backup>
            <duration>20160</duration>
          </backup>
        </measure>
        >>> len(MEX.xmlRoot)
        1
        Úbackupr   Nrm  )r�   rj  ÚamountToBackupÚmxBackuprq  s        r;   ÚmoveBackwardzMeasureExporter.moveBackward‹  sŽ   € õ$ "¥%¨°4Ô3HÑ(HÑ"IÔ"IÑJÔJˆØð 	-Ý˜xÑ(Ô(ˆHÝ# H¨jÑ9Ô9ˆJÝ! .Ñ1Ô1ˆJŒOØŒL×Ò Ñ)Ô)Ð)ØÐ Ô  HÑ,Ð Ô Ð Ð ð	-ð 	-r=   Frc  r¿   ústream.Measure | stream.Voicerd  rX   r3   rú   c               ó  ‡ — d‰ _         t          |t          j        ¦  «        r{t          |j        t
          ¦  «        r'|j        t          j        k     r|j        }|dz   ‰ _        n<t          |j        t
          ¦  «        r‰ j        }‰ xj        dz  c_        n
|j        }nd}|‰ _	        t          |                     t          j        ¦  «        ¦  «        }t          |¦  «        }|D �]‚}|                     |d         ¦  «        }|‰ j         z
  }|dk    r.t!          d„ |D ¦   «         ¦  «        r‰                      |¦  «         g }	|D ]µ}
t          |
t          j        ¦  «        rŒt          |
t$          j        ¦  «        r;t          |
t(          j        ¦  «        x}r	|r|
j        r|	                     |
¦  «         Œr|r!‰                      |
t2          j        ¦  «         Œ•‰                      |
t2          j        ¦  «         Œ¶|	D ]i}|j        r|j        j        r|j        j         dk    rŒ&|r!‰                      |t2          j        ¦  «         ŒI‰                      |t2          j        ¦  «         Œj�Œ„‰ j         }|r¶‰ j         r‰  !                    ‰ j         ¦  «         t          |¦  «        }|D ]ƒ}t!          ˆ fd„|D ¦   «         ¦  «        sŒ|                     |d         ¦  «        }|‰ j         z
  }|dk    r‰                      |¦  «         |D ]"}
‰                      |
t2          j"        ¦  «         Œ#Œ„|r"‰ j         r‰  !                    ‰ j         ¦  «         n5‰ j         |k     r*‰                      tG          |‰ j         z
  ¦  «        ¦  «         d‰ _	        dS )aÉ  
        Deals with parsing all the elements in .elements, assuming that .elements is flat.

        `m` here can be a Measure or Voice, but it must be flat.

        If m is a 'Voice' class, we use the .id element to set self.currentVoiceId and then
        send a backup tag to go back to the beginning of the measure.

        Note that if the .id is high enough to be an id(x) memory location, then a small
        voice number is used instead.
        r’   rÃ   Nr   c              3  ób   K  — | ]*}t          |t          j        t          j        f¦  «        V — Œ+d S rñ   )r‡   r   rm   r   r·   )r#  r{   s     r;   r%  z4MeasureExporter.parseFlatElements.<locals>.<genexpr>Û  sO   è è € ð /Xð /XØGJ•J˜s¥TÔ%5µt´yÐ$AÑBÔBð/Xð /Xð /Xð /Xð /Xð /Xr=   r8   c              3  óB   •K  — | ]}‰                      |¦  «        V — Œd S rñ   )Ú_hasRelatedSpanners)r#  r{   r�   s     €r;   r%  z4MeasureExporter.parseFlatElements.<locals>.<genexpr>  s1   øè è € ÐMÐM¸S˜4×3Ò3°CÑ8Ô8ÐMÐMÐMÐMÐMÐMr=   )$rQ  r‡   r"   ri   r  r  r   r  rS  rR  rX   rÊ   r!   ÚSpannerAnchorr#   ÚelementOffsetÚanyrr  r   rm   r   ÚHarmonyÚwriteAsChordr¼   ÚparseOneElementr   ÚNONEÚNORMALÚisRestr$   rR  r   rR  rw  ÚRELATED_ONLYr   )r�   r¿   rd  ÚvoiceIdÚhasSpannerAnchorsÚobjIteratorÚobjGroupÚgroupOffsetÚoffsetToMoveForwardÚnotesForLaterr{   ÚisHarmrÔ   ÚfirstPassEndOffsetInMeasures   `             r;   rf  z!MeasureExporter.parseFlatElements¥  s  ø€ ð"  #ˆÔå�a�œÑ&Ô&ð 	Ý˜!œ$¥Ñ$Ô$ð 	¨¬µÔ0\Ò)\Ð)\Øœ$�Ø+2°Q©;�Ô(Ð(Ý˜AœD¥#Ñ&Ô&ð ð Ô2�ØÐ(Ô(¨AÑ-Ð(Ô(Ð(àœ$��àˆGà%ˆÔõ #' q×';Ò';½GÔ<QÑ'RÔ'RÑ"SÔ"SÐõ ;IÈÑ:KÔ:KˆØ#ð '	Cñ '	CˆHØŸ/š/¨(°1¬+Ñ6Ô6ˆKØ"-°Ô0DÑ"DÐð # QÒ&Ð&­3ð /Xð /XØNVð/Xñ /Xô /Xñ ,Xô ,XÐ&ð × Ò Ð!4Ñ5Ô5Ð5àˆMàð Ið I�õ ˜c¥7Ô#8Ñ9Ô9ð ð å˜c¥4Ô#3Ñ4Ô4ð 	IÝ#-¨cµ7´?Ñ#CÔ#CÐC˜ð	Iàð	Ià#&Ô#3ð	Ið "×(Ò(¨Ñ-Ô-Ð-Ð-à(ð IØ×,Ò,¨Sµ.Ô2EÑFÔFÐFÐFà×,Ò,¨Sµ.Ô2GÑHÔHÐHÐHà"ð Cð C�Ø”8ð  ¤Ô 9ð ¸a¼j¼oÐQ`Ò>`Ð>`ð Ø$ð CØ×(Ò(¨­NÔ,?Ñ@Ô@Ð@Ð@à×(Ò(¨­NÔ,AÑBÔBÐBÐBñCð" 15Ô0DÐ#àð 	KàÔ#ð 8Ø×!Ò! $Ô"6Ñ7Ô7Ð7å(¨Ñ+Ô+ˆKØ'ð Kð K�åÐMÐMÐMÐMÀHÐMÑMÔMÑMÔMð ØØŸošo¨h°q¬kÑ:Ô:�Ø&1°DÔ4HÑ&HÐ#Ø&¨Ò*Ð*à×$Ò$Ð%8Ñ9Ô9Ð9ð $ð Kð K�CØ×(Ò(¨­nÔ.IÑJÔJÐJÐJðKð ð 	]àÔ#ð 8Ø×!Ò! $Ô"6Ñ7Ô7Ð7øð Ô#Ð&AÒAÐAØ× Ò ¥Ð(CÀdÔFZÑ(ZÑ![Ô![Ñ\Ô\Ð\à"ˆÔÐÐr=   ÚappendSpannersr   c                ó  — | j         }| j                             |¦  «        | _        |                      |¦  «        \  }}|t
          j        k    r|D ]}|                     |¦  «         Œ|t
          j        k    �r“|j	        }d|v r+t          |dd¦  «        r| xj        |j        j        z  c_        |j        j        dk    r+|j        j        |j        _        |                     ¦   «         }nPt!          |j        j        ¦  «        dk    r0|j                             d¬¦  «         |                     ¦   «         }n|g}d}	| j                             ¦   «         D ]-\  }
}|
|v r$t          | |¦  «        }|D ]} ||¦  «         Œd}	 nŒ.| j                             ¦   «         D ]8\  }
}|
|v r/t          | |¦  «        }|D ]}|                      ||¦  «         Œd}	 nŒ9|	du r2|D ]}
|
| j        v rd}	 nŒ|	du rt0                               d|g¦  «         nF|rD|j        d	k    r9d|j	        v r0t          |dd¦  «        r|                      |j        j        ¦  «         |t
          j        k    r|D ]}|                     |¦  «         Œd
S d
S )zl
        parse one element completely and add it to xmlRoot, updating
        offsetInMeasure, etc.
        rm   r�  Tr8   rÃ   r¡   Fzdid not convert objectr   N)rü   rÃ  ÚgetBySpannedElementrX  ÚrelatedSpannersr   rƒ  r¼   r†  r˜   r]   rQ  r   rá   rR  rÐ  r  Ú	dotGroupsÚsplitDotGroupsÚclassesToMethodsrœ   ÚwrapAttributeMethodClassesÚwrapObjectInAttributesÚignoreOnParseClassesrç  Ú
printDebugrr  )r�   r{   r�  ÚrootÚpreListÚpostListrÿ  r˜   ÚobjListÚparsedObjectÚ	classNamerž   rŸ   Úos                 r;   r‚  zMeasureExporter.parseOneElement'  s  € ð Œ|ˆØ#'Ô#5×#IÒ#IÈ#Ñ#NÔ#NˆÔ Ø ×0Ò0°Ñ5Ô5Ñˆ�ð �^Ô0Ò0Ð0àð  ð  �Ø—’˜B‘”��ð �^Ô8Ò8Ñ8à”kˆGà Ð'Ð'­G°C¸ÈÑ,NÔ,NÐ'ØÐ$Ô$¨¬Ô(BÑBÐ$Ô$ð Œ|Ô  OÒ3Ð3Ø-0¬\Ô-G�”Ô*Ø×.Ò.Ñ0Ô0��å�S”\Ô+Ñ,Ô,¨qÒ0Ð0Ø”×+Ò+°DÐ+Ñ9Ô9Ð9Ø×.Ò.Ñ0Ô0��ð ˜%�à ˆLØ'+Ô'<×'BÒ'BÑ'DÔ'Dð ð Ñ#�	˜8Ø Ð'Ð'Ý" 4¨Ñ2Ô2�DØ$ð  ð  ˜Ø˜˜Q™œ˜˜Ø#'�LØ�Eð (ð (,Ô'F×'LÒ'LÑ'NÔ'Nð ð Ñ#�	˜8Ø Ð'Ð'Ý" 4¨Ñ2Ô2�DØ$ð =ð =˜Ø×3Ò3°A°tÑ<Ô<Ð<Ð<Ø#'�LØ�Eð (ð ˜uÐ$Ð$Ø!(ð ð �IØ  DÔ$=Ð=Ð=Ø'+˜Ø˜ð >ð   5Ð(Ð(Ý ×+Ò+Ð-EÀsÐ,KÑLÔLÐLøð ð A˜CÔ-°Ò1Ð1ð ! C¤KÐ/Ð/µG¸CÀÐQUÑ4VÔ4VÐ/Ø×$Ò$ S¤\Ô%?Ñ@Ô@Ð@ð �^Ô0Ò0Ð0àð  ð  �Ø—’˜B‘”��ð 1Ð0ð ð  r=   c                ó$  — | j                              |¦  «        }|sdS |                     t          j        t
          j        t          j        t          j	        f¦  «        D ]/}| 
                    |¦  «        s|                     |¦  «        r dS Œ0dS )a  
        returns True if and only if:
        (1) there are spanners related to the object that should appear before the object
        to the <measure> tag, or (2) there are spanners related to the object that should
        appear after the object in the measure tag.
        FT)rÃ  r’  r[  r!   ÚOttavar   ÚDynamicWedgeÚLiner   Ú	PedalMarkr]  r`  )r�   r{   rÃ  ÚthisSpanners       r;   r|  z#MeasureExporter._hasRelatedSpannersw  s¥   € ð Ô*×>Ò>¸sÑCÔCˆØð 	Ø�5ð )×3Ò3µW´^Ý5=Ô5JÝ5<´\Ý5@Ô5Jð5Lñ Mô Mð 	ð 	ˆKð ×"Ò" 3Ñ'Ô'ð ¨;×+=Ò+=¸cÑ+BÔ+Bð Ø�t�tðð ˆur=   Útargetúbase.Music21Objectú/tuple[t.Sequence[Element], t.Sequence[Element]]c                ó\  — d„ }| j         }|sdS g }g }dddddœ}|                     ¦   «         D �]z\  }}|\  }	}
|                     |¦  «        D �]X} |||¦  «        D �]G}t          |	¦  «        }t	          ||¦  «         |                     dt          |j        ¦  «        ¦  «         |d	k    r(|                     d
t          |j        ¦  «        ¦  «         |dk    r|  	                    ||¦  «        }n|dk    r|  
                    ||¦  «        }ni }d|v r)|                     dt          |d         ¦  «        ¦  «         |
D ]7}||v r1||         �)|                     |t          ||         ¦  «        ¦  «         Œ8t          d¦  «        }t	          ||¦  «         t          |d¦  «        r/|j        �(|                     dt          |j        ¦  «        ¦  «         t          |d¦  «        }|                     |¦  «         |dk    r|                     |¦  «         n|                     |¦  «         |dk    rr|dk    rlt          j        rt#          |t$          j        ¦  «        sJ ‚|j        t$          j        j        k    r*|                      |¦  «        }|                     |¦  «         �ŒI�ŒZ�Œ|||fS )a  
        return two lists or empty tuples:
        (1) spanners related to the object that should appear before the object
        in the <measure> tag. (2) spanners related to the object that should appear after the
        object in the <measure> tag.
        c                óð   — t          | ¦  «        dk    rd}n_|                      |¦  «        r|                      |¦  «        rd}n2|                      |¦  «        rd}n|                      |¦  «        rd}nd}|S )NrÃ   )rÍ   Úlast)rÍ   )r­  r÷   )r  r]  r`  )rª  ÚinnerTargetÚprocs      r;   ÚgetProcz0MeasureExporter.relatedSpanners.<locals>.getProc–  s†   € Ý�2‰wŒw˜!Š|ˆ|Ø(��à—:’:˜kÑ*Ô*ð ¨r¯yªy¸Ñ/EÔ/Eð Ø,�D�DØ—Z’Z Ñ,Ô,ð Ø%�D�DØ—Y’Y˜{Ñ+Ô+ð Ø$�D�Dà�DØˆKr=   )r÷   r÷   )zoctave-shift)Úsize)Úwedge)Úspread)r°  )úline-endú
end-length)Úpedal)ÚlineÚsignÚabbreviated)r£  r¤  r¥  r¦  rÅ   r¥  ú	line-typerÍ   r­  rR  Nr‘  Ú	placementúdirection-typer¦  )rX  rœ   r[  r   rM  r-  r2   ÚidLocalÚlineTypeÚ_spannerStartParametersÚ_spannerEndParametersra  r»  r   r¼   rê  rë  r‡   r   r¦  Ú	pedalFormÚ	PedalFormÚ
SymbolLineÚmakePedalResumeLineXml)r�   r¨  r°  rÃ  rœ  r�  Ú	paramsSetÚm21spannerClassÚ	infoTupleÚmxTagÚparameterSetr§  ÚposSubÚ	mxElementÚspannerParamsÚattrNameÚmxDirectionÚmxDirectionTypeÚmxPedalLines                      r;   r“  zMeasureExporter.relatedSpannersŒ  s  € ð	ð 	ð 	ð Ô0ˆØð 	Ø�6à!#ˆØ"$ˆð
  ;à%;àDà"Lðð ˆ	ð +4¯/ª/Ñ*;Ô*;ð 1	8ñ 1	8Ñ&ˆO˜YØ"+ÑˆE�<Ø,×7Ò7¸ÑHÔHð /8ñ /8�Ø%˜g k°6Ñ:Ô:ð .8ñ .8�Få '¨¡¤�IÝ" 9¨kÑ:Ô:Ð:à—M’M (­C°Ô0CÑ,DÔ,DÑEÔEÐEØ&¨&Ò0Ð0Ø!Ÿš kµ3°{Ô7KÑ3LÔ3LÑMÔMÐMà Ò(Ð(Ø(,×(DÒ(DÀ_ÐVaÑ(bÔ(b˜˜Ø 6Ò)Ð)Ø(,×(BÒ(BÀ?ÐT_Ñ(`Ô(`˜˜à(*˜à Ð.Ð.Ø!Ÿš f­c°-ÀÔ2GÑ.HÔ.HÑIÔIÐIà$0ð Rð R˜Ø# }Ð4Ð4¸ÀxÔ9PÐ9\Ø%ŸMšM¨(µC¸ÀhÔ8OÑ4PÔ4PÑQÔQÐQøå")¨+Ñ"6Ô"6�KÝ" ;°Ñ<Ô<Ð<õ ˜{¨KÑ8Ô8ð Q¸[Ô=RÐ=^Ø#Ÿš¨µS¸Ô9NÑ5OÔ5OÑPÔPÐPÝ&0°Ð>NÑ&OÔ&O�OØ#×*Ò*¨9Ñ5Ô5Ð5ð  Ò(Ð(ØŸš {Ñ3Ô3Ð3Ð3à Ÿš¨Ñ4Ô4Ð4à&¨+Ò5Ð5¸&ÀGÒ:KÐ:Kåœ?ð RÝ#-¨k½;Ô;PÑ#QÔ#QÐQÐQÐ#QØ&Ô0µKÔ4IÔ4TÒTÐTà $× ;Ò ;¸KÑ HÔ Hð (ð $ŸNšN¨;Ñ7Ô7Ð7ùñ].8ñ/8ðb ˜Ð Ð r=   ÚspannerClassr2   rÿ  úspanner.Spannerúdict[str, t.Any]c                ó  — ddi}| dk    rZt           j        rt          |t          j        ¦  «        sJ ‚|                     ¦   «         |d<   |                     d¬¦  «        |d<   �n'| dk    r=t           j        rt          |t          j        ¦  «        sJ ‚|j        |d<   |j	        |d	<   nä| d
k    rZt           j        rt          |t          j        ¦  «        sJ ‚|j        |d<   |j        dk    rd|d<   |j        rd|d<   n�|j        |d<   n„| dk    r~t           j        rt          |t          j        ¦  «        sJ ‚|j        t          j        j        k    rd|d<   nd|d<   |j        t          j        j        k    rd|d<   nd|d<   |j        rd|d<   |S )a˜  
        Return a dict of the parameters for the start of this spanner required by MusicXML output.

        >>> ssp = musicxml.m21ToXml.MeasureExporter._spannerStartParameters

        >>> ottava = spanner.Ottava(type='8va')
        >>> st = ssp('Ottava', ottava)

        Note that an ottava up in MusicXML is type "down", perhaps the opposite of what
        you might expect.  It means that the music should be engraved "down" from
        where the sounding pitches would normally be engraved.

        >>> st['type']
        'down'
        >>> st['size']
        8

        >>> cresc = dynamics.Crescendo()
        >>> st = ssp('DynamicWedge', cresc)
        >>> st['type']
        'crescendo'
        >>> st['spread']
        0

        >>> diminuendo = dynamics.Diminuendo()
        >>> st = ssp('DynamicWedge', diminuendo)
        >>> st['type']
        'diminuendo'
        >>> st['spread']
        15
        rR  rj  r£  r±  T)Úreverser¥  r´  rµ  r¤  Ú	crescendor   r³  r¯  Únienter¦  Ú	sostenutor·  r¸  r¹  )rê  rë  r‡   r!   r£  ÚshiftMagnitudeÚshiftDirectionr¥  Ú	startTickÚstartHeightr   r¤  rR  r×  r³  r   r¦  Ú	pedalTypeÚ	PedalTypeÚ	SostenutorÁ  rÂ  r¹  ©rÑ  rÿ  Úposts      r;   r¿  z'MeasureExporter._spannerStartParametersì  s¾  € ðB #)¨'Ð!2ˆØ˜8Ò#Ð#ÝŒð 6Ý! "¥g¤nÑ5Ô5Ð5Ð5Ð5Ø×,Ò,Ñ.Ô.ˆD�‰LØ×,Ò,°TÐ,Ñ:Ô:ˆD�‰L‰LØ˜VÒ#Ð#ÝŒð 4Ý! "¥g¤lÑ3Ô3Ð3Ð3Ð3Ø!œ|ˆD�ÑØ!#¤ˆD�ÑÐØ˜^Ò+Ð+ÝŒð =Ý! "¥hÔ&;Ñ<Ô<Ð<Ð<Ð<Øœ7ˆD�‰LØŒw˜+Ò%Ð%Ø!"��X‘Ø”9ð +Ø%*�D˜‘Nøà!#¤��X‘�Ø˜[Ò(Ð(ÝŒð =Ý! "¥kÔ&;Ñ<Ô<Ð<Ð<Ð<ØŒ|�{Ô4Ô>Ò>Ð>Ø*��V‘�ð  '��V‘ØŒ|�{Ô4Ô9Ò9Ð9Ø$��V‘�ð  %��V‘ØŒ~ð ,Ø&+��]Ñ#Øˆr=   c                ó�  — ddi}| dk    r@t           j        rt          |t          j        ¦  «        sJ ‚|                     ¦   «         |d<   nû| dk    r=t           j        rt          |t          j        ¦  «        sJ ‚|j        |d<   |j        |d<   n¸| dk    rPt           j        rt          |t          j
        ¦  «        sJ ‚|j        d	k    r|j        |d
<   ntd|d
<   |j        rd|d<   nb| dk    r\t           j        rt          |t          j        ¦  «        sJ ‚|j        t          j        j        t          j        j        fv rd|d<   nd|d<   |S )a=  
        Return a dict of the parameters for the end of this spanner required by MusicXML output.

        >>> ottava = spanner.Ottava(type='8va')
        >>> en = musicxml.m21ToXml.MeasureExporter._spannerEndParameters('Ottava', ottava)
        >>> en['type']
        'stop'
        >>> en['size']
        8
        rR  rZ  r£  r±  r¥  r´  rµ  r¤  rÖ  r³  r   r¯  r×  r¦  r·  r¸  )rê  rë  r‡   r!   r£  rÙ  r¥  ÚendTickÚ	endHeightr   r¤  rR  r³  r×  r   r¦  rÁ  rÂ  rÃ  rà  s      r;   rÀ  z%MeasureExporter._spannerEndParameters6  sf  € ð #)¨&Ð!1ˆØ˜8Ò#Ð#ÝŒð 6Ý! "¥g¤nÑ5Ô5Ð5Ð5Ð5Ø×,Ò,Ñ.Ô.ˆD�‰LˆLØ˜VÒ#Ð#ÝŒð 4Ý! "¥g¤lÑ3Ô3Ð3Ð3Ð3Ø!œzˆD�ÑØ!#¤ˆD�ÑÐØ˜^Ò+Ð+ÝŒð =Ý! "¥hÔ&;Ñ<Ô<Ð<Ð<Ð<ØŒw˜+Ò%Ð%Ø!#¤��X‘�à!"��X‘Ø”9ð +Ø%*�D˜‘NøØ˜[Ò(Ð(ÝŒð =Ý! "¥kÔ&;Ñ<Ô<Ð<Ð<Ð<ØŒ|¥Ô 5Ô :½KÔ<QÔ<\Ð]Ð]Ð]Ø$��V‘�ð  %��V‘àˆr=   Úarpúexpressions.ArpeggioMarkSpannerr  c                ó®   — | j                              |d¦  «        }|dk    r3| j        }| xj        dz  c_        | j        dk    rd| _        || j         |<   |S )NéÿÿÿÿrÃ   é   )rU  r  rT  )r�   rå  ÚarpeggioNumbers      r;   ÚgetArpeggioNumberz!MeasureExporter.getArpeggioNumber`  sj   € Ø"Ô2×6Ò6°s¸BÑ?Ô?ˆØ˜RÒÐØ!Ô4ˆNØÐ#Ô# qÑ(Ð#Ô#ØÔ&¨Ò+Ð+Ø*+�Ô'Ø(6ˆDÔ  Ñ%àÐr=   r   r{   ÚnoteIndexInChordrX  úspanner.SpannerBundle | Noner£  c                óR
  — g }|�|}n| j         }|s|S |                      ||||¦  «         |dk    }|s|S g }|                     d¦  «        D �]}t          d¦  «        }	|                     |¦  «        r‰|	                     dd¦  «         |                      |	|¦  «         |                      |	|¦  «         |                      |	|d¦  «         |j	        �(|	                     dt          |j	        ¦  «        ¦  «         n-|                     |¦  «        r|	                     dd	¦  «         nŒÝ|	                     d
t          |j        ¦  «        ¦  «         |                     |	¦  «         �Œ|                     d¦  «        D �]}|j        dk    rd}
nd}
t          |
¦  «        }|                     d
t          |j        ¦  «        ¦  «         |j        �(|                     dt          |j        ¦  «        ¦  «         |                     |¦  «        r7|j        �t          |j        ¦  «        |_        |                     dd¦  «         n-|                     |¦  «        r|                     dd	¦  «         nŒòt%          ||¦  «         |                     |¦  «         �Œ|                     d¦  «        D ]ã}t          d¦  «        }t          |j        ¦  «        |_        |                     |¦  «        rF|                     dd¦  «         |j	        �(|                     dt          |j	        ¦  «        ¦  «         nI|                     |¦  «        r|                     dd	¦  «         nt(                               d||g¦  «         |                     |¦  «         Œä|                     d¦  «        D �]A}t          d¦  «        }|                     d
t          |j        ¦  «        ¦  «         d}d}|                     |¦  «        r:|                     dd¦  «         d}|j	        �|                     d|j	        ¦  «         |                     |¦  «        r|du rd}n|                     dd	¦  «         d}|du rŒÆ|                     |¦  «         |du rbt          d¦  «        }|                     d
t          |j        ¦  «        ¦  «         |                     dd	¦  «         |                     |¦  «         �ŒC|r>t          d¦  «        }|D ]}|                     |¦  «         Œ|                     |¦  «         |S )až  
        return a list of <notations> from spanners related to the object that should appear
        in the notations tag (slurs, slides, etc.)

        >>> n0 = note.Note('C')
        >>> n1 = note.Note('D')
        >>> trem = expressions.TremoloSpanner([n0, n1])
        >>> m = stream.Measure()
        >>> m.insert(0, trem)
        >>> m.append(n0)
        >>> m.append(n1)
        >>> mex = musicxml.m21ToXml.MeasureExporter(m)
        >>> out = mex.objectAttachedSpannersToNotations(n0, objectSpannerBundle=m.spannerBundle)
        >>> out
        [<Element 'ornaments' at 0x1114d9408>]
        >>> mex.dump(out[0])
        <ornaments>
          <tremolo type="start">3</tremolo>
        </ornaments>

        >>> out = mex.objectAttachedSpannersToNotations(n1, objectSpannerBundle=m.spannerBundle)
        >>> mex.dump(out[0])
        <ornaments>
          <tremolo type="stop">3</tremolo>
        </ornaments>
        Nr   ÚSlurÚslurrR  rj  )zbezier-offsetzbezier-offset2zbezier-xzbezier-yz	bezier-x2z	bezier-y2r»  rZ  rÅ   Ú	GlissandoÚ
continuousÚslideÚ	glissandorº  ÚTremoloSpannerÚtremoloz:spanner w/ a component that is neither a start nor an end.ÚTrillExtensionz	wavy-lineFTÚ	ornaments)rX  Ú%appendArpeggioMarkSpannersToNotationsr[  r   r]  r-  ÚsetLineStylerL  r6  r»  r2   r`  r½  r¼   Ú	slideTyper¾  Úlabelr&   rM  ÚnumberOfMarksrç  rš  )r�   r{   rì  rX  Ú	notationsÚsbÚisSingleNoteOrFirstInChordrø  rª  ÚmxSlurrÈ  ÚmxGlissandoÚmxTremÚ
mxWavyLineÚisFirstOrLastÚisFirstANDLastÚ
mxOrnGroupÚmxOrns                     r;   Ú!objectAttachedSpannersToNotationsz1MeasureExporter.objectAttachedSpannersToNotationsk  sE  € ð@ $&ˆ	ØÐ*Ø$ˆBˆBàÔ)ˆBàð 	ØÐà×2Ò2°3Ð8HÈ)ÐUWÑXÔXÐXà&6¸!Ò&;Ð"ð *ð 	ØÐàˆ	à—-’- Ñ'Ô'ð 	%ñ 	%ˆBÝ˜V‘_”_ˆFØ�zŠz˜#‰Œð Ø—
’
˜6 7Ñ+Ô+Ð+Ø×!Ò! &¨"Ñ-Ô-Ð-Ø× Ò  ¨Ñ,Ô,Ð,Ø×'Ò'¨Ø(*ð)Cñ*ô *ð *ð ”<Ð+Ø—J’J˜{­C°´Ñ,=Ô,=Ñ>Ô>Ð>øØ—’˜3‘”ð Ø—
’
˜6 6Ñ*Ô*Ð*Ð*àØ�JŠJ�x¥ R¤Z¡¤Ñ1Ô1Ð1Ø×Ò˜VÑ$Ô$Ð$Ñ$à—-’- Ñ,Ô,ð 	*ñ 	*ˆBØŒ|˜|Ò+Ð+Ø��à#�å! %™.œ.ˆKØ�OŠO˜H¥c¨"¬*¡o¤oÑ6Ô6Ð6ØŒ{Ð&Ø—’ ­S°´Ñ-=Ô-=Ñ>Ô>Ð>à�zŠz˜#‰Œð Ø”8Ð'Ý'*¨2¬8¡}¤}�KÔ$Ø—’ ¨Ñ0Ô0Ð0Ð0Ø—’˜3‘”ð Ø—’ ¨Ñ/Ô/Ð/Ð/àå˜;¨Ñ+Ô+Ð+à×Ò˜[Ñ)Ô)Ð)Ñ)ð —-’-Ð 0Ñ1Ô1ð 	%ð 	%ˆBÝ˜YÑ'Ô'ˆFÝ˜bÔ.Ñ/Ô/ˆFŒKØ�zŠz˜#‰Œð 	]Ø—
’
˜6 7Ñ+Ô+Ð+Ø”<Ð+Ø—J’J˜{­C°´Ñ,=Ô,=Ñ>Ô>Ð>øØ—’˜3‘”ð ]Ø—
’
˜6 6Ñ*Ô*Ð*Ð*õ ×'Ò'ØQÐSUÐWZÐ[ñ]ô ]ð ]ð ×Ò˜VÑ$Ô$Ð$Ð$à—-’-Ð 0Ñ1Ô1ð 	-ñ 	-ˆBÝ  Ñ-Ô-ˆJØ�NŠN˜8¥S¨¬¡_¤_Ñ5Ô5Ð5Ø!ˆMØ"ˆNà�zŠz˜#‰Œð >Ø—’˜v wÑ/Ô/Ð/à $�Ø”<Ð+Ø—N’N ;°´Ñ=Ô=Ð=ð �yŠy˜‰~Œ~ð )Ø  DÐ(Ð(Ø%)�N�Nà—N’N 6¨6Ñ2Ô2Ð2Ø$(�Mð  Ð%Ð%ØØ×Ò˜ZÑ(Ô(Ð(Ø Ð%Ð%å$ [Ñ1Ô1�
Ø—’˜x­¨R¬Z©¬Ñ9Ô9Ð9Ø—’˜v vÑ.Ô.Ð.Ø× Ò  Ñ,Ô,Ð,ùàð 	)Ý  Ñ-Ô-ˆJØ"ð )ð )�Ø×!Ò! %Ñ(Ô(Ð(Ð(Ø×Ò˜ZÑ(Ô(Ð(àÐr=   c                ó  — g }|�|}n| j         }|s|S |                     t          j        ¦  «        D ]œ}t	          d¦  «        }|                     |¦  «        r|                     dd¦  «         d|_        n-|                     |¦  «        r|                     dd¦  «         nŒq|                     dd¦  «         | 	                    |¦  «         Œ�|                     t          j
        ¦  «        D ]œ}t	          d	¦  «        }|                     |¦  «        r|                     dd¦  «         d
|_        n-|                     |¦  «        r|                     dd¦  «         nŒq|                     dd¦  «         | 	                    |¦  «         Œ�|S )a®  
        return a list of <technical> from spanners related to the object that should appear
        in the technical tag of the notations tag (hammer-on, pull-off etc.)

        >>> n0 = note.Note('C')
        >>> n1 = note.Note('D')
        >>> n2 = note.Note('F')
        >>> n3 = note.Note('E')
        >>> hammerOn01 = articulations.HammerOn([n0, n1])
        >>> pullOff23 = articulations.PullOff([n2, n3])
        >>> m = stream.Measure()
        >>> m.insert(0, hammerOn01)
        >>> m.insert(0, pullOff23)
        >>> m.append(n0)
        >>> m.append(n1)
        >>> m.append(n2)
        >>> m.append(n3)
        >>> mex = musicxml.m21ToXml.MeasureExporter(m)
        >>> out = mex.objectAttachedSpannersToTechnicals(n0, m.spannerBundle)
        >>> out
        [<Element 'hammer-on' at 0x102857f40>]
        >>> mex.dump(out[0])
        <hammer-on number="1" type="start">H</hammer-on>
        >>> out = mex.objectAttachedSpannersToTechnicals(n3, m.spannerBundle)
        >>> mex.dump(out[0])
        <pull-off number="1" type="stop" />

        OMIT_FROM_DOCS

        The other permutations of class and first/last:

        >>> out = mex.objectAttachedSpannersToTechnicals(n1, m.spannerBundle)
        >>> mex.dump(out[0])
        <hammer-on number="1" type="stop" />
        >>> out = mex.objectAttachedSpannersToTechnicals(n2, m.spannerBundle)
        >>> mex.dump(out[0])
        <pull-off number="1" type="start">P</pull-off>
        Nz	hammer-onrR  rj  ÚHrZ  rÅ   r(  zpull-offÚP)rX  r[  r   ÚHammerOnr   r]  r-  r&   r`  r¼   ÚPullOff)r�   r{   rX  Ú
technicalsrÿ  rª  Ú
mxHammerOnÚ	mxPullOffs           r;   Ú"objectAttachedSpannersToTechnicalsz2MeasureExporter.objectAttachedSpannersToTechnicals  s•  € ðN ˆ
ØÐ*Ø$ˆBˆBàÔ)ˆBàð 	ØÐà—-’-¥Ô 6Ñ7Ô7ð 
	*ð 
	*ˆBÝ  Ñ-Ô-ˆJØ�zŠz˜#‰Œð Ø—’˜v wÑ/Ô/Ð/Ø"%�
”�Ø—’˜3‘”ð Ø—’˜v vÑ.Ô.Ð.Ð.àØ�NŠN˜8 SÑ)Ô)Ð)Ø×Ò˜jÑ)Ô)Ð)Ð)à—-’-¥Ô 5Ñ6Ô6ð 
	)ð 
	)ˆBÝ 
Ñ+Ô+ˆIØ�zŠz˜#‰Œð Ø—’˜f gÑ.Ô.Ð.Ø!$�	”�Ø—’˜3‘”ð Ø—’˜f fÑ-Ô-Ð-Ð-àØ�MŠM˜( CÑ(Ô(Ð(Ø×Ò˜iÑ(Ô(Ð(Ð(àÐr=   rþ  rÿ  úspanner.SpannerBundlec                ó<  — |                      t          j        ¦  «        D �]z}|                     |¦  «        sŒ|}t	          |t
          j        ¦  «        r||         }d }|j        dk    rk|                     ¦   «         \  }}	||u r&t          d¦  «        }| 
                    dd¦  «         n_||	u r%t          d¦  «        }| 
                    dd¦  «         n5t          d¦  «        }|j        dk    r| 
                    d|j        ¦  «         |�wt          |¦  «        d	k    s,t          |¦  «        d	k    rQt          |d
         ¦  «        d	k    r8|                      |¦  «        }
| 
                    dt          |
¦  «        ¦  «         |�|                     |¦  «         �Œ|d S )Núnon-arpeggioúnon-arpeggiaterR  r‹  rŠ  Ú
arpeggiateÚnormalr‘  rÃ   r   rÅ   )r[  r   ÚArpeggioMarkSpannerÚhasSpannedElementr‡   r   ÚChordrR  ÚnoteExtremesr   r-  r  rë  r2   r¼   )r�   r{   rì  rþ  rÿ  ÚamsÚsub_objÚ
mxArpeggioÚmin_noteÚmax_noterê  s              r;   rù  z5MeasureExporter.appendArpeggioMarkSpannersToNotationsO  s¦  € ð —=’=¥Ô!@ÑAÔAð  	-ñ  	-ˆCØ×(Ò(¨Ñ-Ô-ð Øð ˆGÝ˜#�uœ{Ñ+Ô+ð 0ØÐ.Ô/�à'+ˆJØŒx˜>Ò)Ð)Ø%(×%5Ò%5Ñ%7Ô%7Ñ"�˜(à˜hÐ&Ð&Ý!(Ð)9Ñ!:Ô!:�JØ—N’N 6¨8Ñ4Ô4Ð4Ð4Ø Ð(Ð(Ý!(Ð)9Ñ!:Ô!:�JØ—N’N 6¨5Ñ1Ô1Ð1øå$ \Ñ2Ô2�
Ø”8˜xÒ'Ð'Ø—N’N ;°´Ñ9Ô9Ð9ØÐ%­3¨s©8¬8°aª<¨<½CÀ¹H¼HÈºM¸MÍcÐRUÐVWÔRXÉkÌkÐ\]ÊoÈoð
 '+×&<Ò&<¸SÑ&AÔ&A�Ø—’˜x­¨^Ñ)<Ô)<Ñ=Ô=Ð=ØÐ%Ø× Ò  Ñ,Ô,Ð,ùðA 	-ð  	-r=   rÔ   únote.GeneralNotec                ó¸  — |dk    }t           }t          d¦  «        }|€|}n|}|                      ||¦  «         |                      ||¦  «         t          |t          j        ¦  «        rJ|                     ¦   «         r6|j        j        �*|j        j        dz  dz  }| 	                    d|d›¦  «         t          ||¦  «         |j        }	t          |	t          j        ¦  «        r¡t          |d¦  «        }
	 |	j        d	v r ||	|
d
t          j        ¬¦  «         |	j        � ||	|
dt          j        ¬¦  «         |	j        � ||	|
dt          j        ¬¦  «         n-# t(          $ r  t*                               d|	› �¦  «         Y nw xY w|                      ||¦  «         |j        r$|j        j        du r| 	                    dd¦  «         |j        D ]!}d|j        v r| 	                    dd¦  «         Œ"|rt          |d¦  «         t;          |d¦  «        rOt=          j        t          j         |¦  «        }|  !                    |j"        ¦  «        }| #                    |¦  «         n|j$        rt          |d¦  «         |	j%        dur*|  &                    |	¦  «        }| #                    |¦  «         |j'        �4|  (                    |j'        ¦  «        }|D ]}| #                    |¦  «         Œt          |t          j        ¦  «        r|  )                    |||¦  «         |  *                    ||¦  «         | j+        �)t          |d¦  «        }tY          | j+        ¦  «        |_-        t          d¦  «        }|	j%        du r|	j.        dk    rd|_-        n[	 t_          |	j.        ¦  «        |_-        n@# t`          $ r3 t          |t          j1        ¦  «        rte          j3        |¦  «        rn‚ Y nw xY w|  4                    ||dd¦  «         | #                    |¦  «         tk          |	j6        ¦  «        D ]}t          |d¦  «         Œt          |t          j         ¦  «        rS|j"        j7        �G|j"        j7        j8        dv r4|  9                    |j"        j7        ¦  «        }| #                    |¦  «         tu          |	j;        ¦  «        dk    r6|  <                    |	j;        d         ¦  «        }| #                    |¦  «         nštu          |	j;        ¦  «        dk    r‚t{          j>        |	 ?                    ¦   «         ¦  «         @                    d ¦  «        }t          jA        |jB        |jC        ¦  «        }|  <                    |¦  «        }| #                    |¦  «         d}|d!u rLt          |t          j        ¦  «        r2|jD        d"k    r't=          j        t          j        |¦  «        }|jD        }nO||urKt          |t          j        ¦  «        r1|jD        d"k    r&t=          j        t          j        |¦  «        }|jD        }d}|j        r7t          |j        t2          jE        ¦  «        r|j        jF        �|j        jF        }|€|r�t          |d#¦  «        }|€?| G                    t�          jI        ¦  «        x}r| J                    |jK        ¦  «        }nd$}n|}|d%k    rd&}||_-        |r,|  L                    ||¦  «         |  M                    ||¦  «         |  N                    |||¦  «         |d!u rUt          |t          j        ¦  «        r;|jO        �4|  P                    |jO        ¦  «        }|D ]}| #                    |¦  «         Œ|  Q                    |||¦  «        }|d!u rHt¥          |	j;        ¦  «        D ]3\  }} |  S                    | |dz   ¦  «        }!| T                    |!¦  «         Œ4|r*t          |d'¦  «        }"|D ]}#|" #                    |#¦  «         Œ|d!u r<|jU        D ]4}$|$j-        €Œ
|  V                    |$¦  «        }%| #                    |%¦  «         Œ5| jW         #                    |¦  «         |S )(aj  
        Translate a music21 :class:`~music21.note.Note` or a Rest into a
        ElementTree, note element.

        Note that, some note-attached spanners, such
        as octave shifts, produce direction (and direction types)
        in this method.

        >>> n = note.Note('D#5')
        >>> n.quarterLength = 3
        >>> n.volume.velocityScalar = 0.5
        >>> n.style.color = 'silver'

        >>> MEX = musicxml.m21ToXml.MeasureExporter()
        >>> len(MEX.xmlRoot)
        0
        >>> mxNote = MEX.noteToXml(n)
        >>> mxNote
        <Element 'note' at 0x10113cb38>
        >>> MEX.dump(mxNote)
        <note color="#C0C0C0" dynamics="70.56">
          <pitch>
            <step>D</step>
            <alter>1</alter>
            <octave>5</octave>
          </pitch>
          <duration>30240</duration>
          <type>half</type>
          <dot />
          <accidental>sharp</accidental>
          <notehead color="#C0C0C0" parentheses="no">normal</notehead>
        </note>
        >>> len(MEX.xmlRoot)
        1

        >>> r = note.Rest()
        >>> r.quarterLength = 1/3
        >>> r.duration.tuplets[0].type = 'start'
        >>> mxRest = MEX.noteToXml(r)
        >>> MEX.dump(mxRest)
        <note>
          <rest />
          <duration>3360</duration>
          <type>eighth</type>
          <time-modification>
            <actual-notes>3</actual-notes>
            <normal-notes>2</normal-notes>
            <normal-type>eighth</normal-type>
          </time-modification>
          <notations>
            <tuplet bracket="yes" number="1" placement="above" type="start">
              <tuplet-actual>
                <tuplet-number>3</tuplet-number>
                <tuplet-type>eighth</tuplet-type>
              </tuplet-actual>
              <tuplet-normal>
                <tuplet-number>2</tuplet-number>
                <tuplet-type>eighth</tuplet-type>
              </tuplet-normal>
            </tuplet>
          </notations>
        </note>
        >>> len(MEX.xmlRoot)
        2

        >>> n.notehead = 'diamond'
        >>> n.articulations.append(articulations.Pizzicato())
        >>> mxNote = MEX.noteToXml(n)
        >>> MEX.dump(mxNote)
        <note color="#C0C0C0" dynamics="70.56" pizzicato="yes">
          ...
          <notehead color="#C0C0C0" parentheses="no">diamond</notehead>
        </note>

        Notes with complex durations need to be simplified before coming here
        otherwise they raise :class:`MusicXMLExportException`:

        >>> nComplex = note.Note()
        >>> nComplex.duration.quarterLength = 5.0
        >>> mxComplex = MEX.noteToXml(nComplex)
        Traceback (most recent call last):
        music21.musicxml.xmlObjects.MusicXMLExportException:
        Cannot convert complex durations to MusicXML.
        Try exporting with makeNotation=True or manually running splitAtDurations()

        TODO: Test with spanners
        r   r   Néd   g?é“>é“ö?r   z.2fÚgrace)TFÚslashr~  zsteal-time-previouszsteal-time-followingz6Duration set as Grace while not being a GraceDuration Tzprint-spacingr¯  Ú	PizzicatoÚ	pizzicator   r   ÚrestÚvoicerR  r:   Úeighthr±  ÚnoteSizeÚdot)TNrÃ   iè  FÚunspecifiedr­  ÚupÚnoStemÚnonerþ  )Xr  r   rI  r‡   r   ÚNotRestÚhasVolumeInformationÚvolumeÚvelocityScalarr-  rM  r   ÚGraceDurationr   r&  r*   r+  ÚstealTimePreviousÚfractionToPercentÚstealTimeFollowingr^   rç  r§   rS  r'  r$   rR  r   r˜   ra  rê  ÚcastrÑ   Ú
pitchToXmlr   r¼   r…  ÚisGraceÚdurationXmlr'   ÚtieToXmlTieÚsetNoteInstrumentry  rR  r2   r&   rR  r<   r,   rà  r(   ÚisFullMeasureRestr6  rÚ   Údotsr¤  ÚdisplayStatusr¶  r  r  ÚtupletToTimeModificationÚ	fractionsÚFractionÚaggregateTupletMultiplierÚlimit_denominatorÚTupletÚdenominatorÚ	numeratorÚstemDirectionÚ	NoteStyleÚ	stemStyler¶   r   r·   ÚgetStemDirectionForPitchesÚpitchesrN  rL  ÚdealWithNoteheadrþ  Ú
beamsToXmlÚnoteToNotationsr  ÚtupletToXmlTupletÚextendÚlyricsÚ
lyricToXmlrü   )&r�   rÔ   rì  ÚchordParentÚaddChordTagr„  ÚmxNoteÚchordOrNÚvelrÒ   ÚgraceElementÚartÚmxPitchrq  Ú	mxTieListÚmxTieÚmxVoiceÚmxTypeÚunused_dotCounterrµ  ÚmxTimeModificationÚtupletFractionÚ
tempTupletrK  Ú
stem_styleÚmxStemÚclosest_clefÚsdTextÚ
nBeamsListÚmxBÚmxNotationsListrå   ÚtupÚ
tupTagListÚmxNotationsÚmxNÚlyricObjÚmxLyrics&                                         r;   r$  zMeasureExporter.noteToXmlx  sâ  € ðr (¨1Ò,ˆÝ(ˆå˜‘”ˆàÐØˆHˆHà"ˆHà×Ò˜v qÑ)Ô)Ð)ð 	×Ò˜6 8Ñ,Ô,Ð,õ �x¥¤Ñ.Ô.ð 	1Ø×1Ò1Ñ3Ô3ð	1à”OÔ2Ð>Ø”/Ô0°3Ñ6¸(ÑCˆCØ�JŠJ�z c < <Ñ0Ô0Ð0õ 	�v˜qÑ!Ô!Ð!àÔˆå�a�Ô/Ñ0Ô0ð 	`Ý% f¨gÑ6Ô6ˆLð`Ø”7˜mÐ+Ð+Ø�D˜˜L¨'½ZÔ=VÐWÑWÔWÐWàÔ&Ð2Ø�D˜Ø%Ø.Ý#-Ô#?ðAñ Aô Að Að
 Ô'Ð3Ø�D˜Ø%Ø/Ý#-Ô#?ðAñ Aô Að Aøøõ "ð `ð `ð `Ý×!Ò!Ð"^Ð[\Ð"^Ð"^Ñ_Ô_Ð_Ð_Ð_ð`øøøð
 	×Ò˜F AÑ&Ô&Ð&ØÔ ð 	/ Q¤WÔ%>À$Ð%FÐ%FØ�JŠJ�¨Ñ.Ô.Ð.àÔ)ð 	/ð 	/ˆCØ˜cœkÐ)Ð)Ø—
’
˜;¨Ñ.Ô.Ð.øàð 	(Ý�v˜wÑ'Ô'Ð'å�1�gÑÔð 	'Ý”•t”y !Ñ$Ô$ˆAØ—o’o a¤gÑ.Ô.ˆGØ�MŠM˜'Ñ"Ô"Ð"Ð"ØŒXð 	'Ý�v˜vÑ&Ô&Ð&àŒ9˜DÐ Ð Ø×)Ò)¨!Ñ,Ô,ˆJØ�MŠM˜*Ñ%Ô%Ð%ð Œ5ÐØ×(Ò(¨¬Ñ/Ô/ˆIØ"ð %ð %�Ø—’˜eÑ$Ô$Ð$Ð$å�a�œÑ&Ô&ð 	;Ø×"Ò" 1 f¨kÑ:Ô:Ð:Ø×Ò˜& !Ñ$Ô$Ð$ØÔÐ*Ý  ¨Ñ1Ô1ˆGÝ˜tÔ2Ñ3Ô3ˆGŒLå˜‘”ˆØŒ9˜ÐÐ ¤¨6Ò!1Ð!1à"ˆFŒKˆKðÝ0°´Ñ8Ô8�”�øÝ*ð ð ð Ý˜a¥¤Ñ+Ô+ð µÔ0IÈ!Ñ0LÔ0Lð ààð �Dðøøøð 	×Ò ¨¨6°:Ñ>Ô>Ð>Ø�Š�fÑÔÐÝ!& q¤v¡¤ð 	&ð 	&ÐÝ�v˜uÑ%Ô%Ð%Ð%õ �q�$œ)Ñ$Ô$ð 	(Ø”GÔ&Ð2Ø”GÔ&Ô4¸ÐDÐDØ×.Ò.¨q¬wÔ/AÑBÔBˆLØ�MŠM˜,Ñ'Ô'Ð'åˆqŒy‰>Œ>˜QÒÐØ!%×!>Ò!>¸q¼yÈ¼|Ñ!LÔ!LÐØ�MŠMÐ,Ñ-Ô-Ð-Ð-Ý�”‰^Œ^˜aÒÐå&Ô/°×0KÒ0KÑ0MÔ0Mñ 2ô 2ß2CÒ2CÀDÑ2IÔ2Ið å!œ¨Ô)CØ)7Ô)AñCô CˆJð
 "&×!>Ò!>¸zÑ!JÔ!JÐØ�MŠMÐ,Ñ-Ô-Ð-ð ˆð ˜5Ð Ð Ý˜x­¬Ñ6Ô6ð !àÔ*¨mÒ;Ð;Ý”v�dœl¨HÑ5Ô5ˆHØ$Ô2ˆMˆMð ˜aÐÐÝ˜q¥$¤,Ñ/Ô/ð  à”O }Ò4Ð4Ý”•t”| QÑ'Ô'ˆAØœOˆMàˆ
ØÔ(ð 	2Ý˜xœ~­u¬Ñ?Ô?ð	2à”NÔ,Ð8Ø!œÔ1ˆJàÐ$¨
Ð$Ý ¨Ñ/Ô/ˆFØÐ$Ø#+×#=Ò#=½d¼iÑ#HÔ#HÐH�<ð "Ø)×DÒDÀXÔEUÑVÔV�F�Fà!�F�Fà&�Ø˜Ò!Ð!Ø�Ø ˆFŒKØð 5Ø—’˜f jÑ1Ô1Ð1Ø× Ò  ¨Ñ4Ô4Ð4ð
 	×Ò˜f a¨Ñ5Ô5Ð5ð
 ˜%ÐÐÝ˜(¥D¤LÑ1Ô1ð '°h´nÐ6PØ!Ÿ_š_¨X¬^Ñ<Ô<�
Ø%ð 'ð '�CØ—M’M #Ñ&Ô&Ð&Ð&à×.Ò.¨qÐ2BÀKÑPÔPˆð ˜%ÐÐÝ# A¤IÑ.Ô.ð 3ð 3‘��3Ø!×3Ò3°C¸¸Q¹Ñ?Ô?�
Ø×&Ò& zÑ2Ô2Ð2Ð2àð 	(Ý$ V¨[Ñ9Ô9ˆKØ&ð (ð (�Ø×"Ò" 3Ñ'Ô'Ð'Ð'ð ˜%ÐÐØ$œOð 'ð '�Ø”=Ð(ØØŸ/š/¨(Ñ3Ô3�Ø—’˜gÑ&Ô&Ð&Ð&àŒ×Ò˜FÑ#Ô#Ð#Øˆs%   Ã6A"E Å'FÆFÎ	N# Î#:O ÏO únote.NotRestrY  r   rW  úchord.Chord | Nonec                ó¢  — | j         �| j         j        €dS t          | j         j        ¦  «        dk    rdS |j        rdS |r|n|}|                     ¦   «         }|€dS |}d}| j         j        D ]}|j        |j        k    r|} nŒ|€t          d|› d|› d�¦  «        ‚t          |d¦  «        }	|j        �|	 	                    d|j        ¦  «         dS dS )z–
        Insert <instrument> tags if necessary, that is, when there is more than one
        instrument anywhere in the same musicxml <part>.
        NrÃ   zInstrument instance z
 for note z not found in instrumentStreamr   r  )
rü  rÌ  r  r…  ÚgetInstrumentÚclassSetr,   r   rè  r-  )
r�   rÔ   rY  rW  ÚsearchingObjectÚclosest_inst_or_noneÚclosest_instÚinstance_to_user  ÚmxInstruments
             r;   r?  z!MeasureExporter.setNoteInstrument   s!  € ð Œ;Ð $¤+Ô">Ð"FØˆFåˆtŒ{Ô+Ñ,Ô,°Ò1Ð1ØˆFàŒ8ð 	ØˆFàCNÐ4U°K°KÐTUˆØ.×<Ò<Ñ>Ô>ÐØÐ'ØˆFØ.Bˆàˆà”KÔ0ð 	ð 	ˆDØŒ} Ô 5Ò5Ð5Ø"&�Ø�ð 6ð Ð"å)Ø` |Ð`Ð`¸qÐ`Ð`Ð`ñô ð õ " &¨,Ñ7Ô7ˆØÔ'Ð3Ø×Ò˜T ?Ô#?Ñ@Ô@Ð@Ð@Ð@ð 4Ð3r=   râ  ú	note.Restc                óZ  — |                       |¦  «        }|                     d¦  «        }|€t          d¦  «        ‚t          j        |¦  «        rq|                     dd¦  «         |                     d¦  «        }|�|                     |¦  «         |                     d¦  «        }|D ]}|                     |¦  «         Œ|j        dk    rßt          |d	¦  «        }t          |d
¦  «        }| 
                    t          j        ¦  «        }	|	�t          |	d¦  «        st          j        ¦   «         }	t          j        rt#          |	t          j        ¦  «        sJ ‚|	j        dz   }
|
|j        z   }t'          j        ¦   «         }||_        |j        |_        t1          |j        ¦  «        |_        |S )a×	  
        Convert a Rest object to a <note> with a <rest> tag underneath it.

        >>> MEX = musicxml.m21ToXml.MeasureExporter()
        >>> r = note.Rest(quarterLength=2.0)

        Give the rest some context:

        >>> m = stream.Measure()
        >>> m.timeSignature = meter.TimeSignature('4/4')
        >>> m.append(r)
        >>> mxNoteRest = MEX.restToXml(r)
        >>> MEX.dump(mxNoteRest)
        <note>
          <rest />
          <duration>20160</duration>
          <type>half</type>
        </note>

        Now it is a full measure:

        >>> m.timeSignature = meter.TimeSignature('2/4')
        >>> mxNoteRest = MEX.restToXml(r)
        >>> MEX.dump(mxNoteRest)
        <note>
          <rest measure="yes" />
          <duration>20160</duration>
        </note>

        Unless we specify that it should not be converted to a full measure:

        >>> r.fullMeasure = False
        >>> mxNoteRest = MEX.restToXml(r)
        >>> MEX.dump(mxNoteRest)
        <note>
          <rest />
          <duration>20160</duration>
          <type>half</type>
        </note>

        With True or "always" it will be converted to full measure even if
        it does not match:

        >>> m.timeSignature = meter.TimeSignature('4/4')
        >>> r.duration.dots = 1
        >>> r.fullMeasure = True
        >>> mxNoteRest = MEX.restToXml(r)
        >>> MEX.dump(mxNoteRest)
        <note>
          <rest measure="yes" />
          <duration>30240</duration>
        </note>

        Note that if a measure has paddingLeft/paddingRight (such as a pickup)
        then a fullMeasure duration might not match the TimeSignature duration.

        The display-step and display-octave are set from a Rest's stepShift:

        >>> r = note.Rest()
        >>> r.stepShift = 1
        >>> mxNoteRest = MEX.restToXml(r)
        >>> MEX.dump(mxNoteRest)
        <note>
          <rest>
            <display-step>C</display-step>
            <display-octave>5</display-octave>
          </rest>
          <duration>10080</duration>
          <type>quarter</type>
        </note>

        Clef context matters:

        >>> m = stream.Measure()
        >>> m.clef = clef.BassClef()
        >>> m.append(r)
        >>> mxNoteRest = MEX.restToXml(r)
        >>> MEX.dump(mxNoteRest)
        <note>
          <rest>
            <display-step>E</display-step>
            <display-octave>3</display-octave>
          </rest>
          <duration>10080</duration>
          <type>quarter</type>
        </note>
        r)  Nz3Something went wrong -- converted rest w/o rest tagr°   r¯  rR  r-  r   údisplay-stepúdisplay-octaveÚ
lowestLinerÙ   )r$  Úfindr,   r(   r@  r-  ÚremoveÚfindallÚ	stepShiftr   r¶   r   Ú	PitchClefra  Ú
TrebleClefrê  rë  r‡   r‚  r   ro   ÚdiatonicNoteNumÚstepr&   r2   Úoctave)r�   râ  rY  Ú	mxRestTagrb  ÚmxDotsÚmxDotÚmxDisplayStepÚmxDisplayOctaveÚcurrentClefÚ
midLineDNNÚrestObjectPseudoDNNÚ	tempPitchs                r;   r1  zMeasureExporter.restToXmlÇ  s™  € ðr —’ Ñ"Ô"ˆØ—K’K Ñ'Ô'ˆ	ØÐÝ)Ð*_Ñ`Ô`Ð`åÔ$ QÑ'Ô'ð 	%Ø�MŠM˜) UÑ+Ô+Ð+Ø—[’[ Ñ(Ô(ˆFØÐ!Ø—’˜fÑ%Ô%Ð%Ø—^’^ EÑ*Ô*ˆFØð %ð %�Ø—’˜eÑ$Ô$Ð$Ð$ð Œ;˜!ÒÐÝ& y°.ÑAÔAˆMÝ(¨Ð4DÑEÔEˆOØ/0×/BÒ/BÅ4Ä>Ñ/RÔ/RˆKØÐ"­'°+¸|Ñ*LÔ*LÐ"Ý"œoÑ/Ô/�õ Œð ?Ý! +­t¬~Ñ>Ô>Ð>Ð>Ð>Ø$Ô/°!Ñ3ˆJØ",¨q¬{Ñ":ÐÝœ™œˆIØ(;ˆIÔ%Ø!*¤ˆMÔÝ#& yÔ'7Ñ#8Ô#8ˆOÔ àˆr=   rv  úchord.ChordBasec                óP  — g }t          |t          j        ¦  «        r|                     ¦   «          t	          |¦  «        D ]e\  }}d|j        v r,|                     |                      |||¬¦  «        ¦  «         Œ:|                     |                      |||¬¦  «        ¦  «         Œf|S )a=  
        Returns a list of <note> tags, all but the first with a <chord/> tag on them.
        And appends them to self.xmlRoot

        Attributes of notes are merged from different locations: first from the
        duration objects, then from the pitch objects. Finally, GeneralNote
        attributes are added.

        >>> ch = chord.Chord()
        >>> ch.quarterLength = 2
        >>> b = pitch.Pitch('A-2')
        >>> c = pitch.Pitch('D3')
        >>> d = pitch.Pitch('E4')
        >>> e = [b, c, d]
        >>> ch.pitches = e

        >>> len(ch.pitches)
        3
        >>> MEX = musicxml.m21ToXml.MeasureExporter()
        >>> len(MEX.xmlRoot)
        0
        >>> mxNoteList = MEX.chordToXml(ch)
        >>> len(mxNoteList)  # get three mxNotes
        3
        >>> len(MEX.xmlRoot)
        3

        >>> MEX.dump(mxNoteList[0])
        <note>
          <pitch>
            <step>A</step>
            <alter>-1</alter>
            <octave>2</octave>
          </pitch>
          <duration>20160</duration>
          <type>half</type>
          <accidental>flat</accidental>
        </note>

        >>> MEX.dump(mxNoteList[1])
        <note>
          <chord />
          <pitch>
            <step>D</step>
            <octave>3</octave>
          </pitch>
          <duration>20160</duration>
          <type>half</type>
        </note>

        >>> MEX.dump(mxNoteList[2])
        <note>
          <chord />
          <pitch>
            <step>E</step>
            <octave>4</octave>
          </pitch>
          <duration>20160</duration>
          <type>half</type>
        </note>

        Test that notehead and style translation works:

        >>> g = pitch.Pitch('g3')
        >>> h = note.Note('b4')
        >>> h.notehead = 'diamond'
        >>> h.style.color = 'gold'
        >>> h.style.absoluteX = 176
        >>> ch2 = chord.Chord([g, h])
        >>> ch2.quarterLength = 2.0
        >>> mxNoteList = MEX.chordToXml(ch2)
        >>> MEX.dump(mxNoteList[1])
        <note color="#FFD700" default-x="176">
          <chord />
          <pitch>
            <step>B</step>
            <octave>4</octave>
          </pitch>
          <duration>20160</duration>
          <type>half</type>
          <notehead color="#FFD700" parentheses="no">diamond</notehead>
        </note>

        And unpitched chord members:

        >>> perc = percussion.PercussionChord([note.Unpitched(), note.Unpitched()])
        >>> for n in MEX.chordToXml(perc):
        ...     MEX.dump(n)
        <note>
          <unpitched>
            <display-step>B</display-step>
            <display-octave>4</display-octave>
          </unpitched>
          <duration>10080</duration>
          <type>quarter</type>
        </note>
        <note>
          <chord />
          <unpitched>
            <display-step>B</display-step>
            <display-octave>4</display-octave>
          </unpitched>
          <duration>10080</duration>
          <type>quarter</type>
        </note>

        Test articulations of chords with fingerings. Superfluous fingerings will be ignored.

        >>> testChord = chord.Chord('E4 C5')
        >>> testChord.articulations = [articulations.Fingering(1),
        ...        articulations.Accent(), articulations.Fingering(5), articulations.Fingering(3)]
        >>> for n in MEX.chordToXml(testChord):
        ...     MEX.dump(n)
        <note>
          ...
          <notations>
            <articulations>
              <accent />
            </articulations>
            <technical>
              <fingering alternate="no" substitution="no">1</fingering>
            </technical>
          </notations>
        </note>
        <note>
          <chord />
          ...
          <notations>
            <technical>
              <fingering alternate="no" substitution="no">5</fingering>
            </technical>
          </notations>
        </note>
        r/  ©rì  rW  )	r‡   r   r  ÚsortAscendingr  rx  r¼   r0  r$  )r�   rv  Ú
mxNoteListrå   rÔ   s        r;   r.  zMeasureExporter.chordToXmlB  s³   € ðP ˆ
Ý�a�œÑ%Ô%ð 	Ø�OŠOÑÔÐå˜a‘L”Lð 	Xð 	X‰DˆAˆqØ˜aœjÐ(Ð(Ø×!Ò! $×"5Ò"5°aÈ!ÐYZÐ"5Ñ"[Ô"[Ñ\Ô\Ð\Ð\à×!Ò! $§.¢.°ÀQÐTU .Ñ"VÔ"VÑWÔWÐWÐWØÐr=   Údurúduration.Durationc                óš   — t          d¦  «        }t          t          t          | j        |j        z  ¦  «        ¦  «        ¦  «        |_        |S )aU  
        Convert a duration.Duration object to a <duration> tag using self.currentDivisions

        >>> d = duration.Duration(1.5)
        >>> MEX = musicxml.m21ToXml.MeasureExporter()
        >>> MEX.currentDivisions = 10
        >>> mxDuration = MEX.durationXml(d)
        >>> MEX.dump(mxDuration)
        <duration>15</duration>
        r   )r   r2   r  rn  rL  rá   r&   )r�   rš  rq  s      r;   r=  zMeasureExporter.durationXmlÕ  sA   € õ ˜ZÑ(Ô(ˆ
Ý�c¥%¨Ô(=ÀÔ@QÑ(QÑ"RÔ"RÑSÔSÑTÔTˆ
ŒØÐr=   r®   rï   c                óú   — t          d¦  «        }t          ||dd¦  «         |j        �@t          |d¦  «        }t	          t          j        |j        j        ¦  «        ¦  «        |_        t          ||dd¦  «         |S )a�  
        Convert a :class:`~music21.pitch.Pitch` to xml.
        Does not create the <accidental> tag.

        >>> p = pitch.Pitch('D#5')
        >>> MEX = musicxml.m21ToXml.MeasureExporter()
        >>> mxPitch = MEX.pitchToXml(p)
        >>> MEX.dump(mxPitch)
        <pitch>
          <step>D</step>
          <alter>1</alter>
          <octave>5</octave>
        </pitch>
        r   rŠ  NÚalterr‹  ÚimplicitOctave)	r   r`   r¤  r   r2   r   ÚnumToIntOrFloatrž  r&   )r�   r®   r^  ÚmxAlters       r;   r;  zMeasureExporter.pitchToXmlå  su   € õ  ˜'Ñ"Ô"ˆÝ   G¨V°VÑ<Ô<Ð<ØŒ<Ð#Ý  ¨'Ñ2Ô2ˆGÝ�vÔ5°a´lÔ6HÑIÔIÑJÔJˆGŒLÝ   G¨XÐ7GÑHÔHÐHØˆr=   r/  únote.Unpitchedúchord.ChordBase | Nonec                óÊ   — |                       |||¬¦  «        }t          d¦  «        }t          ||d¦  «         t          ||d¦  «         t          j        ||ddg¬¦  «         |S )ay  
        Convert an :class:`~music21.note.Unpitched` to a <note>
        with an <unpitched> subelement.

        >>> up = note.Unpitched(displayName='D5')
        >>> MEX = musicxml.m21ToXml.MeasureExporter()
        >>> mxUnpitched = MEX.unpitchedToXml(up)
        >>> MEX.dump(mxUnpitched)
        <note>
          <unpitched>
            <display-step>D</display-step>
            <display-octave>5</display-octave>
          </unpitched>
          <duration>10080</duration>
          <type>quarter</type>
        </note>

        >>> graceUp = up.getGrace()
        >>> mxUnpitched = MEX.unpitchedToXml(graceUp)
        >>> MEX.dump(mxUnpitched)
        <note>
          <grace slash="yes" />
          <unpitched>
            <display-step>D</display-step>
            <display-octave>5</display-octave>
          </unpitched>
          <type>quarter</type>
        </note>
        r—  Ú	unpitchedr€  r�  r   rR  )ÚtagList)r$  r   r`   r(   ÚinsertBeforeElements)r�   r/  rì  rW  rY  ÚmxUnpitcheds         r;   r0  zMeasureExporter.unpitchedToXmlý  sr   € ðD —’ Ð5EÐS^�Ñ_Ô_ˆå˜kÑ*Ô*ˆÝ   [°.ÑAÔAÐAÝ   [Ð2BÑCÔCÐCåÔ$ V¨[À:ÈvÐBVÐWÑWÔWÐWàˆr=   c                óž   — t          d¦  «        }t          ||dd¦  «         t          ||dd¦  «         |j        �t          ||dd¦  «         |S )aÈ  
        Converts a FretNote Object to MusicXML readable format.

        Note that, although music21 is referring to FretNotes as FretNotes,
        musicxml refers to them as frame notes. To convert between the two formats,
        each 'Fret-Note' must be converted to 'Frame-Note'.

        >>> fn = tablature.FretNote(string=3, fret=1, fingering=2)
        >>> MEX = musicxml.m21ToXml.MeasureExporter()
        >>> MEXFretNote = MEX.fretNoteToXml(fn)
        >>> MEX.dump(MEXFretNote)
        <frame-note>
            <string>3</string>
            <fret>1</fret>
            <fingering>2</fingering>
        </frame-note>

        Without fingering!

        >>> fn2 = tablature.FretNote(string=5, fret=2)
        >>> MEX = musicxml.m21ToXml.MeasureExporter()
        >>> MEXOtherFretNote = MEX.fretNoteToXml(fn2)
        >>> MEX.dump(MEXOtherFretNote)
        <frame-note>
            <string>5</string>
            <fret>2</fret>
        </frame-note>
        z
frame-noteÚstringÚfretNÚ	fingering)r   r`   r¬  )r�   ÚfretNoteÚmxFrameNotes      r;   ÚfretNoteToXmlzMeasureExporter.fretNoteToXml)  s\   € õ: ˜lÑ+Ô+ˆÝ  ¨;¸À(ÑKÔKÐKÝ  ¨;¸ÀÑGÔGÐGàÔÐ)Ý$ X¨{¸KÈÑUÔUÐUàÐr=   rY   c                ó\  — |j         sdS t          d¦  «        }t          |d¦  «        }t          |j        ¦  «        |_        t          |d¦  «        }t          |j        ¦  «        |_        |                     ¦   «         D ],}|                      |¦  «        }| 	                    |¦  «         Œ-|S )af  
        The ChordWithFretBoard Object combines chord symbols with FretNote objects.

        >>> myFretNote1 = tablature.FretNote(1, 2, 2)
        >>> myFretNote2 = tablature.FretNote(2, 3, 3)
        >>> myFretNote3 = tablature.FretNote(3, 2, 1)
        >>> guitarChord = tablature.ChordWithFretBoard('DM', numStrings=6,
        ...                    fretNotes=[myFretNote1, myFretNote2, myFretNote3])
        >>> guitarChord.tuning = tablature.GuitarFretBoard().tuning
        >>> guitarChord.getPitches()
        [None, None, None,
         <music21.pitch.Pitch A3>, <music21.pitch.Pitch D4>, <music21.pitch.Pitch F#4>]
        >>> MEX = musicxml.m21ToXml.MeasureExporter()
        >>> MEXChordWithFret = MEX.fretBoardToXml(guitarChord)
        >>> MEX.dump(MEXChordWithFret)
        <frame>
            <frame-strings>6</frame-strings>
            <frame-frets>4</frame-frets>
            <frame-note>
                <string>3</string>
                <fret>2</fret>
                <fingering>1</fingering>
            </frame-note>
            <frame-note>
                <string>2</string>
                <fret>3</fret>
                <fingering>3</fingering>
            </frame-note>
            <frame-note>
                <string>1</string>
                <fret>2</fret>
                <fingering>2</fingering>
            </frame-note>
        </frame>
        NÚframezframe-stringszframe-frets)
Ú	fretNotesr   r   r2   Ú
numStringsr&   ÚdisplayFretsÚfretNotesLowestFirstr¯  r¼   )r�   Ú	fretBoardÚmxFrameÚmxFrameStringsÚmxFrameFretsÚthisFretNoteÚ
mxFretNotes          r;   ÚfretBoardToXmlzMeasureExporter.fretBoardToXmlO  s°   € ðH Ô"ð 	Ø�4õ ˜'Ñ"Ô"ˆÝ# G¨_Ñ=Ô=ˆÝ! )Ô"6Ñ7Ô7ˆÔÝ! '¨=Ñ9Ô9ˆÝ 	Ô 6Ñ7Ô7ˆÔà%×:Ò:Ñ<Ô<ð 	'ð 	'ˆLØ×+Ò+¨LÑ9Ô9ˆJØ�NŠN˜:Ñ&Ô&Ð&Ð&àˆr=   Úcwfútablature.ChordWithFretBoardc                óÎ   — |                       |¦  «        }t          j        rt          |t          ¦  «        sJ ‚|                      |¦  «        }|�|                     |¦  «         |S )zb
        Deals with both chords and frets.
        Generate harmony and append xml to it.
        )r*  rê  rë  r‡   r   r¼  r¼   )r�   r½  Ú	mxHarmonyr·  s       r;   r(  z'MeasureExporter.chordWithFretBoardToXmlƒ  sj   € ð
 ×)Ò)¨#Ñ.Ô.ˆ	ÝŒ?ð 	2å˜i­Ñ1Ô1Ð1Ð1Ð1à×%Ò% cÑ*Ô*ˆàÐØ×Ò˜WÑ%Ô%Ð%àÐr=   c                óN  — t          d¦  «        }t          ||dd¦  «         t          ||dd¦  «         |j        �jt          |d¦  «        }t	          |j        j        ¦  «        |_        |j        j        dk    r,t          |j        j        ¦  «        D ]}t          |d	¦  «         Œ|S )
aÆ  
        >>> tup = duration.Tuplet(11, 8)
        >>> MEX = musicxml.m21ToXml.MeasureExporter()
        >>> mxTimeMod = MEX.tupletToTimeModification(tup)
        >>> MEX.dump(mxTimeMod)
        <time-modification>
          <actual-notes>11</actual-notes>
          <normal-notes>8</normal-notes>
        </time-modification>

        >>> tup.setDurationType('eighth', dots=2)
        >>> mxTimeMod = MEX.tupletToTimeModification(tup)
        >>> MEX.dump(mxTimeMod)
        <time-modification>
          <actual-notes>11</actual-notes>
          <normal-notes>8</normal-notes>
          <normal-type>eighth</normal-type>
          <normal-dot />
          <normal-dot />
        </time-modification>

        ztime-modificationzactual-notesÚnumberNotesActualznormal-notesÚnumberNotesNormalNznormal-typer   z
normal-dot)	r   r`   ÚdurationNormalr   r<   rR  r&   rA  rÚ   )r�   rn  rd  ÚmxNormalTyperå   s        r;   rC  z(MeasureExporter.tupletToTimeModification”  s¸   € õ0 %Ð%8Ñ9Ô9ÐÝ  Ð&8¸.ÐJ]Ñ^Ô^Ð^Ý  Ð&8¸.ÐJ]Ñ^Ô^Ð^ØÔÐ)Ý%Ð&8¸-ÑHÔHˆLÝ 2°3Ô3EÔ3JÑ KÔ KˆLÔØÔ!Ô&¨Ò*Ð*Ý˜sÔ1Ô6Ñ7Ô7ð Að A�AÝÐ1°<Ñ@Ô@Ð@Ð@à!Ð!r=   c                ó   — d}t          |t          j        ¦  «        ry|j        dk    s#|j        s|j        €|j        rY|j        j        dvrKt          j
        t          j        |¦  «        }d}|                      |¦  «        }|                     |¦  «         |du rl|�lt          |d¦  «        r^|j        dk    s#|j        s|j        €|j        r@|j        j        dvr4|                      |¦  «        }|                     |¦  «         dS dS dS dS dS dS )a…  
        Determine if an <notehead> element needs to be added to this <note>
        element (mxNote) and if it does then get the <notehead> element from
        noteheadToXml and add it to mxNote.

        Complicated because the chordParent might have notehead
        set, which would affect every note along the way.

        Returns nothing.  The mxNote is modified in place.
        Fr  Nr[   TÚnotehead)r‡   r   r2  rÇ  ÚnoteheadParenthesisÚnoteheadFillr'  r$   r>   rê  r:  ÚnoteheadToXmlr¼   ra  )r�   rY  rÔ   rW  ÚfoundANoteheadÚ
mxNoteheads         r;   rP  z MeasureExporter.dealWithNotehead¸  sE  € ð  ˆÝ�q�$œ,Ñ'Ô'ð 	&Ø”˜xÒ'Ð'ØÔ)ð (à”NÐ.ØÔ*ð /Ø/0¬w¬}ÀJÐ/NÐ/NÝ”•t”| QÑ'Ô'ˆAØ!ˆNØ×+Ò+¨AÑ.Ô.ˆJØ�MŠM˜*Ñ%Ô%Ð%Ø˜UÐ"Ð" {Ð'>Ý˜ ZÑ0Ô0ð *Ø Ô)¨XÒ5Ð5Ø#Ô7ð 6à#Ô0Ð<Ø$Ô8ð =à(Ô.Ô4¸JÐFÐFØ!×/Ò/°Ñ<Ô<�
Ø—’˜jÑ)Ô)Ð)Ð)Ð)ð #Ð"Ð'>Ð'>ð*ð *ð =Ð<àFÐFr=   c                óB  — t          d¦  «        }|j        }|€d}||_        t          } |||ddt          j        ¬¦  «          |||ddt          j        ¬¦  «         |j        r;|j        j        r/t          |j        j        ¦  «        }| 
                    d	|¦  «         |S )
a  
        Translate a music21 :class:`~music21.note.NotRest` object
        such as a Note, or Chord into a `<notehead>` tag.

        >>> n = note.Note('C#4')
        >>> n.notehead = 'diamond'
        >>> MEX = musicxml.m21ToXml.MeasureExporter()
        >>> mxN = MEX.noteheadToXml(n)
        >>> MEX.dump(mxN)
        <notehead parentheses="no">diamond</notehead>

        >>> n1 = note.Note('c3')
        >>> n1.style.color = 'red'
        >>> n1.notehead = 'diamond'
        >>> n1.noteheadParenthesis = True
        >>> n1.noteheadFill = False
        >>> mxN = MEX.noteheadToXml(n1)
        >>> MEX.dump(mxN)
        <notehead color="#FF0000" filled="no" parentheses="yes">diamond</notehead>

        >>> n1 = note.Note('c3')
        >>> n1.style.color = 'red'
        >>> n1.notehead = 'diamond'
        >>> n1.noteheadParenthesis = True
        >>> n1.noteheadFill = False
        >>> mxN = MEX.noteheadToXml(n1)
        >>> MEX.dump(mxN)
        <notehead color="#FF0000" filled="no" parentheses="yes">diamond</notehead>
        rÇ  Nr1  ÚfilledrÉ  r~  r­  rÈ  r>   )r   rÇ  r&   r  r*   r+  r'  r$   r>   rE   r-  )r�   rÔ   rÌ  Únhr„  r>   s         r;   rÊ  zMeasureExporter.noteheadToXmlÜ  s·   € õ> ˜ZÑ(Ô(ˆ
ØŒZˆØˆ:ØˆBØˆ
ŒÝ(ˆØˆˆQ�
˜H nÅ
Ô@YÐZÑZÔZÐZØˆˆQ�
˜MÐ+@Ý!Ô0ð	2ñ 	2ô 	2ð 	2ð Ô ð 	+ Q¤W¤]ð 	+Ý" 1¤7¤=Ñ1Ô1ˆEØ�NŠN˜7 EÑ*Ô*Ð*ØÐr=   c                ó<  — d }|j         dk    ry|dk    r,|                      |¦  «        }|                     dd¦  «         n\|t          |j        ¦  «        dz
  k    r+|                      |¦  «        }|                     dd¦  «         n|                      |¦  «        }|S )Nr  r   rR  r‹  rÃ   rŠ  )rR  ÚexpressionToXmlr-  r  Únotes)r�   ÚarpeggioMarkÚchordOrNoterì  ÚmxExpressions        r;   ÚarpeggioMarkToMxExpressionz*MeasureExporter.arpeggioMarkToMxExpression
  s¬   € ØˆØÔ Ò.Ð.à 1Ò$Ð$Ø#×3Ò3°LÑAÔA�Ø× Ò  ¨Ñ2Ô2Ð2Ð2Ø!¥S¨Ô):Ñ%;Ô%;¸aÑ%?Ò?Ð?Ø#×3Ò3°LÑAÔA�Ø× Ò  ¨Ñ/Ô/Ð/øð  ×/Ò/°Ñ=Ô=ˆLØÐr=   ÚornamentObjúexpressions.Ornamentc                ó”  — g }t          |t          j        ¦  «        ré|j        rm|j        j        ra|j        j        j        du rN|                     |                      |j        j        ¦  «        ¦  «         |d                              dd¦  «         |j	        rm|j	        j        ra|j	        j        j        du rN|                     |                      |j	        j        ¦  «        ¦  «         |d                              dd¦  «         nÂt          |t          j
        t          j        f¦  «        rœ|j        r•|j        j        r‰|j        j        j        du rv|                     |                      |j        j        ¦  «        ¦  «         |j        dk    r|d                              dd¦  «         n|d                              dd¦  «         |S )NTrè  r»  ÚaboveÚbelowÚdown)r‡   r   ÚTurnÚupperOrnamentalPitchr¤  rB  r¼   r¸  r-  ÚlowerOrnamentalPitchÚGeneralMordentÚTrillÚornamentalPitchr‘  )r�   r×  ÚmxAccidentalMarkss      r;   ÚornamentToMxAccidentalMarksz+MeasureExporter.ornamentToMxAccidentalMarks  sã  € Ø+-Ðå�k¥;Ô#3Ñ4Ô4ð 	DàÔ0ð @Ø#Ô8ÔCð@à#Ô8ÔCÔQÐUYÐYÐYØ!×(Ò(Ø×5Ò5°kÔ6VÔ6aÑbÔbñô ð ð " "Ô%×)Ò)¨+°wÑ?Ô?Ð?ØÔ0ð @Ø#Ô8ÔCð@à#Ô8ÔCÔQÐUYÐYÐYØ!×(Ò(Ø×5Ò5°kÔ6VÔ6aÑbÔbñô ð ð " "Ô%×)Ò)¨+°wÑ?Ô?Ð?øÝ˜¥kÔ&@Å+ÔBSÐ%TÑUÔUð 	DàÔ+ð 	DØ#Ô3Ô>ð	Dà#Ô3Ô>ÔLÐPTÐTÐTØ!×(Ò(Ø×5Ò5°kÔ6QÔ6\Ñ]Ô]ñô ð ð Ô(¨FÒ2Ð2Ø% bÔ)×-Ò-¨k¸7ÑCÔCÐCÐCà% bÔ)×-Ò-¨k¸7ÑCÔCÐCà Ð r=   c                óÒ  — d}d}d}|dk    }g }|}	|�|}	|	j         D ]ë}
t          |
t           j        ¦  «        r0|                      |
|	|¦  «        }|€Œ6|                     |¦  «         ŒL|r�|                      |
¦  «        }|€Œft          |
t           j        ¦  «        rV|€t          d¦  «        }|                     |¦  «         |                      |
¦  «        }|D ]}|                     |¦  «         ŒŒÖ|                     |¦  «         Œìg }d}|	j	        D ]z}t          |t          j
        ¦  «        r!||k    r|                     |¦  «         |dz  }Œ=|r;t          |t          j        t          j        f¦  «        s|                     |¦  «         Œ{|D ]Ð}t          |t          j        ¦  «        rŒt          |t          j        ¦  «        r|j        dk     rŒCt          |t          j        ¦  «        r:|€t          d¦  «        }|                     |                      |¦  «        ¦  «         Œ—|€t          d¦  «        }|                     |                      |¦  «        ¦  «         ŒÑ|j        �/|                      |j        ¦  «        }|                     |¦  «         |�*|                     |                      ||¦  «        ¦  «         n)|                     |                      ||¦  «        ¦  «         |r|�|                      |¦  «        }n|�d}n|                      |¦  «        }|r&|€t          d¦  «        }|                     |¦  «         |||fD ]}|�|                     |¦  «         Œ|S )zŠ
        Take information from .expressions,
        .articulations, and spanners to
        make the <notations> tag for a note.
        Nr   rø  rÃ   Ú	technicalr   )r   r‡   ÚArpeggioMarkrÖ  r¼   rÑ  ÚOrnamentr   rä  r   Ú	Fingeringr  r  r'  ÚStringIndicationrÅ   ÚTechnicalIndicationÚarticulationToXmlTechnicalÚarticulationToXmlArticulationr'   ÚtieToXmlTiedrT  r	  r  )r�   rÔ   rì  rW  ÚmxArticulationsÚmxTechnicalMarkÚmxOrnamentsr   rþ  rÔ  ÚexpObjrÕ  ÚmxAccidMarksÚmxAccidMarkÚapplicableArticulationsÚfingeringNumberÚaObjÚtiedListÚspannerTechnicalsr$  s                       r;   rR  zMeasureExporter.noteToNotations;  s	  € ð ˆØˆØˆØ&6¸!Ò&;Ð"à#%ˆ	àˆØÐ"à%ˆKð "Ô-ð 	3ð 	3ˆFÝ˜&¥+Ô":Ñ;Ô;ð 3Ø#×>Ò>Ø˜KÐ)9ñ ô  �ð  Ð'àØ× Ò  Ñ.Ô.Ð.Ð.à+ð 3Ø#×3Ò3°FÑ;Ô;�ØÐ'ð Ý˜f¥kÔ&:Ñ;Ô;ð 3Ø"Ð*Ý&-¨kÑ&:Ô&:˜Ø×&Ò& |Ñ4Ô4Ð4ð ×8Ò8¸Ñ@Ô@ð !ð (4ð 8ð 8˜Ø#×*Ò*¨;Ñ7Ô7Ð7Ð7ð8ð ×$Ò$ \Ñ2Ô2Ð2øð EGÐØˆØÔ-ð 	9ð 	9ˆDÝ˜$¥Ô 7Ñ8Ô8ð 9Ø"Ð&6Ò6Ð6Ø+×2Ò2°4Ñ8Ô8Ð8Ø 1Ñ$��Ø+ð 9õ " $­Ô)?ÅÔAVÐ(WÑXÔXð 9Ø+×2Ò2°4Ñ8Ô8Ð8øà+ð 	Qð 	QˆDÝ˜$¥Ô 7Ñ8Ô8ð ØÝ˜$¥Ô >Ñ?Ô?ð ÀDÄKÐRSÂOÀOØÝ˜$¥Ô AÑBÔBð QØ"Ð*Ý&-¨kÑ&:Ô&:�Oà×&Ò& t×'FÒ'FÀtÑ'LÔ'LÑMÔMÐMÐMà"Ð*Ý&-¨oÑ&>Ô&>�OØ×&Ò& t×'IÒ'IÈ$Ñ'OÔ'OÑPÔPÐPÐPð Œ5ÐØ×(Ò(¨¬Ñ/Ô/ˆHØ×Ò˜XÑ&Ô&Ð&ð Ð"Ø×Ò˜T×CÒCÀKÐQaÑbÔbÑcÔcÐcÐcà×Ò˜T×CÒCÀAÐGWÑXÔXÑYÔYÐYð
 &ð 	K¨+Ð*AØ $× GÒ GÈÑ TÔ TÐÐØÐ$Ø $ÐÐà $× GÒ GÈÑ JÔ JÐØð 	6ØÐ&Ý")¨+Ñ"6Ô"6�Ø×"Ò"Ð#4Ñ5Ô5Ð5à!Ø!Øðð 	$ð 	$ˆAð ˆ}Ø× Ò  Ñ#Ô#Ð#øð
 Ðr=   Úm21Tieútie.Tiec                ó2  — g }|j         dk    rd}n|j         }t          d¦  «        }|                     d|¦  «         |                     |¦  «         |j         dk    r:t          d¦  «        }|                     dd¦  «         |                     |¦  «         |S )a€  
        returns a list of ties from a Tie object.

        A 'continue' tie requires two <tie> tags to represent.

        >>> tieObj = tie.Tie('continue')
        >>> MEX = musicxml.m21ToXml.MeasureExporter()
        >>> tieList = MEX.tieToXmlTie(tieObj)
        >>> for mxT in tieList:
        ...     MEX.dump(mxT)
        <tie type="stop" />
        <tie type="start" />
        ÚcontinuerZ  r'   rR  rj  )rR  r   r-  r¼   )r�   rú  r_  ÚmusicxmlTieTyper`  s        r;   r>  zMeasureExporter.tieToXmlTie¼  s�   € ð ˆ	àŒ;˜*Ò$Ð$Ø$ˆOˆOà$œkˆOÝ˜‘”ˆØ�	Š	�&˜/Ñ*Ô*Ð*Ø×Ò˜ÑÔÐàŒ;˜*Ò$Ð$Ý˜E‘N”NˆEØ�IŠI�f˜gÑ&Ô&Ð&Ø×Ò˜UÑ#Ô#Ð#àÐr=   c                ó‚  — |j         dk    rg S g }|j        dk    rd}n|j        }t          d¦  «        }t          ||¦  «         |                     d|¦  «         |                     |¦  «         |j        dk    r:t          d¦  «        }|                     dd¦  «         |                     |¦  «         |j         dk    r&|j        dk    r|                     d|j         ¦  «         |j        �S|                     d
|j        ¦  «         d	}|j        dk    rd}n|j        dk    rd}nd}|r|                     d|¦  «         |S )aö  
        In musicxml, a tie is represented in sound
        by the tie tag (near the pitch object), and
        the <tied> tag in notations.  This
        creates the <tied> tag.

        Returns a list since a music21 "continue" tie type needs two tags
        in musicxml.  List may be empty if tie.style == "hidden"

        >>> tieObj = tie.Tie('continue')
        >>> tieObj.id = 'tied1'

        >>> MEX = musicxml.m21ToXml.MeasureExporter()
        >>> tiedList = MEX.tieToXmlTied(tieObj)
        >>> for mxT in tiedList:
        ...     MEX.dump(mxT)
        <tied id="tied1" type="stop" />
        <tied type="start" />

        >>> tieObj.style = 'hidden'
        >>> tiedList = MEX.tieToXmlTied(tieObj)
        >>> len(tiedList)
        0
        Úhiddenrý  rZ  ÚtiedrR  rj  r  rº  Nr»  rÚ  ÚoverrÛ  Úunderr@   Úorientation)r$   rR  r   rM  r-  r¼   r»  )r�   rú  Ú
mxTiedListrþ  ÚmxTiedr  s         r;   rî  zMeasureExporter.tieToXmlTiedÜ  sf  € ð4 Œ<˜8Ò#Ð#ØˆIàˆ
ØŒ;˜*Ò$Ð$Ø$ˆOˆOà$œkˆOå˜‘”ˆÝ�v˜vÑ&Ô&Ð&à�
Š
�6˜?Ñ+Ô+Ð+Ø×Ò˜&Ñ!Ô!Ð!àŒ;˜*Ò$Ð$Ý˜V‘_”_ˆFØ�JŠJ�v˜wÑ'Ô'Ð'Ø×Ò˜fÑ%Ô%Ð%ð Œ<˜8Ò#Ð#¨¬°vÒ(=Ð(=Ø�JŠJ�{ F¤LÑ1Ô1Ð1ð ÔÐ'Ø�JŠJ�{ FÔ$4Ñ5Ô5Ð5ØˆKØÔ 7Ò*Ð*Ø$��ØÔ! WÒ,Ð,Ø%��à �ð
 ð 7Ø—
’
˜=¨+Ñ6Ô6Ð6ð
 Ðr=   rÃ   c                ó  — |j         dv rg S |j         dvrt          d|j         z   ¦  «        ‚|j         dk    rddg}n|j         g}g }|D �]¶}t          d¦  «        }|                     d|¦  «         |                     d	t	          |¦  «        ¦  «         |dk    �rO|j        }|d
k    rd}|                     dt          j        |¦  «        ¦  «         |j        �|                     d|j        ¦  «         |j	        }|j
        }	|€|                     dd¦  «         n9|dv r|	dv r|                     dd¦  «         n|dv r|                     dd¦  «         |dv r|	dv r|                     dd¦  «         n|dv r|                     dd¦  «         |j        d
k    r|                     dd¦  «         t          |d¦  «        }
t          |
d¦  «        }t	          |j        ¦  «        |_        |j        �^t          |j        j         ¦  «        }|rt          |
d¦  «        }||_        t!          |j        j        ¦  «        D ]}t          |
d¦  «         Œt          |d¦  «        }t          |d¦  «        }t	          |j        ¦  «        |_        |j        �^t          |j        j         ¦  «        }|rt          |d¦  «        }||_        t!          |j        j        ¦  «        D ]}t          |d¦  «         Œ|                     |¦  «         �Œ¸|S )a®  
        In musicxml, a tuplet is represented by
        a timeModification and visually by the
        <notations><tuplet> tag.  This method
        creates the latter.

        Returns a list of them because a
        startStop type tuplet needs two tuplet
        brackets.

        TODO: make sure something happens if
            makeTupletBrackets is not set.

        >>> tup = duration.Tuplet(11, 8)
        >>> tup.type = 'start'
        >>> MEX = musicxml.m21ToXml.MeasureExporter()
        >>> mxTup = MEX.tupletToXmlTuplet(tup)
        >>> len(mxTup)
        1
        >>> MEX.dump(mxTup[0])
        <tuplet bracket="yes" number="1" placement="above" type="start">
          <tuplet-actual>
            <tuplet-number>11</tuplet-number>
          </tuplet-actual>
          <tuplet-normal>
            <tuplet-number>8</tuplet-number>
          </tuplet-normal>
        </tuplet>

        >>> tup.tupletActualShow = 'both'
        >>> tup.tupletNormalShow = 'type'
        >>> mxTup = MEX.tupletToXmlTuplet(tup)
        >>> MEX.dump(mxTup[0])
        <tuplet bracket="yes" number="1" placement="above"
            show-number="actual" show-type="both" type="start">...</tuplet>
        )NFr@   )rj  rZ  Ú	startStopz.Cannot create music XML from a tuplet of type r  rj  rZ  ÚtupletrR  rÅ   rð  Tr°  Nr»  zshow-numberr1  )r®  rÅ   r®  )r®  Úactualr
  )r®  rR  z	show-typeú
line-shapeÚcurvedztuplet-actualztuplet-numberztuplet-typez
tuplet-dotztuplet-normal)rR  r,   r   r-  r2   r°  r*   r+  r»  ÚtupletActualShowÚtupletNormalShowr   rÂ  r&   ÚdurationActualr<   rÚ   rA  rÃ  rÄ  r¼   )r�   r	  ÚtupletIndexÚ	localTypeÚretListÚ
tupletTypeÚmxTupletÚtBracketÚtasÚtnsÚmxTupletActualÚmxTupletNumberÚ
actualTypeÚmxTupletTypeÚunused_counterÚmxTupletNormalÚ
normalTypes                    r;   rS  z!MeasureExporter.tupletToXmlTuplet)  sf  € ðJ Œ;Ð+Ð+Ð+ØˆIàŒ;Ð<Ð<Ð<Ý)Ø@À6Ä;ÑNñPô Pð Pð Œ;˜+Ò%Ð%Ø  &Ð)ˆIˆIàœ˜ˆIàˆà#ð 7	%ñ 7	%ˆJå˜xÑ(Ô(ˆHØ�LŠL˜ Ñ,Ô,Ð,Ø�LŠL˜¥3 {Ñ#3Ô#3Ñ4Ô4Ð4à˜WÒ$Ñ$Ø!œ>�Ø˜vÒ%Ð%Ø#�HØ—’˜YÝ'Ô6°xÑ@Ô@ñBô Bð BàÔ#Ð/Ø—L’L ¨fÔ.>Ñ?Ô?Ð?ØÔ-�ØÔ-�Ø�;Ø—L’L °Ñ7Ô7Ð7Ð7àÐ.Ð.Ð.°3Ð:LÐ3LÐ3LØ—L’L °Ñ7Ô7Ð7Ð7ØÐ.Ð.Ð.Ø—L’L °Ñ9Ô9Ð9àÐ*Ð*Ð*¨sÐ6FÐ/FÐ/FØ—L’L ¨fÑ5Ô5Ð5Ð5ØÐ,Ð,Ð,Ø—L’L ¨hÑ7Ô7Ð7à”> VÒ+Ð+Ø—L’L ¨xÑ8Ô8Ð8õ ",¨H°oÑ!FÔ!F�Ý!+¨N¸OÑ!LÔ!L�Ý&)¨&Ô*BÑ&CÔ&C�Ô#ØÔ(Ð4Ý!3°FÔ4IÔ4NÑ!OÔ!O�JØ!ð 7Ý'1°.À-Ñ'PÔ'P˜Ø,6˜Ô)Ý*/°Ô0EÔ0JÑ*KÔ*Kð Að A˜Ý" >°<Ñ@Ô@Ð@Ð@å!+¨H°oÑ!FÔ!F�Ý!+¨N¸OÑ!LÔ!L�Ý&)¨&Ô*BÑ&CÔ&C�Ô#ØÔ(Ð4Ý!3°FÔ4IÔ4NÑ!OÔ!O�JØ!ð 7Ý'1°.À-Ñ'PÔ'P˜Ø,6˜Ô)Ý*/°Ô0EÔ0JÑ*KÔ*Kð Að A˜Ý" >°<Ñ@Ô@Ð@Ð@à�NŠN˜8Ñ$Ô$Ð$Ñ$Øˆr=   Ú
expressionúexpressions.Expressionc                ó¼  — d}|j         }t          |t          j        ¦  «        rP|j        dk    rt          d¦  «        }n5t          d¦  «        }|j        dk    r|                     d|j        ¦  «         t          |t          j        ¦  «        rgt          |t          j        ¦  «        r'|j	        rt          d¦  «        }n6t          d¦  «        }n&|j	        rt          d	¦  «        }nt          d
¦  «        }|€@t          g d¢¦  «        }|                     ¦   «         D ]\  }}||v rt          |¦  «        } nŒ|€+t                               d|g¦  «         t          d¦  «        S |                      ||¦  «         t          |d¦  «        r"|j        �|                     d|j        ¦  «         t          |t          j        ¦  «        rM|                     dt%          |j        ¦  «        ¦  «         |j        dv r|j        |_        t+          ||¦  «         t          |t          j        ¦  «        r/|                     dd¦  «         t%          |j        ¦  «        |_        |S )aô  
        Convert a music21 Expression (expression or ornament)
        to a musicxml tag;
        return None if no conversion is possible.

        Expressions apply only to the first note of chord.

        >>> invTurn = expressions.InvertedTurn()
        >>> MEX = musicxml.m21ToXml.MeasureExporter()
        >>> mxExpression = MEX.expressionToXml(invTurn)
        >>> MEX.dump(mxExpression)
        <inverted-turn placement="above" />

        >>> invDelayedTurn = expressions.InvertedTurn(delay=1.0)
        >>> invDelayedTurn.placement = 'below'
        >>> MEX = musicxml.m21ToXml.MeasureExporter()
        >>> mxExpression = MEX.expressionToXml(invDelayedTurn)
        >>> MEX.dump(mxExpression)
        <delayed-inverted-turn placement="below" />

        Some special types:

        >>> f = expressions.Fermata()
        >>> MEX = musicxml.m21ToXml.MeasureExporter()
        >>> mxExpression = MEX.expressionToXml(f)
        >>> MEX.dump(mxExpression)
        <fermata type="inverted" />
        >>> f.shape = 'angled'
        >>> mxExpression = MEX.expressionToXml(f)
        >>> MEX.dump(mxExpression)
        <fermata type="inverted">angled</fermata>

        >>> trem = expressions.Tremolo()
        >>> trem.numberOfMarks = 4
        >>> MEX = musicxml.m21ToXml.MeasureExporter()
        >>> mxExpression = MEX.expressionToXml(trem)
        >>> MEX.dump(mxExpression)
        <tremolo type="single">4</tremolo>

        >>> arp = expressions.ArpeggioMark()
        >>> MEX = musicxml.m21ToXml.MeasureExporter()
        >>> mxExpression = MEX.expressionToXml(arp)
        >>> MEX.dump(mxExpression)
        <arpeggiate />
        >>> arp.type = 'down'
        >>> mxExpression = MEX.expressionToXml(arp)
        >>> MEX.dump(mxExpression)
        <arpeggiate direction="down" />

        >>> nonArp = expressions.ArpeggioMark('non-arpeggio')
        >>> MEX = musicxml.m21ToXml.MeasureExporter()
        >>> mxExpression = MEX.expressionToXml(nonArp)
        >>> MEX.dump(mxExpression)
        <non-arpeggiate />
        Nr  r  r  r  r‘  zdelayed-inverted-turnzinverted-turnzdelayed-turnÚturn))rá  z
trill-mark)ÚInvertedMordentzinverted-mordent)ÚMordentÚmordent)ÚShakeÚshake)Ú	SchleiferÚ	schleifer)ÚTremolorö  )ÚFermataÚfermata)rè  úother-ornamentzno musicxml conversion for:r-  r»  rR  )ÚangledÚsquareÚsingle)r˜   r‡   r   rç  rR  r   r-  rÝ  ÚInvertedTurnÚ	isDelayedr   rœ   rç  rš  rI  ra  r»  r+  r2   Úshaper&   rM  r*  rý  )r�   r  Úmxr˜   Úmappingrh  rÆ   s          r;   rÑ  zMeasureExporter.expressionToXml–  sb  € ðp ˆØÔ$ˆõ �j¥+Ô":Ñ;Ô;ð 	9ØŒ .Ò0Ð0ÝÐ-Ñ.Ô.��å˜\Ñ*Ô*�Ø”? hÒ.Ð.Ø—F’F˜;¨
¬Ñ8Ô8Ð8õ �j¥+Ô"2Ñ3Ô3ð 
	)Ý˜*¥kÔ&>Ñ?Ô?ð 	)ØÔ'ð 2Ý Ð!8Ñ9Ô9�B�Bå  Ñ1Ô1�B�BàÔ'ð )Ý  Ñ0Ô0�B�Bå  ™œ�Bàˆ:Ý!ð #ð #ð #ñ ô ˆGð  Ÿš™œð ð ‘��1Ø˜�<�<Ý  ™œ�BØ�Eð  ð ˆ:Ý×#Ò#Ð%BÀJÐ$OÑPÔPÐPÝÐ+Ñ,Ô,Ð,à×Ò˜2˜zÑ*Ô*Ð*å�:˜{Ñ+Ô+ð 	6°
Ô0DÐ0PØ�FŠF�; 
Ô 4Ñ5Ô5Ð5Ý�j¥+Ô"5Ñ6Ô6ð 	+Ø�FŠF�6�3˜zœÑ/Ô/Ñ0Ô0Ð0ØÔÐ#7Ð7Ð7Ø$Ô*�”Ý˜2˜zÑ*Ô*Ð*å�j¥+Ô"5Ñ6Ô6ð 	4Ø�FŠF�6˜8Ñ$Ô$Ð$Ý˜*Ô2Ñ3Ô3ˆBŒGàˆ	r=   ÚarticulationMarkúarticulations.Articulationc                ó€  — d}t           j        D ]&}t          ||¦  «        rt           j        |         } nŒ'|€d}t          |¦  «        }|j        �|                     d|j        ¦  «         |                      ||¦  «         |dk    rCt          j        rt          |t          j
        ¦  «        sJ ‚|                     d|j        ¦  «         |dv r|                      ||¦  «         |dk    r;t          j        rt          |t          j        ¦  «        sJ ‚|j        �|j        |_        |dk    r|j        �|j        |_        |S )a«  
        Returns a class (mxArticulationMark) that represents the
        MusicXML structure of an articulation mark.

        >>> a = articulations.Accent()
        >>> a.placement = 'below'

        >>> MEX = musicxml.m21ToXml.MeasureExporter()
        >>> mxArticulationMark = MEX.articulationToXmlArticulation(a)
        >>> MEX.dump(mxArticulationMark)
        <accent placement="below" />

        >>> a = articulations.Staccatissimo()
        >>> a.placement = 'below'

        >>> mxArticulationMark = MEX.articulationToXmlArticulation(a)
        >>> MEX.dump(mxArticulationMark)
        <staccatissimo placement="below" />

        Articulations can have style attached to them:

        >>> a = articulations.Doit()
        >>> a.style.lineShape = 'curved'
        >>> a.style.lineType = 'dashed'
        >>> a.style.dashLength = 2
        >>> a.style.spaceLength = 1
        >>> a.style.absoluteX = 5
        >>> a.style.absoluteY = 2

        >>> mxArticulationMark = MEX.articulationToXmlArticulation(a)
        >>> MEX.dump(mxArticulationMark)
        <doit dash-length="2" default-x="5" default-y="2"
            line-shape="curved" line-type="dashed" space-length="1" />
        Nzother-articulationr»  zstrong-accentrR  )ÚdoitÚfalloffÚplopÚscoopzbreath-mark)r*   ÚARTICULATION_MARKS_REVr‡   r   r»  r-  rI  rê  rë  r   ÚStrongAccentÚpointDirectionrú  Ú
BreathMarkrl  r&   ÚdisplayText)r�   r6  ÚmusicXMLArticulationNamerv  ÚmxArticulationMarks        r;   rí  z-MeasureExporter.articulationToXmlArticulation  sz  € ðP $(Ð ÝÔ2ð 	ð 	ˆAÝÐ*¨AÑ.Ô.ð Ý+5Ô+LÈQÔ+OÐ(Ø�ðð $Ð+Ø';Ð$å$Ð%=Ñ>Ô>ÐØÔ%Ð1Ø×"Ò" ;Ð0@Ô0JÑKÔKÐKØ×ÒÐ-Ð/?Ñ@Ô@Ð@Ø# Ò6Ð6ÝŒð PÝ!Ð"2µMÔ4NÑOÔOÐOÐOÐOØ×"Ò" 6Ð+;Ô+JÑKÔKÐKØ#Ð'KÐKÐKØ×ÒÐ0Ð2BÑCÔCÐCØ# }Ò4Ð4ÝŒð NÝ!Ð"2µMÔ4LÑMÔMÐMÐMÐMØÔ&Ð2Ø*:Ô*AÐ"Ô'Ø$Ð(<Ò<Ð<Ø$Ô0Ð<Ø&6Ô&BÐÔ#à!Ð!r=   c                ó>   — d}d}|                       ||||¦  «         dS )z¨
        Sets four additional elements for line elements, conforms to entity
        %line-shape, %line-type, %dashed-formatting (dash-length and space-length)
        )r  rº  zdash-lengthzspace-length)Ú	lineShaper¾  Ú
dashLengthÚspaceLengthNri  rB  s        r;   rú  zMeasureExporter.setLineStyleT  s/   € ð
 SˆØIˆØ×Ò ¨)°]ÀHÑMÔMÐMÐMÐMr=   c                óP  — d}t           j        D ]&}t          ||¦  «        rt           j        |         } nŒ'|€d}|dv rd}t          |¦  «        }|j        �|                     d|j        ¦  «         |dk    rnt          j        rt          |t          j	        ¦  «        sJ ‚t          |j        ¦  «        |_        |                     dt          j        |j        ¦  «        ¦  «         |dv r|j        �|j        |_        |dv rat          j        r(t          |t          j	        t          j        f¦  «        sJ ‚|                     d	t          j        |j        ¦  «        ¦  «         |d
k    rAt          j        rt          |t          j        ¦  «        sJ ‚t          |j        ¦  «        |_        |dk    rAt          j        rt          |t          j        ¦  «        sJ ‚t          |j        ¦  «        |_        |dk    r>t          j        rt          |t          j        ¦  «        sJ ‚|                      ||¦  «         |dk    r>t          j        rt          |t          j        ¦  «        sJ ‚|                      ||¦  «         |dk    r|j        �|j        |_        |                      ||¦  «         |S )aÏ  
        Returns a tag that represents the
        MusicXML structure of an articulation mark that is primarily a TechnicalIndication.

        >>> MEX = musicxml.m21ToXml.MeasureExporter()

        >>> a = articulations.UpBow()
        >>> a.placement = 'below'

        >>> mxTechnicalMark = MEX.articulationToXmlTechnical(a)
        >>> MEX.dump(mxTechnicalMark)
        <up-bow placement="below" />

        >>> f = articulations.Fingering(4)
        >>> f.substitution = True
        >>> mxFingering = MEX.articulationToXmlTechnical(f)
        >>> MEX.dump(mxFingering)
        <fingering alternate="no" substitution="yes">4</fingering>

        Technical marks too specific to express in musicxml just get other-technical.

        >>> g = articulations.OrganIndication()
        >>> g.displayText = 'unda maris'
        >>> mxOther = MEX.articulationToXmlTechnical(g)
        >>> MEX.dump(mxOther)
        <other-technical>unda maris</other-technical>

        Same with technical marks not yet supported.
        TODO: support HammerOn, PullOff, Hole, Arrow.

        >>> h = articulations.HammerOn()
        >>> mxOther = MEX.articulationToXmlTechnical(h)
        >>> MEX.dump(mxOther)
        <other-technical />
        Núother-technical)ÚholeÚarrowr»  r¬  Ú	alternate)ÚhandbellrI  )ÚheelÚtoer¬  Úsubstitutionrª  r«  ÚbendÚharmonic)r*   ÚTECHNICAL_MARKS_REVr‡   r   r»  r-  rê  rë  r   ré  r2   ÚfingerNumberr&   r+  rL  rA  ÚOrganIndicationrP  rê  rÅ   ÚFretIndicationÚFretBendÚsetBendÚStringHarmonicÚsetHarmonicrI  )r�   r6  ÚmusicXMLTechnicalNamerv  rð  s        r;   rì  z*MeasureExporter.articulationToXmlTechnicalj  sþ  € ðT !%ÐÝÔ/ð 	ð 	ˆAÝÐ*¨AÑ.Ô.ð Ý(2Ô(FÀqÔ(IÐ%Ø�ðð !Ð(Ø$5Ð!ð !Ð$5Ð5Ð5Ø$5Ð!å!Ð"7Ñ8Ô8ˆØÔ%Ð1Ø×Ò Ð-=Ô-GÑHÔHÐHØ  KÒ/Ð/ÝŒð MÝ!Ð"2µMÔ4KÑLÔLÐLÐLÐLÝ#&Ð'7Ô'DÑ#EÔ#EˆOÔ Ø×Ò Ý *Ô 9Ð:JÔ:TÑ UÔ UñWô Wð Wà!Ð%DÐDÐDØ$Ô0Ð<ð $4Ô#?ˆOÔ Ø Ð$@Ð@Ð@ÝŒð UÝ!Ð"2µ]Ô5LÝ5BÔ5Rð5Tñ Uô Uð Uð Uð Uà×Ò Ý *Ô 9Ð:JÔ:WÑ XÔ XñZô Zð Zà  HÒ,Ð,ÝŒð TÝ!Ð"2µMÔ4RÑSÔSÐSÐSÐSÝ#&Ð'7Ô'>Ñ#?Ô#?ˆOÔ Ø  FÒ*Ð*ÝŒð RÝ!Ð"2µMÔ4PÑQÔQÐQÐQÐQÝ#&Ð'7Ô'>Ñ#?Ô#?ˆOÔ Ø  FÒ*Ð*ÝŒð LÝ!Ð"2µMÔ4JÑKÔKÐKÐKÐKØ�LŠL˜Ð*:Ñ;Ô;Ð;ð ! JÒ.Ð.ÝŒð RÝ!Ð"2µMÔ4PÑQÔQÐQÐQÐQØ×Ò˜_Ð.>Ñ?Ô?Ð?à!Ð%6Ò6Ð6Ø$Ô0Ð<Ø#3Ô#?ˆOÔ à×Ò˜?Ð,<Ñ=Ô=Ð=àÐr=   ÚmxhrQ  úarticulations.FretBendc                ó¶  — t          | d¦  «        }|j        }|�t          |j        ¦  «        |_        |j        rt          | d¦  «         |j        �Vt          | d¦  «        }|j        }t          t          j	        |z  ¦  «        }| 
                    dt          |¦  «        ¦  «         |j        �+t          | d¦  «        }t          |j        ¦  «        |_        dS dS )aµ  
        Sets the bend-alter SubElement and the pre-bend,
        release and with-bar SubElements when present.

        Called from articulationToXmlTechnical

        >>> from xml.etree.ElementTree import Element
        >>> from fractions import Fraction

        >>> MEXclass = musicxml.m21ToXml.MeasureExporter

        >>> a = articulations.FretBend(bendAlter=interval.Interval(2))
        >>> mxh = Element('bend')
        >>> MEXclass.setBend(mxh, a)
        >>> MEXclass.dump(mxh)
        <bend>
          <bend-alter>2</bend-alter>
        </bend>
        >>> mxh = Element('bend')
        >>> a = articulations.FretBend(bendAlter=interval.Interval(2))
        >>> a.preBend = True
        >>> MEXclass.setBend(mxh, a)
        >>> MEXclass.dump(mxh)
        <bend>
          <bend-alter>2</bend-alter>
          <pre-bend />
        </bend>
        >>> mxh = Element('bend')
        >>> a = articulations.FretBend(bendAlter=interval.Interval(-2), release=Fraction(1, 10080))
        >>> MEXclass.setBend(mxh, a)
        >>> MEXclass.dump(mxh)
        <bend>
          <bend-alter>-2</bend-alter>
          <release offset="1" />
        </bend>
        >>> mxh = Element('bend')
        >>> a = articulations.FretBend(bendAlter=interval.Interval(-2), withBar='scoop')
        >>> MEXclass.setBend(mxh, a)
        >>> MEXclass.dump(mxh)
        <bend>
          <bend-alter>-2</bend-alter>
          <with-bar>scoop</with-bar>
        </bend>
        z
bend-alterNzpre-bendÚreleaserì  zwith-bar)r   Ú	bendAlterr2   Ú	semitonesr&   ÚpreBendr_  r  r   rK  r-  ÚwithBar)r\  rQ  ÚbendAlterSubElementrž  ÚreleaseSubElementÚquarterLengthValueÚdivisionsValueÚwithBarSubElements           r;   rX  zMeasureExporter.setBendÒ  sÜ   € õ\ )¨¨lÑ;Ô;ÐØ”ˆØÐÝ'*¨5¬?Ñ';Ô';ÐÔ$ØŒ<ð 	(Ý�s˜JÑ'Ô'Ð'ØŒ<Ð#Ý *¨3°	Ñ :Ô :ÐØ!%¤ÐÝ ¥Ô!=Ð@RÑ!RÑSÔSˆNØ×!Ò! (­C°Ñ,?Ô,?Ñ@Ô@Ð@ØŒ<Ð#Ý *¨3°
Ñ ;Ô ;ÐÝ%(¨¬Ñ%6Ô%6ÐÔ"Ð"Ð"ð $Ð#r=   Úharmúarticulations.StringHarmonicc                óF  — t          |d¦  «        sdS |j        dk    rt          | d¦  «         n|j        dk    rt          | d¦  «         |j        dk    rt          | d¦  «         dS |j        dk    rt          | d¦  «         dS |j        d	k    rt          | d
¦  «         dS dS )a¾  
        Sets the artificial or natural tag (or no tag) and
        zero or one of base-pitch, sounding-pitch, touching-pitch

        Called from articulationToXmlTechnical

        >>> MEXClass = musicxml.m21ToXml.MeasureExporter

        >>> a = articulations.StringHarmonic()
        >>> a.harmonicType = 'artificial'
        >>> a.pitchType = 'sounding'

        >>> from xml.etree.ElementTree import Element
        >>> mxh = Element('harmonic')

        >>> MEXClass.setHarmonic(mxh, a)
        >>> MEXClass.dump(mxh)
        <harmonic>
          <artificial />
          <sounding-pitch />
        </harmonic>

        :class:`~music21.articulations.Harmonic` is probably too general for most uses,
        but if you use it, you get a harmonic tag with no details:

        >>> b = articulations.Harmonic()
        >>> mxh2 = Element('harmonic')
        >>> MEXClass.setHarmonic(mxh2, b)
        >>> MEXClass.dump(mxh2)
        <harmonic />
        ÚharmonicTypeNÚ
artificialÚnaturalr	   z
base-pitchÚsoundingzsounding-pitchÚtouchingztouching-pitch)ra  rl  r   Ú	pitchType)r\  ri  s     r;   rZ  zMeasureExporter.setHarmonic  sÎ   € õD �t˜^Ñ,Ô,ð 	ØˆFàÔ Ò,Ð,Ý�s˜LÑ)Ô)Ð)Ð)ØÔ )Ò+Ð+Ý�s˜IÑ&Ô&Ð&àŒ>˜VÒ#Ð#Ý�s˜LÑ)Ô)Ð)Ð)Ð)ØŒ^˜zÒ)Ð)Ý�sÐ,Ñ-Ô-Ð-Ð-Ð-ØŒ^˜zÒ)Ð)Ý�sÐ,Ñ-Ô-Ð-Ð-Ð-ð *Ð)r=   Úcsúharmony.NoChordc                ó  — |j         du r/t          j        |j        ¬¦  «        }|                      |¦  «        S t          d¦  «        }t          ||¦  «         |                      ||¦  «         |                      ||¦  «         t          |d¦  «        }t          |d¦  «        }d|_
        |                     dd¦  «         t          |d	¦  «        }|j        }|j        d
k    rt          d¦  «        ‚t          |¦  «        |_
        |j        dv rt          d¦  «        ‚|                     d|j        ¦  «         |                      ||¦  «         |                      ||¦  «         | j                             |¦  «         |S )a�  
        Convert a NoChord object to an mxHarmony object (or a rest
        if .writeAsChord = True).

        Expected attributes of the NoChord object:

        >>> nc = harmony.NoChord()
        >>> nc.chordKind
        'none'

        >>> nc.chordKindStr
        'N.C.'

        Other values may not export:

        >>> nc.chordKindStr = ''
        >>> nc.write()
        Traceback (most recent call last):
        music21.musicxml.xmlObjects.MusicXMLExportException:
             In part (None), measure (1): NoChord object's chordKindStr must be non-empty

        >>> nc.chordKind = None
        >>> nc.write()
        Traceback (most recent call last):
        music21.musicxml.xmlObjects.MusicXMLExportException:
             In part (None), measure (1): NoChord object's chordKind must be 'none'

        To realize the NoChord as a rest:

        >>> nc2 = harmony.NoChord()
        >>> nc2.writeAsChord = True
        >>> MEX = musicxml.m21ToXml.MeasureExporter()
        >>> mxNote = MEX.noChordToXml(nc2)
        >>> MEX.dump(mxNote)
        <note>
            <rest />
            <duration>10080</duration>
            <type>quarter</type>
        </note>
        Tr   r   r›  ú	root-stepÚCr&   r@   Úkindr1  z)NoChord object's chordKind must be 'none'r[   z/NoChord object's chordKindStr must be non-empty)r�  r   rà  r   r1  r   rM  rS  rI  r   r&   r-  Ú	chordKindr,   r2   ÚchordKindStrÚsetOffsetOptionalry  rü   r¼   )r�   rr  râ  rÀ  ÚmxRootÚmxStepÚmxKindÚcKinds           r;   r&  zMeasureExporter.noChordToXml@  ss  € ðR Œ?˜dÐ"Ð"Ý”	 2¤;Ð/Ñ/Ô/ˆAØ—>’> !Ñ$Ô$Ð$å˜IÑ&Ô&ˆ	Ý�y "Ñ%Ô%Ð%à×Ò˜I rÑ*Ô*Ð*à×Ò˜9 bÑ)Ô)Ð)å˜I vÑ.Ô.ˆÝ˜F KÑ0Ô0ˆØˆŒØ�
Š
�6˜2ÑÔÐå˜I vÑ.Ô.ˆØ”ˆØŒ<˜6Ò!Ð!Ý)Ð*UÑVÔVÐVÝ˜%‘j”jˆŒØŒ?˜jÐ(Ð(Ý)Ð*[Ñ\Ô\Ð\Ø�
Š
�6˜2œ?Ñ+Ô+Ð+à×Ò˜r 9Ñ-Ô-Ð-Ø×Ò˜) RÑ(Ô(Ð(àŒ×Ò˜IÑ&Ô&Ð&ØÐr=   Úrnúroman.RomanNumeralúElement | list[Element]c                ól  — |j         du r|                      |¦  «        S t          j        |¦  «        }|j        |_        |                      |d¬¦  «        }t          j        rt          |t          ¦  «        sJ ‚| 
                    d¦  «        }|�|                     |¦  «         | 
                    d¦  «        }|�|                     |¦  «         t          d¦  «        }t          |d¦  «        }|                     d	|j        ¦  «         t          |j        ¦  «        |_        |j        rDt          |d
¦  «        }t          |j        j        ¦  «        |_        |                     dd¦  «         |j        �rt          |d¦  «        }	|j        s|	                     dd¦  «         t          |	d¦  «        }
t          |j        j        ¦  «        |
_        t          |	d¦  «        }d}|j        j        dk    rd}n†|j        dvrd}nz|j        dk    r8|                     ¦   «         j        |j        j        j        z
  dz  dk    rd}n:d}n7|                     ¦   «         j        |j        j        j        z
  dz  dk    rd}nd}||_        |                     d|¦  «         | j                             |¦  «         |S )u¼  
        Convert a RomanNumeral object to either a chord (if .writeAsChord is True)
        or a Harmony XML Element.

        >>> rnI = roman.RomanNumeral('I', 'C')
        >>> MEX = musicxml.m21ToXml.MeasureExporter()
        >>> MEX.currentDivisions = 10

        >>> listMxChords = MEX.romanNumeralToXml(rnI)
        >>> len(listMxChords)
        3
        >>> MEX.dump(listMxChords[1])
        <note>
          <chord />
          <pitch>
            <step>E</step>
            <octave>4</octave>
          </pitch>
          <duration>10</duration>
          <type>quarter</type>
        </note>

        If writeAsChord is False, we create a MusicXML 4.0 <numeral> tag.
        This does not work in the current version of MuseScore (which only
        supports MusicXML 3.1) but outputs decently well in Finale.

        >>> rnI.writeAsChord = False
        >>> mxHarmonyFromRN = MEX.romanNumeralToXml(rnI)
        >>> MEX.dump(mxHarmonyFromRN)
        <harmony>
          <numeral>
            <numeral-root text="I">1</numeral-root>
            <numeral-key print-object="no">
              <numeral-fifths>0</numeral-fifths>
              <numeral-mode>major</numeral-mode>
            </numeral-key>
          </numeral>
          <kind>major</kind>
        </harmony>

        >>> complexRn = roman.RomanNumeral('#iio65', 'e-')
        >>> complexRn.followsKeyChange = True
        >>> complexRn.writeAsChord = False
        >>> mxHarmonyFromRN = MEX.romanNumeralToXml(complexRn)
        >>> MEX.dump(mxHarmonyFromRN)
        <harmony>
          <numeral>
            <numeral-root text="#iio65">2</numeral-root>
            <numeral-alter location="left">1.0</numeral-alter>
            <numeral-key>
              <numeral-fifths>-6</numeral-fifths>
              <numeral-mode>minor</numeral-mode>
            </numeral-key>
          </numeral>
          <kind>diminished-seventh</kind>
          <inversion>1</inversion>
        </harmony>

        >>> maj6 = roman.RomanNumeral('VI7', 'd')
        >>> maj6.writeAsChord = False
        >>> mxHarmonyFromRN = MEX.romanNumeralToXml(maj6)
        >>> MEX.dump(mxHarmonyFromRN)
        <harmony>
          <numeral>
            <numeral-root text="VI7">6</numeral-root>
            <numeral-key print-object="no">
              <numeral-fifths>-1</numeral-fifths>
              <numeral-mode>natural minor</numeral-mode>
            </numeral-key>
          </numeral>
          <kind>major-seventh</kind>
        </harmony>

        >>> min6 = roman.RomanNumeral('vi', 'd')
        >>> min6.writeAsChord = False
        >>> mxHarmonyFromRN = MEX.romanNumeralToXml(min6)
        >>> mxHarmonyFromRN.find('.//numeral-mode').text
        'melodic minor'

        >>> dim7 = roman.RomanNumeral('viiÃ¸65', 'd')
        >>> dim7.writeAsChord = False
        >>> mxHarmonyFromRN = MEX.romanNumeralToXml(dim7)
        >>> mxHarmonyFromRN.find('.//numeral-mode').text
        'harmonic minor'
        >>> mxHarmonyFromRN.find('kind').text
        'half-diminished'

        >>> maj7 = roman.RomanNumeral('VII64', 'd')
        >>> maj7.writeAsChord = False
        >>> mxHarmonyFromRN = MEX.romanNumeralToXml(maj7)
        >>> mxHarmonyFromRN.find('.//numeral-mode').text
        'natural minor'
        TF©r¼   r›  NÚbassÚnumeralznumeral-rootr&   znumeral-alterÚlocationrˆ  znumeral-keyrP  rQ  znumeral-fifthsznumeral-moder@   Úmajor)é   é   Úminorrˆ  é   é   znatural minorzmelodic minoré
   zharmonic minorr   )r�  r.  r   ÚchordSymbolFromChordrì  r*  rê  rë  r‡   r   rƒ  r„  r   r-  ÚprimaryFigurer2   ÚscaleDegreer&   ÚfrontAlterationAccidentalrž  r   ÚfollowsKeyChangeÚsharpsÚmoder›  Ú
pitchClassÚtonicr«   rü   r¼   )r�   r  rr  rÀ  r{  ÚmxBassÚ	mxNumeralÚmxNumeralRootÚmxNumeralAlterÚmxNumeralKeyÚmxNumeralFifthsÚmxNumeralModeÚmodeTexts                r;   r,  z!MeasureExporter.romanNumeralToXmlˆ  s§  € ð| Œ?˜dÐ"Ð"Ø—?’? 2Ñ&Ô&Ð&õ
 Ô)¨"Ñ-Ô-ˆØ”IˆŒ	Ø×)Ò)¨"°UÐ)Ñ;Ô;ˆ	ÝŒ?ð 	2å˜i­Ñ1Ô1Ð1Ð1Ð1à—’ Ñ'Ô'ˆØÐà×Ò˜VÑ$Ô$Ð$Ø—’ Ñ'Ô'ˆØÐØ×Ò˜VÑ$Ô$Ð$õ ˜IÑ&Ô&ˆ	Ý" 9¨nÑ=Ô=ˆØ×Ò˜& "Ô"2Ñ3Ô3Ð3Ý  ¤Ñ0Ô0ˆÔØÔ'ð 	3Ý'¨	°?ÑCÔCˆNå"% bÔ&BÔ&HÑ"IÔ"IˆNÔØ×Ò˜z¨6Ñ2Ô2Ð2ØŒ6ñ 	*Ý% i°Ñ?Ô?ˆLØÔ&ð 7Ø× Ò  °Ñ6Ô6Ð6Ý(¨Ð7GÑHÔHˆOÝ#& r¤v¤}Ñ#5Ô#5ˆOÔ Ý& |°^ÑDÔDˆMØˆHØŒvŒ{˜gÒ%Ð%Ø"��Ø” vÐ-Ð-Ø"��Ø” 1Ò$Ð$à—G’G‘I”IÔ(¨2¬6¬<Ô+BÑBÀbÑHÈAÒMÐMØ.�H�Hà.�H�Hà—G’G‘I”IÔ(¨2¬6¬<Ô+BÑBÀbÑHÈBÒNÐNØ.�H�Hà/�HØ!)ˆMÔà×Ò˜˜IÑ&Ô&Ð&ØŒ×Ò˜IÑ&Ô&Ð&ØÐr=   Trƒ  úharmony.ChordSymbolr¼   c               ó¼  — |j         du r|                      |¦  «        S t          d¦  «        }t          ||¦  «         |                      ||¦  «         |j        �|                     d|j        ¦  «         |                      ||¦  «         |                     ¦   «         }|j	        �"t          |d¦  «        }|j        j        |_        n |��t          |d¦  «        }t          |d¦  «        }t          |j        ¦  «        |_        |j        �@t          |d¦  «        }t          t#          j        |j        j        ¦  «        ¦  «        |_        nt(                               d	g¦  «         |S t          |d
¦  «        }	|j        pd}
t.          j        D ]}t.          j        |         |
k    r|}
Œt          |
¦  «        |	_        |j        dvr|	                     d|j        ¦  «         |                     ¦   «         }|dvr$t          |d¦  «        }t          |¦  «        |_        |                     d¬¦  «        p|                     d¬¦  «        }|�’|�|j        |j        k    r€t          |d¦  «        }t          |d¦  «        }t          |j        ¦  «        |_        |j        �@t          |d¦  «        }t          t#          j        |j        j        ¦  «        ¦  «        |_        |                     ¦   «         }|D ] }t          |d¦  «        }t          |d¦  «        }t          |j        ¦  «        |_        t          |d¦  «        }|j        rt          |j        j         j!        ¦  «        nd|_        t          |d¦  «        }t          |j"        ¦  «        |_        Œ¡|  #                    ||¦  «         |  $                    ||¦  «         |r| j%         &                    |¦  «         |S )aV  
        Convert a ChordSymbol object to either a chord (if .writeAsChord is True)
        or a Harmony XML Element.

        >>> cs = harmony.ChordSymbol()
        >>> cs.root('E-')
        >>> cs.bass('B-', allow_add=True)
        >>> cs.inversion(2, transposeOnSet=False)
        >>> cs.chordKind = 'major'
        >>> cs.chordKindStr = 'M'
        >>> cs
        <music21.harmony.ChordSymbol E-/B->

        >>> MEX = musicxml.m21ToXml.MeasureExporter()
        >>> MEX.currentDivisions = 10

        >>> mxHarmony = MEX.chordSymbolToXml(cs)
        >>> MEX.dump(mxHarmony)
        <harmony>
          <root>
            <root-step>E</root-step>
            <root-alter>-1</root-alter>
          </root>
          <kind text="M">major</kind>
          <inversion>2</inversion>
          <bass>
            <bass-step>B</bass-step>
            <bass-alter>-1</bass-alter>
          </bass>
        </harmony>

        Now give function:

        >>> cs.romanNumeral = 'I64'
        >>> mxHarmony = MEX.chordSymbolToXml(cs)
        >>> MEX.dump(mxHarmony)
        <harmony>
          <function>I64</function>
          <kind text="M">major</kind>
          <inversion>2</inversion>
          <bass>
            <bass-step>B</bass-step>
            <bass-alter>-1</bass-alter>
          </bass>
        </harmony>

        >>> hd = harmony.ChordStepModification()
        >>> hd.modType = 'alter'
        >>> hd.interval = -1
        >>> hd.degree = 3
        >>> cs.addChordStepModification(hd)

        >>> mxHarmony = MEX.chordSymbolToXml(cs)
        >>> MEX.dump(mxHarmony)
        <harmony>
          <function>I64</function>
          <kind text="M">major</kind>
          <inversion>2</inversion>
          <bass>
            <bass-step>B</bass-step>
            <bass-alter>-1</bass-alter>
          </bass>
          <degree>
            <degree-value>3</degree-value>
            <degree-alter>-1</degree-alter>
            <degree-type>alter</degree-type>
          </degree>
        </harmony>

        Test altered chords:

        >>> f = harmony.ChordSymbol('F sus add 9')
        >>> f
        <music21.harmony.ChordSymbol F sus add 9>
        >>> mxHarmony = MEX.chordSymbolToXml(f)
        >>> MEX.dump(mxHarmony)
        <harmony>
          <root>
            <root-step>F</root-step>
          </root>
          <kind>suspended-fourth</kind>
          <degree>
            <degree-value>9</degree-value>
            <degree-alter>0</degree-alter>
            <degree-type>add</degree-type>
          </degree>
        </harmony>

        MusicXML uses "dominant" for "dominant-seventh" so check aliases back...

        >>> dom7 = harmony.ChordSymbol('C7')
        >>> dom7.chordKind
        'dominant-seventh'
        >>> mxHarmony = MEX.chordSymbolToXml(dom7)
        >>> MEX.dump(mxHarmony)
        <harmony>
          <root>
            <root-step>C</root-step>
          </root>
          <kind>dominant</kind>
        </harmony>

        set writeAsChord to not get a symbol, but the notes.  Will return a list of notes.

        >>> dom7.writeAsChord = True
        >>> harmonyList = MEX.chordSymbolToXml(dom7)
        >>> len(harmonyList)
        4
        >>> MEX.dump(harmonyList[0])
        <note>
          <pitch>
            <step>C</step>
            <octave>3</octave>
          </pitch>
          <duration>10</duration>
          <type>quarter</type>
        </note>
        Tr   Nr»  Úfunctionr›  ru  z
root-alterz&need either a root or a _roman to showrw  r1  r[   r&   )Nr   Ú	inversionF)rƒ  r„  z	bass-stepz
bass-alterÚdegreezdegree-valuezdegree-alterÚ0zdegree-type)'r�  r.  r   rM  rS  r»  r-  rI  r›  Ú_romanr   ÚromanNumeralÚfigurer&   r2   rŠ  r¤  r   r   rž  rç  rš  rx  r   ÚCHORD_ALIASESry  r¢  r„  rß   ÚgetChordStepModificationsr£  ÚintervalÚ	chromaticÚdirectedÚmodTyperz  ry  rü   r¼   )r�   rr  r¼   rÀ  ÚcsRootÚ
mxFunctionr{  r|  r¡  r}  r~  ÚxmlAliasÚcsInvÚmxInversionÚcsBassr—  ÚcsmÚhdÚmxDegreeÚmxDegreeValueÚmxDegreeAlterÚmxDegreeTypes                         r;   r*  z MeasureExporter.chordSymbolToXml"  s¡  € ðz Œ?˜dÐ"Ð"Ø—?’? 2Ñ&Ô&Ð&å˜IÑ&Ô&ˆ	Ý�y "Ñ%Ô%Ð%à×Ò˜I rÑ*Ô*Ð*àŒ<Ð#Ø�MŠM˜+ r¤|Ñ4Ô4Ð4à×Ò˜9 bÑ)Ô)Ð)à—’‘”ˆàŒ9Ð Ý# I¨zÑ:Ô:ˆJØ œoÔ4ˆJŒOˆOØÐÝ 	¨6Ñ2Ô2ˆFÝ ¨Ñ4Ô4ˆFÝ˜fœkÑ*Ô*ˆFŒKð Ô Ð,Ý$ V¨\Ñ:Ô:�Ý"¥6Ô#9¸&Ô:KÔ:QÑ#RÔ#RÑSÔS�”øõ
 ×#Ò#Ð%MÐ$NÑOÔOÐOØÐå˜I vÑ.Ô.ˆØ”Ð& ˆÝÔ-ð 	!ð 	!ˆHÝÔ$ XÔ.°%Ò7Ð7Ø �øå˜%‘j”jˆŒØŒ? *Ð,Ð,Ø�JŠJ�v˜rœÑ/Ô/Ð/ð —’‘”ˆØ˜	Ð!Ð!Ý$ Y°Ñ<Ô<ˆKÝ" 5™zœzˆKÔð —’˜e�Ñ$Ô$Ð:¨¯ª°T¨Ñ(:Ô(:ˆØÐ 6 >°V´[ÀFÄKÒ5OÐ5Oå 	¨6Ñ2Ô2ˆFÝ ¨Ñ4Ô4ˆFÝ˜fœkÑ*Ô*ˆFŒKð Ô Ð,Ý$ V¨\Ñ:Ô:�Ý"¥6Ô#9¸&Ô:KÔ:QÑ#RÔ#RÑSÔS�”ð
 ×*Ò*Ñ,Ô,ˆØð 	0ð 	0ˆBÝ! )¨XÑ6Ô6ˆHõ ' x°Ñ@Ô@ˆMÝ!$ R¤Y¡¤ˆMÔÝ& x°Ñ@Ô@ˆMàHJÌÐ!\¥ R¤[Ô%:Ô%CÑ!DÔ!DÐ!DÐY\ˆMÔõ & h°Ñ>Ô>ˆLÝ # B¤J¡¤ˆLÔÐð
 	×Ò˜r 9Ñ-Ô-Ð-Ø×Ò˜) RÑ(Ô(Ð(ð ð 	+ØŒL×Ò 	Ñ*Ô*Ð*ØÐr=   ©ÚsetSoundÚm21ObjÚmxObjr»  c               ó  — |j         | j        k    rdS |j         | j        z
  }t          || j        z  ¦  «        }|�t	          |d¦  «        }nt          d¦  «        }t          |¦  «        |_        |r|                     dd¦  «         |S )zÓ
        If this object has an offset different from self.offsetInMeasure,
        then create and return an offset Element.

        If mxObj is not None then the offset element will be appended to it.
        Nrì  Úsoundr¯  )	rì  rQ  r  rL  r   r   r2   r&   r-  )r�   r¼  r½  r»  ÚoffsetDifferenceInQlÚoffsetDifferenceInDivisionsÚmxOffsets          r;   rz  z!MeasureExporter.setOffsetOptional  s•   € ð Œ=˜DÔ0Ò0Ð0Ø�4Ø%œ}¨tÔ/CÑCÐÝ&)Ð*>ÀÔAVÑ*VÑ&WÔ&WÐ#ØÐÝ! %¨Ñ2Ô2ˆHˆHå˜xÑ(Ô(ˆHÝÐ7Ñ8Ô8ˆŒØð 	)Ø�LŠL˜ %Ñ(Ô(Ð(Øˆr=   úbase.Music21Object | Nonec               ó  — t          d¦  «        }t          |d¦  «        }|                     |¦  «         |�Jt          |d¦  «        r"|j        �|                     d|j        ¦  «         |                      |||¬¦  «         |S )zÈ
        Places the mxObj <element> inside <direction><direction-type>
        and sets <offset> if needed.

        * Changed in v8: added `setSound` keyword (see :meth:`setOffsetOptional`).
        r‘  r¼  Nr»  rº  )r   r   r¼   ra  r»  r-  rz  )r�   r½  r¼  r»  rÎ  rÏ  s         r;   ÚplaceInDirectionz MeasureExporter.placeInDirection  s�   € õ ˜kÑ*Ô*ˆÝ$ [Ð2BÑCÔCˆØ×Ò˜uÑ%Ô%Ð%ØÐÝ�v˜{Ñ+Ô+ð ?°Ô0@Ð0LØ—’ ¨VÔ-=Ñ>Ô>Ð>Ø×"Ò" 6¨;ÀÐ"ÑJÔJÐJàÐr=   rÒ   údynamics.Dynamicc                ó<  — t          d¦  «        }t          ||¦  «         |j        t          j        v rt          ||j        ¦  «        }n)t          |d¦  «        }t          |j        ¦  «        |_        |                      ||¦  «         |  	                    ||¦  «        }|  
                    ||¦  «         |j        }|�Et          |d¦  «        }t          |dz  ¦  «        }|                     dt          |¦  «        ¦  «         | j                             |¦  «         |S )a‚  
        return a nested tag:
        <direction><direction-type><dynamic><ff>
        or whatever:

        >>> ppp = dynamics.Dynamic('ppp')
        >>> print(f'{ppp.volumeScalar:.2f}')
        0.15
        >>> ppp.style.relativeY = -10

        >>> MEX = musicxml.m21ToXml.MeasureExporter()
        >>> mxDirection = MEX.dynamicToXml(ppp)
        >>> MEX.dump(mxDirection)
        <direction>
          <direction-type>
            <dynamics default-x="-36" default-y="-80" relative-y="-10">
              <ppp />
            </dynamics>
          </direction-type>
          <sound dynamics="19" />
        </direction>

        appends to score.

        Now with offset not zero.

        >>> MEX = musicxml.m21ToXml.MeasureExporter()
        >>> ppp.offset = 1.0
        >>> mxDirection = MEX.dynamicToXml(ppp)
        >>> MEX.dump(mxDirection)
        <direction>
          <direction-type>
            <dynamics default-x="-36" default-y="-80" relative-y="-10">
              <ppp />
            </dynamics>
          </direction-type>
          <offset sound="yes">10080</offset>
          <sound dynamics="19" />
        </direction>

        r   zother-dynamicsNr¿  é   )r   rM  r1   r*   ÚDYNAMIC_MARKSr   r2   r&   rA  rÅ  ry  ÚvolumeScalarr  r-  rü   r¼   )r�   rÒ   Ú
mxDynamicsÚmxThisDynamicrÎ  ÚvSÚmxSoundÚdynamicVolumes           r;   r2  zMeasureExporter.dynamicToXml2  s  € õV ˜ZÑ(Ô(ˆ
Ý�z 1Ñ%Ô%Ð%ØŒ7•jÔ.Ð.Ð.Ý& z°1´7Ñ;Ô;ˆMˆMå& zÐ3CÑDÔDˆMÝ!$ Q¤W¡¤ˆMÔð 	×Ò 
¨AÑ.Ô.Ð.ð
 ×+Ò+¨J¸Ñ:Ô:ˆà×Ò˜+ qÑ)Ô)Ð)ð
 Œ^ˆØˆ>Ý  ¨gÑ6Ô6ˆGõ    S¡™MœMˆMØ�KŠK˜
¥C¨Ñ$6Ô$6Ñ7Ô7Ð7àŒ×Ò˜KÑ(Ô(Ð(ØÐr=   Úsegnoúrepeat.Segnoc                óÐ   — t          d¦  «        }t          ||¦  «         |                      ||¦  «         |                      ||¦  «        }| j                             |¦  «         |S )aú  
        returns a segno inside a direction-type inside a direction.

        appends to score

        >>> s = repeat.Segno()
        >>> MEX = musicxml.m21ToXml.MeasureExporter()
        >>> mxSegnoDir = MEX.segnoToXml(s)
        >>> MEX.dump(mxSegnoDir)
        <direction>
          <direction-type>
            <segno default-y="20" />
          </direction-type>
        </direction>

        >>> s.id = 'segno0'
        >>> s.style.alignHorizontal = 'left'
        >>> MEX = musicxml.m21ToXml.MeasureExporter()
        >>> mxSegnoDir = MEX.segnoToXml(s)
        >>> MEX.dump(mxSegnoDir)
        <direction>
          <direction-type>
            <segno default-y="20" halign="left" id="segno0" />
          </direction-type>
        </direction>

        rÐ  )r   rM  rA  rÅ  rü   r¼   )r�   rÐ  ÚmxSegnorÎ  s       r;   r4  zMeasureExporter.segnoToXml}  sh   € õ8 ˜'Ñ"Ô"ˆÝ�w Ñ&Ô&Ð&Ø×Ò ¨Ñ/Ô/Ð/Ø×+Ò+¨G°UÑ;Ô;ˆØŒ×Ò˜KÑ(Ô(Ð(ØÐr=   Úcodaúrepeat.Codac                óH  — |j         rgt          d¦  «        }t          ||¦  «         |                      ||¦  «         |                      ||¦  «        }| j                             |¦  «         |S |                     ¦   «         }|j        |_        |  	                    |¦  «        S )a  
        returns a coda inside a direction-type inside a direction IF coda.useSymbol is
        True; otherwise returns a TextExpression and appends to score:

        >>> c = repeat.Coda()
        >>> MEX = musicxml.m21ToXml.MeasureExporter()
        >>> mxCodaDir = MEX.codaToXml(c)
        >>> MEX.dump(mxCodaDir)
        <direction>
          <direction-type>
            <coda default-y="20" />
          </direction-type>
        </direction>

        turn coda.useSymbol to `False` to get a text expression instead,
        and set enclosure to NO_ENCLOSURE to explicitly generate
        enclosure="none".

        >>> c.useSymbol = False
        >>> c.style.enclosure = style.Enclosure.NO_ENCLOSURE
        >>> MEX = musicxml.m21ToXml.MeasureExporter()
        >>> mxCodaText = MEX.codaToXml(c)
        >>> MEX.dump(mxCodaText)
        <direction>
          <direction-type>
            <words default-y="20" enclosure="none"
                justify="center">Coda</words>
          </direction-type>
        </direction>
        rÔ  )
Ú	useSymbolr   rM  rA  rÅ  rü   r¼   ÚgetTextExpressionrì  r<  )r�   rÔ  ÚmxCodarÎ  ÚcodaTes        r;   r6  zMeasureExporter.codaToXml   sž   € ð> Œ>ð 
	4Ý˜V‘_”_ˆFÝ˜6 4Ñ(Ô(Ð(Ø×#Ò# F¨DÑ1Ô1Ð1Ø×/Ò/°¸Ñ=Ô=ˆKØŒL×Ò Ñ,Ô,Ð,ØÐà×+Ò+Ñ-Ô-ˆFØ œKˆFŒMØ×+Ò+¨FÑ3Ô3Ð3r=   Útiútempo.TempoIndicationc                óˆ  — g }g }d}g }d}t          |t          j        ¦  «        r5|                     ¦   «         }|j        |_        |                      |¦  «        S t          |t          j        ¦  «        rq|j        s|j        €d}nI| 	                    |j
        ¦  «         | 	                    |j        ¦  «         | 	                    d¦  «         |                     ¦   «         pd}n‘t          |t          j        ¦  «        rwd}|j        |j        fD ]K}| 	                    d¦  «         | 	                    |j
        ¦  «         | 	                    |j        ¦  «         ŒL|j                             ¦   «         pd}t          d¦  «        }	t!          |	|¦  «         t#          |¦  «        D ]Á\  }
}t          d¦  «        }t%          |j        ¦  «        |_        |	 	                    |¦  «         t+          |j        ¦  «        D ]$}|	 	                    t          d¦  «        ¦  «         Œ%|rD||
         s<t/          |	d¦  «        }t1          t3          j        |d	         ¦  «        ¦  «        |_        ŒÂt7          |d
¦  «        r|j        r|	                     d
d¦  «         n|	                     d
d¦  «         |r|                      |	|¦  «        }n5t          d¦  «        }t!          ||¦  «         |                      ||¦  «        }|rEt/          |d¦  «        }|                     dt1          t3          j        |¦  «        ¦  «        ¦  «         |�| j         	                    |¦  «         t          |t          j        ¦  «        rM|                     d¬¦  «        �7|                     d¬¦  «        }|j        |_        |                      |¦  «        }|S )a  
        returns a <direction> tag for a single tempo indication.

        note that **two** direction tags may be added to xmlroot, the second one
        as a textExpression, but only the first will be returned.

        >>> mm = tempo.MetronomeMark('slow', 40, note.Note(type='half'))
        >>> mm.style.justify = 'left'

        >>> MEX = musicxml.m21ToXml.MeasureExporter()
        >>> mxDirection = MEX.tempoIndicationToXml(mm)
        >>> MEX.dump(mxDirection)
        <direction>
          <direction-type>
            <metronome parentheses="no">
              <beat-unit>half</beat-unit>
              <per-minute>40</per-minute>
            </metronome>
          </direction-type>
          <sound tempo="80" />
        </direction>

        In this case, two directions were added to xmlRoot.  Here is the other one:

        >>> MEX.dump(MEX.xmlRoot.findall('direction')[1])
        <direction>
          <direction-type>
            <words default-y="45" font-weight="bold"
                justify="left">slow</words>
          </direction-type>
        </direction>

        >>> mm = tempo.MetronomeMark('slow', 40, duration.Duration(quarterLength=1.5))
        >>> mxDirection = MEX.tempoIndicationToXml(mm)
        >>> MEX.dump(mxDirection)
        <direction>
          <direction-type>
            <metronome parentheses="no">
              <beat-unit>quarter</beat-unit>
              <beat-unit-dot />
              <per-minute>40</per-minute>
            </metronome>
          </direction-type>
          <sound tempo="60" />
        </direction>

        >>> mmod1 = tempo.MetricModulation()
        >>> mmod1.oldReferent = 0.75  # quarterLength
        >>> mmod1.newReferent = 'quarter'  # type
        >>> mxDirection = MEX.tempoIndicationToXml(mmod1)
        >>> MEX.dump(mxDirection)
        <direction>
          <direction-type>
            <metronome parentheses="no">
              <beat-unit>eighth</beat-unit>
              <beat-unit-dot />
              <beat-unit>quarter</beat-unit>
            </metronome>
          </direction-type>
        </direction>

        >>> mmod1.newReferent = 'longa'  # music21 type w/ different musicxml name
        >>> mxDirection = MEX.tempoIndicationToXml(mmod1)
        >>> MEX.dump(mxDirection)
        <direction>
          <direction-type>
            <metronome parentheses="no">
              <beat-unit>eighth</beat-unit>
              <beat-unit-dot />
              <beat-unit>long</beat-unit>
            </metronome>
          </direction-type>
        </direction>

        This is the case where only a sound tag is added and no metronome mark

        >>> mm = tempo.MetronomeMark()
        >>> mm.numberSounding = 60

        >>> MEX = musicxml.m21ToXml.MeasureExporter()
        >>> mxDirection = MEX.tempoIndicationToXml(mm)
        >>> MEX.dump(mxDirection)
        <direction>
          <direction-type>
            <words />
          </direction-type>
          <sound tempo="60" />
        </direction>

        This is the case of a TempoText.

        >>> tt = tempo.TempoText('Andante')
        >>> mxDirection = MEX.tempoIndicationToXml(tt)
        >>> MEX.dump(mxDirection)
        <direction>
          <direction-type>
            <words default-y="45" font-weight="bold">Andante</words>
          </direction-type>
        </direction>

        Fr’   NTÚ	metronomez	beat-unitzbeat-unit-dotz
per-minuter   r­  r¯  rQ  Úwordsr¿  r%   )ÚreturnImplicit) r‡   r%   r7  rØ  rì  r<  r9  ÚnumberImplicitrÅ   r¼   ÚreferentÚgetQuarterBPMr:  ÚoldMetronomeÚnewMetronomer   rM  r  r<   rR  r&   rÚ   rA  r   r2   r   r   ra  r­  r-  rÅ  rü   )r�   rÛ  ÚdursÚnumbersÚhideNumericalMetroÚ
hideNumberÚsoundingQuarterBPMÚteÚsubÚmxMetrorå   rÒ   ÚmxSubrc  ÚmxPerMinuterÎ  ÚmxWordsrÎ  Úunused_mxDirectionTexts                      r;   r8  z$MeasureExporter.tempoIndicationToXmlË  s¹  € ðT ˆØˆØ"ÐØˆ
à Ðõ �b�%œ/Ñ*Ô*ð 	0Ø×%Ò%Ñ'Ô'ˆBØœ	ˆBŒIØ×+Ò+¨BÑ/Ô/Ð/å�b�%Ô-Ñ.Ô.ð 	HàÔ ð ) B¤IÐ$5à%)Ð"Ð"à—’˜BœKÑ(Ô(Ð(Ø—’˜rœyÑ)Ô)Ð)Ø×!Ò! %Ñ(Ô(Ð(ð "$×!1Ò!1Ñ!3Ô!3Ð!:°sÐÐå˜�EÔ2Ñ3Ô3ð 		Hð "'ÐØœ¨¬Ð9ð +ð +�Ø×!Ò! $Ñ'Ô'Ð'Ø—’˜CœLÑ)Ô)Ð)Ø—’˜sœzÑ*Ô*Ð*Ð*à!#¤×!>Ò!>Ñ!@Ô!@Ð!GÀCÐõ ˜+Ñ&Ô&ˆÝ�w Ñ#Ô#Ð#å˜d‘O”Oð 		Kð 		K‰DˆAˆqå˜KÑ(Ô(ˆEÝ+¨A¬FÑ3Ô3ˆEŒJØ�NŠN˜5Ñ!Ô!Ð!Ý%*¨1¬6¡]¤]ð 9ð 9Ð!Ø—’�w Ñ7Ô7Ñ8Ô8Ð8Ð8Øð K˜z¨!œ}ð KÝ(¨°,Ñ?Ô?�Ý#&¥vÔ'=¸gÀa¼jÑ'IÔ'IÑ#JÔ#J�Ô øå�2�}Ñ%Ô%ð 	-¨"¬.ð 	-Ø�KŠK˜ uÑ-Ô-Ð-Ð-à�KŠK˜ tÑ,Ô,Ð,ð ð 	=Ø×/Ò/°¸Ñ<Ô<ˆKˆKå˜gÑ&Ô&ˆGÝ˜7 BÑ'Ô'Ð'à×/Ò/°¸Ñ<Ô<ˆKàð 	RÝ  ¨gÑ6Ô6ˆGØ�KŠK˜¥¥VÔ%;Ð<NÑ%OÔ%OÑ!PÔ!PÑQÔQÐQàÐ)ØŒL×Ò Ñ,Ô,Ð,å�b�%Ô-Ñ.Ô.ð 	FØ×#Ò#°5Ð#Ñ9Ô9ÐEØ×)Ò)¸Ð)Ñ?Ô?�ØœI�”	Ø)-×)AÒ)AÀ"Ñ)EÔ)EÐ&àÐr=   Úrmúexpressions.RehearsalMarkc                ó  — t          d¦  «        }|                      ||¦  «         t          |j        ¦  «        |_        |                      ||¦  «        }|                      ||d¦  «         | j                             |¦  «         |S )a  
        Convert a RehearsalMark object to a MusicXML <direction> tag with a <rehearsal> tag
        inside it.

        >>> rm = expressions.RehearsalMark('II')
        >>> rm.style.enclosure = 'square'
        >>> MEX = musicxml.m21ToXml.MeasureExporter()
        >>> mxRehearsal = MEX.rehearsalMarkToXml(rm)
        >>> MEX.dump(mxRehearsal)
        <direction>
          <direction-type>
            <rehearsal enclosure="square" halign="center" valign="middle">II</rehearsal>
            </direction-type>
          </direction>
        Ú	rehearsalr»  )	r   rC  r2   r+  r&   rÅ  r6  rü   r¼   )r�   rò  ÚmxRehearsalrÎ  s       r;   r?  z"MeasureExporter.rehearsalMarkToXmlˆ  s€   € õ" ˜kÑ*Ô*ˆØ×Ò˜{¨BÑ/Ô/Ð/Ý˜rœz™?œ?ˆÔØ×+Ò+¨K¸Ñ<Ô<ˆØ×Ò ¨R°Ñ=Ô=Ð=àŒ×Ò˜KÑ(Ô(Ð(ØÐr=   Úpoúexpressions.PedalObjectc                óþ  — d}|                      ¦   «         }|D ] }t          |t          j        ¦  «        r|} nŒ!|€dS g }t          |t          j        ¦  «        �rð|j        t          j        j        t          j        j        fv r.t          d¦  «        g}|d          
                    dd¦  «         �n)|j        t          j        j        k    ržt          d¦  «        g}|j        t          j        j        k    r|d          
                    dd¦  «         �nÇ|j        t          j        j        k    r|d          
                    dd¦  «         �n�|d          
                    dd¦  «         �nq|j        t          j        j        k    rÅt          d¦  «        t          d¦  «        g}|d          
                    dd	¦  «         |j        t          j        j        k    r|d
          
                    dd¦  «         næ|j        t          j        j        k    r|d
          
                    dd¦  «         n¯|d
          
                    dd¦  «         n’dS t          |t          j        ¦  «        r-t          d¦  «        g}|d          
                    dd¦  «         nIt          |t          j        ¦  «        r-t          d¦  «        g}|d          
                    dd¦  «         ndS |D ]Ÿ}|j        t          j        j        t          j        j        fv r| 
                    dd¦  «         n| 
                    dd¦  «         |                      ||¦  «        }|                      ||d¦  «         | j                             |¦  «         Œ |S )aa  
        Convert a PedalObject object (i.e. PedalBounce, PedalGapStart,
        PedalGapEnds) to a MusicXML <direction> tag with a <pedal> tag
        inside it.  Attributes like pedalForm are stored in the enclosing
        PedalMark spanner.

        >>> pm = expressions.PedalMark()
        >>> po = expressions.PedalBounce()
        >>> pm.addSpannedElements(po)
        >>> pm.pedalForm = expressions.PedalForm.Line
        >>> pm.pedalType = expressions.PedalType.Sustain
        >>> MEX = musicxml.m21ToXml.MeasureExporter()
        >>> mxPedal = MEX.pedalObjectToXml(po)
        >>> MEX.dump(mxPedal)
        <direction>
          <direction-type>
            <pedal line="yes" type="change" />
          </direction-type>
        </direction>

        >>> pm = expressions.PedalMark()
        >>> po = expressions.PedalGapStart()
        >>> pm.addSpannedElements(po)
        >>> pm.pedalForm = expressions.PedalForm.Line
        >>> pm.pedalType = expressions.PedalType.Sustain
        >>> po.placement = 'above'
        >>> MEX = musicxml.m21ToXml.MeasureExporter()
        >>> mxPedal = MEX.pedalObjectToXml(po)
        >>> MEX.dump(mxPedal)
        <direction placement="above">
          <direction-type>
            <pedal line="yes" type="discontinue" />
          </direction-type>
        </direction>

        >>> pm = expressions.PedalMark()
        >>> po = expressions.PedalGapEnd()
        >>> pm.addSpannedElements(po)
        >>> pm.pedalForm = expressions.PedalForm.Line
        >>> pm.pedalType = expressions.PedalType.Sustain
        >>> po.placement = 'below'
        >>> MEX = musicxml.m21ToXml.MeasureExporter()
        >>> mxPedal = MEX.pedalObjectToXml(po)
        >>> MEX.dump(mxPedal)
        <direction placement="below">
          <direction-type>
            <pedal line="yes" type="resume" />
          </direction-type>
        </direction>
        Nr¶  r   rR  Úchangerj  rØ  ÚsustainrZ  rÃ   ÚdiscontinueÚresumer·  r¯  r¸  r»  )ÚgetSpannerSitesr‡   r   r¦  ÚPedalBouncerÁ  rÂ  r¥  rÃ  r   r-  Ú	SymbolAltrÝ  rÞ  ÚSustainrß  ÚSymbolÚPedalGapStartÚPedalGapEndrÅ  r6  rü   r¼   )r�   r÷  ÚpmÚspannersrÿ  ÚmxPedalsÚmxPedalrÎ  s           r;   rA  z MeasureExporter.pedalObjectToXml¢  sM  € ðh *.ˆØ*,×*<Ò*<Ñ*>Ô*>ˆØð 	ð 	ˆBÝ˜"�kÔ3Ñ4Ô4ð Ø�Ø�ðð ˆ:ð �4à"$ˆÝ�b�+Ô1Ñ2Ô2ñ ,	ØŒ|¥Ô 5Ô :½KÔ<QÔ<\Ð]Ð]Ð]õ $ GÑ,Ô,Ð-�Ø˜”—’ ¨Ñ1Ô1Ð1Ñ1Ø”¥Ô!6Ô!@Ò@Ð@å# GÑ,Ô,Ð-�Ø”<¥;Ô#8Ô#@Ò@Ð@Ø˜Q”K—O’O F¨GÑ4Ô4Ð4Ñ4Ø”\¥[Ô%:Ô%DÒDÐDØ˜Q”K—O’O F¨KÑ8Ô8Ð8Ñ8ð ˜Q”K—O’O F¨IÑ6Ô6Ð6Ñ6Ø”¥Ô!6Ô!=Ò=Ð=å# GÑ,Ô,­g°gÑ.>Ô.>Ð?�Ø˜”—’ ¨Ñ/Ô/Ð/Ø”<¥;Ô#8Ô#@Ò@Ð@Ø˜Q”K—O’O F¨GÑ4Ô4Ð4Ð4Ø”\¥[Ô%:Ô%DÒDÐDØ˜Q”K—O’O F¨KÑ8Ô8Ð8Ð8ð ˜Q”K—O’O F¨IÑ6Ô6Ð6Ð6ð �tå˜�KÔ5Ñ6Ô6ð 	Ý Ñ(Ô(Ð)ˆHØ�QŒK�OŠO˜F MÑ2Ô2Ð2Ð2Ý˜�KÔ3Ñ4Ô4ð 	Ý Ñ(Ô(Ð)ˆHØ�QŒK�OŠO˜F HÑ-Ô-Ð-Ð-à�4àð 
	-ð 
	-ˆGØŒ|¥Ô 5Ô :½KÔ<QÔ<\Ð]Ð]Ð]Ø—’˜F EÑ*Ô*Ð*Ð*à—’˜F EÑ*Ô*Ð*ð ×/Ò/°¸Ñ<Ô<ˆKà×#Ò# K°°[ÑAÔAÐAØŒL×Ò Ñ,Ô,Ð,Ð,àÐr=   r  úexpressions.PedalMarkc                óÖ   — t          d¦  «        }|                     dd¦  «         |                     dd¦  «         |                      ||¦  «        }|                      ||d¦  «         |S )Nr¶  rR  rý  r·  r¯  r»  )r   r-  rÅ  r6  )r�   r  r  rÎ  s       r;   rÄ  z&MeasureExporter.makePedalResumeLineXml  sj   € å˜'Ñ"Ô"ˆØ�Š�F˜HÑ%Ô%Ð%Ø�Š�F˜EÑ"Ô"Ð"à×+Ò+¨G°RÑ8Ô8ˆà×Ò ¨R°Ñ=Ô=Ð=ØÐr=   ÚteOrReú4expressions.TextExpression | repeat.RepeatExpressionc                óæ  — t          d¦  «        }t          |t          j        ¦  «        r|}t	          |j        ¦  «        |_        nct          |t          j        ¦  «        r:| 	                    ¦   «         }|j
        |_
        t	          |j        ¦  «        |_        nt          d¦  «        ‚|                      ||¦  «         |                      ||d¬¦  «        }| j                             |¦  «         |S )z”
        Convert a TextExpression or RepeatExpression to a MusicXML mxDirection type.
        returns a musicxml.mxObjects.Direction object
        rß  z3teOrRe must be a TextExpression or RepeatExpressionFrº  )r   r‡   r   r;  r2   r+  r&   r    r=  rØ  rì  r,   rC  rÅ  rü   r¼   )r�   r  rð  rë  rÎ  s        r;   r<  z#MeasureExporter.textExpressionToXml*  sÙ   € õ ˜'Ñ"Ô"ˆå�f�kÔ8Ñ9Ô9ð 	aØˆBÝ˜rœz™?œ?ˆGŒLˆLÝ˜¥Ô 7Ñ8Ô8ð 	aØ×)Ò)Ñ+Ô+ˆBØœˆBŒIÝ˜rœz™?œ?ˆGŒLˆLå)Ð*_Ñ`Ô`Ð`à×Ò˜w¨Ñ+Ô+Ð+à×+Ò+¨G°RÀ%Ð+ÑHÔHˆØŒ×Ò˜KÑ(Ô(Ð(ØÐr=   ÚobjectToWrapÚ
methodToMxút.Callable[[t.Any], Element]c                ó²   — | j         dk    rdS t          d¦  «        } ||¦  «        }|                     |¦  «         | j                             |¦  «         |S )a  
        given a Clef, KeySignature, or TimeSignature which is in .elements and not m.clef,
        etc. insert it in self.xmlRoot as
        part of the current mxAttributes using methodToMx as a wrapper function.

        (or insert into a new mxAttributes if Clef/KeySignature/etc. is not at the beginning
        of the measure and not at the same point as an existing mxAttributes)

        >>> MEX = musicxml.m21ToXml.MeasureExporter()
        >>> MEX.offsetInMeasure = 3.0
        >>> cl = clef.BassClef()
        >>> methodToMx = MEX.clefToXml
        >>> mxAttributes = MEX.wrapObjectInAttributes(cl, methodToMx)
        >>> MEX.dump(mxAttributes)
        <attributes>
          <clef>
            <sign>F</sign>
            <line>4</line>
          </clef>
        </attributes>

        Also puts it in MEX.xmlRoot.

        If offsetInMeasure is 0.0 then nothing is done or returned:

        >>> MEX.offsetInMeasure = 0.0
        >>> nothing = MEX.wrapObjectInAttributes(cl, methodToMx)
        >>> nothing is None
        True
        r’   NÚ
attributes)rQ  r   r¼   rü   )r�   r  r  ÚmxAttributesr½  s        r;   r˜  z&MeasureExporter.wrapObjectInAttributesE  sd   € ðH Ô 3Ò&Ð&Ø�4å˜|Ñ,Ô,ˆà�
˜<Ñ(Ô(ˆØ×Ò˜EÑ"Ô"Ð"àŒ×Ò˜LÑ)Ô)Ð)àÐr=   rø  Ú__eq__ÚattrÚ
comparisonc                óä   — | j         €dS | j         j        €dS |j        €dS | j         j                             |j        ¦  «        }|€dS t	          ||¦  «        } |t	          ||¦  «        ¦  «        S )a4  
        If this measure is part of a subsequent PartStaff in a joinable staff
        group (e.g. the left hand of a keyboard part), then look up the
        corresponding measure by number in the previous PartStaff, retrieve
        the `attr` value there, and compare it to `obj` by `comparison`.
        NF)rü  rÄ  r×  r°   r]   )r�   r{   r  r  Úmaybe_measureÚcomparison_wrappers         r;   Ú _matchesPreviousPartStaffInGroupz0MeasureExporter._matchesPreviousPartStaffInGroupu  s‚   € ð Œ;ÐØ�5ØŒ;Ô/Ð7Ø�5ð
 ÔÐ$Ø�5ØœÔ<×DÒDÀSÔEVÑWÔWˆØÐ Ø�5Ý$ S¨*Ñ5Ô5ÐØ!Ð!¥'¨-¸Ñ">Ô">Ñ?Ô?Ð?r=   Úlyú
note.Lyricc                ód  — t          d¦  «        }|j        s't          ||dd¦  «         t          ||ddd¬¦  «         nŠt          j        r	|j        €J ‚t          |j        ¦  «        D ]`\  }}|j        dk    rŒ|dk    r#t          |d	¦  «        }|j	        r|j	        |_
        t          ||dd¦  «         t          ||ddd¬¦  «         Œa|j        �(|                     d
t          |j        ¦  «        ¦  «         |j        �)|                     dt          |j        ¦  «        ¦  «         n/|j        �(|                     dt          |j        ¦  «        ¦  «         |                      ||dd¦  «         |                      ||¦  «         |                      ||¦  «         |                      ||¦  «         |S )z¾
        Translate a music21 :class:`~music21.note.Lyric` object
        to a <lyric> tag.

        Lyrics have attribute list %justify, %position, %placement, %color, %print-object
        ÚlyricÚsyllabicr&   T)rP   NÚ	compositerÃ   Úelisionrß   rÅ   )r8  r»  )r   ÚisCompositer`   rê  rë  Ú
componentsr  r  r   ÚelisionBeforer&   Ú
identifierr-  r2   rÅ   r6  rS  rN  rL  )r�   r  rs  rå   Ú	componentÚ	mxElisions         r;   rV  zMeasureExporter.lyricToXml”  sÓ  € õ ˜'Ñ"Ô"ˆØŒ~ð 	^Ý$ R¨°*¸jÑIÔIÐIÝ$ R¨°&¸&ÈTÐRÑRÔRÐRÐRõ Œð 1Ø”}Ð0Ð0Ð0å )¨"¬-Ñ 8Ô 8ð 	^ð 	^‘��9ØÔ%¨Ò4Ð4àØ˜’6�6Ý *¨7°IÑ >Ô >�IØ Ô.ð AØ)2Ô)@˜	œÝ(¨°G¸ZÈÑTÔTÐTÝ(¨°G¸VÀVÐX\Ð]Ñ]Ô]Ð]Ð]ð Œ=Ð$Ø�KŠK˜¥ B¤MÑ 2Ô 2Ñ3Ô3Ð3àŒ9Ð Ø�KŠK˜¥# b¤i¡.¤.Ñ1Ô1Ð1Ð1ØŒ]Ð&Ø�KŠK˜¥# b¤mÑ"4Ô"4Ñ5Ô5Ð5à×Ò ¨Ø 8Ø 8ñ	:ô 	:ð 	:ð 	×Ò˜G RÑ(Ô(Ð(à�Š�g˜rÑ"Ô"Ð"Ø×Ò˜ "Ñ%Ô%Ð%Øˆr=   c                ón   — g }|j         D ]*}|                     |                      |¦  «        ¦  «         Œ+|S )aµ  
        Returns a list of <beam> tags
        from a :class:`~music21.beam.Beams` object

        >>> a = beam.Beams()
        >>> a.fill(2, type='start')

        >>> MEX = musicxml.m21ToXml.MeasureExporter()
        >>> mxBeamList = MEX.beamsToXml(a)
        >>> len(mxBeamList)
        2
        >>> for b in mxBeamList:
        ...     MEX.dump(b)
        <beam number="1">begin</beam>
        <beam number="2">begin</beam>
        )Ú	beamsListr¼   Ú	beamToXml)r�   rþ  Ú
mxBeamListÚbeamObjs       r;   rQ  zMeasureExporter.beamsToXmlÆ  sC   € ð$ ˆ
Ø”ð 	7ð 	7ˆGØ×Ò˜dŸnšn¨WÑ5Ô5Ñ6Ô6Ð6Ð6ØÐr=   c                óö  — t          d¦  «        }t          ||¦  «         ddddœ}|j        |v r||j                 |_        na|j        dk    r>|j        dk    rd|_        nC|j        d	k    rd
|_        n0t          d|j        › d�¦  «        ‚t          d|j        › d�¦  «        ‚|                     dt          |j        ¦  «        ¦  «         |  	                    ||¦  «         |  
                    ||dd¦  «         |S )a   
        Returns an ElementTree Element from a :class:`~music21.beam.Beam` object

        >>> a = beam.Beam()
        >>> a.type = 'start'
        >>> a.number = 1

        >>> MEX = musicxml.m21ToXml.MeasureExporter()
        >>> b = MEX.beamToXml(a)
        >>> b
        <Element 'beam' at 0x104f3a728>
        >>> MEX.dump(b)
        <beam number="1">begin</beam>

        >>> a.type = 'continue'
        >>> b = MEX.beamToXml(a)
        >>> MEX.dump(b)
        <beam number="1">continue</beam>

        >>> a.type = 'stop'
        >>> b = MEX.beamToXml(a)
        >>> MEX.dump(b)
        <beam number="1">end</beam>

        >>> a.type = 'partial'
        >>> a.direction = 'left'
        >>> b = MEX.beamToXml(a)
        >>> MEX.dump(b)
        <beam number="1">backward hook</beam>

        >>> a.direction = 'right'
        >>> a.id = 'beam1'
        >>> b = MEX.beamToXml(a)
        >>> MEX.dump(b)
        <beam id="beam1" number="1">forward hook</beam>

        >>> a.direction = None
        >>> b = MEX.beamToXml(a)
        Traceback (most recent call last):
        music21.musicxml.xmlObjects.MusicXMLExportException: partial beam defined
            without a proper direction set (set to None)

        >>> a.type = 'crazy'
        >>> b = MEX.beamToXml(a)
        Traceback (most recent call last):
        music21.musicxml.xmlObjects.MusicXMLExportException: unexpected beam type
            encountered (crazy)
        r¬  Úbeginrý  Úend)rj  rý  rZ  Úpartialrˆ  zbackward hookr‰  zforward hookz<partial beam defined without a proper direction set (set to ú)z"unexpected beam type encountered (rÅ   Úfan)r   rM  rR  r&   r‘  r,   r-  r2   rÅ   rN  r6  )r�   Ú
beamObjectÚmxBeamÚ
beamToTypes       r;   r*  zMeasureExporter.beamToXmlÝ  s7  € õb ˜‘”ˆÝ�v˜zÑ*Ô*Ð*Ø&Ø",Ø#ðð ˆ
ð Œ?˜jÐ(Ð(Ø$ Z¤_Ô5ˆFŒKˆKØŒ_ 	Ò)Ð)ØÔ# vÒ-Ð-Ø-�”�ØÔ%¨Ò0Ð0Ø,�”�å-ð7Ø)Ô3ð7ð 7ð 7ñô ð õ
 *ØG°Z´_ÐGÐGÐGñô ð ð 	�
Š
�8�S Ô!2Ñ3Ô3Ñ4Ô4Ð4ð
 	�Š�f˜jÑ)Ô)Ð)ð 	×Ò ¨
°E¸5ÑAÔAÐAàˆr=   c                óÌ   — | j         }t          |d¦  «        sdS | j        }| j         j        }|€|r|d                              |¦  «        sdS |                      |d¦  «         dS )zb
        Calls self.setBarline for the right side if the measure has a .rightBarline set.
        ÚrightBarlineNr   r‰  )r"   ra  rV  r7  r`  Ú
setBarline)r�   r¿   rV  r7  s       r;   ra  zMeasureExporter.setRightBarline1  s|   € ð ŒKˆÝ�q˜.Ñ)Ô)ð 	ØˆFà”_ˆ
Ø”{Ô/ˆØÐ Ø#ð !Ø+5°a¬=×+?Ò+?ÀÑ+BÔ+Bð !àˆFð �OŠO˜L¨'Ñ2Ô2Ð2Ð2Ð2r=   c                óÂ   — | j         }t          |d¦  «        sdS | j        }|j        }|€|r|d                              |¦  «        sdS |                      |d¦  «         dS )z`
        Calls self.setBarline for the left side if the measure has a .leftBarline set.
        ÚleftBarlineNr   rˆ  )r"   ra  rV  r:  r]  r8  )r�   r¿   rV  r:  s       r;   r_  zMeasureExporter.setLeftBarlineB  sy   € ð ŒKˆÝ�q˜-Ñ(Ô(ð 	ØˆFà”_ˆ
Ø”mˆØÐØ#ð  Ø+5°a¬=×+@Ò+@ÀÑ+CÔ+Cð  àˆFð �OŠO˜K¨Ñ0Ô0Ð0Ð0Ð0r=   c                ó–  — d}|€t          d¦  «        }nTt          |t          j        ¦  «        r%t          d¦  «        }|                      |¦  «        }n|                      |¦  «        }t          ||¦  «         |                     d|¦  «         | j        �r|dk    r(| j        d          	                    | j
        ¦  «        rd}n0|dk    r(| j        d                              | j
        ¦  «        rd}nd	}|r¡t          d
¦  «        }| j        d         j        }t          |d         ¦  «        }|dk    rd	}|dd…         D ]}	|dt          |	¦  «        z   z  }Œ|                     d|¦  «         |                     d|¦  «         |                     |¦  «         |�|                     |¦  «         | j                             |¦  «         |S )zp
        sets either a left or right barline from a
        bar.Barline() object or bar.Repeat() object
        NÚbarliner†  rˆ  r   rj  r‰  rZ  r@   Úendingr¤  rÃ   r`  rÅ   rR  )r   r‡   r
   ÚRepeatÚrepeatToXmlÚbarlineToXmlrM  r-  rV  r]  r"   r`  ÚnumberRanger2   r¼   rü   )
r�   r<  ÚpositionÚmxRepeatÚ	mxBarlineÚ
endingTypeÚmxEndingÚ
numberListÚ	numberStrÚnums
             r;   r8  zMeasureExporter.setBarlineS  sÝ  € ð
 ˆØˆ?Ý 	Ñ*Ô*ˆIˆIå˜'¥3¤:Ñ.Ô.ð 7Ý# IÑ.Ô.�	Ø×+Ò+¨GÑ4Ô4��à ×-Ò-¨gÑ6Ô6�	å�y 'Ñ*Ô*Ð*à�Š�j (Ñ+Ô+Ð+ð Œ?ñ 	+Ø˜6Ò!Ð! d¤o°aÔ&8×&@Ò&@ÀÄÑ&MÔ&MÐ!Ø$�
�
Ø˜WÒ$Ð$¨¬¸Ô);×)BÒ)BÀ4Ä;Ñ)OÔ)OÐ$Ø#�
�
à�
àð +Ý" 8Ñ,Ô,�Ø!œ_¨QÔ/Ô;�
Ý 
¨1¤Ñ.Ô.�	à Ò#Ð#Ø "�IØ% a b bœ>ð 0ð 0�CØ ¥s¨3¡x¤x¡Ñ/�I�IØ—’˜X yÑ1Ô1Ð1Ø—’˜V ZÑ0Ô0Ð0Ø× Ò  Ñ*Ô*Ð*àÐØ×Ò˜XÑ&Ô&Ð&ð 	Œ×Ò˜IÑ&Ô&Ð&ØÐr=   c                óº   — t          d¦  «        }t          |d¦  «        }|                     ¦   «         |_        |j        �|                     d|j        ¦  «         |S )az  
        Translate a music21 bar.Bar object to an mxBar
        while making two substitutions: double -> light-light
        and final -> light-heavy as shown below.

        >>> b = bar.Barline('final')
        >>> MEX = musicxml.m21ToXml.MeasureExporter()
        >>> mxBarline = MEX.barlineToXml(b)
        >>> MEX.dump(mxBarline)
        <barline>
          <bar-style>light-heavy</bar-style>
        </barline>

        >>> b.location = 'right'
        >>> mxBarline = MEX.barlineToXml(b)
        >>> MEX.dump(mxBarline)
        <barline location="right">
          <bar-style>light-heavy</bar-style>
        </barline>
        r<  z	bar-styleNr†  )r   r   ÚmusicXMLBarStyler&   r†  r-  )r�   Ú	barObjectrD  Ú
mxBarStyles       r;   r@  zMeasureExporter.barlineToXmlŠ  sY   € õ, ˜IÑ&Ô&ˆ	Ý 	¨;Ñ7Ô7ˆ
Ø#×4Ò4Ñ6Ô6ˆ
ŒàÔÐ)Ø�MŠM˜* iÔ&8Ñ9Ô9Ð9ØÐr=   c                ó>  — t          d¦  «        }|j        dk    r|                     dd¦  «         n<|j        dk    r|                     dd¦  «         nt          j        d|j        ¦  «        ‚|j        �(|                     d	t          |j        ¦  «        ¦  «         |S )
a§  
        returns a <repeat> tag from a barline object.

        >>> b = bar.Repeat(direction='end')
        >>> MEX = musicxml.m21ToXml.MeasureExporter()
        >>> mxRepeat = MEX.repeatToXml(b)
        >>> MEX.dump(mxRepeat)
        <repeat direction="backward" />

        >>> b.times = 3
        >>> mxRepeat = MEX.repeatToXml(b)
        >>> MEX.dump(mxRepeat)
        <repeat direction="backward" times="3" />
        r    rj  r‘  rl  r/  Úbackwardzcannot handle direction format:NÚtimes)r   r‘  r-  r
   ÚBarExceptionrP  r2   )r�   râ  rC  s      r;   r?  zMeasureExporter.repeatToXml¨  sœ   € õ  ˜8Ñ$Ô$ˆØŒ;˜'Ò!Ð!Ø�LŠL˜ iÑ0Ô0Ð0Ð0ØŒ[˜EÒ!Ð!Ø�LŠL˜ jÑ1Ô1Ð1Ð1õ Ô"Ð#DÀaÄkÑRÔRÐRàŒ7ÐØ�LŠL˜¥# a¤g¡,¤,Ñ/Ô/Ð/ð ˆr=   c                ó(  — | j         }t          d¦  «        }t          j        | _        | j        �| j        | j        j        k    r:t          |d¦  «        }t          | j        ¦  «        |_	        | j        | j        _        |j
        �H|                      |j
        d¦  «        s-|                     |                      |j
        ¦  «        ¦  «         |j        �J|                      |j        dd¬¦  «        s-|                     |                      |j        ¦  «        ¦  «         t!          |                     t$          j        ¦  «        ¦  «        }|r.|                     |                      |d         ¦  «        ¦  «         |j        �-|                     |                      |j        ¦  «        ¦  «         |                     t,          j        ¦  «        }|r0|d         }|                     |                      |¦  «        ¦  «         | j        �-|                     |                      | j        ¦  «        ¦  «         |                      ¦   «         }|�|                     |¦  «         t9          |¦  «        dk    s|j        r| j                             |¦  «         |S )	z¥
        creates an <attributes> tag at the start of the measure.

        We create one for each measure unless it is identical to self.parent.mxAttributes
        r  NÚ	divisionsrø  rã   Ú
ratioEqual)r  r   )r"   r   r   rK  rL  rü  rÎ  r   r2   r&   rø  r  r¼   rC  rã   rD  rç  rÊ   r   ÚSenzaMisuraTimeSignaturer   rB  r   ÚStaffLayoutÚstaffLayoutToXmlStaffDetailsrN  ÚintervalToXmlTransposeÚmeasureStyler  rU  rü   )r�   r¿   r  ÚmxDivisionsÚsmtsÚfoundÚslÚmxMeasureStyles           r;   r^  z6MeasureExporter.setMxAttributesObjectForStartOfMeasureÈ  sd  € ð ŒKˆÝ˜|Ñ,Ô,ˆõ
 !)Ô <ˆÔàŒ;Ð $Ô"7¸4¼;Ô;TÒ"TÐ"TÝ$ \°;Ñ?Ô?ˆKÝ" 4Ô#8Ñ9Ô9ˆKÔØ(,Ô(=ˆDŒKÔ%àŒNÐ&Ø×=Ò=Ø”N Nñô ð 'ð ×Ò × 6Ò 6°q´~Ñ FÔ FÑGÔGÐGØŒOÐ'Ø×=Ò=Ø”O _Àð >ñ ô ð (ð ×Ò × 7Ò 7¸¼Ñ HÔ HÑIÔIÐIÝ�A×(Ò(­Ô)GÑHÔHÑIÔIˆØð 	BØ×Ò × 7Ò 7¸¸Q¼Ñ @Ô @ÑAÔAÐAð
 Œ6ÐØ×Ò §¢¨q¬vÑ 6Ô 6Ñ7Ô7Ð7à×$Ò$¥VÔ%7Ñ8Ô8ˆØð 	GØ�q”ˆBØ×Ò × AÒ AÀ"Ñ EÔ EÑFÔFÐFàÔ%Ð1Ø×Ò × ;Ò ;¸DÔ<VÑ WÔ WÑXÔXÐXð ×*Ò*Ñ,Ô,ˆØÐ%Ø×Ò Ñ/Ô/Ð/åˆ|ÑÔ˜qÒ Ð  LÔ$7Ð ØŒL×Ò Ñ-Ô-Ð-ØÐr=   c                óâ  — | j         }d}d}|                     t          j        ¦  «        }|rœ|d                              d¦  «        }|r|d         }|                     |d         ¦  «        r\t          d¦  «        }|j        r|                     dd¦  «         n|                     dd¦  «         t          |j
        ¦  «        |_        |�$t          d¦  «        }|                     |¦  «         |S )	z˜
        return a <measure-style> Element or None according to the contents of the Stream.

        Currently, only multiple-rest is supported.
        Nr   ÚMultiMeasureRestzmultiple-restzuse-symbolsr¯  rQ  zmeasure-style)r"   rÊ   r   rà  rþ  r]  r   Ú
useSymbolsr-  r2   ÚnumRestsr&   r¼   )r�   r¿   r^  ÚmxMultipleRestÚrestsÚhasMMRÚfirstRestMMRs          r;   rY  zMeasureExporter.measureStyle  s  € ð ŒKˆàˆØˆà×$Ò$¥T¤YÑ/Ô/ˆØð 
	EØ˜1”X×-Ò-Ð.@ÑAÔAˆFØð EØ% aœy�Ø×'Ò'¨¨a¬Ñ1Ô1ð EÝ%,¨_Ñ%=Ô%=�NØ#Ô.ð @Ø&×*Ò*¨=¸%Ñ@Ô@Ð@Ð@à&×*Ò*¨=¸$Ñ?Ô?Ð?Ý*-¨lÔ.CÑ*DÔ*D�NÔ'àÐ%Ý$ _Ñ5Ô5ˆNð ×!Ò! .Ñ1Ô1Ð1àÐr=   c                ó~  — t          d¦  «        }|j        du r|                     dd¦  «         n|                     dd¦  «         t          j        j        }|j        |j        |j        fvr!t          |d¦  «        }|j        j
        |_        |j        �)t          |d¦  «        }t          |j        ¦  «        |_        |S )	aA  
        Convert a :class:`~music21.layout.StaffLayout` object to a
        <staff-details> element.

        >>> MEX = musicxml.m21ToXml.MeasureExporter()
        >>> sl = layout.StaffLayout()
        >>> sl.staffLines = 3  # tenor drums?
        >>> sl.staffType = stream.enums.StaffType.CUE
        >>> sl.hidden = True
        >>> mxDetails = MEX.staffLayoutToXmlStaffDetails(sl)
        >>> MEX.dump(mxDetails)
        <staff-details print-object="no">
              <staff-type>cue</staff-type>
              <staff-lines>3</staff-lines>
        </staff-details>
        zstaff-detailsTrP  rQ  r¯  z
staff-typeNzstaff-lines)r   r   r-  r"   r¸   Ú	StaffTypeÚ	staffTypeÚREGULARÚOTHERr   r1   r&   Ú
staffLinesr2   )r�   r   ÚmxStaffDetailsrh  ÚmxStaffTypeÚmxStaffLiness         r;   rW  z,MeasureExporter.staffLayoutToXmlStaffDetails!  sÀ   € õ, ! Ñ1Ô1ˆØÔ Ð%Ð%Ø×Ò˜~¨tÑ4Ô4Ð4Ð4à×Ò˜~¨uÑ5Ô5Ð5å”LÔ*ˆ	ØÔ ¨Ô):¸I¼OÐ(LÐLÐLÝ$ ^°\ÑBÔBˆKØ*Ô4Ô:ˆKÔØÔ!Ð-Ý% n°mÑDÔDˆLÝ # KÔ$:Ñ ;Ô ;ˆLÔð
 Ðr=   Útsú4meter.TimeSignature | meter.SenzaMisuraTimeSignaturec                óî  — t          d¦  «        }t          ||¦  «         t          |t          j        ¦  «        r%t          |d¦  «        }|j        �|j        |_        |S t          d„ |j         	                    ¦   «         D ¦   «         ¦  «        }|j
        rt          j                             |¦  «        }|D ]M\  }}t          |d¦  «        }t          |¦  «        |_        t          |d¦  «        }t          |¦  «        |_        ŒN|j        r|                     dd¦  «         n&|j        d	k    r|                     d|j        ¦  «         |                      ||¦  «         |                      ||¦  «         |S )
a4  
        Returns a single <time> tag from a meter.TimeSignature object.

        Compound meters are represented as multiple pairs of beat
        and beat-type elements

        >>> MEX = musicxml.m21ToXml.MeasureExporter()
        >>> a = meter.TimeSignature('3/4')
        >>> b = MEX.timeSignatureToXml(a)
        >>> MEX.dump(b)
        <time>
          <beats>3</beats>
          <beat-type>4</beat-type>
        </time>

        >>> a = meter.TimeSignature('3/4+2/4')
        >>> b = MEX.timeSignatureToXml(a)
        >>> MEX.dump(b)
        <time>
          <beats>3</beats>
          <beat-type>4</beat-type>
          <beats>2</beats>
          <beat-type>4</beat-type>
        </time>

        >>> a.setDisplay('5/4')
        >>> b = MEX.timeSignatureToXml(a)
        >>> MEX.dump(b)
        <time>
          <beats>5</beats>
          <beat-type>4</beat-type>
        </time>

        >>> a = meter.TimeSignature('4/4')
        >>> a.symbol = 'common'
        >>> b = MEX.timeSignatureToXml(a)
        >>> MEX.dump(b)
        <time symbol="common">
          <beats>4</beats>
          <beat-type>4</beat-type>
        </time>

        >>> a.symbol = ''
        >>> a.symbolizeDenominator = True
        >>> b = MEX.timeSignatureToXml(a)
        >>> MEX.dump(b)
        <time symbol="note">
          <beats>4</beats>
          <beat-type>4</beat-type>
        </time>

        >>> sm = meter.SenzaMisuraTimeSignature('free')
        >>> b = MEX.timeSignatureToXml(sm)
        >>> MEX.dump(b)
        <time>
          <senza-misura>free</senza-misura>
        </time>
        Útimezsenza-misuraNc              3  ó2   K  — | ]}|j         |j        fV — Œd S rñ   )rJ  rI  )r#  Úmts     r;   r%  z5MeasureExporter.timeSignatureToXml.<locals>.<genexpr>�  s+   è è € Ð\Ð\¸�r”| R¤^Ð4Ð\Ð\Ð\Ð\Ð\Ð\r=   Úbeatsz	beat-typerl  r   r@   )r   rM  r‡   r   rU  r   r&   ÚtupleÚdisplaySequenceÚflattenÚsummedNumeratorÚtoolsÚfractionToSlashMixedr2   ÚsymbolizeDenominatorr-  rl  rA  rS  )	r�   rp  ÚmxTimeÚmxSenzaMisuraÚfListrÔ   rÒ   ÚmxBeatsÚ
mxBeatTypes	            r;   rD  z"MeasureExporter.timeSignatureToXmlJ  so  € õx ˜‘”ˆÝ�v˜rÑ"Ô"Ð"Ý�b�%Ô8Ñ9Ô9ð 	Ý& v¨~Ñ>Ô>ˆMØŒwÐ"Ø%'¤W�Ô"ØˆMõ Ð\Ð\¸rÔ?Q×?YÒ?YÑ?[Ô?[Ð\Ñ\Ô\Ñ\Ô\ˆØÔð 	<õ ”K×4Ò4°UÑ;Ô;ˆEàð 	%ð 	%‰DˆAˆqÝ  ¨Ñ1Ô1ˆGÝ˜q™6œ6ˆGŒLÝ# F¨KÑ8Ô8ˆJÝ! !™fœfˆJŒOˆOð Ô"ð 	,Ø�JŠJ�x Ñ(Ô(Ð(Ð(ØŒY˜"Š_ˆ_Ø�JŠJ�x ¤Ñ+Ô+Ð+ð 	×Ò ¨Ñ+Ô+Ð+Ø×Ò˜F BÑ'Ô'Ð'Øˆr=   c                ó´  — t           }t          d¦  «        }t          ||¦  «         |                      ||¦  «         |j        s4 |||dd¦  «         t          |d¦  «        r|j        � |||dd¦  «         np|j        D ]h} |||dd¦  «         |j        }|€t          j
        d¦  «        }t          |d	¦  «        }t          t          j        |j        ¦  «        ¦  «        |_        Œit#          |j        ¦  «        D ][\  }}|j        �Ot          |d
¦  «        }t          |j        ¦  «        |_        |                     dt          |dz   ¦  «        ¦  «         Œ\|S )a/  
        returns a key tag from a music21
        key.KeySignature or key.Key object

        >>> ks = key.KeySignature(-3)
        >>> ks
        <music21.key.KeySignature of 3 flats>

        >>> MEX = musicxml.m21ToXml.MeasureExporter()
        >>> mxKey = MEX.keySignatureToXml(ks)
        >>> MEX.dump(mxKey)
        <key>
          <fifths>-3</fifths>
        </key>

        >>> ks.mode = 'major'
        >>> mxKey = MEX.keySignatureToXml(ks)
        >>> MEX.dump(mxKey)
        <key>
          <fifths>-3</fifths>
          <mode>major</mode>
        </key>

        >>> ksNonTrad = key.KeySignature(sharps=None)
        >>> ksNonTrad.alteredPitches = ['C#', 'E-4']
        >>> ksNonTrad
        <music21.key.KeySignature of pitches: [C#, E-4]>

        >>> mxKeyNonTrad = MEX.keySignatureToXml(ksNonTrad)
        >>> MEX.dump(mxKeyNonTrad)
        <key>
          <key-step>C</key-step>
          <key-alter>1</key-alter>
          <key-step>E</key-step>
          <key-alter>-1</key-alter>
          <key-octave number="2">4</key-octave>
        </key>
        r   Úfifthsr“  r”  Nzkey-steprŠ  r   z	key-alterz
key-octaverÅ   rÃ   )r`   r   rM  rI  ÚisNonTraditionalra  r”  ÚalteredPitchesr¤  r   Ú
Accidentalr   r2   r   r   rž  r&   r  r‹  r-  )	r�   ÚkeyOrKeySignaturer�  ÚmxKeyr®   r§  r¡  rå   ÚmxKeyOctaves	            r;   rC  z!MeasureExporter.keySignatureToXml¬  sy  € õP (ˆÝ˜‘”ˆÝ�uÐ/Ñ0Ô0Ð0à×Ò˜5Ð"3Ñ4Ô4Ð4ð !Ô1ð 	Dð ˆDÐ" E¨8°XÑ>Ô>Ð>ÝÐ(¨&Ñ1Ô1ð ?Ð6GÔ6LÐ6XØ�Ð&¨¨v°vÑ>Ô>Ð>øð 'Ô5ð Dð D�Ø��Q˜˜z¨6Ñ2Ô2Ð2Ø”L�Ø�9ÝÔ(¨Ñ+Ô+�AÝ$ U¨KÑ8Ô8�Ý"¥6Ô#9¸!¼'Ñ#BÔ#BÑCÔC�”�õ Ð/Ô>Ñ?Ô?ð 	6ð 	6‰DˆAˆqØŒxÐ#Ý(¨°Ñ=Ô=�Ý#& q¤x¡=¤=�Ô Ø—’ ­#¨a°!©e©*¬*Ñ5Ô5Ð5øàˆr=   c                ó,  — t          d¦  «        }t          ||¦  «         |                      ||¦  «         |j        }|€t	          d¦  «         d}t          |d¦  «        }||_        t          ||dd¦  «         |j        dvrt          ||dd	¦  «         |S )
a!  
        Given a music21 Clef object, return a MusicXML clef
        tag.

        >>> gc = clef.GClef()
        >>> gc
        <music21.clef.GClef>
        >>> MEX = musicxml.m21ToXml.MeasureExporter()
        >>> mxc = MEX.clefToXml(gc)
        >>> MEX.dump(mxc)
        <clef>
          <sign>G</sign>
        </clef>

        >>> b = clef.Treble8vbClef()
        >>> b.octaveChange
        -1
        >>> mxc2 = MEX.clefToXml(b)
        >>> MEX.dump(mxc2)
        <clef>
          <sign>G</sign>
          <line>2</line>
          <clef-octave-change>-1</clef-octave-change>
        </clef>

        >>> pc = clef.PercussionClef()
        >>> mxc3 = MEX.clefToXml(pc)
        >>> MEX.dump(mxc3)
        <clef>
          <sign>percussion</sign>
        </clef>

        Clefs without signs get exported as G clefs with a warning

        >>> generic = clef.Clef()
        >>> mxc4 = MEX.clefToXml(generic)
        Clef with no .sign exported; setting as a G clef
        >>> MEX.dump(mxc4)
        <clef>
          <sign>G</sign>
        </clef>
        r   Nz0Clef with no .sign exported; setting as a G clefÚGr¸  r·  ©r   Nzclef-octave-changeÚoctaveChange)	r   rM  rI  r¸  r{  r   r&   r`   rŽ  )r�   ÚclefObjÚmxClefr¸  ÚmxSigns        r;   rB  zMeasureExporter.clefToXmlõ  sª   € õV ˜‘”ˆÝ�v˜wÑ'Ô'Ð'à×Ò˜6 7Ñ+Ô+Ð+ð Œ|ˆØˆ<ÝÐDÑEÔEÐEØˆDå˜F FÑ+Ô+ˆØˆŒÝ  ¨&°&¸&ÑAÔAÐAØÔ yÐ0Ð0Ý$ W¨fÐ6JÈNÑ[Ô[Ð[àˆr=   c                ó  — |€| j         }|j        j        j        }t	          t          |¦  «        dz
  d¦  «        \  }}t          |j        j        ¦  «        dz  }|dk     r|dz  }|dz  }|dz  }t          d¦  «        }t          ||¦  «         t          |d¦  «        }t          |¦  «        |_        t          |d	¦  «        }t          |¦  «        |_        |dk    r$t          |d
¦  «        }	t          |¦  «        |	_        |S )aU  
        >>> ME = musicxml.m21ToXml.MeasureExporter()
        >>> i = interval.Interval('P5')
        >>> mxTranspose = ME.intervalToXmlTranspose(i)
        >>> ME.dump(mxTranspose)
        <transpose>
          <diatonic>4</diatonic>
          <chromatic>7</chromatic>
        </transpose>

        >>> i = interval.Interval('A13')
        >>> mxTranspose = ME.intervalToXmlTranspose(i)
        >>> ME.dump(mxTranspose)
        <transpose>
          <diatonic>5</diatonic>
          <chromatic>10</chromatic>
          <octave-change>1</octave-change>
        </transpose>

        >>> i = interval.Interval('-M6')
        >>> mxTranspose = ME.intervalToXmlTranspose(i)
        >>> ME.dump(mxTranspose)
        <transpose>
          <diatonic>-5</diatonic>
          <chromatic>-9</chromatic>
        </transpose>

        >>> i = interval.Interval('-M9')
        >>> mxTranspose = ME.intervalToXmlTranspose(i)
        >>> ME.dump(mxTranspose)
        <transpose>
          <diatonic>-1</diatonic>
          <chromatic>-2</chromatic>
          <octave-change>-1</octave-change>
        </transpose>

        NrÃ   r‰  r‹  r   rè  Ú	transposeÚdiatonicr«  zoctave-change)rN  r”  Úgenericr¬  ÚdivmodÚabsr«  ra  r   rM  r   r2   r&   )
r�   rå   ÚgenericStepsÚmusicxmlOctaveShiftÚmusicxmlDiatonicÚmusicxmlChromaticrO  Ú
mxDiatonicÚmxChromaticÚmxOctaveChanges
             r;   rX  z&MeasureExporter.intervalToXmlTranspose6  s  € ðR ˆ9ØÔ*ˆAà”zÔ)Ô2ˆÝ06µs¸<Ñ7HÔ7HÈ1Ñ7LÈaÑ0PÔ0PÑ-ÐÐ-Ý ¤Ô 5Ñ6Ô6¸Ñ;Ðà˜!ÒÐØ Ñ"ÐØ 2Ñ%ÐØ Ñ#Ðå˜kÑ*Ô*ˆÝ�{ AÑ&Ô&Ð&å ¨ZÑ8Ô8ˆ
ÝÐ.Ñ/Ô/ˆ
Œå  ¨kÑ:Ô:ˆÝÐ0Ñ1Ô1ˆÔà !Ò#Ð#Ý'¨°_ÑEÔEˆNÝ"%Ð&9Ñ":Ô":ˆNÔàÐr=   c                óD  — | j         }|                     t          j        ¦  «        }|sdS d}|                     t          j        ¦  «        }|r|d         }|                      |¦  «        }|                     t          j        ¦  «        }|r6|d         }|€|                      |¦  «        }n|                      ||¦  «         |                     t          j        ¦  «        }|r6|d         }|€|  	                    |¦  «        }n|  	                    ||¦  «         |j
        rb|j        j        �V|€t          d¦  «        }t          |d¦  «        }|j        j        |_        |j        j        }|�|                      ||¦  «         |�| j                             |¦  «         dS dS )zU
        Creates a <print> element and appends it to root, if one is needed.
        Nr   r{  zmeasure-numbering)r"   rÊ   r   rE  Ú
PageLayoutr†  ÚSystemLayoutr˜  rV  ÚstaffLayoutToXmlPrintr'  r$   rµ   r   r   r&   ÚmeasureNumberStylerA  rü   r¼   )	r�   r¿   ÚfoundAnyrƒ  r\  Úplr]  ÚmxMeasureNumberingÚmnStyles	            r;   r]  zMeasureExporter.setMxPrintz  s¹  € ð ŒKˆð ×'Ò'­Ô(9Ñ:Ô:ˆØð 	ØˆFàˆØ×+Ò+­FÔ,=Ñ>Ô>ˆØð 	4Ø�q”ˆBØ×/Ò/°Ñ3Ô3ˆGØ×+Ò+­FÔ,?Ñ@Ô@ˆØð 	9Ø�q”ˆBØˆØ×5Ò5°bÑ9Ô9��à×+Ò+¨B°Ñ8Ô8Ð8Ø×+Ò+­FÔ,>Ñ?Ô?ˆØð 	8Ø�q”ˆBØˆØ×4Ò4°RÑ8Ô8��à×*Ò*¨2¨wÑ7Ô7Ð7ð Ô ð 	E Q¤WÔ%=Ð%IØˆÝ! 'Ñ*Ô*�Ý!+¨GÐ5HÑ!IÔ!IÐØ&'¤gÔ&>ÐÔ#Ø”gÔ0ˆGØÐ"Ø×'Ò'Ð(:¸GÑDÔDÐDð ÐØŒL×Ò Ñ(Ô(Ð(Ð(Ð(ð Ðr=   c                óœ   — |€t          d¦  «        }t          ||¦  «         |                      |¦  «        }|                     |¦  «         |S )Nr{  )r   rM  r£  r¼   )r�   r   rƒ  r¢  s       r;   r¢  z%MeasureExporter.staffLayoutToXmlPrint®  sN   € Øˆ?Ý˜gÑ&Ô&ˆGÝ�w Ñ,Ô,Ð,à×8Ò8¸ÑEÔEˆØ�Š�}Ñ%Ô%Ð%Øˆr=   c                ó$  — | j         }t          |d¦  «        r-| j                             d|                     ¦   «         ¦  «         t          || j        ddd„ ¦  «         t          |d¦  «        r |j        �t          || j        dd¦  «         dS dS dS )	z®
        sets the attributes (x=y) for a measure,
        that is, number, implicit, and layoutWidth

        Does not create the <attributes> tag. That's elsewhere.
        ÚmeasureNumberWithSuffixrÅ   ÚimplicitÚ
showNumberc                óV   — t          j        | t          j        j        j        u ¦  «        S rñ   )r*   r+  r"   r¸   Ú
ShowNumberÚNEVER)ÚshowNums    r;   ú<lambda>z1MeasureExporter.setMxAttributes.<locals>.<lambda>Ã  s   € �JÔ5°gÅÄÔAXÔA^Ð6^Ñ_Ô_€ r=   ÚlayoutWidthNÚwidth)r"   ra  rü   r-  rª  r  r²  )r�   r¿   s     r;   r\  zMeasureExporter.setMxAttributes·  s³   € ð ŒKˆÝ�1Ð/Ñ0Ô0ð 	DØŒL×Ò˜X q×'@Ò'@Ñ'BÔ'BÑCÔCÐCÝ!ØˆtŒ|˜Z¨Ø_Ð_ñ	aô 	að 	aõ �1�mÑ$Ô$ð 	O¨¬Ð)BÝ% a¨¬°wÀÑNÔNÐNÐNÐNð	Oð 	OÐ)BÐ)Br=   c                óx   — | j                              | j        ¦  «        }|                     d¦  «        | _        dS )z>
        Makes a set of spanners from repeat brackets
        ÚRepeatBracketN)rÃ  r’  r"   r[  rV  )r�   ÚspannersOnStreams     r;   r[  zMeasureExporter.setRbSpannersÈ  s6   € ð  Ô-×AÒAÀ$Ä+ÑNÔNÐØ*×5Ò5°oÑFÔFˆŒˆˆr=   c                óV  — | j         €dS | j         j        €dS | j        }|                     | j         j        ¦  «        | _        | j         j                             | j        | j        |j        j        z   d¬¦  «        }|sdS |                     ¦   «         }|j	        €dS |j	        | _
        dS )zÈ
        Set the transposition interval based on whether the active
        instrument for this period has a transposition object.

        Stores in self.transpositionInterval.  Returns None
        NF)ÚincludeEndBoundary)rü  r"   ÚgetOffsetBySiterP  rÌ  rË   r   rá   rÍ   ÚtranspositionrN  )r�   r¿   ÚinstSubStreamÚ
instSubObjs       r;   rZ  zMeasureExporter.setTransposeÏ  s¼   € ð Œ;ÐØ�4ØŒ;ÔÐ%Ø�4àŒKˆØ"#×"3Ò"3°D´KÔ4FÑ"GÔ"GˆÔàœÔ4×HÒHØÔ#ØÔ# a¤jÔ&>Ñ>Ø$ð Iñ &ô &ˆð ð 	Ø�4à"×(Ò(Ñ*Ô*ˆ
ØÔ#Ð+Ø�4Ø%/Ô%=ˆÔ"ð ˆtr=   r®  )rG  rH  rü  rI  )rj  r.   )r¿   rx  rd  rX   r3   rú   )r�  r   r!  )r¨  r©  r3   rª  )rÑ  r2   rÿ  rÒ  r3   rÓ  )rå  ræ  r3   r  r�  )r{   r©  rì  r  rX  rí  r3   r£  rñ   )
r{   r©  rì  r  rþ  r£  rÿ  r  r3   rú   )rÔ   r"  )rÔ   rt  rY  r   rW  ru  )râ  r~  )rv  r•  r3   r£  )rš  r›  rò   )r/  r¢  rì  r  rW  r£  r3   r   rÀ  )r3   rY   )r½  r¾  r3   r   )rY  r   rÔ   r"  rW  ru  r3   rú   )rÔ   rt  r3   r   )r×  rØ  r3   r£  )rÔ   r"  rì  r  rW  ru  r3   r£  )rú  rû  )rÃ   )r  r   r3   r   )r6  r7  r3   r   )r6  r7  )r\  r   rQ  r]  r3   rú   )r\  r   ri  rj  r3   rú   )rr  rs  r3   r   )r  r€  r3   r�  )rr  rŸ  r¼   rX   r3   r�  )r¼  r©  r½  rY   r»  rX   r3   rY   )r½  r   r¼  rÃ  r»  rX   r3   r   )rÒ   rÆ  r3   r   )rÐ  rÑ  r3   r   )rÔ  rÕ  r3   r   )rÛ  rÜ  r3   r   )rò  ró  r3   r   )r÷  rø  r3   rY   )r  r	  r3   r   )r  r  r3   r   )r  r©  r  r  r3   rY   )rø  r  )r{   r©  r  r2   r  r2   r3   rX   )r  r  )rp  rq  )Vró   rô   rõ   r   r–  r—  r™  r‚   r‰   r`  rr  rw  rf  r   r„  r‚  r|  r“  rº  r¿  rÀ  rë  r	  r  rù  r$  r?  r1  r.  r=  r;  r0  r¯  r¼  r(  rC  rP  rÊ  rÖ  rä  rR  r>  rî  rS  rÑ  rí  rú  rì  rX  rZ  r&  r,  r*  rz  rÅ  r2  r4  r6  r8  r?  rA  rÄ  r<  r˜  r  rV  rQ  r*  ra  r_  r8  r@  r?  r^  rY  rW  rD  rC  rB  rX  r]  r¢  r\  r[  rZ  rÁ  rÂ  s   @r;   rÖ  rÖ     s�  ø€ € € € € Ø"�{ð	
ð 	
ð 	
ñô Ðð. "- ð	ð 	ð 	ñ"ô "Ðð )¨)Ð4Ðð 48Ø-1ð!6ð !6ð !6ð !6ð !6ð !6ð !6ðFð ð ð(Ið Ið Ið2-ð -ð -ð -ð6-ð -ð -ð -ð< "'ð	@#ð @#ð @#ð @#ð @#ð @#ðJ *8Ô)>ðN ð N ð N ð N ð N ð`ð ð ð ð*^!ð ^!ð ^!ð ^!ð@ ðGð Gð Gñ „\ðGðR ð'ð 'ð 'ñ „\ð'ðR	ð 	ð 	ð 	ð !"Ø:>ð	Xð Xð Xð Xð XðtHð Hð Hð HðT'-ð '-ð '-ð '-ðRfð fð fð fð fðP	%Að %Að %Að %AðNyð yð yð yðvQð Qð Qð Qðfð ð ð ð ð ð ð ð4 01Ø;?ð*ð *ð *ð *ð *ðX$ð $ð $ð $ðL2ð 2ð 2ð 2ðhð ð ð ð"""ð ""ð ""ð ""ðP )-ð	"*ð "*ð "*ð "*ð "*ðH,ð ,ð ,ð ,ð\ð ð ð !ð  !ð  !ð  !ðJ !"Ø(,ð	ð ð ð ð ðBð ð ð ð@Kð Kð Kð KðZkð kð kð kðZwð wð wð wðrC"ð C"ð C"ð C"ðJNð Nð Nð,fð fð fð fðP ð:7ð :7ð :7ñ „\ð:7ðx ð..ð ..ð ..ñ „\ð..ð`Fð Fð Fð FðPXð Xð Xð Xð| ð	_ð _ð _ð _ð _ð _ðF 15ðð ,0ð	ð ð ð ð ð ð6 <@ðð +/ð	ð ð ð ð ð ð,Ið Ið Ið IðV!ð !ð !ð !ðF)4ð )4ð )4ð )4ðV{ð {ð {ð {ðzð ð ð ð4{ð {ð {ð {ðz	ð 	ð 	ð 	ðð ð ð ð6.ð .ð .ð .ðf #Ø"ð	@ð @ð @ð @ð @ð>0ð 0ð 0ð 0ðdð ð ð.Rð Rð Rðh3ð 3ð 3ð"1ð 1ð 1ð"5ð 5ð 5ðnð ð ð<ð ð ð@7ð 7ð 7ðrð ð ð@'ð 'ð 'ðR`ð `ð `ð `ðDGð Gð GðR?ð ?ð ?ðBBð Bð Bð BðH2)ð 2)ð 2)ðhð ð ð ðOð Oð Oð"Gð Gð Gðð ð ð ð ð ð r=   rÖ  Ú__main__)r1   r2   r3   r2   )r>   r2   r3   r2   )rF   rG   r3   rH   rñ   )rQ   rR   rS   r   rT   r2   rU   rV   rO   rW   rP   rX   r3   rY   )Srö   Ú
__future__r   Úcollectionsr   r¬   r™  rD  r  r  Útypingrê  r¦   Úxml.etree.ElementTreer   r   r   rB   Úmusic21r   r	   r
   r   r   r   Úmusic21.common.enumsr   Úmusic21.common.numberToolsr   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r    r!   r"   Úmusic21.stream.iteratorr#   r$   r%   r&   r'   Úmusic21.musicxmlr(   Ú"music21.musicxml.partStaffExporterr)   r*   Úmusic21.musicxml.xmlObjectsr,   r-   ÚEnvironmentrç  ÚsynchronizeIdsToXMLrM  ÚsetXMLAttributeFromAttributer  rë  Úmusic21.common.typesr.   r/   r0   r<   rE   rN   r`   rb   rù   r�   rý  rÖ  ró   ÚmainTestr÷   r=   r;   ú<module>rÎ     sd  ððð ð #Ð "Ð "Ð "Ð "Ð "à #Ð #Ð #Ð #Ð #Ð #Ø €€€Ø €€€Ø Ð Ð Ð Ø 	€	€	€	Ø €€€Ø Ð Ð Ð Ø €€€ðð ð ð ð ð ð ð ð ð ð
 Ð Ð Ð ð "Ð !Ð !Ð !Ð !Ð !Ø Ð Ð Ð Ð Ð Ø Ð Ð Ð Ð Ð Ø Ð Ð Ð Ð Ð Ø Ð Ð Ð Ð Ð Ø Ð Ð Ð Ð Ð Ø /Ð /Ð /Ð /Ð /Ð /Ø -Ð -Ð -Ð -Ð -Ð -Ø Ð Ð Ð Ð Ð Ø Ð Ð Ð Ð Ð Ø Ð Ð Ð Ð Ð Ø Ð Ð Ð Ð Ð Ø  Ð  Ð  Ð  Ð  Ð  Ø Ð Ð Ð Ð Ð Ø Ð Ð Ð Ð Ð Ø Ð Ð Ð Ð Ð Ø Ð Ð Ð Ð Ð Ø Ð Ð Ð Ð Ð Ø Ð Ð Ð Ð Ð Ø Ð Ð Ð Ð Ð Ø Ð Ð Ð Ð Ð Ø Ð Ð Ð Ð Ð Ø Ð Ð Ð Ð Ð Ø Ð Ð Ð Ð Ð Ø Ð Ð Ð Ð Ð Ø Ð Ð Ð Ð Ð Ø 2Ð 2Ð 2Ð 2Ð 2Ð 2Ø Ð Ð Ð Ð Ð Ø Ð Ð Ð Ð Ð Ø Ð Ð Ð Ð Ð Ø Ð Ð Ð Ð Ð à $Ð $Ð $Ð $Ð $Ð $Ø EÐ EÐ EÐ EÐ EÐ EØ 'Ð 'Ð 'Ð 'Ð 'Ð 'Ø ?Ð ?Ð ?Ð ?Ð ?Ð ?Ø 7Ð 7Ð 7Ð 7Ð 7Ð 7à&ˆ{Ô&Ð':Ñ;Ô;€àÔ,€Ø#Ô@Ð ð „?ð "Ø-Ð-Ð-Ð-Ð-Ð-ØÐÐÐÐÐØ!Ð!Ð!Ð!Ð!Ð!ð&ð &ð &ð &ðRð ð ð ð&ð ð ð ðJ #ð	Að 26ØðAð Að Að Að Að AðH\%ð \%ð \%ð \%ð \%ñ \%ô \%ð \%ð~}	@ð }	@ð }	@ð }	@ð }	@ñ }	@ô }	@ð }	@ðDDð Dð Dð Dð D�OÐ%;ñ Dô Dð DðR&\ ð \ ð \ ð \ ð \ �?ñ \ ô \ ð \ ðBkGð kGð kGð kGð kG�oñ kGô kGð kGð`O ˆzÒÐØ€N€N€NØ€GÔÑÔÐÐÐð Ðr=   