Run uv run ruff format from repo root

Change-Id: I78b86be095e2c12a09e87145477c8173b30a9b5f

Author: mikeas1

examples/helloworld/__main__.py

@@ -37,7 +37,9 @@
         task_store=InMemoryTaskStore(),
     )
 
-    server = A2AStarletteApplication(agent_card=agent_card, http_handler=request_handler)
+    server = A2AStarletteApplication(
+        agent_card=agent_card, http_handler=request_handler
+    )
     import uvicorn
 
     uvicorn.run(server.build(), host='0.0.0.0', port=9999)

examples/langgraph/__main__.py

@@ -36,8 +36,8 @@ def main(host: str, port: int):
     )
 
     server = A2AStarletteApplication(
-        agent_card=get_agent_card(host, port),
-        http_handler=request_handler)
+        agent_card=get_agent_card(host, port), http_handler=request_handler
+    )
     import uvicorn
 
     uvicorn.run(server.build(), host=host, port=port)

src/a2a/server/agent_execution/__init__.py

@@ -2,4 +2,3 @@
 from a2a.server.agent_execution.context import RequestContext
 
 __all__ = ['AgentExecutor', 'RequestContext']
-

tests/server/events/test_event_consumer.py

@@ -1,4 +1,3 @@
-
 import asyncio
 import pytest
 from unittest.mock import AsyncMock, MagicMock, patch
@@ -36,16 +35,17 @@
     'messageId': '111',
 }
 
+
 @pytest.fixture
 def mock_event_queue():
     return AsyncMock(spec=EventQueue)
 
+
 @pytest.fixture
-def event_consumer(
-    mock_event_queue: EventQueue
-):
+def event_consumer(mock_event_queue: EventQueue):
     return EventConsumer(queue=mock_event_queue)
 
