hypern 0.2.0__cp312-none-win32.whl

hypern/processpool.py

@@ -0,0 +1,106 @@
+import asyncio
+import signal
+import sys
+from typing import Any, Dict, List
+
+from multiprocess import Process
+
+from .hypern import FunctionInfo, Router, Server, SocketHeld
+from .logging import logger
+
+
+def run_processes(
+    host: str,
+    port: int,
+    workers: int,
+    processes: int,
+    max_blocking_threads: int,
+    router: Router,
+    injectables: Dict[str, Any],
+    before_request: List[FunctionInfo],
+    after_request: List[FunctionInfo],
+    response_headers: Dict[str, str],
+) -> List[Process]:
+    socket = SocketHeld(host, port)
+
+    process_pool = init_processpool(router, socket, workers, processes, max_blocking_threads, injectables, before_request, after_request, response_headers)
+
+    def terminating_signal_handler(_sig, _frame):
+        logger.info("Terminating server!!")
+        for process in process_pool:
+            process.kill()
+
+    signal.signal(signal.SIGINT, terminating_signal_handler)
+    signal.signal(signal.SIGTERM, terminating_signal_handler)
+
+    logger.info("Press Ctrl + C to stop \n")
+    for process in process_pool:
+        process.join()
+
+    return process_pool
+
+
+def init_processpool(
+    router: Router,
+    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 = []
+
+    for _ in range(processes):
+        copied_socket = socket.try_clone()
+        process = Process(
+            target=spawn_process,
+            args=(router, copied_socket, workers, max_blocking_threads, injectables, before_request, after_request, response_headers),
+        )
+        process.start()
+        process_pool.append(process)
+
+    return process_pool
+
+
+def initialize_event_loop():
+    if sys.platform.startswith("win32") or sys.platform.startswith("linux-cross"):
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        return loop
+    else:
+        import uvloop
+
+        uvloop.install()
+        loop = uvloop.new_event_loop()
+        asyncio.set_event_loop(loop)
+        return loop
+
+
+def spawn_process(
+    router: Router,
+    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_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/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,134 @@
+from __future__ import annotations
+
+import typing
+from urllib.parse import quote
+from hypern.hypern import Response as InternalResponse, Header
+import orjson
+
+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)))

hypern/routing/__init__.py

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

hypern/routing/dispatcher.py

@@ -0,0 +1,67 @@
+# -*- 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 BaseException
+from hypern.hypern import Request, Response
+from hypern.response import JSONResponse
+
+from .parser import InputHandler
+
+
+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:
+        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, BaseException):
+            _res["error_code"] = e.error_code
+            _res["message"] = e.msg
+            _status = e.status
+        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,100 @@
+# -*- 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 BadRequest
+from hypern.exceptions import ValidationError as HypernValidationError
+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 BadRequest(msg="Backend Error: Invalid parameter type, must be query_params, path_params or form_data.")
+        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 HypernValidationError(
+                msg=orjson.dumps(
+                    [
+                        {
+                            "field": get(item, "loc")[0],
+                            "msg": get(item, "msg"),
+                        }
+                        for item in invalid_fields
+                    ]
+                ).decode("utf-8"),
+            )
+
+    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