0%

Den OpenAI-Client verwenden · Übung

Über den Client streamen

In Kapitel 3 brauchte das Streamen einer Antwort fünf Funktionen: den Stream öffnen, die data:-Zeilen herausfiltern, jeden Chunk dekodieren, den Text herausnehmen und ihn ausgeben, während die ganze Antwort aufbewahrt wird. Der Client erledigt die ersten vier. Die Regel, auf die es am meisten ankommt, nämlich nie einen Teil einer Antwort als die ganze Antwort auszugeben, bleibt deine Aufgabe, und diese Lektion hält sie in zwei Schritten ein.

Schritt 1: der Normalfall

Füge stream=True zu create hinzu, und der Aufruf gibt einen Stream statt einer Antwort zurück. Füge außerdem stream_options={"include_usage": True} hinzu, wie in Kapitel 3, damit der Stream auch die Token-Zahlen meldet:

stream = client.chat.completions.create(
    model=MODEL,
    messages=messages,
    stream=True,
    stream_options={"include_usage": True},
)
for chunk in stream:
    ...

Die Schleife bekommt pro data:-Zeile ein Chunk-Objekt. Der Client hat die Zeilen schon gelesen, den Kommentar : keep-alive übersprungen, das JSON dekodiert und bei [DONE] aufgehört, also taucht nichts davon in deinem Code auf. Für Say hello in a short sentence. enthalten die Chunks dieselben Werte, die Kapitel 3 von Hand dekodiert hat, jetzt als Attribute:

Chunkchunk.choicesdelta.contentfinish_reason
erstereine Choice""None
einer pro Textstückeine Choice"Hello there, it ", dann "is nice to ", dann "meet you."None
Abschlusseine ChoiceNone"stop"
Usage[]keine Choice zu lesenkeine Choice zu lesen

chunk.choices[0].delta.content ist das Textstück. Es ist "" im ersten Chunk und None im Abschluss-Chunk, und ein Live-Modell kann zwischendurch None senden. Gib ein Textstück also nur aus und bewahre es nur auf, wenn es ein nicht leerer String ist; if content: prüft genau das. Der letzte Chunk trägt die Token-Zahlen in chunk.usage und hat eine leere choices-Liste. Überspringe also einen Chunk, dessen choices leer ist, bevor du choices[0] liest. Kapitel 9 liest diesen Usage-Chunk, um ein Budget einzuhalten.

Baue die erste Version von stream_chat(messages, *, client):

  1. Rufe create mit model=MODEL, messages=messages, stream=True und stream_options={"include_usage": True} auf, und mit nichts sonst.

  2. Laufe in einer Schleife über den Stream. Überspringe einen Chunk, wenn chunk.choices leer ist.

  3. Lies content = chunk.choices[0].delta.content. Wenn es ein nicht leerer String ist, gib es mit end="" und flush=True aus und hänge es an eine Liste an.

  4. Gib nach der Schleife einen Zeilenumbruch aus und gib die mit "".join(pieces) verbundenen Textstücke zurück.

Das ist stream_reply aus Kapitel 3 ohne die Zeilenverarbeitung. Führe python client_calls.py aus. Die lange Antwort strömt wie zuvor herein, und dann sendet die Demonstration dieselbe Anfrage über einen Client, der das geskriptete Modell bittet, den Stream abzubrechen:

A streamed 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_chat returned 709 characters.
A stream that breaks halfway:
A list is an ordered collection that can hold 
openai raised APIConnectionError: Connection error.
Its cause, by name: RemoteProtocolError
Run stopped: stream_chat does not turn a broken stream into StreamBroken yet.

Schritt 2: der Abbruch

Der abgebrochene Stream hat drei Textstücke ausgegeben, und dann hat die Schleife openai.APIConnectionError ausgelöst. Das ist der Fehler des Clients für eine fehlgeschlagene Verbindung, und hier bedeutet er, dass der Stream abgerissen ist. Er spielt die Rolle, die requests.exceptions.ChunkedEncodingError in Kapitel 3 gespielt hat, und der Teiltext ist genau derselbe.

Die Demonstration hat auch die Ursache des Fehlers mit Namen ausgegeben, RemoteProtocolError. Dieser Fehler gehört zu der Bibliothek, die der Client darunter zum Senden von Anfragen verwendet, und der Client verpackt ihn für dich in seinen eigenen Fehler. Lies den Namen aus Interesse, aber fange ihn nie ab: Die Bibliothek darunter ist Sache des Clients und kann sich zwischen Versionen ändern, während openai.APIConnectionError der Teil ist, den der Client zusagt.

