# coding: utf-8
# AUTO-GENERATED FILE -- DO NOT EDIT

""" Tools that operate on functions. """

__doc__ = 'Tools that operate on functions.'

class __loader__(object):
  """ Meta path import for built-in modules.
  
      All methods are either class or static methods to avoid the need to
      instantiate the class.
  
       """

  _ORIGIN = 'built-in'

  def create_module(self, spec):
    """ Create a built-in module """
    pass

  def exec_module(self, module):
    """ Exec a built-in module """
    pass

  def find_spec(self, fullname, path=None, target=None):
    pass

  def get_code(self, fullname):
    """ Return None as built-in modules do not have code objects. """
    pass

  def get_source(self, fullname):
    """ Return None as built-in modules do not have source code. """
    pass

  def is_package(self, fullname):
    """ Return False as built-in modules are never packages. """
    pass

  def load_module(self, fullname):
    """ Load the specified module into sys.modules and return it.
    
        This method is deprecated.  Use loader.exec_module() instead.
    
         """
    pass

__name__ = '_functools'
__package__ = ''
__spec__ = None

class _lru_cache_wrapper(object):
  """ Create a cached callable that wraps another function.
  
  user_function:      the function being cached
  
  maxsize:  0         for no caching
            None      for unlimited cache size
            n         for a bounded cache
  
  typed:    False     cache f(3) and f(3.0) as identical calls
            True      cache f(3) and f(3.0) as distinct calls
  
  cache_info_type:    namedtuple class with the fields:
                          hits misses currsize maxsize
   """

  def cache_clear(self):
    """ Clear the cache and cache statistics """
    pass

  def cache_info(self):
    """ Report cache statistics """
    pass

  def __init__(self, arg0):
    pass

def cmp_to_key(mycmp):
  """ Convert a cmp= function into a key= function.
  
    mycmp
      Function that compares two objects. """
  pass

class partial(object):
  """ partial(func, *args, **keywords) - new function with partial application
      of the given arguments and keywords.
   """

  args = None
  func = None
  keywords = None

  def __init__(self, func, *args, **keywords):
    pass

def reduce(function, iterable, initial=None):
  """ reduce(function, iterable[, initial]) -> value
  
  Apply a function of two arguments cumulatively to the items of a sequence
  or iterable, from left to right, so as to reduce the iterable to a single
  value.  For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates
  ((((1+2)+3)+4)+5).  If initial is present, it is placed before the items
  of the iterable in the calculation, and serves as a default when the
  iterable is empty. """
  return None