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

provide/foundation/transport/__init__.py

@@ -14,28 +14,28 @@ Key Features:
 
 Example Usage:
     >>> from provide.foundation.transport import get, post
-    >>> 
+    >>>
     >>> # Simple requests
     >>> response = await get("https://api.example.com/users")
     >>> data = response.json()
-    >>> 
+    >>>
     >>> # POST with JSON body
     >>> response = await post(
     ...     "https://api.example.com/users",
     ...     body={"name": "John", "email": "john@example.com"}
     ... )
-    >>> 
+    >>>
     >>> # Using client for multiple requests
     >>> from provide.foundation.transport import UniversalClient
-    >>> 
+    >>>
     >>> async with UniversalClient() as client:
     ...     users = await client.get("https://api.example.com/users")
     ...     posts = await client.get("https://api.example.com/posts")
-    >>> 
+    >>>
     >>> # Custom transport registration
     >>> from provide.foundation.transport import register_transport
     >>> from provide.foundation.transport.types import TransportType
-    >>> 
+    >>>
     >>> register_transport(TransportType("custom"), MyCustomTransport)
 
 Environment Configuration:
@@ -43,7 +43,7 @@ Environment Configuration:
     TRANSPORT_MAX_RETRIES=3
     TRANSPORT_RETRY_BACKOFF_FACTOR=0.5
     TRANSPORT_VERIFY_SSL=true
-    
+
     HTTP_POOL_CONNECTIONS=10
     HTTP_POOL_MAXSIZE=100
     HTTP_FOLLOW_REDIRECTS=true
@@ -54,9 +54,23 @@ Environment Configuration:
 # Core transport abstractions
 from provide.foundation.transport.base import Request, Response
 
+# High-level client API
+from provide.foundation.transport.client import (
+    UniversalClient,
+    delete,
+    get,
+    get_default_client,
+    head,
+    options,
+    patch,
+    post,
+    put,
+    request,
+    stream,
+)
+
 # Transport types and configuration
 from provide.foundation.transport.config import HTTPConfig, TransportConfig
