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

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/wrappers/threads.py

@@ -0,0 +1,114 @@
+import contextvars
+import functools
+import logging
+import threading
+from concurrent import futures
+from typing import Any, TypeVar
+
+from wrapt import wrap_function_wrapper  # pyright: ignore[reportUnknownVariableType, reportMissingTypeStubs]
+
+logger = logging.getLogger(__name__)
+
+__all__ = ["setup_threads", "patch_thread", "patch_thread_pool_executor"]
+
+
+def setup_threads() -> bool:
+    """
+    Setup automatic context propagation for threading.
+
+    This patches stdlib threading primitives to automatically
+    propagate Braintrust context across thread boundaries.
+
+    Enable via:
+        - BRAINTRUST_INSTRUMENT_THREADS=true env var (automatic)
+        - Call this function directly (manual)
+
+    Returns:
+        bool: True if instrumentation was successful, False otherwise.
+    """
+    try:
+        patch_thread(threading.Thread)
+        patch_thread_pool_executor(futures.ThreadPoolExecutor)
+
+        logger.debug("Braintrust thread instrumentation enabled")
+        return True
+
+    except Exception as e:
+        logger.warning(f"Failed to enable thread instrumentation: {e}")
+        return False
+
+
+T = TypeVar("T", bound=type[threading.Thread])
+
+
+def patch_thread(thread_cls: T) -> T:
+    if __is_patched(thread_cls):
+        return thread_cls
+
+    def _wrap_thread_start(wrapped: Any, instance: Any, args: Any, kwargs: Any) -> Any:
+        try:
+            instance._braintrust_context = contextvars.copy_context()
+        except Exception as e:
+            logger.debug(f"Failed to capture context in thread start: {e}")
+        return wrapped(*args, **kwargs)
+
+    wrap_function_wrapper(thread_cls, "start", _wrap_thread_start)
+
+    def _wrap_thread_run(wrapped: Any, instance: Any, args: Any, kwargs: Any) -> Any:
+        try:
+            if hasattr(instance, "_braintrust_context"):
+                return instance._braintrust_context.run(wrapped, *args, **kwargs)
+        except Exception as e:
+            logger.debug(f"Failed to restore context in thread run: {e}")
+        return wrapped(*args, **kwargs)
+
+    wrap_function_wrapper(thread_cls, "run", _wrap_thread_run)
+
+    __mark_patched(thread_cls)
+    return thread_cls
+
+
+def __is_patched(obj: Any) -> bool:
+    """Check if an object has already been patched."""
+    return getattr(obj, "_braintrust_patched", False)
+
+
+def __mark_patched(obj: Any) -> None:
+    setattr(obj, "_braintrust_patched", True)
+
+
+P = TypeVar("P", bound=type[futures.ThreadPoolExecutor])
+
+
+def patch_thread_pool_executor(executor_cls: P) -> P:
+    if __is_patched(executor_cls):
+        return executor_cls
+
+    def _wrap_executor_submit(wrapped: Any, instance: Any, args: Any, kwargs: Any) -> Any:
+        try:
+            if not args:
+                return wrapped(*args, **kwargs)
+
+            func = args[0]
+            ctx = contextvars.copy_context()
+
+            @functools.wraps(func)
+            def context_wrapper(*func_args: Any, **func_kwargs: Any) -> Any:
+                try:
+                    return ctx.run(func, *func_args, **func_kwargs)
+                except Exception as e:
+                    # context.run() can fail if token is invalid
+                    logger.debug(f"Failed to run in captured context: {e}")
+                    return func(*func_args, **func_kwargs)
+
+            new_args = (context_wrapper,) + args[1:]
+            return wrapped(*new_args, **kwargs)
+        except Exception as e:
+            # Wrapping can fail - fall back to original
+            logger.debug(f"Failed to wrap executor submit: {e}")
+            return wrapped(*args, **kwargs)
+
+    wrap_function_wrapper(executor_cls, "submit", _wrap_executor_submit)
+
+    __mark_patched(executor_cls)
+    return executor_cls

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

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

