dj-evals 0.2.0__tar.gz

dj_evals-0.2.0/PKG-INFO

@@ -0,0 +1,95 @@
+Metadata-Version: 2.4
+Name: dj-evals
+Version: 0.2.0
+Summary: Internal Django SSE eval runner
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: django>=5.0
+Provides-Extra: test
+Requires-Dist: pytest>=8.0; extra == "test"
+Requires-Dist: pytest-asyncio>=0.23; extra == "test"
+Provides-Extra: dev
+Requires-Dist: ruff>=0.8; extra == "dev"
+
+# dj-evals
+
+Internal Django helper for running one eval function with multiple argument sets in parallel, so you can visually compare output, tool calls, usage, cost, and completion behavior as the runs happen.
+
+## Django setup
+
+Add `dj_evals` to `INSTALLED_APPS` and mount your eval view:
+
+```python
+INSTALLED_APPS = [
+    "dj_evals",
+]
+```
+
+```python
+from django.urls import path
+
+urlpatterns = [
+    path("evals/run/", eval_run),
+]
+```
+
+Protect the eval view with your app's normal authorization checks before using it in production.
+
+## Usage
+
+```python
+from dj_evals import handle_eval_request
+
+async def eval_run(request):
+    return await handle_eval_request(
+        request,
+        allowed_paths={"myapp.evals.echo_eval"},
+    )
+```
+
+Generate a URL for the view with one or more eval argument dictionaries:
+
+```python
+from dj_evals import generate_eval_url
+
+url = "/evals/run/" + generate_eval_url(
+    "myapp.evals.echo_eval",
+    {"model": "gpt-4.1", "text": "hello"},
+    {"model": "gemini-3-flash-preview", "text": "hello"},
+)
+```
+
+The GET request renders the comparison page. The page starts one POST request per argument set. Each POST response is a direct SSE stream from the eval run, and the browser renders those events into the comparison panels.
+
+## Eval function contract
+
+The eval function must be importable by dotted path, whitelisted in `allowed_paths`, and must be an async generator.
+
+```python
+async def echo_eval(text="hello", model=""):
+    yield {"type": "response.output_text.delta", "delta": text}
+    yield {"type": "response.completed", "response": {"cost": 0}}
+```
+
+Eval argument dictionaries are passed to the eval function as keyword arguments.
+
+## Developers
+
+Run a local demo server to try the library in a browser:
+
+```bash
+uv run --with daphne daphne examples.local_server:application
+# or, if you have just installed:
+just run
+```
+
+Then open <http://127.0.0.1:8000/>. The demo redirects to an eval URL that starts three argument sets side by side and streams their events over SSE.
+
+Run checks from this repo:
+
+```bash
+uv run --with ruff ruff check .
+uv run --with pytest --with pytest-asyncio pytest -q
+# or, if you have just installed:
+just test
+```

dj_evals-0.2.0/README.md

