hypern 0.3.0__cp312-cp312-win32.whl → 0.3.2__cp312-cp312-win32.whl

hypern/gateway/proxy.py

@@ -0,0 +1,60 @@
+import asyncio
+from typing import Any, Dict, Optional
+
+import aiohttp
+import orjson
+import traceback
+
+from hypern.hypern import Request
+from hypern.response import JSONResponse
+
+from .service import ServiceConfig, ServiceRegistry, ServiceStatus
+
+
+class Proxy:
+    def __init__(self, service_registry: ServiceRegistry):
+        self._registry = service_registry
+        self._session: Optional[aiohttp.ClientSession] = None
+        self._rate_limiters: Dict[str, asyncio.Semaphore] = {}
+
+    async def startup(self):
+        self._session = aiohttp.ClientSession()
+        for service in self._registry._services.values():
+            self._rate_limiters[service.name] = asyncio.Semaphore(100)  # Default 100 concurrent requests
+
+    async def shutdown(self):
+        if self._session:
+            await self._session.close()
+
+    async def forward_request(self, service: ServiceConfig, request: Request) -> Any:
+        if not self._session:
+            await self.startup()
+
+        target_path = request.path.replace(service.prefix, "", 1)
+        target_url = f"{service.url}{target_path}"
+
+        headers = request.headers.get_headers()
+        # Remove hop-by-hop headers
+        for header in ["connection", "keep-alive", "transfer-encoding"]:
+            headers.pop(header, None)
+
+        async with self._rate_limiters[service.name]:
+            try:
+                async with self._session.request(
+                    method=request.method,
+                    url=target_url,
+                    headers=headers,
+                    params=request.query_params.to_dict(),
+                    data=await request.json() if request.method in ["POST", "PUT", "PATCH"] else None,
+                    timeout=aiohttp.ClientTimeout(total=service.timeout),
+                ) as response:
+                    body = await response.read()
+                    return JSONResponse(
+                        content=orjson.loads(body) if response.content_type == "application/json" else body.decode(),
+                        status_code=response.status,
+                        headers=dict(response.headers),
+                    )
+            except Exception as e:
+                traceback.print_exc()
+                self._registry.update_status(service.name, ServiceStatus.DEGRADED)
+                return JSONResponse(content={"error": "Service unavailable", "details": str(e)}, status_code=503)

hypern/gateway/service.py

@@ -0,0 +1,52 @@
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any, Dict, Optional
+
+
+class ServiceStatus(Enum):
+    ONLINE = "online"
+    OFFLINE = "offline"
+    DEGRADED = "degraded"
+
+
+@dataclass
+class ServiceConfig:
+    name: str
+    url: str
+    prefix: str
+    timeout: float = 30.0
+    max_retries: int = 3
+    health_check_path: str = "/health"
+
+
+class ServiceRegistry:
+    def __init__(self):
+        self._services: Dict[str, ServiceConfig] = {}
+        self._status: Dict[str, ServiceStatus] = {}
+        self._metadata: Dict[str, Dict[str, Any]] = {}
+
+    def register(self, service: ServiceConfig, metadata: Optional[Dict[str, Any]] = None):
+        self._services[service.name] = service
+        self._status[service.name] = ServiceStatus.ONLINE
+        self._metadata[service.name] = metadata or {}
+
+    def unregister(self, service_name: str):
+        self._services.pop(service_name, None)
+        self._status.pop(service_name, None)
+        self._metadata.pop(service_name, None)
+
+    def get_service(self, service_name: str) -> Optional[ServiceConfig]:
+        return self._services.get(service_name)
+
+    def get_service_by_prefix(self, path: str) -> Optional[ServiceConfig]:
+        for service in self._services.values():
+            if path.startswith(service.prefix):
+                return service
+        return None
+
+    def update_status(self, service_name: str, status: ServiceStatus):
+        if service_name in self._services:
+            self._status[service_name] = status
+
+    def get_status(self, service_name: str) -> ServiceStatus:
+        return self._status.get(service_name, ServiceStatus.OFFLINE)

