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

provide/foundation/transport/client.py

@@ -9,7 +9,10 @@ from attrs import define, field
 
 from provide.foundation.logger import get_logger
 from provide.foundation.transport.base import Request, Response
-from provide.foundation.transport.middleware import MiddlewarePipeline, create_default_pipeline
+from provide.foundation.transport.middleware import (
+    MiddlewarePipeline,
+    create_default_pipeline,
+)
 from provide.foundation.transport.registry import get_transport
 from provide.foundation.transport.types import Data, Headers, HTTPMethod, Params
 
@@ -19,12 +22,12 @@ log = get_logger(__name__)
 @define
 class UniversalClient:
     """Universal client that works with any transport via Hub registry."""
-    
+
     middleware: MiddlewarePipeline = field(factory=create_default_pipeline)
     default_headers: Headers = field(factory=dict)
     default_timeout: float | None = field(default=None)
     _transports: dict[str, Any] = field(factory=dict, init=False)
-    
+
     async def request(
         self,
         uri: str,
@@ -34,11 +37,11 @@ class UniversalClient:
         params: Params | None = None,
         body: Data = None,
         timeout: float | None = None,
-        **kwargs
+        **kwargs,
     ) -> Response:
         """
         Make a request using appropriate transport.
-        
+
         Args:
             uri: Full URI to make request to
             method: HTTP method or protocol-specific method
@@ -47,19 +50,19 @@ class UniversalClient:
             body: Request body (dict for JSON, str/bytes for raw)
             timeout: Request timeout override
             **kwargs: Additional request metadata
-            
+
         Returns:
             Response from the transport
         """
         # Normalize method
         if isinstance(method, HTTPMethod):
             method = method.value
-        
+
         # Merge headers
         request_headers = dict(self.default_headers)
         if headers:
             request_headers.update(headers)
-        
+
         # Create request object
         request = Request(
             uri=uri,
@@ -70,92 +73,86 @@ class UniversalClient:
             timeout=timeout or self.default_timeout,
             metadata=kwargs,
         )
-        
+
         # Process through middleware
         request = await self.middleware.process_request(request)
-        
+
         try:
             # Get transport for this URI
             transport = await self._get_transport(request.transport_type.value)
-            
+
             # Execute request
             response = await transport.execute(request)
-            
+
             # Process response through middleware
             response = await self.middleware.process_response(response)
-            
+
             return response
-            
+
         except Exception as e:
             # Process error through middleware
             e = await self.middleware.process_error(e, request)
             raise e
-    
+
     async def stream(
-        self,
-        uri: str,
-        method: str | HTTPMethod = HTTPMethod.GET,
-        **kwargs
+        self, uri: str, method: str | HTTPMethod = HTTPMethod.GET, **kwargs
     ) -> AsyncIterator[bytes]:
         """
         Stream data from URI.
-        
+
         Args:
             uri: URI to stream from
             method: HTTP method or protocol-specific method
             **kwargs: Additional request parameters
-            
+
         Yields:
             Chunks of response data
         """
         # Normalize method
         if isinstance(method, HTTPMethod):
             method = method.value
-        
+
         # Create request
         request = Request(
-            uri=uri,
-            method=method,
-            headers=dict(self.default_headers),
-            **kwargs
+            uri=uri, method=method, headers=dict(self.default_headers), **kwargs
         )
-        
+
         # Get transport
         transport = await self._get_transport(request.transport_type.value)
-        
+
         # Stream response
         log.info(f"🌊 Streaming {method} {uri}")
         async for chunk in transport.stream(request):
             yield chunk
-    
+
     async def get(self, uri: str, **kwargs) -> Response:
         """GET request."""
         return await self.request(uri, HTTPMethod.GET, **kwargs)
-    
+
     async def post(self, uri: str, **kwargs) -> Response:
         """POST request."""
         return await self.request(uri, HTTPMethod.POST, **kwargs)
-    
+
     async def put(self, uri: str, **kwargs) -> Response:
         """PUT request."""
         return await self.request(uri, HTTPMethod.PUT, **kwargs)
-    
+
     async def patch(self, uri: str, **kwargs) -> Response:
         """PATCH request."""
         return await self.request(uri, HTTPMethod.PATCH, **kwargs)
-    
+
     async def delete(self, uri: str, **kwargs) -> Response:
         """DELETE request."""
         return await self.request(uri, HTTPMethod.DELETE, **kwargs)
-    
+
     async def head(self, uri: str, **kwargs) -> Response:
         """HEAD request."""
         return await self.request(uri, HTTPMethod.HEAD, **kwargs)
-    
+
     async def options(self, uri: str, **kwargs) -> Response:
         """OPTIONS request."""
         return await self.request(uri, HTTPMethod.OPTIONS, **kwargs)
-    
+
     async def _get_transport(self, scheme: str) -> Any:
         """Get or create transport for scheme."""
         if scheme not in self._transports:
@@ -163,13 +160,13 @@ class UniversalClient:
             transport = get_transport(f"{scheme}://example.com")
             await transport.connect()
             self._transports[scheme] = transport
-        
+
         return self._transports[scheme]
-    
+
     async def __aenter__(self) -> "UniversalClient":
         """Context manager entry."""
         return self
-    
+
     async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
         """Context manager exit - cleanup all transports."""
         for transport in self._transports.values():
@@ -193,9 +190,7 @@ def get_default_client() -> UniversalClient:
 
 
 async def request(
-    uri: str,
-    method: str | HTTPMethod = HTTPMethod.GET,
-    **kwargs
+    uri: str, method: str | HTTPMethod = HTTPMethod.GET, **kwargs
 ) -> Response:
     """Make a request using the default client."""
     client = get_default_client()
@@ -253,14 +248,14 @@ async def stream(uri: str, **kwargs) -> AsyncIterator[bytes]:
 
 __all__ = [
     "UniversalClient",
-    "get_default_client",
-    "request",
-    "get",
-    "post",
-    "put", 
-    "patch",
     "delete",
+    "get",
+    "get_default_client",
     "head",
     "options",
+    "patch",
+    "post",
+    "put",
+    "request",
     "stream",
-]
+]

provide/foundation/transport/config.py

@@ -4,7 +4,6 @@ Transport configuration with Foundation config integration.
 
 from attrs import define
 
-from provide.foundation.config.env import RuntimeConfig
 from provide.foundation.config.base import field
 from provide.foundation.config.converters import (
     parse_bool_extended,
@@ -12,6 +11,7 @@ from provide.foundation.config.converters import (
     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.logger import get_logger
@@ -22,7 +22,7 @@ log = get_logger(__name__)
 @define(slots=True, repr=False)
 class TransportConfig(RuntimeConfig):
     """Base configuration for all transports."""
-    
+
     timeout: float = field(
         default=30.0,
         env_var="PROVIDE_TRANSPORT_TIMEOUT",
@@ -50,13 +50,12 @@ class TransportConfig(RuntimeConfig):
         converter=parse_bool_extended,
         description="Whether to verify SSL certificates",
     )
-    
 
 
 @define(slots=True, repr=False)
 class HTTPConfig(TransportConfig):
     """HTTP-specific configuration."""
-    
+
     pool_connections: int = field(
         default=10,
         env_var="PROVIDE_HTTP_POOL_CONNECTIONS",
@@ -90,7 +89,6 @@ class HTTPConfig(TransportConfig):
         validator=validate_non_negative,
         description="Maximum number of redirects to follow",
     )
-    
 
 
 async def register_transport_configs() -> None:
@@ -106,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
@@ -124,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",
-]
+]