§
    ƒØj8±  ã            
      ól  — U d Z ddlmZ ddlZddlZddlZddlm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 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ez  ej        z  ej        z  Zi Zded<   d„ Z d„ Z!dZ"ddddddddddœ	Z#	 d0d1d"„Z$ G d#„ d$ej%        ¦  «        Z& G d%„ d&ej%        ¦  «        Z' G d'„ d(e(¦  «        Z) G d)„ d*ej*        ¦  «        Z+ G d+„ d,e+ej,        ¦  «        Z- G d-„ d.ej.        ¦  «        Z/e+e-gZ0e1d/k    rddl
Z
 e
j2        e/¦  «         dS dS )2aQ  
This module defines objects for representing key signatures as well as key
areas. The :class:`~music21.key.KeySignature` is used in
:class:`~music21.stream.Measure` objects for defining notated key signatures.

The :class:`~music21.key.Key` object is a fuller representation not just of
a key signature but also of the key of a region.
é    )ÚannotationsN)Úoverload)Úbase)ÚcacheMethod)ÚStepName)Úenvironment)Úexceptions21)Úinterval)Únote)Úpitch)Úscale)ÚstyleÚkeyzdict[int, pitch.Pitch]Ú_sharpsToPitchCachec                ó,  — |                       d¦  «        r| dk    rnw| dk    rd} nn| dk    rd} net          | ¦  «        dk    r| d         dk    r| d         d	z   } n:t          | d
d…         ¦  «        dhk    r| d         d	t          | ¦  «        d
z
  z  z   } | S )a+  
    Utility function to change strings in the form of "Eb" to
    "E-" (for E-flat major) and leaves alone proper music21 strings
    (like "E-" or "f#").  A little bit complex because of parsing
    bb as B-flat minor and Bb as B-flat major.

    >>> key.convertKeyStringToMusic21KeyString('Eb')
    'E-'
    >>> key.convertKeyStringToMusic21KeyString('f#')
    'f#'
    >>> key.convertKeyStringToMusic21KeyString('bb')
    'b-'
    >>> key.convertKeyStringToMusic21KeyString('Bb')
    'B-'
    >>> key.convertKeyStringToMusic21KeyString('b#')
    'b#'
    >>> key.convertKeyStringToMusic21KeyString('c')
    'c'
    >>> key.convertKeyStringToMusic21KeyString('Bbb')
    'B--'
    >>> key.convertKeyStringToMusic21KeyString('bbb')
    'b--'
    >>> key.convertKeyStringToMusic21KeyString('Ebb')
    'E--'
    ÚbÚbbzb-ÚBbúB-é   éÿÿÿÿr   ú-é   N)ÚendswithÚlenÚset)Ú
textStrings    ú€/Users/tedpeters/Documents/Projects/Claude Projects/Misc Tools/notename-sheets/.venv/lib/python3.11/site-packages/music21/key.pyÚ"convertKeyStringToMusic21KeyStringr   1   s¼   € ð4 ×Ò Ñ$Ô$ð 	A¨°sÒ):Ð):ØØ	�tÒ	Ð	Øˆ
ˆ
Ø	�tÒ	Ð	Øˆ
ˆ
Ý	ˆZ‰Œ˜AÒ	Ð	 *¨R¤.°CÒ"7Ð"7Ø ”] SÑ(ˆ
ˆ
Ý	ˆZ˜˜˜Œ^Ñ	Ô	  Ò	%Ð	%Ø ”] S­C°
©O¬O¸aÑ,?Ñ%@Ñ@ˆ
ØÐó    c                ón  — | €d} | t           v rt          j        t           |          ¦  «        S t          j        d¦  «        }d|_        | dk    rd}n| dk     rd}n|S t          j        |¦  «        }t          t          | ¦  «        ¦  «        D ]}| 
                    |¦  «        }Œd|_        |t           | <   |S )a£  
    Given a positive/negative number of sharps, return a Pitch
    object set to the appropriate major key value.

    >>> key.sharpsToPitch(1)
    <music21.pitch.Pitch G>
    >>> key.sharpsToPitch(2)
    <music21.pitch.Pitch D>
    >>> key.sharpsToPitch(-2)
    <music21.pitch.Pitch B->
    >>> key.sharpsToPitch(-6)
    <music21.pitch.Pitch G->

    Note that these are :class:`music21.pitch.Pitch` objects not just names:

    >>> k1 = key.sharpsToPitch(6)
    >>> k1
    <music21.pitch.Pitch F#>
    >>> k1.step
    'F'
    >>> k1.accidental
    <music21.pitch.Accidental sharp>

    OMIT_FROM_DOCS

    The second time we do something it should be in the cache, so let's make sure it still works:

    >>> key.sharpsToPitch(1)
    <music21.pitch.Pitch G>
    >>> key.sharpsToPitch(1)
    <music21.pitch.Pitch G>
    >>> 1 in key._sharpsToPitchCache
    True
    >>> key._sharpsToPitchCache[1]
    <music21.pitch.Pitch G>
    Nr   ÚCÚP5zP-5)r   ÚcopyÚdeepcopyr   ÚPitchÚoctaver
   ÚIntervalÚrangeÚabsÚtransposePitch)Ú
sharpCountÚ	pitchInitÚintervalStrÚintervalObjÚis        r   ÚsharpsToPitchr1   X   sÊ   € ðJ ÐØˆ
àÕ(Ð(Ð(åŒ}Õ0°Ô<Ñ=Ô=Ð=å”˜CÑ Ô €IØ€IÔà�A‚~€~ØˆˆØ	�aŠˆØˆˆàÐåÔ# KÑ0Ô0€KÝ•3�z‘?”?Ñ#Ô#ð :ð :ˆØ×.Ò.¨yÑ9Ô9ˆ	ˆ	Ø€IÔà&/Õ˜
Ñ#ØÐr    )ÚFr"   ÚGÚDÚAÚEÚBéýÿÿÿéþÿÿÿéüÿÿÿr   r   éûÿÿÿ)	ÚmajorÚionianÚminorÚaeolianÚdorianÚphrygianÚlydianÚ
mixolydianÚlocrianÚvalueústr | pitch.Pitch | note.NoteÚmodeú
str | NoneÚreturnÚintc                ó  — t          | t          ¦  «        rt          j        | ¦  «        }nQt          | t          j        ¦  «        r| }n4t          | t          j        ¦  «        r| j        }nt          d| › �¦  «        ‚t                               |j	        ¦  «        dz
  }|j
        �K|j
                             ¦   «         du rt          d¦  «        ‚t          |j
        j        ¦  «        }|d|z  z   }|�|t          v r|t          |         z  }|S )a  
    Given a pitch string or :class:`music21.pitch.Pitch` or
    :class:`music21.note.Note` object,
    return the number of sharps found in that mode.

    The `mode` parameter can be 'major', 'minor', or most
    of the common church/jazz modes ('dorian', 'mixolydian', etc.)
    including Locrian.

    If `mode` is omitted or not found, the default mode is major.

    (extra points to anyone who can find the earliest reference to
    the Locrian mode in print.  David Cohen and I (MSAC) have been
    looking for this for years).

    >>> key.pitchToSharps('c')
    0
    >>> key.pitchToSharps('c', 'minor')
    -3
    >>> key.pitchToSharps('a', 'minor')
    0
    >>> key.pitchToSharps('d')
    2
    >>> key.pitchToSharps('e-')
    -3
    >>> key.pitchToSharps('a')
    3
    >>> key.pitchToSharps('e', 'minor')
    1
    >>> key.pitchToSharps('f#', 'major')
    6
    >>> key.pitchToSharps('g-', 'major')
    -6
    >>> key.pitchToSharps('c#')
    7
    >>> key.pitchToSharps('g#')
    8
    >>> key.pitchToSharps('e', 'dorian')
    2
    >>> key.pitchToSharps('d', 'dorian')
    0
    >>> key.pitchToSharps('g', 'mixolydian')
    0
    >>> key.pitchToSharps('e-', 'lydian')
    -2
    >>> key.pitchToSharps('e-', 'lydian')
    -2
    >>> key.pitchToSharps('a', 'phrygian')
    -1
    >>> key.pitchToSharps('e', 'phrygian')
    0
    >>> key.pitchToSharps('f#')
    6
    >>> key.pitchToSharps(note.Note('f-'))
    -8
    >>> key.pitchToSharps(pitch.Pitch('f--'))
    -15
    >>> key.pitchToSharps('f--', 'locrian')
    -20
    >>> key.pitchToSharps('a', 'ionian')
    3
    >>> key.pitchToSharps('a', 'aeolian')
    0

    But quarter tones don't work:

    >>> key.pitchToSharps('C~')
    Traceback (most recent call last):
    music21.key.KeyException: Cannot determine sharps for quarter-tone keys! silly!
    z&Cannot get a sharp number from value: r   NFz5Cannot determine sharps for quarter-tone keys! silly!é   )Ú
