0%

Streaming · Übung

Einen Stream öffnen und seine Bytes lesen

Der Stream in Lektion 2 war Text auf einer Seite. Jetzt öffnest du ihn aus deinem eigenen Code und gibst seine Zeilen aus, während sie ankommen. Dafür braucht es eine Funktion, open_stream, und eine neue Idee darüber, was diese Zeilen sind.

Zwei Einstellungen, beide heißen stream

Eine gestreamte Anfrage braucht gegenüber den Anfragen aus Kapitel 1 zwei Änderungen, und beide verwenden das Wort „stream“:

  • Im Body: "stream": True bittet den Dienst, die Antwort als Server-Sent Events statt als ein JSON-Dokument zu senden. Daneben fordert "stream_options": {"include_usage": True} den Usage-Chunk am Ende an, wie in Lektion 2 erklärt.

  • Im Aufruf: stream=True ist ein Argument von requests.post selbst, neben json= und timeout=. Es ändert, wann post zurückkehrt. Ohne es liest requests die gesamte Antwort, bevor es sie dir gibt, du würdest also auf das letzte Textstück warten, obwohl der Dienst das erste schon lange vorher gesendet hat. Mit stream=True kehrt post zurück, sobald die Statuszeile und die Header da sind, und der Body wird später Stück für Stück gelesen, wenn dein Code danach fragt.

Du brauchst beide. Die Einstellung im Body sorgt dafür, dass der Dienst Textstücke sendet; die Einstellung im Aufruf lässt dein Programm sie lesen, sobald sie kommen.

Baue open_stream

open_stream(body, *, headers=None, session=None) nimmt einen Chat-Body wie die, die send_body sendet, und macht daraus eine gestreamte Anfrage:

  1. Kopiere body und füge der Kopie "stream": True und "stream_options": {"include_usage": True} hinzu. Kopiere zuerst, wie du es in Kapitel 2 mit Verläufen gemacht hast: Das Dictionary des Aufrufers darf sich nicht ändern. body.copy() liefert ein neues Dictionary mit denselben Schlüsseln und Werten.

  2. Schicke die Kopie per POST an f"{BASE_URL}/chat/completions" mit json= und übergib headers=headers, stream=True und timeout=STREAM_TIMEOUT. Verwende das Session-Muster aus Kapitel 1: http = requests if session is None else session.

  3. Rufe response.raise_for_status() auf, damit ein Fehlerstatus hier scheitert und nicht erst später.

  4. Gib die Antwort selbst zurück, ohne sie zu lesen. Der Aufrufer liest die Zeilen.

headers ist None, solange ein Aufrufer keine übergibt, und requests behandelt headers=None genauso wie gar keine Header. Lektion 7 nutzt das, um einen Header zu senden, der das geskriptete Modell absichtlich einen Stream abbrechen lässt.

Der Timeout für einen Stream

TIMEOUT = (3.05, 10) aus Kapitel 1 erlaubt bis zu 10 Sekunden Warten auf Daten. streaming.py hat eine eigene Konstante, STREAM_TIMEOUT = (3.05, 30), und die zweite Zahl bedeutet etwas Genaueres als „die ganze Antwort“. Sie ist die längste Zeit, die requests jedes Mal wartet, wenn es auf weitere Bytes wartet. Diese Grenze funktioniert bei jeder Antwort gleich. Eine normale Antwort sendet nichts, bis sie fertig ist, also dauert dieses eine Warten ungefähr so lange wie die ganze Antwort. Ein Stream sendet alle paar Millisekunden etwas, also kommt kein einzelnes Warten auch nur in die Nähe, und eine Antwort, die weiter ankommt, kann Minuten dauern, ohne je einen Timeout auszulösen. Der Timeout greift nur, wenn der Dienst 30 Sekunden am Stück schweigt. Auch Kommentarzeilen zählen als Bytes, und das ist ein Grund, warum Dienste sie senden, während ein Modell nachdenkt. Ein Live-Reasoning-Modell kann trotzdem länger nachdenken, bevor sein erstes Textstück kommt, daher ist ein Lese-Timeout bei einem Live-Aufruf ein normales Ergebnis, wie MODEL_SERVICE.md sagt.

Lies die Zeilen

Sobald open_stream funktioniert, führe python streaming.py aus. Nach den beiden Antworten aus Lektion 1 öffnet die Demonstration einen Stream für Say hello in a short sentence. und durchläuft die Zeilen der Antwort in einer Schleife:

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

response.iter_lines() liefert den Body Zeile für Zeile, jede, sobald sie vollständig angekommen ist. Das funktioniert nur, weil die Anfrage stream=True verwendet hat. Das gibt sie aus:

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''

Das sind die Zeilen aus Lektion 2, Leerzeilen eingeschlossen, aber jede ist in b'...' eingepackt.

Bytes, kein Text

Das b vor den Anführungszeichen bedeutet, dass jede Zeile ein bytes-Wert ist, kein String. Eine Netzwerkverbindung transportiert Bytes: Zahlen von 0 bis 255. requests gibt sie dir so, wie sie ankamen, weil nur du weißt, wie sie als Text gelesen werden sollen. Die meisten Zeichen, die du bisher verwendet hast, belegen je ein Byte, deshalb sehen die Zeilen fast wie Strings aus. Andere belegen mehr:

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

Das é in café besteht aus zwei Bytes, \xc3\xa9, in der Kodierung UTF-8, die der Dienst verwendet. .decode("utf-8") macht aus den Bytes einen str, so wie du in Python in der Praxis beim Öffnen von Textdateien encoding="utf-8" angegeben hast. String-Methoden wie .startswith funktionieren auf dem dekodierten String, und genau das braucht die nächste Lektion.

Verwende dafür nicht str(line). Das liefert dir den Text b'data: ...', mit dem b und den Anführungszeichen als Teil des Strings, statt ihn zu dekodieren.

Die Demonstration öffnet den Stream ein zweites Mal, weil die Zeilen eines Streams nur einmal gelesen werden können, und gibt jede Zeile dekodiert aus:

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}]}

und so weiter bis data: [DONE], gefolgt von Run stopped at the next function to build: parse_line is built in Lesson 4. Deine Werte für id und created werden andere sein.

iter_lines kann auch für dich dekodieren: response.iter_lines(decode_unicode=True) liefert Strings. Dieser Kurs dekodiert jede Zeile selbst, damit du den Schritt siehst.

open_stream setzt "stream": True in den Body und übergibt außerdem stream=True an post. Was bewirkt stream=True im Aufruf?

response.iter_lines() liefert b'data: [DONE]'. Wie bekommst du den String data: [DONE]?

Eine gestreamte Antwort kommt 90 Sekunden lang an, alle 50 Millisekunden ein Textstück. Die Anfrage verwendete STREAM_TIMEOUT = (3.05, 30). Was passiert?

Aufgabe

Ersetze in streaming.py den unfertigen Rumpf von open_stream(body, *, headers=None, session=None).

  • Kopiere body und füge der Kopie "stream": True und "stream_options": {"include_usage": True} hinzu. Das Dictionary des Aufrufers darf sich nicht ändern.

  • Schicke die Kopie per POST an f"{BASE_URL}/chat/completions" mit json=, headers=headers, stream=True und timeout=STREAM_TIMEOUT. Verwende die Session, wenn eine übergeben wird, und sonst requests.

  • Rufe raise_for_status() auf der Antwort auf und gib dann die Antwort selbst zurück, ohne ihre Zeilen zu lesen.

Führe python streaming.py aus, um die Zeilen des Streams erst als Bytes und dann dekodiert zu sehen, und prüfe dann deine Arbeit.