code: def cycler(*args, **kwargs):
      """
      Creates a `~cycler.Cycler` object much like :func:`cycler.cycler`,
      but includes input validation.
  
      Call signatures::
  
        cycler(cycler)
        cycler(label=values[, label2=values2[, ...]])
        cycler(label, values)
  
      Form 1 copies a given `~cycler.Cycler` object.
  
      Form 2 creates a `~cycler.Cycler` which cycles over one or more
      properties simultaneously. If multiple properties are given, their
      value lists must have the same length.
  
      Form 3 creates a `~cycler.Cycler` for a single property. This form
      exists for compatibility with the original cycler. Its use is
      discouraged in favor of the kwarg form, i.e. ``cycler(label=values)``.
  
      Parameters
      ----------
      cycler : Cycler
          Copy constructor for Cycler.
  
      label : str
          The property key. Must be a valid `.Artist` property.
          For example, 'color' or 'linestyle'. Aliases are allowed,
          such as 'c' for 'color' and 'lw' for 'linewidth'.
  
      values : iterable
          Finite-length iterable of the property values. These values
          are validated and will raise a ValueError if invalid.
  
      Returns
      -------
      cycler : Cycler
          A new :class:`~cycler.Cycler` for the given properties.
  
      Examples
      --------
      Creating a cycler for a single property:
  
      >>> c = cycler(color=['red', 'green', 'blue'])
  
      Creating a cycler for simultaneously cycling over multiple properties
      (e.g. red circle, green plus, blue cross):
  
      >>> c = cycler(color=['red', 'green', 'blue'],
      ...            marker=['o', '+', 'x'])
  
      """
      if args and kwargs:
          raise TypeError(
              "cycler() can only accept positional OR keyword "
              "arguments -- not both."
          )
      elif not args and not kwargs:
          raise TypeError(
              "cycler() must have positional OR keyword arguments"
          )
  
      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 validate_cycler(args[0])
      elif len(args) == 2:
          pairs = [(args[0], args[1])]
      elif len(args) > 2:
          raise TypeError("No more than 2 positional arguments allowed")
      else:
          pairs = six.iteritems(kwargs)
  
      validated = []
      for prop, vals in pairs:
          norm_prop = _prop_aliases.get(prop, prop)
          validator = _prop_validators.get(norm_prop, None)
          if validator is None:
              raise TypeError("Unknown artist property: %s" % prop)
          vals = validator(vals)
          # We will normalize the property names as well to reduce
          # the amount of alias handling code elsewhere.
          validated.append((norm_prop, vals))
  
      return reduce(operator.add, (ccycler(k, v) for k, v in validated))
  
imports: from __future__ import absolute_import, division, print_function
  import six
  from functools import reduce
  import operator
  import os
  import warnings
  import re
  from matplotlib import cbook, testing
  from matplotlib.cbook import mplDeprecation, deprecated, ls_mapper
  from matplotlib.fontconfig_pattern import parse_fontconfig_pattern
  from matplotlib.colors import is_color_like
  from cycler import Cycler, cycler
label_desc: Use image node_id 37 for calling a global function with example usage: cycler() and returns: reduce, validate_cycler