AutoGineer
Generated banner for Python Resilience
Generated logo for Python Resilience

Python Resilience

Seth HobsonCommunityCreated by Seth Hobson

  • Skill
  • Guidelines
  • Software development
  • MIT
  • No issues found
Download ZIP

From the author

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.
— the description by Seth Hobson

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

This skill provides a comprehensive guide to building fault-tolerant Python applications. It focuses on handling transient failures in network operations and external service calls through established patterns like exponential backoff, jitter, and bounded retries. By leveraging decorators, developers can cleanly separate infrastructure concerns from core business logic, ensuring systems remain stable and responsive even when dependencies are unreliable.

What it does

  • Defines patterns for automatic retries on transient network and HTTP errors.
  • Implements exponential backoff and jitter to prevent service overloading.
  • Provides decorators for consistent timeout management in synchronous and asynchronous code.
  • Demonstrates how to stack decorators for cross-cutting concerns like tracing and resilience.
  • Offers guidance on distinguishing between transient and permanent failures.
  • Shows how to inject infrastructure dependencies to improve testability.

When to use it

  • When integrating with external APIs or microservices that may experience downtime.
  • When you need to implement reliable network communication in Python.
  • When building services that require consistent error handling and logging strategies.
  • When you want to decouple infrastructure logic from your main application code.

Advantages

  • Reduces boilerplate code by using reusable decorators.
  • Improves system stability by preventing cascading failures.
  • Enhances observability through structured logging of retry attempts.
  • Promotes testable code through dependency injection patterns.

Usage examples

“How do I add a retry mechanism to an API call that handles network timeouts?”
The agent provides a decorator-based solution using the tenacity library, configuring it to catch specific transient exceptions like ConnectTimeout with exponential backoff.
“Can you show me how to stack a timeout and a retry decorator on an async function?”
The agent demonstrates how to wrap an async function with both a custom timeout decorator and a tenacity retry decorator to ensure robust execution.

Install

  1. Download the skill as a ZIP:

    https://autogineer.com/agent-skills/wshobson/python-resilience/download

  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip python-resilience.zip -d .agents/skills

Documentation by Seth Hobson

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

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.

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

from tenacity import retry, retry_if_exception_type
import httpx

# Define what's retryable
RETRYABLE_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.

from tenacity import retry, retry_if_result, stop_after_attempt
import 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.

from tenacity import (
    retry,
    retry_if_exception_type,
    retry_if_result,
    stop_after_attempt,
    wait_exponential_jitter,
    before_sleep_log,
)
import logging
import 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

  1. Retry only transient errors - Don't retry bugs or authentication failures

  2. Use exponential backoff - Give services time to recover

  3. Add jitter - Prevent thundering herd from synchronized retries

  4. Cap total duration - stop_after_attempt(5) | stop_after_delay(60)

  5. Log every retry - Silent retries hide systemic problems

  6. Use decorators - Keep retry logic separate from business logic

  7. Inject dependencies - Make infrastructure testable

  8. Set timeouts everywhere - Every network call needs a timeout

  9. Fail gracefully - Return cached/default values for non-critical paths

  10. Monitor retry rates - High retry rates indicate underlying issues

Files

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs Python

Security

No issues found by our static scan· No issues found

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by
Seth Hobson
Publisher
Seth Hobson (Community)
Source
wshobson/agents · plugins/python-development/skills/python-resilience · commit 4bde316
Licence
MIT License (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by Seth Hobson or Seth Hobson.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download python-resilience.zip