Error handling and rate limits in Prompt Engineering / GenAI - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding Rate Limits in API Calls

When using a machine learning API that enforces rate limits, what is the best practice to avoid hitting the limit?

A Send all requests as fast as possible and retry only if the server crashes.

B Ignore rate limits because the API will queue requests automatically.

C Implement a delay between requests to stay within the allowed number of calls per minute.

D Use multiple API keys simultaneously without restrictions.

💡 Hint

Think about how to respect the server's capacity to handle requests.

APIs with rate limits require clients to space out requests to avoid errors. Implementing delays or backoff strategies helps stay within limits.

❓ Predict Output

intermediate

Output of Error Handling Code

What will be the output of the following Python code snippet that calls a machine learning API with error handling?

Prompt Engineering / GenAI

import time

class APIError(Exception):
    pass

def call_api():
    raise APIError('Rate limit exceeded')

try:
    call_api()
except APIError as e:
    print(f'Error caught: {e}')
    time.sleep(1)
    print('Retrying...')

A

Error caught: Rate limit exceeded
Retrying...

B Error caught: Rate limit exceeded

C No output, program crashes

D Retrying...

💡 Hint

Look at what happens inside the except block.

The exception is caught and prints the error message, then waits 1 second, and prints 'Retrying...'.

❓ Model Choice

advanced

Choosing a Strategy for Handling API Rate Limits

You have a machine learning model API with a strict rate limit of 5 requests per second. Which strategy best handles this limit while maximizing throughput?

A Queue requests and send them at a steady rate of 5 per second.

B Send requests randomly without delay and ignore errors.

C Send 10 requests at once and retry failed ones after 10 seconds.

D Send 1 request per minute to be safe.

💡 Hint

Consider how to keep requests within the allowed rate without wasting time.

Queuing requests and sending them at the allowed rate maximizes throughput without triggering errors.

❓ Metrics

advanced

Interpreting Error Rate Metrics

You monitor your ML API calls and see the following metrics over 1000 requests: 950 successful, 30 rate limit errors, 20 timeout errors. What is the error rate percentage?

A 50%

B 2%

C 10%

D 5%

💡 Hint

Error rate = (number of errors / total requests) * 100

Total errors = 30 + 20 = 50. Error rate = (50/1000)*100 = 5%.

🔧 Debug

expert

Debugging API Rate Limit Handling Code

Given the following Python code snippet that calls an ML API, which option correctly identifies the bug causing the program to crash?

Prompt Engineering / GenAI

import time

rate_limit = 3
calls = 0
start_time = time.time()

def call_api():
    global calls, start_time
    if calls >= rate_limit:
        elapsed = time.time() - start_time
        time.sleep(1 - elapsed)
        calls = 0
        start_time = time.time()
    calls += 1
    print('API call made')

for _ in range(5):
    call_api()

A The variable 'calls' is not declared global inside call_api(), causing UnboundLocalError.

B The time.sleep() call may receive a negative argument causing ValueError.

C The start_time is reset too early, causing infinite loop.

D The loop runs 5 times but only 3 API calls are made.

💡 Hint

Check the calculation inside time.sleep().

If elapsed is greater than 1, 1 - elapsed is negative, and time.sleep() raises ValueError.

Practice

1. What is the main purpose of using error handling in AI applications?

easy

A. To keep the app running smoothly even when problems happen

B. To speed up the AI model training process

C. To increase the number of requests sent to the server

D. To reduce the size of the AI model

Solution

1. Step 1: Understand error handling purpose

   Error handling is used to manage unexpected problems during app execution.

2. Step 2: Connect to AI app context

   In AI apps, error handling helps keep the app running smoothly despite issues.

3. Final Answer:

   To keep the app running smoothly even when problems happen -> Option A

4. Quick Check:

   Error handling = keep app running smoothly [OK]

Hint: Error handling means catching problems to avoid crashes [OK]

Common Mistakes:

• Thinking error handling speeds up training
• Confusing error handling with increasing requests
• Believing error handling reduces model size

2. Which Python syntax correctly catches an error when calling an AI API?

easy

A. try:
response = call_api()
except:
print('Error occurred')

B. catch:
response = call_api()
try:
print('Error occurred')

C. if error:
response = call_api()
else:
print('Error occurred')

D. error handling:
response = call_api()
except:
print('Error occurred')

Solution

1. Step 1: Identify correct try-except syntax

   Python uses try: block followed by except: to catch errors.

