hypern 0.3.7__cp312-cp312-win32.whl → 0.3.9__cp312-cp312-win32.whl

hypern/__init__.py

@@ -1,4 +1,24 @@
+from hypern.logging import logger
+from hypern.routing import HTTPEndpoint, QueuedHTTPEndpoint, Route
+from hypern.ws import WebsocketRoute, WebSocketSession
+
 from .application import Hypern
 from .hypern import Request, Response
+from .response import FileResponse, HTMLResponse, JSONResponse, PlainTextResponse, RedirectResponse
 
-__all__ = ["Hypern", "Request", "Response"]
+__all__ = [
+    "Hypern",
+    "Request",
+    "Response",
+    "Route",
+    "HTTPEndpoint",
+    "QueuedHTTPEndpoint",
+    "WebsocketRoute",
+    "WebSocketSession",
+    "FileResponse",
+    "HTMLResponse",
+    "JSONResponse",
+    "PlainTextResponse",
+    "RedirectResponse",
+    "logger",
+]

hypern/application.py

@@ -83,6 +83,14 @@ class Hypern:
                 """
             ),
         ] = None,
+        dependencies: Annotated[
+            dict[str, Any] | None,
+            Doc(
+                """
+                A dictionary of global dependencies that can be accessed by all routes.
+                """
+            ),
+        ] = None,
         title: Annotated[
             str,
             Doc(
@@ -209,22 +217,6 @@ class Hypern:
                 """
             ),
         ] = None,
