feat: add Excel exports for history details

arena/application/services/history_export_service.py

@@ -0,0 +1,187 @@
+from io import BytesIO
+from typing import Callable, Iterable
+
+from django.utils import timezone
+from openpyxl import Workbook
+from openpyxl.styles import Alignment, Font
+from openpyxl.utils import get_column_letter
+
+from arena.models import PromptRun
+
+
+class HistoryExportService:
+    def build_run_workbook(
+        self,
+        run: PromptRun,
+        provider_labeler: Callable[[str], str] | None = None,
+    ) -> bytes:
+        workbook = Workbook()
+        summary_sheet = workbook.active
+        summary_sheet.title = "Kayit Ozeti"
+
+        summary_rows = [
+            ("Kayit ID", run.id),
+            ("Olusturma Tarihi", self._format_datetime(run.created_at)),
+            ("Temperature", run.temperature),
+            ("Max Tokens", "limitsiz" if run.max_tokens == 0 else run.max_tokens),
+            ("Prompt", run.prompt),
+            ("System Prompt", run.system_prompt),
+        ]
+        self._write_key_value_rows(summary_sheet, summary_rows)
+
+        responses_sheet = workbook.create_sheet("Model Cevaplari")
+        response_headers = [
+            "Provider",
+            "Provider Etiketi",
+            "Model",
+            "Durum",
+            "Gecikme (ms)",
+            "Cevap",
+            "Hata Mesaji",
+            "Olusturma Tarihi",
+        ]
+        responses_sheet.append(response_headers)
+        self._style_header_row(responses_sheet)
+
+        for response in run.responses.all():
+            responses_sheet.append(
+                [
+                    response.provider,
+                    self._provider_label(provider_labeler, response.provider),
+                    response.model_id,
+                    response.status,
+                    response.latency_ms,
+                    response.content,
+                    response.error_message,
+                    self._format_datetime(response.created_at),
+                ]
+            )
+
+        self._wrap_text_columns(responses_sheet, ["F", "G"])
+        self._auto_size_columns(summary_sheet)
+        self._auto_size_columns(responses_sheet)
+        responses_sheet.freeze_panes = "A2"
+        return self._to_bytes(workbook)
+
+    def build_all_runs_workbook(
+        self,
+        runs: Iterable[PromptRun],
+        provider_labeler: Callable[[str], str] | None = None,
+    ) -> bytes:
+        workbook = Workbook()
+        sheet = workbook.active
+        sheet.title = "Tum Gecmis Detay"
+
+        headers = [
+            "Kayit ID",
+            "Kayit Tarihi",
+            "Prompt",
+            "System Prompt",
+            "Temperature",
+            "Max Tokens",
+            "Response ID",
+            "Provider",
+            "Provider Etiketi",
+            "Model",
+            "Durum",
+            "Gecikme (ms)",
+            "Cevap",
+            "Hata Mesaji",
+            "Response Tarihi",
+        ]
+        sheet.append(headers)
+        self._style_header_row(sheet)
+
+        for run in runs:
+            responses = list(run.responses.all())
+            if not responses:
+                sheet.append(
+                    [
+                        run.id,
+                        self._format_datetime(run.created_at),
+                        run.prompt,
+                        run.system_prompt,
+                        run.temperature,
+                        "limitsiz" if run.max_tokens == 0 else run.max_tokens,
+                        "",
+                        "",
+                        "",
+                        "",
+                        "",
+                        "",
+                        "",
+                        "",
+                        "",
+                    ]
+                )
+                continue
+
+            for response in responses:
+                sheet.append(
+                    [
+                        run.id,
+                        self._format_datetime(run.created_at),
+                        run.prompt,
+                        run.system_prompt,
+                        run.temperature,
+                        "limitsiz" if run.max_tokens == 0 else run.max_tokens,
+                        response.id,
+                        response.provider,
+                        self._provider_label(provider_labeler, response.provider),
+                        response.model_id,
+                        response.status,
+                        response.latency_ms,
+                        response.content,
+                        response.error_message,
+                        self._format_datetime(response.created_at),
+                    ]
+                )
+
+        self._wrap_text_columns(sheet, ["C", "D", "M", "N"])
+        self._auto_size_columns(sheet)
+        sheet.freeze_panes = "A2"
+        return self._to_bytes(workbook)
+
+    def _to_bytes(self, workbook: Workbook) -> bytes:
+        stream = BytesIO()
+        workbook.save(stream)
+        stream.seek(0)
+        return stream.getvalue()
+
+    def _style_header_row(self, sheet) -> None:
+        for cell in sheet[1]:
+            cell.font = Font(bold=True)
+            cell.alignment = Alignment(vertical="top")
+
+    def _write_key_value_rows(self, sheet, rows: list[tuple[str, object]]) -> None:
+        for index, (key, value) in enumerate(rows, start=1):
+            key_cell = sheet.cell(row=index, column=1, value=key)
+            value_cell = sheet.cell(row=index, column=2, value=value)
+            key_cell.font = Font(bold=True)
+            key_cell.alignment = Alignment(vertical="top")
+            value_cell.alignment = Alignment(vertical="top", wrap_text=True)
+
+    def _auto_size_columns(self, sheet) -> None:
+        for column_cells in sheet.columns:
+            column_letter = get_column_letter(column_cells[0].column)
+            width = max((len(str(cell.value or "")) for cell in column_cells), default=0)
+            sheet.column_dimensions[column_letter].width = min(max(width + 2, 12), 80)
+
+    def _wrap_text_columns(self, sheet, columns: list[str]) -> None:
+        for column in columns:
+            for cell in sheet[column]:
+                cell.alignment = Alignment(vertical="top", wrap_text=True)
+
+    def _provider_label(
+        self,
+        provider_labeler: Callable[[str], str] | None,
+        provider_id: str,
+    ) -> str:
+        if provider_labeler:
+            return provider_labeler(provider_id)
+        return provider_id
+
+    def _format_datetime(self, value) -> str:
+        if not value:
+            return ""
+        return timezone.localtime(value).strftime("%Y-%m-%d %H:%M:%S")

