pydantic-ai-examples 0.3.5__tar.gz → 0.3.7__tar.gz

{pydantic_ai_examples-0.3.5 → pydantic_ai_examples-0.3.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-examples
-Version: 0.3.5
+Version: 0.3.7
 Summary: Examples of how to use PydanticAI and what it can do.
 Author-email: Samuel Colvin <samuel@pydantic.dev>
 License-Expression: MIT
@@ -32,8 +32,8 @@ Requires-Dist: gradio>=5.9.0; python_version > '3.9'
 Requires-Dist: logfire[asyncpg,fastapi,httpx,sqlite3]>=2.6
 Requires-Dist: mcp[cli]>=1.4.1; python_version >= '3.10'
 Requires-Dist: modal>=1.0.4
-Requires-Dist: pydantic-ai-slim[anthropic,groq,openai,vertexai]==0.3.5
-Requires-Dist: pydantic-evals==0.3.5
+Requires-Dist: pydantic-ai-slim[anthropic,groq,openai,vertexai]==0.3.7
+Requires-Dist: pydantic-evals==0.3.7
 Requires-Dist: python-multipart>=0.0.17
 Requires-Dist: rich>=13.9.2
 Requires-Dist: uvicorn>=0.32.0

{pydantic_ai_examples-0.3.5 → pydantic_ai_examples-0.3.7}/pydantic_ai_examples/stream_whales.py

@@ -11,7 +11,7 @@ Run with:
 from typing import Annotated
 
 import logfire
-from pydantic import Field, ValidationError
+from pydantic import Field
 from rich.console import Console
 from rich.live import Live
 from rich.table import Table
@@ -51,20 +51,7 @@ async def main():
         ) as result:
             console.print('Response:', style='green')
 
