Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Valdymas WebSocket sesijomis

Paskaita 11 iš 14 Atnaujinta 2026 m. lapkričio 3 d. Kūrėjas
Šiame puslapyje
  1. Įvaldyk sesijos gyvavimo ciklą
  2. Sesijos gyvavimo ciklas
  3. Automatinis prisijungimas iš naujo
  4. Sesijos gyvavimo trukmės valdymas
  5. Sesijų telkinys
  6. Stebimi rodikliai
  7. Svarbiausi punktai

Atnaujinta 2026 m. lapkričio 3 d., remiantis xAI Text to Speech puslapiu, kuriame minima 600 sekundžių „sesijos leidimas“ ir ryšys be laiko limito. Toliau pateikta atnaujinimo strategija yra atsargumo priemonė. Šaltinis: Text to Speech.

Įvaldyk sesijos gyvavimo ciklą

Gaminiuose būtent patikimas WebSocket sesijų valdymas atskiria prototipą nuo patikimo produkto. TTS sesijos turi specifinių apribojimų (gyvavimo trukmė, vienalaikiškumo limitai), kuriuos tavo programa turi tinkamai apdoroti.

Sesijos gyvavimo ciklas

TTS WebSocket sesija pereina šį ciklą:

  1. Atidarymas: prisijungimas prie wss://api.x.ai/v1/tts su parametrais
  2. Aktyvus: keitimasis text.delta/audio.delta žinutėmis
  3. Normalus uždarymas: klientas arba serveris užveria ryšį
  4. Netikėtas uždarymas: klaida, techninė priežiūra arba dokumentacijoje minimo 600 sekundžių sesijos leidimo pabaiga

Aptikti uždarymą

Serveris gali bet kada nutraukti ryšį (vidinė klaida, techninė priežiūra, sesijos leidimo pabaiga). Tavo programa visada turi apdoroti uždarymo įvykį:

async def managed_session(api_key, language="en", voice="eve"):
    uri = f"wss://api.x.ai/v1/tts?language={language}&voice={voice}"
    headers = {"Authorization": f"Bearer {api_key}"}

    try:
        async with websockets.connect(uri, additional_headers=headers) as ws:
            yield ws
    except websockets.ConnectionClosed as e:
        print(f"Connection closed: code={e.code}, reason={e.reason}")
    except websockets.ConnectionClosedError:
        print("Connection lost unexpectedly")

Automatinis prisijungimas iš naujo

Ilgo veikimo programoms įgyvendink prisijungimą iš naujo naudodamas eksponentinį delsą:

import asyncio
import random

class TTSSessionManager:
    def __init__(self, api_key, language="en", voice="eve"):
        self.api_key = api_key
        self.language = language
        self.voice = voice
        self.ws = None
        self.max_retries = 5

    async def connect(self):
        uri = f"wss://api.x.ai/v1/tts?language={self.language}&voice={self.voice}"
        headers = {"Authorization": f"Bearer {self.api_key}"}

        for attempt in range(self.max_retries):
            try:
                self.ws = await websockets.connect(uri, additional_headers=headers)
                print(f"Connected (attempt {attempt + 1})")
                return
            except Exception as e:
                wait = min(2 ** attempt + random.random(), 30)
                print(f"Connection failed: {e}. Retrying in {wait:.1f}s")
                await asyncio.sleep(wait)

        raise ConnectionError("Could not connect after 5 attempts")

    async def ensure_connected(self):
        if self.ws is None or self.ws.closed:
            await self.connect()

    async def synthesize(self, text):
        await self.ensure_connected()

        try:
            await self.ws.send(json.dumps({
                "type": "text.delta",
                "delta": text
            }))
            await self.ws.send(json.dumps({"type": "text.done"}))

            audio_chunks = []
            async for msg in self.ws:
                data = json.loads(msg)
                if data["type"] == "audio.delta":
                    audio_chunks.append(base64.b64decode(data["delta"]))
                elif data["type"] == "audio.done":
                    break
                elif data["type"] == "error":
                    raise Exception(data["message"])

            return b"".join(audio_chunks)

        except websockets.ConnectionClosed:
            # Prisijungti iš naujo ir bandyti dar kartą
            await self.connect()
            return await self.synthesize(text)

