hypern 0.3.1__cp310-cp310-win_amd64.whl → 0.3.3__cp310-cp310-win_amd64.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

@@ -2,34 +2,33 @@ import asyncio
 import os
 import signal
 import sys
-from typing import Any, Dict, List
+from typing import List
 
 from multiprocess import Process
 from watchdog.observers import Observer
 
-from .hypern import FunctionInfo, Router, Server, SocketHeld, WebsocketRouter
+from .hypern import Server, SocketHeld
 from .logging import logger
 from .reload import EventHandler
 
 
 def run_processes(
+    server: Server,
     host: str,
     port: int,
     workers: int,
     processes: int,
     max_blocking_threads: int,
-    router: Router,
-    websocket_router: WebsocketRouter,
-    injectables: Dict[str, Any],
-    before_request: List[FunctionInfo],
-    after_request: List[FunctionInfo],
-    response_headers: Dict[str, str],
     reload: bool = True,
 ) -> 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
+        server,
+        socket,
+        workers,
+        processes,
+        max_blocking_threads,
     )
 
     def terminating_signal_handler(_sig, _frame):
@@ -69,16 +68,11 @@ def run_processes(
 
 
 def init_processpool(
-    router: Router,
-    websocket_router: WebsocketRouter,
+    server: Server,
     socket: SocketHeld,
     workers: int,
     processes: int,
     max_blocking_threads: int,
-    injectables: Dict[str, Any],
-    before_request: List[FunctionInfo],
-    after_request: List[FunctionInfo],
-    response_headers: Dict[str, str],
 ) -> List[Process]:
     process_pool = []
 
@@ -86,7 +80,12 @@ 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=(
+                server,
+                copied_socket,
+                workers,
+                max_blocking_threads,
+            ),
         )
         process.start()
         process_pool.append(process)
@@ -109,29 +108,14 @@ def initialize_event_loop():
 
 
 def spawn_process(
-    router: Router,
-    websocket_router: WebsocketRouter,
+    server: Server,
     socket: SocketHeld,
     workers: int,
     max_blocking_threads: int,
-    injectables: Dict[str, Any],
-    before_request: List[FunctionInfo],
-    after_request: List[FunctionInfo],
-    response_headers: Dict[str, str],
 ):
     loop = initialize_event_loop()
 
-    server = Server()
-    server.set_router(router=router)
-    server.set_websocket_router(websocket_router=websocket_router)
-    server.set_injected(injected=injectables)
-    server.set_before_hooks(hooks=before_request)
-    server.set_after_hooks(hooks=after_request)
-    server.set_response_headers(headers=response_headers)
-
     try:
         server.start(socket, workers, max_blocking_threads)
-        loop = asyncio.get_event_loop()
-        loop.run_forever()
     except KeyboardInterrupt:
         loop.close()

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/dispatcher.py

@@ -15,6 +15,7 @@ from hypern.hypern import Request, Response
 from hypern.response import JSONResponse
 
 from .parser import InputHandler
+from hypern.config import context_store
 
 
 def is_async_callable(obj: typing.Any) -> bool:
@@ -32,6 +33,9 @@ async def run_in_threadpool(func: typing.Callable, *args, **kwargs):
 
 async def dispatch(handler, request: Request, inject: typing.Dict[str, typing.Any]) -> Response:
     try:
+        # set context for global handler
+        context_store.set_context(request.context_id)
+
         is_async = is_async_callable(handler)
         signature = inspect.signature(handler)
         input_handler = InputHandler(request)

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.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypern
-Version: 0.3.1
+Version: 0.3.3
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
@@ -23,6 +23,8 @@ Requires-Dist: multiprocess ==0.70.17
 Requires-Dist: uvloop ==0.21.0 ; sys_platform != 'win32' and platform_python_implementation == 'CPython' and platform_machine != 'armv7l'
 Requires-Dist: cryptography ==43.0.3
 Requires-Dist: watchdog ==6.0.0
