
    3j                    Z   d 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mZ ddlm	Z	 ddlm
Z
 ddlmZ ddlmZ  e
j                  d	      Z ej                  d
      Z ej                  d      Z ej                  d      Z ej                  d      Z ej                  d      Z ej                  d      Z ej                  d      Z ej                  d      Z ej                  d      Z ej                  d      Z ej                  d      Z ej                  d      Z G d de	j8                        Z G d de	j8                        Z G d de	j8                        Z G d dej@                        Z! G d de!      Z" G d  d!e!      Z# G d" d#e!      Z$ G d$ d%e$      Z% G d& d'e$      Z& G d( d)e$      Z' G d* d+e$      Z( G d, d-e(      Z) G d. d/e(      Z* G d0 d1e$      Z+ G d2 d3e$      Z, G d4 d5e$      Z- G d6 d7e$      Z. G d8 d9e$      Z/ G d: d;e$      Z0 G d< d=e0      Z1 G d> d?e0      Z2 G d@ dAe0      Z3 G dB dCe$      Z4 G dD dEe4      Z5 G dF dGe4      Z6 G dH dI      Z7 G dJ dKej@                        Z8 G dL dMejr                        Z:e;dNk(  rddlZ ejx                  e:       yy)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                      e Zd Zy)RomanTextExceptionN__name__
__module____qualname__     H/DATA/.local/lib/python3.12/site-packages/music21/romanText/rtObjects.pyr
   r
   5       r   r
   c                      e Zd Zy)RTTokenExceptionNr   r   r   r   r   r   9   r   r   r   c                      e Zd Zy)RTHandlerExceptionNr   r   r   r   r   r   =   r   r   r   c                  x    e Zd Z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 Zd Zd Zd Zd Zy)RTTokena  
    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                     || _         d| _        y Nr   )src
