HTTPX Retries

https://github.com/will-ockmore/httpx-retries
Admin
HTTPX Retries is a retry layer for the HTTPX library, designed to handle flaky and unreliable APIs...
Tokens:20,603
Snippets:253
Trust Score:8
License:MIT
Update:1 month ago
Show doc for...
Tokens:
Raw
### Requests Library Equivalent with urllib3 Retry

Source: https://github.com/will-ockmore/httpx-retries/blob/main/docs/index.md

This example shows the equivalent setup using the requests library and urllib3's Retry utility. It demonstrates how httpx-retries aims for a similar developer experience.

```python
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

retry = Retry(total=5, backoff_factor=0.5)
adapter = HTTPAdapter(max_retries=retry)

with requests.Session() as session:
    session.mount("http://", adapter)
    session.mount("https://", adapter)
    response = session.get("https://example.com")
```

--------------------------------

### Install httpx-retries

Source: https://github.com/will-ockmore/httpx-retries/blob/main/docs/index.md

Install the httpx-retries package using pip. This is the first step to enable retry functionality.

```bash
pip install httpx-retries
```

--------------------------------

### Basic Asynchronous Client Setup

Source: https://github.com/will-ockmore/httpx-retries/blob/main/docs/index.md

Use RetryTransport with an asynchronous httpx.AsyncClient for retrying requests in async applications. The setup is similar to the synchronous version.

```python
import httpx
from httpx_retries import RetryTransport

async with httpx.AsyncClient(transport=RetryTransport()) as client:
    response = await client.get("https://example.com")
```

--------------------------------

### Tenacity Retry Example for Connection Errors

Source: https://github.com/will-ockmore/httpx-retries/blob/main/docs/differences_with_other_retry_libraries.md

This example demonstrates how to configure Tenacity to retry a function up to three times specifically for HTTPX connection errors on a particular host, logging each retry attempt.

```python
import logging

import httpx
from tenacity import before_sleep_log, retry, retry_if_exception, stop_after_attempt

logger = logging.getLogger(__name__)

SOME_HOST: str = "..."  # GET requests are known to be flaky on this host.

def is_some_host_predicate(exc: BaseException) -> bool:
    return isinstance(exc, httpx.ConnectError) and exc.request.url.host == SOME_HOST

@retry(
    retry=retry_if_exception(is_some_host_predicate),
    before_sleep=before_sleep_log(logger, logging.WARNING),
    stop=stop_after_attempt(3),
)
async def get_from_some_host(client: httpx.AsyncClient, ...):
    ...
```

--------------------------------

### Basic Synchronous Client Setup

Source: https://github.com/will-ockmore/httpx-retries/blob/main/docs/index.md

Add the RetryTransport to a synchronous httpx.Client to enable automatic retries. Defaults are used for retry configuration.

```python
import httpx
from httpx_retries import RetryTransport

with httpx.Client(transport=RetryTransport()) as client:
    response = client.get("https://example.com")
```

--------------------------------

### Compare with Requests Retry Pattern

Source: https://github.com/will-ockmore/httpx-retries/blob/main/README.md

Example of the equivalent retry configuration using the requests library and urllib3.

```python
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

retry = Retry(total=5, backoff_factor=0.5)
adapter = HTTPAdapter(max_retries=retry)

with requests.Session() as session:
    session.mount("http://", adapter)
    session.mount("https://", adapter)
    response = session.get("https://example.com")
```

--------------------------------

### Custom Retry Strategy with Specific Backoff

Source: https://github.com/will-ockmore/httpx-retries/blob/main/docs/behaviour.md

Implement a custom retry strategy by subclassing Retry. This example waits 1 second for every third attempt, otherwise using the default strategy. Ensure the Retry class is imported.

```python
from httpx_retries import Retry

class CustomRetry(Retry):
    def backoff_strategy(self) -> float:
        if self.attempts_made % 3:
            return 1.0

        return super().backoff_strategy()
```

--------------------------------

### Basic retry_request usage

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/api-reference/retry-request-functions.md

Perform a standard GET request using the default retry configuration.

```python
import httpx
from httpx_retries import retry_request, Retry

with httpx.Client() as client:
    # Standard retry_request usage with default retry config
    response = retry_request(client, "GET", "https://example.com/large-file")
    print(f"Status: {response.status_code}")
```

--------------------------------

### Handling Retry-After parsing errors

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/errors.md

Example of catching a ValueError during header parsing and falling back to a default backoff strategy.

```python
from httpx_retries import Retry
import httpx

retry = Retry()

try:
    sleep_time = retry.parse_retry_after("not-a-valid-date")
except ValueError as e:
    print(f"Failed to parse Retry-After header: {e}")
    # Fall back to backoff strategy
    sleep_time = retry.backoff_strategy()
```

--------------------------------

### Implement validate_response Callback

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/types.md

Example implementation of a response validation callback that triggers a retry on invalid JSON.

```python
from httpx_retries import Retry, RetryTransport
import httpx
import json

def validate_json_response(response: httpx.Response) -> None:
    # Retry if response is not valid JSON
    try:
        response.json()
    except json.JSONDecodeError:
        raise ValueError("Response is not valid JSON")

retry = Retry(validate_response=validate_json_response)
transport = RetryTransport(retry=retry)

with httpx.Client(transport=transport) as client:
    response = client.get("https://api.example.com/data")
```

--------------------------------

### Configure Retry for Streaming APIs

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/configuration.md

Restrict retries to safe methods like GET to prevent unintended side effects during streaming operations.

```python
from httpx_retries import Retry, RetryTransport
import httpx

retry = Retry(
    total=3,
    allowed_methods=["GET"],  # Only GET can be retried safely
    backoff_factor=0.5,
    respect_retry_after_header=True
)
transport = RetryTransport(retry=retry)

with httpx.Client(transport=transport) as client:
    response = client.get("https://streaming-api.example.com")
```

