0%

Streamen · oefening

Open een stream en lees de bytes

De stream in les 2 was tekst op een pagina. Nu open je hem vanuit je eigen code en druk je de regels af zodra ze binnenkomen. Daarvoor is één functie nodig, open_stream, en één nieuw idee over wat die regels zijn.

Twee instellingen, allebei stream genoemd

Een gestreamd request heeft twee wijzigingen nodig ten opzichte van de requests die je in hoofdstuk 1 stuurde, en beide gebruiken het woord “stream”:

  • In de body vraagt "stream": True de dienst om het antwoord als server-sent events te sturen in plaats van als één JSON-document. Ernaast vraagt "stream_options": {"include_usage": True} om het usage-stukje aan het eind, zoals les 2 uitlegde.

  • In de aanroep is stream=True een argument van requests.post zelf, naast json= en timeout=. Het bepaalt wanneer post terugkeert. Zonder dit argument leest requests de hele response voordat het die aan jou geeft, dus zou je op het laatste deel wachten terwijl de dienst het eerste al lang geleden stuurde. Met stream=True keert post terug zodra de statusregel en de headers binnen zijn, en wordt de body later gelezen, deel voor deel, wanneer je code erom vraagt.

Je hebt ze allebei nodig. De instelling in de body zorgt dat de dienst delen stuurt; de instelling in de aanroep laat je programma ze lezen zodra ze komen.

Bouw open_stream

open_stream(body, *, headers=None, session=None) neemt een chatbody zoals die welke send_body verstuurt en maakt er een gestreamd request van:

  1. Kopieer body en voeg "stream": True en "stream_options": {"include_usage": True} toe aan de kopie. Kopieer eerst, zoals je in hoofdstuk 2 met geschiedenissen deed: de dictionary van de aanroeper mag niet veranderen. body.copy() geeft een nieuwe dictionary met dezelfde sleutels en waarden.

  2. POST de kopie naar f"{BASE_URL}/chat/completions" met json=, en geef headers=headers, stream=True en timeout=STREAM_TIMEOUT mee. Gebruik het sessiepatroon uit hoofdstuk 1: http = requests if session is None else session.

  3. Roep response.raise_for_status() aan, zodat een foutstatus hier misgaat en niet later.

  4. Geef de response zelf terug, zonder hem te lezen. De aanroeper leest de regels.

headers is None tenzij een aanroeper headers meegeeft, en requests behandelt headers=None hetzelfde als geen headers. Les 7 gebruikt het om een header te sturen waardoor het gescripte model een stream met opzet afbreekt.

De time-out voor een stream

TIMEOUT = (3.05, 10) uit hoofdstuk 1 staat tot 10 seconden wachten op data toe. streaming.py heeft een eigen constante, STREAM_TIMEOUT = (3.05, 30), en het tweede getal betekent iets preciezers dan “het hele antwoord”. Het is hoe lang requests hoogstens wacht, telkens als het op meer bytes wacht. Die grens werkt voor elke response hetzelfde. Een normale response stuurt niets tot hij klaar is, dus die ene wachtperiode duurt ongeveer zo lang als het hele antwoord. Een stream stuurt om de paar milliseconden iets, dus geen enkele wachtperiode komt ook maar in de buurt, en een antwoord dat blijft binnenkomen kan minuten duren zonder ooit een time-out te geven. De time-out gaat alleen af als de dienst 30 seconden aan één stuk stil blijft. Commentaarregels tellen ook als bytes, en dat is een van de redenen dat diensten ze sturen terwijl een model nadenkt. Een live redeneermodel kan nog steeds langer nadenken voordat zijn eerste deel komt, dus een lees-time-out bij een live aanroep is een normale uitkomst, zoals MODEL_SERVICE.md zegt.

Lees de regels

Als open_stream werkt, voer je python streaming.py uit. Na de twee antwoorden uit les 1 opent de demonstratie een stream voor Say hello in a short sentence. en loopt ze over de regels van de response:

response = open_stream(hello)
for line in response.iter_lines():
    print(line)

response.iter_lines() geeft de body regel voor regel, elke regel zodra die helemaal binnen is. Dat werkt alleen omdat het request stream=True gebruikte. Dit wordt er afgedrukt:

