jararaca 0.3.11a16__py3-none-any.whl → 0.3.12__py3-none-any.whl

jararaca/rpc/http/backends/httpx.py

@@ -1,3 +1,4 @@
+import time
 from urllib.parse import urljoin
 
 import httpx
@@ -7,34 +8,63 @@ from jararaca.rpc.http.decorators import (
     HttpRPCRequest,
     HttpRPCResponse,
     RPCRequestNetworkError,
+    TimeoutException,
 )
 
 
 class HTTPXHttpRPCAsyncBackend(HttpRPCAsyncBackend):
 
-    def __init__(self, prefix_url: str = ""):
+    def __init__(self, prefix_url: str = "", default_timeout: float = 30.0):
         self.prefix_url = prefix_url
+        self.default_timeout = default_timeout
 
     async def request(
         self,
         request: HttpRPCRequest,
     ) -> HttpRPCResponse:
 
-        async with httpx.AsyncClient() as client:
+        start_time = time.time()
+
+        # Prepare timeout
+        timeout = (
+            request.timeout if request.timeout is not None else self.default_timeout
+        )
+
+        # Prepare request kwargs
+        request_kwargs = {
+            "method": request.method,
+            "url": urljoin(self.prefix_url, request.url),
+            "headers": request.headers,
+            "params": request.query_params,
+            "timeout": timeout,
+        }
+
+        # Handle different content types
+        if request.form_data and request.files:
+            # Multipart form data with files
+            request_kwargs["data"] = request.form_data
+            request_kwargs["files"] = request.files
+        elif request.form_data:
+            # Form data only
+            request_kwargs["data"] = request.form_data
+        elif request.body:
+            # Raw body content
+            request_kwargs["content"] = request.body
 
+        async with httpx.AsyncClient() as client:
             try:
-                response = await client.request(
-                    method=request.method,
-                    url=urljoin(self.prefix_url, request.url),
-                    headers=request.headers,
-                    params=request.query_params,
-                    content=request.body,
-                )
+                response = await client.request(**request_kwargs)  # type: ignore[arg-type]
+
+                elapsed_time = time.time() - start_time
 
                 return HttpRPCResponse(
                     status_code=response.status_code,
                     data=response.content,
+                    headers=dict(response.headers),
+                    elapsed_time=elapsed_time,
                 )
