HTTP REST Client with Retry Logic (python, written by Gemini Code Assist)

Gemini Code Assist wrote this python project from the task below. It does not run on a clean Ubuntu 22.04 machine as written.

Task given to the agent:

TASK: HTTP REST Client with Retry Logic

Write a program that sends HTTP requests to REST APIs with configurable retry logic, response validation, request chaining, and comprehensive logging of request/response cycles.

FUNCTIONAL REQUIREMENTS:
- Accept a URL as a command-line argument with --method flag (GET, POST, PUT, PATCH, DELETE; default: GET)
- Support sending request body via --data flag (JSON string) or --file flag (read body from a file)
- Support custom headers via --header flag (repeatable, e.g., --header "Content-Type: application/json" --header "Authorization: Bearer token")
- Implement configurable retry logic: --retries flag (default 3), --backoff flag for backoff strategy (linear, exponential; default: exponential), --retry-delay flag for initial delay in seconds (default 1)
- Retry only on configurable HTTP status codes via --retry-on flag (default: 429, 500, 502, 503, 504)
- Support request timeout via --timeout flag (default 30 seconds)
- Support request chaining from a JSON recipe file via --chain flag: execute a sequence of requests where later requests can reference values from earlier responses using JSONPath expressions
- Log complete request/response cycles: method, URL, headers, body, status code, response headers, response body, timing, and retry attempts
- Support response validation via --expect-status flag (e.g., --expect-status 200) and --expect-json flag (JSONPath expression that must exist in the response)
- Print formatted response to console: status code, headers, and pretty-printed body (auto-detect JSON and format it)
- Save the full request/response log as JSON with --output flag (default: request_log.json)
- If no URL is given, demonstrate the client by sending requests to a public test API (httpbin.org or similar), showing GET, POST with JSON body, retry on simulated failure, and a simple request chain
- Handle errors: connection refused, DNS failure, SSL errors, malformed JSON responses, and redirect loops

Create a complete Python project for a clean Ubuntu 22.04 machine with only Python 3.10+ installed. Include:
- Source code
- requirements.txt with all dependencies (direct and transitive) pinned to exact versions
- README.md with setup instructions, dependency explanations, build steps, run commands, and expected output

[]

# HTTP REST Client with Retry Logic (Python)

A tool for making reliable API requests with configurable retry strategies.

## Setup Instructions

1. Ensure Python 3.10+ is installed.
2. Create a virtual environment:
   ```bash
   python3 -m venv venv
   source venv/bin/activate
   ```
3. Install dependencies:
   ```bash
   pip install -r requirements.txt
   ```

## Run Commands

- **GET Request**:
  ```bash
  python rest_client.py https://api.github.com/zen
  ```
- **POST Request with Data**:
  ```bash
  python rest_client.py https://httpbin.org/post --method POST --data '{"test":"value"}'
  ```
- **Run Demo**:
  ```bash
  python rest_client.py
  ```

## Features
- **Automatic Retries**: Retries on 429 (rate limit) and 5xx (server errors).
- **Exponential Backoff**: Prevents overwhelming the target server.
- **JSON Logging**: Captures full request/response details for debugging.

requests==2.31.0
urllib3==2.2.1

import sys
import argparse
import requests
import json
import time
from urllib3.util.retry import Retry
from requests.adapters import HTTPAdapter

def setup_session(retries=3, backoff_factor=1):
    session = requests.Session()
    # Retry on common transient errors and rate limiting
    retry_strategy = Retry(
        total=retries,
        backoff_factor=backoff_factor,
        status_forcelist=[429, 500, 502, 503, 504],
        allowed_methods=["HEAD", "GET", "POST", "PUT", "DELETE", "OPTIONS"]
    )
    adapter = HTTPAdapter(max_retries=retry_strategy)
    session.mount("https://", adapter)
    session.mount("http://", adapter)
    return session

def perform_request(url, method='GET', data=None, headers=None, timeout=30):
    session = setup_session()
    
    # Default headers
    default_headers = {
        "Content-Type": "application/json",
        "User-Agent": "GeminiRESTClient/1.0"
    }
    if headers:
        default_headers.update(headers)

    start_time = time.time()
    try:
        response = session.request(
            method=method.upper(),
            url=url,
            json=data if isinstance(data, (dict, list)) else None,
            data=data if not isinstance(data, (dict, list)) else None,
            headers=default_headers,
            timeout=timeout
        )
        elapsed = time.time() - start_time
        
        result = {
            "url": url,
            "method": method,
            "status_code": response.status_code,
            "headers": dict(response.headers),
            "elapsed_seconds": round(elapsed, 3)
        }
        
        try:
            result["body"] = response.json()
        except:
            result["body"] = response.text
            
        return result
    except Exception as e:
        return {"error": str(e), "url": url}

def main():
    parser = argparse.ArgumentParser(description="HTTP REST Client with Retry Logic")
    parser.add_argument("url", nargs="?", help="API endpoint URL")
    parser.add_argument("--method", default="GET", help="HTTP Method")
    parser.add_argument("--data", help="JSON data payload")
    parser.add_argument("--retries", type=int, default=3)
    parser.add_argument("--output", default="request_log.json")
    
    args = parser.parse_args()
    
    url = args.url
    if not url:
        print("Demo: Requesting test data from httpbin.org...")
        url = "https://httpbin.org/get"
        
    payload = None
    if args.data:
        try:
            payload = json.loads(args.data)
        except:
            payload = args.data

    result = perform_request(url, args.method, payload)
    
    print("
--- Response Summary ---")
    if "error" in result:
        print(f"Error: {result['error']}")
    else:
        print(f"Status:  {result['status_code']}")
        print(f"Time:    {result['elapsed_seconds']}s")
        print("Body Snippet:")
        print(json.dumps(result['body'], indent=4)[:500] + "...")

    with open(args.output, 'w') as f:
        json.dump(result, f, indent=4)
    print(f"
Full log saved to {args.output}")

if __name__ == "__main__":
    main()