pydantic-ai-examples 0.1.2__py3-none-any.whl → 1.12.0__py3-none-any.whl

pydantic_ai_examples/slack_lead_qualifier/models.py

@@ -0,0 +1,46 @@
+from typing import Annotated, Any
+
+from annotated_types import Ge, Le
+from pydantic import BaseModel
+
+### [import-format_as_xml]
+from pydantic_ai import format_as_xml  ### [/import-format_as_xml]
+
+
+### [profile,profile-intro]
+class Profile(BaseModel):  ### [/profile-intro]
+    first_name: str | None = None
+    last_name: str | None = None
+    display_name: str | None = None
+    email: str  ### [/profile]
+
+    ### [profile-as_prompt]
+    def as_prompt(self) -> str:
+        return format_as_xml(self, root_tag='profile')  ### [/profile-as_prompt]
+
+
+### [analysis,analysis-intro]
+class Analysis(BaseModel):  ### [/analysis-intro]
+    profile: Profile
+    organization_name: str
+    organization_domain: str
+    job_title: str
+    relevance: Annotated[int, Ge(1), Le(5)]
+    """Estimated fit for Pydantic Logfire: 1 = low, 5 = high"""
+    summary: str
+    """One-sentence welcome note summarising who they are and how we might help"""  ### [/analysis]
+
+    ### [analysis-as_slack_blocks]
+    def as_slack_blocks(self, include_relevance: bool = False) -> list[dict[str, Any]]:
+        profile = self.profile
+        relevance = f'({self.relevance}/5)' if include_relevance else ''
+        return [
+            {
+                'type': 'markdown',
+                'text': f'[{profile.display_name}](mailto:{profile.email}), {self.job_title} at [**{self.organization_name}**](https://{self.organization_domain}) {relevance}',
+            },
+            {
+                'type': 'markdown',
+                'text': self.summary,
+            },
+        ]  ### [/analysis-as_slack_blocks]

pydantic_ai_examples/slack_lead_qualifier/slack.py

@@ -0,0 +1,30 @@
+import os
+from typing import Any
+
+import httpx
+import logfire
+
+### [send_slack_message]
+API_KEY = os.getenv('SLACK_API_KEY')
+assert API_KEY, 'SLACK_API_KEY is not set'
+
+
+@logfire.instrument('Send Slack message')
+async def send_slack_message(channel: str, blocks: list[dict[str, Any]]):
+    client = httpx.AsyncClient()
+    response = await client.post(
+        'https://slack.com/api/chat.postMessage',
+        json={
+            'channel': channel,
+            'blocks': blocks,
+        },
+        headers={
+            'Authorization': f'Bearer {API_KEY}',
+        },
+        timeout=5,
+    )
+    response.raise_for_status()
+    result = response.json()
+    if not result.get('ok', False):
+        error = result.get('error', 'Unknown error')
+        raise Exception(f'Failed to send to Slack: {error}')  ### [/send_slack_message]

pydantic_ai_examples/slack_lead_qualifier/store.py

@@ -0,0 +1,31 @@
+import logfire
+
+### [import-modal]
+import modal  ### [/import-modal]
+
+from .models import Analysis
+
+
+### [analysis_store]
+class AnalysisStore:
+    @classmethod
+    @logfire.instrument('Add analysis to store')
+    async def add(cls, analysis: Analysis):
+        await cls._get_store().put.aio(analysis.profile.email, analysis.model_dump())
+
+    @classmethod
+    @logfire.instrument('List analyses from store')
+    async def list(cls) -> list[Analysis]:
+        return [
+            Analysis.model_validate(analysis)
+            async for analysis in cls._get_store().values.aio()
+        ]
+
+    @classmethod
+    @logfire.instrument('Clear analyses from store')
+    async def clear(cls):
+        await cls._get_store().clear.aio()
+
+    @classmethod
+    def _get_store(cls) -> modal.Dict:
+        return modal.Dict.from_name('analyses', create_if_missing=True)  # type: ignore ### [/analysis_store]

pydantic_ai_examples/sql_gen.py

@@ -1,4 +1,4 @@
-"""Example demonstrating how to use PydanticAI to generate SQL queries based on user input.
+"""Example demonstrating how to use Pydantic AI to generate SQL queries based on user input.
 
 Run postgres with:
 
