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

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.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypern
-Version: 0.3.0
+Version: 0.3.2
 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.2.dist-info}/RECORD

@@ -1,19 +1,15 @@
-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/application.py,sha256=D8tye5rpOJzHGQHUelaDpjUL3B9xO40B7xAL9wC3Uno,14328
-hypern/args_parser.py,sha256=Crxzr8_uhiIk_AWJvuwJTEfRqEBqU_GfTbg6chg_YiY,1790
+hypern-0.3.2.dist-info/METADATA,sha256=xbMB8V67yK1aLvRGbYrsjqoScFdSOZXs97zXg0yVVQ4,3754
+hypern-0.3.2.dist-info/WHEEL,sha256=SK_cql1gpDHx6aBV-LOSvGbTt4TUC8AJJOzjOP2tdpI,92
+hypern-0.3.2.dist-info/licenses/LICENSE,sha256=qbYKAIJLS6jYg5hYncKE7OtWmqOtpVTvKNkwOa0Iwwg,1328
+hypern/application.py,sha256=yNlohWdSG0lpKfuTVX7N9gI3cmXl3IoEvP8WLH-yAiE,16251
+hypern/args_parser.py,sha256=diz3Oq1PDNMBlG7ElqK01iokY5w_X3U1Ky1jikPVXRg,2020
 hypern/auth/authorization.py,sha256=-NprZsI0np889ZN1fp-MiVFrPoMNzUtatBJaCMtkllM,32
 hypern/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hypern/background.py,sha256=xy38nQZSJsYFRXr3-uFJeNW9E1GiXXOC7lSe5pC0eyE,124
-hypern/caching/base/backend.py,sha256=nHl5_nH95LSYWBS9RmOvOzsps_p19HcnQsb4h4W7cP8,68
-hypern/caching/base/key_maker.py,sha256=-W1r3ywfQ-K6saniiK3aTMaW3iy3aXai2pvQqM8f74I,232
-hypern/caching/base/__init__.py,sha256=M-B56YGTkSwCkKW_I6GcV1LSIFfxZ6KuXowB1_aJQpQ,155
-hypern/caching/cache_manager.py,sha256=TF6UosJ54950JgsrPVZUS3MH2R8zafAu5PTryNJ0sRs,2053
-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/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hypern/caching/backend.py,sha256=bfSEgJQxS3FDdj08CY4V9b9U3rwf4uy9gS46QmwA3Zc,829
+hypern/caching/redis_backend.py,sha256=SWYlJvr8qi2kS_grhxhqQBLEEATpFremT2XyXkio8h0,5968
+hypern/caching/strategies.py,sha256=qQjqgZLUX7KZjhwPD4SYUaMRewgCgsp6qa1FunK3Y0I,7288
+hypern/caching/__init__.py,sha256=ODO7zMm4iFG8wcvrhKmukryG5wOTW0DnzFvNMfF57Cc,352
 hypern/cli/commands.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hypern/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hypern/config.py,sha256=frZSdXBI8GaM0tkw1Rs-XydZ9-XjGLRPj6DL4d51-y4,4930
@@ -38,32 +34,46 @@ 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/gateway/aggregator.py,sha256=N1onAp9gdzpCR-E5VubkVoUjjEmVNxG8gDZx9rhnbXc,1132
+hypern/gateway/gateway.py,sha256=26K2qvJUR-0JnN4IlhwvSSt7EYcpYrBVDuzZ1ivQQ34,1475
+hypern/gateway/proxy.py,sha256=w1wcTplDnVrfjn7hb0M0yBVth5TGl88irF-MUYHysQQ,2463
+hypern/gateway/service.py,sha256=PkRaM08olqM_j_4wRjEJCR8X8ZysAF2WOcfhWjaX2eo,1701
+hypern/gateway/__init__.py,sha256=TpFWtqnJerW1-jCWq5fjypJcw9Y6ytyrkvkzby1Eg0E,235
+hypern/hypern.pyi,sha256=GiUjtY6tbV8d6KI1PDTTZK5zWyOD4hooahALnFd7Fl4,8197
 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
-hypern/middleware/base.py,sha256=mJoz-i-7lqw1eDxZ8Bb0t8sz60lx5TE-OjZT4UR75e4,541
-hypern/middleware/cors.py,sha256=x90DnCOJSfp4ojm1krttn_EdtlqeDazyUzVg66NES4A,1681
+hypern/middleware/base.py,sha256=3G7vxFXr0tDp28Bz3NeM76eo03qYGppm07N3yWoA_4U,369
+hypern/middleware/cache.py,sha256=HFfghpnhS21DOsXLn6nt-TgRLCNNm6ZqTKPMgoXM0Mw,7583
+hypern/middleware/compress.py,sha256=Zph3pQz15YrYB4dMUMbQnfWIFY8ovysgPMepbY_WV9k,3119
+hypern/middleware/cors.py,sha256=pt5HyTd3J5L9Lvczo2xI8fxLmtntSbJq-CPU0vYXoAI,1800
 hypern/middleware/i18n.py,sha256=jHzVzjTx1nnjbraZtIVOprrnSaeKMxZB8RuSqRp2I4s,16