-            async for message, last in result.stream_structured(debounce_by=0.01):
-                try:
-                    whales = await result.validate_structured_output(
-                        message, allow_partial=not last
-                    )
-                except ValidationError as exc:
-                    if all(
-                        e['type'] == 'missing' and e['loc'] == ('response',)
-                        for e in exc.errors()
-                    ):
-                        continue
-                    else:
-                        raise
-
+            async for whales in result.stream(debounce_by=0.01):
                 table = Table(
                     title='Species of Whale',
                     caption='Streaming Structured responses from GPT-4',

pydantic_ai_examples-0.3.7/pydantic_ai_examples/weather_agent.py

@@ -0,0 +1,105 @@
+"""Example of PydanticAI with multiple tools which the LLM needs to call in turn to answer a question.
+
+In this case the idea is a "weather" agent — the user can ask for the weather in multiple cities,
+the agent will use the `get_lat_lng` tool to get the latitude and longitude of the locations, then use
+the `get_weather` tool to get the weather.
+
+Run with:
+
+    uv run -m pydantic_ai_examples.weather_agent
+"""
+
+from __future__ import annotations as _annotations
+
+import asyncio
+from dataclasses import dataclass
+from typing import Any
+
+import logfire
+from httpx import AsyncClient
+from pydantic import BaseModel
+
+from pydantic_ai import Agent, RunContext
+
+# 'if-token-present' means nothing will be sent (and the example will work) if you don't have logfire configured
+logfire.configure(send_to_logfire='if-token-present')
+logfire.instrument_pydantic_ai()
+
+
+@dataclass
+class Deps:
+    client: AsyncClient
+
+
+weather_agent = Agent(
+    'openai:gpt-4.1-mini',
+    # 'Be concise, reply with one sentence.' is enough for some models (like openai) to use
+    # the below tools appropriately, but others like anthropic and gemini require a bit more direction.
+    instructions='Be concise, reply with one sentence.',
+    deps_type=Deps,
+    retries=2,
+)
+
+
+class LatLng(BaseModel):
+    lat: float
+    lng: float
+
+
+@weather_agent.tool
+async def get_lat_lng(ctx: RunContext[Deps], location_description: str) -> LatLng:
+    """Get the latitude and longitude of a location.
+
+    Args:
+        ctx: The context.
+        location_description: A description of a location.
+    """
+    # NOTE: the response here will be random, and is not related to the location description.
+    r = await ctx.deps.client.get(
+        'https://demo-endpoints.pydantic.workers.dev/latlng',
+        params={'location': location_description},
+    )
+    r.raise_for_status()
+    return LatLng.model_validate_json(r.content)
+
+
+@weather_agent.tool
+async def get_weather(ctx: RunContext[Deps], lat: float, lng: float) -> dict[str, Any]:
+    """Get the weather at a location.
+
+    Args:
+        ctx: The context.
+        lat: Latitude of the location.
+        lng: Longitude of the location.
+    """
+    # NOTE: the responses here will be random, and are not related to the lat and lng.
+    temp_response, descr_response = await asyncio.gather(
+        ctx.deps.client.get(
+            'https://demo-endpoints.pydantic.workers.dev/number',
+            params={'min': 10, 'max': 30},
+        ),
+        ctx.deps.client.get(
+            'https://demo-endpoints.pydantic.workers.dev/weather',
+            params={'lat': lat, 'lng': lng},
+        ),
+    )
+    temp_response.raise_for_status()
+    descr_response.raise_for_status()
+    return {
+        'temperature': f'{temp_response.text} °C',
+        'description': descr_response.text,
+    }
+
+
+async def main():
+    async with AsyncClient() as client:
+        logfire.instrument_httpx(client, capture_all=True)
+        deps = Deps(client=client)
+        result = await weather_agent.run(
+            'What is the weather like in London and in Wiltshire?', deps=deps
+        )
+        print('Response:', result.output)
+
+
+if __name__ == '__main__':
+    asyncio.run(main())

{pydantic_ai_examples-0.3.5 → pydantic_ai_examples-0.3.7}/pydantic_ai_examples/weather_agent_gradio.py

@@ -1,7 +1,6 @@
 from __future__ import annotations as _annotations
 
 import json
-import os
 
 from httpx import AsyncClient
 
@@ -18,10 +17,7 @@ except ImportError as e:
 TOOL_TO_DISPLAY_NAME = {'get_lat_lng': 'Geocoding API', 'get_weather': 'Weather API'}
 
 client = AsyncClient()
-weather_api_key = os.getenv('WEATHER_API_KEY')
-# create a free API key at https://geocode.maps.co/
-geo_api_key = os.getenv('GEO_API_KEY')
-deps = Deps(client=client, weather_api_key=weather_api_key, geo_api_key=geo_api_key)
+deps = Deps(client=client)
 
 
 async def stream_from_agent(prompt: str, chatbot: list[dict], past_messages: list):

pydantic_ai_examples-0.3.5/pydantic_ai_examples/weather_agent.py

@@ -1,158 +0,0 @@
-"""Example of PydanticAI with multiple tools which the LLM needs to call in turn to answer a question.
-
-In this case the idea is a "weather" agent — the user can ask for the weather in multiple cities,
-the agent will use the `get_lat_lng` tool to get the latitude and longitude of the locations, then use
-the `get_weather` tool to get the weather.
-
-Run with:
-
-    uv run -m pydantic_ai_examples.weather_agent
-"""
-
-from __future__ import annotations as _annotations
-
-import asyncio
-import os
-import urllib.parse
-from dataclasses import dataclass
-from typing import Any
-
-import logfire
-from devtools import debug
-from httpx import AsyncClient
-
-from pydantic_ai import Agent, ModelRetry, RunContext
-
-# 'if-token-present' means nothing will be sent (and the example will work) if you don't have logfire configured
-logfire.configure(send_to_logfire='if-token-present')
-logfire.instrument_pydantic_ai()
-
-
-@dataclass
-class Deps:
-    client: AsyncClient
-    weather_api_key: str | None
-    geo_api_key: str | None
-
-
-weather_agent = Agent(
-    'openai:gpt-4o',
-    # 'Be concise, reply with one sentence.' is enough for some models (like openai) to use
-    # the below tools appropriately, but others like anthropic and gemini require a bit more direction.
-    instructions=(
-        'Be concise, reply with one sentence.'
-        'Use the `get_lat_lng` tool to get the latitude and longitude of the locations, '
-        'then use the `get_weather` tool to get the weather.'
-    ),
-    deps_type=Deps,
-    retries=2,
-)
-
-
-@weather_agent.tool
-async def get_lat_lng(
-    ctx: RunContext[Deps], location_description: str
-) -> dict[str, float]:
-    """Get the latitude and longitude of a location.
-
-    Args:
-        ctx: The context.
-        location_description: A description of a location.
-    """
-    if ctx.deps.geo_api_key is None:
-        # if no API key is provided, return a dummy response (London)
-        return {'lat': 51.1, 'lng': -0.1}
-
-    params = {'access_token': ctx.deps.geo_api_key}
-    loc = urllib.parse.quote(location_description)
-    r = await ctx.deps.client.get(
-        f'https://api.mapbox.com/geocoding/v5/mapbox.places/{loc}.json', params=params
-    )
-    r.raise_for_status()
-    data = r.json()
-
-    if features := data['features']:
-        lat, lng = features[0]['center']
-        return {'lat': lat, 'lng': lng}
-    else:
-        raise ModelRetry('Could not find the location')
-
-
-@weather_agent.tool
-async def get_weather(ctx: RunContext[Deps], lat: float, lng: float) -> dict[str, Any]:
-    """Get the weather at a location.
-
-    Args:
-        ctx: The context.
-        lat: Latitude of the location.
-        lng: Longitude of the location.
-    """
-    if ctx.deps.weather_api_key is None:
-        # if no API key is provided, return a dummy response
-        return {'temperature': '21 °C', 'description': 'Sunny'}
-
-    params = {
-        'apikey': ctx.deps.weather_api_key,
-        'location': f'{lat},{lng}',
-        'units': 'metric',
-    }
-    with logfire.span('calling weather API', params=params) as span:
-        r = await ctx.deps.client.get(
-            'https://api.tomorrow.io/v4/weather/realtime', params=params
-        )
-        r.raise_for_status()
-        data = r.json()
-        span.set_attribute('response', data)
-
-    values = data['data']['values']
-    # https://docs.tomorrow.io/reference/data-layers-weather-codes
-    code_lookup = {
-        1000: 'Clear, Sunny',
-        1100: 'Mostly Clear',
-        1101: 'Partly Cloudy',
-        1102: 'Mostly Cloudy',
-        1001: 'Cloudy',
-        2000: 'Fog',
-        2100: 'Light Fog',
-        4000: 'Drizzle',
-        4001: 'Rain',
-        4200: 'Light Rain',
-        4201: 'Heavy Rain',
-        5000: 'Snow',
-        5001: 'Flurries',
-        5100: 'Light Snow',
-        5101: 'Heavy Snow',
-        6000: 'Freezing Drizzle',
-        6001: 'Freezing Rain',
-        6200: 'Light Freezing Rain',
-        6201: 'Heavy Freezing Rain',
-        7000: 'Ice Pellets',
-        7101: 'Heavy Ice Pellets',
-        7102: 'Light Ice Pellets',
-        8000: 'Thunderstorm',
-    }
-    return {
-        'temperature': f'{values["temperatureApparent"]:0.0f}°C',
-        'description': code_lookup.get(values['weatherCode'], 'Unknown'),
-    }
-
-
-async def main():
-    async with AsyncClient() as client:
-        logfire.instrument_httpx(client, capture_all=True)
-        # create a free API key at https://www.tomorrow.io/weather-api/
-        weather_api_key = os.getenv('WEATHER_API_KEY')
-        # create a free API key at https://www.mapbox.com/
-        geo_api_key = os.getenv('GEO_API_KEY')
-        deps = Deps(
-            client=client, weather_api_key=weather_api_key, geo_api_key=geo_api_key
-        )
-        result = await weather_agent.run(
-            'What is the weather like in London and in Wiltshire?', deps=deps
-        )
-        debug(result)
-        print('Response:', result.output)
-
-
-if __name__ == '__main__':
-    asyncio.run(main())