@@ -16,20 +16,20 @@ from collections.abc import AsyncGenerator
 from contextlib import asynccontextmanager
 from dataclasses import dataclass
 from datetime import date
-from typing import Annotated, Any, Union
+from typing import Annotated, Any, TypeAlias
 
 import asyncpg
 import logfire
 from annotated_types import MinLen
 from devtools import debug
 from pydantic import BaseModel, Field
-from typing_extensions import TypeAlias
 
 from pydantic_ai import Agent, ModelRetry, RunContext, format_as_xml
 
 # '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_asyncpg()
+logfire.instrument_pydantic_ai()
 
 DB_SCHEMA = """
 CREATE TABLE records (
@@ -90,13 +90,12 @@ class InvalidRequest(BaseModel):
     error_message: str
 
 
-Response: TypeAlias = Union[Success, InvalidRequest]
-agent: Agent[Deps, Response] = Agent(
-    'google-gla:gemini-1.5-flash',
+Response: TypeAlias = Success | InvalidRequest
+agent = Agent[Deps, Response](
+    'google-gla:gemini-2.5-flash',
     # Type ignore while we wait for PEP-0747, nonetheless unions will work fine everywhere else
     output_type=Response,  # type: ignore
     deps_type=Deps,
-    instrument=True,
 )
 
 

pydantic_ai_examples/stream_markdown.py

@@ -20,13 +20,14 @@ from pydantic_ai.models import KnownModelName
 
 # '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()
 
-agent = Agent(instrument=True)
+agent = Agent()
 
 # models to try, and the appropriate env var
 models: list[tuple[KnownModelName, str]] = [
-    ('google-gla:gemini-1.5-flash', 'GEMINI_API_KEY'),
-    ('openai:gpt-4o-mini', 'OPENAI_API_KEY'),
+    ('google-gla:gemini-2.5-flash', 'GEMINI_API_KEY'),
+    ('openai:gpt-5-mini', 'OPENAI_API_KEY'),
     ('groq:llama-3.3-70b-versatile', 'GROQ_API_KEY'),
 ]
 
@@ -41,7 +42,7 @@ async def main():
             console.log(f'Using model: {model}')
             with Live('', console=console, vertical_overflow='visible') as live:
                 async with agent.run_stream(prompt, model=model) as result:
-                    async for message in result.stream():
+                    async for message in result.stream_output():
                         live.update(Markdown(message))
             console.log(result.usage())
         else:

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
@@ -21,6 +21,7 @@ from pydantic_ai import Agent
 
 # '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()
 
 
 class Whale(TypedDict):
@@ -38,7 +39,7 @@ class Whale(TypedDict):
     description: NotRequired[Annotated[str, Field(description='Short Description')]]
 
 
-agent = Agent('openai:gpt-4', output_type=list[Whale], instrument=True)
+agent = Agent('openai:gpt-4', output_type=list[Whale])
 
 
 async def main():
@@ -50,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_output(debounce_by=0.01):
                 table = Table(
                     title='Species of Whale',
                     caption='Streaming Structured responses from GPT-4',

pydantic_ai_examples/weather_agent.py

@@ -1,4 +1,4 @@
-"""Example of PydanticAI with multiple tools which the LLM needs to call in turn to answer a question.
+"""Example of Pydantic AI 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
@@ -12,70 +12,55 @@ Run with:
 from __future__ import annotations as _annotations
 
 import asyncio
-import os
 from dataclasses import dataclass
 from typing import Any
 
 import logfire
-from devtools import debug
 from httpx import AsyncClient
+from pydantic import BaseModel
 
-from pydantic_ai import Agent, ModelRetry, RunContext
+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_api_key: str | None
-    geo_api_key: str | None
 
 
 weather_agent = Agent(
-    'openai:gpt-4o',
+    'openai:gpt-5-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.
-    system_prompt=(
-        '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.'
-    ),
+    instructions='Be concise, reply with one sentence.',
     deps_type=Deps,
     retries=2,
-    instrument=True,
 )
 
 
+class LatLng(BaseModel):
+    lat: float
+    lng: float
+
+
 @weather_agent.tool
-async def get_lat_lng(
-    ctx: RunContext[Deps], location_description: str
-) -> dict[str, float]:
+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.
     """