@@ -0,0 +1,82 @@
+# dj-evals
+
+Internal Django helper for running one eval function with multiple argument sets in parallel, so you can visually compare output, tool calls, usage, cost, and completion behavior as the runs happen.
+
+## Django setup
+
+Add `dj_evals` to `INSTALLED_APPS` and mount your eval view:
+
+```python
+INSTALLED_APPS = [
+    "dj_evals",
+]
+```
+
+```python
+from django.urls import path
+
+urlpatterns = [
+    path("evals/run/", eval_run),
+]
+```
+
+Protect the eval view with your app's normal authorization checks before using it in production.
+
+## Usage
+
+```python
+from dj_evals import handle_eval_request
+
+async def eval_run(request):
+    return await handle_eval_request(
+        request,
+        allowed_paths={"myapp.evals.echo_eval"},
+    )
+```
+
+Generate a URL for the view with one or more eval argument dictionaries:
+
+```python
+from dj_evals import generate_eval_url
+
+url = "/evals/run/" + generate_eval_url(
+    "myapp.evals.echo_eval",
+    {"model": "gpt-4.1", "text": "hello"},
+    {"model": "gemini-3-flash-preview", "text": "hello"},
+)
+```
+
+The GET request renders the comparison page. The page starts one POST request per argument set. Each POST response is a direct SSE stream from the eval run, and the browser renders those events into the comparison panels.
+
+## Eval function contract
+
+The eval function must be importable by dotted path, whitelisted in `allowed_paths`, and must be an async generator.
+
+```python
+async def echo_eval(text="hello", model=""):
+    yield {"type": "response.output_text.delta", "delta": text}
+    yield {"type": "response.completed", "response": {"cost": 0}}
+```
+
+Eval argument dictionaries are passed to the eval function as keyword arguments.
+
+## Developers
+
+Run a local demo server to try the library in a browser:
+
+```bash
+uv run --with daphne daphne examples.local_server:application
+# or, if you have just installed:
+just run
+```
+
+Then open <http://127.0.0.1:8000/>. The demo redirects to an eval URL that starts three argument sets side by side and streams their events over SSE.
+
+Run checks from this repo:
+
+```bash
+uv run --with ruff ruff check .
+uv run --with pytest --with pytest-asyncio pytest -q
+# or, if you have just installed:
+just test
+```

dj_evals-0.2.0/dj_evals/__init__.py

@@ -0,0 +1,6 @@
+from .views import generate_eval_url, handle_eval_request
+
+__all__ = [
+    "generate_eval_url",
+    "handle_eval_request",
+]

dj_evals-0.2.0/dj_evals/events.py

@@ -0,0 +1,55 @@
+import importlib
+import inspect
+import json
+import traceback
+
+
+async def iter_eval_events(*, eval_path, kwargs):
+    """Yield eval events as JSON-safe values for SSE publishing.
+
+    The eval function is imported from ``eval_path``, called with ``kwargs``, and
+    consumed as an async iterator. Events are kept in their original shape when
+    possible so the browser can render them.
+    """
+    try:
+        eval_func = _import_from_dotted_path(eval_path)
+        async for event in eval_func(**kwargs):
+            yield _json_safe_event(event)
+    except Exception as exc:
+        yield {"type": "error", "message": f"{exc}\n{traceback.format_exc()}"}
+
+
+def _event_to_dict(event):
+    """Return SDK model events as plain dictionaries when possible."""
+    if isinstance(event, dict):
+        return event
+    if not hasattr(event, "to_dict"):
+        return event
+
+    try:
+        return event.to_dict(mode="json", warnings=False)
+    except TypeError:
+        return event.to_dict()
+
+
+def _json_safe_event(event):
+    event = _event_to_dict(event)
+    try:
+        json.dumps(event)
+    except TypeError:
+        return str(event)
+    return event
+
+
+def _import_from_dotted_path(eval_path):
+    """Import and validate an async-generator eval function by dotted path."""
+    module_path, _, function_name = eval_path.rpartition(".")
+    if not module_path or not function_name:
+        raise ImportError(f"Invalid eval_path: {eval_path}")
+    module = importlib.import_module(module_path)
+    eval_func = getattr(module, function_name)
+    if not callable(eval_func):
+        raise TypeError(f"{eval_path} is not callable")
+    if not inspect.isasyncgenfunction(eval_func):
+        raise TypeError(f"{eval_path} is not an async generator function")
+    return eval_func

dj_evals-0.2.0/dj_evals/static/dj_evals/run_page.js

