Gecko [ beriskala.com ]

Name	Size	Permission	Date
CXX	[ DIR ]	drwxr-xr-x	2026-05-01 04:25
Cerberus-1.1-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:25
PyJWT-1.6.4-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:25
PyMySQL-0.7.11-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:25
SentryLogs-0.3.0-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:22
__pycache__	[ DIR ]	drwxr-xr-x	2026-05-01 04:25
aiodns	[ DIR ]	drwxr-xr-x	2026-05-01 04:22
aiodns-2.0.0-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:22
aioredis	[ DIR ]	drwxr-xr-x	2026-05-01 04:23
aioredis-1.1.0-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:23
asn1crypto	[ DIR ]	drwxr-xr-x	2026-05-01 04:21
asn1crypto-0.22.0-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:21
async_timeout	[ DIR ]	drwxr-xr-x	2026-05-01 04:20
async_timeout-1.3.0-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:20
attr	[ DIR ]	drwxr-xr-x	2026-05-01 04:20
attrs-17.4.0-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:20
blinker	[ DIR ]	drwxr-xr-x	2026-05-01 04:25
blinker-1.4-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:25
cached_property-1.3.0-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:21
captcha	[ DIR ]	drwxr-xr-x	2026-05-01 04:23
captcha-0.2.1-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:23
cerberus	[ DIR ]	drwxr-xr-x	2026-05-01 04:25
certifi	[ DIR ]	drwxr-xr-x	2026-05-01 04:20
certifi-2018.4.16-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:20
chardet	[ DIR ]	drwxr-xr-x	2026-05-01 04:20
chardet-3.0.4-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:20
click	[ DIR ]	drwxr-xr-x	2026-05-01 04:21
click-6.6-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:21
contextlib2-0.5.4-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:25
cryptography_vectors	[ DIR ]	drwxr-xr-x	2026-05-01 04:25
cryptography_vectors-1.9-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:25
cycler-0.10.0-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:23
daemon	[ DIR ]	drwxr-xr-x	2026-05-01 04:22
dateutil	[ DIR ]	drwxr-xr-x	2026-05-01 04:20
docutils	[ DIR ]	drwxr-xr-x	2026-05-01 04:25
fasteners	[ DIR ]	drwxr-xr-x	2026-05-01 04:23
fasteners-0.14.1-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:23
funcsigs	[ DIR ]	drwxr-xr-x	2026-05-01 04:21
funcsigs-1.0.2-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:21
geoip2	[ DIR ]	drwxr-xr-x	2026-05-01 04:22
geoip2-2.4.2-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:22
google	[ DIR ]	drwxr-xr-x	2026-05-01 04:22
google_apputils-0.4.2-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:22
humanize	[ DIR ]	drwxr-xr-x	2026-05-01 04:25
humanize-0.5.1-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:25
idna	[ DIR ]	drwxr-xr-x	2026-05-01 04:19
idna-2.5-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:19
idna_ssl-1.0.1-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:20
ipaddress-1.0.18-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:25
joblib	[ DIR ]	drwxr-xr-x	2026-05-01 04:22
joblib-0.10.3-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:22
jsonschema	[ DIR ]	drwxr-xr-x	2026-05-01 04:23
jsonschema-3.0.1-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:23
jwt	[ DIR ]	drwxr-xr-x	2026-05-01 04:25
lockfile	[ DIR ]	drwxr-xr-x	2026-05-01 04:21
lockfile-0.12.2-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:21
mock	[ DIR ]	drwxr-xr-x	2026-05-01 04:21
mock-2.0.0-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:21
nose	[ DIR ]	drwxr-xr-x	2026-05-01 04:21
nose-1.3.7-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:21
packaging	[ DIR ]	drwxr-xr-x	2026-05-01 04:21
packaging-16.8-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:21
pbr	[ DIR ]	drwxr-xr-x	2026-05-01 04:21
pbr-1.8.1-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:21
peewee_migrate	[ DIR ]	drwxr-xr-x	2026-05-01 04:22
peewee_migrate-0.6.4-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:22
pip	[ DIR ]	drwxr-xr-x	2026-04-30 23:38
pip-20.2.4.dist-info	[ DIR ]	drwxr-xr-x	2026-04-30 23:38
pkg_resources	[ DIR ]	drwxr-xr-x	2026-04-30 23:38
ply	[ DIR ]	drwxr-xr-x	2026-05-01 04:21
ply-3.8-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:21
pycparser	[ DIR ]	drwxr-xr-x	2026-05-01 04:21
pycparser-2.14-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:21
pyflakes	[ DIR ]	drwxr-xr-x	2026-05-01 04:25
pyflakes-1.5.0-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:25
pymysql	[ DIR ]	drwxr-xr-x	2026-05-01 04:25
pyparsing-2.1.10-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:21
python_daemon-2.1.1-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:22
python_dateutil-2.6.0-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:20
python_gflags-2.0-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:21
python_magic-0.4.13-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:25
python_pam-1.8.4-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:25
pytz	[ DIR ]	drwxr-xr-x	2026-05-01 04:21
pytz-2017.2-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:21
raven	[ DIR ]	drwxr-xr-x	2026-05-01 04:21
raven-6.3.0-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:21
requests	[ DIR ]	drwxr-xr-x	2026-05-01 04:21
requests-2.19.1-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:21
requests_mock	[ DIR ]	drwxr-xr-x	2026-05-01 04:22
requests_mock-1.2.0-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:22
sdnotify	[ DIR ]	drwxr-xr-x	2026-05-01 04:25
sentry_sdk	[ DIR ]	drwxr-xr-x	2026-05-01 04:22
sentry_sdk-0.7.10-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:22
sentrylogs	[ DIR ]	drwxr-xr-x	2026-05-01 04:22
setuptools	[ DIR ]	drwxr-xr-x	2026-04-30 23:38
setuptools-36.3.0.post20231113.dist-info	[ DIR ]	drwxr-xr-x	2026-04-30 23:38
setuptools_scm	[ DIR ]	drwxr-xr-x	2026-05-01 04:25
setuptools_scm-3.2.0-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:25
six-1.12.0-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:19
speaklater-1.3-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:25
tailer	[ DIR ]	drwxr-xr-x	2026-05-01 04:21
urllib3	[ DIR ]	drwxr-xr-x	2026-05-01 04:21
urllib3-1.23-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:21
wheel	[ DIR ]	drwxr-xr-x	2026-05-01 04:25
wheel-0.29.0-py3.5.egg-info	[ DIR ]	drwxr-xr-x	2026-05-01 04:25
CXX-6.2.8-py3.5.egg-info	257 B	-rw-r--r--	2019-12-11 20:32
PySocks-1.5.7-py3.5.egg-info	322 B	-rw-r--r--	2019-11-23 14:16
bottle-0.12.9-py3.5.egg-info	1.65 KB	-rw-r--r--	2019-11-23 13:35
bottle.py	146.05 KB	-rw-r--r--	2019-11-23 13:35
cached_property.py	3.81 KB	-rw-r--r--	2015-11-25 05:18
contextlib2.py	14.48 KB	-rw-r--r--	2016-07-31 08:12
cycler.py	15.58 KB	-rw-r--r--	2016-02-16 08:26
docutils-0.14-py3.5.egg-info	2.31 KB	-rw-r--r--	2019-11-23 13:37
easy_install.py	126 B	-rw-r--r--	2023-11-14 00:53
gflags.py	101.81 KB	-rw-r--r--	2019-11-23 13:26
gflags_validators.py	6.79 KB	-rw-r--r--	2019-11-23 13:26
google_apputils-0.4.2-py3.5-nspkg.pth	539 B	-rw-r--r--	2019-12-10 23:13
idna_ssl.py	666 B	-rw-r--r--	2018-03-06 18:40
ipaddress.py	78.28 KB	-rw-r--r--	2017-01-11 15:59
magic.py	9.13 KB	-rw-r--r--	2017-03-20 09:53
pam.py	7.38 KB	-rw-r--r--	2018-06-16 10:32
pyparsing.py	224.48 KB	-rw-r--r--	2016-10-07 05:01
sdnotify-0.3.2-py3.5.egg-info	1.11 KB	-rw-r--r--	2019-12-11 20:30
six.py	31.69 KB	-rw-r--r--	2018-12-10 04:29
socks.py	29.25 KB	-rw-r--r--	2016-05-22 02:24
sockshandler.py	2.84 KB	-rw-r--r--	2016-05-22 02:24
speaklater.py	5.09 KB	-rw-r--r--	2010-10-17 18:33
tailer-0.4.1-py3.5.egg-info	3.04 KB	-rw-r--r--	2019-11-16 01:41

