example - tornado python mac

Diferencia en tornado.gen.engine v/s tornado.gen.coroutine

Question

Pasando por la documentación tornado.gen alguien me puede ayudar a entender la diferencia exacta entre tornado.gen.coroutine y tornado.gen.engine

Answer 1

Como dice la documentación del tornado para gen.engine :

Este decorador es similar a coroutine, excepto que no devuelve un futuro y el argumento de devolución de llamada no se trata de manera especial.

Y como dice la documentación de gen.coroutine

Desde la perspectiva de la persona que llama, @ gen.coroutine es similar a la combinación de @return_future y @ gen.engine.

gen.engine es básicamente una versión más antigua, menos aerodinámica de lo que hace coroutine. Si está escribiendo un código nuevo, debe seguir los consejos de la documentación y siempre usar tornado.gen.coroutine .

Es bastante evidente si mira el código para ambas funciones (con la documentación eliminada).

motor:

def engine(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
runner = None
def handle_exception(typ, value, tb):
if runner is not None:
return runner.handle_exception(typ, value, tb)
return False
with ExceptionStackContext(handle_exception) as deactivate:
try:
result = func(*args, **kwargs)
except (Return, StopIteration) as e:
result = getattr(e, ''value'', None)
else:
if isinstance(result, types.GeneratorType):
def final_callback(value):
if value is not None:
raise ReturnValueIgnoredError(
"@gen.engine functions cannot return values: "
"%r" % (value,))
assert value is None
deactivate()
runner = Runner(result, final_callback)
runner.run()
return
if result is not None:
raise ReturnValueIgnoredError(
"@gen.engine functions cannot return values: %r" %
(result,))
deactivate()
# no yield, so we''re done
return wrapper

coroutine:

def coroutine(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
runner = None
future = TracebackFuture()
if ''callback'' in kwargs:
callback = kwargs.pop(''callback'')
IOLoop.current().add_future(
future, lambda future: callback(future.result()))
def handle_exception(typ, value, tb):
try:
if runner is not None and runner.handle_exception(typ, value, tb):
return True
except Exception:
typ, value, tb = sys.exc_info()
future.set_exc_info((typ, value, tb))
return True
with ExceptionStackContext(handle_exception) as deactivate:
try:
result = func(*args, **kwargs)
except (Return, StopIteration) as e:
result = getattr(e, ''value'', None)
except Exception:
deactivate()
future.set_exc_info(sys.exc_info())
return future
else:
if isinstance(result, types.GeneratorType):
def final_callback(value):
deactivate()
future.set_result(value)
runner = Runner(result, final_callback)
runner.run()
return future
deactivate()
future.set_result(result)
return future
return wrapper

Ambas son probablemente bastante difíciles de entender a primera vista. Pero aún así, es obvio que el código es muy similar, excepto que @gen.coroutine tiene un manejo especial del kwarg de callback de callback , y crea / devuelve un Future . @gen.engine tiene un código que específicamente arroja un error si intentas devolver algo de él, en lugar de ponerlo en el Future .