The lines of a stream, as iter_lines() gives them:
b': keep-alive'
b''
b'data: {"id": "chatcmpl-scripted-60cb3303cf3e4ae68892c51f", "object": "chat.completion.chunk", "created": 1794141681, "model": "pl-scripted", "choices": [{"index": 0, "delta": {"role": "assistant", "content": ""}, "finish_reason": null}]}'
b''
b'data: {"id": "chatcmpl-scripted-60cb3303cf3e4ae68892c51f", "object": "chat.completion.chunk", "created": 1794141681, "model": "pl-scripted", "choices": [{"index": 0, "delta": {"content": "Hello there, it "}, "finish_reason": null}]}'
b''
b'data: {"id": "chatcmpl-scripted-60cb3303cf3e4ae68892c51f", "object": "chat.completion.chunk", "created": 1794141681, "model": "pl-scripted", "choices": [{"index": 0, "delta": {"content": "is nice to "}, "finish_reason": null}]}'
b''
b'data: {"id": "chatcmpl-scripted-60cb3303cf3e4ae68892c51f", "object": "chat.completion.chunk", "created": 1794141681, "model": "pl-scripted", "choices": [{"index": 0, "delta": {"content": "meet you."}, "finish_reason": null}]}'
b''
b'data: {"id": "chatcmpl-scripted-60cb3303cf3e4ae68892c51f", "object": "chat.completion.chunk", "created": 1794141681, "model": "pl-scripted", "choices": [{"index": 0, "delta": {}, "finish_reason": "stop"}]}'
b''
b'data: {"id": "chatcmpl-scripted-60cb3303cf3e4ae68892c51f", "object": "chat.completion.chunk", "created": 1794141681, "model": "pl-scripted", "choices": [], "usage": {"prompt_tokens": 8, "completion_tokens": 9, "total_tokens": 17}}'
b''
b'data: [DONE]'
b''

Dit zijn de regels uit les 2, inclusief de lege regels, maar elke regel staat in b'...'.

Bytes, geen tekst

De b voor de aanhalingstekens betekent dat elke regel een bytes-waarde is, geen string. Een netwerkverbinding vervoert bytes: getallen van 0 tot en met 255. requests geeft ze aan je zoals ze binnenkwamen, omdat alleen jij weet hoe ze als tekst gelezen moeten worden. De meeste tekens die je hebt gebruikt nemen elk één byte in beslag, en daarom lijken de regels bijna op strings. Andere nemen er meer:

line = b'data: {"content": "caf\xc3\xa9"}'
print(line)
print(line.decode("utf-8"))
print(type(line))
print(type(line.decode("utf-8")))

De é in café is twee bytes, \xc3\xa9, in de codering UTF-8, die de dienst gebruikt. .decode("utf-8") zet de bytes om in een str, op dezelfde manier als je encoding="utf-8" opgaf toen je in Python in de praktijk tekstbestanden opende. Stringmethoden zoals .startswith werken op de gedecodeerde string, en die heeft de volgende les nodig.

Gebruik hiervoor geen str(line). Dat geeft je de tekst b'data: ...', met de b en de aanhalingstekens als deel van de string, in plaats van hem te decoderen.

De demonstratie opent de stream een tweede keer, omdat de regels van een stream maar één keer gelezen kunnen worden, en drukt elke regel gedecodeerd af:

response = open_stream(hello)
for line in response.iter_lines():
    print(line.decode("utf-8"))
The same lines, decoded:
: keep-alive

data: {"id": "chatcmpl-scripted-ed4cc227957d410a99ce7adb", "object": "chat.completion.chunk", "created": 1794141681, "model": "pl-scripted", "choices": [{"index": 0, "delta": {"role": "assistant", "content": ""}, "finish_reason": null}]}

data: {"id": "chatcmpl-scripted-ed4cc227957d410a99ce7adb", "object": "chat.completion.chunk", "created": 1794141681, "model": "pl-scripted", "choices": [{"index": 0, "delta": {"content": "Hello there, it "}, "finish_reason": null}]}

en zo verder tot data: [DONE], gevolgd door Run stopped at the next function to build: parse_line is built in Lesson 4. Jouw waarden voor id en created zullen anders zijn.

iter_lines kan ook voor je decoderen: response.iter_lines(decode_unicode=True) geeft strings. Deze cursus decodeert elke regel zelf, zodat je de stap ziet.

open_stream zet "stream": True in de body en geeft ook stream=True mee aan post. Wat doet stream=True in de aanroep?

response.iter_lines() geeft b'data: [DONE]'. Hoe krijg je de string data: [DONE]?

Een gestreamd antwoord blijft 90 seconden binnenkomen, elke 50 milliseconden een deel. Het request gebruikte STREAM_TIMEOUT = (3.05, 30). Wat gebeurt er?

Opdracht

Vervang in streaming.py de onafgemaakte body van open_stream(body, *, headers=None, session=None).

  • Kopieer body en voeg "stream": True en "stream_options": {"include_usage": True} toe aan de kopie. De dictionary van de aanroeper mag niet veranderen.

  • POST de kopie naar f"{BASE_URL}/chat/completions" met json=, headers=headers, stream=True en timeout=STREAM_TIMEOUT. Gebruik de sessie als die wordt meegegeven, en anders requests.

  • Roep raise_for_status() aan op de response en geef daarna de response zelf terug zonder de regels te lezen.

Voer python streaming.py uit om de regels van de stream eerst als bytes en daarna gedecodeerd te zien, en controleer daarna je werk.