provide-foundation 0.0.0.dev1__py3-none-any.whl → 0.0.0.dev2__py3-none-any.whl

provide/foundation/errors/decorators.py

@@ -7,13 +7,9 @@ fallback, and error suppression.
 from collections.abc import Callable
 import functools
 import inspect
-import time
 from typing import Any, TypeVar
 
-from attrs import define, field
-
 from provide.foundation.errors.base import FoundationError
-from provide.foundation.errors.types import RetryPolicy
 
 F = TypeVar("F", bound=Callable[..., Any])
 
@@ -148,125 +144,6 @@ def with_error_handling(
         return decorator(func)
 
 
-def retry_on_error(
-    *exceptions: type[Exception],
-    policy: RetryPolicy | None = None,
-    max_attempts: int | None = None,
-    delay: float | None = None,
-    backoff: float | None = None,
-    on_retry: Callable[[int, Exception], None] | None = None,
-) -> Callable[[F], F]:
-    """Decorator for retrying operations on specific errors.
-
-    Args:
-        *exceptions: Exception types to retry on (all if empty).
-        policy: Complete retry policy (overrides other retry params).
-        max_attempts: Maximum retry attempts (ignored if policy provided).
-        delay: Base delay between retries in seconds.
-        backoff: Backoff multiplier for delays.
-        on_retry: Callback function called before each retry.
-
-    Returns:
-        Decorated function.
-
-    Examples:
-        >>> @retry_on_error(ConnectionError, TimeoutError, max_attempts=3)
-        ... def fetch_data():
-        ...     return api_call()
-
-        >>> @retry_on_error(
-        ...     policy=RetryPolicy(max_attempts=5, backoff="exponential")
-        ... )
-        ... def unreliable_operation():
-        ...     pass
-    """
-    # Use provided policy or create one from parameters
-    if policy is None:
-        from provide.foundation.errors.types import BackoffStrategy
-
-        # Determine backoff strategy
-        if backoff is not None and backoff > 1:
-            backoff_strategy = BackoffStrategy.EXPONENTIAL
-        elif backoff == 1:
-            backoff_strategy = BackoffStrategy.FIXED
-        else:
-            backoff_strategy = BackoffStrategy.EXPONENTIAL
-
-        policy = RetryPolicy(
-            max_attempts=max_attempts or 3,
-            base_delay=delay or 1.0,
-            backoff=backoff_strategy,
-            retryable_errors=exceptions if exceptions else None,
-        )
-
-    def decorator(func: F) -> F:
-        @functools.wraps(func)
-        def wrapper(*args, **kwargs):
-            last_exception = None
-
-            for attempt in range(1, policy.max_attempts + 1):
-                try:
-                    return func(*args, **kwargs)
-                except Exception as e:
-                    last_exception = e
-
-                    # Check if we should retry this error
-                    if not policy.should_retry(e, attempt):
-                        if attempt > 1:  # Only log if we've actually retried
-                            _get_logger().error(
-                                f"All {attempt} retry attempts failed for {func.__name__}",
-                                attempts=attempt,
-                                error=str(e),
-                                error_type=type(e).__name__,
-                            )
-                        raise
-
-                    # Don't retry on last attempt
-                    if attempt >= policy.max_attempts:
-                        _get_logger().error(
-                            f"All {policy.max_attempts} retry attempts failed for {func.__name__}",
-                            attempts=policy.max_attempts,
-                            error=str(e),
-                            error_type=type(e).__name__,
-                        )
-                        raise
-
-                    # Calculate delay
-                    retry_delay = policy.calculate_delay(attempt)
-
-                    # Log retry attempt
-                    _get_logger().warning(
-                        f"Retry {attempt}/{policy.max_attempts} for {func.__name__} after {retry_delay:.2f}s",
-                        function=func.__name__,
-                        attempt=attempt,
-                        max_attempts=policy.max_attempts,
-                        delay=retry_delay,
-                        error=str(e),
-                        error_type=type(e).__name__,
-                    )
-
-                    # Call retry callback if provided
-                    if on_retry:
-                        try:
-                            on_retry(attempt, e)
-                        except Exception as callback_error:
-                            _get_logger().warning(
-                                f"Retry callback failed: {callback_error}",
-                                function=func.__name__,
-                                attempt=attempt,
-                            )
-
-                    # Wait before retry
-                    time.sleep(retry_delay)
-
-            # Should never reach here, but just in case
-            if last_exception:
-                raise last_exception
-
-        return wrapper  # type: ignore
-
-    return decorator
-
 
 def suppress_and_log(
     *exceptions: type[Exception],
@@ -374,111 +251,3 @@ def fallback_on_error(
     return decorator
 
 
-@define(kw_only=True, slots=True)
-class CircuitBreaker:
-    """Circuit breaker pattern for preventing cascading failures.
-
-    Attributes:
-        failure_threshold: Number of failures before opening circuit.
-        recovery_timeout: Seconds to wait before attempting recovery.
-        expected_exception: Exception types that trigger the breaker.
-    """
-
-    failure_threshold: int = 5
-    recovery_timeout: float = 60.0
-    expected_exception: tuple[type[Exception], ...] = field(default=(Exception,))
-
-    # Internal state
-    _failure_count: int = field(init=False, default=0)
-    _last_failure_time: float | None = field(init=False, default=None)
-    _state: str = field(init=False, default="closed")  # closed, open, half_open
-
-    def __call__(self, func: F) -> F:
-        """Decorator to apply circuit breaker to a function."""
-
-        @functools.wraps(func)
-        def wrapper(*args, **kwargs):
-            # Check circuit state
-            if self._state == "open":
-                # Check if we should try half-open
-                if (
-                    self._last_failure_time
-                    and (time.time() - self._last_failure_time) > self.recovery_timeout
-                ):
-                    self._state = "half_open"
-                    _get_logger().info(
-                        f"Circuit breaker for {func.__name__} entering half-open state",
-                        function=func.__name__,
-                    )
-                else:
-                    raise RuntimeError(f"Circuit breaker is open for {func.__name__}")
-
-            try:
-                result = func(*args, **kwargs)
-
-                # Success - reset on half-open or reduce failure count
-                if self._state == "half_open":
-                    self._state = "closed"
-                    self._failure_count = 0
-                    _get_logger().info(
-                        f"Circuit breaker for {func.__name__} closed after successful recovery",
-                        function=func.__name__,
-                    )
-                elif self._failure_count > 0:
-                    self._failure_count = max(0, self._failure_count - 1)
-
-                return result
-
-            except self.expected_exception as e:
-                self._failure_count += 1
-                self._last_failure_time = time.time()
-
-                # Check if we should open the circuit
-                if self._failure_count >= self.failure_threshold:
-                    self._state = "open"
-                    _get_logger().error(
-                        f"Circuit breaker for {func.__name__} opened after {self._failure_count} failures",
-                        function=func.__name__,
-                        failures=self._failure_count,
-                        error=str(e),
-                    )
-                else:
-                    _get_logger().warning(
-                        f"Circuit breaker for {func.__name__} failure {self._failure_count}/{self.failure_threshold}",
-                        function=func.__name__,
-                        failures=self._failure_count,
-                        threshold=self.failure_threshold,
-                        error=str(e),
-                    )
-
-                raise
-
-        return wrapper  # type: ignore
-
-
-def circuit_breaker(
-    failure_threshold: int = 5,
-    recovery_timeout: float = 60.0,
-    expected_exception: tuple[type[Exception], ...] = (Exception,),
-) -> Callable[[F], F]:
-    """Create a circuit breaker decorator.
-
-    Args:
-        failure_threshold: Number of failures before opening circuit.
-        recovery_timeout: Seconds to wait before attempting recovery.
-        expected_exception: Exception types that trigger the breaker.
-
-    Returns:
-        Circuit breaker decorator.
-
-    Examples:
-        >>> @circuit_breaker(failure_threshold=3, recovery_timeout=30)
-        ... def unreliable_service():
-        ...     return external_api_call()
-    """
-    breaker = CircuitBreaker(
-        failure_threshold=failure_threshold,
-        recovery_timeout=recovery_timeout,
-        expected_exception=expected_exception,
-    )
-    return breaker

provide/foundation/errors/types.py

@@ -118,103 +118,6 @@ class ErrorMetadata:
         return result
 
 
-class BackoffStrategy(str, Enum):
-    """Backoff strategies for retry policies."""
-
-    FIXED = "fixed"  # Fixed delay between retries
-    LINEAR = "linear"  # Linear increase (delay * attempt)
-    EXPONENTIAL = "exponential"  # Exponential increase (delay * 2^attempt)
-    FIBONACCI = "fibonacci"  # Fibonacci sequence delays
-
-
-@define(kw_only=True, slots=True)
-class RetryPolicy:
-    """Configuration for retry behavior on errors.
-
-    Attributes:
-        max_attempts: Maximum number of retry attempts.
-        backoff: Backoff strategy to use.
-        base_delay: Base delay in seconds between retries.
-        max_delay: Maximum delay in seconds (caps exponential growth).
-        jitter: Whether to add random jitter to delays.
-        retryable_errors: Optional tuple of exception types to retry on.
-
-    Examples:
-        >>> policy = RetryPolicy(
-        ...     max_attempts=5,
-        ...     backoff=BackoffStrategy.EXPONENTIAL,
-        ...     base_delay=1.0,
-        ...     max_delay=30.0
-        ... )
-    """
-
-    max_attempts: int = 3
-    backoff: BackoffStrategy = BackoffStrategy.EXPONENTIAL
-    base_delay: float = 1.0
-    max_delay: float = 60.0
-    jitter: bool = True
-    retryable_errors: tuple[type[Exception], ...] | None = None
-
-    def calculate_delay(self, attempt: int) -> float:
-        """Calculate delay for a given attempt number.
-
-        Args:
-            attempt: Attempt number (1-based).
-
-        Returns:
-            Delay in seconds.
-        """
-        if attempt <= 0:
-            return 0
-
-        if self.backoff == BackoffStrategy.FIXED:
-            delay = self.base_delay
-        elif self.backoff == BackoffStrategy.LINEAR:
-            delay = self.base_delay * attempt
-        elif self.backoff == BackoffStrategy.EXPONENTIAL:
-            delay = self.base_delay * (2 ** (attempt - 1))
-        elif self.backoff == BackoffStrategy.FIBONACCI:
-            # Calculate fibonacci number for attempt
-            a, b = 0, 1
-            for _ in range(attempt):
-                a, b = b, a + b
-            delay = self.base_delay * a
-        else:
-            delay = self.base_delay
-
-        # Cap at max delay
-        delay = min(delay, self.max_delay)
-
-        # Add jitter if configured (±25% random variation)
-        if self.jitter:
-            import random
-
-            jitter_factor = 0.75 + (random.random() * 0.5)
-            delay *= jitter_factor
-
-        return delay
-
-    def should_retry(self, error: Exception, attempt: int) -> bool:
-        """Determine if an error should be retried.
-
-        Args:
-            error: The exception that occurred.
-            attempt: Current attempt number (1-based).
-
-        Returns:
-            True if should retry, False otherwise.
-        """
-        # Check attempt limit
-        if attempt >= self.max_attempts:
-            return False
-
-        # Check error type if filter is configured
-        if self.retryable_errors is not None:
-            return isinstance(error, self.retryable_errors)
-
-        # Default to retry for any error
-        return True
-
 
 @define(kw_only=True, slots=True)
 class ErrorResponse:

provide/foundation/file/directory.py

@@ -6,6 +6,8 @@ from pathlib import Path
 import shutil
 import tempfile
 
+from provide.foundation.errors.decorators import with_error_handling
+from provide.foundation.errors.handlers import error_boundary
 from provide.foundation.logger import get_logger
 
 log = get_logger(__name__)
@@ -80,17 +82,12 @@ def temp_dir(
         yield temp_path
     finally:
         if cleanup and temp_path and temp_path.exists():
-            try:
+            with error_boundary(Exception, reraise=False):
                 shutil.rmtree(temp_path)
                 log.debug("Cleaned up temp directory", path=str(temp_path))
-            except Exception as e:
-                log.warning(
-                    "Failed to cleanup temp directory",
-                    path=str(temp_path),
-                    error=str(e),
-                )
 
 
+@with_error_handling(fallback=False, suppress=(FileNotFoundError,) if False else ())
 def safe_rmtree(
     path: Path | str,
     missing_ok: bool = True,
@@ -109,21 +106,15 @@ def safe_rmtree(
     """
     path = Path(path)
 
-    try:
-        if path.exists():
-            shutil.rmtree(path)
-            log.debug("Removed directory tree", path=str(path))
-            return True
-        elif missing_ok:
-            log.debug("Directory already absent", path=str(path))
-            return False
-        else:
-            raise FileNotFoundError(f"Directory does not exist: {path}")
-    except Exception as e:
-        if not path.exists() and missing_ok:
-            return False
-        log.error("Failed to remove directory tree", path=str(path), error=str(e))
-        raise
+    if path.exists():
+        shutil.rmtree(path)
+        log.debug("Removed directory tree", path=str(path))
+        return True
+    elif missing_ok:
+        log.debug("Directory already absent", path=str(path))
+        return False
+    else:
+        raise FileNotFoundError(f"Directory does not exist: {path}")
 
 
 __all__ = [

provide/foundation/file/lock.py

@@ -4,6 +4,8 @@ import os
 from pathlib import Path
 import time
 
+from provide.foundation.config.defaults import DEFAULT_FILE_LOCK_TIMEOUT
+from provide.foundation.errors.decorators import with_error_handling
 from provide.foundation.errors.resources import LockError
 from provide.foundation.logger import get_logger
 
@@ -25,7 +27,7 @@ class FileLock:
     def __init__(
         self,
         path: Path | str,
-        timeout: float = 10.0,
+        timeout: float = DEFAULT_FILE_LOCK_TIMEOUT,
         check_interval: float = 0.1,
     ) -> None:
         """Initialize file lock.