Menggunakan WebSocket dengan Python

Apakah itu WebSocket?

WebSocket ialah protokol yang membolehkan komunikasi dua hala masa nyata antara penyemak imbas dan pelayan. Komunikasi HTTP tradisional melibatkan pelanggan menghantar permintaan dan pelayan bertindak balas terhadap pertukaran data. Sebaliknya, dengan WebSocket, setelah sambungan awal diwujudkan, kedua-dua pelanggan dan pelayan boleh menghantar dan menerima mesej antara satu sama lain tanpa perlu berulang kali mewujudkan sambungan baharu.

Baru-baru ini, perkhidmatan interaktif seperti OpenAI Realtime API dan Hume AI telah menjadi lebih biasa, membawa kepada peningkatan yang dijangkakan dalam permintaan untuk WebSocket. Artikel ini memperkenalkan asas cara menggunakan WebSocket, bersama-sama dengan melihat pemprosesan tak segerak yang berkaitan.

Menggunakan WebSocket dengan Python

Dalam Python, anda boleh menggunakan WebSocket seperti yang ditunjukkan di bawah:

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. Sambung ke pelayan WebSocket menggunakan websockets.connect(uri).
2. Hantar mesej dengan websocket.send(message).
3. Terima mesej menggunakan websocket.recv().

Pemprosesan Asynchronous

Async dan tunggu yang digunakan dalam kod sebelumnya mewakili pemprosesan tak segerak. Pemprosesan tak segerak amat berkesan apabila melaksanakan berbilang tugas serentak.

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

Dalam fungsi yang menggunakan await, tugasan lain boleh dijalankan sementara menunggu selesainya tugasan semasa. Ini membolehkan pertukaran yang cekap antara tugas.

Pemprosesan Asynchronous dan Multithreading

Multithreading juga mengendalikan berbilang tugas, tetapi terdapat perbezaan dalam cara urutan digunakan:

• Dalam multithreading, setiap tugasan mempunyai urutan sendiri dan program bertukar antara tugas sementara menunggu proses tertentu selesai.
• Pemprosesan tak segerak, sebaliknya, tidak mencipta urutan baharu tetapi bertukar antara tugas.

Multithreading berkesan apabila bekerja dengan operasi intensif CPU atau menyekat. Walau bagaimanapun, ia mempunyai kelemahan seperti overhed daripada penukaran benang (penukaran konteks) dan peningkatan penggunaan memori.

Sebaliknya, pemprosesan tak segerak mengurangkan overhed daripada penukaran konteks kerana ia tidak bergantung pada urutan. Walau bagaimanapun, jika tugas berat sedang berjalan, tugas lain mungkin perlu menunggu. Oleh itu, ia sesuai untuk operasi terikat IO seperti permintaan API.

(Untuk tugasan yang intensif secara pengiraan atau memerlukan pemasaan yang tepat, berbilang pemprosesan selalunya lebih berkesan. Tidak seperti berbilang benang, berbilang pemprosesan membenarkan berbilang tugasan dijalankan serentak.)

Sebagai contoh, apabila menggunakan OpenAI Realtime API untuk menerima audio daripada mikrofon dalam masa nyata dan menghantar data audio ke API, anda boleh menggunakan gabungan pemprosesan berbilang benang dan tak segerak:

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

Proses penangkapan audio ialah operasi menyekat, jadi ia dilaksanakan dalam benang berasingan menggunakan benang. Sebaliknya, penghantaran data audio, yang melibatkan operasi terikat IO seperti berinteraksi dengan API, dilakukan menggunakan pemprosesan tak segerak. (Nota: PyAudio juga boleh dijalankan tanpa sekatan menggunakan panggilan balik. )

Kesimpulan

Dalam artikel ini, kami memperkenalkan WebSocket dan pemprosesan tak segerak.

Saya mendapati konsep ini sangat mengelirukan semasa bekerja dengan OpenAI Realtime API, jadi saya meletakkannya sebagai nota peribadi. Jika anda mendapati sebarang ralat atau mempunyai sebarang maklum balas, saya amat menghargai input anda.

Terima kasih kerana membaca sehingga habis.

Atas ialah kandungan terperinci Menggunakan WebSocket dengan Python. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!