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

provide/foundation/transport/middleware.py

@@ -2,18 +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.resilience.retry import (
+    BackoffStrategy,
+    RetryExecutor,
+    RetryPolicy,
+)
 from provide.foundation.transport.base import Request, Response
 from provide.foundation.transport.errors import TransportError
 
@@ -22,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."""
@@ -42,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:
@@ -54,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:
@@ -72,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(
@@ -96,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:
@@ -114,7 +120,7 @@ class LoggingMiddleware(Middleware):
 @define
 class RetryMiddleware(Middleware):
     """Automatic retry middleware using unified retry logic."""
-    
+
     policy: RetryPolicy = field(
         factory=lambda: RetryPolicy(
             max_attempts=3,
@@ -124,33 +130,33 @@ class RetryMiddleware(Middleware):
             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 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:
@@ -165,76 +171,73 @@ class RetryMiddleware(Middleware):
 @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):
@@ -243,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:
@@ -267,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,
@@ -280,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]
@@ -306,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
 
 
@@ -324,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
@@ -349,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",
+]

provide/foundation/utils/deps.py

@@ -6,6 +6,7 @@ from typing import NamedTuple
 def _get_logger():
     """Lazy logger import to avoid circular dependencies."""
     from provide.foundation.logger import get_logger
+
     return get_logger(__name__)
 
 
@@ -21,7 +22,7 @@ class DependencyStatus(NamedTuple):
 def _check_click() -> DependencyStatus:
     """Check click availability."""
     try:
-        import click
+        import click  # noqa: F401
 
         # Use importlib.metadata to avoid deprecation warning
         try:
@@ -68,7 +69,7 @@ def _check_cryptography() -> DependencyStatus:
 def _check_opentelemetry() -> DependencyStatus:
     """Check OpenTelemetry availability."""
     try:
-        import opentelemetry
+        import opentelemetry  # noqa: F401
 
         try:
             from importlib.metadata import version

provide/foundation/utils/parsing.py

@@ -222,11 +222,11 @@ def auto_parse(attr: Any, value: str) -> Any:
         'HELLO'
     """
     # Check for attrs field converter first
-    if hasattr(attr, 'converter') and attr.converter is not None:
+    if hasattr(attr, "converter") and attr.converter is not None:
         try:
             result = attr.converter(value)
             # Check if result is a Mock object (test scenario)
-            if hasattr(result, '_mock_name') or str(type(result)).find('Mock') >= 0:
+            if hasattr(result, "_mock_name") or str(type(result)).find("Mock") >= 0:
                 # It's a Mock, fall back to type-based parsing
                 pass
             else:
@@ -234,15 +234,15 @@ def auto_parse(attr: Any, value: str) -> Any:
         except Exception:
             # If converter fails, fall back to type-based parsing
             pass
-    
+
     # Check for converter in metadata as fallback
-    if hasattr(attr, 'metadata') and attr.metadata:
-        converter = attr.metadata.get('converter')
+    if hasattr(attr, "metadata") and attr.metadata:
+        converter = attr.metadata.get("converter")
         if converter and callable(converter):
             try:
                 result = converter(value)
                 # Check if result is a Mock object (test scenario)
-                if hasattr(result, '_mock_name') or str(type(result)).find('Mock') >= 0:
+                if hasattr(result, "_mock_name") or str(type(result)).find("Mock") >= 0:
                     # It's a Mock, fall back to type-based parsing
                     pass
                 else:
@@ -250,7 +250,7 @@ def auto_parse(attr: Any, value: str) -> Any:
             except Exception:
                 # If converter fails, fall back to type-based parsing
                 pass
-    
+
     # Get type hint from attrs field
     if hasattr(attr, "type") and attr.type is not None:
         field_type = attr.type

{provide_foundation-0.0.0.dev2.dist-info → provide_foundation-0.0.0.dev3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: provide-foundation
-Version: 0.0.0.dev2
+Version: 0.0.0.dev3
 Summary: Foundation Telemetry: An opinionated, developer-friendly telemetry wrapper for Python.
 Author-email: Tim Perkins <code@tim.life>
 Maintainer-email: "provide.io" <code@provide.io>
@@ -96,7 +96,7 @@ provide.foundation has optional feature sets that require additional dependencie
 ### Core Components
 
 #### **Structured Logging**
-Beautiful, performant logging built on `structlog` with emoji-enhanced visual parsing and zero configuration required.
+Beautiful, performant logging built on `structlog` with event-enriched structured logging and zero configuration required.
 
 ```python
 # Simple usage - works immediately with base install