0%

Streaming · Übung

Beim Eintreffen ausgeben, die ganze Antwort behalten

Du hast jeden Schritt für eine Zeile: sie dekodieren, mit parse_line sortieren und ihren Text mit chunk_text holen. In dieser Lektion kommen diese Schritte in eine Schleife, die die Antwort beim Eintreffen anzeigt und außerdem die ganze Antwort als einen String zurückgibt, weil ein Programm meist beides braucht. Die Person liest die Textstücke, sobald sie kommen, und das Programm behält die ganze Antwort, zum Beispiel um sie einem Verlauf hinzuzufügen.

Textstücke in einer Zeile ausgeben

print beendet seine Ausgabe mit einem Zeilenumbruch. Für Textstücke eines Satzes ist das falsch: Jedes Textstück würde in einer eigenen Zeile landen. Das Argument end ersetzt den Zeilenumbruch durch das, was du angibst, und end="" bedeutet gar nichts:

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

Die Textstücke fügen sich zu einer Zeile zusammen, weil jedes schon mit dem Leerzeichen endet, das es braucht. Das print() nach der Schleife gibt nur den Zeilenumbruch aus, der die Antwort beendet, damit alles, was danach ausgegeben wird, in einer neuen Zeile beginnt.

Über das Ausgeben ohne Zeilenumbruch musst du noch etwas wissen. Python schreibt Text nicht immer in dem Moment auf den Bildschirm, in dem du ihn ausgibst. Bei der Ausgabe in ein sammelt es Text in einem Puffer und schreibt den Puffer, wenn eine Zeile vollständig ist. Ein Textstück ohne Zeilenumbruch kann in diesem Puffer liegen bleiben, bis später ein Zeilenumbruch kommt, und das heißt bei einer gestreamten Antwort: am Ende. Bis dahin sieht der Leser nichts. flush=True weist print an, den Puffer sofort zu schreiben:

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

Damit erscheint jedes Textstück, sobald es ausgegeben wird. Verwende beide Argumente für jedes Textstück.

Um den Unterschied zu sehen, sobald du unten stream_reply gebaut hast, entferne flush=True und führe python streaming.py erneut aus. Die lange Antwort sollte dann am Ende auf einmal erscheinen statt Stück für Stück. Setze das Argument danach wieder ein. Die Prüfung deiner Arbeit achtet nicht auf flush=True, ein Leser im Terminal aber schon.

Behalte auch die Textstücke

Die Ausgabe zeigt die Antwort, aber danach ist der Text aus deinem Programm verschwunden. Behalte deshalb jedes Textstück zusätzlich in einer Liste und füge die Liste am Ende zusammen. str.join kennst du aus den Python-Grundlagen: "".join(pieces) fügt die Textstücke ohne etwas dazwischen zusammen, und das ist hier richtig, weil die Leerzeichen schon in den Textstücken stecken.

Baue stream_reply

stream_reply(response) nimmt eine offene Antwort von open_stream und tut Folgendes:

  1. Lege eine leere Liste für die Textstücke an.

  2. Für jede Zeile aus response.iter_lines(): Dekodiere sie mit .decode("utf-8") und gib sie an parse_line.

    • Wenn das Ergebnis None ist, geh zur nächsten Zeile.

    • Wenn es "[DONE]" ist, beende die Schleife mit break. Alles nach der Endmarkierung wird ignoriert.

    • Sonst dekodiere das JSON mit json.loads und hol das Textstück mit chunk_text. Wenn das Textstück nicht leer ist, gib es mit print(piece, end="", flush=True) aus und füge es der Liste hinzu.

  3. Gib nach der Schleife einen Zeilenumbruch aus und gib dann "".join(pieces) zurück.

Prüfe auf "[DONE]", bevor du json.loads aufrufst. [DONE] ist kein JSON, und json.loads("[DONE]") löst einen Fehler aus.

Beachte, was die Schleife nicht tut: Sie hält nicht bei dem Chunk mit einem finish_reason an. Danach kommt noch der Usage-Chunk, und ein Leser, der zu früh anhält, würde die Token-Zahlen verpassen, auf die Kapitel 9 angewiesen ist. Manche Live-Modelle packen außerdem das letzte Textstück in denselben Chunk wie den finish_reason. Bis "[DONE]" weiterzulesen deckt beides ab.

Ausführen

Führe python streaming.py aus. Nach den früheren Abschnitten öffnet die Demonstration einen Stream für Explain Python lists in detail. und übergibt ihn deiner Funktion:

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

Die Antwort erscheint Stück für Stück, wie in der Vorschau aus Lektion 1, und diesmal gibt dein eigener Code sie aus:

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.

Der zurückgegebene String enthält alle 709 Zeichen der Antwort: Was ausgegeben und was zurückgegeben wurde, ist derselbe Text.

Die letzten vier Zeilen sind das Problem der nächsten Lektion. Die Demonstration hat das geskriptete Modell gebeten, die Verbindung nach drei Textstücken zu kappen. Deine Funktion hat diese Textstücke ausgegeben, und dann hat requests mitten in der Schleife einen Fehler ausgelöst. Lektion 7 entscheidet, was stream_reply damit tun soll.

Was gibt das aus?

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

Dein Stream-Leser gibt mit print(piece, end="") und ohne flush=True aus. Im Terminal erscheint die Antwort am Ende auf einmal statt Stück für Stück. Warum?

Warum muss stream_reply auf "[DONE]" prüfen, bevor es json.loads aufruft?

Aufgabe

Ersetze in streaming.py den unfertigen Rumpf von stream_reply(response).

  • Lies die Zeilen mit response.iter_lines(), dekodiere jede mit .decode("utf-8") und gib sie an parse_line.

  • Überspringe eine Zeile, wenn parse_line None zurückgibt. Hör bei "[DONE]" auf zu lesen und ignoriere alles danach.

  • Hol für jede andere Zeile das Textstück mit chunk_text(json.loads(text)). Wenn das Textstück nicht leer ist, gib es mit print(piece, end="", flush=True) aus und behalte es.

  • Gib nach der Schleife einen Zeilenumbruch aus und gib alle Textstücke zu einem String zusammengefügt zurück.

Führe python streaming.py aus, um zu sehen, wie deine Funktion eine lange Antwort streamt, und prüfe dann deine Arbeit.