+
    iEA                    j   R t ^ RIHt ^ RIHtHtHt ^ RIt^ RIH	t	 ^ RI
HtHt ^ RIHtHt ^ RIHtHtHtHtHtHtHtHtHt Rt]! R	]R
7      t]! R]R
7      t]! R4      t]! R4      tR R ltR R lt  ! R R]]]3,          4      t!]R R l4       t"]R R l4       t"]R R l4       t"R t"R R lt#R# )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Uc               $    V ^8  d   QhRRRRRR/# )   leftz#Cycler[K, V] | Iterable[dict[K, V]]right*Cycler[K, V] | Iterable[dict[K, V]] | Nonereturnset[K] )formats   "o/Users/tonyclaw/.openclaw/workspace/skills/math-calculator/venv/lib/python3.14/site-packages/cycler/__init__.py__annotate__r#   >   s&      
-5     c                   V . 8w  d   \        \        V 4      4      M/ pVe   \        \        V4      4      M/ p\        VP                  4       4      p\        VP                  4       4      pWE,          '       d   \	        R4      hWE,          # )z
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.
z"Can not compose overlapping cycles)nextitersetkeys
ValueError)r   r   l_peekr_peekl_keyr_keys   &&    r"   _process_keysr/   >   sj    " .2RZd4j)RF.3.?d5k*RF&E&E}}=>>=r$   c               $    V ^8  d   QhRRRRRR/# )r   r   Cycler[K, V]r   zCycler[K, U]r   zCycler[K, V | U]r    )r!   s   "r"   r#   r#   X   s'     G G Gl G7G Gr$   c                V  aa V P                   VP                   8w  dS   \        RP                  V P                   VP                   ,          V P                   VP                   ,          R7      4      h\        \        \
        \        \        \        \        3,          ,          3,          V P                  4       4      o\        \        \
        \        \        \        \        3,          ,          3,          VP                  4       4      o\        \        VV3R lV P                    4       4      # )a  
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  f   <"   T F&  p\        VSV,          SV,          ,           4      x  K(  	  R # 5iN_cycler).0k_l_rs   & r"   	<genexpr>concat.<locals>.<genexpr>t   s'     E9a2a52a5=119s   .1)r)   r*   r!   r   r   r   r   r   r   r   by_keyr   r
   )r   r   r;   r<   s   &&@@r"   concatr@   X   s    $ yyEJJ''-vYY+dii%**6L (. (
 	
 
d1d5A;''($++-	8B	d1d5A;''(%,,.	9B#E499EFFr$   c                  b   ] tR t^wtRtR tR.R R lltR t]R R l4       t	R	 R
 lt
]R R l4       tR R ltR R ltR R lt]R R l4       t]R R l4       tR t]R R l4       t]R R l4       tR tR R ltR R  ltR! R" ltR# R$ ltRtR% R& ltR' R( ltR) R* lt]tR+ R, lt]tR-tR# )/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                	    \        V 4      # r6   )r   selfs   &r"   __call__Cycler.__call__   s    T{r$   Nc               $    V ^8  d   QhRRRRRR/# )r   r   r   r   zCycler[K, V] | Noneopr   r    )r!   s   "r"   r#   Cycler.__annotate__   s(      8 # 	r$   c                   \        V\        4      '       d2   \        VP                  VP                  VP                  4      V n        M7Ve-   V Uu. uF  p\
        P
                  ! V4      NK  	  upV n        M. V n        \        V\        4      '       d2   \        VP                  VP                  VP                  4      V n        MRV n        \        V P                  V P                  4      V n        W0n        R# u upi )zN
Semi-private init.

Do not use this directly, use `cycler` function instead.
N)
isinstancerB   _left_right_opcopyr/   _keys)rE   r   r   rI   vs   &&&& r"   __init__Cycler.__init__   s     dF##:@

DKK;DJ  1551$))A,5DJDJeV$$/5U\\5990DK DK*4::t{{C
 6s   C:c                	    WP                   9   # r6   )rQ   )rE   r:   s   &&r"   __contains__Cycler.__contains__   s    JJr$   c                   V ^8  d   QhRR/# )r   r   r   r    )r!   s   "r"   r#   rJ      s      f r$   c                ,    \        V P                  4      # )z!The keys this Cycler knows about.)r(   rQ   rD   s   &r"   r)   Cycler.keys   s     4::r$   c               $    V ^8  d   QhRRRRRR/# )r   oldr   newr   Noner    )r!   s   "r"   r#   rJ      s&     "E "Ea "Ea "ED "Er$   c           	     t   W8X  d   R# W P                   9   d   \        RV RV RV R24      hWP                   9  d   \        RV RV RV R24      hV P                   P                  V4       V P                   P	                  V4       V P
                  e8   WP
                  P                  9   d   V P
                  P                  W4       R# \        V P                  \        4      '       d   V P                  P                  W4       R# V P                   Uu. uF  q2W1,          /NK  	  upV n	        R# u upi )z
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 key)rQ   r*   KeyErrorremover
   rN   r)   
