
    rh                    \   S r SSKJr  SSKrSSKrSSKrSSKrSSKJr  SSKJ	r	  SSKJ
r
  SSKJr  SSKJr  \
R                  " S	5      r\R                  " S
5      r\R                  " S5      r\R                  " S5      r\R                  " S5      r\R                  " S5      r\R                  " S5      r\R                  " S5      r\R                  " S5      r\R                  " S5      r\R                  " S5      r\R                  " S5      r\R                  " S5      r " S S\	R8                  5      r " S S\	R8                  5      r " S S\	R8                  5      r " S S\R@                  5      r! " S S\!5      r" " S  S!\!5      r# " S" S#\!5      r$ " S$ S%\$5      r% " S& S'\$5      r& " S( S)\$5      r' " S* S+\$5      r( " S, S-\(5      r) " S. S/\(5      r* " S0 S1\$5      r+ " S2 S3\$5      r, " S4 S5\$5      r- " S6 S7\$5      r. " S8 S9\$5      r/ " S: S;\$5      r0 " S< S=\05      r1 " S> S?\05      r2 " S@ SA\05      r3 " SB SC\$5      r4 " SD SE\45      r5 " SF SG\45      r6 " SH SI5      r7 " SJ SK\R@                  5      r8 " SL SM\Rr                  5      r:\;SN:X  a  SSKr\Rx                  " \:5        gg)Oz
Translation routines for roman numeral analysis text files, as defined
and demonstrated by Dmitri Tymoczko, Mark Gotham, Michael Scott Cuthbert,
and Christopher Ariza in ISMIR 2019.
    )annotationsN)common)exceptions21)environment)key)prebasezromanText.rtObjectszm[0-9]+[a-h]*-*[0-9]*[a-h]*z	var[0-9]+zvar([A-Z]+)z\?\([A-Ga-g]+[b#]*:z\?\)[A-Ga-g]+[b#]*:?z[A-Ga-g]+[b#]*;:z[A-Ga-g]+[b#]*:z	KS-?[0-7]zb[1-9.]+z\|\|:z:\|\|z(NC|N.C.|nc)c                      \ rS rSrSrg)RomanTextException6    N__name__
__module____qualname____firstlineno____static_attributes__r       U/home/james-whalen/.local/lib/python3.13/site-packages/music21/romanText/rtObjects.pyr
   r
   6       r   r
   c                      \ rS rSrSrg)RTTokenException:   r   Nr   r   r   r   r   r   :   r   r   r   c                      \ rS rSrSrg)RTHandlerException>   r   Nr   r   r   r   r   r   >   r   r   r   c                      \ rS rSrSrSS jrS rS rS rS r	S r
S	 rS
 rS rS rS rS rS rS rS rS rS rSrg)RTTokenD   a~  
Stores each linear, logical entity of a RomanText.

A multi-pass parsing procedure is likely necessary, as RomanText permits
variety of groupings and markings.

>>> rtt = romanText.rtObjects.RTToken('||:')
>>> rtt
<music21.romanText.rtObjects.RTToken '||:'>

A standard RTToken returns `False` for all the following.

>>> rtt.isComposer() or rtt.isTitle() or rtt.isPiece()
False
>>> rtt.isAnalyst() or rtt.isProofreader()
False
>>> rtt.isTimeSignature() or rtt.isKeySignature() or rtt.isNote()
False
>>> rtt.isForm() or rtt.isPedal() or rtt.isMeasure() or rtt.isWork()
False
>>> rtt.isMovement() or rtt.isVersion() or rtt.isAtom()
False
c                    Xl         SU l        g Nr   )src
lineNumberselfr!   s     r   __init__RTToken.__init__]   s    r   c                ,    [        U R                  5      $ N)reprr!   r$   s    r   _reprInternalRTToken._reprInternala   s    DHH~r   c                    gNFr   r*   s    r   
isComposerRTToken.isComposerd       r   c                    gr.   r   r*   s    r   isTitleRTToken.isTitleg   r1   r   c                    gr.   r   r*   s    r   isPieceRTToken.isPiecej   r1   r   c                    gr.   r   r*   s    r   	isAnalystRTToken.isAnalystm   r1   r   c                    gr.   r   r*   s    r   isProofreaderRTToken.isProofreaderp   r1   r   c                    gr.   r   r*   s    r   isTimeSignatureRTToken.isTimeSignatures   r1   r   c                    gr.   r   r*   s    r   isKeySignatureRTToken.isKeySignaturev   r1   r   c                    gr.   r   r*   s    r   isNoteRTToken.isNotey   r1   r   c                    g)z
Occasionally found in header.
Fr   r*   s    r   isFormRTToken.isForm|   s     r   c                    gr.   r   r*   s    r   	isMeasureRTToken.isMeasure   r1   r   c                    gr.   r   r*   s    r   isPedalRTToken.isPedal   r1   r   c                    gr.   r   r*   s    r   isWorkRTToken.isWork   r1   r   c                    gr.   r   r*   s    r   
isMovementRTToken.isMovement   r1   r   c                    gr.   r   r*   s    r   	isVersionRTToken.isVersion   r1   r   c                    g)zP
Atoms are any untagged data; generally only found inside a
measure definition.
Fr   r*   s    r   isAtomRTToken.isAtom   s    
 r   )r"   r!   N )r   r   r   r   __doc__r%   r+   r/   r3   r6   r9   r<   r?   rB   rE   rH   rK   rN   rQ   rT   rW   rZ   r   r   r   r   r   r   D   s\    0r   r   c                     ^  \ rS rSrSrSU 4S jjrS rS rS rS r	S r
S	 rS
 rS rS rS rS rS rS rS rS rSrU =r$ )RTTagged   a  
In romanText, some data elements are tags, that is a tag name, a colon,
optional whitespace, and data. In non-RTTagged elements, there is just
data.

All tagged tokens are subclasses of this class. Examples are:

    Title: Die Jahrzeiten
    Composer: Fanny Mendelssohn

>>> rtTag = romanText.rtObjects.RTTagged('Title: Die Jahrzeiten')
>>> rtTag.tag
'Title'
>>> rtTag.data
'Die Jahrzeiten'
>>> rtTag.isTitle()
True
>>> rtTag.isComposer()
False
c                   > [         TU ]  U5        SU l        SU l        SU;   aD  UR	                  S5      nUS U R                  5       U l        XS-   S  R                  5       U l        g Xl        g )Nr]   :   )superr%   tagdatafindstrip)r$   r!   iFirst	__class__s      r   r%   RTTagged.__init__   sf    	#:XXc]F7F|))+DHQJK(..0DIIr   c                B    U R                   R                  5       S:X  a  gg)z
True is the tag represents a composer.

>>> rth = romanText.rtObjects.RTTagged('Composer: Claudio Monteverdi')
>>> rth.isComposer()
True
>>> rth.isTitle()
False
>>> rth.isWork()
False
>>> rth.data
'Claudio Monteverdi'
composerTFrf   lowerr*   s    r   r/   RTTagged.isComposer   s     88>>z)r   c                B    U R                   R                  5       S:X  a  gg)z
True if tag represents a title, otherwise False.