-    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 = {
-        'q': location_description,
-        'api_key': ctx.deps.geo_api_key,
-    }
-    with logfire.span('calling geocode API', params=params) as span:
-        r = await ctx.deps.client.get('https://geocode.maps.co/search', params=params)
-        r.raise_for_status()
-        data = r.json()
-        span.set_attribute('response', data)
-
-    if data:
-        return {'lat': data[0]['lat'], 'lng': data[0]['lon']}
-    else:
-        raise ModelRetry('Could not find the 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
@@ -87,69 +72,32 @@ async def get_weather(ctx: RunContext[Deps], lat: float, lng: float) -> dict[str
         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',
-    }
+    # 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'{values["temperatureApparent"]:0.0f}°C',
-        'description': code_lookup.get(values['weatherCode'], 'Unknown'),
+        'temperature': f'{temp_response.text} °C',
+        'description': descr_response.text,
     }
 
 
 async def main():
     async with AsyncClient() as client:
-        # 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://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
-        )
+        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
         )
-        debug(result)
         print('Response:', result.output)
 
 

pydantic_ai_examples/weather_agent_gradio.py

@@ -1,11 +1,11 @@
 from __future__ import annotations as _annotations
 
 import json
-import os
 
 from httpx import AsyncClient
+from pydantic import BaseModel
 
-from pydantic_ai.messages import ToolCallPart, ToolReturnPart
+from pydantic_ai import ToolCallPart, ToolReturnPart
 from pydantic_ai_examples.weather_agent import Deps, weather_agent
 
 try:
@@ -18,10 +18,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):
@@ -33,16 +30,12 @@ async def stream_from_agent(prompt: str, chatbot: list[dict], past_messages: lis
         for message in result.new_messages():
             for call in message.parts:
                 if isinstance(call, ToolCallPart):
-                    call_args = (
-                        call.args.args_json
-                        if hasattr(call.args, 'args_json')
-                        else json.dumps(call.args.args_dict)
-                    )
+                    call_args = call.args_as_json_str()
                     metadata = {
                         'title': f'🛠️ Using {TOOL_TO_DISPLAY_NAME[call.tool_name]}',
                     }
                     if call.tool_call_id is not None:
-                        metadata['id'] = {call.tool_call_id}
+                        metadata['id'] = call.tool_call_id
 
                     gr_message = {
                         'role': 'assistant',
@@ -56,9 +49,11 @@ async def stream_from_agent(prompt: str, chatbot: list[dict], past_messages: lis
                             gr_message.get('metadata', {}).get('id', '')
                             == call.tool_call_id
                         ):
-                            gr_message['content'] += (
-                                f'\nOutput: {json.dumps(call.content)}'
-                            )
+                            if isinstance(call.content, BaseModel):
+                                json_content = call.content.model_dump_json()
+                            else:
+                                json_content = json.dumps(call.content)
+                            gr_message['content'] += f'\nOutput: {json_content}'
                 yield gr.skip(), chatbot, gr.skip()
         chatbot.append({'role': 'assistant', 'content': ''})
         async for message in result.stream_text():

{pydantic_ai_examples-0.1.2.dist-info → pydantic_ai_examples-1.12.0.dist-info}/METADATA

@@ -1,10 +1,11 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-examples
-Version: 0.1.2
-Summary: Examples of how to use PydanticAI and what it can do.
-Author-email: Samuel Colvin <samuel@pydantic.dev>
+Version: 1.12.0
+Summary: Examples of how to use Pydantic AI and what it can do.
+Author-email: Samuel Colvin <samuel@pydantic.dev>, Marcelo Trylesinski <marcelotryle@gmail.com>, David Montague <david@pydantic.dev>, Alex Hall <alex@pydantic.dev>, Douwe Maan <douwe@pydantic.dev>
 License-Expression: MIT
-Classifier: Development Status :: 4 - Beta
+License-File: LICENSE
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
 Classifier: Environment :: MacOS X
 Classifier: Intended Audience :: Developers
@@ -16,28 +17,31 @@ Classifier: Operating System :: Unix
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Internet
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Requires-Dist: asyncpg>=0.30.0
+Requires-Dist: datasets>=4.0.0
 Requires-Dist: devtools>=0.12.2
+Requires-Dist: duckdb>=1.3.2
 Requires-Dist: fastapi>=0.115.4
-Requires-Dist: gradio>=5.9.0; python_version > '3.9'
-Requires-Dist: logfire[asyncpg,fastapi,sqlite3]>=2.6
-Requires-Dist: mcp[cli]>=1.4.1; python_version >= '3.10'
-Requires-Dist: pydantic-ai-slim[anthropic,groq,openai,vertexai]==0.1.2
-Requires-Dist: pydantic-evals==0.1.2
+Requires-Dist: gradio>=5.9.0
+Requires-Dist: logfire[asyncpg,fastapi,httpx,sqlite3]>=3.14.1
+Requires-Dist: mcp[cli]>=1.4.1
+Requires-Dist: modal>=1.0.4
+Requires-Dist: pandas>=2.2.3
+Requires-Dist: pydantic-ai-slim[ag-ui,anthropic,groq,openai,vertexai]==1.12.0
+Requires-Dist: pydantic-evals==1.12.0
 Requires-Dist: python-multipart>=0.0.17
 Requires-Dist: rich>=13.9.2
 Requires-Dist: uvicorn>=0.32.0
 Description-Content-Type: text/markdown
 
-# PydanticAI Examples
+# Pydantic AI Examples
 
 [![CI](https://github.com/pydantic/pydantic-ai/actions/workflows/ci.yml/badge.svg?event=push)](https://github.com/pydantic/pydantic-ai/actions/workflows/ci.yml?query=branch%3Amain)
 [![Coverage](https://coverage-badge.samuelcolvin.workers.dev/pydantic/pydantic-ai.svg)](https://coverage-badge.samuelcolvin.workers.dev/redirect/pydantic/pydantic-ai)
@@ -45,6 +49,6 @@ Description-Content-Type: text/markdown
 [![versions](https://img.shields.io/pypi/pyversions/pydantic-ai.svg)](https://github.com/pydantic/pydantic-ai)
 [![license](https://img.shields.io/github/license/pydantic/pydantic-ai.svg?v)](https://github.com/pydantic/pydantic-ai/blob/main/LICENSE)
 
-Examples of how to use PydanticAI and what it can do.
+Examples of how to use Pydantic AI and what it can do.
 
 For full documentation of these examples and how to run them, see [ai.pydantic.dev/examples/](https://ai.pydantic.dev/examples/).

pydantic_ai_examples-1.12.0.dist-info/RECORD

@@ -0,0 +1,50 @@
+pydantic_ai_examples/__main__.py,sha256=i0LEo2JBOZ-gnHED0ou5Bya43gi7KmOyQ_jKN7M5Ces,1647
+pydantic_ai_examples/bank_support.py,sha256=O9r6yQraDRPibWLOC1wyZu0n_Nr7Exg4u7wEHh25czk,2664
+pydantic_ai_examples/chat_app.html,sha256=90XhxrpDAT09mPVTn9edEn8PqAD-tHxWkeeMz9r_okQ,2580
+pydantic_ai_examples/chat_app.py,sha256=AX28rI0TR9lTPLDOd0uEkmirvfIZCRyCGr_VdGiOkHM,7053
+pydantic_ai_examples/chat_app.ts,sha256=2KfZ2rJU2o0iCPjelyqEi5sH6vfemzWaa5Evx_VcAE4,3307
+pydantic_ai_examples/data_analyst.py,sha256=sC6mcgfeWzfj4STB7J_7oAWC7T8Y0NWvlIeQ8XND9zA,3752
+pydantic_ai_examples/flight_booking.py,sha256=x8FbztbAiqNdDACzal1O5M80syjt8UuGm_wqHpybeQM,7415
+pydantic_ai_examples/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pydantic_ai_examples/pydantic_model.py,sha256=4u_-sdpKSF_lRMLSI-WVYwsyIxgdOpq-8LSCJunoyvA,774
+pydantic_ai_examples/question_graph.py,sha256=ERjlfHxKXswISed6TJtj60SFoTIYe-PyCTZoYR4OJkY,5073
+pydantic_ai_examples/rag.py,sha256=t1um_C3EqX7dhbdopWFqYgHfnKUTyeVWxD3SK7AUdio,8010
+pydantic_ai_examples/roulette_wheel.py,sha256=2YHKbGzYOkLsd98hO3ntjM6pChR1UpmsRrLD36Qh5f0,1654
+pydantic_ai_examples/sql_gen.py,sha256=akgJv4TSImw6O4NRgQZh92QITSmDeEyvoGQcU3oUNFQ,5159
+pydantic_ai_examples/stream_markdown.py,sha256=4uEK6dzC9jVcQTRaYBEDzYfYAJPYHZWfLJ-ZMtmI8y4,2453
+pydantic_ai_examples/stream_whales.py,sha256=Yoa7IuqN_6fowfYSINW39uPCthYu9FKChF-QBmQqWb8,2721
+pydantic_ai_examples/weather_agent.py,sha256=FZF7pgL2U24m-ymFUw6MnqASVpXOfl49ilrYAtZXlOo,3185
+pydantic_ai_examples/weather_agent_gradio.py,sha256=MCoNp5TgWj628ABoZpTUVJYIeSV_C-ig08WfcssDH7A,4719
+pydantic_ai_examples/ag_ui/__init__.py,sha256=ZZs2V-5e9RaLl_7hJAq9-0Juk_f0mk2Vr7a4QT2QB-k,1174
+pydantic_ai_examples/ag_ui/__main__.py,sha256=PMycatJt8Abb-Q8HXRGZoEY6vnOcvRebH7iI9MxLknA,225
+pydantic_ai_examples/ag_ui/api/__init__.py,sha256=Pe307_ET_ERKBP-8Vs4L1yZRkK3ILPpajwxDpeW8YiI,673
+pydantic_ai_examples/ag_ui/api/agentic_chat.py,sha256=QGb7q4AMq5PD1-D-S-71GsMs3wAhH2niUeRryhjL12s,577
+pydantic_ai_examples/ag_ui/api/agentic_generative_ui.py,sha256=RnkSjb8C_J9kXPuB7nFI1knkPF30OkOoSRXoAX2h2Ck,3531
+pydantic_ai_examples/ag_ui/api/human_in_the_loop.py,sha256=Jb_0Sryb4mUOZmr1k9MVTciGUAcC8-tzuyNCaCTWZhc,807
+pydantic_ai_examples/ag_ui/api/predictive_state_updates.py,sha256=PO3SZPCzmWowpEPnqez-oLlMRsPD3MnJArpdwDYThO4,2165
+pydantic_ai_examples/ag_ui/api/shared_state.py,sha256=dr7vCTuZN2tyUrdroD25r69YBPjQFeAPaOt_NbenHyE,3843
+pydantic_ai_examples/ag_ui/api/tool_based_generative_ui.py,sha256=rW0Inzd9_yDqdTE6HmnnF7M-LsR_l4woiwlGbJBHLSM,261
+pydantic_ai_examples/evals/__init__.py,sha256=4f1v2o4F-gnUVtlkZU-dpwwwbLhqRxMcZv676atjNLg,115
+pydantic_ai_examples/evals/agent.py,sha256=o_l6I4DF3HXh7fgsmyz7mViq1ckdFV1Hxq_B7KJPLa0,2041
+pydantic_ai_examples/evals/custom_evaluators.py,sha256=siSpALUMrUGJ1DDrm0Ejniuxhmxhlvee_jubgXjOAeU,2244
+pydantic_ai_examples/evals/example_01_generate_dataset.py,sha256=R-cV9bBHMA8EMIyveP5Yf2p3_VV-g_NSXtDa_zz0ODs,2368
+pydantic_ai_examples/evals/example_02_add_custom_evaluators.py,sha256=pFX0bvVeyfbZGGb0LSajRW-g1ZiVID3e3-sEXZVcjv8,977
+pydantic_ai_examples/evals/example_03_unit_testing.py,sha256=G4Ry7ykJfozaQ9GEXi6cnz0O-6pGBrZIkV4_6RNK194,1207
+pydantic_ai_examples/evals/example_04_compare_models.py,sha256=4oPIeFgbk2vMkN7asN6LjWMYPatMpUFLkKhEzrioqJg,1199
+pydantic_ai_examples/evals/models.py,sha256=QYe_fNv03fmF4ssgSqutHgGx2YX5NLKhhth8-0XFnWo,1776
+pydantic_ai_examples/evals/datasets/time_range_v1.yaml,sha256=pSUawuDen4NQt2RqqJNmrVENgksTWxIFcw-Kkao_yo8,4193
+pydantic_ai_examples/evals/datasets/time_range_v1_schema.json,sha256=xS-wRRSvcoG2FcQZGdL0i332mbjsZh9MOSJAND6VkWU,19932
+pydantic_ai_examples/evals/datasets/time_range_v2.yaml,sha256=zIffxC5bR2l05MrrECJsTHiagFaz8nIPTH-YrmjJz8I,4326
+pydantic_ai_examples/evals/datasets/time_range_v2_schema.json,sha256=GDbDtBH1skdbUzK5Wd_0-SNXTmEWHMTYhhshaLsq_1Q,21309
+pydantic_ai_examples/slack_lead_qualifier/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pydantic_ai_examples/slack_lead_qualifier/agent.py,sha256=kskE4RjlqeqAT51NDt7FoC1OIyQ47DqFcTDkCOvQS9k,1935
+pydantic_ai_examples/slack_lead_qualifier/app.py,sha256=KALNxIV8hz0lGxFclZHxolqoH4MsiIYga_CmpidzONE,1036
+pydantic_ai_examples/slack_lead_qualifier/functions.py,sha256=4LsYtPH_SBo_rJ7008DXvKq_SOwiGtweW_DfzJh8R0s,2196
+pydantic_ai_examples/slack_lead_qualifier/modal.py,sha256=f464AaeyP-n3UIfvEVVc4DZ7FQQtsEX7-kUP3VqoPYo,1635
+pydantic_ai_examples/slack_lead_qualifier/models.py,sha256=WTp6D2WCASXqrjPVT3vGgTSYATLPBM3_cjq9wvXMRao,1586
+pydantic_ai_examples/slack_lead_qualifier/slack.py,sha256=VJVfMeUXYClWUJBLHNuaW8PB2sxjNzpTC-O_AJwcxQ4,833
+pydantic_ai_examples/slack_lead_qualifier/store.py,sha256=04vB4eZWKk_Tx0b9K4QuVI1U24JEyJyBS4X76cui7OI,896
+pydantic_ai_examples-1.12.0.dist-info/METADATA,sha256=vNTvNoFtwV9hR_ENchwD2xp8RaL6ofm-T-Q98u27mGg,2763
+pydantic_ai_examples-1.12.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pydantic_ai_examples-1.12.0.dist-info/licenses/LICENSE,sha256=vA6Jc482lEyBBuGUfD1pYx-cM7jxvLYOxPidZ30t_PQ,1100
+pydantic_ai_examples-1.12.0.dist-info/RECORD,,

pydantic_ai_examples-1.12.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Pydantic Services Inc. 2024 to present
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pydantic_ai_examples-0.1.2.dist-info/RECORD

@@ -1,30 +0,0 @@
-pydantic_ai_examples/__main__.py,sha256=i0LEo2JBOZ-gnHED0ou5Bya43gi7KmOyQ_jKN7M5Ces,1647
-pydantic_ai_examples/bank_support.py,sha256=u_mkEPiUt3YDnlVvBgwUp2VShZ33Hdm0AASSL7_ymXY,2661
-pydantic_ai_examples/chat_app.html,sha256=90XhxrpDAT09mPVTn9edEn8PqAD-tHxWkeeMz9r_okQ,2580
-pydantic_ai_examples/chat_app.py,sha256=OsKy68EHFTKSDMH9Yo53txm7P7b4-b4LJnTvUUY0B78,7089
-pydantic_ai_examples/chat_app.ts,sha256=2KfZ2rJU2o0iCPjelyqEi5sH6vfemzWaa5Evx_VcAE4,3307
-pydantic_ai_examples/flight_booking.py,sha256=TAlotG4Hiuuaps6Pyfokbte4GXpVLo1TVep_ExaHAB4,7442
-pydantic_ai_examples/pydantic_model.py,sha256=fQFPkulep9JQgICpEMrEaj3NpzBiz4OO8WAaeaw4U7c,758
-pydantic_ai_examples/question_graph.py,sha256=ZFb1Z2XHLQy-VD5JGUtj8NCGFNQByg7f7YsBpwOCquY,5091
-pydantic_ai_examples/rag.py,sha256=LYgJSJYSAYyVuIOvVYSvfzAhxVey0pY--hJ3gCk3Lw4,7989
-pydantic_ai_examples/roulette_wheel.py,sha256=TFJAn0hnGSMB_LCAASfc5nKqeN8ImHBYCQStfq5Kp8E,1674
-pydantic_ai_examples/sql_gen.py,sha256=rDvN7qm60Sq6J6rP7on8W7yE0x-fQCifC55N-RjQQnk,5195
-pydantic_ai_examples/stream_markdown.py,sha256=-uNLQBAU7kpem16aMfLcAxdSG6jnqMFnofqqFc3Qv08,2429
-pydantic_ai_examples/stream_whales.py,sha256=EuKdhc0G3kqXAeimpshU0_ThugG5r_ENxe2c0KYBVC4,3213
-pydantic_ai_examples/weather_agent.py,sha256=WKljXL_mSbKguNvZmvmBI4SBi5e0qa5dQ28xJSIVZj4,4874
-pydantic_ai_examples/weather_agent_gradio.py,sha256=0Of2pYrT1H-qt2NjBXzLovI-1D_nl-afRtIBPJ9xTZM,4893
-pydantic_ai_examples/evals/__init__.py,sha256=4f1v2o4F-gnUVtlkZU-dpwwwbLhqRxMcZv676atjNLg,115
-pydantic_ai_examples/evals/agent.py,sha256=KjCsUiL28RCNT6NwoQnQCwJ0xRw3EUGdIrYhlIjmVqI,2042
-pydantic_ai_examples/evals/custom_evaluators.py,sha256=Uz37_wbT4uA6s9fl46nTsH3NQKyS1KamMPPP860stww,2245
-pydantic_ai_examples/evals/example_01_generate_dataset.py,sha256=7fhTY4IMN0xEODGEKtrNlaEIYkqYRauC6w6NRIQnFWY,2369
-pydantic_ai_examples/evals/example_02_add_custom_evaluators.py,sha256=mNPEIDnuE3RcfdMtBKhs5aGUdcDtDQD-v7KoSuE1ZDk,978
-pydantic_ai_examples/evals/example_03_unit_testing.py,sha256=QNkfMQgBZrN8wWhj0ZRsq9XC46AgtFo9gklgh52e4iE,1151
-pydantic_ai_examples/evals/example_04_compare_models.py,sha256=H00BaMEF6etK5497kFjWmdEFbNgVhhq25RDw8KPrLuw,1201
-pydantic_ai_examples/evals/models.py,sha256=QYe_fNv03fmF4ssgSqutHgGx2YX5NLKhhth8-0XFnWo,1776
-pydantic_ai_examples/evals/datasets/time_range_v1.yaml,sha256=pSUawuDen4NQt2RqqJNmrVENgksTWxIFcw-Kkao_yo8,4193
-pydantic_ai_examples/evals/datasets/time_range_v1_schema.json,sha256=xS-wRRSvcoG2FcQZGdL0i332mbjsZh9MOSJAND6VkWU,19932
-pydantic_ai_examples/evals/datasets/time_range_v2.yaml,sha256=zIffxC5bR2l05MrrECJsTHiagFaz8nIPTH-YrmjJz8I,4326
-pydantic_ai_examples/evals/datasets/time_range_v2_schema.json,sha256=GDbDtBH1skdbUzK5Wd_0-SNXTmEWHMTYhhshaLsq_1Q,21309
-pydantic_ai_examples-0.1.2.dist-info/METADATA,sha256=3RDsjVZVRHg7hkiX60r5tkKGYLWGvfcEbJOn9O4N0bM,2542
-pydantic_ai_examples-0.1.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pydantic_ai_examples-0.1.2.dist-info/RECORD,,