dummy_thread
index
/usr/local/lib/python2.5/dummy_thread.py
Module Docs

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
warnings

 
Classes
       
__builtin__.object
LockType
exceptions.Exception(exceptions.BaseException)
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:
__enter__ = acquire(self, waitflag=None)
__exit__(self, typ, val, tb)
__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.
 
 
Method resolution order:
error
exceptions.Exception
exceptions.BaseException
__builtin__.object

Methods defined here:
__init__(self, *args)

Data descriptors defined here:
__weakref__
list of weak references to the object (if defined)

Data and other attributes inherited from exceptions.Exception:
__new__ = <built-in method __new__ of type object at 0x8125440>
T.__new__(S, ...) -> a new object with type S, a subtype of T

Methods inherited from exceptions.BaseException:
__delattr__(...)
x.__delattr__('name') <==> del x.name
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__getitem__(...)
x.__getitem__(y) <==> x[y]
__getslice__(...)
x.__getslice__(i, j) <==> x[i:j]
 
Use of negative indices is not supported.
__reduce__(...)
__repr__(...)
x.__repr__() <==> repr(x)
__setattr__(...)
x.__setattr__('name', value) <==> x.name = value
__setstate__(...)
__str__(...)
x.__str__() <==> str(x)

Data descriptors inherited from exceptions.BaseException:
__dict__
args
message
exception message

 
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