--------------------------------

### Initialize with default settings

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/api-reference/retry-class.md

Create a Retry instance with default settings and attach it to an httpx Client via RetryTransport.

```python
import httpx
from httpx_retries import Retry, RetryTransport

# Default configuration: 10 retries with no backoff
retry = Retry()
transport = RetryTransport(retry=retry)

with httpx.Client(transport=transport) as client:
    response = client.get("https://example.com")
```

--------------------------------

### Initialize with Default Configuration

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/api-reference/retry-transport-class.md

Create a transport using default retry settings and internal transport defaults.

```python
import httpx
from httpx_retries import RetryTransport

# Creates transport with default Retry() and internal transports
transport = RetryTransport()

with httpx.Client(transport=transport) as client:
    response = client.get("https://example.com")
```

--------------------------------

### Respect Retry-After header

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/configuration.md

Enable respect_retry_after_header to honor server-provided wait times, capped by max_backoff_wait.

```python
from httpx_retries import Retry, RetryTransport
import httpx

retry = Retry(
    total=5,
    respect_retry_after_header=True,  # Default
    backoff_factor=0.5,
    max_backoff_wait=120.0
)
transport = RetryTransport(retry=retry)

with httpx.Client(transport=transport) as client:
    response = client.get("https://api.example.com/data")
    # If response has Retry-After header, will wait that duration (capped at max_backoff_wait)
```

--------------------------------

### Initialize with Custom Retry Configuration

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/api-reference/retry-transport-class.md

Configure retry behavior by passing a custom Retry object to the constructor.

```python
import httpx
from httpx_retries import Retry, RetryTransport

retry = Retry(total=5, backoff_factor=0.5)
transport = RetryTransport(retry=retry)

with httpx.Client(transport=transport) as client:
    response = client.get("https://example.com")
```

--------------------------------

### Sync Client with Default Retries

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/INDEX.md

Initializes an httpx client with the default RetryTransport configuration.

```python
import httpx
from httpx_retries import RetryTransport

with httpx.Client(transport=RetryTransport()) as client:
    response = client.get("https://example.com")
```

--------------------------------

### Configure Sync Client with RetryTransport

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/api-reference/retry-transport-class.md

Initializes a synchronous httpx client with a RetryTransport instance using a defined Retry configuration.

```python
import httpx
from httpx_retries import Retry, RetryTransport

# Create retry configuration
retry = Retry(
    total=5,
    backoff_factor=0.5,
    status_forcelist=[429, 502, 503, 504]
)

# Create transport with retry configuration
transport = RetryTransport(retry=retry)

# Use with sync client
with httpx.Client(transport=transport) as client:
    response = client.get("https://api.example.com/data")
    print(response.status_code)
```

--------------------------------

### Retry.__init__

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/types.md

Initializes the Retry configuration object with specific parameters for controlling retry behavior.

```APIDOC
## Retry.__init__(allowed_methods, status_forcelist, retry_on_exceptions)

### Description
Initializes a new Retry configuration instance. This object defines which HTTP methods, status codes, and exceptions trigger a retry attempt.

### Parameters
- **allowed_methods** (Iterable[HTTPMethod | str]) - Optional - Collection of HTTP methods eligible for retry. Defaults to ["HEAD", "GET", "PUT", "DELETE", "OPTIONS", "TRACE"].
- **status_forcelist** (Iterable[HTTPStatus | int]) - Optional - Collection of HTTP status codes that trigger a retry. Defaults to [429, 502, 503, 504].
- **retry_on_exceptions** (Iterable[type[Exception]]) - Optional - Collection of exception types that trigger a retry. Defaults to (httpx.TimeoutException, httpx.NetworkError, httpx.RemoteProtocolError).
```

--------------------------------

### Configure Logging and RetryTransport

Source: https://github.com/will-ockmore/httpx-retries/blob/main/docs/logging.md

This snippet demonstrates how to set up basic logging with a custom format and level, and initialize RetryTransport with retry parameters. It's used to enable detailed logging for HTTPX requests that involve retries.

```python
import logging

import httpx

from httpx_retries import Retry, RetryTransport

logging.basicConfig(
    format="%(levelname)s [%(asctime)s] %(name)s - %(message)s",
    datefmt="%Y-%m-%d %H:%M:%S",
    level=logging.DEBUG
)

transport = RetryTransport(retry=Retry(total=3, backoff_factor=0.5))

with httpx.Client(transport=transport) as client:
    response = client.get("https://httpco.de/429")
```

--------------------------------

### Initialize with Custom Underlying Transport

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/api-reference/retry-transport-class.md

Wrap an existing HTTPX transport to add retry logic to specific transport configurations.

```python
import httpx
from httpx_retries import RetryTransport

# Wrap a custom transport (e.g., with specific local address binding)
base_transport = httpx.HTTPTransport(local_address="0.0.0.0")
transport = RetryTransport(transport=base_transport)

with httpx.Client(transport=transport) as client:
    response = client.get("https://example.com")
```

--------------------------------

### Configure Async Client with RetryTransport

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/api-reference/retry-transport-class.md

Initializes an asynchronous httpx client with a RetryTransport instance, enabling retry logic for async requests.

```python
import httpx
from httpx_retries import Retry, RetryTransport
import asyncio

async def main():
    retry = Retry(
        total=5,
        backoff_factor=0.5,
        respect_retry_after_header=True
    )
    
    transport = RetryTransport(retry=retry)
    
    async with httpx.AsyncClient(transport=transport) as client:
        response = await client.get("https://api.example.com/data")
        print(response.status_code)

asyncio.run(main())
```

--------------------------------

### Request with headers and parameters

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/api-reference/retry-request-functions.md

Pass custom headers and query parameters to the request.

