
    q                     r    d Z g dZdZ G d de      Zi fdZd Zd Zd Zdd
Z	 G d de
      Zdadad Zy	)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:
        try:
            import _thread  # Python >= 3
        except:
            import thread as _thread  # Python < 3
    except ImportError:
        import _dummy_thread as _thread

)errorstart_new_threadexit	get_identallocate_lockinterrupt_mainLockTypel        c                       e Zd ZdZd Zy)r   z&Dummy implementation of _thread.error.c                     || _         y N)args)selfr   s     .lib/third_party/functools32/_dummy_thread32.py__init__zerror.__init__!   s	    	    N)__name__
__module____qualname____doc__r    r   r   r   r      s
    0r   r   c                 ,   t        |      t        t                     k7  rt        d      t        |      t        t                     k7  rt        d      da	  | |i | dat        rdat        y# t
        $ r Y  ddl}|j                          Y 3xY w)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.

    z2nd arg must be a tuplez3rd arg must be a dictF    NT)
typetuple	TypeErrordict_main
SystemExit	traceback	print_exc
_interruptKeyboardInterrupt)functionr   kwargsr   s       r   r   r   $   s     DzT%']"122F|tDF|#011E$!&! E
   s   A1 1	B<Bc                      t         )z'Dummy implementation of _thread.exit().)r   r   r   r   r   r   D   s    
r   c                       y)zDummy 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   H   s     r   c                      t               S )z0Dummy implementation of _thread.allocate_lock().)r   r   r   r   r   r   Q   s
    :r   Nc                     | t        d      y)z-Dummy implementation of _thread.stack_size().z'setting thread stack size not supportedr   )r   )sizes    r   
stack_sizer*   U   s    =>>r   c                   4    e Zd ZdZd ZddZeZd Zd Zd Z	y)	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                     d| _         y )NFlocked_statusr   s    r   r   zLockType.__init__f   s
    "r   Nc                 x    ||rd| _         y| j                   sd| _         y|dkD  rddl}|j                  |       y)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.   timesleep)r   waitflagtimeoutr1   s       r   acquirezLockType.acquirei   sD     x!%D%%%)"Q;JJw'r   c                 $    | j                          y r   )release)r   typvaltbs       r   __exit__zLockType.__exit__   s    r   c                 6    | j                   st        d| _         y)zRelease the dummy lock.FT)r.   r   r/   s    r   r7   zLockType.release   s     !!K"r   c                     | j                   S r   r-   r/   s    r   lockedzLockType.locked   s    !!!r   )Nr&   )
r   r   r   r   r   r5   	__enter__r;   r7   r>   r   r   r   r   r   [   s'    #0 I"r   r   FTc                       t         rt        day)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      
r   r   )r   __all__TIMEOUT_MAX	Exceptionr   r   r   r   r   r*   objectr   r    r   r   r   r   r   <module>rE      sa   $) I  -/  @5"v 5"p 
r   