style: uv run ruff format

Signed-off-by: Samantha Coyle <sam@diagrid.io>

Author: sicoyle

dapr/aio/clients/grpc/client.py

@@ -80,9 +80,9 @@
     GetMetadataResponse,
     GetSecretResponse,
     InvokeMethodResponse,
+    MetadataMCPServer,
     QueryResponse,
     QueryResponseItem,
-    MetadataMCPServer,
     RegisteredComponents,
     StateResponse,
     TopicEventResponse,
@@ -1724,9 +1724,7 @@ async def get_metadata(self) -> GetMetadataResponse:
             for i in response.registered_components
         ]
         extended_metadata = dict(response.extended_metadata.items())
-        mcp_servers = [
-            MetadataMCPServer(name=s.name) for s in response.mcp_servers
-        ]
+        mcp_servers = [MetadataMCPServer(name=s.name) for s in response.mcp_servers]
 
         return GetMetadataResponse(
             application_id=response.id,

dapr/clients/grpc/client.py

@@ -71,9 +71,9 @@
     GetMetadataResponse,
     GetSecretResponse,
     InvokeMethodResponse,
+    MetadataMCPServer,
     QueryResponse,
     QueryResponseItem,
-    MetadataMCPServer,
     RegisteredComponents,
     StateResponse,
     TopicEventResponse,
@@ -1829,9 +1829,7 @@ def get_metadata(self) -> GetMetadataResponse:
             for i in response.registered_components
         ]
         extended_metadata = dict(response.extended_metadata.items())
