mò
‚=5Dc@s¢dZd
Z
dZddddddd	gZd
kZdef
d„ƒYZhd„
Zd
„Z	d„Z
d„Zd	ef
d„ƒYZ
eaead„Zd
S(s,
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

sBrett Cannonsbrett@python.orgterrortstart_new_threadtexitt	get_identt
allocate_locktinterrupt_maintLockTypeNc
BstZ
dZd
„ZRS(s%Dummy implementation of thread.error.c
Gs
|
|_dS(
N(targstself(RR((t$/usr/lib64/python2.4/dummy_thread.pyt__init__s
(t__name__t
__module__t__doc__R
(((R	Rs
cCs¶t|
ƒ
ttƒƒ
jo
td
ƒ
‚
n

t|ƒ
ttƒƒ
jo
tdƒ
‚
n

tay||
|Ž
Wn#t	j
o



n



t
iƒ
n
Xtat
o
ta
t‚
n

dS(sä
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.

    s2nd arg must be a tuples3rd arg must be a dictN(ttypeRttuplet	TypeErrortkwargstdicttFalset_maintfunctiont
SystemExitt
_tracebackt	print_exctTruet
_interrupttKeyboardInterrupt(RRR((R	R
s$
















c
Cs
t‚
d
S(s&Dummy implementation of thread.exit().N(
R(((R	R=s

c
Csd
S(sò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.
    iÿÿÿÿN((((R	RAs
c
CstƒS(s/Dummy implementation of thread.allocate_lock().N(
R(((R	RJs

cBs5tZ
dZd
„Zed„
Zd„Zd„ZRS(s‹
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.

    c

Cs
t|_dS(
N(RRt
locked_status(
R((R	R
Ys
cCsY|
d
jo
t|_d
Sn8
|
p#
|ip
t|_tSqU
tSn
t|_tSd
S(s©
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.

        N(twaitflagtNoneRRRR(RR((R	tacquire\s



	




	
	
c

Cs!|i
p

t‚
n

t|_
tS(sRelease the dummy lock.N(RRRRR(
R((R	treleasets





	
c


Cs|i
S(
N(RR(
R((R	tlocked}s
(RRR
R
RRR R!(((R	RNs
				c
Csto

t
‚
n
tad
S(s^Set _interrupt flag to True to have start_new_thread raise
    KeyboardInterrupt upon exiting.N(RRRR(((R	R…s




(R
t
__author__t	__email__t__all__t	tracebackRt	ExceptionRR
RRRtobjectRRRRRR(RR$RRR
R"R#RRRR((R	t
?
s

					3