{braintrust-0.5.0.dist-info → braintrust-0.5.3.dist-info}/RECORD

@@ -1,22 +1,22 @@
-braintrust/__init__.py,sha256=sw6dLIINeyUVP4IbF49wqXv2cyAWEoO3SGSIvCb_b2o,2238
-braintrust/_generated_types.py,sha256=_eqozb1MG75khlsvXoAV7oKjbgEEBvnzlLtiUfpxX8U,99447
+braintrust/__init__.py,sha256=DU4gzkV0R3nsWxp2da7iQS1MM_T9xHkrKSQE6nAnZbE,2627
+braintrust/_generated_types.py,sha256=1gNbTwsy7LEBdLW-uYqzQ2v78ToAFX0PSmeE_NOJC18,101153
 braintrust/audit.py,sha256=3GQKzuTcFquYdrJtABM-k3xMlOIqgVkfG6UyeQ8_028,461
+braintrust/auto.py,sha256=wf4Jb7hYoGS0Agpx-YjUYEW7wwwUpyAJDp-l3A-y6c0,4792
 braintrust/aws.py,sha256=OBz_SRyopgpCDSNvETLypzGwTXk-bNLn-Eisevnjfwo,377
 braintrust/bt_json.py,sha256=VNunedFUEfbvVEBuACHLRsjDr8lLD3_nFwB54MXtcbY,9385
-braintrust/conftest.py,sha256=cmuwhK0BvqZ6yGqD_3x_JJmWkCtaSOwfSKz6n8ZT5Ug,2339
+braintrust/conftest.py,sha256=qcS1T4tqXN5Ocaol6gEN9xGOXBqvTYPXXiBJjHnHC6Y,3140
 braintrust/context.py,sha256=bOo1Li29lUsi2DOOllIDar0oRuQNbkLNzJ7cYq5JTbo,4126
-braintrust/db_fields.py,sha256=vjVEyDxl2d13lvvTcVwT5paHvaT-1kgI-4Lg-gihRIw,476
-braintrust/framework.py,sha256=GG9V7Tq--9whgiWFFicgdeWPQp_7KuknznKDN1ixOmU,61872
+braintrust/db_fields.py,sha256=AX-K5t7KqO-xHHOfVRv8bn1ww7gZd3RNIFfANkZ2W0U,709
+braintrust/framework.py,sha256=KoXFKCprfeEHq-AqjarENcmHHcTuvr4PScWtMbIQ6zg,62635
 braintrust/framework2.py,sha256=o0igz4vXbmn0jHJPhDYvx14rFnI3ntV8H6VJfyJYRtM,16542
-braintrust/generated_types.py,sha256=_IBZSkYTralTQM5hLhnbdIQS8_NhWr4V77kJPHtEUHY,4997
+braintrust/generated_types.py,sha256=MUpi5l9XIW0bGqnYqa9DE7XbxDYsBI82ANyTVHz9DVg,5047
 braintrust/git_fields.py,sha256=au5ayyuvt7y_ojE9LC98ypTZd3RgFdjhRc8eFxcjnto,1434
 braintrust/gitutil.py,sha256=RsW7cawJMgaAaTw6WeB1sShyfflkPb7yH2x7yuRv10c,5642
-braintrust/graph_util.py,sha256=Z2Uy8RaOq5iMe5mShhQqRDDIpXVitE-biVxDiFB-0Ds,5545
 braintrust/http_headers.py,sha256=9ZsDcsAKG04SGowsgchZktD6rG_oSTKWa8QyGUPA4xE,154
 braintrust/id_gen.py,sha256=4UWLWRhksf76IkYi4cKACSaQ3yNgausrMRlhiurhy74,1590
