fix(eval): await asynchronous data sources (#1076)

`EvalData` accepts awaitable iterators and async data factories, but
both `Eval` and `EvalAsync` currently pass the resulting coroutine into
a synchronous `for` loop. Evaluation fails with `TypeError: 'coroutine'
object is not iterable` before processing a sample.

Await the data after resolving its factory and before adapting the
iterator. This matches the existing `workflow_eval.py` handling and
preserves synchronous iterators and async generators.

Validation on Python 3.13.18 with locked dependencies:
- The new public-API regression has 4 failures and 4 passing synchronous
controls on base `e26deb0`; all 8 cases pass with the fix.
- `pytest src/braintrust/test_framework.py
src/braintrust/test_framework2.py --vcr-record=none -q`: 180 passed, 5
skipped.
- Ruff 0.15.21 lint and format checks pass for both changed files.
- Full `pre-commit run --all-files` passes (pre-commit 4.6.2, including
Ruff and Codespell).
- Targeted Pylint (`--errors-only`) passes for both changed files.
- Full `nox -R -s test_core -- --vcr-record=none -q`: 1,127 passed, 114
skipped, 12 xfailed, 23 subtests passed. Git signing was disabled only
in this test process for deterministic generated Git fixtures.

Author: feiiiiii5

py/src/braintrust/framework.py

@@ -2014,6 +2014,9 @@ async def ensure_spans_flushed():
     if inspect.isfunction(data_iterator) or inspect.isroutine(data_iterator):
         data_iterator = data_iterator()
 
+    if inspect.isawaitable(data_iterator):
+        data_iterator = await data_iterator
+
     if not inspect.isasyncgen(data_iterator):
 
         async def to_async(it):

py/src/braintrust/test_framework.py

@@ -287,6 +287,46 @@ def exact_match(input_value, output, expected):
     assert result.summary.scores["exact_match"].score == 1.0
 
 
+@pytest.mark.parametrize("is_async", [False, True], ids=["Eval", "EvalAsync"])
+@pytest.mark.parametrize("data_kind", ["iterator", "factory", "awaitable", "async-factory"])
+def test_eval_resolves_awaitable_data(is_async, data_kind):
+    cases = [EvalCase(input=1, expected=2), EvalCase(input=2, expected=4)]
+
+    async def load_data():
+        await asyncio.sleep(0)
+        return iter(cases)
+
+    if data_kind == "iterator":
+        data = iter(cases)
+    elif data_kind == "factory":
+        data = lambda: iter(cases)
+    elif data_kind == "awaitable":
+        data = load_data()
+    else:
+        data = load_data
+
+    def exact_match(output, expected):
+        return float(output == expected)
+
+    evaluate = EvalAsync if is_async else Eval
+    result = evaluate(
+        "test-awaitable-data",
+        data=data,
+        task=lambda input_value: input_value * 2,
+        scores=[exact_match],
+        no_send_logs=True,
+        enable_cache=False,
+    )
+    if is_async:
+        result = asyncio.run(result)
+
+    assert [(row.input, row.output, row.scores, row.error) for row in result.results] == [
+        (1, 2, {"exact_match": 1.0}, None),
+        (2, 4, {"exact_match": 1.0}, None),
+    ]
+    assert result.summary.scores["exact_match"].score == 1.0
+
+
 @pytest.mark.parametrize("is_async", [False, True], ids=["Eval", "EvalAsync"])
 @pytest.mark.parametrize("outcome", ["task_error", "scorer_error", "success"])
 @pytest.mark.parametrize("handler_result", ["score", "none", "default"])