lineNumberselfr   s     r   __init__zRTToken.__init__\   s    r   c                ,    t        | j                        S N)reprr   r   s    r   _reprInternalzRTToken._reprInternal`   s    DHH~r   c                     yNFr   r#   s    r   
isComposerzRTToken.isComposerc       r   c                     yr&   r   r#   s    r   isTitlezRTToken.isTitlef   r(   r   c                     yr&   r   r#   s    r   isPiecezRTToken.isPiecei   r(   r   c                     yr&   r   r#   s    r   	isAnalystzRTToken.isAnalystl   r(   r   c                     yr&   r   r#   s    r   isProofreaderzRTToken.isProofreadero   r(   r   c                     yr&   r   r#   s    r   isTimeSignaturezRTToken.isTimeSignaturer   r(   r   c                     yr&   r   r#   s    r   isKeySignaturezRTToken.isKeySignatureu   r(   r   c                     yr&   r   r#   s    r   isNotezRTToken.isNotex   r(   r   c                     y)z/
        Occasionally found in header.
        Fr   r#   s    r   isFormzRTToken.isForm{   s     r   c                     yr&   r   r#   s    r   	isMeasurezRTToken.isMeasure   r(   r   c                     yr&   r   r#   s    r   isPedalzRTToken.isPedal   r(   r   c                     yr&   r   r#   s    r   isWorkzRTToken.isWork   r(   r   c                     yr&   r   r#   s    r   
isMovementzRTToken.isMovement   r(   r   c                     yr&   r   r#   s    r   	isVersionzRTToken.isVersion   r(   r   c                     y)zh
        Atoms are any untagged data; generally only found inside a
        measure definition.
        Fr   r#   s    r   isAtomzRTToken.isAtom   s    
 r   N )r   r   r   __doc__r   r$   r'   r*   r,   r.   r0   r2   r4   r6   r8   r:   r<   r>   r@   rB   rD   r   r   r   r   r   C   s\    0r   r   c                  ~     e Zd ZdZd f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 Zd Zd Zd Z xZS )RTTaggeda  
    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         |   |       d| _        d| _        d|v rE|j	                  d      }|d | j                         | _        ||dz   d  j                         | _        y || _        y )NrF   :   )superr   tagdatafindstrip)r   r   iFirst	__class__s      r   r   zRTTagged.__init__   sj    	#:XXc]F7F|))+DHFQJK(..0DIDIr   c                @    | j                   j                         dk(  ryy)a3  
        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rN   lowerr#   s    r   r'   zRTTagged.isComposer   s     88>>z)r   c                @    | j                   j                         dk(  ryy)a(  
        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
        titleTFrV   r#   s    r   r*   zRTTagged.isTitle        88>>w&r   c                @    | j                   j                         dk(  ryy)a(  
        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
        pieceTFrV   r#   s    r   r,   zRTTagged.isPiece   rZ   r   c                @    | j                   j                         dk(  ryy)a4  
        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
        analystTFrV   r#   s    r   r.   zRTTagged.isAnalyst   s     88>>y(r   c                >    | j                   j                         dv ryy)aF  
        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 readerTFrV   r#   s    r   r0   zRTTagged.isProofreader   s     88>>>>r   c                >    | j                   j                         dv ryy)a  
        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 signatureTFrV   r#   s    r   r2   zRTTagged.isTimeSignature  s     88>>BBr   c                >    | j                   j                         dv ryy)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 signatureTFrV   r#   s    r   r4   zRTTagged.isKeySignature  s    L 88>>@@r   c                @    | j                   j                         dk(  ryy)a#  
        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
        noteTFrV   r#   s    r   r6   zRTTagged.isNoteJ       88>>v%r   c                @    | j                   j                         dk(  ryy)a#  
        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
        formTFrV   r#   s    r   r8   zRTTagged.isFormZ  rg   r   c                >    | j                   j                         dv ryy)a(  
        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
        )pedalTFrV   r#   s    r   r<   zRTTagged.isPedalj  s     88>>y(r   c                @    | j                   j                         dk(  ryy)a  
        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'
        	rtversionTFrV   r#   s    r   rB   zRTTagged.isVersionz  s    $ 88>>{*r   c                >    | j                   j                         dv ryy)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madrigalTFrV   r#   s    r   r>   zRTTagged.isWork  s    6 88>>33r   c                @    | j                   j                         dk(  ryy)a7  
        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
        movementTFrV   r#   s    r   r@   zRTTagged.isMovement  s     88>>z)r   c                :    | j                   j                         dv 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 minorrV   r#   s    r   isSixthMinorzRTTagged.isSixthMinor  s     xx~~#@@@r   c                :    | j                   j                         dv S )a  
        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 minorrV   r#   s    r   isSeventhMinorzRTTagged.isSeventhMinor  s     xx~~#DDDr   rE   )r   r   r   rG   r   r'   r*   r,   r.   r0   r2   r4   r6   r8   r<   rB   r>   r@   ru   rx   __classcell__rS   s   @r   rI   rI      s\    *$    $)V   .@ 
A
Er   rI   c                  B     e Zd ZdZd fd	Zd Zd Zd Zd Zd Z	 xZ
S )		RTMeasurea  
    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         |   |       d| _        d| _        g | _        g | _        d | _        d | _        d| _        g | _	        |r| j                  |       y y )NrF   F)rM   r   rN   rO   numberrepeatLettervariantNumbervariantLetterisCopyDefinitionatoms_parseAttributes)r   r   rS   s     r   r   zRTMeasure.__init__  sd    	! " %
!!#& r   c                
   d|v r|j                  d      \  }}||g}n|g}g }g }|D ]W  }t        j                  |      \  }}	|j                  t	        |             |	j                  dd      }	|j                  |	       Y ||fS )a.  
        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'])
        -mrF   )splitr   getNumFromStrappendintreplace)
r   r   mnStartmnEndprocr~   r   mnnumStralphaStrs
             r   _getMeasureNumberDatazRTMeasure._getMeasureNumberData  s     #: YYs^NGUU#D5DB%33B7FHMM#f+&''R0H)  |##r   c                   t         j                  |      }|t        d|       |j                         }|d | j	                         }|| _        ||d  j	                         }| j                  |      \  | _        | _        t        j                  |      }|^|j                  d      }t        t        j                  |      d         | _        ||j                         d  j	                         | _        n|| _        t         j                  |      }|>|j                  d      }|| _        ||j                         d  j	                         | _        | j                  j%                  d      rd| _        y y )Nzfound no measure tag: r   rL   =T)reMeasureTagmatchr   endrQ   rN   r   r~   r   	reVariantgroupr   r   r   r   rO   reVariantLetterr   
startswithr   )r   r   giEndrawTagrawDatavarStrs          r   r   zRTMeasure._parseAttributes/  sI   s#9$'=cU%CDDuuwUd!!#de*""$ *.)C)CF)K&T& OOG$=WWQZF!$V%9%9&%A!%D!ED)//1DIDI!!'*=WWQZF!'D)//1DI99$$(D! %r   c                    t        | j                        dk(  rt        | j                  d         }|S | j                  d    d| j                  d    }|S )NrL   r   r   )lenr~   str)r   	numberStrs     r   r$   zRTMeasure._reprInternalM  sW    t{{q DKKN+I   ;;q>*!DKKN+;<Ir   c                     yNTr   r#   s    r   r:   zRTMeasure.isMeasureT      r   c                x    | j                   j                  dd      j                         }| j                  |      S )a  
        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   rF   )rO   r   rQ   r   )r   r   s     r   getCopyTargetzRTMeasure.getCopyTargetW  s4    $ ))##C,224))'22r   rE   )r   r   r   rG   r   r   r   r$   r:   r   ry   rz   s   @r   r|   r|     s'    "H'&$:)<3r   r|   c                  *     e Zd ZdZd fd	Zd Z xZS )RTAtoma  
    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                2    t         |   |       || _        y r!   )rM   r   	containerr   r   r   rS   s      r   r   zRTAtom.__init__  s    "r   c                     yr   r   r#   s    r   rD   zRTAtom.isAtom  r   r   rF   N)r   r   r   rG   r   rD   ry   rz   s   @r   r   r   m  s    &#
r   r   c                  $     e Zd ZdZd fd	Z xZS )RTChordz
    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                B    t         |   ||       d | _        d | _        y r!   rM   r   offsetquarterLengthr   s      r   r   zRTChord.__init__  #    i( !r   r   r   r   r   rG   r   ry   rz   s   @r   r   r     s    " "r   r   c                  $     e Zd ZdZd fd	Z xZS )	RTNoChorda  
    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                B    t         |   ||       d | _        d | _        y r!   r   r   s      r   r   zRTNoChord.__init__  r   r   r   r   rz   s   @r   r   r     s    " "r   r   c                      e Zd ZdZd Zd Zy)RTBeatz
    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                   | j                   j                  dd      }|j                  d      }t        |d         }t	        |      dkD  rt        j                  d|d   z         }nd}t	        |      dkD  rht        d|d   z         }t        |t              rt        j                  j                  |      }|j                  }t        j                  d||z  z        }nd}t	        |      d	kD  r;t        j                  d
| j                    g       t!        d| j                          t        j                  ||z   |z         }|S )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
        brF   .r   rL              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   getBeatFloatOrFraczRTBeat.getBeatFloatOrFrac  s!   r ((""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                    | j                         }	 |j                  |      }|S # t        j                  $ r, t        j                  d| j                   d| g       d}Y |S w xY w)a  
        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   	getOffsetzRTBeat.getOffset  s{    4 &&(	 2248D  22 	##*88*OM?<%  D	s   % ;A$#A$N)r   r   r   rG   r   r   r   r   r   r   r     s    Qf'r   r   c                       e Zd ZdZdZd Zd Zy)RTKeyTypeAtoma9  
    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                    | j                   j                  | j                        }t        j                  |      }t        j
                  |      S )z?
        This returns a Key, not a KeySignature object
        )r   rstripfooterStripr   "convertKeyStringToMusic21KeyStringKeyr   myKeys     r   getKeyzRTKeyTypeAtom.getKeyL  s:      0 0166u=wwu~r   c                `    | j                         }t        j                  |j                        S )z,
        Get a KeySignature object.
        )r   r   KeySignaturesharpsr   s     r   getKeySignaturezRTKeyTypeAtom.getKeySignatureT  s$     --r   N)r   r   r   rG   r   r   r   r   r   r   r   r   ?  s    	 K.r   r   c                      e Zd ZdZdZy)RTKeya  
    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   Nr   r   r   rG   r   r   r   r   r   r   \  s    4 Kr   r   c                      e Zd ZdZdZy)RTAnalyticKeya  
    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>

    rK   Nr   r   r   r   r   r   z  s    $ Kr   r   c                      e Zd ZdZd Zy)RTKeySignatureah  
    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                \    t        | j                  dd        }t        j                  |      S )Nr   )r   r   r   r   )r   	numSharpss     r   r   zRTKeySignature.getKeySignature  s'    %		**r   N)r   r   r   rG   r   r   r   r   r   r     s    $+r   r   c                  $     e Zd ZdZd fd	Z xZS )RTOpenParensz
    A simple open parenthesis Atom with a sensible default

    >>> romanText.rtObjects.RTOpenParens('(')
    <music21.romanText.rtObjects.RTOpenParens '('>
    c                &    t         |   ||       y r!   rM   r   r   s      r   r   zRTOpenParens.__init__      i(r   )(Nr   rz   s   @r   r   r         ) )r   r   c                  $     e Zd ZdZd fd	Z xZS )RTCloseParensz
    A simple close parenthesis Atom with a sensible default

    >>> romanText.rtObjects.RTCloseParens(')')
    <music21.romanText.rtObjects.RTCloseParens ')'>
    c                &    t         |   ||       y r!   r   r   s      r   r   zRTCloseParens.__init__  r   r   ))Nr   rz   s   @r   r   r     r   r   r   c                      e Zd ZdZd Zy)RTOptionalKeyOpena  
    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                   | j                   dk(  rt        j                  d      S | j                   j                  dd      }|j                  dd      }|j                  dd      }|j                  dd      }t        j                  |      S )Nz?(b:r   r   rK   rF   ?r   r   r   r   r   r   keyStrs     r   r   zRTOptionalKeyOpen.getKey  sp    88v773<XX%%c3/F^^C,F^^C,F^^C,F776?"r   Nr   r   r   rG   r   r   r   r   r  r    s    

#r   r  c                      e Zd ZdZd Zy)RTOptionalKeyClosea  
    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                   | j                   dv rt        j                  d      S | j                   j                  dd      }|j                  dd      }|j                  dd      }|j                  dd      }t        j                  |      S )N)z?)b:z?)br   r   rK   rF   r  r   r  r  s     r   r   zRTOptionalKeyClose.getKey  sp    88&773<XX%%c3/F^^C,F^^C,F^^C,F776?"r   Nr  r   r   r   r
  r
    s    
