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

provide/foundation/transport/config.py

@@ -2,164 +2,93 @@
 Transport configuration with Foundation config integration.
 """
 
-import os
-
 from attrs import define
 
-from provide.foundation.config import BaseConfig, field
+from provide.foundation.config.base import field
+from provide.foundation.config.converters import (
+    parse_bool_extended,
+    parse_float_with_validation,
+    validate_non_negative,
+    validate_positive,
+)
+from provide.foundation.config.env import RuntimeConfig
 from provide.foundation.config.loader import RuntimeConfigLoader
 from provide.foundation.config.manager import register_config
-from provide.foundation.config.types import ConfigSource
 from provide.foundation.logger import get_logger
 
 log = get_logger(__name__)
 
 
 @define(slots=True, repr=False)
-class TransportConfig(BaseConfig):
+class TransportConfig(RuntimeConfig):
     """Base configuration for all transports."""
-    
+
     timeout: float = field(
         default=30.0,
         env_var="PROVIDE_TRANSPORT_TIMEOUT",
+        converter=lambda x: parse_float_with_validation(x, min_val=0.0) if x else 30.0,
+        validator=validate_positive,
         description="Request timeout in seconds",
     )
     max_retries: int = field(
         default=3,
         env_var="PROVIDE_TRANSPORT_MAX_RETRIES",
+        converter=int,
+        validator=validate_non_negative,
         description="Maximum number of retry attempts",
     )
     retry_backoff_factor: float = field(
         default=0.5,
-        env_var="PROVIDE_TRANSPORT_RETRY_BACKOFF_FACTOR", 
+        env_var="PROVIDE_TRANSPORT_RETRY_BACKOFF_FACTOR",
+        converter=lambda x: parse_float_with_validation(x, min_val=0.0) if x else 0.5,
+        validator=validate_non_negative,
         description="Backoff multiplier for retries",
     )
     verify_ssl: bool = field(
         default=True,
         env_var="PROVIDE_TRANSPORT_VERIFY_SSL",
+        converter=parse_bool_extended,
         description="Whether to verify SSL certificates",
     )
-    
-    @classmethod
-    def from_env(cls, strict: bool = True) -> "TransportConfig":
-        """Load configuration from environment variables."""
-        config_dict = {}
-        
-        if timeout := os.getenv("PROVIDE_TRANSPORT_TIMEOUT"):
-            try:
-                config_dict["timeout"] = float(timeout)
-            except ValueError:
-                if strict:
-                    log.warning(
-                        "Invalid transport timeout value, using field default",
-                        invalid_value=timeout,
-                    )
-        
-        if max_retries := os.getenv("PROVIDE_TRANSPORT_MAX_RETRIES"):
-            try:
-                config_dict["max_retries"] = int(max_retries)
-            except ValueError:
-                if strict:
-                    log.warning(
-                        "Invalid max retries value, using field default",
-                        invalid_value=max_retries,
-                    )
-        
-        if backoff := os.getenv("PROVIDE_TRANSPORT_RETRY_BACKOFF_FACTOR"):
-            try:
-                config_dict["retry_backoff_factor"] = float(backoff)
-            except ValueError:
-                if strict:
-                    log.warning(
-                        "Invalid backoff factor value, using field default",
-                        invalid_value=backoff,
-                    )
-        
-        if verify_ssl := os.getenv("PROVIDE_TRANSPORT_VERIFY_SSL"):
-            config_dict["verify_ssl"] = verify_ssl.lower() == "true"
-        
-        config = cls.from_dict(config_dict, source=ConfigSource.ENV)
-        log.trace("Loaded transport configuration from environment", config_dict=config_dict)
-        return config
 
 
 @define(slots=True, repr=False)
 class HTTPConfig(TransportConfig):
     """HTTP-specific configuration."""
-    
+
     pool_connections: int = field(
         default=10,
         env_var="PROVIDE_HTTP_POOL_CONNECTIONS",
+        converter=int,
+        validator=validate_positive,
         description="Number of connection pools to cache",
     )
     pool_maxsize: int = field(
         default=100,
-        env_var="PROVIDE_HTTP_POOL_MAXSIZE", 
+        env_var="PROVIDE_HTTP_POOL_MAXSIZE",
+        converter=int,
+        validator=validate_positive,
         description="Maximum number of connections per pool",
     )
     follow_redirects: bool = field(
         default=True,
         env_var="PROVIDE_HTTP_FOLLOW_REDIRECTS",
+        converter=parse_bool_extended,
         description="Whether to automatically follow redirects",
     )
     http2: bool = field(
         default=False,
         env_var="PROVIDE_HTTP_USE_HTTP2",
+        converter=parse_bool_extended,
         description="Enable HTTP/2 support",
     )
     max_redirects: int = field(
         default=5,
         env_var="PROVIDE_HTTP_MAX_REDIRECTS",
+        converter=int,
+        validator=validate_non_negative,
         description="Maximum number of redirects to follow",
     )
-    
-    @classmethod
-    def from_env(cls, strict: bool = True) -> "HTTPConfig":
-        """Load HTTP configuration from environment variables."""
-        # Start with base transport config
-        base_config = TransportConfig.from_env(strict=strict)
-        config_dict = base_config.to_dict(include_sensitive=True)
-        
-        # Add HTTP-specific settings
-        if pool_connections := os.getenv("PROVIDE_HTTP_POOL_CONNECTIONS"):
-            try:
-                config_dict["pool_connections"] = int(pool_connections)
-            except ValueError:
-                if strict:
-                    log.warning(
-                        "Invalid pool connections value, using field default",
-                        invalid_value=pool_connections,
-                    )
-        
-        if pool_maxsize := os.getenv("PROVIDE_HTTP_POOL_MAXSIZE"):
-            try:
-                config_dict["pool_maxsize"] = int(pool_maxsize)
-            except ValueError:
-                if strict:
-                    log.warning(
-                        "Invalid pool maxsize value, using field default",
-                        invalid_value=pool_maxsize,
-                    )
-        
-        if follow_redirects := os.getenv("PROVIDE_HTTP_FOLLOW_REDIRECTS"):
-            config_dict["follow_redirects"] = follow_redirects.lower() == "true"
-        
-        if http2 := os.getenv("PROVIDE_HTTP_USE_HTTP2"):
-            config_dict["http2"] = http2.lower() == "true"
-        
-        if max_redirects := os.getenv("PROVIDE_HTTP_MAX_REDIRECTS"):
-            try:
-                config_dict["max_redirects"] = int(max_redirects)
-            except ValueError:
-                if strict:
-                    log.warning(
-                        "Invalid max redirects value, using field default",
-                        invalid_value=max_redirects,
-                    )
-        
-        config = cls.from_dict(config_dict, source=ConfigSource.ENV)
-        log.trace("Loaded HTTP configuration from environment", config_dict=config_dict)
-        return config
 
 
 async def register_transport_configs() -> None:
@@ -175,10 +104,10 @@ async def register_transport_configs() -> None:
                 "max_retries": 3,
                 "retry_backoff_factor": 0.5,
                 "verify_ssl": True,
-            }
+            },
         )
-        
-        # Register HTTPConfig  
+
+        # Register HTTPConfig
         await register_config(
             name="transport.http",
             config=None,  # Will be loaded on demand
@@ -193,17 +122,17 @@ async def register_transport_configs() -> None:
                 "follow_redirects": True,
                 "http2": False,
                 "max_redirects": 5,
-            }
+            },
         )
-        
+
         log.trace("Successfully registered transport configurations with ConfigManager")
-        
+
     except Exception as e:
         log.warning("Failed to register transport configurations", error=str(e))
 
 
 __all__ = [
-    "TransportConfig",
     "HTTPConfig",
+    "TransportConfig",
     "register_transport_configs",
-]
+]

provide/foundation/transport/errors.py

@@ -12,38 +12,29 @@ if TYPE_CHECKING:
 
 class TransportError(FoundationError):
     """Base transport error."""
-    
-    def __init__(
-        self, 
-        message: str,
-        *,
-        request: "Request | None" = None,
-        **kwargs
-    ):
+
+    def __init__(self, message: str, *, request: "Request | None" = None, **kwargs):
         super().__init__(message, **kwargs)
         self.request = request
 
 
 class TransportConnectionError(TransportError):
     """Transport connection failed."""
+
     pass
 
 
 class TransportTimeoutError(TransportError):
     """Transport request timed out."""
+
     pass
 
 
 class HTTPResponseError(TransportError):
     """HTTP response error (4xx/5xx status codes)."""
-    
+
     def __init__(
-        self,
-        message: str,
-        *,
-        status_code: int,
-        response: "Response",
-        **kwargs
+        self, message: str, *, status_code: int, response: "Response", **kwargs
     ):
         super().__init__(message, **kwargs)
         self.status_code = status_code
@@ -52,28 +43,23 @@ class HTTPResponseError(TransportError):
 
 class TransportConfigurationError(TransportError):
     """Transport configuration error."""
+
     pass
 
 
 class TransportNotFoundError(TransportError):
     """No transport found for the given URI scheme."""
-    
-    def __init__(
-        self,
-        message: str,
-        *,
-        scheme: str,
-        **kwargs
-    ):
+
+    def __init__(self, message: str, *, scheme: str, **kwargs):
         super().__init__(message, **kwargs)
         self.scheme = scheme
 
 
 __all__ = [
-    "TransportError",
-    "TransportConnectionError", 
-    "TransportTimeoutError",
     "HTTPResponseError",
     "TransportConfigurationError",
+    "TransportConnectionError",
+    "TransportError",
     "TransportNotFoundError",
-]
+    "TransportTimeoutError",
+]

provide/foundation/transport/http.py

@@ -2,18 +2,16 @@
 HTTP/HTTPS transport implementation using httpx.
 """
 
