braintrust 0.3.7__py3-none-any.whl → 0.3.9__py3-none-any.whl

braintrust/_generated_types.py

@@ -212,6 +212,17 @@ CallEvent = Union[
 ]
 
 
+class ChatCompletionContentPartFileFile(TypedDict):
+    file_data: NotRequired[Optional[str]]
+    filename: NotRequired[Optional[str]]
+    file_id: NotRequired[Optional[str]]
+
+
+class ChatCompletionContentPartFileWithTitle(TypedDict):
+    file: ChatCompletionContentPartFileFile
+    type: Literal['file']
+
+
 class ChatCompletionContentPartImageWithTitleImageUrl(TypedDict):
     url: str
     detail: NotRequired[Optional[Union[Literal['auto'], Literal['low'], Literal['high']]]]
@@ -342,7 +353,7 @@ class ChatCompletionTool(TypedDict):
 
 
 class CodeBundleRuntimeContext(TypedDict):
-    runtime: Literal['node', 'python']
+    runtime: Literal['node', 'python', 'browser']
     version: str
 
 
@@ -570,7 +581,7 @@ class Data(CodeBundle):
 
 
 class FunctionDataFunctionData1DataRuntimeContext(TypedDict):
-    runtime: Literal['node', 'python']
+    runtime: Literal['node', 'python', 'browser']
     version: str
 
 
@@ -649,7 +660,7 @@ class FunctionIdFunctionId3(TypedDict):
 
 
 class FunctionIdFunctionId4InlineContext(TypedDict):
-    runtime: Literal['node', 'python']
+    runtime: Literal['node', 'python', 'browser']
     version: str
 
 
@@ -668,16 +679,16 @@ class FunctionIdFunctionId4(TypedDict):
 FunctionIdRef = Mapping[str, Any]
 
 
-FunctionObjectType = Literal['prompt', 'tool', 'scorer', 'task', 'agent']
+FunctionObjectType = Literal['prompt', 'tool', 'scorer', 'task', 'agent', 'custom_view']
 
 
 FunctionOutputType = Literal['completion', 'score', 'any']
 
 
-FunctionTypeEnum = Literal['llm', 'scorer', 'task', 'tool']
+FunctionTypeEnum = Literal['llm', 'scorer', 'task', 'tool', 'custom_view']
 
 
-FunctionTypeEnumNullish = Literal['llm', 'scorer', 'task', 'tool']
+FunctionTypeEnumNullish = Literal['llm', 'scorer', 'task', 'tool', 'custom_view']
 
 
 class GitMetadataSettings(TypedDict):
@@ -1854,7 +1865,7 @@ class AnyModelParams(TypedDict):
     function_call: NotRequired[Optional[Union[Literal['auto'], Literal['none'], AnyModelParamsFunctionCall]]]
     n: NotRequired[Optional[float]]
     stop: NotRequired[Optional[Sequence[str]]]
-    reasoning_effort: NotRequired[Optional[Literal['minimal', 'low', 'medium', 'high']]]
+    reasoning_effort: NotRequired[Optional[Literal['none', 'minimal', 'low', 'medium', 'high']]]
     verbosity: NotRequired[Optional[Literal['low', 'medium', 'high']]]
     top_k: NotRequired[Optional[float]]
     stop_sequences: NotRequired[Optional[Sequence[str]]]
@@ -1894,7 +1905,11 @@ class AttachmentStatus(TypedDict):
     """
 
 
-ChatCompletionContentPart = Union[ChatCompletionContentPartTextWithTitle, ChatCompletionContentPartImageWithTitle]
+ChatCompletionContentPart = Union[
+    ChatCompletionContentPartTextWithTitle,
+    ChatCompletionContentPartImageWithTitle,
+    ChatCompletionContentPartFileWithTitle,
+]
 
 
 class ChatCompletionMessageParamChatCompletionMessageParam1(TypedDict):
@@ -1993,6 +2008,14 @@ class DatasetEvent(TypedDict):
     Whether this span is a root span
     """
     origin: NotRequired[Optional[ObjectReferenceNullish]]
+    comments: NotRequired[Optional[Sequence[Any]]]
+    """
+    Optional list of comments attached to this event
+    """
+    audit_data: NotRequired[Optional[Sequence[Any]]]
+    """
+    Optional list of audit entries attached to this event
+    """
 
 
 class Experiment(TypedDict):
@@ -2075,7 +2098,7 @@ class ModelParamsModelParams(TypedDict):
     function_call: NotRequired[Optional[Union[Literal['auto'], Literal['none'], ModelParamsModelParamsFunctionCall]]]
     n: NotRequired[Optional[float]]
     stop: NotRequired[Optional[Sequence[str]]]
-    reasoning_effort: NotRequired[Optional[Literal['minimal', 'low', 'medium', 'high']]]
+    reasoning_effort: NotRequired[Optional[Literal['none', 'minimal', 'low', 'medium', 'high']]]
     verbosity: NotRequired[Optional[Literal['low', 'medium', 'high']]]
 
 