-        default_injectables: Annotated[
-            dict[str, Any] | None,
-            Doc(
-                """
-                A dictionary of default injectables to be passed to all routes.
-                """
-            ),
-        ] = None,
-        auto_compression: Annotated[
-            bool,
-            Doc(
-                """
-                Enable automatic compression of responses.
-                """
-            ),
-        ] = False,
         database_config: Annotated[
             DatabaseConfig | None,
             Doc(
@@ -239,15 +231,14 @@ class Hypern:
         super().__init__(*args, **kwargs)
         self.router = Router(path="/")
         self.websocket_router = WebsocketRouter(path="/")
+        self.dependencies = dependencies or {}
         self.scheduler = scheduler
-        self.injectables = default_injectables or {}
         self.middleware_before_request = []
         self.middleware_after_request = []
         self.response_headers = {}
         self.args = ArgsConfig()
         self.start_up_handler = None
         self.shutdown_handler = None
-        self.auto_compression = auto_compression
         self.database_config = database_config
         self.thread_config = ThreadConfigurator().get_config()
 
@@ -255,7 +246,8 @@ class Hypern:
             self.router.extend_route(route(app=self).routes)
 
         for websocket_route in websockets or []:
-            self.websocket_router.add_route(websocket_route)
+            for route in websocket_route.routes:
+                self.websocket_router.add_route(route)
 
         if openapi_url and docs_url:
             self.__add_openapi(
@@ -313,6 +305,20 @@ class Hypern:
         self.add_route(HTTPMethod.GET, openapi_url, schema)
         self.add_route(HTTPMethod.GET, docs_url, template_render)
 
+    def inject(self, key: str, value: Any):
+        """
+        Injects a key-value pair into the injectables dictionary.
+
+        Args:
+            key (str): The key to be added to the injectables dictionary.
+            value (Any): The value to be associated with the key.
+
+        Returns:
+            self: Returns the instance of the class to allow method chaining.
+        """
+        self.dependencies[key] = value
+        return self
+
     def add_response_header(self, key: str, value: str):
         """
         Adds a response header to the response headers dictionary.
@@ -366,20 +372,6 @@ class Hypern:
 
         return decorator
 
-    def inject(self, key: str, value: Any):
-        """
-        Injects a key-value pair into the injectables dictionary.
-
-        Args:
-            key (str): The key to be added to the injectables dictionary.
-            value (Any): The value to be associated with the key.
-
-        Returns:
-            self: Returns the instance of the class to allow method chaining.
-        """
-        self.injectables[key] = value
-        return self
-
     def add_middleware(self, middleware: Middleware):
         """
         Adds middleware to the application.
@@ -429,12 +421,10 @@ class Hypern:
         server = Server()
         server.set_router(router=self.router)
         server.set_websocket_router(websocket_router=self.websocket_router)
-        server.set_injected(injected=self.injectables)
+        server.set_dependencies(dependencies=self.dependencies)
         server.set_before_hooks(hooks=self.middleware_before_request)
         server.set_after_hooks(hooks=self.middleware_after_request)
         server.set_response_headers(headers=self.response_headers)
-        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)
 
         if self.database_config:
             server.set_database_config(config=self.database_config)
@@ -447,6 +437,9 @@ class Hypern:
             self.args.workers = self.thread_config.workers
             self.args.max_blocking_threads = self.thread_config.max_blocking_threads
 
+        if self.args.http2:
+            server.enable_http2()
+
         run_processes(
             server=server,
             host=self.args.host,

hypern/args_parser.py

@@ -49,13 +49,6 @@ class ArgsConfig:
             action="store_true",
             help="It restarts the server based on file changes.",
         )
-
-        parser.add_argument(
-            "--auto-compression",
-            action="store_true",
-            help="It compresses the response automatically.",
-        )
-
         parser.add_argument(
             "--auto-workers",
             action="store_true",
@@ -63,19 +56,9 @@ class ArgsConfig:
         )
 
         parser.add_argument(
-            "--min-capacity",
-            type=int,
-            default=1,
-            required=False,
-            help="Choose the minimum memory pool capacity. [Default: 1]",
-        )
-
-        parser.add_argument(
-            "--max-capacity",
-            type=int,
-            default=100,
-            required=False,
-            help="Choose the maximum memory pool capacity. [Default: 100]",
+            "--http2",
+            action="store_true",
+            help="Enable HTTP/2 support.",
         )
 
         args, _ = parser.parse_known_args()
@@ -86,7 +69,5 @@ class ArgsConfig:
         self.processes = args.processes or 1
         self.workers = args.workers or 1
         self.reload = args.reload or False
-        self.auto_compression = args.auto_compression
         self.auto_workers = args.auto_workers
-        self.min_capacity = args.min_capacity
-        self.max_capacity = args.max_capacity
+        self.http2 = args.http2 or False

hypern/database/sqlalchemy/__init__.py

@@ -0,0 +1,4 @@
+from .repository import Model, PostgresRepository
+from .config import SqlalchemyConfig
+
+__all__ = ["Model", "PostgresRepository", "SqlalchemyConfig"]

hypern/database/{addons/sqlalchemy/__init__.py → sqlalchemy/config.py}

@@ -7,8 +7,6 @@ from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession, async_scoped_sessi
 from sqlalchemy.orm import Session, sessionmaker
 from sqlalchemy.sql.expression import Delete, Insert, Update
 
-from .repository import Model, PostgresRepository
-
 
 class SqlalchemyConfig:
     def __init__(self, default_engine: AsyncEngine | None = None, reader_engine: AsyncEngine | None = None, writer_engine: AsyncEngine | None = None):
@@ -66,6 +64,3 @@ class SqlalchemyConfig:
 
     def init_app(self, app):
         app.inject("get_session", self.get_session)
-
-
-__all__ = ["Model", "PostgresRepository", "SqlalchemyConfig"]

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

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

hypern/datastructures.py

@@ -1,6 +1,6 @@
 from typing import Optional
 from enum import Enum
-from pydantic import BaseModel, AnyUrl, EmailStr
+from pydantic import BaseModel, AnyUrl
 
 
 class BaseModelWithConfig(BaseModel):
@@ -10,7 +10,7 @@ class BaseModelWithConfig(BaseModel):
 class Contact(BaseModelWithConfig):
     name: Optional[str] = None
     url: Optional[AnyUrl] = None
-    email: Optional[EmailStr] = None
+    email: Optional[str] = None
 
 
 class License(BaseModelWithConfig):

hypern/hypern.pyi

@@ -181,16 +181,14 @@ class Server:
     def set_router(self, router: Router) -> None: ...
     def set_websocket_router(self, websocket_router: WebsocketRouter) -> None: ...
     def start(self, socket: SocketHeld, worker: int, max_blocking_threads: int) -> None: ...
-    def inject(self, key: str, value: Any) -> None: ...
-    def set_injected(self, injected: Dict[str, Any]) -> None: ...
     def set_before_hooks(self, hooks: List[FunctionInfo]) -> None: ...
     def set_after_hooks(self, hooks: List[FunctionInfo]) -> None: ...
     def set_response_headers(self, headers: Dict[str, str]) -> None: ...
     def set_startup_handler(self, on_startup: FunctionInfo) -> None: ...
     def set_shutdown_handler(self, on_shutdown: FunctionInfo) -> None: ...
-    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 set_dependencies(self, dependencies: Dict[str, Any]) -> None: ...
+    def enable_http2(self) -> None: ...
 
 class Route:
     path: str
@@ -278,7 +276,7 @@ class UploadedFile:
     path: str
     size: int
     content: bytes
-    filename: str
+    file_name: str
 
 @dataclass
 class BodyData:

hypern/worker.py

@@ -1,30 +1,274 @@
-# -*- coding: utf-8 -*-
-from typing import Any
+import asyncio
+import logging
+import os
+import time
+import traceback
+from concurrent.futures import ThreadPoolExecutor
+from functools import partial, wraps
+from typing import Callable, Dict, List
+
 from celery import Celery
-from asgiref.sync import async_to_sync
+from celery.result import AsyncResult
+from celery.signals import (
+    after_setup_logger,
+    after_setup_task_logger,
+    task_failure,
+    task_postrun,
+    task_prerun,
+    worker_ready,
+    worker_shutdown,
+)
+from kombu import Exchange, Queue
+
+
+class Worker(Celery):
+    def __init__(
+        self,
+        main: str = None,
+        broker_url: str = None,
+        result_backend: str = "rpc://",
+        queues: Dict[str, Dict] = None,
+        task_routes: Dict[str, str] = None,
+        imports: List[str] = None,
+        **kwargs,
+    ):
+        super().__init__(main, **kwargs)
+
+        self._executor = ThreadPoolExecutor()
+        self._task_timings = {}
+
+        self.default_exchange = Exchange("default", type="direct")
+        self.priority_exchange = Exchange("priority", type="direct")
+
+        default_queues = {
+            "default": {"exchange": self.default_exchange, "routing_key": "default"},
+            "high_priority": {"exchange": self.priority_exchange, "routing_key": "high"},
+            "low_priority": {"exchange": self.priority_exchange, "routing_key": "low"},
+        }
+        if queues:
+            default_queues.update(queues)
+
+        self._queues = {
+            name: Queue(
+                name,
+                exchange=config.get("exchange", self.default_exchange),
+                routing_key=config.get("routing_key", name),
+                queue_arguments=config.get("arguments", {}),
+            )
+            for name, config in default_queues.items()
+        }
+
+        self.conf.update(
+            broker_url=broker_url,
+            result_backend=result_backend,
+            # Worker Pool Configuration
+            worker_pool="solo",
+            worker_pool_restarts=True,
+            broker_connection_retry_on_startup=True,
+            # Worker Configuration
+            worker_prefetch_multiplier=1,
+            worker_max_tasks_per_child=1000,
+            worker_concurrency=os.cpu_count(),
+            # Task Settings
+            task_acks_late=True,
+            task_reject_on_worker_lost=True,
+            task_time_limit=3600,
+            task_soft_time_limit=3000,
+            task_default_retry_delay=300,
+            task_max_retries=3,
+            # Memory Management
+            worker_max_memory_per_child=200000,  # 200MB
+            # Task Routing
+            task_routes=task_routes,
+            task_queues=list(self._queues.values()),
+            # Performance Settings
+            task_compression="gzip",
+            result_compression="gzip",
+            task_serializer="json",
+            result_serializer="json",
+            accept_content=["json"],
+            imports=imports,
+            task_default_exchange=self.default_exchange.name,
+            task_default_routing_key="default",
+        )
+
+        self._setup_signals()
+
+    def _setup_signals(self):
+        @worker_ready.connect
+        def on_worker_ready(sender, **kwargs):
+            self.logger.info(f"Worker {sender.hostname} is ready")
+
+        @worker_shutdown.connect
+        def on_worker_shutdown(sender, **kwargs):
+            self.logger.info(f"Worker {sender.hostname} is shutting down")
+            self._executor.shutdown(wait=True)
+
+        @task_prerun.connect
+        def task_prerun_handler(task_id, task, *args, **kwargs):
+            self._task_timings[task_id] = {"start": time.time()}
+            self.logger.info(f"Task {task.name}[{task_id}] started")
+
+        @task_postrun.connect
+        def task_postrun_handler(task_id, task, *args, retval=None, **kwargs):
+            if task_id in self._task_timings:
+                start_time = self._task_timings[task_id]["start"]
+                duration = time.time() - start_time
+                self.logger.info(f"Task {task.name}[{task_id}] completed in {duration:.2f}s")
+                del self._task_timings[task_id]
+
+        @task_failure.connect
+        def task_failure_handler(task_id, exc, task, *args, **kwargs):
+            self.logger.error(f"Task {task.name}[{task_id}] failed: {exc}\n{traceback.format_exc()}")
+
+        @after_setup_logger.connect
+        def setup_celery_logger(logger, *args, **kwargs):
+            existing_logger = logging.getLogger("hypern")
+            logger.handlers = existing_logger.handlers
+            logger.filters = existing_logger.filters
+            logger.level = existing_logger.level
+
+        @after_setup_task_logger.connect
+        def setup_task_logger(logger, *args, **kwargs):
+            existing_logger = logging.getLogger("hypern")
+            logger.handlers = existing_logger.handlers
+            logger.filters = existing_logger.filters
+            logger.level = existing_logger.level
+
+    def add_task_routes(self, routes: Dict[str, str]) -> None:
+        """
+        Example:
+            app.add_task_routes({
+                'tasks.email.*': 'email_queue',
+                'tasks.payment.process': 'payment_queue',
+                'tasks.high_priority.*': 'high_priority'
+            })
+        """
+        for task_pattern, queue in routes.items():
+            self.add_task_route(task_pattern, queue)
+
+    def add_task_route(self, task_pattern: str, queue: str) -> None:
+        """
+        Add a task route to the Celery app
+
+        Example:
+            app.add_task_route('tasks.email.send', 'email_queue')
+            app.add_task_route('tasks.payment.*', 'payment_queue')
+        """
+        if queue not in self._queues:
+            raise ValueError(f"Queue '{queue}' does not exist. Create it first using create_queue()")
+
+        self._task_route_mapping[task_pattern] = queue
+
+        # Update Celery task routes
+        routes = self.conf.task_routes or {}
+        routes[task_pattern] = {"queue": queue}
+        self.conf.task_routes = routes
+
+        self.logger.info(f"Added route: {task_pattern} -> {queue}")
+
+    def task(self, *args, **opts):
+        """
+        Decorator modified to support sync and async functions
+        """
+        base_task = Celery.task.__get__(self)
+
+        def decorator(func):
+            is_async = asyncio.iscoroutinefunction(func)
+
+            if is_async:
+
+                @wraps(func)
+                async def async_wrapper(*fargs, **fkwargs):
+                    return await func(*fargs, **fkwargs)
+
+                @base_task(*args, **opts)
+                def wrapped(*fargs, **fkwargs):
+                    loop = asyncio.new_event_loop()
+                    asyncio.set_event_loop(loop)
+                    try:
+                        return loop.run_until_complete(async_wrapper(*fargs, **fkwargs))
+                    finally:
+                        loop.close()
+
+                return wrapped
+            else:
+                return base_task(*args, **opts)(func)
+
+        return decorator
+
+    async def async_send_task(self, task_name: str, *args, **kwargs) -> AsyncResult:
+        """
+        Version of send_task() that is async
+        """
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(self._executor, partial(self.send_task, task_name, args=args, kwargs=kwargs))
+
+    async def async_result(self, task_id: str) -> Dict:
+        """
+        Get the result of a task asynchronously
+        """
+        async_result = self.AsyncResult(task_id)
+        loop = asyncio.get_event_loop()
+
+        result = await loop.run_in_executor(
+            self._executor,
+            lambda: {
+                "task_id": task_id,
+                "status": async_result.status,
+                "result": async_result.result,
+                "traceback": async_result.traceback,
+                "date_done": async_result.date_done,
+            },
+        )
+        return result
+
+    def get_queue_length(self, queue_name: str) -> int:
+        """
+        Get the number of messages in a queue
+        """
+        with self.connection_or_acquire() as conn:
+            channel = conn.channel()
+            queue = Queue(queue_name, channel=channel)
+            return queue.queue_declare(passive=True).message_count
 
+    async def chain_tasks(self, tasks: list) -> AsyncResult:
+        """
+        Function to chain multiple tasks together
+        """
+        chain = tasks[0]
+        for task in tasks[1:]:
+            chain = chain | task
+        return await self.adelay_task(chain)
 
-class AsyncCelery(Celery):
-    def __new__(cls, *args, **kwargs) -> Any:
-        if not hasattr(cls, "instance") or not cls.instance:  # type: ignore
-            cls.instance = super().__new__(cls)
-        return cls.instance
+    def register_task_middleware(self, middleware: Callable):
+        """
+        Register a middleware function to be called before each task
+        """
 
-    def __init__(self, *args, **kwargs) -> None:
-        super().__init__(*args, **kwargs)
-        self.patch_task()
+        def task_middleware(task):
+            @wraps(task)
+            def _wrapped(*args, **kwargs):
+                return middleware(task, *args, **kwargs)
 
-    def patch_task(self) -> None:
-        TaskBase = self.Task
+            return _wrapped
 
-        class ContextTask(TaskBase):  # type: ignore
-            abstract = True
+        self.task = task_middleware(self.task)
 
-            def _run(self, *args, **kwargs):
-                result = async_to_sync(TaskBase.__call__)(self, *args, **kwargs)
-                return result
+    def monitor_task(self, task_id: str) -> dict:
+        """
+        Get monitoring data for a task
+        """
+        result = self.AsyncResult(task_id)
+        timing_info = self._task_timings.get(task_id, {})
 
-            def __call__(self, *args, **kwargs):
-                return self._run(*args, **kwargs)
+        monitoring_data = {
+            "task_id": task_id,
+            "status": result.status,
+            "start_time": timing_info.get("start"),
+            "duration": time.time() - timing_info["start"] if timing_info.get("start") else None,
+            "result": result.result if result.ready() else None,
+            "traceback": result.traceback,
+        }
 
-        self.Task = ContextTask
+        return monitoring_data

{hypern-0.3.7.dist-info → hypern-0.3.9.dist-info}/METADATA

@@ -1,32 +1,24 @@
 Metadata-Version: 2.4
 Name: hypern
-Version: 0.3.7
+Version: 0.3.9
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Dist: sqlalchemy[asyncio] ==2.0.31
-Requires-Dist: pydantic[email] ==2.8.2
-Requires-Dist: passlib ==1.7.4
 Requires-Dist: pyjwt ==2.8.0
 Requires-Dist: pydash ==8.0.3
 Requires-Dist: sentry-sdk ==2.11.0
-Requires-Dist: pydantic-settings ==2.3.4
 Requires-Dist: celery ==5.4.0
-Requires-Dist: asgiref ==3.8.1
 Requires-Dist: psycopg ==3.2.3
 Requires-Dist: pyyaml ==6.0.2
-Requires-Dist: mongoengine ==0.29.1
-Requires-Dist: argon2-cffi ==23.1.0
-Requires-Dist: bcrypt ==4.2.0
 Requires-Dist: orjson ==3.10.11
 Requires-Dist: multiprocess ==0.70.17
 Requires-Dist: uvloop ==0.21.0 ; sys_platform != 'win32' and platform_python_implementation == 'CPython' and platform_machine != 'armv7l'
-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
 Requires-Dist: redis ==5.2.1
+Requires-Dist: pydantic ==2.10.4
 License-File: LICENSE
 Summary: A Fast Async Python backend with a Rust runtime.
 Author-email: Martin Dang <vannghiem848@gmail.com>
@@ -38,7 +30,7 @@ Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
 
 Hypern: A Versatile Python and Rust Framework
 
-Hypern is a flexible, open-source framework built on the [Axum](https://github.com/tokio-rs/axum), designed to jumpstart your high-performance web development endeavors. By providing a pre-configured structure and essential components, Hypern empowers you to rapidly develop custom web applications that leverage the combined power of Python and Rust.
+Hypern is a flexible, open-source framework built on the [Rust](https://github.com/rust-lang/rust), designed to jumpstart your high-performance web development endeavors. By providing a pre-configured structure and essential components, Hypern empowers you to rapidly develop custom web applications that leverage the combined power of Python and Rust.
 
 With Hypern, you can seamlessly integrate asynchronous features and build scalable solutions for RESTful APIs and dynamic web applications. Its intuitive design and robust tooling allow developers to focus on creating high-quality code while maximizing performance. Embrace the synergy of Python and Rust to elevate your web development experience.
 
@@ -92,7 +84,7 @@ routing = [
 app = Hypern(routing)
 
 if __name__ == "__main__":
-    app.start(host='localhost', port=5005)
+    app.start()
 ```
 
 ```
@@ -100,6 +92,16 @@ $ python3 main.py
 ```
 You can open swagger UI at path `/docs` 
 
+## CLI
+
+    - host (str): The host address to bind to. Defaults to '127.0.0.1'.
+    - port (int): The port number to bind to. Defaults to 5000.
+    - processes (int): The number of processes to use. Defaults to 1.
+    - workers (int): The number of worker threads to use. Defaults to 1.
+    - max_blocking_threads (int): The maximum number of blocking threads. Defaults to 32.
+    - reload (bool): If True, the server will restart on file changes.
+    - auto_workers (bool): If True, sets the number of workers and max-blocking-threads automatically.
+
 
 ## 💡 Features
 
@@ -107,7 +109,7 @@ You can open swagger UI at path `/docs`
 - Rust-powered core with Python flexibility
 - Multi-process architecture for optimal CPU utilization
 - Async/await support for non-blocking operations
-- Built on top of production-ready Axum web framework
+- Built on top of production-ready Rust language
 
 ### 🛠 Development Experience
 - Type hints and IDE support
@@ -118,7 +120,7 @@ You can open swagger UI at path `/docs`
 ### 🔌 Integration & Extensions
 - Easy dependency injection
 - Middleware support (before/after request hooks)
-- WebSocket support (Comming soon)
+- WebSocket support
 - Background task scheduling
 - File upload handling