Python Resilience

by wshobson46891e7e60daNo licenseListed Oct 8, 2026Updated Oct 8, 2026

Python resilience patterns including automatic retries, exponential backoff, timeouts, and fault-tolerant decorators. Use when adding retry logic, implementing timeouts, building fault-tolerant services, or handling transient failures.

Instructions onlySoftware Development

AI-generated overview

Guides Python developers in adding retries, exponential backoff, jitter, timeouts and fault-tolerant decorators to unreliable calls.

What it does: This skill provides Python resilience patterns for handling transient failures, network issues and service outages. It explains transient versus permanent failures, exponential backoff, jitter and bounded retries, and shows worked examples using the tenacity library with httpx, including retrying on exceptions, HTTP status codes, or both. It also lists best practices such as capping total duration, logging retries and setting timeouts everywhere.
When to use it: Use it when adding retry logic to external service calls, implementing timeouts for network operations, or building fault-tolerant services and microservices. It also fits handling rate limiting, backpressure and circuit-breaker design.
Requirements: Instructions only; no scripts are shipped. Examples assume Python with the tenacity and httpx packages, and network access for the HTTP calls shown. A bundled references/details.md file holds advanced patterns.

Python Resilience Patterns

Build fault-tolerant Python applications that gracefully handle transient failures, network issues, and service outages. Resilience patterns keep systems running when dependencies are unreliable.

When to Use This Skill

Adding retry logic to external service calls
Implementing timeouts for network operations
Building fault-tolerant microservices
Handling rate limiting and backpressure
Creating infrastructure decorators
Designing circuit breakers

Core Concepts

1. Transient vs Permanent Failures

Retry transient errors (network timeouts, temporary service issues). Don't retry permanent errors (invalid credentials, bad requests).

2. Exponential Backoff

Increase wait time between retries to avoid overwhelming recovering services.

3. Jitter

Add randomness to backoff to prevent thundering herd when many clients retry simultaneously.

4. Bounded Retries

Cap both attempt count and total duration to prevent infinite retry loops.

Quick Start

python

from tenacity import retry, stop_after_attempt, wait_exponential_jitter
@retry(    stop=stop_after_attempt(3),    wait=wait_exponential_jitter(initial=1, max=10),)def call_external_service(request: dict) -> dict:    return httpx.post("https://api.example.com", json=request).json()

from tenacity import retry, stop_after_attempt, wait_exponential_jitter
@retry(    stop=stop_after_attempt(3),    wait=wait_exponential_jitter(initial=1, max=10),)def call_external_service(request: dict) -> dict:    return httpx.post("https://api.example.com", json=request).json()

Fundamental Patterns

Pattern 1: Basic Retry with Tenacity

Use the tenacity library for production-grade retry logic. For simpler cases, consider built-in retry functionality or a lightweight custom implementation.

python

from tenacity import (    retry,    stop_after_attempt,    stop_after_delay,    wait_exponential_jitter,    retry_if_exception_type,)
TRANSIENT_ERRORS = (ConnectionError, TimeoutError, OSError)
@retry(    retry=retry_if_exception_type(TRANSIENT_ERRORS),    stop=stop_after_attempt(5) | stop_after_delay(60),    wait=wait_exponential_jitter(initial=1, max=30),)def fetch_data(url: str) -> dict:    """Fetch data with automatic retry on transient failures."""    response = httpx.get(url, timeout=30)    response.raise_for_status()    return response.json()

from tenacity import (    retry,    stop_after_attempt,    stop_after_delay,    wait_exponential_jitter,    retry_if_exception_type,)
TRANSIENT_ERRORS = (ConnectionError, TimeoutError, OSError)
@retry(    retry=retry_if_exception_type(TRANSIENT_ERRORS),    stop=stop_after_attempt(5) | stop_after_delay(60),    wait=wait_exponential_jitter(initial=1, max=30),)def fetch_data(url: str) -> dict:    """Fetch data with automatic retry on transient failures."""    response = httpx.get(url, timeout=30)    response.raise_for_status()    return response.json()

Pattern 2: Retry Only Appropriate Errors

Whitelist specific transient exceptions. Never retry:

ValueError, TypeError - These are bugs, not transient issues
AuthenticationError - Invalid credentials won't become valid
HTTP 4xx errors (except 429) - Client errors are permanent

python

from tenacity import retry, retry_if_exception_typeimport httpx
# Define what's retryableRETRYABLE_EXCEPTIONS = (    ConnectionError,    TimeoutError,    httpx.ConnectTimeout,    httpx.ReadTimeout,)
@retry(    retry=retry_if_exception_type(RETRYABLE_EXCEPTIONS),    stop=stop_after_attempt(3),    wait=wait_exponential_jitter(initial=1, max=10),)def resilient_api_call(endpoint: str) -> dict:    """Make API call with retry on network issues."""    return httpx.get(endpoint, timeout=10).json()

from tenacity import retry, retry_if_exception_typeimport httpx
# Define what's retryableRETRYABLE_EXCEPTIONS = (    ConnectionError,    TimeoutError,    httpx.ConnectTimeout,    httpx.ReadTimeout,)
@retry(    retry=retry_if_exception_type(RETRYABLE_EXCEPTIONS),    stop=stop_after_attempt(3),    wait=wait_exponential_jitter(initial=1, max=10),)def resilient_api_call(endpoint: str) -> dict:    """Make API call with retry on network issues."""    return httpx.get(endpoint, timeout=10).json()

