§
    áŽ’j‚C  ã                  ó€  — d Z ddlmZ ddlmZmZmZ ddlZddlm	Z	 ddl
mZmZ ddlmZmZ ddlmZmZmZmZmZmZmZmZmZ d	Z ed
e¬¦  «        Z ede¬¦  «        Z ed¦  «        Z ed¦  «        Zd'd„Zd(d„Z  G d„ deeef         ¦  «        Z!ed)d„¦   «         Z"ed*d!„¦   «         Z"ed+d$„¦   «         Z"d%„ Z"d+d&„Z#dS ),a’  
Cycler
======

Cycling through combinations of values, producing dictionaries.

You can add cyclers::

    from cycler import cycler
    cc = (cycler(color=list('rgb')) +
          cycler(linestyle=['-', '--', '-.']))
    for d in cc:
        print(d)

Results in::

    {'color': 'r', 'linestyle': '-'}
    {'color': 'g', 'linestyle': '--'}
    {'color': 'b', 'linestyle': '-.'}


You can multiply cyclers::

    from cycler import cycler
    cc = (cycler(color=list('rgb')) *
          cycler(linestyle=['-', '--', '-.']))
    for d in cc:
        print(d)

Results in::

    {'color': 'r', 'linestyle': '-'}
    {'color': 'r', 'linestyle': '--'}
    {'color': 'r', 'linestyle': '-.'}
    {'color': 'g', 'linestyle': '-'}
    {'color': 'g', 'linestyle': '--'}
    {'color': 'g', 'linestyle': '-.'}
    {'color': 'b', 'linestyle': '-'}
    {'color': 'b', 'linestyle': '--'}
    {'color': 'b', 'linestyle': '-.'}
é    )Úannotations)ÚHashableÚIterableÚ	GeneratorN)Úreduce)ÚproductÚcycle)ÚmulÚadd)	ÚTypeVarÚGenericÚCallableÚUnionÚDictÚListÚAnyÚoverloadÚcastz0.12.1ÚK)ÚboundÚLÚVÚUÚleftú#Cycler[K, V] | Iterable[dict[K, V]]Úrightú*Cycler[K, V] | Iterable[dict[K, V]] | NoneÚreturnúset[K]c                ó@  — | g k    rt          t          | ¦  «        ¦  «        ni }|�t          t          |¦  «        ¦  «        ni }t          |                     ¦   «         ¦  «        }t          |                     ¦   «         ¦  «        }||z  rt	          d¦  «        ‚||z  S )a  
    Helper function to compose cycler keys.

    Parameters
    ----------
    left, right : iterable of dictionaries or None
        The cyclers to be composed.

    Returns
    -------
    keys : set
        The keys in the composition of the two cyclers.
    Nz"Can not compose overlapping cycles)ÚnextÚiterÚsetÚkeysÚ
ValueError)r   r   Úl_peekÚr_peekÚl_keyÚr_keys         ú=C:\Projects\DSCons\.venv\Lib\site-packages\cycler\__init__.pyÚ_process_keysr+   >   s�   € ð" .2°RªZ¨Z��d 4™jœjÑ)Ô)Ð)¸R€FØ.3Ð.?��d 5™kœkÑ*Ô*Ð*ÀR€FÝ˜Ÿš™œÑ&Ô&€EÝ˜Ÿš™œÑ&Ô&€EØˆu�}ð ?ÝÐ=Ñ>Ô>Ð>Ø�5‰=Ðó    úCycler[K, V]úCycler[K, U]úCycler[K, V | U]c                óH  ‡‡— | j         |j         k    r>t          d                     | j         |j         z  | j         |j         z  ¬¦  «        ¦  «        ‚t          t          t
          t          t          t          t          f                  f         |  
                    ¦   «         ¦  «        Št          t          t
          t          t          t          t          f                  f         | 
                    ¦   «         ¦  «        Št          t          ˆˆfd„| j         D ¦   «         ¦  «        S )aS  
    Concatenate `Cycler`\s, as if chained using `itertools.chain`.

    The keys must match exactly.

    Examples
    --------
    >>> num = cycler('a', range(3))
    >>> let = cycler('a', 'abc')
    >>> num.concat(let)
    cycler('a', [0, 1, 2, 'a', 'b', 'c'])

    Returns
    -------
    `Cycler`
        The concatenated cycler.
    zBKeys do not match:
	Intersection: {both!r}
	Disjoint: {just_one!r})ÚbothÚjust_onec              3  óV   •K  — | ]#}t          |‰|         ‰|         z   ¦  «        V — Œ$d S ©N©Ú_cycler)Ú.0ÚkÚ_lÚ_rs     €€r*   ú	<genexpr>zconcat.<locals>.<genexpr>t   s9   øè è € ÐEÐE°a�  2 a¤5¨2¨a¬5¡=Ñ1Ô1ÐEÐEÐEÐEÐEÐEr,   )r$   r%   Úformatr   r   r   r   r   r   r   Úby_keyr   r   )r   r   r9   r:   s     @@r*   Úconcatr>   X   sß   øø€ ð$ „y�E”JÒÐÝð'ç'-¢vØ”Y ¤Ñ+°d´iÀ%Ä*Ñ6Lð (.ñ (ô (ñ