-import time
 from collections.abc import AsyncIterator
-from typing import Any
+import time
 
-import httpx
 from attrs import define, field
+import httpx
 
 from provide.foundation.logger import get_logger
 from provide.foundation.transport.base import Request, Response, TransportBase
 from provide.foundation.transport.config import HTTPConfig
 from provide.foundation.transport.errors import (
-    HTTPResponseError,
     TransportConnectionError,
     TransportTimeoutError,
 )
@@ -25,28 +23,28 @@ log = get_logger(__name__)
 @define
 class HTTPTransport(TransportBase):
     """HTTP/HTTPS transport using httpx backend."""
-    
+
     SCHEMES = ["http", "https"]
-    
+
     config: HTTPConfig = field(factory=HTTPConfig.from_env)
     _client: httpx.AsyncClient | None = field(default=None, init=False)
-    
+
     def supports(self, transport_type: TransportType) -> bool:
         """Check if this transport supports the given type."""
         return transport_type.value in self.SCHEMES
-    
+
     async def connect(self) -> None:
         """Initialize httpx client with configuration."""
         if self._client is not None:
             return
-        
+
         limits = httpx.Limits(
             max_connections=self.config.pool_connections,
             max_keepalive_connections=self.config.pool_maxsize,
         )
-        
+
         timeout = httpx.Timeout(self.config.timeout)
