formatting and linting

Author: akash329d

src/mcp/server/fastmcp/server.py

@@ -472,6 +472,7 @@ async def run_stdio_async(self) -> None:
     async def run_sse_async(self) -> None:
         """Run the server using SSE transport."""
         import uvicorn
+
         starlette_app = self.sse_app()
 
         config = uvicorn.Config(

src/mcp/server/message_queue/base.py

@@ -3,6 +3,7 @@
 from contextlib import asynccontextmanager
 from typing import Protocol, runtime_checkable
 from uuid import UUID
+
 from pydantic import ValidationError
 
 import mcp.types as types
@@ -59,13 +60,13 @@ async def session_exists(self, session_id: UUID) -> bool:
 class InMemoryMessageDispatch:
     """Default in-memory implementation of the MessageDispatch interface.
 
-    This implementation immediately dispatches messages to registered callbacks when 
+    This implementation immediately dispatches messages to registered callbacks when
     messages are received without any queuing behavior.
     """
 
     def __init__(self) -> None:
         self._callbacks: dict[UUID, MessageCallback] = {}
-        # We don't need a separate _active_sessions set since _callbacks already tracks this
+        # _callbacks tracks active sessions, no need for separate _active_sessions set
 
     async def publish_message(
         self, session_id: UUID, message: types.JSONRPCMessage | str
@@ -74,19 +75,19 @@ async def publish_message(
         if session_id not in self._callbacks:
             logger.warning(f"Message dropped: unknown session {session_id}")
             return False
-        
-        # For string messages, attempt parsing and recreate original ValidationError if invalid
+
+        # Parse string messages or recreate original ValidationError
         if isinstance(message, str):
             try:
                 callback_argument = types.JSONRPCMessage.model_validate_json(message)
             except ValidationError as exc:
                 callback_argument = exc
         else:
             callback_argument = message
-        
+
         # Call the callback with either valid message or recreated ValidationError
         await self._callbacks[session_id](callback_argument)
-        
+
         logger.debug(f"Message dispatched to session {session_id}")
         return True
 

src/mcp/server/message_queue/redis.py

@@ -2,10 +2,10 @@
 from contextlib import asynccontextmanager
 from typing import Any, cast
 from uuid import UUID
-from pydantic import ValidationError
 
 import anyio
 from anyio import CapacityLimiter, lowlevel
+from pydantic import ValidationError
 
 import mcp.types as types
 from mcp.server.message_queue.base import MessageCallback
@@ -68,7 +68,7 @@ async def subscribe(self, session_id: UUID, callback: MessageCallback):
                 await self._pubsub.unsubscribe(channel)  # type: ignore
                 await self._redis.srem(self._active_sessions_key, session_id.hex)
                 del self._callbacks[session_id]
-                logger.debug(f"Unsubscribed from Redis channel for session {session_id}")
+                logger.debug(f"Unsubscribed from Redis channel: {session_id}")
 
     async def _listen_for_messages(self) -> None:
         """Background task that listens for messages on subscribed channels."""
@@ -84,37 +84,37 @@ async def _listen_for_messages(self) -> None:
 
                 channel: str = cast(str, message["channel"])
                 expected_prefix = f"{self._prefix}session:"
-                
+
                 if not channel.startswith(expected_prefix):
                     logger.debug(f"Ignoring message from non-MCP channel: {channel}")
                     continue
-                
-                session_hex = channel[len(expected_prefix):]
+
+                session_hex = channel[len(expected_prefix) :]
                 try:
                     session_id = UUID(hex=session_hex)
                     expected_channel = self._session_channel(session_id)
                     if channel != expected_channel:
                         logger.error(f"Channel format mismatch: {channel}")
                         continue
                 except ValueError:
-                    logger.error(f"Received message with invalid UUID in channel: {channel}")
+                    logger.error(f"Invalid UUID in channel: {channel}")
                     continue
 
                 data: str = cast(str, message["data"])
                 try:
                     if session_id not in self._callbacks:
-                        logger.warning(f"Message dropped: no callback for session {session_id}")
+                        logger.warning(f"Message dropped: no callback for {session_id}")
                         continue
-                        
+
                     # Try to parse as valid message or recreate original ValidationError
                     try:
                         msg = types.JSONRPCMessage.model_validate_json(data)
                         await self._callbacks[session_id](msg)
                     except ValidationError as exc:
-                        # Pass the identical validation error that would have occurred originally
+                        # Pass the identical validation error that would have occurred
                         await self._callbacks[session_id](exc)
                 except Exception as e:
-                    logger.error(f"Error processing message for session {session_id}: {e}")
+                    logger.error(f"Error processing message for {session_id}: {e}")
 
     async def publish_message(
         self, session_id: UUID, message: types.JSONRPCMessage | str

src/mcp/server/sse.py

@@ -137,9 +137,7 @@ async def sse_writer():
             logger.debug("Starting SSE response task")
             tg.start_soon(response, scope, receive, send)
 
-            async with self._message_dispatch.subscribe(
-                session_id, message_callback
-            ):
+            async with self._message_dispatch.subscribe(session_id, message_callback):
                 logger.debug("Yielding read and write streams")
                 yield (read_stream, write_stream)
 
@@ -178,8 +176,8 @@ async def handle_post_message(
             logger.error(f"Failed to parse message: {err}")
             response = Response("Could not parse message", status_code=400)
             await response(scope, receive, send)
-            # Pass raw JSON string through dispatch; original ValidationError will be recreated when 
-            # the receiver tries to validate the same invalid JSON
+            # Pass raw JSON string; receiver will recreate identical ValidationError
+            # when parsing the same invalid JSON
             await self._message_dispatch.publish_message(session_id, body.decode())
             return
 

tests/server/fastmcp/servers/test_file_server.py

@@ -114,17 +114,13 @@ async def test_read_resource_file(mcp: FastMCP):
 
 @pytest.mark.anyio
 async def test_delete_file(mcp: FastMCP, test_dir: Path):
-    await mcp.call_tool(
-        "delete_file", arguments={"path": str(test_dir / "example.py")}
-    )
+    await mcp.call_tool("delete_file", arguments={"path": str(test_dir / "example.py")})
     assert not (test_dir / "example.py").exists()
 
 
 @pytest.mark.anyio
 async def test_delete_file_and_check_resources(mcp: FastMCP, test_dir: Path):
-    await mcp.call_tool(
-        "delete_file", arguments={"path": str(test_dir / "example.py")}
-    )
+    await mcp.call_tool("delete_file", arguments={"path": str(test_dir / "example.py")})
     res_iter = await mcp.read_resource("file://test_dir/example.py")
     res_list = list(res_iter)
     assert len(res_list) == 1