ô 
ð 	
õ 
�d•1•d�5¥¥A œ;Ô'Ð'Ô(¨$¯+ª+©-¬-Ñ	8Ô	8€BÝ	�d•1•d�5¥¥A œ;Ô'Ð'Ô(¨%¯,ª,©.¬.Ñ	9Ô	9€BÝ•#ÐEÐEÐEÐEÐE¸4¼9ÐEÑEÔEÑFÔFÐFr,   c                  ó4  — e Zd ZdZd„ Z	 	 d6d7d
„Zd„ Zed8d„¦   «         Zd9d„Z	e
d:d„¦   «         Zd;d„Zd<d„Zd=d!„Zed=d"„¦   «         Zed>d$„¦   «         Zd%„ Zed=d&„¦   «         Zed>d'„¦   «         Zd(„ Zd?d)„Zd@d*„ZdAd,„ZdBd/„ZdZdCd1„ZdCd2„ZdDd4„ZeZdEd5„ZeZdS )FÚCycleraó  
    Composable cycles.

    This class has compositions methods:

    ``+``
      for 'inner' products (zip)

    ``+=``
      in-place ``+``

    ``*``
      for outer products (`itertools.product`) and integer multiplication

    ``*=``
      in-place ``*``

    and supports basic slicing via ``[]``.

    Parameters
    ----------
    left, right : Cycler or None
        The 'left' and 'right' cyclers.
    op : func or None
        Function which composes the 'left' and 'right' cyclers.
    c                ó    — t          | ¦  «        S r4   )r	   ©Úselfs    r*   Ú__call__zCycler.__call__“   s   € Ý�T‰{Œ{Ðr,   Nr   r   r   úCycler[K, V] | NoneÚopr   c                ó‚  — t          |t          ¦  «        r&t          |j        |j        |j        ¦  «        | _        n|�d„ |D ¦   «         | _        ng | _        t          |t          ¦  «        r&t          |j        |j        |j        ¦  «        | _        nd| _        t          | j        | j        ¦  «        | _        || _        dS )zf
        Semi-private init.

        Do not use this directly, use `cycler` function instead.
        Nc                ó6   — g | ]}t          j         |¦  «        ‘ŒS © )Úcopy)r7   Úvs     r*   ú