hypern/hypern.pyi

@@ -3,20 +3,6 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Any, Callable, Dict, List, Tuple
 
-@dataclass
-class BaseBackend:
-    get: Callable[[str], Any]
-    set: Callable[[Any, str, int], None]
-    delete_startswith: Callable[[str], None]
-
-@dataclass
-class RedisBackend(BaseBackend):
-    url: str
-
-    get: Callable[[str], Any]
-    set: Callable[[Any, str, int], None]
-    delete_startswith: Callable[[str], None]
-
 @dataclass
 class BaseSchemaGenerator:
     remove_converter: Callable[[str], str]
@@ -199,6 +185,9 @@ class Server:
     def set_before_hooks(self, hooks: List[FunctionInfo]) -> None: ...
     def set_after_hooks(self, hooks: List[FunctionInfo]) -> None: ...
     def set_response_headers(self, headers: Dict[str, str]) -> None: ...
+    def set_startup_handler(self, on_startup: FunctionInfo) -> None: ...
+    def set_shutdown_handler(self, on_shutdown: FunctionInfo) -> None: ...
+    def set_auto_compression(self, enabled: bool) -> None: ...
 
 class Route:
     path: str
@@ -257,18 +246,27 @@ class WebsocketRouter:
 class Header:
     headers: Dict[str, str]
 
+    def get(self, key: str) -> str | None: ...
+    def set(self, key: str, value: str) -> None: ...
+    def append(self, key: str, value: str) -> None: ...
+    def update(self, headers: Dict[str, str]) -> None: ...
+    def get_headers(self) -> Dict[str, str]: ...
+
 @dataclass
 class Response:
     status_code: int
     response_type: str
-    headers: Any
+    headers: Header
     description: str
-    file_path: str
+    file_path: str | None
+    context_id: str
 
 @dataclass
 class QueryParams:
     queries: Dict[str, List[str]]
 
+    def to_dict(self) -> Dict[str, str]: ...
+
 @dataclass
 class UploadedFile:
     name: str
@@ -285,11 +283,23 @@ class BodyData:
 
 @dataclass
 class Request:
+    path: str
     query_params: QueryParams
-    headers: Dict[str, str]
+    headers: Header
     path_params: Dict[str, str]
     body: BodyData
     method: str
     remote_addr: str
     timestamp: float
     context_id: str
+
+    def json(self) -> Dict[str, Any]: ...
+    def set_body(self, body: BodyData) -> None: ...
+
+@dataclass
+class MiddlewareConfig:
+    priority: int = 0
+    is_conditional: bool = True
+
+    @staticmethod
+    def default(self) -> MiddlewareConfig: ...

hypern/middleware/__init__.py

@@ -1,5 +1,17 @@
-from .base import Middleware
+from .base import Middleware, MiddlewareConfig
 from .cors import CORSMiddleware
 from .limit import RateLimitMiddleware, StorageBackend, RedisBackend, InMemoryBackend
+from .compress import CompressionMiddleware
+from .cache import EdgeCacheMiddleware
 
-__all__ = ["Middleware", "CORSMiddleware", "RateLimitMiddleware", "StorageBackend", "RedisBackend", "InMemoryBackend"]
+__all__ = [
+    "Middleware",
+    "CORSMiddleware",
+    "RateLimitMiddleware",
+    "StorageBackend",
+    "RedisBackend",
+    "InMemoryBackend",
+    "CompressionMiddleware",
+    "EdgeCacheMiddleware",
+    "MiddlewareConfig",
+]

hypern/middleware/base.py

@@ -1,18 +1,13 @@
-from abc import ABC, abstractmethod
-from hypern.hypern import Response, Request
+from typing import Optional
+from hypern.hypern import MiddlewareConfig
 
 
-# The `Middleware` class is an abstract base class with abstract methods `before_request` and
-# `after_request` for handling requests and responses in a web application.
-class Middleware(ABC):
-    def __init__(self) -> None:
-        super().__init__()
-        self.app = None
+class Middleware:
+    def __init__(self, config: Optional[MiddlewareConfig] = None):
+        self.config = config or MiddlewareConfig.default()
 