-braintrust/logger.py,sha256=vfoDb8pIqkkFKdWGaI670MSnyRz5BTx2DUmp-r1T92M,207496
-braintrust/merge_row_batch.py,sha256=tvuz3qdsa7HZBrzzAzoQqAXU7pKsHUebC7sw6RybbmA,9881
-braintrust/oai.py,sha256=AjHeD0uNYO-ECVUh9RbPBxyKMps06A3dvHAWa41prMc,36259
+braintrust/logger.py,sha256=ofx0_8ywVk_iyyqOH-6kCgRaYmm_sO7guVJ5hW2ISNg,217467
+braintrust/merge_row_batch.py,sha256=mCutumLDOpH8ArP_4K5swP93mve7gmgfAnQdkdjUZ5E,6271
+braintrust/oai.py,sha256=K7NLw7-3U7TJCyBVeoOwpy_UOmGlpaXXJcHZgW-rzHM,37746
 braintrust/object.py,sha256=vYLyYWncsqLD00zffZUJwGTSkcJF9IIXmgIzrx3Np5c,632
 braintrust/parameters.py,sha256=sQWfw18QXdPSnMHsF7aRrPmP7Zx6HEz9vaTUXWreudg,5911
 braintrust/prompt.py,sha256=pLzhXoBp7ebxNraZADflR4YQMW5Ycjmt5ucK80P4_h0,1875
@@ -31,12 +31,15 @@ braintrust/span_identifier_v2.py,sha256=2dLc-Vz8iWLISmL_-ebCyWnY-ysA7sMnBsQtKqzM
 braintrust/span_identifier_v3.py,sha256=RAvOK0lK0huH952kI5X1Q9TaAloD5to8jgTCuYMMw6o,10356
 braintrust/span_identifier_v4.py,sha256=uFT-OdzySo4uCeAaJC3VqH55Oy433xZGBdK2hiEsm2w,10044
 braintrust/span_types.py,sha256=cpTzCwUj4yBPbPLnzR23-VXIU2E9nl_dsVCSVMvtSkc,376
-braintrust/test_bt_json.py,sha256=p4r5DlMkH2rRQbYT9X1ASPbKVEMku5bFUUa7hVAO-ZY,25259
-braintrust/test_framework.py,sha256=7spRLovwNjZLula8mNW_KspyWuWgpqSfHV6sZqub-ME,17664
+braintrust/test_bt_json.py,sha256=pokqmFSQ3m8aB0XN1EEsS-zbv_N4KCYzad6VyOFtwPw,25188
+braintrust/test_context.py,sha256=4wZOhwzGgAxt-CcN2izAxhgcY975oh_HUMkZXRwwTys,42754
+braintrust/test_framework.py,sha256=rPjJYfVzRSbjf8e0irVfCnE3q5Rl1O_2Dy2dPyC9-lo,18674
 braintrust/test_framework2.py,sha256=pSEEmBIyszAiYnpEVvDZgJqIe3lQ3T807LmIuBqV98w,7235
 braintrust/test_helpers.py,sha256=VSelzjkR2IHyy5QD6sYB_79VIXq-wEDslDwyx9H11kI,13528
+braintrust/test_http.py,sha256=RiW07psmoxO9ZB5ZUN1K1hIan7l4_F9YC2mW0iqSMr0,15751
 braintrust/test_id_gen.py,sha256=Oqp8Rxd1_9ptpEJSu_xi6STIquZpx9n7Kh-bGUKMQH0,2489
-braintrust/test_logger.py,sha256=lQpxqqzcP_TgM1_ZgUE_eau6xZ8dQa7UHc8kgz39qFw,107121
+braintrust/test_logger.py,sha256=zINMwUn2hT1_ElZRkVJP95CkTwtLhjUKpR5zIP7tn5Y,112653
+braintrust/test_merge_row_batch.py,sha256=cQ_Hiq6wlWIs091Tqexgd3TXWPb0BJm1N1t7cCQ7ZM4,4892
 braintrust/test_otel.py,sha256=EyLOBMIZegvGyqqWl4vAlIazZfz1s4tWbgSAM68-2mM,31356
 braintrust/test_queue.py,sha256=872weDhTfxN1Vu4-cV8pZZ9XNE8UkX4WNcvc2mPtSDI,8431
 braintrust/test_score.py,sha256=PpfzNeaYhC4shMFqF85EczuMT0FCTr6l1rdEYWLe4g0,5857
