ruff E501

Author: nick-merrill

mcp_python/client/session.py

@@ -38,7 +38,13 @@ def __init__(
         write_stream: MemoryObjectSendStream[JSONRPCMessage],
         read_timeout_seconds: int | float | None = None,
     ) -> None:
-        super().__init__(read_stream, write_stream, ServerRequest, ServerNotification, read_timeout_seconds=read_timeout_seconds)
+        super().__init__(
+            read_stream,
+            write_stream,
+            ServerRequest,
+            ServerNotification,
+            read_timeout_seconds=read_timeout_seconds,
+        )
 
     async def initialize(self) -> InitializeResult:
         from mcp_python.types import (

mcp_python/server/memory.py

@@ -14,10 +14,21 @@
 
 
 @asynccontextmanager
-async def create_client_server_memory_streams() -> AsyncGenerator[ Tuple[
-    Tuple[MemoryObjectReceiveStream[JSONRPCMessage | Exception], MemoryObjectSendStream[JSONRPCMessage]],
-    Tuple[MemoryObjectReceiveStream[JSONRPCMessage | Exception], MemoryObjectSendStream[JSONRPCMessage]]
-], None]:
+async def create_client_server_memory_streams() -> (
+    AsyncGenerator[
+        Tuple[
+            Tuple[
+                MemoryObjectReceiveStream[JSONRPCMessage | Exception],
+                MemoryObjectSendStream[JSONRPCMessage],
+            ],
+            Tuple[
+                MemoryObjectReceiveStream[JSONRPCMessage | Exception],
+                MemoryObjectSendStream[JSONRPCMessage],
+            ],
+        ],
+        None,
+    ]
+):
     """
     Creates a pair of bidirectional memory streams for client-server communication.
 
@@ -26,42 +37,55 @@ async def create_client_server_memory_streams() -> AsyncGenerator[ Tuple[
         (read_stream, write_stream)
     """
     # Create streams for both directions
-    server_to_client_send, server_to_client_receive = anyio.create_memory_object_stream[JSONRPCMessage | Exception](1)
-    client_to_server_send, client_to_server_receive = anyio.create_memory_object_stream[JSONRPCMessage | Exception](1)
+    server_to_client_send, server_to_client_receive = anyio.create_memory_object_stream[
+        JSONRPCMessage | Exception
+    ](1)
+    client_to_server_send, client_to_server_receive = anyio.create_memory_object_stream[
+        JSONRPCMessage | Exception
+    ](1)
 
     # Return streams grouped by client/server
     client_streams = (server_to_client_receive, client_to_server_send)
     server_streams = (client_to_server_receive, server_to_client_send)
 
-    async with (server_to_client_receive, client_to_server_send,
-                client_to_server_receive, server_to_client_send):
+    async with (
+        server_to_client_receive,
+        client_to_server_send,
+        client_to_server_receive,
+        server_to_client_send,
+    ):
         yield client_streams, server_streams
 
 
 @asynccontextmanager
-async def create_connected_server_and_client_session(server: Server) -> AsyncGenerator[ClientSession, None]:
+async def create_connected_server_and_client_session(
+    server: Server,
+) -> AsyncGenerator[ClientSession, None]:
     """Creates a ServerSession that is connected to the `server`."""
-    async with create_client_server_memory_streams() as (client_streams, server_streams):
+    async with create_client_server_memory_streams() as (
+        client_streams,
+        server_streams,
+    ):
         # Unpack the streams
         client_read, client_write = client_streams
         server_read, server_write = server_streams
         print("stream-1")
 
         # Create a cancel scope for the server task
         async with anyio.create_task_group() as tg:
-
             tg.start_soon(
                 server.run,
                 server_read,
                 server_write,
-                server.create_initialization_options()
+                server.create_initialization_options(),
             )
 
             print("stream2")
 
             try:
-                # Client session could be created here using client_read and client_write
-                # This would allow testing the server with a client in the same process
+                # Client session could be created here using client_read and
+                # client_write This would allow testing the server with a client
+                # in the same process
                 async with ClientSession(
                     read_stream=client_read, write_stream=client_write
                 ) as client_session:

mcp_python/shared/session.py

@@ -155,7 +155,17 @@ async def send_request(
                 response_or_error = await response_stream_reader.receive()
         except TimeoutError:
             # TODO: make sure this response comes back correctly to the client
-            raise McpError(ErrorData(code=408, message=f"Timed out while waiting for response to {request.__class__.__name__}. Waited {READ_TIMEOUT_SECONDS} seconds."))
+            raise McpError(
+                ErrorData(
+                    code=408,
+                    message=(
+                        f"Timed out while waiting for response to "
+                        f"{request.__class__.__name__}. Waited "
+                        f"{self._read_timeout_seconds} seconds."
+                    ),
+                )
+
+            )
 
         if isinstance(response_or_error, JSONRPCError):
             raise McpError(response_or_error.error)

tests/test_memory.py

@@ -12,18 +12,22 @@
 
 
 @pytest.fixture
-async def client_connected_to_server(mcp_server: Server) -> AsyncGenerator[ClientSession, None]:
-    print('11111')
+async def client_connected_to_server(
+    mcp_server: Server,
+) -> AsyncGenerator[ClientSession, None]:
+    print("11111")
     async with create_connected_server_and_client_session(mcp_server) as client_session:
-        print('2222k')
+        print("2222k")
         yield client_session
-        print('33')
+        print("33")
 
 
 @pytest.mark.anyio
-async def test_memory_server_and_client_connection(client_connected_to_server: ClientSession):
+async def test_memory_server_and_client_connection(
+    client_connected_to_server: ClientSession,
+):
     """Shows how a client and server can communicate over memory streams."""
     response = await client_connected_to_server.send_ping()
-    print('foo')
+    print("foo")
     assert isinstance(response, EmptyResult)
-    print('bar')
+    print("bar")