-hypern/middleware/limit.py,sha256=8hzUxu_mxra2QiDjAghgZtvwN6Dx07irPUiL12dbVhY,8152
-hypern/middleware/__init__.py,sha256=lXwR3fdmpVK4Z7QWaLsgf3Sazy5NPPFXIOxIEv1xDC8,273
+hypern/middleware/limit.py,sha256=eAYARPjqxq8Ue0TCpnxlVRB5hv7hwBF0PxeD-bG6Sl0,8252
+hypern/middleware/security.py,sha256=d9Qf2UNMN8wz-MLnG2wRb0Vgf55_IGZAje5hbc2T_HQ,7539
+hypern/middleware/__init__.py,sha256=V-Gnv-Jf-14BVuA28z7PN7GBVQ9BBiBdab6-QnTPCfY,493
 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/processpool.py,sha256=l6_PKRMFQ4GIMPLTMOEbIwWDsxER0NIj_wdxVWqA7zA,5042
 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
 hypern/routing/endpoint.py,sha256=RKVhvqOEGL9IKBXQ3KJgPi9bgJj9gfWC5BdZc5U_atc,1026
 hypern/routing/parser.py,sha256=R-4lcN9Ha1iMeAjlqDe8HwkjjMVG-c-ubQLZyWKXj6M,3554
+hypern/routing/queue.py,sha256=NtFBbogU22ddyyX-CuQMip1XFDPZdMCVMIeUCQ-CR6Y,7176
 hypern/routing/route.py,sha256=IUnWU5ra-0R9rrRDpxJiwiw7vaEefn-We2dZ4EocJGw,10403
-hypern/routing/__init__.py,sha256=7rw7EAxougCXtmkgJjrmLP3N5RXctIpI_3JmG9FcKVU,101
+hypern/routing/__init__.py,sha256=U4xW5fDRsn03z4cVLT4dJHHGGU6SVxyv2DL86LXodeE,162
 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=JxNOpTLC3EaBfc6d3TLY05BbTHHx5ciyj3wSbOKbWIM,6539264
+hypern-0.3.2.dist-info/RECORD,,

{hypern-0.3.0.dist-info → hypern-0.3.2.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

hypern/caching/base/__init__.py

@@ -1,8 +0,0 @@
-# -*- coding: utf-8 -*-
-from .backend import BaseBackend
-from .key_maker import BaseKeyMaker
-
-__all__ = [
-    "BaseKeyMaker",
-    "BaseBackend",
-]

hypern/caching/base/backend.py

@@ -1,3 +0,0 @@
-from hypern.hypern import BaseBackend
-
-__all__ = ["BaseBackend"]

hypern/caching/base/key_maker.py

@@ -1,8 +0,0 @@
-# -*- coding: utf-8 -*-
-from abc import ABC, abstractmethod
-from typing import Callable
-
-
-class BaseKeyMaker(ABC):
-    @abstractmethod
-    async def make(self, function: Callable, prefix: str, identify_key: str) -> str: ...

hypern/caching/cache_manager.py

@@ -1,56 +0,0 @@
-# -*- coding: utf-8 -*-
-from functools import wraps
-from typing import Callable, Dict, Type
-
-from .base import BaseBackend, BaseKeyMaker
-from .cache_tag import CacheTag
-import orjson
-
-
-class CacheManager:
-    def __init__(self):
-        self.backend = None
-        self.key_maker = None
-
-    def init(self, backend: BaseBackend, key_maker: BaseKeyMaker) -> None:
-        self.backend = backend
-        self.key_maker = key_maker
-
-    def cached(self, tag: CacheTag, ttl: int = 60, identify: Dict = {}) -> Type[Callable]:
-        def _cached(function):
-            @wraps(function)
-            async def __cached(*args, **kwargs):
-                if not self.backend or not self.key_maker:
-                    raise ValueError("Backend or KeyMaker not initialized")
-
-                _identify_key = []
-                for key, values in identify.items():
-                    _obj = kwargs.get(key, None)
-                    if not _obj:
-                        raise ValueError(f"Caching: Identify key {key} not found in kwargs")
-                    for attr in values:
-                        _identify_key.append(f"{attr}={getattr(_obj, attr)}")
-                _identify_key = ":".join(_identify_key)
-
-                key = await self.key_maker.make(function=function, prefix=tag.value, identify_key=_identify_key)
-
-                cached_response = self.backend.get(key=key)
-                if cached_response:
-                    return orjson.loads(cached_response)
-
-                response = await function(*args, **kwargs)
-                self.backend.set(response=orjson.dumps(response).decode("utf-8"), key=key, ttl=ttl)
-                return response
-
-            return __cached
-
-        return _cached  # type: ignore
-
-    async def remove_by_tag(self, tag: CacheTag) -> None:
-        await self.backend.delete_startswith(value=tag.value)
-
-    async def remove_by_prefix(self, prefix: str) -> None:
-        await self.backend.delete_startswith(value=prefix)
-
-
-Cache = CacheManager()

hypern/caching/cache_tag.py

@@ -1,10 +0,0 @@
-# -*- coding: utf-8 -*-
-from enum import Enum
-
-
-class CacheTag(Enum):
-    GET_HEALTH_CHECK = "get_health_check"
-    GET_USER_INFO = "get_user_info"
-    GET_CATEGORIES = "get_categories"
-    GET_HISTORY = "get_chat_history"
-    GET_QUESTION = "get_question"

hypern/caching/custom_key_maker.py

@@ -1,11 +0,0 @@
-# -*- coding: utf-8 -*-
-from typing import Callable
-import inspect
-
-from hypern.caching.base import BaseKeyMaker
-
-
-class CustomKeyMaker(BaseKeyMaker):
-    async def make(self, function: Callable, prefix: str, identify_key: str = "") -> str:
-        path = f"{prefix}:{inspect.getmodule(function).__name__}.{function.__name__}:{identify_key}"  # type: ignore
-        return str(path)