hypern 0.3.1__cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.whl → 0.3.3__cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.whl

hypern/application.py

@@ -2,25 +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
+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
 
 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,
@@ -190,6 +217,22 @@ class Hypern:
                 """
             ),
         ] = None,
+        auto_compression: Annotated[
+            bool,
+            Doc(
+                """
+                Enable automatic compression of responses.
+                """
+            ),
+        ] = False,
+        database_config: Annotated[
+            DatabaseConfig | None,
+            Doc(
+                """
+                The database configuration for the application.
+                """
+            ),
+        ] = None,
         *args: Any,
         **kwargs: Any,
     ) -> None:
@@ -202,6 +245,11 @@ class Hypern:
         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()
 
         for route in routes or []:
             self.router.extend_route(route(app=self).routes)
@@ -287,10 +335,12 @@ class Hypern:
             function: The decorator function that registers the middleware.
         """
 
+        logger.warning("This functin will be deprecated in version 0.4.0. Please use the middleware class instead.")
+
         def decorator(func):
             is_async = asyncio.iscoroutinefunction(func)
             func_info = FunctionInfo(handler=func, is_async=is_async)
-            self.middleware_before_request.append(func_info)
+            self.middleware_before_request.append((func_info, MiddlewareConfig.default()))
             return func
 
         return decorator
@@ -306,11 +356,12 @@ class Hypern:
         Returns:
             function: The decorator function that registers the given function.
         """
+        logger.warning("This functin will be deprecated in version 0.4.0. Please use the middleware class instead.")
 
         def decorator(func):
             is_async = asyncio.iscoroutinefunction(func)
             func_info = FunctionInfo(handler=func, is_async=is_async)
-            self.middleware_after_request.append(func_info)
+            self.middleware_after_request.append((func_info, MiddlewareConfig.default()))
             return func
 
         return decorator
@@ -346,11 +397,22 @@ class Hypern:
         before_request = getattr(middleware, "before_request", None)
         after_request = getattr(middleware, "after_request", None)
 
-        if before_request:
-            self.before_request()(before_request)
-        if after_request:
-            self.after_request()(after_request)
-        return self
+        is_async = asyncio.iscoroutinefunction(before_request)
+        before_request = FunctionInfo(handler=before_request, is_async=is_async)
+        self.middleware_before_request.append((before_request, middleware.config))
+
+        is_async = asyncio.iscoroutinefunction(after_request)
+        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,
@@ -364,18 +426,36 @@ 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)
+
+        server.optimize_routes()
+
+        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,
         )
 
@@ -403,3 +483,22 @@ class Hypern:
         """
         for route in ws_route.routes:
             self.websocket_router.add_route(route=route)
+
+    def on_startup(self, handler: Callable[..., Any]):
+        """
+        Registers a function to be executed on application startup.
+
+        Args:
+            handler (Callable[..., Any]): The function to be executed on application startup.
+        """
+        # decorator
+        self.start_up_handler = FunctionInfo(handler=handler, is_async=asyncio.iscoroutinefunction(handler))
+
+    def on_shutdown(self, handler: Callable[..., Any]):
+        """
+        Registers a function to be executed on application shutdown.
+
+        Args:
+            handler (Callable[..., Any]): The function to be executed on application shutdown.
+        """
+        self.shutdown_handler = FunctionInfo(handler=handler, is_async=asyncio.iscoroutinefunction(handler))

hypern/args_parser.py

@@ -49,11 +49,44 @@ 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",
+            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/caching/__init__.py

@@ -0,0 +1,6 @@
+from .backend import BaseBackend
+from .redis_backend import RedisBackend
+
+from .strategies import CacheAsideStrategy, CacheEntry, CacheStrategy, StaleWhileRevalidateStrategy, cache_with_strategy
+
+__all__ = ["BaseBackend", "RedisBackend", "CacheAsideStrategy", "CacheEntry", "CacheStrategy", "StaleWhileRevalidateStrategy", "cache_with_strategy"]

hypern/caching/backend.py

@@ -0,0 +1,31 @@
+from abc import ABC, abstractmethod
+from typing import Any, Optional
+
+
+class BaseBackend(ABC):
+    @abstractmethod
+    async def get(self, key: str) -> Any: ...
+
+    @abstractmethod
+    async def set(self, key: str, value: Any, ttl: Optional[int] = None) -> None: ...
+
+    @abstractmethod
+    async def delete_pattern(self, pattern: str) -> None: ...
+
+    @abstractmethod
+    async def delete(self, key: str) -> None: ...
+
+    @abstractmethod
+    async def exists(self, key: str) -> bool: ...
+
+    @abstractmethod
+    async def set_nx(self, key: str, value: Any, ttl: Optional[int] = None) -> bool: ...
+
+    @abstractmethod
+    async def ttl(self, key: str) -> int: ...
+
+    @abstractmethod
+    async def incr(self, key: str) -> int: ...
+
+    @abstractmethod
+    async def clear(self) -> None: ...

hypern/caching/redis_backend.py

@@ -1,3 +1,201 @@
-from hypern.hypern import RedisBackend
+# src/hypern/cache/backends/redis.py
+import pickle
+from typing import Any, Optional
 