change_keyrL   rM   rB   )rE   r\   r]   entrys   &&& r"   rc   Cycler.change_key   s    :** VC53%7HI  jj  VC53%}E  	

#

s;;"skk.>.>'>KK""3, 

F++JJ!!#+
 :>D
+DDJDs   D5c               $    V ^8  d   QhRRRRRR/# r   labelr   itrIterable[V]r   r1   r    )r!   s   "r"   r#   rJ      s!      q { | r$   c                \   a V ! R4      p\        V3R lV 4       4      Vn        S0Vn        V# )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  ,   <"   T F	  pSV/x  K  	  R # 5ir6   r    )r9   rR   rh   s   & r"   r=   $Cycler._from_iter.<locals>.<genexpr>   s     1S%Ss   )listrM   rQ   )clsrh   ri   rets   &f& r"   
_from_iterCycler._from_iter   s.    (  I1S11	G	
r$   c                    V ^8  d   QhRRRR/# )r   keyslicer   r1   r    )r!   s   "r"   r#   rJ      s     L Lu L Lr$   c                	   a \        S\        4      '       d9   V P                  4       p\        \        V3R  lVP                  4        4       4      # \        R4      h)c              3  L   <"   T F  w  r\        WS,          4      x  K  	  R # 5ir6   r7   )r9   r:   rR   rt   s   &  r"   r=   %Cycler.__getitem__.<locals>.<genexpr>   s     M}tqS6 2 2}   !$z+Can only use slices with Cycler.__getitem__)rL   ru   r?   r   r
   itemsr*   )rE   rt   transs   &f r"   __getitem__Cycler.__getitem__   s@    c5!!KKME#Mu{{}MNNJKKr$   c                   V ^8  d   QhRR/# )r   r   z!Generator[dict[K, V], None, None]r    )r!   s   "r"   r#   rJ     s      ; r$   c              #  	N  "   V P                   f#   V P                   F  p\        V4      x  K  	  R # V P                  f   \	        R4      hV P                  V P                  V P                   4       F-  w  r#/ pVP                  V4       VP                  V4       Vx  K/  	  R # 5i)Nz=Operation cannot be None when both left and right are defined)rN   rM   dictrO   	TypeErrorupdate)rE   r   abouts   &    r"   __iter__Cycler.__iter__  s     ;;

4j  # xxS  T[[9

1

1		 :s   B#B%c                    V ^8  d   QhRRRR/# r   otherzCycler[L, U]r   zCycler[K | L, V | U]r    )r!   s   "r"   r#   rJ     s     
 
\ 
.B 
r$   c           
        \        V 4      \        V4      8w  d$   \        R\        V 4       R\        V4       24      h\        \        \        \        \
        \        3,          \        \        \        3,          3,          V 4      \        \        \        \
        \        3,          \        \        \        3,          3,          V4      \        4      # )zY
Pair-wise combine two equal length cyclers (zip).

Parameters
----------
other : Cycler
z&Can only add equal length cycles, not z and )
lenr*   rB   r   r   r   r   r   r   ziprE   r   s   &&r"   __add__Cycler.__add__  s     t9E
"8T5UU  adU1a4[0148adU1a4[0159
 	
r$   c                    V ^8  d   QhRRRR/# r   r    )r!   s   "r"   r#   rJ   %  s      \ .B r$   c                	    R # r6   r    r   s   &&r"   __mul__Cycler.__mul__$      r$   c                    V ^8  d   QhRRRR/# r   r   intr   r1   r    )r!   s   "r"   r#   rJ   )  s      S \ r$   c                	    R # r6   r    r   s   &&r"   r   r   (  r   r$   c           
       a \        S\        4      '       d   \        \        \        \        \        \
        3,          \        \        \        3,          3,          V 4      \        \        \        \        \
        3,          \        \        \        3,          3,          S4      \        4      # \        S\        4      '       d9   V P                  4       p\        \        V3R lVP                  4        4       4      # \        # )z|
Outer product of two cyclers (`itertools.product`) or integer
multiplication.

