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

hypern/middleware/security.py

@@ -4,13 +4,14 @@ import secrets
 import time
 from base64 import b64decode, b64encode
 from dataclasses import dataclass
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 from typing import Any, Dict, List, Optional
 
 import jwt
 
 from hypern.exceptions import Forbidden, Unauthorized
-from hypern.hypern import Middleware, Request, Response
+from hypern.hypern import Request, Response
+from .base import Middleware, MiddlewareConfig
 
 
 @dataclass
@@ -44,16 +45,16 @@ class SecurityConfig:
 
 
 class SecurityMiddleware(Middleware):
-    def __init__(self, config: SecurityConfig):
-        super().__init__()
-        self.config = config
+    def __init__(self, secur_config: SecurityConfig, config: Optional[MiddlewareConfig] = None):
+        super().__init__(config)
+        self.secur_config = secur_config
         self._secret_key = secrets.token_bytes(32)
         self._token_lifetime = 3600
         self._rate_limit_storage = {}
 
     def _rate_limit_check(self, request: Request) -> Optional[Response]:
         """Check if the request exceeds rate limits"""
-        if not self.config.rate_limiting:
+        if not self.secur_config.rate_limiting:
             return None
 
         client_ip = request.client.host
@@ -74,16 +75,20 @@ class SecurityMiddleware(Middleware):
 
     def _generate_jwt_token(self, user_data: Dict[str, Any]) -> str:
         """Generate a JWT token"""
-        if not self.config.jwt_secret:
+        if not self.secur_config.jwt_secret:
             raise ValueError("JWT secret key is not configured")
 
-        payload = {"user": user_data, "exp": datetime.utcnow() + timedelta(seconds=self.config.jwt_expires_in), "iat": datetime.utcnow()}
-        return jwt.encode(payload, self.config.jwt_secret, algorithm=self.config.jwt_algorithm)
+        payload = {
+            "user": user_data,
+            "exp": datetime.now(tz=timezone.utc) + timedelta(seconds=self.secur_config.jwt_expires_in),
+            "iat": datetime.now(tz=timezone.utc),
+        }
+        return jwt.encode(payload, self.secur_config.jwt_secret, algorithm=self.secur_config.jwt_algorithm)
 
     def _verify_jwt_token(self, token: str) -> Dict[str, Any]:
         """Verify JWT token and return payload"""
         try:
-            payload = jwt.decode(token, self.config.jwt_secret, algorithms=[self.config.jwt_algorithm])
+            payload = jwt.decode(token, self.secur_config.jwt_secret, algorithms=[self.secur_config.jwt_algorithm])
             return payload
         except jwt.ExpiredSignatureError:
             raise Unauthorized("Token has expired")
@@ -121,10 +126,10 @@ class SecurityMiddleware(Middleware):
 
     def _apply_cors_headers(self, response: Response) -> None:
         """Apply CORS headers to response"""
-        if not self.config.cors_configuration:
+        if not self.secur_config.cors_configuration:
             return
 
