0%

Streaming · Übung

Wenn ein Stream mittendrin abbricht

Am Ende von Lektion 6 hat die Demonstration das geskriptete Modell gebeten, einen Stream vorzeitig abzubrechen, und dein stream_reply hat drei Textstücke ausgegeben, bevor requests einen Fehler ausgelöst hat. Genau das behebt diese Lektion. Ein Stream ist eine Verbindung, die für die ganze Antwort offen bleibt, und Verbindungen brechen ab: Ein Netzwerk fällt aus, ein Dienst startet neu, ein Proxy gibt auf. Dein Leser muss das bemerken, und er muss es klar sagen.

Die Gefahr ist eine Antwort, die fertig aussieht

Angenommen, ein Stream bricht nach A list is an ordered collection that can hold ab. Der Text steht schon auf dem Bildschirm. Wenn stream_reply ihn wie jede andere Antwort zurückgäbe, könnte der Aufrufer ihn nicht von einer vollständigen Antwort unterscheiden. Ein Chat würde ihn als das, was das Modell gesagt hat, im Verlauf speichern, und ein Programm, das auf die Antwort reagiert, würde auf die Hälfte davon reagieren. Hier ist der halbe Satz offensichtlich abgeschnitten, aber der Abbruch kann genauso gut nach einem vollständigen Satz kommen, und dann ist der fehlende Teil unsichtbar.

Deshalb gilt in dieser Lektion: stream_reply gibt nur eine vollständige Antwort zurück. Dieses Kapitel verwendet dafür eine strenge Regel: Eine Antwort gilt nur dann als vollständig, wenn "[DONE]" angekommen ist. Der Abschluss-Chunk zeigt, dass das Modell aufgehört hat zu schreiben, aber [DONE] ist das einzige Signal, dass der Dienst alles gesendet hat. Ein Leser, der darauf besteht, kann einen abgeschnittenen Stream nie für einen fertigen halten. Alles andere ist ein Fehler.

Zwei Arten, wie ein Stream zu früh endet

Die Verbindung bricht ab. Der Dienst hatte weitere Daten angekündigt, und die Verbindung wurde ohne sie geschlossen. requests bemerkt das, während du Zeilen liest, und löst requests.exceptions.ChunkedEncodingError innerhalb der for-Schleife über response.iter_lines() aus. Das hat die Demonstration in Lektion 6 gezeigt. ChunkedEncodingError gehört zur Familie requests.RequestException, die du in Python in der Praxis abgefangen hast. Der Name des Fehlers stammt aus HTTP, nicht von den JSON-Chunks des Streams. Eine gestreamte Antwort wird in Blöcken gesendet, die mit einem Abschlussblock enden, und requests löst diesen Fehler aus, wenn die Verbindung schließt, bevor dieser Abschlussblock ankommt. Das Wort „chunked“ bezieht sich hier auf Blöcke der HTTP-Antwort, nicht auf deine data:-Dokumente.

Die Zeilen gehen aus. Die Verbindung wird sauber geschlossen, aber [DONE] kam nie, also endet die Schleife einfach. requests sieht kein Problem, denn aus Sicht der Verbindung ist die Antwort vorbei. Nur dein Code weiß, dass das Stream-Format eine Endmarkierung versprochen hat.

Das geskriptete Modell kann den ersten Fall auf Wunsch erzeugen, mit dem Anfrage-Header X-Scripted-Scenario: broken-stream. Den zweiten kann es nicht erzeugen, deshalb zeigt die Demonstration ihn mit einem gespeicherten Stream, der unten beschrieben ist.

Der Fehler, den du auslöst: StreamBroken

errors.py stellt dafür eine Ausnahme bereit:

from errors import StreamBroken

Du erzeugst sie mit dem Text, der angekommen ist, raise StreamBroken(text), und der Code, der sie abfängt, liest diesen Text aus dem Attribut partial_text der Ausnahme zurück:

try:
    reply = stream_reply(response)
except StreamBroken as error:
    print(f"StreamBroken. The partial text was {error.partial_text!r}")

So hast du in Python in der Praxis Attribute vorhandener Ausnahmen gelesen. Du musst errors.py weder lesen noch ändern: Du löst nur seine Ausnahme aus und liest ihr Attribut. Den Teiltext mitzugeben lässt einen Aufrufer entscheiden, was er damit tut, zum Beispiel ihn als unvollständig markiert anzeigen oder ihn protokollieren, ohne dass ihn jemand für eine ganze Antwort hält.

Ändere stream_reply

Behalte alles aus Lektion 6 und füge zwei Dinge hinzu:

  1. Merke dir, ob "[DONE]" angekommen ist. Setze vor der Schleife finished = False und setze es direkt vor dem break bei "[DONE]" auf True. Wenn finished nach der Schleife noch False ist, sind die Zeilen zu früh ausgegangen: Gib einen Zeilenumbruch aus und löse StreamBroken("".join(pieces)) aus.

  2. Mach aus einer abgebrochenen Verbindung denselben Fehler. Setze die for-Schleife in einen try-Block und füge except requests.exceptions.ChunkedEncodingError: hinzu, das einen Zeilenumbruch ausgibt und StreamBroken("".join(pieces)) auslöst.

