hypern 0.3.0__cp312-cp312-win_amd64.whl

hypern/exceptions.py

@@ -0,0 +1,97 @@
+# -*- coding: utf-8 -*-
+from typing import Any
+from hypern.enum import ErrorCode
+
+
+class BaseException(Exception):
+    def __init__(self, msg: str = "", *args: Any) -> None:
+        super().__init__(*args)
+        self.msg = msg
+        self.status = 400
+        self.error_code = ErrorCode.UNKNOWN_ERROR
+
+
+class BadRequest(BaseException):
+    def __init__(
+        self,
+        msg: str = "Bad request",
+        error_code: str = ErrorCode.BAD_REQUEST,
+        *args: Any,
+    ) -> None:
+        super().__init__(msg, *args)
+        self.error_code = error_code
+
+
+class ValidationError(BaseException):
+    def __init__(
+        self,
+        msg: str = "Validation error",
+        error_code: str = ErrorCode.VALIDATION_ERROR,
+        *args: Any,
+    ) -> None:
+        super().__init__(msg, *args)
+        self.error_code = error_code
+
+
+class Forbidden(BaseException):
+    def __init__(
+        self,
+        msg: str = "Forbidden",
+        error_code: str = ErrorCode.FORBIDDEN,
+        *args: Any,
+    ) -> None:
+        super().__init__(msg, *args)
+        self.status = 403
+        self.error_code = error_code
+
+
+class NotFound(BaseException):
+    def __init__(
+        self,
+        msg: str = "NotFound",
+        error_code: str = ErrorCode.NOT_FOUND,
+        *args: Any,
+    ) -> None:
+        super().__init__(msg, *args)
+        self.status = 404
+        self.error_code = error_code
+
+
+class MethodNotAllow(BaseException):
+    def __init__(
+        self,
+        msg: str = "Method not allow",
+        error_code: str = ErrorCode.METHOD_NOT_ALLOW,
+        *args: Any,
+    ) -> None:
+        super().__init__(msg, *args)
+        self.status = 405
+        self.error_code = error_code
+
+
+class InternalServer(BaseException):
+    def __init__(
+        self,
+        msg: str = "Internal server error",
+        error_code: str = ErrorCode.SERVER_ERROR,
+        *args: Any,
+    ) -> None:
+        super().__init__(msg, *args)
+        self.status = 500
+        self.error_code = error_code
+
+
+class Unauthorized(BaseException):
+    def __init__(
+        self,
+        msg: str = "Unauthorized",
+        error_code: str = ErrorCode.UNAUTHORIZED,
+        *args: Any,
+    ) -> None:
+        super().__init__(msg, *args)
+        self.status = 401
+        self.error_code = error_code
+
+
+class InvalidPortNumber(Exception):
+    pass

hypern/hypern.pyi