isinstanceÚstrr   r&   r   ÚNoteÚKeyExceptionÚfifthsOrderÚindexÚstepÚ
accidentalÚisTwelveTonerJ   ÚalterÚmodeSharpsAlter)rE   rG   Ú
pitchValueÚsharpsÚvaas        r   ÚpitchToSharpsr[   §   s  € õR �%�ÑÔð MÝ”[ Ñ'Ô'ˆ
ˆ
Ý	�E�5œ;Ñ	'Ô	'ð MØˆ
ˆ
Ý	�E�4œ9Ñ	%Ô	%ð MØ”[ˆ
ˆ
åÐKÀEÐKÐKÑLÔLÐLõ ×Ò˜zœÑ/Ô/°!Ñ3€FØÔÐ(ØÔ ×-Ò-Ñ/Ô/°5Ð8Ð8ÝÐVÑWÔWÐWÝ�*Ô'Ô-Ñ.Ô.ˆØ˜!˜c™'Ñ!ˆàÐ˜D¥OÐ3Ð3Ø•/ $Ô'Ñ'ˆà€Mr    c                  ó   — e Zd ZdS )ÚKeySignatureExceptionN©Ú__name__Ú
__module__Ú__qualname__© r    r   r]   r]     ó   € € € € € Ø€Dr    r]   c                  ó   — e Zd ZdS )rP   Nr^   rb   r    r   rP   rP     rc   r    rP   c                  ó   — e Zd ZdS )Ú
KeyWarningNr^   rb   r    r   rf   rf     rc   r    rf   c                  óB  ‡ — e Zd ZdZej        ZdZdZd2d3ˆ fd„Z	d„ Z
d	„ Zd4d5d„Zeed6d„¦   «         ¦   «         Zej        d7d„¦   «         Zed8d„¦   «         Zd9d„Zeddœd:d#„¦   «         Zed;d%„¦   «         Zddœd<d'„Zddœd=d+„Zd>d-„Zd?d.„Zd@d/„Z eeed0¬1¦  «        Zˆ xZS )AÚKeySignaturea&	  
    A KeySignature object specifies the signature to be used for a piece; it normally
    takes one argument: an `int` giving the number of sharps,
    or, if negative, the number of flats.

    If you are starting with the name of a key, see the :class:`~music21.key.Key` object.

    >>> A = key.KeySignature(3)
    >>> A
    <music21.key.KeySignature of 3 sharps>

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

    If you want to get a real Key, then use the :class:`~music21.key.Key` object instead:

    >>> illegal = key.KeySignature('c#')
    Traceback (most recent call last):
    music21.key.KeySignatureException: Cannot get a KeySignature from this
        "number" of sharps: 'c#'; did you mean to use a key.Key() object instead?

    >>> legal = key.Key('c#')
    >>> legal.sharps
    4
    >>> legal
    <music21.key.Key of c# minor>

    To set a non-traditional Key Signature, create a KeySignature object
    with `sharps=None`, and then set the `alteredPitches` list:

    >>> unusual = key.KeySignature(sharps=None)
    >>> unusual.alteredPitches = ['E-', 'G#']
    >>> unusual
    <music21.key.KeySignature of pitches: [E-, G#]>
    >>> unusual.isNonTraditional
    True

    To set a pitch as displayed in a particular octave, create a non-traditional
    KeySignature and then set pitches with octaves:

    >>> unusual = key.KeySignature(sharps=None)
    >>> unusual.alteredPitches = ['F#4']
    >>> unusual
    <music21.key.KeySignature of pitches: [F#4]>

    If the accidental applies to all octaves but is being displayed differently
    then you are done, but if you want them to apply only to the octave displayed
    in then set `.accidentalsApplyOnlyToOctave` to `True`:

    >>> unusual.accidentalsApplyOnlyToOctave
    False
    >>> unusual.accidentalsApplyOnlyToOctave = True

    **Equality**

    Two KeySignatures are equal if they pass all `super().__eq__` checks and
    their sharps are equal.  Currently, non-standard key signatures are not
    checked (this may change).

    >>> sharp2 = key.KeySignature(2)
    >>> flat4 = key.KeySignature(-4)
    >>> sharp2 == flat4
    False
    >>> sharp2 == key.KeySignature(2)
    True

    * Changed in v7: `sharps` defaults to 0 (key of no flats/sharps)
      rather than `None` for nontraditional keys.
    )rY   r   r   rY   ú
int | Nonec                ó  •—  t          ¦   «         j        di |¤Ž 	 |�)|t          |¦  «        k    rt          d|›d�dz   ¦  «        ‚n)# t          $ r}t          d|›d�dz   ¦  «        |‚d }~ww xY w|| _        d | _        d| _        d S )Nz8Cannot get a KeySignature from this "number" of sharps: z; z/did you mean to use a key.Key() object instead?Frb   )ÚsuperÚ__init__rJ   r]   Ú
ValueErrorÚ_sharpsÚ_alteredPitchesÚaccidentalsApplyOnlyToOctave)ÚselfrY   ÚkeywordsÚveÚ	__class__s       €r   rl   zKeySignature.__init__d  sØ   ø€ Ø�‰ŒÔÐ$Ð$˜8Ð$Ð$Ð$ð		ØÐ! vµ°V±´Ò'<Ð'<Ý+Ø[ÈvÐ[Ð[Ð[ØGñHñIô Ið Iøøõ ð 	ð 	ð 	Ý'ØWÈ6ÐWÐWÐWØCñDñô ð ðøøøøð	øøøð ˆŒð 8<ˆÔØ,1ˆÔ)Ð)Ð)s   œ+A Á
A.ÁA)Á)A.c                óä   — d}| j         }|€+dd                     d„ | j        D ¦   «         ¦  «        z   dz   }n9|dk    r|› d�}n-|dk    rd}n$|d	k    rd
}n|dk    rd}nt          |¦  «        › d�}|S )NÚ z
pitches: [z, c                ó,   — g | ]}t          |¦  «        ‘ŒS rb   ©rN   )Ú.0Úps     r   ú
<listcomp>z0KeySignature._strDescription.<locals>.<listcomp>  s   € Ð.SÐ.SÐ.S¸!­s°1©v¬vÐ.SÐ.SÐ.Sr    ú]r   z sharpsz1 sharpr   zno sharps or flatsr   z1 flatz flats)rY   ÚjoinÚalteredPitchesr*   )rq   ÚoutputÚnss      r   Ú_strDescriptionzKeySignature._strDescription{  s¢   € ØˆØŒ[ˆØˆ:Ø! D§I¢IÐ.SÐ.S¸tÔ?RÐ.SÑ.SÔ.SÑ$TÔ$TÑTÐWZÑZˆFˆFØ�!ŠVˆVØ�^�^�^ˆFˆFØ�1ŠWˆWØˆFˆFØ�1ŠWˆWØ)ˆFˆFØ�2ŠXˆXØˆFˆFå˜B™œÐ'Ð'Ð'ˆFØˆr    c                ó0   — d|                       ¦   «         z   S ©Nzof )r�   ©rq   s    r   Ú_reprInternalzKeySignature._reprInternalŒ  s   € Ø�t×+Ò+Ñ-Ô-Ñ-Ð-r    NrG   rH   Útonicc                óB  — | j         pd}|�!|�t          j        d|› �t          d¬¦  «         |€|€d}|€n|�ld„ t                               ¦   «         D ¦   «         }t          |¦  «        }	 |||z
           }n-# t          $ r }t          d| j         › d	|› �¦  «        |‚d}~ww xY wt          j
        t          |¦  «        }|                     ¦   «         }|t          vrt          d