Parameters
----------
other : Cycler or int
c              3  L   <"   T F  w  r\        WS,          4      x  K  	  R # 5ir6   r7   )r9   r:   rR   r   s   &  r"   r=   !Cycler.__mul__.<locals>.<genexpr>>  s     FgaU++ry   )rL   rB   r   r   r   r   r   r   r   r   r?   r   r
   rz   NotImplemented)rE   r   r{   s   &f r"   r   r   ,  s     eV$$VE!Q$Kq!t45t<VE!Q$Kq!t45u= 
 s##KKMEFF  "!r$   c                    V ^8  d   QhRRRR/# r   r    )r!   s   "r"   r#   rJ   D  s      l /C r$   c                	    R # r6   r    r   s   &&r"   __rmul__Cycler.__rmul__C  r   r$   c                    V ^8  d   QhRRRR/# r   r    )r!   s   "r"   r#   rJ   H  s      c l r$   c                	    R # r6   r    r   s   &&r"   r   r   G  r   r$   c                	    W,          # r6   r    r   s   &&r"   r   r   K  s
    |r$   c                   V ^8  d   QhRR/# )r   r   r   r    )r!   s   "r"   r#   rJ   N  s     / / /r$   c                	    \         \        \        \        /pV P                  f   \        V P                  4      # \        V P                  4      p\        V P                  4      pWP                  ,          ! W#4      # r6   )r   minr   r	   rN   r   rM   rO   )rE   op_dictl_lenr_lens   &   r"   __len__Cycler.__len__N  sV    >A3QT=U;;tzz?"DJJDKK xx ..r$   c                    V ^8  d   QhRRRR/# )r   r   r1   r   r    )r!   s   "r"   r#   rJ   X  s      l | r$   c                   \        V\        4      '       g   \        R4      h\        P                  ! V 4      p\	        W!4      V n        W n        \        V n        \        VP                  VP                  VP                  4      V n	        V # )zb
In-place pair-wise combine two equal length cyclers (zip).

Parameters
----------
other : Cycler
z"Cannot += with a non-Cycler object)
rL   rB   r   rP   r/   rQ   rM   r   rO   rN   rE   r   old_selfs   && r"   __iadd__Cycler.__iadd__X  sc     %((@AA99T?"83

U[[%,,		Br$   c                    V ^8  d   QhRRRR/# )r   r   zCycler[K, V] | intr   r1   r    )r!   s   "r"   r#   rJ   j  s      0 \ r$   c                   \        V\        4      '       g   \        R4      h\        P                  ! V 4      p\	        W!4      V n        W n        \        V n        \        VP                  VP                  VP                  4      V n	        V # )zd
In-place outer product of two cyclers (`itertools.product`).

Parameters
----------
other : Cycler
z"Cannot *= with a non-Cycler object)
rL   rB   r   rP   r/   rQ   rM   r   rO   rN   r   s   && r"   __imul__Cycler.__imul__j  sc     %((@AA99T?"83

U[[%,,		Br$   c                    V ^8  d   QhRRRR/# )r   r   objectr   boolr    )r!   s   "r"   r#   rJ   |  s     8 8F 8t 8r$   c                	>   \        V\        4      '       g   R # \        V 4      \        V4      8w  d   R # V P                  VP                  ,          '       d   R # \        ;QJ d%    R \        W4       4       F  '       d   K   R # 	  R# ! R \        W4       4       4      # )Fc              3  .   "   T F  w  rW8H  x  K  	  R # 5ir6   r    )r9   r   r   s   &  r"   r=    Cycler.__eq__.<locals>.<genexpr>  s     7&6da16&6s   T)rL   rB   r   r)   allr   r   s   &&r"   __eq__Cycler.__eq__|  sn    %((t9E
"99uzz!!s7c$&67ss7s7s7c$&6777r$   c                   V ^8  d   QhRR/# r   r   strr    )r!   s   "r"   r#   rJ     s     	I 	I# 	Ir$   c                	:  a \         R \        R/pV P                  f;   V P                  P	                  4       o\        V3R lV  4       4      pRS: RV: R2# VP                  V P                  R4      pRpVP                  V P                  W0P                  R7      # )	+*c              3  4   <"   T F  qS,          x  K  	  R # 5ir6   r    r9   rR   labs   & r"   r=   "Cycler.__repr__.<locals>.<genexpr>  s     ,t!vvt   zcycler(r`   )?z({left!r} {op} {right!r}))r   rI   r   )
r   r   rN   r)   poprn   getrO   r!   rM   )rE   op_mapri   rI   msgr   s   &    @r"   __repr__Cycler.__repr__  s    sGS);;))--/C,t,,CSG2cWA..DHHc*B-C::4::"KK:HHr$   c                   V ^8  d   QhRR/# r   r    )r!   s   "r"   r#   rJ     s      S r$   c                	   R p\        V P                  \        R7      pV F  pVRV: R2,          pK  	  \        V 4       F2  pVR,          pV F  pVRWE,          : R2,          pK  	  VR,          pK4  	  VR,          pV# )	z<table>)rt   z<th>z</th>z<tr>z<td>z</td>z</tr>z</table>)sortedr)   reprr'   )rE   outputsorted_keysrt   dr:   s   &     r"   _repr_html_Cycler._repr_html_  s    TYYD1CSG5))F dAfF D.. !gF	 
 	*r$   c                   V ^8  d   QhRR/# )r   r   zdict[K, list[V]]r    )r!   s   "r"   r#   rJ     s      ( r$   c                    V P                   pV Uu/ uF  q"\        4       bK  	  ppV  F)  pV F   pW2,          P                  WB,          4       K"  	  K+  	  V# u upi )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.
)r)   rn   append)rE   r)   r:   r   r   s   &    r"   r?   Cycler.by_key  sU    * yy48 9DqDFD 9Aad#   
 !:s   Ac                   V ^8  d   QhRR/# )r   r   r1   r    )r!   s   "r"   r#   rJ     s     F F, Fr$   c                l    V P                  4       p\        \        R VP                  4        4       4      # )z_
