hypern 0.2.1__cp310-cp310-macosx_10_12_x86_64.whl → 0.3.1__cp310-cp310-macosx_10_12_x86_64.whl

hypern/application.py

@@ -8,8 +8,7 @@ import orjson
 from typing_extensions import Annotated, Doc
 
 from hypern.datastructures import Contact, HTTPMethod, Info, License
-from hypern.hypern import FunctionInfo, Router
-from hypern.hypern import Route as InternalRoute
+from hypern.hypern import FunctionInfo, Router, Route as InternalRoute, WebsocketRouter
 from hypern.openapi import SchemaGenerator, SwaggerUI
 from hypern.processpool import run_processes
 from hypern.response import HTMLResponse, JSONResponse
@@ -17,6 +16,7 @@ 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")
 
@@ -47,6 +47,15 @@ class Hypern:
                 """
             ),
         ] = None,
+        websockets: Annotated[
+            List[WebsocketRoute] | None,
+            Doc(
+                """
+                A list of routes to serve incoming WebSocket requests.
+                You can define routes using the `WebsocketRoute` class from `Hypern
+                """
+            ),
+        ] = None,
         title: Annotated[
             str,
             Doc(
@@ -186,6 +195,7 @@ class Hypern:
     ) -> None:
         super().__init__(*args, **kwargs)
         self.router = Router(path="/")
+        self.websocket_router = WebsocketRouter(path="/")
         self.scheduler = scheduler
         self.injectables = default_injectables or {}
         self.middleware_before_request = []
@@ -193,9 +203,12 @@ class Hypern:
         self.response_headers = {}
         self.args = ArgsConfig()
 
-        for route in routes:
+        for route in routes or []:
             self.router.extend_route(route(app=self).routes)
 
+        for websocket_route in websockets or []:
+            self.websocket_router.add_route(websocket_route)
+
         if openapi_url and docs_url:
             self.__add_openapi(
                 info=Info(
@@ -358,6 +371,7 @@ class Hypern:
             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,
@@ -379,3 +393,13 @@ class Hypern:
         func_info = FunctionInfo(handler=handler, is_async=is_async)
         route = InternalRoute(path=endpoint, function=func_info, method=method.name)
         self.router.add_route(route=route)
+
+    def add_websocket(self, ws_route: WebsocketRoute):
+        """
+        Adds a WebSocket route to the WebSocket router.
+
+        Args:
+            ws_route (WebsocketRoute): The WebSocket route to be added to the router.
+        """
+        for route in ws_route.routes:
+            self.websocket_router.add_route(route=route)

hypern/caching/strategies.py

@@ -0,0 +1,115 @@
+from typing import Any, Optional, Callable, TypeVar
+from datetime import datetime
+import asyncio
+import orjson
+
+from hypern.logging import logger
+
+T = TypeVar("T")
+
+
+class CacheEntry:
+    def __init__(self, value: Any, expires_at: int, stale_at: Optional[int] = None):
+        self.value = value
+        self.expires_at = expires_at
+        self.stale_at = stale_at or expires_at
+        self.is_revalidating = False
+
+    def to_json(self) -> str:
+        return orjson.dumps({"value": self.value, "expires_at": self.expires_at, "stale_at": self.stale_at, "is_revalidating": self.is_revalidating})
+
+    @classmethod
+    def from_json(cls, data: str) -> "CacheEntry":
+        data_dict = orjson.loads(data)
+        entry = cls(value=data_dict["value"], expires_at=data_dict["expires_at"], stale_at=data_dict["stale_at"])
+        entry.is_revalidating = data_dict["is_revalidating"]
+        return entry
+
+
+class CacheStrategy:
+    def __init__(self, backend: Any):
+        self.backend = backend
+
+    async def get(self, key: str, loader: Callable[[], T]) -> T:
+        raise NotImplementedError
+
+
+class StaleWhileRevalidateStrategy(CacheStrategy):
+    def __init__(self, backend: Any, stale_ttl: int, cache_ttl: int):
+        super().__init__(backend)
+        self.stale_ttl = stale_ttl
+        self.cache_ttl = cache_ttl
+
+    async def get(self, key: str, loader: Callable[[], T]) -> T:
+        now = int(datetime.now().timestamp())
+
+        # Try to get from cache
+        cached_data = await self.backend.get(key)
+        if cached_data:
+            entry = CacheEntry.from_json(cached_data)
+
+            if now < entry.stale_at:
+                # Cache is fresh
+                return entry.value
+
+            if now < entry.expires_at and not entry.is_revalidating:
+                # Cache is stale but usable - trigger background revalidation
+                entry.is_revalidating = True
+                await self.backend.set(key, entry.to_json(), self.cache_ttl)
+                asyncio.create_task(self._revalidate(key, loader))
+                return entry.value
+
+        # Cache miss or expired - load fresh data
+        value = await loader()
+        entry = CacheEntry(value=value, expires_at=now + self.cache_ttl, stale_at=now + (self.cache_ttl - self.stale_ttl))
+        await self.backend.set(key, entry.to_json(), self.cache_ttl)
+        return value
+
+    async def _revalidate(self, key: str, loader: Callable[[], T]):
+        try:
+            value = await loader()
+            now = int(datetime.now().timestamp())
+            entry = CacheEntry(value=value, expires_at=now + self.cache_ttl, stale_at=now + (self.cache_ttl - self.stale_ttl))
+            await self.backend.set(key, entry.to_json(), self.cache_ttl)
+        except Exception as e:
+            logger.error(f"Revalidation failed for key {key}: {e}")
+
+
+class CacheAsideStrategy(CacheStrategy):
+    def __init__(self, backend: Any, ttl: int):
+        super().__init__(backend)
+        self.ttl = ttl
+
+    async def get(self, key: str, loader: Callable[[], T]) -> T:
+        # Try to get from cache
+        cached_data = await self.backend.get(key)
+        if cached_data:
+            entry = CacheEntry.from_json(cached_data)
+            if entry.expires_at > int(datetime.now().timestamp()):
+                return entry.value
+
+        # Cache miss or expired - load from source
+        value = await loader()
+        entry = CacheEntry(value=value, expires_at=int(datetime.now().timestamp()) + self.ttl)
+        await self.backend.set(key, entry.to_json(), self.ttl)
+        return value
+
+
+def cache_with_strategy(strategy: CacheStrategy, key_prefix: str = None):
+    """
+    Decorator for using cache strategies
+    """
+
+    def decorator(func):
+        async def wrapper(*args, **kwargs):
+            # Generate cache key
+            cache_key = f"{key_prefix or func.__name__}:{hash(str(args) + str(kwargs))}"
+
+            async def loader():
+                return await func(*args, **kwargs)
+
+            return await strategy.get(cache_key, loader)
+
+        return wrapper
+
+    return decorator

hypern/hypern.pyi

@@ -16,6 +16,9 @@ class RedisBackend(BaseBackend):
     get: Callable[[str], Any]
     set: Callable[[Any, str, int], None]
     delete_startswith: Callable[[str], None]
+    set_nx: Callable[[Any, str, int], None]
+    get_ttl: Callable[[str], int]
+    current_timestamp: Callable[[], int]
 
 @dataclass
 class BaseSchemaGenerator:
@@ -183,9 +186,6 @@ class FunctionInfo:
     handler: Callable
     is_async: bool
 
-class SocketHeld:
-    socket: Any
-
 @dataclass
 class Server:
     router: Router
@@ -195,6 +195,7 @@ class Server:
 
     def add_route(self, route: Route) -> None: ...
     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: ...
@@ -227,15 +228,48 @@ class Router:
     def get_routes_by_method(self, method: str) -> List[Route]: ...
     def extend_route(self, routes: List[Route]) -> None: ...
 
+@dataclass
+class SocketHeld:
+    socket: Any
+
+@dataclass
+class WebSocketSession:
+    sender: Callable[[str], None]
+    receiver: Callable[[], str]
+    is_closed: bool
+
+    def send(self, message: str) -> None: ...
+
+@dataclass
+class WebsocketRoute:
+    path: str
+    handler: Callable[[WebSocketSession], None]
+
+@dataclass
+class WebsocketRouter:
+    path: str
+    routes: List[WebsocketRoute]
+
+    def add_route(self, route: WebsocketRoute) -> None: ...
+    def remove_route(self, path: str) -> None: ...
+    def extend_route(self, route: WebsocketRoute) -> None: ...
+    def clear_routes(self) -> None: ...
+    def route_count(self) -> int: ...
+
 @dataclass
 class Header:
     headers: Dict[str, str]
 
+    def get(self, key: str) -> str | None: ...
+    def set(self, key: str, value: str) -> None: ...
+    def append(self, key: str, value: str) -> None: ...
+    def update(self, headers: Dict[str, str]) -> None: ...
+
 @dataclass
 class Response:
     status_code: int
     response_type: str
-    headers: Any
+    headers: Header
     description: str
     file_path: str
 
@@ -260,7 +294,10 @@ class BodyData:
 @dataclass
 class Request:
     query_params: QueryParams
-    headers: Dict[str, str]
+    headers: Header
     path_params: Dict[str, str]
     body: BodyData
     method: str
+    remote_addr: str
+    timestamp: float
+    context_id: str

hypern/middleware/limit.py

@@ -147,7 +147,7 @@ class ConcurrentRequestMiddleware(Middleware):
         self.lock = Lock()
 
     def get_request_identifier(self, request):
-        return request.ip_addr
+        return request.remote_addr
 
     def before_request(self, request):
         """

hypern/middleware/security.py

@@ -0,0 +1,179 @@
+import hashlib
+import hmac
+import secrets
+import time
+from base64 import b64decode, b64encode
+from dataclasses import dataclass
+from datetime import datetime, timedelta
+from typing import Any, Dict, List, Optional
+
+import jwt
+
+from hypern.exceptions import Forbidden, Unauthorized
+from hypern.hypern import Middleware, Request, Response
+
+
+@dataclass
+class CORSConfig:
+    allowed_origins: List[str]
+    allowed_methods: List[str]
+    max_age: int
+
+
+@dataclass
+class SecurityConfig:
+    rate_limiting: bool = False
+    jwt_auth: bool = False
+    cors_configuration: Optional[CORSConfig] = None
+    csrf_protection: bool = False
+    security_headers: Optional[Dict[str, str]] = None
+    jwt_secret: str = ""
+    jwt_algorithm: str = "HS256"
+    jwt_expires_in: int = 3600  # 1 hour in seconds
+
+    def __post_init__(self):
+        if self.cors_configuration:
+            self.cors_configuration = CORSConfig(**self.cors_configuration)
+
+        if self.security_headers is None:
+            self.security_headers = {
+                "X-Frame-Options": "DENY",
+                "X-Content-Type-Options": "nosniff",
+                "Strict-Transport-Security": "max-age=31536000; includeSubDomains",
+            }
+
+
+class SecurityMiddleware(Middleware):
+    def __init__(self, config: SecurityConfig):
+        super().__init__()
+        self.config = config
+        self._secret_key = secrets.token_bytes(32)
+        self._token_lifetime = 3600
+        self._rate_limit_storage = {}
+
+    def _rate_limit_check(self, request: Request) -> Optional[Response]:
+        """Check if the request exceeds rate limits"""
+        if not self.config.rate_limiting:
+            return None
+
+        client_ip = request.client.host
+        current_time = time.time()
+        window_start = int(current_time - 60)  # 1-minute window
+
+        # Clean up old entries
+        self._rate_limit_storage = {ip: hits for ip, hits in self._rate_limit_storage.items() if hits["timestamp"] > window_start}
+
+        if client_ip not in self._rate_limit_storage:
+            self._rate_limit_storage[client_ip] = {"count": 1, "timestamp": current_time}
+        else:
+            self._rate_limit_storage[client_ip]["count"] += 1
+
+        if self._rate_limit_storage[client_ip]["count"] > 60:  # 60 requests per minute
+            return Response(status_code=429, description=b"Too Many Requests", headers={"Retry-After": "60"})
+        return None
+
+    def _generate_jwt_token(self, user_data: Dict[str, Any]) -> str:
+        """Generate a JWT token"""
+        if not self.config.jwt_secret:
+            raise ValueError("JWT secret key is not configured")
+
+        payload = {"user": user_data, "exp": datetime.utcnow() + timedelta(seconds=self.config.jwt_expires_in), "iat": datetime.utcnow()}
+        return jwt.encode(payload, self.config.jwt_secret, algorithm=self.config.jwt_algorithm)
+
+    def _verify_jwt_token(self, token: str) -> Dict[str, Any]:
+        """Verify JWT token and return payload"""
+        try:
+            payload = jwt.decode(token, self.config.jwt_secret, algorithms=[self.config.jwt_algorithm])
+            return payload
+        except jwt.ExpiredSignatureError:
+            raise Unauthorized("Token has expired")
+        except jwt.InvalidTokenError:
+            raise Unauthorized("Invalid token")
+
+    def _generate_csrf_token(self, session_id: str) -> str:
+        """Generate a new CSRF token"""
+        timestamp = str(int(time.time()))
+        token_data = f"{session_id}:{timestamp}"
+        signature = hmac.new(self._secret_key, token_data.encode(), hashlib.sha256).digest()
+        return b64encode(f"{token_data}:{b64encode(signature).decode()}".encode()).decode()
+
+    def _validate_csrf_token(self, token: str) -> bool:
+        """Validate CSRF token"""
+        try:
+            decoded_token = b64decode(token.encode()).decode()
+            session_id, timestamp, signature = decoded_token.rsplit(":", 2)
+
+            # Verify timestamp
+            token_time = int(timestamp)
+            current_time = int(time.time())
+            if current_time - token_time > self._token_lifetime:
+                return False
+
+            # Verify signature
+            expected_data = f"{session_id}:{timestamp}"
+            expected_signature = hmac.new(self._secret_key, expected_data.encode(), hashlib.sha256).digest()
+
+            actual_signature = b64decode(signature)
+            return hmac.compare_digest(expected_signature, actual_signature)
+
+        except (ValueError, AttributeError, TypeError):
+            return False
+
+    def _apply_cors_headers(self, response: Response) -> None:
+        """Apply CORS headers to response"""
+        if not self.config.cors_configuration:
+            return
+
+        cors = self.config.cors_configuration
+        response.headers.update(
+            {
+                "Access-Control-Allow-Origin": ", ".join(cors.allowed_origins),
+                "Access-Control-Allow-Methods": ", ".join(cors.allowed_methods),
+                "Access-Control-Max-Age": str(cors.max_age),
+                "Access-Control-Allow-Headers": "Content-Type, Authorization, X-CSRF-Token",
+                "Access-Control-Allow-Credentials": "true",
+            }
+        )
+
+    def _apply_security_headers(self, response: Response) -> None:
+        """Apply security headers to response"""
+        if self.config.security_headers:
+            response.headers.update(self.config.security_headers)
+
+    async def before_request(self, request: Request) -> Request | Response:
+        """Process request before handling"""
+        # Rate limiting check
+        if rate_limit_response := self._rate_limit_check(request):
+            return rate_limit_response
+
+        # JWT authentication check
+        if self.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")
+            token = auth_header.split(" ")[1]
+            try:
+                request.user = self._verify_jwt_token(token)
+            except Unauthorized as e:
+                return Response(status_code=401, description=str(e))
+
+        # CSRF protection check
+        if self.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")
+
+        return request
+
+    async def after_request(self, response: Response) -> Response:
+        """Process response after handling"""
+        self._apply_security_headers(response)
+        self._apply_cors_headers(response)
+        return response
+
+    def generate_csrf_token(self, request: Request) -> str:
+        """Generate and set CSRF token for the request"""
+        if not hasattr(request, "session_id"):
+            request.session_id = secrets.token_urlsafe(32)
+        token = self._generate_csrf_token(request.session_id)
+        return token

hypern/processpool.py

@@ -7,7 +7,7 @@ from typing import Any, Dict, List
 from multiprocess import Process
 from watchdog.observers import Observer
 
-from .hypern import FunctionInfo, Router, Server, SocketHeld
+from .hypern import FunctionInfo, Router, Server, SocketHeld, WebsocketRouter
 from .logging import logger
 from .reload import EventHandler
 
@@ -19,6 +19,7 @@ def run_processes(
     processes: int,
     max_blocking_threads: int,
     router: Router,
+    websocket_router: WebsocketRouter,
     injectables: Dict[str, Any],
     before_request: List[FunctionInfo],
     after_request: List[FunctionInfo],
@@ -27,7 +28,9 @@ def run_processes(
 ) -> List[Process]:
     socket = SocketHeld(host, port)
 
-    process_pool = init_processpool(router, socket, workers, processes, max_blocking_threads, injectables, before_request, after_request, response_headers)
+    process_pool = init_processpool(
+        router, websocket_router, socket, workers, processes, max_blocking_threads, injectables, before_request, after_request, response_headers
+    )
 
     def terminating_signal_handler(_sig, _frame):
         logger.info("Terminating server!!")
@@ -67,6 +70,7 @@ def run_processes(
 
 def init_processpool(
     router: Router,
+    websocket_router: WebsocketRouter,
     socket: SocketHeld,
     workers: int,
     processes: int,
@@ -82,7 +86,7 @@ def init_processpool(
         copied_socket = socket.try_clone()
         process = Process(
             target=spawn_process,
-            args=(router, copied_socket, workers, max_blocking_threads, injectables, before_request, after_request, response_headers),
+            args=(router, websocket_router, copied_socket, workers, max_blocking_threads, injectables, before_request, after_request, response_headers),
         )
         process.start()
         process_pool.append(process)
@@ -106,6 +110,7 @@ def initialize_event_loop():
 
 def spawn_process(
     router: Router,
+    websocket_router: WebsocketRouter,
     socket: SocketHeld,
     workers: int,
     max_blocking_threads: int,
@@ -118,6 +123,7 @@ def spawn_process(
 
     server = Server()
     server.set_router(router=router)
+    server.set_websocket_router(websocket_router=websocket_router)
     server.set_injected(injected=injectables)
     server.set_before_hooks(hooks=before_request)
     server.set_after_hooks(hooks=after_request)

hypern/reload.py

@@ -2,6 +2,8 @@ import sys
 import time
 import subprocess
 from watchdog.events import FileSystemEventHandler
+import signal
+import os
 
 from .logging import logger
 
@@ -10,51 +12,35 @@ class EventHandler(FileSystemEventHandler):
     def __init__(self, file_path: str, directory_path: str) -> None:
         self.file_path = file_path
         self.directory_path = directory_path
-        self.process = None  # Keep track of the subprocess
-        self.last_reload = time.time()  # Keep track of the last reload. EventHandler is initialized with the process.
-
-    def stop_server(self):
-        if self.process:
-            try:
-                # Check if the process is still alive
-                if self.process.poll() is None:  # None means the process is still running
-                    self.process.terminate()  # Gracefully terminate the process
-                    self.process.wait(timeout=5)  # Wait for the process to exit
-                else:
-                    logger.error("Process is not running.")
-            except subprocess.TimeoutExpired:
-                logger.error("Process did not terminate in time. Forcing termination.")
-                self.process.kill()  # Forcefully kill the process if it doesn't stop
-            except ProcessLookupError:
-                logger.error("Process does not exist.")
-            except Exception as e:
-                logger.error(f"An error occurred while stopping the server: {e}")
-        else:
-            logger.debug("No process to stop.")
+        self.process = None
+        self.last_reload = time.time()
 
     def reload(self):
-        self.stop_server()
-        logger.debug("Reloading the server")
-        prev_process = self.process
-        if prev_process:
-            prev_process.kill()
-
-        self.process = subprocess.Popen(
-            [sys.executable, *sys.argv],
-        )
-
-        self.last_reload = time.time()
+        # Kill all existing processes with the same command
+        current_cmd = [sys.executable, *sys.argv]
+
+        try:
+            # Find and kill existing processes
+            for proc in subprocess.Popen(["ps", "aux"], stdout=subprocess.PIPE).communicate()[0].decode().splitlines():
+                if all(str(arg) in proc for arg in current_cmd):
+                    pid = int(proc.split()[1])
+                    try:
+                        os.kill(pid, signal.SIGKILL)  # NOSONAR
+                        logger.debug(f"Killed process with PID {pid}")
+                    except ProcessLookupError:
+                        pass
+
+            # Start new process
+            self.process = subprocess.Popen(current_cmd)
+            self.last_reload = time.time()
+            logger.debug("Server reloaded successfully")
+
+        except Exception as e:
+            logger.error(f"Reload failed: {e}")
 
     def on_modified(self, event) -> None:
-        """
-        This function is a callback that will start a new server on every even change
-
-        :param event FSEvent: a data structure with info about the events
-        """
-
-        # Avoid reloading multiple times when watchdog detects multiple events
         if time.time() - self.last_reload < 0.5:
             return
 
-        time.sleep(0.2)  # Wait for the file to be fully written
+        time.sleep(0.2)  # Ensure file is written
         self.reload()

hypern/routing/route.py

@@ -188,7 +188,7 @@ class Route:
             docs["responses"] = {
                 "200": {
                     "description": "Successful response",
-                    "content": {"application/json": {"schema": response_type.model_json_schema()}},
+                    "content": {"application/json": {"schema": pydantic_to_swagger(response_type).get(response_type.__name__)}},
                 }
             }
 

hypern/ws/__init__.py

@@ -0,0 +1,4 @@
+from hypern.hypern import WebSocketSession
+from .route import WebsocketRoute
+
+__all__ = ["WebsocketRoute", "WebSocketSession"]

hypern/ws/channel.py

@@ -0,0 +1,80 @@
+from dataclasses import dataclass, field
+from typing import Any, Awaitable, Callable, Dict, Set
+
+from hypern.hypern import WebSocketSession
+
+
+@dataclass
+class Channel:
+    name: str
+    subscribers: Set[WebSocketSession] = field(default_factory=set)
+    handlers: Dict[str, Callable[[WebSocketSession, Any], Awaitable[None]]] = field(default_factory=dict)
+
+    def publish(self, event: str, data: Any, publisher: WebSocketSession = None):
+        """Publish an event to all subscribers except the publisher"""
+        for subscriber in self.subscribers:
+            if subscriber != publisher:
+                subscriber.send({"channel": self.name, "event": event, "data": data})
+
+    def handle_event(self, event: str, session: WebSocketSession, data: Any):
+        """Handle an event on this channel"""
+        if event in self.handlers:
+            self.handlers[event](session, data)
+
+    def add_subscriber(self, subscriber: WebSocketSession):
+        """Add a subscriber to the channel"""
+        self.subscribers.add(subscriber)
+
+    def remove_subscriber(self, subscriber: WebSocketSession):
+        """Remove a subscriber from the channel"""
+        self.subscribers.discard(subscriber)
+
+    def on(self, event: str):
+        """Decorator for registering event handlers"""
+
+        def decorator(handler: Callable[[WebSocketSession, Any], Awaitable[None]]):
+            self.handlers[event] = handler
+            return handler
+
+        return decorator
+
+
+class ChannelManager:
+    def __init__(self):
+        self.channels: Dict[str, Channel] = {}
+        self.client_channels: Dict[WebSocketSession, Set[str]] = {}
+
+    def create_channel(self, channel_name: str) -> Channel:
+        """Create a new channel if it doesn't exist"""
+        if channel_name not in self.channels:
+            self.channels[channel_name] = Channel(channel_name)
+        return self.channels[channel_name]
+
+    def get_channel(self, channel_name: str) -> Channel:
+        """Get a channel by name"""
+        return self.channels.get(channel_name)
+
+    def subscribe(self, client: WebSocketSession, channel_name: str):
+        """Subscribe a client to a channel"""
+        channel = self.create_channel(channel_name)
+        channel.add_subscriber(client)
+
+        if client not in self.client_channels:
+            self.client_channels[client] = set()
+        self.client_channels[client].add(channel_name)
+
+    def unsubscribe(self, client: WebSocketSession, channel_name: str):
+        """Unsubscribe a client from a channel"""
+        channel = self.get_channel(channel_name)
+        if channel:
+            channel.remove_subscriber(client)
+            if client in self.client_channels:
+                self.client_channels[client].discard(channel_name)
+
+    def unsubscribe_all(self, client: WebSocketSession):
+        """Unsubscribe a client from all channels"""
+        if client in self.client_channels:
+            channels = self.client_channels[client].copy()
+            for channel_name in channels:
+                self.unsubscribe(client, channel_name)
+            del self.client_channels[client]

hypern/ws/heartbeat.py

@@ -0,0 +1,74 @@
+import asyncio
+from dataclasses import dataclass
+from time import time
+from typing import Dict
+
+from hypern.hypern import WebSocketSession
+
+
+@dataclass
+class HeartbeatConfig:
+    ping_interval: float = 30.0  # Send ping every 30 seconds
+    ping_timeout: float = 10.0  # Wait 10 seconds for pong response
+    max_missed_pings: int = 2  # Disconnect after 2 missed pings
+
+
+class HeartbeatManager:
+    def __init__(self, config: HeartbeatConfig = None):
+        self.config = config or HeartbeatConfig()
+        self.active_sessions: Dict[WebSocketSession, float] = {}
+        self.ping_tasks: Dict[WebSocketSession, asyncio.Task] = {}
+        self.missed_pings: Dict[WebSocketSession, int] = {}
+
+    async def start_heartbeat(self, session: WebSocketSession):
+        """Start heartbeat monitoring for a session"""
+        self.active_sessions[session] = time()
+        self.missed_pings[session] = 0
+        self.ping_tasks[session] = asyncio.create_task(self._heartbeat_loop(session))
+
+    async def stop_heartbeat(self, session: WebSocketSession):
+        """Stop heartbeat monitoring for a session"""
+        if session in self.ping_tasks:
+            self.ping_tasks[session].cancel()
+            del self.ping_tasks[session]
+            self.active_sessions.pop(session, None)
+            self.missed_pings.pop(session, None)
+
+    async def handle_pong(self, session: WebSocketSession):
+        """Handle pong response from client"""
+        if session in self.active_sessions:
+            self.active_sessions[session] = time()
+            self.missed_pings[session] = 0
+
+    async def _heartbeat_loop(self, session: WebSocketSession):
+        """Main heartbeat loop for a session"""
+        try:
+            while True:
+                await asyncio.sleep(self.config.ping_interval)
+
+                if session not in self.active_sessions:
+                    break
+
+                # Send ping frame
+                try:
+                    await session.ping()
+                    last_pong = self.active_sessions[session]
+
+                    # Wait for pong timeout
+                    await asyncio.sleep(self.config.ping_timeout)
+
+                    # Check if we received a pong
+                    if self.active_sessions[session] == last_pong:
+                        self.missed_pings[session] += 1
+
+                        # Check if we exceeded max missed pings
+                        if self.missed_pings[session] >= self.config.max_missed_pings:
+                            await session.close(1001, "Connection timeout")
+                            break
+
+                except Exception as e:
+                    await session.close(1001, f"Heartbeat failed: {str(e)}")
+                    break
+
+        finally:
+            await self.stop_heartbeat(session)

hypern/ws/room.py

@@ -0,0 +1,76 @@
+from dataclasses import dataclass, field
+from typing import Dict, Set
+
+from hypern.hypern import WebSocketSession
+
+
+@dataclass
+class Room:
+    name: str
+    clients: Set[WebSocketSession] = field(default_factory=set)
+
+    def broadcast(self, message: str, exclude: WebSocketSession = None):
+        """Broadcast message to all clients in the room except excluded one"""
+        for client in self.clients:
+            if client != exclude:
+                client.send(message)
+
+    def add_client(self, client: WebSocketSession):
+        """Add a client to the room"""
+        self.clients.add(client)
+
+    def remove_client(self, client: WebSocketSession):
+        """Remove a client from the room"""
+        self.clients.discard(client)
+
+    @property
+    def client_count(self) -> int:
+        return len(self.clients)
+
+
+class RoomManager:
+    def __init__(self):
+        self.rooms: Dict[str, Room] = {}
+        self.client_rooms: Dict[WebSocketSession, Set[str]] = {}
+
+    def create_room(self, room_name: str) -> Room:
+        """Create a new room if it doesn't exist"""
+        if room_name not in self.rooms:
+            self.rooms[room_name] = Room(room_name)
+        return self.rooms[room_name]
+
+    def get_room(self, room_name: str) -> Room:
+        """Get a room by name"""
+        return self.rooms.get(room_name)
+
+    def join_room(self, client: WebSocketSession, room_name: str):
+        """Add a client to a room"""
+        room = self.create_room(room_name)
+        room.add_client(client)
+
+        if client not in self.client_rooms:
+            self.client_rooms[client] = set()
+        self.client_rooms[client].add(room_name)
+
+        room.broadcast(f"Client joined room: {room_name}", exclude=client)
+
+    def leave_room(self, client: WebSocketSession, room_name: str):
+        """Remove a client from a room"""
+        room = self.get_room(room_name)
+        if room:
+            room.remove_client(client)
+            if client in self.client_rooms:
+                self.client_rooms[client].discard(room_name)
+
+            room.broadcast(f"Client left room: {room_name}", exclude=client)
+
+            if room.client_count == 0:
+                del self.rooms[room_name]
+
+    def leave_all_rooms(self, client: WebSocketSession):
+        """Remove a client from all rooms"""
+        if client in self.client_rooms:
+            rooms = self.client_rooms[client].copy()
+            for room_name in rooms:
+                self.leave_room(client, room_name)
+            del self.client_rooms[client]

hypern/ws/route.py

@@ -0,0 +1,26 @@
+from typing import Callable, Optional
+
+from hypern.hypern import WebsocketRoute as WebsocketRouteInternal, WebSocketSession
+
+
+class WebsocketRoute:
+    def __init__(self) -> None:
+        self.routes = []
+        self._disconnect_handler: Optional[Callable] = None
+
+    def on(self, path):
+        def wrapper(func):
+            self.routes.append(WebsocketRouteInternal(path, func))
+            return func
+
+        return wrapper
+
+    def on_disconnect(self, func):
+        """Register a disconnect handler"""
+        self._disconnect_handler = func
+        return func
+
+    def handle_disconnect(self, session: WebSocketSession):
+        """Internal method to handle disconnection"""
+        if self._disconnect_handler:
+            return self._disconnect_handler(session)

hypern/ws.py

@@ -0,0 +1,16 @@
+from .hypern import WebsocketRoute as WebsocketRouteInternal, WebSocketSession
+
+
+class WebsocketRoute:
+    def __init__(self) -> None:
+        self.routes = []
+
+    def on(self, path):
+        def wrapper(func):
+            self.routes.append(WebsocketRouteInternal(path, func))
+            return func
+
+        return wrapper
+
+
+__all__ = ["WebsocketRoute", "WebSocketSession"]

{hypern-0.2.1.dist-info → hypern-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: hypern
-Version: 0.2.1
+Version: 0.3.1
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{hypern-0.2.1.dist-info → hypern-0.3.1.dist-info}/RECORD

@@ -1,16 +1,17 @@
-hypern-0.2.1.dist-info/METADATA,sha256=XnBEky_cZRe5MMTijuguzD2xMsbXI8Jc0mLvXmlO1Zo,3658
-hypern-0.2.1.dist-info/WHEEL,sha256=LVI1AVbYRTYC5adM2lSivmcJtOl9s941xFznjYMT5P8,106
-hypern-0.2.1.dist-info/licenses/LICENSE,sha256=VdbaK2hSaaD-LUjtDIlEbeZVmvLGK7BEQvltP3mv-cY,1304
+hypern-0.3.1.dist-info/METADATA,sha256=4Wi8nT7rpmfnz3LxOF1imQOsFLyOZIpz-YbmNkzy85I,3658
+hypern-0.3.1.dist-info/WHEEL,sha256=vLFuuz-EwE_uKz-SBQtX_C4ldZn2z-QIrwWEe3bn0JY,106
+hypern-0.3.1.dist-info/licenses/LICENSE,sha256=VdbaK2hSaaD-LUjtDIlEbeZVmvLGK7BEQvltP3mv-cY,1304
 hypern/worker.py,sha256=kN93QGx4bst0inHRO_fsTzMmhDA0N3pdzaqNXwyu3N0,894
 hypern/middleware/cors.py,sha256=SfG-3vAS-4MPXqsIsegNwDx9mqC9lvgUc3RuYzN6HNg,1643
+hypern/middleware/security.py,sha256=d_cfu58lUeVY7qk6O4GNvM1qIj64IO0Jd9DjcWB899s,7094
 hypern/middleware/__init__.py,sha256=YpgxL7GQkzZM91VCNxHT2xmTa1R1b_BUS8n3tZ2b1Ys,268
-hypern/middleware/limit.py,sha256=JNlZ2S5xlr3svt_rvr92ofh_zsVpe1uNuGc2jO5y3GY,7972
+hypern/middleware/limit.py,sha256=9EA79q2GgyZkRynMJj8rfgumEhJKbAvyi3jII6A_BX8,7976
 hypern/middleware/i18n.py,sha256=s82nQo6kKClZ0s3G3jsy87VRfwxpBDbASB_ErjRL3O0,15
 hypern/middleware/base.py,sha256=Llcg9wglcumvY4BqaTfrX1OOZDqns4wb34wGF55EXcI,523
 hypern/config.py,sha256=v9KLL6snReAETKiVb8x3KOFrXpYd8-Io5tM7eruR85U,4781
 hypern/response/__init__.py,sha256=9z99BDgASpG404GK8LGkOsXgac0wFwH_cQOTI5Ju-1U,223
 hypern/response/response.py,sha256=s6KqscjA7jl8RaZh5gZQgVksPtHKzsRrQywDcEjVSR4,4448
-hypern/reload.py,sha256=oRwDyxze69ERiVT41eJI_qpg6eJFDbIszGPVAoS5DHs,2233
+hypern/reload.py,sha256=Y2pjHHh8Zv0z-pRkBPLezKiowRblb1ZJ7yI_oE55D4U,1523
 hypern/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hypern/auth/authorization.py,sha256=b8N_MiBmSJBVR45SsOI2iMGmXYOlNKbsMsrMwXApxtk,30
 hypern/security.py,sha256=dOWdNHA8SoUhlbu6Z2MapOwT9tAhlsierrTBBiEV5-A,1729
@@ -21,9 +22,10 @@ hypern/cli/commands.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hypern/openapi/swagger.py,sha256=E5fHYUfFa77zQsCyQGf_vnqJVpl4_KI5qsKFHdgJEdw,61
 hypern/openapi/__init__.py,sha256=oJ0HM9yAgSN00mBC_fRgV2irlGugrhvIpiveuDMv8PM,136
 hypern/openapi/schemas.py,sha256=nmcmNYvKmjNkwFqi_3qpXVi1ukanNxMVay68bOLTrx8,1624
-hypern/application.py,sha256=DE9tQjkB4Pa6YQmmKJ7QwdaHDnhW3iw99zsyLJ0uFLI,13018
-hypern/hypern.pyi,sha256=eSqxlY7q6KboRjP3bpRlGSn2sEjxrIHFpxXh1o-qQJ4,6649
-hypern/processpool.py,sha256=Wrh_l87-3w4Z9znc6P22hi8kZfBA8cQ1C0Oaq8ysLVs,3657
+hypern/ws.py,sha256=XImBSYW2SM9s8wprnis8c2uRPhYxIXuDhwgRLLLDU38,378
+hypern/application.py,sha256=yXrKhVKwCQDweHoZPFyWr0ws7nmCOPp6H3aLZLbD7sw,13923
+hypern/hypern.pyi,sha256=u0hRm3xmoecGvxb8G3oCLGROa9NAJi_C16CypEKlmPk,7735
+hypern/processpool.py,sha256=mtP6qYSKTUgHOQEqtw6yhBvZ4JMAPw6uLxuyd-96CYI,3908
 hypern/db/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hypern/db/nosql/addons/color.py,sha256=8zUBFjR19J1zy_WaOCXlS14GjgdOaHAcuSb__zFp_II,430
 hypern/db/nosql/addons/unicode.py,sha256=vKyqfzrS9SKFo4eKlvu6klST0FrjM0wTx5N3ocvSSO8,258
@@ -47,13 +49,14 @@ hypern/exceptions.py,sha256=wpTSTzw32Sb6bY9YxCDM7W_-Ww6u6pB1GKNbFf-1oj0,2331
 hypern/scheduler.py,sha256=nQoWIYMRmKd30g4XwdB072hWTNHvJlLd9S6rLlTFKS0,62
 hypern/args_parser.py,sha256=kJQtzw2xZrumDBzLQaZyEejAT02rUetPYCrmOpjzxWY,1731
 hypern/routing/dispatcher.py,sha256=aujogCVTz2mYtZRkEtmpdlxXA9l6X4D072qOiIg-a_Q,2301
-hypern/routing/route.py,sha256=ribSMOo0eZ2WUZ1P8PdiXIsyVA3dHrI1gEYDikRDn4o,10090
+hypern/routing/route.py,sha256=AZc4Qo5iy74q0_U8E5X6RIsudznHZYEZR8MdHRoCmB4,10119
 hypern/routing/__init__.py,sha256=MtyPYRHYMWIiCReZsUjJH93PvluotCbPU3RnWFQQmrA,97
 hypern/routing/parser.py,sha256=4BFn8MAmSX1QplwBXEEgbabYiNUAllYf2svPZoPPD5k,3454
 hypern/routing/endpoint.py,sha256=AWLHLQNlSGR8IGU6xM0RP-1kP06OJQzqpbXKSiZEzEo,996
 hypern/enum.py,sha256=-StRU0cWboP-y5fNuhB4Q7yMk8Zm_h1Eua9KzOtIyI8,347
 hypern/datastructures.py,sha256=7Nb_fOxmfO8CT7_v_-RhmXg54IhioXGZSp405IzJLh4,857
 hypern/i18n/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hypern/caching/strategies.py,sha256=CNpcwN719ETqxzkWWX-tQvVb4j2xlGrI667QEca3mJM,4084
 hypern/caching/cache_manager.py,sha256=EBx89xNj38bYpQ9jf4MoQ3zNkfoCGYInxvvPtzsW5Xo,1997
 hypern/caching/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hypern/caching/cache_tag.py,sha256=DpkhFeKvcPT0zJlIWq5ywkYM8zRWGJ_grYIVZmHj-Js,257
@@ -64,5 +67,10 @@ hypern/caching/base/key_maker.py,sha256=FPW9L-N8NSPPgRngqMUCOdLurm1qmqe-KTe4Ucto
 hypern/caching/redis_backend.py,sha256=3FYzKCW0_OvoIMl-e9pARRGOUvRYGG7hGlaXEB18vnY,67
 hypern/logging/__init__.py,sha256=lzYSz0382eIM3CvP0sZ6RbEEwYZwfeJEJh9cxQA6Rws,49
 hypern/logging/logger.py,sha256=62Qg4YAi_JDGV72Rd6R58jixqZk7anRqHbtnuBlkrwA,3174
-hypern/hypern.cpython-310-darwin.so,sha256=1zAixAEVaZryZP5wgZ1jfK7VihvPeKZmCkDbGjtoTC4,6077672
-hypern-0.2.1.dist-info/RECORD,,
+hypern/ws/channel.py,sha256=TWaqowshz3WZRdg7ApBdFtVAlZW0OsVqoOHoFtXaZrk,3103
+hypern/ws/route.py,sha256=8YPTf1fsF46oCyqoXePC3mEbhjNVFDp8rqyWSsBHhBA,777
+hypern/ws/__init__.py,sha256=iUYERiHxs7HCmHj7CS5iG2XewKAJgW7w8kqxSORu_N8,127
+hypern/ws/heartbeat.py,sha256=PIrYWnQn8VxQjfDXDmtMymMl-wN5MQ_Q6oHfAjPWznU,2787
+hypern/ws/room.py,sha256=9u6gLq1WY4hn9_yEniavaY0yetFbQzgya_g6VPN-cgg,2522
+hypern/hypern.cpython-310-darwin.so,sha256=Of15SGptCispmduwQmqg9gO72q9HRAip0Mok8yaC-gc,6305320
+hypern-0.3.1.dist-info/RECORD,,

{hypern-0.2.1.dist-info → hypern-0.3.1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: maturin (1.7.4)
+Generator: maturin (1.7.8)
 Root-Is-Purelib: false
 Tag: cp310-cp310-macosx_10_12_x86_64