<listcomp>z#Cycler.__init__.<locals>.<listcomp>¨   s    € Ð5Ð5Ð5¨1�$œ) A™,œ,Ð5Ð5Ð5r,   )Ú
isinstancer@   Ú_leftÚ_rightÚ_opr+   Ú_keys)rC   r   r   rF   s       r*   Ú__init__zCycler.__init__–   s¹   € õ �d�FÑ#Ô#ð 		Ý:@Ø”
˜DœK¨¬ñ;ô ;ˆDŒJˆJð Ðð 6Ð5°Ð5Ñ5Ô5ˆDŒJˆJàˆDŒJå�e�VÑ$Ô$ð 	Ý/5Ø”˜Uœ\¨5¬9ñ0ô 0ˆDŒKˆKð ˆDŒKå*¨4¬:°t´{ÑCÔCˆŒ
ØˆŒˆˆr,   c                ó   — || j         v S r4   )rQ   )rC   r8   s     r*   Ú__contains__zCycler.__contains__¶   s   € Ø�D”JˆÐr,   r   r   c                ó*   — t          | j        ¦  «        S )z!The keys this Cycler knows about.)r#   rQ   rB   s    r*   r$   zCycler.keys¹   s   € õ �4”:‰ŒÐr,   Úoldr   ÚnewÚNonec           	     ó  ‡‡— ‰‰k    rdS ‰| j         v rt          d‰› d‰› d‰› d�¦  «        ‚‰| j         vrt          d‰› d‰› d‰› d�¦  «        ‚| j                              ‰¦  «         | j                              ‰¦  «         | j        �+‰| j        j        v r| j                             ‰‰¦  «         dS t          | j	        t          ¦  «        r| j	                             ‰‰¦  «         dS ˆˆfd„| j	        D ¦   «         | _	        dS )a  
        Change a key in this cycler to a new name.
        Modification is performed in-place.

        Does nothing if the old key is the same as the new key.
        Raises a ValueError if the new key is already a key.
        Raises a KeyError if the old key isn't a key.
        NzCan't replace z with ú, z is already a keyz is not a keyc                ó$   •— g | ]}‰|‰         i‘ŒS rI   rI   )r7   ÚentryrW   rV   s     €€r*   rL   z%Cycler.change_key.<locals>.<listcomp>à   s"   ø€ ÐDÐDÐD°˜3  c¤
Ð+ÐDÐDÐDr,   )rQ   r%   ÚKeyErrorÚremover   rO   r$   Ú
change_keyrM   rN   r@   )rC   rV   rW   s    ``r*   r_   zCycler.change_key¾   sM  øø€ ð �#Š:ˆ:ØˆFØ�$”*ÐÐÝØI ÐIÐI¨CÐIÐI°3ÐIÐIÐIñô ð ð �d”jÐ Ð ÝØE ÐEÐE¨CÐEÐE°3ÐEÐEÐEñô ð ð 	Œ
×Ò˜#ÑÔÐØŒ
�Š�sÑÔÐàŒ;Ð" s¨d¬kÔ.>Ð'>Ð'>ØŒK×"Ò" 3¨Ñ,Ô,Ð,Ð,Ð,õ ˜œ
¥FÑ+Ô+ð 	EØŒJ×!Ò! # sÑ+Ô+Ð+Ð+Ð+ð
 EÐDÐDÐDÐD¸¼ÐDÑDÔDˆDŒJˆJˆJr,   ÚlabelÚitrúIterable[V]r-   c                ón   ‡—  | d¦  «        }t          ˆfd„|D ¦   «         ¦  «        |_        ‰h|_        |S )aª  
        Class method to create 'base' Cycler objects
        that do not have a 'right' or 'op' and for which
        the 'left' object is not another Cycler.

        Parameters
        ----------
        label : hashable
            The property key.

        itr : iterable
            Finite length iterable of the property values.

        Returns
        -------
        `Cycler`
            New 'base' cycler.
        Nc              3  ó    •K  — | ]}‰|iV — Œ	d S r4   rI   )r7   rK   r`   s     €r*   r;   z$Cycler._from_iter.<locals>.<genexpr>÷   s'   øè è € Ð1Ð1¨˜% ˜Ð1Ð1Ð1Ð1Ð1Ð1r,   )ÚlistrN   rQ   )Úclsr`   ra   Úrets    `  r*   Ú
_from_iterzCycler._from_iterâ   sD   ø€ ð(  ˜C ™IœIˆÝÐ1Ð1Ð1Ð1¨SÐ1Ñ1Ô1Ñ1Ô1ˆŒ	Ø�GˆŒ	Øˆ
r,   ÚkeyÚslicec                óÚ   ‡— t          ‰t          ¦  «        rG|                      ¦   «         }t          t          ˆfd„|                     ¦   «         D ¦   «         ¦  «        S t          d¦  «        ‚)Nc              3  óJ   •K  — | ]\  }}t          ||‰         ¦  «        V — Œd S r4   r5   )r7   r8   rK   ri   s      €r*   r;   z%Cycler.__getitem__.<locals>.<genexpr>ÿ   s5   øè è € ÐMÐM±t°q¸!¥¨¨1¨S¬6Ñ 2Ô 2ÐMÐMÐMÐMÐMÐMr,   z+Can only use slices with Cycler.__getitem__)rM   rj   r=   r   r   Úitemsr%   )rC   ri   Útranss    ` r*   Ú__getitem__zCycler.__getitem__û   s_   ø€ å�c�5Ñ!Ô!ð 	LØ—K’K‘M”MˆEÝ�#ÐMÐMÐMÐM¸u¿{º{¹}¼}ÐMÑMÔMÑNÔNÐNåÐJÑKÔKÐKr,   ú!Generator[dict[K, V], None, None]c              #  ó*  K  — | j         €| j        D ]}t          |¦  «        V — Œd S | j        €t	          d¦  «        ‚|                      | j        | j         ¦  «        D ]5\  }}i }|                     |¦  «         |                     |¦  «         |V — Œ6d S )Nz=Operation cannot be None when both left and right are defined)rO   rN   ÚdictrP   Ú	TypeErrorÚupdate)rC   r   ÚaÚbÚouts        r*   Ú__iter__zCycler.__iter__  s¼   è è € ØŒ;ÐØœ
ð !ð !�Ý˜4‘j”jÐ Ð Ð Ð ð!ð !ð ŒxÐÝØSñô ð ð Ÿš ¤¨T¬[Ñ9Ô9ð ð ‘��1Ø�Ø—
’
˜1‘”�Ø—
’
˜1‘”�Ø�	�	�	�	ð	ð r,   ÚotherúCycler[L, U]úCycler[K | L, V | U]c           
     óð  — t          | ¦  «        t          |¦  «        k    r/t          dt          | ¦  «        › dt          |¦  «        › �¦  «        ‚t          t          t          t          t
          t          f         t          t          t          f         f         | ¦  «        t          t          t          t
          t          f         t          t          t          f         f         |¦  «        t          ¦  «        S )z�
        Pair-wise combine two equal length cyclers (zip).

        Parameters
        ----------
        other : Cycler
        z&Can only add equal length cycles, not z and )