2. Step 2: Match syntax with options

   try: response = call_api() except: print('Error occurred') uses correct try-except structure; others use invalid keywords.

3. Final Answer:

   try:\n response = call_api()\nexcept:\n print('Error occurred') -> Option A

4. Quick Check:

   try-except syntax = try: response = call_api() except: print('Error occurred') [OK]

Hint: Remember Python uses try: and except: blocks [OK]

Common Mistakes:

• Using catch instead of except
• Using if error instead of try-except
• Writing invalid keywords like error handling:

3. What will the following Python code print if the API returns a rate limit error?

import time

try:
    response = call_api()
except RateLimitError:
    print('Rate limit hit, waiting...')
    time.sleep(10)
    response = call_api()
print('Done')

medium

A. Error: RateLimitError not caught

B. Done

C. Rate limit hit, waiting...

D. Rate limit hit, waiting...\nDone

Solution

1. Step 1: Understand try-except with RateLimitError

   If call_api() raises RateLimitError, except block runs printing message and waits 10 seconds.

2. Step 2: After waiting, call_api() runs again and then prints 'Done'

   So output includes the message and 'Done' on separate lines.

3. Final Answer:

   Rate limit hit, waiting...\nDone -> Option D

4. Quick Check:

   RateLimitError caught, message + Done printed [OK]

Hint: Exception caught prints message then continues [OK]

Common Mistakes:

• Assuming no message prints
• Thinking program crashes on rate limit
• Ignoring the second call_api() after sleep

4. Identify the error in this code snippet handling rate limits:

try:
    response = call_api()
except RateLimitError
    print('Too many requests')
    time.sleep(5)
    response = call_api()

medium

A. call_api() should not be retried

B. time.sleep() cannot be used in except block

C. Missing colon after except RateLimitError

D. print statement syntax is incorrect

Solution

1. Step 1: Check except syntax

   Python requires a colon ':' after except RateLimitError to start the block.

2. Step 2: Verify other parts

   time.sleep() is valid, retrying call_api() is allowed, print syntax is correct.

3. Final Answer:

   Missing colon after except RateLimitError -> Option C

4. Quick Check:

   except needs colon ':' [OK]

Hint: except lines always end with a colon ':' [OK]

Common Mistakes:

• Forgetting colon after except
• Thinking sleep() is invalid in except
• Believing retry is not allowed

5. You want to build an AI app that calls an API but respects rate limits by retrying after waiting. Which code snippet correctly implements this with error handling and exponential backoff?

hard

A. import time
wait = 1
for _ in range(3):
try:
response = call_api()
break
except RateLimitError:
time.sleep(wait)
wait *= 2

B. import time
wait = 1
while True:
try:
response = call_api()
break
except RateLimitError:
time.sleep(wait)
wait *= 2

C. import time
wait = 1
for _ in range(3):
try:
response = call_api()
except RateLimitError:
wait *= 2
time.sleep(wait)
else:
break

D. import time
wait = 1
while True:
try:
response = call_api()
except RateLimitError:
time.sleep(wait)
wait += 1
else:
break

Solution

1. Step 1: Understand exponential backoff with retries

   We want to retry after waiting, doubling wait time each failure, and stop on success.

2. Step 2: Analyze options for correct loop and break

   import time wait = 1 while True: try: response = call_api() break except RateLimitError: time.sleep(wait) wait *= 2 uses while True loop, tries call_api(), breaks on success, and doubles wait after RateLimitError.

3. Step 3: Check other options

   import time wait = 1 for _ in range(3): try: response = call_api() break except RateLimitError: time.sleep(wait) wait *= 2 breaks on success but uses for loop with fixed tries (less flexible). import time wait = 1 while True: try: response = call_api() except RateLimitError: time.sleep(wait) wait += 1 else: break increments wait linearly, not exponential. import time wait = 1 for _ in range(3): try: response = call_api() except RateLimitError: wait *= 2 time.sleep(wait) else: break doubles wait before sleep, but order is less clear.

4. Final Answer:

   import time wait = 1 while True: try: response = call_api() break except RateLimitError: time.sleep(wait) wait *= 2 -> Option B

5. Quick Check:

   Retry loop with exponential backoff = import time wait = 1 while True: try: response = call_api() break except RateLimitError: time.sleep(wait) wait *= 2 [OK]

Hint: Use while True with break and double wait after error [OK]

Common Mistakes:

• Using for loop limits retries too strictly
• Incrementing wait linearly instead of doubling
• Not breaking loop on success