|› d�¦  «        ‚t          |         }t          ||z
  ¦  «        }t          |j        |¦  «        S )a�  
        Return a `key.Key` object representing this KeySignature object as a key in the
        given mode or in the given tonic. If `mode` is None, and `tonic` is not provided,
        major is assumed. If both mode and tonic are provided, the tonic is ignored.

        >>> ks = key.KeySignature(2)
        >>> ks.asKey()
        <music21.key.Key of D major>
        >>> ks.asKey(mode='minor')
        <music21.key.Key of b minor>

        If `mode` is None, an attempt is made to solve for the mode:

        >>> ks.asKey(tonic='A')
        <music21.key.Key of A mixolydian>

        But will raise `KeyException` if an impossible solution is requested:

        >>> ks.asKey(tonic='D#')
        Traceback (most recent call last):
        music21.key.KeyException: Could not solve for mode from sharps=2, tonic=D#

        Ionian and Aeolian are supplied instead of major or minor when deriving mode in this way:

        >>> ks2 = key.KeySignature()
        >>> ks2.asKey()
        <music21.key.Key of C major>
        >>> ks2.asKey(tonic='C')
        <music21.key.Key of C ionian>

        * New in v7: `tonic` argument to solve for mode.
        r   Nzignoring provided tonic: r   )Ú
