hypern 0.3.11__cp312-cp312-musllinux_1_2_i686.whl

hypern/middleware/compress.py

@@ -0,0 +1,78 @@
+import gzip
+import zlib
+from typing import List, Optional
+
+from hypern.hypern import Request, Response
+
+from .base import Middleware, MiddlewareConfig
+
+
+class CompressionMiddleware(Middleware):
+    """
+    Middleware for compressing response content using gzip or deflate encoding.
+    """
+
+    def __init__(
+        self, config: Optional[MiddlewareConfig] = None, min_size: int = 500, compression_level: int = 6, include_types: Optional[List[str]] = None
+    ) -> None:
+        """
+        Initialize compression middleware.
+
+        Args:
+            min_size: Minimum response size in bytes to trigger compression
+            compression_level: Compression level (1-9, higher = better compression but slower)
+            include_types: List of content types to compress (defaults to common text types)
+        """
+        super().__init__(config)
+        self.min_size = min_size
+        self.compression_level = compression_level
+        self.include_types = include_types or [
+            "text/plain",
+            "text/html",
+            "text/css",
+            "text/javascript",
+            "application/javascript",
+            "application/json",
+            "application/xml",
+            "application/x-yaml",
+        ]
+
+    def before_request(self, request: Request) -> Request:
+        return request
+
+    def after_request(self, response: Response) -> Response:
+        # Check if response should be compressed
+        content_type = (response.headers.get("content-type") or "").split(";")[0].lower()
+        content_encoding = (response.headers.get("content-encoding") or "").lower()
+
+        # Skip if:
+        # - Content is already encoded
+        # - Content type is not in include list
+        # - Content length is below minimum size
+        if content_encoding or content_type not in self.include_types or len(response.description.encode()) < self.min_size:
+            return response
+
+        # Get accepted encodings from request
+        accept_encoding = (response.headers.get("accept-encoding") or "").lower()
+
+        if "gzip" in accept_encoding:
+            # Use gzip compression
+            response.description = gzip.compress(
+                response.description if isinstance(response.description, bytes) else str(response.description).encode(), compresslevel=self.compression_level
+            )
+            response.headers.set("content-encoding", "gzip")
+
+        elif "deflate" in accept_encoding:
+            # Use deflate compression
+            response.description = zlib.compress(
+                response.description if isinstance(response.description, bytes) else str(response.description).encode(), level=self.compression_level
+            )
+            response.headers.set("content-encoding", "deflate")
+
+        # Update content length after compression
+        response.headers.set("content-length", str(len(response.description)))
+
+        # Add Vary header to indicate content varies by Accept-Encoding
+        response.headers.set("vary", "Accept-Encoding")
+
+        return response

hypern/middleware/cors.py

@@ -0,0 +1,41 @@
+from typing import List, Optional
+from .base import Middleware
+from hypern.hypern import MiddlewareConfig
+
+
+class CORSMiddleware(Middleware):
+    """
+    The `CORSMiddleware` class is used to add CORS headers to the response based on specified origins,
+    methods, and headers.
+    """
+
+    def __init__(
+        self, config: Optional[MiddlewareConfig] = None, allow_origins: List[str] = None, allow_methods: List[str] = None, allow_headers: List[str] = None
+    ) -> None:
+        super().__init__(config)
+        self.allow_origins = allow_origins or []
+        self.allow_methods = allow_methods or []
+        self.allow_headers = allow_headers or []
+
+    def before_request(self, request):
+        return request
+
+    def after_request(self, response):
+        """
+        The `after_request` function adds Access-Control headers to the response based on specified origins,
+        methods, and headers.
+
+        :param response: The `after_request` method is used to add CORS (Cross-Origin Resource Sharing)
+        headers to the response object before sending it back to the client. The parameters used in this
+        method are:
+        :return: The `response` object is being returned from the `after_request` method.
+        """
+        for origin in self.allow_origins:
+            self.app.add_response_header("Access-Control-Allow-Origin", origin)
+            self.app.add_response_header(
+                "Access-Control-Allow-Methods",
+                ", ".join([method.upper() for method in self.allow_methods]),
+            )
+            self.app.add_response_header("Access-Control-Allow-Headers", ", ".join(self.allow_headers))
+            self.app.add_response_header("Access-Control-Allow-Credentials", "true")
+        return response

hypern/middleware/i18n.py

@@ -0,0 +1 @@
+# comming soon

hypern/middleware/limit.py