-        
+
         self._client = httpx.AsyncClient(
             limits=limits,
             timeout=timeout,
@@ -55,35 +53,37 @@ class HTTPTransport(TransportBase):
             max_redirects=self.config.max_redirects,
             http2=self.config.http2,
         )
-        
-        log.trace("HTTP transport connected", 
-                 pool_connections=self.config.pool_connections,
-                 http2=self.config.http2)
-    
+
+        log.trace(
+            "HTTP transport connected",
+            pool_connections=self.config.pool_connections,
+            http2=self.config.http2,
+        )
+
     async def disconnect(self) -> None:
         """Close httpx client."""
         if self._client is not None:
             await self._client.aclose()
             self._client = None
             log.trace("HTTP transport disconnected")
-    
+
     async def execute(self, request: Request) -> Response:
         """Execute HTTP request."""
         await self.connect()
-        
+
         if self._client is None:
             raise TransportConnectionError("HTTP client not connected")
-        
+
         # Log request with emoji
         log.info(f"🚀 {request.method} {request.uri}")
-        
+
         start_time = time.perf_counter()
-        
+
         try:
             # Determine request body format
             json_data = None
             data = None
-            
+
             if request.body is not None:
                 if isinstance(request.body, dict):
                     json_data = request.body
@@ -91,9 +91,8 @@ class HTTPTransport(TransportBase):
                     data = request.body
                 else:
                     # Try to serialize as JSON
-                    import json
                     json_data = request.body
-            
+
             # Make the request
             httpx_response = await self._client.request(
                 method=request.method,
@@ -104,13 +103,15 @@ class HTTPTransport(TransportBase):
                 data=data,
                 timeout=request.timeout or self.config.timeout,
             )
-            
+
             elapsed_ms = (time.perf_counter() - start_time) * 1000
-            
+
             # Log response with status emoji
             status_emoji = self._get_status_emoji(httpx_response.status_code)
