pydantic-ai-examples 0.3.4__py3-none-any.whl → 0.3.6__py3-none-any.whl

pydantic_ai_examples/slack_lead_qualifier/agent.py

@@ -0,0 +1,47 @@
+from textwrap import dedent
+from types import NoneType
+
+import logfire
+
+### [imports]
+from pydantic_ai import Agent, NativeOutput
+from pydantic_ai.common_tools.duckduckgo import duckduckgo_search_tool  ### [/imports]
+
+from .models import Analysis, Profile
+
+### [agent]
+agent = Agent(
+    'openai:gpt-4o',
+    instructions=dedent(
+        """
+        When a new person joins our public Slack, please put together a brief snapshot so we can be most useful to them.
+
+        **What to include**
+
+        1. **Who they are:**  Any details about their professional role or projects (e.g. LinkedIn, GitHub, company bio).
+        2. **Where they work:**  Name of the organisation and its domain.
+        3. **How we can help:**  On a scale of 1–5, estimate how likely they are to benefit from **Pydantic Logfire**
+           (our paid observability tool) based on factors such as company size, product maturity, or AI usage.
+           *1 = probably not relevant, 5 = very strong fit.*
+
+        **Our products (for context only)**
+        • **Pydantic Validation** – Python data-validation (open source)
+        • **Pydantic AI** – Python agent framework (open source)
+        • **Pydantic Logfire** – Observability for traces, logs & metrics with first-class AI support (commercial)
+
+        **How to research**
+
+        • Use the provided DuckDuckGo search tool to research the person and the organization they work for, based on the email domain or what you find on e.g. LinkedIn and GitHub.
+        • If you can't find enough to form a reasonable view, return **None**.
+        """
+    ),
+    tools=[duckduckgo_search_tool()],
+    output_type=NativeOutput([Analysis, NoneType]),
+)  ### [/agent]
+
+
+### [analyze_profile]
+@logfire.instrument('Analyze profile')
+async def analyze_profile(profile: Profile) -> Analysis | None:
+    result = await agent.run(profile.as_prompt())
+    return result.output  ### [/analyze_profile]

pydantic_ai_examples/slack_lead_qualifier/app.py

@@ -0,0 +1,36 @@
+from typing import Any
+
+import logfire
+from fastapi import FastAPI, HTTPException, status
+from logfire.propagate import get_context
+
+from .models import Profile
+
+
+### [process_slack_member]
+def process_slack_member(profile: Profile):
+    from .modal import process_slack_member as _process_slack_member
+
+    _process_slack_member.spawn(
+        profile.model_dump(), logfire_ctx=get_context()
+    )  ### [/process_slack_member]
+
+
+### [app]
+app = FastAPI()
+logfire.instrument_fastapi(app, capture_headers=True)
+
+
+@app.post('/')
+async def process_webhook(payload: dict[str, Any]) -> dict[str, Any]:
+    if payload['type'] == 'url_verification':
+        return {'challenge': payload['challenge']}
+    elif (
+        payload['type'] == 'event_callback' and payload['event']['type'] == 'team_join'
+    ):
+        profile = Profile.model_validate(payload['event']['user']['profile'])
+
+        process_slack_member(profile)
+        return {'status': 'OK'}
+
+    raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY)  ### [/app]

pydantic_ai_examples/slack_lead_qualifier/functions.py