Úlenr%   r@   r   r   r   r   r   r   Úzip©rC   ry   s     r*   Ú__add__zCycler.__add__  s±   € õ ˆt‰9Œ9�˜E™
œ
Ò"Ð"ÝØU½¸T¹¼ÐUÐUÍÈUÉÌÐUÐUñô ð õ Ý•��a¥˜dœ¥U­1­a¨4¤[Ð0Ô1°4Ñ8Ô8Ý•��a¥˜dœ¥U­1­a¨4¤[Ð0Ô1°5Ñ9Ô9Ýñ
ô 
ð 	
r,   c                ó   — d S r4   rI   r   s     r*   Ú__mul__zCycler.__mul__$  ó   € àˆr,   Úintc                ó   — d S r4   rI   r   s     r*   r‚   zCycler.__mul__(  rƒ   r,   c           
     óD  ‡— t          ‰t          ¦  «        r¨t          t          t          t          t          t
          f         t          t          t          f         f         | ¦  «        t          t          t          t          t
          f         t          t          t          f         f         ‰¦  «        t          ¦  «        S t          ‰t          ¦  «        rG|  
                    ¦   «         }t          t          ˆfd„|                     ¦   «         D ¦   «         ¦  «        S t          S )z¬
        Outer product of two cyclers (`itertools.product`) or integer
        multiplication.

        Parameters
        ----------
        other : Cycler or int
        c              3  óD   •K  — | ]\  }}t          ||‰z  ¦  «        V — Œd S r4   r5   )r7   r8   rK   ry   s      €r*   r;   z!Cycler.__mul__.<locals>.<genexpr>>  s5   øè è € ÐFÐF±°°1•g˜a  U¡Ñ+Ô+ÐFÐFÐFÐFÐFÐFr,   )rM   r@   r   r   r   r   r   r   r   r„   r=   r   r   rm   ÚNotImplemented)rC   ry   rn   s    ` r*   r‚   zCycler.__mul__,  s×   ø€ õ �e�VÑ$Ô$ð 	"ÝÝ•V�E¥!¥Q $œK­­qµ!¨t¬Ð4Ô5°tÑ<Ô<Ý•V�E¥!¥Q $œK­­qµ!¨t¬Ð4Ô5°uÑ=Ô=Ýñô ð õ
 ˜�sÑ#Ô#ð 	"Ø—K’K‘M”MˆEÝÝÐFÐFÐFÐF¸¿º¹¼ÐFÑFÔFñô ð õ "Ð!r,   c                ó   — d S r4   rI   r   s     r*   Ú__rmul__zCycler.__rmul__C  rƒ   r,   c                ó   — d S r4   rI   r   s     r*   rŠ   zCycler.__rmul__G  rƒ   r,   c                ó   — | |z  S r4   rI   r   s     r*   rŠ   zCycler.__rmul__K  s   € Ø�e‰|Ðr,   c                óê   — t           t          t          t          i}| j        €t          | j        ¦  «        S t          | j        ¦  «        }t          | j        ¦  «        } || j                 ||¦  «        S r4   )r~   Úminr   r
   rO   r}   rN   rP   )rC   Úop_dictÚl_lenÚr_lens       r*   Ú__len__zCycler.__len__N  s\   € Ý>AÅ3ÍÕQTÐ=UˆØŒ;ÐÝ�t”z‘?”?Ð"Ý�D”J‘”ˆÝ�D”KÑ Ô ˆØ ˆw�t”xÔ  ¨Ñ.Ô.Ð.r,   c                ó  — t          |t          ¦  «        st          d¦  «        ‚t          j        | ¦  «        }t	          ||¦  «        | _        || _        t          | _        t          |j        |j	        |j        ¦  «        | _	        | S )zŠ
        In-place pair-wise combine two equal length cyclers (zip).

        Parameters
        ----------
        other : Cycler
        z"Cannot += with a non-Cycler object)
rM   r@   rs   rJ   r+   rQ   rN   r~   rP   rO   ©rC   ry   Úold_selfs      r*   Ú__iadd__zCycler.__iadd__X  sp   € õ ˜%¥Ñ(Ô(ð 	BÝÐ@ÑAÔAÐAå”9˜T‘?”?ˆÝ" 8¨UÑ3Ô3ˆŒ
ØˆŒ
ÝˆŒÝ˜Uœ[¨%¬,¸¼	ÑBÔBˆŒØˆr,   úCycler[K, V] | intc                ó  — t          |t          ¦  «        st          d¦  «        ‚t          j        | ¦  «        }t	          ||¦  «        | _        || _        t          | _        t          |j        |j	        |j        ¦  «        | _	        | S )zŒ
        In-place outer product of two cyclers (`itertools.product`).

        Parameters
        ----------
        other : Cycler
        z"Cannot *= with a non-Cycler object)
rM   r@   rs   rJ   r+   rQ   rN   r   rP   rO   r”   s      r*   Ú__imul__zCycler.__imul__j  sp   € õ ˜%¥Ñ(Ô(ð 	BÝÐ@ÑAÔAÐAå”9˜T‘?”?ˆÝ" 8¨UÑ3Ô3ˆŒ
ØˆŒ
ÝˆŒÝ˜Uœ[¨%¬,¸¼	ÑBÔBˆŒØˆr,   ÚobjectÚboolc                óä   — t          |t          ¦  «        sdS t          | ¦  «        t          |¦  «        k    rdS | j        |j        z  rdS t	          d„ t          | |¦  «        D ¦   «         ¦  «        S )NFc              3  ó(   K  — | ]\  }}||k    V — Œd S r4   rI   )r7   ru   rv   s      r*   r;   z Cycler.__eq__.<locals>.<genexpr>ƒ  s*   è è € Ð7Ð7™d˜a �1˜’6Ð7Ð7Ð7Ð7Ð7Ð7r,   )rM   r@   r}   r$   Úallr~   r   s     r*   Ú__eq__zCycler.__eq__|  sr   € Ý˜%¥Ñ(Ô(ð 	Ø�5Ýˆt‰9Œ9�˜E™
œ
Ò"Ð"Ø�5ØŒ9�u”zÑ!ð 	Ø�5ÝÐ7Ð7¥c¨$°Ñ&6Ô&6Ð7Ñ7Ô7Ñ7Ô7Ð7r,   Ústrc                ó*  ‡— t           dt          di}| j        €=| j                             ¦   «         Št          ˆfd„| D ¦   «         ¦  «        }d‰›d|›d�S |                     | j        d¦  «        }d}|                     | j	        || j        ¬	¦  «        S )
Nú+Ú*c              3  ó(   •K  — | ]}|‰         V — Œd S r4   rI   ©r7   rK   Úlabs     €r*   r;   z"Cycler.__repr__.<locals>.<genexpr>‹  s'   øè è € Ð,Ð, !�q˜”vÐ,Ð,Ð,Ð,Ð,Ð,r,   zcycler(rZ   ú)Ú?z({left!r} {op} {right!r}))r   rF   r   )
r~   r   rO   r$   Úpopre   ÚgetrP   r<   rN   )rC   Úop_mapra   rF   Úmsgr¦   s        @r*   Ú__repr__zCycler.__repr__‡  s™   ø€ Ý�s�G SÐ)ˆØŒ;ÐØ”)—-’-‘/”/ˆCÝÐ,Ð,Ð,Ð, tÐ,Ñ,Ô,Ñ,Ô,ˆCØ.˜SÐ.Ð. cÐ.Ð.Ð.Ð.à—’˜DœH cÑ*Ô*ˆBØ-ˆCØ—:’: 4¤:°"¸D¼K�:ÑHÔHÐHr,   c                óÆ   — d}t          | j        t          ¬¦  «        }|D ]}|d|›d�z  }Œt          | ¦  «        D ] }|dz  }|D ]}|d||         ›d�z  }Œ|dz  }Œ!|d	z  }|S )
Nz<table>)ri   z<th>z</th>z<tr>z<td>z</td>z</tr>z</table>)Úsortedr$   Úreprr"   )rC   ÚoutputÚsorted_keysri   Údr8   s         r*   Ú_repr_html_zCycler._repr_html_’  s§   € àˆÝ˜TœY­DÐ1Ñ1Ô1ˆØð 	*ð 	*ˆCØÐ)˜SÐ)Ð)Ð)Ñ)ˆFˆFÝ�d‘”ð 	ð 	ˆAØ�fÑˆFØ ð /ð /�ØÐ.  1¤Ð.Ð.Ð.Ñ.��Ø�gÑˆFˆFØ�*ÑˆØˆr,   údict[K, list[V]]c                ó‚   — | j         }d„ |D ¦   «         }| D ](}|D ]#}||                              ||         ¦  «         Œ$Œ)|S )aÝ  
        Values by key.

        This returns the transposed values of the cycler.  Iterating
        over a `Cycler` yields dicts with a single value for each key,
        this method returns a `dict` of `list` which are the values
        for the given key.

        The returned value can be used to create an equivalent `Cycler`
        using only `+`.

        Returns
        -------
        transpose : dict
            dict of lists of the values for each key.
        c                ó,   — i | ]}|t          ¦   «         “ŒS rI   )re   )r7   r8   s     r*   ú
<dictcomp>z!Cycler.by_key.<locals>.<dictcomp>¶  s   € Ð 9Ð 9Ð 9¨q ¥D¡F¤FÐ 9Ð 9Ð 9r,   )r$   Úappend)rC   r$   rw   r³   r8   s        r*   r=   zCycler.by_key   sc   € ð* ŒyˆØ 9Ð 9°DÐ 9Ñ 9Ô 9ˆàð 	$ð 	$ˆAØð $ð $�Ø�A”—’˜a œdÑ#Ô#Ð#Ð#ð$àˆ
r,   c                óŒ   — |                       ¦   «         }t          t          d„ |                     ¦   «         D ¦   «         ¦  «        S )z‡
        Simplify the cycler into a sum (but no products) of cyclers.

        Returns
        -------
        simple : Cycler
        c              3  ó<   K  — | ]\  }}t          ||¦  «        V — Œd S r4   r5   ©r7   r8   rK   s      r*   r;   z"Cycler.simplify.<locals>.<genexpr>Î  s.   è è € ÐDÐD©d¨a°�G A q™MœMÐDÐDÐDÐDÐDÐDr,   )r=   r   r   rm   )rC   rn   s     r*   ÚsimplifyzCycler.simplifyÀ  s8   € ð —’‘”ˆÝ•cÐDÐD°e·k²k±m´mÐDÑDÔDÑEÔEÐEr,   )NN)r   r   r   rE   rF   r   )r   r   )rV   r   rW   r   r   rX   ©r`   r   ra   rb   r   r-   )ri   rj   r   r-   )r   rp   )ry   rz   r   r{   )ry   r„   r   r-   )r   r„   )ry   r-   r   r-   )ry   r—   r   r-   )ry   rš   r   r›   )r   r    )r   rµ   )r   r-   )Ú__name__Ú