-    @abstractmethod
-    def before_request(self, request: Request):
-        pass
+    async def before_request(self, request):
+        return request
 
-    @abstractmethod
-    def after_request(self, response: Response):
-        pass
+    async def after_request(self, response):
+        return response

hypern/middleware/cache.py

@@ -0,0 +1,177 @@
+import hashlib
+from datetime import datetime, timezone
+from typing import Dict, List, Optional
+
+from hypern.hypern import Header, MiddlewareConfig, Request, Response
+
+from .base import Middleware
+
+
+class CacheConfig:
+    """
+    Configuration class for caching middleware.
+
+    Attributes:
+        max_age (int): The maximum age (in seconds) for the cache. Default is 3600 seconds (1 hour).
+        s_maxage (Optional[int]): The shared maximum age (in seconds) for the cache. Default is None.
+        stale_while_revalidate (Optional[int]): The time (in seconds) the cache can be used while revalidation is performed. Default is None.
+        stale_if_error (Optional[int]): The time (in seconds) the cache can be used if an error occurs during revalidation. Default is None.
+        vary_by (List[str]): List of headers to vary the cache by. Default is ['Accept', 'Accept-Encoding'].
+        cache_control (List[str]): List of cache control directives. Default is an empty list.
+        include_query_string (bool): Whether to include the query string in the cache key. Default is True.
+        exclude_paths (List[str]): List of paths to exclude from caching. Default is ['/admin', '/api/private'].
+        exclude_methods (List[str]): List of HTTP methods to exclude from caching. Default is ['POST', 'PUT', 'DELETE', 'PATCH'].
+        private_paths (List[str]): List of paths to be marked as private. Default is an empty list.
+        cache_by_headers (List[str]): List of headers to include in the cache key. Default is an empty list.
+    """
+
+    def __init__(
+        self,
+        max_age: int = 3600,  # 1 hour default
+        s_maxage: Optional[int] = None,
+        stale_while_revalidate: Optional[int] = None,
+        stale_if_error: Optional[int] = None,
+        vary_by: List[str] = None,
+        cache_control: List[str] = None,
+        include_query_string: bool = True,
+        exclude_paths: List[str] = None,
+        exclude_methods: List[str] = None,
+        private_paths: List[str] = None,
+        cache_by_headers: List[str] = None,
+    ):
+        self.max_age = max_age
+        self.s_maxage = s_maxage
+        self.stale_while_revalidate = stale_while_revalidate
+        self.stale_if_error = stale_if_error
+        self.vary_by = vary_by or ["accept", "accept-encoding"]
+        self.cache_control = cache_control or []
+        self.include_query_string = include_query_string
+        self.exclude_paths = exclude_paths or ["/admin", "/api/private"]
+        self.exclude_methods = exclude_methods or ["POST", "PUT", "DELETE", "PATCH"]
+        self.private_paths = private_paths or []
+        self.cache_by_headers = cache_by_headers or []
+
+
+class EdgeCacheMiddleware(Middleware):
+    """
+    Middleware implementing edge caching strategies with support for:
+    - Cache-Control directives
+    - ETag generation
+    - Conditional requests (If-None-Match, If-Modified-Since)
+    - Vary header management
+    - CDN-specific headers
+    """
+
+    def __init__(self, cache_config: CacheConfig | None = None, config: Optional[MiddlewareConfig] = None):
+        super().__init__(config)
+        self.cache_config = cache_config or CacheConfig()
+        self._etag_cache: Dict[str, str] = {}
+        self.request_context = {}
+
+    def _should_cache(self, request: Request, path: str) -> bool:
+        """Determine if the request should be cached"""
+        if request.method in self.cache_config.exclude_methods:
+            return False
+
+        if any(excluded in path for excluded in self.cache_config.exclude_paths):
+            return False
+
+        return True
+
+    def _generate_cache_key(self, request: Request) -> str:
+        """Generate a unique cache key based on request attributes"""
+        components = [request.method, request.path]
+
+        if self.cache_config.include_query_string:
+            components.append(str(request.query_params))
+
+        for header in self.cache_config.cache_by_headers:
+            value = request.headers.get(str(header).lower())
+            if value:
+                components.append(f"{header}:{value}")
+
+        return hashlib.sha256(":".join(components).encode()).hexdigest()
+
+    def _generate_etag(self, response: Response) -> str:
+        """Generate ETag for response content"""
+        content = response.description
+        if not isinstance(content, bytes):
+            content = str(content).encode()
+        return hashlib.sha256(content).hexdigest()
+
+    def _build_cache_control(self, path: str) -> str:
+        """Build Cache-Control header value"""
+        directives = []
+
+        # Determine public/private caching
+        if any(private in path for private in self.cache_config.private_paths):
+            directives.append("private")
+        else:
+            directives.append("public")
+
+        # Add max-age directives
+        directives.append(f"max-age={self.cache_config.max_age}")
+
+        if self.cache_config.s_maxage is not None:
+            directives.append(f"s-maxage={self.cache_config.s_maxage}")
+
+        if self.cache_config.stale_while_revalidate is not None:
+            directives.append(f"stale-while-revalidate={self.cache_config.stale_while_revalidate}")
+
+        if self.cache_config.stale_if_error is not None:
+            directives.append(f"stale-if-error={self.cache_config.stale_if_error}")
+
+        # Add custom cache control directives
+        directives.extend(self.cache_config.cache_control)
+
+        return ", ".join(directives)
+
+    def cleanup_context(self, context_id: str):
+        try:
+            del self.request_context[context_id]
+        except Exception:
+            pass
+
+    def before_request(self, request: Request) -> Request | Response:
+        """Handle conditional requests"""
+        if not self._should_cache(request, request.path):
+            return request
+
+        cache_key = self._generate_cache_key(request)
+        etag = self._etag_cache.get(cache_key)
+
+        if etag:
+            if_none_match = request.headers.get("if-none-match")
+            if if_none_match and if_none_match == etag:
+                return Response(status_code=304, description=b"", headers=Header({"ETag": etag}))
+        self.request_context[request.context_id] = request
+        return request
+
+    def after_request(self, response: Response) -> Response:
+        """Add caching headers to response"""
+        request = self.request_context.get(response.context_id)
+        self.cleanup_context(response.context_id)
+        if not self._should_cache(request, request.path):
+            response.headers.set("Cache-Control", "no-store")
+            return response
+
+        # Generate and store ETag
+        cache_key = self._generate_cache_key(request)
+        etag = self._generate_etag(response)
+        self._etag_cache[cache_key] = etag
+
+        # Set cache headers
+        response.headers.update(
+            {
+                "Cache-Control": self._build_cache_control(request.path),
+                "ETag": etag,
+                "Vary": ", ".join(self.cache_config.vary_by),
+                "Last-Modified": datetime.now(tz=timezone.utc).strftime("%a, %d %b %Y %H:%M:%S GMT"),
+            }
+        )
+
+        # Add CDN-specific headers
+        response.headers.set("CDN-Cache-Control", response.headers["Cache-Control"])
+        response.headers.set("Surrogate-Control", f"max-age={self.cache_config.s_maxage or self.cache_config.max_age}")
+
+        return response