Rename

"""
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': '-.'}
"""

from __future__ import (absolute_import, division, print_function,
                        unicode_literals)

import six
from itertools import product, cycle
from six.moves import zip, reduce
from operator import mul, add
import copy

__version__ = '0.10.0'

def _process_keys(left, right):
    """
    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
    """
    l_peek = next(iter(left)) if left is not None else {}
    r_peek = next(iter(right)) if right is not None else {}
    l_key = set(l_peek.keys())
    r_key = set(r_peek.keys())
    if l_key & r_key:
        raise ValueError("Can not compose overlapping cycles")
    return l_key | r_key

class Cycler(object):
    """
    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.

"""
    def __call__(self):
        return cycle(self)

def __init__(self, left, right=None, op=None):
        """Semi-private init

Do not use this directly, use `cycler` function instead.
        """
        if isinstance(left, Cycler):
            self._left = Cycler(left._left, left._right, left._op)
        elif left is not None:
            # Need to copy the dictionary or else that will be a residual
            # mutable that could lead to strange errors
            self._left = [copy.copy(v) for v in left]
        else:
            self._left = None

if isinstance(right, Cycler):
            self._right = Cycler(right._left, right._right, right._op)
        elif right is not None:
            # Need to copy the dictionary or else that will be a residual
            # mutable that could lead to strange errors
            self._right = [copy.copy(v) for v in right]
        else:
            self._right = None

