hypern 0.3.11__cp312-cp312-musllinux_1_2_armv7l.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.11.dist-info/METADATA

@@ -0,0 +1,134 @@
+Metadata-Version: 2.4
+Name: hypern
+Version: 0.3.11
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Dist: sqlalchemy[asyncio] ==2.0.31
+Requires-Dist: pyjwt ==2.8.0
+Requires-Dist: pydash ==8.0.3
+Requires-Dist: sentry-sdk ==2.11.0
+Requires-Dist: celery ==5.4.0
+Requires-Dist: psycopg ==3.2.3
+Requires-Dist: pyyaml ==6.0.2
+Requires-Dist: orjson ==3.10.11
+Requires-Dist: multiprocess ==0.70.17
+Requires-Dist: uvloop ==0.21.0 ; sys_platform != 'win32' and platform_python_implementation == 'CPython' and platform_machine != 'armv7l'
+Requires-Dist: watchdog ==6.0.0
+Requires-Dist: psutil ==6.1.0
+Requires-Dist: msgpack ==1.1.0
+Requires-Dist: redis ==5.2.1
+Requires-Dist: pydantic ==2.10.4
+License-File: LICENSE
+Summary: A Fast Async Python backend with a Rust runtime.
+Author-email: Martin Dang <vannghiem848@gmail.com>
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+
+
+# Hypern
+
+Hypern: A Versatile Python and Rust Framework
+
+Hypern is a flexible, open-source framework built on the [Rust](https://github.com/rust-lang/rust), designed to jumpstart your high-performance web development endeavors. By providing a pre-configured structure and essential components, Hypern empowers you to rapidly develop custom web applications that leverage the combined power of Python and Rust.
+
+With Hypern, you can seamlessly integrate asynchronous features and build scalable solutions for RESTful APIs and dynamic web applications. Its intuitive design and robust tooling allow developers to focus on creating high-quality code while maximizing performance. Embrace the synergy of Python and Rust to elevate your web development experience.
+
+
+### 🏁 Get started
+
+### ⚙️ To Develop Locally
+
+- Setup a virtual environment:
+```
+python3 -m venv venv
+source venv/bin/activate
+```
+- Install required packages
+
+```
+pip install pre-commit poetry maturin
+```
+- Install development dependencies
+```
+poetry install --with dev --with test
+```
+- Install pre-commit git hooks
+```
+pre-commit install
+```
+- Build & install Rust package
+```
+maturin develop
+```
+
+## 🤔 Usage
+
+### 🏃 Run your code
+
+You will then have access to a server on the `localhost:5005`,
+```python
+# main.py
+from hypern import Hypern
+from hypern.routing import Route, HTTPEndpoint
+
+class MyEndpoint(HTTPEndpoint):
+    
+    async def get(self, request):
+        return {"data": "Hello World"}
+
+routing = [
+    Route("/hello", MyEndpoint)
+]
+
+app = Hypern(routing)
+
+if __name__ == "__main__":
+    app.start()
+```
+
+```
+$ python3 main.py
+```
+You can open swagger UI at path `/docs` 
+
+## CLI
+
+    - host (str): The host address to bind to. Defaults to '127.0.0.1'.
+    - port (int): The port number to bind to. Defaults to 5000.
+    - processes (int): The number of processes to use. Defaults to 1.
+    - workers (int): The number of worker threads to use. Defaults to 1.
+    - max_blocking_threads (int): The maximum number of blocking threads. Defaults to 32.
+    - reload (bool): If True, the server will restart on file changes.
+    - auto_workers (bool): If True, sets the number of workers and max-blocking-threads automatically.
+
+
+## 💡 Features
+
+### ⚡ High Performance
+- Rust-powered core with Python flexibility
+- Multi-process architecture for optimal CPU utilization
+- Async/await support for non-blocking operations
+- Built on top of production-ready Rust language
+
+### 🛠 Development Experience
+- Type hints and IDE support
+- Built-in Swagger/OpenAPI documentation
+- Hot reload during development
+- Comprehensive error handling and logging
+
+### 🔌 Integration & Extensions
+- Easy dependency injection
+- Middleware support (before/after request hooks)
+- WebSocket support
+- Background task scheduling
+- File upload handling
+
+### 🔒 Security
+- Built-in authentication/authorization (Comming soon)
+- CORS configuration
+- Rate limiting
+- Request validation
+
+
+

hypern-0.3.11.dist-info/RECORD

@@ -0,0 +1,74 @@
+hypern-0.3.11.dist-info/METADATA,sha256=ITw8gsjB2mG8_N0MV--ZF2Fi2pVeFCzAZBGCR0cK80o,4007
+hypern-0.3.11.dist-info/WHEEL,sha256=ZpVFxu0p_HmuO1LnhwVR1IZeNyd7_l7MNT8RKZkkpkk,107
+hypern-0.3.11.dist-info/licenses/LICENSE,sha256=VdbaK2hSaaD-LUjtDIlEbeZVmvLGK7BEQvltP3mv-cY,1304
+hypern.libs/libgcc_s-5b5488a6.so.1,sha256=HGKUsVmTeNAxEdSy7Ua5Vh_I9FN3RCbPWzvZ7H_TrwE,2749061
+hypern/args_parser.py,sha256=hRlZe6VOZUutynVPXzCS8Mpn_Qp36MDDV0hFLNjM5YM,2149
+hypern/gateway/aggregator.py,sha256=Z4LnsDlVDtlPlhsSKu8jCD0UsbztXOLu6UAVtkgJwQk,1100
+hypern/gateway/gateway.py,sha256=rAZrS9db55tQGUfEfVNIKw6EetBdHAcSXyrC7rLfCZ8,1434
+hypern/gateway/service.py,sha256=kxKTBZN0ZjuNEp8uwFldQWql-g1q1AECXUjKZsICdLg,1649
+hypern/gateway/__init__.py,sha256=4wyCK49W_sTBCh0hkTdEli6kdRUFu9UBxncV6EXBxwA,229
+hypern/gateway/proxy.py,sha256=cgMFJ6znUMWRDgPgnRz7HmPT6UUY6Z09-8HAxkCWGgk,2403
+hypern/auth/authorization.py,sha256=b8N_MiBmSJBVR45SsOI2iMGmXYOlNKbsMsrMwXApxtk,30
+hypern/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hypern/middleware/limit.py,sha256=oWNt-XqYdORJuJMgg8pLYoEpHVm1cZBOPatxk8g7Nao,8075
+hypern/middleware/__init__.py,sha256=sPmefKAy8-XeSg6BhkZBjqV8zgreeNLxikyyM6aDFT8,476
+hypern/middleware/base.py,sha256=IXmEe7x_X5YykBsxTpko6ApsvNmVqfZ7IHBgJSSEWnY,356
+hypern/middleware/compress.py,sha256=2eyxkYMgmsL6klbcTqr7WK0rFTo0grU0ZKQF15pVUBI,3041
+hypern/middleware/cache.py,sha256=b4hRh1smFwhJE789hZ0p4TlkQ8ZjYR-7fXg9rI7uvbc,7406
+hypern/middleware/i18n.py,sha256=s82nQo6kKClZ0s3G3jsy87VRfwxpBDbASB_ErjRL3O0,15
+hypern/middleware/cors.py,sha256=q8Ts_znqApdUJYSJyLlRIbYKxxTQy6WNnJD6Kqbl32I,1759
+hypern/middleware/security.py,sha256=hPYsilqhF9mRCX7DzOQw4AKh0y5k5FL0cM_zQdb9tiA,7491
+hypern/openapi/schemas.py,sha256=Hg8G4aPZ1xXJTKFWhx8BgwRsDt2yw-v0N6LVjJ_qBHU,1547
+hypern/openapi/__init__.py,sha256=oJ0HM9yAgSN00mBC_fRgV2irlGugrhvIpiveuDMv8PM,136
+hypern/openapi/swagger.py,sha256=E5fHYUfFa77zQsCyQGf_vnqJVpl4_KI5qsKFHdgJEdw,61
+hypern/hypern.pyi,sha256=GSVs2lNIlIU6k8KL2VNOBO8jafEEqzmsmJF6PHNtwAA,8718
+hypern/routing/dispatcher.py,sha256=8_JuxyyOMiCqY3WsqcjSzUTpYjIGbvzGtI8j9T-fIkA,2391
+hypern/routing/route.py,sha256=juK0eOjmTv1iYYhw3zyLt3uHCB3pT6au64tVcXqCEDc,9976
+hypern/routing/parser.py,sha256=VYdQtf9TPe-NSx3J2wCfOZIh1S-iFLf0jdqrY9UPVMQ,3328
+hypern/routing/__init__.py,sha256=FvmUQlSraZ91q9AFGkgj3ELIep1jiKZLBCDrXIVf5DI,157
+hypern/routing/queue.py,sha256=Yus-49N4xc7O5S3YYxqL0muFLypu_Zgd0u2SADFh-Uk,7001
+hypern/routing/endpoint.py,sha256=AWLHLQNlSGR8IGU6xM0RP-1kP06OJQzqpbXKSiZEzEo,996
+hypern/response/response.py,sha256=_UbLlzEfDZvXKHDKOdXFdus-CJXgoNFPmV259cjQz2Q,4729
+hypern/response/__init__.py,sha256=9z99BDgASpG404GK8LGkOsXgac0wFwH_cQOTI5Ju-1U,223
+hypern/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hypern/cli/commands.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hypern/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hypern/datastructures.py,sha256=SqqYX0iwA0U7R42bYerUjL-gjaA4mu-RwrvVT9biELg,842
+hypern/worker.py,sha256=_m0NV-Srn4NGi65UciOOg3t4Bk6wGm0PMG4_1EYi6Zk,9487
+hypern/__init__.py,sha256=IxXU3ev_2KFfceMvBlJBgHeF5_YGYoiDotWJOAiYjh4,615
+hypern/reload.py,sha256=Y2pjHHh8Zv0z-pRkBPLezKiowRblb1ZJ7yI_oE55D4U,1523
+hypern/background.py,sha256=fN38UlJG6wZf1gOGcvdY-INoD8zJKvGZZOdVYTMjDwg,120
+hypern/processpool.py,sha256=7DSUMKy0IL6D3822W-XseH6oAU2MCmb-wKRt_80RuZE,3744
+hypern/caching/__init__.py,sha256=I7X3bmdEHeHs80kjAI1s0mMlVD7RKmw9I-QupaTAIWo,346
+hypern/caching/backend.py,sha256=Tj66YSepGUvpXrwC04gSdJzs45IepHA2hNlMtnRVB6c,798
+hypern/caching/redis_backend.py,sha256=nRkAq07B248iFljn9TxE4tadYUeM8RqqERZWzEpfk7E,5767
+hypern/caching/strategies.py,sha256=VU0FpYmIK6rEjjJSwRXPrprYdo0d2u1s9OxB3OAvs3g,7080
+hypern/i18n/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hypern/config.py,sha256=Ksn2LnHU0yhtGUjnac9bNjqtxl7IcPKmMdbDfZYm7Jo,7911
+hypern/application.py,sha256=8dnaBB5zn5H-AccPHO38EWPMun1M3eRyxdF6zXFi1mg,17573
+hypern/database/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hypern/database/sqlx/field.py,sha256=C7vxo6VvCeOWxG3-GFrwe23xC4AiZ3fGqOzZTDbkC8c,8875
+hypern/database/sqlx/model.py,sha256=5liN9IP6cKZhW2SZqQE5ynFNCPVkGL9_xoyPu5PAyjQ,3927
+hypern/database/sqlx/__init__.py,sha256=1GJLdJfh1Dgy6o1tyl6Aus431rhrX4shhE53M9FLQl0,609
+hypern/database/sqlx/query.py,sha256=_SRoXXXdVZ_kRLcvrYCtxmIbpb1GE3BpBg4rseHhctc,32442
+hypern/database/sqlx/migrate.py,sha256=gHoZFUPop7OGp_cVic8pKiVnnV1-j2oUAJ9lXVfBBAA,9479
+hypern/database/sqlalchemy/__init__.py,sha256=U_9q6L3V7VIRN-neeN5mVb1z6wKf7_GjWptgUl8-xxI,150
+hypern/database/sqlalchemy/repository.py,sha256=YShEl1DqRXtYwNnn1F3YVfXX-TEdoNRjDEWIO_3Lu2s,9226
+hypern/database/sqlalchemy/config.py,sha256=AyeDJnWtq42NFLX65T0w04yhX7l9x8t6lXFq8U4WgfE,2580
+hypern/enum.py,sha256=-StRU0cWboP-y5fNuhB4Q7yMk8Zm_h1Eua9KzOtIyI8,347
+hypern/exceptions/common.py,sha256=p9cx3PC6Azn0WAz7jCH02DEoLRLCCvKqNrL-dGhMGSQ,215
+hypern/exceptions/formatters.py,sha256=51krRQIUq3uvwvcQm81mYPifdp2r2ckwC98pXI5v_P8,2330
+hypern/exceptions/__init__.py,sha256=t4GhxGHjOPgPQ34f0MycMjoRGw5u3TRb3OcTDYc4Orw,936
+hypern/exceptions/errors.py,sha256=mt6ZXUGHFZ_FfyP7sZFj4XT6amb5G-1Fa_26rH7BSWc,842
+hypern/exceptions/http.py,sha256=N98kHaQtH4x9EW6Gavrcr-Ll_-HDvsDSaRAX1sNuN4A,3150
+hypern/exceptions/base.py,sha256=_tt42Tuy_7oXR-THhJ00lZFsCJMKWbArJyTlF-kcgH4,1955
+hypern/logging/__init__.py,sha256=lzYSz0382eIM3CvP0sZ6RbEEwYZwfeJEJh9cxQA6Rws,49
+hypern/logging/logger.py,sha256=62Qg4YAi_JDGV72Rd6R58jixqZk7anRqHbtnuBlkrwA,3174
+hypern/scheduler.py,sha256=nQoWIYMRmKd30g4XwdB072hWTNHvJlLd9S6rLlTFKS0,62
+hypern/ws/channel.py,sha256=TWaqowshz3WZRdg7ApBdFtVAlZW0OsVqoOHoFtXaZrk,3103
+hypern/ws/room.py,sha256=9u6gLq1WY4hn9_yEniavaY0yetFbQzgya_g6VPN-cgg,2522
+hypern/ws/heartbeat.py,sha256=PIrYWnQn8VxQjfDXDmtMymMl-wN5MQ_Q6oHfAjPWznU,2787
+hypern/ws/route.py,sha256=8YPTf1fsF46oCyqoXePC3mEbhjNVFDp8rqyWSsBHhBA,777
+hypern/ws/__init__.py,sha256=iUYERiHxs7HCmHj7CS5iG2XewKAJgW7w8kqxSORu_N8,127
+hypern/hypern.cpython-312-arm-linux-musleabihf.so,sha256=bTB2Da5txb67o96fDDRdFgudGlyv-hyFGczu5d38TGw,9244653
+hypern-0.3.11.dist-info/RECORD,,

hypern-0.3.11.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.8.1)
+Root-Is-Purelib: false
+Tag: cp312-cp312-musllinux_1_2_armv7l

hypern-0.3.11.dist-info/licenses/LICENSE

@@ -0,0 +1,24 @@
+BSD 2-Clause License
+
+Copyright (c) 2024, Dang Van Nghiem
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.