```python
import httpx
from httpx_retries import retry_request, Retry

retry = Retry(total=5, backoff_factor=0.5)

with httpx.Client() as client:
    response = retry_request(
        client,
        "GET",
        "https://api.example.com/data",
        retry=retry,
        params={"limit": 100, "offset": 0},
        headers={"Authorization": "Bearer token123"}
    )
    print(response.json())
```

--------------------------------

### Implement Immutable Configuration

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/README.md

Demonstrates that retry instances are immutable and return a new instance upon modification.

```python
retry = Retry(total=5)
retry = retry.increment()  # Returns new Retry with attempts_made=1
```

--------------------------------

### Importing httpx-retries symbols

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/README.md

Import the core classes and helper functions required to configure and execute retries with HTTPX.

```python
from httpx_retries import (
    Retry,              # Configuration class
    RetryTransport,     # HTTPX transport wrapper
    retry_request,      # Sync helper function
    aretry_request,     # Async helper function
)
```

--------------------------------

### Configure RetryTransport

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/api-reference/overview.md

Initialize a RetryTransport and attach it to an HTTPX client instance.

```python
import httpx
from httpx_retries import RetryTransport

transport = RetryTransport()
with httpx.Client(transport=transport) as client:
    response = client.get("https://example.com")
```

--------------------------------

### Using RetryTransport with Client

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/types.md

Configure a client with RetryTransport to track retry attempts and sleep duration.

```python
import httpx
from httpx_retries import Retry, RetryTransport

retry = Retry(total=5, backoff_factor=0.5)
transport = RetryTransport(retry=retry)

with httpx.Client(transport=transport) as client:
    response = client.get("https://example.com")
    
    if "retry" in response.extensions:
        retry_state = response.extensions["retry"]
        print(f"Attempts: {retry_state.attempts_made}")
        print(f"Total sleep: {retry_state.elapsed_sleep}s")
```

--------------------------------

### Use Dual-Mode Transport

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/README.md

Shows how to use RetryTransport with both synchronous and asynchronous httpx clients.

```python
# Sync
transport = RetryTransport()
with httpx.Client(transport=transport) as client:
    response = client.get("https://example.com")

# Async
async with httpx.AsyncClient(transport=transport) as client:
    response = await client.get("https://example.com")
```

--------------------------------

### Apply transport parameters correctly

Source: https://github.com/will-ockmore/httpx-retries/blob/main/docs/faq.md

Pass configuration parameters directly to the HTTPTransport instance instead of the Client constructor when using a custom transport.

```python
with Client(
    transport=RetryTransport(
        HTTPTransport(
            # Pass a transport with these parameters to wrap.
            http2=True,
            limits=httpx.Limits(max_connections=100, max_keepalive_connections=100, keepalive_expiry=60),
            verify=False
        ),
        retry=Retry(total=5, backoff_factor=0.5),
    )
    # These will do nothing!
    http2=True,
    limits=httpx.Limits(max_connections=100, max_keepalive_connections=100, keepalive_expiry=60),
    verify=False
) as client:
    ...
```

--------------------------------

### Async Client with Default Retries

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/INDEX.md

Demonstrates usage of RetryTransport within an asynchronous httpx client context.

```python
import httpx
from httpx_retries import RetryTransport
import asyncio

async def main():
    async with httpx.AsyncClient(transport=RetryTransport()) as client:
        response = await client.get("https://example.com")

asyncio.run(main())
```

--------------------------------

### POST request behavior

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/api-reference/retry-request-functions.md

Demonstrate that POST requests are not retried by default even if specified in the retry configuration.

```python
import httpx
from httpx_retries import retry_request, Retry

retry = Retry(allowed_methods=["GET", "POST"])  # POST is not retryable by default

with httpx.Client() as client:
    response = retry_request(
        client,
        "POST",
        "https://api.example.com/submit",
        retry=retry,
        json={"data": "value"}
    )
    # POST bypasses retry logic even though allowed_methods includes it
    # (POST is not in Retry's default retryable methods)
    print(response.status_code)
```

--------------------------------

### Helper Functions

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/INDEX.md

Convenience functions for performing retriable requests using existing HTTPX clients.

```APIDOC
## retry_request(client, method, url, *, retry=None, **kwargs)

### Description
Sync request with header and body-phase retry.

### Parameters
- **client** (httpx.Client) - Required
- **method** (str) - Required
- **url** (str|URL) - Required
- **retry** (Retry|None) - Optional

## aretry_request(client, method, url, *, retry=None, **kwargs)

### Description
Async request with header and body-phase retry.

### Parameters
- **client** (httpx.AsyncClient) - Required
- **method** (str) - Required
- **url** (str|URL) - Required
- **retry** (Retry|None) - Optional
```

--------------------------------

### Configure exponential backoff with jitter

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/api-reference/retry-class.md

Use backoff_factor and backoff_jitter to implement exponential backoff strategies for unreliable endpoints.

```python
from httpx_retries import Retry, RetryTransport
import httpx

# Retry up to 5 times with exponential backoff and full jitter
retry = Retry(
    total=5,
    backoff_factor=0.5,
    backoff_jitter=1.0,  # Full jitter (0-100%)
    max_backoff_wait=60.0
)
transport = RetryTransport(retry=retry)

with httpx.Client(transport=transport) as client:
    try:
        response = client.get("https://unreliable-api.example.com")
    except Exception as e:
        print(f"Request failed after all retries: {e}")
```

--------------------------------

### Import retry helper functions

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/api-reference/retry-request-functions.md

Import the necessary helper functions for synchronous and asynchronous request retries.

```python
from httpx_retries import retry_request, aretry_request
```

--------------------------------

### Configure Retry for Rate-Limited APIs

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/configuration.md

Use status_forcelist and respect_retry_after_header to handle 429 Too Many Requests responses effectively.