@@ -44,11 +47,11 @@ braintrust/test_serializable_data_class.py,sha256=b04Ym64YtC6GJRGbKIN4J20RG1QN1F
 braintrust/test_span_cache.py,sha256=HCCpedhJVb24jwcf2sbnP4Vj7t5p2AsMGUOSc91I6po,8705
 braintrust/test_span_components.py,sha256=6w0oDnDLuVbHygNienujk4JDqtSRR5A49AI-S8Pa5hY,16197
 braintrust/test_trace.py,sha256=u1V6wC-bgOhHofeg6q196CCurH3L-5diYjRK_hRQCII,8383
-braintrust/test_util.py,sha256=xMN84ERVzZYUTAOp0IkFK-ktWOLK4rr6OdhaNeq7Fg0,6382
+braintrust/test_util.py,sha256=SuSKTmvNyaR9Rbgf2TYCUWxJpZHoA2BMx6n4nQfV_pM,8221
 braintrust/test_version.py,sha256=hk5JKjEFbNJ_ONc1VEkqHquflzre34RpFhCEYLTK8iA,1051
 braintrust/trace.py,sha256=PHxfaHApGP_MPMIndZw7atIa2iwKPETUoG-TbF2dv6A,13767
-braintrust/util.py,sha256=-q73F17BkaUaDCGtNBTtacqIPwWiXcgWYpzHqFTQdhc,8361
-braintrust/version.py,sha256=zo6vrUFCLMjkdBQDNzANhse_z5JzTXZAtFlYrCDt56A,117
+braintrust/util.py,sha256=S-qMBNsT36r_3pJ4LNKZ-vvHRlJwy8Wy7M7NAdfNOug,8919
+braintrust/version.py,sha256=u7mu2r_lw0F22zAYs8OHbW11HrkdIhoAK-RbDs2uQdA,117
 braintrust/xact_ids.py,sha256=bdyp88HjlyIkglgLSqYlCYscdSH6EWVyE14sR90Xl1s,658
 braintrust/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 braintrust/cli/__main__.py,sha256=wCBKHGVmn3IT_yMXk5qfDwyI2SV2gf1tLr0NTxm9T8k,1519
@@ -92,37 +95,38 @@ braintrust/prompt_cache/test_lru_cache.py,sha256=4NNIXSfYBtOma7KYum74UdeM83eYmcX
 braintrust/prompt_cache/test_prompt_cache.py,sha256=x17Ru9eaix8jt6yMhRgEljD2vVe7ieA8uKhk3bszgSM,8447
 braintrust/wrappers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 braintrust/wrappers/_anthropic_utils.py,sha256=tOj_rv5NVRXpCij0F3NPxOZg0XGAAXo8Y0IYpNY5DHg,3078
-braintrust/wrappers/anthropic.py,sha256=sh0UbSWDarU5glic4HIUXNZmMcfn3Odau2K8HzaOIWY,11785
-braintrust/wrappers/dspy.py,sha256=ckPcMHpbVZP6k4R60ZbgegWz82lsK3lu2u9nvN0EIss,13516
+braintrust/wrappers/anthropic.py,sha256=jJDmdI0PnE4rNqtJvFaYd3huMnCWRJKxM1kNOH_J8xQ,13792
+braintrust/wrappers/dspy.py,sha256=DGvDkSteOqhNhD5R3XgYcIKAI1-Ui2WYUbjqBl88C2Y,14996
 braintrust/wrappers/langchain.py,sha256=0aY5LuVA7BPkgWA0N6CwPG9EaPqRmVVfEPaM1kN4XZY,5028
 braintrust/wrappers/langsmith_wrapper.py,sha256=mWhBnY6KypOlSQw4NrCwzif0Oe6SHV6LYGGiwiz-EJQ,17956
-braintrust/wrappers/litellm.py,sha256=ZE63C8OE5Z0N3mArwOWZusDXBW1MElPOCjODOF-tmB0,26616
+braintrust/wrappers/litellm.py,sha256=SxyDrji84OReBGiIf7aP51iIIF8ocD44QmmnYJwVCbo,25168
 braintrust/wrappers/openai.py,sha256=SZuT4ouJd8FRNXxy9zM_OGb2HNL9XGsFnwkHCk3LDAM,10563
