hypern 0.3.11__cp310-cp310-macosx_11_0_arm64.whl

hypern/reload.py

@@ -0,0 +1,46 @@
+import sys
+import time
+import subprocess
+from watchdog.events import FileSystemEventHandler
+import signal
+import os
+
+from .logging import logger
+
+
+class EventHandler(FileSystemEventHandler):
+    def __init__(self, file_path: str, directory_path: str) -> None:
+        self.file_path = file_path
+        self.directory_path = directory_path
+        self.process = None
+        self.last_reload = time.time()
+
+    def reload(self):
+        # Kill all existing processes with the same command
+        current_cmd = [sys.executable, *sys.argv]
+
+        try:
+            # Find and kill existing processes
+            for proc in subprocess.Popen(["ps", "aux"], stdout=subprocess.PIPE).communicate()[0].decode().splitlines():
+                if all(str(arg) in proc for arg in current_cmd):
+                    pid = int(proc.split()[1])
+                    try:
+                        os.kill(pid, signal.SIGKILL)  # NOSONAR
+                        logger.debug(f"Killed process with PID {pid}")
+                    except ProcessLookupError:
+                        pass
+
+            # Start new process
+            self.process = subprocess.Popen(current_cmd)
+            self.last_reload = time.time()
+            logger.debug("Server reloaded successfully")
+
+        except Exception as e:
+            logger.error(f"Reload failed: {e}")
+
+    def on_modified(self, event) -> None:
+        if time.time() - self.last_reload < 0.5:
+            return
+
+        time.sleep(0.2)  # Ensure file is written
+        self.reload()

hypern/response/__init__.py

@@ -0,0 +1,3 @@
+from .response import Response, JSONResponse, HTMLResponse, PlainTextResponse, RedirectResponse, FileResponse
+
+__all__ = ["Response", "JSONResponse", "HTMLResponse", "PlainTextResponse", "RedirectResponse", "FileResponse"]