>>> tag = romanText.rtObjects.RTTagged('Title: This is a title.')
>>> tag.isTitle()
True

>>> tag = romanText.rtObjects.RTTagged('Nothing: Nothing at all.')
>>> tag.isTitle()
False
titleTFro   r*   s    r   r3   RTTagged.isTitle        88>>w&r   c                B    U R                   R                  5       S:X  a  gg)z
True if tag represents a piece, otherwise False.

>>> tag = romanText.rtObjects.RTTagged('Piece: This is a piece.')
>>> tag.isPiece()
True

>>> tag = romanText.rtObjects.RTTagged('Nothing: Nothing at all.')
>>> tag.isPiece()
False
pieceTFro   r*   s    r   r6   RTTagged.isPiece   ru   r   c                B    U R                   R                  5       S:X  a  gg)z
True if tag represents an analyst, otherwise False.

>>> tag = romanText.rtObjects.RTTagged('Analyst: This is an analyst.')
>>> tag.isAnalyst()
True

>>> tag = romanText.rtObjects.RTTagged('Nothing: Nothing at all.')
>>> tag.isAnalyst()
False
analystTFro   r*   s    r   r9   RTTagged.isAnalyst        88>>y(r   c                B    U R                   R                  5       S;   a  gg)a  
True if tag represents a proofreader, otherwise False.

>>> tag = romanText.rtObjects.RTTagged('Proofreader: This is a proofreader.')
>>> tag.isProofreader()
True

>>> tag = romanText.rtObjects.RTTagged('Nothing: Nothing at all.')
>>> tag.isProofreader()
False
)proofreaderzproof readerTFro   r*   s    r   r<   RTTagged.isProofreader   s     88>>>>r   c                B    U R                   R                  5       S;   a  gg)aV  
True if tag represents a time signature, otherwise False.

>>> tag = romanText.rtObjects.RTTagged('TimeSignature: This is a time signature.')
>>> tag.isTimeSignature()
True

>>> tag = romanText.rtObjects.RTTagged('Nothing: Nothing at all.')
>>> tag.isTimeSignature()
False

TimeSignature header data can be found intermingled with measures.
)timesignatureztime signatureTFro   r*   s    r   r?   RTTagged.isTimeSignature  s     88>>BBr   c                B    U R                   R                  5       S;   a  gg)a  
True if tag represents a key signature, otherwise False.

>>> tag = romanText.rtObjects.RTTagged('KeySignature: This is a key signature.')
>>> tag.isKeySignature()
True
>>> tag.data
'This is a key signature.'

KeySignatures are a type of tagged data found outside of measures,
such as "Key Signature: -1" meaning one flat.

Key signatures are generally numbers representing the number of sharps (or
negative for flats).  Non-standard key signatures are not supported.

>>> tag = romanText.rtObjects.RTTagged('KeySignature: -3')
>>> tag.data
'-3'

music21 supports one legacy key signature type: `KeySignature: Bb` which
represents a one-flat signature.  Important to note: no other key signatures
of this type are supported.  (For instance, `KeySignature: Ab` has no effect)

>>> tag = romanText.rtObjects.RTTagged('KeySignature: Bb')
>>> tag.data
'Bb'

Testing that `.isKeySignature` returns `False` for non-key signatures:

>>> tag = romanText.rtObjects.RTTagged('Nothing: Nothing at all.')
>>> tag.isKeySignature()
False


N.B.: this is not the same as a key definition found inside a
Measure. These are represented by RTKey rtObjects, defined below, and are
not RTTagged rtObjects, but RTAtom subclasses.
)keysignaturezkey signatureTFro   r*   s    r   rB   RTTagged.isKeySignature   s    N 88>>@@r   c                B    U R                   R                  5       S:X  a  gg)z
True if tag represents a note, otherwise False.

>>> tag = romanText.rtObjects.RTTagged('Note: This is a note.')
>>> tag.isNote()
True

>>> tag = romanText.rtObjects.RTTagged('Nothing: Nothing at all.')
>>> tag.isNote()
False
noteTFro   r*   s    r   rE   RTTagged.isNoteL       88>>v%r   c                B    U R                   R                  5       S:X  a  gg)z
True if tag represents a form, otherwise False.

>>> tag = romanText.rtObjects.RTTagged('Form: This is a form.')
>>> tag.isForm()
True

>>> tag = romanText.rtObjects.RTTagged('Nothing: Nothing at all.')
>>> tag.isForm()
False
formTFro   r*   s    r   rH   RTTagged.isForm\  r   r   c                B    U R                   R                  5       S;   a  gg)z
True if tag represents a pedal, otherwise False.

>>> tag = romanText.rtObjects.RTTagged('Pedal: This is a pedal.')
>>> tag.isPedal()
True

>>> tag = romanText.rtObjects.RTTagged('Nothing: Nothing at all.')
>>> tag.isPedal()
False
)pedalTFro   r*   s    r   rN   RTTagged.isPedall  r|   r   c                B    U R                   R                  5       S:X  a  gg)aU  
True if tag defines the version of RomanText standard used,
otherwise False.

Pieces without the tag are defined to conform to RomanText 1.0,
the version described in the ISMIR publication.

>>> rth = romanText.rtObjects.RTTagged('RTVersion: 1.0')
>>> rth.isTitle()
False
>>> rth.isVersion()
True
>>> rth.tag
'RTVersion'
>>> rth.data
'1.0'
	rtversionTFro   r*   s    r   rW   RTTagged.isVersion|  s    $ 88>>{*r   c                B    U R                   R                  5       S;   a  gg)a  
True if tag represents a work, otherwise False.

The "work" is not defined as a header tag, but is used to represent
all tags, often placed after Composer, for the work or pieces designation.

>>> rth = romanText.rtObjects.RTTagged('Work: BWV232')
>>> rth.isWork()
True
>>> rth.tag
'Work'
>>> rth.data
'BWV232'

For historical reasons, the tag 'Madrigal' also designates a work.

>>> rth = romanText.rtObjects.RTTagged('Madrigal: 4.12')
>>> rth.isTitle()
False
>>> rth.isWork()
True
>>> rth.tag
'Madrigal'
>>> rth.data
'4.12'
)workmadrigalTFro   r*   s    r   rQ   RTTagged.isWork  s    6 88>>33r   c                B    U R                   R                  5       S:X  a  gg)z
True if tag represents a movement, otherwise False.

>>> tag = romanText.rtObjects.RTTagged('Movement: This is a movement.')
>>> tag.isMovement()
True

>>> tag = romanText.rtObjects.RTTagged('Nothing: Nothing at all.')
>>> tag.isMovement()
False
movementTFro   r*   s    r   rT   RTTagged.isMovement  s     88>>z)r   c                <    U R                   R                  5       S;   $ )z
True if tag represents a configuration setting for setting vi/vio/VI in minor

