Module dup_threading

Assert that threading is required for operation to continue. Raise an appropriate exception if this is not the case.

Call fn with lock acquired. Guarantee that lock is released upon the return of fn.

Returns the value returned by fn, or raises the exception raised by fn.

cv   - The threading.Condition instance to wait on
test - Callable returning a boolean to indicate whether
       the criteria being waited on has been satisfied.

Perform a wait on a condition such that it is keyboard
interruptable when done in the main thread. Due to Python
limitations as of <= 2.5, lock acquisition and conditions waits
are not interruptable when performed in the main thread.

Currently, this comes at a cost additional CPU use, compared to a
normal wait. Future implementations may be more efficient if the
underlying python supports it.

The condition must be acquired.

This function should only be used on conditions that are never
expected to be acquired for extended periods of time, or the
lock-acquire of the underlying condition could cause an
uninterruptable state despite the efforts of this function.

There is no equivalent for acquireing a lock, as that cannot be
done efficiently.

Example:

Instead of:

  cv.acquire()
  while not thing_done:
    cv.wait(someTimeout)
  cv.release()

do:

  cv.acquire()
  interruptable_condwait(cv, lambda: thing_done)
  cv.release()

Splits the act of calling the given function into one front-end part for waiting on the result, and a back-end part for performing the work in another thread.

Returns (waiter, caller) where waiter is a function to be called in order to wait for the results of an asynchronous invokation of fn to complete, returning fn's result or propagating it's exception.