Ein vollständiger Stream gibt weiterhin seinen Zeilenumbruch aus und gibt die zusammengefügten Textstücke zurück, wie zuvor. Der Zeilenumbruch vor jedem raise beendet die halb ausgegebene Zeile, damit alles, was der Aufrufer danach ausgibt, in einer neuen Zeile beginnt.

Fange nur ChunkedEncodingError ab. Der try-Block umfasst auch json.loads und deine eigenen Funktionen, und ein Fehler dort, etwa ein Chunk, der kein gültiges JSON ist, oder ein Tippfehler in einem Schlüssel, ist keine abgebrochene Verbindung. Wenn except Exception: solche Fehler zu StreamBroken machen würde, würde ein Bug in deinem Code als Netzwerkproblem gemeldet, und der eigentliche Fehler wäre versteckt. Enge except-Klauseln, wie in Python in der Praxis, lassen alles andere unverändert zum Aufrufer durch.

Ein Stream, der mittendrin länger als der Lese-Timeout schweigt, löst einen anderen Fehler aus, requests.exceptions.ConnectionError, nicht ChunkedEncodingError. stream_reply fängt ihn nicht ab, also erreicht er den Aufrufer ohne den Teiltext. Wie man damit umgeht, kommt später, bei den erneuten Versuchen.

Ausführen

Führe python streaming.py aus. Der abgebrochene Stream kommt zuerst. Die Demonstration sendet Explain Python lists in detail. mit dem Szenario-Header:

response = open_stream(long_body, headers={"X-Scripted-Scenario": "broken-stream"})

Das geskriptete Modell sendet den Kommentar, den ersten Chunk und drei Textstücke und schließt dann die Verbindung. Diesmal macht stream_reply daraus StreamBroken, und die Demonstration fängt den Fehler ab und gibt den Teiltext mit !r aus, damit du das Leerzeichen an seinem Ende siehst:

A stream that breaks halfway:
A list is an ordered collection that can hold 
StreamBroken. The partial text was 'A list is an ordered collection that can hold '
A stream that ends without [DONE]:
Lists keep their order, 
StreamBroken. The partial text was 'Lists keep their order, '
The streaming study chat:
You: What does len() return?
Run stopped at the next function to build: chat_turn is built in Lesson 8.

Der zweite Fall ist der gespeicherte Stream. Die Demonstration baut eine Antwort aus zwei data:-Zeilen, die sie selbst geschrieben hat, ohne [DONE] danach:

saved = requests.Response()
saved.raw = io.BytesIO(
    b'data: {"choices": [{"index": 0, "delta": {"content": "Lists keep "}}]}\n\n'
    b'data: {"choices": [{"index": 0, "delta": {"content": "their order, "}}]}\n\n'
)

requests.Response() erzeugt ein leeres Antwortobjekt, und wenn man sein raw auf diese Bytes setzt, hat iter_lines() etwas zu lesen, genau so, als hätte ein Dienst sie gesendet und dann die Verbindung sauber geschlossen. Dein stream_reply liest beide Textstücke, dann gehen ihm die Zeilen aus, und es löst StreamBroken aus, weil finished noch False ist.

Ein Stream bricht nach der Hälfte der Antwort ab. Warum sollte stream_reply StreamBroken auslösen, statt die empfangene Hälfte zurückzugeben?

Ein Stream sendet seine Textstücke, den Abschluss-Chunk und den Usage-Chunk, und dann wird die Verbindung sauber geschlossen, ohne data: [DONE]. Was sollte dein stream_reply nach der Regel dieses Kapitels tun?

stream_reply fängt requests.exceptions.ChunkedEncodingError ab und sonst nichts. Ein Chunk in einem Stream ist kein gültiges JSON, also löst json.loads einen Fehler aus. Was passiert?

Aufgabe

Ändere in streaming.py die Funktion stream_reply(response) so, dass sie nie einen Teil einer Antwort zurückgibt, als wäre er vollständig.

  • Wenn beim Lesen der Zeilen requests.exceptions.ChunkedEncodingError ausgelöst wird, gib einen Zeilenumbruch aus und löse StreamBroken("".join(pieces)) aus.

  • Wenn die Zeilen ausgehen, bevor "[DONE]" angekommen ist, tu dasselbe.

  • Ein Stream, der "[DONE]" erreicht, gibt weiterhin die Textstücke aus, dann einen Zeilenumbruch, und gibt die ganze Antwort zurück.

  • Fange keine andere Ausnahme ab: Andere Fehler müssen den Aufrufer unverändert erreichen.

StreamBroken ist bereits aus errors.py importiert. Führe python streaming.py aus, um zu sehen, wie beide Arten abgebrochener Streams gemeldet werden, und prüfe dann deine Arbeit.