braintrust 0.5.0__py3-none-any.whl → 0.5.2__py3-none-any.whl

braintrust/wrappers/test_dspy.py

@@ -7,6 +7,7 @@ import pytest
 from braintrust import logger
 from braintrust.test_helpers import init_test_logger
 from braintrust.wrappers.dspy import BraintrustDSpyCallback
+from braintrust.wrappers.test_utils import run_in_subprocess, verify_autoinstrument_script
 
 PROJECT_NAME = "test-dspy-app"
 MODEL = "openai/gpt-4o-mini"
@@ -58,3 +59,119 @@ def test_dspy_callback(memory_logger):
 
     # Verify span parenting (LM span should have parent)
     assert lm_span.get("span_parents")  # LM span should have parent
+
+
+class TestPatchDSPy:
+    """Tests for patch_dspy() / unpatch_dspy()."""
+
+    def test_patch_dspy_sets_wrapped_flag(self):
+        """patch_dspy() should set __braintrust_wrapped__ on dspy module."""
+        result = run_in_subprocess("""
+            dspy = __import__("dspy")
+            from braintrust.wrappers.dspy import patch_dspy
+
+            assert not hasattr(dspy, "__braintrust_wrapped__")
+            patch_dspy()
+            assert hasattr(dspy, "__braintrust_wrapped__")
+            print("SUCCESS")
+        """)
+        assert result.returncode == 0, f"Failed: {result.stderr}"
+        assert "SUCCESS" in result.stdout
+
+    def test_patch_dspy_wraps_configure(self):
+        """After patch_dspy(), dspy.configure() should auto-add BraintrustDSpyCallback."""
+        result = run_in_subprocess("""
+            from braintrust.wrappers.dspy import patch_dspy, BraintrustDSpyCallback
+            patch_dspy()
+
+            import dspy
+
+            # Configure without explicitly adding callback
+            dspy.configure(lm=None)
+
+            # Check that BraintrustDSpyCallback was auto-added
+            from dspy.dsp.utils.settings import settings
+            callbacks = settings.callbacks
+            has_bt_callback = any(isinstance(cb, BraintrustDSpyCallback) for cb in callbacks)
+            assert has_bt_callback, f"Expected BraintrustDSpyCallback in {callbacks}"
+            print("SUCCESS")
+        """)
+        assert result.returncode == 0, f"Failed: {result.stderr}"
+        assert "SUCCESS" in result.stdout
+
+    def test_patch_dspy_preserves_existing_callbacks(self):
+        """patch_dspy() should preserve user-provided callbacks."""
+        result = run_in_subprocess("""
+            from braintrust.wrappers.dspy import patch_dspy, BraintrustDSpyCallback
+            patch_dspy()
+
+            import dspy
+            from dspy.utils.callback import BaseCallback
+
+            class MyCallback(BaseCallback):
+                pass
+
+            my_callback = MyCallback()
+            dspy.configure(lm=None, callbacks=[my_callback])
+
+            from dspy.dsp.utils.settings import settings
+            callbacks = settings.callbacks
+
+            # Should have both callbacks
+            has_my_callback = any(cb is my_callback for cb in callbacks)
+            has_bt_callback = any(isinstance(cb, BraintrustDSpyCallback) for cb in callbacks)
+
+            assert has_my_callback, "User callback should be preserved"
+            assert has_bt_callback, "BraintrustDSpyCallback should be added"
+            print("SUCCESS")
+        """)
+        assert result.returncode == 0, f"Failed: {result.stderr}"
+        assert "SUCCESS" in result.stdout
+
+    def test_patch_dspy_does_not_duplicate_callback(self):
+        """patch_dspy() should not add duplicate BraintrustDSpyCallback."""
+        result = run_in_subprocess("""
+            from braintrust.wrappers.dspy import patch_dspy, BraintrustDSpyCallback
+            patch_dspy()
+
+            import dspy
+
+            # User explicitly adds BraintrustDSpyCallback
+            bt_callback = BraintrustDSpyCallback()
+            dspy.configure(lm=None, callbacks=[bt_callback])
+
+            from dspy.dsp.utils.settings import settings
+            callbacks = settings.callbacks
+
+            # Should only have one BraintrustDSpyCallback
+            bt_callbacks = [cb for cb in callbacks if isinstance(cb, BraintrustDSpyCallback)]
+            assert len(bt_callbacks) == 1, f"Expected 1 BraintrustDSpyCallback, got {len(bt_callbacks)}"
+            print("SUCCESS")
+        """)
+        assert result.returncode == 0, f"Failed: {result.stderr}"
+        assert "SUCCESS" in result.stdout
+
+    def test_patch_dspy_idempotent(self):
+        """Multiple patch_dspy() calls should be safe."""
+        result = run_in_subprocess("""
+            from braintrust.wrappers.dspy import patch_dspy
+            import dspy
+
+            patch_dspy()
+            patch_dspy()  # Second call - should be no-op, not double-wrap
+
+            # Verify configure still works
+            lm = dspy.LM("openai/gpt-4o-mini")
+            dspy.configure(lm=lm)
+            print("SUCCESS")
+        """)
+        assert result.returncode == 0, f"Failed: {result.stderr}"
+        assert "SUCCESS" in result.stdout
+
+
+class TestAutoInstrumentDSPy:
+    """Tests for auto_instrument() with DSPy."""
+
+    def test_auto_instrument_dspy(self):
+        """Test auto_instrument patches DSPy, creates spans, and uninstrument works."""
+        verify_autoinstrument_script("test_auto_dspy.py")