@@ -0,0 +1,295 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Callable, Dict, List, Tuple
+
+@dataclass
+class BaseBackend:
+    get: Callable[[str], Any]
+    set: Callable[[Any, str, int], None]
+    delete_startswith: Callable[[str], None]
+
+@dataclass
+class RedisBackend(BaseBackend):
+    url: str
+
+    get: Callable[[str], Any]
+    set: Callable[[Any, str, int], None]
+    delete_startswith: Callable[[str], None]
+
+@dataclass
+class BaseSchemaGenerator:
+    remove_converter: Callable[[str], str]
+    parse_docstring: Callable[[Callable[..., Any]], str]
+
+@dataclass
+class SwaggerUI:
+    title: str
+    openapi_url: str
+
+    def get_html_content(self) -> str: ...
+
+@dataclass
+class BackgroundTask:
+    """
+    A task to be executed in the background
+    id: str: The task ID
+    function: Callable[..., Any]: The function to be executed
+    args: List | Tuple: The arguments to be passed to the function
+    kwargs: Dict[str, Any]: The keyword arguments to be passed to the function
+    timeout_secs: int: The maximum time in seconds the task is allowed to run
+    cancelled: bool: Whether the task is cancelled
+
+    **Note**: function is currently running with sync mode, so it should be a sync function
+    """
+
+    id: str
+    function: Callable[..., Any]
+    args: List | Tuple
+    kwargs: Dict[str, Any]
+    timeout_secs: int
+    cancelled: bool
+
+    def get_id(self) -> str:
+        """
+        Get the task ID
+        """
+        pass
+
+    def cancel(self) -> None:
+        """
+        Cancel the task
+        """
+        pass
+
+    def is_cancelled(self) -> bool:
+        """
+        Check if the task is cancelled
+        """
+        pass
+
+    def execute(self) -> Any:
+        """
+        Execute the task
+        """
+        pass
+
+@dataclass
+class BackgroundTasks:
+    """
+    A collection of tasks to be executed in the background
+
+    **Note**: Only set tasks. pool, sender, receiver are set by the framework
+    """
+
+    def add_task(self, task: BackgroundTask) -> str:
+        """
+        Add a task to the collection
+        """
+        pass
+
+    def cancel_task(self, task_id: str) -> bool:
+        """
+        Cancel a task in the collection
+        """
+        pass
+
+    def execute_all(self) -> None:
+        """
+        Execute all tasks in the collection
+        """
+        pass
+
+    def execute_task(self, task_id: str) -> None:
+        """
+        Execute a task in the collection
+        """
+        pass
+
+class Scheduler:
+    def add_job(
+        self,
+        job_type: str,
+        schedule_param: str,
+        task: Callable[..., Any],
+        timezone: str,
+        dependencies: List[str],
+        retry_policy: Tuple[int, int, bool] | None = None,
+    ) -> str:
+        """
+        Add a job to the scheduler
+        params:
+        job_type: str: The type of the job (e.g. "cron", "interval")
+
+        schedule_param: str: The schedule parameter of the job. interval in seconds for interval jobs, cron expression for cron jobs
+
+        Exmaple:
+        //           sec  min   hour   day of month   month   day of week   year
+        expression = "0   30   9,12,15     1,15       May-Aug  Mon,Wed,Fri  2018/2";
+
+        task: Callable[..., Any]: The task to be executed
+
+        timezone: str: The timezone of the job
+
+        dependencies: List[str]: The IDs of the jobs this job depends on
+
+        retry_policy: Tuple[int, int, bool] | None: The retry policy of the job. (max_retries, retry_delay_secs, exponential_backoff)
+
+        return:
+        str: The ID of the job
+        """
+        pass
+
+    def remove_job(self, job_id: str) -> None:
+        """
+        Remove a job from the scheduler
+        """
+        pass
+
+    def start(self) -> None:
+        """
+        Start the scheduler
+        """
+        pass
+
+    def stop(self) -> None:
+        """
+        Stop the scheduler
+        """
+        pass
+
+    def get_job_status(self, job_id: str) -> Tuple[float, float, List[str], int]:
+        """
+        Get the status of a job
+        """
+        pass
+
+    def get_next_run(self, job_id: str) -> float:
+        """
+        Get the next run time of a job
+        """
+        pass
+
+@dataclass
+class FunctionInfo:
+    """
+    The function info object passed to the route handler.
+
+    Attributes:
+        handler (Callable): The function to be called
+        is_async (bool): Whether the function is async or not
+    """
+
+    handler: Callable
+    is_async: bool
+
+@dataclass
+class Server:
+    router: Router
+    websocket_router: Any
+    startup_handler: Any
+    shutdown_handler: Any
+
+    def add_route(self, route: Route) -> None: ...
+    def set_router(self, router: Router) -> None: ...
+    def set_websocket_router(self, websocket_router: WebsocketRouter) -> None: ...
+    def start(self, socket: SocketHeld, worker: int, max_blocking_threads: int) -> None: ...
+    def inject(self, key: str, value: Any) -> None: ...
+    def set_injected(self, injected: Dict[str, Any]) -> None: ...
+    def set_before_hooks(self, hooks: List[FunctionInfo]) -> None: ...
+    def set_after_hooks(self, hooks: List[FunctionInfo]) -> None: ...
+    def set_response_headers(self, headers: Dict[str, str]) -> None: ...
+
+class Route:
+    path: str
+    function: FunctionInfo
+    method: str
+
+    def matches(self, path: str, method: str) -> str: ...
+    def clone_route(self) -> Route: ...
+    def update_path(self, new_path: str) -> None: ...
+    def update_method(self, new_method: str) -> None: ...
+    def is_valid(self) -> bool: ...
+    def get_path_parans(self) -> List[str]: ...
+    def has_parameters(self) -> bool: ...
+    def normalized_path(self) -> str: ...
+    def same_handler(self, other: Route) -> bool: ...
+
+class Router:
+    routes: List[Route]
+
+    def add_route(self, route: Route) -> None: ...
+    def remove_route(self, path: str, method: str) -> bool: ...
+    def get_route(self, path: str, method) -> Route | None: ...
+    def get_routes_by_path(self, path: str) -> List[Route]: ...
+    def get_routes_by_method(self, method: str) -> List[Route]: ...
+    def extend_route(self, routes: List[Route]) -> None: ...
+
+@dataclass
+class SocketHeld:
+    socket: Any
+
+@dataclass
+class WebSocketSession:
+    sender: Callable[[str], None]
+    receiver: Callable[[], str]
+    is_closed: bool
+
+    def send(self, message: str) -> None: ...
+
+@dataclass
+class WebsocketRoute:
+    path: str
+    handler: Callable[[WebSocketSession], None]
+
+@dataclass
+class WebsocketRouter:
+    path: str
+    routes: List[WebsocketRoute]
+
+    def add_route(self, route: WebsocketRoute) -> None: ...
+    def remove_route(self, path: str) -> None: ...
+    def extend_route(self, route: WebsocketRoute) -> None: ...
+    def clear_routes(self) -> None: ...
+    def route_count(self) -> int: ...
+
+@dataclass
+class Header:
+    headers: Dict[str, str]
+
+@dataclass
+class Response:
+    status_code: int
+    response_type: str
+    headers: Any
+    description: str
+    file_path: str
+
+@dataclass
+class QueryParams:
+    queries: Dict[str, List[str]]
+
+@dataclass
+class UploadedFile:
+    name: str
+    content_type: str
+    path: str
+    size: int
+    content: bytes
+    filename: str
+
+@dataclass
+class BodyData:
+    json: bytes
+    files: List[UploadedFile]
+
+@dataclass
+class Request:
+    query_params: QueryParams
+    headers: Dict[str, str]
+    path_params: Dict[str, str]
+    body: BodyData
+    method: str
+    remote_addr: str
+    timestamp: float
+    context_id: str