hypern/response/response.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+import typing
+from urllib.parse import quote
+from hypern.hypern import Response as InternalResponse, Header
+import orjson
+import msgpack
+
+from hypern.background import BackgroundTask, BackgroundTasks
+
+
+class BaseResponse:
+    media_type = None
+    charset = "utf-8"
+
+    def __init__(
+        self,
+        content: typing.Any = None,
+        status_code: int = 200,
+        headers: typing.Mapping[str, str] | None = None,
+        media_type: str | None = None,
+        backgrounds: typing.List[BackgroundTask] | None = None,
+    ) -> None:
+        self.status_code = status_code
+        if media_type is not None:
+            self.media_type = media_type
+        self.body = self.render(content)
+        self.init_headers(headers)
+        self.backgrounds = backgrounds
+
+    def render(self, content: typing.Any) -> bytes | memoryview:
+        if content is None:
+            return b""
+        if isinstance(content, (bytes, memoryview)):
+            return content
+        if isinstance(content, str):
+            return content.encode(self.charset)
+        return orjson.dumps(content)  # type: ignore
+
+    def init_headers(self, headers: typing.Mapping[str, str] | None = None) -> None:
+        if headers is None:
+            raw_headers: dict = {}
+            populate_content_length = True
+            populate_content_type = True
+        else:
+            raw_headers = {k.lower(): v for k, v in headers.items()}
+            keys = raw_headers.keys()
+            populate_content_length = "content-length" not in keys
+            populate_content_type = "content-type" not in keys
+
+        body = getattr(self, "body", None)
+        if body is not None and populate_content_length and not (self.status_code < 200 or self.status_code in (204, 304)):
+            content_length = str(len(body))
+            raw_headers.setdefault("content-length", content_length)
+
+        content_type = self.media_type
+        if content_type is not None and populate_content_type:
+            if content_type.startswith("text/") and "charset=" not in content_type.lower():
+                content_type += "; charset=" + self.charset
+            raw_headers.setdefault("content-type", content_type)
+
+        self.raw_headers = raw_headers
+
+
+def to_response(cls):
+    class ResponseWrapper(cls):
+        def __new__(cls, *args, **kwargs):
+            instance = super().__new__(cls)
+            instance.__init__(*args, **kwargs)
+            # Execute background tasks
+            task_manager = BackgroundTasks()
+            if instance.backgrounds:
+                for task in instance.backgrounds:
+                    task_manager.add_task(task)
+                task_manager.execute_all()
+                del task_manager
+
+            headers = Header(instance.raw_headers)
+            return InternalResponse(
+                status_code=instance.status_code,
+                headers=headers,
+                description=instance.body,
+            )
+
+    return ResponseWrapper
+
+
+@to_response
+class Response(BaseResponse):
+    media_type = None
+    charset = "utf-8"
+
+
+@to_response
+class JSONResponse(BaseResponse):
+    media_type = "application/json"
+
+
+@to_response
+class HTMLResponse(BaseResponse):
+    media_type = "text/html"
+
+
+@to_response
+class PlainTextResponse(BaseResponse):
+    media_type = "text/plain"
+
+
+@to_response
+class RedirectResponse(BaseResponse):
+    def __init__(
+        self,
+        url: str,
+        status_code: int = 307,
+        headers: typing.Mapping[str, str] | None = None,
+        backgrounds: typing.List[BackgroundTask] | None = None,
+    ) -> None:
+        super().__init__(content=b"", status_code=status_code, headers=headers, backgrounds=backgrounds)
+        self.raw_headers["location"] = quote(str(url), safe=":/%#?=@[]!$&'()*+,;")
+
+
+@to_response
+class FileResponse(BaseResponse):
+    def __init__(
+        self,
+        content: bytes | memoryview,
+        filename: str,
+        status_code: int = 200,
+        headers: typing.Mapping[str, str] | None = None,
+        backgrounds: typing.List[BackgroundTask] | None = None,
+    ) -> None:
+        super().__init__(content=content, status_code=status_code, headers=headers, backgrounds=backgrounds)
+        self.raw_headers["content-disposition"] = f'attachment; filename="{filename}"'
+        self.raw_headers.setdefault("content-type", "application/octet-stream")
+        self.raw_headers.setdefault("content-length", str(len(content)))
+
+
+@to_response
+class BinaryResponse(BaseResponse):
+    def __init__(self, content: bytes):
+        super().__init__(status_code=200, media_type="application/x-msgpack", headers={"Content-Type": "application/x-msgpack"})
+        self.content = msgpack.packb(content)

hypern/routing/__init__.py

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

hypern/routing/dispatcher.py

@@ -0,0 +1,70 @@
+# -*- coding: utf-8 -*-
+from __future__ import annotations
+
+import asyncio
+import functools
+import inspect
+import traceback
+import typing
+
+import orjson
+from pydantic import BaseModel
+
+from hypern.exceptions import HTTPException
+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:
+    while isinstance(obj, functools.partial):
+        obj = obj.funcz
+    return asyncio.iscoroutinefunction(obj) or (callable(obj) and asyncio.iscoroutinefunction(obj.__call__))
+
+
+async def run_in_threadpool(func: typing.Callable, *args, **kwargs):
+    if kwargs:  # pragma: no cover
+        # run_sync doesn't accept 'kwargs', so bind them in here
+        func = functools.partial(func, **kwargs)
+    return await asyncio.to_thread(func, *args)
+
+
+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)
+        _response_type = signature.return_annotation
+        _kwargs = await input_handler.get_input_handler(signature, inject)
+
+        if is_async:
+            response = await handler(**_kwargs)  # type: ignore
+        else:
+            response = await run_in_threadpool(handler, **_kwargs)
+        if not isinstance(response, Response):
+            if isinstance(_response_type, type) and issubclass(_response_type, BaseModel):
+                response = _response_type.model_validate(response).model_dump(mode="json")  # type: ignore
+            response = JSONResponse(
+                content=orjson.dumps({"message": response, "error_code": None}),
+                status_code=200,
+            )
+
+    except Exception as e:
+        _res: typing.Dict = {"message": "", "error_code": "UNKNOWN_ERROR"}
+        if isinstance(e, HTTPException):
+            _res = e.to_dict()
+            _status = e.status_code
+        else:
+            traceback.print_exc()
+            _res["message"] = str(e)
+            _status = 400
+        response = JSONResponse(
+            content=orjson.dumps(_res),
+            status_code=_status,
+        )
+    return response

