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

provide/foundation/transport/config.py

@@ -0,0 +1,209 @@
+"""
+Transport configuration with Foundation config integration.
+"""
+
+import os
+
+from attrs import define
+
+from provide.foundation.config import BaseConfig, field
+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):
+    """Base configuration for all transports."""
+    
+    timeout: float = field(
+        default=30.0,
+        env_var="PROVIDE_TRANSPORT_TIMEOUT",
+        description="Request timeout in seconds",
+    )
+    max_retries: int = field(
+        default=3,
+        env_var="PROVIDE_TRANSPORT_MAX_RETRIES",
+        description="Maximum number of retry attempts",
+    )
+    retry_backoff_factor: float = field(
+        default=0.5,
+        env_var="PROVIDE_TRANSPORT_RETRY_BACKOFF_FACTOR", 
+        description="Backoff multiplier for retries",
+    )
+    verify_ssl: bool = field(
+        default=True,
+        env_var="PROVIDE_TRANSPORT_VERIFY_SSL",
+        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",
+        description="Number of connection pools to cache",
+    )
+    pool_maxsize: int = field(
+        default=100,
+        env_var="PROVIDE_HTTP_POOL_MAXSIZE", 
+        description="Maximum number of connections per pool",
+    )
+    follow_redirects: bool = field(
+        default=True,
+        env_var="PROVIDE_HTTP_FOLLOW_REDIRECTS",
+        description="Whether to automatically follow redirects",
+    )
+    http2: bool = field(
+        default=False,
+        env_var="PROVIDE_HTTP_USE_HTTP2",
+        description="Enable HTTP/2 support",
+    )
+    max_redirects: int = field(
+        default=5,
+        env_var="PROVIDE_HTTP_MAX_REDIRECTS",
+        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:
+    """Register transport configurations with the global ConfigManager."""
+    try:
+        # Register TransportConfig
+        await register_config(
+            name="transport",
+            config=None,  # Will be loaded on demand
+            loader=RuntimeConfigLoader(prefix="PROVIDE_TRANSPORT"),
+            defaults={
+                "timeout": 30.0,
+                "max_retries": 3,
+                "retry_backoff_factor": 0.5,
+                "verify_ssl": True,
+            }
+        )
+        
+        # Register HTTPConfig  
+        await register_config(
+            name="transport.http",
+            config=None,  # Will be loaded on demand
+            loader=RuntimeConfigLoader(prefix="PROVIDE_HTTP"),
+            defaults={
+                "timeout": 30.0,
+                "max_retries": 3,
+                "retry_backoff_factor": 0.5,
+                "verify_ssl": True,
+                "pool_connections": 10,
+                "pool_maxsize": 100,
+                "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",
+    "register_transport_configs",
+]

provide/foundation/transport/errors.py

@@ -0,0 +1,79 @@
+"""
+Transport-specific error types.
+"""
+
+from typing import TYPE_CHECKING
+
+from provide.foundation.errors.base import FoundationError
+
+if TYPE_CHECKING:
+    from provide.foundation.transport.base import Request, Response
+
+
+class TransportError(FoundationError):
+    """Base transport error."""
+    
+    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
+    ):
+        super().__init__(message, **kwargs)
+        self.status_code = status_code
+        self.response = response
+
+
+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
+    ):
+        super().__init__(message, **kwargs)
+        self.scheme = scheme
+
+
+__all__ = [
+    "TransportError",
+    "TransportConnectionError", 
+    "TransportTimeoutError",
+    "HTTPResponseError",
+    "TransportConfigurationError",
+    "TransportNotFoundError",
+]

provide/foundation/transport/http.py

@@ -0,0 +1,232 @@
+"""
+HTTP/HTTPS transport implementation using httpx.
+"""
+
+import time
+from collections.abc import AsyncIterator
+from typing import Any
+
+import httpx
+from attrs import define, field
+
+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,
+)
+from provide.foundation.transport.types import TransportType
+
+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,
+            verify=self.config.verify_ssl,
+            follow_redirects=self.config.follow_redirects,
+            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)
+    
+    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
+                elif isinstance(request.body, (str, bytes)):
+                    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,
+                url=request.uri,
+                headers=request.headers,
+                params=request.params,
+                json=json_data,
+                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)")
+            
+            # Create response object
+            response = Response(
+                status=httpx_response.status_code,
+                headers=dict(httpx_response.headers),
+                body=httpx_response.content,
+                metadata={
+                    "http_version": str(httpx_response.http_version),
+                    "reason_phrase": httpx_response.reason_phrase,
+                    "encoding": httpx_response.encoding,
+                    "is_redirect": httpx_response.is_redirect,
+                    "url": str(httpx_response.url),
+                },
+                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
+            
+        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
+            
+        except httpx.RequestError as e:
+            log.error(f"❌ Request failed: {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
+    
+    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,
+                url=request.uri,
+                headers=request.headers,
+                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
+            
+        except httpx.TimeoutException as 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
+    
+    def _get_status_emoji(self, status_code: int) -> str:
+        """Get emoji for HTTP status code."""
+        if 200 <= status_code < 300:
+            return "✅"  # Success
+        elif 300 <= status_code < 400:
+            return "↩️"  # Redirect
+        elif 400 <= status_code < 500:
+            return "⚠️"  # Client error
+        elif 500 <= status_code < 600:
+            return "❌"  # Server error
+        else:
+            return "❓"  # Unknown
+
+
+# Auto-register HTTP transport
+def _register_http_transport():
+    """Register HTTP transport with the Hub."""
+    try:
+        from provide.foundation.transport.registry import register_transport
+        
+        register_transport(
+            TransportType.HTTP,
+            HTTPTransport,
+            schemes=HTTPTransport.SCHEMES,
+            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", 
+            version="1.0.0",
+        )
+        
+    except ImportError:
+        # Registry not available yet, will be registered later
+        pass
+
+
+# Register when module is imported
+_register_http_transport()
+
+
+__all__ = [
+    "HTTPTransport",
+]