"greenthread" -- Green Thread Implementation
********************************************

class eventlet.greenthread.GreenThread(parent)

   The GreenThread class is a type of Greenlet which has the
   additional property of being able to retrieve the return value of
   the main function. Do not construct GreenThread objects directly;
   call "spawn()" to get one.

   cancel(*throw_args)

      Kills the greenthread using "kill()", but only if it hasn't
      already started running.  After being canceled, all calls to
      "wait()" will raise *throw_args* (which default to
      "greenlet.GreenletExit").

   kill(*throw_args)

      Kills the greenthread using "kill()".  After being killed all
      calls to "wait()" will raise *throw_args* (which default to
      "greenlet.GreenletExit").

   link(func, *curried_args, **curried_kwargs)

      Set up a function to be called with the results of the
      GreenThread.

      The function must have the following signature:

         def func(gt, [curried args/kwargs]):

      When the GreenThread finishes its run, it calls *func* with
      itself and with the curried arguments supplied at link-time.  If
      the function wants to retrieve the result of the GreenThread, it
      should call wait() on its first argument.

      Note that *func* is called within execution context of the
      GreenThread, so it is possible to interfere with other linked
      functions by doing things like switching explicitly to another
      greenthread.

   unlink(func, *curried_args, **curried_kwargs)

      remove linked function set by "link()"

      Remove successfully return True, otherwise False

   wait()

      Returns the result of the main function of this GreenThread.  If
      the result is a normal return value, "wait()" returns it.  If it
      raised an exception, "wait()" will raise the same exception
      (though the stack trace will unavoidably contain some frames
      from within the greenthread module).

eventlet.greenthread.getcurrent() -> greenlet

   Returns the current greenlet (i.e. the one which called this
   function).

eventlet.greenthread.kill(g, *throw_args)

   Terminates the target greenthread by raising an exception into it.
   Whatever that greenthread might be doing; be it waiting for I/O or
   another primitive, it sees an exception right away.

   By default, this exception is GreenletExit, but a specific
   exception may be specified.  *throw_args* should be the same as the
   arguments to raise; either an exception instance or an exc_info
   tuple.

   Calling "kill()" causes the calling greenthread to cooperatively
   yield.

eventlet.greenthread.sleep(seconds=0)

   Yield control to another eligible coroutine until at least
   *seconds* have elapsed.

   *seconds* may be specified as an integer, or a float if fractional
   seconds are desired. Calling "sleep()" with *seconds* of 0 is the
   canonical way of expressing a cooperative yield. For example, if
   one is looping over a large list performing an expensive
   calculation without calling any socket methods, it's a good idea to
   call "sleep(0)" occasionally; otherwise nothing else will run.

eventlet.greenthread.spawn(func, *args, **kwargs)

   Create a greenthread to run "func(*args, **kwargs)".  Returns a
   "GreenThread" object which you can use to get the results of the
   call.

   Execution control returns immediately to the caller; the created
   greenthread is merely scheduled to be run at the next available
   opportunity. Use "spawn_after()" to  arrange for greenthreads to be
   spawned after a finite delay.

eventlet.greenthread.spawn_after(seconds, func, *args, **kwargs)

   Spawns *func* after *seconds* have elapsed.  It runs as scheduled
   even if the current greenthread has completed.

   *seconds* may be specified as an integer, or a float if fractional
   seconds are desired. The *func* will be called with the given
   *args* and keyword arguments *kwargs*, and will be executed within
   its own greenthread.

   The return value of "spawn_after()" is a "GreenThread" object,
   which can be used to retrieve the results of the call.

   To cancel the spawn and prevent *func* from being called, call
   "GreenThread.cancel()" on the return value of "spawn_after()". This
   will not abort the function if it's already started running, which
   is generally the desired behavior.  If terminating *func*
   regardless of whether it's started or not is the desired behavior,
   call "GreenThread.kill()".

eventlet.greenthread.spawn_after_local(seconds, func, *args, **kwargs)

   Spawns *func* after *seconds* have elapsed.  The function will NOT
   be called if the current greenthread has exited.

   *seconds* may be specified as an integer, or a float if fractional
   seconds are desired. The *func* will be called with the given
   *args* and keyword arguments *kwargs*, and will be executed within
   its own greenthread.

   The return value of "spawn_after()" is a "GreenThread" object,
   which can be used to retrieve the results of the call.

   To cancel the spawn and prevent *func* from being called, call
   "GreenThread.cancel()" on the return value. This will not abort the
   function if it's already started running.  If terminating *func*
   regardless of whether it's started or not is the desired behavior,
   call "GreenThread.kill()".

eventlet.greenthread.spawn_n(func, *args, **kwargs)

   Same as "spawn()", but returns a "greenlet" object from which it is
   not possible to retrieve either a return value or whether it raised
   any exceptions.  This is faster than "spawn()"; it is fastest if
   there are no keyword arguments.

   If an exception is raised in the function, spawn_n prints a stack
   trace; the print can be disabled by calling
   "eventlet.debug.hub_exceptions()" with False.