@@ -0,0 +1,180 @@
+(function () {
+  function stringify(value) {
+    if (typeof value === "string") {
+      return value;
+    }
+    try {
+      return JSON.stringify(value, null, 2);
+    } catch (error) {
+      return String(value);
+    }
+  }
+
+  function append(outputEl, text) {
+    outputEl.append(document.createTextNode(String(text)));
+  }
+
+  function appendEvent(outputEl, event) {
+    append(outputEl, "\n" + stringify(event) + "\n");
+  }
+
+  function appendEmptyLine(outputEl) {
+    append(outputEl, "\n");
+  }
+
+  function appendEvalEvent(outputEl, event) {
+    if (typeof event === "string") {
+      append(outputEl, event);
+      return;
+    }
+
+    if (!event || typeof event !== "object") {
+      appendEvent(outputEl, event);
+      return;
+    }
+
+    if (event.type === "response.output_text.delta") {
+      append(outputEl, event.delta || event.text || "");
+      return;
+    }
+
+    if (["response.completed", "response.output_text.done"].includes(event.type)) {
+      appendEmptyLine(outputEl);
+      return;
+    }
+
+    if (event.type === "error") {
+      append(outputEl, "\n" + (event.message || "Unknown error") + "\n");
+      return;
+    }
+
+    if (event.choices) {
+      event.choices.forEach(function (choice) {
+        append(outputEl, (choice.delta || {}).content || "");
+      });
+      return;
+    }
+
+    if (event.content) {
+      append(outputEl, event.content);
+      return;
+    }
+
+    appendEvent(outputEl, event);
+  }
+
+  function readArguments(form) {
+    var kwargs = {};
+    new FormData(form).forEach(function (value, key) {
+      kwargs[key] = value;
+    });
+    return kwargs;
+  }
+
+  function getCsrfToken() {
+    return document.querySelector('meta[name="csrf-token"]').content;
+  }
+
+  function parseSseBlock(block) {
+    var eventType = "message";
+    var data = [];
+    block.replace(/\r/g, "").split("\n").forEach(function (line) {
+      if (line.indexOf("event:") === 0) {
+        eventType = line.slice(6).trim();
+      }
+      if (line.indexOf("data:") === 0) {
+        data.push(line.slice(5).trimStart());
+      }
+    });
+    return {type: eventType, data: data.join("\n")};
+  }
+
+  function readSse(text, outputEl, state) {
+    var blocks = (state.pendingSseText + text).split("\n\n");
+    state.pendingSseText = blocks.pop();
+
+    blocks.forEach(function (block) {
+      var message = parseSseBlock(block);
+      if (message.type === "done") {
+        appendEmptyLine(outputEl);
+        return;
+      }
+
+      // Keep-alive or malformed SSE blocks may have no data.
+      if (!message.data) {
+        return;
+      }
+
+      if (message.type === "eval-event") {
+        appendEvalEvent(outputEl, JSON.parse(message.data).event);
+        return;
+      }
+
+      appendEvent(outputEl, message);
+    });
+  }
+
+  async function startRun(section) {
+    // The user can re-run a panel while the previous stream is active.
+    if (section.djEvalsAbortController) {
+      section.djEvalsAbortController.abort();
+    }
+
+    var outputEl = section.querySelector(".events");
+    var form = section.querySelector(".eval-args");
+    var startUrl = new URL(section.dataset.startUrl, window.location.href);
+    var state = {
+      // Stream chunks can split one SSE message, so keep the unfinished tail.
+      pendingSseText: ""
+    };
+    var abortController = new AbortController();
+    section.djEvalsAbortController = abortController;
+    startUrl.searchParams.set("eval_args", JSON.stringify(readArguments(form)));
+    outputEl.textContent = "";
+
+    try {
+      var response = await fetch(startUrl.toString(), {
+        method: "POST",
+        credentials: "same-origin",
+        headers: {"X-CSRFToken": getCsrfToken()},
+        signal: abortController.signal
+      });
+
+      // Validation and permission errors return normal HTTP failures.
+      if (!response.ok) {
+        append(outputEl, "Eval request failed: " + response.status + "\n");
+        return;
+      }
+
+      var reader = response.body.getReader();
+      var decoder = new TextDecoder();
+      while (true) {
+        var result = await reader.read();
+        if (result.done) {
+          readSse(decoder.decode(), outputEl, state);
+          return;
+        }
+        readSse(decoder.decode(result.value, {stream: true}), outputEl, state);
+      }
+    } catch (error) {
+      // Re-running a panel aborts the previous request intentionally.
+      if (error.name === "AbortError") {
+        return;
+      }
+      append(outputEl, String(error) + "\n");
+    }
+  }
+
+  function main() {
+    document.querySelectorAll("[data-eval-run]").forEach(function (section) {
+      var form = section.querySelector(".eval-args");
+      form.addEventListener("submit", function (event) {
+        event.preventDefault();
+        startRun(section);
+      });
+      startRun(section);
+    });
+  }
+
+  main();
+}());

