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(
              "cycler() 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 kwargs.items()))
  
      raise TypeError(
          "Must have at least a positional OR keyword arguments"
      )
  
imports: from __future__ import annotations
  from collections.abc import Hashable, Iterable, Generator
  import copy
  from functools import reduce
  from itertools import product, cycle
  from operator import mul, add
  from typing import TypeVar, Generic, Callable, Union, Dict, List, Any, overload, cast
label_desc: Use image node_id 6 for calling a global function with example usage: cycler() and returns: Cycler, reduce, _cycler