Chamada de método assíncrona em Python?

Eu queria saber se existe alguma biblioteca para chamadas de método assíncronas em Python . Seria ótimo se você pudesse fazer algo como

@async
def longComputation():
    <code>


token = longComputation()
token.registerCallback(callback_function)
# alternative, polling
while not token.finished():
    doSomethingElse()
    if token.finished():
        result = token.result()

Ou para chamar uma rotina não assíncrona de forma assíncrona

def longComputation()
    <code>

token = asynccall(longComputation())

Seria ótimo ter uma estratégia mais refinada como nativa no núcleo do idioma. Isso foi considerado?

Você pode usar o módulo de multiprocessamento adicionado no Python 2.6. Você pode usar conjuntos de processos e obter resultados de forma assíncrona com:

apply_async(func[, args[, kwds[, callback]]])

Por exemplo:

from multiprocessing import Pool

def f(x):
    return x*x

if __name__ == '__main__':
    pool = Pool(processes=1)              # Start a worker processes.
    result = pool.apply_async(f, [10], callback) # Evaluate "f(10)" asynchronously calling callback when finished.

Esta é apenas uma alternativa. Este módulo fornece muitas facilidades para alcançar o que você deseja. Também será muito fácil fazer um decorador com isso.

Algo como:

import threading

thr = threading.Thread(target=foo, args=(), kwargs={})
thr.start() # Will run "foo"
....
thr.is_alive() # Will return whether foo is running currently
....
thr.join() # Will wait till "foo" is done

Consulte a documentação em https://docs.python.org/library/threading.html para obter mais detalhes.

No Python 3.5, você pode usar geradores aprimorados para funções assíncronas.

import asyncio
import datetime

Sintaxe aprimorada do gerador:

@asyncio.coroutine
def display_date(loop):
    end_time = loop.time() + 5.0
    while True:
        print(datetime.datetime.now())
        if (loop.time() + 1.0) >= end_time:
            break
        yield from asyncio.sleep(1)


loop = asyncio.get_event_loop()
# Blocking call which returns when the display_date() coroutine is done
loop.run_until_complete(display_date(loop))
loop.close()

Nova async/awaitsintaxe:

async def display_date(loop):
    end_time = loop.time() + 5.0
    while True:
        print(datetime.datetime.now())
        if (loop.time() + 1.0) >= end_time:
            break
        await asyncio.sleep(1)


loop = asyncio.get_event_loop()
# Blocking call which returns when the display_date() coroutine is done
loop.run_until_complete(display_date(loop))
loop.close()

Não está no núcleo da linguagem, mas uma biblioteca muito madura que faz o que você quer é o Twisted . Ele apresenta o objeto Adiado, ao qual você pode anexar retornos de chamada ou manipuladores de erros ("errbacks"). Um diferido é basicamente uma "promessa" de que uma função terá um resultado eventualmente.

Você pode implementar um decorador para tornar suas funções assíncronas, embora isso seja um pouco complicado. O multiprocessingmódulo está cheio de pequenas peculiaridades e restrições aparentemente arbitrárias - mais um motivo para encapsulá-lo atrás de uma interface amigável.

from inspect import getmodule
from multiprocessing import Pool


def async(decorated):
    r'''Wraps a top-level function around an asynchronous dispatcher.

        when the decorated function is called, a task is submitted to a
        process pool, and a future object is returned, providing access to an
        eventual return value.

        The future object has a blocking get() method to access the task
        result: it will return immediately if the job is already done, or block
        until it completes.

        This decorator won't work on methods, due to limitations in Python's
        pickling machinery (in principle methods could be made pickleable, but
        good luck on that).
    '''
    # Keeps the original function visible from the module global namespace,
    # under a name consistent to its __name__ attribute. This is necessary for
    # the multiprocessing pickling machinery to work properly.
    module = getmodule(decorated)
    decorated.__name__ += '_original'
    setattr(module, decorated.__name__, decorated)

    def send(*args, **opts):
        return async.pool.apply_async(decorated, args, opts)

    return send

O código abaixo ilustra o uso do decorador:

@async
def printsum(uid, values):
    summed = 0
    for value in values:
        summed += value

    print("Worker %i: sum value is %i" % (uid, summed))

    return (uid, summed)