hypern/routing/endpoint.py

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+from __future__ import annotations
+
+import typing
+from typing import Any, Dict
+
+import orjson
+
+from hypern.hypern import Request, Response
+from hypern.response import JSONResponse
+
+from .dispatcher import dispatch
+
+
+class HTTPEndpoint:
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+
+    def method_not_allowed(self, request: Request) -> Response:
+        return JSONResponse(
+            description=orjson.dumps({"message": "Method Not Allowed", "error_code": "METHOD_NOT_ALLOW"}),
+            status_code=405,
+        )
+
+    async def dispatch(self, request: Request, inject: Dict[str, Any]) -> Response:
+        handler_name = "get" if request.method == "HEAD" and not hasattr(self, "head") else request.method.lower()
+        handler: typing.Callable[[Request], typing.Any] = getattr(  # type: ignore
+            self, handler_name, self.method_not_allowed
+        )
+        return await dispatch(handler, request, inject)

hypern/routing/parser.py

@@ -0,0 +1,98 @@
+# -*- coding: utf-8 -*-
+from __future__ import annotations
+
+import inspect
+import typing
+
+import orjson
+from pydantic import BaseModel, ValidationError
+from pydash import get
+
+from hypern.auth.authorization import Authorization
+from hypern.exceptions import BadRequestException
+from hypern.exceptions import ValidationException
+from hypern.hypern import Request
+
+
+class ParamParser:
+    def __init__(self, request: Request):
+        self.request = request
+
+    def parse_data_by_name(self, param_name: str) -> dict:
+        param_name = param_name.lower()
+        data_parsers = {
+            "query_params": self._parse_query_params,
+            "path_params": self._parse_path_params,
+            "form_data": self._parse_form_data,
+        }
+
+        parser = data_parsers.get(param_name)
+        if not parser:
+            raise BadRequestException(details={"message": f"Invalid parameter name: {param_name}"})
+        return parser()
+
+    def _parse_query_params(self) -> dict:
+        query_params = self.request.query_params.to_dict()
+        return {k: v[0] for k, v in query_params.items()}
+
+    def _parse_path_params(self) -> dict:
+        return lambda: dict(self.request.path_params.items())
+
+    def _parse_form_data(self) -> dict:
+        return self.request.json()
+
+
+class InputHandler:
+    def __init__(self, request):
+        self.request = request
+        self.param_parser = ParamParser(request)
+
+    async def parse_pydantic_model(self, param_name: str, model_class: typing.Type[BaseModel]) -> BaseModel:
+        try:
+            data = self.param_parser.parse_data_by_name(param_name)
+            return model_class(**data)
+        except ValidationError as e:
+            invalid_fields = orjson.loads(e.json())
+            raise ValidationException(
+                details=[
+                    {
+                        "field": get(item, "loc")[0],
+                        "msg": get(item, "msg"),
+                    }
+                    for item in invalid_fields
+                ]
+            )
+
+    async def handle_special_params(self, param_name: str) -> typing.Any:
+        special_params = {
+            "request": lambda: self.request,
+        }
+        return special_params.get(param_name, lambda: None)()
+
+    async def get_input_handler(self, signature: inspect.Signature, inject: typing.Dict[str, typing.Any]) -> typing.Dict[str, typing.Any]:
+        """
+        Parse the request data and return the kwargs for the handler
+        """
+        kwargs = {}
+
+        for param in signature.parameters.values():
+            name = param.name
+            ptype = param.annotation
+
+            # Handle Pydantic models
+            if isinstance(ptype, type) and issubclass(ptype, BaseModel):
+                kwargs[name] = await self.parse_pydantic_model(name, ptype)
+                continue
+
+            # Handle Authorization
+            if isinstance(ptype, type) and issubclass(ptype, Authorization):
+                kwargs[name] = await ptype().validate(self.request)
+                continue
+
+            # Handle special parameters
+            special_value = await self.handle_special_params(name)
+            if special_value is not None:
+                kwargs[name] = special_value
+            if name in inject:
+                kwargs[name] = inject[name]
+        return kwargs

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}