```python
from httpx_retries import Retry, RetryTransport
import httpx

retry = Retry(
    total=10,
    status_forcelist=[429, 502, 503, 504],
    backoff_factor=1.0,
    respect_retry_after_header=True,  # Critical for rate limiting
    max_backoff_wait=300.0  # Up to 5 minutes
)
transport = RetryTransport(retry=retry)

with httpx.Client(transport=transport) as client:
    response = client.get("https://rate-limited-api.example.com")
```

--------------------------------

### Configure Retry for Flaky Internal Services

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/configuration.md

Set a lower backoff factor and disable Retry-After header respect for internal services that do not provide standard headers.

```python
from httpx_retries import Retry, RetryTransport
import httpx

retry = Retry(
    total=5,
    status_forcelist=[502, 503, 504],
    backoff_factor=0.5,
    respect_retry_after_header=False,  # Internal service doesn't set this
    max_backoff_wait=30.0
)
transport = RetryTransport(retry=retry)

with httpx.Client(transport=transport) as client:
    response = client.get("https://internal-service.internal")
```

--------------------------------

### Import retry_request Function

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/api-reference/overview.md

Import the helper function for synchronous request retries.

```python
from httpx_retries import retry_request
```

--------------------------------

### Configure RetryTransport for HTTPX Clients

Source: https://github.com/will-ockmore/httpx-retries/blob/main/README.md

Add the RetryTransport to sync and async HTTPX clients to enable automatic retries.

```python
import httpx
from httpx_retries import RetryTransport

with httpx.Client(transport=RetryTransport()) as client:
    response = client.get("https://example.com")
```

```python
async with httpx.AsyncClient(transport=RetryTransport()) as client:
    response = await client.get("https://example.com")
```

--------------------------------

### Import RetryTransport

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/api-reference/retry-transport-class.md

Import the class from the httpx_retries package.

```python
from httpx_retries import RetryTransport
```

--------------------------------

### handle_request(request)

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/api-reference/retry-transport-class.md

Sends an HTTP request synchronously, applying retry logic based on the configured policy.

```APIDOC
## handle_request(request)

### Description
Send an HTTP request synchronously, retrying according to the configured retry policy.

### Parameters
- **request** (httpx.Request) - Required - The HTTP request to send

### Returns
- **httpx.Response** - The final response after retries or the original failure response

### Raises
- **RuntimeError** - If synchronous transport is not available
- **TypeError** - If validate_response is async
- **Exception** - Any exception from is_retryable_exception if retries are exhausted
```

--------------------------------

### Custom Retry Strategy with Specific Configuration

Source: https://github.com/will-ockmore/httpx-retries/blob/main/docs/index.md

Configure a custom retry strategy by providing a Retry object with specific parameters like total retries and backoff factor. This allows fine-tuning retry behavior.

```python
from httpx_retries import Retry
from httpx_retries import RetryTransport

retry = Retry(total=5, backoff_factor=0.5)
transport = RetryTransport(retry=retry)

with httpx.Client(transport=transport) as client:
    response = client.get("https://example.com")
```

--------------------------------

### Import Retry class

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/api-reference/retry-class.md

Import the Retry class to begin configuring request retry behavior.

```python
from httpx_retries import Retry
```

--------------------------------

### Implement linear backoff

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/configuration.md

Override the backoff_strategy method to create a custom linear wait time between retries.

```python
from httpx_retries import Retry, RetryTransport
import httpx

class LinearRetry(Retry):
    def backoff_strategy(self) -> float:
        linear_backoff = self.attempts_made * 1.0
        return min(linear_backoff, self.max_backoff_wait)

retry = LinearRetry(total=5, max_backoff_wait=10.0)
transport = RetryTransport(retry=retry)

with httpx.Client(transport=transport) as client:
    response = client.get("https://example.com")
```

--------------------------------

### Retry-After parsing logic

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/errors.md

Internal implementation of the Retry-After header parsing, showing the validation logic for integers and HTTP dates.

```python
def parse_retry_after(self, retry_after: str) -> float:
    retry_after = retry_after.strip()
    if retry_after.isascii() and retry_after.isdigit():
        return float(retry_after)
    
    try:
        parsed_date = parsedate_to_datetime(retry_after)
        # ...
    except (TypeError, ValueError):
        raise ValueError(f"Invalid Retry-After header: {retry_after}")
```

--------------------------------

### Configure Custom Backoff

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/api-reference/overview.md

Defines specific retry limits and backoff parameters using the Retry class.

```python
from httpx_retries import Retry, RetryTransport
import httpx

retry = Retry(total=5, backoff_factor=0.5, max_backoff_wait=60.0)
with httpx.Client(transport=RetryTransport(retry=retry)) as client:
    response = client.get("https://example.com")
```

--------------------------------

### Compare retry_request with standard client methods

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/api-reference/retry-request-functions.md

Demonstrates how retry_request enables retries for body-phase errors, unlike standard client.get() calls.

```python
import httpx
from httpx_retries import retry_request, Retry

# Standard approach (no body-phase retry)
with httpx.Client() as client:
    response = client.get("https://example.com/file")
    # ReadTimeout during response.content read will NOT be retried

# With retry_request (body-phase errors retried)
with httpx.Client() as client:
    retry = Retry(total=3, backoff_factor=0.5)
    response = retry_request(
        client,
        "GET",
        "https://example.com/file",
        retry=retry
    )
    # ReadTimeout during body download WILL be retried
```

--------------------------------

### Configure retry backoff parameters

Source: https://github.com/will-ockmore/httpx-retries/blob/main/docs/faq.md

Adjust max_backoff_wait and backoff_factor to control the total time spent across multiple retry attempts.

```python
Retry(total=3, max_backoff_wait=5.0, backoff_factor=1, jitter=0)
```