hypern/middleware/compress.py

@@ -0,0 +1,78 @@
+import gzip
+import zlib
+from typing import List, Optional
+
+from hypern.hypern import Request, Response
+
+from .base import Middleware, MiddlewareConfig
+
+
+class CompressionMiddleware(Middleware):
+    """
+    Middleware for compressing response content using gzip or deflate encoding.
+    """
+
+    def __init__(
+        self, config: Optional[MiddlewareConfig] = None, min_size: int = 500, compression_level: int = 6, include_types: Optional[List[str]] = None
+    ) -> None:
+        """
+        Initialize compression middleware.
+
+        Args:
+            min_size: Minimum response size in bytes to trigger compression
+            compression_level: Compression level (1-9, higher = better compression but slower)
+            include_types: List of content types to compress (defaults to common text types)
+        """
+        super().__init__(config)
+        self.min_size = min_size
+        self.compression_level = compression_level
+        self.include_types = include_types or [
+            "text/plain",
+            "text/html",
+            "text/css",
+            "text/javascript",
+            "application/javascript",
+            "application/json",
+            "application/xml",
+            "application/x-yaml",
+        ]
+
+    def before_request(self, request: Request) -> Request:
+        return request
+
+    def after_request(self, response: Response) -> Response:
+        # Check if response should be compressed
+        content_type = (response.headers.get("content-type") or "").split(";")[0].lower()
+        content_encoding = (response.headers.get("content-encoding") or "").lower()
+
+        # Skip if:
+        # - Content is already encoded
+        # - Content type is not in include list
+        # - Content length is below minimum size
+        if content_encoding or content_type not in self.include_types or len(response.description.encode()) < self.min_size:
+            return response
+
+        # Get accepted encodings from request
+        accept_encoding = (response.headers.get("accept-encoding") or "").lower()
+
+        if "gzip" in accept_encoding:
+            # Use gzip compression
+            response.description = gzip.compress(
+                response.description if isinstance(response.description, bytes) else str(response.description).encode(), compresslevel=self.compression_level
+            )
+            response.headers.set("content-encoding", "gzip")
+
+        elif "deflate" in accept_encoding:
+            # Use deflate compression
+            response.description = zlib.compress(
+                response.description if isinstance(response.description, bytes) else str(response.description).encode(), level=self.compression_level
+            )
+            response.headers.set("content-encoding", "deflate")
+
+        # Update content length after compression
+        response.headers.set("content-length", str(len(response.description)))
+
+        # Add Vary header to indicate content varies by Accept-Encoding
+        response.headers.set("vary", "Accept-Encoding")
+
+        return response

