✏ EDIT: _dummy_thread.cpython-36.pyc

� \�������������������@���sx���d�Z�dddddddgZdZeZi�fd
d�Zdd��Zdd��Zd
d��Zddd�Z	dd��Z
G�dd��de�Zda
dadd��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��������c�������������C���s����t�|�t�t���krtd��t�|�t�t���kr4td��day|�||��W�n.�tk
rZ���Y�n���ddl}|j���Y�nX�datr�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����%/usr/lib64/python3.6/_dummy_thread.pyr������s ����
c���������������C���s���t��dS�)z'Dummy implementation of _thread.exit().N)r���r���r���r���r���r���=���s����c���������������C���s���dS�)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.
    �������r���r���r���r���r���r���A���s����c���������������C���s���t���S�)z0Dummy implementation of _thread.allocate_lock().)r���r���r���r���r���r���J���s����Nc�������������C���s���|�dk	rt�d��dS�)z-Dummy implementation of _thread.stack_size().Nz'setting thread stack size not supportedr
���)r���)�sizer���r���r����
stack_sizeN���s����r���c���������������C���s���t���S�)z0Dummy implementation of _thread._set_sentinel().)r���r���r���r���r����
_set_sentinelT���s����r���c���������������@���sF���e�Zd�ZdZdd��Zddd�ZeZdd	��Zd
d��Zdd
��Z	dd��Z
dS�)r���a���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�������������C���s
���d|�_�d�S�)NF)�
locked_status)�selfr���r���r����__init__c���s����zLockType.__init__Nr���c�������������C���sH���|dks|rd|�_�dS�|�j�s&d|�_�dS�|dkr@ddl}|j|��dS�dS�)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���ZwaitflagZtimeoutr!���r���r���r����acquiref���s����
zLockType.acquirec�������������C���s���|�j����d�S�)N)�release)r����typ�val�tbr���r���r����__exit__����s����zLockType.__exit__c�������������C���s���|�j�s
t�d|�_�dS�)zRelease the dummy lock.FT)r���r���)r���r���r���r���r#�������s����zLockType.releasec�������������C���s���|�j�S�)N)r���)r���r���r���r����locked����s����zLockType.lockedc�������������C���s*���d|�j�rdnd|�jj|�jjtt|���f�S�)Nz<%s %s.%s object at %s>r(���Zunlocked)r����	__class__�
__module__�__qualname__�hex�id)r���r���r���r����__repr__����s
����zLockType.__repr__r���)Nr���)�__name__r*���r+����__doc__r ���r"����	__enter__r'���r#���r(���r.���r���r���r���r���r���X���s���	
	FTc���������������C���s���t�r
t�ndadS�)z^Set _interrupt flag to True to have start_new_thread raise
    KeyboardInterrupt upon exiting.TN)r���r���r���r���r���r���r���r�������s����l��������)N)r0����__all__�TIMEOUT_MAX�RuntimeErrorr���r���r���r���r���r���r����objectr���r���r���r���r���r���r���r����<module>
���s���
 	
@

[✗] CANCEL