-        cors = self.config.cors_configuration
+        cors = self.secur_config.cors_configuration
         response.headers.update(
             {
                 "Access-Control-Allow-Origin": ", ".join(cors.allowed_origins),
@@ -137,8 +142,8 @@ class SecurityMiddleware(Middleware):
 
     def _apply_security_headers(self, response: Response) -> None:
         """Apply security headers to response"""
-        if self.config.security_headers:
-            response.headers.update(self.config.security_headers)
+        if self.secur_config.security_headers:
+            response.headers.update(self.secur_config.security_headers)
 
     async def before_request(self, request: Request) -> Request | Response:
         """Process request before handling"""
@@ -147,7 +152,7 @@ class SecurityMiddleware(Middleware):
             return rate_limit_response
 
         # JWT authentication check
-        if self.config.jwt_auth:
+        if self.secur_config.jwt_auth:
             auth_header = request.headers.get("Authorization")
             if not auth_header or not auth_header.startswith("Bearer "):
                 raise Unauthorized("Missing or invalid authorization header")
@@ -158,7 +163,7 @@ class SecurityMiddleware(Middleware):
                 return Response(status_code=401, description=str(e))
 
         # CSRF protection check
-        if self.config.csrf_protection and request.method in ["POST", "PUT", "DELETE", "PATCH"]:
+        if self.secur_config.csrf_protection and request.method in ["POST", "PUT", "DELETE", "PATCH"]:
             csrf_token = request.headers.get("X-CSRF-Token")
             if not csrf_token or not self._validate_csrf_token(csrf_token):
                 raise Forbidden("CSRF token missing or invalid")

hypern/processpool.py

@@ -25,11 +25,26 @@ def run_processes(
     after_request: List[FunctionInfo],
     response_headers: Dict[str, str],
     reload: bool = True,
+    on_startup: FunctionInfo | None = None,
+    on_shutdown: FunctionInfo | None = None,
+    auto_compression: bool = False,
 ) -> List[Process]:
     socket = SocketHeld(host, port)
 
     process_pool = init_processpool(
-        router, websocket_router, socket, workers, processes, max_blocking_threads, injectables, before_request, after_request, response_headers
+        router,
+        websocket_router,
+        socket,
+        workers,
+        processes,
+        max_blocking_threads,
+        injectables,
+        before_request,
+        after_request,
+        response_headers,
+        on_startup,
+        on_shutdown,
+        auto_compression,
     )
 
     def terminating_signal_handler(_sig, _frame):
@@ -79,6 +94,9 @@ def init_processpool(
     before_request: List[FunctionInfo],
     after_request: List[FunctionInfo],
     response_headers: Dict[str, str],
+    on_startup: FunctionInfo | None = None,
+    on_shutdown: FunctionInfo | None = None,
+    auto_compression: bool = False,
 ) -> List[Process]:
     process_pool = []
 
@@ -86,7 +104,20 @@ def init_processpool(
         copied_socket = socket.try_clone()
         process = Process(
             target=spawn_process,
-            args=(router, websocket_router, copied_socket, workers, max_blocking_threads, injectables, before_request, after_request, response_headers),
+            args=(
+                router,
+                websocket_router,
+                copied_socket,
+                workers,
+                max_blocking_threads,
+                injectables,
+                before_request,
+                after_request,
+                response_headers,
+                on_startup,
+                on_shutdown,
+                auto_compression,
+            ),
         )
         process.start()
         process_pool.append(process)
@@ -118,6 +149,9 @@ def spawn_process(
     before_request: List[FunctionInfo],
     after_request: List[FunctionInfo],
     response_headers: Dict[str, str],
+    on_startup: FunctionInfo | None = None,
+    on_shutdown: FunctionInfo | None = None,
+    auto_compression: bool = False,
 ):
     loop = initialize_event_loop()
 
@@ -128,7 +162,12 @@ def spawn_process(
     server.set_before_hooks(hooks=before_request)
     server.set_after_hooks(hooks=after_request)
     server.set_response_headers(headers=response_headers)
+    server.set_auto_compression(enabled=auto_compression)
 
+    if on_startup:
+        server.set_startup_handler(on_startup)
+    if on_shutdown:
+        server.set_shutdown_handler(on_shutdown)
     try:
         server.start(socket, workers, max_blocking_threads)
         loop = asyncio.get_event_loop()

hypern/routing/__init__.py

@@ -1,4 +1,5 @@
 from .route import Route
 from .endpoint import HTTPEndpoint
+from .queue import QueuedHTTPEndpoint
 
-__all__ = ["Route", "HTTPEndpoint"]
+__all__ = ["Route", "HTTPEndpoint", "QueuedHTTPEndpoint"]

hypern/routing/queue.py

@@ -0,0 +1,175 @@
+import asyncio
+import time
+from contextlib import asynccontextmanager
+from dataclasses import dataclass, field
+from queue import PriorityQueue
+from typing import Any, Dict
+
+from hypern.hypern import Request, Response
+from hypern.response import JSONResponse
+from hypern.routing import HTTPEndpoint
+from hypern.logging import logger
+
+
+@dataclass(order=True)
+class PrioritizedRequest:
+    priority: int
+    timestamp: float = field(default_factory=time.time)
+    request: Request | None = field(default=None, compare=False)
+    future: asyncio.Future = field(compare=False, default_factory=asyncio.Future)
+
+
+class QueuedHTTPEndpoint(HTTPEndpoint):
+    """
+    HTTPEndpoint with request queuing capabilities for high-load scenarios.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        # Queue configuration
+        self._max_concurrent = kwargs.get("max_concurrent", 100)
+        self._queue_size = kwargs.get("queue_size", 1000)
+        self._request_timeout = kwargs.get("request_timeout", 30)
+
+        # Initialize queuing system
+        self._request_queue: PriorityQueue = PriorityQueue(maxsize=self._queue_size)
+        self._active_requests = 0
+        self._lock = None  # Will be initialized when needed
+        self._request_semaphore = None  # Will be initialized when needed
+        self._shutdown = False
+        self._queue_task = None
+        self._initialized = False
+
+        # Metrics
+        self._metrics = {"processed_requests": 0, "queued_requests": 0, "rejected_requests": 0, "avg_wait_time": 0.0}
+
+        self._fully_message = "Request queue is full"
+
+    async def _initialize(self):
+        """Initialize async components when first request arrives"""
+        if not self._initialized:
+            self._lock = asyncio.Lock()
+            self._request_semaphore = asyncio.Semaphore(self._max_concurrent)
+            self._queue_task = asyncio.create_task(self._process_queue())
+            self._initialized = True
+
+    @asynccontextmanager
+    async def _queue_context(self, request: Request, priority: int = 10):
+        """Context manager for handling request queuing."""
+        if self._shutdown:
+            raise RuntimeError("Endpoint is shutting down")
+
+        await self._initialize()  # Ensure async components are initialized
+
+        request_future = asyncio.Future()
+        prioritized_request = PrioritizedRequest(priority=priority, timestamp=time.time(), request=request, future=request_future)
+
+        try:
+            if self._request_queue.qsize() >= self._queue_size:
+                self._metrics["rejected_requests"] += 1
+                raise asyncio.QueueFull(self._fully_message)
+
+            await self._enqueue_request(prioritized_request)
+            yield await asyncio.wait_for(request_future, timeout=self._request_timeout)
+
+        except asyncio.TimeoutError:
+            self._metrics["rejected_requests"] += 1
+            raise asyncio.TimeoutError("Request timed out while waiting in queue")
+        finally:
+            if not request_future.done():
+                request_future.cancel()
+
+    async def _enqueue_request(self, request: PrioritizedRequest):
+        """Add request to the queue."""
+        try:
+            self._request_queue.put_nowait(request)
+            self._metrics["queued_requests"] += 1
+        except asyncio.QueueFull:
+            self._metrics["rejected_requests"] += 1
+            raise asyncio.QueueFull(self._fully_message)
+
+    async def _process_queue(self):
+        """Background task to process queued requests."""
+        while not self._shutdown:
+            try:
+                if not self._request_queue.empty():
+                    async with self._lock:
+                        if self._active_requests >= self._max_concurrent:
+                            await asyncio.sleep(0.1)
+                            continue
+
+                        request = self._request_queue.get_nowait()
+                        wait_time = time.time() - request.timestamp
+                        self._metrics["avg_wait_time"] = (self._metrics["avg_wait_time"] * self._metrics["processed_requests"] + wait_time) / (
+                            self._metrics["processed_requests"] + 1
+                        )
+
+                        if not request.future.cancelled():
+                            self._active_requests += 1
+                            asyncio.create_task(self._handle_request(request))
+
+                await asyncio.sleep(0.01)
+            except Exception as e:
+                logger.error(f"Error processing queue: {e}")
+                await asyncio.sleep(1)
+
+    async def _handle_request(self, request: PrioritizedRequest):
+        """Handle individual request."""
+        try:
+            async with self._request_semaphore:
+                response = await super().dispatch(request.request, {})
+                if not request.future.done():
+                    request.future.set_result(response)
+        except Exception as e:
+            if not request.future.done():
+                request.future.set_exception(e)
+        finally:
+            self._active_requests -= 1
+            self._metrics["processed_requests"] += 1
+            self._metrics["queued_requests"] -= 1
+
+    async def dispatch(self, request: Request, inject: Dict[str, Any]) -> Response:
+        """
+        Enhanced dispatch method with request queuing.
+        """
+        try:
+            priority = self._get_request_priority(request)
+
+            async with self._queue_context(request, priority) as response:
+                return response
+
+        except asyncio.QueueFull:
+            return JSONResponse(description={"error": "Server too busy", "message": self._fully_message, "retry_after": 5}, status_code=503)
+        except asyncio.TimeoutError:
+            return JSONResponse(
+                description={
+                    "error": "Request timeout",
+                    "message": "Request timed out while waiting in queue",
+                },
+                status_code=504,
+            )
+        except Exception as e:
+            return JSONResponse(description={"error": "Internal server error", "message": str(e)}, status_code=500)
+
+    def _get_request_priority(self, request: Request) -> int:
+        """
+        Determine request priority. Override this method to implement
+        custom priority logic.
+        """
+        if request.method == "GET":
+            return 5
+        return 10
+
+    async def shutdown(self):
+        """Gracefully shutdown the endpoint."""
+        self._shutdown = True
+        if self._queue_task and not self._queue_task.done():
+            self._queue_task.cancel()
+            try:
+                await self._queue_task
+            except asyncio.CancelledError:
+                pass
+
+    def get_metrics(self) -> Dict[str, Any]:
+        """Get current queue metrics."""
+        return {**self._metrics, "current_queue_size": self._request_queue.qsize(), "active_requests": self._active_requests}

{hypern-0.3.1.dist-info → hypern-0.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypern
-Version: 0.3.1
+Version: 0.3.2
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{hypern-0.3.1.dist-info → hypern-0.3.2.dist-info}/RECORD

@@ -1,20 +1,15 @@
-hypern-0.3.1.dist-info/METADATA,sha256=dAKnEF83pJsKjgE50V8YZOD-_dTDlcrM3yc4Gtn5_IE,3754
-hypern-0.3.1.dist-info/WHEEL,sha256=SK_cql1gpDHx6aBV-LOSvGbTt4TUC8AJJOzjOP2tdpI,92
-hypern-0.3.1.dist-info/licenses/LICENSE,sha256=qbYKAIJLS6jYg5hYncKE7OtWmqOtpVTvKNkwOa0Iwwg,1328
-hypern/application.py,sha256=D8tye5rpOJzHGQHUelaDpjUL3B9xO40B7xAL9wC3Uno,14328
-hypern/args_parser.py,sha256=Crxzr8_uhiIk_AWJvuwJTEfRqEBqU_GfTbg6chg_YiY,1790
+hypern-0.3.2.dist-info/METADATA,sha256=xbMB8V67yK1aLvRGbYrsjqoScFdSOZXs97zXg0yVVQ4,3754
+hypern-0.3.2.dist-info/WHEEL,sha256=SK_cql1gpDHx6aBV-LOSvGbTt4TUC8AJJOzjOP2tdpI,92
+hypern-0.3.2.dist-info/licenses/LICENSE,sha256=qbYKAIJLS6jYg5hYncKE7OtWmqOtpVTvKNkwOa0Iwwg,1328
+hypern/application.py,sha256=yNlohWdSG0lpKfuTVX7N9gI3cmXl3IoEvP8WLH-yAiE,16251
+hypern/args_parser.py,sha256=diz3Oq1PDNMBlG7ElqK01iokY5w_X3U1Ky1jikPVXRg,2020
 hypern/auth/authorization.py,sha256=-NprZsI0np889ZN1fp-MiVFrPoMNzUtatBJaCMtkllM,32
 hypern/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hypern/background.py,sha256=xy38nQZSJsYFRXr3-uFJeNW9E1GiXXOC7lSe5pC0eyE,124
-hypern/caching/base/backend.py,sha256=nHl5_nH95LSYWBS9RmOvOzsps_p19HcnQsb4h4W7cP8,68
-hypern/caching/base/key_maker.py,sha256=-W1r3ywfQ-K6saniiK3aTMaW3iy3aXai2pvQqM8f74I,232
-hypern/caching/base/__init__.py,sha256=M-B56YGTkSwCkKW_I6GcV1LSIFfxZ6KuXowB1_aJQpQ,155
-hypern/caching/cache_manager.py,sha256=TF6UosJ54950JgsrPVZUS3MH2R8zafAu5PTryNJ0sRs,2053
-hypern/caching/cache_tag.py,sha256=bZcjivMNETAzAHAIobuLN0S2wHgPgLLL8Gg4uso_qbk,267
-hypern/caching/custom_key_maker.py,sha256=88RIIJjpQYFnv857wOlCKgWWBbK_S23zNHsIrJz_4PY,394
-hypern/caching/redis_backend.py,sha256=IgQToCnHYGpKEErq2CNZkR5woo01z456Ef3C-XRPRV8,70
-hypern/caching/strategies.py,sha256=S7qJiJOTJrk6KUFDrmjGkHP3XV8mYTRM3Sd4pA4UQKA,4199
-hypern/caching/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hypern/caching/backend.py,sha256=bfSEgJQxS3FDdj08CY4V9b9U3rwf4uy9gS46QmwA3Zc,829
+hypern/caching/redis_backend.py,sha256=SWYlJvr8qi2kS_grhxhqQBLEEATpFremT2XyXkio8h0,5968
+hypern/caching/strategies.py,sha256=qQjqgZLUX7KZjhwPD4SYUaMRewgCgsp6qa1FunK3Y0I,7288
+hypern/caching/__init__.py,sha256=ODO7zMm4iFG8wcvrhKmukryG5wOTW0DnzFvNMfF57Cc,352
 hypern/cli/commands.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hypern/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hypern/config.py,sha256=frZSdXBI8GaM0tkw1Rs-XydZ9-XjGLRPj6DL4d51-y4,4930
@@ -39,20 +34,27 @@ hypern/db/sql/__init__.py,sha256=1UoWQi2CIcUAbQj3FadR-8V0o_b286nI2wYvOsvtbFc,647
 hypern/db/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hypern/enum.py,sha256=KcVziJj7vWvyie0r2rtxhrLzdtkZAsf0DY58oJ4tQl4,360
 hypern/exceptions.py,sha256=nHTkF0YdNBMKfSiNtjRMHMNKoY3RMUm68YYluuW15us,2428
-hypern/hypern.pyi,sha256=DhTRcW9c0qjVS976fx__insErvhk4k7W0NKcV6iZGxw,8038
+hypern/gateway/aggregator.py,sha256=N1onAp9gdzpCR-E5VubkVoUjjEmVNxG8gDZx9rhnbXc,1132
+hypern/gateway/gateway.py,sha256=26K2qvJUR-0JnN4IlhwvSSt7EYcpYrBVDuzZ1ivQQ34,1475
+hypern/gateway/proxy.py,sha256=w1wcTplDnVrfjn7hb0M0yBVth5TGl88irF-MUYHysQQ,2463
+hypern/gateway/service.py,sha256=PkRaM08olqM_j_4wRjEJCR8X8ZysAF2WOcfhWjaX2eo,1701
+hypern/gateway/__init__.py,sha256=TpFWtqnJerW1-jCWq5fjypJcw9Y6ytyrkvkzby1Eg0E,235
+hypern/hypern.pyi,sha256=GiUjtY6tbV8d6KI1PDTTZK5zWyOD4hooahALnFd7Fl4,8197
 hypern/i18n/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hypern/logging/logger.py,sha256=WACam_IJiCMXX0hGVKMGSxUQpY4DgAXy7M1dD3q-Z9s,3256
 hypern/logging/__init__.py,sha256=6eVriyncsJ4J73fGYhoejv9MX7aGTkRezTpPxO4DX1I,52
-hypern/middleware/base.py,sha256=mJoz-i-7lqw1eDxZ8Bb0t8sz60lx5TE-OjZT4UR75e4,541
-hypern/middleware/cors.py,sha256=x90DnCOJSfp4ojm1krttn_EdtlqeDazyUzVg66NES4A,1681
+hypern/middleware/base.py,sha256=3G7vxFXr0tDp28Bz3NeM76eo03qYGppm07N3yWoA_4U,369
+hypern/middleware/cache.py,sha256=HFfghpnhS21DOsXLn6nt-TgRLCNNm6ZqTKPMgoXM0Mw,7583
+hypern/middleware/compress.py,sha256=Zph3pQz15YrYB4dMUMbQnfWIFY8ovysgPMepbY_WV9k,3119
+hypern/middleware/cors.py,sha256=pt5HyTd3J5L9Lvczo2xI8fxLmtntSbJq-CPU0vYXoAI,1800
 hypern/middleware/i18n.py,sha256=jHzVzjTx1nnjbraZtIVOprrnSaeKMxZB8RuSqRp2I4s,16
-hypern/middleware/limit.py,sha256=8hzUxu_mxra2QiDjAghgZtvwN6Dx07irPUiL12dbVhY,8152
-hypern/middleware/security.py,sha256=hIbmP1fkZ_KgxK1Wx7s9xdNH7M174mo6ySASiuzMz_A,7273
-hypern/middleware/__init__.py,sha256=lXwR3fdmpVK4Z7QWaLsgf3Sazy5NPPFXIOxIEv1xDC8,273
+hypern/middleware/limit.py,sha256=eAYARPjqxq8Ue0TCpnxlVRB5hv7hwBF0PxeD-bG6Sl0,8252
+hypern/middleware/security.py,sha256=d9Qf2UNMN8wz-MLnG2wRb0Vgf55_IGZAje5hbc2T_HQ,7539
+hypern/middleware/__init__.py,sha256=V-Gnv-Jf-14BVuA28z7PN7GBVQ9BBiBdab6-QnTPCfY,493
 hypern/openapi/schemas.py,sha256=YHfMlPUeP5DzDX5ao3YH8p_25Vvyaf616dh6XDCUZRc,1677
 hypern/openapi/swagger.py,sha256=naqUY3rFAEYA1ZLIlmDsMYaol0yIm6TVebdkFa5cMTc,64
 hypern/openapi/__init__.py,sha256=4rEVD8pa0kdSpsy7ZkJ5JY0Z2XF0NGSKDMwYAd7YZpE,141
-hypern/processpool.py,sha256=YW7Dg33Hla9D33x3Mf8xsjaTprHaovkLPK-4XnQKiGU,4045
+hypern/processpool.py,sha256=l6_PKRMFQ4GIMPLTMOEbIwWDsxER0NIj_wdxVWqA7zA,5042
 hypern/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hypern/reload.py,sha256=nfaZCoChrQetHNtIqN4Xzi-a0v-irxSCMhwCK3bCEq0,1569
 hypern/response/response.py,sha256=-dnboAraPic8asf503PxwmDuxhNllUO5h97_DGmbER4,4582
@@ -60,8 +62,9 @@ hypern/response/__init__.py,sha256=_w3u3TDNuYx5ejnnN1unqnTY8NlBgUATQi6wepEB_FQ,2
 hypern/routing/dispatcher.py,sha256=i2wLAAW1ZXgpi5K2heGXhTODnP1WdQzaR5WlUjs1o9c,2368
 hypern/routing/endpoint.py,sha256=RKVhvqOEGL9IKBXQ3KJgPi9bgJj9gfWC5BdZc5U_atc,1026
 hypern/routing/parser.py,sha256=R-4lcN9Ha1iMeAjlqDe8HwkjjMVG-c-ubQLZyWKXj6M,3554
+hypern/routing/queue.py,sha256=NtFBbogU22ddyyX-CuQMip1XFDPZdMCVMIeUCQ-CR6Y,7176
 hypern/routing/route.py,sha256=IUnWU5ra-0R9rrRDpxJiwiw7vaEefn-We2dZ4EocJGw,10403
-hypern/routing/__init__.py,sha256=7rw7EAxougCXtmkgJjrmLP3N5RXctIpI_3JmG9FcKVU,101
+hypern/routing/__init__.py,sha256=U4xW5fDRsn03z4cVLT4dJHHGGU6SVxyv2DL86LXodeE,162
 hypern/scheduler.py,sha256=-k3tW2AGCnHYSthKXk-FOs_SCtWp3yIxQzwzUJMJsbo,67
 hypern/security.py,sha256=3E86Yp_eOSVa1emUvBrDgoF0Sn6eNX0CfLnt87w5CPI,1773
 hypern/worker.py,sha256=WQrhY_awR6zjMwY4Q7izXi4E4fFrDqt7jIblUW8Bzcg,924
@@ -72,5 +75,5 @@ hypern/ws/route.py,sha256=fGQ2RC708MPOiiIHPUo8aZ-oK379TTAyQYm4htNA5jM,803
 hypern/ws/__init__.py,sha256=dhRoRY683_rfPfSPM5qUczfTuyYDeuLOCFxY4hIdKt8,131
 hypern/ws.py,sha256=F6SA2Z1KVnqTEX8ssvOXqCtudUS4eo30JsiIsvfbHnE,394
 hypern/__init__.py,sha256=9Ww_aUQ0vJls0tOq7Yw1_TVOCRsa5bHJ-RtnSeComwk,119
-hypern/hypern.cp312-win32.pyd,sha256=GClLmHIIv0CKb5uHz_ochUZKY_1wketwqHGB9TUdRPg,5482496
-hypern-0.3.1.dist-info/RECORD,,
+hypern/hypern.cp312-win32.pyd,sha256=JxNOpTLC3EaBfc6d3TLY05BbTHHx5ciyj3wSbOKbWIM,6539264
+hypern-0.3.2.dist-info/RECORD,,

hypern/caching/base/__init__.py

@@ -1,8 +0,0 @@
-# -*- coding: utf-8 -*-
-from .backend import BaseBackend
-from .key_maker import BaseKeyMaker
-
-__all__ = [
-    "BaseKeyMaker",
-    "BaseBackend",
-]

hypern/caching/base/backend.py

@@ -1,3 +0,0 @@
-from hypern.hypern import BaseBackend
-
-__all__ = ["BaseBackend"]

hypern/caching/base/key_maker.py

@@ -1,8 +0,0 @@
-# -*- coding: utf-8 -*-
-from abc import ABC, abstractmethod
-from typing import Callable
-
-
-class BaseKeyMaker(ABC):
-    @abstractmethod
-    async def make(self, function: Callable, prefix: str, identify_key: str) -> str: ...

hypern/caching/cache_manager.py

@@ -1,56 +0,0 @@
-# -*- coding: utf-8 -*-
-from functools import wraps
-from typing import Callable, Dict, Type
-
-from .base import BaseBackend, BaseKeyMaker
-from .cache_tag import CacheTag
-import orjson
-
-
-class CacheManager:
-    def __init__(self):
-        self.backend = None
-        self.key_maker = None
-
-    def init(self, backend: BaseBackend, key_maker: BaseKeyMaker) -> None:
-        self.backend = backend
-        self.key_maker = key_maker
-
-    def cached(self, tag: CacheTag, ttl: int = 60, identify: Dict = {}) -> Type[Callable]:
-        def _cached(function):
-            @wraps(function)
-            async def __cached(*args, **kwargs):
-                if not self.backend or not self.key_maker:
-                    raise ValueError("Backend or KeyMaker not initialized")
-
-                _identify_key = []
-                for key, values in identify.items():
-                    _obj = kwargs.get(key, None)
-                    if not _obj:
-                        raise ValueError(f"Caching: Identify key {key} not found in kwargs")
-                    for attr in values:
-                        _identify_key.append(f"{attr}={getattr(_obj, attr)}")
-                _identify_key = ":".join(_identify_key)
-
-                key = await self.key_maker.make(function=function, prefix=tag.value, identify_key=_identify_key)
-
-                cached_response = self.backend.get(key=key)
-                if cached_response:
-                    return orjson.loads(cached_response)
-
-                response = await function(*args, **kwargs)
-                self.backend.set(response=orjson.dumps(response).decode("utf-8"), key=key, ttl=ttl)
-                return response
-
-            return __cached
-
-        return _cached  # type: ignore
-
-    async def remove_by_tag(self, tag: CacheTag) -> None:
-        await self.backend.delete_startswith(value=tag.value)
-
-    async def remove_by_prefix(self, prefix: str) -> None:
-        await self.backend.delete_startswith(value=prefix)
-
-
-Cache = CacheManager()

hypern/caching/cache_tag.py

@@ -1,10 +0,0 @@
-# -*- coding: utf-8 -*-
-from enum import Enum
-
-
-class CacheTag(Enum):
-    GET_HEALTH_CHECK = "get_health_check"
-    GET_USER_INFO = "get_user_info"
-    GET_CATEGORIES = "get_categories"
-    GET_HISTORY = "get_chat_history"
-    GET_QUESTION = "get_question"

hypern/caching/custom_key_maker.py

@@ -1,11 +0,0 @@
-# -*- coding: utf-8 -*-
-from typing import Callable
-import inspect
-
-from hypern.caching.base import BaseKeyMaker
-
-
-class CustomKeyMaker(BaseKeyMaker):
-    async def make(self, function: Callable, prefix: str, identify_key: str = "") -> str:
-        path = f"{prefix}:{inspect.getmodule(function).__name__}.{function.__name__}:{identify_key}"  # type: ignore
-        return str(path)