@@ -2327,6 +2350,14 @@ class ExperimentEvent(TypedDict):
     Whether this span is a root span
     """
     origin: NotRequired[Optional[ObjectReferenceNullish]]
+    comments: NotRequired[Optional[Sequence[Any]]]
+    """
+    Optional list of comments attached to this event
+    """
+    audit_data: NotRequired[Optional[Sequence[Any]]]
+    """
+    Optional list of audit entries attached to this event
+    """
 
 
 class GraphNodeGraphNode7(TypedDict):
@@ -2437,6 +2468,18 @@ class ProjectLogsEvent(TypedDict):
     """
     span_attributes: NotRequired[Optional[SpanAttributes]]
     origin: NotRequired[Optional[ObjectReferenceNullish]]
+    comments: NotRequired[Optional[Sequence[Any]]]
+    """
+    Optional list of comments attached to this event
+    """
+    audit_data: NotRequired[Optional[Sequence[Any]]]
+    """
+    Optional list of audit entries attached to this event
+    """
+    _async_scoring_state: NotRequired[Optional[Any]]
+    """
+    The async scoring state for this event
+    """
 
 
 class ProjectScore(TypedDict):

braintrust/framework2.py

@@ -3,7 +3,6 @@ import json
 from typing import Any, Callable, Dict, List, Optional, Union, overload
 
 import slugify
-
 from braintrust.logger import api_conn, app_conn, login
 
 from .framework import _is_lazy_load, bcolors  # type: ignore

braintrust/generated_types.py

