0%

De OpenAI-client gebruiken · oefening

Stream via de client

In hoofdstuk 3 had je vijf functies nodig om een antwoord te streamen: de stream openen, de data:-regels eruit pikken, elk stukje decoderen, de tekst eruit halen, en die afdrukken terwijl je het hele antwoord bewaart. De client doet de eerste vier. De regel die er het meest toe doet, nooit een deel van een antwoord presenteren als het geheel, moet je nog steeds zelf bewaken, en deze les doet dat in twee stappen.

Stap 1: het normale pad

Voeg stream=True toe aan create, en de aanroep geeft een stream terug in plaats van een antwoord. Voeg ook stream_options={"include_usage": True} toe, zoals hoofdstuk 3 deed, zodat de stream ook de tokenaantallen meldt:

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

De lus krijgt één stukje (chunk) als object per data:-regel. De client heeft de regels al gelezen, het commentaar : keep-alive overgeslagen, de JSON gedecodeerd en is gestopt bij [DONE], dus niets daarvan zie je in je code. Voor Say hello in a short sentence. bevatten de stukjes dezelfde waarden die hoofdstuk 3 met de hand decodeerde, nu als attributen:

Stukjechunk.choicesdelta.contentfinish_reason
eersteéén keuze""None
één per deeléén keuze"Hello there, it ", dan "is nice to ", dan "meet you."None
afsluitendéén keuzeNone"stop"
usage[]geen keuze om te lezengeen keuze om te lezen

chunk.choices[0].delta.content is het tekstdeel. Het is "" in het eerste stukje en None in het slotstukje, en een live model kan daartussen None sturen, dus druk een tekstdeel alleen af en bewaar het alleen als het een niet-lege string is; if content: test precies dat. Het laatste stukje bevat de tokenaantallen in chunk.usage en heeft een lege lijst choices, dus sla een stukje waarvan choices leeg is over voordat je choices[0] leest. Hoofdstuk 9 leest dat usage-stukje om een budget bij te houden.

Bouw de eerste versie van stream_chat(messages, *, client):

  1. Roep create aan met model=MODEL, messages=messages, stream=True en stream_options={"include_usage": True}, en verder niets.

  2. Loop over de stream. Sla een stukje over als chunk.choices leeg is.

  3. Lees content = chunk.choices[0].delta.content. Als dat een niet-lege string is, druk het dan af met end="" en flush=True en voeg het toe aan een lijst.

  4. Druk na de lus één newline af en geef de delen terug, samengevoegd met "".join(pieces).

Dat is stream_reply uit hoofdstuk 3 zonder de regelverwerking. Voer python client_calls.py uit. Het lange antwoord streamt binnen zoals eerder, en daarna stuurt de demonstratie hetzelfde request via een client die het gescripte model vraagt de stream af te breken:

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.

Stap 2: de onderbreking

De onderbroken stream drukte drie tekstdelen af, en daarna wierp de lus openai.APIConnectionError op. Dat is de fout van de client voor een mislukte verbinding, en hier betekent die dat de stream werd afgebroken. Hij speelt de rol die requests.exceptions.ChunkedEncodingError in hoofdstuk 3 speelde, en de gedeeltelijke tekst is precies dezelfde.

De demonstratie drukte ook de oorzaak van de fout bij naam af, RemoteProtocolError. Die fout hoort bij de bibliotheek die de client onder de motorkap gebruikt om requests te versturen, en de client verpakt hem voor je in zijn eigen fout. Lees de naam uit interesse, maar vang hem nooit af: de bibliotheek eronder is de zaak van de client en kan tussen versies veranderen, terwijl openai.APIConnectionError het deel is dat de client belooft.

Verander stream_chat zodat de functie zich aan de regel uit hoofdstuk 3 houdt:

  1. Een afgebroken verbinding. Zet de for-lus in een try-blok, met except openai.APIConnectionError: dat één newline afdrukt en StreamBroken("".join(pieces)) opwerpt.

  2. Een stream die nooit afrondde. Zet finished = False vóór de lus. Zet voor elk stukje met een keuze finished = True als chunk.choices[0].finish_reason niet None is. Druk na de lus de newline af zoals eerder, en werp StreamBroken("".join(pieces)) op als finished nog steeds False is.