self._keys = _process_keys(self._left, self._right)
        self._op = op

@property
    def keys(self):
        """
        The keys this Cycler knows about
        """
        return set(self._keys)

def change_key(self, old, new):
        """
        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.

"""
        if old == new:
            return
        if new in self._keys:
            raise ValueError("Can't replace %s with %s, %s is already a key" %
                             (old, new, new))
        if old not in self._keys:
            raise KeyError("Can't replace %s with %s, %s is not a key" %
                           (old, new, old))

self._keys.remove(old)
        self._keys.add(new)

if self._right is not None and old in self._right.keys:
            self._right.change_key(old, new)

# self._left should always be non-None
        # if self._keys is non-empty.
        elif isinstance(self._left, Cycler):
            self._left.change_key(old, new)
        else:
            # It should be completely safe at this point to
            # assume that the old key can be found in each
            # iteration.
            self._left = [{new: entry[old]} for entry in self._left]

def _compose(self):
        """
        Compose the 'left' and 'right' components of this cycle
        with the proper operation (zip or product as of now)
        """
        for a, b in self._op(self._left, self._right):
            out = dict()
            out.update(a)
            out.update(b)
            yield out

@classmethod
    def _from_iter(cls, label, itr):
        """
        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`
        """
        ret = cls(None)
        ret._left = list({label: v} for v in itr)
        ret._keys = set([label])
        return ret

def __getitem__(self, key):
        # TODO : maybe add numpy style fancy slicing
        if isinstance(key, slice):
            trans = self.by_key()
            return reduce(add, (_cycler(k, v[key])
                                for k, v in six.iteritems(trans)))
        else:
            raise ValueError("Can only use slices with Cycler.__getitem__")

def __iter__(self):
        if self._right is None:
            return iter(dict(l) for l in self._left)

return self._compose()

def __add__(self, other):
        """
        Pair-wise combine two equal length cycles (zip)

Parameters
        ----------
        other : Cycler
           The second Cycler
        """
        if len(self) != len(other):
            raise ValueError("Can only add equal length cycles, "
                             "not {0} and {1}".format(len(self), len(other)))
        return Cycler(self, other, zip)

def __mul__(self, other):
        """
        Outer product of two cycles (`itertools.product`) or integer
        multiplication.

Parameters
        ----------
        other : Cycler or int
           The second Cycler or integer
        """
        if isinstance(other, Cycler):
            return Cycler(self, other, product)
        elif isinstance(other, int):
            trans = self.by_key()
            return reduce(add, (_cycler(k, v*other)
                                for k, v in six.iteritems(trans)))
        else:
            return NotImplemented

def __rmul__(self, other):
        return self * other

def __len__(self):
        op_dict = {zip: min, product: mul}
        if self._right is None:
            return len(self._left)
        l_len = len(self._left)
        r_len = len(self._right)
        return op_dict[self._op](l_len, r_len)

