fix: Lint fixes of services

app/services/socket.py

@@ -13,7 +13,8 @@ logger = logging.getLogger(__name__)
 class SocketManager:
     """Manages WebSocket connections and user rooms."""
 
-    def __init__(self):
+    def __init__(self) -> None:
+        """Initialize the SocketManager with a Socket.IO server."""
         self.sio = socketio.AsyncServer(
             cors_allowed_origins=["http://localhost:8001"],
             logger=True,
@@ -27,20 +28,20 @@ class SocketManager:
 
         self._setup_handlers()
 
-    def _setup_handlers(self):
+    def _setup_handlers(self) -> None:
         """Set up socket event handlers."""
 
         @self.sio.event
-        async def connect(sid, environ, auth=None):
+        async def connect(sid: str, environ: dict) -> None:
             """Handle client connection."""
-            logger.info(f"Client {sid} attempting to connect")
+            logger.info("Client %s attempting to connect", sid)
 
             # Extract access token from cookies
             cookie_header = environ.get("HTTP_COOKIE", "")
             access_token = extract_access_token_from_cookies(cookie_header)
 
             if not access_token:
-                logger.warning(f"Client {sid} connecting without access token")
+                logger.warning("Client %s connecting without access token", sid)
                 await self.sio.disconnect(sid)
                 return
 
@@ -50,13 +51,13 @@ class SocketManager:
                 user_id = payload.get("sub")
 
                 if not user_id:
-                    logger.warning(f"Client {sid} token missing user ID")
+                    logger.warning("Client %s token missing user ID", sid)
                     await self.sio.disconnect(sid)
                     return
 
-                logger.info(f"User {user_id} connected with socket {sid}")
-            except Exception as e:
-                logger.warning(f"Client {sid} invalid token: {e}")
+                logger.info("User %s connected with socket %s", user_id, sid)
+            except Exception:
+                logger.exception("Client %s invalid token", sid)
                 await self.sio.disconnect(sid)
                 return
 
@@ -70,7 +71,7 @@ class SocketManager:
             # Update room tracking
             self.user_rooms[user_id] = room_id
 
-            logger.info(f"User {user_id} joined room {room_id}")
+            logger.info("User %s joined room %s", user_id, room_id)
 
             # Send welcome message to user
             await self.sio.emit(
@@ -84,33 +85,33 @@ class SocketManager:
             )
 
         @self.sio.event
-        async def disconnect(sid):
+        async def disconnect(sid: str) -> None:
             """Handle client disconnection."""
             user_id = self.socket_users.get(sid)
 
             if user_id:
-                logger.info(f"User {user_id} disconnected (socket {sid})")
+                logger.info("User %s disconnected (socket %s)", user_id, sid)
                 # Clean up mappings
                 del self.socket_users[sid]
                 if user_id in self.user_rooms:
                     del self.user_rooms[user_id]
             else:
-                logger.info(f"Unknown client {sid} disconnected")
+                logger.info("Unknown client %s disconnected", sid)
 
-    async def send_to_user(self, user_id: str, event: str, data: dict):
+    async def send_to_user(self, user_id: str, event: str, data: dict) -> bool:
         """Send a message to a specific user's room."""
         room_id = self.user_rooms.get(user_id)
         if room_id:
             await self.sio.emit(event, data, room=room_id)
-            logger.debug(f"Sent {event} to user {user_id} in room {room_id}")
+            logger.debug("Sent %s to user %s in room %s", event, user_id, room_id)
             return True
-        logger.warning(f"User {user_id} not found in any room")
+        logger.warning("User %s not found in any room", user_id)
         return False
 
-    async def broadcast_to_all(self, event: str, data: dict):
+    async def broadcast_to_all(self, event: str, data: dict) -> None:
         """Broadcast a message to all connected users."""
         await self.sio.emit(event, data)
-        logger.info(f"Broadcasted {event} to all users")
+        logger.info("Broadcasted %s to all users", event)
 
     def get_connected_users(self) -> list:
         """Get list of currently connected user IDs."""