# coding: utf-8
# AUTO-GENERATED FILE -- DO NOT EDIT

""" This module provides primitive operations to write multi-threaded programs.
The 'threading' module provides a more convenient interface. """

LockType = lock
class RLock(object):

  def _acquire_restore(self, state):
    """ For internal use by `threading.Condition`. """
    pass

  def _at_fork_reinit(self):
    pass

  def _is_owned(self):
    """ For internal use by `threading.Condition`. """
    pass

  def _recursion_count(self):
    """ For internal use by reentrancy checks. """
    pass

  def _release_save(self):
    """ For internal use by `threading.Condition`. """
    pass

  def acquire(self, blocking=True, timeout=-1):
    """ Lock the lock.  `blocking` indicates whether we should wait
    for the lock to be available or not.  If `blocking` is False
    and another thread holds the lock, the method will return False
    immediately.  If `blocking` is True and another thread holds
    the lock, the method will wait for the lock to be released,
    take it and then return True.
    (note: the blocking operation is interruptible.)
    
    In all other cases, the method will return True immediately.
    Precisely, if the current thread already holds the lock, its
    internal counter is simply incremented. If nobody holds the lock,
    the lock is taken and its internal counter initialized to 1. """
    pass

  def release(self):
    """ Release the lock, allowing another thread that is blocked waiting for
    the lock to acquire the lock.  The lock must be in the locked state,
    and must be locked by the same thread that unlocks it; otherwise a
    `RuntimeError` is raised.
    
    Do note that if the lock was acquire()d several times in a row by the
    current thread, release() needs to be called as many times for the lock
    to be available for other threads. """
    pass

TIMEOUT_MAX = 9223372036.0

class _ExceptHookArgs(tuple):
  """ ExceptHookArgs
  
  Type used to pass arguments to threading.excepthook. """

  exc_traceback = None
  exc_type = None
  exc_value = None
  n_fields = 4
  n_sequence_fields = 4
  n_unnamed_fields = 0
  thread = None

class _ThreadHandle(object):

  def _set_done(self):
    pass

  ident = property(None, None, None,
                   )


  def is_done(self):
    pass

  def join(self):
    pass

__doc__ = """This module provides primitive operations to write multi-threaded programs.
The 'threading' module provides a more convenient interface."""

class __loader__(object):
  """ Meta path import for built-in modules.
  
  All methods are either class or static methods to avoid the need to
  instantiate the class.
  
   """

  _ORIGIN = 'built-in'

  def create_module(self, spec):
    """ Create a built-in module """
    pass

  def exec_module(self, module):
    """ Exec a built-in module """
    pass

  def find_spec(self, fullname, path=None, target=None):
    pass

  def get_code(self, fullname):
    """ Return None as built-in modules do not have code objects. """
    pass

  def get_source(self, fullname):
    """ Return None as built-in modules do not have source code. """
    pass

  def is_package(self, fullname):
    """ Return False as built-in modules are never packages. """
    pass

  def load_module(self, fullname):
    """ Load the specified module into sys.modules and return it.
    
    This method is deprecated.  Use loader.exec_module() instead.
    
     """
    pass

__name__ = '_thread'
__package__ = ''
__spec__ = None

def _count():
  """ Return the number of currently running Python threads, excluding
  the main thread. The returned number comprises all threads created
  through `start_new_thread()` as well as `threading.Thread`, and not
  yet finished.
  
  This function is meant for internal and specialized purposes only.
  In most applications `threading.enumerate()` should be used instead. """
  pass

def _excepthook():
  """ Handle uncaught Thread.run() exception. """
  pass

def _get_main_thread_ident():
  """ Internal only. Return a non-zero integer that uniquely identifies the main thread
  of the main interpreter. """
  pass

def _is_main_interpreter():
  """ Return True if the current interpreter is the main Python interpreter. """
  pass

class _local(object):
  """ Thread-local data """

  pass

def _make_thread_handle(ident):
  """ Internal only. Make a thread handle for threads not spawned
  by the _thread or threading module. """
  pass

def _shutdown():
  """ Wait for all non-daemon threads (other than the calling thread) to stop. """
  pass

def allocate():
  """ An obsolete synonym of allocate_lock(). """
  pass

def allocate_lock(arg0):
  """ Create a new lock object. See help(type(threading.Lock())) for
  information about locks. """
  pass

def daemon_threads_allowed():
  """ Return True if daemon threads are allowed in the current interpreter,
  and False otherwise.
   """
  pass