stacklevelr<   c                ó   — i | ]\  }}||“Œ	S rb   rb   )ry   ÚkÚvs      r   ú
<dictcomp>z&KeySignature.asKey.<locals>.<dictcomp>¶  s   € Ð JÐ JÐ J©$¨!¨Q  AÐ JÐ JÐ Jr    z%Could not solve for mode from sharps=z, tonic=zMode z is unknown)rY   ÚwarningsÚwarnrf   rW   Úitemsr[   ÚKeyErrorrP   ÚtÚcastrN   Úlowerr1   ÚKeyÚname)	rq   rG   r†   Ú
our_sharpsÚmajorSharpsToModeÚmajorSharpsÚkeÚsharpAlterationFromMajorÚpitchObjs	            r   ÚasKeyzKeySignature.asKey�  s_  € ðB ”[Ð% Aˆ
ØÐ Ð 1ÝŒMÐ=°eÐ=Ð=½zÐVWÐXÑXÔXÐXØˆ<˜E˜MØˆDØˆ<˜EÐ-Ø JÐ Jµ/×2GÒ2GÑ2IÔ2IÐ JÑ JÔ JÐÝ'¨Ñ.Ô.ˆKðbØ(¨°kÑ)AÔB��øÝð bð bð bÝ"ØX¸D¼KÐXÐXÐQVÐXÐXñZô ZØ_aðbøøøøðbøøøõ Œv•c˜4Ñ Ô ˆØ�zŠz‰|Œ|ˆØ•Ð&Ð&ÝÐ8 tÐ8Ð8Ð8Ñ9Ô9Ð9Ý#2°4Ô#8Ð å  Ð.FÑ!FÑGÔGˆå�8”= $Ñ'Ô'Ð's   Á*A6 Á6
B Â BÂB rI   úlist[pitch.Pitch]c                ó`  — | j         �| j         S g }| j        €|S | j        dk    rt          j        d¦  «        }| j        dk    r	 t	          | j        ¦  «        D ]I}|                     dd¬¦  «         t          j        |¦  «        }d|_        | 	                    |¦  «         ŒJnŠ| j        dk     rt          j        d¦  «        }t	          t          | j        ¦  «        ¦  «        D ]I}|                     d	d¬¦  «         t          j        |¦  «        }d|_        | 	                    |¦  «         ŒJ|S )
a´  
        Return or set a list of music21.pitch.Pitch objects that are altered by this
        KeySignature. That is, all Pitch objects that will receive an accidental.

        >>> a = key.KeySignature(3)
        >>> a.alteredPitches
        [<music21.pitch.Pitch F#>, <music21.pitch.Pitch C#>, <music21.pitch.Pitch G#>]
        >>> b = key.KeySignature(1)
        >>> b.alteredPitches
        [<music21.pitch.Pitch F#>]

        >>> c = key.KeySignature(9)
        >>> [str(p) for p in c.alteredPitches]
        ['F#', 'C#', 'G#', 'D#', 'A#', 'E#', 'B#', 'F##', 'C##']

        >>> d = key.KeySignature(-3)
        >>> d.alteredPitches
        [<music21.pitch.Pitch B->, <music21.pitch.Pitch E->, <music21.pitch.Pitch A->]

        >>> e = key.KeySignature(-1)
        >>> e.alteredPitches
        [<music21.pitch.Pitch B->]

        >>> f = key.KeySignature(-6)
        >>> [str(p) for p in f.alteredPitches]
        ['B-', 'E-', 'A-', 'D-', 'G-', 'C-']

        >>> g = key.KeySignature(-8)
        >>> [str(p) for p in g.alteredPitches]
        ['B-', 'E-', 'A-', 'D-', 'G-', 'C-', 'F-', 'B--']

        Non-standard, non-traditional key signatures can set their own
        altered pitches cache.

        >>> nonTrad = key.KeySignature(sharps=None)
        >>> nonTrad.alteredPitches = ['B-', 'F#', 'E-', 'G#']
        >>> nonTrad.alteredPitches
        [<music21.pitch.Pitch B->,
         <music21.pitch.Pitch F#>,
         <music21.pitch.Pitch E->,
         <music21.pitch.Pitch G#>]

        OMIT_FROM_DOCS

        Ensure at least something is provided when the user hasn't provided enough info:

        >>> nonTrad2 = key.KeySignature(sharps=None)
        >>> nonTrad2.alteredPitches
        []

        Nr   r7   é   r#   T©ÚinPlacer2   ÚP4)ro   rY   r   r&   r)   Ú	transposer$   r%   r'   Úappendr*   )rq   ÚpostÚpKeepr0   rz   s        r   r~   zKeySignature.alteredPitchesÇ  s+  € ðp ÔÐ+ØÔ'Ð'à"$ˆØŒ;ÐØˆKàŒ;˜Š?ˆ?Ý”K Ñ$Ô$ˆEØŒ{˜QŠˆØÝ˜4œ;Ñ'Ô'ð ð �Ø—’ ¨d�Ñ3Ô3Ð3Ý”M %Ñ(Ô(�Ø�”Ø—’˜A‘”��ð	ð Œ[˜1Š_ˆ_Ý”K Ñ$Ô$ˆEÝ�3˜tœ{Ñ+Ô+Ñ,Ô,ð ð �Ø—’ ¨d�Ñ3Ô3Ð3Ý”M %Ñ(Ô(�Ø�”Ø—’˜A‘”��àˆr    ÚnewAlteredPitchesú#list[str | pitch.Pitch | note.Note]ÚNonec                ó°  — |                       ¦   «          g }|D ]µ}t          |t          ¦  «        r(|                     t	          j        |¦  «        ¦  «         Œ?t          |t          j        ¦  «        r|                     |¦  «         Œot          |t          j        ¦  «        r,|                     t          j	        |j        ¦  «        ¦  «         Œ¶|| _
        d S ©N)Ú
clearCacherM   rN   r¤   r   r&   r   rO   r$   r%   ro   )rq   r§   ÚnewListrz   s       r   r~   zKeySignature.alteredPitches  sÁ   € ð 	�ŠÑÔÐØ%'ˆØ"ð 	7ð 	7ˆAÝ˜!�SÑ!Ô!ð 7Ø—’�uœ{¨1™~œ~Ñ.Ô.Ð.Ð.Ý˜A�uœ{Ñ+Ô+ð 7Ø—’˜qÑ!Ô!Ð!Ð!Ý˜A�tœyÑ)Ô)ð 7Ø—’�tœ}¨Q¬WÑ5Ô5Ñ6Ô6Ð6øØ&ˆÔÐÐr    Úboolc                ó&   — | j         €	| j        rdS dS )a¾  
        Returns bool if this is a non-traditional KeySignature:

        >>> g = key.KeySignature(3)
        >>> g.isNonTraditional
        False

        >>> g = key.KeySignature(sharps=None)
        >>> g.alteredPitches = [pitch.Pitch('E`')]
        >>> g.isNonTraditional
        True

        >>> g
        <music21.key.KeySignature of pitches: [E`]>

        >>> g.accidentalByStep('E')
        <music21.pitch.Accidental half-flat>
        NTF)rY   r~   r„   s    r   ÚisNonTraditionalzKeySignature.isNonTraditional(  s   € ð( Œ;Ð 4Ô#6ÐØ�4à�5r    rS   r   úpitch.Accidental | Nonec                óÈ   — t          | j        ¦  «        D ]L}|j                             ¦   «         |                     ¦   «         k    rt	          j        |j        ¦  «        c S ŒMdS )aN
  
        Given a step (C, D, E, F, etc.) return the accidental
        for that note in this key (using the natural minor for minor)
        or None if there is none.

        >>> g = key.KeySignature(1)
        >>> g.accidentalByStep('F')
        <music21.pitch.Accidental sharp>
        >>> g.accidentalByStep('G') is None
        True

        >>> f = key.KeySignature(-1)
        >>> bbNote = note.Note('B-5')
        >>> f.accidentalByStep(bbNote.step)
        <music21.pitch.Accidental flat>

        Fix a wrong note in F-major:

        >>> wrongBNote = note.Note('B#4')
        >>> if f.accidentalByStep(wrongBNote.step) != wrongBNote.pitch.accidental:
        ...    wrongBNote.pitch.accidental = f.accidentalByStep(wrongBNote.step)
        >>> wrongBNote
        <music21.note.Note B->

        Set all notes to the correct notes for a key using the
        note's Key Context.  Before:

        >>> s1 = stream.Stream()
        >>> s1.append(key.KeySignature(4))  # E-major or C-sharp-minor
        >>> s1.append(note.Note('C', type='half'))
        >>> s1.append(note.Note('E-', type='half'))
        >>> s1.append(key.KeySignature(-4))  # A-flat-major or F-minor
        >>> s1.append(note.Note('A', type='whole'))
        >>> s1.append(note.Note('F#', type='whole'))
        >>> #_DOCS_SHOW s1.show()

        .. image:: images/keyAccidentalByStep_Before.*
            :width: 400

        After:

        >>> for n in s1.notes:
        ...    n.pitch.accidental = n.getContextByClass(key.KeySignature).accidentalByStep(n.step)
        >>> #_DOCS_SHOW s1.show()

        .. image:: images/keyAccidentalByStep.*
            :width: 400

        OMIT_FROM_DOCS
        >>> s1.show('text')
        {0.0} <music21.key.KeySignature of 4 sharps>
        {0.0} <music21.note.Note C#>
        {2.0} <music21.note.Note E>
        {4.0} <music21.key.KeySignature of 4 flats>
        {4.0} <music21.note.Note A->
        {8.0} <music21.note.Note F>

        Test to make sure there are not linked accidentals (fixed bug 22 Nov. 2010)

        >>> nB1 = note.Note('B', type='whole')
        >>> nB2 = note.Note('B', type='whole')
        >>> s1.append(nB1)
        >>> s1.append(nB2)
        >>> for n in s1.notes:
        ...    n.pitch.accidental = n.getContextByClass(key.KeySignature).accidentalByStep(n.step)
        >>> (nB1.pitch.accidental, nB2.pitch.accidental)
        (<music21.pitch.Accidental flat>, <music21.pitch.Accidental flat>)
        >>> nB1.pitch.accidental.name = 'sharp'
        >>> (nB1.pitch.accidental, nB2.pitch.accidental)
        (<music21.pitch.Accidental sharp>, <music21.pitch.Accidental flat>)
        N)Úreversedr~   rS   r“   r$   r%   rT   )rq   rS   ÚthisAlterations      r   ÚaccidentalByStepzKeySignature.accidentalByStepA  sh   € õR ' tÔ':Ñ;Ô;ð 	@ð 	@ˆNØÔ"×(Ò(Ñ*Ô*¨d¯jªj©l¬lÒ:Ð:Ý”} ^Ô%>Ñ?Ô?Ð?Ð?Ð?ð ;ð ˆtr    Fr    rE   ÚTransposeTypesr¡   út.Literal[False]út.Selfc               ó   — d S r«   rb   ©rq   rE   r¡   s      r   r£   zKeySignature.transpose“  ó	   € ð
 	ˆr    út.Literal[True]c               ó   — d S r«   rb   rº   s      r   r£   zKeySignature.transposeš  r»   r    út.Self | Nonec               ó   — t          |t          j        ¦  «        r|}n1t          |t          j        ¦  «        r|}nt          j        |¦  «        }|st	          j        | ¦  «        }n| }|                     d¦  «        }|j        }|                     |¦  «        }t          |t          ¦  «        r4t          t          |¦  «        ¦  «        dk    r|                     ¦   «         }t          |¦  «        |_        |                     ¦   «          |s|S dS )aG  
        Transpose the KeySignature by the user-provided value.
        If the value is an integer, the transposition is treated
        in half steps. If the value is a string, any Interval string
        specification can be provided. Alternatively, a
        :class:`music21.interval.Interval` object can be supplied.

        >>> a = key.KeySignature(2)
        >>> a
        <music21.key.KeySignature of 2 sharps>
        >>> a.asKey('major')
        <music21.key.Key of D major>

        >>> b = a.transpose('p5')
        >>> b
        <music21.key.KeySignature of 3 sharps>
        >>> b.asKey('major')
        <music21.key.Key of A major>
        >>> b.sharps
        3

        >>> c = b.transpose('-m2')
        >>> c.asKey('major')
        <music21.key.Key of G# major>
        >>> c.sharps
        8

        >>> d = c.transpose('-a3')
        >>> d.asKey('major')
        <music21.key.Key of E- major>
        >>> d.sharps
        -3

        Transposition by semitone (or other chromatic interval)

        >>> c = key.KeySignature(0)
        >>> dFlat = c.transpose(1)
        >>> dFlat
        <music21.key.KeySignature of 5 flats>
        >>> d = dFlat.transpose(1)
        >>> d
        <music21.key.KeySignature of 2 sharps>
        >>> eFlat = d.transpose(1)
        >>> eFlat
        <music21.key.KeySignature of 3 flats>
        r<   é   N)rM   r
   r(   ÚGenericIntervalr$   r%   rœ   r†   r+   rJ   r*   r[   ÚgetEnharmonicrY   r¬   )rq   rE   r¡   r/   r¥   Úk1Úp1Úp2s           r   r£   zKeySignature.transpose¡  s  € õf �e�XÔ.Ñ/Ô/ð 	3ØˆKˆKÝ˜�xÔ7Ñ8Ô8ð 	3ØˆKˆKå"Ô+¨EÑ2Ô2ˆKàð 	Ý”= Ñ&Ô&ˆDˆDàˆDà�ZŠZ˜Ñ Ô ˆØŒXˆØ×'Ò'¨Ñ+Ô+ˆÝ�e�SÑ!Ô!ð 	$¥c­-¸Ñ*;Ô*;Ñ&<Ô&<¸qÒ&@Ð&@Ø×!Ò!Ñ#Ô#ˆBå# BÑ'Ô'ˆŒØ�ŠÑÔÐð ð 	ØˆKà�4r    rz   úpitch.Pitchúpitch.Pitch | Nonec               ót  — d}d}|j         }|st          j        |¦  «        }| j        dk    r|rdS |S | j        dk     r)t	          | j        ¦  «        }t          j        d¦  «        }n| j        }t          j        d¦  «        }t          |¦  «        D ]}|                     |d¬¦  «         Œ|�||_         |s|S dS )a9  
        Takes a pitch in C major and transposes it so that it has
        the same step position in the current key signature.

        Example: B is the leading tone in C major, so given
        a key signature of 3 flats, get the leading tone in E-flat major:

        >>> ks = key.KeySignature(-3)
        >>> p1 = pitch.Pitch('B')
        >>> p2 = ks.transposePitchFromC(p1)
        >>> p2.name
        'D'

        Original pitch is unchanged:

        >>> p1.name
        'B'

        >>> ks2 = key.KeySignature(2)
        >>> p2 = ks2.transposePitchFromC(p1)
        >>> p2.name
        'C#'

        For out of scale pitches the relationship still works; note also that
        original octave is preserved.

        >>> p3 = pitch.Pitch('G-4')
        >>> p4 = ks.transposePitchFromC(p3)
        >>> p4.nameWithOctave
        'B--4'

        If inPlace is True then the original pitch is
        modified and nothing is returned.

        >>> p5 = pitch.Pitch('C5')
        >>> ks.transposePitchFromC(p5, inPlace=True)
        >>> p5.nameWithOctave
        'E-5'
        Nr   r¢   r#   Tr    )	r'   r$   r%   rY   r*   r
   r(   r)   r+   )rq   rz   r¡   ÚtransIntervalÚ
transTimesÚoriginalOctaver0   s          r   ÚtransposePitchFromCz KeySignature.transposePitchFromCï  sá   € ðP ˆØˆ
àœˆØð 	!Ý”˜aÑ Ô ˆAàŒ;˜!ÒÐØð Ø�tØˆHØŒ[˜1Š_ˆ_Ý˜Tœ[Ñ)Ô)ˆJÝ$Ô-¨dÑ3Ô3ˆMˆMàœˆJÝ$Ô-¨dÑ3Ô3ˆMå�zÑ"Ô"ð 	:ð 	:ˆAØ×(Ò(¨°DÐ(Ñ9Ô9Ð9Ð9àÐ%Ø%ˆAŒHàð 	ØˆHà�4r    r<   c                ó¾   — |                       |¦  «        j        }|dv rt          j        |¦  «        S |dk    rt          j        |¦  «        S t          d|› �¦  «        ‚)a@  
        Return a :class:`music21.scale.Scale` object (or, actually, a subclass such as
        :class:`~music21.scale.MajorScale` or :class:`~music21.scale.MinorScale`) that is
        representative of this key signature and mode.

        Raises KeySignatureException if mode is not in [None, 'major', 'minor'].

        >>> ks = key.KeySignature(3)
        >>> ks
        <music21.key.KeySignature of 3 sharps>
        >>> ks.getScale('major')
        <music21.scale.MajorScale A major>
        >>> ks.getScale('minor')
        <music21.scale.MinorScale F# minor>
        )Nr<   r>   z0No mapping to a scale exists for this mode yet: )rœ   r†   r   Ú
MajorScaleÚ
MinorScaler]   )rq   rG   r›   s      r   ÚgetScalezKeySignature.getScale4  sf   € ð  —:’:˜dÑ#Ô#Ô)ˆØ�?Ð"Ð"ÝÔ# HÑ-Ô-Ð-Ø�WŠ_ˆ_ÝÔ# HÑ-Ô-Ð-å'Ð(aÐ[_Ð(aÐ(aÑbÔbÐbr    c                ó   — | j         S r«   )rn   r„   s    r   Ú
_getSharpszKeySignature._getSharpsO  s
   € ØŒ|Ðr    c                óV   — || j         k    r|| _         |                      ¦   «          d S d S r«   )rn   r¬   )rq   rE   s     r   Ú
_setSharpszKeySignature._setSharpsR  s4   € Ø�D”LÒ Ð Ø ˆDŒLØ�OŠOÑÔÐÐÐð !Ð r    a�  
        Get or set the number of sharps.  If the number is negative
        then it sets the number of flats.  Equivalent to musicxml's 'fifths'
        attribute.

        >>> ks1 = key.KeySignature(2)
        >>> ks1.sharps
        2
        >>> ks1.sharps = -4
        >>> ks1
        <music21.key.KeySignature of 4 flats>

        Can be set to None for a non-traditional key signature
        )Údoc)r   )rY   ri   )NN)rG   rH   r†   rH   )rI   r�   )r§   r¨   rI   r©   )rI   r®   )rS   r   rI   r±   ©rE   r¶   r¡   r·   rI   r¸   ©rE   r¶   r¡   r¼   rI   r©   ©rE   r¶   r¡   r®   rI   r¾   )rz   rÆ   rI   rÇ   )r<   )rI   ri   )rE   ri   )r_   r`   ra   Ú__doc__r   Ú	TextStyleÚ_styleClassÚequalityAttributesÚclassSortOrderrl   r�   r…   rœ   Úpropertyr   r~   Úsetterr°   rµ   r   r£   rÌ   rÐ   rÒ   rÔ   rY   Ú__classcell__©rt   s   @r   rh   rh     s"  ø€ € € € € ðEð EðL ”/€KØ$Ðð €Nð2ð 2ð 2ð 2ð 2ð 2ð 2ð.ð ð ð".ð .ð .ð6(ð 6(ð 6(ð 6(ð 6(ðp ØðOð Oð Oñ „[ñ „XðOðb Ôð'ð 'ð 'ñ Ôð'ð ðð ð ñ „Xðð0Nð Nð Nð Nðd ð /4ðð ð ð ð ñ „Xðð ðð ð ñ „Xðð #(ðLð Lð Lð Lð Lð Lð\ >Cð Cð Cð Cð Cð Cð CðJcð cð cð cð6ð ð ð ðð ð ð ð
 ˆX�j *ððñ ô €F€F€F€F€Fr    rh   c                  ó  ‡ — e Zd ZU dZdZdZded<   ded<   	 	 d'd(d
„Zd„ Zd„ Z	d„ Z
d„ Zed)d„¦   «         Zed)d„¦   «         Zed*d„¦   «         Zˆ fd„Zd„ Zd+d,d„Zeddœd-d „¦   «         Zed.d#„¦   «         Zddœd/ˆ fd&„Zˆ xZS )0r”   aä  
    Note that a key is a sort of hypothetical/conceptual object.
    It probably has a scale (or scales) associated with it and a :class:`~music21.key.KeySignature`,
    but not necessarily.

    A Key object has all the attributes of a KeySignature and all the attributes of a
    :class:`~music21.scale.DiatonicScale`.

    >>> cm = key.Key('c')  # lowercase = c minor.
    >>> cm
    <music21.key.Key of c minor>
    >>> cm.mode
    'minor'
    >>> cm.tonic
    <music21.pitch.Pitch C>

    >>> cm.sharps
    -3
    >>> cm.pitchFromDegree(3)
    <music21.pitch.Pitch E-4>
    >>> cm.pitchFromDegree(7)
    <music21.pitch.Pitch B-4>

    >>> cSharpMaj = key.Key('C#')  # uppercase = C# major
    >>> cSharpMaj
    <music21.key.Key of C# major>
    >>> cSharpMaj.sharps
    7

    >>> fFlatMaj = key.Key('F-')
    >>> fFlatMaj
    <music21.key.Key of F- major>
    >>> fFlatMaj.sharps
    -8
    >>> fFlatMaj.accidentalByStep('B')
    <music21.pitch.Accidental double-flat>

    >>> eDor = key.Key('E', 'dorian')
    >>> eDor
    <music21.key.Key of E dorian>
    >>> eDor.sharps
    2
    >>> eDor.pitches
    [<music21.pitch.Pitch E4>,
     <music21.pitch.Pitch F#4>,
     <music21.pitch.Pitch G4>,
     <music21.pitch.Pitch A4>,
     <music21.pitch.Pitch B4>,
     <music21.pitch.Pitch C#5>,
     <music21.pitch.Pitch D5>,
     <music21.pitch.Pitch E5>]

    If you prefer not to use uppercase and lowercase to distinguish major and minor,
    the shorthand of CM or Cm can also be used:

    >>> key.Key('EM')
    <music21.key.Key of E major>
    >>> key.Key('F#m')
    <music21.key.Key of f# minor>

    **Equality**

    Two Keys are equal if their tonics' names are equal, their sharps are equal,
    and their modes are equal (and they pass all superclass tests)

    >>> k = key.Key(pitch.Pitch('C4'))
    >>> k2 = key.Key(pitch.Pitch('C5'))
    >>> k == k2
    True
    >>> k.mode = 'minor'
    >>> k == k2
    False

    * Changed in v8: keys now compare equal regardless of the octave of their tonics.
    r   NrH   Ú_moderÆ   r†   r"   rF   c                óò  — t          |t          j        t          j        f¦  «        r|j        }n|}|€Xd|v rd}t          j        dd|¦  «        }nOd|v rd}t          j        dd|¦  «        }n2|                     ¦   «         |k    rd}nd}n|                     ¦   «         }t          ||¦  «        }t          |t          j        ¦  «        r|}n6t          |t          j        ¦  «        r|j        }nt          j        |¦  «        }t          j        | |fi |¤Ž t          j        j        | fd|i|¤Ž || _        || _        || _        | j        �| j                             | j        ¦  «         d | _        g | _        d S )NÚmr>   rv   ÚMr<   r†   )rM   r   rO   r   r&   r•   ÚreÚsubr“   r[   rh   rl   r   ÚDiatonicScaler†   ÚtyperG   Ú	_abstractÚbuildNetworkÚcorrelationCoefficientÚalternateInterpretations)rq   r†   rG   rr   ÚtonicStrrY   Ú
tonicPitchs          r   rl   zKey.__init__¸  s�  € õ �e�dœi­¬Ð5Ñ6Ô6ð 	Ø”zˆHˆHàˆHð ˆ<Ø�hˆˆØ�Ýœ6 # r¨8Ñ4Ô4��Ø˜��Ø�Ýœ6 # r¨8Ñ4Ô4��Ø—’Ñ!Ô! XÒ-Ð-Ø��à��à—:’:‘<”<ˆDå˜x¨Ñ.Ô.ˆå�e�Uœ[Ñ)Ô)ð 	/ØˆJˆJÝ˜�tœyÑ)Ô)ð 	/ØœˆJˆJåœ XÑ.Ô.ˆJåÔ˜d FÐ7Ð7¨hÐ7Ð7Ð7ÝÔÔ$ TÐHÐH°ÐH¸xÐHÐHÐHàˆŒ
ØˆŒ	ØˆŒ	ð Œ>Ð%ØŒN×'Ò'¨¬	Ñ2Ô2Ð2ð
 '+ˆÔ#ð 46ˆÔ%Ð%Ð%r    c                ó&   — dt          | ¦  «        z   S rƒ   rx   r„   s    r   r…   zKey._reprInternalì  s   € Ø•s˜4‘y”yÑ Ð r    c                ó(   — | j         }|› d| j        › �S )Nú )ÚtonicPitchNameWithCaserG   )rq   r†   s     r   Ú__str__zKey.__str__ï  s"   € ð Ô+ˆØÐ%Ð%˜$œ)Ð%Ð%Ð%r    c                ó�   — t                                | |¦  «        sdS | j        j        |j        j        k    o| j        |j        k    S )NF)rh   Ú__eq__r†   r•   rG   )rq   Úothers     r   r÷   z
Key.__eq__õ  sA   € Ý×"Ò" 4¨Ñ/Ô/ð 	Ø�5àŒzŒ %¤+Ô"2Ò2ÐN°t´yÀEÄJÒ7NÐNr    c                ó&   — t          | ¦  «        dz	  S )Né   )Úidr„   s    r   Ú__hash__zKey.__hash__û  s   € Ý�$‰xŒx˜1‰}Ðr    rI   c                óÊ   — | j         dvr| S | j         dk    r't          | j        ¦  «                             d¦  «        S t          | j        ¦  «                             d¦  «        S )an  
        if the Key is major or minor, return the relative minor or major.

        Otherwise, just returns self -- this is the best way to not have random crashes
        in the middle of large datasets.

        Note that this uses .sharps as a speedup, so if that has been changed, there
        will be a problem:

        >>> k = key.Key('E-')
        >>> k
        <music21.key.Key of E- major>
        >>> k.relative
        <music21.key.Key of c minor>
        >>> k.relative.relative
        <music21.key.Key of E- major>

        >>> key.Key('D', 'dorian').relative
        <music21.key.Key of D dorian>
        ©r>   r<   r<   r>   )rG   rh   rY   rœ   r„   s    r   ÚrelativezKey.relativeþ  s`   € ð, Œ9Ð.Ð.Ð.ØˆKàŒ9˜ÒÐÝ ¤Ñ,Ô,×2Ò2°7Ñ;Ô;Ð;å ¤Ñ,Ô,×2Ò2°7Ñ;Ô;Ð;r    c                ó‚   — | j         dvr| S | j         dk    rt          | j        d¦  «        S t          | j        d¦  «        S )aú  
        if the Key is major or minor, return the parallel minor or major.

        Otherwise, just returns self -- this is the best way to not have random crashes
        in the middle of large datasets.

        >>> k = key.Key('D')
        >>> k
        <music21.key.Key of D major>
        >>> k.parallel
        <music21.key.Key of d minor>
        >>> k.parallel.parallel
        <music21.key.Key of D major>

        >>> key.Key('D', 'dorian').parallel
        <music21.key.Key of D dorian>
        rþ   r<   r>   )rG   r”   r†   r„   s    r   ÚparallelzKey.parallel  sH   € ð& Œ9Ð.Ð.Ð.ØˆKàŒ9˜ÒÐÝ�t”z 7Ñ+Ô+Ð+å�t”z 7Ñ+Ô+Ð+r    rN   c                óœ   — | j         j        }| j        dk    r|                     ¦   «         }n| j        dk    r|                     ¦   «         }|S )aú  
        Return the pitch name as a string with the proper case (upper = major; lower = minor)

        Useful, but simple:

        >>> k = key.Key('c#')
        >>> k.tonicPitchNameWithCase
        'c#'
        >>> k = key.Key('B')
        >>> k.tonicPitchNameWithCase
        'B'
        >>> k.mode = 'minor'
        >>> k.tonicPitchNameWithCase
        'b'

        Anything else will return the default (capital)

        >>> k.mode = 'dorian'
        >>> k.tonicPitchNameWithCase
        'B'
        r<   r>   )r†   r•   rG   Úupperr“   )rq   rï   s     r   rô   zKey.tonicPitchNameWithCase7  sL   € ð. ”:”?ˆØŒ9˜ÒÐØ—~’~Ñ'Ô'ˆHˆHØŒY˜'Ò!Ð!Ø—~’~Ñ'Ô'ˆHØˆr    c                ó€   •— t          ¦   «                              ||¦  «        }| j        |_        d|_        g |_        |S )ai  
        Given a degree and pitchReference derive a new
        Key object that has the same mode but a different tonic

        Example: What minor key has scale degree 3 as B-flat?

        >>> minorKey = key.Key(mode='minor')
        >>> newMinor = minorKey.deriveByDegree(3, 'B-')
        >>> newMinor
        <music21.key.Key of g minor>

        Note that in minor, the natural form is used:

        >>> minorKey.deriveByDegree(7, 'E')
        <music21.key.Key of f# minor>
        >>> minorKey.deriveByDegree(6, 'G')
        <music21.key.Key of b minor>

        To use the harmonic form, change `.abstract` on the key to
        another abstract scale:

        >>> minorKey.abstract = scale.AbstractHarmonicMinorScale()
        >>> minorKey.deriveByDegree(7, 'E')
        <music21.key.Key of f minor>
        >>> minorKey.deriveByDegree(6, 'G')
        <music21.key.Key of b minor>

        Currently because of a limitation in bidirectional scale
        searching, melodic minor scales cannot be used as abstracts
        for deriving by degree.

        * New in v6: preserve mode in key.Key.deriveByDegree.
        N)rk   ÚderiveByDegreerG   rí   rî   )rq   ÚdegreeÚpitchRefÚretrt   s       €r   r  zKey.deriveByDegreeU  s?   ø€ õD ‰gŒg×$Ò$ V¨XÑ6Ô6ˆØ”9ˆŒð &*ˆÔ"Ø')ˆÔ$àˆ
r    c                óT  — | j         st          d¦  «        ‚g }|                     | j        ¦  «         | j         D ]$}|j        }|dk    r|                     |¦  «         Œ%t	          |¦  «        dk     r| j        dk    rdS | j        S |d         }|d         |d         z
  }|dz  |dz  z   S )NzDcannot process ambiguity without a list of .alternateInterpretationsr   r   g        r   )rî   r]   r¤   rí   r   )rq   ÚfocusÚsubKeyÚccÚabsMagnitudeÚ
leaderSpans         r   Ú%_tonalCertaintyCorrelationCoefficientz)Key._tonalCertaintyCorrelationCoefficient�  sÖ   € àÔ,ð 	XÝ'ØVñXô Xð XàˆØ�Š�TÔ0Ñ1Ô1Ð1ØÔ3ð 	!ð 	!ˆFØÔ.ˆBØ�AŠvˆvØ—’˜RÑ Ô Ð øÝˆu‰:Œ:˜Š>ˆ>ØÔ*¨aÒ/Ð/Ø�sàÔ2Ð2ð ˜Q”xˆð ˜1”X  a¤Ñ(ˆ
ð ˜qÑ  Z°!¡^Ñ4Ð4r    rí   Úfloatc                óZ   — |dk    r|                       ¦   «         S t          d|› �¦  «        ‚)al  
        Provide a measure of tonal ambiguity for Key
        determined with one of many methods.

        The `correlationCoefficient` assumes that the
        alternateInterpretations list has
        been filled from the use of a KeyWeightKeyAnalysis subclass.

        >>> littlePiece = converter.parse("tinyNotation: 4/4 c4 d e f g a b c' e' g' e' c'")
        >>> k = littlePiece.analyze('key')
        >>> k
        <music21.key.Key of C major>
        >>> k.tonalCertainty()
        1.1648...

        Three most likely alternateInterpretations:

        >>> k.alternateInterpretations[0:3]
        [<music21.key.Key of a minor>, <music21.key.Key of F major>, <music21.key.Key of d minor>]
        >>> k.correlationCoefficient
        0.9068...
        >>> k.alternateInterpretations[0].correlationCoefficient
        0.7778...

        least likely interpretation:

        >>> k.alternateInterpretations[-1]
        <music21.key.Key of F# major>

        Note that this method only exists if the key has come from an analysis method. Otherwise
        it raises a KeySignatureException

        >>> k2 = key.Key('b-')
        >>> k2.tonalCertainty()
        Traceback (most recent call last):
        music21.key.KeySignatureException: cannot process ambiguity without a
            list of .alternateInterpretations

        >>> k2.alternateInterpretations
        []
        rí   zUnknown method: )r  rm   )rq   Úmethods     r   ÚtonalCertaintyzKey.tonalCertainty�  s:   € ðT Ð-Ò-Ð-Ø×=Ò=Ñ?Ô?Ð?åÐ8°Ð8Ð8Ñ9Ô9Ð9r    Fr    rE   r¶   r¡   r·   r¸   c               ó   — d S r«   rb   rº   s      r   r£   zKey.transposeÌ  ó	   € ð 	ˆr    r¼   r©   c               ó   — d S r«   rb   rº   s      r   r£   zKey.transposeÔ  r  r    r®   r¾   c               ó  •— |du r&t          ¦   «                              ||¬¦  «         | }n#t          ¦   «                              ||¬¦  «        }|                     | j        ¦  «        }|j        |_        |                     ¦   «          |s|S dS )aç  
        Transpose the Key by the user-provided value.
        If the value is an integer, the transposition is treated
        in half steps. If the value is a string, any Interval string
        specification can be provided. Alternatively, a
        :class:`music21.interval.Interval` object can be supplied.

        >>> dMajor = key.Key('D')
        >>> dMajor
        <music21.key.Key of D major>

        >>> aMaj = dMajor.transpose('p5')
        >>> aMaj
        <music21.key.Key of A major>
        >>> aMaj.sharps
        3
        >>> aMaj.tonic
        <music21.pitch.Pitch A>
        >>> aMaj.mode
        'major'

        `inPlace=True` works here and returns None while changing the Key itself.

        >>> changingKey = key.Key('g')
        >>> changingKey
        <music21.key.Key of g minor>
        >>> changingKey.sharps
        -2
        >>> changingKey.transpose('m-3', inPlace=True)
        >>> changingKey
        <music21.key.Key of e minor>
        >>> changingKey.sharps
        1

        >>> changingKey.transpose(1, inPlace=True)
        >>> changingKey
        <music21.key.Key of f minor>
        >>> changingKey.sharps
        -4
        >>> changingKey.transpose(1, inPlace=True)
        >>> changingKey
        <music21.key.Key of f# minor>
        >>> changingKey.transpose(1, inPlace=True)
        >>> changingKey
        <music21.key.Key of g minor>
        >>> changingKey.transpose(1, inPlace=True)
        >>> changingKey
        <music21.key.Key of g# minor>
        Tr    N)rk   r£   rœ   rG   r†   r¬   )rq   rE   r¡   r¥   ÚpostKeyrt   s        €r   r£   zKey.transposeÜ  s�   ø€ ðl �dˆ?ˆ?Ý‰GŒG×Ò˜e¨WÐÑ5Ô5Ð5ØˆDˆDå‘7”7×$Ò$ U°GÐ$Ñ<Ô<ˆDà—*’*˜TœYÑ'Ô'ˆØ”]ˆŒ
Ø�ŠÑÔÐð ð 	ØˆKØˆtr    )r"   N)r†   rF   )rI   r”   )rI   rN   )rí   )rI   r  rÖ   r×   rØ   )r_   r`   ra   rÙ   rn   rã   Ú__annotations__rl   r…   rõ   r÷   rü   rÞ   rÿ   r  rô   r  r  r  r   r£   rà   rá   s   @r   r”   r”   h  sÞ  ø€ € € € € € ðJð JðV €GØ€EÐÐÐÑØÐÐÑð 58Øð26ð 26ð 26ð 26ð 26ðh!ð !ð !ð&ð &ð &ðOð Oð Oðð ð ð ð<ð <ð <ñ „Xð<ð: ð,ð ,ð ,ñ „Xð,ð4 ðð ð ñ „Xðð:)ð )ð )ð )ð )ðX5ð 5ð 5ð8-:ð -:ð -:ð -:ð -:ð^ ð /4ðð ð ð ð ñ „Xðð ðð ð ñ „Xðð #(ðCð Cð Cð Cð Cð Cð Cð Cð Cð Cð Cð Cr    r”   c                  ó,   — e Zd Zd„ Zd„ Zd„ Zd„ Zd„ ZdS )ÚTestc                óB   — ddl m}  || t          ¦   «         ¦  «         d S )Nr   )ÚtestCopyAll)Úmusic21.test.commonTestr  Úglobals)rq   r  s     r   ÚtestCopyAndDeepcopyzTest.testCopyAndDeepcopy%  s0   € Ø7Ð7Ð7Ð7Ð7Ð7Øˆ�D�'™)œ)Ñ$Ô$Ð$Ð$Ð$r    c                óX   — t          ¦   «         }|                      |j        d¦  «         d S )Nr   )rh   ÚassertEqualrY   )rq   Úas     r   Ú	testBasiczTest.testBasic)  s)   € Ý‰NŒNˆØ×Ò˜œ 1Ñ%Ô%Ð%Ð%Ð%r    c                óH  — ddl m} t          ¦   «         }t          j        d¦  «        }||_        |                      |j        |¦  «         |                     d¦  «                             ¦   «         }t          |¬¦  «        }|  	                    |j        j
        d¦  «         d S )Nr   )Úchordr7   z	Bb4 D5 F5©r†   r   )Úmusic21r&  r”   r   r&   r†   ÚassertIsÚChordÚrootr"  r•   )rq   r&  rŠ   r   Ú
