hypern 0.3.2__cp312-cp312-win32.whl → 0.3.4__cp312-cp312-win32.whl

hypern/application.py

@@ -2,26 +2,52 @@
 from __future__ import annotations
 
 import asyncio
+from dataclasses import dataclass
 from typing import Any, Callable, List, TypeVar
 
 import orjson
+import psutil
 from typing_extensions import Annotated, Doc
 
+from hypern.args_parser import ArgsConfig
 from hypern.datastructures import Contact, HTTPMethod, Info, License
-from hypern.hypern import FunctionInfo, Router, Route as InternalRoute, WebsocketRouter, MiddlewareConfig
+from hypern.hypern import DatabaseConfig, FunctionInfo, MiddlewareConfig, Router, Server, WebsocketRouter
+from hypern.hypern import Route as InternalRoute
+from hypern.logging import logger
+from hypern.middleware import Middleware
 from hypern.openapi import SchemaGenerator, SwaggerUI
 from hypern.processpool import run_processes
 from hypern.response import HTMLResponse, JSONResponse
 from hypern.routing import Route
 from hypern.scheduler import Scheduler
-from hypern.middleware import Middleware
-from hypern.args_parser import ArgsConfig
 from hypern.ws import WebsocketRoute
-from hypern.logging import logger
 
 AppType = TypeVar("AppType", bound="Hypern")
 
 