@@ -0,0 +1,85 @@
+import logfire
+
+### [imports]
+from .agent import analyze_profile
+from .models import Profile
+
+### [imports-daily_summary]
+from .slack import send_slack_message
+from .store import AnalysisStore  ### [/imports,/imports-daily_summary]
+
+### [constant-new_lead_channel]
+NEW_LEAD_CHANNEL = '#new-slack-leads'
+### [/constant-new_lead_channel]
+### [constant-daily_summary_channel]
+DAILY_SUMMARY_CHANNEL = '#daily-slack-leads-summary'
+### [/constant-daily_summary_channel]
+
+
+### [process_slack_member]
+@logfire.instrument('Process Slack member')
+async def process_slack_member(profile: Profile):
+    analysis = await analyze_profile(profile)
+    logfire.info('Analysis', analysis=analysis)
+
+    if analysis is None:
+        return
+
+    await AnalysisStore().add(analysis)
+
+    await send_slack_message(
+        NEW_LEAD_CHANNEL,
+        [
+            {
+                'type': 'header',
+                'text': {
+                    'type': 'plain_text',
+                    'text': f'New Slack member with score {analysis.relevance}/5',
+                },
+            },
+            {
+                'type': 'divider',
+            },
+            *analysis.as_slack_blocks(),
+        ],
+    )  ### [/process_slack_member]
+
+
+### [send_daily_summary]
+@logfire.instrument('Send daily summary')
+async def send_daily_summary():
+    analyses = await AnalysisStore().list()
+    logfire.info('Analyses', analyses=analyses)
+
+    if len(analyses) == 0:
+        return
+
+    sorted_analyses = sorted(analyses, key=lambda x: x.relevance, reverse=True)
+    top_analyses = sorted_analyses[:5]
+
+    blocks = [
+        {
+            'type': 'header',
+            'text': {
+                'type': 'plain_text',
+                'text': f'Top {len(top_analyses)} new Slack members from the last 24 hours',
+            },
+        },
+    ]
+
+    for analysis in top_analyses:
+        blocks.extend(
+            [
+                {
+                    'type': 'divider',
+                },
+                *analysis.as_slack_blocks(include_relevance=True),
+            ]
+        )
+
+    await send_slack_message(
+        DAILY_SUMMARY_CHANNEL,
+        blocks,
+    )
+
+    await AnalysisStore().clear()  ### [/send_daily_summary]

pydantic_ai_examples/slack_lead_qualifier/modal.py

@@ -0,0 +1,66 @@
+from typing import Any
+
+### [setup_modal]
+import modal
+
+image = modal.Image.debian_slim(python_version='3.13').pip_install(
+    'pydantic',
+    'pydantic_ai_slim[openai,duckduckgo]',
+    'logfire[httpx,fastapi]',
+    'fastapi[standard]',
+    'httpx',
+)
+app = modal.App(
+    name='slack-lead-qualifier',
+    image=image,
+    secrets=[
+        modal.Secret.from_name('logfire'),
+        modal.Secret.from_name('openai'),
+        modal.Secret.from_name('slack'),
+    ],
+)  ### [/setup_modal]
+
+
+### [setup_logfire]
+def setup_logfire():
+    import logfire
+
+    logfire.configure(service_name=app.name)
+    logfire.instrument_pydantic_ai()
+    logfire.instrument_httpx(capture_all=True)  ### [/setup_logfire]
+
+
+### [web_app]
+@app.function(min_containers=1)
+@modal.asgi_app()  # type: ignore
+def web_app():
+    setup_logfire()
+
+    from .app import app as _app
+
+    return _app  ### [/web_app]
+
+
+### [process_slack_member]
+@app.function()
+async def process_slack_member(profile_raw: dict[str, Any], logfire_ctx: Any):
+    setup_logfire()
+
+    from logfire.propagate import attach_context
+
+    from .functions import process_slack_member as _process_slack_member
+    from .models import Profile
+
+    with attach_context(logfire_ctx):
+        profile = Profile.model_validate(profile_raw)
+        await _process_slack_member(profile)  ### [/process_slack_member]
+
+
+### [send_daily_summary]
+@app.function(schedule=modal.Cron('0 8 * * *'))  # Every day at 8am UTC
+async def send_daily_summary():
+    setup_logfire()
+
+    from .functions import send_daily_summary as _send_daily_summary
+
+    await _send_daily_summary()  ### [/send_daily_summary]

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/weather_agent.py

@@ -12,16 +12,14 @@ Run with:
 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 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')
@@ -31,51 +29,38 @@ 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-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.'
-        '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,
 )
 
 
+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 = {'access_token': ctx.deps.geo_api_key}
-    loc = urllib.parse.quote(location_description)
+    # NOTE: the response here will be random, and is not related to the location description.
     r = await ctx.deps.client.get(
-        f'https://api.mapbox.com/geocoding/v5/mapbox.places/{loc}.json', params=params
+        'https://demo-endpoints.pydantic.workers.dev/latlng',
+        params={'location': location_description},
     )
     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')