-        mcp_servers = [
-            MetadataMCPServer(name=s.name) for s in response.mcp_servers
-        ]
+        mcp_servers = [MetadataMCPServer(name=s.name) for s in response.mcp_servers]
 
         return GetMetadataResponse(
             application_id=response.id,

examples/mcp/mcp_tool_discovery.py

@@ -58,18 +58,18 @@ def main():
     print("Connecting to MCPServer 'weather'...")
 
     client = DaprMCPClient(timeout_in_seconds=30)
-    client.connect("weather")
+    client.connect('weather')
 
     tools = client.get_all_tools()
-    print(f"\nDiscovered {len(tools)} tool(s):\n")
+    print(f'\nDiscovered {len(tools)} tool(s):\n')
     for tool in tools:
-        print(f"  Name:        {tool.name}")
-        print(f"  Description: {tool.description}")
-        print(f"  Server:      {tool.server_name}")
-        print(f"  Workflow:    {tool.call_tool_workflow}")
-        if tool.input_schema.get("properties"):
-            props = list(tool.input_schema["properties"].keys())
-            print(f"  Parameters:  {', '.join(props)}")
+        print(f'  Name:        {tool.name}')
+        print(f'  Description: {tool.description}')
+        print(f'  Server:      {tool.server_name}')
+        print(f'  Workflow:    {tool.call_tool_workflow}')
+        if tool.input_schema.get('properties'):
+            props = list(tool.input_schema['properties'].keys())
+            print(f'  Parameters:  {", ".join(props)}')
         print()
 
     # ------------------------------------------------------------------
@@ -78,35 +78,33 @@ def main():
     #    durable tool calls via child workflows.
     # ------------------------------------------------------------------
     if not tools:
-        print("No tools discovered — exiting.")
+        print('No tools discovered — exiting.')
         return
 
     tool = tools[0]
     print(f"Using tool '{tool.name}' in a workflow...\n")
 
     # Build a Pydantic model from the tool's JSON Schema for validation.
     if tool.input_schema:
-        ArgsModel = create_pydantic_model_from_schema(
-            tool.input_schema, f"{tool.name}Args"
-        )
-        print(f"  Args model: {ArgsModel.__name__}")
-        print(f"  Fields:     {list(ArgsModel.model_fields.keys())}\n")
+        ArgsModel = create_pydantic_model_from_schema(tool.input_schema, f'{tool.name}Args')
+        print(f'  Args model: {ArgsModel.__name__}')
+        print(f'  Fields:     {list(ArgsModel.model_fields.keys())}\n')
 
     # Define a simple workflow that calls the MCP tool.
     def call_mcp_tool_workflow(ctx: DaprWorkflowContext, input: dict):
         """Workflow that calls an MCP tool as a child workflow."""
         result = yield ctx.call_child_workflow(
             workflow=tool.call_tool_workflow,
             input={
-                "toolName": tool.name,
-                "arguments": input.get("arguments", {}),
+                'toolName': tool.name,
+                'arguments': input.get('arguments', {}),
             },
         )
         return result
 
     def print_result(ctx: WorkflowActivityContext, input):
         """Activity that prints the tool result."""
-        print(f"  Tool result: {input}")
+        print(f'  Tool result: {input}')
 
     # Register and run the workflow.
     wfr = WorkflowRuntime()
@@ -117,9 +115,9 @@ def print_result(ctx: WorkflowActivityContext, input):
     wf_client = DaprWorkflowClient()
     instance_id = wf_client.schedule_new_workflow(
         workflow=call_mcp_tool_workflow,
-        input={"arguments": {"location": "Seattle"}},
+        input={'arguments': {'location': 'Seattle'}},
     )
-    print(f"  Scheduled workflow: {instance_id}")
+    print(f'  Scheduled workflow: {instance_id}')
 
     state = wf_client.wait_for_workflow_completion(
         instance_id=instance_id,
@@ -128,14 +126,14 @@ def print_result(ctx: WorkflowActivityContext, input):
     )
 
     if state:
-        print(f"  Status: {state.runtime_status.name}")
-        print(f"  Output: {state.serialized_output}")
+        print(f'  Status: {state.runtime_status.name}')
+        print(f'  Output: {state.serialized_output}')
     else:
-        print("  Workflow timed out.")
+        print('  Workflow timed out.')
 
     wfr.shutdown()
-    print("\nDone.")
+    print('\nDone.')
 
 
-if __name__ == "__main__":
+if __name__ == '__main__':
     main()

examples/mcp/weather_mcp_server.py

@@ -29,14 +29,12 @@
 
 from mcp.server.fastmcp import FastMCP
 
-logging.basicConfig(
-    level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
-)
-logger = logging.getLogger("weather-mcp-server")
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger('weather-mcp-server')
 
 
 def build_server(host: str, port: int) -> FastMCP:
-    mcp = FastMCP("WeatherService", host=host, port=port)
+    mcp = FastMCP('WeatherService', host=host, port=port)
 
     @mcp.tool()
     async def get_weather(location: str) -> str:
@@ -50,10 +48,10 @@ async def get_weather(location: str) -> str:
         """
         temperature = random.randint(32, 105)
         conditions = random.choice(
-            ["sunny", "cloudy", "partly cloudy", "rainy", "windy", "snowy", "foggy"]
+            ['sunny', 'cloudy', 'partly cloudy', 'rainy', 'windy', 'snowy', 'foggy']
         )
         humidity = random.randint(20, 95)
-        return f"{location}: {temperature}F, {conditions}, {humidity}% humidity."
+        return f'{location}: {temperature}F, {conditions}, {humidity}% humidity.'
 
     @mcp.tool()
     async def get_forecast(location: str, days: int = 5) -> str:
@@ -67,36 +65,30 @@ async def get_forecast(location: str, days: int = 5) -> str:
             Multi-line forecast summary.
         """
         days = min(max(days, 1), 10)
-        lines = [f"{location} {days}-day forecast:"]
+        lines = [f'{location} {days}-day forecast:']
         for i in range(1, days + 1):
             high = random.randint(55, 105)
             low = high - random.randint(10, 25)
-            cond = random.choice(
-                ["sunny", "cloudy", "rainy", "stormy", "clear", "partly cloudy"]
-            )
-            lines.append(f"  Day {i}: High {high}F / Low {low}F, {cond}")
-        return "\n".join(lines)
+            cond = random.choice(['sunny', 'cloudy', 'rainy', 'stormy', 'clear', 'partly cloudy'])
+            lines.append(f'  Day {i}: High {high}F / Low {low}F, {cond}')
+        return '\n'.join(lines)
 
     return mcp
 
 
 def main() -> None:
-    parser = argparse.ArgumentParser(
-        description="Weather MCP server (streamable-HTTP transport)"
-    )
-    parser.add_argument("--host", default="0.0.0.0")
-    parser.add_argument("--port", type=int, default=8081)
+    parser = argparse.ArgumentParser(description='Weather MCP server (streamable-HTTP transport)')
+    parser.add_argument('--host', default='0.0.0.0')
+    parser.add_argument('--port', type=int, default=8081)
     args = parser.parse_args()
 
     mcp = build_server(args.host, args.port)
-    logger.info(
-        "Weather MCP server listening on http://%s:%d/mcp", args.host, args.port
-    )
+    logger.info('Weather MCP server listening on http://%s:%d/mcp', args.host, args.port)
     try:
-        mcp.run(transport="streamable-http")
+        mcp.run(transport='streamable-http')
     except (KeyboardInterrupt, SystemExit):
-        logger.info("Shutting down.")
+        logger.info('Shutting down.')
 
 
-if __name__ == "__main__":
+if __name__ == '__main__':
     main()

ext/dapr-ext-workflow/dapr/ext/workflow/__init__.py

@@ -17,15 +17,15 @@
 from dapr.ext.workflow._durabletask.task import TaskFailedError
 from dapr.ext.workflow.dapr_workflow_client import DaprWorkflowClient
 from dapr.ext.workflow.dapr_workflow_context import DaprWorkflowContext, when_all, when_any
+
+# MCP
+from dapr.ext.workflow.mcp import MCP_WORKFLOW_PREFIX, DaprMCPClient, MCPToolDef
+from dapr.ext.workflow.mcp_schema import create_pydantic_model_from_schema
 from dapr.ext.workflow.retry_policy import RetryPolicy
 from dapr.ext.workflow.workflow_activity_context import WorkflowActivityContext
 from dapr.ext.workflow.workflow_runtime import WorkflowRuntime, alternate_name
 from dapr.ext.workflow.workflow_state import WorkflowState, WorkflowStatus
 
-# MCP
-from dapr.ext.workflow.mcp import DaprMCPClient, MCPToolDef, MCP_WORKFLOW_PREFIX
-from dapr.ext.workflow.mcp_schema import create_pydantic_model_from_schema
-
 __all__ = [
     'WorkflowRuntime',
     'DaprWorkflowClient',

ext/dapr-ext-workflow/dapr/ext/workflow/aio/__init__.py

@@ -13,12 +13,12 @@
 limitations under the License.
 """
 
-from .dapr_workflow_client import DaprWorkflowClient
-from .mcp import DaprMCPClient
-
 # Re-export MCPToolDef so async users don't need to import from the sync module.
 from dapr.ext.workflow.mcp import MCPToolDef
 
+from .dapr_workflow_client import DaprWorkflowClient
+from .mcp import DaprMCPClient
+
 __all__ = [
     'DaprWorkflowClient',
     'DaprMCPClient',

ext/dapr-ext-workflow/dapr/ext/workflow/aio/mcp.py

@@ -11,16 +11,16 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from __future__ import annotations
-
 """Async variant of :class:`~dapr.ext.workflow.mcp.DaprMCPClient`."""
 
+from __future__ import annotations
+
 import logging
 import uuid
 from typing import Optional, Set
 
 from dapr.ext.workflow.aio.dapr_workflow_client import DaprWorkflowClient
-from dapr.ext.workflow.mcp import MCP_WORKFLOW_PREFIX, _DaprMCPClientBase, _MCP_METHOD_LIST_TOOLS
+from dapr.ext.workflow.mcp import _MCP_METHOD_LIST_TOOLS, MCP_WORKFLOW_PREFIX, _DaprMCPClientBase
 from dapr.ext.workflow.workflow_state import WorkflowStatus
 
 logger = logging.getLogger(__name__)
@@ -76,19 +76,17 @@ async def connect(self, mcpserver_name: str) -> None:
             ValueError: If *mcpserver_name* is empty.
         """
         if not mcpserver_name or not mcpserver_name.strip():
-            raise ValueError("mcpserver_name must be a non-empty string")
+            raise ValueError('mcpserver_name must be a non-empty string')
 
         instance_id = str(uuid.uuid4())
         # TODO(@sicoyle): reminder to add a func like I have in durabletask-go to use for here instead of building like this!
-        workflow_name = f"{MCP_WORKFLOW_PREFIX}{mcpserver_name}{_MCP_METHOD_LIST_TOOLS}"
+        workflow_name = f'{MCP_WORKFLOW_PREFIX}{mcpserver_name}{_MCP_METHOD_LIST_TOOLS}'
 
-        logger.debug(
-            "Scheduling %s (instance=%s)", workflow_name, instance_id
-        )
+        logger.debug('Scheduling %s (instance=%s)', workflow_name, instance_id)
 
         await self._wf_client.schedule_new_workflow(
             workflow=workflow_name,
-            input={"mcpServerName": mcpserver_name},
+            input={'mcpServerName': mcpserver_name},
             instance_id=instance_id,
         )
 
@@ -101,14 +99,14 @@ async def connect(self, mcpserver_name: str) -> None:
         if state is None:
             raise RuntimeError(
                 f"ListTools workflow for MCPServer '{mcpserver_name}' "
-                f"timed out after {self._timeout}s"
+                f'timed out after {self._timeout}s'
             )
 
         if state.runtime_status != WorkflowStatus.COMPLETED:
             raise RuntimeError(
                 f"ListTools workflow for MCPServer '{mcpserver_name}' "
-                f"ended with status {state.runtime_status.name!r}: "
-                f"{state.serialized_output or ''}"
+                f'ended with status {state.runtime_status.name!r}: '
+                f'{state.serialized_output or ""}'
             )
 
         self._process_list_tools_result(mcpserver_name, state.serialized_output)