Building an Asynchronous HTTP Client with aiohttp

This challenge will guide you through creating a basic asynchronous HTTP client using the aiohttp library in Python. Understanding how to make asynchronous network requests is fundamental for building efficient and scalable web applications, APIs, and data scraping tools.

Problem Description

Your task is to implement a Python script that acts as an asynchronous HTTP client. This client should be capable of making GET requests to a specified URL and handling the response. You will need to use the aiohttp library to manage the asynchronous network operations.

Key Requirements:

1. Asynchronous GET Request: Implement a function that takes a URL as input and performs an asynchronous GET request to that URL.
2. Response Handling: The function should successfully retrieve the response from the server.
3. Error Handling: Implement basic error handling for network issues (e.g., connection errors, timeouts).
4. Content Retrieval: Extract and return the text content of the HTTP response.
5. Asynchronous Execution: The entire client logic should be runnable within an async function and executed using asyncio.run().

Expected Behavior:

When the script is run with a valid URL, it should print the text content of the response from that URL. If an error occurs during the request, it should print an informative error message.

Edge Cases to Consider:

• Invalid URLs (e.g., malformed, non-existent domains).
• Server errors (e.g., 404 Not Found, 500 Internal Server Error).
• Network connectivity issues.

Examples

Example 1:

Input URL: "https://httpbin.org/get"

Output:
{
  "args": {},
  "headers": {
    "Accept": "*/*",
    "Accept-Encoding": "gzip, deflate",
    "Host": "httpbin.org",
    "User-Agent": "Python/3.x aiohttp/x.x.x",
    "X-Amzn-Trace-Id": "Root=..."
  },
  "origin": "...",
  "url": "https://httpbin.org/get"
}
Explanation: The script successfully made a GET request to httpbin.org/get and returned the JSON response, which includes details about the request itself.

Example 2:

Input URL: "https://httpbin.org/status/404"

Output:
Error fetching URL: https://httpbin.org/status/404 - Status: 404
Explanation: The request to a URL that returns a 404 status code should be handled gracefully, indicating the status code received.

Example 3:

Input URL: "http://this-is-a-non-existent-domain-123456789.com"

Output:
Error fetching URL: http://this-is-a-non-existent-domain-123456789.com - Error: [Specific connection error message, e.g., 'Name or service not known']
Explanation: A request to a non-existent domain should trigger a connection error, and the script should report this error.

Constraints

• You must use the aiohttp library for making HTTP requests.
• You must use the asyncio library for managing asynchronous operations.
• The solution should be a single Python script.
• The script should be executable from the command line.

Notes

• The aiohttp library provides ClientSession for managing connections. It's recommended to create a single session and reuse it for multiple requests if you were to extend this functionality.
• Consider using async with statements for managing resources like ClientSession and the response object.
• The aiohttp.ClientError class is a good base for catching various aiohttp-related exceptions.
• asyncio.run() is the standard way to run the top-level async function in Python 3.7+.
• For a basic implementation, you don't need to handle every single HTTP status code, but gracefully indicating non-2xx status codes is good practice.