+@dataclass
+class ThreadConfig:
+    workers: int
+    max_blocking_threads: int
+
+
+class ThreadConfigurator:
+    def __init__(self):
+        self._cpu_count = psutil.cpu_count(logical=True)
+        self._memory_gb = psutil.virtual_memory().total / (1024**3)
+
+    def get_config(self, concurrent_requests: int = None) -> ThreadConfig:
+        """Calculate optimal thread configuration based on system resources."""
+        workers = max(2, self._cpu_count)
+
+        if concurrent_requests:
+            max_blocking = min(max(32, concurrent_requests * 2), workers * 4, int(self._memory_gb * 8))
+        else:
+            max_blocking = min(workers * 4, int(self._memory_gb * 8), 256)
+
+        return ThreadConfig(workers=workers, max_blocking_threads=max_blocking)
+
+
 class Hypern:
     def __init__(
         self: AppType,
@@ -199,6 +225,14 @@ class Hypern:
                 """
             ),
         ] = False,
+        database_config: Annotated[
+            DatabaseConfig | None,
+            Doc(
+                """
+                The database configuration for the application.
+                """
+            ),
+        ] = None,
         *args: Any,
         **kwargs: Any,
     ) -> None:
@@ -214,6 +248,8 @@ class Hypern:
         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()
 
         for route in routes or []:
             self.router.extend_route(route(app=self).routes)
@@ -369,6 +405,15 @@ class Hypern:
         after_request = FunctionInfo(handler=after_request, is_async=is_async)
         self.middleware_after_request.append((after_request, middleware.config))
 
+    def set_database_config(self, config: DatabaseConfig):
+        """
+        Sets the database configuration for the application.
+
+        Args:
+            config (DatabaseConfig): The database configuration to be set.
+        """
+        self.database_config = config
+
     def start(
         self,
     ):
@@ -381,22 +426,35 @@ class Hypern:
         if self.scheduler:
             self.scheduler.start()
 
+        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_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)
+        if self.start_up_handler:
+            server.set_startup_handler(self.start_up_handler)
+        if self.shutdown_handler:
+            server.set_shutdown_handler(self.shutdown_handler)
+
+        if self.args.auto_workers:
+            self.args.workers = self.thread_config.workers
+            self.args.max_blocking_threads = self.thread_config.max_blocking_threads
+
         run_processes(
+            server=server,
             host=self.args.host,
             port=self.args.port,
             workers=self.args.workers,
             processes=self.args.processes,
             max_blocking_threads=self.args.max_blocking_threads,
-            router=self.router,
-            websocket_router=self.websocket_router,
-            injectables=self.injectables,
-            before_request=self.middleware_before_request,
-            after_request=self.middleware_after_request,
-            response_headers=self.response_headers,
             reload=self.args.reload,
-            on_startup=self.start_up_handler,
-            on_shutdown=self.shutdown_handler,
-            auto_compression=self.args.auto_compression or self.auto_compression,
         )
 
     def add_route(self, method: HTTPMethod, endpoint: str, handler: Callable[..., Any]):

hypern/args_parser.py

@@ -55,12 +55,38 @@ class ArgsConfig:
             action="store_true",
             help="It compresses the response automatically.",
         )
+
+        parser.add_argument(
+            "--auto-workers",
+            action="store_true",
+            help="It sets the number of workers and max-blocking-threads automatically.",
+        )
+
+        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]",
+        )
+
         args, _ = parser.parse_known_args()
 
         self.host = args.host or "127.0.0.1"
         self.port = args.port or 5000
-        self.max_blocking_threads = args.max_blocking_threads or 100
+        self.max_blocking_threads = args.max_blocking_threads or 32
         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

hypern/config.py

@@ -1,9 +1,15 @@
 from __future__ import annotations
 
 import os
+
+# -*- coding: utf-8 -*-
+import threading
 import typing
 import warnings
+from contextvars import ContextVar
+from datetime import datetime
 from pathlib import Path
+from typing import Dict, Optional
 
 """
 
@@ -147,3 +153,94 @@ class Config:
             return cast(value)
         except (TypeError, ValueError):
             raise ValueError(f"Config '{key}' has value '{value}'. Not a valid {cast.__name__}.")
+
+
+class ContextStore:
+    def __init__(self, cleanup_interval: int = 300, max_age: int = 3600):
+        """
+        Initialize ContextStore with automatic session cleanup.
+
+        :param cleanup_interval: Interval between cleanup checks (in seconds)
+        :param max_age: Maximum age of a session before it's considered expired (in seconds)
+        """
+        self._session_times: Dict[str, datetime] = {}
+        self.session_var = ContextVar("session_id", default=None)
+
+        self._max_age = max_age
+        self._cleanup_interval = cleanup_interval
+        self._cleanup_thread: Optional[threading.Thread] = None
+        self._stop_event = threading.Event()
+
+        # Start the cleanup thread
+        self._start_cleanup_thread()
+
+    def _start_cleanup_thread(self):
+        """Start a background thread for periodic session cleanup."""
+
+        def cleanup_worker():
+            while not self._stop_event.is_set():
+                self._perform_cleanup()
+                self._stop_event.wait(self._cleanup_interval)
+
+        self._cleanup_thread = threading.Thread(
+            target=cleanup_worker,
+            daemon=True,  # Allows the thread to be automatically terminated when the main program exits
+        )
+        self._cleanup_thread.start()
+
+    def _perform_cleanup(self):
+        """Perform cleanup of expired sessions."""
+        current_time = datetime.now()
+        expired_sessions = [
+            session_id for session_id, timestamp in list(self._session_times.items()) if (current_time - timestamp).total_seconds() > self._max_age
+        ]
+
+        for session_id in expired_sessions:
+            self.remove_session(session_id)
+
+    def remove_session(self, session_id: str):
+        """Remove a specific session."""
+        self._session_times.pop(session_id, None)
+
+    def set_context(self, session_id: str):
+        """
+        Context manager for setting and resetting session context.
+
+        :param session_id: Unique identifier for the session
+        :return: Context manager for session
+        """
+        self.session_var.set(session_id)
+        self._session_times[session_id] = datetime.now()
+
+    def get_context(self) -> str:
+        """
+        Get the current session context.
+
+        :return: Current session ID
+        :raises RuntimeError: If no session context is available
+        """
+        return self.session_var.get()
+
+    def reset_context(self):
+        """Reset the session context."""
+        token = self.get_context()
+        if token is not None:
+            self.session_var.reset(token)
+
+    def stop_cleanup(self):
+        """
+        Stop the cleanup thread.
+        Useful for graceful shutdown of the application.
+        """
+        self._stop_event.set()
+        if self._cleanup_thread:
+            self._cleanup_thread.join()
+
+    def __del__(self):
+        """
+        Ensure cleanup thread is stopped when the object is deleted.
+        """
+        self.stop_cleanup()
+
+
+context_store = ContextStore()

hypern/db/addons/__init__.py

@@ -0,0 +1,5 @@
+from . import sqlalchemy
+
+__all__ = [
+    "sqlalchemy",
+]

hypern/db/addons/sqlalchemy/__init__.py

@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+import asyncio
+import traceback
+from contextlib import asynccontextmanager
+
+from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession, async_scoped_session
+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):
+        """
+        Initialize the SQL configuration.
+        You can provide a default engine, a reader engine, and a writer engine.
+        If only one engine is provided (default_engine), it will be used for both reading and writing.
+        If both reader and writer engines are provided, they will be used for reading and writing respectively.
+        Note: The reader and writer engines must be different.
+        """
+
+        assert default_engine or reader_engine or writer_engine, "At least one engine must be provided."
+        assert not (reader_engine and writer_engine and id(reader_engine) == id(writer_engine)), "Reader and writer engines must be different."
+
+        engines = {
+            "writer": writer_engine or default_engine,
+            "reader": reader_engine or default_engine,
+        }
+
+        class RoutingSession(Session):
+            def get_bind(this, mapper=None, clause=None, **kwargs):
+                if this._flushing or isinstance(clause, (Update, Delete, Insert)):
+                    return engines["writer"].sync_engine
+                return engines["reader"].sync_engine
+
+        async_session_factory = sessionmaker(
+            class_=AsyncSession,
+            sync_session_class=RoutingSession,
+            expire_on_commit=False,
+        )
+
+        session_scope: AsyncSession | async_scoped_session = async_scoped_session(
+            session_factory=async_session_factory,
+            scopefunc=asyncio.current_task,
+        )
+
+        @asynccontextmanager
+        async def get_session():
+            """
+            Get the database session.
+            This can be used for dependency injection.
+
+            :return: The database session.
+            """
+            try:
+                yield session_scope
+            except Exception:
+                traceback.print_exc()
+                await session_scope.rollback()
+            finally:
+                await session_scope.remove()
+                await session_scope.close()
+
+        self.get_session = get_session
+
+    def init_app(self, app):
+        app.inject("get_session", self.get_session)
+
+
+__all__ = ["Model", "PostgresRepository", "SqlalchemyConfig"]

