[pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

Author: pre-commit-ci[bot]

integration_tests/base_routes.py

@@ -7,7 +7,7 @@
 from typing import Optional
 
 from integration_tests.subroutes import di_subrouter, sub_router
-from robyn import Headers, Request, Response, Robyn, SSEMessage, SSEResponse, WebSocketConnector, WebSocketDisconnect, jsonify, serve_file, serve_html
+from robyn import Headers, Request, Response, Robyn, SSEMessage, SSEResponse, WebSocketDisconnect, jsonify, serve_file, serve_html
 from robyn.authentication import AuthenticationHandler, BearerGetter, Identity
 from robyn.robyn import QueryParams, Url
 from robyn.templating import JinjaTemplate
@@ -28,14 +28,14 @@
 @app.websocket("/web_socket")
 async def websocket_endpoint(websocket):
     await websocket.accept()
-    
+
     try:
         while True:
             msg = await websocket.receive_text()
             websocket_id = websocket._connector.id
             global websocket_state
             state = websocket_state[websocket_id]
-            
+
             if state == 0:
                 await websocket._connector.async_broadcast("This is a broadcast message")
                 await websocket.send_text("This is a message to self")
@@ -50,9 +50,9 @@ async def websocket_endpoint(websocket):
                 await websocket.send_text("Connection closed")
                 await websocket.close()
                 break
-                
+
             websocket_state[websocket_id] = (state + 1) % 4
-            
+
     except WebSocketDisconnect:
         pass
 
@@ -62,7 +62,7 @@ def websocket_on_connect(websocket):
     return "Hello world, from ws"
 
 
-@websocket_endpoint.on_close  
+@websocket_endpoint.on_close
 def websocket_on_close(websocket):
     return "GoodBye world, from ws"
 
@@ -71,25 +71,25 @@ def websocket_on_close(websocket):
 @app.websocket("/web_socket_json")
 async def json_websocket_endpoint(websocket):
     await websocket.accept()
-    
+
     try:
         while True:
             msg = await websocket.receive_text()
             websocket_id = websocket._connector.id
             response = {"ws_id": websocket_id, "resp": "", "msg": msg}
             global websocket_state
             state = websocket_state[websocket_id]
-            
+
             if state == 0:
                 response["resp"] = "Whaaat??"
             elif state == 1:
                 response["resp"] = "Whooo??"
             elif state == 2:
                 response["resp"] = "*chika* *chika* Slim Shady."
-                
+
             websocket_state[websocket_id] = (state + 1) % 3
             await websocket.send_json(response)
-            
+
     except WebSocketDisconnect:
         pass
 
@@ -108,13 +108,13 @@ def json_websocket_on_close(websocket):
 @app.websocket("/web_socket_di")
 async def di_websocket_endpoint(websocket):
     await websocket.accept()
-    
+
     try:
         while True:
             await websocket.receive_text()
             # Just echo back an empty response for DI test
             await websocket.send_text("")
-            
+
     except WebSocketDisconnect:
         pass
 

robyn/__init__.py

@@ -32,7 +32,7 @@
 
 class WebSocketDisconnect(Exception):
     """Exception raised when a WebSocket connection is disconnected."""
-    
+
     def __init__(self, code: int = 1000, reason: str = ""):
         self.code = code
         self.reason = reason
@@ -44,28 +44,28 @@ class WebSocketAdapter:
     Adapter class that provides a modern WebSocket interface
     wrapping Robyn's WebSocketConnector for compatibility.
     """
-    
+
     def __init__(self, websocket_connector: WebSocketConnector, message: str = None):
         self._connector = websocket_connector
         self._message = message
         self._accepted = False
-    
+
     async def accept(self):
         """Accept the WebSocket connection (no-op in Robyn as it's auto-accepted)"""
         self._accepted = True
-    
+
     async def close(self, code: int = 1000):
         """Close the WebSocket connection"""
         self._connector.close()
-    
+
     async def send_text(self, data: str):
         """Send text data to the WebSocket"""
         await self._connector.async_send_to(self._connector.id, data)
-    
+
     async def send_bytes(self, data: bytes):
         """Send binary data to the WebSocket"""
-        await self._connector.async_send_to(self._connector.id, data.decode('utf-8'))
-    
+        await self._connector.async_send_to(self._connector.id, data.decode("utf-8"))
+
     async def receive_text(self) -> str:
         """Receive text data from the WebSocket"""
         if self._message is not None:
@@ -75,42 +75,44 @@ async def receive_text(self) -> str:
         # Note: In a real implementation, this would need to handle the message queue
         # For now, we return the current message if available
         return ""
-    
+
     async def receive_bytes(self) -> bytes:
         """Receive binary data from the WebSocket"""
         text = await self.receive_text()
-        return text.encode('utf-8')
-    
+        return text.encode("utf-8")
+
     async def send_json(self, data):
         """Send JSON data to the WebSocket"""
         import json
+
         await self.send_text(json.dumps(data))
-    
+
     async def receive_json(self):
         """Receive JSON data from the WebSocket"""
         import json
+
         text = await self.receive_text()
         return json.loads(text) if text else None
-    
+
     @property
     def query_params(self):
         """Access query parameters"""
         return self._connector.query_params
-    
+
     @property
     def path_params(self):
         """Access path parameters"""
-        return getattr(self._connector, 'path_params', {})
-    
+        return getattr(self._connector, "path_params", {})
+
     @property
     def headers(self):
         """Access request headers"""
-        return getattr(self._connector, 'headers', {})
-    
+        return getattr(self._connector, "headers", {})
+
     @property
     def client(self):
         """Client information"""
-        return getattr(self._connector, 'client', None)
+        return getattr(self._connector, "client", None)
 
 
 def _normalize_endpoint(endpoint: str) -> str:
@@ -367,28 +369,29 @@ def websocket(self, endpoint: str):
         """
         Modern WebSocket decorator that accepts a single handler function.
         The handler function receives a WebSocket object and can optionally have on_connect and on_close callbacks.
-        
+
         Usage:
         @app.websocket("/ws")
         async def websocket_endpoint(websocket):
             await websocket.accept()
             while True:
                 data = await websocket.receive_text()
                 await websocket.send_text(f"Echo: {data}")
-        
+
         # With optional callbacks:
         @websocket_endpoint.on_connect
         async def on_connect(websocket):
             await websocket.send_text("Connected!")
-            
-        @websocket_endpoint.on_close  
+
+        @websocket_endpoint.on_close
         async def on_close(websocket):
             print("Disconnected")
         """
+
         def decorator(handler):
             # Dictionary to store handlers for this WebSocket endpoint
             handlers = {}
-            
+
             # Create the main message handler
             async def message_handler(websocket_connector, msg, *args, **kwargs):
                 # Convert WebSocketConnector to modern WebSocket interface
@@ -405,53 +408,53 @@ async def message_handler(websocket_connector, msg, *args, **kwargs):
                     if "connection closed" in str(e).lower() or "websocket" in str(e).lower():
                         return ""
                     raise e
-            
+
             # Create FunctionInfo for the message handler
             params = dict(inspect.signature(message_handler).parameters)
             num_params = len(params)
             is_async = asyncio.iscoroutinefunction(message_handler)
             injected_dependencies = self.dependencies.get_dependency_map(self)
-            
+
             handlers["message"] = FunctionInfo(message_handler, is_async, num_params, params, kwargs=injected_dependencies)
-            
+
             # Add methods to the handler to allow attaching on_connect and on_close
             def add_on_connect(connect_handler):
                 def connect_wrapper(websocket_connector, *args, **kwargs):
                     websocket_adapter = WebSocketAdapter(websocket_connector)
                     if asyncio.iscoroutinefunction(connect_handler):
                         return asyncio.create_task(connect_handler(websocket_adapter))
                     return connect_handler(websocket_adapter)
-                
+
                 # Create FunctionInfo for connect handler
                 connect_params = dict(inspect.signature(connect_wrapper).parameters)
                 connect_num_params = len(connect_params)
                 connect_is_async = asyncio.iscoroutinefunction(connect_wrapper)
                 handlers["connect"] = FunctionInfo(connect_wrapper, connect_is_async, connect_num_params, connect_params, kwargs=injected_dependencies)
                 return connect_handler
-            
+
             def add_on_close(close_handler):
                 def close_wrapper(websocket_connector, *args, **kwargs):
                     websocket_adapter = WebSocketAdapter(websocket_connector)
                     if asyncio.iscoroutinefunction(close_handler):
                         return asyncio.create_task(close_handler(websocket_adapter))
                     return close_handler(websocket_adapter)
-                
+
                 # Create FunctionInfo for close handler
                 close_params = dict(inspect.signature(close_wrapper).parameters)
                 close_num_params = len(close_params)
                 close_is_async = asyncio.iscoroutinefunction(close_wrapper)
                 handlers["close"] = FunctionInfo(close_wrapper, close_is_async, close_num_params, close_params, kwargs=injected_dependencies)
                 return close_handler
-            
+
             # Attach methods to the handler function
             handler.on_connect = add_on_connect
             handler.on_close = add_on_close
             handler._ws_handlers = handlers  # Store reference to handlers dict
-            
+
             # Add the WebSocket to the router
             self.add_web_socket(endpoint, handlers)
             return handler
-        
+
         return decorator
 
     def _add_event_handler(self, event_type: Events, handler: Callable) -> None:
@@ -859,15 +862,15 @@ def websocket(self, endpoint: str):
         """
         Modern WebSocket decorator for SubRouter that accepts a single handler function.
         Works the same as the main Robyn websocket decorator but with prefix support.
-        
+
         Usage:
         @subrouter.websocket("/ws")
         async def websocket_endpoint(websocket):
             await websocket.accept()
             while True:
                 data = await websocket.receive_text()
                 await websocket.send_text(f"Echo: {data}")
-        
+
         # With optional callbacks:
         @websocket_endpoint.on_connect
         async def on_connect(websocket):

websocket_example.py

@@ -7,11 +7,12 @@
 
 app = Robyn(__file__)
 
+
 # Define the main WebSocket handler
 @app.websocket("/ws")
 async def websocket_endpoint(websocket):
     await websocket.accept()
-    
+
     try:
         while True:
             data = await websocket.receive_text()
@@ -24,23 +25,28 @@ async def websocket_endpoint(websocket):
     except WebSocketDisconnect:
         print("Client disconnected")
 
+
 # Now you can add on_connect and on_close handlers to websocket_endpoint
 @websocket_endpoint.on_connect
 async def on_connect(websocket):
     await websocket.send_text("Welcome! You are now connected.")
     print("New client connected")
 
-@websocket_endpoint.on_close  
+
+@websocket_endpoint.on_close
 async def on_close(websocket):
     print("Client disconnected from WebSocket")
 
+
 # You can also add handlers programmatically:
 def another_connect_handler(websocket):
     print("Another connect handler called")
 
+
 # This would override the previous on_connect handler
 # websocket_endpoint.on_connect(another_connect_handler)
 
+
 @app.get("/")
 def index():
     return """
@@ -50,7 +56,8 @@ def index():
     <p>Send 'close' to disconnect</p>
     """
 
+
 if __name__ == "__main__":
     print("Starting WebSocket server...")
     print("Connect to: ws://localhost:8080/ws")
-    app.start(host="0.0.0.0", port=8080)
+    app.start(host="0.0.0.0", port=8080)