class error(Exception):
  """ Unspecified run-time error. """

  def __init__(self, *args, **kwargs):
    pass

def exit():
  """ This is synonymous to ``raise SystemExit''.  It will cause the current
  thread to exit silently unless the exception is caught. """
  pass

def exit_thread():
  """ An obsolete synonym of exit(). """
  pass

def get_ident():
  """ Return a non-zero integer that uniquely identifies the current thread
  amongst other threads that exist simultaneously.
  This may be used to identify per-thread resources.
  Even though on some platforms threads identities may appear to be
  allocated consecutive numbers starting at 1, this behavior should not
  be relied upon, and the number should be seen purely as a magic cookie.
  A thread's identity may be reused for another thread after it exits. """
  pass

def get_native_id():
  """ Return a non-negative integer identifying the thread as reported
  by the OS (kernel). This may be used to uniquely identify a
  particular thread within a system. """
  pass

def interrupt_main():
  """ Simulate the arrival of the given signal in the main thread,
  where the corresponding signal handler will be executed.
  If *signum* is omitted, SIGINT is assumed.
  A subthread can use this function to interrupt the main thread.
  
  Note: the default signal handler for SIGINT raises ``KeyboardInterrupt``. """
  pass

class lock(object):
  """ A lock object is a synchronization primitive.  To create a lock,
  call threading.Lock().  Methods are:
  
  acquire() -- lock the lock, possibly blocking until it can be obtained
  release() -- unlock of the lock
  locked() -- test whether the lock is currently locked
  
  A lock is not owned by the thread that locked it; another thread may
  unlock it.  A thread attempting to lock a lock that it has already locked
  will block until another thread unlocks it.  Deadlocks may ensue. """

  def _at_fork_reinit(self):
    pass

  def acquire(self, blocking=True, timeout=-1):
    """ Lock the lock.  Without argument, this blocks if the lock is already
    locked (even by the same thread), waiting for another thread to release
    the lock, and return True once the lock is acquired.
    With an argument, this will only block if the argument is true,
    and the return value reflects whether the lock is acquired.
    The blocking operation is interruptible. """
    pass

  def acquire_lock(self, blocking=True, timeout=-1):
    """ An obsolete synonym of acquire(). """
    pass

  def locked(self):
    """ Return whether the lock is in the locked state. """
    pass

  def locked_lock(self):
    """ An obsolete synonym of locked(). """
    pass

  def release(self):
    """ Release the lock, allowing another thread that is blocked waiting for
    the lock to acquire the lock.  The lock must be in the locked state,
    but it needn't be locked by the same thread that unlocks it. """
    pass

  def release_lock(self):
    """ An obsolete synonym of release(). """
    pass

def stack_size(size=0):
  """ Return the thread stack size used when creating new threads.  The
  optional size argument specifies the stack size (in bytes) to be used
  for subsequently created threads, and must be 0 (use platform or
  configured default) or a positive integer value of at least 32,768 (32k).
  If changing the thread stack size is unsupported, a ThreadError
  exception is raised.  If the specified size is invalid, a ValueError
  exception is raised, and the stack size is unmodified.  32k bytes
   currently the minimum supported stack size value to guarantee
  sufficient stack space for the interpreter itself.
  
  Note that some platforms may have particular restrictions on values for
  the stack size, such as requiring a minimum stack size larger than 32 KiB or
  requiring allocation in multiples of the system memory page size
  - platform documentation should be referred to for more information
  (4 KiB pages are common; using multiples of 4096 for the stack size is
  the suggested approach in the absence of more specific information). """
  pass

def start_joinable_thread(function, handle=None, daemon=True):
  """ *For internal use only*: start a new thread.
  
  Like start_new_thread(), this starts a new thread calling the given function.
  Unlike start_new_thread(), this returns a handle object with methods to join
  or detach the given thread.
  This function is not for third-party code, please use the
  `threading` module instead. During finalization the runtime will not wait for
  the thread to exit if daemon is True. If handle is provided it must be a
  newly created thread._ThreadHandle instance. """
  pass

def start_new(function, args, kwargs={}):
  """ An obsolete synonym of start_new_thread(). """
  pass

def start_new_thread(function, args, kwargs={}):
  """ Start a new thread and return its identifier.
  
  The thread will call the function with positional arguments from the
  tuple args and keyword arguments taken from the optional dictionary
  kwargs.  The thread exits when the function returns; the return value
  is ignored.  The thread will also exit when the function raises an
  unhandled exception; a stack trace will be printed unless the exception
  is SystemExit. """
  pass