braintrust/wrappers/test_google_genai.py

@@ -6,6 +6,7 @@ import pytest
 from braintrust import logger
 from braintrust.test_helpers import init_test_logger
 from braintrust.wrappers.google_genai import setup_genai
+from braintrust.wrappers.test_utils import verify_autoinstrument_script
 from google.genai import types
 from google.genai.client import Client
 
@@ -637,3 +638,11 @@ def test_attachment_with_pydantic_model(memory_logger):
 
     # Attachment should be preserved
     assert copied["context_file"] is attachment
+
+
+class TestAutoInstrumentGoogleGenAI:
+    """Tests for auto_instrument() with Google GenAI."""
+
+    def test_auto_instrument_google_genai(self):
+        """Test auto_instrument patches Google GenAI and creates spans."""
+        verify_autoinstrument_script("test_auto_google_genai.py")

braintrust/wrappers/test_litellm.py

@@ -6,7 +6,7 @@ import pytest
 from braintrust import logger
 from braintrust.test_helpers import assert_dict_matches, init_test_logger
 from braintrust.wrappers.litellm import wrap_litellm
-from braintrust.wrappers.test_utils import assert_metrics_are_valid
+from braintrust.wrappers.test_utils import assert_metrics_are_valid, verify_autoinstrument_script
 
 TEST_ORG_ID = "test-org-litellm-py-tracing"
 PROJECT_NAME = "test-project-litellm-py-tracing"
@@ -697,71 +697,73 @@ async def test_litellm_async_streaming_with_break(memory_logger):
 @pytest.mark.vcr
 def test_patch_litellm_responses(memory_logger):
     """Test that patch_litellm() patches responses."""
-    from braintrust.wrappers.litellm import patch_litellm, unpatch_litellm
+    from braintrust.wrappers.litellm import patch_litellm
 
     assert not memory_logger.pop()
 
     patch_litellm()
-    try:
-        start = time.time()
-        # Call litellm.responses directly (not wrapped_litellm.responses)
-        response = litellm.responses(
-            model=TEST_MODEL,
-            input=TEST_PROMPT,
-            instructions="Just the number please",
-        )
-        end = time.time()
-
-        assert response
-        assert response.output
-        assert len(response.output) > 0
-        content = response.output[0].content[0].text
-        assert "24" in content or "twenty-four" in content.lower()
-
-        # Verify span was created
-        spans = memory_logger.pop()
-        assert len(spans) == 1
-        span = spans[0]
-        assert_metrics_are_valid(span["metrics"], start, end)
-        assert span["metadata"]["model"] == TEST_MODEL
-        assert span["metadata"]["provider"] == "litellm"
-        assert TEST_PROMPT in str(span["input"])
-    finally:
-        unpatch_litellm()
+    start = time.time()
+    # Call litellm.responses directly (not wrapped_litellm.responses)
+    response = litellm.responses(
+        model=TEST_MODEL,
+        input=TEST_PROMPT,
+        instructions="Just the number please",
+    )
+    end = time.time()
+
+    assert response
+    assert response.output
+    assert len(response.output) > 0
+    content = response.output[0].content[0].text
+    assert "24" in content or "twenty-four" in content.lower()
+
+    # Verify span was created
+    spans = memory_logger.pop()
+    assert len(spans) == 1
+    span = spans[0]
+    assert_metrics_are_valid(span["metrics"], start, end)
+    assert span["metadata"]["model"] == TEST_MODEL
+    assert span["metadata"]["provider"] == "litellm"
+    assert TEST_PROMPT in str(span["input"])
 
 
 @pytest.mark.vcr
 @pytest.mark.asyncio
 async def test_patch_litellm_aresponses(memory_logger):
     """Test that patch_litellm() patches aresponses."""