b_flat_majs        r   ÚtestSetToniczTest.testSetTonic-  sš   € Ø!Ð!Ð!Ð!Ð!Ð!Ý‰EŒEˆõ ŒK˜ÑÔˆØˆŒØ�Š�a”g˜qÑ!Ô!Ð!ð —[’[ Ñ-Ô-×2Ò2Ñ4Ô4ˆ
Ý�jÐ!Ñ!Ô!ˆØ×Ò˜œœ tÑ,Ô,Ð,Ð,Ð,r    c                ó  — ddl m} ddl m} |                     d¦  «        }|                     d¦  «        }|                     d¬¦  «        }|                      d|cxk    od	k    nc ¦  «         |                     d
d¦  «        }|                     d¦  «        }|                     d¬¦  «        }|                      d|cxk    od	k    nc ¦  «         t          j        d¦  «        }t          j        d¦  «        }t          j        d¦  «        }t          j        d¦  «        }	| 	                    ¦   «         }|j
        D ])}
|                     t          j        |
¦  «        ¦  «         Œ*|                     d¦  «        }|                     d¬¦  «        }|                      d|cxk    od	k    nc ¦  «         | 	                    ¦   «         }|j
        |j
        z   |j
        z   |j
        z   D ])}
|                     t          j        |
¦  «        ¦  «         Œ*|                     d¦  «        }|                     d¬¦  «        }|                      d|cxk    od	k    nc ¦  «         | 	                    ¦   «         }|j
        |	j
        z   D ])}