--------------------------------

### Configure Retry Hierarchy

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/README.md

Illustrates the priority order for retry configuration, where request-level settings override transport-level settings.

```python
request.extensions["retry"] = Retry(...)  # Highest priority
# vs
RetryTransport(retry=Retry(...))  # Medium priority
# vs
Retry()  # Defaults
```

--------------------------------

### copy_with(**kwargs)

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/api-reference/retry-class.md

Creates a new Retry instance with specific fields overridden, useful for maintaining state during retry loops.

```APIDOC
## copy_with(**kwargs)

### Description
Return a new Retry instance with selected fields overridden. Used internally to create new instances during retry loops.

### Returns
- **Retry**: New instance with specified fields replaced.
```

--------------------------------

### Configure Retries for Flaky Services

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/api-reference/overview.md

Suitable for internal services that do not provide Retry-After headers, allowing for a standard backoff factor.

```python
from httpx_retries import Retry, RetryTransport
import httpx

retry = Retry(
    total=5,
    backoff_factor=0.5,
    respect_retry_after_header=False  # Internal doesn't set this
)
with httpx.Client(transport=RetryTransport(retry=retry)) as client:
    response = client.get("https://internal.example.com")
```

--------------------------------

### Retry Class Constructor

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/configuration.md

The Retry class is initialized with various parameters to define how HTTP requests should be retried upon failure or specific status codes.

```APIDOC
## Retry(total, allowed_methods, status_forcelist, retry_on_exceptions, backoff_factor, respect_retry_after_header, max_backoff_wait, backoff_jitter, attempts_made, total_timeout, elapsed_sleep, validate_response)

### Description
Initializes the retry configuration for httpx requests.

### Parameters
- **total** (int) - Optional - Maximum number of times to retry a request. Default: 10.
- **allowed_methods** (Iterable[HTTPMethod | str]) - Optional - HTTP methods eligible for retry. Default: ["HEAD", "GET", "PUT", "DELETE", "OPTIONS", "TRACE"].
- **status_forcelist** (Iterable[HTTPStatus | int]) - Optional - HTTP status codes that trigger a retry. Default: [429, 502, 503, 504].
- **retry_on_exceptions** (Iterable[type[Exception]]) - Optional - Exception types that trigger a retry. Default: [httpx.TimeoutException, httpx.NetworkError, httpx.RemoteProtocolError].
- **backoff_factor** (float) - Optional - Multiplier for exponential backoff calculation. Default: 0.0.
- **respect_retry_after_header** (bool) - Optional - Whether to honor the Retry-After response header. Default: True.
- **max_backoff_wait** (float) - Optional - Maximum seconds to wait between retries. Default: 120.0.
- **backoff_jitter** (float) - Optional - Jitter applied to backoff (0 to 1). Default: 1.0.
- **attempts_made** (int) - Optional - Number of attempts already made. Default: 0.
- **total_timeout** (float | None) - Optional - Maximum total seconds to sleep across all retries. Default: None.
- **elapsed_sleep** (float) - Optional - Cumulative sleep time already spent. Default: 0.0.
- **validate_response** (Callable[[httpx.Response], None | Awaitable[None]] | None) - Optional - Callback to validate non-retryable-status responses.
```

--------------------------------

### Configure Aggressive Retries

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/configuration.md

Increase retry count and backoff duration to handle highly unreliable endpoints.

```python
from httpx_retries import Retry, RetryTransport
import httpx

retry = Retry(
    total=20,  # 20 retries
    backoff_factor=2.0,  # Exponential backoff
    max_backoff_wait=300.0  # Up to 5 minutes between retries
)
transport = RetryTransport(retry=retry)

with httpx.Client(transport=transport) as client:
    response = client.get("https://unreliable-api.example.com")
```

--------------------------------

### handle_async_request(request)

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/api-reference/retry-transport-class.md

Sends an HTTP request asynchronously, applying retry logic based on the configured policy.

```APIDOC
## handle_async_request(request)

### Description
Send an HTTP request asynchronously, retrying according to the configured retry policy.

### Parameters
- **request** (httpx.Request) - Required - The HTTP request to send

### Returns
- **httpx.Response** - The final response after retries or the original failure response

### Raises
- **RuntimeError** - If async transport is not available
- **Exception** - Any exception from is_retryable_exception if retries are exhausted
```

--------------------------------

### Ignore Retry-After header

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/configuration.md

Set respect_retry_after_header to False to force the client to use the configured backoff strategy exclusively.

```python
from httpx_retries import Retry, RetryTransport
import httpx

retry = Retry(
    total=5,
    respect_retry_after_header=False,
    backoff_factor=0.5
)
transport = RetryTransport(retry=retry)

with httpx.Client(transport=transport) as client:
    response = client.get("https://example.com")
```

--------------------------------

### Request with custom authentication

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/api-reference/retry-request-functions.md

Provide authentication credentials that are forwarded to the underlying client.

```python
import httpx
from httpx_retries import retry_request, Retry

retry = Retry(total=3, backoff_factor=0.5)

with httpx.Client() as client:
    response = retry_request(
        client,
        "GET",
        "https://api.example.com/protected",
        retry=retry,
        auth=("username", "password")  # Forwarded to client.send()
    )
    print(response.status_code)
```

--------------------------------

### Mount Different Retry Strategies per Host

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/api-reference/retry-transport-class.md

Applies distinct RetryTransport configurations to specific hosts using the client's mount mapping.

```python
import httpx
from httpx_retries import Retry, RetryTransport

# Different retry strategies for different hosts
strict_retry = Retry(total=2, backoff_factor=0.1)
lenient_retry = Retry(total=10, backoff_factor=1.0)

with httpx.Client() as client:
    client.mounts["https://critical-api.example.com"] = RetryTransport(retry=strict_retry)
    client.mounts["https://lenient-api.example.com"] = RetryTransport(retry=lenient_retry)
    
    response1 = client.get("https://critical-api.example.com/endpoint")
    response2 = client.get("https://lenient-api.example.com/endpoint")
```