def __iadd__(self, other):
        """
        In-place pair-wise combine two equal length cycles (zip)

Parameters
        ----------
        other : Cycler
           The second Cycler
        """
        if not isinstance(other, Cycler):
            raise TypeError("Cannot += with a non-Cycler object")
        # True shallow copy of self is fine since this is in-place
        old_self = copy.copy(self)
        self._keys = _process_keys(old_self, other)
        self._left = old_self
        self._op = zip
        self._right = Cycler(other._left, other._right, other._op)
        return self

def __imul__(self, other):
        """
        In-place outer product of two cycles (`itertools.product`)

Parameters
        ----------
        other : Cycler
           The second Cycler
        """
        if not isinstance(other, Cycler):
            raise TypeError("Cannot *= with a non-Cycler object")
        # True shallow copy of self is fine since this is in-place
        old_self = copy.copy(self)
        self._keys = _process_keys(old_self, other)
        self._left = old_self
        self._op = product
        self._right = Cycler(other._left, other._right, other._op)
        return self

def __eq__(self, other):
        """
        Check equality
        """
        if len(self) != len(other):
            return False
        if self.keys ^ other.keys:
            return False

return all(a == b for a, b in zip(self, other))

def __repr__(self):
        op_map = {zip: '+', product: '*'}
        if self._right is None:
            lab = self.keys.pop()
            itr = list(v[lab] for v in self)
            return "cycler({lab!r}, {itr!r})".format(lab=lab, itr=itr)
        else:
            op = op_map.get(self._op, '?')
            msg = "({left!r} {op} {right!r})"
            return msg.format(left=self._left, op=op, right=self._right)

def _repr_html_(self):
        # an table showing the value of each key through a full cycle
        output = "<table>"
        sorted_keys = sorted(self.keys, key=repr)
        for key in sorted_keys:
            output += "<th>{key!r}</th>".format(key=key)
        for d in iter(self):
            output += "<tr>"
            for k in sorted_keys:
                output += "<td>{val!r}</td>".format(val=d[k])
            output += "</tr>"
        output += "</table>"
        return output

def by_key(self):
        """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.
        """

# TODO : sort out if this is a bottle neck, if there is a better way
        # and if we care.

keys = self.keys
        # change this to dict comprehension when drop 2.6
        out = dict((k,  list()) for k in keys)

for d in self:
            for k in keys:
                out[k].append(d[k])
        return out

# for back compatibility
    _transpose = by_key

def simplify(self):
        """Simplify the Cycler

Returned as a composition using only sums (no multiplications)

Returns
        -------
        simple : Cycler
            An equivalent cycler using only summation"""
        # TODO: sort out if it is worth the effort to make sure this is
        # balanced.  Currently it is is
        # (((a + b) + c) + d) vs
        # ((a + b) + (c + d))
        # I would believe that there is some performance implications

trans = self.by_key()
        return reduce(add, (_cycler(k, v) for k, v in six.iteritems(trans)))

def concat(self, other):
        """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`
        """
        return concat(self, other)

def concat(left, right):
    """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`
    """
    if left.keys != right.keys:
        msg = '\n\t'.join(["Keys do not match:",
                           "Intersection: {both!r}",
                           "Disjoint: {just_one!r}"]).format(
                               both=left.keys & right.keys,
                               just_one=left.keys ^ right.keys)

raise ValueError(msg)

_l = left.by_key()
    _r = right.by_key()
    return reduce(add, (_cycler(k, _l[k] + _r[k]) for k in left.keys))

def cycler(*args, **kwargs):
    """
    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

"""
    if args and kwargs:
        raise TypeError("cyl() can only accept positional OR keyword "
                        "arguments -- not both.")

if len(args) == 1:
        if not isinstance(args[0], Cycler):
            raise TypeError("If only one positional argument given, it must "
                            " be a Cycler instance.")
        return Cycler(args[0])
    elif len(args) == 2:
        return _cycler(*args)
    elif len(args) > 2:
        raise TypeError("Only a single Cycler can be accepted as the lone "
                        "positional argument. Use keyword arguments instead.")

if kwargs:
        return reduce(add, (_cycler(k, v) for k, v in six.iteritems(kwargs)))

raise TypeError("Must have at least a positional OR keyword arguments")

def _cycler(label, itr):
    """
    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
    """
    if isinstance(itr, Cycler):
        keys = itr.keys
        if len(keys) != 1:
            msg = "Can not create Cycler from a multi-property Cycler"
            raise ValueError(msg)

lab = keys.pop()
        # Doesn't need to be a new list because
        # _from_iter() will be creating that new list anyway.
        itr = (v[lab] for v in itr)

return Cycler._from_iter(label, itr)