Python-exécution du serveur websocket Autobahn / Python asyncio dans un sous-processus ou un thread séparé

La réponse de @dano peut être correcte, mais crée un nouveau processus qui n'est pas nécessaire dans la plupart des situations.

J'ai trouvé cette question sur Google parce que j'avais moi-même le même problème. J'ai écrit une application où je voulais qu'une api websocket ne s'exécute pas sur le thread principal et cela a causé votre problème.

J'ai trouvé ma solution alternative en lisant simplement sur les boucles d'événements sur la documentation python et trouvé l'asyncio.new_event_loop et asyncio.set_event_loop fonctions qui ont résolu ce problème.

Je n'ai pas utilisé AutoBahn mais la bibliothèque WebSockets pypi, et voici ma solution

import websockets
import asyncio
import threading

class WebSocket(threading.Thread):    
    @asyncio.coroutine
    def handler(self, websocket, path):
        name = yield from websocket.recv()
        print("< {}".format(name))
        greeting = "Hello {}!".format(name)
        yield from websocket.send(greeting)
        print("> {}".format(greeting))

    def run(self):
        start_server = websockets.serve(self.handler, '127.0.0.1', 9091)
        eventloop = asyncio.new_event_loop()
        asyncio.set_event_loop(eventloop)
        eventloop.run_until_complete(start_server)
        eventloop.run_forever()

if __name__ == "__main__":
    ws = WebSocket()
    ws.start()

"Existe-t-il même un moyen d'intégrer une boucle d'événement asyncio dans un programme/Tkinter actuellement multithread?"

Oui, exécutez votre programme tkinter avec une boucle d'événement asyncio. La preuve de concept.

'''Proof of concept integrating asyncio and tk loops.

Terry Jan Reedy
Run with 'python -i' or from IDLE editor to keep tk window alive.
'''

import asyncio
import datetime as dt
import tkinter as tk

loop = asyncio.get_event_loop()
root = tk.Tk()

# Combine 2 event loop examples from BaseEventLoop doc.
# Add button to prove that gui remain responsive between time updates.
# Prints statements are only for testing.

def flipbg(widget, color):
    bg = widget['bg']
    print('click', bg, loop.time())
    widget['bg'] = color if bg == 'white' else 'white'

hello = tk.Label(root)
flipper = tk.Button(root, text='Change hello background', bg='yellow',
                    command=lambda: flipbg(hello, 'red'))
time = tk.Label(root)
hello.pack()
flipper.pack()
time.pack()

def hello_world(loop):
    hello['text'] = 'Hello World'
loop.call_soon(hello_world, loop)

def display_date(end_time, loop):
    print(dt.datetime.now())
    time['text'] = dt.datetime.now()
    if (loop.time() + 1.0) < end_time:
        loop.call_later(1, display_date, end_time, loop)
    else:
        loop.stop()

end_time = loop.time() + 10.1
loop.call_soon(display_date, end_time, loop)

# Replace root.mainloop with these 4 lines.
def tk_update():
    root.update()
    loop.call_soon(tk_update)  # or loop.call_later(delay, tk_update)
# Initialize loop before each run_forever or run_until_complete call    
tk_update() 
loop.run_forever()

J'ai expérimenté IDLE avec ces 4 lignes supplémentaires, avec un ralentissement seulement perceptible lorsque la syntaxe met en évidence 1000s de lignes.