'Wait until notified or until a timeout occurs.
If the calling thread has not acquired the lock when this method is
called, a RuntimeError is raised.
This method releases the underlying lock, and then blocks until it is
awakened by a notify() or notifyAll() call for the same condition
variable in another thread, or until the optional timeout occurs. Once
awakened or timed out, it re-acquires the lock and returns.
When the timeout argument is present and not None, it should be a
floating point number specifying a timeout for the operation in seconds
(or fractions thereof).
When the underlying lock is an RLock, it is not released using its
release() method, since this may not actually unlock the lock when it
was acquired multiple times recursively. Instead, an internal interface
of the RLock class is used, which really unlocks it even when it has
been recursively acquired several times. Another internal interface is
then used to restore the recursion level when the lock is reacquired.'

def wait(self, timeout=None):

    if (not self._is_owned()):
        raise RuntimeError('cannot    wait    on    un-acquired    lock')
    waiter = _allocate_lock()
    waiter.acquire()
    self.__waiters.append(waiter)
    saved_state = self._release_save()
    try:
        if (timeout is None):
            waiter.acquire()
            if __debug__:
                self._note('%s.wait():    got    it', self)
        else:
            endtime = (_time() + timeout)
            delay = 0.0005
            while True:
                gotit = waiter.acquire(0)
                if gotit:
                    break
                remaining = (endtime - _time())
                if (remaining <= 0):
                    break
                delay = min((delay * 2), remaining, 0.05)
                _sleep(delay)
            if (not gotit):
                if __debug__:
                    self._note('%s.wait(%s):    timed    out', self, timeout)
                try:
                    self.__waiters.remove(waiter)
                except ValueError:
                    pass
            elif __debug__:
                self._note('%s.wait(%s):    got    it', self, timeout)
    finally:
        self._acquire_restore(saved_state)