+            except httpx.TimeoutException as err:
+                raise TimeoutException(f"Request timed out: {err}") from err
             except httpx.NetworkError as err:
                 raise RPCRequestNetworkError(
                     request=request, backend_request=err.request

jararaca/rpc/http/decorators.py

@@ -1,11 +1,16 @@
+import asyncio
 import inspect
+import json
+import time
 from dataclasses import dataclass
 from typing import (
     Any,
     Awaitable,
     Callable,
+    Dict,
     Iterable,
     Literal,
+    Optional,
     Protocol,
     Type,
     TypeVar,
@@ -15,6 +20,11 @@ from typing import (
 from pydantic import BaseModel
 
 DECORATED_FUNC = TypeVar("DECORATED_FUNC", bound=Callable[..., Awaitable[Any]])
+DECORATED_CLASS = TypeVar("DECORATED_CLASS", bound=Any)
+
+
+class TimeoutException(Exception):
+    """Exception raised when a request times out"""
 
 
 class HttpMapping:
@@ -95,7 +105,9 @@ class RequestAttribute:
         return []
 
     def __init__(
-        self, attribute_type: Literal["query", "header", "body", "param"], name: str
+        self,
+        attribute_type: Literal["query", "header", "body", "param", "form", "file"],
+        name: str,
     ):
         self.attribute_type = attribute_type
         self.name = name
@@ -129,7 +141,105 @@ class PathParam(RequestAttribute):
         super().__init__("param", name)
 
 
-DECORATED_CLASS = TypeVar("DECORATED_CLASS", bound=Any)
+class FormData(RequestAttribute):
+    """Decorator for form data parameters"""
+
+    def __init__(self, name: str):
+        super().__init__("form", name)
+
+
+class File(RequestAttribute):
+    """Decorator for file upload parameters"""
+
+    def __init__(self, name: str):
+        super().__init__("file", name)
+
+
+class Timeout:
+    """Decorator for setting request timeout"""
+
+    TIMEOUT_ATTR = "__request_timeout__"
+
+    def __init__(self, seconds: float):
+        self.seconds = seconds
+
+    def __call__(self, func: DECORATED_FUNC) -> DECORATED_FUNC:
+        setattr(func, self.TIMEOUT_ATTR, self)
+        return func
+
+    @staticmethod
+    def get(func: DECORATED_FUNC) -> Optional["Timeout"]:
+        return getattr(func, Timeout.TIMEOUT_ATTR, None)
+
+
+class RetryConfig:
+    """Configuration for retry behavior"""
+
+    def __init__(
+        self,
+        max_attempts: int = 3,
+        backoff_factor: float = 1.0,
+        retry_on_status_codes: Optional[list[int]] = None,
+    ):
+        self.max_attempts = max_attempts
+        self.backoff_factor = backoff_factor
+        self.retry_on_status_codes = retry_on_status_codes or [500, 502, 503, 504]
+
+
+class Retry:
+    """Decorator for retry configuration"""
+
+    RETRY_ATTR = "__request_retry__"
+
+    def __init__(self, config: RetryConfig):
+        self.config = config
+
+    def __call__(self, func: DECORATED_FUNC) -> DECORATED_FUNC:
+        setattr(func, self.RETRY_ATTR, self)
+        return func
+
+    @staticmethod
+    def get(func: DECORATED_FUNC) -> Optional["Retry"]:
+        return getattr(func, Retry.RETRY_ATTR, None)
+
+
+class ContentType:
+    """Decorator for specifying content type"""
+
+    CONTENT_TYPE_ATTR = "__content_type__"
+
+    def __init__(self, content_type: str):
+        self.content_type = content_type
+
+    def __call__(self, func: DECORATED_FUNC) -> DECORATED_FUNC:
+        setattr(func, self.CONTENT_TYPE_ATTR, self)
+        return func
+
+    @staticmethod
+    def get(func: DECORATED_FUNC) -> Optional["ContentType"]:
+        return getattr(func, ContentType.CONTENT_TYPE_ATTR, None)
+
+
+class ResponseMiddleware(Protocol):
+    """Protocol for response middleware"""
+
+    def on_response(
+        self, request: "HttpRPCRequest", response: "HttpRPCResponse"
+    ) -> "HttpRPCResponse": ...
+
+
+class RequestHook(Protocol):
+    """Protocol for request hooks"""
+
+    def before_request(self, request: "HttpRPCRequest") -> "HttpRPCRequest": ...
+
+
+class ResponseHook(Protocol):
+    """Protocol for response hooks"""
+
+    def after_response(
+        self, request: "HttpRPCRequest", response: "HttpRPCResponse"
+    ) -> "HttpRPCResponse": ...
 
 
 class RestClient:
@@ -159,9 +269,10 @@ class RestClient:
 
 @dataclass
 class HttpRPCResponse:
-
     status_code: int
     data: bytes
+    headers: Optional[Dict[str, str]] = None
+    elapsed_time: Optional[float] = None
 
 
 @dataclass
@@ -171,6 +282,9 @@ class HttpRPCRequest:
     headers: list[tuple[str, str]]
     query_params: dict[str, str]
     body: bytes | None
+    timeout: Optional[float] = None
+    form_data: Optional[Dict[str, Any]] = None
+    files: Optional[Dict[str, Any]] = None
 
 
 class RPCRequestNetworkError(Exception):
@@ -275,15 +389,130 @@ class RequestMiddleware(Protocol):
     def on_request(self, request: HttpRPCRequest) -> HttpRPCRequest: ...
 
 
+class AuthenticationMiddleware(RequestMiddleware):
+    """Base class for authentication middleware"""
+
+    def on_request(self, request: HttpRPCRequest) -> HttpRPCRequest:
+        return self.add_auth(request)
+
+    def add_auth(self, request: HttpRPCRequest) -> HttpRPCRequest:
+        raise NotImplementedError
+
+
+class BearerTokenAuth(AuthenticationMiddleware):
+    """Bearer token authentication middleware"""
+
+    def __init__(self, token: str):
+        self.token = token
+
+    def add_auth(self, request: HttpRPCRequest) -> HttpRPCRequest:
+        request.headers.append(("Authorization", f"Bearer {self.token}"))
+        return request
+
+
+class BasicAuth(AuthenticationMiddleware):
+    """Basic authentication middleware"""
+
+    def __init__(self, username: str, password: str):
+        import base64
+
+        credentials = base64.b64encode(f"{username}:{password}".encode()).decode()
+        self.credentials = credentials
+
+    def add_auth(self, request: HttpRPCRequest) -> HttpRPCRequest:
+        request.headers.append(("Authorization", f"Basic {self.credentials}"))
+        return request
+
+
+class ApiKeyAuth(AuthenticationMiddleware):
+    """API key authentication middleware"""
+
+    def __init__(self, api_key: str, header_name: str = "X-API-Key"):
+        self.api_key = api_key
+        self.header_name = header_name
+
+    def add_auth(self, request: HttpRPCRequest) -> HttpRPCRequest:
+        request.headers.append((self.header_name, self.api_key))
+        return request
+
+
+class CacheMiddleware(RequestMiddleware):
+    """Simple in-memory cache middleware"""
+
+    def __init__(self, ttl_seconds: int = 300):
+        self.cache: Dict[str, tuple[Any, float]] = {}
+        self.ttl_seconds = ttl_seconds
+
+    def _cache_key(self, request: HttpRPCRequest) -> str:
+        """Generate cache key from request"""
+        key_data = {
+            "method": request.method,
+            "url": request.url,
+            "query_params": request.query_params,
+            "headers": sorted(request.headers),
+        }
+        return str(hash(json.dumps(key_data, sort_keys=True)))
+
+    def on_request(self, request: HttpRPCRequest) -> HttpRPCRequest:
+        # Only cache GET requests
+        if request.method == "GET":
+            cache_key = self._cache_key(request)
+            if cache_key in self.cache:
+                cached_response, timestamp = self.cache[cache_key]
+                if time.time() - timestamp < self.ttl_seconds:
+                    # Return cached response (this needs to be handled in the client builder)
+                    setattr(request, "_cached_response", cached_response)
+        return request
+
+
 class HttpRpcClientBuilder:
 
     def __init__(
         self,
         backend: HttpRPCAsyncBackend,
         middlewares: list[RequestMiddleware] = [],
+        response_middlewares: list[ResponseMiddleware] = [],
+        request_hooks: list[RequestHook] = [],
+        response_hooks: list[ResponseHook] = [],
     ):
         self._backend = backend
         self._middlewares = middlewares
+        self._response_middlewares = response_middlewares
+        self._request_hooks = request_hooks
+        self._response_hooks = response_hooks
+
+    async def _execute_with_retry(
+        self, request: HttpRPCRequest, retry_config: Optional[RetryConfig]
+    ) -> HttpRPCResponse:
+        """Execute request with retry logic"""
+        if not retry_config:
+            return await self._backend.request(request)
+
+        last_exception = None
+        for attempt in range(retry_config.max_attempts):
+            try:
+                response = await self._backend.request(request)
+
+                # Check if we should retry based on status code
+                if response.status_code in retry_config.retry_on_status_codes:
+                    if attempt < retry_config.max_attempts - 1:
+                        wait_time = retry_config.backoff_factor * (2**attempt)
+                        await asyncio.sleep(wait_time)
+                        continue
+
+                return response
+
+            except Exception as e:
+                last_exception = e
+                if attempt < retry_config.max_attempts - 1:
+                    wait_time = retry_config.backoff_factor * (2**attempt)
+                    await asyncio.sleep(wait_time)
+                    continue
+                else:
+                    raise
+
+        # This should never be reached, but just in case
+        raise last_exception or Exception("Retry failed")
 
     def build(self, cls: type[T]) -> T:
         rest_client = RestClient.get(cls)
@@ -314,10 +543,17 @@ class HttpRpcClientBuilder:
                 headers: list[tuple[str, str]] = []
                 query_params = {}
                 body: Any = None
+                form_data: Dict[str, Any] = {}
+                files: Dict[str, Any] = {}
                 compiled_path = (
                     rest_client.base_path.rstrip("/") + "/" + mapping.path.lstrip("/")
                 )
 
+                # Get decorators for this method
+                timeout_config = Timeout.get(method_call)
+                retry_config = Retry.get(method_call)
+                content_type_config = ContentType.get(method_call)
+
                 for attr in request_attributes:
                     if attr.attribute_type == "header":
                         headers.append((attr.name, compiled_kwargs[attr.name]))
@@ -329,17 +565,33 @@ class HttpRpcClientBuilder:
                         compiled_path = compiled_path.replace(
                             f":{attr.name}", str(compiled_kwargs[attr.name])
                         )
+                    elif attr.attribute_type == "form":
+                        form_data[attr.name] = compiled_kwargs[attr.name]
+                    elif attr.attribute_type == "file":
+                        files[attr.name] = compiled_kwargs[attr.name]
 
                 body_content: bytes | None = None
 
+                # Handle different content types
                 if body is not None:
                     if isinstance(body, BaseModel):
                         body_content = body.model_dump_json().encode()
-                        headers.append(("Content-Type", "application/json"))
+                        if not content_type_config:
+                            headers.append(("Content-Type", "application/json"))
                     elif isinstance(body, bytes):
                         body_content = body
+                    elif isinstance(body, str):
+                        body_content = body.encode()
+                    elif isinstance(body, dict):
+                        body_content = json.dumps(body).encode()
+                        if not content_type_config:
+                            headers.append(("Content-Type", "application/json"))
                     else:
-                        raise ValueError("Invalid body type")
+                        raise ValueError(f"Invalid body type: {type(body)}")
+
+                # Apply custom content type if specified
+                if content_type_config:
+                    headers.append(("Content-Type", content_type_config.content_type))
 
                 request = HttpRPCRequest(
                     url=compiled_path,
@@ -347,12 +599,41 @@ class HttpRpcClientBuilder:
                     headers=headers,
                     query_params=query_params,
                     body=body_content,
+                    timeout=timeout_config.seconds if timeout_config else None,
+                    form_data=form_data if form_data else None,
+                    files=files if files else None,
                 )
 
+                # Apply request hooks
+                for hook in self._request_hooks:
+                    request = hook.before_request(request)
+
                 for middleware in self._middlewares:
                     request = middleware.on_request(request)
 
-                response = await self._backend.request(request)
+                # Check for cached response
+                if hasattr(request, "_cached_response"):
+                    response = getattr(request, "_cached_response")
+                else:
+                    # Execute request with retry if configured
+                    response = await self._execute_with_retry(
+                        request, retry_config.config if retry_config else None
+                    )
+
+                # Apply response middleware
+                for response_middleware in self._response_middlewares:
+                    response = response_middleware.on_response(request, response)
+
+                # Apply response hooks
+                for response_hook in self._response_hooks:
+                    response = response_hook.after_response(request, response)
+
+                # Cache response if using cache middleware and it's a GET request
+                if request.method == "GET":
+                    for middleware in self._middlewares:
+                        if isinstance(middleware, CacheMiddleware):
+                            cache_key = middleware._cache_key(request)
+                            middleware.cache[cache_key] = (response, time.time())
 
                 return_type = inspect.signature(method_call).return_annotation
 
@@ -407,13 +688,28 @@ __all__ = [
     "Header",
     "Body",
     "PathParam",
+    "FormData",
+    "File",
+    "Timeout",
+    "RetryConfig",
+    "Retry",
+    "ContentType",
     "RestClient",
     "HttpRPCAsyncBackend",
     "HttpRPCRequest",
     "HttpRPCResponse",
     "RPCRequestNetworkError",
+    "RPCUnhandleError",
     "HttpRpcClientBuilder",
     "RequestMiddleware",
+    "ResponseMiddleware",
+    "RequestHook",
+    "ResponseHook",
+    "AuthenticationMiddleware",
+    "BearerTokenAuth",
+    "BasicAuth",
+    "ApiKeyAuth",
+    "CacheMiddleware",
     "TracedRequestMiddleware",
     "GlobalHttpErrorHandler",
     "RouteHttpErrorHandler",