hypern 0.3.4__cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.whl → 0.3.5__cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.whl

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

@@ -1,6 +1,6 @@
 from enum import Enum
 from typing import Any, Dict, List, Tuple, Union
-from hypern.db.sql.field import ForeignKey
+from hypern.database.sql.field import ForeignKey
 
 
 class JoinType(Enum):

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/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.4.dist-info → hypern-0.3.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypern
-Version: 0.3.4
+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.4.dist-info → hypern-0.3.5.dist-info}/RECORD

@@ -1,7 +1,6 @@
-hypern-0.3.4.dist-info/METADATA,sha256=6lG_RNIeI43JEIwErMWPFmc9byTrMQOkm-akGhEYvVA,3723
-hypern-0.3.4.dist-info/WHEEL,sha256=7tIgc9iVs-udH1vh5eIZ1Q0fZTSpFzTPubZ0mCMu2bY,125
-hypern-0.3.4.dist-info/licenses/LICENSE,sha256=VdbaK2hSaaD-LUjtDIlEbeZVmvLGK7BEQvltP3mv-cY,1304
-hypern/exceptions.py,sha256=YjWcXfBbM0srzcCcYu6raw0KavcH_iVlr2RGuxw09M0,2501
+hypern-0.3.5.dist-info/METADATA,sha256=3YWjQNKci-jBTZGWJX-ue43rETDHtkxN5jA_trYz4tM,3754
+hypern-0.3.5.dist-info/WHEEL,sha256=7tIgc9iVs-udH1vh5eIZ1Q0fZTSpFzTPubZ0mCMu2bY,125
+hypern-0.3.5.dist-info/licenses/LICENSE,sha256=VdbaK2hSaaD-LUjtDIlEbeZVmvLGK7BEQvltP3mv-cY,1304
 hypern/args_parser.py,sha256=jDcON-mVqYTPrBirMkmhH6Gm2QhS9rV2u_72SyoYSdY,2723
 hypern/gateway/aggregator.py,sha256=Z4LnsDlVDtlPlhsSKu8jCD0UsbztXOLu6UAVtkgJwQk,1100
 hypern/gateway/gateway.py,sha256=rAZrS9db55tQGUfEfVNIKw6EetBdHAcSXyrC7rLfCZ8,1434
@@ -17,41 +16,18 @@ hypern/middleware/compress.py,sha256=2eyxkYMgmsL6klbcTqr7WK0rFTo0grU0ZKQF15pVUBI
 hypern/middleware/cache.py,sha256=b4hRh1smFwhJE789hZ0p4TlkQ8ZjYR-7fXg9rI7uvbc,7406
 hypern/middleware/i18n.py,sha256=s82nQo6kKClZ0s3G3jsy87VRfwxpBDbASB_ErjRL3O0,15
 hypern/middleware/cors.py,sha256=q8Ts_znqApdUJYSJyLlRIbYKxxTQy6WNnJD6Kqbl32I,1759
-hypern/middleware/security.py,sha256=vteO6ISGF1okPP2tn0dCURyKv7J04i6FN2FU5KXmNaU,7355
+hypern/middleware/security.py,sha256=hPYsilqhF9mRCX7DzOQw4AKh0y5k5FL0cM_zQdb9tiA,7491
 hypern/openapi/schemas.py,sha256=nmcmNYvKmjNkwFqi_3qpXVi1ukanNxMVay68bOLTrx8,1624
 hypern/openapi/__init__.py,sha256=oJ0HM9yAgSN00mBC_fRgV2irlGugrhvIpiveuDMv8PM,136
 hypern/openapi/swagger.py,sha256=E5fHYUfFa77zQsCyQGf_vnqJVpl4_KI5qsKFHdgJEdw,61