-from provide.foundation.transport.types import HTTPMethod, TransportType
 
 # Error types
 from provide.foundation.transport.errors import (
@@ -87,45 +101,26 @@ from provide.foundation.transport.registry import (
     list_registered_transports,
     register_transport,
 )
-
-# High-level client API
-from provide.foundation.transport.client import (
-    UniversalClient,
-    delete,
-    get,
-    get_default_client,
-    head,
-    options,
-    patch,
-    post,
-    put,
-    request,
-    stream,
-)
+from provide.foundation.transport.types import HTTPMethod, TransportType
 
 __all__ = [
     # Core abstractions
     "Request",
     "Response",
-    
     # Configuration
     "TransportConfig",
     "HTTPConfig",
-    
     # Types
     "TransportType",
     "HTTPMethod",
-    
     # Errors
     "TransportError",
     "TransportConnectionError",
-    "TransportTimeoutError", 
+    "TransportTimeoutError",
     "HTTPResponseError",
     "TransportNotFoundError",
-    
     # Transport implementations
     "HTTPTransport",
-    
     # Middleware
     "Middleware",
     "MiddlewarePipeline",
@@ -133,13 +128,11 @@ __all__ = [
     "RetryMiddleware",
     "MetricsMiddleware",
     "create_default_pipeline",
-    
     # Registry
     "register_transport",
     "get_transport",
     "get_transport_info",
     "list_registered_transports",
-    
     # Client API
     "UniversalClient",
     "get_default_client",
@@ -147,9 +140,9 @@ __all__ = [
     "get",
     "post",
     "put",
-    "patch", 
+    "patch",
     "delete",
     "head",
     "options",
     "stream",
-]
+]

provide/foundation/transport/base.py

@@ -2,7 +2,6 @@
 Core transport abstractions.
 """
 
-import time
 from abc import ABC, abstractmethod
 from collections.abc import AsyncIterator
 from typing import Any, Protocol, runtime_checkable
@@ -18,7 +17,7 @@ log = get_logger(__name__)
 @define
 class Request:
     """Protocol-agnostic request."""
-    
+
     uri: str
     method: str = "GET"
     headers: Headers = field(factory=dict)
@@ -26,7 +25,7 @@ class Request:
     body: Data = None
     timeout: float | None = None
     metadata: dict[str, Any] = field(factory=dict)
-    
+
     @property
     def transport_type(self) -> TransportType:
         """Infer transport type from URI scheme."""
@@ -36,7 +35,7 @@ class Request:
         except ValueError:
             log.trace(f"Unknown scheme '{scheme}', defaulting to HTTP")
             return TransportType.HTTP
-    
+
     @property
     def base_url(self) -> str:
         """Extract base URL from URI."""
@@ -49,43 +48,44 @@ class Request:
 @define
 class Response:
     """Protocol-agnostic response."""
-    
+
     status: int
     headers: Headers = field(factory=dict)
     body: bytes | str | None = None
     metadata: dict[str, Any] = field(factory=dict)
     elapsed_ms: float = 0
     request: Request | None = None
-    
+
     def is_success(self) -> bool:
         """Check if response indicates success."""
         return 200 <= self.status < 300
-    
+
     def json(self) -> Any:
         """Parse response body as JSON."""
         import json
-        
+
         if isinstance(self.body, bytes):
-            return json.loads(self.body.decode('utf-8'))
+            return json.loads(self.body.decode("utf-8"))
         elif isinstance(self.body, str):
             return json.loads(self.body)
         else:
             raise ValueError("Response body is not JSON-parseable")
-    
+
     @property
     def text(self) -> str:
         """Get response body as text."""
         if isinstance(self.body, bytes):
-            return self.body.decode('utf-8')
+            return self.body.decode("utf-8")
         elif isinstance(self.body, str):
             return self.body
         else:
             return str(self.body or "")
-    
+
     def raise_for_status(self) -> None:
         """Raise error if response status indicates failure."""
         if not self.is_success():
             from provide.foundation.transport.errors import HTTPResponseError
+
             raise HTTPResponseError(
                 f"Request failed with status {self.status}",
                 status_code=self.status,
@@ -96,32 +96,32 @@ class Response:
 @runtime_checkable
 class Transport(Protocol):
     """Abstract transport protocol."""
-    
+
     async def execute(self, request: Request) -> Response:
         """Execute a request and return response."""
         ...
-    
+
     async def stream(self, request: Request) -> AsyncIterator[bytes]:
         """Stream response data."""
         ...
-    
+
     async def connect(self) -> None:
         """Establish connection if needed."""
         ...
-    
+
     async def disconnect(self) -> None:
         """Close connection if needed."""
         ...
-    
+
     def supports(self, transport_type: TransportType) -> bool:
         """Check if this transport handles the given type."""
         ...
-    
+
     async def __aenter__(self) -> "Transport":
         """Context manager entry."""
         await self.connect()
         return self
-    
+
     async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
         """Context manager exit."""
         await self.disconnect()
@@ -129,43 +129,45 @@ class Transport(Protocol):
 
 class TransportBase(ABC):
     """Base class for transport implementations."""
-    
+
     def __init__(self):
         self._logger = get_logger(self.__class__.__name__)
-    
+
     @abstractmethod
     async def execute(self, request: Request) -> Response:
         """Execute a request and return response."""
         pass
-    
+
     @abstractmethod
     def supports(self, transport_type: TransportType) -> bool:
         """Check if this transport handles the given type."""
         pass
-    
+
     async def connect(self) -> None:
         """Default connect implementation."""
         self._logger.trace("Transport connecting")
-    
+
     async def disconnect(self) -> None:
         """Default disconnect implementation."""
         self._logger.trace("Transport disconnecting")
-    
+
     async def stream(self, request: Request) -> AsyncIterator[bytes]:
         """Default streaming implementation (not supported)."""
-        raise NotImplementedError(f"{self.__class__.__name__} does not support streaming")
-    
+        raise NotImplementedError(
+            f"{self.__class__.__name__} does not support streaming"
+        )
+
     async def __aenter__(self) -> "TransportBase":
         await self.connect()
         return self
-    
+
     async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
         await self.disconnect()
 
 
 __all__ = [
     "Request",
-    "Response", 
+    "Response",
     "Transport",
     "TransportBase",
-]
+]

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",
-]
+]