-    from braintrust.wrappers.litellm import patch_litellm, unpatch_litellm
+    from braintrust.wrappers.litellm import patch_litellm
 
     assert not memory_logger.pop()
 
     patch_litellm()
-    try:
-        start = time.time()
-        # Call litellm.aresponses directly (not wrapped_litellm.aresponses)
-        response = await litellm.aresponses(
-            model=TEST_MODEL,
-            input=TEST_PROMPT,
-            instructions="Just the number please",
-        )
-        end = time.time()
-
-        assert response
-        assert response.output
-        assert len(response.output) > 0
-        content = response.output[0].content[0].text
-        assert "24" in content or "twenty-four" in content.lower()
-
-        # Verify span was created
-        spans = memory_logger.pop()
-        assert len(spans) == 1
-        span = spans[0]
-        assert_metrics_are_valid(span["metrics"], start, end)
-        assert span["metadata"]["model"] == TEST_MODEL
-        assert span["metadata"]["provider"] == "litellm"
-        assert TEST_PROMPT in str(span["input"])
-    finally:
-        unpatch_litellm()
+    start = time.time()
+    # Call litellm.aresponses directly (not wrapped_litellm.aresponses)
+    response = await litellm.aresponses(
+        model=TEST_MODEL,
+        input=TEST_PROMPT,
+        instructions="Just the number please",
+    )
+    end = time.time()
+
+    assert response
+    assert response.output
+    assert len(response.output) > 0
+    content = response.output[0].content[0].text
+    assert "24" in content or "twenty-four" in content.lower()
+
+    # Verify span was created
+    spans = memory_logger.pop()
+    assert len(spans) == 1
+    span = spans[0]
+    assert_metrics_are_valid(span["metrics"], start, end)
+    assert span["metadata"]["model"] == TEST_MODEL
+    assert span["metadata"]["provider"] == "litellm"
+    assert TEST_PROMPT in str(span["input"])
+
+
+class TestAutoInstrumentLiteLLM:
+    """Tests for auto_instrument() with LiteLLM."""
+
+    def test_auto_instrument_litellm(self):
+        """Test auto_instrument patches LiteLLM, creates spans, and uninstrument works."""
+        verify_autoinstrument_script("test_auto_litellm.py")

braintrust/wrappers/test_openai.py

@@ -6,7 +6,7 @@ import openai
 import pytest
 from braintrust import logger, wrap_openai
 from braintrust.test_helpers import assert_dict_matches, init_test_logger
-from braintrust.wrappers.test_utils import assert_metrics_are_valid
+from braintrust.wrappers.test_utils import assert_metrics_are_valid, run_in_subprocess, verify_autoinstrument_script
 from openai import AsyncOpenAI
 from openai._types import NOT_GIVEN
 from pydantic import BaseModel
@@ -1681,3 +1681,255 @@ def test_braintrust_tracing_processor_trace_metadata_logging(memory_logger):
     spans = memory_logger.pop()
     root_span = spans[0]
     assert root_span["metadata"]["conversation_id"] == "test-12345", "Should log trace metadata"