+Requires-Dist: jsonschema ==4.23.0
+Requires-Dist: psutil ==6.1.0
 License-File: LICENSE
 Summary: A Fast Async Python backend with a Rust runtime.
 Author-email: Martin Dang <vannghiem848@gmail.com>

hypern-0.3.3.dist-info/RECORD

@@ -0,0 +1,84 @@
+hypern-0.3.3.dist-info/METADATA,sha256=VDUnlR9iin2qEAagUwnOdvZL1vC4dMeNM1oBrwl-rZ8,3819
+hypern-0.3.3.dist-info/WHEEL,sha256=ieLtPNGsC7xoJjcmwA6ZxvTXpcxDlcXaGCM87uD_Bf0,96
+hypern-0.3.3.dist-info/licenses/LICENSE,sha256=qbYKAIJLS6jYg5hYncKE7OtWmqOtpVTvKNkwOa0Iwwg,1328
+hypern/application.py,sha256=TZKwSHpWSOaValZtogmMO18l8U_xOpFN7cARMFK1hns,18432
+hypern/args_parser.py,sha256=zTfLfBoKBvYWxdPjabTfZsCtYF3La3PT0TD8dfLMeM4,2815
+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/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=Jij9eGg5NgC8Un5Lw5i7ghuEMAfkVctdcoE4RaN5LTE,8157
+hypern/datastructures.py,sha256=zZGGSP07kPc9KJDf11hX5uYhAyRE-Ck5wezW5QtOVXw,897
+hypern/db/addons/sqlalchemy/fields/color.py,sha256=Jj8q4lkT0ukKyjVyZjBx7fokGrX7AIJpKOGzwsBpfnU,480
+hypern/db/addons/sqlalchemy/fields/daterange.py,sha256=qEfQN9c4jQdzeXNYKgQ4VIJ3Qc0HXHWRouzNF1se-RA,853
+hypern/db/addons/sqlalchemy/fields/datetime.py,sha256=Bp2jMja2lb_b2WnzRnfbjXXTHBgBTyph1ECsItIwvvg,643
+hypern/db/addons/sqlalchemy/fields/encrypted.py,sha256=pXsg4ImPpK-VkLDruKrv2gUtdp2kajQX7xDbRDxa-SI,1930
+hypern/db/addons/sqlalchemy/fields/password.py,sha256=9pypORygWaINj3oiAOBRIOGgpuA0lcjPq4rh1pqJxq0,5789
+hypern/db/addons/sqlalchemy/fields/ts_vector.py,sha256=bQyXYvQ1bAfFpYcS-sFwM7fU6L1lg9_7nGDRGp0CoUo,1361
+hypern/db/addons/sqlalchemy/fields/unicode.py,sha256=rbqyHlsPUqRDWIjYQSRFF3zkHncnwxo0sdlzqUlcrUw,411
+hypern/db/addons/sqlalchemy/fields/__init__.py,sha256=mLN_AvwgpSAbrWZvVHZuO7ff0gk1T_JbVwd5wug5nlw,359
+hypern/db/addons/sqlalchemy/repository.py,sha256=ue6vWOTrnEPyDevlyh3v-7PU6GSfrZHYKrbXVuoS8UA,9516
+hypern/db/addons/sqlalchemy/__init__.py,sha256=FuY78ubEwtifdQTVHhCrscYaAarlp2urgYBc_R77yt0,2766
+hypern/db/addons/__init__.py,sha256=mdW0P0xvnK8htUk02ujvIaeHXl6w53JjrTS4ioNi1Bw,63
+hypern/db/nosql/addons/color.py,sha256=bAGRuARCAYwZ1nO4jK0lzGYKmavTDtS34BxvrsetF74,446
+hypern/db/nosql/addons/daterange.py,sha256=hGUSoVFqatNY-TB5wjZTq62iZpHpdsyRJIsHxsj1uDs,1192
+hypern/db/nosql/addons/encrypted.py,sha256=B0M-uDqvZHVmIZcFdwcuC2MGsv0pGJFQ1lrOg8klR9U,1741
+hypern/db/nosql/addons/password.py,sha256=jfZxvWFm6nV9EWpXq5Mj-jpqnl9QbokZj9WT14n7dKE,5035
+hypern/db/nosql/addons/unicode.py,sha256=LaDpLfdoTcJuASPE-8fqOVD05H_uOx8gOdnyDn5Iu0c,268
+hypern/db/nosql/addons/__init__.py,sha256=WEtPM8sPHilvga7zxwqvINeTkF0hdcfgPcAnHc4MASE,125
+hypern/db/nosql/__init__.py,sha256=MH9YvlbRlbBCrQVNOdfTaK-hINwJxbJLmxwY9Mei7I8,644
+hypern/db/sql/field.py,sha256=_5Et9pPmTI_bhUFN7PgdSiozip-Iv0eH2491J_WUvXU,20009
+hypern/db/sql/model.py,sha256=5GtH3v6LfYIENlBN1NpIjZpsYFQyo36jX-b6jO1lNdU,3894
+hypern/db/sql/query.py,sha256=_kBZbdQckYyawSIcuaUrE4C6eWgpeWyK1JVR3JWdh60,31964
+hypern/db/sql/__init__.py,sha256=lCOGNTHaXNSJbuLLIOe2IWWNmX0MFQFPNCl2yytD2Xs,261
+hypern/db/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hypern/enum.py,sha256=KcVziJj7vWvyie0r2rtxhrLzdtkZAsf0DY58oJ4tQl4,360
+hypern/exceptions.py,sha256=rWQpWjnkLY51HBpKcWkFaVGCKoC_EiFUPrIBBfLh-eA,2608
+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=4qHekIzH-I6CYch8PwYMus9Ou-JI901kgaLOGsnlOog,9389
+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=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=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=RFV4turo1dBv40NlzzosjwaZLC24igdyq6twY2IXCUE,2968
+hypern/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hypern/reload.py,sha256=nfaZCoChrQetHNtIqN4Xzi-a0v-irxSCMhwCK3bCEq0,1569
+hypern/response/response.py,sha256=-dnboAraPic8asf503PxwmDuxhNllUO5h97_DGmbER4,4582
+hypern/response/__init__.py,sha256=_w3u3TDNuYx5ejnnN1unqnTY8NlBgUATQi6wepEB_FQ,226
+hypern/routing/dispatcher.py,sha256=oQsbOTkjE5roFCl6k58oCW9lEGR_sY5tBoXSJIDgh0w,2508
+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=U4xW5fDRsn03z4cVLT4dJHHGGU6SVxyv2DL86LXodeE,162
+hypern/scheduler.py,sha256=-k3tW2AGCnHYSthKXk-FOs_SCtWp3yIxQzwzUJMJsbo,67
+hypern/security.py,sha256=3E86Yp_eOSVa1emUvBrDgoF0Sn6eNX0CfLnt87w5CPI,1773
+hypern/worker.py,sha256=WQrhY_awR6zjMwY4Q7izXi4E4fFrDqt7jIblUW8Bzcg,924
+hypern/ws/channel.py,sha256=0ns2qmeoFJOpGLXS_hqldhywDQm_DxHwj6KloQx4Q3I,3183
+hypern/ws/heartbeat.py,sha256=sWMXzQm6cbDHHA2NHc-gFjv7G_E56XtxswHQ93_BueM,2861
+hypern/ws/room.py,sha256=0_L6Nun0n007F0rfNY8yX5x_A8EuXuI67JqpMkJ4RNI,2598
+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.cp310-win_amd64.pyd,sha256=B8_uOIWwg1dU_R5dQcJGSr9EFnRnIEyaiNCyuqEk8cA,11248640
+hypern-0.3.3.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)