Ändere stream_chat so, dass es die Regel aus Kapitel 3 einhält:

  1. Eine abgerissene Verbindung. Setze die for-Schleife in einen try-Block, mit except openai.APIConnectionError:, das einen Zeilenumbruch ausgibt und StreamBroken("".join(pieces)) auslöst.

  2. Ein Stream, der nie fertig wurde. Setze vor der Schleife finished = False. Wenn bei einem Chunk mit einer Choice chunk.choices[0].finish_reason nicht None ist, setze finished = True. Gib nach der Schleife wie zuvor den Zeilenumbruch aus, und wenn finished immer noch False ist, löse StreamBroken("".join(pieces)) aus.

Die zweite Regel ist das „endete ohne [DONE]“ aus Kapitel 3, in den Begriffen des Clients. Der Client hört bei [DONE] auf, ohne es dir zu zeigen, also ist der Abschluss-Chunk das letzte Signal, an dem du sehen kannst, dass das Modell fertig ist. Jeder finish_reason zählt, auch "length": Der Stream ist fertig geworden, und dass dem Modell die Tokens ausgegangen sind, ist ein anderes Problem, um das sich Kapitel 9 kümmert. Das geskriptete Modell kann keinen Stream senden, der sauber ohne Abschluss-Chunk endet, also zeigt die Demonstration diesen Fall nie; das tun nur die Prüfungen.

Fange nur openai.APIConnectionError ab. Ein Tippfehler in deinem eigenen Code innerhalb der Schleife ist keine abgerissene Verbindung und muss dich als das erreichen, was er ist.

Ein Stream, der länger als der Timeout des Clients schweigt, löst openai.APITimeoutError aus. Das ist eine Art von APIConnectionError, also meldet stream_chat ihn als StreamBroken mit dem bisherigen Text. In Kapitel 3 ist dieser Fall ohne den Teiltext entwischt; der Client macht daraus einen einzigen Fall.

Lass den create-Aufruf selbst außerhalb des try-Blocks. Wenn create einen Fehler auslöst, zum Beispiel openai.InternalServerError, weil der Dienst 500 zurückgegeben hat, wurde noch nichts ausgegeben, also gibt es keine Teilantwort zu schützen. Dieser Fehler erreicht den Aufrufer unverändert, und Kapitel 9 versucht genau solche Fehlschläge erneut.

Wer den Szenario-Header sendet

In Kapitel 3 hast du den Header X-Scripted-Scenario: broken-stream selbst an open_stream übergeben. Hier verwendet die Demonstration das mitgelieferte scenario_client("broken-stream"):

def scenario_client(scenario):
    return make_client().with_options(default_headers={"X-Scripted-Scenario": scenario})

with_options gibt eine Kopie des Clients mit einigen geänderten Einstellungen zurück. default_headers sind Header, die die Kopie bei jedem ihrer Aufrufe sendet. So bittet jede Anfrage über diesen Client das geskriptete Modell um das Szenario, und stream_chat braucht keinen Header-Parameter. Lektion 5 zeigt den anderen Weg: extra_headers= bei einem Aufruf fügt nur diesem Aufruf einen Header hinzu.

Führe python client_calls.py noch einmal aus. Jetzt wird der abgebrochene Stream so gemeldet, wie Kapitel 3 ihn gemeldet hat:

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 quiz through the parse helper:
Run stopped at the next function to build: quiz_messages is built in Lesson 4.

Deine Schleife liest bei jedem Chunk chunk.choices[0].delta.content und prüft nie chunk.choices. Streams, die normal enden, schlagen ganz am Ende mit IndexError fehl. Warum?

Der create-Aufruf in stream_chat löst openai.InternalServerError aus, bevor ein Chunk ankommt. Was sollte stream_chat tun?

Ein abgebrochener Stream hat openai.APIConnectionError ausgelöst, dessen Ursache als RemoteProtocolError ausgegeben wird. Welchen Fehler sollte stream_chat abfangen?

Aufgabe

Ersetze in client_calls.py den unfertigen Rumpf von stream_chat(messages, *, client).

  • Rufe client.chat.completions.create(model=MODEL, messages=messages, stream=True, stream_options={"include_usage": True}) außerhalb jedes try-Blocks auf.

  • Laufe über die Chunks. Überspringe einen Chunk, dessen choices leer ist. Gib jedes nicht leere chunk.choices[0].delta.content mit end="" und flush=True aus und bewahre es auf.

  • Merke dir, ob der finish_reason irgendeines Chunks nicht None war.

  • Wenn während der Schleife openai.APIConnectionError ausgelöst wird, gib einen Zeilenumbruch aus und löse StreamBroken("".join(pieces)) aus.

  • Gib nach der Schleife einen Zeilenumbruch aus. Wenn kein Chunk einen finish_reason trug, löse StreamBroken("".join(pieces)) aus; andernfalls gib den verbundenen Text zurück.

Fange keine andere Ausnahme ab. Führe nach jedem Schritt python client_calls.py aus, um den Stream und den abgebrochenen Stream zu sehen, und prüfe dann deine Arbeit.