|                     t          j        |
¦  «        ¦  «         Œ*|                     d¦  «        }|                     d¬¦  «        }|                      d|cxk    od	k    nc ¦  «         | 	                    ¦   «         }dD ])}
|                     t          j        |
¦  «        ¦  «         Œ*|                     d¦  «        }|                     d¬¦  «        }|                      d|cxk    od	k    nc ¦  «         d S )Nr   )Úcorpus)Ústreamzbwv66.6ÚKrumhanslSchmucklerrí   )r  r   gš™™™™™¹?zschoenberg/opus19rÀ   ÚgÚdr#  zf#)Úcr2  r4  r4  Úe)r(  r/  r0  ÚparseÚanalyzer  Ú
assertTruer   rÎ   ÚStreamÚpitchesr¤   r   rO   )rq   r/  r0  ÚsrŠ   ÚtaÚsc1Úsc2Úsc3Úsc5rz   s              r   ÚtestTonalAmbiguityAzTest.testTonalAmbiguityA<  ss  € Ø"Ð"Ð"Ð"Ð"Ð"Ø"Ð"Ð"Ð"Ð"Ð"ð
 �LŠL˜Ñ#Ô#ˆØ�IŠIÐ+Ñ,Ô,ˆØ×ÒÐ%=ÐÑ>Ô>ˆØ�Š˜˜B˜˜š˜ š˜˜˜Ñ%Ô%Ð%à�LŠLÐ,¨aÑ0Ô0ˆØ�IŠIÐ+Ñ,Ô,ˆØ×ÒÐ%=ÐÑ>Ô>ˆØ�Š˜˜B˜˜š˜ š˜˜˜Ñ%Ô%Ð%åÔ˜sÑ#Ô#ˆÝÔ˜sÑ#Ô#ˆÝÔ˜sÑ#Ô#ˆÝÔ˜tÑ$Ô$ˆà�MŠM‰OŒOˆØ”ð 	#ð 	#ˆAØ�HŠH•T”Y˜q‘\”\Ñ"Ô"Ð"Ð"Ø�IŠIÐ+Ñ,Ô,ˆØ×ÒÐ%=ÐÑ>Ô>ˆØ�Š˜˜B˜˜š˜ š˜˜˜Ñ%Ô%Ð%à�MŠM‰OŒOˆØ”˜sœ{Ñ*¨S¬[Ñ8¸3¼;ÑFð 	#ð 	#ˆAØ�HŠH•T”Y˜q‘\”\Ñ"Ô"Ð"Ð"Ø�IŠIÐ+Ñ,Ô,ˆØ×ÒÐ%=ÐÑ>Ô>ˆØ�Š˜˜B˜˜š˜ š˜˜˜Ñ%Ô%Ð%à�MŠM‰OŒOˆØ”˜sœ{Ñ*ð 	#ð 	#ˆAØ�HŠH•T”Y˜q‘\”\Ñ"Ô"Ð"Ð"Ø�IŠIÐ+Ñ,Ô,ˆØ×ÒÐ%=ÐÑ>Ô>ˆØ�Š˜˜B˜˜š˜ š˜˜˜Ñ%Ô%Ð%à�MŠM‰OŒOˆØ*ð 	#ð 	#ˆAØ�HŠH•T”Y˜q‘\”\Ñ"Ô"Ð"Ð"Ø�IŠIÐ+Ñ,Ô,ˆØ×ÒÐ%=ÐÑ>Ô>ˆØ�Š˜˜B˜˜š˜ š˜˜˜Ñ%Ô%Ð%Ð%Ð%r    c                ó<  — t          d¦  «        }|                     d d ¬¦  «        }|                      |j        d¦  «         |                      |j        d¦  «         |                     d¬¦  «        }|                      |j        d¦  «         |                      |j        d¦  «         d}|                      t          |¦  «        5 }|                     d	d¬¦  «        }d d d ¦  «         n# 1 swxY w Y   |                      |j        d	¦  «         |                      |j        d
