hypern 0.3.0__cp312-cp312-win32.whl

hypern/middleware/limit.py

@@ -0,0 +1,176 @@
+import time
+from abc import ABC, abstractmethod
+from threading import Lock
+
+from hypern.hypern import Request, Response
+
+from .base import Middleware
+
+
+class StorageBackend(ABC):
+    @abstractmethod
+    def increment(self, key, amount=1, expire=None):
+        pass
+
+    @abstractmethod
+    def get(self, key):
+        pass
+
+
+class RedisBackend(StorageBackend):
+    def __init__(self, redis_client):
+        self.redis = redis_client
+
+    def increment(self, key, amount=1, expire=None):
+        """
+        The `increment` function increments a value in Redis by a specified amount and optionally sets an
+        expiration time for the key.
+
+        :param key: The `key` parameter in the `increment` method is used to specify the key in the Redis
+        database that you want to increment
+        :param amount: The `amount` parameter in the `increment` method specifies the value by which the
+        key's current value should be incremented. By default, it is set to 1, meaning that if no specific
+        amount is provided, the key's value will be incremented by 1, defaults to 1 (optional)
+        :param expire: The `expire` parameter in the `increment` method is used to specify the expiration
+        time for the key in Redis. If a value is provided for `expire`, the key will expire after the
+        specified number of seconds. If `expire` is not provided (i.e., it is `None`
+        :return: The `increment` method returns the result of incrementing the value of the key by the
+        specified amount. If an expiration time is provided, it also sets the expiration time for the key in
+        Redis. The method returns the updated value of the key after the increment operation.
+        """
+        with self.redis.pipeline() as pipe:
+            pipe.incr(key, amount)
+            if expire:
+                pipe.expire(key, int(expire))
+            return pipe.execute()[0]
+
+    def get(self, key):
+        return int(self.redis.get(key) or 0)
+
+
+class InMemoryBackend(StorageBackend):
+    def __init__(self):
+        self.storage = {}
+
+    def increment(self, key, amount=1, expire=None):
+        """
+        The `increment` function updates the value associated with a key in a storage dictionary by a
+        specified amount and optionally sets an expiration time.
+
+        :param key: The `key` parameter in the `increment` method is used to identify the value that needs
+        to be incremented in the storage. It serves as a unique identifier for the value being manipulated
+        :param amount: The `amount` parameter in the `increment` method specifies the value by which the
+        existing value associated with the given `key` should be incremented. By default, if no `amount` is
+        provided, it will increment the value by 1, defaults to 1 (optional)
+        :param expire: The `expire` parameter in the `increment` method is used to specify the expiration
+        time for the key-value pair being incremented. If a value is provided for the `expire` parameter, it
+        sets the expiration time for the key in the storage dictionary to the current time plus the
+        specified expiration duration
+        :return: The function `increment` returns the updated value of the key in the storage after
+        incrementing it by the specified amount.
+        """
+        if key not in self.storage:
+            self.storage[key] = {"value": 0, "expire": None}
+        self.storage[key]["value"] += amount
+        if expire:
+            self.storage[key]["expire"] = time.time() + expire
+        return self.storage[key]["value"]
+
+    def get(self, key):
+        """
+        This Python function retrieves the value associated with a given key from a storage dictionary,
+        checking for expiration before returning the value or 0 if the key is not found.
+
+        :param key: The `key` parameter is used to specify the key of the item you want to retrieve from the
+        storage. The function checks if the key exists in the storage dictionary and returns the
+        corresponding value if it does. If the key has an expiration time set and it has expired, the
+        function deletes the key
+        :return: The `get` method returns the value associated with the given key if the key is present in
+        the storage and has not expired. If the key is not found or has expired, it returns 0.
+        """
+        if key in self.storage:
+            if self.storage[key]["expire"] and time.time() > self.storage[key]["expire"]:
+                del self.storage[key]
+                return 0
+            return self.storage[key]["value"]
+        return 0
+
+
+class RateLimitMiddleware(Middleware):
+    """
+    The RateLimitMiddleware class implements rate limiting functionality to restrict the number of
+    Requests per minute for a given IP address.
+    """
+
+    def __init__(self, storage_backend, requests_per_minute=60, window_size=60):
+        super().__init__()
+        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
+
+    def before_request(self, request: Request):
+        """
+        The `before_request` function checks the request rate limit and returns a 429 status code if the
+        limit is exceeded.
+
+        :param request: The `request` parameter in the `before_request` method is of type `Request`. It
+        is used to represent an incoming HTTP request that the server will process
+        :type request: Request
+        :return: The code snippet is a method called `before_request` that takes in a `Request` object
+        as a parameter.
+        """
+        identifier = self.get_request_identifier(request)
+        current_time = int(time.time())
+        window_key = f"{identifier}:{current_time // self.window_size}"
+
+        request_count = self.storage.increment(window_key, expire=self.window_size)
+
+        if request_count > self.requests_per_minute:
+            return Response(status_code=429, description=b"Too Many Requests", headers={"Retry-After": str(self.window_size)})
+
+        return request
+
+    def after_request(self, response):
+        return response
+
+
+class ConcurrentRequestMiddleware(Middleware):
+    # The `ConcurrentRequestMiddleware` class limits the number of concurrent requests and returns a 429
+    # status code with a Retry-After header if the limit is reached.
+    def __init__(self, max_concurrent_requests=100):
+        super().__init__()
+        self.max_concurrent_requests = max_concurrent_requests
+        self.current_requests = 0
+        self.lock = Lock()
+
+    def get_request_identifier(self, request):
+        return request.remote_addr
+
+    def before_request(self, request):
+        """
+        The `before_request` function limits the number of concurrent requests and returns a 429 status code
+        with a Retry-After header if the limit is reached.
+
+        :param request: The `before_request` method in the code snippet is a method that is called before
+        processing each incoming request. It checks if the number of current requests is within the allowed
+        limit (`max_concurrent_requests`). If the limit is exceeded, it returns a 429 status code with a
+        "Too Many Requests
+        :return: the `request` object after checking if the number of current requests is within the allowed
+        limit. If the limit is exceeded, it returns a 429 status code response with a "Too Many Requests"
+        description and a "Retry-After" header set to 5.
+        """
+
+        with self.lock:
+            if self.current_requests >= self.max_concurrent_requests:
+                return Response(status_code=429, description="Too Many Requests", headers={"Retry-After": "5"})
+            self.current_requests += 1
+
+        return request
+
+    def after_request(self, response):
+        with self.lock:
+            self.current_requests -= 1
+        return response

