from time import time

from twisted.internet import reactor
from twisted.internet.defer import Deferred, DeferredList, inlineCallbacks, returnValue

@inlineCallbacks
def timeWrapper(d):
    start = time()
    result = (yield d)
    end = time()
    returnValue(end - start)

def sleep(t):
    d = Deferred()
    reactor.callLater(t, lambda *args: d.callback(None))
    return d

@inlineCallbacks
def waitAll(deferreds):
    results  = (yield DeferredList(deferreds, fireOnOneErrback=1))
    
    if any(not success for success, result in  results):
        raise Exception(results)

    returnValue([result for success, result in results])

def runDeferred(deferred):
    result = {"return": None, "error": None}

    @inlineCallbacks
    def runThenCrash(result = result):
        try:
            result["return"] = yield deferred
        except Exception, e:
            result["error"] = e
        reactor.stop()

    runThenCrash()
    reactor.run()

    if result["error"] is not None:
        raise result["error"]
    else:
        return result["return"]