>>> tag = romanText.rtObjects.RTTagged('Sixth Minor: Flat')
>>> tag.isSixthMinor()
True
>>> tag.data
'Flat'
)
sixthminorzsixth minorro   r*   s    r   isSixthMinorRTTagged.isSixthMinor  s     xx~~#@@@r   c                <    U R                   R                  5       S;   $ )z
True if tag represents a configuration setting for setting vii/viio/VII in minor

>>> tag = romanText.rtObjects.RTTagged('Seventh Minor: Courtesy')
>>> tag.isSeventhMinor()
True
>>> tag.data
'Courtesy'
)seventhminorzseventh minorro   r*   s    r   isSeventhMinorRTTagged.isSeventhMinor  s     xx~~#DDDr   )rg   rf   r\   )r   r   r   r   r^   r%   r/   r3   r6   r9   r<   r?   rB   rE   rH   rN   rW   rQ   rT   r   r   r   __classcell__rk   s   @r   r`   r`      sb    *$    $*X   .@ 
A
E 
Er   r`   c                  N   ^  \ rS rSrSrS
U 4S jjrS rS rS rS r	S r
S	rU =r$ )	RTMeasurei  a  
In RomanText, measures are given one per line and always start with 'm'.

For instance:

    m4 i b3 v b4 VI
    m5 b2 g: IV b4 V
    m6 i
    m7 D: V

Measure ranges can be used and copied, such as:

    m8-m9=m4-m5

RTMeasure objects can also define variant readings for a measure:

    m1     ii
    m1var1 ii b2 ii6 b3 IV

Variants are not part of the tag, but are read into an attribute.

Endings are indicated by a single letter after the measure number, such as
"a" for first ending.

>>> rtm = romanText.rtObjects.RTMeasure('m15a V6 b1.5 V6/5 b2 I b3 viio6')
>>> rtm.data
'V6 b1.5 V6/5 b2 I b3 viio6'
>>> rtm.number
[15]
>>> rtm.repeatLetter
['a']
>>> rtm.isMeasure()
True


c                   > [         TU ]  U5        SU l        SU l        / U l        / U l        S U l        S U l        SU l        / U l	        U(       a  U R                  U5        g g )Nr]   F)re   r%   rf   rg   numberrepeatLettervariantNumbervariantLetterisCopyDefinitionatoms_parseAttributes)r$   r!   rk   s     r   r%   RTMeasure.__init__  sd    	! " %
!!#& r   c                   SU;   a  UR                  S5      u  p#X#/nOU/n/ n/ nU HX  n[        R                  " U5      u  pUR                  [	        U5      5        U	R                  SS5      n	UR                  U	5        MZ     XV4$ )z
Return the number of numbers as a list, as well as any repeat
indications.

>>> rtm = romanText.rtObjects.RTMeasure()
>>> rtm._getMeasureNumberData('m77')
([77], [''])
>>> rtm._getMeasureNumberData('m123b-432b')
([123, 432], ['b', 'b'])
-mr]   )splitr   getNumFromStrappendintreplace)
r$   r!   mnStartmnEndprocr   r   mnnumStralphaStrs
             r   _getMeasureNumberDataRTMeasure._getMeasureNumberData  s     #: YYs^NG#D5DB%33B7FMM#f+&''R0H)  ##r   c                   [         R                  U5      nUc  [        SU 35      eUR                  5       nUS U R	                  5       nX@l        XS  R	                  5       nU R                  U5      u  U l        U l        [        R                  U5      nUb^  UR                  S5      n[        [        R                  " U5      S   5      U l        XRR                  5       S  R	                  5       U l        OXPl        [         R                  U5      nUb<  UR                  S5      nX`l        XRR                  5       S  R	                  5       U l        U R                  R%                  S5      (       a  SU l        g g )Nzfound no measure tag: r   rd   =T)reMeasureTagmatchr   endri   rf   r   r   r   	reVariantgroupr   r   r   r   rg   reVariantLetterr   
startswithr   )r$   r!   giEndrawTagrawDatavarStrs          r   r   RTMeasure._parseAttributes2  s@   s#9$'=cU%CDDuuwUd!!#e*""$ *.)C)CF)K&T& OOG$=WWQZF!$V%9%9&%A!%D!ED)//1DII!!'*=WWQZF!')//1DI99$$$(D! %r   c                    [        U R                  5      S:X  a  [        U R                  S   5      nU$ U R                  S    SU R                  S    3nU$ )Nrd   r   r   )lenr   str)r$   	numberStrs     r   r+   RTMeasure._reprInternalP  sW    t{{q DKKN+I   ;;q>*!DKKN+;<Ir   c                    gNTr   r*   s    r   rK   RTMeasure.isMeasureW      r   c                x    U R                   R                  SS5      R                  5       nU R                  U5      $ )al  
If this measure defines a copy operation, return two lists defining
the measures to copy; the second list has the repeat data.

>>> rtm = romanText.rtObjects.RTMeasure('m35-36 = m29-30')
>>> rtm.number
[35, 36]
>>> rtm.getCopyTarget()
([29, 30], ['', ''])

>>> rtm = romanText.rtObjects.RTMeasure('m4 = m1')
>>> rtm.number
[4]
>>> rtm.getCopyTarget()
([1], [''])
r   r]   )rg   r   ri   r   )r$   r   s     r   getCopyTargetRTMeasure.getCopyTargetZ  s4    $ ))##C,224))'22r   )r   rg   r   r   r   rf   r   r   r\   )r   r   r   r   r^   r%   r   r   r+   rK   r   r   r   r   s   @r   r   r     s,    #J'&$:)<3 3r   r   c                  6   ^  \ rS rSrSrSU 4S jjrS rSrU =r$ )RTAtomip  aI  
In RomanText, definitions of chords, phrases boundaries, open/close
parenthesis, beat indicators, etc. appear within measures (RTMeasure
objects). These individual elements will be called Atoms, as they are data
that is not tagged.

Each atom store a reference to its container (normally an RTMeasure).

>>> chordIV = romanText.rtObjects.RTAtom('IV')
>>> beat4 = romanText.rtObjects.RTAtom('b4')
>>> beat4
<music21.romanText.rtObjects.RTAtom 'b4'>
>>> beat4.isAtom()
True

However, see RTChord, RTBeat, etc. which are subclasses of RTAtom
specifically for storing chords, beats, etc.
c                0   > [         TU ]  U5        X l        g r(   )re   r%   	containerr$   r!   r   rk   s      r   r%   RTAtom.__init__  s    "r   c                    gr   r   r*   s    r   rZ   RTAtom.isAtom  r   r   r   r]   N)	r   r   r   r   r^   r%   rZ   r   r   r   s   @r   r   r   p  s    &#
 r   r   c                  0   ^  \ rS rSrSrSU 4S jjrSrU =r$ )RTChordi  z
An RTAtom subclass that defines a chord.  Also contains a reference to
the container.

