Utiliser WebSocket avec Python

Qu’est-ce que WebSocket ?

WebSocket est un protocole qui permet une communication bidirectionnelle en temps réel entre un navigateur et un serveur. La communication HTTP traditionnelle implique que le client envoie une requête et que le serveur réponde pour échanger des données. En revanche, avec WebSocket, une fois la connexion initiale établie, le client et le serveur peuvent s'envoyer et recevoir des messages sans avoir besoin d'établir de nouvelles connexions à plusieurs reprises.

Récemment, les services interactifs tels que l'API OpenAI Realtime et Hume AI sont devenus plus courants, entraînant une augmentation anticipée de la demande pour WebSocket. Cet article présente les bases de l'utilisation de WebSocket, ainsi qu'un aperçu du traitement asynchrone associé.

Utiliser WebSocket avec Python

En Python, vous pouvez utiliser WebSocket comme indiqué ci-dessous :

import asyncio
import websockets

uri = "ws://..."

async def hello():
    async with websockets.connect(uri) as websocket:
        await websocket.send("Hello, Server!")
        response = await websocket.recv()
        print(f"Server says: {response}")

asyncio.run(hello())

1. Connectez-vous au serveur WebSocket à l'aide de websockets.connect(uri).
2. Envoyez un message avec websocket.send(message).
3. Recevez un message en utilisant websocket.recv().

Traitement asynchrone

Les async et wait utilisés dans le code précédent représentent un traitement asynchrone. Le traitement asynchrone est particulièrement efficace lors de l'exécution simultanée de plusieurs tâches.

import asyncio

async def task1():
    print("Task 1: Start")
    await asyncio.sleep(2)  # Wait for 2 seconds
    print("Task 1: End")

async def task2():
    print("Task 2: Start")
    await asyncio.sleep(1)  # Wait for 1 second
    print("Task 2: End")

async def main():
    await asyncio.gather(task1(), task2())

asyncio.run(main())

Dans les fonctions qui utilisent wait, d'autres tâches peuvent s'exécuter en attendant la fin de la tâche en cours. Cela permet une commutation efficace entre les tâches.

Traitement asynchrone et multithreading

Le multithreading gère également plusieurs tâches, mais il existe une différence dans la façon dont les threads sont utilisés :

• En multithreading, chaque tâche a son propre thread et le programme bascule entre les tâches en attendant la fin de certains processus.
• Le traitement asynchrone, en revanche, ne crée pas de nouveaux threads mais bascule entre les tâches.

Le multithreading est efficace lorsque vous travaillez avec des opérations gourmandes en CPU ou bloquantes. Cependant, il présente des inconvénients tels que la surcharge due au changement de thread (changement de contexte) et une consommation de mémoire accrue.

En revanche, le traitement asynchrone réduit la surcharge liée au changement de contexte car il ne repose pas sur les threads. Cependant, si une tâche lourde est en cours d’exécution, d’autres tâches devront peut-être attendre. En tant que tel, il convient aux opérations liées aux IO telles que les requêtes API.

(Pour les tâches qui nécessitent beaucoup de calculs ou nécessitent un timing précis, le multitraitement est souvent plus efficace. Contrairement au multithreading, le multitraitement permet à plusieurs tâches de s'exécuter simultanément.)

Par exemple, lorsque vous utilisez l'API OpenAI Realtime pour recevoir l'audio d'un microphone en temps réel et envoyer les données audio à l'API, vous pouvez utiliser une combinaison de multithreading et de traitement asynchrone :

import asyncio
import threading
import queue
import pyaudio
import websockets

# Use a queue to share data between threads
audio_queue = queue.Queue()

# Thread to capture audio using PyAudio
def audio_stream():
    p = pyaudio.PyAudio()
    stream = p.open(format=pyaudio.paInt16,
                    channels=1,
                    rate=44100,
                    input=True,
                    frames_per_buffer=1024)

    print("Start recording...")
    while True:
        data = stream.read(1024)
        audio_queue.put(data)

# Asynchronous function to send audio data via WebSocket
async def send_audio():
    uri = "ws://localhost:8765"
    async with websockets.connect(uri) as websocket:
        while True:
            # Get audio data from the queue
            data = audio_queue.get()
            if data is None:
                break
            await websocket.send(data)
            print("Sent audio data")

# Start the audio capture thread and run the asynchronous task
def main():
    audio_thread = threading.Thread(target=audio_stream)
    audio_thread.start()

    # Run the WebSocket sending task
    asyncio.run(send_audio())

if __name__ == "__main__":
    main()

Le processus de capture audio est une opération bloquante, il est donc exécuté dans un thread séparé à l'aide du threading. En revanche, l'envoi des données audio, qui implique des opérations liées aux E/S comme l'interaction avec une API, s'effectue à l'aide d'un traitement asynchrone. (Remarque : PyAudio peut également être exécuté de manière non bloquante à l'aide de rappels. )

Conclusion

Dans cet article, nous avons présenté WebSocket et le traitement asynchrone.

J'ai trouvé ces concepts particulièrement déroutants lorsque je travaillais avec l'API OpenAI Realtime, j'ai donc rassemblé cela comme une note personnelle. Si vous trouvez des erreurs ou avez des commentaires, j'apprécierais votre contribution.

Merci d'avoir lu jusqu'à la fin.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!