-hypern/db/sql/field.py,sha256=a_AVQP2r08RZG9twN3bWLB3QQHQIZq-J7HpAto01q2g,19466
-hypern/db/sql/model.py,sha256=VV5pmNacgyZEWb1MvBGxBd9RNaL8gywlKO447CK_3VA,3797
-hypern/db/sql/__init__.py,sha256=YjhnqREh4vWkcwcMXHYMMRVjx2_ew-ngqY50AGOVl48,248
-hypern/db/sql/query.py,sha256=huPnehqK_Hb1WiuyLQizu0VKrBG-0MzKR1V7z5NQokE,32425
-hypern/db/nosql/__init__.py,sha256=LCVBhcJCQmFt5dCLiSf7C_TsjsEILeZe8JqiFEKuD2s,619
-hypern/db/nosql/addons/password.py,sha256=kbqQRzT5uq9IQ4Z_eE69cVo1rHTiovhtG3I0l5AZmMk,4901
-hypern/db/nosql/addons/__init__.py,sha256=h6wJKPvCqyvivD52L7qsbFKnqqUnAdU1RQ30spnki98,121
-hypern/db/nosql/addons/unicode.py,sha256=vKyqfzrS9SKFo4eKlvu6klST0FrjM0wTx5N3ocvSSO8,258
-hypern/db/nosql/addons/encrypted.py,sha256=bbJozZfcsWvumqHYOrN1Y8XrwRZqaR-z__u11GEmIv4,1688
-hypern/db/nosql/addons/color.py,sha256=8zUBFjR19J1zy_WaOCXlS14GjgdOaHAcuSb__zFp_II,430
-hypern/db/nosql/addons/daterange.py,sha256=YJBVfiX13Wx8DZociajWLBm20L_c0ZxTUbgCYMNk10Q,1162
-hypern/db/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hypern/db/addons/__init__.py,sha256=rzwN5hPXja_TLGUu863QQLSyQ1zbNNeYXfDVboxQE2I,58
-hypern/db/addons/sqlalchemy/__init__.py,sha256=LAhAdJRNu_izh0X9KbesuJiF33oEQ6ET_tkAkR74Lpw,2695
-hypern/db/addons/sqlalchemy/fields/password.py,sha256=SnPKke6YAyq4LRYMMHp1qGj5jKIVSU5GFV6Y4ungaRo,5618
-hypern/db/addons/sqlalchemy/fields/__init__.py,sha256=gZpp75nCNZHx9VDw5aNEmJzlpvVKv7Tulp40-Z7-ULM,345
-hypern/db/addons/sqlalchemy/fields/unicode.py,sha256=gvsWvt0gTEwy62U4l6yDQjEXfc982QAaVay3YfxD3do,396
-hypern/db/addons/sqlalchemy/fields/encrypted.py,sha256=TmbpI0XE4_GYYAnHwbx3lVqD5BewcMedHcD-18eWUJA,1872
-hypern/db/addons/sqlalchemy/fields/color.py,sha256=dxfY2K0RTIdwlul75y-Vs8ldRs-2UYMBZnTkvVATA1U,464
-hypern/db/addons/sqlalchemy/fields/datetime.py,sha256=vZEV0s8M6VlsV9DDcEsCFIwoEAi_vNGY5HGFGULc0H0,621
-hypern/db/addons/sqlalchemy/fields/daterange.py,sha256=zeylGZc4JWVzLJRQi1DjP_LAvB3JNBNYwAa-KSolZyQ,830
-hypern/db/addons/sqlalchemy/fields/ts_vector.py,sha256=xmh-iLLGG5uW4QL_cnONdQd5rEfYZpNXaX_rW2kBrZU,1315
-hypern/db/addons/sqlalchemy/repository.py,sha256=YShEl1DqRXtYwNnn1F3YVfXX-TEdoNRjDEWIO_3Lu2s,9226
 hypern/hypern.pyi,sha256=jdjclVZUpYPhJOy6kGBKXTbbVwm6x163twSk0N7l9fI,9008
-hypern/routing/dispatcher.py,sha256=ksPjd-JnOCvrmyWodJhsLm02S5R8BrSlW4SdtG86G0w,2437
+hypern/routing/dispatcher.py,sha256=8_JuxyyOMiCqY3WsqcjSzUTpYjIGbvzGtI8j9T-fIkA,2391
 hypern/routing/route.py,sha256=AZc4Qo5iy74q0_U8E5X6RIsudznHZYEZR8MdHRoCmB4,10119
-hypern/routing/parser.py,sha256=4BFn8MAmSX1QplwBXEEgbabYiNUAllYf2svPZoPPD5k,3454
+hypern/routing/parser.py,sha256=VYdQtf9TPe-NSx3J2wCfOZIh1S-iFLf0jdqrY9UPVMQ,3328
 hypern/routing/__init__.py,sha256=FvmUQlSraZ91q9AFGkgj3ELIep1jiKZLBCDrXIVf5DI,157
 hypern/routing/queue.py,sha256=Yus-49N4xc7O5S3YYxqL0muFLypu_Zgd0u2SADFh-Uk,7001
 hypern/routing/endpoint.py,sha256=AWLHLQNlSGR8IGU6xM0RP-1kP06OJQzqpbXKSiZEzEo,996