+
+
+class TestPatchOpenAI:
+    """Tests for patch_openai()."""
+
+    def test_patch_openai_sets_wrapped_flag(self):
+        """patch_openai() should set __braintrust_wrapped__ on openai module."""
+        result = run_in_subprocess("""
+            from braintrust.oai import patch_openai
+            import openai
+
+            assert not hasattr(openai, "__braintrust_wrapped__")
+            patch_openai()
+            assert hasattr(openai, "__braintrust_wrapped__")
+            print("SUCCESS")
+        """)
+        assert result.returncode == 0, f"Failed: {result.stderr}"
+        assert "SUCCESS" in result.stdout
+
+    def test_patch_openai_wraps_new_clients(self):
+        """After patch_openai(), new OpenAI() clients should be wrapped."""
+        result = run_in_subprocess("""
+            from braintrust.oai import patch_openai
+            patch_openai()
+
+            import openai
+            client = openai.OpenAI(api_key="test-key")
+
+            # Check that chat completions is wrapped (our wrapper adds tracing)
+            # The wrapper replaces client.chat with a wrapped version
+            chat_type = type(client.chat).__name__
+            print(f"chat_type={chat_type}")
+            print("SUCCESS")
+        """)
+        assert result.returncode == 0, f"Failed: {result.stderr}"
+        assert "SUCCESS" in result.stdout
+
+    def test_patch_openai_creates_spans(self):
+        """patch_openai() should create spans when making API calls."""
+        result = run_in_subprocess("""
+            from braintrust.oai import patch_openai
+            from braintrust.test_helpers import init_test_logger
+            from braintrust import logger
+
+            # Set up memory logger
+            init_test_logger("test-auto")
+            with logger._internal_with_memory_background_logger() as memory_logger:
+                patch_openai()
+
+                import openai
+                client = openai.OpenAI()
+
+                # Make a call within a span context
+                import braintrust
+                with braintrust.start_span(name="test") as span:
+                    try:
+                        # This will fail without API key, but span should still be created
+                        client.chat.completions.create(
+                            model="gpt-4o-mini",
+                            messages=[{"role": "user", "content": "hi"}],
+                        )
+                    except Exception:
+                        pass  # Expected without API key
+
+                # Check that spans were logged
+                spans = memory_logger.pop()
+                # Should have at least the parent span
+                assert len(spans) >= 1, f"Expected spans, got {spans}"
+                print("SUCCESS")
+        """)
+        assert result.returncode == 0, f"Failed: {result.stderr}"
+        assert "SUCCESS" in result.stdout
+
+    def test_patch_openai_before_import(self):
+        """patch_openai() should work when called before importing openai."""
+        result = run_in_subprocess("""
+            from braintrust.oai import patch_openai
+
+            # Patch BEFORE importing openai
+            patch_openai()
+
+            import openai
+            assert hasattr(openai, "__braintrust_wrapped__")
+
+            client = openai.OpenAI(api_key="test-key")
+            print("SUCCESS")
+        """)
+        assert result.returncode == 0, f"Failed: {result.stderr}"
+        assert "SUCCESS" in result.stdout
+
+    def test_patch_openai_after_import(self):
+        """patch_openai() should work when called after importing openai."""
+        result = run_in_subprocess("""
+            import openai
+            from braintrust.oai import patch_openai
+
+            # Patch AFTER importing openai
+            patch_openai()
+
+            assert hasattr(openai, "__braintrust_wrapped__")
+
+            client = openai.OpenAI(api_key="test-key")
+            print("SUCCESS")
+        """)
+        assert result.returncode == 0, f"Failed: {result.stderr}"
+        assert "SUCCESS" in result.stdout
+
+    def test_patch_openai_idempotent(self):
+        """Multiple patch_openai() calls should be safe."""
+        result = run_in_subprocess("""
+            from braintrust.oai import patch_openai
+            import openai
+
+            patch_openai()
+            patch_openai()  # Second call - should be no-op, not double-wrap
+
+            # Verify we can still create clients
+            client = openai.OpenAI(api_key="test-key")
+            assert hasattr(client, "chat")
+            print("SUCCESS")
+        """)
+        assert result.returncode == 0, f"Failed: {result.stderr}"
+        assert "SUCCESS" in result.stdout
+
+    def test_patch_openai_chains_with_other_patches(self):
+        """patch_openai() should chain with other libraries that patch OpenAI."""
+        result = run_in_subprocess("""
+            import openai
+
+            # Simulate another library (like Datadog) patching OpenAI first
+            other_library_init_called = []
+
+            class OtherLibraryOpenAI(openai.OpenAI):
+                def __init__(self, *args, **kwargs):
+                    other_library_init_called.append(True)
+                    super().__init__(*args, **kwargs)
+
+            openai.OpenAI = OtherLibraryOpenAI
+
+            # Now apply our patch - should subclass OtherLibraryOpenAI
+            from braintrust.oai import patch_openai
+            patch_openai()
+
+            # Create a client - both patches should run
+            client = openai.OpenAI(api_key="test-key")
+
+            # Verify other library's __init__ was called (chaining works)
+            assert len(other_library_init_called) == 1, "Other library's patch should have run"
+
+            # Verify our patch was applied (client has wrapped chat)
+            assert hasattr(client, "chat"), "Client should have chat attribute"
+
+            print("SUCCESS")
+        """)
+        assert result.returncode == 0, f"Failed: {result.stderr}"
+        assert "SUCCESS" in result.stdout
+
+    def test_patch_openai_chains_async_client(self):
+        """patch_openai() should chain with other libraries for AsyncOpenAI too."""
+        result = run_in_subprocess("""
+            import openai
+
+            # Simulate another library patching AsyncOpenAI first
+            other_library_init_called = []
+
+            class OtherLibraryAsyncOpenAI(openai.AsyncOpenAI):
+                def __init__(self, *args, **kwargs):
+                    other_library_init_called.append(True)
+                    super().__init__(*args, **kwargs)
+
+            openai.AsyncOpenAI = OtherLibraryAsyncOpenAI
+
+            # Now apply our patch
+            from braintrust.oai import patch_openai
+            patch_openai()
+
+            # Create an async client - both patches should run
+            client = openai.AsyncOpenAI(api_key="test-key")
+
+            # Verify other library's __init__ was called
+            assert len(other_library_init_called) == 1, "Other library's patch should have run"
+
+            # Verify our patch was applied
+            assert hasattr(client, "chat"), "Client should have chat attribute"
+
+            print("SUCCESS")
+        """)
+        assert result.returncode == 0, f"Failed: {result.stderr}"
+        assert "SUCCESS" in result.stdout
+
+
+class TestPatchOpenAISpans:
+    """VCR-based tests verifying that patch_openai() produces spans."""
+
+    @pytest.mark.vcr
+    def test_patch_openai_creates_spans(self, memory_logger):
+        """patch_openai() should create spans when making API calls."""
+        from braintrust.oai import patch_openai
+
+        assert not memory_logger.pop()
+
+        patch_openai()
+        client = openai.OpenAI()
+        response = client.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=[{"role": "user", "content": "Say hi"}],
+        )
+        assert response.choices[0].message.content
+
+        # Verify span was created
+        spans = memory_logger.pop()
+        assert len(spans) == 1
+        span = spans[0]
+        assert span["metadata"]["provider"] == "openai"
+        assert "gpt-4o-mini" in span["metadata"]["model"]
+        assert span["input"]
+
+
+class TestPatchOpenAIAsyncSpans:
+    """VCR-based tests verifying that patch_openai() produces spans for async clients."""
+
+    @pytest.mark.vcr
+    @pytest.mark.asyncio
+    async def test_patch_openai_async_creates_spans(self, memory_logger):
+        """patch_openai() should create spans for async API calls."""
+        from braintrust.oai import patch_openai
+
+        assert not memory_logger.pop()
+
+        patch_openai()
+        client = openai.AsyncOpenAI()
+        response = await client.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=[{"role": "user", "content": "Say hi async"}],
+        )
+        assert response.choices[0].message.content
+
+        # Verify span was created
+        spans = memory_logger.pop()
+        assert len(spans) == 1
+        span = spans[0]
+        assert span["metadata"]["provider"] == "openai"
+        assert "gpt-4o-mini" in span["metadata"]["model"]
+        assert span["input"]
+
+
+class TestAutoInstrumentOpenAI:
+    """Tests for auto_instrument() with OpenAI."""
+
+    def test_auto_instrument_openai(self):
+        """Test auto_instrument patches OpenAI, creates spans, and uninstrument works."""
+        verify_autoinstrument_script("test_auto_openai.py")

