What are hooks in the Requests library, and how do I use them?

Hooks in the Python requests library are a mechanism that allows you to attach functions (callbacks) to certain stages of the request process. You can use hooks to modify the request or the response, log information, handle exceptions, or perform any other custom action you need.

The most commonly used hook is the response hook, which allows you to process the response after it has been received but before it is returned from the requests.get(), requests.post(), or any other method that sends a request.

Here's how you can use hooks in the requests library:

1. Define a callback function that takes a response object as an argument.
2. Attach this function to the hooks dictionary of your request call, using the response key.
3. Send your request as usual.

Let's go through an example to see how it works:

import requests

# Define the hook function
def print_url(response, *args, **kwargs):
    print("Request URL:", response.url)
    # You can also modify the response here if needed
    return response  # It's important to return the response object

# Send a request with the hook
response = requests.get('https://httpbin.org/get', hooks={'response': print_url})

# The hook function will be called after the response is received,
# but before the response object is returned from requests.get()

When you run this script, the URL of the request will be printed to the console, because the print_url function is called with the response object after the request is complete.

You can also use multiple hook functions for the same stage by passing them in a list:

def log_response(response, *args, **kwargs):
    print("Status Code:", response.status_code)
    # Additional logging here
    return response

response = requests.get('https://httpbin.org/get', hooks={'response': [print_url, log_response]})

In this case, both print_url and log_response will be called in the order they are listed in the array.

Hooks provide a powerful way to extend the functionality of the requests library without having to subclass or wrap the library's classes. This makes your code more modular and easier to maintain.