-hypern/response/response.py,sha256=s6KqscjA7jl8RaZh5gZQgVksPtHKzsRrQywDcEjVSR4,4448
+hypern/response/response.py,sha256=_UbLlzEfDZvXKHDKOdXFdus-CJXgoNFPmV259cjQz2Q,4729
 hypern/response/__init__.py,sha256=9z99BDgASpG404GK8LGkOsXgac0wFwH_cQOTI5Ju-1U,223
 hypern/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hypern/cli/commands.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -62,7 +38,7 @@ hypern/worker.py,sha256=kN93QGx4bst0inHRO_fsTzMmhDA0N3pdzaqNXwyu3N0,894
 hypern/__init__.py,sha256=Ew7xzNI_FIXpXin5vgv6det0lVYxGI8Xtbtger3Y5JY,115
 hypern/reload.py,sha256=Y2pjHHh8Zv0z-pRkBPLezKiowRblb1ZJ7yI_oE55D4U,1523
 hypern/background.py,sha256=fN38UlJG6wZf1gOGcvdY-INoD8zJKvGZZOdVYTMjDwg,120
-hypern/processpool.py,sha256=TuqcHMpSdXNSOZi3DKgUINAS03sTDn9tRAJQ63YPYZU,2847
+hypern/processpool.py,sha256=7DSUMKy0IL6D3822W-XseH6oAU2MCmb-wKRt_80RuZE,3744
 hypern/caching/__init__.py,sha256=I7X3bmdEHeHs80kjAI1s0mMlVD7RKmw9I-QupaTAIWo,346
 hypern/caching/backend.py,sha256=Tj66YSepGUvpXrwC04gSdJzs45IepHA2hNlMtnRVB6c,798
 hypern/caching/redis_backend.py,sha256=nRkAq07B248iFljn9TxE4tadYUeM8RqqERZWzEpfk7E,5767
@@ -70,7 +46,36 @@ hypern/caching/strategies.py,sha256=VU0FpYmIK6rEjjJSwRXPrprYdo0d2u1s9OxB3OAvs3g,
 hypern/i18n/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hypern/config.py,sha256=Ksn2LnHU0yhtGUjnac9bNjqtxl7IcPKmMdbDfZYm7Jo,7911
 hypern/application.py,sha256=S80VpC5H0Xna7AHoF_nEGeKfQAv4QTBnJ7KJalrIp7k,17894
+hypern/database/sql/field.py,sha256=a_AVQP2r08RZG9twN3bWLB3QQHQIZq-J7HpAto01q2g,19466
+hypern/database/sql/model.py,sha256=VV5pmNacgyZEWb1MvBGxBd9RNaL8gywlKO447CK_3VA,3797
+hypern/database/sql/__init__.py,sha256=YjhnqREh4vWkcwcMXHYMMRVjx2_ew-ngqY50AGOVl48,248
+hypern/database/sql/query.py,sha256=MWSN1aVswSchw-LWj1j8nKJi_QkJXz8x4a_YsOVx9ek,32431
+hypern/database/nosql/__init__.py,sha256=LCVBhcJCQmFt5dCLiSf7C_TsjsEILeZe8JqiFEKuD2s,619
+hypern/database/nosql/addons/password.py,sha256=kbqQRzT5uq9IQ4Z_eE69cVo1rHTiovhtG3I0l5AZmMk,4901
+hypern/database/nosql/addons/__init__.py,sha256=h6wJKPvCqyvivD52L7qsbFKnqqUnAdU1RQ30spnki98,121
+hypern/database/nosql/addons/unicode.py,sha256=vKyqfzrS9SKFo4eKlvu6klST0FrjM0wTx5N3ocvSSO8,258
+hypern/database/nosql/addons/encrypted.py,sha256=bbJozZfcsWvumqHYOrN1Y8XrwRZqaR-z__u11GEmIv4,1688
+hypern/database/nosql/addons/color.py,sha256=8zUBFjR19J1zy_WaOCXlS14GjgdOaHAcuSb__zFp_II,430
+hypern/database/nosql/addons/daterange.py,sha256=YJBVfiX13Wx8DZociajWLBm20L_c0ZxTUbgCYMNk10Q,1162
+hypern/database/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hypern/database/addons/__init__.py,sha256=rzwN5hPXja_TLGUu863QQLSyQ1zbNNeYXfDVboxQE2I,58
+hypern/database/addons/sqlalchemy/__init__.py,sha256=LAhAdJRNu_izh0X9KbesuJiF33oEQ6ET_tkAkR74Lpw,2695
+hypern/database/addons/sqlalchemy/fields/password.py,sha256=SnPKke6YAyq4LRYMMHp1qGj5jKIVSU5GFV6Y4ungaRo,5618
+hypern/database/addons/sqlalchemy/fields/__init__.py,sha256=gZpp75nCNZHx9VDw5aNEmJzlpvVKv7Tulp40-Z7-ULM,345
+hypern/database/addons/sqlalchemy/fields/unicode.py,sha256=gvsWvt0gTEwy62U4l6yDQjEXfc982QAaVay3YfxD3do,396
+hypern/database/addons/sqlalchemy/fields/encrypted.py,sha256=TmbpI0XE4_GYYAnHwbx3lVqD5BewcMedHcD-18eWUJA,1872
+hypern/database/addons/sqlalchemy/fields/color.py,sha256=dxfY2K0RTIdwlul75y-Vs8ldRs-2UYMBZnTkvVATA1U,464
+hypern/database/addons/sqlalchemy/fields/datetime.py,sha256=vZEV0s8M6VlsV9DDcEsCFIwoEAi_vNGY5HGFGULc0H0,621
+hypern/database/addons/sqlalchemy/fields/daterange.py,sha256=zeylGZc4JWVzLJRQi1DjP_LAvB3JNBNYwAa-KSolZyQ,830
+hypern/database/addons/sqlalchemy/fields/ts_vector.py,sha256=xmh-iLLGG5uW4QL_cnONdQd5rEfYZpNXaX_rW2kBrZU,1315
+hypern/database/addons/sqlalchemy/repository.py,sha256=YShEl1DqRXtYwNnn1F3YVfXX-TEdoNRjDEWIO_3Lu2s,9226
 hypern/enum.py,sha256=-StRU0cWboP-y5fNuhB4Q7yMk8Zm_h1Eua9KzOtIyI8,347
