¿Qué es WebSocket?

WebSocket es un protocolo que permite la comunicación bidireccional en tiempo real entre un navegador y un servidor. La comunicación HTTP tradicional implica que el cliente envía una solicitud y el servidor responde para intercambiar datos. Por el contrario, con WebSocket, una vez establecida la conexión inicial, tanto el cliente como el servidor pueden enviarse y recibir mensajes entre sí sin necesidad de establecer nuevas conexiones repetidamente.

Recientemente, los servicios interactivos como OpenAI Realtime API y Hume AI se han vuelto más comunes, lo que lleva a un aumento anticipado en la demanda de WebSocket. Este artículo presenta los conceptos básicos de cómo utilizar WebSocket, junto con una mirada al procesamiento asincrónico relacionado.

Usando WebSocket con Python

En Python, puedes usar WebSocket como se muestra a continuación:

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. Conéctese al servidor WebSocket usando websockets.connect(uri).
2. Enviar un mensaje con websocket.send(mensaje).
3. Recibir un mensaje usando websocket.recv().

Procesamiento asincrónico

Async y await utilizados en el código anterior representan procesamiento asincrónico. El procesamiento asincrónico es especialmente efectivo cuando se ejecutan múltiples tareas simultáneamente.

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())

En funciones que usan await, se pueden ejecutar otras tareas mientras se espera que se complete la tarea actual. Esto permite un cambio eficiente entre tareas.

Procesamiento asincrónico y subprocesos múltiples

El subproceso múltiple también maneja múltiples tareas, pero hay una diferencia en cómo se utilizan los subprocesos:

• En subprocesos múltiples, cada tarea tiene su propio subproceso y el programa cambia entre tareas mientras espera que se completen ciertos procesos.
• El procesamiento asincrónico, por otro lado, no crea nuevos hilos sino que cambia entre tareas.

El subproceso múltiple es efectivo cuando se trabaja con operaciones de bloqueo o que requieren un uso intensivo de la CPU. Sin embargo, tiene desventajas como la sobrecarga derivada del cambio de subprocesos (cambio de contexto) y un mayor consumo de memoria.

Por el contrario, el procesamiento asincrónico reduce la sobrecarga del cambio de contexto porque no depende de subprocesos. Sin embargo, si se está ejecutando una tarea pesada, es posible que otras tareas deban esperar. Como tal, es adecuado para operaciones vinculadas a IO, como solicitudes de API.

(Para tareas que requieren un uso intensivo de computación o una sincronización precisa, el multiprocesamiento suele ser más efectivo. A diferencia del multiproceso, el multiprocesamiento permite que se ejecuten múltiples tareas simultáneamente).

Por ejemplo, cuando usa OpenAI Realtime API para recibir audio desde un micrófono en tiempo real y enviar los datos de audio a la API, puede usar una combinación de procesamiento asincrónico y de subprocesos múltiples:

importar asincio importar subprocesos cola de importación importar paudio importar sockets web # Usar una cola para compartir datos entre hilos cola_audio = cola.Cola() # Hilo para capturar audio usando PyAudio def audio_stream(): p = pyaudio.PyAudio() flujo = p.open(formato=pyaudio.paInt16, canales = 1, tasa = 44100, entrada = Verdadero, fotogramas_por_búfer=1024) print("Comenzar a grabar...") mientras que Verdadero: datos = flujo.leer(1024) audio_queue.put(datos) # Función asincrónica para enviar datos de audio a través de WebSocket asíncrono def send_audio(): uri = "ws://localhost:8765" asíncrono con websockets.connect(uri) como websocket: mientras que Verdadero: # Obtener datos de audio de la cola datos = audio_queue.get() si los datos son Ninguno: romper esperar websocket.send(datos) print("Datos de audio enviados") # Inicie el hilo de captura de audio y ejecute la tarea asincrónica definición principal(): audio_thread = subprocesos.Thread(destino=audio_stream) hilo_audio.start() # Ejecutar la tarea de envío de WebSocket asyncio.run(enviar_audio()) si __nombre__ == "__principal__": principal()

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()

El proceso de captura de audio es una operación de bloqueo, por lo que se ejecuta en un hilo separado mediante subprocesos. Por el contrario, el envío de datos de audio, que implica operaciones vinculadas a IO, como interactuar con una API, se realiza mediante procesamiento asincrónico. (Nota: PyAudio también se puede ejecutar sin bloqueo mediante devoluciones de llamada).

Conclusión

En este artículo, presentamos WebSocket y el procesamiento asincrónico.

Encontré estos conceptos particularmente confusos mientras trabajaba con OpenAI Realtime API, así que los preparé como una nota personal. Si encuentra algún error o tiene algún comentario, le agradecería su opinión.

Gracias por leer hasta el final.