hypern/db/sql/__init__.py

@@ -1,179 +1,13 @@
-# -*- coding: utf-8 -*-
-import asyncio
-import threading
-import traceback
-from contextlib import asynccontextmanager
-from contextvars import ContextVar, Token
-from datetime import datetime
-from typing import Dict, Optional, Union
-from uuid import uuid4
-
-from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession, async_scoped_session
-from sqlalchemy.orm import Session, sessionmaker
-from sqlalchemy.sql.expression import Delete, Insert, Update
-
-from hypern.hypern import Request, Response
-
-from .repository import Model, PostgresRepository
-
-
-class ContextStore:
-    def __init__(self, cleanup_interval: int = 300, max_age: int = 3600):
-        """
-        Initialize ContextStore with automatic session cleanup.
-
-        :param cleanup_interval: Interval between cleanup checks (in seconds)
-        :param max_age: Maximum age of a session before it's considered expired (in seconds)
-        """
-        self._session_times: Dict[str, datetime] = {}
-        self.session_var = ContextVar("session_id", default=None)
-
-        self._max_age = max_age
-        self._cleanup_interval = cleanup_interval
-        self._cleanup_thread: Optional[threading.Thread] = None
-        self._stop_event = threading.Event()
-
-        # Start the cleanup thread
-        self._start_cleanup_thread()
-
-    def _start_cleanup_thread(self):
-        """Start a background thread for periodic session cleanup."""
-
-        def cleanup_worker():
-            while not self._stop_event.is_set():
-                self._perform_cleanup()
-                self._stop_event.wait(self._cleanup_interval)
-
-        self._cleanup_thread = threading.Thread(
-            target=cleanup_worker,
-            daemon=True,  # Allows the thread to be automatically terminated when the main program exits
-        )
-        self._cleanup_thread.start()
-
-    def _perform_cleanup(self):
-        """Perform cleanup of expired sessions."""
-        current_time = datetime.now()
-        expired_sessions = [
-            session_id for session_id, timestamp in list(self._session_times.items()) if (current_time - timestamp).total_seconds() > self._max_age
-        ]
-
-        for session_id in expired_sessions:
-            self.remove_session(session_id)
-
-    def remove_session(self, session_id: str):
-        """Remove a specific session."""
-        self._session_times.pop(session_id, None)
-
-    def set_context(self, session_id: str):
-        """
-        Context manager for setting and resetting session context.
-
-        :param session_id: Unique identifier for the session
-        :return: Context manager for session
-        """
-        self.session_var.set(session_id)
-        self._session_times[session_id] = datetime.now()
-
-    def get_context(self) -> str:
-        """
-        Get the current session context.
-
-        :return: Current session ID
-        :raises RuntimeError: If no session context is available
-        """
-        return self.session_var.get()
-
-    def reset_context(self):
-        """Reset the session context."""
-        token = self.get_context()
-        if token is not None:
-            self.session_var.reset(token)
-
-    def stop_cleanup(self):
-        """
-        Stop the cleanup thread.
-        Useful for graceful shutdown of the application.
-        """
-        self._stop_event.set()
-        if self._cleanup_thread:
-            self._cleanup_thread.join()
-
-    def __del__(self):
-        """
-        Ensure cleanup thread is stopped when the object is deleted.
-        """
-        self.stop_cleanup()
-
-
-class SqlConfig:
-    def __init__(self, default_engine: AsyncEngine | None = None, reader_engine: AsyncEngine | None = None, writer_engine: AsyncEngine | None = None):
-        """
-        Initialize the SQL configuration.
-        You can provide a default engine, a reader engine, and a writer engine.
-        If only one engine is provided (default_engine), it will be used for both reading and writing.
-        If both reader and writer engines are provided, they will be used for reading and writing respectively.
-        Note: The reader and writer engines must be different.
-        """
-
-        assert default_engine or reader_engine or writer_engine, "At least one engine must be provided."
-        assert not (reader_engine and writer_engine and id(reader_engine) == id(writer_engine)), "Reader and writer engines must be different."
-
-        engines = {
-            "writer": writer_engine or default_engine,
-            "reader": reader_engine or default_engine,
-        }
-        self.session_store = ContextStore()
-
-        class RoutingSession(Session):
-            def get_bind(this, mapper=None, clause=None, **kwargs):
-                if this._flushing or isinstance(clause, (Update, Delete, Insert)):
-                    return engines["writer"].sync_engine
-                return engines["reader"].sync_engine
-
-        async_session_factory = sessionmaker(
-            class_=AsyncSession,
-            sync_session_class=RoutingSession,
-            expire_on_commit=False,
-        )
-
-        session_scope: Union[AsyncSession, async_scoped_session] = async_scoped_session(
-            session_factory=async_session_factory,
-            scopefunc=asyncio.current_task,
-        )
-
-        @asynccontextmanager
-        async def get_session():
-            """
-            Get the database session.
-            This can be used for dependency injection.
-
-            :return: The database session.
-            """
-            try:
-                yield session_scope
-            except Exception:
-                traceback.print_exc()
-                await session_scope.rollback()
-            finally:
-                await session_scope.remove()
-                await session_scope.close()
-
-        self.get_session = get_session
-        self._context_token: Optional[Token] = None
-
-    def before_request(self, request: Request):
-        token = str(uuid4())
-        self.session_store.set_context(token)
-        return request
-
-    def after_request(self, response: Response):
-        self.session_store.reset_context()
-        return response
-
-    def init_app(self, app):
-        app.inject("get_session", self.get_session)
-        app.before_request()(self.before_request)
-        app.after_request()(self.after_request)
-
-
-__all__ = ["Model", "PostgresRepository", "SqlConfig"]
+# from .context import SqlConfig, DatabaseType
+from .field import CharField, IntegerField
+from .model import Model
+from .query import F, Q, QuerySet
+
+__all__ = [
+    "CharField",
+    "IntegerField",
+    "Model",
+    "Q",
+    "F",
+    "QuerySet",
+]