-            log.info(f"{status_emoji} {httpx_response.status_code} ({elapsed_ms:.0f}ms)")
-            
+            log.info(
+                f"{status_emoji} {httpx_response.status_code} ({elapsed_ms:.0f}ms)"
+            )
+
             # Create response object
             response = Response(
                 status=httpx_response.status_code,
@@ -126,35 +127,43 @@ class HTTPTransport(TransportBase):
                 elapsed_ms=elapsed_ms,
                 request=request,
             )
-            
+
             return response
-            
+
         except httpx.ConnectError as e:
             log.error(f"❌ Connection failed: {e}")
-            raise TransportConnectionError(f"Failed to connect: {e}", request=request) from e
-            
+            raise TransportConnectionError(
+                f"Failed to connect: {e}", request=request
+            ) from e
+
         except httpx.TimeoutException as e:
             elapsed_ms = (time.perf_counter() - start_time) * 1000
             log.error(f"⏱️ Request timed out ({elapsed_ms:.0f}ms)")
-            raise TransportTimeoutError(f"Request timed out: {e}", request=request) from e
-            
+            raise TransportTimeoutError(
+                f"Request timed out: {e}", request=request
+            ) from e
+
         except httpx.RequestError as e:
             log.error(f"❌ Request failed: {e}")
-            raise TransportConnectionError(f"Request failed: {e}", request=request) from e
-            
+            raise TransportConnectionError(
+                f"Request failed: {e}", request=request
+            ) from e
+
         except Exception as e:
             log.error(f"❌ Unexpected error: {e}", exc_info=True)
-            raise TransportConnectionError(f"Unexpected error: {e}", request=request) from e
-    
+            raise TransportConnectionError(
+                f"Unexpected error: {e}", request=request
+            ) from e
+
     async def stream(self, request: Request) -> AsyncIterator[bytes]:
         """Stream HTTP response."""
         await self.connect()
-        
+
         if self._client is None:
             raise TransportConnectionError("HTTP client not connected")
-        
+
         log.info(f"🌊 Streaming {request.method} {request.uri}")
-        
+
         try:
             async with self._client.stream(
                 method=request.method,
@@ -163,24 +172,29 @@ class HTTPTransport(TransportBase):
                 params=request.params,
                 timeout=request.timeout or self.config.timeout,
             ) as response:
-                
                 # Log response start
                 status_emoji = self._get_status_emoji(response.status_code)
                 log.info(f"{status_emoji} {response.status_code} (streaming)")
-                
+
                 # Stream the response
                 async for chunk in response.aiter_bytes():
                     yield chunk
-                    
+
         except httpx.ConnectError as e:
-            raise TransportConnectionError(f"Failed to connect: {e}", request=request) from e
-            
+            raise TransportConnectionError(
+                f"Failed to connect: {e}", request=request
+            ) from e
+
         except httpx.TimeoutException as e:
-            raise TransportTimeoutError(f"Stream timed out: {e}", request=request) from e
-            
+            raise TransportTimeoutError(
+                f"Stream timed out: {e}", request=request
+            ) from e
+
         except httpx.RequestError as e:
-            raise TransportConnectionError(f"Stream failed: {e}", request=request) from e
-    
+            raise TransportConnectionError(
+                f"Stream failed: {e}", request=request
+            ) from e
+
     def _get_status_emoji(self, status_code: int) -> str:
         """Get emoji for HTTP status code."""
         if 200 <= status_code < 300:
@@ -200,7 +214,7 @@ def _register_http_transport():
     """Register HTTP transport with the Hub."""
     try:
         from provide.foundation.transport.registry import register_transport
-        
+
         register_transport(
             TransportType.HTTP,
             HTTPTransport,
@@ -208,16 +222,16 @@ def _register_http_transport():
             description="HTTP/HTTPS transport using httpx",
             version="1.0.0",
         )
-        
+
         # Also register HTTPS explicitly
         register_transport(
             TransportType.HTTPS,
             HTTPTransport,
             schemes=HTTPTransport.SCHEMES,
-            description="HTTP/HTTPS transport using httpx", 
+            description="HTTP/HTTPS transport using httpx",
             version="1.0.0",
         )
-        
+
     except ImportError:
         # Registry not available yet, will be registered later
         pass
@@ -229,4 +243,4 @@ _register_http_transport()
 
 __all__ = [
     "HTTPTransport",
-]
+]