@@ -0,0 +1,177 @@
+from typing import Optional
+import time
+from abc import ABC, abstractmethod
+from threading import Lock
+
+from hypern.hypern import Request, Response
+
+from .base import Middleware, MiddlewareConfig
+
+
+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, config: Optional[MiddlewareConfig] = None, requests_per_minute=60, window_size=60):
+        super().__init__(config)
+        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.remote_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/middleware/security.py

@@ -0,0 +1,184 @@
+import hashlib
+import hmac
+import secrets
+import time
+from base64 import b64decode, b64encode
+from dataclasses import dataclass
+from datetime import datetime, timedelta, timezone
+from typing import Any, Dict, List, Optional
+
+import jwt
+
+from hypern.exceptions import ForbiddenException, UnauthorizedException
+from hypern.hypern import Request, Response
+from .base import Middleware, MiddlewareConfig
+
+
+@dataclass
+class CORSConfig:
+    allowed_origins: List[str]
+    allowed_methods: List[str]
+    max_age: int
+
+
+@dataclass
+class SecurityConfig:
+    rate_limiting: bool = False
+    jwt_auth: bool = False
+    cors_configuration: Optional[CORSConfig] = None
+    csrf_protection: bool = False
+    security_headers: Optional[Dict[str, str]] = None
+    jwt_secret: str = ""
+    jwt_algorithm: str = "HS256"
+    jwt_expires_in: int = 3600  # 1 hour in seconds
+
+    def __post_init__(self):
+        if self.cors_configuration:
+            self.cors_configuration = CORSConfig(**self.cors_configuration)
+
+        if self.security_headers is None:
+            self.security_headers = {
+                "X-Frame-Options": "DENY",
+                "X-Content-Type-Options": "nosniff",
+                "Strict-Transport-Security": "max-age=31536000; includeSubDomains",
+            }
+
+
+class SecurityMiddleware(Middleware):
+    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.secur_config.rate_limiting:
+            return None
+
+        client_ip = request.client.host
+        current_time = time.time()
+        window_start = int(current_time - 60)  # 1-minute window
+
+        # Clean up old entries
+        self._rate_limit_storage = {ip: hits for ip, hits in self._rate_limit_storage.items() if hits["timestamp"] > window_start}
+
+        if client_ip not in self._rate_limit_storage:
+            self._rate_limit_storage[client_ip] = {"count": 1, "timestamp": current_time}
+        else:
+            self._rate_limit_storage[client_ip]["count"] += 1
+
+        if self._rate_limit_storage[client_ip]["count"] > 60:  # 60 requests per minute
+            return Response(status_code=429, description=b"Too Many Requests", headers={"Retry-After": "60"})
+        return None
+
+    def _generate_jwt_token(self, user_data: Dict[str, Any]) -> str:
+        """Generate a JWT token"""
+        if not self.secur_config.jwt_secret:
+            raise ValueError("JWT secret key is not configured")
+
+        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.secur_config.jwt_secret, algorithms=[self.secur_config.jwt_algorithm])
+            return payload
+        except jwt.ExpiredSignatureError:
+            raise UnauthorizedException(details={"message": "Token has expired"})
+        except jwt.InvalidTokenError:
+            raise UnauthorizedException(details={"message": "Invalid token"})
+
+    def _generate_csrf_token(self, session_id: str) -> str:
+        """Generate a new CSRF token"""
+        timestamp = str(int(time.time()))
+        token_data = f"{session_id}:{timestamp}"
+        signature = hmac.new(self._secret_key, token_data.encode(), hashlib.sha256).digest()
+        return b64encode(f"{token_data}:{b64encode(signature).decode()}".encode()).decode()
+
+    def _validate_csrf_token(self, token: str) -> bool:
+        """Validate CSRF token"""
+        try:
+            decoded_token = b64decode(token.encode()).decode()
+            session_id, timestamp, signature = decoded_token.rsplit(":", 2)
+
+            # Verify timestamp
+            token_time = int(timestamp)
+            current_time = int(time.time())
+            if current_time - token_time > self._token_lifetime:
+                return False
+
+            # Verify signature
+            expected_data = f"{session_id}:{timestamp}"
+            expected_signature = hmac.new(self._secret_key, expected_data.encode(), hashlib.sha256).digest()
+
+            actual_signature = b64decode(signature)
+            return hmac.compare_digest(expected_signature, actual_signature)
+
+        except (ValueError, AttributeError, TypeError):
+            return False
+
+    def _apply_cors_headers(self, response: Response) -> None:
+        """Apply CORS headers to response"""
+        if not self.secur_config.cors_configuration:
+            return
+
+        cors = self.secur_config.cors_configuration
+        response.headers.update(
+            {
+                "Access-Control-Allow-Origin": ", ".join(cors.allowed_origins),
+                "Access-Control-Allow-Methods": ", ".join(cors.allowed_methods),
+                "Access-Control-Max-Age": str(cors.max_age),
+                "Access-Control-Allow-Headers": "Content-Type, Authorization, X-CSRF-Token",
+                "Access-Control-Allow-Credentials": "true",
+            }
+        )
+
+    def _apply_security_headers(self, response: Response) -> None:
+        """Apply security headers to response"""
+        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"""
+        # Rate limiting check
+        if rate_limit_response := self._rate_limit_check(request):
+            return rate_limit_response
+
+        # JWT authentication check
+        if self.secur_config.jwt_auth:
+            auth_header = request.headers.get("Authorization")
+            if not auth_header or not auth_header.startswith("Bearer "):
+                raise UnauthorizedException(details={"message": "Authorization header missing or invalid"})
+            token = auth_header.split(" ")[1]
+            try:
+                request.user = self._verify_jwt_token(token)
+            except UnauthorizedException as e:
+                return Response(status_code=401, description=str(e))
+
+        # CSRF protection check
+        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 ForbiddenException(details={"message": "Invalid CSRF token"})
+
+        return request
+
+    async def after_request(self, response: Response) -> Response:
+        """Process response after handling"""
+        self._apply_security_headers(response)
+        self._apply_cors_headers(response)
+        return response
+
+    def generate_csrf_token(self, request: Request) -> str:
+        """Generate and set CSRF token for the request"""
+        if not hasattr(request, "session_id"):
+            request.session_id = secrets.token_urlsafe(32)
+        token = self._generate_csrf_token(request.session_id)
+        return token

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,51 @@
+# -*- 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", {})
+        for route in app.router.routes:
+            parsed = self.parse_docstring(route.doc)
+
+            if not parsed:
+                continue
+
+            if route.path not in schema["paths"]:
+                schema["paths"][route.path] = {}
+
+            schema["paths"][route.path][route.method.lower()] = 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,139 @@
+import asyncio
+import os
+import signal
+import sys
+from typing import List
+from concurrent.futures import ThreadPoolExecutor
+from multiprocess import Process
+from watchdog.observers import Observer
+
+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,
+    reload: bool = True,
+) -> List[Process]:
+    socket = SocketHeld(host, port)
+
+    process_pool = init_processpool(
+        server,
+        socket,
+        workers,
+        processes,
+        max_blocking_threads,
+    )
+
+    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(
+    server: Server,
+    socket: SocketHeld,
+    workers: int,
+    processes: int,
+    max_blocking_threads: int,
+) -> List[Process]:
+    process_pool = []
+
+    for i in range(processes):
+        copied_socket = socket.try_clone()
+        process = Process(
+            target=spawn_process,
+            args=(
+                server,
+                copied_socket,
+                workers,
+                max_blocking_threads,
+            ),
+            name=f"hypern-worker-{i}",
+        )
+        process.daemon = True  # This is important to avoid zombie processes
+        process.start()
+        process_pool.append(process)
+
+    return process_pool
+
+
+class OptimizedEventLoopPolicy(asyncio.DefaultEventLoopPolicy):
+    def __init__(self, max_blocking_threads: int):
+        super().__init__()
+        self.max_blocking_threads = max_blocking_threads
+
+    def new_event_loop(self):
+        loop = super().new_event_loop()
+        # Optimize thread pool cho I/O operations
+        loop.set_default_executor(ThreadPoolExecutor(max_workers=self.max_blocking_threads, thread_name_prefix="hypern-io"))
+        return loop
+
+
+def initialize_event_loop(max_blocking_threads: int = 100) -> asyncio.AbstractEventLoop:
+    if sys.platform.startswith("win32") or sys.platform.startswith("linux-cross"):
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+    else:
+        import uvloop
+
+        uvloop.install()
+
+        asyncio.set_event_loop_policy(OptimizedEventLoopPolicy(max_blocking_threads))
+        loop = uvloop.new_event_loop()
+        asyncio.set_event_loop(loop)
+
+    loop.slow_callback_duration = 0.1  # Log warnings for slow callbacks
+    loop.set_debug(False)  # Disable debug mode
+    return loop
+
+
+def spawn_process(
+    server: Server,
+    socket: SocketHeld,
+    workers: int,
+    max_blocking_threads: int,
+):
+    loop = initialize_event_loop(max_blocking_threads)
+
+    try:
+        server.start(socket, workers, max_blocking_threads)
+    except KeyboardInterrupt:
+        loop.close()