>>> chordIV = romanText.rtObjects.RTChord('IV')
>>> chordIV
<music21.romanText.rtObjects.RTChord 'IV'>
c                @   > [         TU ]  X5        S U l        S U l        g r(   re   r%   offsetquarterLengthr   s      r   r%   RTChord.__init__  !    ( !r   r   r   r   r   r   r   r   r^   r%   r   r   r   s   @r   r   r     s    " "r   r   c                  0   ^  \ rS rSrSrSU 4S jjrSrU =r$ )	RTNoChordi  a  
An RTAtom subclass that defines absence of a chord.  Also contains a
reference to the container.

>>> chordNC = romanText.rtObjects.RTNoChord('NC')
>>> chordNC
<music21.romanText.rtObjects.RTNoChord 'NC'>

>>> rth = romanText.rtObjects.RTHandler()
>>> rth.tokenizeAtoms('nc NC N.C.')
[<music21.romanText.rtObjects.RTNoChord 'nc'>,
 <music21.romanText.rtObjects.RTNoChord 'NC'>,
 <music21.romanText.rtObjects.RTNoChord 'N.C.'>]
c                @   > [         TU ]  X5        S U l        S U l        g r(   r   r   s      r   r%   RTNoChord.__init__  r   r   r   r   r   r   s   @r   r   r     s    " "r   r   c                  $    \ rS rSrSrS rS rSrg)RTBeati  z
An RTAtom subclass that defines a beat definition.  Also contains a
reference to the container.

>>> beatFour = romanText.rtObjects.RTBeat('b4')
>>> beatFour
<music21.romanText.rtObjects.RTBeat 'b4'>
c                   U R                   R                  SS5      nUR                  S5      n[        US   5      n[	        U5      S:  a  [
        R                  " SUS   -   5      nOSn[	        U5      S:  am  [        SUS   -   5      n[        U[        5      (       a  [        R                  R                  U5      nUR                  n[
        R                  " SXe-  -  5      nOSn[	        U5      S	:  a;  [        R                  S
U R                    3/5        [!        SU R                    35      e[
        R                  " X4-   U-   5      nU$ )a  
Gets the beat number as a float or fraction. Time signature independent

>>> RTB = romanText.rtObjects.RTBeat

Simple ones:

>>> RTB('b1').getBeatFloatOrFrac()
1.0
>>> RTB('b2').getBeatFloatOrFrac()
2.0

etc.

with easy float:

>>> RTB('b1.5').getBeatFloatOrFrac()
1.5
>>> RTB('b1.25').getBeatFloatOrFrac()
1.25

with harder:

>>> RTB('b1.33').getBeatFloatOrFrac()
Fraction(4, 3)

>>> RTB('b2.66').getBeatFloatOrFrac()
Fraction(8, 3)

>>> RTB('b1.2').getBeatFloatOrFrac()
Fraction(6, 5)


A third digit of 0.5 adds 1/2 of 1/DENOM of before.  Here DENOM is 3 (in 5/3) so
we add 1/6 to 5/3 to get 11/6:


>>> RTB('b1.66').getBeatFloatOrFrac()
Fraction(5, 3)

>>> RTB('b1.66.5').getBeatFloatOrFrac()
Fraction(11, 6)


Similarly 0.25 adds 1/4 of 1/DENOM, to get 21/12 or 7/4 or 1.75:

>>> RTB('b1.66.25').getBeatFloatOrFrac()
1.75

And 0.75 adds 3/4 of 1/DENOM to get 23/12:

>>> RTB('b1.66.75').getBeatFloatOrFrac()
Fraction(23, 12)

A weird way of writing 'b1.5':

>>> RTB('b1.33.5').getBeatFloatOrFrac()
1.5
br]   .r   rd              g      ?   zgot unexpected beat: zcannot handle specification: )r!   r   r   r   r   r   addFloatPrecisionfloat
isinstance	fractionsFraction
from_floatdenominatoropFracenvironLocal
printDebugr   )	r$   beatStrpartsmainBeatfracPartfracPartDivisordenomfracBeatFracbeats	            r   getBeatFloatOrFracRTBeat.getBeatFloatOrFrac  s    x ((""3+ c"uQx=u:>//eAh?HHu:>#C%(N3O(E**$--88B((E!==u/F)GHLLu:>##'<TXXJ%G$HI"%B488*#MNN}}X0<?@r   c                    U R                  5       n UR                  U5      nU$ ! [        R                   a.    [        R                  SU R                  < SU< 3/5        Sn U$ f = f)ae  
Given a time signature, return the offset position specified by this
beat.

>>> rtb = romanText.rtObjects.RTBeat('b1.5')
>>> rtb.getOffset(meter.TimeSignature('3/4'))
0.5
>>> rtb.getOffset(meter.TimeSignature('6/8'))
0.75
>>> rtb.getOffset(meter.TimeSignature('2/2'))
1.0

>>> rtb = romanText.rtObjects.RTBeat('b2')
>>> rtb.getOffset(meter.TimeSignature('3/4'))
1.0
>>> rtb.getOffset(meter.TimeSignature('6/8'))
1.5

>>> rtb = romanText.rtObjects.RTBeat('b1.66')
>>> rtb.getOffset(meter.TimeSignature('6/8'))
1.0
>>> rtc = romanText.rtObjects.RTBeat('b1.66.5')
>>> rtc.getOffset(meter.TimeSignature('6/8'))
1.25
zbad beat specification: z in a meter of r   )r  getOffsetFromBeatr   TimeSignatureExceptionr  r  r!   )r$   timeSignaturer  posts       r   	getOffsetRTBeat.getOffset  sp    4 &&(	 2248D  22 	##$(HHm&= %> ?D	s   % >A'&A'r   N)r   r   r   r   r^   r  r  r   r   r   r   r   r     s    Tl%r   r   c                  (    \ rS rSrSrSrS rS rSrg)RTKeyTypeAtomiC  a  
RTKeyTypeAtoms contain utility functions for all Key-type tokens, i.e.
RTKey, RTAnalyticKey, but not KeySignature.

>>> gMinor = romanText.rtObjects.RTKeyTypeAtom('g;:')
>>> gMinor
<music21.romanText.rtObjects.RTKeyTypeAtom 'g;:'>
>>> gMinor.getKey()
<music21.key.Key of g minor>
;:c                    U R                   R                  U R                  5      n[        R                  " U5      n[        R
                  " U5      $ )z/
This returns a Key, not a KeySignature object
)r!   rstripfooterStripr   "convertKeyStringToMusic21KeyStringKeyr$   myKeys     r   getKeyRTKeyTypeAtom.getKeyP  s:      0 0166u=wwu~r   c                b    U R                  5       n[        R                  " UR                  5      $ )z
Get a KeySignature object.
)r  r   KeySignaturesharpsr  s     r   getKeySignatureRTKeyTypeAtom.getKeySignatureX  s$     --r   r   N)	r   r   r   r   r^   r  r  r$  r   r   r   r   r  r  C  s    	 K.r   r  c                      \ rS rSrSrSrSrg)RTKeyi`  a  
An RTKey(RTAtom) defines both a change in KeySignature and a change
in the analyzed Key.

They are defined by ";:" after the Key.

>>> gMinor = romanText.rtObjects.RTKey('g;:')
>>> gMinor
<music21.romanText.rtObjects.RTKey 'g;:'>
>>> gMinor.getKey()
<music21.key.Key of g minor>

>>> bMinor = romanText.rtObjects.RTKey('bb;:')
>>> bMinor
<music21.romanText.rtObjects.RTKey 'bb;:'>
>>> bMinor.getKey()
<music21.key.Key of b- minor>
>>> bMinor.getKeySignature()
<music21.key.KeySignature of 5 flats>

>>> eFlatMajor = romanText.rtObjects.RTKey('Eb;:')
>>> eFlatMajor
<music21.romanText.rtObjects.RTKey 'Eb;:'>
>>> eFlatMajor.getKey()
<music21.key.Key of E- major>
r  r   Nr   r   r   r   r^   r  r   r   r   r   r'  r'  `  s    4 Kr   r'  c                      \ rS rSrSrSrSrg)RTAnalyticKeyi~  a  
An RTAnalyticKey(RTKeyTypeAtom) only defines a change in the key
being analyzed.  It does not in itself create a :class:`~music21.key.Key`
object.