dj_evals-0.2.0/dj_evals/templates/dj_evals/run_page.html

@@ -0,0 +1,53 @@
+{% load static %}
+<!doctype html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <meta name="csrf-token" content="{{ csrf_token }}">
+  <title>Eval run</title>
+  <style>
+    html, body { max-width: 100%; overflow-x: hidden; }
+    body { font-family: system-ui, sans-serif; margin: 24px; }
+    .runs {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 16px;
+    }
+    section {
+      flex: 1 1 calc((100% - 32px) / 3);
+      min-width: 0;
+      border: 1px solid #ddd;
+      box-sizing: border-box;
+      padding: 8px;
+    }
+    pre { white-space: pre-wrap; overflow-wrap: anywhere; max-width: 100%; }
+    h1 { overflow-wrap: anywhere; }
+    label { display: block; margin: 8px 0; }
+    label span { display: block; font-weight: 600; margin-bottom: 4px; }
+    input { box-sizing: border-box; width: 100%; }
+    button { margin: 8px 0 16px; }
+  </style>
+</head>
+<body>
+  <main>
+    <h1>{{ eval_path }}</h1>
+    <div class="runs">
+      {% for run in runs %}
+        <section data-eval-run data-start-url="{{ run.start_url }}">
+          <form class="eval-args">
+            {% for key, value in run.arguments %}
+              <label>
+                <span>{{ key }}</span>
+                <input name="{{ key }}" value="{{ value }}">
+              </label>
+            {% endfor %}
+            <button type="submit">Run eval</button>
+          </form>
+          <pre class="events"></pre>
+        </section>
+      {% endfor %}
+    </div>
+  </main>
+  <script src="{% static 'dj_evals/run_page.js' %}"></script>
+</body>
+</html>

dj_evals-0.2.0/dj_evals/views.py