__module__Ú__qualname__Ú__doc__rD   rR   rT   Úpropertyr$   r_   Úclassmethodrh   ro   rx   r€   r   r‚   rŠ   r’   r–   r™   rŸ   Ú__hash__r­   r´   r=   Ú
_transposer½   r>   rI   r,   r*   r@   r@   w   sL  € € € € € ðð ð6ð ð ð &*Øð	ð ð ð ð ð@ð ð ð ðð ð ñ „Xðð"Eð "Eð "Eð "EðH ðð ð ñ „[ðð0Lð Lð Lð Lðð ð ð ð
ð 
ð 
ð 
ð$ ðð ð ñ „Xðð ðð ð ñ „Xðð"ð "ð "ð. ðð ð ñ „Xðð ðð ð ñ „Xððð ð ð/ð /ð /ð /ðð ð ð ð$ð ð ð ð$8ð 8ð 8ð 8ð €Hð	Ið 	Ið 	Ið 	Iðð ð ð ðð ð ð ð< €JðFð Fð Fð Fð  €F€F€Fr,   r@   Úargc                ó   — d S r4   rI   )rÇ   s    r*   ÚcyclerrÉ   Ó  ó   € à€Cr,   Úkwargsrb   úCycler[str, V]c                 ó   — d S r4   rI   )rË   s    r*   rÉ   rÉ   Ø  rÊ   r,   r`   ra   c                ó   — d S r4   rI   )r`   ra   s     r*   rÉ   rÉ   Ý  rÊ   r,   c                 óÌ  — | r|rt          d¦  «        ‚t          | ¦  «        dk    r?t          | d         t          ¦  «        st          d¦  «        ‚t          | d         ¦  «        S t          | ¦  «        dk    r	t	          | Ž S t          | ¦  «        dk    rt          d¦  «        ‚|r1t          t          d„ |                     ¦   «         D ¦   «         ¦  «        S t          d¦  «        ‚)	aë  
    Create a new `Cycler` object from a single positional argument,
    a pair of positional arguments, or the combination of keyword arguments.

    cycler(arg)
    cycler(label1=itr1[, label2=iter2[, ...]])
    cycler(label, itr)

    Form 1 simply copies a given `Cycler` object.

    Form 2 composes a `Cycler` as an inner product of the
    pairs of keyword arguments. In other words, all of the
    iterables are cycled simultaneously, as if through zip().

    Form 3 creates a `Cycler` from a label and an iterable.
    This is useful for when the label cannot be a keyword argument
    (e.g., an integer or a name that has a space in it).

    Parameters
    ----------
    arg : Cycler
        Copy constructor for Cycler (does a shallow copy of iterables).
    label : name
        The property key. In the 2-arg form of the function,
        the label can be any hashable object. In the keyword argument
        form of the function, it must be a valid python identifier.
    itr : iterable
        Finite length iterable of the property values.
        Can be a single-property `Cycler` that would
        be like a key change, but as a shallow copy.

    Returns
    -------
    cycler : Cycler
        New `Cycler` for the given property

    zEcycler() can only accept positional OR keyword arguments -- not both.é   r   zDIf only one positional argument given, it must be a Cycler instance.é   zdOnly a single Cycler can be accepted as the lone positional argument. Use keyword arguments instead.c              3  ó<   K  — | ]\  }}t          ||¦  «        V — Œd S r4   r5   r¼   s      r*   r;   zcycler.<locals>.<genexpr>  s.   è è € ÐEÐE©d¨a°�G A q™MœMÐEÐEÐEÐEÐEÐEr,   z4Must have at least a positional OR keyword arguments)rs   r}   rM   r@   r6   r   r   rm   )ÚargsrË   s     r*   rÉ   rÉ   â  sú   € ðL ð 