+
 @pytest.mark.asyncio
 async def test_consume_one_task_event(
     event_consumer: MagicMock,
@@ -57,6 +57,7 @@ async def test_consume_one_task_event(
     assert result == task_event
     mock_event_queue.task_done.assert_called_once()
 
+
 @pytest.mark.asyncio
 async def test_consume_one_message_event(
     event_consumer: MagicMock,
@@ -68,6 +69,7 @@ async def test_consume_one_message_event(
     assert result == message_event
     mock_event_queue.task_done.assert_called_once()
 
+
 @pytest.mark.asyncio
 async def test_consume_one_a2a_error_event(
     event_consumer: MagicMock,
@@ -79,6 +81,7 @@ async def test_consume_one_a2a_error_event(
     assert result == error_event
     mock_event_queue.task_done.assert_called_once()
 
+
 @pytest.mark.asyncio
 async def test_consume_one_jsonrpc_error_event(
     event_consumer: MagicMock,
@@ -90,6 +93,7 @@ async def test_consume_one_jsonrpc_error_event(
     assert result == error_event
     mock_event_queue.task_done.assert_called_once()
 
+
 @pytest.mark.asyncio
 async def test_consume_one_queue_empty(
     event_consumer: MagicMock,
@@ -103,6 +107,7 @@ async def test_consume_one_queue_empty(
         pass
     mock_event_queue.task_done.assert_not_called()
 
+
 @pytest.mark.asyncio
 async def test_consume_all_multiple_events(
     event_consumer: MagicMock,
@@ -125,12 +130,14 @@ async def test_consume_all_multiple_events(
         ),
     ]
     cursor = 0
+
     async def mock_dequeue() -> Any:
         nonlocal cursor
         if cursor < len(events):
             event = events[cursor]
             cursor += 1
             return event
+
     mock_event_queue.dequeue_event = mock_dequeue
     consumed_events: list[Any] = []
     async for event in event_consumer.consume_all():
@@ -141,6 +148,7 @@ async def mock_dequeue() -> Any:
     assert consumed_events[2] == events[2]
     assert mock_event_queue.task_done.call_count == 3
 
+
 @pytest.mark.asyncio
 async def test_consume_until_message(
     event_consumer: MagicMock,
@@ -164,12 +172,14 @@ async def test_consume_until_message(
         ),
     ]
     cursor = 0
+
     async def mock_dequeue() -> Any:
         nonlocal cursor
         if cursor < len(events):
             event = events[cursor]
             cursor += 1
             return event
+
     mock_event_queue.dequeue_event = mock_dequeue
     consumed_events: list[Any] = []
     async for event in event_consumer.consume_all():
@@ -180,6 +190,7 @@ async def mock_dequeue() -> Any:
     assert consumed_events[2] == events[2]
     assert mock_event_queue.task_done.call_count == 3
 
+
 @pytest.mark.asyncio
 async def test_consume_message_events(
     event_consumer: MagicMock,
@@ -190,12 +201,14 @@ async def test_consume_message_events(
         Message(**MESSAGE_PAYLOAD, final=True),
     ]
     cursor = 0
+
     async def mock_dequeue() -> Any:
         nonlocal cursor
         if cursor < len(events):
             event = events[cursor]
             cursor += 1
             return event
+
     mock_event_queue.dequeue_event = mock_dequeue
     consumed_events: list[Any] = []
     async for event in event_consumer.consume_all():

tests/server/events/test_event_queue.py

@@ -1,4 +1,3 @@
-
 import asyncio
 import pytest
 from a2a.server.events.event_queue import EventQueue
@@ -17,6 +16,7 @@
     TaskNotFoundError,
 )
 from typing import Any
+
 MINIMAL_TASK: dict[str, Any] = {
     'id': '123',
     'contextId': 'session-xyz',
@@ -28,30 +28,40 @@
     'parts': [{'text': 'test message'}],
     'messageId': '111',
 }
+
+
 @pytest.fixture
 def event_queue() -> EventQueue:
     return EventQueue()
+
+
 @pytest.mark.asyncio
 async def test_enqueue_and_dequeue_event(event_queue: EventQueue) -> None:
     """Test that an event can be enqueued and dequeued."""
     event = Message(**MESSAGE_PAYLOAD)
     event_queue.enqueue_event(event)
     dequeued_event = await event_queue.dequeue_event()
     assert dequeued_event == event
+
+
 @pytest.mark.asyncio
 async def test_dequeue_event_no_wait(event_queue: EventQueue) -> None:
     """Test dequeue_event with no_wait=True."""
     event = Task(**MINIMAL_TASK)
     event_queue.enqueue_event(event)
     dequeued_event = await event_queue.dequeue_event(no_wait=True)
     assert dequeued_event == event
+
+
 @pytest.mark.asyncio
 async def test_dequeue_event_empty_queue_no_wait(
     event_queue: EventQueue,
 ) -> None:
     """Test dequeue_event with no_wait=True when the queue is empty."""
     with pytest.raises(asyncio.QueueEmpty):
         await event_queue.dequeue_event(no_wait=True)
+
+
 @pytest.mark.asyncio
 async def test_dequeue_event_wait(event_queue: EventQueue) -> None:
     """Test dequeue_event with the default wait behavior."""
@@ -64,6 +74,8 @@ async def test_dequeue_event_wait(event_queue: EventQueue) -> None:
     event_queue.enqueue_event(event)
     dequeued_event = await event_queue.dequeue_event()
     assert dequeued_event == event
+
+
 @pytest.mark.asyncio
 async def test_task_done(event_queue: EventQueue) -> None:
     """Test the task_done method."""
@@ -75,6 +87,8 @@ async def test_task_done(event_queue: EventQueue) -> None:
     event_queue.enqueue_event(event)
     _ = await event_queue.dequeue_event()
     event_queue.task_done()
+
+
 @pytest.mark.asyncio
 async def test_enqueue_different_event_types(
     event_queue: EventQueue,
@@ -88,4 +102,3 @@ async def test_enqueue_different_event_types(
         event_queue.enqueue_event(event)
         dequeued_event = await event_queue.dequeue_event()
         assert dequeued_event == event
-

tests/server/tasks/test_inmemory_task_store.py

@@ -11,6 +11,7 @@
     'type': 'task',
 }
 
+
 @pytest.mark.asyncio
 async def test_in_memory_task_store_save_and_get() -> None:
     """Test saving and retrieving a task from the in-memory store."""
@@ -20,13 +21,15 @@ async def test_in_memory_task_store_save_and_get() -> None:
     retrieved_task = await store.get(MINIMAL_TASK['id'])
     assert retrieved_task == task
 
+
 @pytest.mark.asyncio
 async def test_in_memory_task_store_get_nonexistent() -> None:
     """Test retrieving a non-existent task."""
     store = InMemoryTaskStore()
     retrieved_task = await store.get('nonexistent')
     assert retrieved_task is None
 
+
 @pytest.mark.asyncio
 async def test_in_memory_task_store_delete() -> None:
     """Test deleting a task from the store."""
@@ -37,9 +40,9 @@ async def test_in_memory_task_store_delete() -> None:
     retrieved_task = await store.get(MINIMAL_TASK['id'])
     assert retrieved_task is None
 
+
 @pytest.mark.asyncio
 async def test_in_memory_task_store_delete_nonexistent() -> None:
     """Test deleting a non-existent task."""
     store = InMemoryTaskStore()
     await store.delete('nonexistent')
-