hypern 0.3.0__cp312-cp312-win32.whl → 0.3.1__cp312-cp312-win32.whl

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:
@@ -257,11 +260,16 @@ class WebsocketRouter:
 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
 
@@ -286,7 +294,7 @@ class BodyData:
 @dataclass
 class Request:
     query_params: QueryParams
-    headers: Dict[str, str]
+    headers: Header
     path_params: Dict[str, str]
     body: BodyData
     method: str

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/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/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-0.3.0.dist-info → hypern-0.3.1.dist-info}/METADATA

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

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

@@ -1,6 +1,6 @@
-hypern-0.3.0.dist-info/METADATA,sha256=aG7HYARcYTZed6140LAyzlcSeZ189_4OOZIT0bqiOxE,3754
-hypern-0.3.0.dist-info/WHEEL,sha256=llwl3fX8kOi_BiOUBLq5Qrnznqct4O7tJSEJsqg9n1c,92
-hypern-0.3.0.dist-info/licenses/LICENSE,sha256=qbYKAIJLS6jYg5hYncKE7OtWmqOtpVTvKNkwOa0Iwwg,1328
+hypern-0.3.1.dist-info/METADATA,sha256=dAKnEF83pJsKjgE50V8YZOD-_dTDlcrM3yc4Gtn5_IE,3754
+hypern-0.3.1.dist-info/WHEEL,sha256=SK_cql1gpDHx6aBV-LOSvGbTt4TUC8AJJOzjOP2tdpI,92
+hypern-0.3.1.dist-info/licenses/LICENSE,sha256=qbYKAIJLS6jYg5hYncKE7OtWmqOtpVTvKNkwOa0Iwwg,1328
 hypern/application.py,sha256=D8tye5rpOJzHGQHUelaDpjUL3B9xO40B7xAL9wC3Uno,14328
 hypern/args_parser.py,sha256=Crxzr8_uhiIk_AWJvuwJTEfRqEBqU_GfTbg6chg_YiY,1790
 hypern/auth/authorization.py,sha256=-NprZsI0np889ZN1fp-MiVFrPoMNzUtatBJaCMtkllM,32
@@ -13,6 +13,7 @@ hypern/caching/cache_manager.py,sha256=TF6UosJ54950JgsrPVZUS3MH2R8zafAu5PTryNJ0s
 hypern/caching/cache_tag.py,sha256=bZcjivMNETAzAHAIobuLN0S2wHgPgLLL8Gg4uso_qbk,267
 hypern/caching/custom_key_maker.py,sha256=88RIIJjpQYFnv857wOlCKgWWBbK_S23zNHsIrJz_4PY,394
 hypern/caching/redis_backend.py,sha256=IgQToCnHYGpKEErq2CNZkR5woo01z456Ef3C-XRPRV8,70
+hypern/caching/strategies.py,sha256=S7qJiJOTJrk6KUFDrmjGkHP3XV8mYTRM3Sd4pA4UQKA,4199
 hypern/caching/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hypern/cli/commands.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hypern/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -38,7 +39,7 @@ hypern/db/sql/__init__.py,sha256=1UoWQi2CIcUAbQj3FadR-8V0o_b286nI2wYvOsvtbFc,647
 hypern/db/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hypern/enum.py,sha256=KcVziJj7vWvyie0r2rtxhrLzdtkZAsf0DY58oJ4tQl4,360
 hypern/exceptions.py,sha256=nHTkF0YdNBMKfSiNtjRMHMNKoY3RMUm68YYluuW15us,2428
-hypern/hypern.pyi,sha256=b5Zjr9ipm43rI8eSUV4WYmKpIJWUsv6O2TrpvvbeTlE,7700
+hypern/hypern.pyi,sha256=DhTRcW9c0qjVS976fx__insErvhk4k7W0NKcV6iZGxw,8038
 hypern/i18n/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hypern/logging/logger.py,sha256=WACam_IJiCMXX0hGVKMGSxUQpY4DgAXy7M1dD3q-Z9s,3256
 hypern/logging/__init__.py,sha256=6eVriyncsJ4J73fGYhoejv9MX7aGTkRezTpPxO4DX1I,52