De tweede regel is “eindigde zonder [DONE]” uit hoofdstuk 3, in de termen van de client. De client stopt bij [DONE] zonder het je te laten zien, dus het slotstukje is het laatste signaal dat je kunt zien dat het model klaar was. Elke finish_reason telt, ook "length": de stream werd afgerond, en dat het model door zijn tokens heen was, is een ander probleem, dat hoofdstuk 9 aanpakt. Het gescripte model kan geen stream sturen die netjes eindigt zonder slotstukje, dus de demonstratie laat dit geval nooit zien; alleen de controles doen dat.

Vang alleen openai.APIConnectionError af. Een typfout in je eigen code binnen de lus is geen verbroken verbinding, en moet je bereiken als wat hij is.

Een stream die langer stil blijft dan de time-out van de client, geeft openai.APITimeoutError, een soort APIConnectionError, dus stream_chat meldt dat als StreamBroken met de tekst tot dan toe. In hoofdstuk 3 ontsnapte dat geval zonder de gedeeltelijke tekst; de client maakt er één geval van.

Houd de aanroep van create zelf buiten het try-blok. Als create een fout opwerpt, bijvoorbeeld openai.InternalServerError omdat de dienst 500 teruggaf, is er nog niets afgedrukt, dus is er geen gedeeltelijk antwoord om te beschermen. Die fout bereikt de aanroeper onveranderd, en hoofdstuk 9 probeert precies die mislukkingen opnieuw.

Wie de scenarioheader verstuurt

In hoofdstuk 3 gaf je de header X-Scripted-Scenario: broken-stream zelf mee aan open_stream. Hier gebruikt de demonstratie de meegeleverde scenario_client("broken-stream"):

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

with_options geeft een kopie van de client terug waarin enkele instellingen zijn veranderd. default_headers zijn headers die de kopie bij elke aanroep meestuurt, dus elk request via die client vraagt het gescripte model om het scenario, en stream_chat heeft geen headerparameter nodig. Les 5 laat de andere manier zien: extra_headers= bij één aanroep voegt alleen aan die aanroep een header toe.

Voer python client_calls.py opnieuw uit. Nu wordt de onderbroken stream gemeld zoals hoofdstuk 3 dat deed:

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.

Je lus leest bij elk stukje chunk.choices[0].delta.content en controleert chunk.choices nooit. Streams die normaal eindigen, mislukken helemaal aan het eind met IndexError. Waarom?

De aanroep van create in stream_chat werpt openai.InternalServerError op voordat er een stukje binnenkomt. Wat moet stream_chat doen?

Een onderbroken stream wierp openai.APIConnectionError op, waarvan de oorzaak wordt afgedrukt als RemoteProtocolError. Welke fout moet stream_chat afvangen?

Opdracht

Vervang in client_calls.py de onafgemaakte body van stream_chat(messages, *, client).

  • Roep client.chat.completions.create(model=MODEL, messages=messages, stream=True, stream_options={"include_usage": True}) aan, buiten elk try-blok.

  • Loop over de stukjes. Sla een stukje over waarvan choices leeg is. Druk elke niet-lege chunk.choices[0].delta.content af met end="" en flush=True, en bewaar die.

  • Onthoud of de finish_reason van een stukje ooit niet None was.

  • Als openai.APIConnectionError wordt opgeworpen terwijl je loopt, druk dan één newline af en werp StreamBroken("".join(pieces)) op.

  • Druk na de lus één newline af. Als geen enkel stukje een finish_reason had, werp dan StreamBroken("".join(pieces)) op; geef anders de samengevoegde tekst terug.

Vang geen andere exception af. Voer na elke stap python client_calls.py uit om de stream en de onderbroken stream te zien, en controleer daarna je werk.