hypern/openapi/__init__.py

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+from .schemas import SchemaGenerator
+from .swagger import SwaggerUI
+
+__all__ = ["SchemaGenerator", "SwaggerUI"]

hypern/openapi/schemas.py

@@ -0,0 +1,53 @@
+# -*- coding: utf-8 -*-
+from __future__ import annotations
+
+from hypern.hypern import BaseSchemaGenerator, Route as InternalRoute
+import typing
+import orjson
+
+
+class EndpointInfo(typing.NamedTuple):
+    path: str
+    http_method: str
+    func: typing.Callable[..., typing.Any]
+
+
+class SchemaGenerator(BaseSchemaGenerator):
+    def __init__(self, base_schema: dict[str, typing.Any]) -> None:
+        self.base_schema = base_schema
+
+    def get_endpoints(self, routes: list[InternalRoute]) -> list[EndpointInfo]:
+        """
+        Given the routes, yields the following information:
+
+        - path
+            eg: /users/
+        - http_method
+            one of 'get', 'post', 'put', 'patch', 'delete', 'options'
+        - func
+            method ready to extract the docstring
+        """
+        endpoints_info: list[EndpointInfo] = []
+
+        for route in routes:
+            method = route.method.lower()
+            endpoints_info.append(EndpointInfo(path=route.path, http_method=method, func=route.function.handler))
+        return endpoints_info
+
+    def get_schema(self, app) -> dict[str, typing.Any]:
+        schema = dict(self.base_schema)
+        schema.setdefault("paths", {})
+        endpoints_info = self.get_endpoints(app.router.routes)
+
+        for endpoint in endpoints_info:
+            parsed = self.parse_docstring(endpoint.func)
+
+            if not parsed:
+                continue
+
+            if endpoint.path not in schema["paths"]:
+                schema["paths"][endpoint.path] = {}
+
+            schema["paths"][endpoint.path][endpoint.http_method] = orjson.loads(parsed)
+
+        return schema

