Your IP : 216.73.216.196
��VW> � @ s� d Z d d l m Z m Z m Z m Z d d l Z d d l m Z m Z d d l
m Z m Z d d l
m Z m Z d d l Z d Z d d � Z Gd
d � d e � Z d d
� Z d 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': '-.'}
� )�absolute_import�division�print_function�unicode_literalsN)�product�cycle)�zip�reduce)�mul�addz0.10.0c C s� | d k r t t | � � n i } | d k rB t t | � � n i } t | j � � } t | j � � } | | @r� t d � � | | BS)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)�left�rightZl_peekZr_peekZl_keyZr_key� r �7/opt/alt/python35/lib/python3.5/site-packages/cycler.py�
_process_keys7 s
$$
r c @ s e Z d Z d Z d d � Z d d d d � Z e d d � � Z d d
� Z d d � Z e
d
d � � Z d d � Z d d � Z
d d � Z d d � Z d d � Z d d � Z d d � Z d d � Z d d � Z d! d" � Z d# d$ � Z d% d& � Z e Z d' d( � Z d) d* � Z d S)+�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 : Cycler or None
The 'left' cycler
right : Cycler or None
The 'right' cycler
op : func or None
Function which composes the 'left' and 'right' cyclers.
c C s
t | � S)N)r )�selfr r r �__call__m s zCycler.__call__Nc C s� t | t � r0 t | j | j | j � | _ n. | d k rU d d � | D� | _ n d | _ t | t � r� t | j | j | j � | _ n. | d k r� d d � | D� | _ n d | _ t | j | j � | _ | | _ d S)z\Semi-private init
Do not use this directly, use `cycler` function instead.
Nc S s g | ] } t j | � � q Sr )�copy)�.0�vr r r �
<listcomp>z s z#Cycler.__init__.<locals>.<listcomp>c S s g | ] } t j | � � q Sr )r )r r r r r r � s )�
isinstancer �_left�_right�_opr �_keys)r r r �opr r r �__init__p s ! ! zCycler.__init__c C s
t | j � S)z2
The keys this Cycler knows about
)r r! )r r r r r � s z Cycler.keysc s � � k r d S� | j k r8 t d � � � f � � � | j k r` t d � � � f � � | j j � � | j j � � | j d k r� � | j j k r� | j j � � � nJ t | j t
� r� | j j � � � n" � � f d 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 %s with %s, %s is already a keyz)Can't replace %s with %s, %s is not a keyc s g | ] } � | � i � q Sr r )r �entry)�new�oldr r r � s z%Cycler.change_key.<locals>.<listcomp>) r! r �KeyError�remover r r �
change_keyr r r )r r& r% r )r% r& r r) � s
!zCycler.change_keyc c sU xN | j | j | j � D]4 \ } } t � } | j | � | j | � | Vq Wd S)z�
Compose the 'left' and 'right' components of this cycle
with the proper operation (zip or product as of now)
N)r r r �dict�update)r �a�b�outr r r �_compose� s
%
zCycler._composec sD | d � } t � f d d � | D� � | _ t � g � | _ | 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 : str
The property key.
itr : iterable
Finite length iterable of the property values.
Returns
-------
cycler : Cycler
New 'base' `Cycler`
Nc 3 s | ] } � | i Vq d S)Nr )r r )�labelr r � <genexpr>� s z$Cycler._from_iter.<locals>.<genexpr>)�listr r r! )�clsr0 �itr�retr )r0 r �
_from_iter� s "zCycler._from_iterc sT t � t � rD | j � } t t � f d d � t j | � D� � St d � � d S)Nc 3 s( | ] \ } } t | | � � Vq d S)N)�_cycler)r �kr )�keyr r r1 � s z%Cycler.__getitem__.<locals>.<genexpr>z+Can only use slices with Cycler.__getitem__)r �slice�by_keyr r �six� iteritemsr )r r9 �transr )r9 r � __getitem__� s
zCycler.__getitem__c C s3 | j d k r) t d d � | j D� � S| j � S)Nc s s | ] } t | � Vq d S)N)r* )r �lr r r r1 � s z"Cycler.__iter__.<locals>.<genexpr>)r r
r r/ )r r r r �__iter__� s zCycler.__iter__c C sL t | � t | � k r< t d j t | � t | � � � � t | | t � S)z�
Pair-wise combine two equal length cycles (zip)
Parameters
----------
other : Cycler
The second Cycler
z1Can only add equal length cycles, not {0} and {1})�lenr �formatr r )r �otherr r r �__add__� s zCycler.__add__c sk t � t � r t | � t � St � t � rc | j � } t t � f d d � t j | � D� � St Sd S)z�
Outer product of two cycles (`itertools.product`) or integer
multiplication.
Parameters
----------
other : Cycler or int
The second Cycler or integer
c 3 s( | ] \ } } t | | � � Vq d S)N)r7 )r r8 r )rD r r r1 s z!Cycler.__mul__.<locals>.<genexpr>N)
r r r �intr; r r r< r= �NotImplemented)r rD r> r )rD r �__mul__� s
zCycler.__mul__c C s | | S)Nr )r rD r r r �__rmul__ s zCycler.__rmul__c C s` t t t t i } | j d k r. t | j � St | j � } t | j � } | | j | | � S)N)r �minr r
r rB r r )r Zop_dictZl_lenZr_lenr r r �__len__ s
zCycler.__len__c C sp t | t � s t d � � t j | � } t | | � | _ | | _ t | _ t | j | j | j � | _ | S)z�
In-place pair-wise combine two equal length cycles (zip)
Parameters
----------
other : Cycler
The second Cycler
z"Cannot += with a non-Cycler object)
r r � TypeErrorr r r! r r r r )r rD �old_selfr r r �__iadd__ s zCycler.__iadd__c C sp t | t � s t d � � t j | � } t | | � | _ | | _ t | _ t | j | j | j � | _ | S)z�
In-place outer product of two cycles (`itertools.product`)
Parameters
----------
other : Cycler
The second Cycler
z"Cannot *= with a non-Cycler object)
r r rL r r r! r r r r )r rD rM r r r �__imul__& s zCycler.__imul__c C sP t | � t | � k r d S| j | j Ar0 d St d d � t | | � D� � S)z
Check equality
Fc s s! | ] \ } } | | k Vq d S)Nr )r r, r- r r r r1 B s z Cycler.__eq__.<locals>.<genexpr>)rB r �allr )r rD r r r �__eq__9 s
z
Cycler.__eq__c s� t d t d i } | j d k re | j j � � t � f d d � | D� � } d j d � d | � S| j | j d � } d } | j d
| j d | d | j � Sd S)
N�+�*c 3 s | ] } | � Vq d S)Nr )r r )�labr r r1 H s z"Cycler.__repr__.<locals>.<genexpr>zcycler({lab!r}, {itr!r})rT r4 �?z({left!r} {op} {right!r})r r" r )
r r r r �popr2 rC �getr r )r Zop_mapr4 r" �msgr )rT r �__repr__D s zCycler.__repr__c C s� d } t | j d t �} x$ | D] } | d j d | � 7} q" WxS t | � D]E } | d 7} x( | D] } | d j d | | � 7} qf W| d 7} qO W| d 7} | S) Nz<table>r9 z<th>{key!r}</th>z<tr>z<td>{val!r}</td>�valz</tr>z</table>)�sortedr �reprrC r
)r �outputZ sorted_keysr9 �dr8 r r r � _repr_html_O s
zCycler._repr_html_c C s] | j } t d d � | D� � } x4 | D], } x# | D] } | | j | | � q6 Wq) W| 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 s s | ] } | t � f Vq d S)N)r2 )r r8 r r r r1 s s z Cycler.by_key.<locals>.<genexpr>)r r* �append)r r r. r^ r8 r r r r; ] s
z
Cycler.by_keyc C s/ | j � } t t d d � t j | � D� � S)z�Simplify the Cycler
Returned as a composition using only sums (no multiplications)
Returns
-------
simple : Cycler
An equivalent cycler using only summationc s s$ | ] \ } } t | | � Vq d S)N)r7 )r r8 r r r r r1 � s z"Cycler.simplify.<locals>.<genexpr>)r; r r r< r= )r r> r r r �simplify} s zCycler.simplifyc C s
t | | � S)aF Concatenate this cycler and an other.
The keys must match exactly.
This returns a single Cycler which is equivalent to
`itertools.chain(self, other)`
Examples
--------
>>> num = cycler('a', range(3))
>>> let = cycler('a', 'abc')
>>> num.concat(let)
cycler('a', [0, 1, 2, 'a', 'b', 'c'])
Parameters
----------
other : `Cycler`
The `Cycler` to concatenate to this one.
Returns
-------
ret : `Cycler`
The concatenated `Cycler`
)�concat)r rD r r r rb � s z
Cycler.concat)�__name__�
__module__� __qualname__�__doc__r r# �propertyr r) r/ � classmethodr6 r? rA rE rH rI rK rN rO rQ rY r_ r; Z
_transposera rb r r r r r M s, # r c s� | j | j k r\ d j d d d g � j d | j | j @d | j | j A� } t | � � | j � � | j � � t t � � f d d � | j D� � S) a� Concatenate two cyclers.
The keys must match exactly.
This returns a single Cycler which is equivalent to
`itertools.chain(left, right)`
Examples
--------
>>> num = cycler('a', range(3))
>>> let = cycler('a', 'abc')
>>> num.concat(let)
cycler('a', [0, 1, 2, 'a', 'b', 'c'])
Parameters
----------
left, right : `Cycler`
The two `Cycler` instances to concatenate
Returns
-------
ret : `Cycler`
The concatenated `Cycler`
z
zKeys do not match:zIntersection: {both!r}zDisjoint: {just_one!r}ZbothZjust_onec 3 s* | ] } t | � | � | � Vq d S)N)r7 )r r8 )�_l�_rr r r1 � s zconcat.<locals>.<genexpr>)r �joinrC r r; r r )r r rX r )ri rj r rb � s rb c O s� | r | r t d � � t | � d k rW t | d t � sI t d � � t | d � St | � d k rs t | � St | � d k r� t d � � | r� t t d d � t j | � D� � St d � � d
S) 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
zBcyl() can only accept positional OR keyword arguments -- not both.� r zEIf 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 s s$ | ] \ } } t | | � Vq d S)N)r7 )r r8 r r r r r1 s zcycler.<locals>.<genexpr>z4Must have at least a positional OR keyword argumentsN) rL rB r r r7 r r r< r= )�args�kwargsr r r �cycler� s (
#rp c sq t | t � ra | j } t | � d k r< d } t | � � | j � � � f d d � | D� } t j | | � S)aI
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
rl z2Can not create Cycler from a multi-property Cyclerc 3 s | ] } | � Vq d S)Nr )r r )rT r r r1 , s z_cycler.<locals>.<genexpr>)r r r rB r rV r6 )r0 r4 r rX r )rT r r7 s r7 )rf �
__future__r r r r r< � itertoolsr r Z six.movesr r �operatorr
r r � __version__r �objectr rb rp r7 r r r r �<module>) s " � ` ( =