@@ -0,0 +1,142 @@
+import json
+from collections.abc import Collection
+from urllib.parse import urlencode
+
+from django.http import (
+    HttpResponseBadRequest,
+    HttpResponseForbidden,
+    HttpResponseNotAllowed,
+    StreamingHttpResponse,
+)
+from django.middleware.csrf import get_token
+from django.shortcuts import render
+
+from .events import iter_eval_events
+
+EVAL_PARAM = "eval_path"
+ARGS_PARAM = "eval_args"
+
+
+def generate_eval_url(eval_path: str, *args: dict) -> str:
+    """Generate a query-string URL for one eval path and argument sets."""
+    pairs = [(EVAL_PARAM, eval_path)]
+    for kwargs in args:
+        # Callers may pass malformed arguments; only dict kwargs can be encoded.
+        if not isinstance(kwargs, dict):
+            raise TypeError("eval arguments must be a dictionary")
+        pairs.append((
+            ARGS_PARAM,
+            json.dumps(kwargs, sort_keys=True, separators=(",", ":")),
+        ))
+    return "?" + urlencode(pairs)
+
+
+async def handle_eval_request(request, *, allowed_paths: Collection[str]):
+    """Render the eval runner page on GET or publish one eval run on POST.
+
+    Use this from a host Django view::
+
+        return await handle_eval_request(
+            request,
+            allowed_paths={"myapp.evals.some_eval"},
+        )
+
+    The request should include an ``eval_path`` query parameter. It must match
+    one of the dotted paths in ``allowed_paths``. Use ``generate_eval_url`` to
+    create URLs.
+
+    All eval arguments are passed to the eval function as keyword arguments.
+    Multiple argument sets create separate SSE-backed panels.
+
+    GET renders an HTML page. Browser JavaScript starts each eval run with a
+    POST request, and that POST response streams SSE events directly.
+
+    Args:
+        request: Django request with the eval query params.
+        allowed_paths: Whitelist of eval dotted paths that can be run.
+
+    Returns:
+        ``HttpResponse`` for the outer page or run trigger.
+    """
+    if request.method == "GET":
+        return _render_eval_page(request, allowed_paths)
+    if request.method == "POST":
+        return await _run_eval(request, allowed_paths)
+    return HttpResponseNotAllowed(["GET", "POST"])
+
+
+def _render_eval_page(request, allowed_paths: Collection[str]):
+    try:
+        eval_path, eval_arguments = _parse_eval_request(request, allowed_paths)
+    except PermissionError as exc:
+        return HttpResponseForbidden(str(exc))
+    except (TypeError, ValueError) as exc:
+        return HttpResponseBadRequest(str(exc))
+
+    runs = []
+    for kwargs in eval_arguments:
+        query = generate_eval_url(eval_path, kwargs)
+        runs.append({
+            "arguments": kwargs.items(),
+            "start_url": request.path + query,
+        })
+
+    return render(request, "dj_evals/run_page.html", {
+        "csrf_token": get_token(request),
+        "eval_path": eval_path,
+        "runs": runs,
+    })
+
+
+async def _run_eval(request, allowed_paths: Collection[str]):
+    try:
+        eval_path, eval_arguments = _parse_eval_request(request, allowed_paths)
+    except PermissionError as exc:
+        return HttpResponseForbidden(str(exc))
+    except (TypeError, ValueError) as exc:
+        return HttpResponseBadRequest(str(exc))
+
+    async def stream_events():
+        async for event in iter_eval_events(
+            eval_path=eval_path,
+            kwargs=eval_arguments[0],
+        ):
+            payload = json.dumps({"event": event}, separators=(",", ":"))
+            yield f"event: eval-event\ndata: {payload}\n\n"
+
+        yield "event: done\ndata: {}\n\n"
+
+    response = StreamingHttpResponse(
+        stream_events(),
+        content_type="text/event-stream",
+    )
+    response["Cache-Control"] = "no-cache"
+    response["X-Accel-Buffering"] = "no"
+    return response
+
+
+def _parse_eval_request(
+    request,
+    allowed_paths: Collection[str],
+) -> tuple[str, list[dict]]:
+    eval_path = request.GET.get(EVAL_PARAM, "")
+    # Reject missing or unapproved eval paths before importing host code.
+    if eval_path not in allowed_paths:
+        raise PermissionError("eval_path is not allowed")
+
+    eval_arguments = []
+    for value in request.GET.getlist(ARGS_PARAM):
+        try:
+            kwargs = json.loads(value)
+        except json.JSONDecodeError as exc:
+            raise ValueError("eval_args must be valid JSON") from exc
+
+        # Users can edit eval_args by hand, so validate before use.
+        if not isinstance(kwargs, dict):
+            raise TypeError("eval arguments must be a dictionary")
+        eval_arguments.append(kwargs)
+
+    # No eval_args means run the eval once with no kwargs.
+    if not eval_arguments:
+        eval_arguments.append({})
+    return eval_path, eval_arguments

dj_evals-0.2.0/dj_evals.egg-info/PKG-INFO