+hypern/exceptions/common.py,sha256=p9cx3PC6Azn0WAz7jCH02DEoLRLCCvKqNrL-dGhMGSQ,215
+hypern/exceptions/formatters.py,sha256=51krRQIUq3uvwvcQm81mYPifdp2r2ckwC98pXI5v_P8,2330
+hypern/exceptions/__init__.py,sha256=t4GhxGHjOPgPQ34f0MycMjoRGw5u3TRb3OcTDYc4Orw,936
+hypern/exceptions/errors.py,sha256=mt6ZXUGHFZ_FfyP7sZFj4XT6amb5G-1Fa_26rH7BSWc,842
+hypern/exceptions/http.py,sha256=N98kHaQtH4x9EW6Gavrcr-Ll_-HDvsDSaRAX1sNuN4A,3150
+hypern/exceptions/base.py,sha256=_tt42Tuy_7oXR-THhJ00lZFsCJMKWbArJyTlF-kcgH4,1955
 hypern/logging/__init__.py,sha256=lzYSz0382eIM3CvP0sZ6RbEEwYZwfeJEJh9cxQA6Rws,49
 hypern/logging/logger.py,sha256=62Qg4YAi_JDGV72Rd6R58jixqZk7anRqHbtnuBlkrwA,3174
 hypern/scheduler.py,sha256=nQoWIYMRmKd30g4XwdB072hWTNHvJlLd9S6rLlTFKS0,62
@@ -80,5 +85,5 @@ hypern/ws/room.py,sha256=9u6gLq1WY4hn9_yEniavaY0yetFbQzgya_g6VPN-cgg,2522
 hypern/ws/heartbeat.py,sha256=PIrYWnQn8VxQjfDXDmtMymMl-wN5MQ_Q6oHfAjPWznU,2787
 hypern/ws/route.py,sha256=8YPTf1fsF46oCyqoXePC3mEbhjNVFDp8rqyWSsBHhBA,777
 hypern/ws/__init__.py,sha256=iUYERiHxs7HCmHj7CS5iG2XewKAJgW7w8kqxSORu_N8,127
-hypern/hypern.cpython-311-i386-linux-gnu.so,sha256=zpQIY2ZzCRfJVylyoOv5X7UuqH_5A8fivghQkpcQ6Uo,12060284
-hypern-0.3.4.dist-info/RECORD,,
+hypern/hypern.cpython-311-i386-linux-gnu.so,sha256=ejbRZl5HfgGT3ItZU08gF33fXrOCtySg8RT_8ESXc4g,12039804
+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