Léim go dtí an príomhábhar
Gaeilge— Roghnaigh teanga
Roghchlár

Bainistíocht seisiún WebSocket

Ceacht 11 as 14 Nuashonraithe 3 Samhain 2026 Forbróir
Ar an leathanach seo
  1. Máistir a dhéanamh ar shaolré an tseisiúin
  2. Saolré an tseisiúin
  3. Athnascadh uathoibríoch
  4. Bainistíocht ar shaolré an tseisiúin
  5. Linne seisiún
  6. Méadrachtaí le faire orthu
  7. Príomhphointí

Nuashonraithe an 3 Samhain 2026, bunaithe ar an leathanach Text to Speech ó xAI, a luaann “cead seisiúin” 600 soicind agus nasc gan aon teorainn ama. Is beart réamhchúraim é an straitéis athnuachana thíos. Foinse: Text to Speech.

Máistir a dhéanamh ar shaolré an tseisiúin

Sa táirgeadh, is é bainistíocht láidir sheisiún WebSocket an difríocht idir fréamhshamhail agus táirge iontaofa. Tagann srianta sonracha le seisiúin TTS (saolré, teorainneacha comhthreomhaireachta) nach mór d’fheidhmchlár a láimhseáil i gceart.

Saolré an tseisiúin

Téann seisiún WebSocket TTS tríd an timthriall seo:

  1. Oscailt: nasc le wss://api.x.ai/v1/tts leis na paraiméadair
  2. Gníomhach: malartú teachtaireachtaí text.delta/audio.delta
  3. Dúnadh gnáth: dúnann an cliant nó an freastalaí an nasc
  4. Dúnadh gan choinne: earráid, cothabháil, nó deireadh an cheada seisiúin 600 soicind a luaitear sa doiciméadú

Brath ar dhúnadh

Is féidir leis an bhfreastalaí an nasc a dhúnadh ag am ar bith (earráid inmheánach, cothabháil, deireadh an cheada seisiúin). Ba chóir d’fheidhmchlár an teagmhas dúntha a láimhseáil i gcónaí:

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

Athnascadh uathoibríoch

Chun feidhmchláir a ritheann ar feadh i bhfad, cuir athnascadh i bhfeidhm le cúlú easpónantúil:

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:
            # Athnasc agus déan iarracht arís
            await self.connect()
            return await self.synthesize(text)

Bainistíocht ar shaolré an tseisiúin

Luaann an leathanach Text to Speech ó xAI “cead seisiúin” 600 soicind gan a rá cathain a thosaíonn sé nó cad a tharlaíonn nuair a chríochnaíonn sé, agus deir sé ar leithligh nach bhfuil aon teorainn ama leis an nasc. Is é an cur chuige is cúthalaí ná comhaireamh ón nóiméad a nascann tú agus an seisiún a athnuachan roimh an bpointe sin:

import time

class TTLAwareSession:
    TTL = 600  # soicind
    REFRESH_MARGIN = 60  # athnasc 60 s roimh dhul in éag

    def __init__(self):
        self.connected_at = None

    async def connect(self):
        # ... nasc ...
        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()  # Seisiún nua
        # ... seol an téacs ...

Coinníonn an t-athnascadh 60 soicind roimh dhul in éag as an ngearradh ort i lár sintéise.

Linne seisiún

Chun feidhmchláir thráchta arda, coinnigh linne de sheisiúin in-athúsáidte:

class SessionPool:
    def __init__(self, api_key, pool_size=10):
        self.api_key = api_key
        self.pool_size = min(pool_size, 50)  # Uasmhéid 50 in aghaidh na foirne
        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

        # Fan go saorfar seisiún
        return await self.available.get()

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

Coinnigh méid na linne ina chodán den teorainn 50-seisiún chun spás a fhágáil do sheirbhísí eile d’fheidhmchláir.

Méadrachtaí le faire orthu

Chun seisiúin a choinneáil sláintiúil sa táirgeadh, déan monatóireacht ar:

  • Líon na seisiún gníomhach: ní mór nach sáraíonn sé 50
  • Ráta athnascadh: léiríonn ráta ard fadhb líonra nó saolré
  • Moill an chéad audio.delta: tomhaiseann sé cé chomh freagrach agus atá an tseirbhís
  • Earráidí WebSocket: cóid dúntha mínormálta (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)

Príomhphointí

  • Luaann an doiciméadú cead seisiúin 600 soicind: chun a bheith sábháilte, comhair ón nóiméad a nascann tú
  • Cuir athnascadh uathoibríoch i bhfeidhm le cúlú easpónantúil
  • Athnuadaigh an seisiún roimh an bpointe sin (le corrlach 60 soicind)
  • Úsáid linne seisiún d’fheidhmchláir thráchta arda
  • Fan faoin teorainn 50 seisiún comhthreomhar in aghaidh na foirne
  • Déan monatóireacht ar mhéadrachtaí nasctha sa táirgeadh