#r   r
  c                      e Zd ZdZy)RTPhraseMarkerz
    A Phrase Marker:

    >>> rtPhraseMarker = romanText.rtObjects.RTPhraseMarker('')
    >>> rtPhraseMarker
    <music21.romanText.rtObjects.RTPhraseMarker ''>
    Nr   r   r   rG   r   r   r   r  r    s    r   r  c                  $     e Zd ZdZd fd	Z xZS )RTPhraseBoundaryz
    >>> phrase = romanText.rtObjects.RTPhraseBoundary('||')
    >>> phrase
    <music21.romanText.rtObjects.RTPhraseBoundary '||'>
    c                &    t         |   ||       y r!   r   r   s      r   r   zRTPhraseBoundary.__init__  r   r   )||Nr   rz   s   @r   r  r         ) )r   r  c                  $     e Zd ZdZd fd	Z xZS )RTEllisonStartz
    >>> phrase = romanText.rtObjects.RTEllisonStart('|*')
    >>> phrase
    <music21.romanText.rtObjects.RTEllisonStart '|*'>
    c                &    t         |   ||       y r!   r   r   s      r   r   zRTEllisonStart.__init__  r   r   )z|*Nr   rz   s   @r   r  r    r  r   r  c                  $     e Zd ZdZd fd	Z xZS )RTEllisonStopz
    >>> phrase = romanText.rtObjects.RTEllisonStop('*|')
    >>> phrase
    <music21.romanText.rtObjects.RTEllisonStop '*|'>
    c                &    t         |   ||       y r!   r   r   s      r   r   zRTEllisonStop.__init__  r   r   )z*|Nr   rz   s   @r   r  r    r  r   r  c                      e Zd ZdZy)RTRepeatzz
    >>> repeat = romanText.rtObjects.RTRepeat('||:')
    >>> repeat
    <music21.romanText.rtObjects.RTRepeat '||:'>
    Nr  r   r   r   r  r  !  s    r   r  c                  $     e Zd ZdZd fd	Z xZS )RTRepeatStartz
    >>> repeat = romanText.rtObjects.RTRepeatStart()
    >>> repeat
    <music21.romanText.rtObjects.RTRepeatStart ...'||:'>
    c                &    t         |   ||       y r!   r   r   s      r   r   zRTRepeatStart.__init__0  r   r   )z||:Nr   rz   s   @r   r  r  )  r  r   r  c                  $     e Zd ZdZd fd	Z xZS )RTRepeatStopz
    >>> repeat = romanText.rtObjects.RTRepeatStop()
    >>> repeat
    <music21.romanText.rtObjects.RTRepeatStop ...':||'>
    c                &    t         |   ||       y r!   r   r   s      r   r   zRTRepeatStop.__init__;  r   r   )z:||Nr   rz   s   @r   r   r   4  r  r   r   c                      e Zd Zd Zd Zd Zd ZddZd Zd Z	dd	Z
