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

provide/foundation/transport/middleware.py

@@ -2,17 +2,19 @@
 Transport middleware system with Hub registration.
 """
 
-import asyncio
-import time
 from abc import ABC, abstractmethod
-from typing import Any
+import time
 
 from attrs import define, field
 
 from provide.foundation.hub import get_component_registry
-from provide.foundation.hub.components import ComponentCategory
 from provide.foundation.logger import get_logger
 from provide.foundation.metrics import counter, histogram
+from provide.foundation.resilience.retry import (
+    BackoffStrategy,
+    RetryExecutor,
+    RetryPolicy,
+)
 from provide.foundation.transport.base import Request, Response
 from provide.foundation.transport.errors import TransportError
 
@@ -21,17 +23,17 @@ log = get_logger(__name__)
 
 class Middleware(ABC):
     """Abstract base class for transport middleware."""
-    
+
     @abstractmethod
     async def process_request(self, request: Request) -> Request:
         """Process request before sending."""
         pass
-    
-    @abstractmethod 
+
+    @abstractmethod
     async def process_response(self, response: Response) -> Response:
         """Process response after receiving."""
         pass
-    
+
     @abstractmethod
     async def process_error(self, error: Exception, request: Request) -> Exception:
         """Process errors during request."""
@@ -41,11 +43,11 @@ class Middleware(ABC):
 @define
 class LoggingMiddleware(Middleware):
     """Built-in telemetry middleware using foundation.logger."""
-    
+
     log_requests: bool = field(default=True)
     log_responses: bool = field(default=True)
     log_bodies: bool = field(default=False)
-    
+
     async def process_request(self, request: Request) -> Request:
         """Log outgoing request."""
         if self.log_requests:
@@ -53,14 +55,19 @@ class LoggingMiddleware(Middleware):
                 f"🚀 {request.method} {request.uri}",
                 method=request.method,
                 uri=str(request.uri),
-                headers=dict(request.headers) if hasattr(request, 'headers') else {},
+                headers=dict(request.headers) if hasattr(request, "headers") else {},
             )
-            
+
             if self.log_bodies and request.body:
-                log.trace("Request body", body=request.body, method=request.method, uri=str(request.uri))
-        
+                log.trace(
+                    "Request body",
+                    body=request.body,
+                    method=request.method,
+                    uri=str(request.uri),
+                )
+
         return request
-    
+
     async def process_response(self, response: Response) -> Response:
         """Log incoming response."""
         if self.log_responses:
@@ -71,20 +78,20 @@ class LoggingMiddleware(Middleware):
                 elapsed_ms=response.elapsed_ms,
                 method=response.request.method if response.request else None,
                 uri=str(response.request.uri) if response.request else None,
-                headers=dict(response.headers) if hasattr(response, 'headers') else {},
+                headers=dict(response.headers) if hasattr(response, "headers") else {},
             )
-            
+
             if self.log_bodies and response.body:
                 log.trace(
-                    "Response body", 
+                    "Response body",
                     body=response.text[:500],  # Truncate large bodies
                     status_code=response.status,
                     method=response.request.method if response.request else None,
                     uri=str(response.request.uri) if response.request else None,
                 )
-        
+
         return response
-    
+
     async def process_error(self, error: Exception, request: Request) -> Exception:
         """Log errors."""
         log.error(
@@ -95,13 +102,13 @@ class LoggingMiddleware(Middleware):
             error_message=str(error),
         )
         return error
-    
+
     def _get_status_emoji(self, status_code: int) -> str:
         """Get emoji for status code."""
         if 200 <= status_code < 300:
             return "✅"
         elif 300 <= status_code < 400:
-            return "↩️" 
+            return "↩️"
         elif 400 <= status_code < 500:
             return "⚠️"
         elif 500 <= status_code < 600:
@@ -112,135 +119,125 @@ class LoggingMiddleware(Middleware):
 
 @define
 class RetryMiddleware(Middleware):
-    """Automatic retry middleware with exponential backoff."""
-    
-    max_retries: int = field(default=3)
-    backoff_factor: float = field(default=0.5)
-    retryable_status_codes: set[int] = field(factory=lambda: {500, 502, 503, 504})
-    retryable_exceptions: tuple[type[Exception], ...] = field(
-        factory=lambda: (TransportError,)
+    """Automatic retry middleware using unified retry logic."""
+
+    policy: RetryPolicy = field(
+        factory=lambda: RetryPolicy(
+            max_attempts=3,
+            base_delay=0.5,
+            backoff=BackoffStrategy.EXPONENTIAL,
+            retryable_errors=(TransportError,),
+            retryable_status_codes={500, 502, 503, 504},
+        )
     )
-    
+
     async def process_request(self, request: Request) -> Request:
         """No request processing needed."""
         return request
-    
+
     async def process_response(self, response: Response) -> Response:
         """No response processing needed (retries handled in execute)."""
         return response
-    
+
     async def process_error(self, error: Exception, request: Request) -> Exception:
         """Handle error, potentially with retries (this is called by client)."""
         return error
-    
+
     async def execute_with_retry(self, execute_func, request: Request) -> Response:
-        """Execute request with retry logic."""
-        last_exception = None
-        
-        for attempt in range(self.max_retries + 1):
-            try:
-                response = await execute_func(request)
-                
-                # Check if status code is retryable
-                if response.status in self.retryable_status_codes and attempt < self.max_retries:
-                    wait_time = self.backoff_factor * (2 ** attempt)
-                    log.info(f"🔄 Retry {attempt + 1}/{self.max_retries} after {wait_time:.1f}s (status {response.status})")
-                    await asyncio.sleep(wait_time)
-                    continue
-                
-                return response
-                
-            except self.retryable_exceptions as e:
-                last_exception = e
-                
-                if attempt < self.max_retries:
-                    wait_time = self.backoff_factor * (2 ** attempt)
-                    log.info(f"🔄 Retry {attempt + 1}/{self.max_retries} after {wait_time:.1f}s (error: {e})")
-                    await asyncio.sleep(wait_time)
-                else:
-                    break
-        
-        # All retries exhausted
-        if last_exception:
-            raise last_exception
-        else:
-            # This shouldn't happen, but just in case
-            raise TransportError("Max retries exceeded")
+        """Execute request with retry logic using unified RetryExecutor."""
+        executor = RetryExecutor(self.policy)
+
+        async def wrapped():
+            response = await execute_func(request)
+
+            # Check if status code is retryable
+            if self.policy.should_retry_response(response, attempt=1):
+                # Convert to exception for executor to handle
+                raise TransportError(f"Retryable HTTP status: {response.status}")
+
+            return response
+
+        try:
+            return await executor.execute_async(wrapped)
+        except TransportError as e:
+            # If it's our synthetic error, extract the response
+            if "Retryable HTTP status" in str(e):
+                # The last response will be returned
+                # For now, re-raise as this needs more sophisticated handling
+                raise
+            raise
 
 
 @define
 class MetricsMiddleware(Middleware):
     """Middleware for collecting transport metrics using foundation.metrics."""
-    
+
     # Create metrics instances
     _request_counter = counter(
         "transport_requests_total",
         description="Total number of transport requests",
-        unit="requests"
+        unit="requests",
     )
     _request_duration = histogram(
-        "transport_request_duration_seconds", 
+        "transport_request_duration_seconds",
         description="Duration of transport requests",
-        unit="seconds"
+        unit="seconds",
     )
     _error_counter = counter(
         "transport_errors_total",
-        description="Total number of transport errors", 
-        unit="errors"
+        description="Total number of transport errors",
+        unit="errors",
     )
-    
+
     async def process_request(self, request: Request) -> Request:
         """Record request start time."""
         request.metadata["start_time"] = time.perf_counter()
         return request
-    
+
     async def process_response(self, response: Response) -> Response:
         """Record response metrics."""
         if response.request and "start_time" in response.request.metadata:
             start_time = response.request.metadata["start_time"]
             duration = time.perf_counter() - start_time
-            
+
             method = response.request.method
             status_class = f"{response.status // 100}xx"
-            
+
             # Record metrics with labels
-            self._request_counter.inc(1, 
+            self._request_counter.inc(
+                1,
                 method=method,
                 status_code=str(response.status),
-                status_class=status_class
+                status_class=status_class,
             )
-            
-            self._request_duration.observe(duration,
-                method=method,
-                status_class=status_class
+
+            self._request_duration.observe(
+                duration, method=method, status_class=status_class
             )
-        
+
         return response
-    
+
     async def process_error(self, error: Exception, request: Request) -> Exception:
         """Record error metrics."""
         method = request.method
         error_type = error.__class__.__name__
-        
-        self._error_counter.inc(1,
-            method=method,
-            error_type=error_type
-        )
-        
+
+        self._error_counter.inc(1, method=method, error_type=error_type)
+
         return error
 
 
 @define
 class MiddlewarePipeline:
     """Pipeline for executing middleware in order."""
-    
+
     middleware: list[Middleware] = field(factory=list)
-    
+
     def add(self, middleware: Middleware) -> None:
         """Add middleware to the pipeline."""
         self.middleware.append(middleware)
         log.trace(f"Added middleware: {middleware.__class__.__name__}")
-    
+
     def remove(self, middleware_class: type[Middleware]) -> bool:
         """Remove middleware by class type."""
         for i, mw in enumerate(self.middleware):
@@ -249,19 +246,19 @@ class MiddlewarePipeline:
                 log.trace(f"Removed middleware: {middleware_class.__name__}")
                 return True
         return False
-    
+
     async def process_request(self, request: Request) -> Request:
         """Process request through all middleware."""
         for mw in self.middleware:
             request = await mw.process_request(request)
         return request
-    
+
     async def process_response(self, response: Response) -> Response:
         """Process response through all middleware (in reverse order)."""
         for mw in reversed(self.middleware):
             response = await mw.process_response(response)
         return response
-    
+
     async def process_error(self, error: Exception, request: Request) -> Exception:
         """Process error through all middleware."""
         for mw in self.middleware:
@@ -273,11 +270,11 @@ def register_middleware(
     name: str,
     middleware_class: type[Middleware],
     category: str = "transport.middleware",
-    **metadata
+    **metadata,
 ) -> None:
     """Register middleware in the Hub."""
     registry = get_component_registry()
-    
+
     registry.register(
         name=name,
         value=middleware_class,
@@ -286,24 +283,26 @@ def register_middleware(
             "category": category,
             "priority": metadata.get("priority", 100),
             "class_name": middleware_class.__name__,
-            **metadata
+            **metadata,
         },
         replace=True,
     )
-    
+
     log.debug(f"Registered middleware {middleware_class.__name__} as '{name}'")
 
 
-def get_middleware_by_category(category: str = "transport.middleware") -> list[type[Middleware]]:
+def get_middleware_by_category(
+    category: str = "transport.middleware",
+) -> list[type[Middleware]]:
     """Get all middleware for a category, sorted by priority."""
     registry = get_component_registry()
     middleware = []
-    
+
     for entry in registry:
         if entry.dimension == category:
             priority = entry.metadata.get("priority", 100)
             middleware.append((entry.value, priority))
-    
+
     # Sort by priority (lower numbers = higher priority)
     middleware.sort(key=lambda x: x[1])
     return [mw[0] for mw in middleware]
@@ -312,11 +311,11 @@ def get_middleware_by_category(category: str = "transport.middleware") -> list[t
 def create_default_pipeline() -> MiddlewarePipeline:
     """Create pipeline with default middleware."""
     pipeline = MiddlewarePipeline()
-    
+
     # Add built-in middleware
     pipeline.add(LoggingMiddleware())
     pipeline.add(MetricsMiddleware())
-    
+
     return pipeline
 
 
@@ -330,21 +329,21 @@ def _register_builtin_middleware():
             description="Built-in request/response logging",
             priority=10,
         )
-        
+
         register_middleware(
-            "retry", 
+            "retry",
             RetryMiddleware,
             description="Automatic retry with exponential backoff",
             priority=20,
         )
-        
+
         register_middleware(
             "metrics",
-            MetricsMiddleware, 
+            MetricsMiddleware,
             description="Request/response metrics collection",
             priority=30,
         )
-        
+
     except ImportError:
         # Registry not available yet
         pass
@@ -355,12 +354,12 @@ _register_builtin_middleware()
 
 
 __all__ = [
-    "Middleware",
     "LoggingMiddleware",
-    "RetryMiddleware", 
     "MetricsMiddleware",
+    "Middleware",
     "MiddlewarePipeline",
-    "register_middleware",
-    "get_middleware_by_category",
+    "RetryMiddleware",
     "create_default_pipeline",
-]
+    "get_middleware_by_category",
+    "register_middleware",
+]

provide/foundation/transport/registry.py

@@ -18,11 +18,11 @@ def register_transport(
     transport_type: TransportType,
     transport_class: type[Transport],
     schemes: list[str] | None = None,
-    **metadata
+    **metadata,
 ) -> None:
     """
     Register a transport implementation in the Hub.