arena/static/arena/styles.css

@@ -361,6 +361,15 @@ code,
     align-items: center;
 }
 
+.history-actions {
+    display: flex;
+    gap: 0.5rem;
+}
+
+.actions-row {
+    margin-bottom: 0.8rem;
+}
+
 .history-main p {
     margin: 0.35rem 0;
 }

arena/templates/arena/history_detail.html

@@ -6,6 +6,9 @@
 <section class="card">
     <h1>Kayit #{{ run.id }}</h1>
     <p class="muted">{{ run.created_at|date:"Y-m-d H:i:s" }}</p>
+    <div class="actions-row">
+        <a class="btn btn-primary" href="{% url 'arena:history_export_run_excel' run.id %}">Bu Kaydi Excel Olarak Indir</a>
+    </div>
 
     <h3>Prompt</h3>
     <pre class="response-box">{{ run.prompt }}</pre>

arena/templates/arena/history_list.html

@@ -6,6 +6,9 @@
 <section class="card">
     <h1>Gecmis Karsilastirmalar</h1>
     <p class="muted">Tum prompt/coklu model sonuc kayitlari.</p>
+    <div class="actions-row">
+        <a class="btn btn-primary" href="{% url 'arena:history_export_all_excel' %}">Tum Gecmisi Excel Olarak Indir</a>
+    </div>
 
     <div class="stack-sm">
         {% for run in page_obj %}
@@ -15,7 +18,10 @@
                     <p>{{ run.prompt|truncatechars:180 }}</p>
                     <small class="muted">{{ run.responses.count }} model sonucu</small>
                 </div>
-                <a class="btn btn-secondary" href="{% url 'arena:history_detail' run.id %}">Detay</a>
+                <div class="history-actions">
+                    <a class="btn btn-secondary" href="{% url 'arena:history_detail' run.id %}">Detay</a>
+                    <a class="btn btn-secondary" href="{% url 'arena:history_export_run_excel' run.id %}">Excel</a>
+                </div>
             </article>
         {% empty %}
             <p>Henuz kayit yok.</p>

arena/tests.py

@@ -1,3 +1,77 @@
-from django.test import TestCase
-
-# Create your tests here.
+from io import BytesIO
+
+from django.contrib.auth import get_user_model
+from django.test import TestCase
+from django.urls import reverse
+from openpyxl import load_workbook
+
+from arena.models import ModelResponse, PromptRun
+
+
+class HistoryExcelExportTests(TestCase):
+    def setUp(self):
+        user_model = get_user_model()
+        self.user = user_model.objects.create_user(username="tester", password="secret123")
+        self.client.force_login(self.user)
+
+        self.run = PromptRun.objects.create(
+            prompt="Ana prompt metni",
+            system_prompt="Sistem prompt metni",
+            temperature=0.55,
+            max_tokens=2048,
+        )
+        ModelResponse.objects.create(
+            run=self.run,
+            provider="openai",
+            model_id="gpt-4o-mini",
+            content="Model cevabi",
+            status=ModelResponse.STATUS_SUCCESS,
+            latency_ms=321,
+        )
+
+    def test_single_history_excel_export(self):
+        response = self.client.get(reverse("arena:history_export_run_excel", args=[self.run.id]))
+
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(
+            response["Content-Type"],
+            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        )
+        self.assertIn(".xlsx", response["Content-Disposition"])
+
+        workbook = load_workbook(filename=BytesIO(response.content))
+        self.assertIn("Kayit Ozeti", workbook.sheetnames)
+        self.assertIn("Model Cevaplari", workbook.sheetnames)
+
+        summary_sheet = workbook["Kayit Ozeti"]
+        response_sheet = workbook["Model Cevaplari"]
+
+        self.assertEqual(summary_sheet["B5"].value, "Ana prompt metni")
+        self.assertEqual(summary_sheet["B6"].value, "Sistem prompt metni")
+        self.assertEqual(response_sheet["A2"].value, "openai")
+        self.assertEqual(response_sheet["C2"].value, "gpt-4o-mini")
+
+    def test_all_history_excel_export(self):
+        empty_run = PromptRun.objects.create(
+            prompt="Ikinci prompt",
+            system_prompt="",
+            temperature=0.2,
+            max_tokens=0,
+        )
+
+        response = self.client.get(reverse("arena:history_export_all_excel"))
+
+        self.assertEqual(response.status_code, 200)
+        workbook = load_workbook(filename=BytesIO(response.content))
+        self.assertIn("Tum Gecmis Detay", workbook.sheetnames)
+
+        detail_sheet = workbook["Tum Gecmis Detay"]
+        data_rows = list(detail_sheet.iter_rows(min_row=2, values_only=True))
+
+        run_ids = {row[0] for row in data_rows}
+        self.assertIn(self.run.id, run_ids)
+        self.assertIn(empty_run.id, run_ids)
+
+        empty_run_rows = [row for row in data_rows if row[0] == empty_run.id]
+        self.assertTrue(empty_run_rows)
+        self.assertEqual(empty_run_rows[0][5], "limitsiz")