@@ -0,0 +1,95 @@
+Metadata-Version: 2.4
+Name: dj-evals
+Version: 0.2.0
+Summary: Internal Django SSE eval runner
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: django>=5.0
+Provides-Extra: test
+Requires-Dist: pytest>=8.0; extra == "test"
+Requires-Dist: pytest-asyncio>=0.23; extra == "test"
+Provides-Extra: dev
+Requires-Dist: ruff>=0.8; extra == "dev"
+
+# dj-evals
+
+Internal Django helper for running one eval function with multiple argument sets in parallel, so you can visually compare output, tool calls, usage, cost, and completion behavior as the runs happen.
+
+## Django setup
+
+Add `dj_evals` to `INSTALLED_APPS` and mount your eval view:
+
+```python
+INSTALLED_APPS = [
+    "dj_evals",
+]
+```
+
+```python
+from django.urls import path
+
+urlpatterns = [
+    path("evals/run/", eval_run),
+]
+```
+
+Protect the eval view with your app's normal authorization checks before using it in production.
+
+## Usage
+
+```python
+from dj_evals import handle_eval_request
+
+async def eval_run(request):
+    return await handle_eval_request(
+        request,
+        allowed_paths={"myapp.evals.echo_eval"},
+    )
+```
+
+Generate a URL for the view with one or more eval argument dictionaries:
+
+```python
+from dj_evals import generate_eval_url
+
+url = "/evals/run/" + generate_eval_url(
+    "myapp.evals.echo_eval",
+    {"model": "gpt-4.1", "text": "hello"},
+    {"model": "gemini-3-flash-preview", "text": "hello"},
+)
+```
+
+The GET request renders the comparison page. The page starts one POST request per argument set. Each POST response is a direct SSE stream from the eval run, and the browser renders those events into the comparison panels.
+
+## Eval function contract
+
+The eval function must be importable by dotted path, whitelisted in `allowed_paths`, and must be an async generator.
+
+```python
+async def echo_eval(text="hello", model=""):
+    yield {"type": "response.output_text.delta", "delta": text}
+    yield {"type": "response.completed", "response": {"cost": 0}}
+```
+
+Eval argument dictionaries are passed to the eval function as keyword arguments.
+
+## Developers
+
+Run a local demo server to try the library in a browser:
+
+```bash
+uv run --with daphne daphne examples.local_server:application
+# or, if you have just installed:
+just run
+```
+
+Then open <http://127.0.0.1:8000/>. The demo redirects to an eval URL that starts three argument sets side by side and streams their events over SSE.
+
+Run checks from this repo:
+
+```bash
+uv run --with ruff ruff check .
+uv run --with pytest --with pytest-asyncio pytest -q
+# or, if you have just installed:
+just test
+```

dj_evals-0.2.0/dj_evals.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+dj_evals/__init__.py
+dj_evals/events.py
+dj_evals/views.py
+dj_evals.egg-info/PKG-INFO
+dj_evals.egg-info/SOURCES.txt
+dj_evals.egg-info/dependency_links.txt
+dj_evals.egg-info/requires.txt
+dj_evals.egg-info/top_level.txt
+dj_evals/static/dj_evals/run_page.js
+dj_evals/templates/dj_evals/run_page.html
+tests/test_events.py
+tests/test_views.py

dj_evals-0.2.0/dj_evals.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

dj_evals-0.2.0/dj_evals.egg-info/requires.txt

@@ -0,0 +1,8 @@
+django>=5.0
+
+[dev]
+ruff>=0.8
+
+[test]
+pytest>=8.0
+pytest-asyncio>=0.23

dj_evals-0.2.0/dj_evals.egg-info/top_level.txt

@@ -0,0 +1 @@
+dj_evals

dj_evals-0.2.0/pyproject.toml

