[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.id
             global websocket_state
             state = websocket_state[websocket_id]
-            
+
             if state == 0:
                 await websocket.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.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

@@ -30,8 +30,6 @@
 __version__ = get_version()
 
 
-
-
 def _normalize_endpoint(endpoint: str) -> str:
     """
     Normalize an endpoint to ensure consistent routing.
@@ -286,21 +284,21 @@ 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")
         """
@@ -711,15 +709,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):

robyn/ws.py

@@ -15,7 +15,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
@@ -27,28 +27,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:
@@ -58,47 +58,49 @@ 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
-    
+
     async def broadcast(self, data: str):
         """Broadcast data to all connected WebSocket clients"""
         await self._connector.async_broadcast(data)
-    
+
     @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)
+
     @property
     def id(self):
         """WebSocket connection ID"""
@@ -110,32 +112,34 @@ def create_websocket_decorator(app_instance):
     Factory function to create a websocket decorator for an app instance.
     This allows access to the app's dependencies and web_socket_router.
     """
+
     def websocket(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
@@ -152,78 +156,78 @@ 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 = app_instance.dependencies.get_dependency_map(app_instance)
-            
+
             # Filter dependencies to only include reserved parameters that exist in handler
             filtered_dependencies = {}
             if "global_dependencies" in params:
                 filtered_dependencies["global_dependencies"] = injected_dependencies.get("global_dependencies", {})
             if "router_dependencies" in params:
                 filtered_dependencies["router_dependencies"] = injected_dependencies.get("router_dependencies", {})
-            
+
             handlers["message"] = FunctionInfo(message_handler, is_async, num_params, params, filtered_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_handler).parameters)  # Use original handler params, not wrapper
                 connect_num_params = len(connect_params)
                 connect_is_async = asyncio.iscoroutinefunction(connect_wrapper)
-                
+
                 # Filter dependencies for connect handler - only reserved parameters
                 filtered_connect_deps = {}
                 if "global_dependencies" in connect_params:
                     filtered_connect_deps["global_dependencies"] = injected_dependencies.get("global_dependencies", {})
                 if "router_dependencies" in connect_params:
                     filtered_connect_deps["router_dependencies"] = injected_dependencies.get("router_dependencies", {})
-                        
+
                 handlers["connect"] = FunctionInfo(connect_wrapper, connect_is_async, connect_num_params, connect_params, filtered_connect_deps)
                 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_handler).parameters)  # Use original handler params, not wrapper
                 close_num_params = len(close_params)
                 close_is_async = asyncio.iscoroutinefunction(close_wrapper)
-                
+
                 # Filter dependencies for close handler - only reserved parameters
                 filtered_close_deps = {}
                 if "global_dependencies" in close_params:
                     filtered_close_deps["global_dependencies"] = injected_dependencies.get("global_dependencies", {})
                 if "router_dependencies" in close_params:
                     filtered_close_deps["router_dependencies"] = injected_dependencies.get("router_dependencies", {})
-                        
+
                 handlers["close"] = FunctionInfo(close_wrapper, close_is_async, close_num_params, close_params, filtered_close_deps)
                 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
             app_instance.add_web_socket(endpoint, handlers)
             return handler
-        
+
         return decorator
-    
+
     return websocket
 
 
@@ -259,4 +263,4 @@ def inner(handler):
 
             return handler
 
-        return inner
+        return inner