403Webshell
Server IP : 93.86.61.54  /  Your IP : 216.73.216.60
Web Server : Apache/2.4.62 (Ubuntu)
System : Linux rasin.ddns.net 6.8.0-124-generic #124~22.04.1-Ubuntu SMP PREEMPT_DYNAMIC Tue May 26 21:05:19 UTC x86_64
User : www-data ( 33)
PHP Version : 8.4.22
Disable Function : NONE
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : OFF  |  Sudo : ON  |  Pkexec : ON
Directory :  /lib/python3/dist-packages/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :

[ Back ]     

Current File : /lib/python3/dist-packages/__pycache__/cycler.cpython-310.pyc
o

�k{a�8�@sndZddlZddlmZddlmZmZddlmZm	Z	dZ
dd�Zd	d
�ZGdd�d�Z
d
d�Zdd�ZdS)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': '-.'}
�N)�reduce)�product�cycle)�mul�addz0.10.0cCs`|dur
tt|��ni}|durtt|��ni}t|���}t|���}||@r,td��||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�right�l_peek�r_peek�l_key�r_key�r�(/usr/lib/python3/dist-packages/cycler.py�
_process_keys4srcsZ|j|jkrtdj|j|j@|j|jAd���|���|���tt��fdd�|jD��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_onec3s&�|]}t|�|�|�VqdS�N��_cycler��.0�k��_l�_rrr�	<genexpr>es�$zconcat.<locals>.<genexpr>)r
r�format�by_keyrr)rr
rrr�concatKs

�r#c@s�eZdZdZdd�Zd+dd�Zdd�Zed	d
��Zdd�Z	e
d
d��Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd �Zd!d"�ZdZd#d$�Zd%d&�Zd'd(�ZeZd)d*�ZeZdS),�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.
    cCst|�Sr)r��selfrrr�__call__��zCycler.__call__NcCs�t|t�rt|j|j|j�|_n|durdd�|D�|_nd|_t|t�r0t|j|j|j�|_n|dur=dd�|D�|_nd|_t|j|j�|_||_dS)zf
        Semi-private init.

        Do not use this directly, use `cycler` function instead.
        NcS�g|]}t�|��qSr��copy�r�vrrr�
<listcomp>��z#Cycler.__init__.<locals>.<listcomp>cSr)rr*r,rrrr.�r/)�
isinstancer$�_left�_right�_opr�_keys)r&rr
�oprrr�__init__�s


zCycler.__init__cCs
||jvSr)r4)r&rrrr�__contains__��
zCycler.__contains__cCs
t|j�S)z!The keys this Cycler knows about.)r	r4r%rrrr
�s
zCycler.keyscs���krdS�|jvrtdj��d����|jvr"tdj��d���|j���|j���|jdurB�|jjvrB|j����dSt	|j
t�rQ|j
����dS��fdd�|j
D�|_
dS)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.
        Nz6Can't replace {old} with {new}, {new} is already a key)�old�newz2Can't replace {old} with {new}, {old} is not a keycsg|]}�|�i�qSrr)r�entry�r:r9rrr.�sz%Cycler.change_key.<locals>.<listcomp>)r4rr!�KeyError�removerr2r
�
change_keyr0r1r$)r&r9r:rr<rr?�s&	
��
�zCycler.change_keycs,|d�}t�fdd�|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 : str
            The property key.

        itr : iterable
            Finite length iterable of the property values.

        Returns
        -------
        `Cycler`
            New 'base' cycler.
        Nc3s�|]}�|iVqdSrrr,��labelrrr ���z$Cycler._from_iter.<locals>.<genexpr>)�listr1r4)�clsrA�itr�retrr@r�
_from_iter�szCycler._from_itercs6t�t�r|��}tt�fdd�|��D��Std��)Nc3s"�|]\}}t||��VqdSrr�rrr-��keyrrr ��� z%Cycler.__getitem__.<locals>.<genexpr>z+Can only use slices with Cycler.__getitem__)r0�slicer"rr�itemsr)r&rJ�transrrIr�__getitem__�s
zCycler.__getitem__ccsb�|jdur|jD]}t|�Vq	dS|�|j|j�D]\}}i}|�|�|�|�|VqdSr)r2r1�dictr3�update)r&r�a�b�outrrr�__iter__�s�

�

�zCycler.__iter__cCs8t|�t|�krtdt|��dt|�����t||t�S)z�
        Pair-wise combine two equal length cyclers (zip).

        Parameters
        ----------
        other : Cycler
        z&Can only add equal length cycles, not z and )�lenrr$�zip�r&�otherrrr�__add__�s��zCycler.__add__csHt�t�rt|�t�St�t�r"|��}tt�fdd�|��D��StS)z�
        Outer product of two cyclers (`itertools.product`) or integer
        multiplication.

        Parameters
        ----------
        other : Cycler or int
        c3s"�|]\}}t||��VqdSrrrH�rYrrr rKz!Cycler.__mul__.<locals>.<genexpr>)	r0r$r�intr"rrrM�NotImplemented)r&rYrNrr[r�__mul__s
	
zCycler.__mul__cCs||SrrrXrrr�__rmul__r(zCycler.__rmul__cCsDtttti}|jdurt|j�St|j�}t|j�}||j||�Sr)rW�minrrr2rVr1r3)r&�op_dict�l_len�r_lenrrr�__len__s



zCycler.__len__cC�Lt|t�s	td��t�|�}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)
r0r$�	TypeErrorr+rr4r1rWr3r2�r&rY�old_selfrrr�__iadd__#�

zCycler.__iadd__cCre)z�
        In-place outer product of two cyclers (`itertools.product`).

        Parameters
        ----------
        other : Cycler
        z"Cannot *= with a non-Cycler object)
r0r$rfr+rr4r1rr3r2rgrrr�__imul__5rjzCycler.__imul__cCs<t|�t|�kr
dS|j|jArdStdd�t||�D��S)NFcss�|]	\}}||kVqdSrr)rrRrSrrrr Ls�z Cycler.__eq__.<locals>.<genexpr>)rVr
�allrWrXrrr�__eq__Gs
z
Cycler.__eq__cCs
||kSrrrXrrr�__ne__Nr8z
Cycler.__ne__csntdtdi}|jdur$|j���t�fdd�|D��}d��d|�d�S|�|jd�}d	}|j|j	||jd
�S)N�+�*c3��|]}|�VqdSrrr,��labrrr WrBz"Cycler.__repr__.<locals>.<genexpr>zcycler(z, �)�?z({left!r} {op} {right!r}))rr5r
)
rWrr2r
�poprC�getr3r!r1)r&�op_maprEr5�msgrrrr�__repr__Ss

zCycler.__repr__cCstd}t|jtd�}|D]
}|d|�d�7}qt|�D]}|d7}|D]}|d||�d�7}q"|d7}q|d	7}|S)
Nz<table>rIz<th>z</th>z<tr>z<td>z</td>z</tr>z</table>)�sortedr
�reprr)r&�output�sorted_keysrJ�drrrr�_repr_html_^s
zCycler._repr_html_cCs>|j}dd�|D�}|D]}|D]}||�||�qq|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.
        cSsi|]}|t��qSr)rCrrrr�
<dictcomp>�sz!Cycler.by_key.<locals>.<dictcomp>)r
�append)r&r
rTrrrrrr"ls�z
Cycler.by_keycCs |��}ttdd�|��D��S)z�
        Simplify the cycler into a sum (but no products) of cyclers.

        Returns
        -------
        simple : Cycler
        cs��|]
\}}t||�VqdSrrrHrrrr ���z"Cycler.simplify.<locals>.<genexpr>)r"rrrM)r&rNrrr�simplify�s
zCycler.simplify)NN)�__name__�
__module__�__qualname__�__doc__r'r6r7�propertyr
r?�classmethodrGrOrUrZr^r_rdrirkrmrn�__hash__rzr�r"�
_transposer�r#rrrrr$hs6

$

r$cOs�|r|rtd��t|�dkrt|dt�std��t|d�St|�dkr)t|�St|�dkr3td��|rAttdd�|��D��Std	��)
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.�rzDIf 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.csr�rrrHrrrr �r�zcycler.<locals>.<genexpr>z4Must have at least a positional OR keyword arguments)rfrVr0r$rrrrM)�args�kwargsrrr�cycler�s&r�csNt|t�r!|j}t|�dkrd}t|��|����fdd�|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 Cyclerc3rqrrr,rrrrr �rBz_cycler.<locals>.<genexpr>)r0r$r
rVrrvrG)rArEr
ryrrrrr�s
r)r�r+�	functoolsr�	itertoolsrr�operatorrr�__version__rr#r$r�rrrrr�<module>s+9;

Youez - 2016 - github.com/yon3zu
LinuXploit