hypern/middleware/cors.py

@@ -1,5 +1,6 @@
-from typing import List
+from typing import List, Optional
 from .base import Middleware
+from hypern.hypern import MiddlewareConfig
 
 
 class CORSMiddleware(Middleware):
@@ -8,8 +9,10 @@ class CORSMiddleware(Middleware):
     methods, and headers.
     """
 
-    def __init__(self, allow_origins: List[str] = None, allow_methods: List[str] = None, allow_headers: List[str] = None) -> None:
-        super().__init__()
+    def __init__(
+        self, config: Optional[MiddlewareConfig] = None, allow_origins: List[str] = None, allow_methods: List[str] = None, allow_headers: List[str] = None
+    ) -> None:
+        super().__init__(config)
         self.allow_origins = allow_origins or []
         self.allow_methods = allow_methods or []
         self.allow_headers = allow_headers or []

hypern/middleware/limit.py

@@ -1,10 +1,11 @@
+from typing import Optional
 import time
 from abc import ABC, abstractmethod
 from threading import Lock
 
 from hypern.hypern import Request, Response
 
-from .base import Middleware
+from .base import Middleware, MiddlewareConfig
 
 
 class StorageBackend(ABC):
@@ -102,14 +103,14 @@ class RateLimitMiddleware(Middleware):
     Requests per minute for a given IP address.
     """
 
-    def __init__(self, storage_backend, requests_per_minute=60, window_size=60):
-        super().__init__()
+    def __init__(self, storage_backend, config: Optional[MiddlewareConfig] = None, requests_per_minute=60, window_size=60):
+        super().__init__(config)
         self.storage = storage_backend
         self.requests_per_minute = requests_per_minute
         self.window_size = window_size
 
     def get_request_identifier(self, request: Request):
-        return request.ip_addr
+        return request.remote_addr
 
     def before_request(self, request: Request):
         """