@@ -1,4 +1,4 @@
-"""Auto-generated file (internal git SHA 93e76a7bcdf0f874a1827af017d26ac37995a47b) -- do not modify"""
+"""Auto-generated file (internal git SHA 8e9c0a96b3cf291360978c17580f72f6817bd6c8) -- do not modify"""
 
 from ._generated_types import (
     Acl,
@@ -14,6 +14,8 @@ from ._generated_types import (
     BraintrustModelParams,
     CallEvent,
     ChatCompletionContentPart,
+    ChatCompletionContentPartFileFile,
+    ChatCompletionContentPartFileWithTitle,
     ChatCompletionContentPartImageWithTitle,
     ChatCompletionContentPartText,
     ChatCompletionContentPartTextWithTitle,
@@ -111,6 +113,8 @@ __all__ = [
     "BraintrustModelParams",
     "CallEvent",
     "ChatCompletionContentPart",
+    "ChatCompletionContentPartFileFile",
+    "ChatCompletionContentPartFileWithTitle",
     "ChatCompletionContentPartImageWithTitle",
     "ChatCompletionContentPartText",
     "ChatCompletionContentPartTextWithTitle",

braintrust/logger.py

@@ -459,22 +459,24 @@ class BraintrustState:
 
     def copy_state(self, other: "BraintrustState"):
         """Copy login information from another BraintrustState instance."""
-        self.__dict__.update({
-            k: v
-            for (k, v) in other.__dict__.items()
-            if k
-            not in (
-                "current_experiment",
-                "current_logger",
-                "current_parent",
-                "current_span",
-                "_global_bg_logger",
-                "_override_bg_logger",
-                "_context_manager",
-                "_last_otel_setting",
-                "_context_manager_lock",
-            )
-        })
+        self.__dict__.update(
+            {
+                k: v
+                for (k, v) in other.__dict__.items()
+                if k
+                not in (
+                    "current_experiment",
+                    "current_logger",
+                    "current_parent",
+                    "current_span",
+                    "_global_bg_logger",
+                    "_override_bg_logger",
+                    "_context_manager",
+                    "_last_otel_setting",
+                    "_context_manager_lock",
+                )
+            }
+        )
 
     def login(
         self,
@@ -750,7 +752,7 @@ def construct_logs3_data(items: Sequence[str]):
 def _check_json_serializable(event):
     try:
         return bt_dumps(event)
-    except TypeError as e:
+    except (TypeError, ValueError) as e:
         raise Exception(f"All logged values must be JSON-serializable: {event}") from e
 
 
@@ -2439,19 +2441,46 @@ def _deep_copy_event(event: Mapping[str, Any]) -> Dict[str, Any]:
     Creates a deep copy of the given event. Replaces references to user objects
     with placeholder strings to ensure serializability, except for `Attachment`
     and `ExternalAttachment` objects, which are preserved and not deep-copied.
-    """
 
-    def _deep_copy_object(v: Any) -> Any:
-        if isinstance(v, Mapping):
-            # Prevent dict keys from holding references to user data. Note that
-            # `bt_json` already coerces keys to string, a behavior that comes from
-            # `json.dumps`. However, that runs at log upload time, while we want to
-            # cut out all the references to user objects synchronously in this
-            # function.
-            return {str(k): _deep_copy_object(v[k]) for k in v}
-        elif isinstance(v, (List, Tuple, Set)):
-            return [_deep_copy_object(x) for x in v]
-        elif isinstance(v, Span):
+    Handles circular references and excessive nesting depth to prevent
+    RecursionError during serialization.
+    """
+    # Maximum depth to prevent hitting Python's recursion limit
+    # Python's default limit is ~1000, we use a conservative limit
+    # to account for existing call stack usage from pytest, application code, etc.
+    MAX_DEPTH = 200
+
+    # Track visited objects to detect circular references
+    visited: set[int] = set()
+
+    def _deep_copy_object(v: Any, depth: int = 0) -> Any:
+        # Check depth limit - use >= to stop before exceeding
+        if depth >= MAX_DEPTH:
+            return "<max depth exceeded>"
+
+        # Check for circular references in mutable containers
+        # Use id() to track object identity
+        if isinstance(v, (Mapping, List, Tuple, Set)):
+            obj_id = id(v)
+            if obj_id in visited:
+                return "<circular reference>"
+            visited.add(obj_id)
+            try:
+                if isinstance(v, Mapping):
+                    # Prevent dict keys from holding references to user data. Note that
+                    # `bt_json` already coerces keys to string, a behavior that comes from
+                    # `json.dumps`. However, that runs at log upload time, while we want to
+                    # cut out all the references to user objects synchronously in this
+                    # function.
+                    return {str(k): _deep_copy_object(v[k], depth + 1) for k in v}
+                elif isinstance(v, (List, Tuple, Set)):
+                    return [_deep_copy_object(x, depth + 1) for x in v]
+            finally:
+                # Remove from visited set after processing to allow the same object
+                # to appear in different branches of the tree
+                visited.discard(obj_id)
+
+        if isinstance(v, Span):
             return "<span>"
         elif isinstance(v, Experiment):
             return "<experiment>"
@@ -3278,17 +3307,17 @@ def _start_span_parent_args(
     if parent:
         assert parent_span_ids is None, "Cannot specify both parent and parent_span_ids"
         parent_components = SpanComponentsV4.from_str(parent)
-        assert (
-            parent_object_type == parent_components.object_type
-        ), f"Mismatch between expected span parent object type {parent_object_type} and provided type {parent_components.object_type}"
+        assert parent_object_type == parent_components.object_type, (
+            f"Mismatch between expected span parent object type {parent_object_type} and provided type {parent_components.object_type}"
+        )
 
         parent_components_object_id_lambda = _span_components_to_object_id_lambda(parent_components)
 
         def compute_parent_object_id():
             parent_components_object_id = parent_components_object_id_lambda()
-            assert (
-                parent_object_id.get() == parent_components_object_id
-            ), f"Mismatch between expected span parent object id {parent_object_id.get()} and provided id {parent_components_object_id}"
+            assert parent_object_id.get() == parent_components_object_id, (
+                f"Mismatch between expected span parent object id {parent_object_id.get()} and provided id {parent_components_object_id}"
+            )
             return parent_object_id.get()
 
         arg_parent_object_id = LazyValue(compute_parent_object_id, use_mutex=False)
@@ -3896,8 +3925,8 @@ class SpanImpl(Span):
             **{IS_MERGE_FIELD: self._is_merge},
         )
 
-        _check_json_serializable(partial_record)
         serializable_partial_record = _deep_copy_event(partial_record)
+        _check_json_serializable(serializable_partial_record)
         if serializable_partial_record.get("metrics", {}).get("end") is not None:
             self._logged_end_time = serializable_partial_record["metrics"]["end"]
 
@@ -4453,10 +4482,24 @@ def render_message(render: Callable[[str], str], message: PromptMessage):
                 if c["type"] == "text":
                     rendered_content.append({**c, "text": render(c["text"])})
                 elif c["type"] == "image_url":
-                    rendered_content.append({
-                        **c,
-                        "image_url": {**c["image_url"], "url": render(c["image_url"]["url"])},
-                    })
+                    rendered_content.append(
+                        {
+                            **c,
+                            "image_url": {**c["image_url"], "url": render(c["image_url"]["url"])},
+                        }
+                    )
+                elif c["type"] == "file":
+                    rendered_content.append(
+                        {
+                            **c,
+                            "file": {
+                                **c["file"],
+                                "file_data": render(c["file"]["file_data"]),
+                                **({} if "file_id" not in c["file"] else {"file_id": render(c["file"]["file_id"])}),
+                                **({} if "filename" not in c["file"] else {"filename": render(c["file"]["filename"])}),
+                            },
+                        }
+                    )
                 else:
                     raise ValueError(f"Unknown content type: {c['type']}")
 

braintrust/test_logger.py

@@ -20,7 +20,7 @@ from braintrust import (
     logger,
 )
 from braintrust.id_gen import OTELIDGenerator, get_id_generator
-from braintrust.logger import _deep_copy_event, _extract_attachments, parent_context, render_mustache
+from braintrust.logger import _deep_copy_event, _extract_attachments, parent_context, render_message, render_mustache
 from braintrust.prompt import PromptChatBlock, PromptData, PromptMessage, PromptSchema
 from braintrust.test_helpers import (
     assert_dict_matches,
@@ -252,6 +252,32 @@ class TestLogger(TestCase):
         self.assertIs(copy["output"]["attachmentList"][1], attachment2)
         self.assertIs(copy["output"]["attachmentList"][3], attachment3)
 
+    def test_check_json_serializable_catches_circular_references(self):
+        """Test that _check_json_serializable properly handles circular references.
+
+        After fix, _check_json_serializable should catch ValueError from circular
+        references and convert them to a more appropriate exception or handle them.
+        """
+        from braintrust.logger import _check_json_serializable
+
+        # Create data with circular reference
+        data = {"a": "b"}
+        data["self"] = data
+
+        # Should either succeed (by handling circular refs) or raise a clear exception
+        # The error message should indicate the data is not serializable
+        try:
+            result = _check_json_serializable(data)
+            # If it succeeds, it should return a serialized string
+            self.assertIsInstance(result, str)
+        except Exception as e:
+            # If it raises an exception, it should mention serialization issue
+            error_msg = str(e).lower()
+            self.assertTrue(
+                "json-serializable" in error_msg or "circular" in error_msg,
+                f"Expected error message to mention serialization issue, got: {e}",
+            )
+
     def test_prompt_build_with_structured_output_templating(self):
         self.maxDiff = None
         prompt = Prompt(
@@ -459,6 +485,46 @@ class TestLogger(TestCase):
         with self.assertRaises(ValueError):
             prompt.build(items=["only_one"], strict=True)
 
+    def test_render_message_with_file_content_parts(self):
+        """Test render_message with mixed text, image, and file content parts including all file fields."""
+        message = PromptMessage(
+            role="user",
+            content=[
+                {"type": "text", "text": "Here is a {{item}}:"},
+                {"type": "image_url", "image_url": {"url": "{{image_url}}"}},
+                {
+                    "type": "file",
+                    "file": {
+                        "file_data": "{{file_data}}",
+                        "file_id": "{{file_id}}",
+                        "filename": "{{filename}}",
+                    },
+                },
+            ],
+        )
+
+        rendered = render_message(
+            lambda template: template.replace("{{item}}", "document")
+            .replace("{{image_url}}", "https://example.com/image.png")
+            .replace("{{file_data}}", "base64data")
+            .replace("{{file_id}}", "file-456")
+            .replace("{{filename}}", "report.pdf"),
+            message,
+        )
+
+        assert rendered["content"] == [
+            {"type": "text", "text": "Here is a document:"},
+            {"type": "image_url", "image_url": {"url": "https://example.com/image.png"}},
+            {
+                "type": "file",
+                "file": {
+                    "file_data": "base64data",
+                    "file_id": "file-456",
+                    "filename": "report.pdf",
+                },
+            },
+        ]
+
 
 def test_noop_permalink_issue_1837():
     # fixes issue #BRA-1837
@@ -471,6 +537,185 @@ def test_noop_permalink_issue_1837():
     assert span.link() == "https://www.braintrust.dev/noop-span"
 
 
+def test_span_log_with_simple_circular_reference(with_memory_logger):
+    """Test that span.log() with simple circular reference works gracefully."""
+    logger = init_test_logger(__name__)
+
+    with logger.start_span(name="test_span") as span:
+        # Create simple circular reference
+        data = {"key": "value"}
+        data["self"] = data
+
+        # Should handle circular reference gracefully
+        span.log(
+            input={"test": "simple circular ref"},
+            output=data,
+        )
+
+    # Verify the log was recorded with circular reference replaced by placeholder
+    logs = with_memory_logger.pop()
+    assert len(logs) == 1
+
+    logged_output = logs[0]["output"]
+    assert logged_output["key"] == "value"
+    # Circular reference should be replaced with a placeholder string
+    assert isinstance(logged_output["self"], str)
+    assert "circular" in logged_output["self"].lower()
+
+
+def test_span_log_with_nested_circular_reference(with_memory_logger):
+    """Test that span.log() with nested circular reference works gracefully."""
+    logger = init_test_logger(__name__)
+
+    with logger.start_span(name="test_span") as span:
+        # Create nested structure with circular reference
+        page = {"page_number": 1, "content": "text"}
+        document = {"pages": [page]}
+        page["document"] = document
+
+        # Should handle circular reference gracefully
+        span.log(
+            input={"file": "test.pdf"},
+            output=document,
+        )
+
+    # Verify the log was recorded with nested circular reference handled
+    logs = with_memory_logger.pop()
+    assert len(logs) == 1
+
+    logged_output = logs[0]["output"]
+    assert len(logged_output["pages"]) == 1
+    assert logged_output["pages"][0]["page_number"] == 1
+    assert logged_output["pages"][0]["content"] == "text"
+    # Circular reference should be replaced with a placeholder
+    assert isinstance(logged_output["pages"][0]["document"], str)
+    assert "circular" in logged_output["pages"][0]["document"].lower()
+
+
+def test_span_log_with_deep_document_structure(with_memory_logger):
+    """Test that span.log() with deeply nested document structure works gracefully."""
+    logger = init_test_logger(__name__)
+
+    with logger.start_span(name="test_span") as span:
+        # Create deeply nested document structure with circular reference
+        doc_data = {
+            "model_id": "document-model",
+            "content": "Document content",
+            "pages": [],
+        }
+
+        page = {
+            "page_number": 1,
+            "lines": [{"content": "Line 1"}],
+        }
+
+        # Create circular reference
+        page["document"] = doc_data
+        doc_data["pages"].append(page)
+
+        # Should handle circular reference gracefully
+        span.log(
+            input={"file": "test.pdf"},
+            output=doc_data,
+            metadata={"source": "document_processor"},
+        )
+
+    # Verify the log was recorded with proper structure
+    logs = with_memory_logger.pop()
+    assert len(logs) == 1
+
+    logged_output = logs[0]["output"]
+    assert logged_output["model_id"] == "document-model"
+    assert logged_output["content"] == "Document content"
+    assert len(logged_output["pages"]) == 1
+    assert logged_output["pages"][0]["page_number"] == 1
+    assert len(logged_output["pages"][0]["lines"]) == 1
+    assert logged_output["pages"][0]["lines"][0]["content"] == "Line 1"
+    # Circular reference should be replaced with placeholder
+    assert isinstance(logged_output["pages"][0]["document"], str)
+    assert "circular" in logged_output["pages"][0]["document"].lower()
+
+
+def test_span_log_with_extremely_deep_nesting(with_memory_logger):
+    """Test that span.log() with extremely deep nesting works gracefully."""
+    import sys
+
+    logger = init_test_logger(__name__)
+
+    with logger.start_span(name="test_span") as span:
+        recursion_limit = sys.getrecursionlimit()
+
+        # Create structure deeper than recursion limit
+        deeply_nested = {"level": 0}
+        current = deeply_nested
+        for i in range(1, recursion_limit + 100):
+            current["nested"] = {"level": i}
+            current = current["nested"]
+
+        # Should handle extremely deep nesting without RecursionError
+        span.log(
+            input={"test": "deep nesting"},
+            output=deeply_nested,
+        )
+
+    # Verify the log was recorded (may be truncated or have placeholder for deep nesting)
+    logs = with_memory_logger.pop()
+    assert len(logs) == 1
+
+    logged_output = logs[0]["output"]
+    assert logged_output["level"] == 0
+    # Either the structure is preserved up to a safe depth, or replaced with placeholder
+    assert "nested" in logged_output
+
+
+def test_span_log_with_large_document_many_pages(with_memory_logger):
+    """Test that span.log() with large multi-page document works gracefully."""
+    logger = init_test_logger(__name__)
+
+    with logger.start_span(name="test_span") as span:
+        # Create realistic large document: 20 pages × 30 lines × 10 words
+        pages = []
+        for page_num in range(20):
+            lines = []
+            for line_num in range(30):
+                words = []
+                for word_num in range(10):
+                    words.append(
+                        {
+                            "content": f"word_{word_num}",
+                            "confidence": 0.98,
+                        }
+                    )
+                lines.append(
+                    {
+                        "content": f"line_{line_num}",
+                        "words": words,
+                    }
+                )
+            pages.append(
+                {
+                    "page_number": page_num + 1,
+                    "lines": lines,
+                }
+            )
+
+        # Should handle large document structure
+        span.log(
+            input={"file": "large_document.pdf"},
+            output={"pages": pages},
+        )
+
+    # Verify the log was recorded with full structure intact (no circular refs)
+    logs = with_memory_logger.pop()
+    assert len(logs) == 1
+
+    logged_output = logs[0]["output"]
+    assert len(logged_output["pages"]) == 20
+    assert len(logged_output["pages"][0]["lines"]) == 30
+    assert len(logged_output["pages"][0]["lines"][0]["words"]) == 10
+    assert logged_output["pages"][0]["lines"][0]["words"][0]["content"] == "word_0"
+
+
 def test_span_link_logged_out(with_memory_logger):
     simulate_logout()
     assert_logged_out()
@@ -1762,7 +2007,6 @@ def test_parent_precedence_traced_baseline(with_memory_logger, with_simulate_log
     assert top_log["span_id"] in (child_log.get("span_parents") or [])
 
 
-
 def test_parent_precedence_explicit_parent_overrides(with_memory_logger, with_simulate_login):
     """Test that explicit parent overrides current span."""
     init_test_logger(__name__)
@@ -1800,6 +2044,7 @@ def reset_id_generator_state():
         if original_env:
             os.environ["BRAINTRUST_OTEL_COMPAT"] = original_env
 
+
 def test_otel_compatible_span_export_import():
     """Test that spans with OTEL-compatible IDs can be exported and imported correctly."""
     from braintrust.span_identifier_v4 import SpanComponentsV4, SpanObjectTypeV3
@@ -1807,21 +2052,21 @@ def test_otel_compatible_span_export_import():
     # Generate OTEL-compatible IDs
     otel_gen = OTELIDGenerator()
     trace_id = otel_gen.get_trace_id()  # 32-char hex (16 bytes)
-    span_id = otel_gen.get_span_id()    # 16-char hex (8 bytes)
+    span_id = otel_gen.get_span_id()  # 16-char hex (8 bytes)
 
     # Test that trace_id is 32 chars and span_id is 16 chars
     assert len(trace_id) == 32
     assert len(span_id) == 16
-    assert all(c in '0123456789abcdef' for c in trace_id)
-    assert all(c in '0123456789abcdef' for c in span_id)
+    assert all(c in "0123456789abcdef" for c in trace_id)
+    assert all(c in "0123456789abcdef" for c in span_id)
 
     # Create span components
     components = SpanComponentsV4(
         object_type=SpanObjectTypeV3.PROJECT_LOGS,
-        object_id='test-project-id',
-        row_id='test-row-id',
+        object_id="test-project-id",
+        row_id="test-row-id",
         span_id=span_id,
-        root_span_id=trace_id
+        root_span_id=trace_id,
     )
 
     # Test export/import cycle
@@ -1856,14 +2101,15 @@ def test_span_with_otel_ids_export_import(reset_id_generator_state):
         # Verify the span has OTEL-compatible IDs
         assert len(span.span_id) == 16  # 8-byte hex
         assert len(span.root_span_id) == 32  # 16-byte hex
-        assert all(c in '0123456789abcdef' for c in span.span_id)
-        assert all(c in '0123456789abcdef' for c in span.root_span_id)
+        assert all(c in "0123456789abcdef" for c in span.span_id)
+        assert all(c in "0123456789abcdef" for c in span.root_span_id)
 
         # Export the span
         exported = span.export()
 
         # Parse it back
         from braintrust.span_identifier_v4 import SpanComponentsV4
+
         imported = SpanComponentsV4.from_str(exported)
 
         # Verify IDs are preserved exactly
@@ -1874,9 +2120,10 @@ def test_span_with_otel_ids_export_import(reset_id_generator_state):
 def test_span_with_uuid_ids_share_root_span_id(reset_id_generator_state):
     """Test that UUID generators share span_id as root_span_id for backwards compatibility."""
     import os
+
     # Ensure UUID generator is used (default behavior)
-    if 'BRAINTRUST_OTEL_COMPAT' in os.environ:
-        del os.environ['BRAINTRUST_OTEL_COMPAT']
+    if "BRAINTRUST_OTEL_COMPAT" in os.environ:
+        del os.environ["BRAINTRUST_OTEL_COMPAT"]
 
     init_test_logger(__name__)
 
@@ -1901,7 +2148,7 @@ def test_parent_context_with_otel_ids(with_memory_logger, reset_id_generator_sta
         original_root_span_id = parent_span.root_span_id
 
     def is_hex(s):
-        return all(c in '0123456789abcdef' for c in s.lower())
+        return all(c in "0123456789abcdef" for c in s.lower())
 
     assert is_hex(original_span_id)
     assert is_hex(original_root_span_id)
@@ -1978,14 +2225,15 @@ def test_span_start_span_with_explicit_parent(with_memory_logger):
     span3_log = next(l for l in logs if l.get("span_attributes", {}).get("name") == "span3")
 
     # span3 should NOT have span2 as parent (would happen if it inherited from context)
-    assert span2_span_id not in span3_log.get("span_parents", []), \
+    assert span2_span_id not in span3_log.get("span_parents", []), (
         "span3 should not inherit from span2 context when explicit parent is provided"
+    )
 
     # span3 should inherit from root (the explicit parent)
-    assert root_span_id in span3_log.get("span_parents", []), \
+    assert root_span_id in span3_log.get("span_parents", []), (
         "span3 should have root_span_id in span_parents from explicit parent"
-    assert span3_log["root_span_id"] == root_root_span_id, \
-        "span3 should have root's root_span_id"
+    )
+    assert span3_log["root_span_id"] == root_root_span_id, "span3 should have root's root_span_id"
 
 
 def test_span_start_span_inherits_from_self(with_memory_logger):
@@ -2011,8 +2259,9 @@ def test_span_start_span_inherits_from_self(with_memory_logger):
 
     # Child should inherit parent's root_span_id and have parent_span_id in span_parents
     assert child_log["root_span_id"] == parent_root_span_id
-    assert parent_span_id in child_log.get("span_parents", []), \
+    assert parent_span_id in child_log.get("span_parents", []), (
         "child should have parent_span_id in span_parents when no explicit parent is provided"
+    )
 
 
 def test_span_start_span_with_exported_span_parent(with_memory_logger):
@@ -2046,10 +2295,12 @@ def test_span_start_span_with_exported_span_parent(with_memory_logger):
 
     # Child should inherit from exported_parent, not active_context
     assert child_log["root_span_id"] == exported_parent_root_span_id
-    assert exported_parent_span_id in child_log.get("span_parents", []), \
+    assert exported_parent_span_id in child_log.get("span_parents", []), (
         "child should have exported_parent_span_id in span_parents"
-    assert active_context_span_id not in child_log.get("span_parents", []), \
+    )
+    assert active_context_span_id not in child_log.get("span_parents", []), (
         "child should NOT have active_context_span_id in span_parents"
+    )
 
 
 def test_get_exporter_returns_v3_by_default():
@@ -2082,6 +2333,7 @@ def test_experiment_export_respects_otel_compat_default():
         exported = experiment.export()
 
         from braintrust.span_identifier_v4 import SpanComponentsV4
+
         version = SpanComponentsV4.get_version(exported)
         assert version == 3, f"Expected V3 encoding (version=3), got version={version}"
 
@@ -2094,6 +2346,7 @@ def test_experiment_export_respects_otel_compat_enabled():
         exported = experiment.export()
 
         from braintrust.span_identifier_v4 import SpanComponentsV4
+
         version = SpanComponentsV4.get_version(exported)
         assert version == 4, f"Expected V4 encoding (version=4), got version={version}"
 
@@ -2106,6 +2359,7 @@ def test_logger_export_respects_otel_compat_default():
         exported = test_logger.export()
 
         from braintrust.span_identifier_v4 import SpanComponentsV4
+
         version = SpanComponentsV4.get_version(exported)
         assert version == 3, f"Expected V3 encoding (version=3), got version={version}"
 
@@ -2118,6 +2372,7 @@ def test_logger_export_respects_otel_compat_enabled():
         exported = test_logger.export()
 
         from braintrust.span_identifier_v4 import SpanComponentsV4
+
         version = SpanComponentsV4.get_version(exported)
         assert version == 4, f"Expected V4 encoding (version=4), got version={version}"
 

braintrust/version.py

@@ -1,4 +1,4 @@
-VERSION = "0.3.7"
+VERSION = "0.3.9"
 
 # this will be templated during the build
-GIT_COMMIT = "1cbc14e38442cfbae772c080de6e17b3df09868f"
+GIT_COMMIT = "238ae256a3a1ab93e682d603c4b53652fa0059f1"

{braintrust-0.3.7.dist-info → braintrust-0.3.9.dist-info}/METADATA

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

{braintrust-0.3.7.dist-info → braintrust-0.3.9.dist-info}/RECORD

@@ -1,5 +1,5 @@
 braintrust/__init__.py,sha256=-NLWOaTdzVtQFu2TA0qYULbxP4pAdVdgqzZWosqL2eI,2092
-braintrust/_generated_types.py,sha256=B3m9AxXfe2Fza63Kfq7doyecINU26Bqio1HxZbObqQM,79603
+braintrust/_generated_types.py,sha256=X5UGdtWp9vnoyUd4PyY74xjWIoNRVqiqWHNpYd-v0to,80911
 braintrust/audit.py,sha256=Na3LJhpHj8Nd1az41HMQLLbHeWQkDZIOYHLLmVZdAdQ,467
 braintrust/aws.py,sha256=OBz_SRyopgpCDSNvETLypzGwTXk-bNLn-Eisevnjfwo,377
 braintrust/bt_json.py,sha256=NrpEpl7FkwgL3sSg_XoKCR8HYy9uEiBOfaJ4r7HkW2U,816
@@ -7,14 +7,14 @@ braintrust/conftest.py,sha256=_leQUhneeVovUhXeHdXiyC04bykrjWs75XJNvmXsR_g,1385
 braintrust/context.py,sha256=ZXIOc3zXIXOzAopkuPIM9tq2prfsTjH0-e_FEEFTTJI,4235
 braintrust/db_fields.py,sha256=DBGFhfu9B3aLQI6cU6P2WGrdfCIs8AzDFRQEUBt9NCw,439
 braintrust/framework.py,sha256=Uf2DogzQG4suCcmABeQzc-5SWCO5tB2ic1OeQFZo_o4,57618
-braintrust/framework2.py,sha256=tIYwx7ufiUy0Nl9aoz4D0a7CE9k0ng5nZ72K1o--aGA,15886
-braintrust/generated_types.py,sha256=G5p5dXST8QeQzPKaGoSP2Gxrw_PT3dU_Trrk50QBS5Y,4351
+braintrust/framework2.py,sha256=ck1-ybuEHf_ExEfveMGmQ02FDiSrIRsxJxTd64qlotM,15885
+braintrust/generated_types.py,sha256=StMC58Mg_Imc4Z-xpLzqZql2E5K14b92FAnxj0aOrtw,4521
 braintrust/git_fields.py,sha256=oT1h1nVkidGrIIamtIQfOpbuEzd1n-nup9bx54J_u0A,1480
 braintrust/gitutil.py,sha256=bEk38AlNtT-umtdCJ9lnSXlbKXsvjBOyTTsmzUKiVtM,5586
 braintrust/graph_util.py,sha256=lABIOMzxHf6E5LfDYfqa4OUR4uaW7xgUYNq5WGewD4w,5594
 braintrust/http_headers.py,sha256=9ZsDcsAKG04SGowsgchZktD6rG_oSTKWa8QyGUPA4xE,154
 braintrust/id_gen.py,sha256=PVkz-pS-9AzgmnAgpV-jgOFFo4hfl6e3IP9dVt6FouQ,1595
-braintrust/logger.py,sha256=z4uovYtyD-ZIqbbJFseRQ8ZDNd2DLdI05HqTKyYv9OU,207448
+braintrust/logger.py,sha256=gODmFkQpS7wW3NCPlFvD7XHanW4ui2-5ld1n1MChrdc,209442
 braintrust/merge_row_batch.py,sha256=NX4jRE9uuFB3Z7btrarQp_di84_NGTjvzpJhksn82W8,9882
 braintrust/oai.py,sha256=8gUtISG8oIwgMRcFtlfDndzaF_md1Po_4_DFZcH_PkQ,33159
 braintrust/object.py,sha256=vYLyYWncsqLD00zffZUJwGTSkcJF9IIXmgIzrx3Np5c,632
@@ -33,7 +33,7 @@ braintrust/span_types.py,sha256=UvuyjfL_Delao14TJs9IjnpYLcgDSodKJfAYju01aXQ,292
 braintrust/test_framework.py,sha256=fALvUefSmNOdQcEVgKHvdCOnPlUreZjhF5AiqfNLBPg,14657
 braintrust/test_helpers.py,sha256=-RrxDtyCfOOukhdN6tFSwr-Nmq7DrNQ7KO45hySqNZ0,13549
 braintrust/test_id_gen.py,sha256=mgArTyEBV-Xv21ARHPSHEPBsJshZrvIiPjBLNOKsAko,2490
-braintrust/test_logger.py,sha256=ffVKQWrBcovc90-7ojro_aHca1M2DwRNSUbFsdbadqM,83627
+braintrust/test_logger.py,sha256=UGRwDtGnoni5HrwTSHUsJQjM0njH77H1cJTVKNb40dw,92756
 braintrust/test_otel.py,sha256=janmEtu6dyFQL8N68WjRTS-65Kr5vSNSSwIaBWqXlyw,27243
 braintrust/test_queue.py,sha256=MdH6R9uSk_4akY4Db514Cpukwiy2RJ76Lqts1nQwZJY,8432
 braintrust/test_serializable_data_class.py,sha256=b04Ym64YtC6GJRGbKIN4J20RG1QN1FlnODwtEQh4sv0,1897
@@ -41,7 +41,7 @@ braintrust/test_span_components.py,sha256=UnF6ZL4k41XZ-CnfbjuqLeK4MZLtHTMdID3CMh
 braintrust/test_util.py,sha256=gyqe2JspRP7oXlp6ENztZe2fdRTOEMZMKpQi00y1DSc,4538
 braintrust/test_version.py,sha256=hk5JKjEFbNJ_ONc1VEkqHquflzre34RpFhCEYLTK8iA,1051
 braintrust/util.py,sha256=Ec6sRkQw5BckGrFjdA4YTyu_2BaKmHh4tWDwAi_ysOw,7227
-braintrust/version.py,sha256=nF2uDtOugToR0b5XKMnral46yFA39LnqdbT1Wb241OI,117
+braintrust/version.py,sha256=3QoSvR9upAkmscSlqZqj5iUZV0cddFtBgRVYdbEJU_0,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
@@ -104,8 +104,8 @@ braintrust/wrappers/claude_agent_sdk/__init__.py,sha256=CSXJWy-z2fHF7h4VJjLSnXJv
 braintrust/wrappers/claude_agent_sdk/_wrapper.py,sha256=uzElIOwwPmF_Y5fbWcKWEPC8HnSzW7byzpiuVKK0TXE,15613
 braintrust/wrappers/claude_agent_sdk/test_wrapper.py,sha256=0NmohdECudFvWtc-5PbANtTXzexkkwIJhGbujydDrT8,6826
 braintrust/wrappers/google_genai/__init__.py,sha256=PGFMuR3c4Gc3SUt24eP7z5AzdS2Dc1uF1d3QPCnLnuo,16018
-braintrust-0.3.7.dist-info/METADATA,sha256=qUVhqTkwvsfCYY_cDnU64MRs6f9LWYzWpYC114F83A8,2942
-braintrust-0.3.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-braintrust-0.3.7.dist-info/entry_points.txt,sha256=Zpc0_09g5xm8as5jHqqFq7fhwO0xHSNct_TrEMONS7Q,60
-braintrust-0.3.7.dist-info/top_level.txt,sha256=hw1-y-UFMf60RzAr8x_eM7SThbIuWfQsQIbVvqSF83A,11
-braintrust-0.3.7.dist-info/RECORD,,
+braintrust-0.3.9.dist-info/METADATA,sha256=xEK83D4NuSxMV9ETcoBVzO0AqltIerG5NQP6z1galOk,2942
+braintrust-0.3.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+braintrust-0.3.9.dist-info/entry_points.txt,sha256=Zpc0_09g5xm8as5jHqqFq7fhwO0xHSNct_TrEMONS7Q,60
+braintrust-0.3.9.dist-info/top_level.txt,sha256=hw1-y-UFMf60RzAr8x_eM7SThbIuWfQsQIbVvqSF83A,11
+braintrust-0.3.9.dist-info/RECORD,,