Standardize "py" -> "python" in code blocks with pre-commit (#217)

Author: sydney-runkle

README.md

@@ -49,7 +49,7 @@ PydanticAI is in early beta, the API is still subject to change and there's a lo
 
 Here's a minimal example of PydanticAI:
 
-```py
+```python
 from pydantic_ai import Agent
 
 # Define a very simple agent including the model to use, you can also set the model when running the agent.
@@ -80,7 +80,7 @@ Here is a concise example using PydanticAI to build a support agent for a bank:
 
 **(Better documented example [in the docs](https://ai.pydantic.dev/#tools-dependency-injection-example))**
 
-```py
+```python
 from dataclasses import dataclass
 
 from pydantic import BaseModel, Field

docs/agents.md

@@ -17,7 +17,7 @@ In typing terms, agents are generic in their dependency and result types, e.g.,
 
 Here's a toy example of an agent that simulates a roulette wheel:
 
-```py title="roulette_wheel.py"
+```python {title="roulette_wheel.py"}
 from pydantic_ai import Agent, RunContext
 
 roulette_agent = Agent(  # (1)!
@@ -67,7 +67,7 @@ There are three ways to run an agent:
 
 Here's a simple example demonstrating all three:
 
-```py title="run_agent.py"
+```python {title="run_agent.py"}
 from pydantic_ai import Agent
 
 agent = Agent('openai:gpt-4o')
@@ -95,7 +95,7 @@ You can also pass messages from previous runs to continue a conversation or prov
     to manage conflicts between event loops that occur between jupyter's event loops and `pydantic-ai`'s.
 
     Before you execute any agent runs, do the following:
-    ```py {test="skip", lint="skip"}
+    ```python {test="skip" lint="skip"}
     import nest_asyncio
     nest_asyncio.apply()
     ```
@@ -106,7 +106,7 @@ An agent **run** might represent an entire conversation — there's no limit to
 
 Here's an example of a conversation comprised of multiple runs:
 
-```py title="conversation_example.py" hl_lines="13"
+```python {title="conversation_example.py" hl_lines="13"}
 from pydantic_ai import Agent
 
 agent = Agent('openai:gpt-4o')
@@ -144,7 +144,7 @@ In particular, agents are generic in both the type of their dependencies and the
 
 Consider the following script with type mistakes:
 
-```py title="type_mistakes.py" hl_lines="18 28"
+```python {title="type_mistakes.py" hl_lines="18 28"}
 from dataclasses import dataclass
 
 from pydantic_ai import Agent, RunContext
@@ -203,7 +203,7 @@ You can add both to a single agent; they're appended in the order they're define
 
 Here's an example using both types of system prompts:
 
-```py title="system_prompts.py"
+```python {title="system_prompts.py"}
 from datetime import date
 
 from pydantic_ai import Agent, RunContext
@@ -258,7 +258,7 @@ There are a number of ways to register tools with an agent:
 
 Here's an example using both:
 
-```py title="dice_game.py"
+```python {title="dice_game.py"}
 import random
 
 from pydantic_ai import Agent, RunContext
@@ -301,7 +301,7 @@ _(This example is complete, it can be run "as is")_
 
 Let's print the messages from that game to see what happened:
 
-```py title="dice_game_messages.py"
+```python {title="dice_game_messages.py"}
 from dice_game import dice_result
 
 print(dice_result.all_messages())
@@ -399,7 +399,7 @@ sequenceDiagram
 
 As well as using the decorators, we can register tools via the `tools` argument to the [`Agent` constructor][pydantic_ai.Agent.__init__]. This is useful when you want to re-use tools, and can also give more fine-grained control over the tools.
 
-```py title="dice_game_tool_kwarg.py"
+```python {title="dice_game_tool_kwarg.py"}
 import random
 
 from pydantic_ai import Agent, RunContext, Tool
@@ -452,7 +452,7 @@ Even better, PydanticAI extracts the docstring from functions and (thanks to [gr
 
 To demonstrate a tool's schema, here we use [`FunctionModel`][pydantic_ai.models.function.FunctionModel] to print the schema a model would receive:
 
-```py title="tool_schema.py"
+```python {title="tool_schema.py"}
 from pydantic_ai import Agent
 from pydantic_ai.messages import Message, ModelAnyResponse, ModelTextResponse
 from pydantic_ai.models.function import AgentInfo, FunctionModel
@@ -509,7 +509,7 @@ If a tool has a single parameter that can be represented as an object in JSON sc
 
 Here's an example, we use [`TestModel.agent_model_function_tools`][pydantic_ai.models.test.TestModel.agent_model_function_tools] to inspect the tool schema that would be passed to the model.
 
-```py title="single_parameter_tool.py"
+```python {title="single_parameter_tool.py"}
 from pydantic import BaseModel
 
 from pydantic_ai import Agent
@@ -577,7 +577,7 @@ Here's a simple `prepare` method that only includes the tool if the value of the
 
 As with the previous example, we use [`TestModel`][pydantic_ai.models.test.TestModel] to demonstrate the behavior without calling a real model.
 
-```py title="tool_only_if_42.py"
+```python {title="tool_only_if_42.py"}
 from typing import Union
 
 from pydantic_ai import Agent, RunContext
@@ -612,7 +612,7 @@ Here's a more complex example where we change the description of the `name` para
 
 For the sake of variation, we create this tool using the [`Tool`][pydantic_ai.tools.Tool] dataclass.
 
-```py title="customize_name.py"
+```python {title="customize_name.py"}
 from __future__ import annotations
 
 from typing import Literal
@@ -678,7 +678,7 @@ You can also raise [`ModelRetry`][pydantic_ai.exceptions.ModelRetry] from within
 
 Here's an example:
 
-```py title="tool_retry.py"
+```python {title="tool_retry.py"}
 from fake_database import DatabaseConn
 from pydantic import BaseModel
 
@@ -726,7 +726,7 @@ If models behave unexpectedly (e.g., the retry limit is exceeded, or their API r
 
 In these cases, [`agent.last_run_messages`][pydantic_ai.Agent.last_run_messages] can be used to access the messages exchanged during the run to help diagnose the issue.
 
-```py
+```python
 from pydantic_ai import Agent, ModelRetry, UnexpectedModelBehavior
 
 agent = Agent('openai:gpt-4o')

docs/api/models/ollama.md

@@ -8,14 +8,14 @@ For details on how to set up authentication with this model, see [model configur
 
 With `ollama` installed, you can run the server with the model you want to use:
 
-```bash title="terminal-run-ollama"
+```bash {title="terminal-run-ollama"}
 ollama run llama3.2
 ```
 (this will pull the `llama3.2` model if you don't already have it downloaded)
 
 Then run your code, here's a minimal example:
 
-```py title="ollama_example.py"
+```python {title="ollama_example.py"}
 from pydantic import BaseModel
 
 from pydantic_ai import Agent
@@ -37,7 +37,7 @@ print(result.cost())
 
 ## Example using a remote server
 
-```py title="ollama_example_with_remote_server.py"
+```python {title="ollama_example_with_remote_server.py"}
 from pydantic import BaseModel
 
 from pydantic_ai import Agent

docs/api/models/vertexai.md

@@ -19,7 +19,7 @@ see [model configuration for Gemini via VertexAI](../../install.md#gemini-via-ve
 
 With the default google project already configured in your environment using "application default credentials":
 
-```py title="vertex_example_env.py"
+```python {title="vertex_example_env.py"}
 from pydantic_ai import Agent
 from pydantic_ai.models.vertexai import VertexAIModel
 
@@ -32,7 +32,7 @@ print(result.data)
 
 Or using a service account JSON file:
 
-```py title="vertex_example_service_account.py"
+```python {title="vertex_example_service_account.py"}
 from pydantic_ai import Agent
 from pydantic_ai.models.vertexai import VertexAIModel
 

docs/dependencies.md

@@ -12,7 +12,7 @@ Here's an example of defining an agent that requires dependencies.
 
 (**Note:** dependencies aren't actually used in this example, see [Accessing Dependencies](#accessing-dependencies) below)
 
-```py title="unused_dependencies.py"
+```python {title="unused_dependencies.py"}
 from dataclasses import dataclass
 
 import httpx
@@ -54,7 +54,7 @@ _(This example is complete, it can be run "as is")_
 Dependencies are accessed through the [`RunContext`][pydantic_ai.tools.RunContext] type, this should be the first parameter of system prompt functions etc.
 
 
-```py title="system_prompt_dependencies.py" hl_lines="20-27"
+```python {title="system_prompt_dependencies.py" hl_lines="20-27"}
 from dataclasses import dataclass
 
 import httpx
@@ -112,7 +112,7 @@ to use `async` methods where dependencies perform IO, although synchronous depen
 
 Here's the same example as above, but with a synchronous dependency:
 
-```py title="sync_dependencies.py"
+```python {title="sync_dependencies.py"}
 from dataclasses import dataclass
 
 import httpx
@@ -160,7 +160,7 @@ _(This example is complete, it can be run "as is")_
 
 As well as system prompts, dependencies can be used in [tools](agents.md#function-tools) and [result validators](results.md#result-validators-functions).
 
-```py title="full_example.py" hl_lines="27-35 38-48"
+```python {title="full_example.py" hl_lines="27-35 38-48"}
 from dataclasses import dataclass
 
 import httpx
@@ -233,7 +233,7 @@ while calling application code which in turn calls the agent.
 
 This is done via the [`override`][pydantic_ai.Agent.override] method on the agent.
 
-```py title="joke_app.py"
+```python {title="joke_app.py"}
 from dataclasses import dataclass
 
 import httpx
@@ -275,7 +275,7 @@ async def application_code(prompt: str) -> str:  # (3)!
 3. Application code that calls the agent, in a real application this might be an API endpoint.
 4. Call the agent from within the application code, in a real application this call might be deep within a call stack. Note `app_deps` here will NOT be used when deps are overridden.
 
-```py title="test_joke_app.py" hl_lines="10-12"
+```python {title="test_joke_app.py" hl_lines="10-12"}
 from joke_app import MyDeps, application_code, joke_agent
 
 
@@ -300,7 +300,7 @@ async def test_application_code():
 
 Since dependencies can be any python type, and agents are just python objects, agents can be dependencies of other agents.
 
-```py title="agents_as_dependencies.py"
+```python {title="agents_as_dependencies.py"}
 from dataclasses import dataclass
 
 from pydantic_ai import Agent, RunContext

docs/examples/bank-support.md

@@ -18,6 +18,6 @@ python/uv-run -m pydantic_ai_examples.bank_support
 
 ## Example Code
 
-```py title="bank_support.py"
+```python {title="bank_support.py"}
 #! pydantic_ai_examples/bank_support.py
 ```

docs/examples/chat-app.md

@@ -29,18 +29,18 @@ TODO screenshot.
 
 Python code that runs the chat app:
 
-```py title="chat_app.py"
+```python {title="chat_app.py"}
 #! pydantic_ai_examples/chat_app.py
 ```
 
 Simple HTML page to render the app:
 
-```html title="chat_app.html"
+```html {title="chat_app.html"}
 #! pydantic_ai_examples/chat_app.html
 ```
 
 TypeScript to handle rendering the messages, to keep this simple (and at the risk of offending frontend developers) the typescript code is passed to the browser as plain text and transpiled in the browser.
 
-```ts title="chat_app.ts"
+```ts {title="chat_app.ts"}
 #! pydantic_ai_examples/chat_app.ts
 ```

docs/examples/pydantic-model.md

@@ -25,6 +25,6 @@ PYDANTIC_AI_MODEL=gemini-1.5-pro python/uv-run -m pydantic_ai_examples.pydantic_
 
 ## Example Code
 
-```py title="pydantic_model.py"
+```python {title="pydantic_model.py"}
 #! pydantic_ai_examples/pydantic_model.py
 ```

docs/examples/rag.md

@@ -44,6 +44,6 @@ python/uv-run -m pydantic_ai_examples.rag search "How do I configure logfire to
 
 ## Example Code
 
-```py title="rag.py"
+```python {title="rag.py"}
 #! pydantic_ai_examples/rag.py
 ```

docs/examples/sql-gen.md

@@ -34,6 +34,6 @@ This model uses `gemini-1.5-flash` by default since Gemini is good at single sho
 
 ## Example Code
 
-```py title="sql_gen.py"
+```python {title="sql_gen.py"}
 #! pydantic_ai_examples/sql_gen.py
 ```