code: 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"
      )
  
imports: 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
label_desc: Use image node_id 3 for calling a global function with example usage: cycler() and returns: Cycler, reduce, _cycler