"""High-perfomance logging profiler, mostly written in C.""" import _hotshot from _hotshot import ProfilerError  class Profile:    def __init__(self, logfn, lineevents=0, linetimings=1):        self.lineevents = lineevents and 1 or 0        self.linetimings = (linetimings and lineevents) and 1 or 0        self._prof = p = _hotshot.profiler(            logfn, self.lineevents, self.linetimings)         # Attempt to avoid confusing results caused by the presence of        # Python wrappers around these functions, but only if we can        # be sure the methods have not been overridden or extended.        if self.__class__ is Profile:            self.close = p.close            self.start = p.start            self.stop = p.stop            self.addinfo = p.addinfo     def close(self):        """Close the logfile and terminate the profiler."""        self._prof.close()     def fileno(self):        """Return the file descriptor of the profiler's log file."""        return self._prof.fileno()     def start(self):        """Start the profiler."""        self._prof.start()     def stop(self):        """Stop the profiler."""        self._prof.stop()     def addinfo(self, key, value):        """Add an arbitrary labelled value to the profile log."""        self._prof.addinfo(key, value)     # These methods offer the same interface as the profile.Profile class,    # but delegate most of the work to the C implementation underneath.     def run(self, cmd):        """Profile an exec-compatible string in the script        environment.         The globals from the __main__ module are used as both the        globals and locals for the script.        """        import __main__        dict = __main__.__dict__        return self.runctx(cmd, dict, dict)     def runctx(self, cmd, globals, locals):        """Evaluate an exec-compatible string in a specific        environment.         The string is compiled before profiling begins.        """        code = compile(cmd, "<string>", "exec")        self._prof.runcode(code, globals, locals)        return self     def runcall(self, func, *args, **kw):        """Profile a single call of a callable.         Additional positional and keyword arguments may be passed        along; the result of the call is returned, and exceptions are        allowed to propogate cleanly, while ensuring that profiling is        disabled on the way out.        """        return self._prof.runcall(func, args, kw)