¦  «         d}|                      t          |¦  «        5 }|                     d d¬¦  «        }d d d ¦  «         n# 1 swxY w Y   |  	                    |j
        j        t          ¦  «         d S )Nr   )rG   r†   r<   r4   r6   r'  r@   zignoring provided tonic: Er>   r   z0Could not solve for mode from sharps=2, tonic=A-zA-)rh   rœ   r"  rG   rô   ÚassertWarnsRegexrf   ÚassertRaisesRegexrP   ÚassertIsInstanceÚ	exceptionÚ	__cause__r�   )rq   ÚksrŠ   ÚexpectedÚcms        r   Ú	testAsKeyzTest.testAsKeys  sñ  € Ý˜!‰_Œ_ˆà�HŠH˜$ dˆHÑ+Ô+ˆØ×Ò˜œ Ñ)Ô)Ð)Ø×Ò˜Ô1°3Ñ7Ô7Ð7à�HŠH˜3ˆHÑÔˆØ×Ò˜œ Ñ*Ô*Ð*Ø×Ò˜Ô1°3Ñ7Ô7Ð7à/ˆØ×"Ò"¥:¨xÑ8Ô8ð 	2¸Bà—’˜g¨S�Ñ1Ô1ˆAð	2ð 	2ð 	2ñ 	2ô 	2ð 	2ð 	2ð 	2ð 	2ð 	2ð 	2øøøð 	2ð 	2ð 	2ð 	2ð 	×Ò˜œ Ñ)Ô)Ð)Ø×Ò˜Ô1°3Ñ7Ô7Ð7àEˆØ×#Ò#¥L°(Ñ;Ô;ð 	0¸rØ—’˜d¨$�Ñ/Ô/ˆAð	0ð 	0ð 	0ñ 	0ô 	0ð 	0ð 	0ð 	0ð 	0ð 	0ð 	0øøøð 	0ð 	0ð 	0ð 	0ð 	×Ò˜bœlÔ4µhÑ?Ô?Ð?Ð?Ð?s$   ÃC*Ã*C.Ã1C.ÅE,Å,E0Å3E0N)r_   r`   ra   r   r$  r-  rA  rK  rb   r    r   r  r  #  se   € € € € € ð%ð %ð %ð&ð &ð &ð-ð -ð -ð0&ð 0&ð 0&ðn@ð @ð @ð @ð @r    r  Ú__main__r«   )rE   rF   rG   rH   rI   rJ   )3rÙ   Ú