>>> gMinor = romanText.rtObjects.RTAnalyticKey('g:')
>>> gMinor
<music21.romanText.rtObjects.RTAnalyticKey 'g:'>
>>> gMinor.getKey()
<music21.key.Key of g minor>

>>> bMinor = romanText.rtObjects.RTAnalyticKey('bb:')
>>> bMinor
<music21.romanText.rtObjects.RTAnalyticKey 'bb:'>
>>> bMinor.getKey()
<music21.key.Key of b- minor>

rc   r   Nr(  r   r   r   r*  r*  ~  s    $ Kr   r*  c                      \ rS rSrSrS rSrg)RTKeySignaturei  a4  
An RTKeySignature(RTAtom) only defines a change in the KeySignature.
It does not in itself create a :class:`~music21.key.Key` object, nor
does it change the analysis taking place.

The number after KS defines the number of sharps (negative for flats).

>>> gMinor = romanText.rtObjects.RTKeySignature('KS-2')
>>> gMinor
<music21.romanText.rtObjects.RTKeySignature 'KS-2'>
>>> gMinor.getKeySignature()
<music21.key.KeySignature of 2 flats>

>>> aMajor = romanText.rtObjects.RTKeySignature('KS3')
>>> aMajor.getKeySignature()
<music21.key.KeySignature of 3 sharps>
c                ^    [        U R                  SS  5      n[        R                  " U5      $ )Nr   )r   r!   r   r"  )r$   	numSharpss     r   r$  RTKeySignature.getKeySignature  s'    %		**r   r   N)r   r   r   r   r^   r$  r   r   r   r   r,  r,    s    $+r   r,  c                  0   ^  \ rS rSrSrSU 4S jjrSrU =r$ )RTOpenParensi  z
A simple open parenthesis Atom with a sensible default

>>> romanText.rtObjects.RTOpenParens('(')
<music21.romanText.rtObjects.RTOpenParens '('>
c                $   > [         TU ]  X5        g r(   re   r%   r   s      r   r%   RTOpenParens.__init__      (r   r   )(Nr   r   s   @r   r1  r1        ) )r   r1  c                  0   ^  \ rS rSrSrSU 4S jjrSrU =r$ )RTCloseParensi  z
A simple close parenthesis Atom with a sensible default

>>> romanText.rtObjects.RTCloseParens(')')
<music21.romanText.rtObjects.RTCloseParens ')'>
c                $   > [         TU ]  X5        g r(   r3  r   s      r   r%   RTCloseParens.__init__  r5  r   r   ))Nr   r   s   @r   r9  r9    r7  r   r9  c                      \ rS rSrSrS rSrg)RTOptionalKeyOpeni  as  
Marks the beginning of an optional Key area which does not
affect the roman numeral analysis.  (For instance, it is
possible to analyze in Bb major, while remaining in g minor)

>>> possibleKey = romanText.rtObjects.RTOptionalKeyOpen('?(Bb:')
>>> possibleKey
<music21.romanText.rtObjects.RTOptionalKeyOpen '?(Bb:'>
>>> possibleKey.getKey()
<music21.key.Key of B- major>
c                   U R                   S:X  a  [        R                  " S5      $ U R                   R                  SS5      nUR                  SS5      nUR                  SS5      nUR                  SS5      n[        R                  " U5      $ )Nz?(b:r   r   rc   r]   ?r6  r!   r   r  r   r$   keyStrs     r   r  RTOptionalKeyOpen.getKey  sp    88v773<XX%%c3/F^^C,F^^C,F^^C,F776?"r   r   Nr   r   r   r   r^   r  r   r   r   r   r>  r>    s    

#r   r>  c                      \ rS rSrSrS rSrg)RTOptionalKeyClosei  am  
Marks the end of an optional Key area which does not affect the roman
numeral analysis.

For example, it is possible to analyze in Bb major, while remaining in g
minor.

>>> possibleKey = romanText.rtObjects.RTOptionalKeyClose('?)Bb:')
>>> possibleKey
<music21.romanText.rtObjects.RTOptionalKeyClose '?)Bb:'>
>>> possibleKey.getKey()
<music21.key.Key of B- major>
c                   U R                   S;   a  [        R                  " S5      $ U R                   R                  SS5      nUR                  SS5      nUR                  SS5      nUR                  SS5      n[        R                  " U5      $ )N)z?)b:z?)br   r   rc   r]   r@  r<  rA  rB  s     r   r  RTOptionalKeyClose.getKey  sp    88&773<XX%%c3/F^^C,F^^C,F^^C,F776?"r   r   NrE  r   r   r   rG  rG    s    
#r   rG  c                      \ rS rSrSrSrg)RTPhraseMarkeri  z
A Phrase Marker:

