0%

Streamen · oefening

Druk af wat binnenkomt, bewaar het hele antwoord

Je hebt elke stap voor één regel: decoderen, sorteren met parse_line en de tekst eruit halen met chunk_text. Deze les zet ze in een lus die het antwoord toont terwijl het binnenkomt en ook het hele antwoord als één string teruggeeft, omdat een programma meestal allebei nodig heeft. De lezer leest de delen zodra ze komen, en het programma bewaart het hele antwoord, bijvoorbeeld om het aan een geschiedenis toe te voegen.

Delen op één regel afdrukken

print sluit wat het afdrukt af met een newline. Voor delen van één zin is dat fout: elk deel zou op een eigen regel belanden. Het argument end vervangt de newline door wat je meegeeft, en end="" betekent helemaal niets:

for piece in ["Lists keep ", "their order, ", "so the first item stays first."]:
    print(piece, end="")
print()

De delen komen op één regel samen omdat elk deel al eindigt op de spatie die het nodig heeft. De print() na de lus drukt alleen de newline af die het antwoord afsluit, zodat wat daarna wordt afgedrukt op een nieuwe regel begint.

Er is nog één ding dat je moet weten over afdrukken zonder newlines. Python schrijft tekst niet altijd naar het scherm op het moment dat je hem afdrukt. Bij afdrukken naar een verzamelt het tekst in een buffer en schrijft het die buffer weg zodra een regel compleet is. Een deel zonder newline kan in die buffer blijven staan tot er later een newline komt, en bij een gestreamd antwoord is dat pas aan het eind, dus tot dan ziet de lezer niets. flush=True vertelt print de buffer meteen weg te schrijven:

print(piece, end="", flush=True)

Daarmee verschijnt elk deel zodra het is afgedrukt. Gebruik beide argumenten voor elk deel.

Wil je het verschil zien zodra je hieronder stream_reply hebt gebouwd, haal dan flush=True weg en voer python streaming.py opnieuw uit. Het lange antwoord zou nu aan het eind in één keer moeten verschijnen in plaats van deel voor deel. Zet het argument daarna terug. De controle van je werk kijkt niet naar flush=True, maar een lezer in een terminal merkt het wel.

Bewaar de delen ook

Afdrukken toont het antwoord, maar daarna is de tekst uit je programma verdwenen. Bewaar elk deel ook in een lijst en voeg de lijst aan het eind samen. Je leerde str.join kennen in Python-basis: "".join(pieces) zet de delen aan elkaar met niets ertussen, en dat klopt hier omdat de spaties al in de delen zitten.

Bouw stream_reply

stream_reply(response) neemt een open response van open_stream en doet het volgende:

  1. Begin met een lege lijst voor de delen.

  2. Voor elke regel uit response.iter_lines(): decodeer hem met .decode("utf-8") en geef hem door aan parse_line.

    • Is het resultaat None, ga dan door naar de volgende regel.

    • Is het "[DONE]", stop de lus dan met break. Alles na de eindmarkering wordt genegeerd.

    • Decodeer anders de JSON met json.loads en haal het deel op met chunk_text. Is het deel niet leeg, druk het dan af met print(piece, end="", flush=True) en voeg het toe aan de lijst.

  3. Druk na de lus één newline af en geef dan "".join(pieces) terug.

Controleer op "[DONE]" voordat je json.loads aanroept. [DONE] is geen JSON, en json.loads("[DONE]") werpt een fout op.

Let op wat de lus niet doet: hij stopt niet bij het stukje met een finish_reason. Het usage-stukje komt daarna, en een lezer die te vroeg stopte zou de tokenaantallen missen waar hoofdstuk 9 op rekent. Sommige live modellen zetten ook het laatste tekstdeel in hetzelfde stukje als de finish_reason. Doorlezen tot "[DONE]" vangt beide op.

Voer het uit

Voer python streaming.py uit. Na de eerdere onderdelen opent de demonstratie een stream voor Explain Python lists in detail. en geeft die aan je functie:

reply = stream_reply(open_stream(long_body))
print(f"stream_reply returned {len(reply)} characters.")

Het antwoord verschijnt deel voor deel, zoals in de preview van les 1, en deze keer drukt je eigen code het af:

A long reply, streamed by stream_reply:
A list is an ordered collection that can hold any mix of values. You create one with square brackets, such as scores = [90, 72, 85]. Each item has a position, starting at 0, so scores[0] is 90 and scores[-1] is the last item. Slicing takes a range: scores[0:2] gives a new list with the first two items. Lists are mutable, which means you can change them after creating them: scores.append(60) adds an item to the end, scores.remove(72) removes the first matching value, and scores[1] = 75 replaces an item in place. Because a list is changed in place, two names that refer to the same list both see the change. Use list.copy() when you need an independent list. len(scores) tells you how many items it holds.
stream_reply returned 709 characters.
A stream that breaks halfway:
A list is an ordered collection that can hold 
requests raised ChunkedEncodingError: Response ended prematurely
Run stopped: stream_reply does not handle a broken stream yet. Lesson 7 changes that.

De teruggegeven string bevat alle 709 tekens van het antwoord: wat werd afgedrukt en wat werd teruggegeven is dezelfde tekst.

De laatste vier regels zijn het probleem van de volgende les. De demonstratie vroeg het gescripte model de verbinding na drie delen te verbreken. Je functie drukte die delen af, en daarna wierp requests midden in de lus een fout op. Les 7 bepaalt wat stream_reply daarmee moet doen.

Wat drukt dit af?

for piece in ["Sets ", "drop ", "duplicates."]:
    print(piece)

Je streamlezer drukt af met print(piece, end="") en zonder flush=True. In de terminal verschijnt het antwoord aan het eind in één keer in plaats van deel voor deel. Waarom?

Waarom moet stream_reply op "[DONE]" controleren voordat het json.loads aanroept?

Opdracht

Vervang in streaming.py de onafgemaakte body van stream_reply(response).

  • Lees de regels met response.iter_lines(), decodeer elke regel met .decode("utf-8") en geef hem door aan parse_line.

  • Sla een regel over als parse_line None teruggeeft. Stop met lezen bij "[DONE]" en negeer alles daarna.

  • Haal voor elke andere regel het deel op met chunk_text(json.loads(text)). Is het deel niet leeg, druk het dan af met print(piece, end="", flush=True) en bewaar het.

  • Druk na de lus één newline af en geef alle delen samengevoegd tot één string terug.

Voer python streaming.py uit om je functie een lang antwoord te zien streamen, en controleer daarna je werk.