arena/urls.py

@@ -7,7 +7,13 @@ app_name = "arena"
 urlpatterns = [
     path("", views.index_view, name="index"),
     path("history/", views.history_list_view, name="history_list"),
+    path("history/export/excel/", views.history_export_all_excel_view, name="history_export_all_excel"),
     path("history/<int:run_id>/", views.history_detail_view, name="history_detail"),
+    path(
+        "history/<int:run_id>/export/excel/",
+        views.history_export_run_excel_view,
+        name="history_export_run_excel",
+    ),
     path("catalog/", views.catalog_view, name="catalog"),
     path("settings/credentials/", views.provider_credentials_view, name="provider_credentials"),
     path("api/models/<str:provider_id>/", views.provider_models_api, name="provider_models_api"),

arena/views.py

@@ -8,14 +8,16 @@ from django.conf import settings
 from django.contrib.auth.decorators import login_required
 from django.contrib import messages
 from django.core.paginator import Paginator
-from django.http import Http404, JsonResponse, StreamingHttpResponse
+from django.http import Http404, HttpResponse, JsonResponse, StreamingHttpResponse
 from django.shortcuts import redirect, render
 from django.urls import reverse
+from django.utils import timezone
 from django.views.decorators.http import require_http_methods
 
 from arena.application.dto import ModelTarget
 from arena.application.services.catalog_service import CatalogService
 from arena.application.services.comparison_service import ComparisonService
+from arena.application.services.history_export_service import HistoryExportService
 from arena.application.services.history_service import HistoryService
 from arena.application.services.provider_config_service import ProviderConfigService
 from arena.forms import CatalogModelForm, ModelRefreshForm, PromptInputForm, ProviderCredentialForm
@@ -24,6 +26,7 @@ from arena.models import PromptRun, ProviderCredential
 catalog_service = CatalogService()
 comparison_service = ComparisonService()
 history_service = HistoryService()
+history_export_service = HistoryExportService()
 provider_config_service = ProviderConfigService()
 logger = logging.getLogger("arena.views")
 
@@ -92,6 +95,18 @@ def _masked_token_preview(token: str) -> str:
     return f"{cleaned[:4]}...{cleaned[-4:]}"
 
 
+def _excel_download_response(content: bytes, file_prefix: str) -> HttpResponse:
+    timestamp = timezone.localtime().strftime("%Y%m%d_%H%M%S")
+    response = HttpResponse(
+        content,
+        content_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    )
+    response["Content-Disposition"] = (
+        f'attachment; filename="{file_prefix}_{timestamp}.xlsx"'
+    )
+    return response
+
+
 @login_required
 def index_view(request):
     catalog_service.ensure_seed_models()
@@ -202,6 +217,30 @@ def history_detail_view(request, run_id: int):
     return render(request, "arena/history_detail.html", context)
 
 
+@login_required
+def history_export_all_excel_view(request):
+    runs = history_service.list_runs().prefetch_related("responses")
+    workbook_content = history_export_service.build_all_runs_workbook(
+        runs=runs,
+        provider_labeler=catalog_service.provider_label,
+    )
+    return _excel_download_response(workbook_content, "tum_gecmis_detay")
+
+
+@login_required
+def history_export_run_excel_view(request, run_id: int):
+    try:
+        run = history_service.get_run(run_id)
+    except PromptRun.DoesNotExist as exc:
+        raise Http404("Kayit bulunamadi.") from exc
+
+    workbook_content = history_export_service.build_run_workbook(
+        run=run,
+        provider_labeler=catalog_service.provider_label,
+    )
+    return _excel_download_response(workbook_content, f"kayit_{run_id}_detay")
+
+
 @login_required
 def catalog_view(request):
     catalog_service.ensure_seed_models()

requirements.txt

@@ -7,3 +7,4 @@ langchain-openai==0.2.14
 langchain-anthropic==0.3.7
 langchain-google-genai==2.1.8
 langchain-ollama==0.2.3
+openpyxl==3.1.5