Auto-sort imports and require single quotes in docs examples

Author: DouweM

docs/ag-ui.md

@@ -43,24 +43,24 @@ This example uses [`run_ag_ui()`][pydantic_ai.ag_ui.run_ag_ui] and performs its
 This can be modified to work with any web framework.
 
 ```py {title="run_ag_ui.py"}
+import json
+from http import HTTPStatus
+
 from ag_ui.core import RunAgentInput
 from fastapi import FastAPI
-from http import HTTPStatus
 from fastapi.requests import Request
 from fastapi.responses import Response, StreamingResponse
 from pydantic import ValidationError
-import json
 
 from pydantic_ai import Agent
-from pydantic_ai.ag_ui import run_ag_ui, SSE_CONTENT_TYPE
-
+from pydantic_ai.ag_ui import SSE_CONTENT_TYPE, run_ag_ui
 
 agent = Agent('openai:gpt-4.1', instructions='Be fun!')
 
 app = FastAPI()
 
 
-@app.post("/")
+@app.post('/')
 async def run_agent(request: Request) -> Response:
     accept = request.headers.get('accept', SSE_CONTENT_TYPE)
     try:
@@ -97,12 +97,11 @@ from starlette.responses import Response
 from pydantic_ai import Agent
 from pydantic_ai.ag_ui import handle_ag_ui_request
 
-
 agent = Agent('openai:gpt-4.1', instructions='Be fun!')
 
 app = FastAPI()
 
-@app.post("/")
+@app.post('/')
 async def run_agent(request: Request) -> Response:
     return await handle_ag_ui_request(agent, request)
 ```

docs/agents.md

