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


class LogReaderType(object):
  """ logreader(filename) --> log-iterator
  Create a log-reader for the timing information file. """

  def close(self):
    """ close()
    Close the log file, preventing additional records from being read. """
    pass

  closed = property(None, None, None,
                    """ True if the logreader's input file has already been closed. """
                    )


  def fileno(self):
    """ fileno() -> file descriptor
    Returns the file descriptor for the log file, if open.
    Raises ValueError if the log file is closed. """
    return file(__file__)

  info = None

  def next(self):
    """ x.next() -> the next value, or raise StopIteration """
    return None

class ProfilerError(Exception):

  pass

class ProfilerType(object):
  """ High-performance profiler object.
  
  Methods:
  
  close():      Stop the profiler and close the log files.
  fileno():     Returns the file descriptor of the log file.
  runcall():    Run a single function call with profiling enabled.
  runcode():    Execute a code object with profiling enabled.
  start():      Install the profiler and return.
  stop():       Remove the profiler.
  
  Attributes (read-only):
  
  closed:       True if the profiler has already been closed.
  frametimings: True if ENTER/EXIT events collect timing information.
  lineevents:   True if line events are reported to the profiler.
  linetimings:  True if line events collect timing information. """

  def addinfo(self, key, value):
    """ addinfo(key, value)
    Insert an ADD_INFO record into the log. """
    pass

  def close(self):
    """ close()
    Shut down this profiler and close the log files, even if its active. """
    pass

  closed = property(None, None, None,
                    """ True if the profiler's output file has already been closed. """
                    )


  def fileno(self):
    """ fileno() -> file descriptor
    Returns the file descriptor for the log file, if open.
    Raises ValueError if the log file is closed. """
    return file(__file__)

  frametimings = None
  lineevents = None
  linetimings = None

  def runcall(self, callable, args=None, kw=None):
    """ runcall(callable[, args[, kw]]) -> callable()
    Profile a specific function call, returning the result of that call. """
    return None

  def runcode(self, code, globals, locals=None):
    """ runcode(code, globals[, locals])
    Execute a code object while collecting profile data.  If locals is
    omitted, globals is used for the locals as well. """
    pass

  def start(self):
    """ start()
    Install this profiler for the current thread. """
    pass

  def stop(self):
    """ stop()
    Remove this profiler from the current thread. """
    pass

WHAT_ADD_INFO = 19
WHAT_DEFINE_FILE = 35
WHAT_DEFINE_FUNC = 67
WHAT_ENTER = 0
WHAT_EXIT = 1
WHAT_LINENO = 2
WHAT_LINE_TIMES = 51
WHAT_OTHER = 3
__doc__ = None
__name__ = '_hotshot'
__package__ = None
__version__ = ''

def coverage(logfilename):
  """ coverage(logfilename) -> profiler
  Returns a profiler that doesn't collect any timing information, which is
  useful in building a coverage analysis tool. """
  return file(__file__)

def logreader(filename):
  """ logreader(filename) --> log-iterator
  Create a log-reader for the timing information file. """
  return None

def profiler(logfilename, lineevents=None, linetimes=None):
  """ profiler(logfilename[, lineevents[, linetimes]]) -> profiler
  Create a new profiler object. """
  return file(__file__)

def resolution():
  """ resolution() -> (performance-counter-ticks, update-frequency)
  Return the resolution of the timer provided by the QueryPerformanceCounter()
  function.  The first value is the smallest observed change, and the second
  is the result of QueryPerformanceFrequency(). """
  return (None, None)