__future__r   r$   rç   Útypingr‘   r   Úunittestr�   r(  r   Úmusic21.common.decoratorsr   Úmusic21.common.typesr   r   r	   r
   r   r   r   r   ÚEnvironmentÚenvironLocalrJ   rN   r(   rÁ   r¶   r   r  r   r1   rQ   rW   r[   ÚMusic21Exceptionr]   rP   ÚWarningrf   ÚMusic21Objectrh   ré   r”   ÚTestCaser  Ú
_DOC_ORDERr_   ÚmainTestrb   r    r   ú<module>rZ     sB  ððð ð ð #Ð "Ð "Ð "Ð "Ð "à €€€Ø 	€	€	€	Ø Ð Ð Ð Ø Ð Ð Ð Ð Ð Ø €€€Ø €€€à Ð Ð Ð Ð Ð Ø 1Ð 1Ð 1Ð 1Ð 1Ð 1Ø )Ð )Ð )Ð )Ð )Ð )Ø Ð Ð Ð Ð Ð Ø  Ð  Ð  Ð  Ð  Ð  Ø Ð Ð Ð Ð Ð Ø Ð Ð Ð Ð Ð Ø Ð Ð Ð Ð Ð Ø Ð Ð Ð Ð Ð Ø Ð Ð Ð Ð Ð à&ˆ{Ô& uÑ-Ô-€à�S‘˜Ô*Ñ*¨8Ô+CÑC€ð
 /1Ð Ð 0Ð 0Ð 0Ñ 0ð$ð $ð $ðN<ð <ð <ðD 2€ØØØØ ØØ!ØØ!#Ø ð	ð 	€ð $(ð]ð ]ð ]ð ]ð ]ð@	ð 	ð 	ð 	ð 	˜LÔ9ñ 	ô 	ð 	ð	ð 	ð 	ð 	ð 	�<Ô0ñ 	ô 	ð 	ð	ð 	ð 	ð 	ð 	�ñ 	ô 	ð 	ð
Q	ð Q	ð Q	ð Q	ð Q	�4Ô%ñ Q	ô Q	ð Q	ðhwð wð wð wð wˆ,˜Ô+ñ wô wð wðvf@ð f@ð f@ð f@ð f@ˆ8Ôñ f@ô f@ð f@ðV ˜CÐ €
ð ˆzÒÐØ€N€N€NØ€GÔ�TÑÔÐÐÐð Ðr    