Cuir sruthú i bhfeidhm i bPython
Ar an leathanach seo
Ó phrótaitíopa go dtí táirgeadh
Chumhdaigh an cheacht roimhe seo coincheapa sruthaithe SSE. Is é an chuid is deacra atá fágtha ná: lúb taispeána a thiontú ina chliaint a sheasann faoi ualach, a mhaireann earráidí líonra, agus a chothaíonn comhéadan gréasáin. Leanann an cheacht seo conair fhíor thionscadail—cnámharlach ar dtús, ansin láimhseáil earráidí, ansin async, ansin nochtadh HTTP, agus ar deireadh tomhas.
An patrún bunúsach
Tosaíonn gach rud leis an gcnámharlach deich líne seo, a oiriúnóidh tú do gach tionscadal. Déanann sé dhá rud ag an am céanna: taispeánann sé tokenaí de réir mar a thagann siad agus carnann sé iad le haghaidh aisghabháil feidhme.
from mistralai.client import Mistral
import os
client = Mistral(api_key=os.getenv("MISTRAL_API_KEY"))
def stream_chat(messages: list, model: str = "mistral-large-latest") -> str:
"""Seolann sé iarratas sruthaithe agus taispeánann sé tokenaí i bhfíor-am."""
stream = client.chat.stream(
model=model,
messages=messages
)
full_text = ""
for chunk in stream:
content = chunk.data.choices[0].delta.content
if content:
full_text += content
print(content, end="", flush=True)
print() # Líne nua
return full_text
Oibríonn an leagan seo do script áitiúil. Tá locht marfach aige i dtáirgeadh: priontálann sé chuig an teirminéal, mar sin ní féidir leis ach obair teirminéil a dhéanamh.
Láimhseáil chuimsitheach earráidí
Ní hipitéisí iad earráidí líonra, teorainneacha ama, agus teorainneacha ráta: is cinnteachtaí iad ag scála tráchta fíor. Déileálann an cliant thíos leis an dá fhadhb. Déanann sé athriail uathoibríoch ar earráidí 429 le cúlú easpónantúil, agus ní phriontálann sé aon rud a thuilleadh: eisíonn sé imeachtaí típithe trí yield, ag fágáil don ghlaóir cinneadh a dhéanamh faoin méid atá le déanamh leo—iad a thaispeáint, iad a bhrú chuig WebSocket, nó iad a scríobh chuig bunachar sonraí.
from mistralai.client import Mistral
from mistralai.client.errors import SDKError
import os
import time
client = Mistral(api_key=os.getenv("MISTRAL_API_KEY"))
def stream_with_retry(
messages: list,
model: str = "mistral-large-latest",
max_retries: int = 3,
max_tokens: int = 2000
) -> dict:
"""Sruthú le hathriail uathoibríoch agus méadrachtaí."""
for attempt in range(max_retries):
try:
stream = client.chat.stream(
model=model,
messages=messages,
max_tokens=max_tokens
)
full_text = ""
finish_reason = None
chunk_count = 0
for chunk in stream:
delta = chunk.data.choices[0].delta
if delta.content:
full_text += delta.content
chunk_count += 1
yield {"type": "token", "content": delta.content}
if chunk.data.choices[0].finish_reason:
finish_reason = chunk.data.choices[0].finish_reason
yield {
"type": "done",
"full_text": full_text,
"finish_reason": finish_reason,
"chunks": chunk_count
}
return
except SDKError as e:
if e.status_code == 429 and attempt < max_retries - 1:
wait_time = 2 ** attempt # Cúlú easpónantúil
yield {"type": "retry", "wait": wait_time, "attempt": attempt + 1}
time.sleep(wait_time)
else:
yield {"type": "error", "message": str(e), "status": e.status_code}
return
except Exception as e:
yield {"type": "error", "message": str(e), "status": None}
return
Fanann an cúlú easpónantúil 2 ** attempt soicind amháin, ansin 2, ansin 4. Níl an dul chun cinn seo maisiúil: dá ndéanfadh do chliaint go léir athriail ag an rithim sheasta chéanna, bhuailfidís an API i mburstanna sioncronaithe agus chuirfidís síneadh leis an sáithiú céanna atá ag fulaingt acu. Tabhair faoi deara freisin nach dtosaíonn ach earráid 429 athriail—dá ndéanfá athriail ar 401 mar gheall ar eochair neamhbhailí, ní dhéanfá ach diagnóisic a mhoilliú.
Ar thaobh an ghlaoire, éiríonn an tomhaltas ina léamh simplí imeachtaí:
messages = [
{"role": "system", "content": "Is cúntóir teicniúil tú."},
{"role": "user", "content": "Mínigh patrúin dearaidh i bPython."}
]
for event in stream_with_retry(messages):
if event["type"] == "token":
print(event["content"], end="", flush=True)
elif event["type"] == "retry":
print(f"\n[Athriail {event['attempt']}, ag fanacht {event['wait']}s...]")
elif event["type"] == "done":
print(f"\n\n--- Críochnaithe ({event['chunks']} píosaí, {event['finish_reason']})")
elif event["type"] == "error":
print(f"\n[Earráid: {event['message']}]")
Sruthú async le asyncio
Bacann an cliant sioncronach a snáithe ar fad le haghaidh na giniúna ar fad. Ar fhreastalaí gréasáin a chaithfidh caoga comhrá comhuaineach a láimhseáil, ciallaíonn sé seo caoga snáithe a chur ar ceal díreach le fanacht. Tógann an cliant async an srian seo:
from mistralai.client import Mistral
import asyncio
import os
client = Mistral(api_key=os.getenv("MISTRAL_API_KEY"))
async def async_stream_chat(messages: list) -> str:
"""Sruthú async d'fheidhmchláir chomhuaineacha."""
stream = await client.chat.stream_async(
model="mistral-large-latest",
messages=messages
)
full_text = ""
async for chunk in stream:
content = chunk.data.choices[0].delta.content
if content:
full_text += content
print(content, end="", flush=True)
print()
return full_text
# Feidhmiú
async def main():
messages = [{"role": "user", "content": "Dia dhuit, déan cur síos ort féin."}]
result = await async_stream_chat(messages)
print(f"\nIomlán: {len(result)} carachtar")
asyncio.run(main())
Tá an loighic mar an gcéanna leis an leagan sioncronach; ní athraíonn ach stream_async, an await ar an nglaó, agus an async for ar an lúb.
Comhtháthú le FastAPI
Ina dhiaidh sin, caithfidh tú an sruth seo a fháil amach as do phróiseas Python agus isteach sa bhrabhsálaí. Déileálann FastAPI leis seo le StreamingResponse, ar choinníoll go ndéanann tú gach blúire a athfhoirmiú chuig formáid SSE a chonaic tú sa cheacht roimhe seo:
from fastapi import FastAPI
from fastapi.responses import StreamingResponse
from mistralai.client import Mistral
import os
import json
app = FastAPI()
client = Mistral(api_key=os.getenv("MISTRAL_API_KEY"))
async def generate_stream(prompt: str):
"""Gineadóir SSE do FastAPI."""
stream = await client.chat.stream_async(
model="mistral-large-latest",
messages=[{"role": "user", "content": prompt}]
)
async for chunk in stream:
content = chunk.data.choices[0].delta.content
if content:
data = json.dumps({"content": content})
yield f"data: {data}\n\n"
yield "data: [DONE]\n\n"
@app.get("/chat/stream")
async def chat_stream(prompt: str):
return StreamingResponse(
generate_stream(prompt),
media_type="text/event-stream"
)
Is é an dá shonraí a chinneann an oibríonn an críochphointe seo i gceart. Is é an líne dhúbailte \n\n a chríochnaíonn gach yield a scarann imeachtaí sa phrótacal SSE: gan é, fanfaidh an brabhsálaí go deo ar imeacht a mheasann sé atá neamhchríochnaithe. Agus is é media_type="text/event-stream" a ligeann don chliaint JavaScript an freagra a thomhailt le EventSource seachas fetch caighdeánach.
Feidhmíocht a thomhas
Nuair a bheidh an sruth ina áit, beidh tú ag iarraidh a fháil amach conas a fheidhmíonn sé. Tá dhá mhéadrach leordhóthanach chun feabhsú a stiúradh:
import time
start = time.perf_counter()
first_token_time = None
token_count = 0
stream = client.chat.stream(
model="mistral-large-latest",
messages=[{"role": "user", "content": "Scríobh alt faoi Pháras."}]
)
for chunk in stream:
if chunk.data.choices[0].delta.content:
if first_token_time is None:
first_token_time = time.perf_counter() - start
token_count += 1
total_time = time.perf_counter() - start
print(f"Am go dtí an Chéad Token (TTFT): {first_token_time:.3f}s")
print(f"Tokenaí ginte: {token_count}")
print(f"Am iomlán: {total_time:.3f}s")
print(f"Tokenaí/inneadh: {token_count / total_time:.1f}")
Is é TTFT (Time to First Token)—an t-am idir an t-iarratas a sheoladh agus an chéad charachtar a thaispeáint—an mhéadrach is tábhachtaí don taithí úsáideora. Tá sé níos tábhachtaí ná an t-am iomlán: beidh giniúint cúig shoicind déag a bhfuil a chéad fhocal le feiceáil i dtrí dhéagú soicind tapa, ach beidh giniúint cúig shoicind a sheachadtar i mbloc amháin mall. Tomhais é ar do leideanna fíora, an teachtaireacht chórais san áireamh—cuireann teachtaireacht chórais dhá leathanach fad le TTFT sula ngintear an chéad token fiú.
Príomhphointí
- Úsáid patrún gineadóra (
yield) chun tokenaí sruthaithe a scaipeadh - Cuir cúlú easpónantúil i bhfeidhm d’earráidí 429 (teorainn ráta)
- Roghnaigh
stream_asyncd’fheidhmchláir ghréasáin chomhuaineacha - Tomhais TTFT agus tokenaí in aghaidh an tsoicind chun feidhmíocht a fheabhsú
- Le FastAPI, scaipeann
StreamingResponse+text/event-streamSSE chuig an mbrabhsálaí