human
Complete this python program:
def inlineCallbacks(f):
assistant
#Here is the Python program you requested.

    """inlineCallbacks helps you write L{Deferred}-using code that looks like a
    regular sequential function. For example::
    @inlineCallbacks
    def thingummy():
    thing = yield makeSomeRequestResultingInDeferred()
    print(thing)  # the result! hoorj!
    When you call anything that results in a L{Deferred}, you can simply yield it;
    your generator will automatically be resumed when the Deferred\s result is
    available. The generator will be sent the result of the L{Deferred} with the
    \send\ method on generators, or if the result was a failure, \throw\.
    Things that are not L{Deferred}s may also be yielded, and your generator
    will be resumed with the same object sent back. This means C{yield}
    performs an operation roughly equivalent to L{maybeDeferred}.
    Your inlineCallbacks-enabled generator will return a L{Deferred} object, which
    will result in the return value of the generator (or will fail with a
    failure object if your generator raises an unhandled exception). Note that
    you can\t use C{return result} to return a value; use C{returnValue(result)}
    instead. Falling off the end of the generator, or simply using C{return}
    will cause the L{Deferred} to have a result of L{None}.
    Be aware that L{returnValue} will not accept a L{Deferred} as a parameter.
    If you believe the thing you\d like to return could be a L{Deferred}, do
    this::
    result = yield result
    returnValue(result)
    The L{Deferred} returned from your deferred generator may errback if your
    generator raised an exception::
    @inlineCallbacks
    def thingummy():
    thing = yield makeSomeRequestResultingInDeferred()
    if thing == \I love Twisted\:
    # will become the result of the Deferred
    returnValue(\TWISTED IS GREAT!\)
    else:
    # will trigger an errback
    raise Exception(\DESTROY ALL LIFE\)
    If you are using Python 3.3 or later, it is possible to use the C{return}
    statement instead of L{returnValue}::
    @inlineCallbacks
    def loadData(url):
    response =..."""
    @wraps(f)
    def unwindGenerator(*args, **kwargs):
        try:
            gen = f(*args, **kwargs)
        except _DefGen_Return:
            raise TypeError(('inlineCallbacks    requires    %r    to    produce    a    generator;    insteadcaught    returnValue    being    used    in    a    non-generator' % (f,)))
        if (not isinstance(gen, types.GeneratorType)):
            raise TypeError(('inlineCallbacks    requires    %r    to    produce    a    generator;    instead    got    %r' % (f, gen)))
        return _inlineCallbacks(None, gen, Deferred())
    return unwindGenerator