-braintrust/wrappers/pydantic_ai.py,sha256=AgMZS4F7c5Um-P98p13A0uapMFGuYf5YyXuDw1nwPHs,48534
-braintrust/wrappers/test_agno.py,sha256=IyxhKOy8kfMbLR_fA__MK7aDvmsJpV-oh-7eez9hrw8,3452
-braintrust/wrappers/test_anthropic.py,sha256=DcLrYhFUhBFiYcP_Su3FcEW6-Ubt21JzjY8Hxwzpcbw,15495
-braintrust/wrappers/test_dspy.py,sha256=peWwbBBi8mpDhp2brs4ozd5cWz_CjYoyQTp7hjvt97U,1759
-braintrust/wrappers/test_google_genai.py,sha256=dY5ZXeTscvrz_8HfSbMr2Qbb_0W-FzUvQSzpG6EZXnU,20204
+braintrust/wrappers/pydantic_ai.py,sha256=dukJCdcfkRc0ue8nPHpI5DogwNvL9kooGJEbri2W97w,48435
+braintrust/wrappers/test_agno.py,sha256=ad5w6CEWzNwmzbF4NwSvHWhw1SpSjrt-X29pCmBRkhY,3772
+braintrust/wrappers/test_anthropic.py,sha256=VkmlP3_FrZ12x5YWxcbx11A-TEZUghGQeQ4OuT3R4Oc,21409
+braintrust/wrappers/test_dspy.py,sha256=0hlNi-JR3SJdYvFXAzD7AKuFJO0aXrbGVCV19OxIXdo,6382
+braintrust/wrappers/test_google_genai.py,sha256=BKkPfLFk2JG1UNJ3mFKzv5OjioWqo7EQ0WSwZzvDltI,20563
 braintrust/wrappers/test_langsmith_wrapper.py,sha256=wEbPNy4o7VVvcuHcsCJ-sy2EATvBxhUXTYFBQNkKCjs,10449
-braintrust/wrappers/test_litellm.py,sha256=BAdksj_yzoY0LoHpnDHVgUpOaSxkI_I9Nk5ZZEVuaAU,23604
+braintrust/wrappers/test_litellm.py,sha256=MKukVH-C-Mwc0-cVJZhkLdXwiXupXHc8EiWYKq0X8V0,23620
 braintrust/wrappers/test_oai_attachments.py,sha256=_EtNXjQxPgqXmj6UYMZn9GF4GDZf8m_1_TrwiEk7HWQ,11100
-braintrust/wrappers/test_openai.py,sha256=8gQqJigWmEe3_Nxc5vvPndLIuhIeBY2B2oHLU_vuUkk,60065
+braintrust/wrappers/test_openai.py,sha256=pC-5zO2CbeG1wmQ5IvbCQ5vXic5sZgTCTW7347QwbwI,69474
 braintrust/wrappers/test_openrouter.py,sha256=8HUfILPugOMqcvttpq76KQrynFb0xZpazvta7TTSF6A,3849
-braintrust/wrappers/test_pydantic_ai_integration.py,sha256=oK26oEI56feg3SwbA-fxkGtVMS8eAC9j-gJsOUudmzw,104106
+braintrust/wrappers/test_pydantic_ai_integration.py,sha256=xUSkiY5HUI-Z9G_etjyX7rGlOjBEdEY9CwVHyWM3xEE,104460
 braintrust/wrappers/test_pydantic_ai_wrap_openai.py,sha256=OO5NrbothkMr4v2sZ-EZLH7-yLj3k6TfdLG4uzXAsQk,5090
