AWS & Infrastructure Entities¶

class RetrainingStatus(str, Enum):
    """Status of a retraining workflow execution.

    Tracks the lifecycle from trigger to completion.
    """

    PENDING = "pending"  # Waiting to start
    CHECKING = "checking"  # Evaluating if retraining needed
    TRAINING = "training"  # Training task running
    VALIDATING = "validating"  # Validation backtest running
    COMPARING = "comparing"  # Comparing champion vs challenger
    PROMOTING = "promoting"  # Promoting new model
    COMPLETED = "completed"  # Successfully completed
    FAILED = "failed"  # Workflow failed
    SKIPPED = "skipped"  # Retraining not needed

class ResilienceConfig(BaseModel):
    """Unified configuration for retry and circuit breaker.

    Combines both retry and circuit breaker settings into a single
    configuration object with sensible presets for common use cases.

    Attributes:
        max_retries: Maximum retry attempts (0 to disable retries)
        retry_delay: Initial delay between retries in seconds
        retry_backoff: Multiplier for exponential backoff
        max_retry_delay: Maximum delay cap in seconds
        retriable_exceptions: Exception types that trigger retries
        circuit_threshold: Failures before circuit opens (0 to disable)
        circuit_timeout: Seconds before circuit transitions to HALF_OPEN
        circuit_success_threshold: Successes needed in HALF_OPEN to close

    Example:
        >>> # Default config
        >>> config = ResilienceConfig()
        >>>
        >>> # HTTP preset with aggressive retries
        >>> config = ResilienceConfig.for_http()
        >>>
        >>> # Database preset with conservative settings
        >>> config = ResilienceConfig.for_database()
    """

    model_config = ConfigDict(frozen=True, arbitrary_types_allowed=True)

    # Retry settings
    max_retries: int = 3
    retry_delay: float = 1.0
    retry_backoff: float = 2.0
    max_retry_delay: float = 30.0
    retriable_exceptions: tuple[type[Exception], ...] = (ExternalServiceError,)

    # Circuit breaker settings
    circuit_threshold: int = 5
    circuit_timeout: float = 60.0
    circuit_success_threshold: int = 1

    @classmethod
    def for_http(cls) -> ResilienceConfig:
        """Preset for HTTP/API calls.

        Aggressive retries with shorter delays, suitable for
        transient network failures.

        Returns:
            ResilienceConfig tuned for HTTP calls
        """
        return cls(
            max_retries=3,
            retry_delay=0.5,
            retry_backoff=2.0,
            max_retry_delay=10.0,
            retriable_exceptions=(ExternalServiceError, ConnectionError, TimeoutError),
            circuit_threshold=5,
            circuit_timeout=30.0,
            circuit_success_threshold=2,
        )

    @classmethod
    def for_database(cls) -> ResilienceConfig:
        """Preset for database operations.

        More conservative settings with longer delays to avoid
        overwhelming the database during recovery.

        Returns:
            ResilienceConfig tuned for database operations
        """
        return cls(
            max_retries=3,
            retry_delay=2.0,
            retry_backoff=2.0,
            max_retry_delay=30.0,
            retriable_exceptions=(ExternalServiceError, ConnectionError),
            circuit_threshold=3,
            circuit_timeout=60.0,
            circuit_success_threshold=1,
        )

    @classmethod
    def for_external_api(cls) -> ResilienceConfig:
        """Preset for external third-party APIs.

        Balanced settings with moderate retries and circuit breaker
        to protect against unreliable external services.

        Returns:
            ResilienceConfig tuned for external APIs
        """
        return cls(
            max_retries=2,
            retry_delay=1.0,
            retry_backoff=3.0,
            max_retry_delay=15.0,
            retriable_exceptions=(ExternalServiceError, ConnectionError, TimeoutError),
            circuit_threshold=3,
            circuit_timeout=45.0,
            circuit_success_threshold=2,
        )

    @classmethod
    def retry_only(cls, max_retries: int = 3) -> ResilienceConfig:
        """Preset with retries but no circuit breaker.

        Args:
            max_retries: Maximum retry attempts

        Returns:
            ResilienceConfig with circuit breaker disabled
        """
        return cls(
            max_retries=max_retries,
            circuit_threshold=0,  # Disable circuit breaker
        )

    @classmethod
    def circuit_breaker_only(cls, threshold: int = 5) -> ResilienceConfig:
        """Preset with circuit breaker but no retries.

        Args:
            threshold: Failures before circuit opens

        Returns:
            ResilienceConfig with retries disabled
        """
        return cls(
            max_retries=0,  # Disable retries
            circuit_threshold=threshold,
        )