Sesijos gyvavimo trukmės valdymas

xAI Text to Speech puslapyje minimas 600 sekundžių „sesijos leidimas“, tačiau nenurodoma, kada jis prasideda ir kas nutinka jam pasibaigus, o atskirai teigiama, kad ryšys neturi laiko limito. Saugiausias būdas – skaičiuoti laiką nuo prisijungimo momento ir atnaujinti sesiją prieš tai įvykstant:

import time

class TTLAwareSession:
    TTL = 600  # sekundės
    REFRESH_MARGIN = 60  # prisijungti iš naujo likus 60 s iki galiojimo pabaigos

    def __init__(self):
        self.connected_at = None

    async def connect(self):
        # ... prisijungimas ...
        self.connected_at = time.time()

    def should_refresh(self):
        if self.connected_at is None:
            return True
        elapsed = time.time() - self.connected_at
        return elapsed >= (self.TTL - self.REFRESH_MARGIN)

    async def synthesize(self, text):
        if self.should_refresh():
            await self.connect()  # Nauja sesija
        # ... siųsti tekstą ...

Prisijungimas iš naujo likus 60 sekundžių iki galiojimo pabaigos apsaugo tave nuo nutraukimo sintezės viduryje.

Sesijų telkinys

Didelio srauto programoms laikyk pakartotinai naudojamų sesijų telkinį:

class SessionPool:
    def __init__(self, api_key, pool_size=10):
        self.api_key = api_key
        self.pool_size = min(pool_size, 50)  # Maks. 50 vienai komandai
        self.available = asyncio.Queue()
        self.active_count = 0

    async def acquire(self):
        if not self.available.empty():
            session = await self.available.get()
            if not session.should_refresh():
                return session

        if self.active_count < self.pool_size:
            session = TTSSessionManager(self.api_key)
            await session.connect()
            self.active_count += 1
            return session

        # Laukti, kol atsiras laisva sesija
        return await self.available.get()

    async def release(self, session):
        await self.available.put(session)

Laikyk telkinio dydį mažesniu nei 50 sesijų limitas, kad liktų rezervos kitoms tavo programos tarnyboms.

Stebimi rodikliai

Kad sesijos veiktų sklandžiai gaminiuose, stebėk:

  • Aktyvių sesijų skaičius: negali viršyti 50
  • Prisijungimų iš naujo dažnis: didelis rodiklis rodo tinklo arba gyvavimo trukmės problemą
  • Pirmojo audio.delta delsos laikas: parodo, kaip greitai reaguoja tarnyba
  • WebSocket klaidos: neįprasti uždarymo kodai (1006, 1011)
class MetricsCollector:
    def __init__(self):
        self.connections = 0
        self.reconnections = 0
        self.errors = 0
        self.first_audio_latencies = []

    def record_connection(self):
        self.connections += 1

    def record_reconnection(self):
        self.reconnections += 1

    def record_first_audio(self, latency_ms):
        self.first_audio_latencies.append(latency_ms)

Svarbiausi punktai

  • Dokumentacijoje minimas 600 sekundžių sesijos leidimas: saugumo sumetimais skaičiuok jį nuo prisijungimo momento
  • Įgyvendink automatinį prisijungimą iš naujo su eksponentiniu delsos laiku
  • Atnaujink sesiją prieš jai pasibaigiant (su 60 sekundžių atsarga)
  • Didelio srauto programoms naudok sesijų telkinį
  • Laikykitės 50 vienalaikių sesijų vienai komandai limito
  • Gaminiuose stebėk ryšio rodiklius