@@ -0,0 +1,29 @@
+[project]
+name = "dj-evals"
+version = "0.2.0"
+description = "Internal Django SSE eval runner"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "django>=5.0",
+]
+
+[project.optional-dependencies]
+test = [
+    "pytest>=8.0",
+    "pytest-asyncio>=0.23",
+]
+dev = [
+    "ruff>=0.8",
+]
+
+[tool.setuptools.packages.find]
+include = ["dj_evals*"]
+
+
+[tool.setuptools.package-data]
+dj_evals = ["templates/dj_evals/*.html", "static/dj_evals/*.js"]
+
+[build-system]
+requires = ["setuptools>=69", "wheel"]
+build-backend = "setuptools.build_meta"

dj_evals-0.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

dj_evals-0.2.0/tests/test_events.py

@@ -0,0 +1,67 @@
+import pytest
+
+from dj_evals.events import iter_eval_events
+
+
+@pytest.mark.asyncio
+async def test_iter_eval_events_yields_raw_eval_events():
+    events = [
+        event
+        async for event in iter_eval_events(
+            eval_path="tests.fake_evals.echo_eval",
+            kwargs={"text": "from url", "model": "model-a"},
+        )
+    ]
+
+    assert events == [
+        {"type": "response.output_text.delta", "delta": "model-a:from url"},
+        {
+            "type": "response.completed",
+            "response": {
+                "usage": {"input_tokens": 3, "output_tokens": 4},
+                "cost": 0.01,
+            },
+        },
+    ]
+
+
+@pytest.mark.asyncio
+async def test_iter_eval_events_yields_failures_as_error_events():
+    events = [
+        event
+        async for event in iter_eval_events(
+            eval_path="tests.fake_evals.missing_eval",
+            kwargs={},
+        )
+    ]
+
+    assert events[0]["type"] == "error"
+    assert "missing_eval" in events[0]["message"]
+
+
+@pytest.mark.asyncio
+async def test_iter_eval_events_serializes_sdk_events_without_pydantic_warnings():
+    events = [
+        event
+        async for event in iter_eval_events(
+            eval_path="tests.fake_evals.sdk_eval",
+            kwargs={},
+        )
+    ]
+
+    assert events == [
+        {"type": "response.output_text.delta", "delta": "quiet sdk event"}
+    ]
+
+
+@pytest.mark.asyncio
+async def test_iter_eval_events_stringifies_non_json_events():
+    events = [
+        event
+        async for event in iter_eval_events(
+            eval_path="tests.fake_evals.object_eval",
+            kwargs={},
+        )
+    ]
+
+    assert events[0].startswith("<object object at")

dj_evals-0.2.0/tests/test_views.py

