hypern 0.3.3__cp312-cp312-win32.whl → 0.3.5__cp312-cp312-win32.whl

hypern/application.py

@@ -436,8 +436,6 @@ class Hypern:
         server.set_auto_compression(enabled=self.auto_compression)
         server.set_mem_pool_capacity(min_capacity=self.args.min_capacity, max_capacity=self.args.max_capacity)
 
-        server.optimize_routes()
-
         if self.database_config:
             server.set_database_config(config=self.database_config)
         if self.start_up_handler:

hypern/{db → database}/sql/field.py

@@ -437,7 +437,7 @@ class ArrayField(Field):
 class ForeignKey(Field):
     """Foreign key field representing a relationship to another model."""
 
-    def __init__(self, to_model: str, on_delete: str = "CASCADE", on_update: str = "CASCADE", **kwargs):
+    def __init__(self, to_model: str, related_field: str, on_delete: str = "CASCADE", on_update: str = "CASCADE", **kwargs):
         """
         Initialize a foreign key field.
 
@@ -455,6 +455,7 @@ class ForeignKey(Field):
         self.to_model = to_model
         self.on_delete = on_delete
         self.on_update = on_update
+        self.related_field = related_field
 
     def to_py_type(self, value: Any) -> Optional[int]:
         """

hypern/{db → database}/sql/model.py

@@ -109,7 +109,7 @@ class Model(metaclass=MetaModel):
 
     @classmethod
     def _get_foreign_key_sql(cls, name, field) -> str:
-        return f"FOREIGN KEY ({name}) REFERENCES {field.to_model}(id) ON DELETE {field.on_delete} ON UPDATE {field.on_update}"
+        return f"FOREIGN KEY ({name}) REFERENCES {field.to_model}({field.related_field}) ON DELETE {field.on_delete} ON UPDATE {field.on_update}"
 
     def save(self):
         query_object = QuerySet(self)

hypern/{db → database}/sql/query.py

@@ -1,5 +1,6 @@
 from enum import Enum
 from typing import Any, Dict, List, Tuple, Union
+from hypern.database.sql.field import ForeignKey
 
 
 class JoinType(Enum):
@@ -98,7 +99,7 @@ class F:
     """Class for creating SQL expressions and column references"""
 
     def __init__(self, field: str):
-        self.field = field.replace("__", ".")  # Handle Django-style field references
+        self.field = field.replace("__", ".")
 
     def __add__(self, other):
         if isinstance(other, F):
@@ -356,6 +357,7 @@ class QuerySet:
         self._nowait = False
         self._skip_locked = False
         self._param_counter = 1
+        self._selected_related = set()
 
     def __get_next_param(self):
         param_name = f"${self._param_counter}"
@@ -372,11 +374,12 @@ class QuerySet:
         new_qs._nowait = self._nowait
         new_qs._skip_locked = self._skip_locked
         new_qs._param_counter = self._param_counter
+        new_qs._selected_related = self._selected_related.copy()
         return new_qs
 
     def select(self, *fields, distinct: bool = False) -> "QuerySet":
         qs = self.clone()
-        qs.query_parts["select"] = list(fields)
+        qs.query_parts["select"] = list(map(lambda x: f"{qs.model.Meta.table_name}.{x}" if x != "*" else x, fields))
         qs._distinct = distinct
         return qs
 
@@ -426,10 +429,10 @@ class QuerySet:
         return self._process_standard_value(field, op, value)
 
     def _process_f_value(self, field: str, op: str, value: F) -> Tuple[str, List]:
-        return f"{field} {op} {value.field}", []
+        return f"{self.model.Meta.table_name}.{field} {op} {value.field}", []
 
     def _process_expression_value(self, field: str, op: str, value: Expression) -> Tuple[str, List]:
-        return f"{field} {op} {value.sql}", value.params
+        return f"{self.model.Meta.table_name}.{field} {op} {value.sql}", value.params
 
     def _process_standard_value(self, field: str, op: str, value: Any) -> Tuple[str, List]:
         op_map = {
@@ -453,25 +456,26 @@ class QuerySet:
             return self._process_op_map_value(field, op, value, op_map)
         else:
             param_name = self.__get_next_param()
-            return f"{field} = {param_name}", [value]
+            return f"{self.model.Meta.table_name}.{field} = {param_name}", [value]
 
     def _process_op_map_value(self, field: str, op: str, value: Any, op_map: dict) -> Tuple[str, List]:
         param_name = self.__get_next_param()
+        combine_field_name = f"{self.model.Meta.table_name}.{field}"
         if op in ("contains", "icontains"):
-            return f"{field} {op_map[op]} {param_name}", [f"%{value}%"]
+            return f"{combine_field_name} {op_map[op]} {param_name}", [f"%{value}%"]
         elif op == "startswith":
-            return f"{field} {op_map[op]} {param_name}", [f"{value}%"]
+            return f"{combine_field_name} {op_map[op]} {param_name}", [f"{value}%"]
         elif op == "endswith":
-            return f"{field} {op_map[op]} {param_name}", [f"%{value}"]
+            return f"{combine_field_name} {op_map[op]} {param_name}", [f"%{value}"]
         elif op == "isnull":
-            return f"{field} {Operator.IS_NULL.value if value else Operator.IS_NOT_NULL.value}", []
+            return f"{combine_field_name} {Operator.IS_NULL.value if value else Operator.IS_NOT_NULL.value}", []
         elif op == "between":
-            return f"{field} {op_map[op]} {param_name} AND {param_name}", [value[0], value[1]]
+            return f"{combine_field_name} {op_map[op]} {param_name} AND {param_name}", [value[0], value[1]]
         elif op in ("in", "not_in"):
             placeholders = ",".join(["{param_name}" for _ in value])
-            return f"{field} {op_map[op]} ({placeholders})", list(value)
+            return f"{combine_field_name} {op_map[op]} ({placeholders})", list(value)
         else:
-            return f"{field} {op_map[op]} {param_name}", [value]
+            return f"{combine_field_name} {op_map[op]} {param_name}", [value]
 
     def where(self, *args, **kwargs) -> "QuerySet":
         qs = self.clone()
@@ -535,22 +539,36 @@ class QuerySet:
             elif field.startswith("-"):
                 order_parts.append(f"{field[1:]} DESC")
             else:
-                order_parts.append(f"{field} ASC")
+                order_parts.append(f"{qs.model.Meta.table_name}.{field} ASC")
 
         qs.query_parts["order_by"] = order_parts
         return qs
 
-    def join(self, table: str, on: Union[str, Expression], join_type: Union[str, JoinType] = JoinType.INNER) -> "QuerySet":
+    def select_related(self, *fields) -> "QuerySet":
+        """
+        Include related objects in the query results.
+
+        Args:
+            *fields: Names of foreign key fields to include
+        """
+        qs = self.clone()
+        for field in fields:
+            if field in qs.model._fields and isinstance(qs.model._fields[field], ForeignKey):
+                qs._selected_related.add(field)
+        return qs
+
+    def join(self, table: Any, on: Union[str, Expression], join_type: Union[str, JoinType] = JoinType.INNER) -> "QuerySet":
         qs = self.clone()
+        joined_table = table.Meta.table_name if hasattr(table, "Meta") else table
 
         if isinstance(join_type, JoinType):
             join_type = join_type.value
 
         if isinstance(on, Expression):
-            qs.query_parts["joins"].append(f"{join_type} {table} ON {on.sql}")
+            qs.query_parts["joins"].append(f"{join_type} {joined_table} ON {on.sql}")
             qs.params.extend(on.params)
         else:
-            qs.query_parts["joins"].append(f"{join_type} {table} ON {on}")
+            qs.query_parts["joins"].append(f"{join_type} {joined_table} ON {on}")
 
         return qs
 
@@ -565,7 +583,7 @@ class QuerySet:
                 group_parts.append(field.sql)
                 qs.params.extend(field.params)
             else:
-                group_parts.append(str(field))
+                group_parts.append(f"{qs.model.Meta.table_name}.{field}")
 
         qs.query_parts["group_by"] = group_parts
         return qs
@@ -607,7 +625,7 @@ class QuerySet:
                 partition_parts.append(field.sql)
                 qs.params.extend(field.params)
             else:
-                partition_parts.append(str(field))
+                partition_parts.append(f"{self.model.Meta.table_name}.{field}")
         return f"PARTITION BY {', '.join(partition_parts)}"
 
     def _process_order_by(self, order_by: List, qs: "QuerySet") -> str:
@@ -619,9 +637,9 @@ class QuerySet:
                 order_parts.append(field.sql)
                 qs.params.extend(field.params)
             elif field.startswith("-"):
-                order_parts.append(f"{field[1:]} DESC")
+                order_parts.append(f"{qs.model.Meta.table_name}.{field[1:]} DESC")
             else:
-                order_parts.append(f"{field} ASC")
+                order_parts.append(f"{qs.model.Meta.table_name}.{field} ASC")
         return f"ORDER BY {', '.join(order_parts)}"
 
     def limit(self, limit: int) -> "QuerySet":
@@ -726,7 +744,14 @@ class QuerySet:
         select_clause = "SELECT"
         if self._distinct:
             select_clause += " DISTINCT"
-        select_clause += " " + ", ".join(self.query_parts["select"])
+
+        # Add selected fields
+        select_related_fields = []
+        for field in self._selected_related:
+            related_table = self.model._fields[field].to_model
+            select_related_fields.append(f"{related_table}.*")
+
+        select_clause += " " + ", ".join(self.query_parts["select"] + select_related_fields)
         parts.append(select_clause)
 
     def _add_from_clause(self, parts):

hypern/exceptions/__init__.py

@@ -0,0 +1,34 @@
+from .base import HTTPException, ResponseFormatter, HypernError
+from .errors import ErrorDefinitions
+from .formatters import SimpleFormatter, DetailedFormatter, LocalizedFormatter
+from .http import (
+    BadRequestException,
+    UnauthorizedException,
+    ForbiddenException,
+    NotFoundException,
+    ValidationException,
+    InternalServerException,
+    RateLimitException,
+)
+
+from .common import DBFieldValidationError, InvalidPortNumber, OutOfScopeApplicationException
+
+__all__ = [
+    "HTTPException",
+    "ResponseFormatter",
+    "HypernError",
+    "ErrorDefinitions",
+    "SimpleFormatter",
+    "DetailedFormatter",
+    "LocalizedFormatter",
+    "BadRequestException",
+    "UnauthorizedException",
+    "ForbiddenException",
+    "NotFoundException",
+    "ValidationException",
+    "InternalServerException",
+    "RateLimitException",
+    "DBFieldValidationError",
+    "InvalidPortNumber",
+    "OutOfScopeApplicationException",
+]

hypern/exceptions/base.py

@@ -0,0 +1,62 @@
+import uuid
+from abc import ABC, abstractmethod
+from datetime import datetime, timezone
+from http import HTTPStatus
+from typing import Any, Dict, Optional
+
+
+class ResponseFormatter(ABC):
+    @abstractmethod
+    def format_error(self, exception: "HTTPException") -> Dict[str, Any]:
+        """Format exception into response dictionary"""
+        pass
+
+
+class DefaultFormatter(ResponseFormatter):
+    def format_error(self, exception: "HTTPException") -> Dict[str, Any]:
+        return {
+            "error": {
+                "code": exception.error.code if exception.error else "UNKNOWN_ERROR",
+                "message": exception.error.message if exception.error else "Unknown error occurred",
+                "details": exception.details or {},
+                "timestamp": datetime.now(tz=timezone.utc).isoformat(),
+                "request_id": str(uuid.uuid4()),
+            },
+            "status": exception.status_code,
+        }
+
+
+class HypernError:
+    """Base error definition"""
+
+    def __init__(self, message: str, code: str):
+        self.message = message
+        self.code = code
+
+
+class HTTPException(Exception):
+    """Base HTTP exception"""
+
+    _formatter: ResponseFormatter = DefaultFormatter()
+
+    @classmethod
+    def set_formatter(cls, formatter: ResponseFormatter):
+        cls._formatter = formatter
+
+    def __init__(
+        self,
+        status_code: int = HTTPStatus.BAD_REQUEST,
+        error: Optional[HypernError] = None,
+        details: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        formatter: Optional[ResponseFormatter] = None,
+    ):
+        self.status_code = status_code
+        self.error = error
+        self.details = details or {}
+        self.headers = headers or {}
+        self._instance_formatter = formatter
+
+    def to_dict(self) -> Dict[str, Any]:
+        formatter = self._instance_formatter or self._formatter
+        return formatter.format_error(self)

hypern/exceptions/common.py

@@ -0,0 +1,12 @@
+class InvalidPortNumber(Exception):
+    pass
+
+
+class OutOfScopeApplicationException(Exception):
+    pass
+
+
+class DBFieldValidationError(ValueError):
+    """Custom exception for field validation errors."""
+
+    pass

hypern/exceptions/errors.py

@@ -0,0 +1,15 @@
+from .base import HypernError
+
+
+class ErrorDefinitions:
+    """Standard error definitions"""
+
+    BAD_REQUEST = HypernError(message="Bad request", code="BAD_REQUEST")
+    UNAUTHORIZED = HypernError(message="Unauthorized access", code="UNAUTHORIZED")
+    FORBIDDEN = HypernError(message="Access forbidden", code="FORBIDDEN")
+    NOT_FOUND = HypernError(message="Resource not found", code="NOT_FOUND")
+    METHOD_NOT_ALLOWED = HypernError(message="Method not allowed", code="METHOD_NOT_ALLOWED")
+    VALIDATION_ERROR = HypernError(message="Validation error", code="VALIDATION_ERROR")
+    INTERNAL_ERROR = HypernError(message="Internal server error", code="INTERNAL_SERVER_ERROR")
+    CONFLICT = HypernError(message="Resource conflict", code="CONFLICT")
+    TOO_MANY_REQUESTS = HypernError(message="Too many requests", code="TOO_MANY_REQUESTS")

hypern/exceptions/formatters.py

@@ -0,0 +1,56 @@
+import uuid
+from datetime import datetime, timezone
+from typing import Any, Dict
+
+from .base import HTTPException, ResponseFormatter
+
+
+class SimpleFormatter(ResponseFormatter):
+    def format_error(self, exception: HTTPException) -> Dict[str, Any]:
+        return {
+            "code": exception.error.code if exception.error else "UNKNOWN_ERROR",
+            "message": exception.error.message if exception.error else "Unknown error occurred",
+        }
+
+
+class DetailedFormatter(ResponseFormatter):
+    def format_error(self, exception: HTTPException) -> Dict[str, Any]:
+        return {
+            "status": {"code": exception.status_code, "text": str(exception.status_code)},
+            "error": {
+                "type": exception.error.code if exception.error else "UNKNOWN_ERROR",
+                "message": exception.error.message if exception.error else "Unknown error occurred",
+                "details": exception.details or {},
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+            },
+            "request": {"path": exception.path, "id": str(uuid.uuid4())},
+        }
+
+
+class LocalizedFormatter(ResponseFormatter):
+    def __init__(self, language: str = "en"):
+        self.language = language
+        self.translations = {
+            "en": {
+                "BAD_REQUEST": "Bad request",
+                "VALIDATION_ERROR": "Validation error",
+                "NOT_FOUND": "Resource not found",
+                # Add more translations
+            },
+            "vi": {
+                "BAD_REQUEST": "Yêu cầu không hợp lệ",
+                "VALIDATION_ERROR": "Lỗi xác thực",
+                "NOT_FOUND": "Không tìm thấy tài nguyên",
+                # Add more translations
+            },
+        }
+
+    def format_error(self, exception: HTTPException) -> Dict[str, Any]:
+        error_code = exception.error.code if exception.error else "UNKNOWN_ERROR"
+        translated_message = self.translations.get(self.language, {}).get(error_code, exception.error.message if exception.error else "Unknown error occurred")
+
+        return {
+            "error": {"code": error_code, "message": translated_message, "details": exception.details or {}},
+            "status": exception.status_code,
+            "timestamp": datetime.now(tz=timezone.utc).isoformat(),
+        }

hypern/exceptions/http.py

@@ -0,0 +1,76 @@
+from http import HTTPStatus
+from typing import Any, Dict, Optional
+
+from .base import HTTPException, ResponseFormatter, HypernError
+from .errors import ErrorDefinitions
+
+
+class BadRequestException(HTTPException):
+    def __init__(
+        self,
+        error: Optional[HypernError] = ErrorDefinitions.BAD_REQUEST,
+        details: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        formatter: Optional[ResponseFormatter] = None,
+    ):
+        super().__init__(status_code=HTTPStatus.BAD_REQUEST, error=error, details=details, headers=headers, formatter=formatter)
+
+
+class UnauthorizedException(HTTPException):
+    def __init__(
+        self,
+        error: Optional[HypernError] = ErrorDefinitions.UNAUTHORIZED,
+        details: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        formatter: Optional[ResponseFormatter] = None,
+    ):
+        super().__init__(status_code=HTTPStatus.UNAUTHORIZED, error=error, details=details, headers=headers, formatter=formatter)
+
+
+class ForbiddenException(HTTPException):
+    def __init__(
+        self,
+        error: Optional[HypernError] = ErrorDefinitions.FORBIDDEN,
+        details: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        formatter: Optional[ResponseFormatter] = None,
+    ):
+        super().__init__(status_code=HTTPStatus.FORBIDDEN, error=error, details=details, headers=headers, formatter=formatter)
+
+
+class NotFoundException(HTTPException):
+    def __init__(
+        self,
+        error: Optional[HypernError] = ErrorDefinitions.NOT_FOUND,
+        details: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        formatter: Optional[ResponseFormatter] = None,
+    ):
+        super().__init__(status_code=HTTPStatus.NOT_FOUND, error=error, details=details, headers=headers, formatter=formatter)
+
+
+class ValidationException(HTTPException):
+    def __init__(self, details: Optional[Dict[str, Any]] = None, headers: Optional[Dict[str, str]] = None, formatter: Optional[ResponseFormatter] = None):
+        super().__init__(status_code=HTTPStatus.BAD_REQUEST, error=ErrorDefinitions.VALIDATION_ERROR, details=details, headers=headers, formatter=formatter)
+
+
+class InternalServerException(HTTPException):
+    def __init__(
+        self,
+        error: Optional[HypernError] = ErrorDefinitions.INTERNAL_ERROR,
+        details: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        formatter: Optional[ResponseFormatter] = None,
+    ):
+        super().__init__(status_code=HTTPStatus.INTERNAL_SERVER_ERROR, error=error, details=details, headers=headers, formatter=formatter)
+
+
+class RateLimitException(HTTPException):
+    def __init__(self, retry_after: int, details: Optional[Dict[str, Any]] = None, formatter: Optional[ResponseFormatter] = None):
+        super().__init__(
+            status_code=HTTPStatus.TOO_MANY_REQUESTS,
+            error=ErrorDefinitions.TOO_MANY_REQUESTS,
+            details=details,
+            headers={"Retry-After": str(retry_after)},
+            formatter=formatter,
+        )

hypern/hypern.pyi

@@ -191,7 +191,6 @@ class Server:
     def set_auto_compression(self, enabled: bool) -> None: ...
     def set_database_config(self, config: DatabaseConfig) -> None: ...
     def set_mem_pool_capacity(self, min_capacity: int, max_capacity: int) -> None: ...
-    def optimize_routes(self) -> None: ...
 
 class Route:
     path: str

hypern/middleware/security.py

@@ -9,7 +9,7 @@ from typing import Any, Dict, List, Optional
 
 import jwt
 
-from hypern.exceptions import Forbidden, Unauthorized
+from hypern.exceptions import ForbiddenException, UnauthorizedException
 from hypern.hypern import Request, Response
 from .base import Middleware, MiddlewareConfig
 
@@ -91,9 +91,9 @@ class SecurityMiddleware(Middleware):
             payload = jwt.decode(token, self.secur_config.jwt_secret, algorithms=[self.secur_config.jwt_algorithm])
             return payload
         except jwt.ExpiredSignatureError:
-            raise Unauthorized("Token has expired")
+            raise UnauthorizedException(details={"message": "Token has expired"})
         except jwt.InvalidTokenError:
-            raise Unauthorized("Invalid token")
+            raise UnauthorizedException(details={"message": "Invalid token"})
 
     def _generate_csrf_token(self, session_id: str) -> str:
         """Generate a new CSRF token"""
@@ -155,18 +155,18 @@ class SecurityMiddleware(Middleware):
         if self.secur_config.jwt_auth:
             auth_header = request.headers.get("Authorization")
             if not auth_header or not auth_header.startswith("Bearer "):
-                raise Unauthorized("Missing or invalid authorization header")
+                raise UnauthorizedException(details={"message": "Authorization header missing or invalid"})
             token = auth_header.split(" ")[1]
             try:
                 request.user = self._verify_jwt_token(token)
-            except Unauthorized as e:
+            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 Forbidden("CSRF token missing or invalid")
+                raise ForbiddenException(details={"message": "Invalid CSRF token"})
 
         return request
 

hypern/processpool.py

@@ -3,7 +3,7 @@ import os
 import signal
 import sys
 from typing import List
-
+from concurrent.futures import ThreadPoolExecutor
 from multiprocess import Process
 from watchdog.observers import Observer
 
@@ -76,7 +76,7 @@ def init_processpool(
 ) -> List[Process]:
     process_pool = []
 
-    for _ in range(processes):
+    for i in range(processes):
         copied_socket = socket.try_clone()
         process = Process(
             target=spawn_process,
@@ -86,25 +86,43 @@ def init_processpool(
                 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
 
 
-def initialize_event_loop():
+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)
-        return 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)
-        return loop
+
+    loop.slow_callback_duration = 0.1  # Log warnings for slow callbacks
+    loop.set_debug(False)  # Disable debug mode
+    return loop
 
 
 def spawn_process(
@@ -113,7 +131,7 @@ def spawn_process(
     workers: int,
     max_blocking_threads: int,
 ):
-    loop = initialize_event_loop()
+    loop = initialize_event_loop(max_blocking_threads)
 
     try:
         server.start(socket, workers, max_blocking_threads)

hypern/response/response.py

@@ -4,6 +4,7 @@ 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
 
@@ -132,3 +133,10 @@ class FileResponse(BaseResponse):
         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/dispatcher.py

@@ -10,7 +10,7 @@ import typing
 import orjson
 from pydantic import BaseModel
 
-from hypern.exceptions import BaseException
+from hypern.exceptions import HTTPException
 from hypern.hypern import Request, Response
 from hypern.response import JSONResponse
 
@@ -56,10 +56,9 @@ async def dispatch(handler, request: Request, inject: typing.Dict[str, typing.An
 
     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
+        if isinstance(e, HTTPException):
+            _res = e.to_dict()
+            _status = e.status_code
         else:
             traceback.print_exc()
             _res["message"] = str(e)

hypern/routing/parser.py

@@ -9,8 +9,8 @@ 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.exceptions import BadRequestException
+from hypern.exceptions import ValidationException
 from hypern.hypern import Request
 
 
@@ -28,7 +28,7 @@ class ParamParser:
 
         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.")
+            raise BadRequestException(details={"message": f"Invalid parameter name: {param_name}"})
         return parser()
 
     def _parse_query_params(self) -> dict:
@@ -53,16 +53,14 @@ class InputHandler:
             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"),
+            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:

{hypern-0.3.3.dist-info → hypern-0.3.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypern
-Version: 0.3.3
+Version: 0.3.5
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
@@ -25,6 +25,7 @@ Requires-Dist: cryptography ==43.0.3
 Requires-Dist: watchdog ==6.0.0
 Requires-Dist: jsonschema ==4.23.0
 Requires-Dist: psutil ==6.1.0
+Requires-Dist: msgpack ==1.1.0
 License-File: LICENSE
 Summary: A Fast Async Python backend with a Rust runtime.
 Author-email: Martin Dang <vannghiem848@gmail.com>

{hypern-0.3.3.dist-info → hypern-0.3.5.dist-info}/RECORD

@@ -1,7 +1,7 @@
-hypern-0.3.3.dist-info/METADATA,sha256=VDUnlR9iin2qEAagUwnOdvZL1vC4dMeNM1oBrwl-rZ8,3819
-hypern-0.3.3.dist-info/WHEEL,sha256=SK_cql1gpDHx6aBV-LOSvGbTt4TUC8AJJOzjOP2tdpI,92
-hypern-0.3.3.dist-info/licenses/LICENSE,sha256=qbYKAIJLS6jYg5hYncKE7OtWmqOtpVTvKNkwOa0Iwwg,1328
-hypern/application.py,sha256=TZKwSHpWSOaValZtogmMO18l8U_xOpFN7cARMFK1hns,18432
+hypern-0.3.5.dist-info/METADATA,sha256=Lhxf8FMnS1RvE17wHATRz6F1-v0S3IYcXrGmzWkm3Jg,3850
+hypern-0.3.5.dist-info/WHEEL,sha256=SK_cql1gpDHx6aBV-LOSvGbTt4TUC8AJJOzjOP2tdpI,92
+hypern-0.3.5.dist-info/licenses/LICENSE,sha256=qbYKAIJLS6jYg5hYncKE7OtWmqOtpVTvKNkwOa0Iwwg,1328
+hypern/application.py,sha256=DCYFtU8e8NhQtmfaXbUfOxR2_Y3fEn-pzce9OOs6S4U,18396
 hypern/args_parser.py,sha256=zTfLfBoKBvYWxdPjabTfZsCtYF3La3PT0TD8dfLMeM4,2815
 hypern/auth/authorization.py,sha256=-NprZsI0np889ZN1fp-MiVFrPoMNzUtatBJaCMtkllM,32
 hypern/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -13,38 +13,43 @@ hypern/caching/__init__.py,sha256=ODO7zMm4iFG8wcvrhKmukryG5wOTW0DnzFvNMfF57Cc,35
 hypern/cli/commands.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hypern/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hypern/config.py,sha256=Jij9eGg5NgC8Un5Lw5i7ghuEMAfkVctdcoE4RaN5LTE,8157
+hypern/database/addons/sqlalchemy/fields/color.py,sha256=Jj8q4lkT0ukKyjVyZjBx7fokGrX7AIJpKOGzwsBpfnU,480
+hypern/database/addons/sqlalchemy/fields/daterange.py,sha256=qEfQN9c4jQdzeXNYKgQ4VIJ3Qc0HXHWRouzNF1se-RA,853
+hypern/database/addons/sqlalchemy/fields/datetime.py,sha256=Bp2jMja2lb_b2WnzRnfbjXXTHBgBTyph1ECsItIwvvg,643
+hypern/database/addons/sqlalchemy/fields/encrypted.py,sha256=pXsg4ImPpK-VkLDruKrv2gUtdp2kajQX7xDbRDxa-SI,1930
+hypern/database/addons/sqlalchemy/fields/password.py,sha256=9pypORygWaINj3oiAOBRIOGgpuA0lcjPq4rh1pqJxq0,5789
+hypern/database/addons/sqlalchemy/fields/ts_vector.py,sha256=bQyXYvQ1bAfFpYcS-sFwM7fU6L1lg9_7nGDRGp0CoUo,1361
+hypern/database/addons/sqlalchemy/fields/unicode.py,sha256=rbqyHlsPUqRDWIjYQSRFF3zkHncnwxo0sdlzqUlcrUw,411
+hypern/database/addons/sqlalchemy/fields/__init__.py,sha256=mLN_AvwgpSAbrWZvVHZuO7ff0gk1T_JbVwd5wug5nlw,359
+hypern/database/addons/sqlalchemy/repository.py,sha256=ue6vWOTrnEPyDevlyh3v-7PU6GSfrZHYKrbXVuoS8UA,9516
+hypern/database/addons/sqlalchemy/__init__.py,sha256=FuY78ubEwtifdQTVHhCrscYaAarlp2urgYBc_R77yt0,2766
+hypern/database/addons/__init__.py,sha256=mdW0P0xvnK8htUk02ujvIaeHXl6w53JjrTS4ioNi1Bw,63
+hypern/database/nosql/addons/color.py,sha256=bAGRuARCAYwZ1nO4jK0lzGYKmavTDtS34BxvrsetF74,446
+hypern/database/nosql/addons/daterange.py,sha256=hGUSoVFqatNY-TB5wjZTq62iZpHpdsyRJIsHxsj1uDs,1192
+hypern/database/nosql/addons/encrypted.py,sha256=B0M-uDqvZHVmIZcFdwcuC2MGsv0pGJFQ1lrOg8klR9U,1741
+hypern/database/nosql/addons/password.py,sha256=jfZxvWFm6nV9EWpXq5Mj-jpqnl9QbokZj9WT14n7dKE,5035
+hypern/database/nosql/addons/unicode.py,sha256=LaDpLfdoTcJuASPE-8fqOVD05H_uOx8gOdnyDn5Iu0c,268
+hypern/database/nosql/addons/__init__.py,sha256=WEtPM8sPHilvga7zxwqvINeTkF0hdcfgPcAnHc4MASE,125
+hypern/database/nosql/__init__.py,sha256=MH9YvlbRlbBCrQVNOdfTaK-hINwJxbJLmxwY9Mei7I8,644
+hypern/database/sql/field.py,sha256=tSs8iaYjy-K6nplJJ-1X4OQddzW76cfBlx9xTrG_NbQ,20073
+hypern/database/sql/model.py,sha256=BLRmOlmfn6ibedR9Bv_rHErSruudJ24B9-nDbRHqWm4,3913
+hypern/database/sql/query.py,sha256=tQ7Wss2NAIqsAH0M-fT5m9DU_MsiBR0DcoyTbS_aatU,33335
+hypern/database/sql/__init__.py,sha256=lCOGNTHaXNSJbuLLIOe2IWWNmX0MFQFPNCl2yytD2Xs,261
+hypern/database/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hypern/datastructures.py,sha256=zZGGSP07kPc9KJDf11hX5uYhAyRE-Ck5wezW5QtOVXw,897
-hypern/db/addons/sqlalchemy/fields/color.py,sha256=Jj8q4lkT0ukKyjVyZjBx7fokGrX7AIJpKOGzwsBpfnU,480
-hypern/db/addons/sqlalchemy/fields/daterange.py,sha256=qEfQN9c4jQdzeXNYKgQ4VIJ3Qc0HXHWRouzNF1se-RA,853
-hypern/db/addons/sqlalchemy/fields/datetime.py,sha256=Bp2jMja2lb_b2WnzRnfbjXXTHBgBTyph1ECsItIwvvg,643
-hypern/db/addons/sqlalchemy/fields/encrypted.py,sha256=pXsg4ImPpK-VkLDruKrv2gUtdp2kajQX7xDbRDxa-SI,1930
-hypern/db/addons/sqlalchemy/fields/password.py,sha256=9pypORygWaINj3oiAOBRIOGgpuA0lcjPq4rh1pqJxq0,5789
-hypern/db/addons/sqlalchemy/fields/ts_vector.py,sha256=bQyXYvQ1bAfFpYcS-sFwM7fU6L1lg9_7nGDRGp0CoUo,1361
-hypern/db/addons/sqlalchemy/fields/unicode.py,sha256=rbqyHlsPUqRDWIjYQSRFF3zkHncnwxo0sdlzqUlcrUw,411
-hypern/db/addons/sqlalchemy/fields/__init__.py,sha256=mLN_AvwgpSAbrWZvVHZuO7ff0gk1T_JbVwd5wug5nlw,359
-hypern/db/addons/sqlalchemy/repository.py,sha256=ue6vWOTrnEPyDevlyh3v-7PU6GSfrZHYKrbXVuoS8UA,9516
-hypern/db/addons/sqlalchemy/__init__.py,sha256=FuY78ubEwtifdQTVHhCrscYaAarlp2urgYBc_R77yt0,2766
-hypern/db/addons/__init__.py,sha256=mdW0P0xvnK8htUk02ujvIaeHXl6w53JjrTS4ioNi1Bw,63
-hypern/db/nosql/addons/color.py,sha256=bAGRuARCAYwZ1nO4jK0lzGYKmavTDtS34BxvrsetF74,446
-hypern/db/nosql/addons/daterange.py,sha256=hGUSoVFqatNY-TB5wjZTq62iZpHpdsyRJIsHxsj1uDs,1192
-hypern/db/nosql/addons/encrypted.py,sha256=B0M-uDqvZHVmIZcFdwcuC2MGsv0pGJFQ1lrOg8klR9U,1741
-hypern/db/nosql/addons/password.py,sha256=jfZxvWFm6nV9EWpXq5Mj-jpqnl9QbokZj9WT14n7dKE,5035
-hypern/db/nosql/addons/unicode.py,sha256=LaDpLfdoTcJuASPE-8fqOVD05H_uOx8gOdnyDn5Iu0c,268
-hypern/db/nosql/addons/__init__.py,sha256=WEtPM8sPHilvga7zxwqvINeTkF0hdcfgPcAnHc4MASE,125
-hypern/db/nosql/__init__.py,sha256=MH9YvlbRlbBCrQVNOdfTaK-hINwJxbJLmxwY9Mei7I8,644
-hypern/db/sql/field.py,sha256=_5Et9pPmTI_bhUFN7PgdSiozip-Iv0eH2491J_WUvXU,20009
-hypern/db/sql/model.py,sha256=5GtH3v6LfYIENlBN1NpIjZpsYFQyo36jX-b6jO1lNdU,3894
-hypern/db/sql/query.py,sha256=_kBZbdQckYyawSIcuaUrE4C6eWgpeWyK1JVR3JWdh60,31964
-hypern/db/sql/__init__.py,sha256=lCOGNTHaXNSJbuLLIOe2IWWNmX0MFQFPNCl2yytD2Xs,261
-hypern/db/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hypern/enum.py,sha256=KcVziJj7vWvyie0r2rtxhrLzdtkZAsf0DY58oJ4tQl4,360
-hypern/exceptions.py,sha256=rWQpWjnkLY51HBpKcWkFaVGCKoC_EiFUPrIBBfLh-eA,2608
+hypern/exceptions/base.py,sha256=5AgfyEea79JjKk5MeAIJ-wy44FG5XEU0Jn3KXKScPiI,2017
+hypern/exceptions/common.py,sha256=0E8wHRRTWjYOmtOCkTDvZ5NMwL6vRW6aiDD9X1eYA30,227
+hypern/exceptions/errors.py,sha256=oAaeTeMgJEpQHspwZDG7B36FD6u6MoLgsxxDTxD7opc,857
+hypern/exceptions/formatters.py,sha256=nHWrsQwG7VVZmcArDL1EYxIlkpNGkS-eCBVjUHZ296I,2386
+hypern/exceptions/http.py,sha256=Q9rpL86SaUYICFZCGQowkhtd5iTS1mT-QQGx-jv7cNE,3226
+hypern/exceptions/__init__.py,sha256=6ud25zPps_mzWUZlMe0Jz_rLjb3wlUNO8rCH01Di6R0,970
 hypern/gateway/aggregator.py,sha256=N1onAp9gdzpCR-E5VubkVoUjjEmVNxG8gDZx9rhnbXc,1132
 hypern/gateway/gateway.py,sha256=26K2qvJUR-0JnN4IlhwvSSt7EYcpYrBVDuzZ1ivQQ34,1475
 hypern/gateway/proxy.py,sha256=w1wcTplDnVrfjn7hb0M0yBVth5TGl88irF-MUYHysQQ,2463
 hypern/gateway/service.py,sha256=PkRaM08olqM_j_4wRjEJCR8X8ZysAF2WOcfhWjaX2eo,1701
 hypern/gateway/__init__.py,sha256=TpFWtqnJerW1-jCWq5fjypJcw9Y6ytyrkvkzby1Eg0E,235
-hypern/hypern.pyi,sha256=4qHekIzH-I6CYch8PwYMus9Ou-JI901kgaLOGsnlOog,9389
+hypern/hypern.pyi,sha256=yXaWGPt598gwPN-CT1ARDdwOSqryZCBFuDLQC8gRd1U,9345
 hypern/i18n/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hypern/logging/logger.py,sha256=WACam_IJiCMXX0hGVKMGSxUQpY4DgAXy7M1dD3q-Z9s,3256
 hypern/logging/__init__.py,sha256=6eVriyncsJ4J73fGYhoejv9MX7aGTkRezTpPxO4DX1I,52
@@ -54,19 +59,19 @@ hypern/middleware/compress.py,sha256=Zph3pQz15YrYB4dMUMbQnfWIFY8ovysgPMepbY_WV9k
 hypern/middleware/cors.py,sha256=pt5HyTd3J5L9Lvczo2xI8fxLmtntSbJq-CPU0vYXoAI,1800
 hypern/middleware/i18n.py,sha256=jHzVzjTx1nnjbraZtIVOprrnSaeKMxZB8RuSqRp2I4s,16
 hypern/middleware/limit.py,sha256=eAYARPjqxq8Ue0TCpnxlVRB5hv7hwBF0PxeD-bG6Sl0,8252
-hypern/middleware/security.py,sha256=d9Qf2UNMN8wz-MLnG2wRb0Vgf55_IGZAje5hbc2T_HQ,7539
+hypern/middleware/security.py,sha256=fGBSF7n2iKBtDHE2QW4q_sQE4awYgaYxVUFKsDHkMXg,7675
 hypern/middleware/__init__.py,sha256=V-Gnv-Jf-14BVuA28z7PN7GBVQ9BBiBdab6-QnTPCfY,493
 hypern/openapi/schemas.py,sha256=YHfMlPUeP5DzDX5ao3YH8p_25Vvyaf616dh6XDCUZRc,1677
 hypern/openapi/swagger.py,sha256=naqUY3rFAEYA1ZLIlmDsMYaol0yIm6TVebdkFa5cMTc,64
 hypern/openapi/__init__.py,sha256=4rEVD8pa0kdSpsy7ZkJ5JY0Z2XF0NGSKDMwYAd7YZpE,141
-hypern/processpool.py,sha256=RFV4turo1dBv40NlzzosjwaZLC24igdyq6twY2IXCUE,2968
+hypern/processpool.py,sha256=qEsu9WXWc3_Cl0Frn1jGs7jUJho45zck5L5Ww81Vm70,3883
 hypern/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hypern/reload.py,sha256=nfaZCoChrQetHNtIqN4Xzi-a0v-irxSCMhwCK3bCEq0,1569
-hypern/response/response.py,sha256=-dnboAraPic8asf503PxwmDuxhNllUO5h97_DGmbER4,4582
+hypern/response/response.py,sha256=Jrkpk5KOmE4WjsAh1G0hUuPHfOPxU6eeR3J2fRIhusU,4871
 hypern/response/__init__.py,sha256=_w3u3TDNuYx5ejnnN1unqnTY8NlBgUATQi6wepEB_FQ,226
-hypern/routing/dispatcher.py,sha256=oQsbOTkjE5roFCl6k58oCW9lEGR_sY5tBoXSJIDgh0w,2508
+hypern/routing/dispatcher.py,sha256=NAVjILlEJjYrixJZ4CO4N1CKkuqbk4TGZOjnQNTTEu4,2461
 hypern/routing/endpoint.py,sha256=RKVhvqOEGL9IKBXQ3KJgPi9bgJj9gfWC5BdZc5U_atc,1026
-hypern/routing/parser.py,sha256=R-4lcN9Ha1iMeAjlqDe8HwkjjMVG-c-ubQLZyWKXj6M,3554
+hypern/routing/parser.py,sha256=0tJVVNwHC3pWDsehwH6SwJv8_gEuDjltVXrNQWbHyrU,3426
 hypern/routing/queue.py,sha256=NtFBbogU22ddyyX-CuQMip1XFDPZdMCVMIeUCQ-CR6Y,7176
 hypern/routing/route.py,sha256=IUnWU5ra-0R9rrRDpxJiwiw7vaEefn-We2dZ4EocJGw,10403
 hypern/routing/__init__.py,sha256=U4xW5fDRsn03z4cVLT4dJHHGGU6SVxyv2DL86LXodeE,162
@@ -80,5 +85,5 @@ hypern/ws/route.py,sha256=fGQ2RC708MPOiiIHPUo8aZ-oK379TTAyQYm4htNA5jM,803
 hypern/ws/__init__.py,sha256=dhRoRY683_rfPfSPM5qUczfTuyYDeuLOCFxY4hIdKt8,131
 hypern/ws.py,sha256=F6SA2Z1KVnqTEX8ssvOXqCtudUS4eo30JsiIsvfbHnE,394
 hypern/__init__.py,sha256=9Ww_aUQ0vJls0tOq7Yw1_TVOCRsa5bHJ-RtnSeComwk,119
-hypern/hypern.cp312-win32.pyd,sha256=KNwQAiAS6V9tS3efx4JNemf-6v2t15thzhuhqrDEbXQ,9854464
-hypern-0.3.3.dist-info/RECORD,,
+hypern/hypern.cp312-win32.pyd,sha256=vNJOrF5I7_yOmuisz19FaH0C2M5CsHxv1SWLm-CzQOk,9797632
+hypern-0.3.5.dist-info/RECORD,,

hypern/exceptions.py

@@ -1,107 +0,0 @@
-# -*- 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
-
-
-class OutOfScopeApplicationException(Exception):
-    pass
-
-
-class DBFieldValidationError(ValueError):
-    """Custom exception for field validation errors."""
-
-    pass