>>> rtPhraseMarker = romanText.rtObjects.RTPhraseMarker('')
>>> rtPhraseMarker
<music21.romanText.rtObjects.RTPhraseMarker ''>
r   Nr   r   r   r   r^   r   r   r   r   rK  rK    s    r   rK  c                  0   ^  \ rS rSrSrSU 4S jjrSrU =r$ )RTPhraseBoundaryi  zx
>>> phrase = romanText.rtObjects.RTPhraseBoundary('||')
>>> phrase
<music21.romanText.rtObjects.RTPhraseBoundary '||'>
c                $   > [         TU ]  X5        g r(   r3  r   s      r   r%   RTPhraseBoundary.__init__  r5  r   r   )||Nr   r   s   @r   rN  rN        ) )r   rN  c                  0   ^  \ rS rSrSrSU 4S jjrSrU =r$ )RTEllisonStarti  zt
>>> phrase = romanText.rtObjects.RTEllisonStart('|*')
>>> phrase
<music21.romanText.rtObjects.RTEllisonStart '|*'>
c                $   > [         TU ]  X5        g r(   r3  r   s      r   r%   RTEllisonStart.__init__  r5  r   r   )z|*Nr   r   s   @r   rT  rT    rR  r   rT  c                  0   ^  \ rS rSrSrSU 4S jjrSrU =r$ )RTEllisonStopi  zr
>>> phrase = romanText.rtObjects.RTEllisonStop('*|')
>>> phrase
<music21.romanText.rtObjects.RTEllisonStop '*|'>
c                $   > [         TU ]  X5        g r(   r3  r   s      r   r%   RTEllisonStop.__init__!  r5  r   r   )z*|Nr   r   s   @r   rX  rX    rR  r   rX  c                      \ rS rSrSrSrg)RTRepeati%  zj
>>> repeat = romanText.rtObjects.RTRepeat('||:')
>>> repeat
<music21.romanText.rtObjects.RTRepeat '||:'>
r   NrL  r   r   r   r\  r\  %  s    r   r\  c                  0   ^  \ rS rSrSrSU 4S jjrSrU =r$ )RTRepeatStarti-  zr
>>> repeat = romanText.rtObjects.RTRepeatStart()
>>> repeat
<music21.romanText.rtObjects.RTRepeatStart ...'||:'>
c                $   > [         TU ]  X5        g r(   r3  r   s      r   r%   RTRepeatStart.__init__4  r5  r   r   )z||:Nr   r   s   @r   r^  r^  -  rR  r   r^  c                  0   ^  \ rS rSrSrSU 4S jjrSrU =r$ )RTRepeatStopi8  zp
>>> repeat = romanText.rtObjects.RTRepeatStop()
>>> repeat
<music21.romanText.rtObjects.RTRepeatStop ...':||'>
c                $   > [         TU ]  X5        g r(   r3  r   s      r   r%   RTRepeatStop.__init__?  r5  r   r   )z:||Nr   r   s   @r   rb  rb  8  rR  r   rb  c                      \ rS rSrS rS rS rS rSS jrS r	S	 r
SS
 jrS rSS jr\S 5       r\R                   S 5       rS rS rSrg)	RTHandleriE  c                     / U l         SU l        g r    _tokenscurrentLineNumberr*   s    r   r%   RTHandler.__init__H  s     !"r   c                    Sn[        U5       H-  u  p4[        R                  UR                  5       5      c  M+  Un  O   Uc  [	        SU5      eUSU XS 4$ )z
Divide string into header and non-header; this is done before
tokenization.

>>> rth = romanText.rtObjects.RTHandler()
>>> rth.splitAtHeader(['Title: s', 'Time Signature:', '', 'm1 g: i'])
(['Title: s', 'Time Signature:', ''], ['m1 g: i'])
NzKCannot find the first measure definition in this file. Dumping contexts: %s)	enumerater   r   ri   r
   )r$   lines
iStartBodyils        r   splitAtHeaderRTHandler.splitAtHeaderO  so     
e$DA!!!''),8
	 %
 $ &>?DF F[j!5#555r   c                    / n[        U5       HC  u  p4UR                  5       nUS:X  a  M  [        U5      nUS-   Ul        UR	                  U5        ME     [        U5      S-   U l        U$ )z
In the header, we only have :class:`~music21.romanText.base.RTTagged`
tokens. We can this process these all as the same class.
r]   rd   )rm  ri   r`   r"   r   r   rj  )r$   rn  r  rp  linertts         r   tokenizeHeaderRTHandler.tokenizeHeaderd  sf    
  'GA::<Drz4.CUCNKK ( "%Uar   c           
        / nU R                   n[        U5       H  u  pEX4-   n UR                  5       nUS:X  a  M"  [        R	                  U5      b\  [        U5      nXgl        U R                  UR                  US9Ul	        UR                   H	  nXhl        M     UR                  U5        M  [        U5      n	Xil        UR                  U	5        M     U$ ! [         a,    SSKn
U
R                  5       n[        SU< SU< SU< 35      ef = f)zw
In the body, we may have measure, time signature, or note
declarations, as well as possible other tagged definitions.
r]   Nr   r   zAt line z (z) an exception was raised: 
)rj  rm  ri   r   r   r   r"   tokenizeAtomsrg   r   r   r`   	Exception	traceback
format_excr   )r$   rn  r  startLineNumberrp  ru  rj  rtmarv  r|  tracebackMessages               r   tokenizeBodyRTHandler.tokenizeBodyu  s   
 00 'GA / 3@zz|2:%%d+7#D/C%6N $ 2 2388s 2 KCI YY'8 'KK$ #4.C%6NKK$' (2   @ #,#7#7#9 (%t-=*? @ @@s   CA0C."C6DNc                   / nUR                  S5       GHn  nUR                  5       nUS:X  a  M  US:X  a    U$ US:X  a  UR                  [        XB5      5        MG  US:X  a  UR                  [	        XB5      5        Mi  US:X  a  UR                  [        XB5      5        M  [        R                  U5      b  UR                  [        XB5      5        M  [        R                  U5      b  UR                  [        XB5      5        M  [        R                  U5      b  UR                  [        XB5      5        GM"  [        R                  U5      b  UR                  [        XB5      5        GMU  [        R                  U5      b  UR                  [!        XB5      5        GM  ["        R                  U5      b  UR                  [%        XB5      5        GM  [&        R                  U5      b  UR                  [)        XB5      5        GM  [*        R                  U5      b  UR                  [-        XB5      5        GM!  [.        R                  U5      b  UR                  [1        XB5      5        GMT  UR                  [3        XB5      5        GMq     U$ )a4  
Given a line of data stored in measure consisting only of Atoms,
tokenize and return a list.

>>> rth = romanText.rtObjects.RTHandler()
>>> rth.tokenizeAtoms('IV b3 ii7 b4 ii')
[<music21.romanText.rtObjects.RTChord 'IV'>,
 <music21.romanText.rtObjects.RTBeat 'b3'>,
 <music21.romanText.rtObjects.RTChord 'ii7'>,
 <music21.romanText.rtObjects.RTBeat 'b4'>,
 <music21.romanText.rtObjects.RTChord 'ii'>]

>>> rth.tokenizeAtoms('V7 b2 V13 b3 V7 iio6/5[no5]')
[<music21.romanText.rtObjects.RTChord 'V7'>,
 <music21.romanText.rtObjects.RTBeat 'b2'>,
 <music21.romanText.rtObjects.RTChord 'V13'>,
 <music21.romanText.rtObjects.RTBeat 'b3'>,
 <music21.romanText.rtObjects.RTChord 'V7'>,
 <music21.romanText.rtObjects.RTChord 'iio6/5[no5]'>]

>>> tokenList = rth.tokenizeAtoms('I b2 I b2.25 V/ii b2.5 bVII b2.75 V g: IV')
>>> tokenList
[<music21.romanText.rtObjects.RTChord 'I'>,
 <music21.romanText.rtObjects.RTBeat 'b2'>,
 <music21.romanText.rtObjects.RTChord 'I'>,
 <music21.romanText.rtObjects.RTBeat 'b2.25'>,
 <music21.romanText.rtObjects.RTChord 'V/ii'>,
 <music21.romanText.rtObjects.RTBeat 'b2.5'>,
 <music21.romanText.rtObjects.RTChord 'bVII'>,
 <music21.romanText.rtObjects.RTBeat 'b2.75'>,
 <music21.romanText.rtObjects.RTChord 'V'>,
 <music21.romanText.rtObjects.RTAnalyticKey 'g:'>,
 <music21.romanText.rtObjects.RTChord 'IV'>]

>>> tokenList[-2].getKey()
<music21.key.Key of g minor>

>>> rth.tokenizeAtoms('= m3')
[]

>>> tokenList = rth.tokenizeAtoms('g;: ||: V b2 ?(Bb: VII7 b3 III b4 ?)Bb: i :||')
>>> tokenList
[<music21.romanText.rtObjects.RTKey 'g;:'>,
 <music21.romanText.rtObjects.RTRepeatStart '||:'>,
 <music21.romanText.rtObjects.RTChord 'V'>,
 <music21.romanText.rtObjects.RTBeat 'b2'>,
 <music21.romanText.rtObjects.RTOptionalKeyOpen '?(Bb:'>,
 <music21.romanText.rtObjects.RTChord 'VII7'>,
 <music21.romanText.rtObjects.RTBeat 'b3'>,
 <music21.romanText.rtObjects.RTChord 'III'>,
 <music21.romanText.rtObjects.RTBeat 'b4'>,
 <music21.romanText.rtObjects.RTOptionalKeyClose '?)Bb:'>,
 <music21.romanText.rtObjects.RTChord 'i'>,
 <music21.romanText.rtObjects.RTRepeatStop ':||'>]
 r]   r   rQ  r6  r<  )r   ri   r   rN  r1  r9  
