�`^c@s�dZd
ddddddgZ
dd	lZd
ef
d
��YZid�Zd�Zd
�Zd�Z	d	d�Zde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

terrortstart_new_threadtexitt	get_identt
allocate_locktinterrupt_maintLockTypei�Nc
BseZ
dZd
�ZRS(s%Dummy implementation of thread.error.c
Gs
|
|_dS(
N(
targs(tselfR((s"/sys/lib/python2.7/dummy_thread.pyt__init__s
(t__name__t
__module__t__doc__R	(((s"/sys/lib/python2.7/dummy_thread.pyRs
cCs�t|
�tt
��kr*td
��nt|�tt��krTtd��ntay||
|�
Wn!tk
r~


n


tj�
n
Xt	at
r�ta
t�ndS(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(ttypettuplet	TypeErrortdicttFalset_maint
SystemExitt
_tracebackt	print_exctTruet
_interrupttKeyboardInterrupt(tfunctionRtkwargs((s"/sys/lib/python2.7/dummy_thread.pyR
s













c
Cs
t�d
S(s&Dummy implementation of thread.exit().N(
R(((s"/sys/lib/python2.7/dummy_thread.pyR:sc
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�((((s"/sys/lib/python2.7/dummy_thread.pyR>sc
Cst�S(
s/Dummy implementation of thread.allocate_lock().(
R(((s"/sys/lib/python2.7/dummy_thread.pyRGsc

Cs|dk	rt
d
��ndS(s,Dummy implementation of thread.stack_size().s'setting thread stack size not supportediN(tNoneR(
tsize((s"/sys/lib/python2.7/dummy_thread.pyt
stack_sizeKs

cBsDeZ
dZd
�Zdd�ZeZd�Zd�Zd�Z	RS(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(Rt
locked_status(
R((s"/sys/lib/python2.7/dummy_thread.pyR	\s
cCs=|
d
ks|
rt
|_t
S|js5t
|_t
StSd
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(RRRR(Rtwaitflag((s"/sys/lib/python2.7/dummy_thread.pytacquire_s
	
	
	
c
Cs|j�
dS(
N(
trelease(Rttyptvalttb((s"/sys/lib/python2.7/dummy_thread.pyt__exit__vs
c

Cs|jst
�nt|_tS(
sRelease the dummy lock.(RRRR(
R((s"/sys/lib/python2.7/dummy_thread.pyR!ys	
	
	
c


Cs|jS(
N(
R(
R((s"/sys/lib/python2.7/dummy_thread.pytlocked�s
N(
R
RRR	RR t	__enter__R%R!R&(((s"/sys/lib/python2.7/dummy_thread.pyRQs					c
Cstrt
�ntad
S(s^Set _interrupt flag to True to have start_new_thread raise
    KeyboardInterrupt upon exiting.N(RRRR(((s"/sys/lib/python2.7/dummy_thread.pyR�s
	(Rt__all__t	tracebackRt	ExceptionRR
RRRRRtobjectRRRRRR(((s"/sys/lib/python2.7/dummy_thread.pyt<module>
s
				5