hypern/logging/__init__.py

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

hypern/logging/logger.py

@@ -0,0 +1,82 @@
+# -*- coding: utf-8 -*-
+import logging
+import sys
+from copy import copy
+from datetime import datetime, timezone
+from typing import Literal, Optional
+
+import click
+
+TRACE_LOG_LEVEL = 5
+
+
+class ColourizedFormatter(logging.Formatter):
+    level_name_colors = {
+        TRACE_LOG_LEVEL: lambda level_name: click.style(str(level_name), fg="blue"),
+        logging.DEBUG: lambda level_name: click.style(str(level_name), fg="cyan"),
+        logging.INFO: lambda level_name: click.style(str(level_name), fg="green"),
+        logging.WARNING: lambda level_name: click.style(str(level_name), fg="yellow"),
+        logging.ERROR: lambda level_name: click.style(str(level_name), fg="red"),
+        logging.CRITICAL: lambda level_name: click.style(str(level_name), fg="bright_red"),
+    }
+
+    def __init__(
+        self,
+        fmt: Optional[str] = None,
+        datefmt: Optional[str] = None,
+        style: Literal["%", "{", "$"] = "%",
+        use_colors: Optional[bool] = None,
+    ):
+        if use_colors in (True, False):
+            self.use_colors = use_colors
+        else:
+            self.use_colors = sys.stdout.isatty()
+        super().__init__(fmt=fmt, datefmt=datefmt, style=style)
+
+    def color_level_name(self, level_name: str, level_no: int) -> str:
+        def default(level_name: str) -> str:
+            return str(level_name)
+
+        func = self.level_name_colors.get(level_no, default)
+        return func(level_name)
+
+    def should_use_colors(self) -> bool:
+        return True
+
+    def formatMessage(self, record: logging.LogRecord) -> str:
+        recordcopy = copy(record)
+        levelname = recordcopy.levelname
+        process = recordcopy.process
+        created = recordcopy.created
+        filename = recordcopy.filename
+        module = recordcopy.module
+        lineno = recordcopy.lineno
+        separator = " " * (5 - len(recordcopy.levelname))
+        if self.use_colors:
+            levelname = self.color_level_name(levelname, recordcopy.levelno)
+            if "color_message" in recordcopy.__dict__:
+                recordcopy.msg = recordcopy.__dict__["color_message"]
+                recordcopy.__dict__["message"] = recordcopy.getMessage()
+        recordcopy.__dict__["levelprefix"] = levelname + separator
+        recordcopy.__dict__["process"] = click.style(str(process), fg="blue")
+        recordcopy.__dict__["asctime"] = click.style(datetime.fromtimestamp(created, tz=timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%fZ"), fg=(101, 111, 104))
+        recordcopy.__dict__["filename"] = click.style(f"{module}/{filename}:{lineno}:", fg=(101, 111, 104))
+        return super().formatMessage(recordcopy)
+
+
+class DefaultFormatter(ColourizedFormatter):
+    def should_use_colors(self) -> bool:
+        return sys.stderr.isatty()
+
+
+def create_logger(name) -> logging.Logger:
+    logger = logging.getLogger(name)
+    logger.setLevel(logging.DEBUG)
+    formatter = DefaultFormatter(fmt="%(asctime)s %(levelprefix)s %(filename)s %(message)s", use_colors=True, datefmt="%Y-%m-%d %H:%M:%S")
+    handler = logging.StreamHandler()
+    handler.setFormatter(formatter)
+    logger.addHandler(handler)
+    return logger
+
+
+logger = create_logger("hypern")

hypern/middleware/__init__.py

@@ -0,0 +1,5 @@
+from .base import Middleware
+from .cors import CORSMiddleware
+from .limit import RateLimitMiddleware, StorageBackend, RedisBackend, InMemoryBackend
+
+__all__ = ["Middleware", "CORSMiddleware", "RateLimitMiddleware", "StorageBackend", "RedisBackend", "InMemoryBackend"]

hypern/middleware/base.py

@@ -0,0 +1,18 @@
+from abc import ABC, abstractmethod
+from hypern.hypern import Response, Request
+
+
+# The `Middleware` class is an abstract base class with abstract methods `before_request` and
+# `after_request` for handling requests and responses in a web application.
+class Middleware(ABC):
+    def __init__(self) -> None:
+        super().__init__()
+        self.app = None
+
+    @abstractmethod
+    def before_request(self, request: Request):
+        pass
+
+    @abstractmethod
+    def after_request(self, response: Response):
+        pass

hypern/middleware/cors.py

@@ -0,0 +1,38 @@
+from typing import List
+from .base import Middleware
+
+
+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, allow_origins: List[str] = None, allow_methods: List[str] = None, allow_headers: List[str] = None) -> None:
+        super().__init__()
+        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