--------------------------------

### Exponential Backoff Formula

Source: https://github.com/will-ockmore/httpx-retries/blob/main/docs/behaviour.md

This formula illustrates the calculation for exponential backoff, where the wait time increases exponentially with each attempt. On the first attempt, the backoff time equals the backoff factor.

```python
backoff_time = backoff_factor * (2 ** attempts_made)
```

--------------------------------

### retry_request(client, method, url, retry=None, **kwargs)

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/api-reference/retry-request-functions.md

Executes a synchronous HTTP request using the provided httpx client, with support for retrying errors that occur during both the header and body phases.

```APIDOC
## retry_request(client, method, url, retry=None, **kwargs)

### Description
Executes a synchronous HTTP request with retry logic. Unlike standard client methods, this function catches and retries errors that occur during the response body download phase.

### Parameters
- **client** (httpx.Client) - Required - The httpx client instance to use for the request.
- **method** (str) - Required - The HTTP method (e.g., "GET", "POST").
- **url** (str) - Required - The target URL.
- **retry** (Retry) - Optional - The retry configuration object.
- **kwargs** (dict) - Optional - Additional arguments passed to the client request method.
```

--------------------------------

### Retry class constructor

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/api-reference/retry-class.md

The constructor defines the retry policy, including limits, backoff parameters, and response validation callbacks.

```python
def __init__(
    self,
    total: int = 10,
    allowed_methods: Iterable[HTTPMethod | str] | None = None,
    status_forcelist: Iterable[HTTPStatus | int] | None = None,
    retry_on_exceptions: Iterable[type[Exception]] | None = None,
    backoff_factor: float = 0.0,
    respect_retry_after_header: bool = True,
    max_backoff_wait: float = 120.0,
    backoff_jitter: float = 1.0,
    attempts_made: int = 0,
    total_timeout: float | None = None,
    elapsed_sleep: float = 0.0,
    validate_response: Callable[[httpx.Response], None | Awaitable[None]] | None = None,
) -> None
```

--------------------------------

### RetryTransport Constructor

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/api-reference/retry-transport-class.md

Initializes a new instance of the RetryTransport class to be used with httpx clients.

```APIDOC
## RetryTransport(transport, retry)

### Description
Initializes the RetryTransport with an optional underlying transport and custom retry configuration.

### Parameters
- **transport** (httpx.BaseTransport | httpx.AsyncBaseTransport | None) - Optional - The underlying transport to wrap. If None, default transports are created.
- **retry** (Retry | None) - Optional - The retry configuration object. Defaults to Retry() if not provided.

### Example
```python
import httpx
from httpx_retries import Retry, RetryTransport

retry = Retry(total=5, backoff_factor=0.5)
transport = RetryTransport(retry=retry)

with httpx.Client(transport=transport) as client:
    response = client.get("https://example.com")
```
```

--------------------------------

### Retry on all HTTP methods

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/configuration.md

Explicitly include methods like POST or PATCH in the allowed_methods list to enable retries for non-idempotent requests.

```python
from httpx_retries import Retry, RetryTransport
import httpx

retry = Retry(
    total=3,
    allowed_methods=["HEAD", "GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "TRACE"],
    backoff_factor=0.5
)
transport = RetryTransport(retry=retry)

with httpx.Client(transport=transport) as client:
    response = client.post("https://api.example.com/submit", json={"data": "value"})
```

--------------------------------

### Retry

Source: https://github.com/will-ockmore/httpx-retries/blob/main/docs/api.md

Configuration class for defining retry behavior.

```APIDOC
## Retry

### Description
Configuration object used to define the parameters and strategies for retrying failed HTTP requests.
```

--------------------------------

### Configure Rate Limiting Retries

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/api-reference/overview.md

Use this configuration when interacting with APIs that enforce rate limits via 429 status codes and Retry-After headers.

```python
from httpx_retries import Retry, RetryTransport
import httpx

retry = Retry(
    total=10,
    status_forcelist=[429, 502, 503, 504],
    backoff_factor=1.0,
    respect_retry_after_header=True  # Critical!
)
with httpx.Client(transport=RetryTransport(retry=retry)) as client:
    response = client.get("https://rate-limited-api.example.com")
```

--------------------------------

### Create Modified Retry Instances

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/api-reference/retry-class.md

Uses copy_with to generate a new Retry instance with specific fields overridden, preserving the original instance's state.

```python
from httpx_retries import Retry

retry = Retry(total=5, backoff_factor=0.5)

# Create a new retry with updated attempts
retry2 = retry.copy_with(attempts_made=1)
print(retry.attempts_made)   # 0
print(retry2.attempts_made)  # 1

# Create a new retry with updated total
retry3 = retry.copy_with(total=3)
print(retry.total)   # 5
print(retry3.total)  # 3
```

--------------------------------

### Define allowed_methods for Retry

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/types.md

Configures which HTTP methods trigger a retry using enums, strings, or a mix of both.

```python
Iterable[HTTPMethod | str]
```

```python
Retry.RETRYABLE_METHODS  # ["HEAD", "GET", "PUT", "DELETE", "OPTIONS", "TRACE"]
```

```python
from httpx_retries import Retry
from http import HTTPMethod

# Using HTTPMethod enum
retry1 = Retry(allowed_methods=[HTTPMethod.GET, HTTPMethod.HEAD])

# Using strings
retry2 = Retry(allowed_methods=["get", "head", "put"])

# Mixed
retry3 = Retry(allowed_methods=[HTTPMethod.GET, "post"])
```

--------------------------------