Pattern 3: HTTP Status Code Retries

Retry specific HTTP status codes that indicate transient issues.

python

from tenacity import retry, retry_if_result, stop_after_attemptimport httpx
RETRY_STATUS_CODES = {429, 502, 503, 504}
def should_retry_response(response: httpx.Response) -> bool:    """Check if response indicates a retryable error."""    return response.status_code in RETRY_STATUS_CODES
@retry(    retry=retry_if_result(should_retry_response),    stop=stop_after_attempt(3),    wait=wait_exponential_jitter(initial=1, max=10),)def http_request(method: str, url: str, **kwargs) -> httpx.Response:    """Make HTTP request with retry on transient status codes."""    return httpx.request(method, url, timeout=30, **kwargs)

from tenacity import retry, retry_if_result, stop_after_attemptimport httpx
RETRY_STATUS_CODES = {429, 502, 503, 504}
def should_retry_response(response: httpx.Response) -> bool:    """Check if response indicates a retryable error."""    return response.status_code in RETRY_STATUS_CODES
@retry(    retry=retry_if_result(should_retry_response),    stop=stop_after_attempt(3),    wait=wait_exponential_jitter(initial=1, max=10),)def http_request(method: str, url: str, **kwargs) -> httpx.Response:    """Make HTTP request with retry on transient status codes."""    return httpx.request(method, url, timeout=30, **kwargs)

Pattern 4: Combined Exception and Status Retry

Handle both network exceptions and HTTP status codes.

python

from tenacity import (    retry,    retry_if_exception_type,    retry_if_result,    stop_after_attempt,    wait_exponential_jitter,    before_sleep_log,)import loggingimport httpx
logger = logging.getLogger(__name__)
TRANSIENT_EXCEPTIONS = (    ConnectionError,    TimeoutError,    httpx.ConnectError,    httpx.ReadTimeout,)RETRY_STATUS_CODES = {429, 500, 502, 503, 504}
def is_retryable_response(response: httpx.Response) -> bool:    return response.status_code in RETRY_STATUS_CODES
@retry(    retry=(        retry_if_exception_type(TRANSIENT_EXCEPTIONS) |        retry_if_result(is_retryable_response)    ),    stop=stop_after_attempt(5),    wait=wait_exponential_jitter(initial=1, max=30),    before_sleep=before_sleep_log(logger, logging.WARNING),)def robust_http_call(    method: str,    url: str,    **kwargs,) -> httpx.Response:    """HTTP call with comprehensive retry handling."""    return httpx.request(method, url, timeout=30, **kwargs)

from tenacity import (    retry,    retry_if_exception_type,    retry_if_result,    stop_after_attempt,    wait_exponential_jitter,    before_sleep_log,)import loggingimport httpx
logger = logging.getLogger(__name__)
TRANSIENT_EXCEPTIONS = (    ConnectionError,    TimeoutError,    httpx.ConnectError,    httpx.ReadTimeout,)RETRY_STATUS_CODES = {429, 500, 502, 503, 504}
def is_retryable_response(response: httpx.Response) -> bool:    return response.status_code in RETRY_STATUS_CODES
@retry(    retry=(        retry_if_exception_type(TRANSIENT_EXCEPTIONS) |        retry_if_result(is_retryable_response)    ),    stop=stop_after_attempt(5),    wait=wait_exponential_jitter(initial=1, max=30),    before_sleep=before_sleep_log(logger, logging.WARNING),)def robust_http_call(    method: str,    url: str,    **kwargs,) -> httpx.Response:    """HTTP call with comprehensive retry handling."""    return httpx.request(method, url, timeout=30, **kwargs)

Detailed worked examples and patterns

Detailed sections (starting with ## Advanced Patterns) live in references/details.md. Read that file when the navigation summary above is insufficient.

Best Practices Summary

Retry only transient errors - Don't retry bugs or authentication failures
Use exponential backoff - Give services time to recover
Add jitter - Prevent thundering herd from synchronized retries
Cap total duration - stop_after_attempt(5) | stop_after_delay(60)
Log every retry - Silent retries hide systemic problems
Use decorators - Keep retry logic separate from business logic
Inject dependencies - Make infrastructure testable
Set timeouts everywhere - Every network call needs a timeout
Fail gracefully - Return cached/default values for non-critical paths
Monitor retry rates - High retry rates indicate underlying issues

Source and attribution

Source:wshobson/agentsinplugins/python-development/skills/python-resilienceat commit46891e7

License: No license

Content belongs to its original authors. SourceWeft indexes it from a public repository.

Report or request removal

Python Resilience

Python Resilience Patterns

When to Use This Skill

Core Concepts

1. Transient vs Permanent Failures

2. Exponential Backoff

3. Jitter

4. Bounded Retries

Quick Start

Fundamental Patterns

Pattern 1: Basic Retry with Tenacity

Pattern 2: Retry Only Appropriate Errors

Pattern 3: HTTP Status Code Retries

Pattern 4: Combined Exception and Status Retry

Detailed worked examples and patterns

Best Practices Summary

Source and attribution

More from wshobson/agents

Uv Package Manager

Web Component Design

Python Type Safety

Visual Design Foundations

Responsive Design

Python Resource Management

More in Software Development

Playground

M5 Onboard

Cardputer Buddy

Dev

Dpop Adoption

Web Design Guidelines