update uv.lock & add pragmas

Author: felixweinberger

src/mcp/client/streamable_http.py

@@ -358,11 +358,11 @@ async def _handle_sse_response(
                 if is_complete:
                     await response.aclose()
                     return  # Normal completion, no reconnect needed
-        except Exception as e:
+        except Exception as e:  # pragma: no cover
             logger.debug(f"SSE stream ended: {e}")
 
         # Stream ended without response - reconnect if we received an event with ID
-        if last_event_id is not None:
+        if last_event_id is not None:  # pragma: no branch
             logger.info("SSE stream disconnected, reconnecting...")
             await self._handle_reconnection(ctx, last_event_id, retry_interval_ms)
 
@@ -375,7 +375,7 @@ async def _handle_reconnection(
     ) -> None:
         """Reconnect with Last-Event-ID to resume stream after server disconnect."""
         # Bail if max retries exceeded
-        if attempt >= MAX_RECONNECTION_ATTEMPTS:
+        if attempt >= MAX_RECONNECTION_ATTEMPTS:  # pragma: no cover
             logger.debug(f"Max reconnection attempts ({MAX_RECONNECTION_ATTEMPTS}) exceeded")
             return
 
@@ -388,7 +388,7 @@ async def _handle_reconnection(
 
         # Extract original request ID to map responses
         original_request_id = None
-        if isinstance(ctx.session_message.message.root, JSONRPCRequest):
+        if isinstance(ctx.session_message.message.root, JSONRPCRequest):  # pragma: no branch
             original_request_id = ctx.session_message.message.root.id
 
         try:
@@ -407,7 +407,7 @@ async def _handle_reconnection(
                 reconnect_retry_ms = retry_interval_ms
 
                 async for sse in event_source.aiter_sse():
-                    if sse.id:
+                    if sse.id:  # pragma: no branch
                         reconnect_last_event_id = sse.id
                     if sse.retry is not None:
                         reconnect_retry_ms = sse.retry
@@ -425,7 +425,7 @@ async def _handle_reconnection(
                 # Stream ended again without response - reconnect again (reset attempt counter)
                 logger.info("SSE stream disconnected, reconnecting...")
                 await self._handle_reconnection(ctx, reconnect_last_event_id, reconnect_retry_ms, 0)
-        except Exception as e:
+        except Exception as e:  # pragma: no cover
             logger.debug(f"Reconnection failed: {e}")
             # Try to reconnect again if we still have an event ID
             await self._handle_reconnection(ctx, last_event_id, retry_interval_ms, attempt + 1)

src/mcp/server/fastmcp/server.py

@@ -1299,7 +1299,7 @@ async def close_sse_stream(self) -> None:
             This is a no-op if not using StreamableHTTP transport with event_store.
             The callback is only available when event_store is configured.
         """
-        if self._request_context and self._request_context.close_sse_stream:
+        if self._request_context and self._request_context.close_sse_stream:  # pragma: no cover
             await self._request_context.close_sse_stream()
 
     # Convenience methods for common log levels

src/mcp/server/streamable_http.py

@@ -186,7 +186,7 @@ def is_terminated(self) -> bool:
         """Check if this transport has been explicitly terminated."""
         return self._terminated
 
-    def close_sse_stream(self, request_id: RequestId) -> None:
+    def close_sse_stream(self, request_id: RequestId) -> None:  # pragma: no cover
         """Close SSE connection for a specific request without terminating the stream.
 
         This method closes the HTTP connection for the specified request, triggering
@@ -214,7 +214,7 @@ def close_sse_stream(self, request_id: RequestId) -> None:
             send_stream.close()
             receive_stream.close()
 
-    def _create_session_message(
+    def _create_session_message(  # pragma: no cover
         self,
         message: JSONRPCMessage,
         request: Request,
@@ -231,7 +231,7 @@ async def close_stream_callback() -> None:
         )
         return SessionMessage(message, metadata=metadata)
 
-    async def _send_priming_event(
+    async def _send_priming_event(  # pragma: no cover
         self,
         request_id: RequestId,
         sse_stream_writer: MemoryObjectSendStream[dict[str, Any]],

tests/shared/test_streamable_http.py

@@ -80,7 +80,9 @@ def __init__(self):
         self._events: list[tuple[StreamId, EventId, types.JSONRPCMessage | None]] = []
         self._event_id_counter = 0
 
-    async def store_event(self, stream_id: StreamId, message: types.JSONRPCMessage | None) -> EventId:
+    async def store_event(  # pragma: no cover
+        self, stream_id: StreamId, message: types.JSONRPCMessage | None
+    ) -> EventId:
         """Store an event and return its ID."""
         self._event_id_counter += 1
         event_id = str(self._event_id_counter)
@@ -1817,10 +1819,10 @@ async def test_streamablehttp_client_auto_reconnects(
     async def message_handler(
         message: RequestResponder[types.ServerRequest, types.ClientResult] | types.ServerNotification | Exception,
     ) -> None:
-        if isinstance(message, Exception):
-            return
-        if isinstance(message, types.ServerNotification):
-            if isinstance(message.root, types.LoggingMessageNotification):
+        if isinstance(message, Exception):  # pragma: no branch
+            return  # pragma: no cover
+        if isinstance(message, types.ServerNotification):  # pragma: no branch
+            if isinstance(message.root, types.LoggingMessageNotification):  # pragma: no branch
                 captured_notifications.append(str(message.root.params.data))
 
     async with streamablehttp_client(f"{server_url}/mcp") as (
@@ -1893,10 +1895,10 @@ async def test_streamablehttp_sse_polling_full_cycle(
     async def message_handler(
         message: RequestResponder[types.ServerRequest, types.ClientResult] | types.ServerNotification | Exception,
     ) -> None:
-        if isinstance(message, Exception):
-            return
-        if isinstance(message, types.ServerNotification):
-            if isinstance(message.root, types.LoggingMessageNotification):
+        if isinstance(message, Exception):  # pragma: no branch
+            return  # pragma: no cover
+        if isinstance(message, types.ServerNotification):  # pragma: no branch
+            if isinstance(message.root, types.LoggingMessageNotification):  # pragma: no branch
                 all_notifications.append(str(message.root.params.data))
 
     async with streamablehttp_client(f"{server_url}/mcp") as (
@@ -1941,10 +1943,10 @@ async def test_streamablehttp_events_replayed_after_disconnect(
     async def message_handler(
         message: RequestResponder[types.ServerRequest, types.ClientResult] | types.ServerNotification | Exception,
     ) -> None:
-        if isinstance(message, Exception):
-            return
-        if isinstance(message, types.ServerNotification):
-            if isinstance(message.root, types.LoggingMessageNotification):
+        if isinstance(message, Exception):  # pragma: no branch
+            return  # pragma: no cover
+        if isinstance(message, types.ServerNotification):  # pragma: no branch
+            if isinstance(message.root, types.LoggingMessageNotification):  # pragma: no branch
                 notification_data.append(str(message.root.params.data))
 
     async with streamablehttp_client(f"{server_url}/mcp") as (
@@ -2025,7 +2027,7 @@ async def on_resumption_token(token: str) -> None:
             assert "Completed 3 checkpoints" in result.content[0].text
 
     # 4 priming + 3 notifications + 1 response = 8 tokens
-    assert len(resumption_tokens) == 8, (
+    assert len(resumption_tokens) == 8, (  # pragma: no cover
         f"Expected 8 resumption tokens (4 priming + 3 notifs + 1 response), "
         f"got {len(resumption_tokens)}: {resumption_tokens}"
     )