### Import aretry_request Function

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/api-reference/overview.md

Import the asynchronous counterpart for request retries.

```python
from httpx_retries import aretry_request
```

--------------------------------

### RetryTransport Constructor Signature

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/api-reference/retry-transport-class.md

The constructor accepts an optional underlying transport and a retry configuration object.

```python
def __init__(
    self,
    transport: httpx.BaseTransport | httpx.AsyncBaseTransport | None = None,
    retry: Retry | None = None,
) -> None
```

--------------------------------

### Implement Async Validation Callback

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/configuration.md

Use an asynchronous validation function when working with httpx.AsyncClient.

```python
from httpx_retries import Retry, RetryTransport
import httpx
import asyncio

async def validate_response_async(response: httpx.Response) -> None:
    # Simulate async validation (e.g., calling a validation service)
    await asyncio.sleep(0.1)
    
    if response.status_code != 200:
        raise ValueError(f"Unexpected status {response.status_code}")

retry = Retry(total=3, validate_response=validate_response_async)
transport = RetryTransport(retry=retry)

async def main():
    async with httpx.AsyncClient(transport=transport) as client:
        response = await client.get("https://api.example.com/data")

asyncio.run(main())
```

--------------------------------

### Configure individual sleep cap

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/configuration.md

Set max_backoff_wait to limit the duration of each individual retry sleep interval without a cumulative cap.

```python
from httpx_retries import Retry, RetryTransport
import httpx

retry = Retry(
    total=10,
    backoff_factor=2.0,
    max_backoff_wait=30.0,  # Each sleep capped at 30 seconds
    total_timeout=None  # No cumulative cap
)
transport = RetryTransport(retry=retry)

with httpx.Client(transport=transport) as client:
    response = client.get("https://example.com")
```

--------------------------------

### Define status_forcelist for Retry

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/types.md

Configures which HTTP status codes trigger a retry using enums or integers.

```python
Iterable[HTTPStatus | int]
```

```python
Retry.RETRYABLE_STATUS_CODES  # [429, 502, 503, 504]
```

```python
from httpx_retries import Retry
from http import HTTPStatus

# Using HTTPStatus enum
retry1 = Retry(status_forcelist=[HTTPStatus.TOO_MANY_REQUESTS, HTTPStatus.SERVICE_UNAVAILABLE])

# Using integers
retry2 = Retry(status_forcelist=[429, 502, 503, 504])

# Mixed
retry3 = Retry(status_forcelist=[HTTPStatus.TOO_MANY_REQUESTS, 502, 503])
```

--------------------------------

### Handle Body-Phase Errors

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/api-reference/overview.md

Uses retry_request for manual control over request retries.

```python
import httpx
from httpx_retries import retry_request, Retry

with httpx.Client() as client:
    retry = Retry(total=3, backoff_factor=1.0)
    response = retry_request(client, "GET", "https://example.com/large-file", retry=retry)
```

--------------------------------

### Retry body-phase errors with synchronous client

Source: https://github.com/will-ockmore/httpx-retries/blob/main/docs/faq.md

Use retry_request to handle retries at the client level, covering both header-phase and body-phase errors.

```python
import httpx
from httpx_retries import Retry, retry_request

with httpx.Client() as client:
    response = retry_request(client, "GET", "https://example.com", retry=Retry(total=5, backoff_factor=0.5))
```

--------------------------------

### Retry Body-Phase Errors (Sync)

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/INDEX.md

Uses the retry_request helper function to handle errors during the request body phase synchronously.

```python
import httpx
from httpx_retries import retry_request, Retry

with httpx.Client() as client:
    retry = Retry(total=3, backoff_factor=1.0)
    response = retry_request(client, "GET", "https://example.com/file", retry=retry)
```

--------------------------------

### Retry on timeout during download

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/api-reference/retry-request-functions.md

Configure a custom Retry object to handle ReadTimeout errors during large file downloads.

```python
import httpx
from httpx_retries import retry_request, Retry

retry = Retry(
    total=3,
    backoff_factor=1.0,
    status_forcelist=[429, 502, 503, 504]
)

with httpx.Client(timeout=5.0) as client:
    # If ReadTimeout occurs during body download, will retry up to 3 times
    response = retry_request(
        client,
        "GET",
        "https://example.com/large-file.zip",
        retry=retry
    )
    
    # Body is fully buffered and available
    file_size = len(response.content)
    print(f"Downloaded {file_size} bytes")
```

--------------------------------

### Define retry_on_exceptions for Retry

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/types.md

Configures which exception types trigger a retry, matching subclasses via isinstance().

```python
Iterable[type[Exception]]
```

```python
Retry.RETRYABLE_EXCEPTIONS  # (httpx.TimeoutException, httpx.NetworkError, httpx.RemoteProtocolError)
```

```python
import httpx
from httpx_retries import Retry, RetryTransport

# Retry only on timeout and network errors
retry = Retry(retry_on_exceptions=[httpx.TimeoutException, httpx.NetworkError])
transport = RetryTransport(retry=retry)

# Custom exception
class CustomNetworkError(httpx.NetworkError):
    pass

retry2 = Retry(retry_on_exceptions=[httpx.TimeoutException, CustomNetworkError])
```

--------------------------------

### Wrap Custom Transport with Retry

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/api-reference/retry-transport-class.md

Integrates retry capabilities into an existing custom transport, such as one configured for mTLS or proxies.

```python
import httpx
from httpx_retries import Retry, RetryTransport

# Create a custom transport (e.g., with mTLS or proxy)
base_transport = httpx.HTTPTransport(
    cert=("client.crt", "client.key"),
    verify="ca.crt"
)

# Wrap it with retry capability
retry_transport = RetryTransport(
    transport=base_transport,
    retry=Retry(total=3, backoff_factor=1.0)
)

with httpx.Client(transport=retry_transport) as client:
    response = client.get("https://secure-api.example.com")
```

