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

""" Fast profiler """

class Profiler(object):
  """ Profiler(custom_timer=None, time_unit=None, subcalls=True, builtins=True)
  
      Builds a profiler object using the specified timer function.
      The default timer is a fast built-in one based on real time.
      For custom timer functions returning integers, time_unit can
      be a float specifying a scale (i.e. how long each integer unit
      is, in seconds).
   """

  def __init__(self, arg0, arg1):
    pass

  def clear(self):
    """ clear()
    
    Clear all profiling information collected so far.
     """
    pass

  def disable(self):
    """ disable()
    
    Stop collecting profiling information.
     """
    pass

  def enable(self):
    """ enable(subcalls=True, builtins=True)
    
    Start collecting profiling information.
    If 'subcalls' is True, also records for each function
    statistics separated according to its current caller.
    If 'builtins' is True, records the time spent in
    built-in functions separately from their caller.
     """
    pass

  def getstats(self):
    """ getstats() -> list of profiler_entry objects
    
    Return all information collected by the profiler.
    Each profiler_entry is a tuple-like object with the
    following attributes:
    
        code          code object
        callcount     how many times this was called
        reccallcount  how many times called recursively
        totaltime     total time in this entry
        inlinetime    inline time in this entry (not in subcalls)
        calls         details of the calls
    
    The calls attribute is either None or a list of
    profiler_subentry objects:
    
        code          called code object
        callcount     how many times this is called
        reccallcount  how many times this is called recursively
        totaltime     total time spent in this call
        inlinetime    inline time (not in further subcalls)
     """
    return []

__doc__ = 'Fast profiler'

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.
  
       """

  def find_module(self, cls, fullname, path):
    """ Find the built-in module.
    
            If 'path' is ever specified then the search is considered a failure.
    
             """
    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):
    """ Load a built-in module. """
    pass

  def module_repr(self, cls, module):
    pass

__name__ = '_lsprof'
__package__ = ''

class profiler_entry(tuple):

  callcount = None
  calls = None
  code = None
  inlinetime = None
  n_fields = 6
  n_sequence_fields = 6
  n_unnamed_fields = 0
  reccallcount = None
  totaltime = None

class profiler_subentry(tuple):

  callcount = None
  code = None
  inlinetime = None
  n_fields = 5
  n_sequence_fields = 5
  n_unnamed_fields = 0
  reccallcount = None
  totaltime = None