more linting (#249)

More linting

Author: eyurtsev

langchain_mcp_adapters/client.py

@@ -82,7 +82,10 @@ def __init__(self, connections: dict[str, Connection] | None = None) -> None:
 
     @asynccontextmanager
     async def session(
-        self, server_name: str, *, auto_initialize: bool = True
+        self,
+        server_name: str,
+        *,
+        auto_initialize: bool = True,
     ) -> AsyncIterator[ClientSession]:
         """Connect to an MCP server and initialize a session.
 
@@ -136,15 +139,21 @@ async def get_tools(self, *, server_name: str | None = None) -> list[BaseTool]:
         return all_tools
 
     async def get_prompt(
-        self, server_name: str, prompt_name: str, *, arguments: dict[str, Any] | None = None
+        self,
+        server_name: str,
+        prompt_name: str,
+        *,
+        arguments: dict[str, Any] | None = None,
     ) -> list[HumanMessage | AIMessage]:
         """Get a prompt from a given MCP server."""
         async with self.session(server_name) as session:
-            prompt = await load_mcp_prompt(session, prompt_name, arguments=arguments)
-            return prompt
+            return await load_mcp_prompt(session, prompt_name, arguments=arguments)
 
     async def get_resources(
-        self, server_name: str, *, uris: str | list[str] | None = None
+        self,
+        server_name: str,
+        *,
+        uris: str | list[str] | None = None,
     ) -> list[Blob]:
         """Get resources from a given MCP server.
 
@@ -157,8 +166,7 @@ async def get_resources(
 
         """
         async with self.session(server_name) as session:
-            resources = await load_mcp_resources(session, uris=uris)
-            return resources
+            return await load_mcp_resources(session, uris=uris)
 
     async def __aenter__(self) -> "MultiServerMCPClient":
         raise NotImplementedError(ASYNC_CONTEXT_MANAGER_ERROR)

langchain_mcp_adapters/prompts.py

@@ -30,7 +30,10 @@ def convert_mcp_prompt_message_to_langchain_message(
 
 
 async def load_mcp_prompt(
-    session: ClientSession, name: str, *, arguments: dict[str, Any] | None = None
+    session: ClientSession,
+    name: str,
+    *,
+    arguments: dict[str, Any] | None = None,
 ) -> list[HumanMessage | AIMessage]:
     """Load MCP prompt and convert to LangChain messages."""
     response = await session.get_prompt(name, arguments)

langchain_mcp_adapters/resources.py

@@ -48,7 +48,9 @@ async def get_mcp_resource(session: ClientSession, uri: str) -> list[Blob]:
 
 
 async def load_mcp_resources(
-    session: ClientSession, *, uris: str | list[str] | None = None
+    session: ClientSession,
+    *,
+    uris: str | list[str] | None = None,
 ) -> list[Blob]:
     """Load MCP resources and convert them to LangChain Blobs.
 
@@ -74,12 +76,14 @@ async def load_mcp_resources(
     else:
         uri_list = uris
 
-    for uri in uri_list:
-        try:
+    current_uri = None
+    try:
+        for uri in uri_list:
+            current_uri = uri
             resource_blobs = await get_mcp_resource(session, uri)
             blobs.extend(resource_blobs)
-        except Exception as e:
-            msg = f"Error fetching resource {uri}"
-            raise RuntimeError(msg) from e
+    except Exception as e:
+        msg = f"Error fetching resource {current_uri}"
+        raise RuntimeError(msg) from e
 
     return blobs

langchain_mcp_adapters/sessions.py

@@ -1,19 +1,22 @@
 from __future__ import annotations
 
 import os
-from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
 from datetime import timedelta
-from pathlib import Path
-from typing import Any, Literal, Protocol
+from typing import TYPE_CHECKING, Any, Literal, Protocol
 
-import httpx
 from mcp import ClientSession, StdioServerParameters
 from mcp.client.sse import sse_client
 from mcp.client.stdio import stdio_client
 from mcp.client.streamable_http import streamablehttp_client
 from typing_extensions import NotRequired, TypedDict
 
+if TYPE_CHECKING:
+    from collections.abc import AsyncIterator
+    from pathlib import Path
+
+    import httpx
+
 EncodingErrorHandler = Literal["strict", "ignore", "replace"]
 
 DEFAULT_ENCODING = "utf-8"
@@ -147,7 +150,7 @@ class WebsocketConnection(TypedDict):
 
 
 @asynccontextmanager
-async def _create_stdio_session(
+async def _create_stdio_session(  # noqa: PLR0913
     *,
     command: str,
     args: list[str],
@@ -186,13 +189,15 @@ async def _create_stdio_session(
     )
 
     # Create and store the connection
-    async with stdio_client(server_params) as (read, write):
-        async with ClientSession(read, write, **(session_kwargs or {})) as session:
-            yield session
+    async with (
+        stdio_client(server_params) as (read, write),
+        ClientSession(read, write, **(session_kwargs or {})) as session,
+    ):
+        yield session
 
 
 @asynccontextmanager
-async def _create_sse_session(
+async def _create_sse_session(  # noqa: PLR0913
     *,
     url: str,
     headers: dict[str, Any] | None = None,
@@ -219,16 +224,18 @@ async def _create_sse_session(
     if httpx_client_factory is not None:
         kwargs["httpx_client_factory"] = httpx_client_factory
 
-    async with sse_client(url, headers, timeout, sse_read_timeout, auth=auth, **kwargs) as (
-        read,
-        write,
+    async with (
+        sse_client(url, headers, timeout, sse_read_timeout, auth=auth, **kwargs) as (
+            read,
+            write,
+        ),
+        ClientSession(read, write, **(session_kwargs or {})) as session,
     ):
-        async with ClientSession(read, write, **(session_kwargs or {})) as session:
-            yield session
+        yield session
 
 
 @asynccontextmanager
-async def _create_streamable_http_session(
+async def _create_streamable_http_session(  # noqa: PLR0913
     *,
     url: str,
     headers: dict[str, Any] | None = None,
@@ -257,16 +264,26 @@ async def _create_streamable_http_session(
     if httpx_client_factory is not None:
         kwargs["httpx_client_factory"] = httpx_client_factory
 
-    async with streamablehttp_client(
-        url, headers, timeout, sse_read_timeout, terminate_on_close, auth=auth, **kwargs
-    ) as (read, write, _):
-        async with ClientSession(read, write, **(session_kwargs or {})) as session:
-            yield session
+    async with (
+        streamablehttp_client(
+            url,
+            headers,
+            timeout,
+            sse_read_timeout,
+            terminate_on_close,
+            auth=auth,
+            **kwargs,
+        ) as (read, write, _),
+        ClientSession(read, write, **(session_kwargs or {})) as session,
+    ):
+        yield session
 
 
 @asynccontextmanager
 async def _create_websocket_session(
-    *, url: str, session_kwargs: dict[str, Any] | None = None
+    *,
+    url: str,
+    session_kwargs: dict[str, Any] | None = None,
 ) -> AsyncIterator[ClientSession]:
     """Create a new session to an MCP server using Websockets.
 
@@ -288,13 +305,15 @@ async def _create_websocket_session(
         )
         raise ImportError(msg) from None
 
-    async with websocket_client(url) as (read, write):
-        async with ClientSession(read, write, **(session_kwargs or {})) as session:
-            yield session
+    async with (
+        websocket_client(url) as (read, write),
+        ClientSession(read, write, **(session_kwargs or {})) as session,
+    ):
+        yield session
 
 
 @asynccontextmanager
-async def create_session(connection: Connection) -> AsyncIterator[ClientSession]:
+async def create_session(connection: Connection) -> AsyncIterator[ClientSession]:  # noqa: C901
     """Create a new session to an MCP server.
 
     Args:

langchain_mcp_adapters/tools.py

@@ -63,7 +63,10 @@ async def _list_all_tools(session: ClientSession) -> list[MCPTool]:
 
 
 def convert_mcp_tool_to_langchain_tool(
-    session: ClientSession | None, tool: MCPTool, *, connection: Connection | None = None
+    session: ClientSession | None,
+    tool: MCPTool,
+    *,
+    connection: Connection | None = None,
 ) -> BaseTool:
     """Convert an MCP tool to a LangChain tool.
 
@@ -91,7 +94,8 @@ async def call_tool(
             async with create_session(connection) as tool_session:
                 await tool_session.initialize()
                 call_tool_result = await cast("ClientSession", tool_session).call_tool(
-                    tool.name, arguments
+                    tool.name,
+                    arguments,
                 )
         else:
             call_tool_result = await session.call_tool(tool.name, arguments)
@@ -108,7 +112,9 @@ async def call_tool(
 
 
 async def load_mcp_tools(
-    session: ClientSession | None, *, connection: Connection | None = None
+    session: ClientSession | None,
+    *,
+    connection: Connection | None = None,
 ) -> list[BaseTool]:
     """Load all available MCP tools and convert them to LangChain tools.
 
@@ -129,10 +135,9 @@ async def load_mcp_tools(
     else:
         tools = await _list_all_tools(session)
 
-    converted_tools = [
+    return [
         convert_mcp_tool_to_langchain_tool(session, tool, connection=connection) for tool in tools
     ]
-    return converted_tools
 
 
 def _get_injected_args(tool: BaseTool) -> list[str]:
@@ -143,12 +148,11 @@ def _is_injected_arg_type(type_: type) -> bool:
             for arg in get_args(type_)[1:]
         )
 
-    injected_args = [
+    return [
         field
         for field, field_info in get_all_basemodel_annotations(tool.args_schema).items()
         if _is_injected_arg_type(field_info)
     ]
-    return injected_args
 
 
 def to_fastmcp(tool: BaseTool) -> FastMCPTool:
@@ -168,19 +172,21 @@ def to_fastmcp(tool: BaseTool) -> FastMCPTool:
     arg_model = create_model(f"{tool.name}Arguments", **field_definitions, __base__=ArgModelBase)
     fn_metadata = FuncMetadata(arg_model=arg_model)
 
-    async def fn(**arguments: dict[str, Any]) -> Any:
+    # We'll use an Any type for the function return type.
+    # We're providing the parameters separately
+    async def fn(**arguments: dict[str, Any]) -> Any:  # noqa: ANN401
         return await tool.ainvoke(arguments)
 
     injected_args = _get_injected_args(tool)
     if len(injected_args) > 0:
-        raise NotImplementedError("LangChain tools with injected arguments are not supported")
+        msg = "LangChain tools with injected arguments are not supported"
+        raise NotImplementedError(msg)
 
-    fastmcp_tool = FastMCPTool(
+    return FastMCPTool(
         fn=fn,
         name=tool.name,
         description=tool.description,
         parameters=parameters,
         fn_metadata=fn_metadata,
         is_async=True,
     )
-    return fastmcp_tool

pyproject.toml

@@ -52,23 +52,12 @@ target-version = "py310"
 select = [ "ALL",]
 ignore = [
   "E501", # line-length
-  "ARG",
-  "ANN401",
-  "C901",
-  "COM812",
+  "COM812", # conflict with formatter
   "D100", 
   "D101",
   "D102",
   "D104",
   "D105",
-  "EM101",
-  "EM102",
-  "PERF203",
-  "PLR0913",
-  "RET504",
-  "SIM117",
-  "TC002",
-  "TC003",
 ]
 
 

tests/conftest.py

@@ -19,7 +19,9 @@ def websocket_server_port() -> int:
 @pytest.fixture
 def websocket_server(websocket_server_port: int) -> Generator[None, None, None]:
     proc = multiprocessing.Process(
-        target=run_server, kwargs={"server_port": websocket_server_port}, daemon=True
+        target=run_server,
+        kwargs={"server_port": websocket_server_port},
+        daemon=True,
     )
     proc.start()
 

tests/servers/math_server.py

@@ -21,7 +21,7 @@ def configure_assistant(skills: str) -> list[dict]:
         {
             "role": "assistant",
             "content": f"You are a helpful assistant. You have the following skills: {skills}. Always use only one tool at a time.",
-        }
+        },
     ]