-braintrust/wrappers/test_utils.py,sha256=Qz7LYG5V0DK2KuTJ_YLGpO_Zr_LJFfJgZX_Ps8tlM_c,505
-braintrust/wrappers/agno/__init__.py,sha256=0ehV_7L_ILsMfZ1bKHnzcR_CvFM98KMbGFN9UiE94vI,2379
+braintrust/wrappers/test_utils.py,sha256=wpLNRSCAZ42eG4srJrGFMAlfBSkhaCOcn2QwJXkRQ7s,3005
+braintrust/wrappers/threads.py,sha256=rGQO6aFmFstrXA4xPEZCGTZJ1FC7CAS_4zF6ikszprc,3682
+braintrust/wrappers/agno/__init__.py,sha256=soVMMmm_nmMcX9rWxfmKw9ur03XNKRcDmlf3G4GbR4g,2306
 braintrust/wrappers/agno/agent.py,sha256=m3HCxQNotJviJswGYMxxsOnMilF-DNGqeFZFJa2Zhs4,6473
 braintrust/wrappers/agno/function_call.py,sha256=MSsHLGoBk98xGlm-CYnjE5pYBi-IJfokLhjtbYgJpX0,2206
 braintrust/wrappers/agno/model.py,sha256=VVFHEPlJ210P8BmSNQp8LchulHo62s4xvitvrR535yc,10714
 braintrust/wrappers/agno/team.py,sha256=hYCnmeunLk47PEkoOrlpbxFERjK-D4evR07ghoiO5UU,6452
 braintrust/wrappers/agno/utils.py,sha256=_b_s2WzAJ5HIkZ8Qbq5ZKctsdFDh5tX3gFuRiT2o6g0,15685
-braintrust/wrappers/claude_agent_sdk/__init__.py,sha256=dcBP61ijW2B4g902-09ZfIOkAkC2GtPWz9Rg3RWELWQ,4390
+braintrust/wrappers/claude_agent_sdk/__init__.py,sha256=4FUE59ii39jVfhMAfkOcU-TJ5rh2d3sX6fLzo2EcCJ8,4281
 braintrust/wrappers/claude_agent_sdk/_wrapper.py,sha256=UNZBcgTu7X71zvJKy6e-QQFuz9j8kRS6Kd1VOh3OOXA,17755
-braintrust/wrappers/claude_agent_sdk/test_wrapper.py,sha256=pozwSJAD7DKJRoOdekR8Bvyv1Iu7XuCnwl4Ep60oMYE,10401
-braintrust/wrappers/google_genai/__init__.py,sha256=Yv4hBOUc6TjUpYH3bEW8UaYiZ-sm3TpdVfqUw50NwQU,15826
-braintrust-0.5.0.dist-info/METADATA,sha256=fYC6JxpWH65cyszHdVaLBkhGx9KCSAq7zGBatfHc7n4,3753
-braintrust-0.5.0.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
-braintrust-0.5.0.dist-info/entry_points.txt,sha256=Zpc0_09g5xm8as5jHqqFq7fhwO0xHSNct_TrEMONS7Q,60
-braintrust-0.5.0.dist-info/top_level.txt,sha256=hw1-y-UFMf60RzAr8x_eM7SThbIuWfQsQIbVvqSF83A,11
-braintrust-0.5.0.dist-info/RECORD,,
+braintrust/wrappers/claude_agent_sdk/test_wrapper.py,sha256=RmSzTfDC3tkepEbc9S_KYFITsjGVyllYE1fF9roSqBk,10779
+braintrust/wrappers/google_genai/__init__.py,sha256=C7MzKUr17CEcIbP0kg9L9IjN-6suE3NQ-oSYAjXdR_g,15832
+braintrust-0.5.3.dist-info/METADATA,sha256=snLiF8lw3wJkTkmgZnbthtfApgwnFb7eKFNARCWK0mM,3753
+braintrust-0.5.3.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+braintrust-0.5.3.dist-info/entry_points.txt,sha256=Zpc0_09g5xm8as5jHqqFq7fhwO0xHSNct_TrEMONS7Q,60
+braintrust-0.5.3.dist-info/top_level.txt,sha256=hw1-y-UFMf60RzAr8x_eM7SThbIuWfQsQIbVvqSF83A,11
+braintrust-0.5.3.dist-info/RECORD,,

{braintrust-0.5.0.dist-info → braintrust-0.5.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.10.1)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any