-    
+
     Args:
         transport_type: The primary transport type
         transport_class: Transport implementation class
@@ -30,11 +30,11 @@ def register_transport(
         **metadata: Additional metadata for the transport
     """
     registry = get_component_registry()
-    
+
     # Default schemes to just the transport type
     if schemes is None:
         schemes = [transport_type.value]
-    
+
     registry.register(
         name=transport_type.value,
         value=transport_class,
@@ -43,37 +43,39 @@ def register_transport(
             "transport_type": transport_type,
             "schemes": schemes,
             "class_name": transport_class.__name__,
-            **metadata
+            **metadata,
         },
         replace=True,  # Allow re-registration
     )
-    
+
     log.debug(f"Registered transport {transport_class.__name__} for schemes: {schemes}")
 
 
 def get_transport_for_scheme(scheme: str) -> type[Transport]:
     """
     Get transport class for a URI scheme.
-    
+
     Args:
         scheme: URI scheme (e.g., 'http', 'https', 'ws')
-        
+
     Returns:
         Transport class that handles the scheme
-        
+
     Raises:
         TransportNotFoundError: If no transport is registered for the scheme
     """
     registry = get_component_registry()
-    
+
     # Search through registered transports
     for entry in registry:
         if entry.dimension == ComponentCategory.TRANSPORT.value:
             schemes = entry.metadata.get("schemes", [])
             if scheme.lower() in schemes:
-                log.trace(f"Found transport {entry.value.__name__} for scheme '{scheme}'")
+                log.trace(
+                    f"Found transport {entry.value.__name__} for scheme '{scheme}'"
+                )
                 return entry.value
-    
+
     raise TransportNotFoundError(
         f"No transport registered for scheme: {scheme}",
         scheme=scheme,
@@ -83,13 +85,13 @@ def get_transport_for_scheme(scheme: str) -> type[Transport]:
 def get_transport(uri: str) -> Transport:
     """
     Get transport instance for a URI.
-    
+
     Args:
         uri: Full URI to get transport for
-        
+
     Returns:
         Transport instance ready to use
-        
+
     Raises:
         TransportNotFoundError: If no transport supports the URI scheme
     """
@@ -101,13 +103,13 @@ def get_transport(uri: str) -> Transport:
 def list_registered_transports() -> dict[str, dict[str, Any]]:
     """
     List all registered transports.
-    
+
     Returns:
         Dictionary mapping transport names to their info
     """
     registry = get_component_registry()
     transports = {}
-    
+
     for entry in registry:
         if entry.dimension == ComponentCategory.TRANSPORT.value:
             transports[entry.name] = {
@@ -116,22 +118,22 @@ def list_registered_transports() -> dict[str, dict[str, Any]]:
                 "transport_type": entry.metadata.get("transport_type"),
                 "metadata": entry.metadata,
             }
-    
+
     return transports
 
 
 def get_transport_info(scheme_or_name: str) -> dict[str, Any] | None:
     """
     Get detailed information about a transport.
-    
+
     Args:
         scheme_or_name: URI scheme or transport name
-        
+
     Returns:
         Transport information or None if not found
     """
     registry = get_component_registry()
-    
+
     for entry in registry:
         if entry.dimension == ComponentCategory.TRANSPORT.value:
             # Check if it matches by name
@@ -143,7 +145,7 @@ def get_transport_info(scheme_or_name: str) -> dict[str, Any] | None:
                     "transport_type": entry.metadata.get("transport_type"),
                     "metadata": entry.metadata,
                 }
-            
+
             # Check if it matches by scheme
             schemes = entry.metadata.get("schemes", [])
             if scheme_or_name.lower() in schemes:
@@ -154,14 +156,14 @@ def get_transport_info(scheme_or_name: str) -> dict[str, Any] | None:
                     "transport_type": entry.metadata.get("transport_type"),
                     "metadata": entry.metadata,
                 }
-    
+
     return None
 
 
 __all__ = [
-    "register_transport",
-    "get_transport_for_scheme", 
     "get_transport",
-    "list_registered_transports",
+    "get_transport_for_scheme",
     "get_transport_info",
-]
+    "list_registered_transports",
+    "register_transport",
+]

provide/foundation/transport/types.py

@@ -13,7 +13,7 @@ Data: TypeAlias = dict[str, Any] | bytes | str | None
 
 class TransportType(str, Enum):
     """Supported transport types."""
-    
+
     HTTP = "http"
     HTTPS = "https"
     WS = "ws"
@@ -26,7 +26,7 @@ class TransportType(str, Enum):
 
 class HTTPMethod(str, Enum):
     """HTTP methods."""
-    
+
     GET = "GET"
     POST = "POST"
     PUT = "PUT"
@@ -37,9 +37,9 @@ class HTTPMethod(str, Enum):
 
 
 __all__ = [
-    "Headers",
-    "Params", 
     "Data",
-    "TransportType",
     "HTTPMethod",
-]
+    "Headers",
+    "Params",
+    "TransportType",
+]