reBeatAtomr   r   reOptKeyOpenAtomr>  reOptKeyCloseAtomrG  	reKeyAtomr'  reAnalyticKeyAtomr*  reKeySignatureAtomr,  reRepeatStartAtomr^  reRepeatStopAtomrb  reNoChordAtomr   r   )r$   ru  r   r  words        r   rz  RTHandler.tokenizeAtoms  s   p JJsOD::<Drz8 7 ,T=>L9:M$:;!!$'3F434!''-9-d>?"((.:.t?@&2E$23"((.:M$:;#))$/;N4;<"((.:M$:;!''-9L9:$$T*6Id67GD45C $D r   c                    UR                  S5      nU R                  U5      u  p4U =R                  U R                  U5      -  sl        U =R                  U R	                  U5      -  sl        g)z:
Walk the RT string, creating RT rtObjects along the way.

N)r   rr  ri  rw  r  )r$   r!   rn  linesHeader	linesBodys        r   tokenizeRTHandler.tokenize  sV    
 		$!%!3!3E!:++K88)))44r   c                4    / U l         U R                  U5        g)zs
Given an entire specification as a single source string, strSrc, tokenize it.
This is usually provided in a file.
N)ri  r  r#   s     r   processRTHandler.process   s    
 cr   c                    U R                   (       d  [        S5      eSnU R                    H&  nUR                  5       (       d  M  US-  nX!:  d  M&    g   g)a  
Return True if more than one movement is defined in a RT file.

>>> rth = romanText.rtObjects.RTHandler()
>>> rth.process('Movement: 1 \n Movement: 2 \n \n m1')
>>> rth.definesMovements()
True
>>> rth.process('Movement: 1 \n m1')
>>> rth.definesMovements()
False
zmust create tokens firstr   rd   TF)ri  r   rT   )r$   countRequiredcountts       r   definesMovementsRTHandler.definesMovements  sL     ||$%?@@A||~~
)	 
 r   c                     U R                  SS9$ )z
Return True if this handler has 1 or more movement.

>>> rth = romanText.rtObjects.RTHandler()
>>> rth.process('Movement: 1 \n \n m1')
>>> rth.definesMovements()
False
>>> rth.definesMovement()
True
rd   )r  )r  r*   s    r   definesMovementRTHandler.definesMovement  s     $$1$55r   c                   / n/ nU R                    HL  nUR                  5       (       a#  [        5       nX5l        UR	                  U5        / nUR	                  U5        MN     U(       a!  [        5       nX5l        UR	                  U5        U(       aK  / nUS   R                  5       (       d  US   nSnOSnSnX(S  H  n	Ub  Xy-   n	UR	                  U	5        M     UnU$ )a  
If we have movements defined, return a list of RTHandler rtObjects,
representing header information and each movement, in order.

>>> rth = romanText.rtObjects.RTHandler()
>>> rth.process('Title: Test \n Movement: 1 \n m1 \n Movement: 2 \n m1')
>>> post = rth.splitByMovement(False)
>>> len(post)
3

>>> len(post[0])
1

>>> post[0].__class__
<class 'music21.romanText.rtObjects.RTHandler'>
>>> len(post[1]), len(post[2])
(2, 2)

>>> post = rth.splitByMovement(duplicateHeader=True)
>>> len(post)
2

>>> len(post[0]), len(post[1])
(3, 3)
r   rd   N)ri  rT   rf  tokensr   r  )
r$   duplicateHeaderr  subr  rthalthandlerHeadiStarths
             r   splitByMovementRTHandler.splitByMovement+  s    6 A||~~  k 
C JJqM  +CJKKC7**,,"1g"']*#A

1 #
 Dr   c                R    U R                   (       d  [        S5      eU R                   $ )z%
Get or set tokens for this Handler.
z(must process tokens before calling split)ri  r   r*   s    r   r  RTHandler.tokensl  s!    
 ||$%OPP||r   c                    Xl         g)z 
Assign tokens to this Handler.
N)ri  )r$   r  s     r   r  r  u  s	    
 r   c                ,    [        U R                  5      $ r(   )r   ri  r*   s    r   __len__RTHandler.__len__|  s    4<<  r   c                b    U R                  5       nU R                  UR                  -   Ul        U$ )z0
Return a new handler adding the tokens in both
)rk   ri  r  )r$   otherr  s      r   __add__RTHandler.__add__  s)     nn\\EMM1

r   rh  r(   )r   )T)r   r   r   r   r%   rr  rw  r  rz  r  r  r  r  r  propertyr  setterr  r  r   r   r   r   rf  rf  E  sn    #6*" D\|	5,6<B   ]] !r   rf  c                  B    \ rS rSrSrS rS rS rS rS r	S r
S	 rS
rg)RTFilei  z
Roman Text File access.
c                     S U l         S U l        g r(   filefilenamer*   s    r   r%   RTFile.__init__  s    	r   c                p   S H,  n [         R                  " XS9U l        U R                  b    OM.     U R                  cO  S H-  n [         R                  " XSS9U l        U R                  b    OM/     U R                  c  [	        SU S35      eXl        g! [         a     M  f = f! [         a     Mr  f = f)	z
Open a file for reading, trying a variety of encodings and then
trying them again with an "ignore" flag if it is not possible.
)utf-8	macintoshlatin-1utf-16)encodingN)r  r  r  r  Nignore)r  errorszCannot parse file z, possibly a broken codec?)ioopenr  UnicodeDecodeErrorr
   r  )r$   r  r  s      r   r  RTFile.open  s    
 DHGGH@	99( )	 D 99M "H UDIyy, -	 N yy ((