-__all__ = ["RedisBackend"]
+from redis import asyncio as aioredis
+
+from hypern.logging import logger
+
+from .backend import BaseBackend
+
+
+class RedisBackend(BaseBackend):
+    def __init__(self, url: str = "redis://localhost:6379", encoding: str = "utf-8", decode_responses: bool = False, **kwargs):
+        """
+        Initialize Redis backend with aioredis
+
+        Args:
+            url: Redis connection URL
+            encoding: Character encoding to use
+            decode_responses: Whether to decode response bytes to strings
+            **kwargs: Additional arguments passed to aioredis.from_url
+        """
+        self.redis = aioredis.from_url(url, encoding=encoding, decode_responses=decode_responses, **kwargs)
+        self._encoding = encoding
+
+    async def get(self, key: str) -> Optional[Any]:
+        """
+        Get value from Redis
+
+        Args:
+            key: Cache key
+
+        Returns:
+            Deserialized Python object or None if key doesn't exist
+        """
+        try:
+            value = await self.redis.get(key)
+            if value is not None:
+                return pickle.loads(value)
+            return None
+        except Exception as e:
+            logger.error(f"Error getting cache key {key}: {e}")
+            return None
+
+    async def set(self, key: str, value: Any, ttl: Optional[int] = None) -> bool:
+        """
+        Set value in Redis with optional TTL
+
+        Args:
+            key: Cache key
+            value: Python object to store
+            ttl: Time to live in seconds
+
+        Returns:
+            bool: True if successful, False otherwise
+        """
+        try:
+            serialized = pickle.dumps(value)
+            if ttl is not None:
+                await self.redis.setex(key, ttl, serialized)
+            else:
+                await self.redis.set(key, serialized)
+            return True
+        except Exception as e:
+            logger.error(f"Error setting cache key {key}: {e}")
+            return False
+
+    async def delete(self, key: str) -> bool:
+        """
+        Delete key from Redis
+
+        Args:
+            key: Cache key to delete
+
+        Returns:
+            bool: True if key was deleted, False otherwise
+        """
+        try:
+            return bool(await self.redis.delete(key))
+        except Exception as e:
+            logger.error(f"Error deleting cache key {key}: {e}")
+            return False
+
+    async def delete_pattern(self, pattern: str) -> int:
+        """
+        Delete all keys matching pattern
+
+        Args:
+            pattern: Redis key pattern to match
+
+        Returns:
+            int: Number of keys deleted
+        """
+        try:
+            keys = await self.redis.keys(pattern)
+            if keys:
+                return await self.redis.delete(*keys)
+            return 0
+        except Exception as e:
+            logger.error(f"Error deleting keys matching {pattern}: {e}")
+            return 0
+
+    async def exists(self, key: str) -> bool:
+        """
+        Check if key exists
+
+        Args:
+            key: Cache key to check
+
+        Returns:
+            bool: True if key exists, False otherwise
+        """
+        try:
+            return bool(await self.redis.exists(key))
+        except Exception as e:
+            logger.error(f"Error checking existence of key {key}: {e}")
+            return False
+
+    async def ttl(self, key: str) -> int:
+        """
+        Get TTL of key in seconds
+
+        Args:
+            key: Cache key
+
+        Returns:
+            int: TTL in seconds, -2 if key doesn't exist, -1 if key has no TTL
+        """
+        try:
+            return await self.redis.ttl(key)
+        except Exception as e:
+            logger.error(f"Error getting TTL for key {key}: {e}")
+            return -2
+
+    async def incr(self, key: str, amount: int = 1) -> Optional[int]:
+        """
+        Increment value by amount
+
+        Args:
+            key: Cache key
+            amount: Amount to increment by
+
+        Returns:
+            int: New value after increment or None on error
+        """
+        try:
+            return await self.redis.incrby(key, amount)
+        except Exception as e:
+            logger.error(f"Error incrementing key {key}: {e}")
+            return None
+
+    async def set_nx(self, key: str, value: Any, ttl: Optional[int] = None) -> bool:
+        """
+        Set key only if it doesn't exist (SET NX operation)
+
+        Args:
+            key: Cache key
+            value: Value to set
+            ttl: Optional TTL in seconds
+
+        Returns:
+            bool: True if key was set, False otherwise
+        """
+        try:
+            serialized = pickle.dumps(value)
+            if ttl is not None:
+                return await self.redis.set(key, serialized, nx=True, ex=ttl)
+            return await self.redis.set(key, serialized, nx=True)
+        except Exception as e:
+            logger.error(f"Error setting NX for key {key}: {e}")
+            return False
+
+    async def clear(self) -> bool:
+        """
+        Clear all keys from the current database
+
+        Returns:
+            bool: True if successful, False otherwise
+        """
+        try:
+            await self.redis.flushdb()
+            return True
+        except Exception as e:
+            logger.error(f"Error clearing cache: {e}")
+            return False
+
+    async def close(self) -> None:
+        """Close Redis connection"""
+        await self.redis.close()
+
+    async def ping(self) -> bool:
+        """
+        Check Redis connection
+
+        Returns:
+            bool: True if connection is alive, False otherwise
+        """
+        try:
+            return await self.redis.ping()
+        except Exception:
+            return False