braintrust/wrappers/test_pydantic_ai_integration.py

@@ -9,6 +9,7 @@ import pytest
 from braintrust import logger, setup_pydantic_ai, traced
 from braintrust.span_types import SpanTypeAttribute
 from braintrust.test_helpers import init_test_logger
+from braintrust.wrappers.test_utils import verify_autoinstrument_script
 from pydantic import BaseModel
 from pydantic_ai import Agent, ModelSettings
 from pydantic_ai.messages import ModelRequest, UserPromptPart
@@ -2572,3 +2573,11 @@ async def test_attachment_in_result_data(memory_logger):
     copied = bt_safe_deep_copy(result_data)
     assert copied["output_file"] is ext_attachment
     assert copied["success"] is True
+
+
+class TestAutoInstrumentPydanticAI:
+    """Tests for auto_instrument() with Pydantic AI."""
+
+    def test_auto_instrument_pydantic_ai(self):
+        """Test auto_instrument patches Pydantic AI and creates spans."""
+        verify_autoinstrument_script("test_auto_pydantic_ai.py")

braintrust/wrappers/test_utils.py

@@ -1,3 +1,59 @@
+import os
+import subprocess
+import sys
+import textwrap
+from contextlib import contextmanager
+from pathlib import Path
+
+import vcr
+from braintrust import logger
+from braintrust.conftest import get_vcr_config
+from braintrust.test_helpers import init_test_logger
+
+# Source directory paths (resolved to handle installed vs source locations)
+_SOURCE_DIR = Path(__file__).resolve().parent
+AUTO_TEST_SCRIPTS_DIR = _SOURCE_DIR / "auto_test_scripts"
+
+# Cassettes dir can be overridden via env var for subprocess tests
+CASSETTES_DIR = Path(os.environ.get("BRAINTRUST_CASSETTES_DIR", _SOURCE_DIR / "cassettes"))
+
+
+def run_in_subprocess(
+    code: str, timeout: int = 30, env: dict[str, str] | None = None
+) -> subprocess.CompletedProcess:
+    """Run Python code in a fresh subprocess."""
+    run_env = os.environ.copy()
+    if env:
+        run_env.update(env)
+    return subprocess.run(
+        [sys.executable, "-c", textwrap.dedent(code)],
+        capture_output=True,
+        text=True,
+        timeout=timeout,
+        env=run_env,
+    )
+
+
+def verify_autoinstrument_script(script_name: str, timeout: int = 30) -> subprocess.CompletedProcess:
+    """Run a test script from the auto_test_scripts directory.
+
+    Raises AssertionError if the script exits with non-zero code.
+    """
+    script_path = AUTO_TEST_SCRIPTS_DIR / script_name
+    # Pass cassettes dir to subprocess since it may use installed package
+    env = os.environ.copy()
+    env["BRAINTRUST_CASSETTES_DIR"] = str(_SOURCE_DIR / "cassettes")
+    result = subprocess.run(
+        [sys.executable, str(script_path)],
+        capture_output=True,
+        text=True,
+        timeout=timeout,
+        env=env,
+    )
+    assert result.returncode == 0, f"Script {script_name} failed:\n{result.stderr}"
+    return result
+
+
 def assert_metrics_are_valid(metrics, start=None, end=None):
     assert metrics
     # assert 0 < metrics["time_to_first_token"]
@@ -10,3 +66,26 @@ def assert_metrics_are_valid(metrics, start=None, end=None):
         assert start <= metrics["start"] <= metrics["end"] <= end
     else:
         assert metrics["start"] <= metrics["end"]
+
+
+@contextmanager
+def autoinstrument_test_context(cassette_name: str):
+    """Context manager for auto_instrument tests.
+
+    Sets up VCR and memory_logger, yields memory_logger for direct use.
+
+    Usage:
+        with autoinstrument_test_context("test_auto_openai") as memory_logger:
+            # make API call
+            spans = memory_logger.pop()
+    """
+    cassette_path = CASSETTES_DIR / f"{cassette_name}.yaml"
+
+    init_test_logger("test-auto-instrument")
+
+    with logger._internal_with_memory_background_logger() as memory_logger:
+        memory_logger.pop()  # Clear any prior spans
+
+        my_vcr = vcr.VCR(**get_vcr_config())
+        with my_vcr.use_cassette(str(cassette_path)):
+            yield memory_logger

{braintrust-0.5.0.dist-info → braintrust-0.5.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: braintrust
-Version: 0.5.0
+Version: 0.5.2
 Summary: SDK for integrating Braintrust
 Home-page: https://www.braintrust.dev
 Author: Braintrust