2LMO O ! &  * s#   &B'B'
B$#B$'
B54B5c                    Xl         g)zX
Assign a file-like object, such as those provided by StringIO, as an
open file object.
N)r  )r$   fileLikes     r   openFileLikeRTFile.openFileLike  s	    
 	r   c                    g)Nr]   r   r*   s    r   r+   RTFile._reprInternal  s    r   c                8    U R                   R                  5         g r(   )r  closer*   s    r   r  RTFile.close  s    		r   c                T    U R                  U R                  R                  5       5      $ )z
Read a file. Note that this calls readstr, which processes all tokens.

If `number` is given, a work number will be extracted if possible.
)readstrr  readr*   s    r   r  RTFile.read  s     ||DIINN,--r   c                <    [        5       nUR                  U5        U$ )zF
Read a string and process all Tokens. Returns a ABCHandler instance.
)rf  r  )r$   strSrchandlers      r   r  RTFile.readstr  s     +r   r  N)r   r   r   r   r^   r%   r  r  r+   r  r  r  r   r   r   r   r  r    s*    !8.r   r  c                  ,    \ rS rSrS rS rS rS rSrg)Testi  c                l    SSK Jn  UR                   H  n[        5       nUR	                  U5      nM      g )Nr   	testFiles)music21.romanTextr  ALLr  r  )r$   r  fileStrf
unused_rths        r   
testBasicATest.testBasicA  s(    / }}GA7+J %r   c                D   [         R                  S5      nU R                  UR                  5       S5        U R                  UR	                  S5      S5        U R                  [         R                  S5      S 5        [         R                  S5      nU R                  UR                  5       S5        U R                  UR                  5       S5        U R                  UR	                  S5      S5        [         R                  S	5      nU R                  UR	                  S5      S
5        [         R                  S5      nU R                  UR	                  S5      S5        [         R                  S5      nU R                  UR	                  S5      S5        [         R                  S5      nU R                  UR	                  S5      S5        [        R                  S5      nU R                  UR	                  S5      S5        [        R                  S5      nU R                  UR	                  S5      S5        [        R                  S5      nU R                  UR	                  S5      S5        [        R                  S5      nU R                  UR	                  S5      S5        [        R                  S5      nU R                  UR	                  S5      S5        [        R                  S5      nU R                  UR	                  S5      S5        [        R                  S5      nU R                  UR	                  S5      S5        U R                  [        R                  S5      S 5        U R                  [        R                  S5      S 5        [        R                  S5      nU R                  UR	                  S5      S5        [        R                  S5      nU R                  US 5        [        R                  S5      nU R                  UR	                  S5      S5        g )Nzm1 g: V b2 ir   r   m1zTime Signature: 2/2z	m3-4=m1-2   m3-4zm123-432=m1120-24234zm123-432zm231a IV6 b4 C: Vm231azm123b-432b=m1120a-24234az
m123b-432bzm231var1 IV6 b4 C: Vm231zvar1 IV6 b4 C: Vvar1zBb:zF#:zf#:zb:zbb:zg:b2zb2.5bVIIzb1.66.5)
r   r   assertEqualr   r   startr   r  r  r  )r$   r   s     r   testReATest.testReA  s   ~.!$T*++,ABDI{+!$A&V,56Z023W-9:\256V, OO./V,##E*U+##E*U+##E*U+##D)T*##E*U+##D)T* 	.50$7V$V,V$D!Y'Y/r   c                <   [        S5      nU R                  UR                  S5        U R                  UR                  S/5        U R                  UR                  S5        U R                  UR
                  S5        [        S5      nU R                  UR                  S5        U R                  UR                  S5        [        S5      nU R                  UR                  S	5        U R                  UR                  S
/5        U R                  UR                  S5        U R                  UR
                  S 5        U R                  UR                  5        [        S5      nU R                  UR                  S5        U R                  UR                  S/5        U R                  UR                  S5        U R                  UR
                  S 5        U R                  UR                  5        [        S5      nU R                  UR                  S5        U R                  UR                  S/5        U R                  UR                  S5        U R                  UR
                  S 5        U R                  UR                  5        [        S5      nU R                  UR                  S5        U R                  UR                  SS/5        U R                  UR                  S5        U R                  UR
                  S 5        U R                  UR                  5        g )Nz$m17var1 vi b2 IV b2.5 viio6/4 b3.5 Izvi b2 IV b2.5 viio6/4 b3.5 I   m17rd   z$m17varC vi b2 IV b2.5 viio6/4 b3.5 ICzm20 vi b2 ii6/5 b3 V b3.5 V7zvi b2 ii6/5 b3 V b3.5 V7   m20z
m0 b3 G: Izb3 G: Ir   m0z	m59 = m57z= m57;   m59zm3-4 = m1-2z= m1-2r   r  r  )
r   r  rg   r   rf   r   r   assertFalser   
assertTrue)r$   r  s     r   testMeasureAttributeProcessing#Test.testMeasureAttributeProcessing  s`   >?#ABbT*%(**A.>?#AB**C067#=>bT*%(**D1--.%9-aS)$'**D1--.$7+bT*%(**D1,,-&8,aV,&)**D1,,-r   c                v   SSK Jn  [        5       nUR                  UR                  5        SnUR
                   H  nUR                  5       (       d  M  US-  nM!     U R                  US5        UR                  UR                  5        SnUR
                   H  nUR                  5       (       d  M  US-  nM!     U R                  US5        SnUR
                   HI  nUR                  5       (       d  M  UR                   H  n[        U[        5      (       d  M  US-  nM!     MK     U R                  US5        g )Nr   r  rd   r      )r  r  rf  r  
mozartK279ri  rT   r  riemenschneider001rK   r   r   r*  )r$   r  r  r  r  r  s         r   testTokenDefinitionTest.testTokenDefinition6  s    /kI(()A||~~
  	"I001A{{}}
 
 	
+A{{}}A!!]33
 ! 
 	"r   r   N)	r   r   r   r   r  r  r  r  r   r   r   r   r  r    s    ,50n%.N#r   r  __main__)=r^   
__future__r   r   r  reunittestmusic21r   r   r   r   r   Environmentr  compiler   r   r   r  r  r  r  r  r  r  r  r  Music21Exceptionr
   r   r   ProtoM21Objectr   r`   r   r   r   r   r   r  r'  r*  r,  r1  r9  r>  rG  rK  rN  rT  rX  r\  r^  rb  rf  r  TestCaser  r   mainTestr   r   r   <module>r     s  
 #  	 	       &&'<= zz89JJ|$	**^,::45 JJ67 JJ)*	JJ01 ZZ- ZZ$
JJx( ::h' 

>*
	66 		|44 		66 	Rg$$ Rj@Ew @EF
Q3 Q3hW >"f "&" "2EV EP.F .:M <M ,+V +0	)6 	)	)F 	)# #4# #8V )~ ))^ ))N )v )H ))8 )@ @J
AW## ALB#8 B#R zT r   