$28 GRAYBYTE WORDPRESS FILE MANAGER $47

B

� f��@s�dZd
dddddddgZ
d	ZeZif
d
d�
Zdd�Zdd�Zd
d�Zddd�
Z	dd�Z
Gdd�de�ZGdd�de�Z
dadadd�ZdS)a/
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

�error�start_new_thread�exit�	get_ident�
allocate_lock�interrupt_main�LockType�RLocklcCs�t|
�
tt
��
krtd
�
�
t|�
tt��
kr4td�
�
day||
|�

Wn.tk
rZ


Yn


ddl}|��
YnXdatr�dat	�
dS)a�
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.

    z2nd arg must be a tuplez3rd arg must be a dictF�NT)
�type�tuple�	TypeError�dict�_main�
SystemExit�	traceback�	print_exc�
_interrupt�KeyboardInterrupt)Zfunction�args�kwargsr�r�2/opt/alt/python37/lib64/python3.7/_dummy_thread.pyrs 













c
Cst�
d
S)z'Dummy implementation of _thread.exit().N)
rrrrrr=sc
Csd
S)z�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.
    �
rrrrrrAsc
Cst�S)
z0Dummy implementation of _thread.allocate_lock().)
rrrrrrJsNc

Cs|d
k	rtd�
�
dS)z-Dummy implementation of _thread.stack_size().Nz'setting thread stack size not supportedr	)
r
)
�sizerrr�
stack_sizeNs

rc
Cst�S)
z0Dummy implementation of _thread._set_sentinel().)
rrrrr�
_set_sentinelTsrc@sFeZ
dZd
Zdd�Zddd�
ZeZdd	�Zd
d�Zdd
�Z	dd�Z
dS)ra�
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
d
|_dS)NF)
�
locked_status)
�selfrrr�__init__cs
zLockType.__init__N���cCsH|
d
ks|
rd|_dS|js&d|_dS|dkr@dd
l
}|�|�

dSd
S)a�
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.

        NTr	F)r�timeZsleep)r�waitflag�timeoutr rrr�acquirefs







zLockType.acquirecCs|��
dS)
N)
�release)r�typ�val�tbrrr�__exit__�s
zLockType.__exit__c

Cs|js
t
�
d
|_dS)zRelease the dummy lock.FT)rr
)
rrrrr$�s


zLockType.releasec


Cs|jS)
N)
r)
rrrr�locked�s
zLockType.lockedc

Cs*d
|jrdnd|j
j|j
jtt|�
�
fS)Nz<%s %s.%s object at %s>r)Zunlocked)r�	__class__�
__module__�__qualname__�hex�id)
rrrr�__repr__�s





zLockType.__repr__)Nr)�__name__r+r,�__doc__rr#�	__enter__r(r$r)r/rrrrrXs	
	cs:eZ
dZd
Z�f
dd�Zd
�f
dd�	Z�f
dd	�Z�ZS)ra
Dummy implementation of threading._RLock.

    Re-entrant lock can be aquired multiple times and needs to be released
    just as many times. This dummy implemention does not check wheter the
    current thread actually owns the lock, but does accounting on the call
    counts.
    c

st��
�
d
|_dS)Nr	)�superr�_levels)
r)
r*rrr�s


zRLock.__init__Nrcs$t��
|
|�}|r |jd
7_|S)zEAquire the lock, can be called multiple times in succession.
        r)r3r#r4)rr!r"r))
r*rrr#�s


z
RLock.acquirec

s4|jd
krt
�
|jdkr"t���
|jd8_dS)zERelease needs to be called once for every call to acquire().
        r	rN)r4r
r3r$)
r)
r*rrr$�s







z
RLock.release)Nr)r0r+r,r1rr#r$�
__classcell__rr)
r*rr�s
FTc
Cstr
t
�
nd
adS)z^Set _interrupt flag to True to have start_new_thread raise
    KeyboardInterrupt upon exiting.TN)rrrrrrrr�s
)
N)r1�__all__�TIMEOUT_MAX�RuntimeErrorr
rrrrrr�objectrrrrrrrrr�<module>
s


 	
@