Drop-in replacement for the thread module.
 
Meant to be used as a brain-dead substitute so that threaded code does
not need to be rewritten for when the thread module is not present.
 
Suggested usage is::
 
    try:
        import thread
    except ImportError:
        import dummy_thread as thread

Modules
		traceback

Classes
		__builtin__.object LockType exceptions.Exception error   class LockType(__builtin__.object)     Class implementing dummy implementation of thread.LockType.   Compatibility is maintained by maintaining self.locked_status which is a boolean that stores the state of the lock.  Pickling of the lock, though, should not be done since if the thread module is then used with an unpickled ``lock()`` from here problems could occur from this class not having atomic methods.     Methods defined here: __init__(self) acquire(self, waitflag=None) Dummy implementation of acquire().   For blocking calls, self.locked_status is automatically set to True and returned appropriately based on value of ``waitflag``.  If it is non-blocking, then the value is actually checked and not set if it is already acquired.  This is all done so that threading.Condition's assert statements aren't triggered and throw a little fit. locked(self) release(self) Release the dummy lock. Data descriptors defined here: __dict__ dictionary for instance variables (if defined) __weakref__ list of weak references to the object (if defined)   class error(exceptions.Exception)     Dummy implementation of thread.error.     Methods defined here: __init__(self, *args) Methods inherited from exceptions.Exception: __getitem__(...) __str__(...)

Functions
		allocate_lock() Dummy implementation of thread.allocate_lock(). exit() Dummy implementation of thread.exit(). get_ident() Dummy implementation of thread.get_ident().   Since this module should only be used when threadmodule is not available, it is safe to assume that the current process is the only thread.  Thus a constant can be safely returned. interrupt_main() Set _interrupt flag to True to have start_new_thread raise KeyboardInterrupt upon exiting. start_new_thread(function, args, kwargs={}) Dummy implementation of thread.start_new_thread().   Compatibility is maintained by making sure that ``args`` is a tuple and ``kwargs`` is a dictionary.  If an exception is raised and it is SystemExit (which can be done by thread.exit()) it is caught and nothing is done; all other exceptions are printed out by using traceback.print_exc().   If the executed function calls interrupt_main the KeyboardInterrupt will be raised when the function returns.

Data
		__all__ = ['error', 'start_new_thread', 'exit', 'get_ident', 'allocate_lock', 'interrupt_main', 'LockType'] __author__ = 'Brett Cannon' __email__ = 'brett@python.org'

Author
		Brett Cannon