@@ -0,0 +1,160 @@
+import pytest
+from django.test import RequestFactory
+
+from dj_evals import generate_eval_url, handle_eval_request
+
+
+def test_handle_eval_request_is_importable():
+    assert callable(handle_eval_request)
+
+
+def test_handle_eval_request_requires_named_allowed_paths():
+    request = RequestFactory().get(
+        "/evals/run/",
+        {"eval_path": "tests.fake_evals.echo_eval"},
+    )
+
+    with pytest.raises(TypeError):
+        handle_eval_request(request, {"tests.fake_evals.echo_eval"})
+
+
+def test_generate_eval_url_encodes_eval_arguments():
+    url = generate_eval_url(
+        "tests.fake_evals.echo_eval",
+        {"model": "gpt-4.1", "temperature": 0.2},
+    )
+
+    assert "eval_path=tests.fake_evals.echo_eval" in url
+    assert "eval_args=" in url
+    assert "temperature" in url
+
+
+def test_generate_eval_url_rejects_non_dict_arguments():
+    with pytest.raises(TypeError, match="dictionary"):
+        generate_eval_url("tests.fake_evals.echo_eval", ["not", "a", "dict"])
+
+
+@pytest.mark.asyncio
+async def test_handle_eval_request_renders_sse_panels_for_each_argument_set():
+    request = RequestFactory().get(
+        "/evals/run/"
+        + generate_eval_url(
+            "tests.fake_evals.echo_eval",
+            {"model": "gpt-4.1", "text": "hello"},
+            {"model": "openrouter/openai/gpt-4.1", "text": "hello"},
+        ),
+    )
+
+    response = await handle_eval_request(
+        request,
+        allowed_paths={"tests.fake_evals.echo_eval"},
+    )
+    html = response.content.decode()
+
+    assert response.status_code == 200
+    assert html.count("<section data-eval-run") == 2
+    assert '<script src="/static/dj_evals/run_page.js"></script>' in html
+    assert '<meta name="csrf-token"' in html
+    assert "/events/" not in html
+    assert "data-channel" not in html
+    assert "<h1>tests.fake_evals.echo_eval</h1>" in html
+    assert 'input name="model" value="gpt-4.1"' in html
+    assert 'input name="text" value="hello"' in html
+    assert 'input name="model" value="openrouter/openai/gpt-4.1"' in html
+    assert '<button type="submit">Run eval</button>' in html
+    assert "overflow-x: hidden" in html
+    assert "flex-wrap: wrap" in html
+    assert "calc((100% - 32px) / 3)" in html
+    assert "<iframe" not in html
+
+
+@pytest.mark.asyncio
+async def test_handle_eval_request_defaults_to_one_empty_argument_set():
+    request = RequestFactory().get(
+        "/evals/run/" + generate_eval_url("tests.fake_evals.echo_eval"),
+    )
+
+    response = await handle_eval_request(
+        request,
+        allowed_paths={"tests.fake_evals.echo_eval"},
+    )
+    html = response.content.decode()
+
+    assert response.status_code == 200
+    assert html.count("<section data-eval-run") == 1
+
+
+@pytest.mark.asyncio
+async def test_handle_eval_request_post_streams_eval_events_as_sse():
+    request = RequestFactory().post(
+        "/evals/run/"
+        + generate_eval_url(
+            "tests.fake_evals.echo_eval",
+            {"model": "gpt-4.1", "text": "hello"},
+        ),
+    )
+
+    response = await handle_eval_request(
+        request,
+        allowed_paths={"tests.fake_evals.echo_eval"},
+    )
+
+    chunks = []
+    async for chunk in response.streaming_content:
+        chunks.append(chunk.decode() if isinstance(chunk, bytes) else chunk)
+    body = "".join(chunks)
+
+    assert response.status_code == 200
+    assert response["Content-Type"] == "text/event-stream"
+    assert "event: eval-event" in body
+    assert "gpt-4.1:hello" in body
+    assert "event: done" in body
+
+
+@pytest.mark.asyncio
+async def test_handle_eval_request_rejects_disallowed_eval_path():
+    request = RequestFactory().get(
+        "/evals/run/",
+        {"eval_path": "tests.fake_evals.echo_eval"},
+    )
+
+    response = await handle_eval_request(
+        request,
+        allowed_paths={"tests.fake_evals.other_eval"},
+    )
+
+    assert response.status_code == 403
+    assert b"eval_path is not allowed" in response.content
+
+
+@pytest.mark.asyncio
+async def test_handle_eval_request_rejects_disallowed_post_eval_path():
+    request = RequestFactory().post(
+        "/evals/run/"
+        + generate_eval_url(
+            "tests.fake_evals.echo_eval",
+            {},
+        ),
+    )
+
+    response = await handle_eval_request(
+        request,
+        allowed_paths={"tests.fake_evals.other_eval"},
+    )
+
+    assert response.status_code == 403
+
+
+@pytest.mark.asyncio
+async def test_handle_eval_request_rejects_unsupported_methods():
+    request = RequestFactory().put(
+        "/evals/run/",
+        QUERY_STRING="eval_path=tests.fake_evals.echo_eval",
+    )
+
+    response = await handle_eval_request(
+        request,
+        allowed_paths={"tests.fake_evals.echo_eval"},
+    )
+
+    assert response.status_code == 405