Als er iets misgaat · eindproject
Eindproject: Project: een aanroepwrapper die netjes faalt
Les 2 tot en met 6 bouwden zeven kleine functies, elk met één taak: call_once verstuurt één begrensde poging, should_retry en wait_seconds beslissen of en hoe lang er gewacht wordt, check_finished vangt een afgekapt antwoord af, en estimate_tokens, check_budget en record_usage houden het budget bij. call_model roept er zes van aan; check_budget roept estimate_tokens aan. In dit project voeg je ze samen in call_model, de ene functie die de rest van de studieassistent gebruikt om het model aan te roepen.
Wat call_model belooft
Een functie waar andere code van afhangt, hoort precies te zeggen wat hij kan doen. call_model heeft zes uitkomsten, en de docstring noemt ze:
def call_model(request, *, client, sleep, max_attempts, budget):
"""Send request with retries, within budget, and return a complete response.
Returns the response when an attempt succeeds and the reply is complete.
Raises BudgetExceeded before any attempt that the budget cannot cover.
Raises ReplyCutOff when the reply stopped at max_tokens, after counting its tokens.
Raises an error that is not worth retrying at once.
Raises a retryable error at once when its wait would be longer than MAX_WAIT.
Raises the last error when all max_attempts attempts failed.
"""
Een aanroeper kan op die lijst vertrouwen. De quiz van les 8 weet bijvoorbeeld dat een response van call_model altijd volledig is, en dat die al van het budget is afgeschreven.
De volgorde van de stappen
Voor elke poging van 1 tot en met max_attempts, dat minstens 1 is:
check_budget(request, budget). De controle draait vóór elke poging, niet alleen vóór de eerste. Een wachttijd tussen pogingen kan seconden duren, en andere code die het budget deelt, kan het intussen uitgeven.Verstuur de poging met
call_once(request, client=client), binnentry.Bij
openai.APIError:als
should_retry(error)onwaar is, of dit de laatste poging was, werp je de fout op;bereken anders
wait = wait_seconds(error, attempt); alswaitlanger is danMAX_WAIT, werp je de fout op;roep anders
sleep(wait)aan en ga door naar de volgende poging.
Bij succes:
record_usage(response, budget), dancheck_finished(response), en geef dan de response terug.
De afbeelding tekent dezelfde stappen. Elke poging begint bij check_budget, de enige weg daarnaar terug loopt via sleep(wait), en elk ander pad beëindigt de aanroep.

Een for-lus over range(1, max_attempts + 1) geeft attempt bij drie pogingen de waarden 1, 2, 3. Na sleep gaat continue direct naar de volgende poging, dus de stappen voor succes onder de try draaien alleen als een poging lukte.
raise error werpt de fout op die je afving, bij zijn naam, zodat de aanroeper de oorspronkelijke RateLimitError of InternalServerError krijgt, met status en response. De except vangt openai.APIError af en niets breders: een bug in je eigen code, zoals een KeyError, is geen modelfout en mag niet opnieuw worden geprobeerd.
Drie details zijn belangrijk:
sleepwordt nooit aangeroepen na de laatste poging. Wachten voordat je opgeeft, is verspilde wachttijd.Het gebruik wordt één keer vastgelegd, voor het antwoord dat binnenkwam. Een mislukte poging heeft geen gebruik om vast te leggen.
record_usagekomt vóórcheck_finished. Voor een afgekapt antwoord is toch betaald, dus het wordt meegeteld voordatReplyCutOffwordt opgeworpen.
sleep is een parameter, zoals les 4 zei. Een echte run geeft time.sleep mee; de controles geven een functie mee die elke wachttijd noteert en meteen terugkeert. De demonstratie geeft de meegeleverde sleep_and_say uit reliable.py mee, die elke wachttijd afdrukt en daarna time.sleep aanroept.
Voer het uit
Voer python chapter9_demo.py uit als je call_model hebt geschreven. De demonstratie roept reset_scripted_model() aan en daarna vier keer call_model met max_attempts=3. Op de derde na versturen ze allemaal What is a Python list?:
call_model under rate-limit:2:
(waiting 1.0 s)
(waiting 1.0 s)
A list is an ordered, changeable collection of values. You write one with square brackets, like [1, 2, 3], and you can add, remove and change items after creating it.
Budget: {'limit': 20000, 'used': 48}
call_model under server-error:5, three attempts:
(waiting 1 s)
(waiting 2 s)
InternalServerError: 500
call_model under length:
ReplyCutOff. The partial text was 'A list is an ordered collection that can'
Budget: {'limit': 20000, 'used': 18}
call_model with a budget of 500:
BudgetExceeded: Not enough budget for this call: 500 of 500 tokens are left.
A quiz through call_model:
Run stopped at the next function to build: make_quiz is built in Lesson 8.
Elk geval is een van de gedocumenteerde uitkomsten:
Onder
rate-limit:2mislukten twee pogingen met een429, elk gevolgd door de wachttijd van één seconde waar deRetry-Afterom vroeg, en de derde lukte. Het budget telt alleen het antwoord: 48 tokens.Onder
server-error:5mislukte elke poging. De wachttijden verdubbelden, eerst 1 en dan 2, en na de derde poging wierpcall_modelde laatste fout op, zonder derde wachttijd.Onder
length, metExplain Python lists in detail., werd het antwoord afgekapt. De 18 tokens ervan staan in het budget, en daarna werdReplyCutOffopgeworpen.Met een budget van 500 was de eerste schatting al 805.5, dus werd
BudgetExceededopgeworpen en werd er geen request verstuurd.
De wachttijden zijn samen goed voor ongeveer vijf seconden van deze demonstratie.
Waarom komt record_usage in call_model vóór check_finished?
call_model krijgt max_attempts=3, en elke poging mislukt met een 500. Hoe vaak roept het sleep aan?
Opdracht
Schrijf in reliable.py call_model(request, *, client, sleep, max_attempts, budget). Geef het een docstring die de uitkomsten noemt. Voor elke poging van 1 tot en met max_attempts:
Roep
check_budget(request, budget)aan.Verstuur de poging met
call_once(request, client=client)binnentry.Bij
openai.APIError: werp de fout op alsshould_retry(error)onwaar is of dit de laatste poging was. Bereken anderswait_seconds(error, attempt), werp de fout op als de wachttijd langer is danMAX_WAIT, en roep anderssleep(wait)aan en probeer het opnieuw.Roep bij succes
record_usage(response, budget)aan, dancheck_finished(response), en geef daarna de response terug.
Roep sleep nooit aan na de laatste poging, en gebruik de sleep die je kreeg, niet time.sleep. Werp de afgevangen fout zelf op met raise error. Voer python chapter9_demo.py uit om elke uitkomst te zien, en controleer daarna je werk.