Tryag File Manager

//proc/self/root/usr/lib/python2.4/dummy_thread.pyc

mò
‚=5Dc�����������@���s¢���d��Z��d�Z�d�Z�d�d�d�d�d�d�d	�g�Z�d
�k�Z�d�e�f�d�„��ƒ��YZ�h��d�„�Z�d
�„��Z	�d�„��Z
�d�„��Z�d	�e�f�d�„��ƒ��YZ
�e�a�e�a�d�„��Z�d
�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 Cannons���brett@python.orgt���errort���start_new_threadt���exitt	���get_identt
���allocate_lockt���interrupt_maint���LockTypeNc�����������B���s���t��Z�d��Z�d�„��Z�RS(���s%���Dummy implementation of thread.error.c���������G���s
���|�|��_��d��S(���N(���t���argst���self(���R���R���(����(����t"���/usr/lib/python2.4/dummy_thread.pyt���__init__���s����(���t���__name__t
���__module__t���__doc__R
���(����(����(����R	���R�������s����c���������C���s¶���t��|�ƒ�t��t�ƒ��ƒ�j�o�t�d�ƒ�‚�n�t��|�ƒ�t��t�ƒ��ƒ�j�o�t�d�ƒ�‚�n�t�a�y�|��|�|�Ž��Wn#�t	�j
�o�n�t
�i�ƒ��n�Xt�a�t
�o�t�a
�t�‚�n�d�S(���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.

s���2nd arg must be a tuples���3rd arg must be a dictN(���t���typeR���t���tuplet	���TypeErrort���kwargst���dictt���Falset���_maint���functiont
���SystemExitt
���_tracebackt	���print_exct���Truet
���_interruptt���KeyboardInterrupt(���R���R���R���(����(����R	���R������s$�������c�����������C���s
���t��‚�d�S(���s&���Dummy implementation of thread.exit().N(���R���(����(����(����R	���R���=���s�����c�����������C���s���d�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	���R���A���s�����c�����������C���s���t��ƒ��S(���s/���Dummy implementation of thread.allocate_lock().N(���R���(����(����(����R	���R���J���s�����c�����������B���s5���t��Z�d��Z�d�„��Z�e�d�„�Z�d�„��Z�d�„��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.

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(���t���waitflagt���NoneR���R���R���R���(���R���R���(����(����R	���t���acquire\���s����
�
	
		c���������C���s!���|��i�p
�t�‚�n�t�|��_�t�S(���s���Release the dummy lock.N(���R���R���R����R���R���(���R���(����(����R	���t���releaset���s
�����

c���������C���s���|��i�S(���N(���R���R���(���R���(����(����R	���t���locked}���s����(���R���R���R
���R
���R���R���R ���R!���(����(����(����R	���R���N���s
���	�			c�����������C���s���t��o
�t�‚�n�t�a�d�S(���s^���Set _interrupt flag to True to have start_new_thread raise
    KeyboardInterrupt upon exiting.N(���R���R���R���R���(����(����(����R	���R���…���s
�����
�(���R
���t
���__author__t	���__email__t���__all__t	���tracebackR���t	���ExceptionR����R���R���R���R���t���objectR���R���R���R���R���R���(���R���R$���R���R���R���R"���R#���R���R���R����R���(����(����R	���t���?
���s���					3