+    return LatLng.model_validate_json(r.content)
 
 
 @weather_agent.tool
@@ -87,70 +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:
         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
-        )
+        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,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.4.dist-info → pydantic_ai_examples-0.3.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-examples
-Version: 0.3.4
+Version: 0.3.6
 Summary: Examples of how to use PydanticAI and what it can do.
 Author-email: Samuel Colvin <samuel@pydantic.dev>
 License-Expression: MIT
@@ -31,8 +31,9 @@ Requires-Dist: fastapi>=0.115.4
 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: pydantic-ai-slim[anthropic,groq,openai,vertexai]==0.3.4
-Requires-Dist: pydantic-evals==0.3.4
+Requires-Dist: modal>=1.0.4
+Requires-Dist: pydantic-ai-slim[anthropic,groq,openai,vertexai]==0.3.6
+Requires-Dist: pydantic-evals==0.3.6
 Requires-Dist: python-multipart>=0.0.17
 Requires-Dist: rich>=13.9.2
 Requires-Dist: uvicorn>=0.32.0

{pydantic_ai_examples-0.3.4.dist-info → pydantic_ai_examples-0.3.6.dist-info}/RECORD

@@ -11,8 +11,8 @@ pydantic_ai_examples/roulette_wheel.py,sha256=WUPklPKsnmJy-NoPY20mC-AI0820T-YMAY
 pydantic_ai_examples/sql_gen.py,sha256=x-vRRDe93DRW83RWgirXkQdthMFwSGcHm0VIoBgvdaE,5200
 pydantic_ai_examples/stream_markdown.py,sha256=4YcUIXI29gwV5rgUb-u7uaf6el7FxfsY9Rcoo1t2_EA,2447
 pydantic_ai_examples/stream_whales.py,sha256=WqadBOTe15B_QW8Z6TaWkK2G7Abl5llBbTGjtaI2D1s,3229
-pydantic_ai_examples/weather_agent.py,sha256=ALacJXoGhCHiGEWMsT-fvshKY2Z9pDjcZxcbVbGcrek,4931
-pydantic_ai_examples/weather_agent_gradio.py,sha256=k3ORCcOMt_rp7WZuzChyRq_vFGFtKaiqTBxmjm8NGF4,4727
+pydantic_ai_examples/weather_agent.py,sha256=MA1SDkHuUyh2hC-lZdWUSsBVVLALSajgKduIb5Wer1Q,3186
+pydantic_ai_examples/weather_agent_gradio.py,sha256=WVoRqD74jEvGyUs5VHmsRIGduLMu2sP7GHvc3E79T6A,4521
 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
@@ -25,7 +25,15 @@ pydantic_ai_examples/evals/datasets/time_range_v1.yaml,sha256=pSUawuDen4NQt2RqqJ
 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.3.4.dist-info/METADATA,sha256=zYH16Qb3yS8AIA7cpAuj4AEJlLzLVa6SwFPtsi48HaU,2570
-pydantic_ai_examples-0.3.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pydantic_ai_examples-0.3.4.dist-info/licenses/LICENSE,sha256=vA6Jc482lEyBBuGUfD1pYx-cM7jxvLYOxPidZ30t_PQ,1100
-pydantic_ai_examples-0.3.4.dist-info/RECORD,,
+pydantic_ai_examples/slack_lead_qualifier/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pydantic_ai_examples/slack_lead_qualifier/agent.py,sha256=0OlqkXYps7bbetRVpv3jgBdwU4kJcYSyy1RycQxfyDk,1936
+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-0.3.6.dist-info/METADATA,sha256=hKVGb6gcHiy4WDt2tfbH8ajqLn-uMbX2qsXtGvdMVLM,2598
+pydantic_ai_examples-0.3.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pydantic_ai_examples-0.3.6.dist-info/licenses/LICENSE,sha256=vA6Jc482lEyBBuGUfD1pYx-cM7jxvLYOxPidZ30t_PQ,1100
+pydantic_ai_examples-0.3.6.dist-info/RECORD,,