Simplify the cycler into a sum (but no products) of cyclers.

Returns
-------
simple : Cycler
c              3  <   "   T F  w  r\        W4      x  K  	  R # 5ir6   r7   r9   r:   rR   s   &  r"   r=   "Cycler.simplify.<locals>.<genexpr>  s     DmdaGAMMm   )r?   r   r
   rz   )rE   r{   s   & r"   simplifyCycler.simplify  s(     cDekkmDEEr$   )rQ   rM   rO   rN   )NN)__name__
__module____qualname____firstlineno____doc__rF   rS   rV   propertyr)   rc   classmethodrq   r|   r   r   r   r   r   r   r   r   r   __hash__r   r   r?   
_transposer   r@   __static_attributes__r    r$   r"   rB   rB   w   s    6@  "EH  0L
$    ".    /$$8 H	I< JF  Fr$   rB   c                    V ^8  d   QhRRRR/# )r   argr1   r   r    )r!   s   "r"   r#   r#     s        r$   c                    R # r6   r    )r   s   &r"   cyclerr         r$   c                    V ^8  d   QhRRRR/# )r   kwargsrj   r   zCycler[str, V]r    )r!   s   "r"   r#   r#     s      [ ^ r$   c                     R # r6   r    )r   s   ,r"   r   r     r   r$   c               $    V ^8  d   QhRRRRRR/# rg   r    )r!   s   "r"   r#   r#     s!      ! + , r$   c                    R # r6   r    )rh   ri   s   &&r"   r   r     r   r$   c                    V '       d   V'       d   \        R4      h\        V 4      ^8X  d;   \        V ^ ,          \        4      '       g   \        R4      h\        V ^ ,          4      # \        V 4      ^8X  d
   \	        V !  # \        V 4      ^8  d   \        R4      hV'       d&   \        \        R VP                  4        4       4      # \        R4      h)aw  
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.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  <   "   T F  w  r\        W4      x  K  	  R # 5ir6   r7   r   s   &  r"   r=   cycler.<locals>.<genexpr>  s     EndaGAMMnr   z4Must have at least a positional OR keyword arguments)r   r   rL   rB   r8   r   r
   rz   )argsr   s   *,r"   r   r     s    L S
 	
 4yA~$q'6**(  d1g	Ta~	TQB
 	

 cEfllnEFF
J
KKr$   c               $    V ^8  d   QhRRRRRR/# rg   r    )r!   s   "r"   r#   r#   "  s!     ) )1 ); )< )r$   c                   a \        V\        4      '       dF   VP                  p\        V4      ^8w  d   Rp\	        V4      hVP                  4       oV3R lV 4       p\        P                  W4      # )a  
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
z2Can not create Cycler from a multi-property Cyclerc              3  4   <"   T F  qS,          x  K  	  R # 5ir6   r    r   s   & r"   r=   _cycler.<locals>.<genexpr>;  s     #s!vvsr   )rL   rB   r)   r   r*   r   rq   )rh   ri   r)   r   r   s   &&  @r"   r8   r8   "  s]      #vxxt9>FCS/!hhj $s#U((r$   )$r   
__future__r   collections.abcr   r   r   rP   	functoolsr   	itertoolsr   r   operatorr	   r
   typingr   r   r   r   r   r   r   r   r   __version__r   r   r   r   r/   r@   rB   r   r8   r    r$   r"   <module>r     s   (V # 9 9   $  U U UCx Cx CLCL4G>YWQT] Yx
 
 
 
 
 
 
=L@)r$   