@@ -46,13 +47,14 @@ hypern/middleware/base.py,sha256=mJoz-i-7lqw1eDxZ8Bb0t8sz60lx5TE-OjZT4UR75e4,541
 hypern/middleware/cors.py,sha256=x90DnCOJSfp4ojm1krttn_EdtlqeDazyUzVg66NES4A,1681
 hypern/middleware/i18n.py,sha256=jHzVzjTx1nnjbraZtIVOprrnSaeKMxZB8RuSqRp2I4s,16
 hypern/middleware/limit.py,sha256=8hzUxu_mxra2QiDjAghgZtvwN6Dx07irPUiL12dbVhY,8152
+hypern/middleware/security.py,sha256=hIbmP1fkZ_KgxK1Wx7s9xdNH7M174mo6ySASiuzMz_A,7273
 hypern/middleware/__init__.py,sha256=lXwR3fdmpVK4Z7QWaLsgf3Sazy5NPPFXIOxIEv1xDC8,273
 hypern/openapi/schemas.py,sha256=YHfMlPUeP5DzDX5ao3YH8p_25Vvyaf616dh6XDCUZRc,1677
 hypern/openapi/swagger.py,sha256=naqUY3rFAEYA1ZLIlmDsMYaol0yIm6TVebdkFa5cMTc,64
 hypern/openapi/__init__.py,sha256=4rEVD8pa0kdSpsy7ZkJ5JY0Z2XF0NGSKDMwYAd7YZpE,141
 hypern/processpool.py,sha256=YW7Dg33Hla9D33x3Mf8xsjaTprHaovkLPK-4XnQKiGU,4045
 hypern/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hypern/reload.py,sha256=d28xP7MWiO2vL6RAAlIqSh8q7_ugsRBN66Mlbz3UWEI,2293
+hypern/reload.py,sha256=nfaZCoChrQetHNtIqN4Xzi-a0v-irxSCMhwCK3bCEq0,1569
 hypern/response/response.py,sha256=-dnboAraPic8asf503PxwmDuxhNllUO5h97_DGmbER4,4582
 hypern/response/__init__.py,sha256=_w3u3TDNuYx5ejnnN1unqnTY8NlBgUATQi6wepEB_FQ,226
 hypern/routing/dispatcher.py,sha256=i2wLAAW1ZXgpi5K2heGXhTODnP1WdQzaR5WlUjs1o9c,2368
@@ -63,7 +65,12 @@ hypern/routing/__init__.py,sha256=7rw7EAxougCXtmkgJjrmLP3N5RXctIpI_3JmG9FcKVU,10
 hypern/scheduler.py,sha256=-k3tW2AGCnHYSthKXk-FOs_SCtWp3yIxQzwzUJMJsbo,67
 hypern/security.py,sha256=3E86Yp_eOSVa1emUvBrDgoF0Sn6eNX0CfLnt87w5CPI,1773
 hypern/worker.py,sha256=WQrhY_awR6zjMwY4Q7izXi4E4fFrDqt7jIblUW8Bzcg,924
+hypern/ws/channel.py,sha256=0ns2qmeoFJOpGLXS_hqldhywDQm_DxHwj6KloQx4Q3I,3183
+hypern/ws/heartbeat.py,sha256=sWMXzQm6cbDHHA2NHc-gFjv7G_E56XtxswHQ93_BueM,2861
+hypern/ws/room.py,sha256=0_L6Nun0n007F0rfNY8yX5x_A8EuXuI67JqpMkJ4RNI,2598
+hypern/ws/route.py,sha256=fGQ2RC708MPOiiIHPUo8aZ-oK379TTAyQYm4htNA5jM,803
+hypern/ws/__init__.py,sha256=dhRoRY683_rfPfSPM5qUczfTuyYDeuLOCFxY4hIdKt8,131
 hypern/ws.py,sha256=F6SA2Z1KVnqTEX8ssvOXqCtudUS4eo30JsiIsvfbHnE,394
 hypern/__init__.py,sha256=9Ww_aUQ0vJls0tOq7Yw1_TVOCRsa5bHJ-RtnSeComwk,119
-hypern/hypern.cp312-win32.pyd,sha256=Ufztl71auGJOE_0x63ZldXhd94YTxB_52KhlaaEODG4,5471744
-hypern-0.3.0.dist-info/RECORD,,
+hypern/hypern.cp312-win32.pyd,sha256=GClLmHIIv0CKb5uHz_ochUZKY_1wketwqHGB9TUdRPg,5482496
+hypern-0.3.1.dist-info/RECORD,,

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

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: maturin (1.7.7)
+Generator: maturin (1.7.8)
 Root-Is-Purelib: false
 Tag: cp312-cp312-win32