hypern 0.3.4__cp312-cp312-win32.whl → 0.3.6__cp312-cp312-win32.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.6.dist-info}/METADATA

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

@@ -1,6 +1,6 @@
-hypern-0.3.4.dist-info/METADATA,sha256=wJ9_iA8bw0-Sc-a3AtzB0aCWhN4iPavHZjQfZgEpats,3819
-hypern-0.3.4.dist-info/WHEEL,sha256=SK_cql1gpDHx6aBV-LOSvGbTt4TUC8AJJOzjOP2tdpI,92
-hypern-0.3.4.dist-info/licenses/LICENSE,sha256=qbYKAIJLS6jYg5hYncKE7OtWmqOtpVTvKNkwOa0Iwwg,1328
+hypern-0.3.6.dist-info/METADATA,sha256=NZSUrAbL7D7aleTF03qoRJiO2r8cQ7OQdwYlPu9hRoM,3850
+hypern-0.3.6.dist-info/WHEEL,sha256=SK_cql1gpDHx6aBV-LOSvGbTt4TUC8AJJOzjOP2tdpI,92
+hypern-0.3.6.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
@@ -13,32 +13,37 @@ 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=tSs8iaYjy-K6nplJJ-1X4OQddzW76cfBlx9xTrG_NbQ,20073
-hypern/db/sql/model.py,sha256=BLRmOlmfn6ibedR9Bv_rHErSruudJ24B9-nDbRHqWm4,3913
-hypern/db/sql/query.py,sha256=MXiphm4pXBz6Axbdoc5rg11XEmw_UahTCdppowyXJxY,33329
-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
@@ -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=jJffm7oIt2JsiZrH3M4faieg-Ezb-WoWOH_4ZMt3sog,9813504
-hypern-0.3.4.dist-info/RECORD,,
+hypern/hypern.cp312-win32.pyd,sha256=UEZnqNJkk-53t73JL5FWC2oDcmxOUmLAT8rc1R0E4DI,9796096
+hypern-0.3.6.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