@@ -214,10 +214,10 @@ Unlike `run_stream()`, it always runs the agent graph to completion even if text
     To get the best of both worlds, at the expense of some additional complexity, you can use [`agent.iter()`][pydantic_ai.agent.AbstractAgent.iter] as described in the next section, which lets you [iterate over the agent graph](#iterating-over-an-agents-graph) and [stream both events and output](#streaming-all-events-and-output) at every step.
 
 ```python {title="run_events.py" requires="run_stream_events.py"}
-from run_stream_events import weather_agent, event_stream_handler, output_messages
-
 import asyncio
 
+from run_stream_events import event_stream_handler, output_messages, weather_agent
+
 
 async def main():
     user_prompt = 'What will the weather be like in Paris on Tuesday?'

docs/cli.md

@@ -115,7 +115,13 @@ Both `Agent.to_cli()` and `Agent.to_cli_sync()` support a `message_history` para
 
 ```python {title="agent_with_history.py" test="skip"}
 from pydantic_ai import Agent
-from pydantic_ai.messages import ModelMessage, ModelRequest, ModelResponse, UserPromptPart, TextPart
+from pydantic_ai.messages import (
+    ModelMessage,
+    ModelRequest,
+    ModelResponse,
+    TextPart,
+    UserPromptPart,
+)
 
 agent = Agent('openai:gpt-4.1')
 

docs/direct.md

@@ -40,8 +40,9 @@ You can also use the direct API to work with function/tool calling.
 Even here we can use Pydantic to generate the JSON schema for the tool:
 
 ```python
+from typing import Literal
+
 from pydantic import BaseModel
-from typing_extensions import Literal
 
 from pydantic_ai import ToolDefinition
 from pydantic_ai.direct import model_request

docs/evals.md

@@ -58,10 +58,9 @@ Pydantic Evals includes several built-in evaluators and allows you to create cus
 ```python {title="simple_eval_evaluator.py" requires="simple_eval_dataset.py"}
 from dataclasses import dataclass
 
-from simple_eval_dataset import dataset
-
 from pydantic_evals.evaluators import Evaluator, EvaluatorContext
 from pydantic_evals.evaluators.common import IsInstance
+from simple_eval_dataset import dataset
 
 dataset.add_evaluator(IsInstance(type_name='str'))  # (1)!
 
@@ -620,7 +619,6 @@ You can also write datasets as JSON files:
 from pathlib import Path
 
 from generate_dataset_example import AnswerOutput, MetadataType, QuestionInputs
-
 from pydantic_evals import Dataset
 from pydantic_evals.generation import generate_dataset
 

docs/mcp/client.md

@@ -244,29 +244,29 @@ parameter that lets you pass your own pre-configured
 [`httpx.AsyncClient`](https://www.python-httpx.org/async/).
 
 ```python {title="mcp_custom_tls_client.py"}
-import httpx
 import ssl
 
+import httpx
+
 from pydantic_ai import Agent
 from pydantic_ai.mcp import MCPServerSSE
 
-
 # Trust an internal / self-signed CA
-ssl_ctx = ssl.create_default_context(cafile="/etc/ssl/private/my_company_ca.pem")
+ssl_ctx = ssl.create_default_context(cafile='/etc/ssl/private/my_company_ca.pem')
 
 # OPTIONAL: if the server requires **mutual TLS** load your client certificate
-ssl_ctx.load_cert_chain(certfile="/etc/ssl/certs/client.crt", keyfile="/etc/ssl/private/client.key",)
+ssl_ctx.load_cert_chain(certfile='/etc/ssl/certs/client.crt', keyfile='/etc/ssl/private/client.key',)
 
 http_client = httpx.AsyncClient(
     verify=ssl_ctx,
     timeout=httpx.Timeout(10.0),
 )
 
 server = MCPServerSSE(
-    url="http://localhost:3001/sse",
+    url='http://localhost:3001/sse',
     http_client=http_client,  # (1)!
 )
-agent = Agent("openai:gpt-4o", toolsets=[server])
+agent = Agent('openai:gpt-4o', toolsets=[server])
 
 async def main():
     async with agent:

docs/mcp/server.md

@@ -102,7 +102,12 @@ from typing import Any
 from mcp import ClientSession, StdioServerParameters
 from mcp.client.stdio import stdio_client
 from mcp.shared.context import RequestContext
-from mcp.types import CreateMessageRequestParams, CreateMessageResult, ErrorData, TextContent
+from mcp.types import (
+    CreateMessageRequestParams,
+    CreateMessageResult,
+    ErrorData,
+    TextContent,
+)
 
 
 async def sampling_callback(

docs/multi-agent-applications.md

@@ -22,7 +22,7 @@ You'll generally want to pass [`ctx.usage`][pydantic_ai.RunContext.usage] to the
     Agent delegation doesn't need to use the same model for each agent. If you choose to use different models within a run, calculating the monetary cost from the final [`result.usage()`][pydantic_ai.agent.AgentRunResult.usage] of the run will not be possible, but you can still use [`UsageLimits`][pydantic_ai.usage.UsageLimits] to avoid unexpected costs.
 
 ```python {title="agent_delegation_simple.py"}
-from pydantic_ai import Agent, RunContext,  UsageLimits
+from pydantic_ai import Agent, RunContext, UsageLimits
 
 joke_selection_agent = Agent(  # (1)!
     'openai:gpt-4o',
@@ -180,7 +180,7 @@ Here agents don't need to use the same deps.
 Here we show two agents used in succession, the first to find a flight and the second to extract the user's seat preference.
 
 ```python {title="programmatic_handoff.py"}
-from typing import Literal, Union
+from typing import Literal
 
 from pydantic import BaseModel, Field
 from rich.prompt import Prompt
@@ -197,9 +197,9 @@ class Failed(BaseModel):
     """Unable to find a satisfactory choice."""
 
 
-flight_search_agent = Agent[None, Union[FlightDetails, Failed]](  # (1)!
+flight_search_agent = Agent[None, FlightDetails | Failed](  # (1)!
     'openai:gpt-4o',
-    output_type=Union[FlightDetails, Failed],  # type: ignore
+    output_type=FlightDetails | Failed,  # type: ignore
     system_prompt=(
         'Use the "flight_search" tool to find a flight '
         'from the given origin to the given destination.'
@@ -210,7 +210,7 @@ flight_search_agent = Agent[None, Union[FlightDetails, Failed]](  # (1)!
 @flight_search_agent.tool  # (2)!
 async def flight_search(
     ctx: RunContext[None], origin: str, destination: str
-) -> Union[FlightDetails, None]:
+) -> FlightDetails | None:
     # in reality, this would call a flight search API or
     # use a browser to scrape a flight search website
     return FlightDetails(flight_number='AK456')
@@ -219,8 +219,8 @@ async def flight_search(
 usage_limits = UsageLimits(request_limit=15)  # (3)!
 
 
-async def find_flight(usage: RunUsage) -> Union[FlightDetails, None]:  # (4)!
-    message_history: Union[list[ModelMessage], None] = None
+async def find_flight(usage: RunUsage) -> FlightDetails | None:  # (4)!
+    message_history: list[ModelMessage] | None = None
     for _ in range(3):
         prompt = Prompt.ask(
             'Where would you like to fly from and to?',
@@ -245,9 +245,9 @@ class SeatPreference(BaseModel):
 
 
 # This agent is responsible for extracting the user's seat selection
-seat_preference_agent = Agent[None, Union[SeatPreference, Failed]](  # (5)!
+seat_preference_agent = Agent[None, SeatPreference | Failed](  # (5)!
     'openai:gpt-4o',
-    output_type=Union[SeatPreference, Failed],  # type: ignore
+    output_type=SeatPreference | Failed,  # type: ignore
     system_prompt=(
         "Extract the user's seat preference. "
         'Seats A and F are window seats. '
@@ -258,7 +258,7 @@ seat_preference_agent = Agent[None, Union[SeatPreference, Failed]](  # (5)!
 
 
 async def find_seat(usage: RunUsage) -> SeatPreference:  # (6)!
-    message_history: Union[list[ModelMessage], None] = None
+    message_history: list[ModelMessage] | None = None
     while True:
         answer = Prompt.ask('What seat would you like?')
 

docs/output.md

@@ -313,9 +313,8 @@ Native Output mode uses a model's native "Structured Outputs" feature (aka "JSON
 To use this mode, you can wrap the output type(s) in the [`NativeOutput`][pydantic_ai.output.NativeOutput] marker class that also lets you specify a `name` and `description` if the name and docstring of the type or function are not sufficient.
 
 ```python {title="native_output.py" requires="tool_output.py"}
-from tool_output import Fruit, Vehicle
-
 from pydantic_ai import Agent, NativeOutput
+from tool_output import Fruit, Vehicle
 
 agent = Agent(
     'openai:gpt-4o',
@@ -346,9 +345,9 @@ To use this mode, you can wrap the output type(s) in the [`PromptedOutput`][pyda
 
 ```python {title="prompted_output.py" requires="tool_output.py"}
 from pydantic import BaseModel
-from tool_output import Vehicle
 
 from pydantic_ai import Agent, PromptedOutput
+from tool_output import Vehicle
 
 
 class Device(BaseModel):
@@ -399,19 +398,19 @@ from pydantic_ai import Agent, StructuredDict
 
 HumanDict = StructuredDict(
     {
-        "type": "object",
-        "properties": {
-            "name": {"type": "string"},
-            "age": {"type": "integer"}
+        'type': 'object',
+        'properties': {
+            'name': {'type': 'string'},
+            'age': {'type': 'integer'}
         },
-        "required": ["name", "age"]
+        'required': ['name', 'age']
     },
-    name="Human",
-    description="A human with a name and age",
+    name='Human',
+    description='A human with a name and age',
 )
 
 agent = Agent('openai:gpt-4o', output_type=HumanDict)
-result = agent.run_sync("Create a person")
+result = agent.run_sync('Create a person')
 #> {'name': 'John Doe', 'age': 30}
 ```
 
@@ -546,7 +545,7 @@ Here's an example of streaming a user profile as it's built:
 ```python {title="streamed_user_profile.py" line_length="120"}
 from datetime import date
 
-from typing_extensions import TypedDict, NotRequired
+from typing_extensions import NotRequired, TypedDict
 
 from pydantic_ai import Agent