hypern/openapi/swagger.py

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

hypern/processpool.py

@@ -0,0 +1,137 @@
+import asyncio
+import os
+import signal
+import sys
+from typing import Any, Dict, List
+
+from multiprocess import Process
+from watchdog.observers import Observer
+
+from .hypern import FunctionInfo, Router, Server, SocketHeld, WebsocketRouter
+from .logging import logger
+from .reload import EventHandler
+
+
+def run_processes(
+    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
+    )
+
+    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)
+
+    if reload:
+        # Set up file system watcher for auto-reload
+        watch_dirs = [os.getcwd()]
+        observer = Observer()
+        reload_handler = EventHandler(file_path=sys.argv[0], directory_path=os.getcwd())
+
+        for directory in watch_dirs:
+            observer.schedule(reload_handler, directory, recursive=True)
+
+        observer.start()
+
+    logger.info(f"Server started at http://{host}:{port}")
+    logger.info("Press Ctrl + C to stop")
+
+    try:
+        for process in process_pool:
+            logger.debug(f"Process {process.pid} started")
+            process.join()
+    except KeyboardInterrupt:
+        pass
+    finally:
+        if reload:
+            observer.stop()
+            observer.join()
+
+    return process_pool
+
+
+def init_processpool(
+    router: Router,
+    websocket_router: WebsocketRouter,
+    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, websocket_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,
+    websocket_router: WebsocketRouter,
+    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/reload.py

@@ -0,0 +1,60 @@
+import sys
+import time
+import subprocess
+from watchdog.events import FileSystemEventHandler
+
+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  # Keep track of the subprocess
+        self.last_reload = time.time()  # Keep track of the last reload. EventHandler is initialized with the process.
+
+    def stop_server(self):
+        if self.process:
+            try:
+                # Check if the process is still alive
+                if self.process.poll() is None:  # None means the process is still running
+                    self.process.terminate()  # Gracefully terminate the process
+                    self.process.wait(timeout=5)  # Wait for the process to exit
+                else:
+                    logger.error("Process is not running.")
+            except subprocess.TimeoutExpired:
+                logger.error("Process did not terminate in time. Forcing termination.")
+                self.process.kill()  # Forcefully kill the process if it doesn't stop
+            except ProcessLookupError:
+                logger.error("Process does not exist.")
+            except Exception as e:
+                logger.error(f"An error occurred while stopping the server: {e}")
+        else:
+            logger.debug("No process to stop.")
+
+    def reload(self):
+        self.stop_server()
+        logger.debug("Reloading the server")
+        prev_process = self.process
+        if prev_process:
+            prev_process.kill()
+
+        self.process = subprocess.Popen(
+            [sys.executable, *sys.argv],
+        )
+
+        self.last_reload = time.time()
+
+    def on_modified(self, event) -> None:
+        """
+        This function is a callback that will start a new server on every even change
+
+        :param event FSEvent: a data structure with info about the events
+        """
+
+        # Avoid reloading multiple times when watchdog detects multiple events
+        if time.time() - self.last_reload < 0.5:
+            return
+
+        time.sleep(0.2)  # Wait for the file to be fully 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,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)