�ð 
ÝØSñ
ô 
ð 	
õ ˆ4�y„y�A‚~€~Ý˜$˜qœ'¥6Ñ*Ô*ð 	Ýð(ñô ð õ �d˜1”g‰ŒÐÝ	ˆT‰Œ�aŠˆÝ˜ˆ~ÐÝ	ˆT‰Œ�QŠˆÝðBñ
ô 
ð 	
ð
 ð GÝ•cÐEÐE°f·l²l±n´nÐEÑEÔEÑFÔFÐFå
ÐJÑ
KÔ
KÐKr,   c                óþ   ‡— t          |t          ¦  «        rM|j        }t          |¦  «        dk    rd}t	          |¦  «        ‚|                     ¦   «         Šˆfd„|D ¦   «         }t                               | |¦  «        S )aD  
    Create a new `Cycler` object from a property name and iterable of values.

    Parameters
    ----------
    label : hashable
        The property key.
    itr : iterable
        Finite length iterable of the property values.

    Returns
    -------
    cycler : Cycler
        New `Cycler` for the given property
    rÐ   z2Can not create Cycler from a multi-property Cyclerc              3  ó(   •K  — | ]}|‰         V — Œd S r4   rI   r¥   s     €r*   r;   z_cycler.<locals>.<genexpr>;  s'   øè è € Ð#Ð#˜!ˆq�ŒvÐ#Ð#Ð#Ð#Ð#Ð#r,   )rM   r@   r$   r}   r%   r©   rh   )r`   ra   r$   r¬   r¦   s       @r*   r6   r6   "  s|   ø€ õ  �#•vÑÔð 	$ØŒxˆÝˆt‰9Œ9˜Š>ˆ>ØFˆCÝ˜S‘/”/Ð!à�hŠh‰jŒjˆð $Ð#Ð#Ð#˜sÐ#Ñ#Ô#ˆå×Ò˜U CÑ(Ô(Ð(r,   )r   r   r   r   r   r   )r   r-   r   r.   r   r/   )rÇ   r-   r   r-   )rË   rb   r   rÌ   r¾   )$rÂ   Ú