--------------------------------

### response.extensions["retry"]

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/types.md

Access the Retry object from a response to inspect the number of attempts made and the total sleep time elapsed during retries.

```APIDOC
## Response Extension: retry

### Description
The `Retry` object that was used for the final attempt on this response. Available on all responses sent through `RetryTransport` or via `retry_request`/`aretry_request` helpers.

### Properties
- **attempts_made** (int) - Number of retry attempts that were made
- **elapsed_sleep** (float) - Total sleep time across all retries

### Usage Example
```python
import httpx
from httpx_retries import Retry, RetryTransport

retry = Retry(total=5, backoff_factor=0.5)
transport = RetryTransport(retry=retry)

with httpx.Client(transport=transport) as client:
    response = client.get("https://example.com")
    
    if "retry" in response.extensions:
        retry_state = response.extensions["retry"]
        print(f"Attempts: {retry_state.attempts_made}")
        print(f"Total sleep: {retry_state.elapsed_sleep}s")
```
```

--------------------------------

### Accessing Retry Extension

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/types.md

Access the retry metadata stored in response extensions.

```python
response.extensions["retry"]: Retry
```

--------------------------------

### backoff_strategy()

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/api-reference/retry-class.md

Calculates the backoff duration in seconds based on the current attempt count. This method can be overridden to implement custom backoff logic.

```APIDOC
## backoff_strategy()

### Description
Calculates the backoff time based on the current attempt count. Override this method to implement custom backoff behavior.

### Returns
- **float**: Calculated backoff time in seconds, capped by max_backoff_wait.
```

--------------------------------

### Configure Conservative Retries

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/configuration.md

Limit retry attempts and backoff duration for critical operations to minimize latency.

```python
from httpx_retries import Retry, RetryTransport
import httpx

retry = Retry(
    total=2,  # Only 2 retries
    backoff_factor=0.1,  # Quick backoff
    max_backoff_wait=1.0  # At most 1 second between retries
)
transport = RetryTransport(retry=retry)

with httpx.Client(transport=transport) as client:
    response = client.get("https://critical-api.example.com")
```

--------------------------------

### close()

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/api-reference/retry-transport-class.md

Closes the synchronous underlying transport to release resources.

```APIDOC
## close()

### Description
Closes the synchronous underlying transport. Call this to release resources when done with the transport.

### Signature
`def close(self) -> None`
```

--------------------------------

### Define HTTPStatus Enum

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/types.md

Integer subclass enumeration for HTTP status codes, sourced from the standard library.

```python
class HTTPStatus(int, Enum):
    TOO_MANY_REQUESTS = 429
    BAD_GATEWAY = 502
    SERVICE_UNAVAILABLE = 503
    GATEWAY_TIMEOUT = 504
    # ... and other HTTP status codes
```

--------------------------------

### Execute Asynchronous Request with Retries

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/api-reference/retry-transport-class.md

Sends an asynchronous HTTP request using a configured RetryTransport within an async context.

```python
import httpx
from httpx_retries import Retry, RetryTransport
import asyncio

async def main():
    retry = Retry(total=3, backoff_factor=0.5)
    transport = RetryTransport(retry=retry)
    
    async with httpx.AsyncClient(transport=transport) as client:
        response = await client.get("https://example.com")
        
        if "retry" in response.extensions:
            print(f"Attempts made: {response.extensions['retry'].attempts_made}")

asyncio.run(main())
```

--------------------------------

### Fixing retry_request double retry errors

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/errors.md

Demonstrates the incorrect usage of RetryTransport with retry_request and the two correct alternatives.

```python
import httpx
from httpx_retries import retry_request, RetryTransport, Retry

# Incorrect: double retry
transport = RetryTransport()
with httpx.Client(transport=transport) as client:
    response = retry_request(client, "GET", "https://example.com")  # ERROR!

# Correct: Use retry_request with plain client
with httpx.Client() as client:
    response = retry_request(client, "GET", "https://example.com")

# OR: Use RetryTransport with plain client
transport = RetryTransport()
with httpx.Client(transport=transport) as client:
    response = client.get("https://example.com")
```

--------------------------------

### aclose()

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/api-reference/retry-transport-class.md

Asynchronously closes the async underlying transport to release resources.

```APIDOC
## aclose()

### Description
Asynchronously close the async underlying transport. Call this to release resources when done with the transport.

### Signature
`async def aclose(self) -> None`
```

--------------------------------

### ValueError: retry_request configuration check

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/errors.md

Internal condition check that prevents using retry_request with a client already configured for retries.

```python
if _client_retries(client):
    raise ValueError(
        "retry_request runs the retry loop itself and must be used with a client that does not also retry. "
        "The given client uses RetryTransport, which would retry every request twice. Use a plain "
        "httpx.Client instead; retry_request already retries header-phase errors and retryable status codes."
    )
```

--------------------------------

### Define HTTPMethod Enum

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/types.md

String subclass enumeration for HTTP methods, used for compatibility across Python versions.

```python
class HTTPMethod(str, Enum):
    HEAD = "HEAD"
    GET = "GET"
    POST = "POST"
    PUT = "PUT"
    DELETE = "DELETE"
    OPTIONS = "OPTIONS"
    TRACE = "TRACE"
    PATCH = "PATCH"
    CONNECT = "CONNECT"
```

--------------------------------

### Execute Synchronous retry_request

Source: https://github.com/will-ockmore/httpx-retries/blob/main/_autodocs/api-reference/overview.md

Use this function to retry requests, particularly useful for catching body-phase errors like ReadTimeout.

```python
import httpx
from httpx_retries import retry_request

with httpx.Client() as client:
    response = retry_request(client, "GET", "https://example.com")
```
Tokens:
Raw