d
 ZddZed        Zej                  d        Zd Zd Zy)	RTHandlerc                     g | _         d| _        y r   )_tokenscurrentLineNumberr#   s    r   r   zRTHandler.__init__D  s     !"r   c                    d}t        |      D ],  \  }}t        j                  |j                               *|} n |t	        d|      |d| ||d fS )a!  
        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   rQ   r
   )r   lines
iStartBodyilines        r   splitAtHeaderzRTHandler.splitAtHeaderK  ss     
 'GAt!!$**,/;
	 (
 $ &>?DF F[j!5#555r   c                    g }t        |      D ]A  \  }}|j                         }|dk(  rt        |      }|dz   |_        |j	                  |       C t        |      dz   | _        |S )z
        In the header, we only have :class:`~music21.romanText.base.RTTagged`
        tokens. We can this process these all as the same class.
        rF   rL   )r(  rQ   rI   r   r   r   r&  )r   r)  r   r+  r,  rtts         r   tokenizeHeaderzRTHandler.tokenizeHeader`  sh    
  'GAt::<Drz4.CUCNKK ( "%Uar   c           
         g }| j                   }t        |      D ]  \  }}||z   }	 |j                         }|dk(  r"t        j	                  |      ^t        |      }||_        | j                  |j                  |      |_	        |j                  D ]	  }||_         |j                  |       n#t        |      }	||	_        |j                  |	        |S # t        $ r.}
ddl}|j                         }t        d| d| d|       |
d}
~
ww xY w)z
        In the body, we may have measure, time signature, or note
        declarations, as well as possible other tagged definitions.
        rF   N)r   r   zAt line z (z) an exception was raised:
)r&  r(  rQ   r   r   r|   r   tokenizeAtomsrO   r   r   rI   	Exception	traceback
format_excr   )r   r)  r   startLineNumberr+  r,  r&  rtmar/  excr4  tracebackMessages                r   tokenizeBodyzRTHandler.tokenizeBodyq  s"   
 00 'GAt /! 3zz|2:%%d+7#D/C%6CN $ 2 2388s 2 KCI YY'8 'KK$ #4.C%6CNKK$' (6    #,#7#7#9 (01D69U'(* s   CBC	D)DDNc                   g }|j                  d      D ]_  }|j                         }|dk(  r|dk(  r |S |dk(  r|j                  t        ||             C|dk(  r|j                  t	        ||             d|dk(  r|j                  t        ||             t        j                  |      |j                  t        ||             t        j                  |      |j                  t        ||             t        j                  |      |j                  t        ||             t        j                  |      |j                  t        ||             Kt        j                  |      |j                  t!        ||             }t"        j                  |      |j                  t%        ||             t&        j                  |      |j                  t)        ||             t*        j                  |      |j                  t-        ||             t.        j                  |      |j                  t1        ||             E|j                  t3        ||             b |S )a	  
        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 ':||'>]
         rF   r   r  r   r   )r   rQ   r   r  r   r   
reBeatAtomr   r   reOptKeyOpenAtomr  reOptKeyCloseAtomr
  	reKeyAtomr   reAnalyticKeyAtomr   reKeySignatureAtomr   reRepeatStartAtomr  reRepeatStopAtomr   reNoChordAtomr   r   )r   r,  r   r   words        r   r2  zRTHandler.tokenizeAtoms  s   p JJsOD::<Drz8 7 ,T9=>Ly9:M$	:;!!$'3F434!''-9-dI>?"((.:.tY?@&2E$	23"((.:M$	:;#))$/;N4;<"((.:M$	:;!''-9Ly9:$$T*6IdI67GD)45C $D r   c                    |j                  d      }| j                  |      \  }}| xj                  | j                  |      z  c_        | xj                  | j	                  |      z  c_        y)zJ
        Walk the RT string, creating RT rtObjects along the way.
        
N)r   r-  r%  r0  r;  )r   r   r)  linesHeader	linesBodys        r   tokenizezRTHandler.tokenize  sX    
 		$!%!3!3E!:Y++K88)))44r   c                4    g | _         | j                  |       y)z
        Given an entire specification as a single source string, strSrc, tokenize it.
        This is usually provided in a file.
        N)r%  rL  r   s     r   processzRTHandler.process  s    
 cr   c                    | j                   st        d      d}| j                   D ]  }|j                         s|dz  }||k\  s y y)aP  
        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   rL   TF)r%  r   r@   )r   countRequiredcountts       r   definesMovementszRTHandler.definesMovements  sL     ||$%?@@A||~
M)	 
 r   c                &    | j                  d      S )a  
        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
        rL   )rP  )rS  r#   s    r   definesMovementzRTHandler.definesMovement  s     $$1$55r   c                   g }g }| j                   D ]G  }|j                         r$t               }||_        |j	                  |       g }|j	                  |       I |r"t               }||_        |j	                  |       |rEg }|d   j                         s|d   }d}nd}d}||d D ]  }	|||	z   }	|j	                  |	        |}|S )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   rL   N)r%  r@   r#  tokensr   rU  )
r   duplicateHeaderr   subrR  rthalthandlerHeadiStarths
             r   splitByMovementzRTHandler.splitByMovement)  s    6 A||~  k 
C JJqM  +CCJKKC7**,"1g"&']*#aA

1 #
 Dr   c                H    | j                   st        d      | j                   S )z5
        Get or set tokens for this Handler.
        z(must process tokens before calling split)r%  r   r#   s    r   rW  zRTHandler.tokensj  s!    
 ||$%OPP||r   c                    || _         y)z0
        Assign tokens to this Handler.
        N)r%  )r   rW  s     r   rW  zRTHandler.tokenss  s    
 r   c                ,    t        | j                        S r!   )r   r%  r#   s    r   __len__zRTHandler.__len__z  s    4<<  r   c                b    | j                         }| j                  |j                  z   |_        |S )z@
        Return a new handler adding the tokens in both
        )rS   r%  rW  )r   otherrZ  s      r   __add__zRTHandler.__add__}  s)     nn\\EMM1

r   r!   )r   )T)r   r   r   r   r-  r0  r;  r2  rL  rN  rS  rU  r_  propertyrW  setterrc  rf  r   r   r   r#  r#  A  sn    #6*""H\|	5,6<B   ]] !r   r#  c                  :    e Zd ZdZd Zd Zd Zd Zd Zd Z	d Z
y	)
RTFilez!
    Roman Text File access.
    c                     d | _         d | _        y r!   )filefilenamer#   s    r   r   zRTFile.__init__  s    	r   c                f   dD ]-  }	 t        j                  ||      | _        | j                   n/ | j                  NdD ].  }	 t        j                  ||d      | _        | j                   n0 | j                  t	        d| d      || _        y# t        $ r Y w xY w# t        $ r Y nw xY w)	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)ro  rp  rq  rr  Nignore)rs  errorszCannot parse file z, possibly a broken codec?)ioopenrl  UnicodeDecodeErrorr
   rm  )r   rm  rs  s      r   rw  zRTFile.open  s    
 DHGGHx@	99( )	 D 99M "8H UDIyy, -	 N yy ((
2LMO O ! &  * s#   (B)B$	B! B!$	B0/B0c                    || _         y)zp
        Assign a file-like object, such as those provided by StringIO, as an
        open file object.
        N)rl  )r   fileLikes     r   openFileLikezRTFile.openFileLike  s    
 	r   c                     y)NrF   r   r#   s    r   r$   zRTFile._reprInternal  s    r   c                8    | j                   j                          y r!   )rl  closer#   s    r   r~  zRTFile.close  s    		r   c                T    | j                  | j                  j                               S )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.
        )readstrrl  readr#   s    r   r  zRTFile.read  s     ||DIINN,--r   c                <    t               }|j                  |       |S )zV
        Read a string and process all Tokens. Returns a ABCHandler instance.
        )r#  rN  )r   strSrchandlers      r   r  zRTFile.readstr  s     +r   N)r   r   r   rG   r   rw  r{  r$   r~  r  r  r   r   r   rj  rj    s*    !8.r   rj  c                  $    e Zd Zd Zd Zd Zd Zy)Testc                h    ddl m} |j                  D ]  }t               }|j	                  |      } y )Nr   	testFiles)music21.romanTextr  ALLrj  r  )r   r  fileStrf
unused_rths        r   
testBasicAzTest.testBasicA  s(    / }}GA7+J %r   c                D   t         j                  d      }| j                  |j                         d       | j                  |j	                  d      d       | j                  t         j                  d      d        t         j                  d      }| j                  |j                         d       | j                  |j                         d       | j                  |j	                  d      d       t         j                  d	      }| j                  |j	                  d      d
       t         j                  d      }| j                  |j	                  d      d       t         j                  d      }| j                  |j	                  d      d       t         j                  d      }| j                  |j	                  d      d       t        j                  d      }| j                  |j	                  d      d       t        j                  d      }| j                  |j	                  d      d       t        j                  d      }| j                  |j	                  d      d       t        j                  d      }| j                  |j	                  d      d       t        j                  d      }| j                  |j	                  d      d       t        j                  d      }| j                  |j	                  d      d       t        j                  d      }| j                  |j	                  d      d       | j                  t        j                  d      d        | j                  t        j                  d      d        t        j                  d      }| j                  |j	                  d      d       t        j                  d      }| j                  |d        t        j                  d      }| j                  |j	                  d      d       y )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   rB  rA  r>  )r   r   s     r   testReAz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                <   t        d      }| j                  |j                  d       | j                  |j                  dg       | j                  |j                  d       | j                  |j
                  d       t        d      }| j                  |j                  d       | j                  |j                  d       t        d      }| j                  |j                  d	       | j                  |j                  d
g       | j                  |j                  d       | j                  |j
                  d        | j                  |j                         t        d      }| j                  |j                  d       | j                  |j                  dg       | j                  |j                  d       | j                  |j
                  d        | j                  |j                         t        d      }| j                  |j                  d       | j                  |j                  dg       | j                  |j                  d       | j                  |j
                  d        | j                  |j                         t        d      }| j                  |j                  d       | j                  |j                  ddg       | j                  |j                  d       | j                  |j
                  d        | j                  |j                         y )Nz$m17var1 vi b2 IV b2.5 viio6/4 b3.5 Izvi b2 IV b2.5 viio6/4 b3.5 I   m17rL   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  rO   r~   rN   r   r   assertFalser   
assertTrue)r   r7  s     r   testMeasureAttributeProcessingz#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                6   ddl m} t               }|j                  |j                         d}|j
                  D ]  }|j                         s|dz  } | j                  |d       |j                  |j                         d}|j
                  D ]  }|j                         s|dz  } | j                  |d       d}|j
                  D ]:  }|j                         s|j                  D ]  }t        |t              s|dz  } < | j                  |d       y )Nr   r  rL   r      )r  r  r#  rN  
mozartK279r%  r@   r  riemenschneider001r:   r   r   r   )r   r  rZ  rQ  rR  r8  s         r   testTokenDefinitionzTest.testTokenDefinition4  s    /kI(()A||~
  	"I001A{{}
 
 	
+A{{}A!!]3
 ! 
 	"r   N)r   r   r   r  r  r  r  r   r   r   r  r    s    ,50n%.N#r   r  __main__)=rG   
__future__r   r   rv  reunittestmusic21r   r   r   r   r   Environmentr   compiler   r   r   r?  r@  rA  rB  rC  r>  rD  rE  rF  Music21Exceptionr
   r   r   ProtoM21Objectr   rI   r|   r   r   r   r   r   r   r   r   r   r   r  r
  r  r  r  r  r  r  r   r#  rj  TestCaser  r   mainTestr   r   r   <module>r     s  
 #  	 	       &{&&'<= rzz89BJJ|$	"**^,2::45 BJJ67 BJJ)*	BJJ01 RZZ- RZZ$
BJJx( 2::h' 

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