__future__r   Úcollections.abcr   r   r   rJ   Ú	functoolsr   Ú	itertoolsr   r	   Úoperatorr
   r   Útypingr   r   r   r   r   r   r   r   r   Ú__version__r   r   r   r   r+   r>   r@   rÉ   r6   rI   r,   r*   ú<module>rÝ      s  ðð(ð (ðV #Ð "Ð "Ð "Ð "Ð "à 9Ð 9Ð 9Ð 9Ð 9Ð 9Ð 9Ð 9Ð 9Ð 9Ø €€€Ø Ð Ð Ð Ð Ð Ø $Ð $Ð $Ð $Ð $Ð $Ð $Ð $Ø Ð Ð Ð Ð Ð Ð Ð à UÐ UÐ UÐ UÐ UÐ UÐ UÐ UÐ UÐ UÐ UÐ UÐ UÐ UÐ UÐ UÐ UÐ UÐ UÐ UÐ UÐ Uà€à€GˆC�xÐ Ñ Ô €Ø€GˆC�xÐ Ñ Ô €Ø€GˆC�L„L€Ø€GˆC�L„L€ðð ð ð ð4Gð Gð Gð Gð>Yð Yð Yð Yð YˆW�Q˜�TŒ]ñ Yô Yð Yðx
 
ðð ð ñ 
„ðð 
ðð ð ñ 
„ðð 
ðð ð ñ 
„ðð=Lð =Lð =Lð@)ð )ð )ð )ð )ð )r,   