Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Implementacija pretakanja v Pythonu

Lekcija 6 od 16 Posodobljeno 2. november 2026 Razvijalec
Na tej strani
  1. Od prototipa do proizvodnje
  2. Osnovni vzorec
  3. Celovita obravnava napak
  4. Asinhrono pretakanje z asyncio
  5. Integracija s FastAPI
  6. Merjenje zmogljivosti
  7. Ključne ugotovitve

Od prototipa do proizvodnje

Prejšnja lekcija je pokrila koncepte pretakanja SSE. Težji del šele sledi: pretvorba demonstracijske zanke v odjemalca, ki zdrži obremenitev, preživi napake v omrežju in napaja spletni vmesnik. Ta lekcija sledi realni poti projekta – najprej ogrodje, nato obravnava napak, asinhronost, izpostavitev HTTP in nazadnje merjenje.

Osnovni vzorec

Vse se začne s tem desetvrstičnim ogrodjem, ki ga boš prilagodil za vsak projekt. Hkrati počne dve stvari: prikazuje žetone, ko prispejo, in jih kopiči za vrnitev funkcije.

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:
    """Pošlje zahtevo za pretakanje in prikaže žetone v realnem času."""
    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()  # Nova vrstica
    return full_text

Ta različica deluje za lokalno skripto. V proizvodnem okolju ima usodno pomanjkljivost: izpisuje v terminal, zato lahko opravlja le delo v terminalu.

Celovita obravnava napak

Napake v omrežju, časovne omejitve in omejitve hitrosti niso hipotetične: pri realnem obsegu prometa so neizogibne. Spodnji odjemalec rešuje obe težavi. Samodejno ponovno poskusi napake 429 z eksponentnim zamikom in ne izpisuje ničesar: namesto tega oddaja tipizirane dogodke prek yield, kar klicatelju prepusti odločitev, kaj z njimi storiti – jih prikazati, poslati v WebSocket ali zapisati v bazo podatkov.

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:
    """Pretakanje s samodejnim ponovnim poskusom in metrikami."""
    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  # Eksponentni zamik
                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

Eksponentni zamik 2 ** attempt čaka 1 sekundo, nato 2, nato 4. To napredovanje ni okrasno: če bi vsi tvoji odjemalci ponovno poskušali v istem fiksnem ritmu, bi zadeli API v sinhroniziranih sunkih in podaljšali prav tisto zasičenost, ki jo trpijo. Upoštevaj tudi, da samo napaka 429 sproži ponovni poskus – ponovni poskus 401 zaradi neveljavnega ključa bi le odložil diagnozo.

Na strani klicatelja poraba postane preprosto branje dogodkov:

messages = [
    {"role": "system", "content": "You are a technical assistant."},
    {"role": "user", "content": "Explain design patterns in Python."}
]

for event in stream_with_retry(messages):
    if event["type"] == "token":
        print(event["content"], end="", flush=True)
    elif event["type"] == "retry":
        print(f"\n[Ponovni poskus {event['attempt']}, čakanje {event['wait']}s...]")
    elif event["type"] == "done":
        print(f"\n\n--- Končano ({event['chunks']} kosov, {event['finish_reason']})")
    elif event["type"] == "error":
        print(f"\n[Napaka: {event['message']}]")

Asinhrono pretakanje z asyncio

Sinhroni odjemalec blokira svojo nit za celoten čas generiranja. Na spletnem strežniku, ki mora obdelati petdeset simultanih pogovorov, to pomeni imobilizacijo petdesetih niti zgolj za čakanje. Asinhroni odjemalec to omejitev odpravi:

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:
    """Asinhrono pretakanje za sočasne aplikacije."""
    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

# Izvedba
async def main():
    messages = [{"role": "user", "content": "Hello, introduce yourself."}]
    result = await async_stream_chat(messages)
    print(f"\nSkupaj: {len(result)} znakov")

asyncio.run(main())

Logika je enaka sinhroni različici; spremenita se le stream_async, await pri klicu in async for v zanki.

Integracija s FastAPI

Nato moraš to pretakanje spraviti iz svojega procesa Python v brskalnik. FastAPI to obravnava z StreamingResponse, pod pogojem, da vsak fragment preoblikuješ v format SSE, kot smo ga videli v prejšnji lekciji:

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):
    """Generator SSE za 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"
    )

Dve podrobnosti določata, ali ta končna točka deluje pravilno. Dvojno novo vrstico \n\n, ki zaključuje vsak yield, ločuje dogodke v protokolu SSE: brez nje brskalnik neskončno čaka na dogodek, ki ga šteje za nedokončan. In media_type="text/event-stream" je tisto, kar omogoča odjemalcu JavaScript, da odzive porabi z EventSource namesto s standardnim fetch.

Merjenje zmogljivosti

Ko je pretakanje vzpostavljeno, boš želel vedeti, kako deluje. Dve metрики sta dovolj za usmerjanje optimizacije:

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": "Write a paragraph about Paris."}]
)

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"Čas do prvega žetona (TTFT): {first_token_time:.3f}s")
print(f"Generirani žetoni: {token_count}")
print(f"Skupni čas: {total_time:.3f}s")
print(f"Žetonov/sekundo: {token_count / total_time:.1f}")

TTFT (Time to First Token) – čas med pošiljanjem zahteve in prikazom prvega znaka – je najpomembnejša metrika za uporabniško izkušnjo. Ima prednost pred skupnim časom: generiranje, ki traja petnajst sekund, a se prvi beseda pojavi v treh desetinkah sekunde, bo delovalo hitro, medtem ko bo petsekundno generiranje, dostavljeno v enem bloku, delovalo počasi. Izmeri ga na svojih realnih pozivih, vključno s sistemskim sporočilom – dolžina sistemskega sporočila na dveh straneh podaljša TTFT, še preden je prvi žeton sploh generiran.

Ključne ugotovitve

  • Uporabi vzorec generatorja (yield) za posredovanje žetonov pretakanja
  • Implementiraj eksponentni zamik za napake 429 (omejitev hitrosti)
  • Za sočasne spletne aplikacije raje uporabi stream_async
  • Za optimizacijo zmogljivosti izmeri TTFT in žetone na sekundo
  • S FastAPI StreamingResponse + text/event-stream posreduje SSE v brskalnik