if __name__ == '__main__':
    from random import sample

    # The process pool must be created inside __main__.
    async.pool = Pool(4)

    p = range(0, 1000)
    results = []
    for i in range(4):
        result = printsum(i, sample(p, 100))
        results.append(result)

    for result in results:
        print("Worker %i: sum value is %i" % result.get())

Em um caso do mundo real, eu elaboraria um pouco mais sobre o decorador, fornecendo uma maneira de desativá-lo para depuração (mantendo a interface futura no lugar) ou talvez um recurso para lidar com exceções; mas acho que isso demonstra o princípio suficientemente bem.

Somente

import threading, time

def f():
    print "f started"
    time.sleep(3)
    print "f finished"

threading.Thread(target=f).start()

Você poderia usar o eventlet. Ele permite que você escreva o que parece ser um código síncrono, mas que ele opere de forma assíncrona na rede.

Aqui está um exemplo de um rastreador super mínimo:

urls = ["http://www.google.com/intl/en_ALL/images/logo.gif",
     "https://wiki.secondlife.com/w/images/secondlife.jpg",
     "http://us.i1.yimg.com/us.yimg.com/i/ww/beta/y3.gif"]

import eventlet
from eventlet.green import urllib2

def fetch(url):

  return urllib2.urlopen(url).read()

pool = eventlet.GreenPool()

for body in pool.imap(fetch, urls):
  print "got body", len(body)

Minha solução é:

import threading

class TimeoutError(RuntimeError):
    pass

class AsyncCall(object):
    def __init__(self, fnc, callback = None):
        self.Callable = fnc
        self.Callback = callback

    def __call__(self, *args, **kwargs):
        self.Thread = threading.Thread(target = self.run, name = self.Callable.__name__, args = args, kwargs = kwargs)
        self.Thread.start()
        return self

    def wait(self, timeout = None):
        self.Thread.join(timeout)
        if self.Thread.isAlive():
            raise TimeoutError()
        else:
            return self.Result

    def run(self, *args, **kwargs):
        self.Result = self.Callable(*args, **kwargs)
        if self.Callback:
            self.Callback(self.Result)

class AsyncMethod(object):
    def __init__(self, fnc, callback=None):
        self.Callable = fnc
        self.Callback = callback

    def __call__(self, *args, **kwargs):
        return AsyncCall(self.Callable, self.Callback)(*args, **kwargs)

def Async(fnc = None, callback = None):
    if fnc == None:
        def AddAsyncCallback(fnc):
            return AsyncMethod(fnc, callback)
        return AddAsyncCallback
    else:
        return AsyncMethod(fnc, callback)

E funciona exatamente como solicitado:

@Async
def fnc():
    pass

Algo assim funciona para mim, você pode chamar a função e ela será despachada para um novo thread.

from thread import start_new_thread

def dowork(asynchronous=True):
    if asynchronous:
        args = (False)
        start_new_thread(dowork,args) #Call itself on a new thread.
    else:
        while True:
            #do something...
            time.sleep(60) #sleep for a minute
    return

Existe algum motivo para não usar threads? Você pode usar a threadingclasse Em vez da finished()função, use o isAlive(). A result()função poderia join()encadear e recuperar o resultado. E, se puder, substitua as funções run()e __init__para chamar a função especificada no construtor e salve o valor em algum lugar da instância da classe.

Você pode usar concurrent.futures (adicionado no Python 3.2).

import time
from concurrent.futures import ThreadPoolExecutor


def long_computation(duration):
    for x in range(0, duration):
        print(x)
        time.sleep(1)
    return duration * 2


print('Use polling')
with ThreadPoolExecutor(max_workers=1) as executor:
    future = executor.submit(long_computation, 5)
    while not future.done():
        print('waiting...')
        time.sleep(0.5)

    print(future.result())

print('Use callback')
executor = ThreadPoolExecutor(max_workers=1)
future = executor.submit(long_computation, 5)
future.add_done_callback(lambda f: print(f.result()))

print('waiting for callback')

executor.shutdown(False)  # non-blocking

print('shutdown invoked')

Você pode usar o processo. Se você deseja executá-lo para sempre, use enquanto (como rede) em sua função:

from multiprocessing import Process
def foo():
    while 1:
        # Do something

p = Process(target = foo)
p.start()

se você quiser executá-lo apenas uma vez, faça o seguinte:

from multiprocessing import Process
def foo():
    # Do something

p = Process(target = foo)
p.start()
p.join()